RepoMirrors
/
mpv
mirror of https://github.com/mpv-player/mpv
1
0
Fork 0
Code Issues Releases Wiki Activity
mpv/video/out/vo_vaapi.c

1056 lines
32 KiB
C
Raw Blame History

/*
* VA API output module
*
* Copyright (C) 2008-2009 Splitted-Desktop Systems
*
* This file is part of MPlayer.
*
* MPlayer is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* MPlayer is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with MPlayer; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <assert.h>
#include <stdarg.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <va/va_x11.h>
#include <libavutil/common.h>
#include <libavcodec/vaapi.h>
#include "config.h"
#include "mpvcore/mp_msg.h"
#include "video/out/vo.h"
#include "video/memcpy_pic.h"
#include "sub/sub.h"
#include "sub/img_convert.h"
#include "x11_common.h"
#include "video/vfcap.h"
#include "video/mp_image.h"
#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;
VASubpictureID subpic_id;
bool is_used;
};
struct vaapi_subpic {
VASubpictureID id;
int src_x, src_y, src_w, src_h;
int dst_x, dst_y, dst_w, dst_h;
};
struct vaapi_osd_part {
bool active;
int bitmap_pos_id;
struct vaapi_osd_image image;
struct vaapi_subpic subpic;
struct osd_conv_cache *conv_cache;
};
#define MAX_OUTPUT_SURFACES 2
struct priv {
struct mp_log *log;
struct vo *vo;
VADisplay display;
struct mp_vaapi_ctx mpvaapi;
struct mp_image_params image_params;
struct mp_rect src_rect;
struct mp_rect dst_rect;
struct mp_osd_res screen_osd_res;
struct mp_image *output_surfaces[MAX_OUTPUT_SURFACES];
struct mp_image *swdec_surfaces[MAX_OUTPUT_SURFACES];
int output_surface;
int visible_surface;
int deint;
int deint_type;
int scaling;
int force_scaled_osd;
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;
VAImageFormat *va_subpic_formats;
unsigned int *va_subpic_flags;
int va_num_subpic_formats;
VADisplayAttribute *va_display_attrs;
int va_num_display_attrs;
};
#define OSD_VA_FORMAT VA_FOURCC_BGRA
static const bool osd_formats[SUBBITMAP_COUNT] = {
// Actually BGRA, but only on little endian.
// This will break on big endian, I think.
[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);
s->id = VA_INVALID_ID;
s->w = 0;
s->h = 0;
s->va_format = -1;
}
static struct vaapi_surface *get_vaapi_surface(struct priv *p, int w, int h,
int va_format)
{
struct vaapi_surface *best = NULL;
for (int n = 0; n < p->num_video_surfaces; n++) {
struct vaapi_surface *s = p->video_surfaces[n];
if (!s->is_used && s->w == w && s->h == h && s->va_format == va_format) {
if (!best || best->order > s->order)
best = s;
}
}
if (!best)
best = alloc_vaapi_surface(p, w, h, va_format);
if (best) {
best->is_used = true;
best->order = ++p->video_surface_lru_counter;
}
return best;
}
static void release_video_surface(void *ptr)
{
struct vaapi_surface *surface = ptr;
surface->is_used = false;
if (surface->is_dead)
destroy_vaapi_surface(surface->p, surface);
}
static struct mp_image *get_surface(struct mp_vaapi_ctx *ctx, int va_rt_format,
int mp_format, int w, int h)
{
assert(IMGFMT_IS_VAAPI(mp_format));
struct vo *vo = ctx->priv;
struct priv *p = vo->priv;
struct mp_image img = {0};
mp_image_setfmt(&img, mp_format);
mp_image_set_size(&img, w, h);
struct vaapi_surface *surface = get_vaapi_surface(p, w, h, va_rt_format);
if (!surface)
return NULL;
// libavcodec probably wants it at [0] and [3]
// [1] and [2] are possibly free for own use.
for (int n = 0; n < 4; n++)
img.planes[n] = (void *)(uintptr_t)surface->id;
return mp_image_new_custom_ref(&img, surface, release_video_surface);
}
// This should be called only by code that is going to preallocate surfaces
// (and by uninit). Otherwise, hw decoder init might get confused by
// accidentally releasing hw decoder preallocated surfaces.
static void flush_surfaces(struct mp_vaapi_ctx *ctx)
{
struct vo *vo = ctx->priv;
struct priv *p = vo->priv;
for (int n = 0; n < p->num_video_surfaces; n++) {
struct vaapi_surface *s = p->video_surfaces[n];
if (s->is_used) {
s->is_dead = true;
} else {
destroy_vaapi_surface(p, s);
}
}
}
static void flush_output_surfaces(struct priv *p)
{
for (int n = 0; n < MAX_OUTPUT_SURFACES; n++) {
talloc_free(p->output_surfaces[n]);
p->output_surfaces[n] = NULL;
}
p->output_surface = 0;
p->visible_surface = 0;
}
// See flush_surfaces() remarks - the same applies.
static void free_video_specific(struct priv *p)
{
flush_output_surfaces(p);
for (int n = 0; n < MAX_OUTPUT_SURFACES; n++) {
talloc_free(p->swdec_surfaces[n]);
p->swdec_surfaces[n] = NULL;
}
flush_surfaces(&p->mpvaapi);
}
static int alloc_swdec_surfaces(struct priv *p, int w, int h, int format)
{
VAStatus status;
free_video_specific(p);
VAImageFormat *image_format = VAImageFormat_from_imgfmt(p, format);
if (!image_format)
return -1;
for (int i = 0; i < MAX_OUTPUT_SURFACES; i++) {
// WTF: no mapping from VAImageFormat -> VA_RT_FORMAT_
struct mp_image *img =
get_surface(&p->mpvaapi, VA_RT_FORMAT_YUV420, IMGFMT_VAAPI, w, h);
struct vaapi_surface *s = to_vaapi_surface(p, img);
if (!s)
return -1;
if (s->image.image_id != VA_INVALID_ID) {
vaDestroyImage(p->display, s->image.image_id);
s->image.image_id = VA_INVALID_ID;
}
status = vaDeriveImage(p->display, s->id, &s->image);
if (status == VA_STATUS_SUCCESS) {
/* vaDeriveImage() is supported, check format */
if (s->image.format.fourcc == image_format->fourcc &&
s->image.width == w && s->image.height == h)
{
s->is_bound = true;
MP_VERBOSE(p, "Using vaDeriveImage()\n");
} else {
vaDestroyImage(p->display, s->image.image_id);
s->image.image_id = VA_INVALID_ID;
status = VA_STATUS_ERROR_OPERATION_FAILED;
}
}
if (status != VA_STATUS_SUCCESS) {
status = vaCreateImage(p->display, image_format, w, h, &s->image);
if (!check_va_status(status, "vaCreateImage()")) {
talloc_free(img);
return -1;
}
}
p->swdec_surfaces[i] = img;
}
return 0;
}
static void resize(struct priv *p)
{
vo_get_src_dst_rects(p->vo, &p->src_rect, &p->dst_rect, &p->screen_osd_res);
// It's not clear whether this is needed; maybe not.
//vo_x11_clearwindow(p->vo, p->vo->x11->window);
p->vo->want_redraw = true;
}
static int reconfig(struct vo *vo, struct mp_image_params *params, int flags)
{
struct priv *p = vo->priv;
vo_x11_config_vo_window(vo, NULL, vo->dx, vo->dy, vo->dwidth, vo->dheight,
flags, "vaapi");
if (!IMGFMT_IS_VAAPI(params->imgfmt)) {
if (alloc_swdec_surfaces(p, params->w, params->h, params->imgfmt) < 0)
return -1;
}
p->image_params = *params;
resize(p);
return 0;
}
static int query_format(struct vo *vo, uint32_t format)
{
struct priv *p = vo->priv;
if (IMGFMT_IS_VAAPI(format) || VAImageFormat_from_imgfmt(p, format))
return VFCAP_CSP_SUPPORTED | VFCAP_CSP_SUPPORTED_BY_HW;
return 0;
}
static inline int get_field_flags(struct priv *p, int i, int flags)
{
return (p->deint && (flags & MP_IMGFIELD_INTERLACED) ?
(((!!(flags & MP_IMGFIELD_TOP_FIRST)) ^ i) == 0 ?
VA_BOTTOM_FIELD : VA_TOP_FIELD) : VA_FRAME_PICTURE);
}
static inline int get_colorspace_flags(struct priv *p)
{
#if USE_VAAPI_COLORSPACE
switch (p->image_params.colorspace) {
case MP_CSP_BT_601: return VA_SRC_BT601;
case MP_CSP_BT_709: return VA_SRC_BT709;
case MP_CSP_SMPTE_240M: return VA_SRC_SMPTE_240;
}
#endif
return 0;
}
static bool render_to_screen(struct priv *p, struct mp_image *mpi)
{
bool res = true;
VAStatus status;
struct vaapi_surface *surface = to_vaapi_surface(p, mpi);
if (!surface)
return false;
for (int n = 0; n < MAX_OSD_PARTS; n++) {
struct vaapi_osd_part *part = &p->osd_parts[n];
if (part->active) {
struct vaapi_subpic *sp = &part->subpic;
int flags = 0;
if (p->osd_screen)
flags |= VA_SUBPICTURE_DESTINATION_IS_SCREEN_COORD;
status = vaAssociateSubpicture2(p->display,
sp->id, &surface->id, 1,
sp->src_x, sp->src_y,
sp->src_w, sp->src_h,
sp->dst_x, sp->dst_y,
sp->dst_w, sp->dst_h,
flags);
check_va_status(status, "vaAssociateSubpicture()");
}
}
for (int i = 0; i <= !!(p->deint > 1); i++) {
unsigned int flags = (get_field_flags(p, i, mpi->fields) |
get_colorspace_flags(p) |
p->scaling);
status = vaPutSurface(p->display,
surface->id,
p->vo->x11->window,
p->src_rect.x0,
p->src_rect.y0,
p->src_rect.x1 - p->src_rect.x0,
p->src_rect.y1 - p->src_rect.y0,
p->dst_rect.x0,
p->dst_rect.y0,
p->dst_rect.x1 - p->dst_rect.x0,
p->dst_rect.y1 - p->dst_rect.y0,
NULL, 0,
flags);
if (!check_va_status(status, "vaPutSurface()"))
res = false;
}
for (int n = 0; n < MAX_OSD_PARTS; n++) {
struct vaapi_osd_part *part = &p->osd_parts[n];
if (part->active) {
struct vaapi_subpic *sp = &part->subpic;
status = vaDeassociateSubpicture(p->display, sp->id,
&surface->id, 1);
check_va_status(status, "vaDeassociateSubpicture()");
}
}
return res;
}
static void flip_page(struct vo *vo)
{
struct priv *p = vo->priv;
p->visible_surface = p->output_surface;
render_to_screen(p, p->output_surfaces[p->output_surface]);
p->output_surface = (p->output_surface + 1) % MAX_OUTPUT_SURFACES;
}
static int map_image(struct priv *p, VAImage *va_image, int mpfmt,
struct mp_image *dst)
{
VAStatus status;
if (mpfmt != va_fourcc_to_imgfmt(va_image->format.fourcc))
return -1;
void *image_data = NULL;
status = vaMapBuffer(p->display, va_image->buf, &image_data);
if (!check_va_status(status, "vaMapBuffer()"))
return -1;
*dst = (struct mp_image) {0};
mp_image_setfmt(dst, mpfmt);
mp_image_set_size(dst, va_image->width, va_image->height);
for (int p = 0; p < va_image->num_planes; p++) {
dst->stride[p] = va_image->pitches[p];
dst->planes[p] = (uint8_t *)image_data + va_image->offsets[p];
}
if (va_image->format.fourcc == VA_FOURCC('Y','V','1','2')) {
FFSWAP(unsigned int, dst->stride[1], dst->stride[2]);
FFSWAP(uint8_t *, dst->planes[1], dst->planes[2]);
}
return 0;
}
static int unmap_image(struct priv *p, VAImage *va_image)
{
VAStatus status;
status = vaUnmapBuffer(p->display, va_image->buf);
return check_va_status(status, "vaUnmapBuffer()") ? 0 : -1;
}
static int upload_surface(struct priv *p, struct vaapi_surface *va_surface,
struct mp_image *mpi)
{
VAStatus status;
if (va_surface->image.image_id == VA_INVALID_ID)
return -1;
struct mp_image img;
if (map_image(p, &va_surface->image, mpi->imgfmt, &img) < 0)
return -1;
mp_image_copy(&img, mpi);
unmap_image(p, &va_surface->image);
if (!va_surface->is_bound) {
status = vaPutImage2(p->display, va_surface->id,
va_surface->image.image_id,
0, 0, mpi->w, mpi->h,
0, 0, mpi->w, mpi->h);
if (!check_va_status(status, "vaPutImage()"))
return -1;
}
return 0;
}
static int try_get_surface(struct priv *p, VAImageFormat *fmt,
struct vaapi_surface *va_surface,
VAImage *out_image)
{
VAStatus status;
status = vaSyncSurface(p->display, va_surface->id);
if (!check_va_status(status, "vaSyncSurface()"))
return -2;
int w = va_surface->w;
int h = va_surface->h;
status = vaCreateImage(p->display, fmt, w, h, out_image);
if (!check_va_status(status, "vaCreateImage()"))
return -2;
status = vaGetImage(p->display, va_surface->id, 0, 0, w, h,
out_image->image_id);
if (status != VA_STATUS_SUCCESS) {
vaDestroyImage(p->display, out_image->image_id);
return -1;
}
return 0;
}
static struct mp_image *download_surface(struct priv *p,
struct vaapi_surface *va_surface)
{
// We have no clue which format will work, so try them all.
// This code is just for screenshots, so it's ok not to cache the right
// format (to prevent unnecessary work), and we don't attempt to use
// vaDeriveImage() for direct access either.
for (int i = 0; i < p->va_num_image_formats; i++) {
VAImageFormat *fmt = &p->va_image_formats[i];
int mpfmt = va_fourcc_to_imgfmt(fmt->fourcc);
if (!mpfmt)
continue;
VAImage image;
int r = try_get_surface(p, fmt, va_surface, &image);
if (r == -1)
continue;
if (r < 0)
return NULL;
struct mp_image *res = NULL;
struct mp_image tmp;
if (map_image(p, &image, mpfmt, &tmp) >= 0) {
res = mp_image_alloc(mpfmt, tmp.w, tmp.h);
mp_image_copy(res, &tmp);
unmap_image(p, &image);
}
vaDestroyImage(p->display, image.image_id);
return res;
}
MP_ERR(p, "failed to get surface data.\n");
return NULL;
}
static void draw_image(struct vo *vo, mp_image_t *mpi)
{
struct priv *p = vo->priv;
if (!IMGFMT_IS_VAAPI(mpi->imgfmt)) {
struct mp_image *surface = p->swdec_surfaces[p->output_surface];
struct vaapi_surface *va_surface = to_vaapi_surface(p, surface);
if (!va_surface)
return;
if (upload_surface(p, va_surface, mpi) < 0)
return;
mp_image_copy_attributes(surface, mpi);
mpi = surface;
}
mp_image_setrefp(&p->output_surfaces[p->output_surface], mpi);
}
static struct mp_image *get_screenshot(struct priv *p)
{
struct vaapi_surface *va_surface =
to_vaapi_surface(p, p->output_surfaces[p->visible_surface]);
if (!va_surface)
return NULL;
struct mp_image *img = download_surface(p, va_surface);
if (!img)
return NULL;
struct mp_image_params params = p->image_params;
params.imgfmt = img->imgfmt;
mp_image_params_guess_csp(&params); // ensure colorspace consistency
mp_image_set_params(img, &params);
return img;
}
static bool redraw_frame(struct priv *p)
{
p->output_surface = p->visible_surface;
return render_to_screen(p, p->output_surfaces[p->output_surface]);
}
static void free_subpicture(struct priv *p, struct vaapi_osd_image *img)
{
if (img->image.image_id != VA_INVALID_ID)
vaDestroyImage(p->display, img->image.image_id);
if (img->subpic_id != VA_INVALID_ID)
vaDestroySubpicture(p->display, img->subpic_id);
img->image.image_id = VA_INVALID_ID;
img->subpic_id = VA_INVALID_ID;
}
static int new_subpicture(struct priv *p, int w, int h,
struct vaapi_osd_image *out)
{
VAStatus status;
free_subpicture(p, out);
struct vaapi_osd_image m = {
.image = {.image_id = VA_INVALID_ID, .buf = VA_INVALID_ID},
.subpic_id = VA_INVALID_ID,
.w = w,
.h = h,
};
status = vaCreateImage(p->display, &p->osd_format, w, h, &m.image);
if (!check_va_status(status, "vaCreateImage()"))
goto error;
status = vaCreateSubpicture(p->display, m.image.image_id, &m.subpic_id);
if (!check_va_status(status, "vaCreateSubpicture()"))
goto error;
*out = m;
return 0;
error:
free_subpicture(p, &m);
MP_ERR(p, "failed to allocate OSD sub-picture of size %dx%d.\n", w, h);
return -1;
}
static void draw_osd_cb(void *pctx, struct sub_bitmaps *imgs)
{
struct priv *p = pctx;
struct vaapi_osd_part *part = &p->osd_parts[imgs->render_index];
if (imgs->bitmap_pos_id != part->bitmap_pos_id) {
part->bitmap_pos_id = imgs->bitmap_pos_id;
osd_scale_rgba(part->conv_cache, imgs);
struct mp_rect bb;
if (!mp_sub_bitmaps_bb(imgs, &bb))
goto error;
// Prevent filtering artifacts on borders
int pad = 2;
int w = bb.x1 - bb.x0;
int h = bb.y1 - bb.y0;
if (part->image.w < w + pad || part->image.h < h + pad) {
int sw = MP_ALIGN_UP(w + pad, 64);
int sh = MP_ALIGN_UP(h + pad, 64);
if (new_subpicture(p, sw, sh, &part->image) < 0)
goto error;
}
struct vaapi_osd_image *img = &part->image;
struct mp_image vaimg;
if (map_image(p, &img->image, IMGFMT_BGRA, &vaimg) < 0)
goto error;
// Clear borders and regions uncovered by sub-bitmaps
mp_image_clear(&vaimg, 0, 0, w + pad, h + pad);
for (int n = 0; n < imgs->num_parts; n++) {
struct sub_bitmap *sub = &imgs->parts[n];
// Note: nothing guarantees that the sub-bitmaps don't overlap.
// But in all currently existing cases, they don't.
// We simply hope that this won't change, and nobody will
// ever notice our little shortcut here.
size_t dst = (sub->y - bb.y0) * vaimg.stride[0] +
(sub->x - bb.x0) * 4;
memcpy_pic(vaimg.planes[0] + dst, sub->bitmap, sub->w * 4, sub->h,
vaimg.stride[0], sub->stride);
}
if (unmap_image(p, &img->image) < 0)
goto error;
part->subpic = (struct vaapi_subpic) {
.id = img->subpic_id,
.src_x = 0, .src_y = 0,
.src_w = w, .src_h = h,
.dst_x = bb.x0, .dst_y = bb.y0,
.dst_w = w, .dst_h = h,
};
}
part->active = true;
error:
;
}
static void draw_osd(struct vo *vo, struct osd_state *osd)
{
struct priv *p = vo->priv;
if (!p->osd_format.fourcc)
return;
struct mp_osd_res vid_res = {
.w = p->image_params.w,
.h = p->image_params.h,
.display_par = 1.0 / vo->aspdat.par,
.video_par = vo->aspdat.par,
};
struct mp_osd_res *res;
if (p->osd_screen) {
res = &p->screen_osd_res;
} else {
res = &vid_res;
}
for (int n = 0; n < MAX_OSD_PARTS; n++)
p->osd_parts[n].active = false;
osd_draw(osd, *res, osd->vo_pts, 0, osd_formats, draw_osd_cb, p);
}
static int get_displayattribtype(const char *name)
{
if (!strcasecmp(name, "brightness"))
return VADisplayAttribBrightness;
else if (!strcasecmp(name, "contrast"))
return VADisplayAttribContrast;
else if (!strcasecmp(name, "saturation"))
return VADisplayAttribSaturation;
else if (!strcasecmp(name, "hue"))
return VADisplayAttribHue;
return -1;
}
static VADisplayAttribute *get_display_attribute(struct priv *p,
const char *name)
{
int type = get_displayattribtype(name);
for (int n = 0; n < p->va_num_display_attrs; n++) {
VADisplayAttribute *attr = &p->va_display_attrs[n];
if (attr->type == type)
return attr;
}
return NULL;
}
static int get_equalizer(struct priv *p, const char *name, int *value)
{
VADisplayAttribute * const attr = get_display_attribute(p, name);
if (!attr || !(attr->flags & VA_DISPLAY_ATTRIB_GETTABLE))
return VO_NOTIMPL;
/* normalize to -100 .. 100 range */
int r = attr->max_value - attr->min_value;
if (r == 0)
return VO_NOTIMPL;
*value = ((attr->value - attr->min_value) * 200) / r - 100;
return VO_TRUE;
}
static int set_equalizer(struct priv *p, const char *name, int value)
{
VADisplayAttribute * const attr = get_display_attribute(p, name);
VAStatus status;
if (!attr || !(attr->flags & VA_DISPLAY_ATTRIB_SETTABLE))
return VO_NOTIMPL;
/* normalize to attribute value range */
int r = attr->max_value - attr->min_value;
if (r == 0)
return VO_NOTIMPL;
attr->value = ((value + 100) * r) / 200 + attr->min_value;
status = vaSetDisplayAttributes(p->display, attr, 1);
if (!check_va_status(status, "vaSetDisplayAttributes()"))
return VO_FALSE;
return VO_TRUE;
}
static int control(struct vo *vo, uint32_t request, void *data)
{
struct priv *p = vo->priv;
switch (request) {
case VOCTRL_GET_DEINTERLACE:
*(int*)data = !!p->deint;
return VO_TRUE;
case VOCTRL_SET_DEINTERLACE:
p->deint = *(int*)data ? p->deint_type : 0;
return VO_TRUE;
case VOCTRL_GET_HWDEC_INFO: {
struct mp_hwdec_info *arg = data;
arg->vaapi_ctx = &p->mpvaapi;
return true;
}
case VOCTRL_SET_EQUALIZER: {
struct voctrl_set_equalizer_args *eq = data;
return set_equalizer(p, eq->name, eq->value);
}
case VOCTRL_GET_EQUALIZER: {
struct voctrl_get_equalizer_args *eq = data;
return get_equalizer(p, eq->name, eq->valueptr);
}
case VOCTRL_REDRAW_FRAME:
return redraw_frame(p);
case VOCTRL_SCREENSHOT: {
struct voctrl_screenshot_args *args = data;
args->out_image = get_screenshot(p);
return true;
}
case VOCTRL_GET_PANSCAN:
return VO_TRUE;
case VOCTRL_SET_PANSCAN:
resize(p);
return VO_TRUE;
}
int events = 0;
int r = vo_x11_control(vo, &events, request, data);
if (events & VO_EVENT_RESIZE)
resize(p);
if (events & VO_EVENT_EXPOSE)
vo->want_redraw = true;
return r;
}
static void uninit(struct vo *vo)
{
struct priv *p = vo->priv;
free_video_specific(p);
for (int n = 0; n < p->num_video_surfaces; n++) {
struct vaapi_surface *surface = p->video_surfaces[n];
// Nothing is allowed to reference HW surfaces past VO lifetime.
assert(!surface->is_used);
talloc_free(surface);
}
p->num_video_surfaces = 0;
for (int n = 0; n < MAX_OSD_PARTS; n++) {
struct vaapi_osd_part *part = &p->osd_parts[n];
free_subpicture(p, &part->image);
}
if (p->display) {
vaTerminate(p->display);
p->display = NULL;
}
vo_x11_uninit(vo);
}
static int preinit(struct vo *vo)
{
struct priv *p = vo->priv;
p->vo = vo;
p->log = vo->log;
VAStatus status;
if (!vo_x11_init(vo))
return -1;
p->display = vaGetDisplay(vo->x11->display);
if (!p->display)
return -1;
int major_version, minor_version;
status = vaInitialize(p->display, &major_version, &minor_version);
if (!check_va_status(status, "vaInitialize()"))
return -1;
MP_VERBOSE(vo, "VA API version %d.%d\n", major_version, minor_version);
p->mpvaapi.display = p->display;
p->mpvaapi.priv = vo;
p->mpvaapi.flush = flush_surfaces;
p->mpvaapi.get_surface = get_surface;
int max_image_formats = vaMaxNumImageFormats(p->display);
p->va_image_formats = talloc_array(vo, VAImageFormat, max_image_formats);
status = vaQueryImageFormats(p->display, p->va_image_formats,
&p->va_num_image_formats);
if (!check_va_status(status, "vaQueryImageFormats()"))
return -1;
MP_VERBOSE(vo, "%d image formats available:\n", p->va_num_image_formats);
for (int i = 0; i < p->va_num_image_formats; i++)
MP_VERBOSE(vo, " %s\n", STR_FOURCC(p->va_image_formats[i].fourcc));
int max_subpic_formats = vaMaxNumSubpictureFormats(p->display);
p->va_subpic_formats = talloc_array(vo, VAImageFormat, max_subpic_formats);
p->va_subpic_flags = talloc_array(vo, unsigned int, max_subpic_formats);
status = vaQuerySubpictureFormats(p->display,
p->va_subpic_formats,
p->va_subpic_flags,
&p->va_num_subpic_formats);
if (!check_va_status(status, "vaQuerySubpictureFormats()"))
p->va_num_subpic_formats = 0;
MP_VERBOSE(vo, "%d subpicture formats available:\n",
p->va_num_subpic_formats);
for (int i = 0; i < p->va_num_subpic_formats; i++) {
MP_VERBOSE(vo, " %s, flags 0x%x\n",
STR_FOURCC(p->va_subpic_formats[i].fourcc),
p->va_subpic_flags[i]);
if (p->va_subpic_formats[i].fourcc == OSD_VA_FORMAT) {
p->osd_format = p->va_subpic_formats[i];
if (!p->force_scaled_osd) {
p->osd_screen =
p->va_subpic_flags[i] & VA_SUBPICTURE_DESTINATION_IS_SCREEN_COORD;
}
}
}
if (!p->osd_format.fourcc)
MP_ERR(vo, "OSD format not supported. Disabling OSD.\n");
for (int n = 0; n < MAX_OSD_PARTS; n++) {
struct vaapi_osd_part *part = &p->osd_parts[n];
part->image.image.image_id = VA_INVALID_ID;
part->image.subpic_id = VA_INVALID_ID;
part->conv_cache = talloc_steal(vo, osd_conv_cache_new());
}
int max_display_attrs = vaMaxNumDisplayAttributes(p->display);
p->va_display_attrs = talloc_array(vo, VADisplayAttribute, max_display_attrs);
if (p->va_display_attrs) {
status = vaQueryDisplayAttributes(p->display, p->va_display_attrs,
&p->va_num_display_attrs);
if (!check_va_status(status, "vaQueryDisplayAttributes()"))
p->va_num_display_attrs = 0;
}
return 0;
}
#define OPT_BASE_STRUCT struct priv
const struct vo_driver video_out_vaapi = {
.info = &(const vo_info_t) {
"VA API with X11",
"vaapi",
"Gwenole Beauchesne <gbeauchesne@splitted-desktop.com> and others",
""
},
.preinit = preinit,
.query_format = query_format,
.reconfig = reconfig,
.control = control,
.draw_image = draw_image,
.draw_osd = draw_osd,
.flip_page = flip_page,
.uninit = uninit,
.priv_size = sizeof(struct priv),
.priv_defaults = &(const struct priv) {
.scaling = VA_FILTER_SCALING_DEFAULT,
.deint_type = 2,
.deint = 0,
},
.options = (const struct m_option[]) {
#if USE_VAAPI_SCALING
OPT_CHOICE("scaling", scaling, 0,
({"default", VA_FILTER_SCALING_DEFAULT},
{"fast", VA_FILTER_SCALING_FAST},
{"hq", VA_FILTER_SCALING_HQ},
{"nla", VA_FILTER_SCALING_NL_ANAMORPHIC})),
#endif
OPT_CHOICE("deint", deint_type, 0,
({"no", 0},
{"first-field", 1},
{"bob", 2})),
OPT_FLAG("scaled-osd", force_scaled_osd, 0),
{0}
},
};
Reference in New Issue View Git Blame Copy Permalink