libao2/ao_pulse.c

   1 /*
   2  * PulseAudio audio output driver.
   3  * Copyright (C) 2006 Lennart Poettering
   4  * Copyright (C) 2007 Reimar Doeffinger
   5  *
   6  * This file is part of MPlayer.
   7  *
   8  * MPlayer 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  * MPlayer 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 MPlayer; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22 #include <string.h>
  23
  24 #include <pulse/pulseaudio.h>
  25
  26 #include "config.h"
  27 #include "libaf/af_format.h"
  28 #include "mp_msg.h"
  29 #include "audio_out.h"
  30 #include "audio_out_internal.h"
  31
  32 #define PULSE_CLIENT_NAME "MPlayer"
  33
  34 /** General driver info */
  35 static ao_info_t info = {
  36     "PulseAudio audio output",
  37     "pulse",
  38     "Lennart Poettering",
  39     ""
  40 };
  41
  42 /** PulseAudio playback stream object */
  43 static struct pa_stream *stream;
  44
  45 /** PulseAudio connection context */
  46 static struct pa_context *context;
  47
  48 /** Main event loop object */
  49 static struct pa_threaded_mainloop *mainloop;
  50
  51 /** A temporary variable to store the current volume */
  52 static pa_cvolume volume;
  53
  54 LIBAO_EXTERN(pulse)
  55
  56 #define GENERIC_ERR_MSG(ctx, str) \
  57     mp_msg(MSGT_AO, MSGL_ERR, "AO: [pulse] "str": %s\n", \
  58     pa_strerror(pa_context_errno(ctx)))
  59
  60 static void context_state_cb(pa_context *c, void *userdata) {
  61     switch (pa_context_get_state(c)) {
  62         case PA_CONTEXT_READY:
  63         case PA_CONTEXT_TERMINATED:
  64         case PA_CONTEXT_FAILED:
  65             pa_threaded_mainloop_signal(mainloop, 0);
  66             break;
  67     }
  68 }
  69
  70 static void stream_state_cb(pa_stream *s, void *userdata) {
  71     switch (pa_stream_get_state(s)) {
  72         case PA_STREAM_READY:
  73         case PA_STREAM_FAILED:
  74         case PA_STREAM_TERMINATED:
  75             pa_threaded_mainloop_signal(mainloop, 0);
  76             break;
  77     }
  78 }
  79
  80 static void stream_request_cb(pa_stream *s, size_t length, void *userdata) {
  81     pa_threaded_mainloop_signal(mainloop, 0);
  82 }
  83
  84 static void stream_latency_update_cb(pa_stream *s, void *userdata) {
  85     pa_threaded_mainloop_signal(mainloop, 0);
  86 }
  87
  88 static void success_cb(pa_stream *s, int success, void *userdata) {
  89     if (userdata)
  90         *(int *)userdata = success;
  91     pa_threaded_mainloop_signal(mainloop, 0);
  92 }
  93
  94 /**
  95  * \brief waits for a pulseaudio operation to finish, frees it and
  96  *        unlocks the mainloop
  97  * \param op operation to wait for
  98  * \return 1 if operation has finished normally (DONE state), 0 otherwise
  99  */
 100 static int waitop(pa_operation *op) {
 101     pa_operation_state_t state;
 102     if (!op) return 0;
 103     state = pa_operation_get_state(op);
 104     while (state == PA_OPERATION_RUNNING) {
 105         pa_threaded_mainloop_wait(mainloop);
 106         state = pa_operation_get_state(op);
 107     }
 108     pa_operation_unref(op);
 109     pa_threaded_mainloop_unlock(mainloop);
 110     return state == PA_OPERATION_DONE;
 111 }
 112
 113 static const struct format_map_s {
 114     int mp_format;
 115     pa_sample_format_t pa_format;
 116 } format_maps[] = {
 117     {AF_FORMAT_U8, PA_SAMPLE_U8},
 118     {AF_FORMAT_S16_LE, PA_SAMPLE_S16LE},
 119     {AF_FORMAT_S16_BE, PA_SAMPLE_S16BE},
 120     {AF_FORMAT_FLOAT_LE, PA_SAMPLE_FLOAT32LE},
 121     {AF_FORMAT_FLOAT_BE, PA_SAMPLE_FLOAT32BE},
 122     {AF_FORMAT_MU_LAW, PA_SAMPLE_ULAW},
 123     {AF_FORMAT_A_LAW, PA_SAMPLE_ALAW},
 124     {AF_FORMAT_UNKNOWN, 0}
 125 };
 126
 127 static int init(int rate_hz, int channels, int format, int flags) {
 128     struct pa_sample_spec ss;
 129     struct pa_channel_map map;
 130     const struct format_map_s *fmt_map;
 131     char *devarg = NULL;
 132     char *host = NULL;
 133     char *sink = NULL;
 134
 135     if (ao_subdevice) {
 136         devarg = strdup(ao_subdevice);
 137         sink = strchr(devarg, ':');
 138         if (sink) *sink++ = 0;
 139         if (devarg[0]) host = devarg;
 140     }
 141
 142     ss.channels = channels;
 143     ss.rate = rate_hz;
 144
 145     ao_data.samplerate = rate_hz;
 146     ao_data.format = format;
 147     ao_data.channels = channels;
 148
 149     fmt_map = format_maps;
 150     while (fmt_map->mp_format != format) {
 151         if (fmt_map->mp_format == AF_FORMAT_UNKNOWN) {
 152             mp_msg(MSGT_AO, MSGL_ERR, "AO: [pulse] Unsupported sample spec\n");
 153             goto fail;
 154         }
 155         fmt_map++;
 156     }
 157     ss.format = fmt_map->pa_format;
 158
 159     if (!pa_sample_spec_valid(&ss)) {
 160         mp_msg(MSGT_AO, MSGL_ERR, "AO: [pulse] Invalid sample spec\n");
 161         goto fail;
 162     }
 163
 164     pa_channel_map_init_auto(&map, ss.channels, PA_CHANNEL_MAP_ALSA);
 165     ao_data.bps = pa_bytes_per_second(&ss);
 166
 167     pa_cvolume_reset(&volume, ss.channels);
 168
 169     if (!(mainloop = pa_threaded_mainloop_new())) {
 170         mp_msg(MSGT_AO, MSGL_ERR, "AO: [pulse] Failed to allocate main loop\n");
 171         goto fail;
 172     }
 173
 174     if (!(context = pa_context_new(pa_threaded_mainloop_get_api(mainloop), PULSE_CLIENT_NAME))) {
 175         mp_msg(MSGT_AO, MSGL_ERR, "AO: [pulse] Failed to allocate context\n");
 176         goto fail;
 177     }
 178
 179     pa_context_set_state_callback(context, context_state_cb, NULL);
 180
 181     if (pa_context_connect(context, host, 0, NULL) < 0)
 182         goto fail;
 183
 184     pa_threaded_mainloop_lock(mainloop);
 185
 186     if (pa_threaded_mainloop_start(mainloop) < 0)
 187         goto unlock_and_fail;
 188
 189     /* Wait until the context is ready */
 190     pa_threaded_mainloop_wait(mainloop);
 191
 192     if (pa_context_get_state(context) != PA_CONTEXT_READY)
 193         goto unlock_and_fail;
 194
 195     if (!(stream = pa_stream_new(context, "audio stream", &ss, &map)))
 196         goto unlock_and_fail;
 197
 198     pa_stream_set_state_callback(stream, stream_state_cb, NULL);
 199     pa_stream_set_write_callback(stream, stream_request_cb, NULL);
 200     pa_stream_set_latency_update_callback(stream, stream_latency_update_cb, NULL);
 201
 202     if (pa_stream_connect_playback(stream, sink, NULL, PA_STREAM_INTERPOLATE_TIMING|PA_STREAM_AUTO_TIMING_UPDATE, &volume, NULL) < 0)
 203         goto unlock_and_fail;
 204
 205     /* Wait until the stream is ready */
 206     pa_threaded_mainloop_wait(mainloop);
 207
 208     if (pa_stream_get_state(stream) != PA_STREAM_READY)
 209         goto unlock_and_fail;
 210
 211     pa_threaded_mainloop_unlock(mainloop);
 212
 213     free(devarg);
 214     return 1;
 215
 216 unlock_and_fail:
 217
 218     if (mainloop)
 219         pa_threaded_mainloop_unlock(mainloop);
 220
 221 fail:
 222     if (context)
 223         GENERIC_ERR_MSG(context, "Init failed");
 224     free(devarg);
 225     uninit(1);
 226     return 0;
 227 }
 228
 229 /** Destroy libao driver */
 230 static void uninit(int immed) {
 231     if (stream && !immed) {
 232             pa_threaded_mainloop_lock(mainloop);
 233             waitop(pa_stream_drain(stream, success_cb, NULL));
 234     }
 235
 236     if (mainloop)
 237         pa_threaded_mainloop_stop(mainloop);
 238
 239     if (stream) {
 240         pa_stream_disconnect(stream);
 241         pa_stream_unref(stream);
 242         stream = NULL;
 243     }
 244
 245     if (context) {
 246         pa_context_disconnect(context);
 247         pa_context_unref(context);
 248         context = NULL;
 249     }
 250
 251     if (mainloop) {
 252         pa_threaded_mainloop_free(mainloop);
 253         mainloop = NULL;
 254     }
 255 }
 256
 257 /** Play the specified data to the pulseaudio server */
 258 static int play(void* data, int len, int flags) {
 259     pa_threaded_mainloop_lock(mainloop);
 260     if (pa_stream_write(stream, data, len, NULL, 0, PA_SEEK_RELATIVE) < 0) {
 261         GENERIC_ERR_MSG(context, "pa_stream_write() failed");
 262         len = -1;
 263     }
 264     pa_threaded_mainloop_unlock(mainloop);
 265     return len;
 266 }
 267
 268 static void cork(int b) {
 269     int success = 0;
 270     pa_threaded_mainloop_lock(mainloop);
 271     if (!waitop(pa_stream_cork(stream, b, success_cb, &success)) ||
 272         !success)
 273         GENERIC_ERR_MSG(context, "pa_stream_cork() failed");
 274 }
 275
 276 /** Pause the audio stream by corking it on the server */
 277 static void audio_pause(void) {
 278     cork(1);
 279 }
 280
 281 /** Resume the audio stream by uncorking it on the server */
 282 static void audio_resume(void) {
 283     cork(0);
 284 }
 285
 286 /** Reset the audio stream, i.e. flush the playback buffer on the server side */
 287 static void reset(void) {
 288     int success = 0;
 289     pa_threaded_mainloop_lock(mainloop);
 290     if (!waitop(pa_stream_flush(stream, success_cb, &success)) ||
 291         !success)
 292         GENERIC_ERR_MSG(context, "pa_stream_flush() failed");
 293 }
 294
 295 /** Return number of bytes that may be written to the server without blocking */
 296 static int get_space(void) {
 297     size_t l;
 298     pa_threaded_mainloop_lock(mainloop);
 299     l = pa_stream_writable_size(stream);
 300     pa_threaded_mainloop_unlock(mainloop);
 301     return l;
 302 }
 303
 304 /** Return the current latency in seconds */
 305 static float get_delay(void) {
 306     pa_usec_t latency = (pa_usec_t) -1;
 307     pa_threaded_mainloop_lock(mainloop);
 308     while (pa_stream_get_latency(stream, &latency, NULL) < 0) {
 309         if (pa_context_errno(context) != PA_ERR_NODATA) {
 310             GENERIC_ERR_MSG(context, "pa_stream_get_latency() failed");
 311             break;
 312         }
 313         /* Wait until latency data is available again */
 314         pa_threaded_mainloop_wait(mainloop);
 315     }
 316     pa_threaded_mainloop_unlock(mainloop);
 317     return latency == (pa_usec_t) -1 ? 0 : latency / 1000000.0;
 318 }
 319
 320 /** A callback function that is called when the
 321  * pa_context_get_sink_input_info() operation completes. Saves the
 322  * volume field of the specified structure to the global variable volume. */
 323 static void info_func(struct pa_context *c, const struct pa_sink_input_info *i, int is_last, void *userdata) {
 324     if (is_last < 0) {
 325         GENERIC_ERR_MSG(context, "Failed to get sink input info");
 326         return;
 327     }
 328     if (!i)
 329         return;
 330     volume = i->volume;
 331     pa_threaded_mainloop_signal(mainloop, 0);
 332 }
 333
 334 static int control(int cmd, void *arg) {
 335     switch (cmd) {
 336         case AOCONTROL_GET_VOLUME: {
 337             ao_control_vol_t *vol = arg;
 338             uint32_t devidx = pa_stream_get_index(stream);
 339             pa_threaded_mainloop_lock(mainloop);
 340             if (!waitop(pa_context_get_sink_input_info(context, devidx, info_func, NULL))) {
 341                 GENERIC_ERR_MSG(context, "pa_stream_get_sink_input_info() failed");
 342                 return CONTROL_ERROR;
 343             }
 344
 345             if (volume.channels != 2)
 346                 vol->left = vol->right = pa_cvolume_avg(&volume)*100/PA_VOLUME_NORM;
 347             else {
 348                 vol->left = volume.values[0]*100/PA_VOLUME_NORM;
 349                 vol->right = volume.values[1]*100/PA_VOLUME_NORM;
 350             }
 351
 352             return CONTROL_OK;
 353         }
 354
 355         case AOCONTROL_SET_VOLUME: {
 356             const ao_control_vol_t *vol = arg;
 357             pa_operation *o;
 358
 359             if (volume.channels != 2)
 360                 pa_cvolume_set(&volume, volume.channels, (pa_volume_t)vol->left*PA_VOLUME_NORM/100);
 361             else {
 362                 volume.values[0] = (pa_volume_t)vol->left*PA_VOLUME_NORM/100;
 363                 volume.values[1] = (pa_volume_t)vol->right*PA_VOLUME_NORM/100;
 364             }
 365
 366             if (!(o = pa_context_set_sink_input_volume(context, pa_stream_get_index(stream), &volume, NULL, NULL))) {
 367                 GENERIC_ERR_MSG(context, "pa_context_set_sink_input_volume() failed");
 368                 return CONTROL_ERROR;
 369             }
 370             /* We don't wait for completion here */
 371             pa_operation_unref(o);
 372             return CONTROL_OK;
 373         }
 374
 375         default:
 376             return CONTROL_UNKNOWN;
 377     }
 378 }