diff options
Diffstat (limited to 'src/glx')
-rw-r--r-- | src/glx/x11/compsize.c | 19 | ||||
-rw-r--r-- | src/glx/x11/glxclient.h | 12 | ||||
-rw-r--r-- | src/glx/x11/indirect.c | 517 | ||||
-rw-r--r-- | src/glx/x11/pixel.c | 31 | ||||
-rw-r--r-- | src/glx/x11/render2.c | 2 | ||||
-rw-r--r-- | src/glx/x11/renderpix.c | 852 | ||||
-rw-r--r-- | src/glx/x11/singlepix.c | 4 | ||||
-rw-r--r-- | src/glx/x11/size.h | 53 |
8 files changed, 629 insertions, 861 deletions
diff --git a/src/glx/x11/compsize.c b/src/glx/x11/compsize.c index 9529496b127..973b640a877 100644 --- a/src/glx/x11/compsize.c +++ b/src/glx/x11/compsize.c @@ -35,7 +35,7 @@ */ #include <GL/gl.h> -#include "size.h" +#include "indirect_size.h" /* ** Return the number of elements per group of a specified format @@ -147,14 +147,28 @@ GLint __glBytesPerElement(GLenum type) ** and format. */ GLint __glImageSize(GLsizei width, GLsizei height, GLsizei depth, - GLenum format, GLenum type) + GLenum format, GLenum type, GLenum target) { int bytes_per_row; int components; + switch( target ) { + case GL_PROXY_TEXTURE_1D: + case GL_PROXY_TEXTURE_2D: + case GL_PROXY_TEXTURE_3D: + case GL_PROXY_TEXTURE_4D_SGIS: + case GL_PROXY_TEXTURE_CUBE_MAP: + case GL_PROXY_TEXTURE_RECTANGLE_ARB: + case GL_PROXY_COLOR_TABLE: + case GL_PROXY_POST_CONVOLUTION_COLOR_TABLE: + case GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE: + return 0; + } + if (width < 0 || height < 0 || depth < 0) { return 0; } + /* ** Zero is returned if either format or type are invalid. */ @@ -168,5 +182,6 @@ GLint __glImageSize(GLsizei width, GLsizei height, GLsizei depth, } else { bytes_per_row = __glBytesPerElement(type) * width; } + return bytes_per_row * height * depth * components; } diff --git a/src/glx/x11/glxclient.h b/src/glx/x11/glxclient.h index 7729903f0b9..d0cc12e5ffe 100644 --- a/src/glx/x11/glxclient.h +++ b/src/glx/x11/glxclient.h @@ -737,8 +737,15 @@ extern CARD8 __glXSetupForCommand(Display *dpy); ** Data conversion and packing support. */ +extern const GLuint __glXDefaultPixelStore[9]; + +/* Send an image to the server using RenderLarge. */ +extern void __glXSendLargeImage(__GLXcontext *gc, GLint compsize, GLint dim, + GLint width, GLint height, GLint depth, GLenum format, GLenum type, + const GLvoid *src, GLubyte *pc, GLubyte *modes); + /* Return the size, in bytes, of some pixel data */ -extern GLint __glImageSize(GLint, GLint, GLint, GLenum, GLenum); +extern GLint __glImageSize(GLint, GLint, GLint, GLenum, GLenum, GLenum); /* Return the number of elements per group of a specified format*/ extern GLint __glElementsPerGroup(GLenum format, GLenum type); @@ -748,9 +755,6 @@ extern GLint __glElementsPerGroup(GLenum format, GLenum type); */ extern GLint __glBytesPerElement(GLenum type); -/* Return the k value for a given map target */ -extern GLint __glEvalComputeK(GLenum); - /* ** Fill the transport buffer with the data from the users buffer, ** applying some of the pixel store modes (unpack modes) to the data diff --git a/src/glx/x11/indirect.c b/src/glx/x11/indirect.c index a9b52e2aa22..3468f0d8b70 100644 --- a/src/glx/x11/indirect.c +++ b/src/glx/x11/indirect.c @@ -1,7 +1,7 @@ /* DO NOT EDIT - This file generated automatically by glX_proto_send.py (from Mesa) script */ /* - * (C) Copyright IBM Corporation 2004 + * (C) Copyright IBM Corporation 2004, 2005 * All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a @@ -29,7 +29,7 @@ #include <GL/gl.h> #include "indirect.h" #include "glxclient.h" -#include "size.h" +#include "indirect_size.h" #include <GL/glxproto.h> #define __GLX_PAD(n) (((n) + 3) & ~3) @@ -115,6 +115,19 @@ setup_vendor_request( __GLXcontext * gc, GLint code, GLint vop, GLint cmdlen ) return (GLubyte *)(req) + sz_xGLXVendorPrivateReq; } +const GLuint __glXDefaultPixelStore[9] = { 0, 0, 0, 0, 0, 0, 0, 0, 1 }; + +#define zero (__glXDefaultPixelStore+0) +#define one (__glXDefaultPixelStore+8) +#define default_pixel_store_1D (__glXDefaultPixelStore+4) +#define default_pixel_store_1D_size 20 +#define default_pixel_store_2D (__glXDefaultPixelStore+4) +#define default_pixel_store_2D_size 20 +#define default_pixel_store_3D (__glXDefaultPixelStore+0) +#define default_pixel_store_3D_size 36 +#define default_pixel_store_4D (__glXDefaultPixelStore+0) +#define default_pixel_store_4D_size 36 + static FASTCALL NOINLINE void generic_3_byte( GLint rop, const void * ptr ) { @@ -342,6 +355,51 @@ __indirect_glBegin(GLenum mode) if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } +#define X_GLrop_Bitmap 5 +void +__indirect_glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte * bitmap) +{ + __GLXcontext * const gc = __glXGetCurrentContext(); + const GLuint compsize = (bitmap != NULL) ? __glImageSize(width, height, 1, GL_COLOR_INDEX, GL_BITMAP, 0) : 0; + const GLuint cmdlen = 48 + __GLX_PAD(compsize); + if (__builtin_expect(gc->currentDpy != NULL, 1)) { + if (cmdlen <= gc->maxSmallRenderCommandSize) { + if ( (gc->pc + cmdlen) > gc->bufEnd ) { + (void) __glXFlushRenderBuffer(gc, gc->pc); + } + emit_header(gc->pc, X_GLrop_Bitmap, cmdlen); + (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4); + (void) memcpy((void *)(gc->pc + 28), (void *)(&height), 4); + (void) memcpy((void *)(gc->pc + 32), (void *)(&xorig), 4); + (void) memcpy((void *)(gc->pc + 36), (void *)(&yorig), 4); + (void) memcpy((void *)(gc->pc + 40), (void *)(&xmove), 4); + (void) memcpy((void *)(gc->pc + 44), (void *)(&ymove), 4); + if (compsize > 0) { + (*gc->fillImage)(gc, 2, width, height, 1, GL_COLOR_INDEX, GL_BITMAP, bitmap, gc->pc + 48, gc->pc + 4); + } + else { + (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size ); + } + gc->pc += cmdlen; + if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); } + } + else { + const GLint op = X_GLrop_Bitmap; + const GLuint cmdlenLarge = cmdlen + 4; + GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); + (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); + (void) memcpy((void *)(pc + 4), (void *)(&op), 4); + (void) memcpy((void *)(pc + 28), (void *)(&width), 4); + (void) memcpy((void *)(pc + 32), (void *)(&height), 4); + (void) memcpy((void *)(pc + 36), (void *)(&xorig), 4); + (void) memcpy((void *)(pc + 40), (void *)(&yorig), 4); + (void) memcpy((void *)(pc + 44), (void *)(&xmove), 4); + (void) memcpy((void *)(pc + 48), (void *)(&ymove), 4); + __glXSendLargeImage(gc, compsize, 2, width, height, 1, GL_COLOR_INDEX, GL_BITMAP, bitmap, pc + 52, pc + 8); + } + } +} + #define X_GLrop_Color3bv 6 void __indirect_glColor3b(GLbyte red, GLbyte green, GLbyte blue) @@ -2193,6 +2251,24 @@ __indirect_glPolygonMode(GLenum face, GLenum mode) if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } +#define X_GLrop_PolygonStipple 102 +void +__indirect_glPolygonStipple(const GLubyte * mask) +{ + __GLXcontext * const gc = __glXGetCurrentContext(); + const GLuint compsize = (mask != NULL) ? __glImageSize(32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, 0) : 0; + const GLuint cmdlen = 24 + __GLX_PAD(compsize); + emit_header(gc->pc, X_GLrop_PolygonStipple, cmdlen); + if (compsize > 0) { + (*gc->fillImage)(gc, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, mask, gc->pc + 24, gc->pc + 4); + } + else { + (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size ); + } + gc->pc += cmdlen; + if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); } +} + #define X_GLrop_Scissor 103 void __indirect_glScissor(GLint x, GLint y, GLsizei width, GLsizei height) @@ -2278,6 +2354,68 @@ __indirect_glTexParameteriv(GLenum target, GLenum pname, const GLint * params) if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } +static void +__glx_TexImage_1D2D( unsigned opcode, unsigned dim, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels ) +{ + __GLXcontext * const gc = __glXGetCurrentContext(); + const GLuint compsize = __glImageSize(width, height, 1, format, type, target); + const GLuint cmdlen = 56 + __GLX_PAD(compsize); + if (__builtin_expect(gc->currentDpy != NULL, 1)) { + if (cmdlen <= gc->maxSmallRenderCommandSize) { + if ( (gc->pc + cmdlen) > gc->bufEnd ) { + (void) __glXFlushRenderBuffer(gc, gc->pc); + } + emit_header(gc->pc, opcode, cmdlen); + (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4); + (void) memcpy((void *)(gc->pc + 28), (void *)(&level), 4); + (void) memcpy((void *)(gc->pc + 32), (void *)(&internalformat), 4); + (void) memcpy((void *)(gc->pc + 36), (void *)(&width), 4); + (void) memcpy((void *)(gc->pc + 40), (void *)(&height), 4); + (void) memcpy((void *)(gc->pc + 44), (void *)(&border), 4); + (void) memcpy((void *)(gc->pc + 48), (void *)(&format), 4); + (void) memcpy((void *)(gc->pc + 52), (void *)(&type), 4); + if ((compsize > 0) && (pixels != NULL)) { + (*gc->fillImage)(gc, dim, width, height, 1, format, type, pixels, gc->pc + 56, gc->pc + 4); + } + else { + (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size ); + } + gc->pc += cmdlen; + if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); } + } + else { + const GLint op = opcode; + const GLuint cmdlenLarge = cmdlen + 4; + GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); + (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); + (void) memcpy((void *)(pc + 4), (void *)(&op), 4); + (void) memcpy((void *)(pc + 28), (void *)(&target), 4); + (void) memcpy((void *)(pc + 32), (void *)(&level), 4); + (void) memcpy((void *)(pc + 36), (void *)(&internalformat), 4); + (void) memcpy((void *)(pc + 40), (void *)(&width), 4); + (void) memcpy((void *)(pc + 44), (void *)(&height), 4); + (void) memcpy((void *)(pc + 48), (void *)(&border), 4); + (void) memcpy((void *)(pc + 52), (void *)(&format), 4); + (void) memcpy((void *)(pc + 56), (void *)(&type), 4); + __glXSendLargeImage(gc, compsize, dim, width, height, 1, format, type, pixels, pc + 60, pc + 8); + } + } +} + +#define X_GLrop_TexImage1D 109 +void +__indirect_glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid * pixels) +{ + __glx_TexImage_1D2D(X_GLrop_TexImage1D, 1, target, level, internalformat, width, 1, border, format, type, pixels ); +} + +#define X_GLrop_TexImage2D 110 +void +__indirect_glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels) +{ + __glx_TexImage_1D2D(X_GLrop_TexImage2D, 2, target, level, internalformat, width, height, border, format, type, pixels ); +} + #define X_GLrop_TexEnvf 111 void __indirect_glTexEnvf(GLenum target, GLenum pname, GLfloat param) @@ -3091,6 +3229,47 @@ __indirect_glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } +#define X_GLrop_DrawPixels 173 +void +__indirect_glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels) +{ + __GLXcontext * const gc = __glXGetCurrentContext(); + const GLuint compsize = (pixels != NULL) ? __glImageSize(width, height, 1, format, type, 0) : 0; + const GLuint cmdlen = 40 + __GLX_PAD(compsize); + if (__builtin_expect(gc->currentDpy != NULL, 1)) { + if (cmdlen <= gc->maxSmallRenderCommandSize) { + if ( (gc->pc + cmdlen) > gc->bufEnd ) { + (void) __glXFlushRenderBuffer(gc, gc->pc); + } + emit_header(gc->pc, X_GLrop_DrawPixels, cmdlen); + (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4); + (void) memcpy((void *)(gc->pc + 28), (void *)(&height), 4); + (void) memcpy((void *)(gc->pc + 32), (void *)(&format), 4); + (void) memcpy((void *)(gc->pc + 36), (void *)(&type), 4); + if (compsize > 0) { + (*gc->fillImage)(gc, 2, width, height, 1, format, type, pixels, gc->pc + 40, gc->pc + 4); + } + else { + (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size ); + } + gc->pc += cmdlen; + if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); } + } + else { + const GLint op = X_GLrop_DrawPixels; + const GLuint cmdlenLarge = cmdlen + 4; + GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); + (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); + (void) memcpy((void *)(pc + 4), (void *)(&op), 4); + (void) memcpy((void *)(pc + 28), (void *)(&width), 4); + (void) memcpy((void *)(pc + 32), (void *)(&height), 4); + (void) memcpy((void *)(pc + 36), (void *)(&format), 4); + (void) memcpy((void *)(pc + 40), (void *)(&type), 4); + __glXSendLargeImage(gc, compsize, 2, width, height, 1, format, type, pixels, pc + 44, pc + 8); + } + } +} + #define X_GLsop_GetClipPlane 113 void __indirect_glGetClipPlane(GLenum plane, GLdouble * equation) @@ -3893,6 +4072,70 @@ __indirect_glPrioritizeTextures(GLsizei n, const GLuint * textures, const GLclam } } +static void +__glx_TexSubImage_1D2D( unsigned opcode, unsigned dim, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels ) +{ + __GLXcontext * const gc = __glXGetCurrentContext(); + const GLuint compsize = (pixels != NULL) ? __glImageSize(width, height, 1, format, type, target) : 0; + const GLuint cmdlen = 60 + __GLX_PAD(compsize); + if (__builtin_expect(gc->currentDpy != NULL, 1)) { + if (cmdlen <= gc->maxSmallRenderCommandSize) { + if ( (gc->pc + cmdlen) > gc->bufEnd ) { + (void) __glXFlushRenderBuffer(gc, gc->pc); + } + emit_header(gc->pc, opcode, cmdlen); + (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4); + (void) memcpy((void *)(gc->pc + 28), (void *)(&level), 4); + (void) memcpy((void *)(gc->pc + 32), (void *)(&xoffset), 4); + (void) memcpy((void *)(gc->pc + 36), (void *)(&yoffset), 4); + (void) memcpy((void *)(gc->pc + 40), (void *)(&width), 4); + (void) memcpy((void *)(gc->pc + 44), (void *)(&height), 4); + (void) memcpy((void *)(gc->pc + 48), (void *)(&format), 4); + (void) memcpy((void *)(gc->pc + 52), (void *)(&type), 4); + (void) memcpy((void *)(gc->pc + 56), (void *)((pixels == NULL) ? one : zero), 4); + if (compsize > 0) { + (*gc->fillImage)(gc, dim, width, height, 1, format, type, pixels, gc->pc + 60, gc->pc + 4); + } + else { + (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size ); + } + gc->pc += cmdlen; + if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); } + } + else { + const GLint op = opcode; + const GLuint cmdlenLarge = cmdlen + 4; + GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); + (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); + (void) memcpy((void *)(pc + 4), (void *)(&op), 4); + (void) memcpy((void *)(pc + 28), (void *)(&target), 4); + (void) memcpy((void *)(pc + 32), (void *)(&level), 4); + (void) memcpy((void *)(pc + 36), (void *)(&xoffset), 4); + (void) memcpy((void *)(pc + 40), (void *)(&yoffset), 4); + (void) memcpy((void *)(pc + 44), (void *)(&width), 4); + (void) memcpy((void *)(pc + 48), (void *)(&height), 4); + (void) memcpy((void *)(pc + 52), (void *)(&format), 4); + (void) memcpy((void *)(pc + 56), (void *)(&type), 4); + (void) memcpy((void *)(pc + 60), zero, 4); + __glXSendLargeImage(gc, compsize, dim, width, height, 1, format, type, pixels, pc + 64, pc + 8); + } + } +} + +#define X_GLrop_TexSubImage1D 4099 +void +__indirect_glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid * pixels) +{ + __glx_TexSubImage_1D2D(X_GLrop_TexSubImage1D, 1, target, level, xoffset, 1, width, 1, format, type, pixels ); +} + +#define X_GLrop_TexSubImage2D 4100 +void +__indirect_glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels) +{ + __glx_TexSubImage_1D2D(X_GLrop_TexSubImage2D, 2, target, level, xoffset, yoffset, width, height, format, type, pixels ); +} + #define X_GLrop_BlendColor 4096 void __indirect_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) @@ -3920,6 +4163,49 @@ __indirect_glBlendEquation(GLenum mode) if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } +#define X_GLrop_ColorTable 2053 +void +__indirect_glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * table) +{ + __GLXcontext * const gc = __glXGetCurrentContext(); + const GLuint compsize = (table != NULL) ? __glImageSize(width, 1, 1, format, type, target) : 0; + const GLuint cmdlen = 44 + __GLX_PAD(compsize); + if (__builtin_expect(gc->currentDpy != NULL, 1)) { + if (cmdlen <= gc->maxSmallRenderCommandSize) { + if ( (gc->pc + cmdlen) > gc->bufEnd ) { + (void) __glXFlushRenderBuffer(gc, gc->pc); + } + emit_header(gc->pc, X_GLrop_ColorTable, cmdlen); + (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4); + (void) memcpy((void *)(gc->pc + 28), (void *)(&internalformat), 4); + (void) memcpy((void *)(gc->pc + 32), (void *)(&width), 4); + (void) memcpy((void *)(gc->pc + 36), (void *)(&format), 4); + (void) memcpy((void *)(gc->pc + 40), (void *)(&type), 4); + if (compsize > 0) { + (*gc->fillImage)(gc, 1, width, 1, 1, format, type, table, gc->pc + 44, gc->pc + 4); + } + else { + (void) memcpy( gc->pc + 4, default_pixel_store_1D, default_pixel_store_1D_size ); + } + gc->pc += cmdlen; + if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); } + } + else { + const GLint op = X_GLrop_ColorTable; + const GLuint cmdlenLarge = cmdlen + 4; + GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); + (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); + (void) memcpy((void *)(pc + 4), (void *)(&op), 4); + (void) memcpy((void *)(pc + 28), (void *)(&target), 4); + (void) memcpy((void *)(pc + 32), (void *)(&internalformat), 4); + (void) memcpy((void *)(pc + 36), (void *)(&width), 4); + (void) memcpy((void *)(pc + 40), (void *)(&format), 4); + (void) memcpy((void *)(pc + 44), (void *)(&type), 4); + __glXSendLargeImage(gc, compsize, 1, width, 1, 1, format, type, table, pc + 48, pc + 8); + } + } +} + #define X_GLrop_ColorTableParameterfv 2054 void __indirect_glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat * params) @@ -4000,6 +4286,49 @@ __indirect_glGetColorTableParameteriv(GLenum target, GLenum pname, GLint * param return; } +#define X_GLrop_ColorSubTable 195 +void +__indirect_glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid * data) +{ + __GLXcontext * const gc = __glXGetCurrentContext(); + const GLuint compsize = (data != NULL) ? __glImageSize(count, 1, 1, format, type, target) : 0; + const GLuint cmdlen = 44 + __GLX_PAD(compsize); + if (__builtin_expect(gc->currentDpy != NULL, 1)) { + if (cmdlen <= gc->maxSmallRenderCommandSize) { + if ( (gc->pc + cmdlen) > gc->bufEnd ) { + (void) __glXFlushRenderBuffer(gc, gc->pc); + } + emit_header(gc->pc, X_GLrop_ColorSubTable, cmdlen); + (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4); + (void) memcpy((void *)(gc->pc + 28), (void *)(&start), 4); + (void) memcpy((void *)(gc->pc + 32), (void *)(&count), 4); + (void) memcpy((void *)(gc->pc + 36), (void *)(&format), 4); + (void) memcpy((void *)(gc->pc + 40), (void *)(&type), 4); + if (compsize > 0) { + (*gc->fillImage)(gc, 1, count, 1, 1, format, type, data, gc->pc + 44, gc->pc + 4); + } + else { + (void) memcpy( gc->pc + 4, default_pixel_store_1D, default_pixel_store_1D_size ); + } + gc->pc += cmdlen; + if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); } + } + else { + const GLint op = X_GLrop_ColorSubTable; + const GLuint cmdlenLarge = cmdlen + 4; + GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); + (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); + (void) memcpy((void *)(pc + 4), (void *)(&op), 4); + (void) memcpy((void *)(pc + 28), (void *)(&target), 4); + (void) memcpy((void *)(pc + 32), (void *)(&start), 4); + (void) memcpy((void *)(pc + 36), (void *)(&count), 4); + (void) memcpy((void *)(pc + 40), (void *)(&format), 4); + (void) memcpy((void *)(pc + 44), (void *)(&type), 4); + __glXSendLargeImage(gc, compsize, 1, count, 1, 1, format, type, data, pc + 48, pc + 8); + } + } +} + #define X_GLrop_CopyColorSubTable 196 void __indirect_glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width) @@ -4016,6 +4345,64 @@ __indirect_glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, G if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } +static void +__glx_ConvolutionFilter_1D2D( unsigned opcode, unsigned dim, GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image ) +{ + __GLXcontext * const gc = __glXGetCurrentContext(); + const GLuint compsize = (image != NULL) ? __glImageSize(width, height, 1, format, type, target) : 0; + const GLuint cmdlen = 48 + __GLX_PAD(compsize); + if (__builtin_expect(gc->currentDpy != NULL, 1)) { + if (cmdlen <= gc->maxSmallRenderCommandSize) { + if ( (gc->pc + cmdlen) > gc->bufEnd ) { + (void) __glXFlushRenderBuffer(gc, gc->pc); + } + emit_header(gc->pc, opcode, cmdlen); + (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4); + (void) memcpy((void *)(gc->pc + 28), (void *)(&internalformat), 4); + (void) memcpy((void *)(gc->pc + 32), (void *)(&width), 4); + (void) memcpy((void *)(gc->pc + 36), (void *)(&height), 4); + (void) memcpy((void *)(gc->pc + 40), (void *)(&format), 4); + (void) memcpy((void *)(gc->pc + 44), (void *)(&type), 4); + if (compsize > 0) { + (*gc->fillImage)(gc, dim, width, height, 1, format, type, image, gc->pc + 48, gc->pc + 4); + } + else { + (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size ); + } + gc->pc += cmdlen; + if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); } + } + else { + const GLint op = opcode; + const GLuint cmdlenLarge = cmdlen + 4; + GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); + (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); + (void) memcpy((void *)(pc + 4), (void *)(&op), 4); + (void) memcpy((void *)(pc + 28), (void *)(&target), 4); + (void) memcpy((void *)(pc + 32), (void *)(&internalformat), 4); + (void) memcpy((void *)(pc + 36), (void *)(&width), 4); + (void) memcpy((void *)(pc + 40), (void *)(&height), 4); + (void) memcpy((void *)(pc + 44), (void *)(&format), 4); + (void) memcpy((void *)(pc + 48), (void *)(&type), 4); + __glXSendLargeImage(gc, compsize, dim, width, height, 1, format, type, image, pc + 52, pc + 8); + } + } +} + +#define X_GLrop_ConvolutionFilter1D 4101 +void +__indirect_glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * image) +{ + __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter1D, 1, target, internalformat, width, 1, format, type, image ); +} + +#define X_GLrop_ConvolutionFilter2D 4102 +void +__indirect_glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image) +{ + __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter2D, 2, target, internalformat, width, height, format, type, image ); +} + #define X_GLrop_ConvolutionParameterf 4103 void __indirect_glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params) @@ -4262,6 +4649,132 @@ __indirect_glResetMinmax(GLenum target) if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); } } +static void +__glx_TexImage_3D4D( unsigned opcode, unsigned dim, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei extent, GLint border, GLenum format, GLenum type, const GLvoid * pixels ) +{ + __GLXcontext * const gc = __glXGetCurrentContext(); + const GLuint compsize = (pixels != NULL) ? __glImageSize(width, height, depth, format, type, target) : 0; + const GLuint cmdlen = 84 + __GLX_PAD(compsize); + if (__builtin_expect(gc->currentDpy != NULL, 1)) { + if (cmdlen <= gc->maxSmallRenderCommandSize) { + if ( (gc->pc + cmdlen) > gc->bufEnd ) { + (void) __glXFlushRenderBuffer(gc, gc->pc); + } + emit_header(gc->pc, opcode, cmdlen); + (void) memcpy((void *)(gc->pc + 40), (void *)(&target), 4); + (void) memcpy((void *)(gc->pc + 44), (void *)(&level), 4); + (void) memcpy((void *)(gc->pc + 48), (void *)(&internalformat), 4); + (void) memcpy((void *)(gc->pc + 52), (void *)(&width), 4); + (void) memcpy((void *)(gc->pc + 56), (void *)(&height), 4); + (void) memcpy((void *)(gc->pc + 60), (void *)(&depth), 4); + (void) memcpy((void *)(gc->pc + 64), (void *)(&extent), 4); + (void) memcpy((void *)(gc->pc + 68), (void *)(&border), 4); + (void) memcpy((void *)(gc->pc + 72), (void *)(&format), 4); + (void) memcpy((void *)(gc->pc + 76), (void *)(&type), 4); + (void) memcpy((void *)(gc->pc + 80), (void *)((pixels == NULL) ? one : zero), 4); + if (compsize > 0) { + (*gc->fillImage)(gc, dim, width, height, depth, format, type, pixels, gc->pc + 84, gc->pc + 4); + } + else { + (void) memcpy( gc->pc + 4, default_pixel_store_4D, default_pixel_store_4D_size ); + } + gc->pc += cmdlen; + if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); } + } + else { + const GLint op = opcode; + const GLuint cmdlenLarge = cmdlen + 4; + GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); + (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); + (void) memcpy((void *)(pc + 4), (void *)(&op), 4); + (void) memcpy((void *)(pc + 44), (void *)(&target), 4); + (void) memcpy((void *)(pc + 48), (void *)(&level), 4); + (void) memcpy((void *)(pc + 52), (void *)(&internalformat), 4); + (void) memcpy((void *)(pc + 56), (void *)(&width), 4); + (void) memcpy((void *)(pc + 60), (void *)(&height), 4); + (void) memcpy((void *)(pc + 64), (void *)(&depth), 4); + (void) memcpy((void *)(pc + 68), (void *)(&extent), 4); + (void) memcpy((void *)(pc + 72), (void *)(&border), 4); + (void) memcpy((void *)(pc + 76), (void *)(&format), 4); + (void) memcpy((void *)(pc + 80), (void *)(&type), 4); + (void) memcpy((void *)(pc + 84), zero, 4); + __glXSendLargeImage(gc, compsize, dim, width, height, depth, format, type, pixels, pc + 88, pc + 8); + } + } +} + +#define X_GLrop_TexImage3D 4114 +void +__indirect_glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels) +{ + __glx_TexImage_3D4D(X_GLrop_TexImage3D, 3, target, level, internalformat, width, height, depth, 1, border, format, type, pixels ); +} + +static void +__glx_TexSubImage_3D4D( unsigned opcode, unsigned dim, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei extent, GLenum format, GLenum type, const GLvoid * pixels ) +{ + __GLXcontext * const gc = __glXGetCurrentContext(); + const GLuint compsize = (pixels != NULL) ? __glImageSize(width, height, depth, format, type, target) : 0; + const GLuint cmdlen = 92 + __GLX_PAD(compsize); + if (__builtin_expect(gc->currentDpy != NULL, 1)) { + if (cmdlen <= gc->maxSmallRenderCommandSize) { + if ( (gc->pc + cmdlen) > gc->bufEnd ) { + (void) __glXFlushRenderBuffer(gc, gc->pc); + } + emit_header(gc->pc, opcode, cmdlen); + (void) memcpy((void *)(gc->pc + 40), (void *)(&target), 4); + (void) memcpy((void *)(gc->pc + 44), (void *)(&level), 4); + (void) memcpy((void *)(gc->pc + 48), (void *)(&xoffset), 4); + (void) memcpy((void *)(gc->pc + 52), (void *)(&yoffset), 4); + (void) memcpy((void *)(gc->pc + 56), (void *)(&zoffset), 4); + (void) memcpy((void *)(gc->pc + 60), (void *)(&woffset), 4); + (void) memcpy((void *)(gc->pc + 64), (void *)(&width), 4); + (void) memcpy((void *)(gc->pc + 68), (void *)(&height), 4); + (void) memcpy((void *)(gc->pc + 72), (void *)(&depth), 4); + (void) memcpy((void *)(gc->pc + 76), (void *)(&extent), 4); + (void) memcpy((void *)(gc->pc + 80), (void *)(&format), 4); + (void) memcpy((void *)(gc->pc + 84), (void *)(&type), 4); + (void) memcpy((void *)(gc->pc + 88), (void *)((pixels == NULL) ? one : zero), 4); + if (compsize > 0) { + (*gc->fillImage)(gc, dim, width, height, depth, format, type, pixels, gc->pc + 92, gc->pc + 4); + } + else { + (void) memcpy( gc->pc + 4, default_pixel_store_4D, default_pixel_store_4D_size ); + } + gc->pc += cmdlen; + if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); } + } + else { + const GLint op = opcode; + const GLuint cmdlenLarge = cmdlen + 4; + GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc); + (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4); + (void) memcpy((void *)(pc + 4), (void *)(&op), 4); + (void) memcpy((void *)(pc + 44), (void *)(&target), 4); + (void) memcpy((void *)(pc + 48), (void *)(&level), 4); + (void) memcpy((void *)(pc + 52), (void *)(&xoffset), 4); + (void) memcpy((void *)(pc + 56), (void *)(&yoffset), 4); + (void) memcpy((void *)(pc + 60), (void *)(&zoffset), 4); + (void) memcpy((void *)(pc + 64), (void *)(&woffset), 4); + (void) memcpy((void *)(pc + 68), (void *)(&width), 4); + (void) memcpy((void *)(pc + 72), (void *)(&height), 4); + (void) memcpy((void *)(pc + 76), (void *)(&depth), 4); + (void) memcpy((void *)(pc + 80), (void *)(&extent), 4); + (void) memcpy((void *)(pc + 84), (void *)(&format), 4); + (void) memcpy((void *)(pc + 88), (void *)(&type), 4); + (void) memcpy((void *)(pc + 92), zero, 4); + __glXSendLargeImage(gc, compsize, dim, width, height, depth, format, type, pixels, pc + 96, pc + 8); + } + } +} + +#define X_GLrop_TexSubImage3D 4115 +void +__indirect_glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels) +{ + __glx_TexSubImage_3D4D(X_GLrop_TexSubImage3D, 3, target, level, xoffset, yoffset, zoffset, 1, width, height, depth, 1, format, type, pixels ); +} + #define X_GLrop_CopyTexSubImage3D 4123 void __indirect_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) diff --git a/src/glx/x11/pixel.c b/src/glx/x11/pixel.c index 75960e40f55..3b3a1811abb 100644 --- a/src/glx/x11/pixel.c +++ b/src/glx/x11/pixel.c @@ -249,31 +249,12 @@ void __glFillImage(__GLXcontext *gc, GLint dim, GLint width, GLint height, /* Setup store modes that describe what we just did */ if (modes) { - if (dim == 3) { - GLubyte *pc = modes; - __GLX_PUT_CHAR(0,GL_FALSE); - __GLX_PUT_CHAR(1,GL_FALSE); - __GLX_PUT_CHAR(2,0); - __GLX_PUT_CHAR(3,0); - __GLX_PUT_LONG(4,0); - __GLX_PUT_LONG(8,0); - __GLX_PUT_LONG(12,0); - __GLX_PUT_LONG(16,0); - __GLX_PUT_LONG(20,0); - __GLX_PUT_LONG(24,0); - __GLX_PUT_LONG(28,0); - __GLX_PUT_LONG(32,1); - } else { - GLubyte *pc = modes; - __GLX_PUT_CHAR(0,GL_FALSE); - __GLX_PUT_CHAR(1,GL_FALSE); - __GLX_PUT_CHAR(2,0); - __GLX_PUT_CHAR(3,0); - __GLX_PUT_LONG(4,0); - __GLX_PUT_LONG(8,0); - __GLX_PUT_LONG(12,0); - __GLX_PUT_LONG(16,1); - } + if ( dim < 3 ) { + (void) memcpy( modes, __glXDefaultPixelStore + 4, 20 ); + } + else { + (void) memcpy( modes, __glXDefaultPixelStore + 0, 36 ); + } } } diff --git a/src/glx/x11/render2.c b/src/glx/x11/render2.c index a8c6ded39de..21ba2709982 100644 --- a/src/glx/x11/render2.c +++ b/src/glx/x11/render2.c @@ -36,7 +36,7 @@ #include "packrender.h" #include "indirect.h" -#include "size.h" +#include "indirect_size.h" /* ** This file contains routines that might need to be transported as diff --git a/src/glx/x11/renderpix.c b/src/glx/x11/renderpix.c index c24d3aa1c7c..9b7d3db93ca 100644 --- a/src/glx/x11/renderpix.c +++ b/src/glx/x11/renderpix.c @@ -34,32 +34,65 @@ ** */ -#include "packrender.h" - /* -** This file contains routines that deal with unpacking data from client -** memory using the pixel store unpack modes and then shipping it to -** the server. For all of these routines (except glPolygonStipple) there -** are two forms of the transport - small and large. Small commands are -** the commands that fit into the "rendering" transport buffer. Large -** commands are sent to the server in chunks by __glXSendLargeCommand. -** -** All of the commands send over a pixel header (see glxproto.h) which -** describes the pixel store modes that the server must use to properly -** handle the data. Any pixel store modes not done by the __glFillImage -** routine are passed on to the server. -*/ + * (C) Copyright IBM Corporation 2005 + * 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 + * IBM, + * 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. + */ -/* -** Send a large image to the server. If necessary, a buffer is allocated -** to hold the unpacked data that is copied from the clients memory. -*/ -static void SendLargeImage(__GLXcontext *gc, GLint compsize, GLint dim, - GLint width, GLint height, GLint depth, - GLenum format, GLenum type, const GLvoid *src, - GLubyte *pc, GLubyte *modes) -{ - if (!gc->fastImageUnpack) { +#include "packrender.h" + +/** + * Send a large image to the server. If necessary, a buffer is allocated + * to hold the unpacked data that is copied from the clients memory. + * + * \param gc Current GLX context + * \param compsize Size, in bytes, of the image portion + * \param dim Number of dimensions of the image + * \param width Width of the image + * \param height Height of the image, must be 1 for 1D images + * \param depth Depth of the image, must be 1 for 1D or 2D images + * \param format Format of the image + * \param type Data type of the image + * \param src Pointer to the image data + * \param pc Pointer to end of the command header + * \param modes Pointer to the pixel unpack data + * + * \todo + * Modify this function so that \c NULL images are sent using + * \c __glXSendLargeChunk instead of __glXSendLargeCommand. Doing this + * will eliminate the need to allocate a buffer for that case. + * + * \bugs + * The \c fastImageUnpack path, which is thankfully never used, is completely + * broken. + */ +void +__glXSendLargeImage(__GLXcontext *gc, GLint compsize, GLint dim, + GLint width, GLint height, GLint depth, + GLenum format, GLenum type, const GLvoid *src, + GLubyte *pc, GLubyte *modes) +{ + if ( !gc->fastImageUnpack || (src == NULL) ) { /* Allocate a temporary holding buffer */ GLubyte *buf = (GLubyte *) Xmalloc(compsize); if (!buf) { @@ -68,8 +101,18 @@ static void SendLargeImage(__GLXcontext *gc, GLint compsize, GLint dim, } /* Apply pixel store unpack modes to copy data into buf */ - (*gc->fillImage)(gc, dim, width, height, depth, format, type, src, buf, - modes); + if ( src != NULL ) { + (*gc->fillImage)(gc, dim, width, height, depth, format, type, + src, buf, modes); + } + else { + if ( dim < 3 ) { + (void) memcpy( modes, __glXDefaultPixelStore + 4, 20 ); + } + else { + (void) memcpy( modes, __glXDefaultPixelStore + 0, 36 ); + } + } /* Send large command */ __glXSendLargeCommand(gc, gc->pc, pc - gc->pc, buf, compsize); @@ -82,578 +125,15 @@ static void SendLargeImage(__GLXcontext *gc, GLint compsize, GLint dim, } } -/* -** Send a large null image to the server. To be backwards compatible, -** data must be sent to the server even when the application has passed -** a null pointer into glTexImage1D, glTexImage2D or glTexImage3D. -*/ -static void SendLargeNULLImage(__GLXcontext *gc, GLint compsize, - GLint width, GLint height, GLint depth, - GLenum format, GLenum type, const GLvoid *src, - GLubyte *pc, GLubyte *modes) -{ - GLubyte *buf = (GLubyte *) Xmalloc(compsize); - - /* Allocate a temporary holding buffer */ - if (!buf) { - __glXSetError(gc, GL_OUT_OF_MEMORY); - return; - } - - /* Send large command */ - __glXSendLargeCommand(gc, gc->pc, pc - gc->pc, buf, compsize); - - /* Free buffer */ - Xfree((char*) buf); -} - /************************************************************************/ -void __indirect_glPolygonStipple(const GLubyte *mask) -{ - __GLX_DECLARE_VARIABLES(); - - __GLX_LOAD_VARIABLES(); - compsize = __glImageSize(32, 32, 1, GL_COLOR_INDEX, GL_BITMAP); - cmdlen = __GLX_PAD(__GLX_POLYGONSTIPPLE_CMD_HDR_SIZE + compsize); - if (!gc->currentDpy) return; - - __GLX_BEGIN(X_GLrop_PolygonStipple,cmdlen); - pc += __GLX_RENDER_HDR_SIZE; - pixelHeaderPC = pc; - pc += __GLX_PIXEL_HDR_SIZE; - (*gc->fillImage)(gc, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, - mask, pc, pixelHeaderPC); - __GLX_END(__GLX_PAD(compsize)); -} - -void __indirect_glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, - GLfloat xmove, GLfloat ymove, const GLubyte *bitmap) -{ - __GLX_DECLARE_VARIABLES(); - - __GLX_LOAD_VARIABLES(); - compsize = __glImageSize(width, height, 1, GL_COLOR_INDEX, GL_BITMAP); - cmdlen = __GLX_PAD(__GLX_BITMAP_CMD_HDR_SIZE + compsize); - if (!gc->currentDpy) return; - - if (cmdlen <= gc->maxSmallRenderCommandSize) { - /* Use GLXRender protocol to send small command */ - __GLX_BEGIN_VARIABLE_WITH_PIXEL(X_GLrop_Bitmap,cmdlen); - __GLX_PUT_LONG(0,width); - __GLX_PUT_LONG(4,height); - __GLX_PUT_FLOAT(8,xorig); - __GLX_PUT_FLOAT(12,yorig); - __GLX_PUT_FLOAT(16,xmove); - __GLX_PUT_FLOAT(20,ymove); - pc += __GLX_BITMAP_HDR_SIZE; - if (compsize > 0) { - (*gc->fillImage)(gc, 2, width, height, 1, GL_COLOR_INDEX, - GL_BITMAP, bitmap, pc, pixelHeaderPC); - } else { - /* Setup default store modes */ - GLubyte *pc = pixelHeaderPC; - __GLX_PUT_CHAR(0,GL_FALSE); - __GLX_PUT_CHAR(1,GL_FALSE); - __GLX_PUT_CHAR(2,0); - __GLX_PUT_CHAR(3,0); - __GLX_PUT_LONG(4,0); - __GLX_PUT_LONG(8,0); - __GLX_PUT_LONG(12,0); - __GLX_PUT_LONG(16,1); - } - __GLX_END(__GLX_PAD(compsize)); - } else { - /* Use GLXRenderLarge protocol to send command */ - __GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL(X_GLrop_Bitmap,cmdlen+4); - __GLX_PUT_LONG(0,width); - __GLX_PUT_LONG(4,height); - __GLX_PUT_FLOAT(8,xorig); - __GLX_PUT_FLOAT(12,yorig); - __GLX_PUT_FLOAT(16,xmove); - __GLX_PUT_FLOAT(20,ymove); - pc += __GLX_BITMAP_HDR_SIZE; - SendLargeImage(gc, compsize, 2, width, height, 1, GL_COLOR_INDEX, - GL_BITMAP, bitmap, pc, pixelHeaderPC); - } -} - -void __indirect_glTexImage1D(GLenum target, GLint level, GLint components, - GLsizei width, GLint border, GLenum format, GLenum type, - const GLvoid *image) -{ - __GLX_DECLARE_VARIABLES(); - - __GLX_LOAD_VARIABLES(); - if (target == GL_PROXY_TEXTURE_1D) { - compsize = 0; - } else { - compsize = __glImageSize(width, 1, 1, format, type); - } - cmdlen = __GLX_PAD(__GLX_TEXIMAGE_CMD_HDR_SIZE + compsize); - if (!gc->currentDpy) return; - - if (cmdlen <= gc->maxSmallRenderCommandSize) { - /* Use GLXRender protocol to send small command */ - __GLX_BEGIN_VARIABLE_WITH_PIXEL(X_GLrop_TexImage1D,cmdlen); - __GLX_PUT_LONG(0,target); - __GLX_PUT_LONG(4,level); - __GLX_PUT_LONG(8,components); - __GLX_PUT_LONG(12,width); - __GLX_PUT_LONG(20,border); - __GLX_PUT_LONG(24,format); - __GLX_PUT_LONG(28,type); - pc += __GLX_TEXIMAGE_HDR_SIZE; - if (compsize > 0 && image != NULL) { - (*gc->fillImage)(gc, 1, width, 1, 1, format, type, - image, pc, pixelHeaderPC); - } else { - /* Setup default store modes */ - GLubyte *pc = pixelHeaderPC; - __GLX_PUT_CHAR(0,GL_FALSE); - __GLX_PUT_CHAR(1,GL_FALSE); - __GLX_PUT_CHAR(2,0); - __GLX_PUT_CHAR(3,0); - __GLX_PUT_LONG(4,0); - __GLX_PUT_LONG(8,0); - __GLX_PUT_LONG(12,0); - __GLX_PUT_LONG(16,1); - } - __GLX_END(__GLX_PAD(compsize)); - } else { - /* Use GLXRenderLarge protocol to send command */ - __GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL(X_GLrop_TexImage1D,cmdlen+4); - __GLX_PUT_LONG(0,target); - __GLX_PUT_LONG(4,level); - __GLX_PUT_LONG(8,components); - __GLX_PUT_LONG(12,width); - __GLX_PUT_LONG(16,1); - __GLX_PUT_LONG(20,border); - __GLX_PUT_LONG(24,format); - __GLX_PUT_LONG(28,type); - pc += __GLX_TEXIMAGE_HDR_SIZE; - if (image != NULL) { - SendLargeImage(gc, compsize, 1, width, 1, 1, format, - type, image, pc, pixelHeaderPC); - } else { - /* Setup default store modes */ - { - GLubyte *pc = pixelHeaderPC; - __GLX_PUT_CHAR(0,GL_FALSE); - __GLX_PUT_CHAR(1,GL_FALSE); - __GLX_PUT_CHAR(2,0); - __GLX_PUT_CHAR(3,0); - __GLX_PUT_LONG(4,0); - __GLX_PUT_LONG(8,0); - __GLX_PUT_LONG(12,0); - __GLX_PUT_LONG(16,1); - } - SendLargeNULLImage(gc, compsize, width, 1, 1, format, - type, image, pc, pixelHeaderPC); - } - } -} - -void __indirect_glTexImage2D(GLenum target, GLint level, GLint components, - GLsizei width, GLsizei height, GLint border, GLenum format, - GLenum type, const GLvoid *image) -{ - __GLX_DECLARE_VARIABLES(); - - __GLX_LOAD_VARIABLES(); - if (target == GL_PROXY_TEXTURE_2D || - target == GL_PROXY_TEXTURE_CUBE_MAP_ARB) { - compsize = 0; - } else { - compsize = __glImageSize(width, height, 1, format, type); - } - cmdlen = __GLX_PAD(__GLX_TEXIMAGE_CMD_HDR_SIZE + compsize); - if (!gc->currentDpy) return; - - if (cmdlen <= gc->maxSmallRenderCommandSize) { - /* Use GLXRender protocol to send small command */ - __GLX_BEGIN_VARIABLE_WITH_PIXEL(X_GLrop_TexImage2D,cmdlen); - __GLX_PUT_LONG(0,target); - __GLX_PUT_LONG(4,level); - __GLX_PUT_LONG(8,components); - __GLX_PUT_LONG(12,width); - __GLX_PUT_LONG(16,height); - __GLX_PUT_LONG(20,border); - __GLX_PUT_LONG(24,format); - __GLX_PUT_LONG(28,type); - pc += __GLX_TEXIMAGE_HDR_SIZE; - if (compsize > 0 && image != NULL) { - (*gc->fillImage)(gc, 2, width, height, 1, format, type, - image, pc, pixelHeaderPC); - } else { - /* Setup default store modes */ - GLubyte *pc = pixelHeaderPC; - __GLX_PUT_CHAR(0,GL_FALSE); - __GLX_PUT_CHAR(1,GL_FALSE); - __GLX_PUT_CHAR(2,0); - __GLX_PUT_CHAR(3,0); - __GLX_PUT_LONG(4,0); - __GLX_PUT_LONG(8,0); - __GLX_PUT_LONG(12,0); - __GLX_PUT_LONG(16,1); - } - __GLX_END(__GLX_PAD(compsize)); - } else { - /* Use GLXRenderLarge protocol to send command */ - __GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL(X_GLrop_TexImage2D,cmdlen+4); - __GLX_PUT_LONG(0,target); - __GLX_PUT_LONG(4,level); - __GLX_PUT_LONG(8,components); - __GLX_PUT_LONG(12,width); - __GLX_PUT_LONG(16,height); - __GLX_PUT_LONG(20,border); - __GLX_PUT_LONG(24,format); - __GLX_PUT_LONG(28,type); - pc += __GLX_TEXIMAGE_HDR_SIZE; - if (image != NULL) { - SendLargeImage(gc, compsize, 2, width, height, 1, format, - type, image, pc, pixelHeaderPC); - } else { - /* Setup default store modes */ - { - GLubyte *pc = pixelHeaderPC; - __GLX_PUT_CHAR(0,GL_FALSE); - __GLX_PUT_CHAR(1,GL_FALSE); - __GLX_PUT_CHAR(2,0); - __GLX_PUT_CHAR(3,0); - __GLX_PUT_LONG(4,0); - __GLX_PUT_LONG(8,0); - __GLX_PUT_LONG(12,0); - __GLX_PUT_LONG(16,1); - } - SendLargeNULLImage(gc, compsize, width, height, 1, format, - type, image, pc, pixelHeaderPC); - } - } -} - -void __indirect_glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, - const GLvoid *image) -{ - __GLX_DECLARE_VARIABLES(); - - __GLX_LOAD_VARIABLES(); - compsize = __glImageSize(width, height, 1, format, type); - cmdlen = __GLX_PAD(__GLX_DRAWPIXELS_CMD_HDR_SIZE + compsize); - if (!gc->currentDpy) return; - - if (cmdlen <= gc->maxSmallRenderCommandSize) { - /* Use GLXRender protocol to send small command */ - __GLX_BEGIN_VARIABLE_WITH_PIXEL(X_GLrop_DrawPixels,cmdlen); - __GLX_PUT_LONG(0,width); - __GLX_PUT_LONG(4,height); - __GLX_PUT_LONG(8,format); - __GLX_PUT_LONG(12,type); - pc += __GLX_DRAWPIXELS_HDR_SIZE; - if (compsize > 0) { - (*gc->fillImage)(gc, 2, width, height, 1, format, type, - image, pc, pixelHeaderPC); - } else { - /* Setup default store modes */ - GLubyte *pc = pixelHeaderPC; - __GLX_PUT_CHAR(0,GL_FALSE); - __GLX_PUT_CHAR(1,GL_FALSE); - __GLX_PUT_CHAR(2,0); - __GLX_PUT_CHAR(3,0); - __GLX_PUT_LONG(4,0); - __GLX_PUT_LONG(8,0); - __GLX_PUT_LONG(12,0); - __GLX_PUT_LONG(16,1); - } - __GLX_END(__GLX_PAD(compsize)); - } else { - /* Use GLXRenderLarge protocol to send command */ - __GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL(X_GLrop_DrawPixels,cmdlen+4); - __GLX_PUT_LONG(0,width); - __GLX_PUT_LONG(4,height); - __GLX_PUT_LONG(8,format); - __GLX_PUT_LONG(12,type); - pc += __GLX_DRAWPIXELS_HDR_SIZE; - SendLargeImage(gc, compsize, 2, width, height, 1, format, - type, image, pc, pixelHeaderPC); - } -} - -static void __glx_TexSubImage1D2D(GLshort opcode, GLenum target, GLint level, - GLint xoffset, GLint yoffset, GLsizei width, - GLsizei height, GLenum format, GLenum type, - const GLvoid *image, GLint dim) -{ - __GLX_DECLARE_VARIABLES(); - - __GLX_LOAD_VARIABLES(); - if (image == NULL) { - compsize = 0; - } else { - compsize = __glImageSize(width, height, 1, format, type); - } - - cmdlen = __GLX_PAD(__GLX_TEXSUBIMAGE_CMD_HDR_SIZE + compsize); - if (!gc->currentDpy) return; - - if (cmdlen <= gc->maxSmallRenderCommandSize) { - /* Use GLXRender protocol to send small command */ - __GLX_BEGIN_VARIABLE_WITH_PIXEL(opcode, cmdlen); - __GLX_PUT_LONG(0,target); - __GLX_PUT_LONG(4,level); - __GLX_PUT_LONG(8,xoffset); - __GLX_PUT_LONG(12,yoffset); - __GLX_PUT_LONG(16,width); - __GLX_PUT_LONG(20,height); - __GLX_PUT_LONG(24,format); - __GLX_PUT_LONG(28,type); - if (image == NULL) { - __GLX_PUT_LONG(32,GL_TRUE); - } else { - __GLX_PUT_LONG(32,GL_FALSE); - } - pc += __GLX_TEXSUBIMAGE_HDR_SIZE; - if (compsize > 0) { - (*gc->fillImage)(gc, dim, width, height, 1, format, type, image, - pc, pixelHeaderPC); - } else { - /* Setup default store modes */ - GLubyte *pc = pixelHeaderPC; - __GLX_PUT_CHAR(0,GL_FALSE); - __GLX_PUT_CHAR(1,GL_FALSE); - __GLX_PUT_CHAR(2,0); - __GLX_PUT_CHAR(3,0); - __GLX_PUT_LONG(4,0); - __GLX_PUT_LONG(8,0); - __GLX_PUT_LONG(12,0); - __GLX_PUT_LONG(16,1); - } - __GLX_END(__GLX_PAD(compsize)); - } else { - /* Use GLXRenderLarge protocol to send command */ - __GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL(opcode,cmdlen+4); - __GLX_PUT_LONG(0,target); - __GLX_PUT_LONG(4,level); - __GLX_PUT_LONG(8,xoffset); - __GLX_PUT_LONG(12,yoffset); - __GLX_PUT_LONG(16,width); - __GLX_PUT_LONG(20,height); - __GLX_PUT_LONG(24,format); - __GLX_PUT_LONG(28,type); - if (image == NULL) { - __GLX_PUT_LONG(32,GL_TRUE); - } else { - __GLX_PUT_LONG(32,GL_FALSE); - } - pc += __GLX_TEXSUBIMAGE_HDR_SIZE; - SendLargeImage(gc, compsize, dim, width, height, 1, - format, type, image, pc, pixelHeaderPC); - } -} - -void __indirect_glTexSubImage1D(GLenum target, GLint level, GLint xoffset, - GLsizei width, GLenum format, GLenum type, - const GLvoid *image) -{ - __glx_TexSubImage1D2D(X_GLrop_TexSubImage1D, target, level, xoffset, - 0, width, 1, format, type, image, 1); -} - -void __indirect_glTexSubImage2D(GLenum target, GLint level, GLint xoffset, - GLint yoffset, GLsizei width, GLsizei height, - GLenum format, GLenum type, const GLvoid *image) -{ - __glx_TexSubImage1D2D(X_GLrop_TexSubImage2D, target, level, xoffset, - yoffset, width, height, format, type, image, 2); -} - -void __indirect_glColorTable(GLenum target, GLenum internalformat, GLsizei width, - GLenum format, GLenum type, const GLvoid *table) -{ - __GLX_DECLARE_VARIABLES(); - - __GLX_LOAD_VARIABLES(); - switch (target) { - case GL_PROXY_TEXTURE_1D: - case GL_PROXY_TEXTURE_2D: - case GL_PROXY_TEXTURE_3D: - case GL_PROXY_COLOR_TABLE: - case GL_PROXY_POST_CONVOLUTION_COLOR_TABLE: - case GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE: - case GL_PROXY_TEXTURE_CUBE_MAP_ARB: - compsize = 0; - break; - default: - compsize = __glImageSize(width, 1, 1, format, type); - break; - } - cmdlen = __GLX_PAD(__GLX_COLOR_TABLE_CMD_HDR_SIZE + compsize); - if (!gc->currentDpy) { - return; - } - - if (cmdlen <= gc->maxSmallRenderCommandSize) { - /* Use GLXRender protocol to send small command */ - __GLX_BEGIN_VARIABLE_WITH_PIXEL(X_GLrop_ColorTable, (short)cmdlen); - __GLX_PUT_LONG(0, (long)target); - __GLX_PUT_LONG(4, (long)internalformat); - __GLX_PUT_LONG(8, width); - __GLX_PUT_LONG(12, (long)format); - __GLX_PUT_LONG(16, (long)type); - pc += __GLX_COLOR_TABLE_HDR_SIZE; - if (compsize > 0 && table != NULL) { - (*gc->fillImage)(gc, 1, width, 1, 1, format, type, table, pc, - pixelHeaderPC); - } else { - /* Setup default store modes */ - GLubyte *pc = pixelHeaderPC; - __GLX_PUT_CHAR(0, GL_FALSE); - __GLX_PUT_CHAR(1, GL_FALSE); - __GLX_PUT_CHAR(2, 0); - __GLX_PUT_CHAR(3, 0); - __GLX_PUT_LONG(4, 0); - __GLX_PUT_LONG(8, 0); - __GLX_PUT_LONG(12, 0); - __GLX_PUT_LONG(16, 1); - } - __GLX_END(__GLX_PAD(compsize)); - } else { - /* Use GLXRenderLarge protocol to send command */ - __GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL(X_GLrop_ColorTable, cmdlen+4); - __GLX_PUT_LONG(0, (long)target); - __GLX_PUT_LONG(4, (long)internalformat); - __GLX_PUT_LONG(8, width); - __GLX_PUT_LONG(12, (long)format); - __GLX_PUT_LONG(16, (long)type); - pc += __GLX_COLOR_TABLE_HDR_SIZE; - SendLargeImage(gc, compsize, 1, width, 1, 1, format, - type, table, pc, pixelHeaderPC); - } -} - -void __indirect_glColorSubTable(GLenum target, GLsizei start, GLsizei count, - GLenum format, GLenum type, const GLvoid *table) -{ - __GLX_DECLARE_VARIABLES(); - - __GLX_LOAD_VARIABLES(); - compsize = __glImageSize(count, 1, 1, format, type); - cmdlen = __GLX_PAD(__GLX_COLOR_SUBTABLE_CMD_HDR_SIZE + compsize); - if (!gc->currentDpy) { - return; - } - - if (cmdlen <= gc->maxSmallRenderCommandSize) { - /* Use GLXRender protocol to send small command */ - __GLX_BEGIN_VARIABLE_WITH_PIXEL(X_GLrop_ColorSubTable, (short)cmdlen); - __GLX_PUT_LONG(0, (long)target); - __GLX_PUT_LONG(4, start); - __GLX_PUT_LONG(8, count); - __GLX_PUT_LONG(12, (long)format); - __GLX_PUT_LONG(16, (long)type); - pc += __GLX_COLOR_SUBTABLE_HDR_SIZE; - if (compsize > 0 && table != NULL) { - (*gc->fillImage)(gc, 1, start+count, 1, 1, format, type, table, pc, - pixelHeaderPC); - } else { - /* Setup default store modes */ - GLubyte *pc = pixelHeaderPC; - __GLX_PUT_CHAR(0, GL_FALSE); - __GLX_PUT_CHAR(1, GL_FALSE); - __GLX_PUT_CHAR(2, 0); - __GLX_PUT_CHAR(3, 0); - __GLX_PUT_LONG(4, 0); - __GLX_PUT_LONG(8, 0); - __GLX_PUT_LONG(12, 0); - __GLX_PUT_LONG(16, 1); - } - __GLX_END(__GLX_PAD(compsize)); - } else { - /* Use GLXRenderLarge protocol to send command */ - __GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL(X_GLrop_ColorSubTable, cmdlen+4); - __GLX_PUT_LONG(0, (long)target); - __GLX_PUT_LONG(4, start); - __GLX_PUT_LONG(8, count); - __GLX_PUT_LONG(12, (long)format); - __GLX_PUT_LONG(16, (long)type); - pc += __GLX_COLOR_SUBTABLE_HDR_SIZE; - SendLargeImage(gc, compsize, 1, start+count, 1, 1, format, - type, table, pc, pixelHeaderPC); - } -} - -static void __glx_ConvolutionFilter1D2D(GLshort opcode, GLint dim, - GLenum target, - GLenum internalformat, - GLsizei width, GLsizei height, - GLenum format, GLenum type, const GLvoid *image) -{ - __GLX_DECLARE_VARIABLES(); - - __GLX_LOAD_VARIABLES(); - compsize = __glImageSize(width, height, 1, format, type); - cmdlen = __GLX_PAD(__GLX_CONV_FILT_CMD_HDR_SIZE + compsize); - if (!gc->currentDpy) return; - - if (cmdlen <= gc->maxSmallRenderCommandSize) { - /* Use GLXRender protocol to send small command */ - __GLX_BEGIN_VARIABLE_WITH_PIXEL(opcode, cmdlen); - __GLX_PUT_LONG(0,target); - __GLX_PUT_LONG(4,internalformat); - __GLX_PUT_LONG(8,width); - __GLX_PUT_LONG(12,height); - __GLX_PUT_LONG(16,format); - __GLX_PUT_LONG(20,type); - pc += __GLX_CONV_FILT_HDR_SIZE; - if (compsize > 0) { - (*gc->fillImage)(gc, dim, width, height, 1, format, type, - image, pc, pixelHeaderPC); - } else { - /* Setup default store modes */ - GLubyte *pc = pixelHeaderPC; - __GLX_PUT_CHAR(0,GL_FALSE); - __GLX_PUT_CHAR(1,GL_FALSE); - __GLX_PUT_CHAR(2,0); - __GLX_PUT_CHAR(3,0); - __GLX_PUT_LONG(4,0); - __GLX_PUT_LONG(8,0); - __GLX_PUT_LONG(12,0); - __GLX_PUT_LONG(16,1); - } - __GLX_END(__GLX_PAD(compsize)); - } else { - /* Use GLXRenderLarge protocol to send command */ - __GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL(opcode,cmdlen+4); - __GLX_PUT_LONG(0,target); - __GLX_PUT_LONG(4,internalformat); - __GLX_PUT_LONG(8,width); - __GLX_PUT_LONG(12,height); - __GLX_PUT_LONG(16,format); - __GLX_PUT_LONG(20,type); - pc += __GLX_CONV_FILT_HDR_SIZE; - SendLargeImage(gc, compsize, dim, width, height, 1, format, - type, image, pc, pixelHeaderPC); - } -} - -void __indirect_glConvolutionFilter1D(GLenum target, GLenum internalformat, - GLsizei width, GLenum format, - GLenum type, const GLvoid *image) -{ - __glx_ConvolutionFilter1D2D(X_GLrop_ConvolutionFilter1D, 1, target, - internalformat, width, 1, format, type, - image); -} - -void __indirect_glConvolutionFilter2D(GLenum target, GLenum internalformat, - GLsizei width, GLsizei height, GLenum format, - GLenum type, const GLvoid *image) -{ - __glx_ConvolutionFilter1D2D(X_GLrop_ConvolutionFilter2D, 2, target, - internalformat, width, height, format, type, - image); -} - +/** + * Implement GLX protocol for \c glSeparableFilter2D. + * + * \bugs + * The \c fastImageUnpack path, which is thankfully never used, is completely + * broken. + */ void __indirect_glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, @@ -663,8 +143,8 @@ void __indirect_glSeparableFilter2D(GLenum target, GLenum internalformat, GLuint compsize2, hdrlen, totalhdrlen, image1len, image2len; __GLX_LOAD_VARIABLES(); - compsize = __glImageSize(width, 1, 1, format, type); - compsize2 = __glImageSize(height, 1, 1, format, type); + compsize = __glImageSize(width, 1, 1, format, type, 0); + compsize2 = __glImageSize(height, 1, 1, format, type, 0); totalhdrlen = __GLX_PAD(__GLX_CONV_FILT_CMD_HDR_SIZE); hdrlen = __GLX_PAD(__GLX_CONV_FILT_HDR_SIZE); image1len = __GLX_PAD(compsize); @@ -694,21 +174,11 @@ void __indirect_glSeparableFilter2D(GLenum target, GLenum internalformat, } if ((compsize == 0) && (compsize2 == 0)) { /* Setup default store modes */ - GLubyte *pc = pixelHeaderPC; - __GLX_PUT_CHAR(0,GL_FALSE); - __GLX_PUT_CHAR(1,GL_FALSE); - __GLX_PUT_CHAR(2,0); - __GLX_PUT_CHAR(3,0); - __GLX_PUT_LONG(4,0); - __GLX_PUT_LONG(8,0); - __GLX_PUT_LONG(12,0); - __GLX_PUT_LONG(16,1); + (void) memcpy( pixelHeaderPC, __glXDefaultPixelStore + 4, 20 ); } __GLX_END(0); } else { - GLint bufsize; - - bufsize = image1len + image2len; + const GLint bufsize = image1len + image2len; /* Use GLXRenderLarge protocol to send command */ __GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL(X_GLrop_SeparableFilter2D,cmdlen+4); @@ -742,165 +212,3 @@ void __indirect_glSeparableFilter2D(GLenum target, GLenum internalformat, } } } - -void __indirect_glTexImage3D(GLenum target, GLint level, GLint internalformat, - GLsizei width, GLsizei height, GLsizei depth, GLint border, - GLenum format, GLenum type, const GLvoid *image) -{ - __GLX_DECLARE_VARIABLES(); - - __GLX_LOAD_VARIABLES(); - if ((target == GL_PROXY_TEXTURE_3D) || (image == NULL)) { - compsize = 0; - } else { - compsize = __glImageSize(width, height, depth, format, type); - } - cmdlen = __GLX_PAD(__GLX_TEXIMAGE_3D_CMD_HDR_SIZE + compsize); - if (!gc->currentDpy) return; - - if (cmdlen <= gc->maxSmallRenderCommandSize) { - /* Use GLXRender protocol to send small command */ - __GLX_BEGIN_VARIABLE_WITH_PIXEL_3D(X_GLrop_TexImage3D,cmdlen); - __GLX_PUT_LONG(0,target); - __GLX_PUT_LONG(4,level); - __GLX_PUT_LONG(8,internalformat); - __GLX_PUT_LONG(12,width); - __GLX_PUT_LONG(16,height); - __GLX_PUT_LONG(20,depth); - __GLX_PUT_LONG(24,0); /* size4d */ - __GLX_PUT_LONG(28,border); - __GLX_PUT_LONG(32,format); - __GLX_PUT_LONG(36,type); - if (image == NULL) { - __GLX_PUT_LONG(40,GL_TRUE); - } else { - __GLX_PUT_LONG(40,GL_FALSE); - } - pc += __GLX_TEXIMAGE_3D_HDR_SIZE; - if (compsize > 0 && image != NULL) { - (*gc->fillImage)(gc, 3, width, height, depth, format, type, - image, pc, pixelHeaderPC); - } else { - /* Setup default store modes */ - GLubyte *pc = pixelHeaderPC; - __GLX_PUT_CHAR(0,GL_FALSE); - __GLX_PUT_CHAR(1,GL_FALSE); - __GLX_PUT_CHAR(2,0); - __GLX_PUT_CHAR(3,0); - __GLX_PUT_LONG(4,0); - __GLX_PUT_LONG(8,0); - __GLX_PUT_LONG(12,0); - __GLX_PUT_LONG(16,0); - __GLX_PUT_LONG(20,0); - __GLX_PUT_LONG(24,0); - __GLX_PUT_LONG(28,0); - __GLX_PUT_LONG(32,1); - } - __GLX_END(__GLX_PAD(compsize)); - } else { - /* Use GLXRenderLarge protocol to send command */ - __GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL_3D(X_GLrop_TexImage3D,cmdlen+4); - __GLX_PUT_LONG(0,target); - __GLX_PUT_LONG(4,level); - __GLX_PUT_LONG(8,internalformat); - __GLX_PUT_LONG(12,width); - __GLX_PUT_LONG(16,height); - __GLX_PUT_LONG(20,depth); - __GLX_PUT_LONG(24,0); /* size4d */ - __GLX_PUT_LONG(28,border); - __GLX_PUT_LONG(32,format); - __GLX_PUT_LONG(36,type); - if (image == NULL) { - __GLX_PUT_LONG(40,GL_TRUE); - } else { - __GLX_PUT_LONG(40,GL_FALSE); - } - pc += __GLX_TEXIMAGE_3D_HDR_SIZE; - SendLargeImage(gc, compsize, 3, width, height, depth, format, - type, image, pc, pixelHeaderPC); - } -} - -void __indirect_glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, - GLint zoffset, GLsizei width, GLsizei height, - GLsizei depth, GLenum format, GLenum type, - const GLvoid *image) -{ - __GLX_DECLARE_VARIABLES(); - - __GLX_LOAD_VARIABLES(); - if (image == NULL) { - compsize = 0; - } else { - compsize = __glImageSize(width, height, depth, format, type); - } - cmdlen = __GLX_PAD(__GLX_TEXSUBIMAGE_3D_CMD_HDR_SIZE + compsize); - if (!gc->currentDpy) return; - - if (cmdlen <= gc->maxSmallRenderCommandSize) { - /* Use GLXRender protocol to send small command */ - __GLX_BEGIN_VARIABLE_WITH_PIXEL_3D(X_GLrop_TexSubImage3D,cmdlen); - __GLX_PUT_LONG(0,target); - __GLX_PUT_LONG(4,level); - __GLX_PUT_LONG(8,xoffset); - __GLX_PUT_LONG(12,yoffset); - __GLX_PUT_LONG(16,zoffset); - __GLX_PUT_LONG(20,0); /* woffset */ - __GLX_PUT_LONG(24,width); - __GLX_PUT_LONG(28,height); - __GLX_PUT_LONG(32,depth); - __GLX_PUT_LONG(36,0); /* size4d */ - __GLX_PUT_LONG(40,format); - __GLX_PUT_LONG(44,type); - if (image == NULL) { - __GLX_PUT_LONG(48,GL_TRUE); - } else { - __GLX_PUT_LONG(48,GL_FALSE); - } - pc += __GLX_TEXSUBIMAGE_3D_HDR_SIZE; - if (compsize > 0) { - (*gc->fillImage)(gc, 3, width, height, depth, format, type, image, - pc, pixelHeaderPC); - } else { - /* Setup default store modes */ - GLubyte *pc = pixelHeaderPC; - __GLX_PUT_CHAR(0,GL_FALSE); - __GLX_PUT_CHAR(1,GL_FALSE); - __GLX_PUT_CHAR(2,0); - __GLX_PUT_CHAR(3,0); - __GLX_PUT_LONG(4,0); - __GLX_PUT_LONG(8,0); - __GLX_PUT_LONG(12,0); - __GLX_PUT_LONG(16,0); - __GLX_PUT_LONG(20,0); - __GLX_PUT_LONG(24,0); - __GLX_PUT_LONG(28,0); - __GLX_PUT_LONG(32,1); - } - __GLX_END(__GLX_PAD(compsize)); - } else { - /* Use GLXRenderLarge protocol to send command */ - __GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL_3D(X_GLrop_TexSubImage3D, - cmdlen+4); - __GLX_PUT_LONG(0,target); - __GLX_PUT_LONG(4,level); - __GLX_PUT_LONG(8,xoffset); - __GLX_PUT_LONG(12,yoffset); - __GLX_PUT_LONG(16,zoffset); - __GLX_PUT_LONG(20,0); /* woffset */ - __GLX_PUT_LONG(24,width); - __GLX_PUT_LONG(28,height); - __GLX_PUT_LONG(32,depth); - __GLX_PUT_LONG(36,0); /* size4d */ - __GLX_PUT_LONG(40,format); - __GLX_PUT_LONG(44,type); - if (image == NULL) { - __GLX_PUT_LONG(48,GL_TRUE); - } else { - __GLX_PUT_LONG(48,GL_FALSE); - } - pc += __GLX_TEXSUBIMAGE_3D_HDR_SIZE; - SendLargeImage(gc, compsize, 3, width, height, depth, format, type, - image, pc, pixelHeaderPC); - } -} diff --git a/src/glx/x11/singlepix.c b/src/glx/x11/singlepix.c index b387a809803..d2e8860d1f3 100644 --- a/src/glx/x11/singlepix.c +++ b/src/glx/x11/singlepix.c @@ -280,8 +280,8 @@ void __indirect_glGetSeparableFilter(GLenum target, GLenum format, GLenum type, width = reply.width; height = reply.height; - widthsize = __glImageSize(width,1,1,format, type); - heightsize = __glImageSize(height,1,1,format, type); + widthsize = __glImageSize(width,1,1,format, type, 0); + heightsize = __glImageSize(height,1,1,format, type, 0); /* Allocate a holding buffer to transform the data from */ rowBuf = (GLubyte*) Xmalloc(widthsize); diff --git a/src/glx/x11/size.h b/src/glx/x11/size.h deleted file mode 100644 index 80a721e54b4..00000000000 --- a/src/glx/x11/size.h +++ /dev/null @@ -1,53 +0,0 @@ -/* $XFree86: xc/lib/GL/glx/size.h,v 1.4 2003/09/28 20:15:04 alanh Exp $ */ -#ifndef _size_h_ -#define _size_h_ - -/* -** License Applicability. Except to the extent portions of this file are -** made subject to an alternative license as permitted in the SGI Free -** Software License B, Version 1.1 (the "License"), the contents of this -** file are subject only to the provisions of the License. You may not use -** this file except in compliance with the License. You may obtain a copy -** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 -** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: -** -** http://oss.sgi.com/projects/FreeB -** -** Note that, as provided in the License, the Software is distributed on an -** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS -** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND -** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A -** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. -** -** Original Code. The Original Code is: OpenGL Sample Implementation, -** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, -** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. -** Copyright in any portions created by third parties is as indicated -** elsewhere herein. All Rights Reserved. -** -** Additional Notice Provisions: The application programming interfaces -** established by SGI in conjunction with the Original Code are The -** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released -** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version -** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X -** Window System(R) (Version 1.3), released October 19, 1998. This software -** was created using the OpenGL(R) version 1.2.1 Sample Implementation -** published by SGI, but has not been independently verified as being -** compliant with the OpenGL(R) version 1.2.1 Specification. -** -*/ - -/* -** These are _size functions that are needed to pack the arguments -** into the protocol -*/ - -#include "indirect_size.h" - -extern GLint __glBitmap_size(GLsizei w, GLsizei h); -extern GLint __glDrawPixels_size(GLenum format, GLenum type, GLsizei w,GLsizei h); -extern GLint __glTexImage1D_size(GLenum format, GLenum type, GLsizei w); -extern GLint __glTexImage2D_size(GLenum format, GLenum type, GLsizei w, GLsizei h); -extern GLint __glTexImage3D_size(GLenum format, GLenum type, GLsizei w, GLsizei h, GLsizei d); - -#endif /* _size_h_ */ |