OpenHarmony/third_party_mesa3d
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Generate GLX protocol for pixel single commands.

Browse Source
This commit is contained in:
Ian Romanick
2005-02-09 03:11:23 +00:00
parent 799bc13da2
commit d863424032
5 changed files with 297 additions and 344 deletions
Download Patch File Download Diff File Expand all files Collapse all files

191
src/glx/x11/indirect.c
View File

@@ -82,6 +82,48 @@ read_reply( Display *dpy, size_t size, void * dest, GLboolean reply_is_always_ar
return reply.retval; return reply.retval;
} }
static NOINLINE void
read_pixel_reply( Display *dpy, __GLXcontext * gc, unsigned max_dim,
GLint width, GLint height, GLint depth, GLenum format, GLenum type,
void * dest, GLboolean dimensions_in_reply )
{
xGLXSingleReply reply;
GLint size;
(void) _XReply(dpy, (xReply *) & reply, 0, False);
if ( dimensions_in_reply ) {
width = reply.pad3;
height = reply.pad4;
depth = reply.pad5;
if ((height == 0) || (max_dim < 2)) { height = 1; }
if ((depth == 0) || (max_dim < 3)) { depth = 1; }
}
size = reply.length * 4;
if (size != 0) {
void * buf = Xmalloc( size );
if ( buf == NULL ) {
_XEatData(dpy, size);
__glXSetError(gc, GL_OUT_OF_MEMORY);
}
else {
const GLint extra = 4 - (size & 3);
_XRead(dpy, buf, size);
if ( extra < 4 ) {
_XEatData(dpy, extra);
}
__glEmptyImage(gc, 3, width, height, depth, format, type,
buf, dest);
Xfree(buf);
}
}
}
#define X_GLXSingle 0 #define X_GLXSingle 0
static NOINLINE FASTCALL GLubyte * static NOINLINE FASTCALL GLubyte *
@@ -3229,6 +3271,30 @@ __indirect_glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum
if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
} }
#define X_GLsop_ReadPixels 111
void
__indirect_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid * pixels)
{
__GLXcontext * const gc = __glXGetCurrentContext();
const __GLXattribute * const state = gc->client_state_private;
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 28;
if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_ReadPixels, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&x), 4);
(void) memcpy((void *)(pc + 4), (void *)(&y), 4);
(void) memcpy((void *)(pc + 8), (void *)(&width), 4);
(void) memcpy((void *)(pc + 12), (void *)(&height), 4);
(void) memcpy((void *)(pc + 16), (void *)(&format), 4);
(void) memcpy((void *)(pc + 20), (void *)(&type), 4);
*(int32_t *)(pc + 24) = 0;
* (int8_t *)(pc + 24) = state->storePack.swapEndian;
read_pixel_reply(dpy, gc, 2, width, height, 1, format, type, pixels, GL_FALSE);
UnlockDisplay(dpy); SyncHandle();
}
return;
}
#define X_GLrop_DrawPixels 173 #define X_GLrop_DrawPixels 173
void void
__indirect_glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels) __indirect_glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels)
@@ -3453,6 +3519,23 @@ __indirect_glGetPixelMapusv(GLenum map, GLushort * values)
return; return;
} }
#define X_GLsop_GetPolygonStipple 128
void
__indirect_glGetPolygonStipple(GLubyte * mask)
{
__GLXcontext * const gc = __glXGetCurrentContext();
const __GLXattribute * const state = gc->client_state_private;
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 4;
if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_GetPolygonStipple, cmdlen);
*(int32_t *)(pc + 0) = 0;
read_pixel_reply(dpy, gc, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, mask, GL_FALSE);
UnlockDisplay(dpy); SyncHandle();
}
return;
}
#define X_GLsop_GetTexEnvfv 130 #define X_GLsop_GetTexEnvfv 130
void void
__indirect_glGetTexEnvfv(GLenum target, GLenum pname, GLfloat * params) __indirect_glGetTexEnvfv(GLenum target, GLenum pname, GLfloat * params)
@@ -3538,6 +3621,28 @@ __indirect_glGetTexGeniv(GLenum coord, GLenum pname, GLint * params)
return; return;
} }
#define X_GLsop_GetTexImage 135
void
__indirect_glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid * pixels)
{
__GLXcontext * const gc = __glXGetCurrentContext();
const __GLXattribute * const state = gc->client_state_private;
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 20;
if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexImage, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
(void) memcpy((void *)(pc + 4), (void *)(&level), 4);
(void) memcpy((void *)(pc + 8), (void *)(&format), 4);
(void) memcpy((void *)(pc + 12), (void *)(&type), 4);
*(int32_t *)(pc + 16) = 0;
* (int8_t *)(pc + 16) = state->storePack.swapEndian;
read_pixel_reply(dpy, gc, 3, 0, 0, 0, format, type, pixels, GL_TRUE);
UnlockDisplay(dpy); SyncHandle();
}
return;
}
#define X_GLsop_GetTexParameterfv 136 #define X_GLsop_GetTexParameterfv 136
void void
__indirect_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat * params) __indirect_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat * params)
@@ -4252,6 +4357,27 @@ __indirect_glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint
if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
} }
#define X_GLsop_GetColorTable 147
void
__indirect_glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid * table)
{
__GLXcontext * const gc = __glXGetCurrentContext();
const __GLXattribute * const state = gc->client_state_private;
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_GetColorTable, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
(void) memcpy((void *)(pc + 4), (void *)(&format), 4);
(void) memcpy((void *)(pc + 8), (void *)(&type), 4);
*(int32_t *)(pc + 12) = 0;
* (int8_t *)(pc + 12) = state->storePack.swapEndian;
read_pixel_reply(dpy, gc, 1, 0, 0, 0, format, type, table, GL_TRUE);
UnlockDisplay(dpy); SyncHandle();
}
return;
}
#define X_GLsop_GetColorTableParameterfv 148 #define X_GLsop_GetColorTableParameterfv 148
void void
__indirect_glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat * params) __indirect_glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat * params)
@@ -4494,6 +4620,27 @@ __indirect_glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint
if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
} }
#define X_GLsop_GetConvolutionFilter 150
void
__indirect_glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid * image)
{
__GLXcontext * const gc = __glXGetCurrentContext();
const __GLXattribute * const state = gc->client_state_private;
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_GetConvolutionFilter, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
(void) memcpy((void *)(pc + 4), (void *)(&format), 4);
(void) memcpy((void *)(pc + 8), (void *)(&type), 4);
*(int32_t *)(pc + 12) = 0;
* (int8_t *)(pc + 12) = state->storePack.swapEndian;
read_pixel_reply(dpy, gc, 2, 0, 0, 0, format, type, image, GL_TRUE);
UnlockDisplay(dpy); SyncHandle();
}
return;
}
#define X_GLsop_GetConvolutionParameterfv 151 #define X_GLsop_GetConvolutionParameterfv 151
void void
__indirect_glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat * params) __indirect_glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat * params)
@@ -4528,6 +4675,28 @@ __indirect_glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint * para
return; return;
} }
#define X_GLsop_GetHistogram 154
void
__indirect_glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values)
{
__GLXcontext * const gc = __glXGetCurrentContext();
const __GLXattribute * const state = gc->client_state_private;
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_GetHistogram, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
(void) memcpy((void *)(pc + 4), (void *)(&format), 4);
(void) memcpy((void *)(pc + 8), (void *)(&type), 4);
*(int32_t *)(pc + 12) = 0;
* (int8_t *)(pc + 12) = state->storePack.swapEndian;
* (int8_t *)(pc + 13) = reset;
read_pixel_reply(dpy, gc, 1, 0, 0, 0, format, type, values, GL_TRUE);
UnlockDisplay(dpy); SyncHandle();
}
return;
}
#define X_GLsop_GetHistogramParameterfv 155 #define X_GLsop_GetHistogramParameterfv 155
void void
__indirect_glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat * params) __indirect_glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat * params)
@@ -4562,6 +4731,28 @@ __indirect_glGetHistogramParameteriv(GLenum target, GLenum pname, GLint * params
return; return;
} }
#define X_GLsop_GetMinmax 157
void
__indirect_glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values)
{
__GLXcontext * const gc = __glXGetCurrentContext();
const __GLXattribute * const state = gc->client_state_private;
Display * const dpy = gc->currentDpy;
const GLuint cmdlen = 16;
if (__builtin_expect(dpy != NULL, 1)) {
GLubyte const * pc = setup_single_request(gc, X_GLsop_GetMinmax, cmdlen);
(void) memcpy((void *)(pc + 0), (void *)(&target), 4);
(void) memcpy((void *)(pc + 4), (void *)(&format), 4);
(void) memcpy((void *)(pc + 8), (void *)(&type), 4);
*(int32_t *)(pc + 12) = 0;
* (int8_t *)(pc + 12) = state->storePack.swapEndian;
* (int8_t *)(pc + 13) = reset;
read_pixel_reply(dpy, gc, 1, 2, 1, 1, format, type, values, GL_FALSE);
UnlockDisplay(dpy); SyncHandle();
}
return;
}
#define X_GLsop_GetMinmaxParameterfv 158 #define X_GLsop_GetMinmaxParameterfv 158
void void
__indirect_glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat * params) __indirect_glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat * params)

