[008/906] gst-indent

2025-01-12 02:15:31 +00:00 · 2004-03-14 22:34:32 +00:00 · 2004-03-14 22:34:32 +00:00 · febb402b4b
commit febb402b4b
parent 925dfd952a
10 changed files with 2188 additions and 1749 deletions
--- a/gst/gl/ARB_multitexture.h
+++ b/gst/gl/ARB_multitexture.h
@ -19,26 +19,26 @@
 #define ARB_MULTITEXTURE_INITIALIZE 1	// enable generic init-routines
 #ifndef _WIN32
 #define GL_GLEXT_PROTOTYPES 1
-#endif
+#endif /* 
 */
 #ifdef __cplusplus
-extern "C" {
+extern "C"
-#endif
+{
 #endif				/* 
 */
 #if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__)
 #define WIN32_LEAN_AND_MEAN 1
 #include <windows.h>
-#endif
+#endif				/* 
 */
 #ifndef APIENTRY
 #define APIENTRY
-#endif
+#endif				/* 
 */
 // Header file version number, required by OpenGL ABI for Linux
 //#define GL_GLEXT_VERSION 7
 /* 
 * NEW TOKENS TO OPENGL 1.2.1 
 *
@ -80,7 +80,7 @@ extern "C" {
 #define GL_CLIENT_ACTIVE_TEXTURE_ARB      0x84E1
 #define GL_MAX_TEXTURE_UNITS_ARB          0x84E2
 #define GL_ARB_multitexture 1
-#endif
+#endif				/* 
 */
 #ifndef _WIN32
 #ifdef GL_GLEXT_PROTOTYPES
@ -102,58 +102,99 @@ extern void APIENTRY glMultiTexCoord2iARB (GLenum, GLint, GLint);
   
extern void APIENTRY glMultiTexCoord2ivARB (GLenum, const GLint *);
   
extern void APIENTRY glMultiTexCoord2sARB (GLenum, GLshort, GLshort);
   
extern void APIENTRY glMultiTexCoord2svARB (GLenum, const GLshort *);
-extern void APIENTRY glMultiTexCoord3dARB (GLenum, GLdouble, GLdouble, GLdouble);
+   
extern void APIENTRY glMultiTexCoord3dARB (GLenum, GLdouble, GLdouble,
      GLdouble);
   
extern void APIENTRY glMultiTexCoord3dvARB (GLenum, const GLdouble *);
-extern void APIENTRY glMultiTexCoord3fARB (GLenum, GLfloat, GLfloat, GLfloat);
+   
extern void APIENTRY glMultiTexCoord3fARB (GLenum, GLfloat, GLfloat,
      GLfloat);
   
extern void APIENTRY glMultiTexCoord3fvARB (GLenum, const GLfloat *);
   
extern void APIENTRY glMultiTexCoord3iARB (GLenum, GLint, GLint, GLint);
   
extern void APIENTRY glMultiTexCoord3ivARB (GLenum, const GLint *);
-extern void APIENTRY glMultiTexCoord3sARB (GLenum, GLshort, GLshort, GLshort);
+   
extern void APIENTRY glMultiTexCoord3sARB (GLenum, GLshort, GLshort,
      GLshort);
   
extern void APIENTRY glMultiTexCoord3svARB (GLenum, const GLshort *);
-extern void APIENTRY glMultiTexCoord4dARB (GLenum, GLdouble, GLdouble, GLdouble, GLdouble);
+   
extern void APIENTRY glMultiTexCoord4dARB (GLenum, GLdouble, GLdouble,
      GLdouble, GLdouble);
   
extern void APIENTRY glMultiTexCoord4dvARB (GLenum, const GLdouble *);
-extern void APIENTRY glMultiTexCoord4fARB (GLenum, GLfloat, GLfloat, GLfloat, GLfloat);
+   
extern void APIENTRY glMultiTexCoord4fARB (GLenum, GLfloat, GLfloat,
      GLfloat, GLfloat);
   
extern void APIENTRY glMultiTexCoord4fvARB (GLenum, const GLfloat *);
-extern void APIENTRY glMultiTexCoord4iARB (GLenum, GLint, GLint, GLint, GLint);
+   
extern void APIENTRY glMultiTexCoord4iARB (GLenum, GLint, GLint, GLint,
      GLint);
   
extern void APIENTRY glMultiTexCoord4ivARB (GLenum, const GLint *);
-extern void APIENTRY glMultiTexCoord4sARB (GLenum, GLshort, GLshort, GLshort, GLshort);
+   
extern void APIENTRY glMultiTexCoord4sARB (GLenum, GLshort, GLshort,
      GLshort, GLshort);
   
extern void APIENTRY glMultiTexCoord4svARB (GLenum, const GLshort *);
 #endif				// GL_GLEXT_PROTOTYPES
 #else				// not _WIN32
  typedef void (APIENTRY * PFNGLACTIVETEXTUREARBPROC) (GLenum texture);
   
typedef void (APIENTRY * PFNGLCLIENTACTIVETEXTUREARBPROC) (GLenum texture);
-typedef void (APIENTRY * PFNGLMULTITEXCOORD1DARBPROC) (GLenum target, GLdouble s);
+   
typedef void (APIENTRY * PFNGLMULTITEXCOORD1DARBPROC) (GLenum target,
-typedef void (APIENTRY * PFNGLMULTITEXCOORD1DVARBPROC) (GLenum target, const GLdouble *v);
+      GLdouble s);
-typedef void (APIENTRY * PFNGLMULTITEXCOORD1FARBPROC) (GLenum target, GLfloat s);
+   
typedef void (APIENTRY * PFNGLMULTITEXCOORD1DVARBPROC) (GLenum target,
-typedef void (APIENTRY * PFNGLMULTITEXCOORD1FVARBPROC) (GLenum target, const GLfloat *v);
+      const GLdouble * v);
-typedef void (APIENTRY * PFNGLMULTITEXCOORD1IARBPROC) (GLenum target, GLint s);
+   
typedef void (APIENTRY * PFNGLMULTITEXCOORD1FARBPROC) (GLenum target,
-typedef void (APIENTRY * PFNGLMULTITEXCOORD1IVARBPROC) (GLenum target, const GLint *v);
+      GLfloat s);
-typedef void (APIENTRY * PFNGLMULTITEXCOORD1SARBPROC) (GLenum target, GLshort s);
+   
typedef void (APIENTRY * PFNGLMULTITEXCOORD1FVARBPROC) (GLenum target,
-typedef void (APIENTRY * PFNGLMULTITEXCOORD1SVARBPROC) (GLenum target, const GLshort *v);
+      const GLfloat * v);
-typedef void (APIENTRY * PFNGLMULTITEXCOORD2DARBPROC) (GLenum target, GLdouble s, GLdouble t);
+   
typedef void (APIENTRY * PFNGLMULTITEXCOORD1IARBPROC) (GLenum target,
-typedef void (APIENTRY * PFNGLMULTITEXCOORD2DVARBPROC) (GLenum target, const GLdouble *v);
+      GLint s);
-typedef void (APIENTRY * PFNGLMULTITEXCOORD2FARBPROC) (GLenum target, GLfloat s, GLfloat t);
+   
typedef void (APIENTRY * PFNGLMULTITEXCOORD1IVARBPROC) (GLenum target,
-typedef void (APIENTRY * PFNGLMULTITEXCOORD2FVARBPROC) (GLenum target, const GLfloat *v);
+      const GLint * v);
-typedef void (APIENTRY * PFNGLMULTITEXCOORD2IARBPROC) (GLenum target, GLint s, GLint t);
+   
typedef void (APIENTRY * PFNGLMULTITEXCOORD1SARBPROC) (GLenum target,
-typedef void (APIENTRY * PFNGLMULTITEXCOORD2IVARBPROC) (GLenum target, const GLint *v);
+      GLshort s);
-typedef void (APIENTRY * PFNGLMULTITEXCOORD2SARBPROC) (GLenum target, GLshort s, GLshort t);
+   
typedef void (APIENTRY * PFNGLMULTITEXCOORD1SVARBPROC) (GLenum target,
-typedef void (APIENTRY * PFNGLMULTITEXCOORD2SVARBPROC) (GLenum target, const GLshort *v);
+      const GLshort * v);
-typedef void (APIENTRY * PFNGLMULTITEXCOORD3DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r);
+   
typedef void (APIENTRY * PFNGLMULTITEXCOORD2DARBPROC) (GLenum target,
-typedef void (APIENTRY * PFNGLMULTITEXCOORD3DVARBPROC) (GLenum target, const GLdouble *v);
+      GLdouble s, GLdouble t);
-typedef void (APIENTRY * PFNGLMULTITEXCOORD3FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r);
+   
typedef void (APIENTRY * PFNGLMULTITEXCOORD2DVARBPROC) (GLenum target,
-typedef void (APIENTRY * PFNGLMULTITEXCOORD3FVARBPROC) (GLenum target, const GLfloat *v);
+      const GLdouble * v);
-typedef void (APIENTRY * PFNGLMULTITEXCOORD3IARBPROC) (GLenum target, GLint s, GLint t, GLint r);
+   
typedef void (APIENTRY * PFNGLMULTITEXCOORD2FARBPROC) (GLenum target,
-typedef void (APIENTRY * PFNGLMULTITEXCOORD3IVARBPROC) (GLenum target, const GLint *v);
+      GLfloat s, GLfloat t);
-typedef void (APIENTRY * PFNGLMULTITEXCOORD3SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r);
+   
typedef void (APIENTRY * PFNGLMULTITEXCOORD2FVARBPROC) (GLenum target,
-typedef void (APIENTRY * PFNGLMULTITEXCOORD3SVARBPROC) (GLenum target, const GLshort *v);
+      const GLfloat * v);
-typedef void (APIENTRY * PFNGLMULTITEXCOORD4DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+   
typedef void (APIENTRY * PFNGLMULTITEXCOORD2IARBPROC) (GLenum target,
-typedef void (APIENTRY * PFNGLMULTITEXCOORD4DVARBPROC) (GLenum target, const GLdouble *v);
+      GLint s, GLint t);
-typedef void (APIENTRY * PFNGLMULTITEXCOORD4FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+   
typedef void (APIENTRY * PFNGLMULTITEXCOORD2IVARBPROC) (GLenum target,
-typedef void (APIENTRY * PFNGLMULTITEXCOORD4FVARBPROC) (GLenum target, const GLfloat *v);
+      const GLint * v);
-typedef void (APIENTRY * PFNGLMULTITEXCOORD4IARBPROC) (GLenum target, GLint s, GLint t, GLint r, GLint q);
+   
typedef void (APIENTRY * PFNGLMULTITEXCOORD2SARBPROC) (GLenum target,
-typedef void (APIENTRY * PFNGLMULTITEXCOORD4IVARBPROC) (GLenum target, const GLint *v);
+      GLshort s, GLshort t);
-typedef void (APIENTRY * PFNGLMULTITEXCOORD4SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
+   
typedef void (APIENTRY * PFNGLMULTITEXCOORD2SVARBPROC) (GLenum target,
-typedef void (APIENTRY * PFNGLMULTITEXCOORD4SVARBPROC) (GLenum target, const GLshort *v);
+      const GLshort * v);
   
typedef void (APIENTRY * PFNGLMULTITEXCOORD3DARBPROC) (GLenum target,
      GLdouble s, GLdouble t, GLdouble r);
   
typedef void (APIENTRY * PFNGLMULTITEXCOORD3DVARBPROC) (GLenum target,
      const GLdouble * v);
   
typedef void (APIENTRY * PFNGLMULTITEXCOORD3FARBPROC) (GLenum target,
      GLfloat s, GLfloat t, GLfloat r);
   
typedef void (APIENTRY * PFNGLMULTITEXCOORD3FVARBPROC) (GLenum target,
      const GLfloat * v);
   
typedef void (APIENTRY * PFNGLMULTITEXCOORD3IARBPROC) (GLenum target,
      GLint s, GLint t, GLint r);
   
typedef void (APIENTRY * PFNGLMULTITEXCOORD3IVARBPROC) (GLenum target,
      const GLint * v);
   
typedef void (APIENTRY * PFNGLMULTITEXCOORD3SARBPROC) (GLenum target,
      GLshort s, GLshort t, GLshort r);
   
typedef void (APIENTRY * PFNGLMULTITEXCOORD3SVARBPROC) (GLenum target,
      const GLshort * v);
   
typedef void (APIENTRY * PFNGLMULTITEXCOORD4DARBPROC) (GLenum target,
      GLdouble s, GLdouble t, GLdouble r, GLdouble q);
   
typedef void (APIENTRY * PFNGLMULTITEXCOORD4DVARBPROC) (GLenum target,
      const GLdouble * v);
   
typedef void (APIENTRY * PFNGLMULTITEXCOORD4FARBPROC) (GLenum target,
      GLfloat s, GLfloat t, GLfloat r, GLfloat q);
   
typedef void (APIENTRY * PFNGLMULTITEXCOORD4FVARBPROC) (GLenum target,
      const GLfloat * v);
   
typedef void (APIENTRY * PFNGLMULTITEXCOORD4IARBPROC) (GLenum target,
      GLint s, GLint t, GLint r, GLint q);
   
typedef void (APIENTRY * PFNGLMULTITEXCOORD4IVARBPROC) (GLenum target,
      const GLint * v);
   
typedef void (APIENTRY * PFNGLMULTITEXCOORD4SARBPROC) (GLenum target,
      GLshort s, GLshort t, GLshort r, GLshort q);
   
typedef void (APIENTRY * PFNGLMULTITEXCOORD4SVARBPROC) (GLenum target,
      const GLshort * v);
 #endif				// _WIN32
 #ifdef ARB_MULTITEXTURE_INITIALIZE
@ -194,9 +235,10 @@ PFNGLMULTITEXCOORD4IARBPROC     glMultiTexCoord4iARB     = NULL;
   
PFNGLMULTITEXCOORD4IVARBPROC glMultiTexCoord4ivARB = NULL;
   
PFNGLMULTITEXCOORD4SARBPROC glMultiTexCoord4sARB = NULL;
   
PFNGLMULTITEXCOORD4SVARBPROC glMultiTexCoord4svARB = NULL;
 #endif // _WIN32 
-int CheckForARBMultitextureSupport(void) {
+#endif				// _WIN32 
   
int CheckForARBMultitextureSupport (void)
  {
    
const char search[] = "GL_ARB_multitexture";
     
int i, pos = 0;
     
int maxpos = strlen (search) - 1;
@ -205,14 +247,19 @@ int CheckForARBMultitextureSupport(void) {
     
strcpy (extensions, (const char *) glGetString (GL_EXTENSIONS));
     
printf ("Examinig GLstring\n");
     
int len = strlen (extensions);
-    for ( i=0; i<len; i++) {
+     
for (i = 0; i < len; i++)
    {
      
if ((i == 0) || ((i > 1) && extensions[i - 1] == ' ')) {
 	
pos = 0;
-            while(extensions[i]!=' ') {
+	
while (extensions[i] != ' ')
-                if (extensions[i]==search[pos]) pos++;
+	{
 	  
if (extensions[i] == search[pos])
 	    pos++;
 	  
if ((pos > maxpos) && extensions[i + 1] == ' ') {
 		//if (debug)
 	    {
 		  //fprintf(stderr, search);
 		  //fprintf(stderr, " supported.\n");
 	    }
@ -222,82 +269,222 @@ int CheckForARBMultitextureSupport(void) {
 	
}
      
}
    
}
 	//printf(search);
 	//printf(" not supported.\n");
 	return 0;
  
}
  

int GL_ARB_multitexture_Init (void)
  {
    
if (!CheckForARBMultitextureSupport ())
      return 0;
 int GL_ARB_multitexture_Init(void) {
    if (!CheckForARBMultitextureSupport()) return 0;
 #ifdef _WIN32
-    glActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC) wglGetProcAddress("glActiveTextureARB");
+	glActiveTextureARB =
-        if (glActiveTextureARB==NULL) {fprintf(stderr,"glActiveTextureARB not found.\n"); return 0; }
+	(PFNGLACTIVETEXTUREARBPROC) wglGetProcAddress ("glActiveTextureARB");
-    glClientActiveTextureARB = (PFNGLCLIENTACTIVETEXTUREARBPROC) wglGetProcAddress("glClientActiveTextureARB");
+    
if (glActiveTextureARB == NULL) {
-        if (glClientActiveTextureARB==NULL) {fprintf(stderr,"glClientActiveTextureARB not found.\n"); return 0; }
+      fprintf (stderr, "glActiveTextureARB not found.\n");
-    glMultiTexCoord1dARB = (PFNGLMULTITEXCOORD1DARBPROC) wglGetProcAddress("glMultiTexCoord1dARB");
+      return 0;
-        if (glMultiTexCoord1dARB==NULL) {fprintf(stderr,"glMultiTexCoord1dARB not found.\n"); return 0; }
+    }
-    glMultiTexCoord1dvARB = (PFNGLMULTITEXCOORD1DVARBPROC) wglGetProcAddress("glMultiTexCoord1dvARB");
+    
glClientActiveTextureARB = (PFNGLCLIENTACTIVETEXTUREARBPROC)
-        if (glMultiTexCoord1dvARB==NULL) {fprintf(stderr,"glMultiTexCoord1dAvRB not found.\n"); return 0; }
+	wglGetProcAddress ("glClientActiveTextureARB");
-    glMultiTexCoord1fARB = (PFNGLMULTITEXCOORD1FARBPROC) wglGetProcAddress("glMultiTexCoord1fARB");
+    
if (glClientActiveTextureARB == NULL) {
-        if (glMultiTexCoord1fARB==NULL) {fprintf(stderr,"glMultiTexCoord1fARB not found.\n"); return 0; }
+      fprintf (stderr, "glClientActiveTextureARB not found.\n");
-    glMultiTexCoord1fvARB = (PFNGLMULTITEXCOORD1FVARBPROC) wglGetProcAddress("glMultiTexCoord1fvARB");
+      return 0;
-        if (glMultiTexCoord1fvARB==NULL) {fprintf(stderr,"glMultiTexCoord1fvARB not found.\n"); return 0; }
+    }
-    glMultiTexCoord1iARB = (PFNGLMULTITEXCOORD1IARBPROC) wglGetProcAddress("glMultiTexCoord1iARB");
+    
glMultiTexCoord1dARB = (PFNGLMULTITEXCOORD1DARBPROC)
-        if (glMultiTexCoord1iARB==NULL) {fprintf(stderr,"glMultiTexCoord1iARB not found.\n"); return 0; }
+	wglGetProcAddress ("glMultiTexCoord1dARB");
-    glMultiTexCoord1ivARB = (PFNGLMULTITEXCOORD1IVARBPROC) wglGetProcAddress("glMultiTexCoord1ivARB");
+    
if (glMultiTexCoord1dARB == NULL) {
-        if (glMultiTexCoord1ivARB==NULL) {fprintf(stderr,"glMultiTexCoord1ivARB not found.\n"); return 0; }
+      fprintf (stderr, "glMultiTexCoord1dARB not found.\n");
-    glMultiTexCoord1sARB = (PFNGLMULTITEXCOORD1SARBPROC) wglGetProcAddress("glMultiTexCoord1sARB");
+      return 0;
-        if (glMultiTexCoord1sARB==NULL) {fprintf(stderr,"glMultiTexCoord1sARB not found.\n"); return 0; }
+    }
-    glMultiTexCoord1svARB = (PFNGLMULTITEXCOORD1SVARBPROC) wglGetProcAddress("glMultiTexCoord1svARB");
+    
glMultiTexCoord1dvARB = (PFNGLMULTITEXCOORD1DVARBPROC)
-        if (glMultiTexCoord1svARB==NULL) {fprintf(stderr,"glMultiTexCoord1svARB not found.\n"); return 0; }
+	wglGetProcAddress ("glMultiTexCoord1dvARB");
-    glMultiTexCoord2dARB = (PFNGLMULTITEXCOORD2DARBPROC) wglGetProcAddress("glMultiTexCoord2dARB");
+    
if (glMultiTexCoord1dvARB == NULL) {
-        if (glMultiTexCoord2dARB==NULL) {fprintf(stderr,"glMultiTexCoord2dARB not found.\n"); return 0; }
+      fprintf (stderr, "glMultiTexCoord1dAvRB not found.\n");
-    glMultiTexCoord2dvARB = (PFNGLMULTITEXCOORD2DVARBPROC) wglGetProcAddress("glMultiTexCoord2dvARB");
+      return 0;
-        if (glMultiTexCoord2dvARB==NULL) {fprintf(stderr,"glMultiTexCoord2dAvRB not found.\n"); return 0; }
+    }
-    glMultiTexCoord2fARB = (PFNGLMULTITEXCOORD2FARBPROC) wglGetProcAddress("glMultiTexCoord2fARB");
+    
glMultiTexCoord1fARB = (PFNGLMULTITEXCOORD1FARBPROC)
-        if (glMultiTexCoord2fARB==NULL) {fprintf(stderr,"glMultiTexCoord2fARB not found.\n"); return 0; }
+	wglGetProcAddress ("glMultiTexCoord1fARB");
-    glMultiTexCoord2fvARB = (PFNGLMULTITEXCOORD2FVARBPROC) wglGetProcAddress("glMultiTexCoord2fvARB");
+    
if (glMultiTexCoord1fARB == NULL) {
-        if (glMultiTexCoord2fvARB==NULL) {fprintf(stderr,"glMultiTexCoord2fvARB not found.\n"); return 0; }
+      fprintf (stderr, "glMultiTexCoord1fARB not found.\n");
-    glMultiTexCoord2iARB = (PFNGLMULTITEXCOORD2IARBPROC) wglGetProcAddress("glMultiTexCoord2iARB");
+      return 0;
-        if (glMultiTexCoord2iARB==NULL) {fprintf(stderr,"glMultiTexCoord2iARB not found.\n"); return 0; }
+    }
-    glMultiTexCoord2ivARB = (PFNGLMULTITEXCOORD2IVARBPROC) wglGetProcAddress("glMultiTexCoord2ivARB");
+    
glMultiTexCoord1fvARB = (PFNGLMULTITEXCOORD1FVARBPROC)
-        if (glMultiTexCoord2ivARB==NULL) {fprintf(stderr,"glMultiTexCoord2ivARB not found.\n"); return 0; }
+	wglGetProcAddress ("glMultiTexCoord1fvARB");
-    glMultiTexCoord2sARB = (PFNGLMULTITEXCOORD2SARBPROC) wglGetProcAddress("glMultiTexCoord2sARB");
+    
if (glMultiTexCoord1fvARB == NULL) {
-        if (glMultiTexCoord2sARB==NULL) {fprintf(stderr,"glMultiTexCoord2sARB not found.\n"); return 0; }
+      fprintf (stderr, "glMultiTexCoord1fvARB not found.\n");
-    glMultiTexCoord2svARB = (PFNGLMULTITEXCOORD2SVARBPROC) wglGetProcAddress("glMultiTexCoord2svARB");
+      return 0;
-        if (glMultiTexCoord2svARB==NULL) {fprintf(stderr,"glMultiTexCoord2svARB not found.\n"); return 0; }
+    }
-    glMultiTexCoord3dARB = (PFNGLMULTITEXCOORD3DARBPROC) wglGetProcAddress("glMultiTexCoord3dARB");
+    
glMultiTexCoord1iARB = (PFNGLMULTITEXCOORD1IARBPROC)
-        if (glMultiTexCoord3dARB==NULL) {fprintf(stderr,"glMultiTexCoord3dARB not found.\n"); return 0; }
+	wglGetProcAddress ("glMultiTexCoord1iARB");
-    glMultiTexCoord3dvARB = (PFNGLMULTITEXCOORD3DVARBPROC) wglGetProcAddress("glMultiTexCoord3dvARB");
+    
if (glMultiTexCoord1iARB == NULL) {
-        if (glMultiTexCoord3dvARB==NULL) {fprintf(stderr,"glMultiTexCoord3dAvRB not found.\n"); return 0; }
+      fprintf (stderr, "glMultiTexCoord1iARB not found.\n");
-    glMultiTexCoord3fARB = (PFNGLMULTITEXCOORD3FARBPROC) wglGetProcAddress("glMultiTexCoord3fARB");
+      return 0;
-        if (glMultiTexCoord3fARB==NULL) {fprintf(stderr,"glMultiTexCoord3fARB not found.\n"); return 0; }
+    }
-    glMultiTexCoord3fvARB = (PFNGLMULTITEXCOORD3FVARBPROC) wglGetProcAddress("glMultiTexCoord3fvARB");
+    
glMultiTexCoord1ivARB = (PFNGLMULTITEXCOORD1IVARBPROC)
-        if (glMultiTexCoord3fvARB==NULL) {fprintf(stderr,"glMultiTexCoord3fvARB not found.\n"); return 0; }
+	wglGetProcAddress ("glMultiTexCoord1ivARB");
-    glMultiTexCoord3iARB = (PFNGLMULTITEXCOORD3IARBPROC) wglGetProcAddress("glMultiTexCoord3iARB");
+    
if (glMultiTexCoord1ivARB == NULL) {
-        if (glMultiTexCoord3iARB==NULL) {fprintf(stderr,"glMultiTexCoord3iARB not found.\n"); return 0; }
+      fprintf (stderr, "glMultiTexCoord1ivARB not found.\n");
-    glMultiTexCoord3ivARB = (PFNGLMULTITEXCOORD3IVARBPROC) wglGetProcAddress("glMultiTexCoord3ivARB");
+      return 0;
-        if (glMultiTexCoord3ivARB==NULL) {fprintf(stderr,"glMultiTexCoord3ivARB not found.\n"); return 0; }
+    }
-    glMultiTexCoord3sARB = (PFNGLMULTITEXCOORD3SARBPROC) wglGetProcAddress("glMultiTexCoord3sARB");
+    
glMultiTexCoord1sARB = (PFNGLMULTITEXCOORD1SARBPROC)
-        if (glMultiTexCoord3sARB==NULL) {fprintf(stderr,"glMultiTexCoord3sARB not found.\n"); return 0; }
+	wglGetProcAddress ("glMultiTexCoord1sARB");
-    glMultiTexCoord3svARB = (PFNGLMULTITEXCOORD3SVARBPROC) wglGetProcAddress("glMultiTexCoord3svARB");
+    
if (glMultiTexCoord1sARB == NULL) {
-        if (glMultiTexCoord3svARB==NULL) {fprintf(stderr,"glMultiTexCoord3svARB not found.\n"); return 0; }
+      fprintf (stderr, "glMultiTexCoord1sARB not found.\n");
-    glMultiTexCoord4dARB = (PFNGLMULTITEXCOORD4DARBPROC) wglGetProcAddress("glMultiTexCoord4dARB");
+      return 0;
-        if (glMultiTexCoord4dARB==NULL) {fprintf(stderr,"glMultiTexCoord4dARB not found.\n"); return 0; }
+    }
-    glMultiTexCoord4dvARB = (PFNGLMULTITEXCOORD4DVARBPROC) wglGetProcAddress("glMultiTexCoord4dvARB");
+    
glMultiTexCoord1svARB = (PFNGLMULTITEXCOORD1SVARBPROC)
-        if (glMultiTexCoord4dvARB==NULL) {fprintf(stderr,"glMultiTexCoord4dAvRB not found.\n"); return 0; }
+	wglGetProcAddress ("glMultiTexCoord1svARB");
-    glMultiTexCoord4fARB = (PFNGLMULTITEXCOORD4FARBPROC) wglGetProcAddress("glMultiTexCoord4fARB");
+    
if (glMultiTexCoord1svARB == NULL) {
-        if (glMultiTexCoord4fARB==NULL) {fprintf(stderr,"glMultiTexCoord4fARB not found.\n"); return 0; }
+      fprintf (stderr, "glMultiTexCoord1svARB not found.\n");
-    glMultiTexCoord4fvARB = (PFNGLMULTITEXCOORD4FVARBPROC) wglGetProcAddress("glMultiTexCoord4fvARB");
+      return 0;
-        if (glMultiTexCoord4fvARB==NULL) {fprintf(stderr,"glMultiTexCoord4fvARB not found.\n"); return 0; }
+    }
-    glMultiTexCoord4iARB = (PFNGLMULTITEXCOORD4IARBPROC) wglGetProcAddress("glMultiTexCoord4iARB");
+    
glMultiTexCoord2dARB = (PFNGLMULTITEXCOORD2DARBPROC)
-        if (glMultiTexCoord4iARB==NULL) {fprintf(stderr,"glMultiTexCoord4iARB not found.\n"); return 0; }
+	wglGetProcAddress ("glMultiTexCoord2dARB");
-    glMultiTexCoord4ivARB = (PFNGLMULTITEXCOORD4IVARBPROC) wglGetProcAddress("glMultiTexCoord4ivARB");
+    
if (glMultiTexCoord2dARB == NULL) {
-        if (glMultiTexCoord4ivARB==NULL) {fprintf(stderr,"glMultiTexCoord4ivARB not found.\n"); return 0; }
+      fprintf (stderr, "glMultiTexCoord2dARB not found.\n");
-    glMultiTexCoord4sARB = (PFNGLMULTITEXCOORD4SARBPROC) wglGetProcAddress("glMultiTexCoord4sARB");
+      return 0;
-        if (glMultiTexCoord4sARB==NULL) {fprintf(stderr,"glMultiTexCoord4sARB not found.\n"); return 0; }
+    }
-    glMultiTexCoord4svARB = (PFNGLMULTITEXCOORD4SVARBPROC) wglGetProcAddress("glMultiTexCoord4svARB");
+    
glMultiTexCoord2dvARB = (PFNGLMULTITEXCOORD2DVARBPROC)
-        if (glMultiTexCoord4svARB==NULL) {fprintf(stderr,"glMultiTexCoord4svARB not found.\n"); return 0; }
+	wglGetProcAddress ("glMultiTexCoord2dvARB");
    
if (glMultiTexCoord2dvARB == NULL) {
      fprintf (stderr, "glMultiTexCoord2dAvRB not found.\n");
      return 0;
    }
    
glMultiTexCoord2fARB = (PFNGLMULTITEXCOORD2FARBPROC)
 	wglGetProcAddress ("glMultiTexCoord2fARB");
    
if (glMultiTexCoord2fARB == NULL) {
      fprintf (stderr, "glMultiTexCoord2fARB not found.\n");
      return 0;
    }
    
glMultiTexCoord2fvARB = (PFNGLMULTITEXCOORD2FVARBPROC)
 	wglGetProcAddress ("glMultiTexCoord2fvARB");
    
if (glMultiTexCoord2fvARB == NULL) {
      fprintf (stderr, "glMultiTexCoord2fvARB not found.\n");
      return 0;
    }
    
glMultiTexCoord2iARB = (PFNGLMULTITEXCOORD2IARBPROC)
 	wglGetProcAddress ("glMultiTexCoord2iARB");
    
if (glMultiTexCoord2iARB == NULL) {
      fprintf (stderr, "glMultiTexCoord2iARB not found.\n");
      return 0;
    }
    
glMultiTexCoord2ivARB = (PFNGLMULTITEXCOORD2IVARBPROC)
 	wglGetProcAddress ("glMultiTexCoord2ivARB");
    
if (glMultiTexCoord2ivARB == NULL) {
      fprintf (stderr, "glMultiTexCoord2ivARB not found.\n");
      return 0;
    }
    
glMultiTexCoord2sARB = (PFNGLMULTITEXCOORD2SARBPROC)
 	wglGetProcAddress ("glMultiTexCoord2sARB");
    
if (glMultiTexCoord2sARB == NULL) {
      fprintf (stderr, "glMultiTexCoord2sARB not found.\n");
      return 0;
    }
    
glMultiTexCoord2svARB = (PFNGLMULTITEXCOORD2SVARBPROC)
 	wglGetProcAddress ("glMultiTexCoord2svARB");
    
if (glMultiTexCoord2svARB == NULL) {
      fprintf (stderr, "glMultiTexCoord2svARB not found.\n");
      return 0;
    }
    
glMultiTexCoord3dARB = (PFNGLMULTITEXCOORD3DARBPROC)
 	wglGetProcAddress ("glMultiTexCoord3dARB");
    
if (glMultiTexCoord3dARB == NULL) {
      fprintf (stderr, "glMultiTexCoord3dARB not found.\n");
      return 0;
    }
    
glMultiTexCoord3dvARB = (PFNGLMULTITEXCOORD3DVARBPROC)
 	wglGetProcAddress ("glMultiTexCoord3dvARB");
    
if (glMultiTexCoord3dvARB == NULL) {
      fprintf (stderr, "glMultiTexCoord3dAvRB not found.\n");
      return 0;
    }
    
glMultiTexCoord3fARB = (PFNGLMULTITEXCOORD3FARBPROC)
 	wglGetProcAddress ("glMultiTexCoord3fARB");
    
if (glMultiTexCoord3fARB == NULL) {
      fprintf (stderr, "glMultiTexCoord3fARB not found.\n");
      return 0;
    }
    
glMultiTexCoord3fvARB = (PFNGLMULTITEXCOORD3FVARBPROC)
 	wglGetProcAddress ("glMultiTexCoord3fvARB");
    
if (glMultiTexCoord3fvARB == NULL) {
      fprintf (stderr, "glMultiTexCoord3fvARB not found.\n");
      return 0;
    }
    
glMultiTexCoord3iARB = (PFNGLMULTITEXCOORD3IARBPROC)
 	wglGetProcAddress ("glMultiTexCoord3iARB");
    
if (glMultiTexCoord3iARB == NULL) {
      fprintf (stderr, "glMultiTexCoord3iARB not found.\n");
      return 0;
    }
    
glMultiTexCoord3ivARB = (PFNGLMULTITEXCOORD3IVARBPROC)
 	wglGetProcAddress ("glMultiTexCoord3ivARB");
    
if (glMultiTexCoord3ivARB == NULL) {
      fprintf (stderr, "glMultiTexCoord3ivARB not found.\n");
      return 0;
    }
    
glMultiTexCoord3sARB = (PFNGLMULTITEXCOORD3SARBPROC)
 	wglGetProcAddress ("glMultiTexCoord3sARB");
    
if (glMultiTexCoord3sARB == NULL) {
      fprintf (stderr, "glMultiTexCoord3sARB not found.\n");
      return 0;
    }
    
glMultiTexCoord3svARB = (PFNGLMULTITEXCOORD3SVARBPROC)
 	wglGetProcAddress ("glMultiTexCoord3svARB");
    
if (glMultiTexCoord3svARB == NULL) {
      fprintf (stderr, "glMultiTexCoord3svARB not found.\n");
      return 0;
    }
    
glMultiTexCoord4dARB = (PFNGLMULTITEXCOORD4DARBPROC)
 	wglGetProcAddress ("glMultiTexCoord4dARB");
    
if (glMultiTexCoord4dARB == NULL) {
      fprintf (stderr, "glMultiTexCoord4dARB not found.\n");
      return 0;
    }
    
glMultiTexCoord4dvARB = (PFNGLMULTITEXCOORD4DVARBPROC)
 	wglGetProcAddress ("glMultiTexCoord4dvARB");
    
if (glMultiTexCoord4dvARB == NULL) {
      fprintf (stderr, "glMultiTexCoord4dAvRB not found.\n");
      return 0;
    }
    
glMultiTexCoord4fARB = (PFNGLMULTITEXCOORD4FARBPROC)
 	wglGetProcAddress ("glMultiTexCoord4fARB");
    
if (glMultiTexCoord4fARB == NULL) {
      fprintf (stderr, "glMultiTexCoord4fARB not found.\n");
      return 0;
    }
    
glMultiTexCoord4fvARB = (PFNGLMULTITEXCOORD4FVARBPROC)
 	wglGetProcAddress ("glMultiTexCoord4fvARB");
    
if (glMultiTexCoord4fvARB == NULL) {
      fprintf (stderr, "glMultiTexCoord4fvARB not found.\n");
      return 0;
    }
    
glMultiTexCoord4iARB = (PFNGLMULTITEXCOORD4IARBPROC)
 	wglGetProcAddress ("glMultiTexCoord4iARB");
    
if (glMultiTexCoord4iARB == NULL) {
      fprintf (stderr, "glMultiTexCoord4iARB not found.\n");
      return 0;
    }
    
glMultiTexCoord4ivARB = (PFNGLMULTITEXCOORD4IVARBPROC)
 	wglGetProcAddress ("glMultiTexCoord4ivARB");
    
if (glMultiTexCoord4ivARB == NULL) {
      fprintf (stderr, "glMultiTexCoord4ivARB not found.\n");
      return 0;
    }
    
glMultiTexCoord4sARB = (PFNGLMULTITEXCOORD4SARBPROC)
 	wglGetProcAddress ("glMultiTexCoord4sARB");
    
if (glMultiTexCoord4sARB == NULL) {
      fprintf (stderr, "glMultiTexCoord4sARB not found.\n");
      return 0;
    }
    
glMultiTexCoord4svARB = (PFNGLMULTITEXCOORD4SVARBPROC)
 	wglGetProcAddress ("glMultiTexCoord4svARB");
    
if (glMultiTexCoord4svARB == NULL) {
      fprintf (stderr, "glMultiTexCoord4svARB not found.\n");
      return 0;
    }
 #endif // _WIN32
 	return 1;
  
}
@ -306,6 +493,8 @@ int GL_ARB_multitexture_Init(void) {
 #ifdef __cplusplus
 }
-#endif
+
 #endif /* 
 */
 #endif // not __ARB_MULTITEXTURE_H_
--- a/gst/gl/EXT_paletted_texture.h
+++ b/gst/gl/EXT_paletted_texture.h
@ -19,26 +19,26 @@
 #define EXT_PALETTED_TEXTURE_INITIALIZE 1	// enable generic init-routines
 #ifndef _WIN32
 #define GL_GLEXT_PROTOTYPES 1
-#endif
+#endif /* 
 */
 #ifdef __cplusplus
-extern "C" {
+extern "C"
-#endif
+{
 #endif				/* 
 */
 #if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__)
 #define WIN32_LEAN_AND_MEAN 1
 #include <windows.h>
-#endif
+#endif				/* 
 */
 #ifndef APIENTRY
 #define APIENTRY
-#endif
+#endif				/* 
 */
 // Header file version number, required by OpenGL ABI for Linux
 //#define GL_GLEXT_VERSION 7
 /* 
 * NEW TOKENS TO OPENGL 1.2.1 
 *
@ -60,22 +60,37 @@ extern "C" {
 #define GL_COLOR_TABLE_INTENSITY_SIZE_EXT 0x80DF
 #define GL_TEXTURE_INDEX_SIZE_EXT         0x80ED
 #define GL_EXT_paletted_texture 1
-#endif
+#endif				/* 
 */
 #ifndef _WIN32
 #ifdef GL_GLEXT_PROTOTYPES
-extern void APIENTRY glColorTableEXT   (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *); 
+  extern void APIENTRY glColorTableEXT (GLenum, GLenum, GLsizei, GLenum, GLenum,
-extern void APIENTRY glColorSubTableEXT(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *); 
+      const GLvoid *);
   
extern void APIENTRY glColorSubTableEXT (GLenum, GLsizei, GLsizei, GLenum,
      GLenum, const GLvoid *);
   
extern void APIENTRY glGetColorTableEXT (GLenum, GLenum, GLenum, GLvoid *);
-extern void APIENTRY glGetColorTableParameterivEXT(GLenum, GLenum, GLint *);
+   
extern void APIENTRY glGetColorTableParameterivEXT (GLenum, GLenum,
-extern void APIENTRY glGetColorTableParameterfvEXT(GLenum, GLenum, GLfloat *);
+      GLint *);
   
extern void APIENTRY glGetColorTableParameterfvEXT (GLenum, GLenum,
      GLfloat *);
 #endif				// GL_GLEXT_PROTOTYPES 
 #else				// _WIN32
-typedef void (APIENTRY * PFNGLCOLORTABLEEXTPROC)   (GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const GLvoid *data); 
+  typedef void (APIENTRY * PFNGLCOLORTABLEEXTPROC) (GLenum target,
-typedef void (APIENTRY * PFNGLCOLORSUBTABLEEXTPROC)(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data);
+      GLenum internalFormat, GLsizei width, GLenum format, GLenum type,
-typedef void (APIENTRY * PFNGLGETCOLORTABLEEXTPROC)(GLenum target, GLenum format, GLenum type, GLvoid *data);
+      const GLvoid * data);
-typedef void (APIENTRY * PFNGLGETCOLORTABLEPARAMETERIVEXTPROC)(GLenum target, GLenum pname, GLint *params); 
+   
typedef void (APIENTRY * PFNGLCOLORSUBTABLEEXTPROC) (GLenum target,
-typedef void (APIENTRY * PFNGLGETCOLORTABLEPARAMETERFVEXTPROC)(GLenum target, GLenum pname, GLfloat *params);
+      GLsizei start, GLsizei count, GLenum format, GLenum type,
      const GLvoid * data);
   
typedef void (APIENTRY * PFNGLGETCOLORTABLEEXTPROC) (GLenum target,
      GLenum format, GLenum type, GLvoid * data);
   
typedef void (APIENTRY *
      PFNGLGETCOLORTABLEPARAMETERIVEXTPROC) (GLenum target, GLenum pname,
      GLint * params);
   
typedef void (APIENTRY *
      PFNGLGETCOLORTABLEPARAMETERFVEXTPROC) (GLenum target, GLenum pname,
      GLfloat * params);
 #endif				// not _WIN32
 #ifdef EXT_PALETTED_TEXTURE_INITIALIZE
@ -87,21 +102,26 @@ PFNGLCOLORSUBTABLEEXTPROC            glColorSubTableEXT = NULL;
   
PFNGLGETCOLORTABLEEXTPROC glGetColorTableEXT = NULL;
   
PFNGLGETCOLORTABLEPARAMETERIVEXTPROC glGetColorTableParameterivEXT = NULL;
   
PFNGLGETCOLORTABLEPARAMETERFVEXTPROC glGetColorTableParameterfvEXT = NULL;
 #endif // _WIN32
-int CheckForEXTPalettedTextureSupport(void) {
+#endif				// _WIN32
   
int CheckForEXTPalettedTextureSupport (void)
  {
    
const char search[] = "GL_EXT_paletted_texture";
     
int i, pos = 0;
     
int maxpos = strlen (search) - 1;
     
char extensions[10000];
     
strcpy (extensions, (const char *) glGetString (GL_EXTENSIONS));
     
int len = strlen (extensions);
-    for (i=0; i<len; i++) {
+     
for (i = 0; i < len; i++)
    {
      
if ((i == 0) || ((i > 1) && extensions[i - 1] == ' ')) {
 	
pos = 0;
-            while(extensions[i]!=' ') {
+	
while (extensions[i] != ' ')
-                if (extensions[i]==search[pos]) pos++;
+	{
 	  
if (extensions[i] == search[pos])
 	    pos++;
 	  
if ((pos > maxpos) && extensions[i + 1] == ' ') {
 		//printf(search);
 		//printf(" supported.\n");
 		return 1;
@ -110,25 +130,48 @@ int CheckForEXTPalettedTextureSupport(void) {
 	
}
      
}
    
}
 	//printf(search);
 	//printf(" not supported.\n");
 	return 0;
  
}
-
+  

int GL_EXT_paletted_texture_Init (void)
-int GL_EXT_paletted_texture_Init(void) {
+  {
-    if (!CheckForEXTPalettedTextureSupport()) return 0;
+    
if (!CheckForEXTPalettedTextureSupport ())
      return 0;
 #ifdef _WIN32
-    glColorTableEXT = (PFNGLCOLORTABLEEXTPROC) wglGetProcAddress("glColorTableEXT");
+	glColorTableEXT =
-        if (glColorTableEXT==NULL) {fprintf(stderr,"glColorTableEXT not found.\n"); return 0;}
+	(PFNGLCOLORTABLEEXTPROC) wglGetProcAddress ("glColorTableEXT");
-    glColorSubTableEXT = (PFNGLCOLORSUBTABLEEXTPROC) wglGetProcAddress("glColorSubTableEXT");
+    
if (glColorTableEXT == NULL) {
-        if (glColorSubTableEXT==NULL) {fprintf(stderr,"glColorSubTableEXT not found.\n"); return 0;}
+      fprintf (stderr, "glColorTableEXT not found.\n");
-    glGetColorTableEXT = (PFNGLGETCOLORTABLEEXTPROC) wglGetProcAddress("glGetColorTableEXT");
+      return 0;
-        if (glGetColorTableEXT==NULL) {fprintf(stderr,"glGetColorTableEXT not found.\n"); return 0;}
+    }
-    glGetColorTableParameterivEXT = (PFNGLGETCOLORTABLEPARAMETERIVEXTPROC) wglGetProcAddress("glGetColorTableParameterivEXT");
+    
glColorSubTableEXT =
-        if (glGetColorTableParameterivEXT==NULL) {fprintf(stderr,"glGetColorTableParameterivEXT not found.\n"); return 0;}
+	(PFNGLCOLORSUBTABLEEXTPROC) wglGetProcAddress ("glColorSubTableEXT");
-    glGetColorTableParameterfvEXT = (PFNGLGETCOLORTABLEPARAMETERFVEXTPROC) wglGetProcAddress("glGetColorTableParameterfvEXT");
+    
if (glColorSubTableEXT == NULL) {
-        if (glGetColorTableParameterfvEXT==NULL) {fprintf(stderr,"glGetColorTableParameterfvEXT not found.\n"); return 0;}
+      fprintf (stderr, "glColorSubTableEXT not found.\n");
      return 0;
    }
    
glGetColorTableEXT =
 	(PFNGLGETCOLORTABLEEXTPROC) wglGetProcAddress ("glGetColorTableEXT");
    
if (glGetColorTableEXT == NULL) {
      fprintf (stderr, "glGetColorTableEXT not found.\n");
      return 0;
    }
    
glGetColorTableParameterivEXT = (PFNGLGETCOLORTABLEPARAMETERIVEXTPROC)
 	wglGetProcAddress ("glGetColorTableParameterivEXT");
    
if (glGetColorTableParameterivEXT == NULL) {
      fprintf (stderr, "glGetColorTableParameterivEXT not found.\n");
      return 0;
    }
    
glGetColorTableParameterfvEXT = (PFNGLGETCOLORTABLEPARAMETERFVEXTPROC)
 	wglGetProcAddress ("glGetColorTableParameterfvEXT");
    
if (glGetColorTableParameterfvEXT == NULL) {
      fprintf (stderr, "glGetColorTableParameterfvEXT not found.\n");
      return 0;
    }
 #endif // _WIN32
 	return 1;
  
}
@ -137,6 +180,8 @@ int GL_EXT_paletted_texture_Init(void) {
 #ifdef __cplusplus
 }
-#endif
+
 #endif /* 
 */
 #endif // not __EXT_PALETTED_TEXTURE_H_
--- a/gst/gl/NV_register_combiners.h
+++ b/gst/gl/NV_register_combiners.h
@ -19,26 +19,26 @@
 #define NV_REGISTER_COMBINERS_INITIALIZE 1	// enable generic init-routines
 #ifndef _WIN32
 #define GL_GLEXT_PROTOTYPES 1
-#endif
+#endif /* 
 */
 #ifdef __cplusplus
-extern "C" {
+extern "C"
-#endif
+{
 #endif				/* 
 */
 #if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__)
 #define WIN32_LEAN_AND_MEAN 1
 #include <windows.h>
-#endif
+#endif				/* 
 */
 #ifndef APIENTRY
 #define APIENTRY
-#endif
+#endif				/* 
 */
 // Header file version number, required by OpenGL ABI for Linux
 //#define GL_GLEXT_VERSION 7
 /* 
 * NEW TOKENS TO OPENGL 1.2.1 
 *
@ -96,7 +96,7 @@ extern "C" {
 #define GL_COLOR_SUM_CLAMP_NV             0x854F
 #define GL_MAX_GENERAL_COMBINERS_NV       0x854D
 #define GL_NV_register_combiners 1
-#endif
+#endif				/* 
 */
 #ifndef _WIN32
 #ifdef GL_GLEXT_PROTOTYPES
@ -104,30 +104,63 @@ extern void APIENTRY glCombinerParameterfvNV(GLenum, const GLfloat *);
   
extern void APIENTRY glCombinerParameterivNV (GLenum, const GLint *);
   
extern void APIENTRY glCombinerParameterfNV (GLenum, GLfloat);
   
extern void APIENTRY glCombinerParameteriNV (GLenum, GLint);
-extern void APIENTRY glCombinerInputNV      (GLenum, GLenum, GLenum, GLenum, GLenum, GLenum); 
+   
extern void APIENTRY glCombinerInputNV (GLenum, GLenum, GLenum, GLenum,
-extern void APIENTRY glCombinerOutputNV     (GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLboolean, GLboolean, GLboolean); 
+      GLenum, GLenum);
-extern void APIENTRY glFinalCombinerInputNV (GLenum, GLenum, GLenum, GLenum); 
+   
extern void APIENTRY glCombinerOutputNV (GLenum, GLenum, GLenum, GLenum,
-extern void APIENTRY glGetCombinerInputParameterfvNV (GLenum, GLenum, GLenum, GLenum, GLfloat *); 
+      GLenum, GLenum, GLenum, GLboolean, GLboolean, GLboolean);
-extern void APIENTRY glGetCombinerInputParameterivNV (GLenum, GLenum, GLenum, GLenum, GLint *); 
+   
extern void APIENTRY glFinalCombinerInputNV (GLenum, GLenum, GLenum,
-extern void APIENTRY glGetCombinerOutputParameterfvNV(GLenum, GLenum, GLenum, GLfloat *); 
+      GLenum);
-extern void APIENTRY glGetCombinerOutputParameterivNV(GLenum, GLenum, GLenum, GLint *);
+   
extern void APIENTRY glGetCombinerInputParameterfvNV (GLenum, GLenum,
-extern void APIENTRY glGetFinalCombinerInputParameterfvNV(GLenum, GLenum, GLfloat *); 
+      GLenum, GLenum, GLfloat *);
-extern void APIENTRY glGetFinalCombinerInputParameterivNV(GLenum, GLenum, GLint *);
+   
extern void APIENTRY glGetCombinerInputParameterivNV (GLenum, GLenum,
      GLenum, GLenum, GLint *);
   
extern void APIENTRY glGetCombinerOutputParameterfvNV (GLenum, GLenum,
      GLenum, GLfloat *);
   
extern void APIENTRY glGetCombinerOutputParameterivNV (GLenum, GLenum,
      GLenum, GLint *);
   
extern void APIENTRY glGetFinalCombinerInputParameterfvNV (GLenum, GLenum,
      GLfloat *);
   
extern void APIENTRY glGetFinalCombinerInputParameterivNV (GLenum, GLenum,
      GLint *);
 #endif				// GL_GLEXT_PROTOTYPES 
 #else				// _WIN32
-typedef void (APIENTRY * PFNGLCOMBINERPARAMETERFVNVPROC) (GLenum pname, const GLfloat *params);
+  typedef void (APIENTRY * PFNGLCOMBINERPARAMETERFVNVPROC) (GLenum pname,
-typedef void (APIENTRY * PFNGLCOMBINERPARAMETERIVNVPROC) (GLenum pname, const GLint *params); 
+      const GLfloat * params);
-typedef void (APIENTRY * PFNGLCOMBINERPARAMETERFNVPROC)  (GLenum pname, GLfloat param); 
+   
typedef void (APIENTRY * PFNGLCOMBINERPARAMETERIVNVPROC) (GLenum pname,
-typedef void (APIENTRY * PFNGLCOMBINERPARAMETERINVPROC)  (GLenum pname, GLint param); 
+      const GLint * params);
-typedef void (APIENTRY * PFNGLCOMBINERINPUTNVPROC)       (GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage); 
+   
typedef void (APIENTRY * PFNGLCOMBINERPARAMETERFNVPROC) (GLenum pname,
-typedef void (APIENTRY * PFNGLCOMBINEROUTPUTNVPROC)      (GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum); 
+      GLfloat param);
-typedef void (APIENTRY * PFNGLFINALCOMBINERINPUTNVPROC)  (GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage); 
+   
typedef void (APIENTRY * PFNGLCOMBINERPARAMETERINVPROC) (GLenum pname,
-typedef void (APIENTRY * PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat *params); 
+      GLint param);
-typedef void (APIENTRY * PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint *params); 
+   
typedef void (APIENTRY * PFNGLCOMBINERINPUTNVPROC) (GLenum stage,
-typedef void (APIENTRY * PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC)(GLenum stage, GLenum portion, GLenum pname, GLfloat *params); 
+      GLenum portion, GLenum variable, GLenum input, GLenum mapping,
-typedef void (APIENTRY * PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC)(GLenum stage, GLenum portion, GLenum pname, GLint *params);
+      GLenum componentUsage);
-typedef void (APIENTRY * PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC)(GLenum variable, GLenum pname, GLfloat *params); 
+   
typedef void (APIENTRY * PFNGLCOMBINEROUTPUTNVPROC) (GLenum stage,
-typedef void (APIENTRY * PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC)(GLenum variable, GLenum pname, GLint *params);
+      GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput,
      GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct,
      GLboolean muxSum);
   
typedef void (APIENTRY * PFNGLFINALCOMBINERINPUTNVPROC) (GLenum variable,
      GLenum input, GLenum mapping, GLenum componentUsage);
   
typedef void (APIENTRY *
      PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC) (GLenum stage, GLenum portion,
      GLenum variable, GLenum pname, GLfloat * params);
   
typedef void (APIENTRY *
      PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC) (GLenum stage, GLenum portion,
      GLenum variable, GLenum pname, GLint * params);
   
typedef void (APIENTRY *
      PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC) (GLenum stage, GLenum portion,
      GLenum pname, GLfloat * params);
   
typedef void (APIENTRY *
      PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC) (GLenum stage, GLenum portion,
      GLenum pname, GLint * params);
   
typedef void (APIENTRY *
      PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC) (GLenum variable,
      GLenum pname, GLfloat * params);
   
typedef void (APIENTRY *
      PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC) (GLenum variable,
      GLenum pname, GLint * params);
 #endif				// not _WIN32
 #ifdef NV_REGISTER_COMBINERS_INITIALIZE
@ -141,27 +174,38 @@ PFNGLCOMBINERPARAMETERINVPROC               glCombinerParameteriNV
   
PFNGLCOMBINERINPUTNVPROC glCombinerInputNV = NULL;
   
PFNGLCOMBINEROUTPUTNVPROC glCombinerOutputNV = NULL;
   
PFNGLFINALCOMBINERINPUTNVPROC glFinalCombinerInputNV = NULL;
-PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC      glGetCombinerInputParameterfvNV      = NULL;
+   
PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC glGetCombinerInputParameterfvNV =
-PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC      glGetCombinerInputParameterivNV      = NULL;
+      NULL;
-PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC     glGetCombinerOutputParameterfvNV     = NULL;
+   
PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC glGetCombinerInputParameterivNV =
-PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC     glGetCombinerOutputParameterivNV     = NULL;
+      NULL;
-PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC glGetFinalCombinerInputParameterfvNV = NULL;
+   
PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC glGetCombinerOutputParameterfvNV =
-PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC glGetFinalCombinerInputParameterivNV = NULL;
+      NULL;
-#endif // _WIN32
+   
PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC glGetCombinerOutputParameterivNV =
      NULL;
   
PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC
      glGetFinalCombinerInputParameterfvNV = NULL;
   
PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC
      glGetFinalCombinerInputParameterivNV = NULL;
-int CheckForNVRegisterCombinersSupport(void) {
+#endif				// _WIN32
   
int CheckForNVRegisterCombinersSupport (void)
  {
    
const char search[] = "GL_NV_register_combiners";
     
int i, pos = 0;
     
int maxpos = strlen (search) - 1;
     
char extensions[10000];
     
strcpy (extensions, (const char *) glGetString (GL_EXTENSIONS));
     
int len = strlen (extensions);
-    for (i=0; i<len; i++) {
+     
for (i = 0; i < len; i++)
    {
      
if ((i == 0) || ((i > 1) && extensions[i - 1] == ' ')) {
 	
pos = 0;
-             while(extensions[i]!=' ') {
+	
while (extensions[i] != ' ')
-                if (extensions[i]==search[pos]) pos++;
+	{
 	  
if (extensions[i] == search[pos])
 	    pos++;
 	  
if ((pos > maxpos) && extensions[i + 1] == ' ') {
 		//printf(search);
 		//  printf(" supported.\n");
 		return 1;
@ -170,41 +214,100 @@ int CheckForNVRegisterCombinersSupport(void) {
 	
}
      
}
    
}
 	//printf(search);
 	//printf(" not supported.\n");
 	return 0;
  
}
-
+  

int GL_NV_register_combiners_Init (void)
-int GL_NV_register_combiners_Init(void) {
+  {
-    if (!CheckForNVRegisterCombinersSupport()) return 0;
+    
if (!CheckForNVRegisterCombinersSupport ())
      return 0;
 #ifdef _WIN32
-    glCombinerParameterfvNV=(PFNGLCOMBINERPARAMETERFVNVPROC) wglGetProcAddress("glCombinerParameterfvNV");
+	glCombinerParameterfvNV = (PFNGLCOMBINERPARAMETERFVNVPROC)
-        if (glCombinerParameterfvNV==NULL) {fprintf(stderr,"glCombinerParameterfvNV not found.\n"); return 0;}
+	wglGetProcAddress ("glCombinerParameterfvNV");
-    glCombinerParameterivNV=(PFNGLCOMBINERPARAMETERIVNVPROC) wglGetProcAddress("glCombinerParameterivNV");
+    
if (glCombinerParameterfvNV == NULL) {
-        if (glCombinerParameterivNV==NULL) {fprintf(stderr,"glCombinerParameterivNV not found.\n"); return 0;}
+      fprintf (stderr, "glCombinerParameterfvNV not found.\n");
-    glCombinerParameterfNV=(PFNGLCOMBINERPARAMETERFNVPROC) wglGetProcAddress("glCombinerParameterfNV");
+      return 0;
-        if (glCombinerParameterfvNV==NULL) {fprintf(stderr,"glCombinerParameterfNV not found.\n"); return 0;}
+    }
-    glCombinerParameteriNV=(PFNGLCOMBINERPARAMETERINVPROC) wglGetProcAddress("glCombinerParameteriNV");
+    
glCombinerParameterivNV = (PFNGLCOMBINERPARAMETERIVNVPROC)
-        if (glCombinerParameterivNV==NULL) {fprintf(stderr,"glCombinerParameteriNV not found.\n"); return 0;}
+	wglGetProcAddress ("glCombinerParameterivNV");
-    glCombinerInputNV=(PFNGLCOMBINERINPUTNVPROC) wglGetProcAddress("glCombinerInputNV");
+    
if (glCombinerParameterivNV == NULL) {
-        if (glCombinerInputNV==NULL) {fprintf(stderr,"glCombinerInputNV not found.\n"); return 0;}
+      fprintf (stderr, "glCombinerParameterivNV not found.\n");
-    glCombinerOutputNV=(PFNGLCOMBINEROUTPUTNVPROC) wglGetProcAddress("glCombinerOutputNV");
+      return 0;
-        if (glCombinerOutputNV==NULL) {fprintf(stderr,"glCombinerOutputNV not found.\n"); return 0;}
+    }
-    glFinalCombinerInputNV=(PFNGLFINALCOMBINERINPUTNVPROC) wglGetProcAddress("glFinalCombinerInputNV");
+    
glCombinerParameterfNV = (PFNGLCOMBINERPARAMETERFNVPROC)
-        if (glFinalCombinerInputNV==NULL) {fprintf(stderr,"glFinalCombinerInputNV not found.\n"); return 0;}
+	wglGetProcAddress ("glCombinerParameterfNV");
-    glGetCombinerInputParameterfvNV=(PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC) wglGetProcAddress("glGetCombinerInputParameterfvNV");
+    
if (glCombinerParameterfvNV == NULL) {
-        if (glGetCombinerInputParameterfvNV==NULL) {fprintf(stderr,"glGetCombinerInputParameterfvNV not found.\n"); return 0;}
+      fprintf (stderr, "glCombinerParameterfNV not found.\n");
-    glGetCombinerInputParameterivNV=(PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC) wglGetProcAddress("glGetCombinerInputParameterivNV");
+      return 0;
-        if (glGetCombinerInputParameterivNV==NULL) {fprintf(stderr,"glGetCombinerInputParameterivNV not found.\n"); return 0;}
+    }
-    glGetCombinerOutputParameterfvNV=(PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC) wglGetProcAddress("glGetCombinerOutputParameterfvNV");
+    
glCombinerParameteriNV = (PFNGLCOMBINERPARAMETERINVPROC)
-        if (glGetCombinerOutputParameterfvNV==NULL) {fprintf(stderr,"glGetCombinerOutputParameterfvNV not found.\n"); return 0;}
+	wglGetProcAddress ("glCombinerParameteriNV");
-    glGetCombinerOutputParameterivNV=(PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC) wglGetProcAddress("glGetCombinerOutputParameterivNV");
+    
if (glCombinerParameterivNV == NULL) {
-        if (glGetCombinerOutputParameterivNV==NULL) {fprintf(stderr,"glGetCombinerOutputParameterivNV not found.\n"); return 0;}
+      fprintf (stderr, "glCombinerParameteriNV not found.\n");
-    glGetFinalCombinerInputParameterfvNV=(PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC) wglGetProcAddress("glGetFinalCombinerInputParameterfvNV");
+      return 0;
-        if (glGetFinalCombinerInputParameterfvNV==NULL) {fprintf(stderr,"glGetFinalCombinerInputParameterfvNV not found.\n"); return 0;}
+    }
-    glGetFinalCombinerInputParameterivNV=(PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC) wglGetProcAddress("glGetFinalCombinerInputParameterivNV");
+    
glCombinerInputNV =
-        if (glGetFinalCombinerInputParameterivNV==NULL) {fprintf(stderr,"glGetFinalCombinerInputParameterivNV not found.\n"); return 0;}
+	(PFNGLCOMBINERINPUTNVPROC) wglGetProcAddress ("glCombinerInputNV");
    
if (glCombinerInputNV == NULL) {
      fprintf (stderr, "glCombinerInputNV not found.\n");
      return 0;
    }
    
glCombinerOutputNV =
 	(PFNGLCOMBINEROUTPUTNVPROC) wglGetProcAddress ("glCombinerOutputNV");
    
if (glCombinerOutputNV == NULL) {
      fprintf (stderr, "glCombinerOutputNV not found.\n");
      return 0;
    }
    
glFinalCombinerInputNV = (PFNGLFINALCOMBINERINPUTNVPROC)
 	wglGetProcAddress ("glFinalCombinerInputNV");
    
if (glFinalCombinerInputNV == NULL) {
      fprintf (stderr, "glFinalCombinerInputNV not found.\n");
      return 0;
    }
    
glGetCombinerInputParameterfvNV = (PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC)
 	wglGetProcAddress ("glGetCombinerInputParameterfvNV");
    
if (glGetCombinerInputParameterfvNV == NULL) {
      fprintf (stderr, "glGetCombinerInputParameterfvNV not found.\n");
      return 0;
    }
    
glGetCombinerInputParameterivNV = (PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC)
 	wglGetProcAddress ("glGetCombinerInputParameterivNV");
    
if (glGetCombinerInputParameterivNV == NULL) {
      fprintf (stderr, "glGetCombinerInputParameterivNV not found.\n");
      return 0;
    }
    
glGetCombinerOutputParameterfvNV =
 	(PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC)
 	wglGetProcAddress ("glGetCombinerOutputParameterfvNV");
    
if (glGetCombinerOutputParameterfvNV == NULL) {
      fprintf (stderr, "glGetCombinerOutputParameterfvNV not found.\n");
      return 0;
    }
    
glGetCombinerOutputParameterivNV =
 	(PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC)
 	wglGetProcAddress ("glGetCombinerOutputParameterivNV");
    
if (glGetCombinerOutputParameterivNV == NULL) {
      fprintf (stderr, "glGetCombinerOutputParameterivNV not found.\n");
      return 0;
    }
    
glGetFinalCombinerInputParameterfvNV =
 	(PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC)
 	wglGetProcAddress ("glGetFinalCombinerInputParameterfvNV");
    
if (glGetFinalCombinerInputParameterfvNV == NULL) {
      fprintf (stderr, "glGetFinalCombinerInputParameterfvNV not found.\n");
      return 0;
    }
    
glGetFinalCombinerInputParameterivNV =
 	(PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC)
 	wglGetProcAddress ("glGetFinalCombinerInputParameterivNV");
    
if (glGetFinalCombinerInputParameterivNV == NULL) {
      fprintf (stderr, "glGetFinalCombinerInputParameterivNV not found.\n");
      return 0;
    }
 #endif // _WIN32
 	return 1;
  
}
@ -213,6 +316,8 @@ int GL_NV_register_combiners_Init(void) {
 #ifdef __cplusplus
 }
-#endif
+
 #endif /* 
 */
 #endif // not __NV_REGISTER_COMBINERS_H_
--- a/gst/gl/gstgl_nvimage.c
+++ b/gst/gl/gstgl_nvimage.c
@ -31,7 +31,8 @@
 #include "gstglsink.h"
 typedef struct _GstGLImageConnection GstGLImageConnection;
-struct _GstGLImageConnection {
+struct _GstGLImageConnection
 {
  GstImageConnection conn;
  Display *dpy;
  gint w, h;
@ -59,25 +60,33 @@ struct _GstNvImage
 };
 static GstGLImageInfo *gst_gl_nvimage_info (GstImageInfo * info);
-static GstGLImageConnection *	gst_gl_nvimage_connection 		(GstImageConnection *conn);
+static GstGLImageConnection *gst_gl_nvimage_connection (GstImageConnection *
    conn);
 static gboolean gst_gl_nvimage_check_xvideo ();
 static GstCaps *gst_gl_nvimage_get_caps (GstImageInfo * info);
-static GstImageConnection *	gst_gl_nvimage_set_caps		(GstImageInfo *info, GstCaps *caps);
+static GstImageConnection *gst_gl_nvimage_set_caps (GstImageInfo * info,
-static GstImageData *		gst_gl_nvimage_get_image		(GstImageInfo *info, GstImageConnection *conn);
+    GstCaps * caps);
-static void 			gst_gl_nvimage_put_image		(GstImageInfo *info, GstImageData *image);
+static GstImageData *gst_gl_nvimage_get_image (GstImageInfo * info,
    GstImageConnection * conn);
 static void gst_gl_nvimage_put_image (GstImageInfo * info,
    GstImageData * image);
 static void gst_gl_nvimage_free_image (GstImageData * image);
-static void 			gst_gl_nvimage_open_conn		(GstImageConnection *conn, GstImageInfo *info);
+static void gst_gl_nvimage_open_conn (GstImageConnection * conn,
-static void 			gst_gl_nvimage_close_conn		(GstImageConnection *conn, GstImageInfo *info);
+    GstImageInfo * info);
 static void gst_gl_nvimage_close_conn (GstImageConnection * conn,
    GstImageInfo * info);
 static void gst_gl_nvimage_free_conn (GstImageConnection * conn);
-GstImagePlugin* get_gl_nvimage_plugin(void)
+GstImagePlugin *
 get_gl_nvimage_plugin (void)
 {
  static GstImagePlugin plugin = { gst_gl_nvimage_get_caps,
    gst_gl_nvimage_set_caps,
    gst_gl_nvimage_get_image,
    gst_gl_nvimage_put_image,
-    				   gst_gl_nvimage_free_image};
+    gst_gl_nvimage_free_image
  };
  return &plugin;
 }
@ -86,8 +95,7 @@ GstImagePlugin* get_gl_nvimage_plugin(void)
 static GstGLImageInfo *
 gst_gl_nvimage_info (GstImageInfo * info)
 {
-  if (info == NULL || info->id != GST_MAKE_FOURCC ('X', 'l', 'i', 'b'))
+  if (info == NULL || info->id != GST_MAKE_FOURCC ('X', 'l', 'i', 'b')) {
  {
    return NULL;
  }
  return (GstGLImageInfo *) info;
@ -106,9 +114,12 @@ gst_gl_nvimage_check_xvideo ()
 {
  //int ver, rel, req, ev, err;
  printf ("Checking NVidia OpenGL extensions.\n");
-  if (!GL_ARB_multitexture_Init()) return FALSE;
+  if (!GL_ARB_multitexture_Init ())
-  if (!GL_EXT_paletted_texture_Init()) return FALSE;
+    return FALSE;
-  if (!GL_NV_register_combiners_Init()) return FALSE;
+  if (!GL_EXT_paletted_texture_Init ())
    return FALSE;
  if (!GL_NV_register_combiners_Init ())
    return FALSE;
 #if 0
  if (display == NULL)
@ -129,22 +140,20 @@ gst_gl_nvimage_get_caps (GstImageInfo *info)
  GstCaps *caps = NULL;
  GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
-  g_warning("nvimage get caps called, context %p !\n", glXGetCurrentContext());
+  g_warning ("nvimage get caps called, context %p !\n",
      glXGetCurrentContext ());
  /* we don't handle these image information */
-  if (xinfo == NULL) 
+  if (xinfo == NULL) {
    {
    printf ("Invalid XInfo struct !\n");
    return NULL;
  }
-  if (gst_gl_nvimage_check_xvideo () == FALSE)
+  if (gst_gl_nvimage_check_xvideo () == FALSE) {
  {
    g_warning ("GL_NVImage: Server has no NVidia extension support\n");
    return NULL;
  }
-  caps = gst_caps_append (caps, GST_CAPS_NEW (
+  caps = gst_caps_append (caps, GST_CAPS_NEW ("nvimage_caps",
 					      "nvimage_caps",
 	  "video/x-raw-yuv",
 	  "format", GST_PROPS_FOURCC (GST_MAKE_FOURCC ('Y', 'V', '1', '2')),
 	  "width", GST_PROPS_INT_RANGE (0, 1024),
@ -165,7 +174,8 @@ gst_gl_nvimage_set_caps (GstImageInfo *info, GstCaps *caps)
  guint32 format;
  /* we don't handle these image information */
-  if (xinfo == NULL) return NULL;
+  if (xinfo == NULL)
    return NULL;
  conn = g_new0 (GstGLImageConnection, 1);
  conn->conn.open_conn = gst_gl_nvimage_open_conn;
@ -173,14 +183,10 @@ gst_gl_nvimage_set_caps (GstImageInfo *info, GstCaps *caps)
  conn->conn.free_conn = gst_gl_nvimage_free_conn;
  gst_caps_get (caps,
-		  "width",  &conn->w,
+      "width", &conn->w, "height", &conn->h, "format", &format, NULL);
 		  "height", &conn->h,
 		  "format", &format,
                  NULL);
  // maybe I should a bit more checking here, e.g. maximum size smaller than maximum texture extents
-  if (format != GST_MAKE_FOURCC ('Y', 'V', '1', '2')) 
+  if (format != GST_MAKE_FOURCC ('Y', 'V', '1', '2')) {
    { 
    GST_DEBUG ("GL_NVImage: Format is invalid !\n");
    return NULL;
  }
@ -203,8 +209,10 @@ gst_gl_nvimage_get_image (GstImageInfo *info, GstImageConnection *conn)
  GstGLImageConnection *nvconn = gst_gl_nvimage_connection (conn);
  /* checks */
-  if (xinfo == NULL) return NULL;
+  if (xinfo == NULL)
-  if (nvconn == NULL) return NULL;
+    return NULL;
  if (nvconn == NULL)
    return NULL;
  // I should also check the current GLX context ! 
  // Ah, Don't have to, I am guarantueed to be in the same thread as put_image
@ -219,8 +227,7 @@ gst_gl_nvimage_get_image (GstImageInfo *info, GstImageConnection *conn)
  image->conn = nvconn;
-  if (image->data.data == NULL)
+  if (image->data.data == NULL) {
  {
    g_warning ("GL_NvImage: data allocation failed!");
    g_free (image);
    return NULL;
@ -256,8 +263,7 @@ gst_gl_nvimage_put_image (GstImageInfo *info, GstImageData *image)
  glTranslatef (0.0, 0.0, -5.0);
  glDisable (GL_TEXTURE_2D);
-  if (xinfo->info.demo)
+  if (xinfo->info.demo) {
    {
    //g_print("Putting image, context is %p\n", glXGetCurrentContext());
    glTranslatef (0.0, 0.0, -5.0);	// make it avoid the clipping plane, zoom 2.0 instead
@ -267,6 +273,7 @@ gst_gl_nvimage_put_image (GstImageInfo *info, GstImageData *image)
    xinfo->rotX += 0.01;
    xinfo->rotY -= 0.015;
    float zoom = xinfo->zoom;
    glScalef (zoom, zoom, zoom);
    //glScalef(0.1,0.1,0.1); 
@ -278,16 +285,18 @@ gst_gl_nvimage_put_image (GstImageInfo *info, GstImageData *image)
    xinfo->zoom += xinfo->zoomdir;
  }
  //Draws the surface rectangle
-  if (Ywidth != im->conn->w || Yheight != im->conn->h)
+  if (Ywidth != im->conn->w || Yheight != im->conn->h) {
-  {
+    Ywidth = im->conn->w;
-    Ywidth = im->conn->w; Yheight = im->conn->h;  UVwidth = im->conn->w/2; UVheight = im->conn->h/2;
+    Yheight = im->conn->h;
    UVwidth = im->conn->w / 2;
    UVheight = im->conn->h / 2;
    Initialize_Backend (Ywidth, Yheight, UVwidth, UVheight, GL_LINEAR);
  }
-  LoadYUVPlanes(Yhandle,Uhandle,Vhandle,img_width,img_height,uv_width,uv_height,buf_y,buf_u,buf_v);
+  LoadYUVPlanes (Yhandle, Uhandle, Vhandle, img_width, img_height, uv_width,
      uv_height, buf_y, buf_u, buf_v);
  float xmax = (float) (im->conn->w - 1) / tex_xsize;
  float ymax = (float) (im->conn->h - 1) / tex_ysize;
@ -324,8 +333,7 @@ gst_gl_nvimage_put_image (GstImageInfo *info, GstImageData *image)
  glEnd ();
-  if (xinfo->info.dumpvideo)
+  if (xinfo->info.dumpvideo) {
    {
    static int framenr = 0;
    char capfilename[255];
    static guint8 *cap_image_data = NULL, *cap_image_data2 = NULL;
@ -339,20 +347,23 @@ gst_gl_nvimage_put_image (GstImageInfo *info, GstImageData *image)
      cap_image_data2 = (guint8 *) malloc (img_width * img_height * 3);
    printf ("Recording frame #%d\n", framenr);
-      glReadPixels(0,0,img_width,img_height,GL_RGB,GL_UNSIGNED_BYTE,cap_image_data);
+    glReadPixels (0, 0, img_width, img_height, GL_RGB, GL_UNSIGNED_BYTE,
 	cap_image_data);
    // invert the pixels
    for (i = 0; i < img_height; i++)
-	memcpy(cap_image_data2 + i * img_width * 3, cap_image_data + (img_height-1-i) * img_width * 3, img_width*3);
+      memcpy (cap_image_data2 + i * img_width * 3,
 	  cap_image_data + (img_height - 1 - i) * img_width * 3, img_width * 3);
    sprintf (capfilename, "cap%04d.ppm", framenr);
    FILE *outfile = fopen (capfilename, "wb");
-      if (outfile != NULL)
+
-	{
+    if (outfile != NULL) {
      fprintf (outfile, "P6\n");
      fprintf (outfile, "# created by glsink from GStreamer\n");
      fprintf (outfile, "%d %d\n", img_width, img_height);
      fprintf (outfile, "255\n");
-	  fwrite(cap_image_data2, sizeof(char), img_width*img_height*3, outfile);
+      fwrite (cap_image_data2, sizeof (char), img_width * img_height * 3,
 	  outfile);
      fclose (outfile);
    }
    framenr++;
@ -366,14 +377,13 @@ static void
 gst_gl_nvimage_free_image (GstImageData * image)
 {
  GstNvImage *im = (GstNvImage *) image;
  g_return_if_fail (im != NULL);
  GstGLImageConnection *nvconn = im->conn;
-  if (im->slot < AGP_BUFSLOTS)
+  if (im->slot < AGP_BUFSLOTS) {
    {
    nvconn->m_bufslots[im->slot] = 0;
-    } 
+  } else
  else
    g_free (im->data.data);
  g_free (im);
@ -385,9 +395,13 @@ gst_gl_nvimage_open_conn (GstImageConnection *conn, GstImageInfo *info)
  //GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);  
  //GstGLImageConnection *xconn = gst_gl_nvimage_connection (conn);
-  g_print("Opening NVidia connection; OpenGL on Nvidia, using register combiners.\n");
+  g_print
      ("Opening NVidia connection; OpenGL on Nvidia, using register combiners.\n");
  {
-    Ywidth = TEX_XSIZE; Yheight = TEX_YSIZE;  UVwidth = TEX_XSIZE/2; UVheight = TEX_YSIZE/2;
+    Ywidth = TEX_XSIZE;
    Yheight = TEX_YSIZE;
    UVwidth = TEX_XSIZE / 2;
    UVheight = TEX_YSIZE / 2;
    Initialize_Backend (Ywidth, Yheight, UVwidth, UVheight, GL_LINEAR);
  }
  g_print ("Done\n");
@ -397,6 +411,7 @@ static void
 gst_gl_nvimage_close_conn (GstImageConnection * conn, GstImageInfo * info)
 {
  GstGLImageConnection *xconn = gst_gl_nvimage_connection (conn);
  //GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);  
  // anything needed in here ? Oh, maybe drawing de-init, or something
@ -412,4 +427,3 @@ gst_gl_nvimage_free_conn (GstImageConnection *conn)
  g_free (nvconn);
 }
--- a/gst/gl/gstgl_pdrimage.c
+++ b/gst/gl/gstgl_pdrimage.c
@ -31,7 +31,8 @@
 #include "gstglsink.h"
 typedef struct _GstGLImageConnection GstGLImageConnection;
-struct _GstGLImageConnection {
+struct _GstGLImageConnection
 {
  GstImageConnection conn;
  Display *dpy;
  gint w, h;
@ -59,25 +60,33 @@ struct _GstNvImage
 };
 static GstGLImageInfo *gst_gl_nvimage_info (GstImageInfo * info);
-static GstGLImageConnection *	gst_gl_nvimage_connection 		(GstImageConnection *conn);
+static GstGLImageConnection *gst_gl_nvimage_connection (GstImageConnection *
    conn);
 static gboolean gst_gl_nvimage_check_xvideo ();
 static GstCaps *gst_gl_nvimage_get_caps (GstImageInfo * info);
-static GstImageConnection *	gst_gl_nvimage_set_caps		(GstImageInfo *info, GstCaps *caps);
+static GstImageConnection *gst_gl_nvimage_set_caps (GstImageInfo * info,
-static GstImageData *		gst_gl_nvimage_get_image		(GstImageInfo *info, GstImageConnection *conn);
+    GstCaps * caps);
-static void 			gst_gl_nvimage_put_image		(GstImageInfo *info, GstImageData *image);
+static GstImageData *gst_gl_nvimage_get_image (GstImageInfo * info,
    GstImageConnection * conn);
 static void gst_gl_nvimage_put_image (GstImageInfo * info,
    GstImageData * image);
 static void gst_gl_nvimage_free_image (GstImageData * image);
-static void 			gst_gl_nvimage_open_conn		(GstImageConnection *conn, GstImageInfo *info);
+static void gst_gl_nvimage_open_conn (GstImageConnection * conn,
-static void 			gst_gl_nvimage_close_conn		(GstImageConnection *conn, GstImageInfo *info);
+    GstImageInfo * info);
 static void gst_gl_nvimage_close_conn (GstImageConnection * conn,
    GstImageInfo * info);
 static void gst_gl_nvimage_free_conn (GstImageConnection * conn);
-GstImagePlugin* get_gl_nvimage_plugin(void)
+GstImagePlugin *
 get_gl_nvimage_plugin (void)
 {
  static GstImagePlugin plugin = { gst_gl_nvimage_get_caps,
    gst_gl_nvimage_set_caps,
    gst_gl_nvimage_get_image,
    gst_gl_nvimage_put_image,
-    				   gst_gl_nvimage_free_image};
+    gst_gl_nvimage_free_image
  };
  return &plugin;
 }
@ -86,8 +95,7 @@ GstImagePlugin* get_gl_nvimage_plugin(void)
 static GstGLImageInfo *
 gst_gl_nvimage_info (GstImageInfo * info)
 {
-  if (info == NULL || info->id != GST_MAKE_FOURCC ('X', 'l', 'i', 'b'))
+  if (info == NULL || info->id != GST_MAKE_FOURCC ('X', 'l', 'i', 'b')) {
  {
    return NULL;
  }
  return (GstGLImageInfo *) info;
@ -126,16 +134,15 @@ gst_gl_nvimage_get_caps (GstImageInfo *info)
  GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
  /* we don't handle these image information */
-  if (xinfo == NULL) return NULL;
+  if (xinfo == NULL)
    return NULL;
-  if (gst_gl_nvimage_check_xvideo () == FALSE)
+  if (gst_gl_nvimage_check_xvideo () == FALSE) {
  {
    g_warning ("GL_NVImage: Server has no NVidia extension support\n");
    return NULL;
  }
-  caps = gst_caps_append (caps, GST_CAPS_NEW (
+  caps = gst_caps_append (caps, GST_CAPS_NEW ("xvimage_caps",
 					      "xvimage_caps",
 	  "video/raw",
 	  "format", GST_PROPS_FOURCC (GST_MAKE_FOURCC ('Y', 'C', '1', '2')),
 	  "width", GST_PROPS_INT_RANGE (0, 1024),
@ -155,7 +162,8 @@ gst_gl_nvimage_set_caps (GstImageInfo *info, GstCaps *caps)
  guint32 format;
  /* we don't handle these image information */
-  if (xinfo == NULL) return NULL;
+  if (xinfo == NULL)
    return NULL;
  conn = g_new0 (GstGLImageConnection, 1);
  conn->conn.open_conn = gst_gl_nvimage_open_conn;
@ -163,14 +171,10 @@ gst_gl_nvimage_set_caps (GstImageInfo *info, GstCaps *caps)
  conn->conn.free_conn = gst_gl_nvimage_free_conn;
  gst_caps_get (caps,
-		  "width",  &conn->w,
+      "width", &conn->w, "height", &conn->h, "format", &format, NULL);
 		  "height", &conn->h,
 		  "format", &format,
                  NULL);
  // maybe I should a bit more checking here, e.g. maximum size smaller than maximum texture extents
-  if (format != GST_MAKE_FOURCC ('R', 'G', 'B', ' ')) 
+  if (format != GST_MAKE_FOURCC ('R', 'G', 'B', ' ')) {
    { 
    GST_DEBUG (GST_CAT_PLUGIN_INFO, "GL_NVImage: Format is invalid !\n");
    return NULL;
  }
@ -181,7 +185,8 @@ gst_gl_nvimage_set_caps (GstImageInfo *info, GstCaps *caps)
    return NULL;
  }
-  GST_DEBUG (GST_CAT_PLUGIN_INFO, "GL_NVImage: caps %p are ok, creating image", caps);
+  GST_DEBUG (GST_CAT_PLUGIN_INFO, "GL_NVImage: caps %p are ok, creating image",
      caps);
  return (GstImageConnection *) conn;
 }
@ -194,17 +199,19 @@ gst_gl_nvimage_get_image (GstImageInfo *info, GstImageConnection *conn)
  int slot = 0;
  /* checks */
-  if (xinfo == NULL) return NULL;
+  if (xinfo == NULL)
-  if (nvconn == NULL) return NULL;
+    return NULL;
  if (nvconn == NULL)
    return NULL;
  // I should also check the current GLX context ! 
  // Ah, Don't have to, I am guarantueed to always be in the same thread
  image = g_new0 (GstNvImage, 1);
-  for (slot = 0; slot < AGP_BUFSLOTS; slot++)
+  for (slot = 0; slot < AGP_BUFSLOTS; slot++) {
-    {
+    if (!nvconn->m_bufslots[slot])
-      if (!nvconn->m_bufslots[slot]) break;
+      break;
  }
  image->data.size = nvconn->w * nvconn->h * 3 / 2;
@ -214,17 +221,14 @@ gst_gl_nvimage_get_image (GstImageInfo *info, GstImageConnection *conn)
    image->data.data = nvconn->m_memory + slot * YUVTEX_SIZE;
    image->slot = slot;		// store for freeing
    nvconn->m_bufslots[slot] = 1;	// it is now taken
-    }
+  } else {
  else
    {
    g_warning ("Allocating from main memory !");
    image->data.data = g_malloc (image->data.size);
    image->slot = AGP_BUFSLOTS;	// no AGP slot
  }
  image->conn = nvconn;
-  if (image->data.data == NULL)
+  if (image->data.data == NULL) {
  {
    g_warning ("GL_NvImage: data allocation failed!");
    g_free (image);
    return NULL;
@ -255,6 +259,7 @@ gst_gl_nvimage_put_image (GstImageInfo *info, GstImageData *image)
  glRotatef (xinfo->rotX - 250, 1, 0, 0);
  glRotatef (xinfo->rotY, 0, 1, 0);
  int zoom = xinfo->zoom;
  glScaled (zoom, zoom, zoom);
  //Draws the surface rectangle
@ -292,14 +297,13 @@ static void
 gst_gl_nvimage_free_image (GstImageData * image)
 {
  GstNvImage *im = (GstNvImage *) image;
  g_return_if_fail (im != NULL);
  GstGLImageConnection *nvconn = im->conn;
-  if (im->slot < AGP_BUFSLOTS)
+  if (im->slot < AGP_BUFSLOTS) {
    {
    nvconn->m_bufslots[im->slot] = 0;
-    } 
+  } else
  else
    g_free (im->data.data);
  g_free (im);
@ -315,18 +319,19 @@ gst_gl_nvimage_open_conn (GstImageConnection *conn, GstImageInfo *info)
  int slot;
  g_warning ("Opening NVidia Connection");
-  xconn->m_memory = (unsigned char*)glXAllocateMemoryNV(AGP_BUFSLOTS*YUVTEX_SIZE, 0, 1.0, 1.0);
+  xconn->m_memory =
      (unsigned char *) glXAllocateMemoryNV (AGP_BUFSLOTS * YUVTEX_SIZE, 0, 1.0,
      1.0);
-  if (!xconn->m_memory)
+  if (!xconn->m_memory) {
-    {
+    printf
-      printf("Unable to acquire graphics card mem... will acquire in normal memory.\n");
+	("Unable to acquire graphics card mem... will acquire in normal memory.\n");
    for (slot = 0; slot < AGP_BUFSLOTS; slot++)
      xconn->m_bufslots[slot] = 1;
-    }
+  } else {
  else
    {
    // maybe this fast writable memory, awfully slow to read from, though
-      glPixelDataRangeNV(GL_WRITE_PIXEL_DATA_RANGE_NV, AGP_BUFSLOTS*YUVTEX_SIZE, xconn->m_memory);
+    glPixelDataRangeNV (GL_WRITE_PIXEL_DATA_RANGE_NV,
 	AGP_BUFSLOTS * YUVTEX_SIZE, xconn->m_memory);
    glEnableClientState (GL_WRITE_PIXEL_DATA_RANGE_NV);
    for (slot = 0; slot < AGP_BUFSLOTS; slot++)
@ -341,13 +346,15 @@ gst_gl_nvimage_open_conn (GstImageConnection *conn, GstImageInfo *info)
  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
-  glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE8_ALPHA8, TEX_XSIZE, TEX_YSIZE, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, NULL);
+  glTexImage2D (GL_TEXTURE_2D, 0, GL_LUMINANCE8_ALPHA8, TEX_XSIZE, TEX_YSIZE, 0,
      GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, NULL);
  glActiveTextureARB (GL_TEXTURE1_ARB);
  glGenTextures (1, &xconn->uvtex_id);
  glBindTexture (GL_TEXTURE_2D, xconn->uvtex_id);
  glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
-  glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE8_ALPHA8, TEX_XSIZE/2, TEX_YSIZE/2, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, NULL);
+  glTexImage2D (GL_TEXTURE_2D, 0, GL_LUMINANCE8_ALPHA8, TEX_XSIZE / 2,
      TEX_YSIZE / 2, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, NULL);
  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
@ -358,7 +365,8 @@ gst_gl_nvimage_open_conn (GstImageConnection *conn, GstImageInfo *info)
  glGenTextures (1, &xconn->septex_id);
  glBindTexture (GL_TEXTURE_2D, xconn->septex_id);
  glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
-  glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE8, 2, 2, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, data_sep);
+  glTexImage2D (GL_TEXTURE_2D, 0, GL_LUMINANCE8, 2, 2, 0, GL_LUMINANCE,
      GL_UNSIGNED_BYTE, data_sep);
  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
@ -395,4 +403,3 @@ gst_gl_nvimage_free_conn (GstImageConnection *conn)
  g_free (nvconn);
 }
--- a/gst/gl/gstgl_rgbimage.c
+++ b/gst/gl/gstgl_rgbimage.c
@ -29,7 +29,8 @@
 typedef struct _GstGLImageConnection GstGLImageConnection;
 // this contains everything to draw an image, including all necessary graphics card data. 
-struct _GstGLImageConnection {
+struct _GstGLImageConnection
 {
  GstImageConnection conn;
  Display *dpy;			// the Xlib drawing context
  GLXContext ctx;		// The GLX drawing context
@ -52,24 +53,32 @@ struct _GstGLImage
 };
 static GstGLImageInfo *gst_gl_rgbimage_info (GstImageInfo * info);
-static GstGLImageConnection *	gst_gl_rgbimage_connection 	(GstImageConnection *conn);
+static GstGLImageConnection *gst_gl_rgbimage_connection (GstImageConnection *
    conn);
 static GstCaps *gst_gl_rgbimage_get_caps (GstImageInfo * info);
-static GstImageConnection *	gst_gl_rgbimage_set_caps	(GstImageInfo *info, GstCaps *caps);
+static GstImageConnection *gst_gl_rgbimage_set_caps (GstImageInfo * info,
-static GstImageData *		gst_gl_rgbimage_get_image	(GstImageInfo *info, GstImageConnection *conn);
+    GstCaps * caps);
-static void 			gst_gl_rgbimage_put_image	(GstImageInfo *info, GstImageData *image);
+static GstImageData *gst_gl_rgbimage_get_image (GstImageInfo * info,
    GstImageConnection * conn);
 static void gst_gl_rgbimage_put_image (GstImageInfo * info,
    GstImageData * image);
 static void gst_gl_rgbimage_free_image (GstImageData * image);
-static void 			gst_gl_rgbimage_open_conn	(GstImageConnection *conn, GstImageInfo *info);
+static void gst_gl_rgbimage_open_conn (GstImageConnection * conn,
-static void 			gst_gl_rgbimage_close_conn	(GstImageConnection *conn, GstImageInfo *info);
+    GstImageInfo * info);
 static void gst_gl_rgbimage_close_conn (GstImageConnection * conn,
    GstImageInfo * info);
 static void gst_gl_rgbimage_free_conn (GstImageConnection * conn);
-GstImagePlugin* get_gl_rgbimage_plugin(void)
+GstImagePlugin *
 get_gl_rgbimage_plugin (void)
 {
  static GstImagePlugin plugin = { gst_gl_rgbimage_get_caps,
    gst_gl_rgbimage_set_caps,
    gst_gl_rgbimage_get_image,
    gst_gl_rgbimage_put_image,
-    				   gst_gl_rgbimage_free_image};
+    gst_gl_rgbimage_free_image
  };
  return &plugin;
 }
@ -77,8 +86,7 @@ GstImagePlugin* get_gl_rgbimage_plugin(void)
 static GstGLImageInfo *
 gst_gl_rgbimage_info (GstImageInfo * info)
 {
-  if (info == NULL || info->id != GST_MAKE_FOURCC ('X', 'l', 'i', 'b'))
+  if (info == NULL || info->id != GST_MAKE_FOURCC ('X', 'l', 'i', 'b')) {
  {
    return NULL;
  }
  return (GstGLImageInfo *) info;
@ -102,9 +110,11 @@ gst_gl_rgbimage_get_caps (GstImageInfo *info)
  XImage *ximage;
  GstGLImageInfo *xinfo = gst_gl_rgbimage_info (info);
-  g_warning("rgbimage get caps called, context %p, endianness %d !\n", glXGetCurrentContext(), G_BIG_ENDIAN);
+  g_warning ("rgbimage get caps called, context %p, endianness %d !\n",
      glXGetCurrentContext (), G_BIG_ENDIAN);
  /* we don't handle this image information */
-  if (xinfo == NULL) return NULL;
+  if (xinfo == NULL)
    return NULL;
  XGetWindowAttributes (xinfo->dpy, xinfo->win, &attrib);
@ -121,17 +131,12 @@ gst_gl_rgbimage_get_caps (GstImageInfo *info)
      100, 100, xpad, (attrib.depth + 7) / 8 * 100);
  if (ximage != NULL) {
    caps =
-      GST_CAPS_NEW (
+	GST_CAPS_NEW ("forcing Video RGB", "video/x-raw-rgb", "format",
-		    "forcing Video RGB",
+	GST_PROPS_FOURCC (GST_STR_FOURCC ("RGB ")), "depth", GST_PROPS_INT (24),
-		    "video/x-raw-rgb",
+	"bpp", GST_PROPS_INT (24), "red_mask", GST_PROPS_INT (0xff),
-		    "format",          GST_PROPS_FOURCC (GST_STR_FOURCC ("RGB ")),
+	"green_mask", GST_PROPS_INT (0xff00), "blue_mask",
-		    "depth",        GST_PROPS_INT(24),
+	GST_PROPS_INT (0xff0000), "endianness", GST_PROPS_INT (G_BIG_ENDIAN),
-		    "bpp",          GST_PROPS_INT(24),
+								/*= 1234/4321 (INT) <- endianness */
 		    "red_mask",        GST_PROPS_INT(0xff),
 		    "green_mask",        GST_PROPS_INT(0xff00),
 		    "blue_mask",        GST_PROPS_INT(0xff0000),
 		    "endianness",  GST_PROPS_INT(G_BIG_ENDIAN), /*= 1234/4321 (INT) <- endianness */
 	"width", GST_PROPS_INT_RANGE (0, TEX_XSIZE),	/* can't have videos larger than TEX_SIZE */
 	"height", GST_PROPS_INT_RANGE (0, TEX_YSIZE)
 	);
@ -158,7 +163,8 @@ gst_gl_rgbimage_set_caps (GstImageInfo *info, GstCaps *caps)
  gint width, height, bpp;
  /* check if this is the right image info */
-  if (xinfo == NULL) return NULL;
+  if (xinfo == NULL)
    return NULL;
  XGetWindowAttributes (xinfo->dpy, xinfo->win, &attrib);
@ -171,13 +177,11 @@ gst_gl_rgbimage_set_caps (GstImageInfo *info, GstCaps *caps)
      "red_mask", &red_mask,
      "green_mask", &green_mask,
      "blue_mask", &blue_mask,
-		  "width",	&width,
+      "width", &width, "height", &height, "bpp", &bpp, NULL);
 		  "height",	&height,
 		  "bpp",	&bpp,
 		  NULL);
  /* check if the caps are ok */
-  if (format != GST_MAKE_FOURCC ('R', 'G', 'B', ' ')) return NULL;
+  if (format != GST_MAKE_FOURCC ('R', 'G', 'B', ' '))
    return NULL;
  /* if (gst_caps_get_int (caps, "bpp") != ???) return NULL; */
  //if (depth != attrib.depth) return NULL;
  //if (endianness != ((ImageByteOrder (xinfo->dpy) == LSBFirst) ? G_LITTLE_ENDIAN : G_BIG_ENDIAN)) return NULL;
@ -203,6 +207,7 @@ static GstImageData *
 gst_gl_rgbimage_get_image (GstImageInfo * info, GstImageConnection * conn)
 {
  GstGLImage *image;
  //XWindowAttributes attrib;
  GstGLImageInfo *xinfo = gst_gl_rgbimage_info (info);
  GstGLImageConnection *xconn = gst_gl_rgbimage_connection (conn);
@ -210,10 +215,11 @@ gst_gl_rgbimage_get_image (GstImageInfo *info, GstImageConnection *conn)
  image = g_new (GstGLImage, 1);
  /* checks */
-  if (xinfo == NULL) return NULL;
+  if (xinfo == NULL)
-  if (xconn == NULL) return NULL;
+    return NULL;
-  if (xinfo->dpy != xconn->dpy)
+  if (xconn == NULL)
-  {
+    return NULL;
  if (xinfo->dpy != xconn->dpy) {
    g_warning ("XImage: wrong x display specified in 'get_image'\n");
    return NULL;
  }
@ -221,8 +227,7 @@ gst_gl_rgbimage_get_image (GstImageInfo *info, GstImageConnection *conn)
  image->conn = xconn;
  image->data.size = xconn->w * xconn->h * 4;
  image->data.data = g_malloc (image->data.size);
-  if (image->data.data == NULL)
+  if (image->data.data == NULL) {
  {
    g_warning ("GL_RGBImage: data allocation failed!");
    g_free (image);
    return NULL;
@ -254,8 +259,7 @@ gst_gl_rgbimage_put_image (GstImageInfo *info, GstImageData *image)
  glEnable (GL_TEXTURE_2D);
-  if (xinfo->info.demo)
+  if (xinfo->info.demo) {
    {
    glTranslatef (0.0, 0.0, -5.0);	// make it avoid the clipping plane, zoom 2.0 instead
    glRotatef (180.0 * sin (xinfo->rotX), 1, 0, 0);
    glRotatef (180.0 * cos (xinfo->rotY), 0, 1, 0);
@ -263,6 +267,7 @@ gst_gl_rgbimage_put_image (GstImageInfo *info, GstImageData *image)
    xinfo->rotX += 0.01;
    xinfo->rotY -= 0.015;
    float zoom = xinfo->zoom;
    glScalef (zoom, zoom, zoom);
    if (xinfo->zoom > 2.0)
@ -273,7 +278,6 @@ gst_gl_rgbimage_put_image (GstImageInfo *info, GstImageData *image)
    xinfo->zoom += xinfo->zoomdir;
  }
  //Draws the surface rectangle
  glBindTexture (GL_TEXTURE_2D, im->conn->rgbatex_id);
  glTexSubImage2D (GL_TEXTURE_2D, 0, 0, 0, im->conn->w, im->conn->h, GL_RGB,
@ -302,8 +306,7 @@ gst_gl_rgbimage_put_image (GstImageInfo *info, GstImageData *image)
  glVertex3f (hor, -1, 0);
  glEnd ();
-  if (xinfo->info.dumpvideo)
+  if (xinfo->info.dumpvideo) {
    {
    static int framenr = 0;
    char capfilename[255];
    static guint8 *cap_image_data = NULL, *cap_image_data2 = NULL;
@ -317,20 +320,23 @@ gst_gl_rgbimage_put_image (GstImageInfo *info, GstImageData *image)
      cap_image_data2 = (guint8 *) malloc (img_width * img_height * 3);
    printf ("Recording frame #%d\n", framenr);
-      glReadPixels(0,0,img_width,img_height,GL_RGB,GL_UNSIGNED_BYTE,cap_image_data);
+    glReadPixels (0, 0, img_width, img_height, GL_RGB, GL_UNSIGNED_BYTE,
 	cap_image_data);
    // invert the pixels
    for (i = 0; i < img_height; i++)
-	memcpy(cap_image_data2 + i * img_width * 3, cap_image_data + (img_height-1-i) * img_width * 3, img_width*3);
+      memcpy (cap_image_data2 + i * img_width * 3,
 	  cap_image_data + (img_height - 1 - i) * img_width * 3, img_width * 3);
    sprintf (capfilename, "cap%04d.ppm", framenr);
    FILE *outfile = fopen (capfilename, "wb");
-      if (outfile != NULL)
+
-	{
+    if (outfile != NULL) {
      fprintf (outfile, "P6\n");
      fprintf (outfile, "# created by raw_zb\n");
      fprintf (outfile, "%d %d\n", img_width, img_height);
      fprintf (outfile, "255\n");
-	  fwrite(cap_image_data2, sizeof(char), img_width*img_height*3, outfile);
+      fwrite (cap_image_data2, sizeof (char), img_width * img_height * 3,
 	  outfile);
      fclose (outfile);
    }
    framenr++;
@ -344,7 +350,8 @@ gst_gl_rgbimage_free_image (GstImageData *image)
 {
  GstGLImage *im = (GstGLImage *) image;
-  g_warning ("gst_gl_rgbimage_free_image doesn't do anything yet -> freeing image\n");
+  g_warning
      ("gst_gl_rgbimage_free_image doesn't do anything yet -> freeing image\n");
  g_free (im->data.data);
  g_free (im);
 }
@ -366,7 +373,8 @@ gst_gl_rgbimage_open_conn (GstImageConnection *conn, GstImageInfo *info)
  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
-  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, TEX_XSIZE, TEX_YSIZE, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+  glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, TEX_XSIZE, TEX_YSIZE, 0, GL_RGBA,
      GL_UNSIGNED_BYTE, NULL);
 }
 /* Deletes the creates OpenGL textures */
@ -374,6 +382,7 @@ static void
 gst_gl_rgbimage_close_conn (GstImageConnection * conn, GstImageInfo * info)
 {
  GstGLImageConnection *xconn = gst_gl_rgbimage_connection (conn);
  //GstGLImageInfo *xinfo = gst_gl_rgbimage_info (info);  
  glDeleteTextures (1, &xconn->rgbatex_id);
@ -388,5 +397,3 @@ gst_gl_rgbimage_free_conn (GstImageConnection *conn)
  g_free (xconn);
 }
--- a/gst/gl/gstglsink.c
+++ b/gst/gl/gstglsink.c
@ -66,12 +66,14 @@ GST_PAD_TEMPLATE_FACTORY (gst_glsink_sink_template_factory,
    )
 /* glsink signals and args */
-enum {
+     enum
     {
       LAST_SIGNAL
     };
-enum {
+     enum
     {
       ARG_0,
       ARG_WIDTH,
       ARG_HEIGHT,
@ -94,7 +96,8 @@ enum {
     typedef struct _GstGLSink GstGLSink;
     typedef struct _GstGLSinkClass GstGLSinkClass;
-struct _GstGLSink {
+     struct _GstGLSink
     {
       GstElement element;
       GstPad *sinkpad;
@ -120,7 +123,8 @@ struct _GstGLSink {
       GstImageInfo *hook;
     };
-struct _GstGLSinkClass {
+     struct _GstGLSinkClass
     {
       GstElementClass parent_class;
       /* plugins */
@ -132,12 +136,15 @@ static GType 			gst_glsink_get_type		(void);
     static void gst_glsink_base_init (gpointer g_class);
     static void gst_glsink_class_init (GstGLSinkClass * klass);
     static void gst_glsink_init (GstGLSink * sink);
 /* static void 			gst_glsink_dispose 		(GObject *object); */
     static void gst_glsink_chain (GstPad * pad, GstData * _data);
     static void gst_glsink_set_clock (GstElement * element, GstClock * clock);
-static GstElementStateReturn	gst_glsink_change_state 	(GstElement *element);
+     static GstElementStateReturn gst_glsink_change_state (GstElement *
-static GstPadLinkReturn	gst_glsink_sinkconnect	(GstPad *pad, GstCaps *caps);
+    element);
     static GstPadLinkReturn gst_glsink_sinkconnect (GstPad * pad,
    GstCaps * caps);
     static GstCaps *gst_glsink_getcaps (GstPad * pad, GstCaps * caps);
     static void gst_glsink_set_property (GObject * object, guint prop_id,
@ -146,12 +153,14 @@ static void			gst_glsink_get_property	(GObject *object, guint prop_id,
    GValue * value, GParamSpec * pspec);
     static void gst_glsink_release_conn (GstGLSink * sink);
-static void			gst_glsink_append_cache	(GstGLSink *sink, GstImageData *image);
+     static void gst_glsink_append_cache (GstGLSink * sink,
    GstImageData * image);
     static gboolean gst_glsink_set_caps (GstGLSink * sink, GstCaps * caps);
 /* prototypes from plugins */
     extern GstImagePlugin *get_gl_rgbimage_plugin (void);
     extern GstImagePlugin *get_gl_nvimage_plugin (void);
 /* default output */
     extern void gst_glxwindow_new (GstGLSink * sink);
     extern void gst_glxwindow_hook_context (GstImageInfo * info);
@ -161,10 +170,10 @@ extern void			gst_glxwindow_unhook_context 		(GstImageInfo *info);
     static GstPadTemplate *sink_template;
     static GstElementClass *parent_class = NULL;
 /* static guint gst_glsink_signals[LAST_SIGNAL] = { 0 }; */
-static GType
+     static GType gst_glsink_get_type (void)
 gst_glsink_get_type (void)
 {
  static GType videosink_type = 0;
@ -180,7 +189,9 @@ gst_glsink_get_type (void)
      0,
      (GInstanceInitFunc) gst_glsink_init,
    };
-    videosink_type = g_type_register_static(GST_TYPE_ELEMENT, "GstGLSink", &videosink_info, 0);
+    videosink_type =
 	g_type_register_static (GST_TYPE_ELEMENT, "GstGLSink", &videosink_info,
 	0);
  }
  return videosink_type;
 }
@ -192,8 +203,7 @@ gst_glsink_base_init (gpointer g_class)
  gst_element_class_set_details (element_class, &gst_glsink_details);
-  gst_element_class_add_pad_template (
+  gst_element_class_add_pad_template (element_class,
    element_class, 
      GST_PAD_TEMPLATE_GET (gst_glsink_sink_template_factory));
 }
@ -208,28 +218,25 @@ gst_glsink_class_init (GstGLSinkClass *klass)
  parent_class = g_type_class_ref (GST_TYPE_ELEMENT);
-  g_object_class_install_property (gobject_class, ARG_WIDTH,
+  g_object_class_install_property (gobject_class, ARG_WIDTH, g_param_spec_int ("width", "Width", "The video width", G_MININT, G_MAXINT, 0, G_PARAM_READABLE));	/* CHECKME */
-    g_param_spec_int ("width", "Width", "The video width",
+  g_object_class_install_property (gobject_class, ARG_HEIGHT, g_param_spec_int ("height", "Height", "The video height", G_MININT, G_MAXINT, 0, G_PARAM_READABLE));	/* CHECKME */
-                      G_MININT, G_MAXINT, 0, G_PARAM_READABLE)); /* CHECKME */
+  g_object_class_install_property (gobject_class, ARG_FRAMES_DISPLAYED, g_param_spec_int ("frames_displayed", "Frames Displayed", "The number of frames displayed so far", G_MININT, G_MAXINT, 0, G_PARAM_READWRITE));	/* CHECKME */
-  g_object_class_install_property (gobject_class, ARG_HEIGHT,
+  g_object_class_install_property (gobject_class, ARG_FRAME_TIME, g_param_spec_int ("frame_time", "Frame time", "The interval between frames", G_MININT, G_MAXINT, 0, G_PARAM_READWRITE));	/* CHECKME */
    g_param_spec_int ("height", "Height", "The video height",
                      G_MININT, G_MAXINT, 0, G_PARAM_READABLE)); /* CHECKME */
  g_object_class_install_property (gobject_class, ARG_FRAMES_DISPLAYED,
    g_param_spec_int ("frames_displayed", "Frames Displayed", "The number of frames displayed so far",
                      G_MININT,G_MAXINT, 0, G_PARAM_READWRITE)); /* CHECKME */
  g_object_class_install_property (gobject_class, ARG_FRAME_TIME,
    g_param_spec_int ("frame_time", "Frame time", "The interval between frames",
                      G_MININT, G_MAXINT, 0, G_PARAM_READWRITE)); /* CHECKME */
  g_object_class_install_property (gobject_class, ARG_HOOK,
-    g_param_spec_pointer ("hook", "Hook", "The object receiving the output", G_PARAM_WRITABLE));
+      g_param_spec_pointer ("hook", "Hook", "The object receiving the output",
 	  G_PARAM_WRITABLE));
  g_object_class_install_property (gobject_class, ARG_MUTE,
-    g_param_spec_boolean ("mute", "Mute", "mute the output ?", FALSE, G_PARAM_READWRITE));
+      g_param_spec_boolean ("mute", "Mute", "mute the output ?", FALSE,
 	  G_PARAM_READWRITE));
  g_object_class_install_property (gobject_class, ARG_REPAINT,
-    g_param_spec_boolean ("repaint", "Repaint", "repaint the current frame", FALSE, G_PARAM_WRITABLE));
+      g_param_spec_boolean ("repaint", "Repaint", "repaint the current frame",
 	  FALSE, G_PARAM_WRITABLE));
  g_object_class_install_property (gobject_class, ARG_DEMO,
-    g_param_spec_int ("demo", "Demo", "demo mode (shows 3D capabilities)",0, 1, 0, G_PARAM_READWRITE)); 
+      g_param_spec_int ("demo", "Demo", "demo mode (shows 3D capabilities)", 0,
 	  1, 0, G_PARAM_READWRITE));
  g_object_class_install_property (gobject_class, ARG_DUMP,
-    g_param_spec_boolean ("dump", "Dump", "stores sequence of frames in .ppm files", FALSE, G_PARAM_READWRITE));
+      g_param_spec_boolean ("dump", "Dump",
 	  "stores sequence of frames in .ppm files", FALSE, G_PARAM_READWRITE));
  gobject_class->set_property = gst_glsink_set_property;
  gobject_class->get_property = gst_glsink_get_property;
@ -287,18 +294,17 @@ gst_glsink_init (GstGLSink *sink)
 static void
 gst_glsink_release_conn (GstGLSink * sink)
 {
-  if (sink->conn == NULL) return;
+  if (sink->conn == NULL)
    return;
  /* free last image if any */
-  if (sink->last_image != NULL)
+  if (sink->last_image != NULL) {
  {
    gst_buffer_unref (sink->last_image);
    sink->last_image = NULL;
  }
  /* free cache */
  g_mutex_lock (sink->cache_lock);
-  while (sink->cache)
+  while (sink->cache) {
  {
    sink->plugin->free_image ((GstImageData *) sink->cache->data);
    sink->cache = g_list_delete_link (sink->cache, sink->cache);
  }
@ -355,11 +361,15 @@ gst_glsink_buffer_new (GstBufferPool *pool, gint64 location,
  Free a buffer that the chain doesn't need anymore. 
 */
 static void
-gst_glsink_buffer_free (GstBufferPool *pool, GstBuffer *buffer, gpointer user_data)
+gst_glsink_buffer_free (GstBufferPool * pool, GstBuffer * buffer,
    gpointer user_data)
 {
-  GstGLSink *sink = GST_GLSINK (gst_buffer_pool_get_user_data (GST_BUFFER_BUFFERPOOL (buffer)));
+  GstGLSink *sink =
      GST_GLSINK (gst_buffer_pool_get_user_data (GST_BUFFER_BUFFERPOOL
 	  (buffer)));
-  gst_glsink_append_cache (sink, (GstImageData *) GST_BUFFER_POOL_PRIVATE (buffer));
+  gst_glsink_append_cache (sink,
      (GstImageData *) GST_BUFFER_POOL_PRIVATE (buffer));
  /* set to NULL so the data is not freed */
  GST_BUFFER_DATA (buffer) = NULL;
@ -380,12 +390,12 @@ gst_glsink_set_caps (GstGLSink *sink, GstCaps *caps)
  GList *list = ((GstGLSinkClass *) G_OBJECT_GET_CLASS (sink))->plugins;
  GstImageConnection *conn = NULL;
-  while (list)    
+
-  {
+  while (list) {
    printf ("AGetting GLstring, context is %p\n", glXGetCurrentContext ());
    GstImagePlugin *plugin = (GstImagePlugin *) list->data;
-    if ((conn = plugin->set_caps (sink->hook, caps)) != NULL)
+
-    {
+    if ((conn = plugin->set_caps (sink->hook, caps)) != NULL) {
      //gst_glsink_release_conn (sink);
      printf ("BGetting GLstring, context is %p\n", glXGetCurrentContext ());
      sink->conn = conn;
@ -420,8 +430,7 @@ gst_glsink_sinkconnect (GstPad *pad, GstCaps *caps)
  result = gst_glsink_set_caps (sink, caps);
  gst_glxwindow_unhook_context (sink->hook);
-  if (result == FALSE)
+  if (result == FALSE) {
    {
    return GST_PAD_LINK_REFUSED;
  }
@ -452,9 +461,10 @@ gst_glsink_getcaps (GstPad *pad, GstCaps *caps)
  GList *list = ((GstGLSinkClass *) G_OBJECT_GET_CLASS (sink))->plugins;
  gst_glxwindow_hook_context (sink->hook);
-  while (list)    
+  while (list) {
-  {
+    ret =
-    ret = gst_caps_append (ret, ((GstImagePlugin *) list->data)->get_caps (sink->hook));
+	gst_caps_append (ret,
 	((GstImagePlugin *) list->data)->get_caps (sink->hook));
    list = g_list_next (list);
  }
@ -501,8 +511,7 @@ gst_glsink_chain (GstPad *pad, GstData *_data)
  static int frame_drops = 0;
  if (sink->clock && time != -1) {
-    if (time < gst_clock_get_time(sink->clock))
+    if (time < gst_clock_get_time (sink->clock)) {
      {
      g_warning ("Frame drop (%d consecutive) !!", frame_drops);
      /* we are going to drop late buffers */
      gst_buffer_unref (buf);
@ -512,7 +521,8 @@ gst_glsink_chain (GstPad *pad, GstData *_data)
    frame_drops = 0;		// we made it - reset time
    GstClockReturn ret;
-    GstClockID id = gst_clock_new_single_shot_id (sink->clock, GST_BUFFER_TIMESTAMP (buf));
+    GstClockID id =
 	gst_clock_new_single_shot_id (sink->clock, GST_BUFFER_TIMESTAMP (buf));
    ret = gst_element_clock_wait (GST_ELEMENT (sink), id, NULL);
    gst_clock_id_free (id);
@ -529,10 +539,8 @@ gst_glsink_chain (GstPad *pad, GstData *_data)
  sink->frames_displayed++;
  g_object_notify (G_OBJECT (sink), "frames_displayed");
-  if (!sink->muted)
+  if (!sink->muted) {
-  {
+    if (glXGetCurrentContext () == NULL) {
    if (glXGetCurrentContext() == NULL)
      {
      printf ("Rehooking window !\n");
      gst_glxwindow_hook_context (sink->hook);
@ -562,6 +570,7 @@ gst_glsink_chain (GstPad *pad, GstData *_data)
      glLoadIdentity ();
      GLfloat aspect = (GLfloat) w / (GLfloat) h;
      glFrustum (-aspect, aspect, -1.0, 1.0, 5.0, 500.0);
 #endif
@ -584,16 +593,20 @@ gst_glsink_chain (GstPad *pad, GstData *_data)
      sink->hook->demo = sink->demo;
      sink->hook->dumpvideo = sink->dumpvideo;
-      sink->plugin->put_image (sink->hook, (GstImageData *) GST_BUFFER_POOL_PRIVATE (buf));
+      sink->plugin->put_image (sink->hook,
 	  (GstImageData *) GST_BUFFER_POOL_PRIVATE (buf));
      sink->last_image = buf;
    } else {
-      buffer = gst_buffer_new_from_pool (gst_glsink_get_bufferpool (sink->sinkpad), 
+      buffer =
 	  gst_buffer_new_from_pool (gst_glsink_get_bufferpool (sink->sinkpad),
 	  0, GST_BUFFER_SIZE (buf));
      memcpy (GST_BUFFER_DATA (buffer), GST_BUFFER_DATA (buf),
-	      GST_BUFFER_SIZE (buf) > GST_BUFFER_SIZE (buffer) ? 
+	  GST_BUFFER_SIZE (buf) >
-	        GST_BUFFER_SIZE (buffer) : GST_BUFFER_SIZE (buf));
+	  GST_BUFFER_SIZE (buffer) ? GST_BUFFER_SIZE (buffer) :
 	  GST_BUFFER_SIZE (buf));
-      sink->plugin->put_image (sink->hook, (GstImageData *) GST_BUFFER_POOL_PRIVATE (buffer));
+      sink->plugin->put_image (sink->hook,
 	  (GstImageData *) GST_BUFFER_POOL_PRIVATE (buffer));
      sink->last_image = buffer;
      gst_buffer_unref (buf);
@ -606,7 +619,8 @@ gst_glsink_chain (GstPad *pad, GstData *_data)
 static void
-gst_glsink_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
+gst_glsink_set_property (GObject * object, guint prop_id, const GValue * value,
    GParamSpec * pspec)
 {
  //g_warning("in set_property!\n");
  GstGLSink *sink;
@ -625,8 +639,7 @@ gst_glsink_set_property (GObject *object, guint prop_id, const GValue *value, GP
      sink->frame_time = g_value_get_int (value);
      break;
    case ARG_HOOK:
-      if (sink->hook)
+      if (sink->hook) {
      {
 	sink->hook->free_info (sink->hook);
      }
      sink->hook = g_value_get_pointer (value);
@ -645,7 +658,8 @@ gst_glsink_set_property (GObject *object, guint prop_id, const GValue *value, GP
      break;
    case ARG_REPAINT:
      if (sink->last_image != NULL) {
-	sink->plugin->put_image (sink->hook, (GstImageData *) GST_BUFFER_POOL_PRIVATE (sink->last_image));
+	sink->plugin->put_image (sink->hook,
 	    (GstImageData *) GST_BUFFER_POOL_PRIVATE (sink->last_image));
      }
      break;
    default:
@ -655,7 +669,8 @@ gst_glsink_set_property (GObject *object, guint prop_id, const GValue *value, GP
 }
 static void
-gst_glsink_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
+gst_glsink_get_property (GObject * object, guint prop_id, GValue * value,
    GParamSpec * pspec)
 {
  //g_warning("in get_property!\n");
  GstGLSink *sink;
@ -741,11 +756,8 @@ plugin_init (GstPlugin *plugin)
    return FALSE;
  /* this is needed later on in the _real_ init (during a gst-launch) */
-  sink_template = gst_pad_template_new (
+  sink_template = gst_pad_template_new ("sink",
-		  "sink",
+      GST_PAD_SINK, GST_PAD_ALWAYS, NULL);
                  GST_PAD_SINK,
  		  GST_PAD_ALWAYS,
 		  NULL);
  if (!gst_element_register (plugin, "glsink", GST_RANK_NONE, GST_TYPE_GLSINK))
    return FALSE;
@ -753,14 +765,8 @@ plugin_init (GstPlugin *plugin)
  return TRUE;
 }
-GST_PLUGIN_DEFINE (
+GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
  GST_VERSION_MAJOR,
    GST_VERSION_MINOR,
    "glsink",
    "An OpenGL based video sink - uses OpenGL and GLX to draw video, utilizing different acceleration options",
-  plugin_init,
+    plugin_init, VERSION, GST_LICENSE, GST_PACKAGE, GST_ORIGIN);
  VERSION,
  GST_LICENSE,
  GST_PACKAGE,
  GST_ORIGIN
 );
--- a/gst/gl/gstglsink.h
+++ b/gst/gl/gstglsink.h
@ -25,13 +25,15 @@
 #include <gst/gst.h>
 #ifdef __cplusplus
-extern "C" {
+extern "C"
 {
 #endif				/* __cplusplus */
 #define MAX_FLIP_BUFFERS 1
  typedef struct _GstImageInfo GstImageInfo;
-struct _GstImageInfo {
+  struct _GstImageInfo
  {
    gulong id;
    int demo;
    int dumpvideo;
@ -40,26 +42,32 @@ struct _GstImageInfo {
  typedef struct _GstImageData GstImageData;
-struct _GstImageData {
+  struct _GstImageData
  {
    gint size;
    gchar *data;
  };
  typedef struct _GstImageConnection GstImageConnection;
-struct _GstImageConnection {
+  struct _GstImageConnection
  {
    void (*open_conn) (GstImageConnection * conn, GstImageInfo * info);
    void (*close_conn) (GstImageConnection * conn, GstImageInfo * info);
    void (*free_conn) (GstImageConnection * conn);
  };
  typedef GstCaps *(*GstImagePluginGetCapsFunc) (GstImageInfo * info);
-typedef GstImageConnection *	(*GstImagePluginSetCapsFunc) 	(GstImageInfo *info, GstCaps *caps);
+  typedef GstImageConnection *(*GstImagePluginSetCapsFunc) (GstImageInfo * info,
-typedef GstImageData*		(*GstImagePluginGetImageFunc)	(GstImageInfo *info, GstImageConnection *conn);
+      GstCaps * caps);
-typedef void 			(*GstImagePluginPutImageFunc)	(GstImageInfo *info, GstImageData *image);
+  typedef GstImageData *(*GstImagePluginGetImageFunc) (GstImageInfo * info,
      GstImageConnection * conn);
  typedef void (*GstImagePluginPutImageFunc) (GstImageInfo * info,
      GstImageData * image);
  typedef void (*GstImagePluginFreeImageFunc) (GstImageData * image);
  typedef struct _GstImagePlugin GstImagePlugin;
-struct _GstImagePlugin {
+  struct _GstImagePlugin
  {
    GstImagePluginGetCapsFunc get_caps;
    GstImagePluginSetCapsFunc set_caps;
    GstImagePluginGetImageFunc get_image;
@ -69,7 +77,8 @@ struct _GstImagePlugin {
  typedef struct _GstGLImageInfo GstGLImageInfo;
 /* stuff about our window grouped together */
-struct _GstGLImageInfo {
+  struct _GstGLImageInfo
  {
    GstImageInfo info;
    Display *dpy;
    int screen;
--- a/gst/gl/gstglxwindow.c
+++ b/gst/gl/gstglxwindow.c
@ -21,8 +21,7 @@
 /* attributes for a single buffered visual in RGBA format with at least
 * 4 bits per color and a 16 bit depth buffer */
-static int attrListSgl[] = 
+static int attrListSgl[] = {
 {
  GLX_RGBA, GLX_RED_SIZE, 4,
  GLX_GREEN_SIZE, 4,
  GLX_BLUE_SIZE, 4,
@ -32,8 +31,7 @@ static int attrListSgl[] =
 /* attributes for a double buffered visual in RGBA format with at least
 * 4 bits per color and a 16 bit depth buffer */
-static int attrListDbl[] = 
+static int attrListDbl[] = {
  { 
  GLX_RGBA, GLX_DOUBLEBUFFER,
  GLX_RED_SIZE, 4,
  GLX_GREEN_SIZE, 4,
@ -53,13 +51,10 @@ gst_glxwindow_unhook_context(GstImageInfo *info)
 {
  GstGLImageInfo *window = (GstGLImageInfo *) info;
-  if (window->ctx)
+  if (window->ctx) {
-    {
+    if (!glXMakeCurrent (window->dpy, None, NULL)) {
      if (!glXMakeCurrent(window->dpy, None, NULL))
        {
      printf ("Could not release drawing context.\n");
-        }
+    } else
      else
      printf ("Released drawing context.\n");
  }
 }
@ -69,13 +64,10 @@ gst_glxwindow_hook_context(GstImageInfo *info)
 {
  GstGLImageInfo *window = (GstGLImageInfo *) info;
-  if (window->ctx && window->win && window->ctx)
+  if (window->ctx && window->win && window->ctx) {
-    {
+    if (!glXMakeCurrent (window->dpy, window->win, window->ctx)) {
      if (!glXMakeCurrent(window->dpy, window->win, window->ctx))
        {
      printf ("Could not acquire GLX drawing context.\n");
-        }
+    } else
      else
      printf ("Acquired drawing context.\n");
  }
 }
@ -87,10 +79,8 @@ gst_glxwindow_free (GstImageInfo *info)
  g_signal_handler_disconnect (window->sink, window->handler_id);
-  if (window->ctx)
+  if (window->ctx) {
-    {
+    if (!glXMakeCurrent (window->dpy, None, NULL)) {
      if (!glXMakeCurrent(window->dpy, None, NULL))
        {
      printf ("Could not release drawing context.\n");
    }
    glXDestroyContext (window->dpy, window->ctx);
@ -98,8 +88,7 @@ gst_glxwindow_free (GstImageInfo *info)
  }
 #if 0
  /* switch back to original desktop resolution if we were in fs */
-    if (GLWin.fs)
+  if (GLWin.fs) {
    {
    XF86VidModeSwitchToMode (GLWin.dpy, GLWin.screen, &GLWin.deskMode);
    XF86VidModeSetViewPort (GLWin.dpy, GLWin.screen, 0, 0);
  }
@ -109,19 +98,21 @@ gst_glxwindow_free (GstImageInfo *info)
 }
 static void
-gst_glxwindow_callback(GObject *object, GParamSpec *pspec, GstGLImageInfo *data)
+gst_glxwindow_callback (GObject * object, GParamSpec * pspec,
    GstGLImageInfo * data)
 {
  XWindowAttributes attr;
  XGetWindowAttributes (data->dpy, data->win, &attr);
-  if (strncmp (pspec->name, "width", 5) == 0 || strncmp (pspec->name, "height", 6) == 0)
+  if (strncmp (pspec->name, "width", 5) == 0
-  {
+      || strncmp (pspec->name, "height", 6) == 0) {
    gint w = 0;
    gint h = 0;
    g_object_get (object, "width", &w, NULL);
    g_object_get (object, "height", &h, NULL);
-    if (w != attr.width || h != attr.height)
+    if (w != attr.width || h != attr.height) {
    {
      attr.width = w;
      attr.height = h;
      XResizeWindow (data->dpy, data->win, attr.width, attr.height);
@ -134,11 +125,11 @@ gst_glxwindow_callback(GObject *object, GParamSpec *pspec, GstGLImageInfo *data)
      glLoadIdentity ();
      GLfloat aspect = (GLfloat) h / (GLfloat) w;
      glFrustum (-1.0, 1.0, -aspect, aspect, 5.0, 500.0);
    }
  }
-  if (attr.width != data->width || attr.height != data->height)
+  if (attr.width != data->width || attr.height != data->height) {
  {
    data->width = attr.width;
    data->height = attr.height;
  }
@ -151,6 +142,7 @@ gst_glxwindow_new (GstElement *sink)
  //XGCValues values;
  GstGLImageInfo *new;
  int glxMajorVersion, glxMinorVersion;
  //XSetWindowAttributes attrib;
  XVisualInfo *vi;
  Atom wmDelete;
@ -161,8 +153,7 @@ gst_glxwindow_new (GstElement *sink)
  new = g_new0 (GstGLImageInfo, 1);
-  if (sink == NULL)
+  if (sink == NULL) {
  {
    sink = gst_element_factory_make ("glsink", "glsink");
    g_assert (sink != NULL);
  }
@ -180,13 +171,10 @@ gst_glxwindow_new (GstElement *sink)
  new->screen = DefaultScreen (new->dpy);
  /* get an appropriate visual */
  vi = glXChooseVisual (new->dpy, new->screen, attrListDbl);
-  if (vi == NULL)
+  if (vi == NULL) {
    {
    vi = glXChooseVisual (new->dpy, new->screen, attrListSgl);
    GST_DEBUG ("Only Singlebuffered Visual!\n");
-    }
+  } else {
  else
    {
    GST_DEBUG ("Got Doublebuffered Visual!\n");
  }
  glXQueryVersion (new->dpy, &glxMajorVersion, &glxMinorVersion);
@ -216,10 +204,9 @@ gst_glxwindow_new (GstElement *sink)
    new->attr.event_mask = ExposureMask | KeyPressMask | ButtonPressMask |
 	StructureNotifyMask;
    new->win = XCreateWindow (new->dpy, RootWindow (new->dpy, vi->screen),
-			      new->x, new->y, new->width, new->height, 0, vi->depth, InputOutput, vi->visual,
+	new->x, new->y, new->width, new->height, 0, vi->depth, InputOutput,
-			      CWBorderPixel | CWColormap | CWEventMask, &new->attr);
+	vi->visual, CWBorderPixel | CWColormap | CWEventMask, &new->attr);
-    if (!new->win) 
+    if (!new->win) {
      {
      g_warning ("create window failed\n");
      g_free (new);
      return;
@ -272,6 +259,7 @@ gst_glxwindow_new (GstElement *sink)
  g_object_set (sink, "hook", new, NULL);
  new->sink = sink;
-  new->handler_id = g_signal_connect (sink, "notify", G_CALLBACK (gst_glxwindow_callback), new);
+  new->handler_id =
      g_signal_connect (sink, "notify", G_CALLBACK (gst_glxwindow_callback),
      new);
 }
--- a/gst/gl/regcomb_yuvrgb.c
+++ b/gst/gl/regcomb_yuvrgb.c
@ -28,7 +28,8 @@ unsigned int UVwidth=256, UVheight=512;
 int tex_xsize, tex_ysize;
-void GenerateRGBTables(unsigned char *Ytable, // Y-palette
+void
 GenerateRGBTables (unsigned char *Ytable,	// Y-palette
    unsigned char *Utable,	// U-palette
    unsigned char *Vtable,	// V-palette
    float *bias,		// bias (fourth vector to be added)
@ -77,7 +78,9 @@ void GenerateRGBTables(unsigned char *Ytable, // Y-palette
 // Sets the constants. Call once prior to rendering.
-void SetConsts(float *bias, float *Uscale, float *Vscale) {
+void
 SetConsts (float *bias, float *Uscale, float *Vscale)
 {
  glEnable (GL_REGISTER_COMBINERS_NV);
  glColor3fv (bias);
  //printf("%f %f %f\n",bias[0],bias[1],bias[2]);
@ -89,60 +92,73 @@ void SetConsts(float *bias, float *Uscale, float *Vscale) {
 * SOFTWARE PATH
 */
-inline void map_EXPAND_NORMAL(float *v) {
+inline void
 map_EXPAND_NORMAL (float *v)
 {
  v[0] = 2.0f * v[0] - 1.0f;
  v[1] = 2.0f * v[1] - 1.0f;
  v[2] = 2.0f * v[2] - 1.0f;
 }
-inline void map_UNSIGNED_INVERT(float *v) {
+inline void
 map_UNSIGNED_INVERT (float *v)
 {
  v[0] = 1.0f - v[0];
  v[1] = 1.0f - v[1];
  v[2] = 1.0f - v[2];
 }
-inline void map_UNSIGNED_IDENTITY(float *v) {
+inline void
 map_UNSIGNED_IDENTITY (float *v)
 {
  v[0] = (v[0] < 0.0f ? 0.0f : v[0]);
  v[1] = (v[1] < 0.0f ? 0.0f : v[1]);
  v[2] = (v[2] < 0.0f ? 0.0f : v[2]);
 }
-inline void map_SIGNED_IDENTITY(float *v) {
+inline void
 map_SIGNED_IDENTITY (float *v)
 {
 }
-inline void omap_SCALE_BY_TWO(float *v) {
+inline void
 omap_SCALE_BY_TWO (float *v)
 {
  v[0] *= 2.0f;
  v[1] *= 2.0f;
  v[2] *= 2.0f;
 }
-inline void omap_SCALE_BY_ONE_HALF(float *v) {
+inline void
 omap_SCALE_BY_ONE_HALF (float *v)
 {
  v[0] *= 0.5f;
  v[1] *= 0.5f;
  v[2] *= 0.5f;
 }
-inline void omap_RANGE(float *v) {
+inline void
 omap_RANGE (float *v)
 {
  v[0] = (v[0] < -1.0f ? -1.0f : (v[0] > 1.0f ? 1.0f : v[0]));
  v[1] = (v[1] < -1.0f ? -1.0f : (v[1] > 1.0f ? 1.0f : v[1]));
  v[2] = (v[2] < -1.0f ? -1.0f : (v[2] > 1.0f ? 1.0f : v[2]));
 }
-inline void omap_CLAMP_01(float *v) {
+inline void
 omap_CLAMP_01 (float *v)
 {
  v[0] = (v[0] < 0.0f ? 0.0f : (v[0] > 1.0f ? 1.0f : v[0]));
  v[1] = (v[1] < 0.0f ? 0.0f : (v[1] > 1.0f ? 1.0f : v[1]));
  v[2] = (v[2] < 0.0f ? 0.0f : (v[2] > 1.0f ? 1.0f : v[2]));
 }
-void PerformSWCombiner(unsigned char *Result,
+void
 PerformSWCombiner (unsigned char *Result,
    unsigned char *tex0,
    unsigned char *tex1,
-					   unsigned char *tex2,
+    unsigned char *tex2, float *COLOR0, float *CONST0, float *CONST1)
 					   float *COLOR0,
 					   float *CONST0,
 					   float *CONST1
 						) 
 {
  float SPARE0[3];
  float SPARE1[3];
@ -163,10 +179,14 @@ void PerformSWCombiner(unsigned char *Result,
  TEX2[2] = (float) tex2[2] / 255.0f;
  // Combiner Stage 0:
-	memcpy(A,TEX0,3*sizeof(float));		map_UNSIGNED_IDENTITY(A);
+  memcpy (A, TEX0, 3 * sizeof (float));
-	memcpy(B,ZERO,3*sizeof(float));		map_UNSIGNED_INVERT(B);
+  map_UNSIGNED_IDENTITY (A);
-	memcpy(C,COLOR0,3*sizeof(float));	map_EXPAND_NORMAL(C);
+  memcpy (B, ZERO, 3 * sizeof (float));
-	memcpy(D,ZERO,3*sizeof(float));		map_UNSIGNED_INVERT(D);
+  map_UNSIGNED_INVERT (B);
  memcpy (C, COLOR0, 3 * sizeof (float));
  map_EXPAND_NORMAL (C);
  memcpy (D, ZERO, 3 * sizeof (float));
  map_UNSIGNED_INVERT (D);
  SPARE0[0] = A[0] * B[0] + C[0] * D[0];
  SPARE0[1] = A[1] * B[1] + C[1] * D[1];
  SPARE0[2] = A[2] * B[2] + C[2] * D[2];
@ -174,20 +194,28 @@ void PerformSWCombiner(unsigned char *Result,
  omap_RANGE (SPARE0);
  // Combiner Stage 1:
-	memcpy(A,TEX1,3*sizeof(float));		map_EXPAND_NORMAL(A);
+  memcpy (A, TEX1, 3 * sizeof (float));
-	memcpy(B,CONST0,3*sizeof(float));	map_UNSIGNED_IDENTITY(B);
+  map_EXPAND_NORMAL (A);
-	memcpy(C,TEX2,3*sizeof(float));		map_EXPAND_NORMAL(C);
+  memcpy (B, CONST0, 3 * sizeof (float));
-	memcpy(D,CONST1,3*sizeof(float));	map_UNSIGNED_IDENTITY(D);
+  map_UNSIGNED_IDENTITY (B);
  memcpy (C, TEX2, 3 * sizeof (float));
  map_EXPAND_NORMAL (C);
  memcpy (D, CONST1, 3 * sizeof (float));
  map_UNSIGNED_IDENTITY (D);
  SPARE1[0] = A[0] * B[0] + C[0] * D[0];
  SPARE1[1] = A[1] * B[1] + C[1] * D[1];
  SPARE1[2] = A[2] * B[2] + C[2] * D[2];
  omap_RANGE (SPARE1);
  // Combiner Stage 2:
-	memcpy(A,SPARE0,3*sizeof(float));	map_SIGNED_IDENTITY(A);
+  memcpy (A, SPARE0, 3 * sizeof (float));
-	memcpy(B,ZERO,3*sizeof(float));		map_UNSIGNED_INVERT(B);
+  map_SIGNED_IDENTITY (A);
-	memcpy(C,SPARE1,3*sizeof(float));	map_SIGNED_IDENTITY(C);
+  memcpy (B, ZERO, 3 * sizeof (float));
-	memcpy(D,ZERO,3*sizeof(float));		map_UNSIGNED_INVERT(D);
+  map_UNSIGNED_INVERT (B);
  memcpy (C, SPARE1, 3 * sizeof (float));
  map_SIGNED_IDENTITY (C);
  memcpy (D, ZERO, 3 * sizeof (float));
  map_UNSIGNED_INVERT (D);
  SPARE0[0] = A[0] * B[0] + C[0] * D[0];
  SPARE0[1] = A[1] * B[1] + C[1] * D[1];
  SPARE0[2] = A[2] * B[2] + C[2] * D[2];
@ -195,10 +223,14 @@ void PerformSWCombiner(unsigned char *Result,
  omap_RANGE (SPARE0);
  // Final Combiner Stage:
-	memcpy(A,ZERO,3*sizeof(float));		map_UNSIGNED_INVERT(A);
+  memcpy (A, ZERO, 3 * sizeof (float));
-	memcpy(B,SPARE0,3*sizeof(float));	map_UNSIGNED_IDENTITY(B);
+  map_UNSIGNED_INVERT (A);
-	memcpy(C,ZERO,3*sizeof(float));		map_UNSIGNED_IDENTITY(C);
+  memcpy (B, SPARE0, 3 * sizeof (float));
-	memcpy(D,ZERO,3*sizeof(float));		map_UNSIGNED_IDENTITY(D);
+  map_UNSIGNED_IDENTITY (B);
  memcpy (C, ZERO, 3 * sizeof (float));
  map_UNSIGNED_IDENTITY (C);
  memcpy (D, ZERO, 3 * sizeof (float));
  map_UNSIGNED_IDENTITY (D);
  SPARE0[0] = A[0] * B[0] + (1.0f - A[0]) * C[0] + D[0];
  SPARE0[1] = A[1] * B[1] + (1.0f - A[1]) * C[1] + D[1];
  SPARE0[2] = A[2] * B[2] + (1.0f - A[2]) * C[2] + D[2];
@ -209,56 +241,81 @@ void PerformSWCombiner(unsigned char *Result,
 }
 // Sets up the register combiners. Call once prior to rendering
-void SetupCombiners(void) 
+void
 SetupCombiners (void)
 {
  glCombinerParameteriNV (GL_NUM_GENERAL_COMBINERS_NV, 3);
  // Combiner Stage 0: th. OK
-	glCombinerInputNV (GL_COMBINER0_NV,GL_RGB,GL_VARIABLE_A_NV,GL_TEXTURE0_ARB,    GL_UNSIGNED_IDENTITY_NV,GL_RGB);
+  glCombinerInputNV (GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_A_NV, GL_TEXTURE0_ARB,
-	glCombinerInputNV (GL_COMBINER0_NV,GL_RGB,GL_VARIABLE_B_NV,GL_ZERO,            GL_UNSIGNED_INVERT_NV,  GL_RGB);
+      GL_UNSIGNED_IDENTITY_NV, GL_RGB);
-	glCombinerInputNV (GL_COMBINER0_NV,GL_RGB,GL_VARIABLE_C_NV,GL_PRIMARY_COLOR_NV,GL_EXPAND_NORMAL_NV,    GL_RGB);
+  glCombinerInputNV (GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_B_NV, GL_ZERO,
-	glCombinerInputNV (GL_COMBINER0_NV,GL_RGB,GL_VARIABLE_D_NV,GL_ZERO,            GL_UNSIGNED_INVERT_NV,  GL_RGB);
+      GL_UNSIGNED_INVERT_NV, GL_RGB);
-	glCombinerOutputNV(GL_COMBINER0_NV,GL_RGB,GL_DISCARD_NV,GL_DISCARD_NV,GL_SPARE0_NV,GL_SCALE_BY_ONE_HALF_NV,GL_NONE,GL_FALSE,GL_FALSE,GL_FALSE);
+  glCombinerInputNV (GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_C_NV,
      GL_PRIMARY_COLOR_NV, GL_EXPAND_NORMAL_NV, GL_RGB);
  glCombinerInputNV (GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_D_NV, GL_ZERO,
      GL_UNSIGNED_INVERT_NV, GL_RGB);
  glCombinerOutputNV (GL_COMBINER0_NV, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV,
      GL_SPARE0_NV, GL_SCALE_BY_ONE_HALF_NV, GL_NONE, GL_FALSE, GL_FALSE,
      GL_FALSE);
  // Combiner Stage 1: th. OK
-	glCombinerInputNV (GL_COMBINER1_NV,GL_RGB,GL_VARIABLE_A_NV,GL_TEXTURE1_ARB,      GL_EXPAND_NORMAL_NV,    GL_RGB);
+  glCombinerInputNV (GL_COMBINER1_NV, GL_RGB, GL_VARIABLE_A_NV, GL_TEXTURE1_ARB,
-	glCombinerInputNV (GL_COMBINER1_NV,GL_RGB,GL_VARIABLE_B_NV,GL_CONSTANT_COLOR0_NV,GL_UNSIGNED_IDENTITY_NV,GL_RGB);
+      GL_EXPAND_NORMAL_NV, GL_RGB);
-	glCombinerInputNV (GL_COMBINER1_NV,GL_RGB,GL_VARIABLE_C_NV,GL_TEXTURE2_ARB,      GL_EXPAND_NORMAL_NV,    GL_RGB);
+  glCombinerInputNV (GL_COMBINER1_NV, GL_RGB, GL_VARIABLE_B_NV,
-	glCombinerInputNV (GL_COMBINER1_NV,GL_RGB,GL_VARIABLE_D_NV,GL_CONSTANT_COLOR1_NV,GL_UNSIGNED_IDENTITY_NV,GL_RGB);
+      GL_CONSTANT_COLOR0_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
-	glCombinerOutputNV(GL_COMBINER1_NV,GL_RGB,GL_DISCARD_NV,GL_DISCARD_NV,GL_SPARE1_NV,GL_NONE,GL_NONE,GL_FALSE,GL_FALSE,GL_FALSE);
+  glCombinerInputNV (GL_COMBINER1_NV, GL_RGB, GL_VARIABLE_C_NV, GL_TEXTURE2_ARB,
      GL_EXPAND_NORMAL_NV, GL_RGB);
  glCombinerInputNV (GL_COMBINER1_NV, GL_RGB, GL_VARIABLE_D_NV,
      GL_CONSTANT_COLOR1_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
  glCombinerOutputNV (GL_COMBINER1_NV, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV,
      GL_SPARE1_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE);
  // Combiner Stage 2: th. OK
-	glCombinerInputNV (GL_COMBINER2_NV,GL_RGB,GL_VARIABLE_A_NV,GL_SPARE0_NV,       GL_SIGNED_IDENTITY_NV,  GL_RGB);
+  glCombinerInputNV (GL_COMBINER2_NV, GL_RGB, GL_VARIABLE_A_NV, GL_SPARE0_NV,
-	glCombinerInputNV (GL_COMBINER2_NV,GL_RGB,GL_VARIABLE_B_NV,GL_ZERO,            GL_UNSIGNED_INVERT_NV,  GL_RGB);
+      GL_SIGNED_IDENTITY_NV, GL_RGB);
-	glCombinerInputNV (GL_COMBINER2_NV,GL_RGB,GL_VARIABLE_C_NV,GL_SPARE1_NV,       GL_SIGNED_IDENTITY_NV,  GL_RGB);
+  glCombinerInputNV (GL_COMBINER2_NV, GL_RGB, GL_VARIABLE_B_NV, GL_ZERO,
-	glCombinerInputNV (GL_COMBINER2_NV,GL_RGB,GL_VARIABLE_D_NV,GL_ZERO,            GL_UNSIGNED_INVERT_NV,  GL_RGB);
+      GL_UNSIGNED_INVERT_NV, GL_RGB);
-	glCombinerOutputNV(GL_COMBINER2_NV,GL_RGB,GL_DISCARD_NV,GL_DISCARD_NV,GL_SPARE0_NV,GL_SCALE_BY_TWO_NV,GL_NONE,GL_FALSE,GL_FALSE,GL_FALSE);
+  glCombinerInputNV (GL_COMBINER2_NV, GL_RGB, GL_VARIABLE_C_NV, GL_SPARE1_NV,
      GL_SIGNED_IDENTITY_NV, GL_RGB);
  glCombinerInputNV (GL_COMBINER2_NV, GL_RGB, GL_VARIABLE_D_NV, GL_ZERO,
      GL_UNSIGNED_INVERT_NV, GL_RGB);
  glCombinerOutputNV (GL_COMBINER2_NV, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV,
      GL_SPARE0_NV, GL_SCALE_BY_TWO_NV, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE);
  // Final Sage: th. OK
-	glFinalCombinerInputNV(GL_VARIABLE_A_NV,GL_ZERO,     GL_UNSIGNED_INVERT_NV,  GL_RGB);
+  glFinalCombinerInputNV (GL_VARIABLE_A_NV, GL_ZERO, GL_UNSIGNED_INVERT_NV,
-	glFinalCombinerInputNV(GL_VARIABLE_B_NV,GL_SPARE0_NV,GL_UNSIGNED_IDENTITY_NV,GL_RGB);
+      GL_RGB);
-	glFinalCombinerInputNV(GL_VARIABLE_C_NV,GL_ZERO,     GL_UNSIGNED_IDENTITY_NV,GL_RGB);
+  glFinalCombinerInputNV (GL_VARIABLE_B_NV, GL_SPARE0_NV,
-	glFinalCombinerInputNV(GL_VARIABLE_D_NV,GL_ZERO,     GL_UNSIGNED_IDENTITY_NV,GL_RGB);
+      GL_UNSIGNED_IDENTITY_NV, GL_RGB);
-	glFinalCombinerInputNV(GL_VARIABLE_G_NV,GL_ZERO,     GL_UNSIGNED_INVERT_NV,  GL_ALPHA);
+  glFinalCombinerInputNV (GL_VARIABLE_C_NV, GL_ZERO, GL_UNSIGNED_IDENTITY_NV,
      GL_RGB);
  glFinalCombinerInputNV (GL_VARIABLE_D_NV, GL_ZERO, GL_UNSIGNED_IDENTITY_NV,
      GL_RGB);
  glFinalCombinerInputNV (GL_VARIABLE_G_NV, GL_ZERO, GL_UNSIGNED_INVERT_NV,
      GL_ALPHA);
 }
-unsigned int PowerOfTwo(unsigned int i) {
+unsigned int
 PowerOfTwo (unsigned int i)
 {
  unsigned int bitsum = 0;
  unsigned int shifts = 0;
  unsigned int j = (unsigned int) i;
  // Check wether i is a power of two - may contain at most one set bit
  do {
    bitsum += j & 1;
    j = j >> 1;
    ++shifts;
  } while (j > 0);
-	if (bitsum==1) return i;
+  if (bitsum == 1)
-	else return (1<<shifts);
+    return i;
  else
    return (1 << shifts);
 }
 // Initializes textures. Call once prior to rendering
-void InitYUVPlanes(GLuint *Yhandle, GLuint *Uhandle, GLuint *Vhandle, 
+void
-		   unsigned int Ywidth,  unsigned int Yheight,
+InitYUVPlanes (GLuint * Yhandle, GLuint * Uhandle, GLuint * Vhandle, unsigned int Ywidth, unsigned int Yheight, unsigned int UVwidth, unsigned int UVheight, GLenum filter,	// filter should be either GL_NEAREST or GL_LINEAR. Test this! 
 		   unsigned int UVwidth, unsigned int UVheight,
 		   GLenum filter, // filter should be either GL_NEAREST or GL_LINEAR. Test this! 
    unsigned char *Ypal, unsigned char *Upal, unsigned char *Vpal)
 {
  glGenTextures (1, Yhandle);
@ -276,7 +333,8 @@ void InitYUVPlanes(GLuint *Yhandle, GLuint *Uhandle, GLuint *Vhandle,
  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
  tex_xsize = PowerOfTwo (Ywidth);
  tex_ysize = PowerOfTwo (Yheight);
-  glTexImage2D(GL_TEXTURE_2D,0,GL_COLOR_INDEX8_EXT,PowerOfTwo(Ywidth),PowerOfTwo(Yheight),0,GL_COLOR_INDEX,GL_UNSIGNED_BYTE,NULL);
+  glTexImage2D (GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT, PowerOfTwo (Ywidth),
      PowerOfTwo (Yheight), 0, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, NULL);
  glBindTexture (GL_TEXTURE_2D, (*Uhandle));
 #ifdef _WIN32
@ -288,7 +346,8 @@ void InitYUVPlanes(GLuint *Yhandle, GLuint *Uhandle, GLuint *Vhandle,
  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter);
  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
-  glTexImage2D(GL_TEXTURE_2D,0,GL_COLOR_INDEX8_EXT,PowerOfTwo(UVwidth),PowerOfTwo(UVheight),0,GL_COLOR_INDEX,GL_UNSIGNED_BYTE,NULL);
+  glTexImage2D (GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT, PowerOfTwo (UVwidth),
      PowerOfTwo (UVheight), 0, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, NULL);
  glBindTexture (GL_TEXTURE_2D, (*Vhandle));
 #ifdef _WIN32
@ -300,36 +359,42 @@ void InitYUVPlanes(GLuint *Yhandle, GLuint *Uhandle, GLuint *Vhandle,
  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter);
  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
-  glTexImage2D(GL_TEXTURE_2D,0,GL_COLOR_INDEX8_EXT,PowerOfTwo(UVwidth),PowerOfTwo(UVheight),0,GL_COLOR_INDEX,GL_UNSIGNED_BYTE,NULL);
+  glTexImage2D (GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT, PowerOfTwo (UVwidth),
      PowerOfTwo (UVheight), 0, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, NULL);
 }
-void LoadYUVPlanes(GLuint Yhandle, GLuint Uhandle, GLuint Vhandle,
+void
 LoadYUVPlanes (GLuint Yhandle, GLuint Uhandle, GLuint Vhandle,
    unsigned int Ywidth, unsigned int Yheight,
    unsigned int UVwidth, unsigned int UVheight,
-		   unsigned char *Ydata,
+    unsigned char *Ydata, unsigned char *Udata, unsigned char *Vdata)
 		   unsigned char *Udata,
 		   unsigned char *Vdata) 
 {
  glActiveTextureARB (GL_TEXTURE0_ARB);
  glBindTexture (GL_TEXTURE_2D, Yhandle);
-  glTexSubImage2D(GL_TEXTURE_2D,0,0,0,Ywidth,Yheight,GL_COLOR_INDEX,GL_UNSIGNED_BYTE,Ydata);
+  glTexSubImage2D (GL_TEXTURE_2D, 0, 0, 0, Ywidth, Yheight, GL_COLOR_INDEX,
      GL_UNSIGNED_BYTE, Ydata);
  glEnable (GL_TEXTURE_2D);
  glActiveTextureARB (GL_TEXTURE1_ARB);
  glBindTexture (GL_TEXTURE_2D, Uhandle);
-  glTexSubImage2D(GL_TEXTURE_2D,0,0,0,UVwidth,UVheight,GL_COLOR_INDEX,GL_UNSIGNED_BYTE,Udata);
+  glTexSubImage2D (GL_TEXTURE_2D, 0, 0, 0, UVwidth, UVheight, GL_COLOR_INDEX,
      GL_UNSIGNED_BYTE, Udata);
  glEnable (GL_TEXTURE_2D);
  glActiveTextureARB (GL_TEXTURE2_ARB);
  glBindTexture (GL_TEXTURE_2D, Vhandle);
-  glTexSubImage2D(GL_TEXTURE_2D,0,0,0,UVwidth,UVheight,GL_COLOR_INDEX,GL_UNSIGNED_BYTE,Vdata);
+  glTexSubImage2D (GL_TEXTURE_2D, 0, 0, 0, UVwidth, UVheight, GL_COLOR_INDEX,
      GL_UNSIGNED_BYTE, Vdata);
  glEnable (GL_TEXTURE_2D);
 }
-void Initialize_Backend(unsigned int Ywidth, unsigned int Yheight, unsigned int UVwidth, unsigned int UVheight, GLenum filter) 
+void
 Initialize_Backend (unsigned int Ywidth, unsigned int Yheight,
    unsigned int UVwidth, unsigned int UVheight, GLenum filter)
 {
-  printf("Reinitializing register combiner backend with res %d x %d!\n", Ywidth, Yheight);
+  printf ("Reinitializing register combiner backend with res %d x %d!\n",
      Ywidth, Yheight);
  //if (!GL_ARB_multitexture_Init()) exit(0);
  //if (!GL_EXT_paletted_texture_Init()) exit(0);
  //if (!GL_NV_register_combiners_Init()) exit(0);
@ -339,14 +404,18 @@ void Initialize_Backend(unsigned int Ywidth, unsigned int Yheight, unsigned int
  float bias[4];
  float Uscale[4];
  float Vscale[4];
  GenerateRGBTables (Ypal, Upal, Vpal, bias, Uscale, Vscale);
-  InitYUVPlanes(&Yhandle,&Uhandle,&Vhandle,Ywidth,Yheight,UVwidth,UVheight,filter,Ypal,Upal,Vpal);
+  InitYUVPlanes (&Yhandle, &Uhandle, &Vhandle, Ywidth, Yheight, UVwidth,
      UVheight, filter, Ypal, Upal, Vpal);
  SetupCombiners ();
  SetConsts (bias, Uscale, Vscale);
 }
-void initialize(GLenum filter) {
+void
 initialize (GLenum filter)
 {
  glShadeModel (GL_SMOOTH);
  glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
  glClearColor (0.0f, 0.0f, 0.2f, 1.0f);