From b782c901809a47dddadc33368d66d88d1bd9e9b9 Mon Sep 17 00:00:00 2001
From: wm4 <wm4@nowhere>
Date: Sun, 10 Dec 2017 05:07:36 +0100
Subject: demux_timeline: disable pointless packet cache for sub-demuxers

It seems like there's nothing stopping from sub-demuxers from keeping
packets in the cache, even if it's completely pointless. The top-most
demuxer (demux_timeline) already takes care of caching, so sub-demuxers
only waste space and time with this.

Add a function that can disable the packet cache even at runtime and
after packets are read. (It's not clear whether it really can happen
that packets are read before demux_timeline gets the sub-demuxers, but
there's no reason to make it too fragile.) Call it on all sub-demuxers.

For this to work, it seems we have to move the code for setting the
seekable_cache flag to before demux_timeline is potentially initialized,
because otherwise the cache would be reenabled if the demuxer triggering
timeline support is a timeline segment itself (e.g. ordered chapters).
---
 demux/demux.c | 34 ++++++++++++++++++++++++++--------
 1 file changed, 26 insertions(+), 8 deletions(-)

(limited to 'demux/demux.c')

diff --git a/demux/demux.c b/demux/demux.c
index 80f171b757..5a052fc787 100644
--- a/demux/demux.c
+++ b/demux/demux.c
@@ -520,7 +520,7 @@ static void free_empty_cached_ranges(struct demux_internal *in)
 
         for (int n = in->num_ranges - 2; n >= 0; n--) {
             struct demux_cached_range *range = in->ranges[n];
-            if (range->seek_start == MP_NOPTS_VALUE) {
+            if (range->seek_start == MP_NOPTS_VALUE || !in->seekable_cache) {
                 clear_cached_range(in, range);
                 MP_TARRAY_REMOVE_AT(in->ranges, in->num_ranges, n);
             } else {
@@ -2006,6 +2006,13 @@ static struct demuxer *open_given_type(struct mpv_global *global,
         demux_update(demuxer);
         stream_control(demuxer->stream, STREAM_CTRL_SET_READAHEAD,
                        &(int){params ? params->initial_readahead : false});
+        int seekable = opts->seekable_cache;
+        if (demuxer->is_network || stream->caching) {
+            in->min_secs = MPMAX(in->min_secs, opts->min_secs_cache);
+            if (seekable < 0)
+                seekable = 1;
+        }
+        in->seekable_cache = seekable == 1;
         if (!(params && params->disable_timeline)) {
             struct timeline *tl = timeline_load(global, log, demuxer);
             if (tl) {
@@ -2021,13 +2028,6 @@ static struct demuxer *open_given_type(struct mpv_global *global,
                 }
             }
         }
-        int seekable = opts->seekable_cache;
-        if (demuxer->is_network || stream->caching) {
-            in->min_secs = MPMAX(in->min_secs, opts->min_secs_cache);
-            if (seekable < 0)
-                seekable = 1;
-        }
-        in->seekable_cache = seekable == 1;
         return demuxer;
     }
 
@@ -2560,6 +2560,24 @@ int demuxer_add_chapter(demuxer_t *demuxer, char *name,
     return demuxer->num_chapters - 1;
 }
 
+void demux_disable_cache(demuxer_t *demuxer)
+{
+    struct demux_internal *in = demuxer->in;
+    assert(demuxer == in->d_user);
+
+    pthread_mutex_lock(&in->lock);
+    if (in->seekable_cache) {
+        MP_VERBOSE(demuxer, "disabling persistent packet cache\n");
+        in->seekable_cache = false;
+
+        // Get rid of potential buffered ranges floating around.
+        free_empty_cached_ranges(in);
+        // Get rid of potential old packets in the current range.
+        prune_old_packets(in);
+    }
+    pthread_mutex_unlock(&in->lock);
+}
+
 // must be called not locked
 static void update_cache(struct demux_internal *in)
 {
-- 
cgit v1.2.3