void __glXDispSwap_Rectiv(GLbyte *pc) { __GLX_DECLARE_SWAP_VARIABLES; __GLX_DECLARE_SWAP_ARRAY_VARIABLES; __GLX_SWAP_INT_ARRAY(pc + 0, 2); __GLX_SWAP_INT_ARRAY(pc + 8, 2); }
void __glXDispSwap_CallLists(GLbyte *pc) { GLenum type; GLsizei n; __GLX_DECLARE_SWAP_VARIABLES; __GLX_SWAP_INT(pc + 4); __GLX_SWAP_INT(pc + 0); type = *(GLenum *)(pc + 4); n = *(GLsizei *)(pc + 0); switch (type) { case GL_BYTE: case GL_UNSIGNED_BYTE: case GL_2_BYTES: case GL_3_BYTES: case GL_4_BYTES: break; case GL_SHORT: case GL_UNSIGNED_SHORT: __GLX_SWAP_SHORT_ARRAY(pc+8, n); break; case GL_INT: case GL_UNSIGNED_INT: __GLX_SWAP_INT_ARRAY(pc+8, n); break; case GL_FLOAT: __GLX_SWAP_FLOAT_ARRAY(pc+8, n); break; } }
void __glXDispSwap_Color3uiv(GLbyte *pc) { __GLX_DECLARE_SWAP_VARIABLES; __GLX_DECLARE_SWAP_ARRAY_VARIABLES; __GLX_SWAP_INT_ARRAY(pc + 0, 3); }
int __glXVForwardAllWithReplySwapdv(__GLXclientState * cl, GLbyte * pc) { xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc; __GLX_DECLARE_SWAP_VARIABLES; __GLX_DECLARE_SWAP_ARRAY_VARIABLES; __GLX_SWAP_SHORT(&req->length); __GLX_SWAP_INT(&req->vendorCode); __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_xGLXVendorPrivateReq / 4) { int *data = (int *) (req + 1); int count = req->length - sz_xGLXVendorPrivateReq / 4; __GLX_SWAP_INT_ARRAY(data, count); } return (__glXVForwardAllWithReply(cl, pc)); }
void __glXDispSwap_Vertex4iv(GLbyte *pc) { __GLX_DECLARE_SWAP_VARIABLES; __GLX_DECLARE_SWAP_ARRAY_VARIABLES; __GLX_SWAP_INT_ARRAY(pc + 0, 4); }
void __glXDispSwap_TexCoord2iv(GLbyte *pc) { __GLX_DECLARE_SWAP_VARIABLES; __GLX_DECLARE_SWAP_ARRAY_VARIABLES; __GLX_SWAP_INT_ARRAY(pc + 0, 2); }
void __glXDispSwap_RasterPos3iv(GLbyte *pc) { __GLX_DECLARE_SWAP_VARIABLES; __GLX_DECLARE_SWAP_ARRAY_VARIABLES; __GLX_SWAP_INT_ARRAY(pc + 0, 3); }
void __glXDispSwap_Indexiv(GLbyte *pc) { __GLX_DECLARE_SWAP_VARIABLES; __GLX_DECLARE_SWAP_ARRAY_VARIABLES; __GLX_SWAP_INT_ARRAY(pc + 0, 1); }
void __glXDispSwap_MultiTexCoord4ivARB(GLbyte *pc) { __GLX_DECLARE_SWAP_VARIABLES; __GLX_DECLARE_SWAP_ARRAY_VARIABLES; __GLX_SWAP_INT(pc + 0); __GLX_SWAP_INT_ARRAY(pc + 4, 4); }
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") ; free(props_buf) ; props_buf = NULL ; return res ; }
void __glXSwapQueryContextInfoEXTReply(ClientPtr client, xGLXQueryContextInfoEXTReply *reply, int *buf) { int length = reply->length; __GLX_DECLARE_SWAP_VARIABLES; __GLX_DECLARE_SWAP_ARRAY_VARIABLES; __GLX_SWAP_SHORT(&reply->sequenceNumber); __GLX_SWAP_INT(&reply->length); __GLX_SWAP_INT(&reply->n); WriteToClient(client, sz_xGLXQueryContextInfoEXTReply, (char *)reply); __GLX_SWAP_INT_ARRAY((int *)buf, length); WriteToClient(client, length << 2, (char *)buf); }
void __glXDispSwap_PrioritizeTextures(GLbyte *pc) { GLsizei n; __GLX_DECLARE_SWAP_VARIABLES; __GLX_DECLARE_SWAP_ARRAY_VARIABLES; __GLX_SWAP_INT(pc + 0); n = *(GLsizei *)(pc + 0); __GLX_SWAP_INT_ARRAY(pc + 4, n); __GLX_SWAP_FLOAT_ARRAY(pc + 4+n*4, n); }
void __glXDispSwap_PixelMapuiv(GLbyte *pc) { GLint mapsize; __GLX_DECLARE_SWAP_VARIABLES; __GLX_DECLARE_SWAP_ARRAY_VARIABLES; __GLX_SWAP_INT(pc + 4); mapsize = *(GLint *)(pc + 4); __GLX_SWAP_INT(pc + 0); __GLX_SWAP_INT_ARRAY(pc + 8, mapsize); }
void __glXSwapGetDrawableAttributesReply(ClientPtr client, xGLXGetDrawableAttributesReply *reply, CARD32 *buf) { int length = reply->length; __GLX_DECLARE_SWAP_VARIABLES; __GLX_DECLARE_SWAP_ARRAY_VARIABLES; __GLX_SWAP_SHORT(&reply->sequenceNumber); __GLX_SWAP_INT(&reply->length); __GLX_SWAP_INT(&reply->numAttribs); WriteToClient(client, sz_xGLXGetDrawableAttributesReply, (char *)reply); __GLX_SWAP_INT_ARRAY((int *)buf, length); WriteToClient(client, length << 2, (char *)buf); }
void glxSwapQueryExtensionsStringReply(ClientPtr client, xGLXQueryExtensionsStringReply *reply, char *buf) { int length = reply->length; __GLX_DECLARE_SWAP_VARIABLES; __GLX_DECLARE_SWAP_ARRAY_VARIABLES; __GLX_SWAP_SHORT(&reply->sequenceNumber); __GLX_SWAP_INT(&reply->length); __GLX_SWAP_INT(&reply->n); WriteToClient(client, sz_xGLXQueryExtensionsStringReply, (char *)reply); __GLX_SWAP_INT_ARRAY((int *)buf, length); WriteToClient(client, length << 2, buf); }
void __glXDispSwap_LightModeliv(GLbyte *pc) { GLenum pname; GLint compsize; __GLX_DECLARE_SWAP_VARIABLES; __GLX_DECLARE_SWAP_ARRAY_VARIABLES; __GLX_SWAP_INT(pc + 0); pname = *(GLenum *)(pc + 0); compsize = __glLightModeliv_size(pname); if (compsize < 0) compsize = 0; __GLX_SWAP_INT_ARRAY(pc + 4, compsize); }
void __glXDispSwap_ConvolutionParameteriv(GLbyte *pc) { GLenum pname; GLint compsize; __GLX_DECLARE_SWAP_VARIABLES; __GLX_DECLARE_SWAP_ARRAY_VARIABLES; __GLX_SWAP_INT(pc + 4); pname = *(GLenum *)(pc + 4); compsize = __glConvolutionParameteriv_size(pname); if (compsize < 0) compsize = 0; __GLX_SWAP_INT(pc + 0); __GLX_SWAP_INT_ARRAY(pc + 8, compsize); }
int __glXDispSwap_ChangeDrawableAttributes(__GLXclientState *cl, GLbyte *pc) { xGLXChangeDrawableAttributesReq *req = (xGLXChangeDrawableAttributesReq *) 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_ChangeDrawableAttributes(cl, pc); }
int __glXDispSwap_CreatePbuffer(__GLXclientState *cl, GLbyte *pc) { xGLXCreatePbufferReq *req = (xGLXCreatePbufferReq *) pc; __GLX_DECLARE_SWAP_VARIABLES; __GLX_DECLARE_SWAP_ARRAY_VARIABLES; CARD32 *attribs; __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 __glXDisp_CreatePbuffer(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); __GLX_SWAP_INT(&req->fbconfig); __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 __glXDisp_CreatePixmap(cl, pc); }
int __glXDispSwap_RenderMode(__GLXclientState * cl, GLbyte * pc) { ClientPtr client = cl->client; __GLXcontext *cx; xGLXRenderModeReply reply; GLint nitems = 0, retBytes = 0, retval, newModeCheck; GLubyte *retBuffer = NULL; GLenum newMode; __GLX_DECLARE_SWAP_VARIABLES; __GLX_DECLARE_SWAP_ARRAY_VARIABLES; int error; REQUEST_FIXED_SIZE(xGLXSingleReq, 4); __GLX_SWAP_INT(&((xGLXSingleReq *) pc)->contextTag); cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error); if (!cx) { return error; } pc += __GLX_SINGLE_HDR_SIZE; __GLX_SWAP_INT(pc); newMode = *(GLenum *) pc; retval = glRenderMode(newMode); /* Check that render mode worked */ glGetIntegerv(GL_RENDER_MODE, &newModeCheck); if (newModeCheck != newMode) { /* Render mode change failed. Bail */ newMode = newModeCheck; goto noChangeAllowed; } /* ** Render mode might have still failed if we get here. But in this ** case we can't really tell, nor does it matter. If it did fail, it ** will return 0, and thus we won't send any data across the wire. */ switch (cx->renderMode) { case GL_RENDER: cx->renderMode = newMode; break; case GL_FEEDBACK: if (retval < 0) { /* Overflow happened. Copy the entire buffer */ nitems = cx->feedbackBufSize; } else { nitems = retval; } retBytes = nitems * __GLX_SIZE_FLOAT32; retBuffer = (GLubyte *) cx->feedbackBuf; __GLX_SWAP_FLOAT_ARRAY((GLbyte *) retBuffer, nitems); cx->renderMode = newMode; break; case GL_SELECT: if (retval < 0) { /* Overflow happened. Copy the entire buffer */ nitems = cx->selectBufSize; } else { GLuint *bp = cx->selectBuf; GLint i; /* ** Figure out how many bytes of data need to be sent. Parse ** the selection buffer to determine this fact as the ** return value is the number of hits, not the number of ** items in the buffer. */ nitems = 0; i = retval; while (--i >= 0) { GLuint n; /* Parse select data for this hit */ n = *bp; bp += 3 + n; } nitems = bp - cx->selectBuf; } retBytes = nitems * __GLX_SIZE_CARD32; retBuffer = (GLubyte *) cx->selectBuf; __GLX_SWAP_INT_ARRAY((GLbyte *) retBuffer, nitems); cx->renderMode = newMode; break; } /* ** First reply is the number of elements returned in the feedback or ** selection array, as per the API for glRenderMode itself. */ noChangeAllowed:; reply = (xGLXRenderModeReply) { .type = X_Reply, .sequenceNumber = client->sequence, .length = nitems, .retval = retval, .size = nitems, .newMode = newMode }; __GLX_SWAP_SHORT(&reply.sequenceNumber); __GLX_SWAP_INT(&reply.length); __GLX_SWAP_INT(&reply.retval); __GLX_SWAP_INT(&reply.size); __GLX_SWAP_INT(&reply.newMode); WriteToClient(client, sz_xGLXRenderModeReply, &reply); if (retBytes) { WriteToClient(client, retBytes, retBuffer); } return Success; } int __glXDispSwap_Flush(__GLXclientState * cl, GLbyte * pc) { ClientPtr client = cl->client; __GLXcontext *cx; int error; __GLX_DECLARE_SWAP_VARIABLES; REQUEST_SIZE_MATCH(xGLXSingleReq); __GLX_SWAP_INT(&((xGLXSingleReq *) pc)->contextTag); cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error); if (!cx) { return error; } glFlush(); return Success; }
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 = (xGLXGetVisualConfigsReply) { .type = X_Reply, .sequenceNumber = client->sequence, .length = (num_visuals * __GLX_SIZE_CARD32 * num_props) >> 2, .numVisuals = num_visuals, .numProps = num_props }; 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, &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"); free(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 = (xGLXGetVisualConfigsReply) { .type = X_Reply, .sequenceNumber = client->sequence, .length = props_buf_size >> 2, .numVisuals = num_visuals, .numProps = num_props }; 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, &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"); free(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; }