Merge branch 'master' into glyph-pixmaps
Conflicts: configure.ac
This commit is contained in:
commit
a3a95d3475
|
@ -53,7 +53,6 @@ libglx_la_SOURCES = \
|
|||
glxserver.h \
|
||||
glxutil.c \
|
||||
glxutil.h \
|
||||
glxvisuals.c \
|
||||
indirect_dispatch.c \
|
||||
indirect_dispatch.h \
|
||||
indirect_dispatch_swap.c \
|
||||
|
|
|
@ -34,7 +34,6 @@
|
|||
** version 1.2.1 Specification.
|
||||
*/
|
||||
|
||||
extern int __glXDisp_GetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
extern int __glXDisp_BindSwapBarrierSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
extern int __glXDisp_QueryMaxSwapBarriersSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
extern int __glXDisp_QueryHyperpipeNetworkSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
|
@ -42,7 +41,6 @@ extern int __glXDisp_DestroyHyperpipeConfigSGIX (__GLXclientState *cl, GLbyte *p
|
|||
extern int __glXDisp_QueryHyperpipeConfigSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
extern int __glXDisp_HyperpipeConfigSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
|
||||
extern int __glXDispSwap_GetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
extern int __glXDispSwap_BindSwapBarrierSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
extern int __glXDispSwap_QueryMaxSwapBarriersSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
extern int __glXDispSwap_QueryHyperpipeNetworkSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
|
|
1115
GL/glx/glxcmds.c
1115
GL/glx/glxcmds.c
File diff suppressed because it is too large
Load Diff
|
@ -77,8 +77,7 @@ int __glXDispSwap_CreateContext(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_SWAP_INT(&req->screen);
|
||||
__GLX_SWAP_INT(&req->shareList);
|
||||
|
||||
return DoCreateContext( cl, req->context, req->shareList, req->visual,
|
||||
req->screen, req->isDirect );
|
||||
return __glXDisp_CreateContext(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_CreateNewContext(__GLXclientState *cl, GLbyte *pc)
|
||||
|
@ -93,8 +92,7 @@ int __glXDispSwap_CreateNewContext(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_SWAP_INT(&req->renderType);
|
||||
__GLX_SWAP_INT(&req->shareList);
|
||||
|
||||
return DoCreateContext( cl, req->context, req->shareList, req->fbconfig,
|
||||
req->screen, req->isDirect );
|
||||
return __glXDisp_CreateNewContext(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_CreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
|
||||
|
@ -110,8 +108,7 @@ int __glXDispSwap_CreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_SWAP_INT(&req->renderType);
|
||||
__GLX_SWAP_INT(&req->shareList);
|
||||
|
||||
return DoCreateContext( cl, req->context, req->shareList, req->fbconfig,
|
||||
req->screen, req->isDirect );
|
||||
return __glXDisp_CreateContextWithConfigSGIX(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_DestroyContext(__GLXclientState *cl, GLbyte *pc)
|
||||
|
@ -135,8 +132,7 @@ int __glXDispSwap_MakeCurrent(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_SWAP_INT(&req->context);
|
||||
__GLX_SWAP_INT(&req->oldContextTag);
|
||||
|
||||
return DoMakeCurrent( cl, req->drawable, req->drawable,
|
||||
req->context, req->oldContextTag );
|
||||
return __glXDisp_MakeCurrent(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_MakeContextCurrent(__GLXclientState *cl, GLbyte *pc)
|
||||
|
@ -150,8 +146,7 @@ int __glXDispSwap_MakeContextCurrent(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_SWAP_INT(&req->context);
|
||||
__GLX_SWAP_INT(&req->oldContextTag);
|
||||
|
||||
return DoMakeCurrent( cl, req->drawable, req->readdrawable,
|
||||
req->context, req->oldContextTag );
|
||||
return __glXDisp_MakeContextCurrent(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_MakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc)
|
||||
|
@ -165,8 +160,7 @@ int __glXDispSwap_MakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_SWAP_INT(&req->context);
|
||||
__GLX_SWAP_INT(&req->oldContextTag);
|
||||
|
||||
return DoMakeCurrent( cl, req->drawable, req->readable,
|
||||
req->context, req->oldContextTag );
|
||||
return __glXDisp_MakeCurrentReadSGI(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_IsDirect(__GLXclientState *cl, GLbyte *pc)
|
||||
|
@ -233,7 +227,7 @@ int __glXDispSwap_GetVisualConfigs(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
||||
__GLX_SWAP_INT(&req->screen);
|
||||
return DoGetVisualConfigs( cl, req->screen, GL_TRUE );
|
||||
return __glXDisp_GetVisualConfigs(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_GetFBConfigs(__GLXclientState *cl, GLbyte *pc)
|
||||
|
@ -242,7 +236,7 @@ int __glXDispSwap_GetFBConfigs(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
||||
__GLX_SWAP_INT(&req->screen);
|
||||
return DoGetFBConfigs( cl, req->screen, GL_TRUE );
|
||||
return __glXDisp_GetFBConfigs(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_GetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc)
|
||||
|
@ -251,7 +245,7 @@ int __glXDispSwap_GetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
||||
__GLX_SWAP_INT(&req->screen);
|
||||
return DoGetFBConfigs( cl, req->screen, GL_TRUE );
|
||||
return __glXDisp_GetFBConfigsSGIX(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_CreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
|
||||
|
@ -265,14 +259,15 @@ int __glXDispSwap_CreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_SWAP_INT(&req->pixmap);
|
||||
__GLX_SWAP_INT(&req->glxpixmap);
|
||||
|
||||
return DoCreateGLXPixmap( cl, req->visual, req->screen,
|
||||
req->pixmap, req->glxpixmap, NULL, 0 );
|
||||
return __glXDisp_CreateGLXPixmap(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_CreatePixmap(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXCreatePixmapReq *req = (xGLXCreatePixmapReq *) pc;
|
||||
CARD32 *attribs;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
|
||||
|
||||
__GLX_SWAP_SHORT(&req->length);
|
||||
__GLX_SWAP_INT(&req->screen);
|
||||
|
@ -280,11 +275,10 @@ int __glXDispSwap_CreatePixmap(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_SWAP_INT(&req->pixmap);
|
||||
__GLX_SWAP_INT(&req->glxpixmap);
|
||||
__GLX_SWAP_INT(&req->numAttribs);
|
||||
attribs = (CARD32*)(req + 1);
|
||||
__GLX_SWAP_INT_ARRAY(attribs, req->numAttribs);
|
||||
|
||||
return DoCreateGLXPixmap( cl, req->fbconfig, req->screen,
|
||||
req->pixmap, req->glxpixmap,
|
||||
(CARD32*)(req + 1),
|
||||
req->numAttribs );
|
||||
return __glXDisp_CreatePixmap(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_CreateGLXPixmapWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
|
||||
|
@ -299,8 +293,7 @@ int __glXDispSwap_CreateGLXPixmapWithConfigSGIX(__GLXclientState *cl, GLbyte *pc
|
|||
__GLX_SWAP_INT(&req->pixmap);
|
||||
__GLX_SWAP_INT(&req->glxpixmap);
|
||||
|
||||
return DoCreateGLXPixmap( cl, req->fbconfig, req->screen,
|
||||
req->pixmap, req->glxpixmap, NULL, 0 );
|
||||
return __glXDisp_CreateGLXPixmapWithConfigSGIX(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_DestroyGLXPixmap(__GLXclientState *cl, GLbyte *pc)
|
||||
|
@ -328,52 +321,123 @@ int __glXDispSwap_DestroyPixmap(__GLXclientState *cl, GLbyte *pc)
|
|||
int __glXDispSwap_QueryContext(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXQueryContextReq *req = (xGLXQueryContextReq *) pc;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
||||
(void) req;
|
||||
__GLX_SWAP_INT(&req->context);
|
||||
|
||||
return BadRequest;
|
||||
return __glXDisp_QueryContext(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_CreatePbuffer(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXCreatePbufferReq *req = (xGLXCreatePbufferReq *) pc;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
|
||||
CARD32 *attribs;
|
||||
|
||||
(void) req;
|
||||
__GLX_SWAP_INT(&req->screen);
|
||||
__GLX_SWAP_INT(&req->fbconfig);
|
||||
__GLX_SWAP_INT(&req->pbuffer);
|
||||
__GLX_SWAP_INT(&req->numAttribs);
|
||||
attribs = (CARD32*)(req + 1);
|
||||
__GLX_SWAP_INT_ARRAY(attribs, req->numAttribs);
|
||||
|
||||
return BadRequest;
|
||||
return __glXDisp_CreatePbuffer(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_CreateGLXPbufferSGIX(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXCreateGLXPbufferSGIXReq *req = (xGLXCreateGLXPbufferSGIXReq *) pc;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
||||
__GLX_SWAP_INT(&req->screen);
|
||||
__GLX_SWAP_INT(&req->fbconfig);
|
||||
__GLX_SWAP_INT(&req->pbuffer);
|
||||
__GLX_SWAP_INT(&req->width);
|
||||
__GLX_SWAP_INT(&req->height);
|
||||
|
||||
return __glXDisp_CreateGLXPbufferSGIX(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_DestroyPbuffer(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXDestroyPbufferReq *req = (xGLXDestroyPbufferReq *) req;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
||||
return BadRequest;
|
||||
__GLX_SWAP_INT(&req->pbuffer);
|
||||
|
||||
return __glXDisp_DestroyPbuffer(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_DestroyGLXPbufferSGIX(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXDestroyGLXPbufferSGIXReq *req = (xGLXDestroyGLXPbufferSGIXReq *) req;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
||||
__GLX_SWAP_INT(&req->pbuffer);
|
||||
|
||||
return __glXDisp_DestroyGLXPbufferSGIX(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_ChangeDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXChangeDrawableAttributesReq *req =
|
||||
(xGLXChangeDrawableAttributesReq *) req;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
|
||||
CARD32 *attribs;
|
||||
|
||||
return BadRequest;
|
||||
__GLX_SWAP_INT(&req->drawable);
|
||||
__GLX_SWAP_INT(&req->numAttribs);
|
||||
attribs = (CARD32*)(req + 1);
|
||||
__GLX_SWAP_INT_ARRAY(attribs, req->numAttribs);
|
||||
|
||||
return __glXDisp_ChangeDrawableAttributes(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_ChangeDrawableAttributesSGIX(__GLXclientState *cl,
|
||||
GLbyte *pc)
|
||||
{
|
||||
xGLXChangeDrawableAttributesSGIXReq *req =
|
||||
(xGLXChangeDrawableAttributesSGIXReq *) req;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
|
||||
CARD32 *attribs;
|
||||
|
||||
__GLX_SWAP_INT(&req->drawable);
|
||||
__GLX_SWAP_INT(&req->numAttribs);
|
||||
attribs = (CARD32*)(req + 1);
|
||||
__GLX_SWAP_INT_ARRAY(attribs, req->numAttribs);
|
||||
|
||||
return __glXDisp_ChangeDrawableAttributesSGIX(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_CreateWindow(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXCreateWindowReq *req = (xGLXCreateWindowReq *) pc;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
|
||||
CARD32 *attribs;
|
||||
|
||||
(void) req;
|
||||
__GLX_SWAP_INT(&req->screen);
|
||||
__GLX_SWAP_INT(&req->fbconfig);
|
||||
__GLX_SWAP_INT(&req->window);
|
||||
__GLX_SWAP_INT(&req->glxwindow);
|
||||
__GLX_SWAP_INT(&req->numAttribs);
|
||||
attribs = (CARD32*)(req + 1);
|
||||
__GLX_SWAP_INT_ARRAY(attribs, req->numAttribs);
|
||||
|
||||
return BadRequest;
|
||||
return __glXDisp_CreateWindow(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_DestroyWindow(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXDestroyWindowReq *req = (xGLXDestroyWindowReq *) pc;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
||||
(void) req;
|
||||
__GLX_SWAP_INT(&req->glxwindow);
|
||||
|
||||
return BadRequest;
|
||||
return __glXDisp_DestroyWindow(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_SwapBuffers(__GLXclientState *cl, GLbyte *pc)
|
||||
|
@ -643,7 +707,7 @@ void __glXSwapGetDrawableAttributesReply(ClientPtr client,
|
|||
|
||||
int __glXDispSwap_Render(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
return DoRender(cl, pc, True);
|
||||
return __glXDisp_Render(cl, pc);
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -651,7 +715,7 @@ int __glXDispSwap_Render(__GLXclientState *cl, GLbyte *pc)
|
|||
*/
|
||||
int __glXDispSwap_RenderLarge(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
return DoRenderLarge(cl, pc, True);
|
||||
return __glXDisp_RenderLarge(cl, pc);
|
||||
}
|
||||
|
||||
/************************************************************************/
|
||||
|
|
|
@ -46,10 +46,10 @@ typedef struct __GLXtextureFromPixmap __GLXtextureFromPixmap;
|
|||
struct __GLXtextureFromPixmap {
|
||||
int (*bindTexImage) (__GLXcontext *baseContext,
|
||||
int buffer,
|
||||
__GLXpixmap *pixmap);
|
||||
__GLXdrawable *pixmap);
|
||||
int (*releaseTexImage) (__GLXcontext *baseContext,
|
||||
int buffer,
|
||||
__GLXpixmap *pixmap);
|
||||
__GLXdrawable *pixmap);
|
||||
};
|
||||
|
||||
|
||||
|
@ -151,12 +151,6 @@ struct __GLXcontext {
|
|||
GLuint *selectBuf;
|
||||
GLint selectBufSize; /* number of elements allocated */
|
||||
|
||||
/*
|
||||
** Set only if current drawable is a glx pixmap.
|
||||
*/
|
||||
__GLXpixmap *drawPixmap;
|
||||
__GLXpixmap *readPixmap;
|
||||
|
||||
/*
|
||||
** The drawable private this context is bound to
|
||||
*/
|
||||
|
|
|
@ -42,26 +42,12 @@
|
|||
|
||||
#include <damage.h>
|
||||
|
||||
#ifdef XF86DRI
|
||||
#include <GL/internal/dri_interface.h>
|
||||
#endif
|
||||
|
||||
typedef struct {
|
||||
|
||||
DrawablePtr pDraw;
|
||||
__GLcontextModes *modes;
|
||||
__GLXscreen *pGlxScreen;
|
||||
ScreenPtr pScreen;
|
||||
Bool idExists;
|
||||
int refcnt;
|
||||
GLenum target;
|
||||
#ifdef XF86DRI
|
||||
DamagePtr pDamage;
|
||||
__DRIcontext *pDRICtx;
|
||||
GLint texname;
|
||||
unsigned long offset;
|
||||
#endif
|
||||
} __GLXpixmap;
|
||||
/* We just need to avoid clashing with DRAWABLE_{WINDOW,PIXMAP} */
|
||||
enum {
|
||||
GLX_DRAWABLE_WINDOW,
|
||||
GLX_DRAWABLE_PIXMAP,
|
||||
GLX_DRAWABLE_PBUFFER
|
||||
};
|
||||
|
||||
struct __GLXdrawable {
|
||||
void (*destroy)(__GLXdrawable *private);
|
||||
|
@ -78,12 +64,10 @@ struct __GLXdrawable {
|
|||
|
||||
DrawablePtr pDraw;
|
||||
XID drawId;
|
||||
__GLXpixmap *pGlxPixmap;
|
||||
|
||||
/*
|
||||
** Either DRAWABLE_PIXMAP or DRAWABLE_WINDOW, copied from pDraw above.
|
||||
** Needed by the resource freer because pDraw might already have been
|
||||
** freed.
|
||||
** Either GLX_DRAWABLE_PIXMAP, GLX_DRAWABLE_WINDOW or
|
||||
** GLX_DRAWABLE_PBUFFER.
|
||||
*/
|
||||
int type;
|
||||
|
||||
|
@ -105,6 +89,13 @@ struct __GLXdrawable {
|
|||
** reference count
|
||||
*/
|
||||
int refCount;
|
||||
|
||||
GLenum target;
|
||||
|
||||
/*
|
||||
** Event mask
|
||||
*/
|
||||
unsigned long eventMask;
|
||||
};
|
||||
|
||||
#endif /* !__GLX_drawable_h__ */
|
||||
|
|
580
GL/glx/glxdri.c
580
GL/glx/glxdri.c
|
@ -59,9 +59,8 @@
|
|||
#include "dispatch.h"
|
||||
#include "extension_string.h"
|
||||
|
||||
|
||||
#define STRINGIFY(macro_or_string) STRINGIFY_ARG (macro_or_string)
|
||||
#define STRINGIFY_ARG(contents) #contents
|
||||
#define containerOf(ptr, type, member) \
|
||||
(type *)( (char *)ptr - offsetof(type,member) )
|
||||
|
||||
typedef struct __GLXDRIscreen __GLXDRIscreen;
|
||||
typedef struct __GLXDRIcontext __GLXDRIcontext;
|
||||
|
@ -69,67 +68,46 @@ typedef struct __GLXDRIdrawable __GLXDRIdrawable;
|
|||
|
||||
struct __GLXDRIscreen {
|
||||
__GLXscreen base;
|
||||
|
||||
__DRIscreen driScreen;
|
||||
void *driver;
|
||||
|
||||
xf86EnterVTProc *enterVT;
|
||||
xf86LeaveVTProc *leaveVT;
|
||||
|
||||
__DRIcopySubBufferExtension *copySubBuffer;
|
||||
__DRIswapControlExtension *swapControl;
|
||||
|
||||
#ifdef __DRI_TEX_OFFSET
|
||||
__DRItexOffsetExtension *texOffset;
|
||||
DRITexOffsetStartProcPtr texOffsetStart;
|
||||
DRITexOffsetFinishProcPtr texOffsetFinish;
|
||||
__GLXpixmap* texOffsetOverride[16];
|
||||
__GLXDRIdrawable *texOffsetOverride[16];
|
||||
GLuint lastTexOffsetOverride;
|
||||
#endif
|
||||
|
||||
unsigned char glx_enable_bits[__GLX_EXT_BYTES];
|
||||
};
|
||||
|
||||
struct __GLXDRIcontext {
|
||||
__GLXcontext base;
|
||||
|
||||
__DRIcontext driContext;
|
||||
XID hwContextID;
|
||||
};
|
||||
|
||||
struct __GLXDRIdrawable {
|
||||
__GLXdrawable base;
|
||||
__DRIdrawable driDrawable;
|
||||
|
||||
__DRIdrawable *driDrawable;
|
||||
/* Pulled in from old __GLXpixmap */
|
||||
#ifdef __DRI_TEX_OFFSET
|
||||
GLint texname;
|
||||
__GLXDRIcontext *ctx;
|
||||
unsigned long offset;
|
||||
DamagePtr pDamage;
|
||||
#endif
|
||||
};
|
||||
|
||||
/* History:
|
||||
* 20021121 - Initial version
|
||||
* 20021128 - Added __glXWindowExists() function
|
||||
* 20021207 - Added support for dynamic GLX extensions,
|
||||
* GLX_SGI_swap_control, GLX_SGI_video_sync,
|
||||
* GLX_OML_sync_control, and GLX_MESA_swap_control.
|
||||
* Never officially released. Do NOT test against
|
||||
* this version. Use 20030317 instead.
|
||||
* 20030317 - Added support GLX_SGIX_fbconfig,
|
||||
* GLX_MESA_swap_frame_usage, GLX_OML_swap_method,
|
||||
* GLX_{ARB,SGIS}_multisample, and
|
||||
* GLX_SGIX_visual_select_group.
|
||||
* 20030606 - Added support for GLX_SGI_make_current_read.
|
||||
* 20030813 - Made support for dynamic extensions multi-head aware.
|
||||
* 20030818 - Added support for GLX_MESA_allocate_memory in place of the
|
||||
* deprecated GLX_NV_vertex_array_range & GLX_MESA_agp_offset
|
||||
* interfaces.
|
||||
* 20031201 - Added support for the first round of DRI interface changes.
|
||||
* Do NOT test against this version! It has binary
|
||||
* compatibility bugs, use 20040317 instead.
|
||||
* 20040317 - Added the 'mode' field to __DRIcontextRec.
|
||||
* 20040415 - Added support for bindContext3 and unbindContext3.
|
||||
* 20040602 - Add __glXGetDrawableInfo. I though that was there
|
||||
* months ago. :(
|
||||
* 20050727 - Gut all the old interfaces. This breaks compatability with
|
||||
* any DRI driver built to any previous version.
|
||||
* 20060314 - Added support for GLX_MESA_copy_sub_buffer.
|
||||
*/
|
||||
|
||||
#define INTERNAL_VERSION 20050727
|
||||
|
||||
static const char CREATE_NEW_SCREEN_FUNC[] =
|
||||
"__driCreateNewScreen_" STRINGIFY (INTERNAL_VERSION);
|
||||
|
||||
static const char CREATE_NEW_SCREEN_FUNC[] = __DRI_CREATE_NEW_SCREEN_STRING;
|
||||
|
||||
static void
|
||||
__glXDRIleaveServer(GLboolean rendering)
|
||||
|
@ -138,19 +116,19 @@ __glXDRIleaveServer(GLboolean rendering)
|
|||
|
||||
for (i = 0; rendering && i < screenInfo.numScreens; i++) {
|
||||
__GLXDRIscreen * const screen =
|
||||
(__GLXDRIscreen *) __glXgetActiveScreen(i);
|
||||
(__GLXDRIscreen *) glxGetScreen(screenInfo.screens[i]);
|
||||
GLuint lastOverride = screen->lastTexOffsetOverride;
|
||||
|
||||
if (lastOverride) {
|
||||
__GLXpixmap **texOffsetOverride = screen->texOffsetOverride;
|
||||
__GLXDRIdrawable **texOffsetOverride = screen->texOffsetOverride;
|
||||
int j;
|
||||
|
||||
for (j = 0; j < lastOverride; j++) {
|
||||
__GLXpixmap *pGlxPix = texOffsetOverride[j];
|
||||
__GLXDRIdrawable *pGlxPix = texOffsetOverride[j];
|
||||
|
||||
if (pGlxPix && pGlxPix->texname) {
|
||||
pGlxPix->offset =
|
||||
screen->texOffsetStart((PixmapPtr)pGlxPix->pDraw);
|
||||
screen->texOffsetStart((PixmapPtr)pGlxPix->base.pDraw);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -160,23 +138,22 @@ __glXDRIleaveServer(GLboolean rendering)
|
|||
|
||||
for (i = 0; rendering && i < screenInfo.numScreens; i++) {
|
||||
__GLXDRIscreen * const screen =
|
||||
(__GLXDRIscreen *) __glXgetActiveScreen(i);
|
||||
(__GLXDRIscreen *) glxGetScreen(screenInfo.screens[i]);
|
||||
GLuint lastOverride = screen->lastTexOffsetOverride;
|
||||
|
||||
if (lastOverride) {
|
||||
__GLXpixmap **texOffsetOverride = screen->texOffsetOverride;
|
||||
__GLXDRIdrawable **texOffsetOverride = screen->texOffsetOverride;
|
||||
int j;
|
||||
|
||||
for (j = 0; j < lastOverride; j++) {
|
||||
__GLXpixmap *pGlxPix = texOffsetOverride[j];
|
||||
__GLXDRIdrawable *pGlxPix = texOffsetOverride[j];
|
||||
|
||||
if (pGlxPix && pGlxPix->texname) {
|
||||
screen->driScreen.setTexOffset(pGlxPix->pDRICtx,
|
||||
screen->texOffset->setTexOffset(&pGlxPix->ctx->driContext,
|
||||
pGlxPix->texname,
|
||||
pGlxPix->offset,
|
||||
pGlxPix->pDraw->depth,
|
||||
((PixmapPtr)pGlxPix->pDraw)->
|
||||
devKind);
|
||||
pGlxPix->base.pDraw->depth,
|
||||
((PixmapPtr)pGlxPix->base.pDraw)->devKind);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -189,8 +166,8 @@ __glXDRIenterServer(GLboolean rendering)
|
|||
int i;
|
||||
|
||||
for (i = 0; rendering && i < screenInfo.numScreens; i++) {
|
||||
__GLXDRIscreen * const screen =
|
||||
(__GLXDRIscreen *) __glXgetActiveScreen(i);
|
||||
__GLXDRIscreen * const screen = (__GLXDRIscreen *)
|
||||
glxGetScreen(screenInfo.screens[i]);
|
||||
|
||||
if (screen->lastTexOffsetOverride) {
|
||||
CALL_Flush(GET_DISPATCH(), ());
|
||||
|
@ -201,29 +178,17 @@ __glXDRIenterServer(GLboolean rendering)
|
|||
DRIWakeupHandler(NULL, 0, NULL);
|
||||
}
|
||||
|
||||
/**
|
||||
* \bug
|
||||
* We're jumping through hoops here to get the DRIdrawable which the DRI
|
||||
* driver tries to keep to it self... cf. FIXME in \c createDrawable.
|
||||
*/
|
||||
static void
|
||||
__glXDRIdrawableFoo(__GLXDRIdrawable *draw)
|
||||
__glXDRIdrawableDestroy(__GLXdrawable *drawable)
|
||||
{
|
||||
__GLXDRIscreen * const screen =
|
||||
(__GLXDRIscreen *) __glXgetActiveScreen(draw->base.pDraw->pScreen->myNum);
|
||||
__GLXDRIdrawable *private = (__GLXDRIdrawable *) drawable;
|
||||
|
||||
draw->driDrawable = (*screen->driScreen.getDrawable)(NULL,
|
||||
draw->base.drawId,
|
||||
screen->driScreen.private);
|
||||
}
|
||||
(*private->driDrawable.destroyDrawable)(&private->driDrawable);
|
||||
|
||||
static void
|
||||
__glXDRIdrawableDestroy(__GLXdrawable *private)
|
||||
{
|
||||
#if 0
|
||||
(*glxPriv->driDrawable.destroyDrawable)(NULL,
|
||||
glxPriv->driDrawable.private);
|
||||
#endif
|
||||
__glXenterServer(GL_FALSE);
|
||||
DRIDestroyDrawable(drawable->pDraw->pScreen,
|
||||
serverClient, drawable->pDraw);
|
||||
__glXleaveServer(GL_FALSE);
|
||||
|
||||
xfree(private);
|
||||
}
|
||||
|
@ -242,10 +207,7 @@ __glXDRIdrawableSwapBuffers(__GLXdrawable *basePrivate)
|
|||
{
|
||||
__GLXDRIdrawable *private = (__GLXDRIdrawable *) basePrivate;
|
||||
|
||||
__glXDRIdrawableFoo(private);
|
||||
|
||||
(*private->driDrawable->swapBuffers)(NULL,
|
||||
private->driDrawable->private);
|
||||
(*private->driDrawable.swapBuffers)(&private->driDrawable);
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
@ -255,10 +217,12 @@ static int
|
|||
__glXDRIdrawableSwapInterval(__GLXdrawable *baseDrawable, int interval)
|
||||
{
|
||||
__GLXDRIdrawable *draw = (__GLXDRIdrawable *) baseDrawable;
|
||||
__GLXDRIscreen *screen = (__GLXDRIscreen *)
|
||||
glxGetScreen(baseDrawable->pDraw->pScreen);
|
||||
|
||||
__glXDRIdrawableFoo(draw);
|
||||
if (screen->swapControl)
|
||||
screen->swapControl->setSwapInterval(&draw->driDrawable, interval);
|
||||
|
||||
draw->driDrawable->swap_interval = interval;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -268,11 +232,11 @@ __glXDRIdrawableCopySubBuffer(__GLXdrawable *basePrivate,
|
|||
int x, int y, int w, int h)
|
||||
{
|
||||
__GLXDRIdrawable *private = (__GLXDRIdrawable *) basePrivate;
|
||||
__GLXDRIscreen *screen = (__GLXDRIscreen *)
|
||||
glxGetScreen(basePrivate->pDraw->pScreen);
|
||||
|
||||
__glXDRIdrawableFoo(private);
|
||||
|
||||
(*private->driDrawable->copySubBuffer)(NULL,
|
||||
private->driDrawable->private,
|
||||
if (screen->copySubBuffer)
|
||||
screen->copySubBuffer->copySubBuffer(&private->driDrawable,
|
||||
x, y, w, h);
|
||||
}
|
||||
|
||||
|
@ -280,10 +244,14 @@ static void
|
|||
__glXDRIcontextDestroy(__GLXcontext *baseContext)
|
||||
{
|
||||
__GLXDRIcontext *context = (__GLXDRIcontext *) baseContext;
|
||||
Bool retval;
|
||||
|
||||
context->driContext.destroyContext(&context->driContext);
|
||||
|
||||
__glXenterServer(GL_FALSE);
|
||||
retval = DRIDestroyContext(baseContext->pScreen, context->hwContextID);
|
||||
__glXleaveServer(GL_FALSE);
|
||||
|
||||
context->driContext.destroyContext(NULL,
|
||||
context->base.pScreen->myNum,
|
||||
context->driContext.private);
|
||||
__glXContextDestroy(&context->base);
|
||||
xfree(context);
|
||||
}
|
||||
|
@ -292,12 +260,12 @@ static int
|
|||
__glXDRIcontextMakeCurrent(__GLXcontext *baseContext)
|
||||
{
|
||||
__GLXDRIcontext *context = (__GLXDRIcontext *) baseContext;
|
||||
__GLXDRIdrawable *draw = (__GLXDRIdrawable *) baseContext->drawPriv;
|
||||
__GLXDRIdrawable *read = (__GLXDRIdrawable *) baseContext->readPriv;
|
||||
|
||||
return (*context->driContext.bindContext)(NULL,
|
||||
context->base.pScreen->myNum,
|
||||
baseContext->drawPriv->drawId,
|
||||
baseContext->readPriv->drawId,
|
||||
&context->driContext);
|
||||
return (*context->driContext.bindContext)(&context->driContext,
|
||||
&draw->driDrawable,
|
||||
&read->driDrawable);
|
||||
}
|
||||
|
||||
static int
|
||||
|
@ -305,11 +273,7 @@ __glXDRIcontextLoseCurrent(__GLXcontext *baseContext)
|
|||
{
|
||||
__GLXDRIcontext *context = (__GLXDRIcontext *) baseContext;
|
||||
|
||||
return (*context->driContext.unbindContext)(NULL,
|
||||
context->base.pScreen->myNum,
|
||||
baseContext->drawPriv->drawId,
|
||||
baseContext->readPriv->drawId,
|
||||
&context->driContext);
|
||||
return (*context->driContext.unbindContext)(&context->driContext);
|
||||
}
|
||||
|
||||
static int
|
||||
|
@ -331,12 +295,12 @@ static int
|
|||
__glXDRIcontextForceCurrent(__GLXcontext *baseContext)
|
||||
{
|
||||
__GLXDRIcontext *context = (__GLXDRIcontext *) baseContext;
|
||||
__GLXDRIdrawable *draw = (__GLXDRIdrawable *) baseContext->drawPriv;
|
||||
__GLXDRIdrawable *read = (__GLXDRIdrawable *) baseContext->readPriv;
|
||||
|
||||
return (*context->driContext.bindContext)(NULL,
|
||||
context->base.pScreen->myNum,
|
||||
baseContext->drawPriv->drawId,
|
||||
baseContext->readPriv->drawId,
|
||||
&context->driContext);
|
||||
return (*context->driContext.bindContext)(&context->driContext,
|
||||
&draw->driDrawable,
|
||||
&read->driDrawable);
|
||||
}
|
||||
|
||||
static void
|
||||
|
@ -370,15 +334,17 @@ glxFillAlphaChannel (PixmapPtr pixmap, int x, int y, int width, int height)
|
|||
static int
|
||||
__glXDRIbindTexImage(__GLXcontext *baseContext,
|
||||
int buffer,
|
||||
__GLXpixmap *glxPixmap)
|
||||
__GLXdrawable *glxPixmap)
|
||||
{
|
||||
RegionPtr pRegion = NULL;
|
||||
PixmapPtr pixmap;
|
||||
int bpp, override = 0, texname;
|
||||
GLenum format, type;
|
||||
ScreenPtr pScreen = glxPixmap->pScreen;
|
||||
ScreenPtr pScreen = glxPixmap->pDraw->pScreen;
|
||||
__GLXDRIdrawable *driDraw =
|
||||
containerOf(glxPixmap, __GLXDRIdrawable, base);
|
||||
__GLXDRIscreen * const screen =
|
||||
(__GLXDRIscreen *) __glXgetActiveScreen(pScreen->myNum);
|
||||
(__GLXDRIscreen *) glxGetScreen(pScreen);
|
||||
|
||||
CALL_GetIntegerv(GET_DISPATCH(), (glxPixmap->target == GL_TEXTURE_2D ?
|
||||
GL_TEXTURE_BINDING_2D :
|
||||
|
@ -390,12 +356,12 @@ __glXDRIbindTexImage(__GLXcontext *baseContext,
|
|||
|
||||
pixmap = (PixmapPtr) glxPixmap->pDraw;
|
||||
|
||||
if (screen->texOffsetStart && screen->driScreen.setTexOffset) {
|
||||
__GLXpixmap **texOffsetOverride = screen->texOffsetOverride;
|
||||
if (screen->texOffsetStart && screen->texOffset) {
|
||||
__GLXDRIdrawable **texOffsetOverride = screen->texOffsetOverride;
|
||||
int i, firstEmpty = 16;
|
||||
|
||||
for (i = 0; i < 16; i++) {
|
||||
if (texOffsetOverride[i] == glxPixmap)
|
||||
if (texOffsetOverride[i] == driDraw)
|
||||
goto alreadyin;
|
||||
|
||||
if (firstEmpty == 16 && !texOffsetOverride[i])
|
||||
|
@ -410,36 +376,37 @@ __glXDRIbindTexImage(__GLXcontext *baseContext,
|
|||
if (firstEmpty >= screen->lastTexOffsetOverride)
|
||||
screen->lastTexOffsetOverride = firstEmpty + 1;
|
||||
|
||||
texOffsetOverride[firstEmpty] = glxPixmap;
|
||||
texOffsetOverride[firstEmpty] = driDraw;
|
||||
|
||||
alreadyin:
|
||||
override = 1;
|
||||
|
||||
glxPixmap->pDRICtx = &((__GLXDRIcontext*)baseContext)->driContext;
|
||||
driDraw->ctx = (__GLXDRIcontext*)baseContext;
|
||||
|
||||
if (texname == glxPixmap->texname)
|
||||
if (texname == driDraw->texname)
|
||||
return Success;
|
||||
|
||||
glxPixmap->texname = texname;
|
||||
driDraw->texname = texname;
|
||||
|
||||
screen->driScreen.setTexOffset(glxPixmap->pDRICtx, texname, 0,
|
||||
pixmap->drawable.depth, pixmap->devKind);
|
||||
screen->texOffset->setTexOffset(&driDraw->ctx->driContext, texname, 0,
|
||||
pixmap->drawable.depth,
|
||||
pixmap->devKind);
|
||||
}
|
||||
nooverride:
|
||||
|
||||
if (!glxPixmap->pDamage) {
|
||||
if (!driDraw->pDamage) {
|
||||
if (!override) {
|
||||
glxPixmap->pDamage = DamageCreate(NULL, NULL, DamageReportNone,
|
||||
driDraw->pDamage = DamageCreate(NULL, NULL, DamageReportNone,
|
||||
TRUE, pScreen, NULL);
|
||||
if (!glxPixmap->pDamage)
|
||||
if (!driDraw->pDamage)
|
||||
return BadAlloc;
|
||||
|
||||
DamageRegister ((DrawablePtr) pixmap, glxPixmap->pDamage);
|
||||
DamageRegister ((DrawablePtr) pixmap, driDraw->pDamage);
|
||||
}
|
||||
|
||||
pRegion = NULL;
|
||||
} else {
|
||||
pRegion = DamageRegion(glxPixmap->pDamage);
|
||||
pRegion = DamageRegion(driDraw->pDamage);
|
||||
if (REGION_NIL(pRegion))
|
||||
return Success;
|
||||
}
|
||||
|
@ -518,7 +485,7 @@ nooverride:
|
|||
}
|
||||
|
||||
if (!override)
|
||||
DamageEmpty(glxPixmap->pDamage);
|
||||
DamageEmpty(driDraw->pDamage);
|
||||
|
||||
return Success;
|
||||
}
|
||||
|
@ -526,19 +493,21 @@ nooverride:
|
|||
static int
|
||||
__glXDRIreleaseTexImage(__GLXcontext *baseContext,
|
||||
int buffer,
|
||||
__GLXpixmap *pixmap)
|
||||
__GLXdrawable *pixmap)
|
||||
{
|
||||
ScreenPtr pScreen = pixmap->pScreen;
|
||||
ScreenPtr pScreen = pixmap->pDraw->pScreen;
|
||||
__GLXDRIdrawable *driDraw =
|
||||
containerOf(pixmap, __GLXDRIdrawable, base);
|
||||
__GLXDRIscreen * const screen =
|
||||
(__GLXDRIscreen *) __glXgetActiveScreen(pScreen->myNum);
|
||||
(__GLXDRIscreen *) glxGetScreen(pScreen);
|
||||
GLuint lastOverride = screen->lastTexOffsetOverride;
|
||||
|
||||
if (lastOverride) {
|
||||
__GLXpixmap **texOffsetOverride = screen->texOffsetOverride;
|
||||
__GLXDRIdrawable **texOffsetOverride = screen->texOffsetOverride;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < lastOverride; i++) {
|
||||
if (texOffsetOverride[i] == pixmap) {
|
||||
if (texOffsetOverride[i] == driDraw) {
|
||||
if (screen->texOffsetFinish)
|
||||
screen->texOffsetFinish((PixmapPtr)pixmap->pDraw);
|
||||
|
||||
|
@ -575,9 +544,7 @@ __glXDRIscreenDestroy(__GLXscreen *baseScreen)
|
|||
{
|
||||
__GLXDRIscreen *screen = (__GLXDRIscreen *) baseScreen;
|
||||
|
||||
screen->driScreen.destroyScreen(NULL,
|
||||
screen->base.pScreen->myNum,
|
||||
screen->driScreen.private);
|
||||
screen->driScreen.destroyScreen(&screen->driScreen);
|
||||
|
||||
dlclose(screen->driver);
|
||||
|
||||
|
@ -593,13 +560,18 @@ __glXDRIscreenCreateContext(__GLXscreen *baseScreen,
|
|||
{
|
||||
__GLXDRIscreen *screen = (__GLXDRIscreen *) baseScreen;
|
||||
__GLXDRIcontext *context, *shareContext;
|
||||
void *sharePrivate;
|
||||
VisualPtr visual;
|
||||
int i;
|
||||
GLboolean retval;
|
||||
__DRIcontext *driShare;
|
||||
drm_context_t hwContext;
|
||||
ScreenPtr pScreen = baseScreen->pScreen;
|
||||
|
||||
shareContext = (__GLXDRIcontext *) baseShareContext;
|
||||
if (shareContext)
|
||||
sharePrivate = shareContext->driContext.private;
|
||||
driShare = &shareContext->driContext;
|
||||
else
|
||||
sharePrivate = NULL;
|
||||
driShare = NULL;
|
||||
|
||||
context = xalloc(sizeof *context);
|
||||
if (context == NULL)
|
||||
|
@ -614,25 +586,43 @@ __glXDRIscreenCreateContext(__GLXscreen *baseScreen,
|
|||
context->base.pScreen = screen->base.pScreen;
|
||||
|
||||
context->base.textureFromPixmap = &__glXDRItextureFromPixmap;
|
||||
/* Find the requested X visual */
|
||||
visual = pScreen->visuals;
|
||||
for (i = 0; i < pScreen->numVisuals; i++, visual++)
|
||||
if (visual->vid == modes->visualID)
|
||||
break;
|
||||
if (i == pScreen->numVisuals)
|
||||
return GL_FALSE;
|
||||
|
||||
context->hwContextID = FakeClientID(0);
|
||||
|
||||
__glXenterServer(GL_FALSE);
|
||||
retval = DRICreateContext(baseScreen->pScreen, visual,
|
||||
context->hwContextID, &hwContext);
|
||||
__glXleaveServer(GL_FALSE);
|
||||
|
||||
context->driContext.private =
|
||||
screen->driScreen.createNewContext(NULL, modes,
|
||||
screen->driScreen.createNewContext(&screen->driScreen,
|
||||
modes,
|
||||
0, /* render type */
|
||||
sharePrivate,
|
||||
driShare,
|
||||
hwContext,
|
||||
&context->driContext);
|
||||
|
||||
context->driContext.mode = modes;
|
||||
|
||||
return &context->base;
|
||||
}
|
||||
|
||||
static __GLXdrawable *
|
||||
__glXDRIscreenCreateDrawable(__GLXscreen *screen,
|
||||
DrawablePtr pDraw,
|
||||
int type,
|
||||
XID drawId,
|
||||
__GLcontextModes *modes)
|
||||
{
|
||||
__GLXDRIscreen *driScreen = (__GLXDRIscreen *) screen;
|
||||
__GLXDRIdrawable *private;
|
||||
GLboolean retval;
|
||||
drm_drawable_t hwDrawable;
|
||||
|
||||
private = xalloc(sizeof *private);
|
||||
if (private == NULL)
|
||||
|
@ -640,7 +630,8 @@ __glXDRIscreenCreateDrawable(__GLXscreen *screen,
|
|||
|
||||
memset(private, 0, sizeof *private);
|
||||
|
||||
if (!__glXDrawableInit(&private->base, screen, pDraw, drawId, modes)) {
|
||||
if (!__glXDrawableInit(&private->base, screen,
|
||||
pDraw, type, drawId, modes)) {
|
||||
xfree(private);
|
||||
return NULL;
|
||||
}
|
||||
|
@ -650,238 +641,45 @@ __glXDRIscreenCreateDrawable(__GLXscreen *screen,
|
|||
private->base.swapBuffers = __glXDRIdrawableSwapBuffers;
|
||||
private->base.copySubBuffer = __glXDRIdrawableCopySubBuffer;
|
||||
|
||||
#if 0
|
||||
/* FIXME: It would only be natural that we called
|
||||
* driScreen->createNewDrawable here but the DRI drivers manage
|
||||
* them a little oddly. FIXME: describe this better.*/
|
||||
__glXenterServer(GL_FALSE);
|
||||
retval = DRICreateDrawable(screen->pScreen, serverClient,
|
||||
pDraw, &hwDrawable);
|
||||
__glXleaveServer(GL_FALSE);
|
||||
|
||||
/* The last argument is 'attrs', which is used with pbuffers which
|
||||
* we currently don't support. */
|
||||
|
||||
glxPriv->driDrawable.private =
|
||||
(screen->driScreen.createNewDrawable)(NULL, modes,
|
||||
drawId,
|
||||
&glxPriv->driDrawable,
|
||||
0,
|
||||
NULL);
|
||||
#endif
|
||||
private->driDrawable.private =
|
||||
(driScreen->driScreen.createNewDrawable)(&driScreen->driScreen,
|
||||
modes,
|
||||
&private->driDrawable,
|
||||
hwDrawable, 0, NULL);
|
||||
|
||||
return &private->base;
|
||||
}
|
||||
|
||||
|
||||
static unsigned
|
||||
filter_modes(__GLcontextModes **server_modes,
|
||||
const __GLcontextModes *driver_modes)
|
||||
{
|
||||
__GLcontextModes * m;
|
||||
__GLcontextModes ** prev_next;
|
||||
const __GLcontextModes * check;
|
||||
unsigned modes_count = 0;
|
||||
|
||||
if ( driver_modes == NULL ) {
|
||||
LogMessage(X_WARNING,
|
||||
"AIGLX: 3D driver returned no fbconfigs.\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* For each mode in server_modes, check to see if a matching mode exists
|
||||
* in driver_modes. If not, then the mode is not available.
|
||||
*/
|
||||
|
||||
prev_next = server_modes;
|
||||
for ( m = *prev_next ; m != NULL ; m = *prev_next ) {
|
||||
GLboolean do_delete = GL_TRUE;
|
||||
|
||||
for ( check = driver_modes ; check != NULL ; check = check->next ) {
|
||||
if ( _gl_context_modes_are_same( m, check ) ) {
|
||||
do_delete = GL_FALSE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* The 3D has to support all the modes that match the GLX visuals
|
||||
* sent from the X server.
|
||||
*/
|
||||
if ( do_delete && (m->visualID != 0) ) {
|
||||
do_delete = GL_FALSE;
|
||||
|
||||
LogMessage(X_WARNING,
|
||||
"AIGLX: 3D driver claims to not support "
|
||||
"visual 0x%02x\n", m->visualID);
|
||||
}
|
||||
|
||||
if ( do_delete ) {
|
||||
*prev_next = m->next;
|
||||
|
||||
m->next = NULL;
|
||||
_gl_context_modes_destroy( m );
|
||||
}
|
||||
else {
|
||||
modes_count++;
|
||||
prev_next = & m->next;
|
||||
}
|
||||
}
|
||||
|
||||
return modes_count;
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
enable_glx_extension(void *psc, const char *ext_name)
|
||||
{
|
||||
__GLXDRIscreen * const screen = (__GLXDRIscreen *) psc;
|
||||
|
||||
__glXEnableExtension(screen->glx_enable_bits, ext_name);
|
||||
}
|
||||
|
||||
|
||||
static __DRIfuncPtr getProcAddress(const char *proc_name)
|
||||
{
|
||||
if (strcmp(proc_name, "glxEnableExtension") == 0) {
|
||||
return (__DRIfuncPtr) enable_glx_extension;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static __DRIscreen *findScreen(__DRInativeDisplay *dpy, int scrn)
|
||||
{
|
||||
__GLXDRIscreen *screen = (__GLXDRIscreen *) __glXgetActiveScreen(scrn);
|
||||
|
||||
return &screen->driScreen;
|
||||
}
|
||||
|
||||
static GLboolean windowExists(__DRInativeDisplay *dpy, __DRIid draw)
|
||||
{
|
||||
DrawablePtr pDrawable = (DrawablePtr) LookupIDByType(draw, RT_WINDOW);
|
||||
int unused;
|
||||
drm_clip_rect_t *pRects;
|
||||
|
||||
return pDrawable ? DRIGetDrawableInfo(pDrawable->pScreen, pDrawable,
|
||||
(unsigned*)&unused, (unsigned*)&unused,
|
||||
&unused, &unused, &unused, &unused,
|
||||
&unused, &pRects, &unused, &unused,
|
||||
&unused, &pRects)
|
||||
: GL_FALSE;
|
||||
}
|
||||
|
||||
static GLboolean createContext(__DRInativeDisplay *dpy, int screen,
|
||||
int configID, void *contextID,
|
||||
drm_context_t *hw_context)
|
||||
{
|
||||
XID fakeID;
|
||||
VisualPtr visual;
|
||||
int i;
|
||||
ScreenPtr pScreen;
|
||||
GLboolean retval;
|
||||
|
||||
pScreen = screenInfo.screens[screen];
|
||||
|
||||
/* Find the requested X visual */
|
||||
visual = pScreen->visuals;
|
||||
for (i = 0; i < pScreen->numVisuals; i++, visual++)
|
||||
if (visual->vid == configID)
|
||||
break;
|
||||
if (i == pScreen->numVisuals)
|
||||
return GL_FALSE;
|
||||
|
||||
fakeID = FakeClientID(0);
|
||||
*(XID *) contextID = fakeID;
|
||||
|
||||
__glXDRIenterServer(GL_FALSE);
|
||||
retval = DRICreateContext(pScreen, visual, fakeID, hw_context);
|
||||
__glXDRIleaveServer(GL_FALSE);
|
||||
return retval;
|
||||
}
|
||||
|
||||
static GLboolean destroyContext(__DRInativeDisplay *dpy, int screen,
|
||||
__DRIid context)
|
||||
{
|
||||
GLboolean retval;
|
||||
|
||||
__glXDRIenterServer(GL_FALSE);
|
||||
retval = DRIDestroyContext(screenInfo.screens[screen], context);
|
||||
__glXDRIleaveServer(GL_FALSE);
|
||||
return retval;
|
||||
}
|
||||
|
||||
static GLboolean
|
||||
createDrawable(__DRInativeDisplay *dpy, int screen,
|
||||
__DRIid drawable, drm_drawable_t *hHWDrawable)
|
||||
{
|
||||
DrawablePtr pDrawable;
|
||||
GLboolean retval;
|
||||
|
||||
pDrawable = (DrawablePtr) LookupIDByClass(drawable, RC_DRAWABLE);
|
||||
if (!pDrawable)
|
||||
return GL_FALSE;
|
||||
|
||||
__glXDRIenterServer(GL_FALSE);
|
||||
retval = DRICreateDrawable(screenInfo.screens[screen], __pGlxClient,
|
||||
pDrawable, hHWDrawable);
|
||||
__glXDRIleaveServer(GL_FALSE);
|
||||
return retval;
|
||||
}
|
||||
|
||||
static GLboolean
|
||||
destroyDrawable(__DRInativeDisplay *dpy, int screen, __DRIid drawable)
|
||||
{
|
||||
DrawablePtr pDrawable;
|
||||
GLboolean retval;
|
||||
|
||||
pDrawable = (DrawablePtr) LookupIDByClass(drawable, RC_DRAWABLE);
|
||||
if (!pDrawable)
|
||||
return GL_FALSE;
|
||||
|
||||
__glXDRIenterServer(GL_FALSE);
|
||||
retval = DRIDestroyDrawable(screenInfo.screens[screen], __pGlxClient,
|
||||
pDrawable);
|
||||
__glXDRIleaveServer(GL_FALSE);
|
||||
return retval;
|
||||
}
|
||||
|
||||
static GLboolean
|
||||
getDrawableInfo(__DRInativeDisplay *dpy, int screen,
|
||||
__DRIid drawable, unsigned int *index, unsigned int *stamp,
|
||||
getDrawableInfo(__DRIdrawable *driDrawable,
|
||||
unsigned int *index, unsigned int *stamp,
|
||||
int *x, int *y, int *width, int *height,
|
||||
int *numClipRects, drm_clip_rect_t **ppClipRects,
|
||||
int *backX, int *backY,
|
||||
int *numBackClipRects, drm_clip_rect_t **ppBackClipRects)
|
||||
{
|
||||
DrawablePtr pDrawable;
|
||||
__GLXDRIdrawable *drawable = containerOf(driDrawable,
|
||||
__GLXDRIdrawable, driDrawable);
|
||||
ScreenPtr pScreen = drawable->base.pDraw->pScreen;
|
||||
drm_clip_rect_t *pClipRects, *pBackClipRects;
|
||||
GLboolean retval;
|
||||
size_t size;
|
||||
|
||||
pDrawable = (DrawablePtr) LookupIDByClass(drawable, RC_DRAWABLE);
|
||||
if (!pDrawable) {
|
||||
ErrorF("getDrawableInfo failed to look up window\n");
|
||||
|
||||
*index = 0;
|
||||
*stamp = 0;
|
||||
*x = 0;
|
||||
*y = 0;
|
||||
*width = 0;
|
||||
*height = 0;
|
||||
*numClipRects = 0;
|
||||
*ppClipRects = NULL;
|
||||
*backX = 0;
|
||||
*backY = 0;
|
||||
*numBackClipRects = 0;
|
||||
*ppBackClipRects = NULL;
|
||||
|
||||
return GL_FALSE;
|
||||
}
|
||||
|
||||
__glXDRIenterServer(GL_FALSE);
|
||||
retval = DRIGetDrawableInfo(screenInfo.screens[screen],
|
||||
pDrawable, index, stamp,
|
||||
__glXenterServer(GL_FALSE);
|
||||
retval = DRIGetDrawableInfo(pScreen, drawable->base.pDraw, index, stamp,
|
||||
x, y, width, height,
|
||||
numClipRects, &pClipRects,
|
||||
backX, backY,
|
||||
numBackClipRects, &pBackClipRects);
|
||||
__glXDRIleaveServer(GL_FALSE);
|
||||
__glXleaveServer(GL_FALSE);
|
||||
|
||||
if (*numClipRects > 0) {
|
||||
size = sizeof (drm_clip_rect_t) * *numClipRects;
|
||||
|
@ -889,7 +687,6 @@ getDrawableInfo(__DRInativeDisplay *dpy, int screen,
|
|||
|
||||
/* Clip cliprects to screen dimensions (redirected windows) */
|
||||
if (*ppClipRects != NULL) {
|
||||
ScreenPtr pScreen = screenInfo.screens[screen];
|
||||
int i, j;
|
||||
|
||||
for (i = 0, j = 0; i < *numClipRects; i++) {
|
||||
|
@ -946,25 +743,33 @@ getUST(int64_t *ust)
|
|||
}
|
||||
}
|
||||
|
||||
static void __glXReportDamage(__DRIdrawable *driDraw,
|
||||
int x, int y,
|
||||
drm_clip_rect_t *rects, int num_rects,
|
||||
GLboolean front_buffer)
|
||||
{
|
||||
__GLXDRIdrawable *drawable =
|
||||
containerOf(driDraw, __GLXDRIdrawable, driDrawable);
|
||||
DrawablePtr pDraw = drawable->base.pDraw;
|
||||
RegionRec region;
|
||||
|
||||
REGION_INIT(pDraw->pScreen, ®ion, (BoxPtr) rects, num_rects);
|
||||
REGION_TRANSLATE(pScreen, ®ion, pDraw->x, pDraw->y);
|
||||
DamageDamageRegion(pDraw, ®ion);
|
||||
REGION_UNINIT(pDraw->pScreen, ®ion);
|
||||
}
|
||||
|
||||
/* Table of functions that we export to the driver. */
|
||||
static const __DRIinterfaceMethods interface_methods = {
|
||||
getProcAddress,
|
||||
|
||||
_gl_context_modes_create,
|
||||
_gl_context_modes_destroy,
|
||||
|
||||
findScreen,
|
||||
windowExists,
|
||||
|
||||
createContext,
|
||||
destroyContext,
|
||||
|
||||
createDrawable,
|
||||
destroyDrawable,
|
||||
getDrawableInfo,
|
||||
|
||||
getUST,
|
||||
NULL, /* glXGetMscRateOML, */
|
||||
|
||||
__glXReportDamage,
|
||||
};
|
||||
|
||||
static const char dri_driver_path[] = DRI_DRIVER_PATH;
|
||||
|
@ -972,7 +777,8 @@ static const char dri_driver_path[] = DRI_DRIVER_PATH;
|
|||
static Bool
|
||||
glxDRIEnterVT (int index, int flags)
|
||||
{
|
||||
__GLXDRIscreen *screen = (__GLXDRIscreen *) __glXgetActiveScreen(index);
|
||||
__GLXDRIscreen *screen = (__GLXDRIscreen *)
|
||||
glxGetScreen(screenInfo.screens[index]);
|
||||
|
||||
LogMessage(X_INFO, "AIGLX: Resuming AIGLX clients after VT switch\n");
|
||||
|
||||
|
@ -987,7 +793,8 @@ glxDRIEnterVT (int index, int flags)
|
|||
static void
|
||||
glxDRILeaveVT (int index, int flags)
|
||||
{
|
||||
__GLXDRIscreen *screen = (__GLXDRIscreen *) __glXgetActiveScreen(index);
|
||||
__GLXDRIscreen *screen = (__GLXDRIscreen *)
|
||||
glxGetScreen(screenInfo.screens[index]);
|
||||
|
||||
LogMessage(X_INFO, "AIGLX: Suspending AIGLX clients for VT switch\n");
|
||||
|
||||
|
@ -996,6 +803,48 @@ glxDRILeaveVT (int index, int flags)
|
|||
return (*screen->leaveVT) (index, flags);
|
||||
}
|
||||
|
||||
static void
|
||||
initializeExtensions(__GLXDRIscreen *screen)
|
||||
{
|
||||
const __DRIextension **extensions;
|
||||
int i;
|
||||
|
||||
extensions = screen->driScreen.getExtensions(&screen->driScreen);
|
||||
for (i = 0; extensions[i]; i++) {
|
||||
#ifdef __DRI_COPY_SUB_BUFFER
|
||||
if (strcmp(extensions[i]->name, __DRI_COPY_SUB_BUFFER) == 0) {
|
||||
screen->copySubBuffer = (__DRIcopySubBufferExtension *) extensions[i];
|
||||
__glXEnableExtension(screen->glx_enable_bits,
|
||||
"GLX_MESA_copy_sub_buffer");
|
||||
|
||||
LogMessage(X_INFO, "AIGLX: enabled GLX_MESA_copy_sub_buffer\n");
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef __DRI_SWAP_CONTROL
|
||||
if (strcmp(extensions[i]->name, __DRI_SWAP_CONTROL) == 0) {
|
||||
screen->swapControl = (__DRIswapControlExtension *) extensions[i];
|
||||
__glXEnableExtension(screen->glx_enable_bits,
|
||||
"GLX_SGI_swap_control");
|
||||
__glXEnableExtension(screen->glx_enable_bits,
|
||||
"GLX_MESA_swap_control");
|
||||
|
||||
LogMessage(X_INFO, "AIGLX: enabled GLX_SGI_swap_control and GLX_MESA_swap_control\n");
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef __DRI_TEX_OFFSET
|
||||
if (strcmp(extensions[i]->name, __DRI_TEX_OFFSET) == 0) {
|
||||
screen->texOffset = (__DRItexOffsetExtension *) extensions[i];
|
||||
LogMessage(X_INFO, "AIGLX: enabled GLX_texture_from_pixmap with driver support\n");
|
||||
}
|
||||
#endif
|
||||
/* Ignore unknown extensions */
|
||||
}
|
||||
}
|
||||
|
||||
#define COPY_SUB_BUFFER_INTERNAL_VERSION 20060314
|
||||
|
||||
static __GLXscreen *
|
||||
__glXDRIscreenProbe(ScreenPtr pScreen)
|
||||
{
|
||||
|
@ -1016,7 +865,6 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
|
|||
char *driverName;
|
||||
drm_handle_t hFB;
|
||||
int junk;
|
||||
__GLcontextModes * driver_modes;
|
||||
__GLXDRIscreen *screen;
|
||||
void *dev_priv = NULL;
|
||||
char filename[128];
|
||||
|
@ -1044,8 +892,6 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
|
|||
screen->base.pScreen = pScreen;
|
||||
|
||||
__glXInitExtensionEnableBits(screen->glx_enable_bits);
|
||||
screen->driScreen.screenConfigs = screen;
|
||||
|
||||
|
||||
/* DRI protocol version. */
|
||||
dri_version.major = XF86DRI_MAJOR_VERSION;
|
||||
|
@ -1168,11 +1014,9 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
|
|||
goto handle_error;
|
||||
}
|
||||
|
||||
driver_modes = NULL;
|
||||
screen->driScreen.private =
|
||||
(*createNewScreen)(NULL, pScreen->myNum,
|
||||
(*createNewScreen)(pScreen->myNum,
|
||||
&screen->driScreen,
|
||||
screen->base.modes,
|
||||
&ddx_version,
|
||||
&dri_version,
|
||||
&drm_version,
|
||||
|
@ -1181,7 +1025,7 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
|
|||
fd,
|
||||
api_ver,
|
||||
&interface_methods,
|
||||
&driver_modes);
|
||||
&screen->base.fbconfigs);
|
||||
|
||||
if (screen->driScreen.private == NULL) {
|
||||
LogMessage(X_ERROR, "AIGLX error: Calling driver entry point failed");
|
||||
|
@ -1191,6 +1035,8 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
|
|||
DRIGetTexOffsetFuncs(pScreen, &screen->texOffsetStart,
|
||||
&screen->texOffsetFinish);
|
||||
|
||||
initializeExtensions(screen);
|
||||
|
||||
__glXScreenInit(&screen->base, pScreen);
|
||||
|
||||
buffer_size = __glXGetExtensionString(screen->glx_enable_bits, NULL);
|
||||
|
@ -1204,10 +1050,6 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
|
|||
screen->base.GLXextensions);
|
||||
}
|
||||
|
||||
|
||||
filter_modes(&screen->base.modes, driver_modes);
|
||||
_gl_context_modes_destroy(driver_modes);
|
||||
|
||||
__glXsetEnterLeaveServerFuncs(__glXDRIenterServer, __glXDRIleaveServer);
|
||||
|
||||
screen->enterVT = pScrn->EnterVT;
|
||||
|
|
238
GL/glx/glxext.c
238
GL/glx/glxext.c
|
@ -45,8 +45,6 @@ __GLXcontext *__glXLastContext;
|
|||
** X resources.
|
||||
*/
|
||||
RESTYPE __glXContextRes;
|
||||
RESTYPE __glXClientRes;
|
||||
RESTYPE __glXPixmapRes;
|
||||
RESTYPE __glXDrawableRes;
|
||||
RESTYPE __glXSwapBarrierRes;
|
||||
|
||||
|
@ -55,11 +53,7 @@ RESTYPE __glXSwapBarrierRes;
|
|||
*/
|
||||
xGLXSingleReply __glXReply;
|
||||
|
||||
/*
|
||||
** A set of state for each client. The 0th one is unused because client
|
||||
** indices start at 1, not 0.
|
||||
*/
|
||||
static __GLXclientState *__glXClients[MAXCLIENTS + 1];
|
||||
static int glxClientPrivateIndex;
|
||||
|
||||
/*
|
||||
** Client that called into GLX dispatch.
|
||||
|
@ -77,29 +71,6 @@ static int __glXDispatch(ClientPtr);
|
|||
static void ResetExtension(ExtensionEntry* extEntry)
|
||||
{
|
||||
__glXFlushContextCache();
|
||||
__glXResetScreens();
|
||||
}
|
||||
|
||||
/*
|
||||
** Initialize the per-client context storage.
|
||||
*/
|
||||
static void ResetClientState(int clientIndex)
|
||||
{
|
||||
__GLXclientState *cl = __glXClients[clientIndex];
|
||||
|
||||
if (cl->returnBuf) xfree(cl->returnBuf);
|
||||
if (cl->largeCmdBuf) xfree(cl->largeCmdBuf);
|
||||
if (cl->currentContexts) xfree(cl->currentContexts);
|
||||
memset(cl, 0, sizeof(__GLXclientState));
|
||||
/*
|
||||
** By default, assume that the client supports
|
||||
** GLX major version 1 minor version 0 protocol.
|
||||
*/
|
||||
cl->GLClientmajorVersion = 1;
|
||||
cl->GLClientminorVersion = 0;
|
||||
if (cl->GLClientextensions)
|
||||
xfree(cl->GLClientextensions);
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -129,66 +100,6 @@ static int ContextGone(__GLXcontext* cx, XID id)
|
|||
return True;
|
||||
}
|
||||
|
||||
/*
|
||||
** Free a client's state.
|
||||
*/
|
||||
static int ClientGone(int clientIndex, XID id)
|
||||
{
|
||||
__GLXcontext *cx;
|
||||
__GLXclientState *cl = __glXClients[clientIndex];
|
||||
int i;
|
||||
|
||||
if (cl) {
|
||||
/*
|
||||
** Free all the contexts that are current for this client.
|
||||
*/
|
||||
for (i=0; i < cl->numCurrentContexts; i++) {
|
||||
cx = cl->currentContexts[i];
|
||||
if (cx) {
|
||||
__glXDeassociateContext(cx);
|
||||
cx->isCurrent = GL_FALSE;
|
||||
if (!cx->idExists) {
|
||||
__glXFreeContext(cx);
|
||||
}
|
||||
}
|
||||
}
|
||||
/*
|
||||
** Re-initialize the client state structure. Don't free it because
|
||||
** we'll probably get another client with this index and use the struct
|
||||
** again. There is a maximum of MAXCLIENTS of these structures.
|
||||
*/
|
||||
ResetClientState(clientIndex);
|
||||
}
|
||||
|
||||
return True;
|
||||
}
|
||||
|
||||
/*
|
||||
** Free a GLX Pixmap.
|
||||
*/
|
||||
static int PixmapGone(__GLXpixmap *pGlxPixmap, XID id)
|
||||
{
|
||||
PixmapPtr pPixmap = (PixmapPtr) pGlxPixmap->pDraw;
|
||||
|
||||
pGlxPixmap->idExists = False;
|
||||
if (!pGlxPixmap->refcnt) {
|
||||
#ifdef XF86DRI
|
||||
if (pGlxPixmap->pDamage) {
|
||||
DamageUnregister (pGlxPixmap->pDraw, pGlxPixmap->pDamage);
|
||||
DamageDestroy(pGlxPixmap->pDamage);
|
||||
}
|
||||
#endif
|
||||
/*
|
||||
** The DestroyPixmap routine should decrement the refcount and free
|
||||
** only if it's zero.
|
||||
*/
|
||||
(*pGlxPixmap->pScreen->DestroyPixmap)(pPixmap);
|
||||
xfree(pGlxPixmap);
|
||||
}
|
||||
|
||||
return True;
|
||||
}
|
||||
|
||||
/*
|
||||
** Destroy routine that gets called when a drawable is freed. A drawable
|
||||
** contains the ancillary buffers needed for rendering.
|
||||
|
@ -198,13 +109,7 @@ static Bool DrawableGone(__GLXdrawable *glxPriv, XID xid)
|
|||
__GLXcontext *cx, *cx1;
|
||||
|
||||
/*
|
||||
** Use glxPriv->type to figure out what kind of drawable this is. Don't
|
||||
** use glxPriv->pDraw->type because by the time this routine is called,
|
||||
** the pDraw might already have been freed.
|
||||
*/
|
||||
if (glxPriv->type == DRAWABLE_WINDOW) {
|
||||
/*
|
||||
** When a window is destroyed, notify all context bound to
|
||||
** When a drawable is destroyed, notify all context bound to
|
||||
** it, that there are no longer bound to anything.
|
||||
*/
|
||||
for (cx = glxPriv->drawGlxc; cx; cx = cx1) {
|
||||
|
@ -216,7 +121,6 @@ static Bool DrawableGone(__GLXdrawable *glxPriv, XID xid)
|
|||
cx1 = cx->nextReadPriv;
|
||||
cx->pendingState |= __GLX_PENDING_DESTROY;
|
||||
}
|
||||
}
|
||||
|
||||
__glXUnrefDrawable(glxPriv);
|
||||
|
||||
|
@ -260,9 +164,10 @@ extern RESTYPE __glXSwapBarrierRes;
|
|||
|
||||
static int SwapBarrierGone(int screen, XID drawable)
|
||||
{
|
||||
if (__glXSwapBarrierFuncs &&
|
||||
__glXSwapBarrierFuncs[screen].bindSwapBarrierFunc != NULL) {
|
||||
__glXSwapBarrierFuncs[screen].bindSwapBarrierFunc(screen, drawable, 0);
|
||||
__GLXscreen *pGlxScreen = glxGetScreen(screenInfo.screens[screen]);
|
||||
|
||||
if (pGlxScreen->swapBarrierFuncs) {
|
||||
pGlxScreen->swapBarrierFuncs->bindSwapBarrierFunc(screen, drawable, 0);
|
||||
}
|
||||
FreeResourceByType(drawable, __glXSwapBarrierRes, FALSE);
|
||||
return True;
|
||||
|
@ -310,22 +215,86 @@ int __glXError(int error)
|
|||
return __glXErrorBase + error;
|
||||
}
|
||||
|
||||
__GLXclientState *
|
||||
glxGetClient(ClientPtr pClient)
|
||||
{
|
||||
return (__GLXclientState *) pClient->devPrivates[glxClientPrivateIndex].ptr;
|
||||
}
|
||||
|
||||
static void
|
||||
glxClientCallback (CallbackListPtr *list,
|
||||
pointer closure,
|
||||
pointer data)
|
||||
{
|
||||
NewClientInfoRec *clientinfo = (NewClientInfoRec *) data;
|
||||
ClientPtr pClient = clientinfo->client;
|
||||
__GLXclientState *cl = glxGetClient(pClient);
|
||||
__GLXcontext *cx;
|
||||
int i;
|
||||
|
||||
switch (pClient->clientState) {
|
||||
case ClientStateRunning:
|
||||
/*
|
||||
** 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;
|
||||
|
||||
case ClientStateGone:
|
||||
for (i = 0; i < cl->numCurrentContexts; i++) {
|
||||
cx = cl->currentContexts[i];
|
||||
if (cx) {
|
||||
cx->isCurrent = GL_FALSE;
|
||||
if (!cx->idExists)
|
||||
__glXFreeContext(cx);
|
||||
}
|
||||
}
|
||||
|
||||
if (cl->returnBuf) xfree(cl->returnBuf);
|
||||
if (cl->largeCmdBuf) xfree(cl->largeCmdBuf);
|
||||
if (cl->currentContexts) xfree(cl->currentContexts);
|
||||
if (cl->GLClientextensions) xfree(cl->GLClientextensions);
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/************************************************************************/
|
||||
|
||||
static __GLXprovider *__glXProviderStack;
|
||||
|
||||
void GlxPushProvider(__GLXprovider *provider)
|
||||
{
|
||||
provider->next = __glXProviderStack;
|
||||
__glXProviderStack = provider;
|
||||
}
|
||||
|
||||
/*
|
||||
** Initialize the GLX extension.
|
||||
*/
|
||||
void GlxExtensionInit(void)
|
||||
{
|
||||
ExtensionEntry *extEntry;
|
||||
ScreenPtr pScreen;
|
||||
int i;
|
||||
__GLXprovider *p;
|
||||
|
||||
__glXContextRes = CreateNewResourceType((DeleteType)ContextGone);
|
||||
__glXClientRes = CreateNewResourceType((DeleteType)ClientGone);
|
||||
__glXPixmapRes = CreateNewResourceType((DeleteType)PixmapGone);
|
||||
__glXDrawableRes = CreateNewResourceType((DeleteType)DrawableGone);
|
||||
__glXSwapBarrierRes = CreateNewResourceType((DeleteType)SwapBarrierGone);
|
||||
|
||||
glxClientPrivateIndex = AllocateClientPrivateIndex ();
|
||||
if (!AllocateClientPrivate (glxClientPrivateIndex,
|
||||
sizeof (__GLXclientState)))
|
||||
return;
|
||||
if (!AddCallback (&ClientStateCallback, glxClientCallback, 0))
|
||||
return;
|
||||
|
||||
/*
|
||||
** Add extension to server extensions.
|
||||
*/
|
||||
|
@ -344,17 +313,18 @@ void GlxExtensionInit(void)
|
|||
|
||||
__glXErrorBase = extEntry->errorBase;
|
||||
|
||||
/*
|
||||
** Initialize table of client state. There is never a client 0.
|
||||
*/
|
||||
for (i = 1; i <= MAXCLIENTS; i++) {
|
||||
__glXClients[i] = 0;
|
||||
}
|
||||
for (i = 0; i < screenInfo.numScreens; i++) {
|
||||
pScreen = screenInfo.screens[i];
|
||||
|
||||
/*
|
||||
** Initialize screen specific data.
|
||||
*/
|
||||
__glXInitScreens();
|
||||
for (p = __glXProviderStack; p != NULL; p = p->next) {
|
||||
if (p->screenProbe(pScreen) != NULL) {
|
||||
LogMessage(X_INFO,
|
||||
"GLX: Initialized %s GL provider for screen %d\n",
|
||||
p->name, i);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/************************************************************************/
|
||||
|
@ -422,11 +392,9 @@ void glxSuspendClients(void)
|
|||
{
|
||||
int i;
|
||||
|
||||
for (i = 1; i <= MAXCLIENTS; i++) {
|
||||
if (__glXClients[i] == NULL || !__glXClients[i]->inUse)
|
||||
continue;
|
||||
|
||||
IgnoreClient(__glXClients[i]->client);
|
||||
for (i = 1; i < currentMaxClients; i++) {
|
||||
if (glxGetClient(clients[i])->inUse)
|
||||
IgnoreClient(clients[i]);
|
||||
}
|
||||
|
||||
glxBlockClients = TRUE;
|
||||
|
@ -439,11 +407,9 @@ void glxResumeClients(void)
|
|||
|
||||
glxBlockClients = FALSE;
|
||||
|
||||
for (i = 1; i <= MAXCLIENTS; i++) {
|
||||
if (__glXClients[i] == NULL || !__glXClients[i]->inUse)
|
||||
continue;
|
||||
|
||||
AttendClient(__glXClients[i]->client);
|
||||
for (i = 1; i < currentMaxClients; i++) {
|
||||
if (glxGetClient(clients[i])->inUse)
|
||||
AttendClient(clients[i]);
|
||||
}
|
||||
|
||||
__glXleaveServer(GL_FALSE);
|
||||
|
@ -505,29 +471,9 @@ static int __glXDispatch(ClientPtr client)
|
|||
int retval;
|
||||
|
||||
opcode = stuff->glxCode;
|
||||
cl = __glXClients[client->index];
|
||||
if (!cl) {
|
||||
cl = (__GLXclientState *) xalloc(sizeof(__GLXclientState));
|
||||
__glXClients[client->index] = cl;
|
||||
if (!cl) {
|
||||
return BadAlloc;
|
||||
}
|
||||
memset(cl, 0, sizeof(__GLXclientState));
|
||||
}
|
||||
|
||||
if (!cl->inUse) {
|
||||
/*
|
||||
** This is first request from this client. Associate a resource
|
||||
** with the client so we will be notified when the client dies.
|
||||
*/
|
||||
XID xid = FakeClientID(client->index);
|
||||
if (!AddResource( xid, __glXClientRes, (pointer)(long)client->index)) {
|
||||
return BadAlloc;
|
||||
}
|
||||
ResetClientState(client->index);
|
||||
cl->inUse = GL_TRUE;
|
||||
cl->client = client;
|
||||
}
|
||||
cl = glxGetClient(client);
|
||||
/* Mark it in use so we suspend it on VT switch. */
|
||||
cl->inUse = TRUE;
|
||||
|
||||
/*
|
||||
** If we're expecting a glXRenderLarge request, this better be one.
|
||||
|
|
|
@ -71,24 +71,6 @@ extern void __glXClearErrorOccured(void);
|
|||
extern GLboolean __glXErrorOccured(void);
|
||||
extern void __glXResetLargeCommandStatus(__GLXclientState*);
|
||||
|
||||
extern int DoMakeCurrent( __GLXclientState *cl, GLXDrawable drawId,
|
||||
GLXDrawable readId, GLXContextID contextId, GLXContextTag tag );
|
||||
extern int DoGetVisualConfigs(__GLXclientState *cl, unsigned screen,
|
||||
GLboolean do_swap);
|
||||
extern int DoGetFBConfigs(__GLXclientState *cl, unsigned screen,
|
||||
GLboolean do_swap);
|
||||
extern int DoCreateContext(__GLXclientState *cl, GLXContextID gcId,
|
||||
GLXContextID shareList, VisualID visual, GLuint screen, GLboolean isDirect);
|
||||
extern int DoCreateGLXPixmap(__GLXclientState *cl, XID fbconfigId,
|
||||
GLuint screenNum, XID pixmapId, XID glxpixmapId, CARD32 *attribs,
|
||||
CARD32 numAttribs);
|
||||
extern int DoDestroyPixmap(__GLXclientState *cl, XID glxpixmapId);
|
||||
|
||||
extern int DoQueryContext(__GLXclientState *cl, GLXContextID gcId);
|
||||
|
||||
extern int DoRender(__GLXclientState *cl, GLbyte *pc, int do_swap);
|
||||
extern int DoRenderLarge(__GLXclientState *cl, GLbyte *pc, int do_swap);
|
||||
|
||||
extern void GlxExtensionInit(void);
|
||||
|
||||
extern const char GLServerVersion[];
|
||||
|
@ -106,25 +88,5 @@ extern int GlxInitVisuals(
|
|||
int preferredVis
|
||||
);
|
||||
|
||||
typedef struct {
|
||||
void * (* queryHyperpipeNetworkFunc)(int, int *, int *);
|
||||
void * (* queryHyperpipeConfigFunc)(int, int, int *, int *);
|
||||
int (* destroyHyperpipeConfigFunc)(int, int);
|
||||
void * (* hyperpipeConfigFunc)(int, int, int *, int *, void *);
|
||||
} __GLXHyperpipeExtensionFuncs;
|
||||
|
||||
extern void __glXHyperpipeInit(int screen, __GLXHyperpipeExtensionFuncs *funcs);
|
||||
|
||||
extern __GLXHyperpipeExtensionFuncs *__glXHyperpipeFuncs;
|
||||
|
||||
typedef struct {
|
||||
int (* bindSwapBarrierFunc)(int, XID, int);
|
||||
int (* queryMaxSwapBarriersFunc)(int);
|
||||
} __GLXSwapBarrierExtensionFuncs;
|
||||
|
||||
extern void __glXSwapBarrierInit(int screen, __GLXSwapBarrierExtensionFuncs *funcs);
|
||||
|
||||
extern __GLXSwapBarrierExtensionFuncs *__glXSwapBarrierFuncs;
|
||||
|
||||
#endif /* _glxext_h_ */
|
||||
|
||||
|
|
|
@ -70,7 +70,7 @@ struct __GLXMESAdrawable {
|
|||
XMesaBuffer xm_buf;
|
||||
};
|
||||
|
||||
static XMesaVisual find_mesa_visual(__GLXscreen *screen, VisualID vid);
|
||||
static XMesaVisual find_mesa_visual(__GLXscreen *screen, XID fbconfigID);
|
||||
|
||||
|
||||
static void
|
||||
|
@ -118,7 +118,7 @@ __glXMesaDrawableSwapBuffers(__GLXdrawable *base)
|
|||
|
||||
static __GLXdrawable *
|
||||
__glXMesaScreenCreateDrawable(__GLXscreen *screen,
|
||||
DrawablePtr pDraw,
|
||||
DrawablePtr pDraw, int type,
|
||||
XID drawId,
|
||||
__GLcontextModes *modes)
|
||||
{
|
||||
|
@ -131,7 +131,8 @@ __glXMesaScreenCreateDrawable(__GLXscreen *screen,
|
|||
|
||||
memset(glxPriv, 0, sizeof *glxPriv);
|
||||
|
||||
if (!__glXDrawableInit(&glxPriv->base, screen, pDraw, drawId, modes)) {
|
||||
if (!__glXDrawableInit(&glxPriv->base, screen,
|
||||
pDraw, type, drawId, modes)) {
|
||||
xfree(glxPriv);
|
||||
return NULL;
|
||||
}
|
||||
|
@ -140,7 +141,7 @@ __glXMesaScreenCreateDrawable(__GLXscreen *screen,
|
|||
glxPriv->base.resize = __glXMesaDrawableResize;
|
||||
glxPriv->base.swapBuffers = __glXMesaDrawableSwapBuffers;
|
||||
|
||||
xm_vis = find_mesa_visual(screen, modes->visualID);
|
||||
xm_vis = find_mesa_visual(screen, modes->fbconfigID);
|
||||
if (xm_vis == NULL) {
|
||||
ErrorF("find_mesa_visual returned NULL for visualID = 0x%04x\n",
|
||||
modes->visualID);
|
||||
|
@ -154,6 +155,11 @@ __glXMesaScreenCreateDrawable(__GLXscreen *screen,
|
|||
glxPriv->xm_buf = XMesaCreatePixmapBuffer(xm_vis, (PixmapPtr)pDraw, 0);
|
||||
}
|
||||
|
||||
if (glxPriv->xm_buf == NULL) {
|
||||
xfree(glxPriv);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return &glxPriv->base;
|
||||
}
|
||||
|
||||
|
@ -234,7 +240,7 @@ __glXMesaScreenCreateContext(__GLXscreen *screen,
|
|||
context->base.copy = __glXMesaContextCopy;
|
||||
context->base.forceCurrent = __glXMesaContextForceCurrent;
|
||||
|
||||
xm_vis = find_mesa_visual(screen, modes->visualID);
|
||||
xm_vis = find_mesa_visual(screen, modes->fbconfigID);
|
||||
if (!xm_vis) {
|
||||
ErrorF("find_mesa_visual returned NULL for visualID = 0x%04x\n",
|
||||
modes->visualID);
|
||||
|
@ -273,107 +279,122 @@ __glXMesaScreenDestroy(__GLXscreen *screen)
|
|||
}
|
||||
|
||||
static XMesaVisual
|
||||
find_mesa_visual(__GLXscreen *screen, VisualID vid)
|
||||
find_mesa_visual(__GLXscreen *screen, XID fbconfigID)
|
||||
{
|
||||
__GLXMESAscreen *mesaScreen = (__GLXMESAscreen *) screen;
|
||||
const __GLcontextModes *modes;
|
||||
unsigned i = 0;
|
||||
|
||||
for ( modes = screen->modes ; modes != NULL ; modes = modes->next ) {
|
||||
if ( modes->visualID == vid ) {
|
||||
break;
|
||||
}
|
||||
|
||||
for (modes = screen->fbconfigs; modes != NULL; modes = modes->next) {
|
||||
if (modes->fbconfigID == fbconfigID)
|
||||
return mesaScreen->xm_vis[i];
|
||||
i++;
|
||||
}
|
||||
|
||||
return (modes != NULL) ? mesaScreen->xm_vis[i] : NULL;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void init_screen_visuals(__GLXMESAscreen *screen)
|
||||
const static int numBack = 2;
|
||||
const static int numDepth = 2;
|
||||
const static int numStencil = 2;
|
||||
|
||||
static __GLcontextModes *
|
||||
createFBConfigsForVisual(__GLXscreen *screen, ScreenPtr pScreen,
|
||||
VisualPtr visual, __GLcontextModes *config)
|
||||
{
|
||||
ScreenPtr pScreen = screen->base.pScreen;
|
||||
__GLcontextModes *modes;
|
||||
XMesaVisual *pXMesaVisual;
|
||||
int *used;
|
||||
int num_vis, j, size;
|
||||
int back, depth, stencil;
|
||||
|
||||
/* Alloc space for the list of XMesa visuals */
|
||||
size = screen->base.numVisuals * sizeof(XMesaVisual);
|
||||
pXMesaVisual = (XMesaVisual *) xalloc(size);
|
||||
memset(pXMesaVisual, 0, size);
|
||||
/* FIXME: Ok, I'm making all this up... anybody has a better idea? */
|
||||
|
||||
/* FIXME: Change 'used' to be a array of bits (rather than of ints),
|
||||
* FIXME: create a stack array of 8 or 16 bytes. If 'numVisuals' is less
|
||||
* FIXME: than 64 or 128 the stack array can be used instead of calling
|
||||
* FIXME: __glXMalloc / __glXFree. If nothing else, convert 'used' to
|
||||
* FIXME: array of bytes instead of ints!
|
||||
*/
|
||||
used = (int *) xalloc(pScreen->numVisuals * sizeof(int));
|
||||
memset(used, 0, pScreen->numVisuals * sizeof(int));
|
||||
for (back = numBack - 1; back >= 0; back--)
|
||||
for (depth = 0; depth < numDepth; depth++)
|
||||
for (stencil = 0; stencil < numStencil; stencil++) {
|
||||
config->visualType = _gl_convert_from_x_visual_type(visual->class);
|
||||
config->xRenderable = GL_TRUE;
|
||||
config->drawableType = GLX_WINDOW_BIT | GLX_PIXMAP_BIT;
|
||||
config->rgbMode = (visual->class >= TrueColor);
|
||||
config->colorIndexMode = !config->rgbMode;
|
||||
config->renderType =
|
||||
(config->rgbMode) ? GLX_RGBA_BIT : GLX_COLOR_INDEX_BIT;
|
||||
config->doubleBufferMode = back;
|
||||
config->haveDepthBuffer = depth;
|
||||
config->depthBits = depth ? visual->nplanes : 0;
|
||||
config->haveStencilBuffer = stencil;
|
||||
config->stencilBits = stencil ? visual->bitsPerRGBValue : 0;
|
||||
config->haveAccumBuffer = 0;
|
||||
|
||||
num_vis = 0;
|
||||
for ( modes = screen->base.modes; modes != NULL; modes = modes->next ) {
|
||||
const int vis_class = _gl_convert_to_x_visual_type( modes->visualType );
|
||||
const int nplanes = (modes->rgbBits - modes->alphaBits);
|
||||
const VisualPtr pVis = pScreen->visuals;
|
||||
config->redBits = Ones(visual->redMask);
|
||||
config->greenBits = Ones(visual->greenMask);
|
||||
config->blueBits = Ones(visual->blueMask);
|
||||
config->alphaBits = 0;
|
||||
config->redMask = visual->redMask;
|
||||
config->greenMask = visual->greenMask;
|
||||
config->blueMask = visual->blueMask;
|
||||
config->alphaMask = 0;
|
||||
config->rgbBits = config->rgbMode ? visual->nplanes : 0;
|
||||
config->indexBits = config->colorIndexMode ? visual->nplanes : 0;
|
||||
config = config->next;
|
||||
}
|
||||
|
||||
for (j = 0; j < pScreen->numVisuals; j++) {
|
||||
if (pVis[j].class == vis_class &&
|
||||
pVis[j].nplanes == nplanes &&
|
||||
pVis[j].redMask == modes->redMask &&
|
||||
pVis[j].greenMask == modes->greenMask &&
|
||||
pVis[j].blueMask == modes->blueMask &&
|
||||
!used[j]) {
|
||||
return config;
|
||||
}
|
||||
|
||||
/* Create the XMesa visual */
|
||||
assert(num_vis < screen->base.numVisuals);
|
||||
pXMesaVisual[num_vis] =
|
||||
XMesaCreateVisual(pScreen,
|
||||
&pVis[j],
|
||||
modes->rgbMode,
|
||||
(modes->alphaBits > 0),
|
||||
modes->doubleBufferMode,
|
||||
modes->stereoMode,
|
||||
GL_TRUE, /* ximage_flag */
|
||||
modes->depthBits,
|
||||
modes->stencilBits,
|
||||
modes->accumRedBits,
|
||||
modes->accumGreenBits,
|
||||
modes->accumBlueBits,
|
||||
modes->accumAlphaBits,
|
||||
modes->samples,
|
||||
modes->level,
|
||||
modes->visualRating);
|
||||
/* Set the VisualID */
|
||||
modes->visualID = pVis[j].vid;
|
||||
static void
|
||||
createFBConfigs(__GLXscreen *pGlxScreen, ScreenPtr pScreen)
|
||||
{
|
||||
__GLcontextModes *configs;
|
||||
int i;
|
||||
|
||||
/* Mark this visual used */
|
||||
used[j] = 1;
|
||||
/* We assume here that each existing visual correspond to a
|
||||
* different visual class. Note, this runs before COMPOSITE adds
|
||||
* its visual, so it's not entirely crazy. */
|
||||
pGlxScreen->numFBConfigs = pScreen->numVisuals * numBack * numDepth * numStencil;
|
||||
pGlxScreen->fbconfigs = _gl_context_modes_create(pGlxScreen->numFBConfigs,
|
||||
sizeof *configs);
|
||||
|
||||
configs = pGlxScreen->fbconfigs;
|
||||
for (i = 0; i < pScreen->numVisuals; i++)
|
||||
configs = createFBConfigsForVisual(pGlxScreen, pScreen,
|
||||
&pScreen->visuals[i], configs);
|
||||
}
|
||||
|
||||
static void
|
||||
createMesaVisuals(__GLXMESAscreen *pMesaScreen)
|
||||
{
|
||||
__GLcontextModes *config;
|
||||
ScreenPtr pScreen;
|
||||
VisualPtr visual;
|
||||
int i, j;
|
||||
|
||||
i = 0;
|
||||
pScreen = pMesaScreen->base.pScreen;
|
||||
pMesaScreen->xm_vis =
|
||||
xcalloc(pMesaScreen->base.numFBConfigs, sizeof (XMesaVisual));
|
||||
for (config = pMesaScreen->base.fbconfigs; config != NULL; config = config->next) {
|
||||
for (j = 0; j < pScreen->numVisuals; j++)
|
||||
if (pScreen->visuals[j].vid == config->visualID) {
|
||||
visual = &pScreen->visuals[j];
|
||||
break;
|
||||
}
|
||||
|
||||
pMesaScreen->xm_vis[i++] =
|
||||
XMesaCreateVisual(pScreen,
|
||||
visual,
|
||||
config->rgbMode,
|
||||
(config->alphaBits > 0),
|
||||
config->doubleBufferMode,
|
||||
config->stereoMode,
|
||||
GL_TRUE, /* ximage_flag */
|
||||
config->depthBits,
|
||||
config->stencilBits,
|
||||
config->accumRedBits,
|
||||
config->accumGreenBits,
|
||||
config->accumBlueBits,
|
||||
config->accumAlphaBits,
|
||||
config->samples,
|
||||
config->level,
|
||||
config->visualRating);
|
||||
}
|
||||
|
||||
if ( j == pScreen->numVisuals ) {
|
||||
ErrorF("No matching visual for __GLcontextMode with "
|
||||
"visual class = %d (%d), nplanes = %u\n",
|
||||
vis_class,
|
||||
modes->visualType,
|
||||
(modes->rgbBits - modes->alphaBits) );
|
||||
}
|
||||
else if ( modes->visualID == -1 ) {
|
||||
FatalError( "Matching visual found, but visualID still -1!\n" );
|
||||
}
|
||||
|
||||
num_vis++;
|
||||
}
|
||||
|
||||
xfree(used);
|
||||
|
||||
screen->num_vis = num_vis;
|
||||
screen->xm_vis = pXMesaVisual;
|
||||
|
||||
assert(screen->num_vis <= screen->base.numVisuals);
|
||||
}
|
||||
|
||||
static __GLXscreen *
|
||||
|
@ -385,19 +406,22 @@ __glXMesaScreenProbe(ScreenPtr pScreen)
|
|||
if (screen == NULL)
|
||||
return NULL;
|
||||
|
||||
/*
|
||||
* Find the GLX visuals that are supported by this screen and create
|
||||
* XMesa's visuals.
|
||||
*/
|
||||
createFBConfigs(&screen->base, pScreen);
|
||||
|
||||
__glXScreenInit(&screen->base, pScreen);
|
||||
|
||||
/* Now that GLX has created the corresponding X visual, create the mesa visuals. */
|
||||
createMesaVisuals(screen);
|
||||
|
||||
screen->base.destroy = __glXMesaScreenDestroy;
|
||||
screen->base.createContext = __glXMesaScreenCreateContext;
|
||||
screen->base.createDrawable = __glXMesaScreenCreateDrawable;
|
||||
screen->base.pScreen = pScreen;
|
||||
|
||||
/*
|
||||
* Find the GLX visuals that are supported by this screen and create
|
||||
* XMesa's visuals.
|
||||
*/
|
||||
init_screen_visuals(screen);
|
||||
|
||||
return &screen->base;
|
||||
}
|
||||
|
||||
|
|
|
@ -40,10 +40,14 @@
|
|||
#include <string.h>
|
||||
#include <windowstr.h>
|
||||
#include <os.h>
|
||||
#include <colormapst.h>
|
||||
|
||||
#include "glxserver.h"
|
||||
#include "glxutil.h"
|
||||
#include "glxext.h"
|
||||
#include "glcontextmodes.h"
|
||||
|
||||
static int glxScreenPrivateIndex;
|
||||
|
||||
const char GLServerVersion[] = "1.4";
|
||||
static const char GLServerExtensions[] =
|
||||
|
@ -179,36 +183,25 @@ static char GLXServerExtensions[] =
|
|||
"GLX_MESA_copy_sub_buffer "
|
||||
;
|
||||
|
||||
__GLXscreen **__glXActiveScreens;
|
||||
|
||||
__GLXSwapBarrierExtensionFuncs *__glXSwapBarrierFuncs = NULL;
|
||||
static int __glXNumSwapBarrierFuncs = 0;
|
||||
__GLXHyperpipeExtensionFuncs *__glXHyperpipeFuncs = NULL;
|
||||
static int __glXNumHyperpipeFuncs = 0;
|
||||
|
||||
__GLXscreen *__glXgetActiveScreen(int num) {
|
||||
return __glXActiveScreens[num];
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** This hook gets called when a window moves or changes size.
|
||||
*/
|
||||
static Bool PositionWindow(WindowPtr pWin, int x, int y)
|
||||
static Bool glxPositionWindow(WindowPtr pWin, int x, int y)
|
||||
{
|
||||
ScreenPtr pScreen;
|
||||
__GLXcontext *glxc;
|
||||
__GLXdrawable *glxPriv;
|
||||
Bool ret;
|
||||
__GLXscreen *pGlxScreen;
|
||||
|
||||
/*
|
||||
** Call wrapped position window routine
|
||||
*/
|
||||
pScreen = pWin->drawable.pScreen;
|
||||
pScreen->PositionWindow =
|
||||
__glXActiveScreens[pScreen->myNum]->WrappedPositionWindow;
|
||||
pGlxScreen = glxGetScreen(pScreen);
|
||||
pScreen->PositionWindow = pGlxScreen->PositionWindow;
|
||||
ret = (*pScreen->PositionWindow)(pWin, x, y);
|
||||
pScreen->PositionWindow = PositionWindow;
|
||||
pScreen->PositionWindow = glxPositionWindow;
|
||||
|
||||
/*
|
||||
** Tell all contexts rendering into this window that the window size
|
||||
|
@ -259,110 +252,299 @@ static Bool PositionWindow(WindowPtr pWin, int x, int y)
|
|||
|
||||
void __glXHyperpipeInit(int screen, __GLXHyperpipeExtensionFuncs *funcs)
|
||||
{
|
||||
if (__glXNumHyperpipeFuncs < screen + 1) {
|
||||
__glXHyperpipeFuncs = xrealloc(__glXHyperpipeFuncs,
|
||||
(screen+1) * sizeof(__GLXHyperpipeExtensionFuncs));
|
||||
__glXNumHyperpipeFuncs = screen + 1;
|
||||
}
|
||||
__GLXscreen *pGlxScreen = glxGetScreen(screenInfo.screens[screen]);
|
||||
|
||||
__glXHyperpipeFuncs[screen].queryHyperpipeNetworkFunc =
|
||||
*funcs->queryHyperpipeNetworkFunc;
|
||||
__glXHyperpipeFuncs[screen].queryHyperpipeConfigFunc =
|
||||
*funcs->queryHyperpipeConfigFunc;
|
||||
__glXHyperpipeFuncs[screen].destroyHyperpipeConfigFunc =
|
||||
*funcs->destroyHyperpipeConfigFunc;
|
||||
__glXHyperpipeFuncs[screen].hyperpipeConfigFunc =
|
||||
*funcs->hyperpipeConfigFunc;
|
||||
pGlxScreen->hyperpipeFuncs = funcs;
|
||||
}
|
||||
|
||||
void __glXSwapBarrierInit(int screen, __GLXSwapBarrierExtensionFuncs *funcs)
|
||||
{
|
||||
if (__glXNumSwapBarrierFuncs < screen + 1) {
|
||||
__glXSwapBarrierFuncs = xrealloc(__glXSwapBarrierFuncs,
|
||||
(screen+1) * sizeof(__GLXSwapBarrierExtensionFuncs));
|
||||
__glXNumSwapBarrierFuncs = screen + 1;
|
||||
__GLXscreen *pGlxScreen = glxGetScreen(screenInfo.screens[screen]);
|
||||
|
||||
pGlxScreen->swapBarrierFuncs = funcs;
|
||||
}
|
||||
|
||||
static Bool
|
||||
glxCloseScreen (int index, ScreenPtr pScreen)
|
||||
{
|
||||
__GLXscreen *pGlxScreen = glxGetScreen(pScreen);
|
||||
|
||||
pScreen->CloseScreen = pGlxScreen->CloseScreen;
|
||||
pScreen->PositionWindow = pGlxScreen->PositionWindow;
|
||||
|
||||
pGlxScreen->destroy(pGlxScreen);
|
||||
|
||||
return pScreen->CloseScreen(index, pScreen);
|
||||
}
|
||||
|
||||
__GLXscreen *
|
||||
glxGetScreen(ScreenPtr pScreen)
|
||||
{
|
||||
return (__GLXscreen *) pScreen->devPrivates[glxScreenPrivateIndex].ptr;
|
||||
}
|
||||
|
||||
void GlxSetVisualConfigs(int nconfigs,
|
||||
__GLXvisualConfig *configs, void **privates)
|
||||
{
|
||||
/* We keep this stub around for the DDX drivers that still
|
||||
* call it. */
|
||||
}
|
||||
|
||||
static XID
|
||||
findVisualForConfig(ScreenPtr pScreen, __GLcontextModes *m)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < pScreen->numVisuals; i++) {
|
||||
if (_gl_convert_to_x_visual_type(m->visualType) == pScreen->visuals[i].class)
|
||||
return pScreen->visuals[i].vid;
|
||||
}
|
||||
|
||||
__glXSwapBarrierFuncs[screen].bindSwapBarrierFunc =
|
||||
funcs->bindSwapBarrierFunc;
|
||||
__glXSwapBarrierFuncs[screen].queryMaxSwapBarriersFunc =
|
||||
funcs->queryMaxSwapBarriersFunc;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static __GLXprovider *__glXProviderStack;
|
||||
/* This code inspired by composite/compinit.c. We could move this to
|
||||
* mi/ and share it with composite.*/
|
||||
|
||||
void GlxPushProvider(__GLXprovider *provider)
|
||||
static VisualPtr
|
||||
AddScreenVisuals(ScreenPtr pScreen, int count, int d)
|
||||
{
|
||||
provider->next = __glXProviderStack;
|
||||
__glXProviderStack = provider;
|
||||
XID *installedCmaps, *vids, vid;
|
||||
int numInstalledCmaps, numVisuals, i, j;
|
||||
VisualPtr visuals;
|
||||
ColormapPtr installedCmap;
|
||||
DepthPtr depth;
|
||||
|
||||
depth = NULL;
|
||||
for (i = 0; i < pScreen->numDepths; i++) {
|
||||
if (pScreen->allowedDepths[i].depth == d) {
|
||||
depth = &pScreen->allowedDepths[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (depth == NULL)
|
||||
return NULL;
|
||||
|
||||
/* Find the installed colormaps */
|
||||
installedCmaps = xalloc (pScreen->maxInstalledCmaps * sizeof (XID));
|
||||
if (!installedCmaps)
|
||||
return NULL;
|
||||
|
||||
numInstalledCmaps = pScreen->ListInstalledColormaps(pScreen, installedCmaps);
|
||||
|
||||
/* realloc the visual array to fit the new one in place */
|
||||
numVisuals = pScreen->numVisuals;
|
||||
visuals = xrealloc(pScreen->visuals, (numVisuals + count) * sizeof(VisualRec));
|
||||
if (!visuals) {
|
||||
xfree(installedCmaps);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
vids = xrealloc(depth->vids, (depth->numVids + count) * sizeof(XID));
|
||||
if (vids == NULL) {
|
||||
xfree(installedCmaps);
|
||||
xfree(visuals);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
* Fix up any existing installed colormaps -- we'll assume that
|
||||
* the only ones created so far have been installed. If this
|
||||
* isn't true, we'll have to walk the resource database looking
|
||||
* for all colormaps.
|
||||
*/
|
||||
for (i = 0; i < numInstalledCmaps; i++) {
|
||||
installedCmap = LookupIDByType (installedCmaps[i], RT_COLORMAP);
|
||||
if (!installedCmap)
|
||||
continue;
|
||||
j = installedCmap->pVisual - pScreen->visuals;
|
||||
installedCmap->pVisual = &visuals[j];
|
||||
}
|
||||
|
||||
xfree(installedCmaps);
|
||||
|
||||
for (i = 0; i < count; i++) {
|
||||
vid = FakeClientID(0);
|
||||
visuals[pScreen->numVisuals + i].vid = vid;
|
||||
vids[depth->numVids + i] = vid;
|
||||
}
|
||||
|
||||
pScreen->visuals = visuals;
|
||||
pScreen->numVisuals += count;
|
||||
depth->vids = vids;
|
||||
depth->numVids += count;
|
||||
|
||||
/* Return a pointer to the first of the added visuals. */
|
||||
return pScreen->visuals + pScreen->numVisuals - count;
|
||||
}
|
||||
|
||||
void __glXScreenInit(__GLXscreen *screen, ScreenPtr pScreen)
|
||||
static int
|
||||
findFirstSet(unsigned int v)
|
||||
{
|
||||
screen->pScreen = pScreen;
|
||||
screen->GLextensions = xstrdup(GLServerExtensions);
|
||||
screen->GLXvendor = xstrdup(GLXServerVendorName);
|
||||
screen->GLXversion = xstrdup(GLXServerVersion);
|
||||
screen->GLXextensions = xstrdup(GLXServerExtensions);
|
||||
int i;
|
||||
|
||||
screen->WrappedPositionWindow = pScreen->PositionWindow;
|
||||
pScreen->PositionWindow = PositionWindow;
|
||||
for (i = 0; i < 32; i++)
|
||||
if (v & (1 << i))
|
||||
return i;
|
||||
|
||||
__glXScreenInitVisuals(screen);
|
||||
return -1;
|
||||
}
|
||||
|
||||
void
|
||||
__glXScreenDestroy(__GLXscreen *screen)
|
||||
static void
|
||||
initGlxVisual(VisualPtr visual, __GLcontextModes *config)
|
||||
{
|
||||
config->visualID = visual->vid;
|
||||
visual->class = _gl_convert_to_x_visual_type(config->visualType);
|
||||
visual->bitsPerRGBValue = config->redBits;
|
||||
visual->ColormapEntries = 1 << config->redBits;
|
||||
visual->nplanes = config->redBits + config->greenBits + config->blueBits;
|
||||
|
||||
visual->redMask = config->redMask;
|
||||
visual->greenMask = config->greenMask;
|
||||
visual->blueMask = config->blueMask;
|
||||
visual->offsetRed = findFirstSet(config->redMask);
|
||||
visual->offsetGreen = findFirstSet(config->greenMask);
|
||||
visual->offsetBlue = findFirstSet(config->blueMask);
|
||||
}
|
||||
|
||||
static void
|
||||
addMinimalSet(__GLXscreen *pGlxScreen)
|
||||
{
|
||||
__GLcontextModes *config;
|
||||
VisualPtr visuals;
|
||||
int depth;
|
||||
|
||||
for (config = pGlxScreen->fbconfigs; config != NULL; config = config->next) {
|
||||
if (config->visualRating != GLX_NONE)
|
||||
continue;
|
||||
if (config->doubleBufferMode && config->depthBits > 0)
|
||||
break;
|
||||
}
|
||||
if (config == NULL)
|
||||
config = pGlxScreen->fbconfigs;
|
||||
|
||||
pGlxScreen->visuals = xcalloc(1, sizeof (__GLcontextModes *));
|
||||
if (pGlxScreen->visuals == NULL) {
|
||||
ErrorF("Failed to allocate for minimal set of GLX visuals\n");
|
||||
return;
|
||||
}
|
||||
|
||||
depth = config->redBits + config->greenBits + config->blueBits;
|
||||
visuals = AddScreenVisuals(pGlxScreen->pScreen, 1, depth);
|
||||
if (visuals == NULL) {
|
||||
xfree(pGlxScreen->visuals);
|
||||
return;
|
||||
}
|
||||
|
||||
pGlxScreen->numVisuals = 1;
|
||||
pGlxScreen->visuals[0] = config;
|
||||
initGlxVisual(&visuals[0], config);
|
||||
}
|
||||
|
||||
static void
|
||||
addTypicalSet(__GLXscreen *pGlxScreen)
|
||||
{
|
||||
addMinimalSet(pGlxScreen);
|
||||
}
|
||||
|
||||
static void
|
||||
addFullSet(__GLXscreen *pGlxScreen)
|
||||
{
|
||||
__GLcontextModes *config;
|
||||
VisualPtr visuals;
|
||||
int i, depth;
|
||||
|
||||
pGlxScreen->visuals =
|
||||
xcalloc(pGlxScreen->numFBConfigs, sizeof (__GLcontextModes *));
|
||||
if (pGlxScreen->visuals == NULL) {
|
||||
ErrorF("Failed to allocate for full set of GLX visuals\n");
|
||||
return;
|
||||
}
|
||||
|
||||
config = pGlxScreen->fbconfigs;
|
||||
depth = config->redBits + config->greenBits + config->blueBits;
|
||||
visuals = AddScreenVisuals(pGlxScreen->pScreen, pGlxScreen->numFBConfigs, depth);
|
||||
if (visuals == NULL) {
|
||||
xfree(pGlxScreen->visuals);
|
||||
return;
|
||||
}
|
||||
|
||||
pGlxScreen->numVisuals = pGlxScreen->numFBConfigs;
|
||||
for (i = 0, config = pGlxScreen->fbconfigs; config; config = config->next, i++) {
|
||||
pGlxScreen->visuals[i] = config;
|
||||
initGlxVisual(&visuals[i], config);
|
||||
}
|
||||
}
|
||||
|
||||
static int glxVisualConfig = GLX_ALL_VISUALS;
|
||||
|
||||
void GlxSetVisualConfig(int config)
|
||||
{
|
||||
glxVisualConfig = config;
|
||||
}
|
||||
|
||||
void __glXScreenInit(__GLXscreen *pGlxScreen, ScreenPtr pScreen)
|
||||
{
|
||||
static int glxGeneration;
|
||||
__GLcontextModes *m;
|
||||
int i;
|
||||
|
||||
if (glxGeneration != serverGeneration)
|
||||
{
|
||||
glxScreenPrivateIndex = AllocateScreenPrivateIndex ();
|
||||
if (glxScreenPrivateIndex == -1)
|
||||
return;
|
||||
|
||||
glxGeneration = serverGeneration;
|
||||
}
|
||||
|
||||
pGlxScreen->pScreen = pScreen;
|
||||
pGlxScreen->GLextensions = xstrdup(GLServerExtensions);
|
||||
pGlxScreen->GLXvendor = xstrdup(GLXServerVendorName);
|
||||
pGlxScreen->GLXversion = xstrdup(GLXServerVersion);
|
||||
pGlxScreen->GLXextensions = xstrdup(GLXServerExtensions);
|
||||
|
||||
pGlxScreen->PositionWindow = pScreen->PositionWindow;
|
||||
pScreen->PositionWindow = glxPositionWindow;
|
||||
|
||||
pGlxScreen->CloseScreen = pScreen->CloseScreen;
|
||||
pScreen->CloseScreen = glxCloseScreen;
|
||||
|
||||
i = 0;
|
||||
for (m = pGlxScreen->fbconfigs; m != NULL; m = m->next) {
|
||||
m->fbconfigID = FakeClientID(0);
|
||||
m->visualID = findVisualForConfig(pScreen, m);
|
||||
ErrorF("mapping fbconfig id 0x%02lx to visual id 0x%02lx\n",
|
||||
m->fbconfigID, m->visualID);
|
||||
i++;
|
||||
}
|
||||
pGlxScreen->numFBConfigs = i;
|
||||
|
||||
/* Select a subset of fbconfigs that we send to the client when it
|
||||
* asks for the glx visuals. All the fbconfigs here have a valid
|
||||
* value for visual ID and each visual ID is only present once.
|
||||
* This runs before composite adds its extra visual so we have to
|
||||
* remember the number of visuals here.*/
|
||||
|
||||
switch (glxVisualConfig) {
|
||||
case GLX_MINIMAL_VISUALS:
|
||||
addMinimalSet(pGlxScreen);
|
||||
break;
|
||||
case GLX_TYPICAL_VISUALS:
|
||||
addTypicalSet(pGlxScreen);
|
||||
break;
|
||||
case GLX_ALL_VISUALS:
|
||||
addFullSet(pGlxScreen);
|
||||
break;
|
||||
}
|
||||
|
||||
pScreen->devPrivates[glxScreenPrivateIndex].ptr = (pointer) pGlxScreen;
|
||||
}
|
||||
|
||||
void __glXScreenDestroy(__GLXscreen *screen)
|
||||
{
|
||||
xfree(screen->GLXvendor);
|
||||
xfree(screen->GLXversion);
|
||||
xfree(screen->GLXextensions);
|
||||
xfree(screen->GLextensions);
|
||||
}
|
||||
|
||||
void __glXInitScreens(void)
|
||||
{
|
||||
GLint i;
|
||||
ScreenPtr pScreen;
|
||||
__GLXprovider *p;
|
||||
size_t size;
|
||||
|
||||
/*
|
||||
** This alloc has to work or else the server might as well core dump.
|
||||
*/
|
||||
size = screenInfo.numScreens * sizeof(__GLXscreen *);
|
||||
__glXActiveScreens = xalloc(size);
|
||||
memset(__glXActiveScreens, 0, size);
|
||||
|
||||
for (i = 0; i < screenInfo.numScreens; i++) {
|
||||
pScreen = screenInfo.screens[i];
|
||||
|
||||
for (p = __glXProviderStack; p != NULL; p = p->next) {
|
||||
__glXActiveScreens[i] = p->screenProbe(pScreen);
|
||||
if (__glXActiveScreens[i] != NULL) {
|
||||
LogMessage(X_INFO,
|
||||
"GLX: Initialized %s GL provider for screen %d\n",
|
||||
p->name, i);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void __glXResetScreens(void)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < screenInfo.numScreens; i++)
|
||||
if (__glXActiveScreens[i])
|
||||
__glXActiveScreens[i]->destroy(__glXActiveScreens[i]);
|
||||
|
||||
xfree(__glXActiveScreens);
|
||||
xfree(__glXHyperpipeFuncs);
|
||||
xfree(__glXSwapBarrierFuncs);
|
||||
__glXNumHyperpipeFuncs = 0;
|
||||
__glXNumSwapBarrierFuncs = 0;
|
||||
__glXHyperpipeFuncs = NULL;
|
||||
__glXSwapBarrierFuncs = NULL;
|
||||
__glXActiveScreens = NULL;
|
||||
}
|
||||
|
|
|
@ -42,6 +42,21 @@
|
|||
|
||||
#include "GL/internal/glcore.h"
|
||||
|
||||
typedef struct {
|
||||
void * (* queryHyperpipeNetworkFunc)(int, int *, int *);
|
||||
void * (* queryHyperpipeConfigFunc)(int, int, int *, int *);
|
||||
int (* destroyHyperpipeConfigFunc)(int, int);
|
||||
void * (* hyperpipeConfigFunc)(int, int, int *, int *, void *);
|
||||
} __GLXHyperpipeExtensionFuncs;
|
||||
|
||||
typedef struct {
|
||||
int (* bindSwapBarrierFunc)(int, XID, int);
|
||||
int (* queryMaxSwapBarriersFunc)(int);
|
||||
} __GLXSwapBarrierExtensionFuncs;
|
||||
|
||||
void __glXHyperpipeInit(int screen, __GLXHyperpipeExtensionFuncs *funcs);
|
||||
void __glXSwapBarrierInit(int screen, __GLXSwapBarrierExtensionFuncs *funcs);
|
||||
|
||||
/*
|
||||
** Screen dependent data. These methods are the interface between the DIX
|
||||
** and DDX layers of the GLX server extension. The methods provide an
|
||||
|
@ -57,21 +72,24 @@ struct __GLXscreen {
|
|||
|
||||
__GLXdrawable *(*createDrawable)(__GLXscreen *context,
|
||||
DrawablePtr pDraw,
|
||||
int type,
|
||||
XID drawId,
|
||||
__GLcontextModes *modes);
|
||||
int (*swapInterval) (__GLXdrawable *drawable,
|
||||
int interval);
|
||||
|
||||
__GLXHyperpipeExtensionFuncs *hyperpipeFuncs;
|
||||
__GLXSwapBarrierExtensionFuncs *swapBarrierFuncs;
|
||||
|
||||
ScreenPtr pScreen;
|
||||
|
||||
/**
|
||||
* Linked list of valid context modes for this screen.
|
||||
*/
|
||||
__GLcontextModes *modes;
|
||||
/* Linked list of valid fbconfigs for this screen. */
|
||||
__GLcontextModes *fbconfigs;
|
||||
int numFBConfigs;
|
||||
|
||||
void **pVisualPriv;
|
||||
/* Subset of fbconfigs that are exposed as GLX visuals. */
|
||||
__GLcontextModes **visuals;
|
||||
GLint numVisuals;
|
||||
GLint numUsableVisuals;
|
||||
|
||||
char *GLextensions;
|
||||
|
||||
|
@ -79,18 +97,12 @@ struct __GLXscreen {
|
|||
char *GLXversion;
|
||||
char *GLXextensions;
|
||||
|
||||
/*
|
||||
** Things that are not statically set.
|
||||
*/
|
||||
Bool (*WrappedPositionWindow)(WindowPtr pWin, int x, int y);
|
||||
|
||||
Bool (*PositionWindow)(WindowPtr pWin, int x, int y);
|
||||
Bool (*CloseScreen)(int index, ScreenPtr pScreen);
|
||||
};
|
||||
|
||||
|
||||
void __glXScreenInit(__GLXscreen *screen, ScreenPtr pScreen);
|
||||
void __glXScreenDestroy(__GLXscreen *screen);
|
||||
|
||||
void __glXInitScreens(void);
|
||||
extern void __glXResetScreens(void);
|
||||
|
||||
#endif /* !__GLX_screens_h__ */
|
||||
|
|
|
@ -90,12 +90,13 @@ typedef XID GLXDrawable;
|
|||
|
||||
typedef struct __GLXclientStateRec __GLXclientState;
|
||||
|
||||
extern __GLXscreen **__glXActiveScreens;
|
||||
extern GLint __glXNumActiveScreens;
|
||||
extern __GLXscreen *__glXgetActiveScreen(int num);
|
||||
extern __GLXscreen *glxGetScreen(ScreenPtr pScreen);
|
||||
extern __GLXclientState *glxGetClient(ClientPtr pClient);
|
||||
|
||||
/************************************************************************/
|
||||
|
||||
void GlxExtensionInit(void);
|
||||
|
||||
void GlxSetVisualConfigs(int nconfigs,
|
||||
__GLXvisualConfig *configs, void **privates);
|
||||
|
||||
|
@ -133,6 +134,14 @@ struct __GLXprovider {
|
|||
|
||||
void GlxPushProvider(__GLXprovider *provider);
|
||||
|
||||
enum {
|
||||
GLX_MINIMAL_VISUALS,
|
||||
GLX_TYPICAL_VISUALS,
|
||||
GLX_ALL_VISUALS
|
||||
};
|
||||
|
||||
void GlxSetVisualConfig(int config);
|
||||
|
||||
void __glXsetEnterLeaveServerFuncs(void (*enter)(GLboolean),
|
||||
void (*leave)(GLboolean));
|
||||
void __glXenterServer(GLboolean rendering);
|
||||
|
|
|
@ -139,18 +139,15 @@ __glXUnrefDrawable(__GLXdrawable *glxPriv)
|
|||
|
||||
GLboolean
|
||||
__glXDrawableInit(__GLXdrawable *drawable,
|
||||
__GLXscreen *screen, DrawablePtr pDraw, XID drawId,
|
||||
__GLcontextModes *modes)
|
||||
__GLXscreen *screen, DrawablePtr pDraw, int type,
|
||||
XID drawId, __GLcontextModes *modes)
|
||||
{
|
||||
drawable->type = pDraw->type;
|
||||
drawable->pDraw = pDraw;
|
||||
drawable->type = type;
|
||||
drawable->drawId = drawId;
|
||||
drawable->refCount = 1;
|
||||
drawable->modes = modes;
|
||||
|
||||
/* if not a pixmap, lookup will fail, so pGlxPixmap will be NULL */
|
||||
drawable->pGlxPixmap = (__GLXpixmap *)
|
||||
LookupIDByType(drawId, __glXPixmapRes);
|
||||
drawable->eventMask = 0;
|
||||
|
||||
return GL_TRUE;
|
||||
}
|
||||
|
|
|
@ -50,7 +50,7 @@ extern void __glXUnrefDrawable(__GLXdrawable *glxPriv);
|
|||
|
||||
extern GLboolean __glXDrawableInit(__GLXdrawable *drawable,
|
||||
__GLXscreen *screen,
|
||||
DrawablePtr pDraw, XID drawID,
|
||||
DrawablePtr pDraw, int type, XID drawID,
|
||||
__GLcontextModes *modes);
|
||||
|
||||
/* context helper routines */
|
||||
|
|
|
@ -1,518 +0,0 @@
|
|||
/*
|
||||
* Copyright © 2006 Red Hat, Inc.
|
||||
* (C) Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a
|
||||
* copy of this software and associated documentation files (the "Software"),
|
||||
* to deal in the Software without restriction, including without limitation
|
||||
* the rights to use, copy, modify, merge, publish, distribute, sub license,
|
||||
* and/or sell copies of the Software, and to permit persons to whom the
|
||||
* Software is furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice (including the next
|
||||
* paragraph) shall be included in all copies or substantial portions of the
|
||||
* Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
|
||||
* RED HAT, INC, OR PRECISION INSIGHT AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY
|
||||
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT
|
||||
* OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
|
||||
* THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Authors:
|
||||
* Kevin E. Martin <kevin@precisioninsight.com>
|
||||
* Brian Paul <brian@precisioninsight.com>
|
||||
* Kristian Høgsberg <krh@redhat.com>
|
||||
*
|
||||
*/
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <assert.h>
|
||||
#include <string.h>
|
||||
#include <regionstr.h>
|
||||
#include <resource.h>
|
||||
#include <GL/gl.h>
|
||||
#include <GL/glxint.h>
|
||||
#include <GL/glxtokens.h>
|
||||
#include <GL/internal/glcore.h>
|
||||
#include <scrnintstr.h>
|
||||
#include <config.h>
|
||||
#include <glxserver.h>
|
||||
#include <glxscreens.h>
|
||||
#include <glxdrawable.h>
|
||||
#include <glxcontext.h>
|
||||
#include <glxext.h>
|
||||
#include <glxutil.h>
|
||||
#include <micmap.h>
|
||||
|
||||
void GlxWrapInitVisuals(miInitVisualsProcPtr *);
|
||||
|
||||
#include "glcontextmodes.h"
|
||||
|
||||
struct ScreenVisualsRec {
|
||||
int num_vis;
|
||||
void *private;
|
||||
__GLcontextModes *modes;
|
||||
};
|
||||
typedef struct ScreenVisualsRec ScreenVisuals;
|
||||
|
||||
static ScreenVisuals screenVisuals[MAXSCREENS];
|
||||
|
||||
static int numConfigs = 0;
|
||||
static __GLXvisualConfig *visualConfigs = NULL;
|
||||
static void **visualPrivates = NULL;
|
||||
|
||||
static int count_bits(unsigned int n)
|
||||
{
|
||||
int bits = 0;
|
||||
|
||||
while (n > 0) {
|
||||
if (n & 1) bits++;
|
||||
n >>= 1;
|
||||
}
|
||||
return bits;
|
||||
}
|
||||
|
||||
/*
|
||||
* In the case the driver defines no GLX visuals we'll use these.
|
||||
* Note that for TrueColor and DirectColor visuals, bufferSize is the
|
||||
* sum of redSize, greenSize, blueSize and alphaSize, which may be larger
|
||||
* than the nplanes/rootDepth of the server's X11 visuals
|
||||
*/
|
||||
#define NUM_FALLBACK_CONFIGS 5
|
||||
static __GLXvisualConfig FallbackConfigs[NUM_FALLBACK_CONFIGS] = {
|
||||
/* [0] = RGB, double buffered, Z */
|
||||
{
|
||||
-1, /* vid */
|
||||
-1, /* class */
|
||||
True, /* rgba */
|
||||
-1, -1, -1, 0, /* rgba sizes */
|
||||
-1, -1, -1, 0, /* rgba masks */
|
||||
0, 0, 0, 0, /* rgba accum sizes */
|
||||
True, /* doubleBuffer */
|
||||
False, /* stereo */
|
||||
-1, /* bufferSize */
|
||||
16, /* depthSize */
|
||||
0, /* stencilSize */
|
||||
0, /* auxBuffers */
|
||||
0, /* level */
|
||||
GLX_NONE, /* visualRating */
|
||||
GLX_NONE, /* transparentPixel */
|
||||
0, 0, 0, 0, /* transparent rgba color (floats scaled to ints) */
|
||||
0 /* transparentIndex */
|
||||
},
|
||||
/* [1] = RGB, double buffered, Z, stencil, accum */
|
||||
{
|
||||
-1, /* vid */
|
||||
-1, /* class */
|
||||
True, /* rgba */
|
||||
-1, -1, -1, 0, /* rgba sizes */
|
||||
-1, -1, -1, 0, /* rgba masks */
|
||||
16, 16, 16, 0, /* rgba accum sizes */
|
||||
True, /* doubleBuffer */
|
||||
False, /* stereo */
|
||||
-1, /* bufferSize */
|
||||
16, /* depthSize */
|
||||
8, /* stencilSize */
|
||||
0, /* auxBuffers */
|
||||
0, /* level */
|
||||
GLX_NONE, /* visualRating */
|
||||
GLX_NONE, /* transparentPixel */
|
||||
0, 0, 0, 0, /* transparent rgba color (floats scaled to ints) */
|
||||
0 /* transparentIndex */
|
||||
},
|
||||
/* [2] = RGB+Alpha, double buffered, Z, stencil, accum */
|
||||
{
|
||||
-1, /* vid */
|
||||
-1, /* class */
|
||||
True, /* rgba */
|
||||
-1, -1, -1, 8, /* rgba sizes */
|
||||
-1, -1, -1, -1, /* rgba masks */
|
||||
16, 16, 16, 16, /* rgba accum sizes */
|
||||
True, /* doubleBuffer */
|
||||
False, /* stereo */
|
||||
-1, /* bufferSize */
|
||||
16, /* depthSize */
|
||||
8, /* stencilSize */
|
||||
0, /* auxBuffers */
|
||||
0, /* level */
|
||||
GLX_NONE, /* visualRating */
|
||||
GLX_NONE, /* transparentPixel */
|
||||
0, 0, 0, 0, /* transparent rgba color (floats scaled to ints) */
|
||||
0 /* transparentIndex */
|
||||
},
|
||||
/* [3] = RGB+Alpha, single buffered, Z, stencil, accum */
|
||||
{
|
||||
-1, /* vid */
|
||||
-1, /* class */
|
||||
True, /* rgba */
|
||||
-1, -1, -1, 8, /* rgba sizes */
|
||||
-1, -1, -1, -1, /* rgba masks */
|
||||
16, 16, 16, 16, /* rgba accum sizes */
|
||||
False, /* doubleBuffer */
|
||||
False, /* stereo */
|
||||
-1, /* bufferSize */
|
||||
16, /* depthSize */
|
||||
8, /* stencilSize */
|
||||
0, /* auxBuffers */
|
||||
0, /* level */
|
||||
GLX_NONE, /* visualRating */
|
||||
GLX_NONE, /* transparentPixel */
|
||||
0, 0, 0, 0, /* transparent rgba color (floats scaled to ints) */
|
||||
0 /* transparentIndex */
|
||||
},
|
||||
/* [4] = CI, double buffered, Z */
|
||||
{
|
||||
-1, /* vid */
|
||||
-1, /* class */
|
||||
False, /* rgba? (false = color index) */
|
||||
-1, -1, -1, 0, /* rgba sizes */
|
||||
-1, -1, -1, 0, /* rgba masks */
|
||||
0, 0, 0, 0, /* rgba accum sizes */
|
||||
True, /* doubleBuffer */
|
||||
False, /* stereo */
|
||||
-1, /* bufferSize */
|
||||
16, /* depthSize */
|
||||
0, /* stencilSize */
|
||||
0, /* auxBuffers */
|
||||
0, /* level */
|
||||
GLX_NONE, /* visualRating */
|
||||
GLX_NONE, /* transparentPixel */
|
||||
0, 0, 0, 0, /* transparent rgba color (floats scaled to ints) */
|
||||
0 /* transparentIndex */
|
||||
},
|
||||
};
|
||||
|
||||
|
||||
static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
|
||||
VisualID *defaultVisp,
|
||||
int ndepth, DepthPtr pdepth,
|
||||
int rootDepth)
|
||||
{
|
||||
int numRGBconfigs;
|
||||
int numCIconfigs;
|
||||
int numVisuals = *nvisualp;
|
||||
int numNewVisuals;
|
||||
int numNewConfigs;
|
||||
VisualPtr pVisual = *visualp;
|
||||
VisualPtr pVisualNew = NULL;
|
||||
VisualID *orig_vid = NULL;
|
||||
__GLcontextModes *modes;
|
||||
__GLXvisualConfig *pNewVisualConfigs = NULL;
|
||||
void **glXVisualPriv;
|
||||
void **pNewVisualPriv;
|
||||
int found_default;
|
||||
int i, j, k;
|
||||
|
||||
if (numConfigs > 0)
|
||||
numNewConfigs = numConfigs;
|
||||
else
|
||||
numNewConfigs = NUM_FALLBACK_CONFIGS;
|
||||
|
||||
/* Alloc space for the list of new GLX visuals */
|
||||
pNewVisualConfigs = (__GLXvisualConfig *)
|
||||
xalloc(numNewConfigs * sizeof(__GLXvisualConfig));
|
||||
if (!pNewVisualConfigs) {
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/* Alloc space for the list of new GLX visual privates */
|
||||
pNewVisualPriv = (void **) xalloc(numNewConfigs * sizeof(void *));
|
||||
if (!pNewVisualPriv) {
|
||||
xfree(pNewVisualConfigs);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/*
|
||||
** If SetVisualConfigs was not called, then use default GLX
|
||||
** visual configs.
|
||||
*/
|
||||
if (numConfigs == 0) {
|
||||
memcpy(pNewVisualConfigs, FallbackConfigs,
|
||||
NUM_FALLBACK_CONFIGS * sizeof(__GLXvisualConfig));
|
||||
memset(pNewVisualPriv, 0, NUM_FALLBACK_CONFIGS * sizeof(void *));
|
||||
}
|
||||
else {
|
||||
/* copy driver's visual config info */
|
||||
for (i = 0; i < numConfigs; i++) {
|
||||
pNewVisualConfigs[i] = visualConfigs[i];
|
||||
pNewVisualPriv[i] = visualPrivates[i];
|
||||
}
|
||||
}
|
||||
|
||||
/* Count the number of RGB and CI visual configs */
|
||||
numRGBconfigs = 0;
|
||||
numCIconfigs = 0;
|
||||
for (i = 0; i < numNewConfigs; i++) {
|
||||
if (pNewVisualConfigs[i].rgba)
|
||||
numRGBconfigs++;
|
||||
else
|
||||
numCIconfigs++;
|
||||
}
|
||||
|
||||
/* Count the total number of visuals to compute */
|
||||
numNewVisuals = 0;
|
||||
for (i = 0; i < numVisuals; i++) {
|
||||
numNewVisuals +=
|
||||
(pVisual[i].class == TrueColor || pVisual[i].class == DirectColor)
|
||||
? numRGBconfigs : numCIconfigs;
|
||||
}
|
||||
|
||||
/* Reset variables for use with the next screen/driver's visual configs */
|
||||
visualConfigs = NULL;
|
||||
numConfigs = 0;
|
||||
|
||||
/* Alloc temp space for the list of orig VisualIDs for each new visual */
|
||||
orig_vid = (VisualID *) xalloc(numNewVisuals * sizeof(VisualID));
|
||||
if (!orig_vid) {
|
||||
xfree(pNewVisualPriv);
|
||||
xfree(pNewVisualConfigs);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/* Alloc space for the list of glXVisuals */
|
||||
modes = _gl_context_modes_create(numNewVisuals, sizeof(__GLcontextModes));
|
||||
if (modes == NULL) {
|
||||
xfree(orig_vid);
|
||||
xfree(pNewVisualPriv);
|
||||
xfree(pNewVisualConfigs);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/* Alloc space for the list of glXVisualPrivates */
|
||||
glXVisualPriv = (void **)xalloc(numNewVisuals * sizeof(void *));
|
||||
if (!glXVisualPriv) {
|
||||
_gl_context_modes_destroy( modes );
|
||||
xfree(orig_vid);
|
||||
xfree(pNewVisualPriv);
|
||||
xfree(pNewVisualConfigs);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/* Alloc space for the new list of the X server's visuals */
|
||||
pVisualNew = (VisualPtr)xalloc(numNewVisuals * sizeof(VisualRec));
|
||||
if (!pVisualNew) {
|
||||
xfree(glXVisualPriv);
|
||||
_gl_context_modes_destroy( modes );
|
||||
xfree(orig_vid);
|
||||
xfree(pNewVisualPriv);
|
||||
xfree(pNewVisualConfigs);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/* Initialize the new visuals */
|
||||
found_default = FALSE;
|
||||
screenVisuals[screenInfo.numScreens-1].modes = modes;
|
||||
for (i = j = 0; i < numVisuals; i++) {
|
||||
int is_rgb = (pVisual[i].class == TrueColor ||
|
||||
pVisual[i].class == DirectColor);
|
||||
|
||||
for (k = 0; k < numNewConfigs; k++) {
|
||||
if (pNewVisualConfigs[k].rgba != is_rgb)
|
||||
continue;
|
||||
|
||||
assert( modes != NULL );
|
||||
|
||||
/* Initialize the new visual */
|
||||
pVisualNew[j] = pVisual[i];
|
||||
pVisualNew[j].vid = FakeClientID(0);
|
||||
|
||||
/* Check for the default visual */
|
||||
if (!found_default && pVisual[i].vid == *defaultVisp) {
|
||||
*defaultVisp = pVisualNew[j].vid;
|
||||
found_default = TRUE;
|
||||
}
|
||||
|
||||
/* Save the old VisualID */
|
||||
orig_vid[j] = pVisual[i].vid;
|
||||
|
||||
/* Initialize the glXVisual */
|
||||
_gl_copy_visual_to_context_mode( modes, & pNewVisualConfigs[k] );
|
||||
modes->visualID = pVisualNew[j].vid;
|
||||
if (modes->fbconfigID == GLX_DONT_CARE)
|
||||
modes->fbconfigID = modes->visualID;
|
||||
|
||||
/*
|
||||
* If the class is -1, then assume the X visual information
|
||||
* is identical to what GLX needs, and take them from the X
|
||||
* visual. NOTE: if class != -1, then all other fields MUST
|
||||
* be initialized.
|
||||
*/
|
||||
if (modes->visualType == GLX_NONE) {
|
||||
modes->visualType = _gl_convert_from_x_visual_type( pVisual[i].class );
|
||||
modes->redBits = count_bits(pVisual[i].redMask);
|
||||
modes->greenBits = count_bits(pVisual[i].greenMask);
|
||||
modes->blueBits = count_bits(pVisual[i].blueMask);
|
||||
modes->alphaBits = modes->alphaBits;
|
||||
modes->redMask = pVisual[i].redMask;
|
||||
modes->greenMask = pVisual[i].greenMask;
|
||||
modes->blueMask = pVisual[i].blueMask;
|
||||
modes->alphaMask = modes->alphaMask;
|
||||
modes->rgbBits = (is_rgb)
|
||||
? (modes->redBits + modes->greenBits +
|
||||
modes->blueBits + modes->alphaBits)
|
||||
: rootDepth;
|
||||
}
|
||||
|
||||
/* Save the device-dependent private for this visual */
|
||||
glXVisualPriv[j] = pNewVisualPriv[k];
|
||||
|
||||
j++;
|
||||
modes = modes->next;
|
||||
}
|
||||
}
|
||||
|
||||
assert(j <= numNewVisuals);
|
||||
|
||||
/* Save the GLX visuals in the screen structure */
|
||||
screenVisuals[screenInfo.numScreens-1].num_vis = numNewVisuals;
|
||||
screenVisuals[screenInfo.numScreens-1].private = glXVisualPriv;
|
||||
|
||||
/* Set up depth's VisualIDs */
|
||||
for (i = 0; i < ndepth; i++) {
|
||||
int numVids = 0;
|
||||
VisualID *pVids = NULL;
|
||||
int k, n = 0;
|
||||
|
||||
/* Count the new number of VisualIDs at this depth */
|
||||
for (j = 0; j < pdepth[i].numVids; j++)
|
||||
for (k = 0; k < numNewVisuals; k++)
|
||||
if (pdepth[i].vids[j] == orig_vid[k])
|
||||
numVids++;
|
||||
|
||||
/* Allocate a new list of VisualIDs for this depth */
|
||||
pVids = (VisualID *)xalloc(numVids * sizeof(VisualID));
|
||||
|
||||
/* Initialize the new list of VisualIDs for this depth */
|
||||
for (j = 0; j < pdepth[i].numVids; j++)
|
||||
for (k = 0; k < numNewVisuals; k++)
|
||||
if (pdepth[i].vids[j] == orig_vid[k])
|
||||
pVids[n++] = pVisualNew[k].vid;
|
||||
|
||||
/* Update this depth's list of VisualIDs */
|
||||
xfree(pdepth[i].vids);
|
||||
pdepth[i].vids = pVids;
|
||||
pdepth[i].numVids = numVids;
|
||||
}
|
||||
|
||||
/* Update the X server's visuals */
|
||||
*nvisualp = numNewVisuals;
|
||||
*visualp = pVisualNew;
|
||||
|
||||
/* Free the old list of the X server's visuals */
|
||||
xfree(pVisual);
|
||||
|
||||
/* Clean up temporary allocations */
|
||||
xfree(orig_vid);
|
||||
xfree(pNewVisualPriv);
|
||||
xfree(pNewVisualConfigs);
|
||||
|
||||
/* Free the private list created by DDX HW driver */
|
||||
if (visualPrivates)
|
||||
xfree(visualPrivates);
|
||||
visualPrivates = NULL;
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
void GlxSetVisualConfigs(int nconfigs,
|
||||
__GLXvisualConfig *configs, void **privates)
|
||||
{
|
||||
numConfigs = nconfigs;
|
||||
visualConfigs = configs;
|
||||
visualPrivates = privates;
|
||||
}
|
||||
|
||||
static miInitVisualsProcPtr saveInitVisualsProc;
|
||||
|
||||
Bool GlxInitVisuals(VisualPtr *visualp, DepthPtr *depthp,
|
||||
int *nvisualp, int *ndepthp,
|
||||
int *rootDepthp, VisualID *defaultVisp,
|
||||
unsigned long sizes, int bitsPerRGB,
|
||||
int preferredVis)
|
||||
{
|
||||
Bool ret;
|
||||
|
||||
if (saveInitVisualsProc) {
|
||||
ret = saveInitVisualsProc(visualp, depthp, nvisualp, ndepthp,
|
||||
rootDepthp, defaultVisp, sizes, bitsPerRGB,
|
||||
preferredVis);
|
||||
if (!ret)
|
||||
return False;
|
||||
}
|
||||
|
||||
/*
|
||||
* Setup the visuals supported by this particular screen.
|
||||
*/
|
||||
init_visuals(nvisualp, visualp, defaultVisp,
|
||||
*ndepthp, *depthp, *rootDepthp);
|
||||
|
||||
|
||||
return True;
|
||||
}
|
||||
|
||||
|
||||
/************************************************************************/
|
||||
|
||||
|
||||
void
|
||||
GlxWrapInitVisuals(miInitVisualsProcPtr *initVisProc)
|
||||
{
|
||||
saveInitVisualsProc = *initVisProc;
|
||||
*initVisProc = GlxInitVisuals;
|
||||
}
|
||||
|
||||
static void fixup_visuals(int screen)
|
||||
{
|
||||
ScreenPtr pScreen = screenInfo.screens[screen];
|
||||
ScreenVisuals *psv = &screenVisuals[screen];
|
||||
int j;
|
||||
__GLcontextModes *modes;
|
||||
|
||||
for ( modes = psv->modes ; modes != NULL ; modes = modes->next ) {
|
||||
const int vis_class = _gl_convert_to_x_visual_type( modes->visualType );
|
||||
const int nplanes = (modes->rgbBits - modes->alphaBits);
|
||||
const VisualPtr pVis = pScreen->visuals;
|
||||
|
||||
/* Find a visual that matches the GLX visual's class and size */
|
||||
for (j = 0; j < pScreen->numVisuals; j++) {
|
||||
if (pVis[j].class == vis_class &&
|
||||
pVis[j].nplanes == nplanes) {
|
||||
|
||||
/* Fixup the masks */
|
||||
modes->redMask = pVis[j].redMask;
|
||||
modes->greenMask = pVis[j].greenMask;
|
||||
modes->blueMask = pVis[j].blueMask;
|
||||
|
||||
/* Recalc the sizes */
|
||||
modes->redBits = count_bits(modes->redMask);
|
||||
modes->greenBits = count_bits(modes->greenMask);
|
||||
modes->blueBits = count_bits(modes->blueMask);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void __glXScreenInitVisuals(__GLXscreen *screen)
|
||||
{
|
||||
int index = screen->pScreen->myNum;
|
||||
|
||||
screen->modes = screenVisuals[index].modes;
|
||||
screen->pVisualPriv = screenVisuals[index].private;
|
||||
screen->numVisuals = screenVisuals[index].num_vis;
|
||||
screen->numUsableVisuals = screenVisuals[index].num_vis;
|
||||
|
||||
/*
|
||||
* The ordering of the rgb compenents might have been changed by the
|
||||
* driver after mi initialized them.
|
||||
*/
|
||||
fixup_visuals(index);
|
||||
}
|
|
@ -207,6 +207,8 @@ extern HIDDEN void __glXDisp_TexCoord2iv(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_TexCoord2iv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_CompressedTexImage1DARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_CompressedTexImage1DARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_Rotated(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Rotated(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_ReadPixels(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_ReadPixels(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_EdgeFlagv(GLbyte * pc);
|
||||
|
@ -293,8 +295,8 @@ extern HIDDEN void __glXDisp_ClearIndex(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_ClearIndex(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_LoadMatrixd(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_LoadMatrixd(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_RasterPos2dv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_RasterPos2dv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_PushMatrix(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_PushMatrix(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_ConvolutionParameterfv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_ConvolutionParameterfv(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_GetTexGendv(struct __GLXclientStateRec *, GLbyte *);
|
||||
|
@ -371,14 +373,16 @@ extern HIDDEN void __glXDisp_ProgramNamedParameter4fvNV(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_ProgramNamedParameter4fvNV(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_VertexAttrib4fvARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_VertexAttrib4fvARB(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_CreateGLXPbufferSGIX(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_CreateGLXPbufferSGIX(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_MultiTexCoord1svARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_MultiTexCoord1svARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_EndQueryARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_EndQueryARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_DepthMask(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_DepthMask(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_Rotated(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Rotated(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_Color4iv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Color4iv(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_GetMaterialiv(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetMaterialiv(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_StencilOp(GLbyte * pc);
|
||||
|
@ -619,8 +623,8 @@ extern HIDDEN int __glXDisp_PixelStorei(struct __GLXclientStateRec *, GLbyte *);
|
|||
extern HIDDEN int __glXDispSwap_PixelStorei(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_VertexAttrib4usvARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_VertexAttrib4usvARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_Color4iv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Color4iv(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_DestroyGLXPbufferSGIX(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_DestroyGLXPbufferSGIX(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_EvalCoord2dv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_EvalCoord2dv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_VertexAttrib3svARB(GLbyte * pc);
|
||||
|
@ -669,6 +673,8 @@ extern HIDDEN void __glXDisp_Lighti(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_Lighti(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_GetFramebufferAttachmentParameterivEXT(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetFramebufferAttachmentParameterivEXT(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDisp_ChangeDrawableAttributesSGIX(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_ChangeDrawableAttributesSGIX(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_MultiTexCoord4dvARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_MultiTexCoord4dvARB(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_CreatePbuffer(struct __GLXclientStateRec *, GLbyte *);
|
||||
|
@ -751,8 +757,8 @@ extern HIDDEN void __glXDisp_PixelTransferf(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_PixelTransferf(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_CopyTexImage1D(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_CopyTexImage1D(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_PushMatrix(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_PushMatrix(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_RasterPos2dv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_RasterPos2dv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_Fogiv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Fogiv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_TexCoord1dv(GLbyte * pc);
|
||||
|
|
|
@ -697,6 +697,7 @@ __glGetBooleanv_size(GLenum e)
|
|||
case GL_MATRIX_INDEX_ARRAY_SIZE_ARB:
|
||||
case GL_MATRIX_INDEX_ARRAY_TYPE_ARB:
|
||||
case GL_MATRIX_INDEX_ARRAY_STRIDE_ARB:
|
||||
case GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT:
|
||||
case GL_POINT_SPRITE_ARB:
|
||||
/* case GL_POINT_SPRITE_NV:*/
|
||||
case GL_POINT_SPRITE_R_MODE_NV:
|
||||
|
@ -704,8 +705,11 @@ __glGetBooleanv_size(GLenum e)
|
|||
case GL_MAX_TEXTURE_COORDS_ARB:
|
||||
case GL_MAX_TEXTURE_IMAGE_UNITS_ARB:
|
||||
case GL_DEPTH_BOUNDS_TEST_EXT:
|
||||
case GL_MAX_ARRAY_TEXTURE_LAYERS_EXT:
|
||||
case GL_STENCIL_TEST_TWO_SIDE_EXT:
|
||||
case GL_ACTIVE_STENCIL_FACE_EXT:
|
||||
case GL_TEXTURE_BINDING_1D_ARRAY_EXT:
|
||||
case GL_TEXTURE_BINDING_2D_ARRAY_EXT:
|
||||
case GL_RASTER_POSITION_UNCLIPPED_IBM:
|
||||
return 1;
|
||||
case GL_SMOOTH_POINT_SIZE_RANGE:
|
||||
|
|
|
@ -1575,9 +1575,9 @@ static const void *VendorPriv_function_table[104][2] = {
|
|||
/* [ 92] = 65540 */ {__glXDisp_GetFBConfigsSGIX, __glXDispSwap_GetFBConfigsSGIX},
|
||||
/* [ 93] = 65541 */ {__glXDisp_CreateContextWithConfigSGIX, __glXDispSwap_CreateContextWithConfigSGIX},
|
||||
/* [ 94] = 65542 */ {__glXDisp_CreateGLXPixmapWithConfigSGIX, __glXDispSwap_CreateGLXPixmapWithConfigSGIX},
|
||||
/* [ 95] = 65543 */ {NULL, NULL},
|
||||
/* [ 96] = 65544 */ {NULL, NULL},
|
||||
/* [ 97] = 65545 */ {NULL, NULL},
|
||||
/* [ 95] = 65543 */ {__glXDisp_CreateGLXPbufferSGIX, __glXDispSwap_CreateGLXPbufferSGIX},
|
||||
/* [ 96] = 65544 */ {__glXDisp_DestroyGLXPbufferSGIX, __glXDispSwap_DestroyGLXPbufferSGIX},
|
||||
/* [ 97] = 65545 */ {__glXDisp_ChangeDrawableAttributesSGIX, __glXDispSwap_ChangeDrawableAttributesSGIX},
|
||||
/* [ 98] = 65546 */ {__glXDisp_GetDrawableAttributesSGIX, __glXDispSwap_GetDrawableAttributesSGIX},
|
||||
/* [ 99] = 65547 */ {NULL, NULL},
|
||||
/* [ 100] = 65548 */ {NULL, NULL},
|
||||
|
|
74
Xext/shm.c
74
Xext/shm.c
|
@ -62,6 +62,33 @@ in this Software without prior written authorization from The Open Group.
|
|||
#include <X11/extensions/shmstr.h>
|
||||
#include <X11/Xfuncproto.h>
|
||||
|
||||
/* Needed for Solaris cross-zone shared memory extension */
|
||||
#ifdef HAVE_SHMCTL64
|
||||
#include <sys/ipc_impl.h>
|
||||
#define SHMSTAT(id, buf) shmctl64(id, IPC_STAT64, buf)
|
||||
#define SHMSTAT_TYPE struct shmid_ds64
|
||||
#define SHMPERM_TYPE struct ipc_perm64
|
||||
#define SHM_PERM(buf) buf.shmx_perm
|
||||
#define SHM_SEGSZ(buf) buf.shmx_segsz
|
||||
#define SHMPERM_UID(p) p->ipcx_uid
|
||||
#define SHMPERM_CUID(p) p->ipcx_cuid
|
||||
#define SHMPERM_GID(p) p->ipcx_gid
|
||||
#define SHMPERM_CGID(p) p->ipcx_cgid
|
||||
#define SHMPERM_MODE(p) p->ipcx_mode
|
||||
#define SHMPERM_ZONEID(p) p->ipcx_zoneid
|
||||
#else
|
||||
#define SHMSTAT(id, buf) shmctl(id, IPC_STAT, buf)
|
||||
#define SHMSTAT_TYPE struct shmid_ds
|
||||
#define SHMPERM_TYPE struct ipc_perm
|
||||
#define SHM_PERM(buf) buf.shm_perm
|
||||
#define SHM_SEGSZ(buf) buf.shm_segsz
|
||||
#define SHMPERM_UID(p) p->uid
|
||||
#define SHMPERM_CUID(p) p->cuid
|
||||
#define SHMPERM_GID(p) p->gid
|
||||
#define SHMPERM_CGID(p) p->cgid
|
||||
#define SHMPERM_MODE(p) p->mode
|
||||
#endif
|
||||
|
||||
#ifdef PANORAMIX
|
||||
#include "panoramiX.h"
|
||||
#include "panoramiXsrv.h"
|
||||
|
@ -348,32 +375,57 @@ ProcShmQueryVersion(client)
|
|||
* using the credentials from the client if available
|
||||
*/
|
||||
static int
|
||||
shm_access(ClientPtr client, struct ipc_perm *perm, int readonly)
|
||||
shm_access(ClientPtr client, SHMPERM_TYPE *perm, int readonly)
|
||||
{
|
||||
int uid, gid;
|
||||
mode_t mask;
|
||||
int uidset = 0, gidset = 0;
|
||||
LocalClientCredRec *lcc;
|
||||
|
||||
if (LocalClientCred(client, &uid, &gid) != -1) {
|
||||
if (GetLocalClientCreds(client, &lcc) != -1) {
|
||||
|
||||
if (lcc->fieldsSet & LCC_UID_SET) {
|
||||
uid = lcc->euid;
|
||||
uidset = 1;
|
||||
}
|
||||
if (lcc->fieldsSet & LCC_GID_SET) {
|
||||
gid = lcc->egid;
|
||||
gidset = 1;
|
||||
}
|
||||
|
||||
#if defined(HAVE_GETZONEID) && defined(SHMPERM_ZONEID)
|
||||
if ( ((lcc->fieldsSet & LCC_ZID_SET) == 0) || (lcc->zoneid == -1)
|
||||
|| (lcc->zoneid != SHMPERM_ZONEID(perm))) {
|
||||
uidset = 0;
|
||||
gidset = 0;
|
||||
}
|
||||
#endif
|
||||
FreeLocalClientCreds(lcc);
|
||||
|
||||
if (uidset) {
|
||||
/* User id 0 always gets access */
|
||||
if (uid == 0) {
|
||||
return 0;
|
||||
}
|
||||
/* Check the owner */
|
||||
if (perm->uid == uid || perm->cuid == uid) {
|
||||
if (SHMPERM_UID(perm) == uid || SHMPERM_CUID(perm) == uid) {
|
||||
mask = S_IRUSR;
|
||||
if (!readonly) {
|
||||
mask |= S_IWUSR;
|
||||
}
|
||||
return (perm->mode & mask) == mask ? 0 : -1;
|
||||
return (SHMPERM_MODE(perm) & mask) == mask ? 0 : -1;
|
||||
}
|
||||
}
|
||||
|
||||
if (gidset) {
|
||||
/* Check the group */
|
||||
if (perm->gid == gid || perm->cgid == gid) {
|
||||
if (SHMPERM_GID(perm) == gid || SHMPERM_CGID(perm) == gid) {
|
||||
mask = S_IRGRP;
|
||||
if (!readonly) {
|
||||
mask |= S_IWGRP;
|
||||
}
|
||||
return (perm->mode & mask) == mask ? 0 : -1;
|
||||
return (SHMPERM_MODE(perm) & mask) == mask ? 0 : -1;
|
||||
}
|
||||
}
|
||||
}
|
||||
/* Otherwise, check everyone else */
|
||||
|
@ -381,14 +433,14 @@ shm_access(ClientPtr client, struct ipc_perm *perm, int readonly)
|
|||
if (!readonly) {
|
||||
mask |= S_IWOTH;
|
||||
}
|
||||
return (perm->mode & mask) == mask ? 0 : -1;
|
||||
return (SHMPERM_MODE(perm) & mask) == mask ? 0 : -1;
|
||||
}
|
||||
|
||||
static int
|
||||
ProcShmAttach(client)
|
||||
register ClientPtr client;
|
||||
{
|
||||
struct shmid_ds buf;
|
||||
SHMSTAT_TYPE buf;
|
||||
ShmDescPtr shmdesc;
|
||||
REQUEST(xShmAttachReq);
|
||||
|
||||
|
@ -417,7 +469,7 @@ ProcShmAttach(client)
|
|||
shmdesc->addr = shmat(stuff->shmid, 0,
|
||||
stuff->readOnly ? SHM_RDONLY : 0);
|
||||
if ((shmdesc->addr == ((char *)-1)) ||
|
||||
shmctl(stuff->shmid, IPC_STAT, &buf))
|
||||
SHMSTAT(stuff->shmid, &buf))
|
||||
{
|
||||
xfree(shmdesc);
|
||||
return BadAccess;
|
||||
|
@ -427,7 +479,7 @@ ProcShmAttach(client)
|
|||
* do manual checking of access rights for the credentials
|
||||
* of the client */
|
||||
|
||||
if (shm_access(client, &(buf.shm_perm), stuff->readOnly) == -1) {
|
||||
if (shm_access(client, &(SHM_PERM(buf)), stuff->readOnly) == -1) {
|
||||
shmdt(shmdesc->addr);
|
||||
xfree(shmdesc);
|
||||
return BadAccess;
|
||||
|
@ -436,7 +488,7 @@ ProcShmAttach(client)
|
|||
shmdesc->shmid = stuff->shmid;
|
||||
shmdesc->refcnt = 1;
|
||||
shmdesc->writable = !stuff->readOnly;
|
||||
shmdesc->size = buf.shm_segsz;
|
||||
shmdesc->size = SHM_SEGSZ(buf);
|
||||
shmdesc->next = Shmsegs;
|
||||
Shmsegs = shmdesc;
|
||||
}
|
||||
|
|
19
configure.ac
19
configure.ac
|
@ -179,7 +179,7 @@ dnl Checks for library functions.
|
|||
AC_FUNC_VPRINTF
|
||||
AC_CHECK_FUNCS([geteuid getuid link memmove memset mkstemp strchr strrchr \
|
||||
strtol getopt getopt_long vsnprintf walkcontext backtrace \
|
||||
getisax getzoneid])
|
||||
getisax getzoneid shmctl64])
|
||||
AC_FUNC_ALLOCA
|
||||
dnl Old HAS_* names used in os/*.c.
|
||||
AC_CHECK_FUNC([getdtablesize],
|
||||
|
@ -290,6 +290,7 @@ case $host_cpu in
|
|||
alpha*)
|
||||
ALPHA_VIDEO=yes
|
||||
case $host_os in
|
||||
*freebsd*) SYS_LIBS=-lio ;;
|
||||
*netbsd*) AC_DEFINE(USE_ALPHA_PIO, 1, [NetBSD PIO alpha IO]) ;;
|
||||
esac
|
||||
;;
|
||||
|
@ -723,6 +724,7 @@ if test "x$XV" = xyes; then
|
|||
AC_DEFINE(XV, 1, [Support Xv extension])
|
||||
AC_DEFINE(XvExtension, 1, [Build Xv extension])
|
||||
REQUIRED_MODULES="$REQUIRED_MODULES videoproto"
|
||||
PKG_CHECK_MODULES(XV, [xv >= 0.22])
|
||||
else
|
||||
XVMC=no
|
||||
fi
|
||||
|
@ -774,7 +776,7 @@ fi
|
|||
|
||||
if test "x$GLX" = xyes && ! test "x$MESA_SOURCE" = x; then
|
||||
PKG_CHECK_MODULES([XLIB], [x11])
|
||||
PKG_CHECK_MODULES([GL], [glproto >= 1.4.8])
|
||||
PKG_CHECK_MODULES([GL], [glproto >= 1.4.9])
|
||||
AC_SUBST(XLIB_CFLAGS)
|
||||
AC_DEFINE(GLXEXT, 1, [Build GLX extension])
|
||||
GLX_LIBS='$(top_builddir)/GL/glx/libglx.la $(top_builddir)/GL/mesa/libGLcore.la'
|
||||
|
@ -1842,6 +1844,13 @@ if test "$KDRIVE" = yes; then
|
|||
if test "x$XEPHYR" = xauto; then
|
||||
XEPHYR=$xephyr
|
||||
fi
|
||||
XEPHYR_DRI=no
|
||||
if test x$XEPHYR = xyes -a x$DRI = xyes; then
|
||||
XEPHYR_DRI=yes
|
||||
fi
|
||||
if test x$XEPHYR_DRI = xyes ; then
|
||||
AC_DEFINE(XEPHYR_DRI,1,[enable DRI extension in xephyr])
|
||||
fi
|
||||
|
||||
# Xephyr needs nanosleep() which is in librt on Solaris
|
||||
AC_CHECK_FUNC([nanosleep], [],
|
||||
|
@ -1861,9 +1870,9 @@ if test "$KDRIVE" = yes; then
|
|||
KDRIVE_OS_INC='-I$(top_srcdir)/hw/kdrive/linux'
|
||||
KDRIVE_INCS="$KDRIVE_PURE_INCS $KDRIVE_OS_INC"
|
||||
|
||||
KDRIVE_CFLAGS="$XSERVER_CFLAGS -DHAVE_KDRIVE_CONFIG_H $TSLIB_CFLAGS"
|
||||
KDRIVE_CFLAGS="$XSERVER_CFLAGS -DHAVE_KDRIVE_CONFIG_H $TSLIB_CFLAGS $XV_CFLAGS"
|
||||
|
||||
KDRIVE_PURE_LIBS="$FIXES_LIB $XEXT_LIB $DBE_LIB $XTRAP_LIB $RECORD_LIB $GLX_LIBS $RENDER_LIB $RANDR_LIB $DAMAGE_LIB $MIEXT_SHADOW_LIB $MIEXT_DAMAGE_LIB $XI_LIB $XKB_LIB $XKB_STUB_LIB $COMPOSITE_LIB $XPSTUBS_LIB"
|
||||
KDRIVE_PURE_LIBS="$FB_LIB $MI_LIB $FIXES_LIB $XEXT_LIB $DBE_LIB $XTRAP_LIB $RECORD_LIB $GLX_LIBS $RENDER_LIB $RANDR_LIB $DAMAGE_LIB $MIEXT_DAMAGE_LIB $MIEXT_SHADOW_LIB $XI_LIB $XKB_LIB $XKB_STUB_LIB $COMPOSITE_LIB $XPSTUBS_LIB $OS_LIB"
|
||||
KDRIVE_LIB='$(top_builddir)/hw/kdrive/src/libkdrive.a'
|
||||
case $host_os in
|
||||
*linux*)
|
||||
|
@ -1875,7 +1884,7 @@ if test "$KDRIVE" = yes; then
|
|||
KDRIVE_LOCAL_LIBS="$TSLIB_LIBS $DIX_LIB $KDRIVE_LIB $KDRIVE_STUB_LIB $CONFIG_LIB"
|
||||
KDRIVE_LOCAL_LIBS="$KDRIVE_LOCAL_LIBS $FB_LIB $MI_LIB $KDRIVE_PURE_LIBS"
|
||||
KDRIVE_LOCAL_LIBS="$KDRIVE_LOCAL_LIBS $KDRIVE_OS_LIB $OS_LIB"
|
||||
KDRIVE_LIBS="$KDRIVE_LOCAL_LIBS $XSERVER_SYS_LIBS"
|
||||
KDRIVE_LIBS="$KDRIVE_LOCAL_LIBS $XSERVER_SYS_LIBS $XV_LIBS"
|
||||
|
||||
# check if we can build Xephyr
|
||||
PKG_CHECK_MODULES(XEPHYR, x11 xext xfont xau xdmcp, [xephyr="yes"], [xephyr="no"])
|
||||
|
|
|
@ -184,6 +184,8 @@ _X_EXPORT Bool AddExtensionAlias(char *alias, ExtensionEntry *ext)
|
|||
char *name;
|
||||
char **aliases;
|
||||
|
||||
if (!ext)
|
||||
return FALSE ;
|
||||
aliases = (char **)xrealloc(ext->aliases,
|
||||
(ext->num_aliases + 1) * sizeof(char *));
|
||||
if (!aliases)
|
||||
|
|
|
@ -288,6 +288,7 @@ exaCreatePixmap(ScreenPtr pScreen, int w, int h, int depth)
|
|||
paddedWidth, NULL);
|
||||
pExaPixmap->driverPriv = driver_priv;
|
||||
pExaPixmap->score = EXA_PIXMAP_SCORE_PINNED;
|
||||
pExaPixmap->fb_ptr = NULL;
|
||||
} else {
|
||||
pExaPixmap->driverPriv = NULL;
|
||||
/* Glyphs have w/h equal to zero, and may not be migrated. See exaGlyphs. */
|
||||
|
@ -409,7 +410,7 @@ exaPixmapIsOffscreen(PixmapPtr p)
|
|||
|
||||
save_ptr = p->devPrivate.ptr;
|
||||
|
||||
if (!save_ptr && pExaPixmap)
|
||||
if (!save_ptr && pExaPixmap && !(pExaScr->info->flags & EXA_HANDLES_PIXMAPS))
|
||||
p->devPrivate.ptr = ExaGetPixmapAddress(p);
|
||||
|
||||
if (pExaScr->info->PixmapIsOffscreen)
|
||||
|
@ -459,7 +460,7 @@ ExaDoPrepareAccess(DrawablePtr pDrawable, int index)
|
|||
Bool offscreen = exaPixmapIsOffscreen(pPixmap);
|
||||
|
||||
/* Unhide pixmap pointer */
|
||||
if (pPixmap->devPrivate.ptr == NULL) {
|
||||
if (pPixmap->devPrivate.ptr == NULL && !(pExaScr->info->flags & EXA_HANDLES_PIXMAPS)) {
|
||||
pPixmap->devPrivate.ptr = ExaGetPixmapAddress(pPixmap);
|
||||
}
|
||||
|
||||
|
@ -520,8 +521,7 @@ exaFinishAccess(DrawablePtr pDrawable, int index)
|
|||
ExaPixmapPriv (pPixmap);
|
||||
|
||||
/* Rehide pixmap pointer if we're doing that. */
|
||||
if (pExaPixmap)
|
||||
{
|
||||
if (pExaPixmap && !(pExaScr->info->flags & EXA_HANDLES_PIXMAPS)) {
|
||||
pPixmap->devPrivate.ptr = NULL;
|
||||
}
|
||||
|
||||
|
|
|
@ -733,6 +733,13 @@ typedef struct _ExaDriver {
|
|||
* (right-to-left, bottom-to-top).
|
||||
*/
|
||||
#define EXA_TWO_BITBLT_DIRECTIONS (1 << 2)
|
||||
|
||||
/**
|
||||
* EXA_HANDLES_PIXMAPS indicates to EXA that the driver can handle
|
||||
* all pixmap addressing and migration.
|
||||
*/
|
||||
#define EXA_HANDLES_PIXMAPS (1 << 3)
|
||||
|
||||
/** @} */
|
||||
|
||||
ExaDriverPtr
|
||||
|
|
|
@ -152,6 +152,9 @@ exaDoPutImage (DrawablePtr pDrawable, GCPtr pGC, int depth, int x, int y,
|
|||
int bpp = pDrawable->bitsPerPixel;
|
||||
Bool access_prepared = FALSE;
|
||||
|
||||
if (pExaPixmap->accel_blocked)
|
||||
return FALSE;
|
||||
|
||||
/* Don't bother with under 8bpp, XYPixmaps. */
|
||||
if (format != ZPixmap || bpp < 8)
|
||||
return FALSE;
|
||||
|
@ -1134,7 +1137,8 @@ exaFillRegionSolid (DrawablePtr pDrawable,
|
|||
(*pExaScr->info->DoneSolid) (pPixmap);
|
||||
exaMarkSync(pDrawable->pScreen);
|
||||
|
||||
if (pDrawable->width == 1 && pDrawable->height == 1 &&
|
||||
if (!(pExaScr->info->flags & EXA_HANDLES_PIXMAPS) &&
|
||||
pDrawable->width == 1 && pDrawable->height == 1 &&
|
||||
pDrawable->bitsPerPixel != 24) {
|
||||
ExaPixmapPriv(pPixmap);
|
||||
|
||||
|
|
|
@ -299,6 +299,9 @@ exaDoMoveInPixmap (ExaMigrationPtr migrate)
|
|||
if (pPixmap->drawable.bitsPerPixel < 8)
|
||||
return;
|
||||
|
||||
if (pExaPixmap->accel_blocked)
|
||||
return;
|
||||
|
||||
if (pExaPixmap->area == NULL) {
|
||||
pExaPixmap->area =
|
||||
exaOffscreenAlloc (pScreen, pExaPixmap->fb_size,
|
||||
|
@ -553,6 +556,9 @@ exaDoMigration (ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel)
|
|||
ExaScreenPriv(pScreen);
|
||||
int i, j;
|
||||
|
||||
if (pExaScr->info->flags & EXA_HANDLES_PIXMAPS)
|
||||
return;
|
||||
|
||||
/* If this debugging flag is set, check each pixmap for whether it is marked
|
||||
* as clean, and if so, actually check if that's the case. This should help
|
||||
* catch issues with failing to mark a drawable as dirty. While it will
|
||||
|
|
|
@ -247,10 +247,24 @@ exaTryDriverSolidFill(PicturePtr pSrc,
|
|||
int nbox;
|
||||
int dst_off_x, dst_off_y;
|
||||
PixmapPtr pSrcPix, pDstPix;
|
||||
ExaPixmapPrivPtr pSrcExaPix, pDstExaPix;
|
||||
CARD32 pixel;
|
||||
CARD16 red, green, blue, alpha;
|
||||
ExaMigrationRec pixmaps[1];
|
||||
|
||||
pDstPix = exaGetDrawablePixmap (pDst->pDrawable);
|
||||
pSrcPix = exaGetDrawablePixmap (pSrc->pDrawable);
|
||||
|
||||
pSrcExaPix = ExaGetPixmapPriv(pSrcPix);
|
||||
pDstExaPix = ExaGetPixmapPriv(pDstPix);
|
||||
|
||||
/* Check whether the accelerator can use these pixmaps.
|
||||
*/
|
||||
if (pSrcExaPix->accel_blocked || pDstExaPix->accel_blocked)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
xDst += pDst->pDrawable->x;
|
||||
yDst += pDst->pDrawable->y;
|
||||
xSrc += pSrc->pDrawable->x;
|
||||
|
@ -261,12 +275,10 @@ exaTryDriverSolidFill(PicturePtr pSrc,
|
|||
width, height))
|
||||
return 1;
|
||||
|
||||
pDstPix = exaGetDrawablePixmap (pDst->pDrawable);
|
||||
exaGetDrawableDeltas (pDst->pDrawable, pDstPix, &dst_off_x, &dst_off_y);
|
||||
|
||||
REGION_TRANSLATE(pScreen, ®ion, dst_off_x, dst_off_y);
|
||||
|
||||
pSrcPix = exaGetDrawablePixmap (pSrc->pDrawable);
|
||||
pixel = exaGetPixmapFirstPixel (pSrcPix);
|
||||
|
||||
pixmaps[0].as_dst = TRUE;
|
||||
|
@ -1202,6 +1214,7 @@ exaGlyphs (CARD8 op,
|
|||
y1 = y - glyph->info.y;
|
||||
|
||||
if (x1 >= pCmpDrw->width || y1 >= pCmpDrw->height ||
|
||||
glyph->info.width == 0 || glyph->info.height == 0 ||
|
||||
(x1 + glyph->info.width) <= 0 || (y1 + glyph->info.height) <= 0)
|
||||
goto nextglyph;
|
||||
|
||||
|
|
|
@ -103,6 +103,14 @@ fbSetVisualTypes (int depth, int visuals, int bitsPerRGB)
|
|||
return miSetVisualTypes(depth, visuals, bitsPerRGB, -1);
|
||||
}
|
||||
|
||||
Bool
|
||||
fbSetVisualTypesAndMasks (int depth, int visuals, int bitsPerRGB,
|
||||
Pixel redMask, Pixel greenMask, Pixel blueMask)
|
||||
{
|
||||
return miSetVisualTypesAndMasks(depth, visuals, bitsPerRGB, -1,
|
||||
redMask, greenMask, blueMask);
|
||||
}
|
||||
|
||||
/*
|
||||
* Given a list of formats for a screen, create a list
|
||||
* of visuals and depths for the screen which coorespond to
|
||||
|
|
517
hw/kdrive/ephyr/GL/internal/dri_interface.h
Normal file
517
hw/kdrive/ephyr/GL/internal/dri_interface.h
Normal file
|
@ -0,0 +1,517 @@
|
|||
/*
|
||||
* Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
|
||||
* (C) Copyright IBM Corporation 2004
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a
|
||||
* copy of this software and associated documentation files (the "Software"),
|
||||
* to deal in the Software without restriction, including without limitation
|
||||
* on the rights to use, copy, modify, merge, publish, distribute, sub
|
||||
* license, and/or sell copies of the Software, and to permit persons to whom
|
||||
* the Software is furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice (including the next
|
||||
* paragraph) shall be included in all copies or substantial portions of the
|
||||
* Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
|
||||
* THE COPYRIGHT HOLDERS AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
|
||||
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
||||
* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
||||
* USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*/
|
||||
|
||||
/**
|
||||
* \file dri_interface.h
|
||||
*
|
||||
* This file contains all the types and functions that define the interface
|
||||
* between a DRI driver and driver loader. Currently, the most common driver
|
||||
* loader is the XFree86 libGL.so. However, other loaders do exist, and in
|
||||
* the future the server-side libglx.a will also be a loader.
|
||||
*
|
||||
* \author Kevin E. Martin <kevin@precisioninsight.com>
|
||||
* \author Ian Romanick <idr@us.ibm.com>
|
||||
*/
|
||||
|
||||
#ifndef DRI_INTERFACE_H
|
||||
#define DRI_INTERFACE_H
|
||||
|
||||
#include <GL/internal/glcore.h>
|
||||
#include <drm.h>
|
||||
|
||||
/**
|
||||
* \name DRI interface structures
|
||||
*
|
||||
* The following structures define the interface between the GLX client
|
||||
* side library and the DRI (direct rendering infrastructure).
|
||||
*/
|
||||
/*@{*/
|
||||
typedef struct __DRIdisplayRec __DRIdisplay;
|
||||
typedef struct __DRIscreenRec __DRIscreen;
|
||||
typedef struct __DRIcontextRec __DRIcontext;
|
||||
typedef struct __DRIdrawableRec __DRIdrawable;
|
||||
typedef struct __DRIdriverRec __DRIdriver;
|
||||
typedef struct __DRIframebufferRec __DRIframebuffer;
|
||||
typedef struct __DRIversionRec __DRIversion;
|
||||
typedef struct __DRIinterfaceMethodsRec __DRIinterfaceMethods;
|
||||
typedef unsigned long __DRIid;
|
||||
typedef void __DRInativeDisplay;
|
||||
/*@}*/
|
||||
|
||||
|
||||
/**
|
||||
* \name Functions provided by the driver loader.
|
||||
*/
|
||||
/*@{*/
|
||||
/**
|
||||
* Type of a pointer to \c glXGetScreenDriver, as returned by
|
||||
* \c glXGetProcAddress. This function is used to get the name of the DRI
|
||||
* driver for the specified screen of the specified display. The driver
|
||||
* name is typically used with \c glXGetDriverConfig.
|
||||
*
|
||||
* \sa glXGetScreenDriver, glXGetProcAddress, glXGetDriverConfig
|
||||
*/
|
||||
typedef const char * (* PFNGLXGETSCREENDRIVERPROC) (__DRInativeDisplay *dpy, int scrNum);
|
||||
|
||||
/**
|
||||
* Type of a pointer to \c glXGetDriverConfig, as returned by
|
||||
* \c glXGetProcAddress. This function is used to get the XML document
|
||||
* describing the configuration options available for the specified driver.
|
||||
*
|
||||
* \sa glXGetDriverConfig, glXGetProcAddress, glXGetScreenDriver
|
||||
*/
|
||||
typedef const char * (* PFNGLXGETDRIVERCONFIGPROC) (const char *driverName);
|
||||
|
||||
/**
|
||||
* Type of a pointer to \c glxEnableExtension, as returned by
|
||||
* \c __DRIinterfaceMethods::getProcAddress. This function is used to enable
|
||||
* a GLX extension on the specified screen.
|
||||
*/
|
||||
typedef void (* PFNGLXSCRENABLEEXTENSIONPROC) ( void *psc, const char * name );
|
||||
/*@}*/
|
||||
|
||||
|
||||
/**
|
||||
* \name Functions and data provided by the driver.
|
||||
*/
|
||||
/*@{*/
|
||||
|
||||
typedef void *(CREATENEWSCREENFUNC)(__DRInativeDisplay *dpy, int scrn,
|
||||
__DRIscreen *psc, const __GLcontextModes * modes,
|
||||
const __DRIversion * ddx_version, const __DRIversion * dri_version,
|
||||
const __DRIversion * drm_version, const __DRIframebuffer * frame_buffer,
|
||||
void * pSAREA, int fd, int internal_api_version,
|
||||
const __DRIinterfaceMethods * interface,
|
||||
__GLcontextModes ** driver_modes);
|
||||
typedef CREATENEWSCREENFUNC* PFNCREATENEWSCREENFUNC;
|
||||
extern CREATENEWSCREENFUNC __driCreateNewScreen_20050727;
|
||||
|
||||
|
||||
/**
|
||||
* XML document describing the configuration options supported by the
|
||||
* driver.
|
||||
*/
|
||||
extern const char __driConfigOptions[];
|
||||
|
||||
/*@}*/
|
||||
|
||||
|
||||
/**
|
||||
* Stored version of some component (i.e., server-side DRI module, kernel-side
|
||||
* DRM, etc.).
|
||||
*
|
||||
* \todo
|
||||
* There are several data structures that explicitly store a major version,
|
||||
* minor version, and patch level. These structures should be modified to
|
||||
* have a \c __DRIversionRec instead.
|
||||
*/
|
||||
struct __DRIversionRec {
|
||||
int major; /**< Major version number. */
|
||||
int minor; /**< Minor version number. */
|
||||
int patch; /**< Patch-level. */
|
||||
};
|
||||
|
||||
|
||||
typedef void (*__DRIfuncPtr)(void);
|
||||
|
||||
struct __DRIinterfaceMethodsRec {
|
||||
/**
|
||||
* Get pointer to named function.
|
||||
*/
|
||||
__DRIfuncPtr (*getProcAddress)( const char * proc_name );
|
||||
|
||||
/**
|
||||
* Create a list of \c __GLcontextModes structures.
|
||||
*/
|
||||
__GLcontextModes * (*createContextModes)(unsigned count,
|
||||
size_t minimum_bytes_per_struct);
|
||||
|
||||
/**
|
||||
* Destroy a list of \c __GLcontextModes structures.
|
||||
*
|
||||
* \todo
|
||||
* Determine if the drivers actually need to call this.
|
||||
*/
|
||||
void (*destroyContextModes)( __GLcontextModes * modes );
|
||||
|
||||
/**
|
||||
* Get the \c __DRIscreen for a given display and screen number.
|
||||
*/
|
||||
__DRIscreen *(*getScreen)(__DRInativeDisplay *dpy, int screenNum);
|
||||
|
||||
|
||||
/**
|
||||
* \name Client/server protocol functions.
|
||||
*
|
||||
* These functions implement the DRI client/server protocol for
|
||||
* context and drawable operations. Platforms that do not implement
|
||||
* the wire protocol (e.g., EGL) will implement glorified no-op functions.
|
||||
*/
|
||||
/*@{*/
|
||||
/**
|
||||
* Determine if the specified window ID still exists.
|
||||
*
|
||||
* \note
|
||||
* Implementations may assume that the driver will only pass an ID into
|
||||
* this function that actually corresponds to a window. On
|
||||
* implementations where windows can only be destroyed by the DRI driver
|
||||
* (e.g., EGL), this function is allowed to always return \c GL_TRUE.
|
||||
*/
|
||||
GLboolean (*windowExists)(__DRInativeDisplay *dpy, __DRIid draw);
|
||||
|
||||
/**
|
||||
* Create the server-side portion of the GL context.
|
||||
*/
|
||||
GLboolean (* createContext)( __DRInativeDisplay *dpy, int screenNum,
|
||||
int configID, void * contextID, drm_context_t * hw_context );
|
||||
|
||||
/**
|
||||
* Destroy the server-side portion of the GL context.
|
||||
*/
|
||||
GLboolean (* destroyContext)( __DRInativeDisplay *dpy, int screenNum,
|
||||
__DRIid context );
|
||||
|
||||
/**
|
||||
* Create the server-side portion of the drawable.
|
||||
*/
|
||||
GLboolean (*createDrawable)( __DRInativeDisplay * ndpy, int screen,
|
||||
__DRIid drawable, drm_drawable_t * hHWDrawable );
|
||||
|
||||
/**
|
||||
* Destroy the server-side portion of the drawable.
|
||||
*/
|
||||
GLboolean (*destroyDrawable)( __DRInativeDisplay * ndpy, int screen,
|
||||
__DRIid drawable );
|
||||
|
||||
/**
|
||||
* This function is used to get information about the position, size, and
|
||||
* clip rects of a drawable.
|
||||
*/
|
||||
GLboolean (* getDrawableInfo) ( __DRInativeDisplay *dpy, int scrn,
|
||||
__DRIid draw, unsigned int * index, unsigned int * stamp,
|
||||
int * x, int * y, int * width, int * height,
|
||||
int * numClipRects, drm_clip_rect_t ** pClipRects,
|
||||
int * backX, int * backY,
|
||||
int * numBackClipRects, drm_clip_rect_t ** pBackClipRects );
|
||||
/*@}*/
|
||||
|
||||
|
||||
/**
|
||||
* \name Timing related functions.
|
||||
*/
|
||||
/*@{*/
|
||||
/**
|
||||
* Get the 64-bit unadjusted system time (UST).
|
||||
*/
|
||||
int (*getUST)(int64_t * ust);
|
||||
|
||||
/**
|
||||
* Get the media stream counter (MSC) rate.
|
||||
*
|
||||
* Matching the definition in GLX_OML_sync_control, this function returns
|
||||
* the rate of the "media stream counter". In practical terms, this is
|
||||
* the frame refresh rate of the display.
|
||||
*/
|
||||
GLboolean (*getMSCRate)(__DRInativeDisplay * dpy, __DRIid drawable,
|
||||
int32_t * numerator, int32_t * denominator);
|
||||
/*@}*/
|
||||
|
||||
/**
|
||||
* Reports areas of the given drawable which have been modified by the
|
||||
* driver.
|
||||
*
|
||||
* \param drawable which the drawing was done to.
|
||||
* \param rects rectangles affected, with the drawable origin as the
|
||||
* origin.
|
||||
* \param x X offset of the drawable within the screen (used in the
|
||||
* front_buffer case)
|
||||
* \param y Y offset of the drawable within the screen.
|
||||
* \param front_buffer boolean flag for whether the drawing to the
|
||||
* drawable was actually done directly to the front buffer (instead
|
||||
* of backing storage, for example)
|
||||
*/
|
||||
void (*reportDamage)(__DRInativeDisplay * dpy, int screen,
|
||||
__DRIid drawable,
|
||||
int x, int y,
|
||||
drm_clip_rect_t *rects, int num_rects,
|
||||
int front_buffer);
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* Framebuffer information record. Used by libGL to communicate information
|
||||
* about the framebuffer to the driver's \c __driCreateNewScreen function.
|
||||
*
|
||||
* In XFree86, most of this information is derrived from data returned by
|
||||
* calling \c XF86DRIGetDeviceInfo.
|
||||
*
|
||||
* \sa XF86DRIGetDeviceInfo __DRIdisplayRec::createNewScreen
|
||||
* __driUtilCreateNewScreen CallCreateNewScreen
|
||||
*
|
||||
* \bug This structure could be better named.
|
||||
*/
|
||||
struct __DRIframebufferRec {
|
||||
unsigned char *base; /**< Framebuffer base address in the CPU's
|
||||
* address space. This value is calculated by
|
||||
* calling \c drmMap on the framebuffer handle
|
||||
* returned by \c XF86DRIGetDeviceInfo (or a
|
||||
* similar function).
|
||||
*/
|
||||
int size; /**< Framebuffer size, in bytes. */
|
||||
int stride; /**< Number of bytes from one line to the next. */
|
||||
int width; /**< Pixel width of the framebuffer. */
|
||||
int height; /**< Pixel height of the framebuffer. */
|
||||
int dev_priv_size; /**< Size of the driver's dev-priv structure. */
|
||||
void *dev_priv; /**< Pointer to the driver's dev-priv structure. */
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* Screen dependent methods. This structure is initialized during the
|
||||
* \c __DRIdisplayRec::createScreen call.
|
||||
*/
|
||||
struct __DRIscreenRec {
|
||||
/**
|
||||
* Method to destroy the private DRI screen data.
|
||||
*/
|
||||
void (*destroyScreen)(__DRInativeDisplay *dpy, int scrn, void *screenPrivate);
|
||||
|
||||
/**
|
||||
* Method to create the private DRI drawable data and initialize the
|
||||
* drawable dependent methods.
|
||||
*/
|
||||
void *(*createNewDrawable)(__DRInativeDisplay *dpy, const __GLcontextModes *modes,
|
||||
__DRIid draw, __DRIdrawable *pdraw,
|
||||
int renderType, const int *attrs);
|
||||
|
||||
/**
|
||||
* Method to return a pointer to the DRI drawable data.
|
||||
*/
|
||||
__DRIdrawable *(*getDrawable)(__DRInativeDisplay *dpy, __DRIid draw,
|
||||
void *drawablePrivate);
|
||||
|
||||
/**
|
||||
* Opaque pointer to private per screen direct rendering data. \c NULL
|
||||
* if direct rendering is not supported on this screen. Never
|
||||
* dereferenced in libGL.
|
||||
*/
|
||||
void *private;
|
||||
|
||||
/**
|
||||
* Get the number of vertical refreshes since some point in time before
|
||||
* this function was first called (i.e., system start up).
|
||||
*
|
||||
* \since Internal API version 20030317.
|
||||
*/
|
||||
int (*getMSC)( void *screenPrivate, int64_t *msc );
|
||||
|
||||
/**
|
||||
* Opaque pointer that points back to the containing
|
||||
* \c __GLXscreenConfigs. This data structure is shared with DRI drivers
|
||||
* but \c __GLXscreenConfigs is not. However, they are needed by some GLX
|
||||
* functions called by DRI drivers.
|
||||
*
|
||||
* \since Internal API version 20030813.
|
||||
*/
|
||||
void *screenConfigs;
|
||||
|
||||
/**
|
||||
* Functions associated with MESA_allocate_memory.
|
||||
*
|
||||
* \since Internal API version 20030815.
|
||||
*/
|
||||
/*@{*/
|
||||
void *(*allocateMemory)(__DRInativeDisplay *dpy, int scrn, GLsizei size,
|
||||
GLfloat readfreq, GLfloat writefreq,
|
||||
GLfloat priority);
|
||||
|
||||
void (*freeMemory)(__DRInativeDisplay *dpy, int scrn, GLvoid *pointer);
|
||||
|
||||
GLuint (*memoryOffset)(__DRInativeDisplay *dpy, int scrn, const GLvoid *pointer);
|
||||
/*@}*/
|
||||
|
||||
/**
|
||||
* Method to create the private DRI context data and initialize the
|
||||
* context dependent methods.
|
||||
*
|
||||
* \since Internal API version 20031201.
|
||||
*/
|
||||
void * (*createNewContext)(__DRInativeDisplay *dpy, const __GLcontextModes *modes,
|
||||
int render_type,
|
||||
void *sharedPrivate, __DRIcontext *pctx);
|
||||
|
||||
/**
|
||||
* Method to override base texture image with a driver specific 'offset'.
|
||||
* The depth passed in allows e.g. to ignore the alpha channel of texture
|
||||
* images where the non-alpha components don't occupy a whole texel.
|
||||
*
|
||||
* For GLX_EXT_texture_from_pixmap with AIGLX.
|
||||
*
|
||||
* \since Internal API version 20070121.
|
||||
*/
|
||||
void (*setTexOffset)(__DRIcontext *pDRICtx, GLint texname,
|
||||
unsigned long long offset, GLint depth, GLuint pitch);
|
||||
};
|
||||
|
||||
/**
|
||||
* Context dependent methods. This structure is initialized during the
|
||||
* \c __DRIscreenRec::createContext call.
|
||||
*/
|
||||
struct __DRIcontextRec {
|
||||
/**
|
||||
* Method to destroy the private DRI context data.
|
||||
*/
|
||||
void (*destroyContext)(__DRInativeDisplay *dpy, int scrn, void *contextPrivate);
|
||||
|
||||
/**
|
||||
* Opaque pointer to private per context direct rendering data.
|
||||
* \c NULL if direct rendering is not supported on the display or
|
||||
* screen used to create this context. Never dereferenced in libGL.
|
||||
*/
|
||||
void *private;
|
||||
|
||||
/**
|
||||
* Pointer to the mode used to create this context.
|
||||
*
|
||||
* \since Internal API version 20040317.
|
||||
*/
|
||||
const __GLcontextModes * mode;
|
||||
|
||||
/**
|
||||
* Method to bind a DRI drawable to a DRI graphics context.
|
||||
*
|
||||
* \since Internal API version 20050727.
|
||||
*/
|
||||
GLboolean (*bindContext)(__DRInativeDisplay *dpy, int scrn, __DRIid draw,
|
||||
__DRIid read, __DRIcontext *ctx);
|
||||
|
||||
/**
|
||||
* Method to unbind a DRI drawable from a DRI graphics context.
|
||||
*
|
||||
* \since Internal API version 20050727.
|
||||
*/
|
||||
GLboolean (*unbindContext)(__DRInativeDisplay *dpy, int scrn, __DRIid draw,
|
||||
__DRIid read, __DRIcontext *ctx);
|
||||
};
|
||||
|
||||
/**
|
||||
* Drawable dependent methods. This structure is initialized during the
|
||||
* \c __DRIscreenRec::createDrawable call. \c createDrawable is not called
|
||||
* by libGL at this time. It's currently used via the dri_util.c utility code
|
||||
* instead.
|
||||
*/
|
||||
struct __DRIdrawableRec {
|
||||
/**
|
||||
* Method to destroy the private DRI drawable data.
|
||||
*/
|
||||
void (*destroyDrawable)(__DRInativeDisplay *dpy, void *drawablePrivate);
|
||||
|
||||
/**
|
||||
* Method to swap the front and back buffers.
|
||||
*/
|
||||
void (*swapBuffers)(__DRInativeDisplay *dpy, void *drawablePrivate);
|
||||
|
||||
/**
|
||||
* Opaque pointer to private per drawable direct rendering data.
|
||||
* \c NULL if direct rendering is not supported on the display or
|
||||
* screen used to create this drawable. Never dereferenced in libGL.
|
||||
*/
|
||||
void *private;
|
||||
|
||||
/**
|
||||
* Get the number of completed swap buffers for this drawable.
|
||||
*
|
||||
* \since Internal API version 20030317.
|
||||
*/
|
||||
int (*getSBC)(__DRInativeDisplay *dpy, void *drawablePrivate, int64_t *sbc );
|
||||
|
||||
/**
|
||||
* Wait for the SBC to be greater than or equal target_sbc.
|
||||
*
|
||||
* \since Internal API version 20030317.
|
||||
*/
|
||||
int (*waitForSBC)( __DRInativeDisplay * dpy, void *drawablePriv,
|
||||
int64_t target_sbc,
|
||||
int64_t * msc, int64_t * sbc );
|
||||
|
||||
/**
|
||||
* Wait for the MSC to equal target_msc, or, if that has already passed,
|
||||
* the next time (MSC % divisor) is equal to remainder. If divisor is
|
||||
* zero, the function will return as soon as MSC is greater than or equal
|
||||
* to target_msc.
|
||||
*
|
||||
* \since Internal API version 20030317.
|
||||
*/
|
||||
int (*waitForMSC)( __DRInativeDisplay * dpy, void *drawablePriv,
|
||||
int64_t target_msc, int64_t divisor, int64_t remainder,
|
||||
int64_t * msc, int64_t * sbc );
|
||||
|
||||
/**
|
||||
* Like \c swapBuffers, but does NOT have an implicit \c glFlush. Once
|
||||
* rendering is complete, waits until MSC is equal to target_msc, or
|
||||
* if that has already passed, waits until (MSC % divisor) is equal
|
||||
* to remainder. If divisor is zero, the swap will happen as soon as
|
||||
* MSC is greater than or equal to target_msc.
|
||||
*
|
||||
* \since Internal API version 20030317.
|
||||
*/
|
||||
int64_t (*swapBuffersMSC)(__DRInativeDisplay *dpy, void *drawablePrivate,
|
||||
int64_t target_msc,
|
||||
int64_t divisor, int64_t remainder);
|
||||
|
||||
/**
|
||||
* Enable or disable frame usage tracking.
|
||||
*
|
||||
* \since Internal API version 20030317.
|
||||
*/
|
||||
int (*frameTracking)(__DRInativeDisplay *dpy, void *drawablePrivate, GLboolean enable);
|
||||
|
||||
/**
|
||||
* Retrieve frame usage information.
|
||||
*
|
||||
* \since Internal API version 20030317.
|
||||
*/
|
||||
int (*queryFrameTracking)(__DRInativeDisplay *dpy, void *drawablePrivate,
|
||||
int64_t * sbc, int64_t * missedFrames,
|
||||
float * lastMissedUsage, float * usage );
|
||||
|
||||
/**
|
||||
* Used by drivers that implement the GLX_SGI_swap_control or
|
||||
* GLX_MESA_swap_control extension.
|
||||
*
|
||||
* \since Internal API version 20030317.
|
||||
*/
|
||||
unsigned swap_interval;
|
||||
|
||||
/**
|
||||
* Used by drivers that implement the GLX_MESA_copy_sub_buffer extension.
|
||||
*
|
||||
* \since Internal API version 20060314.
|
||||
*/
|
||||
void (*copySubBuffer)(__DRInativeDisplay *dpy, void *drawablePrivate,
|
||||
int x, int y, int w, int h);
|
||||
};
|
||||
|
||||
#endif
|
|
@ -3,16 +3,10 @@ INCLUDES = \
|
|||
@KDRIVE_CFLAGS@ \
|
||||
-I$(srcdir)/../../../exa
|
||||
|
||||
noinst_LIBRARIES = libxephyr.a libxephyr-hostx.a
|
||||
noinst_LIBRARIES = libxephyr-hostx.a libxephyr-hostxv.a libxephyr.a
|
||||
|
||||
bin_PROGRAMS = Xephyr
|
||||
|
||||
libxephyr_a_SOURCES = \
|
||||
ephyr.c \
|
||||
ephyr_draw.c \
|
||||
os.c \
|
||||
hostx.h \
|
||||
ephyr.h
|
||||
|
||||
libxephyr_hostx_a_SOURCES = \
|
||||
hostx.c \
|
||||
|
@ -20,19 +14,54 @@ libxephyr_hostx_a_SOURCES = \
|
|||
|
||||
libxephyr_hostx_a_INCLUDES = @XEPHYR_INCS@
|
||||
|
||||
libxephyr_hostxv_a_SOURCES= \
|
||||
ephyrhostvideo.c \
|
||||
ephyrhostvideo.h
|
||||
|
||||
libxephyr_a_SOURCES = \
|
||||
ephyr.c \
|
||||
ephyr_draw.c \
|
||||
ephyrvideo.c \
|
||||
XF86dri.c \
|
||||
ephyrdriext.c \
|
||||
ephyrdri.c \
|
||||
ephyrdri.h \
|
||||
ephyrglxext.c \
|
||||
ephyrglxext.h \
|
||||
ephyrhostglx.c \
|
||||
ephyrhostglx.h \
|
||||
ephyrhostproxy.c \
|
||||
ephyrhostproxy.h \
|
||||
ephyrhostproxy.c \
|
||||
ephyrproxyext.c \
|
||||
ephyrproxyext.h \
|
||||
os.c \
|
||||
hostx.h \
|
||||
ephyr.h \
|
||||
ephyrlog.h
|
||||
|
||||
libxephyr_a_CFLAGS = \
|
||||
@LIBDRM_CFLAGS@ \
|
||||
-I$(top_srcdir) \
|
||||
@DRIPROTO_CFLAGS@
|
||||
|
||||
Xephyr_SOURCES = \
|
||||
ephyrinit.c
|
||||
|
||||
Xephyr_LDADD = \
|
||||
libxephyr.a \
|
||||
libxephyr-hostx.a \
|
||||
libxephyr-hostxv.a \
|
||||
../../../exa/libexa.la \
|
||||
@KDRIVE_LIBS@ \
|
||||
@XEPHYR_LIBS@
|
||||
@XEPHYR_LIBS@ \
|
||||
@LIBDRM_LIBS@ \
|
||||
-lGL
|
||||
|
||||
Xephyr_DEPENDENCIES = \
|
||||
libxephyr.a \
|
||||
libxephyr-hostx.a \
|
||||
libxephyr-hostxv.a \
|
||||
@KDRIVE_LOCAL_LIBS@
|
||||
|
||||
relink:
|
||||
|
|
622
hw/kdrive/ephyr/XF86dri.c
Normal file
622
hw/kdrive/ephyr/XF86dri.c
Normal file
|
@ -0,0 +1,622 @@
|
|||
/* $XFree86: xc/lib/GL/dri/XF86dri.c,v 1.13 2002/10/30 12:51:25 alanh Exp $ */
|
||||
/**************************************************************************
|
||||
|
||||
Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
|
||||
Copyright 2000 VA Linux Systems, Inc.
|
||||
All Rights Reserved.
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a
|
||||
copy of this software and associated documentation files (the
|
||||
"Software"), to deal in the Software without restriction, including
|
||||
without limitation the rights to use, copy, modify, merge, publish,
|
||||
distribute, sub license, and/or sell copies of the Software, and to
|
||||
permit persons to whom the Software is furnished to do so, subject to
|
||||
the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice (including the
|
||||
next paragraph) shall be included in all copies or substantial portions
|
||||
of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
|
||||
IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
|
||||
ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
||||
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
||||
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
**************************************************************************/
|
||||
|
||||
/*
|
||||
* Authors:
|
||||
* Kevin E. Martin <martin@valinux.com>
|
||||
* Jens Owen <jens@tungstengraphics.com>
|
||||
* Rickard E. (Rik) Faith <faith@valinux.com>
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* This file has been copied from the mesa source tree and a little bit
|
||||
* modified by:
|
||||
*
|
||||
* Dodji Seketeli <dodji@openedhand.com>
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <kdrive-config.h>
|
||||
#endif
|
||||
|
||||
#ifdef XEPHYR_DRI
|
||||
|
||||
/* THIS IS NOT AN X CONSORTIUM STANDARD */
|
||||
|
||||
#define NEED_REPLIES
|
||||
#include <X11/Xlibint.h>
|
||||
#include <X11/extensions/Xext.h>
|
||||
#include <X11/extensions/extutil.h>
|
||||
#include <GL/glx.h>
|
||||
#include <X11/dri/xf86dri.h>
|
||||
#include <X11/dri/xf86dristr.h>
|
||||
|
||||
static XExtensionInfo _xf86dri_info_data;
|
||||
static XExtensionInfo *xf86dri_info = &_xf86dri_info_data;
|
||||
static char xf86dri_extension_name[] = XF86DRINAME;
|
||||
|
||||
#define XF86DRICheckExtension(dpy,i,val) \
|
||||
XextCheckExtension (dpy, i, xf86dri_extension_name, val)
|
||||
|
||||
/*****************************************************************************
|
||||
* *
|
||||
* private utility routines *
|
||||
* *
|
||||
*****************************************************************************/
|
||||
|
||||
static int close_display(Display *dpy, XExtCodes *extCodes);
|
||||
static /* const */ XExtensionHooks xf86dri_extension_hooks = {
|
||||
NULL, /* create_gc */
|
||||
NULL, /* copy_gc */
|
||||
NULL, /* flush_gc */
|
||||
NULL, /* free_gc */
|
||||
NULL, /* create_font */
|
||||
NULL, /* free_font */
|
||||
close_display, /* close_display */
|
||||
NULL, /* wire_to_event */
|
||||
NULL, /* event_to_wire */
|
||||
NULL, /* error */
|
||||
NULL, /* error_string */
|
||||
};
|
||||
|
||||
static XEXT_GENERATE_FIND_DISPLAY (find_display, xf86dri_info,
|
||||
xf86dri_extension_name,
|
||||
&xf86dri_extension_hooks,
|
||||
0, NULL)
|
||||
|
||||
static XEXT_GENERATE_CLOSE_DISPLAY (close_display, xf86dri_info)
|
||||
|
||||
|
||||
/*****************************************************************************
|
||||
* *
|
||||
* public XFree86-DRI Extension routines *
|
||||
* *
|
||||
*****************************************************************************/
|
||||
|
||||
#if 0
|
||||
#include <stdio.h>
|
||||
#define TRACE(msg) fprintf(stderr,"XF86DRI%s\n", msg);
|
||||
#else
|
||||
#define TRACE(msg)
|
||||
#endif
|
||||
|
||||
Bool XF86DRIOpenFullScreen(Display *dpy, int screen, Drawable drawable);
|
||||
Bool XF86DRICloseFullScreen(Display *dpy, int screen, Drawable drawable);
|
||||
|
||||
Bool XF86DRIQueryExtension (Display *dpy, int *event_basep, int *error_basep)
|
||||
{
|
||||
XExtDisplayInfo *info = find_display (dpy);
|
||||
|
||||
TRACE("QueryExtension...");
|
||||
if (XextHasExtension(info)) {
|
||||
*event_basep = info->codes->first_event;
|
||||
*error_basep = info->codes->first_error;
|
||||
TRACE("QueryExtension... return True");
|
||||
return True;
|
||||
} else {
|
||||
TRACE("QueryExtension... return False");
|
||||
return False;
|
||||
}
|
||||
}
|
||||
|
||||
Bool XF86DRIQueryVersion(dpy, majorVersion, minorVersion, patchVersion)
|
||||
Display* dpy;
|
||||
int* majorVersion;
|
||||
int* minorVersion;
|
||||
int* patchVersion;
|
||||
{
|
||||
XExtDisplayInfo *info = find_display (dpy);
|
||||
xXF86DRIQueryVersionReply rep;
|
||||
xXF86DRIQueryVersionReq *req;
|
||||
|
||||
TRACE("QueryVersion...");
|
||||
XF86DRICheckExtension (dpy, info, False);
|
||||
|
||||
LockDisplay(dpy);
|
||||
GetReq(XF86DRIQueryVersion, req);
|
||||
req->reqType = info->codes->major_opcode;
|
||||
req->driReqType = X_XF86DRIQueryVersion;
|
||||
if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
|
||||
UnlockDisplay(dpy);
|
||||
SyncHandle();
|
||||
TRACE("QueryVersion... return False");
|
||||
return False;
|
||||
}
|
||||
*majorVersion = rep.majorVersion;
|
||||
*minorVersion = rep.minorVersion;
|
||||
*patchVersion = rep.patchVersion;
|
||||
UnlockDisplay(dpy);
|
||||
SyncHandle();
|
||||
TRACE("QueryVersion... return True");
|
||||
return True;
|
||||
}
|
||||
|
||||
Bool
|
||||
XF86DRIQueryDirectRenderingCapable (Display *dpy, int screen, Bool *isCapable)
|
||||
{
|
||||
XExtDisplayInfo *info = find_display (dpy);
|
||||
xXF86DRIQueryDirectRenderingCapableReply rep;
|
||||
xXF86DRIQueryDirectRenderingCapableReq *req;
|
||||
|
||||
TRACE("QueryDirectRenderingCapable...");
|
||||
XF86DRICheckExtension (dpy, info, False);
|
||||
|
||||
LockDisplay(dpy);
|
||||
GetReq(XF86DRIQueryDirectRenderingCapable, req);
|
||||
req->reqType = info->codes->major_opcode;
|
||||
req->driReqType = X_XF86DRIQueryDirectRenderingCapable;
|
||||
req->screen = screen;
|
||||
if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
|
||||
UnlockDisplay(dpy);
|
||||
SyncHandle();
|
||||
TRACE("QueryDirectRenderingCapable... return False");
|
||||
return False;
|
||||
}
|
||||
*isCapable = rep.isCapable;
|
||||
UnlockDisplay(dpy);
|
||||
SyncHandle();
|
||||
TRACE("QueryDirectRenderingCapable... return True");
|
||||
return True;
|
||||
}
|
||||
|
||||
Bool
|
||||
XF86DRIOpenConnection (Display *dpy, int screen,
|
||||
drm_handle_t *hSAREA,
|
||||
char **busIdString)
|
||||
{
|
||||
XExtDisplayInfo *info = find_display (dpy);
|
||||
xXF86DRIOpenConnectionReply rep;
|
||||
xXF86DRIOpenConnectionReq *req;
|
||||
|
||||
TRACE("OpenConnection...");
|
||||
XF86DRICheckExtension (dpy, info, False);
|
||||
|
||||
LockDisplay(dpy);
|
||||
GetReq(XF86DRIOpenConnection, req);
|
||||
req->reqType = info->codes->major_opcode;
|
||||
req->driReqType = X_XF86DRIOpenConnection;
|
||||
req->screen = screen;
|
||||
if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
|
||||
UnlockDisplay(dpy);
|
||||
SyncHandle();
|
||||
TRACE("OpenConnection... return False");
|
||||
return False;
|
||||
}
|
||||
|
||||
*hSAREA = rep.hSAREALow;
|
||||
if (sizeof(drm_handle_t) == 8) {
|
||||
int shift = 32; /* var to prevent warning on next line */
|
||||
*hSAREA |= ((drm_handle_t) rep.hSAREAHigh) << shift;
|
||||
}
|
||||
|
||||
if (rep.length) {
|
||||
if (!(*busIdString = (char *)Xcalloc(rep.busIdStringLength + 1, 1))) {
|
||||
_XEatData(dpy, ((rep.busIdStringLength+3) & ~3));
|
||||
UnlockDisplay(dpy);
|
||||
SyncHandle();
|
||||
TRACE("OpenConnection... return False");
|
||||
return False;
|
||||
}
|
||||
_XReadPad(dpy, *busIdString, rep.busIdStringLength);
|
||||
} else {
|
||||
*busIdString = NULL;
|
||||
}
|
||||
UnlockDisplay(dpy);
|
||||
SyncHandle();
|
||||
TRACE("OpenConnection... return True");
|
||||
return True;
|
||||
}
|
||||
|
||||
Bool XF86DRIAuthConnection(dpy, screen, magic)
|
||||
Display* dpy;
|
||||
int screen;
|
||||
drm_magic_t magic;
|
||||
{
|
||||
XExtDisplayInfo *info = find_display (dpy);
|
||||
xXF86DRIAuthConnectionReq *req;
|
||||
xXF86DRIAuthConnectionReply rep;
|
||||
|
||||
TRACE("AuthConnection...");
|
||||
XF86DRICheckExtension (dpy, info, False);
|
||||
|
||||
LockDisplay(dpy);
|
||||
GetReq(XF86DRIAuthConnection, req);
|
||||
req->reqType = info->codes->major_opcode;
|
||||
req->driReqType = X_XF86DRIAuthConnection;
|
||||
req->screen = screen;
|
||||
req->magic = magic;
|
||||
rep.authenticated = 0;
|
||||
if (!_XReply(dpy, (xReply *)&rep, 0, xFalse) || !rep.authenticated) {
|
||||
UnlockDisplay(dpy);
|
||||
SyncHandle();
|
||||
TRACE("AuthConnection... return False");
|
||||
return False;
|
||||
}
|
||||
UnlockDisplay(dpy);
|
||||
SyncHandle();
|
||||
TRACE("AuthConnection... return True");
|
||||
return True;
|
||||
}
|
||||
|
||||
Bool XF86DRICloseConnection(dpy, screen)
|
||||
Display* dpy;
|
||||
int screen;
|
||||
{
|
||||
XExtDisplayInfo *info = find_display (dpy);
|
||||
xXF86DRICloseConnectionReq *req;
|
||||
|
||||
TRACE("CloseConnection...");
|
||||
|
||||
XF86DRICheckExtension (dpy, info, False);
|
||||
|
||||
LockDisplay(dpy);
|
||||
GetReq(XF86DRICloseConnection, req);
|
||||
req->reqType = info->codes->major_opcode;
|
||||
req->driReqType = X_XF86DRICloseConnection;
|
||||
req->screen = screen;
|
||||
UnlockDisplay(dpy);
|
||||
SyncHandle();
|
||||
TRACE("CloseConnection... return True");
|
||||
return True;
|
||||
}
|
||||
|
||||
Bool XF86DRIGetClientDriverName(dpy, screen, ddxDriverMajorVersion,
|
||||
ddxDriverMinorVersion, ddxDriverPatchVersion, clientDriverName)
|
||||
Display* dpy;
|
||||
int screen;
|
||||
int* ddxDriverMajorVersion;
|
||||
int* ddxDriverMinorVersion;
|
||||
int* ddxDriverPatchVersion;
|
||||
char** clientDriverName;
|
||||
{
|
||||
XExtDisplayInfo *info = find_display (dpy);
|
||||
xXF86DRIGetClientDriverNameReply rep;
|
||||
xXF86DRIGetClientDriverNameReq *req;
|
||||
|
||||
TRACE("GetClientDriverName...");
|
||||
XF86DRICheckExtension (dpy, info, False);
|
||||
|
||||
LockDisplay(dpy);
|
||||
GetReq(XF86DRIGetClientDriverName, req);
|
||||
req->reqType = info->codes->major_opcode;
|
||||
req->driReqType = X_XF86DRIGetClientDriverName;
|
||||
req->screen = screen;
|
||||
if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
|
||||
UnlockDisplay(dpy);
|
||||
SyncHandle();
|
||||
TRACE("GetClientDriverName... return False");
|
||||
return False;
|
||||
}
|
||||
|
||||
*ddxDriverMajorVersion = rep.ddxDriverMajorVersion;
|
||||
*ddxDriverMinorVersion = rep.ddxDriverMinorVersion;
|
||||
*ddxDriverPatchVersion = rep.ddxDriverPatchVersion;
|
||||
|
||||
if (rep.length) {
|
||||
if (!(*clientDriverName = (char *)Xcalloc(rep.clientDriverNameLength + 1, 1))) {
|
||||
_XEatData(dpy, ((rep.clientDriverNameLength+3) & ~3));
|
||||
UnlockDisplay(dpy);
|
||||
SyncHandle();
|
||||
TRACE("GetClientDriverName... return False");
|
||||
return False;
|
||||
}
|
||||
_XReadPad(dpy, *clientDriverName, rep.clientDriverNameLength);
|
||||
} else {
|
||||
*clientDriverName = NULL;
|
||||
}
|
||||
UnlockDisplay(dpy);
|
||||
SyncHandle();
|
||||
TRACE("GetClientDriverName... return True");
|
||||
return True;
|
||||
}
|
||||
|
||||
Bool XF86DRICreateContextWithConfig(dpy, screen, configID, context,
|
||||
hHWContext)
|
||||
Display* dpy;
|
||||
int screen;
|
||||
int configID;
|
||||
XID* context;
|
||||
drm_context_t * hHWContext;
|
||||
{
|
||||
XExtDisplayInfo *info = find_display (dpy);
|
||||
xXF86DRICreateContextReply rep;
|
||||
xXF86DRICreateContextReq *req;
|
||||
|
||||
TRACE("CreateContext...");
|
||||
XF86DRICheckExtension (dpy, info, False);
|
||||
|
||||
LockDisplay(dpy);
|
||||
GetReq(XF86DRICreateContext, req);
|
||||
req->reqType = info->codes->major_opcode;
|
||||
req->driReqType = X_XF86DRICreateContext;
|
||||
req->visual = configID;
|
||||
req->screen = screen;
|
||||
*context = XAllocID(dpy);
|
||||
req->context = *context;
|
||||
if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
|
||||
UnlockDisplay(dpy);
|
||||
SyncHandle();
|
||||
TRACE("CreateContext... return False");
|
||||
return False;
|
||||
}
|
||||
*hHWContext = rep.hHWContext;
|
||||
UnlockDisplay(dpy);
|
||||
SyncHandle();
|
||||
TRACE("CreateContext... return True");
|
||||
return True;
|
||||
}
|
||||
|
||||
Bool XF86DRICreateContext(dpy, screen, visual, context, hHWContext)
|
||||
Display* dpy;
|
||||
int screen;
|
||||
Visual* visual;
|
||||
XID* context;
|
||||
drm_context_t * hHWContext;
|
||||
{
|
||||
return XF86DRICreateContextWithConfig( dpy, screen, visual->visualid,
|
||||
context, hHWContext );
|
||||
}
|
||||
|
||||
GLboolean XF86DRIDestroyContext( __DRInativeDisplay * ndpy, int screen,
|
||||
__DRIid context )
|
||||
{
|
||||
Display * const dpy = (Display *) ndpy;
|
||||
XExtDisplayInfo *info = find_display (dpy);
|
||||
xXF86DRIDestroyContextReq *req;
|
||||
|
||||
TRACE("DestroyContext...");
|
||||
XF86DRICheckExtension (dpy, info, False);
|
||||
|
||||
LockDisplay(dpy);
|
||||
GetReq(XF86DRIDestroyContext, req);
|
||||
req->reqType = info->codes->major_opcode;
|
||||
req->driReqType = X_XF86DRIDestroyContext;
|
||||
req->screen = screen;
|
||||
req->context = context;
|
||||
UnlockDisplay(dpy);
|
||||
SyncHandle();
|
||||
TRACE("DestroyContext... return True");
|
||||
return True;
|
||||
}
|
||||
|
||||
GLboolean XF86DRICreateDrawable( __DRInativeDisplay * ndpy, int screen,
|
||||
__DRIid drawable, drm_drawable_t * hHWDrawable )
|
||||
{
|
||||
Display * const dpy = (Display *) ndpy;
|
||||
XExtDisplayInfo *info = find_display (dpy);
|
||||
xXF86DRICreateDrawableReply rep;
|
||||
xXF86DRICreateDrawableReq *req;
|
||||
|
||||
TRACE("CreateDrawable...");
|
||||
XF86DRICheckExtension (dpy, info, False);
|
||||
|
||||
LockDisplay(dpy);
|
||||
GetReq(XF86DRICreateDrawable, req);
|
||||
req->reqType = info->codes->major_opcode;
|
||||
req->driReqType = X_XF86DRICreateDrawable;
|
||||
req->screen = screen;
|
||||
req->drawable = drawable;
|
||||
if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
|
||||
UnlockDisplay(dpy);
|
||||
SyncHandle();
|
||||
TRACE("CreateDrawable... return False");
|
||||
return False;
|
||||
}
|
||||
*hHWDrawable = rep.hHWDrawable;
|
||||
UnlockDisplay(dpy);
|
||||
SyncHandle();
|
||||
TRACE("CreateDrawable... return True");
|
||||
return True;
|
||||
}
|
||||
|
||||
GLboolean XF86DRIDestroyDrawable( __DRInativeDisplay * ndpy, int screen,
|
||||
__DRIid drawable )
|
||||
{
|
||||
Display * const dpy = (Display *) ndpy;
|
||||
XExtDisplayInfo *info = find_display (dpy);
|
||||
xXF86DRIDestroyDrawableReq *req;
|
||||
|
||||
TRACE("DestroyDrawable...");
|
||||
XF86DRICheckExtension (dpy, info, False);
|
||||
|
||||
LockDisplay(dpy);
|
||||
GetReq(XF86DRIDestroyDrawable, req);
|
||||
req->reqType = info->codes->major_opcode;
|
||||
req->driReqType = X_XF86DRIDestroyDrawable;
|
||||
req->screen = screen;
|
||||
req->drawable = drawable;
|
||||
UnlockDisplay(dpy);
|
||||
SyncHandle();
|
||||
TRACE("DestroyDrawable... return True");
|
||||
return True;
|
||||
}
|
||||
|
||||
Bool XF86DRIGetDrawableInfo(Display* dpy, int screen, Drawable drawable,
|
||||
unsigned int* index, unsigned int* stamp,
|
||||
int* X, int* Y, int* W, int* H,
|
||||
int* numClipRects, drm_clip_rect_t ** pClipRects,
|
||||
int* backX, int* backY,
|
||||
int* numBackClipRects, drm_clip_rect_t ** pBackClipRects )
|
||||
{
|
||||
XExtDisplayInfo *info = find_display (dpy);
|
||||
xXF86DRIGetDrawableInfoReply rep;
|
||||
xXF86DRIGetDrawableInfoReq *req=NULL;
|
||||
int total_rects;
|
||||
|
||||
TRACE("GetDrawableInfo...");
|
||||
XF86DRICheckExtension (dpy, info, False);
|
||||
|
||||
LockDisplay(dpy);
|
||||
GetReq(XF86DRIGetDrawableInfo, req);
|
||||
req->reqType = info->codes->major_opcode;
|
||||
req->driReqType = X_XF86DRIGetDrawableInfo;
|
||||
req->screen = screen;
|
||||
req->drawable = drawable;
|
||||
|
||||
if (!_XReply(dpy, (xReply *)&rep, 1, xFalse))
|
||||
{
|
||||
UnlockDisplay(dpy);
|
||||
SyncHandle();
|
||||
TRACE("GetDrawableInfo... return False");
|
||||
return False;
|
||||
}
|
||||
*index = rep.drawableTableIndex;
|
||||
*stamp = rep.drawableTableStamp;
|
||||
*X = (int)rep.drawableX;
|
||||
*Y = (int)rep.drawableY;
|
||||
*W = (int)rep.drawableWidth;
|
||||
*H = (int)rep.drawableHeight;
|
||||
*numClipRects = rep.numClipRects;
|
||||
total_rects = *numClipRects;
|
||||
|
||||
*backX = rep.backX;
|
||||
*backY = rep.backY;
|
||||
*numBackClipRects = rep.numBackClipRects;
|
||||
total_rects += *numBackClipRects;
|
||||
|
||||
#if 0
|
||||
/* Because of the fix in Xserver/GL/dri/xf86dri.c, this check breaks
|
||||
* backwards compatibility (Because of the >> 2 shift) but the fix
|
||||
* enables multi-threaded apps to work.
|
||||
*/
|
||||
if (rep.length != ((((SIZEOF(xXF86DRIGetDrawableInfoReply) -
|
||||
SIZEOF(xGenericReply) +
|
||||
total_rects * sizeof(drm_clip_rect_t)) + 3) & ~3) >> 2)) {
|
||||
_XEatData(dpy, rep.length);
|
||||
UnlockDisplay(dpy);
|
||||
SyncHandle();
|
||||
TRACE("GetDrawableInfo... return False");
|
||||
return False;
|
||||
}
|
||||
#endif
|
||||
|
||||
if (*numClipRects) {
|
||||
int len = sizeof(drm_clip_rect_t) * (*numClipRects);
|
||||
|
||||
*pClipRects = (drm_clip_rect_t *)Xcalloc(len, 1);
|
||||
if (*pClipRects)
|
||||
_XRead(dpy, (char*)*pClipRects, len);
|
||||
} else {
|
||||
*pClipRects = NULL;
|
||||
}
|
||||
|
||||
if (*numBackClipRects) {
|
||||
int len = sizeof(drm_clip_rect_t) * (*numBackClipRects);
|
||||
|
||||
*pBackClipRects = (drm_clip_rect_t *)Xcalloc(len, 1);
|
||||
if (*pBackClipRects)
|
||||
_XRead(dpy, (char*)*pBackClipRects, len);
|
||||
} else {
|
||||
*pBackClipRects = NULL;
|
||||
}
|
||||
|
||||
UnlockDisplay(dpy);
|
||||
SyncHandle();
|
||||
TRACE("GetDrawableInfo... return True");
|
||||
return True;
|
||||
}
|
||||
|
||||
Bool
|
||||
XF86DRIGetDeviceInfo (Display *dpy, int screen, drm_handle_t *hFrameBuffer,
|
||||
int *fbOrigin, int *fbSize, int *fbStride,
|
||||
int *devPrivateSize, void **pDevPrivate)
|
||||
{
|
||||
XExtDisplayInfo *info = find_display (dpy);
|
||||
xXF86DRIGetDeviceInfoReply rep;
|
||||
xXF86DRIGetDeviceInfoReq *req;
|
||||
|
||||
TRACE("GetDeviceInfo...");
|
||||
XF86DRICheckExtension (dpy, info, False);
|
||||
|
||||
LockDisplay(dpy);
|
||||
GetReq(XF86DRIGetDeviceInfo, req);
|
||||
req->reqType = info->codes->major_opcode;
|
||||
req->driReqType = X_XF86DRIGetDeviceInfo;
|
||||
req->screen = screen;
|
||||
if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
|
||||
UnlockDisplay(dpy);
|
||||
SyncHandle();
|
||||
TRACE("GetDeviceInfo... return False");
|
||||
return False;
|
||||
}
|
||||
|
||||
*hFrameBuffer = rep.hFrameBufferLow;
|
||||
if (sizeof(drm_handle_t) == 8) {
|
||||
int shift = 32; /* var to prevent warning on next line */
|
||||
*hFrameBuffer |= ((drm_handle_t) rep.hFrameBufferHigh) << shift;
|
||||
}
|
||||
|
||||
*fbOrigin = rep.framebufferOrigin;
|
||||
*fbSize = rep.framebufferSize;
|
||||
*fbStride = rep.framebufferStride;
|
||||
*devPrivateSize = rep.devPrivateSize;
|
||||
|
||||
if (rep.length) {
|
||||
if (!(*pDevPrivate = (void *)Xcalloc(rep.devPrivateSize, 1))) {
|
||||
_XEatData(dpy, ((rep.devPrivateSize+3) & ~3));
|
||||
UnlockDisplay(dpy);
|
||||
SyncHandle();
|
||||
TRACE("GetDeviceInfo... return False");
|
||||
return False;
|
||||
}
|
||||
_XRead(dpy, (char*)*pDevPrivate, rep.devPrivateSize);
|
||||
} else {
|
||||
*pDevPrivate = NULL;
|
||||
}
|
||||
|
||||
UnlockDisplay(dpy);
|
||||
SyncHandle();
|
||||
TRACE("GetDeviceInfo... return True");
|
||||
return True;
|
||||
}
|
||||
|
||||
Bool
|
||||
XF86DRIOpenFullScreen(Display *dpy, int screen, Drawable drawable)
|
||||
{
|
||||
/* This function and the underlying X protocol are deprecated.
|
||||
*/
|
||||
(void) dpy;
|
||||
(void) screen;
|
||||
(void) drawable;
|
||||
return False;
|
||||
}
|
||||
|
||||
Bool
|
||||
XF86DRICloseFullScreen(Display *dpy, int screen, Drawable drawable)
|
||||
{
|
||||
/* This function and the underlying X protocol are deprecated.
|
||||
*/
|
||||
(void) dpy;
|
||||
(void) screen;
|
||||
(void) drawable;
|
||||
return True;
|
||||
}
|
||||
#endif /*EPHYR_DRI*/
|
||||
|
|
@ -23,11 +23,6 @@
|
|||
* PERFORMANCE OF THIS SOFTWARE.
|
||||
*/
|
||||
|
||||
/* TODO:
|
||||
*
|
||||
* o Support multiple screens, shouldn't be hard just alot of rejigging.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <kdrive-config.h>
|
||||
#endif
|
||||
|
@ -35,11 +30,25 @@
|
|||
|
||||
#include "inputstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "ephyrlog.h"
|
||||
|
||||
#ifdef XEPHYR_DRI
|
||||
#include "ephyrdri.h"
|
||||
#include "ephyrdriext.h"
|
||||
#include "ephyrglxext.h"
|
||||
#include "ephyrproxyext.h"
|
||||
#endif /*XEPHYR_DRI*/
|
||||
|
||||
extern int KdTsPhyScreen;
|
||||
#ifdef GLXEXT
|
||||
extern Bool noGlxVisualInit;
|
||||
#endif
|
||||
|
||||
KdKeyboardInfo *ephyrKbd;
|
||||
KdPointerInfo *ephyrMouse;
|
||||
EphyrKeySyms ephyrKeySyms;
|
||||
Bool ephyrNoDRI=FALSE ;
|
||||
Bool ephyrNoXV=FALSE ;
|
||||
|
||||
static int mouseState = 0;
|
||||
|
||||
|
@ -49,6 +58,7 @@ typedef struct _EphyrInputPrivate {
|
|||
|
||||
Bool EphyrWantGrayScale = 0;
|
||||
|
||||
|
||||
Bool
|
||||
ephyrInitialize (KdCardInfo *card, EphyrPriv *priv)
|
||||
{
|
||||
|
@ -209,7 +219,7 @@ ephyrMapFramebuffer (KdScreenInfo *screen)
|
|||
KdPointerMatrix m;
|
||||
int buffer_height;
|
||||
|
||||
EPHYR_DBG("screen->width: %d, screen->height: %d index=%d",
|
||||
EPHYR_LOG("screen->width: %d, screen->height: %d index=%d",
|
||||
screen->width, screen->height, screen->mynum);
|
||||
|
||||
KdComputePointerMatrix (&m, scrpriv->randr, screen->width, screen->height);
|
||||
|
@ -245,7 +255,7 @@ ephyrMapFramebuffer (KdScreenInfo *screen)
|
|||
/* Rotated/Reflected so we need to use shadow fb */
|
||||
scrpriv->shadow = TRUE;
|
||||
|
||||
EPHYR_DBG("allocing shadow");
|
||||
EPHYR_LOG("allocing shadow");
|
||||
|
||||
KdShadowFbAlloc (screen, 0,
|
||||
scrpriv->randr & (RR_Rotate_90|RR_Rotate_270));
|
||||
|
@ -296,7 +306,7 @@ ephyrShadowUpdate (ScreenPtr pScreen, shadowBufPtr pBuf)
|
|||
KdScreenPriv(pScreen);
|
||||
KdScreenInfo *screen = pScreenPriv->screen;
|
||||
|
||||
EPHYR_DBG("slow paint");
|
||||
EPHYR_LOG("slow paint");
|
||||
|
||||
/* FIXME: Slow Rotated/Reflected updates could be much
|
||||
* much faster efficiently updating via tranforming
|
||||
|
@ -410,7 +420,7 @@ ephyrRandRGetInfo (ScreenPtr pScreen, Rotation *rotations)
|
|||
Rotation randr;
|
||||
int n = 0;
|
||||
|
||||
EPHYR_DBG("mark");
|
||||
EPHYR_LOG("mark");
|
||||
|
||||
struct { int width, height; } sizes[] =
|
||||
{
|
||||
|
@ -563,7 +573,7 @@ ephyrRandRSetConfig (ScreenPtr pScreen,
|
|||
return TRUE;
|
||||
|
||||
bail4:
|
||||
EPHYR_DBG("bailed");
|
||||
EPHYR_LOG("bailed");
|
||||
|
||||
ephyrUnmapFramebuffer (screen);
|
||||
*scrpriv = oldscr;
|
||||
|
@ -606,10 +616,40 @@ ephyrInitScreen (ScreenPtr pScreen)
|
|||
KdScreenPriv(pScreen);
|
||||
KdScreenInfo *screen = pScreenPriv->screen;
|
||||
|
||||
EPHYR_DBG ("pScreen->myNum:%d\n", pScreen->myNum) ;
|
||||
EPHYR_LOG ("pScreen->myNum:%d\n", pScreen->myNum) ;
|
||||
hostx_set_screen_number (screen, pScreen->myNum);
|
||||
hostx_set_win_title (screen, "(ctrl+shift grabs mouse and keyboard)") ;
|
||||
pScreen->CreateColormap = ephyrCreateColormap;
|
||||
|
||||
#ifdef XV
|
||||
if (!ephyrNoXV) {
|
||||
if (!ephyrInitVideo (pScreen)) {
|
||||
EPHYR_LOG_ERROR ("failed to initialize xvideo\n") ;
|
||||
} else {
|
||||
EPHYR_LOG ("initialized xvideo okay\n") ;
|
||||
}
|
||||
}
|
||||
#endif /*XV*/
|
||||
|
||||
#ifdef XEPHYR_DRI
|
||||
if (!ephyrNoDRI && !hostx_has_dri ()) {
|
||||
EPHYR_LOG ("host x does not support DRI. Disabling DRI forwarding\n") ;
|
||||
ephyrNoDRI = TRUE ;
|
||||
noGlxVisualInit = FALSE ;
|
||||
}
|
||||
if (!ephyrNoDRI) {
|
||||
ephyrDRIExtensionInit (pScreen) ;
|
||||
ephyrHijackGLXExtension () ;
|
||||
ephyrProxyExtensionInit ("ATIFGLRXDRI") ;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef GLXEXT
|
||||
if (ephyrNoDRI) {
|
||||
noGlxVisualInit = FALSE ;
|
||||
}
|
||||
#endif
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
@ -637,7 +677,7 @@ ephyrCreateResources (ScreenPtr pScreen)
|
|||
KdScreenInfo *screen = pScreenPriv->screen;
|
||||
EphyrScrPriv *scrpriv = screen->driver;
|
||||
|
||||
EPHYR_DBG("mark pScreen=%p mynum=%d shadow=%d",
|
||||
EPHYR_LOG("mark pScreen=%p mynum=%d shadow=%d",
|
||||
pScreen, pScreen->myNum, scrpriv->shadow);
|
||||
|
||||
if (scrpriv->shadow)
|
||||
|
@ -809,20 +849,20 @@ ephyrPoll(void)
|
|||
case EPHYR_EV_MOUSE_MOTION:
|
||||
if (!ephyrMouse ||
|
||||
!((EphyrPointerPrivate *)ephyrMouse->driverPrivate)->enabled) {
|
||||
EPHYR_DBG ("skipping mouse motion:%d\n", ephyrCurScreen) ;
|
||||
EPHYR_LOG ("skipping mouse motion:%d\n", ephyrCurScreen) ;
|
||||
continue;
|
||||
}
|
||||
{
|
||||
if (ephyrCurScreen != ev.data.mouse_motion.screen)
|
||||
{
|
||||
EPHYR_DBG ("warping mouse cursor:%d\n", ephyrCurScreen) ;
|
||||
EPHYR_LOG ("warping mouse cursor:%d\n", ephyrCurScreen) ;
|
||||
ephyrWarpCursor(screenInfo.screens[ev.data.mouse_motion.screen],
|
||||
ev.data.mouse_motion.x,
|
||||
ev.data.mouse_motion.y );
|
||||
}
|
||||
else
|
||||
{
|
||||
EPHYR_DBG ("enqueuing mouse motion:%d\n", ephyrCurScreen) ;
|
||||
EPHYR_LOG ("enqueuing mouse motion:%d\n", ephyrCurScreen) ;
|
||||
KdEnqueuePointerEvent(ephyrMouse, mouseState,
|
||||
ev.data.mouse_motion.x,
|
||||
ev.data.mouse_motion.y,
|
||||
|
@ -834,10 +874,10 @@ ephyrPoll(void)
|
|||
case EPHYR_EV_MOUSE_PRESS:
|
||||
if (!ephyrMouse ||
|
||||
!((EphyrPointerPrivate *)ephyrMouse->driverPrivate)->enabled) {
|
||||
EPHYR_DBG ("skipping mouse press:%d\n", ephyrCurScreen) ;
|
||||
EPHYR_LOG ("skipping mouse press:%d\n", ephyrCurScreen) ;
|
||||
continue;
|
||||
}
|
||||
EPHYR_DBG ("enqueuing mouse press:%d\n", ephyrCurScreen) ;
|
||||
EPHYR_LOG ("enqueuing mouse press:%d\n", ephyrCurScreen) ;
|
||||
ephyrUpdateModifierState(ev.key_state);
|
||||
mouseState |= ev.data.mouse_down.button_num;
|
||||
KdEnqueuePointerEvent(ephyrMouse, mouseState|KD_MOUSE_DELTA, 0, 0, 0);
|
||||
|
@ -849,7 +889,7 @@ ephyrPoll(void)
|
|||
continue;
|
||||
ephyrUpdateModifierState(ev.key_state);
|
||||
mouseState &= ~ev.data.mouse_up.button_num;
|
||||
EPHYR_DBG ("enqueuing mouse release:%d\n", ephyrCurScreen) ;
|
||||
EPHYR_LOG ("enqueuing mouse release:%d\n", ephyrCurScreen) ;
|
||||
KdEnqueuePointerEvent(ephyrMouse, mouseState|KD_MOUSE_DELTA, 0, 0, 0);
|
||||
break;
|
||||
|
||||
|
@ -886,7 +926,7 @@ ephyrGetColors (ScreenPtr pScreen, int fb, int n, xColorItem *pdefs)
|
|||
{
|
||||
/* XXX Not sure if this is right */
|
||||
|
||||
EPHYR_DBG("mark");
|
||||
EPHYR_LOG("mark");
|
||||
|
||||
while (n--)
|
||||
{
|
||||
|
@ -1025,6 +1065,7 @@ EphyrKeyboardBell (KdKeyboardInfo *ki, int volume, int frequency, int duration)
|
|||
{
|
||||
}
|
||||
|
||||
|
||||
KdKeyboardDriver EphyrKeyboardDriver = {
|
||||
"ephyr",
|
||||
EphyrKeyboardInit,
|
||||
|
|
|
@ -194,4 +194,8 @@ ephyrDrawDisable(ScreenPtr pScreen);
|
|||
void
|
||||
ephyrDrawFini(ScreenPtr pScreen);
|
||||
|
||||
/*ephyvideo.c*/
|
||||
|
||||
Bool ephyrInitVideo(ScreenPtr pScreen) ;
|
||||
|
||||
#endif
|
||||
|
|
291
hw/kdrive/ephyr/ephyrdri.c
Normal file
291
hw/kdrive/ephyr/ephyrdri.c
Normal file
|
@ -0,0 +1,291 @@
|
|||
/*
|
||||
* Xephyr - A kdrive X server thats runs in a host X window.
|
||||
* Authored by Matthew Allum <mallum@openedhand.com>
|
||||
*
|
||||
* Copyright © 2007 OpenedHand Ltd
|
||||
*
|
||||
* Permission to use, copy, modify, distribute, and sell this software and its
|
||||
* documentation for any purpose is hereby granted without fee, provided that
|
||||
* the above copyright notice appear in all copies and that both that
|
||||
* copyright notice and this permission notice appear in supporting
|
||||
* documentation, and that the name of OpenedHand Ltd not be used in
|
||||
* advertising or publicity pertaining to distribution of the software without
|
||||
* specific, written prior permission. OpenedHand Ltd makes no
|
||||
* representations about the suitability of this software for any purpose. It
|
||||
* is provided "as is" without express or implied warranty.
|
||||
*
|
||||
* OpenedHand Ltd DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
||||
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
|
||||
* EVENT SHALL OpenedHand Ltd BE LIABLE FOR ANY SPECIAL, INDIRECT OR
|
||||
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
||||
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
||||
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
||||
* PERFORMANCE OF THIS SOFTWARE.
|
||||
*
|
||||
* Authors:
|
||||
* Dodji Seketeli <dodji@openedhand.com>
|
||||
*/
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <kdrive-config.h>
|
||||
#endif
|
||||
|
||||
#ifdef XEPHYR_DRI
|
||||
|
||||
#include <X11/Xutil.h>
|
||||
#include <X11/Xlibint.h>
|
||||
/*#define _XF86DRI_SERVER_*/
|
||||
#include <GL/glx.h>
|
||||
#include <X11/dri/xf86dri.h>
|
||||
#include "hostx.h"
|
||||
#include "ephyrdri.h"
|
||||
#define _HAVE_XALLOC_DECLS
|
||||
#include "ephyrlog.h"
|
||||
#include "dixstruct.h"
|
||||
#include "pixmapstr.h"
|
||||
|
||||
#ifndef TRUE
|
||||
#define TRUE 1
|
||||
#endif /*TRUE*/
|
||||
|
||||
#ifndef FALSE
|
||||
#define FALSE 0
|
||||
#endif /*FALSE*/
|
||||
|
||||
Bool
|
||||
ephyrDRIQueryDirectRenderingCapable (int a_screen, Bool *a_is_capable)
|
||||
{
|
||||
Display *dpy=hostx_get_display () ;
|
||||
Bool is_ok=FALSE ;
|
||||
|
||||
EPHYR_RETURN_VAL_IF_FAIL (a_is_capable, FALSE) ;
|
||||
EPHYR_LOG ("enter\n") ;
|
||||
is_ok = XF86DRIQueryDirectRenderingCapable (dpy, DefaultScreen (dpy),
|
||||
a_is_capable) ;
|
||||
EPHYR_LOG ("leave. is_capable:%d, is_ok=%d\n", *a_is_capable, is_ok) ;
|
||||
|
||||
return is_ok ;
|
||||
}
|
||||
|
||||
Bool
|
||||
ephyrDRIOpenConnection (int a_screen,
|
||||
drm_handle_t *a_sarea,
|
||||
char **a_bus_id_string)
|
||||
{
|
||||
Display *dpy = hostx_get_display () ;
|
||||
Bool is_ok=FALSE ;
|
||||
|
||||
EPHYR_RETURN_VAL_IF_FAIL (a_bus_id_string, FALSE) ;
|
||||
EPHYR_LOG ("enter. screen:%d\n", a_screen) ;
|
||||
is_ok = XF86DRIOpenConnection (dpy, DefaultScreen (dpy),
|
||||
a_sarea,
|
||||
a_bus_id_string) ;
|
||||
if (*a_bus_id_string) {
|
||||
EPHYR_LOG ("leave. bus_id_string:%s, is_ok:%d\n",
|
||||
*a_bus_id_string, is_ok) ;
|
||||
} else {
|
||||
EPHYR_LOG ("leave. bus_id_string:null, is_ok:%d\n",
|
||||
is_ok) ;
|
||||
}
|
||||
return is_ok ;
|
||||
}
|
||||
|
||||
Bool
|
||||
ephyrDRIAuthConnection (int a_screen, drm_magic_t a_magic)
|
||||
{
|
||||
Display *dpy = hostx_get_display () ;
|
||||
Bool is_ok=FALSE ;
|
||||
|
||||
EPHYR_LOG ("enter\n") ;
|
||||
is_ok = XF86DRIAuthConnection (dpy, DefaultScreen (dpy), a_magic) ;
|
||||
EPHYR_LOG ("leave. is_ok:%d\n", is_ok) ;
|
||||
return is_ok ;
|
||||
}
|
||||
|
||||
Bool
|
||||
ephyrDRICloseConnection (int a_screen)
|
||||
{
|
||||
Display *dpy = hostx_get_display () ;
|
||||
Bool is_ok=FALSE ;
|
||||
|
||||
EPHYR_LOG ("enter\n") ;
|
||||
is_ok = XF86DRICloseConnection (dpy, DefaultScreen (dpy)) ;
|
||||
EPHYR_LOG ("leave\n") ;
|
||||
return is_ok ;
|
||||
}
|
||||
|
||||
Bool
|
||||
ephyrDRIGetClientDriverName (int a_screen,
|
||||
int *a_ddx_driver_major_version,
|
||||
int *a_ddx_driver_minor_version,
|
||||
int *a_ddx_driver_patch_version,
|
||||
char ** a_client_driver_name)
|
||||
{
|
||||
Display *dpy = hostx_get_display () ;
|
||||
Bool is_ok=FALSE ;
|
||||
|
||||
EPHYR_RETURN_VAL_IF_FAIL (a_ddx_driver_major_version
|
||||
&& a_ddx_driver_minor_version
|
||||
&& a_ddx_driver_patch_version
|
||||
&& a_client_driver_name,
|
||||
FALSE);
|
||||
EPHYR_LOG ("enter\n") ;
|
||||
is_ok = XF86DRIGetClientDriverName (dpy, DefaultScreen (dpy),
|
||||
a_ddx_driver_major_version,
|
||||
a_ddx_driver_minor_version,
|
||||
a_ddx_driver_patch_version,
|
||||
a_client_driver_name) ;
|
||||
EPHYR_LOG ("major:%d, minor:%d, patch:%d, name:%s\n",
|
||||
*a_ddx_driver_major_version,
|
||||
*a_ddx_driver_minor_version,
|
||||
*a_ddx_driver_patch_version,
|
||||
*a_client_driver_name) ;
|
||||
EPHYR_LOG ("leave:%d\n", is_ok) ;
|
||||
return is_ok ;
|
||||
}
|
||||
|
||||
Bool
|
||||
ephyrDRICreateContext (int a_screen,
|
||||
int a_visual_id,
|
||||
unsigned long int *a_returned_ctxt_id,
|
||||
drm_context_t *a_hw_ctxt)
|
||||
{
|
||||
Display *dpy = hostx_get_display () ;
|
||||
Bool is_ok=FALSE ;
|
||||
Visual v;
|
||||
|
||||
EPHYR_LOG ("enter. screen:%d, visual:%d\n", a_screen, a_visual_id) ;
|
||||
memset (&v, 0, sizeof (v)) ;
|
||||
v.visualid = a_visual_id ;
|
||||
is_ok = XF86DRICreateContext (dpy,
|
||||
DefaultScreen (dpy),
|
||||
&v,
|
||||
a_returned_ctxt_id,
|
||||
a_hw_ctxt) ;
|
||||
EPHYR_LOG ("leave:%d\n", is_ok) ;
|
||||
return is_ok ;
|
||||
}
|
||||
|
||||
Bool
|
||||
ephyrDRIDestroyContext (int a_screen,
|
||||
int a_context_id)
|
||||
{
|
||||
Display *dpy = hostx_get_display () ;
|
||||
Bool is_ok=FALSE ;
|
||||
|
||||
EPHYR_LOG ("enter\n") ;
|
||||
is_ok = XF86DRIDestroyContext (dpy, DefaultScreen (dpy), a_context_id) ;
|
||||
EPHYR_LOG ("leave:%d\n", is_ok) ;
|
||||
return is_ok ;
|
||||
}
|
||||
|
||||
Bool
|
||||
ephyrDRICreateDrawable (int a_screen,
|
||||
int a_drawable,
|
||||
drm_drawable_t *a_hw_drawable)
|
||||
{
|
||||
Bool is_ok=FALSE;
|
||||
Display *dpy=hostx_get_display () ;
|
||||
|
||||
EPHYR_LOG ("enter\n") ;
|
||||
is_ok = XF86DRICreateDrawable (dpy, DefaultScreen (dpy),
|
||||
a_drawable, a_hw_drawable) ;
|
||||
EPHYR_LOG ("leave. is_ok:%d\n", is_ok) ;
|
||||
return is_ok ;
|
||||
}
|
||||
|
||||
Bool
|
||||
ephyrDRIDestroyDrawable (int a_screen, int a_drawable)
|
||||
{
|
||||
EPHYR_LOG ("enter\n") ;
|
||||
EPHYR_LOG_ERROR ("not implemented yet\n") ;
|
||||
EPHYR_LOG ("leave\n") ;
|
||||
return FALSE ;
|
||||
}
|
||||
|
||||
Bool
|
||||
ephyrDRIGetDrawableInfo (int a_screen,
|
||||
int a_drawable,
|
||||
unsigned int *a_index,
|
||||
unsigned int *a_stamp,
|
||||
int *a_x,
|
||||
int *a_y,
|
||||
int *a_w,
|
||||
int *a_h,
|
||||
int *a_num_clip_rects,
|
||||
drm_clip_rect_t **a_clip_rects,
|
||||
int *a_back_x,
|
||||
int *a_back_y,
|
||||
int *a_num_back_clip_rects,
|
||||
drm_clip_rect_t **a_back_clip_rects)
|
||||
{
|
||||
Bool is_ok=FALSE;
|
||||
Display *dpy=hostx_get_display () ;
|
||||
EphyrHostWindowAttributes attrs ;
|
||||
|
||||
EPHYR_RETURN_VAL_IF_FAIL (a_x && a_y && a_w && a_h
|
||||
&& a_num_clip_rects,
|
||||
FALSE) ;
|
||||
|
||||
EPHYR_LOG ("enter\n") ;
|
||||
memset (&attrs, 0, sizeof (attrs)) ;
|
||||
if (!hostx_get_window_attributes (a_drawable, &attrs)) {
|
||||
EPHYR_LOG_ERROR ("failed to query host window attributes\n") ;
|
||||
goto out;
|
||||
}
|
||||
if (!XF86DRIGetDrawableInfo (dpy, DefaultScreen (dpy), a_drawable,
|
||||
a_index, a_stamp,
|
||||
a_x, a_y,
|
||||
a_w, a_h,
|
||||
a_num_clip_rects, a_clip_rects,
|
||||
a_back_x, a_back_y,
|
||||
a_num_back_clip_rects,
|
||||
a_back_clip_rects)) {
|
||||
EPHYR_LOG_ERROR ("XF86DRIGetDrawableInfo ()\n") ;
|
||||
goto out ;
|
||||
}
|
||||
EPHYR_LOG ("host x,y,w,h: (%d,%d,%d,%d)\n", *a_x, *a_y, *a_w, *a_h) ;
|
||||
if (*a_num_clip_rects) {
|
||||
free (*a_back_clip_rects) ;
|
||||
*a_back_clip_rects = calloc (*a_num_clip_rects,
|
||||
sizeof (drm_clip_rect_t)) ;
|
||||
memmove (*a_back_clip_rects,
|
||||
*a_clip_rects,
|
||||
*a_num_clip_rects * sizeof (drm_clip_rect_t)) ;
|
||||
*a_num_back_clip_rects = *a_num_clip_rects;
|
||||
}
|
||||
EPHYR_LOG ("num back clip rects:%d, num clip rects:%d\n",
|
||||
*a_num_clip_rects, *a_num_back_clip_rects) ;
|
||||
*a_back_x = *a_x ;
|
||||
*a_back_y = *a_y ;
|
||||
*a_w = attrs.width;
|
||||
*a_h = attrs.height;
|
||||
|
||||
is_ok = TRUE ;
|
||||
out:
|
||||
EPHYR_LOG ("leave. index:%d, stamp:%d, x,y:(%d,%d), w,y:(%d,%d)\n",
|
||||
*a_index, *a_stamp, *a_x, *a_y, *a_w, *a_h) ;
|
||||
return is_ok ;
|
||||
}
|
||||
|
||||
Bool
|
||||
ephyrDRIGetDeviceInfo (int a_screen,
|
||||
drm_handle_t *a_frame_buffer,
|
||||
int *a_fb_origin,
|
||||
int *a_fb_size,
|
||||
int *a_fb_stride,
|
||||
int *a_dev_private_size,
|
||||
void **a_dev_private)
|
||||
{
|
||||
Bool is_ok = FALSE ;
|
||||
Display *dpy = hostx_get_display () ;
|
||||
|
||||
EPHYR_RETURN_VAL_IF_FAIL (dpy, FALSE) ;
|
||||
EPHYR_LOG ("enter\n") ;
|
||||
is_ok = XF86DRIGetDeviceInfo (dpy, DefaultScreen (dpy), a_frame_buffer,
|
||||
a_fb_origin, a_fb_size, a_fb_stride,
|
||||
a_dev_private_size, a_dev_private) ;
|
||||
EPHYR_LOG ("leave:%d\n", is_ok) ;
|
||||
return is_ok ;
|
||||
}
|
||||
#endif /*EPHYR_DRI*/
|
||||
|
75
hw/kdrive/ephyr/ephyrdri.h
Normal file
75
hw/kdrive/ephyr/ephyrdri.h
Normal file
|
@ -0,0 +1,75 @@
|
|||
/*
|
||||
* Xephyr - A kdrive X server thats runs in a host X window.
|
||||
* Authored by Matthew Allum <mallum@openedhand.com>
|
||||
*
|
||||
* Copyright © 2007 OpenedHand Ltd
|
||||
*
|
||||
* Permission to use, copy, modify, distribute, and sell this software and its
|
||||
* documentation for any purpose is hereby granted without fee, provided that
|
||||
* the above copyright notice appear in all copies and that both that
|
||||
* copyright notice and this permission notice appear in supporting
|
||||
* documentation, and that the name of OpenedHand Ltd not be used in
|
||||
* advertising or publicity pertaining to distribution of the software without
|
||||
* specific, written prior permission. OpenedHand Ltd makes no
|
||||
* representations about the suitability of this software for any purpose. It
|
||||
* is provided "as is" without express or implied warranty.
|
||||
*
|
||||
* OpenedHand Ltd DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
||||
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
|
||||
* EVENT SHALL OpenedHand Ltd BE LIABLE FOR ANY SPECIAL, INDIRECT OR
|
||||
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
||||
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
||||
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
||||
* PERFORMANCE OF THIS SOFTWARE.
|
||||
*
|
||||
* Authors:
|
||||
* Dodji Seketeli <dodji@openedhand.com>
|
||||
*/
|
||||
|
||||
#ifndef __EPHYRDRI_H__
|
||||
#define __EPHYRDRI_H__
|
||||
|
||||
#include <xf86drm.h>
|
||||
|
||||
Bool ephyrDRIQueryDirectRenderingCapable (int a_screen, Bool *a_is_capable) ;
|
||||
Bool ephyrDRIOpenConnection (int screen, drm_handle_t *a_sarea, char **a_bus_id_string) ;
|
||||
Bool ephyrDRIAuthConnection (int a_screen, drm_magic_t a_magic) ;
|
||||
Bool ephyrDRICloseConnection (int a_screen) ;
|
||||
Bool ephyrDRIGetClientDriverName (int a_screen,
|
||||
int *a_ddx_driver_major_version,
|
||||
int *a_ddx_driver_minor_version,
|
||||
int *a_ddx_driver_patch_version,
|
||||
char ** a_client_driver_name) ;
|
||||
Bool ephyrDRICreateContext (int a_screen,
|
||||
int a_visual_id,
|
||||
unsigned long int *a_returned_ctx_id,
|
||||
drm_context_t *a_hw_ctx) ;
|
||||
Bool ephyrDRIDestroyContext (int a_screen,
|
||||
int a_context_id) ;
|
||||
Bool ephyrDRICreateDrawable (int a_screen,
|
||||
int a_drawable,
|
||||
drm_drawable_t *a_hw_drawable) ;
|
||||
Bool ephyrDRIDestroyDrawable (int a_screen, int a_drawable) ;
|
||||
Bool ephyrDRIGetDrawableInfo (int a_screen,
|
||||
int /*Drawable*/a_drawable,
|
||||
unsigned int *a_index,
|
||||
unsigned int *a_stamp,
|
||||
int *a_x,
|
||||
int *a_y,
|
||||
int *a_w,
|
||||
int *a_h,
|
||||
int *a_num_clip_rects,
|
||||
drm_clip_rect_t **a_clip_rects,
|
||||
int *a_back_x,
|
||||
int *a_back_y,
|
||||
int *num_back_clip_rects,
|
||||
drm_clip_rect_t **a_back_clip_rects) ;
|
||||
Bool ephyrDRIGetDeviceInfo (int a_screen,
|
||||
drm_handle_t *a_frame_buffer,
|
||||
int *a_fb_origin,
|
||||
int *a_fb_size,
|
||||
int *a_fb_stride,
|
||||
int *a_dev_private_size,
|
||||
void **a_dev_private) ;
|
||||
#endif /*__EPHYRDRI_H__*/
|
||||
|
1448
hw/kdrive/ephyr/ephyrdriext.c
Normal file
1448
hw/kdrive/ephyr/ephyrdriext.c
Normal file
File diff suppressed because it is too large
Load Diff
32
hw/kdrive/ephyr/ephyrdriext.h
Normal file
32
hw/kdrive/ephyr/ephyrdriext.h
Normal file
|
@ -0,0 +1,32 @@
|
|||
/*
|
||||
* Xephyr - A kdrive X server thats runs in a host X window.
|
||||
* Authored by Matthew Allum <mallum@openedhand.com>
|
||||
*
|
||||
* Copyright © 2007 OpenedHand Ltd
|
||||
*
|
||||
* Permission to use, copy, modify, distribute, and sell this software and its
|
||||
* documentation for any purpose is hereby granted without fee, provided that
|
||||
* the above copyright notice appear in all copies and that both that
|
||||
* copyright notice and this permission notice appear in supporting
|
||||
* documentation, and that the name of OpenedHand Ltd not be used in
|
||||
* advertising or publicity pertaining to distribution of the software without
|
||||
* specific, written prior permission. OpenedHand Ltd makes no
|
||||
* representations about the suitability of this software for any purpose. It
|
||||
* is provided "as is" without express or implied warranty.
|
||||
*
|
||||
* OpenedHand Ltd DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
||||
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
|
||||
* EVENT SHALL OpenedHand Ltd BE LIABLE FOR ANY SPECIAL, INDIRECT OR
|
||||
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
||||
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
||||
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
||||
* PERFORMANCE OF THIS SOFTWARE.
|
||||
*
|
||||
* Authors:
|
||||
* Dodji Seketeli <dodji@openedhand.com>
|
||||
*/
|
||||
#ifndef __EPHYRDRIEXT_H__
|
||||
#define __EPHYRDRIEXT_H__
|
||||
Bool ephyrDRIExtensionInit (ScreenPtr a_screen) ;
|
||||
#endif /*__EPHYRDRIEXT_H__*/
|
||||
|
722
hw/kdrive/ephyr/ephyrglxext.c
Normal file
722
hw/kdrive/ephyr/ephyrglxext.c
Normal file
|
@ -0,0 +1,722 @@
|
|||
/*
|
||||
* Xephyr - A kdrive X server thats runs in a host X window.
|
||||
* Authored by Matthew Allum <mallum@openedhand.com>
|
||||
*
|
||||
* Copyright © 2007 OpenedHand Ltd
|
||||
*
|
||||
* Permission to use, copy, modify, distribute, and sell this software and its
|
||||
* documentation for any purpose is hereby granted without fee, provided that
|
||||
* the above copyright notice appear in all copies and that both that
|
||||
* copyright notice and this permission notice appear in supporting
|
||||
* documentation, and that the name of OpenedHand Ltd not be used in
|
||||
* advertising or publicity pertaining to distribution of the software without
|
||||
* specific, written prior permission. OpenedHand Ltd makes no
|
||||
* representations about the suitability of this software for any purpose. It
|
||||
* is provided "as is" without express or implied warranty.
|
||||
*
|
||||
* OpenedHand Ltd DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
||||
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
|
||||
* EVENT SHALL OpenedHand Ltd BE LIABLE FOR ANY SPECIAL, INDIRECT OR
|
||||
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
||||
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
||||
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
||||
* PERFORMANCE OF THIS SOFTWARE.
|
||||
*
|
||||
* Authors:
|
||||
* Dodji Seketeli <dodji@openedhand.com>
|
||||
*/
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <kdrive-config.h>
|
||||
#endif
|
||||
|
||||
#include "extnsionst.h"
|
||||
#include "ephyrglxext.h"
|
||||
#include "ephyrhostglx.h"
|
||||
#define _HAVE_XALLOC_DECLS
|
||||
#include "ephyrlog.h"
|
||||
#include <GL/glxproto.h>
|
||||
#include "GL/glx/glxserver.h"
|
||||
#include "GL/glx/indirect_table.h"
|
||||
#include "GL/glx/indirect_util.h"
|
||||
#include "GL/glx/unpack.h"
|
||||
#include "hostx.h"
|
||||
|
||||
|
||||
#ifdef XEPHYR_DRI
|
||||
|
||||
#ifndef TRUE
|
||||
#define TRUE 1
|
||||
#endif
|
||||
|
||||
#ifndef FALSE
|
||||
#define FALSE 0
|
||||
#endif
|
||||
|
||||
|
||||
int ephyrGLXQueryVersion (__GLXclientState *cl, GLbyte *pc) ;
|
||||
int ephyrGLXQueryVersionSwap (__GLXclientState *cl, GLbyte *pc) ;
|
||||
int ephyrGLXGetVisualConfigs (__GLXclientState *cl, GLbyte *pc) ;
|
||||
int ephyrGLXGetVisualConfigsSwap (__GLXclientState *cl, GLbyte *pc) ;
|
||||
int ephyrGLXClientInfo(__GLXclientState *cl, GLbyte *pc) ;
|
||||
int ephyrGLXClientInfoSwap(__GLXclientState *cl, GLbyte *pc) ;
|
||||
int ephyrGLXQueryServerString(__GLXclientState *a_cl, GLbyte *a_pc) ;
|
||||
int ephyrGLXQueryServerStringSwap(__GLXclientState *a_cl, GLbyte *a_pc) ;
|
||||
int ephyrGLXGetFBConfigsSGIX (__GLXclientState *a_cl, GLbyte *a_pc);
|
||||
int ephyrGLXGetFBConfigsSGIXSwap (__GLXclientState *a_cl, GLbyte *a_pc);
|
||||
int ephyrGLXCreateContext (__GLXclientState *a_cl, GLbyte *a_pc);
|
||||
int ephyrGLXCreateContextSwap (__GLXclientState *a_cl, GLbyte *a_pc);
|
||||
int ephyrGLXDestroyContext (__GLXclientState *a_cl, GLbyte *a_pc) ;
|
||||
int ephyrGLXDestroyContextSwap (__GLXclientState *a_cl, GLbyte *a_pc) ;
|
||||
int ephyrGLXMakeCurrent (__GLXclientState *a_cl, GLbyte *a_pc) ;
|
||||
int ephyrGLXMakeCurrentSwap (__GLXclientState *a_cl, GLbyte *a_pc) ;
|
||||
int ephyrGLXGetString (__GLXclientState *a_cl, GLbyte *a_pc) ;
|
||||
int ephyrGLXGetStringSwap (__GLXclientState *a_cl, GLbyte *a_pc) ;
|
||||
int ephyrGLXGetIntegerv (__GLXclientState *a_cl, GLbyte *a_pc) ;
|
||||
int ephyrGLXGetIntegervSwap (__GLXclientState *a_cl, GLbyte *a_pc) ;
|
||||
int ephyrGLXIsDirect (__GLXclientState *a_cl, GLbyte *a_pc) ;
|
||||
int ephyrGLXIsDirectSwap (__GLXclientState *a_cl, GLbyte *a_pc) ;
|
||||
|
||||
Bool
|
||||
ephyrHijackGLXExtension (void)
|
||||
{
|
||||
const void *(*dispatch_functions)[2];
|
||||
|
||||
if (!hostx_has_glx ()) {
|
||||
EPHYR_LOG ("host X does not have GLX\n") ;
|
||||
return FALSE ;
|
||||
}
|
||||
EPHYR_LOG ("host X does have GLX\n") ;
|
||||
|
||||
if (!Single_dispatch_info.dispatch_functions) {
|
||||
EPHYR_LOG_ERROR ("could not get dispatch functions table\n") ;
|
||||
return FALSE ;
|
||||
}
|
||||
/*
|
||||
* hijack some single entry point dispatch functions
|
||||
*/
|
||||
dispatch_functions = Single_dispatch_info.dispatch_functions ;
|
||||
EPHYR_RETURN_VAL_IF_FAIL (dispatch_functions, FALSE) ;
|
||||
|
||||
dispatch_functions[X_GLXQueryVersion][0] = ephyrGLXQueryVersion ;
|
||||
dispatch_functions[X_GLXQueryVersion][1] = ephyrGLXQueryVersionSwap ;
|
||||
|
||||
dispatch_functions[X_GLXGetVisualConfigs][0] = ephyrGLXGetVisualConfigs ;
|
||||
dispatch_functions[X_GLXGetVisualConfigs][1] = ephyrGLXGetVisualConfigsSwap ;
|
||||
dispatch_functions[X_GLXClientInfo][0] = ephyrGLXClientInfo ;
|
||||
dispatch_functions[X_GLXClientInfo][1] = ephyrGLXClientInfoSwap ;
|
||||
|
||||
dispatch_functions[X_GLXQueryServerString][0] = ephyrGLXQueryServerString ;
|
||||
dispatch_functions[X_GLXQueryServerString][1] =
|
||||
ephyrGLXQueryServerStringSwap ;
|
||||
|
||||
dispatch_functions[X_GLXCreateContext][0] = ephyrGLXCreateContext ;
|
||||
dispatch_functions[X_GLXCreateContext][1] = ephyrGLXCreateContextSwap ;
|
||||
|
||||
dispatch_functions[X_GLXDestroyContext][0] = ephyrGLXDestroyContext ;
|
||||
dispatch_functions[X_GLXDestroyContext][1] = ephyrGLXDestroyContextSwap ;
|
||||
|
||||
dispatch_functions[X_GLXMakeCurrent][0] = ephyrGLXMakeCurrent ;
|
||||
dispatch_functions[X_GLXMakeCurrent][1] = ephyrGLXMakeCurrentSwap ;
|
||||
|
||||
dispatch_functions[X_GLXIsDirect][0] = ephyrGLXIsDirect ;
|
||||
dispatch_functions[X_GLXIsDirect][1] = ephyrGLXIsDirectSwap ;
|
||||
|
||||
dispatch_functions[73][0] = ephyrGLXGetString ;
|
||||
dispatch_functions[73][1] = ephyrGLXGetStringSwap ;
|
||||
|
||||
dispatch_functions[61][0] = ephyrGLXGetIntegerv ;
|
||||
dispatch_functions[61][1] = ephyrGLXGetIntegervSwap ;
|
||||
|
||||
/*
|
||||
* hijack some vendor priv entry point dispatch functions
|
||||
*/
|
||||
dispatch_functions = VendorPriv_dispatch_info.dispatch_functions ;
|
||||
dispatch_functions[92][0] = ephyrGLXGetFBConfigsSGIX;
|
||||
dispatch_functions[92][1] = ephyrGLXGetFBConfigsSGIXSwap;
|
||||
EPHYR_LOG ("hijacked glx entry points to forward requests to host X\n") ;
|
||||
|
||||
return TRUE ;
|
||||
}
|
||||
|
||||
/*********************
|
||||
* implementation of
|
||||
* hijacked GLX entry
|
||||
* points
|
||||
********************/
|
||||
|
||||
int
|
||||
ephyrGLXQueryVersion(__GLXclientState *a_cl, GLbyte *a_pc)
|
||||
{
|
||||
ClientPtr client = a_cl->client;
|
||||
xGLXQueryVersionReq *req = (xGLXQueryVersionReq *) a_pc;
|
||||
xGLXQueryVersionReply reply;
|
||||
int major, minor;
|
||||
int res = BadImplementation ;
|
||||
|
||||
EPHYR_LOG ("enter\n") ;
|
||||
|
||||
major = req->majorVersion ;
|
||||
minor = req->minorVersion ;
|
||||
|
||||
if (!ephyrHostGLXQueryVersion (&major, &minor)) {
|
||||
EPHYR_LOG_ERROR ("ephyrHostGLXQueryVersion() failed\n") ;
|
||||
goto out ;
|
||||
}
|
||||
EPHYR_LOG ("major:%d, minor:%d\n",
|
||||
major, minor);
|
||||
reply.majorVersion = major ;
|
||||
reply.minorVersion = minor ;
|
||||
reply.length = 0 ;
|
||||
reply.type = X_Reply ;
|
||||
reply.sequenceNumber = client->sequence ;
|
||||
|
||||
if (client->swapped) {
|
||||
__glXSwapQueryVersionReply(client, &reply);
|
||||
} else {
|
||||
WriteToClient(client, sz_xGLXQueryVersionReply, (char *)&reply);
|
||||
}
|
||||
|
||||
res = Success ;
|
||||
out:
|
||||
EPHYR_LOG ("leave\n") ;
|
||||
return res;
|
||||
}
|
||||
|
||||
int
|
||||
ephyrGLXQueryVersionSwap (__GLXclientState *a_cl, GLbyte *a_pc)
|
||||
{
|
||||
xGLXQueryVersionReq *req = (xGLXQueryVersionReq *) a_pc;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
||||
__GLX_SWAP_SHORT (&req->length);
|
||||
__GLX_SWAP_INT (&req->majorVersion);
|
||||
__GLX_SWAP_INT (&req->minorVersion);
|
||||
return ephyrGLXQueryVersion (a_cl, a_pc) ;
|
||||
}
|
||||
|
||||
static int
|
||||
ephyrGLXGetVisualConfigsReal (__GLXclientState *a_cl,
|
||||
GLbyte *a_pc,
|
||||
Bool a_do_swap)
|
||||
{
|
||||
xGLXGetVisualConfigsReq *req = (xGLXGetVisualConfigsReq *) a_pc;
|
||||
ClientPtr client = a_cl->client;
|
||||
xGLXGetVisualConfigsReply reply;
|
||||
int32_t *props_buf=NULL, num_visuals=0,
|
||||
num_props=0, res=BadImplementation, i=0,
|
||||
props_per_visual_size=0,
|
||||
props_buf_size=0;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
|
||||
|
||||
EPHYR_LOG ("enter\n") ;
|
||||
|
||||
if (!ephyrHostGLXGetVisualConfigs (req->screen,
|
||||
&num_visuals,
|
||||
&num_props,
|
||||
&props_buf_size,
|
||||
&props_buf)) {
|
||||
EPHYR_LOG_ERROR ("ephyrHostGLXGetVisualConfigs() failed\n") ;
|
||||
goto out ;
|
||||
}
|
||||
EPHYR_LOG ("num_visuals:%d, num_props:%d\n", num_visuals, num_props) ;
|
||||
|
||||
reply.numVisuals = num_visuals;
|
||||
reply.numProps = num_props;
|
||||
reply.length = (num_visuals *__GLX_SIZE_CARD32 * num_props) >> 2;
|
||||
reply.type = X_Reply;
|
||||
reply.sequenceNumber = client->sequence;
|
||||
|
||||
if (a_do_swap) {
|
||||
__GLX_SWAP_SHORT(&reply.sequenceNumber);
|
||||
__GLX_SWAP_INT(&reply.length);
|
||||
__GLX_SWAP_INT(&reply.numVisuals);
|
||||
__GLX_SWAP_INT(&reply.numProps);
|
||||
__GLX_SWAP_INT_ARRAY (props_buf, num_props) ;
|
||||
}
|
||||
WriteToClient(client, sz_xGLXGetVisualConfigsReply, (char*)&reply);
|
||||
props_per_visual_size = props_buf_size/num_visuals ;
|
||||
for (i=0; i < num_visuals; i++) {
|
||||
WriteToClient (client,
|
||||
props_per_visual_size,
|
||||
(char*)props_buf +i*props_per_visual_size);
|
||||
}
|
||||
res = Success ;
|
||||
|
||||
out:
|
||||
EPHYR_LOG ("leave\n") ;
|
||||
if (props_buf) {
|
||||
xfree (props_buf) ;
|
||||
props_buf = NULL ;
|
||||
}
|
||||
return res ;
|
||||
}
|
||||
|
||||
static int
|
||||
ephyrGLXGetFBConfigsSGIXReal (__GLXclientState *a_cl,
|
||||
GLbyte *a_pc,
|
||||
Bool a_do_swap)
|
||||
{
|
||||
xGLXGetFBConfigsSGIXReq *req = (xGLXGetFBConfigsSGIXReq *)a_pc;
|
||||
ClientPtr client = a_cl->client;
|
||||
xGLXGetVisualConfigsReply reply;
|
||||
int32_t *props_buf=NULL, num_visuals=0,
|
||||
num_props=0, res=BadImplementation, i=0,
|
||||
props_per_visual_size=0,
|
||||
props_buf_size=0;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
|
||||
|
||||
EPHYR_LOG ("enter\n") ;
|
||||
|
||||
if (!ephyrHostGLXVendorPrivGetFBConfigsSGIX (req->screen,
|
||||
&num_visuals,
|
||||
&num_props,
|
||||
&props_buf_size,
|
||||
&props_buf)) {
|
||||
EPHYR_LOG_ERROR ("ephyrHostGLXGetVisualConfigs() failed\n") ;
|
||||
goto out ;
|
||||
}
|
||||
EPHYR_LOG ("num_visuals:%d, num_props:%d\n", num_visuals, num_props) ;
|
||||
|
||||
reply.numVisuals = num_visuals;
|
||||
reply.numProps = num_props;
|
||||
reply.length = props_buf_size >> 2;
|
||||
reply.type = X_Reply;
|
||||
reply.sequenceNumber = client->sequence;
|
||||
|
||||
if (a_do_swap) {
|
||||
__GLX_SWAP_SHORT(&reply.sequenceNumber);
|
||||
__GLX_SWAP_INT(&reply.length);
|
||||
__GLX_SWAP_INT(&reply.numVisuals);
|
||||
__GLX_SWAP_INT(&reply.numProps);
|
||||
__GLX_SWAP_INT_ARRAY (props_buf, num_props) ;
|
||||
}
|
||||
WriteToClient(client, sz_xGLXGetVisualConfigsReply, (char*)&reply);
|
||||
props_per_visual_size = props_buf_size/num_visuals ;
|
||||
for (i=0; i < num_visuals; i++) {
|
||||
WriteToClient (client,
|
||||
props_per_visual_size,
|
||||
&((char*)props_buf)[i*props_per_visual_size]);
|
||||
}
|
||||
res = Success ;
|
||||
|
||||
out:
|
||||
EPHYR_LOG ("leave\n") ;
|
||||
if (props_buf) {
|
||||
xfree (props_buf) ;
|
||||
props_buf = NULL ;
|
||||
}
|
||||
return res ;
|
||||
}
|
||||
|
||||
int
|
||||
ephyrGLXGetVisualConfigs (__GLXclientState *a_cl, GLbyte *a_pc)
|
||||
{
|
||||
return ephyrGLXGetVisualConfigsReal (a_cl, a_pc, FALSE) ;
|
||||
}
|
||||
|
||||
int
|
||||
ephyrGLXGetVisualConfigsSwap (__GLXclientState *a_cl, GLbyte *a_pc)
|
||||
{
|
||||
return ephyrGLXGetVisualConfigsReal (a_cl, a_pc, TRUE) ;
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
ephyrGLXClientInfo(__GLXclientState *a_cl, GLbyte *a_pc)
|
||||
{
|
||||
int res=BadImplementation ;
|
||||
xGLXClientInfoReq *req = (xGLXClientInfoReq *) a_pc;
|
||||
|
||||
EPHYR_LOG ("enter\n") ;
|
||||
if (!ephyrHostGLXSendClientInfo (req->major, req->minor, (char*)req+1)) {
|
||||
EPHYR_LOG_ERROR ("failed to send client info to host\n") ;
|
||||
goto out ;
|
||||
}
|
||||
res = Success ;
|
||||
|
||||
out:
|
||||
EPHYR_LOG ("leave\n") ;
|
||||
return res ;
|
||||
}
|
||||
|
||||
int
|
||||
ephyrGLXClientInfoSwap (__GLXclientState *a_cl, GLbyte *a_pc)
|
||||
{
|
||||
xGLXClientInfoReq *req = (xGLXClientInfoReq *)a_pc;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
||||
__GLX_SWAP_SHORT (&req->length);
|
||||
__GLX_SWAP_INT (&req->major);
|
||||
__GLX_SWAP_INT (&req->minor);
|
||||
__GLX_SWAP_INT (&req->numbytes);
|
||||
|
||||
return ephyrGLXClientInfo (a_cl, a_pc) ;
|
||||
}
|
||||
|
||||
int
|
||||
ephyrGLXQueryServerString(__GLXclientState *a_cl, GLbyte *a_pc)
|
||||
{
|
||||
int res = BadImplementation ;
|
||||
ClientPtr client = a_cl->client;
|
||||
xGLXQueryServerStringReq *req = (xGLXQueryServerStringReq *) a_pc;
|
||||
xGLXQueryServerStringReply reply;
|
||||
char *server_string=NULL ;
|
||||
int length=0 ;
|
||||
|
||||
EPHYR_LOG ("enter\n") ;
|
||||
if (!ephyrHostGLXGetStringFromServer (req->screen,
|
||||
req->name,
|
||||
EPHYR_HOST_GLX_QueryServerString,
|
||||
&server_string)) {
|
||||
EPHYR_LOG_ERROR ("failed to query string from host\n") ;
|
||||
goto out ;
|
||||
}
|
||||
EPHYR_LOG ("string: %s\n", server_string) ;
|
||||
length= strlen (server_string) + 1;
|
||||
reply.type = X_Reply ;
|
||||
reply.sequenceNumber = client->sequence ;
|
||||
reply.length = __GLX_PAD (length) >> 2 ;
|
||||
reply.n = length ;
|
||||
|
||||
WriteToClient(client, sz_xGLXQueryServerStringReply, (char*)&reply);
|
||||
WriteToClient(client, (int)length, server_string);
|
||||
|
||||
res = Success ;
|
||||
|
||||
out:
|
||||
EPHYR_LOG ("leave\n") ;
|
||||
if (server_string) {
|
||||
xfree (server_string) ;
|
||||
server_string = NULL;
|
||||
}
|
||||
return res ;
|
||||
}
|
||||
|
||||
int
|
||||
ephyrGLXQueryServerStringSwap(__GLXclientState *a_cl, GLbyte *a_pc)
|
||||
{
|
||||
EPHYR_LOG_ERROR ("not yet implemented\n") ;
|
||||
return BadImplementation ;
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
ephyrGLXGetFBConfigsSGIX (__GLXclientState *a_cl, GLbyte *a_pc)
|
||||
{
|
||||
return ephyrGLXGetFBConfigsSGIXReal (a_cl, a_pc, FALSE) ;
|
||||
}
|
||||
|
||||
int
|
||||
ephyrGLXGetFBConfigsSGIXSwap (__GLXclientState *a_cl, GLbyte *a_pc)
|
||||
{
|
||||
return ephyrGLXGetFBConfigsSGIXReal (a_cl, a_pc, TRUE) ;
|
||||
}
|
||||
|
||||
static int
|
||||
ephyrGLXCreateContextReal (xGLXCreateContextReq *a_req, Bool a_do_swap)
|
||||
{
|
||||
int res=BadImplementation;
|
||||
EphyrHostWindowAttributes host_w_attrs ;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
||||
EPHYR_RETURN_VAL_IF_FAIL (a_req, BadValue) ;
|
||||
EPHYR_LOG ("enter\n") ;
|
||||
|
||||
if (a_do_swap) {
|
||||
__GLX_SWAP_SHORT(&a_req->length);
|
||||
__GLX_SWAP_INT(&a_req->context);
|
||||
__GLX_SWAP_INT(&a_req->visual);
|
||||
__GLX_SWAP_INT(&a_req->screen);
|
||||
__GLX_SWAP_INT(&a_req->shareList);
|
||||
}
|
||||
|
||||
EPHYR_LOG ("context creation requested. localid:%d, "
|
||||
"screen:%d, visual:%d, direct:%d\n",
|
||||
(int)a_req->context, (int)a_req->screen,
|
||||
(int)a_req->visual, (int)a_req->isDirect) ;
|
||||
|
||||
memset (&host_w_attrs, 0, sizeof (host_w_attrs)) ;
|
||||
if (!hostx_get_window_attributes (hostx_get_window (a_req->screen),
|
||||
&host_w_attrs)) {
|
||||
EPHYR_LOG_ERROR ("failed to get host window attrs\n") ;
|
||||
goto out ;
|
||||
}
|
||||
|
||||
EPHYR_LOG ("host window visual id: %d\n", host_w_attrs.visualid) ;
|
||||
|
||||
if (!ephyrHostGLXCreateContext (a_req->screen,
|
||||
host_w_attrs.visualid,
|
||||
a_req->context,
|
||||
a_req->shareList,
|
||||
a_req->isDirect)) {
|
||||
EPHYR_LOG_ERROR ("ephyrHostGLXCreateContext() failed\n") ;
|
||||
goto out ;
|
||||
}
|
||||
res = Success;
|
||||
out:
|
||||
EPHYR_LOG ("leave\n") ;
|
||||
return res ;
|
||||
}
|
||||
|
||||
int
|
||||
ephyrGLXCreateContext (__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXCreateContextReq *req = (xGLXCreateContextReq *) pc;
|
||||
|
||||
return ephyrGLXCreateContextReal (req, FALSE) ;
|
||||
}
|
||||
|
||||
int ephyrGLXCreateContextSwap (__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXCreateContextReq *req = (xGLXCreateContextReq *) pc;
|
||||
return ephyrGLXCreateContextReal (req, TRUE) ;
|
||||
}
|
||||
|
||||
static int
|
||||
ephyrGLXDestroyContextReal (__GLXclientState *a_cl,
|
||||
GLbyte *a_pc,
|
||||
Bool a_do_swap)
|
||||
{
|
||||
int res=BadImplementation;
|
||||
ClientPtr client = a_cl->client;
|
||||
xGLXDestroyContextReq *req = (xGLXDestroyContextReq *) a_pc;
|
||||
|
||||
EPHYR_LOG ("enter. id:%d\n", (int)req->context) ;
|
||||
if (!ephyrHostDestroyContext (req->context)) {
|
||||
EPHYR_LOG_ERROR ("ephyrHostDestroyContext() failed\n") ;
|
||||
client->errorValue = req->context ;
|
||||
goto out ;
|
||||
}
|
||||
res = Success ;
|
||||
|
||||
out:
|
||||
EPHYR_LOG ("leave\n") ;
|
||||
return res ;
|
||||
}
|
||||
|
||||
int
|
||||
ephyrGLXDestroyContext (__GLXclientState *a_cl, GLbyte *a_pc)
|
||||
{
|
||||
return ephyrGLXDestroyContextReal (a_cl, a_pc, FALSE) ;
|
||||
}
|
||||
|
||||
int
|
||||
ephyrGLXDestroyContextSwap (__GLXclientState *a_cl, GLbyte *a_pc)
|
||||
{
|
||||
return ephyrGLXDestroyContextReal (a_cl, a_pc, TRUE) ;
|
||||
}
|
||||
|
||||
static int
|
||||
ephyrGLXMakeCurrentReal (__GLXclientState *a_cl, GLbyte *a_pc, Bool a_do_swap)
|
||||
{
|
||||
int res=BadImplementation;
|
||||
xGLXMakeCurrentReq *req = (xGLXMakeCurrentReq *) a_pc;
|
||||
xGLXMakeCurrentReply reply ;
|
||||
DrawablePtr drawable=NULL;
|
||||
int rc=0;
|
||||
|
||||
EPHYR_LOG ("enter\n") ;
|
||||
rc = dixLookupDrawable (&drawable,
|
||||
req->drawable,
|
||||
a_cl->client,
|
||||
0,
|
||||
DixReadAccess);
|
||||
EPHYR_RETURN_VAL_IF_FAIL (drawable, BadValue) ;
|
||||
EPHYR_RETURN_VAL_IF_FAIL (drawable->pScreen, BadValue) ;
|
||||
EPHYR_LOG ("screen nummber requested:%d\n",
|
||||
drawable->pScreen->myNum) ;
|
||||
|
||||
memset (&reply, 0, sizeof (reply)) ;
|
||||
if (!ephyrHostGLXMakeCurrent (hostx_get_window (drawable->pScreen->myNum),
|
||||
req->context,
|
||||
req->oldContextTag,
|
||||
(int*)&reply.contextTag)) {
|
||||
EPHYR_LOG_ERROR ("ephyrHostGLXMakeCurrent() failed\n") ;
|
||||
goto out;
|
||||
}
|
||||
reply.length = 0;
|
||||
reply.type = X_Reply;
|
||||
reply.sequenceNumber = a_cl->client->sequence;
|
||||
if (a_do_swap) {
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
__GLX_SWAP_SHORT(&reply.sequenceNumber);
|
||||
__GLX_SWAP_INT(&reply.length);
|
||||
__GLX_SWAP_INT(&reply.contextTag);
|
||||
}
|
||||
WriteToClient(a_cl->client, sz_xGLXMakeCurrentReply, (char *)&reply);
|
||||
|
||||
res = Success ;
|
||||
out:
|
||||
EPHYR_LOG ("leave\n") ;
|
||||
return res ;
|
||||
}
|
||||
|
||||
int
|
||||
ephyrGLXMakeCurrent (__GLXclientState *a_cl, GLbyte *a_pc)
|
||||
{
|
||||
return ephyrGLXMakeCurrentReal (a_cl, a_pc, FALSE) ;
|
||||
}
|
||||
|
||||
int
|
||||
ephyrGLXMakeCurrentSwap (__GLXclientState *a_cl, GLbyte *a_pc)
|
||||
{
|
||||
return ephyrGLXMakeCurrentReal (a_cl, a_pc, TRUE) ;
|
||||
}
|
||||
|
||||
static int
|
||||
ephyrGLXGetStringReal (__GLXclientState *a_cl, GLbyte *a_pc, Bool a_do_swap)
|
||||
{
|
||||
ClientPtr client=NULL ;
|
||||
int context_tag=0, name=0, res=BadImplementation, length=0 ;
|
||||
char *string=NULL;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
||||
EPHYR_RETURN_VAL_IF_FAIL (a_cl && a_pc, BadValue) ;
|
||||
|
||||
EPHYR_LOG ("enter\n") ;
|
||||
|
||||
client = a_cl->client ;
|
||||
|
||||
if (a_do_swap) {
|
||||
__GLX_SWAP_INT (a_pc + 4);
|
||||
__GLX_SWAP_INT (a_pc + __GLX_SINGLE_HDR_SIZE);
|
||||
}
|
||||
context_tag = __GLX_GET_SINGLE_CONTEXT_TAG (a_pc) ;
|
||||
a_pc += __GLX_SINGLE_HDR_SIZE;
|
||||
name = *(GLenum*)(a_pc + 0);
|
||||
EPHYR_LOG ("context_tag:%d, name:%d\n", context_tag, name) ;
|
||||
if (!ephyrHostGLXGetStringFromServer (context_tag,
|
||||
name,
|
||||
EPHYR_HOST_GLX_GetString,
|
||||
&string)) {
|
||||
EPHYR_LOG_ERROR ("failed to get string from server\n") ;
|
||||
goto out ;
|
||||
}
|
||||
if (string) {
|
||||
length = strlen (string) + 1;
|
||||
EPHYR_LOG ("got string:'%s', size:%d\n", string, length) ;
|
||||
} else {
|
||||
EPHYR_LOG ("got string: string (null)\n") ;
|
||||
}
|
||||
__GLX_BEGIN_REPLY (length);
|
||||
__GLX_PUT_SIZE (length);
|
||||
__GLX_SEND_HEADER ();
|
||||
if (a_do_swap) {
|
||||
__GLX_SWAP_REPLY_SIZE ();
|
||||
__GLX_SWAP_REPLY_HEADER ();
|
||||
}
|
||||
WriteToClient (client, length, (char *)string);
|
||||
|
||||
res = Success ;
|
||||
out:
|
||||
EPHYR_LOG ("leave\n") ;
|
||||
return res ;
|
||||
}
|
||||
|
||||
int
|
||||
ephyrGLXGetString (__GLXclientState *a_cl, GLbyte *a_pc)
|
||||
{
|
||||
return ephyrGLXGetStringReal (a_cl, a_pc, FALSE) ;
|
||||
}
|
||||
|
||||
int
|
||||
ephyrGLXGetStringSwap (__GLXclientState *a_cl, GLbyte *a_pc)
|
||||
{
|
||||
return ephyrGLXGetStringReal (a_cl, a_pc, TRUE) ;
|
||||
}
|
||||
|
||||
static int
|
||||
ephyrGLXGetIntegervReal (__GLXclientState *a_cl, GLbyte *a_pc, Bool a_do_swap)
|
||||
{
|
||||
int res=BadImplementation;
|
||||
xGLXSingleReq * const req = (xGLXSingleReq *) a_pc;
|
||||
GLenum int_name ;
|
||||
int value=0 ;
|
||||
GLint answer_buf_room[200];
|
||||
GLint *buf=NULL ;
|
||||
|
||||
EPHYR_LOG ("enter\n") ;
|
||||
|
||||
a_pc += __GLX_SINGLE_HDR_SIZE;
|
||||
|
||||
int_name = *(GLenum*) (a_pc+0) ;
|
||||
if (!ephyrHostGetIntegerValue (req->contextTag, int_name, &value)) {
|
||||
EPHYR_LOG_ERROR ("ephyrHostGetIntegerValue() failed\n") ;
|
||||
goto out ;
|
||||
}
|
||||
buf = __glXGetAnswerBuffer (a_cl, sizeof (value),
|
||||
answer_buf_room,
|
||||
sizeof (answer_buf_room),
|
||||
4) ;
|
||||
|
||||
if (!buf) {
|
||||
EPHYR_LOG_ERROR ("failed to allocate reply buffer\n") ;
|
||||
res = BadAlloc ;
|
||||
goto out ;
|
||||
}
|
||||
__glXSendReply (a_cl->client, buf, 1, sizeof (value), GL_FALSE, 0) ;
|
||||
res = Success ;
|
||||
|
||||
out:
|
||||
EPHYR_LOG ("leave\n") ;
|
||||
return res ;
|
||||
}
|
||||
|
||||
int
|
||||
ephyrGLXGetIntegerv (__GLXclientState *a_cl, GLbyte *a_pc)
|
||||
{
|
||||
return ephyrGLXGetIntegervReal (a_cl, a_pc, FALSE) ;
|
||||
}
|
||||
|
||||
int
|
||||
ephyrGLXGetIntegervSwap (__GLXclientState *a_cl, GLbyte *a_pc)
|
||||
{
|
||||
return ephyrGLXGetIntegervReal (a_cl, a_pc, TRUE) ;
|
||||
}
|
||||
|
||||
static int
|
||||
ephyrGLXIsDirectReal (__GLXclientState *a_cl, GLbyte *a_pc, Bool a_do_swap)
|
||||
{
|
||||
int res=BadImplementation;
|
||||
ClientPtr client = a_cl->client;
|
||||
xGLXIsDirectReq *req = (xGLXIsDirectReq *) a_pc;
|
||||
xGLXIsDirectReply reply;
|
||||
int is_direct=0 ;
|
||||
|
||||
EPHYR_RETURN_VAL_IF_FAIL (a_cl && a_pc, FALSE) ;
|
||||
|
||||
EPHYR_LOG ("enter\n") ;
|
||||
|
||||
memset (&reply, 0, sizeof (reply)) ;
|
||||
if (!ephyrHostIsContextDirect (req->context, (int*)&is_direct)) {
|
||||
EPHYR_LOG_ERROR ("ephyrHostIsContextDirect() failed\n") ;
|
||||
goto out ;
|
||||
}
|
||||
reply.isDirect = is_direct ;
|
||||
reply.length = 0;
|
||||
reply.type = X_Reply;
|
||||
reply.sequenceNumber = client->sequence;
|
||||
WriteToClient(client, sz_xGLXIsDirectReply, (char *)&reply);
|
||||
res = Success ;
|
||||
|
||||
out:
|
||||
EPHYR_LOG ("leave\n") ;
|
||||
return res ;
|
||||
}
|
||||
|
||||
int
|
||||
ephyrGLXIsDirect (__GLXclientState *a_cl, GLbyte *a_pc)
|
||||
{
|
||||
return ephyrGLXIsDirectReal (a_cl, a_pc, FALSE) ;
|
||||
}
|
||||
|
||||
int
|
||||
ephyrGLXIsDirectSwap (__GLXclientState *a_cl, GLbyte *a_pc)
|
||||
{
|
||||
return ephyrGLXIsDirectReal (a_cl, a_pc, TRUE) ;
|
||||
}
|
||||
|
||||
#endif /*XEPHYR_DRI*/
|
||||
|
35
hw/kdrive/ephyr/ephyrglxext.h
Normal file
35
hw/kdrive/ephyr/ephyrglxext.h
Normal file
|
@ -0,0 +1,35 @@
|
|||
/*
|
||||
* Xephyr - A kdrive X server thats runs in a host X window.
|
||||
* Authored by Matthew Allum <mallum@openedhand.com>
|
||||
*
|
||||
* Copyright © 2007 OpenedHand Ltd
|
||||
*
|
||||
* Permission to use, copy, modify, distribute, and sell this software and its
|
||||
* documentation for any purpose is hereby granted without fee, provided that
|
||||
* the above copyright notice appear in all copies and that both that
|
||||
* copyright notice and this permission notice appear in supporting
|
||||
* documentation, and that the name of OpenedHand Ltd not be used in
|
||||
* advertising or publicity pertaining to distribution of the software without
|
||||
* specific, written prior permission. OpenedHand Ltd makes no
|
||||
* representations about the suitability of this software for any purpose. It
|
||||
* is provided "as is" without express or implied warranty.
|
||||
*
|
||||
* OpenedHand Ltd DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
||||
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
|
||||
* EVENT SHALL OpenedHand Ltd BE LIABLE FOR ANY SPECIAL, INDIRECT OR
|
||||
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
||||
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
||||
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
||||
* PERFORMANCE OF THIS SOFTWARE.
|
||||
*
|
||||
* Authors:
|
||||
* Dodji Seketeli <dodji@openedhand.com>
|
||||
*/
|
||||
#ifndef __EPHYR_GLXEXT_H__
|
||||
#define __EPHYR_GLXEXT_H__
|
||||
|
||||
#include <X11/Xdefs.h>
|
||||
Bool ephyrHijackGLXExtension (void) ;
|
||||
|
||||
#endif /*__EPHYR_GLXEXT_H__*/
|
||||
|
687
hw/kdrive/ephyr/ephyrhostglx.c
Normal file
687
hw/kdrive/ephyr/ephyrhostglx.c
Normal file
|
@ -0,0 +1,687 @@
|
|||
/*
|
||||
* Xephyr - A kdrive X server thats runs in a host X window.
|
||||
* Authored by Matthew Allum <mallum@openedhand.com>
|
||||
*
|
||||
* Copyright © 2007 OpenedHand Ltd
|
||||
*
|
||||
* Permission to use, copy, modify, distribute, and sell this software and its
|
||||
* documentation for any purpose is hereby granted without fee, provided that
|
||||
* the above copyright notice appear in all copies and that both that
|
||||
* copyright notice and this permission notice appear in supporting
|
||||
* documentation, and that the name of OpenedHand Ltd not be used in
|
||||
* advertising or publicity pertaining to distribution of the software without
|
||||
* specific, written prior permission. OpenedHand Ltd makes no
|
||||
* representations about the suitability of this software for any purpose. It
|
||||
* is provided "as is" without express or implied warranty.
|
||||
*
|
||||
* OpenedHand Ltd DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
||||
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
|
||||
* EVENT SHALL OpenedHand Ltd BE LIABLE FOR ANY SPECIAL, INDIRECT OR
|
||||
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
||||
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
||||
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
||||
* PERFORMANCE OF THIS SOFTWARE.
|
||||
*
|
||||
* a lots of the content of this file has been adapted from the mesa source
|
||||
* code.
|
||||
* Authors:
|
||||
* Dodji Seketeli <dodji@openedhand.com>
|
||||
*/
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <kdrive-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/Xlibint.h>
|
||||
#include <GL/glx.h>
|
||||
#include <GL/internal/glcore.h>
|
||||
#include <GL/glxproto.h>
|
||||
#include <GL/glxint.h>
|
||||
#include "ephyrhostglx.h"
|
||||
#define _HAVE_XALLOC_DECLS
|
||||
#include "ephyrlog.h"
|
||||
#include "hostx.h"
|
||||
|
||||
#ifdef XEPHYR_DRI
|
||||
enum VisualConfRequestType {
|
||||
EPHYR_GET_FB_CONFIG,
|
||||
EPHYR_VENDOR_PRIV_GET_FB_CONFIG_SGIX,
|
||||
EPHYR_GET_VISUAL_CONFIGS
|
||||
|
||||
};
|
||||
|
||||
static Bool ephyrHostGLXGetVisualConfigsInternal
|
||||
(enum VisualConfRequestType a_type,
|
||||
int32_t a_screen,
|
||||
int32_t *a_num_visuals,
|
||||
int32_t *a_num_props,
|
||||
int32_t *a_props_buf_size,
|
||||
int32_t **a_props_buf);
|
||||
Bool
|
||||
ephyrHostGLXGetMajorOpcode (int *a_opcode)
|
||||
{
|
||||
Bool is_ok=FALSE ;
|
||||
Display *dpy=hostx_get_display () ;
|
||||
static int opcode ;
|
||||
int first_event_return=0, first_error_return=0;
|
||||
|
||||
EPHYR_RETURN_VAL_IF_FAIL (dpy, FALSE) ;
|
||||
EPHYR_LOG ("enter\n") ;
|
||||
if (!opcode) {
|
||||
if (!XQueryExtension (dpy, GLX_EXTENSION_NAME, &opcode,
|
||||
&first_event_return, &first_error_return)) {
|
||||
EPHYR_LOG_ERROR ("XQueryExtension() failed\n") ;
|
||||
goto out ;
|
||||
}
|
||||
}
|
||||
*a_opcode = opcode ;
|
||||
is_ok = TRUE ;
|
||||
out:
|
||||
EPHYR_LOG ("release\n") ;
|
||||
return is_ok ;
|
||||
}
|
||||
|
||||
Bool
|
||||
ephyrHostGLXQueryVersion (int *a_major, int *a_minor)
|
||||
{
|
||||
Bool is_ok = FALSE ;
|
||||
Display *dpy = hostx_get_display () ;
|
||||
int major_opcode=0;
|
||||
xGLXQueryVersionReq *req=NULL;
|
||||
xGLXQueryVersionReply reply;
|
||||
|
||||
EPHYR_RETURN_VAL_IF_FAIL (a_major && a_minor, FALSE) ;
|
||||
EPHYR_LOG ("enter\n") ;
|
||||
|
||||
if (!ephyrHostGLXGetMajorOpcode (&major_opcode)) {
|
||||
EPHYR_LOG_ERROR ("failed to get major opcode\n") ;
|
||||
goto out ;
|
||||
}
|
||||
EPHYR_LOG ("major opcode: %d\n", major_opcode) ;
|
||||
|
||||
/* Send the glXQueryVersion request */
|
||||
memset (&reply, 0, sizeof (reply)) ;
|
||||
LockDisplay (dpy);
|
||||
GetReq (GLXQueryVersion, req);
|
||||
req->reqType = major_opcode;
|
||||
req->glxCode = X_GLXQueryVersion;
|
||||
req->majorVersion = 2;
|
||||
req->minorVersion = 1;
|
||||
_XReply(dpy, (xReply*) &reply, 0, False);
|
||||
UnlockDisplay (dpy);
|
||||
SyncHandle ();
|
||||
|
||||
*a_major = reply.majorVersion ;
|
||||
*a_minor = reply.minorVersion ;
|
||||
|
||||
EPHYR_LOG ("major:%d, minor:%d\n", *a_major, *a_minor) ;
|
||||
|
||||
is_ok = TRUE ;
|
||||
out:
|
||||
EPHYR_LOG ("leave\n") ;
|
||||
return is_ok ;
|
||||
}
|
||||
|
||||
/**
|
||||
* GLX protocol structure for the ficticious "GXLGenericGetString" request.
|
||||
*
|
||||
* This is a non-existant protocol packet. It just so happens that all of
|
||||
* the real protocol packets used to request a string from the server have
|
||||
* an identical binary layout. The only difference between them is the
|
||||
* meaning of the \c for_whom field and the value of the \c glxCode.
|
||||
* (this has been copied from the mesa source code)
|
||||
*/
|
||||
typedef struct GLXGenericGetString {
|
||||
CARD8 reqType;
|
||||
CARD8 glxCode;
|
||||
CARD16 length B16;
|
||||
CARD32 for_whom B32;
|
||||
CARD32 name B32;
|
||||
} xGLXGenericGetStringReq;
|
||||
|
||||
/* These defines are only needed to make the GetReq macro happy.
|
||||
*/
|
||||
#define sz_xGLXGenericGetStringReq 12
|
||||
#define X_GLXGenericGetString 0
|
||||
|
||||
Bool
|
||||
ephyrHostGLXGetStringFromServer (int a_screen_number,
|
||||
int a_string_name,
|
||||
enum EphyrHostGLXGetStringOps a_op,
|
||||
char **a_string)
|
||||
{
|
||||
Bool is_ok=FALSE ;
|
||||
Display *dpy = hostx_get_display () ;
|
||||
xGLXGenericGetStringReq *req=NULL;
|
||||
xGLXSingleReply reply;
|
||||
int length=0, numbytes=0, major_opcode=0, get_string_op=0;
|
||||
|
||||
EPHYR_RETURN_VAL_IF_FAIL (dpy && a_string, FALSE) ;
|
||||
|
||||
EPHYR_LOG ("enter\n") ;
|
||||
switch (a_op) {
|
||||
case EPHYR_HOST_GLX_QueryServerString:
|
||||
get_string_op = X_GLXQueryServerString;
|
||||
break ;
|
||||
case EPHYR_HOST_GLX_GetString:
|
||||
get_string_op = X_GLsop_GetString;
|
||||
EPHYR_LOG ("Going to glXGetString. strname:%#x, ctxttag:%d\n",
|
||||
a_string_name, a_screen_number) ;
|
||||
break ;
|
||||
default:
|
||||
EPHYR_LOG_ERROR ("unknown EphyrHostGLXGetStringOp:%d\n", a_op) ;
|
||||
goto out ;
|
||||
}
|
||||
|
||||
if (!ephyrHostGLXGetMajorOpcode (&major_opcode)) {
|
||||
EPHYR_LOG_ERROR ("failed to get major opcode\n") ;
|
||||
goto out ;
|
||||
}
|
||||
EPHYR_LOG ("major opcode: %d\n", major_opcode) ;
|
||||
|
||||
LockDisplay (dpy);
|
||||
|
||||
/* All of the GLX protocol requests for getting a string from the server
|
||||
* look the same. The exact meaning of the a_for_whom field is usually
|
||||
* either the screen number (for glXQueryServerString) or the context tag
|
||||
* (for GLXSingle).
|
||||
*/
|
||||
GetReq (GLXGenericGetString, req);
|
||||
req->reqType = major_opcode;
|
||||
req->glxCode = get_string_op;
|
||||
req->for_whom = DefaultScreen (dpy);
|
||||
req->name = a_string_name;
|
||||
|
||||
_XReply (dpy, (xReply *)&reply, 0, False);
|
||||
|
||||
length = reply.length * 4;
|
||||
numbytes = reply.size;
|
||||
EPHYR_LOG ("going to get a string of size:%d\n", numbytes) ;
|
||||
|
||||
*a_string = (char *) Xmalloc (numbytes +1);
|
||||
if (!a_string) {
|
||||
EPHYR_LOG_ERROR ("allocation failed\n") ;
|
||||
goto out;
|
||||
}
|
||||
|
||||
memset (*a_string, 0, numbytes+1) ;
|
||||
if (_XRead (dpy, *a_string, numbytes)) {
|
||||
UnlockDisplay (dpy);
|
||||
SyncHandle ();
|
||||
EPHYR_LOG_ERROR ("read failed\n") ;
|
||||
goto out ;
|
||||
}
|
||||
length -= numbytes;
|
||||
_XEatData (dpy, length) ;
|
||||
UnlockDisplay (dpy);
|
||||
SyncHandle ();
|
||||
EPHYR_LOG ("strname:%#x, strvalue:'%s', strlen:%d\n",
|
||||
a_string_name, *a_string, numbytes) ;
|
||||
|
||||
is_ok = TRUE ;
|
||||
out:
|
||||
EPHYR_LOG ("leave\n") ;
|
||||
return is_ok ;
|
||||
}
|
||||
|
||||
static Bool
|
||||
ephyrHostGLXGetVisualConfigsInternal (enum VisualConfRequestType a_type,
|
||||
int32_t a_screen,
|
||||
int32_t *a_num_visuals,
|
||||
int32_t *a_num_props,
|
||||
int32_t *a_props_buf_size,
|
||||
int32_t **a_props_buf)
|
||||
{
|
||||
Bool is_ok = FALSE ;
|
||||
Display *dpy = hostx_get_display () ;
|
||||
xGLXGetVisualConfigsReq *req;
|
||||
xGLXGetFBConfigsReq *fb_req;
|
||||
xGLXVendorPrivateWithReplyReq *vpreq;
|
||||
xGLXGetFBConfigsSGIXReq *sgi_req;
|
||||
xGLXGetVisualConfigsReply reply;
|
||||
char *server_glx_version=NULL,
|
||||
*server_glx_extensions=NULL ;
|
||||
int j=0,
|
||||
screens=0,
|
||||
major_opcode=0,
|
||||
num_props=0,
|
||||
num_visuals=0,
|
||||
props_buf_size=0,
|
||||
props_per_visual_size=0;
|
||||
int32_t *props_buf=NULL;
|
||||
|
||||
EPHYR_RETURN_VAL_IF_FAIL (dpy, FALSE) ;
|
||||
|
||||
screens = ScreenCount (dpy);
|
||||
if (!ephyrHostGLXGetMajorOpcode (&major_opcode)) {
|
||||
EPHYR_LOG_ERROR ("failed to get opcode\n") ;
|
||||
goto out ;
|
||||
}
|
||||
|
||||
LockDisplay(dpy);
|
||||
switch (a_type) {
|
||||
case EPHYR_GET_FB_CONFIG:
|
||||
GetReq(GLXGetFBConfigs,fb_req);
|
||||
fb_req->reqType = major_opcode;
|
||||
fb_req->glxCode = X_GLXGetFBConfigs;
|
||||
fb_req->screen = DefaultScreen (dpy);
|
||||
break;
|
||||
|
||||
case EPHYR_VENDOR_PRIV_GET_FB_CONFIG_SGIX:
|
||||
GetReqExtra(GLXVendorPrivateWithReply,
|
||||
sz_xGLXGetFBConfigsSGIXReq
|
||||
-
|
||||
sz_xGLXVendorPrivateWithReplyReq,
|
||||
vpreq);
|
||||
sgi_req = (xGLXGetFBConfigsSGIXReq *) vpreq;
|
||||
sgi_req->reqType = major_opcode;
|
||||
sgi_req->glxCode = X_GLXVendorPrivateWithReply;
|
||||
sgi_req->vendorCode = X_GLXvop_GetFBConfigsSGIX;
|
||||
sgi_req->screen = DefaultScreen (dpy);
|
||||
break;
|
||||
|
||||
case EPHYR_GET_VISUAL_CONFIGS:
|
||||
GetReq(GLXGetVisualConfigs,req);
|
||||
req->reqType = major_opcode;
|
||||
req->glxCode = X_GLXGetVisualConfigs;
|
||||
req->screen = DefaultScreen (dpy);
|
||||
break;
|
||||
}
|
||||
|
||||
if (!_XReply(dpy, (xReply*) &reply, 0, False)) {
|
||||
EPHYR_LOG_ERROR ("unknown error\n") ;
|
||||
UnlockDisplay(dpy);
|
||||
goto out ;
|
||||
}
|
||||
if (!reply.numVisuals) {
|
||||
EPHYR_LOG_ERROR ("screen does not support GL rendering\n") ;
|
||||
UnlockDisplay(dpy);
|
||||
goto out ;
|
||||
}
|
||||
num_visuals = reply.numVisuals ;
|
||||
|
||||
/* FIXME: Is the __GLX_MIN_CONFIG_PROPS test correct for
|
||||
* FIXME: FBconfigs?
|
||||
*/
|
||||
/* Check number of properties */
|
||||
num_props = reply.numProps;
|
||||
if ((num_props < __GLX_MIN_CONFIG_PROPS) ||
|
||||
(num_props > __GLX_MAX_CONFIG_PROPS)) {
|
||||
/* Huh? Not in protocol defined limits. Punt */
|
||||
EPHYR_LOG_ERROR ("got a bad reply to request\n") ;
|
||||
UnlockDisplay(dpy);
|
||||
goto out ;
|
||||
}
|
||||
|
||||
if (a_type != EPHYR_GET_VISUAL_CONFIGS) {
|
||||
num_props *= 2;
|
||||
}
|
||||
props_per_visual_size = num_props * __GLX_SIZE_INT32;
|
||||
props_buf_size = props_per_visual_size * reply.numVisuals;
|
||||
props_buf = malloc (props_buf_size) ;
|
||||
for (j = 0; j < reply.numVisuals; j++) {
|
||||
if (_XRead (dpy,
|
||||
&((char*)props_buf)[j*props_per_visual_size],
|
||||
props_per_visual_size) != Success) {
|
||||
EPHYR_LOG_ERROR ("read failed\n") ;
|
||||
}
|
||||
}
|
||||
UnlockDisplay(dpy);
|
||||
|
||||
*a_num_visuals = num_visuals ;
|
||||
*a_num_props = reply.numProps ;
|
||||
*a_props_buf_size = props_buf_size ;
|
||||
*a_props_buf = props_buf ;
|
||||
is_ok = TRUE ;
|
||||
|
||||
out:
|
||||
if (server_glx_version) {
|
||||
XFree (server_glx_version) ;
|
||||
server_glx_version = NULL ;
|
||||
}
|
||||
if (server_glx_extensions) {
|
||||
XFree (server_glx_extensions) ;
|
||||
server_glx_extensions = NULL ;
|
||||
}
|
||||
SyncHandle () ;
|
||||
return is_ok;
|
||||
}
|
||||
|
||||
Bool
|
||||
ephyrHostGLXGetVisualConfigs (int32_t a_screen,
|
||||
int32_t *a_num_visuals,
|
||||
int32_t *a_num_props,
|
||||
int32_t *a_props_buf_size,
|
||||
int32_t **a_props_buf)
|
||||
{
|
||||
Bool is_ok = FALSE;
|
||||
|
||||
EPHYR_LOG ("enter\n") ;
|
||||
is_ok = ephyrHostGLXGetVisualConfigsInternal (EPHYR_GET_VISUAL_CONFIGS,
|
||||
a_screen,
|
||||
a_num_visuals,
|
||||
a_num_props,
|
||||
a_props_buf_size,
|
||||
a_props_buf) ;
|
||||
|
||||
EPHYR_LOG ("leave:%d\n", is_ok) ;
|
||||
return is_ok;
|
||||
}
|
||||
|
||||
Bool
|
||||
ephyrHostGLXVendorPrivGetFBConfigsSGIX (int a_screen,
|
||||
int32_t *a_num_visuals,
|
||||
int32_t *a_num_props,
|
||||
int32_t *a_props_buf_size,
|
||||
int32_t **a_props_buf)
|
||||
{
|
||||
Bool is_ok=FALSE ;
|
||||
EPHYR_LOG ("enter\n") ;
|
||||
is_ok = ephyrHostGLXGetVisualConfigsInternal
|
||||
(EPHYR_VENDOR_PRIV_GET_FB_CONFIG_SGIX,
|
||||
a_screen,
|
||||
a_num_visuals,
|
||||
a_num_props,
|
||||
a_props_buf_size,
|
||||
a_props_buf) ;
|
||||
EPHYR_LOG ("leave\n") ;
|
||||
return is_ok ;
|
||||
}
|
||||
|
||||
Bool
|
||||
ephyrHostGLXSendClientInfo (int32_t a_major, int32_t a_minor,
|
||||
const char* a_extension_list)
|
||||
{
|
||||
Bool is_ok = FALSE ;
|
||||
Display *dpy = hostx_get_display () ;
|
||||
xGLXClientInfoReq *req;
|
||||
int size;
|
||||
int32_t major_opcode=0 ;
|
||||
|
||||
EPHYR_RETURN_VAL_IF_FAIL (dpy && a_extension_list, FALSE) ;
|
||||
|
||||
if (!ephyrHostGLXGetMajorOpcode (&major_opcode)) {
|
||||
EPHYR_LOG_ERROR ("failed to get major opcode\n") ;
|
||||
goto out ;
|
||||
}
|
||||
|
||||
LockDisplay (dpy);
|
||||
|
||||
GetReq (GLXClientInfo,req);
|
||||
req->reqType = major_opcode;
|
||||
req->glxCode = X_GLXClientInfo;
|
||||
req->major = a_major;
|
||||
req->minor = a_minor;
|
||||
|
||||
size = strlen (a_extension_list) + 1;
|
||||
req->length += (size + 3) >> 2;
|
||||
req->numbytes = size;
|
||||
Data (dpy, a_extension_list, size);
|
||||
|
||||
UnlockDisplay(dpy);
|
||||
SyncHandle();
|
||||
|
||||
is_ok=TRUE ;
|
||||
|
||||
out:
|
||||
return is_ok ;
|
||||
}
|
||||
|
||||
Bool
|
||||
ephyrHostGLXCreateContext (int a_screen,
|
||||
int a_visual_id,
|
||||
int a_context_id,
|
||||
int a_share_list_ctxt_id,
|
||||
Bool a_direct)
|
||||
{
|
||||
Bool is_ok = FALSE;
|
||||
Display *dpy = hostx_get_display ();
|
||||
int major_opcode=0, remote_context_id=0;
|
||||
xGLXCreateContextReq *req;
|
||||
|
||||
EPHYR_LOG ("enter. screen:%d, visual:%d, contextid:%d, direct:%d\n",
|
||||
a_screen, a_visual_id, a_context_id, a_direct) ;
|
||||
|
||||
if (!hostx_allocate_resource_id_peer (a_context_id, &remote_context_id)) {
|
||||
EPHYR_LOG_ERROR ("failed to peer the context id %d host X",
|
||||
remote_context_id) ;
|
||||
goto out ;
|
||||
}
|
||||
|
||||
if (!ephyrHostGLXGetMajorOpcode (&major_opcode)) {
|
||||
EPHYR_LOG_ERROR ("failed to get major opcode\n") ;
|
||||
goto out ;
|
||||
}
|
||||
|
||||
LockDisplay (dpy) ;
|
||||
|
||||
/* Send the glXCreateContext request */
|
||||
GetReq(GLXCreateContext,req);
|
||||
req->reqType = major_opcode;
|
||||
req->glxCode = X_GLXCreateContext;
|
||||
req->context = remote_context_id;
|
||||
req->visual = a_visual_id;
|
||||
req->screen = DefaultScreen (dpy);
|
||||
req->shareList = a_share_list_ctxt_id;
|
||||
req->isDirect = a_direct;
|
||||
|
||||
UnlockDisplay (dpy);
|
||||
SyncHandle ();
|
||||
|
||||
is_ok = TRUE ;
|
||||
|
||||
out:
|
||||
EPHYR_LOG ("leave\n") ;
|
||||
return is_ok ;
|
||||
}
|
||||
|
||||
Bool
|
||||
ephyrHostDestroyContext (int a_ctxt_id)
|
||||
{
|
||||
Bool is_ok=FALSE;
|
||||
Display *dpy=hostx_get_display ();
|
||||
int major_opcode=0, remote_ctxt_id=0 ;
|
||||
xGLXDestroyContextReq *req=NULL;
|
||||
|
||||
EPHYR_LOG ("enter:%d\n", a_ctxt_id) ;
|
||||
|
||||
if (!ephyrHostGLXGetMajorOpcode (&major_opcode)) {
|
||||
EPHYR_LOG_ERROR ("failed to get major opcode\n") ;
|
||||
goto out ;
|
||||
}
|
||||
if (!hostx_get_resource_id_peer (a_ctxt_id, &remote_ctxt_id)) {
|
||||
EPHYR_LOG_ERROR ("failed to get remote glx ctxt id\n") ;
|
||||
goto out ;
|
||||
}
|
||||
EPHYR_LOG ("host context id:%d\n", remote_ctxt_id) ;
|
||||
|
||||
LockDisplay (dpy);
|
||||
GetReq (GLXDestroyContext,req);
|
||||
req->reqType = major_opcode;
|
||||
req->glxCode = X_GLXDestroyContext;
|
||||
req->context = remote_ctxt_id;
|
||||
UnlockDisplay (dpy);
|
||||
SyncHandle ();
|
||||
|
||||
is_ok = TRUE ;
|
||||
|
||||
out:
|
||||
EPHYR_LOG ("leave\n") ;
|
||||
return is_ok ;
|
||||
}
|
||||
|
||||
Bool
|
||||
ephyrHostGLXMakeCurrent (int a_drawable,
|
||||
int a_glx_ctxt_id,
|
||||
int a_old_ctxt_tag,
|
||||
int *a_ctxt_tag)
|
||||
{
|
||||
Bool is_ok=FALSE ;
|
||||
Display *dpy = hostx_get_display () ;
|
||||
int32_t major_opcode=0 ;
|
||||
int remote_glx_ctxt_id=0 ;
|
||||
xGLXMakeCurrentReq *req;
|
||||
xGLXMakeCurrentReply reply;
|
||||
|
||||
EPHYR_RETURN_VAL_IF_FAIL (a_ctxt_tag, FALSE) ;
|
||||
|
||||
EPHYR_LOG ("enter. drawable:%d, context:%d, oldtag:%d\n",
|
||||
a_drawable, a_glx_ctxt_id, a_old_ctxt_tag) ;
|
||||
|
||||
if (!ephyrHostGLXGetMajorOpcode (&major_opcode)) {
|
||||
EPHYR_LOG_ERROR ("failed to get major opcode\n") ;
|
||||
goto out ;
|
||||
}
|
||||
if (!hostx_get_resource_id_peer (a_glx_ctxt_id, &remote_glx_ctxt_id)) {
|
||||
EPHYR_LOG_ERROR ("failed to get remote glx ctxt id\n") ;
|
||||
goto out ;
|
||||
}
|
||||
|
||||
LockDisplay (dpy);
|
||||
|
||||
GetReq (GLXMakeCurrent,req);
|
||||
req->reqType = major_opcode;
|
||||
req->glxCode = X_GLXMakeCurrent;
|
||||
req->drawable = a_drawable;
|
||||
req->context = remote_glx_ctxt_id;
|
||||
req->oldContextTag = a_old_ctxt_tag;
|
||||
|
||||
memset (&reply, 0, sizeof (reply)) ;
|
||||
if (!_XReply (dpy, (xReply*)&reply, 0, False)) {
|
||||
EPHYR_LOG_ERROR ("failed to get reply from host\n") ;
|
||||
UnlockDisplay (dpy);
|
||||
SyncHandle ();
|
||||
goto out ;
|
||||
}
|
||||
UnlockDisplay (dpy);
|
||||
SyncHandle ();
|
||||
*a_ctxt_tag = reply.contextTag ;
|
||||
EPHYR_LOG ("context tag:%d\n", *a_ctxt_tag) ;
|
||||
is_ok = TRUE ;
|
||||
|
||||
out:
|
||||
EPHYR_LOG ("leave\n") ;
|
||||
return is_ok ;
|
||||
}
|
||||
|
||||
#define X_GLXSingle 0
|
||||
|
||||
#define __EPHYR_GLX_SINGLE_PUT_CHAR(offset,a) \
|
||||
*((INT8 *) (pc + offset)) = a
|
||||
|
||||
#define EPHYR_GLX_SINGLE_PUT_SHORT(offset,a) \
|
||||
*((INT16 *) (pc + offset)) = a
|
||||
|
||||
#define EPHYR_GLX_SINGLE_PUT_LONG(offset,a) \
|
||||
*((INT32 *) (pc + offset)) = a
|
||||
|
||||
#define EPHYR_GLX_SINGLE_PUT_FLOAT(offset,a) \
|
||||
*((FLOAT32 *) (pc + offset)) = a
|
||||
|
||||
#define EPHYR_GLX_SINGLE_READ_XREPLY() \
|
||||
(void) _XReply(dpy, (xReply*) &reply, 0, False)
|
||||
|
||||
#define EPHYR_GLX_SINGLE_GET_RETVAL(a,cast) \
|
||||
a = (cast) reply.retval
|
||||
|
||||
#define EPHYR_GLX_SINGLE_GET_SIZE(a) \
|
||||
a = (GLint) reply.size
|
||||
|
||||
#define EPHYR_GLX_SINGLE_GET_CHAR(p) \
|
||||
*p = *(GLbyte *)&reply.pad3;
|
||||
|
||||
#define EPHYR_GLX_SINGLE_GET_SHORT(p) \
|
||||
*p = *(GLshort *)&reply.pad3;
|
||||
|
||||
#define EPHYR_GLX_SINGLE_GET_LONG(p) \
|
||||
*p = *(GLint *)&reply.pad3;
|
||||
|
||||
#define EPHYR_GLX_SINGLE_GET_FLOAT(p) \
|
||||
*p = *(GLfloat *)&reply.pad3;
|
||||
|
||||
Bool
|
||||
ephyrHostGetIntegerValue (int a_current_context_tag, int a_int, int *a_val)
|
||||
{
|
||||
Bool is_ok=FALSE;
|
||||
Display *dpy = hostx_get_display () ;
|
||||
int major_opcode=0, size=0;
|
||||
xGLXSingleReq *req=NULL;
|
||||
xGLXSingleReply reply;
|
||||
unsigned char* pc=NULL ;
|
||||
|
||||
EPHYR_RETURN_VAL_IF_FAIL (a_val, FALSE) ;
|
||||
|
||||
EPHYR_LOG ("enter\n") ;
|
||||
if (!ephyrHostGLXGetMajorOpcode (&major_opcode)) {
|
||||
EPHYR_LOG_ERROR ("failed to get major opcode\n") ;
|
||||
goto out ;
|
||||
}
|
||||
LockDisplay (dpy) ;
|
||||
GetReqExtra (GLXSingle, 4, req) ;
|
||||
req->reqType = major_opcode ;
|
||||
req->glxCode = X_GLsop_GetIntegerv ;
|
||||
req->contextTag = a_current_context_tag;
|
||||
pc = ((unsigned char *)(req) + sz_xGLXSingleReq) ;
|
||||
EPHYR_GLX_SINGLE_PUT_LONG (0, a_int) ;
|
||||
EPHYR_GLX_SINGLE_READ_XREPLY () ;
|
||||
EPHYR_GLX_SINGLE_GET_SIZE (size) ;
|
||||
if (!size) {
|
||||
UnlockDisplay (dpy) ;
|
||||
SyncHandle () ;
|
||||
EPHYR_LOG_ERROR ("X_GLsop_GetIngerv failed\n") ;
|
||||
goto out ;
|
||||
}
|
||||
EPHYR_GLX_SINGLE_GET_LONG (a_val) ;
|
||||
UnlockDisplay (dpy) ;
|
||||
SyncHandle () ;
|
||||
is_ok = TRUE ;
|
||||
|
||||
out:
|
||||
EPHYR_LOG ("leave\n") ;
|
||||
return is_ok ;
|
||||
}
|
||||
|
||||
Bool
|
||||
ephyrHostIsContextDirect (int a_ctxt_id,
|
||||
int *a_is_direct)
|
||||
{
|
||||
Bool is_ok=FALSE;
|
||||
Display *dpy = hostx_get_display () ;
|
||||
xGLXIsDirectReq *req=NULL;
|
||||
xGLXIsDirectReply reply;
|
||||
int major_opcode=0, remote_glx_ctxt_id=0;
|
||||
|
||||
EPHYR_LOG ("enter\n") ;
|
||||
if (!ephyrHostGLXGetMajorOpcode (&major_opcode)) {
|
||||
EPHYR_LOG_ERROR ("failed to get major opcode\n") ;
|
||||
goto out ;
|
||||
}
|
||||
if (!hostx_get_resource_id_peer (a_ctxt_id, &remote_glx_ctxt_id)) {
|
||||
EPHYR_LOG_ERROR ("failed to get remote glx ctxt id\n") ;
|
||||
goto out ;
|
||||
}
|
||||
memset (&reply, 0, sizeof (reply)) ;
|
||||
|
||||
/* Send the glXIsDirect request */
|
||||
LockDisplay (dpy);
|
||||
GetReq (GLXIsDirect,req);
|
||||
req->reqType = major_opcode;
|
||||
req->glxCode = X_GLXIsDirect;
|
||||
req->context = remote_glx_ctxt_id;
|
||||
if (!_XReply (dpy, (xReply*) &reply, 0, False)) {
|
||||
EPHYR_LOG_ERROR ("fail in reading reply from host\n") ;
|
||||
UnlockDisplay (dpy);
|
||||
SyncHandle ();
|
||||
goto out ;
|
||||
}
|
||||
UnlockDisplay (dpy);
|
||||
SyncHandle ();
|
||||
*a_is_direct = reply.isDirect ;
|
||||
is_ok = TRUE ;
|
||||
|
||||
out:
|
||||
EPHYR_LOG ("leave\n") ;
|
||||
return is_ok ;
|
||||
}
|
||||
|
||||
#endif /*XEPHYR_DRI*/
|
||||
|
76
hw/kdrive/ephyr/ephyrhostglx.h
Normal file
76
hw/kdrive/ephyr/ephyrhostglx.h
Normal file
|
@ -0,0 +1,76 @@
|
|||
/*
|
||||
* Xephyr - A kdrive X server thats runs in a host X window.
|
||||
* Authored by Matthew Allum <mallum@openedhand.com>
|
||||
*
|
||||
* Copyright © 2007 OpenedHand Ltd
|
||||
*
|
||||
* Permission to use, copy, modify, distribute, and sell this software and its
|
||||
* documentation for any purpose is hereby granted without fee, provided that
|
||||
* the above copyright notice appear in all copies and that both that
|
||||
* copyright notice and this permission notice appear in supporting
|
||||
* documentation, and that the name of OpenedHand Ltd not be used in
|
||||
* advertising or publicity pertaining to distribution of the software without
|
||||
* specific, written prior permission. OpenedHand Ltd makes no
|
||||
* representations about the suitability of this software for any purpose. It
|
||||
* is provided "as is" without express or implied warranty.
|
||||
*
|
||||
* OpenedHand Ltd DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
||||
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
|
||||
* EVENT SHALL OpenedHand Ltd BE LIABLE FOR ANY SPECIAL, INDIRECT OR
|
||||
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
||||
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
||||
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
||||
* PERFORMANCE OF THIS SOFTWARE.
|
||||
*
|
||||
* Authors:
|
||||
* Dodji Seketeli <dodji@openedhand.com>
|
||||
*/
|
||||
#ifndef __EPHYRHOSTGLX_H__
|
||||
#define __EPHYRHOSTGLX_H__
|
||||
|
||||
enum EphyrHostGLXGetStringOps {
|
||||
EPHYR_HOST_GLX_UNDEF,
|
||||
EPHYR_HOST_GLX_QueryServerString,
|
||||
EPHYR_HOST_GLX_GetString,
|
||||
};
|
||||
|
||||
Bool ephyrHostGLXQueryVersion (int *a_maj, int *a_min) ;
|
||||
Bool ephyrHostGLXGetStringFromServer (int a_screen_number,
|
||||
int a_string_name,
|
||||
enum EphyrHostGLXGetStringOps a_op,
|
||||
char **a_string) ;
|
||||
Bool ephyrHostGLXGetVisualConfigs (int a_screen,
|
||||
int32_t *a_num_visuals,
|
||||
int32_t *a_num_props,
|
||||
int32_t *a_props_buf_size,
|
||||
int32_t **a_props_buf) ;
|
||||
Bool
|
||||
ephyrHostGLXVendorPrivGetFBConfigsSGIX (int a_screen,
|
||||
int32_t *a_num_visuals,
|
||||
int32_t *a_num_props,
|
||||
int32_t *a_props_buf_size,
|
||||
int32_t **a_props_buf);
|
||||
Bool ephyrHostGLXGetMajorOpcode (int32_t *a_opcode) ;
|
||||
Bool ephyrHostGLXSendClientInfo (int32_t a_major, int32_t a_minor,
|
||||
const char* a_extension_list) ;
|
||||
Bool ephyrHostGLXCreateContext (int a_screen,
|
||||
int a_visual_id,
|
||||
int a_context_id,
|
||||
int a_shared_list_ctx_id,
|
||||
Bool a_direct) ;
|
||||
|
||||
Bool ephyrHostDestroyContext (int a_ctxt_id) ;
|
||||
|
||||
Bool ephyrHostGLXMakeCurrent (int a_drawable, int a_glx_ctxt_id,
|
||||
int a_olg_ctxt_tag, int *a_ctxt_tag) ;
|
||||
|
||||
Bool ephyrHostGetIntegerValue (int a_current_context_tag,
|
||||
int a_int,
|
||||
int *a_val) ;
|
||||
|
||||
Bool ephyrHostIsContextDirect (int a_ctxt_id,
|
||||
int *a_is_direct) ;
|
||||
|
||||
|
||||
#endif /*__EPHYRHOSTGLX_H__*/
|
||||
|
94
hw/kdrive/ephyr/ephyrhostproxy.c
Normal file
94
hw/kdrive/ephyr/ephyrhostproxy.c
Normal file
|
@ -0,0 +1,94 @@
|
|||
/*
|
||||
* Xephyr - A kdrive X server thats runs in a host X window.
|
||||
* Authored by Matthew Allum <mallum@openedhand.com>
|
||||
*
|
||||
* Copyright © 2007 OpenedHand Ltd
|
||||
*
|
||||
* Permission to use, copy, modify, distribute, and sell this software and its
|
||||
* documentation for any purpose is hereby granted without fee, provided that
|
||||
* the above copyright notice appear in all copies and that both that
|
||||
* copyright notice and this permission notice appear in supporting
|
||||
* documentation, and that the name of OpenedHand Ltd not be used in
|
||||
* advertising or publicity pertaining to distribution of the software without
|
||||
* specific, written prior permission. OpenedHand Ltd makes no
|
||||
* representations about the suitability of this software for any purpose. It
|
||||
* is provided "as is" without express or implied warranty.
|
||||
*
|
||||
* OpenedHand Ltd DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
||||
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
|
||||
* EVENT SHALL OpenedHand Ltd BE LIABLE FOR ANY SPECIAL, INDIRECT OR
|
||||
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
||||
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
||||
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
||||
* PERFORMANCE OF THIS SOFTWARE.
|
||||
*
|
||||
* Authors:
|
||||
* Dodji Seketeli <dodji@openedhand.com>
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <kdrive-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/Xlibint.h>
|
||||
#define _HAVE_XALLOC_DECLS
|
||||
#include "ephyrlog.h"
|
||||
#include "ephyrhostproxy.h"
|
||||
#include "hostx.h"
|
||||
|
||||
/* byte swap a short */
|
||||
#define swaps(x, n) { \
|
||||
n = ((char *) (x))[0];\
|
||||
((char *) (x))[0] = ((char *) (x))[1];\
|
||||
((char *) (x))[1] = n; }
|
||||
|
||||
#define GetXReq(req) \
|
||||
WORD64ALIGN ;\
|
||||
if ((dpy->bufptr + SIZEOF(xReq)) > dpy->bufmax)\
|
||||
_XFlush(dpy);\
|
||||
req = (xReq *)(dpy->last_req = dpy->bufptr);\
|
||||
dpy->bufptr += SIZEOF(xReq);\
|
||||
dpy->request++
|
||||
|
||||
|
||||
Bool
|
||||
ephyrHostProxyDoForward (pointer a_request_buffer,
|
||||
struct XReply *a_reply,
|
||||
Bool a_do_swap)
|
||||
{
|
||||
Bool is_ok = FALSE ;
|
||||
int n=0 ;
|
||||
Display *dpy=hostx_get_display () ;
|
||||
xReq *in_req = (xReq*) a_request_buffer ;
|
||||
xReq *forward_req=NULL ;
|
||||
struct XReply reply ;
|
||||
|
||||
EPHYR_RETURN_VAL_IF_FAIL (in_req && dpy, FALSE) ;
|
||||
|
||||
EPHYR_LOG ("enter\n") ;
|
||||
|
||||
if (a_do_swap) {
|
||||
swaps (&in_req->length, n) ;
|
||||
}
|
||||
EPHYR_LOG ("Req {type:%d, data:%d, length:%d}\n",
|
||||
in_req->reqType, in_req->data, in_req->length) ;
|
||||
GetXReq (forward_req) ;
|
||||
memmove (forward_req, in_req, 4) ;
|
||||
|
||||
if (!_XReply (dpy, (xReply*) &reply, 0, FALSE)) {
|
||||
EPHYR_LOG_ERROR ("failed to get reply\n") ;
|
||||
goto out;
|
||||
}
|
||||
EPHYR_LOG ("XReply{type:%d, foo:%d, seqnum:%d, length:%d}\n",
|
||||
reply.type, reply.foo, reply.sequence_number, reply.length) ;
|
||||
|
||||
if (a_reply) {
|
||||
memmove (a_reply, &reply, sizeof (reply)) ;
|
||||
}
|
||||
is_ok = TRUE ;
|
||||
|
||||
out:
|
||||
EPHYR_LOG ("leave\n") ;
|
||||
return is_ok ;
|
||||
}
|
||||
|
51
hw/kdrive/ephyr/ephyrhostproxy.h
Normal file
51
hw/kdrive/ephyr/ephyrhostproxy.h
Normal file
|
@ -0,0 +1,51 @@
|
|||
/*
|
||||
* Xephyr - A kdrive X server thats runs in a host X window.
|
||||
* Authored by Matthew Allum <mallum@openedhand.com>
|
||||
*
|
||||
* Copyright © 2007 OpenedHand Ltd
|
||||
*
|
||||
* Permission to use, copy, modify, distribute, and sell this software and its
|
||||
* documentation for any purpose is hereby granted without fee, provided that
|
||||
* the above copyright notice appear in all copies and that both that
|
||||
* copyright notice and this permission notice appear in supporting
|
||||
* documentation, and that the name of OpenedHand Ltd not be used in
|
||||
* advertising or publicity pertaining to distribution of the software without
|
||||
* specific, written prior permission. OpenedHand Ltd makes no
|
||||
* representations about the suitability of this software for any purpose. It
|
||||
* is provided "as is" without express or implied warranty.
|
||||
*
|
||||
* OpenedHand Ltd DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
||||
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
|
||||
* EVENT SHALL OpenedHand Ltd BE LIABLE FOR ANY SPECIAL, INDIRECT OR
|
||||
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
||||
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
||||
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
||||
* PERFORMANCE OF THIS SOFTWARE.
|
||||
*
|
||||
* Authors:
|
||||
* Dodji Seketeli <dodji@openedhand.com>
|
||||
*/
|
||||
|
||||
#ifndef __EPHYRHOSTPROXY_H__
|
||||
#define __EPHYRHOSTPROXY_H__
|
||||
|
||||
struct XReply {
|
||||
int8_t type ;/*X_Reply*/
|
||||
int8_t foo;
|
||||
int16_t sequence_number ;
|
||||
int32_t length ;
|
||||
/*following is some data up to 32 bytes lenght*/
|
||||
int32_t pad0 ;
|
||||
int32_t pad1 ;
|
||||
int32_t pad2 ;
|
||||
int32_t pad3 ;
|
||||
int32_t pad4 ;
|
||||
int32_t pad5 ;
|
||||
};
|
||||
|
||||
Bool
|
||||
ephyrHostProxyDoForward (pointer a_request_buffer,
|
||||
struct XReply *a_reply,
|
||||
Bool a_do_swap) ;
|
||||
|
||||
#endif /*__EPHYRHOSTPROXY_H__*/
|
1004
hw/kdrive/ephyr/ephyrhostvideo.c
Normal file
1004
hw/kdrive/ephyr/ephyrhostvideo.c
Normal file
File diff suppressed because it is too large
Load Diff
238
hw/kdrive/ephyr/ephyrhostvideo.h
Normal file
238
hw/kdrive/ephyr/ephyrhostvideo.h
Normal file
|
@ -0,0 +1,238 @@
|
|||
/*
|
||||
* Xephyr - A kdrive X server thats runs in a host X window.
|
||||
* Authored by Matthew Allum <mallum@openedhand.com>
|
||||
*
|
||||
* Copyright © 2007 OpenedHand Ltd
|
||||
*
|
||||
* Permission to use, copy, modify, distribute, and sell this software and its
|
||||
* documentation for any purpose is hereby granted without fee, provided that
|
||||
* the above copyright notice appear in all copies and that both that
|
||||
* copyright notice and this permission notice appear in supporting
|
||||
* documentation, and that the name of OpenedHand Ltd not be used in
|
||||
* advertising or publicity pertaining to distribution of the software without
|
||||
* specific, written prior permission. OpenedHand Ltd makes no
|
||||
* representations about the suitability of this software for any purpose. It
|
||||
* is provided "as is" without express or implied warranty.
|
||||
*
|
||||
* OpenedHand Ltd DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
||||
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
|
||||
* EVENT SHALL OpenedHand Ltd BE LIABLE FOR ANY SPECIAL, INDIRECT OR
|
||||
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
||||
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
||||
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
||||
* PERFORMANCE OF THIS SOFTWARE.
|
||||
*
|
||||
* Authors:
|
||||
* Dodji Seketeli <dodji@openedhand.com>
|
||||
*/
|
||||
#ifndef __EPHYRHOSTVIDEO_H__
|
||||
#define __EPHYRHOSTVIDEO_H__
|
||||
|
||||
typedef void* EphyrHostXVAdaptor ;
|
||||
typedef struct _EphyrHostXVAdaptorArray EphyrHostXVAdaptorArray ;
|
||||
|
||||
typedef struct _EphyrHostVideoFormat {
|
||||
char depth ;
|
||||
short visual_class;
|
||||
} EphyrHostVideoFormat ;
|
||||
|
||||
typedef struct _EphyrHostRational {
|
||||
int numerator ;
|
||||
int denominator ;
|
||||
} EphyrHostRational;
|
||||
|
||||
typedef struct _EphyrHostEncoding {
|
||||
int id ;
|
||||
char *name ;
|
||||
unsigned short width, height ;
|
||||
EphyrHostRational rate ;
|
||||
} EphyrHostEncoding ;
|
||||
|
||||
typedef struct _EphyrHostAttribute {
|
||||
int flags;
|
||||
int min_value;
|
||||
int max_value;
|
||||
char *name;
|
||||
} EphyrHostAttribute ;
|
||||
|
||||
typedef struct _EphyrHostImageFormat {
|
||||
int id; /* Unique descriptor for the format */
|
||||
int type; /* XvRGB, XvYUV */
|
||||
int byte_order; /* LSBFirst, MSBFirst */
|
||||
char guid[16]; /* Globally Unique IDentifier */
|
||||
int bits_per_pixel;
|
||||
int format; /* XvPacked, XvPlanar */
|
||||
int num_planes;
|
||||
|
||||
/* for RGB formats only */
|
||||
int depth;
|
||||
unsigned int red_mask;
|
||||
unsigned int green_mask;
|
||||
unsigned int blue_mask;
|
||||
|
||||
/* for YUV formats only */
|
||||
unsigned int y_sample_bits;
|
||||
unsigned int u_sample_bits;
|
||||
unsigned int v_sample_bits;
|
||||
unsigned int horz_y_period;
|
||||
unsigned int horz_u_period;
|
||||
unsigned int horz_v_period;
|
||||
unsigned int vert_y_period;
|
||||
unsigned int vert_u_period;
|
||||
unsigned int vert_v_period;
|
||||
char component_order[32]; /* eg. UYVY */
|
||||
int scanline_order; /* XvTopToBottom, XvBottomToTop */
|
||||
} EphyrHostImageFormat ;
|
||||
|
||||
typedef struct {
|
||||
unsigned short x1, y1, x2, y2 ;
|
||||
} EphyrHostBox ;
|
||||
|
||||
void ephyrHostXVInit (void) ;
|
||||
|
||||
void ephyrHostFree (void *a_pointer) ;
|
||||
|
||||
/*
|
||||
* host adaptor array
|
||||
*/
|
||||
Bool ephyrHostXVQueryAdaptors (EphyrHostXVAdaptorArray **a_adaptors) ;
|
||||
void ephyrHostXVAdaptorArrayDelete (EphyrHostXVAdaptorArray *a_adaptors) ;
|
||||
int ephyrHostXVAdaptorArrayGetSize (const EphyrHostXVAdaptorArray *a_this) ;
|
||||
EphyrHostXVAdaptor* ephyrHostXVAdaptorArrayAt (const EphyrHostXVAdaptorArray *a_this,
|
||||
int a_index) ;
|
||||
|
||||
/*
|
||||
* host adaptor
|
||||
*/
|
||||
|
||||
char ephyrHostXVAdaptorGetType (const EphyrHostXVAdaptor *a_this) ;
|
||||
const char* ephyrHostXVAdaptorGetName (const EphyrHostXVAdaptor *a_this) ;
|
||||
EphyrHostVideoFormat* ephyrHostXVAdaptorGetVideoFormats
|
||||
(const EphyrHostXVAdaptor *a_this,
|
||||
int *a_nb_formats) ;
|
||||
int ephyrHostXVAdaptorGetNbPorts (const EphyrHostXVAdaptor *a_this) ;
|
||||
int ephyrHostXVAdaptorGetFirstPortID (const EphyrHostXVAdaptor *a_this) ;
|
||||
|
||||
Bool ephyrHostXVAdaptorHasPutVideo (const EphyrHostXVAdaptor *a_this,
|
||||
Bool *a_result) ;
|
||||
Bool ephyrHostXVAdaptorHasGetVideo (const EphyrHostXVAdaptor *a_this,
|
||||
Bool *a_result) ;
|
||||
Bool ephyrHostXVAdaptorHasPutStill (const EphyrHostXVAdaptor *a_this,
|
||||
Bool *a_result) ;
|
||||
Bool ephyrHostXVAdaptorHasGetStill (const EphyrHostXVAdaptor *a_this,
|
||||
Bool *a_result) ;
|
||||
Bool ephyrHostXVAdaptorHasPutImage (const EphyrHostXVAdaptor *a_this,
|
||||
Bool *a_result) ;
|
||||
|
||||
/*
|
||||
* encoding
|
||||
*/
|
||||
Bool ephyrHostXVQueryEncodings (int a_port_id,
|
||||
EphyrHostEncoding **a_encodings,
|
||||
unsigned int *a_num_encodings) ;
|
||||
|
||||
void ephyrHostEncodingsDelete (EphyrHostEncoding *a_encodings,
|
||||
int a_num_encodings) ;
|
||||
|
||||
/*
|
||||
* attribute
|
||||
*/
|
||||
Bool ephyrHostXVQueryPortAttributes (int a_port_id,
|
||||
EphyrHostAttribute **a_attributes,
|
||||
int *a_num_attributes) ;
|
||||
|
||||
void ephyrHostAttributesDelete (EphyrHostAttribute *a_attributes) ;
|
||||
/*
|
||||
* image format
|
||||
*/
|
||||
|
||||
Bool ephyrHostXVQueryImageFormats (int a_port_id,
|
||||
EphyrHostImageFormat **a_formats,
|
||||
int *a_num_format) ;
|
||||
/*
|
||||
* Port Attribute Get/Set
|
||||
*/
|
||||
Bool ephyrHostXVSetPortAttribute (int a_port_id,
|
||||
int a_atom,
|
||||
int a_attr_value) ;
|
||||
Bool ephyrHostXVGetPortAttribute (int a_port_id,
|
||||
int a_atom,
|
||||
int *a_attr_value) ;
|
||||
/*
|
||||
*size query
|
||||
*/
|
||||
Bool ephyrHostXVQueryBestSize (int a_port_id,
|
||||
Bool a_motion,
|
||||
unsigned int a_frame_w,
|
||||
unsigned int a_frame_h,
|
||||
unsigned int a_drw_w,
|
||||
unsigned int a_drw_h,
|
||||
unsigned int *a_actual_w,
|
||||
unsigned int *a_actual_h) ;
|
||||
|
||||
Bool ephyrHostXVQueryImageAttributes (int a_port_id,
|
||||
int a_image_id /*image fourcc code*/,
|
||||
unsigned short *a_width,
|
||||
unsigned short *a_height,
|
||||
int *a_image_size,
|
||||
int *a_pitches,
|
||||
int *a_offsets) ;
|
||||
/*
|
||||
* atom
|
||||
*/
|
||||
Bool ephyrHostGetAtom (const char* a_name,
|
||||
Bool a_create_if_not_exists,
|
||||
int *a_atom) ;
|
||||
char* ephyrHostGetAtomName (int a_atom) ;
|
||||
|
||||
/*
|
||||
*PutImage
|
||||
* (ignore clipping for now)
|
||||
*/
|
||||
Bool ephyrHostXVPutImage (int a_screen_num,
|
||||
int a_port_id,
|
||||
int a_image_id,
|
||||
int a_drw_x,
|
||||
int a_drw_y,
|
||||
int a_drw_w,
|
||||
int a_drw_h,
|
||||
int a_src_x,
|
||||
int a_src_y,
|
||||
int a_src_w,
|
||||
int a_src_h,
|
||||
int a_image_width,
|
||||
int a_image_height,
|
||||
unsigned char *a_buf,
|
||||
EphyrHostBox *a_clip_rects,
|
||||
int a_clip_rect_nums) ;
|
||||
|
||||
/*
|
||||
* Putvideo/PutStill/GetVideo
|
||||
*/
|
||||
Bool ephyrHostXVPutVideo (int a_screen_num,
|
||||
int a_port_id,
|
||||
int a_vid_x, int a_vid_y, int a_vid_w, int a_vid_h,
|
||||
int a_drw_x, int a_drw_y, int a_drw_w, int a_drw_h) ;
|
||||
|
||||
Bool ephyrHostXVGetVideo (int a_screen_num,
|
||||
int a_port_id,
|
||||
int a_vid_x, int a_vid_y, int a_vid_w, int a_vid_h,
|
||||
int a_drw_x, int a_drw_y, int a_drw_w, int a_drw_h) ;
|
||||
|
||||
Bool ephyrHostXVPutStill (int a_screen_num,
|
||||
int a_port_id,
|
||||
int a_vid_x, int a_vid_y, int a_vid_w, int a_vid_h,
|
||||
int a_drw_x, int a_drw_y, int a_drw_w, int a_drw_h) ;
|
||||
|
||||
Bool ephyrHostXVGetStill (int a_screen_num,
|
||||
int a_port_id,
|
||||
int a_vid_x, int a_vid_y, int a_vid_w, int a_vid_h,
|
||||
int a_drw_x, int a_drw_y, int a_drw_w, int a_drw_h) ;
|
||||
|
||||
/*
|
||||
* StopVideo
|
||||
*/
|
||||
Bool ephyrHostXVStopVideo (int a_screen_num, int a_port_id) ;
|
||||
|
||||
#endif /*__EPHYRHOSTVIDEO_H__*/
|
||||
|
|
@ -27,12 +27,19 @@
|
|||
#include <kdrive-config.h>
|
||||
#endif
|
||||
#include "ephyr.h"
|
||||
#include "ephyrlog.h"
|
||||
|
||||
extern Window EphyrPreExistingHostWin;
|
||||
extern Bool EphyrWantGrayScale;
|
||||
extern Bool kdHasPointer;
|
||||
extern Bool kdHasKbd;
|
||||
|
||||
#ifdef GLXEXT
|
||||
extern Bool ephyrNoDRI;
|
||||
extern Bool noGlxVisualInit;
|
||||
#endif
|
||||
extern Bool ephyrNoXV;
|
||||
|
||||
void processScreenArg (char *screen_size, char *parent_id) ;
|
||||
|
||||
void
|
||||
|
@ -92,11 +99,16 @@ ddxUseMsg (void)
|
|||
KdUseMsg();
|
||||
|
||||
ErrorF("\nXephyr Option Usage:\n");
|
||||
ErrorF("-parent XID Use existing window as Xephyr root win\n");
|
||||
ErrorF("-parent <XID> Use existing window as Xephyr root win\n");
|
||||
ErrorF("-host-cursor Re-use exisiting X host server cursor\n");
|
||||
ErrorF("-fullscreen Attempt to run Xephyr fullscreen\n");
|
||||
ErrorF("-grayscale Simulate 8bit grayscale\n");
|
||||
ErrorF("-fakexa Simulate acceleration using software rendering\n");
|
||||
ErrorF("-verbosity <level> Set log verbosity level\n");
|
||||
#ifdef GLXEXT
|
||||
ErrorF("-nodri do not use DRI\n");
|
||||
#endif
|
||||
ErrorF("-noxv do not use XV\n");
|
||||
ErrorF("\n");
|
||||
|
||||
exit(1);
|
||||
|
@ -106,7 +118,6 @@ void
|
|||
processScreenArg (char *screen_size, char *parent_id)
|
||||
{
|
||||
KdCardInfo *card;
|
||||
static int card_exists;
|
||||
|
||||
InitCard (0); /*Put each screen on a separate card*/
|
||||
card = KdCardInfoLast ();
|
||||
|
@ -182,6 +193,36 @@ ddxProcessArgument (int argc, char **argv, int i)
|
|||
ephyrFuncs.finiAccel = ephyrDrawFini;
|
||||
return 1;
|
||||
}
|
||||
else if (!strcmp (argv[i], "-verbosity"))
|
||||
{
|
||||
if(i+1 < argc && argv[i+1][0] != '-')
|
||||
{
|
||||
int verbosity=atoi (argv[i+1]) ;
|
||||
LogSetParameter (XLOG_VERBOSITY, verbosity) ;
|
||||
EPHYR_LOG ("set verbosiry to %d\n", verbosity) ;
|
||||
return 2 ;
|
||||
}
|
||||
else
|
||||
{
|
||||
UseMsg() ;
|
||||
exit(1) ;
|
||||
}
|
||||
}
|
||||
#ifdef GLXEXT
|
||||
else if (!strcmp (argv[i], "-nodri"))
|
||||
{
|
||||
noGlxVisualInit = FALSE ;
|
||||
ephyrNoDRI = TRUE ;
|
||||
EPHYR_LOG ("no direct rendering enabled\n") ;
|
||||
return 1 ;
|
||||
}
|
||||
#endif
|
||||
else if (!strcmp (argv[i], "-noxv"))
|
||||
{
|
||||
ephyrNoXV = TRUE ;
|
||||
EPHYR_LOG ("no XVideo enabled\n") ;
|
||||
return 1 ;
|
||||
}
|
||||
else if (argv[i][0] == ':')
|
||||
{
|
||||
hostx_set_display_name(argv[i]);
|
||||
|
|
67
hw/kdrive/ephyr/ephyrlog.h
Normal file
67
hw/kdrive/ephyr/ephyrlog.h
Normal file
|
@ -0,0 +1,67 @@
|
|||
/*
|
||||
* Xephyr - A kdrive X server thats runs in a host X window.
|
||||
* Authored by Matthew Allum <mallum@openedhand.com>
|
||||
*
|
||||
* Copyright © 2007 OpenedHand Ltd
|
||||
*
|
||||
* Permission to use, copy, modify, distribute, and sell this software and its
|
||||
* documentation for any purpose is hereby granted without fee, provided that
|
||||
* the above copyright notice appear in all copies and that both that
|
||||
* copyright notice and this permission notice appear in supporting
|
||||
* documentation, and that the name of OpenedHand Ltd not be used in
|
||||
* advertising or publicity pertaining to distribution of the software without
|
||||
* specific, written prior permission. OpenedHand Ltd makes no
|
||||
* representations about the suitability of this software for any purpose. It
|
||||
* is provided "as is" without express or implied warranty.
|
||||
*
|
||||
* OpenedHand Ltd DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
||||
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
|
||||
* EVENT SHALL OpenedHand Ltd BE LIABLE FOR ANY SPECIAL, INDIRECT OR
|
||||
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
||||
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
||||
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
||||
* PERFORMANCE OF THIS SOFTWARE.
|
||||
*
|
||||
* Authors:
|
||||
* Dodji Seketeli <dodji@openedhand.com>
|
||||
*/
|
||||
#ifndef __EPHYRLOG_H__
|
||||
#define __EPHYRLOG_H__
|
||||
|
||||
#include <assert.h>
|
||||
#include "os.h"
|
||||
|
||||
#ifdef NDEBUG
|
||||
/*we are not in debug mode*/
|
||||
#define EPHYR_LOG
|
||||
#define EPHYR_LOG_ERROR
|
||||
#endif /*NDEBUG*/
|
||||
|
||||
#define ERROR_LOG_LEVEL 3
|
||||
#define INFO_LOG_LEVEL 4
|
||||
|
||||
#ifndef EPHYR_LOG
|
||||
#define EPHYR_LOG(...) \
|
||||
LogMessageVerb(X_NOTICE, INFO_LOG_LEVEL, "in %s:%d:%s: ",\
|
||||
__FILE__, __LINE__, __func__) ; \
|
||||
LogMessageVerb(X_NOTICE, INFO_LOG_LEVEL, __VA_ARGS__)
|
||||
#endif /*nomadik_log*/
|
||||
|
||||
#ifndef EPHYR_LOG_ERROR
|
||||
#define EPHYR_LOG_ERROR(...) \
|
||||
LogMessageVerb(X_NOTICE, ERROR_LOG_LEVEL, "Error:in %s:%d:%s: ",\
|
||||
__FILE__, __LINE__, __func__) ; \
|
||||
LogMessageVerb(X_NOTICE, ERROR_LOG_LEVEL, __VA_ARGS__)
|
||||
#endif /*EPHYR_LOG_ERROR*/
|
||||
|
||||
#ifndef EPHYR_RETURN_IF_FAIL
|
||||
#define EPHYR_RETURN_IF_FAIL(cond) \
|
||||
if (!(cond)) {EPHYR_LOG_ERROR("condition %s failed\n", #cond);return;}
|
||||
#endif /*nomadik_return_if_fail*/
|
||||
|
||||
#ifndef EPHYR_RETURN_VAL_IF_FAIL
|
||||
#define EPHYR_RETURN_VAL_IF_FAIL(cond,val) \
|
||||
if (!(cond)) {EPHYR_LOG_ERROR("condition %s failed\n", #cond);return val;}
|
||||
#endif /*nomadik_return_val_if_fail*/
|
||||
|
||||
#endif /*__EPHYRLOG_H__*/
|
119
hw/kdrive/ephyr/ephyrproxyext.c
Normal file
119
hw/kdrive/ephyr/ephyrproxyext.c
Normal file
|
@ -0,0 +1,119 @@
|
|||
/*
|
||||
* Xephyr - A kdrive X server thats runs in a host X window.
|
||||
* Authored by Matthew Allum <mallum@openedhand.com>
|
||||
*
|
||||
* Copyright © 2007 OpenedHand Ltd
|
||||
*
|
||||
* Permission to use, copy, modify, distribute, and sell this software and its
|
||||
* documentation for any purpose is hereby granted without fee, provided that
|
||||
* the above copyright notice appear in all copies and that both that
|
||||
* copyright notice and this permission notice appear in supporting
|
||||
* documentation, and that the name of OpenedHand Ltd not be used in
|
||||
* advertising or publicity pertaining to distribution of the software without
|
||||
* specific, written prior permission. OpenedHand Ltd makes no
|
||||
* representations about the suitability of this software for any purpose. It
|
||||
* is provided "as is" without express or implied warranty.
|
||||
*
|
||||
* OpenedHand Ltd DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
||||
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
|
||||
* EVENT SHALL OpenedHand Ltd BE LIABLE FOR ANY SPECIAL, INDIRECT OR
|
||||
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
||||
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
||||
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
||||
* PERFORMANCE OF THIS SOFTWARE.
|
||||
*
|
||||
* Authors:
|
||||
* Dodji Seketeli <dodji@openedhand.com>
|
||||
*/
|
||||
|
||||
/*
|
||||
* \file
|
||||
* This file defines a proxy extension that forwards requests.
|
||||
* When a request to extension FOO is sent to Xephyr, that request is forwared
|
||||
* to the host X, without even trying to know what the request means.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <kdrive-config.h>
|
||||
#endif
|
||||
|
||||
#include "misc.h"
|
||||
#include "dixstruct.h"
|
||||
#include "extnsionst.h"
|
||||
#include "ephyrproxyext.h"
|
||||
#define _HAVE_XALLOC_DECLS
|
||||
#include "ephyrlog.h"
|
||||
#include "ephyrhostproxy.h"
|
||||
#include "hostx.h"
|
||||
|
||||
static Bool ephyrProxyGetHostExtensionInfo (const char *a_ext_name,
|
||||
int *a_major_opcode,
|
||||
int *a_first_event,
|
||||
int *a_first_error) ;
|
||||
|
||||
static int ephyrProxyProcDispatch (ClientPtr client) ;
|
||||
|
||||
static Bool
|
||||
ephyrProxyGetHostExtensionInfo (const char *a_ext_name,
|
||||
int *a_major_opcode,
|
||||
int *a_first_event,
|
||||
int *a_first_error)
|
||||
{
|
||||
return hostx_get_extension_info (a_ext_name, a_major_opcode,
|
||||
a_first_event, a_first_error) ;
|
||||
}
|
||||
|
||||
static int
|
||||
ephyrProxyProcDispatch (ClientPtr a_client)
|
||||
{
|
||||
int res=BadImplementation ;
|
||||
struct XReply reply ;
|
||||
|
||||
if (!ephyrHostProxyDoForward (a_client->requestBuffer, &reply, FALSE)) {
|
||||
EPHYR_LOG_ERROR ("forwarding failed\n") ;
|
||||
goto out ;
|
||||
}
|
||||
reply.sequence_number = a_client->sequence;
|
||||
res = Success ;
|
||||
|
||||
WriteToClient(a_client, 32, (char *)&reply);
|
||||
|
||||
out:
|
||||
return res ;
|
||||
}
|
||||
|
||||
static void
|
||||
ephyrProxyProcReset (ExtensionEntry *a_entry)
|
||||
{
|
||||
}
|
||||
|
||||
Bool
|
||||
ephyrProxyExtensionInit (const char *a_extension_name)
|
||||
{
|
||||
Bool is_ok = FALSE ;
|
||||
int major_opcode=0, first_event=0, first_error=0;
|
||||
ExtensionEntry *ext=NULL ;
|
||||
|
||||
if (!ephyrProxyGetHostExtensionInfo (a_extension_name,
|
||||
&major_opcode,
|
||||
&first_event,
|
||||
&first_error)) {
|
||||
EPHYR_LOG ("failed to query extension %s from host\n", a_extension_name) ;
|
||||
goto out;
|
||||
}
|
||||
ext = AddExtension ((char*)a_extension_name, 0, 0,
|
||||
ephyrProxyProcDispatch,
|
||||
ephyrProxyProcDispatch,
|
||||
ephyrProxyProcReset,
|
||||
StandardMinorOpcode) ;
|
||||
if (!ext) {
|
||||
EPHYR_LOG_ERROR ("failed to add the extension\n") ;
|
||||
goto out ;
|
||||
}
|
||||
is_ok = TRUE ;
|
||||
|
||||
out:
|
||||
EPHYR_LOG ("leave\n") ;
|
||||
return is_ok ;
|
||||
}
|
||||
|
34
hw/kdrive/ephyr/ephyrproxyext.h
Normal file
34
hw/kdrive/ephyr/ephyrproxyext.h
Normal file
|
@ -0,0 +1,34 @@
|
|||
/*
|
||||
* Xephyr - A kdrive X server thats runs in a host X window.
|
||||
* Authored by Matthew Allum <mallum@openedhand.com>
|
||||
*
|
||||
* Copyright © 2007 OpenedHand Ltd
|
||||
*
|
||||
* Permission to use, copy, modify, distribute, and sell this software and its
|
||||
* documentation for any purpose is hereby granted without fee, provided that
|
||||
* the above copyright notice appear in all copies and that both that
|
||||
* copyright notice and this permission notice appear in supporting
|
||||
* documentation, and that the name of OpenedHand Ltd not be used in
|
||||
* advertising or publicity pertaining to distribution of the software without
|
||||
* specific, written prior permission. OpenedHand Ltd makes no
|
||||
* representations about the suitability of this software for any purpose. It
|
||||
* is provided "as is" without express or implied warranty.
|
||||
*
|
||||
* OpenedHand Ltd DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
||||
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
|
||||
* EVENT SHALL OpenedHand Ltd BE LIABLE FOR ANY SPECIAL, INDIRECT OR
|
||||
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
||||
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
||||
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
||||
* PERFORMANCE OF THIS SOFTWARE.
|
||||
*
|
||||
* Authors:
|
||||
* Dodji Seketeli <dodji@openedhand.com>
|
||||
*/
|
||||
#ifndef __EPHYRPROXYEXT_H__
|
||||
#define __EPHYRPROXYEXT_H__
|
||||
|
||||
Bool ephyrProxyExtensionInit (const char *a_extension_name) ;
|
||||
|
||||
#endif /*__EPHYRPROXYEXT_H__*/
|
||||
|
1278
hw/kdrive/ephyr/ephyrvideo.c
Normal file
1278
hw/kdrive/ephyr/ephyrvideo.c
Normal file
File diff suppressed because it is too large
Load Diff
|
@ -23,6 +23,10 @@
|
|||
* PERFORMANCE OF THIS SOFTWARE.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <kdrive-config.h>
|
||||
#endif
|
||||
|
||||
#include "hostx.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
|
@ -40,6 +44,17 @@
|
|||
#include <X11/Xatom.h>
|
||||
#include <X11/keysym.h>
|
||||
#include <X11/extensions/XShm.h>
|
||||
#include <X11/extensions/shape.h>
|
||||
#ifdef XEPHYR_DRI
|
||||
#include <GL/glx.h>
|
||||
#endif /*XEPHYR_DRI*/
|
||||
#include "ephyrlog.h"
|
||||
|
||||
#ifdef XEPHYR_DRI
|
||||
extern Bool XF86DRIQueryExtension (Display *dpy,
|
||||
int *event_basep,
|
||||
int *error_basep);
|
||||
#endif
|
||||
|
||||
/*
|
||||
* All xlib calls go here, which gets built as its own .a .
|
||||
|
@ -956,3 +971,385 @@ hostx_get_event(EphyrHostXEvent *ev)
|
|||
return 0;
|
||||
}
|
||||
|
||||
void*
|
||||
hostx_get_display(void)
|
||||
{
|
||||
return HostX.dpy ;
|
||||
}
|
||||
|
||||
int
|
||||
hostx_get_window (int a_screen_number)
|
||||
{
|
||||
if (a_screen_number < 0 || a_screen_number >= HostX.n_screens) {
|
||||
EPHYR_LOG_ERROR ("bad screen number:%d\n", a_screen_number) ;
|
||||
return 0;
|
||||
}
|
||||
return HostX.screens[a_screen_number].win ;
|
||||
}
|
||||
|
||||
int
|
||||
hostx_get_window_attributes (int a_window, EphyrHostWindowAttributes *a_attrs)
|
||||
{
|
||||
XWindowAttributes attrs ;
|
||||
|
||||
memset (&attrs, 0, sizeof (attrs)) ;
|
||||
|
||||
if (!XGetWindowAttributes (hostx_get_display (),
|
||||
a_window,
|
||||
&attrs)) {
|
||||
return FALSE ;
|
||||
}
|
||||
a_attrs->x = attrs.x ;
|
||||
a_attrs->y = attrs.y ;
|
||||
a_attrs->width = attrs.width ;
|
||||
a_attrs->height = attrs.height ;
|
||||
if (attrs.visual)
|
||||
a_attrs->visualid = attrs.visual->visualid ;
|
||||
return TRUE ;
|
||||
}
|
||||
|
||||
int
|
||||
hostx_get_extension_info (const char *a_ext_name,
|
||||
int *a_major_opcode,
|
||||
int *a_first_event,
|
||||
int *a_first_error)
|
||||
{
|
||||
if (!a_ext_name || !a_major_opcode || !a_first_event || !a_first_error)
|
||||
return 0 ;
|
||||
if (!XQueryExtension (HostX.dpy,
|
||||
a_ext_name,
|
||||
a_major_opcode,
|
||||
a_first_event,
|
||||
a_first_error))
|
||||
{
|
||||
return 0 ;
|
||||
}
|
||||
return 1 ;
|
||||
}
|
||||
|
||||
int
|
||||
hostx_get_visuals_info (EphyrHostVisualInfo **a_visuals,
|
||||
int *a_num_entries)
|
||||
{
|
||||
Display *dpy=hostx_get_display () ;
|
||||
Bool is_ok=False ;
|
||||
XVisualInfo templ, *visuals=NULL;
|
||||
EphyrHostVisualInfo *host_visuals=NULL ;
|
||||
int nb_items=0, i=0;
|
||||
|
||||
EPHYR_RETURN_VAL_IF_FAIL (a_visuals && a_num_entries && dpy,
|
||||
False) ;
|
||||
EPHYR_LOG ("enter\n") ;
|
||||
memset (&templ, 0, sizeof (templ)) ;
|
||||
visuals = XGetVisualInfo (dpy, VisualNoMask, &templ, &nb_items) ;
|
||||
if (!visuals) {
|
||||
EPHYR_LOG_ERROR ("host does not advertise any visual\n") ;
|
||||
goto out ;
|
||||
}
|
||||
EPHYR_LOG ("host advertises %d visuals\n", nb_items) ;
|
||||
host_visuals = calloc (nb_items, sizeof (EphyrHostVisualInfo)) ;
|
||||
for (i=0; i<nb_items; i++) {
|
||||
host_visuals[i].visualid = visuals[i].visualid ;
|
||||
host_visuals[i].screen = visuals[i].screen ;
|
||||
host_visuals[i].depth = visuals[i].depth ;
|
||||
host_visuals[i].class = visuals[i].class ;
|
||||
host_visuals[i].red_mask = visuals[i].red_mask ;
|
||||
host_visuals[i].green_mask = visuals[i].green_mask ;
|
||||
host_visuals[i].blue_mask = visuals[i].blue_mask ;
|
||||
host_visuals[i].colormap_size = visuals[i].colormap_size ;
|
||||
host_visuals[i].bits_per_rgb = visuals[i].bits_per_rgb ;
|
||||
}
|
||||
*a_visuals = host_visuals ;
|
||||
*a_num_entries = nb_items;
|
||||
host_visuals=NULL;
|
||||
|
||||
is_ok = TRUE;
|
||||
out:
|
||||
if (visuals) {
|
||||
XFree (visuals) ;
|
||||
visuals = NULL;
|
||||
}
|
||||
if (host_visuals) {
|
||||
free (host_visuals) ;
|
||||
host_visuals = NULL;
|
||||
}
|
||||
EPHYR_LOG ("leave\n") ;
|
||||
return is_ok ;
|
||||
|
||||
}
|
||||
|
||||
typedef struct {
|
||||
int is_valid ;
|
||||
int local_id ;
|
||||
int remote_id ;
|
||||
} ResourcePair ;
|
||||
|
||||
#define RESOURCE_PEERS_SIZE 1024*10
|
||||
static ResourcePair resource_peers[RESOURCE_PEERS_SIZE] ;
|
||||
|
||||
|
||||
int
|
||||
hostx_create_window (int a_screen_number,
|
||||
EphyrBox *a_geometry,
|
||||
int a_visual_id,
|
||||
int *a_host_peer /*out parameter*/)
|
||||
{
|
||||
Bool is_ok=FALSE ;
|
||||
Display *dpy=hostx_get_display () ;
|
||||
XVisualInfo *visual_info=NULL, visual_info_templ;
|
||||
int visual_mask=VisualIDMask ;
|
||||
Window win=None ;
|
||||
int nb_visuals=0, winmask=0;
|
||||
XSetWindowAttributes attrs;
|
||||
|
||||
EPHYR_RETURN_VAL_IF_FAIL (dpy && a_geometry, FALSE) ;
|
||||
|
||||
EPHYR_LOG ("enter\n") ;
|
||||
|
||||
/*get visual*/
|
||||
memset (&visual_info, 0, sizeof (visual_info)) ;
|
||||
visual_info_templ.visualid = a_visual_id ;
|
||||
visual_info = XGetVisualInfo (dpy, visual_mask,
|
||||
&visual_info_templ,
|
||||
&nb_visuals) ;
|
||||
if (!visual_info) {
|
||||
EPHYR_LOG_ERROR ("argh, could not find a remote visual with id:%d\n",
|
||||
a_visual_id) ;
|
||||
goto out ;
|
||||
}
|
||||
memset (&attrs, 0, sizeof (attrs)) ;
|
||||
attrs.colormap = XCreateColormap (dpy,
|
||||
RootWindow (dpy,
|
||||
visual_info->screen),
|
||||
visual_info->visual,
|
||||
AllocNone) ;
|
||||
winmask = CWColormap;
|
||||
|
||||
win = XCreateWindow (dpy, hostx_get_window (a_screen_number),
|
||||
a_geometry->x, a_geometry->y,
|
||||
a_geometry->width, a_geometry->height, 0,
|
||||
visual_info->depth, InputOutput,
|
||||
visual_info->visual, winmask, &attrs) ;
|
||||
if (win == None) {
|
||||
EPHYR_LOG_ERROR ("failed to create peer window\n") ;
|
||||
goto out ;
|
||||
}
|
||||
XFlush (dpy) ;
|
||||
XMapWindow (dpy, win) ;
|
||||
*a_host_peer = win ;
|
||||
is_ok = TRUE ;
|
||||
out:
|
||||
EPHYR_LOG ("leave\n") ;
|
||||
return is_ok ;
|
||||
}
|
||||
|
||||
int
|
||||
hostx_destroy_window (int a_win)
|
||||
{
|
||||
Display *dpy=hostx_get_display () ;
|
||||
|
||||
EPHYR_RETURN_VAL_IF_FAIL (dpy, FALSE) ;
|
||||
XDestroyWindow (dpy, a_win) ;
|
||||
XFlush (dpy) ;
|
||||
return TRUE ;
|
||||
}
|
||||
|
||||
int
|
||||
hostx_set_window_geometry (int a_win, EphyrBox *a_geo)
|
||||
{
|
||||
Display *dpy=hostx_get_display ();
|
||||
|
||||
EPHYR_RETURN_VAL_IF_FAIL (dpy && a_geo, FALSE) ;
|
||||
|
||||
EPHYR_LOG ("enter. x,y,w,h:(%d,%d,%d,%d)\n",
|
||||
a_geo->x, a_geo->y,
|
||||
a_geo->width, a_geo->height) ;
|
||||
|
||||
XMoveWindow (dpy, a_win, a_geo->x, a_geo->y) ;
|
||||
XResizeWindow (dpy, a_win, a_geo->width, a_geo->height) ;
|
||||
EPHYR_LOG ("leave\n") ;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
int
|
||||
hostx_set_window_bounding_rectangles (int a_window,
|
||||
EphyrRect *a_rects,
|
||||
int a_num_rects)
|
||||
{
|
||||
Bool is_ok=FALSE;
|
||||
Display *dpy=hostx_get_display () ;
|
||||
int i=0 ;
|
||||
XRectangle *rects=NULL ;
|
||||
|
||||
EPHYR_RETURN_VAL_IF_FAIL (dpy && a_rects, FALSE) ;
|
||||
|
||||
EPHYR_LOG ("enter. num rects:%d\n", a_num_rects) ;
|
||||
|
||||
rects = calloc (a_num_rects, sizeof (XRectangle)) ;
|
||||
for (i=0; i<a_num_rects; i++) {
|
||||
rects[i].x = a_rects[i].x1 ;
|
||||
rects[i].y = a_rects[i].y1 ;
|
||||
rects[i].width = abs (a_rects[i].x2 - a_rects[i].x1);
|
||||
rects[i].height = abs (a_rects[i].y2 - a_rects[i].y1) ;
|
||||
EPHYR_LOG ("borders clipped to rect[x:%d,y:%d,w:%d,h:%d]\n",
|
||||
rects[i].x, rects[i].y,
|
||||
rects[i].width, rects[i].height) ;
|
||||
}
|
||||
/*this aways returns 1*/
|
||||
XShapeCombineRectangles (dpy, a_window, ShapeBounding, 0, 0,
|
||||
rects, a_num_rects, ShapeSet, YXBanded) ;
|
||||
is_ok = TRUE ;
|
||||
|
||||
if (rects) {
|
||||
free (rects) ;
|
||||
rects = NULL ;
|
||||
}
|
||||
EPHYR_LOG ("leave\n") ;
|
||||
return is_ok;
|
||||
}
|
||||
|
||||
int
|
||||
hostx_set_window_clipping_rectangles (int a_window,
|
||||
EphyrRect *a_rects,
|
||||
int a_num_rects)
|
||||
{
|
||||
Bool is_ok=FALSE;
|
||||
Display *dpy=hostx_get_display () ;
|
||||
int i=0 ;
|
||||
XRectangle *rects=NULL ;
|
||||
|
||||
EPHYR_RETURN_VAL_IF_FAIL (dpy && a_rects, FALSE) ;
|
||||
|
||||
EPHYR_LOG ("enter. num rects:%d\n", a_num_rects) ;
|
||||
|
||||
rects = calloc (a_num_rects, sizeof (XRectangle)) ;
|
||||
for (i=0; i<a_num_rects; i++) {
|
||||
rects[i].x = a_rects[i].x1 ;
|
||||
rects[i].y = a_rects[i].y1 ;
|
||||
rects[i].width = abs (a_rects[i].x2 - a_rects[i].x1);
|
||||
rects[i].height = abs (a_rects[i].y2 - a_rects[i].y1) ;
|
||||
EPHYR_LOG ("clipped to rect[x:%d,y:%d,w:%d,h:%d]\n",
|
||||
rects[i].x, rects[i].y,
|
||||
rects[i].width, rects[i].height) ;
|
||||
}
|
||||
/*this aways returns 1*/
|
||||
XShapeCombineRectangles (dpy, a_window, ShapeClip, 0, 0,
|
||||
rects, a_num_rects, ShapeSet, YXBanded) ;
|
||||
is_ok = TRUE ;
|
||||
|
||||
if (rects) {
|
||||
free (rects) ;
|
||||
rects = NULL ;
|
||||
}
|
||||
EPHYR_LOG ("leave\n") ;
|
||||
return is_ok;
|
||||
}
|
||||
|
||||
int
|
||||
hostx_has_xshape (void)
|
||||
{
|
||||
int event_base=0, error_base=0 ;
|
||||
Display *dpy=hostx_get_display () ;
|
||||
if (!XShapeQueryExtension (dpy,
|
||||
&event_base,
|
||||
&error_base)) {
|
||||
return FALSE ;
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
#ifdef XEPHYR_DRI
|
||||
int
|
||||
hostx_allocate_resource_id_peer (int a_local_resource_id,
|
||||
int *a_remote_resource_id)
|
||||
{
|
||||
int i=0 ;
|
||||
ResourcePair *peer=NULL ;
|
||||
Display *dpy=hostx_get_display ();
|
||||
|
||||
/*
|
||||
* first make sure a resource peer
|
||||
* does not exist already for
|
||||
* a_local_resource_id
|
||||
*/
|
||||
for (i=0; i<RESOURCE_PEERS_SIZE; i++) {
|
||||
if (resource_peers[i].is_valid
|
||||
&& resource_peers[i].local_id == a_local_resource_id) {
|
||||
peer = &resource_peers[i] ;
|
||||
break ;
|
||||
}
|
||||
}
|
||||
/*
|
||||
* find one free peer entry, an feed it with
|
||||
*/
|
||||
if (!peer) {
|
||||
for (i=0; i<RESOURCE_PEERS_SIZE; i++) {
|
||||
if (!resource_peers[i].is_valid) {
|
||||
peer = &resource_peers[i] ;
|
||||
break ;
|
||||
}
|
||||
}
|
||||
if (peer) {
|
||||
peer->remote_id = XAllocID (dpy);
|
||||
peer->local_id = a_local_resource_id ;
|
||||
peer->is_valid = TRUE ;
|
||||
}
|
||||
}
|
||||
if (peer) {
|
||||
*a_remote_resource_id = peer->remote_id ;
|
||||
return TRUE ;
|
||||
}
|
||||
return FALSE ;
|
||||
}
|
||||
|
||||
int
|
||||
hostx_get_resource_id_peer (int a_local_resource_id,
|
||||
int *a_remote_resource_id)
|
||||
{
|
||||
int i=0 ;
|
||||
ResourcePair *peer=NULL ;
|
||||
for (i=0; i<RESOURCE_PEERS_SIZE; i++) {
|
||||
if (resource_peers[i].is_valid
|
||||
&& resource_peers[i].local_id == a_local_resource_id) {
|
||||
peer = &resource_peers[i] ;
|
||||
break ;
|
||||
}
|
||||
}
|
||||
if (peer) {
|
||||
*a_remote_resource_id = peer->remote_id ;
|
||||
return TRUE ;
|
||||
}
|
||||
return FALSE ;
|
||||
}
|
||||
|
||||
int
|
||||
hostx_has_dri (void)
|
||||
{
|
||||
int event_base=0, error_base=0 ;
|
||||
Display *dpy=hostx_get_display () ;
|
||||
|
||||
if (!dpy)
|
||||
return FALSE ;
|
||||
|
||||
if (!XF86DRIQueryExtension (dpy,
|
||||
&event_base,
|
||||
&error_base)) {
|
||||
return FALSE ;
|
||||
}
|
||||
return TRUE ;
|
||||
}
|
||||
|
||||
int
|
||||
hostx_has_glx (void)
|
||||
{
|
||||
Display *dpy=hostx_get_display () ;
|
||||
int event_base=0, error_base=0 ;
|
||||
|
||||
if (!glXQueryExtension (dpy, &event_base, &error_base)) {
|
||||
return FALSE ;
|
||||
}
|
||||
return TRUE ;
|
||||
}
|
||||
|
||||
#endif /*XEPHYR_DRI*/
|
||||
|
||||
|
|
|
@ -92,6 +92,32 @@ struct EphyrHostXEvent
|
|||
int key_state;
|
||||
};
|
||||
|
||||
typedef struct {
|
||||
VisualID visualid;
|
||||
int screen;
|
||||
int depth;
|
||||
int class;
|
||||
unsigned long red_mask;
|
||||
unsigned long green_mask;
|
||||
unsigned long blue_mask;
|
||||
int colormap_size;
|
||||
int bits_per_rgb;
|
||||
} EphyrHostVisualInfo;
|
||||
|
||||
typedef struct {
|
||||
int x, y;
|
||||
int width, height ;
|
||||
int visualid ;
|
||||
} EphyrHostWindowAttributes;
|
||||
|
||||
typedef struct {
|
||||
int x,y,width,height;
|
||||
} EphyrBox;
|
||||
|
||||
typedef struct {
|
||||
short x1,y1,x2,y2;
|
||||
} EphyrRect;
|
||||
|
||||
int
|
||||
hostx_want_screen_size(EphyrScreenInfo screen, int *width, int *height);
|
||||
|
||||
|
@ -167,9 +193,60 @@ hostx_paint_rect(EphyrScreenInfo screen,
|
|||
|
||||
|
||||
void
|
||||
hostx_load_keymap(void);
|
||||
hostx_load_keymap (void);
|
||||
|
||||
int
|
||||
hostx_get_event(EphyrHostXEvent *ev);
|
||||
hostx_get_event (EphyrHostXEvent *ev);
|
||||
|
||||
#endif
|
||||
void*
|
||||
hostx_get_display (void) ;
|
||||
|
||||
int
|
||||
hostx_get_window (int a_screen_number) ;
|
||||
|
||||
int
|
||||
hostx_get_window_attributes (int a_window, EphyrHostWindowAttributes *a_attr) ;
|
||||
|
||||
int
|
||||
hostx_get_extension_info (const char *a_ext_name,
|
||||
int *a_major_opcode,
|
||||
int *a_first_even,
|
||||
int *a_first_error) ;
|
||||
int
|
||||
hostx_get_visuals_info (EphyrHostVisualInfo **a_visuals,
|
||||
int *a_num_entries) ;
|
||||
|
||||
int hostx_create_window (int a_screen_number,
|
||||
EphyrBox *a_geometry,
|
||||
int a_visual_id,
|
||||
int *a_host_win /*out parameter*/) ;
|
||||
|
||||
int hostx_destroy_window (int a_win) ;
|
||||
|
||||
int hostx_set_window_geometry (int a_win, EphyrBox *a_geo) ;
|
||||
|
||||
|
||||
int hostx_set_window_bounding_rectangles (int a_window,
|
||||
EphyrRect *a_rects,
|
||||
int a_num_rects) ;
|
||||
|
||||
int hostx_set_window_clipping_rectangles (int a_window,
|
||||
EphyrRect *a_rects,
|
||||
int a_num_rects) ;
|
||||
int hostx_has_xshape (void) ;
|
||||
|
||||
#ifdef XEPHYR_DRI
|
||||
int hostx_lookup_peer_window (void *a_local_window,
|
||||
int *a_host_peer /*out parameter*/) ;
|
||||
int
|
||||
hostx_allocate_resource_id_peer (int a_local_resource_id,
|
||||
int *a_remote_resource_id) ;
|
||||
int
|
||||
hostx_get_resource_id_peer (int a_local_resource_id,
|
||||
int *a_remote_resource_id) ;
|
||||
int hostx_has_dri (void) ;
|
||||
|
||||
int hostx_has_glx (void) ;
|
||||
#endif /*XEPHYR_DRI*/
|
||||
|
||||
#endif /*_XLIBS_STUFF_H_*/
|
||||
|
|
|
@ -28,6 +28,8 @@
|
|||
#endif
|
||||
#include "ephyr.h"
|
||||
|
||||
extern void processScreenArg (char *screen_size, char *parent_id) ;
|
||||
|
||||
static int
|
||||
EphyrInit (void)
|
||||
{
|
||||
|
|
|
@ -20,7 +20,7 @@ Xfbdev_LDADD = \
|
|||
|
||||
Xfbdev_DEPENDENCIES = \
|
||||
libfbdev.a \
|
||||
@KDRIVE_LOCAL_LIBS@
|
||||
$(KDRIVE_PURE_LIBS)
|
||||
|
||||
relink:
|
||||
rm -f $(bin_PROGRAMS) && make $(bin_PROGRAMS)
|
||||
|
|
|
@ -37,4 +37,4 @@ libkdrive_a_SOURCES = \
|
|||
$(top_srcdir)/mi/miinitext.c
|
||||
|
||||
libkdrivestubs_a_SOURCES = \
|
||||
$(top_srcdir)/fb/fbcmap.c
|
||||
$(top_srcdir)/fb/fbcmap_mi.c
|
||||
|
|
|
@ -39,6 +39,7 @@
|
|||
#include "xf86Config.h"
|
||||
#include "xf86Priv.h"
|
||||
#include "xf86_OSlib.h"
|
||||
#include "dirent.h"
|
||||
|
||||
/* Sections for the default built-in configuration. */
|
||||
|
||||
|
@ -174,7 +175,7 @@ videoPtrToDriverName(struct pci_device *dev)
|
|||
case 0x8086:
|
||||
if ((dev->device_id == 0x00d1) || (dev->device_id == 0x7800))
|
||||
return "i740";
|
||||
else return "i810";
|
||||
else return "intel";
|
||||
case 0x102b: return "mga";
|
||||
case 0x10c8: return "neomagic";
|
||||
case 0x105d: return "i128";
|
||||
|
@ -214,27 +215,10 @@ xf86AutoConfig(void)
|
|||
{
|
||||
const char **p;
|
||||
char buf[1024];
|
||||
struct pci_device_iterator *iter;
|
||||
struct pci_device * info = NULL;
|
||||
const char *driver = NULL;
|
||||
ConfigStatus ret;
|
||||
|
||||
/* Find the primary device, and get some information about it. */
|
||||
iter = pci_slot_match_iterator_create(NULL);
|
||||
while ((info = pci_device_next(iter)) != NULL) {
|
||||
if (xf86IsPrimaryPci(info)) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
pci_iterator_destroy(iter);
|
||||
|
||||
if (!info) {
|
||||
ErrorF("Primary device is not PCI\n");
|
||||
}
|
||||
|
||||
if (info)
|
||||
driver = videoPtrToDriverName(info);
|
||||
driver = chooseVideoDriver();
|
||||
|
||||
AppendToConfig(BUILTIN_MODULE_SECTION);
|
||||
AppendToConfig(BUILTIN_MONITOR_SECTION);
|
||||
|
@ -287,3 +271,217 @@ xf86AutoConfig(void)
|
|||
|
||||
return (ret == CONFIG_OK);
|
||||
}
|
||||
|
||||
int
|
||||
xchomp(char *line)
|
||||
{
|
||||
size_t len = 0;
|
||||
|
||||
if (!line) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
len = strlen(line);
|
||||
if (line[len - 1] == '\n' && len > 0) {
|
||||
line[len - 1] = '\0';
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
GDevPtr
|
||||
autoConfigDevice(GDevPtr preconf_device)
|
||||
{
|
||||
GDevPtr ptr = NULL;
|
||||
|
||||
if (!xf86configptr) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* If there's a configured section with no driver chosen, use it */
|
||||
if (preconf_device) {
|
||||
ptr = preconf_device;
|
||||
} else {
|
||||
ptr = (GDevPtr)xalloc(sizeof(GDevRec));
|
||||
if (!ptr) {
|
||||
return NULL;
|
||||
}
|
||||
memset((GDevPtr)ptr, 0, sizeof(GDevRec));
|
||||
ptr->chipID = -1;
|
||||
ptr->chipRev = -1;
|
||||
ptr->irq = -1;
|
||||
|
||||
ptr->active = TRUE;
|
||||
ptr->claimed = FALSE;
|
||||
ptr->identifier = "Autoconfigured Video Device";
|
||||
ptr->driver = NULL;
|
||||
}
|
||||
if (!ptr->driver) {
|
||||
ptr->driver = chooseVideoDriver();
|
||||
}
|
||||
|
||||
/* TODO Handle multiple screen sections */
|
||||
if (xf86ConfigLayout.screens && !xf86ConfigLayout.screens->screen->device) {
|
||||
xf86ConfigLayout.screens->screen->device = ptr;
|
||||
ptr->myScreenSection = xf86ConfigLayout.screens->screen;
|
||||
}
|
||||
xf86Msg(X_DEFAULT, "Assigned the driver to the xf86ConfigLayout\n");
|
||||
|
||||
return ptr;
|
||||
}
|
||||
|
||||
#ifdef __linux__
|
||||
static void
|
||||
matchDriverFromFiles (char** matches, uint16_t match_vendor, uint16_t match_chip)
|
||||
{
|
||||
DIR *idsdir;
|
||||
FILE *fp;
|
||||
struct dirent *direntry;
|
||||
char *line = NULL;
|
||||
size_t len;
|
||||
ssize_t read;
|
||||
char path_name[256], vendor_str[5], chip_str[5];
|
||||
uint16_t vendor, chip;
|
||||
int i, j;
|
||||
idsdir = opendir("/usr/share/xserver-xorg/pci");
|
||||
|
||||
if (idsdir) {
|
||||
direntry = readdir(idsdir);
|
||||
/* Read the directory */
|
||||
while (direntry) {
|
||||
if (direntry->d_name[0] == '.') {
|
||||
direntry = readdir(idsdir);
|
||||
continue;
|
||||
}
|
||||
len = strlen(direntry->d_name);
|
||||
/* A tiny bit of sanity checking. We should probably do better */
|
||||
if (strncmp(&(direntry->d_name[len-4]), ".ids", 4) == 0) {
|
||||
/* We need the full path name to open the file */
|
||||
strncpy(path_name, "/usr/share/xserver-xorg/pci/", 256);
|
||||
strncat(path_name, direntry->d_name, (256 - strlen(path_name)));
|
||||
fp = fopen(path_name, "r");
|
||||
if (fp == NULL) {
|
||||
xf86Msg(X_ERROR, "Could not open %s for reading. Exiting.\n", path_name);
|
||||
goto end;
|
||||
}
|
||||
/* Read the file */
|
||||
while ((read = getline(&line, &len, fp)) != -1) {
|
||||
xchomp(line);
|
||||
if (isdigit(line[0])) {
|
||||
strncpy(vendor_str, line, 4);
|
||||
vendor_str[4] = '\0';
|
||||
vendor = (int)strtol(vendor_str, NULL, 16);
|
||||
if ((strlen(&line[4])) == 0) {
|
||||
chip_str[0] = '\0';
|
||||
chip = -1;
|
||||
} else {
|
||||
/* Handle trailing whitespace */
|
||||
if (isspace(line[4])) {
|
||||
chip_str[0] = '\0';
|
||||
chip = -1;
|
||||
} else {
|
||||
/* Ok, it's a real ID */
|
||||
strncpy(chip_str, &line[4], 4);
|
||||
chip_str[4] = '\0';
|
||||
chip = (int)strtol(chip_str, NULL, 16);
|
||||
}
|
||||
}
|
||||
if (vendor == match_vendor && chip == match_chip ) {
|
||||
i = 0;
|
||||
while (matches[i]) {
|
||||
i++;
|
||||
}
|
||||
matches[i] = (char*)xalloc(sizeof(char) * strlen(direntry->d_name) - 3);
|
||||
if (!matches[i]) {
|
||||
xf86Msg(X_ERROR, "Could not allocate space for the module name. Exiting.\n");
|
||||
goto end;
|
||||
}
|
||||
/* hack off the .ids suffix. This should guard
|
||||
* against other problems, but it will end up
|
||||
* taking off anything after the first '.' */
|
||||
for (j = 0; j < (strlen(direntry->d_name) - 3) ; j++) {
|
||||
if (direntry->d_name[j] == '.') {
|
||||
matches[i][j] = '\0';
|
||||
break;
|
||||
} else {
|
||||
matches[i][j] = direntry->d_name[j];
|
||||
}
|
||||
}
|
||||
xf86Msg(X_INFO, "Matched %s from file name %s in autoconfig\n", matches[i], direntry->d_name);
|
||||
|
||||
}
|
||||
} else {
|
||||
/* TODO Handle driver overrides here */
|
||||
}
|
||||
}
|
||||
fclose(fp);
|
||||
}
|
||||
direntry = readdir(idsdir);
|
||||
}
|
||||
}
|
||||
end:
|
||||
xfree(line);
|
||||
closedir(idsdir);
|
||||
}
|
||||
#endif /* __linux__ */
|
||||
|
||||
char*
|
||||
chooseVideoDriver(void)
|
||||
{
|
||||
struct pci_device * info = NULL;
|
||||
struct pci_device_iterator *iter;
|
||||
char *chosen_driver = NULL;
|
||||
int i;
|
||||
char *matches[20]; /* If we have more than 20 drivers we're in trouble */
|
||||
|
||||
for (i=0 ; i<20 ; i++)
|
||||
matches[i] = NULL;
|
||||
|
||||
/* Find the primary device, and get some information about it. */
|
||||
iter = pci_slot_match_iterator_create(NULL);
|
||||
while ((info = pci_device_next(iter)) != NULL) {
|
||||
if (xf86IsPrimaryPci(info)) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
pci_iterator_destroy(iter);
|
||||
|
||||
if (!info) {
|
||||
ErrorF("Primary device is not PCI\n");
|
||||
}
|
||||
|
||||
#ifdef __linux__
|
||||
matchDriverFromFiles(matches, info->vendor_id, info->device_id);
|
||||
#endif /* __linux__ */
|
||||
|
||||
/* TODO Handle multiple drivers claiming to support the same PCI ID */
|
||||
if (matches[0]) {
|
||||
chosen_driver = matches[0];
|
||||
} else {
|
||||
if (info != NULL)
|
||||
chosen_driver = videoPtrToDriverName(info);
|
||||
if (chosen_driver == NULL) {
|
||||
#if defined __i386__ || defined __amd64__ || defined __hurd__
|
||||
chosen_driver = "vesa";
|
||||
#elif defined __alpha__
|
||||
chosen_driver = "vga";
|
||||
#elif defined __sparc__
|
||||
chosen_driver = "sunffb";
|
||||
#else
|
||||
chosen_driver = "fbdev";
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
xf86Msg(X_DEFAULT, "Matched %s for the autoconfigured driver\n", chosen_driver);
|
||||
|
||||
i = 0;
|
||||
while (matches[i]) {
|
||||
if (matches[i] != chosen_driver) {
|
||||
xfree(matches[i]);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
|
||||
return chosen_driver;
|
||||
}
|
||||
|
|
|
@ -77,7 +77,7 @@ extern DeviceAssocRec mouse_assoc;
|
|||
#include "picture.h"
|
||||
#endif
|
||||
|
||||
#if (defined(i386) || defined(__i386__)) && \
|
||||
#if (defined(__i386__)) && \
|
||||
(defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || \
|
||||
defined(__NetBSD__) || defined(linux) || \
|
||||
(defined(SVR4) && !defined(sun)) || defined(__GNU__))
|
||||
|
@ -792,6 +792,7 @@ typedef enum {
|
|||
FLAG_USE_DEFAULT_FONT_PATH,
|
||||
FLAG_AUTO_ADD_DEVICES,
|
||||
FLAG_AUTO_ENABLE_DEVICES,
|
||||
FLAG_GLX_VISUALS,
|
||||
} FlagValues;
|
||||
|
||||
static OptionInfoRec FlagOptions[] = {
|
||||
|
@ -873,11 +874,13 @@ static OptionInfoRec FlagOptions[] = {
|
|||
{0}, TRUE },
|
||||
{ FLAG_AUTO_ENABLE_DEVICES, "AutoEnableDevices", OPTV_BOOLEAN,
|
||||
{0}, TRUE },
|
||||
{ FLAG_GLX_VISUALS, "GlxVisuals", OPTV_STRING,
|
||||
{0}, FALSE },
|
||||
{ -1, NULL, OPTV_NONE,
|
||||
{0}, FALSE },
|
||||
};
|
||||
|
||||
#if defined(i386) || defined(__i386__)
|
||||
#ifdef __i386__
|
||||
static Bool
|
||||
detectPC98(void)
|
||||
{
|
||||
|
@ -904,6 +907,7 @@ configServerFlags(XF86ConfFlagsPtr flagsconf, XF86OptionPtr layoutopts)
|
|||
Pix24Flags pix24 = Pix24DontCare;
|
||||
Bool value;
|
||||
MessageType from;
|
||||
const char *s;
|
||||
|
||||
/*
|
||||
* Merge the ServerLayout and ServerFlags options. The former have
|
||||
|
@ -1021,7 +1025,6 @@ configServerFlags(XF86ConfFlagsPtr flagsconf, XF86OptionPtr layoutopts)
|
|||
if (xf86GetOptValBool(FlagOptions, FLAG_NOPM, &value))
|
||||
xf86Info.pmFlag = !value;
|
||||
{
|
||||
const char *s;
|
||||
if ((s = xf86GetOptValString(FlagOptions, FLAG_LOG))) {
|
||||
if (!xf86NameCmp(s,"flush")) {
|
||||
xf86Msg(X_CONFIG, "Flushing logfile enabled\n");
|
||||
|
@ -1040,8 +1043,6 @@ configServerFlags(XF86ConfFlagsPtr flagsconf, XF86OptionPtr layoutopts)
|
|||
|
||||
#ifdef RENDER
|
||||
{
|
||||
const char *s;
|
||||
|
||||
if ((s = xf86GetOptValString(FlagOptions, FLAG_RENDER_COLORMAP_MODE))){
|
||||
int policy = PictureParseCmapPolicy (s);
|
||||
if (policy == PictureCmapPolicyInvalid)
|
||||
|
@ -1055,7 +1056,6 @@ configServerFlags(XF86ConfFlagsPtr flagsconf, XF86OptionPtr layoutopts)
|
|||
}
|
||||
#endif
|
||||
{
|
||||
const char *s;
|
||||
if ((s = xf86GetOptValString(FlagOptions, FLAG_HANDLE_SPECIAL_KEYS))) {
|
||||
if (!xf86NameCmp(s,"always")) {
|
||||
xf86Msg(X_CONFIG, "Always handling special keys in DDX\n");
|
||||
|
@ -1093,6 +1093,27 @@ configServerFlags(XF86ConfFlagsPtr flagsconf, XF86OptionPtr layoutopts)
|
|||
xf86Info.aiglxFrom = X_CONFIG;
|
||||
}
|
||||
|
||||
#ifdef GLXEXT
|
||||
xf86Info.glxVisuals = XF86_GlxVisualsAll;
|
||||
xf86Info.glxVisualsFrom = X_DEFAULT;
|
||||
if ((s = xf86GetOptValString(FlagOptions, FLAG_GLX_VISUALS))) {
|
||||
if (!xf86NameCmp(s, "minimal")) {
|
||||
xf86Info.glxVisuals = XF86_GlxVisualsMinimal;
|
||||
} else if (!xf86NameCmp(s, "typical")) {
|
||||
xf86Info.glxVisuals = XF86_GlxVisualsTypical;
|
||||
} else if (!xf86NameCmp(s, "all")) {
|
||||
xf86Info.glxVisuals = XF86_GlxVisualsAll;
|
||||
} else {
|
||||
xf86Msg(X_WARNING,"Unknown HandleSpecialKeys option\n");
|
||||
}
|
||||
}
|
||||
|
||||
if (xf86GetOptValBool(FlagOptions, FLAG_AIGLX, &value)) {
|
||||
xf86Info.aiglx = value;
|
||||
xf86Info.aiglxFrom = X_CONFIG;
|
||||
}
|
||||
#endif
|
||||
|
||||
xf86Info.allowEmptyInput = FALSE;
|
||||
if (xf86GetOptValBool(FlagOptions, FLAG_ALLOW_EMPTY_INPUT, &value))
|
||||
xf86Info.allowEmptyInput = TRUE;
|
||||
|
@ -1164,7 +1185,7 @@ configServerFlags(XF86ConfFlagsPtr flagsconf, XF86OptionPtr layoutopts)
|
|||
xf86Info.pixmap24 = Pix24DontCare;
|
||||
xf86Info.pix24From = X_DEFAULT;
|
||||
}
|
||||
#if defined(i386) || defined(__i386__)
|
||||
#ifdef __i386__
|
||||
if (xf86GetOptValBool(FlagOptions, FLAG_PC98, &value)) {
|
||||
xf86Info.pc98 = value;
|
||||
if (value) {
|
||||
|
@ -1813,11 +1834,6 @@ configImpliedLayout(serverLayoutPtr servlayoutp, XF86ConfScreenPtr conf_screen)
|
|||
if (!servlayoutp)
|
||||
return FALSE;
|
||||
|
||||
if (conf_screen == NULL) {
|
||||
xf86ConfigError("No Screen sections present\n");
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/*
|
||||
* which screen section is the active one?
|
||||
*
|
||||
|
@ -1905,6 +1921,12 @@ configScreen(confScreenPtr screenp, XF86ConfScreenPtr conf_screen, int scrnum,
|
|||
XF86ConfAdaptorLinkPtr conf_adaptor;
|
||||
Bool defaultMonitor = FALSE;
|
||||
|
||||
if (!conf_screen) {
|
||||
conf_screen = xnfcalloc(1, sizeof(XF86ConfScreenRec));
|
||||
conf_screen->scrn_identifier = "Default Screen Section";
|
||||
xf86Msg(X_DEFAULT, "No screen section available. Using defaults.\n");
|
||||
}
|
||||
|
||||
xf86Msg(from, "|-->Screen \"%s\" (%d)\n", conf_screen->scrn_identifier,
|
||||
scrnum);
|
||||
/*
|
||||
|
@ -1939,9 +1961,20 @@ configScreen(confScreenPtr screenp, XF86ConfScreenPtr conf_screen, int scrnum,
|
|||
if (!configMonitor(screenp->monitor,conf_screen->scrn_monitor))
|
||||
return FALSE;
|
||||
}
|
||||
/* Configure the device. If there isn't one configured, attach to the
|
||||
* first inactive one that we can configure. If there's none that work,
|
||||
* set it to NULL so that the section can be autoconfigured later */
|
||||
screenp->device = xnfcalloc(1, sizeof(GDevRec));
|
||||
configDevice(screenp->device,conf_screen->scrn_device, TRUE);
|
||||
if ((!conf_screen->scrn_device) && (xf86configptr->conf_device_lst)) {
|
||||
conf_screen->scrn_device = xf86configptr->conf_device_lst;
|
||||
xf86Msg(X_DEFAULT, "No device specified for screen \"%s\".\n"
|
||||
"\tUsing the first device section listed.\n", screenp->id);
|
||||
}
|
||||
if (configDevice(screenp->device,conf_screen->scrn_device, TRUE)) {
|
||||
screenp->device->myScreenSection = screenp;
|
||||
} else {
|
||||
screenp->device = NULL;
|
||||
}
|
||||
screenp->options = conf_screen->scrn_option_lst;
|
||||
|
||||
/*
|
||||
|
@ -2230,6 +2263,10 @@ configDevice(GDevPtr devicep, XF86ConfDevicePtr conf_device, Bool active)
|
|||
{
|
||||
int i;
|
||||
|
||||
if (!conf_device) {
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
if (active)
|
||||
xf86Msg(X_CONFIG, "| |-->Device \"%s\"\n",
|
||||
conf_device->dev_identifier);
|
||||
|
|
|
@ -34,6 +34,8 @@
|
|||
#define _xf86_config_h
|
||||
|
||||
#include "xf86Optrec.h"
|
||||
#include "xf86Parser.h"
|
||||
#include "xf86str.h"
|
||||
|
||||
#ifdef HAVE_PARSER_DECLS
|
||||
/*
|
||||
|
@ -65,5 +67,8 @@ Bool xf86BuiltinInputDriver(const char *);
|
|||
ConfigStatus xf86HandleConfigFile(Bool);
|
||||
|
||||
Bool xf86AutoConfig(void);
|
||||
GDevPtr autoConfigDevice(GDevPtr preconf_device);
|
||||
char* chooseVideoDriver(void);
|
||||
int xchomp(char *line);
|
||||
|
||||
#endif /* _xf86_config_h */
|
||||
|
|
|
@ -317,7 +317,7 @@ xf86ProcessActionEvent(ActionEvent action, void *arg)
|
|||
}
|
||||
break;
|
||||
#if !defined(__SOL8__) && !defined(sgi) && \
|
||||
(!defined(sun) || defined(i386)) && defined(VT_ACTIVATE)
|
||||
(!defined(sun) || defined(__i386__)) && defined(VT_ACTIVATE)
|
||||
case ACTION_SWITCHSCREEN:
|
||||
if (VTSwitchEnabled && !xf86Info.dontVTSwitch && arg) {
|
||||
int vtno = *((int *) arg);
|
||||
|
@ -340,7 +340,7 @@ xf86ProcessActionEvent(ActionEvent action, void *arg)
|
|||
#else
|
||||
if (ioctl(xf86Info.consoleFd, VT_ACTIVATE, xf86Info.vtno + 1) < 0)
|
||||
#endif
|
||||
#if defined (__SCO__) || (defined(sun) && defined (i386) && defined (SVR4)) || defined(__UNIXWARE__)
|
||||
#if defined (__SCO__) || (defined(sun) && defined (__i386__) && defined (SVR4)) || defined(__UNIXWARE__)
|
||||
if (ioctl(xf86Info.consoleFd, VT_ACTIVATE, 0) < 0)
|
||||
#else
|
||||
if (ioctl(xf86Info.consoleFd, VT_ACTIVATE, 1) < 0)
|
||||
|
|
|
@ -124,7 +124,7 @@ xf86InfoRec xf86Info = {
|
|||
PCIOsConfig, /* pciFlags */
|
||||
Pix24DontCare, /* pixmap24 */
|
||||
X_DEFAULT, /* pix24From */
|
||||
#if defined(i386) || defined(__i386__)
|
||||
#ifdef __i386__
|
||||
FALSE, /* pc98 */
|
||||
#endif
|
||||
TRUE, /* pmFlag */
|
||||
|
|
|
@ -2341,7 +2341,7 @@ xf86GetAllowMouseOpenFail()
|
|||
_X_EXPORT Bool
|
||||
xf86IsPc98()
|
||||
{
|
||||
#if defined(i386) || defined(__i386__)
|
||||
#ifdef __i386__
|
||||
return xf86Info.pc98;
|
||||
#else
|
||||
return FALSE;
|
||||
|
|
|
@ -572,6 +572,16 @@ InitOutput(ScreenInfo *pScreenInfo, int argc, char **argv)
|
|||
}
|
||||
|
||||
/* Load all driver modules specified in the config file */
|
||||
/* If there aren't any specified in the config file, autoconfig them */
|
||||
/* FIXME: Does not handle multiple active screen sections, but I'm not
|
||||
* sure if we really want to handle that case*/
|
||||
GDevPtr configured_device = xf86ConfigLayout.screens->screen->device;
|
||||
if ((!configured_device) || (!configured_device->driver)) {
|
||||
if (!autoConfigDevice(configured_device)) {
|
||||
xf86Msg(X_ERROR, "Automatic driver configuration failed\n");
|
||||
return ;
|
||||
}
|
||||
}
|
||||
if ((modulelist = xf86DriverlistFromConfig())) {
|
||||
xf86LoadModules(modulelist, NULL);
|
||||
xfree(modulelist);
|
||||
|
|
|
@ -60,6 +60,12 @@ typedef enum {
|
|||
SKAlways
|
||||
} SpecialKeysInDDX;
|
||||
|
||||
typedef enum {
|
||||
XF86_GlxVisualsMinimal,
|
||||
XF86_GlxVisualsTypical,
|
||||
XF86_GlxVisualsAll,
|
||||
} XF86_GlxVisuals;
|
||||
|
||||
/*
|
||||
* xf86InfoRec contains global parameters which the video drivers never
|
||||
* need to access. Global parameters which the video drivers do need
|
||||
|
@ -109,7 +115,7 @@ typedef struct {
|
|||
PciProbeType pciFlags;
|
||||
Pix24Flags pixmap24;
|
||||
MessageType pix24From;
|
||||
#if defined(i386) || defined(__i386__)
|
||||
#ifdef __i386__
|
||||
Bool pc98;
|
||||
#endif
|
||||
Bool pmFlag;
|
||||
|
@ -120,6 +126,9 @@ typedef struct {
|
|||
MessageType randRFrom;
|
||||
Bool aiglx;
|
||||
MessageType aiglxFrom;
|
||||
XF86_GlxVisuals glxVisuals;
|
||||
MessageType glxVisualsFrom;
|
||||
|
||||
Bool useDefaultFontPath;
|
||||
MessageType useDefaultFontPathFrom;
|
||||
Bool ignoreABI;
|
||||
|
|
|
@ -142,6 +142,7 @@ typedef enum {
|
|||
# define M_T_DEFAULT 0x10 /* (VESA) default modes */
|
||||
# define M_T_USERDEF 0x20 /* One of the modes from the config file */
|
||||
# define M_T_DRIVER 0x40 /* Supplied by the driver (EDID, etc) */
|
||||
# define M_T_USERPREF 0x80 /* mode preferred by the user config */
|
||||
|
||||
/* Video mode */
|
||||
typedef struct _DisplayModeRec {
|
||||
|
|
|
@ -41,18 +41,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|||
#include "colormap.h"
|
||||
#include "micmap.h"
|
||||
#include "globals.h"
|
||||
|
||||
typedef struct __GLXscreen __GLXscreen;
|
||||
typedef struct __GLXprovider __GLXprovider;
|
||||
struct __GLXprovider {
|
||||
__GLXscreen *(*screenProbe)(ScreenPtr pScreen);
|
||||
const char *name;
|
||||
__GLXprovider *next;
|
||||
};
|
||||
|
||||
extern void GlxPushProvider(__GLXprovider *provider);
|
||||
extern void GlxExtensionInit(void);
|
||||
extern void GlxWrapInitVisuals(miInitVisualsProcPtr *);
|
||||
#include "glxserver.h"
|
||||
|
||||
static MODULESETUPPROTO(glxSetup);
|
||||
|
||||
|
@ -114,7 +103,6 @@ static __GLXprovider __glXMesaProxyProvider = {
|
|||
NULL
|
||||
};
|
||||
|
||||
|
||||
static pointer
|
||||
glxSetup(pointer module, pointer opts, int *errmaj, int *errmin)
|
||||
{
|
||||
|
@ -139,12 +127,22 @@ glxSetup(pointer module, pointer opts, int *errmaj, int *errmin)
|
|||
GlxPushProvider(provider);
|
||||
}
|
||||
|
||||
LoadExtension(&GLXExt, FALSE);
|
||||
/* Wrap the init visuals routine in micmap.c */
|
||||
GlxWrapInitVisuals(&miInitVisualsProc);
|
||||
/* Make sure this gets wrapped each time InitVisualWrap is called */
|
||||
miHookInitVisuals(NULL, GlxWrapInitVisuals);
|
||||
switch (xf86Info.glxVisuals) {
|
||||
case XF86_GlxVisualsMinimal:
|
||||
GlxSetVisualConfig(GLX_MINIMAL_VISUALS);
|
||||
xf86Msg(xf86Info.aiglxFrom, "Exporting only minimal set of GLX visuals\n");
|
||||
break;
|
||||
case XF86_GlxVisualsTypical:
|
||||
GlxSetVisualConfig(GLX_TYPICAL_VISUALS);
|
||||
xf86Msg(xf86Info.aiglxFrom, "Exporting typical set of GLX visuals\n");
|
||||
break;
|
||||
case XF86_GlxVisualsAll:
|
||||
GlxSetVisualConfig(GLX_ALL_VISUALS);
|
||||
xf86Msg(xf86Info.aiglxFrom, "Exporting all GLX visuals\n");
|
||||
break;
|
||||
}
|
||||
|
||||
LoadExtension(&GLXExt, FALSE);
|
||||
|
||||
bail:
|
||||
return module;
|
||||
}
|
||||
|
|
|
@ -700,6 +700,17 @@ the builtin handler will be used.
|
|||
.BI "Option \*qAIGLX\*q \*q" boolean \*q
|
||||
enable or disable AIGLX. AIGLX is enabled by default.
|
||||
.TP 7
|
||||
.BI "Option \*qGlxVisuals\*q \*q" string \*q
|
||||
This option controls how many GLX visuals the GLX modules sets up.
|
||||
The default value is
|
||||
.BR "typical" ,
|
||||
which will setup up a typical subset of
|
||||
the GLXFBConfigs provided by the driver as GLX visuals. Other options are
|
||||
.BR "minimal" ,
|
||||
which will set up the minimal set allowed by the GLX specification and
|
||||
.BR "all"
|
||||
which will setup GLX visuals for all GLXFBConfigs.
|
||||
.TP 7
|
||||
.BI "Option \*qUseDefaultFontPath\*q \*q" boolean \*q
|
||||
Include the default font path even if other paths are specified in
|
||||
xorg.conf. If enabled, other font paths are included as well. Enabled by
|
||||
|
|
|
@ -67,7 +67,6 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|||
#include "dristruct.h"
|
||||
#include "xf86.h"
|
||||
#include "xf86drm.h"
|
||||
#include "glxserver.h"
|
||||
#include "mi.h"
|
||||
#include "mipointer.h"
|
||||
#include "xf86_OSproc.h"
|
||||
|
@ -972,24 +971,8 @@ static Bool
|
|||
DRICreateDummyContext(ScreenPtr pScreen, Bool needCtxPriv)
|
||||
{
|
||||
DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);
|
||||
__GLXscreen *pGLXScreen = __glXgetActiveScreen(pScreen->myNum);
|
||||
__GLcontextModes *modes = pGLXScreen->modes;
|
||||
void **pVisualConfigPriv = pGLXScreen->pVisualPriv;
|
||||
DRIContextPrivPtr pDRIContextPriv;
|
||||
void *contextStore;
|
||||
VisualPtr visual;
|
||||
int visNum;
|
||||
|
||||
visual = pScreen->visuals;
|
||||
|
||||
/* Find the X visual that corresponds the the first GLX visual */
|
||||
for (visNum = 0;
|
||||
visNum < pScreen->numVisuals;
|
||||
visNum++, visual++) {
|
||||
if (modes->visualID == visual->vid)
|
||||
break;
|
||||
}
|
||||
if (visNum == pScreen->numVisuals) return FALSE;
|
||||
|
||||
if (!(pDRIContextPriv =
|
||||
DRICreateContextPriv(pScreen,
|
||||
|
@ -999,9 +982,9 @@ DRICreateDummyContext(ScreenPtr pScreen, Bool needCtxPriv)
|
|||
|
||||
contextStore = DRIGetContextStore(pDRIContextPriv);
|
||||
if (pDRIPriv->pDriverInfo->CreateContext && needCtxPriv) {
|
||||
if (!pDRIPriv->pDriverInfo->CreateContext(pScreen, visual,
|
||||
if (!pDRIPriv->pDriverInfo->CreateContext(pScreen, NULL,
|
||||
pDRIPriv->pSAREA->dummy_context,
|
||||
*pVisualConfigPriv,
|
||||
NULL,
|
||||
(DRIContextType)(long)contextStore)) {
|
||||
DRIDestroyContextPriv(pDRIContextPriv);
|
||||
return FALSE;
|
||||
|
@ -1036,9 +1019,6 @@ DRICreateContext(ScreenPtr pScreen, VisualPtr visual,
|
|||
XID context, drm_context_t * pHWContext)
|
||||
{
|
||||
DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);
|
||||
__GLXscreen *pGLXScreen = __glXgetActiveScreen(pScreen->myNum);
|
||||
__GLcontextModes *modes = pGLXScreen->modes;
|
||||
void **pVisualConfigPriv = pGLXScreen->pVisualPriv;
|
||||
DRIContextPrivPtr pDRIContextPriv;
|
||||
void *contextStore;
|
||||
|
||||
|
@ -1050,26 +1030,14 @@ DRICreateContext(ScreenPtr pScreen, VisualPtr visual,
|
|||
}
|
||||
}
|
||||
|
||||
/* Find the GLX visual associated with the one requested */
|
||||
for (modes = pGLXScreen->modes; modes != NULL; modes = modes->next) {
|
||||
if (modes->visualID == visual->vid)
|
||||
break;
|
||||
pVisualConfigPriv++;
|
||||
}
|
||||
|
||||
if (modes == NULL) {
|
||||
/* No matching GLX visual found */
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
if (!(pDRIContextPriv = DRICreateContextPriv(pScreen, pHWContext, 0))) {
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
contextStore = DRIGetContextStore(pDRIContextPriv);
|
||||
if (pDRIPriv->pDriverInfo->CreateContext) {
|
||||
if (!((*pDRIPriv->pDriverInfo->CreateContext)(pScreen, visual,
|
||||
*pHWContext, *pVisualConfigPriv,
|
||||
if (!((*pDRIPriv->pDriverInfo->CreateContext)(pScreen, NULL,
|
||||
*pHWContext, NULL,
|
||||
(DRIContextType)(long)contextStore))) {
|
||||
DRIDestroyContextPriv(pDRIContextPriv);
|
||||
return FALSE;
|
||||
|
|
|
@ -337,19 +337,9 @@ ProcXF86DRICreateContext(
|
|||
rep.sequenceNumber = client->sequence;
|
||||
|
||||
pScreen = screenInfo.screens[stuff->screen];
|
||||
visual = pScreen->visuals;
|
||||
|
||||
/* Find the requested X visual */
|
||||
for (i = 0; i < pScreen->numVisuals; i++, visual++)
|
||||
if (visual->vid == stuff->visual)
|
||||
break;
|
||||
if (i == pScreen->numVisuals) {
|
||||
/* No visual found */
|
||||
return BadValue;
|
||||
}
|
||||
|
||||
if (!DRICreateContext( pScreen,
|
||||
visual,
|
||||
NULL,
|
||||
stuff->context,
|
||||
(drm_context_t *)&rep.hHWContext)) {
|
||||
return BadValue;
|
||||
|
|
|
@ -711,7 +711,8 @@ xf86DefaultMode (xf86OutputPtr output, int width, int height)
|
|||
for (mode = output->probed_modes; mode; mode = mode->next)
|
||||
{
|
||||
int dpi;
|
||||
int preferred = (mode->type & M_T_PREFERRED) != 0;
|
||||
int preferred = (((mode->type & M_T_PREFERRED) != 0) +
|
||||
((mode->type & M_T_USERPREF) != 0));
|
||||
int diff;
|
||||
|
||||
if (xf86ModeWidth (mode, output->initial_rotation) > width ||
|
||||
|
@ -1415,7 +1416,7 @@ xf86ProbeOutputModes (ScrnInfoPtr scrn, int maxX, int maxY)
|
|||
mode->prev = NULL;
|
||||
output->probed_modes = mode;
|
||||
}
|
||||
mode->type |= M_T_PREFERRED;
|
||||
mode->type |= (M_T_PREFERRED|M_T_USERPREF);
|
||||
}
|
||||
else
|
||||
mode->type &= ~M_T_PREFERRED;
|
||||
|
@ -1532,6 +1533,7 @@ xf86InitialConfiguration (ScrnInfoPtr scrn, Bool canGrow)
|
|||
xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(scrn);
|
||||
int o, c;
|
||||
DisplayModePtr target_mode = NULL;
|
||||
int target_preferred = 0;
|
||||
Rotation target_rotation = RR_Rotate_0;
|
||||
xf86CrtcPtr *crtcs;
|
||||
DisplayModePtr *modes;
|
||||
|
@ -1572,43 +1574,34 @@ xf86InitialConfiguration (ScrnInfoPtr scrn, Bool canGrow)
|
|||
}
|
||||
|
||||
/*
|
||||
* Let outputs with preferred modes drive screen size
|
||||
* User preferred > preferred > other modes
|
||||
*/
|
||||
for (o = 0; o < config->num_output; o++)
|
||||
{
|
||||
xf86OutputPtr output = config->output[o];
|
||||
DisplayModePtr default_mode;
|
||||
int default_preferred;
|
||||
|
||||
if (enabled[o] &&
|
||||
xf86OutputHasPreferredMode (output, width, height))
|
||||
if (!enabled[o])
|
||||
continue;
|
||||
default_mode = xf86DefaultMode (output, width, height);
|
||||
if (!default_mode)
|
||||
continue;
|
||||
default_preferred = (((default_mode->type & M_T_PREFERRED) != 0) +
|
||||
((default_mode->type & M_T_USERPREF) != 0));
|
||||
if (default_preferred > target_preferred || !target_mode)
|
||||
{
|
||||
target_mode = xf86DefaultMode (output, width, height);
|
||||
target_mode = default_mode;
|
||||
target_preferred = default_preferred;
|
||||
target_rotation = output->initial_rotation;
|
||||
if (target_mode)
|
||||
{
|
||||
modes[o] = target_mode;
|
||||
config->compat_output = o;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!target_mode)
|
||||
{
|
||||
for (o = 0; o < config->num_output; o++)
|
||||
{
|
||||
xf86OutputPtr output = config->output[o];
|
||||
if (enabled[o])
|
||||
{
|
||||
target_mode = xf86DefaultMode (output, width, height);
|
||||
target_rotation = output->initial_rotation;
|
||||
if (target_mode)
|
||||
{
|
||||
modes[o] = target_mode;
|
||||
config->compat_output = o;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
modes[config->compat_output] = target_mode;
|
||||
/*
|
||||
* Fill in other output modes
|
||||
*/
|
||||
for (o = 0; o < config->num_output; o++)
|
||||
{
|
||||
xf86OutputPtr output = config->output[o];
|
||||
|
@ -2134,8 +2127,12 @@ _X_EXPORT xf86MonPtr
|
|||
xf86OutputGetEDID (xf86OutputPtr output, I2CBusPtr pDDCBus)
|
||||
{
|
||||
ScrnInfoPtr scrn = output->scrn;
|
||||
xf86MonPtr mon;
|
||||
|
||||
return xf86DoEDID_DDC2 (scrn->scrnIndex, pDDCBus);
|
||||
mon = xf86DoEDID_DDC2 (scrn->scrnIndex, pDDCBus);
|
||||
xf86DDCApplyQuirks (scrn->scrnIndex, pDDCBus);
|
||||
|
||||
return mon;
|
||||
}
|
||||
|
||||
static char *_xf86ConnectorNames[] = { "None", "VGA", "DVI-I", "DVI-D",
|
||||
|
|
|
@ -39,6 +39,9 @@
|
|||
#ifndef M_T_DRIVER
|
||||
#define M_T_DRIVER 0x40
|
||||
#endif
|
||||
#ifndef M_T_USERPREF
|
||||
#define M_T_USERPREF 0x80
|
||||
#endif
|
||||
#ifndef HARDWARE_CURSOR_ARGB
|
||||
#define HARDWARE_CURSOR_ARGB 0x00004000
|
||||
#endif
|
||||
|
|
|
@ -54,6 +54,18 @@ typedef enum {
|
|||
DDC_QUIRK_PREFER_LARGE_60 = 1 << 0,
|
||||
/* 135MHz clock is too high, drop a bit */
|
||||
DDC_QUIRK_135_CLOCK_TOO_HIGH = 1 << 1,
|
||||
/* Prefer the largest mode at 75 Hz */
|
||||
DDC_QUIRK_PREFER_LARGE_75 = 1 << 2,
|
||||
/* Convert detailed timing's horizontal from units of cm to mm */
|
||||
DDC_QUIRK_DETAILED_H_IN_CM = 1 << 3,
|
||||
/* Convert detailed timing's vertical from units of cm to mm */
|
||||
DDC_QUIRK_DETAILED_V_IN_CM = 1 << 4,
|
||||
/* Detailed timing descriptors have bogus size values, so just take the
|
||||
* maximum size and use that.
|
||||
*/
|
||||
DDC_QUIRK_DETAILED_USE_MAXIMUM_SIZE = 1 << 5,
|
||||
/* Monitor forgot to set the first detailed is preferred bit. */
|
||||
DDC_QUIRK_FIRST_DETAILED_PREFERRED = 1 << 6,
|
||||
} ddc_quirk_t;
|
||||
|
||||
static Bool quirk_prefer_large_60 (int scrnIndex, xf86MonPtr DDC)
|
||||
|
@ -81,6 +93,52 @@ static Bool quirk_prefer_large_60 (int scrnIndex, xf86MonPtr DDC)
|
|||
return FALSE;
|
||||
}
|
||||
|
||||
static Bool quirk_prefer_large_75 (int scrnIndex, xf86MonPtr DDC)
|
||||
{
|
||||
/* Bug #11603: Funai Electronics PM36B */
|
||||
if (memcmp (DDC->vendor.name, "FCM", 4) == 0 &&
|
||||
DDC->vendor.prod_id == 13600)
|
||||
return TRUE;
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
static Bool quirk_detailed_h_in_cm (int scrnIndex, xf86MonPtr DDC)
|
||||
{
|
||||
/* Bug #10304: "LGPhilipsLCD LP154W01-A5" */
|
||||
/* Bug #12784: "LGPhilipsLCD LP154W01-TLA2" */
|
||||
if (memcmp (DDC->vendor.name, "LPL", 4) == 0 &&
|
||||
DDC->vendor.prod_id == 0)
|
||||
return TRUE;
|
||||
|
||||
/* Bug #11603: Funai Electronics PM36B */
|
||||
if (memcmp (DDC->vendor.name, "FCM", 4) == 0 &&
|
||||
DDC->vendor.prod_id == 13600)
|
||||
return TRUE;
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
static Bool quirk_detailed_v_in_cm (int scrnIndex, xf86MonPtr DDC)
|
||||
{
|
||||
/* Bug #11603: Funai Electronics PM36B */
|
||||
if (memcmp (DDC->vendor.name, "FCM", 4) == 0 &&
|
||||
DDC->vendor.prod_id == 13600)
|
||||
return TRUE;
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
static Bool quirk_detailed_use_maximum_size (int scrnIndex, xf86MonPtr DDC)
|
||||
{
|
||||
/* Bug #10304: LGPhilipsLCD LP154W01-A5 */
|
||||
if (memcmp (DDC->vendor.name, "LPL", 4) == 0 &&
|
||||
DDC->vendor.prod_id == 0)
|
||||
return TRUE;
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
static Bool quirk_135_clock_too_high (int scrnIndex, xf86MonPtr DDC)
|
||||
{
|
||||
/* Envision Peripherals, Inc. EN-7100e. See bug #9550. */
|
||||
|
@ -91,6 +149,16 @@ static Bool quirk_135_clock_too_high (int scrnIndex, xf86MonPtr DDC)
|
|||
return FALSE;
|
||||
}
|
||||
|
||||
static Bool quirk_first_detailed_preferred (int scrnIndex, xf86MonPtr DDC)
|
||||
{
|
||||
/* Philips 107p5 CRT. Reported on xorg@ with pastebin. */
|
||||
if (memcmp (DDC->vendor.name, "PHL", 4) == 0 &&
|
||||
DDC->vendor.prod_id == 57364)
|
||||
return TRUE;
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
typedef struct {
|
||||
Bool (*detect) (int scrnIndex, xf86MonPtr DDC);
|
||||
ddc_quirk_t quirk;
|
||||
|
@ -106,6 +174,26 @@ static const ddc_quirk_map_t ddc_quirks[] = {
|
|||
quirk_135_clock_too_high, DDC_QUIRK_135_CLOCK_TOO_HIGH,
|
||||
"Recommended 135MHz pixel clock is too high"
|
||||
},
|
||||
{
|
||||
quirk_prefer_large_75, DDC_QUIRK_PREFER_LARGE_75,
|
||||
"Detailed timing is not preferred, use largest mode at 75Hz"
|
||||
},
|
||||
{
|
||||
quirk_detailed_h_in_cm, DDC_QUIRK_DETAILED_H_IN_CM,
|
||||
"Detailed timings give horizontal size in cm."
|
||||
},
|
||||
{
|
||||
quirk_detailed_v_in_cm, DDC_QUIRK_DETAILED_V_IN_CM,
|
||||
"Detailed timings give vertical size in cm."
|
||||
},
|
||||
{
|
||||
quirk_detailed_use_maximum_size, DDC_QUIRK_DETAILED_USE_MAXIMUM_SIZE,
|
||||
"Detailed timings give sizes in cm."
|
||||
},
|
||||
{
|
||||
quirk_first_detailed_preferred, DDC_QUIRK_FIRST_DETAILED_PREFERRED,
|
||||
"First detailed timing was not marked as preferred."
|
||||
},
|
||||
{
|
||||
NULL, DDC_QUIRK_NONE,
|
||||
"No known quirks"
|
||||
|
@ -185,7 +273,7 @@ DDCModesFromStandardTiming(int scrnIndex, struct std_timings *timing,
|
|||
*/
|
||||
static DisplayModePtr
|
||||
DDCModeFromDetailedTiming(int scrnIndex, struct detailed_timings *timing,
|
||||
int preferred, ddc_quirk_t quirks)
|
||||
Bool preferred, ddc_quirk_t quirks)
|
||||
{
|
||||
DisplayModePtr Mode;
|
||||
|
||||
|
@ -303,27 +391,116 @@ DDCGuessRangesFromModes(int scrnIndex, MonPtr Monitor, DisplayModePtr Modes)
|
|||
}
|
||||
}
|
||||
|
||||
static ddc_quirk_t
|
||||
xf86DDCDetectQuirks(int scrnIndex, xf86MonPtr DDC, Bool verbose)
|
||||
{
|
||||
ddc_quirk_t quirks;
|
||||
int i;
|
||||
|
||||
quirks = DDC_QUIRK_NONE;
|
||||
for (i = 0; ddc_quirks[i].detect; i++) {
|
||||
if (ddc_quirks[i].detect (scrnIndex, DDC)) {
|
||||
if (verbose) {
|
||||
xf86DrvMsg (scrnIndex, X_INFO, " EDID quirk: %s\n",
|
||||
ddc_quirks[i].description);
|
||||
}
|
||||
quirks |= ddc_quirks[i].quirk;
|
||||
}
|
||||
}
|
||||
|
||||
return quirks;
|
||||
}
|
||||
|
||||
/**
|
||||
* Applies monitor-specific quirks to the decoded EDID information.
|
||||
*
|
||||
* Note that some quirks applying to the mode list are still implemented in
|
||||
* xf86DDCGetModes.
|
||||
*/
|
||||
void
|
||||
xf86DDCApplyQuirks(int scrnIndex, xf86MonPtr DDC)
|
||||
{
|
||||
ddc_quirk_t quirks = xf86DDCDetectQuirks (scrnIndex, DDC, FALSE);
|
||||
int i;
|
||||
|
||||
for (i = 0; i < DET_TIMINGS; i++) {
|
||||
struct detailed_monitor_section *det_mon = &DDC->det_mon[i];
|
||||
|
||||
if (det_mon->type != DT)
|
||||
continue;
|
||||
|
||||
if (quirks & DDC_QUIRK_DETAILED_H_IN_CM)
|
||||
det_mon->section.d_timings.h_size *= 10;
|
||||
|
||||
if (quirks & DDC_QUIRK_DETAILED_V_IN_CM)
|
||||
det_mon->section.d_timings.v_size *= 10;
|
||||
|
||||
if (quirks & DDC_QUIRK_DETAILED_USE_MAXIMUM_SIZE) {
|
||||
det_mon->section.d_timings.h_size = 10 * DDC->features.hsize;
|
||||
det_mon->section.d_timings.v_size = 10 * DDC->features.vsize;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Walks the modes list, finding the mode with the largest area which is
|
||||
* closest to the target refresh rate, and marks it as the only preferred mode.
|
||||
*/
|
||||
static void
|
||||
xf86DDCSetPreferredRefresh(int scrnIndex, DisplayModePtr modes,
|
||||
float target_refresh)
|
||||
{
|
||||
DisplayModePtr mode, best = modes;
|
||||
|
||||
for (mode = modes; mode; mode = mode->next)
|
||||
{
|
||||
mode->type &= ~M_T_PREFERRED;
|
||||
|
||||
if (mode == best) continue;
|
||||
|
||||
if (mode->HDisplay * mode->VDisplay >
|
||||
best->HDisplay * best->VDisplay)
|
||||
{
|
||||
best = mode;
|
||||
continue;
|
||||
}
|
||||
if (mode->HDisplay * mode->VDisplay ==
|
||||
best->HDisplay * best->VDisplay)
|
||||
{
|
||||
double mode_refresh = xf86ModeVRefresh (mode);
|
||||
double best_refresh = xf86ModeVRefresh (best);
|
||||
double mode_dist = fabs(mode_refresh - target_refresh);
|
||||
double best_dist = fabs(best_refresh - target_refresh);
|
||||
|
||||
if (mode_dist < best_dist)
|
||||
{
|
||||
best = mode;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (best)
|
||||
best->type |= M_T_PREFERRED;
|
||||
}
|
||||
|
||||
_X_EXPORT DisplayModePtr
|
||||
xf86DDCGetModes(int scrnIndex, xf86MonPtr DDC)
|
||||
{
|
||||
int preferred, i;
|
||||
int i;
|
||||
DisplayModePtr Modes = NULL, Mode;
|
||||
ddc_quirk_t quirks;
|
||||
Bool preferred;
|
||||
|
||||
xf86DrvMsg (scrnIndex, X_INFO, "EDID vendor \"%s\", prod id %d\n",
|
||||
DDC->vendor.name, DDC->vendor.prod_id);
|
||||
quirks = DDC_QUIRK_NONE;
|
||||
for (i = 0; ddc_quirks[i].detect; i++)
|
||||
if (ddc_quirks[i].detect (scrnIndex, DDC))
|
||||
{
|
||||
xf86DrvMsg (scrnIndex, X_INFO, " EDID quirk: %s\n",
|
||||
ddc_quirks[i].description);
|
||||
quirks |= ddc_quirks[i].quirk;
|
||||
}
|
||||
|
||||
quirks = xf86DDCDetectQuirks(scrnIndex, DDC, TRUE);
|
||||
|
||||
preferred = PREFERRED_TIMING_MODE(DDC->features.msc);
|
||||
if (quirks & DDC_QUIRK_PREFER_LARGE_60)
|
||||
preferred = 0;
|
||||
if (quirks & DDC_QUIRK_FIRST_DETAILED_PREFERRED)
|
||||
preferred = TRUE;
|
||||
if (quirks & (DDC_QUIRK_PREFER_LARGE_60 | DDC_QUIRK_PREFER_LARGE_75))
|
||||
preferred = FALSE;
|
||||
|
||||
for (i = 0; i < DET_TIMINGS; i++) {
|
||||
struct detailed_monitor_section *det_mon = &DDC->det_mon[i];
|
||||
|
@ -334,7 +511,7 @@ xf86DDCGetModes(int scrnIndex, xf86MonPtr DDC)
|
|||
&det_mon->section.d_timings,
|
||||
preferred,
|
||||
quirks);
|
||||
preferred = 0;
|
||||
preferred = FALSE;
|
||||
Modes = xf86ModesAdd(Modes, Mode);
|
||||
break;
|
||||
case DS_STD_TIMINGS:
|
||||
|
@ -357,32 +534,11 @@ xf86DDCGetModes(int scrnIndex, xf86MonPtr DDC)
|
|||
Modes = xf86ModesAdd(Modes, Mode);
|
||||
|
||||
if (quirks & DDC_QUIRK_PREFER_LARGE_60)
|
||||
{
|
||||
DisplayModePtr best = Modes;
|
||||
for (Mode = Modes; Mode; Mode = Mode->next)
|
||||
{
|
||||
if (Mode == best) continue;
|
||||
if (Mode->HDisplay * Mode->VDisplay > best->HDisplay * best->VDisplay)
|
||||
{
|
||||
best = Mode;
|
||||
continue;
|
||||
}
|
||||
if (Mode->HDisplay * Mode->VDisplay == best->HDisplay * best->VDisplay)
|
||||
{
|
||||
double mode_refresh = xf86ModeVRefresh (Mode);
|
||||
double best_refresh = xf86ModeVRefresh (best);
|
||||
double mode_dist = fabs(mode_refresh - 60.0);
|
||||
double best_dist = fabs(best_refresh - 60.0);
|
||||
if (mode_dist < best_dist)
|
||||
{
|
||||
best = Mode;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (best)
|
||||
best->type |= M_T_PREFERRED;
|
||||
}
|
||||
xf86DDCSetPreferredRefresh(scrnIndex, Modes, 60);
|
||||
|
||||
if (quirks & DDC_QUIRK_PREFER_LARGE_75)
|
||||
xf86DDCSetPreferredRefresh(scrnIndex, Modes, 75);
|
||||
|
||||
return Modes;
|
||||
}
|
||||
|
||||
|
|
|
@ -389,8 +389,8 @@ xf86ValidateModesSync(ScrnInfoPtr pScrn, DisplayModePtr modeList,
|
|||
|
||||
bad = TRUE;
|
||||
for (i = 0; i < mon->nHsync; i++) {
|
||||
if (xf86ModeHSync(mode) >= mon->hsync[i].lo &&
|
||||
xf86ModeHSync(mode) <= mon->hsync[i].hi)
|
||||
if (xf86ModeHSync(mode) >= mon->hsync[i].lo * (1-SYNC_TOLERANCE) &&
|
||||
xf86ModeHSync(mode) <= mon->hsync[i].hi * (1+SYNC_TOLERANCE))
|
||||
{
|
||||
bad = FALSE;
|
||||
}
|
||||
|
@ -400,8 +400,8 @@ xf86ValidateModesSync(ScrnInfoPtr pScrn, DisplayModePtr modeList,
|
|||
|
||||
bad = TRUE;
|
||||
for (i = 0; i < mon->nVrefresh; i++) {
|
||||
if (xf86ModeVRefresh(mode) >= mon->vrefresh[i].lo &&
|
||||
xf86ModeVRefresh(mode) <= mon->vrefresh[i].hi)
|
||||
if (xf86ModeVRefresh(mode) >= mon->vrefresh[i].lo * (1-SYNC_TOLERANCE) &&
|
||||
xf86ModeVRefresh(mode) <= mon->vrefresh[i].hi * (1+SYNC_TOLERANCE))
|
||||
{
|
||||
bad = FALSE;
|
||||
}
|
||||
|
@ -434,7 +434,8 @@ xf86ValidateModesClocks(ScrnInfoPtr pScrn, DisplayModePtr modeList,
|
|||
for (mode = modeList; mode != NULL; mode = mode->next) {
|
||||
Bool good = FALSE;
|
||||
for (i = 0; i < n_ranges; i++) {
|
||||
if (mode->Clock >= min[i] && mode->Clock <= max[i]) {
|
||||
if (mode->Clock >= min[i] * (1-SYNC_TOLERANCE) &&
|
||||
mode->Clock <= max[i] * (1+SYNC_TOLERANCE)) {
|
||||
good = TRUE;
|
||||
break;
|
||||
}
|
||||
|
|
|
@ -95,4 +95,7 @@ xf86GetMonitorModes (ScrnInfoPtr pScrn, XF86ConfMonitorPtr conf_monitor);
|
|||
DisplayModePtr
|
||||
xf86GetDefaultModes (Bool interlaceAllowed, Bool doubleScanAllowed);
|
||||
|
||||
void
|
||||
xf86DDCApplyQuirks(int scrnIndex, xf86MonPtr DDC);
|
||||
|
||||
#endif /* _XF86MODES_H_ */
|
||||
|
|
|
@ -91,7 +91,7 @@
|
|||
#define GNU_ASSEMBLER
|
||||
#endif
|
||||
|
||||
#if (defined(__STDC__) && !defined(UNIXCPP)) || (defined (sun) && defined (i386) && defined (SVR4) && defined (__STDC__) && !defined (__GNUC__))
|
||||
#if (defined(__STDC__) && !defined(UNIXCPP)) || (defined (sun) && defined (__i386__) && defined (SVR4) && defined (__STDC__) && !defined (__GNUC__))
|
||||
#define CONCAT(x, y) x ## y
|
||||
#else
|
||||
#define CONCAT(x, y) x/**/y
|
||||
|
|
|
@ -210,7 +210,7 @@
|
|||
# define ARCH_PCI_INIT ia64linuxPciInit
|
||||
# endif
|
||||
# define XF86SCANPCI_WRAPPER ia64ScanPCIWrapper
|
||||
#elif defined(__i386__) || defined(i386)
|
||||
#elif defined(__i386__)
|
||||
# if defined(linux)
|
||||
# define ARCH_PCI_INIT linuxPciInit
|
||||
# else
|
||||
|
|
|
@ -23,11 +23,11 @@
|
|||
#define ACPI_VIDEO_NOTIFY_NEXT_OUTPUT 0x83
|
||||
#define ACPI_VIDEO_NOTIFY_PREV_OUTPUT 0x84
|
||||
|
||||
#define ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS 0x82
|
||||
#define ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS 0x83
|
||||
#define ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS 0x84
|
||||
#define ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS 0x85
|
||||
#define ACPI_VIDEO_NOTIFY_DISPLAY_OFF 0x86
|
||||
#define ACPI_VIDEO_NOTIFY_CYCLE_BRIGHTNESS 0x85
|
||||
#define ACPI_VIDEO_NOTIFY_INC_BRIGHTNESS 0x86
|
||||
#define ACPI_VIDEO_NOTIFY_DEC_BRIGHTNESS 0x87
|
||||
#define ACPI_VIDEO_NOTIFY_ZERO_BRIGHTNESS 0x88
|
||||
#define ACPI_VIDEO_NOTIFY_DISPLAY_OFF 0x89
|
||||
|
||||
#define ACPI_VIDEO_HEAD_INVALID (~0u - 1)
|
||||
#define ACPI_VIDEO_HEAD_END (~0u)
|
||||
|
@ -69,9 +69,11 @@ lnxACPIGetEventFromOs(int fd, pmEvent *events, int num)
|
|||
TimerSet(NULL, 0, ACPI_REOPEN_DELAY, lnxACPIReopen, NULL);
|
||||
return 0;
|
||||
}
|
||||
/* FIXME: this only processes the first read ACPI event & might break
|
||||
* with interrupted reads. */
|
||||
|
||||
/* Check that we have a video event */
|
||||
if (strstr(ev, "video") == ev) {
|
||||
if (!strncmp(ev, "video", 5)) {
|
||||
char *video = NULL;
|
||||
char *GFX = NULL;
|
||||
char *notify = NULL;
|
||||
|
@ -97,26 +99,19 @@ lnxACPIGetEventFromOs(int fd, pmEvent *events, int num)
|
|||
ErrorF("data: 0x%lx\n",data_l);
|
||||
#endif
|
||||
|
||||
/* We currently don't differentiate between any event */
|
||||
/* Differentiate between events */
|
||||
switch (notify_l) {
|
||||
case ACPI_VIDEO_NOTIFY_SWITCH:
|
||||
break;
|
||||
case ACPI_VIDEO_NOTIFY_PROBE:
|
||||
break;
|
||||
case ACPI_VIDEO_NOTIFY_CYCLE:
|
||||
break;
|
||||
case ACPI_VIDEO_NOTIFY_NEXT_OUTPUT:
|
||||
break;
|
||||
case ACPI_VIDEO_NOTIFY_PREV_OUTPUT:
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
/* Deal with all ACPI events as a capability change */
|
||||
events[0] = XF86_APM_CAPABILITY_CHANGED;
|
||||
|
||||
return 1;
|
||||
case ACPI_VIDEO_NOTIFY_PROBE:
|
||||
return 0;
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
|
|
@ -26,7 +26,7 @@
|
|||
#include <xorg-config.h>
|
||||
#endif
|
||||
|
||||
#ifdef i386
|
||||
#ifdef __i386__
|
||||
#define _NEED_SYSI86
|
||||
#endif
|
||||
#include "xf86.h"
|
||||
|
@ -66,7 +66,7 @@ xf86ReadBIOS(unsigned long Base, unsigned long Offset, unsigned char *Buf,
|
|||
Offset += Base & (psize - 1);
|
||||
Base &= ~(psize - 1);
|
||||
mlen = (Offset + Len + psize - 1) & ~(psize - 1);
|
||||
#if defined(i386) && !defined(__SOL8__)
|
||||
#if defined(__i386__) && !defined(__SOL8__)
|
||||
if (Base >= 0xA0000 && Base + mlen < 0xFFFFF && xf86Info.vtno >= 0)
|
||||
sprintf(solx86_vtname, "/dev/vt%02d", xf86Info.vtno);
|
||||
else
|
||||
|
|
|
@ -29,7 +29,7 @@
|
|||
#include "xf86.h"
|
||||
#include "xf86Priv.h"
|
||||
#include "xf86_OSlib.h"
|
||||
#if defined(__i386) || defined(__x86)
|
||||
#if defined(__i386__) || defined(__x86)
|
||||
# include <sys/kd.h>
|
||||
#endif
|
||||
|
||||
|
@ -40,7 +40,7 @@ static int VTnum = -1;
|
|||
static int xf86StartVT = -1;
|
||||
#endif
|
||||
|
||||
#if defined(__SOL8__) || !defined(__i386)
|
||||
#if defined(__SOL8__) || !defined(__i386__)
|
||||
static char fb_dev[PATH_MAX] = "/dev/fb";
|
||||
#else
|
||||
static char fb_dev[PATH_MAX] = "/dev/console";
|
||||
|
@ -209,11 +209,11 @@ xf86CloseConsole(void)
|
|||
#ifdef HAS_USL_VTS
|
||||
struct vt_mode VT;
|
||||
#endif
|
||||
#if defined(__SOL8__) || !defined(i386)
|
||||
#if defined(__SOL8__) || !defined(__i386__)
|
||||
int tmp;
|
||||
#endif
|
||||
|
||||
#if !defined(i386) && !defined(__x86)
|
||||
#if !defined(__i386__) && !defined(__x86)
|
||||
|
||||
if (!xf86DoProbe && !xf86DoConfigure) {
|
||||
int fd;
|
||||
|
@ -332,7 +332,7 @@ xf86ProcessArgument(int argc, char **argv, int i)
|
|||
|
||||
#endif /* HAS_USL_VTS */
|
||||
|
||||
#if defined(__SOL8__) || !defined(i386)
|
||||
#if defined(__SOL8__) || !defined(__i386__)
|
||||
|
||||
if ((i + 1) < argc) {
|
||||
if (!strcmp(argv[i], "-dev")) {
|
||||
|
@ -352,7 +352,7 @@ void xf86UseMsg()
|
|||
#ifdef HAS_USL_VTS
|
||||
ErrorF("vtXX Use the specified VT number\n");
|
||||
#endif
|
||||
#if defined(__SOL8__) || !defined(i386)
|
||||
#if defined(__SOL8__) || !defined(__i386__)
|
||||
ErrorF("-dev <fb> Framebuffer device\n");
|
||||
#endif
|
||||
ErrorF("-keeptty Don't detach controlling tty\n");
|
||||
|
|
|
@ -28,7 +28,7 @@
|
|||
|
||||
#include <sys/types.h> /* get __x86 definition if not set by compiler */
|
||||
|
||||
#if defined(i386) || defined(__x86)
|
||||
#if defined(__i386__) || defined(__x86)
|
||||
#define _NEED_SYSI86
|
||||
#endif
|
||||
#include "xf86.h"
|
||||
|
@ -108,7 +108,7 @@ xf86MapVidMem(int ScreenNum, int Flags, unsigned long Base, unsigned long Size)
|
|||
* TSI - 2001.09 - SPARC changes
|
||||
*/
|
||||
|
||||
#if defined(i386) && !defined(__SOL8__)
|
||||
#if defined(__i386__) && !defined(__SOL8__)
|
||||
if(Base < 0xFFFFF)
|
||||
sprintf(vtname, "/dev/vt%02d", xf86Info.vtno);
|
||||
else
|
||||
|
@ -148,14 +148,14 @@ xf86UnMapVidMem(int ScreenNum, pointer Base, unsigned long Size)
|
|||
/* I/O Permissions section */
|
||||
/***************************************************************************/
|
||||
|
||||
#if defined(i386) || defined(__x86)
|
||||
#if defined(__i386__) || defined(__x86)
|
||||
static Bool ExtendedEnabled = FALSE;
|
||||
#endif
|
||||
|
||||
_X_EXPORT Bool
|
||||
xf86EnableIO(void)
|
||||
{
|
||||
#if defined(i386) || defined(__x86)
|
||||
#if defined(__i386__) || defined(__x86)
|
||||
if (ExtendedEnabled)
|
||||
return TRUE;
|
||||
|
||||
|
@ -171,7 +171,7 @@ xf86EnableIO(void)
|
|||
_X_EXPORT void
|
||||
xf86DisableIO(void)
|
||||
{
|
||||
#if defined(i386) || defined(__x86)
|
||||
#if defined(__i386__) || defined(__x86)
|
||||
if(!ExtendedEnabled)
|
||||
return;
|
||||
|
||||
|
@ -188,7 +188,7 @@ xf86DisableIO(void)
|
|||
|
||||
_X_EXPORT Bool xf86DisableInterrupts(void)
|
||||
{
|
||||
#if defined(i386) || defined(__x86)
|
||||
#if defined(__i386__) || defined(__x86)
|
||||
if (!ExtendedEnabled && (sysi86(SI86V86, V86SC_IOPL, PS_IOPL) < 0))
|
||||
return FALSE;
|
||||
|
||||
|
@ -207,7 +207,7 @@ _X_EXPORT Bool xf86DisableInterrupts(void)
|
|||
|
||||
_X_EXPORT void xf86EnableInterrupts(void)
|
||||
{
|
||||
#if defined(i386) || defined(__x86)
|
||||
#if defined(__i386__) || defined(__x86)
|
||||
if (!ExtendedEnabled && (sysi86(SI86V86, V86SC_IOPL, PS_IOPL) < 0))
|
||||
return;
|
||||
|
||||
|
|
|
@ -234,7 +234,7 @@ unmapVidMem(int ScreenNum, pointer Base, unsigned long Size)
|
|||
return;
|
||||
}
|
||||
|
||||
#if defined(SVR4) && defined(i386) && !defined(sun)
|
||||
#if defined(SVR4) && defined(__i386__) && !defined(sun)
|
||||
/*
|
||||
* For some SVR4 versions, a 32-bit read is done for the first location
|
||||
* in each page when the page is first mapped. If this is done while
|
||||
|
@ -270,7 +270,7 @@ xf86OSInitVidMem(VidMemInfoPtr pVidMem)
|
|||
pVidMem->linearSupported = linearVidMem();
|
||||
pVidMem->mapMem = mapVidMem;
|
||||
pVidMem->unmapMem = unmapVidMem;
|
||||
#if defined(SVR4) && defined(i386) && !defined(sun)
|
||||
#if defined(SVR4) && defined(__i386__) && !defined(sun)
|
||||
pVidMem->readSideEffects = readSideEffects;
|
||||
#endif
|
||||
pVidMem->initialised = TRUE;
|
||||
|
|
|
@ -100,7 +100,7 @@ typedef signed long xf86ssize_t;
|
|||
/**************************************************************************/
|
||||
#if (defined(SYSV) || defined(SVR4)) && \
|
||||
!defined(DGUX) && !defined(sgi) && \
|
||||
(defined(sun) || defined(i386))
|
||||
(defined(sun) || defined(__i386__))
|
||||
# ifdef SCO325
|
||||
# ifndef _SVID3
|
||||
# define _SVID3
|
||||
|
@ -140,7 +140,7 @@ typedef signed long xf86ssize_t;
|
|||
# endif /* SVR4 && !sun */
|
||||
/* V86SC_IOPL was moved to <sys/sysi86.h> on Solaris 7 and later */
|
||||
# if defined(sun) && defined (SVR4) /* Solaris? */
|
||||
# if defined(i386) || defined(__x86) /* on x86 or x64? */
|
||||
# if defined(__i386__) || defined(__x86) /* on x86 or x64? */
|
||||
# if !defined(V86SC_IOPL) /* Solaris 7 or later? */
|
||||
# include <sys/v86.h> /* Nope */
|
||||
# endif
|
||||
|
@ -148,7 +148,7 @@ typedef signed long xf86ssize_t;
|
|||
# else
|
||||
# include <sys/v86.h> /* Not solaris */
|
||||
# endif /* sun && i386 && SVR4 */
|
||||
# if defined(sun) && (defined (i386) || defined(__x86)) && defined (SVR4)
|
||||
# if defined(sun) && (defined (__i386__) || defined(__x86)) && defined (SVR4)
|
||||
# include <sys/psw.h>
|
||||
# endif
|
||||
# endif /* _NEED_SYSI86 */
|
||||
|
@ -224,15 +224,11 @@ typedef signed long xf86ssize_t;
|
|||
# define POSIX_TTY
|
||||
# endif
|
||||
|
||||
# if defined(sun) && defined (i386) && defined (SVR4) && !defined(__SOL8__)
|
||||
# if defined(sun) && defined (__i386__) && defined (SVR4) && !defined(__SOL8__)
|
||||
# define USE_VT_SYSREQ
|
||||
# define VT_SYSREQ_DEFAULT TRUE
|
||||
# endif
|
||||
|
||||
# if defined(ATT) && !defined(i386)
|
||||
# define i386 /* not defined in ANSI C mode */
|
||||
# endif /* ATT && !i386 */
|
||||
|
||||
# ifdef SYSV
|
||||
# if !defined(ISC) || defined(ISC202) || defined(ISC22)
|
||||
# define NEED_STRERROR
|
||||
|
|
|
@ -186,8 +186,6 @@ else\
|
|||
"The Inactive keyword must be followed by a Device name in quotes."
|
||||
#define UNDEFINED_SCREEN_MSG \
|
||||
"Undefined Screen \"%s\" referenced by ServerLayout \"%s\"."
|
||||
#define UNDEFINED_MONITOR_MSG \
|
||||
"Undefined Monitor \"%s\" referenced by Screen \"%s\"."
|
||||
#define UNDEFINED_MODES_MSG \
|
||||
"Undefined Modes Section \"%s\" referenced by Monitor \"%s\"."
|
||||
#define UNDEFINED_DEVICE_MSG \
|
||||
|
@ -204,8 +202,6 @@ else\
|
|||
"This section must have an Identifier line."
|
||||
#define ONLY_ONE_MSG \
|
||||
"This section must have only one of either %s line."
|
||||
#define UNDEFINED_DRIVER_MSG \
|
||||
"Device section \"%s\" must have a Driver line."
|
||||
#define UNDEFINED_INPUTDRIVER_MSG \
|
||||
"InputDevice section \"%s\" must have a Driver line."
|
||||
#define INVALID_GAMMA_MSG \
|
||||
|
|
|
@ -357,26 +357,6 @@ xf86freeDeviceList (XF86ConfDevicePtr ptr)
|
|||
}
|
||||
}
|
||||
|
||||
int
|
||||
xf86validateDevice (XF86ConfigPtr p)
|
||||
{
|
||||
XF86ConfDevicePtr device = p->conf_device_lst;
|
||||
|
||||
if (!device) {
|
||||
xf86validationError ("At least one Device section is required.");
|
||||
return (FALSE);
|
||||
}
|
||||
|
||||
while (device) {
|
||||
if (!device->dev_driver) {
|
||||
xf86validationError (UNDEFINED_DRIVER_MSG, device->dev_identifier);
|
||||
return (FALSE);
|
||||
}
|
||||
device = device->list.next;
|
||||
}
|
||||
return (TRUE);
|
||||
}
|
||||
|
||||
XF86ConfDevicePtr
|
||||
xf86findDevice (const char *ident, XF86ConfDevicePtr p)
|
||||
{
|
||||
|
|
|
@ -498,12 +498,6 @@ xf86validateScreen (XF86ConfigPtr p)
|
|||
XF86ConfDevicePtr device;
|
||||
XF86ConfAdaptorLinkPtr adaptor;
|
||||
|
||||
if (!screen)
|
||||
{
|
||||
xf86validationError ("At least one Screen section is required.");
|
||||
return (FALSE);
|
||||
}
|
||||
|
||||
while (screen)
|
||||
{
|
||||
if (screen->scrn_obso_driver && !screen->scrn_identifier)
|
||||
|
@ -512,13 +506,7 @@ xf86validateScreen (XF86ConfigPtr p)
|
|||
monitor = xf86findMonitor (screen->scrn_monitor_str, p->conf_monitor_lst);
|
||||
if (screen->scrn_monitor_str)
|
||||
{
|
||||
if (!monitor)
|
||||
{
|
||||
xf86validationError (UNDEFINED_MONITOR_MSG,
|
||||
screen->scrn_monitor_str, screen->scrn_identifier);
|
||||
return (FALSE);
|
||||
}
|
||||
else
|
||||
if (monitor)
|
||||
{
|
||||
screen->scrn_monitor = monitor;
|
||||
if (!xf86validateMonitor(p, screen))
|
||||
|
@ -526,15 +514,7 @@ xf86validateScreen (XF86ConfigPtr p)
|
|||
}
|
||||
}
|
||||
|
||||
device = xf86findDevice (screen->scrn_device_str, p->conf_device_lst);
|
||||
if (!device)
|
||||
{
|
||||
xf86validationError (UNDEFINED_DEVICE_MSG,
|
||||
screen->scrn_device_str, screen->scrn_identifier);
|
||||
return (FALSE);
|
||||
}
|
||||
else
|
||||
screen->scrn_device = device;
|
||||
screen->scrn_device= xf86findDevice (screen->scrn_device_str, p->conf_device_lst);
|
||||
|
||||
adaptor = screen->scrn_adaptor_lst;
|
||||
while (adaptor)
|
||||
|
|
|
@ -80,8 +80,6 @@ static xf86ConfigSymTabRec TopLevelTab[] =
|
|||
static int
|
||||
xf86validateConfig (XF86ConfigPtr p)
|
||||
{
|
||||
if (!xf86validateDevice (p))
|
||||
return FALSE;
|
||||
if (!xf86validateScreen (p))
|
||||
return FALSE;
|
||||
if (!xf86validateInput (p))
|
||||
|
|
|
@ -631,7 +631,7 @@ mouse_configuration(void) {
|
|||
config_emulate3buttons = 0;
|
||||
printf("\n");
|
||||
|
||||
#if (defined(sun) && (defined(__i386) || defined(__x86)))
|
||||
#if (defined(sun) && (defined(__i386__) || defined(__x86)))
|
||||
/* SPARC & USB mice (VUID or AUTO protocols) default to /dev/mouse,
|
||||
but PS/2 mice default to /dev/kdmouse */
|
||||
if ((config_mousetype != M_AUTO) && (config_mousetype != M_VUID)) {
|
||||
|
|
|
@ -54,7 +54,7 @@ static void fastFill
|
|||
{
|
||||
int stop_count = bytewidth ;
|
||||
register int row_jump = bytes_per_line - bytewidth ;
|
||||
#if !defined(OLDHC) && defined(BSDrt) && !defined(i386)
|
||||
#if !defined(OLDHC) && defined(BSDrt) && !defined(__i386__)
|
||||
register const unsigned int notZero = ((unsigned char)(~0x0));
|
||||
#else
|
||||
#define notZero ((unsigned char)(~0))
|
||||
|
@ -112,7 +112,7 @@ static void fastFillRMW
|
|||
{
|
||||
int stop_count = bytewidth ;
|
||||
register int row_jump = bytes_per_line - bytewidth ;
|
||||
#if !defined(OLDHC) && defined(BSDrt) && !defined(i386)
|
||||
#if !defined(OLDHC) && defined(BSDrt) && !defined(__i386__)
|
||||
register const unsigned int notZero = ((unsigned char)(~0x0));
|
||||
#endif
|
||||
register int tmp ;
|
||||
|
@ -369,7 +369,7 @@ register unsigned int height ; /* MUST BE > 0 !! */
|
|||
{
|
||||
int stop_count = wordwidth ;
|
||||
register int row_jump = bytes_per_line - wordwidth*2 ;
|
||||
#if !defined(OLDHC) && defined(BSDrt) && !defined(i386) && 0
|
||||
#if !defined(OLDHC) && defined(BSDrt) && !defined(__i386__) && 0
|
||||
register const int notZero = ~0x0 ;
|
||||
#else
|
||||
#define notZero ( ~0 )
|
||||
|
|
|
@ -45,10 +45,6 @@ is" without express or implied warranty.
|
|||
Window xnestDefaultWindows[MAXSCREENS];
|
||||
Window xnestScreenSaverWindows[MAXSCREENS];
|
||||
|
||||
#ifdef GLXEXT
|
||||
extern void GlxWrapInitVisuals(miInitVisualsProcPtr *);
|
||||
#endif
|
||||
|
||||
static int xnestScreenGeneration = -1;
|
||||
|
||||
ScreenPtr
|
||||
|
@ -230,17 +226,6 @@ xnestOpenScreen(int index, ScreenPtr pScreen, int argc, char *argv[])
|
|||
defaultVisual = visuals[xnestDefaultVisualIndex].vid;
|
||||
rootDepth = visuals[xnestDefaultVisualIndex].nplanes;
|
||||
|
||||
#ifdef GLXEXT
|
||||
{
|
||||
miInitVisualsProcPtr proc = NULL;
|
||||
|
||||
GlxWrapInitVisuals(&proc);
|
||||
/* GlxInitVisuals ignores the last three arguments. */
|
||||
proc(&visuals, &depths, &numVisuals, &numDepths,
|
||||
&rootDepth, &defaultVisual, 0, 0, 0);
|
||||
}
|
||||
#endif
|
||||
|
||||
if (xnestParentWindow != 0) {
|
||||
XGetWindowAttributes(xnestDisplay, xnestParentWindow, &gattributes);
|
||||
xnestWidth = gattributes.width;
|
||||
|
|
|
@ -184,6 +184,9 @@
|
|||
/* Define to 1 if you have the <rpcsvc/dbm.h> header file. */
|
||||
#undef HAVE_RPCSVC_DBM_H
|
||||
|
||||
/* Define to 1 if you have the `shmctl64' function. */
|
||||
#undef HAVE_SHMCTL64
|
||||
|
||||
/* Define to 1 if you have the <stdint.h> header file. */
|
||||
#undef HAVE_STDINT_H
|
||||
|
||||
|
@ -425,6 +428,8 @@
|
|||
/* Support DRI extension */
|
||||
#undef XF86DRI
|
||||
|
||||
#undef XEPHYR_DRI
|
||||
|
||||
/* Build DBE support */
|
||||
#undef DBE
|
||||
|
||||
|
|
|
@ -260,7 +260,7 @@ SOFTWARE.
|
|||
|
||||
#if defined(ibm032) || defined (ibm)
|
||||
|
||||
#ifdef i386
|
||||
#ifdef __i386__
|
||||
# define IMAGE_BYTE_ORDER LSBFirst /* Value for PS/2 only */
|
||||
#else
|
||||
# define IMAGE_BYTE_ORDER MSBFirst /* Values for the RT only*/
|
||||
|
@ -270,7 +270,7 @@ SOFTWARE.
|
|||
#define GETLEFTBITS_ALIGNMENT 4
|
||||
/* ibm pcc doesn't understand pragmas. */
|
||||
|
||||
#ifdef i386
|
||||
#ifdef __i386__
|
||||
#define BITMAP_SCANLINE_UNIT 8
|
||||
#endif
|
||||
|
||||
|
@ -444,10 +444,9 @@ SOFTWARE.
|
|||
|
||||
#endif /* luna */
|
||||
|
||||
#if (defined(SVR4) && defined(i386)) || \
|
||||
#if (defined(SVR4) && defined(__i386__)) || \
|
||||
defined(__alpha__) || defined(__alpha) || \
|
||||
defined(__i386__) || defined(__i386) || \
|
||||
defined(__QNX__) || \
|
||||
defined(__i386__) || defined(__QNX__) || \
|
||||
defined(__s390x__) || defined(__s390__)
|
||||
|
||||
#ifndef IMAGE_BYTE_ORDER
|
||||
|
|
|
@ -46,8 +46,7 @@
|
|||
#if defined(mips) || defined(sgi) || \
|
||||
defined(sparc) || defined(__sparc64__) || \
|
||||
defined(__alpha) || defined(__alpha__) || \
|
||||
defined(__i386__) || defined(i386) || \
|
||||
defined(__ia64__) || defined(ia64) || \
|
||||
defined(__i386__) || defined(__ia64__) || \
|
||||
defined(__s390x__) || defined(__s390__) || \
|
||||
defined(__amd64__) || defined(amd64) || defined(__amd64)
|
||||
#define GetHighWord(x) (((int) (x)) >> 16)
|
||||
|
|
|
@ -347,7 +347,6 @@ extern void DarwinGlxWrapInitVisuals(miInitVisualsProcPtr *);
|
|||
extern __GLXprovider __glXMesaProvider;
|
||||
extern void GlxPushProvider(__GLXprovider *impl);
|
||||
extern void GlxExtensionInit(INITARGS);
|
||||
extern void GlxWrapInitVisuals(miInitVisualsProcPtr *);
|
||||
#endif // INXDARWINAPP
|
||||
#endif // GLXEXT
|
||||
#ifdef XF86DRI
|
||||
|
@ -673,9 +672,7 @@ InitVisualWrap()
|
|||
{
|
||||
miResetInitVisuals();
|
||||
#ifdef GLXEXT
|
||||
#ifndef __DARWIN__
|
||||
GlxWrapInitVisuals(&miInitVisualsProc);
|
||||
#else
|
||||
#ifdef __DARWIN__
|
||||
DarwinGlxWrapInitVisuals(&miInitVisualsProc);
|
||||
#endif
|
||||
#endif
|
||||
|
|
|
@ -119,10 +119,10 @@ SOFTWARE.
|
|||
# include <net/if.h>
|
||||
# endif
|
||||
#else
|
||||
#if defined(SVR4) || (defined(SYSV) && defined(i386)) || defined(__GNU__)
|
||||
#if defined(SVR4) || (defined(SYSV) && defined(__i386__)) || defined(__GNU__)
|
||||
# include <sys/utsname.h>
|
||||
#endif
|
||||
#if defined(SYSV) && defined(i386)
|
||||
#if defined(SYSV) && defined(__i386__)
|
||||
# include <sys/stream.h>
|
||||
# ifdef ISC
|
||||
# include <sys/stropts.h>
|
||||
|
|
2
os/io.c
2
os/io.c
|
@ -356,7 +356,7 @@ ReadRequestFromClient(ClientPtr client)
|
|||
{
|
||||
if ((result < 0) && ETEST(errno))
|
||||
{
|
||||
#if defined(SVR4) && defined(i386) && !defined(sun)
|
||||
#if defined(SVR4) && defined(__i386__) && !defined(sun)
|
||||
if (0)
|
||||
#endif
|
||||
{
|
||||
|
|
|
@ -160,6 +160,7 @@ _X_EXPORT Bool noFontCacheExtension = FALSE;
|
|||
#endif
|
||||
#ifdef GLXEXT
|
||||
_X_EXPORT Bool noGlxExtension = FALSE;
|
||||
_X_EXPORT Bool noGlxVisualInit = FALSE;
|
||||
#endif
|
||||
#ifdef SCREENSAVER
|
||||
_X_EXPORT Bool noScreenSaverExtension = FALSE;
|
||||
|
|
|
@ -211,7 +211,7 @@ extern Bool Must_have_memory;
|
|||
fclose(f); \
|
||||
} \
|
||||
}
|
||||
#if defined(linux) && defined(i386)
|
||||
#if defined(linux) && defined(__i386__)
|
||||
#define LOG_ALLOC(_fun, _size, _ret) \
|
||||
{ unsigned long *from; \
|
||||
__asm__("movl %%ebp,%0" : /*OUT*/ "=r" (from) : /*IN*/ ); \
|
||||
|
|
|
@ -8,6 +8,6 @@ sdkdir=@sdkdir@
|
|||
Name: xorg-server
|
||||
Description: Modular X.Org X Server
|
||||
Version: @PACKAGE_VERSION@
|
||||
Requires.private: pixman-1
|
||||
Requires: pixman-1
|
||||
Cflags: -I${sdkdir}
|
||||
Libs: -L${libdir}
|
||||
|
|
Loading…
Reference in New Issue
Block a user