#ifdef HAVE_DMX_CONFIG_H
#include <dmx-config.h>
#endif
#include "dmx.h"
#include "dmxwindow.h"
#include "dmxpixmap.h"
#include "dmxfont.h"
#undef Xmalloc
#undef Xcalloc
#undef Xrealloc
#undef Xfree
#define NEED_REPLIES
#include "glxserver.h"
#include "glxext.h"
#include "g_disptab.h"
#include "unpack.h"
#include "glxutil.h"
#include "GL/glxproto.h"
#ifdef PANORAMIX
#include "panoramiXsrv.h"
#endif
#if (defined(__STDC__) && !defined(UNIXCPP)) || defined(ANSICPP)
#define GetReqVendorPrivate(name, req) \
WORD64ALIGN\
if ((dpy->bufptr + SIZEOF(x##name##Req)) > dpy->bufmax)\
_XFlush(dpy);\
req = (x##name##Req *)(dpy->last_req = dpy->bufptr);\
req->length = (SIZEOF(x##name##Req))>>2;\
dpy->bufptr += SIZEOF(x##name##Req);\
dpy->request++
#else
#define GetReqVendorPrivate(name, req) \
WORD64ALIGN\
if ((dpy->bufptr + SIZEOF(xnameReq)) > dpy->bufmax)\
_XFlush(dpy);\
req = (xnameReq *)(dpy->last_req = dpy->bufptr);\
req->length = (SIZEOF(xnameReq))>>2;\
dpy->bufptr += SIZEOF(xnameReq);\
dpy->request++
#endif
extern Display *GetBackEndDisplay( __GLXclientState *cl, int s );
extern int GetCurrentBackEndTag(__GLXclientState *cl, GLXContextTag tag, int s);
static int swap_vec_element_size = 0;
static void SendSwappedReply( ClientPtr client,
xGLXVendorPrivReply *reply,
char *buf,
int buf_size )
{
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_SHORT(&reply->sequenceNumber);
__GLX_SWAP_INT(&reply->length);
__GLX_SWAP_INT(&reply->retval);
__GLX_SWAP_INT(&reply->size);
if ( (buf_size == 0) && (swap_vec_element_size > 0) ) {
if (swap_vec_element_size == 2) {
__GLX_SWAP_SHORT(&reply->pad3);
}
else if (swap_vec_element_size == 4) {
__GLX_SWAP_INT(&reply->pad3);
__GLX_SWAP_INT(&reply->pad4);
}
else if (swap_vec_element_size == 8) {
__GLX_SWAP_DOUBLE(&reply->pad3);
}
}
else if ( (buf_size > 0) && (swap_vec_element_size > 0) ) {
int vsize = buf_size / swap_vec_element_size;
char *p = buf;
int i;
for (i=0; i<vsize; i++) {
if (swap_vec_element_size == 2) {
__GLX_SWAP_SHORT(p);
}
else if (swap_vec_element_size == 4) {
__GLX_SWAP_INT(p);
}
else if (swap_vec_element_size == 8) {
__GLX_SWAP_DOUBLE(p);
}
p += swap_vec_element_size;
}
__GLX_SWAP_INT(&reply->pad3);
__GLX_SWAP_INT(&reply->pad4);
__GLX_SWAP_INT(&reply->pad5);
__GLX_SWAP_INT(&reply->pad6);
}
WriteToClient(client, sizeof(xGLXVendorPrivReply),(char *)reply);
if (buf_size > 0)
WriteToClient(client, buf_size, (char *)buf);
}
int __glXVForwardSingleReq( __GLXclientState *cl, GLbyte *pc )
{
xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;
xGLXVendorPrivateReq *be_req;
__GLXcontext *glxc;
int from_screen = 0;
int to_screen = 0;
int buf_size;
int s;
glxc = __glXLookupContextByTag(cl, req->contextTag);
if (!glxc) {
return 0;
}
from_screen = to_screen = glxc->pScreen->myNum;
#ifdef PANORAMIX
if (!noPanoramiXExtension) {
from_screen = 0;
to_screen = screenInfo.numScreens - 1;
}
#endif
pc += sz_xGLXVendorPrivateReq;
buf_size = (req->length << 2) - sz_xGLXVendorPrivateReq;
for (s=from_screen; s<=to_screen; s++) {
DMXScreenInfo *dmxScreen = &dmxScreens[s];
Display *dpy = GetBackEndDisplay(cl,s);
LockDisplay(dpy);
GetReqVendorPrivate(GLXVendorPrivate,be_req);
be_req->reqType = dmxScreen->glxMajorOpcode;
be_req->glxCode = req->glxCode;
be_req->length = req->length;
be_req->vendorCode = req->vendorCode;
be_req->contextTag = GetCurrentBackEndTag(cl,req->contextTag,s);
if (buf_size > 0)
_XSend(dpy, (const char *)pc, buf_size);
UnlockDisplay(dpy);
SyncHandle();
}
return Success;
}
int __glXVForwardPipe0WithReply( __GLXclientState *cl, GLbyte *pc )
{
ClientPtr client = cl->client;
xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;
xGLXVendorPrivateReq *be_req;
xGLXVendorPrivReply reply;
xGLXVendorPrivReply be_reply;
__GLXcontext *glxc;
int buf_size;
char *be_buf;
int be_buf_size;
DMXScreenInfo *dmxScreen;
Display *dpy;
glxc = __glXLookupContextByTag(cl, req->contextTag);
if (!glxc) {
return __glXBadContext;
}
pc += sz_xGLXVendorPrivateReq;
buf_size = (req->length << 2) - sz_xGLXVendorPrivateReq;
dmxScreen = &dmxScreens[glxc->pScreen->myNum];
dpy = GetBackEndDisplay(cl, glxc->pScreen->myNum);
LockDisplay(dpy);
GetReqVendorPrivate(GLXVendorPrivate,be_req);
be_req->reqType = dmxScreen->glxMajorOpcode;
be_req->glxCode = req->glxCode;
be_req->length = req->length;
be_req->vendorCode = req->vendorCode;
be_req->contextTag = GetCurrentBackEndTag(cl,req->contextTag, glxc->pScreen->myNum);
if (buf_size > 0)
_XSend(dpy, (const char *)pc, buf_size);
_XReply(dpy, (xReply*) &be_reply, 0, False);
be_buf_size = be_reply.length << 2;
if (be_buf_size > 0) {
be_buf = (char *)Xalloc( be_buf_size );
if (be_buf) {
_XRead(dpy, be_buf, be_buf_size);
}
else {
_XEatData(dpy, be_buf_size);
return BadAlloc;
}
}
UnlockDisplay(dpy);
SyncHandle();
memcpy( &reply, &be_reply, sz_xGLXVendorPrivReply );
reply.type = X_Reply;
reply.sequenceNumber = client->sequence;
if (client->swapped) {
SendSwappedReply( client, &reply, be_buf, be_buf_size );
}
else {
WriteToClient(client, sizeof(xGLXVendorPrivReply),(char *)&reply);
if (be_buf_size > 0)
WriteToClient(client, be_buf_size, (char *)be_buf);
}
if (be_buf_size > 0) Xfree(be_buf);
return Success;
}
int __glXVForwardAllWithReply( __GLXclientState *cl, GLbyte *pc )
{
ClientPtr client = cl->client;
xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;
xGLXVendorPrivateReq *be_req;
xGLXVendorPrivReply reply;
xGLXVendorPrivReply be_reply;
__GLXcontext *glxc;
int buf_size;
char *be_buf;
int be_buf_size;
int from_screen = 0;
int to_screen = 0;
int s;
DMXScreenInfo *dmxScreen;
Display *dpy;
glxc = __glXLookupContextByTag(cl, req->contextTag);
if (!glxc) {
return 0;
}
from_screen = to_screen = glxc->pScreen->myNum;
#ifdef PANORAMIX
if (!noPanoramiXExtension) {
from_screen = 0;
to_screen = screenInfo.numScreens - 1;
}
#endif
pc += sz_xGLXVendorPrivateReq;
buf_size = (req->length << 2) - sz_xGLXVendorPrivateReq;
for (s=to_screen; s>=from_screen; s--) {
dmxScreen = &dmxScreens[s];
dpy = GetBackEndDisplay(cl,s);
LockDisplay(dpy);
GetReqVendorPrivate(GLXVendorPrivate,be_req);
be_req->reqType = dmxScreen->glxMajorOpcode;
be_req->glxCode = req->glxCode;
be_req->length = req->length;
be_req->vendorCode = req->vendorCode;
be_req->contextTag = GetCurrentBackEndTag(cl,req->contextTag,s);
if (buf_size > 0)
_XSend(dpy, (const char *)pc, buf_size);
_XReply(dpy, (xReply*) &be_reply, 0, False);
be_buf_size = be_reply.length << 2;
if (be_buf_size > 0) {
be_buf = (char *)Xalloc( be_buf_size );
if (be_buf) {
_XRead(dpy, be_buf, be_buf_size);
}
else {
_XEatData(dpy, be_buf_size);
return BadAlloc;
}
}
UnlockDisplay(dpy);
SyncHandle();
if (s > from_screen && be_buf_size > 0) {
Xfree(be_buf);
}
}
memcpy( &reply, &be_reply, sz_xGLXVendorPrivReply );
reply.type = X_Reply;
reply.sequenceNumber = client->sequence;
if (client->swapped) {
SendSwappedReply( client, &reply, be_buf, be_buf_size );
}
else {
WriteToClient(client, sizeof(xGLXVendorPrivReply),(char *)&reply);
if (be_buf_size > 0)
WriteToClient(client, be_buf_size, (char *)be_buf);
}
if (be_buf_size > 0) Xfree(be_buf);
return Success;
}
int __glXVForwardSingleReqSwap( __GLXclientState *cl, GLbyte *pc )
{
xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_SHORT(&req->length);
__GLX_SWAP_INT(&req->vendorCode);
__GLX_SWAP_INT(&req->contextTag);
swap_vec_element_size = 0;
return( __glXVForwardSingleReq( cl, pc ) );
}
int __glXVForwardPipe0WithReplySwap( __GLXclientState *cl, GLbyte *pc )
{
xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_SHORT(&req->length);
__GLX_SWAP_INT(&req->vendorCode);
__GLX_SWAP_INT(&req->contextTag);
swap_vec_element_size = 0;
if (req->length > sz_xGLXVendorPrivateReq/4) {
int *data = (int *)(req+1);
int count = req->length - sz_xGLXVendorPrivateReq/4;
__GLX_SWAP_INT_ARRAY(data, count );
}
return( __glXVForwardPipe0WithReply( cl, pc ) );
}
int __glXVForwardPipe0WithReplySwapsv( __GLXclientState *cl, GLbyte *pc )
{
xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_SHORT(&req->length);
__GLX_SWAP_INT(&req->vendorCode);
__GLX_SWAP_INT(&req->contextTag);
swap_vec_element_size = 2;
if (req->length > sz_xGLXVendorPrivateReq/4) {
int *data = (int *)(req+1);
int count = req->length - sz_xGLXVendorPrivateReq/4;
__GLX_SWAP_INT_ARRAY(data, count );
}
return( __glXVForwardPipe0WithReply( cl, pc ) );
}
int __glXVForwardPipe0WithReplySwapiv( __GLXclientState *cl, GLbyte *pc )
{
xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_SHORT(&req->length);
__GLX_SWAP_INT(&req->vendorCode);
__GLX_SWAP_INT(&req->contextTag);
swap_vec_element_size = 4;
if (req->length > sz_xGLXVendorPrivateReq/4) {
int *data = (int *)(req+1);
int count = req->length - sz_xGLXVendorPrivateReq/4;
__GLX_SWAP_INT_ARRAY(data, count );
}
return( __glXVForwardPipe0WithReply( cl, pc ) );
}
int __glXVForwardPipe0WithReplySwapdv( __GLXclientState *cl, GLbyte *pc )
{
xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_SHORT(&req->length);
__GLX_SWAP_INT(&req->vendorCode);
__GLX_SWAP_INT(&req->contextTag);
swap_vec_element_size = 8;
if (req->length > sz_xGLXVendorPrivateReq/4) {
int *data = (int *)(req+1);
int count = req->length - sz_xGLXVendorPrivateReq/4;
__GLX_SWAP_INT_ARRAY(data, count );
}
return( __glXVForwardPipe0WithReply( cl, pc ) );
}
int __glXVForwardAllWithReplySwap( __GLXclientState *cl, GLbyte *pc )
{
xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_SHORT(&req->length);
__GLX_SWAP_INT(&req->vendorCode);
__GLX_SWAP_INT(&req->contextTag);
swap_vec_element_size = 0;
if (req->length > sz_xGLXVendorPrivateReq/4) {
int *data = (int *)(req+1);
int count = req->length - sz_xGLXVendorPrivateReq/4;
__GLX_SWAP_INT_ARRAY(data, count );
}
return( __glXVForwardAllWithReply( cl, pc ) );
}
int __glXVForwardAllWithReplySwapsv( __GLXclientState *cl, GLbyte *pc )
{
xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_SHORT(&req->length);
__GLX_SWAP_INT(&req->vendorCode);
__GLX_SWAP_INT(&req->contextTag);
swap_vec_element_size = 2;
if (req->length > sz_xGLXVendorPrivateReq/4) {
int *data = (int *)(req+1);
int count = req->length - sz_xGLXVendorPrivateReq/4;
__GLX_SWAP_INT_ARRAY(data, count );
}
return( __glXVForwardAllWithReply( cl, pc ) );
}
int __glXVForwardAllWithReplySwapiv( __GLXclientState *cl, GLbyte *pc )
{
xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_SHORT(&req->length);
__GLX_SWAP_INT(&req->vendorCode);
__GLX_SWAP_INT(&req->contextTag);
swap_vec_element_size = 4;
if (req->length > sz_xGLXVendorPrivateReq/4) {
int *data = (int *)(req+1);
int count = req->length - sz_xGLXVendorPrivateReq/4;
__GLX_SWAP_INT_ARRAY(data, count );
}
return( __glXVForwardAllWithReply( cl, pc ) );
}
int __glXVForwardAllWithReplySwapdv( __GLXclientState *cl, GLbyte *pc )
{
xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *)pc;
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_SHORT(&req->length);
__GLX_SWAP_INT(&req->vendorCode);
__GLX_SWAP_INT(&req->contextTag);
swap_vec_element_size = 8;
if (req->length > sz_xGLXVendorPrivateReq/4) {
int *data = (int *)(req+1);
int count = req->length - sz_xGLXVendorPrivateReq/4;
__GLX_SWAP_INT_ARRAY(data, count );
}
return( __glXVForwardAllWithReply( cl, pc ) );
}