Merge branch 'master' of git.distorted.org.uk:~mdw/publish/public-git/disorder

[disorder] / lib / uaudio-pulseaudio.c

diff --git a/lib/uaudio-pulseaudio.c b/lib/uaudio-pulseaudio.c
index f0124be08789fcebad9f2ef47f5f26ea0dc507df..c7a823f6a1ea626c58cbd726bf25f78a2d95f156 100644 (file)
--- a/lib/uaudio-pulseaudio.c
+++ b/lib/uaudio-pulseaudio.c
@@ -1,6 +1,6 @@
 /*
  * This file is part of DisOrder.
 /*
  * This file is part of DisOrder.

- * Copyright (C) 2013 Richard Kettlewell
+ * Copyright (C) 2013 Richard Kettlewell, 2018 Mark Wooding

  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by


@@ -21,8 +21,11 @@
 
 #if HAVE_PULSEAUDIO
 
 
 #if HAVE_PULSEAUDIO
 

-#include <pulse/simple.h>
+#include <pulse/context.h>

 #include <pulse/error.h>
 #include <pulse/error.h>

+#include <pulse/introspect.h>
+#include <pulse/thread-mainloop.h>
+#include <pulse/stream.h>

 
 #include "mem.h"
 #include "log.h"
 
 #include "mem.h"
 #include "log.h"


@@ -34,61 +37,145 @@ static const char *const pulseaudio_options[] = {
   NULL
 };
 
   NULL
 };
 

-static pa_simple *pulseaudio_simple_handle;
+static pa_threaded_mainloop *loop;
+static pa_context *ctx;
+static pa_stream *str;
+static pa_channel_map cmap;
+static uint32_t strix;
+
+#define PAERRSTR pa_strerror(pa_context_errno(ctx))
+
+/** @brief Callback: wake up main loop when the context is ready. */
+static void cb_ctxstate(attribute((unused)) pa_context *xctx,
+                        attribute((unused)) void *p) {
+  pa_context_state_t st = pa_context_get_state(ctx);
+  switch(st) {
+  case PA_CONTEXT_READY:
+    pa_threaded_mainloop_signal(loop, 0);
+    break;
+  default:
+    if(!PA_CONTEXT_IS_GOOD(st))
+      disorder_fatal(0, "pulseaudio failed: %s", PAERRSTR);
+  }
+}
+
+/** @brief Callback: wake up main loop when the stream is ready. */
+static void cb_strstate(attribute((unused)) pa_stream *xstr,
+                        attribute((unused)) void *p) {
+  pa_stream_state_t st = pa_stream_get_state(str);
+  switch(st) {
+  case PA_STREAM_READY:
+    pa_threaded_mainloop_signal(loop, 0);
+    break;
+  default:
+    if(!PA_STREAM_IS_GOOD(st))
+      disorder_fatal(0, "pulseaudio failed: %s", PAERRSTR);
+  }
+}
+
+/** @brief Callback: wake up main loop when there's output buffer space. */
+static void cb_wakeup(attribute((unused)) pa_stream *xstr,
+                      attribute((unused)) size_t sz,
+                      attribute((unused)) void *p)
+  { pa_threaded_mainloop_signal(loop, 0); }
+
+struct simpleop {
+  const char *what;
+  int donep;
+};
+
+/** @brief Callback: wake up main loop when a simple operation completes. */
+static void cb_success(attribute((unused)) pa_context *xctx,
+                       int winp, void *p) {
+  struct simpleop *sop = p;
+  if(!winp) disorder_fatal(0, "%s failed: %s", sop->what, PAERRSTR);
+  sop->donep = 1; pa_threaded_mainloop_signal(loop, 0);
+}

 
 /** @brief Open the PulseAudio sound device */
 static void pulseaudio_open() {
 
 /** @brief Open the PulseAudio sound device */
 static void pulseaudio_open() {

+  /* Much of the following is cribbed from the PulseAudio `simple' source. */
+

   pa_sample_spec ss;
   pa_sample_spec ss;

-  int error;
+
+  /* Set up the sample format. */

   ss.format = -1;
   switch(uaudio_bits) {
   ss.format = -1;
   switch(uaudio_bits) {

-  case 8:
-    if(!uaudio_signed)
-      ss.format = PA_SAMPLE_U8;
-    break;
-  case 16:
-    if(uaudio_signed)
-      ss.format = PA_SAMPLE_S16NE;
-    break;
-  case 32:
-    if(uaudio_signed)
-      ss.format = PA_SAMPLE_S32NE;
-    break;
+  case 8: if(!uaudio_signed) ss.format = PA_SAMPLE_U8; break;
+  case 16: if(uaudio_signed) ss.format = PA_SAMPLE_S16NE; break;
+  case 32: if(uaudio_signed) ss.format = PA_SAMPLE_S32NE; break;

   }
   if(ss.format == -1)
     disorder_fatal(0, "unsupported uaudio format (%d, %d)",
                    uaudio_bits, uaudio_signed);
   ss.channels = uaudio_channels;
   ss.rate = uaudio_rate;
   }
   if(ss.format == -1)
     disorder_fatal(0, "unsupported uaudio format (%d, %d)",
                    uaudio_bits, uaudio_signed);
   ss.channels = uaudio_channels;
   ss.rate = uaudio_rate;

-  pulseaudio_simple_handle = pa_simple_new(NULL,
-                                           uaudio_get("application", "DisOrder"),
-                                           PA_STREAM_PLAYBACK,
-                                           NULL,
-                                           "DisOrder",
-                                           &ss,
-                                           NULL,
-                                           NULL,
-                                           &error);
-  if(!pulseaudio_simple_handle)
-    disorder_fatal(0, "pa_simple_new: %s", pa_strerror(error));
+
+  /* Create the random PulseAudio pieces. */
+  loop = pa_threaded_mainloop_new();
+  if(!loop) disorder_fatal(0, "failed to create pulseaudio main loop");
+  pa_threaded_mainloop_lock(loop);
+  ctx = pa_context_new(pa_threaded_mainloop_get_api(loop),
+                       uaudio_get("application", "DisOrder"));
+  if(!ctx) disorder_fatal(0, "failed to create pulseaudio context");
+  pa_context_set_state_callback(ctx, cb_ctxstate, 0);
+  if(pa_context_connect(ctx, 0, 0, 0) < 0)
+    disorder_fatal(0, "failed to connect to pulseaudio server: %s",
+                   PAERRSTR);
+
+  /* Set the main loop going. */
+  if(pa_threaded_mainloop_start(loop) < 0)
+    disorder_fatal(0, "failed to start pulseaudio main loop");
+  while(pa_context_get_state(ctx) != PA_CONTEXT_READY)
+    pa_threaded_mainloop_wait(loop);
+
+  /* Set up my stream. */
+  str = pa_stream_new(ctx, "DisOrder", &ss, 0);
+  if(!str)
+    disorder_fatal(0, "failed to create pulseaudio stream: %s", PAERRSTR);
+  pa_stream_set_write_callback(str, cb_wakeup, 0);
+  if(pa_stream_connect_playback(str, 0, 0,
+                                PA_STREAM_ADJUST_LATENCY,
+                                0, 0))
+    disorder_fatal(0, "failed to connect pulseaudio stream for playback: %s",
+                   PAERRSTR);
+  pa_stream_set_state_callback(str, cb_strstate, 0);
+
+  /* Wait until the stream is ready. */
+  while(pa_stream_get_state(str) != PA_STREAM_READY)
+    pa_threaded_mainloop_wait(loop);
+
+  /* All done. */
+  strix = pa_stream_get_index(str);
+  pa_threaded_mainloop_unlock(loop);

 }
 
 /** @brief Close the PulseAudio sound device */
 static void pulseaudio_close(void) {
 }
 
 /** @brief Close the PulseAudio sound device */
 static void pulseaudio_close(void) {

-  pa_simple_free(pulseaudio_simple_handle);
-  pulseaudio_simple_handle = NULL;
+  if(loop) pa_threaded_mainloop_stop(loop);
+  if(str) { pa_stream_unref(str); str = 0; }
+  if(ctx) { pa_context_disconnect(ctx); pa_context_unref(ctx); ctx = 0; }
+  if(loop) { pa_threaded_mainloop_free(loop); loop = 0; }

 }
 
 /** @brief Actually play sound via PulseAudio */
 static size_t pulseaudio_play(void *buffer, size_t samples,
 }
 
 /** @brief Actually play sound via PulseAudio */
 static size_t pulseaudio_play(void *buffer, size_t samples,

-                              unsigned attribute((unused)) flags) {
-  int error;
-  int ret = pa_simple_write(pulseaudio_simple_handle,
-                            buffer,
-                            samples * uaudio_sample_size,
-                            &error);
-  if(ret < 0)
-    disorder_fatal(0, "pa_simple_write: %s", pa_strerror(error));
+                              attribute((unused)) unsigned flags) {
+  unsigned char *p = buffer;
+  size_t n, sz = samples*uaudio_sample_size;
+
+  pa_threaded_mainloop_lock(loop);
+  while(sz) {
+
+    /* Wait until some output space becomes available. */
+    while(!(n = pa_stream_writable_size(str)))
+      pa_threaded_mainloop_wait(loop);
+    if(n > sz) n = sz;
+    if(pa_stream_write(str, p, n, 0, 0, PA_SEEK_RELATIVE) < 0)
+      disorder_fatal(0, "failed to write pulseaudio data: %s", PAERRSTR);
+    p += n; sz -= n;
+  }
+  pa_threaded_mainloop_unlock(loop);

   return samples;
 }
 
   return samples;
 }
 


