From 23bfc6dfe5b3d2feedd689c91ed05eb84e29d46e Mon Sep 17 00:00:00 2001 From: "jinhyung.jo" Date: Wed, 26 Mar 2014 17:20:03 +0900 Subject: [PATCH] VirtGL : Modified source files as the QEMU coding style Change-Id: If1134995efeaabc9502cfec5bd0f2005f6d43af1 Signed-off-by: Jinhyung Jo --- tizen/src/hw/mesa_mipmap.c | 1448 +++++++++++------------ tizen/src/hw/opengl_exec.c | 2261 +++++++++++++++++++----------------- tizen/src/hw/parse_gl_h.c | 999 ++++++++-------- tizen/src/hw/virtio-gl.c | 309 +++-- 4 files changed, 2530 insertions(+), 2487 deletions(-) diff --git a/tizen/src/hw/mesa_mipmap.c b/tizen/src/hw/mesa_mipmap.c index b6e6bbe942..a728f72ec6 100644 --- a/tizen/src/hw/mesa_mipmap.c +++ b/tizen/src/hw/mesa_mipmap.c @@ -29,14 +29,13 @@ #include #include #include -//#include "gluP.h" #endif /* * Compute ceiling of integer quotient of A divided by B: */ -#define CEILING( A, B ) ( (A) % (B) == 0 ? (A)/(B) : (A)/(B)+1 ) +#define CEILING(A, B) ((A) % (B) == 0 ? (A) / (B) : (A) / (B) + 1) @@ -48,8 +47,7 @@ /* To work around optimizer bug in MSVC4.1 */ #if defined(__WIN32__) && !defined(OPENSTEP) -void -dummy(GLuint j, GLuint k) +void dummy(GLuint j, GLuint k) { } #else @@ -57,462 +55,464 @@ dummy(GLuint j, GLuint k) #endif -static GLint GLAPIENTRY -mesa_gluScaleImage(GLenum format, - GLsizei widthin, GLsizei heightin, - GLenum typein, const void *datain, - GLsizei widthout, GLsizei heightout, - GLenum typeout, void *dataout) +static GLint GLAPIENTRY mesa_gluScaleImage(GLenum format, + GLsizei widthin, GLsizei heightin, + GLenum typein, const void *datain, + GLsizei widthout, GLsizei heightout, + GLenum typeout, void *dataout) { - GLint components, i, j, k; - GLfloat *tempin, *tempout; - GLfloat sx, sy; - GLint unpackrowlength, unpackalignment, unpackskiprows, unpackskippixels; - GLint packrowlength, packalignment, packskiprows, packskippixels; - GLint sizein, sizeout; - GLint rowstride, rowlen; - - - /* Determine number of components per pixel */ - switch (format) { - case GL_COLOR_INDEX: - case GL_STENCIL_INDEX: - case GL_DEPTH_COMPONENT: - case GL_RED: - case GL_GREEN: - case GL_BLUE: - case GL_ALPHA: - case GL_LUMINANCE: - components = 1; - break; - case GL_LUMINANCE_ALPHA: - components = 2; - break; - case GL_RGB: - case GL_BGR: - components = 3; - break; - case GL_RGBA: - case GL_BGRA: + GLint components, i, j, k; + GLfloat *tempin, *tempout; + GLfloat sx, sy; + GLint unpackrowlength, unpackalignment, unpackskiprows, unpackskippixels; + GLint packrowlength, packalignment, packskiprows, packskippixels; + GLint sizein, sizeout; + GLint rowstride, rowlen; + + /* Determine number of components per pixel */ + switch (format) { + case GL_COLOR_INDEX: + case GL_STENCIL_INDEX: + case GL_DEPTH_COMPONENT: + case GL_RED: + case GL_GREEN: + case GL_BLUE: + case GL_ALPHA: + case GL_LUMINANCE: + components = 1; + break; + case GL_LUMINANCE_ALPHA: + components = 2; + break; + case GL_RGB: + case GL_BGR: + components = 3; + break; + case GL_RGBA: + case GL_BGRA: #ifdef GL_EXT_abgr - case GL_ABGR_EXT: + case GL_ABGR_EXT: #endif - components = 4; - break; - default: - return GLU_INVALID_ENUM; - } - - /* Determine bytes per input datum */ - switch (typein) { - case GL_UNSIGNED_BYTE: - sizein = sizeof(GLubyte); - break; - case GL_BYTE: - sizein = sizeof(GLbyte); - break; - case GL_UNSIGNED_SHORT: - sizein = sizeof(GLushort); - break; - case GL_SHORT: - sizein = sizeof(GLshort); - break; - case GL_UNSIGNED_INT: - sizein = sizeof(GLuint); - break; - case GL_INT: - sizein = sizeof(GLint); - break; - case GL_FLOAT: - sizein = sizeof(GLfloat); - break; - case GL_BITMAP: - /* not implemented yet */ - default: - return GL_INVALID_ENUM; - } - - /* Determine bytes per output datum */ - switch (typeout) { - case GL_UNSIGNED_BYTE: - sizeout = sizeof(GLubyte); - break; - case GL_BYTE: - sizeout = sizeof(GLbyte); - break; - case GL_UNSIGNED_SHORT: - sizeout = sizeof(GLushort); - break; - case GL_SHORT: - sizeout = sizeof(GLshort); - break; - case GL_UNSIGNED_INT: - sizeout = sizeof(GLuint); - break; - case GL_INT: - sizeout = sizeof(GLint); - break; - case GL_FLOAT: - sizeout = sizeof(GLfloat); - break; - case GL_BITMAP: - /* not implemented yet */ - default: - return GL_INVALID_ENUM; - } - - /* Get glPixelStore state */ - glGetIntegerv(GL_UNPACK_ROW_LENGTH, &unpackrowlength); - glGetIntegerv(GL_UNPACK_ALIGNMENT, &unpackalignment); - glGetIntegerv(GL_UNPACK_SKIP_ROWS, &unpackskiprows); - glGetIntegerv(GL_UNPACK_SKIP_PIXELS, &unpackskippixels); - glGetIntegerv(GL_PACK_ROW_LENGTH, &packrowlength); - glGetIntegerv(GL_PACK_ALIGNMENT, &packalignment); - glGetIntegerv(GL_PACK_SKIP_ROWS, &packskiprows); - glGetIntegerv(GL_PACK_SKIP_PIXELS, &packskippixels); - - /* Allocate storage for intermediate images */ - tempin = (GLfloat *) malloc(widthin * heightin - * components * sizeof(GLfloat)); - if (!tempin) { - return GLU_OUT_OF_MEMORY; - } - tempout = (GLfloat *) malloc(widthout * heightout - * components * sizeof(GLfloat)); - if (!tempout) { - free(tempin); - return GLU_OUT_OF_MEMORY; - } - - - /* - * Unpack the pixel data and convert to floating point - */ - - if (unpackrowlength > 0) { - rowlen = unpackrowlength; - } - else { - rowlen = widthin; - } - if (sizein >= unpackalignment) { - rowstride = components * rowlen; - } - else { - rowstride = unpackalignment / sizein - * CEILING(components * rowlen * sizein, unpackalignment); - } - - switch (typein) { - case GL_UNSIGNED_BYTE: - k = 0; - for (i = 0; i < heightin; i++) { - GLubyte *ubptr = (GLubyte *) datain - + i * rowstride - + unpackskiprows * rowstride + unpackskippixels * components; - for (j = 0; j < widthin * components; j++) { - dummy(j, k); - tempin[k++] = (GLfloat) * ubptr++; - } - } - break; - case GL_BYTE: - k = 0; - for (i = 0; i < heightin; i++) { - GLbyte *bptr = (GLbyte *) datain - + i * rowstride - + unpackskiprows * rowstride + unpackskippixels * components; - for (j = 0; j < widthin * components; j++) { - dummy(j, k); - tempin[k++] = (GLfloat) * bptr++; - } - } - break; - case GL_UNSIGNED_SHORT: - k = 0; - for (i = 0; i < heightin; i++) { - GLushort *usptr = (GLushort *) datain - + i * rowstride - + unpackskiprows * rowstride + unpackskippixels * components; - for (j = 0; j < widthin * components; j++) { - dummy(j, k); - tempin[k++] = (GLfloat) * usptr++; - } - } - break; - case GL_SHORT: - k = 0; - for (i = 0; i < heightin; i++) { - GLshort *sptr = (GLshort *) datain - + i * rowstride - + unpackskiprows * rowstride + unpackskippixels * components; - for (j = 0; j < widthin * components; j++) { - dummy(j, k); - tempin[k++] = (GLfloat) * sptr++; - } - } - break; - case GL_UNSIGNED_INT: - k = 0; - for (i = 0; i < heightin; i++) { - GLuint *uiptr = (GLuint *) datain - + i * rowstride - + unpackskiprows * rowstride + unpackskippixels * components; - for (j = 0; j < widthin * components; j++) { - dummy(j, k); - tempin[k++] = (GLfloat) * uiptr++; - } - } - break; - case GL_INT: - k = 0; - for (i = 0; i < heightin; i++) { - GLint *iptr = (GLint *) datain - + i * rowstride - + unpackskiprows * rowstride + unpackskippixels * components; - for (j = 0; j < widthin * components; j++) { - dummy(j, k); - tempin[k++] = (GLfloat) * iptr++; - } - } - break; - case GL_FLOAT: - k = 0; - for (i = 0; i < heightin; i++) { - GLfloat *fptr = (GLfloat *) datain - + i * rowstride - + unpackskiprows * rowstride + unpackskippixels * components; - for (j = 0; j < widthin * components; j++) { - dummy(j, k); - tempin[k++] = *fptr++; - } - } - break; - default: - return GLU_INVALID_ENUM; - } - - - /* - * Scale the image! - */ - - if (widthout > 1) - sx = (GLfloat) (widthin - 1) / (GLfloat) (widthout - 1); - else - sx = (GLfloat) (widthin - 1); - if (heightout > 1) - sy = (GLfloat) (heightin - 1) / (GLfloat) (heightout - 1); - else - sy = (GLfloat) (heightin - 1); + components = 4; + break; + default: + return GLU_INVALID_ENUM; + } + + /* Determine bytes per input datum */ + switch (typein) { + case GL_UNSIGNED_BYTE: + sizein = sizeof(GLubyte); + break; + case GL_BYTE: + sizein = sizeof(GLbyte); + break; + case GL_UNSIGNED_SHORT: + sizein = sizeof(GLushort); + break; + case GL_SHORT: + sizein = sizeof(GLshort); + break; + case GL_UNSIGNED_INT: + sizein = sizeof(GLuint); + break; + case GL_INT: + sizein = sizeof(GLint); + break; + case GL_FLOAT: + sizein = sizeof(GLfloat); + break; + case GL_BITMAP: + /* not implemented yet */ + default: + return GL_INVALID_ENUM; + } + + /* Determine bytes per output datum */ + switch (typeout) { + case GL_UNSIGNED_BYTE: + sizeout = sizeof(GLubyte); + break; + case GL_BYTE: + sizeout = sizeof(GLbyte); + break; + case GL_UNSIGNED_SHORT: + sizeout = sizeof(GLushort); + break; + case GL_SHORT: + sizeout = sizeof(GLshort); + break; + case GL_UNSIGNED_INT: + sizeout = sizeof(GLuint); + break; + case GL_INT: + sizeout = sizeof(GLint); + break; + case GL_FLOAT: + sizeout = sizeof(GLfloat); + break; + case GL_BITMAP: + /* not implemented yet */ + default: + return GL_INVALID_ENUM; + } + + /* Get glPixelStore state */ + glGetIntegerv(GL_UNPACK_ROW_LENGTH, &unpackrowlength); + glGetIntegerv(GL_UNPACK_ALIGNMENT, &unpackalignment); + glGetIntegerv(GL_UNPACK_SKIP_ROWS, &unpackskiprows); + glGetIntegerv(GL_UNPACK_SKIP_PIXELS, &unpackskippixels); + glGetIntegerv(GL_PACK_ROW_LENGTH, &packrowlength); + glGetIntegerv(GL_PACK_ALIGNMENT, &packalignment); + glGetIntegerv(GL_PACK_SKIP_ROWS, &packskiprows); + glGetIntegerv(GL_PACK_SKIP_PIXELS, &packskippixels); + + /* Allocate storage for intermediate images */ + tempin = (GLfloat *)malloc(widthin * heightin * components * + sizeof(GLfloat)); + if (!tempin) { + return GLU_OUT_OF_MEMORY; + } + tempout = (GLfloat *)malloc(widthout * heightout * components * + sizeof(GLfloat)); + if (!tempout) { + free(tempin); + return GLU_OUT_OF_MEMORY; + } + + + /* + * Unpack the pixel data and convert to floating point + */ + + if (unpackrowlength > 0) { + rowlen = unpackrowlength; + } else { + rowlen = widthin; + } + if (sizein >= unpackalignment) { + rowstride = components * rowlen; + } else { + rowstride = unpackalignment / sizein * CEILING(components * + rowlen * sizein, + unpackalignment); + } + + switch (typein) { + case GL_UNSIGNED_BYTE: + k = 0; + for (i = 0; i < heightin; i++) { + GLubyte *ubptr = (GLubyte *)datain + i * rowstride + + unpackskiprows * rowstride + + unpackskippixels * components; + for (j = 0; j < widthin * components; j++) { + dummy(j, k); + tempin[k++] = (GLfloat)*ubptr++; + } + } + break; + case GL_BYTE: + k = 0; + for (i = 0; i < heightin; i++) { + GLbyte *bptr = (GLbyte *)datain + i * rowstride + + unpackskiprows * rowstride + + unpackskippixels * components; + for (j = 0; j < widthin * components; j++) { + dummy(j, k); + tempin[k++] = (GLfloat)*bptr++; + } + } + break; + case GL_UNSIGNED_SHORT: + k = 0; + for (i = 0; i < heightin; i++) { + GLushort *usptr = (GLushort *)datain + i * rowstride + + unpackskiprows * rowstride + + unpackskippixels * components; + for (j = 0; j < widthin * components; j++) { + dummy(j, k); + tempin[k++] = (GLfloat)*usptr++; + } + } + break; + case GL_SHORT: + k = 0; + for (i = 0; i < heightin; i++) { + GLshort *sptr = (GLshort *)datain + i * rowstride + + unpackskiprows * rowstride + + unpackskippixels * components; + for (j = 0; j < widthin * components; j++) { + dummy(j, k); + tempin[k++] = (GLfloat)*sptr++; + } + } + break; + case GL_UNSIGNED_INT: + k = 0; + for (i = 0; i < heightin; i++) { + GLuint *uiptr = (GLuint *)datain + i * rowstride + + unpackskiprows * rowstride + + unpackskippixels * components; + for (j = 0; j < widthin * components; j++) { + dummy(j, k); + tempin[k++] = (GLfloat)*uiptr++; + } + } + break; + case GL_INT: + k = 0; + for (i = 0; i < heightin; i++) { + GLint *iptr = (GLint *)datain + i * rowstride + + unpackskiprows * rowstride + + unpackskippixels * components; + for (j = 0; j < widthin * components; j++) { + dummy(j, k); + tempin[k++] = (GLfloat)*iptr++; + } + } + break; + case GL_FLOAT: + k = 0; + for (i = 0; i < heightin; i++) { + GLfloat *fptr = (GLfloat *)datain + i * rowstride + + unpackskiprows * rowstride + + unpackskippixels * components; + for (j = 0; j < widthin * components; j++) { + dummy(j, k); + tempin[k++] = *fptr++; + } + } + break; + default: + return GLU_INVALID_ENUM; + } + + /* + * Scale the image! + */ + + if (widthout > 1) { + sx = (GLfloat) (widthin - 1) / (GLfloat) (widthout - 1); + } else { + sx = (GLfloat) (widthin - 1); + } + if (heightout > 1) { + sy = (GLfloat) (heightin - 1) / (GLfloat) (heightout - 1); + } else { + sy = (GLfloat) (heightin - 1); + } /*#define POINT_SAMPLE*/ #ifdef POINT_SAMPLE - for (i = 0; i < heightout; i++) { - GLint ii = i * sy; - for (j = 0; j < widthout; j++) { - GLint jj = j * sx; - - GLfloat *src = tempin + (ii * widthin + jj) * components; - GLfloat *dst = tempout + (i * widthout + j) * components; - - for (k = 0; k < components; k++) { - *dst++ = *src++; - } - } - } + for (i = 0; i < heightout; i++) { + GLint ii = i * sy; + for (j = 0; j < widthout; j++) { + GLint jj = j * sx; + + GLfloat *src = tempin + (ii * widthin + jj) * components; + GLfloat *dst = tempout + (i * widthout + j) * components; + + for (k = 0; k < components; k++) { + *dst++ = *src++; + } + } + } #else - if (sx < 1.0 && sy < 1.0) { - /* magnify both width and height: use weighted sample of 4 pixels */ - GLint i0, i1, j0, j1; - GLfloat alpha, beta; - GLfloat *src00, *src01, *src10, *src11; - GLfloat s1, s2; - GLfloat *dst; - - for (i = 0; i < heightout; i++) { - i0 = i * sy; - i1 = i0 + 1; - if (i1 >= heightin) - i1 = heightin - 1; -/* i1 = (i+1) * sy - EPSILON;*/ - alpha = i * sy - i0; - for (j = 0; j < widthout; j++) { - j0 = j * sx; - j1 = j0 + 1; - if (j1 >= widthin) - j1 = widthin - 1; -/* j1 = (j+1) * sx - EPSILON; */ - beta = j * sx - j0; - - /* compute weighted average of pixels in rect (i0,j0)-(i1,j1) */ - src00 = tempin + (i0 * widthin + j0) * components; - src01 = tempin + (i0 * widthin + j1) * components; - src10 = tempin + (i1 * widthin + j0) * components; - src11 = tempin + (i1 * widthin + j1) * components; - - dst = tempout + (i * widthout + j) * components; - - for (k = 0; k < components; k++) { - s1 = *src00++ * (1.0 - beta) + *src01++ * beta; - s2 = *src10++ * (1.0 - beta) + *src11++ * beta; - *dst++ = s1 * (1.0 - alpha) + s2 * alpha; - } - } - } - } - else { - /* shrink width and/or height: use an unweighted box filter */ - GLint i0, i1; - GLint j0, j1; - GLint ii, jj; - GLfloat sum, *dst; - - for (i = 0; i < heightout; i++) { - i0 = i * sy; - i1 = i0 + 1; - if (i1 >= heightin) - i1 = heightin - 1; -/* i1 = (i+1) * sy - EPSILON; */ - for (j = 0; j < widthout; j++) { - j0 = j * sx; - j1 = j0 + 1; - if (j1 >= widthin) - j1 = widthin - 1; -/* j1 = (j+1) * sx - EPSILON; */ - - dst = tempout + (i * widthout + j) * components; - - /* compute average of pixels in the rectangle (i0,j0)-(i1,j1) */ - for (k = 0; k < components; k++) { - sum = 0.0; - for (ii = i0; ii <= i1; ii++) { - for (jj = j0; jj <= j1; jj++) { - sum += *(tempin + (ii * widthin + jj) * components + k); - } - } - sum /= (j1 - j0 + 1) * (i1 - i0 + 1); - *dst++ = sum; - } - } - } - } + if (sx < 1.0 && sy < 1.0) { + /* magnify both width and height: use weighted sample of 4 pixels */ + GLint i0, i1, j0, j1; + GLfloat alpha, beta; + GLfloat *src00, *src01, *src10, *src11; + GLfloat s1, s2; + GLfloat *dst; + + for (i = 0; i < heightout; i++) { + i0 = i * sy; + i1 = i0 + 1; + if (i1 >= heightin) { + i1 = heightin - 1; + } + /* i1 = (i+1) * sy - EPSILON; */ + alpha = i * sy - i0; + for (j = 0; j < widthout; j++) { + j0 = j * sx; + j1 = j0 + 1; + if (j1 >= widthin) { + j1 = widthin - 1; + } + /* j1 = (j+1) * sx - EPSILON; */ + beta = j * sx - j0; + + /* compute weighted average of pixels + in rect (i0, j0) - (i1, j1) */ + src00 = tempin + (i0 * widthin + j0) * components; + src01 = tempin + (i0 * widthin + j1) * components; + src10 = tempin + (i1 * widthin + j0) * components; + src11 = tempin + (i1 * widthin + j1) * components; + + dst = tempout + (i * widthout + j) * components; + + for (k = 0; k < components; k++) { + s1 = *src00++ * (1.0 - beta) + *src01++ * beta; + s2 = *src10++ * (1.0 - beta) + *src11++ * beta; + *dst++ = s1 * (1.0 - alpha) + s2 * alpha; + } + } + } + } else { + /* shrink width and/or height: use an unweighted box filter */ + GLint i0, i1; + GLint j0, j1; + GLint ii, jj; + GLfloat sum, *dst; + + for (i = 0; i < heightout; i++) { + i0 = i * sy; + i1 = i0 + 1; + if (i1 >= heightin) { + i1 = heightin - 1; + } + /* i1 = (i+1) * sy - EPSILON; */ + for (j = 0; j < widthout; j++) { + j0 = j * sx; + j1 = j0 + 1; + if (j1 >= widthin) { + j1 = widthin - 1; + } + /* j1 = (j+1) * sx - EPSILON; */ + + dst = tempout + (i * widthout + j) * components; + + /* compute average of pixels + in the rectangle (i0, j0) - (i1, j1) */ + for (k = 0; k < components; k++) { + sum = 0.0; + for (ii = i0; ii <= i1; ii++) { + for (jj = j0; jj <= j1; jj++) { + sum += *(tempin + (ii * widthin + jj) * + components + k); + } + } + sum /= (j1 - j0 + 1) * (i1 - i0 + 1); + *dst++ = sum; + } + } + } + } #endif - /* - * Return output image - */ - - if (packrowlength > 0) { - rowlen = packrowlength; - } - else { - rowlen = widthout; - } - if (sizeout >= packalignment) { - rowstride = components * rowlen; - } - else { - rowstride = packalignment / sizeout - * CEILING(components * rowlen * sizeout, packalignment); - } - - switch (typeout) { - case GL_UNSIGNED_BYTE: - k = 0; - for (i = 0; i < heightout; i++) { - GLubyte *ubptr = (GLubyte *) dataout - + i * rowstride - + packskiprows * rowstride + packskippixels * components; - for (j = 0; j < widthout * components; j++) { - dummy(j, k + i); - *ubptr++ = (GLubyte) tempout[k++]; - } - } - break; - case GL_BYTE: - k = 0; - for (i = 0; i < heightout; i++) { - GLbyte *bptr = (GLbyte *) dataout - + i * rowstride - + packskiprows * rowstride + packskippixels * components; - for (j = 0; j < widthout * components; j++) { - dummy(j, k + i); - *bptr++ = (GLbyte) tempout[k++]; - } - } - break; - case GL_UNSIGNED_SHORT: - k = 0; - for (i = 0; i < heightout; i++) { - GLushort *usptr = (GLushort *) dataout - + i * rowstride - + packskiprows * rowstride + packskippixels * components; - for (j = 0; j < widthout * components; j++) { - dummy(j, k + i); - *usptr++ = (GLushort) tempout[k++]; - } - } - break; - case GL_SHORT: - k = 0; - for (i = 0; i < heightout; i++) { - GLshort *sptr = (GLshort *) dataout - + i * rowstride - + packskiprows * rowstride + packskippixels * components; - for (j = 0; j < widthout * components; j++) { - dummy(j, k + i); - *sptr++ = (GLshort) tempout[k++]; - } - } - break; - case GL_UNSIGNED_INT: - k = 0; - for (i = 0; i < heightout; i++) { - GLuint *uiptr = (GLuint *) dataout - + i * rowstride - + packskiprows * rowstride + packskippixels * components; - for (j = 0; j < widthout * components; j++) { - dummy(j, k + i); - *uiptr++ = (GLuint) tempout[k++]; - } - } - break; - case GL_INT: - k = 0; - for (i = 0; i < heightout; i++) { - GLint *iptr = (GLint *) dataout - + i * rowstride - + packskiprows * rowstride + packskippixels * components; - for (j = 0; j < widthout * components; j++) { - dummy(j, k + i); - *iptr++ = (GLint) tempout[k++]; - } - } - break; - case GL_FLOAT: - k = 0; - for (i = 0; i < heightout; i++) { - GLfloat *fptr = (GLfloat *) dataout - + i * rowstride - + packskiprows * rowstride + packskippixels * components; - for (j = 0; j < widthout * components; j++) { - dummy(j, k + i); - *fptr++ = tempout[k++]; - } - } - break; - default: - return GLU_INVALID_ENUM; - } - - - /* free temporary image storage */ - free(tempin); - free(tempout); - - return 0; + /* + * Return output image + */ + + if (packrowlength > 0) { + rowlen = packrowlength; + } else { + rowlen = widthout; + } + if (sizeout >= packalignment) { + rowstride = components * rowlen; + } else { + rowstride = packalignment / sizeout * CEILING(components * rowlen * + sizeout, packalignment); + } + + switch (typeout) { + case GL_UNSIGNED_BYTE: + k = 0; + for (i = 0; i < heightout; i++) { + GLubyte *ubptr = (GLubyte *)dataout + i * rowstride + + packskiprows * rowstride + + packskippixels * components; + for (j = 0; j < widthout * components; j++) { + dummy(j, k + i); + *ubptr++ = (GLubyte)tempout[k++]; + } + } + break; + case GL_BYTE: + k = 0; + for (i = 0; i < heightout; i++) { + GLbyte *bptr = (GLbyte *)dataout + i * rowstride + + packskiprows * rowstride + + packskippixels * components; + for (j = 0; j < widthout * components; j++) { + dummy(j, k + i); + *bptr++ = (GLbyte)tempout[k++]; + } + } + break; + case GL_UNSIGNED_SHORT: + k = 0; + for (i = 0; i < heightout; i++) { + GLushort *usptr = (GLushort *)dataout + i * rowstride + + packskiprows * rowstride + + packskippixels * components; + for (j = 0; j < widthout * components; j++) { + dummy(j, k + i); + *usptr++ = (GLushort)tempout[k++]; + } + } + break; + case GL_SHORT: + k = 0; + for (i = 0; i < heightout; i++) { + GLshort *sptr = (GLshort *)dataout + i * rowstride + + packskiprows * rowstride + + packskippixels * components; + for (j = 0; j < widthout * components; j++) { + dummy(j, k + i); + *sptr++ = (GLshort)tempout[k++]; + } + } + break; + case GL_UNSIGNED_INT: + k = 0; + for (i = 0; i < heightout; i++) { + GLuint *uiptr = (GLuint *)dataout + i * rowstride + + packskiprows * rowstride + + packskippixels * components; + for (j = 0; j < widthout * components; j++) { + dummy(j, k + i); + *uiptr++ = (GLuint)tempout[k++]; + } + } + break; + case GL_INT: + k = 0; + for (i = 0; i < heightout; i++) { + GLint *iptr = (GLint *)dataout + i * rowstride + + packskiprows * rowstride + + packskippixels * components; + for (j = 0; j < widthout * components; j++) { + dummy(j, k + i); + *iptr++ = (GLint)tempout[k++]; + } + } + break; + case GL_FLOAT: + k = 0; + for (i = 0; i < heightout; i++) { + GLfloat *fptr = (GLfloat *)dataout + i * rowstride + + packskiprows * rowstride + packskippixels + * components; + for (j = 0; j < widthout * components; j++) { + dummy(j, k + i); + *fptr++ = tempout[k++]; + } + } + break; + default: + return GLU_INVALID_ENUM; + } + + + /* free temporary image storage */ + free(tempin); + free(tempout); + + return 0; } @@ -520,15 +520,17 @@ mesa_gluScaleImage(GLenum format, /* * Return the largest k such that 2^k <= n. */ -static GLint -ilog2(GLint n) +static GLint ilog2(GLint n) { - GLint k; - - if (n <= 0) - return 0; - for (k = 0; n >>= 1; k++); - return k; + GLint k; + + if (n <= 0) { + return 0; + } + for (k = 0; n >>= 1; k++) { + ; + } + return k; } @@ -536,20 +538,20 @@ ilog2(GLint n) /* * Find the value nearest to n which is also a power of two. */ -static GLint -round2(GLint n) +static GLint round2(GLint n) { - GLint m; - - for (m = 1; m < n; m *= 2); - - /* m>=n */ - if (m - n <= n - m / 2) { - return m; - } - else { - return m / 2; - } + GLint m; + + for (m = 1; m < n; m *= 2) { + ; + } + + /* m>=n */ + if (m - n <= n - m / 2) { + return m; + } else { + return m / 2; + } } @@ -557,70 +559,69 @@ round2(GLint n) * Given an pixel format and datatype, return the number of bytes to * store one pixel. */ -static GLint -bytes_per_pixel(GLenum format, GLenum type) +static GLint bytes_per_pixel(GLenum format, GLenum type) { - GLint n, m; - - switch (format) { - case GL_COLOR_INDEX: - case GL_STENCIL_INDEX: - case GL_DEPTH_COMPONENT: - case GL_RED: - case GL_GREEN: - case GL_BLUE: - case GL_ALPHA: - case GL_LUMINANCE: - n = 1; - break; - case GL_LUMINANCE_ALPHA: - n = 2; - break; - case GL_RGB: - case GL_BGR: - n = 3; - break; - case GL_RGBA: - case GL_BGRA: + GLint n, m; + + switch (format) { + case GL_COLOR_INDEX: + case GL_STENCIL_INDEX: + case GL_DEPTH_COMPONENT: + case GL_RED: + case GL_GREEN: + case GL_BLUE: + case GL_ALPHA: + case GL_LUMINANCE: + n = 1; + break; + case GL_LUMINANCE_ALPHA: + n = 2; + break; + case GL_RGB: + case GL_BGR: + n = 3; + break; + case GL_RGBA: + case GL_BGRA: #ifdef GL_EXT_abgr - case GL_ABGR_EXT: + case GL_ABGR_EXT: #endif - n = 4; - break; - default: - n = 0; - } - - switch (type) { - case GL_UNSIGNED_BYTE: - m = sizeof(GLubyte); - break; - case GL_BYTE: - m = sizeof(GLbyte); - break; - case GL_BITMAP: - m = 1; - break; - case GL_UNSIGNED_SHORT: - m = sizeof(GLushort); - break; - case GL_SHORT: - m = sizeof(GLshort); - break; - case GL_UNSIGNED_INT: - m = sizeof(GLuint); - break; - case GL_INT: - m = sizeof(GLint); - break; - case GL_FLOAT: - m = sizeof(GLfloat); - break; - default: - m = 0; - } - - return n * m; + n = 4; + break; + default: + n = 0; + } + + switch (type) { + case GL_UNSIGNED_BYTE: + m = sizeof(GLubyte); + break; + case GL_BYTE: + m = sizeof(GLbyte); + break; + case GL_BITMAP: + m = 1; + break; + case GL_UNSIGNED_SHORT: + m = sizeof(GLushort); + break; + case GL_SHORT: + m = sizeof(GLshort); + break; + case GL_UNSIGNED_INT: + m = sizeof(GLuint); + break; + case GL_INT: + m = sizeof(GLint); + break; + case GL_FLOAT: + m = sizeof(GLfloat); + break; + default: + m = 0; + } + + return n * m; } @@ -628,199 +629,204 @@ bytes_per_pixel(GLenum format, GLenum type) /* * WARNING: This function isn't finished and has never been tested!!!! */ -GLint GLAPIENTRY -mesa_gluBuild1DMipmaps(GLenum target, GLint components, - GLsizei width, GLenum format, GLenum type, const void *data) +GLint GLAPIENTRY mesa_gluBuild1DMipmaps(GLenum target, GLint components, + GLsizei width, GLenum format, + GLenum type, const void *data) { - GLubyte *texture; - GLint levels, max_levels; - GLint new_width, max_width; - GLint i, j, k, l; - - if (width < 1) - return GLU_INVALID_VALUE; - - glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_width); - max_levels = ilog2(max_width) + 1; - - /* Compute how many mipmap images to make */ - levels = ilog2(width) + 1; - if (levels > max_levels) { - levels = max_levels; - } - - new_width = 1 << (levels - 1); - - texture = (GLubyte *) malloc(new_width * components); - if (!texture) { - return GLU_OUT_OF_MEMORY; - } - - if (width != new_width) { - /* initial rescaling */ - switch (type) { - case GL_UNSIGNED_BYTE: - { - GLubyte *ub_data = (GLubyte *) data; - for (i = 0; i < new_width; i++) { - j = i * width / new_width; - for (k = 0; k < components; k++) { - texture[i * components + k] = ub_data[j * components + k]; - } - } - } - break; - default: - /* Not implemented */ - return GLU_ERROR; - } - } - - /* generate and load mipmap images */ - for (l = 0; l < levels; l++) { - glTexImage1D(GL_TEXTURE_1D, l, components, new_width, 0, - format, GL_UNSIGNED_BYTE, texture); - - /* Scale image down to 1/2 size */ - new_width = new_width / 2; - for (i = 0; i < new_width; i++) { - for (k = 0; k < components; k++) { - GLint sample1, sample2; - sample1 = (GLint) texture[i * 2 * components + k]; - sample2 = (GLint) texture[(i * 2 + 1) * components + k]; - texture[i * components + k] = (GLubyte) ((sample1 + sample2) / 2); - } - } - } - - free(texture); - - return 0; + GLubyte *texture; + GLint levels, max_levels; + GLint new_width, max_width; + GLint i, j, k, l; + + if (width < 1) { + return GLU_INVALID_VALUE; + } + + glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_width); + max_levels = ilog2(max_width) + 1; + + /* Compute how many mipmap images to make */ + levels = ilog2(width) + 1; + if (levels > max_levels) { + levels = max_levels; + } + + new_width = 1 << (levels - 1); + + texture = (GLubyte *)malloc(new_width * components); + if (!texture) { + return GLU_OUT_OF_MEMORY; + } + + if (width != new_width) { + /* initial rescaling */ + switch (type) { + case GL_UNSIGNED_BYTE: + { + GLubyte *ub_data = (GLubyte *)data; + for (i = 0; i < new_width; i++) { + j = i * width / new_width; + for (k = 0; k < components; k++) { + texture[i * components + k] = + ub_data[j * components + k]; + } + } + } + break; + default: + /* Not implemented */ + free(texture); + return GLU_ERROR; + } + } + + /* generate and load mipmap images */ + for (l = 0; l < levels; l++) { + glTexImage1D(GL_TEXTURE_1D, l, components, new_width, 0, + format, GL_UNSIGNED_BYTE, texture); + + /* Scale image down to 1/2 size */ + new_width = new_width / 2; + for (i = 0; i < new_width; i++) { + for (k = 0; k < components; k++) { + GLint sample1, sample2; + sample1 = (GLint)texture[i * 2 * components + k]; + sample2 = (GLint)texture[(i * 2 + 1) * components + k]; + texture[i * components + k] = + (GLubyte)((sample1 + sample2) / 2); + } + } + } + + free(texture); + + return 0; } -GLint GLAPIENTRY -mesa_gluBuild2DMipmaps(GLenum target, GLint components, - GLsizei width, GLsizei height, GLenum format, - GLenum type, const void *data) +GLint GLAPIENTRY mesa_gluBuild2DMipmaps(GLenum target, GLint components, + GLsizei width, GLsizei height, + GLenum format, GLenum type, + const void *data) { - GLint w, h, maxsize; - void *image, *newimage; - GLint neww, newh, level, bpp; - int error; - GLboolean done; - GLint retval = 0; - GLint unpackrowlength, unpackalignment, unpackskiprows, unpackskippixels; - GLint packrowlength, packalignment, packskiprows, packskippixels; - - if (width < 1 || height < 1) - return GLU_INVALID_VALUE; - - glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxsize); - - w = round2(width); - if (w > maxsize) { - w = maxsize; - } - h = round2(height); - if (h > maxsize) { - h = maxsize; - } - - bpp = bytes_per_pixel(format, type); - if (bpp == 0) { - /* probably a bad format or type enum */ - return GLU_INVALID_ENUM; - } - - /* Get current glPixelStore values */ - glGetIntegerv(GL_UNPACK_ROW_LENGTH, &unpackrowlength); - glGetIntegerv(GL_UNPACK_ALIGNMENT, &unpackalignment); - glGetIntegerv(GL_UNPACK_SKIP_ROWS, &unpackskiprows); - glGetIntegerv(GL_UNPACK_SKIP_PIXELS, &unpackskippixels); - glGetIntegerv(GL_PACK_ROW_LENGTH, &packrowlength); - glGetIntegerv(GL_PACK_ALIGNMENT, &packalignment); - glGetIntegerv(GL_PACK_SKIP_ROWS, &packskiprows); - glGetIntegerv(GL_PACK_SKIP_PIXELS, &packskippixels); - - /* set pixel packing */ - glPixelStorei(GL_PACK_ROW_LENGTH, 0); - glPixelStorei(GL_PACK_ALIGNMENT, 1); - glPixelStorei(GL_PACK_SKIP_ROWS, 0); - glPixelStorei(GL_PACK_SKIP_PIXELS, 0); - - done = GL_FALSE; - - if (w != width || h != height) { - /* must rescale image to get "top" mipmap texture image */ - image = malloc((w + 4) * h * bpp); - if (!image) { - return GLU_OUT_OF_MEMORY; - } - error = mesa_gluScaleImage(format, width, height, type, data, - w, h, type, image); - if (error) { - retval = error; - done = GL_TRUE; - } - } - else { - image = (void *) data; - } - - level = 0; - while (!done) { - if (image != data) { - /* set pixel unpacking */ - glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); - glPixelStorei(GL_UNPACK_ALIGNMENT, 1); - glPixelStorei(GL_UNPACK_SKIP_ROWS, 0); - glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0); - } - - glTexImage2D(target, level, components, w, h, 0, format, type, image); - - if (w == 1 && h == 1) - break; - - neww = (w < 2) ? 1 : w / 2; - newh = (h < 2) ? 1 : h / 2; - newimage = malloc((neww + 4) * newh * bpp); - if (!newimage) { - return GLU_OUT_OF_MEMORY; - } - - error = mesa_gluScaleImage(format, w, h, type, image, - neww, newh, type, newimage); - if (error) { - retval = error; - done = GL_TRUE; - } - - if (image != data) { - free(image); - } - image = newimage; - - w = neww; - h = newh; - level++; - } - - if (image != data) { - free(image); - } - - /* Restore original glPixelStore state */ - glPixelStorei(GL_UNPACK_ROW_LENGTH, unpackrowlength); - glPixelStorei(GL_UNPACK_ALIGNMENT, unpackalignment); - glPixelStorei(GL_UNPACK_SKIP_ROWS, unpackskiprows); - glPixelStorei(GL_UNPACK_SKIP_PIXELS, unpackskippixels); - glPixelStorei(GL_PACK_ROW_LENGTH, packrowlength); - glPixelStorei(GL_PACK_ALIGNMENT, packalignment); - glPixelStorei(GL_PACK_SKIP_ROWS, packskiprows); - glPixelStorei(GL_PACK_SKIP_PIXELS, packskippixels); - - return retval; + GLint w, h, maxsize; + void *image, *newimage; + GLint neww, newh, level, bpp; + int error; + GLboolean done; + GLint retval = 0; + GLint unpackrowlength, unpackalignment, unpackskiprows, unpackskippixels; + GLint packrowlength, packalignment, packskiprows, packskippixels; + + if (width < 1 || height < 1) { + return GLU_INVALID_VALUE; + } + + glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxsize); + + w = round2(width); + if (w > maxsize) { + w = maxsize; + } + h = round2(height); + if (h > maxsize) { + h = maxsize; + } + + bpp = bytes_per_pixel(format, type); + if (bpp == 0) { + /* probably a bad format or type enum */ + return GLU_INVALID_ENUM; + } + + /* Get current glPixelStore values */ + glGetIntegerv(GL_UNPACK_ROW_LENGTH, &unpackrowlength); + glGetIntegerv(GL_UNPACK_ALIGNMENT, &unpackalignment); + glGetIntegerv(GL_UNPACK_SKIP_ROWS, &unpackskiprows); + glGetIntegerv(GL_UNPACK_SKIP_PIXELS, &unpackskippixels); + glGetIntegerv(GL_PACK_ROW_LENGTH, &packrowlength); + glGetIntegerv(GL_PACK_ALIGNMENT, &packalignment); + glGetIntegerv(GL_PACK_SKIP_ROWS, &packskiprows); + glGetIntegerv(GL_PACK_SKIP_PIXELS, &packskippixels); + + /* set pixel packing */ + glPixelStorei(GL_PACK_ROW_LENGTH, 0); + glPixelStorei(GL_PACK_ALIGNMENT, 1); + glPixelStorei(GL_PACK_SKIP_ROWS, 0); + glPixelStorei(GL_PACK_SKIP_PIXELS, 0); + + done = GL_FALSE; + + if (w != width || h != height) { + /* must rescale image to get "top" mipmap texture image */ + image = malloc((w + 4) * h * bpp); + if (!image) { + return GLU_OUT_OF_MEMORY; + } + error = mesa_gluScaleImage(format, width, height, type, data, + w, h, type, image); + if (error) { + retval = error; + done = GL_TRUE; + } + } else { + image = (void *) data; + } + + level = 0; + while (!done) { + if (image != data) { + /* set pixel unpacking */ + glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + glPixelStorei(GL_UNPACK_SKIP_ROWS, 0); + glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0); + } + + glTexImage2D(target, level, components, w, h, 0, format, type, image); + + if (w == 1 && h == 1) { + break; + } + + neww = (w < 2) ? 1 : w / 2; + newh = (h < 2) ? 1 : h / 2; + newimage = malloc((neww + 4) * newh * bpp); + if (!newimage) { + return GLU_OUT_OF_MEMORY; + } + + error = mesa_gluScaleImage(format, w, h, type, image, + neww, newh, type, newimage); + if (error) { + retval = error; + done = GL_TRUE; + } + + if (image != data) { + free(image); + } + image = newimage; + + w = neww; + h = newh; + level++; + } + + if (image != data) { + free(image); + } + + /* Restore original glPixelStore state */ + glPixelStorei(GL_UNPACK_ROW_LENGTH, unpackrowlength); + glPixelStorei(GL_UNPACK_ALIGNMENT, unpackalignment); + glPixelStorei(GL_UNPACK_SKIP_ROWS, unpackskiprows); + glPixelStorei(GL_UNPACK_SKIP_PIXELS, unpackskippixels); + glPixelStorei(GL_PACK_ROW_LENGTH, packrowlength); + glPixelStorei(GL_PACK_ALIGNMENT, packalignment); + glPixelStorei(GL_PACK_SKIP_ROWS, packskiprows); + glPixelStorei(GL_PACK_SKIP_PIXELS, packskippixels); + + return retval; } diff --git a/tizen/src/hw/opengl_exec.c b/tizen/src/hw/opengl_exec.c index 1a29f28940..9485593dec 100644 --- a/tizen/src/hw/opengl_exec.c +++ b/tizen/src/hw/opengl_exec.c @@ -30,11 +30,11 @@ #include #include #include -#include // for pid_t +#include /* for pid_t */ #include "qemu-common.h" -/* GW: dyngen-exec.h defines its own version of stuff that is in stdio.h - +/* GW: dyngen-exec.h defines its own version of stuff that is in stdio.h - only it misses things and is mildly different to stdio \o/. Hence don't include stdio and make our own defines. */ @@ -51,13 +51,12 @@ */ #include "tizen/src/debug_ch.h" MULTI_DEBUG_CHANNEL(qemu, opengl); -#define DEBUGF TRACE +#define DEBUGF TRACE #define GL_GLEXT_PROTOTYPES #define GLX_GLXEXT_PROTOTYPES #include -//#include "qemu-queue.h" #include "opengl_func.h" #include "mesa_mipmap.h" #include "opengl_process.h" @@ -69,13 +68,12 @@ MULTI_DEBUG_CHANNEL(qemu, opengl); * as we need them on Windows too */ typedef int Bool; const Bool True = 1; -const Bool False = 0; +const Bool False; typedef struct __GLXFBConfigRec GLXFBConfig; struct __GLXFBConfigRec { - int formatFlags; + int formatFlags; }; -// #defines from glx.h #define GLX_VENDOR 1 #define GLX_VERSION 2 #define GLX_EXTENSIONS 3 @@ -100,13 +98,13 @@ const GLXFBConfig FBCONFIGS[] = { {GLO_FF_BITS_16|GLO_FF_DEPTH_24|GLO_FF_STENCIL_8},*/ }; -#define FAKE_GL_VENDOR "Qemu" +#define FAKE_GL_VENDOR "QEMU" #define FAKE_GL_RENDERER "VMGL Passthrough" #define FAKE_GL_VERSION "1.4" #define FAKE_GL_MAJOR 1 -#define FAKE_GLX_VENDOR "Qemu" +#define FAKE_GLX_VENDOR "QEMU" #define FAKE_GLX_VERSION_STRING "1.2" #define FAKE_GLX_VERSION_MAJOR 1 #define FAKE_GLX_VERSION_MINOR 2 @@ -114,28 +112,30 @@ const GLXFBConfig FBCONFIGS[] = { /*#define glGetError() 0*/ #ifdef WIN32 -# define CCONV _stdcall /* DLL entry points are WINAPI */ +# define CCONV _stdcall /* DLL entry points are WINAPI */ #else -# define CCONV +# define CCONV #endif #define GET_EXT_PTR(type, funcname, args_decl) \ - static int detect_##funcname = 0; \ - static type CCONV (*ptr_func_##funcname)args_decl = NULL; \ - if (detect_##funcname == 0) \ - { \ + static int detect_##funcname; \ + static type CCONV (*ptr_func_##funcname)args_decl; \ + if (detect_##funcname == 0) { \ detect_##funcname = 1; \ - ptr_func_##funcname = (type CCONV (*)args_decl)glo_getprocaddress((const char*)#funcname); \ - assert (ptr_func_##funcname); \ + ptr_func_##funcname = \ + (type CCONV (*)args_decl)glo_getprocaddress( \ + (const char *)#funcname); \ + assert(ptr_func_##funcname); \ } #define GET_EXT_PTR_NO_FAIL(type, funcname, args_decl) \ - static int detect_##funcname = 0; \ - static type CCONV (*ptr_func_##funcname)args_decl = NULL; \ - if (detect_##funcname == 0) \ - { \ + static int detect_##funcname; \ + static type CCONV (*ptr_func_##funcname)args_decl; \ + if (detect_##funcname == 0) { \ detect_##funcname = 1; \ - ptr_func_##funcname = (type CCONV (*)args_decl)glo_getprocaddress((const char*)#funcname); \ + ptr_func_##funcname = \ + (type CCONV (*)args_decl)glo_getprocaddress( \ + (const char *)#funcname); \ } #ifndef WIN32 @@ -149,12 +149,14 @@ static void *get_glu_ptr(const char *name) if (handle == (void *) -1) { #ifndef WIN32 handle = dlopen("libGLU.so", RTLD_LAZY); - if (!handle) + if (!handle) { DEBUGF("can't load libGLU.so : %s\n", dlerror()); + } #else - handle = (void *) LoadLibrary("glu32.dll"); - if (!handle) + handle = (void *)LoadLibrary("glu32.dll"); + if (!handle) { DEBUGF("can't load glu32.dll\n"); + } #endif } if (handle) { @@ -168,15 +170,15 @@ static void *get_glu_ptr(const char *name) } #define GET_GLU_PTR(type, funcname, args_decl) \ - static int detect_##funcname = 0; \ - static type CCONV (*ptr_func_##funcname)args_decl = NULL; \ - if (detect_##funcname == 0) \ - { \ + static int detect_##funcname; \ + static type CCONV (*ptr_func_##funcname)args_decl; \ + if (detect_##funcname == 0) { \ detect_##funcname = 1; \ - ptr_func_##funcname = (type CCONV (*)args_decl)get_glu_ptr(#funcname); \ + ptr_func_##funcname = \ + (type CCONV (*)args_decl)get_glu_ptr(#funcname); \ } -int display_function_call = 0; +int display_function_call; extern int kill_process; typedef struct { @@ -212,8 +214,8 @@ enum { }; enum { - SURFACE_PENDING, /* Created with light-weight context */ - SURFACE_ACTIVE, /* Ready after MakeCurrent */ + SURFACE_PENDING, /* Created with light-weight context */ + SURFACE_ACTIVE, /* Ready after MakeCurrent */ }; typedef struct QGloSurface { @@ -222,7 +224,7 @@ typedef struct QGloSurface { ClientGLXDrawable client_drawable; int type; /* window, pixmap or pbuffer */ int ready; - int status; + int status; int ref; QTAILQ_ENTRY(QGloSurface) next; } QGloSurface; @@ -239,10 +241,10 @@ struct GLState { int fake_ctxt; int fake_shareList; - GloContext *context; // context (owned by this) - QGloSurface *current_qsurface; // current rendering surface/drawable - QTAILQ_HEAD(, QGloSurface) qsurfaces; // list of surfaces/drawables for - // this context + GloContext *context; /* context (owned by this) */ + QGloSurface *current_qsurface; /* current rendering surface/drawable */ + QTAILQ_HEAD(, QGloSurface) qsurfaces; /* list of surfaces/drawables for */ + /* this context */ void *vertexPointer; void *normalPointer; @@ -323,15 +325,15 @@ typedef struct { int nb_qsurf; /* Number of FB configs sets allocated on behalf of this process */ - int nfbconfig; - - /* Array of FB configs sets */ + int nfbconfig; + + /* Array of FB configs sets */ const GLXFBConfig *fbconfigs[MAX_FBCONFIG]; - - /* Number of FB configs per set */ + + /* Number of FB configs per set */ int fbconfigs_max[MAX_FBCONFIG]; - - /* Total number of FB configs allocated on behalf of this process */ + + /* Total number of FB configs allocated on behalf of this process */ int nfbconfig_total; int primitive; @@ -349,14 +351,14 @@ static char *strip_extensions(const char *avail, const char *ext[]) supported = (char *)g_malloc(strlen(avail) + 2); pos = supported; - while(*ext) { - srcp = (char*)avail; - while((srcp = strstr(srcp, *ext))) { + while (*ext) { + srcp = (char *)avail; + while ((srcp = strstr(srcp, *ext))) { int len = strlen(*ext); - if(*(srcp+len) == ' ' || *(srcp+len) == '\0') { + if (*(srcp + len) == ' ' || *(srcp + len) == '\0') { strcpy(pos, *ext); pos += len; - if(*(srcp+len) == ' ') { + if (*(srcp + len) == ' ') { *pos = ' '; pos++; } @@ -372,10 +374,14 @@ static char *strip_extensions(const char *avail, const char *ext[]) return supported; } -extern void vmgl_context_switch(ProcessStruct *p, int switch_gl_context); +extern void vmgl_context_switch(ProcessStruct *p, + int switch_gl_context); extern ProcessStruct *vmgl_get_process(pid_t pid); extern void gl_disconnect(ProcessState *process); -extern int do_function_call(ProcessState *process, int func_number, unsigned long *args, char *ret_string); +extern int do_function_call(ProcessState *process, + int func_number, + unsigned long *args, + char *ret_string); static const char *glx_ext_supported[] = { "GLX_ARB_multisample", @@ -386,15 +392,16 @@ static char *supported_glx_extensions(void) { static char *supported; - if(!supported) - supported = strip_extensions(glo_glXQueryExtensionsString(), + if (!supported) { + supported = strip_extensions(glo_glXQueryExtensionsString(), glx_ext_supported); + } return supported; } static const char *gl_ext_supported[] = { -// Mandatory OpenGL 1.4 Extensions +/* Mandatory OpenGL 1.4 Extensions */ "GL_ARB_depth_texture", "GL_ARB_multisample", "GL_ARB_multitexture", @@ -442,7 +449,7 @@ static const char *gl_ext_supported[] = { "GL_SGIS_texture_border_clamp", "GL_SGIS_texture_edge_clamp", "GL_SGIS_texture_lod", -// Optional extensions. If you get problems try disabling the below. +/* Optional extensions. If you get problems try disabling the below. */ "GL_EXT_compiled_vertex_array", "GL_ARB_copy_buffer", "GL_ARB_depth_clamp", @@ -453,7 +460,7 @@ static const char *gl_ext_supported[] = { "GL_ARB_fragment_shader", "GL_ARB_framebuffer_object", "GL_ARB_half_float_pixel", - "GL_ARB_map_buffer_range", + "GL_ARB_map_buffer_range", "GL_ARB_occlusion_query", "GL_ARB_pixel_buffer_object", "GL_ARB_point_sprite", @@ -462,10 +469,10 @@ static const char *gl_ext_supported[] = { "GL_ARB_shader_objects", "GL_ARB_shading_language_100", "GL_ARB_shading_language_120", - "GL_ARB_sync", + "GL_ARB_sync", "GL_ARB_texture_non_power_of_two", "GL_ARB_texture_rectangle", - "GL_ARB_vertex_array_bgra", + "GL_ARB_vertex_array_bgra", "GL_ARB_vertex_array_object", "GL_ARB_vertex_buffer_object", "GL_ARB_vertex_program", @@ -475,14 +482,14 @@ static const char *gl_ext_supported[] = { "GL_EXT_cull_vertex", "GL_EXT_framebuffer_blit", "GL_EXT_framebuffer_object", - "GL_EXT_gpu_program_parameters", - "GL_EXT_packed_depth_stencil", + "GL_EXT_gpu_program_parameters", + "GL_EXT_packed_depth_stencil", "GL_EXT_pixel_buffer_object", "GL_EXT_provoking_vertex", "GL_EXT_shadow_funcs", "GL_EXT_stencil_two_side", - "GL_EXT_texture_cube_map", - "GL_EXT_texture_env_dot3", + "GL_EXT_texture_cube_map", + "GL_EXT_texture_env_dot3", "GL_EXT_texture_filter_anisotropic", "GL_EXT_texture_rectangle", "GL_EXT_texture_sRGB", @@ -491,7 +498,7 @@ static const char *gl_ext_supported[] = { "GL_EXT_vertex_array_bgra", "GL_3DFX_texture_compression_FXT1", "GL_APPLE_client_storage", - "GL_APPLE_vertex_array_object", + "GL_APPLE_vertex_array_object", "GL_ATI_blend_equation_separate", "GL_ATI_envmap_bumpmap", "GL_ATI_texture_env_combine3", @@ -499,7 +506,7 @@ static const char *gl_ext_supported[] = { "GL_IBM_multimode_draw_arrays", "GL_IBM_rasterpos_clip", "GL_IBM_texture_mirrored_repeat", - "GL_INGR_blend_func_separate", + "GL_INGR_blend_func_separate", "GL_MESA_pack_invert", "GL_MESA_texture_signed_rgba", "GL_MESA_ycbcr_texture", @@ -521,33 +528,42 @@ static char *compute_gl_extensions(void) { static char *supported; - if(!supported) + if (!supported) { supported = strip_extensions((const char *)glGetString(GL_EXTENSIONS), gl_ext_supported); + } return supported; } -static inline QGloSurface *get_qsurface_from_client_drawable(GLState *state, ClientGLXDrawable client_drawable) { +static inline QGloSurface *get_qsurface_from_client_drawable(GLState *state, + ClientGLXDrawable client_drawable) +{ QGloSurface *qsurface; - if (state->current_qsurface && state->current_qsurface->client_drawable == client_drawable) + if (state->current_qsurface && + state->current_qsurface->client_drawable == client_drawable) { return state->current_qsurface; + } QTAILQ_FOREACH(qsurface, &state->qsurfaces, next) { - if (qsurface->client_drawable == client_drawable) + if (qsurface->client_drawable == client_drawable) { return qsurface; + } } return NULL; } -// This must always be called only on surfaces belonging to the current context -static inline void render_surface(QGloSurface *qsurface, int bpp, int stride, char *buffer) +/* This must always be called only on surfaces + belonging to the current context */ +static inline void render_surface(QGloSurface *qsurface, + int bpp, int stride, char *buffer) { int w, h; - if(!qsurface->ready) - return; + if (!qsurface->ready) { + return; + } glo_surface_get_size(qsurface->surface, &w, &h); @@ -557,56 +573,63 @@ static inline void render_surface(QGloSurface *qsurface, int bpp, int stride, ch static void qsurface_pixmap_ref(QGloSurface *qsurface) { if (!qsurface) { - DEBUGF( "%s %p\n", __FUNCTION__, qsurface); + DEBUGF("%s %p\n", __func__, qsurface); return; } if (qsurface->type != SURFACE_PIXMAP) { - DEBUGF( "%s %p is not a pixmap\n", __FUNCTION__, qsurface); + DEBUGF("%s %p is not a pixmap\n", __func__, qsurface); return; } qsurface->ref++; - DEBUGF("%s %p references increased to %d\n", __FUNCTION__, qsurface, qsurface->ref); + DEBUGF("%s %p references increased to %d\n", + __func__, qsurface, qsurface->ref); } static void qsurface_pixmap_unref(QGloSurface *qsurface) { if (!qsurface) { - DEBUGF( "%s %p\n", __FUNCTION__, qsurface); + DEBUGF("%s %p\n", __func__, qsurface); return; } if (qsurface->type != SURFACE_PIXMAP) { - DEBUGF( "%s %p is not a pixmap\n", __FUNCTION__, qsurface); + DEBUGF("%s %p is not a pixmap\n", __func__, qsurface); return; } qsurface->ref--; - DEBUGF("%s %p references decreased to %d\n", __FUNCTION__, qsurface, qsurface->ref); + DEBUGF("%s %p references decreased to %d\n", + __func__, qsurface, qsurface->ref); - if (qsurface->ref == 0) - { + if (qsurface->ref == 0) { glo_surface_destroy(qsurface->surface); g_free(qsurface); - DEBUGF( "%s freed: %p\n", __FUNCTION__, qsurface); + DEBUGF("%s freed: %p\n", __func__, qsurface); } } static void state_set_current_surface(GLState *state, QGloSurface *qsurface) { - if (state->current_qsurface != NULL) + if (state->current_qsurface != NULL) { qsurface_pixmap_unref(state->current_qsurface); + } - if (qsurface != NULL) + if (qsurface != NULL) { qsurface_pixmap_ref(qsurface); + } state->current_qsurface = qsurface; } -// This must always be called only on surfaces belonging to the current context -static inline void resize_surface(ProcessState *process, QGloSurface *qsurface, - int w, int h) { +/* This must always be called only on surfaces + belonging to the current context */ +static inline void resize_surface(ProcessState *process, + QGloSurface *qsurface, + int w, + int h) +{ GLState *glstate = qsurface->glstate; GloSurface *old_surface = qsurface->surface; GloSurface *surface; @@ -618,18 +641,17 @@ static inline void resize_surface(ProcessState *process, QGloSurface *qsurface, surface = glo_surface_create(w, h, glstate->context); qsurface->surface = surface; - // Client doesnt know surface is new - need to MakeCurrent - if(process->current_state == qsurface->glstate) { + /* Client doesnt know surface is new - need to MakeCurrent */ + if (process->current_state == qsurface->glstate) { glo_surface_makecurrent(qsurface->surface); - // set the viewport while the window size is changed. It is needed - // especially for the case that glViewport is not explicitly called - // in program. In this case, the viewport is set to incorrectly - // in the first MakeCurrent when the window size is not known. - // It will not impact normal GL programs with glViewport set as - // programmers want. - glViewport (0, 0, w, h); - } - else { + /* set the viewport while the window size is changed. It is needed + especially for the case that glViewport is not explicitly called + in program. In this case, the viewport is set to incorrectly + in the first MakeCurrent when the window size is not known. + It will not impact normal GL programs with glViewport set as + programmers want. */ + glViewport(0, 0, w, h); + } else { DEBUGF("Error: Surface is not current! %p %p\n", process->current_state, process->current_state->current_qsurface); @@ -637,7 +659,7 @@ static inline void resize_surface(ProcessState *process, QGloSurface *qsurface, } glstate->current_qsurface->ready = 1; - DEBUGF( "resize_done\n"); + DEBUGF("resize_done\n"); } @@ -652,8 +674,8 @@ static void init_process_tab(void) #define ARG_TO_UNSIGNED_SHORT(x) (unsigned short)(long)(x) #define ARG_TO_INT(x) (int)(long)(x) #define ARG_TO_UNSIGNED_INT(x) (unsigned int)(long)(x) -#define ARG_TO_FLOAT(x) (*(float*)&(x)) -#define ARG_TO_DOUBLE(x) (*(double*)(x)) +#define ARG_TO_FLOAT(x) (*(float *)&(x)) +#define ARG_TO_DOUBLE(x) (*(double *)(x)) #include "server_stub.c" @@ -661,7 +683,7 @@ static inline ClientGLXDrawable to_drawable(arg_t arg) { #ifdef TARGET_X86_64 if (arg > (unsigned long) -1) { - DEBUGF( "GLXDrawable too big for this implementation\n"); + DEBUGF("GLXDrawable too big for this implementation\n"); exit(-1); } #endif @@ -674,11 +696,13 @@ static inline ClientGLXDrawable to_drawable(arg_t arg) static void bind_qsurface(GLState *state, QGloSurface *qsurface) { - DEBUGF("%s qsurface %p qsurface->glstate %p new state %p\n", __FUNCTION__, qsurface, qsurface->glstate, state); + DEBUGF("%s qsurface %p qsurface->glstate %p new state %p\n", + __func__, qsurface, qsurface->glstate, state); qsurface->glstate = state; - if ( qsurface->type == SURFACE_WINDOW ) - QTAILQ_INSERT_HEAD(&state->qsurfaces, qsurface, next); + if (qsurface->type == SURFACE_WINDOW) { + QTAILQ_INSERT_HEAD(&state->qsurfaces, qsurface, next); + } state_set_current_surface(state, qsurface); } @@ -688,31 +712,36 @@ static void unbind_qsurface(GLState *state, QGloSurface *qsurface) { if (!state || !qsurface) { - DEBUGF("%s invalid parameter, state %p, qsurface %p\n", __FUNCTION__, state, qsurface); + DEBUGF("%s invalid parameter, state %p, qsurface %p\n", + __func__, state, qsurface); return; } - DEBUGF("%s qsurface %p qsurface->glstate %p old state %p\n", __FUNCTION__, qsurface, qsurface->glstate, state); + DEBUGF("%s qsurface %p qsurface->glstate %p old state %p\n", + __func__, qsurface, qsurface->glstate, state); qsurface->glstate = NULL; - if ( qsurface->type == SURFACE_WINDOW ) - QTAILQ_REMOVE(&state->qsurfaces, qsurface, next); + if (qsurface->type == SURFACE_WINDOW) { + QTAILQ_REMOVE(&state->qsurfaces, qsurface, next); + } - if ( state->current_qsurface == qsurface ) - state_set_current_surface(state, NULL); + if (state->current_qsurface == qsurface) { + state_set_current_surface(state, NULL); + } } /* Find the qsurface with required drawable in all pixmap/pbuffer surfaces */ -static QGloSurface* find_qsurface_from_client_drawable(ProcessState *process, ClientGLXDrawable client_drawable) +static QGloSurface *find_qsurface_from_client_drawable(ProcessState *process, + ClientGLXDrawable client_drawable) { int i; QGloSurface *qsurface; - for ( i = 0; i < process->nb_qsurf; i++ ) - { + for (i = 0; i < process->nb_qsurf; i++) { qsurface = process->pending_qsurfaces[i]; - if ( qsurface && qsurface->client_drawable == client_drawable ) + if (qsurface && qsurface->client_drawable == client_drawable) { return qsurface; + } } return NULL; @@ -724,11 +753,13 @@ static int set_current_qsurface(GLState *state, { QGloSurface *qsurface; - if(state->current_qsurface && state->current_qsurface->client_drawable == client_drawable) + if (state->current_qsurface + && state->current_qsurface->client_drawable == client_drawable) { return 1; + } QTAILQ_FOREACH(qsurface, &state->qsurfaces, next) { - if(qsurface->client_drawable == client_drawable) { + if (qsurface->client_drawable == client_drawable) { state_set_current_surface(state, qsurface); qsurface->glstate = state; return 1; @@ -744,10 +775,8 @@ static int set_current_qsurface(GLState *state, static int keep_drawable(ProcessState *process, ClientGLXDrawable drawable) { int i; - for ( i = 0; i < MAX_PENDING_DRAWABLE; i++) - { - if ( process->pending_drawables[i] == 0 ) - { + for (i = 0; i < MAX_PENDING_DRAWABLE; i++) { + if (process->pending_drawables[i] == 0) { process->pending_drawables[i] = drawable; return 1; } @@ -758,10 +787,8 @@ static int keep_drawable(ProcessState *process, ClientGLXDrawable drawable) static int link_drawable(ProcessState *process, ClientGLXDrawable drawable) { int i; - for ( i = 0; i < MAX_PENDING_DRAWABLE; i++ ) - { - if ( process->pending_drawables[i] == drawable ) - { + for (i = 0; i < MAX_PENDING_DRAWABLE; i++) { + if (process->pending_drawables[i] == drawable) { process->pending_drawables[i] = 0; return 1; } @@ -778,22 +805,22 @@ static void keep_qsurface(ProcessState *process, QGloSurface *qsurface) { process->pending_qsurfaces = g_realloc(process->pending_qsurfaces, - (process->nb_qsurf + 1) * sizeof(QGloSurface*)); + (process->nb_qsurf + 1) * sizeof(QGloSurface *)); process->pending_qsurfaces[process->nb_qsurf] = qsurface; process->nb_qsurf++; } -static int link_qsurface(ProcessState *process, GLState *glstate, ClientGLXDrawable client_drawable) +static int link_qsurface(ProcessState *process, + GLState *glstate, + ClientGLXDrawable client_drawable) { int i; QGloSurface *qsurface; - for ( i = 0; i < process->nb_qsurf; i++ ) - { + for (i = 0; i < process->nb_qsurf; i++) { qsurface = process->pending_qsurfaces[i]; - if ( qsurface && qsurface->client_drawable == client_drawable ) - { + if (qsurface && qsurface->client_drawable == client_drawable) { /* XXX:Current limitation is that each surface is binded to one * context, and not accessible from another context. It's hard for * glEGLImageTargetTexture2DOES implementation, in which we need @@ -804,23 +831,24 @@ static int link_qsurface(ProcessState *process, GLState *glstate, ClientGLXDrawa #if 0 memmove(&process->pending_qsurfaces[i], &process->pending_qsurfaces[i+1], - (process->nb_qsurf - i - 1) * sizeof(QGloSurface*)); + (process->nb_qsurf - i - 1) * sizeof(QGloSurface *)); #endif if (qsurface->type != SURFACE_PIXMAP) { - DEBUGF("%s Forcing non pixmap qsurface->ref to 1 (type %d, ref %d)\n", __FUNCTION__, qsurface->type, qsurface->ref); + DEBUGF("%s Forcing non pixmap qsurface->ref to 1" + " (type %d, ref %d)\n", + __func__, qsurface->type, qsurface->ref); qsurface->ref = 1; } - if(qsurface->status == SURFACE_PENDING) - { - glo_surface_update_context(qsurface->surface, glstate->context, 1); - qsurface->status = SURFACE_ACTIVE; - } - else - { - unbind_qsurface(qsurface->glstate, qsurface); - glo_surface_update_context(qsurface->surface, glstate->context, 0); - } + if (qsurface->status == SURFACE_PENDING) { + glo_surface_update_context(qsurface->surface, + glstate->context, 1); + qsurface->status = SURFACE_ACTIVE; + } else { + unbind_qsurface(qsurface->glstate, qsurface); + glo_surface_update_context(qsurface->surface, + glstate->context, 0); + } bind_qsurface(glstate, qsurface); return 1; @@ -838,11 +866,9 @@ static void del_pixmap_texture_mapping(GLState *state, unsigned int texture) { int i; - for ( i = 0; i < MAX_PIXMAP_TEXTURE; i++ ) - { - if ( state->pixmapTextures[i].used && - state->pixmapTextures[i].texture == texture ) - { + for (i = 0; i < MAX_PIXMAP_TEXTURE; i++) { + if (state->pixmapTextures[i].used && + state->pixmapTextures[i].texture == texture) { state->pixmapTextures[i].used = 0; state->pixmapTextures[i].texture = 0; state->pixmapTextures[i].drawable = 0; @@ -855,11 +881,9 @@ static void remove_pixmap_texture_mapping(GLState *state, ClientGLXDrawable drawable) { int i; - for ( i = 0; i < MAX_PIXMAP_TEXTURE; i++ ) - { - if ( state->pixmapTextures[i].used && - state->pixmapTextures[i].drawable == drawable ) - { + for (i = 0; i < MAX_PIXMAP_TEXTURE; i++) { + if (state->pixmapTextures[i].used && + state->pixmapTextures[i].drawable == drawable) { state->pixmapTextures[i].used = 0; state->pixmapTextures[i].texture = 0; state->pixmapTextures[i].drawable = 0; @@ -872,11 +896,9 @@ static int add_pixmap_texture_mapping(GLState *state, unsigned int texture, ClientGLXDrawable drawable) { int i; - for ( i = 0; i < MAX_PIXMAP_TEXTURE; i++ ) - { - if ( state->pixmapTextures[i].texture == texture || - !state->pixmapTextures[i].used ) - { + for (i = 0; i < MAX_PIXMAP_TEXTURE; i++) { + if (state->pixmapTextures[i].texture == texture || + !state->pixmapTextures[i].used) { state->pixmapTextures[i].used = 1; state->pixmapTextures[i].texture = texture; state->pixmapTextures[i].drawable = drawable; @@ -891,11 +913,11 @@ static ClientGLXDrawable find_pixmap_texture(GLState *state, unsigned int texture) { int i; - for ( i = 0; i < MAX_PIXMAP_TEXTURE; i++ ) - { - if ( state->pixmapTextures[i].used && - state->pixmapTextures[i].texture == texture ) + for (i = 0; i < MAX_PIXMAP_TEXTURE; i++) { + if (state->pixmapTextures[i].used && + state->pixmapTextures[i].texture == texture) { return state->pixmapTextures[i].drawable; + } } return 0; @@ -909,7 +931,7 @@ static int get_server_texture(ProcessState *process, if (client_texture < 32768) { server_texture = process->current_state->tabTextures[client_texture]; } else { - DEBUGF( "invalid texture name %d\n", client_texture); + DEBUGF("invalid texture name %d\n", client_texture); } return server_texture; } @@ -922,7 +944,7 @@ static int get_server_buffer(ProcessState *process, if (client_buffer < 32768) { server_buffer = process->current_state->tabBuffers[client_buffer]; } else { - DEBUGF( "invalid buffer name %d\n", client_buffer); + DEBUGF("invalid buffer name %d\n", client_buffer); } return server_buffer; } @@ -935,111 +957,133 @@ static int get_server_list(ProcessState *process, unsigned int client_list) if (client_list < 32768) { server_list = process->current_state->tabLists[client_list]; } else { - DEBUGF( "invalid list name %d\n", client_list); + DEBUGF("invalid list name %d\n", client_list); } return server_list; } -static const GLXFBConfig *get_fbconfig(ProcessState *process, int client_fbconfig) +static const GLXFBConfig *get_fbconfig(ProcessState *process, + int client_fbconfig) { int i; - - /* The client_fbconfig returned to upper layers is 1 + the index of the - * fb config in the set that contains it, + the number of fb configs - * store in previously allocated sets. */ + + /* The client_fbconfig returned to upper layers is 1 + the index of the + * fb config in the set that contains it, + the number of fb configs + * store in previously allocated sets. */ int nbtotal = 0; /* For each set */ - for (i = 0; i < process->nfbconfig; i++) { - /* If the fb config is stored within this set, return it */ + for (i = 0; i < process->nfbconfig; i++) { + /* If the fb config is stored within this set, return it */ if (client_fbconfig <= nbtotal + process->fbconfigs_max[i]) { return &process->fbconfigs[i][client_fbconfig - 1 - nbtotal]; } /* Otherwise proceed to next set */ - nbtotal += process->fbconfigs_max[i]; + nbtotal += process->fbconfigs_max[i]; } return 0; } static int glXChooseVisualFunc(const int *attrib_list) { - if (attrib_list == NULL) + if (attrib_list == NULL) { return 0; + } int formatFlags = glo_flags_get_from_glx(attrib_list, True); int i; int bestConfig = 0; int bestScore = -1; - for (i=0;i 0) - DEBUGF( "Got format flags %d but we couldn't find an exactly matching config, chose %d\n", formatFlags, bestConfig); + if (bestScore > 0) { + DEBUGF("Got format flags %d but we couldn't find " + "an exactly matching config, chose %d\n", + formatFlags, bestConfig); + } return bestConfig; } -static int glXGetConfigFunc(int visualid, int attrib, int *value) { - const GLXFBConfig *config = &FBCONFIGS[0]; // default +static int glXGetConfigFunc(int visualid, int attrib, int *value) +{ + const GLXFBConfig *config = &FBCONFIGS[0]; /* default */ int v; - if (visualid>=0 && visualid= 0 && visualid < DIM(FBCONFIGS)) { config = &FBCONFIGS[visualid]; - else - DEBUGF( "Unknown visual ID %d\n", visualid); + } else { + DEBUGF("Unknown visual ID %d\n", visualid); + } v = glo_get_glx_from_flags(config->formatFlags, attrib); - if (value) - *value = v; + if (value) { + *value = v; + } return 0; } -static const GLXFBConfig * glXGetFBConfigsFunc(int screen, int *nelements) { +static const GLXFBConfig *glXGetFBConfigsFunc(int screen, int *nelements) +{ *nelements = DIM(FBCONFIGS); return &FBCONFIGS[0]; } -static int glXGetFBConfigAttribFunc(const GLXFBConfig *fbconfig, int attrib, int *value) { - // TODO other enums - see http://www.opengl.org/sdk/docs/man/xhtml/glXGetFBConfigAttrib.xml +static int glXGetFBConfigAttribFunc(const GLXFBConfig *fbconfig, + int attrib, int *value) +{ + /* TODO other enums - + * see http://www.opengl.org/sdk/docs/man/xhtml/glXGetFBConfigAttrib.xml + */ int v = glo_get_glx_from_flags(fbconfig->formatFlags, attrib); - if (value) *value = v; + if (value) { + *value = v; + } return 0; } -static const GLXFBConfig *glXChooseFBConfigFunc(int screen, const int *attrib_list, int *nelements) { +static const GLXFBConfig *glXChooseFBConfigFunc(int screen, + const int *attrib_list, + int *nelements) +{ if (attrib_list != NULL) { int formatFlags = glo_flags_get_from_glx(attrib_list, False); int i; int bestConfig = 0; int bestScore = -1; - for (i=0;i 0) { - DEBUGF( "Got format flags %d but we couldn't find an exactly matching config, chose %d\n", formatFlags, bestConfig); + DEBUGF("Got format flags %d but we couldn't find " + "an exactly matching config, chose %d\n", + formatFlags, bestConfig); } - if (nelements) - *nelements=1; + if (nelements) { + *nelements = 1; + } return &FBCONFIGS[bestConfig]; } - if (nelements) - *nelements=0; + if (nelements) { + *nelements = 0; + } return 0; } @@ -1059,53 +1103,68 @@ static void destroy_gl_state(GLState *state) QGloSurface *qsurface, *tmp; - DEBUGF("%s state %p\n", __FUNCTION__, state); + DEBUGF("%s state %p\n", __func__, state); QTAILQ_FOREACH_SAFE(qsurface, &state->qsurfaces, next, tmp) { glo_surface_destroy(qsurface->surface); QTAILQ_REMOVE(&state->qsurfaces, qsurface, next); g_free(qsurface); } - - if (state->context) - glo_context_destroy(state->context); - if (state->vertexPointer) + if (state->context) { + glo_context_destroy(state->context); + } + + if (state->vertexPointer) { g_free(state->vertexPointer); - if (state->normalPointer) + } + if (state->normalPointer) { g_free(state->normalPointer); - if (state->indexPointer) + } + if (state->indexPointer) { g_free(state->indexPointer); - if (state->colorPointer) + } + if (state->colorPointer) { g_free(state->colorPointer); - if (state->secondaryColorPointer) + } + if (state->secondaryColorPointer) { g_free(state->secondaryColorPointer); + } for (i = 0; i < NB_MAX_TEXTURES; i++) { - if (state->texCoordPointer[i]) + if (state->texCoordPointer[i]) { g_free(state->texCoordPointer[i]); + } } for (i = 0; i < MY_GL_MAX_VERTEX_ATTRIBS_ARB; i++) { - if (state->vertexAttribPointer[i]) + if (state->vertexAttribPointer[i]) { g_free(state->vertexAttribPointer[i]); + } } for (i = 0; i < MY_GL_MAX_VERTEX_ATTRIBS_NV; i++) { - if (state->vertexAttribPointerNV[i]) + if (state->vertexAttribPointerNV[i]) { g_free(state->vertexAttribPointerNV[i]); + } } - if (state->weightPointer) + if (state->weightPointer) { g_free(state->weightPointer); - if (state->matrixIndexPointer) + } + if (state->matrixIndexPointer) { g_free(state->matrixIndexPointer); - if (state->fogCoordPointer) + } + if (state->fogCoordPointer) { g_free(state->fogCoordPointer); + } for (i = 0; i < MY_GL_MAX_VARIANT_POINTER_EXT; i++) { - if (state->variantPointerEXT[i]) + if (state->variantPointerEXT[i]) { g_free(state->variantPointerEXT[i]); + } } - if (state->interleavedArrays) + if (state->interleavedArrays) { g_free(state->interleavedArrays); - if (state->elementPointerATI) + } + if (state->elementPointerATI) { g_free(state->elementPointerATI); + } } static void init_gl_state(GLState *state) @@ -1133,35 +1192,35 @@ static GLuint translate_id(GLsizei n, GLenum type, const GLvoid *list) switch (type) { case GL_BYTE: - bptr = (GLbyte *) list; + bptr = (GLbyte *)list; return (GLuint) *(bptr + n); case GL_UNSIGNED_BYTE: - ubptr = (GLubyte *) list; + ubptr = (GLubyte *)list; return (GLuint) *(ubptr + n); case GL_SHORT: - sptr = (GLshort *) list; + sptr = (GLshort *)list; return (GLuint) *(sptr + n); case GL_UNSIGNED_SHORT: - usptr = (GLushort *) list; + usptr = (GLushort *)list; return (GLuint) *(usptr + n); case GL_INT: - iptr = (GLint *) list; + iptr = (GLint *)list; return (GLuint) *(iptr + n); case GL_UNSIGNED_INT: - uiptr = (GLuint *) list; + uiptr = (GLuint *)list; return (GLuint) *(uiptr + n); case GL_FLOAT: - fptr = (GLfloat *) list; + fptr = (GLfloat *)list; return (GLuint) *(fptr + n); case GL_2_BYTES: - ubptr = ((GLubyte *) list) + 2 * n; + ubptr = ((GLubyte *)list) + 2 * n; return (GLuint) (*ubptr << 8) + (GLuint) *(ubptr + 1); case GL_3_BYTES: - ubptr = ((GLubyte *) list) + 3 * n; + ubptr = ((GLubyte *)list) + 3 * n; return (GLuint) (*ubptr << 16) + (GLuint) (*(ubptr + 1) << 8) + (GLuint) *(ubptr + 2); case GL_4_BYTES: - ubptr = ((GLubyte *) list) + 4 * n; + ubptr = ((GLubyte *)list) + 4 * n; return (GLuint) (*ubptr << 24) + (GLuint) (*(ubptr + 1) << 16) + (GLuint) (*(ubptr + 2) << 8) + (GLuint) *(ubptr + 3); default: @@ -1178,7 +1237,7 @@ static GLState *_create_context(ProcessState *process, int fake_ctxt) state->fake_ctxt = fake_ctxt; init_gl_state(state); - // FIXMEIM - realloc? really? + /* FIXMEIM - realloc? really? */ process->glstates = g_realloc(process->glstates, (process->nb_states + 1) * sizeof(GLState *)); @@ -1187,11 +1246,14 @@ static GLState *_create_context(ProcessState *process, int fake_ctxt) process->nb_states++; } - DEBUGF("state %p fake_ctxt %08x process->nb_states %d\n", state, fake_ctxt, process->nb_states); + DEBUGF("state %p fake_ctxt %08x process->nb_states %d\n", + state, fake_ctxt, process->nb_states); return state; } -static void set_context_sharelist(ProcessState *process, GLState *state, int fake_shareList) +static void set_context_sharelist(ProcessState *process, + GLState *state, + int fake_shareList) { state->fake_shareList = fake_shareList; @@ -1201,9 +1263,11 @@ static void set_context_sharelist(ProcessState *process, GLState *state, int fak for (i = 0; i < process->nb_states; i++) { if (process->glstates[i]->fake_ctxt == fake_shareList) { process->glstates[i]->ref++; - state->textureAllocator = process->glstates[i]->textureAllocator; + state->textureAllocator = + process->glstates[i]->textureAllocator; state->tabTextures = process->glstates[i]->tabTextures; - state->bufferAllocator = process->glstates[i]->bufferAllocator; + state->bufferAllocator = + process->glstates[i]->bufferAllocator; state->tabBuffers = process->glstates[i]->tabBuffers; state->listAllocator = process->glstates[i]->listAllocator; state->tabLists = process->glstates[i]->tabLists; @@ -1213,13 +1277,15 @@ static void set_context_sharelist(ProcessState *process, GLState *state, int fak } } -static GLState *get_glstate_for_fake_ctxt(ProcessState *process, int fake_ctxt) +static GLState *get_glstate_for_fake_ctxt(ProcessState *process, + int fake_ctxt) { int i; for (i = 0; i < process->nb_states; i++) { - if (process->glstates[i]->fake_ctxt == fake_ctxt) + if (process->glstates[i]->fake_ctxt == fake_ctxt) { return process->glstates[i]; - } + } + } return 0; } @@ -1234,20 +1300,22 @@ void gl_disconnect(ProcessState *process) destroy_gl_state(&process->default_state); g_free(process->glstates); - if (process->cmdbuf) + if (process->cmdbuf) { g_free(process->cmdbuf); + } - for (i = 0; &processes[i] != process; i ++) { - ; // do nothing - } + for (i = 0; &processes[i] != process; i++) { + /* do nothing */ + ; + } - memmove(&processes[i], &processes[i + 1], - (MAX_HANDLED_PROCESS - 1 - i) * sizeof(ProcessState)); + memmove(&processes[i], &processes[i + 1], + (MAX_HANDLED_PROCESS - 1 - i) * sizeof(ProcessState)); } static const int beginend_allowed[GL_N_CALLS] = { #undef MAGIC_MACRO -#define MAGIC_MACRO(name) [name ## _func] = 1, +#define MAGIC_MACRO(name) [name##_func] = 1, #include "gl_beginend.h" }; @@ -1257,7 +1325,7 @@ ProcessStruct *vmgl_get_process(pid_t pid) static int first; int i; - if(!first) { + if (!first) { first = 1; init_process_tab(); } @@ -1267,7 +1335,7 @@ ProcessStruct *vmgl_get_process(pid_t pid) * process->current_state contains info on which of the guests contexts is * current. */ - for (i = 0; i < MAX_HANDLED_PROCESS; i ++) { + for (i = 0; i < MAX_HANDLED_PROCESS; i++) { if (processes[i].p.process_id == pid) { process = &processes[i]; break; @@ -1279,43 +1347,48 @@ ProcessStruct *vmgl_get_process(pid_t pid) process->current_state = &process->default_state; break; } - } + } if (process == NULL) { - DEBUGF( "Too many processes !\n"); + DEBUGF("Too many processes !\n"); exit(-1); } - return (ProcessStruct *)process; // Cast is ok due to struct defn. + return (ProcessStruct *)process; /* Cast is ok due to struct defn. */ } void vmgl_context_switch(ProcessStruct *p, int switch_gl_context) { ProcessState *process = (ProcessState *)p; - if(switch_gl_context) { - if(process->current_state->current_qsurface) - glo_surface_makecurrent(process->current_state->current_qsurface->surface); - else - glo_surface_makecurrent(0); // should never happen + if (switch_gl_context) { + if (process->current_state->current_qsurface) { + glo_surface_makecurrent(process->current_state-> + current_qsurface->surface); + } else { + glo_surface_makecurrent(0); /* should never happen */ + } } } -static char *opengl_strtok(const char *s, int *n, char const **saveptr, char *prevbuf) +static char *opengl_strtok(const char *s, int *n, + char const **saveptr, char *prevbuf) { - const char *start; - char *ret; - char *p; - int retlen; + const char *start; + char *ret; + char *p; + int retlen; static const char *delim = " \t\n\r/"; - if (prevbuf) - free(prevbuf); + if (prevbuf) { + free(prevbuf); + } if (s) { *saveptr = s; } else { - if (!(*saveptr) || !(*n)) + if (!(*saveptr) || !(*n)) { return NULL; + } s = *saveptr; } @@ -1330,83 +1403,90 @@ static char *opengl_strtok(const char *s, int *n, char const **saveptr, char *pr s++, (*n)--; } while (*n > 2 && (s[1] != '*' || s[2] != '/')); s++, (*n)--; - s++, (*n)--; - if (*n == 0) { - break; - } - } else { - break; + s++, (*n)--; + if (*n == 0) { + break; + } + } else { + break; } } } - start = s; + start = s; for (; *n && *s && !strchr(delim, *s); s++, (*n)--) { - ; // do nothing - } + /* do nothing */ + ; + } - if (*n > 0) - s++, (*n)--; + if (*n > 0) { + s++, (*n)--; + } - *saveptr = s; + *saveptr = s; - retlen = s - start; - ret = malloc(retlen + 1); - p = ret; + retlen = s - start; + ret = malloc(retlen + 1); + p = ret; - if (retlen == 0) { - *p = 0; - return ret; - } + if (retlen == 0) { + *p = 0; + return ret; + } - while (retlen > 0) { + while (retlen > 0) { if (*start == '/' && retlen > 1) { if (start[1] == '/') { do { start++, retlen--; } while (retlen > 1 && start[1] != '\n' && start[1] != '\r'); - start++, retlen--; - continue; + start++, retlen--; + continue; } else if (start[1] == '*') { do { start++, retlen--; } while (retlen > 2 && (start[1] != '*' || start[2] != '/')); start += 3, retlen -= 3; - continue; + continue; } } - *(p++) = *(start++), retlen--; - } - - *p = 0; - return ret; + *(p++) = *(start++), retlen--; + } + + *p = 0; + return ret; } static char *do_eglShaderPatch(const char *source, int length, int *patched_len) { - const char *saveptr = NULL; - char *sp; - char *p = NULL; + const char *saveptr = NULL; + char *sp; + char *p = NULL; - if (!length) + if (!length) { length = strlen(source); - + } + *patched_len = 0; int patched_size = length; char *patched = malloc(patched_size + 1); - if (!patched) + if (!patched) { return NULL; + } p = opengl_strtok(source, &length, &saveptr, NULL); for (; p; p = opengl_strtok(0, &length, &saveptr, p)) { - if (!strncmp(p, "lowp", 4) || !strncmp(p, "mediump", 7) || !strncmp(p, "highp", 5)) { + if (!strncmp(p, "lowp", 4) || + !strncmp(p, "mediump", 7) || + !strncmp(p, "highp", 5)) { continue; } else if (!strncmp(p, "precision", 9)) { - while ((p = opengl_strtok(0, &length, &saveptr, p)) && !strchr(p, ';')) { - // do nothing - ; - } + while ((p = opengl_strtok(0, &length, &saveptr, p)) && + !strchr(p, ';')) { + /* do nothing */ + ; + } } else { const char *p2; if (!strncmp(p, "gl_MaxVertexUniformVectors", 26)) { @@ -1424,71 +1504,79 @@ static char *do_eglShaderPatch(const char *source, int length, int *patched_len) patched_size *= 2; patched = realloc(patched, patched_size + 1); - if (!patched) + if (!patched) { return NULL; + } } memcpy(patched + *patched_len, p2, new_len); *patched_len += new_len; - } + } } patched[*patched_len] = 0; /* check that we don't leave dummy preprocessor lines */ for (sp = patched; *sp;) { for (; *sp == ' ' || *sp == '\t'; sp++) { - ; // do nothing - } + /* do nothing */ + ; + } if (!strncmp(sp, "#define", 7)) { for (p = sp + 7; *p == ' ' || *p == '\t'; p++) { - ; // do nothing - } + /* do nothing */ + ; + } if (*p == '\n' || *p == '\r' || *p == '/') { memset(sp, 0x20, 7); } } for (; *sp && *sp != '\n' && *sp != '\r'; sp++) { - ; // do nothing - } + /* do nothing */ + ; + } for (; *sp == '\n' || *sp == '\r'; sp++) { - ; // do nothing - } + /* do nothing */ + ; + } } return patched; } -static int -shadersrc_gles_to_gl(GLsizei count, const char** string, char **s, const GLint* length, GLint *l) +static int +shadersrc_gles_to_gl(GLsizei count, const char **string, + char **s, const GLint *length, GLint *l) { - int i; - - for(i = 0; i < count; ++i) { - GLint len; - if(length) { - len = length[i]; - if (len < 0) - len = string[i] ? strlen(string[i]) : 0; - } else - len = string[i] ? strlen(string[i]) : 0; - - if(string[i]) { - s[i] = do_eglShaderPatch(string[i], len, &l[i]); - if(!s[i]) { - while(i) { - free(s[--i]); - } - - free(l); - free(s); - return -1; - } - } else { - s[i] = NULL; - l[i] = 0; - } - } - - return 0; + int i; + + for (i = 0; i < count; ++i) { + GLint len; + if (length) { + len = length[i]; + if (len < 0) { + len = string[i] ? strlen(string[i]) : 0; + } + } else { + len = string[i] ? strlen(string[i]) : 0; + } + + if (string[i]) { + s[i] = do_eglShaderPatch(string[i], len, &l[i]); + if (!s[i]) { + while (i) { + free(s[--i]); + } + + free(l); + free(s); + return -1; + } + } else { + s[i] = NULL; + l[i] = 0; + } + } + + return 0; } #ifdef __APPLE__ @@ -1500,70 +1588,78 @@ shadersrc_gles_to_gl(GLsizei count, const char** string, char **s, const GLint* */ static void mac_dump_texture(void) { - int w, h; - unsigned char *buf; + int w, h; + unsigned char *buf; - /* only handle target=GL_TEXTURE_2D, level=0, format=GL_RGBA, type=GL_UNSIGNED_BYTE */ - glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &w); - glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &h); + /* only handle target=GL_TEXTURE_2D, level=0, + format=GL_RGBA, type=GL_UNSIGNED_BYTE */ + glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &w); + glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &h); - if ( w == 0 && h == 0 ) - return; + if (w == 0 && h == 0) { + return; + } - buf = g_malloc( (w*4) * h); /* XXX:need allignment? */ + buf = g_malloc((w*4) * h); /* XXX:need allignment? */ - glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, buf); + glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, buf); - g_free(buf); + g_free(buf); } #endif -static int record_fbconfig_set (ProcessState *process, const GLXFBConfig* fbconfigs, int nconfigs) +static int record_fbconfig_set(ProcessState *process, + const GLXFBConfig *fbconfigs, + int nconfigs) { - int i; - int id; - int previous_entries = 0; - - if (!fbconfigs) - return 0; - - /* Check if we already have a similar set in our tables */ - for (i=0; infbconfig; i++) - { - if (process->fbconfigs_max[i] == nconfigs && - !memcmp(fbconfigs, process->fbconfigs[i], sizeof(GLXFBConfig) * nconfigs)) - { - /* No need to store this set as it's identical to another one */ - // XFree(fbconfigs); - - /* Return the identifier of the previously allocated set matching the query */ - id = previous_entries + 1; - return id; - } - else - previous_entries += process->fbconfigs_max[i]; - } - - /* Check if we have room for a new set */ - if (process->nfbconfig >= MAX_FBCONFIG) - { - fprintf(stderr, "[%s]:%d Too many FB configs allocated for this process\n", __FUNCTION__, __LINE__); - // XFree(fbconfigs); - return 0; - } - - /* Store new set - this block should be released using XFree on process exit */ - process->fbconfigs[process->nfbconfig] = fbconfigs; - process->fbconfigs_max[process->nfbconfig] = nconfigs; - process->nfbconfig++; - process->nfbconfig_total += nconfigs; - - id = previous_entries + 1; - return id; -} - - -int do_function_call(ProcessState *process, int func_number, unsigned long *args, char *ret_string) + int i; + int id; + int previous_entries = 0; + + if (!fbconfigs) { + return 0; + } + + /* Check if we already have a similar set in our tables */ + for (i = 0; i < process->nfbconfig; i++) { + if (process->fbconfigs_max[i] == nconfigs && + !memcmp(fbconfigs, process->fbconfigs[i], + sizeof(GLXFBConfig) * nconfigs)) { + /* No need to store this set as it's identical to another one */ + /* XFree(fbconfigs); */ + + /* Return the identifier of the previously allocated + set matching the query */ + id = previous_entries + 1; + return id; + } else { + previous_entries += process->fbconfigs_max[i]; + } + } + + /* Check if we have room for a new set */ + if (process->nfbconfig >= MAX_FBCONFIG) { + fprintf(stderr, + "[%s]:%d Too many FB configs allocated for this process\n", + __func__, __LINE__); + /* XFree(fbconfigs); */ + return 0; + } + + /* Store new set - + this block should be released using XFree on process exit */ + process->fbconfigs[process->nfbconfig] = fbconfigs; + process->fbconfigs_max[process->nfbconfig] = nconfigs; + process->nfbconfig++; + process->nfbconfig_total += nconfigs; + + id = previous_entries + 1; + return id; +} + + +int do_function_call(ProcessState *process, int func_number, + unsigned long *args, char *ret_string) { union gl_ret_type ret; @@ -1573,222 +1669,243 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args ret.s = NULL; if (display_function_call) { - DEBUGF( "[%d]> %s\n", process->p.process_id, - tab_opengl_calls_name[func_number]); + DEBUGF("[%d]> %s\n", process->p.process_id, + tab_opengl_calls_name[func_number]); } - TRACE( "[%d]> %s\n", process->p.process_id, - tab_opengl_calls_name[func_number]); + TRACE("[%d]> %s\n", process->p.process_id, + tab_opengl_calls_name[func_number]); switch (func_number) { case -1: break; - case _resize_surface_func: { ClientGLXDrawable client_drawable = to_drawable(args[0]); QGloSurface *qsurface = get_qsurface_from_client_drawable( - process->current_state, client_drawable); + process->current_state, + client_drawable); - // We have to assume the current context here - // since we assume that a drawable must belong to a specific context - if (qsurface) + /* We have to assume the current context here since we assume that + a drawable must belong to a specific context */ + if (qsurface) { resize_surface(process, qsurface, (int)args[1], (int)args[2]); - else - DEBUGF("%s Failed to find surface for client_drawable %p process %p ->current_state %p ->->current_surface %p\n", "_resize_surface_func", client_drawable, process, process->current_state, process->current_state->current_qsurface); + } else { + DEBUGF("%s Failed to find surface for client_drawable(%p)," + "process(%p),current_state(%p),current_surface(%p)\n", + "_resize_surface_func", client_drawable, process, + process->current_state, + process->current_state->current_qsurface); + } break; - } - case _render_surface_func: { ClientGLXDrawable client_drawable = to_drawable(args[0]); QGloSurface *qsurface = get_qsurface_from_client_drawable( - process->current_state, client_drawable); + process->current_state, + client_drawable); int bpp = (int)args[1]; int stride = (int)args[2]; - char *render_buffer = (char*)args[3]; - -// DEBUGF( "win: %08x stride: %d buf: %08x cl_dr: %08x qsurf: %08x\n", args[0], args[1], args[2], client_drawable, qsurface); + char *render_buffer = (char *)args[3]; - // We have to assume the current context here - // since we assume that a drawable must belong to a specific context - if (qsurface) + /* We have to assume the current context here since we assume that + a drawable must belong to a specific context */ + if (qsurface) { render_surface(qsurface, bpp, stride, render_buffer); + } break; - } - case glXWaitGL_func: { - glFinish(); //glXWaitGL(); + glFinish(); /* glXWaitGL(); */ ret.i = 0; break; } - case glXWaitX_func: { - // FIXME GW Maybe we should just do this on the server? - //glXWaitX(); + /* FIXME GW Maybe we should just do this on the server? */ + /* glXWaitX(); */ ret.i = 0; break; } - case glXChooseVisual_func: { - ret.i = glXChooseVisualFunc((int *) &args[2]); + ret.i = glXChooseVisualFunc((int *)&args[2]); break; } - case glXQueryExtensionsString_func: { - ret.s = supported_glx_extensions();//glXQueryExtensionsString(dpy, 0); + /* glXQueryExtensionsString(dpy, 0); */ + ret.s = supported_glx_extensions(); break; } case glXQueryServerString_func: { switch (args[2]) { - case GLX_VENDOR : ret.s = FAKE_GLX_VENDOR; break; - case GLX_VERSION : ret.s = FAKE_GLX_VERSION_STRING; break; - case GLX_EXTENSIONS : ret.s = supported_glx_extensions(); break; - default: ret.s = 0; + case GLX_VENDOR: + ret.s = FAKE_GLX_VENDOR; + break; + case GLX_VERSION: + ret.s = FAKE_GLX_VERSION_STRING; + break; + case GLX_EXTENSIONS: + ret.s = supported_glx_extensions(); + break; + default: + ret.s = 0; + break; } break; } - case glXGetClientString_func: { switch (args[1]) { - case GLX_VENDOR : ret.s = FAKE_GLX_VENDOR; break; - case GLX_VERSION : ret.s = FAKE_GLX_VERSION_STRING; break; - case GLX_EXTENSIONS : ret.s = "GLX_ARB_get_proc_address "; break; - default: ret.s = 0; + case GLX_VENDOR: + ret.s = FAKE_GLX_VENDOR; + break; + case GLX_VERSION: + ret.s = FAKE_GLX_VERSION_STRING; + break; + case GLX_EXTENSIONS: + ret.s = "GLX_ARB_get_proc_address "; + break; + default: + ret.s = 0; + break; } break; } - case glXGetScreenDriver_func: { - // FIXME GW What is this? not documented anywhere!! - //GET_EXT_PTR(const char *, glXGetScreenDriver, (Display *, int)); - //ret.s = ptr_func_glXGetScreenDriver(dpy, 0); + /* FIXME GW What is this? not documented anywhere!! */ + /*GET_EXT_PTR(const char *, glXGetScreenDriver, (Display *, int)); + ret.s = ptr_func_glXGetScreenDriver(dpy, 0); */ ret.s = ""; break; } - case glXGetDriverConfig_func: { - // FIXME GW What is this? not documented anywhere!! - //GET_EXT_PTR(const char *, glXGetDriverConfig, (const char *)); - //ret.s = ptr_func_glXGetDriverConfig((const char *) args[0]); + /* FIXME GW What is this? not documented anywhere!! */ + /*GET_EXT_PTR(const char *, glXGetDriverConfig, (const char *)); + ret.s = ptr_func_glXGetDriverConfig((const char *) args[0]); */ ret.s = ""; break; } - case glXCreateContext_func: { int visualid = (int) args[1]; int fake_shareList = (int) args[2]; - if (display_function_call) - DEBUGF( "visualid=%d, fake_shareList=%d\n", visualid, - fake_shareList); + if (display_function_call) { + DEBUGF("visualid=%d, fake_shareList=%d\n", visualid, + fake_shareList); + } - GLState *shareListState = get_glstate_for_fake_ctxt(process, fake_shareList); + GLState *shareListState = get_glstate_for_fake_ctxt(process, + fake_shareList); ret.i = 0; - // Work out format flags from visual id + /* Work out format flags from visual id */ int formatFlags = GLO_FF_DEFAULT; - if (visualid>=0 && visualid= 0 && visualid < DIM(FBCONFIGS)) { formatFlags = FBCONFIGS[visualid].formatFlags; + } GloContext *context = glo_context_create(formatFlags, - (GloContext*)shareListState ? shareListState->context : 0); + (GloContext *)shareListState ? + shareListState->context : 0); if (context) { - GLState *state = _create_context(process, ++process->next_available_context_number); + GLState *state = _create_context(process, + ++process->next_available_context_number); if (state) { state->context = context; set_context_sharelist(process, state, fake_shareList); ret.i = state->fake_ctxt; } else { - DEBUGF("Failed to allocate state context for format %08x\n", formatFlags); + DEBUGF("Failed to allocate state context" + " for format %08x\n", formatFlags); glo_context_destroy(context); } } else { - DEBUGF("Failed to create context for format %08x\n", formatFlags); + DEBUGF("Failed to create context " + "for format %08x\n", formatFlags); } break; } - case glXCreateNewContext_func: { int client_fbconfig = args[1]; ret.i = 0; - const GLXFBConfig *fbconfig = get_fbconfig(process, client_fbconfig); + const GLXFBConfig *fbconfig = get_fbconfig(process, + client_fbconfig); if (fbconfig) { int fake_shareList = args[3]; - GLState *shareListState = get_glstate_for_fake_ctxt(process, fake_shareList); - + GLState *shareListState = get_glstate_for_fake_ctxt(process, + fake_shareList); + /* FIXME GW get from fbconfig */ GloContext *context = glo_context_create(fbconfig->formatFlags, - (GloContext*)shareListState ? shareListState->context : 0); // FIXME GW get from fbconfig + (GloContext *)shareListState ? + shareListState->context : 0); if (context) { - GLState *state = _create_context(process, ++process->next_available_context_number); + GLState *state = + _create_context(process, + ++process->next_available_context_number); if (state) { state->context = context; set_context_sharelist(process, state, fake_shareList); ret.i = state->fake_ctxt; } else { - DEBUGF("Failed to allocate state context for format %08x", fbconfig->formatFlags); + DEBUGF("Failed to allocate state context" + " for format %08x", fbconfig->formatFlags); glo_context_destroy(context); } } else { - DEBUGF("Failed to create context for format %08x", fbconfig->formatFlags); + DEBUGF("Failed to create context" + " for format %08x", fbconfig->formatFlags); } } break; } - case glXCopyContext_func: { - DEBUGF( " glXCopyContext not supported (does anything use it?)\n"); + DEBUGF("glXCopyContext not supported (does anything use it?)\n"); break; } - case glXDestroyContext_func: { - int fake_ctxt = (int) args[1]; + int fake_ctxt = (int)args[1]; - if (display_function_call) - DEBUGF( "fake_ctxt=%d\n", fake_ctxt); + if (display_function_call) { + DEBUGF("fake_ctxt=%d\n", fake_ctxt); + } int i; - for (i = 0; i < process->nb_states; i ++) { + for (i = 0; i < process->nb_states; i++) { if (process->glstates[i]->fake_ctxt == fake_ctxt) { - /*XXX: DestroyContext should not switch current context, or - * else guest still try to access it and cause qemu - * segfalt. But not sure if any corner case, so comment it - * for now and will remove it completely in future. - */ - // this was our GLState... - // process->current_state = &process->default_state; - - int fake_shareList = - process->glstates[i]->fake_shareList; + /*XXX: DestroyContext should not switch current context, + * or else guest still try to access it + * and cause qemu segfalt. + * But not sure if any corner case, so comment it + * for now and will remove it completely in future. + * this was our GLState... + * process->current_state = &process->default_state; + */ + int fake_shareList = process->glstates[i]->fake_shareList; process->glstates[i]->ref--; if (process->glstates[i]->ref == 0) { - DEBUGF( - "destroy_gl_state fake_ctxt = %d\n", - process->glstates[i]->fake_ctxt); + DEBUGF("destroy_gl_state fake_ctxt = %d\n", + process->glstates[i]->fake_ctxt); destroy_gl_state(process->glstates[i]); g_free(process->glstates[i]); memmove(&process->glstates[i], &process->glstates[i + 1], (process->nb_states - i - 1) * sizeof(GLState *)); - process->nb_states --; + process->nb_states--; } if (fake_shareList) { @@ -1797,223 +1914,239 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args fake_shareList) { process->glstates[i]->ref--; if (process->glstates[i]->ref == 0) { - DEBUGF( - "destroy_gl_state fake_sharelist fake_ctxt = %d\n", - process->glstates[i]-> - fake_ctxt); - destroy_gl_state(process-> - glstates[i]); + DEBUGF("destroy_gl_state fake_sharelist" + " fake_ctxt = %d\n", + process->glstates[i]->fake_ctxt); + destroy_gl_state(process->glstates[i]); g_free(process->glstates[i]); memmove(&process->glstates[i], &process->glstates[i + 1], (process->nb_states - i - 1) * sizeof(GLState *)); - process->nb_states --; + process->nb_states--; } break; } } } - break; } } break; } - case glXQueryVersion_func: { - int *major = (int *) args[1]; - int *minor = (int *) args[2]; - //ret.i = glXQueryVersion(dpy, (int *) args[1], (int *) args[2]); - if (major) *major=FAKE_GLX_VERSION_MAJOR; - if (minor) *minor=FAKE_GLX_VERSION_MINOR; + int *major = (int *)args[1]; + int *minor = (int *)args[2]; + /* ret.i = glXQueryVersion(dpy, (int *)args[1], (int *)args[2]); */ + if (major) { + *major = FAKE_GLX_VERSION_MAJOR; + } + if (minor) { + *minor = FAKE_GLX_VERSION_MINOR; + } ret.i = True; break; } - case glGetString_func: { switch (args[0]) { - case GL_VENDOR: + case GL_VENDOR: ret.s = FAKE_GL_VENDOR; - break; - case GL_RENDERER: + break; + case GL_RENDERER: ret.s = FAKE_GL_RENDERER; - break; - case GL_VERSION: + break; + case GL_VERSION: ret.s = FAKE_GL_VERSION; - break; - case GL_EXTENSIONS: + break; + case GL_EXTENSIONS: ret.s = compute_gl_extensions(); - break; - case GL_SHADING_LANGUAGE_VERSION: - if(FAKE_GL_MAJOR < 2) { - ret.s = ""; - break; + break; + case GL_SHADING_LANGUAGE_VERSION: + if (FAKE_GL_MAJOR < 2) { + ret.s = ""; + break; } - // Fall through. - default: - ret.s = (char *) glGetString(args[0]); - break; + /* Fall through. */ + default: + ret.s = (char *)glGetString(args[0]); + break; } break; } - case glXMakeCurrent_func: { ClientGLXDrawable client_drawable = to_drawable(args[1]); - int fake_ctxt = (int) args[2]; + int fake_ctxt = (int)args[2]; GLState *glstate = NULL; - DEBUGF( "Makecurrent: fake_ctx=%d client_drawable=%08x\n", fake_ctxt, client_drawable); + DEBUGF("Makecurrent: fake_ctx=%d client_drawable=%08x\n", + fake_ctxt, client_drawable); if (client_drawable == 0 && fake_ctxt == 0) { /* Release context */ - if(process->current_state->current_qsurface) { - if(process->current_state->current_qsurface->type != SURFACE_PIXMAP) + if (process->current_state->current_qsurface) { + if (process->current_state->current_qsurface->type != + SURFACE_PIXMAP) { process->current_state->current_qsurface->ref--; - else - unbind_qsurface(process->current_state, process->current_state->current_qsurface); + } else { + unbind_qsurface(process->current_state, + process->current_state->current_qsurface); + } } process->current_state = &process->default_state; - DEBUGF( " --release\n"); + DEBUGF(" --release\n"); glo_surface_makecurrent(0); } else { /* Lookup GLState struct for this context */ glstate = get_glstate_for_fake_ctxt(process, fake_ctxt); if (!glstate) { - DEBUGF( " --invalid fake_ctxt (%d)!\n", fake_ctxt); + DEBUGF(" --invalid fake_ctxt (%d)!\n", fake_ctxt); } else { - if(!set_current_qsurface(glstate, client_drawable) && - !link_qsurface(process, glstate, client_drawable) ) { - // If there is no surface, create one. - QGloSurface *qsurface = calloc(1, sizeof(QGloSurface)); - qsurface->surface = glo_surface_create(4, 4, - glstate->context); - qsurface->client_drawable = client_drawable; - qsurface->ref = 1; - qsurface->type = SURFACE_WINDOW; - qsurface->status = SURFACE_ACTIVE; - - bind_qsurface(glstate, qsurface); - DEBUGF( " --Client drawable not found, create new surface: %p %16lx\n", qsurface, (unsigned long int)client_drawable); - } - else { - DEBUGF( " --Client drawable found, using surface: %p %16lx\n", glstate->current_qsurface, (unsigned long int)client_drawable); + if (!set_current_qsurface(glstate, client_drawable) && + !link_qsurface(process, glstate, client_drawable)) { + /* If there is no surface, create one. */ + QGloSurface *qsurface = calloc(1, sizeof(QGloSurface)); + qsurface->surface = glo_surface_create(4, 4, + glstate->context); + qsurface->client_drawable = client_drawable; + qsurface->ref = 1; + qsurface->type = SURFACE_WINDOW; + qsurface->status = SURFACE_ACTIVE; + + bind_qsurface(glstate, qsurface); + DEBUGF(" --Client drawable not found, " + "create new surface: %p %16lx\n", + qsurface, (unsigned long int)client_drawable); + } else { + DEBUGF(" --Client drawable found, using surface: " + "%p %16lx\n", glstate->current_qsurface, + (unsigned long int)client_drawable); } #if 0 /*Test old surface contents */ int reset_texture = 0; GLState *old_glstate = NULL; /* Switch from pixmap */ - if (process->current_state->current_qsurface && SURFACE_PIXMAP == process->current_state->current_qsurface->type ) - { - glo_surface_updatecontents(process->current_state->current_qsurface->surface); + if (process->current_state->current_qsurface && + SURFACE_PIXMAP == process->current_state-> + current_qsurface->type) { + glo_surface_updatecontents( + process->current_state-> + current_qsurface->surface); reset_texture = 1; old_glstate = process->current_state; } - fprintf(stderr, "edwin:MakeCurrent: drawable=0x%x,qsurface=%p.\n", client_drawable, glstate->current_qsurface); + fprintf(stderr, + "MakeCurrent: drawable=0x%x,qsurface=%p.\n", + client_drawable, glstate->current_qsurface); #endif /* Switch in pixmap surface */ - if (glstate->current_qsurface && SURFACE_PIXMAP == glstate->current_qsurface->type ) - { - /* Release it if the surface is used as texture target */ - glo_surface_release_texture(glstate->current_qsurface->surface); + if (glstate->current_qsurface && SURFACE_PIXMAP == + glstate->current_qsurface->type) { + /* Release it if the surface is used + as texture target */ + glo_surface_release_texture( + glstate->current_qsurface->surface); } process->current_state = glstate; - ret.i = glo_surface_makecurrent(glstate->current_qsurface->surface); -/* if (reset_texture)*/ -/* glo_surface_as_texture(process->current_state->context, old_glstate->current_qsurface->surface);*/ + ret.i = glo_surface_makecurrent( + glstate->current_qsurface->surface); +/* if (reset_texture) { + glo_surface_as_texture( + process->current_state->context, + old_glstate->current_qsurface->surface); + } */ } } break; } - case glXSwapBuffers_func: { - // Does nothing - window data is copied via render_surface() + /* Does nothing - window data is copied via render_surface() */ break; } case glXIsDirect_func: { - // int fake_ctxt = (int) args[1]; + /* int fake_ctxt = (int) args[1]; */ - // Does this go direct and skip the X server? We'll just say - // yes for now. + /* Does this go direct and skip the X server? We'll just say + yes for now. */ ret.c = True; - break; } - case glXGetConfig_func: { int visualid = args[1]; - ret.i = glXGetConfigFunc(visualid, args[2], (int *) args[3]); + ret.i = glXGetConfigFunc(visualid, args[2], (int *)args[3]); break; } - case glXGetConfig_extended_func: { int visualid = args[1]; int n = args[2]; int i; - int *attribs = (int *) args[3]; - int *values = (int *) args[4]; - int *res = (int *) args[5]; + int *attribs = (int *)args[3]; + int *values = (int *)args[4]; + int *res = (int *)args[5]; for (i = 0; i < n; i++) { res[i] = glXGetConfigFunc(visualid, attribs[i], &values[i]); } break; } - case glXUseXFont_func: { /* implementation is client-side only :-) */ break; } - case glXQueryExtension_func: { - int *errorBase = (int *) args[1]; - int *eventBase = (int *) args[2]; - if (errorBase) *errorBase = 0; /* FIXME GW */ - if (eventBase) *eventBase = 0; /* FIXME GW */ + int *errorBase = (int *)args[1]; + int *eventBase = (int *)args[2]; + if (errorBase) { + *errorBase = 0; /* FIXME GW */ + } + if (eventBase) { + *eventBase = 0; /* FIXME GW */ + } ret.i = True; break; } - case glXChooseFBConfig_func: { - /* Retrieve array of FB configs matching our contraints */ - const GLXFBConfig *fbconfigs = glXChooseFBConfigFunc(args[1], (int *) args[2], (int *) args[3]); - - /* Record this in our tables and return a client-side identifier for the first entry in the array */ - ret.i = record_fbconfig_set(process, fbconfigs, *(int *) args[3]); - - /* Zero indicates failure */ - if (ret.i == 0) - *(int *) args[3] = 0; - - break; - } - + /* Retrieve array of FB configs matching our contraints */ + const GLXFBConfig *fbconfigs = glXChooseFBConfigFunc(args[1], + (int *)args[2], (int *)args[3]); + + /* Record this in our tables and return a client-side identifier + for the first entry in the array */ + ret.i = record_fbconfig_set(process, fbconfigs, *(int *)args[3]); + + /* Zero indicates failure */ + if (ret.i == 0) { + *(int *)args[3] = 0; + } + break; + } case glXGetFBConfigs_func: { - /* Retrieve array of available FB configs */ - const GLXFBConfig *fbconfigs = glXGetFBConfigsFunc(args[1], (int *) args[2]); - - /* Record this in our tables and return a client-side identifier for the first entry in the array */ - ret.i = record_fbconfig_set(process, fbconfigs, *(int *) args[2]); - - /* Zero indicates failure */ - if (ret.i == 0) - *(int *) args[2] = 0; - + /* Retrieve array of available FB configs */ + const GLXFBConfig *fbconfigs = glXGetFBConfigsFunc(args[1], + (int *)args[2]); + + /* Record this in our tables and return a client-side identifier + for the first entry in the array */ + ret.i = record_fbconfig_set(process, fbconfigs, *(int *)args[2]); + + /* Zero indicates failure */ + if (ret.i == 0) { + *(int *)args[2] = 0; + } break; } case glXGetFBConfigAttrib_func: @@ -2021,28 +2154,32 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args int client_fbconfig = args[1]; ret.i = 0; - const GLXFBConfig *fbconfig = get_fbconfig(process, client_fbconfig); + const GLXFBConfig *fbconfig = get_fbconfig(process, + client_fbconfig); - if (fbconfig) + if (fbconfig) { ret.i = - glXGetFBConfigAttribFunc(fbconfig, args[2], (int *) args[3]); + glXGetFBConfigAttribFunc(fbconfig, args[2], + (int *)args[3]); + } break; } - case glXGetFBConfigAttrib_extended_func: { int client_fbconfig = args[1]; int n = args[2]; int i; - int *attribs = (int *) args[3]; - int *values = (int *) args[4]; - int *res = (int *) args[5]; - const GLXFBConfig *fbconfig = get_fbconfig(process, client_fbconfig); + int *attribs = (int *)args[3]; + int *values = (int *)args[4]; + int *res = (int *)args[5]; + const GLXFBConfig *fbconfig = get_fbconfig(process, + client_fbconfig); for (i = 0; i < n; i++) { if (fbconfig) { res[i] = - glXGetFBConfigAttribFunc(fbconfig, attribs[i], &values[i]); + glXGetFBConfigAttribFunc(fbconfig, + attribs[i], &values[i]); } else { res[i] = 0; } @@ -2051,36 +2188,37 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args } case glXQueryContext_func: { - DEBUGF( "glXQueryContext not implemented\n"); + DEBUGF("glXQueryContext not implemented\n"); ret.i = 0; -#if 0 //GW +#if 0 /* GW */ GET_EXT_PTR(int, glXQueryContext, (Display *, GLXContext, int, int *)); int fake_ctxt = (int) args[1]; - if (display_function_call) - DEBUGF( "fake_ctx=%i\n", fake_ctxt); + if (display_function_call) { + DEBUGF("fake_ctx=%i\n", fake_ctxt); + } GLXContext ctxt = get_association_fakecontext_glxcontext(process, fake_ctxt); if (ctxt == NULL) { - DEBUGF( "invalid fake_ctxt (%i) !\n", fake_ctxt); + DEBUGF("invalid fake_ctxt (%i) !\n", fake_ctxt); ret.i = 0; } else { ret.i = ptr_func_glXQueryContext(dpy, ctxt, args[2], - (int *) args[3]); + (int *)args[3]); } #endif break; } - case glXQueryDrawable_func: { - // TODO GW one of: - // GLX_WIDTH, GLX_HEIGHT, GLX_PRESERVED_CONTENTS, GLX_LARGEST_PBUFFER, GLX_FBCONFIG_ID - DEBUGF( "FIXME: glXQueryDrawable not implemented\n"); + /* TODO GW one of: + GLX_WIDTH, GLX_HEIGHT, GLX_PRESERVED_CONTENTS, + GLX_LARGEST_PBUFFER, GLX_FBCONFIG_ID */ + DEBUGF("FIXME: glXQueryDrawable not implemented\n"); ret.i = 0; -#if 0 //GW +#if 0 /* GW */ GET_EXT_PTR(void, glXQueryDrawable, (Display *, GLXDrawable, int, int *)); ClientGLXDrawable client_drawable = to_drawable(args[1]); @@ -2088,16 +2226,16 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args get_association_clientdrawable_serverdrawable( glstate, client_drawable); - if (display_function_call) - DEBUGF( "client_drawable=%p\n", - client_drawable); + if (display_function_call) { + DEBUGF("client_drawable=%p\n", client_drawable); + } - if (!drawable) - DEBUGF( "invalid client_drawable (%p) !\n", - client_drawable); - else + if (!drawable) { + DEBUGF("invalid client_drawable (%p) !\n", client_drawable); + } else { ptr_func_glXQueryDrawable(dpy, drawable, - args[2], (int *) args[3]); + args[2], (int *)args[3]); + } #endif break; } @@ -2106,13 +2244,15 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args int client_fbconfig = args[1]; ret.i = 0; - const GLXFBConfig *fbconfig = get_fbconfig(process, client_fbconfig); + const GLXFBConfig *fbconfig = get_fbconfig(process, + client_fbconfig); if (fbconfig) { - // we tread visualid as the index into the fbconfigs array + /* we tread visualid as the index into the fbconfigs array */ ret.i = &FBCONFIGS[0] - fbconfig; - if (display_function_call) - DEBUGF( "visualid = %d\n", ret.i); + if (display_function_call) { + DEBUGF("visualid = %d\n", ret.i); + } } break; } @@ -2126,27 +2266,26 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args case glXGetProcAddress_fake_func: { -// if (display_function_call) - //DEBUGF( "glXGetProcAddress %s ", (char *) args[0]); - // ret.i = glo_getprocaddress((const char *) args[0]) != NULL; - // DEBUGF( " == %08x\n", ret.i); + /* if (display_function_call) + DEBUGF( "glXGetProcAddress %s ", (char *) args[0]); + ret.i = glo_getprocaddress((const char *) args[0]) != NULL; + DEBUGF( " == %08x\n", ret.i); */ ret.i = 0; break; } - case glXGetProcAddress_global_fake_func: { int nbElts = args[0]; - char *huge_buffer = (char *) args[1]; - char *result = (char *) args[2]; + char *huge_buffer = (char *)args[1]; + char *result = (char *)args[2]; int i; for (i = 0; i < nbElts; i++) { int len = strlen(huge_buffer); - //DEBUGF( "glXGetProcAddress_global %s ", (char *)huge_buffer); + /* DEBUGF("glXGetProcAddress_global %s\n", + (char *)huge_buffer); */ result[i] = - glo_getprocaddress((const char *) huge_buffer) != - NULL; + glo_getprocaddress((const char *)huge_buffer) != NULL; huge_buffer += len + 1; } break; @@ -2156,11 +2295,13 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args int client_fbconfig = args[1]; ret.i = 0; - const GLXFBConfig *fbconfig = get_fbconfig(process, client_fbconfig); + const GLXFBConfig *fbconfig = get_fbconfig(process, + client_fbconfig); if (fbconfig) { /* Create a light-weight context just for creating surface */ - GloContext *context = __glo_context_create(fbconfig->formatFlags); + GloContext *context = __glo_context_create( + fbconfig->formatFlags); if (context) { /* glXPixmap same as input Pixmap */ ClientGLXDrawable client_drawable = to_drawable(args[2]); @@ -2169,23 +2310,29 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args if (qsurface) { /* get the width and height */ int width, height; - glo_geometry_get_from_glx((int*)args[3], &width, &height); + glo_geometry_get_from_glx((int *)args[3], + &width, &height); - DEBUGF( "glXCreatePixmap: %dX%d.\n", width, height); - qsurface->surface = glo_surface_create(width, height, context); + DEBUGF("glXCreatePixmap: %dX%d.\n", width, height); + qsurface->surface = glo_surface_create(width, + height, context); if (qsurface->surface) { qsurface->client_drawable = client_drawable; qsurface->type = SURFACE_PIXMAP; qsurface->status = SURFACE_PENDING; qsurface_pixmap_ref(qsurface); - /* Keep this surface, will link it with context in MakeCurrent */ + /* Keep this surface, + will link it with context in MakeCurrent */ keep_qsurface(process, qsurface); - /* If this pixmap is linked as texture previously */ - if (link_drawable(process, client_drawable)) - glo_surface_as_texture(process->current_state->context, + /* If this pixmap is linked + as texture previously */ + if (link_drawable(process, client_drawable)) { + glo_surface_as_texture( + process->current_state->context, qsurface->surface, qsurface->type); + } ret.i = (int)client_drawable; } else { @@ -2203,7 +2350,9 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args { /* glXPixmap same as input Pixmap */ ClientGLXDrawable client_drawable = to_drawable(args[1]); - QGloSurface *qsurface = find_qsurface_from_client_drawable(process, client_drawable); + QGloSurface *qsurface = + find_qsurface_from_client_drawable(process, + client_drawable); qsurface_pixmap_unref(qsurface); break; } @@ -2211,90 +2360,103 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args { int target = args[0]; ClientGLXDrawable client_drawable = to_drawable(args[1]); - QGloSurface *qsurface = find_qsurface_from_client_drawable(process, client_drawable); + QGloSurface *qsurface = + find_qsurface_from_client_drawable(process, + client_drawable); - /* Only support GL_TEXTURE_2D according to spec */ - if ( target == GL_TEXTURE_2D ) + /* Only support GL_TEXTURE_2D according to spec */ + if (target == GL_TEXTURE_2D) { add_pixmap_texture_mapping(process->current_state, process->current_state->bindTexture2D, client_drawable); - - if ( !qsurface ) - { - if ( !keep_drawable(process, client_drawable) ) - { - DEBUGF( "No space to store drawable for ImageTargetTexture. Need call CreatePixmapSurface to free them.\n"); + } + + if (!qsurface) { + if (!keep_drawable(process, client_drawable)) { + DEBUGF("No space to store drawable for ImageTargetTexture." + " Need call CreatePixmapSurface to free them.\n"); break; } + } else { + glo_surface_as_texture(process->current_state->context, + qsurface->surface, qsurface->type); } - else - glo_surface_as_texture(process->current_state->context, qsurface->surface, qsurface->type); - - break; - } - case glXBindTexImageARB_fake_func: - { - ClientGLXDrawable client_drawable = to_drawable(args[1]); - QGloSurface *qsurface = find_qsurface_from_client_drawable(process, client_drawable); - ret.i = 0; - - - if ( qsurface ) - { - add_pixmap_texture_mapping(process->current_state, - process->current_state->bindTexture2D, - client_drawable); - glo_surface_as_texture(process->current_state->context, qsurface->surface, qsurface->type); - ret.i = 1; - } - else - DEBUGF( "Not found pbuffer surface for BindTexImage!\n"); - - break; - } - case glXReleaseTexImageARB_fake_func: - { - ClientGLXDrawable client_drawable = to_drawable(args[1]); - QGloSurface *qsurface = find_qsurface_from_client_drawable(process, client_drawable); - - if ( qsurface ) - { - remove_pixmap_texture_mapping(process->current_state, - client_drawable); - glo_surface_release_texture(qsurface->surface); - } - - break; - } - case glXCreatePbuffer_func: - { - int client_fbconfig = args[1]; - - ret.i = 0; - const GLXFBConfig *fbconfig = get_fbconfig(process, client_fbconfig); - if (fbconfig) { + break; + } + case glXBindTexImageARB_fake_func: + { + ClientGLXDrawable client_drawable = to_drawable(args[1]); + QGloSurface *qsurface = + find_qsurface_from_client_drawable(process, + client_drawable); + ret.i = 0; + + if (qsurface) { + add_pixmap_texture_mapping(process->current_state, + process->current_state->bindTexture2D, + client_drawable); + glo_surface_as_texture(process->current_state->context, + qsurface->surface, qsurface->type); + ret.i = 1; + } else { + DEBUGF("Not found pbuffer surface for BindTexImage!\n"); + } + + break; + } + case glXReleaseTexImageARB_fake_func: + { + ClientGLXDrawable client_drawable = to_drawable(args[1]); + QGloSurface *qsurface = + find_qsurface_from_client_drawable(process, + client_drawable); + + if (qsurface) { + remove_pixmap_texture_mapping(process->current_state, + client_drawable); + glo_surface_release_texture(qsurface->surface); + } + + break; + } + case glXCreatePbuffer_func: + { + int client_fbconfig = args[1]; + + ret.i = 0; + const GLXFBConfig *fbconfig = get_fbconfig(process, + client_fbconfig); + if (fbconfig) { /* Create a light-weight context just for creating surface */ - GloContext *context = __glo_context_create(fbconfig->formatFlags); + GloContext *context = + __glo_context_create(fbconfig->formatFlags); if (context) { QGloSurface *qsurface = calloc(1, sizeof(QGloSurface)); if (qsurface) { /* get the width and height */ int width, height; - glo_geometry_get_from_glx((int*)args[2], &width, &height); + glo_geometry_get_from_glx((int *)args[2], + &width, &height); - DEBUGF( "glXCreatePbuffer: %dX%d.\n", width, height); - qsurface->surface = glo_surface_create(width, height, context); + DEBUGF("glXCreatePbuffer: %dX%d.\n", width, height); + qsurface->surface = glo_surface_create(width, + height, + context); if (qsurface->surface) { - /* Use GloSurface handler as no input client_drawable, and - * keep only low 32bit of handler on x86_64 host. */ - qsurface->client_drawable = (ClientGLXDrawable)(long)qsurface->surface; + /* Use GloSurface handler + as no input client_drawable, + and keep only low 32bit of handler + on x86_64 host. */ + qsurface->client_drawable = + (ClientGLXDrawable)(long)qsurface->surface; qsurface->type = SURFACE_PBUFFER; qsurface->status = SURFACE_PENDING; - /* qsurface->ref = 1;*/ + /* qsurface->ref = 1; */ - /* Keep this surface, will link it with context in MakeCurrent */ + /* Keep this surface, + will link it with context in MakeCurrent */ keep_qsurface(process, qsurface); ret.i = qsurface->client_drawable; @@ -2307,23 +2469,23 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args } } } - break; - } - case glXDestroyPbuffer_func: - { + break; + } + case glXDestroyPbuffer_func: + { ClientGLXDrawable client_drawable = to_drawable(args[1]); - QGloSurface *qsurface = find_qsurface_from_client_drawable(process, client_drawable); - if ( qsurface && - qsurface != process->current_state->current_qsurface && - qsurface->glstate == NULL && - qsurface->type == SURFACE_PBUFFER ) - { + QGloSurface *qsurface = + find_qsurface_from_client_drawable(process, + client_drawable); + if (qsurface && + qsurface != process->current_state->current_qsurface && + qsurface->glstate == NULL && + qsurface->type == SURFACE_PBUFFER) { glo_surface_destroy(qsurface->surface); g_free(qsurface); } break; - } - + } /* Begin of texture stuff */ case glBindTexture_func: case glBindTextureEXT_func: @@ -2332,11 +2494,11 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args unsigned int client_texture = args[1]; unsigned int server_texture; - if(((int)client_texture) < 0) - { - fprintf(stderr, "glBindTexture got invalid texture ID, do nothing!\n"); - break; - } + if (((int)client_texture) < 0) { + fprintf(stderr, + "glBindTexture got invalid texture ID, do nothing!\n"); + break; + } if (client_texture == 0) { glBindTexture(target, 0); @@ -2353,30 +2515,33 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args glBindTexture(target, server_texture); } - if ( target == GL_TEXTURE_2D ) { + if (target == GL_TEXTURE_2D) { QGloSurface *qsurface = NULL; ClientGLXDrawable drawable = - find_pixmap_texture(process->current_state, client_texture); + find_pixmap_texture(process->current_state, + client_texture); - if ( drawable ) - { - qsurface = find_qsurface_from_client_drawable(process, drawable); + if (drawable) { + qsurface = find_qsurface_from_client_drawable(process, + drawable); - if ( qsurface ) - { - glo_surface_as_texture(process->current_state->context, qsurface->surface, qsurface->type); - /*fprintf(stderr, "edwin:bindtexture: drawable=0x%x,qsurface=%p.\n", drawable, qsurface);*/ + if (qsurface) { + glo_surface_as_texture(process->current_state->context, + qsurface->surface, + qsurface->type); + /* fprintf(stderr, + "bindtexture: drawable=0x%x,qsurface=%p.\n", + drawable, qsurface);*/ } } - process->current_state->bindTexture2D = client_texture; } - break; + break; } - case glGenTextures_fake_func: { - //GET_EXT_PTR(void, glGenTextures, (GLsizei n, GLuint *textures)); + /* GET_EXT_PTR(void, glGenTextures, + (GLsizei n, GLuint *textures)); */ int i; int n = args[0]; unsigned int *clientTabTextures = g_malloc(n * sizeof(int)); @@ -2385,8 +2550,8 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args alloc_range(process->current_state->textureAllocator, n, clientTabTextures); - //ptr_func_glGenTextures(n, serverTabTextures); - glGenTextures(n, serverTabTextures); + /* ptr_func_glGenTextures(n, serverTabTextures); */ + glGenTextures(n, serverTabTextures); for (i = 0; i < n; i++) { process->current_state->tabTextures[clientTabTextures[i]] = serverTabTextures[i]; @@ -2396,15 +2561,13 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args g_free(serverTabTextures); break; } - - case glDeleteTextures_func: { - //GET_EXT_PTR(void, glDeleteTextures, - // (GLsizei n, const GLuint *textures)); + /* GET_EXT_PTR(void, glDeleteTextures, + (GLsizei n, const GLuint *textures)); */ int i; int n = args[0]; - unsigned int *clientTabTextures = (unsigned int *) args[1]; + unsigned int *clientTabTextures = (unsigned int *)args[1]; delete_range(process->current_state->textureAllocator, n, clientTabTextures); @@ -2415,20 +2578,19 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args serverTabTextures[i] = get_server_texture(process, clientTabTextures[i]); } - //ptr_func_glDeleteTextures(n, serverTabTextures); - glDeleteTextures(n, serverTabTextures); + /* ptr_func_glDeleteTextures(n, serverTabTextures); */ + glDeleteTextures(n, serverTabTextures); for (i = 0; i < n; i++) { process->current_state->tabTextures[clientTabTextures[i]] = 0; } g_free(serverTabTextures); - for ( i = 0; i < n; i++ ) - { - del_pixmap_texture_mapping(process->current_state, clientTabTextures[i]); + for (i = 0; i < n; i++) { + del_pixmap_texture_mapping(process->current_state, + clientTabTextures[i]); } - break; + break; } - case glPrioritizeTextures_func: { GET_EXT_PTR(void, glPrioritizeTextures, @@ -2437,48 +2599,46 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args int i; int n = args[0]; - unsigned int *textures = (unsigned int *) args[1]; + unsigned int *textures = (unsigned int *)args[1]; for (i = 0; i < n; i++) { textures[i] = get_server_texture(process, textures[i]); } ptr_func_glPrioritizeTextures(n, textures, - (const GLclampf *) args[2]); + (const GLclampf *)args[2]); break; } - case glAreTexturesResident_func: { GET_EXT_PTR(void, glAreTexturesResident, (GLsizei n, const GLuint *textures, - GLboolean *residences)); + GLboolean *residences)); int i; int n = args[0]; - unsigned int *textures = (unsigned int *) args[1]; + unsigned int *textures = (unsigned int *)args[1]; for (i = 0; i < n; i++) { textures[i] = get_server_texture(process, textures[i]); } ptr_func_glAreTexturesResident(n, textures, - (GLboolean *) args[2]); + (GLboolean *)args[2]); break; } - case glIsTexture_func: case glIsTextureEXT_func: { - //GET_EXT_PTR(GLboolean, glIsTexture, (GLuint texture)); + /* GET_EXT_PTR(GLboolean, glIsTexture, (GLuint texture)); */ unsigned int client_texture = args[0]; unsigned int server_texture = get_server_texture(process, client_texture); - if (server_texture) - // ret.c = ptr_func_glIsTexture(server_texture); - ret.c = glIsTexture(server_texture); - else + if (server_texture) { + /* ret.c = ptr_func_glIsTexture(server_texture); */ + ret.c = glIsTexture(server_texture); + } else { ret.c = 0; + } break; } - case glFramebufferTexture1DEXT_func: { GET_EXT_PTR(void, glFramebufferTexture1DEXT, @@ -2486,14 +2646,14 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args unsigned int client_texture = args[3]; unsigned int server_texture = get_server_texture(process, client_texture); - if (server_texture) + if (server_texture) { ptr_func_glFramebufferTexture1DEXT(args[0], args[1], args[2], server_texture, args[4]); + } break; } - case glFramebufferTexture2D_func: - //DEBUGF( "wooooot!\n"); + /* DEBUGF("wooooot!\n"); */ case glFramebufferTexture2DEXT_func: { GET_EXT_PTR(void, glFramebufferTexture2DEXT, @@ -2501,9 +2661,10 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args unsigned int client_texture = args[3]; unsigned int server_texture = get_server_texture(process, client_texture); - if (server_texture) + if (server_texture) { ptr_func_glFramebufferTexture2DEXT(args[0], args[1], args[2], server_texture, args[4]); + } break; } @@ -2514,10 +2675,11 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args unsigned int client_texture = args[3]; unsigned int server_texture = get_server_texture(process, client_texture); - if (server_texture) + if (server_texture) { ptr_func_glFramebufferTexture3DEXT(args[0], args[1], args[2], server_texture, args[4], args[5]); + } break; } /* End of texture stuff */ @@ -2528,10 +2690,11 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args unsigned int client_list = args[0]; unsigned int server_list = get_server_list(process, client_list); - if (server_list) + if (server_list) { ret.c = glIsList(server_list); - else + } else { ret.c = 0; + } break; } @@ -2545,8 +2708,9 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args get_server_list(process, first_client); for (i = 0; i < n; i++) { if (get_server_list(process, first_client + i) != - first_server + i) + first_server + i) { break; + } } if (i == n) { glDeleteLists(first_server, n); @@ -2564,7 +2728,6 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args first_client, n); break; } - case glGenLists_fake_func: { int i; @@ -2582,7 +2745,6 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args } break; } - case glNewList_func: { unsigned int client_list = args[0]; @@ -2598,7 +2760,6 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args glNewList(server_list, mode); break; } - case glCallList_func: { unsigned int client_list = args[0]; @@ -2607,13 +2768,12 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args glCallList(server_list); break; } - case glCallLists_func: { int i; int n = args[0]; int type = args[1]; - const GLvoid *lists = (const GLvoid *) args[2]; + const GLvoid *lists = (const GLvoid *)args[2]; int *new_lists = g_malloc(sizeof(int) * n); for (i = 0; i < n; i++) { @@ -2624,8 +2784,6 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args g_free(new_lists); break; } - - /* End of list stuff */ /* Begin of buffer stuff */ @@ -2644,7 +2802,6 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args } break; } - case glGenBuffersARB_fake_func: { GET_EXT_PTR(void, glGenBuffersARB, (int, unsigned int *)); @@ -2666,14 +2823,12 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args g_free(serverTabBuffers); break; } - - case glDeleteBuffersARB_func: { GET_EXT_PTR(void, glDeleteBuffersARB, (int, int *)); int i; int n = args[0]; - unsigned int *clientTabBuffers = (unsigned int *) args[1]; + unsigned int *clientTabBuffers = (unsigned int *)args[1]; delete_range(process->current_state->bufferAllocator, n, clientTabBuffers); @@ -2691,22 +2846,20 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args g_free(serverTabBuffers); break; } - case glIsBufferARB_func: { GET_EXT_PTR(int, glIsBufferARB, (int)); unsigned int client_buffer = args[0]; unsigned int server_buffer = get_server_buffer(process, client_buffer); - if (server_buffer) + if (server_buffer) { ret.i = ptr_func_glIsBufferARB(server_buffer); - else + } else { ret.i = 0; + } break; } - /* End of buffer stuff */ - case glShaderSourceARB_fake_func: { GET_EXT_PTR(void, glShaderSourceARB, (int, int, char **, void *)); @@ -2714,10 +2867,10 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args int i; int acc_length = 0; GLcharARB **tab_prog = g_malloc(size * sizeof(GLcharARB *)); - int *tab_length = (int *) args[3]; + int *tab_length = (int *)args[3]; for (i = 0; i < size; i++) { - tab_prog[i] = ((GLcharARB *) args[2]) + acc_length; + tab_prog[i] = ((GLcharARB *)args[2]) + acc_length; acc_length += tab_length[i]; } ptr_func_glShaderSourceARB(args[0], args[1], tab_prog, @@ -2725,50 +2878,51 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args g_free(tab_prog); break; } - case glShaderSource_fake_func: - { - GET_EXT_PTR(void, glShaderSource, (int, int, char **, void *)); - int size = args[1]; - int i; - int acc_length = 0; - GLcharARB **tab_prog = g_malloc(size * sizeof(GLcharARB *)); - int *tab_length = (int *) args[3]; - - char **tab_prog_new; - GLint *tab_length_new; + { + GET_EXT_PTR(void, glShaderSource, (int, int, char **, void *)); + int size = args[1]; + int i; + int acc_length = 0; + GLcharARB **tab_prog = g_malloc(size * sizeof(GLcharARB *)); + int *tab_length = (int *)args[3]; - tab_prog_new = malloc(args[1]* sizeof(char*)); - tab_length_new = malloc(args[1]* sizeof(GLint)); + char **tab_prog_new; + GLint *tab_length_new; - memset(tab_prog_new, 0, args[1] * sizeof(char*)); - memset(tab_length_new, 0, args[1] * sizeof(GLint)); + tab_prog_new = malloc(args[1] * sizeof(char *)); + tab_length_new = malloc(args[1] * sizeof(GLint)); + memset(tab_prog_new, 0, args[1] * sizeof(char *)); + memset(tab_length_new, 0, args[1] * sizeof(GLint)); - for (i = 0; i < size; i++) { - tab_prog[i] = ((GLcharARB *) args[2]) + acc_length; - acc_length += tab_length[i]; - } - shadersrc_gles_to_gl(args[1], (const char **)tab_prog, tab_prog_new, tab_length, tab_length_new); + for (i = 0; i < size; i++) { + tab_prog[i] = ((GLcharARB *) args[2]) + acc_length; + acc_length += tab_length[i]; + } - if (!tab_prog_new || !tab_length_new) - break; + shadersrc_gles_to_gl(args[1], (const char **)tab_prog, + tab_prog_new, tab_length, tab_length_new); - ptr_func_glShaderSource(args[0], args[1], tab_prog_new, tab_length_new); + if (!tab_prog_new || !tab_length_new) { + break; + } - for (i = 0; i < args[1]; i++) { - free(tab_prog_new[i]); - } + ptr_func_glShaderSource(args[0], args[1], + tab_prog_new, tab_length_new); - free(tab_prog_new); - free(tab_length_new); + for (i = 0; i < args[1]; i++) { + free(tab_prog_new[i]); + } - free(tab_prog); + free(tab_prog_new); + free(tab_length_new); - break; - } + free(tab_prog); + break; + } case glVertexPointer_fake_func: { int offset = args[0]; @@ -2784,14 +2938,13 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args g_realloc(process->current_state->vertexPointer, process->current_state->vertexPointerSize); memcpy(process->current_state->vertexPointer + offset, - (void *) args[5], bytes_size); - /* DEBUGF( "glVertexPointer_fake_func size=%d, type=%d, + (void *)args[5], bytes_size); + /* DEBUGF("glVertexPointer_fake_func size=%d, type=%d, * stride=%d, byte_size=%d\n", size, type, stride, bytes_size); */ glVertexPointer(size, type, stride, process->current_state->vertexPointer); break; } - case glNormalPointer_fake_func: { int offset = args[0]; @@ -2806,14 +2959,13 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args g_realloc(process->current_state->normalPointer, process->current_state->normalPointerSize); memcpy(process->current_state->normalPointer + offset, - (void *) args[4], bytes_size); - // DEBUGF( "glNormalPointer_fake_func type=%d, stride=%d, - // byte_size=%d\n", type, stride, bytes_size); + (void *)args[4], bytes_size); + /* DEBUGF("glNormalPointer_fake_func type=%d, stride=%d, + byte_size=%d\n", type, stride, bytes_size); */ glNormalPointer(type, stride, process->current_state->normalPointer); break; } - case glIndexPointer_fake_func: { int offset = args[0]; @@ -2828,14 +2980,13 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args g_realloc(process->current_state->indexPointer, process->current_state->indexPointerSize); memcpy(process->current_state->indexPointer + offset, - (void *) args[4], bytes_size); - // DEBUGF( "glIndexPointer_fake_func type=%d, stride=%d, - // byte_size=%d\n", type, stride, bytes_size); + (void *)args[4], bytes_size); + /* DEBUGF("glIndexPointer_fake_func type=%d, stride=%d, + byte_size=%d\n", type, stride, bytes_size); */ glIndexPointer(type, stride, process->current_state->indexPointer); break; } - case glEdgeFlagPointer_fake_func: { int offset = args[0]; @@ -2849,14 +3000,13 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args g_realloc(process->current_state->edgeFlagPointer, process->current_state->edgeFlagPointerSize); memcpy(process->current_state->edgeFlagPointer + offset, - (void *) args[3], bytes_size); - // DEBUGF( "glEdgeFlagPointer_fake_func stride = %d, - // bytes_size=%d\n", stride, bytes_size); + (void *)args[3], bytes_size); + /* DEBUGF("glEdgeFlagPointer_fake_func stride=%d, bytes_size=%d\n", + stride, bytes_size); */ glEdgeFlagPointer(stride, process->current_state->edgeFlagPointer); break; } - case glVertexAttribPointerARB_fake_func: { GET_EXT_PTR(void, glVertexAttribPointerARB, @@ -2877,14 +3027,13 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args process->current_state-> vertexAttribPointerSize[index]); memcpy(process->current_state->vertexAttribPointer[index] + - offset, (void *) args[7], bytes_size); + offset, (void *)args[7], bytes_size); ptr_func_glVertexAttribPointerARB(index, size, type, normalized, stride, process->current_state-> vertexAttribPointer[index]); break; } - case glVertexAttribPointerNV_fake_func: { GET_EXT_PTR(void, glVertexAttribPointerNV, @@ -2904,13 +3053,12 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args process->current_state-> vertexAttribPointerNVSize[index]); memcpy(process->current_state->vertexAttribPointerNV[index] + - offset, (void *) args[6], bytes_size); + offset, (void *)args[6], bytes_size); ptr_func_glVertexAttribPointerNV(index, size, type, stride, process->current_state-> vertexAttribPointerNV[index]); break; } - case glColorPointer_fake_func: { int offset = args[0]; @@ -2926,15 +3074,14 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args g_realloc(process->current_state->colorPointer, process->current_state->colorPointerSize); memcpy(process->current_state->colorPointer + offset, - (void *) args[5], bytes_size); - // DEBUGF( "glColorPointer_fake_func bytes_size = %d\n", - // bytes_size); + (void *)args[5], bytes_size); + /* DEBUGF("glColorPointer_fake_func bytes_size = %d\n", + bytes_size); */ glColorPointer(size, type, stride, process->current_state->colorPointer); break; } - case glSecondaryColorPointer_fake_func: { GET_EXT_PTR(void, glSecondaryColorPointer, @@ -2952,16 +3099,15 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args g_realloc(process->current_state->secondaryColorPointer, process->current_state->secondaryColorPointerSize); memcpy(process->current_state->secondaryColorPointer + offset, - (void *) args[5], bytes_size); - // DEBUGF( "glSecondaryColorPointer_fake_func bytes_size - // = %d\n", bytes_size); + (void *)args[5], bytes_size); + /* DEBUGF("glSecondaryColorPointer_fake_func bytes_size = %d\n", + bytes_size); */ ptr_func_glSecondaryColorPointer(size, type, stride, process->current_state-> secondaryColorPointer); break; } - case glPushClientAttrib_func: { int mask = args[0]; @@ -2984,7 +3130,6 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args glPushClientAttrib(mask); break; } - case glPopClientAttrib_func: { if (process->current_state->clientStateSp > 0) { @@ -3002,7 +3147,6 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args glPopClientAttrib(); break; } - case glClientActiveTexture_func: case glClientActiveTextureARB_func: { @@ -3013,7 +3157,6 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args do_glClientActiveTextureARB(activeTexture); break; } - case glTexCoordPointer_fake_func: { int offset = args[0]; @@ -3030,9 +3173,10 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args g_realloc(process->current_state->texCoordPointer[index], process->current_state->texCoordPointerSize[index]); memcpy(process->current_state->texCoordPointer[index] + offset, - (void *) args[6], bytes_size); - /* DEBUGF( "glTexCoordPointer_fake_func size=%d, type=%d, - * stride=%d, byte_size=%d\n", size, type, stride, bytes_size); */ + (void *)args[6], bytes_size); + /* DEBUGF("glTexCoordPointer_fake_func size=%d, type=%d," + " stride=%d, byte_size=%d\n", + size, type, stride, bytes_size); */ do_glClientActiveTextureARB(GL_TEXTURE0_ARB + index); glTexCoordPointer(size, type, stride, process->current_state->texCoordPointer[index]); @@ -3041,7 +3185,6 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args activeTextureIndex); break; } - case glWeightPointerARB_fake_func: { GET_EXT_PTR(void, glWeightPointerARB, (int, int, int, void *)); @@ -3058,8 +3201,8 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args g_realloc(process->current_state->weightPointer, process->current_state->weightPointerSize); memcpy(process->current_state->weightPointer + offset, - (void *) args[5], bytes_size); - /* DEBUGF( "glWeightPointerARB_fake_func size=%d, + (void *)args[5], bytes_size); + /* DEBUGF("glWeightPointerARB_fake_func size=%d, * type=%d, stride=%d, byte_size=%d\n", size, type, stride, * bytes_size); */ ptr_func_glWeightPointerARB(size, type, stride, @@ -3067,7 +3210,6 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args weightPointer); break; } - case glMatrixIndexPointerARB_fake_func: { GET_EXT_PTR(void, glMatrixIndexPointerARB, @@ -3085,8 +3227,8 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args g_realloc(process->current_state->matrixIndexPointer, process->current_state->matrixIndexPointerSize); memcpy(process->current_state->matrixIndexPointer + offset, - (void *) args[5], bytes_size); - /* DEBUGF( "glMatrixIndexPointerARB_fake_func size=%d, + (void *)args[5], bytes_size); + /* DEBUGF("glMatrixIndexPointerARB_fake_func size=%d, * type=%d, stride=%d, byte_size=%d\n", size, type, stride, * bytes_size); */ ptr_func_glMatrixIndexPointerARB(size, type, stride, @@ -3094,7 +3236,6 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args matrixIndexPointer); break; } - case glFogCoordPointer_fake_func: { GET_EXT_PTR(void, glFogCoordPointer, (int, int, void *)); @@ -3110,15 +3251,14 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args g_realloc(process->current_state->fogCoordPointer, process->current_state->fogCoordPointerSize); memcpy(process->current_state->fogCoordPointer + offset, - (void *) args[4], bytes_size); - // DEBUGF( "glFogCoordPointer_fake_func type=%d, - // stride=%d, byte_size=%d\n", type, stride, bytes_size); + (void *)args[4], bytes_size); + /* DEBUGF("glFogCoordPointer_fake_func type=%d, + stride=%d, byte_size=%d\n", type, stride, bytes_size); */ ptr_func_glFogCoordPointer(type, stride, process->current_state-> fogCoordPointer); break; } - case glVariantPointerEXT_fake_func: { GET_EXT_PTR(void, glVariantPointerEXT, (int, int, int, void *)); @@ -3135,15 +3275,14 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args g_realloc(process->current_state->variantPointerEXT[id], process->current_state->variantPointerEXTSize[id]); memcpy(process->current_state->variantPointerEXT[id] + offset, - (void *) args[5], bytes_size); - // DEBUGF( "glVariantPointerEXT_fake_func[%d] type=%d, - // stride=%d, byte_size=%d\n", id, type, stride, bytes_size); + (void *)args[5], bytes_size); + /* DEBUGF("glVariantPointerEXT_fake_func[%d] type=%d, + stride=%d, byte_size=%d\n", id, type, stride, bytes_size); */ ptr_func_glVariantPointerEXT(id, type, stride, process->current_state-> variantPointerEXT[id]); break; } - case glInterleavedArrays_fake_func: { GET_EXT_PTR(void, glInterleavedArrays, (int, int, void *)); @@ -3159,15 +3298,14 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args g_realloc(process->current_state->interleavedArrays, process->current_state->interleavedArraysSize); memcpy(process->current_state->interleavedArrays + offset, - (void *) args[4], bytes_size); - // DEBUGF( "glInterleavedArrays_fake_func format=%d, - // stride=%d, byte_size=%d\n", format, stride, bytes_size); + (void *)args[4], bytes_size); + /* DEBUGF("glInterleavedArrays_fake_func format=%d, + stride=%d, byte_size=%d\n", format, stride, bytes_size); */ ptr_func_glInterleavedArrays(format, stride, process->current_state-> interleavedArrays); break; } - case glElementPointerATI_fake_func: { GET_EXT_PTR(void, glElementPointerATI, (int, void *)); @@ -3179,15 +3317,14 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args g_realloc(process->current_state->elementPointerATI, process->current_state->elementPointerATISize); memcpy(process->current_state->elementPointerATI, - (void *) args[2], bytes_size); - // DEBUGF( "glElementPointerATI_fake_func type=%d, - // byte_size=%d\n", type, bytes_size); + (void *)args[2], bytes_size); + /* DEBUGF("glElementPointerATI_fake_func type=%d, + byte_size=%d\n", type, bytes_size); */ ptr_func_glElementPointerATI(type, process->current_state-> elementPointerATI); break; } - case glTexCoordPointer01_fake_func: { int size = args[0]; @@ -3200,8 +3337,8 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args g_realloc(process->current_state->texCoordPointer[0], bytes_size); memcpy(process->current_state->texCoordPointer[0], - (void *) args[4], bytes_size); - /* DEBUGF( "glTexCoordPointer01_fake_func size=%d, + (void *)args[4], bytes_size); + /* DEBUGF("glTexCoordPointer01_fake_func size=%d, * type=%d, stride=%d, byte_size=%d\n", size, type, stride, * bytes_size); */ do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 0); @@ -3215,7 +3352,6 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args activeTextureIndex); break; } - case glTexCoordPointer012_fake_func: { int size = args[0]; @@ -3228,8 +3364,8 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args g_realloc(process->current_state->texCoordPointer[0], bytes_size); memcpy(process->current_state->texCoordPointer[0], - (void *) args[4], bytes_size); - /* DEBUGF( "glTexCoordPointer012_fake_func size=%d, + (void *)args[4], bytes_size); + /* DEBUGF("glTexCoordPointer012_fake_func size=%d, * type=%d, stride=%d, byte_size=%d\n", size, type, stride, * bytes_size); */ do_glClientActiveTextureARB(GL_TEXTURE0_ARB + 0); @@ -3246,7 +3382,6 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args activeTextureIndex); break; } - case glVertexAndNormalPointer_fake_func: { int vertexPointerSize = args[0]; @@ -3255,7 +3390,7 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args int normalPointerType = args[3]; int normalPointerStride = args[4]; int bytes_size = args[5]; - void *ptr = (void *) args[6]; + void *ptr = (void *)args[6]; process->current_state->vertexPointerSize = bytes_size; process->current_state->vertexPointer = @@ -3268,7 +3403,6 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args process->current_state->vertexPointer); break; } - case glVertexNormalPointerInterlaced_fake_func: { int i = 0; @@ -3279,7 +3413,7 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args int normalPointerOffset = args[i++]; int normalPointerType = args[i++]; int bytes_size = args[i++]; - void *ptr = (void *) args[i++]; + void *ptr = (void *)args[i++]; process->current_state->vertexPointerSize = MAX(process->current_state->vertexPointerSize, @@ -3296,35 +3430,34 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args normalPointerOffset); break; } - case glTuxRacerDrawElements_fake_func: { int mode = args[0]; int count = args[1]; int isColorEnabled = args[2]; - void *ptr = (void *) args[3]; + void *ptr = (void *)args[3]; int stride = 6 * sizeof(float) + ((isColorEnabled) ? 4 * sizeof(unsigned char) : 0); glVertexPointer(3, GL_FLOAT, stride, ptr); glNormalPointer(GL_FLOAT, stride, ptr + 3 * sizeof(float)); - if (isColorEnabled) + if (isColorEnabled) { glColorPointer(4, GL_UNSIGNED_BYTE, stride, ptr + 6 * sizeof(float)); + } glDrawArrays(mode, 0, count); -#ifdef __APPLE__ //only for mac - { - int prev_fbo; - glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &prev_fbo); - if ( prev_fbo != 0 ) - glFlush(); - } +#ifdef __APPLE__ + { + int prev_fbo; + glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &prev_fbo); + if (prev_fbo != 0) { + glFlush(); + } + } #endif - break; } - case glVertexNormalColorPointerInterlaced_fake_func: { int i = 0; @@ -3338,7 +3471,7 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args int colorPointerSize = args[i++]; int colorPointerType = args[i++]; int bytes_size = args[i++]; - void *ptr = (void *) args[i++]; + void *ptr = (void *)args[i++]; process->current_state->vertexPointerSize = MAX(process->current_state->vertexPointerSize, @@ -3358,7 +3491,6 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args colorPointerOffset); break; } - case glVertexColorTexCoord0PointerInterlaced_fake_func: { int i = 0; @@ -3373,7 +3505,7 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args int texCoord0PointerSize = args[i++]; int texCoord0PointerType = args[i++]; int bytes_size = args[i++]; - void *ptr = (void *) args[i++]; + void *ptr = (void *)args[i++]; process->current_state->vertexPointerSize = MAX(process->current_state->vertexPointerSize, @@ -3398,7 +3530,6 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args activeTextureIndex); break; } - case glVertexNormalTexCoord0PointerInterlaced_fake_func: { int i = 0; @@ -3412,7 +3543,7 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args int texCoord0PointerSize = args[i++]; int texCoord0PointerType = args[i++]; int bytes_size = args[i++]; - void *ptr = (void *) args[i++]; + void *ptr = (void *)args[i++]; process->current_state->vertexPointerSize = MAX(process->current_state->vertexPointerSize, @@ -3437,7 +3568,6 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args activeTextureIndex); break; } - case glVertexNormalTexCoord01PointerInterlaced_fake_func: { int i = 0; @@ -3454,7 +3584,7 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args int texCoord1PointerSize = args[i++]; int texCoord1PointerType = args[i++]; int bytes_size = args[i++]; - void *ptr = (void *) args[i++]; + void *ptr = (void *)args[i++]; process->current_state->vertexPointerSize = MAX(process->current_state->vertexPointerSize, @@ -3484,7 +3614,6 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args activeTextureIndex); break; } - case glVertexNormalTexCoord012PointerInterlaced_fake_func: { int i = 0; @@ -3504,7 +3633,7 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args int texCoord2PointerSize = args[i++]; int texCoord2PointerType = args[i++]; int bytes_size = args[i++]; - void *ptr = (void *) args[i++]; + void *ptr = (void *)args[i++]; process->current_state->vertexPointerSize = MAX(process->current_state->vertexPointerSize, @@ -3539,7 +3668,6 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args activeTextureIndex); break; } - case glVertexNormalColorTexCoord0PointerInterlaced_fake_func: { int i = 0; @@ -3556,7 +3684,7 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args int texCoord0PointerSize = args[i++]; int texCoord0PointerType = args[i++]; int bytes_size = args[i++]; - void *ptr = (void *) args[i++]; + void *ptr = (void *)args[i++]; process->current_state->vertexPointerSize = MAX(process->current_state->vertexPointerSize, @@ -3584,7 +3712,6 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args activeTextureIndex); break; } - case glVertexNormalColorTexCoord01PointerInterlaced_fake_func: { int i = 0; @@ -3604,7 +3731,7 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args int texCoord1PointerSize = args[i++]; int texCoord1PointerType = args[i++]; int bytes_size = args[i++]; - void *ptr = (void *) args[i++]; + void *ptr = (void *)args[i++]; process->current_state->vertexPointerSize = MAX(process->current_state->vertexPointerSize, @@ -3637,7 +3764,6 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args activeTextureIndex); break; } - case glVertexNormalColorTexCoord012PointerInterlaced_fake_func: { int i = 0; @@ -3660,7 +3786,7 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args int texCoord2PointerSize = args[i++]; int texCoord2PointerType = args[i++]; int bytes_size = args[i++]; - void *ptr = (void *) args[i++]; + void *ptr = (void *)args[i++]; process->current_state->vertexPointerSize = MAX(process->current_state->vertexPointerSize, @@ -3698,108 +3824,96 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args activeTextureIndex); break; } - case _glVertexPointer_buffer_func: { - glVertexPointer(args[0], args[1], args[2], (void *) args[3]); + glVertexPointer(args[0], args[1], args[2], (void *)args[3]); break; } - case _glNormalPointer_buffer_func: { - glNormalPointer(args[0], args[1], (void *) args[2]); + glNormalPointer(args[0], args[1], (void *)args[2]); break; } - case _glColorPointer_buffer_func: { - glColorPointer(args[0], args[1], args[2], (void *) args[3]); + glColorPointer(args[0], args[1], args[2], (void *)args[3]); break; } - case _glSecondaryColorPointer_buffer_func: { GET_EXT_PTR(void, glSecondaryColorPointer, (int, int, int, void *)); ptr_func_glSecondaryColorPointer(args[0], args[1], args[2], - (void *) args[3]); + (void *)args[3]); break; } - case _glIndexPointer_buffer_func: { - glIndexPointer(args[0], args[1], (void *) args[2]); + glIndexPointer(args[0], args[1], (void *)args[2]); break; } - case _glTexCoordPointer_buffer_func: { - glTexCoordPointer(args[0], args[1], args[2], (void *) args[3]); + glTexCoordPointer(args[0], args[1], args[2], (void *)args[3]); break; } - case _glEdgeFlagPointer_buffer_func: { - glEdgeFlagPointer(args[0], (void *) args[1]); + glEdgeFlagPointer(args[0], (void *)args[1]); break; } - case _glVertexAttribPointerARB_buffer_func: { GET_EXT_PTR(void, glVertexAttribPointerARB, (int, int, int, int, int, void *)); ptr_func_glVertexAttribPointerARB(args[0], args[1], args[2], args[3], args[4], - (void *) args[5]); + (void *)args[5]); break; } - case _glWeightPointerARB_buffer_func: { GET_EXT_PTR(void, glWeightPointerARB, (int, int, int, void *)); ptr_func_glWeightPointerARB(args[0], args[1], args[2], - (void *) args[3]); + (void *)args[3]); break; } - case _glMatrixIndexPointerARB_buffer_func: { GET_EXT_PTR(void, glMatrixIndexPointerARB, (int, int, int, void *)); ptr_func_glMatrixIndexPointerARB(args[0], args[1], args[2], - (void *) args[3]); + (void *)args[3]); break; } - case _glFogCoordPointer_buffer_func: { GET_EXT_PTR(void, glFogCoordPointer, (int, int, void *)); - ptr_func_glFogCoordPointer(args[0], args[1], (void *) args[2]); + ptr_func_glFogCoordPointer(args[0], args[1], (void *)args[2]); break; } - case _glVariantPointerEXT_buffer_func: { GET_EXT_PTR(void, glVariantPointerEXT, (int, int, int, void *)); ptr_func_glVariantPointerEXT(args[0], args[1], args[2], - (void *) args[3]); + (void *)args[3]); break; } - case _glDrawElements_buffer_func: { - glDrawElements(args[0], args[1], args[2], (void *) args[3]); - -#ifdef __APPLE__ //only for mac - { - int prev_fbo; - glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &prev_fbo); - if ( prev_fbo != 0 ) - glFlush(); - } + glDrawElements(args[0], args[1], args[2], (void *)args[3]); + +#ifdef __APPLE__ + { + int prev_fbo; + glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &prev_fbo); + if (prev_fbo != 0) { + glFlush(); + } + } #endif break; @@ -3808,7 +3922,7 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args case _glDrawRangeElements_buffer_func: { glDrawRangeElements(args[0], args[1], args[2], args[3], args[4], - (void *) args[5]); + (void *)args[5]); break; } #endif @@ -3816,76 +3930,77 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args { GET_EXT_PTR(void, glMultiDrawElements, (int, int *, int, void **, int)); - ptr_func_glMultiDrawElements(args[0], (int *) args[1], args[2], - (void **) args[3], args[4]); -#ifdef __APPLE__ //only for mac - { - int prev_fbo; - glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &prev_fbo); - if ( prev_fbo != 0 ) - glFlush(); - } + ptr_func_glMultiDrawElements(args[0], (int *)args[1], args[2], + (void **)args[3], args[4]); +#ifdef __APPLE__ + { + int prev_fbo; + glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &prev_fbo); + if (prev_fbo != 0) { + glFlush(); + } + } #endif - - break; - } -#ifdef __APPLE__ // only for mac - case glDrawArrays_func: - { - int prev_fbo; - glDrawArrays(ARG_TO_UNSIGNED_INT(args[0]), ARG_TO_INT(args[1]), ARG_TO_INT(args[2])); - glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &prev_fbo); - if ( prev_fbo != 0 ) - glFlush(); - break; - } - case glDrawElements_func: - { - int prev_fbo; - glDrawElements(ARG_TO_UNSIGNED_INT(args[0]), ARG_TO_INT(args[1]), ARG_TO_UNSIGNED_INT(args[2]), (const void*)(args[3])); - glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &prev_fbo); - if ( prev_fbo != 0 ) - glFlush(); - break; - } + break; + } +#ifdef __APPLE__ + case glDrawArrays_func: + { + int prev_fbo; + glDrawArrays(ARG_TO_UNSIGNED_INT(args[0]), ARG_TO_INT(args[1]), + ARG_TO_INT(args[2])); + glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &prev_fbo); + if (prev_fbo != 0) { + glFlush(); + } + break; + } + case glDrawElements_func: + { + int prev_fbo; + glDrawElements(ARG_TO_UNSIGNED_INT(args[0]), + ARG_TO_INT(args[1]), + ARG_TO_UNSIGNED_INT(args[2]), + (const void *)(args[3])); + glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &prev_fbo); + if (prev_fbo != 0) { + glFlush(); + } + break; + } #endif - case _glGetError_fake_func: { break; } - case glGetIntegerv_func: { - glGetIntegerv(args[0], (int *) args[1]); + glGetIntegerv(args[0], (int *)args[1]); break; } - case _glReadPixels_pbo_func: { glReadPixels(ARG_TO_INT(args[0]), ARG_TO_INT(args[1]), ARG_TO_INT(args[2]), ARG_TO_INT(args[3]), ARG_TO_UNSIGNED_INT(args[4]), - ARG_TO_UNSIGNED_INT(args[5]), (void *) (args[6])); + ARG_TO_UNSIGNED_INT(args[5]), (void *)(args[6])); break; } - case _glDrawPixels_pbo_func: { glDrawPixels(ARG_TO_INT(args[0]), ARG_TO_INT(args[1]), ARG_TO_UNSIGNED_INT(args[2]), ARG_TO_UNSIGNED_INT(args[3]), - (const void *) (args[4])); + (const void *)(args[4])); break; } - case _glMapBufferARB_fake_func: { GET_EXT_PTR(GLvoid *, glMapBufferARB, (GLenum, GLenum)); GET_EXT_PTR(GLboolean, glUnmapBufferARB, (GLenum)); int target = args[0]; int size = args[1]; - void *dst_ptr = (void *) args[2]; + void *dst_ptr = (void *)args[2]; void *src_ptr = ptr_func_glMapBufferARB(target, GL_READ_ONLY); if (src_ptr) { @@ -3896,25 +4011,24 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args } break; } - case fake_gluBuild2DMipmaps_func: { GET_GLU_PTR(GLint, gluBuild2DMipmaps, (GLenum arg_0, GLint arg_1, GLsizei arg_2, GLsizei arg_3, GLenum arg_4, GLenum arg_5, const GLvoid *arg_6)); - if (ptr_func_gluBuild2DMipmaps == NULL) + if (ptr_func_gluBuild2DMipmaps == NULL) { ptr_func_gluBuild2DMipmaps = mesa_gluBuild2DMipmaps; + } ptr_func_gluBuild2DMipmaps(ARG_TO_UNSIGNED_INT(args[0]), ARG_TO_INT(args[1]), ARG_TO_INT(args[2]), ARG_TO_INT(args[3]), ARG_TO_UNSIGNED_INT(args[4]), ARG_TO_UNSIGNED_INT(args[5]), - (const void *) (args[6])); + (const void *)(args[6])); break; } - case _glSelectBuffer_fake_func: { process->current_state->selectBufferSize = args[0] * 4; @@ -3924,161 +4038,161 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args glSelectBuffer(args[0], process->current_state->selectBufferPtr); break; } - case _glGetSelectBuffer_fake_func: { - void *ptr = (void *) args[0]; + void *ptr = (void *)args[0]; memcpy(ptr, process->current_state->selectBufferPtr, process->current_state->selectBufferSize); break; } - case _glFeedbackBuffer_fake_func: { process->current_state->feedbackBufferSize = args[0] * 4; process->current_state->feedbackBufferPtr = g_realloc(process->current_state->feedbackBufferPtr, process->current_state->feedbackBufferSize); - glFeedbackBuffer((GLsizei)args[0], (GLenum) args[1], + glFeedbackBuffer((GLsizei)args[0], (GLenum)args[1], process->current_state->feedbackBufferPtr); break; } - case _glGetFeedbackBuffer_fake_func: { - void *ptr = (void *) args[0]; + void *ptr = (void *)args[0]; memcpy(ptr, process->current_state->feedbackBufferPtr, process->current_state->feedbackBufferSize); break; } - - /* + /* * case glEnableClientState_func: { if (display_function_call) * DEBUGF( "cap : %s\n", nameArrays[args[0] - * GL_VERTEX_ARRAY]); glEnableClientState(args[0]); break; } - * + * * case glDisableClientState_func: { if (display_function_call) * DEBUGF( "cap : %s\n", nameArrays[args[0] - * GL_VERTEX_ARRAY]); glDisableClientState(args[0]); break; } - * + * * case glClientActiveTexture_func: case * glClientActiveTextureARB_func: { if (display_function_call) * DEBUGF( "client activeTexture %d\n", args[0] - * GL_TEXTURE0_ARB); glClientActiveTextureARB(args[0]); break; } - * + * * case glActiveTextureARB_func: { if (display_function_call) * DEBUGF( "server activeTexture %d\n", args[0] - * GL_TEXTURE0_ARB); glActiveTextureARB(args[0]); break; } - * + * * case glLockArraysEXT_func: break; - * + * * case glUnlockArraysEXT_func: break; - * + * * case glArrayElement_func: { glArrayElement(args[0]); break; } - * + * * case glDrawArrays_func: { glDrawArrays(args[0],args[1],args[2]); * break; } - * + * * case glDrawElements_func: { * glDrawElements(args[0],args[1],args[2],(void*)args[3]); break; } - * + * * case glDrawRangeElements_func: { - * glDrawRangeElements(args[0],args[1],args[2],args[3],args[4],(void*)args[5]); + * glDrawRangeElements(args[0],args[1],args[2], + args[3],args[4],(void *)args[5]); * break; } */ - case glGetError_func: { ret.i = glGetError(); break; } - case glNewObjectBufferATI_func: { GET_EXT_PTR(int, glNewObjectBufferATI, (int, void *, int)); ret.i = ptr_func_glNewObjectBufferATI(args[0], - (void *) args[1], args[2]); + (void *)args[1], args[2]); break; } - case glClear_func: glClear((GLbitfield)args[0]); break; #if 0 /* HACK workaround for an unexplainable issue */ - if (args[0] & GL_COLOR_BUFFER_BIT) + if (args[0] & GL_COLOR_BUFFER_BIT) { glClear(GL_COLOR_BUFFER_BIT); - if (args[0] & GL_STENCIL_BUFFER_BIT) + } + if (args[0] & GL_STENCIL_BUFFER_BIT) { glClear(GL_STENCIL_BUFFER_BIT); - if (args[0] & GL_DEPTH_BUFFER_BIT) + } + if (args[0] & GL_DEPTH_BUFFER_BIT) { glClear(GL_DEPTH_BUFFER_BIT); - if (args[0] & GL_ACCUM_BUFFER_BIT) + } + if (args[0] & GL_ACCUM_BUFFER_BIT) { glClear(GL_ACCUM_BUFFER_BIT); + } break; #endif #ifdef _WIN32 - /* workaround for bug T_SDK-128. If GL_UNPACK_ROW_LENGTH==0, GL driver - * should calculate it for glTexSubImage2D according to width parameter and - * GL_UNPACK_ALIGNMENT. But on windows, some vender's driver like nvidia, - * don't follow it. So we need do it for the driver, and probably remove - * this hack in future if driver get fixed. - */ - case glTexSubImage2D_func: - { - int origin_row_length, alignment, width; - - if (args[6] == GL_ALPHA) { - width = args[4]; - glGetIntegerv(GL_UNPACK_ALIGNMENT, &alignment); - glGetIntegerv(GL_UNPACK_ROW_LENGTH, &origin_row_length); - - if (width%alignment != 0) { - width = (width/alignment + 1) * alignment; - } - - glPixelStorei(GL_UNPACK_ROW_LENGTH, width); - } - - glTexSubImage2D(ARG_TO_UNSIGNED_INT(args[0]), ARG_TO_INT(args[1]), - ARG_TO_INT(args[2]), ARG_TO_INT(args[3]), - ARG_TO_INT(args[4]), ARG_TO_INT(args[5]), - ARG_TO_UNSIGNED_INT(args[6]), - ARG_TO_UNSIGNED_INT(args[7]), (const void*)(args[8])); - - if (args[6] == GL_ALPHA) - glPixelStorei(GL_UNPACK_ROW_LENGTH, origin_row_length); - - break; - } + /* workaround for bug T_SDK-128. If GL_UNPACK_ROW_LENGTH==0, GL driver + * should calculate it for glTexSubImage2D according to width parameter and + * GL_UNPACK_ALIGNMENT. But on windows, some vender's driver like nvidia, + * don't follow it. So we need do it for the driver, and probably remove + * this hack in future if driver get fixed. + */ + case glTexSubImage2D_func: + { + int origin_row_length, alignment, width; + + if (args[6] == GL_ALPHA) { + width = args[4]; + glGetIntegerv(GL_UNPACK_ALIGNMENT, &alignment); + glGetIntegerv(GL_UNPACK_ROW_LENGTH, &origin_row_length); + + if (width % alignment != 0) { + width = (width / alignment + 1) * alignment; + } + + glPixelStorei(GL_UNPACK_ROW_LENGTH, width); + } + + glTexSubImage2D(ARG_TO_UNSIGNED_INT(args[0]), ARG_TO_INT(args[1]), + ARG_TO_INT(args[2]), ARG_TO_INT(args[3]), + ARG_TO_INT(args[4]), ARG_TO_INT(args[5]), + ARG_TO_UNSIGNED_INT(args[6]), + ARG_TO_UNSIGNED_INT(args[7]), (const void *)(args[8])); + + if (args[6] == GL_ALPHA) { + glPixelStorei(GL_UNPACK_ROW_LENGTH, origin_row_length); + } + + break; + } #endif #ifdef __APPLE__ - case glTexSubImage2D_func: - { - - glTexSubImage2D(ARG_TO_UNSIGNED_INT(args[0]), ARG_TO_INT(args[1]), - ARG_TO_INT(args[2]), ARG_TO_INT(args[3]), - ARG_TO_INT(args[4]), ARG_TO_INT(args[5]), - ARG_TO_UNSIGNED_INT(args[6]), ARG_TO_UNSIGNED_INT(args[7]), - (const void*)(args[8])); - - if ( ARG_TO_UNSIGNED_INT(args[0]) == GL_TEXTURE_2D && - ARG_TO_INT(args[1]) == 0 && - ARG_TO_UNSIGNED_INT(args[6]) == GL_RGBA && - ARG_TO_UNSIGNED_INT(args[7]) == GL_UNSIGNED_BYTE ) - mac_dump_texture(); - else - fprintf(stderr, "!!! Probable screen crash, no work around as glTexSubImage2d parameters do not match!\n"); - - break; - } -#endif + case glTexSubImage2D_func: + { + + glTexSubImage2D(ARG_TO_UNSIGNED_INT(args[0]), ARG_TO_INT(args[1]), + ARG_TO_INT(args[2]), ARG_TO_INT(args[3]), + ARG_TO_INT(args[4]), ARG_TO_INT(args[5]), + ARG_TO_UNSIGNED_INT(args[6]), ARG_TO_UNSIGNED_INT(args[7]), + (const void *)(args[8])); + + if (ARG_TO_UNSIGNED_INT(args[0]) == GL_TEXTURE_2D && + ARG_TO_INT(args[1]) == 0 && + ARG_TO_UNSIGNED_INT(args[6]) == GL_RGBA && + ARG_TO_UNSIGNED_INT(args[7]) == GL_UNSIGNED_BYTE) { + mac_dump_texture(); + } else { + fprintf(stderr, "!!! Probable screen crash, no work around " + "as glTexSubImage2d parameters do not match!\n"); + } + break; + } +#endif default: - execute_func(func_number, (void**)args, &ret); + execute_func(func_number, (void **)args, &ret); break; } @@ -4097,14 +4211,15 @@ int do_function_call(ProcessState *process, int func_number, unsigned long *args } default: - DEBUGF( "unexpected ret type : %d\n", ret_type); + DEBUGF("unexpected ret type : %d\n", ret_type); exit(-1); break; } - if (display_function_call) - DEBUGF( "[%d]< %s\n", process->p.process_id, + if (display_function_call) { + DEBUGF("[%d]< %s\n", process->p.process_id, tab_opengl_calls_name[func_number]); + } return ret.i; } diff --git a/tizen/src/hw/parse_gl_h.c b/tizen/src/hw/parse_gl_h.c index f1b1b65447..78fb30b445 100644 --- a/tizen/src/hw/parse_gl_h.c +++ b/tizen/src/hw/parse_gl_h.c @@ -1,6 +1,6 @@ /* * Parse gl.h et glx.h to auto-generate source code - * + * * Copyright (c) 2006,2007 Even Rouault * * Permission is hereby granted, free of charge, to any person obtaining a copy @@ -28,10 +28,10 @@ #include #include -#define GL_INCLUDE_PATH "../tizen/src/hw/" +#define GL_INCLUDE_PATH "../tizen/src/hw/" -int isExtByName(const char* name) +int isExtByName(const char *name) { return (strstr(name, "ARB") != NULL) || (strstr(name, "IBM") != NULL) || @@ -44,24 +44,26 @@ int isExtByName(const char* name) (strstr(name, "SGI") != NULL); } -char* get_arg_type(char* s) +char *get_arg_type(char *s) { - while(*s == ' ' || *s == '\t') s++; - char* n = s; - char* c = strstr(n, "const"); - if (c) + while (*s == ' ' || *s == '\t') { + s++; + } + char *n = s; + char *c = strstr(n, "const"); + if (c) { n += 6; - - char* t = strstr(n, " "); - if (t) - { - if (t[1] == '*') + } + + char *t = strstr(n, " "); + if (t) { + if (t[1] == '*') { t += 2; + } t[0] = 0; - char* ori = t; + char *ori = t; t = strstr(t+1, "["); - if (t) - { + if (t) { memmove(ori, t, strlen(t)); strstr(ori, "]")[1] = 0; } @@ -69,149 +71,141 @@ char* get_arg_type(char* s) return strdup(s); } -typedef struct -{ - char* type; - char* name; +typedef struct { + char *type; + char *name; int nargs; - char** args; + char **args; int ok; int just_for_server_side; int has_out_parameters; int isExt; } FuncDesc; -int isExt(FuncDesc* func) +int isExt(FuncDesc *func) { return func->isExt; } -char* get_type_string(char* type) +char *get_type_string(char *type) { - if (strstr(type, "[16]")) - { - if (strstr(type, "float")) - return ("TYPE_16FLOAT"); - else if (strstr(type, "double")) - return ("TYPE_16DOUBLE"); - else - { + if (strstr(type, "[16]")) { + if (strstr(type, "float")) { + return "TYPE_16FLOAT"; + } else if (strstr(type, "double")) { + return "TYPE_16DOUBLE"; + } else { printf("inconnu %s\n", type); exit(-1); } - } - else if (strstr(type, "[128]") && strstr(type, "GLubyte")) + } else if (strstr(type, "[128]") && strstr(type, "GLubyte")) { return strstr(type, "const") ? "TYPE_128UCHAR" : "TYPE_OUT_128UCHAR"; - else if (strstr(type, "const GLvoid *")) + } else if (strstr(type, "const GLvoid *")) { return "TYPE_ARRAY_VOID"; - else if (strstr(type, "const GLchar *") || - strstr(type, "const GLcharARB *")) + } else if (strstr(type, "const GLchar *") || + strstr(type, "const GLcharARB *")) { return "TYPE_NULL_TERMINATED_STRING"; - else if (strstr(type, "const GLbyte *")) + } else if (strstr(type, "const GLbyte *")) { return "TYPE_ARRAY_SIGNED_CHAR"; - else if (strstr(type, "const GLubyte *")) + } else if (strstr(type, "const GLubyte *")) { return "TYPE_ARRAY_UNSIGNED_CHAR"; - else if (strstr(type, "const GLshort *")) + } else if (strstr(type, "const GLshort *")) { return "TYPE_ARRAY_SHORT"; - else if (strstr(type, "const GLushort *") || - strstr(type, "const GLhalfNV *")) + } else if (strstr(type, "const GLushort *") || + strstr(type, "const GLhalfNV *")) { return "TYPE_ARRAY_UNSIGNED_SHORT"; - else if (strstr(type, "const GLint *")) + } else if (strstr(type, "const GLint *")) { return "TYPE_ARRAY_INT"; - else if (strstr(type, "const GLuint *") || - strstr(type, "const GLenum *")) + } else if (strstr(type, "const GLuint *") || + strstr(type, "const GLenum *")) { return "TYPE_ARRAY_UNSIGNED_INT"; - else if (strstr(type, "const GLfloat *") || - strstr(type, "const GLclampf *")) + } else if (strstr(type, "const GLfloat *") || + strstr(type, "const GLclampf *")) { return "TYPE_ARRAY_FLOAT"; - else if (strstr(type, "const GLdouble *")) + } else if (strstr(type, "const GLdouble *")) { return "TYPE_ARRAY_DOUBLE"; - else if (strstr(type, "GLvoid *")) + } else if (strstr(type, "GLvoid *")) { return "TYPE_OUT_ARRAY_VOID"; - else if (strstr(type, "GLboolean *") || - strstr(type, "GLubyte *")) + } else if (strstr(type, "GLboolean *") || + strstr(type, "GLubyte *")) { return "TYPE_OUT_ARRAY_UNSIGNED_CHAR"; - else if (strstr(type, "GLcharARB *") || - strstr(type, "GLchar *")) + } else if (strstr(type, "GLcharARB *") || + strstr(type, "GLchar *")) { return "TYPE_OUT_ARRAY_CHAR"; - else if (strstr(type, "GLshort *")) + } else if (strstr(type, "GLshort *")) { return "TYPE_OUT_ARRAY_SHORT"; - else if (strstr(type, "GLushort *")) + } else if (strstr(type, "GLushort *")) { return "TYPE_OUT_ARRAY_UNSIGNED_SHORT"; - else if (strstr(type, "GLint *")|| - strstr(type, "GLsizei *")) + } else if (strstr(type, "GLint *") || + strstr(type, "GLsizei *")) { return "TYPE_OUT_ARRAY_INT"; - else if (strstr(type, "GLuint *") || + } else if (strstr(type, "GLuint *") || strstr(type, "GLenum *") || - strstr(type, "GLhandleARB *")) + strstr(type, "GLhandleARB *")) { return "TYPE_OUT_ARRAY_UNSIGNED_INT"; - else if (strstr(type, "GLfloat *")) + } else if (strstr(type, "GLfloat *")) { return "TYPE_OUT_ARRAY_FLOAT"; - else if (strstr(type, "GLdouble *")) + } else if (strstr(type, "GLdouble *")) { return "TYPE_OUT_ARRAY_DOUBLE"; - else if (strcmp(type, "void") == 0) - return("TYPE_NONE"); - else if (strcmp(type, "GLbyte") == 0) - return("TYPE_CHAR"); - else if (strcmp(type, "GLubyte") == 0 || - strcmp(type, "GLboolean") == 0) - return("TYPE_UNSIGNED_CHAR"); - else if (strcmp(type, "GLshort") == 0) - return("TYPE_SHORT"); - else if (strcmp(type, "GLushort") == 0 || - strcmp(type, "GLhalfNV") == 0) - return("TYPE_UNSIGNED_SHORT"); - else if (strcmp(type, "GLint") == 0 || + } else if (strcmp(type, "void") == 0) { + return "TYPE_NONE"; + } else if (strcmp(type, "GLbyte") == 0) { + return "TYPE_CHAR"; + } else if (strcmp(type, "GLubyte") == 0 || + strcmp(type, "GLboolean") == 0) { + return "TYPE_UNSIGNED_CHAR"; + } else if (strcmp(type, "GLshort") == 0) { + return "TYPE_SHORT"; + } else if (strcmp(type, "GLushort") == 0 || + strcmp(type, "GLhalfNV") == 0) { + return "TYPE_UNSIGNED_SHORT"; + } else if (strcmp(type, "GLint") == 0 || strcmp(type, "GLsizei") == 0 || strcmp(type, "GLintptr") == 0 || strcmp(type, "GLsizeiptr") == 0 || strcmp(type, "GLintptrARB") == 0 || - strcmp(type, "GLsizeiptrARB") == 0) - return("TYPE_INT"); - else if (strcmp(type, "GLenum") == 0 || + strcmp(type, "GLsizeiptrARB") == 0) { + return "TYPE_INT"; + } else if (strcmp(type, "GLenum") == 0 || strcmp(type, "GLuint") == 0 || strcmp(type, "GLhandleARB") == 0 || - strcmp(type, "GLbitfield") == 0) - return("TYPE_UNSIGNED_INT"); - else if (strcmp(type, "GLfloat") == 0 || - strcmp(type, "GLclampf") == 0) - return("TYPE_FLOAT"); - else if (strcmp(type, "GLdouble") == 0 || - strcmp(type, "GLclampd") == 0) - return("TYPE_DOUBLE"); - else - { + strcmp(type, "GLbitfield") == 0) { + return "TYPE_UNSIGNED_INT"; + } else if (strcmp(type, "GLfloat") == 0 || + strcmp(type, "GLclampf") == 0) { + return "TYPE_FLOAT"; + } else if (strcmp(type, "GLdouble") == 0 || + strcmp(type, "GLclampd") == 0) { + return "TYPE_DOUBLE"; + } else { printf("inconnu %s\n", type); exit(-1); } } -typedef struct -{ - char* letter; - char* signature_type_name; - char* gl_c_type_name; - char* c_type_name; +typedef struct { + char *letter; + char *signature_type_name; + char *gl_c_type_name; + char *c_type_name; } ForIsKnownArgVector; #define N_ELEMENTS(x) (sizeof(x)/sizeof(x[0])) #define N_FIELDS_IN_ARG_VECTOR 4 -typedef struct -{ - char* func_name; - char* signature_type_name; +typedef struct { + char *func_name; + char *signature_type_name; } KnownLastArgFunc; -static KnownLastArgFunc knownLastArgFuncs[] = -{ +static KnownLastArgFunc knownLastArgFuncs[] = { {"glFogCoordfv", "TYPE_1FLOAT"}, {"glFogCoorddv", "TYPE_1DOUBLE"}, {"glFogCoordfvEXT", "TYPE_1FLOAT"}, {"glFogCoorddvEXT", "TYPE_1DOUBLE"}, {"glFogCoordhvNV", "TYPE_1USHORT"}, - + {"glGetFenceivNV", "TYPE_OUT_1INT"}, {"glGetTexLevelParameteriv", "TYPE_OUT_1INT" }, @@ -321,10 +315,11 @@ static KnownLastArgFunc knownLastArgFuncs[] = }; -int is_known_arg_vector(FuncDesc* desc, char** p_signature_type_name, char** p_c_type_name) +int is_known_arg_vector(FuncDesc *desc, + char **p_signature_type_name, + char **p_c_type_name) { - static ForIsKnownArgVector my_tab[] = - { + static ForIsKnownArgVector my_tab[] = { { "b", "CHAR", "GLbyte", "signed char" }, { "Boolean", "CHAR", "GLboolean", "unsigned char" }, { "s", "SHORT", "GLshort", "short" }, @@ -340,79 +335,80 @@ int is_known_arg_vector(FuncDesc* desc, char** p_signature_type_name, char** p_c { "Nub", "CHAR", "GLubyte", "unsigned char" }, { "Nus", "SHORT", "GLushort", "unsigned short" }, { "Nui", "INT", "GLuint", "unsigned int" }, - + { "f", "FLOAT", "GLfloat", "float" }, { "Float", "FLOAT", "GLfloat", "float" }, { "d", "DOUBLE", "GLdouble", "double" }, }; - - if (desc->nargs == 0) + + if (desc->nargs == 0) { return 0; - + } + int i , j; - + if (strstr(desc->name, "glVertexAttribs") || strstr(desc->name, "glProgramParameters") || strstr(desc->name, "glProgramEnvParameters") || strstr(desc->name, "glProgramLocalParameters") || - (strstr(desc->name, "glUniform") && (strstr(desc->name, "iv") || strstr(desc->name, "fv")))) + (strstr(desc->name, "glUniform") && (strstr(desc->name, "iv") || + strstr(desc->name, "fv")))) { return 0; - + } + static char signatures[N_ELEMENTS(my_tab)][N_FIELDS_IN_ARG_VECTOR][20] = {0}; char signature[10]; - - for(i=0;iname, knownLastArgFuncs[i].func_name) == 0) - { - if (p_signature_type_name) - { + + for (i = 0; i < N_ELEMENTS(knownLastArgFuncs); i++) { + if (strcmp(desc->name, knownLastArgFuncs[i].func_name) == 0) { + if (p_signature_type_name) { *p_signature_type_name = knownLastArgFuncs[i].signature_type_name; } - if (p_c_type_name) - { - if (strstr(knownLastArgFuncs[i].signature_type_name, "FLOAT")) + if (p_c_type_name) { + if (strstr(knownLastArgFuncs[i].signature_type_name, "FLOAT")) { *p_c_type_name = "float"; - else if (strstr(knownLastArgFuncs[i].signature_type_name, "DOUBLE")) + } else if (strstr(knownLastArgFuncs[i].signature_type_name, "DOUBLE")) { *p_c_type_name = "double"; - else if (strstr(knownLastArgFuncs[i].signature_type_name, "UINT")) + } else if (strstr(knownLastArgFuncs[i].signature_type_name, "UINT")) { *p_c_type_name = "unsigned int"; - else if (strstr(knownLastArgFuncs[i].signature_type_name, "INT")) + } else if (strstr(knownLastArgFuncs[i].signature_type_name, "INT")) { *p_c_type_name = "int"; - else if (strstr(knownLastArgFuncs[i].signature_type_name, "USHORT")) + } else if (strstr(knownLastArgFuncs[i].signature_type_name, "USHORT")) { *p_c_type_name = "unsigned short"; - else if (strstr(knownLastArgFuncs[i].signature_type_name, "SHORT")) + } else if (strstr(knownLastArgFuncs[i].signature_type_name, "SHORT")) { *p_c_type_name = "short"; - else if (strstr(knownLastArgFuncs[i].signature_type_name, "UCHAR")) + } else if (strstr(knownLastArgFuncs[i].signature_type_name, "UCHAR")) { *p_c_type_name = "unsigned char"; - else if (strstr(knownLastArgFuncs[i].signature_type_name, "CHAR")) + } else if (strstr(knownLastArgFuncs[i].signature_type_name, "CHAR")) { *p_c_type_name = "char"; - else + } else { assert(0); + } } return 1; } } - - for(i=0;iname, "glIndex") && strstr(desc->name, "v")) + + for (i = 0; i < N_ELEMENTS(my_tab); i++) { + for (j = 1; j <= N_FIELDS_IN_ARG_VECTOR; j++) { + if (strstr(desc->name, "glIndex") && strstr(desc->name, "v")) { sprintf(signature, "%sv", my_tab[i].letter); - else + } else { sprintf(signature, "%d%sv", j, my_tab[i].letter); + } if (strstr(desc->name, signature) && strstr(desc->args[desc->nargs - 1], my_tab[i].gl_c_type_name) && - strstr(desc->args[desc->nargs - 1], "*")) - { - if (p_signature_type_name) - { - if (signatures[i][j-1][0] == 0) - sprintf(signatures[i][j-1], "TYPE_%d%s", j, my_tab[i].signature_type_name); + strstr(desc->args[desc->nargs - 1], "*")) { + if (p_signature_type_name) { + if (signatures[i][j-1][0] == 0) { + sprintf(signatures[i][j-1], "TYPE_%d%s", + j, my_tab[i].signature_type_name); + } *p_signature_type_name = signatures[i][j-1]; } - if (p_c_type_name) *p_c_type_name = my_tab[i].c_type_name; + if (p_c_type_name) { + *p_c_type_name = my_tab[i].c_type_name; + } return 1; } } @@ -420,86 +416,83 @@ int is_known_arg_vector(FuncDesc* desc, char** p_signature_type_name, char** p_c return 0; } -static void print_server_side_argument(FILE* server_stub, int j, char* glType) +static void print_server_side_argument(FILE *server_stub, int j, char *glType) { - const char* symbolic_type = get_type_string(glType); - if (strcmp(symbolic_type, "TYPE_CHAR") == 0) + const char *symbolic_type = get_type_string(glType); + if (strcmp(symbolic_type, "TYPE_CHAR") == 0) { fprintf(server_stub, "ARG_TO_CHAR(args[%d])", j); - else if (strcmp(symbolic_type, "TYPE_UNSIGNED_CHAR") == 0) + } else if (strcmp(symbolic_type, "TYPE_UNSIGNED_CHAR") == 0) { fprintf(server_stub, "ARG_TO_UNSIGNED_CHAR(args[%d])", j); - else if (strcmp(symbolic_type, "TYPE_SHORT") == 0) + } else if (strcmp(symbolic_type, "TYPE_SHORT") == 0) { fprintf(server_stub, "ARG_TO_SHORT(args[%d])", j); - else if (strcmp(symbolic_type, "TYPE_UNSIGNED_SHORT") == 0) + } else if (strcmp(symbolic_type, "TYPE_UNSIGNED_SHORT") == 0) { fprintf(server_stub, "ARG_TO_UNSIGNED_SHORT(args[%d])", j); - else if (strcmp(symbolic_type, "TYPE_INT") == 0) + } else if (strcmp(symbolic_type, "TYPE_INT") == 0) { fprintf(server_stub, "ARG_TO_INT(args[%d])", j); - else if (strcmp(symbolic_type, "TYPE_UNSIGNED_INT") == 0) + } else if (strcmp(symbolic_type, "TYPE_UNSIGNED_INT") == 0) { fprintf(server_stub, "ARG_TO_UNSIGNED_INT(args[%d])", j); - else if (strcmp(symbolic_type, "TYPE_FLOAT") == 0) + } else if (strcmp(symbolic_type, "TYPE_FLOAT") == 0) { fprintf(server_stub, "ARG_TO_FLOAT(args[%d])", j); - else if (strcmp(symbolic_type, "TYPE_16FLOAT") == 0) + } else if (strcmp(symbolic_type, "TYPE_16FLOAT") == 0) { fprintf(server_stub, "(const float*)(args[%d])", j); - else if (strcmp(symbolic_type, "TYPE_DOUBLE") == 0) + } else if (strcmp(symbolic_type, "TYPE_DOUBLE") == 0) { fprintf(server_stub, "ARG_TO_DOUBLE(args[%d])", j); - else if ( strcmp(symbolic_type, "TYPE_16DOUBLE") == 0) + } else if (strcmp(symbolic_type, "TYPE_16DOUBLE") == 0) { fprintf(server_stub, "(const double*)(args[%d])", j); - else if ( strcmp(symbolic_type, "TYPE_OUT_128UCHAR") == 0) + } else if (strcmp(symbolic_type, "TYPE_OUT_128UCHAR") == 0) { fprintf(server_stub, "(unsigned char*)(args[%d])", j); - else if ( strcmp(symbolic_type, "TYPE_128UCHAR") == 0) + } else if (strcmp(symbolic_type, "TYPE_128UCHAR") == 0) { fprintf(server_stub, "(const unsigned char*)(args[%d])", j); - else if ( strcmp(symbolic_type, "TYPE_NULL_TERMINATED_STRING") == 0) + } else if (strcmp(symbolic_type, "TYPE_NULL_TERMINATED_STRING") == 0) { fprintf(server_stub, "(const char*)(args[%d])", j); - else if ( strcmp(symbolic_type, "TYPE_ARRAY_SHORT") == 0) + } else if (strcmp(symbolic_type, "TYPE_ARRAY_SHORT") == 0) { fprintf(server_stub, "(const short*)(args[%d])", j); - else if ( strcmp(symbolic_type, "TYPE_ARRAY_UNSIGNED_SHORT") == 0) + } else if (strcmp(symbolic_type, "TYPE_ARRAY_UNSIGNED_SHORT") == 0) { fprintf(server_stub, "(const unsigned short*)(args[%d])", j); - else if ( strcmp(symbolic_type, "TYPE_ARRAY_INT") == 0) + } else if (strcmp(symbolic_type, "TYPE_ARRAY_INT") == 0) { fprintf(server_stub, "(const int*)(args[%d])", j); - else if ( strcmp(symbolic_type, "TYPE_ARRAY_UNSIGNED_INT") == 0) + } else if (strcmp(symbolic_type, "TYPE_ARRAY_UNSIGNED_INT") == 0) { fprintf(server_stub, "(const unsigned int*)(args[%d])", j); - else if ( strcmp(symbolic_type, "TYPE_ARRAY_FLOAT") == 0) + } else if (strcmp(symbolic_type, "TYPE_ARRAY_FLOAT") == 0) { fprintf(server_stub, "(const float*)(args[%d])", j); - else if ( strcmp(symbolic_type, "TYPE_ARRAY_DOUBLE") == 0) + } else if (strcmp(symbolic_type, "TYPE_ARRAY_DOUBLE") == 0) { fprintf(server_stub, "(const double*)(args[%d])", j); - else if ( strcmp(symbolic_type, "TYPE_ARRAY_CHAR") == 0) + } else if (strcmp(symbolic_type, "TYPE_ARRAY_CHAR") == 0) { fprintf(server_stub, "(const char*)(args[%d])", j); - else if ( strcmp(symbolic_type, "TYPE_ARRAY_SIGNED_CHAR") == 0) + } else if (strcmp(symbolic_type, "TYPE_ARRAY_SIGNED_CHAR") == 0) { fprintf(server_stub, "(const signed char*)(args[%d])", j); - else if ( strcmp(symbolic_type, "TYPE_ARRAY_VOID") == 0) + } else if (strcmp(symbolic_type, "TYPE_ARRAY_VOID") == 0) { fprintf(server_stub, "(const void*)(args[%d])", j); - else if ( strcmp(symbolic_type, "TYPE_ARRAY_UNSIGNED_CHAR") == 0) + } else if (strcmp(symbolic_type, "TYPE_ARRAY_UNSIGNED_CHAR") == 0) { fprintf(server_stub, "(const unsigned char*)(args[%d])", j); - else if ( strcmp(symbolic_type, "TYPE_OUT_ARRAY_SHORT") == 0) + } else if (strcmp(symbolic_type, "TYPE_OUT_ARRAY_SHORT") == 0) { fprintf(server_stub, "(short*)(args[%d])", j); - else if ( strcmp(symbolic_type, "TYPE_OUT_ARRAY_UNSIGNED_SHORT") == 0) + } else if (strcmp(symbolic_type, "TYPE_OUT_ARRAY_UNSIGNED_SHORT") == 0) { fprintf(server_stub, "(unsigned short*)(args[%d])", j); - else if ( strcmp(symbolic_type, "TYPE_OUT_ARRAY_INT") == 0) + } else if (strcmp(symbolic_type, "TYPE_OUT_ARRAY_INT") == 0) { fprintf(server_stub, "(int*)(args[%d])", j); - else if ( strcmp(symbolic_type, "TYPE_OUT_ARRAY_UNSIGNED_INT") == 0) + } else if (strcmp(symbolic_type, "TYPE_OUT_ARRAY_UNSIGNED_INT") == 0) { fprintf(server_stub, "(unsigned int*)(args[%d])", j); - else if ( strcmp(symbolic_type, "TYPE_OUT_ARRAY_FLOAT") == 0) + } else if (strcmp(symbolic_type, "TYPE_OUT_ARRAY_FLOAT") == 0) { fprintf(server_stub, "(float*)(args[%d])", j); - else if ( strcmp(symbolic_type, "TYPE_OUT_ARRAY_DOUBLE") == 0) + } else if (strcmp(symbolic_type, "TYPE_OUT_ARRAY_DOUBLE") == 0) { fprintf(server_stub, "(double*)(args[%d])", j); - else if ( strcmp(symbolic_type, "TYPE_OUT_ARRAY_VOID") == 0) + } else if (strcmp(symbolic_type, "TYPE_OUT_ARRAY_VOID") == 0) { fprintf(server_stub, "(void*)(args[%d])", j); - else if ( strcmp(symbolic_type, "TYPE_OUT_ARRAY_CHAR") == 0) + } else if (strcmp(symbolic_type, "TYPE_OUT_ARRAY_CHAR") == 0) { fprintf(server_stub, "(char*)(args[%d])", j); - else if ( strcmp(symbolic_type, "TYPE_OUT_ARRAY_UNSIGNED_CHAR") == 0) + } else if (strcmp(symbolic_type, "TYPE_OUT_ARRAY_UNSIGNED_CHAR") == 0) { fprintf(server_stub, "(unsigned char*)(args[%d])", j); - - else - { + } else { fprintf(stderr, "Unknown : %s\n", symbolic_type); assert(0); } } -static const char* func_dealt_by_hand[500] = { NULL }; +static const char *func_dealt_by_hand[500] = { NULL }; -static const char* ignore_func[] = -{ +static const char *ignore_func[] = { "glGetPointerv", "glRectdv", "glRectfv", @@ -519,13 +512,13 @@ static const char* ignore_func[] = "glLoadTransposeMatrixdARB", "glMultTransposeMatrixfARB", "glMultTransposeMatrixdARB", - + "glPixelDataRangeNV", "glFlushPixelDataRangeNV", "glVertexArrayRangeNV", "glFlushVertexArrayRangeNV", "glVertexWeightfEXT", - + "glGetBufferPointerv", "glGetBufferPointervARB", "glGetVertexAttribPointerv", @@ -538,34 +531,33 @@ static const char* ignore_func[] = void get_func_dealt_by_hand() { - FILE* f = fopen(GL_INCLUDE_PATH"gl_func_perso.h", "r"); + FILE *f = fopen(GL_INCLUDE_PATH"gl_func_perso.h", "r"); char buffer[256]; int i = 0; - char* c; - while(fgets(buffer, 256, f)) - { - if (strstr(buffer, "MAGIC_MACRO(")) - { - func_dealt_by_hand[i] = strdup(strstr(buffer, "MAGIC_MACRO(") + strlen("MAGIC_MACRO(")); - * strstr(func_dealt_by_hand[i], ")") = 0; + char *c; + while (fgets(buffer, 256, f)) { + if (strstr(buffer, "MAGIC_MACRO(")) { + func_dealt_by_hand[i] = strdup(strstr(buffer, "MAGIC_MACRO(") + + strlen("MAGIC_MACRO(")); + *strstr(func_dealt_by_hand[i], ")") = 0; c = strstr(func_dealt_by_hand[i], "_"); - if (c && c != func_dealt_by_hand[i]) *c = 0; - i ++; + if (c && c != func_dealt_by_hand[i]) { + *c = 0; + } + i++; } } fclose(f); - + int j = 0; - while(ignore_func[j]) - { + while (ignore_func[j]) { func_dealt_by_hand[i] = ignore_func[j]; i++; j++; } } -static const char* just_for_server_side_list[] = -{ +static const char *just_for_server_side_list[] = { "glEnableClientState", "glDisableClientState", "glPushClientAttrib", @@ -590,7 +582,7 @@ static const char* just_for_server_side_list[] = "glFogi", "glClipPlane", "glGetClipPlane", - + /* begin of openquartz optimization */ #if 1 "glMatrixMode", @@ -611,13 +603,13 @@ static const char* just_for_server_side_list[] = "glTranslatef", #endif /* end of openquartz optimization */ - + "glGetError", "glActiveTextureARB", - + "glViewport", "glScissor", - + "glBindBufferARB", "glDeleteBuffersARB", "glGenBuffersARB", @@ -632,7 +624,7 @@ static const char* just_for_server_side_list[] = "glBufferSubData", "glGetBufferSubData", "glGetBufferParameteriv", - + "glPushAttrib", "glPopAttrib", "glEnable", @@ -648,19 +640,19 @@ static const char* just_for_server_side_list[] = "glDrawPixels", "glSelectBuffer", "glFeedbackBuffer", - + "glTexImage1D", "glTexImage2D", "glTexImage3D", "glTexSubImage1D", "glTexSubImage2D", "glTexSubImage3D", - + "glTexImage3DEXT", "glTexSubImage1DEXT", "glTexSubImage2DEXT", "glTexSubImage3DEXT", - + "glGetCompressedTexImage", "glCompressedTexImage1D", "glCompressedTexImage2D", @@ -668,7 +660,7 @@ static const char* just_for_server_side_list[] = "glCompressedTexSubImage1D", "glCompressedTexSubImage2D", "glCompressedTexSubImage3D", - + "glGetCompressedTexImageARB", "glCompressedTexImage1DARB", "glCompressedTexImage2DARB", @@ -676,12 +668,12 @@ static const char* just_for_server_side_list[] = "glCompressedTexSubImage1DARB", "glCompressedTexSubImage2DARB", "glCompressedTexSubImage3DARB", - + "glCallLists", "glNewList", "glDeleteLists", "glGenLists", - + "glGenTextures", "glDeleteTextures", "glDeleteTexturesEXT", @@ -696,7 +688,7 @@ static const char* just_for_server_side_list[] = "glGetIntegerv", "glGetFloatv", "glGetDoublev", - + "glGetPixelMapfv", "glGetPixelMapuiv", "glGetPixelMapusv", @@ -728,10 +720,10 @@ static const char* just_for_server_side_list[] = "glGetActiveAttrib", "glGetAttribLocationARB", "glGetAttribLocation", - + "glNewObjectBufferATI", "glUpdateObjectBufferATI", - + "glSetLocalConstantEXT", "glSetInvariantEXT", "glVariantbvEXT", @@ -751,11 +743,11 @@ static const char* just_for_server_side_list[] = "glGetLocalConstantBooleanvEXT", "glGetLocalConstantIntegervEXT", "glGetLocalConstantFloatvEXT", - + "glMatrixIndexubvARB", "glMatrixIndexusvARB", "glMatrixIndexuivARB", - + "glColorTable", "glColorSubTable", "glGetColorTable", @@ -776,168 +768,155 @@ static const char* just_for_server_side_list[] = "glGetSeparableFilterEXT", "glGetHistogramEXT", "glGetMinmaxEXT", - + "glGetTexParameterfv", - + "glGetVertexAttribivARB", "glGetVertexAttribfvARB", "glGetVertexAttribdvARB", "glGetVertexAttribiv", "glGetVertexAttribfv", "glGetVertexAttribdv", - + "glGetDetailTexFuncSGIS", "glGetSharpenTexFuncSGIS", - + "fake_gluBuild2DMipmaps", - + "glRenderMode", - + "glEnableVariantClientStateEXT", "glDisableVariantClientStateEXT", - + "glGetActiveVaryingNV", - + NULL, }; -static int just_for_server_side_func(char* funcname) +static int just_for_server_side_func(char *funcname) { int i; - for(i=0;just_for_server_side_list[i];i++) - { - if (strcmp(just_for_server_side_list[i], funcname) == 0) + for (i = 0; just_for_server_side_list[i]; i++) { + if (strcmp(just_for_server_side_list[i], funcname) == 0) { return 1; + } } return 0; } -int parse(FILE* f, FuncDesc* funcDesc, int funcDescCount, int ignoreEXT) +int parse(FILE *f, FuncDesc *funcDesc, int funcDescCount, int ignoreEXT) { char buffer[256]; - while(fgets(buffer, 256, f)) - { + while (fgets(buffer, 256, f)) { - if (strncmp(buffer, "GLAPI", 5) == 0 && strstr(buffer, "APIENTRY") && strstr(buffer, "(")) - { + if (strncmp(buffer, "GLAPI", 5) == 0 && + strstr(buffer, "APIENTRY") && + strstr(buffer, "(")) { int i = 0; int skip = 0; - if (func_dealt_by_hand[0] == 0) - { + if (func_dealt_by_hand[0] == 0) { get_func_dealt_by_hand(); } - while (func_dealt_by_hand[i]) - { - if (strstr(buffer, func_dealt_by_hand[i])) - { + while (func_dealt_by_hand[i]) { + if (strstr(buffer, func_dealt_by_hand[i])) { skip = 1; break; } i++; } - if (skip) + if (skip) { continue; - - char** args = malloc(15 * sizeof(char*)); + } + + char **args = malloc(15 * sizeof(char *)); int narg = 0; - char* type = buffer + 6; - char* n = strstr(type, "GLAPIENTRY") ? strstr(type, "GLAPIENTRY") : strstr(type, "APIENTRY"); + char *type = buffer + 6; + char *n = strstr(type, "GLAPIENTRY") ? + strstr(type, "GLAPIENTRY") : strstr(type, "APIENTRY"); int skip_length = strstr(type, "GLAPIENTRY") ? 11 : 9; n[-1] = 0; type = strdup(type); n += skip_length; - char* fonc = n; + char *fonc = n; n = strstr(n, "("); - if (n[-1] == ' ') n[-1] = 0; + if (n[-1] == ' ') { + n[-1] = 0; + } n[0] = 0; fonc = strdup(fonc); - /*if (strstr(fonc, "glLockArraysEXT") || strstr(fonc, "glUnlockArraysEXT")) - { - } - else*/ - - - if (ignoreEXT == 1 && isExtByName(fonc)) - { + /*if (strstr(fonc, "glLockArraysEXT") || + strstr(fonc, "glUnlockArraysEXT")) { + } else*/ + + if (ignoreEXT == 1 && isExtByName(fonc)) { free(type); free(fonc); continue; } n++; - while(1) - { - char* virg = strstr(n, ","); - if (virg) - { + while (1) { + char *virg = strstr(n, ","); + if (virg) { args[narg] = n; virg[0] = 0; args[narg] = get_arg_type(args[narg]); narg++; n = virg+1; - } - else + } else { break; + } } - while (strstr(n, ")") == 0) - { + while (strstr(n, ")") == 0) { fgets(buffer, 256, f); n = buffer; - while(1) - { - char* virg = strstr(n, ","); - if (virg) - { + while (1) { + char *virg = strstr(n, ","); + if (virg) { args[narg] = n; virg[0] = 0; args[narg] = get_arg_type(args[narg]); narg++; n = virg+1; - } - else + } else { break; + } } } - char* par = strstr(n, ")"); + char *par = strstr(n, ")"); args[narg] = n; par[0] = 0; args[narg] = get_arg_type(args[narg]); narg++; - - + + /*printf("%s %s (", type, fonc); - for(i=0;iargs[j], "*") == NULL) + if (strstr(funcDesc->args[j], "*") == NULL) { return 0; - for(i=0;i< N_ELEMENTS(argDependingOnPreviousArgTab); i++) - { - if (strstr(funcDesc->name, argDependingOnPreviousArgTab[i].str) && j == argDependingOnPreviousArgTab[i].i) + } + for (i = 0; i < N_ELEMENTS(argDependingOnPreviousArgTab); i++) { + if (strstr(funcDesc->name, argDependingOnPreviousArgTab[i].str) && + j == argDependingOnPreviousArgTab[i].i) { return 1; + } } return 0; } -static void fprintf_prototype_args(FILE* f, FuncDesc* funcDesc) +static void fprintf_prototype_args(FILE *f, FuncDesc *funcDesc) { int j; - for(j=0;jnargs;j++) - { - if (j != 0) fprintf(f,", "); - if (strstr(funcDesc->args[j], "[16]")) - { - if (strstr(funcDesc->args[j], "float")) - { + for (j = 0; j < funcDesc->nargs; j++) { + if (j != 0) { + fprintf(f, ", "); + } + if (strstr(funcDesc->args[j], "[16]")) { + if (strstr(funcDesc->args[j], "float")) { fprintf(f, "const GLfloat arg_%d[16]", j); - } - else if (strstr(funcDesc->args[j], "double")) - { + } else if (strstr(funcDesc->args[j], "double")) { fprintf(f, "const GLdouble arg_%d[16]", j); - } - else - { + } else { exit(-1); } - } - else if (strstr(funcDesc->args[j], "[128]") && strstr(funcDesc->args[j], "GLubyte")) - fprintf(f, (strstr(funcDesc->args[j], "const")) ? "const GLubyte* arg_%d" : "GLubyte* arg_%d", j); - else + } else if (strstr(funcDesc->args[j], "[128]") && + strstr(funcDesc->args[j], "GLubyte")) { + fprintf(f, (strstr(funcDesc->args[j], "const")) ? + "const GLubyte* arg_%d" : "GLubyte* arg_%d", j); + } else { fprintf(f, "%s arg_%d", funcDesc->args[j], j); + } + } + if (j == 0) { + fprintf(f, "void"); } - if (j == 0) - fprintf(f, "void"); } -int main(int argc, char* argv[]) +int main(int argc, char *argv[]) { FuncDesc funcDesc[3000]; int funcDescCount = 0; - FILE* f; + FILE *f; - printf("***** path : %s\n", GL_INCLUDE_PATH"mesa_gl.h"); + printf("***** path : %s\n", GL_INCLUDE_PATH"mesa_gl.h"); f = fopen(GL_INCLUDE_PATH"mesa_gl.h", "r"); assert(f); - /*if (!f) - f = fopen("/usr/include/GL/gl.h", "r");*/ + /*if (!f) { + f = fopen("/usr/include/GL/gl.h", "r"); + }*/ funcDescCount = parse(f, funcDesc, 0, 1); fclose(f); - + f = fopen(GL_INCLUDE_PATH"mesa_glext.h", "r"); assert(f); - /*if (!f) - f = fopen("/usr/include/GL/glext.h", "r");*/ + /*if (!f) { + f = fopen("/usr/include/GL/glext.h", "r"); + }*/ funcDescCount = parse(f, funcDesc, funcDescCount, 0); fclose(f); - FILE* header = fopen("gl_func.h", "w"); - FILE* client_stub = fopen("client_stub.c", "w"); - FILE* server_stub = fopen("server_stub.c", "w"); + FILE *header = fopen("gl_func.h", "w"); + FILE *client_stub = fopen("client_stub.c", "w"); + FILE *server_stub = fopen("server_stub.c", "w"); - fprintf(header, "/* This is a generated file by parse_gl_h.c - DO NOT EDIT ! */\n\n"); + fprintf(header, + "/* This is a generated file by parse_gl_h.c - DO NOT EDIT ! */\n\n"); fprintf(header, "union gl_ret_type {\n" "const char *s;\n" "int i;\n" @@ -1171,213 +1151,201 @@ int main(int argc, char* argv[]) fprintf(header, "enum {\n" "#include \"gl_func_perso.h\"\n"); - fprintf(client_stub, "/* This is a generated file by parse_gl_h.c - DO NOT EDIT ! */\n\n"); + fprintf(client_stub, + "/* This is a generated file by parse_gl_h.c - DO NOT EDIT ! */\n\n"); - fprintf(server_stub, "/* This is a generated file by parse_gl_h.c - DO NOT EDIT ! */\n\n"); + fprintf(server_stub, + "/* This is a generated file by parse_gl_h.c - DO NOT EDIT ! */\n\n"); int i; - for(i=0;i= 0) - { + } + } else { + if (funcDesc[i].nargs-1 >= 0) { j = funcDesc[i].nargs-1; if (!is_arg_of_length_depending_on_previous_args(&funcDesc[i], j) && strstr(funcDesc[i].args[j], "const GLchar") == NULL && - strstr(funcDesc[i].args[j], "[16]") == NULL) - { - pointer_of_unknown_size |= strstr(funcDesc[i].args[j], "*") != NULL; - pointer_of_unknown_size |= strstr(funcDesc[i].args[j], "[") != NULL; + strstr(funcDesc[i].args[j], "[16]") == NULL) { + pointer_of_unknown_size |= + strstr(funcDesc[i].args[j], "*") != NULL; + pointer_of_unknown_size |= + strstr(funcDesc[i].args[j], "[") != NULL; } } } } - if (pointer_of_unknown_size && funcDesc[i].nargs == 1) - { - if (strstr(funcDesc[i].name, "Matrixf") || strstr(funcDesc[i].name, "Matrixd")) - { + if (pointer_of_unknown_size && funcDesc[i].nargs == 1) { + if (strstr(funcDesc[i].name, "Matrixf") || + strstr(funcDesc[i].name, "Matrixd")) { free(funcDesc[i].args[0]); - if (strstr(funcDesc[i].name, "Matrixf")) + if (strstr(funcDesc[i].name, "Matrixf")) { funcDesc[i].args[0] = strdup("GLfloat m[16]"); - else + } else { funcDesc[i].args[0] = strdup("GLdouble m[16]"); + } pointer_of_unknown_size = 0; - } - else if (strcmp(funcDesc[i].name, "glPolygonStipple") == 0) - { + } else if (strcmp(funcDesc[i].name, "glPolygonStipple") == 0) { free(funcDesc[i].args[0]); funcDesc[i].args[0] = strdup("const GLubyte mask[128]"); pointer_of_unknown_size = 0; - } - else if (strcmp(funcDesc[i].name, "glGetPolygonStipple") == 0) - { + } else if (strcmp(funcDesc[i].name, "glGetPolygonStipple") == 0) { free(funcDesc[i].args[0]); funcDesc[i].args[0] = strdup("GLubyte mask[128]"); funcDesc[i].has_out_parameters = 1; pointer_of_unknown_size = 0; } } - if (just_for_server_side_func(name) || pointer_of_unknown_size == 0) - { + if (just_for_server_side_func(name) || pointer_of_unknown_size == 0) { fprintf(header, " %s_func,\n", funcDesc[i].name); funcDesc[i].ok = 1; - if (just_for_server_side_func(name)) + if (just_for_server_side_func(name)) { funcDesc[i].just_for_server_side = 1; - for(j=0;j 0) fprintf(client_stub, ", "); - if (strstr(funcDesc[i].args[j], "*")) - { - fprintf(client_stub, "POINTER_TO_ARG(arg_%d)", j); + for (j = 0; j < funcDesc[i].nargs; j++) { + if (j > 0) { + fprintf(client_stub, ", "); } - else - { - const char* symbolic_type = get_type_string(funcDesc[i].args[j]); - if (strcmp(symbolic_type, "TYPE_CHAR") == 0) + if (strstr(funcDesc[i].args[j], "*")) { + fprintf(client_stub, "POINTER_TO_ARG(arg_%d)", j); + } else { + const char *symbolic_type = get_type_string(funcDesc[i].args[j]); + if (strcmp(symbolic_type, "TYPE_CHAR") == 0) { fprintf(client_stub, "CHAR_TO_ARG"); - else if (strcmp(symbolic_type, "TYPE_UNSIGNED_CHAR") == 0) + } else if (strcmp(symbolic_type, "TYPE_UNSIGNED_CHAR") == 0) { fprintf(client_stub, "UNSIGNED_CHAR_TO_ARG"); - else if (strcmp(symbolic_type, "TYPE_SHORT") == 0) + } else if (strcmp(symbolic_type, "TYPE_SHORT") == 0) { fprintf(client_stub, "SHORT_TO_ARG"); - else if (strcmp(symbolic_type, "TYPE_UNSIGNED_SHORT") == 0) + } else if (strcmp(symbolic_type, "TYPE_UNSIGNED_SHORT") == 0) { fprintf(client_stub, "UNSIGNED_SHORT_TO_ARG"); - else if (strcmp(symbolic_type, "TYPE_INT") == 0) + } else if (strcmp(symbolic_type, "TYPE_INT") == 0) { fprintf(client_stub, "INT_TO_ARG"); - else if (strcmp(symbolic_type, "TYPE_UNSIGNED_INT") == 0) + } else if (strcmp(symbolic_type, "TYPE_UNSIGNED_INT") == 0) { fprintf(client_stub, "UNSIGNED_INT_TO_ARG"); - else if (strcmp(symbolic_type, "TYPE_FLOAT") == 0) + } else if (strcmp(symbolic_type, "TYPE_FLOAT") == 0) { fprintf(client_stub, "FLOAT_TO_ARG"); - else if (strcmp(symbolic_type, "TYPE_16FLOAT") == 0) + } else if (strcmp(symbolic_type, "TYPE_16FLOAT") == 0) { fprintf(client_stub, "POINTER_TO_ARG"); - else if (strcmp(symbolic_type, "TYPE_DOUBLE") == 0) + } else if (strcmp(symbolic_type, "TYPE_DOUBLE") == 0) { fprintf(client_stub, "DOUBLE_TO_ARG"); - else if ( strcmp(symbolic_type, "TYPE_16DOUBLE") == 0) + } else if (strcmp(symbolic_type, "TYPE_16DOUBLE") == 0) { fprintf(client_stub, "POINTER_TO_ARG"); - else if ( strcmp(symbolic_type, "TYPE_128UCHAR") == 0 || strcmp(symbolic_type, "TYPE_OUT_128UCHAR") == 0) + } else if (strcmp(symbolic_type, "TYPE_128UCHAR") == 0 || + strcmp(symbolic_type, "TYPE_OUT_128UCHAR") == 0) { fprintf(client_stub, "POINTER_TO_ARG"); - else - { + } else { fprintf(stderr, "Unknown : %s\n", symbolic_type); assert(0); } @@ -1386,86 +1354,89 @@ int main(int argc, char* argv[]) } fprintf(client_stub, "};\n"); } - + fprintf(client_stub, " do_opengl_call(%s_func, %s, %s, NULL);\n", - funcDesc[i].name, (strcmp(funcDesc[i].type, "void") == 0) ? "NULL" : "&ret", + funcDesc[i].name, + (strcmp(funcDesc[i].type, "void") == 0) ? "NULL" : "&ret", (funcDesc[i].nargs) ? "args" : "NULL"); - - if (strcmp(funcDesc[i].type, "void") != 0) - { + + if (strcmp(funcDesc[i].type, "void") != 0) { fprintf(client_stub, " return ret;\n"); } fprintf(client_stub, "}\n\n"); } - + fprintf(server_stub, " case %s_func:\n", funcDesc[i].name); fprintf(server_stub, " {\n"); - - if (isExt(&funcDesc[i])) - { - fprintf(server_stub, " GET_EXT_PTR(%s, %s, (", funcDesc[i].type, funcDesc[i].name); + + if (isExt(&funcDesc[i])) { + fprintf(server_stub, " GET_EXT_PTR(%s, %s, (", + funcDesc[i].type, funcDesc[i].name); fprintf_prototype_args(server_stub, &funcDesc[i]); fprintf(server_stub, "));\n"); } - + fprintf(server_stub, " "); - - if (strcmp(funcDesc[i].type, "void") == 0) + + if (strcmp(funcDesc[i].type, "void") == 0) { ; - else if (strcmp(get_type_string(funcDesc[i].type), "TYPE_INT") == 0 || - strcmp(get_type_string(funcDesc[i].type), "TYPE_UNSIGNED_INT") == 0) + } else if (strcmp(get_type_string(funcDesc[i].type), "TYPE_INT") == 0 || + strcmp(get_type_string(funcDesc[i].type), + "TYPE_UNSIGNED_INT") == 0) { fprintf(server_stub, "pret->i = "); - else if (strcmp(get_type_string(funcDesc[i].type), "TYPE_CHAR") == 0 || - strcmp(get_type_string(funcDesc[i].type), "TYPE_UNSIGNED_CHAR") == 0) + } else if (strcmp(get_type_string(funcDesc[i].type), "TYPE_CHAR") == 0 || + strcmp(get_type_string(funcDesc[i].type), + "TYPE_UNSIGNED_CHAR") == 0) { fprintf(server_stub, "pret->c = "); - else - { - fprintf(stderr, "unknown ret type = %s\n", get_type_string(funcDesc[i].type)); + } else { + fprintf(stderr, "unknown ret type = %s\n", + get_type_string(funcDesc[i].type)); exit(-1); } - /*if (strstr(funcDesc[i].name, "EXT")) - { - char* dup = strdup(funcDesc[i].name); + /* if (strstr(funcDesc[i].name, "EXT")) { + char *dup = strdup(funcDesc[i].name); *strstr(dup, "EXT") = 0; fprintf(server_stub, "%s(", dup); free(dup); - } - else*/ - { - if (isExt(&funcDesc[i])) + } else */ + { + if (isExt(&funcDesc[i])) { fprintf(server_stub, "ptr_func_%s(", funcDesc[i].name); - else + } else { fprintf(server_stub, "%s(", funcDesc[i].name); + } } - char* c_type_name; - if (is_known_arg_vector(&funcDesc[i], NULL, &c_type_name)) - { - for(j=0;j - -#include "tizen/src/debug_ch.h" -MULTI_DEBUG_CHANNEL(qemu, virtio-gl); - -#define TYPE_VIRTIO_GL "virtio-gl" - -int decode_call_int(ProcessStruct *p, char *in_args, int args_len, char *r_buffer); - -/* Uncomment to enable debugging - WARNING!!! changes ABI! */ -//#define DEBUG_GLIO - -typedef struct VirtIOGL -{ - VirtIODevice vdev; - VirtQueue *vq; -} VirtIOGL; - -struct d_hdr -{ - int pid; - int rq_l; - int rrq_l; -#ifdef DEBUG_GLIO - int sum; -#endif -}; - -#define SIZE_OUT_HEADER sizeof(struct d_hdr) - -#ifdef DEBUG_GLIO -#define SIZE_IN_HEADER (4*2) -#else -#define SIZE_IN_HEADER 4 -#endif - -#endif #include "virtio-gl.h" static void virtio_gl_handle(VirtIODevice *vdev, VirtQueue *vq) { - VirtQueueElement elem; - int nkill = 1; - - TRACE("virtio_gl_handle called. \n"); - - while(virtqueue_pop(vq, &elem)) { - struct d_hdr *hdr = (struct d_hdr*)elem.out_sg[0].iov_base; - ProcessStruct *process; - int i, remain; - int ret = 0; - - if(!elem.out_num) { - fprintf(stderr, "Bad packet\n"); - virtqueue_push(vq, &elem, ret); - virtio_notify(vdev, vq); - return; - } - - process = vmgl_get_process(hdr->pid); - - if(hdr->rq_l) { - - if(hdr->rrq_l) { - if(process->rq) { // Usually only the quit packet... - free(process->rq); - free(process->rrq); - } - // process->rq = process->rq_p = qemu_malloc(hdr->rq_l); - // process->rrq = process->rrq_p = qemu_malloc(hdr->rrq_l); - process->rq = process->rq_p = g_malloc(hdr->rq_l); - process->rrq = process->rrq_p = g_malloc(hdr->rrq_l); - process->rq_l = hdr->rq_l - SIZE_OUT_HEADER; - process->rrq_l = hdr->rrq_l; + VirtQueueElement elem; + int nkill = 1; + + TRACE("virtio_gl_handle called.\n"); + + while (virtqueue_pop(vq, &elem)) { + struct d_hdr *hdr = (struct d_hdr *)elem.out_sg[0].iov_base; + ProcessStruct *process; + int i, remain; + int ret = 0; + + if (!elem.out_num) { + ERR("Bad packet\n"); + virtqueue_push(vq, &elem, ret); + virtio_notify(vdev, vq); + return; + } + + process = vmgl_get_process(hdr->pid); + + if (hdr->rq_l) { + if (hdr->rrq_l) { + if (process->rq) { /* Usually only the quit packet... */ + free(process->rq); + free(process->rrq); + } + process->rq = process->rq_p = g_malloc(hdr->rq_l); + process->rrq = process->rrq_p = g_malloc(hdr->rrq_l); + process->rq_l = hdr->rq_l - SIZE_OUT_HEADER; + process->rrq_l = hdr->rrq_l; #ifdef DEBUG_GLIO - process->sum = hdr->sum; + process->sum = hdr->sum; #endif - } - - i = 0; - remain = process->rq_l - (process->rq_p - process->rq); - while(remain && i < elem.out_num){ - char *src = (char *)elem.out_sg[i].iov_base; - int ilen = elem.out_sg[i].iov_len; - int len = remain; - - if(i == 0) { - src += SIZE_OUT_HEADER; - ilen -= SIZE_OUT_HEADER; - } - - if(len > ilen) - len = ilen; - - memcpy(process->rq_p, src, len); - process->rq_p += len; - remain -= len; - i++; - } - - if(process->rq_p >= process->rq + process->rq_l) { - + } + + i = 0; + remain = process->rq_l - (process->rq_p - process->rq); + while (remain && i < elem.out_num) { + char *src = (char *)elem.out_sg[i].iov_base; + int ilen = elem.out_sg[i].iov_len; + int len = remain; + + if (i == 0) { + src += SIZE_OUT_HEADER; + ilen -= SIZE_OUT_HEADER; + } + + if (len > ilen) { + len = ilen; + } + + memcpy(process->rq_p, src, len); + process->rq_p += len; + remain -= len; + i++; + } + + if (process->rq_p >= process->rq + process->rq_l) { #ifdef DEBUG_GLIO - int sum = 0; - for(i = 0; i < process->rq_l ; i++) - sum += process->rq[i]; - if(sum != process->sum) - fprintf(stderr, "Checksum fail\n"); + int sum = 0; + for (i = 0; i < process->rq_l; i++) { + sum += process->rq[i]; + } + if (sum != process->sum) { + ERR("Checksum fail\n"); + } #endif - *(int*)process->rrq = nkill = decode_call_int(process, - process->rq, /* command_buffer */ - process->rq_l, /* cmd buffer length */ - process->rrq + SIZE_IN_HEADER); /* return buffer */ + *(int *)process->rrq = nkill = decode_call_int(process, + process->rq, /* command_buffer */ + process->rq_l, /* cmd buffer length */ + process->rrq + SIZE_IN_HEADER); /* return buffer */ - //qemu_free(process->rq); - g_free(process->rq); - process->rq = NULL; + g_free(process->rq); + process->rq = NULL; #ifdef DEBUG_GLIO - sum = 0; - for(i = SIZE_IN_BUFFER; i < process->rrq_l ; i++) - sum += process->rrq[i]; - *(int*)(process->rrq+sizeof(int)) = sum; + sum = 0; + for (i = SIZE_IN_BUFFER; i < process->rrq_l; i++) { + sum += process->rrq[i]; + } + *(int *)(process->rrq + sizeof(int)) = sum; #endif - } - } - - if(hdr->rrq_l && process->rq == NULL) { - - i = 0; - remain = process->rrq_l - (process->rrq_p - process->rrq); - while(remain && i < elem.in_num) { - char *dst = elem.in_sg[i].iov_base; - int len = remain; - int ilen = elem.in_sg[i].iov_len; - - if(len > ilen) - len = ilen; - - memcpy(dst, process->rrq_p, len); - process->rrq_p += len; - remain -= len; - ret += len; - i++; - } - - if(remain <= 0) { - //qemu_free(process->rrq); - g_free(process->rrq); - if(!nkill) - gl_disconnect(process); - } - } - - virtqueue_push(vq, &elem, ret); - - virtio_notify(vdev, vq); - } + } + } + + if (hdr->rrq_l && process->rq == NULL) { + i = 0; + remain = process->rrq_l - (process->rrq_p - process->rrq); + while (remain && i < elem.in_num) { + char *dst = elem.in_sg[i].iov_base; + int len = remain; + int ilen = elem.in_sg[i].iov_len; + + if (len > ilen) { + len = ilen; + } + + memcpy(dst, process->rrq_p, len); + process->rrq_p += len; + remain -= len; + ret += len; + i++; + } + + if (remain <= 0) { + g_free(process->rrq); + if (!nkill) { + gl_disconnect(process); + } + } + } + + virtqueue_push(vq, &elem, ret); + virtio_notify(vdev, vq); + } } static uint32_t virtio_gl_get_features(VirtIODevice *vdev, uint32_t f) { - return 0; + return 0; } /* static void virtio_gl_save(QEMUFile *f, void *opaque) { - VirtIOGL *s = opaque; + VirtIOGL *s = opaque; - virtio_save(&s->vdev, f); + virtio_save(&s->vdev, f); } static int virtio_gl_load(QEMUFile *f, void *opaque, int version_id) { - VirtIOGL *s = opaque; + VirtIOGL *s = opaque; - if (version_id != 1) - return -EINVAL; + if (version_id != 1) { + return -EINVAL; + } - virtio_load(&s->vdev, f); - return 0; + virtio_load(&s->vdev, f); + return 0; } */ static int virtio_gl_device_init(VirtIODevice *vdev) { - VirtIOGL *s = VIRTIO_GL(vdev); - //DeviceState *qdev = DEVICE(vdev); + VirtIOGL *s = VIRTIO_GL(vdev); + /* DeviceState *qdev = DEVICE(vdev); */ + if (s == NULL) { + ERR("Failed to initialize virtio gl device.\n"); + return -1; + } - virtio_init(vdev, TYPE_VIRTIO_GL, VIRTIO_ID_GL, 0); - if (vdev == NULL) { - ERR("Failed to initialize virtio gl device.\n"); - return -1; - } + virtio_init(vdev, TYPE_VIRTIO_GL, VIRTIO_ID_GL, 0); - /* - VirtioDeviceClass *vdc = VIRTIO_DEVICE_GET_CLASS(&s->vdev); - vdc->get_features = virtio_gl_get_features; + /* + VirtioDeviceClass *vdc = VIRTIO_DEVICE_GET_CLASS(&s->vdev); + vdc->get_features = virtio_gl_get_features; - s->vq = virtio_add_queue(&s->vdev, 128, virtio_gl_handle); - register_savevm(qdev, TYPE_VIRTIO_GL, -1, 1, virtio_gl_save, virtio_gl_load, s); - */ - s->vq = virtio_add_queue(vdev, 128, virtio_gl_handle); + s->vq = virtio_add_queue(&s->vdev, 128, virtio_gl_handle); + register_savevm(qdev, TYPE_VIRTIO_GL, -1, 1, + virtio_gl_save, virtio_gl_load, s); + */ + s->vq = virtio_add_queue(vdev, 128, virtio_gl_handle); - return 0; + return 0; } static int virtio_gl_device_exit(DeviceState *qdev) -- 2.34.1