311
src/glx/x11/singlepix.c
View File

@@ -36,222 +36,6 @@
#include "packsingle.h" #include "packsingle.h"
void __indirect_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height,
GLenum format, GLenum type, GLvoid *pixels)
{
__GLX_SINGLE_DECLARE_VARIABLES();
const __GLXattribute * state;
xGLXReadPixelsReply reply;
GLubyte *buf;
if (!dpy) return;
__GLX_SINGLE_LOAD_VARIABLES();
state = gc->client_state_private;
/* Send request */
__GLX_SINGLE_BEGIN(X_GLsop_ReadPixels,__GLX_PAD(26));
__GLX_SINGLE_PUT_LONG(0,x);
__GLX_SINGLE_PUT_LONG(4,y);
__GLX_SINGLE_PUT_LONG(8,width);
__GLX_SINGLE_PUT_LONG(12,height);
__GLX_SINGLE_PUT_LONG(16,format);
__GLX_SINGLE_PUT_LONG(20,type);
__GLX_SINGLE_PUT_CHAR(24,state->storePack.swapEndian);
__GLX_SINGLE_PUT_CHAR(25,GL_FALSE);
__GLX_SINGLE_READ_XREPLY();
compsize = reply.length << 2;
if (compsize != 0) {
/* Allocate a holding buffer to transform the data from */
buf = (GLubyte*) Xmalloc(compsize);
if (!buf) {
/* Throw data away */
_XEatData(dpy, compsize);
__glXSetError(gc, GL_OUT_OF_MEMORY);
} else {
/*
** Fetch data into holding buffer. Apply pixel store pack modes
** to put data back into client memory
*/
__GLX_SINGLE_GET_CHAR_ARRAY(buf,compsize);
__glEmptyImage(gc, 2, width, height, 1, format, type, buf, pixels);
Xfree((char*) buf);
}
} else {
/*
** GL error occurred; don't modify user's buffer.
*/
}
__GLX_SINGLE_END();
}
void __indirect_glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type,
GLvoid *texels)
{
__GLX_SINGLE_DECLARE_VARIABLES();
const __GLXattribute * state;
xGLXGetTexImageReply reply;
GLubyte *buf;
if (!dpy) return;
__GLX_SINGLE_LOAD_VARIABLES();
state = gc->client_state_private;
/* Send request */
__GLX_SINGLE_BEGIN(X_GLsop_GetTexImage,__GLX_PAD(17));
__GLX_SINGLE_PUT_LONG(0,target);
__GLX_SINGLE_PUT_LONG(4,level);
__GLX_SINGLE_PUT_LONG(8,format);
__GLX_SINGLE_PUT_LONG(12,type);
__GLX_SINGLE_PUT_CHAR(16,state->storePack.swapEndian);
__GLX_SINGLE_READ_XREPLY();
compsize = reply.length << 2;
if (compsize != 0) {
/* Allocate a holding buffer to transform the data from */
buf = (GLubyte*) Xmalloc(compsize);
if (!buf) {
/* Throw data away */
_XEatData(dpy, compsize);
__glXSetError(gc, GL_OUT_OF_MEMORY);
} else {
GLint width, height, depth;
/*
** Fetch data into holding buffer. Apply pixel store pack modes
** to put data back into client memory
*/
width = reply.width;
height = reply.height;
depth = reply.depth;
__GLX_SINGLE_GET_CHAR_ARRAY(buf,compsize);
__glEmptyImage(gc, 2, width, height, depth, format, type, buf,
texels);
Xfree((char*) buf);
}
} else {
/*
** GL error occured, don't modify user's buffer.
*/
}
__GLX_SINGLE_END();
}
void __indirect_glGetPolygonStipple(GLubyte *mask)
{
__GLX_SINGLE_DECLARE_VARIABLES();
xGLXSingleReply reply;
GLubyte buf[128];
if (!dpy) return;
__GLX_SINGLE_LOAD_VARIABLES();
__GLX_SINGLE_BEGIN(X_GLsop_GetPolygonStipple,__GLX_PAD(1));
__GLX_SINGLE_PUT_CHAR(0,GL_FALSE);
__GLX_SINGLE_READ_XREPLY();
if (reply.length == 32) {
__GLX_SINGLE_GET_CHAR_ARRAY(buf,128);
__glEmptyImage(gc, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, buf, mask);
}
__GLX_SINGLE_END();
}
void __indirect_glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table)
{
__GLX_SINGLE_DECLARE_VARIABLES();
const __GLXattribute * state;
xGLXGetColorTableReply reply;
GLubyte *buf;
if (!dpy) return;
__GLX_SINGLE_LOAD_VARIABLES();
state = gc->client_state_private;
/* Send request */
__GLX_SINGLE_BEGIN(X_GLsop_GetColorTable,__GLX_PAD(13));
__GLX_SINGLE_PUT_LONG(0,(long)target);
__GLX_SINGLE_PUT_LONG(4,(long)format);
__GLX_SINGLE_PUT_LONG(8,(long)type);
__GLX_SINGLE_PUT_CHAR(12,state->storePack.swapEndian);
__GLX_SINGLE_READ_XREPLY();
compsize = (long)reply.length << 2;
if (compsize != 0) {
/* Allocate a holding buffer to transform the data from */
buf = (GLubyte*)Xmalloc(compsize);
if (!buf) {
/* Throw data away */
_XEatData(dpy, compsize);
__glXSetError(gc, GL_OUT_OF_MEMORY);
} else {
GLint width;
/*
** Fetch data into holding buffer. Apply pixel store pack modes
** to put data back into client memory
*/
width = (int)reply.width;
__GLX_SINGLE_GET_CHAR_ARRAY(((char*)buf),(long)compsize);
__glEmptyImage(gc, 1, width, 1, 1, format, type, buf, table);
Xfree((char*) buf);
}
} else {
/*
** GL error occured, don't modify user's buffer.
*/
}
__GLX_SINGLE_END();
}
void __indirect_glGetConvolutionFilter(GLenum target, GLenum format, GLenum type,
GLvoid *image)
{
__GLX_SINGLE_DECLARE_VARIABLES();
const __GLXattribute * state;
xGLXGetConvolutionFilterReply reply;
GLubyte *buf;
if (!dpy) return;
__GLX_SINGLE_LOAD_VARIABLES();
state = gc->client_state_private;
/* Send request */
__GLX_SINGLE_BEGIN(X_GLsop_GetConvolutionFilter, __GLX_PAD(13));
__GLX_SINGLE_PUT_LONG(0,target);
__GLX_SINGLE_PUT_LONG(4,format);
__GLX_SINGLE_PUT_LONG(8,type);
__GLX_SINGLE_PUT_CHAR(12,state->storePack.swapEndian);
__GLX_SINGLE_READ_XREPLY();
compsize = reply.length << 2;
if (compsize != 0) {
/* Allocate a holding buffer to transform the data from */
buf = (GLubyte*) Xmalloc(compsize);
if (!buf) {
/* Throw data away */
_XEatData(dpy, compsize);
__glXSetError(gc, GL_OUT_OF_MEMORY);
} else {
GLint width, height;
/*
** Fetch data into holding buffer. Apply pixel store pack modes
** to put data back into client memory
*/
width = reply.width;
height = reply.height;
__GLX_SINGLE_GET_CHAR_ARRAY(((char*)buf),compsize);
__glEmptyImage(gc, 2, width, height, 1, format, type, buf, image);
Xfree((char*) buf);
}
} else {
/*
** GL error occured, don't modify user's buffer.
*/
}
__GLX_SINGLE_END();
}
void __indirect_glGetSeparableFilter(GLenum target, GLenum format, GLenum type, void __indirect_glGetSeparableFilter(GLenum target, GLenum format, GLenum type,
GLvoid *row, GLvoid *column, GLvoid *span) GLvoid *row, GLvoid *column, GLvoid *span)
{ {
@@ -318,98 +102,3 @@ void __indirect_glGetSeparableFilter(GLenum target, GLenum format, GLenum type,
__GLX_SINGLE_END(); __GLX_SINGLE_END();
} }
void __indirect_glGetHistogram(GLenum target, GLboolean reset, GLenum format,
GLenum type, GLvoid *values)
{
__GLX_SINGLE_DECLARE_VARIABLES();
const __GLXattribute * state;
xGLXGetHistogramReply reply;
GLubyte *buf;
if (!dpy) return;
__GLX_SINGLE_LOAD_VARIABLES();
state = gc->client_state_private;
/* Send request */
__GLX_SINGLE_BEGIN(X_GLsop_GetHistogram,__GLX_PAD(14));
__GLX_SINGLE_PUT_LONG(0,(long)target);
__GLX_SINGLE_PUT_LONG(4,(long)format);
__GLX_SINGLE_PUT_LONG(8,(long)type);
__GLX_SINGLE_PUT_CHAR(12,state->storePack.swapEndian);
__GLX_SINGLE_PUT_CHAR(13,reset);
__GLX_SINGLE_READ_XREPLY();
compsize = (long)reply.length << 2;
if (compsize != 0) {
/* Allocate a holding buffer to transform the data from */
buf = (GLubyte*)Xmalloc(compsize);
if (!buf) {
/* Throw data away */
_XEatData(dpy, compsize);
__glXSetError(gc, GL_OUT_OF_MEMORY);
} else {
GLint width;
/*
** Fetch data into holding buffer. Apply pixel store pack modes
** to put data back into client memory
*/
width = (int)reply.width;
__GLX_SINGLE_GET_CHAR_ARRAY(((char*)buf),(long)compsize);
__glEmptyImage(gc, 1, width, 1, 1, format, type, buf, values);
Xfree((char*) buf);
}
} else {
/*
** GL error occured, don't modify user's buffer.
*/
}
__GLX_SINGLE_END();
}
void __indirect_glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type,
GLvoid *values)
{
__GLX_SINGLE_DECLARE_VARIABLES();
const __GLXattribute * state;
xGLXGetMinmaxReply reply;
GLubyte *buf;
if (!dpy) return;
__GLX_SINGLE_LOAD_VARIABLES();
state = gc->client_state_private;
/* Send request */
__GLX_SINGLE_BEGIN(X_GLsop_GetMinmax,__GLX_PAD(14));
__GLX_SINGLE_PUT_LONG(0,(long)target);
__GLX_SINGLE_PUT_LONG(4,(long)format);
__GLX_SINGLE_PUT_LONG(8,(long)type);
__GLX_SINGLE_PUT_CHAR(12,state->storePack.swapEndian);
__GLX_SINGLE_PUT_CHAR(13,reset);
__GLX_SINGLE_READ_XREPLY();
compsize = (long)reply.length << 2;
if (compsize != 0) {
/* Allocate a holding buffer to transform the data from */
buf = (GLubyte*)Xmalloc(compsize);
if (!buf) {
/* Throw data away */
_XEatData(dpy, compsize);
__glXSetError(gc, GL_OUT_OF_MEMORY);
} else {
/*
** Fetch data into holding buffer. Apply pixel store pack modes
** to put data back into client memory
*/
__GLX_SINGLE_GET_CHAR_ARRAY(((char*)buf),(long)compsize);
__glEmptyImage(gc, 1, 2, 1, 1, format, type, buf, values);
Xfree((char*) buf);
}
} else {
/*
** GL error occured, don't modify user's buffer.
*/
}
__GLX_SINGLE_END();
}

