mpv/video/out/opengl/context_vdpau.c

390 lines
12 KiB
C
Raw Normal View History

/*
* This file is part of mpv.
*
* mpv is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with mpv. If not, see <http://www.gnu.org/licenses/>.
*/
#include <X11/Xlib.h>
#include <GL/glx.h>
#include "video/vdpau.h"
#include "video/out/x11_common.h"
#include "context.h"
// This is a GL_NV_vdpau_interop specification bug, and headers (unfortunately)
// follow it. I'm not sure about the original nvidia headers.
#define BRAINDEATH(x) ((void *)(uintptr_t)(x))
#define NUM_SURFACES 4
struct surface {
int w, h;
VdpOutputSurface surface;
// This nested shitshow of handles to the same object piss me off.
GLvdpauSurfaceNV registered;
bool mapped;
GLuint texture;
GLuint fbo;
};
struct priv {
GLXContext context;
struct mp_vdpau_ctx *vdp;
VdpPresentationQueueTarget vdp_target;
VdpPresentationQueue vdp_queue;
int num_surfaces;
struct surface surfaces[NUM_SURFACES];
int current_surface;
};
typedef GLXContext (*glXCreateContextAttribsARBProc)
(Display*, GLXFBConfig, GLXContext, Bool, const int*);
static bool create_context_x11(struct MPGLContext *ctx, int vo_flags)
{
struct priv *glx_ctx = ctx->priv;
struct vo *vo = ctx->vo;
int glx_major, glx_minor;
if (!glXQueryVersion(vo->x11->display, &glx_major, &glx_minor)) {
MP_ERR(vo, "GLX not found.\n");
return false;
}
int glx_attribs[] = {
GLX_X_RENDERABLE, True,
GLX_X_VISUAL_TYPE, GLX_TRUE_COLOR,
GLX_RED_SIZE, 1,
GLX_GREEN_SIZE, 1,
GLX_BLUE_SIZE, 1,
GLX_DOUBLEBUFFER, True,
None
};
int fbcount;
GLXFBConfig *fbcs = glXChooseFBConfig(vo->x11->display, vo->x11->screen,
glx_attribs, &fbcount);
if (!fbcs)
return false;
// The list in fbc is sorted (so that the first element is the best).
GLXFBConfig fbc = fbcount > 0 ? fbcs[0] : NULL;
XFree(fbcs);
if (!fbc) {
MP_ERR(vo, "no GLX support present\n");
return false;
}
glXCreateContextAttribsARBProc glXCreateContextAttribsARB =
(glXCreateContextAttribsARBProc)
glXGetProcAddressARB((const GLubyte *)"glXCreateContextAttribsARB");
const char *glxstr =
glXQueryExtensionsString(vo->x11->display, vo->x11->screen);
bool have_ctx_ext = glxstr && !!strstr(glxstr, "GLX_ARB_create_context");
if (!(have_ctx_ext && glXCreateContextAttribsARB)) {
return false;
}
int ctx_flags = vo_flags & VOFLAG_GL_DEBUG ? GLX_CONTEXT_DEBUG_BIT_ARB : 0;
int context_attribs[] = {
GLX_CONTEXT_MAJOR_VERSION_ARB, 4,
GLX_CONTEXT_MINOR_VERSION_ARB, 0,
GLX_CONTEXT_PROFILE_MASK_ARB, GLX_CONTEXT_CORE_PROFILE_BIT_ARB,
GLX_CONTEXT_FLAGS_ARB, ctx_flags,
None
};
GLXContext context = glXCreateContextAttribsARB(vo->x11->display, fbc, 0,
True, context_attribs);
if (!context)
return false;
// Pass 0 as drawable for offscreen use. This is probably (?) not valid in
// standard GLX, but the nVidia drivers accept it.
if (!glXMakeCurrent(vo->x11->display, 0, context)) {
MP_FATAL(vo, "Could not set GLX context!\n");
glXDestroyContext(vo->x11->display, context);
return false;
}
glx_ctx->context = context;
mpgl_load_functions(ctx->gl, (void *)glXGetProcAddressARB, glxstr, vo->log);
return true;
}
static int create_vdpau_objects(struct MPGLContext *ctx)
{
struct priv *p = ctx->priv;
VdpDevice dev = p->vdp->vdp_device;
struct vdp_functions *vdp = &p->vdp->vdp;
VdpStatus vdp_st;
ctx->gl->VDPAUInitNV(BRAINDEATH(dev), p->vdp->get_proc_address);
vdp_st = vdp->presentation_queue_target_create_x11(dev, ctx->vo->x11->window,
&p->vdp_target);
CHECK_VDP_ERROR(ctx, "creating vdp target");
vdp_st = vdp->presentation_queue_create(dev, p->vdp_target, &p->vdp_queue);
CHECK_VDP_ERROR(ctx, "creating vdp presentation queue");
return 0;
}
static void destroy_vdpau_surface(struct MPGLContext *ctx,
struct surface *surface)
{
struct priv *p = ctx->priv;
struct vdp_functions *vdp = &p->vdp->vdp;
VdpStatus vdp_st;
GL *gl = ctx->gl;
if (surface->mapped)
gl->VDPAUUnmapSurfacesNV(1, &surface->registered);
gl->DeleteFramebuffers(1, &surface->fbo);
gl->DeleteTextures(1, &surface->texture);
if (surface->registered)
gl->VDPAUUnregisterSurfaceNV(surface->registered);
if (surface->surface != VDP_INVALID_HANDLE) {
vdp_st = vdp->output_surface_destroy(surface->surface);
CHECK_VDP_WARNING(ctx, "destroying vdpau surface");
}
*surface = (struct surface){
.surface = VDP_INVALID_HANDLE,
};
}
static int recreate_vdpau_surface(struct MPGLContext *ctx,
struct surface *surface)
{
struct priv *p = ctx->priv;
VdpDevice dev = p->vdp->vdp_device;
struct vdp_functions *vdp = &p->vdp->vdp;
VdpStatus vdp_st;
GL *gl = ctx->gl;
destroy_vdpau_surface(ctx, surface);
surface->w = ctx->vo->dwidth;
surface->h = ctx->vo->dheight;
vdp_st = vdp->output_surface_create(dev, VDP_RGBA_FORMAT_B8G8R8A8,
surface->w, surface->h,
&surface->surface);
CHECK_VDP_ERROR_NORETURN(ctx, "creating vdp output surface");
if (vdp_st != VDP_STATUS_OK)
goto error;
gl->GenTextures(1, &surface->texture);
surface->registered =
gl->VDPAURegisterOutputSurfaceNV(BRAINDEATH(surface->surface),
GL_TEXTURE_2D,
1, &surface->texture);
if (!surface->registered) {
MP_ERR(ctx, "could not register vdpau surface with GL\n");
goto error;
}
gl->VDPAUSurfaceAccessNV(surface->registered, GL_WRITE_DISCARD_NV);
gl->VDPAUMapSurfacesNV(1, &surface->registered);
surface->mapped = true;
gl->GenFramebuffers(1, &surface->fbo);
gl->BindFramebuffer(GL_FRAMEBUFFER, surface->fbo);
gl->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_TEXTURE_2D, surface->texture, 0);
GLenum err = gl->CheckFramebufferStatus(GL_FRAMEBUFFER);
if (err != GL_FRAMEBUFFER_COMPLETE) {
MP_ERR(ctx, "Framebuffer completeness check failed (error=%d).\n",
(int)err);
goto error;
}
gl->BindFramebuffer(GL_FRAMEBUFFER, 0);
gl->VDPAUUnmapSurfacesNV(1, &surface->registered);
surface->mapped = false;
return 0;
error:
destroy_vdpau_surface(ctx, surface);
return -1;
}
static void glx_uninit(MPGLContext *ctx)
{
struct priv *p = ctx->priv;
if (p->vdp) {
struct vdp_functions *vdp = &p->vdp->vdp;
VdpStatus vdp_st;
for (int n = 0; n < p->num_surfaces; n++)
destroy_vdpau_surface(ctx, &p->surfaces[n]);
if (p->vdp_queue != VDP_INVALID_HANDLE) {
vdp_st = vdp->presentation_queue_destroy(p->vdp_queue);
CHECK_VDP_WARNING(ctx, "destroying presentation queue");
}
if (p->vdp_target != VDP_INVALID_HANDLE) {
vdp_st = vdp->presentation_queue_target_destroy(p->vdp_target);
CHECK_VDP_WARNING(ctx, "destroying presentation target");
}
mp_vdpau_destroy(p->vdp);
}
if (p->context) {
Display *display = ctx->vo->x11->display;
glXMakeCurrent(display, None, NULL);
glXDestroyContext(display, p->context);
}
vo_x11_uninit(ctx->vo);
}
static int glx_init(struct MPGLContext *ctx, int flags)
{
struct vo *vo = ctx->vo;
struct priv *p = ctx->priv;
p->vdp_queue = VDP_INVALID_HANDLE;
p->vdp_target = VDP_INVALID_HANDLE;
if (ctx->vo->probing)
goto uninit;
if (!vo_x11_init(ctx->vo))
goto uninit;
p->vdp = mp_vdpau_create_device_x11(ctx->log, ctx->vo->x11->display, false);
if (!p->vdp)
goto uninit;
if (!vo_x11_create_vo_window(vo, NULL, "vdpauglx"))
goto uninit;
if (!create_context_x11(ctx, flags))
goto uninit;
if (!(ctx->gl->mpgl_caps & MPGL_CAP_VDPAU))
goto uninit;
if (create_vdpau_objects(ctx) < 0)
goto uninit;
p->num_surfaces = NUM_SURFACES;
for (int n = 0; n < p->num_surfaces; n++)
p->surfaces[n].surface = VDP_INVALID_HANDLE;
ctx->flip_v = true;
return 0;
uninit:
glx_uninit(ctx);
return -1;
}
static int glx_reconfig(struct MPGLContext *ctx)
{
vo_x11_config_vo_window(ctx->vo);
return 0;
}
static int glx_control(struct MPGLContext *ctx, int *events, int request,
void *arg)
{
return vo_x11_control(ctx->vo, events, request, arg);
}
static void glx_start_frame(struct MPGLContext *ctx)
{
struct priv *p = ctx->priv;
struct vdp_functions *vdp = &p->vdp->vdp;
VdpStatus vdp_st;
GL *gl = ctx->gl;
struct surface *surface = &p->surfaces[p->current_surface];
if (surface->surface != VDP_INVALID_HANDLE) {
VdpTime prev_vsync_time;
vdp_st = vdp->presentation_queue_block_until_surface_idle(p->vdp_queue,
surface->surface,
&prev_vsync_time);
CHECK_VDP_WARNING(ctx, "waiting for surface failed");
}
if (surface->w != ctx->vo->dwidth || surface->h != ctx->vo->dheight)
recreate_vdpau_surface(ctx, surface);
ctx->main_fb = surface->fbo; // 0 if creating the surface failed
if (surface->surface != VDP_INVALID_HANDLE) {
gl->VDPAUMapSurfacesNV(1, &surface->registered);
surface->mapped = true;
}
}
static void glx_swap_buffers(struct MPGLContext *ctx)
{
struct priv *p = ctx->priv;
struct vdp_functions *vdp = &p->vdp->vdp;
VdpStatus vdp_st;
GL *gl = ctx->gl;
struct surface *surface = &p->surfaces[p->current_surface];
if (surface->surface == VDP_INVALID_HANDLE)
return; // surface alloc probably failed before
if (surface->mapped)
gl->VDPAUUnmapSurfacesNV(1, &surface->registered);
surface->mapped = false;
vdp_st = vdp->presentation_queue_display(p->vdp_queue, surface->surface,
0, 0, 0);
CHECK_VDP_WARNING(ctx, "trying to present vdp surface");
p->current_surface = (p->current_surface + 1) % p->num_surfaces;
}
static void glx_wakeup(struct MPGLContext *ctx)
{
vo_x11_wakeup(ctx->vo);
}
static void glx_wait_events(struct MPGLContext *ctx, int64_t until_time_us)
{
vo_x11_wait_events(ctx->vo, until_time_us);
}
const struct mpgl_driver mpgl_driver_vdpauglx = {
.name = "vdpauglx",
.priv_size = sizeof(struct priv),
.init = glx_init,
.reconfig = glx_reconfig,
.start_frame = glx_start_frame,
.swap_buffers = glx_swap_buffers,
.control = glx_control,
.wakeup = glx_wakeup,
.wait_events = glx_wait_events,
.uninit = glx_uninit,
};