From 3486302514db31b8086f46226d9b46d53810d1e7 Mon Sep 17 00:00:00 2001
From: wm4 <wm4@nowhere>
Date: Sat, 23 Nov 2013 21:36:20 +0100
Subject: video: move decoder context from sh_video into new struct

This is similar to the sh_audio commit.

This is mostly cosmetic in nature, except that it also adds automatical
freeing of the decoder driver's state struct (which was in
sh_video->context, now in dec_video->priv).

Also remove all the stheader.h fields that are not needed anymore.
---
 mpvcore/player/audio.c      |   5 +-
 mpvcore/player/command.c    |  69 +++++++--------
 mpvcore/player/loadfile.c   |  20 ++---
 mpvcore/player/main.c       |   2 +-
 mpvcore/player/mp_core.h    |   2 +-
 mpvcore/player/osd.c        |   7 +-
 mpvcore/player/playloop.c   |  39 +++++----
 mpvcore/player/screenshot.c |   4 +-
 mpvcore/player/sub.c        |  13 +--
 mpvcore/player/video.c      | 202 ++++++++++++++++++++++----------------------
 10 files changed, 186 insertions(+), 177 deletions(-)

(limited to 'mpvcore')

diff --git a/mpvcore/player/audio.c b/mpvcore/player/audio.c
index ce161a58d5..377b393dfd 100644
--- a/mpvcore/player/audio.c
+++ b/mpvcore/player/audio.c
@@ -36,6 +36,7 @@
 #include "audio/filter/af.h"
 #include "audio/out/ao.h"
 #include "demux/demux.h"
+#include "video/decode/dec_video.h"
 
 #include "mp_core.h"
 
@@ -302,7 +303,7 @@ static int audio_start_sync(struct MPContext *mpctx, int playsize)
         if (hrseek)
             ptsdiff = written_pts - mpctx->hrseek_pts;
         else
-            ptsdiff = written_pts - mpctx->sh_video->pts - mpctx->delay
+            ptsdiff = written_pts - mpctx->d_video->pts - mpctx->delay
                       - mpctx->audio_delay;
         samples = ptsdiff * real_samplerate;
 
@@ -376,7 +377,7 @@ int fill_audio_out_buffers(struct MPContext *mpctx, double endpts)
         playsize = ao_get_space(ao);
 
     // Coming here with hrseek_active still set means audio-only
