Google Git
Sign in
android / platform / external / mesa3d / b6670157d742548e7f2430614786c733eb4c20e9 / . / src / glx / dri3_glx.c
blob: 4472a0bed2676b3d7b009dcb5d201624dc833f44 [file] [log] [blame]
/*
* Copyright © 2013 Keith Packard
*
* Permission to use, copy, modify, distribute, and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
* the above copyright notice appear in all copies and that both that copyright
* notice and this permission notice appear in supporting documentation, and
* that the name of the copyright holders not be used in advertising or
* publicity pertaining to distribution of the software without specific,
* written prior permission. The copyright holders make no representations
* about the suitability of this software for any purpose. It is provided "as
* is" without express or implied warranty.
*
* THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
* EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
/*
* Portions of this code were adapted from dri2_glx.c which carries the
* following copyright:
*
* Copyright © 2008 Red Hat, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Soft-
* ware"), to deal in the Software without restriction, including without
* limitation the rights to use, copy, modify, merge, publish, distribute,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, provided that the above copyright
* notice(s) and this permission notice appear in all copies of the Soft-
* ware and that both the above copyright notice(s) and this permission
* notice appear in supporting documentation.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
* ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY
* RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN
* THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSE-
* QUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFOR-
* MANCE OF THIS SOFTWARE.
*
* Except as contained in this notice, the name of a copyright holder shall
* not be used in advertising or otherwise to promote the sale, use or
* other dealings in this Software without prior written authorization of
* the copyright holder.
*
* Authors:
* Kristian Høgsberg (krh@redhat.com)
*/
#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
#include <X11/Xlib.h>
#include <X11/extensions/Xfixes.h>
#include <X11/Xlib-xcb.h>
#include <X11/xshmfence.h>
#include <xcb/xcb.h>
#include <xcb/dri3.h>
#include <xcb/present.h>
#include <GL/gl.h>
#include "glxclient.h"
#include <dlfcn.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/mman.h>
#include <sys/time.h>
#include "dri_common.h"
#include "dri3_priv.h"
#include "loader.h"
#include "dri2.h"
static struct dri3_drawable *
loader_drawable_to_dri3_drawable(struct loader_dri3_drawable *draw) {
size_t offset = offsetof(struct dri3_drawable, loader_drawable);
return (struct dri3_drawable *)(((void*) draw) - offset);
}
static int
glx_dri3_get_swap_interval(struct loader_dri3_drawable *draw)
{
struct dri3_drawable *priv = loader_drawable_to_dri3_drawable(draw);
return priv->swap_interval;
}
static int
glx_dri3_clamp_swap_interval(struct loader_dri3_drawable *draw, int interval)
{
return interval;
}
static void
glx_dri3_set_swap_interval(struct loader_dri3_drawable *draw, int interval)
{
struct dri3_drawable *priv = loader_drawable_to_dri3_drawable(draw);
priv->swap_interval = interval;
}
static void
glx_dri3_set_drawable_size(struct loader_dri3_drawable *draw,
int width, int height)
{
/* Nothing to do */
}
static bool
glx_dri3_in_current_context(struct loader_dri3_drawable *draw)
{
struct dri3_drawable *priv = loader_drawable_to_dri3_drawable(draw);
struct dri3_context *pcp = (struct dri3_context *) __glXGetCurrentContext();
struct dri3_screen *psc = (struct dri3_screen *) priv->base.psc;
return (&pcp->base != &dummyContext) && pcp->base.psc == &psc->base;
}
static __DRIcontext *
glx_dri3_get_dri_context(struct loader_dri3_drawable *draw)
{
struct glx_context *gc = __glXGetCurrentContext();
struct dri3_context *dri3Ctx = (struct dri3_context *) gc;
return (gc != &dummyContext) ? dri3Ctx->driContext : NULL;
}
static __DRIscreen *
glx_dri3_get_dri_screen(struct loader_dri3_drawable *draw)
{
struct glx_context *gc = __glXGetCurrentContext();
struct dri3_context *pcp = (struct dri3_context *) gc;
struct dri3_screen *psc = (struct dri3_screen *) pcp->base.psc;
return (gc != &dummyContext && psc) ? psc->driScreen : NULL;
}
static void
glx_dri3_flush_drawable(struct loader_dri3_drawable *draw, unsigned flags)
{
loader_dri3_flush(draw, flags, __DRI2_THROTTLE_SWAPBUFFER);
}
static void
glx_dri3_show_fps(struct loader_dri3_drawable *draw, uint64_t current_ust)
{
struct dri3_drawable *priv = loader_drawable_to_dri3_drawable(draw);
const uint64_t interval =
((struct dri3_screen *) priv->base.psc)->show_fps_interval;
if (!interval)
return;
priv->frames++;
/* DRI3+Present together uses microseconds for UST. */
if (priv->previous_ust + interval * 1000000 <= current_ust) {
if (priv->previous_ust) {
fprintf(stderr, "libGL: FPS = %.1f\n",
((uint64_t) priv->frames * 1000000) /
(double)(current_ust - priv->previous_ust));
}
priv->frames = 0;
priv->previous_ust = current_ust;
}
}
static const struct loader_dri3_vtable glx_dri3_vtable = {
.get_swap_interval = glx_dri3_get_swap_interval,
.clamp_swap_interval = glx_dri3_clamp_swap_interval,
.set_swap_interval = glx_dri3_set_swap_interval,
.set_drawable_size = glx_dri3_set_drawable_size,
.in_current_context = glx_dri3_in_current_context,
.get_dri_context = glx_dri3_get_dri_context,
.get_dri_screen = glx_dri3_get_dri_screen,
.flush_drawable = glx_dri3_flush_drawable,
.show_fps = glx_dri3_show_fps,
};
static const struct glx_context_vtable dri3_context_vtable;
static void
dri3_destroy_context(struct glx_context *context)
{
struct dri3_context *pcp = (struct dri3_context *) context;
struct dri3_screen *psc = (struct dri3_screen *) context->psc;
driReleaseDrawables(&pcp->base);
free((char *) context->extensions);
(*psc->core->destroyContext) (pcp->driContext);
free(pcp);
}
static Bool
dri3_bind_context(struct glx_context *context, struct glx_context *old,
GLXDrawable draw, GLXDrawable read)
{
struct dri3_context *pcp = (struct dri3_context *) context;
struct dri3_screen *psc = (struct dri3_screen *) pcp->base.psc;
struct dri3_drawable *pdraw, *pread;
__DRIdrawable *dri_draw = NULL, *dri_read = NULL;
pdraw = (struct dri3_drawable *) driFetchDrawable(context, draw);
pread = (struct dri3_drawable *) driFetchDrawable(context, read);
driReleaseDrawables(&pcp->base);
if (pdraw)
dri_draw = pdraw->loader_drawable.dri_drawable;
else if (draw != None)
return GLXBadDrawable;
if (pread)
dri_read = pread->loader_drawable.dri_drawable;
else if (read != None)
return GLXBadDrawable;
if (!(*psc->core->bindContext) (pcp->driContext, dri_draw, dri_read))
return GLXBadContext;
return Success;
}
static void
dri3_unbind_context(struct glx_context *context, struct glx_context *new)
{
struct dri3_context *pcp = (struct dri3_context *) context;
struct dri3_screen *psc = (struct dri3_screen *) pcp->base.psc;
(*psc->core->unbindContext) (pcp->driContext);
}
static struct glx_context *
dri3_create_context_attribs(struct glx_screen *base,
struct glx_config *config_base,
struct glx_context *shareList,
unsigned num_attribs,
const uint32_t *attribs,
unsigned *error)
{
struct dri3_context *pcp = NULL;
struct dri3_context *pcp_shared = NULL;
struct dri3_screen *psc = (struct dri3_screen *) base;
__GLXDRIconfigPrivate *config = (__GLXDRIconfigPrivate *) config_base;
__DRIcontext *shared = NULL;
uint32_t minor_ver = 1;
uint32_t major_ver = 2;
uint32_t flags = 0;
unsigned api;
int reset = __DRI_CTX_RESET_NO_NOTIFICATION;
uint32_t ctx_attribs[2 * 5];
unsigned num_ctx_attribs = 0;
uint32_t render_type;
/* Remap the GLX tokens to DRI2 tokens.
*/
if (!dri2_convert_glx_attribs(num_attribs, attribs,
&major_ver, &minor_ver,
&render_type, &flags, &api,
&reset, error))
goto error_exit;
/* Check the renderType value */
if (!validate_renderType_against_config(config_base, render_type))
goto error_exit;
if (shareList) {
pcp_shared = (struct dri3_context *) shareList;
shared = pcp_shared->driContext;
}
pcp = calloc(1, sizeof *pcp);
if (pcp == NULL) {
*error = __DRI_CTX_ERROR_NO_MEMORY;
goto error_exit;
}
if (!glx_context_init(&pcp->base, &psc->base, &config->base))
goto error_exit;
ctx_attribs[num_ctx_attribs++] = __DRI_CTX_ATTRIB_MAJOR_VERSION;
ctx_attribs[num_ctx_attribs++] = major_ver;
ctx_attribs[num_ctx_attribs++] = __DRI_CTX_ATTRIB_MINOR_VERSION;
ctx_attribs[num_ctx_attribs++] = minor_ver;
/* Only send a value when the non-default value is requested. By doing
* this we don't have to check the driver's DRI3 version before sending the
* default value.
*/
if (reset != __DRI_CTX_RESET_NO_NOTIFICATION) {
ctx_attribs[num_ctx_attribs++] = __DRI_CTX_ATTRIB_RESET_STRATEGY;
ctx_attribs[num_ctx_attribs++] = reset;
}
if (flags != 0) {
ctx_attribs[num_ctx_attribs++] = __DRI_CTX_ATTRIB_FLAGS;
/* The current __DRI_CTX_FLAG_* values are identical to the
* GLX_CONTEXT_*_BIT values.
*/
ctx_attribs[num_ctx_attribs++] = flags;
}
pcp->driContext =
(*psc->image_driver->createContextAttribs) (psc->driScreen,
api,
config->driConfig,
shared,
num_ctx_attribs / 2,
ctx_attribs,
error,
pcp);
if (pcp->driContext == NULL)
goto error_exit;
pcp->base.vtable = &dri3_context_vtable;
return &pcp->base;
error_exit:
free(pcp);
return NULL;
}
static struct glx_context *
dri3_create_context(struct glx_screen *base,
struct glx_config *config_base,
struct glx_context *shareList, int renderType)
{
unsigned int error;
return dri3_create_context_attribs(base, config_base, shareList,
0, NULL, &error);
}
static void
dri3_destroy_drawable(__GLXDRIdrawable *base)
{
struct dri3_drawable *pdraw = (struct dri3_drawable *) base;
loader_dri3_drawable_fini(&pdraw->loader_drawable);
free(pdraw);
}
static __GLXDRIdrawable *
dri3_create_drawable(struct glx_screen *base, XID xDrawable,
GLXDrawable drawable, struct glx_config *config_base)
{
struct dri3_drawable *pdraw;
struct dri3_screen *psc = (struct dri3_screen *) base;
__GLXDRIconfigPrivate *config = (__GLXDRIconfigPrivate *) config_base;
pdraw = calloc(1, sizeof(*pdraw));
if (!pdraw)
return NULL;
pdraw->base.destroyDrawable = dri3_destroy_drawable;
pdraw->base.xDrawable = xDrawable;
pdraw->base.drawable = drawable;
pdraw->base.psc = &psc->base;
(void) __glXInitialize(psc->base.dpy);
if (loader_dri3_drawable_init(XGetXCBConnection(base->dpy),
xDrawable, psc->driScreen,
psc->is_different_gpu, config->driConfig,
&psc->loader_dri3_ext, &glx_dri3_vtable,
&pdraw->loader_drawable)) {
free(pdraw);
return NULL;
}
return &pdraw->base;
}
/** dri3_wait_for_msc
*
* Get the X server to send an event when the target msc/divisor/remainder is
* reached.
*/
static int
dri3_wait_for_msc(__GLXDRIdrawable *pdraw, int64_t target_msc, int64_t divisor,
int64_t remainder, int64_t *ust, int64_t *msc, int64_t *sbc)
{
struct dri3_drawable *priv = (struct dri3_drawable *) pdraw;
loader_dri3_wait_for_msc(&priv->loader_drawable, target_msc, divisor,
remainder, ust, msc, sbc);
return 1;
}
/** dri3_drawable_get_msc
*
* Return the current UST/MSC/SBC triplet by asking the server
* for an event
*/
static int
dri3_drawable_get_msc(struct glx_screen *psc, __GLXDRIdrawable *pdraw,
int64_t *ust, int64_t *msc, int64_t *sbc)
{
return dri3_wait_for_msc(pdraw, 0, 0, 0, ust, msc,sbc);
}
/** dri3_wait_for_sbc
*
* Wait for the completed swap buffer count to reach the specified
* target. Presumably the application knows that this will be reached with
* outstanding complete events, or we're going to be here awhile.
*/
static int
dri3_wait_for_sbc(__GLXDRIdrawable *pdraw, int64_t target_sbc, int64_t *ust,
int64_t *msc, int64_t *sbc)
{
struct dri3_drawable *priv = (struct dri3_drawable *) pdraw;
return loader_dri3_wait_for_sbc(&priv->loader_drawable, target_sbc,
ust, msc, sbc);
}
static void
dri3_copy_sub_buffer(__GLXDRIdrawable *pdraw, int x, int y,
int width, int height,
Bool flush)
{
struct dri3_drawable *priv = (struct dri3_drawable *) pdraw;
loader_dri3_copy_sub_buffer(&priv->loader_drawable, x, y,
width, height, flush);
}
static void
dri3_wait_x(struct glx_context *gc)
{
struct dri3_drawable *priv = (struct dri3_drawable *)
GetGLXDRIDrawable(gc->currentDpy, gc->currentDrawable);
if (priv)
loader_dri3_wait_x(&priv->loader_drawable);
}
static void
dri3_wait_gl(struct glx_context *gc)
{
struct dri3_drawable *priv = (struct dri3_drawable *)
GetGLXDRIDrawable(gc->currentDpy, gc->currentDrawable);
if (priv)
loader_dri3_wait_gl(&priv->loader_drawable);
}
/**
* Called by the driver when it needs to update the real front buffer with the
* contents of its fake front buffer.
*/
static void
dri3_flush_front_buffer(__DRIdrawable *driDrawable, void *loaderPrivate)
{
struct loader_dri3_drawable *draw = loaderPrivate;
struct dri3_drawable *pdraw = loader_drawable_to_dri3_drawable(draw);
struct dri3_screen *psc;
if (!pdraw)
return;
if (!pdraw->base.psc)
return;
psc = (struct dri3_screen *) pdraw->base.psc;
(void) __glXInitialize(psc->base.dpy);
loader_dri3_flush(draw, __DRI2_FLUSH_DRAWABLE, __DRI2_THROTTLE_FLUSHFRONT);
loader_dri3_wait_gl(draw);
}
/* The image loader extension record for DRI3
*/
static const __DRIimageLoaderExtension imageLoaderExtension = {
.base = { __DRI_IMAGE_LOADER, 1 },
.getBuffers = loader_dri3_get_buffers,
.flushFrontBuffer = dri3_flush_front_buffer,
};
const __DRIuseInvalidateExtension dri3UseInvalidate = {
.base = { __DRI_USE_INVALIDATE, 1 }
};
static const __DRIextension *loader_extensions[] = {
&imageLoaderExtension.base,
&systemTimeExtension.base,
&dri3UseInvalidate.base,
NULL
};
/** dri3_swap_buffers
*
* Make the current back buffer visible using the present extension
*/
static int64_t
dri3_swap_buffers(__GLXDRIdrawable *pdraw, int64_t target_msc, int64_t divisor,
int64_t remainder, Bool flush)
{
struct dri3_drawable *priv = (struct dri3_drawable *) pdraw;
unsigned flags = __DRI2_FLUSH_DRAWABLE;
if (flush)
flags |= __DRI2_FLUSH_CONTEXT;
return loader_dri3_swap_buffers_msc(&priv->loader_drawable,
target_msc, divisor, remainder,
flags, false);
}
static int
dri3_get_buffer_age(__GLXDRIdrawable *pdraw)
{
struct dri3_drawable *priv = (struct dri3_drawable *)pdraw;
return loader_dri3_query_buffer_age(&priv->loader_drawable);
}
/** dri3_destroy_screen
*/
static void
dri3_destroy_screen(struct glx_screen *base)
{
struct dri3_screen *psc = (struct dri3_screen *) base;
/* Free the direct rendering per screen data */
(*psc->core->destroyScreen) (psc->driScreen);
driDestroyConfigs(psc->driver_configs);
close(psc->fd);
free(psc);
}
/** dri3_set_swap_interval
*
* Record the application swap interval specification,
*/
static int
dri3_set_swap_interval(__GLXDRIdrawable *pdraw, int interval)
{
struct dri3_drawable *priv = (struct dri3_drawable *) pdraw;
GLint vblank_mode = DRI_CONF_VBLANK_DEF_INTERVAL_1;
struct dri3_screen *psc = (struct dri3_screen *) priv->base.psc;
if (psc->config)
psc->config->configQueryi(psc->driScreen,
"vblank_mode", &vblank_mode);
switch (vblank_mode) {
case DRI_CONF_VBLANK_NEVER:
if (interval != 0)
return GLX_BAD_VALUE;
break;
case DRI_CONF_VBLANK_ALWAYS_SYNC:
if (interval <= 0)
return GLX_BAD_VALUE;
break;
default:
break;
}
loader_dri3_set_swap_interval(&priv->loader_drawable, interval);
return 0;
}
/** dri3_get_swap_interval
*
* Return the stored swap interval
*/
static int
dri3_get_swap_interval(__GLXDRIdrawable *pdraw)
{
struct dri3_drawable *priv = (struct dri3_drawable *) pdraw;
return priv->swap_interval;
}
static void
dri3_bind_tex_image(Display * dpy,
GLXDrawable drawable,
int buffer, const int *attrib_list)
{
struct glx_context *gc = __glXGetCurrentContext();
struct dri3_context *pcp = (struct dri3_context *) gc;
__GLXDRIdrawable *base = GetGLXDRIDrawable(dpy, drawable);
struct dri3_drawable *pdraw = (struct dri3_drawable *) base;
struct dri3_screen *psc;
if (pdraw != NULL) {
psc = (struct dri3_screen *) base->psc;
(*psc->f->invalidate)(pdraw->loader_drawable.dri_drawable);
XSync(dpy, false);
(*psc->texBuffer->setTexBuffer2) (pcp->driContext,
pdraw->base.textureTarget,
pdraw->base.textureFormat,
pdraw->loader_drawable.dri_drawable);
}
}
static void
dri3_release_tex_image(Display * dpy, GLXDrawable drawable, int buffer)
{
struct glx_context *gc = __glXGetCurrentContext();
struct dri3_context *pcp = (struct dri3_context *) gc;
__GLXDRIdrawable *base = GetGLXDRIDrawable(dpy, drawable);
struct dri3_drawable *pdraw = (struct dri3_drawable *) base;
struct dri3_screen *psc;
if (pdraw != NULL) {
psc = (struct dri3_screen *) base->psc;
if (psc->texBuffer->base.version >= 3 &&
psc->texBuffer->releaseTexBuffer != NULL)
(*psc->texBuffer->releaseTexBuffer) (pcp->driContext,
pdraw->base.textureTarget,
pdraw->loader_drawable.dri_drawable);
}
}
static const struct glx_context_vtable dri3_context_vtable = {
.destroy = dri3_destroy_context,
.bind = dri3_bind_context,
.unbind = dri3_unbind_context,
.wait_gl = dri3_wait_gl,
.wait_x = dri3_wait_x,
.use_x_font = DRI_glXUseXFont,
.bind_tex_image = dri3_bind_tex_image,
.release_tex_image = dri3_release_tex_image,
.get_proc_address = NULL,
.interop_query_device_info = dri3_interop_query_device_info,
.interop_export_object = dri3_interop_export_object
};
/** dri3_bind_extensions
*
* Enable all of the extensions supported on DRI3
*/
static void
dri3_bind_extensions(struct dri3_screen *psc, struct glx_display * priv,
const char *driverName)
{
const __DRIextension **extensions;
unsigned mask;
int i;
extensions = psc->core->getExtensions(psc->driScreen);
__glXEnableDirectExtension(&psc->base, "GLX_SGI_video_sync");
__glXEnableDirectExtension(&psc->base, "GLX_SGI_swap_control");
__glXEnableDirectExtension(&psc->base, "GLX_MESA_swap_control");
__glXEnableDirectExtension(&psc->base, "GLX_SGI_make_current_read");
__glXEnableDirectExtension(&psc->base, "GLX_INTEL_swap_event");
mask = psc->image_driver->getAPIMask(psc->driScreen);
__glXEnableDirectExtension(&psc->base, "GLX_ARB_create_context");
__glXEnableDirectExtension(&psc->base, "GLX_ARB_create_context_profile");
if ((mask & ((1 << __DRI_API_GLES) |
(1 << __DRI_API_GLES2) |
(1 << __DRI_API_GLES3))) != 0) {
__glXEnableDirectExtension(&psc->base,
"GLX_EXT_create_context_es_profile");
__glXEnableDirectExtension(&psc->base,
"GLX_EXT_create_context_es2_profile");
}
for (i = 0; extensions[i]; i++) {
/* when on a different gpu than the server, the server pixmaps
* can have a tiling mode we can't read. Thus we can't create
* a texture from them.
*/
if (!psc->is_different_gpu &&
(strcmp(extensions[i]->name, __DRI_TEX_BUFFER) == 0)) {
psc->texBuffer = (__DRItexBufferExtension *) extensions[i];
__glXEnableDirectExtension(&psc->base, "GLX_EXT_texture_from_pixmap");
}
if ((strcmp(extensions[i]->name, __DRI2_FLUSH) == 0)) {
psc->f = (__DRI2flushExtension *) extensions[i];
/* internal driver extension, no GL extension exposed */
}
if (strcmp(extensions[i]->name, __DRI_IMAGE) == 0)
psc->image = (__DRIimageExtension *) extensions[i];
if ((strcmp(extensions[i]->name, __DRI2_CONFIG_QUERY) == 0))
psc->config = (__DRI2configQueryExtension *) extensions[i];
if (strcmp(extensions[i]->name, __DRI2_ROBUSTNESS) == 0)
__glXEnableDirectExtension(&psc->base,
"GLX_ARB_create_context_robustness");
if (strcmp(extensions[i]->name, __DRI2_RENDERER_QUERY) == 0) {
psc->rendererQuery = (__DRI2rendererQueryExtension *) extensions[i];
__glXEnableDirectExtension(&psc->base, "GLX_MESA_query_renderer");
}
if (strcmp(extensions[i]->name, __DRI2_INTEROP) == 0)
psc->interop = (__DRI2interopExtension*)extensions[i];
}
}
static const struct glx_screen_vtable dri3_screen_vtable = {
.create_context = dri3_create_context,
.create_context_attribs = dri3_create_context_attribs,
.query_renderer_integer = dri3_query_renderer_integer,
.query_renderer_string = dri3_query_renderer_string,
};
/** dri3_create_screen
*
* Initialize DRI3 on the specified screen.
*
* Opens the DRI device, locates the appropriate DRI driver
* and loads that.
*
* Checks to see if the driver supports the necessary extensions
*
* Initializes the driver for the screen and sets up our structures
*/
static struct glx_screen *
dri3_create_screen(int screen, struct glx_display * priv)
{
xcb_connection_t *c = XGetXCBConnection(priv->dpy);
const __DRIconfig **driver_configs;
const __DRIextension **extensions;
const struct dri3_display *const pdp = (struct dri3_display *)
priv->dri3Display;
struct dri3_screen *psc;
__GLXDRIscreen *psp;
struct glx_config *configs = NULL, *visuals = NULL;
char *driverName, *deviceName, *tmp;
int i;
psc = calloc(1, sizeof *psc);
if (psc == NULL)
return NULL;
psc->fd = -1;
if (!glx_screen_init(&psc->base, screen, priv)) {
free(psc);
return NULL;
}
psc->fd = loader_dri3_open(c, RootWindow(priv->dpy, screen), None);
if (psc->fd < 0) {
int conn_error = xcb_connection_has_error(c);
glx_screen_cleanup(&psc->base);
free(psc);
InfoMessageF("screen %d does not appear to be DRI3 capable\n", screen);
if (conn_error)
ErrorMessageF("Connection closed during DRI3 initialization failure");
return NULL;
}
psc->fd = loader_get_user_preferred_fd(psc->fd, &psc->is_different_gpu);
deviceName = NULL;
driverName = loader_get_driver_for_fd(psc->fd);
if (!driverName) {
ErrorMessageF("No driver found\n");
goto handle_error;
}
psc->driver = driOpenDriver(driverName);
if (psc->driver == NULL) {
ErrorMessageF("driver pointer missing\n");
goto handle_error;
}
extensions = driGetDriverExtensions(psc->driver, driverName);
if (extensions == NULL)
goto handle_error;
for (i = 0; extensions[i]; i++) {
if (strcmp(extensions[i]->name, __DRI_CORE) == 0)
psc->core = (__DRIcoreExtension *) extensions[i];
if (strcmp(extensions[i]->name, __DRI_IMAGE_DRIVER) == 0)
psc->image_driver = (__DRIimageDriverExtension *) extensions[i];
}
if (psc->core == NULL) {
ErrorMessageF("core dri driver extension not found\n");
goto handle_error;
}
if (psc->image_driver == NULL) {
ErrorMessageF("image driver extension not found\n");
goto handle_error;
}
psc->driScreen =
psc->image_driver->createNewScreen2(screen, psc->fd,
pdp->loader_extensions,
extensions,
&driver_configs, psc);
if (psc->driScreen == NULL) {
ErrorMessageF("failed to create dri screen\n");
goto handle_error;
}
dri3_bind_extensions(psc, priv, driverName);
if (!psc->image || psc->image->base.version < 7 || !psc->image->createImageFromFds) {
ErrorMessageF("Version 7 or imageFromFds image extension not found\n");
goto handle_error;
}
if (!psc->f || psc->f->base.version < 4) {
ErrorMessageF("Version 4 or later of flush extension not found\n");
goto handle_error;
}
if (psc->is_different_gpu && psc->image->base.version < 9) {
ErrorMessageF("Different GPU, but image extension version 9 or later not found\n");
goto handle_error;
}
if (psc->is_different_gpu && !psc->image->blitImage) {
ErrorMessageF("Different GPU, but blitImage not implemented for this driver\n");
goto handle_error;
}
if (!psc->is_different_gpu && (
!psc->texBuffer || psc->texBuffer->base.version < 2 ||
!psc->texBuffer->setTexBuffer2
)) {
ErrorMessageF("Version 2 or later of texBuffer extension not found\n");
goto handle_error;
}
psc->loader_dri3_ext.core = psc->core;
psc->loader_dri3_ext.image_driver = psc->image_driver;
psc->loader_dri3_ext.flush = psc->f;
psc->loader_dri3_ext.tex_buffer = psc->texBuffer;
psc->loader_dri3_ext.image = psc->image;
psc->loader_dri3_ext.config = psc->config;
configs = driConvertConfigs(psc->core, psc->base.configs, driver_configs);
visuals = driConvertConfigs(psc->core, psc->base.visuals, driver_configs);
if (!configs || !visuals) {
ErrorMessageF("No matching fbConfigs or visuals found\n");
goto handle_error;
}
glx_config_destroy_list(psc->base.configs);
psc->base.configs = configs;
glx_config_destroy_list(psc->base.visuals);
psc->base.visuals = visuals;
psc->driver_configs = driver_configs;
psc->base.vtable = &dri3_screen_vtable;
psp = &psc->vtable;
psc->base.driScreen = psp;
psp->destroyScreen = dri3_destroy_screen;
psp->createDrawable = dri3_create_drawable;
psp->swapBuffers = dri3_swap_buffers;
psp->getDrawableMSC = dri3_drawable_get_msc;
psp->waitForMSC = dri3_wait_for_msc;
psp->waitForSBC = dri3_wait_for_sbc;
psp->setSwapInterval = dri3_set_swap_interval;
psp->getSwapInterval = dri3_get_swap_interval;
__glXEnableDirectExtension(&psc->base, "GLX_OML_sync_control");
psp->copySubBuffer = dri3_copy_sub_buffer;
__glXEnableDirectExtension(&psc->base, "GLX_MESA_copy_sub_buffer");
psp->getBufferAge = dri3_get_buffer_age;
__glXEnableDirectExtension(&psc->base, "GLX_EXT_buffer_age");
free(driverName);
free(deviceName);
tmp = getenv("LIBGL_SHOW_FPS");
psc->show_fps_interval = tmp ? atoi(tmp) : 0;
if (psc->show_fps_interval < 0)
psc->show_fps_interval = 0;
InfoMessageF("Using DRI3 for screen %d\n", screen);
return &psc->base;
handle_error:
CriticalErrorMessageF("failed to load driver: %s\n", driverName);
if (configs)
glx_config_destroy_list(configs);
if (visuals)
glx_config_destroy_list(visuals);
if (psc->driScreen)
psc->core->destroyScreen(psc->driScreen);
psc->driScreen = NULL;
if (psc->fd >= 0)
close(psc->fd);
if (psc->driver)
dlclose(psc->driver);
free(driverName);
free(deviceName);
glx_screen_cleanup(&psc->base);
free(psc);
return NULL;
}
/** dri_destroy_display
*
* Called from __glXFreeDisplayPrivate.
*/
static void
dri3_destroy_display(__GLXDRIdisplay * dpy)
{
free(dpy);
}
/** dri3_create_display
*
* Allocate, initialize and return a __DRIdisplayPrivate object.
* This is called from __glXInitialize() when we are given a new
* display pointer. This is public to that function, but hidden from
* outside of libGL.
*/
_X_HIDDEN __GLXDRIdisplay *
dri3_create_display(Display * dpy)
{
struct dri3_display *pdp;
xcb_connection_t *c = XGetXCBConnection(dpy);
xcb_dri3_query_version_cookie_t dri3_cookie;
xcb_dri3_query_version_reply_t *dri3_reply;
xcb_present_query_version_cookie_t present_cookie;
xcb_present_query_version_reply_t *present_reply;
xcb_generic_error_t *error;
const xcb_query_extension_reply_t *extension;
xcb_prefetch_extension_data(c, &xcb_dri3_id);
xcb_prefetch_extension_data(c, &xcb_present_id);
extension = xcb_get_extension_data(c, &xcb_dri3_id);
if (!(extension && extension->present))
return NULL;
extension = xcb_get_extension_data(c, &xcb_present_id);
if (!(extension && extension->present))
return NULL;
dri3_cookie = xcb_dri3_query_version(c,
XCB_DRI3_MAJOR_VERSION,
XCB_DRI3_MINOR_VERSION);
present_cookie = xcb_present_query_version(c,
XCB_PRESENT_MAJOR_VERSION,
XCB_PRESENT_MINOR_VERSION);
pdp = malloc(sizeof *pdp);
if (pdp == NULL)
return NULL;
dri3_reply = xcb_dri3_query_version_reply(c, dri3_cookie, &error);
if (!dri3_reply) {
free(error);
goto no_extension;
}
pdp->dri3Major = dri3_reply->major_version;
pdp->dri3Minor = dri3_reply->minor_version;
free(dri3_reply);
present_reply = xcb_present_query_version_reply(c, present_cookie, &error);
if (!present_reply) {
free(error);
goto no_extension;
}
pdp->presentMajor = present_reply->major_version;
pdp->presentMinor = present_reply->minor_version;
free(present_reply);
pdp->base.destroyDisplay = dri3_destroy_display;
pdp->base.createScreen = dri3_create_screen;
loader_set_logger(dri_message);
pdp->loader_extensions = loader_extensions;
return &pdp->base;
no_extension:
free(pdp);
return NULL;
}
#endif /* GLX_DIRECT_RENDERING */