1 files changed, 42 insertions, 47 deletions

diff --git a/audio/out/ao_null.c b/audio/out/ao_null.c
index 07a0d4748c..107dc7e35a 100644
--- a/audio/out/ao_null.c
+++ b/audio/out/ao_null.c
@@ -40,9 +40,10 @@
 struct priv {
     bool paused;
     double last_time;
-    bool playing_final;
     float buffered;     // samples
     int buffersize;     // samples
+    bool playing;
+    bool underrun;
 
     int untimed;
     float bufferlen;    // seconds
@@ -77,8 +78,7 @@ static void drain(struct ao *ao)
     if (priv->buffered > 0) {
         priv->buffered -= (now - priv->last_time) * ao->samplerate * priv->speed;
         if (priv->buffered < 0) {
-            if (!priv->playing_final)
-                MP_ERR(ao, "buffer underrun\n");
+            priv->underrun = true;
             priv->buffered = 0;
         }
     }
@@ -127,85 +127,81 @@ static void reset(struct ao *ao)
 {
     struct priv *priv = ao->priv;
     priv->buffered = 0;
-    priv->playing_final = false;
+    priv->underrun = false;
+    priv->playing = false;
 }
 
-// stop playing, keep buffers (for pause)
-static void pause(struct ao *ao)
+static void start(struct ao *ao)
 {
     struct priv *priv = ao->priv;
 
-    drain(ao);
-    priv->paused = true;
-}
-
-// resume playing, after pause()
-static void resume(struct ao *ao)
-{
-    struct priv *priv = ao->priv;
+    if (priv->paused)
+        MP_ERR(ao, "illegal state: start() while paused\n");
 
     drain(ao);
     priv->paused = false;
     priv->last_time = mp_time_sec();
+    priv->playing = true;
 }
 
-static int get_space(struct ao *ao)
+static bool set_pause(struct ao *ao, bool paused)
 {
     struct priv *priv = ao->priv;
 
-    drain(ao);
-    int samples = priv->buffersize - priv->latency - priv->buffered;
-    return samples / priv->outburst * priv->outburst;
+    if (!priv->playing)
+        MP_ERR(ao, "illegal state: set_pause() while not playing\n");
+
+    if (priv->paused != paused) {
+
+        drain(ao);
+        priv->paused = paused;
+        if (!priv->paused)
+            priv->last_time = mp_time_sec();
+    }
+
+    return true;
 }
 
-static int play(struct ao *ao, void **data, int samples, int flags)
+static bool audio_write(struct ao *ao, void **data, int samples)
 {
     struct priv *priv = ao->priv;
-    int accepted;
-
-    resume(ao);
 
     if (priv->buffered <= 0)
         priv->buffered = priv->latency; // emulate fixed latency
 
-    priv->playing_final = flags & AOPLAY_FINAL_CHUNK;
-    if (priv->playing_final) {
-        // Last audio chunk - don't round to outburst.
-        accepted = MPMIN(priv->buffersize - priv->buffered, samples);
-    } else {
-        int maxbursts = (priv->buffersize - priv->buffered) / priv->outburst;
-        int playbursts = samples / priv->outburst;
-        int bursts = playbursts > maxbursts ? maxbursts : playbursts;
-        accepted = bursts * priv->outburst;
-    }
-    priv->buffered += accepted;
-    return accepted;
+    priv->buffered += samples;
+    return true;
 }
 
-static double get_delay(struct ao *ao)
+static void get_state(struct ao *ao, struct mp_pcm_state *state)
 {
     struct priv *priv = ao->priv;
 
     drain(ao);
 
-    // Note how get_delay returns the delay in audio device time (instead of
+    state->free_samples = priv->buffersize - priv->latency - priv->buffered;
+    state->free_samples = state->free_samples / priv->outburst * priv->outburst;
+    state->queued_samples = priv->buffered;
+
+    // Note how get_state returns the delay in audio device time (instead of
     // adjusting for speed), since most AOs seem to also do that.
-    double delay = priv->buffered;
+    state->delay = priv->buffered;
 
     // Drivers with broken EOF handling usually always report the same device-
     // level delay that is additional to the buffer time.
     if (priv->broken_eof && priv->buffered < priv->latency)
-        delay = priv->latency;
+        state->delay = priv->latency;
 
-    delay /= ao->samplerate;
+    state->delay /= ao->samplerate;
 
     if (priv->broken_delay) { // Report only multiples of outburst
         double q = priv->outburst / (double)ao->samplerate;
-        if (delay > 0)
-            delay = (int)(delay / q) * q;
+        if (state->delay > 0)
+            state->delay = (int)(state->delay / q) * q;
     }
 
-    return delay;
+    state->underrun = priv->underrun;
+    priv->underrun = false;
 }
 
 #define OPT_BASE_STRUCT struct priv
@@ -216,11 +212,10 @@ const struct ao_driver audio_out_null = {
     .init      = init,
     .uninit    = uninit,
     .reset     = reset,
-    .get_space = get_space,
-    .play      = play,
-    .get_delay = get_delay,
-    .pause     = pause,
-    .resume    = resume,
+    .get_state = get_state,
+    .set_pause = set_pause,
+    .write     = audio_write,
+    .start     = start,
     .priv_size = sizeof(struct priv),
     .priv_defaults = &(const struct priv) {
         .bufferlen = 0.2,