player: consider audio buffer if AO driver does not report underruns

AOs can report audio underruns, but only ao_alsa and ao_sdl (???)
currently do so. If the AO was marked as not reporting it, the cache
state was used to determine whether playback was interrupted due to slow
input.

This caused problems in some cases, such as video with very low video
frame rate: when a new frame is displayed, a new frame has to be
decoded, and since there it's so much further into the file (long frame
durations), the cache gets into an underrun state for a short moment,
even though both audio and video are playing fine. Enlarging the audio
buffer didn't help.

Fix this by making all AOs report underruns. If the AO driver does not
report underruns, fall back to using the buffer state.

pull.c behavior is slightly changed. Pull AOs are normally intended to
be used by pseudo-realtime audio APIs that fetch an audio buffer from
the API user via callback. I think it makes no sense to consider a
buffer underflow not an underrun in any situation, since we return
silence to the reader. (OK, maybe the reader could check the return
value? But let's not go there as long as there's no implementation.)
Remove the flag from ao_sdl.c, since it just worked via the generic
mechanism. Make the redundant underrun message verbose only.

push.c seems to log a redundant underflow message when resuming (because
somehow ao_play_data() is called when there's still no new data in the
buffer). But since ao_alsa does its own underrun reporting, and I only
use ao_alsa, I don't really care.

Also in all my tests, there seemed to be a rather high delay until the
underflow was logged (with audio only). I have no idea why this happened
and didn't try to debug this, but there's probably something wrong
somewhere.

This commit may cause random regressions.

See: #7440

1 files changed, 17 insertions, 10 deletions

diff --git a/audio/out/pull.c b/audio/out/pull.c
index 985d6d9f67..a3d4b024b1 100644
--- a/audio/out/pull.c
+++ b/audio/out/pull.c
@@ -83,9 +83,23 @@ static void set_state(struct ao *ao, int new_state)
     }
 }
 
+static void report_underruns(struct ao *ao)
+{
+    struct ao_pull_state *p = ao->api_priv;
+
+    int underflow = atomic_fetch_and(&p->underflow, 0);
+    if (underflow) {
+        if (ao_underrun_event(ao))
+            MP_VERBOSE(ao, "Audio underrun by %d samples.\n", underflow);
+    }
+}
+
 static int get_space(struct ao *ao)
 {
     struct ao_pull_state *p = ao->api_priv;
+
+    report_underruns(ao);
+
     // Since the reader will read the last plane last, its free space is the
     // minimum free space across all planes.
     return mp_ring_available(p->buffers[ao->num_planes - 1]) / ao->sstride;
@@ -119,9 +133,7 @@ static int play(struct ao *ao, void **data, int samples, int flags)
     bool draining = write_samples == samples && (flags & AOPLAY_FINAL_CHUNK);
     atomic_store(&p->draining, draining);
 
-    int underflow = atomic_fetch_and(&p->underflow, 0);
-    if (underflow)
-        MP_WARN(ao, "Audio underflow by %d samples.\n", underflow);
+    report_underruns(ao);
 
     return write_samples;
 }
@@ -153,13 +165,8 @@ int ao_read_data(struct ao *ao, void **data, int samples, int64_t out_time_us)
     int buffered_bytes = mp_ring_buffered(p->buffers[0]);
     bytes = MPMIN(buffered_bytes, full_bytes);
 
-    if (full_bytes > bytes && !atomic_load(&p->draining)) {
-        if (ao->driver->reports_underruns) {
-            ao_underrun_event(ao);
-        } else {
-            atomic_fetch_add(&p->underflow, (full_bytes - bytes) / ao->sstride);
-        }
-    }
+    if (full_bytes > bytes && !atomic_load(&p->draining))
+        atomic_fetch_add(&p->underflow, (full_bytes - bytes) / ao->sstride);
 
     if (bytes > 0)
         atomic_store(&p->end_time_us, out_time_us);