From 34259f11dcabb02eac74feb62589f8295011c7f7 Mon Sep 17 00:00:00 2001 From: wm4 Date: Thu, 17 May 2018 12:40:33 +0200 Subject: stream_file: properly detect stdin as pipe There is some code that checks a FD for whether it is a regular file or not. If it's not a regular file, it e.g. enables use of poll() to avoid blocking forever. But this was done only for FDs that were open()ed by us, not from stdin special handling or fd://. Consequently, " | mpv -" could block the player. Fix this by moving the code and running for it on all FDs. Also, set p->regular_file even on mingw. --- stream/stream_file.c | 33 ++++++++++++++++----------------- 1 file changed, 16 insertions(+), 17 deletions(-) (limited to 'stream') diff --git a/stream/stream_file.c b/stream/stream_file.c index 8778e7e011..2d0e3457c0 100644 --- a/stream/stream_file.c +++ b/stream/stream_file.c @@ -309,7 +309,6 @@ static int open_f(stream_t *stream) openmode |= S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH; if (!write) m |= O_NONBLOCK; - p->use_poll = true; #endif p->fd = open(filename, m | O_BINARY, openmode); if (p->fd < 0) { @@ -317,25 +316,25 @@ static int open_f(stream_t *stream) filename, mp_strerror(errno)); return STREAM_ERROR; } - struct stat st; - if (fstat(p->fd, &st) == 0) { - if (S_ISDIR(st.st_mode)) { - p->use_poll = false; - stream->is_directory = true; - stream->allow_caching = false; - MP_INFO(stream, "This is a directory - adding to playlist.\n"); - } + p->close = true; + } + + struct stat st; + if (fstat(p->fd, &st) == 0) { + if (S_ISDIR(st.st_mode)) { + stream->is_directory = true; + stream->allow_caching = false; + MP_INFO(stream, "This is a directory - adding to playlist.\n"); + } else if (S_ISREG(st.st_mode)) { + p->regular_file = true; #ifndef __MINGW32__ - if (S_ISREG(st.st_mode)) { - p->use_poll = false; - p->regular_file = true; - // O_NONBLOCK has weird semantics on file locks; remove it. - int val = fcntl(p->fd, F_GETFL) & ~(unsigned)O_NONBLOCK; - fcntl(p->fd, F_SETFL, val); - } + // O_NONBLOCK has weird semantics on file locks; remove it. + int val = fcntl(p->fd, F_GETFL) & ~(unsigned)O_NONBLOCK; + fcntl(p->fd, F_SETFL, val); #endif + } else { + p->use_poll = true; } - p->close = true; } #ifdef __MINGW32__ -- cgit v1.2.3 From 31b78ad7fa97d8047b609c1647a273e72612d425 Mon Sep 17 00:00:00 2001 From: wm4 Date: Thu, 17 May 2018 20:58:49 +0200 Subject: misc: move mp_cancel from stream.c to thread_tools.c It seems a bit inappropriate to have dumped this into stream.c, even if it's roughly speaking its main user. At least it made its way somewhat unfortunately to other components not related to the stream or demuxer layer at all. I'm too greedy to give this weird helper its own file, so dump it into thread_tools.c. Probably a somewhat pointless change. --- stream/cache.c | 1 + stream/stream.c | 136 +-------------------------------------------- stream/stream.h | 8 --- stream/stream_file.c | 1 + stream/stream_lavf.c | 1 + stream/stream_libarchive.c | 1 + 6 files changed, 5 insertions(+), 143 deletions(-) (limited to 'stream') diff --git a/stream/cache.c b/stream/cache.c index fb7927f0b1..424f27910f 100644 --- a/stream/cache.c +++ b/stream/cache.c @@ -54,6 +54,7 @@ #include "common/msg.h" #include "common/tags.h" +#include "misc/thread_tools.h" #include "options/options.h" #include "stream.h" diff --git a/stream/stream.c b/stream/stream.c index 4f63236d6a..072672d1ed 100644 --- a/stream/stream.c +++ b/stream/stream.c @@ -17,16 +17,12 @@ #include #include -#include -#include #include -#include #include #include #include -#include "osdep/atomic.h" #include "osdep/io.h" #include "mpv_talloc.h" @@ -36,6 +32,7 @@ #include "common/common.h" #include "common/global.h" #include "misc/bstr.h" +#include "misc/thread_tools.h" #include "common/msg.h" #include "options/options.h" #include "options/path.h" @@ -45,12 +42,6 @@ #include "options/m_option.h" #include "options/m_config.h" -#ifdef __MINGW32__ -#include -#else -#include -#endif - // Includes additional padding in case sizes get rounded up by sector size. #define TOTAL_BUFFER_SIZE (STREAM_MAX_BUFFER_SIZE + STREAM_MAX_SECTOR_SIZE) @@ -842,131 +833,6 @@ struct bstr stream_read_file(const char *filename, void *talloc_ctx, return res; } -#ifndef __MINGW32__ -struct mp_cancel { - atomic_bool triggered; - int wakeup_pipe[2]; -}; - -static void cancel_destroy(void *p) -{ - struct mp_cancel *c = p; - if (c->wakeup_pipe[0] >= 0) { - close(c->wakeup_pipe[0]); - close(c->wakeup_pipe[1]); - } -} - -struct mp_cancel *mp_cancel_new(void *talloc_ctx) -{ - struct mp_cancel *c = talloc_ptrtype(talloc_ctx, c); - talloc_set_destructor(c, cancel_destroy); - *c = (struct mp_cancel){.triggered = ATOMIC_VAR_INIT(false)}; - mp_make_wakeup_pipe(c->wakeup_pipe); - return c; -} - -// Request abort. -void mp_cancel_trigger(struct mp_cancel *c) -{ - atomic_store(&c->triggered, true); - (void)write(c->wakeup_pipe[1], &(char){0}, 1); -} - -// Restore original state. (Allows reusing a mp_cancel.) -void mp_cancel_reset(struct mp_cancel *c) -{ - atomic_store(&c->triggered, false); - // Flush it fully. - while (1) { - int r = read(c->wakeup_pipe[0], &(char[256]){0}, 256); - if (r < 0 && errno == EINTR) - continue; - if (r <= 0) - break; - } -} - -// Return whether the caller should abort. -// For convenience, c==NULL is allowed. -bool mp_cancel_test(struct mp_cancel *c) -{ - return c ? atomic_load_explicit(&c->triggered, memory_order_relaxed) : false; -} - -// Wait until the even is signaled. If the timeout (in seconds) expires, return -// false. timeout==0 polls, timeout<0 waits forever. -bool mp_cancel_wait(struct mp_cancel *c, double timeout) -{ - struct pollfd fd = { .fd = c->wakeup_pipe[0], .events = POLLIN }; - poll(&fd, 1, timeout * 1000); - return fd.revents & POLLIN; -} - -// The FD becomes readable if mp_cancel_test() would return true. -// Don't actually read from it, just use it for poll(). -int mp_cancel_get_fd(struct mp_cancel *c) -{ - return c->wakeup_pipe[0]; -} - -#else - -struct mp_cancel { - atomic_bool triggered; - HANDLE event; -}; - -static void cancel_destroy(void *p) -{ - struct mp_cancel *c = p; - CloseHandle(c->event); -} - -struct mp_cancel *mp_cancel_new(void *talloc_ctx) -{ - struct mp_cancel *c = talloc_ptrtype(talloc_ctx, c); - talloc_set_destructor(c, cancel_destroy); - *c = (struct mp_cancel){.triggered = ATOMIC_VAR_INIT(false)}; - c->event = CreateEventW(NULL, TRUE, FALSE, NULL); - return c; -} - -void mp_cancel_trigger(struct mp_cancel *c) -{ - atomic_store(&c->triggered, true); - SetEvent(c->event); -} - -void mp_cancel_reset(struct mp_cancel *c) -{ - atomic_store(&c->triggered, false); - ResetEvent(c->event); -} - -bool mp_cancel_test(struct mp_cancel *c) -{ - return c ? atomic_load_explicit(&c->triggered, memory_order_relaxed) : false; -} - -bool mp_cancel_wait(struct mp_cancel *c, double timeout) -{ - return WaitForSingleObject(c->event, timeout < 0 ? INFINITE : timeout * 1000) - == WAIT_OBJECT_0; -} - -void *mp_cancel_get_event(struct mp_cancel *c) -{ - return c->event; -} - -int mp_cancel_get_fd(struct mp_cancel *c) -{ - return -1; -} - -#endif - char **stream_get_proto_list(void) { char **list = NULL; diff --git a/stream/stream.h b/stream/stream.h index 3ce74ecd15..863c0cfd3c 100644 --- a/stream/stream.h +++ b/stream/stream.h @@ -254,14 +254,6 @@ stream_t *open_memory_stream(void *data, int len); void mp_url_unescape_inplace(char *buf); char *mp_url_escape(void *talloc_ctx, const char *s, const char *ok); -struct mp_cancel *mp_cancel_new(void *talloc_ctx); -void mp_cancel_trigger(struct mp_cancel *c); -bool mp_cancel_test(struct mp_cancel *c); -bool mp_cancel_wait(struct mp_cancel *c, double timeout); -void mp_cancel_reset(struct mp_cancel *c); -void *mp_cancel_get_event(struct mp_cancel *c); // win32 HANDLE -int mp_cancel_get_fd(struct mp_cancel *c); - // stream_file.c char *mp_file_url_to_filename(void *talloc_ctx, bstr url); char *mp_file_get_path(void *talloc_ctx, bstr url); diff --git a/stream/stream_file.c b/stream/stream_file.c index 2d0e3457c0..73048baefb 100644 --- a/stream/stream_file.c +++ b/stream/stream_file.c @@ -34,6 +34,7 @@ #include "common/common.h" #include "common/msg.h" +#include "misc/thread_tools.h" #include "stream.h" #include "options/m_option.h" #include "options/path.h" diff --git a/stream/stream_lavf.c b/stream/stream_lavf.c index 09866ff74f..fea6f4b62d 100644 --- a/stream/stream_lavf.c +++ b/stream/stream_lavf.c @@ -24,6 +24,7 @@ #include "common/msg.h" #include "common/tags.h" #include "common/av_common.h" +#include "misc/thread_tools.h" #include "stream.h" #include "options/m_config.h" #include "options/m_option.h" diff --git a/stream/stream_libarchive.c b/stream/stream_libarchive.c index bb25c6ad84..d02cb7e630 100644 --- a/stream/stream_libarchive.c +++ b/stream/stream_libarchive.c @@ -20,6 +20,7 @@ #include "misc/bstr.h" #include "common/common.h" +#include "misc/thread_tools.h" #include "stream.h" #include "stream_libarchive.h" -- cgit v1.2.3 From a0cce7f775e97aa364d166c278c49df1325e6cc7 Mon Sep 17 00:00:00 2001 From: wm4 Date: Thu, 17 May 2018 21:45:17 +0200 Subject: stream_file: use a separate mp_cancel thing The intention is to avoid that the parent mp_cancel retains the internally allocated wakeup pipe. File FDs are a relatively scarce resource, so try to avoid having too many. This might matter for subtitle files, for which it is relatively likely that they are loaded in large quantities. demux_lavf.c will close the underlying stream for most subtitle files, and now it will free the wakeup pipe too. Actually, there are currently only 1 or 2 mp_cancel objects per mpv core, but this could change if every external subtitle track gets its own mp_cancel in later commits. --- stream/stream_file.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) (limited to 'stream') diff --git a/stream/stream_file.c b/stream/stream_file.c index 73048baefb..785e96b12c 100644 --- a/stream/stream_file.c +++ b/stream/stream_file.c @@ -65,6 +65,7 @@ struct priv { bool regular_file; bool appending; int64_t orig_size; + struct mp_cancel *cancel; }; // Total timeout = RETRY_TIMEOUT * MAX_RETRIES @@ -85,7 +86,7 @@ static int fill_buffer(stream_t *s, char *buffer, int max_len) #ifndef __MINGW32__ if (p->use_poll) { - int c = s->cancel ? mp_cancel_get_fd(s->cancel) : -1; + int c = mp_cancel_get_fd(p->cancel); struct pollfd fds[2] = { {.fd = p->fd, .events = POLLIN}, {.fd = c, .events = POLLIN}, @@ -112,7 +113,7 @@ static int fill_buffer(stream_t *s, char *buffer, int max_len) if (!p->appending || p->use_poll) break; - if (mp_cancel_wait(s->cancel, RETRY_TIMEOUT)) + if (mp_cancel_wait(p->cancel, RETRY_TIMEOUT)) break; } @@ -160,6 +161,7 @@ static void s_close(stream_t *s) struct priv *p = s->priv; if (p->close) close(p->fd); + talloc_free(p->cancel); } // If url is a file:// URL, return the local filename, otherwise return NULL. @@ -361,6 +363,10 @@ static int open_f(stream_t *stream) p->orig_size = get_size(stream); + p->cancel = mp_cancel_new(p); + if (stream->cancel) + mp_cancel_add_slave(stream->cancel, p->cancel); + return STREAM_OK; } -- cgit v1.2.3 From d7ca95c3ea90782c786a6a607d3713bb42a104b1 Mon Sep 17 00:00:00 2001 From: wm4 Date: Sat, 19 May 2018 12:08:48 +0200 Subject: command: whitelist some blocking accesses for certain demuxers/streams The properties/commands touched in this commit are all for obscure special inputs (BD/DVD/DVB/TV), and they all block on the demuxer/stream layer. For network streams, this blocking is very unwelcome. They will affect playback and probably introduce pauses and frame drops. The player can even freeze fully, and the logic that tries to make playback abortable even if frozen complicates the player. Since the mentioned accesses are not needed for network streams, but they will block on network streams even though they're going to fail, add a flag that coarsely enables/disables these accesses. Essentially it establishes a whitelist of demuxers/streams which support them. In theory you could to access BD/DVD images over network (or add such support, I don't think it's a thing in mpv). In these cases these controls still can block and could even "freeze" the player completely. Writing to the "program" and "cache-size" properties still can block even for network streams. Just don't use them if you don't want freezes. --- stream/stream.h | 1 + stream/stream_dvb.c | 1 + 2 files changed, 2 insertions(+) (limited to 'stream') diff --git a/stream/stream.h b/stream/stream.h index 863c0cfd3c..2f59e5318f 100644 --- a/stream/stream.h +++ b/stream/stream.h @@ -184,6 +184,7 @@ typedef struct stream { bool is_local_file : 1; // from the filesystem bool is_directory : 1; // directory on the filesystem bool access_references : 1; // open other streams + bool extended_ctrls : 1; // supports some of BD/DVD/DVB/TV controls struct mp_log *log; struct mpv_global *global; diff --git a/stream/stream_dvb.c b/stream/stream_dvb.c index 02c5878ca9..9821119cac 100644 --- a/stream/stream_dvb.c +++ b/stream/stream_dvb.c @@ -1120,6 +1120,7 @@ static int dvb_open(stream_t *stream) stream->allow_caching = true; stream->demuxer = "lavf"; stream->lavf_type = "mpegts"; + stream->extended_ctrls = true; return STREAM_OK; -- cgit v1.2.3 From 29a51900c6047798244afaca271618caeeeeeee8 Mon Sep 17 00:00:00 2001 From: wm4 Date: Sat, 19 May 2018 17:06:00 +0200 Subject: player: some further cleanup of the mp_cancel crap Alway give each demuxer its own mp_cancel instance. This makes management of the mp_cancel things much easier. Also, instead of having add/remove functions for mp_cancel slaves, replace them with a simpler to use set_parent function. Remove cancel_and_free_demuxer(), which had mpctx as parameter only to check an assumption. With this commit, demuxers have their own mp_cancel, so add demux_cancel_and_free() which makes use of it. --- stream/stream_file.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'stream') diff --git a/stream/stream_file.c b/stream/stream_file.c index 785e96b12c..20b4d7c0c3 100644 --- a/stream/stream_file.c +++ b/stream/stream_file.c @@ -365,7 +365,7 @@ static int open_f(stream_t *stream) p->cancel = mp_cancel_new(p); if (stream->cancel) - mp_cancel_add_slave(stream->cancel, p->cancel); + mp_cancel_set_parent(p->cancel, stream->cancel); return STREAM_OK; } -- cgit v1.2.3 From b2e24f42d557536305c4f8624e1d568d9c26b6af Mon Sep 17 00:00:00 2001 From: wm4 Date: Tue, 22 May 2018 18:59:59 +0200 Subject: options: add --http-proxy Often requested, trivial. --- stream/stream_lavf.c | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'stream') diff --git a/stream/stream_lavf.c b/stream/stream_lavf.c index fea6f4b62d..9470d3d527 100644 --- a/stream/stream_lavf.c +++ b/stream/stream_lavf.c @@ -47,6 +47,7 @@ struct stream_lavf_params { char *tls_cert_file; char *tls_key_file; double timeout; + char *http_proxy; }; const struct m_sub_options stream_lavf_conf = { @@ -62,6 +63,7 @@ const struct m_sub_options stream_lavf_conf = { OPT_STRING("tls-cert-file", tls_cert_file, M_OPT_FILE), OPT_STRING("tls-key-file", tls_key_file, M_OPT_FILE), OPT_DOUBLE("network-timeout", timeout, M_OPT_MIN, .min = 0), + OPT_STRING("http-proxy", http_proxy, 0), {0} }, .size = sizeof(struct stream_lavf_params), @@ -225,6 +227,8 @@ void mp_setup_av_network_options(AVDictionary **dict, struct mpv_global *global, snprintf(buf, sizeof(buf), "%lld", (long long)(opts->timeout * 1e6)); av_dict_set(dict, "timeout", buf, 0); } + if (opts->http_proxy && opts->http_proxy[0]) + av_dict_set(dict, "http_proxy", opts->http_proxy, 0); mp_set_avdict(dict, opts->avopts); -- cgit v1.2.3 From 559a400ac36e75a8d73ba263fd7fa6736df1c2da Mon Sep 17 00:00:00 2001 From: wm4 Date: Fri, 31 Aug 2018 12:48:36 +0200 Subject: demux, stream: rip out the classic stream cache The demuxer cache is the only cache now. Might need another change to combat seeking failures in mp4 etc. The only bad thing is the loss of cache-speed, which was sort of nice to have. --- stream/cache.c | 809 ----------------------------------------------- stream/cache_file.c | 158 --------- stream/stream.c | 97 ------ stream/stream.h | 27 -- stream/stream_avdevice.c | 1 - stream/stream_dvb.c | 1 - stream/stream_dvdnav.c | 1 - stream/stream_edl.c | 1 - stream/stream_file.c | 1 - stream/stream_memory.c | 1 - stream/stream_mf.c | 1 - stream/stream_tv.c | 1 - 12 files changed, 1099 deletions(-) delete mode 100644 stream/cache.c delete mode 100644 stream/cache_file.c (limited to 'stream') diff --git a/stream/cache.c b/stream/cache.c deleted file mode 100644 index 424f27910f..0000000000 --- a/stream/cache.c +++ /dev/null @@ -1,809 +0,0 @@ -/* - * This file is part of mpv. - * - * mpv is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 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 Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with mpv. If not, see . - */ - -// Time in seconds the main thread waits for the cache thread. On wakeups, the -// code checks for user requested aborts and also prints warnings that the -// cache is being slow. -#define CACHE_WAIT_TIME 1.0 - -// The time the cache sleeps in idle mode. This controls how often the cache -// retries reading from the stream after EOF has reached (in case the stream is -// actually readable again, for example if data has been appended to a file). -// Note that if this timeout is too low, the player will waste too much CPU -// when player is paused. -#define CACHE_IDLE_SLEEP_TIME 1.0 - -// Time in seconds the cache updates "cached" controls. Note that idle mode -// will block the cache from doing this, and this timeout is honored only if -// the cache is active. -#define CACHE_UPDATE_CONTROLS_TIME 2.0 - - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include - -#include "config.h" - -#include "osdep/timer.h" -#include "osdep/threads.h" - -#include "common/msg.h" -#include "common/tags.h" -#include "misc/thread_tools.h" -#include "options/options.h" - -#include "stream.h" -#include "common/common.h" - -#define OPT_BASE_STRUCT struct mp_cache_opts - -const struct m_sub_options stream_cache_conf = { - .opts = (const struct m_option[]){ - OPT_CHOICE_OR_INT("cache", size, 0, 32, 0x7fffffff, - ({"no", 0}, - {"auto", -1}, - {"yes", -2})), - OPT_CHOICE_OR_INT("cache-default", def_size, 0, 32, 0x7fffffff, - ({"no", 0})), - OPT_INTRANGE("cache-initial", initial, 0, 0, 0x7fffffff), - OPT_INTRANGE("cache-seek-min", seek_min, 0, 0, 0x7fffffff), - OPT_INTRANGE("cache-backbuffer", back_buffer, 0, 0, 0x7fffffff), - OPT_STRING("cache-file", file, M_OPT_FILE), - OPT_INTRANGE("cache-file-size", file_max, 0, 0, 0x7fffffff), - {0} - }, - .size = sizeof(struct mp_cache_opts), - .defaults = &(const struct mp_cache_opts){ - .size = -1, - .def_size = 10000, - .initial = 0, - .seek_min = 500, - .back_buffer = 10000, - .file_max = 1024 * 1024, - }, -}; - -// Note: (struct priv*)(cache->priv)->cache == cache -struct priv { - pthread_t cache_thread; - bool cache_thread_running; - pthread_mutex_t mutex; - pthread_cond_t wakeup; - - // Constants (as long as cache thread is running) - // Some of these might actually be changed by a synced cache resize. - unsigned char *buffer; // base pointer of the allocated buffer memory - int64_t buffer_size; // size of the allocated buffer memory - int64_t back_size; // keep back_size amount of old bytes for backward seek - int64_t seek_limit; // keep filling cache if distance is less that seek limit - bool seekable; // underlying stream is seekable - - struct mp_log *log; - - // Owned by the main thread - stream_t *cache; // wrapper stream, used by demuxer etc. - - // Owned by the cache thread - stream_t *stream; // "real" stream, used to read from the source media - int64_t bytes_until_wakeup; // wakeup cache thread after this many bytes - - // All the following members are shared between the threads. - // You must lock the mutex to access them. - - // Ringbuffer - int64_t min_filepos; // range of file that is cached in the buffer - int64_t max_filepos; // ... max_filepos being the last read position - bool eof; // true if max_filepos = EOF - int64_t offset; // buffer[WRAP(s->max_filepos - offset)] corresponds - // to the byte at max_filepos (must be wrapped by - // buffer_size) - - bool idle; // cache thread has stopped reading - int64_t reads; // number of actual read attempts performed - int64_t speed_start; // start time (us) for calculating download speed - int64_t speed_amount; // bytes read since speed_start - double speed; - - bool enable_readahead; // actively read beyond read() position - int64_t read_filepos; // client read position (mirrors cache->pos) - int64_t read_min; // file position until which the thread should - // read even if readahead is disabled - - int64_t eof_pos; - - bool read_seek_failed; // let a read fail because an async seek failed - - int control; // requested STREAM_CTRL_... or CACHE_CTRL_... - void *control_arg; // temporary for executing STREAM_CTRLs - int control_res; - bool control_flush; - - // Cached STREAM_CTRLs - double stream_time_length; - int64_t stream_size; - struct mp_tags *stream_metadata; - double start_pts; - bool has_avseek; -}; - -enum { - CACHE_CTRL_NONE = 0, - CACHE_CTRL_QUIT = -1, - CACHE_CTRL_PING = -2, - CACHE_CTRL_SEEK = -3, - - // we should fill buffer only if space>=FILL_LIMIT - FILL_LIMIT = 16 * 1024, -}; - -// Used by the main thread to wakeup the cache thread, and to wait for the -// cache thread. The cache mutex has to be locked when calling this function. -// *retry_time should be set to 0 on the first call. -// Return false if the stream has been aborted. -static bool cache_wakeup_and_wait(struct priv *s, double *retry_time) -{ - double start = mp_time_sec(); - if (*retry_time >= CACHE_WAIT_TIME) { - MP_VERBOSE(s, "Cache is not responding - slow/stuck network connection?\n"); - *retry_time = -1; // do not warn again for this call - } - - pthread_cond_signal(&s->wakeup); - struct timespec ts = mp_rel_time_to_timespec(CACHE_WAIT_TIME); - pthread_cond_timedwait(&s->wakeup, &s->mutex, &ts); - - if (*retry_time >= 0) - *retry_time += mp_time_sec() - start; - - return !mp_cancel_test(s->cache->cancel); -} - -// Runs in the cache thread -static void cache_drop_contents(struct priv *s) -{ - s->offset = s->min_filepos = s->max_filepos = s->read_filepos; - s->eof = false; - s->start_pts = MP_NOPTS_VALUE; -} - -static void update_speed(struct priv *s) -{ - int64_t now = mp_time_us(); - if (s->speed_start + 1000000 <= now) { - s->speed = s->speed_amount * 1e6 / (now - s->speed_start); - s->speed_amount = 0; - s->speed_start = now; - } -} - -// Copy at most dst_size from the cache at the given absolute file position pos. -// Return number of bytes that could actually be read. -// Does not advance the file position, or change anything else. -// Can be called from anywhere, as long as the mutex is held. -static size_t read_buffer(struct priv *s, unsigned char *dst, - size_t dst_size, int64_t pos) -{ - size_t read = 0; - while (read < dst_size) { - if (pos >= s->max_filepos || pos < s->min_filepos) - break; - int64_t newb = s->max_filepos - pos; // new bytes in the buffer - - int64_t bpos = pos - s->offset; // file pos to buffer memory pos - if (bpos < 0) { - bpos += s->buffer_size; - } else if (bpos >= s->buffer_size) { - bpos -= s->buffer_size; - } - - if (newb > s->buffer_size - bpos) - newb = s->buffer_size - bpos; // handle wrap... - - newb = MPMIN(newb, dst_size - read); - - assert(newb >= 0 && read + newb <= dst_size); - assert(bpos >= 0 && bpos + newb <= s->buffer_size); - memcpy(&dst[read], &s->buffer[bpos], newb); - read += newb; - pos += newb; - } - return read; -} - -// Whether a seek will be needed to get to the position. This honors seek_limit, -// which is a heuristic to prevent dropping the cache with small forward seeks. -// This helps in situations where waiting for network a bit longer would quickly -// reach the target position. Especially if the demuxer seeks back and forth, -// not dropping the backwards cache will be a major performance win. -static bool needs_seek(struct priv *s, int64_t pos) -{ - return pos < s->min_filepos || pos > s->max_filepos + s->seek_limit; -} - -static bool cache_update_stream_position(struct priv *s) -{ - int64_t read = s->read_filepos; - - s->read_seek_failed = false; - - if (needs_seek(s, read)) { - MP_VERBOSE(s, "Dropping cache at pos %"PRId64", " - "cached range: %"PRId64"-%"PRId64".\n", read, - s->min_filepos, s->max_filepos); - cache_drop_contents(s); - } - - if (stream_tell(s->stream) != s->max_filepos && s->seekable) { - MP_VERBOSE(s, "Seeking underlying stream: %"PRId64" -> %"PRId64"\n", - stream_tell(s->stream), s->max_filepos); - if (!stream_seek(s->stream, s->max_filepos)) { - s->read_seek_failed = true; - return false; - } - } - - return stream_tell(s->stream) == s->max_filepos; -} - -// Runs in the cache thread. -static void cache_fill(struct priv *s) -{ - int64_t read = s->read_filepos; - bool read_attempted = false; - int len = 0; - - if (!cache_update_stream_position(s)) - goto done; - - if (!s->enable_readahead && s->read_min <= s->max_filepos) - goto done; - - if (mp_cancel_test(s->cache->cancel)) - goto done; - - // number of buffer bytes which should be preserved in backwards direction - int64_t back = MPCLAMP(read - s->min_filepos, 0, s->back_size); - - // limit maximum readahead so that the backbuffer space is reserved, even - // if the backbuffer is not used. limit it to ensure that we don't stall the - // network when starting a file, or we wouldn't download new data until we - // get new free space again. (unless everything fits in the cache.) - if (s->stream_size > s->buffer_size) - back = MPMAX(back, s->back_size); - - // number of buffer bytes that are valid and can be read - int64_t newb = FFMAX(s->max_filepos - read, 0); - - // max. number of bytes that can be written (starting from max_filepos) - int64_t space = s->buffer_size - (newb + back); - - // offset into the buffer that maps to max_filepos - int64_t pos = s->max_filepos - s->offset; - if (pos >= s->buffer_size) - pos -= s->buffer_size; // wrap-around - - if (space < FILL_LIMIT) - goto done; - - // limit to end of buffer (without wrapping) - if (pos + space >= s->buffer_size) - space = s->buffer_size - pos; - - // limit read size (or else would block and read the entire buffer in 1 call) - space = FFMIN(space, s->stream->read_chunk); - - // back+newb+space <= buffer_size - int64_t back2 = s->buffer_size - (space + newb); // max back size - if (s->min_filepos < (read - back2)) - s->min_filepos = read - back2; - - // The read call might take a long time and block, so drop the lock. - pthread_mutex_unlock(&s->mutex); - len = stream_read_partial(s->stream, &s->buffer[pos], space); - pthread_mutex_lock(&s->mutex); - - // Do this after reading a block, because at least libdvdnav updates the - // stream position only after actually reading something after a seek. - if (s->start_pts == MP_NOPTS_VALUE) { - double pts; - if (stream_control(s->stream, STREAM_CTRL_GET_CURRENT_TIME, &pts) > 0) - s->start_pts = pts; - } - - s->max_filepos += len; - if (pos + len == s->buffer_size) - s->offset += s->buffer_size; // wrap... - s->speed_amount += len; - - read_attempted = true; - -done: ; - - bool prev_eof = s->eof; - if (read_attempted) - s->eof = len <= 0; - if (!prev_eof && s->eof) { - s->eof_pos = stream_tell(s->stream); - MP_VERBOSE(s, "EOF reached.\n"); - } - s->idle = s->eof || !read_attempted; - s->reads++; - - update_speed(s); - - pthread_cond_signal(&s->wakeup); -} - -// This is called both during init and at runtime. -// The size argument is the readahead half only; s->back_size is the backbuffer. -static int resize_cache(struct priv *s, int64_t size) -{ - int64_t min_size = FILL_LIMIT * 2; - int64_t max_size = ((size_t)-1) / 8; - - if (s->stream_size > 0) { - size = MPMIN(size, s->stream_size); - if (size >= s->stream_size) { - MP_VERBOSE(s, "no backbuffer needed\n"); - s->back_size = 0; - } - } - - int64_t buffer_size = MPCLAMP(size, min_size, max_size); - s->back_size = MPCLAMP(s->back_size, min_size, max_size); - buffer_size += s->back_size; - - unsigned char *buffer = malloc(buffer_size); - if (!buffer) - return STREAM_ERROR; - - if (s->buffer) { - // Copy & free the old ringbuffer data. - // If the buffer is too small, prefer to copy these regions: - // 1. Data starting from read_filepos, until cache end - size_t read_1 = read_buffer(s, buffer, buffer_size, s->read_filepos); - // 2. then data from before read_filepos until cache start - // (this one needs to be copied to the end of the ringbuffer) - size_t read_2 = 0; - if (s->min_filepos < s->read_filepos) { - size_t copy_len = buffer_size - read_1; - copy_len = MPMIN(copy_len, s->read_filepos - s->min_filepos); - assert(copy_len + read_1 <= buffer_size); - read_2 = read_buffer(s, buffer + buffer_size - copy_len, copy_len, - s->read_filepos - copy_len); - // This shouldn't happen, unless copy_len was computed incorrectly. - assert(read_2 == copy_len); - } - // Set it up such that read_1 is at buffer pos 0, and read_2 wraps - // around below it, so that it is located at the end of the buffer. - s->min_filepos = s->read_filepos - read_2; - s->max_filepos = s->read_filepos + read_1; - s->offset = s->max_filepos - read_1; - } else { - cache_drop_contents(s); - } - - free(s->buffer); - - s->buffer_size = buffer_size; - s->buffer = buffer; - s->idle = false; - s->eof = false; - - //make sure that we won't wait from cache_fill - //more data than it is allowed to fill - if (s->seek_limit > s->buffer_size - FILL_LIMIT) - s->seek_limit = s->buffer_size - FILL_LIMIT; - - MP_VERBOSE(s, "Cache size set to %lld KiB (%lld KiB backbuffer)\n", - (long long)(s->buffer_size / 1024), - (long long)(s->back_size / 1024)); - - assert(s->back_size < s->buffer_size); - - return STREAM_OK; -} - -static void update_cached_controls(struct priv *s) -{ - int64_t i64; - double d; - struct mp_tags *tags; - s->stream_time_length = 0; - if (stream_control(s->stream, STREAM_CTRL_GET_TIME_LENGTH, &d) == STREAM_OK) - s->stream_time_length = d; - if (stream_control(s->stream, STREAM_CTRL_GET_METADATA, &tags) == STREAM_OK) { - talloc_free(s->stream_metadata); - s->stream_metadata = talloc_steal(s, tags); - } - s->stream_size = s->eof_pos; - i64 = stream_get_size(s->stream); - if (i64 >= 0) - s->stream_size = i64; - s->has_avseek = stream_control(s->stream, STREAM_CTRL_HAS_AVSEEK, NULL) > 0; -} - -// the core might call these every frame, so cache them... -static int cache_get_cached_control(stream_t *cache, int cmd, void *arg) -{ - struct priv *s = cache->priv; - switch (cmd) { - case STREAM_CTRL_GET_CACHE_INFO: - *(struct stream_cache_info *)arg = (struct stream_cache_info) { - .size = s->buffer_size - s->back_size, - .fill = s->max_filepos - s->read_filepos, - .idle = s->idle, - .speed = llrint(s->speed), - }; - return STREAM_OK; - case STREAM_CTRL_SET_READAHEAD: - s->enable_readahead = *(int *)arg; - pthread_cond_signal(&s->wakeup); - return STREAM_OK; - case STREAM_CTRL_GET_TIME_LENGTH: - *(double *)arg = s->stream_time_length; - return s->stream_time_length ? STREAM_OK : STREAM_UNSUPPORTED; - 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_GET_CURRENT_TIME: { - if (s->start_pts == MP_NOPTS_VALUE) - return STREAM_UNSUPPORTED; - *(double *)arg = s->start_pts; - return STREAM_OK; - } - case STREAM_CTRL_HAS_AVSEEK: - return s->has_avseek ? STREAM_OK : STREAM_UNSUPPORTED; - case STREAM_CTRL_GET_METADATA: { - if (s->stream_metadata) { - ta_set_parent(s->stream_metadata, NULL); - *(struct mp_tags **)arg = s->stream_metadata; - s->stream_metadata = NULL; - return STREAM_OK; - } - return STREAM_UNSUPPORTED; - } - case STREAM_CTRL_AVSEEK: - if (!s->has_avseek) - return STREAM_UNSUPPORTED; - break; - } - return STREAM_ERROR; -} - -static bool control_needs_flush(int stream_ctrl) -{ - switch (stream_ctrl) { - case STREAM_CTRL_SEEK_TO_TIME: - case STREAM_CTRL_AVSEEK: - case STREAM_CTRL_SET_ANGLE: - case STREAM_CTRL_SET_CURRENT_TITLE: - case STREAM_CTRL_DVB_SET_CHANNEL: - case STREAM_CTRL_DVB_SET_CHANNEL_NAME: - case STREAM_CTRL_DVB_STEP_CHANNEL: - return true; - } - return false; -} - -// Runs in the cache thread -static void cache_execute_control(struct priv *s) -{ - uint64_t old_pos = stream_tell(s->stream); - s->control_flush = false; - - switch (s->control) { - case STREAM_CTRL_SET_CACHE_SIZE: - s->control_res = resize_cache(s, *(int64_t *)s->control_arg); - break; - default: - s->control_res = stream_control(s->stream, s->control, s->control_arg); - } - - bool pos_changed = old_pos != stream_tell(s->stream); - bool ok = s->control_res == STREAM_OK; - if (pos_changed && !ok) { - MP_ERR(s, "STREAM_CTRL changed stream pos but " - "returned error, this is not allowed!\n"); - } else if (pos_changed || (ok && control_needs_flush(s->control))) { - MP_VERBOSE(s, "Dropping cache due to control()\n"); - s->read_filepos = stream_tell(s->stream); - s->read_min = s->read_filepos; - s->control_flush = true; - cache_drop_contents(s); - } - - update_cached_controls(s); - s->control = CACHE_CTRL_NONE; - pthread_cond_signal(&s->wakeup); -} - -static void *cache_thread(void *arg) -{ - struct priv *s = arg; - mpthread_set_name("cache"); - pthread_mutex_lock(&s->mutex); - update_cached_controls(s); - double last = mp_time_sec(); - while (s->control != CACHE_CTRL_QUIT) { - if (mp_time_sec() - last > CACHE_UPDATE_CONTROLS_TIME) { - update_cached_controls(s); - last = mp_time_sec(); - } - if (s->control > 0) { - cache_execute_control(s); - } else if (s->control == CACHE_CTRL_SEEK) { - s->control_res = cache_update_stream_position(s); - s->control = CACHE_CTRL_NONE; - pthread_cond_signal(&s->wakeup); - } else { - cache_fill(s); - } - if (s->control == CACHE_CTRL_PING) { - pthread_cond_signal(&s->wakeup); - s->control = CACHE_CTRL_NONE; - } - if (s->idle && s->control == CACHE_CTRL_NONE) { - struct timespec ts = mp_rel_time_to_timespec(CACHE_IDLE_SLEEP_TIME); - pthread_cond_timedwait(&s->wakeup, &s->mutex, &ts); - } - } - pthread_cond_signal(&s->wakeup); - pthread_mutex_unlock(&s->mutex); - MP_VERBOSE(s, "Cache exiting...\n"); - return NULL; -} - -static int cache_fill_buffer(struct stream *cache, char *buffer, int max_len) -{ - struct priv *s = cache->priv; - assert(s->cache_thread_running); - - pthread_mutex_lock(&s->mutex); - - if (cache->pos != s->read_filepos) - MP_ERR(s, "!!! read_filepos differs !!! report this bug...\n"); - - int readb = 0; - if (max_len > 0) { - double retry_time = 0; - int64_t retry = s->reads - 1; // try at least 1 read on EOF - while (1) { - s->read_min = s->read_filepos + max_len + 64 * 1024; - readb = read_buffer(s, buffer, max_len, s->read_filepos); - s->read_filepos += readb; - if (readb > 0) - break; - if (s->eof && s->read_filepos >= s->max_filepos && s->reads >= retry) - break; - s->idle = false; - if (!cache_wakeup_and_wait(s, &retry_time)) - break; - if (s->read_seek_failed) { - MP_ERR(s, "error reading after async seek failed\n"); - s->read_seek_failed = false; - break; - } - } - } - - if (!s->eof) { - // wakeup the cache thread, possibly make it read more data ahead - // this is throttled to reduce excessive wakeups during normal reading - // (using the amount of bytes after which the cache thread most likely - // can actually read new data) - s->bytes_until_wakeup -= readb; - if (s->bytes_until_wakeup <= 0) { - s->bytes_until_wakeup = MPMAX(FILL_LIMIT, s->stream->read_chunk); - pthread_cond_signal(&s->wakeup); - } - } - pthread_mutex_unlock(&s->mutex); - return readb; -} - -static int cache_seek(stream_t *cache, int64_t pos) -{ - struct priv *s = cache->priv; - assert(s->cache_thread_running); - int r = 1; - - pthread_mutex_lock(&s->mutex); - - MP_DBG(s, "request seek: %" PRId64 " <= to=%" PRId64 - " (cur=%" PRId64 ") <= %" PRId64 " \n", - s->min_filepos, pos, s->read_filepos, s->max_filepos); - - if (!s->seekable && pos > s->max_filepos) { - MP_ERR(s, "Attempting to seek past cached data in unseekable stream.\n"); - r = 0; - } else if (!s->seekable && pos < s->min_filepos) { - MP_ERR(s, "Attempting to seek before cached data in unseekable stream.\n"); - r = 0; - } else { - cache->pos = s->read_filepos = s->read_min = pos; - // Is this seek likely to cause a stream-level seek? - // If it is, wait until that is complete and return its result. - // This check is not quite exact - if the reader thread is blocked in - // a read, the read might advance file position enough that a seek - // forward is no longer needed. - if (needs_seek(s, pos)) { - s->eof = false; - s->control = CACHE_CTRL_SEEK; - s->control_res = 0; - double retry = 0; - while (s->control != CACHE_CTRL_NONE) { - if (!cache_wakeup_and_wait(s, &retry)) - break; - } - r = s->control_res; - } else { - pthread_cond_signal(&s->wakeup); - r = 1; - } - } - - s->bytes_until_wakeup = 0; - - pthread_mutex_unlock(&s->mutex); - - return r; -} - -static int cache_control(stream_t *cache, int cmd, void *arg) -{ - struct priv *s = cache->priv; - int r = STREAM_ERROR; - - assert(cmd > 0); - - pthread_mutex_lock(&s->mutex); - - r = cache_get_cached_control(cache, cmd, arg); - if (r != STREAM_ERROR) - goto done; - - MP_VERBOSE(s, "blocking for STREAM_CTRL %d\n", cmd); - - s->control = cmd; - s->control_arg = arg; - double retry = 0; - while (s->control != CACHE_CTRL_NONE) { - if (!cache_wakeup_and_wait(s, &retry)) { - s->eof = 1; - r = STREAM_UNSUPPORTED; - goto done; - } - } - r = s->control_res; - if (s->control_flush) { - stream_drop_buffers(cache); - cache->pos = s->read_filepos; - } - -done: - pthread_mutex_unlock(&s->mutex); - return r; -} - -static void cache_uninit(stream_t *cache) -{ - struct priv *s = cache->priv; - if (s->cache_thread_running) { - MP_VERBOSE(s, "Terminating cache...\n"); - pthread_mutex_lock(&s->mutex); - s->control = CACHE_CTRL_QUIT; - pthread_cond_signal(&s->wakeup); - pthread_mutex_unlock(&s->mutex); - pthread_join(s->cache_thread, NULL); - } - pthread_mutex_destroy(&s->mutex); - pthread_cond_destroy(&s->wakeup); - free(s->buffer); - talloc_free(s); -} - -// return 1 on success, 0 if the cache is disabled/not needed, and -1 on error -// or if the cache is disabled -int stream_cache_init(stream_t *cache, stream_t *stream, - struct mp_cache_opts *opts) -{ - if (opts->size < 1) - return 0; - - struct priv *s = talloc_zero(NULL, struct priv); - s->log = cache->log; - s->eof_pos = -1; - s->enable_readahead = true; - - cache_drop_contents(s); - - s->speed_start = mp_time_us(); - - s->seek_limit = opts->seek_min * 1024ULL; - s->back_size = opts->back_buffer * 1024ULL; - - s->stream_size = stream_get_size(stream); - - if (resize_cache(s, opts->size * 1024ULL) != STREAM_OK) { - MP_ERR(s, "Failed to allocate cache buffer.\n"); - talloc_free(s); - return -1; - } - - pthread_mutex_init(&s->mutex, NULL); - pthread_cond_init(&s->wakeup, NULL); - - cache->priv = s; - s->cache = cache; - s->stream = stream; - - cache->seek = cache_seek; - cache->fill_buffer = cache_fill_buffer; - cache->control = cache_control; - cache->close = cache_uninit; - - int64_t min = opts->initial * 1024ULL; - if (min > s->buffer_size - FILL_LIMIT) - min = s->buffer_size - FILL_LIMIT; - - s->seekable = stream->seekable; - - if (pthread_create(&s->cache_thread, NULL, cache_thread, s) != 0) { - MP_ERR(s, "Starting cache thread failed.\n"); - return -1; - } - s->cache_thread_running = true; - - // wait until cache is filled with at least min bytes - if (min < 1) - return 1; - for (;;) { - if (mp_cancel_test(cache->cancel)) - return -1; - struct stream_cache_info info; - if (stream_control(s->cache, STREAM_CTRL_GET_CACHE_INFO, &info) < 0) - break; - mp_msg(s->log, MSGL_STATUS, "Cache fill: %5.2f%% " - "(%" PRId64 " bytes)", 100.0 * info.fill / s->buffer_size, - info.fill); - if (info.fill >= min) - break; - if (info.idle) - break; // file is smaller than prefill size - // Wake up if the cache is done reading some data (or on timeout/abort) - pthread_mutex_lock(&s->mutex); - s->control = CACHE_CTRL_PING; - pthread_cond_signal(&s->wakeup); - cache_wakeup_and_wait(s, &(double){0}); - pthread_mutex_unlock(&s->mutex); - } - return 1; -} diff --git a/stream/cache_file.c b/stream/cache_file.c deleted file mode 100644 index 4cf7060e83..0000000000 --- a/stream/cache_file.c +++ /dev/null @@ -1,158 +0,0 @@ -/* - * This file is part of mpv. - * - * mpv is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 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 Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with mpv. If not, see . - */ - -#include -#include - -#include "osdep/io.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 = stream_get_size(s); - if (p->size >= 0 && 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 - if (p->size >= 0) - 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; - - if (!stream->seekable) { - MP_ERR(cache, "can't cache unseekable stream\n"); - return -1; - } - - bool use_anon_file = strcmp(opts->file, "TMP") == 0; - FILE *file = use_anon_file ? tmpfile() : 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 072672d1ed..7d093e1913 100644 --- a/stream/stream.c +++ b/stream/stream.c @@ -229,7 +229,6 @@ static int open_internal(const stream_info_t *sinfo, const char *url, int flags, s->global = global; s->url = talloc_strdup(s, url); s->path = talloc_strdup(s, path); - s->allow_caching = true; s->is_network = sinfo->is_network; s->mode = flags & (STREAM_READ | STREAM_WRITE); @@ -256,9 +255,6 @@ static int open_internal(const stream_info_t *sinfo, const char *url, int flags, if (!s->read_chunk) s->read_chunk = 4 * (s->sector_size ? s->sector_size : STREAM_BUFFER_SIZE); - if (!s->fill_buffer) - s->allow_caching = false; - assert(s->seekable == !!s->seek); if (s->mime_type) @@ -581,7 +577,6 @@ void free_stream(stream_t *s) if (s->close) s->close(s); - free_stream(s->underlying); talloc_free(s); } @@ -597,98 +592,6 @@ 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->underlying = orig; - cache->caching = true; - 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->streaming = orig->streaming, - cache->is_network = orig->is_network; - cache->is_local_file = orig->is_local_file; - cache->is_directory = orig->is_directory; - cache->cancel = orig->cancel; - 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) -{ - struct mp_cache_opts use_opts = *opts; - if (use_opts.size == -1) - use_opts.size = stream->streaming ? use_opts.def_size : 0; - if (use_opts.size == -2) - use_opts.size = use_opts.def_size; - - if (stream->mode != STREAM_READ || !stream->allow_caching || use_opts.size < 1) - use_opts.size = 0; - return use_opts; -} - -bool stream_wants_cache(stream_t *stream, struct mp_cache_opts *opts) -{ - struct mp_cache_opts use_opts = check_cache_opts(stream, opts); - return use_opts.size > 0; -} - -// return 1 on success, 0 if the cache is disabled/not needed, and -1 on error -// or if the cache is disabled -static int stream_enable_cache(stream_t **stream, struct mp_cache_opts *opts) -{ - stream_t *orig = *stream; - struct mp_cache_opts use_opts = check_cache_opts(*stream, opts); - - if (use_opts.size < 1) - return 0; - - stream_t *fcache = open_cache(orig, "file-cache"); - if (stream_file_cache_init(fcache, orig, &use_opts) <= 0) { - fcache->underlying = NULL; // don't free original stream - free_stream(fcache); - fcache = orig; - } - - stream_t *cache = open_cache(fcache, "cache"); - - int res = stream_cache_init(cache, fcache, &use_opts); - if (res <= 0) { - cache->underlying = NULL; // don't free original stream - free_stream(cache); - if (fcache != orig) { - fcache->underlying = NULL; - free_stream(fcache); - } - } else { - *stream = cache; - } - return res; -} - -// Do some crazy stuff to call stream_enable_cache() with the global options. -int stream_enable_cache_defaults(stream_t **stream) -{ - struct mpv_global *global = (*stream)->global; - if (!global) - return 0; - void *tmp = talloc_new(NULL); - struct mp_cache_opts *opts = - mp_get_config_group(tmp, global, &stream_cache_conf); - int r = stream_enable_cache(stream, opts); - talloc_free(tmp); - return r; -} - static uint16_t stream_read_word_endian(stream_t *s, bool big_endian) { unsigned int y = stream_read_char(s); diff --git a/stream/stream.h b/stream/stream.h index 2f59e5318f..c91843de8a 100644 --- a/stream/stream.h +++ b/stream/stream.h @@ -52,11 +52,6 @@ enum stream_ctrl { STREAM_CTRL_GET_SIZE = 1, - // Cache - STREAM_CTRL_GET_CACHE_INFO, - STREAM_CTRL_SET_CACHE_SIZE, - STREAM_CTRL_SET_READAHEAD, - // stream_memory.c STREAM_CTRL_SET_CONTENTS, @@ -104,14 +99,6 @@ enum stream_ctrl { STREAM_CTRL_SET_CURRENT_TITLE, }; -// for STREAM_CTRL_GET_CACHE_INFO -struct stream_cache_info { - int64_t size; - int64_t fill; - bool idle; - int64_t speed; -}; - struct stream_lang_req { int type; // STREAM_AUDIO, STREAM_SUB int id; @@ -179,8 +166,6 @@ typedef struct stream { bool seekable : 1; // presence of general byte seeking support bool fast_skip : 1; // consider stream fast enough to fw-seek by skipping bool is_network : 1; // original stream_info_t.is_network flag - bool allow_caching : 1; // stream cache makes sense - bool caching : 1; // is a cache, or accesses a cache bool is_local_file : 1; // from the filesystem bool is_directory : 1; // directory on the filesystem bool access_references : 1; // open other streams @@ -190,24 +175,12 @@ typedef struct stream { struct mp_cancel *cancel; // cancellation notification - struct stream *underlying; // e.g. cache wrapper - // Includes additional padding in case sizes get rounded up by sector size. unsigned char buffer[]; } stream_t; int stream_fill_buffer(stream_t *s); -struct mp_cache_opts; -bool stream_wants_cache(stream_t *stream, struct mp_cache_opts *opts); -int stream_enable_cache_defaults(stream_t **stream); - -// 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); inline static int stream_read_char(stream_t *s) diff --git a/stream/stream_avdevice.c b/stream/stream_avdevice.c index 2b132cd1a9..5185b7a844 100644 --- a/stream/stream_avdevice.c +++ b/stream/stream_avdevice.c @@ -22,7 +22,6 @@ static int open_f(stream_t *stream) { stream->demuxer = "lavf"; - stream->allow_caching = false; return STREAM_OK; } diff --git a/stream/stream_dvb.c b/stream/stream_dvb.c index 9821119cac..fa58f633ec 100644 --- a/stream/stream_dvb.c +++ b/stream/stream_dvb.c @@ -1117,7 +1117,6 @@ static int dvb_open(stream_t *stream) stream->close = dvbin_close; stream->control = dvbin_stream_control; stream->streaming = true; - stream->allow_caching = true; stream->demuxer = "lavf"; stream->lavf_type = "mpegts"; stream->extended_ctrls = true; diff --git a/stream/stream_dvdnav.c b/stream/stream_dvdnav.c index 16a3d11d70..55ce771896 100644 --- a/stream/stream_dvdnav.c +++ b/stream/stream_dvdnav.c @@ -520,7 +520,6 @@ static int open_s_internal(stream_t *stream) stream->close = stream_dvdnav_close; stream->demuxer = "+disc"; stream->lavf_type = "mpeg"; - stream->allow_caching = false; return STREAM_OK; } diff --git a/stream/stream_edl.c b/stream/stream_edl.c index 11c149b3ab..94bbe58c88 100644 --- a/stream/stream_edl.c +++ b/stream/stream_edl.c @@ -6,7 +6,6 @@ static int s_open (struct stream *stream) { stream->demuxer = "edl"; - stream->allow_caching = false; return STREAM_OK; } diff --git a/stream/stream_file.c b/stream/stream_file.c index 20b4d7c0c3..319a92f08b 100644 --- a/stream/stream_file.c +++ b/stream/stream_file.c @@ -326,7 +326,6 @@ static int open_f(stream_t *stream) if (fstat(p->fd, &st) == 0) { if (S_ISDIR(st.st_mode)) { stream->is_directory = true; - stream->allow_caching = false; MP_INFO(stream, "This is a directory - adding to playlist.\n"); } else if (S_ISREG(st.st_mode)) { p->regular_file = true; diff --git a/stream/stream_memory.c b/stream/stream_memory.c index e0d01ff2d8..8df043201e 100644 --- a/stream/stream_memory.c +++ b/stream/stream_memory.c @@ -62,7 +62,6 @@ static int open_f(stream_t *stream) stream->seekable = true; stream->control = control; stream->read_chunk = 1024 * 1024; - stream->allow_caching = false; struct priv *p = talloc_zero(stream, struct priv); stream->priv = p; diff --git a/stream/stream_mf.c b/stream/stream_mf.c index fbee82924a..69a6dce58d 100644 --- a/stream/stream_mf.c +++ b/stream/stream_mf.c @@ -31,7 +31,6 @@ static int mf_stream_open (stream_t *stream) { stream->demuxer = "mf"; - stream->allow_caching = false; return STREAM_OK; } diff --git a/stream/stream_tv.c b/stream/stream_tv.c index d9acbe4cf4..bb3c48f269 100644 --- a/stream/stream_tv.c +++ b/stream/stream_tv.c @@ -41,7 +41,6 @@ tv_stream_open (stream_t *stream) stream->close=tv_stream_close; stream->demuxer = "tv"; - stream->allow_caching = false; return STREAM_OK; } -- cgit v1.2.3