13
src/mesa/glapi/glX_XML.py
View File

@@ -304,6 +304,8 @@ class glXFunction(gl_XML.glFunction):
self.output = None self.output = None
self.can_be_large = 0 self.can_be_large = 0
self.reply_always_array = 0 self.reply_always_array = 0
self.dimensions_in_reply = 0
self.img_reset = None
self.server_handcode = 0 self.server_handcode = 0
self.client_handcode = 0 self.client_handcode = 0
@@ -324,6 +326,7 @@ class glXFunction(gl_XML.glFunction):
self.glx_rop = int(attrs.get('rop', "0")) self.glx_rop = int(attrs.get('rop', "0"))
self.glx_sop = int(attrs.get('sop', "0")) self.glx_sop = int(attrs.get('sop', "0"))
self.glx_vendorpriv = int(attrs.get('vendorpriv', "0")) self.glx_vendorpriv = int(attrs.get('vendorpriv', "0"))
self.img_reset = attrs.get('img_reset', None)
# The 'handcode' attribute can be one of 'true', # The 'handcode' attribute can be one of 'true',
# 'false', 'client', or 'server'. # 'false', 'client', or 'server'.
@@ -365,6 +368,10 @@ class glXFunction(gl_XML.glFunction):
else: else:
self.reply_always_array = 0 self.reply_always_array = 0
if attrs.get('dimensions_in_reply', "false") == "true":
self.dimensions_in_reply = 1
else:
self.dimensions_in_reply = 0
else: else:
gl_XML.glFunction.startElement(self, name, attrs) gl_XML.glFunction.startElement(self, name, attrs)
@@ -433,7 +440,7 @@ class glXFunction(gl_XML.glFunction):
pixel commends is zero. The offset for pixel commands depends pixel commends is zero. The offset for pixel commands depends
on the number of dimensions of the pixel data.""" on the number of dimensions of the pixel data."""
if self.image: if self.image and not self.image.is_output:
[dim, junk, junk, junk, junk] = self.dimensions() [dim, junk, junk, junk, junk] = self.dimensions()
# The base size is the size of the pixel pack info # The base size is the size of the pixel pack info
@@ -457,12 +464,12 @@ class glXFunction(gl_XML.glFunction):
size = self.offset_of_first_parameter() size = self.offset_of_first_parameter()
for p in gl_XML.glFunction.parameterIterator(self): for p in gl_XML.glFunction.parameterIterator(self):
if not p.is_output: if not p.is_output and p.name != self.img_reset:
size += p.size() size += p.size()
if self.pad_after(p): if self.pad_after(p):
size += 4 size += 4
if self.image and self.image.img_null_flag: if self.image and (self.image.img_null_flag or self.image.is_output):
size += 4 size += 4
return size return size

