stream: don't use end_pos

Stop using it in most places, and prefer STREAM_CTRL_GET_SIZE. The
advantage is that always the correct size will be used. There can be no
doubt anymore whether the end_pos value is outdated (as it happens often
with files that are being downloaded).

Some streams still use end_pos. They don't change size, and it's easier
to emulate STREAM_CTRL_GET_SIZE using end_pos, instead of adding a
STREAM_CTRL_GET_SIZE implementation to these streams.

Make sure int64_t is always used for STREAM_CTRL_GET_SIZE (it was
uint64_t before).

Remove the seek flags mess, and replace them with a seekable flag. Every
stream must set it consistently now, and an assertion in stream.c checks
this. Don't distinguish between streams that can only be forward or
backwards seeked, since we have no such stream types.

19 files changed, 112 insertions, 104 deletions

diff --git a/demux/demux.c b/demux/demux.c
index 4da1adb134..ba231b5af6 100644
--- a/demux/demux.c
+++ b/demux/demux.c
@@ -587,8 +587,7 @@ static struct demuxer *open_given_type(struct mpv_global *global,
         .type = desc->type,
         .stream = stream,
         .stream_pts = MP_NOPTS_VALUE,
-        .seekable = (stream->flags & MP_STREAM_SEEK) == MP_STREAM_SEEK &&
-                    stream->end_pos > 0,
+        .seekable = stream->seekable,
         .accurate_seek = true,
         .filepos = -1,
         .opts = global->opts,
diff --git a/demux/demux_lavf.c b/demux/demux_lavf.c
index b5a6ef998c..2b43f4f27f 100644
--- a/demux/demux_lavf.c
+++ b/demux/demux_lavf.c
@@ -135,17 +135,18 @@ static int64_t mp_seek(void *opaque, int64_t pos, int whence)
         return -1;
     MP_DBG(demuxer, "mp_seek(%p, %"PRId64", %d)\n",
            stream, pos, whence);
-    if (whence == SEEK_CUR)
+    if (whence == SEEK_END || whence == AVSEEK_SIZE) {
+        int64_t end;
+        if (stream_control(stream, STREAM_CTRL_GET_SIZE, &end) != STREAM_OK)
+            return -1;
+        if (whence == AVSEEK_SIZE)
+            return end;
+        pos += end;
+    } else if (whence == SEEK_CUR) {
         pos += stream_tell(stream);
-    else if (whence == SEEK_END && stream->end_pos > 0)
-        pos += stream->end_pos;
-    else if (whence == SEEK_SET)
-        /* ok */;
-    else if (whence == AVSEEK_SIZE && stream->end_pos > 0) {
-        stream_update_size(stream);
-        return stream->end_pos;
-    } else
+    } else if (whence != SEEK_SET) {
         return -1;
+    }
 
     if (pos < 0)
         return -1;
@@ -824,11 +825,13 @@ static void demux_seek_lavf(demuxer_t *demuxer, float rel_seek_secs, int flags)
 
     if (flags & SEEK_FACTOR) {
         struct stream *s = demuxer->stream;
-        if (s->end_pos > 0 && demuxer->ts_resets_possible &&
+        int64_t end = 0;
+        stream_control(s, STREAM_CTRL_GET_SIZE, &end);
+        if (end > 0 && demuxer->ts_resets_possible &&
             !(priv->avif->flags & AVFMT_NO_BYTE_SEEK))
         {
             avsflags |= AVSEEK_FLAG_BYTE;
-            priv->last_pts = s->end_pos * rel_seek_secs;
+            priv->last_pts = end * rel_seek_secs;
         } else if (priv->avfc->duration != 0 &&
                    priv->avfc->duration != AV_NOPTS_VALUE)
         {
diff --git a/demux/demux_mkv.c b/demux/demux_mkv.c
index 20864aa297..4b08ce2a13 100644
--- a/demux/demux_mkv.c
+++ b/demux/demux_mkv.c
@@ -1058,7 +1058,9 @@ static int demux_mkv_read_seekhead(demuxer_t *demuxer)
                    (unsigned)seek->seek_id, pos);
         get_header_element(demuxer, seek->seek_id, pos);
         // This is nice to warn against incomplete files.
-        if (pos >= s->end_pos)
+        int64_t end = 0;
+        stream_control(s, STREAM_CTRL_GET_SIZE, &end);
+        if (pos >= end)
             MP_WARN(demuxer, "SeekHead position beyond "
                     "end of file - incomplete file?\n");
     }
@@ -1723,7 +1725,9 @@ static int read_mkv_segment_header(demuxer_t *demuxer, int64_t *segment_end)
         MP_VERBOSE(demuxer, "  (skipping)\n");
         if (*segment_end <= 0)
             break;
-        if (*segment_end >= s->end_pos)
+        int64_t end = 0;
+        stream_control(s, STREAM_CTRL_GET_SIZE, &end);
+        if (*segment_end >= end)
             return 0;
         if (!stream_seek(s, *segment_end)) {
             MP_WARN(demuxer, "Failed to seek in file\n");
@@ -1794,7 +1798,9 @@ static int demux_mkv_open(demuxer_t *demuxer, enum demux_check check)
         }
         MP_VERBOSE(demuxer, "Seeking to %"PRIu64" to read header element 0x%x.\n",
                    elem->pos, (unsigned)elem->id);
-        if (elem->pos >= s->end_pos) {
+        int64_t end = 0;
+        stream_control(s, STREAM_CTRL_GET_SIZE, &end);
+        if (elem->pos >= end) {
             MP_WARN(demuxer, "SeekHead position beyond "
                     "end of file - incomplete file?\n");
             continue;
@@ -2748,7 +2754,10 @@ static void demux_mkv_seek(demuxer_t *demuxer, float rel_seek_secs, int flags)
             return;
         }
 
-        target_filepos = (uint64_t) (s->end_pos * rel_seek_secs);
+        int64_t size = 0;
+        stream_control(s, STREAM_CTRL_GET_SIZE, &size);
+
+        target_filepos = (uint64_t) (size * rel_seek_secs);
         for (i = 0; i < mkv_d->num_indexes; i++)
             if (mkv_d->indexes[i].tnum == v_tnum)
                 if ((index == NULL)
diff --git a/demux/demux_raw.c b/demux/demux_raw.c
index 9d649c07a0..3c605e3f96 100644
--- a/demux/demux_raw.c
+++ b/demux/demux_raw.c
@@ -214,8 +214,8 @@ static void raw_seek(demuxer_t *demuxer, float rel_seek_secs, int flags)
 {
     struct priv *p = demuxer->priv;
     stream_t *s = demuxer->stream;
-    stream_update_size(s);
-    int64_t end = s->end_pos;
+    int64_t end = 0;
+    stream_control(s, STREAM_CTRL_GET_SIZE, &end);
     int64_t pos = (flags & SEEK_ABSOLUTE) ? 0 : stream_tell(s);
     if (flags & SEEK_FACTOR)
         pos += end * rel_seek_secs;
@@ -235,9 +235,8 @@ static int raw_control(demuxer_t *demuxer, int cmd, void *arg)
     switch (cmd) {
     case DEMUXER_CTRL_GET_TIME_LENGTH: {
         stream_t *s = demuxer->stream;
-        stream_update_size(s);
-        int64_t end = s->end_pos;
-        if (!end)
+        int64_t end = 0;
+        if (stream_control(s, STREAM_CTRL_GET_SIZE, &end) != STREAM_OK)
             return DEMUXER_CTRL_DONTKNOW;
 
         *((double *) arg) = (end / p->frame_size) / p->frame_rate;
diff --git a/player/command.c b/player/command.c
index 9c690d38ae..4619062bf5 100644
--- a/player/command.c
+++ b/player/command.c
@@ -206,12 +206,12 @@ static int mp_property_file_size(m_option_t *prop, int action, void *arg,
     if (!mpctx->stream)
         return M_PROPERTY_UNAVAILABLE;
 
-    int64_t size = mpctx->stream->end_pos;
+    int64_t size;
+    if (stream_control(mpctx->stream, STREAM_CTRL_GET_SIZE, &size) != STREAM_OK)
+        return M_PROPERTY_UNAVAILABLE;
 
     switch (action) {
     case M_PROPERTY_GET: {
-        if (size <= 0)
-            break;
         *(int64_t *)arg = size;
         return M_PROPERTY_OK;
     }
@@ -301,10 +301,7 @@ static int mp_property_stream_pos(m_option_t *prop, int action, void *arg,
 static int mp_property_stream_end(m_option_t *prop, int action, void *arg,
                                   MPContext *mpctx)
 {
-    struct stream *stream = mpctx->stream;
-    if (!stream)
-        return M_PROPERTY_UNAVAILABLE;
-    return m_property_int64_ro(prop, action, arg, stream->end_pos);
+    return mp_property_file_size(prop, action, arg, mpctx);
 }
 
 // Does some magic to handle "<name>/full" as time formatted with milliseconds.
diff --git a/player/misc.c b/player/misc.c
index e3cf70f81e..6eae646242 100644
--- a/player/misc.c
+++ b/player/misc.c
@@ -169,14 +169,16 @@ void stream_dump(struct MPContext *mpctx)
     stream_t *stream = mpctx->stream;
     assert(stream && filename);
 
+    int64_t size = 0;
+    stream_control(stream, STREAM_CTRL_GET_SIZE, &size);
+
     stream_set_capture_file(stream, filename);
 
     while (mpctx->stop_play == KEEP_PLAYING && !stream->eof) {
         if (!opts->quiet && ((stream->pos / (1024 * 1024)) % 2) == 1) {
             uint64_t pos = stream->pos;
-            uint64_t end = stream->end_pos;
             MP_MSG(mpctx, MSGL_STATUS, "Dumping %lld/%lld...",
-                   (long long int)pos, (long long int)end);
+                   (long long int)pos, (long long int)size);
         }
         stream_fill_buffer(stream);
         for (;;) {
diff --git a/player/playloop.c b/player/playloop.c
index dea78c5571..964f112b6d 100644
--- a/player/playloop.c
+++ b/player/playloop.c
@@ -472,11 +472,12 @@ double get_current_pos_ratio(struct MPContext *mpctx, bool use_range)
         ans = MPCLAMP((pos - start) / len, 0, 1);
     } else {
         struct stream *s = demuxer->stream;
-        int64_t size = s->end_pos;
-        int64_t fpos = demuxer->filepos >= 0 ?
-                       demuxer->filepos : stream_tell(demuxer->stream);
-        if (size > 0)
+        int64_t size;
+        if (stream_control(s, STREAM_CTRL_GET_SIZE, &size) > 0 && size > 0) {
+            int64_t fpos =
+                demuxer->filepos >= 0 ? demuxer->filepos : stream_tell(s);
             ans = MPCLAMP(fpos / (double)size, 0, 1);
+        }
     }
     if (use_range) {
         if (mpctx->opts->play_frames > 0)
diff --git a/stream/cache.c b/stream/cache.c
index ad1277fb85..bd9712e341 100644
--- a/stream/cache.c
+++ b/stream/cache.c
@@ -364,6 +364,7 @@ static int resize_cache(struct priv *s, int64_t size)
 static void update_cached_controls(struct priv *s)
 {
     unsigned int ui;
+    int64_t i64;
     double d;
     char **m;
     char *t;
@@ -388,8 +389,9 @@ static void update_cached_controls(struct priv *s)
         talloc_free(s->disc_name);
         s->disc_name = talloc_steal(s, t);
     }
-    stream_update_size(s->stream);
-    s->stream_size = s->stream->end_pos;
+    s->stream_size = -1;
+    if (stream_control(s->stream, STREAM_CTRL_GET_SIZE, &i64) == STREAM_OK)
+        s->stream_size = i64;
 }
 
 // the core might call these every frame, so cache them...
@@ -410,10 +412,13 @@ static int cache_get_cached_control(stream_t *cache, int cmd, void *arg)
         *(double *)arg = s->stream_time_length;
         return s->stream_time_length ? STREAM_OK : STREAM_UNSUPPORTED;
     case STREAM_CTRL_GET_START_TIME:
+        if (s->stream_start_time == MP_NOPTS_VALUE)
+            return STREAM_UNSUPPORTED;
         *(double *)arg = s->stream_start_time;
-        return s->stream_start_time !=
-               MP_NOPTS_VALUE ? STREAM_OK : STREAM_UNSUPPORTED;
+        return STREAM_OK;
     case STREAM_CTRL_GET_SIZE:
+        if (s->stream_size < 0)
+            return STREAM_UNSUPPORTED;
         *(int64_t *)arg = s->stream_size;
         return STREAM_OK;
     case STREAM_CTRL_MANAGES_TIMELINE:
@@ -692,8 +697,7 @@ int stream_cache_init(stream_t *cache, stream_t *stream,
     if (min > s->buffer_size - FILL_LIMIT)
         min = s->buffer_size - FILL_LIMIT;
 
-    s->seekable = (stream->flags & MP_STREAM_SEEK) == MP_STREAM_SEEK &&
-                  stream->end_pos > 0;
+    s->seekable = stream->seekable;
 
     if (pthread_create(&s->cache_thread, NULL, cache_thread, s) != 0) {
         MP_ERR(s, "Starting cache process/thread failed: %s.\n",
diff --git a/stream/stream.c b/stream/stream.c
index 0acabe3f52..3ea4d475b7 100644
--- a/stream/stream.c
+++ b/stream/stream.c
@@ -306,7 +306,6 @@ static int open_internal(const stream_info_t *sinfo, struct stream *underlying,
         }
     }
 
-    s->flags = 0;
     s->mode = flags & (STREAM_READ | STREAM_WRITE);
     int r = sinfo->open(s, s->mode);
     if (r != STREAM_OK) {
@@ -317,13 +316,7 @@ static int open_internal(const stream_info_t *sinfo, struct stream *underlying,
     if (!s->read_chunk)
         s->read_chunk = 4 * (s->sector_size ? s->sector_size : STREAM_BUFFER_SIZE);
 
-    if (!s->seek)
-        s->flags &= ~MP_STREAM_SEEK;
-    if (s->seek && !(s->flags & MP_STREAM_SEEK))
-        s->flags |= MP_STREAM_SEEK;
-
-    if (!(s->flags & MP_STREAM_SEEK))
-        s->end_pos = 0;
+    assert(s->seekable == !!s->seek);
 
     s->uncached_type = s->type;
 
@@ -394,7 +387,7 @@ static int stream_reconnect(stream_t *s)
 #define RECONNECT_SLEEP_MAX_MS 500
     if (!s->streaming)
         return 0;
-    if (!(s->flags & MP_STREAM_SEEK_FW))
+    if (!s->seekable)
         return 0;
     int64_t pos = s->pos;
     int sleep_ms = 5;
@@ -468,7 +461,9 @@ static int stream_read_unbuffered(stream_t *s, void *buf, int len)
         len = 0;
     if (len == 0) {
         // do not retry if this looks like proper eof
-        if (s->eof || (s->end_pos && s->pos == s->end_pos))
+        int64_t size = -1;
+        stream_control(s, STREAM_CTRL_GET_SIZE, &size);
+        if (s->eof || s->pos == size)
             goto eof_out;
 
         // just in case this is an error e.g. due to network
@@ -622,11 +617,11 @@ void stream_drop_buffers(stream_t *s)
 static int stream_seek_unbuffered(stream_t *s, int64_t newpos)
 {
     if (newpos != s->pos) {
-        if (newpos > s->pos && !(s->flags & MP_STREAM_SEEK_FW)) {
-            MP_ERR(s, "Can not seek in this stream\n");
+        if (newpos > s->pos && !s->seekable) {
+            MP_ERR(s, "Cannot seek forward in this stream\n");
             return 0;
         }
-        if (newpos < s->pos && !(s->flags & MP_STREAM_SEEK_BW)) {
+        if (newpos < s->pos && !s->seekable) {
             MP_ERR(s, "Cannot seek backward in linear streams!\n");
             return 1;
         }
@@ -647,7 +642,7 @@ static int stream_seek_long(stream_t *s, int64_t pos)
     stream_drop_buffers(s);
 
     if (s->mode == STREAM_WRITE) {
-        if (!(s->flags & MP_STREAM_SEEK) || !s->seek(s, pos))
+        if (!s->seekable || !s->seek(s, pos))
             return 0;
         return 1;
     }
@@ -659,9 +654,7 @@ static int stream_seek_long(stream_t *s, int64_t pos)
     MP_TRACE(s, "Seek from %" PRId64 " to %" PRId64
              " (with offset %d)\n", s->pos, pos, (int)(pos - newpos));
 
-    if (pos >= s->pos && !(s->flags & MP_STREAM_SEEK) &&
-        (s->flags & MP_STREAM_FAST_SKIPPING))
-    {
+    if (pos >= s->pos && !s->seekable && s->fast_skip) {
         // skipping is handled by generic code below
     } else if (stream_seek_unbuffered(s, newpos) >= 0) {
         return 0;
@@ -708,7 +701,7 @@ int stream_skip(stream_t *s, int64_t len)
     int64_t target = stream_tell(s) + len;
     if (len < 0)
         return stream_seek(s, target);
-    if (len > 2 * STREAM_BUFFER_SIZE && (s->flags & MP_STREAM_SEEK_FW)) {
+    if (len > 2 * STREAM_BUFFER_SIZE && s->seekable) {
         // Seek to 1 byte before target - this is the only way to distinguish
         // skip-to-EOF and skip-past-EOF in general. Successful seeking means
         // absolutely nothing, so test by doing a real read of the last byte.
@@ -726,18 +719,19 @@ int stream_control(stream_t *s, int cmd, void *arg)
 {
     if (!s->control)
         return STREAM_UNSUPPORTED;
-    return s->control(s, cmd, arg);
-}
-
-void stream_update_size(stream_t *s)
-{
-    if (!(s->flags & MP_STREAM_SEEK))
-        return;
-    uint64_t size;
-    if (stream_control(s, STREAM_CTRL_GET_SIZE, &size) == STREAM_OK) {
-        if (size > s->end_pos)
-            s->end_pos = size;
+    int r = s->control(s, cmd, arg);
+    if (r == STREAM_UNSUPPORTED) {
+        // Fallbacks
+        switch (cmd) {
+        case STREAM_CTRL_GET_SIZE:
+            if (s->end_pos > 0) {
+                *(int64_t *)arg = s->end_pos;
+                return STREAM_OK;
+            }
+            break;
+        }
     }
+    return r;
 }
 
 void free_stream(stream_t *s)
@@ -804,7 +798,7 @@ int stream_enable_cache(stream_t **stream, struct mp_cache_opts *opts)
     stream_t *cache = new_stream();
     cache->uncached_type = orig->type;
     cache->uncached_stream = orig;
-    cache->flags |= MP_STREAM_SEEK;
+    cache->seekable = true;
     cache->mode = STREAM_READ;
     cache->read_chunk = 4 * STREAM_BUFFER_SIZE;
 
@@ -815,7 +809,6 @@ int stream_enable_cache(stream_t **stream, struct mp_cache_opts *opts)
     cache->safe_origin = orig->safe_origin;
     cache->opts = orig->opts;
     cache->global = orig->global;
-    cache->end_pos = orig->end_pos;
 
     cache->log = mp_log_new(cache, cache->global->log, "cache");
 
@@ -935,10 +928,12 @@ struct bstr stream_read_complete(struct stream *s, void *talloc_ctx,
     int total_read = 0;
     int padding = 1;
     char *buf = NULL;
-    if (s->end_pos > max_size)
+    int64_t size = 0;
+    stream_control(s, STREAM_CTRL_GET_SIZE, &size);
+    if (size > max_size)
         return (struct bstr){NULL, 0};
-    if (s->end_pos > 0)
-        bufsize = s->end_pos + padding;
+    if (size > 0)
+        bufsize = size + padding;
     else
         bufsize = 1000;
     while (1) {
diff --git a/stream/stream.h b/stream/stream.h
index 2182de2526..5fc4c58579 100644
--- a/stream/stream.h
+++ b/stream/stream.h
@@ -57,12 +57,6 @@ enum streamtype {
 // flags for stream_open_ext (this includes STREAM_READ and STREAM_WRITE)
 #define STREAM_NO_FILTERS 2
 
-// stream->flags
-#define MP_STREAM_FAST_SKIPPING 1 // allow forward seeks by skipping
-#define MP_STREAM_SEEK_BW  2
-#define MP_STREAM_SEEK_FW  4
-#define MP_STREAM_SEEK  (MP_STREAM_SEEK_BW | MP_STREAM_SEEK_FW)
-
 #define STREAM_NO_MATCH -2
 #define STREAM_UNSUPPORTED -1
 #define STREAM_ERROR 0
@@ -143,11 +137,11 @@ typedef struct stream {
 
     enum streamtype type; // see STREAMTYPE_*
     enum streamtype uncached_type; // if stream is cache, type of wrapped str.
-    int flags; // MP_STREAM_SEEK_* or'ed flags
     int sector_size; // sector size (seek will be aligned on this size if non 0)
     int read_chunk; // maximum amount of data to read at once to limit latency
     unsigned int buf_pos, buf_len;
-    int64_t pos, end_pos;
+    int64_t pos;
+    uint64_t end_pos; // static size; use STREAM_CTRL_GET_SIZE instead
     int eof;
     int mode; //STREAM_READ or STREAM_WRITE
     bool streaming;     // known to be a network stream if true
@@ -157,8 +151,10 @@ typedef struct stream {
     char *mime_type; // when HTTP streaming is used
     char *demuxer; // request demuxer to be used
     char *lavf_type; // name of expected demuxer type for lavf
-    bool safe_origin; // used for playlists that can be opened safely
-    bool allow_caching; // stream cache makes sense
+    bool seekable : 1; // presence of general byte seeking support
+    bool fast_skip : 1; // consider stream fast enough to fw-seek by skipping
+    bool safe_origin : 1; // used for playlists that can be opened safely
+    bool allow_caching : 1; // stream cache makes sense
     struct mp_log *log;
     struct MPOpts *opts;
     struct mpv_global *global;
@@ -219,7 +215,6 @@ struct mpv_global;
 struct bstr stream_read_complete(struct stream *s, void *talloc_ctx,
                                  int max_size);
 int stream_control(stream_t *s, int cmd, void *arg);
-void stream_update_size(stream_t *s);
 void free_stream(stream_t *s);
 struct stream *stream_create(const char *url, int flags, struct mpv_global *global);
 struct stream *stream_open(const char *filename, struct mpv_global *global);
diff --git a/stream/stream_bluray.c b/stream/stream_bluray.c
index cabfbecab8..0ca87403b4 100644
--- a/stream/stream_bluray.c
+++ b/stream/stream_bluray.c
@@ -801,7 +801,6 @@ static int bluray_stream_open(stream_t *s, int mode)
     s->type        = STREAMTYPE_BLURAY;
     s->end_pos     = bd_get_title_size(bd);
     s->sector_size = BLURAY_SECTOR_SIZE;
-    s->flags       = MP_STREAM_SEEK;
     s->priv        = b;
 
     MP_VERBOSE(s, "Blu-ray successfully opened.\n");
diff --git a/stream/stream_cdda.c b/stream/stream_cdda.c
index 6f1c747483..856c9736d2 100644
--- a/stream/stream_cdda.c
+++ b/stream/stream_cdda.c
@@ -396,6 +396,7 @@ static int open_cdda(stream_t *st, int m)
 
     st->fill_buffer = fill_buffer;
     st->seek = seek;
+    st->seekable = true;
     st->control = control;
     st->close = close_cdda;
 
diff --git a/stream/stream_dvdnav.c b/stream/stream_dvdnav.c
index 504aa065e1..fdaf38e640 100644
--- a/stream/stream_dvdnav.c
+++ b/stream/stream_dvdnav.c
@@ -719,7 +719,6 @@ static int open_s(stream_t *stream, int mode)
         dvdnav_angle_change(priv->dvdnav, dvd_angle);
 
     stream->sector_size = 2048;
-    stream->flags = STREAM_READ;
     stream->fill_buffer = fill_buffer;
     stream->control = control;
     stream->close = stream_dvdnav_close;
diff --git a/stream/stream_file.c b/stream/stream_file.c
index c714f5739d..528cf1a6e3 100644
--- a/stream/stream_file.c
+++ b/stream/stream_file.c
@@ -96,9 +96,10 @@ static int control(stream_t *s, int cmd, void *arg)
         size = lseek(p->fd, 0, SEEK_END);
         lseek(p->fd, s->pos, SEEK_SET);
         if (size != (off_t)-1) {
-            *(uint64_t *)arg = size;
+            *(int64_t *)arg = size;
             return 1;
         }
+        break;
     }
     }
     return STREAM_UNSUPPORTED;
@@ -276,10 +277,10 @@ static int open_f(stream_t *stream, int mode)
         len = -1;
 #endif
     stream->type = STREAMTYPE_FILE;
-    stream->flags = MP_STREAM_FAST_SKIPPING;
+    stream->fast_skip = true;
     if (len >= 0) {
         stream->seek = seek;
-        stream->end_pos = len;
+        stream->seekable = true;
     }
 
     MP_VERBOSE(stream, "File size is %" PRId64 " bytes\n", len);
diff --git a/stream/stream_lavf.c b/stream/stream_lavf.c
index c9e714fce4..509aaa3e70 100644
--- a/stream/stream_lavf.c
+++ b/stream/stream_lavf.c
@@ -89,8 +89,8 @@ static int control(stream_t *s, int cmd, void *arg)
     switch(cmd) {
     case STREAM_CTRL_GET_SIZE:
         size = avio_size(avio);
-        if(size >= 0) {
-            *(uint64_t *)arg = size;
+        if (size >= 0) {
+            *(int64_t *)arg = size;
             return 1;
         }
         break;
@@ -136,6 +136,9 @@ static int open_f(stream_t *stream, int mode)
     AVDictionary *dict = NULL;
     void *temp = talloc_new(NULL);
 
+    stream->seek = NULL;
+    stream->seekable = false;
+
     if (mode == STREAM_READ)
         flags = AVIO_FLAG_READ;
     else if (mode == STREAM_WRITE)
@@ -161,7 +164,6 @@ static int open_f(stream_t *stream, int mode)
          * this (the rtsp demuxer's probe function checks for a "rtsp:"
          * filename prefix), so it has to be handled specially here.
          */
-        stream->seek = NULL;
         stream->demuxer = "lavf";
         stream->lavf_type = "rtsp";
         talloc_free(temp);
@@ -238,12 +240,8 @@ static int open_f(stream_t *stream, int mode)
         stream->lavf_type = "flv";
     }
     stream->priv = avio;
-    int64_t size = avio_size(avio);
-    if (size >= 0)
-        stream->end_pos = size;
-    stream->seek = seek;
-    if (!avio->seekable)
-        stream->seek = NULL;
+    stream->seekable = avio->seekable;
+    stream->seek = stream->seekable ? seek : NULL;
     stream->fill_buffer = fill_buffer;
     stream->write_buffer = write_buffer;
     stream->control = control;
diff --git a/stream/stream_memory.c b/stream/stream_memory.c
index ff2b42e020..df01d2956e 100644
--- a/stream/stream_memory.c
+++ b/stream/stream_memory.c
@@ -43,11 +43,13 @@ static int control(stream_t *s, int cmd, void *arg)
 {
     struct priv *p = s->priv;
     switch(cmd) {
+    case STREAM_CTRL_GET_SIZE:
+        *(int64_t *)arg = p->data.len;
+        return 1;
     case STREAM_CTRL_SET_CONTENTS: ;
         bstr *data = (bstr *)arg;
         talloc_free(p->data.start);
         p->data = bstrdup(s, *data);
-        s->end_pos = p->data.len;
         return 1;
     }
     return STREAM_UNSUPPORTED;
@@ -57,6 +59,7 @@ static int open_f(stream_t *stream, int mode)
 {
     stream->fill_buffer = fill_buffer;
     stream->seek = seek;
+    stream->seekable = true;
     stream->control = control;
     stream->read_chunk = 1024 * 1024;
 
diff --git a/stream/stream_rar.c b/stream/stream_rar.c
index cae5e02020..24687523e2 100644
--- a/stream/stream_rar.c
+++ b/stream/stream_rar.c
@@ -133,6 +133,7 @@ static int rar_entry_open(stream_t *stream, int mode)
     stream->end_pos = file->size;
     stream->fill_buffer = rar_entry_fill_buffer;
     stream->seek = rar_entry_seek;
+    stream->seekable = true;
     stream->close = rar_entry_close;
     stream->control = rar_entry_control;
 
@@ -190,6 +191,7 @@ static int rar_filter_open(stream_t *stream, int mode)
     stream->end_pos = m->end_pos;
     stream->fill_buffer = rar_filter_fill_buffer;
     stream->seek = rar_filter_seek;
+    stream->seekable = true;
     stream->close = rar_filter_close;
     stream->safe_origin = true;
 
diff --git a/stream/stream_smb.c b/stream/stream_smb.c
index ab32ea0d3a..6b79d072dd 100644
--- a/stream/stream_smb.c
+++ b/stream/stream_smb.c
@@ -45,10 +45,11 @@ static int control(stream_t *s, int cmd, void *arg) {
       off_t size = smbc_lseek(p->fd,0,SEEK_END);
       smbc_lseek(p->fd,s->pos,SEEK_SET);
       if(size != (off_t)-1) {
-        *(uint64_t *)arg = size;
+        *(int64_t *)arg = size;
         return 1;
       }
     }
+    break;
   }
   return STREAM_UNSUPPORTED;
 }
@@ -131,9 +132,8 @@ static int open_f (stream_t *stream, int mode)
     smbc_lseek (fd, 0, SEEK_SET);
   }
   if(len > 0 || mode == STREAM_WRITE) {
-    stream->flags |= MP_STREAM_SEEK;
+    stream->seekable = true;
     stream->seek = seek;
-    if(mode == STREAM_READ) stream->end_pos = len;
   }
   priv->fd = fd;
   stream->fill_buffer = fill_buffer;
diff --git a/stream/stream_vcd.c b/stream/stream_vcd.c
index a61fc04376..23b95cf3c6 100644
--- a/stream/stream_vcd.c
+++ b/stream/stream_vcd.c
@@ -169,6 +169,7 @@ static int open_s(stream_t *stream,int mode)
 
   stream->fill_buffer = fill_buffer;
   stream->seek = seek;
+  stream->seekable = true;
   stream->close = close_s;
   stream->demuxer = "lavf"; // mpegps ( or "vcd"?)