[outputs] Allow more responsive streaming with configurable output buffer

This allows the user to configure the outputs buffering time. It's a modified
version of PR #1954 by @msolo:

Make the initial start buffer configurable to allow "instant" streaming on
networks/hardware that support it.

The default value for start_buffer_ms is 2000ms, preserving existing behavior.
Values near 250ms work in some setups providing a much more responsive
streaming experience.

Author: ejurgensen

src/conffile.c

@@ -76,6 +76,7 @@ static cfg_opt_t sec_general[] =
     CFG_STR("user_agent", PACKAGE_NAME "/" PACKAGE_VERSION, CFGF_NONE),
     CFG_BOOL("ssl_verifypeer", cfg_true, CFGF_NONE),
     CFG_BOOL("timer_test", cfg_false, CFGF_NONE),
+    CFG_INT("start_buffer_ms", 2000, CFGF_NONE),
     CFG_END()
   };
 

src/misc.c

@@ -1620,6 +1620,21 @@ timespec_add(struct timespec time1, struct timespec time2)
   return result;
 }
 
+struct timespec
+timespec_sub(struct timespec time1, struct timespec time2)
+{
+  struct timespec result;
+
+  result.tv_sec = time1.tv_sec - time2.tv_sec;
+  result.tv_nsec = time1.tv_nsec - time2.tv_nsec;
+  if (result.tv_nsec < 0)
+    {
+      result.tv_sec--;
+      result.tv_nsec += 1000000000L;
+    }
+  return result;
+}
+
 int
 timespec_cmp(struct timespec time1, struct timespec time2)
 {

src/misc.h

@@ -265,6 +265,9 @@ clock_gettime_with_res(clockid_t clock_id, struct timespec *tp, struct timespec
 struct timespec
 timespec_add(struct timespec time1, struct timespec time2);
 
+struct timespec
+timespec_sub(struct timespec time1, struct timespec time2);
+
 int
 timespec_cmp(struct timespec time1, struct timespec time2);
 

src/outputs.c

@@ -38,6 +38,7 @@
 #include "player.h" //TODO remove me when player_pmap is removed again
 #include "worker.h"
 #include "outputs.h"
+#include "conffile.h"
 
 extern struct output_definition output_raop;
 extern struct output_definition output_airplay;
@@ -114,6 +115,7 @@ static struct output_buffer output_buffer;
 
 static struct output_device *outputs_device_list;
 static int outputs_master_volume;
+static uint64_t outputs_buffer_duration_ms;
 
 static struct outputs_callback_register outputs_cb_register[OUTPUTS_MAX_CALLBACKS];
 static struct event *outputs_deferredev;
@@ -614,6 +616,12 @@ outputs_device_get(uint64_t device_id)
   return NULL;
 }
 
+uint64_t
+outputs_buffer_duration_ms_get(void)
+{
+  return outputs_buffer_duration_ms;
+}
+
 /* ----------------------- Called by backend modules ------------------------ */
 
 // Sessions free their sessions themselves, but should not touch the device,
@@ -1299,6 +1307,14 @@ outputs_init(void)
 
   outputs_master_volume = -1;
 
+  // Number of milliseconds the outputs should buffer before starting playback.
+  // This value cannot freely be changed because 1) some Airplay devices ignore
+  // the values we give and stick to 2 seconds, 2) those devices that can handle
+  // different values can only do so within a limited range (maybe max 3 secs)
+  outputs_buffer_duration_ms = cfg_getint(cfg_getsec(cfg, "general"), "start_buffer_ms");
+  if (outputs_buffer_duration_ms != 2000)
+    DPRINTF(E_WARN, L_PLAYER, "Output buffer duration is configured to a non-standard value %" PRIu64 "\n", outputs_buffer_duration_ms);
+
   CHECK_NULL(L_PLAYER, outputs_deferredev = evtimer_new(evbase_player, deferred_cb, NULL));
 
   no_output = 1;

src/outputs.h

@@ -35,12 +35,6 @@
 // as one.
 #define OUTPUTS_MAX_QUALITY_SUBSCRIPTIONS 5
 
-// Number of seconds the outputs should buffer before starting playback. Note
-// this value cannot freely be changed because 1) some Airplay devices ignore
-// the values we give and stick to 2 seconds, 2) those devices that can handle
-// different values can only do so within a limited range (maybe max 3 secs)
-#define OUTPUTS_BUFFER_DURATION 2
-
 // Whether the device should be *displayed* as selected is not given by
 // device->selected, since that means "has the user selected the device",
 // without taking into account whether it is working or available. This macro
@@ -276,6 +270,9 @@ struct output_definition
 struct output_device *
 outputs_device_get(uint64_t device_id);
 
+uint64_t
+outputs_buffer_duration_ms_get(void);
+
 /* ----------------------- Called by backend modules ------------------------ */
 
 int

src/outputs/airplay.c

@@ -202,7 +202,7 @@ struct airplay_extra
 struct airplay_master_session
 {
   struct evbuffer *input_buffer;
-  int input_buffer_samples;
+  uint32_t input_buffer_samples;
 
   // ALAC encoder and buffer for encoded data
   struct encode_ctx *encode_ctx;
@@ -214,14 +214,14 @@ struct airplay_master_session
 
   uint8_t *rawbuf;
   size_t rawbuf_size;
-  int samples_per_packet;
+  uint32_t samples_per_packet;
 
   struct media_quality quality;
 
   // Number of samples that we tell the output to buffer (this will mean that
   // the position that we send in the sync packages are offset by this amount
   // compared to the rtptimes of the corresponding RTP packages we are sending)
-  int output_buffer_samples;
+  uint32_t output_buffer_samples;
 
   struct airplay_master_session *next;
 };
@@ -1168,7 +1168,7 @@ master_session_make(struct media_quality *quality)
   rms->quality = *quality;
   rms->samples_per_packet = AIRPLAY_SAMPLES_PER_PACKET;
   rms->rawbuf_size = STOB(rms->samples_per_packet, quality->bits_per_sample, quality->channels);
-  rms->output_buffer_samples = OUTPUTS_BUFFER_DURATION * quality->sample_rate;
+  rms->output_buffer_samples = outputs_buffer_duration_ms_get() * quality->sample_rate / 1000;
 
   CHECK_NULL(L_AIRPLAY, rms->rawbuf = malloc(rms->rawbuf_size));
   CHECK_NULL(L_AIRPLAY, rms->input_buffer = evbuffer_new());

src/outputs/alsa.c

@@ -722,7 +722,7 @@ playback_session_add(struct alsa_session *as, struct media_quality *quality, str
   struct alsa_playback_session *pb;
   struct alsa_playback_session *tail_pb;
   struct timespec ts;
-  snd_pcm_sframes_t offset_nsamp;
+  uint64_t buffer_duration_ms;
   size_t size;
   int ret;
 
@@ -766,19 +766,17 @@ playback_session_add(struct alsa_session *as, struct media_quality *quality, str
   dump_config(pb->pcm);
 
   // Time stamps used for syncing, here we set when playback should start
-  ts.tv_sec = OUTPUTS_BUFFER_DURATION;
-  ts.tv_nsec = (uint64_t)as->offset_ms * 1000000UL;
+  buffer_duration_ms = outputs_buffer_duration_ms_get();
+  ts.tv_sec = buffer_duration_ms / 1000;
+  ts.tv_nsec = (buffer_duration_ms + (uint64_t)as->offset_ms) % 1000 * 1000000UL;
   pb->stamp_pts = timespec_add(pts, ts);
 
   // The difference between pos and start pos should match the 2 second buffer
-  // that AirPlay uses (OUTPUTS_BUFFER_DURATION) + user configured offset_ms. We
-  // will not use alsa's buffer for the initial buffering, because my sound
-  // card's start_threshold is not to be counted on. Instead we allocate our own
-  // buffer, and when it is time to play we write as much as we can to alsa's
-  // buffer.
-  offset_nsamp = (as->offset_ms * pb->quality.sample_rate / 1000);
-
-  pb->buffer_nsamp = OUTPUTS_BUFFER_DURATION * pb->quality.sample_rate + offset_nsamp;
+  // that e.g. AirPlay uses + user configured offset_ms. We will not use alsa's
+  // buffer for the initial buffering, because my sound card's start_threshold
+  // is not to be counted on. Instead we allocate our own buffer, and when it is
+  // time to play we write as much as we can to alsa's buffer.
+  pb->buffer_nsamp = (buffer_duration_ms + as->offset_ms) * pb->quality.sample_rate / 1000;
   size = STOB(pb->buffer_nsamp, pb->quality.bits_per_sample, pb->quality.channels);
   ringbuffer_init(&pb->prebuf, size);
 

src/outputs/cast.c

@@ -1948,7 +1948,7 @@ cast_session_make(struct output_device *device, int family, int callback_id)
       offset_ms = 0;
     }
 
-  offset_ms += OUTPUTS_BUFFER_DURATION * 1000 + CAST_DEVICE_START_DELAY_MS;
+  offset_ms += outputs_buffer_duration_ms_get() + CAST_DEVICE_START_DELAY_MS;
 
   cs->offset_ts.tv_sec  = (offset_ms / 1000);
   cs->offset_ts.tv_nsec = (offset_ms % 1000) * 1000000UL;

src/outputs/fifo.c

@@ -393,6 +393,8 @@ fifo_write(struct output_buffer *obuf)
   struct fifo_session *fifo_session = sessions;
   struct fifo_packet *packet;
   struct timespec now;
+  struct timespec delay;
+  uint64_t buffer_duration_ms;
   ssize_t bytes;
   int i;
 
@@ -430,8 +432,12 @@ fifo_write(struct output_buffer *obuf)
   if (!buffer.tail)
     buffer.tail = packet;
 
-  now.tv_sec = obuf->pts.tv_sec - OUTPUTS_BUFFER_DURATION;
-  now.tv_nsec = obuf->pts.tv_sec;
+  buffer_duration_ms = outputs_buffer_duration_ms_get();
+
+  delay.tv_sec = buffer_duration_ms / 1000;
+  delay.tv_nsec = (buffer_duration_ms % 1000) * 1000000UL;
+
+  now = timespec_sub(obuf->pts, delay);
 
   while (buffer.tail && (timespec_cmp(buffer.tail->pts, now) == -1))
     {

src/outputs/pulse.c

@@ -570,6 +570,7 @@ stream_open(struct pulse_session *ps, struct media_quality *quality, pa_stream_n
   pa_stream_flags_t flags;
   pa_sample_spec ss;
   pa_cvolume cvol;
+  uint64_t buffer_duration_ms;
   int offset_ms;
   int ret;
 
@@ -602,8 +603,9 @@ stream_open(struct pulse_session *ps, struct media_quality *quality, pa_stream_n
   pa_stream_set_state_callback(ps->stream, cb, ps);
 
   flags = PA_STREAM_INTERPOLATE_TIMING | PA_STREAM_AUTO_TIMING_UPDATE;
+  buffer_duration_ms = outputs_buffer_duration_ms_get();
 
-  ps->attr.tlength   = STOB((OUTPUTS_BUFFER_DURATION * 1000 + offset_ms) * ss.rate / 1000, quality->bits_per_sample, quality->channels);
+  ps->attr.tlength   = STOB((buffer_duration_ms + offset_ms) * ss.rate / 1000, quality->bits_per_sample, quality->channels);
   ps->attr.maxlength = 2 * ps->attr.tlength;
   ps->attr.prebuf    = (uint32_t)-1;
   ps->attr.minreq    = (uint32_t)-1;