From 3486302514db31b8086f46226d9b46d53810d1e7 Mon Sep 17 00:00:00 2001 From: wm4 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. --- video/decode/dec_video.c | 188 +++++++++++++++++++++++------------------------ video/decode/dec_video.h | 53 ++++++++++--- video/decode/lavc_dr1.c | 4 +- video/decode/vd.h | 11 +-- video/decode/vd_lavc.c | 143 ++++++++++++++++++----------------- video/decode/vdpau_old.c | 4 +- 6 files changed, 216 insertions(+), 187 deletions(-) (limited to 'video') 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 : ""); + d_video->header->codec ? d_video->header->codec : ""); } 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; } -static int control(sh_video_t *sh, int cmd, void *arg) +static int control(struct dec_video *vd, int cmd, void *arg) { - vd_ffmpeg_ctx *ctx = sh->context; + vd_ffmpeg_ctx *ctx = vd->priv; AVCodecContext *avctx = ctx->avctx; switch (cmd) { case VDCTRL_RESYNC_STREAM: @@ -853,7 +852,7 @@ static int control(sh_video_t *sh, int cmd, void *arg) return CONTROL_TRUE; case VDCTRL_REINIT_VO: if (ctx->vo_image_params.imgfmt) - mpcodecs_reconfig_vo(sh, &ctx->vo_image_params); + mpcodecs_reconfig_vo(vd, &ctx->vo_image_params); return true; case VDCTRL_GET_PARAMS: *(struct mp_image_params *)arg = ctx->vo_image_params; diff --git a/video/decode/vdpau_old.c b/video/decode/vdpau_old.c index 1ef6c7857a..caca5df1a5 100644 --- a/video/decode/vdpau_old.c +++ b/video/decode/vdpau_old.c @@ -130,8 +130,8 @@ static void draw_slice_hwdec(struct AVCodecContext *s, const AVFrame *src, int offset[4], int y, int type, int height) { - sh_video_t *sh = s->opaque; - struct lavc_ctx *ctx = sh->context; + struct dec_video *vd = s->opaque; + struct lavc_ctx *ctx = vd->priv; struct priv *p = ctx->hwdec_priv; struct vdp_functions *vdp = p->vdp; VdpStatus vdp_st; -- cgit v1.2.3