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.

6 files changed, 216 insertions, 187 deletions

diff --git a/video/decode/dec_video.c b/video/decode/dec_video.c
index e6f56a3d57..cdfbd816a9 100644
--- a/video/decode/dec_video.c
+++ b/video/decode/dec_video.c
@@ -56,17 +56,17 @@ const vd_functions_t * const mpcodecs_vd_drivers[] = {
     NULL
 };
 
-int vd_control(struct sh_video *sh_video, int cmd, void *arg)
+int video_vd_control(struct dec_video *d_video, int cmd, void *arg)
 {
-    const struct vd_functions *vd = sh_video->vd_driver;
+    const struct vd_functions *vd = d_video->vd_driver;
     if (vd)
-        return vd->control(sh_video, cmd, arg);
+        return vd->control(d_video, cmd, arg);
     return CONTROL_UNKNOWN;
 }
 
-int set_video_colors(sh_video_t *sh_video, const char *item, int value)
+int video_set_colors(struct dec_video *d_video, const char *item, int value)
 {
-    vf_instance_t *vf = sh_video->vfilter;
+    vf_instance_t *vf = d_video->vfilter;
     vf_equalizer_t data;
 
     data.item = item;
@@ -83,9 +83,9 @@ int set_video_colors(sh_video_t *sh_video, const char *item, int value)
     return 0;
 }
 
-int get_video_colors(sh_video_t *sh_video, const char *item, int *value)
+int video_get_colors(struct dec_video *d_video, const char *item, int *value)
 {
-    vf_instance_t *vf = sh_video->vfilter;
+    vf_instance_t *vf = d_video->vfilter;
     vf_equalizer_t data;
 
     data.item = item;
@@ -101,55 +101,48 @@ int get_video_colors(sh_video_t *sh_video, const char *item, int *value)
     return 0;
 }
 
-void resync_video_stream(sh_video_t *sh_video)
+void video_resync_stream(struct dec_video *d_video)
 {
-    vd_control(sh_video, VDCTRL_RESYNC_STREAM, NULL);
-    sh_video->prev_codec_reordered_pts = MP_NOPTS_VALUE;
-    sh_video->prev_sorted_pts = MP_NOPTS_VALUE;
+    video_vd_control(d_video, VDCTRL_RESYNC_STREAM, NULL);
+    d_video->prev_codec_reordered_pts = MP_NOPTS_VALUE;
+    d_video->prev_sorted_pts = MP_NOPTS_VALUE;
 }
 
-void video_reinit_vo(struct sh_video *sh_video)
+void video_reinit_vo(struct dec_video *d_video)
 {
-    vd_control(sh_video, VDCTRL_REINIT_VO, NULL);
+    video_vd_control(d_video, VDCTRL_REINIT_VO, NULL);
 }
 
-int get_current_video_decoder_lag(sh_video_t *sh_video)
+void video_uninit(struct dec_video *d_video)
 {
-    int ret = -1;
-    vd_control(sh_video, VDCTRL_QUERY_UNSEEN_FRAMES, &ret);
-    return ret;
-}
-
-void uninit_video(sh_video_t *sh_video)
-{
-    if (!sh_video->initialized)
-        return;
-    mp_tmsg(MSGT_DECVIDEO, MSGL_V, "Uninit video.\n");
-    sh_video->vd_driver->uninit(sh_video);
-    vf_uninit_filter_chain(sh_video->vfilter);
-    sh_video->vfilter = NULL;
-    talloc_free(sh_video->gsh->decoder_desc);
-    sh_video->gsh->decoder_desc = NULL;
-    sh_video->initialized = 0;
+    if (d_video->initialized) {
+        mp_tmsg(MSGT_DECVIDEO, MSGL_V, "Uninit video.\n");
+        d_video->vd_driver->uninit(d_video);
+    }
+    talloc_free(d_video->priv);
+    d_video->priv = NULL;
+    vf_uninit_filter_chain(d_video->vfilter);
+    d_video->vfilter = NULL;
+    talloc_free(d_video);
 }
 