-    if (!mpctx->sh_video || !mpctx->sync_audio_to_video)
+    if (!mpctx->d_video || !mpctx->sync_audio_to_video)
         mpctx->syncing_audio = false;
     if (!opts->initial_audio_sync || !modifiable_audio_format) {
         mpctx->syncing_audio = false;
diff --git a/mpvcore/player/command.c b/mpvcore/player/command.c
index cdeb11c713..c09a046cd2 100644
--- a/mpvcore/player/command.c
+++ b/mpvcore/player/command.c
@@ -316,7 +316,7 @@ static int mp_property_length(m_option_t *prop, int action, void *arg,
 static int mp_property_avsync(m_option_t *prop, int action, void *arg,
                               MPContext *mpctx)
 {
-    if (!mpctx->d_audio || !mpctx->sh_video)
+    if (!mpctx->d_audio || !mpctx->d_video)
         return M_PROPERTY_UNAVAILABLE;
     if (mpctx->last_av_difference == MP_NOPTS_VALUE)
         return M_PROPERTY_UNAVAILABLE;
@@ -623,8 +623,8 @@ static int mp_property_angle(m_option_t *prop, int action, void *arg,
     case M_PROPERTY_SET:
         angle = demuxer_set_angle(demuxer, *(int *)arg);
         if (angle >= 0) {
-            if (mpctx->sh_video)
-                resync_video_stream(mpctx->sh_video);
+            if (mpctx->d_video)
+                video_resync_stream(mpctx->d_video);
 
             if (mpctx->d_audio)
                 audio_resync_stream(mpctx->d_audio);
@@ -817,7 +817,7 @@ static int mp_property_volrestore(m_option_t *prop, int action,
 static int mp_property_audio_delay(m_option_t *prop, int action,
                                    void *arg, MPContext *mpctx)
 {
-    if (!(mpctx->d_audio && mpctx->sh_video))
+    if (!(mpctx->d_audio && mpctx->d_video))
         return M_PROPERTY_UNAVAILABLE;
     float delay = mpctx->opts->audio_delay;
     switch (action) {
@@ -1168,7 +1168,7 @@ static int probe_deint_filters(struct MPContext *mpctx, const char *cmd)
 
 static int get_deinterlacing(struct MPContext *mpctx)
 {
-    vf_instance_t *vf = mpctx->sh_video->vfilter;
+    vf_instance_t *vf = mpctx->d_video->vfilter;
     int enabled = 0;
     if (vf->control(vf, VFCTRL_GET_DEINTERLACE, &enabled) != CONTROL_OK)
         enabled = -1;
@@ -1182,7 +1182,7 @@ static int get_deinterlacing(struct MPContext *mpctx)
 
 static void set_deinterlacing(struct MPContext *mpctx, bool enable)
 {
-    vf_instance_t *vf = mpctx->sh_video->vfilter;
+    vf_instance_t *vf = mpctx->d_video->vfilter;
     if (vf_find_by_label(vf, VF_DEINTERLACE_LABEL)) {
         if (!enable)
             edit_filters(mpctx, STREAM_VIDEO, "del", "@" VF_DEINTERLACE_LABEL);
@@ -1199,7 +1199,7 @@ static void set_deinterlacing(struct MPContext *mpctx, bool enable)
 static int mp_property_deinterlace(m_option_t *prop, int action,
                                    void *arg, MPContext *mpctx)
 {
-    if (!mpctx->sh_video || !mpctx->sh_video->vfilter)
+    if (!mpctx->d_video || !mpctx->d_video->vfilter)
         return M_PROPERTY_UNAVAILABLE;
     switch (action) {
     case M_PROPERTY_GET:
@@ -1218,7 +1218,7 @@ static int video_refresh_property_helper(m_option_t *prop, int action,
 {
     int r = mp_property_generic_option(prop, action, arg, mpctx);
     if (action == M_PROPERTY_SET) {
-        if (mpctx->sh_video) {
+        if (mpctx->d_video) {
             reinit_video_filters(mpctx);
             mp_force_video_refresh(mpctx);
         }
@@ -1239,8 +1239,8 @@ static int mp_property_colormatrix(m_option_t *prop, int action, void *arg,
         vo_control(mpctx->video_out, VOCTRL_GET_YUV_COLORSPACE, &vo_csp);
 
     struct mp_image_params vd_csp = {0};
-    if (mpctx->sh_video)
-        vd_control(mpctx->sh_video, VDCTRL_GET_PARAMS, &vd_csp);
+    if (mpctx->d_video)
+        video_vd_control(mpctx->d_video, VDCTRL_GET_PARAMS, &vd_csp);
 
     char *res = talloc_asprintf(NULL, "%s",
                                 mp_csp_names[opts->requested_colorspace]);
@@ -1273,8 +1273,8 @@ static int mp_property_colormatrix_input_range(m_option_t *prop, int action,
         vo_control(mpctx->video_out, VOCTRL_GET_YUV_COLORSPACE, &vo_csp );
 
     struct mp_image_params vd_csp = {0};
-    if (mpctx->sh_video)
-        vd_control(mpctx->sh_video, VDCTRL_GET_PARAMS, &vd_csp);
+    if (mpctx->d_video)
+        video_vd_control(mpctx->d_video, VDCTRL_GET_PARAMS, &vd_csp);
 
     char *res = talloc_asprintf(NULL, "%s",
                                 mp_csp_levels_names[opts->requested_input_range]);
@@ -1372,7 +1372,7 @@ static int mp_property_border(m_option_t *prop, int action, void *arg,
 static int mp_property_framedrop(m_option_t *prop, int action,
                                  void *arg, MPContext *mpctx)
 {
-    if (!mpctx->sh_video)
+    if (!mpctx->d_video)
         return M_PROPERTY_UNAVAILABLE;
 
     return mp_property_generic_option(prop, action, arg, mpctx);
@@ -1381,17 +1381,17 @@ static int mp_property_framedrop(m_option_t *prop, int action,
 static int mp_property_video_color(m_option_t *prop, int action, void *arg,
                                    MPContext *mpctx)
 {
-    if (!mpctx->sh_video)
+    if (!mpctx->d_video)
         return M_PROPERTY_UNAVAILABLE;
 
     switch (action) {
     case M_PROPERTY_SET: {
-        if (set_video_colors(mpctx->sh_video, prop->name, *(int *) arg) <= 0)
+        if (video_set_colors(mpctx->d_video, prop->name, *(int *) arg) <= 0)
             return M_PROPERTY_UNAVAILABLE;
         break;
     }
     case M_PROPERTY_GET:
-        if (get_video_colors(mpctx->sh_video, prop->name, (int *)arg) <= 0)
+        if (video_get_colors(mpctx->d_video, prop->name, (int *)arg) <= 0)
             return M_PROPERTY_UNAVAILABLE;
         // Write new value to option variable
         mp_property_generic_option(prop, M_PROPERTY_SET, arg, mpctx);
@@ -1404,7 +1404,7 @@ static int mp_property_video_color(m_option_t *prop, int action, void *arg,
 static int mp_property_video_format(m_option_t *prop, int action,
                                     void *arg, MPContext *mpctx)
 {
-    const char *c = mpctx->sh_video ? mpctx->sh_video->gsh->codec : NULL;
+    const char *c = mpctx->d_video ? mpctx->d_video->header->codec : NULL;
     return m_property_strdup_ro(prop, action, arg, c);
 }
 
@@ -1412,7 +1412,7 @@ static int mp_property_video_format(m_option_t *prop, int action,
 static int mp_property_video_codec(m_option_t *prop, int action,
                                    void *arg, MPContext *mpctx)
 {
-    const char *c = mpctx->sh_video ? mpctx->sh_video->gsh->decoder_desc : NULL;
+    const char *c = mpctx->d_video ? mpctx->d_video->decoder_desc : NULL;
     return m_property_strdup_ro(prop, action, arg, c);
 }
 
@@ -1421,42 +1421,44 @@ static int mp_property_video_codec(m_option_t *prop, int action,
 static int mp_property_video_bitrate(m_option_t *prop, int action,
                                      void *arg, MPContext *mpctx)
 {
-    if (!mpctx->sh_video)
+    if (!mpctx->d_video)
         return M_PROPERTY_UNAVAILABLE;
     if (action == M_PROPERTY_PRINT) {
-        *(char **)arg = format_bitrate(mpctx->sh_video->i_bps);
+        *(char **)arg = format_bitrate(mpctx->d_video->i_bps);
         return M_PROPERTY_OK;
     }
-    return m_property_int_ro(prop, action, arg, mpctx->sh_video->i_bps);
+    return m_property_int_ro(prop, action, arg, mpctx->d_video->i_bps);
 }
 
 /// Video display width (RO)
 static int mp_property_width(m_option_t *prop, int action, void *arg,
                              MPContext *mpctx)
 {
-    struct sh_video *sh = mpctx->sh_video;
-    if (!sh)
+    struct dec_video *vd = mpctx->d_video;
+    if (!vd)
         return M_PROPERTY_UNAVAILABLE;
+    struct sh_video *sh = vd->header->video;
     return m_property_int_ro(prop, action, arg,
-                             sh->vf_input ? sh->vf_input->w : sh->disp_w);
+                             vd->vf_input ? vd->vf_input->w : sh->disp_w);
 }
 
 /// Video display height (RO)
 static int mp_property_height(m_option_t *prop, int action, void *arg,
                               MPContext *mpctx)
 {
-    struct sh_video *sh = mpctx->sh_video;
-    if (!sh)
+    struct dec_video *vd = mpctx->d_video;
+    if (!vd)
         return M_PROPERTY_UNAVAILABLE;
+    struct sh_video *sh = vd->header->video;
     return m_property_int_ro(prop, action, arg,
-                             sh->vf_input ? sh->vf_input->h : sh->disp_h);
+                             vd->vf_input ? vd->vf_input->h : sh->disp_h);
 }
 
 static int property_vo_wh(m_option_t *prop, int action, void *arg,
                           MPContext *mpctx, bool get_w)
 {
     struct vo *vo = mpctx->video_out;
-    if (!mpctx->sh_video && !vo || !vo->hasframe)
+    if (!mpctx->d_video || !vo || !vo->hasframe)
         return M_PROPERTY_UNAVAILABLE;
     return m_property_int_ro(prop, action, arg,
                              get_w ? vo->aspdat.prew : vo->aspdat.preh);
@@ -1530,18 +1532,19 @@ static int mp_property_osd_par(m_option_t *prop, int action, void *arg,
 static int mp_property_fps(m_option_t *prop, int action, void *arg,
                            MPContext *mpctx)
 {
-    if (!mpctx->sh_video)
+    if (!mpctx->d_video)
         return M_PROPERTY_UNAVAILABLE;
-    return m_property_float_ro(prop, action, arg, mpctx->sh_video->fps);
+    return m_property_float_ro(prop, action, arg, mpctx->d_video->header->video->fps);
 }
 
 /// Video aspect (RO)
 static int mp_property_aspect(m_option_t *prop, int action, void *arg,
                               MPContext *mpctx)
 {
-    struct sh_video *sh_video = mpctx->sh_video;
-    if (!mpctx->sh_video)
+    if (!mpctx->d_video)
         return M_PROPERTY_UNAVAILABLE;
+    struct dec_video *d_video = mpctx->d_video;
+    struct sh_video *sh_video = d_video->header->video;
     switch (action) {
     case M_PROPERTY_SET: {
         mpctx->opts->movie_aspect = *(float *)arg;
@@ -1551,7 +1554,7 @@ static int mp_property_aspect(m_option_t *prop, int action, void *arg,
     }
     case M_PROPERTY_GET: {
         float aspect = -1;
-        struct mp_image_params *params = sh_video->vf_input;
+        struct mp_image_params *params = d_video->vf_input;
         if (params && params->d_w && params->d_h) {
             aspect = (float)params->d_w / params->d_h;
         } else if (sh_video->disp_w && sh_video->disp_h) {
diff --git a/mpvcore/player/loadfile.c b/mpvcore/player/loadfile.c
index 856f5469c0..51d3f2ec7e 100644
--- a/mpvcore/player/loadfile.c
+++ b/mpvcore/player/loadfile.c
@@ -99,8 +99,9 @@ void uninit_player(struct MPContext *mpctx, unsigned int mask)
 
     if (mask & INITIALIZED_VCODEC) {
         mpctx->initialized_flags &= ~INITIALIZED_VCODEC;
-        if (mpctx->sh_video)
-            uninit_video(mpctx->sh_video);
+        if (mpctx->d_video)
+            video_uninit(mpctx->d_video);
+        mpctx->d_video = NULL;
         cleanup_demux_stream(mpctx, STREAM_VIDEO);
         mpctx->sync_audio_to_video = false;
     }
@@ -113,7 +114,7 @@ void uninit_player(struct MPContext *mpctx, unsigned int mask)
         mpctx->num_tracks = 0;
         for (int t = 0; t < STREAM_TYPE_COUNT; t++)
             mpctx->current_track[t] = NULL;
-        assert(!mpctx->sh_video && !mpctx->d_audio && !mpctx->sh_sub);
+        assert(!mpctx->d_video && !mpctx->d_audio && !mpctx->sh_sub);
         mpctx->master_demuxer = NULL;
         for (int i = 0; i < mpctx->num_sources; i++) {
             uninit_subs(mpctx->sources[i]);
@@ -269,7 +270,6 @@ static void set_demux_field(struct MPContext *mpctx, enum stream_type type,
     mpctx->sh[type] = s;
     // redundant fields for convenience access
     switch(type) {
-        case STREAM_VIDEO: mpctx->sh_video = s ? s->video : NULL; break;
         case STREAM_SUB: mpctx->sh_sub = s ? s->sub : NULL; break;
     }
 }
@@ -348,7 +348,7 @@ bool timeline_set_part(struct MPContext *mpctx, int i, bool force)
     if (n->source == p->source && !force)
         return false;
     enum stop_play_reason orig_stop_play = mpctx->stop_play;
-    if (!mpctx->sh_video && mpctx->stop_play == KEEP_PLAYING)
+    if (!mpctx->d_video && mpctx->stop_play == KEEP_PLAYING)
         mpctx->stop_play = AT_END_OF_FILE;  // let audio uninit drain data
     uninit_player(mpctx, INITIALIZED_VCODEC | (mpctx->opts->fixed_vo ? 0 : INITIALIZED_VO) | (mpctx->opts->gapless_audio ? 0 : INITIALIZED_AO) | INITIALIZED_ACODEC | INITIALIZED_SUB);
     mpctx->stop_play = orig_stop_play;
@@ -1050,7 +1050,7 @@ static void play_current_file(struct MPContext *mpctx)
     assert(mpctx->stream == NULL);
     assert(mpctx->demuxer == NULL);
     assert(mpctx->d_audio == NULL);
-    assert(mpctx->sh_video == NULL);
+    assert(mpctx->d_video == NULL);
     assert(mpctx->sh_sub == NULL);
 
     char *stream_filename = mpctx->filename;
@@ -1189,14 +1189,14 @@ goto_reopen_demuxer: ;
 
     //================ SETUP STREAMS ==========================
 
-    if (opts->force_fps && mpctx->sh_video) {
-        mpctx->sh_video->fps = opts->force_fps;
-        MP_INFO(mpctx, "FPS forced to be %5.3f.\n", mpctx->sh_video->fps);
+    if (opts->force_fps && mpctx->d_video) {
+        mpctx->d_video->header->video->fps = opts->force_fps;
+        MP_INFO(mpctx, "FPS forced to be %5.3f.\n", mpctx->d_video->header->video->fps);
     }
 
     //==================== START PLAYING =======================
 
-    if (!mpctx->sh_video && !mpctx->d_audio) {
+    if (!mpctx->d_video && !mpctx->d_audio) {
         MP_FATAL(mpctx, "No video or audio streams selected.\n");
 #if HAVE_DVBIN
         if (mpctx->stream->type == STREAMTYPE_DVB) {
diff --git a/mpvcore/player/main.c b/mpvcore/player/main.c
index 528076bc57..84b5aa2651 100644
--- a/mpvcore/player/main.c
+++ b/mpvcore/player/main.c
@@ -200,7 +200,7 @@ static bool handle_help_options(struct MPContext *mpctx)
         opt_exit = 1;
     }
     if (opts->video_decoders && strcmp(opts->video_decoders, "help") == 0) {
-        struct mp_decoder_list *list = mp_video_decoder_list();
+        struct mp_decoder_list *list = video_decoder_list();
         mp_print_decoders(MSGT_CPLAYER, MSGL_INFO, "Video decoders:", list);
         talloc_free(list);
         opt_exit = 1;
diff --git a/mpvcore/player/mp_core.h b/mpvcore/player/mp_core.h
index aa0728d10f..f372c4e137 100644
--- a/mpvcore/player/mp_core.h
+++ b/mpvcore/player/mp_core.h
@@ -199,9 +199,9 @@ typedef struct MPContext {
     struct track *current_track[STREAM_TYPE_COUNT];
 
     struct sh_stream *sh[STREAM_TYPE_COUNT];
-    struct sh_video *sh_video;          // same as sh[STREAM_VIDEO]->video
     struct sh_sub *sh_sub;              // same as sh[STREAM_SUB]->sub
 
+    struct dec_video *d_video;
     struct dec_audio *d_audio;
 
     // Uses: accessing metadata (consider ordered chapters case, where the main
diff --git a/mpvcore/player/osd.c b/mpvcore/player/osd.c
index 04052c359e..6f81deae2e 100644
--- a/mpvcore/player/osd.c
+++ b/mpvcore/player/osd.c
@@ -85,7 +85,6 @@ void write_status_line(struct MPContext *mpctx, const char *line)
 void print_status(struct MPContext *mpctx)
 {
     struct MPOpts *opts = mpctx->opts;
-    sh_video_t * const sh_video = mpctx->sh_video;
 
     update_window_title(mpctx, false);
 
@@ -110,7 +109,7 @@ void print_status(struct MPContext *mpctx)
 
     if (mpctx->d_audio)
         saddf(&line, "A");
-    if (mpctx->sh_video)
+    if (mpctx->d_video)
         saddf(&line, "V");
     saddf(&line, ": ");
 
@@ -131,7 +130,7 @@ void print_status(struct MPContext *mpctx)
         saddf(&line, " x%4.2f", opts->playback_speed);
 
     // A-V sync
-    if (mpctx->d_audio && sh_video && mpctx->sync_audio_to_video) {
+    if (mpctx->d_audio && mpctx->d_video && mpctx->sync_audio_to_video) {
         if (mpctx->last_av_difference != MP_NOPTS_VALUE)
             saddf(&line, " A-V:%7.3f", mpctx->last_av_difference);
         else
@@ -152,7 +151,7 @@ void print_status(struct MPContext *mpctx)
 #endif
     {
         // VO stats
-        if (sh_video && mpctx->drop_frame_cnt)
+        if (mpctx->d_video && mpctx->drop_frame_cnt)
             saddf(&line, " Late: %d", mpctx->drop_frame_cnt);
     }
 
diff --git a/mpvcore/player/playloop.c b/mpvcore/player/playloop.c
index 51daf03bb1..591d31fbca 100644
--- a/mpvcore/player/playloop.c
+++ b/mpvcore/player/playloop.c
@@ -93,7 +93,7 @@ void pause_player(struct MPContext *mpctx)
     mpctx->osd_function = 0;
     mpctx->paused_for_cache = false;
 
-    if (mpctx->video_out && mpctx->sh_video && mpctx->video_out->config_ok)
+    if (mpctx->video_out && mpctx->d_video && mpctx->video_out->config_ok)
         vo_control(mpctx->video_out, VOCTRL_PAUSE, NULL);
 
     if (mpctx->ao && mpctx->d_audio)
@@ -126,7 +126,7 @@ void unpause_player(struct MPContext *mpctx)
 
     if (mpctx->ao && mpctx->d_audio)
         ao_resume(mpctx->ao);
-    if (mpctx->video_out && mpctx->sh_video && mpctx->video_out->config_ok)
+    if (mpctx->video_out && mpctx->d_video && mpctx->video_out->config_ok)
         vo_control(mpctx->video_out, VOCTRL_RESUME, NULL);      // resume video
     (void)get_relative_time(mpctx);     // ignore time that passed during pause
 }
@@ -153,7 +153,7 @@ static bool redraw_osd(struct MPContext *mpctx)
 
 void add_step_frame(struct MPContext *mpctx, int dir)
 {
-    if (!mpctx->sh_video)
+    if (!mpctx->d_video)
         return;
     if (dir > 0) {
         mpctx->step_frames += 1;
@@ -169,14 +169,14 @@ void add_step_frame(struct MPContext *mpctx, int dir)
 
 static void seek_reset(struct MPContext *mpctx, bool reset_ao)
 {
-    if (mpctx->sh_video) {
-        resync_video_stream(mpctx->sh_video);
+    if (mpctx->d_video) {
+        video_resync_stream(mpctx->d_video);
         vo_seek_reset(mpctx->video_out);
-        if (mpctx->sh_video->vf_initialized == 1)
-            vf_chain_seek_reset(mpctx->sh_video->vfilter);
-        mpctx->sh_video->num_buffered_pts = 0;
-        mpctx->sh_video->last_pts = MP_NOPTS_VALUE;
-        mpctx->sh_video->pts = MP_NOPTS_VALUE;
+        if (mpctx->d_video->vf_initialized == 1)
+            vf_chain_seek_reset(mpctx->d_video->vfilter);
+        mpctx->d_video->num_buffered_pts = 0;
+        mpctx->d_video->last_pts = MP_NOPTS_VALUE;
+        mpctx->d_video->pts = MP_NOPTS_VALUE;
         mpctx->video_pts = MP_NOPTS_VALUE;
         mpctx->delay = 0;
         mpctx->time_frame = 0;
@@ -589,7 +589,7 @@ do_seek:
 
 static void update_avsync(struct MPContext *mpctx)
 {
-    if (!mpctx->d_audio || !mpctx->sh_video)
+    if (!mpctx->d_audio || !mpctx->d_video)
         return;
 
     double a_pos = playing_audio_pts(mpctx);
@@ -624,7 +624,7 @@ static void adjust_sync(struct MPContext *mpctx, double frame_time)
         return;
 
     double a_pts = written_audio_pts(mpctx) - mpctx->delay;
-    double v_pts = mpctx->sh_video->pts;
+    double v_pts = mpctx->d_video->pts;
     double av_delay = a_pts - v_pts;
     // Try to sync vo_flip() so it will *finish* at given time
     av_delay += mpctx->last_vo_flip_duration;
@@ -797,7 +797,7 @@ static void handle_backstep(struct MPContext *mpctx)
     double current_pts = mpctx->last_vo_pts;
     mpctx->backstep_active = false;
     bool demuxer_ok = mpctx->demuxer && mpctx->demuxer->accurate_seek;
-    if (demuxer_ok && mpctx->sh_video && current_pts != MP_NOPTS_VALUE) {
+    if (demuxer_ok && mpctx->d_video && current_pts != MP_NOPTS_VALUE) {
         double seek_pts = find_previous_pts(mpctx, current_pts);
         if (seek_pts != MP_NOPTS_VALUE) {
             queue_seek(mpctx, MPSEEK_ABSOLUTE, seek_pts, 1);
@@ -863,7 +863,7 @@ static void handle_keep_open(struct MPContext *mpctx)
 void handle_force_window(struct MPContext *mpctx, bool reconfig)
 {
     // Don't interfere with real video playback
-    if (mpctx->sh_video)
+    if (mpctx->d_video)
         return;
 
     struct vo *vo = mpctx->video_out;
@@ -982,7 +982,7 @@ void run_playloop(struct MPContext *mpctx)
     }
 
     double buffered_audio = -1;
-    while (mpctx->sh_video) {   // never loops, for "break;" only
+    while (mpctx->d_video) {   // never loops, for "break;" only
         struct vo *vo = mpctx->video_out;
         update_fps(mpctx);
 
@@ -990,7 +990,7 @@ void run_playloop(struct MPContext *mpctx)
         if (!vo->frame_loaded && (!mpctx->paused || mpctx->restart_playback)) {
             double frame_time = update_video(mpctx, endpts);
             mp_dbg(MSGT_AVSYNC, MSGL_DBG2, "*** ftime=%5.3f ***\n", frame_time);
-            if (mpctx->sh_video->vf_initialized < 0) {
+            if (mpctx->d_video->vf_initialized < 0) {
                 MP_FATAL(mpctx, "\nFATAL: Could not initialize video filters "
                          "(-vf) or video output (-vo).\n");
                 int uninit = INITIALIZED_VCODEC;
@@ -1016,7 +1016,7 @@ void run_playloop(struct MPContext *mpctx)
         }
 
         if (endpts != MP_NOPTS_VALUE)
-            video_left &= mpctx->sh_video->pts < endpts;
+            video_left &= mpctx->d_video->pts < endpts;
 
         handle_heartbeat_cmd(mpctx);
 
@@ -1070,8 +1070,7 @@ void run_playloop(struct MPContext *mpctx)
         //=================== FLIP PAGE (VIDEO BLT): ======================
 
         vo_new_frame_imminent(vo);
-        struct sh_video *sh_video = mpctx->sh_video;
-        mpctx->video_pts = sh_video->pts;
+        mpctx->video_pts = mpctx->d_video->pts;
         mpctx->last_vo_pts = mpctx->video_pts;
         mpctx->playback_pts = mpctx->video_pts;
         update_subtitles(mpctx);
@@ -1182,7 +1181,7 @@ void run_playloop(struct MPContext *mpctx)
      * should trigger after seek only, when we know there's no audio
      * buffered.
      */
-    if ((mpctx->d_audio || mpctx->sh_video) && !audio_left && !video_left
+    if ((mpctx->d_audio || mpctx->d_video) && !audio_left && !video_left
         && (opts->gapless_audio || buffered_audio < 0.05)
         && (!mpctx->paused || was_restart)) {
         if (end_is_chapter) {
diff --git a/mpvcore/player/screenshot.c b/mpvcore/player/screenshot.c
index aeb15c0fd7..f564b5e9d7 100644
--- a/mpvcore/player/screenshot.c
+++ b/mpvcore/player/screenshot.c
@@ -315,8 +315,8 @@ static struct mp_image *screenshot_get(struct MPContext *mpctx, int mode)
         struct voctrl_screenshot_args args =
                             { .full_window = (mode == MODE_FULL_WINDOW) };
 
-        if (mpctx->sh_video && mpctx->sh_video->vfilter) {
-            struct vf_instance *vfilter = mpctx->sh_video->vfilter;
+        if (mpctx->d_video && mpctx->d_video->vfilter) {
+            struct vf_instance *vfilter = mpctx->d_video->vfilter;
             vfilter->control(vfilter, VFCTRL_SCREENSHOT, &args);
         }
 
diff --git a/mpvcore/player/sub.c b/mpvcore/player/sub.c
index 94368435d1..d659e74851 100644
--- a/mpvcore/player/sub.c
+++ b/mpvcore/player/sub.c
@@ -33,6 +33,7 @@
 #include "sub/dec_sub.h"
 #include "demux/demux.h"
 #include "video/mp_image.h"
+#include "video/decode/dec_video.h"
 
 #include "mp_core.h"
 
@@ -83,8 +84,8 @@ void update_subtitles(struct MPContext *mpctx)
     assert(track && sh_sub);
     struct dec_sub *dec_sub = sh_sub->dec_sub;
 
-    if (mpctx->sh_video && mpctx->sh_video->vf_input) {
-        struct mp_image_params params = *mpctx->sh_video->vf_input;
+    if (mpctx->d_video && mpctx->d_video->vf_input) {
+        struct mp_image_params params = *mpctx->d_video->vf_input;
         sub_control(dec_sub, SD_CTRL_SET_VIDEO_PARAMS, &params);
     }
 
@@ -194,9 +195,11 @@ void reinit_subs(struct MPContext *mpctx)
     assert(dec_sub);
 
     if (!sub_is_initialized(dec_sub)) {
-        int w = mpctx->sh_video ? mpctx->sh_video->disp_w : 0;
-        int h = mpctx->sh_video ? mpctx->sh_video->disp_h : 0;
-        float fps = mpctx->sh_video ? mpctx->sh_video->fps : 25;
+        struct sh_video *sh_video =
+            mpctx->d_video ? mpctx->d_video->header->video : NULL;
+        int w = sh_video ? sh_video->disp_w : 0;
+        int h = sh_video ? sh_video->disp_h : 0;
+        float fps = sh_video ? sh_video->fps : 25;
 
         set_dvdsub_fake_extradata(dec_sub, track->demuxer->stream, w, h);
         sub_set_video_res(dec_sub, w, h);
diff --git a/mpvcore/player/video.c b/mpvcore/player/video.c
index ac6406968f..333b694f9c 100644
--- a/mpvcore/player/video.c
+++ b/mpvcore/player/video.c
@@ -46,63 +46,64 @@
 void update_fps(struct MPContext *mpctx)
 {
 #if HAVE_ENCODING
-    struct sh_video *sh_video = mpctx->sh_video;
-    if (mpctx->encode_lavc_ctx && sh_video)
-        encode_lavc_set_video_fps(mpctx->encode_lavc_ctx, sh_video->fps);
+    struct dec_video *d_video = mpctx->d_video;
+    if (mpctx->encode_lavc_ctx && d_video)
+        encode_lavc_set_video_fps(mpctx->encode_lavc_ctx, d_video->header->video->fps);
 #endif
 }
 
 static void recreate_video_filters(struct MPContext *mpctx)
 {
     struct MPOpts *opts = mpctx->opts;
-    struct sh_video *sh_video = mpctx->sh_video;
-    assert(sh_video);
+    struct dec_video *d_video = mpctx->d_video;
+    assert(d_video);
 
-    vf_uninit_filter_chain(sh_video->vfilter);
+    vf_uninit_filter_chain(d_video->vfilter);
 
     char *vf_arg[] = {
         "_oldargs_", (char *)mpctx->video_out, NULL
     };
-    sh_video->vfilter = vf_open_filter(opts, NULL, "vo", vf_arg);
+    d_video->vfilter = vf_open_filter(opts, NULL, "vo", vf_arg);
 
-    sh_video->vfilter = append_filters(sh_video->vfilter, opts->vf_settings);
+    d_video->vfilter = append_filters(d_video->vfilter, opts->vf_settings);
 
-    struct vf_instance *vf = sh_video->vfilter;
+    struct vf_instance *vf = d_video->vfilter;
     mpctx->osd->render_subs_in_filter
         = vf->control(vf, VFCTRL_INIT_OSD, NULL) == VO_TRUE;
 }
 
 int reinit_video_filters(struct MPContext *mpctx)
 {
-    struct sh_video *sh_video = mpctx->sh_video;
+    struct dec_video *d_video = mpctx->d_video;
 
-    if (!sh_video)
+    if (!d_video)
         return -2;
 
     recreate_video_filters(mpctx);
-    video_reinit_vo(sh_video);
+    video_reinit_vo(d_video);
 
-    return sh_video->vf_initialized > 0 ? 0 : -1;
+    return d_video->vf_initialized > 0 ? 0 : -1;
 }
 
 int reinit_video_chain(struct MPContext *mpctx)
 {
     struct MPOpts *opts = mpctx->opts;
     assert(!(mpctx->initialized_flags & INITIALIZED_VCODEC));
+    assert(!mpctx->d_video);
     init_demux_stream(mpctx, STREAM_VIDEO);
-    sh_video_t *sh_video = mpctx->sh_video;
-    if (!sh_video)
+    struct sh_stream *sh = mpctx->sh[STREAM_VIDEO];
+    if (!sh)
         goto no_video;
 
     MP_VERBOSE(mpctx, "[V] fourcc:0x%X  size:%dx%d  fps:%5.3f\n",
-               mpctx->sh_video->format,
-               mpctx->sh_video->disp_w, mpctx->sh_video->disp_h,
-               mpctx->sh_video->fps);
+               sh->video->format,
+               sh->video->disp_w, sh->video->disp_h,
+               sh->video->fps);
     if (opts->force_fps)
-        mpctx->sh_video->fps = opts->force_fps;
+        sh->video->fps = opts->force_fps;
     update_fps(mpctx);
 
-    if (!mpctx->sh_video->fps && !opts->force_fps && !opts->correct_pts) {
+    if (!sh->video->fps && !opts->force_fps && !opts->correct_pts) {
         MP_ERR(mpctx, "FPS not specified in the "
                "header or invalid, use the -fps option.\n");
     }
@@ -121,26 +122,31 @@ int reinit_video_chain(struct MPContext *mpctx)
         mpctx->initialized_flags |= INITIALIZED_VO;
     }
 
-    // dynamic allocation only to make stheader.h lighter
-    talloc_free(sh_video->hwdec_info);
-    sh_video->hwdec_info = talloc_zero(sh_video, struct mp_hwdec_info);
-    vo_control(mpctx->video_out, VOCTRL_GET_HWDEC_INFO, sh_video->hwdec_info);
-
     update_window_title(mpctx, true);
 
-    if (stream_control(mpctx->sh_video->gsh->demuxer->stream,
-                       STREAM_CTRL_GET_ASPECT_RATIO, &ar) != STREAM_UNSUPPORTED)
-        mpctx->sh_video->stream_aspect = ar;
+    struct dec_video *d_video = talloc_zero(NULL, struct dec_video);
+    mpctx->d_video = d_video;
+    d_video->last_pts = MP_NOPTS_VALUE;
+    d_video->opts = mpctx->opts;
+    d_video->header = sh;
+    mpctx->initialized_flags |= INITIALIZED_VCODEC;
+
+    // dynamic allocation only to make stheader.h lighter
+    talloc_free(d_video->hwdec_info);
+    d_video->hwdec_info = talloc_zero(d_video, struct mp_hwdec_info);
+    vo_control(mpctx->video_out, VOCTRL_GET_HWDEC_INFO, d_video->hwdec_info);
+
+    if (stream_control(sh->demuxer->stream, STREAM_CTRL_GET_ASPECT_RATIO, &ar)
+            != STREAM_UNSUPPORTED)
+        d_video->stream_aspect = ar;
 
     recreate_video_filters(mpctx);
 
-    init_best_video_codec(sh_video, opts->video_decoders);
+    video_init_best_codec(d_video, opts->video_decoders);
 
-    if (!sh_video->initialized)
+    if (!d_video->initialized)
         goto err_out;
 
-    mpctx->initialized_flags |= INITIALIZED_VCODEC;
-
     bool saver_state = opts->pause || !opts->stop_screensaver;
     vo_control(mpctx->video_out, saver_state ? VOCTRL_RESTORE_SCREENSAVER
                                              : VOCTRL_KILL_SCREENSAVER, NULL);
@@ -148,12 +154,9 @@ int reinit_video_chain(struct MPContext *mpctx)
     vo_control(mpctx->video_out, mpctx->paused ? VOCTRL_PAUSE
                                                : VOCTRL_RESUME, NULL);
 
-    sh_video->last_pts = MP_NOPTS_VALUE;
-    sh_video->num_buffered_pts = 0;
-    sh_video->next_frame_time = 0;
     mpctx->last_vf_reconfig_count = 0;
     mpctx->restart_playback = true;
-    mpctx->sync_audio_to_video = !sh_video->gsh->attached_picture;
+    mpctx->sync_audio_to_video = !sh->attached_picture;
     mpctx->delay = 0;
     mpctx->vo_pts_history_seek_ts++;
 
@@ -185,10 +188,10 @@ void mp_force_video_refresh(struct MPContext *mpctx)
 
 static bool filter_output_queued_frame(struct MPContext *mpctx)
 {
-    struct sh_video *sh_video = mpctx->sh_video;
+    struct dec_video *d_video = mpctx->d_video;
     struct vo *video_out = mpctx->video_out;
 
-    struct mp_image *img = vf_chain_output_queued_frame(sh_video->vfilter);
+    struct mp_image *img = vf_chain_output_queued_frame(d_video->vfilter);
     if (img)
         vo_queue_image(video_out, img);
     talloc_free(img);
@@ -208,16 +211,16 @@ static bool load_next_vo_frame(struct MPContext *mpctx, bool eof)
 static void init_filter_params(struct MPContext *mpctx)
 {
     struct MPOpts *opts = mpctx->opts;
-    struct sh_video *sh_video = mpctx->sh_video;
+    struct dec_video *d_video = mpctx->d_video;
 
     // Note that the video decoder already initializes the filter chain. This
     // might recreate the chain a second time, which is not very elegant, but
     // allows us to test whether enabling deinterlacing works with the current
     // video format and other filters.
-    if (sh_video->vf_initialized != 1)
+    if (d_video->vf_initialized != 1)
         return;
 
-    if (sh_video->vf_reconfig_count <= mpctx->last_vf_reconfig_count) {
+    if (d_video->vf_reconfig_count <= mpctx->last_vf_reconfig_count) {
         if (opts->deinterlace >= 0) {
             mp_property_do("deinterlace", M_PROPERTY_SET, &opts->deinterlace,
                            mpctx);
@@ -225,18 +228,18 @@ static void init_filter_params(struct MPContext *mpctx)
     }
     // Setting filter params has to be "stable" (no change if params already
     // set) - checking the reconfig count is just an optimization.
-    mpctx->last_vf_reconfig_count = sh_video->vf_reconfig_count;
+    mpctx->last_vf_reconfig_count = d_video->vf_reconfig_count;
 }
 
 static void filter_video(struct MPContext *mpctx, struct mp_image *frame)
 {
-    struct sh_video *sh_video = mpctx->sh_video;
+    struct dec_video *d_video = mpctx->d_video;
 
     init_filter_params(mpctx);
 
-    frame->pts = sh_video->pts;
-    mp_image_set_params(frame, sh_video->vf_input);
-    vf_filter_frame(sh_video->vfilter, frame);
+    frame->pts = d_video->pts;
+    mp_image_set_params(frame, d_video->vf_input);
+    vf_filter_frame(d_video->vfilter, frame);
     filter_output_queued_frame(mpctx);
 }
 
@@ -249,8 +252,9 @@ static int check_framedrop(struct MPContext *mpctx, double frame_time)
     {
         float delay = opts->playback_speed * ao_get_delay(mpctx->ao);
         float d = delay - mpctx->delay;
+        float fps = mpctx->d_video->header->video->fps;
         if (frame_time < 0)
-            frame_time = mpctx->sh_video->fps > 0 ? 1.0 / mpctx->sh_video->fps : 0;
+            frame_time = fps > 0 ? 1.0 / fps : 0;
         // we should avoid dropping too many frames in sequence unless we
         // are too late. and we allow 100ms A-V delay here:
         if (d < -mpctx->dropped_frames * frame_time - 0.100 && !mpctx->paused
@@ -266,24 +270,25 @@ static int check_framedrop(struct MPContext *mpctx, double frame_time)
 
 static struct demux_packet *video_read_frame(struct MPContext *mpctx)
 {
-    sh_video_t *sh_video = mpctx->sh_video;
-    demuxer_t *demuxer = sh_video->gsh->demuxer;
-    float pts1 = sh_video->last_pts;
+    struct dec_video *d_video = mpctx->d_video;
+    sh_video_t *sh_video = d_video->header->video;
+    demuxer_t *demuxer = d_video->header->demuxer;
+    float pts1 = d_video->last_pts;
 
-    struct demux_packet *pkt = demux_read_packet(sh_video->gsh);
+    struct demux_packet *pkt = demux_read_packet(d_video->header);
     if (!pkt)
         return NULL; // EOF
 
     if (pkt->pts != MP_NOPTS_VALUE)
-        sh_video->last_pts = pkt->pts;
+        d_video->last_pts = pkt->pts;
 
     float frame_time = sh_video->fps > 0 ? 1.0f / sh_video->fps : 0;
 
     // override frame_time for variable/unknown FPS formats:
     if (!mpctx->opts->force_fps) {
-        double next_pts = demux_get_next_pts(sh_video->gsh);
-        double d = next_pts == MP_NOPTS_VALUE ? sh_video->last_pts - pts1
-                                              : next_pts - sh_video->last_pts;
+        double next_pts = demux_get_next_pts(d_video->header);
+        double d = next_pts == MP_NOPTS_VALUE ? d_video->last_pts - pts1
+                                              : next_pts - d_video->last_pts;
         if (d >= 0) {
             if (demuxer->type == DEMUXER_TYPE_TV) {
                 if (d > 0)
@@ -296,20 +301,20 @@ static struct demux_packet *video_read_frame(struct MPContext *mpctx)
         }
     }
 
-    sh_video->pts = sh_video->last_pts;
-    sh_video->next_frame_time = frame_time;
+    d_video->pts = d_video->last_pts;
+    d_video->next_frame_time = frame_time;
     return pkt;
 }
 
 static double update_video_nocorrect_pts(struct MPContext *mpctx)
 {
-    struct sh_video *sh_video = mpctx->sh_video;
+    struct dec_video *d_video = mpctx->d_video;
     double frame_time = 0;
     while (1) {
         // In nocorrect-pts mode there is no way to properly time these frames
         if (load_next_vo_frame(mpctx, false))
             break;
-        frame_time = sh_video->next_frame_time;
+        frame_time = d_video->next_frame_time;
         if (mpctx->restart_playback)
             frame_time = 0;
         struct demux_packet *pkt = video_read_frame(mpctx);
@@ -321,8 +326,8 @@ static double update_video_nocorrect_pts(struct MPContext *mpctx)
         update_fps(mpctx);
         int framedrop_type = check_framedrop(mpctx, frame_time);
 
-        void *decoded_frame = decode_video(sh_video, pkt, framedrop_type,
-                                           sh_video->pts);
+        void *decoded_frame = video_decode(d_video, pkt, framedrop_type,
+                                           d_video->pts);
         talloc_free(pkt);
         if (decoded_frame) {
             filter_video(mpctx, decoded_frame);
@@ -334,62 +339,61 @@ static double update_video_nocorrect_pts(struct MPContext *mpctx)
 
 static double update_video_attached_pic(struct MPContext *mpctx)
 {
-    struct sh_video *sh_video = mpctx->sh_video;
+    struct dec_video *d_video = mpctx->d_video;
 
     // Try to decode the picture multiple times, until it is displayed.
     if (mpctx->video_out->hasframe)
         return -1;
 
     struct mp_image *decoded_frame =
-            decode_video(sh_video, sh_video->gsh->attached_picture, 0, 0);
+            video_decode(d_video, d_video->header->attached_picture, 0, 0);
     if (decoded_frame)
         filter_video(mpctx, decoded_frame);
     load_next_vo_frame(mpctx, true);
-    mpctx->sh_video->pts = MP_NOPTS_VALUE;
+    d_video->pts = MP_NOPTS_VALUE;
     return 0;
 }
 
 static void determine_frame_pts(struct MPContext *mpctx)
 {
-    struct sh_video *sh_video = mpctx->sh_video;
+    struct dec_video *d_video = mpctx->d_video;
     struct MPOpts *opts = mpctx->opts;
 
     if (opts->user_pts_assoc_mode)
-        sh_video->pts_assoc_mode = opts->user_pts_assoc_mode;
-    else if (sh_video->pts_assoc_mode == 0) {
-        if (mpctx->sh_video->gsh->demuxer->timestamp_type == TIMESTAMP_TYPE_PTS
-            && sh_video->codec_reordered_pts != MP_NOPTS_VALUE)
-            sh_video->pts_assoc_mode = 1;
+        d_video->pts_assoc_mode = opts->user_pts_assoc_mode;
+    else if (d_video->pts_assoc_mode == 0) {
+        if (d_video->header->demuxer->timestamp_type == TIMESTAMP_TYPE_PTS
+            && d_video->codec_reordered_pts != MP_NOPTS_VALUE)
+            d_video->pts_assoc_mode = 1;
         else
-            sh_video->pts_assoc_mode = 2;
+            d_video->pts_assoc_mode = 2;
     } else {
-        int probcount1 = sh_video->num_reordered_pts_problems;
-        int probcount2 = sh_video->num_sorted_pts_problems;
-        if (sh_video->pts_assoc_mode == 2) {
+        int probcount1 = d_video->num_reordered_pts_problems;
+        int probcount2 = d_video->num_sorted_pts_problems;
+        if (d_video->pts_assoc_mode == 2) {
             int tmp = probcount1;
             probcount1 = probcount2;
             probcount2 = tmp;
         }
         if (probcount1 >= probcount2 * 1.5 + 2) {
-            sh_video->pts_assoc_mode = 3 - sh_video->pts_assoc_mode;
+            d_video->pts_assoc_mode = 3 - d_video->pts_assoc_mode;
             MP_VERBOSE(mpctx, "Switching to pts association mode "
-                       "%d.\n", sh_video->pts_assoc_mode);
+                       "%d.\n", d_video->pts_assoc_mode);
         }
     }
-    sh_video->pts = sh_video->pts_assoc_mode == 1 ?
-                    sh_video->codec_reordered_pts : sh_video->sorted_pts;
+    d_video->pts = d_video->pts_assoc_mode == 1 ?
+                   d_video->codec_reordered_pts : d_video->sorted_pts;
 }
 
 double update_video(struct MPContext *mpctx, double endpts)
 {
-    struct sh_video *sh_video = mpctx->sh_video;
+    struct dec_video *d_video = mpctx->d_video;
     struct vo *video_out = mpctx->video_out;
-    sh_video->vfilter->control(sh_video->vfilter, VFCTRL_SET_OSD_OBJ,
-                               mpctx->osd); // for vf_sub
+    vf_control(d_video->vfilter, VFCTRL_SET_OSD_OBJ, mpctx->osd); // for vf_sub
     if (!mpctx->opts->correct_pts)
         return update_video_nocorrect_pts(mpctx);
 
-    if (sh_video->gsh->attached_picture)
+    if (d_video->header->attached_picture)
         return update_video_attached_pic(mpctx);
 
     double pts;
@@ -400,7 +404,7 @@ double update_video(struct MPContext *mpctx, double endpts)
         pts = MP_NOPTS_VALUE;
         struct demux_packet *pkt = NULL;
         while (1) {
-            pkt = demux_read_packet(mpctx->sh_video->gsh);
+            pkt = demux_read_packet(d_video->header);
             if (!pkt || pkt->len)
                 break;
             /* Packets with size 0 are assumed to not correspond to frames,
@@ -417,7 +421,7 @@ double update_video(struct MPContext *mpctx, double endpts)
         int framedrop_type = mpctx->hrseek_active && mpctx->hrseek_framedrop ?
                              1 : check_framedrop(mpctx, -1);
         struct mp_image *decoded_frame =
-            decode_video(sh_video, pkt, framedrop_type, pts);
+            video_decode(d_video, pkt, framedrop_type, pts);
         talloc_free(pkt);
         if (decoded_frame) {
             determine_frame_pts(mpctx);
@@ -436,9 +440,9 @@ double update_video(struct MPContext *mpctx, double endpts)
     if (pts == MP_NOPTS_VALUE) {
         MP_ERR(mpctx, "Video pts after filters MISSING\n");
         // Try to use decoder pts from before filters
-        pts = sh_video->pts;
+        pts = d_video->pts;
         if (pts == MP_NOPTS_VALUE)
-            pts = sh_video->last_pts;
+            pts = d_video->last_pts;
     }
     if (endpts == MP_NOPTS_VALUE || pts < endpts)
         add_frame_pts(mpctx, pts);
@@ -447,29 +451,29 @@ double update_video(struct MPContext *mpctx, double endpts)
         return 0;
     }
     mpctx->hrseek_active = false;
-    sh_video->pts = pts;
-    if (sh_video->last_pts == MP_NOPTS_VALUE)
-        sh_video->last_pts = sh_video->pts;
-    else if (sh_video->last_pts > sh_video->pts) {
+    d_video->pts = pts;
+    if (d_video->last_pts == MP_NOPTS_VALUE) {
+        d_video->last_pts = d_video->pts;
+    } else if (d_video->last_pts > d_video->pts) {
         MP_WARN(mpctx, "Decreasing video pts: %f < %f\n",
-                sh_video->pts, sh_video->last_pts);
+                d_video->pts, d_video->last_pts);
         /* If the difference in pts is small treat it as jitter around the
          * right value (possibly caused by incorrect timestamp ordering) and
          * just show this frame immediately after the last one.
          * Treat bigger differences as timestamp resets and start counting
          * timing of later frames from the position of this one. */
-        if (sh_video->last_pts - sh_video->pts > 0.5)
-            sh_video->last_pts = sh_video->pts;
+        if (d_video->last_pts - d_video->pts > 0.5)
+            d_video->last_pts = d_video->pts;
         else
-            sh_video->pts = sh_video->last_pts;
-    } else if (sh_video->pts >= sh_video->last_pts + 60) {
+            d_video->pts = d_video->last_pts;
+    } else if (d_video->pts >= d_video->last_pts + 60) {
         // Assume a PTS difference >= 60 seconds is a discontinuity.
         MP_WARN(mpctx, "Jump in video pts: %f -> %f\n",
-                sh_video->last_pts, sh_video->pts);
-        sh_video->last_pts = sh_video->pts;
+                d_video->last_pts, d_video->pts);
+        d_video->last_pts = d_video->pts;
     }
-    double frame_time = sh_video->pts - sh_video->last_pts;
-    sh_video->last_pts = sh_video->pts;
+    double frame_time = d_video->pts - d_video->last_pts;
+    d_video->last_pts = d_video->pts;
     if (mpctx->d_audio)
         mpctx->delay -= frame_time;
     return frame_time;
-- 
cgit v1.2.3