plugins/dfsound/pulseaudio.c

   1 /***************************************************************************
   2                 pulseaudio.c  -  description
   3                      -------------------
   4 begin                : Thu Feb 04 2010
   5 copyright            : (C) 2010 by Tristin Celestin
   6 email                : cetris1@umbc.edu
   7 comment              : Much of this was taken from simple.c, in the pulseaudio
   8                        library
   9 ***************************************************************************/
  10 /***************************************************************************
  11  *                                                                         *
  12  *   This program is free software; you can redistribute it and/or modify  *
  13  *   it under the terms of the GNU General Public License as published by  *
  14  *   the Free Software Foundation; either version 2 of the License, or     *
  15  *   (at your option) any later version. See also the license.txt file for *
  16  *   additional informations.                                              *
  17  *                                                                         *
  18  ***************************************************************************/
  19
  20 #include <stdio.h>
  21
  22 #include <pulse/pulseaudio.h>
  23 #include "out.h"
  24
  25 ////////////////////////////////////////////////////////////////////////
  26 // pulseaudio structs
  27 ////////////////////////////////////////////////////////////////////////
  28
  29 typedef struct {
  30      pa_threaded_mainloop *mainloop;
  31      pa_context *context;
  32      pa_mainloop_api *api;
  33      pa_stream *stream;
  34      pa_sample_spec spec;
  35      int first;
  36 } Device;
  37
  38 typedef struct {
  39      unsigned int frequency;
  40      unsigned int latency_in_msec;
  41 } Settings;
  42
  43 ////////////////////////////////////////////////////////////////////////
  44 // pulseaudio globals
  45 ////////////////////////////////////////////////////////////////////////
  46
  47 static Device device = {
  48      .mainloop = NULL,
  49      .api = NULL,
  50      .context = NULL,
  51      .stream = NULL
  52 };
  53
  54 static Settings settings = {
  55      .frequency = 44100,
  56      .latency_in_msec = 20,
  57 };
  58
  59 // the number of bytes written in SoundFeedStreamData
  60 const int mixlen = 3240;
  61
  62 // used to calculate how much space is used in the buffer, for debugging purposes
  63 //int maxlength = 0;
  64
  65 ////////////////////////////////////////////////////////////////////////
  66 // CALLBACKS FOR THREADED MAINLOOP
  67 ////////////////////////////////////////////////////////////////////////
  68 static void context_state_cb (pa_context *context, void *userdata)
  69 {
  70      Device *dev = userdata;
  71
  72      if ((context == NULL) || (dev == NULL))
  73           return;
  74
  75      switch (pa_context_get_state (context))
  76      {
  77      case PA_CONTEXT_READY:
  78      case PA_CONTEXT_TERMINATED:
  79      case PA_CONTEXT_FAILED:
  80           pa_threaded_mainloop_signal (dev->mainloop, 0);
  81           break;
  82
  83      case PA_CONTEXT_UNCONNECTED:
  84      case PA_CONTEXT_CONNECTING:
  85      case PA_CONTEXT_AUTHORIZING:
  86      case PA_CONTEXT_SETTING_NAME:
  87           break;
  88      }
  89 }
  90
  91 static void stream_state_cb (pa_stream *stream, void * userdata)
  92 {
  93      Device *dev = userdata;
  94
  95      if ((stream == NULL) || (dev == NULL))
  96           return;
  97
  98      switch (pa_stream_get_state (stream))
  99      {
 100      case PA_STREAM_READY:
 101      case PA_STREAM_FAILED:
 102      case PA_STREAM_TERMINATED:
 103           pa_threaded_mainloop_signal (dev->mainloop, 0);
 104           break;
 105
 106      case PA_STREAM_UNCONNECTED:
 107      case PA_STREAM_CREATING:
 108           break;
 109      }
 110 }
 111
 112 static void stream_latency_update_cb (pa_stream *stream, void *userdata)
 113 {
 114      Device *dev = userdata;
 115
 116      if ((stream == NULL) || (dev == NULL))
 117           return;
 118
 119      pa_threaded_mainloop_signal (dev->mainloop, 0);
 120 }
 121
 122 static void stream_request_cb (pa_stream *stream, size_t length, void *userdata)
 123 {
 124      Device *dev = userdata;
 125
 126      if ((stream == NULL) || (dev == NULL))
 127           return;
 128      pa_threaded_mainloop_signal (dev->mainloop, 0);
 129 }
 130
 131 ////////////////////////////////////////////////////////////////////////
 132 // SETUP SOUND
 133 ////////////////////////////////////////////////////////////////////////
 134
 135 static int pulse_init(void)
 136 {
 137      int error_number;
 138
 139      // Acquire mainloop ///////////////////////////////////////////////////////
 140      device.mainloop = pa_threaded_mainloop_new ();
 141      if (device.mainloop == NULL)
 142      {
 143           fprintf (stderr, "Could not acquire PulseAudio main loop\n");
 144           return -1;
 145      }
 146
 147      // Acquire context ////////////////////////////////////////////////////////
 148      device.api = pa_threaded_mainloop_get_api (device.mainloop);
 149      device.context = pa_context_new (device.api, "PCSX");
 150      pa_context_set_state_callback (device.context, context_state_cb, &device);
 151
 152      if (device.context == NULL)
 153      {
 154           fprintf (stderr, "Could not acquire PulseAudio device context\n");
 155           return -1;
 156      }
 157
 158      // Connect to PulseAudio server ///////////////////////////////////////////
 159      if (pa_context_connect (device.context, NULL, 0, NULL) < 0)
 160      {
 161           error_number = pa_context_errno (device.context);
 162           fprintf (stderr, "Could not connect to PulseAudio server: %s\n", pa_strerror(error_number));
 163           return -1;
 164      }
 165
 166      // Run mainloop until sever context is ready //////////////////////////////
 167      pa_threaded_mainloop_lock (device.mainloop);
 168      if (pa_threaded_mainloop_start (device.mainloop) < 0)
 169      {
 170           fprintf (stderr, "Could not start mainloop\n");
 171           return -1;
 172      }
 173
 174      pa_context_state_t context_state;
 175      context_state = pa_context_get_state (device.context);
 176      while (context_state != PA_CONTEXT_READY)
 177      {
 178           context_state = pa_context_get_state (device.context);
 179           if (! PA_CONTEXT_IS_GOOD (context_state))
 180           {
 181                error_number = pa_context_errno (device.context);
 182                fprintf (stderr, "Context state is not good: %s\n", pa_strerror (error_number));
 183                return -1;
 184           }
 185           else if (context_state == PA_CONTEXT_READY)
 186                break;
 187           else
 188                fprintf (stderr, "PulseAudio context state is %d\n", context_state);
 189           pa_threaded_mainloop_wait (device.mainloop);
 190      }
 191
 192      // Set sample spec ////////////////////////////////////////////////////////
 193      device.spec.format = PA_SAMPLE_S16NE;
 194      device.spec.channels = 2;
 195      device.spec.rate = settings.frequency;
 196
 197      pa_buffer_attr buffer_attributes;
 198      buffer_attributes.tlength = pa_bytes_per_second (& device.spec) / 5;
 199      buffer_attributes.maxlength = buffer_attributes.tlength * 3;
 200      buffer_attributes.minreq = buffer_attributes.tlength / 3;
 201      buffer_attributes.prebuf = buffer_attributes.tlength;
 202
 203      //maxlength = buffer_attributes.maxlength;
 204      //fprintf (stderr, "Total space: %u\n", buffer_attributes.maxlength);
 205      //fprintf (stderr, "Minimum request size: %u\n", buffer_attributes.minreq);
 206      //fprintf (stderr, "Bytes needed before playback: %u\n", buffer_attributes.prebuf);
 207      //fprintf (stderr, "Target buffer size: %lu\n", buffer_attributes.tlength);
 208
 209      // Acquire new stream using spec //////////////////////////////////////////
 210      device.stream = pa_stream_new (device.context, "PCSX", &device.spec, NULL);
 211      if (device.stream == NULL)
 212      {
 213           error_number = pa_context_errno (device.context);
 214           fprintf (stderr, "Could not acquire new PulseAudio stream: %s\n", pa_strerror (error_number));
 215           return -1;
 216      }
 217
 218      // Set callbacks for server events ////////////////////////////////////////
 219      pa_stream_set_state_callback (device.stream, stream_state_cb, &device);
 220      pa_stream_set_write_callback (device.stream, stream_request_cb, &device);
 221      pa_stream_set_latency_update_callback (device.stream, stream_latency_update_cb, &device);
 222
 223      // Ready stream for playback //////////////////////////////////////////////
 224      pa_stream_flags_t flags = (pa_stream_flags_t) (PA_STREAM_ADJUST_LATENCY | PA_STREAM_INTERPOLATE_TIMING | PA_STREAM_AUTO_TIMING_UPDATE);
 225      //pa_stream_flags_t flags = (pa_stream_flags_t) (PA_STREAM_INTERPOLATE_TIMING | PA_STREAM_AUTO_TIMING_UPDATE | PA_STREAM_EARLY_REQUESTS);
 226      if (pa_stream_connect_playback (device.stream, NULL, &buffer_attributes, flags, NULL, NULL) < 0)
 227      {
 228           error_number = pa_context_errno (device.context);
 229           fprintf (stderr, "Could not connect for playback: %s\n", pa_strerror (error_number));
 230           return -1;
 231      }
 232
 233      // Run mainloop until stream is ready /////////////////////////////////////
 234      pa_stream_state_t stream_state;
 235      stream_state = pa_stream_get_state (device.stream);
 236      while (stream_state != PA_STREAM_READY)
 237      {
 238           stream_state = pa_stream_get_state (device.stream);
 239
 240           if (stream_state == PA_STREAM_READY)
 241                break;
 242
 243           else if (! PA_STREAM_IS_GOOD (stream_state))
 244           {
 245                error_number = pa_context_errno (device.context);
 246                fprintf (stderr, "Stream state is not good: %s\n", pa_strerror (error_number));
 247                return -1;
 248           }
 249           else
 250                fprintf (stderr, "PulseAudio stream state is %d\n", stream_state);
 251           pa_threaded_mainloop_wait (device.mainloop);
 252      }
 253
 254      pa_threaded_mainloop_unlock (device.mainloop);
 255
 256      fprintf  (stderr, "PulseAudio should be connected\n");
 257      return 0;
 258 }
 259
 260 ////////////////////////////////////////////////////////////////////////
 261 // REMOVE SOUND
 262 ////////////////////////////////////////////////////////////////////////
 263 static void pulse_finish(void)
 264 {
 265      if (device.mainloop != NULL)
 266           pa_threaded_mainloop_stop (device.mainloop);
 267
 268      // Release in reverse order of acquisition
 269      if (device.stream != NULL)
 270      {
 271           pa_stream_unref (device.stream);
 272           device.stream = NULL;
 273
 274      }
 275      if (device.context != NULL)
 276      {
 277           pa_context_disconnect (device.context);
 278           pa_context_unref (device.context);
 279           device.context = NULL;
 280      }
 281
 282      if (device.mainloop != NULL)
 283      {
 284           pa_threaded_mainloop_free (device.mainloop);
 285           device.mainloop = NULL;
 286      }
 287
 288 }
 289
 290 ////////////////////////////////////////////////////////////////////////
 291 // GET BYTES BUFFERED
 292 ////////////////////////////////////////////////////////////////////////
 293
 294 static int pulse_busy(void)
 295 {
 296      int free_space;
 297
 298      if ((device.mainloop == NULL) || (device.api == NULL) || ( device.context == NULL) || (device.stream == NULL))
 299           return 1;
 300
 301      pa_threaded_mainloop_lock (device.mainloop);
 302      free_space = pa_stream_writable_size (device.stream);
 303      pa_threaded_mainloop_unlock (device.mainloop);
 304
 305      //fprintf (stderr, "Free space: %d\n", free_space);
 306      //fprintf (stderr, "Used space: %d\n", maxlength - free_space);
 307      if  (free_space < mixlen * 3)
 308      {
 309           // Don't buffer anymore, just play
 310           //fprintf (stderr, "Not buffering.\n");
 311           return 1;
 312      }
 313      else
 314      {
 315           // Buffer some sound
 316           //fprintf (stderr, "Buffering.\n");
 317           return 0;
 318      }
 319 }
 320
 321 ////////////////////////////////////////////////////////////////////////
 322 // FEED SOUND DATA
 323 ////////////////////////////////////////////////////////////////////////
 324
 325 static void pulse_feed(void *pSound, int lBytes)
 326 {
 327      if (device.mainloop != NULL)
 328      {
 329           pa_threaded_mainloop_lock (device.mainloop);
 330           if (pa_stream_write (device.stream, pSound, lBytes, NULL, 0LL, PA_SEEK_RELATIVE) < 0)
 331           {
 332                fprintf (stderr, "Could not perform write\n");
 333           }
 334           else
 335           {
 336                //fprintf (stderr, "Wrote %d bytes\n", lBytes);
 337                pa_threaded_mainloop_unlock (device.mainloop);
 338           }
 339      }
 340 }
 341
 342 void out_register_pulse(struct out_driver *drv)
 343 {
 344         drv->name = "pulseaudio";
 345         drv->init = pulse_init;
 346         drv->finish = pulse_finish;
 347         drv->busy = pulse_busy;
 348         drv->feed = pulse_feed;
 349 }