Adding upstream version 0.37.0.upstream/0.37.0

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

23 files changed, 7241 insertions, 0 deletions

diff --git a/stream/cookies.c b/stream/cookies.c
new file mode 100644
index 0000000..fe61c0e
--- /dev/null
+++ b/stream/cookies.c
@@ -0,0 +1,138 @@
+/*
+ * HTTP Cookies
+ * Reads Netscape and Mozilla cookies.txt files
+ *
+ * Copyright (c) 2003 Dave Lambley <mplayer@davel.me.uk>
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <dirent.h>
+#include <inttypes.h>
+
+#include "stream/stream.h"
+#include "options/options.h"
+#include "cookies.h"
+#include "common/msg.h"
+
+#define MAX_COOKIES 20
+
+typedef struct cookie_list_type {
+    char *name;
+    char *value;
+    char *domain;
+    char *path;
+
+    int secure;
+
+    struct cookie_list_type *next;
+} cookie_list_t;
+
+/* Like strdup, but stops at anything <31. */
+static char *col_dup(void *talloc_ctx, const char *src)
+{
+    int length = 0;
+    while (src[length] > 31)
+        length++;
+
+    return talloc_strndup(talloc_ctx, src, length);
+}
+
+/* Finds the start of all the columns */
+static int parse_line(char **ptr, char *cols[7])
+{
+    int col;
+    cols[0] = *ptr;
+
+    for (col = 1; col < 7; col++) {
+        for (; (**ptr) > 31; (*ptr)++);
+        if (**ptr == 0)
+            return 0;
+        (*ptr)++;
+        if ((*ptr)[-1] != 9)
+            return 0;
+        cols[col] = (*ptr);
+    }
+
+    return 1;
+}
+
+/* Loads a cookies.txt file into a linked list. */
+static struct cookie_list_type *load_cookies_from(void *ctx,
+                                                  struct mpv_global *global,
+                                                  struct mp_log *log,
+                                                  const char *filename)
+{
+    mp_verbose(log, "Loading cookie file: %s\n", filename);
+    bstr data = stream_read_file(filename, ctx, global, 1000000);
+    if (!data.start) {
+        mp_verbose(log, "Error reading\n");
+        return NULL;
+    }
+
+    bstr_xappend(ctx, &data, (struct bstr){"", 1}); // null-terminate
+    char *ptr = data.start;
+
+    struct cookie_list_type *list = NULL;
+    while (*ptr) {
+        char *cols[7];
+        if (parse_line(&ptr, cols)) {
+            struct cookie_list_type *new;
+            new = talloc_zero(ctx, cookie_list_t);
+            new->name = col_dup(new, cols[5]);
+            new->value = col_dup(new, cols[6]);
+            new->path = col_dup(new, cols[2]);
+            new->domain = col_dup(new, cols[0]);
+            new->secure = (*(cols[3]) == 't') || (*(cols[3]) == 'T');
+            new->next = list;
+            list = new;
+        }
+    }
+
+    return list;
+}
+
+// Return a cookies string as expected by lavf (libavformat/http.c). The format
+// is like a Set-Cookie header (http://curl.haxx.se/rfc/cookie_spec.html),
+// separated by newlines.
+char *cookies_lavf(void *talloc_ctx,
+                   struct mpv_global *global,
+                   struct mp_log *log,
+                   const char *file)
+{
+    void *tmp = talloc_new(NULL);
+    struct cookie_list_type *list = NULL;
+    if (file && file[0])
+        list = load_cookies_from(tmp, global, log, file);
+
+    char *res = talloc_strdup(talloc_ctx, "");
+
+    while (list) {
+        res = talloc_asprintf_append_buffer(res,
+                    "%s=%s; path=%s; domain=%s; %s\n", list->name, list->value,
+                    list->path, list->domain, list->secure ? "secure" : "");
+        list = list->next;
+    }
+
+    talloc_free(tmp);
+    return res;
+}
diff --git a/stream/cookies.h b/stream/cookies.h
new file mode 100644
index 0000000..491b87d
--- /dev/null
+++ b/stream/cookies.h
@@ -0,0 +1,31 @@
+/*
+ * HTTP Cookies
+ * Reads Netscape and Mozilla cookies.txt files
+ *
+ * Copyright (c) 2003 Dave Lambley <mplayer@davel.me.uk>
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MPLAYER_COOKIES_H
+#define MPLAYER_COOKIES_H
+
+char *cookies_lavf(void *talloc_ctx,
+                   struct mpv_global *global,
+                   struct mp_log *log,
+                   const char *file);
+
+#endif /* MPLAYER_COOKIES_H */
diff --git a/stream/dvb_tune.c b/stream/dvb_tune.c
new file mode 100644
index 0000000..d18f70f
--- /dev/null
+++ b/stream/dvb_tune.c
@@ -0,0 +1,652 @@
+/* dvbtune - tune.c
+
+   Copyright (C) Dave Chapman 2001,2002
+   Copyright (C) Rozhuk Ivan <rozhuk.im@gmail.com> 2016 - 2017
+
+   Modified for use with MPlayer, for details see the changelog at
+   http://svn.mplayerhq.hu/mplayer/trunk/
+   $Id$
+
+   This program 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.
+
+   This program 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 this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+   Or, point your browser to http://www.gnu.org/copyleft/gpl.html
+
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/ioctl.h>
+#include <poll.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <linux/dvb/dmx.h>
+#include <linux/dvb/frontend.h>
+
+#include "osdep/io.h"
+#include "osdep/timer.h"
+#include "dvbin.h"
+#include "dvb_tune.h"
+#include "common/msg.h"
+
+/* Keep in sync with enum fe_delivery_system. */
+static const char *dvb_delsys_str[] = {
+    "UNDEFINED",
+    "DVB-C ANNEX A",
+    "DVB-C ANNEX B",
+    "DVB-T",
+    "DSS",
+    "DVB-S",
+    "DVB-S2",
+    "DVB-H",
+    "ISDBT",
+    "ISDBS",
+    "ISDBC",
+    "ATSC",
+    "ATSCMH",
+    "DTMB",
+    "CMMB",
+    "DAB",
+    "DVB-T2",
+    "TURBO",
+    "DVB-C ANNEX C",
+    NULL
+};
+
+const char *get_dvb_delsys(unsigned int delsys)
+{
+    if (SYS_DVB__COUNT__ <= delsys)
+        return dvb_delsys_str[0];
+    return dvb_delsys_str[delsys];
+}
+
+unsigned int dvb_get_tuner_delsys_mask(int fe_fd, struct mp_log *log)
+{
+    unsigned int ret_mask = 0, delsys;
+    struct dtv_property prop[1];
+    struct dtv_properties cmdseq = {.num = 1, .props = prop};
+
+    prop[0].cmd = DTV_ENUM_DELSYS;
+    if (ioctl(fe_fd, FE_GET_PROPERTY, &cmdseq) < 0) {
+        mp_err(log, "DVBv5: FE_GET_PROPERTY(DTV_ENUM_DELSYS) error: %d\n", errno);
+        return ret_mask;
+    }
+    unsigned int delsys_count = prop[0].u.buffer.len;
+    if (delsys_count == 0) {
+        mp_err(log, "DVBv5: Frontend returned no delivery systems!\n");
+        return ret_mask;
+    }
+    mp_verbose(log, "DVBv5: Number of supported delivery systems: %d\n", delsys_count);
+    for (unsigned int i = 0; i < delsys_count; i++) {
+        delsys = (unsigned int)prop[0].u.buffer.data[i];
+        DELSYS_SET(ret_mask, delsys);
+        mp_verbose(log, " %s\n", get_dvb_delsys(delsys));
+    }
+
+    return ret_mask;
+}
+
+int dvb_open_devices(dvb_priv_t *priv, unsigned int adapter,
+    unsigned int frontend, unsigned int demux_cnt)
+{
+    dvb_state_t *state = priv->state;
+
+    char frontend_dev[100], dvr_dev[100], demux_dev[100];
+    snprintf(frontend_dev, sizeof(frontend_dev), "/dev/dvb/adapter%u/frontend%u", adapter, frontend);
+    snprintf(dvr_dev, sizeof(dvr_dev), "/dev/dvb/adapter%u/dvr0", adapter);
+    snprintf(demux_dev, sizeof(demux_dev), "/dev/dvb/adapter%u/demux0", adapter);
+
+    MP_VERBOSE(priv, "Opening frontend device %s\n", frontend_dev);
+    state->fe_fd = open(frontend_dev, O_RDWR | O_NONBLOCK | O_CLOEXEC);
+    if (state->fe_fd < 0) {
+        MP_ERR(priv, "Error opening frontend device: %d\n", errno);
+        return 0;
+    }
+
+    state->demux_fds_cnt = 0;
+    MP_VERBOSE(priv, "Opening %d demuxers\n", demux_cnt);
+    for (unsigned int i = 0; i < demux_cnt; i++) {
+        state->demux_fds[i] = open(demux_dev, O_RDWR | O_NONBLOCK | O_CLOEXEC);
+        if (state->demux_fds[i] < 0) {
+            MP_ERR(priv, "Error opening demux0: %d\n", errno);
+            return 0;
+        }
+        state->demux_fds_cnt++;
+    }
+
+    state->dvr_fd = open(dvr_dev, O_RDONLY | O_NONBLOCK | O_CLOEXEC);
+    if (state->dvr_fd < 0) {
+        MP_ERR(priv, "Error opening dvr device %s: %d\n", dvr_dev, errno);
+        return 0;
+    }
+
+    return 1;
+}
+
+int dvb_fix_demuxes(dvb_priv_t *priv, unsigned int cnt)
+{
+    dvb_state_t *state = priv->state;
+
+    char demux_dev[100];
+    snprintf(demux_dev, sizeof(demux_dev), "/dev/dvb/adapter%d/demux0",
+            state->adapters[state->cur_adapter].devno);
+
+    MP_VERBOSE(priv, "Changing demuxer count %d -> %d\n", state->demux_fds_cnt, cnt);
+    if (state->demux_fds_cnt >= cnt) {
+        for (int i = state->demux_fds_cnt - 1; i >= (int)cnt; i--) {
+            close(state->demux_fds[i]);
+        }
+        state->demux_fds_cnt = cnt;
+    } else {
+        for (int i = state->demux_fds_cnt; i < cnt; i++) {
+            state->demux_fds[i] = open(demux_dev,
+                                      O_RDWR | O_NONBLOCK | O_CLOEXEC);
+            if (state->demux_fds[i] < 0) {
+                MP_ERR(priv, "Error opening demux0: %d\n", errno);
+                return 0;
+            }
+            state->demux_fds_cnt++;
+        }
+    }
+
+    return 1;
+}
+
+int dvb_set_ts_filt(dvb_priv_t *priv, int fd, uint16_t pid,
+                    dmx_pes_type_t pestype)
+{
+    int i;
+    struct dmx_pes_filter_params pesFilterParams;
+
+    pesFilterParams.pid     = pid;
+    pesFilterParams.input   = DMX_IN_FRONTEND;
+    pesFilterParams.output  = DMX_OUT_TS_TAP;
+    pesFilterParams.pes_type = pestype;
+    pesFilterParams.flags   = DMX_IMMEDIATE_START;
+
+    {
+        int buffersize = 256 * 1024;
+        if (ioctl(fd, DMX_SET_BUFFER_SIZE, buffersize) < 0)
+            MP_ERR(priv, "Error in DMX_SET_BUFFER_SIZE %i: errno=%d\n",
+                   pid, errno);
+    }
+
+    errno = 0;
+    if ((i = ioctl(fd, DMX_SET_PES_FILTER, &pesFilterParams)) < 0) {
+        MP_ERR(priv, "Error in DMX_SET_PES_FILTER %i: errno=%d\n",
+               pid, errno);
+        return 0;
+    }
+
+    return 1;
+}
+
+int dvb_get_pmt_pid(dvb_priv_t *priv, int devno, int service_id)
+{
+    /* We need special filters on the demux,
+       so open one locally, and close also here. */
+    char demux_dev[100];
+    snprintf(demux_dev, sizeof(demux_dev), "/dev/dvb/adapter%d/demux0", devno);
+
+    struct dmx_sct_filter_params fparams = {0};
+    fparams.pid = 0;
+    fparams.filter.filter[0] = 0x00;
+    fparams.filter.mask[0] = 0xff;
+    fparams.timeout = 0;
+    fparams.flags = DMX_IMMEDIATE_START | DMX_CHECK_CRC;
+
+    int pat_fd;
+    if ((pat_fd = open(demux_dev, O_RDWR)) < 0) {
+        MP_ERR(priv, "Opening PAT demux failed: %d", errno);
+        return -1;
+    }
+
+    if (ioctl(pat_fd, DMX_SET_FILTER, &fparams) < 0) {
+        MP_ERR(priv, "ioctl DMX_SET_FILTER failed: %d", errno);
+        close(pat_fd);
+        return -1;
+    }
+
+    int bytes_read;
+    unsigned char buft[4096];
+    unsigned char *bufptr = buft;
+
+    int pmt_pid = -1;
+
+    bool pat_read = false;
+    while (!pat_read) {
+        bytes_read = read(pat_fd, bufptr, sizeof(buft));
+        if (bytes_read < 0 && errno == EOVERFLOW)
+            bytes_read = read(pat_fd, bufptr, sizeof(buft));
+        if (bytes_read < 0) {
+            MP_ERR(priv, "PAT: read error: %d", errno);
+            close(pat_fd);
+            return -1;
+        }
+
+        int section_length = ((bufptr[1] & 0x0f) << 8) | bufptr[2];
+        if (bytes_read != section_length + 3)
+            continue;
+
+        bufptr += 8;
+        section_length -= 8;
+
+        /* assumes one section contains the whole pat */
+        pat_read = true;
+        while (section_length > 0) {
+            int this_service_id = (bufptr[0] << 8) | bufptr[1];
+            if (this_service_id == service_id) {
+                pmt_pid = ((bufptr[2] & 0x1f) << 8) | bufptr[3];
+                section_length = 0;
+            }
+            bufptr += 4;
+            section_length -= 4;
+        }
+    }
+    close(pat_fd);
+
+    return pmt_pid;
+}
+
+static void print_status(dvb_priv_t *priv, fe_status_t festatus)
+{
+    MP_VERBOSE(priv, "FE_STATUS:");
+    if (festatus & FE_HAS_SIGNAL)
+        MP_VERBOSE(priv, " FE_HAS_SIGNAL");
+    if (festatus & FE_TIMEDOUT)
+        MP_VERBOSE(priv, " FE_TIMEDOUT");
+    if (festatus & FE_HAS_LOCK)
+        MP_VERBOSE(priv, " FE_HAS_LOCK");
+    if (festatus & FE_HAS_CARRIER)
+        MP_VERBOSE(priv, " FE_HAS_CARRIER");
+    if (festatus & FE_HAS_VITERBI)
+        MP_VERBOSE(priv, " FE_HAS_VITERBI");
+    if (festatus & FE_HAS_SYNC)
+        MP_VERBOSE(priv, " FE_HAS_SYNC");
+    MP_VERBOSE(priv, "\n");
+}
+
+static int check_status(dvb_priv_t *priv, int fd_frontend, int tmout)
+{
+    fe_status_t festatus;
+    bool ok = false;
+    int locks = 0;
+
+    struct pollfd pfd[1];
+    pfd[0].fd = fd_frontend;
+    pfd[0].events = POLLPRI;
+
+    MP_VERBOSE(priv, "Getting frontend status\n");
+    int tm1 = (int)mp_time_sec();
+    while (!ok) {
+        festatus = 0;
+        if (poll(pfd, 1, tmout * 1000) > 0) {
+            if (pfd[0].revents & POLLPRI) {
+                if (ioctl(fd_frontend, FE_READ_STATUS, &festatus) >= 0) {
+                    if (festatus & FE_HAS_LOCK)
+                        locks++;
+                }
+            }
+        }
+        usleep(10000);
+        int tm2 = (int)mp_time_sec();
+        if ((festatus & FE_TIMEDOUT) || (locks >= 2) || (tm2 - tm1 >= tmout))
+            ok = true;
+    }
+
+    if (!(festatus & FE_HAS_LOCK)) {
+        MP_ERR(priv, "Not able to lock to the signal on the given frequency, "
+               "timeout: %d\n", tmout);
+        return -1;
+    }
+
+    int32_t strength = 0;
+    if (ioctl(fd_frontend, FE_READ_BER, &strength) >= 0)
+        MP_VERBOSE(priv, "Bit error rate: %d\n", strength);
+
+    strength = 0;
+    if (ioctl(fd_frontend, FE_READ_SIGNAL_STRENGTH, &strength) >= 0)
+        MP_VERBOSE(priv, "Signal strength: %d\n", strength);
+
+    strength = 0;
+    if (ioctl(fd_frontend, FE_READ_SNR, &strength) >= 0)
+        MP_VERBOSE(priv, "SNR: %d\n", strength);
+
+    strength = 0;
+    if (ioctl(fd_frontend, FE_READ_UNCORRECTED_BLOCKS, &strength) >= 0)
+        MP_VERBOSE(priv, "UNC: %d\n", strength);
+
+    print_status(priv, festatus);
+
+    return 0;
+}
+
+struct diseqc_cmd {
+    struct dvb_diseqc_master_cmd cmd;
+    uint32_t wait;
+};
+
+static int diseqc_send_msg(int fd, fe_sec_voltage_t v, struct diseqc_cmd *cmd,
+                           fe_sec_tone_mode_t t, fe_sec_mini_cmd_t b)
+{
+    if (ioctl(fd, FE_SET_TONE, SEC_TONE_OFF) < 0)
+        return -1;
+    if (ioctl(fd, FE_SET_VOLTAGE, v) < 0)
+        return -1;
+    usleep(15 * 1000);
+    if (ioctl(fd, FE_DISEQC_SEND_MASTER_CMD, &cmd->cmd) < 0)
+        return -1;
+    usleep(cmd->wait * 1000);
+    usleep(15 * 1000);
+    if (ioctl(fd, FE_DISEQC_SEND_BURST, b) < 0)
+        return -1;
+    usleep(15 * 1000);
+    if (ioctl(fd, FE_SET_TONE, t) < 0)
+        return -1;
+    usleep(100000);
+
+    return 0;
+}
+
+/* digital satellite equipment control,
+ * specification is available from http://www.eutelsat.com/
+ */
+static int do_diseqc(int secfd, int sat_no, int polv, int hi_lo)
+{
+    struct diseqc_cmd cmd =  { {{0xe0, 0x10, 0x38, 0xf0, 0x00, 0x00}, 4}, 0 };
+
+    /* param: high nibble: reset bits, low nibble set bits,
+     * bits are: option, position, polarizaion, band
+     */
+    cmd.cmd.msg[3] = 0xf0 | (((sat_no * 4) & 0x0f) | (hi_lo ? 1 : 0) | (polv ? 0 : 2));
+
+    return diseqc_send_msg(secfd, polv ? SEC_VOLTAGE_13 : SEC_VOLTAGE_18,
+                           &cmd, hi_lo ? SEC_TONE_ON : SEC_TONE_OFF,
+                           ((sat_no / 4) % 2) ? SEC_MINI_B : SEC_MINI_A);
+}
+
+static int dvbv5_tune(dvb_priv_t *priv, int fd_frontend,
+                       unsigned int delsys, struct dtv_properties* cmdseq)
+{
+    MP_VERBOSE(priv, "Dumping raw tuning commands and values:\n");
+    for (int i = 0; i < cmdseq->num; ++i) {
+        MP_VERBOSE(priv, " %02d: 0x%x(%d) => 0x%x(%d)\n",
+                   i, cmdseq->props[i].cmd, cmdseq->props[i].cmd,
+                   cmdseq->props[i].u.data, cmdseq->props[i].u.data);
+    }
+    if (ioctl(fd_frontend, FE_SET_PROPERTY, cmdseq) < 0) {
+        MP_ERR(priv, "Error tuning channel\n");
+        return -1;
+    }
+    return 0;
+}
+
+static int tune_it(dvb_priv_t *priv, int fd_frontend, unsigned int delsys,
+                   unsigned int freq, unsigned int srate, char pol,
+                   int stream_id,
+                   fe_spectral_inversion_t specInv, unsigned int diseqc,
+                   fe_modulation_t modulation,
+                   fe_code_rate_t HP_CodeRate,
+                   fe_transmit_mode_t TransmissionMode,
+                   fe_guard_interval_t guardInterval,
+                   fe_bandwidth_t bandwidth,
+                   fe_code_rate_t LP_CodeRate, fe_hierarchy_t hier,
+                   int timeout)
+{
+    dvb_state_t *state = priv->state;
+
+    MP_VERBOSE(priv, "tune_it: fd_frontend %d, %s freq %lu, srate %lu, "
+               "pol %c, diseqc %u\n", fd_frontend,
+               get_dvb_delsys(delsys),
+               (long unsigned int)freq, (long unsigned int)srate,
+               (pol > ' ' ? pol : '-'), diseqc);
+
+    MP_VERBOSE(priv, "Using %s adapter %d\n",
+        get_dvb_delsys(delsys),
+        state->adapters[state->cur_adapter].devno);
+
+    {
+        /* discard stale QPSK events */
+        struct dvb_frontend_event ev;
+        while (true) {
+            if (ioctl(fd_frontend, FE_GET_EVENT, &ev) < 0)
+                break;
+        }
+    }
+
+    /* Prepare params, be verbose. */
+    int hi_lo = 0, bandwidth_hz = 0;
+    switch (delsys) {
+    case SYS_DVBT2:
+    case SYS_DVBT:
+    case SYS_ISDBT:
+        if (freq < 1000000)
+            freq *= 1000UL;
+        switch (bandwidth) {
+        case BANDWIDTH_5_MHZ:
+            bandwidth_hz = 5000000;
+            break;
+        case BANDWIDTH_6_MHZ:
+            bandwidth_hz = 6000000;
+            break;
+        case BANDWIDTH_7_MHZ:
+            bandwidth_hz = 7000000;
+            break;
+        case BANDWIDTH_8_MHZ:
+            bandwidth_hz = 8000000;
+            break;
+        case BANDWIDTH_10_MHZ:
+            bandwidth_hz = 10000000;
+            break;
+        case BANDWIDTH_AUTO:
+            if (freq < 474000000) {
+                bandwidth_hz = 7000000;
+            } else {
+                bandwidth_hz = 8000000;
+            }
+            break;
+        default:
+            bandwidth_hz = 0;
+            break;
+        }
+
+        MP_VERBOSE(priv, "tuning %s to %d Hz, bandwidth: %d\n",
+                   get_dvb_delsys(delsys), freq, bandwidth_hz);
+        break;
+    case SYS_DVBS2:
+    case SYS_DVBS:
+        if (freq > 2200000) {
+            // this must be an absolute frequency
+            if (freq < SLOF) {
+                freq -= LOF1;
+                hi_lo = 0;
+            } else {
+                freq -= LOF2;
+                hi_lo = 1;
+            }
+        }
+        MP_VERBOSE(priv, "tuning %s to Freq: %u, Pol: %c Srate: %d, "
+                   "22kHz: %s, LNB:  %d\n", get_dvb_delsys(delsys), freq,
+                   pol, srate, hi_lo ? "on" : "off", diseqc);
+
+        if (do_diseqc(fd_frontend, diseqc, (pol == 'V' ? 1 : 0), hi_lo) == 0) {
+            MP_VERBOSE(priv, "DISEQC setting succeeded\n");
+        } else {
+            MP_ERR(priv, "DISEQC setting failed\n");
+            return -1;
+        }
+
+        break;
+    case SYS_DVBC_ANNEX_A:
+    case SYS_DVBC_ANNEX_C:
+        MP_VERBOSE(priv, "tuning %s to %d, srate=%d\n",
+                   get_dvb_delsys(delsys), freq, srate);
+        break;
+    case SYS_ATSC:
+    case SYS_DVBC_ANNEX_B:
+        MP_VERBOSE(priv, "tuning %s to %d, modulation=%d\n",
+                   get_dvb_delsys(delsys), freq, modulation);
+        break;
+    default:
+        MP_VERBOSE(priv, "Unknown FE type, aborting.\n");
+        return 0;
+    }
+
+    /* S2API is the DVB API new since 2.6.28.
+     * It is needed to tune to new delivery systems, e.g. DVB-S2.
+     * It takes a struct with a list of pairs of command + parameter.
+     */
+
+    /* Reset before tune. */
+    struct dtv_property p_clear[] = {
+        { .cmd = DTV_CLEAR },
+    };
+    struct dtv_properties cmdseq_clear = {
+        .num = 1,
+        .props = p_clear
+    };
+    if (ioctl(fd_frontend, FE_SET_PROPERTY, &cmdseq_clear) < 0) {
+        MP_ERR(priv, "DTV_CLEAR failed\n");
+    }
+
+    /* Tune. */
+    switch (delsys) {
+    case SYS_DVBS:
+    case SYS_DVBS2:
+        {
+            struct dtv_property p[] = {
+                { .cmd = DTV_DELIVERY_SYSTEM, .u.data = delsys },
+                { .cmd = DTV_FREQUENCY, .u.data = freq },
+                { .cmd = DTV_MODULATION, .u.data = modulation },
+                { .cmd = DTV_SYMBOL_RATE, .u.data = srate },
+                { .cmd = DTV_INNER_FEC, .u.data = HP_CodeRate },
+                { .cmd = DTV_INVERSION, .u.data = specInv },
+                { .cmd = DTV_ROLLOFF, .u.data = ROLLOFF_AUTO },
+                { .cmd = DTV_PILOT, .u.data = PILOT_AUTO },
+                { .cmd = DTV_TUNE },
+            };
+            struct dtv_properties cmdseq = {
+                .num = sizeof(p) / sizeof(p[0]),
+                .props = p
+            };
+            if (dvbv5_tune(priv, fd_frontend, delsys, &cmdseq) != 0) {
+                goto error_tune;
+            }
+        }
+        break;
+    case SYS_DVBT:
+    case SYS_DVBT2:
+    case SYS_ISDBT:
+        {
+            struct dtv_property p[] = {
+                { .cmd = DTV_DELIVERY_SYSTEM, .u.data = delsys },
+                { .cmd = DTV_FREQUENCY, .u.data = freq },
+                { .cmd = DTV_MODULATION, .u.data = modulation },
+                { .cmd = DTV_SYMBOL_RATE, .u.data = srate },
+                { .cmd = DTV_CODE_RATE_HP, .u.data = HP_CodeRate },
+                { .cmd = DTV_CODE_RATE_LP, .u.data = LP_CodeRate },
+                { .cmd = DTV_INVERSION, .u.data = specInv },
+                { .cmd = DTV_BANDWIDTH_HZ, .u.data = bandwidth_hz },
+                { .cmd = DTV_TRANSMISSION_MODE, .u.data = TransmissionMode },
+                { .cmd = DTV_GUARD_INTERVAL, .u.data = guardInterval },
+                { .cmd = DTV_HIERARCHY, .u.data = hier },
+                { .cmd = DTV_STREAM_ID, .u.data = stream_id },
+                { .cmd = DTV_TUNE },
+            };
+            struct dtv_properties cmdseq = {
+                .num = sizeof(p) / sizeof(p[0]),
+                .props = p
+            };
+            if (dvbv5_tune(priv, fd_frontend, delsys, &cmdseq) != 0) {
+                goto error_tune;
+            }
+        }
+        break;
+    case SYS_DVBC_ANNEX_A:
+    case SYS_DVBC_ANNEX_C:
+        {
+            struct dtv_property p[] = {
+                { .cmd = DTV_DELIVERY_SYSTEM, .u.data = delsys },
+                { .cmd = DTV_FREQUENCY, .u.data = freq },
+                { .cmd = DTV_MODULATION, .u.data = modulation },
+                { .cmd = DTV_SYMBOL_RATE, .u.data = srate },
+                { .cmd = DTV_INNER_FEC, .u.data = HP_CodeRate },
+                { .cmd = DTV_INVERSION, .u.data = specInv },
+                { .cmd = DTV_TUNE },
+            };
+            struct dtv_properties cmdseq = {
+                .num = sizeof(p) / sizeof(p[0]),
+                .props = p
+            };
+            if (dvbv5_tune(priv, fd_frontend, delsys, &cmdseq) != 0) {
+                goto error_tune;
+            }
+        }
+        break;
+    case SYS_ATSC:
+    case SYS_DVBC_ANNEX_B:
+        {
+            struct dtv_property p[] = {
+                { .cmd = DTV_DELIVERY_SYSTEM, .u.data = delsys },
+                { .cmd = DTV_FREQUENCY, .u.data = freq },
+                { .cmd = DTV_INVERSION, .u.data = specInv },
+                { .cmd = DTV_MODULATION, .u.data = modulation },
+                { .cmd = DTV_TUNE },
+            };
+            struct dtv_properties cmdseq = {
+                .num = sizeof(p) / sizeof(p[0]),
+                .props = p
+            };
+            if (dvbv5_tune(priv, fd_frontend, delsys, &cmdseq) != 0) {
+                goto error_tune;
+            }
+        }
+        break;
+    }
+
+    int tune_status = check_status(priv, fd_frontend, timeout);
+    if (tune_status != 0) {
+        MP_ERR(priv, "Error locking to channel\n");
+    }
+    return tune_status;
+
+error_tune:
+    MP_ERR(priv, "Error tuning channel\n");
+    return -1;
+}
+
+int dvb_tune(dvb_priv_t *priv, unsigned int delsys,
+             int freq, char pol, int srate, int diseqc,
+             int stream_id, fe_spectral_inversion_t specInv,
+             fe_modulation_t modulation, fe_guard_interval_t guardInterval,
+             fe_transmit_mode_t TransmissionMode, fe_bandwidth_t bandWidth,
+             fe_code_rate_t HP_CodeRate,
+             fe_code_rate_t LP_CodeRate, fe_hierarchy_t hier,
+             int timeout)
+{
+    MP_INFO(priv, "Tuning to %s frequency %lu Hz\n",
+            get_dvb_delsys(delsys), (long unsigned int) freq);
+
+    dvb_state_t *state = priv->state;
+
+    int ris = tune_it(priv, state->fe_fd, delsys, freq, srate, pol,
+                      stream_id, specInv, diseqc, modulation,
+                      HP_CodeRate, TransmissionMode, guardInterval,
+                      bandWidth, LP_CodeRate, hier, timeout);
+
+    if (ris != 0)
+        MP_INFO(priv, "Tuning failed\n");
+
+    return ris == 0;
+}
diff --git a/stream/dvb_tune.h b/stream/dvb_tune.h
new file mode 100644
index 0000000..d7a7901
--- /dev/null
+++ b/stream/dvb_tune.h
@@ -0,0 +1,42 @@
+/*
+ * This file is part of MPlayer.
+ *
+ * MPlayer 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.
+ *
+ * MPlayer 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 MPlayer; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef MPLAYER_DVB_TUNE_H
+#define MPLAYER_DVB_TUNE_H
+
+#include "dvbin.h"
+
+struct mp_log;
+
+
+const char *get_dvb_delsys(unsigned int delsys);
+unsigned int dvb_get_tuner_delsys_mask(int fe_fd, struct mp_log *log);
+int dvb_open_devices(dvb_priv_t *priv, unsigned int adapter,
+                     unsigned int frontend, unsigned int demux_cnt);
+int dvb_fix_demuxes(dvb_priv_t *priv, unsigned int cnt);
+int dvb_set_ts_filt(dvb_priv_t *priv, int fd, uint16_t pid, dmx_pes_type_t pestype);
+int dvb_get_pmt_pid(dvb_priv_t *priv, int card, int service_id);
+int dvb_tune(dvb_priv_t *priv, unsigned int delsys,
+             int freq, char pol, int srate, int diseqc,
+             int stream_id, fe_spectral_inversion_t specInv,
+             fe_modulation_t modulation, fe_guard_interval_t guardInterval,
+             fe_transmit_mode_t TransmissionMode, fe_bandwidth_t bandWidth,
+             fe_code_rate_t HP_CodeRate, fe_code_rate_t LP_CodeRate,
+             fe_hierarchy_t hier, int timeout);
+
+#endif /* MPLAYER_DVB_TUNE_H */
diff --git a/stream/dvbin.h b/stream/dvbin.h
new file mode 100644
index 0000000..3daf747
--- /dev/null
+++ b/stream/dvbin.h
@@ -0,0 +1,143 @@
+/* Imported from the dvbstream project
+ *
+ * Modified for use with MPlayer, for details see the changelog at
+ * http://svn.mplayerhq.hu/mplayer/trunk/
+ * $Id$
+ */
+
+#ifndef MPLAYER_DVBIN_H
+#define MPLAYER_DVBIN_H
+
+#include "config.h"
+#include "stream.h"
+
+#if !HAVE_GPL
+#error GPL only
+#endif
+
+#define SLOF (11700 * 1000UL)
+#define LOF1 (9750 * 1000UL)
+#define LOF2 (10600 * 1000UL)
+
+#include <inttypes.h>
+#include <linux/dvb/dmx.h>
+#include <linux/dvb/frontend.h>
+#include <linux/dvb/version.h>
+
+#define MAX_ADAPTERS 16
+#define MAX_FRONTENDS 8
+
+#if DVB_API_VERSION < 5 || DVB_API_VERSION_MINOR < 8
+#error DVB support requires a non-ancient kernel
+#endif
+
+#define DVB_CHANNEL_LOWER -1
+#define DVB_CHANNEL_HIGHER 1
+
+#ifndef DMX_FILTER_SIZE
+#define DMX_FILTER_SIZE 32
+#endif
+
+typedef struct {
+    char *name;
+    unsigned int freq, srate, diseqc;
+    char pol;
+    unsigned int tpid, dpid1, dpid2, progid, ca, pids[DMX_FILTER_SIZE], pids_cnt;
+    bool is_dvb_x2; /* Used only in dvb_get_channels() and parse_vdr_par_string(), use delsys. */
+    unsigned int frontend;
+    unsigned int delsys;
+    unsigned int stream_id;
+    unsigned int service_id;
+    fe_spectral_inversion_t inv;
+    fe_modulation_t mod;
+    fe_transmit_mode_t trans;
+    fe_bandwidth_t bw;
+    fe_guard_interval_t gi;
+    fe_code_rate_t cr, cr_lp;
+    fe_hierarchy_t hier;
+} dvb_channel_t;
+
+typedef struct {
+    unsigned int NUM_CHANNELS;
+    unsigned int current;
+    dvb_channel_t *channels;
+} dvb_channels_list_t;
+
+typedef struct {
+    int devno;
+    unsigned int delsys_mask[MAX_FRONTENDS];
+    dvb_channels_list_t *list;
+} dvb_adapter_config_t;
+
+typedef struct {
+    unsigned int adapters_count;
+    dvb_adapter_config_t *adapters;
+    unsigned int cur_adapter;
+    unsigned int cur_frontend;
+
+    int fe_fd;
+    int dvr_fd;
+    int demux_fd[3], demux_fds[DMX_FILTER_SIZE], demux_fds_cnt;
+
+    bool is_on;
+    int retry;
+    unsigned int last_freq;
+    bool switching_channel;
+    bool stream_used;
+} dvb_state_t;
+
+typedef struct {
+    char *cfg_prog;
+    int cfg_devno;
+    int cfg_timeout;
+    char *cfg_file;
+    bool cfg_full_transponder;
+    int cfg_channel_switch_offset;
+} dvb_opts_t;
+
+typedef struct {
+    struct mp_log *log;
+
+    dvb_state_t *state;
+
+    char *prog;
+    int devno;
+
+    int opts_check_time;
+    dvb_opts_t *opts;
+    struct m_config_cache *opts_cache;
+} dvb_priv_t;
+
+
+/* Keep in sync with enum fe_delivery_system. */
+#define SYS_DVB__COUNT__            (SYS_DVBC_ANNEX_C + 1)
+
+
+#define DELSYS_BIT(__bit)        (((unsigned int)1) << (__bit))
+
+#define DELSYS_SET(__mask, __bit)                                       \
+    (__mask) |= DELSYS_BIT((__bit))
+
+#define DELSYS_IS_SET(__mask, __bit)                                    \
+    (0 != ((__mask) & DELSYS_BIT((__bit))))
+
+
+#define DELSYS_SUPP_MASK                                                \
+    (                                                                   \
+        DELSYS_BIT(SYS_DVBC_ANNEX_A) |                                  \
+        DELSYS_BIT(SYS_DVBT) |                                          \
+        DELSYS_BIT(SYS_DVBS) |                                          \
+        DELSYS_BIT(SYS_DVBS2) |                                         \
+        DELSYS_BIT(SYS_ATSC) |                                          \
+        DELSYS_BIT(SYS_DVBC_ANNEX_B) |                                  \
+        DELSYS_BIT(SYS_DVBT2) |                                         \
+        DELSYS_BIT(SYS_ISDBT) |                                         \
+        DELSYS_BIT(SYS_DVBC_ANNEX_C)                                    \
+    )
+
+void dvb_update_config(stream_t *);
+int dvb_parse_path(stream_t *);
+int dvb_set_channel(stream_t *, unsigned int, unsigned int);
+dvb_state_t *dvb_get_state(stream_t *);
+
+#endif /* MPLAYER_DVBIN_H */
diff --git a/stream/stream.c b/stream/stream.c
new file mode 100644
index 0000000..dd67825
--- /dev/null
+++ b/stream/stream.c
@@ -0,0 +1,900 @@
+/*
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+
+#include <strings.h>
+#include <assert.h>
+
+#include "osdep/io.h"
+
+#include "mpv_talloc.h"
+
+#include "config.h"
+
+#include "common/common.h"
+#include "common/global.h"
+#include "demux/demux.h"
+#include "misc/bstr.h"
+#include "misc/thread_tools.h"
+#include "common/msg.h"
+#include "options/m_config.h"
+#include "options/options.h"
+#include "options/path.h"
+#include "osdep/timer.h"
+#include "stream.h"
+
+#include "options/m_option.h"
+#include "options/m_config.h"
+
+extern const stream_info_t stream_info_cdda;
+extern const stream_info_t stream_info_dvb;
+extern const stream_info_t stream_info_null;
+extern const stream_info_t stream_info_memory;
+extern const stream_info_t stream_info_mf;
+extern const stream_info_t stream_info_ffmpeg;
+extern const stream_info_t stream_info_ffmpeg_unsafe;
+extern const stream_info_t stream_info_avdevice;
+extern const stream_info_t stream_info_file;
+extern const stream_info_t stream_info_slice;
+extern const stream_info_t stream_info_fd;
+extern const stream_info_t stream_info_ifo_dvdnav;
+extern const stream_info_t stream_info_dvdnav;
+extern const stream_info_t stream_info_bdmv_dir;
+extern const stream_info_t stream_info_bluray;
+extern const stream_info_t stream_info_bdnav;
+extern const stream_info_t stream_info_edl;
+extern const stream_info_t stream_info_libarchive;
+extern const stream_info_t stream_info_cb;
+
+static const stream_info_t *const stream_list[] = {
+#if HAVE_CDDA
+    &stream_info_cdda,
+#endif
+    &stream_info_ffmpeg,
+    &stream_info_ffmpeg_unsafe,
+    &stream_info_avdevice,
+#if HAVE_DVBIN
+    &stream_info_dvb,
+#endif
+#if HAVE_DVDNAV
+    &stream_info_ifo_dvdnav,
+    &stream_info_dvdnav,
+#endif
+#if HAVE_LIBBLURAY
+    &stream_info_bdmv_dir,
+    &stream_info_bluray,
+    &stream_info_bdnav,
+#endif
+#if HAVE_LIBARCHIVE
+    &stream_info_libarchive,
+#endif
+    &stream_info_memory,
+    &stream_info_null,
+    &stream_info_mf,
+    &stream_info_edl,
+    &stream_info_file,
+    &stream_info_slice,
+    &stream_info_fd,
+    &stream_info_cb,
+};
+
+// Because of guarantees documented on STREAM_BUFFER_SIZE.
+// Half the buffer is used as forward buffer, the other for seek-back.
+#define STREAM_MIN_BUFFER_SIZE (STREAM_BUFFER_SIZE * 2)
+// Sort of arbitrary; keep *2 of it comfortably within integer limits.
+// Must be power of 2.
+#define STREAM_MAX_BUFFER_SIZE (512 * 1024 * 1024)
+
+struct stream_opts {
+    int64_t buffer_size;
+    bool load_unsafe_playlists;
+};
+
+#define OPT_BASE_STRUCT struct stream_opts
+
+const struct m_sub_options stream_conf = {
+    .opts = (const struct m_option[]){
+        {"stream-buffer-size", OPT_BYTE_SIZE(buffer_size),
+            M_RANGE(STREAM_MIN_BUFFER_SIZE, STREAM_MAX_BUFFER_SIZE)},
+        {"load-unsafe-playlists", OPT_BOOL(load_unsafe_playlists)},
+        {0}
+    },
+    .size = sizeof(struct stream_opts),
+    .defaults = &(const struct stream_opts){
+        .buffer_size = 128 * 1024,
+    },
+};
+
+// return -1 if not hex char
+static int hex2dec(char c)
+{
+    if (c >= '0' && c <= '9')
+        return c - '0';
+    if (c >= 'A' && c <= 'F')
+        return 10 + c - 'A';
+    if (c >= 'a' && c <= 'f')
+        return 10 + c - 'a';
+    return -1;
+}
+
+// Replace escape sequences in an URL (or a part of an URL)
+void mp_url_unescape_inplace(char *url)
+{
+    for (int len = strlen(url), i = 0, o = 0; i <= len;) {
+        if ((url[i] != '%') || (i > len - 3)) {  // %NN can't start after len-3
+            url[o++] = url[i++];
+            continue;
+        }
+
+        int msd = hex2dec(url[i + 1]),
+            lsd = hex2dec(url[i + 2]);
+
+        if (msd >= 0 && lsd >= 0) {
+            url[o++] = 16 * msd + lsd;
+            i += 3;
+        } else {
+            url[o++] = url[i++];
+            url[o++] = url[i++];
+            url[o++] = url[i++];
+        }
+    }
+}
+
+static const char hex_digits[] = "0123456789ABCDEF";
+
+
+static const char url_default_ok[] = "abcdefghijklmnopqrstuvwxyz"
+                                     "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                                     "0123456789"
+                                     "-._~";
+
+// Escape according to http://tools.ietf.org/html/rfc3986#section-2.1
+// Only unreserved characters are not escaped.
+// The argument ok (if not NULL) is as follows:
+//      ok[0] != '~': additional characters that are not escaped
+//      ok[0] == '~': do not escape anything but these characters
+//                    (can't override the unreserved characters, which are
+//                     never escaped)
+char *mp_url_escape(void *talloc_ctx, const char *url, const char *ok)
+{
+    char *rv = talloc_size(talloc_ctx, strlen(url) * 3 + 1);
+    char *out = rv;
+    bool negate = ok && ok[0] == '~';
+
+    for (char c; (c = *url); url++) {
+        bool as_is = negate ? !strchr(ok + 1, c)
+                            : (strchr(url_default_ok, c) || (ok && strchr(ok, c)));
+        if (as_is) {
+            *out++ = c;
+        } else {
+            unsigned char v = c;
+            *out++ = '%';
+            *out++ = hex_digits[v / 16];
+            *out++ = hex_digits[v % 16];
+        }
+    }
+
+    *out = 0;
+    return rv;
+}
+
+static const char *match_proto(const char *url, const char *proto)
+{
+    int l = strlen(proto);
+    if (l > 0) {
+        if (strncasecmp(url, proto, l) == 0 && strncmp("://", url + l, 3) == 0)
+            return url + l + 3;
+    } else if (!mp_is_url(bstr0(url))) {
+        return url; // pure filenames
+    }
+    return NULL;
+}
+
+// src and new are both STREAM_ORIGIN_* values. This checks whether a stream
+// with flags "new" can be opened from the "src". On success, return
+// new origin, on incompatibility return 0.
+static int check_origin(int src, int new)
+{
+    switch (src) {
+    case STREAM_ORIGIN_DIRECT:
+    case STREAM_ORIGIN_UNSAFE:
+        // Allow anything, but constrain it to the new origin.
+        return new;
+    case STREAM_ORIGIN_FS:
+        // From unix FS, allow all but unsafe.
+        if (new == STREAM_ORIGIN_FS || new == STREAM_ORIGIN_NET)
+            return new;
+        break;
+    case STREAM_ORIGIN_NET:
+        // Allow only other network links.
+        if (new == STREAM_ORIGIN_NET)
+            return new;
+        break;
+    }
+    return 0;
+}
+
+// Read len bytes from the start position, and wrap around as needed. Limit the
+// actually read data to the size of the buffer. Return amount of copied bytes.
+//  len: max bytes to copy to dst
+//  pos: index into s->buffer[], e.g. s->buf_start is byte 0
+//  returns: bytes copied to dst (limited by len and available buffered data)
+static int ring_copy(struct stream *s, void *dst, int len, int pos)
+{
+    assert(len >= 0);
+
+    if (pos < s->buf_start || pos > s->buf_end)
+        return 0;
+
+    int copied = 0;
+    len = MPMIN(len, s->buf_end - pos);
+
+    if (len && pos <= s->buffer_mask) {
+        int copy = MPMIN(len, s->buffer_mask + 1 - pos);
+        memcpy(dst, &s->buffer[pos], copy);
+        copied += copy;
+        len -= copy;
+        pos += copy;
+    }
+
+    if (len) {
+        memcpy((char *)dst + copied, &s->buffer[pos & s->buffer_mask], len);
+        copied += len;
+    }
+
+    return copied;
+}
+
+// Resize the current stream buffer. Uses a larger size if needed to keep data.
+// Does nothing if the size is adequate. Calling this with 0 ensures it uses the
+// default buffer size if possible.
+// The caller must check whether enough data was really allocated.
+//  keep: keep at least [buf_end-keep, buf_end] (used for assert()s only)
+//  new: new total size of buffer
+//  returns: false if buffer allocation failed, true if reallocated or size ok
+static bool stream_resize_buffer(struct stream *s, int keep, int new)
+{
+    assert(keep >= s->buf_end - s->buf_cur);
+    assert(keep <= new);
+
+    new = MPMAX(new, s->requested_buffer_size);
+    new = MPMIN(new, STREAM_MAX_BUFFER_SIZE);
+    new = mp_round_next_power_of_2(new);
+
+    assert(keep <= new); // can't fail (if old buffer size was valid)
+
+    if (new == s->buffer_mask + 1)
+        return true;
+
+    int old_pos = s->buf_cur - s->buf_start;
+    int old_used_len = s->buf_end - s->buf_start;
+    int skip = old_used_len > new ? old_used_len - new : 0;
+
+    MP_DBG(s, "resize stream to %d bytes, drop %d bytes\n", new, skip);
+
+    void *nbuf = ta_alloc_size(s, new);
+    if (!nbuf)
+        return false; // oom; tolerate it, caller needs to check if required
+
+    int new_len = 0;
+    if (s->buffer)
+        new_len = ring_copy(s, nbuf, new, s->buf_start + skip);
+    assert(new_len == old_used_len - skip);
+    assert(old_pos >= skip); // "keep" too low
+    assert(old_pos - skip <= new_len);
+    s->buf_start = 0;
+    s->buf_cur = old_pos - skip;
+    s->buf_end = new_len;
+
+    ta_free(s->buffer);
+
+    s->buffer = nbuf;
+    s->buffer_mask = new - 1;
+
+    return true;
+}
+
+static int stream_create_instance(const stream_info_t *sinfo,
+                                  struct stream_open_args *args,
+                                  struct stream **ret)
+{
+    const char *url = args->url;
+    int flags = args->flags;
+
+    *ret = NULL;
+
+    const char *path = url;
+
+    if (flags & STREAM_LOCAL_FS_ONLY) {
+        if (!sinfo->local_fs)
+            return STREAM_NO_MATCH;
+    } else {
+        for (int n = 0; sinfo->protocols && sinfo->protocols[n]; n++) {
+            path = match_proto(url, sinfo->protocols[n]);
+            if (path)
+                break;
+        }
+
+        if (!path)
+            return STREAM_NO_MATCH;
+    }
+
+    stream_t *s = talloc_zero(NULL, stream_t);
+    s->global = args->global;
+    struct stream_opts *opts = mp_get_config_group(s, s->global, &stream_conf);
+    if (flags & STREAM_SILENT) {
+        s->log = mp_null_log;
+    } else {
+        s->log = mp_log_new(s, s->global->log, sinfo->name);
+    }
+    s->info = sinfo;
+    s->cancel = args->cancel;
+    s->url = talloc_strdup(s, url);
+    s->path = talloc_strdup(s, path);
+    s->mode = flags & (STREAM_READ | STREAM_WRITE);
+    s->requested_buffer_size = opts->buffer_size;
+
+    if (flags & STREAM_LESS_NOISE)
+        mp_msg_set_max_level(s->log, MSGL_WARN);
+
+    struct demux_opts *demux_opts = mp_get_config_group(s, s->global, &demux_conf);
+    s->access_references = demux_opts->access_references;
+    talloc_free(demux_opts);
+
+    MP_VERBOSE(s, "Opening %s\n", url);
+
+    if (strlen(url) > INT_MAX / 8) {
+        MP_ERR(s, "URL too large.\n");
+        talloc_free(s);
+        return STREAM_ERROR;
+    }
+
+    if ((s->mode & STREAM_WRITE) && !sinfo->can_write) {
+        MP_DBG(s, "No write access implemented.\n");
+        talloc_free(s);
+        return STREAM_NO_MATCH;
+    }
+
+    s->stream_origin = flags & STREAM_ORIGIN_MASK; // pass through by default
+    if (opts->load_unsafe_playlists) {
+        s->stream_origin = STREAM_ORIGIN_DIRECT;
+    } else if (sinfo->stream_origin) {
+        s->stream_origin = check_origin(s->stream_origin, sinfo->stream_origin);
+    }
+
+    if (!s->stream_origin) {
+        talloc_free(s);
+        return STREAM_UNSAFE;
+    }
+
+    int r = STREAM_UNSUPPORTED;
+    if (sinfo->open2) {
+        r = sinfo->open2(s, args);
+    } else if (!args->special_arg) {
+        r = (sinfo->open)(s);
+    }
+    if (r != STREAM_OK) {
+        talloc_free(s);
+        return r;
+    }
+
+    if (!stream_resize_buffer(s, 0, 0)) {
+        free_stream(s);
+        return STREAM_ERROR;
+    }
+
+    assert(s->seekable == !!s->seek);
+
+    if (s->mime_type)
+        MP_VERBOSE(s, "Mime-type: '%s'\n", s->mime_type);
+
+    MP_DBG(s, "Stream opened successfully.\n");
+
+    *ret = s;
+    return STREAM_OK;
+}
+
+int stream_create_with_args(struct stream_open_args *args, struct stream **ret)
+
+{
+    assert(args->url);
+
+    int r = STREAM_NO_MATCH;
+    *ret = NULL;
+
+    // Open stream proper
+    if (args->sinfo) {
+        r = stream_create_instance(args->sinfo, args, ret);
+    } else {
+        for (int i = 0; i < MP_ARRAY_SIZE(stream_list); i++) {
+            r = stream_create_instance(stream_list[i], args, ret);
+            if (r == STREAM_OK)
+                break;
+            if (r == STREAM_NO_MATCH || r == STREAM_UNSUPPORTED)
+                continue;
+            if (r == STREAM_UNSAFE)
+                continue;
+            break;
+        }
+    }
+
+    if (!*ret && !(args->flags & STREAM_SILENT) && !mp_cancel_test(args->cancel))
+    {
+        struct mp_log *log = mp_log_new(NULL, args->global->log, "!stream");
+
+        if (r == STREAM_UNSAFE) {
+            mp_err(log, "\nRefusing to load potentially unsafe URL from a playlist.\n"
+                   "Use the --load-unsafe-playlists option to load it anyway.\n\n");
+        } else if (r == STREAM_NO_MATCH || r == STREAM_UNSUPPORTED) {
+            mp_err(log, "No protocol handler found to open URL %s\n", args->url);
+            mp_err(log, "The protocol is either unsupported, or was disabled "
+                        "at compile-time.\n");
+        } else {
+            mp_err(log, "Failed to open %s.\n", args->url);
+        }
+
+        talloc_free(log);
+    }
+
+    return r;
+}
+
+struct stream *stream_create(const char *url, int flags,
+                             struct mp_cancel *c, struct mpv_global *global)
+{
+    struct stream_open_args args = {
+        .global = global,
+        .cancel = c,
+        .flags = flags,
+        .url = url,
+    };
+    struct stream *s;
+    stream_create_with_args(&args, &s);
+    return s;
+}
+
+stream_t *open_output_stream(const char *filename, struct mpv_global *global)
+{
+    return stream_create(filename, STREAM_ORIGIN_DIRECT | STREAM_WRITE,
+                         NULL, global);
+}
+
+// Read function bypassing the local stream buffer. This will not write into
+// s->buffer, but into buf[0..len] instead.
+// Returns 0 on error or EOF, and length of bytes read on success.
+// Partial reads are possible, even if EOF is not reached.
+static int stream_read_unbuffered(stream_t *s, void *buf, int len)
+{
+    assert(len >= 0);
+    if (len <= 0)
+        return 0;
+
+    int res = 0;
+    // we will retry even if we already reached EOF previously.
+    if (s->fill_buffer && !mp_cancel_test(s->cancel))
+        res = s->fill_buffer(s, buf, len);
+    if (res <= 0) {
+        s->eof = 1;
+        return 0;
+    }
+    assert(res <= len);
+    // When reading succeeded we are obviously not at eof.
+    s->eof = 0;
+    s->pos += res;
+    s->total_unbuffered_read_bytes += res;
+    return res;
+}
+
+// Ask for having at most "forward" bytes ready to read in the buffer.
+// To read everything, you may have to call this in a loop.
+//  forward: desired amount of bytes in buffer after s->cur_pos
+//  returns: progress (false on EOF or on OOM or if enough data was available)
+static bool stream_read_more(struct stream *s, int forward)
+{
+    assert(forward >= 0);
+
+    int forward_avail = s->buf_end - s->buf_cur;
+    if (forward_avail >= forward)
+        return false;
+
+    // Avoid that many small reads will lead to many low-level read calls.
+    forward = MPMAX(forward, s->requested_buffer_size / 2);
+    assert(forward_avail < forward);
+
+    // Keep guaranteed seek-back.
+    int buf_old = MPMIN(s->buf_cur - s->buf_start, s->requested_buffer_size / 2);
+
+    if (!stream_resize_buffer(s, buf_old + forward_avail, buf_old + forward))
+        return false;
+
+    int buf_alloc = s->buffer_mask + 1;
+
+    assert(s->buf_start <= s->buf_cur);
+    assert(s->buf_cur <= s->buf_end);
+    assert(s->buf_cur < buf_alloc * 2);
+    assert(s->buf_end < buf_alloc * 2);
+    assert(s->buf_start < buf_alloc);
+
+    // Note: read as much as possible, even if forward is much smaller. Do
+    // this because the stream buffer is supposed to set an approx. minimum
+    // read size on it.
+    int read = buf_alloc - (buf_old + forward_avail); // free buffer past end
+
+    int pos = s->buf_end & s->buffer_mask;
+    read = MPMIN(read, buf_alloc - pos);
+
+    // Note: if wrap-around happens, we need to make two calls. This may
+    // affect latency (e.g. waiting for new data on a socket), so do only
+    // 1 read call always.
+    read = stream_read_unbuffered(s, &s->buffer[pos], read);
+
+    s->buf_end += read;
+
+    // May have overwritten old data.
+    if (s->buf_end - s->buf_start >= buf_alloc) {
+        assert(s->buf_end >= buf_alloc);
+
+        s->buf_start = s->buf_end - buf_alloc;
+
+        assert(s->buf_start <= s->buf_cur);
+        assert(s->buf_cur <= s->buf_end);
+
+        if (s->buf_start >= buf_alloc) {
+            s->buf_start -= buf_alloc;
+            s->buf_cur -= buf_alloc;
+            s->buf_end -= buf_alloc;
+        }
+    }
+
+    // Must not have overwritten guaranteed old data.
+    assert(s->buf_cur - s->buf_start >= buf_old);
+
+    if (s->buf_cur < s->buf_end)
+        s->eof = 0;
+
+    return !!read;
+}
+
+// Read between 1..buf_size bytes of data, return how much data has been read.
+// Return 0 on EOF, error, or if buf_size was 0.
+int stream_read_partial(stream_t *s, void *buf, int buf_size)
+{
+    assert(s->buf_cur <= s->buf_end);
+    assert(buf_size >= 0);
+    if (s->buf_cur == s->buf_end && buf_size > 0) {
+        if (buf_size > (s->buffer_mask + 1) / 2) {
+            // Direct read if the buffer is too small anyway.
+            stream_drop_buffers(s);
+            return stream_read_unbuffered(s, buf, buf_size);
+        }
+        stream_read_more(s, 1);
+    }
+    int res = ring_copy(s, buf, buf_size, s->buf_cur);
+    s->buf_cur += res;
+    return res;
+}
+
+// Slow version of stream_read_char(); called by it if the buffer is empty.
+int stream_read_char_fallback(stream_t *s)
+{
+    uint8_t c;
+    return stream_read_partial(s, &c, 1) ? c : -256;
+}
+
+int stream_read(stream_t *s, void *mem, int total)
+{
+    int len = total;
+    while (len > 0) {
+        int read = stream_read_partial(s, mem, len);
+        if (read <= 0)
+            break; // EOF
+        mem = (char *)mem + read;
+        len -= read;
+    }
+    total -= len;
+    return total;
+}
+
+// Read ahead so that at least forward_size bytes are readable ahead. Returns
+// the actual forward amount available (restricted by EOF or buffer limits).
+int stream_peek(stream_t *s, int forward_size)
+{
+    while (stream_read_more(s, forward_size)) {}
+    return s->buf_end - s->buf_cur;
+}
+
+// Like stream_read(), but do not advance the current position. This may resize
+// the buffer to satisfy the read request.
+int stream_read_peek(stream_t *s, void *buf, int buf_size)
+{
+    stream_peek(s, buf_size);
+    return ring_copy(s, buf, buf_size, s->buf_cur);
+}
+
+int stream_write_buffer(stream_t *s, void *buf, int len)
+{
+    if (!s->write_buffer)
+        return -1;
+    int orig_len = len;
+    while (len) {
+        int w = s->write_buffer(s, buf, len);
+        if (w <= 0)
+            return -1;
+        s->pos += w;
+        buf = (char *)buf + w;
+        len -= w;
+    }
+    return orig_len;
+}
+
+// Drop len bytes form input, possibly reading more until all is skipped. If
+// EOF or an error was encountered before all could be skipped, return false,
+// otherwise return true.
+static bool stream_skip_read(struct stream *s, int64_t len)
+{
+    while (len > 0) {
+        unsigned int left = s->buf_end - s->buf_cur;
+        if (!left) {
+            if (!stream_read_more(s, 1))
+                return false;
+            continue;
+        }
+        unsigned skip = MPMIN(len, left);
+        s->buf_cur += skip;
+        len -= skip;
+    }
+    return true;
+}
+
+// Drop the internal buffer. Note that this will advance the stream position
+// (as seen by stream_tell()), because the real stream position is ahead of the
+// logical stream position by the amount of buffered but not yet read data.
+void stream_drop_buffers(stream_t *s)
+{
+    s->pos = stream_tell(s);
+    s->buf_start = s->buf_cur = s->buf_end = 0;
+    s->eof = 0;
+    stream_resize_buffer(s, 0, 0);
+}
+
+// Seek function bypassing the local stream buffer.
+static bool stream_seek_unbuffered(stream_t *s, int64_t newpos)
+{
+    if (newpos != s->pos) {
+        MP_VERBOSE(s, "stream level seek from %" PRId64 " to %" PRId64 "\n",
+                   s->pos, newpos);
+
+        s->total_stream_seeks++;
+
+        if (newpos > s->pos && !s->seekable) {
+            MP_ERR(s, "Cannot seek forward in this stream\n");
+            return false;
+        }
+        if (newpos < s->pos && !s->seekable) {
+            MP_ERR(s, "Cannot seek backward in linear streams!\n");
+            return false;
+        }
+        if (s->seek(s, newpos) <= 0) {
+            int level = mp_cancel_test(s->cancel) ? MSGL_V : MSGL_ERR;
+            MP_MSG(s, level, "Seek failed (to %lld, size %lld)\n",
+                   (long long)newpos, (long long)stream_get_size(s));
+            return false;
+        }
+        stream_drop_buffers(s);
+        s->pos = newpos;
+    }
+    return true;
+}
+
+bool stream_seek(stream_t *s, int64_t pos)
+{
+    MP_TRACE(s, "seek request from %" PRId64 " to %" PRId64 "\n",
+             stream_tell(s), pos);
+
+    s->eof = 0; // eof should be set only on read; seeking always clears it
+
+    if (pos < 0) {
+        MP_ERR(s, "Invalid seek to negative position %lld!\n", (long long)pos);
+        pos = 0;
+    }
+
+    if (pos <= s->pos) {
+        int64_t x = pos - (s->pos - (int)s->buf_end);
+        if (x >= (int)s->buf_start) {
+            s->buf_cur = x;
+            assert(s->buf_cur >= s->buf_start);
+            assert(s->buf_cur <= s->buf_end);
+            return true;
+        }
+    }
+
+    if (s->mode == STREAM_WRITE)
+        return s->seekable && s->seek(s, pos);
+
+    // Skip data instead of performing a seek in some cases.
+    if (pos >= s->pos &&
+        ((!s->seekable && s->fast_skip) ||
+         pos - s->pos <= s->requested_buffer_size))
+    {
+        return stream_skip_read(s, pos - stream_tell(s));
+    }
+
+    return stream_seek_unbuffered(s, pos);
+}
+
+// Like stream_seek(), but strictly prefer skipping data instead of failing, if
+// it's a forward-seek.
+bool stream_seek_skip(stream_t *s, int64_t pos)
+{
+    uint64_t cur_pos = stream_tell(s);
+
+    if (cur_pos == pos)
+        return true;
+
+    return !s->seekable && pos > cur_pos
+        ? stream_skip_read(s, pos - cur_pos)
+        : stream_seek(s, pos);
+}
+
+int stream_control(stream_t *s, int cmd, void *arg)
+{
+    return s->control ? s->control(s, cmd, arg) : STREAM_UNSUPPORTED;
+}
+
+// Return the current size of the stream, or a negative value if unknown.
+int64_t stream_get_size(stream_t *s)
+{
+    return s->get_size ? s->get_size(s) : -1;
+}
+
+void free_stream(stream_t *s)
+{
+    if (!s)
+        return;
+
+    if (s->close)
+        s->close(s);
+    talloc_free(s);
+}
+
+static const char *const bom[3] = {"\xEF\xBB\xBF", "\xFF\xFE", "\xFE\xFF"};
+
+// Return utf16 argument for stream_read_line
+int stream_skip_bom(struct stream *s)
+{
+    char buf[4];
+    int len = stream_read_peek(s, buf, sizeof(buf));
+    bstr data = {buf, len};
+    for (int n = 0; n < 3; n++) {
+        if (bstr_startswith0(data, bom[n])) {
+            stream_seek_skip(s, stream_tell(s) + strlen(bom[n]));
+            return n;
+        }
+    }
+    return -1; // default to 8 bit codepages
+}
+
+// Read the rest of the stream into memory (current pos to EOF), and return it.
+//  talloc_ctx: used as talloc parent for the returned allocation
+//  max_size: must be set to >0. If the file is larger than that, it is treated
+//            as error. This is a minor robustness measure.
+//  returns: stream contents, or .start/.len set to NULL on error
+// If the file was empty, but no error happened, .start will be non-NULL and
+// .len will be 0.
+// For convenience, the returned buffer is padded with a 0 byte. The padding
+// is not included in the returned length.
+struct bstr stream_read_complete(struct stream *s, void *talloc_ctx,
+                                 int max_size)
+{
+    if (max_size > 1000000000)
+        abort();
+
+    int bufsize;
+    int total_read = 0;
+    int padding = 1;
+    char *buf = NULL;
+    int64_t size = stream_get_size(s) - stream_tell(s);
+    if (size > max_size)
+        return (struct bstr){NULL, 0};
+    if (size > 0)
+        bufsize = size + padding;
+    else
+        bufsize = 1000;
+    while (1) {
+        buf = talloc_realloc_size(talloc_ctx, buf, bufsize);
+        int readsize = stream_read(s, buf + total_read, bufsize - total_read);
+        total_read += readsize;
+        if (total_read < bufsize)
+            break;
+        if (bufsize > max_size) {
+            talloc_free(buf);
+            return (struct bstr){NULL, 0};
+        }
+        bufsize = MPMIN(bufsize + (bufsize >> 1), max_size + padding);
+    }
+    buf = talloc_realloc_size(talloc_ctx, buf, total_read + padding);
+    memset(&buf[total_read], 0, padding);
+    return (struct bstr){buf, total_read};
+}
+
+struct bstr stream_read_file(const char *filename, void *talloc_ctx,
+                             struct mpv_global *global, int max_size)
+{
+    struct bstr res = {0};
+    int flags = STREAM_ORIGIN_DIRECT | STREAM_READ | STREAM_LOCAL_FS_ONLY |
+                STREAM_LESS_NOISE;
+    stream_t *s = stream_create(filename, flags, NULL, global);
+    if (s) {
+        res = stream_read_complete(s, talloc_ctx, max_size);
+        free_stream(s);
+    }
+    return res;
+}
+
+char **stream_get_proto_list(void)
+{
+    char **list = NULL;
+    int num = 0;
+    for (int i = 0; i < MP_ARRAY_SIZE(stream_list); i++) {
+        const stream_info_t *stream_info = stream_list[i];
+
+        if (!stream_info->protocols)
+            continue;
+
+        for (int j = 0; stream_info->protocols[j]; j++) {
+            if (*stream_info->protocols[j] == '\0')
+               continue;
+
+            MP_TARRAY_APPEND(NULL, list, num,
+                                talloc_strdup(NULL, stream_info->protocols[j]));
+        }
+    }
+    MP_TARRAY_APPEND(NULL, list, num, NULL);
+    return list;
+}
+
+void stream_print_proto_list(struct mp_log *log)
+{
+    int count = 0;
+
+    mp_info(log, "Protocols:\n\n");
+    char **list = stream_get_proto_list();
+    for (int i = 0; list[i]; i++) {
+        mp_info(log, " %s://\n", list[i]);
+        count++;
+        talloc_free(list[i]);
+    }
+    talloc_free(list);
+    mp_info(log, "\nTotal: %d protocols\n", count);
+}
+
+bool stream_has_proto(const char *proto)
+{
+    for (int i = 0; i < MP_ARRAY_SIZE(stream_list); i++) {
+        const stream_info_t *stream_info = stream_list[i];
+
+        for (int j = 0; stream_info->protocols && stream_info->protocols[j]; j++) {
+            if (strcmp(stream_info->protocols[j], proto) == 0)
+                return true;
+        }
+    }
+
+    return false;
+}
diff --git a/stream/stream.h b/stream/stream.h
new file mode 100644
index 0000000..423ba12
--- /dev/null
+++ b/stream/stream.h
@@ -0,0 +1,269 @@
+/*
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MPLAYER_STREAM_H
+#define MPLAYER_STREAM_H
+
+#include "common/msg.h"
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+#include <inttypes.h>
+#include <sys/types.h>
+#include <fcntl.h>
+
+#include "misc/bstr.h"
+
+// Minimum guaranteed buffer and seek-back size. For any reads <= of this size,
+// it's guaranteed that you can seek back by <= of this size again.
+#define STREAM_BUFFER_SIZE 2048
+
+// flags for stream_open_ext (this includes STREAM_READ and STREAM_WRITE)
+
+// stream->mode
+#define STREAM_READ             0
+#define STREAM_WRITE            (1 << 0)
+
+#define STREAM_SILENT           (1 << 1)
+
+// Origin value for "security". This is an integer within the flags bit-field.
+#define STREAM_ORIGIN_DIRECT    (1 << 2) // passed from cmdline or loadfile
+#define STREAM_ORIGIN_FS        (2 << 2) // referenced from playlist on unix FS
+#define STREAM_ORIGIN_NET       (3 << 2) // referenced from playlist on network
+#define STREAM_ORIGIN_UNSAFE    (4 << 2) // from a grotesque source
+
+#define STREAM_ORIGIN_MASK      (7 << 2) // for extracting origin value from flags
+
+#define STREAM_LOCAL_FS_ONLY    (1 << 5) // stream_file only, no URLs
+#define STREAM_LESS_NOISE       (1 << 6) // try to log errors only
+
+// end flags for stream_open_ext (the naming convention sucks)
+
+#define STREAM_UNSAFE -3
+#define STREAM_NO_MATCH -2
+#define STREAM_UNSUPPORTED -1
+#define STREAM_ERROR 0
+#define STREAM_OK    1
+
+enum stream_ctrl {
+    // Certain network protocols
+    STREAM_CTRL_AVSEEK,
+    STREAM_CTRL_HAS_AVSEEK,
+    STREAM_CTRL_GET_METADATA,
+
+    // Optical discs (internal interface between streams and demux_disc)
+    STREAM_CTRL_GET_TIME_LENGTH,
+    STREAM_CTRL_GET_DVD_INFO,
+    STREAM_CTRL_GET_DISC_NAME,
+    STREAM_CTRL_GET_NUM_CHAPTERS,
+    STREAM_CTRL_GET_CURRENT_TIME,
+    STREAM_CTRL_GET_CHAPTER_TIME,
+    STREAM_CTRL_SEEK_TO_TIME,
+    STREAM_CTRL_GET_ASPECT_RATIO,
+    STREAM_CTRL_GET_NUM_ANGLES,
+    STREAM_CTRL_GET_ANGLE,
+    STREAM_CTRL_SET_ANGLE,
+    STREAM_CTRL_GET_NUM_TITLES,
+    STREAM_CTRL_GET_TITLE_LENGTH,       // double* (in: title number, out: len)
+    STREAM_CTRL_GET_LANG,
+    STREAM_CTRL_GET_CURRENT_TITLE,
+    STREAM_CTRL_SET_CURRENT_TITLE,
+};
+
+struct stream_lang_req {
+    int type;     // STREAM_AUDIO, STREAM_SUB
+    int id;
+    char name[50];
+};
+
+struct stream_dvd_info_req {
+    unsigned int palette[16];
+    int num_subs;
+};
+
+// for STREAM_CTRL_AVSEEK
+struct stream_avseek {
+    int stream_index;
+    int64_t timestamp;
+    int flags;
+};
+
+struct stream;
+struct stream_open_args;
+typedef struct stream_info_st {
+    const char *name;
+    // opts is set from ->opts
+    int (*open)(struct stream *st);
+    // Alternative to open(). Only either open() or open2() can be set.
+    int (*open2)(struct stream *st, const struct stream_open_args *args);
+    const char *const *protocols;
+    bool can_write;     // correctly checks for READ/WRITE modes
+    bool local_fs;      // supports STREAM_LOCAL_FS_ONLY
+    int stream_origin;  // 0 or set of STREAM_ORIGIN_*; if 0, the same origin
+                        // is set, or the stream's open() function handles it
+} stream_info_t;
+
+typedef struct stream {
+    const struct stream_info_st *info;
+
+    // Read
+    int (*fill_buffer)(struct stream *s, void *buffer, int max_len);
+    // Write
+    int (*write_buffer)(struct stream *s, void *buffer, int len);
+    // Seek
+    int (*seek)(struct stream *s, int64_t pos);
+    // Total stream size in bytes (negative if unavailable)
+    int64_t (*get_size)(struct stream *s);
+    // Control
+    int (*control)(struct stream *s, int cmd, void *arg);
+    // Close
+    void (*close)(struct stream *s);
+
+    int64_t pos;
+    int eof; // valid only after read calls that returned a short result
+    int mode; //STREAM_READ or STREAM_WRITE
+    int stream_origin; // any STREAM_ORIGIN_*
+    void *priv; // used for DVD, TV, RTSP etc
+    char *url;  // filename/url (possibly including protocol prefix)
+    char *path; // filename (url without protocol prefix)
+    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 streaming : 1; // known to be a network stream if true
+    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; // I really don't know what this is for
+    bool is_local_file : 1; // from the filesystem
+    bool is_directory : 1; // directory on the filesystem
+    bool access_references : 1; // open other streams
+    struct mp_log *log;
+    struct mpv_global *global;
+
+    struct mp_cancel *cancel;   // cancellation notification
+
+    // Read statistic for fill_buffer calls. All bytes read by fill_buffer() are
+    // added to this. The user can reset this as needed.
+    uint64_t total_unbuffered_read_bytes;
+    // Seek statistics. The user can reset this as needed.
+    uint64_t total_stream_seeks;
+
+    // Buffer size requested by user; s->buffer may have a different size
+    int requested_buffer_size;
+
+    // This is a ring buffer. It is reset only on seeks (or when buffers are
+    // dropped). Otherwise old contents always stay valid.
+    // The valid buffer is from buf_start to buf_end; buf_end can be larger
+    // than the buffer size (requires wrap around). buf_cur is a value in the
+    // range [buf_start, buf_end].
+    // When reading more data from the stream, buf_start is advanced as old
+    // data is overwritten with new data.
+    // Example:
+    //    0  1  2  3    4  5  6  7    8  9  10 11   12 13 14 15
+    //  +===========================+---------------------------+
+    //  + 05 06 07 08 | 01 02 03 04 + 05 06 07 08 | 01 02 03 04 +
+    //  +===========================+---------------------------+
+    //                  ^ buf_start (4)  |          |
+    //                                   |          ^ buf_end (12 % 8 => 4)
+    //                                   ^ buf_cur (9 % 8 => 1)
+    // Here, the entire 8 byte buffer is filled, i.e. buf_end - buf_start = 8.
+    // buffer_mask == 7, so (x & buffer_mask) == (x % buffer_size)
+    unsigned int buf_start; // index of oldest byte in buffer (is <= buffer_mask)
+    unsigned int buf_cur;   // current read pos (can be > buffer_mask)
+    unsigned int buf_end;   // end position (can be > buffer_mask)
+
+    unsigned int buffer_mask; // buffer_size-1, where buffer_size == 2**n
+    uint8_t *buffer;
+} stream_t;
+
+// Non-inline version of stream_read_char().
+int stream_read_char_fallback(stream_t *s);
+
+int stream_write_buffer(stream_t *s, void *buf, int len);
+
+inline static int stream_read_char(stream_t *s)
+{
+    return s->buf_cur < s->buf_end
+        ? s->buffer[(s->buf_cur++) & s->buffer_mask]
+        : stream_read_char_fallback(s);
+}
+
+int stream_skip_bom(struct stream *s);
+
+inline static int64_t stream_tell(stream_t *s)
+{
+    return s->pos + s->buf_cur - s->buf_end;
+}
+
+bool stream_seek_skip(stream_t *s, int64_t pos);
+bool stream_seek(stream_t *s, int64_t pos);
+int stream_read(stream_t *s, void *mem, int total);
+int stream_read_partial(stream_t *s, void *buf, int buf_size);
+int stream_peek(stream_t *s, int forward_size);
+int stream_read_peek(stream_t *s, void *buf, int buf_size);
+void stream_drop_buffers(stream_t *s);
+int64_t stream_get_size(stream_t *s);
+
+struct mpv_global;
+
+struct bstr stream_read_complete(struct stream *s, void *talloc_ctx,
+                                 int max_size);
+struct bstr stream_read_file(const char *filename, void *talloc_ctx,
+                             struct mpv_global *global, int max_size);
+
+int stream_control(stream_t *s, int cmd, void *arg);
+void free_stream(stream_t *s);
+
+struct stream_open_args {
+    struct mpv_global *global;
+    struct mp_cancel *cancel;   // aborting stream access (used directly)
+    const char *url;
+    int flags;                  // STREAM_READ etc.
+    const stream_info_t *sinfo; // NULL = autoprobe, otherwise force stream impl.
+    void *special_arg;          // specific to impl., use only with sinfo
+};
+
+int stream_create_with_args(struct stream_open_args *args, struct stream **ret);
+struct stream *stream_create(const char *url, int flags,
+                             struct mp_cancel *c, struct mpv_global *global);
+stream_t *open_output_stream(const char *filename, struct mpv_global *global);
+
+void mp_url_unescape_inplace(char *buf);
+char *mp_url_escape(void *talloc_ctx, const char *s, const char *ok);
+
+// stream_memory.c
+struct stream *stream_memory_open(struct mpv_global *global, void *data, int len);
+
+// stream_concat.c
+struct stream *stream_concat_open(struct mpv_global *global, struct mp_cancel *c,
+                                  struct stream **streams, int num_streams);
+
+// stream_file.c
+char *mp_file_url_to_filename(void *talloc_ctx, bstr url);
+char *mp_file_get_path(void *talloc_ctx, bstr url);
+
+// stream_lavf.c
+struct AVDictionary;
+void mp_setup_av_network_options(struct AVDictionary **dict,
+                                 const char *target_fmt,
+                                 struct mpv_global *global,
+                                 struct mp_log *log);
+
+void stream_print_proto_list(struct mp_log *log);
+char **stream_get_proto_list(void);
+bool stream_has_proto(const char *proto);
+
+#endif /* MPLAYER_STREAM_H */
diff --git a/stream/stream_avdevice.c b/stream/stream_avdevice.c
new file mode 100644
index 0000000..5046b21
--- /dev/null
+++ b/stream/stream_avdevice.c
@@ -0,0 +1,32 @@
+/*
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include "stream.h"
+
+static int open_f(stream_t *stream)
+{
+    stream->demuxer = "lavf";
+
+    return STREAM_OK;
+}
+
+const stream_info_t stream_info_avdevice = {
+    .name = "avdevice",
+    .open = open_f,
+    .protocols = (const char*const[]){ "avdevice", "av", NULL },
+    .stream_origin = STREAM_ORIGIN_UNSAFE,
+};
diff --git a/stream/stream_bluray.c b/stream/stream_bluray.c
new file mode 100644
index 0000000..7771375
--- /dev/null
+++ b/stream/stream_bluray.c
@@ -0,0 +1,632 @@
+/*
+ * Copyright (C) 2010 Benjamin Zores <ben@geexbox.org>
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * Blu-ray parser/reader using libbluray
+ *  Use 'git clone git://git.videolan.org/libbluray' to get it.
+ *
+ * TODO:
+ *  - Add descrambled keys database support (KEYDB.cfg)
+ *
+ */
+
+#include <string.h>
+#include <strings.h>
+#include <assert.h>
+
+#include <libbluray/bluray.h>
+#include <libbluray/meta_data.h>
+#include <libbluray/overlay.h>
+#include <libbluray/keys.h>
+#include <libbluray/bluray-version.h>
+#include <libbluray/log_control.h>
+#include <libavutil/common.h>
+
+#include "config.h"
+#include "mpv_talloc.h"
+#include "common/common.h"
+#include "common/msg.h"
+#include "options/m_config.h"
+#include "options/path.h"
+#include "stream.h"
+#include "osdep/timer.h"
+#include "sub/osd.h"
+#include "sub/img_convert.h"
+#include "video/mp_image.h"
+
+#define BLURAY_SECTOR_SIZE     6144
+
+#define BLURAY_DEFAULT_ANGLE      0
+#define BLURAY_DEFAULT_CHAPTER    0
+#define BLURAY_PLAYLIST_TITLE    -3
+#define BLURAY_DEFAULT_TITLE     -2
+#define BLURAY_MENU_TITLE        -1
+
+// 90khz ticks
+#define BD_TIMEBASE (90000)
+#define BD_TIME_TO_MP(x) ((x) / (double)(BD_TIMEBASE))
+#define BD_TIME_FROM_MP(x) ((uint64_t)(x * BD_TIMEBASE))
+
+// copied from aacs.h in libaacs
+#define AACS_ERROR_CORRUPTED_DISC -1 /* opening or reading of AACS files failed */
+#define AACS_ERROR_NO_CONFIG      -2 /* missing config file */
+#define AACS_ERROR_NO_PK          -3 /* no matching processing key */
+#define AACS_ERROR_NO_CERT        -4 /* no valid certificate */
+#define AACS_ERROR_CERT_REVOKED   -5 /* certificate has been revoked */
+#define AACS_ERROR_MMC_OPEN       -6 /* MMC open failed (no MMC drive ?) */
+#define AACS_ERROR_MMC_FAILURE    -7 /* MMC failed */
+#define AACS_ERROR_NO_DK          -8 /* no matching device key */
+
+
+struct bluray_opts {
+    char *bluray_device;
+};
+
+#define OPT_BASE_STRUCT struct bluray_opts
+const struct m_sub_options stream_bluray_conf = {
+    .opts = (const struct m_option[]) {
+        {"device", OPT_STRING(bluray_device), .flags = M_OPT_FILE},
+        {0},
+    },
+    .size = sizeof(struct bluray_opts),
+};
+
+struct bluray_priv_s {
+    BLURAY *bd;
+    BLURAY_TITLE_INFO *title_info;
+    int num_titles;
+    int current_angle;
+    int current_title;
+    int current_playlist;
+
+    int cfg_title;
+    int cfg_playlist;
+    char *cfg_device;
+
+    bool use_nav;
+    struct bluray_opts *opts;
+    struct m_config_cache *opts_cache;
+};
+
+static void destruct(struct bluray_priv_s *priv)
+{
+    if (priv->title_info)
+        bd_free_title_info(priv->title_info);
+    bd_close(priv->bd);
+}
+
+inline static int play_playlist(struct bluray_priv_s *priv, int playlist)
+{
+    return bd_select_playlist(priv->bd, playlist);
+}
+
+inline static int play_title(struct bluray_priv_s *priv, int title)
+{
+    return bd_select_title(priv->bd, title);
+}
+
+static void bluray_stream_close(stream_t *s)
+{
+    destruct(s->priv);
+}
+
+static void handle_event(stream_t *s, const BD_EVENT *ev)
+{
+    struct bluray_priv_s *b = s->priv;
+    switch (ev->event) {
+    case BD_EVENT_MENU:
+        break;
+    case BD_EVENT_STILL:
+        break;
+    case BD_EVENT_STILL_TIME:
+        bd_read_skip_still(b->bd);
+        break;
+    case BD_EVENT_END_OF_TITLE:
+        break;
+    case BD_EVENT_PLAYLIST:
+        b->current_playlist = ev->param;
+        b->current_title = bd_get_current_title(b->bd);
+        if (b->title_info)
+            bd_free_title_info(b->title_info);
+        b->title_info = bd_get_playlist_info(b->bd, b->current_playlist,
+                                             b->current_angle);
+        break;
+    case BD_EVENT_TITLE:
+        if (ev->param == BLURAY_TITLE_FIRST_PLAY) {
+            b->current_title = bd_get_current_title(b->bd);
+        } else
+            b->current_title = ev->param;
+        if (b->title_info) {
+            bd_free_title_info(b->title_info);
+            b->title_info = NULL;
+        }
+        break;
+    case BD_EVENT_ANGLE:
+        b->current_angle = ev->param;
+        if (b->title_info) {
+            bd_free_title_info(b->title_info);
+            b->title_info = bd_get_playlist_info(b->bd, b->current_playlist,
+                                                 b->current_angle);
+        }
+        break;
+    case BD_EVENT_POPUP:
+        break;
+#if BLURAY_VERSION >= BLURAY_VERSION_CODE(0, 5, 0)
+    case BD_EVENT_DISCONTINUITY:
+        break;
+#endif
+    default:
+        MP_TRACE(s, "Unhandled event: %d %d\n", ev->event, ev->param);
+        break;
+    }
+}
+
+static int bluray_stream_fill_buffer(stream_t *s, void *buf, int len)
+{
+    struct bluray_priv_s *b = s->priv;
+    BD_EVENT event;
+    while (bd_get_event(b->bd, &event))
+        handle_event(s, &event);
+    return bd_read(b->bd, buf, len);
+}
+
+static int bluray_stream_control(stream_t *s, int cmd, void *arg)
+{
+    struct bluray_priv_s *b = s->priv;
+
+    switch (cmd) {
+    case STREAM_CTRL_GET_NUM_CHAPTERS: {
+        const BLURAY_TITLE_INFO *ti = b->title_info;
+        if (!ti)
+            return STREAM_UNSUPPORTED;
+        *((unsigned int *) arg) = ti->chapter_count;
+        return STREAM_OK;
+    }
+    case STREAM_CTRL_GET_CHAPTER_TIME: {
+        const BLURAY_TITLE_INFO *ti = b->title_info;
+        if (!ti)
+            return STREAM_UNSUPPORTED;
+        int chapter = *(double *)arg;
+        double time = MP_NOPTS_VALUE;
+        if (chapter >= 0 || chapter < ti->chapter_count)
+            time = BD_TIME_TO_MP(ti->chapters[chapter].start);
+        if (time == MP_NOPTS_VALUE)
+            return STREAM_ERROR;
+        *(double *)arg = time;
+        return STREAM_OK;
+    }
+    case STREAM_CTRL_SET_CURRENT_TITLE: {
+        const uint32_t title = *((unsigned int*)arg);
+        if (title >= b->num_titles || !play_title(b, title))
+            return STREAM_UNSUPPORTED;
+        b->current_title = title;
+        return STREAM_OK;
+    }
+    case STREAM_CTRL_GET_CURRENT_TITLE: {
+        *((unsigned int *) arg) = b->current_title;
+        return STREAM_OK;
+    }
+    case STREAM_CTRL_GET_NUM_TITLES: {
+        *((unsigned int *)arg) = b->num_titles;
+        return STREAM_OK;
+    }
+    case STREAM_CTRL_GET_TIME_LENGTH: {
+        const BLURAY_TITLE_INFO *ti = b->title_info;
+        if (!ti)
+            return STREAM_UNSUPPORTED;
+        *((double *) arg) = BD_TIME_TO_MP(ti->duration);
+        return STREAM_OK;
+    }
+    case STREAM_CTRL_GET_CURRENT_TIME: {
+        *((double *) arg) = BD_TIME_TO_MP(bd_tell_time(b->bd));
+        return STREAM_OK;
+    }
+    case STREAM_CTRL_SEEK_TO_TIME: {
+        double pts = *((double *) arg);
+        bd_seek_time(b->bd, BD_TIME_FROM_MP(pts));
+        stream_drop_buffers(s);
+        // API makes it hard to determine seeking success
+        return STREAM_OK;
+    }
+    case STREAM_CTRL_GET_NUM_ANGLES: {
+        const BLURAY_TITLE_INFO *ti = b->title_info;
+        if (!ti)
+            return STREAM_UNSUPPORTED;
+        *((int *) arg) = ti->angle_count;
+        return STREAM_OK;
+    }
+    case STREAM_CTRL_GET_ANGLE: {
+        *((int *) arg) = b->current_angle;
+        return STREAM_OK;
+    }
+    case STREAM_CTRL_SET_ANGLE: {
+        const BLURAY_TITLE_INFO *ti = b->title_info;
+        if (!ti)
+            return STREAM_UNSUPPORTED;
+        int angle = *((int *) arg);
+        if (angle < 0 || angle > ti->angle_count)
+            return STREAM_UNSUPPORTED;
+        b->current_angle = angle;
+        bd_seamless_angle_change(b->bd, angle);
+        return STREAM_OK;
+    }
+    case STREAM_CTRL_GET_LANG: {
+        const BLURAY_TITLE_INFO *ti = b->title_info;
+        if (ti && ti->clip_count) {
+            struct stream_lang_req *req = arg;
+            BLURAY_STREAM_INFO *si = NULL;
+            int count = 0;
+            switch (req->type) {
+            case STREAM_AUDIO:
+                count = ti->clips[0].audio_stream_count;
+                si = ti->clips[0].audio_streams;
+                break;
+            case STREAM_SUB:
+                count = ti->clips[0].pg_stream_count;
+                si = ti->clips[0].pg_streams;
+                break;
+            }
+            for (int n = 0; n < count; n++) {
+                BLURAY_STREAM_INFO *i = &si[n];
+                if (i->pid == req->id) {
+                    snprintf(req->name, sizeof(req->name), "%.4s", i->lang);
+                    return STREAM_OK;
+                }
+            }
+        }
+        return STREAM_ERROR;
+    }
+    case STREAM_CTRL_GET_DISC_NAME: {
+        const struct meta_dl *meta = bd_get_meta(b->bd);
+        if (!meta || !meta->di_name || !meta->di_name[0])
+            break;
+        *(char**)arg = talloc_strdup(NULL, meta->di_name);
+        return STREAM_OK;
+    }
+    default:
+        break;
+    }
+
+    return STREAM_UNSUPPORTED;
+}
+
+static const char *aacs_strerr(int err)
+{
+    switch (err) {
+    case AACS_ERROR_CORRUPTED_DISC: return "opening or reading of AACS files failed";
+    case AACS_ERROR_NO_CONFIG:      return "missing config file";
+    case AACS_ERROR_NO_PK:          return "no matching processing key";
+    case AACS_ERROR_NO_CERT:        return "no valid certificate";
+    case AACS_ERROR_CERT_REVOKED:   return "certificate has been revoked";
+    case AACS_ERROR_MMC_OPEN:       return "MMC open failed (maybe no MMC drive?)";
+    case AACS_ERROR_MMC_FAILURE:    return "MMC failed";
+    case AACS_ERROR_NO_DK:          return "no matching device key";
+    default:                        return "unknown error";
+    }
+}
+
+static bool check_disc_info(stream_t *s)
+{
+    struct bluray_priv_s *b = s->priv;
+    const BLURAY_DISC_INFO *info = bd_get_disc_info(b->bd);
+
+    // check Blu-ray
+    if (!info->bluray_detected) {
+        MP_ERR(s, "Given stream is not a Blu-ray.\n");
+        return false;
+    }
+
+    // check AACS
+    if (info->aacs_detected) {
+        if (!info->libaacs_detected) {
+            MP_ERR(s, "AACS encryption detected but cannot find libaacs.\n");
+            return false;
+        }
+        if (!info->aacs_handled) {
+            MP_ERR(s, "AACS error: %s\n", aacs_strerr(info->aacs_error_code));
+            return false;
+        }
+    }
+
+    // check BD+
+    if (info->bdplus_detected) {
+        if (!info->libbdplus_detected) {
+            MP_ERR(s, "BD+ encryption detected but cannot find libbdplus.\n");
+            return false;
+        }
+        if (!info->bdplus_handled) {
+            MP_ERR(s, "Cannot decrypt BD+ encryption.\n");
+            return false;
+        }
+    }
+
+    return true;
+}
+
+static void select_initial_title(stream_t *s, int title_guess) {
+    struct bluray_priv_s *b = s->priv;
+
+    if (b->cfg_title == BLURAY_PLAYLIST_TITLE) {
+        if (!play_playlist(b, b->cfg_playlist))
+            MP_WARN(s, "Couldn't start playlist '%05d'.\n", b->cfg_playlist);
+        b->current_title = bd_get_current_title(b->bd);
+    } else {
+        int title = -1;
+        if (b->cfg_title != BLURAY_DEFAULT_TITLE )
+            title = b->cfg_title;
+        else
+            title = title_guess;
+        if (title < 0)
+            return;
+
+        if (play_title(b, title))
+            b->current_title = title;
+        else {
+            MP_WARN(s, "Couldn't start title '%d'.\n", title);
+            b->current_title = bd_get_current_title(b->bd);
+        }
+    }
+}
+
+static int bluray_stream_open_internal(stream_t *s)
+{
+    struct bluray_priv_s *b = s->priv;
+
+    char *device = NULL;
+    /* find the requested device */
+    if (b->cfg_device && b->cfg_device[0]) {
+        device = b->cfg_device;
+    } else {
+        device = b->opts->bluray_device;
+    }
+
+    if (!device || !device[0]) {
+        MP_ERR(s, "No Blu-ray device/location was specified ...\n");
+        return STREAM_UNSUPPORTED;
+    }
+
+    if (!mp_msg_test(s->log, MSGL_DEBUG))
+        bd_set_debug_mask(0);
+
+    /* open device */
+    BLURAY *bd = bd_open(device, NULL);
+    if (!bd) {
+        MP_ERR(s, "Couldn't open Blu-ray device: %s\n", device);
+        return STREAM_UNSUPPORTED;
+    }
+    b->bd = bd;
+
+    if (!check_disc_info(s)) {
+        destruct(b);
+        return STREAM_UNSUPPORTED;
+    }
+
+    int title_guess = BLURAY_DEFAULT_TITLE;
+    if (b->use_nav) {
+        MP_FATAL(s, "BluRay menu support has been removed.\n");
+        return STREAM_ERROR;
+    } else {
+        /* check for available titles on disc */
+        b->num_titles = bd_get_titles(bd, TITLES_RELEVANT, 0);
+        if (!b->num_titles) {
+            MP_ERR(s, "Can't find any Blu-ray-compatible title here.\n");
+            destruct(b);
+            return STREAM_UNSUPPORTED;
+        }
+
+        MP_INFO(s, "List of available titles:\n");
+
+        /* parse titles information */
+        uint64_t max_duration = 0;
+        for (int i = 0; i < b->num_titles; i++) {
+            BLURAY_TITLE_INFO *ti = bd_get_title_info(bd, i, 0);
+            if (!ti)
+                continue;
+
+            char *time = mp_format_time(ti->duration / 90000, false);
+            MP_INFO(s, "idx: %3d duration: %s (playlist: %05d.mpls)\n",
+                       i, time, ti->playlist);
+            talloc_free(time);
+
+            /* try to guess which title may contain the main movie */
+            if (ti->duration > max_duration) {
+                max_duration = ti->duration;
+                title_guess = i;
+            }
+
+            bd_free_title_info(ti);
+        }
+    }
+
+    // these should be set before any callback
+    b->current_angle = -1;
+    b->current_title = -1;
+
+    // initialize libbluray event queue
+    bd_get_event(bd, NULL);
+
+    select_initial_title(s, title_guess);
+
+    s->fill_buffer = bluray_stream_fill_buffer;
+    s->close       = bluray_stream_close;
+    s->control     = bluray_stream_control;
+    s->priv        = b;
+    s->demuxer     = "+disc";
+
+    MP_VERBOSE(s, "Blu-ray successfully opened.\n");
+
+    return STREAM_OK;
+}
+
+const stream_info_t stream_info_bdnav;
+
+static int bluray_stream_open(stream_t *s)
+{
+    struct bluray_priv_s *b = talloc_zero(s, struct bluray_priv_s);
+    s->priv = b;
+
+    struct m_config_cache *opts_cache =
+        m_config_cache_alloc(s, s->global, &stream_bluray_conf);
+
+    b->opts_cache = opts_cache;
+    b->opts = opts_cache->opts;
+
+    b->use_nav = s->info == &stream_info_bdnav;
+
+    bstr title, bdevice, rest = { .len = 0 };
+    bstr_split_tok(bstr0(s->path), "/", &title, &bdevice);
+
+    b->cfg_title = BLURAY_DEFAULT_TITLE;
+
+    if (bstr_equals0(title, "longest") || bstr_equals0(title, "first")) {
+        b->cfg_title = BLURAY_DEFAULT_TITLE;
+    } else if (bstr_equals0(title, "menu")) {
+        b->cfg_title = BLURAY_MENU_TITLE;
+    } else if (bstr_equals0(title, "mpls")) {
+        bstr_split_tok(bdevice, "/", &title, &bdevice);
+        long long pl = bstrtoll(title, &rest, 10);
+        if (rest.len) {
+            MP_ERR(s, "number expected: '%.*s'\n", BSTR_P(rest));
+            return STREAM_ERROR;
+        } else if (pl < 0 || 99999 < pl) {
+            MP_ERR(s, "invalid playlist: '%.*s', must be in the range 0-99999\n",
+                            BSTR_P(title));
+            return STREAM_ERROR;
+        }
+        b->cfg_playlist = pl;
+        b->cfg_title    = BLURAY_PLAYLIST_TITLE;
+    } else if (title.len) {
+        long long t = bstrtoll(title, &rest, 10);
+        if (rest.len) {
+            MP_ERR(s, "number expected: '%.*s'\n", BSTR_P(rest));
+            return STREAM_ERROR;
+        } else if (t < 0 || 99999 < t) {
+            MP_ERR(s, "invalid title: '%.*s', must be in the range 0-99999\n",
+                            BSTR_P(title));
+            return STREAM_ERROR;
+        }
+        b->cfg_title = t;
+    }
+
+    b->cfg_device = bstrto0(b, bdevice);
+
+    return bluray_stream_open_internal(s);
+}
+
+const stream_info_t stream_info_bluray = {
+    .name = "bd",
+    .open = bluray_stream_open,
+    .protocols = (const char*const[]){ "bd", "br", "bluray", NULL },
+    .stream_origin = STREAM_ORIGIN_UNSAFE,
+};
+
+const stream_info_t stream_info_bdnav = {
+    .name = "bdnav",
+    .open = bluray_stream_open,
+    .protocols = (const char*const[]){ "bdnav", "brnav", "bluraynav", NULL },
+    .stream_origin = STREAM_ORIGIN_UNSAFE,
+};
+
+static bool check_bdmv(const char *path)
+{
+    if (strcasecmp(mp_basename(path), "MovieObject.bdmv"))
+        return false;
+
+    FILE *temp = fopen(path, "rb");
+    if (!temp)
+        return false;
+
+    char data[50] = {0};
+
+    fread(data, 50, 1, temp);
+    fclose(temp);
+
+    bstr bdata = {data, 50};
+
+    return bstr_startswith0(bdata, "MOBJ0100") || // AVCHD
+           bstr_startswith0(bdata, "MOBJ0200") || // Blu-ray
+           bstr_startswith0(bdata, "MOBJ0300");   // UHD BD
+}
+
+// Destructively remove the current trailing path component.
+static void remove_prefix(char *path)
+{
+    size_t len = strlen(path);
+#if HAVE_DOS_PATHS
+    const char *seps = "/\\";
+#else
+    const char *seps = "/";
+#endif
+    while (len > 0 && !strchr(seps, path[len - 1]))
+        len--;
+    while (len > 0 && strchr(seps, path[len - 1]))
+        len--;
+    path[len] = '\0';
+}
+
+static int bdmv_dir_stream_open(stream_t *stream)
+{
+    struct bluray_priv_s *priv = talloc_ptrtype(stream, priv);
+    stream->priv = priv;
+    *priv = (struct bluray_priv_s){
+        .cfg_title = BLURAY_DEFAULT_TITLE,
+    };
+
+    if (!stream->access_references)
+        goto unsupported;
+
+    char *path = mp_file_get_path(priv, bstr0(stream->url));
+    if (!path)
+        goto unsupported;
+
+    // We allow the path to point to a directory containing BDMV/, a
+    // directory containing MovieObject.bdmv, or that file itself.
+    if (!check_bdmv(path)) {
+        // On UNIX, just assume the filename has always this case.
+        char *npath = mp_path_join(priv, path, "MovieObject.bdmv");
+        if (!check_bdmv(npath)) {
+            npath = mp_path_join(priv, path, "BDMV/MovieObject.bdmv");
+            if (!check_bdmv(npath))
+                goto unsupported;
+        }
+        path = npath;
+    }
+
+    // Go up by 2 levels.
+    remove_prefix(path);
+    remove_prefix(path);
+    priv->cfg_device = path;
+    if (strlen(priv->cfg_device) <= 1)
+        goto unsupported;
+
+    MP_INFO(stream, "BDMV detected. Redirecting to bluray://\n");
+    return bluray_stream_open_internal(stream);
+
+unsupported:
+    talloc_free(priv);
+    stream->priv = NULL;
+    return STREAM_UNSUPPORTED;
+}
+
+const stream_info_t stream_info_bdmv_dir = {
+    .name = "bdmv/bluray",
+    .open = bdmv_dir_stream_open,
+    .protocols = (const char*const[]){ "file", "", NULL },
+    .stream_origin = STREAM_ORIGIN_UNSAFE,
+};
diff --git a/stream/stream_cb.c b/stream/stream_cb.c
new file mode 100644
index 0000000..29e5563
--- /dev/null
+++ b/stream/stream_cb.c
@@ -0,0 +1,108 @@
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+
+#include "osdep/io.h"
+
+#include "common/common.h"
+#include "common/msg.h"
+#include "common/global.h"
+#include "stream.h"
+#include "options/m_option.h"
+#include "options/path.h"
+#include "player/client.h"
+#include "libmpv/stream_cb.h"
+#include "misc/thread_tools.h"
+
+struct priv {
+    mpv_stream_cb_info info;
+    struct mp_cancel *cancel;
+};
+
+static int fill_buffer(stream_t *s, void *buffer, int max_len)
+{
+    struct priv *p = s->priv;
+    return (int)p->info.read_fn(p->info.cookie, buffer, (size_t)max_len);
+}
+
+static int seek(stream_t *s, int64_t newpos)
+{
+    struct priv *p = s->priv;
+    return p->info.seek_fn(p->info.cookie, newpos) >= 0;
+}
+
+static int64_t get_size(stream_t *s)
+{
+    struct priv *p = s->priv;
+
+    if (p->info.size_fn) {
+        int64_t size = p->info.size_fn(p->info.cookie);
+        if (size >= 0)
+            return size;
+    }
+
+    return -1;
+}
+
+static void s_close(stream_t *s)
+{
+    struct priv *p = s->priv;
+    p->info.close_fn(p->info.cookie);
+}
+
+static int open_cb(stream_t *stream)
+{
+    struct priv *p = talloc_ptrtype(stream, p);
+    stream->priv = p;
+
+    bstr bproto = mp_split_proto(bstr0(stream->url), NULL);
+    char *proto = bstrto0(stream, bproto);
+
+    void *user_data;
+    mpv_stream_cb_open_ro_fn open_fn;
+
+    if (!mp_streamcb_lookup(stream->global, proto, &user_data, &open_fn))
+        return STREAM_UNSUPPORTED;
+
+    mpv_stream_cb_info info = {0};
+
+    int r = open_fn(user_data, stream->url, &info);
+    if (r < 0) {
+        if (r != MPV_ERROR_LOADING_FAILED)
+            MP_WARN(stream, "unknown error from user callback\n");
+        return STREAM_ERROR;
+    }
+
+    if (!info.read_fn || !info.close_fn) {
+        MP_FATAL(stream, "required read_fn or close_fn callbacks not set.\n");
+        return STREAM_ERROR;
+    }
+
+    p->info = info;
+
+    if (p->info.seek_fn && p->info.seek_fn(p->info.cookie, 0) >= 0) {
+        stream->seek = seek;
+        stream->seekable = true;
+    }
+    stream->fast_skip = true;
+    stream->fill_buffer = fill_buffer;
+    stream->get_size = get_size;
+    stream->close = s_close;
+
+    if (p->info.cancel_fn && stream->cancel) {
+        p->cancel = mp_cancel_new(p);
+        mp_cancel_set_parent(p->cancel, stream->cancel);
+        mp_cancel_set_cb(p->cancel, p->info.cancel_fn, p->info.cookie);
+    }
+
+    return STREAM_OK;
+}
+
+const stream_info_t stream_info_cb = {
+    .name = "stream_callback",
+    .open = open_cb,
+    .stream_origin = STREAM_ORIGIN_UNSAFE,
+};
diff --git a/stream/stream_cdda.c b/stream/stream_cdda.c
new file mode 100644
index 0000000..71ae461
--- /dev/null
+++ b/stream/stream_cdda.c
@@ -0,0 +1,369 @@
+/*
+ * Original author: Albeu
+ *
+ * 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 <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <cdio/cdio.h>
+
+// For cdio_cddap_version
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wstrict-prototypes"
+#include <cdio/paranoia/cdda.h>
+#include <cdio/paranoia/paranoia.h>
+#pragma GCC diagnostic pop
+
+#include "common/msg.h"
+#include "config.h"
+#include "mpv_talloc.h"
+
+#include "stream.h"
+#include "options/m_option.h"
+#include "options/m_config.h"
+#include "options/options.h"
+
+#if !HAVE_GPL
+#error GPL only
+#endif
+
+typedef struct cdda_params {
+    cdrom_drive_t *cd;
+    cdrom_paranoia_t *cdp;
+    int sector;
+    int start_sector;
+    int end_sector;
+    uint8_t *data;
+    size_t data_pos;
+
+    // options
+    char *cdda_device;
+    int speed;
+    int paranoia_mode;
+    int sector_size;
+    int search_overlap;
+    int toc_bias;
+    int toc_offset;
+    bool skip;
+    char *device;
+    int span[2];
+    bool cdtext;
+} cdda_priv;
+
+#define OPT_BASE_STRUCT struct cdda_params
+const struct m_sub_options stream_cdda_conf = {
+    .opts = (const m_option_t[]) {
+        {"device", OPT_STRING(cdda_device), .flags = M_OPT_FILE},
+        {"speed", OPT_INT(speed), M_RANGE(1, 100)},
+        {"paranoia", OPT_INT(paranoia_mode), M_RANGE(0, 2)},
+        {"sector-size", OPT_INT(sector_size), M_RANGE(1, 100)},
+        {"overlap", OPT_INT(search_overlap), M_RANGE(0, 75)},
+        {"toc-bias", OPT_INT(toc_bias),
+            .deprecation_message = "toc-bias is no longer used"},
+        {"toc-offset", OPT_INT(toc_offset)},
+        {"skip", OPT_BOOL(skip)},
+        {"span-a", OPT_INT(span[0])},
+        {"span-b", OPT_INT(span[1])},
+        {"cdtext", OPT_BOOL(cdtext)},
+        {0}
+    },
+    .size = sizeof(struct cdda_params),
+    .defaults = &(const struct cdda_params){
+        .search_overlap = -1,
+        .skip = true,
+    },
+};
+
+static const char *const cdtext_name[] = {
+    [CDTEXT_FIELD_ARRANGER] = "Arranger",
+    [CDTEXT_FIELD_COMPOSER] = "Composer",
+    [CDTEXT_FIELD_MESSAGE]  =  "Message",
+    [CDTEXT_FIELD_ISRC] =  "ISRC",
+    [CDTEXT_FIELD_PERFORMER] = "Performer",
+    [CDTEXT_FIELD_SONGWRITER] =  "Songwriter",
+    [CDTEXT_FIELD_TITLE] =  "Title",
+    [CDTEXT_FIELD_UPC_EAN] = "UPC_EAN",
+};
+
+static void print_cdtext(stream_t *s, int track)
+{
+    cdda_priv* p = (cdda_priv*)s->priv;
+    if (!p->cdtext)
+        return;
+    cdtext_t *text = cdio_get_cdtext(p->cd->p_cdio);
+    int header = 0;
+    if (text) {
+        for (int i = 0; i < sizeof(cdtext_name) / sizeof(cdtext_name[0]); i++) {
+            const char *name = cdtext_name[i];
+            const char *value = cdtext_get_const(text, i, track);
+            if (name && value) {
+                if (!header)
+                    MP_INFO(s, "CD-Text (%s):\n", track ? "track" : "CD");
+                header = 1;
+                MP_INFO(s, "  %s: '%s'\n", name, value);
+            }
+        }
+    }
+}
+
+static void print_track_info(stream_t *s, int track)
+{
+    MP_INFO(s, "Switched to track %d\n", track);
+    print_cdtext(s, track);
+}
+
+static void cdparanoia_callback(long int inpos, paranoia_cb_mode_t function)
+{
+}
+
+static int fill_buffer(stream_t *s, void *buffer, int max_len)
+{
+    cdda_priv *p = (cdda_priv *)s->priv;
+
+    if (!p->data || p->data_pos >= CDIO_CD_FRAMESIZE_RAW) {
+        if ((p->sector < p->start_sector) || (p->sector > p->end_sector))
+            return 0;
+
+        p->data_pos = 0;
+        p->data = (uint8_t *)paranoia_read(p->cdp, cdparanoia_callback);
+        if (!p->data)
+            return 0;
+
+        p->sector++;
+    }
+
+    size_t copy = MPMIN(CDIO_CD_FRAMESIZE_RAW - p->data_pos, max_len);
+    memcpy(buffer, p->data + p->data_pos, copy);
+    p->data_pos += copy;
+    return copy;
+}
+
+static int seek(stream_t *s, int64_t newpos)
+{
+    cdda_priv *p = (cdda_priv *)s->priv;
+    int sec;
+    int current_track = 0, seeked_track = 0;
+    int seek_to_track = 0;
+    int i;
+
+    newpos += p->start_sector * CDIO_CD_FRAMESIZE_RAW;
+
+    sec = newpos / CDIO_CD_FRAMESIZE_RAW;
+    if (newpos < 0 || sec > p->end_sector) {
+        p->sector = p->end_sector + 1;
+        return 0;
+    }
+
+    for (i = 0; i < p->cd->tracks; i++) {
+        if (p->sector >= p->cd->disc_toc[i].dwStartSector
+            && p->sector < p->cd->disc_toc[i + 1].dwStartSector)
+            current_track = i;
+        if (sec >= p->cd->disc_toc[i].dwStartSector
+            && sec < p->cd->disc_toc[i + 1].dwStartSector)
+        {
+            seeked_track = i;
+            seek_to_track = sec == p->cd->disc_toc[i].dwStartSector;
+        }
+    }
+    if (current_track != seeked_track && !seek_to_track)
+        print_track_info(s, seeked_track + 1);
+
+    p->sector = sec;
+
+    paranoia_seek(p->cdp, sec, SEEK_SET);
+    return 1;
+}
+
+static void close_cdda(stream_t *s)
+{
+    cdda_priv *p = (cdda_priv *)s->priv;
+    paranoia_free(p->cdp);
+    cdda_close(p->cd);
+}
+
+static int get_track_by_sector(cdda_priv *p, unsigned int sector)
+{
+    int i;
+    for (i = p->cd->tracks; i >= 0; --i)
+        if (p->cd->disc_toc[i].dwStartSector <= sector)
+            break;
+    return i;
+}
+
+static int control(stream_t *stream, int cmd, void *arg)
+{
+    cdda_priv *p = stream->priv;
+    switch (cmd) {
+    case STREAM_CTRL_GET_NUM_CHAPTERS:
+    {
+        int start_track = get_track_by_sector(p, p->start_sector);
+        int end_track = get_track_by_sector(p, p->end_sector);
+        if (start_track == -1 || end_track == -1)
+            return STREAM_ERROR;
+        *(unsigned int *)arg = end_track + 1 - start_track;
+        return STREAM_OK;
+    }
+    case STREAM_CTRL_GET_CHAPTER_TIME:
+    {
+        int track = *(double *)arg;
+        int start_track = get_track_by_sector(p, p->start_sector);
+        int end_track = get_track_by_sector(p, p->end_sector);
+        track += start_track;
+        if (track > end_track)
+            return STREAM_ERROR;
+        int64_t sector = p->cd->disc_toc[track].dwStartSector;
+        int64_t pos = sector * CDIO_CD_FRAMESIZE_RAW;
+        // Assume standard audio CD: 44.1khz, 2 channels, s16 samples
+        *(double *)arg = pos / (44100.0 * 2 * 2);
+        return STREAM_OK;
+    }
+    }
+    return STREAM_UNSUPPORTED;
+}
+
+static int64_t get_size(stream_t *st)
+{
+    cdda_priv *p = st->priv;
+    return (p->end_sector + 1 - p->start_sector) * CDIO_CD_FRAMESIZE_RAW;
+}
+
+static int open_cdda(stream_t *st)
+{
+    st->priv = mp_get_config_group(st, st->global, &stream_cdda_conf);
+    cdda_priv *priv = st->priv;
+    cdda_priv *p = priv;
+    int mode = p->paranoia_mode;
+    int offset = p->toc_offset;
+    cdrom_drive_t *cdd = NULL;
+    int last_track;
+
+    if (st->path[0]) {
+        p->device = st->path;
+    } else if (p->cdda_device && p->cdda_device[0]) {
+        p->device = p->cdda_device;
+    } else {
+        p->device = DEFAULT_CDROM_DEVICE;
+    }
+
+#if defined(__NetBSD__)
+    cdd = cdda_identify_scsi(p->device, p->device, 0, NULL);
+#else
+    cdd = cdda_identify(p->device, 0, NULL);
+#endif
+
+    if (!cdd) {
+        MP_ERR(st, "Can't open CDDA device.\n");
+        return STREAM_ERROR;
+    }
+
+    cdda_verbose_set(cdd, CDDA_MESSAGE_FORGETIT, CDDA_MESSAGE_FORGETIT);
+
+    if (p->sector_size)
+        cdd->nsectors = p->sector_size;
+
+    if (cdda_open(cdd) != 0) {
+        MP_ERR(st, "Can't open disc.\n");
+        cdda_close(cdd);
+        return STREAM_ERROR;
+    }
+
+    priv->cd = cdd;
+
+    offset -= cdda_track_firstsector(cdd, 1);
+    if (offset) {
+        for (int n = 0; n < cdd->tracks + 1; n++)
+            cdd->disc_toc[n].dwStartSector += offset;
+    }
+
+    if (p->speed > 0)
+        cdda_speed_set(cdd, p->speed);
+
+    last_track = cdda_tracks(cdd);
+    if (p->span[0] > last_track)
+        p->span[0] = last_track;
+    if (p->span[1] < p->span[0])
+        p->span[1] = p->span[0];
+    if (p->span[1] > last_track)
+        p->span[1] = last_track;
+    if (p->span[0])
+        priv->start_sector = cdda_track_firstsector(cdd, p->span[0]);
+    else
+        priv->start_sector = cdda_disc_firstsector(cdd);
+
+    if (p->span[1])
+        priv->end_sector = cdda_track_lastsector(cdd, p->span[1]);
+    else
+        priv->end_sector = cdda_disc_lastsector(cdd);
+
+    priv->cdp = paranoia_init(cdd);
+    if (priv->cdp == NULL) {
+        cdda_close(cdd);
+        free(priv);
+        return STREAM_ERROR;
+    }
+
+    if (mode == 0)
+        mode = PARANOIA_MODE_DISABLE;
+    else if (mode == 1)
+        mode = PARANOIA_MODE_OVERLAP;
+    else
+        mode = PARANOIA_MODE_FULL;
+
+    if (p->skip)
+        mode &= ~PARANOIA_MODE_NEVERSKIP;
+    else
+        mode |= PARANOIA_MODE_NEVERSKIP;
+
+    if (p->search_overlap > 0)
+        mode |= PARANOIA_MODE_OVERLAP;
+    else if (p->search_overlap == 0)
+        mode &= ~PARANOIA_MODE_OVERLAP;
+
+    paranoia_modeset(priv->cdp, mode);
+
+    if (p->search_overlap > 0)
+        paranoia_overlapset(priv->cdp, p->search_overlap);
+
+    paranoia_seek(priv->cdp, priv->start_sector, SEEK_SET);
+    priv->sector = priv->start_sector;
+
+    st->priv = priv;
+
+    st->fill_buffer = fill_buffer;
+    st->seek = seek;
+    st->seekable = true;
+    st->control = control;
+    st->get_size = get_size;
+    st->close = close_cdda;
+
+    st->streaming = true;
+
+    st->demuxer = "+disc";
+
+    print_cdtext(st, 0);
+
+    return STREAM_OK;
+}
+
+const stream_info_t stream_info_cdda = {
+    .name = "cdda",
+    .open = open_cdda,
+    .protocols = (const char*const[]){"cdda", NULL },
+    .stream_origin = STREAM_ORIGIN_UNSAFE,
+};
diff --git a/stream/stream_concat.c b/stream/stream_concat.c
new file mode 100644
index 0000000..d06bd4a
--- /dev/null
+++ b/stream/stream_concat.c
@@ -0,0 +1,179 @@
+/*
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include <libavutil/common.h>
+
+#include "common/common.h"
+#include "stream.h"
+
+struct priv {
+    struct stream **streams;
+    int num_streams;
+
+    int64_t size;
+
+    int cur; // streams[cur] is the stream for current stream.pos
+};
+
+static int fill_buffer(struct stream *s, void *buffer, int len)
+{
+    struct priv *p = s->priv;
+
+    while (1) {
+        int res = stream_read_partial(p->streams[p->cur], buffer, len);
+        if (res || p->cur == p->num_streams - 1)
+            return res;
+
+        p->cur += 1;
+        if (s->seekable)
+            stream_seek(p->streams[p->cur], 0);
+    }
+}
+
+static int seek(struct stream *s, int64_t newpos)
+{
+    struct priv *p = s->priv;
+
+    int64_t next_pos = 0;
+    int64_t base_pos = 0;
+
+    // Look for the last stream whose start position is <= newpos.
+    // Note that the last stream's size is essentially ignored. The last
+    // stream is allowed to have an unknown size.
+    for (int n = 0; n < p->num_streams; n++) {
+        if (next_pos > newpos)
+            break;
+
+        base_pos = next_pos;
+        p->cur = n;
+
+        int64_t size = stream_get_size(p->streams[n]);
+        if (size < 0)
+            break;
+
+        next_pos = base_pos + size;
+    }
+
+    int ok = stream_seek(p->streams[p->cur], newpos - base_pos);
+    s->pos = base_pos + stream_tell(p->streams[p->cur]);
+    return ok;
+}
+
+static int64_t get_size(struct stream *s)
+{
+    struct priv *p = s->priv;
+    return p->size;
+}
+
+static void s_close(struct stream *s)
+{
+    struct priv *p = s->priv;
+
+    for (int n = 0; n < p->num_streams; n++)
+        free_stream(p->streams[n]);
+}
+
+// Return the "worst" origin value of the two. cur can be 0 to mean unset.
+static int combine_origin(int cur, int new)
+{
+    if (cur == STREAM_ORIGIN_UNSAFE || new == STREAM_ORIGIN_UNSAFE)
+        return STREAM_ORIGIN_UNSAFE;
+    if (cur == STREAM_ORIGIN_NET || new == STREAM_ORIGIN_NET)
+        return STREAM_ORIGIN_NET;
+    if (cur == STREAM_ORIGIN_FS || new == STREAM_ORIGIN_FS)
+        return STREAM_ORIGIN_FS;
+    return new; // including cur==0
+}
+
+static int open2(struct stream *stream, const struct stream_open_args *args)
+{
+    struct priv *p = talloc_zero(stream, struct priv);
+    stream->priv = p;
+
+    stream->fill_buffer = fill_buffer;
+    stream->get_size = get_size;
+    stream->close = s_close;
+
+    stream->seekable = true;
+
+    struct priv *list = args->special_arg;
+    if (!list || !list->num_streams) {
+        MP_FATAL(stream, "No sub-streams.\n");
+        return STREAM_ERROR;
+    }
+
+    stream->stream_origin = 0;
+
+    for (int n = 0; n < list->num_streams; n++) {
+        struct stream *sub = list->streams[n];
+
+        int64_t size = stream_get_size(sub);
+        if (n != list->num_streams - 1 && size < 0) {
+            MP_WARN(stream, "Sub stream %d has unknown size.\n", n);
+            stream->seekable = false;
+            p->size = -1;
+        } else if (size >= 0 && p->size >= 0) {
+            p->size += size;
+        }
+
+        if (!sub->seekable)
+            stream->seekable = false;
+
+        stream->stream_origin =
+            combine_origin(stream->stream_origin, sub->stream_origin);
+
+        MP_TARRAY_APPEND(p, p->streams, p->num_streams, sub);
+    }
+
+    if (stream->seekable)
+        stream->seek = seek;
+
+    return STREAM_OK;
+}
+
+static const stream_info_t stream_info_concat = {
+    .name = "concat",
+    .open2 = open2,
+    .protocols = (const char*const[]){ "concat", NULL },
+};
+
+// Create a stream with a concatenated view on streams[]. Copies the streams
+// array. Takes over ownership of every stream passed to it (it will free them
+// if the concat stream is closed).
+// If an error happens, NULL is returned, and the streams are not freed.
+struct stream *stream_concat_open(struct mpv_global *global, struct mp_cancel *c,
+                                  struct stream **streams, int num_streams)
+{
+    // (struct priv is blatantly abused to pass in the stream list)
+    struct priv arg = {
+        .streams = streams,
+        .num_streams = num_streams,
+    };
+
+    struct stream_open_args sargs = {
+        .global = global,
+        .cancel = c,
+        .url = "concat://",
+        .flags = STREAM_READ | STREAM_SILENT | STREAM_ORIGIN_DIRECT,
+        .sinfo = &stream_info_concat,
+        .special_arg = &arg,
+    };
+
+    struct stream *s = NULL;
+    stream_create_with_args(&sargs, &s);
+    return s;
+}
diff --git a/stream/stream_dvb.c b/stream/stream_dvb.c
new file mode 100644
index 0000000..215e82c
--- /dev/null
+++ b/stream/stream_dvb.c
@@ -0,0 +1,1161 @@
+/*
+
+   dvbstream
+   (C) Dave Chapman <dave@dchapman.com> 2001, 2002.
+   (C) Rozhuk Ivan <rozhuk.im@gmail.com> 2016 - 2017
+
+   Original authors: Nico, probably Arpi
+
+   Some code based on dvbstream, 0.4.3-pre3 (CVS checkout),
+   http://sourceforge.net/projects/dvbtools/
+
+   Modified for use with MPlayer, for details see the changelog at
+   http://svn.mplayerhq.hu/mplayer/trunk/
+   $Id$
+
+   Copyright notice:
+
+   This program 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.
+
+   This program 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 this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+*/
+
+#include "config.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/time.h>
+#include <poll.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+
+#include "osdep/io.h"
+#include "misc/ctype.h"
+#include "osdep/timer.h"
+
+#include "stream.h"
+#include "common/tags.h"
+#include "options/m_config.h"
+#include "options/m_option.h"
+#include "options/options.h"
+#include "options/path.h"
+#include "osdep/threads.h"
+
+#include "dvbin.h"
+#include "dvb_tune.h"
+
+#if !HAVE_GPL
+#error GPL only
+#endif
+
+#define CHANNEL_LINE_LEN 256
+
+#define OPT_BASE_STRUCT dvb_opts_t
+
+static dvb_state_t *global_dvb_state = NULL;
+static mp_static_mutex global_dvb_state_lock = MP_STATIC_MUTEX_INITIALIZER;
+
+const struct m_sub_options stream_dvb_conf = {
+    .opts = (const m_option_t[]) {
+        {"prog", OPT_STRING(cfg_prog), .flags = UPDATE_DVB_PROG},
+        {"card", OPT_INT(cfg_devno), M_RANGE(0, MAX_ADAPTERS-1)},
+        {"timeout", OPT_INT(cfg_timeout), M_RANGE(1, 30)},
+        {"file", OPT_STRING(cfg_file), .flags = M_OPT_FILE},
+        {"full-transponder", OPT_BOOL(cfg_full_transponder)},
+        {"channel-switch-offset", OPT_INT(cfg_channel_switch_offset),
+            .flags = UPDATE_DVB_PROG},
+        {0}
+    },
+    .size = sizeof(dvb_opts_t),
+    .defaults = &(const dvb_opts_t){
+        .cfg_prog = NULL,
+        .cfg_timeout = 30,
+    },
+};
+
+void dvbin_close(stream_t *stream);
+
+static fe_code_rate_t parse_fec(const char *cr)
+{
+    if (!strcmp(cr, "FEC_1_2")) {
+        return FEC_1_2;
+    } else if (!strcmp(cr, "FEC_2_3")) {
+        return FEC_2_3;
+    } else if (!strcmp(cr, "FEC_3_4")) {
+        return FEC_3_4;
+    } else if (!strcmp(cr, "FEC_4_5")) {
+        return FEC_4_5;
+    } else if (!strcmp(cr, "FEC_5_6")) {
+        return FEC_5_6;
+    } else if (!strcmp(cr, "FEC_6_7")) {
+        return FEC_6_7;
+    } else if (!strcmp(cr, "FEC_7_8")) {
+        return FEC_7_8;
+    } else if (!strcmp(cr, "FEC_8_9")) {
+        return FEC_8_9;
+    } else if (!strcmp(cr, "FEC_NONE")) {
+        return FEC_NONE;
+    }
+    return FEC_NONE;
+}
+
+static fe_modulation_t parse_vdr_modulation(const char** modstring)
+{
+    const static struct { const char *s; fe_modulation_t v; } table[] = {
+        { "16",  QAM_16 },
+        { "32",  QAM_32 },
+        { "64",  QAM_64 },
+        { "128", QAM_128 },
+        { "256", QAM_256 },
+        { "998", QAM_AUTO },
+        { "2",   QPSK },
+        { "5",   PSK_8 },
+        { "6",   APSK_16 },
+        { "7",   APSK_32 },
+        { "10",  VSB_8 },
+        { "11",  VSB_16 },
+        { "12",  DQPSK },
+    };
+    for (int i = 0; i < MP_ARRAY_SIZE(table); i++) {
+        if (!strncmp(*modstring, table[i].s, strlen(table[i].s))) {
+            *modstring += strlen(table[i].s);
+            return table[i].v;
+        }
+    }
+    return QAM_AUTO;
+}
+
+static void parse_vdr_par_string(const char *vdr_par_str, dvb_channel_t *ptr)
+{
+    //FIXME: There is more information in this parameter string, especially related
+    // to non-DVB-S reception.
+    if (!vdr_par_str[0])
+        return;
+    const char *vdr_par = &vdr_par_str[0];
+    while (vdr_par && *vdr_par) {
+        switch (mp_toupper(*vdr_par)) {
+        case 'H':
+            ptr->pol = 'H';
+            vdr_par++;
+            break;
+        case 'V':
+            ptr->pol = 'V';
+            vdr_par++;
+            break;
+        case 'S':
+            vdr_par++;
+            ptr->is_dvb_x2 = *vdr_par == '1';
+            vdr_par++;
+            break;
+        case 'P':
+            vdr_par++;
+            char *endptr = NULL;
+            errno = 0;
+            int n = strtol(vdr_par, &endptr, 10);
+            if (!errno && endptr != vdr_par) {
+                ptr->stream_id = n;
+                vdr_par = endptr;
+            }
+            break;
+        case 'I':
+            vdr_par++;
+            ptr->inv = (*vdr_par == '1') ? INVERSION_ON : INVERSION_OFF;
+            vdr_par++;
+            break;
+        case 'M':
+            vdr_par++;
+            ptr->mod = parse_vdr_modulation(&vdr_par);
+            break;
+        default:
+            vdr_par++;
+        }
+    }
+}
+
+static char *dvb_strtok_r(char *s, const char *sep, char **p)
+{
+    if (!s && !(s = *p))
+        return NULL;
+
+    /* Skip leading separators. */
+    s += strspn(s, sep);
+
+    /* s points at first non-separator, or end of string. */
+    if (!*s)
+        return *p = 0;
+
+    /* Move *p to next separator. */
+    *p = s + strcspn(s, sep);
+    if (**p) {
+        *(*p)++ = 0;
+    } else {
+        *p = 0;
+    }
+    return s;
+}
+
+static bool parse_pid_string(struct mp_log *log, char *pid_string,
+                             dvb_channel_t *ptr)
+{
+    if (!pid_string[0])
+        return false;
+    int pcnt = 0;
+    /* These tokens also catch vdr-style PID lists.
+     * They can contain 123=deu@3,124=eng+jap@4;125
+     * 3 and 4 are codes for codec type, =langLeft+langRight is allowed,
+     * and ; may separate a dolby channel.
+     * With the numChars-test and the full token-list, all is handled
+     * gracefully.
+     */
+    const char *tokens = "+,;";
+    char *pidPart;
+    char *savePtr = NULL;
+    pidPart = dvb_strtok_r(pid_string, tokens, &savePtr);
+    while (pidPart != NULL) {
+        if (ptr->pids_cnt >= DMX_FILTER_SIZE - 1) {
+            mp_verbose(log, "Maximum number of PIDs for one channel "
+                            "reached, ignoring further ones!\n");
+            break;
+        }
+        int numChars = 0;
+        int pid = 0;
+        pcnt += sscanf(pidPart, "%d%n", &pid, &numChars);
+        if (numChars > 0) {
+            ptr->pids[ptr->pids_cnt] = pid;
+            ptr->pids_cnt++;
+        }
+        pidPart = dvb_strtok_r(NULL, tokens, &savePtr);
+    }
+    return pcnt > 0;
+}
+
+static dvb_channels_list_t *dvb_get_channels(struct mp_log *log,
+                                           dvb_channels_list_t *list_add,
+                                           int cfg_full_transponder,
+                                           char *filename,
+                                           unsigned int frontend,
+                                           int delsys, unsigned int delsys_mask)
+{
+    dvb_channels_list_t *list = list_add;
+
+    if (!filename)
+        return list;
+
+    const char *cbl_conf =
+        "%d:%255[^:]:%d:%255[^:]:%255[^:]:%255[^:]:%255[^:]\n";
+    const char *sat_conf = "%d:%c:%d:%d:%255[^:]:%255[^:]\n";
+    const char *ter_conf =
+        "%d:%255[^:]:%255[^:]:%255[^:]:%255[^:]:%255[^:]:%255[^:]:%255[^:]:%255[^:]:%255[^:]:%255[^:]\n";
+    const char *atsc_conf = "%d:%255[^:]:%255[^:]:%255[^:]\n";
+    const char *vdr_conf =
+        "%d:%255[^:]:%255[^:]:%d:%255[^:]:%255[^:]:%255[^:]:%*255[^:]:%d:%*d:%*d:%*d\n%n";
+
+    mp_verbose(log, "Reading config file %s for type %s\n",
+               filename, get_dvb_delsys(delsys));
+    FILE *f = fopen(filename, "r");
+    if (!f) {
+        mp_fatal(log, "Can't open file %s\n", filename);
+        return list;
+    }
+
+    if (!list)
+        list = talloc_zero(NULL, dvb_channels_list_t);
+
+    while (!feof(f)) {
+        char line[CHANNEL_LINE_LEN];
+        if (!fgets(line, CHANNEL_LINE_LEN, f))
+            continue;
+
+        if (line[0] == '#' || strlen(line) == 0)
+            continue;
+
+        dvb_channel_t chn = {0};
+        dvb_channel_t *ptr = &chn;
+
+        char tmp_lcr[256], tmp_hier[256], inv[256], bw[256], cr[256], mod[256],
+            transm[256], gi[256], vpid_str[256], apid_str[256], tpid_str[256],
+            vdr_par_str[256], vdr_loc_str[256];
+
+        vpid_str[0] = apid_str[0] = tpid_str[0] = 0;
+        vdr_loc_str[0] = vdr_par_str[0] = 0;
+
+        char *colon = strchr(line, ':');
+        if (!colon)
+            continue;
+        int k = colon - line;
+        if (!k)
+            continue;
+        // In some modern VDR-style configs, channel name also has bouquet after ;.
+        // Parse that off, we ignore it.
+        char *bouquet_sep = strchr(line, ';');
+        {
+            int namelen = k;
+            if (bouquet_sep && bouquet_sep < colon)
+                namelen = bouquet_sep - line;
+            ptr->name = talloc_strndup(list, line, namelen);
+        }
+
+        k++;
+
+        ptr->pids_cnt = 0;
+        ptr->freq = 0;
+        ptr->service_id = -1;
+        ptr->is_dvb_x2 = false;
+        ptr->frontend = frontend;
+        ptr->delsys = delsys;
+        ptr->diseqc = 0;
+        ptr->stream_id = NO_STREAM_ID_FILTER;
+        ptr->inv = INVERSION_AUTO;
+        ptr->bw = BANDWIDTH_AUTO;
+        ptr->cr = FEC_AUTO;
+        ptr->cr_lp = FEC_AUTO;
+        ptr->mod = QAM_AUTO;
+        ptr->hier = HIERARCHY_AUTO;
+        ptr->gi = GUARD_INTERVAL_AUTO;
+        ptr->trans = TRANSMISSION_MODE_AUTO;
+
+        // Check if VDR-type channels.conf-line - then full line is consumed by the scan.
+        int fields, num_chars = 0;
+        fields = sscanf(&line[k], vdr_conf,
+                        &ptr->freq, vdr_par_str, vdr_loc_str, &ptr->srate,
+                        vpid_str, apid_str, tpid_str, &ptr->service_id,
+                        &num_chars);
+
+        bool is_vdr_conf = (num_chars == strlen(&line[k]));
+
+        // Special case: DVB-T style ZAP config also has 13 columns.
+        // Most columns should have non-numeric content, but some channel list generators insert 0
+        // if a value is not used. However, INVERSION_* should always set after frequency.
+        if (is_vdr_conf && !strncmp(vdr_par_str, "INVERSION_", 10)) {
+            is_vdr_conf = false;
+        }
+
+        if (is_vdr_conf) {
+            // Modulation parsed here, not via old xine-parsing path.
+            mod[0] = '\0';
+            // It's a VDR-style config line.
+            parse_vdr_par_string(vdr_par_str, ptr);
+            // Frequency in VDR-style config files is in MHz for DVB-S,
+            // and may be in MHz, kHz or Hz for DVB-C and DVB-T.
+            // General rule to get useful units is to multiply by 1000 until value is larger than 1000000.
+            while (ptr->freq < 1000000U) {
+                ptr->freq *= 1000U;
+            }
+            // Symbol rate in VDR-style config files is divided by 1000.
+            ptr->srate *= 1000U;
+            switch (delsys) {
+            case SYS_DVBT:
+            case SYS_DVBT2:
+                /* Fix delsys value. */
+                if (ptr->is_dvb_x2) {
+                    ptr->delsys = delsys = SYS_DVBT2;
+                } else {
+                    ptr->delsys = delsys = SYS_DVBT;
+                }
+                if (!DELSYS_IS_SET(delsys_mask, delsys))
+                    continue; /* Skip channel. */
+                mp_verbose(log, "VDR, %s, NUM: %d, NUM_FIELDS: %d, NAME: %s, "
+                           "FREQ: %d, SRATE: %d, T2: %s\n",
+                           get_dvb_delsys(delsys),
+                           list->NUM_CHANNELS, fields,
+                           ptr->name, ptr->freq, ptr->srate,
+                           (delsys == SYS_DVBT2) ? "yes" : "no");
+                break;
+            case SYS_DVBC_ANNEX_A:
+            case SYS_DVBC_ANNEX_C:
+            case SYS_ATSC:
+            case SYS_DVBC_ANNEX_B:
+            case SYS_ISDBT:
+                mp_verbose(log, "VDR, %s, NUM: %d, NUM_FIELDS: %d, NAME: %s, "
+                           "FREQ: %d, SRATE: %d\n",
+                           get_dvb_delsys(delsys),
+                           list->NUM_CHANNELS, fields,
+                           ptr->name, ptr->freq, ptr->srate);
+                break;
+            case SYS_DVBS:
+            case SYS_DVBS2:
+                /* Fix delsys value. */
+                if (ptr->is_dvb_x2) {
+                    ptr->delsys = delsys = SYS_DVBS2;
+                } else {
+                    ptr->delsys = delsys = SYS_DVBS;
+                }
+                if (!DELSYS_IS_SET(delsys_mask, delsys))
+                    continue; /* Skip channel. */
+
+                if (vdr_loc_str[0]) {
+                    // In older vdr config format, this field contained the DISEQc information.
+                    // If it is numeric, assume that's it.
+                    int diseqc_info = 0;
+                    int valid_digits = 0;
+                    if (sscanf(vdr_loc_str, "%d%n", &diseqc_info,
+                               &valid_digits) == 1)
+                    {
+                        if (valid_digits == strlen(vdr_loc_str)) {
+                            ptr->diseqc = (unsigned int)diseqc_info;
+                            if (ptr->diseqc > 4)
+                                continue;
+                            if (ptr->diseqc > 0)
+                                ptr->diseqc--;
+                        }
+                    }
+                }
+
+                mp_verbose(log, "VDR, %s, NUM: %d, NUM_FIELDS: %d, NAME: %s, "
+                           "FREQ: %d, SRATE: %d, POL: %c, DISEQC: %d, S2: %s, "
+                           "StreamID: %d, SID: %d\n",
+                           get_dvb_delsys(delsys),
+                           list->NUM_CHANNELS,
+                           fields, ptr->name, ptr->freq, ptr->srate, ptr->pol,
+                           ptr->diseqc, (delsys == SYS_DVBS2) ? "yes" : "no",
+                           ptr->stream_id, ptr->service_id);
+                break;
+            default:
+                break;
+            }
+        } else {
+            // ZAP style channel config file.
+            switch (delsys) {
+            case SYS_DVBT:
+            case SYS_DVBT2:
+            case SYS_ISDBT:
+                fields = sscanf(&line[k], ter_conf,
+                                &ptr->freq, inv, bw, cr, tmp_lcr, mod,
+                                transm, gi, tmp_hier, vpid_str, apid_str);
+                mp_verbose(log, "%s, NUM: %d, NUM_FIELDS: %d, NAME: %s, FREQ: %d\n",
+                           get_dvb_delsys(delsys), list->NUM_CHANNELS,
+                           fields, ptr->name, ptr->freq);
+                break;
+            case SYS_DVBC_ANNEX_A:
+            case SYS_DVBC_ANNEX_C:
+                fields = sscanf(&line[k], cbl_conf,
+                                &ptr->freq, inv, &ptr->srate,
+                                cr, mod, vpid_str, apid_str);
+                mp_verbose(log, "%s, NUM: %d, NUM_FIELDS: %d, NAME: %s, FREQ: %d, "
+                           "SRATE: %d\n",
+                           get_dvb_delsys(delsys),
+                           list->NUM_CHANNELS, fields, ptr->name,
+                           ptr->freq, ptr->srate);
+                break;
+            case SYS_ATSC:
+            case SYS_DVBC_ANNEX_B:
+                fields = sscanf(&line[k], atsc_conf,
+                                &ptr->freq, mod, vpid_str, apid_str);
+                mp_verbose(log, "%s, NUM: %d, NUM_FIELDS: %d, NAME: %s, FREQ: %d\n",
+                           get_dvb_delsys(delsys), list->NUM_CHANNELS,
+                           fields, ptr->name, ptr->freq);
+                break;
+            case SYS_DVBS:
+            case SYS_DVBS2:
+                fields = sscanf(&line[k], sat_conf,
+                                &ptr->freq, &ptr->pol, &ptr->diseqc, &ptr->srate,
+                                vpid_str,
+                                apid_str);
+                ptr->pol = mp_toupper(ptr->pol);
+                ptr->freq *= 1000U;
+                ptr->srate *= 1000U;
+                if (ptr->diseqc > 4)
+                    continue;
+                if (ptr->diseqc > 0)
+                    ptr->diseqc--;
+                mp_verbose(log, "%s, NUM: %d, NUM_FIELDS: %d, NAME: %s, FREQ: %d, "
+                           "SRATE: %d, POL: %c, DISEQC: %d\n",
+                           get_dvb_delsys(delsys),
+                           list->NUM_CHANNELS, fields, ptr->name, ptr->freq,
+                           ptr->srate, ptr->pol, ptr->diseqc);
+                break;
+            default:
+                break;
+            }
+        }
+
+        if (parse_pid_string(log, vpid_str, ptr))
+            fields++;
+        if (parse_pid_string(log, apid_str, ptr))
+            fields++;
+                 /* If we do not know the service_id, PMT can not be extracted.
+                    Teletext decoding will fail without PMT. */
+        if (ptr->service_id != -1) {
+            if (parse_pid_string(log, tpid_str, ptr))
+                fields++;
+        }
+
+
+        if (fields < 2 || ptr->pids_cnt == 0 || ptr->freq == 0 ||
+            strlen(ptr->name) == 0)
+            continue;
+
+        /* Add some PIDs which are mandatory in DVB,
+         * and contain human-readable helpful data. */
+
+        /* This is the STD, the service description table.
+         * It contains service names and such, ffmpeg decodes it. */
+        ptr->pids[ptr->pids_cnt] = 0x0011;
+        ptr->pids_cnt++;
+
+        /* This is the EIT, which contains EPG data.
+         * ffmpeg can not decode it (yet), but e.g. VLC
+         * shows what was recorded. */
+        ptr->pids[ptr->pids_cnt] = 0x0012;
+        ptr->pids_cnt++;
+
+        if (ptr->service_id != -1) {
+            /* We have the PMT-PID in addition.
+               This will be found later, when we tune to the channel.
+               Push back here to create the additional demux. */
+            ptr->pids[ptr->pids_cnt] = -1;       // Placeholder.
+            ptr->pids_cnt++;
+        }
+
+        bool has8192 = false, has0 = false;
+        for (int cnt = 0; cnt < ptr->pids_cnt; cnt++) {
+            if (ptr->pids[cnt] == 8192)
+                has8192 = true;
+            if (ptr->pids[cnt] == 0)
+                has0 = true;
+        }
+
+        /* 8192 is the pseudo-PID for full TP dump,
+           enforce that if requested. */
+        if (!has8192 && cfg_full_transponder)
+            has8192 = 1;
+        if (has8192) {
+            ptr->pids[0] = 8192;
+            ptr->pids_cnt = 1;
+        } else if (!has0) {
+            ptr->pids[ptr->pids_cnt] = 0;               //PID 0 is the PAT
+            ptr->pids_cnt++;
+        }
+
+        mp_verbose(log, " PIDS: ");
+        for (int cnt = 0; cnt < ptr->pids_cnt; cnt++)
+            mp_verbose(log, " %d ", ptr->pids[cnt]);
+        mp_verbose(log, "\n");
+
+        switch (delsys) {
+        case SYS_DVBT:
+        case SYS_DVBT2:
+        case SYS_ISDBT:
+        case SYS_DVBC_ANNEX_A:
+        case SYS_DVBC_ANNEX_C:
+            if (!strcmp(inv, "INVERSION_ON")) {
+                ptr->inv = INVERSION_ON;
+            } else if (!strcmp(inv, "INVERSION_OFF")) {
+                ptr->inv = INVERSION_OFF;
+            }
+
+            ptr->cr = parse_fec(cr);
+        }
+
+        switch (delsys) {
+        case SYS_DVBT:
+        case SYS_DVBT2:
+        case SYS_ISDBT:
+        case SYS_DVBC_ANNEX_A:
+        case SYS_DVBC_ANNEX_C:
+        case SYS_ATSC:
+        case SYS_DVBC_ANNEX_B:
+            if (!strcmp(mod, "QAM_128")) {
+                ptr->mod = QAM_128;
+            } else if (!strcmp(mod, "QAM_256")) {
+                ptr->mod = QAM_256;
+            } else if (!strcmp(mod, "QAM_64")) {
+                ptr->mod = QAM_64;
+            } else if (!strcmp(mod, "QAM_32")) {
+                ptr->mod = QAM_32;
+            } else if (!strcmp(mod, "QAM_16")) {
+                ptr->mod = QAM_16;
+            } else if (!strcmp(mod, "VSB_8") || !strcmp(mod, "8VSB")) {
+                ptr->mod = VSB_8;
+            } else if (!strcmp(mod, "VSB_16") || !strcmp(mod, "16VSB")) {
+                ptr->mod = VSB_16;
+            }
+        }
+
+        /* Modulation defines real delsys for ATSC:
+           Terrestrial (VSB) is SYS_ATSC, Cable (QAM) is SYS_DVBC_ANNEX_B. */
+        if (delsys == SYS_ATSC || delsys == SYS_DVBC_ANNEX_B) {
+            if (ptr->mod == VSB_8 || ptr->mod == VSB_16) {
+                delsys = SYS_ATSC;
+            } else {
+                delsys = SYS_DVBC_ANNEX_B;
+            }
+            if (!DELSYS_IS_SET(delsys_mask, delsys))
+                continue; /* Skip channel. */
+            mp_verbose(log, "Switched to delivery system for ATSC: %s (guessed from modulation)\n",
+                       get_dvb_delsys(delsys));
+        }
+
+        switch (delsys) {
+        case SYS_DVBT:
+        case SYS_DVBT2:
+        case SYS_ISDBT:
+            if (!strcmp(bw, "BANDWIDTH_5_MHZ")) {
+                ptr->bw = BANDWIDTH_5_MHZ;
+            } else if (!strcmp(bw, "BANDWIDTH_6_MHZ")) {
+                ptr->bw = BANDWIDTH_6_MHZ;
+            } else if (!strcmp(bw, "BANDWIDTH_7_MHZ")) {
+                ptr->bw = BANDWIDTH_7_MHZ;
+            } else if (!strcmp(bw, "BANDWIDTH_8_MHZ")) {
+                ptr->bw = BANDWIDTH_8_MHZ;
+            } else if (!strcmp(bw, "BANDWIDTH_10_MHZ")) {
+                ptr->bw = BANDWIDTH_10_MHZ;
+            }
+
+
+            if (!strcmp(transm, "TRANSMISSION_MODE_2K")) {
+                ptr->trans = TRANSMISSION_MODE_2K;
+            } else if (!strcmp(transm, "TRANSMISSION_MODE_8K")) {
+                ptr->trans = TRANSMISSION_MODE_8K;
+            } else if (!strcmp(transm, "TRANSMISSION_MODE_AUTO")) {
+                ptr->trans = TRANSMISSION_MODE_AUTO;
+            }
+
+            if (!strcmp(gi, "GUARD_INTERVAL_1_32")) {
+                ptr->gi = GUARD_INTERVAL_1_32;
+            } else if (!strcmp(gi, "GUARD_INTERVAL_1_16")) {
+                ptr->gi = GUARD_INTERVAL_1_16;
+            } else if (!strcmp(gi, "GUARD_INTERVAL_1_8")) {
+                ptr->gi = GUARD_INTERVAL_1_8;
+            } else if (!strcmp(gi, "GUARD_INTERVAL_1_4")) {
+                ptr->gi = GUARD_INTERVAL_1_4;
+            }
+
+            ptr->cr_lp = parse_fec(tmp_lcr);
+
+            if (!strcmp(tmp_hier, "HIERARCHY_1")) {
+                ptr->hier = HIERARCHY_1;
+            } else if (!strcmp(tmp_hier, "HIERARCHY_2")) {
+                ptr->hier = HIERARCHY_2;
+            } else if (!strcmp(tmp_hier, "HIERARCHY_4")) {
+                ptr->hier = HIERARCHY_4;
+            } else if (!strcmp(tmp_hier, "HIERARCHY_NONE")) {
+                ptr->hier = HIERARCHY_NONE;
+            }
+        }
+
+        MP_TARRAY_APPEND(list, list->channels, list->NUM_CHANNELS, *ptr);
+    }
+
+    fclose(f);
+    if (list->NUM_CHANNELS == 0)
+        TA_FREEP(&list);
+
+    return list;
+}
+
+static int dvb_streaming_read(stream_t *stream, void *buffer, int size)
+{
+    dvb_priv_t *priv = stream->priv;
+    dvb_state_t *state = priv->state;
+    int pos = 0;
+    int tries = state->retry;
+    const int fd = state->dvr_fd;
+
+    MP_TRACE(stream, "dvb_streaming_read(%d)\n", size);
+
+    struct pollfd pfds[1];
+    pfds[0].fd = fd;
+    pfds[0].events = POLLIN | POLLPRI;
+
+    while (pos < size) {
+        int rk = read(fd, (char *)buffer + pos, (size - pos));
+        if (rk <= 0) {
+            if (pos || tries == 0)
+                break;
+            tries--;
+            if (poll(pfds, 1, 2000) <= 0) {
+                MP_ERR(stream, "dvb_streaming_read: failed with "
+                        "errno %d when reading %d bytes\n", errno, size - pos);
+                errno = 0;
+                break;
+            }
+            continue;
+        }
+        pos += rk;
+        MP_TRACE(stream, "got %d bytes\n", pos);
+    }
+
+    if (!pos)
+        MP_ERR(stream, "dvb_streaming_read: returning 0 bytes\n");
+
+    // Check if config parameters have been updated.
+    dvb_update_config(stream);
+
+    return pos;
+}
+
+int dvb_set_channel(stream_t *stream, unsigned int adapter, unsigned int n)
+{
+    dvb_priv_t *priv = stream->priv;
+    dvb_state_t *state = priv->state;
+
+    assert(adapter < state->adapters_count);
+    int devno = state->adapters[adapter].devno;
+    dvb_channels_list_t *new_list = state->adapters[adapter].list;
+    assert(n < new_list->NUM_CHANNELS);
+    dvb_channel_t *channel = &(new_list->channels[n]);
+
+    if (state->is_on) {  //the fds are already open and we have to stop the demuxers
+        /* Remove all demuxes. */
+        dvb_fix_demuxes(priv, 0);
+
+        state->retry = 0;
+        // empty both the stream's and driver's buffer
+        char buf[4096];
+        while (dvb_streaming_read(stream, buf, sizeof(buf)) > 0) {}
+
+        if (state->cur_adapter != adapter ||
+            state->cur_frontend != channel->frontend) {
+            dvbin_close(stream);
+            if (!dvb_open_devices(priv, devno, channel->frontend, channel->pids_cnt)) {
+                MP_ERR(stream, "dvb_set_channel: couldn't open devices of adapter "
+                    "%d\n", devno);
+                return 0;
+            }
+        } else {
+            // close all demux_fds with pos > pids required for the new channel
+            // or open other demux_fds if we have too few
+            if (!dvb_fix_demuxes(priv, channel->pids_cnt))
+                return 0;
+        }
+    } else {
+        if (!dvb_open_devices(priv, devno, channel->frontend, channel->pids_cnt)) {
+            MP_ERR(stream, "dvb_set_channel: couldn't open devices of adapter "
+                    "%d\n", devno);
+            return 0;
+        }
+    }
+
+    state->retry = 5;
+    new_list->current = n;
+    MP_VERBOSE(stream, "dvb_set_channel: new channel name=\"%s\", adapter: %d, "
+               "channel: %d\n", channel->name, devno, n);
+
+    if (channel->freq != state->last_freq) {
+        if (!dvb_tune(priv, channel->delsys, channel->freq,
+                      channel->pol, channel->srate, channel->diseqc,
+                      channel->stream_id, channel->inv,
+                      channel->mod, channel->gi,
+                      channel->trans, channel->bw, channel->cr, channel->cr_lp,
+                      channel->hier, priv->opts->cfg_timeout))
+            return 0;
+    }
+
+    state->is_on = true;
+    state->last_freq = channel->freq;
+    state->cur_adapter = adapter;
+    state->cur_frontend = channel->frontend;
+
+    if (channel->service_id != -1) {
+        /* We need the PMT-PID in addition.
+           If it has not yet beem resolved, do it now. */
+        for (int i = 0; i < channel->pids_cnt; i++) {
+            if (channel->pids[i] == -1) {
+                MP_VERBOSE(stream, "dvb_set_channel: PMT-PID for service %d "
+                           "not resolved yet, parsing PAT...\n",
+                           channel->service_id);
+                int pmt_pid = dvb_get_pmt_pid(priv, adapter, channel->service_id);
+                MP_VERBOSE(stream, "found PMT-PID: %d\n", pmt_pid);
+                channel->pids[i] = pmt_pid;
+                break;
+            }
+        }
+    }
+
+    // sets demux filters and restart the stream
+    for (int i = 0; i < channel->pids_cnt; i++) {
+        if (channel->pids[i] == -1) {
+            // In case PMT was not resolved, skip it here.
+            MP_ERR(stream, "dvb_set_channel: PMT-PID not found, "
+                           "teletext decoding may fail.\n");
+            continue;
+        }
+        if (!dvb_set_ts_filt(priv, state->demux_fds[i], channel->pids[i],
+                             DMX_PES_OTHER))
+            return 0;
+    }
+
+    return 1;
+}
+
+static int dvbin_stream_control(struct stream *s, int cmd, void *arg)
+{
+    dvb_priv_t *priv = s->priv;
+    dvb_state_t *state = priv->state;
+
+    if (state->cur_adapter >= state->adapters_count)
+        return STREAM_ERROR;
+    dvb_channels_list_t *list = state->adapters[state->cur_adapter].list;
+
+    switch (cmd) {
+    case STREAM_CTRL_GET_METADATA: {
+        struct mp_tags *metadata = talloc_zero(NULL, struct mp_tags);
+        char *progname = list->channels[list->current].name;
+        mp_tags_set_str(metadata, "title", progname);
+        *(struct mp_tags **)arg = metadata;
+        return STREAM_OK;
+    }
+    }
+    return STREAM_UNSUPPORTED;
+}
+
+void dvbin_close(stream_t *stream)
+{
+    dvb_priv_t *priv = stream->priv;
+    dvb_state_t *state = priv->state;
+
+    if (state->switching_channel && state->is_on) {
+        // Prevent state destruction, reset channel-switch.
+        state->switching_channel = false;
+        mp_mutex_lock(&global_dvb_state_lock);
+        global_dvb_state->stream_used = false;
+        mp_mutex_unlock(&global_dvb_state_lock);
+        return;
+    }
+
+    for (int i = state->demux_fds_cnt - 1; i >= 0; i--) {
+        state->demux_fds_cnt--;
+        close(state->demux_fds[i]);
+    }
+    close(state->dvr_fd);
+    close(state->fe_fd);
+    state->fe_fd = state->dvr_fd = -1;
+
+    state->is_on = false;
+    state->cur_adapter = -1;
+    state->cur_frontend = -1;
+
+    mp_mutex_lock(&global_dvb_state_lock);
+    TA_FREEP(&global_dvb_state);
+    mp_mutex_unlock(&global_dvb_state_lock);
+}
+
+static int dvb_streaming_start(stream_t *stream, char *progname)
+{
+    dvb_priv_t *priv = stream->priv;
+    dvb_state_t *state = priv->state;
+
+    if (!progname)
+        return 0;
+
+    dvb_channels_list_t *list = state->adapters[state->cur_adapter].list;
+    dvb_channel_t *channel = NULL;
+    int i;
+    for (i = 0; i < list->NUM_CHANNELS; i ++) {
+        if (!strcmp(list->channels[i].name, progname)) {
+            channel = &(list->channels[i]);
+            break;
+        }
+    }
+
+    if (!channel) {
+        MP_ERR(stream, "no such channel \"%s\"\n", progname);
+        return 0;
+    }
+    list->current = i;
+
+    // When switching channels, cfg_channel_switch_offset
+    // keeps the offset to the initially chosen channel.
+    list->current = (list->NUM_CHANNELS + list->current +
+                     priv->opts->cfg_channel_switch_offset) % list->NUM_CHANNELS;
+    channel = &(list->channels[list->current]);
+    MP_INFO(stream, "Tuning to channel \"%s\"...\n", channel->name);
+    MP_VERBOSE(stream, "Program number %d: name=\"%s\", freq=%u\n", i,
+               channel->name, channel->freq);
+
+    if (!dvb_set_channel(stream, state->cur_adapter, list->current)) {
+        dvbin_close(stream);
+        return 0;
+    }
+
+    return 1;
+}
+
+void dvb_update_config(stream_t *stream)
+{
+    dvb_priv_t *priv = stream->priv;
+    dvb_state_t *state = priv->state;
+
+    // Throttle the check to at maximum once every 0.1 s.
+    int now = (int)(mp_time_sec()*10);
+    if (now == priv->opts_check_time)
+        return;
+    priv->opts_check_time = now;
+
+    if (!m_config_cache_update(priv->opts_cache))
+        return;
+
+    // Re-parse stream path, if we have cfg parameters now,
+    // these should be preferred.
+    if (!dvb_parse_path(stream)) {
+        MP_ERR(stream, "error parsing DVB config, not tuning.");
+        return;
+    }
+
+    int r = dvb_streaming_start(stream, priv->prog);
+    if (r) {
+        // Stream will be pulled down after channel switch,
+        // persist state.
+        state->switching_channel = true;
+    }
+}
+
+static int dvb_open(stream_t *stream)
+{
+    dvb_priv_t *priv = NULL;
+
+    mp_mutex_lock(&global_dvb_state_lock);
+    if (global_dvb_state && global_dvb_state->stream_used) {
+      MP_ERR(stream, "DVB stream already in use, only one DVB stream can exist at a time!\n");
+      mp_mutex_unlock(&global_dvb_state_lock);
+      goto err_out;
+    }
+
+    // Need to re-get config in any case, not part of global state.
+    stream->priv = talloc_zero(stream, dvb_priv_t);
+    priv = stream->priv;
+    priv->opts_cache = m_config_cache_alloc(stream, stream->global, &stream_dvb_conf);
+    priv->opts = priv->opts_cache->opts;
+
+    dvb_state_t *state = dvb_get_state(stream);
+
+    priv->state = state;
+    priv->log = stream->log;
+    if (!state) {
+        MP_ERR(stream, "DVB configuration is empty\n");
+        mp_mutex_unlock(&global_dvb_state_lock);
+        goto err_out;
+    }
+
+    if (!dvb_parse_path(stream)) {
+        mp_mutex_unlock(&global_dvb_state_lock);
+        goto err_out;
+    }
+
+    state->stream_used = true;
+    mp_mutex_unlock(&global_dvb_state_lock);
+
+    if (!state->is_on) {
+        // State could be already initialized, for example, we just did a channel switch.
+        // The following setup only has to be done once.
+
+        state->cur_frontend = -1;
+
+        if (!dvb_streaming_start(stream, priv->prog))
+            goto err_out;
+    }
+
+    stream->fill_buffer = dvb_streaming_read;
+    stream->close = dvbin_close;
+    stream->control = dvbin_stream_control;
+    stream->streaming = true;
+    stream->demuxer = "lavf";
+    stream->lavf_type = "mpegts";
+
+    return STREAM_OK;
+
+err_out:
+    talloc_free(priv);
+    stream->priv = NULL;
+    return STREAM_ERROR;
+}
+
+int dvb_parse_path(stream_t *stream)
+{
+    dvb_priv_t *priv = stream->priv;
+    dvb_state_t *state = priv->state;
+
+    // Parse stream path. Common rule: cfg wins over stream path,
+    // since cfg may be changed at runtime.
+    bstr prog, devno;
+    if (!bstr_split_tok(bstr0(stream->path), "@", &devno, &prog)) {
+        prog = devno;
+        devno.len = 0;
+    }
+
+    if (priv->opts->cfg_devno != 0) {
+        priv->devno = priv->opts->cfg_devno;
+    } else if (devno.len) {
+        bstr r;
+        priv->devno = bstrtoll(devno, &r, 0);
+        if (r.len || priv->devno < 0 || priv->devno >= MAX_ADAPTERS) {
+            MP_ERR(stream, "invalid devno: '%.*s'\n", BSTR_P(devno));
+            return 0;
+        }
+    } else {
+        // Default to the default of cfg_devno.
+        priv->devno = priv->opts->cfg_devno;
+    }
+
+    // Current adapter is derived from devno.
+    state->cur_adapter = -1;
+    for (int i = 0; i < state->adapters_count; i++) {
+        if (state->adapters[i].devno == priv->devno) {
+            state->cur_adapter = i;
+            break;
+        }
+    }
+
+    if (state->cur_adapter == -1) {
+        MP_ERR(stream, "No configuration found for adapter %d!\n",
+               priv->devno);
+        return 0;
+    }
+
+    char *new_prog = NULL;
+    if (priv->opts->cfg_prog != NULL && strlen(priv->opts->cfg_prog) > 0) {
+        new_prog = talloc_strdup(priv, priv->opts->cfg_prog);
+    } else if (prog.len) {
+        new_prog = bstrto0(priv, prog);
+    } else {
+        // We use the first program from the channel list.
+        dvb_channels_list_t  *list = state->adapters[state->cur_adapter].list;
+        if (!list) {
+            MP_ERR(stream, "No channel list available for adapter %d!\n", priv->devno);
+            return 0;
+        }
+        new_prog = talloc_strdup(priv, list->channels[0].name);
+    }
+    talloc_free(priv->prog);
+    priv->prog = new_prog;
+
+    MP_VERBOSE(stream, "dvb_config: prog=\"%s\", devno=%d\n",
+               priv->prog, priv->devno);
+    return 1;
+}
+
+dvb_state_t *dvb_get_state(stream_t *stream)
+{
+    dvb_priv_t *priv = stream->priv;
+    if (global_dvb_state)
+        return global_dvb_state;
+
+    struct mp_log *log = stream->log;
+    struct mpv_global *global = stream->global;
+
+    dvb_state_t *state = talloc_zero(NULL, dvb_state_t);
+    state->switching_channel = false;
+    state->is_on = false;
+    state->stream_used = true;
+    state->fe_fd = state->dvr_fd = -1;
+
+    for (unsigned int i = 0; i < MAX_ADAPTERS; i++) {
+        dvb_channels_list_t *list = NULL;
+        unsigned int delsys_mask[MAX_FRONTENDS];
+        for (unsigned int f = 0; f < MAX_FRONTENDS; f++) {
+            char filename[100];
+            snprintf(filename, sizeof(filename), "/dev/dvb/adapter%u/frontend%u", i, f);
+            int fd = open(filename, O_RDONLY | O_NONBLOCK | O_CLOEXEC);
+            if (fd < 0)
+                continue;
+
+            delsys_mask[f] = dvb_get_tuner_delsys_mask(fd, log);
+            delsys_mask[f] &= DELSYS_SUPP_MASK; /* Filter unsupported delivery systems. */
+            close(fd);
+            if (delsys_mask[f] == 0) {
+                mp_verbose(log, "Frontend device %s has no supported delivery systems.\n",
+                       filename);
+                continue; /* Skip tuner. */
+            }
+
+            /* Create channel list for adapter. */
+            for (unsigned int delsys = 0; delsys < SYS_DVB__COUNT__; delsys++) {
+                if (!DELSYS_IS_SET(delsys_mask[f], delsys))
+                    continue; /* Skip unsupported. */
+
+                mp_verbose(log, "Searching channel list for delivery system %s\n", get_dvb_delsys(delsys));
+                const char *conf_file_name;
+                switch (delsys) {
+                case SYS_DVBC_ANNEX_A:
+                case SYS_DVBC_ANNEX_C:
+                    conf_file_name = "channels.conf.cbl";
+                    break;
+                case SYS_ATSC:
+                    conf_file_name = "channels.conf.atsc";
+                    break;
+                case SYS_DVBT:
+                    if (DELSYS_IS_SET(delsys_mask[f], SYS_DVBT2))
+                        continue; /* Add all channels later with T2. */
+                    conf_file_name = "channels.conf.ter";
+                    break;
+                case SYS_DVBT2:
+                    conf_file_name = "channels.conf.ter";
+                    break;
+                case SYS_ISDBT:
+                    conf_file_name = "channels.conf.isdbt";
+                    break;
+                case SYS_DVBS:
+                    if (DELSYS_IS_SET(delsys_mask[f], SYS_DVBS2))
+                        continue; /* Add all channels later with S2. */
+                    conf_file_name = "channels.conf.sat";
+                    break;
+                case SYS_DVBS2:
+                    conf_file_name = "channels.conf.sat";
+                    break;
+                default:
+                    continue;
+                }
+
+                void *talloc_ctx = NULL;
+                char *conf_file;
+                if (priv->opts->cfg_file && priv->opts->cfg_file[0]) {
+                    conf_file = priv->opts->cfg_file;
+                } else {
+                    talloc_ctx = talloc_new(NULL);
+                    conf_file = mp_find_config_file(talloc_ctx, global, conf_file_name);
+                    if (conf_file) {
+                        mp_verbose(log, "Ignoring other channels.conf files.\n");
+                    } else {
+                        conf_file = mp_find_config_file(talloc_ctx, global,
+                                        "channels.conf");
+                    }
+                }
+
+                list = dvb_get_channels(log, list, priv->opts->cfg_full_transponder,
+                                        conf_file, f, delsys, delsys_mask[f]);
+                talloc_free(talloc_ctx);
+            }
+        }
+        /* Add adapter with non zero channel list. */
+        if (!list)
+            continue;
+
+        dvb_adapter_config_t tmp = {
+            .devno = i,
+            .list = talloc_steal(state, list),
+        };
+        memcpy(&tmp.delsys_mask, delsys_mask, sizeof(delsys_mask));
+
+        MP_TARRAY_APPEND(state, state->adapters, state->adapters_count, tmp);
+
+        mp_verbose(log, "Added adapter with channels to state list, now %d.\n",
+                   state->adapters_count);
+    }
+
+    if (state->adapters_count == 0)
+        TA_FREEP(&state);
+
+    global_dvb_state = state;
+    return state;
+}
+
+const stream_info_t stream_info_dvb = {
+    .name = "dvbin",
+    .open = dvb_open,
+    .protocols = (const char *const[]){ "dvb", NULL },
+    .stream_origin = STREAM_ORIGIN_UNSAFE,
+};
diff --git a/stream/stream_dvdnav.c b/stream/stream_dvdnav.c
new file mode 100644
index 0000000..d858c51
--- /dev/null
+++ b/stream/stream_dvdnav.c
@@ -0,0 +1,719 @@
+/*
+ * 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 "config.h"
+
+#if !HAVE_GPL
+#error GPL only
+#endif
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <strings.h>
+#include <errno.h>
+#include <assert.h>
+
+#ifdef __linux__
+#include <linux/cdrom.h>
+#include <scsi/sg.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#endif
+
+#include <dvdnav/dvdnav.h>
+#include <libavutil/common.h>
+#include <libavutil/intreadwrite.h>
+
+#include "osdep/io.h"
+
+#include "options/options.h"
+#include "common/msg.h"
+#include "input/input.h"
+#include "options/m_config.h"
+#include "options/path.h"
+#include "osdep/timer.h"
+#include "stream.h"
+#include "demux/demux.h"
+#include "video/out/vo.h"
+
+#define TITLE_MENU -1
+#define TITLE_LONGEST -2
+
+struct priv {
+    dvdnav_t *dvdnav;                   // handle to libdvdnav stuff
+    char *filename;                     // path
+    unsigned int duration;              // in milliseconds
+    int mousex, mousey;
+    int title;
+    uint32_t spu_clut[16];
+    bool spu_clut_valid;
+    bool had_initial_vts;
+
+    int dvd_speed;
+
+    int track;
+    char *device;
+
+    struct dvd_opts *opts;
+};
+
+#define DNE(e) [e] = # e
+static const char *const mp_dvdnav_events[] = {
+    DNE(DVDNAV_BLOCK_OK),
+    DNE(DVDNAV_NOP),
+    DNE(DVDNAV_STILL_FRAME),
+    DNE(DVDNAV_SPU_STREAM_CHANGE),
+    DNE(DVDNAV_AUDIO_STREAM_CHANGE),
+    DNE(DVDNAV_VTS_CHANGE),
+    DNE(DVDNAV_CELL_CHANGE),
+    DNE(DVDNAV_NAV_PACKET),
+    DNE(DVDNAV_STOP),
+    DNE(DVDNAV_HIGHLIGHT),
+    DNE(DVDNAV_SPU_CLUT_CHANGE),
+    DNE(DVDNAV_HOP_CHANNEL),
+    DNE(DVDNAV_WAIT),
+};
+
+#define LOOKUP_NAME(array, i) \
+    (((i) >= 0 && (i) < MP_ARRAY_SIZE(array)) ? array[(i)] : "?")
+
+static void dvd_set_speed(stream_t *stream, char *device, unsigned speed)
+{
+#if defined(__linux__) && defined(SG_IO) && defined(GPCMD_SET_STREAMING)
+  int fd;
+  unsigned char buffer[28];
+  unsigned char cmd[12];
+  struct sg_io_hdr sghdr;
+  struct stat st;
+
+  memset(&st, 0, sizeof(st));
+
+  if (stat(device, &st) == -1) return;
+
+  if (!S_ISBLK(st.st_mode)) return; /* not a block device */
+
+  switch (speed) {
+  case 0: /* don't touch speed setting */
+    return;
+  case -1: /* restore default value */
+    MP_INFO(stream, "Restoring DVD speed... ");
+    break;
+  default: /* limit to <speed> KB/s */
+    // speed < 100 is multiple of DVD single speed (1350KB/s)
+    if (speed < 100)
+      speed *= 1350;
+    MP_INFO(stream, "Limiting DVD speed to %dKB/s... ", speed);
+    break;
+  }
+
+  memset(&sghdr, 0, sizeof(sghdr));
+  sghdr.interface_id = 'S';
+  sghdr.timeout = 5000;
+  sghdr.dxfer_direction = SG_DXFER_TO_DEV;
+  sghdr.dxfer_len = sizeof(buffer);
+  sghdr.dxferp = buffer;
+  sghdr.cmd_len = sizeof(cmd);
+  sghdr.cmdp = cmd;
+
+  memset(cmd, 0, sizeof(cmd));
+  cmd[0] = GPCMD_SET_STREAMING;
+  cmd[10] = sizeof(buffer);
+
+  memset(buffer, 0, sizeof(buffer));
+  /* first sector 0, last sector 0xffffffff */
+  AV_WB32(buffer + 8, 0xffffffff);
+  if (speed == -1)
+    buffer[0] = 4; /* restore default */
+  else {
+    /* <speed> kilobyte */
+    AV_WB32(buffer + 12, speed);
+    AV_WB32(buffer + 20, speed);
+  }
+  /* 1 second */
+  AV_WB16(buffer + 18, 1000);
+  AV_WB16(buffer + 26, 1000);
+
+  fd = open(device, O_RDWR | O_NONBLOCK | O_CLOEXEC);
+  if (fd == -1) {
+    MP_INFO(stream, "Couldn't open DVD device for writing, changing DVD speed needs write access.\n");
+    return;
+  }
+
+  if (ioctl(fd, SG_IO, &sghdr) < 0)
+    MP_INFO(stream, "failed\n");
+  else
+    MP_INFO(stream, "successful\n");
+
+  close(fd);
+#endif
+}
+
+// Check if this is likely to be an .ifo or similar file.
+static int dvd_probe(const char *path, const char *ext, const char *sig)
+{
+    if (!bstr_case_endswith(bstr0(path), bstr0(ext)))
+        return false;
+
+    FILE *temp = fopen(path, "rb");
+    if (!temp)
+        return false;
+
+    bool r = false;
+
+    char data[50];
+
+    assert(strlen(sig) <= sizeof(data));
+
+    if (fread(data, 50, 1, temp) == 1) {
+        if (memcmp(data, sig, strlen(sig)) == 0)
+            r = true;
+    }
+
+    fclose(temp);
+    return r;
+}
+
+/**
+ * \brief mp_dvdnav_lang_from_aid() returns the language corresponding to audio id 'aid'
+ * \param stream: - stream pointer
+ * \param sid: physical subtitle id
+ * \return 0 on error, otherwise language id
+ */
+static int mp_dvdnav_lang_from_aid(stream_t *stream, int aid)
+{
+    uint8_t lg;
+    uint16_t lang;
+    struct priv *priv = stream->priv;
+
+    if (aid < 0)
+        return 0;
+    lg = dvdnav_get_audio_logical_stream(priv->dvdnav, aid & 0x7);
+    if (lg == 0xff)
+        return 0;
+    lang = dvdnav_audio_stream_to_lang(priv->dvdnav, lg);
+    if (lang == 0xffff)
+        return 0;
+    return lang;
+}
+
+/**
+ * \brief mp_dvdnav_lang_from_sid() returns the language corresponding to subtitle id 'sid'
+ * \param stream: - stream pointer
+ * \param sid: physical subtitle id
+ * \return 0 on error, otherwise language id
+ */
+static int mp_dvdnav_lang_from_sid(stream_t *stream, int sid)
+{
+    uint8_t k;
+    uint16_t lang;
+    struct priv *priv = stream->priv;
+    if (sid < 0)
+        return 0;
+    for (k = 0; k < 32; k++)
+        if (dvdnav_get_spu_logical_stream(priv->dvdnav, k) == sid)
+            break;
+    if (k == 32)
+        return 0;
+    lang = dvdnav_spu_stream_to_lang(priv->dvdnav, k);
+    if (lang == 0xffff)
+        return 0;
+    return lang;
+}
+
+/**
+ * \brief mp_dvdnav_number_of_subs() returns the count of available subtitles
+ * \param stream: - stream pointer
+ * \return 0 on error, something meaningful otherwise
+ */
+static int mp_dvdnav_number_of_subs(stream_t *stream)
+{
+    struct priv *priv = stream->priv;
+    uint8_t lg, k, n = 0;
+
+    for (k = 0; k < 32; k++) {
+        lg = dvdnav_get_spu_logical_stream(priv->dvdnav, k);
+        if (lg == 0xff)
+            continue;
+        if (lg >= n)
+            n = lg + 1;
+    }
+    return n;
+}
+
+static int fill_buffer(stream_t *s, void *buf, int max_len)
+{
+    struct priv *priv = s->priv;
+    dvdnav_t *dvdnav = priv->dvdnav;
+
+    if (max_len < 2048) {
+        MP_FATAL(s, "Short read size. Data corruption will follow. Please "
+                    "provide a patch.\n");
+        return -1;
+    }
+
+    while (1) {
+        int len = -1;
+        int event = DVDNAV_NOP;
+        if (dvdnav_get_next_block(dvdnav, buf, &event, &len) != DVDNAV_STATUS_OK)
+        {
+            MP_ERR(s, "Error getting next block from DVD %d (%s)\n",
+                   event, dvdnav_err_to_string(dvdnav));
+            return 0;
+        }
+        if (event != DVDNAV_BLOCK_OK) {
+            const char *name = LOOKUP_NAME(mp_dvdnav_events, event);
+            MP_TRACE(s, "DVDNAV: event %s (%d).\n", name, event);
+        }
+        switch (event) {
+        case DVDNAV_BLOCK_OK:
+            return len;
+        case DVDNAV_STOP:
+            return 0;
+        case DVDNAV_NAV_PACKET: {
+            pci_t *pnavpci = dvdnav_get_current_nav_pci(dvdnav);
+            uint32_t start_pts = pnavpci->pci_gi.vobu_s_ptm;
+            MP_TRACE(s, "start pts = %"PRIu32"\n", start_pts);
+            break;
+        }
+        case DVDNAV_STILL_FRAME:
+            dvdnav_still_skip(dvdnav);
+            return 0;
+        case DVDNAV_WAIT:
+            dvdnav_wait_skip(dvdnav);
+            return 0;
+        case DVDNAV_HIGHLIGHT:
+            break;
+        case DVDNAV_VTS_CHANGE: {
+            int tit = 0, part = 0;
+            dvdnav_vts_change_event_t *vts_event =
+                (dvdnav_vts_change_event_t *)s->buffer;
+            MP_INFO(s, "DVDNAV, switched to title: %d\n",
+                   vts_event->new_vtsN);
+            if (!priv->had_initial_vts) {
+                // dvdnav sends an initial VTS change before any data; don't
+                // cause a blocking wait for the player, because the player in
+                // turn can't initialize the demuxer without data.
+                priv->had_initial_vts = true;
+                break;
+            }
+            if (dvdnav_current_title_info(dvdnav, &tit, &part) == DVDNAV_STATUS_OK)
+            {
+                MP_VERBOSE(s, "DVDNAV, NEW TITLE %d\n", tit);
+                if (priv->title > 0 && tit != priv->title)
+                    MP_WARN(s, "Requested title not found\n");
+            }
+            break;
+        }
+        case DVDNAV_CELL_CHANGE: {
+            dvdnav_cell_change_event_t *ev =  (dvdnav_cell_change_event_t *)buf;
+
+            if (ev->pgc_length)
+                priv->duration = ev->pgc_length / 90;
+
+            break;
+        }
+        case DVDNAV_SPU_CLUT_CHANGE: {
+            memcpy(priv->spu_clut, buf, 16 * sizeof(uint32_t));
+            priv->spu_clut_valid = true;
+            break;
+        }
+        }
+    }
+    return 0;
+}
+
+static int control(stream_t *stream, int cmd, void *arg)
+{
+    struct priv *priv = stream->priv;
+    dvdnav_t *dvdnav = priv->dvdnav;
+    int tit, part;
+
+    switch (cmd) {
+    case STREAM_CTRL_GET_NUM_CHAPTERS: {
+        if (dvdnav_current_title_info(dvdnav, &tit, &part) != DVDNAV_STATUS_OK)
+            break;
+        if (dvdnav_get_number_of_parts(dvdnav, tit, &part) != DVDNAV_STATUS_OK)
+            break;
+        if (!part)
+            break;
+        *(unsigned int *)arg = part;
+        return 1;
+    }
+    case STREAM_CTRL_GET_CHAPTER_TIME: {
+        double *ch = arg;
+        int chapter = *ch;
+        if (dvdnav_current_title_info(dvdnav, &tit, &part) != DVDNAV_STATUS_OK)
+            break;
+        uint64_t *parts = NULL, duration = 0;
+        int n = dvdnav_describe_title_chapters(dvdnav, tit, &parts, &duration);
+        if (!parts)
+            break;
+        if (chapter < 0 || chapter + 1 > n)
+            break;
+        *ch = chapter > 0 ? parts[chapter - 1] / 90000.0 : 0;
+        free(parts);
+        return 1;
+    }
+    case STREAM_CTRL_GET_TIME_LENGTH: {
+        if (priv->duration) {
+            *(double *)arg = (double)priv->duration / 1000.0;
+            return 1;
+        }
+        break;
+    }
+    case STREAM_CTRL_GET_ASPECT_RATIO: {
+        uint8_t ar = dvdnav_get_video_aspect(dvdnav);
+        *(double *)arg = !ar ? 4.0 / 3.0 : 16.0 / 9.0;
+        return 1;
+    }
+    case STREAM_CTRL_GET_CURRENT_TIME: {
+        double tm;
+        tm = dvdnav_get_current_time(dvdnav) / 90000.0f;
+        if (tm != -1) {
+            *(double *)arg = tm;
+            return 1;
+        }
+        break;
+    }
+    case STREAM_CTRL_GET_NUM_TITLES: {
+        int32_t num_titles = 0;
+        if (dvdnav_get_number_of_titles(dvdnav, &num_titles) != DVDNAV_STATUS_OK)
+            break;
+        *((unsigned int*)arg)= num_titles;
+        return STREAM_OK;
+    }
+    case STREAM_CTRL_GET_TITLE_LENGTH: {
+        int t = *(double *)arg;
+        int32_t num_titles = 0;
+        if (dvdnav_get_number_of_titles(dvdnav, &num_titles) != DVDNAV_STATUS_OK)
+            break;
+        if (t < 0 || t >= num_titles)
+            break;
+        uint64_t duration = 0;
+        uint64_t *parts = NULL;
+        dvdnav_describe_title_chapters(dvdnav, t + 1, &parts, &duration);
+        if (!parts)
+            break;
+        free(parts);
+        *(double *)arg = duration / 90000.0;
+        return STREAM_OK;
+    }
+    case STREAM_CTRL_GET_CURRENT_TITLE: {
+        if (dvdnav_current_title_info(dvdnav, &tit, &part) != DVDNAV_STATUS_OK)
+            break;
+        *((unsigned int *) arg) = tit - 1;
+        return STREAM_OK;
+    }
+    case STREAM_CTRL_SET_CURRENT_TITLE: {
+        int title = *((unsigned int *) arg);
+        if (dvdnav_title_play(priv->dvdnav, title + 1) != DVDNAV_STATUS_OK)
+            break;
+        stream_drop_buffers(stream);
+        return STREAM_OK;
+    }
+    case STREAM_CTRL_SEEK_TO_TIME: {
+        double *args = arg;
+        double d = args[0]; // absolute target timestamp
+        int flags = args[1]; // from SEEK_* flags (demux.h)
+        if (flags & SEEK_HR)
+            d -= 10; // fudge offset; it's a hack, because fuck libdvd*
+        int64_t tm = (int64_t)(d * 90000);
+        if (tm < 0)
+            tm = 0;
+        if (priv->duration && tm >= (priv->duration * 90))
+            tm = priv->duration * 90 - 1;
+        uint32_t pos, len;
+        if (dvdnav_get_position(dvdnav, &pos, &len) != DVDNAV_STATUS_OK)
+            break;
+        MP_VERBOSE(stream, "seek to PTS %f (%"PRId64")\n", d, tm);
+        if (dvdnav_time_search(dvdnav, tm) != DVDNAV_STATUS_OK)
+            break;
+        stream_drop_buffers(stream);
+        d = dvdnav_get_current_time(dvdnav) / 90000.0f;
+        MP_VERBOSE(stream, "landed at: %f\n", d);
+        if (dvdnav_get_position(dvdnav, &pos, &len) == DVDNAV_STATUS_OK)
+            MP_VERBOSE(stream, "block: %lu\n", (unsigned long)pos);
+        return STREAM_OK;
+    }
+    case STREAM_CTRL_GET_NUM_ANGLES: {
+        uint32_t curr, angles;
+        if (dvdnav_get_angle_info(dvdnav, &curr, &angles) != DVDNAV_STATUS_OK)
+            break;
+        *(int *)arg = angles;
+        return 1;
+    }
+    case STREAM_CTRL_GET_ANGLE: {
+        uint32_t curr, angles;
+        if (dvdnav_get_angle_info(dvdnav, &curr, &angles) != DVDNAV_STATUS_OK)
+            break;
+        *(int *)arg = curr;
+        return 1;
+    }
+    case STREAM_CTRL_SET_ANGLE: {
+        uint32_t curr, angles;
+        int new_angle = *(int *)arg;
+        if (dvdnav_get_angle_info(dvdnav, &curr, &angles) != DVDNAV_STATUS_OK)
+            break;
+        if (new_angle > angles || new_angle < 1)
+            break;
+        if (dvdnav_angle_change(dvdnav, new_angle) != DVDNAV_STATUS_OK)
+            return 1;
+        break;
+    }
+    case STREAM_CTRL_GET_LANG: {
+        struct stream_lang_req *req = arg;
+        int lang = 0;
+        switch (req->type) {
+        case STREAM_AUDIO:
+            lang = mp_dvdnav_lang_from_aid(stream, req->id);
+            break;
+        case STREAM_SUB:
+            lang = mp_dvdnav_lang_from_sid(stream, req->id);
+            break;
+        }
+        if (!lang)
+            break;
+        snprintf(req->name, sizeof(req->name), "%c%c", lang >> 8, lang);
+        return STREAM_OK;
+    }
+    case STREAM_CTRL_GET_DVD_INFO: {
+        struct stream_dvd_info_req *req = arg;
+        memset(req, 0, sizeof(*req));
+        req->num_subs = mp_dvdnav_number_of_subs(stream);
+        assert(sizeof(uint32_t) == sizeof(unsigned int));
+        memcpy(req->palette, priv->spu_clut, sizeof(req->palette));
+        return STREAM_OK;
+    }
+    case STREAM_CTRL_GET_DISC_NAME: {
+        const char *volume = NULL;
+        if (dvdnav_get_title_string(dvdnav, &volume) != DVDNAV_STATUS_OK)
+            break;
+        if (!volume || !volume[0])
+            break;
+        *(char**)arg = talloc_strdup(NULL, volume);
+        return STREAM_OK;
+    }
+    }
+
+    return STREAM_UNSUPPORTED;
+}
+
+static void stream_dvdnav_close(stream_t *s)
+{
+    struct priv *priv = s->priv;
+    dvdnav_close(priv->dvdnav);
+    priv->dvdnav = NULL;
+    if (priv->dvd_speed)
+        dvd_set_speed(s, priv->filename, -1);
+    if (priv->filename)
+        free(priv->filename);
+}
+
+static struct priv *new_dvdnav_stream(stream_t *stream, char *filename)
+{
+    struct priv *priv = stream->priv;
+    const char *title_str;
+
+    if (!filename)
+        return NULL;
+
+    if (!(priv->filename = strdup(filename)))
+        return NULL;
+
+    priv->dvd_speed = priv->opts->speed;
+    dvd_set_speed(stream, priv->filename, priv->dvd_speed);
+
+    if (dvdnav_open(&(priv->dvdnav), priv->filename) != DVDNAV_STATUS_OK) {
+        free(priv->filename);
+        priv->filename = NULL;
+        return NULL;
+    }
+
+    if (!priv->dvdnav)
+        return NULL;
+
+    dvdnav_set_readahead_flag(priv->dvdnav, 1);
+    if (dvdnav_set_PGC_positioning_flag(priv->dvdnav, 1) != DVDNAV_STATUS_OK)
+        MP_ERR(stream, "stream_dvdnav, failed to set PGC positioning\n");
+    /* report the title?! */
+    dvdnav_get_title_string(priv->dvdnav, &title_str);
+
+    return priv;
+}
+
+static int open_s_internal(stream_t *stream)
+{
+    struct priv *priv, *p;
+    priv = p = stream->priv;
+    char *filename;
+
+    p->opts = mp_get_config_group(stream, stream->global, &dvd_conf);
+
+    if (p->device && p->device[0])
+        filename = p->device;
+    else if (p->opts->device && p->opts->device[0])
+        filename = p->opts->device;
+    else
+        filename = DEFAULT_DVD_DEVICE;
+    if (!new_dvdnav_stream(stream, filename)) {
+        MP_ERR(stream, "Couldn't open DVD device: %s\n",
+                filename);
+        return STREAM_ERROR;
+    }
+
+    if (p->track == TITLE_LONGEST) { // longest
+        dvdnav_t *dvdnav = priv->dvdnav;
+        uint64_t best_length = 0;
+        int best_title = -1;
+        int32_t num_titles;
+        if (dvdnav_get_number_of_titles(dvdnav, &num_titles) == DVDNAV_STATUS_OK) {
+            MP_VERBOSE(stream, "List of available titles:\n");
+            for (int n = 1; n <= num_titles; n++) {
+                uint64_t *parts = NULL, duration = 0;
+                dvdnav_describe_title_chapters(dvdnav, n, &parts, &duration);
+                if (parts) {
+                    if (duration > best_length) {
+                        best_length = duration;
+                        best_title = n;
+                    }
+                    if (duration > 90000) { // arbitrarily ignore <1s titles
+                        char *time = mp_format_time(duration / 90000, false);
+                        MP_VERBOSE(stream, "title: %3d duration: %s\n",
+                                   n - 1, time);
+                        talloc_free(time);
+                    }
+                    free(parts);
+                }
+            }
+        }
+        p->track = best_title - 1;
+        MP_INFO(stream, "Selecting title %d.\n", p->track);
+    }
+
+    if (p->track >= 0) {
+        priv->title = p->track;
+        if (dvdnav_title_play(priv->dvdnav, p->track + 1) != DVDNAV_STATUS_OK) {
+            MP_FATAL(stream, "dvdnav_stream, couldn't select title %d, error '%s'\n",
+                   p->track, dvdnav_err_to_string(priv->dvdnav));
+            return STREAM_UNSUPPORTED;
+        }
+    } else {
+        MP_FATAL(stream, "DVD menu support has been removed.\n");
+        return STREAM_ERROR;
+    }
+    if (p->opts->angle > 1)
+        dvdnav_angle_change(priv->dvdnav, p->opts->angle);
+
+    stream->fill_buffer = fill_buffer;
+    stream->control = control;
+    stream->close = stream_dvdnav_close;
+    stream->demuxer = "+disc";
+    stream->lavf_type = "mpeg";
+
+    return STREAM_OK;
+}
+
+static int open_s(stream_t *stream)
+{
+    struct priv *priv = talloc_zero(stream, struct priv);
+    stream->priv = priv;
+
+    bstr title, bdevice;
+    bstr_split_tok(bstr0(stream->path), "/", &title, &bdevice);
+
+    priv->track = TITLE_LONGEST;
+
+    if (bstr_equals0(title, "longest") || bstr_equals0(title, "first")) {
+        priv->track = TITLE_LONGEST;
+    } else if (bstr_equals0(title, "menu")) {
+        priv->track = TITLE_MENU;
+    } else if (title.len) {
+        bstr rest;
+        priv->track = bstrtoll(title, &rest, 10);
+        if (rest.len) {
+            MP_ERR(stream, "number expected: '%.*s'\n", BSTR_P(rest));
+            return STREAM_ERROR;
+        }
+    }
+
+    priv->device = bstrto0(priv, bdevice);
+
+    return open_s_internal(stream);
+}
+
+const stream_info_t stream_info_dvdnav = {
+    .name = "dvdnav",
+    .open = open_s,
+    .protocols = (const char*const[]){ "dvd", "dvdnav", NULL },
+    .stream_origin = STREAM_ORIGIN_UNSAFE,
+};
+
+static bool check_ifo(const char *path)
+{
+    if (strcasecmp(mp_basename(path), "video_ts.ifo"))
+        return false;
+
+    return dvd_probe(path, ".ifo", "DVDVIDEO-VMG");
+}
+
+static int ifo_dvdnav_stream_open(stream_t *stream)
+{
+    struct priv *priv = talloc_zero(stream, struct priv);
+    stream->priv = priv;
+
+    if (!stream->access_references)
+        goto unsupported;
+
+    priv->track = TITLE_LONGEST;
+
+    char *path = mp_file_get_path(priv, bstr0(stream->url));
+    if (!path)
+        goto unsupported;
+
+    // We allow the path to point to a directory containing VIDEO_TS/, a
+    // directory containing VIDEO_TS.IFO, or that file itself.
+    if (!check_ifo(path)) {
+        // On UNIX, just assume the filename is always uppercase.
+        char *npath = mp_path_join(priv, path, "VIDEO_TS.IFO");
+        if (!check_ifo(npath)) {
+            npath = mp_path_join(priv, path, "VIDEO_TS/VIDEO_TS.IFO");
+            if (!check_ifo(npath))
+                goto unsupported;
+        }
+        path = npath;
+    }
+
+    priv->device = bstrto0(priv, mp_dirname(path));
+
+    MP_INFO(stream, ".IFO detected. Redirecting to dvd://\n");
+    return open_s_internal(stream);
+
+unsupported:
+    talloc_free(priv);
+    stream->priv = NULL;
+    return STREAM_UNSUPPORTED;
+}
+
+const stream_info_t stream_info_ifo_dvdnav = {
+    .name = "ifo_dvdnav",
+    .open = ifo_dvdnav_stream_open,
+    .protocols = (const char*const[]){ "file", "", NULL },
+    .stream_origin = STREAM_ORIGIN_UNSAFE,
+};
diff --git a/stream/stream_edl.c b/stream/stream_edl.c
new file mode 100644
index 0000000..94bbe58
--- /dev/null
+++ b/stream/stream_edl.c
@@ -0,0 +1,17 @@
+// Dummy stream implementation to enable demux_edl, which is in turn a
+// dummy demuxer implementation to enable tl_edl.
+
+#include "stream.h"
+
+static int s_open (struct stream *stream)
+{
+    stream->demuxer = "edl";
+
+    return STREAM_OK;
+}
+
+const stream_info_t stream_info_edl = {
+    .name = "edl",
+    .open = s_open,
+    .protocols = (const char*const[]){"edl", NULL},
+};
diff --git a/stream/stream_file.c b/stream/stream_file.c
new file mode 100644
index 0000000..4895a83
--- /dev/null
+++ b/stream/stream_file.c
@@ -0,0 +1,377 @@
+/*
+ * Original authors: Albeu, probably Arpi
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+
+#ifndef __MINGW32__
+#include <poll.h>
+#endif
+
+#include "osdep/io.h"
+
+#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"
+
+#if HAVE_BSD_FSTATFS
+#include <sys/param.h>
+#include <sys/mount.h>
+#endif
+
+#if HAVE_LINUX_FSTATFS
+#include <sys/vfs.h>
+#endif
+
+#ifdef _WIN32
+#include <windows.h>
+#include <winternl.h>
+#include <io.h>
+
+#ifndef FILE_REMOTE_DEVICE
+#define FILE_REMOTE_DEVICE (0x10)
+#endif
+#endif
+
+struct priv {
+    int fd;
+    bool close;
+    bool use_poll;
+    bool regular_file;
+    bool appending;
+    int64_t orig_size;
+    struct mp_cancel *cancel;
+};
+
+// Total timeout = RETRY_TIMEOUT * MAX_RETRIES
+#define RETRY_TIMEOUT 0.2
+#define MAX_RETRIES 10
+
+static int64_t get_size(stream_t *s)
+{
+    struct priv *p = s->priv;
+    struct stat st;
+    if (fstat(p->fd, &st) == 0) {
+        if (st.st_size <= 0 && !s->seekable)
+            st.st_size = -1;
+        if (st.st_size >= 0)
+            return st.st_size;
+    }
+    return -1;
+}
+
+static int fill_buffer(stream_t *s, void *buffer, int max_len)
+{
+    struct priv *p = s->priv;
+
+#ifndef __MINGW32__
+    if (p->use_poll) {
+        int c = mp_cancel_get_fd(p->cancel);
+        struct pollfd fds[2] = {
+            {.fd = p->fd, .events = POLLIN},
+            {.fd = c, .events = POLLIN},
+        };
+        poll(fds, c >= 0 ? 2 : 1, -1);
+        if (fds[1].revents & POLLIN)
+            return -1;
+    }
+#endif
+
+    for (int retries = 0; retries < MAX_RETRIES; retries++) {
+        int r = read(p->fd, buffer, max_len);
+        if (r > 0)
+            return r;
+
+        // Try to detect and handle files being appended during playback.
+        int64_t size = get_size(s);
+        if (p->regular_file && size > p->orig_size && !p->appending) {
+            MP_WARN(s, "File is apparently being appended to, will keep "
+                    "retrying with timeouts.\n");
+            p->appending = true;
+        }
+
+        if (!p->appending || p->use_poll)
+            break;
+
+        if (mp_cancel_wait(p->cancel, RETRY_TIMEOUT))
+            break;
+    }
+
+    return 0;
+}
+
+static int write_buffer(stream_t *s, void *buffer, int len)
+{
+    struct priv *p = s->priv;
+    return write(p->fd, buffer, len);
+}
+
+static int seek(stream_t *s, int64_t newpos)
+{
+    struct priv *p = s->priv;
+    return lseek(p->fd, newpos, SEEK_SET) != (off_t)-1;
+}
+
+static void s_close(stream_t *s)
+{
+    struct priv *p = s->priv;
+    if (p->close)
+        close(p->fd);
+}
+
+// If url is a file:// URL, return the local filename, otherwise return NULL.
+char *mp_file_url_to_filename(void *talloc_ctx, bstr url)
+{
+    bstr proto = mp_split_proto(url, &url);
+    if (bstrcasecmp0(proto, "file") != 0)
+        return NULL;
+    char *filename = bstrto0(talloc_ctx, url);
+    mp_url_unescape_inplace(filename);
+#if HAVE_DOS_PATHS
+    // extract '/' from '/x:/path'
+    if (filename[0] == '/' && filename[1] && filename[2] == ':')
+        memmove(filename, filename + 1, strlen(filename)); // including \0
+#endif
+    return filename;
+}
+
+// Return talloc_strdup's filesystem path if local, otherwise NULL.
+// Unlike mp_file_url_to_filename(), doesn't return NULL if already local.
+char *mp_file_get_path(void *talloc_ctx, bstr url)
+{
+    if (mp_split_proto(url, &(bstr){0}).len) {
+        return mp_file_url_to_filename(talloc_ctx, url);
+    } else {
+        return bstrto0(talloc_ctx, url);
+    }
+}
+
+#if HAVE_BSD_FSTATFS
+static bool check_stream_network(int fd)
+{
+    struct statfs fs;
+    const char *stypes[] = { "afpfs", "nfs", "smbfs", "webdav", "osxfusefs",
+                             "fuse", "fusefs.sshfs", "macfuse", NULL };
+    if (fstatfs(fd, &fs) == 0)
+        for (int i=0; stypes[i]; i++)
+            if (strcmp(stypes[i], fs.f_fstypename) == 0)
+                return true;
+    return false;
+
+}
+#elif HAVE_LINUX_FSTATFS
+static bool check_stream_network(int fd)
+{
+    struct statfs fs;
+    const uint32_t stypes[] = {
+        0x5346414F  /*AFS*/,    0x61756673  /*AUFS*/,   0x00C36400  /*CEPH*/,
+        0xFF534D42  /*CIFS*/,   0x73757245  /*CODA*/,   0x19830326  /*FHGFS*/,
+        0x65735546  /*FUSEBLK*/,0x65735543  /*FUSECTL*/,0x1161970   /*GFS*/,
+        0x47504653  /*GPFS*/,   0x6B414653  /*KAFS*/,   0x0BD00BD0  /*LUSTRE*/,
+        0x564C      /*NCP*/,    0x6969      /*NFS*/,    0x6E667364  /*NFSD*/,
+        0xAAD7AAEA  /*PANFS*/,  0x50495045  /*PIPEFS*/, 0x517B      /*SMB*/,
+        0xBEEFDEAD  /*SNFS*/,   0xBACBACBC  /*VMHGFS*/, 0x7461636f  /*OCFS2*/,
+        0xFE534D42  /*SMB2*/,   0x61636673  /*ACFS*/,   0x013111A8  /*IBRIX*/,
+        0
+    };
+    if (fstatfs(fd, &fs) == 0) {
+        for (int i=0; stypes[i]; i++) {
+            if (stypes[i] == fs.f_type)
+                return true;
+        }
+    }
+    return false;
+
+}
+#elif defined(_WIN32)
+static bool check_stream_network(int fd)
+{
+    NTSTATUS (NTAPI *pNtQueryVolumeInformationFile)(HANDLE,
+        PIO_STATUS_BLOCK, PVOID, ULONG, FS_INFORMATION_CLASS) = NULL;
+
+    // NtQueryVolumeInformationFile is an internal Windows function. It has
+    // been present since Windows XP, however this code should fail gracefully
+    // if it's removed from a future version of Windows.
+    HMODULE ntdll = GetModuleHandleW(L"ntdll.dll");
+    pNtQueryVolumeInformationFile = (NTSTATUS (NTAPI*)(HANDLE,
+        PIO_STATUS_BLOCK, PVOID, ULONG, FS_INFORMATION_CLASS))
+        GetProcAddress(ntdll, "NtQueryVolumeInformationFile");
+
+    if (!pNtQueryVolumeInformationFile)
+        return false;
+
+    HANDLE h = (HANDLE)_get_osfhandle(fd);
+    if (h == INVALID_HANDLE_VALUE)
+        return false;
+
+    FILE_FS_DEVICE_INFORMATION info = { 0 };
+    IO_STATUS_BLOCK io;
+    NTSTATUS status = pNtQueryVolumeInformationFile(h, &io, &info,
+        sizeof(info), FileFsDeviceInformation);
+    if (!NT_SUCCESS(status))
+        return false;
+
+    return info.DeviceType == FILE_DEVICE_NETWORK_FILE_SYSTEM ||
+           (info.Characteristics & FILE_REMOTE_DEVICE);
+}
+#else
+static bool check_stream_network(int fd)
+{
+    return false;
+}
+#endif
+
+static int open_f(stream_t *stream, const struct stream_open_args *args)
+{
+    struct priv *p = talloc_ptrtype(stream, p);
+    *p = (struct priv) {
+        .fd = -1,
+    };
+    stream->priv = p;
+    stream->is_local_file = true;
+
+    bool strict_fs = args->flags & STREAM_LOCAL_FS_ONLY;
+    bool write = stream->mode == STREAM_WRITE;
+    int m = O_CLOEXEC | (write ? O_RDWR | O_CREAT | O_TRUNC : O_RDONLY);
+
+    char *filename = stream->path;
+    char *url = "";
+    if (!strict_fs) {
+        char *fn = mp_file_url_to_filename(stream, bstr0(stream->url));
+        if (fn)
+            filename = stream->path = fn;
+        url = stream->url;
+    }
+
+    bool is_fdclose = strncmp(url, "fdclose://", 10) == 0;
+    if (strncmp(url, "fd://", 5) == 0 || is_fdclose) {
+        char *begin = strstr(stream->url, "://") + 3, *end = NULL;
+        p->fd = strtol(begin, &end, 0);
+        if (!end || end == begin || end[0]) {
+            MP_ERR(stream, "Invalid FD: %s\n", stream->url);
+            return STREAM_ERROR;
+        }
+        if (is_fdclose)
+            p->close = true;
+    } else if (!strict_fs && !strcmp(filename, "-")) {
+        if (!write) {
+            MP_INFO(stream, "Reading from stdin...\n");
+            p->fd = 0;
+        } else {
+            MP_INFO(stream, "Writing to stdout...\n");
+            p->fd = 1;
+        }
+    } else {
+        if (bstr_startswith0(bstr0(stream->url), "appending://"))
+            p->appending = true;
+
+        mode_t openmode = S_IRUSR | S_IWUSR;
+#ifndef __MINGW32__
+        openmode |= S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
+        if (!write)
+            m |= O_NONBLOCK;
+#endif
+        p->fd = open(filename, m | O_BINARY, openmode);
+        if (p->fd < 0) {
+            MP_ERR(stream, "Cannot open file '%s': %s\n",
+                   filename, mp_strerror(errno));
+            return STREAM_ERROR;
+        }
+        p->close = true;
+    }
+
+    struct stat st;
+    if (fstat(p->fd, &st) == 0) {
+        if (S_ISDIR(st.st_mode)) {
+            stream->is_directory = true;
+            if (!(args->flags & STREAM_LESS_NOISE))
+                MP_INFO(stream, "This is a directory - adding to playlist.\n");
+        } else if (S_ISREG(st.st_mode)) {
+            p->regular_file = true;
+#ifndef __MINGW32__
+            // 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;
+        }
+    }
+
+#ifdef __MINGW32__
+    setmode(p->fd, O_BINARY);
+#endif
+
+    off_t len = lseek(p->fd, 0, SEEK_END);
+    lseek(p->fd, 0, SEEK_SET);
+    if (len != (off_t)-1) {
+        stream->seek = seek;
+        stream->seekable = true;
+    }
+
+    stream->fast_skip = true;
+    stream->fill_buffer = fill_buffer;
+    stream->write_buffer = write_buffer;
+    stream->get_size = get_size;
+    stream->close = s_close;
+
+    if (check_stream_network(p->fd)) {
+        stream->streaming = true;
+#if HAVE_COCOA
+        if (fcntl(p->fd, F_RDAHEAD, 0) < 0) {
+            MP_VERBOSE(stream, "Cannot disable read ahead on file '%s': %s\n",
+                       filename, mp_strerror(errno));
+        }
+#endif
+    }
+
+    p->orig_size = get_size(stream);
+
+    p->cancel = mp_cancel_new(p);
+    if (stream->cancel)
+        mp_cancel_set_parent(p->cancel, stream->cancel);
+
+    return STREAM_OK;
+}
+
+const stream_info_t stream_info_file = {
+    .name = "file",
+    .open2 = open_f,
+    .protocols = (const char*const[]){ "file", "", "appending", NULL },
+    .can_write = true,
+    .local_fs = true,
+    .stream_origin = STREAM_ORIGIN_FS,
+};
+
+const stream_info_t stream_info_fd = {
+    .name = "fd",
+    .open2 = open_f,
+    .protocols = (const char*const[]){ "fd", "fdclose", NULL },
+    .can_write = true,
+    .stream_origin = STREAM_ORIGIN_UNSAFE,
+};
diff --git a/stream/stream_lavf.c b/stream/stream_lavf.c
new file mode 100644
index 0000000..c153ddd
--- /dev/null
+++ b/stream/stream_lavf.c
@@ -0,0 +1,457 @@
+/*
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include <libavformat/avformat.h>
+#include <libavformat/avio.h>
+#include <libavutil/opt.h>
+
+#include "options/path.h"
+#include "common/common.h"
+#include "common/msg.h"
+#include "common/tags.h"
+#include "common/av_common.h"
+#include "demux/demux.h"
+#include "misc/charset_conv.h"
+#include "misc/thread_tools.h"
+#include "stream.h"
+#include "options/m_config.h"
+#include "options/m_option.h"
+
+#include "cookies.h"
+
+#include "misc/bstr.h"
+#include "mpv_talloc.h"
+
+#define OPT_BASE_STRUCT struct stream_lavf_params
+struct stream_lavf_params {
+    char **avopts;
+    bool cookies_enabled;
+    char *cookies_file;
+    char *useragent;
+    char *referrer;
+    char **http_header_fields;
+    bool tls_verify;
+    char *tls_ca_file;
+    char *tls_cert_file;
+    char *tls_key_file;
+    double timeout;
+    char *http_proxy;
+};
+
+const struct m_sub_options stream_lavf_conf = {
+    .opts = (const m_option_t[]) {
+        {"stream-lavf-o", OPT_KEYVALUELIST(avopts)},
+        {"http-header-fields", OPT_STRINGLIST(http_header_fields)},
+        {"user-agent", OPT_STRING(useragent)},
+        {"referrer", OPT_STRING(referrer)},
+        {"cookies", OPT_BOOL(cookies_enabled)},
+        {"cookies-file", OPT_STRING(cookies_file), .flags = M_OPT_FILE},
+        {"tls-verify", OPT_BOOL(tls_verify)},
+        {"tls-ca-file", OPT_STRING(tls_ca_file), .flags = M_OPT_FILE},
+        {"tls-cert-file", OPT_STRING(tls_cert_file), .flags = M_OPT_FILE},
+        {"tls-key-file", OPT_STRING(tls_key_file), .flags = M_OPT_FILE},
+        {"network-timeout", OPT_DOUBLE(timeout), M_RANGE(0, DBL_MAX)},
+        {"http-proxy", OPT_STRING(http_proxy)},
+        {0}
+    },
+    .size = sizeof(struct stream_lavf_params),
+    .defaults = &(const struct stream_lavf_params){
+        .useragent = "libmpv",
+        .timeout = 60,
+    },
+};
+
+static const char *const http_like[] =
+    {"http", "https", "mmsh", "mmshttp", "httproxy", NULL};
+
+static int open_f(stream_t *stream);
+static struct mp_tags *read_icy(stream_t *stream);
+
+static int fill_buffer(stream_t *s, void *buffer, int max_len)
+{
+    AVIOContext *avio = s->priv;
+    int r = avio_read_partial(avio, buffer, max_len);
+    return (r <= 0) ? -1 : r;
+}
+
+static int write_buffer(stream_t *s, void *buffer, int len)
+{
+    AVIOContext *avio = s->priv;
+    avio_write(avio, buffer, len);
+    avio_flush(avio);
+    if (avio->error)
+        return -1;
+    return len;
+}
+
+static int seek(stream_t *s, int64_t newpos)
+{
+    AVIOContext *avio = s->priv;
+    if (avio_seek(avio, newpos, SEEK_SET) < 0) {
+        return 0;
+    }
+    return 1;
+}
+
+static int64_t get_size(stream_t *s)
+{
+    AVIOContext *avio = s->priv;
+    return avio_size(avio);
+}
+
+static void close_f(stream_t *stream)
+{
+    AVIOContext *avio = stream->priv;
+    /* NOTE: As of 2011 write streams must be manually flushed before close.
+     * Currently write_buffer() always flushes them after writing.
+     * avio_close() could return an error, but we have no way to return that
+     * with the current stream API.
+     */
+    if (avio)
+        avio_close(avio);
+}
+
+static int control(stream_t *s, int cmd, void *arg)
+{
+    AVIOContext *avio = s->priv;
+    switch(cmd) {
+    case STREAM_CTRL_AVSEEK: {
+        struct stream_avseek *c = arg;
+        int64_t r = avio_seek_time(avio, c->stream_index, c->timestamp, c->flags);
+        if (r >= 0) {
+            stream_drop_buffers(s);
+            return 1;
+        }
+        break;
+    }
+    case STREAM_CTRL_HAS_AVSEEK: {
+        // Starting at some point, read_seek is always available, and runtime
+        // behavior decides whether it exists or not. FFmpeg's API doesn't
+        // return anything helpful to determine seekability upfront, so here's
+        // a hardcoded whitelist. Not our fault.
+        // In addition we also have to jump through ridiculous hoops just to
+        // get the fucking protocol name.
+        const char *proto = NULL;
+        if (avio->av_class && avio->av_class->child_next) {
+            // This usually yields the URLContext (why does it even exist?),
+            // which holds the name of the actual protocol implementation.
+            void *child = avio->av_class->child_next(avio, NULL);
+            AVClass *cl = *(AVClass **)child;
+            if (cl && cl->item_name)
+                proto = cl->item_name(child);
+        }
+        static const char *const has_read_seek[] = {
+            "rtmp", "rtmpt", "rtmpe", "rtmpte", "rtmps", "rtmpts", "mmsh", 0};
+        for (int n = 0; has_read_seek[n]; n++) {
+            if (avio->read_seek && proto && strcmp(proto, has_read_seek[n]) == 0)
+                return 1;
+        }
+        break;
+    }
+    case STREAM_CTRL_GET_METADATA: {
+        *(struct mp_tags **)arg = read_icy(s);
+        if (!*(struct mp_tags **)arg)
+            break;
+        return 1;
+    }
+    }
+    return STREAM_UNSUPPORTED;
+}
+
+static int interrupt_cb(void *ctx)
+{
+    struct stream *stream = ctx;
+    return mp_cancel_test(stream->cancel);
+}
+
+static const char * const prefix[] = { "lavf://", "ffmpeg://" };
+
+void mp_setup_av_network_options(AVDictionary **dict, const char *target_fmt,
+                                 struct mpv_global *global, struct mp_log *log)
+{
+    void *temp = talloc_new(NULL);
+    struct stream_lavf_params *opts =
+        mp_get_config_group(temp, global, &stream_lavf_conf);
+
+    // HTTP specific options (other protocols ignore them)
+    if (opts->useragent)
+        av_dict_set(dict, "user_agent", opts->useragent, 0);
+    if (opts->cookies_enabled) {
+        char *file = opts->cookies_file;
+        if (file && file[0])
+            file = mp_get_user_path(temp, global, file);
+        char *cookies = cookies_lavf(temp, global, log, file);
+        if (cookies && cookies[0])
+            av_dict_set(dict, "cookies", cookies, 0);
+    }
+    av_dict_set(dict, "tls_verify", opts->tls_verify ? "1" : "0", 0);
+    if (opts->tls_ca_file)
+        av_dict_set(dict, "ca_file", opts->tls_ca_file, 0);
+    if (opts->tls_cert_file)
+        av_dict_set(dict, "cert_file", opts->tls_cert_file, 0);
+    if (opts->tls_key_file)
+        av_dict_set(dict, "key_file", opts->tls_key_file, 0);
+    char *cust_headers = talloc_strdup(temp, "");
+    if (opts->referrer) {
+        cust_headers = talloc_asprintf_append(cust_headers, "Referer: %s\r\n",
+                                              opts->referrer);
+    }
+    if (opts->http_header_fields) {
+        for (int n = 0; opts->http_header_fields[n]; n++) {
+            cust_headers = talloc_asprintf_append(cust_headers, "%s\r\n",
+                                                  opts->http_header_fields[n]);
+        }
+    }
+    if (strlen(cust_headers))
+        av_dict_set(dict, "headers", cust_headers, 0);
+    av_dict_set(dict, "icy", "1", 0);
+    // So far, every known protocol uses microseconds for this
+    // Except rtsp.
+    if (opts->timeout > 0) {
+        if (target_fmt && strcmp(target_fmt, "rtsp") == 0) {
+            mp_verbose(log, "Broken FFmpeg RTSP API => not setting timeout.\n");
+        } else {
+            char buf[80];
+            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);
+
+    talloc_free(temp);
+}
+
+// Escape http URLs with unescaped, invalid characters in them.
+// libavformat's http protocol does not do this, and a patch to add this
+// in a 100% safe case (spaces only) was rejected.
+static char *normalize_url(void *ta_parent, const char *filename)
+{
+    bstr proto = mp_split_proto(bstr0(filename), NULL);
+    for (int n = 0; http_like[n]; n++) {
+        if (bstr_equals0(proto, http_like[n]))
+            // Escape everything but reserved characters.
+            // Also don't double-scape, so include '%'.
+            return mp_url_escape(ta_parent, filename, ":/?#[]@!$&'()*+,;=%");
+    }
+    return (char *)filename;
+}
+
+static int open_f(stream_t *stream)
+{
+    AVIOContext *avio = NULL;
+    int res = STREAM_ERROR;
+    AVDictionary *dict = NULL;
+    void *temp = talloc_new(NULL);
+
+    stream->seek = NULL;
+    stream->seekable = false;
+
+    int flags = stream->mode == STREAM_WRITE ? AVIO_FLAG_WRITE : AVIO_FLAG_READ;
+
+    const char *filename = stream->url;
+    if (!filename) {
+        MP_ERR(stream, "No URL\n");
+        goto out;
+    }
+    for (int i = 0; i < sizeof(prefix) / sizeof(prefix[0]); i++)
+        if (!strncmp(filename, prefix[i], strlen(prefix[i])))
+            filename += strlen(prefix[i]);
+    if (!strncmp(filename, "rtsp:", 5) || !strncmp(filename, "rtsps:", 6)) {
+        /* This is handled as a special demuxer, without a separate
+         * stream layer. demux_lavf will do all the real work. Note
+         * that libavformat doesn't even provide a protocol entry for
+         * this (the rtsp demuxer's probe function checks for a "rtsp:"
+         * filename prefix), so it has to be handled specially here.
+         */
+        stream->demuxer = "lavf";
+        stream->lavf_type = "rtsp";
+        talloc_free(temp);
+        return STREAM_OK;
+    }
+
+    // Replace "mms://" with "mmsh://", so that most mms:// URLs just work.
+    // Replace "dav://" or "webdav://" with "http://" and "davs://" or "webdavs://" with "https://"
+    bstr b_filename = bstr0(filename);
+    if (bstr_eatstart0(&b_filename, "mms://") ||
+        bstr_eatstart0(&b_filename, "mmshttp://"))
+    {
+        filename = talloc_asprintf(temp, "mmsh://%.*s", BSTR_P(b_filename));
+    } else if (bstr_eatstart0(&b_filename, "dav://") || bstr_eatstart0(&b_filename, "webdav://"))
+    {
+        filename = talloc_asprintf(temp, "http://%.*s", BSTR_P(b_filename));
+    } else if (bstr_eatstart0(&b_filename, "davs://") || bstr_eatstart0(&b_filename, "webdavs://"))
+    {
+        filename = talloc_asprintf(temp, "https://%.*s", BSTR_P(b_filename));
+    }
+
+    av_dict_set(&dict, "reconnect", "1", 0);
+    av_dict_set(&dict, "reconnect_delay_max", "7", 0);
+
+    mp_setup_av_network_options(&dict, NULL, stream->global, stream->log);
+
+    AVIOInterruptCB cb = {
+        .callback = interrupt_cb,
+        .opaque = stream,
+    };
+
+    filename = normalize_url(stream, filename);
+
+    if (strncmp(filename, "rtmp", 4) == 0) {
+        stream->demuxer = "lavf";
+        stream->lavf_type = "flv";
+        // Setting timeout enables listen mode - force it to disabled.
+        av_dict_set(&dict, "timeout", "0", 0);
+    }
+
+    int err = avio_open2(&avio, filename, flags, &cb, &dict);
+    if (err < 0) {
+        if (err == AVERROR_PROTOCOL_NOT_FOUND)
+            MP_ERR(stream, "Protocol not found. Make sure"
+                   " ffmpeg/Libav is compiled with networking support.\n");
+        goto out;
+    }
+
+    mp_avdict_print_unset(stream->log, MSGL_V, dict);
+
+    if (avio->av_class) {
+        uint8_t *mt = NULL;
+        if (av_opt_get(avio, "mime_type", AV_OPT_SEARCH_CHILDREN, &mt) >= 0) {
+            stream->mime_type = talloc_strdup(stream, mt);
+            av_free(mt);
+        }
+    }
+
+    stream->priv = avio;
+    stream->seekable = avio->seekable & AVIO_SEEKABLE_NORMAL;
+    stream->seek = stream->seekable ? seek : NULL;
+    stream->fill_buffer = fill_buffer;
+    stream->write_buffer = write_buffer;
+    stream->get_size = get_size;
+    stream->control = control;
+    stream->close = close_f;
+    // enable cache (should be avoided for files, but no way to detect this)
+    stream->streaming = true;
+    if (stream->info->stream_origin == STREAM_ORIGIN_NET)
+        stream->is_network = true;
+    res = STREAM_OK;
+
+out:
+    av_dict_free(&dict);
+    talloc_free(temp);
+    return res;
+}
+
+static struct mp_tags *read_icy(stream_t *s)
+{
+    AVIOContext *avio = s->priv;
+
+    if (!avio->av_class)
+        return NULL;
+
+    uint8_t *icy_header = NULL;
+    if (av_opt_get(avio, "icy_metadata_headers", AV_OPT_SEARCH_CHILDREN,
+                   &icy_header) < 0)
+        icy_header = NULL;
+
+    uint8_t *icy_packet;
+    if (av_opt_get(avio, "icy_metadata_packet", AV_OPT_SEARCH_CHILDREN,
+                   &icy_packet) < 0)
+        icy_packet = NULL;
+
+    // Send a metadata update only 1. on start, and 2. on a new metadata packet.
+    // To detect new packages, set the icy_metadata_packet to "-" once we've
+    // read it (a bit hacky, but works).
+
+    struct mp_tags *res = NULL;
+    if ((!icy_header || !icy_header[0]) && (!icy_packet || !icy_packet[0]))
+        goto done;
+
+    bstr packet = bstr0(icy_packet);
+    if (bstr_equals0(packet, "-"))
+        goto done;
+
+    res = talloc_zero(NULL, struct mp_tags);
+
+    bstr header = bstr0(icy_header);
+    while (header.len) {
+        bstr line = bstr_strip_linebreaks(bstr_getline(header, &header));
+        bstr name, val;
+        if (bstr_split_tok(line, ": ", &name, &val))
+            mp_tags_set_bstr(res, name, val);
+    }
+
+    bstr head = bstr0("StreamTitle='");
+    int i = bstr_find(packet, head);
+    if (i >= 0) {
+        packet = bstr_cut(packet, i + head.len);
+        int end = bstr_find(packet, bstr0("\';"));
+        packet = bstr_splice(packet, 0, end);
+
+        bool allocated = false;
+        struct demux_opts *opts = mp_get_config_group(NULL, s->global, &demux_conf);
+        const char *charset = mp_charset_guess(s, s->log, packet, opts->meta_cp, 0);
+        if (charset && !mp_charset_is_utf8(charset)) {
+            bstr conv = mp_iconv_to_utf8(s->log, packet, charset, 0);
+            if (conv.start && conv.start != packet.start) {
+                allocated = true;
+                packet = conv;
+            }
+        }
+        mp_tags_set_bstr(res, bstr0("icy-title"), packet);
+        talloc_free(opts);
+        if (allocated)
+            talloc_free(packet.start);
+    }
+
+    av_opt_set(avio, "icy_metadata_packet", "-", AV_OPT_SEARCH_CHILDREN);
+
+done:
+    av_free(icy_header);
+    av_free(icy_packet);
+    return res;
+}
+
+const stream_info_t stream_info_ffmpeg = {
+  .name = "ffmpeg",
+  .open = open_f,
+  .protocols = (const char *const[]){
+     "rtmp", "rtsp", "rtsps", "http", "https", "mms", "mmst", "mmsh", "mmshttp",
+     "rtp", "httpproxy", "rtmpe", "rtmps", "rtmpt", "rtmpte", "rtmpts", "srt",
+     "rist", "srtp", "gopher", "gophers", "data", "ipfs", "ipns", "dav",
+     "davs", "webdav", "webdavs",
+     NULL },
+  .can_write = true,
+  .stream_origin = STREAM_ORIGIN_NET,
+};
+
+// Unlike above, this is not marked as safe, and can contain protocols which
+// may do insecure things. (Such as "ffmpeg", which can access the "lavfi"
+// pseudo-demuxer, which in turn gives access to filters that can access the
+// local filesystem.)
+const stream_info_t stream_info_ffmpeg_unsafe = {
+  .name = "ffmpeg",
+  .open = open_f,
+  .protocols = (const char *const[]){
+     "lavf", "ffmpeg", "udp", "ftp", "tcp", "tls", "unix", "sftp", "md5",
+     "concat", "smb",
+     NULL },
+  .stream_origin = STREAM_ORIGIN_UNSAFE,
+  .can_write = true,
+};
diff --git a/stream/stream_libarchive.c b/stream/stream_libarchive.c
new file mode 100644
index 0000000..ff2d512
--- /dev/null
+++ b/stream/stream_libarchive.c
@@ -0,0 +1,623 @@
+/*
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include <archive.h>
+#include <archive_entry.h>
+
+#include "misc/bstr.h"
+#include "common/common.h"
+#include "misc/thread_tools.h"
+#include "stream.h"
+
+#include "stream_libarchive.h"
+
+#define MP_ARCHIVE_FLAG_MAYBE_ZIP       (MP_ARCHIVE_FLAG_PRIV << 0)
+#define MP_ARCHIVE_FLAG_MAYBE_RAR       (MP_ARCHIVE_FLAG_PRIV << 1)
+#define MP_ARCHIVE_FLAG_MAYBE_VOLUMES   (MP_ARCHIVE_FLAG_PRIV << 2)
+
+struct mp_archive_volume {
+    struct mp_archive *mpa;
+    int index; // volume number (starting with 0, mp_archive.primary_src)
+    struct stream *src; // NULL => not current volume, or 0 sized dummy stream
+    int64_t seek_to;
+    char *url;
+};
+
+static bool probe_rar(struct stream *s)
+{
+    static uint8_t rar_sig[] = {0x52, 0x61, 0x72, 0x21, 0x1a, 0x07};
+    uint8_t buf[6];
+    if (stream_read_peek(s, buf, sizeof(buf)) != sizeof(buf))
+        return false;
+    return memcmp(buf, rar_sig, 6) == 0;
+}
+
+static bool probe_multi_rar(struct stream *s)
+{
+    uint8_t hdr[14];
+    if (stream_read_peek(s, hdr, sizeof(hdr)) == sizeof(hdr)) {
+        // Look for rar mark head & main head (assume they're in order).
+        if (hdr[6] == 0x00 && hdr[7 + 2] == 0x73) {
+            int rflags = hdr[7 + 3] | (hdr[7 + 4] << 8);
+            return rflags & 0x100;
+        }
+    }
+    return false;
+}
+
+static bool probe_zip(struct stream *s)
+{
+    uint8_t p[4];
+    if (stream_read_peek(s, p, sizeof(p)) != sizeof(p))
+        return false;
+    // Lifted from libarchive, BSD license.
+    if (p[0] == 'P' && p[1] == 'K') {
+        if ((p[2] == '\001' && p[3] == '\002') ||
+            (p[2] == '\003' && p[3] == '\004') ||
+            (p[2] == '\005' && p[3] == '\006') ||
+            (p[2] == '\006' && p[3] == '\006') ||
+            (p[2] == '\007' && p[3] == '\010') ||
+            (p[2] == '0' && p[3] == '0'))
+            return true;
+    }
+    return false;
+}
+
+static int mp_archive_probe(struct stream *src)
+{
+    int flags = 0;
+    assert(stream_tell(src) == 0);
+    if (probe_zip(src))
+        flags |= MP_ARCHIVE_FLAG_MAYBE_ZIP;
+
+    if (probe_rar(src)) {
+        flags |= MP_ARCHIVE_FLAG_MAYBE_RAR;
+        if (probe_multi_rar(src))
+            flags |= MP_ARCHIVE_FLAG_MAYBE_VOLUMES;
+    }
+    return flags;
+}
+
+static bool volume_seek(struct mp_archive_volume *vol)
+{
+    if (!vol->src || vol->seek_to < 0)
+        return true;
+    bool r = stream_seek(vol->src, vol->seek_to);
+    vol->seek_to = -1;
+    return r;
+}
+
+static ssize_t read_cb(struct archive *arch, void *priv, const void **buffer)
+{
+    struct mp_archive_volume *vol = priv;
+    if (!vol->src)
+        return 0;
+    if (!volume_seek(vol))
+        return -1;
+    int res = stream_read_partial(vol->src, vol->mpa->buffer,
+                                  sizeof(vol->mpa->buffer));
+    *buffer = vol->mpa->buffer;
+    return MPMAX(res, 0);
+}
+
+// lazy seek to avoid problems with end seeking over http
+static int64_t seek_cb(struct archive *arch, void *priv,
+                       int64_t offset, int whence)
+{
+    struct mp_archive_volume *vol = priv;
+    if (!vol->src)
+        return 0;
+    switch (whence) {
+    case SEEK_SET:
+        vol->seek_to = offset;
+        break;
+    case SEEK_CUR:
+        if (vol->seek_to < 0)
+            vol->seek_to = stream_tell(vol->src);
+        vol->seek_to += offset;
+        break;
+    case SEEK_END: ;
+        int64_t size = stream_get_size(vol->src);
+        if (size < 0)
+            return -1;
+        vol->seek_to = size + offset;
+        break;
+    default:
+        return -1;
+    }
+    return vol->seek_to;
+}
+
+static int64_t skip_cb(struct archive *arch, void *priv, int64_t request)
+{
+    struct mp_archive_volume *vol = priv;
+    if (!vol->src)
+        return request;
+    if (!volume_seek(vol))
+        return -1;
+    int64_t old = stream_tell(vol->src);
+    stream_seek_skip(vol->src, old + request);
+    return stream_tell(vol->src) - old;
+}
+
+static int open_cb(struct archive *arch, void *priv)
+{
+    struct mp_archive_volume *vol = priv;
+    vol->seek_to = -1;
+    if (!vol->src) {
+        // Avoid annoying warnings/latency for known dummy volumes.
+        if (vol->index >= vol->mpa->num_volumes)
+            return ARCHIVE_OK;
+        MP_INFO(vol->mpa, "Opening volume '%s'...\n", vol->url);
+        vol->src = stream_create(vol->url,
+                                 STREAM_READ |
+                                    vol->mpa->primary_src->stream_origin,
+                                 vol->mpa->primary_src->cancel,
+                                 vol->mpa->primary_src->global);
+        // We pretend that failure to open a stream means it was not found,
+        // we assume in turn means that the volume doesn't exist (since
+        // libarchive builds volumes as some sort of abstraction on top of its
+        // stream layer, and its rar code cannot access volumes or signal
+        // anything related to this). libarchive also encounters a fatal error
+        // when a volume could not be opened. However, due to the way volume
+        // support works, it is fine with 0-sized volumes, which we simulate
+        // whenever vol->src==NULL for an opened volume.
+        if (!vol->src) {
+            vol->mpa->num_volumes = MPMIN(vol->mpa->num_volumes, vol->index);
+            MP_INFO(vol->mpa, "Assuming the volume above was not needed.\n");
+        }
+        return ARCHIVE_OK;
+    }
+
+    // just rewind the primary stream
+    return stream_seek(vol->src, 0) ? ARCHIVE_OK : ARCHIVE_FATAL;
+}
+
+static void volume_close(struct mp_archive_volume *vol)
+{
+    // don't close the primary stream
+    if (vol->src && vol->src != vol->mpa->primary_src) {
+        free_stream(vol->src);
+        vol->src = NULL;
+    }
+}
+
+static int close_cb(struct archive *arch, void *priv)
+{
+    struct mp_archive_volume *vol = priv;
+    volume_close(vol);
+    return ARCHIVE_OK;
+}
+
+static void mp_archive_close(struct mp_archive *mpa)
+{
+    if (mpa && mpa->arch) {
+        archive_read_close(mpa->arch);
+        archive_read_free(mpa->arch);
+        mpa->arch = NULL;
+    }
+}
+
+// Supposedly we're not allowed to continue reading on FATAL returns. Otherwise
+// crashes and other UB is possible. Assume calling the close/free functions is
+// still ok. Return true if it was fatal and the archive was closed.
+static bool mp_archive_check_fatal(struct mp_archive *mpa, int r)
+{
+    if (r > ARCHIVE_FATAL)
+        return false;
+    MP_FATAL(mpa, "fatal error received - closing archive\n");
+    mp_archive_close(mpa);
+    return true;
+}
+
+void mp_archive_free(struct mp_archive *mpa)
+{
+    mp_archive_close(mpa);
+    if (mpa && mpa->locale)
+        freelocale(mpa->locale);
+    talloc_free(mpa);
+}
+
+static bool add_volume(struct mp_archive *mpa, struct stream *src,
+                       const char* url, int index)
+{
+    struct mp_archive_volume *vol = talloc_zero(mpa, struct mp_archive_volume);
+    vol->index = index;
+    vol->mpa = mpa;
+    vol->src = src;
+    vol->url = talloc_strdup(vol, url);
+    locale_t oldlocale = uselocale(mpa->locale);
+    bool res = archive_read_append_callback_data(mpa->arch, vol) == ARCHIVE_OK;
+    uselocale(oldlocale);
+    return res;
+}
+
+static char *standard_volume_url(void *ctx, const char *format,
+                                 struct bstr base, int index)
+{
+    return talloc_asprintf(ctx, format, BSTR_P(base), index);
+}
+
+static char *old_rar_volume_url(void *ctx, const char *format,
+                                struct bstr base, int index)
+{
+    return talloc_asprintf(ctx, format, BSTR_P(base),
+                           'r' + index / 100, index % 100);
+}
+
+struct file_pattern {
+    const char *match;
+    const char *format;
+    char *(*volume_url)(void *ctx, const char *format,
+                        struct bstr base, int index);
+    int start;
+    int stop;
+    bool legacy;
+};
+
+static const struct file_pattern patterns[] = {
+    { ".part1.rar",    "%.*s.part%.1d.rar", standard_volume_url, 2,    9 },
+    { ".part01.rar",   "%.*s.part%.2d.rar", standard_volume_url, 2,   99 },
+    { ".part001.rar",  "%.*s.part%.3d.rar", standard_volume_url, 2,  999 },
+    { ".part0001.rar", "%.*s.part%.4d.rar", standard_volume_url, 2, 9999 },
+    { ".rar",          "%.*s.%c%.2d",       old_rar_volume_url,  0,   99, true },
+    { ".001",          "%.*s.%.3d",         standard_volume_url, 2, 9999 },
+    { NULL, NULL, NULL, 0, 0 },
+};
+
+static bool find_volumes(struct mp_archive *mpa, int flags)
+{
+    struct bstr primary_url = bstr0(mpa->primary_src->url);
+
+    const struct file_pattern *pattern = patterns;
+    while (pattern->match) {
+        if (bstr_endswith0(primary_url, pattern->match))
+            break;
+        pattern++;
+    }
+
+    if (!pattern->match)
+        return true;
+    if (pattern->legacy && !(flags & MP_ARCHIVE_FLAG_MAYBE_VOLUMES))
+        return true;
+
+    struct bstr base = bstr_splice(primary_url, 0, -(int)strlen(pattern->match));
+    for (int i = pattern->start; i <= pattern->stop; i++) {
+        char* url = pattern->volume_url(mpa, pattern->format, base, i);
+
+        if (!add_volume(mpa, NULL, url, i + 1))
+            return false;
+    }
+
+    MP_WARN(mpa, "This appears to be a multi-volume archive.\n"
+            "Support is not very good due to libarchive limitations.\n"
+            "There are known cases of libarchive crashing mpv on these.\n"
+            "This is also an excessively inefficient and stupid way to distribute\n"
+            "media files. People creating them should rethink this.\n");
+
+    return true;
+}
+
+static struct mp_archive *mp_archive_new_raw(struct mp_log *log,
+                                             struct stream *src,
+                                             int flags, int max_volumes)
+{
+    struct mp_archive *mpa = talloc_zero(NULL, struct mp_archive);
+    mpa->log = log;
+    mpa->locale = newlocale(LC_CTYPE_MASK, "C.UTF-8", (locale_t)0);
+    if (!mpa->locale) {
+        mpa->locale = newlocale(LC_CTYPE_MASK, "", (locale_t)0);
+        if (!mpa->locale)
+            goto err;
+    }
+    mpa->arch = archive_read_new();
+    mpa->primary_src = src;
+    if (!mpa->arch)
+        goto err;
+
+    mpa->flags = flags;
+    mpa->num_volumes = max_volumes ? max_volumes : INT_MAX;
+
+    // first volume is the primary stream
+    if (!add_volume(mpa, src, src->url, 0))
+        goto err;
+
+    if (!(flags & MP_ARCHIVE_FLAG_NO_VOLUMES)) {
+        // try to open other volumes
+        if (!find_volumes(mpa, flags))
+            goto err;
+    }
+
+    locale_t oldlocale = uselocale(mpa->locale);
+
+    archive_read_support_format_rar(mpa->arch);
+    archive_read_support_format_rar5(mpa->arch);
+
+    // Exclude other formats if it's probably RAR, because other formats may
+    // behave suboptimal with multiple volumes exposed, such as opening every
+    // single volume by seeking at the end of the file.
+    if (!(flags & MP_ARCHIVE_FLAG_MAYBE_RAR)) {
+        archive_read_support_format_7zip(mpa->arch);
+        archive_read_support_format_iso9660(mpa->arch);
+        archive_read_support_filter_bzip2(mpa->arch);
+        archive_read_support_filter_gzip(mpa->arch);
+        archive_read_support_filter_xz(mpa->arch);
+        archive_read_support_format_zip_streamable(mpa->arch);
+
+        // This zip reader is normally preferable. However, it seeks to the end
+        // of the file, which may be annoying (HTTP reconnect, volume skipping),
+        // so use it only as last resort, or if it's relatively likely that it's
+        // really zip.
+        if (flags & (MP_ARCHIVE_FLAG_UNSAFE | MP_ARCHIVE_FLAG_MAYBE_ZIP))
+            archive_read_support_format_zip_seekable(mpa->arch);
+    }
+
+    archive_read_set_read_callback(mpa->arch, read_cb);
+    archive_read_set_skip_callback(mpa->arch, skip_cb);
+    archive_read_set_open_callback(mpa->arch, open_cb);
+    // Allow it to close a volume.
+    archive_read_set_close_callback(mpa->arch, close_cb);
+    if (mpa->primary_src->seekable)
+        archive_read_set_seek_callback(mpa->arch, seek_cb);
+    bool fail = archive_read_open1(mpa->arch) < ARCHIVE_OK;
+
+    uselocale(oldlocale);
+
+    if (fail)
+        goto err;
+
+    return mpa;
+
+err:
+    mp_archive_free(mpa);
+    return NULL;
+}
+
+struct mp_archive *mp_archive_new(struct mp_log *log, struct stream *src,
+                                  int flags, int max_volumes)
+{
+    flags |= mp_archive_probe(src);
+    return mp_archive_new_raw(log, src, flags, max_volumes);
+}
+
+// Iterate entries. The first call establishes the first entry. Returns false
+// if no entry found, otherwise returns true and sets mpa->entry/entry_filename.
+bool mp_archive_next_entry(struct mp_archive *mpa)
+{
+    mpa->entry = NULL;
+    talloc_free(mpa->entry_filename);
+    mpa->entry_filename = NULL;
+
+    if (!mpa->arch)
+        return false;
+
+    locale_t oldlocale = uselocale(mpa->locale);
+    bool success = false;
+
+    while (!mp_cancel_test(mpa->primary_src->cancel)) {
+        struct archive_entry *entry;
+        int r = archive_read_next_header(mpa->arch, &entry);
+        if (r == ARCHIVE_EOF)
+            break;
+        if (r < ARCHIVE_OK)
+            MP_ERR(mpa, "%s\n", archive_error_string(mpa->arch));
+        if (r < ARCHIVE_WARN) {
+            MP_FATAL(mpa, "could not read archive entry\n");
+            mp_archive_check_fatal(mpa, r);
+            break;
+        }
+        if (archive_entry_filetype(entry) != AE_IFREG)
+            continue;
+        // Some archives may have no filenames, or libarchive won't return some.
+        const char *fn = archive_entry_pathname(entry);
+        char buf[64];
+        if (!fn || bstr_validate_utf8(bstr0(fn)) < 0) {
+            snprintf(buf, sizeof(buf), "mpv_unknown#%d", mpa->entry_num);
+            fn = buf;
+        }
+        mpa->entry = entry;
+        mpa->entry_filename = talloc_strdup(mpa, fn);
+        mpa->entry_num += 1;
+        success = true;
+        break;
+    }
+
+    uselocale(oldlocale);
+
+    return success;
+}
+
+struct priv {
+    struct mp_archive *mpa;
+    bool broken_seek;
+    struct stream *src;
+    int64_t entry_size;
+    char *entry_name;
+};
+
+static int reopen_archive(stream_t *s)
+{
+    struct priv *p = s->priv;
+    s->pos = 0;
+    if (!p->mpa) {
+        p->mpa = mp_archive_new(s->log, p->src, MP_ARCHIVE_FLAG_UNSAFE, 0);
+    } else {
+        int flags = p->mpa->flags;
+        int num_volumes = p->mpa->num_volumes;
+        mp_archive_free(p->mpa);
+        p->mpa = mp_archive_new_raw(s->log, p->src, flags, num_volumes);
+    }
+
+    if (!p->mpa)
+        return STREAM_ERROR;
+
+    // Follows the same logic as demux_libarchive.c.
+    struct mp_archive *mpa = p->mpa;
+    while (mp_archive_next_entry(mpa)) {
+        if (strcmp(p->entry_name, mpa->entry_filename) == 0) {
+            locale_t oldlocale = uselocale(mpa->locale);
+            p->entry_size = -1;
+            if (archive_entry_size_is_set(mpa->entry))
+                p->entry_size = archive_entry_size(mpa->entry);
+            uselocale(oldlocale);
+            return STREAM_OK;
+        }
+    }
+
+    mp_archive_free(p->mpa);
+    p->mpa = NULL;
+    MP_ERR(s, "archive entry not found. '%s'\n", p->entry_name);
+    return STREAM_ERROR;
+}
+
+static int archive_entry_fill_buffer(stream_t *s, void *buffer, int max_len)
+{
+    struct priv *p = s->priv;
+    if (!p->mpa)
+        return 0;
+    locale_t oldlocale = uselocale(p->mpa->locale);
+    int r = archive_read_data(p->mpa->arch, buffer, max_len);
+    if (r < 0) {
+        MP_ERR(s, "%s\n", archive_error_string(p->mpa->arch));
+        if (mp_archive_check_fatal(p->mpa, r)) {
+            mp_archive_free(p->mpa);
+            p->mpa = NULL;
+        }
+    }
+    uselocale(oldlocale);
+    return r;
+}
+
+static int archive_entry_seek(stream_t *s, int64_t newpos)
+{
+    struct priv *p = s->priv;
+    if (p->mpa && !p->broken_seek) {
+        locale_t oldlocale = uselocale(p->mpa->locale);
+        int r = archive_seek_data(p->mpa->arch, newpos, SEEK_SET);
+        uselocale(oldlocale);
+        if (r >= 0)
+            return 1;
+        MP_WARN(s, "possibly unsupported seeking - switching to reopening\n");
+        p->broken_seek = true;
+        if (reopen_archive(s) < STREAM_OK)
+            return -1;
+    }
+    // libarchive can't seek in most formats.
+    if (newpos < s->pos) {
+        // Hack seeking backwards into working by reopening the archive and
+        // starting over.
+        MP_VERBOSE(s, "trying to reopen archive for performing seek\n");
+        if (reopen_archive(s) < STREAM_OK)
+            return -1;
+    }
+    if (newpos > s->pos) {
+        if (!p->mpa && reopen_archive(s) < STREAM_OK)
+            return -1;
+        // For seeking forwards, just keep reading data (there's no libarchive
+        // skip function either).
+        char buffer[4096];
+        while (newpos > s->pos) {
+            if (mp_cancel_test(s->cancel))
+                return -1;
+
+            int size = MPMIN(newpos - s->pos, sizeof(buffer));
+            locale_t oldlocale = uselocale(p->mpa->locale);
+            int r = archive_read_data(p->mpa->arch, buffer, size);
+            if (r <= 0) {
+                if (r == 0 && newpos > p->entry_size) {
+                    MP_ERR(s, "demuxer trying to seek beyond end of archive "
+                           "entry\n");
+                } else if (r == 0) {
+                    MP_ERR(s, "end of archive entry reached while seeking\n");
+                } else {
+                    MP_ERR(s, "%s\n", archive_error_string(p->mpa->arch));
+                }
+                uselocale(oldlocale);
+                if (mp_archive_check_fatal(p->mpa, r)) {
+                    mp_archive_free(p->mpa);
+                    p->mpa = NULL;
+                }
+                return -1;
+            }
+            uselocale(oldlocale);
+            s->pos += r;
+        }
+    }
+    return 1;
+}
+
+static void archive_entry_close(stream_t *s)
+{
+    struct priv *p = s->priv;
+    mp_archive_free(p->mpa);
+    free_stream(p->src);
+}
+
+static int64_t archive_entry_get_size(stream_t *s)
+{
+    struct priv *p = s->priv;
+    return p->entry_size;
+}
+
+static int archive_entry_open(stream_t *stream)
+{
+    struct priv *p = talloc_zero(stream, struct priv);
+    stream->priv = p;
+
+    if (!strchr(stream->path, '|'))
+        return STREAM_ERROR;
+
+    char *base = talloc_strdup(p, stream->path);
+    char *name = strchr(base, '|');
+    if (!name)
+        return STREAM_ERROR;
+    *name++ = '\0';
+    if (name[0] == '/')
+        name += 1;
+    p->entry_name = name;
+    mp_url_unescape_inplace(base);
+
+    p->src = stream_create(base, STREAM_READ | stream->stream_origin,
+                           stream->cancel, stream->global);
+    if (!p->src) {
+        archive_entry_close(stream);
+        return STREAM_ERROR;
+    }
+
+    int r = reopen_archive(stream);
+    if (r < STREAM_OK) {
+        archive_entry_close(stream);
+        return r;
+    }
+
+    stream->fill_buffer = archive_entry_fill_buffer;
+    if (p->src->seekable) {
+        stream->seek = archive_entry_seek;
+        stream->seekable = true;
+    }
+    stream->close = archive_entry_close;
+    stream->get_size = archive_entry_get_size;
+    stream->streaming = true;
+
+    return STREAM_OK;
+}
+
+const stream_info_t stream_info_libarchive = {
+    .name = "libarchive",
+    .open = archive_entry_open,
+    .protocols = (const char*const[]){ "archive", NULL },
+};
diff --git a/stream/stream_libarchive.h b/stream/stream_libarchive.h
new file mode 100644
index 0000000..151e4ee
--- /dev/null
+++ b/stream/stream_libarchive.h
@@ -0,0 +1,35 @@
+#include <locale.h>
+#include "osdep/io.h"
+
+#ifdef __APPLE__
+# include <string.h>
+# include <xlocale.h>
+#endif
+
+struct mp_log;
+
+struct mp_archive {
+    locale_t locale;
+    struct mp_log *log;
+    struct archive *arch;
+    struct stream *primary_src;
+    char buffer[4096];
+    int flags;
+    int num_volumes; // INT_MAX if unknown (initial state)
+
+    // Current entry, as set by mp_archive_next_entry().
+    struct archive_entry *entry;
+    char *entry_filename;
+    int entry_num;
+};
+
+void mp_archive_free(struct mp_archive *mpa);
+
+#define MP_ARCHIVE_FLAG_UNSAFE          (1 << 0)
+#define MP_ARCHIVE_FLAG_NO_VOLUMES      (1 << 1)
+#define MP_ARCHIVE_FLAG_PRIV            (1 << 2)
+
+struct mp_archive *mp_archive_new(struct mp_log *log, struct stream *src,
+                                  int flags, int max_volumes);
+
+bool mp_archive_next_entry(struct mp_archive *mpa);
diff --git a/stream/stream_memory.c b/stream/stream_memory.c
new file mode 100644
index 0000000..e4696a7
--- /dev/null
+++ b/stream/stream_memory.c
@@ -0,0 +1,100 @@
+/*
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include "common/common.h"
+#include "stream.h"
+
+struct priv {
+    bstr data;
+};
+
+static int fill_buffer(stream_t *s, void *buffer, int len)
+{
+    struct priv *p = s->priv;
+    bstr data = p->data;
+    if (s->pos < 0 || s->pos > data.len)
+        return 0;
+    len = MPMIN(len, data.len - s->pos);
+    memcpy(buffer, data.start + s->pos, len);
+    return len;
+}
+
+static int seek(stream_t *s, int64_t newpos)
+{
+    return 1;
+}
+
+static int64_t get_size(stream_t *s)
+{
+    struct priv *p = s->priv;
+    return p->data.len;
+}
+
+static int open2(stream_t *stream, const struct stream_open_args *args)
+{
+    stream->fill_buffer = fill_buffer;
+    stream->seek = seek;
+    stream->seekable = true;
+    stream->get_size = get_size;
+
+    struct priv *p = talloc_zero(stream, struct priv);
+    stream->priv = p;
+
+    // Initial data
+    bstr data = bstr0(stream->url);
+    bool use_hex = bstr_eatstart0(&data, "hex://");
+    if (!use_hex)
+        bstr_eatstart0(&data, "memory://");
+
+    if (args->special_arg)
+        data = *(bstr *)args->special_arg;
+
+    p->data = bstrdup(stream, data);
+
+    if (use_hex && !bstr_decode_hex(stream, p->data, &p->data)) {
+        MP_FATAL(stream, "Invalid data.\n");
+        return STREAM_ERROR;
+    }
+
+    return STREAM_OK;
+}
+
+const stream_info_t stream_info_memory = {
+    .name = "memory",
+    .open2 = open2,
+    .protocols = (const char*const[]){ "memory", "hex", NULL },
+};
+
+// The data is copied.
+// Caller may need to set stream.stream_origin correctly.
+struct stream *stream_memory_open(struct mpv_global *global, void *data, int len)
+{
+    assert(len >= 0);
+
+    struct stream_open_args sargs = {
+        .global = global,
+        .url = "memory://",
+        .flags = STREAM_READ | STREAM_SILENT | STREAM_ORIGIN_DIRECT,
+        .sinfo = &stream_info_memory,
+        .special_arg = &(bstr){data, len},
+    };
+
+    struct stream *s = NULL;
+    stream_create_with_args(&sargs, &s);
+    MP_HANDLE_OOM(s);
+    return s;
+}
diff --git a/stream/stream_mf.c b/stream/stream_mf.c
new file mode 100644
index 0000000..0160d7c
--- /dev/null
+++ b/stream/stream_mf.c
@@ -0,0 +1,41 @@
+/*
+ * stream layer for multiple files input, based on previous work from Albeu
+ *
+ * Copyright (C) 2006 Benjamin Zores
+ * Original author: Albeu
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "stream.h"
+
+static int
+mf_stream_open (stream_t *stream)
+{
+  stream->demuxer = "mf";
+
+  return STREAM_OK;
+}
+
+const stream_info_t stream_info_mf = {
+    .name = "mf",
+    .open = mf_stream_open,
+    .protocols = (const char*const[]){ "mf", NULL },
+    .stream_origin = STREAM_ORIGIN_FS,
+};
diff --git a/stream/stream_null.c b/stream/stream_null.c
new file mode 100644
index 0000000..4027c1b
--- /dev/null
+++ b/stream/stream_null.c
@@ -0,0 +1,35 @@
+/*
+ * Original author: Albeu
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "stream.h"
+
+static int open_s(stream_t *stream)
+{
+  return 1;
+}
+
+const stream_info_t stream_info_null = {
+    .name = "null",
+    .open = open_s,
+    .protocols = (const char*const[]){ "null", NULL },
+    .can_write = true,
+};
diff --git a/stream/stream_slice.c b/stream/stream_slice.c
new file mode 100644
index 0000000..c0dbeeb
--- /dev/null
+++ b/stream/stream_slice.c
@@ -0,0 +1,181 @@
+/*
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include <libavutil/common.h>
+#include <stdint.h>
+#include <string.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include "common/common.h"
+#include "options/m_option.h"
+#include "options/path.h"
+#include "stream.h"
+
+struct priv {
+    int64_t slice_start;
+    int64_t slice_max_end; // 0 for no limit
+    struct stream *inner;
+};
+
+static int fill_buffer(struct stream *s, void *buffer, int len)
+{
+    struct priv *p = s->priv;
+
+    if (p->slice_max_end) {
+        // We don't simply use (s->pos >= size) to avoid early return
+        // if the file is still being appended to.
+        if (s->pos + p->slice_start >= p->slice_max_end)
+            return -1;
+        // Avoid rading beyond p->slice_max_end
+        len = MPMIN(len, p->slice_max_end - s->pos);
+    }
+
+    return stream_read_partial(p->inner, buffer, len);
+}
+
+static int seek(struct stream *s, int64_t newpos)
+{
+    struct priv *p = s->priv;
+    return stream_seek(p->inner, newpos + p->slice_start);
+}
+
+static int64_t get_size(struct stream *s)
+{
+    struct priv *p = s->priv;
+    int64_t size = stream_get_size(p->inner);
+    if (size <= 0)
+        return size;
+    if (size <= p->slice_start)
+      return 0;
+    if (p->slice_max_end)
+        size = MPMIN(size, p->slice_max_end);
+    return size - p->slice_start;
+}
+
+static void s_close(struct stream *s)
+{
+    struct priv *p = s->priv;
+    free_stream(p->inner);
+}
+
+static int parse_slice_range(stream_t *stream)
+{
+    struct priv *p = stream->priv;
+
+    struct bstr b_url = bstr0(stream->url);
+    struct bstr proto_with_range, inner_url;
+
+    bool has_at = bstr_split_tok(b_url, "@", &proto_with_range, &inner_url);
+
+    if (!has_at) {
+        MP_ERR(stream, "Expected slice://start[-end]@URL: '%s'\n", stream->url);
+        return STREAM_ERROR;
+    }
+
+    if (!inner_url.len) {
+        MP_ERR(stream, "URL expected to follow 'slice://start[-end]@': '%s'.\n", stream->url);
+        return STREAM_ERROR;
+    }
+    stream->path = bstrto0(stream, inner_url);
+
+    mp_split_proto(proto_with_range, &proto_with_range);
+    struct bstr range = proto_with_range;
+
+    struct bstr start, end;
+    bool has_end = bstr_split_tok(range, "-", &start, &end);
+
+    if (!start.len) {
+        MP_ERR(stream, "The byte range must have a start, and it can't be negative: '%s'\n", stream->url);
+        return STREAM_ERROR;
+    }
+
+    if (has_end && !end.len) {
+        MP_ERR(stream, "The byte range end can be omitted, but it can't be empty: '%s'\n", stream->url);
+        return STREAM_ERROR;
+    }
+
+    const struct m_option opt = {
+        .type = &m_option_type_byte_size,
+    };
+
+    if (m_option_parse(stream->log, &opt, bstr0("slice_start"), start, &p->slice_start) < 0)
+        return STREAM_ERROR;
+
+    bool max_end_is_offset = bstr_startswith0(end, "+");
+    if (has_end) {
+        if (m_option_parse(stream->log, &opt, bstr0("slice_max_end"), end, &p->slice_max_end) < 0)
+            return STREAM_ERROR;
+    }
+
+    if (max_end_is_offset)
+      p->slice_max_end += p->slice_start;
+
+    if (p->slice_max_end && p->slice_max_end < p->slice_start) {
+        MP_ERR(stream, "The byte range end (%"PRId64") can't be smaller than the start (%"PRId64"): '%s'\n",
+                p->slice_max_end,
+                p->slice_start,
+                stream->url);
+        return STREAM_ERROR;
+    }
+
+    return STREAM_OK;
+}
+
+static int open2(struct stream *stream, const struct stream_open_args *args)
+{
+    struct priv *p = talloc_zero(stream, struct priv);
+    stream->priv = p;
+
+    stream->fill_buffer = fill_buffer;
+    stream->seek = seek;
+    stream->get_size = get_size;
+    stream->close = s_close;
+
+    int parse_ret = parse_slice_range(stream);
+    if (parse_ret != STREAM_OK) {
+        return parse_ret;
+    }
+
+    struct stream_open_args args2 = *args;
+    args2.url = stream->path;
+    int inner_ret = stream_create_with_args(&args2, &p->inner);
+    if (inner_ret != STREAM_OK) {
+        return inner_ret;
+    }
+
+    if (!p->inner->seekable) {
+        MP_FATAL(stream, "Non-seekable stream '%s' can't be used with 'slice://'\n", p->inner->url);
+        free_stream(p->inner);
+        return STREAM_ERROR;
+    }
+
+    stream->seekable = 1;
+    stream->stream_origin = p->inner->stream_origin;
+
+    if (p->slice_start)
+        seek(stream, 0);
+
+    return STREAM_OK;
+}
+
+const stream_info_t stream_info_slice = {
+    .name = "slice",
+    .open2 = open2,
+    .protocols = (const char*const[]){ "slice", NULL },
+    .can_write = false,
+};