@@ -107,18 +194,89 @@ static void pulseaudio_stop(void) {
 }
 
 static void pulseaudio_open_mixer(void) {
 }
 
 static void pulseaudio_open_mixer(void) {

-  disorder_error(0, "no pulseaudio mixer support yet");
+  if(!str)
+    disorder_fatal(0, "won't open pulseaudio mixer with no stream open");
+  switch(uaudio_channels) {
+  case 1: pa_channel_map_init_mono(&cmap); break;
+  case 2: pa_channel_map_init_stereo(&cmap); break;
+  default: disorder_error(0, "no pulseaudio mixer support for %d channels",
+                          uaudio_channels);
+  }

 }
 
 static void pulseaudio_close_mixer(void) {
 }
 
 }
 
 static void pulseaudio_close_mixer(void) {
 }
 

+struct getvol {
+  pa_cvolume vol;
+  int donep;
+};
+
+/** @brief Callback: pick out our stream's volume. */
+static void cb_getvol(attribute((unused)) pa_context *xctx,
+                      const pa_sink_input_info *info, int flag, void *p) {
+  struct getvol *gv = p;
+
+  if(flag < 0)
+    disorder_fatal(0, "failed to read own pulseaudio sink-input volume: %s",
+                   PAERRSTR);
+  else if(!flag) {
+    gv->vol = info->volume;
+    gv->donep = -1;
+  } else if (!gv->donep)
+    disorder_fatal(0, "no answer reading own pulseaudio sink-input volume");
+  else {
+    gv->donep = 1;
+    pa_threaded_mainloop_signal(loop, 0);
+  }
+}
+

 static void pulseaudio_get_volume(int *left, int *right) {
 static void pulseaudio_get_volume(int *left, int *right) {

-  *left = *right = 0;
+  pa_operation *op;
+  struct getvol gv;
+  double l, r;
+
+  pa_threaded_mainloop_lock(loop);
+  gv.donep = 0;
+  op = pa_context_get_sink_input_info(ctx, strix, cb_getvol, &gv);
+  while(gv.donep <= 0) pa_threaded_mainloop_wait(loop);
+  pa_threaded_mainloop_unlock(loop);
+  pa_operation_unref(op);
+
+  switch(uaudio_channels) {
+  case 1: l = r = gv.vol.values[0]; break;
+  case 2: l = gv.vol.values[0]; r = gv.vol.values[1]; break;
+  default: l = r = 0; break;
+  }
+
+  *left = 100.0*l/PA_VOLUME_NORM + 0.5;
+  *right = 100.0*r/PA_VOLUME_NORM + 0.5;

 }
 
 static void pulseaudio_set_volume(int *left, int *right) {
 }
 
 static void pulseaudio_set_volume(int *left, int *right) {

-  *left = *right = 0;
+  pa_operation *op;
+  struct simpleop sop;
+  pa_cvolume vol;
+  double r, l;
+
+  l = *left*PA_VOLUME_NORM/100.0 + 0.5;
+  r = *right*PA_VOLUME_NORM/100.0 + 0.5;
+
+  pa_cvolume_init(&vol); vol.channels = uaudio_channels;
+  switch(uaudio_channels) {
+  case 1: if(r < l) r = l; vol.values[0] = vol.values[1] = r; break;
+  case 2: vol.values[0] = l; vol.values[1] = r; break;
+  default: return;
+  }
+
+  pa_threaded_mainloop_lock(loop);
+  sop.what = "set pulseaudio volume"; sop.donep = 0;
+  op = pa_context_set_sink_input_volume(ctx, strix, &vol, cb_success, &sop);
+  while(!sop.donep) pa_threaded_mainloop_wait(loop);
+  pa_threaded_mainloop_unlock(loop);
+  pa_operation_unref(op);
+
+  pulseaudio_get_volume(left, right);

 }
 
 static void pulseaudio_configure(void) {
 }
 
 static void pulseaudio_configure(void) {