64
src/mesa/glapi/glX_proto_send.py
View File

@@ -103,6 +103,7 @@ class glXPixelFunctionUtility(glX_XML.glXFunction):
self.can_be_large = func.can_be_large self.can_be_large = func.can_be_large
self.count_parameter_list = func.count_parameter_list self.count_parameter_list = func.count_parameter_list
self.counter = func.counter self.counter = func.counter
self.img_reset = None
return return
@@ -166,6 +167,48 @@ read_reply( Display *dpy, size_t size, void * dest, GLboolean reply_is_always_ar
return reply.retval; return reply.retval;
} }
static NOINLINE void
read_pixel_reply( Display *dpy, __GLXcontext * gc, unsigned max_dim,
GLint width, GLint height, GLint depth, GLenum format, GLenum type,
void * dest, GLboolean dimensions_in_reply )
{
xGLXSingleReply reply;
GLint size;
(void) _XReply(dpy, (xReply *) & reply, 0, False);
if ( dimensions_in_reply ) {
width = reply.pad3;
height = reply.pad4;
depth = reply.pad5;
if ((height == 0) || (max_dim < 2)) { height = 1; }
if ((depth == 0) || (max_dim < 3)) { depth = 1; }
}
size = reply.length * 4;
if (size != 0) {
void * buf = Xmalloc( size );
if ( buf == NULL ) {
_XEatData(dpy, size);
__glXSetError(gc, GL_OUT_OF_MEMORY);
}
else {
const GLint extra = 4 - (size & 3);
_XRead(dpy, buf, size);
if ( extra < 4 ) {
_XEatData(dpy, extra);
}
__glEmptyImage(gc, 3, width, height, depth, format, type,
buf, dest);
Xfree(buf);
}
}
}
#define X_GLXSingle 0 #define X_GLXSingle 0
static NOINLINE FASTCALL GLubyte * static NOINLINE FASTCALL GLubyte *
@@ -265,6 +308,7 @@ generic_%u_byte( GLint rop, const void * ptr )
r = 2 r = 2
for p in f.parameterIterator(1, r): for p in f.parameterIterator(1, r):
if p.name != f.img_reset:
self.common_emit_one_arg(p, offset, pc, indent, adjust) self.common_emit_one_arg(p, offset, pc, indent, adjust)
offset += p.size() offset += p.size()
@@ -328,6 +372,9 @@ generic_%u_byte( GLint rop, const void * ptr )
# parameter. # parameter.
if not f.glx_rop: if not f.glx_rop:
if f.image and f.image.is_output:
print ' const __GLXattribute * const state = gc->client_state_private;'
print ' Display * const dpy = gc->currentDpy;' print ' Display * const dpy = gc->currentDpy;'
skip_condition = "dpy != NULL" skip_condition = "dpy != NULL"
elif f.can_be_large: elif f.can_be_large:
@@ -383,8 +430,24 @@ generic_%u_byte( GLint rop, const void * ptr )
print ' %s setup_single_request(gc, %s, cmdlen);' % (pc_decl, f.opcode_name()) print ' %s setup_single_request(gc, %s, cmdlen);' % (pc_decl, f.opcode_name())
self.common_emit_args(f, "pc", " ", 0, 0) self.common_emit_args(f, "pc", " ", 0, 0)
if f.image and f.image.is_output:
o = f.command_fixed_length() - 4
print ' *(int32_t *)(pc + %u) = 0;' % (o)
if f.image.img_format != "GL_COLOR_INDEX" or f.image.img_type != "GL_BITMAP":
print ' * (int8_t *)(pc + %u) = state->storePack.swapEndian;' % (o)
if f.img_reset:
print ' * (int8_t *)(pc + %u) = %s;' % (o + 1, f.img_reset)
if f.needs_reply(): if f.needs_reply():
if f.image and f.image.is_output:
[dim, w, h, d, junk] = f.dimensions()
if f.dimensions_in_reply:
print " read_pixel_reply(dpy, gc, %u, 0, 0, 0, %s, %s, %s, GL_TRUE);" % (dim, f.image.img_format, f.image.img_type, f.image.name)
else:
print " read_pixel_reply(dpy, gc, %u, %s, %s, %s, %s, %s, %s, GL_FALSE);" % (dim, w, h, d, f.image.img_format, f.image.img_type, f.image.name)
else:
if f.output != None: if f.output != None:
output_size = f.output.p_type.size output_size = f.output.p_type.size
output_str = f.output.name output_str = f.output.name
@@ -403,6 +466,7 @@ generic_%u_byte( GLint rop, const void * ptr )
aa = "GL_FALSE" aa = "GL_FALSE"
print " %s read_reply(dpy, %s, %s, %s);" % (return_str, output_size, output_str, aa) print " %s read_reply(dpy, %s, %s, %s);" % (return_str, output_size, output_str, aa)
elif self.debug: elif self.debug:
# Only emit the extra glFinish call for functions # Only emit the extra glFinish call for functions
# that don't already require a reply from the server. # that don't already require a reply from the server.

