diff options
author | xylosper <darklin20@gmail.com> | 2013-09-20 22:55:13 +0900 |
---|---|---|
committer | wm4 <wm4@nowhere> | 2013-09-25 13:53:42 +0200 |
commit | 39d1ab82e5a3ac30e5495c6b6773823c2ff56594 (patch) | |
tree | 03d5ab170fe12046bff32234e4e0b55d67457ce2 | |
parent | 1ee8d0210d8ad613e462eab10a1a4139b62de367 (diff) | |
download | mpv-39d1ab82e5a3ac30e5495c6b6773823c2ff56594.tar.bz2 mpv-39d1ab82e5a3ac30e5495c6b6773823c2ff56594.tar.xz |
vaapi: add vf_vavpp and use it for deinterlacing
Merged from pull request #246 by xylosper. Minor cosmetic changes, some
adjustments (compatibility with older libva versions), and manpage
additions by wm4.
Signed-off-by: wm4 <wm4@nowhere>
-rw-r--r-- | DOCS/man/en/vf.rst | 17 | ||||
-rw-r--r-- | DOCS/man/en/vo.rst | 11 | ||||
-rw-r--r-- | Makefile | 4 | ||||
-rwxr-xr-x | configure | 13 | ||||
-rw-r--r-- | mpvcore/command.c | 3 | ||||
-rw-r--r-- | video/decode/vaapi.c | 65 | ||||
-rw-r--r-- | video/filter/vf.c | 4 | ||||
-rw-r--r-- | video/filter/vf.h | 1 | ||||
-rw-r--r-- | video/filter/vf_vavpp.c | 406 | ||||
-rw-r--r-- | video/filter/vf_vo.c | 2 | ||||
-rw-r--r-- | video/out/vo_vaapi.c | 546 | ||||
-rw-r--r-- | video/vaapi.c | 520 | ||||
-rw-r--r-- | video/vaapi.h | 77 |
13 files changed, 1145 insertions, 524 deletions
diff --git a/DOCS/man/en/vf.rst b/DOCS/man/en/vf.rst index b7f0416ebb..6de671ea58 100644 --- a/DOCS/man/en/vf.rst +++ b/DOCS/man/en/vf.rst @@ -861,3 +861,20 @@ Available filters are: ``a3=<string>`` Specify the fourth parameter to pass to the library. + +``vavpp`` + VA-API video post processing. Works with ``--vo=vaapi`` only. Currently + deinterlaces. This filter is automatically inserted if deinterlacing is + requested (either using the ``D`` key, by default mapped to the command + ``cycle deinterlace``, or the ``--deinterlace`` option). + + ``deint=<method>`` + Select the deinterlacing algorithm. + + no + Don't perform deinterlacing. + first-field + Show only first field (going by ``--field-dominance``). + bob + bob deinterlacing (default). + diff --git a/DOCS/man/en/vo.rst b/DOCS/man/en/vo.rst index c57f25f125..88c1821e9c 100644 --- a/DOCS/man/en/vo.rst +++ b/DOCS/man/en/vo.rst @@ -701,12 +701,19 @@ Available video output drivers are: initially always off, and needs to be enabled with the ``D`` key (default key binding for ``cycle deinterlace``). + This option doesn't apply if libva supports video post processing (vpp). + In this case, the default for ``deint-mode`` is ``no``, and enabling + deinterlacing via user interaction using the methods mentioned above + actually inserts the ``vavpp`` video filter. If vpp is not actually + supported with the libva backend in use, you can use this option to + forcibly enable VO based deinterlacing. + no - Don't allow deinterlacing. + Don't allow deinterlacing (default for newer libva). first-field Show only first field (going by ``--field-dominance``). bob - bob deinterlacing (default). + bob deinterlacing (default for older libva). ``scaled-osd=<yes|no>`` If enabled, then the OSD is rendered at video resolution and scaled to @@ -112,7 +112,9 @@ SOURCES-$(VDA) += video/decode/vda.c SOURCES-$(VDPAU_DEC) += video/decode/vdpau.c SOURCES-$(VDPAU_DEC_OLD) += video/decode/vdpau_old.c SOURCES-$(VAAPI) += video/out/vo_vaapi.c \ - video/decode/vaapi.c + video/decode/vaapi.c \ + video/vaapi.c +SOURCES-$(VAAPI_VPP) += video/filter/vf_vavpp.c SOURCES-$(X11) += video/out/vo_x11.c video/out/x11_common.c SOURCES-$(XV) += video/out/vo_xv.c @@ -1869,6 +1869,8 @@ echores "$_vdpau" echocheck "VAAPI" +_vaapi_vpp=no +def_vaapi_vpp='#define CONFIG_VAAPI_VPP 0' if test "$_vaapi" = auto && test "$_x11" = yes ; then _vaapi=no if test "$_dl" = yes ; then @@ -1884,6 +1886,15 @@ else fi echores "$_vaapi" +if test "$_vaapi" = yes ; then + echocheck "VAAPI VPP" + if pkg-config 'libva >= 0.34.0' ; then + _vaapi_vpp=yes + def_vaapi_vpp='#define CONFIG_VAAPI_VPP 1' + fi + echores "$_vaapi_vpp" +fi + echocheck "Xinerama" if test "$_xinerama" = auto && test "$_x11" = yes ; then @@ -3173,6 +3184,7 @@ VDPAU_DEC_OLD = $_vdpau_dec_old VDA = $_vda VDA_REFCOUNTING = $_vda_refcounting VAAPI = $_vaapi +VAAPI_VPP = $_vaapi_vpp WIN32 = $_win32 X11 = $_x11 WAYLAND = $_wayland @@ -3351,6 +3363,7 @@ $def_vdpau $def_vda $def_vda_refcounting $def_vaapi +$def_vaapi_vpp $def_vm $def_x11 $def_wayland diff --git a/mpvcore/command.c b/mpvcore/command.c index b451669f12..b30a5299e0 100644 --- a/mpvcore/command.c +++ b/mpvcore/command.c @@ -1140,6 +1140,9 @@ static const char *deint_filters[] = { "lavfi=yadif", #endif "yadif", +#if CONFIG_VAAPI_VPP + "vavpp", +#endif NULL }; diff --git a/video/decode/vaapi.c b/video/decode/vaapi.c index 9064389afe..8bec94d950 100644 --- a/video/decode/vaapi.c +++ b/video/decode/vaapi.c @@ -31,6 +31,7 @@ #include "video/fmt-conversion.h" #include "video/vaapi.h" #include "video/decode/dec_video.h" +#include "video/filter/vf.h" /* * The VAAPI decoder can work only with surfaces passed to the decoder at @@ -60,6 +61,9 @@ struct priv { int format, w, h; VASurfaceID surfaces[MAX_SURFACES]; + + struct va_surface_pool *pool; + int rt_format; }; struct profile_entry { @@ -159,36 +163,23 @@ static int is_direct_mapping(VADisplay display) return 0; } -// Make vo_vaapi.c pool the required number of surfaces. -// This is very touchy: vo_vaapi.c must not free surfaces while we decode, -// and we must allocate only surfaces that were passed to the decoder on -// creation. -// We achieve this by deleting all previous surfaces, then allocate every -// surface needed. Then we free these surfaces, and rely on the fact that -// vo_vaapi.c keeps the released surfaces in the pool, and only allocates -// new surfaces out of that pool. -static int preallocate_surfaces(struct lavc_ctx *ctx, int va_rt_format, int num) +// We must allocate only surfaces that were passed to the decoder on creation. +// We achieve this by reserving surfaces in the pool as needed. +// Releasing surfaces is necessary after filling the surface id list so +// that reserved surfaces can be reused for decoding. +static bool preallocate_surfaces(struct lavc_ctx *ctx, int num) { struct priv *p = ctx->hwdec_priv; - int res = -1; - - struct mp_image *tmp_surfaces[MAX_SURFACES] = {0}; - - p->ctx->flush(p->ctx); // free previously allocated surfaces - - for (int n = 0; n < num; n++) { - tmp_surfaces[n] = p->ctx->get_surface(p->ctx, va_rt_format, p->format, - p->w, p->h); - if (!tmp_surfaces[n]) - goto done; - p->surfaces[n] = (uintptr_t)tmp_surfaces[n]->planes[3]; + if (!va_surface_pool_reserve(p->pool, num, p->w, p->h)) { + mp_msg(MSGT_VO, MSGL_ERR, "[vaapi] Could not allocate surfaces.\n"); + return false; } - res = 0; - -done: - for (int n = 0; n < num; n++) - talloc_free(tmp_surfaces[n]); - return res; + for (int i = 0; i < num; i++) { + struct va_surface *s = va_surface_pool_get(p->pool, p->w, p->h); + p->surfaces[i] = s->id; + va_surface_release(s); + } + return true; } static void destroy_decoder(struct lavc_ctx *ctx) @@ -274,7 +265,7 @@ static int create_decoder(struct lavc_ctx *ctx) goto error; } - if (preallocate_surfaces(ctx, VA_RT_FORMAT_YUV420, num_surfaces) < 0) { + if (!preallocate_surfaces(ctx, num_surfaces)) { mp_msg(MSGT_VO, MSGL_ERR, "[vaapi] Could not allocate surfaces.\n"); goto error; } @@ -298,7 +289,7 @@ static int create_decoder(struct lavc_ctx *ctx) &attrib, 1); if (!check_va_status(status, "vaGetConfigAttributes()")) goto error; - if ((attrib.value & VA_RT_FORMAT_YUV420) == 0) { + if ((attrib.value & p->rt_format) == 0) { mp_msg(MSGT_VO, MSGL_ERR, "[vaapi] Chroma format not supported.\n"); goto error; } @@ -339,14 +330,13 @@ static struct mp_image *allocate_image(struct lavc_ctx *ctx, int format, return NULL; } - struct mp_image *img = p->ctx->get_surface(p->ctx, VA_RT_FORMAT_YUV420, - format, p->w, p->h); - if (img) { + struct va_surface *s = va_surface_pool_get(p->pool, p->w, p->h); + if (s) { for (int n = 0; n < MAX_SURFACES; n++) { - if (p->surfaces[n] == (uintptr_t)img->planes[3]) - return img; + if (p->surfaces[n] == s->id) + return va_surface_wrap(s); } - talloc_free(img); + va_surface_release(s); } mp_msg(MSGT_VO, MSGL_ERR, "[vaapi] Insufficient number of surfaces.\n"); return NULL; @@ -361,6 +351,7 @@ static void uninit(struct lavc_ctx *ctx) destroy_decoder(ctx); + va_surface_pool_release(p->pool); talloc_free(p); ctx->hwdec_priv = NULL; } @@ -371,16 +362,18 @@ static int init(struct lavc_ctx *ctx) *p = (struct priv) { .ctx = ctx->hwdec_info->vaapi_ctx, .va_context = &p->va_context_storage, + .rt_format = VA_RT_FORMAT_YUV420 }; - ctx->hwdec_priv = p; p->display = p->ctx->display; + p->pool = va_surface_pool_alloc(p->display, p->rt_format); p->va_context->display = p->display; p->va_context->config_id = VA_INVALID_ID; p->va_context->context_id = VA_INVALID_ID; ctx->avctx->hwaccel_context = p->va_context; + ctx->hwdec_priv = p; return 0; } diff --git a/video/filter/vf.c b/video/filter/vf.c index 56ddd32fd8..216f3c42f4 100644 --- a/video/filter/vf.c +++ b/video/filter/vf.c @@ -70,6 +70,7 @@ extern const vf_info_t vf_info_yadif; extern const vf_info_t vf_info_stereo3d; extern const vf_info_t vf_info_dlopen; extern const vf_info_t vf_info_lavfi; +extern const vf_info_t vf_info_vaapi; // list of available filters: static const vf_info_t *const filter_list[] = { @@ -112,6 +113,9 @@ static const vf_info_t *const filter_list[] = { #ifdef CONFIG_DLOPEN &vf_info_dlopen, #endif +#if CONFIG_VAAPI_VPP + &vf_info_vaapi, +#endif NULL }; diff --git a/video/filter/vf.h b/video/filter/vf.h index 730b0e0da0..ea1246da17 100644 --- a/video/filter/vf.h +++ b/video/filter/vf.h @@ -106,6 +106,7 @@ typedef struct vf_seteq { /* Hack to make the OSD state object available to vf_sub which * access OSD/subtitle state outside of normal OSD draw time. */ #define VFCTRL_SET_OSD_OBJ 20 +#define VFCTRL_GET_HWDEC_INFO 21 // for hwdec filters int vf_control(struct vf_instance *vf, int cmd, void *arg); diff --git a/video/filter/vf_vavpp.c b/video/filter/vf_vavpp.c new file mode 100644 index 0000000000..ba4e9ca411 --- /dev/null +++ b/video/filter/vf_vavpp.c @@ -0,0 +1,406 @@ +/* + * This file is part of mpv. + * + * mpv is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * mpv is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with mpv. If not, see <http://www.gnu.org/licenses/>. + */ + +#include <va/va.h> +#include <va/va_vpp.h> + +#include "config.h" +#include "mpvcore/options.h" +#include "vf.h" +#include "video/vaapi.h" +#include "video/decode/dec_video.h" + +static inline bool is_success(VAStatus status, const char *msg) +{ + if (status == VA_STATUS_SUCCESS) + return true; + mp_msg(MSGT_VFILTER, MSGL_ERR, "[vavpp] %s: %s\n", msg, vaErrorStr(status)); + return false; +} + +struct surface_refs { + VASurfaceID *surfaces; + int num_allocated; + int num_required; +}; + +struct pipeline { + VABufferID *filters; + int num_filters; + VAProcColorStandardType input_colors[VAProcColorStandardCount]; + VAProcColorStandardType output_colors[VAProcColorStandardCount]; + int num_input_colors, num_output_colors; + struct surface_refs forward, backward; +}; + +struct vf_priv_s { + double prev_pts; + int deint_type; // 0: none, 1: discard, 2: double fps + bool do_deint; + VABufferID buffers[VAProcFilterCount]; + int num_buffers; + VAConfigID config; + VAContextID context; + struct mp_image_params params; + VADisplay display; + struct mp_vaapi_ctx *va; + struct pipeline pipe; + struct va_surface_pool *pool; +}; + +static const struct vf_priv_s vf_priv_default = { + .prev_pts = MP_NOPTS_VALUE, + .config = VA_INVALID_ID, + .context = VA_INVALID_ID, + .deint_type = 2, +}; + +static inline void realloc_refs(struct surface_refs *refs, int num) +{ + if (refs->num_allocated < num) { + refs->surfaces = realloc(refs->surfaces, sizeof(VASurfaceID)*num); + refs->num_allocated = num; + } + refs->num_required = num; +} + +static bool update_pipeline(struct vf_priv_s *p, bool deint) +{ + VABufferID *filters = p->buffers; + int num_filters = p->num_buffers; + if (p->deint_type && !deint) { + ++filters; + --num_filters; + } + if (filters == p->pipe.filters && num_filters == p->pipe.num_filters) + return true; + p->pipe.forward.num_required = p->pipe.backward.num_required = 0; + p->pipe.num_input_colors = p->pipe.num_output_colors = 0; + p->pipe.num_filters = 0; + p->pipe.filters = NULL; + if (!num_filters) + return false; + VAProcPipelineCaps caps; + caps.input_color_standards = p->pipe.input_colors; + caps.output_color_standards = p->pipe.output_colors; + caps.num_input_color_standards = VAProcColorStandardCount; + caps.num_output_color_standards = VAProcColorStandardCount; + VAStatus status = vaQueryVideoProcPipelineCaps(p->display, p->context, + filters, num_filters, &caps); + if (!is_success(status, "vaQueryVideoProcPipelineCaps()")) + return false; + p->pipe.filters = filters; + p->pipe.num_filters = num_filters; + p->pipe.num_input_colors = caps.num_input_color_standards; + p->pipe.num_output_colors = caps.num_output_color_standards; + realloc_refs(&p->pipe.forward, caps.num_forward_references); + realloc_refs(&p->pipe.backward, caps.num_backward_references); + return true; +} + +static inline int get_deint_field(struct vf_priv_s *p, int i, + const struct mp_image *mpi) +{ + if (!p->do_deint || !(mpi->fields & MP_IMGFIELD_INTERLACED)) + return VA_FRAME_PICTURE; + return !!(mpi->fields & MP_IMGFIELD_TOP_FIRST) ^ i ? VA_TOP_FIELD : VA_BOTTOM_FIELD; +} + +static struct mp_image *render(struct vf_priv_s *p, struct va_surface *in, + unsigned int flags) +{ + if (!p->pipe.filters || !in) + return NULL; + struct va_surface *out = va_surface_pool_get(p->pool, in->w, in->h); + if (!out) + return NULL; + enum {Begun = 1, Rendered = 2}; + int state = 0; + do { // not a loop, just for break + VAStatus status = vaBeginPicture(p->display, p->context, out->id); + if (!is_success(status, "vaBeginPicture()")) + break; + state |= Begun; + VABufferID buffer = VA_INVALID_ID; + VAProcPipelineParameterBuffer *param = NULL; + status = vaCreateBuffer(p->display, p->context, + VAProcPipelineParameterBufferType, + sizeof(*param), 1, NULL, &buffer); + if (!is_success(status, "vaCreateBuffer()")) + break; + status = vaMapBuffer(p->display, buffer, (void**)¶m); + if (!is_success(status, "vaMapBuffer()")) + break; + param->surface = in->id; + param->surface_region = NULL; + param->output_region = NULL; + param->output_background_color = 0; + param->filter_flags = flags; + param->filters = p->pipe.filters; + param->num_filters = p->pipe.num_filters; + vaUnmapBuffer(p->display, buffer); + param->forward_references = p->pipe.forward.surfaces; + param->backward_references = p->pipe.backward.surfaces; + param->num_forward_references = p->pipe.forward.num_required; + param->num_backward_references = p->pipe.backward.num_required; + status = vaRenderPicture(p->display, p->context, &buffer, 1); + if (!is_success(status, "vaRenderPicture()")) + break; + state |= Rendered; + } while (false); + if (state & Begun) + vaEndPicture(p->display, p->context); + if (state & Rendered) + return va_surface_wrap(out); + va_surface_release(out); + return NULL; +} + +// return value: the number of created images +static int process(struct vf_priv_s *p, struct mp_image *in, + struct mp_image **out1, struct mp_image **out2) +{ + const bool deint = p->do_deint && p->deint_type > 0; + if (!update_pipeline(p, deint) || !p->pipe.filters) // no filtering + return 0; + struct va_surface *surface = va_surface_in_mp_image(in); + const unsigned int csp = va_get_colorspace_flag(p->params.colorspace); + const unsigned int field = get_deint_field(p, 0, in); + *out1 = render(p, surface, field | csp); + if (!*out1) // cannot render + return 0; + mp_image_copy_attributes(*out1, in); + if (field == VA_FRAME_PICTURE || p->deint_type < 2) // first-field only + return 1; + const double add = (in->pts - p->prev_pts)*0.5; + if (p->prev_pts == MP_NOPTS_VALUE || add <= 0.0 || add > 0.5) // no pts, skip it + return 1; + *out2 = render(p, surface, get_deint_field(p, 1, in) | csp); + if (!*out2) // cannot render + return 1; + mp_image_copy_attributes(*out2, in); + (*out2)->pts = in->pts + add; + return 2; +} + +static struct mp_image *upload(struct vf_priv_s *p, struct mp_image *in) +{ + struct va_surface *surface = + va_surface_pool_get_by_imgfmt(p->pool, p->va->image_formats, in->imgfmt, in->w, in->h); + if (!surface) + surface = va_surface_pool_get(p->pool, in->w, in->h); // dummy + else + va_surface_upload(surface, in); + struct mp_image *out = va_surface_wrap(surface); + mp_image_copy_attributes(out, in); + return out; +} + +static int filter_ext(struct vf_instance *vf, struct mp_image *in) +{ + struct vf_priv_s *p = vf->priv; + struct va_surface *surface = va_surface_in_mp_image(in); + const int rt_format = surface ? surface->rt_format : VA_RT_FORMAT_YUV420; + if (!p->pool || va_surface_pool_rt_format(p->pool) != rt_format) { + va_surface_pool_release(p->pool); + p->pool = va_surface_pool_alloc(p->display, rt_format); + } + if (!surface) { + struct mp_image *tmp = upload(p, in); + talloc_free(in); + in = tmp; + } + + struct mp_image *out1, *out2; + const double pts = in->pts; + const int num = process(p, in, &out1, &out2); + if (!num) + vf_add_output_frame(vf, in); + else { + vf_add_output_frame(vf, out1); + if (num > 1) + vf_add_output_frame(vf, out2); + talloc_free(in); + } + p->prev_pts = pts; + return 0; +} + +static int reconfig(struct vf_instance *vf, struct mp_image_params *params, + int flags) +{ + struct vf_priv_s *p = vf->priv; + + p->prev_pts = MP_NOPTS_VALUE; + p->params = *params; + params->imgfmt = IMGFMT_VAAPI; + return vf_next_reconfig(vf, params, flags); +} + +static void uninit(struct vf_instance *vf) +{ + struct vf_priv_s *p = vf->priv; + for (int i=0; i<p->num_buffers; ++i) + vaDestroyBuffer(p->display, p->buffers[i]); + if (p->context != VA_INVALID_ID) + vaDestroyContext(p->display, p->context); + if (p->config != VA_INVALID_ID) + vaDestroyConfig(p->display, p->config); + free(p->pipe.forward.surfaces); + free(p->pipe.backward.surfaces); + va_surface_pool_release(p->pool); +} + +static int query_format(struct vf_instance *vf, unsigned int imgfmt) +{ + struct vf_priv_s *p = vf->priv; + if (IMGFMT_IS_VAAPI(imgfmt) || va_image_format_from_imgfmt(p->va->image_formats, imgfmt)) + return vf_next_query_format(vf, IMGFMT_VAAPI); + return 0; +} + +static int control(struct vf_instance *vf, int request, void* data) +{ + struct vf_priv_s *p = vf->priv; + switch (request){ + case VFCTRL_GET_DEINTERLACE: + *(int*)data = !!p->do_deint; + return true; + case VFCTRL_SET_DEINTERLACE: + p->do_deint = *(int*)data; + return true; + default: + return vf_next_control (vf, request, data); + } +} + +static int va_query_filter_caps(struct vf_priv_s *p, VAProcFilterType type, + void *caps, unsigned int count) +{ + VAStatus status = vaQueryVideoProcFilterCaps(p->display, p->context, type, + caps, &count); + return is_success(status, "vaQueryVideoProcFilterCaps()") ? count : 0; +} + +static VABufferID va_create_filter_buffer(struct vf_priv_s *p, int bytes, + int num, void *data) +{ + VABufferID buffer; + VAStatus status = vaCreateBuffer(p->display, p->context, + VAProcFilterParameterBufferType, + bytes, num, data, &buffer); + return is_success(status, "vaCreateBuffer()") ? buffer : VA_INVALID_ID; +} + +static bool initialize(struct vf_priv_s *p) +{ + VAStatus status; + + VAConfigID config; + status = vaCreateConfig(p->display, VAProfileNone, VAEntrypointVideoProc, + NULL, 0, &config); + if (!is_success(status, "vaCreateConfig()")) // no entrypoint for video porc + return false; + p->config = config; + + VAContextID context; + status = vaCreateContext(p->display, p->config, 0, 0, 0, NULL, 0, &context); + if (!is_success(status, "vaCreateContext()")) + return false; + p->context = context; + + VAProcFilterType filters[VAProcFilterCount]; + int num_filters = VAProcFilterCount; + status = vaQueryVideoProcFilters(p->display, p->context, filters, &num_filters); + if (!is_success(status, "vaQueryVideoProcFilters()")) + return false; + + VABufferID buffers[VAProcFilterCount]; + for (int i=0; i<VAProcFilterCount; ++i) + buffers[i] = VA_INVALID_ID; + for (int i=0; i<num_filters; ++i) { + if (filters[i] == VAProcFilterDeinterlacing) { + if (!p->deint_type) + continue; + VAProcFilterCapDeinterlacing caps[VAProcDeinterlacingCount]; + int num = va_query_filter_caps(p, VAProcFilterDeinterlacing, caps, + VAProcDeinterlacingCount); + if (!num) + continue; + VAProcDeinterlacingType algorithm = VAProcDeinterlacingBob; + for (int i=0; i<num; ++i) { // find Bob + if (caps[i].type != algorithm) + continue; + VAProcFilterParameterBufferDeinterlacing param; + param.type = VAProcFilterDeinterlacing; + param.algorithm = algorithm; + buffers[VAProcFilterDeinterlacing] = + va_create_filter_buffer(p, sizeof(param), 1, ¶m); + } + } // check other filters + } + p->num_buffers = 0; + if (buffers[VAProcFilterDeinterlacing] != VA_INVALID_ID) + p->buffers[p->num_buffers++] = buffers[VAProcFilterDeinterlacing]; + else + p->deint_type = 0; + p->do_deint = !!p->deint_type; + // next filters: p->buffers[p->num_buffers++] = buffers[next_filter]; + return true; +} + +static int vf_open(vf_instance_t *vf, char *args) +{ + vf->reconfig = reconfig; + vf->filter_ext = filter_ext; + vf->query_format = query_format; + vf->uninit = uninit; + vf->control = control; + + struct vf_priv_s *p = vf->priv; + struct mp_hwdec_info hwdec; + if (vf_control(vf->next, VFCTRL_GET_HWDEC_INFO, &hwdec) <= 0) + return false; + p->va = hwdec.vaapi_ctx; + if (!p->va || !p->va->display) + return false; + p->display = p->va->display; + if (initialize(p)) + return true; + uninit(vf); + return false; +} + +#define OPT_BASE_STRUCT struct vf_priv_s +static const m_option_t vf_opts_fields[] = { + OPT_CHOICE("deint", deint_type, 0, + ({"no", 0}, + {"first-field", 1}, + {"bob", 2})), + {0} +}; + +const vf_info_t vf_info_vaapi = { + .info = "VA-API Video Post-Process Filter", + .name = "vavpp", + .author = "xylosper", + .comment = "", + .vf_open = vf_open, + .priv_size = sizeof(struct vf_priv_s), + .priv_defaults = &vf_priv_default, + .options = vf_opts_fields, +}; diff --git a/video/filter/vf_vo.c b/video/filter/vf_vo.c index 05f835d5fd..cccfb45fc2 100644 --- a/video/filter/vf_vo.c +++ b/video/filter/vf_vo.c @@ -83,6 +83,8 @@ static int control(struct vf_instance *vf, int request, void *data) }; return vo_control(video_out, VOCTRL_GET_EQUALIZER, ¶m) == VO_TRUE; } + case VFCTRL_GET_HWDEC_INFO: + return vo_control(video_out, VOCTRL_GET_HWDEC_INFO, data) == VO_TRUE; } return CONTROL_UNKNOWN; } diff --git a/video/out/vo_vaapi.c b/video/out/vo_vaapi.c index d7947cda20..dd7f138a24 100644 --- a/video/out/vo_vaapi.c +++ b/video/out/vo_vaapi.c @@ -43,22 +43,6 @@ #include "video/vaapi.h" #include "video/decode/dec_video.h" -#define STR_FOURCC(fcc) \ - (const char[]){(fcc), (fcc) >> 8u, (fcc) >> 16u, (fcc) >> 24u, 0} - -struct vaapi_surface { - VASurfaceID id; // VA_INVALID_ID if unallocated - int w, h, va_format; // parameters of allocated image (0/0/-1 unallocated) - VAImage image; // used for sofwtare decoding case - bool is_bound; // image bound to the surface? - bool is_used; // referenced by a mp_image - bool is_dead; // used, but deallocate VA objects as soon as possible - int order; // for LRU allocation - - // convenience shortcut for mp_image deallocation callback - struct priv *p; -}; - struct vaapi_osd_image { int w, h; VAImage image; @@ -86,7 +70,7 @@ struct priv { struct mp_log *log; struct vo *vo; VADisplay display; - struct mp_vaapi_ctx mpvaapi; + struct mp_vaapi_ctx *mpvaapi; struct mp_image_params image_params; struct mp_rect src_rect; @@ -98,21 +82,18 @@ struct priv { int output_surface; int visible_surface; - int deint; - int deint_type; int scaling; int force_scaled_osd; + // with old libva versions only + int deint; + int deint_type; VAImageFormat osd_format; // corresponds to OSD_VA_FORMAT struct vaapi_osd_part osd_parts[MAX_OSD_PARTS]; bool osd_screen; - int num_video_surfaces; - struct vaapi_surface **video_surfaces; - int video_surface_lru_counter; - - VAImageFormat *va_image_formats; - int va_num_image_formats; + struct va_surface_pool *pool; + struct va_image_formats *va_image_formats; VAImageFormat *va_subpic_formats; unsigned int *va_subpic_flags; int va_num_subpic_formats; @@ -128,187 +109,10 @@ static const bool osd_formats[SUBBITMAP_COUNT] = { [SUBBITMAP_RGBA] = true, }; -struct fmtentry { - uint32_t va; - int mp; -}; -static struct fmtentry va_to_imgfmt[] = { - {VA_FOURCC('Y','V','1','2'), IMGFMT_420P}, - {VA_FOURCC('I','4','2','0'), IMGFMT_420P}, - {VA_FOURCC('I','Y','U','V'), IMGFMT_420P}, - {VA_FOURCC('N','V','1','2'), IMGFMT_NV12}, - // Note: not sure about endian issues (the mp formats are byte-addressed) - {VA_FOURCC_RGBA, IMGFMT_RGBA}, - {VA_FOURCC_BGRA, IMGFMT_BGRA}, - // Untested. - //{VA_FOURCC_UYVY, IMGFMT_UYVY}, - //{VA_FOURCC_YUY2, IMGFMT_YUYV}, - {0} -}; - - -static int va_fourcc_to_imgfmt(uint32_t fourcc) -{ - for (int n = 0; va_to_imgfmt[n].mp; n++) { - if (va_to_imgfmt[n].va == fourcc) - return va_to_imgfmt[n].mp; - } - return 0; -} - -static VAImageFormat *VAImageFormat_from_imgfmt(struct priv *p, int format) -{ - for (int i = 0; i < p->va_num_image_formats; i++) { - if (va_fourcc_to_imgfmt(p->va_image_formats[i].fourcc) == format) - return &p->va_image_formats[i]; - } - return NULL; -} - -static struct vaapi_surface *to_vaapi_surface(struct priv *p, - struct mp_image *img) -{ - if (!img || !IMGFMT_IS_VAAPI(img->imgfmt)) - return NULL; - // Note: we _could_ use planes[1] or planes[2] to store a vaapi_surface - // pointer, but I just don't trust libavcodec enough. - VASurfaceID id = (uintptr_t)img->planes[3]; - for (int n = 0; n < p->num_video_surfaces; n++) { - struct vaapi_surface *s = p->video_surfaces[n]; - if (s->id == id) - return s; - } - return NULL; -} - -static struct vaapi_surface *alloc_vaapi_surface(struct priv *p, int w, int h, - int va_format) -{ - VAStatus status; - - VASurfaceID id = VA_INVALID_ID; - status = vaCreateSurfaces(p->display, w, h, va_format, 1, &id); - if (!check_va_status(status, "vaCreateSurfaces()")) - return NULL; - - struct vaapi_surface *surface = NULL; - for (int n = 0; n < p->num_video_surfaces; n++) { - struct vaapi_surface *s = p->video_surfaces[n]; - if (s->id == VA_INVALID_ID) { - surface = s; - break; - } - } - if (!surface) { - surface = talloc_ptrtype(NULL, surface); - MP_TARRAY_APPEND(p, p->video_surfaces, p->num_video_surfaces, surface); - } - - *surface = (struct vaapi_surface) { - .id = id, - .image = { .image_id = VA_INVALID_ID, .buf = VA_INVALID_ID }, - .w = w, - .h = h, - .va_format = va_format, - .p = p, - }; - return surface; -} - -static void destroy_vaapi_surface(struct priv *p, struct vaapi_surface *s) -{ - if (!s || s->id == VA_INVALID_ID) - return; - assert(!s->is_used); - - if (s->image.image_id != VA_INVALID_ID) - vaDestroyImage(p->display, s->image.image_id); - vaDestroySurfaces(p->display, &s->id, 1); |