DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
/*
|
|
|
|
|
* 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)
|
|
|
|
|
*/
|
|
|
|
|
|
2010-04-02 09:35:19 +01:00
|
|
|
#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
|
2008-04-23 15:59:23 +01:00
|
|
|
#include <X11/Xlib.h>
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
#include <X11/extensions/Xfixes.h>
|
2012-09-25 19:39:17 +01:00
|
|
|
#include <X11/Xlib-xcb.h>
|
|
|
|
|
#include <xcb/xcb.h>
|
|
|
|
|
#include <xcb/dri2.h>
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
#include "glxclient.h"
|
2010-02-08 22:15:03 +00:00
|
|
|
#include <X11/extensions/dri2proto.h>
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
#include <dlfcn.h>
|
2008-10-12 01:41:14 +01:00
|
|
|
#include <fcntl.h>
|
|
|
|
|
#include <unistd.h>
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
#include <sys/types.h>
|
|
|
|
|
#include <sys/mman.h>
|
2012-01-04 01:09:44 +00:00
|
|
|
#include <sys/time.h>
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
#include "dri2.h"
|
2008-06-09 15:47:09 +01:00
|
|
|
#include "dri_common.h"
|
2013-02-23 00:43:02 +00:00
|
|
|
#include "dri2_priv.h"
|
2014-01-23 18:21:09 +00:00
|
|
|
#include "loader.h"
|
2022-07-11 20:01:27 +01:00
|
|
|
#include "loader_dri_helper.h"
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
|
2009-04-21 04:55:56 +01:00
|
|
|
#undef DRI2_MINOR
|
|
|
|
|
#define DRI2_MINOR 1
|
|
|
|
|
|
2010-07-19 15:51:09 +01:00
|
|
|
struct dri2_display
|
2009-08-12 11:41:22 +01:00
|
|
|
{
|
|
|
|
|
__GLXDRIdisplay base;
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
|
2010-07-19 14:37:07 +01:00
|
|
|
__glxHashTable *dri2Hash;
|
|
|
|
|
|
2012-11-14 23:50:27 +00:00
|
|
|
const __DRIextension *loader_extensions[5];
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
};
|
|
|
|
|
|
2010-07-19 15:51:09 +01:00
|
|
|
struct dri2_drawable
|
2009-08-12 11:41:22 +01:00
|
|
|
{
|
|
|
|
|
__GLXDRIdrawable base;
|
2010-07-19 23:11:03 +01:00
|
|
|
__DRIdrawable *driDrawable;
|
2009-08-12 11:41:22 +01:00
|
|
|
__DRIbuffer buffers[5];
|
|
|
|
|
int bufferCount;
|
|
|
|
|
int width, height;
|
|
|
|
|
int have_back;
|
|
|
|
|
int have_fake_front;
|
2009-11-10 21:28:01 +00:00
|
|
|
int swap_interval;
|
2012-01-04 01:09:44 +00:00
|
|
|
|
2012-09-30 20:41:33 +01:00
|
|
|
uint64_t previous_time;
|
2012-01-04 01:09:44 +00:00
|
|
|
unsigned frames;
|
2008-08-13 16:46:25 +01:00
|
|
|
};
|
|
|
|
|
|
2010-07-23 02:24:14 +01:00
|
|
|
static const struct glx_context_vtable dri2_context_vtable;
|
|
|
|
|
|
2012-09-25 19:39:17 +01:00
|
|
|
/* For XCB's handling of ust/msc/sbc counters, we have to hand it the high and
|
|
|
|
|
* low halves separately. This helps you split them.
|
|
|
|
|
*/
|
|
|
|
|
static void
|
|
|
|
|
split_counter(uint64_t counter, uint32_t *hi, uint32_t *lo)
|
|
|
|
|
{
|
|
|
|
|
*hi = (counter >> 32);
|
|
|
|
|
*lo = counter & 0xffffffff;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static uint64_t
|
|
|
|
|
merge_counter(uint32_t hi, uint32_t lo)
|
|
|
|
|
{
|
|
|
|
|
return ((uint64_t)hi << 32) | lo;
|
|
|
|
|
}
|
|
|
|
|
|
2009-08-12 11:41:22 +01:00
|
|
|
static void
|
2010-07-28 16:16:00 +01:00
|
|
|
dri2_destroy_context(struct glx_context *context)
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
{
|
2010-07-19 15:51:09 +01:00
|
|
|
struct dri2_context *pcp = (struct dri2_context *) context;
|
2010-07-23 02:24:14 +01:00
|
|
|
struct dri2_screen *psc = (struct dri2_screen *) context->psc;
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
|
2010-09-21 14:56:05 +01:00
|
|
|
driReleaseDrawables(&pcp->base);
|
|
|
|
|
|
2012-09-04 04:24:35 +01:00
|
|
|
free((char *) context->extensions);
|
2010-07-23 04:45:18 +01:00
|
|
|
|
2010-07-19 19:57:59 +01:00
|
|
|
(*psc->core->destroyContext) (pcp->driContext);
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
|
2012-09-05 06:52:36 +01:00
|
|
|
free(pcp);
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
}
|
|
|
|
|
|
2009-08-12 11:41:22 +01:00
|
|
|
static Bool
|
2010-07-28 20:33:09 +01:00
|
|
|
dri2_bind_context(struct glx_context *context, struct glx_context *old,
|
|
|
|
|
GLXDrawable draw, GLXDrawable read)
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
{
|
2010-07-19 15:51:09 +01:00
|
|
|
struct dri2_context *pcp = (struct dri2_context *) context;
|
2010-07-23 02:24:14 +01:00
|
|
|
struct dri2_screen *psc = (struct dri2_screen *) pcp->base.psc;
|
2010-07-28 20:33:09 +01:00
|
|
|
struct dri2_drawable *pdraw, *pread;
|
2014-02-05 19:43:58 +00:00
|
|
|
__DRIdrawable *dri_draw = NULL, *dri_read = NULL;
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
|
2010-07-28 20:33:09 +01:00
|
|
|
pdraw = (struct dri2_drawable *) driFetchDrawable(context, draw);
|
|
|
|
|
pread = (struct dri2_drawable *) driFetchDrawable(context, read);
|
|
|
|
|
|
2022-06-21 21:07:19 +01:00
|
|
|
driReleaseDrawables(old);
|
2011-06-15 23:09:12 +01:00
|
|
|
|
2014-02-05 19:43:58 +00:00
|
|
|
if (pdraw)
|
|
|
|
|
dri_draw = pdraw->driDrawable;
|
|
|
|
|
else if (draw != None)
|
2010-07-28 20:33:09 +01:00
|
|
|
return GLXBadDrawable;
|
|
|
|
|
|
2014-02-05 19:43:58 +00:00
|
|
|
if (pread)
|
|
|
|
|
dri_read = pread->driDrawable;
|
|
|
|
|
else if (read != None)
|
|
|
|
|
return GLXBadDrawable;
|
|
|
|
|
|
|
|
|
|
if (!(*psc->core->bindContext) (pcp->driContext, dri_draw, dri_read))
|
2010-09-22 22:34:00 +01:00
|
|
|
return GLXBadContext;
|
|
|
|
|
|
|
|
|
|
return Success;
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
}
|
|
|
|
|
|
2009-08-12 11:41:22 +01:00
|
|
|
static void
|
2010-07-28 20:33:09 +01:00
|
|
|
dri2_unbind_context(struct glx_context *context, struct glx_context *new)
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
{
|
2010-07-19 15:51:09 +01:00
|
|
|
struct dri2_context *pcp = (struct dri2_context *) context;
|
2010-07-23 02:24:14 +01:00
|
|
|
struct dri2_screen *psc = (struct dri2_screen *) pcp->base.psc;
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
|
2010-07-19 19:57:59 +01:00
|
|
|
(*psc->core->unbindContext) (pcp->driContext);
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
}
|
|
|
|
|
|
2011-11-30 21:15:08 +00:00
|
|
|
static struct glx_context *
|
|
|
|
|
dri2_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 dri2_context *pcp = NULL;
|
|
|
|
|
struct dri2_context *pcp_shared = NULL;
|
|
|
|
|
struct dri2_screen *psc = (struct dri2_screen *) base;
|
|
|
|
|
__GLXDRIconfigPrivate *config = (__GLXDRIconfigPrivate *) config_base;
|
|
|
|
|
__DRIcontext *shared = NULL;
|
|
|
|
|
|
2021-08-06 21:32:56 +01:00
|
|
|
struct dri_ctx_attribs dca;
|
2014-10-01 20:00:48 +01:00
|
|
|
uint32_t ctx_attribs[2 * 6];
|
2011-11-30 21:15:08 +00:00
|
|
|
unsigned num_ctx_attribs = 0;
|
|
|
|
|
|
2021-08-06 21:32:56 +01:00
|
|
|
*error = dri_convert_glx_attribs(num_attribs, attribs, &dca);
|
|
|
|
|
if (*error != __DRI_CTX_ERROR_SUCCESS)
|
2011-11-30 21:15:08 +00:00
|
|
|
goto error_exit;
|
|
|
|
|
|
2013-07-18 22:19:38 +01:00
|
|
|
/* Check the renderType value */
|
2021-08-06 21:32:56 +01:00
|
|
|
if (!validate_renderType_against_config(config_base, dca.render_type))
|
2013-07-18 22:19:38 +01:00
|
|
|
goto error_exit;
|
|
|
|
|
|
2011-11-30 21:15:08 +00:00
|
|
|
if (shareList) {
|
2021-08-06 22:10:45 +01:00
|
|
|
/* We can't share with an indirect context */
|
|
|
|
|
if (!shareList->isDirect)
|
|
|
|
|
return NULL;
|
2020-11-17 18:48:46 +00:00
|
|
|
|
2021-10-04 22:53:52 +01:00
|
|
|
/* The GLX_ARB_create_context_no_error specs say:
|
|
|
|
|
*
|
|
|
|
|
* BadMatch is generated if the value of GLX_CONTEXT_OPENGL_NO_ERROR_ARB
|
|
|
|
|
* used to create <share_context> does not match the value of
|
|
|
|
|
* GLX_CONTEXT_OPENGL_NO_ERROR_ARB for the context being created.
|
|
|
|
|
*/
|
|
|
|
|
if (!!shareList->noError != !!dca.no_error) {
|
|
|
|
|
*error = __DRI_CTX_ERROR_BAD_FLAG;
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2011-11-30 21:15:08 +00:00
|
|
|
pcp_shared = (struct dri2_context *) shareList;
|
|
|
|
|
shared = pcp_shared->driContext;
|
|
|
|
|
}
|
|
|
|
|
|
2012-09-05 07:09:22 +01:00
|
|
|
pcp = calloc(1, sizeof *pcp);
|
2011-11-30 21:15:08 +00:00
|
|
|
if (pcp == NULL) {
|
|
|
|
|
*error = __DRI_CTX_ERROR_NO_MEMORY;
|
|
|
|
|
goto error_exit;
|
|
|
|
|
}
|
|
|
|
|
|
2017-11-07 16:36:52 +00:00
|
|
|
if (!glx_context_init(&pcp->base, &psc->base, config_base))
|
2011-11-30 21:15:08 +00:00
|
|
|
goto error_exit;
|
|
|
|
|
|
|
|
|
|
ctx_attribs[num_ctx_attribs++] = __DRI_CTX_ATTRIB_MAJOR_VERSION;
|
2021-08-06 21:32:56 +01:00
|
|
|
ctx_attribs[num_ctx_attribs++] = dca.major_ver;
|
2011-11-30 21:15:08 +00:00
|
|
|
ctx_attribs[num_ctx_attribs++] = __DRI_CTX_ATTRIB_MINOR_VERSION;
|
2021-08-06 21:32:56 +01:00
|
|
|
ctx_attribs[num_ctx_attribs++] = dca.minor_ver;
|
2011-11-30 21:15:08 +00:00
|
|
|
|
2012-07-03 19:32:59 +01:00
|
|
|
/* Only send a value when the non-default value is requested. By doing
|
|
|
|
|
* this we don't have to check the driver's DRI2 version before sending the
|
|
|
|
|
* default value.
|
|
|
|
|
*/
|
2021-08-06 21:32:56 +01:00
|
|
|
if (dca.reset != __DRI_CTX_RESET_NO_NOTIFICATION) {
|
2012-07-03 19:32:59 +01:00
|
|
|
ctx_attribs[num_ctx_attribs++] = __DRI_CTX_ATTRIB_RESET_STRATEGY;
|
2021-08-06 21:32:56 +01:00
|
|
|
ctx_attribs[num_ctx_attribs++] = dca.reset;
|
2012-07-03 19:32:59 +01:00
|
|
|
}
|
|
|
|
|
|
2021-08-06 21:32:56 +01:00
|
|
|
if (dca.release != __DRI_CTX_RELEASE_BEHAVIOR_FLUSH) {
|
2014-10-01 20:00:48 +01:00
|
|
|
ctx_attribs[num_ctx_attribs++] = __DRI_CTX_ATTRIB_RELEASE_BEHAVIOR;
|
2021-08-06 21:32:56 +01:00
|
|
|
ctx_attribs[num_ctx_attribs++] = dca.release;
|
2014-10-01 20:00:48 +01:00
|
|
|
}
|
|
|
|
|
|
2021-10-04 22:53:52 +01:00
|
|
|
if (dca.no_error) {
|
|
|
|
|
ctx_attribs[num_ctx_attribs++] = __DRI_CTX_ATTRIB_NO_ERROR;
|
|
|
|
|
ctx_attribs[num_ctx_attribs++] = dca.no_error;
|
|
|
|
|
pcp->base.noError = GL_TRUE;
|
|
|
|
|
}
|
|
|
|
|
|
2021-08-06 21:32:56 +01:00
|
|
|
if (dca.flags != 0) {
|
2011-11-30 21:15:08 +00:00
|
|
|
ctx_attribs[num_ctx_attribs++] = __DRI_CTX_ATTRIB_FLAGS;
|
2021-08-06 21:32:56 +01:00
|
|
|
ctx_attribs[num_ctx_attribs++] = dca.flags;
|
2011-11-30 21:15:08 +00:00
|
|
|
}
|
|
|
|
|
|
2013-07-17 12:49:14 +01:00
|
|
|
/* The renderType is retrieved from attribs, or set to default
|
|
|
|
|
* of GLX_RGBA_TYPE.
|
|
|
|
|
*/
|
2021-08-06 21:32:56 +01:00
|
|
|
pcp->base.renderType = dca.render_type;
|
2013-07-17 12:49:14 +01:00
|
|
|
|
2011-11-30 21:15:08 +00:00
|
|
|
pcp->driContext =
|
|
|
|
|
(*psc->dri2->createContextAttribs) (psc->driScreen,
|
2021-08-06 21:32:56 +01:00
|
|
|
dca.api,
|
2017-11-07 16:36:52 +00:00
|
|
|
config ? config->driConfig : NULL,
|
2011-11-30 21:15:08 +00:00
|
|
|
shared,
|
|
|
|
|
num_ctx_attribs / 2,
|
|
|
|
|
ctx_attribs,
|
|
|
|
|
error,
|
|
|
|
|
pcp);
|
|
|
|
|
|
|
|
|
|
if (pcp->driContext == NULL)
|
|
|
|
|
goto error_exit;
|
|
|
|
|
|
2021-08-06 22:53:38 +01:00
|
|
|
pcp->base.vtable = base->context_vtable;
|
2011-11-30 21:15:08 +00:00
|
|
|
|
|
|
|
|
return &pcp->base;
|
|
|
|
|
|
|
|
|
|
error_exit:
|
2012-09-04 04:24:35 +01:00
|
|
|
free(pcp);
|
2011-11-30 21:15:08 +00:00
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2009-08-12 11:41:22 +01:00
|
|
|
static void
|
2010-07-19 23:11:03 +01:00
|
|
|
dri2DestroyDrawable(__GLXDRIdrawable *base)
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
{
|
2010-07-19 23:11:03 +01:00
|
|
|
struct dri2_screen *psc = (struct dri2_screen *) base->psc;
|
|
|
|
|
struct dri2_drawable *pdraw = (struct dri2_drawable *) base;
|
2010-07-28 16:16:00 +01:00
|
|
|
struct glx_display *dpyPriv = psc->base.display;
|
2010-07-20 02:00:09 +01:00
|
|
|
struct dri2_display *pdp = (struct dri2_display *)dpyPriv->dri2Display;
|
2010-07-19 14:37:07 +01:00
|
|
|
|
2010-07-19 23:11:03 +01:00
|
|
|
__glxHashDelete(pdp->dri2Hash, pdraw->base.xDrawable);
|
2010-07-19 19:57:59 +01:00
|
|
|
(*psc->core->destroyDrawable) (pdraw->driDrawable);
|
2010-09-13 13:39:42 +01:00
|
|
|
|
|
|
|
|
/* If it's a GLX 1.3 drawables, we can destroy the DRI2 drawable
|
|
|
|
|
* now, as the application explicitly asked to destroy the GLX
|
|
|
|
|
* drawable. Otherwise, for legacy drawables, we let the DRI2
|
|
|
|
|
* drawable linger on the server, since there's no good way of
|
|
|
|
|
* knowing when the application is done with it. The server will
|
|
|
|
|
* destroy the DRI2 drawable when it destroys the X drawable or the
|
|
|
|
|
* client exits anyway. */
|
|
|
|
|
if (pdraw->base.xDrawable != pdraw->base.drawable)
|
|
|
|
|
DRI2DestroyDrawable(psc->base.dpy, pdraw->base.xDrawable);
|
|
|
|
|
|
2012-09-05 06:52:36 +01:00
|
|
|
free(pdraw);
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
}
|
|
|
|
|
|
2009-08-12 11:41:22 +01:00
|
|
|
static __GLXDRIdrawable *
|
2010-07-28 15:28:43 +01:00
|
|
|
dri2CreateDrawable(struct glx_screen *base, XID xDrawable,
|
2021-11-09 09:19:44 +00:00
|
|
|
GLXDrawable drawable, int type,
|
|
|
|
|
struct glx_config *config_base)
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
{
|
2010-07-19 15:51:09 +01:00
|
|
|
struct dri2_drawable *pdraw;
|
2010-07-19 19:57:59 +01:00
|
|
|
struct dri2_screen *psc = (struct dri2_screen *) base;
|
2010-07-28 15:07:52 +01:00
|
|
|
__GLXDRIconfigPrivate *config = (__GLXDRIconfigPrivate *) config_base;
|
2010-07-28 16:16:00 +01:00
|
|
|
struct glx_display *dpyPriv;
|
2010-07-19 15:51:09 +01:00
|
|
|
struct dri2_display *pdp;
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
|
2013-12-16 14:04:00 +00:00
|
|
|
dpyPriv = __glXInitialize(psc->base.dpy);
|
|
|
|
|
if (dpyPriv == NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
2012-09-05 07:09:22 +01:00
|
|
|
pdraw = calloc(1, sizeof(*pdraw));
|
2009-08-12 11:41:22 +01:00
|
|
|
if (!pdraw)
|
|
|
|
|
return NULL;
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
|
2009-08-12 11:41:22 +01:00
|
|
|
pdraw->base.destroyDrawable = dri2DestroyDrawable;
|
|
|
|
|
pdraw->base.xDrawable = xDrawable;
|
|
|
|
|
pdraw->base.drawable = drawable;
|
2010-07-19 19:57:59 +01:00
|
|
|
pdraw->base.psc = &psc->base;
|
2009-08-12 11:41:22 +01:00
|
|
|
pdraw->bufferCount = 0;
|
2022-07-11 20:01:27 +01:00
|
|
|
pdraw->swap_interval = dri_get_initial_swap_interval(psc->driScreen, psc->config);
|
2010-04-27 22:16:46 +01:00
|
|
|
pdraw->have_back = 0;
|
2010-04-22 20:49:03 +01:00
|
|
|
|
2010-07-19 19:57:59 +01:00
|
|
|
DRI2CreateDrawable(psc->base.dpy, xDrawable);
|
2016-04-14 17:07:41 +01:00
|
|
|
pdp = (struct dri2_display *)dpyPriv->dri2Display;
|
2009-08-12 11:41:22 +01:00
|
|
|
/* Create a new drawable */
|
2010-07-19 23:11:03 +01:00
|
|
|
pdraw->driDrawable =
|
2010-07-19 21:45:23 +01:00
|
|
|
(*psc->dri2->createNewDrawable) (psc->driScreen,
|
2009-08-12 11:41:22 +01:00
|
|
|
config->driConfig, pdraw);
|
2008-08-13 16:46:25 +01:00
|
|
|
|
2010-07-19 23:11:03 +01:00
|
|
|
if (!pdraw->driDrawable) {
|
2010-07-19 19:57:59 +01:00
|
|
|
DRI2DestroyDrawable(psc->base.dpy, xDrawable);
|
2012-09-05 06:52:36 +01:00
|
|
|
free(pdraw);
|
2009-08-12 11:41:22 +01:00
|
|
|
return NULL;
|
|
|
|
|
}
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
|
2010-07-19 14:37:07 +01:00
|
|
|
if (__glxHashInsert(pdp->dri2Hash, xDrawable, pdraw)) {
|
2010-07-19 23:11:03 +01:00
|
|
|
(*psc->core->destroyDrawable) (pdraw->driDrawable);
|
2010-07-19 19:57:59 +01:00
|
|
|
DRI2DestroyDrawable(psc->base.dpy, xDrawable);
|
2012-09-05 06:52:36 +01:00
|
|
|
free(pdraw);
|
2010-07-19 14:37:07 +01:00
|
|
|
return None;
|
|
|
|
|
}
|
|
|
|
|
|
2010-04-19 17:54:08 +01:00
|
|
|
/*
|
|
|
|
|
* Make sure server has the same swap interval we do for the new
|
|
|
|
|
* drawable.
|
|
|
|
|
*/
|
2012-09-25 20:14:44 +01:00
|
|
|
if (psc->vtable.setSwapInterval)
|
|
|
|
|
psc->vtable.setSwapInterval(&pdraw->base, pdraw->swap_interval);
|
2010-04-19 22:19:48 +01:00
|
|
|
|
2009-08-12 11:41:22 +01:00
|
|
|
return &pdraw->base;
|
2008-08-13 16:46:25 +01:00
|
|
|
}
|
|
|
|
|
|
2009-09-16 07:23:09 +01:00
|
|
|
static int
|
2010-07-28 15:28:43 +01:00
|
|
|
dri2DrawableGetMSC(struct glx_screen *psc, __GLXDRIdrawable *pdraw,
|
2009-09-16 07:23:09 +01:00
|
|
|
int64_t *ust, int64_t *msc, int64_t *sbc)
|
|
|
|
|
{
|
2012-09-25 20:05:28 +01:00
|
|
|
xcb_connection_t *c = XGetXCBConnection(pdraw->psc->dpy);
|
|
|
|
|
xcb_dri2_get_msc_cookie_t get_msc_cookie;
|
|
|
|
|
xcb_dri2_get_msc_reply_t *get_msc_reply;
|
2010-07-20 01:01:59 +01:00
|
|
|
|
2012-09-25 20:05:28 +01:00
|
|
|
get_msc_cookie = xcb_dri2_get_msc_unchecked(c, pdraw->xDrawable);
|
|
|
|
|
get_msc_reply = xcb_dri2_get_msc_reply(c, get_msc_cookie, NULL);
|
2012-10-15 20:02:05 +01:00
|
|
|
|
|
|
|
|
if (!get_msc_reply)
|
|
|
|
|
return 0;
|
|
|
|
|
|
2012-09-25 20:05:28 +01:00
|
|
|
*ust = merge_counter(get_msc_reply->ust_hi, get_msc_reply->ust_lo);
|
|
|
|
|
*msc = merge_counter(get_msc_reply->msc_hi, get_msc_reply->msc_lo);
|
|
|
|
|
*sbc = merge_counter(get_msc_reply->sbc_hi, get_msc_reply->sbc_lo);
|
|
|
|
|
free(get_msc_reply);
|
2010-07-20 01:01:59 +01:00
|
|
|
|
2012-10-15 20:02:05 +01:00
|
|
|
return 1;
|
2009-09-16 07:23:09 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
dri2WaitForMSC(__GLXDRIdrawable *pdraw, int64_t target_msc, int64_t divisor,
|
|
|
|
|
int64_t remainder, int64_t *ust, int64_t *msc, int64_t *sbc)
|
|
|
|
|
{
|
2012-09-25 20:01:27 +01:00
|
|
|
xcb_connection_t *c = XGetXCBConnection(pdraw->psc->dpy);
|
|
|
|
|
xcb_dri2_wait_msc_cookie_t wait_msc_cookie;
|
|
|
|
|
xcb_dri2_wait_msc_reply_t *wait_msc_reply;
|
|
|
|
|
uint32_t target_msc_hi, target_msc_lo;
|
|
|
|
|
uint32_t divisor_hi, divisor_lo;
|
|
|
|
|
uint32_t remainder_hi, remainder_lo;
|
|
|
|
|
|
|
|
|
|
split_counter(target_msc, &target_msc_hi, &target_msc_lo);
|
|
|
|
|
split_counter(divisor, &divisor_hi, &divisor_lo);
|
|
|
|
|
split_counter(remainder, &remainder_hi, &remainder_lo);
|
|
|
|
|
|
|
|
|
|
wait_msc_cookie = xcb_dri2_wait_msc_unchecked(c, pdraw->xDrawable,
|
|
|
|
|
target_msc_hi, target_msc_lo,
|
|
|
|
|
divisor_hi, divisor_lo,
|
|
|
|
|
remainder_hi, remainder_lo);
|
|
|
|
|
wait_msc_reply = xcb_dri2_wait_msc_reply(c, wait_msc_cookie, NULL);
|
2012-10-15 20:02:05 +01:00
|
|
|
|
|
|
|
|
if (!wait_msc_reply)
|
|
|
|
|
return 0;
|
|
|
|
|
|
2012-09-25 20:01:27 +01:00
|
|
|
*ust = merge_counter(wait_msc_reply->ust_hi, wait_msc_reply->ust_lo);
|
|
|
|
|
*msc = merge_counter(wait_msc_reply->msc_hi, wait_msc_reply->msc_lo);
|
|
|
|
|
*sbc = merge_counter(wait_msc_reply->sbc_hi, wait_msc_reply->sbc_lo);
|
|
|
|
|
free(wait_msc_reply);
|
2010-07-20 01:01:59 +01:00
|
|
|
|
2012-10-15 20:02:05 +01:00
|
|
|
return 1;
|
2009-09-16 07:23:09 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
dri2WaitForSBC(__GLXDRIdrawable *pdraw, int64_t target_sbc, int64_t *ust,
|
|
|
|
|
int64_t *msc, int64_t *sbc)
|
|
|
|
|
{
|
2012-09-25 19:39:17 +01:00
|
|
|
xcb_connection_t *c = XGetXCBConnection(pdraw->psc->dpy);
|
|
|
|
|
xcb_dri2_wait_sbc_cookie_t wait_sbc_cookie;
|
|
|
|
|
xcb_dri2_wait_sbc_reply_t *wait_sbc_reply;
|
|
|
|
|
uint32_t target_sbc_hi, target_sbc_lo;
|
2010-07-20 01:01:59 +01:00
|
|
|
|
2012-09-25 19:39:17 +01:00
|
|
|
split_counter(target_sbc, &target_sbc_hi, &target_sbc_lo);
|
2010-07-20 01:01:59 +01:00
|
|
|
|
2012-09-25 19:39:17 +01:00
|
|
|
wait_sbc_cookie = xcb_dri2_wait_sbc_unchecked(c, pdraw->xDrawable,
|
|
|
|
|
target_sbc_hi, target_sbc_lo);
|
|
|
|
|
wait_sbc_reply = xcb_dri2_wait_sbc_reply(c, wait_sbc_cookie, NULL);
|
2012-10-15 20:02:05 +01:00
|
|
|
|
|
|
|
|
if (!wait_sbc_reply)
|
|
|
|
|
return 0;
|
|
|
|
|
|
2012-09-25 19:39:17 +01:00
|
|
|
*ust = merge_counter(wait_sbc_reply->ust_hi, wait_sbc_reply->ust_lo);
|
|
|
|
|
*msc = merge_counter(wait_sbc_reply->msc_hi, wait_sbc_reply->msc_lo);
|
|
|
|
|
*sbc = merge_counter(wait_sbc_reply->sbc_hi, wait_sbc_reply->sbc_lo);
|
|
|
|
|
free(wait_sbc_reply);
|
|
|
|
|
|
2012-10-15 20:02:05 +01:00
|
|
|
return 1;
|
2009-09-16 07:23:09 +01:00
|
|
|
}
|
|
|
|
|
|
2012-11-23 17:31:42 +00:00
|
|
|
static __DRIcontext *
|
|
|
|
|
dri2GetCurrentContext()
|
|
|
|
|
{
|
|
|
|
|
struct glx_context *gc = __glXGetCurrentContext();
|
|
|
|
|
struct dri2_context *dri2Ctx = (struct dri2_context *)gc;
|
|
|
|
|
|
2016-04-21 14:02:53 +01:00
|
|
|
return (gc != &dummyContext) ? dri2Ctx->driContext : NULL;
|
2012-11-23 17:31:42 +00:00
|
|
|
}
|
|
|
|
|
|
2011-10-10 15:38:19 +01:00
|
|
|
/**
|
|
|
|
|
* dri2Throttle - Request driver throttling
|
|
|
|
|
*
|
|
|
|
|
* This function uses the DRI2 throttle extension to give the
|
|
|
|
|
* driver the opportunity to throttle on flush front, copysubbuffer
|
|
|
|
|
* and swapbuffers.
|
|
|
|
|
*/
|
|
|
|
|
static void
|
|
|
|
|
dri2Throttle(struct dri2_screen *psc,
|
|
|
|
|
struct dri2_drawable *draw,
|
|
|
|
|
enum __DRI2throttleReason reason)
|
|
|
|
|
{
|
|
|
|
|
if (psc->throttle) {
|
2012-11-23 17:31:42 +00:00
|
|
|
__DRIcontext *ctx = dri2GetCurrentContext();
|
2011-10-10 15:38:19 +01:00
|
|
|
|
|
|
|
|
psc->throttle->throttle(ctx, draw->driDrawable, reason);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2012-12-28 19:28:38 +00:00
|
|
|
/**
|
|
|
|
|
* Asks the driver to flush any queued work necessary for serializing with the
|
|
|
|
|
* X command stream, and optionally the slightly more strict requirement of
|
|
|
|
|
* glFlush() equivalence (which would require flushing even if nothing had
|
|
|
|
|
* been drawn to a window system framebuffer, for example).
|
|
|
|
|
*/
|
|
|
|
|
static void
|
|
|
|
|
dri2Flush(struct dri2_screen *psc,
|
|
|
|
|
__DRIcontext *ctx,
|
|
|
|
|
struct dri2_drawable *draw,
|
|
|
|
|
unsigned flags,
|
|
|
|
|
enum __DRI2throttleReason throttle_reason)
|
|
|
|
|
{
|
|
|
|
|
if (ctx && psc->f && psc->f->base.version >= 4) {
|
|
|
|
|
psc->f->flush_with_flags(ctx, draw->driDrawable, flags, throttle_reason);
|
|
|
|
|
} else {
|
|
|
|
|
if (flags & __DRI2_FLUSH_CONTEXT)
|
|
|
|
|
glFlush();
|
|
|
|
|
|
|
|
|
|
if (psc->f)
|
|
|
|
|
psc->f->flush(draw->driDrawable);
|
|
|
|
|
|
|
|
|
|
dri2Throttle(psc, draw, throttle_reason);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2009-08-12 11:41:22 +01:00
|
|
|
static void
|
2011-10-10 15:38:19 +01:00
|
|
|
__dri2CopySubBuffer(__GLXDRIdrawable *pdraw, int x, int y,
|
|
|
|
|
int width, int height,
|
2012-11-13 16:06:37 +00:00
|
|
|
enum __DRI2throttleReason reason, Bool flush)
|
2008-10-12 01:41:14 +01:00
|
|
|
{
|
2010-07-19 15:51:09 +01:00
|
|
|
struct dri2_drawable *priv = (struct dri2_drawable *) pdraw;
|
2010-07-19 20:35:48 +01:00
|
|
|
struct dri2_screen *psc = (struct dri2_screen *) pdraw->psc;
|
2009-08-12 11:41:22 +01:00
|
|
|
XRectangle xrect;
|
|
|
|
|
XserverRegion region;
|
2012-12-28 19:28:38 +00:00
|
|
|
__DRIcontext *ctx = dri2GetCurrentContext();
|
|
|
|
|
unsigned flags;
|
2008-10-12 01:41:14 +01:00
|
|
|
|
2009-08-12 11:41:22 +01:00
|
|
|
/* Check we have the right attachments */
|
|
|
|
|
if (!priv->have_back)
|
|
|
|
|
return;
|
2009-02-16 11:44:40 +00:00
|
|
|
|
2009-08-12 11:41:22 +01:00
|
|
|
xrect.x = x;
|
|
|
|
|
xrect.y = priv->height - y - height;
|
|
|
|
|
xrect.width = width;
|
|
|
|
|
xrect.height = height;
|
2008-10-12 01:41:14 +01:00
|
|
|
|
2012-12-28 19:28:38 +00:00
|
|
|
flags = __DRI2_FLUSH_DRAWABLE;
|
|
|
|
|
if (flush)
|
|
|
|
|
flags |= __DRI2_FLUSH_CONTEXT;
|
2019-10-03 17:16:50 +01:00
|
|
|
dri2Flush(psc, ctx, priv, flags, __DRI2_THROTTLE_COPYSUBBUFFER);
|
2011-10-10 15:38:19 +01:00
|
|
|
|
2010-07-19 20:35:48 +01:00
|
|
|
region = XFixesCreateRegion(psc->base.dpy, &xrect, 1);
|
|
|
|
|
DRI2CopyRegion(psc->base.dpy, pdraw->xDrawable, region,
|
2009-08-12 11:41:22 +01:00
|
|
|
DRI2BufferFrontLeft, DRI2BufferBackLeft);
|
2009-06-23 00:33:29 +01:00
|
|
|
|
2009-08-12 11:41:22 +01:00
|
|
|
/* Refresh the fake front (if present) after we just damaged the real
|
|
|
|
|
* front.
|
|
|
|
|
*/
|
2010-07-20 11:21:17 +01:00
|
|
|
if (priv->have_fake_front)
|
|
|
|
|
DRI2CopyRegion(psc->base.dpy, pdraw->xDrawable, region,
|
|
|
|
|
DRI2BufferFakeFrontLeft, DRI2BufferFrontLeft);
|
|
|
|
|
|
2010-07-19 20:35:48 +01:00
|
|
|
XFixesDestroyRegion(psc->base.dpy, region);
|
2008-10-12 01:41:14 +01:00
|
|
|
}
|
|
|
|
|
|
2011-10-10 15:38:19 +01:00
|
|
|
static void
|
|
|
|
|
dri2CopySubBuffer(__GLXDRIdrawable *pdraw, int x, int y,
|
2012-11-13 16:06:37 +00:00
|
|
|
int width, int height, Bool flush)
|
2011-10-10 15:38:19 +01:00
|
|
|
{
|
|
|
|
|
__dri2CopySubBuffer(pdraw, x, y, width, height,
|
2012-11-13 16:06:37 +00:00
|
|
|
__DRI2_THROTTLE_COPYSUBBUFFER, flush);
|
2011-10-10 15:38:19 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2009-08-12 11:41:22 +01:00
|
|
|
static void
|
2010-07-19 15:51:09 +01:00
|
|
|
dri2_copy_drawable(struct dri2_drawable *priv, int dest, int src)
|
2009-02-16 11:44:40 +00:00
|
|
|
{
|
2009-08-12 11:41:22 +01:00
|
|
|
XRectangle xrect;
|
|
|
|
|
XserverRegion region;
|
2010-07-19 20:35:48 +01:00
|
|
|
struct dri2_screen *psc = (struct dri2_screen *) priv->base.psc;
|
2009-02-16 11:44:40 +00:00
|
|
|
|
2009-08-12 11:41:22 +01:00
|
|
|
xrect.x = 0;
|
|
|
|
|
xrect.y = 0;
|
|
|
|
|
xrect.width = priv->width;
|
|
|
|
|
xrect.height = priv->height;
|
2009-02-16 11:44:40 +00:00
|
|
|
|
2010-07-19 15:32:02 +01:00
|
|
|
if (psc->f)
|
2010-07-19 23:11:03 +01:00
|
|
|
(*psc->f->flush) (priv->driDrawable);
|
2009-02-19 18:39:08 +00:00
|
|
|
|
2010-07-19 20:35:48 +01:00
|
|
|
region = XFixesCreateRegion(psc->base.dpy, &xrect, 1);
|
|
|
|
|
DRI2CopyRegion(psc->base.dpy, priv->base.xDrawable, region, dest, src);
|
|
|
|
|
XFixesDestroyRegion(psc->base.dpy, region);
|
2010-07-19 15:32:02 +01:00
|
|
|
|
2009-02-16 11:44:40 +00:00
|
|
|
}
|
|
|
|
|
|
2009-08-12 11:41:22 +01:00
|
|
|
static void
|
2010-07-28 16:16:00 +01:00
|
|
|
dri2_wait_x(struct glx_context *gc)
|
2009-02-16 11:44:40 +00:00
|
|
|
{
|
2010-07-23 03:24:00 +01:00
|
|
|
struct dri2_drawable *priv = (struct dri2_drawable *)
|
2021-05-03 13:38:02 +01:00
|
|
|
GetGLXDRIDrawable(gc->currentDpy, gc->currentDrawable);
|
2009-02-16 11:44:40 +00:00
|
|
|
|
2010-07-23 03:24:00 +01:00
|
|
|
if (priv == NULL || !priv->have_fake_front)
|
2009-08-12 11:41:22 +01:00
|
|
|
return;
|
2009-02-16 11:44:40 +00:00
|
|
|
|
2010-07-19 15:32:02 +01:00
|
|
|
dri2_copy_drawable(priv, DRI2BufferFakeFrontLeft, DRI2BufferFrontLeft);
|
|
|
|
|
}
|
2009-02-16 11:44:40 +00:00
|
|
|
|
2010-07-19 15:32:02 +01:00
|
|
|
static void
|
2010-07-28 16:16:00 +01:00
|
|
|
dri2_wait_gl(struct glx_context *gc)
|
2010-07-19 15:32:02 +01:00
|
|
|
{
|
2010-07-23 03:24:00 +01:00
|
|
|
struct dri2_drawable *priv = (struct dri2_drawable *)
|
2021-05-03 13:38:02 +01:00
|
|
|
GetGLXDRIDrawable(gc->currentDpy, gc->currentDrawable);
|
2009-02-19 18:39:08 +00:00
|
|
|
|
2010-07-23 03:24:00 +01:00
|
|
|
if (priv == NULL || !priv->have_fake_front)
|
2010-07-19 15:32:02 +01:00
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
dri2_copy_drawable(priv, DRI2BufferFrontLeft, DRI2BufferFakeFrontLeft);
|
2009-02-16 11:44:40 +00:00
|
|
|
}
|
|
|
|
|
|
2012-12-28 20:13:07 +00:00
|
|
|
/**
|
|
|
|
|
* Called by the driver when it needs to update the real front buffer with the
|
|
|
|
|
* contents of its fake front buffer.
|
|
|
|
|
*/
|
2009-08-12 11:41:22 +01:00
|
|
|
static void
|
2010-02-08 18:27:56 +00:00
|
|
|
dri2FlushFrontBuffer(__DRIdrawable *driDrawable, void *loaderPrivate)
|
2009-04-06 20:44:18 +01:00
|
|
|
{
|
2011-08-09 15:58:20 +01:00
|
|
|
struct glx_display *priv;
|
|
|
|
|
struct glx_context *gc;
|
2010-07-19 15:51:09 +01:00
|
|
|
struct dri2_drawable *pdraw = loaderPrivate;
|
2011-10-10 15:38:19 +01:00
|
|
|
struct dri2_screen *psc;
|
2011-08-09 15:58:20 +01:00
|
|
|
|
2011-06-04 01:03:09 +01:00
|
|
|
if (!pdraw)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
if (!pdraw->base.psc)
|
|
|
|
|
return;
|
|
|
|
|
|
2011-10-10 15:38:19 +01:00
|
|
|
psc = (struct dri2_screen *) pdraw->base.psc;
|
|
|
|
|
|
|
|
|
|
priv = __glXInitialize(psc->base.dpy);
|
2013-12-02 14:30:00 +00:00
|
|
|
|
|
|
|
|
if (priv == NULL)
|
|
|
|
|
return;
|
|
|
|
|
|
2011-08-09 15:58:20 +01:00
|
|
|
gc = __glXGetCurrentContext();
|
2010-05-18 19:45:10 +01:00
|
|
|
|
2011-10-10 15:38:19 +01:00
|
|
|
dri2Throttle(psc, pdraw, __DRI2_THROTTLE_FLUSHFRONT);
|
|
|
|
|
|
2010-07-23 21:41:13 +01:00
|
|
|
dri2_wait_gl(gc);
|
2009-04-06 20:44:18 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2009-08-12 11:41:22 +01:00
|
|
|
static void
|
2010-07-28 15:28:43 +01:00
|
|
|
dri2DestroyScreen(struct glx_screen *base)
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
{
|
2010-07-19 19:57:59 +01:00
|
|
|
struct dri2_screen *psc = (struct dri2_screen *) base;
|
|
|
|
|
|
2009-08-12 11:41:22 +01:00
|
|
|
/* Free the direct rendering per screen data */
|
2010-07-19 21:45:23 +01:00
|
|
|
(*psc->core->destroyScreen) (psc->driScreen);
|
2010-07-20 03:12:22 +01:00
|
|
|
driDestroyConfigs(psc->driver_configs);
|
2020-10-16 22:18:18 +01:00
|
|
|
free(psc->driverName);
|
2009-08-12 11:41:22 +01:00
|
|
|
close(psc->fd);
|
2012-09-05 06:52:36 +01:00
|
|
|
free(psc);
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
}
|
|
|
|
|
|
2009-04-21 04:55:56 +01:00
|
|
|
/**
|
|
|
|
|
* Process list of buffer received from the server
|
|
|
|
|
*
|
|
|
|
|
* Processes the list of buffers received in a reply from the server to either
|
|
|
|
|
* \c DRI2GetBuffers or \c DRI2GetBuffersWithFormat.
|
|
|
|
|
*/
|
|
|
|
|
static void
|
2010-07-19 15:51:09 +01:00
|
|
|
process_buffers(struct dri2_drawable * pdraw, DRI2Buffer * buffers,
|
2009-08-12 11:41:22 +01:00
|
|
|
unsigned count)
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
{
|
2009-08-12 11:41:22 +01:00
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
pdraw->bufferCount = count;
|
|
|
|
|
pdraw->have_fake_front = 0;
|
|
|
|
|
pdraw->have_back = 0;
|
|
|
|
|
|
|
|
|
|
/* This assumes the DRI2 buffer attachment tokens matches the
|
|
|
|
|
* __DRIbuffer tokens. */
|
|
|
|
|
for (i = 0; i < count; i++) {
|
|
|
|
|
pdraw->buffers[i].attachment = buffers[i].attachment;
|
|
|
|
|
pdraw->buffers[i].name = buffers[i].name;
|
|
|
|
|
pdraw->buffers[i].pitch = buffers[i].pitch;
|
|
|
|
|
pdraw->buffers[i].cpp = buffers[i].cpp;
|
|
|
|
|
pdraw->buffers[i].flags = buffers[i].flags;
|
|
|
|
|
if (pdraw->buffers[i].attachment == __DRI_BUFFER_FAKE_FRONT_LEFT)
|
|
|
|
|
pdraw->have_fake_front = 1;
|
|
|
|
|
if (pdraw->buffers[i].attachment == __DRI_BUFFER_BACK_LEFT)
|
|
|
|
|
pdraw->have_back = 1;
|
|
|
|
|
}
|
2008-10-15 04:07:42 +01:00
|
|
|
|
2009-04-21 04:55:56 +01:00
|
|
|
}
|
|
|
|
|
|
2010-09-22 06:44:59 +01:00
|
|
|
unsigned dri2GetSwapEventType(Display* dpy, XID drawable)
|
|
|
|
|
{
|
|
|
|
|
struct glx_display *glx_dpy = __glXInitialize(dpy);
|
|
|
|
|
__GLXDRIdrawable *pdraw;
|
2021-05-03 13:38:02 +01:00
|
|
|
pdraw = dri2GetGlxDrawableFromXDrawableId(dpy, drawable);
|
2010-09-22 06:44:59 +01:00
|
|
|
if (!pdraw || !(pdraw->eventMask & GLX_BUFFER_SWAP_COMPLETE_INTEL_MASK))
|
|
|
|
|
return 0;
|
2021-04-23 05:42:35 +01:00
|
|
|
return glx_dpy->codes.first_event + GLX_BufferSwapComplete;
|
2010-09-22 06:44:59 +01:00
|
|
|
}
|
|
|
|
|
|
2012-01-04 01:09:44 +00:00
|
|
|
static void show_fps(struct dri2_drawable *draw)
|
|
|
|
|
{
|
2013-08-28 04:40:05 +01:00
|
|
|
const int interval =
|
|
|
|
|
((struct dri2_screen *) draw->base.psc)->show_fps_interval;
|
2012-01-04 01:09:44 +00:00
|
|
|
struct timeval tv;
|
2012-09-30 20:41:33 +01:00
|
|
|
uint64_t current_time;
|
2012-01-04 01:09:44 +00:00
|
|
|
|
2021-08-02 22:39:27 +01:00
|
|
|
gettimeofday(&tv, NULL);
|
2012-09-30 20:41:33 +01:00
|
|
|
current_time = (uint64_t)tv.tv_sec*1000000 + (uint64_t)tv.tv_usec;
|
2012-01-04 01:09:44 +00:00
|
|
|
|
|
|
|
|
draw->frames++;
|
|
|
|
|
|
2013-08-28 04:40:05 +01:00
|
|
|
if (draw->previous_time + interval * 1000000 <= current_time) {
|
2012-01-04 01:09:44 +00:00
|
|
|
if (draw->previous_time) {
|
2020-01-24 02:01:56 +00:00
|
|
|
fprintf(stderr, "libGL: FPS = %.2f\n",
|
2012-09-30 20:41:33 +01:00
|
|
|
((uint64_t)draw->frames * 1000000) /
|
|
|
|
|
(double)(current_time - draw->previous_time));
|
2012-01-04 01:09:44 +00:00
|
|
|
}
|
|
|
|
|
draw->frames = 0;
|
|
|
|
|
draw->previous_time = current_time;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2012-11-23 17:31:42 +00:00
|
|
|
static int64_t
|
|
|
|
|
dri2XcbSwapBuffers(Display *dpy,
|
|
|
|
|
__GLXDRIdrawable *pdraw,
|
|
|
|
|
int64_t target_msc,
|
|
|
|
|
int64_t divisor,
|
|
|
|
|
int64_t remainder)
|
|
|
|
|
{
|
|
|
|
|
xcb_dri2_swap_buffers_cookie_t swap_buffers_cookie;
|
|
|
|
|
xcb_dri2_swap_buffers_reply_t *swap_buffers_reply;
|
|
|
|
|
uint32_t target_msc_hi, target_msc_lo;
|
|
|
|
|
uint32_t divisor_hi, divisor_lo;
|
|
|
|
|
uint32_t remainder_hi, remainder_lo;
|
|
|
|
|
int64_t ret = 0;
|
|
|
|
|
xcb_connection_t *c = XGetXCBConnection(dpy);
|
|
|
|
|
|
|
|
|
|
split_counter(target_msc, &target_msc_hi, &target_msc_lo);
|
|
|
|
|
split_counter(divisor, &divisor_hi, &divisor_lo);
|
|
|
|
|
split_counter(remainder, &remainder_hi, &remainder_lo);
|
|
|
|
|
|
|
|
|
|
swap_buffers_cookie =
|
|
|
|
|
xcb_dri2_swap_buffers_unchecked(c, pdraw->xDrawable,
|
|
|
|
|
target_msc_hi, target_msc_lo,
|
|
|
|
|
divisor_hi, divisor_lo,
|
|
|
|
|
remainder_hi, remainder_lo);
|
|
|
|
|
|
|
|
|
|
/* Immediately wait on the swapbuffers reply. If we didn't, we'd have
|
|
|
|
|
* to do so some time before reusing a (non-pageflipped) backbuffer.
|
|
|
|
|
* Otherwise, the new rendering could get ahead of the X Server's
|
|
|
|
|
* dispatch of the swapbuffer and you'd display garbage.
|
|
|
|
|
*
|
|
|
|
|
* We use XSync() first to reap the invalidate events through the event
|
|
|
|
|
* filter, to ensure that the next drawing doesn't use an invalidated
|
|
|
|
|
* buffer.
|
|
|
|
|
*/
|
|
|
|
|
XSync(dpy, False);
|
|
|
|
|
|
|
|
|
|
swap_buffers_reply =
|
|
|
|
|
xcb_dri2_swap_buffers_reply(c, swap_buffers_cookie, NULL);
|
2013-01-28 23:04:00 +00:00
|
|
|
if (swap_buffers_reply) {
|
|
|
|
|
ret = merge_counter(swap_buffers_reply->swap_hi,
|
|
|
|
|
swap_buffers_reply->swap_lo);
|
|
|
|
|
free(swap_buffers_reply);
|
|
|
|
|
}
|
2012-11-23 17:31:42 +00:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2009-09-16 07:23:09 +01:00
|
|
|
static int64_t
|
|
|
|
|
dri2SwapBuffers(__GLXDRIdrawable *pdraw, int64_t target_msc, int64_t divisor,
|
2012-11-13 16:06:37 +00:00
|
|
|
int64_t remainder, Bool flush)
|
2009-07-17 08:30:29 +01:00
|
|
|
{
|
2010-07-19 15:51:09 +01:00
|
|
|
struct dri2_drawable *priv = (struct dri2_drawable *) pdraw;
|
2010-07-19 20:35:48 +01:00
|
|
|
struct dri2_screen *psc = (struct dri2_screen *) priv->base.psc;
|
2012-11-23 17:31:42 +00:00
|
|
|
int64_t ret = 0;
|
2009-07-17 08:30:29 +01:00
|
|
|
|
2011-09-14 17:37:48 +01:00
|
|
|
/* Check we have the right attachments */
|
|
|
|
|
if (!priv->have_back)
|
|
|
|
|
return ret;
|
|
|
|
|
|
2021-06-02 19:39:33 +01:00
|
|
|
__DRIcontext *ctx = dri2GetCurrentContext();
|
|
|
|
|
unsigned flags = __DRI2_FLUSH_DRAWABLE;
|
|
|
|
|
if (flush)
|
|
|
|
|
flags |= __DRI2_FLUSH_CONTEXT;
|
|
|
|
|
dri2Flush(psc, ctx, priv, flags, __DRI2_THROTTLE_SWAPBUFFER);
|
|
|
|
|
|
|
|
|
|
ret = dri2XcbSwapBuffers(pdraw->psc->dpy, pdraw,
|
|
|
|
|
target_msc, divisor, remainder);
|
2011-08-18 13:46:02 +01:00
|
|
|
|
2013-08-28 04:40:05 +01:00
|
|
|
if (psc->show_fps_interval) {
|
2012-01-04 01:09:44 +00:00
|
|
|
show_fps(priv);
|
|
|
|
|
}
|
|
|
|
|
|
2009-09-16 07:23:09 +01:00
|
|
|
return ret;
|
2009-07-17 08:30:29 +01:00
|
|
|
}
|
|
|
|
|
|
2009-04-21 04:55:56 +01:00
|
|
|
static __DRIbuffer *
|
2009-08-12 11:41:22 +01:00
|
|
|
dri2GetBuffers(__DRIdrawable * driDrawable,
|
|
|
|
|
int *width, int *height,
|
|
|
|
|
unsigned int *attachments, int count,
|
|
|
|
|
int *out_count, void *loaderPrivate)
|
2009-04-21 04:55:56 +01:00
|
|
|
{
|
2010-07-19 15:51:09 +01:00
|
|
|
struct dri2_drawable *pdraw = loaderPrivate;
|
2009-08-12 11:41:22 +01:00
|
|
|
DRI2Buffer *buffers;
|
2009-04-21 04:55:56 +01:00
|
|
|
|
2009-08-12 11:41:22 +01:00
|
|
|
buffers = DRI2GetBuffers(pdraw->base.psc->dpy, pdraw->base.xDrawable,
|
|
|
|
|
width, height, attachments, count, out_count);
|
|
|
|
|
if (buffers == NULL)
|
|
|
|
|
return NULL;
|
2009-04-21 04:55:56 +01:00
|
|
|
|
2009-08-12 11:41:22 +01:00
|
|
|
pdraw->width = *width;
|
|
|
|
|
pdraw->height = *height;
|
|
|
|
|
process_buffers(pdraw, buffers, *out_count);
|
2009-04-21 04:55:56 +01:00
|
|
|
|
2012-09-05 06:52:36 +01:00
|
|
|
free(buffers);
|
2009-04-21 04:55:56 +01:00
|
|
|
|
2009-08-12 11:41:22 +01:00
|
|
|
return pdraw->buffers;
|
2009-04-21 04:55:56 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static __DRIbuffer *
|
2009-08-12 11:41:22 +01:00
|
|
|
dri2GetBuffersWithFormat(__DRIdrawable * driDrawable,
|
|
|
|
|
int *width, int *height,
|
|
|
|
|
unsigned int *attachments, int count,
|
|
|
|
|
int *out_count, void *loaderPrivate)
|
2009-04-21 04:55:56 +01:00
|
|
|
{
|
2010-07-19 15:51:09 +01:00
|
|
|
struct dri2_drawable *pdraw = loaderPrivate;
|
2009-08-12 11:41:22 +01:00
|
|
|
DRI2Buffer *buffers;
|
2009-04-21 04:55:56 +01:00
|
|
|
|
2009-08-12 11:41:22 +01:00
|
|
|
buffers = DRI2GetBuffersWithFormat(pdraw->base.psc->dpy,
|
|
|
|
|
pdraw->base.xDrawable,
|
|
|
|
|
width, height, attachments,
|
|
|
|
|
count, out_count);
|
|
|
|
|
if (buffers == NULL)
|
|
|
|
|
return NULL;
|
2009-04-21 04:55:56 +01:00
|
|
|
|
2009-08-12 11:41:22 +01:00
|
|
|
pdraw->width = *width;
|
|
|
|
|
pdraw->height = *height;
|
|
|
|
|
process_buffers(pdraw, buffers, *out_count);
|
2009-04-21 04:55:56 +01:00
|
|
|
|
2012-09-05 06:52:36 +01:00
|
|
|
free(buffers);
|
2008-10-15 04:07:42 +01:00
|
|
|
|
2009-08-12 11:41:22 +01:00
|
|
|
return pdraw->buffers;
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
}
|
|
|
|
|
|
2010-07-19 21:39:53 +01:00
|
|
|
static int
|
2009-11-10 21:28:01 +00:00
|
|
|
dri2SetSwapInterval(__GLXDRIdrawable *pdraw, int interval)
|
|
|
|
|
{
|
2012-09-25 20:15:19 +01:00
|
|
|
xcb_connection_t *c = XGetXCBConnection(pdraw->psc->dpy);
|
2010-07-19 15:51:09 +01:00
|
|
|
struct dri2_drawable *priv = (struct dri2_drawable *) pdraw;
|
2010-07-19 20:35:48 +01:00
|
|
|
struct dri2_screen *psc = (struct dri2_screen *) priv->base.psc;
|
2010-04-22 20:49:03 +01:00
|
|
|
|
2022-07-11 20:01:27 +01:00
|
|
|
if (!dri_valid_swap_interval(psc->driScreen, psc->config, interval))
|
|
|
|
|
return GLX_BAD_VALUE;
|
2009-11-10 21:28:01 +00:00
|
|
|
|
2012-09-25 20:15:19 +01:00
|
|
|
xcb_dri2_swap_interval(c, priv->base.xDrawable, interval);
|
2009-11-10 21:28:01 +00:00
|
|
|
priv->swap_interval = interval;
|
2010-07-19 21:39:53 +01:00
|
|
|
|
|
|
|
|
return 0;
|
2009-11-10 21:28:01 +00:00
|
|
|
}
|
|
|
|
|
|
2010-07-20 01:01:59 +01:00
|
|
|
static int
|
2009-11-10 21:28:01 +00:00
|
|
|
dri2GetSwapInterval(__GLXDRIdrawable *pdraw)
|
|
|
|
|
{
|
2010-07-19 15:51:09 +01:00
|
|
|
struct dri2_drawable *priv = (struct dri2_drawable *) pdraw;
|
2009-11-10 21:28:01 +00:00
|
|
|
|
|
|
|
|
return priv->swap_interval;
|
|
|
|
|
}
|
|
|
|
|
|
2012-11-14 23:50:27 +00:00
|
|
|
static void
|
|
|
|
|
driSetBackgroundContext(void *loaderPrivate)
|
|
|
|
|
{
|
|
|
|
|
struct dri2_context *pcp = (struct dri2_context *) loaderPrivate;
|
|
|
|
|
__glXSetCurrentContext(&pcp->base);
|
|
|
|
|
}
|
|
|
|
|
|
2017-05-29 12:18:26 +01:00
|
|
|
static GLboolean
|
|
|
|
|
driIsThreadSafe(void *loaderPrivate)
|
|
|
|
|
{
|
|
|
|
|
struct dri2_context *pcp = (struct dri2_context *) loaderPrivate;
|
|
|
|
|
/* Check Xlib is running in thread safe mode
|
|
|
|
|
*
|
|
|
|
|
* 'lock_fns' is the XLockDisplay function pointer of the X11 display 'dpy'.
|
|
|
|
|
* It wll be NULL if XInitThreads wasn't called.
|
|
|
|
|
*/
|
|
|
|
|
return pcp->base.psc->dpy->lock_fns != NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-13 16:46:25 +01:00
|
|
|
static const __DRIdri2LoaderExtension dri2LoaderExtension = {
|
2014-02-12 18:07:15 +00:00
|
|
|
.base = { __DRI_DRI2_LOADER, 3 },
|
|
|
|
|
|
|
|
|
|
.getBuffers = dri2GetBuffers,
|
|
|
|
|
.flushFrontBuffer = dri2FlushFrontBuffer,
|
|
|
|
|
.getBuffersWithFormat = dri2GetBuffersWithFormat,
|
2009-04-21 04:55:56 +01:00
|
|
|
};
|
|
|
|
|
|
2022-03-15 19:35:19 +00:00
|
|
|
const __DRIuseInvalidateExtension dri2UseInvalidate = {
|
2014-02-12 20:14:15 +00:00
|
|
|
.base = { __DRI_USE_INVALIDATE, 1 }
|
2009-04-21 04:55:56 +01:00
|
|
|
};
|
|
|
|
|
|
2022-03-15 19:35:19 +00:00
|
|
|
const __DRIbackgroundCallableExtension driBackgroundCallable = {
|
2017-05-29 12:18:26 +01:00
|
|
|
.base = { __DRI_BACKGROUND_CALLABLE, 2 },
|
2012-11-14 23:50:27 +00:00
|
|
|
|
|
|
|
|
.setBackgroundContext = driSetBackgroundContext,
|
2017-05-29 12:18:26 +01:00
|
|
|
.isThreadSafe = driIsThreadSafe,
|
2012-11-14 23:50:27 +00:00
|
|
|
};
|
|
|
|
|
|
2010-02-08 18:27:56 +00:00
|
|
|
_X_HIDDEN void
|
|
|
|
|
dri2InvalidateBuffers(Display *dpy, XID drawable)
|
|
|
|
|
{
|
2010-07-19 14:37:07 +01:00
|
|
|
__GLXDRIdrawable *pdraw =
|
2021-05-03 13:38:02 +01:00
|
|
|
dri2GetGlxDrawableFromXDrawableId(dpy, drawable);
|
2011-06-01 21:39:39 +01:00
|
|
|
struct dri2_screen *psc;
|
2010-07-19 23:11:03 +01:00
|
|
|
struct dri2_drawable *pdp = (struct dri2_drawable *) pdraw;
|
2010-02-08 18:27:56 +00:00
|
|
|
|
2011-06-01 21:39:39 +01:00
|
|
|
if (!pdraw)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
psc = (struct dri2_screen *) pdraw->psc;
|
|
|
|
|
|
2019-09-19 15:50:08 +01:00
|
|
|
if (psc->f && psc->f->base.version >= 3 && psc->f->invalidate)
|
2010-07-19 23:11:03 +01:00
|
|
|
psc->f->invalidate(pdp->driDrawable);
|
2010-02-08 18:27:56 +00:00
|
|
|
}
|
|
|
|
|
|
2010-05-21 15:36:56 +01:00
|
|
|
static void
|
2021-03-19 17:39:01 +00:00
|
|
|
dri2_bind_tex_image(__GLXDRIdrawable *base,
|
2010-05-21 15:36:56 +01:00
|
|
|
int buffer, const int *attrib_list)
|
|
|
|
|
{
|
2010-07-28 16:16:00 +01:00
|
|
|
struct glx_context *gc = __glXGetCurrentContext();
|
2010-07-23 22:51:06 +01:00
|
|
|
struct dri2_context *pcp = (struct dri2_context *) gc;
|
2010-07-19 23:11:03 +01:00
|
|
|
struct dri2_drawable *pdraw = (struct dri2_drawable *) base;
|
2010-08-04 17:50:36 +01:00
|
|
|
struct dri2_screen *psc;
|
2010-05-21 15:36:56 +01:00
|
|
|
|
|
|
|
|
if (pdraw != NULL) {
|
2010-08-04 17:50:36 +01:00
|
|
|
psc = (struct dri2_screen *) base->psc;
|
2010-05-21 16:51:33 +01:00
|
|
|
|
2010-07-19 20:35:48 +01:00
|
|
|
if (psc->texBuffer->base.version >= 2 &&
|
|
|
|
|
psc->texBuffer->setTexBuffer2 != NULL) {
|
2010-07-21 18:55:30 +01:00
|
|
|
(*psc->texBuffer->setTexBuffer2) (pcp->driContext,
|
2010-07-19 23:11:03 +01:00
|
|
|
pdraw->base.textureTarget,
|
|
|
|
|
pdraw->base.textureFormat,
|
2010-07-19 20:35:48 +01:00
|
|
|
pdraw->driDrawable);
|
2010-05-21 15:36:56 +01:00
|
|
|
}
|
|
|
|
|
else {
|
2010-07-21 18:55:30 +01:00
|
|
|
(*psc->texBuffer->setTexBuffer) (pcp->driContext,
|
2010-07-19 23:11:03 +01:00
|
|
|
pdraw->base.textureTarget,
|
2010-07-19 20:35:48 +01:00
|
|
|
pdraw->driDrawable);
|
2010-05-21 15:36:56 +01:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2021-03-19 17:39:01 +00:00
|
|
|
dri2_release_tex_image(__GLXDRIdrawable *base, int buffer)
|
2010-05-21 15:36:56 +01:00
|
|
|
{
|
2011-01-09 17:03:02 +00:00
|
|
|
struct glx_context *gc = __glXGetCurrentContext();
|
|
|
|
|
struct dri2_context *pcp = (struct dri2_context *) gc;
|
|
|
|
|
struct dri2_drawable *pdraw = (struct dri2_drawable *) base;
|
|
|
|
|
struct dri2_screen *psc;
|
|
|
|
|
|
2021-03-19 17:39:01 +00:00
|
|
|
if (pdraw != NULL) {
|
2011-01-09 17:03:02 +00:00
|
|
|
psc = (struct dri2_screen *) base->psc;
|
|
|
|
|
|
|
|
|
|
if (psc->texBuffer->base.version >= 3 &&
|
|
|
|
|
psc->texBuffer->releaseTexBuffer != NULL) {
|
|
|
|
|
(*psc->texBuffer->releaseTexBuffer) (pcp->driContext,
|
|
|
|
|
pdraw->base.textureTarget,
|
|
|
|
|
pdraw->driDrawable);
|
|
|
|
|
}
|
|
|
|
|
}
|
2010-05-21 15:36:56 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static const struct glx_context_vtable dri2_context_vtable = {
|
2014-02-18 19:22:29 +00:00
|
|
|
.destroy = dri2_destroy_context,
|
|
|
|
|
.bind = dri2_bind_context,
|
|
|
|
|
.unbind = dri2_unbind_context,
|
|
|
|
|
.wait_gl = dri2_wait_gl,
|
|
|
|
|
.wait_x = dri2_wait_x,
|
2016-03-03 17:43:53 +00:00
|
|
|
.interop_query_device_info = dri2_interop_query_device_info,
|
|
|
|
|
.interop_export_object = dri2_interop_export_object
|
2010-05-21 15:36:56 +01:00
|
|
|
};
|
|
|
|
|
|
2010-07-19 20:35:48 +01:00
|
|
|
static void
|
2013-03-12 23:31:58 +00:00
|
|
|
dri2BindExtensions(struct dri2_screen *psc, struct glx_display * priv,
|
2013-02-15 04:39:36 +00:00
|
|
|
const char *driverName)
|
2010-07-19 20:35:48 +01:00
|
|
|
{
|
2021-08-11 15:18:42 +01:00
|
|
|
const unsigned mask = psc->dri2->getAPIMask(psc->driScreen);
|
2013-03-12 23:31:58 +00:00
|
|
|
const __DRIextension **extensions;
|
2010-07-19 20:35:48 +01:00
|
|
|
int i;
|
|
|
|
|
|
2013-03-12 23:31:58 +00:00
|
|
|
extensions = psc->core->getExtensions(psc->driScreen);
|
|
|
|
|
|
2020-09-09 19:00:35 +01:00
|
|
|
__glXEnableDirectExtension(&psc->base, "GLX_EXT_swap_control");
|
2010-07-19 20:35:48 +01:00
|
|
|
__glXEnableDirectExtension(&psc->base, "GLX_SGI_swap_control");
|
|
|
|
|
__glXEnableDirectExtension(&psc->base, "GLX_MESA_swap_control");
|
2010-07-20 03:40:22 +01:00
|
|
|
__glXEnableDirectExtension(&psc->base, "GLX_SGI_make_current_read");
|
2010-07-19 20:35:48 +01:00
|
|
|
|
2013-02-15 04:39:36 +00:00
|
|
|
/*
|
|
|
|
|
* GLX_INTEL_swap_event is broken on the server side, where it's
|
|
|
|
|
* currently unconditionally enabled. This completely breaks
|
|
|
|
|
* systems running on drivers which don't support that extension.
|
|
|
|
|
* There's no way to test for its presence on this side, so instead
|
2013-03-12 23:31:58 +00:00
|
|
|
* of disabling it unconditionally, just disable it for drivers
|
2021-06-02 19:39:33 +01:00
|
|
|
* which are known to not support it.
|
2013-03-12 23:31:58 +00:00
|
|
|
*
|
2021-06-02 19:39:33 +01:00
|
|
|
* This was fixed in xserver 1.15.0 (190b03215), so now we only
|
|
|
|
|
* disable the broken driver.
|
2013-02-15 04:39:36 +00:00
|
|
|
*/
|
2021-06-02 19:39:33 +01:00
|
|
|
if (strcmp(driverName, "vmwgfx") != 0) {
|
2013-01-25 01:48:12 +00:00
|
|
|
__glXEnableDirectExtension(&psc->base, "GLX_INTEL_swap_event");
|
|
|
|
|
}
|
2010-07-19 20:35:48 +01:00
|
|
|
|
2021-08-11 15:18:42 +01:00
|
|
|
__glXEnableDirectExtension(&psc->base, "GLX_ARB_create_context");
|
|
|
|
|
__glXEnableDirectExtension(&psc->base, "GLX_ARB_create_context_profile");
|
|
|
|
|
__glXEnableDirectExtension(&psc->base, "GLX_EXT_no_config_context");
|
|
|
|
|
|
|
|
|
|
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");
|
2011-11-30 21:15:08 +00:00
|
|
|
}
|
|
|
|
|
|
2010-07-19 20:35:48 +01:00
|
|
|
for (i = 0; extensions[i]; i++) {
|
|
|
|
|
if ((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, __DRI2_CONFIG_QUERY) == 0))
|
|
|
|
|
psc->config = (__DRI2configQueryExtension *) extensions[i];
|
2011-10-10 15:38:19 +01:00
|
|
|
|
|
|
|
|
if (((strcmp(extensions[i]->name, __DRI2_THROTTLE) == 0)))
|
|
|
|
|
psc->throttle = (__DRI2throttleExtension *) extensions[i];
|
2012-07-03 19:32:59 +01:00
|
|
|
|
2021-08-11 15:18:42 +01:00
|
|
|
if (strcmp(extensions[i]->name, __DRI2_ROBUSTNESS) == 0)
|
2012-07-03 19:32:59 +01:00
|
|
|
__glXEnableDirectExtension(&psc->base,
|
|
|
|
|
"GLX_ARB_create_context_robustness");
|
2013-02-16 06:35:55 +00:00
|
|
|
|
2021-08-11 15:18:42 +01:00
|
|
|
if (strcmp(extensions[i]->name, __DRI2_RENDERER_QUERY) == 0) {
|
2013-02-16 06:35:55 +00:00
|
|
|
psc->rendererQuery = (__DRI2rendererQueryExtension *) extensions[i];
|
|
|
|
|
__glXEnableDirectExtension(&psc->base, "GLX_MESA_query_renderer");
|
2021-10-04 22:53:52 +01:00
|
|
|
unsigned int no_error = 0;
|
|
|
|
|
if (psc->rendererQuery->queryInteger(psc->driScreen,
|
|
|
|
|
__DRI2_RENDERER_HAS_NO_ERROR_CONTEXT,
|
|
|
|
|
&no_error) == 0 && no_error)
|
|
|
|
|
__glXEnableDirectExtension(&psc->base,
|
|
|
|
|
"GLX_ARB_create_context_no_error");
|
2013-02-16 06:35:55 +00:00
|
|
|
}
|
2016-03-03 17:43:53 +00:00
|
|
|
|
|
|
|
|
if (strcmp(extensions[i]->name, __DRI2_INTEROP) == 0)
|
|
|
|
|
psc->interop = (__DRI2interopExtension*)extensions[i];
|
2014-10-01 20:00:48 +01:00
|
|
|
|
2021-08-11 15:18:42 +01:00
|
|
|
if (strcmp(extensions[i]->name, __DRI2_FLUSH_CONTROL) == 0)
|
2014-10-01 20:00:48 +01:00
|
|
|
__glXEnableDirectExtension(&psc->base,
|
|
|
|
|
"GLX_ARB_context_flush_control");
|
2010-07-19 20:35:48 +01:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2020-10-16 22:18:18 +01:00
|
|
|
static char *
|
|
|
|
|
dri2_get_driver_name(struct glx_screen *glx_screen)
|
|
|
|
|
{
|
|
|
|
|
struct dri2_screen *psc = (struct dri2_screen *)glx_screen;
|
|
|
|
|
|
|
|
|
|
return psc->driverName;
|
|
|
|
|
}
|
|
|
|
|
|
2010-07-23 21:15:31 +01:00
|
|
|
static const struct glx_screen_vtable dri2_screen_vtable = {
|
2020-11-10 21:06:47 +00:00
|
|
|
.create_context = dri_common_create_context,
|
2014-02-18 19:22:29 +00:00
|
|
|
.create_context_attribs = dri2_create_context_attribs,
|
|
|
|
|
.query_renderer_integer = dri2_query_renderer_integer,
|
|
|
|
|
.query_renderer_string = dri2_query_renderer_string,
|
2020-10-16 22:18:18 +01:00
|
|
|
.get_driver_name = dri2_get_driver_name,
|
2010-07-23 21:15:31 +01:00
|
|
|
};
|
2010-07-19 20:35:48 +01:00
|
|
|
|
2010-07-28 15:28:43 +01:00
|
|
|
static struct glx_screen *
|
2010-07-28 16:16:00 +01:00
|
|
|
dri2CreateScreen(int screen, struct glx_display * priv)
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
{
|
2009-08-12 11:41:22 +01:00
|
|
|
const __DRIconfig **driver_configs;
|
|
|
|
|
const __DRIextension **extensions;
|
2010-07-19 15:51:09 +01:00
|
|
|
const struct dri2_display *const pdp = (struct dri2_display *)
|
2009-04-21 04:55:56 +01:00
|
|
|
priv->dri2Display;
|
2010-07-19 19:57:59 +01:00
|
|
|
struct dri2_screen *psc;
|
2009-08-12 11:41:22 +01:00
|
|
|
__GLXDRIscreen *psp;
|
2011-12-06 18:20:30 +00:00
|
|
|
struct glx_config *configs = NULL, *visuals = NULL;
|
2014-01-23 18:21:09 +00:00
|
|
|
char *driverName = NULL, *loader_driverName, *deviceName, *tmp;
|
2009-08-12 11:41:22 +01:00
|
|
|
drm_magic_t magic;
|
|
|
|
|
int i;
|
|
|
|
|
|
2012-09-05 07:09:22 +01:00
|
|
|
psc = calloc(1, sizeof *psc);
|
2010-07-19 19:57:59 +01:00
|
|
|
if (psc == NULL)
|
2009-08-12 11:41:22 +01:00
|
|
|
return NULL;
|
|
|
|
|
|
2011-01-31 17:09:19 +00:00
|
|
|
psc->fd = -1;
|
|
|
|
|
|
2011-01-29 23:00:48 +00:00
|
|
|
if (!glx_screen_init(&psc->base, screen, priv)) {
|
2012-09-05 06:52:36 +01:00
|
|
|
free(psc);
|
2011-01-29 23:00:48 +00:00
|
|
|
return NULL;
|
|
|
|
|
}
|
2010-07-19 19:57:59 +01:00
|
|
|
|
|
|
|
|
if (!DRI2Connect(priv->dpy, RootWindow(priv->dpy, screen),
|
2010-01-29 15:36:47 +00:00
|
|
|
&driverName, &deviceName)) {
|
2011-01-29 23:00:48 +00:00
|
|
|
glx_screen_cleanup(&psc->base);
|
2012-09-05 06:52:36 +01:00
|
|
|
free(psc);
|
2011-09-14 17:37:48 +01:00
|
|
|
InfoMessageF("screen %d does not appear to be DRI2 capable\n", screen);
|
2009-08-12 11:41:22 +01:00
|
|
|
return NULL;
|
2010-01-29 15:36:47 +00:00
|
|
|
}
|
2009-08-12 11:41:22 +01:00
|
|
|
|
2015-06-17 17:28:50 +01:00
|
|
|
psc->fd = loader_open_device(deviceName);
|
2014-01-23 18:17:11 +00:00
|
|
|
if (psc->fd < 0) {
|
2019-09-27 17:16:22 +01:00
|
|
|
ErrorMessageF("failed to open %s: %s\n", deviceName, strerror(errno));
|
2014-01-23 18:17:11 +00:00
|
|
|
goto handle_error;
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-17 18:42:12 +00:00
|
|
|
if (drmGetMagic(psc->fd, &magic)) {
|
|
|
|
|
ErrorMessageF("failed to get magic\n");
|
|
|
|
|
goto handle_error;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!DRI2Authenticate(priv->dpy, RootWindow(priv->dpy, screen), magic)) {
|
|
|
|
|
ErrorMessageF("failed to authenticate magic %d\n", magic);
|
|
|
|
|
goto handle_error;
|
|
|
|
|
}
|
|
|
|
|
|
2014-01-23 18:21:09 +00:00
|
|
|
/* If Mesa knows about the appropriate driver for this fd, then trust it.
|
|
|
|
|
* Otherwise, default to the server's value.
|
|
|
|
|
*/
|
2016-09-12 17:48:18 +01:00
|
|
|
loader_driverName = loader_get_driver_for_fd(psc->fd);
|
2014-01-23 18:21:09 +00:00
|
|
|
if (loader_driverName) {
|
|
|
|
|
free(driverName);
|
|
|
|
|
driverName = loader_driverName;
|
|
|
|
|
}
|
2020-10-16 22:18:18 +01:00
|
|
|
psc->driverName = driverName;
|
2014-01-23 18:21:09 +00:00
|
|
|
|
2018-11-15 22:22:16 +00:00
|
|
|
extensions = driOpenDriver(driverName, &psc->driver);
|
2013-09-27 23:36:59 +01:00
|
|
|
if (extensions == NULL)
|
2009-08-12 11:41:22 +01:00
|
|
|
goto handle_error;
|
|
|
|
|
|
|
|
|
|
for (i = 0; extensions[i]; i++) {
|
|
|
|
|
if (strcmp(extensions[i]->name, __DRI_CORE) == 0)
|
2009-09-16 07:23:09 +01:00
|
|
|
psc->core = (__DRIcoreExtension *) extensions[i];
|
2009-08-12 11:41:22 +01:00
|
|
|
if (strcmp(extensions[i]->name, __DRI_DRI2) == 0)
|
2009-09-16 07:23:09 +01:00
|
|
|
psc->dri2 = (__DRIdri2Extension *) extensions[i];
|
2009-08-12 11:41:22 +01:00
|
|
|
}
|
|
|
|
|
|
2021-08-25 13:13:21 +01:00
|
|
|
if (psc->core == NULL || psc->dri2 == NULL || psc->dri2->base.version < 3) {
|
2009-08-12 11:41:22 +01:00
|
|
|
ErrorMessageF("core dri or dri2 extension not found\n");
|
|
|
|
|
goto handle_error;
|
|
|
|
|
}
|
|
|
|
|
|
2013-09-27 19:39:25 +01:00
|
|
|
if (psc->dri2->base.version >= 4) {
|
|
|
|
|
psc->driScreen =
|
|
|
|
|
psc->dri2->createNewScreen2(screen, psc->fd,
|
|
|
|
|
(const __DRIextension **)
|
|
|
|
|
&pdp->loader_extensions[0],
|
|
|
|
|
extensions,
|
|
|
|
|
&driver_configs, psc);
|
|
|
|
|
} else {
|
|
|
|
|
psc->driScreen =
|
|
|
|
|
psc->dri2->createNewScreen(screen, psc->fd,
|
|
|
|
|
(const __DRIextension **)
|
|
|
|
|
&pdp->loader_extensions[0],
|
|
|
|
|
&driver_configs, psc);
|
|
|
|
|
}
|
2009-08-12 11:41:22 +01:00
|
|
|
|
2010-07-19 21:45:23 +01:00
|
|
|
if (psc->driScreen == NULL) {
|
2022-03-20 00:01:24 +00:00
|
|
|
ErrorMessageF("glx: failed to create dri2 screen\n");
|
2010-01-29 15:36:47 +00:00
|
|
|
goto handle_error;
|
2009-08-12 11:41:22 +01:00
|
|
|
}
|
|
|
|
|
|
2013-03-12 23:31:58 +00:00
|
|
|
dri2BindExtensions(psc, priv, driverName);
|
2009-08-12 11:41:22 +01:00
|
|
|
|
2011-12-06 18:20:30 +00:00
|
|
|
configs = driConvertConfigs(psc->core, psc->base.configs, driver_configs);
|
|
|
|
|
visuals = driConvertConfigs(psc->core, psc->base.visuals, driver_configs);
|
|
|
|
|
|
2014-05-10 11:04:44 +01:00
|
|
|
if (!configs || !visuals) {
|
|
|
|
|
ErrorMessageF("No matching fbConfigs or visuals found\n");
|
2011-12-06 18:20:30 +00:00
|
|
|
goto handle_error;
|
2014-05-10 11:04:44 +01:00
|
|
|
}
|
2011-12-06 18:20:30 +00:00
|
|
|
|
|
|
|
|
glx_config_destroy_list(psc->base.configs);
|
|
|
|
|
psc->base.configs = configs;
|
|
|
|
|
glx_config_destroy_list(psc->base.visuals);
|
|
|
|
|
psc->base.visuals = visuals;
|
2009-08-12 11:41:22 +01:00
|
|
|
|
2010-07-20 03:12:22 +01:00
|
|
|
psc->driver_configs = driver_configs;
|
2009-08-12 11:41:22 +01:00
|
|
|
|
2010-07-23 21:15:31 +01:00
|
|
|
psc->base.vtable = &dri2_screen_vtable;
|
2021-08-06 22:53:38 +01:00
|
|
|
psc->base.context_vtable = &dri2_context_vtable;
|
2010-07-19 21:45:23 +01:00
|
|
|
psp = &psc->vtable;
|
2010-07-19 19:57:59 +01:00
|
|
|
psc->base.driScreen = psp;
|
2009-08-12 11:41:22 +01:00
|
|
|
psp->destroyScreen = dri2DestroyScreen;
|
|
|
|
|
psp->createDrawable = dri2CreateDrawable;
|
|
|
|
|
psp->swapBuffers = dri2SwapBuffers;
|
2010-02-04 12:46:21 +00:00
|
|
|
psp->getDrawableMSC = NULL;
|
|
|
|
|
psp->waitForMSC = NULL;
|
|
|
|
|
psp->waitForSBC = NULL;
|
|
|
|
|
psp->setSwapInterval = NULL;
|
|
|
|
|
psp->getSwapInterval = NULL;
|
2014-02-24 19:44:42 +00:00
|
|
|
psp->getBufferAge = NULL;
|
2021-03-19 17:39:01 +00:00
|
|
|
psp->bindTexImage = dri2_bind_tex_image;
|
|
|
|
|
psp->releaseTexImage = dri2_release_tex_image;
|
2010-02-04 12:46:21 +00:00
|
|
|
|
2021-06-02 19:39:33 +01:00
|
|
|
psp->getDrawableMSC = dri2DrawableGetMSC;
|
|
|
|
|
psp->waitForMSC = dri2WaitForMSC;
|
|
|
|
|
psp->waitForSBC = dri2WaitForSBC;
|
|
|
|
|
psp->setSwapInterval = dri2SetSwapInterval;
|
|
|
|
|
psp->getSwapInterval = dri2GetSwapInterval;
|
|
|
|
|
psp->maxSwapInterval = INT_MAX;
|
2009-08-12 11:41:22 +01:00
|
|
|
|
2021-06-02 19:39:33 +01:00
|
|
|
__glXEnableDirectExtension(&psc->base, "GLX_OML_sync_control");
|
2020-10-21 08:40:29 +01:00
|
|
|
__glXEnableDirectExtension(&psc->base, "GLX_SGI_video_sync");
|
2018-02-26 13:27:40 +00:00
|
|
|
|
2020-10-15 16:29:45 +01:00
|
|
|
if (psc->config->base.version > 1 &&
|
|
|
|
|
psc->config->configQuerys(psc->driScreen, "glx_extension_override",
|
|
|
|
|
&tmp) == 0)
|
|
|
|
|
__glXParseExtensionOverride(&psc->base, tmp);
|
|
|
|
|
|
2020-10-20 14:20:20 +01:00
|
|
|
if (psc->config->base.version > 1 &&
|
|
|
|
|
psc->config->configQuerys(psc->driScreen,
|
|
|
|
|
"indirect_gl_extension_override",
|
|
|
|
|
&tmp) == 0)
|
|
|
|
|
__IndirectGlParseExtensionOverride(&psc->base, tmp);
|
|
|
|
|
|
2021-10-07 11:14:44 +01:00
|
|
|
if (psc->config->base.version > 1) {
|
|
|
|
|
uint8_t force = false;
|
|
|
|
|
if (psc->config->configQueryb(psc->driScreen, "force_direct_glx_context",
|
|
|
|
|
&force) == 0) {
|
|
|
|
|
psc->base.force_direct_context = force;
|
|
|
|
|
}
|
2021-10-31 05:02:02 +00:00
|
|
|
|
|
|
|
|
uint8_t invalid_glx_destroy_window = false;
|
|
|
|
|
if (psc->config->configQueryb(psc->driScreen,
|
|
|
|
|
"allow_invalid_glx_destroy_window",
|
|
|
|
|
&invalid_glx_destroy_window) == 0) {
|
|
|
|
|
psc->base.allow_invalid_glx_destroy_window = invalid_glx_destroy_window;
|
|
|
|
|
}
|
2021-10-07 11:14:44 +01:00
|
|
|
}
|
|
|
|
|
|
2015-12-09 16:25:15 +00:00
|
|
|
/* DRI2 supports SubBuffer through DRI2CopyRegion, so it's always
|
2009-08-12 11:41:22 +01:00
|
|
|
* available.*/
|
|
|
|
|
psp->copySubBuffer = dri2CopySubBuffer;
|
2010-07-19 19:57:59 +01:00
|
|
|
__glXEnableDirectExtension(&psc->base, "GLX_MESA_copy_sub_buffer");
|
2009-08-12 11:41:22 +01:00
|
|
|
|
2012-09-05 06:52:36 +01:00
|
|
|
free(deviceName);
|
2009-08-12 11:41:22 +01:00
|
|
|
|
2012-01-04 01:09:44 +00:00
|
|
|
tmp = getenv("LIBGL_SHOW_FPS");
|
2013-08-28 04:40:05 +01:00
|
|
|
psc->show_fps_interval = (tmp) ? atoi(tmp) : 0;
|
|
|
|
|
if (psc->show_fps_interval < 0)
|
|
|
|
|
psc->show_fps_interval = 0;
|
2012-01-04 01:09:44 +00:00
|
|
|
|
2015-05-06 11:31:30 +01:00
|
|
|
InfoMessageF("Using DRI2 for screen %d\n", screen);
|
|
|
|
|
|
2010-07-19 19:57:59 +01:00
|
|
|
return &psc->base;
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
|
2009-09-16 07:23:09 +01:00
|
|
|
handle_error:
|
2012-02-04 00:25:38 +00:00
|
|
|
CriticalErrorMessageF("failed to load driver: %s\n", driverName);
|
|
|
|
|
|
2011-12-06 18:20:30 +00:00
|
|
|
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;
|
2011-01-31 17:09:19 +00:00
|
|
|
if (psc->fd >= 0)
|
2011-01-29 23:00:48 +00:00
|
|
|
close(psc->fd);
|
|
|
|
|
if (psc->driver)
|
|
|
|
|
dlclose(psc->driver);
|
2011-12-06 18:20:30 +00:00
|
|
|
|
2012-09-05 06:52:36 +01:00
|
|
|
free(deviceName);
|
2011-01-29 23:00:48 +00:00
|
|
|
glx_screen_cleanup(&psc->base);
|
2012-09-05 06:52:36 +01:00
|
|
|
free(psc);
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
|
2009-08-12 11:41:22 +01:00
|
|
|
return NULL;
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Called from __glXFreeDisplayPrivate.
|
|
|
|
|
*/
|
2009-08-12 11:41:22 +01:00
|
|
|
static void
|
|
|
|
|
dri2DestroyDisplay(__GLXDRIdisplay * dpy)
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
{
|
2011-04-07 22:48:28 +01:00
|
|
|
struct dri2_display *pdp = (struct dri2_display *) dpy;
|
|
|
|
|
|
|
|
|
|
__glxHashDestroy(pdp->dri2Hash);
|
2012-09-05 06:52:36 +01:00
|
|
|
free(dpy);
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
}
|
|
|
|
|
|
2010-07-19 14:37:07 +01:00
|
|
|
_X_HIDDEN __GLXDRIdrawable *
|
2021-05-03 13:38:02 +01:00
|
|
|
dri2GetGlxDrawableFromXDrawableId(Display *dpy, XID id)
|
2010-07-19 14:37:07 +01:00
|
|
|
{
|
2021-05-03 13:38:02 +01:00
|
|
|
struct glx_display *d = __glXInitialize(dpy);
|
2010-07-19 15:51:09 +01:00
|
|
|
struct dri2_display *pdp = (struct dri2_display *) d->dri2Display;
|
2010-07-19 14:37:07 +01:00
|
|
|
__GLXDRIdrawable *pdraw;
|
|
|
|
|
|
|
|
|
|
if (__glxHashLookup(pdp->dri2Hash, id, (void *) &pdraw) == 0)
|
|
|
|
|
return pdraw;
|
|
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
/*
|
|
|
|
|
* Allocate, initialize and return a __DRIdisplayPrivate object.
|
|
|
|
|
* This is called from __glXInitialize() when we are given a new
|
|
|
|
|
* display pointer.
|
|
|
|
|
*/
|
2009-08-12 11:41:22 +01:00
|
|
|
_X_HIDDEN __GLXDRIdisplay *
|
|
|
|
|
dri2CreateDisplay(Display * dpy)
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
{
|
2010-07-19 15:51:09 +01:00
|
|
|
struct dri2_display *pdp;
|
2010-05-11 14:42:57 +01:00
|
|
|
int eventBase, errorBase, i;
|
2022-07-06 15:22:39 +01:00
|
|
|
int driMajor, driMinor;
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
|
2009-08-12 11:41:22 +01:00
|
|
|
if (!DRI2QueryExtension(dpy, &eventBase, &errorBase))
|
|
|
|
|
return NULL;
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
|
2012-09-05 06:52:36 +01:00
|
|
|
pdp = malloc(sizeof *pdp);
|
2009-08-12 11:41:22 +01:00
|
|
|
if (pdp == NULL)
|
|
|
|
|
return NULL;
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
|
2022-07-06 15:22:39 +01:00
|
|
|
if (!DRI2QueryVersion(dpy, &driMajor, &driMinor) ||
|
|
|
|
|
driMinor < 3) {
|
2021-06-02 19:39:33 +01:00
|
|
|
free(pdp);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2009-08-12 11:41:22 +01:00
|
|
|
pdp->base.destroyDisplay = dri2DestroyDisplay;
|
|
|
|
|
pdp->base.createScreen = dri2CreateScreen;
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
|
2010-05-11 14:42:57 +01:00
|
|
|
i = 0;
|
2021-06-02 19:39:33 +01:00
|
|
|
pdp->loader_extensions[i++] = &dri2LoaderExtension.base;
|
2010-05-18 19:45:10 +01:00
|
|
|
pdp->loader_extensions[i++] = &dri2UseInvalidate.base;
|
2012-11-14 23:50:27 +00:00
|
|
|
pdp->loader_extensions[i++] = &driBackgroundCallable.base;
|
2010-05-18 19:02:57 +01:00
|
|
|
pdp->loader_extensions[i++] = NULL;
|
2010-05-11 14:42:57 +01:00
|
|
|
|
2010-07-19 14:37:07 +01:00
|
|
|
pdp->dri2Hash = __glxHashCreate();
|
|
|
|
|
if (pdp->dri2Hash == NULL) {
|
2012-09-05 06:52:36 +01:00
|
|
|
free(pdp);
|
2010-07-19 14:37:07 +01:00
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2009-08-12 11:41:22 +01:00
|
|
|
return &pdp->base;
|
DRI interface changes and DRI2 direct rendering support.
Add DRI2 direct rendering support to libGL and add DRI2 client side
protocol code. Extend the GLX 1.3 create drawable functions in
glx_pbuffer.c to call into the DRI driver when possible.
Introduce __DRIconfig, opaque struct that represents a DRI driver
configuration. Get's rid of the open coded __GLcontextModes in the
DRI driver interface and the context modes create and destroy
functions that the loader was requires to provide. glcore.h is no
longer part of the DRI driver interface. The DRI config is GL binding
agnostic, that is, not specific to GLX, EGL or other bindings.
The core API is now also an extension, and the driver exports a list
of extensions as the symbol __driDriverExtensions, which the loader
must dlsym() for. The list of extension will always include the DRI
core extension, which allows creating and manipulating DRI screens,
drawables and contexts. The DRI legacy extension, when available,
provides alternative entry points for creating the DRI objects that
work with the XF86DRI infrastructure.
Change DRI2 client code to not use drm drawables or contexts. We
never used drm_drawable_t's and the only use for drm_context_t was as
a unique identifier when taking the lock. We now just allocate a
unique lock ID out of the DRILock sarea block. Once we get rid of the
lock entirely, we can drop this hack.
Change the interface between dri_util.c and the drivers, so that the
drivers now export the DriverAPI struct as driDriverAPI instead of the
InitScreen entry point. This lets us avoid dlsym()'ing for the DRI2
init screen function to see if DRI2 is supported by the driver.
2008-03-26 23:26:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#endif /* GLX_DIRECT_RENDERING */
|
