Merge remote-tracking branch 'idr/GLX_ARB_create_context'
This commit is contained in:
commit
ffb47a123d
|
@ -777,7 +777,7 @@ DRI2PROTO="dri2proto >= 2.7"
|
|||
XINERAMAPROTO="xineramaproto"
|
||||
BIGFONTPROTO="xf86bigfontproto >= 1.2.0"
|
||||
DGAPROTO="xf86dgaproto >= 2.0.99.1"
|
||||
GLPROTO="glproto >= 1.4.14"
|
||||
GLPROTO="glproto >= 1.4.15"
|
||||
DMXPROTO="dmxproto >= 2.2.99.1"
|
||||
VIDMODEPROTO="xf86vidmodeproto >= 2.2.99.1"
|
||||
WINDOWSWMPROTO="windowswmproto"
|
||||
|
|
|
@ -26,17 +26,62 @@
|
|||
|
||||
#include "glxserver.h"
|
||||
#include "indirect_dispatch.h"
|
||||
#include "glxbyteorder.h"
|
||||
#include "unpack.h"
|
||||
|
||||
int
|
||||
__glXDisp_SetClientInfoARB(__GLXclientState * cl, GLbyte * pc)
|
||||
{
|
||||
return BadRequest;
|
||||
xGLXSetClientInfoARBReq *req = (xGLXSetClientInfoARBReq *) pc;
|
||||
char *gl_extensions;
|
||||
char *glx_extensions;
|
||||
|
||||
/* Verify that the size of the packet matches the size inferred from the
|
||||
* sizes specified for the various fields.
|
||||
*/
|
||||
const unsigned expected_size = sz_xGLXSetClientInfoARBReq
|
||||
+ (req->numVersions * 8)
|
||||
+ __GLX_PAD(req->numGLExtensionBytes)
|
||||
+ __GLX_PAD(req->numGLXExtensionBytes);
|
||||
|
||||
if (req->length != (expected_size / 4))
|
||||
return BadLength;
|
||||
|
||||
/* Verify that the actual length of the GL extension string matches what's
|
||||
* encoded in protocol packet.
|
||||
*/
|
||||
gl_extensions = (char *) (req + 1) + (req->numVersions * 8);
|
||||
if (req->numGLExtensionBytes != 0
|
||||
&& memchr(gl_extensions, 0,
|
||||
__GLX_PAD(req->numGLExtensionBytes)) == NULL)
|
||||
return BadLength;
|
||||
|
||||
/* Verify that the actual length of the GLX extension string matches
|
||||
* what's encoded in protocol packet.
|
||||
*/
|
||||
glx_extensions = gl_extensions + __GLX_PAD(req->numGLExtensionBytes);
|
||||
if (req->numGLXExtensionBytes != 0
|
||||
&& memchr(glx_extensions, 0,
|
||||
__GLX_PAD(req->numGLXExtensionBytes)) == NULL)
|
||||
return BadLength;
|
||||
|
||||
free(cl->GLClientextensions);
|
||||
cl->GLClientextensions = strdup(gl_extensions);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
__glXDispSwap_SetClientInfoARB(__GLXclientState * cl, GLbyte * pc)
|
||||
{
|
||||
return BadRequest;
|
||||
xGLXSetClientInfoARBReq *req = (xGLXSetClientInfoARBReq *) pc;
|
||||
|
||||
req->length = bswap_16(req->length);
|
||||
req->numVersions = bswap_32(req->numVersions);
|
||||
req->numGLExtensionBytes = bswap_32(req->numGLExtensionBytes);
|
||||
req->numGLXExtensionBytes = bswap_32(req->numGLXExtensionBytes);
|
||||
|
||||
return __glXDisp_SetClientInfoARB(cl, pc);
|
||||
}
|
||||
|
||||
int
|
||||
|
|
|
@ -24,13 +24,224 @@
|
|||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <GL/glxtokens.h>
|
||||
#include "glxserver.h"
|
||||
#include "glxext.h"
|
||||
#include "indirect_dispatch.h"
|
||||
|
||||
#define ALL_VALID_FLAGS \
|
||||
(GLX_CONTEXT_DEBUG_BIT_ARB | GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB)
|
||||
|
||||
static Bool
|
||||
validate_GL_version(int major_version, int minor_version)
|
||||
{
|
||||
if (major_version <= 0 || minor_version < 0)
|
||||
return False;
|
||||
|
||||
switch (major_version) {
|
||||
case 1:
|
||||
if (minor_version > 5)
|
||||
return False;
|
||||
break;
|
||||
|
||||
case 2:
|
||||
if (minor_version > 1)
|
||||
return False;
|
||||
break;
|
||||
|
||||
case 3:
|
||||
if (minor_version > 3)
|
||||
return False;
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return True;
|
||||
}
|
||||
|
||||
static Bool
|
||||
validate_render_type(uint32_t render_type)
|
||||
{
|
||||
switch (render_type) {
|
||||
case GLX_RGBA_TYPE:
|
||||
case GLX_COLOR_INDEX_TYPE:
|
||||
return True;
|
||||
default:
|
||||
return False;
|
||||
}
|
||||
}
|
||||
|
||||
int
|
||||
__glXDisp_CreateContextAttribsARB(__GLXclientState * cl, GLbyte * pc)
|
||||
{
|
||||
return BadRequest;
|
||||
ClientPtr client = cl->client;
|
||||
xGLXCreateContextAttribsARBReq *req = (xGLXCreateContextAttribsARBReq *) pc;
|
||||
int32_t *attribs = (req->numAttribs != 0) ? (int32_t *) (req + 1) : NULL;
|
||||
unsigned i;
|
||||
int major_version = 1;
|
||||
int minor_version = 0;
|
||||
uint32_t flags = 0;
|
||||
uint32_t render_type = GLX_RGBA_TYPE;
|
||||
__GLXcontext *ctx = NULL;
|
||||
__GLXcontext *shareCtx = NULL;
|
||||
__GLXscreen *glxScreen;
|
||||
__GLXconfig *config;
|
||||
int err;
|
||||
|
||||
/* Verify that the size of the packet matches the size inferred from the
|
||||
* sizes specified for the various fields.
|
||||
*/
|
||||
const unsigned expected_size = (sz_xGLXCreateContextAttribsARBReq
|
||||
+ (req->numAttribs * 8)) / 4;
|
||||
|
||||
if (req->length != expected_size)
|
||||
return BadLength;
|
||||
|
||||
LEGAL_NEW_RESOURCE(req->context, client);
|
||||
|
||||
/* The GLX_ARB_create_context spec says:
|
||||
*
|
||||
* "* If <config> is not a valid GLXFBConfig, GLXBadFBConfig is
|
||||
* generated."
|
||||
*
|
||||
* On the client, the screen comes from the FBConfig, so GLXBadFBConfig
|
||||
* should be issued if the screen is nonsense.
|
||||
*/
|
||||
if (!validGlxScreen(client, req->screen, &glxScreen, &err))
|
||||
return __glXError(GLXBadFBConfig);
|
||||
|
||||
if (!validGlxFBConfig(client, glxScreen, req->fbconfig, &config, &err))
|
||||
return __glXError(GLXBadFBConfig);
|
||||
|
||||
/* Validate the context with which the new context should share resources.
|
||||
*/
|
||||
if (req->shareList != None) {
|
||||
if (!validGlxContext(client, req->shareList, DixReadAccess,
|
||||
&shareCtx, &err))
|
||||
return err;
|
||||
|
||||
/* The crazy condition is because C doesn't have a logical XOR
|
||||
* operator. Comparing directly for equality may fail if one is 1 and
|
||||
* the other is 2 even though both are logically true.
|
||||
*/
|
||||
if (!!req->isDirect != !!shareCtx->isDirect) {
|
||||
client->errorValue = req->shareList;
|
||||
return BadMatch;
|
||||
}
|
||||
|
||||
/* The GLX_ARB_create_context spec says:
|
||||
*
|
||||
* "* If the server context state for <share_context>...was
|
||||
* created on a different screen than the one referenced by
|
||||
* <config>...BadMatch is generated."
|
||||
*/
|
||||
if (glxScreen != shareCtx->pGlxScreen) {
|
||||
client->errorValue = shareCtx->pGlxScreen->pScreen->myNum;
|
||||
return BadMatch;
|
||||
}
|
||||
}
|
||||
|
||||
for (i = 0; i < req->numAttribs; i++) {
|
||||
switch (attribs[i * 2]) {
|
||||
case GLX_CONTEXT_MAJOR_VERSION_ARB:
|
||||
major_version = attribs[2 * i + 1];
|
||||
break;
|
||||
|
||||
case GLX_CONTEXT_MINOR_VERSION_ARB:
|
||||
minor_version = attribs[2 * i + 1];
|
||||
break;
|
||||
|
||||
case GLX_CONTEXT_FLAGS_ARB:
|
||||
flags = attribs[2 * i + 1];
|
||||
break;
|
||||
|
||||
case GLX_RENDER_TYPE:
|
||||
render_type = attribs[2 * i + 1];
|
||||
break;
|
||||
|
||||
default:
|
||||
return BadValue;
|
||||
}
|
||||
}
|
||||
|
||||
/* The GLX_ARB_create_context spec says:
|
||||
*
|
||||
* "If attributes GLX_CONTEXT_MAJOR_VERSION_ARB and
|
||||
* GLX_CONTEXT_MINOR_VERSION_ARB, when considered together
|
||||
* with attributes GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB and
|
||||
* GLX_RENDER_TYPE, specify an OpenGL version and feature set
|
||||
* that are not defined, BadMatch is generated.
|
||||
*
|
||||
* ...Feature deprecation was introduced with OpenGL 3.0, so
|
||||
* forward-compatible contexts may only be requested for
|
||||
* OpenGL 3.0 and above. Thus, examples of invalid
|
||||
* combinations of attributes include:
|
||||
*
|
||||
* - Major version < 1 or > 3
|
||||
* - Major version == 1 and minor version < 0 or > 5
|
||||
* - Major version == 2 and minor version < 0 or > 1
|
||||
* - Major version == 3 and minor version > 2
|
||||
* - Forward-compatible flag set and major version < 3
|
||||
* - Color index rendering and major version >= 3"
|
||||
*/
|
||||
if (!validate_GL_version(major_version, minor_version))
|
||||
return BadMatch;
|
||||
|
||||
if (major_version < 3
|
||||
&& ((flags & GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB) != 0))
|
||||
return BadMatch;
|
||||
|
||||
if (major_version >= 3 && render_type == GLX_COLOR_INDEX_TYPE)
|
||||
return BadMatch;
|
||||
|
||||
if (!validate_render_type(render_type))
|
||||
return BadValue;
|
||||
|
||||
if ((flags & ~ALL_VALID_FLAGS) != 0)
|
||||
return BadValue;
|
||||
|
||||
/* Allocate memory for the new context
|
||||
*/
|
||||
if (req->isDirect) {
|
||||
ctx = __glXdirectContextCreate(glxScreen, config, shareCtx);
|
||||
err = BadAlloc;
|
||||
}
|
||||
else {
|
||||
ctx = glxScreen->createContext(glxScreen, config, shareCtx,
|
||||
req->numAttribs, (uint32_t *) attribs,
|
||||
&err);
|
||||
}
|
||||
|
||||
if (ctx == NULL)
|
||||
return err;
|
||||
|
||||
ctx->pGlxScreen = glxScreen;
|
||||
ctx->config = config;
|
||||
ctx->id = req->context;
|
||||
ctx->share_id = req->shareList;
|
||||
ctx->idExists = True;
|
||||
ctx->isCurrent = False;
|
||||
ctx->isDirect = req->isDirect;
|
||||
ctx->hasUnflushedCommands = False;
|
||||
ctx->renderMode = GL_RENDER;
|
||||
ctx->feedbackBuf = NULL;
|
||||
ctx->feedbackBufSize = 0;
|
||||
ctx->selectBuf = NULL;
|
||||
ctx->selectBufSize = 0;
|
||||
ctx->drawPriv = NULL;
|
||||
ctx->readPriv = NULL;
|
||||
|
||||
/* Add the new context to the various global tables of GLX contexts.
|
||||
*/
|
||||
if (!__glXAddContext(ctx)) {
|
||||
(*ctx->destroy) (ctx);
|
||||
client->errorValue = req->context;
|
||||
return BadAlloc;
|
||||
}
|
||||
|
||||
return Success;
|
||||
}
|
||||
|
||||
int
|
||||
|
|
|
@ -67,23 +67,27 @@ struct extension_info {
|
|||
|
||||
static const struct extension_info known_glx_extensions[] = {
|
||||
/* GLX_ARB_get_proc_address is implemented on the client. */
|
||||
{GLX(ARB_multisample), VER(1, 4), Y,},
|
||||
/* *INDENT-OFF* */
|
||||
{ GLX(ARB_create_context), VER(0,0), N, },
|
||||
{ GLX(ARB_create_context_profile), VER(0,0), N, },
|
||||
{ GLX(ARB_multisample), VER(1,4), Y, },
|
||||
|
||||
{GLX(EXT_import_context), VER(0, 0), Y,},
|
||||
{GLX(EXT_texture_from_pixmap), VER(0, 0), Y,},
|
||||
{GLX(EXT_visual_info), VER(0, 0), Y,},
|
||||
{GLX(EXT_visual_rating), VER(0, 0), Y,},
|
||||
{ GLX(EXT_import_context), VER(0,0), Y, },
|
||||
{ GLX(EXT_texture_from_pixmap), VER(0,0), Y, },
|
||||
{ GLX(EXT_visual_info), VER(0,0), Y, },
|
||||
{ GLX(EXT_visual_rating), VER(0,0), Y, },
|
||||
|
||||
{GLX(MESA_copy_sub_buffer), VER(0, 0), N,},
|
||||
{GLX(OML_swap_method), VER(0, 0), Y,},
|
||||
{GLX(SGI_make_current_read), VER(1, 3), N,},
|
||||
{GLX(SGI_swap_control), VER(0, 0), N,},
|
||||
{GLX(SGIS_multisample), VER(0, 0), Y,},
|
||||
{GLX(SGIX_fbconfig), VER(1, 3), Y,},
|
||||
{GLX(SGIX_pbuffer), VER(1, 3), Y,},
|
||||
{GLX(SGIX_visual_select_group), VER(0, 0), Y,},
|
||||
{GLX(INTEL_swap_event), VER(1, 4), N,},
|
||||
{NULL}
|
||||
{ GLX(MESA_copy_sub_buffer), VER(0,0), N, },
|
||||
{ GLX(OML_swap_method), VER(0,0), Y, },
|
||||
{ GLX(SGI_make_current_read), VER(1,3), N, },
|
||||
{ GLX(SGI_swap_control), VER(0,0), N, },
|
||||
{ GLX(SGIS_multisample), VER(0,0), Y, },
|
||||
{ GLX(SGIX_fbconfig), VER(1,3), Y, },
|
||||
{ GLX(SGIX_pbuffer), VER(1,3), Y, },
|
||||
{ GLX(SGIX_visual_select_group), VER(0,0), Y, },
|
||||
{ GLX(INTEL_swap_event), VER(1,4), N, },
|
||||
{ NULL }
|
||||
/* *INDENT-ON* */
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
|
@ -36,7 +36,9 @@
|
|||
|
||||
enum {
|
||||
/* GLX_ARB_get_proc_address is implemented on the client. */
|
||||
ARB_multisample_bit = 0,
|
||||
ARB_create_context_bit = 0,
|
||||
ARB_create_context_profile_bit,
|
||||
ARB_multisample_bit,
|
||||
EXT_import_context_bit,
|
||||
EXT_texture_from_pixmap_bit,
|
||||
EXT_visual_info_bit,
|
||||
|
|
|
@ -50,7 +50,7 @@
|
|||
#include "indirect_table.h"
|
||||
#include "indirect_util.h"
|
||||
|
||||
static int
|
||||
_X_HIDDEN int
|
||||
validGlxScreen(ClientPtr client, int screen, __GLXscreen ** pGlxScreen,
|
||||
int *err)
|
||||
{
|
||||
|
@ -67,7 +67,7 @@ validGlxScreen(ClientPtr client, int screen, __GLXscreen ** pGlxScreen,
|
|||
return TRUE;
|
||||
}
|
||||
|
||||
static int
|
||||
_X_HIDDEN int
|
||||
validGlxFBConfig(ClientPtr client, __GLXscreen * pGlxScreen, XID id,
|
||||
__GLXconfig ** config, int *err)
|
||||
{
|
||||
|
@ -131,7 +131,7 @@ validGlxFBConfigForWindow(ClientPtr client, __GLXconfig * config,
|
|||
return TRUE;
|
||||
}
|
||||
|
||||
static int
|
||||
_X_HIDDEN int
|
||||
validGlxContext(ClientPtr client, XID id, int access_mode,
|
||||
__GLXcontext ** context, int *err)
|
||||
{
|
||||
|
@ -200,7 +200,7 @@ __glXdirectContextDestroy(__GLXcontext * context)
|
|||
free(context);
|
||||
}
|
||||
|
||||
static __GLXcontext *
|
||||
_X_HIDDEN __GLXcontext *
|
||||
__glXdirectContextCreate(__GLXscreen * screen,
|
||||
__GLXconfig * modes, __GLXcontext * shareContext)
|
||||
{
|
||||
|
@ -251,20 +251,20 @@ DoCreateContext(__GLXclientState * cl, GLXContextID gcId,
|
|||
&shareglxc, &err))
|
||||
return err;
|
||||
|
||||
if (shareglxc->isDirect) {
|
||||
/*
|
||||
** NOTE: no support for sharing display lists between direct
|
||||
** contexts, even if they are in the same address space.
|
||||
*/
|
||||
#if 0
|
||||
/* Disabling this code seems to allow shared display lists
|
||||
* and texture objects to work. We'll leave it disabled for now.
|
||||
*/
|
||||
/* Page 26 (page 32 of the PDF) of the GLX 1.4 spec says:
|
||||
*
|
||||
* "The server context state for all sharing contexts must exist
|
||||
* in a single address space or a BadMatch error is generated."
|
||||
*
|
||||
* If the share context is indirect, force the new context to also be
|
||||
* indirect. If the shard context is direct but the new context
|
||||
* cannot be direct, generate BadMatch.
|
||||
*/
|
||||
if (shareglxc->isDirect && !isDirect) {
|
||||
client->errorValue = shareList;
|
||||
return BadMatch;
|
||||
#endif
|
||||
}
|
||||
else {
|
||||
else if (!shareglxc->isDirect) {
|
||||
/*
|
||||
** Create an indirect context regardless of what the client asked
|
||||
** for; this way we can share display list space with shareList.
|
||||
|
@ -276,42 +276,45 @@ DoCreateContext(__GLXclientState * cl, GLXContextID gcId,
|
|||
/*
|
||||
** Allocate memory for the new context
|
||||
*/
|
||||
if (!isDirect)
|
||||
glxc = pGlxScreen->createContext(pGlxScreen, config, shareglxc);
|
||||
if (!isDirect) {
|
||||
/* Without any attributes, the only error that the driver should be
|
||||
* able to generate is BadAlloc. As result, just drop the error
|
||||
* returned from the driver on the floor.
|
||||
*/
|
||||
glxc = pGlxScreen->createContext(pGlxScreen, config, shareglxc,
|
||||
0, NULL, &err);
|
||||
}
|
||||
else
|
||||
glxc = __glXdirectContextCreate(pGlxScreen, config, shareglxc);
|
||||
if (!glxc) {
|
||||
return BadAlloc;
|
||||
}
|
||||
|
||||
/*
|
||||
** Initially, setup the part of the context that could be used by
|
||||
** a GL core that needs windowing information (e.g., Mesa).
|
||||
/* Initialize the GLXcontext structure.
|
||||
*/
|
||||
glxc->pGlxScreen = pGlxScreen;
|
||||
glxc->config = config;
|
||||
|
||||
/*
|
||||
** Register this context as a resource.
|
||||
*/
|
||||
if (!AddResource(gcId, __glXContextRes, (pointer) glxc)) {
|
||||
(*glxc->destroy) (glxc);
|
||||
client->errorValue = gcId;
|
||||
return BadAlloc;
|
||||
}
|
||||
|
||||
/*
|
||||
** Finally, now that everything is working, setup the rest of the
|
||||
** context.
|
||||
*/
|
||||
glxc->id = gcId;
|
||||
glxc->share_id = shareList;
|
||||
glxc->idExists = GL_TRUE;
|
||||
glxc->isCurrent = GL_FALSE;
|
||||
glxc->isDirect = isDirect;
|
||||
glxc->hasUnflushedCommands = GL_FALSE;
|
||||
glxc->renderMode = GL_RENDER;
|
||||
glxc->feedbackBuf = NULL;
|
||||
glxc->feedbackBufSize = 0;
|
||||
glxc->selectBuf = NULL;
|
||||
glxc->selectBufSize = 0;
|
||||
glxc->drawPriv = NULL;
|
||||
glxc->readPriv = NULL;
|
||||
|
||||
__glXAddToContextList(glxc);
|
||||
/* Add the new context to the various global tables of GLX contexts.
|
||||
*/
|
||||
if (!__glXAddContext(glxc)) {
|
||||
(*glxc->destroy) (glxc);
|
||||
client->errorValue = gcId;
|
||||
return BadAlloc;
|
||||
}
|
||||
|
||||
return Success;
|
||||
}
|
||||
|
@ -2396,8 +2399,6 @@ __glXDisp_ClientInfo(__GLXclientState * cl, GLbyte * pc)
|
|||
if (!memchr(buf, 0, (client->req_len << 2) - sizeof(xGLXClientInfoReq)))
|
||||
return BadLength;
|
||||
|
||||
cl->GLClientmajorVersion = req->major;
|
||||
cl->GLClientminorVersion = req->minor;
|
||||
free(cl->GLClientextensions);
|
||||
cl->GLClientextensions = strdup(buf);
|
||||
|
||||
|
|
|
@ -121,4 +121,17 @@ struct __GLXcontext {
|
|||
|
||||
void __glXContextDestroy(__GLXcontext * context);
|
||||
|
||||
extern int validGlxScreen(ClientPtr client, int screen,
|
||||
__GLXscreen ** pGlxScreen, int *err);
|
||||
|
||||
extern int validGlxFBConfig(ClientPtr client, __GLXscreen * pGlxScreen,
|
||||
XID id, __GLXconfig ** config, int *err);
|
||||
|
||||
extern int validGlxContext(ClientPtr client, XID id, int access_mode,
|
||||
__GLXcontext ** context, int *err);
|
||||
|
||||
extern __GLXcontext *__glXdirectContextCreate(__GLXscreen * screen,
|
||||
__GLXconfig * modes,
|
||||
__GLXcontext * shareContext);
|
||||
|
||||
#endif /* !__GLX_context_h__ */
|
||||
|
|
12
glx/glxdri.c
12
glx/glxdri.c
|
@ -599,7 +599,10 @@ __glXDRIscreenDestroy(__GLXscreen * baseScreen)
|
|||
static __GLXcontext *
|
||||
__glXDRIscreenCreateContext(__GLXscreen * baseScreen,
|
||||
__GLXconfig * glxConfig,
|
||||
__GLXcontext * baseShareContext)
|
||||
__GLXcontext * baseShareContext,
|
||||
unsigned num_attribs,
|
||||
const uint32_t *attribs,
|
||||
int *error)
|
||||
{
|
||||
__GLXDRIscreen *screen = (__GLXDRIscreen *) baseScreen;
|
||||
__GLXDRIcontext *context, *shareContext;
|
||||
|
@ -611,6 +614,13 @@ __glXDRIscreenCreateContext(__GLXscreen * baseScreen,
|
|||
drm_context_t hwContext;
|
||||
ScreenPtr pScreen = baseScreen->pScreen;
|
||||
|
||||
/* DRI1 cannot support createContextAttribs, so these parameters will
|
||||
* never be used.
|
||||
*/
|
||||
(void) num_attribs;
|
||||
(void) attribs;
|
||||
(void) error;
|
||||
|
||||
shareContext = (__GLXDRIcontext *) baseShareContext;
|
||||
if (shareContext)
|
||||
driShare = shareContext->driContext;
|
||||
|
|
161
glx/glxdri2.c
161
glx/glxdri2.c
|
@ -47,6 +47,7 @@
|
|||
#include "glxserver.h"
|
||||
#include "glxutil.h"
|
||||
#include "glxdricommon.h"
|
||||
#include <GL/glxtokens.h>
|
||||
|
||||
#include "glapitable.h"
|
||||
#include "glapi.h"
|
||||
|
@ -377,10 +378,150 @@ __glXDRIscreenDestroy(__GLXscreen * baseScreen)
|
|||
free(screen);
|
||||
}
|
||||
|
||||
static Bool
|
||||
dri2_convert_glx_attribs(unsigned num_attribs, const uint32_t *attribs,
|
||||
unsigned *major_ver, unsigned *minor_ver,
|
||||
uint32_t *flags, unsigned *error)
|
||||
{
|
||||
unsigned i;
|
||||
|
||||
if (num_attribs == 0)
|
||||
return True;
|
||||
|
||||
if (attribs == NULL) {
|
||||
*error = BadImplementation;
|
||||
return False;
|
||||
}
|
||||
|
||||
*major_ver = 1;
|
||||
*minor_ver = 0;
|
||||
|
||||
for (i = 0; i < num_attribs; i++) {
|
||||
switch (attribs[i * 2]) {
|
||||
case GLX_CONTEXT_MAJOR_VERSION_ARB:
|
||||
*major_ver = attribs[i * 2 + 1];
|
||||
break;
|
||||
case GLX_CONTEXT_MINOR_VERSION_ARB:
|
||||
*minor_ver = attribs[i * 2 + 1];
|
||||
break;
|
||||
case GLX_CONTEXT_FLAGS_ARB:
|
||||
*flags = attribs[i * 2 + 1];
|
||||
break;
|
||||
case GLX_RENDER_TYPE:
|
||||
break;
|
||||
default:
|
||||
/* If an unknown attribute is received, fail.
|
||||
*/
|
||||
*error = BadValue;
|
||||
return False;
|
||||
}
|
||||
}
|
||||
|
||||
/* Unknown flag value.
|
||||
*/
|
||||
if (*flags & ~(__DRI_CTX_FLAG_DEBUG | __DRI_CTX_FLAG_FORWARD_COMPATIBLE)) {
|
||||
*error = BadValue;
|
||||
return False;
|
||||
}
|
||||
|
||||
*error = Success;
|
||||
return True;
|
||||
}
|
||||
|
||||
static void
|
||||
create_driver_context(__GLXDRIcontext * context,
|
||||
__GLXDRIscreen * screen,
|
||||
__GLXDRIconfig * config,
|
||||
__DRIcontext * driShare,
|
||||
unsigned num_attribs,
|
||||
const uint32_t *attribs,
|
||||
int *error)
|
||||
{
|
||||
context->driContext = NULL;
|
||||
|
||||
#if __DRI_DRI2_VERSION >= 3
|
||||
if (screen->dri2->base.version >= 3) {
|
||||
uint32_t ctx_attribs[3 * 2];
|
||||
unsigned num_ctx_attribs = 0;
|
||||
unsigned dri_err = 0;
|
||||
unsigned major_ver;
|
||||
unsigned minor_ver;
|
||||
uint32_t flags;
|
||||
|
||||
if (num_attribs != 0) {
|
||||
if (!dri2_convert_glx_attribs(num_attribs, attribs,
|
||||
&major_ver, &minor_ver,
|
||||
&flags, (unsigned *) error))
|
||||
return NULL;
|
||||
|
||||
ctx_attribs[num_ctx_attribs++] = __DRI_CTX_ATTRIB_MAJOR_VERSION;
|
||||
ctx_attribs[num_ctx_attribs++] = major_ver;
|
||||
ctx_attribs[num_ctx_attribs++] = __DRI_CTX_ATTRIB_MINOR_VERSION;
|
||||
ctx_attribs[num_ctx_attribs++] = minor_ver;
|
||||
|
||||
if (flags != 0) {
|
||||
ctx_attribs[num_ctx_attribs++] = __DRI_CTX_ATTRIB_FLAGS;
|
||||
|
||||
/* The current __DRI_CTX_FLAG_* values are identical to the
|
||||
* GLX_CONTEXT_*_BIT values.
|
||||
*/
|
||||
ctx_attribs[num_ctx_attribs++] = flags;
|
||||
}
|
||||
}
|
||||
|
||||
context->driContext =
|
||||
(*screen->dri2->createContextAttribs)(screen->driScreen,
|
||||
__DRI_API_OPENGL,
|
||||
config->driConfig,
|
||||
driShare,
|
||||
num_ctx_attribs / 2,
|
||||
ctx_attribs,
|
||||
&dri_err,
|
||||
context);
|
||||
|
||||
switch (dri_err) {
|
||||
case __DRI_CTX_ERROR_SUCCESS:
|
||||
*error = Success;
|
||||
break;
|
||||
case __DRI_CTX_ERROR_NO_MEMORY:
|
||||
*error = BadAlloc;
|
||||
break;
|
||||
case __DRI_CTX_ERROR_BAD_API:
|
||||
*error = __glXError(GLXBadProfileARB);
|
||||
break;
|
||||
case __DRI_CTX_ERROR_BAD_VERSION:
|
||||
case __DRI_CTX_ERROR_BAD_FLAG:
|
||||
*error = __glXError(GLXBadFBConfig);
|
||||
break;
|
||||
case __DRI_CTX_ERROR_UNKNOWN_ATTRIBUTE:
|
||||
case __DRI_CTX_ERROR_UNKNOWN_FLAG:
|
||||
default:
|
||||
*error = BadValue;
|
||||
break;
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
|
||||
if (num_attribs != 0) {
|
||||
*error = BadValue;
|
||||
return;
|
||||
}
|
||||
|
||||
context->driContext =
|
||||
(*screen->dri2->createNewContext) (screen->driScreen,
|
||||
config->driConfig,
|
||||
driShare, context);
|
||||
}
|
||||
|
||||
static __GLXcontext *
|
||||
__glXDRIscreenCreateContext(__GLXscreen * baseScreen,
|
||||
__GLXconfig * glxConfig,
|
||||
__GLXcontext * baseShareContext)
|
||||
__GLXcontext * baseShareContext,
|
||||
unsigned num_attribs,
|
||||
const uint32_t *attribs,
|
||||
int *error)
|
||||
{
|
||||
__GLXDRIscreen *screen = (__GLXDRIscreen *) baseScreen;
|
||||
__GLXDRIcontext *context, *shareContext;
|
||||
|
@ -394,8 +535,10 @@ __glXDRIscreenCreateContext(__GLXscreen * baseScreen,
|
|||
driShare = NULL;
|
||||
|
||||
context = calloc(1, sizeof *context);
|
||||
if (context == NULL)
|
||||
if (context == NULL) {
|
||||
*error = BadAlloc;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
context->base.destroy = __glXDRIcontextDestroy;
|
||||
context->base.makeCurrent = __glXDRIcontextMakeCurrent;
|
||||
|
@ -404,10 +547,8 @@ __glXDRIscreenCreateContext(__GLXscreen * baseScreen,
|
|||
context->base.textureFromPixmap = &__glXDRItextureFromPixmap;
|
||||
context->base.wait = __glXDRIcontextWait;
|
||||
|
||||
context->driContext =
|
||||
(*screen->dri2->createNewContext) (screen->driScreen,
|
||||
config->driConfig,
|
||||
driShare, context);
|
||||
create_driver_context(context, screen, config, driShare, num_attribs,
|
||||
attribs, error);
|
||||
if (context->driContext == NULL) {
|
||||
free(context);
|
||||
return NULL;
|
||||
|
@ -641,6 +782,14 @@ initializeExtensions(__GLXDRIscreen * screen)
|
|||
__glXEnableExtension(screen->glx_enable_bits, "GLX_INTEL_swap_event");
|
||||
LogMessage(X_INFO, "AIGLX: enabled GLX_INTEL_swap_event\n");
|
||||
|
||||
#if __DRI_DRI2_VERSION >= 3
|
||||
if (screen->dri2->base.version >= 3) {
|
||||
__glXEnableExtension(screen->glx_enable_bits,
|
||||
"GLX_ARB_create_context");
|
||||
LogMessage(X_INFO, "AIGLX: enabled GLX_ARB_create_context\n");
|
||||
}
|
||||
#endif
|
||||
|
||||
if (DRI2HasSwapControl(pScreen)) {
|
||||
__glXEnableExtension(screen->glx_enable_bits, "GLX_SGI_swap_control");
|
||||
__glXEnableExtension(screen->glx_enable_bits, "GLX_MESA_swap_control");
|
||||
|
|
|
@ -257,7 +257,10 @@ __glXDRIscreenDestroy(__GLXscreen * baseScreen)
|
|||
static __GLXcontext *
|
||||
__glXDRIscreenCreateContext(__GLXscreen * baseScreen,
|
||||
__GLXconfig * glxConfig,
|
||||
__GLXcontext * baseShareContext)
|
||||
__GLXcontext * baseShareContext,
|
||||
unsigned num_attribs,
|
||||
const uint32_t *attribs,
|
||||
int *error)
|
||||
{
|
||||
__GLXDRIscreen *screen = (__GLXDRIscreen *) baseScreen;
|
||||
__GLXDRIcontext *context, *shareContext;
|
||||
|
@ -265,6 +268,13 @@ __glXDRIscreenCreateContext(__GLXscreen * baseScreen,
|
|||
const __DRIcoreExtension *core = screen->core;
|
||||
__DRIcontext *driShare;
|
||||
|
||||
/* DRISWRAST won't support createContextAttribs, so these parameters will
|
||||
* never be used.
|
||||
*/
|
||||
(void) num_attribs;
|
||||
(void) attribs;
|
||||
(void) error;
|
||||
|
||||
shareContext = (__GLXDRIcontext *) baseShareContext;
|
||||
if (shareContext)
|
||||
driShare = shareContext->driContext;
|
||||
|
|
13
glx/glxext.c
13
glx/glxext.c
|
@ -157,11 +157,18 @@ DrawableGone(__GLXdrawable * glxPriv, XID xid)
|
|||
return True;
|
||||
}
|
||||
|
||||
void
|
||||
__glXAddToContextList(__GLXcontext * cx)
|
||||
Bool
|
||||
__glXAddContext(__GLXcontext * cx)
|
||||
{
|
||||
/* Register this context as a resource.
|
||||
*/
|
||||
if (!AddResource(cx->id, __glXContextRes, (pointer)cx)) {
|
||||
return False;
|
||||
}
|
||||
|
||||
cx->next = glxAllContexts;
|
||||
glxAllContexts = cx;
|
||||
return True;
|
||||
}
|
||||
|
||||
static void
|
||||
|
@ -281,8 +288,6 @@ glxClientCallback(CallbackListPtr *list, pointer closure, pointer data)
|
|||
** By default, assume that the client supports
|
||||
** GLX major version 1 minor version 0 protocol.
|
||||
*/
|
||||
cl->GLClientmajorVersion = 1;
|
||||
cl->GLClientminorVersion = 0;
|
||||
cl->client = pClient;
|
||||
break;
|
||||
|
||||
|
|
|
@ -38,7 +38,7 @@
|
|||
extern GLboolean __glXFreeContext(__GLXcontext * glxc);
|
||||
extern void __glXFlushContextCache(void);
|
||||
|
||||
extern void __glXAddToContextList(__GLXcontext * cx);
|
||||
extern Bool __glXAddContext(__GLXcontext * cx);
|
||||
extern void __glXErrorCallBack(GLenum code);
|
||||
extern void __glXClearErrorOccured(void);
|
||||
extern GLboolean __glXErrorOccured(void);
|
||||
|
|
|
@ -117,7 +117,10 @@ struct __GLXscreen {
|
|||
|
||||
__GLXcontext *(*createContext) (__GLXscreen * screen,
|
||||
__GLXconfig * modes,
|
||||
__GLXcontext * shareContext);
|
||||
__GLXcontext * shareContext,
|
||||
unsigned num_attribs,
|
||||
const uint32_t *attribs,
|
||||
int *error);
|
||||
|
||||
__GLXdrawable *(*createDrawable) (ClientPtr client,
|
||||
__GLXscreen * context,
|
||||
|
|
|
@ -145,8 +145,6 @@ struct __GLXclientStateRec {
|
|||
/* Back pointer to X client record */
|
||||
ClientPtr client;
|
||||
|
||||
int GLClientmajorVersion;
|
||||
int GLClientminorVersion;
|
||||
char *GLClientextensions;
|
||||
};
|
||||
|
||||
|
|
Loading…
Reference in New Issue
Block a user