1068 lines
30 KiB
C
1068 lines
30 KiB
C
/* DO NOT EDIT - THIS FILE IS AUTOMATICALLY GENERATED */
|
|
/*
|
|
* SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
|
|
* Copyright (C) 1991-2000 Silicon Graphics, 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, sublicense,
|
|
* 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 including the dates of first publication and
|
|
* either this permission notice or a reference to
|
|
* http://oss.sgi.com/projects/FreeB/
|
|
* 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 NONINFRINGEMENT. IN NO EVENT SHALL
|
|
* SILICON GRAPHICS, INC. 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.
|
|
*
|
|
* Except as contained in this notice, the name of Silicon Graphics, Inc.
|
|
* shall not be used in advertising or otherwise to promote the sale, use or
|
|
* other dealings in this Software without prior written authorization from
|
|
* Silicon Graphics, Inc.
|
|
*/
|
|
|
|
#ifdef HAVE_DMX_CONFIG_H
|
|
#include <dmx-config.h>
|
|
#endif
|
|
|
|
#include "dmx.h"
|
|
#include "dmxwindow.h"
|
|
#include "dmxpixmap.h"
|
|
#include "dmxfont.h"
|
|
#include "dmxcb.h"
|
|
|
|
#include "glxserver.h"
|
|
#include "glxext.h"
|
|
#include "g_disptab.h"
|
|
/* #include "g_disptab_EXT.h" */
|
|
#include "unpack.h"
|
|
#include "glxutil.h"
|
|
#include "glxcmds.h"
|
|
#include "glxsingle.h"
|
|
|
|
#include "GL/glxproto.h"
|
|
|
|
#ifdef PANORAMIX
|
|
#include "panoramiXsrv.h"
|
|
#endif
|
|
|
|
/*
|
|
* GetReqSingle - this is the equivalent of GetReq macro
|
|
* from Xlibint.h but it does not set the reqType field (the opcode).
|
|
* this is because the GL single opcodes has different naming convension
|
|
* the other X opcodes (ie. X_GLsop_GetFloatv).
|
|
*/
|
|
#if (defined(__STDC__) && !defined(UNIXCPP)) || defined(ANSICPP)
|
|
#define GetReqSingle(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 /* non-ANSI C uses empty comment instead of "##" for token concatenation */
|
|
#define GetReqSingle(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++
|
|
#endif
|
|
|
|
#define X_GLXSingle 0 /* needed by GetReqExtra */
|
|
|
|
static int swap_vec_element_size = 0;
|
|
|
|
static void
|
|
SendSwappedReply(ClientPtr client,
|
|
xGLXSingleReply * 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)) {
|
|
/*
|
|
* the reply has single component - need to swap pad3
|
|
*/
|
|
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); /* some requests use also pad4
|
|
* i.e GetConvolutionFilter
|
|
*/
|
|
}
|
|
else if (swap_vec_element_size == 8) {
|
|
__GLX_SWAP_DOUBLE(&reply->pad3);
|
|
}
|
|
}
|
|
else if ((buf_size > 0) && (swap_vec_element_size > 0)) {
|
|
/*
|
|
* the reply has vector of elements which needs to be swapped
|
|
*/
|
|
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;
|
|
}
|
|
|
|
/*
|
|
* swap pad words as well - for case that some single reply uses
|
|
* them as well
|
|
*/
|
|
__GLX_SWAP_INT(&reply->pad3);
|
|
__GLX_SWAP_INT(&reply->pad4);
|
|
__GLX_SWAP_INT(&reply->pad5);
|
|
__GLX_SWAP_INT(&reply->pad6);
|
|
|
|
}
|
|
|
|
WriteToClient(client, sizeof(xGLXSingleReply), reply);
|
|
if (buf_size > 0)
|
|
WriteToClient(client, buf_size, buf);
|
|
|
|
}
|
|
|
|
int
|
|
__glXForwardSingleReq(__GLXclientState * cl, GLbyte * pc)
|
|
{
|
|
xGLXSingleReq *req = (xGLXSingleReq *) pc;
|
|
xGLXSingleReq *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_xGLXSingleReq;
|
|
buf_size = (req->length << 2) - sz_xGLXSingleReq;
|
|
|
|
/*
|
|
* just forward the request to back-end server(s)
|
|
*/
|
|
for (s = from_screen; s <= to_screen; s++) {
|
|
DMXScreenInfo *dmxScreen = &dmxScreens[s];
|
|
Display *dpy = GetBackEndDisplay(cl, s);
|
|
|
|
LockDisplay(dpy);
|
|
GetReqSingle(GLXSingle, be_req);
|
|
be_req->reqType = dmxScreen->glxMajorOpcode;
|
|
be_req->glxCode = req->glxCode;
|
|
be_req->length = req->length;
|
|
be_req->contextTag = GetCurrentBackEndTag(cl, req->contextTag, s);
|
|
if (buf_size > 0)
|
|
_XSend(dpy, (const char *) pc, buf_size);
|
|
UnlockDisplay(dpy);
|
|
SyncHandle();
|
|
|
|
if (req->glxCode == X_GLsop_Flush) {
|
|
XFlush(dpy);
|
|
}
|
|
|
|
}
|
|
|
|
return Success;
|
|
}
|
|
|
|
int
|
|
__glXForwardPipe0WithReply(__GLXclientState * cl, GLbyte * pc)
|
|
{
|
|
ClientPtr client = cl->client;
|
|
xGLXSingleReq *req = (xGLXSingleReq *) pc;
|
|
xGLXSingleReq *be_req;
|
|
xGLXSingleReply reply;
|
|
xGLXSingleReply be_reply;
|
|
__GLXcontext *glxc;
|
|
int buf_size;
|
|
char *be_buf = NULL;
|
|
int be_buf_size;
|
|
DMXScreenInfo *dmxScreen;
|
|
Display *dpy;
|
|
|
|
glxc = __glXLookupContextByTag(cl, req->contextTag);
|
|
if (!glxc) {
|
|
return __glXBadContext;
|
|
}
|
|
|
|
pc += sz_xGLXSingleReq;
|
|
buf_size = (req->length << 2) - sz_xGLXSingleReq;
|
|
|
|
dmxScreen = &dmxScreens[glxc->pScreen->myNum];
|
|
dpy = GetBackEndDisplay(cl, glxc->pScreen->myNum);
|
|
|
|
/*
|
|
* send the request to the first back-end server
|
|
*/
|
|
LockDisplay(dpy);
|
|
GetReqSingle(GLXSingle, be_req);
|
|
be_req->reqType = dmxScreen->glxMajorOpcode;
|
|
be_req->glxCode = req->glxCode;
|
|
be_req->length = req->length;
|
|
be_req->contextTag =
|
|
GetCurrentBackEndTag(cl, req->contextTag, glxc->pScreen->myNum);
|
|
if (buf_size > 0)
|
|
_XSend(dpy, (const char *) pc, buf_size);
|
|
|
|
/*
|
|
* get the reply from the back-end server
|
|
*/
|
|
_XReply(dpy, (xReply *) &be_reply, 0, False);
|
|
be_buf_size = be_reply.length << 2;
|
|
if (be_buf_size > 0) {
|
|
be_buf = (char *) malloc(be_buf_size);
|
|
if (be_buf) {
|
|
_XRead(dpy, be_buf, be_buf_size);
|
|
}
|
|
else {
|
|
/* Throw data on the floor */
|
|
_XEatDataWords(dpy, be_reply.length);
|
|
return BadAlloc;
|
|
}
|
|
}
|
|
|
|
UnlockDisplay(dpy);
|
|
SyncHandle();
|
|
|
|
/*
|
|
* send the reply to the client
|
|
*/
|
|
reply = (xGLXSingleReply) {
|
|
.type = X_Reply,
|
|
.sequenceNumber = client->sequence,
|
|
.length = be_reply.length,
|
|
.retval = be_reply.retval,
|
|
.size = be_reply.size,
|
|
.pad3 = be_reply.pad3,
|
|
.pad4 = be_reply.pad4
|
|
};
|
|
|
|
if (client->swapped) {
|
|
SendSwappedReply(client, &reply, be_buf, be_buf_size);
|
|
}
|
|
else {
|
|
WriteToClient(client, sizeof(xGLXSingleReply), &reply);
|
|
if (be_buf_size > 0)
|
|
WriteToClient(client, be_buf_size, be_buf);
|
|
}
|
|
|
|
if (be_buf_size > 0)
|
|
free(be_buf);
|
|
|
|
return Success;
|
|
}
|
|
|
|
int
|
|
__glXForwardAllWithReply(__GLXclientState * cl, GLbyte * pc)
|
|
{
|
|
ClientPtr client = cl->client;
|
|
xGLXSingleReq *req = (xGLXSingleReq *) pc;
|
|
xGLXSingleReq *be_req;
|
|
xGLXSingleReply reply;
|
|
xGLXSingleReply be_reply;
|
|
__GLXcontext *glxc;
|
|
int buf_size;
|
|
char *be_buf = NULL;
|
|
int be_buf_size = 0;
|
|
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_xGLXSingleReq;
|
|
buf_size = (req->length << 2) - sz_xGLXSingleReq;
|
|
|
|
/*
|
|
* send the request to the first back-end server(s)
|
|
*/
|
|
for (s = to_screen; s >= from_screen; s--) {
|
|
dmxScreen = &dmxScreens[s];
|
|
dpy = GetBackEndDisplay(cl, s);
|
|
|
|
LockDisplay(dpy);
|
|
GetReqSingle(GLXSingle, be_req);
|
|
be_req->reqType = dmxScreen->glxMajorOpcode;
|
|
be_req->glxCode = req->glxCode;
|
|
be_req->length = req->length;
|
|
be_req->contextTag = GetCurrentBackEndTag(cl, req->contextTag, s);
|
|
if (buf_size > 0)
|
|
_XSend(dpy, (const char *) pc, buf_size);
|
|
|
|
/*
|
|
* get the reply from the back-end server
|
|
*/
|
|
_XReply(dpy, (xReply *) &be_reply, 0, False);
|
|
if (s == from_screen) {
|
|
/* Save data from last reply to send on to client */
|
|
be_buf_size = be_reply.length << 2;
|
|
if (be_buf_size > 0) {
|
|
be_buf = malloc(be_buf_size);
|
|
if (be_buf) {
|
|
_XRead(dpy, be_buf, be_buf_size);
|
|
}
|
|
else {
|
|
/* Throw data on the floor */
|
|
_XEatDataWords(dpy, be_reply.length);
|
|
return BadAlloc;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
/* Just discard data from all replies before the last one */
|
|
if (be_reply.length > 0)
|
|
_XEatDataWords(dpy, be_reply.length);
|
|
}
|
|
|
|
UnlockDisplay(dpy);
|
|
SyncHandle();
|
|
}
|
|
|
|
/*
|
|
* send the reply to the client
|
|
*/
|
|
reply = (xGLXSingleReply) {
|
|
.type = X_Reply,
|
|
.sequenceNumber = client->sequence,
|
|
.length = be_reply.length,
|
|
.retval = be_reply.retval,
|
|
.size = be_reply.size,
|
|
.pad3 = be_reply.pad3,
|
|
.pad4 = be_reply.pad4
|
|
};
|
|
|
|
if (client->swapped) {
|
|
SendSwappedReply(client, &reply, be_buf, be_buf_size);
|
|
}
|
|
else {
|
|
WriteToClient(client, sizeof(xGLXSingleReply), &reply);
|
|
if (be_buf_size > 0)
|
|
WriteToClient(client, be_buf_size, be_buf);
|
|
}
|
|
|
|
if (be_buf_size > 0)
|
|
free(be_buf);
|
|
|
|
return Success;
|
|
}
|
|
|
|
int
|
|
__glXForwardSingleReqSwap(__GLXclientState * cl, GLbyte * pc)
|
|
{
|
|
xGLXSingleReq *req = (xGLXSingleReq *) pc;
|
|
|
|
__GLX_DECLARE_SWAP_VARIABLES;
|
|
__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
|
|
|
|
__GLX_SWAP_SHORT(&req->length);
|
|
__GLX_SWAP_INT(&req->contextTag);
|
|
|
|
swap_vec_element_size = 0;
|
|
|
|
/*
|
|
* swap extra data in request - assuming all data
|
|
* (if available) are arrays of 4 bytes components !
|
|
*/
|
|
if (req->length > sz_xGLXSingleReq / 4) {
|
|
int *data = (int *) (req + 1);
|
|
int count = req->length - sz_xGLXSingleReq / 4;
|
|
|
|
__GLX_SWAP_INT_ARRAY(data, count);
|
|
}
|
|
|
|
return (__glXForwardSingleReq(cl, pc));
|
|
}
|
|
|
|
int
|
|
__glXForwardPipe0WithReplySwap(__GLXclientState * cl, GLbyte * pc)
|
|
{
|
|
xGLXSingleReq *req = (xGLXSingleReq *) pc;
|
|
|
|
__GLX_DECLARE_SWAP_VARIABLES;
|
|
__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
|
|
|
|
__GLX_SWAP_SHORT(&req->length);
|
|
__GLX_SWAP_INT(&req->contextTag);
|
|
|
|
swap_vec_element_size = 0;
|
|
|
|
/*
|
|
* swap extra data in request - assuming all data
|
|
* (if available) are arrays of 4 bytes components !
|
|
*/
|
|
if (req->length > sz_xGLXSingleReq / 4) {
|
|
int *data = (int *) (req + 1);
|
|
int count = req->length - sz_xGLXSingleReq / 4;
|
|
|
|
__GLX_SWAP_INT_ARRAY(data, count);
|
|
}
|
|
|
|
return (__glXForwardPipe0WithReply(cl, pc));
|
|
}
|
|
|
|
int
|
|
__glXForwardPipe0WithReplySwapsv(__GLXclientState * cl, GLbyte * pc)
|
|
{
|
|
xGLXSingleReq *req = (xGLXSingleReq *) pc;
|
|
|
|
__GLX_DECLARE_SWAP_VARIABLES;
|
|
__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
|
|
|
|
__GLX_SWAP_SHORT(&req->length);
|
|
__GLX_SWAP_INT(&req->contextTag);
|
|
|
|
swap_vec_element_size = 2;
|
|
|
|
/*
|
|
* swap extra data in request - assuming all data
|
|
* (if available) are arrays of 4 bytes components !
|
|
*/
|
|
if (req->length > sz_xGLXSingleReq / 4) {
|
|
int *data = (int *) (req + 1);
|
|
int count = req->length - sz_xGLXSingleReq / 4;
|
|
|
|
__GLX_SWAP_INT_ARRAY(data, count);
|
|
}
|
|
|
|
return (__glXForwardPipe0WithReply(cl, pc));
|
|
}
|
|
|
|
int
|
|
__glXForwardPipe0WithReplySwapiv(__GLXclientState * cl, GLbyte * pc)
|
|
{
|
|
xGLXSingleReq *req = (xGLXSingleReq *) pc;
|
|
|
|
__GLX_DECLARE_SWAP_VARIABLES;
|
|
__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
|
|
|
|
__GLX_SWAP_SHORT(&req->length);
|
|
__GLX_SWAP_INT(&req->contextTag);
|
|
|
|
swap_vec_element_size = 4;
|
|
|
|
/*
|
|
* swap extra data in request - assuming all data
|
|
* (if available) are arrays of 4 bytes components !
|
|
*/
|
|
if (req->length > sz_xGLXSingleReq / 4) {
|
|
int *data = (int *) (req + 1);
|
|
int count = req->length - sz_xGLXSingleReq / 4;
|
|
|
|
__GLX_SWAP_INT_ARRAY(data, count);
|
|
}
|
|
|
|
return (__glXForwardPipe0WithReply(cl, pc));
|
|
}
|
|
|
|
int
|
|
__glXForwardPipe0WithReplySwapdv(__GLXclientState * cl, GLbyte * pc)
|
|
{
|
|
xGLXSingleReq *req = (xGLXSingleReq *) pc;
|
|
|
|
__GLX_DECLARE_SWAP_VARIABLES;
|
|
__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
|
|
|
|
__GLX_SWAP_SHORT(&req->length);
|
|
__GLX_SWAP_INT(&req->contextTag);
|
|
|
|
swap_vec_element_size = 8;
|
|
|
|
/*
|
|
* swap extra data in request - assuming all data
|
|
* (if available) are arrays of 4 bytes components !
|
|
*/
|
|
if (req->length > sz_xGLXSingleReq / 4) {
|
|
int *data = (int *) (req + 1);
|
|
int count = req->length - sz_xGLXSingleReq / 4;
|
|
|
|
__GLX_SWAP_INT_ARRAY(data, count);
|
|
}
|
|
|
|
return (__glXForwardPipe0WithReply(cl, pc));
|
|
}
|
|
|
|
int
|
|
__glXForwardAllWithReplySwap(__GLXclientState * cl, GLbyte * pc)
|
|
{
|
|
xGLXSingleReq *req = (xGLXSingleReq *) pc;
|
|
|
|
__GLX_DECLARE_SWAP_VARIABLES;
|
|
__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
|
|
|
|
__GLX_SWAP_SHORT(&req->length);
|
|
__GLX_SWAP_INT(&req->contextTag);
|
|
|
|
swap_vec_element_size = 0;
|
|
|
|
/*
|
|
* swap extra data in request - assuming all data
|
|
* (if available) are arrays of 4 bytes components !
|
|
*/
|
|
if (req->length > sz_xGLXSingleReq / 4) {
|
|
int *data = (int *) (req + 1);
|
|
int count = req->length - sz_xGLXSingleReq / 4;
|
|
|
|
__GLX_SWAP_INT_ARRAY(data, count);
|
|
}
|
|
|
|
return (__glXForwardAllWithReply(cl, pc));
|
|
}
|
|
|
|
int
|
|
__glXForwardAllWithReplySwapsv(__GLXclientState * cl, GLbyte * pc)
|
|
{
|
|
xGLXSingleReq *req = (xGLXSingleReq *) pc;
|
|
|
|
__GLX_DECLARE_SWAP_VARIABLES;
|
|
__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
|
|
|
|
__GLX_SWAP_SHORT(&req->length);
|
|
__GLX_SWAP_INT(&req->contextTag);
|
|
|
|
swap_vec_element_size = 2;
|
|
|
|
/*
|
|
* swap extra data in request - assuming all data
|
|
* (if available) are arrays of 4 bytes components !
|
|
*/
|
|
if (req->length > sz_xGLXSingleReq / 4) {
|
|
int *data = (int *) (req + 1);
|
|
int count = req->length - sz_xGLXSingleReq / 4;
|
|
|
|
__GLX_SWAP_INT_ARRAY(data, count);
|
|
}
|
|
|
|
return (__glXForwardAllWithReply(cl, pc));
|
|
}
|
|
|
|
int
|
|
__glXForwardAllWithReplySwapiv(__GLXclientState * cl, GLbyte * pc)
|
|
{
|
|
xGLXSingleReq *req = (xGLXSingleReq *) pc;
|
|
|
|
__GLX_DECLARE_SWAP_VARIABLES;
|
|
__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
|
|
|
|
__GLX_SWAP_SHORT(&req->length);
|
|
__GLX_SWAP_INT(&req->contextTag);
|
|
|
|
swap_vec_element_size = 4;
|
|
|
|
/*
|
|
* swap extra data in request - assuming all data
|
|
* (if available) are arrays of 4 bytes components !
|
|
*/
|
|
if (req->length > sz_xGLXSingleReq / 4) {
|
|
int *data = (int *) (req + 1);
|
|
int count = req->length - sz_xGLXSingleReq / 4;
|
|
|
|
__GLX_SWAP_INT_ARRAY(data, count);
|
|
}
|
|
|
|
return (__glXForwardAllWithReply(cl, pc));
|
|
}
|
|
|
|
int
|
|
__glXForwardAllWithReplySwapdv(__GLXclientState * cl, GLbyte * pc)
|
|
{
|
|
xGLXSingleReq *req = (xGLXSingleReq *) pc;
|
|
|
|
__GLX_DECLARE_SWAP_VARIABLES;
|
|
__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
|
|
|
|
__GLX_SWAP_SHORT(&req->length);
|
|
__GLX_SWAP_INT(&req->contextTag);
|
|
|
|
swap_vec_element_size = 8;
|
|
|
|
/*
|
|
* swap extra data in request - assuming all data
|
|
* (if available) are arrays of 4 bytes components !
|
|
*/
|
|
if (req->length > sz_xGLXSingleReq / 4) {
|
|
int *data = (int *) (req + 1);
|
|
int count = req->length - sz_xGLXSingleReq / 4;
|
|
|
|
__GLX_SWAP_INT_ARRAY(data, count);
|
|
}
|
|
|
|
return (__glXForwardAllWithReply(cl, pc));
|
|
}
|
|
|
|
static GLint
|
|
__glReadPixels_size(GLenum format, GLenum type, GLint w, GLint h,
|
|
int *elementbits_return, int *rowbytes_return)
|
|
{
|
|
GLint elements, esize;
|
|
GLint rowsize, padding;
|
|
|
|
if (w < 0 || h < 0) {
|
|
return -1;
|
|
}
|
|
switch (format) {
|
|
case GL_COLOR_INDEX:
|
|
case GL_STENCIL_INDEX:
|
|
case GL_DEPTH_COMPONENT:
|
|
elements = 1;
|
|
break;
|
|
case GL_RED:
|
|
case GL_GREEN:
|
|
case GL_BLUE:
|
|
case GL_ALPHA:
|
|
case GL_LUMINANCE:
|
|
elements = 1;
|
|
break;
|
|
case GL_LUMINANCE_ALPHA:
|
|
elements = 2;
|
|
break;
|
|
case GL_RGB:
|
|
case GL_BGR:
|
|
elements = 3;
|
|
break;
|
|
case GL_RGBA:
|
|
case GL_BGRA:
|
|
case GL_ABGR_EXT:
|
|
elements = 4;
|
|
break;
|
|
default:
|
|
return -1;
|
|
}
|
|
/*
|
|
** According to the GLX protocol, each row must be padded to a multiple of
|
|
** 4 bytes. 4 bytes also happens to be the default alignment in the pixel
|
|
** store modes of the GL.
|
|
*/
|
|
switch (type) {
|
|
case GL_BITMAP:
|
|
if (format == GL_COLOR_INDEX || format == GL_STENCIL_INDEX) {
|
|
rowsize = ((w * elements) + 7) / 8;
|
|
padding = rowsize % 4;
|
|
if (padding) {
|
|
rowsize += 4 - padding;
|
|
}
|
|
if (elementbits_return)
|
|
*elementbits_return = elements;
|
|
if (rowbytes_return)
|
|
*rowbytes_return = rowsize;
|
|
return rowsize * h;
|
|
}
|
|
else {
|
|
return -1;
|
|
}
|
|
case GL_BYTE:
|
|
case GL_UNSIGNED_BYTE:
|
|
esize = 1;
|
|
break;
|
|
case GL_UNSIGNED_BYTE_3_3_2:
|
|
case GL_UNSIGNED_BYTE_2_3_3_REV:
|
|
esize = 1;
|
|
elements = 1;
|
|
break;
|
|
case GL_SHORT:
|
|
case GL_UNSIGNED_SHORT:
|
|
esize = 2;
|
|
break;
|
|
case GL_UNSIGNED_SHORT_5_6_5:
|
|
case GL_UNSIGNED_SHORT_5_6_5_REV:
|
|
case GL_UNSIGNED_SHORT_4_4_4_4:
|
|
case GL_UNSIGNED_SHORT_4_4_4_4_REV:
|
|
case GL_UNSIGNED_SHORT_5_5_5_1:
|
|
case GL_UNSIGNED_SHORT_1_5_5_5_REV:
|
|
esize = 2;
|
|
elements = 1;
|
|
break;
|
|
case GL_INT:
|
|
case GL_UNSIGNED_INT:
|
|
case GL_FLOAT:
|
|
esize = 4;
|
|
break;
|
|
case GL_UNSIGNED_INT_8_8_8_8:
|
|
case GL_UNSIGNED_INT_8_8_8_8_REV:
|
|
case GL_UNSIGNED_INT_10_10_10_2:
|
|
case GL_UNSIGNED_INT_2_10_10_10_REV:
|
|
esize = 4;
|
|
elements = 1;
|
|
break;
|
|
default:
|
|
return -1;
|
|
}
|
|
rowsize = w * elements * esize;
|
|
padding = rowsize % 4;
|
|
if (padding) {
|
|
rowsize += 4 - padding;
|
|
}
|
|
|
|
if (elementbits_return)
|
|
*elementbits_return = esize * elements * 8;
|
|
if (rowbytes_return)
|
|
*rowbytes_return = rowsize;
|
|
|
|
return rowsize * h;
|
|
}
|
|
|
|
static int
|
|
intersectRect(int x1, int x2, int y1, int y2,
|
|
int X1, int X2, int Y1, int Y2,
|
|
int *ix1, int *ix2, int *iy1, int *iy2)
|
|
{
|
|
int right = (x2 < X2 ? x2 : X2);
|
|
int bottom = (y2 < Y2 ? y2 : Y2);
|
|
int left = (x1 > X1 ? x1 : X1);
|
|
int top = (y1 > Y1 ? y1 : Y1);
|
|
int width = right - left + 1;
|
|
int height = bottom - top + 1;
|
|
|
|
if ((width <= 0) || (height <= 0)) {
|
|
*ix1 = *ix2 = *iy1 = *iy2 = 0;
|
|
return 0;
|
|
}
|
|
else {
|
|
*ix1 = left;
|
|
*ix2 = right;
|
|
*iy1 = top;
|
|
*iy2 = bottom;
|
|
return width * height;
|
|
}
|
|
|
|
}
|
|
|
|
int
|
|
__glXDisp_ReadPixels(__GLXclientState * cl, GLbyte * pc)
|
|
{
|
|
xGLXSingleReq *req = (xGLXSingleReq *) pc;
|
|
xGLXSingleReq *be_req;
|
|
xGLXReadPixelsReply reply;
|
|
xGLXReadPixelsReply be_reply;
|
|
GLbyte *be_pc;
|
|
GLint x, y;
|
|
GLsizei width, height;
|
|
GLenum format, type;
|
|
GLboolean swapBytes, lsbFirst;
|
|
ClientPtr client = cl->client;
|
|
DrawablePtr pDraw;
|
|
__GLXcontext *glxc;
|
|
int from_screen = 0;
|
|
int to_screen = 0;
|
|
char *buf;
|
|
int buf_size;
|
|
int s;
|
|
int win_x1, win_x2;
|
|
int win_y1, win_y2;
|
|
int ebits, rowsize;
|
|
|
|
if (client->swapped) {
|
|
__GLX_DECLARE_SWAP_VARIABLES;
|
|
__GLX_SWAP_INT(&req->contextTag);
|
|
}
|
|
|
|
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_xGLXSingleReq;
|
|
x = *(GLint *) (pc + 0);
|
|
y = *(GLint *) (pc + 4);
|
|
width = *(GLsizei *) (pc + 8);
|
|
height = *(GLsizei *) (pc + 12);
|
|
format = *(GLenum *) (pc + 16);
|
|
type = *(GLenum *) (pc + 20);
|
|
swapBytes = *(GLboolean *) (pc + 24);
|
|
lsbFirst = *(GLboolean *) (pc + 25);
|
|
|
|
if (client->swapped) {
|
|
__GLX_DECLARE_SWAP_VARIABLES;
|
|
__GLX_SWAP_INT(&x);
|
|
__GLX_SWAP_INT(&y);
|
|
__GLX_SWAP_INT(&width);
|
|
__GLX_SWAP_INT(&height);
|
|
__GLX_SWAP_INT(&format);
|
|
__GLX_SWAP_INT(&type);
|
|
swapBytes = !swapBytes;
|
|
}
|
|
|
|
buf_size =
|
|
__glReadPixels_size(format, type, width, height, &ebits, &rowsize);
|
|
if (buf_size > 0) {
|
|
buf = (char *) malloc(buf_size);
|
|
if (!buf) {
|
|
return BadAlloc;
|
|
}
|
|
}
|
|
else {
|
|
buf_size = 0;
|
|
buf = NULL;
|
|
}
|
|
|
|
if (buf_size > 0) {
|
|
/*
|
|
* Get the current drawable this context is bound to
|
|
*/
|
|
pDraw = __glXLookupDrawableByTag(cl, req->contextTag);
|
|
win_x1 = pDraw->x + x;
|
|
win_x2 = win_x1 + width - 1;
|
|
win_y1 = (dmxGlobalHeight - pDraw->y - pDraw->height) + y;
|
|
win_y2 = win_y1 + height - 1;
|
|
if (pDraw->type != DRAWABLE_WINDOW) {
|
|
from_screen = to_screen = 0;
|
|
}
|
|
|
|
for (s = from_screen; s <= to_screen; s++) {
|
|
DMXScreenInfo *dmxScreen = &dmxScreens[s];
|
|
Display *dpy = GetBackEndDisplay(cl, s);
|
|
int scr_x1 = dmxScreen->rootXOrigin;
|
|
int scr_x2 = dmxScreen->rootXOrigin + dmxScreen->scrnWidth - 1;
|
|
int scr_y1 = dmxScreen->rootYOrigin;
|
|
int scr_y2 = dmxScreen->rootYOrigin + dmxScreen->scrnHeight - 1;
|
|
int wx1, wx2, wy1, wy2;
|
|
int sx, sy, sw, sh;
|
|
int npixels;
|
|
|
|
/*
|
|
* find the window portion that is on the current screen
|
|
*/
|
|
if (pDraw->type == DRAWABLE_WINDOW) {
|
|
npixels = intersectRect(scr_x1, scr_x2, scr_y1, scr_y2,
|
|
win_x1, win_x2, win_y1, win_y2,
|
|
&wx1, &wx2, &wy1, &wy2);
|
|
}
|
|
else {
|
|
wx1 = win_x1;
|
|
wx2 = win_x2;
|
|
wy1 = win_y1;
|
|
wy2 = win_y2;
|
|
npixels = (wx2 - wx1 + 1) * (wy2 - wy1 + 1);
|
|
}
|
|
|
|
if (npixels > 0) {
|
|
|
|
/* send the request to the back-end server */
|
|
LockDisplay(dpy);
|
|
GetReqExtra(GLXSingle, __GLX_PAD(26), be_req);
|
|
be_req->reqType = dmxScreen->glxMajorOpcode;
|
|
be_req->glxCode = X_GLsop_ReadPixels;
|
|
be_req->contextTag =
|
|
GetCurrentBackEndTag(cl, req->contextTag, s);
|
|
be_pc = ((GLbyte *) (be_req) + sz_xGLXSingleReq);
|
|
|
|
sx = wx1 - pDraw->x;
|
|
sy = wy1 - (dmxGlobalHeight - pDraw->y - pDraw->height);
|
|
sw = (wx2 - wx1 + 1);
|
|
sh = (wy2 - wy1 + 1);
|
|
|
|
*(GLint *) (be_pc + 0) = sx; /* x */
|
|
*(GLint *) (be_pc + 4) = sy; /* y */
|
|
*(GLsizei *) (be_pc + 8) = sw; /* width */
|
|
*(GLsizei *) (be_pc + 12) = sh; /* height */
|
|
*(GLenum *) (be_pc + 16) = format;
|
|
*(GLenum *) (be_pc + 20) = type;
|
|
*(GLboolean *) (be_pc + 24) = swapBytes;
|
|
*(GLboolean *) (be_pc + 25) = lsbFirst;
|
|
|
|
_XReply(dpy, (xReply *) &be_reply, 0, False);
|
|
|
|
if (be_reply.length > 0) {
|
|
char *be_buf;
|
|
int be_buf_size = be_reply.length << 2;
|
|
|
|
be_buf = (char *) malloc(be_buf_size);
|
|
if (be_buf) {
|
|
_XRead(dpy, be_buf, be_buf_size);
|
|
|
|
/* copy pixels data to the right location of the */
|
|
/* reply buffer */
|
|
if (type != GL_BITMAP) {
|
|
int pbytes = ebits / 8;
|
|
char *dst =
|
|
buf + (sy - y) * rowsize + (sx - x) * pbytes;
|
|
char *src = be_buf;
|
|
int pad = (pbytes * sw) % 4;
|
|
int r;
|
|
|
|
for (r = 0; r < sh; r++) {
|
|
memcpy(dst, src, pbytes * sw);
|
|
dst += rowsize;
|
|
src += (pbytes * sw + (pad ? 4 - pad : 0));
|
|
}
|
|
}
|
|
else {
|
|
/* this is a GL_BITMAP pixel type, should copy bits */
|
|
int r;
|
|
int src_rowsize = bits_to_bytes(sw * ebits);
|
|
int src_pad = src_rowsize % 4;
|
|
|
|
if (src_pad) {
|
|
src_rowsize += (4 - src_pad);
|
|
}
|
|
|
|
for (r = 0; r < sh; r++) {
|
|
unsigned char dst_mask = 0x80 >> (sx % 8);
|
|
unsigned char src_mask = 0x80;
|
|
char *dst =
|
|
buf + (sy - y + r) * rowsize + (sx - x) / 8;
|
|
char *src = be_buf + r * src_rowsize;
|
|
int b;
|
|
|
|
for (b = 0; b < sw * ebits; b++) {
|
|
if (*src & src_mask) {
|
|
*dst |= dst_mask;
|
|
}
|
|
else {
|
|
*dst &= ~dst_mask;
|
|
}
|
|
|
|
if (dst_mask > 1)
|
|
dst_mask >>= 1;
|
|
else {
|
|
dst_mask = 0x80;
|
|
dst++;
|
|
}
|
|
|
|
if (src_mask > 1)
|
|
src_mask >>= 1;
|
|
else {
|
|
src_mask = 0x80;
|
|
src++;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
free(be_buf);
|
|
}
|
|
else {
|
|
/* Throw data on the floor */
|
|
_XEatDataWords(dpy, be_reply.length);
|
|
free(buf);
|
|
return BadAlloc;
|
|
}
|
|
}
|
|
|
|
UnlockDisplay(dpy);
|
|
SyncHandle();
|
|
|
|
} /* of npixels > 0 */
|
|
|
|
} /* of for loop */
|
|
|
|
} /* of if buf_size > 0 */
|
|
|
|
reply = (xGLXReadPixelsReply) {
|
|
.type = X_Reply,
|
|
.sequenceNumber = client->sequence,
|
|
.length = buf_size >> 2
|
|
};
|
|
|
|
if (client->swapped) {
|
|
__GLX_DECLARE_SWAP_VARIABLES;
|
|
__GLX_SWAP_SHORT(&reply.sequenceNumber);
|
|
__GLX_SWAP_INT(&reply.length);
|
|
}
|
|
|
|
WriteToClient(client, sizeof(xGLXReadPixelsReply), &reply);
|
|
if (buf_size > 0) {
|
|
WriteToClient(client, buf_size, buf);
|
|
free(buf);
|
|
}
|
|
|
|
return Success;
|
|
}
|
|
|
|
int
|
|
__glXDispSwap_GetTexImage(__GLXclientState * cl, GLbyte * pc)
|
|
{
|
|
__GLX_DECLARE_SWAP_VARIABLES;
|
|
GLbyte *lpc = pc;
|
|
|
|
lpc += sz_xGLXSingleReq;
|
|
__GLX_SWAP_INT(lpc + 0);
|
|
__GLX_SWAP_INT(lpc + 4);
|
|
__GLX_SWAP_INT(lpc + 8);
|
|
__GLX_SWAP_INT(lpc + 12);
|
|
|
|
/* reverse swapBytes */
|
|
*(GLboolean *) (lpc + 16) = !*(GLboolean *) (lpc + 16);
|
|
|
|
return (__glXForwardPipe0WithReplySwap(cl, pc));
|
|
}
|
|
|
|
int
|
|
__glXDispSwap_GetColorTable(__GLXclientState * cl, GLbyte * pc)
|
|
{
|
|
__GLX_DECLARE_SWAP_VARIABLES;
|
|
GLbyte *lpc = pc;
|
|
|
|
lpc += sz_xGLXSingleReq;
|
|
__GLX_SWAP_INT(lpc + 0);
|
|
__GLX_SWAP_INT(lpc + 4);
|
|
__GLX_SWAP_INT(lpc + 8);
|
|
|
|
/* reverse swapBytes */
|
|
*(GLboolean *) (lpc + 12) = !*(GLboolean *) (lpc + 12);
|
|
|
|
return (__glXForwardPipe0WithReplySwap(cl, pc));
|
|
}
|