30
src/mesa/glapi/gl_API.xml
View File

@@ -53,6 +53,8 @@
doubles_in_order CDATA #IMPLIED doubles_in_order CDATA #IMPLIED
always_array CDATA #IMPLIED always_array CDATA #IMPLIED
handcode CDATA #IMPLIED handcode CDATA #IMPLIED
img_reset CDATA #IMPLIED
dimensions_in_reply CDATA #IMPLIED
ignore CDATA #IMPLIED> ignore CDATA #IMPLIED>
]> ]>
@@ -2349,8 +2351,8 @@ glx:
<param name="height" type="GLsizei"/> <param name="height" type="GLsizei"/>
<param name="format" type="GLenum"/> <param name="format" type="GLenum"/>
<param name="type" type="GLenum"/> <param name="type" type="GLenum"/>
<param name="pixels" type="GLvoid *" output="true"/> <param name="pixels" type="GLvoid *" output="true" img_width="width" img_height="height" img_format="format" img_type="type" img_target="0"/>
<glx sop="111" handcode="true"/> <glx sop="111"/>
</function> </function>
<function name="DrawPixels" offset="257"> <function name="DrawPixels" offset="257">
@@ -2465,8 +2467,8 @@ glx:
</function> </function>
<function name="GetPolygonStipple" offset="274"> <function name="GetPolygonStipple" offset="274">
<param name="mask" type="GLubyte *" output="true"/> <param name="mask" type="GLubyte *" output="true" img_width="32" img_height="32" img_format="GL_COLOR_INDEX" img_type="GL_BITMAP"/>
<glx sop="128" handcode="true"/> <glx sop="128"/>
</function> </function>
<function name="GetString" offset="275"> <function name="GetString" offset="275">
@@ -2515,8 +2517,8 @@ glx:
<param name="level" type="GLint"/> <param name="level" type="GLint"/>
<param name="format" type="GLenum"/> <param name="format" type="GLenum"/>
<param name="type" type="GLenum"/> <param name="type" type="GLenum"/>
<param name="pixels" type="GLvoid *" output="true"/> <param name="pixels" type="GLvoid *" output="true" img_width="width" img_height="height" img_depth="depth" img_format="format" img_type="type"/>
<glx sop="135" handcode="true"/> <glx sop="135" dimensions_in_reply="true"/>
</function> </function>
<function name="GetTexParameterfv" offset="282"> <function name="GetTexParameterfv" offset="282">
@@ -3322,8 +3324,8 @@ glx:
<param name="target" type="GLenum"/> <param name="target" type="GLenum"/>
<param name="format" type="GLenum"/> <param name="format" type="GLenum"/>
<param name="type" type="GLenum"/> <param name="type" type="GLenum"/>
<param name="table" type="GLvoid *" output="true"/> <param name="table" type="GLvoid *" output="true" img_width="width" img_format="format" img_type="type"/>
<glx sop="147" handcode="true"/> <glx sop="147" dimensions_in_reply="true"/>
</function> </function>
<function name="GetColorTableParameterfv" offset="344"> <function name="GetColorTableParameterfv" offset="344">
@@ -3431,8 +3433,8 @@ glx:
<param name="target" type="GLenum"/> <param name="target" type="GLenum"/>
<param name="format" type="GLenum"/> <param name="format" type="GLenum"/>
<param name="type" type="GLenum"/> <param name="type" type="GLenum"/>
<param name="image" type="GLvoid *" output="true"/> <param name="image" type="GLvoid *" output="true" img_width="width" img_height="height" img_format="format" img_type="type"/>
<glx sop="150" handcode="true"/> <glx sop="150" dimensions_in_reply="true"/>
</function> </function>
<function name="GetConvolutionParameterfv" offset="357"> <function name="GetConvolutionParameterfv" offset="357">
@@ -3476,8 +3478,8 @@ glx:
<param name="reset" type="GLboolean"/> <param name="reset" type="GLboolean"/>
<param name="format" type="GLenum"/> <param name="format" type="GLenum"/>
<param name="type" type="GLenum"/> <param name="type" type="GLenum"/>
<param name="values" type="GLvoid *" output="true"/> <param name="values" type="GLvoid *" output="true" img_width="width" img_format="format" img_type="type"/>
<glx sop="154" handcode="true"/> <glx sop="154" dimensions_in_reply="true" img_reset="reset"/>
</function> </function>
<function name="GetHistogramParameterfv" offset="362"> <function name="GetHistogramParameterfv" offset="362">
@@ -3499,8 +3501,8 @@ glx:
<param name="reset" type="GLboolean"/> <param name="reset" type="GLboolean"/>
<param name="format" type="GLenum"/> <param name="format" type="GLenum"/>
<param name="type" type="GLenum"/> <param name="type" type="GLenum"/>
<param name="values" type="GLvoid *" output="true"/> <param name="values" type="GLvoid *" output="true" img_width="2" img_format="format" img_type="type"/>
<glx sop="157" handcode="true"/> <glx sop="157" img_reset="reset"/>
</function> </function>
<function name="GetMinmaxParameterfv" offset="365"> <function name="GetMinmaxParameterfv" offset="365">