3 files changed, 183 insertions, 16 deletions

diff --git a/stream/cache_file.c b/stream/cache_file.c
new file mode 100644
index 0000000000..dfdd8390dc
--- /dev/null
+++ b/stream/cache_file.c
@@ -0,0 +1,149 @@
+/*
+ * This file is part of mpv.
+ *
+ * mpv is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * mpv is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with mpv.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include <stdio.h>
+#include <stdint.h>
+
+#include "common/common.h"
+#include "common/msg.h"
+
+#include "options/options.h"
+
+#include "stream.h"
+
+#define BLOCK_SIZE 1024LL
+#define BLOCK_ALIGN(p) ((p) & ~(BLOCK_SIZE - 1))
+
+struct priv {
+    struct stream *original;
+    FILE *cache_file;
+    uint8_t *block_bits;    // 1 bit for each BLOCK_SIZE, whether block was read
+    int64_t size;           // currently known size
+    int64_t max_size;       // max. size for block_bits and cache_file
+};
+
+static bool test_bit(struct priv *p, int64_t pos)
+{
+    if (pos < 0 || pos >= p->size)
+        return false;
+    size_t block = pos / BLOCK_SIZE;
+    return p->block_bits[block / 8] & (1 << (block % 8));
+}
+
+static void set_bit(struct priv *p, int64_t pos, bool bit)
+{
+    if (pos < 0 || pos >= p->size)
+        return;
+    size_t block = pos / BLOCK_SIZE;
+    unsigned int m = (1 << (block % 8));
+    p->block_bits[block / 8] = (p->block_bits[block / 8] & ~m) | (bit ? m : 0);
+}
+
+static int fill_buffer(stream_t *s, char *buffer, int max_len)
+{
+    struct priv *p = s->priv;
+    if (s->pos < 0)
+        return -1;
+    if (s->pos >= p->max_size) {
+        if (stream_seek(p->original, s->pos) < 1)
+            return -1;
+        return stream_read(p->original, buffer, max_len);
+    }
+    // Size of file changes -> invalidate last block
+    if (s->pos >= p->size - BLOCK_SIZE) {
+        int64_t new_size = -1;
+        stream_control(s, STREAM_CTRL_GET_SIZE, &new_size);
+        if (new_size != p->size)
+            set_bit(p, BLOCK_ALIGN(p->size), 0);
+        p->size = MPMIN(p->max_size, new_size);
+    }
+    int64_t aligned = BLOCK_ALIGN(s->pos);
+    if (!test_bit(p, aligned)) {
+        char tmp[BLOCK_SIZE];
+        stream_seek(p->original, aligned);
+        int r = stream_read(p->original, tmp, BLOCK_SIZE);
+        if (r < BLOCK_SIZE) {
+            if (p->size < 0) {
+                MP_WARN(s, "suspected EOF\n");
+            } else if (aligned + r < p->size) {
+                MP_ERR(s, "unexpected EOF\n");
+                return -1;
+            }
+        }
+        if (fseeko(p->cache_file, aligned, SEEK_SET))
+            return -1;
+        if (fwrite(tmp, r, 1, p->cache_file) != 1)
+            return -1;
+        set_bit(p, aligned, 1);
+    }
+    if (fseeko(p->cache_file, s->pos, SEEK_SET))
+        return -1;
+    // align/limit to blocks
+    max_len = MPMIN(max_len, BLOCK_SIZE - (s->pos % BLOCK_SIZE));
+    // Limit to max. known file size
+    max_len = MPMIN(max_len, p->size - s->pos);
+    return fread(buffer, 1, max_len, p->cache_file);
+}
+
+static int seek(stream_t *s, int64_t newpos)
+{
+    return 1;
+}
+
+static int control(stream_t *s, int cmd, void *arg)
+{
+    struct priv *p = s->priv;
+    return stream_control(p->original, cmd, arg);
+}
+
+static void s_close(stream_t *s)
+{
+    struct priv *p = s->priv;
+    if (p->cache_file)
+        fclose(p->cache_file);
+    talloc_free(p);
+}
+
+// return 1 on success, 0 if disabled, -1 on error
+int stream_file_cache_init(stream_t *cache, stream_t *stream,
+                           struct mp_cache_opts *opts)
+{
+    if (!opts->file || !opts->file[0] || opts->file_max < 1)
+        return 0;
+
+    FILE *file = fopen(opts->file, "wb+");
+    if (!file) {
+        MP_ERR(cache, "can't open cache file '%s'\n", opts->file);
+        return -1;
+    }
+
+    struct priv *p = talloc_zero(NULL, struct priv);
+
+    cache->priv = p;
+    p->original = stream;
+    p->cache_file = file;
+    p->max_size = opts->file_max * 1024LL;
+
+    // file_max can be INT_MAX, so this is at most about 256MB
+    p->block_bits = talloc_zero_size(p, (p->max_size / BLOCK_SIZE + 1) / 8 + 1);
+
+    cache->seek = seek;
+    cache->fill_buffer = fill_buffer;
+    cache->control = control;
+    cache->close = s_close;
+
+    return 1;
+}
diff --git a/stream/stream.c b/stream/stream.c
index 2a6136f036..6e903bc8ec 100644
--- a/stream/stream.c
+++ b/stream/stream.c
@@ -766,6 +766,28 @@ stream_t *open_memory_stream(void *data, int len)
     return s;
 }
 
+static stream_t *open_cache(stream_t *orig, const char *name)
+{
+    stream_t *cache = new_stream();
+    cache->uncached_type = orig->type;
+    cache->uncached_stream = orig;
+    cache->seekable = true;
+    cache->mode = STREAM_READ;
+    cache->read_chunk = 4 * STREAM_BUFFER_SIZE;
+
+    cache->url = talloc_strdup(cache, orig->url);
+    cache->mime_type = talloc_strdup(cache, orig->mime_type);
+    cache->demuxer = talloc_strdup(cache, orig->demuxer);
+    cache->lavf_type = talloc_strdup(cache, orig->lavf_type);
+    cache->safe_origin = orig->safe_origin;
+    cache->opts = orig->opts;
+    cache->global = orig->global;
+
+    cache->log = mp_log_new(cache, cache->global->log, name);
+
+    return cache;
+}
+
 static struct mp_cache_opts check_cache_opts(stream_t *stream,
                                              struct mp_cache_opts *opts)
 {
@@ -794,27 +816,21 @@ int stream_enable_cache(stream_t **stream, struct mp_cache_opts *opts)
     if (use_opts.size < 1)
         return -1;
 
-    stream_t *cache = new_stream();
-    cache->uncached_type = orig->type;
-    cache->uncached_stream = orig;
-    cache->seekable = true;
-    cache->mode = STREAM_READ;
-    cache->read_chunk = 4 * STREAM_BUFFER_SIZE;
-
-    cache->url = talloc_strdup(cache, orig->url);
-    cache->mime_type = talloc_strdup(cache, orig->mime_type);
-    cache->demuxer = talloc_strdup(cache, orig->demuxer);
-    cache->lavf_type = talloc_strdup(cache, orig->lavf_type);
-    cache->safe_origin = orig->safe_origin;
-    cache->opts = orig->opts;
-    cache->global = orig->global;
+    stream_t *fcache = open_cache(orig, "file-cache");
+    if (stream_file_cache_init(fcache, orig, &use_opts) <= 0) {
+        fcache->uncached_stream = NULL; // don't free original stream
+        free_stream(fcache);
+        fcache = orig;
+    }
 
-    cache->log = mp_log_new(cache, cache->global->log, "cache");
+    stream_t *cache = open_cache(fcache, "cache");
 
-    int res = stream_cache_init(cache, orig, &use_opts);
+    int res = stream_cache_init(cache, fcache, &use_opts);
     if (res <= 0) {
         cache->uncached_stream = NULL; // don't free original stream
         free_stream(cache);
+        if (fcache != orig)
+            free_stream(fcache);
     } else {
         *stream = cache;
     }
diff --git a/stream/stream.h b/stream/stream.h
index 267f8e753a..4f8ca6ddae 100644
--- a/stream/stream.h
+++ b/stream/stream.h
@@ -198,6 +198,8 @@ int stream_enable_cache(stream_t **stream, struct mp_cache_opts *opts);
 // Internal
 int stream_cache_init(stream_t *cache, stream_t *stream,
                       struct mp_cache_opts *opts);
+int stream_file_cache_init(stream_t *cache, stream_t *stream,
+                           struct mp_cache_opts *opts);
 
 int stream_write_buffer(stream_t *s, unsigned char *buf, int len);