-static int init_video_codec(sh_video_t *sh_video, const char *decoder)
+static int init_video_codec(struct dec_video *d_video, const char *decoder)
 {
-    assert(!sh_video->initialized);
+    assert(!d_video->initialized);
 
-    if (!sh_video->vd_driver->init(sh_video, decoder)) {
+    if (!d_video->vd_driver->init(d_video, decoder)) {
         mp_tmsg(MSGT_DECVIDEO, MSGL_V, "Video decoder init failed.\n");
-        //uninit_video(sh_video);
+        //uninit_video(d_video);
         return 0;
     }
 
-    sh_video->initialized = 1;
-    sh_video->prev_codec_reordered_pts = MP_NOPTS_VALUE;
-    sh_video->prev_sorted_pts = MP_NOPTS_VALUE;
+    d_video->initialized = 1;
+    d_video->prev_codec_reordered_pts = MP_NOPTS_VALUE;
+    d_video->prev_sorted_pts = MP_NOPTS_VALUE;
     return 1;
 }
 
-struct mp_decoder_list *mp_video_decoder_list(void)
+struct mp_decoder_list *video_decoder_list(void)
 {
     struct mp_decoder_list *list = talloc_zero(NULL, struct mp_decoder_list);
     for (int i = 0; mpcodecs_vd_drivers[i] != NULL; i++)
@@ -160,7 +153,7 @@ struct mp_decoder_list *mp_video_decoder_list(void)
 static struct mp_decoder_list *mp_select_video_decoders(const char *codec,
                                                         char *selection)
 {
-    struct mp_decoder_list *list = mp_video_decoder_list();
+    struct mp_decoder_list *list = video_decoder_list();
     struct mp_decoder_list *new = mp_select_decoders(list, codec, selection);
     talloc_free(list);
     return new;
@@ -175,13 +168,13 @@ static const struct vd_functions *find_driver(const char *name)
     return NULL;
 }
 
-int init_best_video_codec(sh_video_t *sh_video, char* video_decoders)
+int video_init_best_codec(struct dec_video *d_video, char* video_decoders)
 {
-    assert(!sh_video->initialized);
+    assert(!d_video->initialized);
 
     struct mp_decoder_entry *decoder = NULL;
     struct mp_decoder_list *list =
-        mp_select_video_decoders(sh_video->gsh->codec, video_decoders);
+        mp_select_video_decoders(d_video->header->codec, video_decoders);
 
     mp_print_decoders(MSGT_DECVIDEO, MSGL_V, "Codec list:", list);
 
@@ -192,42 +185,43 @@ int init_best_video_codec(sh_video_t *sh_video, char* video_decoders)
             continue;
         mp_tmsg(MSGT_DECVIDEO, MSGL_V, "Opening video decoder %s:%s\n",
                 sel->family, sel->decoder);
-        sh_video->vd_driver = driver;
-        if (init_video_codec(sh_video, sel->decoder)) {
+        d_video->vd_driver = driver;
+        if (init_video_codec(d_video, sel->decoder)) {
             decoder = sel;
             break;
         }
-        sh_video->vd_driver = NULL;
+        d_video->vd_driver = NULL;
         mp_tmsg(MSGT_DECVIDEO, MSGL_WARN, "Video decoder init failed for "
                 "%s:%s\n", sel->family, sel->decoder);
     }
 
-    if (sh_video->initialized) {
-        sh_video->gsh->decoder_desc =
-            talloc_asprintf(NULL, "%s [%s:%s]", decoder->desc, decoder->family,
+    if (d_video->initialized) {
+        d_video->decoder_desc =
+            talloc_asprintf(d_video, "%s [%s:%s]", decoder->desc, decoder->family,
                             decoder->decoder);
         mp_msg(MSGT_DECVIDEO, MSGL_INFO, "Selected video codec: %s\n",
-               sh_video->gsh->decoder_desc);
+               d_video->decoder_desc);
     } else {
         mp_msg(MSGT_DECVIDEO, MSGL_ERR,
                "Failed to initialize a video decoder for codec '%s'.\n",
-               sh_video->gsh->codec ? sh_video->gsh->codec : "<unknown>");
+               d_video->header->codec ? d_video->header->codec : "<unknown>");
     }
 
     talloc_free(list);
-    return sh_video->initialized;
+    return d_video->initialized;
 }
 
-void *decode_video(sh_video_t *sh_video, struct demux_packet *packet,
+void *video_decode(struct dec_video *d_video, struct demux_packet *packet,
                    int drop_frame, double pts)
 {
     mp_image_t *mpi = NULL;
-    struct MPOpts *opts = sh_video->opts;
+    struct MPOpts *opts = d_video->opts;
 
     if (opts->correct_pts && pts != MP_NOPTS_VALUE) {
-        int delay = get_current_video_decoder_lag(sh_video);
+        int delay = -1;
+        video_vd_control(d_video, VDCTRL_QUERY_UNSEEN_FRAMES, &delay);
         if (delay >= 0) {
-            if (delay > sh_video->num_buffered_pts)
+            if (delay > d_video->num_buffered_pts)
 #if 0
                 // this is disabled because vd_ffmpeg reports the same lag
                 // after seek even when there are no buffered frames,
@@ -237,24 +231,24 @@ void *decode_video(sh_video_t *sh_video, struct demux_packet *packet,
                 ;
 #endif
             else
-                sh_video->num_buffered_pts = delay;
+                d_video->num_buffered_pts = delay;
         }
-        if (sh_video->num_buffered_pts ==
-            sizeof(sh_video->buffered_pts) / sizeof(double))
+        if (d_video->num_buffered_pts ==
+            sizeof(d_video->buffered_pts) / sizeof(double))
             mp_msg(MSGT_DECVIDEO, MSGL_ERR, "Too many buffered pts\n");
         else {
             int i, j;
-            for (i = 0; i < sh_video->num_buffered_pts; i++)
-                if (sh_video->buffered_pts[i] < pts)
+            for (i = 0; i < d_video->num_buffered_pts; i++)
+                if (d_video->buffered_pts[i] < pts)
                     break;
-            for (j = sh_video->num_buffered_pts; j > i; j--)
-                sh_video->buffered_pts[j] = sh_video->buffered_pts[j - 1];
-            sh_video->buffered_pts[i] = pts;
-            sh_video->num_buffered_pts++;
+            for (j = d_video->num_buffered_pts; j > i; j--)
+                d_video->buffered_pts[j] = d_video->buffered_pts[j - 1];
+            d_video->buffered_pts[i] = pts;
+            d_video->num_buffered_pts++;
         }
     }
 
-    mpi = sh_video->vd_driver->decode(sh_video, packet, drop_frame, &pts);
+    mpi = d_video->vd_driver->decode(d_video, packet, drop_frame, &pts);
 
     //------------------------ frame decoded. --------------------
 
@@ -268,39 +262,41 @@ void *decode_video(sh_video_t *sh_video, struct demux_packet *packet,
     else if (opts->field_dominance == 1)
         mpi->fields &= ~MP_IMGFIELD_TOP_FIRST;
 
-    double prevpts = sh_video->codec_reordered_pts;
-    sh_video->prev_codec_reordered_pts = prevpts;
-    sh_video->codec_reordered_pts = pts;
+    double prevpts = d_video->codec_reordered_pts;
+    d_video->prev_codec_reordered_pts = prevpts;
+    d_video->codec_reordered_pts = pts;
     if (prevpts != MP_NOPTS_VALUE && pts <= prevpts
         || pts == MP_NOPTS_VALUE)
-        sh_video->num_reordered_pts_problems++;
-    prevpts = sh_video->sorted_pts;
+        d_video->num_reordered_pts_problems++;
+    prevpts = d_video->sorted_pts;
     if (opts->correct_pts) {
-        if (sh_video->num_buffered_pts) {
-            sh_video->num_buffered_pts--;
-            sh_video->sorted_pts =
-                sh_video->buffered_pts[sh_video->num_buffered_pts];
+        if (d_video->num_buffered_pts) {
+            d_video->num_buffered_pts--;
+            d_video->sorted_pts =
+                d_video->buffered_pts[d_video->num_buffered_pts];
         } else {
             mp_msg(MSGT_CPLAYER, MSGL_ERR,
                    "No pts value from demuxer to use for frame!\n");
-            sh_video->sorted_pts = MP_NOPTS_VALUE;
+            d_video->sorted_pts = MP_NOPTS_VALUE;
         }
     }
-    pts = sh_video->sorted_pts;
+    pts = d_video->sorted_pts;
     if (prevpts != MP_NOPTS_VALUE && pts <= prevpts
         || pts == MP_NOPTS_VALUE)
-        sh_video->num_sorted_pts_problems++;
+        d_video->num_sorted_pts_problems++;
     return mpi;
 }
 
-int mpcodecs_reconfig_vo(sh_video_t *sh, const struct mp_image_params *params)
+int mpcodecs_reconfig_vo(struct dec_video *d_video,
+                         const struct mp_image_params *params)
 {
-    struct MPOpts *opts = sh->opts;
-    vf_instance_t *vf = sh->vfilter;
+    struct MPOpts *opts = d_video->opts;
+    vf_instance_t *vf = d_video->vfilter;
     int vocfg_flags = 0;
     struct mp_image_params p = *params;
+    struct sh_video *sh = d_video->header->video;
 
-    sh->vf_reconfig_count++;
+    d_video->vf_reconfig_count++;
 
     mp_msg(MSGT_DECVIDEO, MSGL_V,
            "VIDEO:  %dx%d  %5.3f fps  %5.1f kbps (%4.1f kB/s)\n",
@@ -336,24 +332,24 @@ int mpcodecs_reconfig_vo(sh_video_t *sh, const struct mp_image_params *params)
             "e.g. -vf filter,scale instead of -vf filter.\n");
         mp_tmsg(MSGT_VFILTER, MSGL_WARN, "Attempted filter chain:\n");
         vf_print_filter_chain(MSGL_WARN, vf);
-        sh->vf_initialized = -1;
+        d_video->vf_initialized = -1;
         return -1;               // failed
     }
-    sh->vfilter = vf;
+    d_video->vfilter = vf;
 
     // autodetect flipping
     bool flip = opts->flip;
     if (flip && !(flags & VFCAP_FLIP)) {
         // we need to flip, but no flipping filter avail.
         vf_add_before_vo(&vf, "flip", NULL);
-        sh->vfilter = vf;
+        d_video->vfilter = vf;
         flip = false;
     }
     // time to do aspect ratio corrections...
 
     float force_aspect = opts->movie_aspect;
-    if (force_aspect > -1.0 && sh->stream_aspect != 0.0)
-        force_aspect = sh->stream_aspect;
+    if (force_aspect > -1.0 && d_video->stream_aspect != 0.0)
+        force_aspect = d_video->stream_aspect;
 
     if (force_aspect >= 0)
         vf_set_dar(&p.d_w, &p.d_h, p.w, p.h, force_aspect);
@@ -386,29 +382,29 @@ int mpcodecs_reconfig_vo(sh_video_t *sh, const struct mp_image_params *params)
 
     if (vf_reconfig_wrapper(vf, &p, vocfg_flags) < 0) {
         mp_tmsg(MSGT_CPLAYER, MSGL_WARN, "FATAL: Cannot initialize video driver.\n");
-        sh->vf_initialized = -1;
+        d_video->vf_initialized = -1;
         return -1;
     }
 
     mp_tmsg(MSGT_VFILTER, MSGL_V, "Video filter chain:\n");
     vf_print_filter_chain(MSGL_V, vf);
 
-    sh->vf_initialized = 1;
+    d_video->vf_initialized = 1;
 
-    if (!sh->vf_input)
-        sh->vf_input = talloc(sh, struct mp_image_params);
-    *sh->vf_input = p;
+    if (!d_video->vf_input)
+        d_video->vf_input = talloc(sh, struct mp_image_params);
+    *d_video->vf_input = p;
 
     if (opts->gamma_gamma != 1000)
-        set_video_colors(sh, "gamma", opts->gamma_gamma);
+        video_set_colors(d_video, "gamma", opts->gamma_gamma);
     if (opts->gamma_brightness != 1000)
-        set_video_colors(sh, "brightness", opts->gamma_brightness);
+        video_set_colors(d_video, "brightness", opts->gamma_brightness);
     if (opts->gamma_contrast != 1000)
-        set_video_colors(sh, "contrast", opts->gamma_contrast);
+        video_set_colors(d_video, "contrast", opts->gamma_contrast);
     if (opts->gamma_saturation != 1000)
-        set_video_colors(sh, "saturation", opts->gamma_saturation);
+        video_set_colors(d_video, "saturation", opts->gamma_saturation);
     if (opts->gamma_hue != 1000)
-        set_video_colors(sh, "hue", opts->gamma_hue);
+        video_set_colors(d_video, "hue", opts->gamma_hue);
 
     return 0;
 }
diff --git a/video/decode/dec_video.h b/video/decode/dec_video.h
index 3f163bb1f7..b706910e5b 100644
--- a/video/decode/dec_video.h
+++ b/video/decode/dec_video.h
@@ -20,24 +20,57 @@
 #define MPLAYER_DEC_VIDEO_H
 
 #include "demux/stheader.h"
+#include "video/hwdec.h"
+#include "video/mp_image.h"
 
 struct osd_state;
 struct mp_decoder_list;
 
-struct mp_decoder_list *mp_video_decoder_list(void);
+struct dec_video {
+    struct MPOpts *opts;
+    struct vf_instance *vfilter;  // video filter chain
+    const struct vd_functions *vd_driver;
+    int vf_initialized;   // -1 failed, 0 not done, 1 done
+    long vf_reconfig_count; // incremented each mpcodecs_reconfig_vo() call
+    struct mp_image_params *vf_input; // video filter input params
+    struct mp_hwdec_info *hwdec_info; // video output hwdec handles
+    int initialized;
+    struct sh_stream *header;
 
-int init_best_video_codec(sh_video_t *sh_video, char* video_decoders);
-void uninit_video(sh_video_t *sh_video);
+    char *decoder_desc;
+
+    void *priv;
+
+    float next_frame_time;
+    double last_pts;
+    double buffered_pts[32];
+    int num_buffered_pts;
+    double codec_reordered_pts;
+    double prev_codec_reordered_pts;
+    int num_reordered_pts_problems;
+    double sorted_pts;
+    double prev_sorted_pts;
+    int num_sorted_pts_problems;
+    int pts_assoc_mode;
+    double pts;
+
+    float stream_aspect;  // aspect ratio in media headers (DVD IFO files)
+    int i_bps;            // == bitrate  (compressed bytes/sec)
+};
+
+struct mp_decoder_list *video_decoder_list(void);
+
+int video_init_best_codec(struct dec_video *d_video, char* video_decoders);
+void video_uninit(struct dec_video *d_video);
 
 struct demux_packet;
-void *decode_video(sh_video_t *sh_video, struct demux_packet *packet,
+void *video_decode(struct dec_video *d_video, struct demux_packet *packet,
                    int drop_frame, double pts);
 
-int get_video_colors(sh_video_t *sh_video, const char *item, int *value);
-int set_video_colors(sh_video_t *sh_video, const char *item, int value);
-void resync_video_stream(sh_video_t *sh_video);
-void video_reinit_vo(struct sh_video *sh_video);
-int get_current_video_decoder_lag(sh_video_t *sh_video);
-int vd_control(struct sh_video *sh_video, int cmd, void *arg);
+int video_get_colors(struct dec_video *d_video, const char *item, int *value);
+int video_set_colors(struct dec_video *d_video, const char *item, int value);
+void video_resync_stream(struct dec_video *d_video);
+void video_reinit_vo(struct dec_video *d_video);
+int video_vd_control(struct dec_video *d_video, int cmd, void *arg);
 
 #endif /* MPLAYER_DEC_VIDEO_H */
diff --git a/video/decode/lavc_dr1.c b/video/decode/lavc_dr1.c
index 15fc44a445..a8de29eb1a 100644
--- a/video/decode/lavc_dr1.c
+++ b/video/decode/lavc_dr1.c
@@ -136,8 +136,8 @@ static int alloc_buffer(FramePool *pool, AVCodecContext *s)
 
 int mp_codec_get_buffer(AVCodecContext *s, AVFrame *frame)
 {
-    sh_video_t *sh = s->opaque;
-    struct lavc_ctx *ctx = sh->context;
+    struct dec_video *vd = s->opaque;
+    struct lavc_ctx *ctx = vd->priv;
 
     if (!ctx->dr1_buffer_pool) {
         ctx->dr1_buffer_pool = av_mallocz(sizeof(*ctx->dr1_buffer_pool));
diff --git a/video/decode/vd.h b/video/decode/vd.h
index 488f9fa061..dd2536ab2a 100644
--- a/video/decode/vd.h
+++ b/video/decode/vd.h
@@ -21,6 +21,7 @@
 
 #include "video/mp_image.h"
 #include "demux/stheader.h"
+#include "dec_video.h"
 
 struct demux_packet;
 struct mp_decoder_list;
@@ -30,10 +31,10 @@ typedef struct vd_functions
 {
     const char *name;
     void (*add_decoders)(struct mp_decoder_list *list);
-    int (*init)(sh_video_t *sh, const char *decoder);
-    void (*uninit)(sh_video_t *sh);
-    int (*control)(sh_video_t *sh, int cmd, void *arg);
-    struct mp_image *(*decode)(struct sh_video *sh, struct demux_packet *pkt,
+    int (*init)(struct dec_video *vd, const char *decoder);
+    void (*uninit)(struct dec_video *vd);
+    int (*control)(struct dec_video *vd, int cmd, void *arg);
+    struct mp_image *(*decode)(struct dec_video *vd, struct demux_packet *pkt,
                                int flags, double *reordered_pts);
 } vd_functions_t;
 
@@ -47,6 +48,6 @@ enum vd_ctrl {
     VDCTRL_REINIT_VO, // reinit filter/VO chain
 };
 
-int mpcodecs_reconfig_vo(sh_video_t *sh, const struct mp_image_params *params);
+int mpcodecs_reconfig_vo(struct dec_video *vd, const struct mp_image_params *params);
 
 #endif /* MPLAYER_VD_H */
diff --git a/video/decode/vd_lavc.c b/video/decode/vd_lavc.c
index e6ed8e5602..f7768f130f 100644
--- a/video/decode/vd_lavc.c
+++ b/video/decode/vd_lavc.c
@@ -60,15 +60,15 @@
 
 #include "mpvcore/m_option.h"
 
-static void init_avctx(sh_video_t *sh, const char *decoder,
+static void init_avctx(struct dec_video *vd, const char *decoder,
                        struct vd_lavc_hwdec *hwdec);
-static void uninit_avctx(sh_video_t *sh);
+static void uninit_avctx(struct dec_video *vd);
 static void setup_refcounting_hw(struct AVCodecContext *s);
 
 static enum PixelFormat get_format_hwdec(struct AVCodecContext *avctx,
                                          const enum PixelFormat *pix_fmt);
 
-static void uninit(struct sh_video *sh);
+static void uninit(struct dec_video *vd);
 
 #define OPT_BASE_STRUCT struct MPOpts
 
@@ -116,9 +116,9 @@ static struct vd_lavc_hwdec *find_hwcodec(enum hwdec_type api)
     return NULL;
 }
 
-static bool hwdec_codec_allowed(sh_video_t *sh, const char *codec)
+static bool hwdec_codec_allowed(struct dec_video *vd, const char *codec)
 {
-    bstr s = bstr0(sh->opts->hwdec_codecs);
+    bstr s = bstr0(vd->opts->hwdec_codecs);
     while (s.len) {
         bstr item;
         bstr_split_tok(s, ",", &item, &s);
@@ -213,7 +213,7 @@ static int hwdec_probe(struct vd_lavc_hwdec *hwdec, struct mp_hwdec_info *info,
     return r;
 }
 
-static bool probe_hwdec(sh_video_t *sh, bool autoprobe, enum hwdec_type api,
+static bool probe_hwdec(struct dec_video *vd, bool autoprobe, enum hwdec_type api,
                         const char *decoder, struct vd_lavc_hwdec **use_hwdec,
                         const char **use_decoder)
 {
@@ -224,7 +224,7 @@ static bool probe_hwdec(sh_video_t *sh, bool autoprobe, enum hwdec_type api,
         return false;
     }
     const char *hw_decoder = NULL;
-    int r = hwdec_probe(hwdec, sh->hwdec_info, decoder, &hw_decoder);
+    int r = hwdec_probe(hwdec, vd->hwdec_info, decoder, &hw_decoder);
     if (r >= 0) {
         *use_hwdec = hwdec;
         *use_decoder = hw_decoder;
@@ -240,11 +240,11 @@ static bool probe_hwdec(sh_video_t *sh, bool autoprobe, enum hwdec_type api,
 }
 
 
-static int init(sh_video_t *sh, const char *decoder)
+static int init(struct dec_video *vd, const char *decoder)
 {
     vd_ffmpeg_ctx *ctx;
-    ctx = sh->context = talloc_zero(NULL, vd_ffmpeg_ctx);
-    ctx->opts = sh->opts;
+    ctx = vd->priv = talloc_zero(NULL, vd_ffmpeg_ctx);
+    ctx->opts = vd->opts;
     ctx->non_dr1_pool = talloc_steal(ctx, mp_image_pool_new(16));
 
     if (bstr_endswith0(bstr0(decoder), "_vdpau")) {
@@ -254,22 +254,22 @@ static int init(sh_video_t *sh, const char *decoder)
                 "option can be used to restrict which codecs are\nenabled, "
                 "otherwise all hardware decoding is tried for all codecs.\n",
                 decoder);
-        uninit(sh);
+        uninit(vd);
         return 0;
     }
 
     struct vd_lavc_hwdec *hwdec = NULL;
     const char *hw_decoder = NULL;
 
-    if (hwdec_codec_allowed(sh, decoder)) {
-        if (sh->opts->hwdec_api == HWDEC_AUTO) {
+    if (hwdec_codec_allowed(vd, decoder)) {
+        if (vd->opts->hwdec_api == HWDEC_AUTO) {
             for (int n = 0; hwdec_list[n]; n++) {
-                if (probe_hwdec(sh, true, hwdec_list[n]->type, decoder,
+                if (probe_hwdec(vd, true, hwdec_list[n]->type, decoder,
                     &hwdec, &hw_decoder))
                     break;
             }
-        } else if (sh->opts->hwdec_api != HWDEC_NONE) {
-            probe_hwdec(sh, false, sh->opts->hwdec_api, decoder,
+        } else if (vd->opts->hwdec_api != HWDEC_NONE) {
+            probe_hwdec(vd, false, vd->opts->hwdec_api, decoder,
                         &hwdec, &hw_decoder);
         }
     } else {
@@ -282,21 +282,21 @@ static int init(sh_video_t *sh, const char *decoder)
         if (hw_decoder)
             decoder = hw_decoder;
         mp_tmsg(MSGT_DECVIDEO, MSGL_INFO, "Trying to use hardware decoding.\n");
-    } else if (sh->opts->hwdec_api != HWDEC_NONE) {
+    } else if (vd->opts->hwdec_api != HWDEC_NONE) {
         mp_tmsg(MSGT_DECVIDEO, MSGL_INFO, "Using software decoding.\n");
     }
 
-    init_avctx(sh, decoder, hwdec);
+    init_avctx(vd, decoder, hwdec);
     if (!ctx->avctx) {
         if (ctx->software_fallback_decoder) {
             mp_tmsg(MSGT_DECVIDEO, MSGL_ERR, "Error initializing hardware "
                     "decoding, falling back to software decoding.\n");
             decoder = ctx->software_fallback_decoder;
             ctx->software_fallback_decoder = NULL;
-            init_avctx(sh, decoder, NULL);
+            init_avctx(vd, decoder, NULL);
         }
         if (!ctx->avctx) {
-            uninit(sh);
+            uninit(vd);
             return 0;
         }
     }
@@ -361,12 +361,13 @@ static void set_from_bih(AVCodecContext *avctx, uint32_t format,
     avctx->coded_height = bih->biHeight;
 }
 
-static void init_avctx(sh_video_t *sh, const char *decoder,
+static void init_avctx(struct dec_video *vd, const char *decoder,
                        struct vd_lavc_hwdec *hwdec)
 {
-    vd_ffmpeg_ctx *ctx = sh->context;
-    struct lavc_param *lavc_param = &sh->opts->lavc_param;
+    vd_ffmpeg_ctx *ctx = vd->priv;
+    struct lavc_param *lavc_param = &vd->opts->lavc_param;
     bool mp_rawvideo = false;
+    struct sh_stream *sh = vd->header;
 
     assert(!ctx->avctx);
 
@@ -379,7 +380,7 @@ static void init_avctx(sh_video_t *sh, const char *decoder,
     if (!lavc_codec)
         return;
 
-    ctx->hwdec_info = sh->hwdec_info;
+    ctx->hwdec_info = vd->hwdec_info;
 
     ctx->do_dr1 = ctx->do_hw_dr1 = 0;
     ctx->pix_fmt = PIX_FMT_NONE;
@@ -388,7 +389,7 @@ static void init_avctx(sh_video_t *sh, const char *decoder,
     ctx->hwdec = hwdec;
     ctx->avctx = avcodec_alloc_context3(lavc_codec);
     AVCodecContext *avctx = ctx->avctx;
-    avctx->opaque = sh;
+    avctx->opaque = vd;
     avctx->codec_type = AVMEDIA_TYPE_VIDEO;
     avctx->codec_id = lavc_codec->id;
 
@@ -409,7 +410,7 @@ static void init_avctx(sh_video_t *sh, const char *decoder,
             avctx->get_format  = get_format_hwdec;
         setup_refcounting_hw(avctx);
         if (ctx->hwdec->init && ctx->hwdec->init(ctx) < 0) {
-            uninit_avctx(sh);
+            uninit_avctx(vd);
             return;
         }
     } else {
@@ -445,7 +446,7 @@ static void init_avctx(sh_video_t *sh, const char *decoder,
             mp_msg(MSGT_DECVIDEO, MSGL_ERR,
                    "Your options /%s/ look like gibberish to me pal\n",
                    lavc_param->avopt);
-            uninit_avctx(sh);
+            uninit_avctx(vd);
             return;
         }
     }
@@ -453,33 +454,33 @@ static void init_avctx(sh_video_t *sh, const char *decoder,
     // Do this after the above avopt handling in case it changes values
     ctx->skip_frame = avctx->skip_frame;
 
-    avctx->codec_tag = sh->format;
-    avctx->coded_width  = sh->disp_w;
-    avctx->coded_height = sh->disp_h;
+    avctx->codec_tag = sh->video->format;
+    avctx->coded_width  = sh->video->disp_w;
+    avctx->coded_height = sh->video->disp_h;
 
     // demux_mkv
-    if (sh->bih)
-        set_from_bih(avctx, sh->format, sh->bih);
+    if (sh->video->bih)
+        set_from_bih(avctx, sh->video->format, sh->video->bih);
 
-    if (mp_rawvideo && sh->format >= IMGFMT_START && sh->format < IMGFMT_END) {
-        avctx->pix_fmt = imgfmt2pixfmt(sh->format);
+    if (mp_rawvideo) {
+        avctx->pix_fmt = imgfmt2pixfmt(sh->video->format);
         avctx->codec_tag = 0;
     }
 
-    if (sh->gsh->lav_headers)
-        mp_copy_lav_codec_headers(avctx, sh->gsh->lav_headers);
+    if (sh->lav_headers)
+        mp_copy_lav_codec_headers(avctx, sh->lav_headers);
 
     /* open it */
     if (avcodec_open2(avctx, lavc_codec, NULL) < 0) {
         mp_tmsg(MSGT_DECVIDEO, MSGL_ERR, "Could not open codec.\n");
-        uninit_avctx(sh);
+        uninit_avctx(vd);
         return;
     }
 }
 
-static void uninit_avctx(sh_video_t *sh)
+static void uninit_avctx(struct dec_video *vd)
 {
-    vd_ffmpeg_ctx *ctx = sh->context;
+    vd_ffmpeg_ctx *ctx = vd->priv;
     AVCodecContext *avctx = ctx->avctx;
 
     if (avctx) {
@@ -504,21 +505,19 @@ static void uninit_avctx(sh_video_t *sh)
     ctx->last_sample_aspect_ratio = (AVRational){0, 0};
 }
 
-static void uninit(sh_video_t *sh)
+static void uninit(struct dec_video *vd)
 {
-    vd_ffmpeg_ctx *ctx = sh->context;
-
-    uninit_avctx(sh);
-    talloc_free(ctx);
+    uninit_avctx(vd);
 }
 
-static void update_image_params(sh_video_t *sh, AVFrame *frame)
+static void update_image_params(struct dec_video *vd, AVFrame *frame)
 {
-    vd_ffmpeg_ctx *ctx = sh->context;
+    vd_ffmpeg_ctx *ctx = vd->priv;
     int width = frame->width;
     int height = frame->height;
     float aspect = av_q2d(frame->sample_aspect_ratio) * width / height;
     int pix_fmt = frame->format;
+    struct sh_video *sh = vd->header->video;
 
 #if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(54, 40, 0)
     pix_fmt = ctx->avctx->pix_fmt;
@@ -566,8 +565,8 @@ static void update_image_params(sh_video_t *sh, AVFrame *frame)
 static enum PixelFormat get_format_hwdec(struct AVCodecContext *avctx,
                                          const enum PixelFormat *fmt)
 {
-    sh_video_t *sh = avctx->opaque;
-    vd_ffmpeg_ctx *ctx = sh->context;
+    struct dec_video *vd = avctx->opaque;
+    vd_ffmpeg_ctx *ctx = vd->priv;
 
     mp_msg(MSGT_DECVIDEO, MSGL_V, "Pixel formats supported by decoder:");
     for (int i = 0; fmt[i] != PIX_FMT_NONE; i++)
@@ -587,9 +586,9 @@ static enum PixelFormat get_format_hwdec(struct AVCodecContext *avctx,
     return PIX_FMT_NONE;
 }
 
-static struct mp_image *get_surface_hwdec(struct sh_video *sh, AVFrame *pic)
+static struct mp_image *get_surface_hwdec(struct dec_video *vd, AVFrame *pic)
 {
-    vd_ffmpeg_ctx *ctx = sh->context;
+    vd_ffmpeg_ctx *ctx = vd->priv;
 
     /* Decoders using ffmpeg's hwaccel architecture (everything except vdpau)
      * can fall back to software decoding automatically. However, we don't
@@ -633,9 +632,9 @@ static void free_mpi(void *opaque, uint8_t *data)
 
 static int get_buffer2_hwdec(AVCodecContext *avctx, AVFrame *pic, int flags)
 {
-    sh_video_t *sh = avctx->opaque;
+    struct dec_video *vd = avctx->opaque;
 
-    struct mp_image *mpi = get_surface_hwdec(sh, pic);
+    struct mp_image *mpi = get_surface_hwdec(vd, pic);
     if (!mpi)
         return -1;
 
@@ -653,9 +652,9 @@ static void setup_refcounting_hw(AVCodecContext *avctx)
 
 static int get_buffer_hwdec(AVCodecContext *avctx, AVFrame *pic)
 {
-    sh_video_t *sh = avctx->opaque;
+    struct dec_video *vd = avctx->opaque;
 
-    struct mp_image *mpi = get_surface_hwdec(sh, pic);
+    struct mp_image *mpi = get_surface_hwdec(vd, pic);
     if (!mpi)
         return -1;
 
@@ -694,9 +693,9 @@ static void setup_refcounting_hw(AVCodecContext *avctx)
 
 #if HAVE_AVUTIL_REFCOUNTING
 
-static struct mp_image *image_from_decoder(struct sh_video *sh)
+static struct mp_image *image_from_decoder(struct dec_video *vd)
 {
-    vd_ffmpeg_ctx *ctx = sh->context;
+    vd_ffmpeg_ctx *ctx = vd->priv;
     AVFrame *pic = ctx->pic;
 
     struct mp_image *img = mp_image_from_av_frame(pic);
@@ -722,9 +721,9 @@ static bool fb_is_unique(void *b)
     return mp_buffer_is_unique(b);
 }
 
-static struct mp_image *image_from_decoder(struct sh_video *sh)
+static struct mp_image *image_from_decoder(struct dec_video *vd)
 {
-    vd_ffmpeg_ctx *ctx = sh->context;
+    vd_ffmpeg_ctx *ctx = vd->priv;
     AVFrame *pic = ctx->pic;
 
     struct mp_image new = {0};
@@ -749,12 +748,12 @@ static struct mp_image *image_from_decoder(struct sh_video *sh)
 
 #endif /* HAVE_AVUTIL_REFCOUNTING */
 
-static int decode(struct sh_video *sh, struct demux_packet *packet,
+static int decode(struct dec_video *vd, struct demux_packet *packet,
                   int flags, double *reordered_pts, struct mp_image **out_image)
 {
     int got_picture = 0;
     int ret;
-    vd_ffmpeg_ctx *ctx = sh->context;
+    vd_ffmpeg_ctx *ctx = vd->priv;
     AVFrame *pic = ctx->pic;
     AVCodecContext *avctx = ctx->avctx;
     AVPacket pkt;
@@ -781,9 +780,9 @@ static int decode(struct sh_video *sh, struct demux_packet *packet,
     if (!got_picture)
         return 0;                     // skipped image
 
-    update_image_params(sh, pic);
+    update_image_params(vd, pic);
 
-    struct mp_image *mpi = image_from_decoder(sh);
+    struct mp_image *mpi = image_from_decoder(vd);
     assert(mpi->planes[0]);
     mp_image_set_params(mpi, &ctx->image_params);
 
@@ -794,7 +793,7 @@ static int decode(struct sh_video *sh, struct demux_packet *packet,
     mp_image_params_from_image(&vo_params, mpi);
 
     if (!mp_image_params_equals(&vo_params, &ctx->vo_image_params)) {
-        if (mpcodecs_reconfig_vo(sh, &vo_params) < 0) {
+        if (mpcodecs_reconfig_vo(vd, &vo_params) < 0) {
             talloc_free(mpi);
             return -1;
         }
@@ -805,30 +804,30 @@ static int decode(struct sh_video *sh, struct demux_packet *packet,
     return 1;
 }
 
-static struct mp_image *decode_with_fallback(struct sh_video *sh,
+static struct mp_image *decode_with_fallback(struct dec_video *vd,
                                 struct demux_packet *packet,
                                 int flags, double *reordered_pts)
 {
-    vd_ffmpeg_ctx *ctx = sh->context;
+    vd_ffmpeg_ctx *ctx = vd->priv;
     if (!ctx->avctx)
         return NULL;
 
     struct mp_image *mpi = NULL;
-    int res = decode(sh, packet, flags, reordered_pts, &mpi);
+    int res = decode(vd, packet, flags, reordered_pts, &mpi);
     if (res >= 0)
         return mpi;
 
     // Failed hardware decoding? Try again in software.
     if (ctx->software_fallback_decoder) {
-        uninit_avctx(sh);
+        uninit_avctx(vd);
         mp_tmsg(MSGT_DECVIDEO, MSGL_ERR, "Error using hardware "
                 "decoding, falling back to software decoding.\n");
         const char *decoder = ctx->software_fallback_decoder;
         ctx->software_fallback_decoder = NULL;
-        init_avctx(sh, decoder, NULL);
+        init_avctx(vd, decoder, NULL);
         if (ctx->avctx) {
             mpi = NULL;
-            decode(sh, packet, flags, reordered_pts, &mpi);
+            decode(vd, packet, flags, reordered_pts, &mpi);
             return mpi;
         }
     }
@@ -836,9 +835,9 @@ static struct mp_image *decode_with_fallback(struct sh_video *sh,
     return NULL;
 }