gst-indent

Original commit message from CVS:
gst-indent

10 files changed, 2206 insertions, 1767 deletions

diff --git a/sys/glsink/ARB_multitexture.h b/sys/glsink/ARB_multitexture.h
index 36dcf011..6718e2fc 100644
--- a/sys/glsink/ARB_multitexture.h
+++ b/sys/glsink/ARB_multitexture.h
@@ -7,42 +7,42 @@
  *                                                           *

  * version 1.0ß                                              *

  *                                                           *

- *************************************************************/

-

+ *************************************************************/  

+    

 #ifndef __ARB_MULTITEXTURE_H_

 #define __ARB_MULTITEXTURE_H_

-

+    

 /*

  *  GLOBAL SWITCHES - enable/disable advanced features of this header

  *

- */

-#define ARB_MULTITEXTURE_INITIALIZE 1 // enable generic init-routines

+ */ 

+#define ARB_MULTITEXTURE_INITIALIZE 1	// enable generic init-routines

 #ifndef _WIN32

 #define GL_GLEXT_PROTOTYPES 1

-#endif

-

+#endif /* 
 */
+    

 #ifdef __cplusplus

-extern "C" {

-#endif

-

+extern "C"
+{
+  

+#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 

  *

- */

+ */ 

 #ifndef GL_ARB_multitexture

 #define GL_TEXTURE0_ARB                   0x84C0

 #define GL_TEXTURE1_ARB                   0x84C1

@@ -80,232 +80,421 @@ 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

-extern void APIENTRY glActiveTextureARB (GLenum);

-extern void APIENTRY glClientActiveTextureARB (GLenum);

-extern void APIENTRY glMultiTexCoord1dARB (GLenum, GLdouble);

-extern void APIENTRY glMultiTexCoord1dvARB (GLenum, const GLdouble *);

-extern void APIENTRY glMultiTexCoord1fARB (GLenum, GLfloat);

-extern void APIENTRY glMultiTexCoord1fvARB (GLenum, const GLfloat *);

-extern void APIENTRY glMultiTexCoord1iARB (GLenum, GLint);

-extern void APIENTRY glMultiTexCoord1ivARB (GLenum, const GLint *);

-extern void APIENTRY glMultiTexCoord1sARB (GLenum, GLshort);

-extern void APIENTRY glMultiTexCoord1svARB (GLenum, const GLshort *);

-extern void APIENTRY glMultiTexCoord2dARB (GLenum, GLdouble, GLdouble);

-extern void APIENTRY glMultiTexCoord2dvARB (GLenum, const GLdouble *);

-extern void APIENTRY glMultiTexCoord2fARB (GLenum, GLfloat, GLfloat);

-extern void APIENTRY glMultiTexCoord2fvARB (GLenum, const GLfloat *);

-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 glMultiTexCoord3dvARB (GLenum, const GLdouble *);

-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 glMultiTexCoord3svARB (GLenum, const GLshort *);

-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 glMultiTexCoord4fvARB (GLenum, const GLfloat *);

-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 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 * PFNGLMULTITEXCOORD1DVARBPROC) (GLenum target, const GLdouble *v);

-typedef void (APIENTRY * PFNGLMULTITEXCOORD1FARBPROC) (GLenum target, GLfloat s);

-typedef void (APIENTRY * PFNGLMULTITEXCOORD1FVARBPROC) (GLenum target, const GLfloat *v);

-typedef void (APIENTRY * PFNGLMULTITEXCOORD1IARBPROC) (GLenum target, GLint s);

-typedef void (APIENTRY * PFNGLMULTITEXCOORD1IVARBPROC) (GLenum target, const GLint *v);

-typedef void (APIENTRY * PFNGLMULTITEXCOORD1SARBPROC) (GLenum target, GLshort s);

-typedef void (APIENTRY * PFNGLMULTITEXCOORD1SVARBPROC) (GLenum target, const GLshort *v);

-typedef void (APIENTRY * PFNGLMULTITEXCOORD2DARBPROC) (GLenum target, GLdouble s, GLdouble t);

-typedef void (APIENTRY * PFNGLMULTITEXCOORD2DVARBPROC) (GLenum target, const GLdouble *v);

-typedef void (APIENTRY * PFNGLMULTITEXCOORD2FARBPROC) (GLenum target, GLfloat s, GLfloat t);

-typedef void (APIENTRY * PFNGLMULTITEXCOORD2FVARBPROC) (GLenum target, const GLfloat *v);

-typedef void (APIENTRY * PFNGLMULTITEXCOORD2IARBPROC) (GLenum target, GLint s, GLint t);

-typedef void (APIENTRY * PFNGLMULTITEXCOORD2IVARBPROC) (GLenum target, const GLint *v);

-typedef void (APIENTRY * PFNGLMULTITEXCOORD2SARBPROC) (GLenum target, GLshort s, GLshort t);

-typedef void (APIENTRY * PFNGLMULTITEXCOORD2SVARBPROC) (GLenum target, 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

-

+  extern void APIENTRY glActiveTextureARB (GLenum);
+   
extern void APIENTRY glClientActiveTextureARB (GLenum);
+   
extern void APIENTRY glMultiTexCoord1dARB (GLenum, GLdouble);
+   
extern void APIENTRY glMultiTexCoord1dvARB (GLenum, const GLdouble *);
+   
extern void APIENTRY glMultiTexCoord1fARB (GLenum, GLfloat);
+   
extern void APIENTRY glMultiTexCoord1fvARB (GLenum, const GLfloat *);
+   
extern void APIENTRY glMultiTexCoord1iARB (GLenum, GLint);
+   
extern void APIENTRY glMultiTexCoord1ivARB (GLenum, const GLint *);
+   
extern void APIENTRY glMultiTexCoord1sARB (GLenum, GLshort);
+   
extern void APIENTRY glMultiTexCoord1svARB (GLenum, const GLshort *);
+   
extern void APIENTRY glMultiTexCoord2dARB (GLenum, GLdouble, GLdouble);
+   
extern void APIENTRY glMultiTexCoord2dvARB (GLenum, const GLdouble *);
+   
extern void APIENTRY glMultiTexCoord2fARB (GLenum, GLfloat, GLfloat);
+   
extern void APIENTRY glMultiTexCoord2fvARB (GLenum, const GLfloat *);
+   
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 glMultiTexCoord3dvARB (GLenum, const GLdouble *);
+   
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 glMultiTexCoord3svARB (GLenum, const GLshort *);
+   
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 glMultiTexCoord4fvARB (GLenum, const GLfloat *);
+   
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 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 * PFNGLMULTITEXCOORD1DVARBPROC) (GLenum target,
+      const GLdouble * v);
+   
typedef void (APIENTRY * PFNGLMULTITEXCOORD1FARBPROC) (GLenum target,
+      GLfloat s);
+   
typedef void (APIENTRY * PFNGLMULTITEXCOORD1FVARBPROC) (GLenum target,
+      const GLfloat * v);
+   
typedef void (APIENTRY * PFNGLMULTITEXCOORD1IARBPROC) (GLenum target,
+      GLint s);
+   
typedef void (APIENTRY * PFNGLMULTITEXCOORD1IVARBPROC) (GLenum target,
+      const GLint * v);
+   
typedef void (APIENTRY * PFNGLMULTITEXCOORD1SARBPROC) (GLenum target,
+      GLshort s);
+   
typedef void (APIENTRY * PFNGLMULTITEXCOORD1SVARBPROC) (GLenum target,
+      const GLshort * v);
+   
typedef void (APIENTRY * PFNGLMULTITEXCOORD2DARBPROC) (GLenum target,
+      GLdouble s, GLdouble t);
+   
typedef void (APIENTRY * PFNGLMULTITEXCOORD2DVARBPROC) (GLenum target,
+      const GLdouble * v);
+   
typedef void (APIENTRY * PFNGLMULTITEXCOORD2FARBPROC) (GLenum target,
+      GLfloat s, GLfloat t);
+   
typedef void (APIENTRY * PFNGLMULTITEXCOORD2FVARBPROC) (GLenum target,
+      const GLfloat * v);
+   
typedef void (APIENTRY * PFNGLMULTITEXCOORD2IARBPROC) (GLenum target,
+      GLint s, GLint t);
+   
typedef void (APIENTRY * PFNGLMULTITEXCOORD2IVARBPROC) (GLenum target,
+      const GLint * v);
+   
typedef void (APIENTRY * PFNGLMULTITEXCOORD2SARBPROC) (GLenum target,
+      GLshort s, GLshort t);
+   
typedef void (APIENTRY * PFNGLMULTITEXCOORD2SVARBPROC) (GLenum target,
+      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

 #include<string.h>		// string manipulation for runtime-check

-

+   

 #ifdef _WIN32

-PFNGLACTIVETEXTUREARBPROC       glActiveTextureARB       = NULL;

-PFNGLCLIENTACTIVETEXTUREARBPROC glClientActiveTextureARB = NULL;

-PFNGLMULTITEXCOORD1DARBPROC     glMultiTexCoord1dARB     = NULL;

-PFNGLMULTITEXCOORD1DVARBPROC	glMultiTexCoord1dvARB    = NULL;

-PFNGLMULTITEXCOORD1FARBPROC     glMultiTexCoord1fARB     = NULL;

-PFNGLMULTITEXCOORD1FVARBPROC	glMultiTexCoord1fvARB    = NULL;

-PFNGLMULTITEXCOORD1IARBPROC     glMultiTexCoord1iARB     = NULL;

-PFNGLMULTITEXCOORD1IVARBPROC	glMultiTexCoord1ivARB    = NULL;

-PFNGLMULTITEXCOORD1SARBPROC     glMultiTexCoord1sARB     = NULL;

-PFNGLMULTITEXCOORD1SVARBPROC	glMultiTexCoord1svARB    = NULL;

-PFNGLMULTITEXCOORD2DARBPROC     glMultiTexCoord2dARB     = NULL;

-PFNGLMULTITEXCOORD2DVARBPROC	glMultiTexCoord2dvARB    = NULL;

-PFNGLMULTITEXCOORD2FARBPROC     glMultiTexCoord2fARB     = NULL;

-PFNGLMULTITEXCOORD2FVARBPROC	glMultiTexCoord2fvARB    = NULL;

-PFNGLMULTITEXCOORD2IARBPROC     glMultiTexCoord2iARB     = NULL;

-PFNGLMULTITEXCOORD2IVARBPROC	glMultiTexCoord2ivARB    = NULL;

-PFNGLMULTITEXCOORD2SARBPROC     glMultiTexCoord2sARB     = NULL;

-PFNGLMULTITEXCOORD2SVARBPROC	glMultiTexCoord2svARB    = NULL;

-PFNGLMULTITEXCOORD3DARBPROC     glMultiTexCoord3dARB     = NULL;

-PFNGLMULTITEXCOORD3DVARBPROC	glMultiTexCoord3dvARB    = NULL;

-PFNGLMULTITEXCOORD3FARBPROC     glMultiTexCoord3fARB     = NULL;

-PFNGLMULTITEXCOORD3FVARBPROC	glMultiTexCoord3fvARB    = NULL;

-PFNGLMULTITEXCOORD3IARBPROC     glMultiTexCoord3iARB     = NULL;

-PFNGLMULTITEXCOORD3IVARBPROC	glMultiTexCoord3ivARB    = NULL;

-PFNGLMULTITEXCOORD3SARBPROC     glMultiTexCoord3sARB     = NULL;

-PFNGLMULTITEXCOORD3SVARBPROC	glMultiTexCoord3svARB    = NULL;

-PFNGLMULTITEXCOORD4DARBPROC     glMultiTexCoord4dARB     = NULL;

-PFNGLMULTITEXCOORD4DVARBPROC	glMultiTexCoord4dvARB    = NULL;

-PFNGLMULTITEXCOORD4FARBPROC     glMultiTexCoord4fARB     = NULL;

-PFNGLMULTITEXCOORD4FVARBPROC	glMultiTexCoord4fvARB    = NULL;

-PFNGLMULTITEXCOORD4IARBPROC     glMultiTexCoord4iARB     = NULL;

-PFNGLMULTITEXCOORD4IVARBPROC	glMultiTexCoord4ivARB    = NULL;

-PFNGLMULTITEXCOORD4SARBPROC     glMultiTexCoord4sARB     = NULL;

-PFNGLMULTITEXCOORD4SVARBPROC	glMultiTexCoord4svARB    = NULL;

-#endif // _WIN32 

-

-int CheckForARBMultitextureSupport(void) {

-    const char search[]="GL_ARB_multitexture";

-    int i, pos=0;

-    int maxpos=strlen(search)-1;

-    char extensions[10000];

-    printf("Getting GLstring, context is %p\n",  glXGetCurrentContext());

-    strcpy(extensions,(const char *)glGetString(GL_EXTENSIONS));

-    printf("Examinig GLstring\n");

-    int len=strlen(extensions);

-    for ( i=0; i<len; i++) {

-        if ((i==0) || ((i>1) && extensions[i-1]==' ')) {

-            pos=0;

-            while(extensions[i]!=' ') {

-                if (extensions[i]==search[pos]) pos++;

-                if ((pos>maxpos) && extensions[i+1]==' ') {

-		  //if (debug)

-		    {

-		      //fprintf(stderr, search);

-		      //fprintf(stderr, " supported.\n");

-		    }

-                    return 1;

-                }

-                ++i;

-            }

-        }

-    }

-    //printf(search);

-    //printf(" not supported.\n");

-    return 0;

-}

-

-int GL_ARB_multitexture_Init(void) {

-    if (!CheckForARBMultitextureSupport()) return 0;

+    PFNGLACTIVETEXTUREARBPROC glActiveTextureARB = NULL;
+   
PFNGLCLIENTACTIVETEXTUREARBPROC glClientActiveTextureARB = NULL;
+   
PFNGLMULTITEXCOORD1DARBPROC glMultiTexCoord1dARB = NULL;
+   
PFNGLMULTITEXCOORD1DVARBPROC glMultiTexCoord1dvARB = NULL;
+   
PFNGLMULTITEXCOORD1FARBPROC glMultiTexCoord1fARB = NULL;
+   
PFNGLMULTITEXCOORD1FVARBPROC glMultiTexCoord1fvARB = NULL;
+   
PFNGLMULTITEXCOORD1IARBPROC glMultiTexCoord1iARB = NULL;
+   
PFNGLMULTITEXCOORD1IVARBPROC glMultiTexCoord1ivARB = NULL;
+   
PFNGLMULTITEXCOORD1SARBPROC glMultiTexCoord1sARB = NULL;
+   
PFNGLMULTITEXCOORD1SVARBPROC glMultiTexCoord1svARB = NULL;
+   
PFNGLMULTITEXCOORD2DARBPROC glMultiTexCoord2dARB = NULL;
+   
PFNGLMULTITEXCOORD2DVARBPROC glMultiTexCoord2dvARB = NULL;
+   
PFNGLMULTITEXCOORD2FARBPROC glMultiTexCoord2fARB = NULL;
+   
PFNGLMULTITEXCOORD2FVARBPROC glMultiTexCoord2fvARB = NULL;
+   
PFNGLMULTITEXCOORD2IARBPROC glMultiTexCoord2iARB = NULL;
+   
PFNGLMULTITEXCOORD2IVARBPROC glMultiTexCoord2ivARB = NULL;
+   
PFNGLMULTITEXCOORD2SARBPROC glMultiTexCoord2sARB = NULL;
+   
PFNGLMULTITEXCOORD2SVARBPROC glMultiTexCoord2svARB = NULL;
+   
PFNGLMULTITEXCOORD3DARBPROC glMultiTexCoord3dARB = NULL;
+   
PFNGLMULTITEXCOORD3DVARBPROC glMultiTexCoord3dvARB = NULL;
+   
PFNGLMULTITEXCOORD3FARBPROC glMultiTexCoord3fARB = NULL;
+   
PFNGLMULTITEXCOORD3FVARBPROC glMultiTexCoord3fvARB = NULL;
+   
PFNGLMULTITEXCOORD3IARBPROC glMultiTexCoord3iARB = NULL;
+   
PFNGLMULTITEXCOORD3IVARBPROC glMultiTexCoord3ivARB = NULL;
+   
PFNGLMULTITEXCOORD3SARBPROC glMultiTexCoord3sARB = NULL;
+   
PFNGLMULTITEXCOORD3SVARBPROC glMultiTexCoord3svARB = NULL;
+   
PFNGLMULTITEXCOORD4DARBPROC glMultiTexCoord4dARB = NULL;
+   
PFNGLMULTITEXCOORD4DVARBPROC glMultiTexCoord4dvARB = NULL;
+   
PFNGLMULTITEXCOORD4FARBPROC glMultiTexCoord4fARB = NULL;
+   
PFNGLMULTITEXCOORD4FVARBPROC glMultiTexCoord4fvARB = NULL;
+   
PFNGLMULTITEXCOORD4IARBPROC glMultiTexCoord4iARB = NULL;
+   
PFNGLMULTITEXCOORD4IVARBPROC glMultiTexCoord4ivARB = NULL;
+   
PFNGLMULTITEXCOORD4SARBPROC glMultiTexCoord4sARB = NULL;
+   
PFNGLMULTITEXCOORD4SVARBPROC glMultiTexCoord4svARB = NULL;
+   

+#endif				// _WIN32 

+   
int CheckForARBMultitextureSupport (void)
+  {
+    
const char search[] = "GL_ARB_multitexture";
+     
int i, pos = 0;
+     
int maxpos = strlen (search) - 1;
+     
char extensions[10000];
+     
printf ("Getting GLstring, context is %p\n", glXGetCurrentContext ());
+     
strcpy (extensions, (const char *) glGetString (GL_EXTENSIONS));
+     
printf ("Examinig GLstring\n");
+     
int len = strlen (extensions);
+     
for (i = 0; i < len; i++)
+    {
+      
if ((i == 0) || ((i > 1) && extensions[i - 1] == ' ')) {
+	
pos = 0;
+	
while (extensions[i] != ' ')
+	{
+	  
if (extensions[i] == search[pos])
+	    pos++;
+	  
if ((pos > maxpos) && extensions[i + 1] == ' ') {
+	    

+		//if (debug)

+	    {
+	      

+		  //fprintf(stderr, search);

+		  //fprintf(stderr, " supported.\n");

+	    }
+	     
return 1;
+	  
}
+	  
++i;
+	
}
+      
}
+    
}
+    

+	//printf(search);

+	//printf(" not supported.\n");

+	return 0;
+  
}
+  

int GL_ARB_multitexture_Init (void)
+  {
+    
if (!CheckForARBMultitextureSupport ())
+      return 0;
+    

 #ifdef _WIN32

-    glActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC) wglGetProcAddress("glActiveTextureARB");

-        if (glActiveTextureARB==NULL) {fprintf(stderr,"glActiveTextureARB not found.\n"); return 0; }

-    glClientActiveTextureARB = (PFNGLCLIENTACTIVETEXTUREARBPROC) wglGetProcAddress("glClientActiveTextureARB");

-        if (glClientActiveTextureARB==NULL) {fprintf(stderr,"glClientActiveTextureARB not found.\n"); return 0; }

-    glMultiTexCoord1dARB = (PFNGLMULTITEXCOORD1DARBPROC) wglGetProcAddress("glMultiTexCoord1dARB");

-        if (glMultiTexCoord1dARB==NULL) {fprintf(stderr,"glMultiTexCoord1dARB not found.\n"); return 0; }

-    glMultiTexCoord1dvARB = (PFNGLMULTITEXCOORD1DVARBPROC) wglGetProcAddress("glMultiTexCoord1dvARB");

-        if (glMultiTexCoord1dvARB==NULL) {fprintf(stderr,"glMultiTexCoord1dAvRB not found.\n"); return 0; }

-    glMultiTexCoord1fARB = (PFNGLMULTITEXCOORD1FARBPROC) wglGetProcAddress("glMultiTexCoord1fARB");

-        if (glMultiTexCoord1fARB==NULL) {fprintf(stderr,"glMultiTexCoord1fARB not found.\n"); return 0; }

-    glMultiTexCoord1fvARB = (PFNGLMULTITEXCOORD1FVARBPROC) wglGetProcAddress("glMultiTexCoord1fvARB");

-        if (glMultiTexCoord1fvARB==NULL) {fprintf(stderr,"glMultiTexCoord1fvARB not found.\n"); return 0; }

-    glMultiTexCoord1iARB = (PFNGLMULTITEXCOORD1IARBPROC) wglGetProcAddress("glMultiTexCoord1iARB");

-        if (glMultiTexCoord1iARB==NULL) {fprintf(stderr,"glMultiTexCoord1iARB not found.\n"); return 0; }

-    glMultiTexCoord1ivARB = (PFNGLMULTITEXCOORD1IVARBPROC) wglGetProcAddress("glMultiTexCoord1ivARB");

-        if (glMultiTexCoord1ivARB==NULL) {fprintf(stderr,"glMultiTexCoord1ivARB not found.\n"); return 0; }

-    glMultiTexCoord1sARB = (PFNGLMULTITEXCOORD1SARBPROC) wglGetProcAddress("glMultiTexCoord1sARB");

-        if (glMultiTexCoord1sARB==NULL) {fprintf(stderr,"glMultiTexCoord1sARB not found.\n"); return 0; }

-    glMultiTexCoord1svARB = (PFNGLMULTITEXCOORD1SVARBPROC) wglGetProcAddress("glMultiTexCoord1svARB");

-        if (glMultiTexCoord1svARB==NULL) {fprintf(stderr,"glMultiTexCoord1svARB not found.\n"); return 0; }

-    glMultiTexCoord2dARB = (PFNGLMULTITEXCOORD2DARBPROC) wglGetProcAddress("glMultiTexCoord2dARB");

-        if (glMultiTexCoord2dARB==NULL) {fprintf(stderr,"glMultiTexCoord2dARB not found.\n"); return 0; }

-    glMultiTexCoord2dvARB = (PFNGLMULTITEXCOORD2DVARBPROC) 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; }

+	glActiveTextureARB =
+	(PFNGLACTIVETEXTUREARBPROC) wglGetProcAddress ("glActiveTextureARB");
+    
if (glActiveTextureARB == NULL) {
+      fprintf (stderr, "glActiveTextureARB not found.\n");
+      return 0;
+    }
+    
glClientActiveTextureARB = (PFNGLCLIENTACTIVETEXTUREARBPROC)
+	wglGetProcAddress ("glClientActiveTextureARB");
+    
if (glClientActiveTextureARB == NULL) {
+      fprintf (stderr, "glClientActiveTextureARB not found.\n");
+      return 0;
+    }
+    
glMultiTexCoord1dARB = (PFNGLMULTITEXCOORD1DARBPROC)
+	wglGetProcAddress ("glMultiTexCoord1dARB");
+    
if (glMultiTexCoord1dARB == NULL) {
+      fprintf (stderr, "glMultiTexCoord1dARB not found.\n");
+      return 0;
+    }
+    
glMultiTexCoord1dvARB = (PFNGLMULTITEXCOORD1DVARBPROC)
+	wglGetProcAddress ("glMultiTexCoord1dvARB");
+    
if (glMultiTexCoord1dvARB == NULL) {
+      fprintf (stderr, "glMultiTexCoord1dAvRB not found.\n");
+      return 0;
+    }
+    
glMultiTexCoord1fARB = (PFNGLMULTITEXCOORD1FARBPROC)
+	wglGetProcAddress ("glMultiTexCoord1fARB");
+    
if (glMultiTexCoord1fARB == NULL) {
+      fprintf (stderr, "glMultiTexCoord1fARB not found.\n");
+      return 0;
+    }
+    
glMultiTexCoord1fvARB = (PFNGLMULTITEXCOORD1FVARBPROC)
+	wglGetProcAddress ("glMultiTexCoord1fvARB");
+    
if (glMultiTexCoord1fvARB == NULL) {
+      fprintf (stderr, "glMultiTexCoord1fvARB not found.\n");
+      return 0;
+    }
+    
glMultiTexCoord1iARB = (PFNGLMULTITEXCOORD1IARBPROC)
+	wglGetProcAddress ("glMultiTexCoord1iARB");
+    
if (glMultiTexCoord1iARB == NULL) {
+      fprintf (stderr, "glMultiTexCoord1iARB not found.\n");
+      return 0;
+    }
+    
glMultiTexCoord1ivARB = (PFNGLMULTITEXCOORD1IVARBPROC)
+	wglGetProcAddress ("glMultiTexCoord1ivARB");
+    
if (glMultiTexCoord1ivARB == NULL) {
+      fprintf (stderr, "glMultiTexCoord1ivARB not found.\n");
+      return 0;
+    }
+    
glMultiTexCoord1sARB = (PFNGLMULTITEXCOORD1SARBPROC)
+	wglGetProcAddress ("glMultiTexCoord1sARB");
+    
if (glMultiTexCoord1sARB == NULL) {
+      fprintf (stderr, "glMultiTexCoord1sARB not found.\n");
+      return 0;
+    }
+    
glMultiTexCoord1svARB = (PFNGLMULTITEXCOORD1SVARBPROC)
+	wglGetProcAddress ("glMultiTexCoord1svARB");
+    
if (glMultiTexCoord1svARB == NULL) {
+      fprintf (stderr, "glMultiTexCoord1svARB not found.\n");
+      return 0;
+    }
+    
glMultiTexCoord2dARB = (PFNGLMULTITEXCOORD2DARBPROC)
+	wglGetProcAddress ("glMultiTexCoord2dARB");
+    
if (glMultiTexCoord2dARB == NULL) {
+      fprintf (stderr, "glMultiTexCoord2dARB not found.\n");
+      return 0;
+    }
+    
glMultiTexCoord2dvARB = (PFNGLMULTITEXCOORD2DVARBPROC)
+	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;

-}

-

+	return 1;
+  
}
+  


 #endif // ARB_MULTITEXTURE_INITIALIZE

-

+      

 #ifdef __cplusplus

-}

-#endif

+}
+
 

+#endif /* 
 */
+    

 #endif // not __ARB_MULTITEXTURE_H_

diff --git a/sys/glsink/EXT_paletted_texture.h b/sys/glsink/EXT_paletted_texture.h
index 37e9a9bf..7cc3e5d9 100644
--- a/sys/glsink/EXT_paletted_texture.h
+++ b/sys/glsink/EXT_paletted_texture.h
@@ -7,42 +7,42 @@
  *                                                           *

  * version 1.0ß                                              *

  *                                                           *

- *************************************************************/

-

+ *************************************************************/  

+    

 #ifndef __EXT_paletted_texture_H_

 #define __EXT_paletted_texture_H_

-

+    

 /*

  *  GLOBAL SWITCHES - enable/disable advanced features of this header

  *

- */

-#define EXT_PALETTED_TEXTURE_INITIALIZE 1 // enable generic init-routines

+ */ 

+#define EXT_PALETTED_TEXTURE_INITIALIZE 1	// enable generic init-routines

 #ifndef _WIN32

 #define GL_GLEXT_PROTOTYPES 1

-#endif

-

+#endif /* 
 */
+    

 #ifdef __cplusplus

-extern "C" {

-#endif

-

+extern "C"
+{
+  

+#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 

  *

- */

+ */ 

 #ifndef GL_EXT_paletted_texture

 #define GL_COLOR_INDEX1_EXT               0x80E2 

 #define GL_COLOR_INDEX2_EXT               0x80E3 

@@ -60,83 +60,128 @@ 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 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 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 * PFNGLCOLORSUBTABLEEXTPROC)(GLenum target, 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

-

+  extern void APIENTRY glColorTableEXT (GLenum, GLenum, GLsizei, GLenum, GLenum,
+      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 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 * PFNGLCOLORSUBTABLEEXTPROC) (GLenum target,
+      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

-#include<string.h> // string manipulation for runtime-check

-

+#include<string.h>		// string manipulation for runtime-check

+   

 #ifdef _WIN32

-PFNGLCOLORTABLEEXTPROC               glColorTableEXT    = NULL;

-PFNGLCOLORSUBTABLEEXTPROC            glColorSubTableEXT = NULL;

-PFNGLGETCOLORTABLEEXTPROC            glGetColorTableEXT = NULL;

-PFNGLGETCOLORTABLEPARAMETERIVEXTPROC glGetColorTableParameterivEXT = NULL;

-PFNGLGETCOLORTABLEPARAMETERFVEXTPROC glGetColorTableParameterfvEXT = NULL;

-#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++) {

-        if ((i==0) || ((i>1) && extensions[i-1]==' ')) {

-            pos=0;

-            while(extensions[i]!=' ') {

-                if (extensions[i]==search[pos]) pos++;

-                if ((pos>maxpos) && extensions[i+1]==' ') {

-		  //printf(search);

-		  //printf(" supported.\n");

-                    return 1;

-                }

-                i++;

-            }

-        }

-    }

-    //printf(search);

-    //printf(" not supported.\n");

-    return 0;

-}

-

-int GL_EXT_paletted_texture_Init(void) {

-    if (!CheckForEXTPalettedTextureSupport()) return 0;

-

+    PFNGLCOLORTABLEEXTPROC glColorTableEXT = NULL;
+   
PFNGLCOLORSUBTABLEEXTPROC glColorSubTableEXT = NULL;
+   
PFNGLGETCOLORTABLEEXTPROC glGetColorTableEXT = NULL;
+   
PFNGLGETCOLORTABLEPARAMETERIVEXTPROC glGetColorTableParameterivEXT = NULL;
+   
PFNGLGETCOLORTABLEPARAMETERFVEXTPROC glGetColorTableParameterfvEXT = NULL;
+   

+#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++)
+    {
+      
if ((i == 0) || ((i > 1) && extensions[i - 1] == ' ')) {
+	
pos = 0;
+	
while (extensions[i] != ' ')
+	{
+	  
if (extensions[i] == search[pos])
+	    pos++;
+	  
if ((pos > maxpos) && extensions[i + 1] == ' ') {
+	    

+		//printf(search);

+		//printf(" supported.\n");

+		return 1;
+	  
}
+	   
i++;
+	
}
+      
}
+    
}
+    

+	//printf(search);

+	//printf(" not supported.\n");

+	return 0;
+  
}
+  

int GL_EXT_paletted_texture_Init (void)
+  {
+    
if (!CheckForEXTPalettedTextureSupport ())
+      return 0;
+    


 #ifdef _WIN32

-    glColorTableEXT = (PFNGLCOLORTABLEEXTPROC) wglGetProcAddress("glColorTableEXT");

-        if (glColorTableEXT==NULL) {fprintf(stderr,"glColorTableEXT not found.\n"); return 0;}

-    glColorSubTableEXT = (PFNGLCOLORSUBTABLEEXTPROC) wglGetProcAddress("glColorSubTableEXT");

-        if (glColorSubTableEXT==NULL) {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;}

+	glColorTableEXT =
+	(PFNGLCOLORTABLEEXTPROC) wglGetProcAddress ("glColorTableEXT");
+    
if (glColorTableEXT == NULL) {
+      fprintf (stderr, "glColorTableEXT not found.\n");
+      return 0;
+    }
+    
glColorSubTableEXT =
+	(PFNGLCOLORSUBTABLEEXTPROC) wglGetProcAddress ("glColorSubTableEXT");
+    
if (glColorSubTableEXT == NULL) {
+      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;

-}

-

+	return 1;
+  
}
+  


 #endif // EXT_PALETTED_TEXTURE_INITIALIZE

-

+      

 #ifdef __cplusplus

-}

-#endif

+}
+
 

+#endif /* 
 */
+    

 #endif // not __EXT_PALETTED_TEXTURE_H_

diff --git a/sys/glsink/NV_register_combiners.h b/sys/glsink/NV_register_combiners.h
index 52b74c39..83f33edc 100644
--- a/sys/glsink/NV_register_combiners.h
+++ b/sys/glsink/NV_register_combiners.h
@@ -7,42 +7,42 @@
  *                                                           *

  * version 2.0ß                                              *

  *                                                           *

- *************************************************************/

-

+ *************************************************************/  

+    

 #ifndef __NV_register_combiners_H_

 #define __NV_register_combiners_H_

-

+    

 /*

  *  GLOBAL SWITCHES - enable/disable advanced features of this header

  *

- */

-#define NV_REGISTER_COMBINERS_INITIALIZE 1 // enable generic init-routines

+ */ 

+#define NV_REGISTER_COMBINERS_INITIALIZE 1	// enable generic init-routines

 #ifndef _WIN32

 #define GL_GLEXT_PROTOTYPES 1

-#endif

-

+#endif /* 
 */
+    

 #ifdef __cplusplus

-extern "C" {

-#endif

-

+extern "C"
+{
+  

+#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 

  *

- */

+ */ 

 #ifndef GL_NV_register_combiners

 #define GL_REGISTER_COMBINERS_NV          0x8522

 #define GL_COMBINER0_NV                   0x8550

@@ -96,123 +96,228 @@ 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

-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 glCombinerOutputNV     (GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLboolean, GLboolean, GLboolean); 

-extern void APIENTRY glFinalCombinerInputNV (GLenum, GLenum, GLenum, GLenum); 

-extern void APIENTRY glGetCombinerInputParameterfvNV (GLenum, GLenum, GLenum, GLenum, GLfloat *); 

-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 * PFNGLCOMBINERPARAMETERIVNVPROC) (GLenum pname, const GLint *params); 

-typedef void (APIENTRY * PFNGLCOMBINERPARAMETERFNVPROC)  (GLenum pname, GLfloat param); 

-typedef void (APIENTRY * PFNGLCOMBINERPARAMETERINVPROC)  (GLenum pname, GLint param); 

-typedef void (APIENTRY * PFNGLCOMBINERINPUTNVPROC)       (GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage); 

-typedef void (APIENTRY * PFNGLCOMBINEROUTPUTNVPROC)      (GLenum stage, 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

-

+  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 glCombinerOutputNV (GLenum, GLenum, GLenum, GLenum,
+      GLenum, GLenum, GLenum, GLboolean, GLboolean, GLboolean);
+   
extern void APIENTRY glFinalCombinerInputNV (GLenum, GLenum, GLenum,
+      GLenum);
+   
extern void APIENTRY glGetCombinerInputParameterfvNV (GLenum, GLenum,
+      GLenum, GLenum, GLfloat *);
+   
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 * PFNGLCOMBINERPARAMETERIVNVPROC) (GLenum pname,
+      const GLint * params);
+   
typedef void (APIENTRY * PFNGLCOMBINERPARAMETERFNVPROC) (GLenum pname,
+      GLfloat param);
+   
typedef void (APIENTRY * PFNGLCOMBINERPARAMETERINVPROC) (GLenum pname,
+      GLint param);
+   
typedef void (APIENTRY * PFNGLCOMBINERINPUTNVPROC) (GLenum stage,
+      GLenum portion, GLenum variable, GLenum input, GLenum mapping,
+      GLenum componentUsage);
+   
typedef void (APIENTRY * PFNGLCOMBINEROUTPUTNVPROC) (GLenum stage,
+      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

-#include<string.h> // string manipulation for runtime-check

-

+#include<string.h>		// string manipulation for runtime-check

+   

 #ifdef _WIN32

-PFNGLCOMBINERPARAMETERFVNVPROC              glCombinerParameterfvNV              = NULL;

-PFNGLCOMBINERPARAMETERIVNVPROC              glCombinerParameterivNV              = NULL;

-PFNGLCOMBINERPARAMETERFNVPROC               glCombinerParameterfNV               = NULL;

-PFNGLCOMBINERPARAMETERINVPROC               glCombinerParameteriNV               = NULL;

-PFNGLCOMBINERINPUTNVPROC                    glCombinerInputNV                    = NULL;

-PFNGLCOMBINEROUTPUTNVPROC                   glCombinerOutputNV                   = NULL;

-PFNGLFINALCOMBINERINPUTNVPROC               glFinalCombinerInputNV               = NULL;

-PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC      glGetCombinerInputParameterfvNV      = NULL;

-PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC      glGetCombinerInputParameterivNV      = NULL;

-PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC     glGetCombinerOutputParameterfvNV     = NULL;

-PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC     glGetCombinerOutputParameterivNV     = NULL;

-PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC glGetFinalCombinerInputParameterfvNV = NULL;

-PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC glGetFinalCombinerInputParameterivNV = NULL;

-#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++) {

-        if ((i==0) || ((i>1) && extensions[i-1]==' ')) {

-             pos=0;

-             while(extensions[i]!=' ') {

-                if (extensions[i]==search[pos]) pos++;

-                if ((pos>maxpos) && extensions[i+1]==' ') {

-		  //printf(search);

-		  //  printf(" supported.\n");

-                     return 1;

-                }

-                i++;

-            }

-        }

-    }

-    //printf(search);

-    //printf(" not supported.\n");

-    return 0;

-}

-

-int GL_NV_register_combiners_Init(void) {

-    if (!CheckForNVRegisterCombinersSupport()) return 0;

-

+    PFNGLCOMBINERPARAMETERFVNVPROC glCombinerParameterfvNV = NULL;
+   
PFNGLCOMBINERPARAMETERIVNVPROC glCombinerParameterivNV = NULL;
+   
PFNGLCOMBINERPARAMETERFNVPROC glCombinerParameterfNV = NULL;
+   
PFNGLCOMBINERPARAMETERINVPROC glCombinerParameteriNV = NULL;
+   
PFNGLCOMBINERINPUTNVPROC glCombinerInputNV = NULL;
+   
PFNGLCOMBINEROUTPUTNVPROC glCombinerOutputNV = NULL;
+   
PFNGLFINALCOMBINERINPUTNVPROC glFinalCombinerInputNV = NULL;
+   
PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC glGetCombinerInputParameterfvNV =
+      NULL;
+   
PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC glGetCombinerInputParameterivNV =
+      NULL;
+   
PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC glGetCombinerOutputParameterfvNV =
+      NULL;
+   
PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC glGetCombinerOutputParameterivNV =
+      NULL;
+   
PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC
+      glGetFinalCombinerInputParameterfvNV = NULL;
+   
PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC
+      glGetFinalCombinerInputParameterivNV = NULL;
+   

+#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++)
+    {
+      
if ((i == 0) || ((i > 1) && extensions[i - 1] == ' ')) {
+	
pos = 0;
+	
while (extensions[i] != ' ')
+	{
+	  
if (extensions[i] == search[pos])
+	    pos++;
+	  
if ((pos > maxpos) && extensions[i + 1] == ' ') {
+	    

+		//printf(search);

+		//  printf(" supported.\n");

+		return 1;
+	  
}
+	   
i++;
+	
}
+      
}
+    
}
+    

+	//printf(search);

+	//printf(" not supported.\n");

+	return 0;
+  
}
+  

int GL_NV_register_combiners_Init (void)
+  {
+    
if (!CheckForNVRegisterCombinersSupport ())
+      return 0;
+    


 #ifdef _WIN32

-    glCombinerParameterfvNV=(PFNGLCOMBINERPARAMETERFVNVPROC) wglGetProcAddress("glCombinerParameterfvNV");

-        if (glCombinerParameterfvNV==NULL) {fprintf(stderr,"glCombinerParameterfvNV not found.\n"); return 0;}

-    glCombinerParameterivNV=(PFNGLCOMBINERPARAMETERIVNVPROC) wglGetProcAddress("glCombinerParameterivNV");

-        if (glCombinerParameterivNV==NULL) {fprintf(stderr,"glCombinerParameterivNV not found.\n"); return 0;}

-    glCombinerParameterfNV=(PFNGLCOMBINERPARAMETERFNVPROC) wglGetProcAddress("glCombinerParameterfNV");

-        if (glCombinerParameterfvNV==NULL) {fprintf(stderr,"glCombinerParameterfNV not found.\n"); return 0;}

-    glCombinerParameteriNV=(PFNGLCOMBINERPARAMETERINVPROC) wglGetProcAddress("glCombinerParameteriNV");

-        if (glCombinerParameterivNV==NULL) {fprintf(stderr,"glCombinerParameteriNV not found.\n"); return 0;}

-    glCombinerInputNV=(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;}

+	glCombinerParameterfvNV = (PFNGLCOMBINERPARAMETERFVNVPROC)
+	wglGetProcAddress ("glCombinerParameterfvNV");
+    
if (glCombinerParameterfvNV == NULL) {
+      fprintf (stderr, "glCombinerParameterfvNV not found.\n");
+      return 0;
+    }
+    
glCombinerParameterivNV = (PFNGLCOMBINERPARAMETERIVNVPROC)
+	wglGetProcAddress ("glCombinerParameterivNV");
+    
if (glCombinerParameterivNV == NULL) {
+      fprintf (stderr, "glCombinerParameterivNV not found.\n");
+      return 0;
+    }
+    
glCombinerParameterfNV = (PFNGLCOMBINERPARAMETERFNVPROC)
+	wglGetProcAddress ("glCombinerParameterfNV");
+    
if (glCombinerParameterfvNV == NULL) {
+      fprintf (stderr, "glCombinerParameterfNV not found.\n");
+      return 0;
+    }
+    
glCombinerParameteriNV = (PFNGLCOMBINERPARAMETERINVPROC)
+	wglGetProcAddress ("glCombinerParameteriNV");
+    
if (glCombinerParameterivNV == NULL) {
+      fprintf (stderr, "glCombinerParameteriNV not found.\n");
+      return 0;
+    }
+    
glCombinerInputNV =
+	(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;

-}

-

+	return 1;
+  
}
+  


 #endif // NV_REGISTER_COMBINERS_INITIALIZE

-

+      

 #ifdef __cplusplus

-}

-#endif

+}
+
 

+#endif /* 
 */
+    

 #endif // not __NV_REGISTER_COMBINERS_H_

diff --git a/sys/glsink/gstgl_nvimage.c b/sys/glsink/gstgl_nvimage.c
index 84a1ad95..1aab5c4f 100644
--- a/sys/glsink/gstgl_nvimage.c
+++ b/sys/glsink/gstgl_nvimage.c
@@ -23,7 +23,7 @@
 //#include <GL/glext.h>
 #include <GL/glu.h>
 #include <string.h>
-#include <math.h> 
+#include <math.h>
 
 // too lazy to write an API for this ;) 
 #include "regcomb_yuvrgb.c"
@@ -31,15 +31,16 @@
 #include "gstglsink.h"
 
 typedef struct _GstGLImageConnection GstGLImageConnection;
-struct _GstGLImageConnection {
+struct _GstGLImageConnection
+{
   GstImageConnection conn;
   Display *dpy;
   gint w, h;
   gint bpp;
-  
+
   int ytex_id;
   int uvtex_id;
-  int septex_id; 
+  int septex_id;
   unsigned char *m_memory;
   int m_bufslots[4];
 };
@@ -54,50 +55,57 @@ typedef struct _GstNvImage GstNvImage;
 struct _GstNvImage
 {
   GstImageData data;
-  int slot; // < AGP_BUFSLOTS: allocated from AGP mem, otherwise from CPU mem
+  int slot;			// < AGP_BUFSLOTS: allocated from AGP mem, otherwise from CPU mem
   GstGLImageConnection *conn;
 };
 
-static GstGLImageInfo *		gst_gl_nvimage_info			(GstImageInfo *info);
-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 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_close_conn		(GstImageConnection *conn, GstImageInfo *info);
-static void 			gst_gl_nvimage_free_conn		(GstImageConnection *conn);
-
-GstImagePlugin* get_gl_nvimage_plugin(void)
+static GstGLImageInfo *gst_gl_nvimage_info (GstImageInfo * info);
+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 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_close_conn (GstImageConnection * conn,
+    GstImageInfo * info);
+static void gst_gl_nvimage_free_conn (GstImageConnection * conn);
+
+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_set_caps,
+    gst_gl_nvimage_get_image,
+    gst_gl_nvimage_put_image,
+    gst_gl_nvimage_free_image
+  };
 
   return &plugin;
 }
 
 
 static GstGLImageInfo *
-gst_gl_nvimage_info (GstImageInfo *info)
+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;
 }
 
 static GstGLImageConnection *
-gst_gl_nvimage_connection (GstImageConnection *conn)
+gst_gl_nvimage_connection (GstImageConnection * conn)
 {
   if (conn == NULL || conn->free_conn != gst_gl_nvimage_free_conn)
-    return NULL; 
+    return NULL;
   return (GstGLImageConnection *) conn;
 }
 
@@ -105,57 +113,58 @@ gboolean
 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_EXT_paletted_texture_Init()) return FALSE;
-  if (!GL_NV_register_combiners_Init()) return FALSE;
+  printf ("Checking NVidia OpenGL extensions.\n");
+  if (!GL_ARB_multitexture_Init ())
+    return FALSE;
+  if (!GL_EXT_paletted_texture_Init ())
+    return FALSE;
+  if (!GL_NV_register_combiners_Init ())
+    return FALSE;
 
-#if 0 
+#if 0
   if (display == NULL)
     return FALSE;
-  if (Success == XvQueryExtension (display,&ver,&rel,&req,&ev,&err))
+  if (Success == XvQueryExtension (display, &ver, &rel, &req, &ev, &err))
     return TRUE;
 #endif
 
   return TRUE;
 }
 
-static GstCaps * 	
-gst_gl_nvimage_get_caps (GstImageInfo *info)
+static GstCaps *
+gst_gl_nvimage_get_caps (GstImageInfo * info)
 {
   //gint i;
   //int adaptors;
   //int formats;
   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) 
-    {
-      printf("Invalid XInfo struct !\n");
-      return NULL;
-    }
+  if (xinfo == NULL) {
+    printf ("Invalid XInfo struct !\n");
+    return NULL;
+  }
 
-  if (gst_gl_nvimage_check_xvideo () == FALSE)
-  {
-    g_warning("GL_NVImage: Server has no NVidia extension support\n"); 
+  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 (
-					      "nvimage_caps",
-					      "video/x-raw-yuv",
-					      "format",  GST_PROPS_FOURCC (GST_MAKE_FOURCC ('Y', 'V', '1', '2')),
-					      "width",   GST_PROPS_INT_RANGE (0, 1024),
-					      "height",  GST_PROPS_INT_RANGE (0, 1024))
-			  );
-  g_warning("nvimage returns caps !\n");
+  caps = gst_caps_append (caps, GST_CAPS_NEW ("nvimage_caps",
+	  "video/x-raw-yuv",
+	  "format", GST_PROPS_FOURCC (GST_MAKE_FOURCC ('Y', 'V', '1', '2')),
+	  "width", GST_PROPS_INT_RANGE (0, 1024),
+	  "height", GST_PROPS_INT_RANGE (0, 1024))
+      );
+  g_warning ("nvimage returns caps !\n");
   return caps;
 }
 
 static GstImageConnection *
-gst_gl_nvimage_set_caps (GstImageInfo *info, GstCaps *caps)
+gst_gl_nvimage_set_caps (GstImageInfo * info, GstCaps * caps)
 {
   //gint i, j = 0;
   //int adaptors;
@@ -163,64 +172,62 @@ gst_gl_nvimage_set_caps (GstImageInfo *info, GstCaps *caps)
   GstGLImageConnection *conn;
   GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
   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;
   conn->conn.close_conn = gst_gl_nvimage_close_conn;
   conn->conn.free_conn = gst_gl_nvimage_free_conn;
 
-  gst_caps_get (caps, 
-		  "width",  &conn->w,
-		  "height", &conn->h,
-		  "format", &format,
-                  NULL);
+  gst_caps_get (caps,
+      "width", &conn->w, "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')) 
-    { 
-      GST_DEBUG ("GL_NVImage: Format is invalid !\n");
-      return NULL;
-    }
-  if (0) //conn->port == (XvPortID) -1)
+  if (format != GST_MAKE_FOURCC ('Y', 'V', '1', '2')) {
+    GST_DEBUG ("GL_NVImage: Format is invalid !\n");
+    return NULL;
+  }
+  if (0)			//conn->port == (XvPortID) -1)
   {
     /* this happens if the plugin can't handle the caps, so no warning */
     g_free (conn);
     return NULL;
   }
-  
+
   GST_DEBUG ("GL_NVImage: caps %p are ok, creating image", caps);
   return (GstImageConnection *) conn;
 }
 
 static GstImageData *
-gst_gl_nvimage_get_image (GstImageInfo *info, GstImageConnection *conn)
+gst_gl_nvimage_get_image (GstImageInfo * info, GstImageConnection * conn)
 {
   GstNvImage *image;
-  GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);  
-  GstGLImageConnection *nvconn = gst_gl_nvimage_connection (conn);  
-  
+  GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
+  GstGLImageConnection *nvconn = gst_gl_nvimage_connection (conn);
+
   /* checks */
-  if (xinfo == NULL) return NULL;
-  if (nvconn == NULL) return NULL;
+  if (xinfo == 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
 
-  image = g_new0(GstNvImage, 1);
+  image = g_new0 (GstNvImage, 1);
 
-  image->data.size = nvconn->w * nvconn->h * 3/2;
+  image->data.size = nvconn->w * nvconn->h * 3 / 2;
 
   //g_warning("Allocating %d bytes from main memory !", image->data.size);
-  image->data.data = g_malloc(image->data.size);
+  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;
@@ -229,187 +236,194 @@ gst_gl_nvimage_get_image (GstImageInfo *info, GstImageConnection *conn)
   return (GstImageData *) image;
 }
 
-static void 		
-gst_gl_nvimage_put_image (GstImageInfo *info, GstImageData *image)
+static void
+gst_gl_nvimage_put_image (GstImageInfo * info, GstImageData * image)
 {
   GstNvImage *im = (GstNvImage *) image;
-  GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);  
-  
-  int img_width = im->conn->w; 
-  int img_height = im->conn->h; 
+  GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
+
+  int img_width = im->conn->w;
+  int img_height = im->conn->h;
   int uv_width = img_width >> 1;
   int uv_height = img_height >> 1;
-  
+
   unsigned char *buf_y = im->data.data;
   unsigned char *buf_v = (buf_y + img_width * img_height);
-  unsigned char *buf_u = buf_v + ((img_width/2) * (img_height/2));      
+  unsigned char *buf_u = buf_v + ((img_width / 2) * (img_height / 2));
 
   /* checks omitted for speed (and lazyness), do we need them? */
   g_assert (xinfo != NULL);
-  
+
   // both upload the video, and redraw the screen
   //glClearColor(0,0.5, 0.3,1.0); // a test color
-  glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
+  glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
-  glMatrixMode(GL_MODELVIEW);
-  glLoadIdentity();
-  glTranslatef(0.0, 0.0, -5.0);
-  glDisable(GL_TEXTURE_2D);
+  glMatrixMode (GL_MODELVIEW);
+  glLoadIdentity ();
+  glTranslatef (0.0, 0.0, -5.0);
+  glDisable (GL_TEXTURE_2D);
 
-  if (xinfo->info.demo)
-    {
-      //g_print("Putting image, context is %p\n", glXGetCurrentContext());
+  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
-      glRotatef(180.0*sin(xinfo->rotX),1,0,0);
-      glRotatef(180.0*cos(xinfo->rotY),0,1,0);
+    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);
 
-      xinfo->rotX += 0.01;
-      xinfo->rotY -= 0.015;
-      float zoom = xinfo->zoom;
-      glScalef(zoom,zoom,zoom); 
-      //glScalef(0.1,0.1,0.1); 
+    xinfo->rotX += 0.01;
+    xinfo->rotY -= 0.015;
+    float zoom = xinfo->zoom;
 
-      if (xinfo->zoom > 2.0)
-	xinfo->zoomdir = -0.01;
+    glScalef (zoom, zoom, zoom);
+    //glScalef(0.1,0.1,0.1); 
 
-      if (xinfo->zoom < 1.0)
-	xinfo->zoomdir = 0.01;
+    if (xinfo->zoom > 2.0)
+      xinfo->zoomdir = -0.01;
 
-      xinfo->zoom += xinfo->zoomdir;
-    }  
+    if (xinfo->zoom < 1.0)
+      xinfo->zoomdir = 0.01;
 
+    xinfo->zoom += xinfo->zoomdir;
+  }
   //Draws the surface rectangle
 
-  if (Ywidth != im->conn->w || Yheight != im->conn->h)
-  {
-    Ywidth = im->conn->w; Yheight = im->conn->h;  UVwidth = im->conn->w/2; UVheight = im->conn->h/2;
-    Initialize_Backend(Ywidth,Yheight,UVwidth,UVheight,GL_LINEAR);
+  if (Ywidth != im->conn->w || Yheight != im->conn->h) {
+    Ywidth = im->conn->w;
+    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);
-  float xmax = (float)(im->conn->w-1)/tex_xsize;
-  float ymax = (float)(im->conn->h-1)/tex_ysize;
+  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;
 
   /* Upload the texture here */
   //g_warning("PUTTING IMAGE %f %f %d %d\n", xmax, ymax, tex_xsize, tex_ysize);
 
   //glColor4f(1,1,1,1); // do NOT set a color here ! Done by Initialize_Backend, or actually SetConst !
-  glBegin(GL_QUADS);
+  glBegin (GL_QUADS);
 
-  float aspect = img_width/(float)img_height;
+  float aspect = img_width / (float) img_height;
   float hor = aspect;
 
   //g_print("Drawing vertices, context is %p\n", glXGetCurrentContext());
-  glNormal3f(0, -1, 0);
-  glMultiTexCoord2fARB(GL_TEXTURE0_ARB,0,0); 
-  glMultiTexCoord2fARB(GL_TEXTURE1_ARB,0,0); 
-  glMultiTexCoord2fARB(GL_TEXTURE2_ARB,0,0); 
-  glVertex3f(-hor,1,0);
-
-  glMultiTexCoord2fARB(GL_TEXTURE0_ARB,0,ymax); 
-  glMultiTexCoord2fARB(GL_TEXTURE1_ARB,0,ymax); 
-  glMultiTexCoord2fARB(GL_TEXTURE2_ARB,0,ymax); 
-  glVertex3f(-hor,-1,0);
-
-  glMultiTexCoord2fARB(GL_TEXTURE0_ARB,xmax,ymax); 
-  glMultiTexCoord2fARB(GL_TEXTURE1_ARB,xmax,ymax); 
-  glMultiTexCoord2fARB(GL_TEXTURE2_ARB,xmax,ymax); 
-  glVertex3f(hor,-1,0);
-
-  glMultiTexCoord2fARB(GL_TEXTURE0_ARB,xmax,0); 
-  glMultiTexCoord2fARB(GL_TEXTURE1_ARB,xmax,0); 
-  glMultiTexCoord2fARB(GL_TEXTURE2_ARB,xmax,0); 
-  glVertex3f(hor,1,0);
-
-  glEnd();
-
-  if (xinfo->info.dumpvideo)
-    {
-      static int framenr = 0; 
-      char capfilename[255];
-      static guint8 *cap_image_data = NULL, *cap_image_data2 = NULL;
-      int i;
-      
-      // hmmmm, is this reentrant ?!
-      if (cap_image_data == NULL)
-	cap_image_data = (guint8 *)malloc(img_width * img_height * 3);
-
-      if (cap_image_data2 == NULL)
-	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);
-      // 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);
-      
-      sprintf(capfilename, "cap%04d.ppm", framenr);
-      FILE *outfile = fopen(capfilename, "wb");
-      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);
-	  fclose(outfile);
-	}
-      framenr++;
+  glNormal3f (0, -1, 0);
+  glMultiTexCoord2fARB (GL_TEXTURE0_ARB, 0, 0);
+  glMultiTexCoord2fARB (GL_TEXTURE1_ARB, 0, 0);
+  glMultiTexCoord2fARB (GL_TEXTURE2_ARB, 0, 0);
+  glVertex3f (-hor, 1, 0);
+
+  glMultiTexCoord2fARB (GL_TEXTURE0_ARB, 0, ymax);
+  glMultiTexCoord2fARB (GL_TEXTURE1_ARB, 0, ymax);
+  glMultiTexCoord2fARB (GL_TEXTURE2_ARB, 0, ymax);
+  glVertex3f (-hor, -1, 0);
+
+  glMultiTexCoord2fARB (GL_TEXTURE0_ARB, xmax, ymax);
+  glMultiTexCoord2fARB (GL_TEXTURE1_ARB, xmax, ymax);
+  glMultiTexCoord2fARB (GL_TEXTURE2_ARB, xmax, ymax);
+  glVertex3f (hor, -1, 0);
+
+  glMultiTexCoord2fARB (GL_TEXTURE0_ARB, xmax, 0);
+  glMultiTexCoord2fARB (GL_TEXTURE1_ARB, xmax, 0);
+  glMultiTexCoord2fARB (GL_TEXTURE2_ARB, xmax, 0);
+  glVertex3f (hor, 1, 0);
+
+  glEnd ();
+
+  if (xinfo->info.dumpvideo) {
+    static int framenr = 0;
+    char capfilename[255];
+    static guint8 *cap_image_data = NULL, *cap_image_data2 = NULL;
+    int i;
+
+    // hmmmm, is this reentrant ?!
+    if (cap_image_data == NULL)
+      cap_image_data = (guint8 *) malloc (img_width * img_height * 3);
+
+    if (cap_image_data2 == NULL)
+      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);
+    // 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);
+
+    sprintf (capfilename, "cap%04d.ppm", framenr);
+    FILE *outfile = fopen (capfilename, "wb");
+
+    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);
+      fclose (outfile);
     }
+    framenr++;
+  }
 
 
-  glXSwapBuffers(xinfo->dpy, xinfo->win);
+  glXSwapBuffers (xinfo->dpy, xinfo->win);
 }
 
-static void 		
-gst_gl_nvimage_free_image (GstImageData *image)
+static void
+gst_gl_nvimage_free_image (GstImageData * image)
 {
   GstNvImage *im = (GstNvImage *) image;
+
   g_return_if_fail (im != NULL);
-  GstGLImageConnection *nvconn = im->conn;  
+  GstGLImageConnection *nvconn = im->conn;
 
-  if (im->slot < AGP_BUFSLOTS)
-    {
-      nvconn->m_bufslots[im->slot] = 0;      
-    } 
-  else
-    g_free(im->data.data);
+  if (im->slot < AGP_BUFSLOTS) {
+    nvconn->m_bufslots[im->slot] = 0;
+  } else
+    g_free (im->data.data);
 
   g_free (im);
 }
 
 static void
-gst_gl_nvimage_open_conn (GstImageConnection *conn, GstImageInfo *info)
+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;
-    Initialize_Backend(Ywidth,Yheight,UVwidth,UVheight,GL_LINEAR);
+    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");
+  g_print ("Done\n");
 }
 
 static void
-gst_gl_nvimage_close_conn (GstImageConnection *conn, GstImageInfo *info)
+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
-  glDeleteTextures(1, &xconn->ytex_id);
-  glDeleteTextures(1, &xconn->uvtex_id);
-  glDeleteTextures(1, &xconn->septex_id);
+  glDeleteTextures (1, &xconn->ytex_id);
+  glDeleteTextures (1, &xconn->uvtex_id);
+  glDeleteTextures (1, &xconn->septex_id);
 }
 
-static void 			
-gst_gl_nvimage_free_conn (GstImageConnection *conn)
+static void
+gst_gl_nvimage_free_conn (GstImageConnection * conn)
 {
-  GstGLImageConnection *nvconn = gst_gl_nvimage_connection (conn);  
+  GstGLImageConnection *nvconn = gst_gl_nvimage_connection (conn);
 
   g_free (nvconn);
 }
-
diff --git a/sys/glsink/gstgl_pdrimage.c b/sys/glsink/gstgl_pdrimage.c
index 3cc5c57f..20582ebf 100644
--- a/sys/glsink/gstgl_pdrimage.c
+++ b/sys/glsink/gstgl_pdrimage.c
@@ -31,15 +31,16 @@
 #include "gstglsink.h"
 
 typedef struct _GstGLImageConnection GstGLImageConnection;
-struct _GstGLImageConnection {
+struct _GstGLImageConnection
+{
   GstImageConnection conn;
   Display *dpy;
   gint w, h;
   gint bpp;
-  
+
   int ytex_id;
   int uvtex_id;
-  int septex_id; 
+  int septex_id;
   unsigned char *m_memory;
   int m_bufslots[4];
 };
@@ -54,50 +55,57 @@ typedef struct _GstNvImage GstNvImage;
 struct _GstNvImage
 {
   GstImageData data;
-  int slot; // < AGP_BUFSLOTS: allocated from AGP mem, otherwise from CPU mem
+  int slot;			// < AGP_BUFSLOTS: allocated from AGP mem, otherwise from CPU mem
   GstGLImageConnection *conn;
 };
 
-static GstGLImageInfo *		gst_gl_nvimage_info			(GstImageInfo *info);
-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 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_close_conn		(GstImageConnection *conn, GstImageInfo *info);
-static void 			gst_gl_nvimage_free_conn		(GstImageConnection *conn);
-
-GstImagePlugin* get_gl_nvimage_plugin(void)
+static GstGLImageInfo *gst_gl_nvimage_info (GstImageInfo * info);
+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 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_close_conn (GstImageConnection * conn,
+    GstImageInfo * info);
+static void gst_gl_nvimage_free_conn (GstImageConnection * conn);
+
+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_set_caps,
+    gst_gl_nvimage_get_image,
+    gst_gl_nvimage_put_image,
+    gst_gl_nvimage_free_image
+  };
 
   return &plugin;
 }
 
 
 static GstGLImageInfo *
-gst_gl_nvimage_info (GstImageInfo *info)
+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;
 }
 
 static GstGLImageConnection *
-gst_gl_nvimage_connection (GstImageConnection *conn)
+gst_gl_nvimage_connection (GstImageConnection * conn)
 {
   if (conn == NULL || conn->free_conn != gst_gl_nvimage_free_conn)
-    return NULL; 
+    return NULL;
   return (GstGLImageConnection *) conn;
 }
 
@@ -105,47 +113,46 @@ gboolean
 gst_gl_nvimage_check_xvideo ()
 {
   int ver, rel, req, ev, err;
-  
-#if 0 
+
+#if 0
   if (display == NULL)
     return FALSE;
-  if (Success == XvQueryExtension (display,&ver,&rel,&req,&ev,&err))
+  if (Success == XvQueryExtension (display, &ver, &rel, &req, &ev, &err))
     return TRUE;
 #endif
 
   return FALSE;
 }
 
-static GstCaps * 	
-gst_gl_nvimage_get_caps (GstImageInfo *info)
+static GstCaps *
+gst_gl_nvimage_get_caps (GstImageInfo * info)
 {
   gint i;
   int adaptors;
   int formats;
   GstCaps *caps = NULL;
   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)
-  {
-    g_warning("GL_NVImage: Server has no NVidia extension support\n"); 
+  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 (
-					      "xvimage_caps",
-					      "video/raw",
-					      "format",  GST_PROPS_FOURCC (GST_MAKE_FOURCC ('Y', 'C', '1', '2')),
-					      "width",   GST_PROPS_INT_RANGE (0, 1024),
-					      "height",  GST_PROPS_INT_RANGE (0, 1024))
-			  );
+  caps = gst_caps_append (caps, GST_CAPS_NEW ("xvimage_caps",
+	  "video/raw",
+	  "format", GST_PROPS_FOURCC (GST_MAKE_FOURCC ('Y', 'C', '1', '2')),
+	  "width", GST_PROPS_INT_RANGE (0, 1024),
+	  "height", GST_PROPS_INT_RANGE (0, 1024))
+      );
   return caps;
 }
 
 static GstImageConnection *
-gst_gl_nvimage_set_caps (GstImageInfo *info, GstCaps *caps)
+gst_gl_nvimage_set_caps (GstImageInfo * info, GstCaps * caps)
 {
   gint i, j = 0;
   int adaptors;
@@ -153,78 +160,75 @@ gst_gl_nvimage_set_caps (GstImageInfo *info, GstCaps *caps)
   GstGLImageConnection *conn;
   GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
   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;
   conn->conn.close_conn = gst_gl_nvimage_close_conn;
   conn->conn.free_conn = gst_gl_nvimage_free_conn;
 
-  gst_caps_get (caps, 
-		  "width",  &conn->w,
-		  "height", &conn->h,
-		  "format", &format,
-                  NULL);
+  gst_caps_get (caps,
+      "width", &conn->w, "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', ' ')) 
-    { 
-      GST_DEBUG (GST_CAT_PLUGIN_INFO, "GL_NVImage: Format is invalid !\n");
-      return NULL;
-    }
-  if (0) //conn->port == (XvPortID) -1)
+  if (format != GST_MAKE_FOURCC ('R', 'G', 'B', ' ')) {
+    GST_DEBUG (GST_CAT_PLUGIN_INFO, "GL_NVImage: Format is invalid !\n");
+    return NULL;
+  }
+  if (0)			//conn->port == (XvPortID) -1)
   {
     /* this happens if the plugin can't handle the caps, so no warning */
     g_free (conn);
     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;
 }
 
 static GstImageData *
-gst_gl_nvimage_get_image (GstImageInfo *info, GstImageConnection *conn)
+gst_gl_nvimage_get_image (GstImageInfo * info, GstImageConnection * conn)
 {
   GstNvImage *image;
-  GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);  
-  GstGLImageConnection *nvconn = gst_gl_nvimage_connection (conn);  
+  GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
+  GstGLImageConnection *nvconn = gst_gl_nvimage_connection (conn);
   int slot = 0;
-  
+
   /* checks */
-  if (xinfo == NULL) return NULL;
-  if (nvconn == NULL) return NULL;
+  if (xinfo == 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++)
-    {
-      if (!nvconn->m_bufslots[slot]) break;
-    }
-
-  image->data.size = nvconn->w * nvconn->h * 3/2;
-
-  if (slot < AGP_BUFSLOTS) // found an AGP buffer slot
-    {
-      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
-    {
-      g_warning("Allocating from main memory !");
-      image->data.data = g_malloc(image->data.size);
-      image->slot = AGP_BUFSLOTS; // no AGP slot
-    }
-  image->conn = nvconn;
+  image = g_new0 (GstNvImage, 1);
 
-  if (image->data.data == NULL)
+  for (slot = 0; slot < AGP_BUFSLOTS; slot++) {
+    if (!nvconn->m_bufslots[slot])
+      break;
+  }
+
+  image->data.size = nvconn->w * nvconn->h * 3 / 2;
+
+  if (slot < AGP_BUFSLOTS)	// found an AGP buffer slot
   {
+    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 {
+    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) {
     g_warning ("GL_NvImage: data allocation failed!");
     g_free (image);
     return NULL;
@@ -233,166 +237,169 @@ gst_gl_nvimage_get_image (GstImageInfo *info, GstImageConnection *conn)
   return (GstImageData *) image;
 }
 
-static void 		
-gst_gl_nvimage_put_image (GstImageInfo *info, GstImageData *image)
+static void
+gst_gl_nvimage_put_image (GstImageInfo * info, GstImageData * image)
 {
   GstNvImage *im = (GstNvImage *) image;
-  GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);  
-  
+  GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
+
   /* checks omitted for speed (and lazyness), do we need them? */
   g_assert (xinfo != NULL);
-  
+
   /* Upload the texture here */
-  g_warning("PUTTING IMAGE - BROOOKEN");
+  g_warning ("PUTTING IMAGE - BROOOKEN");
 
   // both upload the video, and redraw the screen
-  glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
+  glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
-  glEnable(GL_TEXTURE_2D);
+  glEnable (GL_TEXTURE_2D);
 
-  glPushMatrix();
+  glPushMatrix ();
   //glTranslatef(0,1,0);
-  glRotatef(xinfo->rotX-250,1,0,0);
-  glRotatef(xinfo->rotY,0,1,0);
+  glRotatef (xinfo->rotX - 250, 1, 0, 0);
+  glRotatef (xinfo->rotY, 0, 1, 0);
   int zoom = xinfo->zoom;
-  glScaled(zoom,zoom,zoom);
+
+  glScaled (zoom, zoom, zoom);
   //Draws the surface rectangle
 
-  glBindTexture(GL_TEXTURE_2D, im->conn->ytex_id);
-  glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, im->conn->w, im->conn->h, GL_RGBA, 
-  		  GL_UNSIGNED_BYTE, im->data.data);  
-  float xmax = (float)im->conn->w/TEX_XSIZE;
-  float ymax = (float)im->conn->h/TEX_YSIZE;
+  glBindTexture (GL_TEXTURE_2D, im->conn->ytex_id);
+  glTexSubImage2D (GL_TEXTURE_2D, 0, 0, 0, im->conn->w, im->conn->h, GL_RGBA,
+      GL_UNSIGNED_BYTE, im->data.data);
+  float xmax = (float) im->conn->w / TEX_XSIZE;
+  float ymax = (float) im->conn->h / TEX_YSIZE;
+
+  glColor4f (1, 1, 1, 1);
+  glBegin (GL_QUADS);
 
-  glColor4f(1,1,1,1);
-  glBegin(GL_QUADS);
+  glNormal3f (0, -1, 0);
 
-  glNormal3f(0, -1, 0);
-  
-  glTexCoord2f(xmax, 0);
-  glVertex3f(4,0,-4);
+  glTexCoord2f (xmax, 0);
+  glVertex3f (4, 0, -4);
 
-  glTexCoord2f(0, 0);
-  glVertex3f(-4,0,-4);
+  glTexCoord2f (0, 0);
+  glVertex3f (-4, 0, -4);
 
-  glTexCoord2f(0, ymax);
-  glVertex3f(-4,0,4);
+  glTexCoord2f (0, ymax);
+  glVertex3f (-4, 0, 4);
 
-  glTexCoord2f(xmax, ymax);
-  glVertex3f(4,0,4);
+  glTexCoord2f (xmax, ymax);
+  glVertex3f (4, 0, 4);
 
-  glEnd();
+  glEnd ();
 
-  glPopMatrix();
+  glPopMatrix ();
 
-  glXSwapBuffers(xinfo->dpy, xinfo->win);
+  glXSwapBuffers (xinfo->dpy, xinfo->win);
 }
 
-static void 		
-gst_gl_nvimage_free_image (GstImageData *image)
+static void
+gst_gl_nvimage_free_image (GstImageData * image)
 {
   GstNvImage *im = (GstNvImage *) image;
+
   g_return_if_fail (im != NULL);
-  GstGLImageConnection *nvconn = im->conn;  
+  GstGLImageConnection *nvconn = im->conn;
 
-  if (im->slot < AGP_BUFSLOTS)
-    {
-      nvconn->m_bufslots[im->slot] = 0;      
-    } 
-  else
-    g_free(im->data.data);
+  if (im->slot < AGP_BUFSLOTS) {
+    nvconn->m_bufslots[im->slot] = 0;
+  } else
+    g_free (im->data.data);
 
   g_free (im);
 }
 
 static void
-gst_gl_nvimage_open_conn (GstImageConnection *conn, GstImageInfo *info)
+gst_gl_nvimage_open_conn (GstImageConnection * conn, GstImageInfo * info)
 {
-  GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);  
+  GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
   GstGLImageConnection *xconn = gst_gl_nvimage_connection (conn);
 
-  unsigned char data_sep[2][2] = {{0, 255}, {0, 255}}; 
+  unsigned char data_sep[2][2] = { {0, 255}, {0, 255} };
   int slot;
 
-  g_warning("Opening NVidia Connection");
-  xconn->m_memory = (unsigned char*)glXAllocateMemoryNV(AGP_BUFSLOTS*YUVTEX_SIZE, 0, 1.0, 1.0);
-  
-  if (!xconn->m_memory)
-    {
-      printf("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
-    {
-      // 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);
-      glEnableClientState(GL_WRITE_PIXEL_DATA_RANGE_NV);
-
-      for (slot = 0; slot < AGP_BUFSLOTS; slot++)
-	xconn->m_bufslots[slot] = 0;
-    }
-
-  glGenTextures(1, &xconn->ytex_id);
-  glBindTexture(GL_TEXTURE_2D, xconn->ytex_id);
-  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-  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);
-
-  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);
-  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);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
-  glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD);
-
-  glActiveTextureARB(GL_TEXTURE2_ARB);
-  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);
-  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);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
-  glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD);
-
-  glFlushPixelDataRangeNV(GL_WRITE_PIXEL_DATA_RANGE_NV);
+  g_warning ("Opening NVidia Connection");
+  xconn->m_memory =
+      (unsigned char *) glXAllocateMemoryNV (AGP_BUFSLOTS * YUVTEX_SIZE, 0, 1.0,
+      1.0);
+
+  if (!xconn->m_memory) {
+    printf
+	("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 {
+    // 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);
+    glEnableClientState (GL_WRITE_PIXEL_DATA_RANGE_NV);
+
+    for (slot = 0; slot < AGP_BUFSLOTS; slot++)
+      xconn->m_bufslots[slot] = 0;
+  }
+
+  glGenTextures (1, &xconn->ytex_id);
+  glBindTexture (GL_TEXTURE_2D, xconn->ytex_id);
+  glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
+  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+  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);
+
+  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);
+  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);
+  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+  glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD);
+
+  glActiveTextureARB (GL_TEXTURE2_ARB);
+  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);
+  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);
+  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+  glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD);
+
+  glFlushPixelDataRangeNV (GL_WRITE_PIXEL_DATA_RANGE_NV);
   //glEnable(GL_TEXTURE_2D);
-  glActiveTextureARB(GL_TEXTURE0_ARB);
-  glEnable(GL_TEXTURE_2D);
-  glActiveTextureARB(GL_TEXTURE1_ARB);
-  glEnable(GL_TEXTURE_2D);
-  glActiveTextureARB(GL_TEXTURE2_ARB);
-  glEnable(GL_TEXTURE_2D);
-  glActiveTextureARB(GL_TEXTURE0_ARB);
+  glActiveTextureARB (GL_TEXTURE0_ARB);
+  glEnable (GL_TEXTURE_2D);
+  glActiveTextureARB (GL_TEXTURE1_ARB);
+  glEnable (GL_TEXTURE_2D);
+  glActiveTextureARB (GL_TEXTURE2_ARB);
+  glEnable (GL_TEXTURE_2D);
+  glActiveTextureARB (GL_TEXTURE0_ARB);
 }
 
 static void
-gst_gl_nvimage_close_conn (GstImageConnection *conn, GstImageInfo *info)
+gst_gl_nvimage_close_conn (GstImageConnection * conn, GstImageInfo * info)
 {
   GstGLImageConnection *xconn = gst_gl_nvimage_connection (conn);
-  GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);  
+  GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
 
   // anything needed in here ? Oh, maybe drawing de-init, or something
-  glDeleteTextures(1, &xconn->ytex_id);
-  glDeleteTextures(1, &xconn->uvtex_id);
-  glDeleteTextures(1, &xconn->septex_id);
+  glDeleteTextures (1, &xconn->ytex_id);
+  glDeleteTextures (1, &xconn->uvtex_id);
+  glDeleteTextures (1, &xconn->septex_id);
 }
 
-static void 			
-gst_gl_nvimage_free_conn (GstImageConnection *conn)
+static void
+gst_gl_nvimage_free_conn (GstImageConnection * conn)
 {
-  GstGLImageConnection *nvconn = gst_gl_nvimage_connection (conn);  
+  GstGLImageConnection *nvconn = gst_gl_nvimage_connection (conn);
 
   g_free (nvconn);
 }
-
diff --git a/sys/glsink/gstgl_rgbimage.c b/sys/glsink/gstgl_rgbimage.c
index ab856bbc..8c61e390 100644
--- a/sys/glsink/gstgl_rgbimage.c
+++ b/sys/glsink/gstgl_rgbimage.c
@@ -22,20 +22,21 @@
 #include <GL/glx.h>
 #include <GL/gl.h>
 #include <GL/glu.h>
-#include <math.h> 
+#include <math.h>
 
 #include "gstglsink.h"
 
 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
+  Display *dpy;			// the Xlib drawing context
+  GLXContext ctx;		// The GLX drawing context
   gint w, h;
   gint bpp;
-  
+
   int rgbatex_id;
   unsigned char *m_memory;
 };
@@ -51,49 +52,56 @@ struct _GstGLImage
   GstGLImageConnection *conn;
 };
 
-static GstGLImageInfo *		gst_gl_rgbimage_info		(GstImageInfo *info);
-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 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_close_conn	(GstImageConnection *conn, GstImageInfo *info);
-static void 			gst_gl_rgbimage_free_conn	(GstImageConnection *conn);
-
-GstImagePlugin* get_gl_rgbimage_plugin(void)
+static GstGLImageInfo *gst_gl_rgbimage_info (GstImageInfo * info);
+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 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_close_conn (GstImageConnection * conn,
+    GstImageInfo * info);
+static void gst_gl_rgbimage_free_conn (GstImageConnection * conn);
+
+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_set_caps,
+    gst_gl_rgbimage_get_image,
+    gst_gl_rgbimage_put_image,
+    gst_gl_rgbimage_free_image
+  };
 
   return &plugin;
 }
 
 static GstGLImageInfo *
-gst_gl_rgbimage_info (GstImageInfo *info)
+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;
 }
 
 static GstGLImageConnection *
-gst_gl_rgbimage_connection (GstImageConnection *conn)
+gst_gl_rgbimage_connection (GstImageConnection * conn)
 {
   if (conn == NULL || conn->free_conn != gst_gl_rgbimage_free_conn)
-    return NULL; 
+    return NULL;
   return (GstGLImageConnection *) conn;
 }
 
 GstCaps *
-gst_gl_rgbimage_get_caps (GstImageInfo *info)
+gst_gl_rgbimage_get_caps (GstImageInfo * info)
 {
   GstCaps *caps = NULL;
   Visual *visual;
@@ -101,13 +109,15 @@ gst_gl_rgbimage_get_caps (GstImageInfo *info)
   XWindowAttributes attrib;
   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);
 
-  XGetWindowAttributes(xinfo->dpy, xinfo->win, &attrib);
-  
   visual = attrib.visual;
   if (attrib.depth <= 8)
     xpad = 8;
@@ -115,42 +125,37 @@ gst_gl_rgbimage_get_caps (GstImageInfo *info)
     xpad = 16;
   else
     xpad = 32;
-  
+
   // create a temporary image
-  ximage = XCreateImage (xinfo->dpy, visual, attrib.depth, ZPixmap, 0, NULL, 
-			      100, 100, xpad, (attrib.depth + 7) / 8 * 100);
+  ximage = XCreateImage (xinfo->dpy, visual, attrib.depth, ZPixmap, 0, NULL,
+      100, 100, xpad, (attrib.depth + 7) / 8 * 100);
   if (ximage != NULL) {
-    caps = 
-      GST_CAPS_NEW (
-		    "forcing Video RGB",
-		    "video/x-raw-rgb",
-		    "format",          GST_PROPS_FOURCC (GST_STR_FOURCC ("RGB ")),
-		    "depth",        GST_PROPS_INT(24),
-		    "bpp",          GST_PROPS_INT(24),
-		    "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) 
-		    );
+    caps =
+	GST_CAPS_NEW ("forcing Video RGB", "video/x-raw-rgb", "format",
+	GST_PROPS_FOURCC (GST_STR_FOURCC ("RGB ")), "depth", GST_PROPS_INT (24),
+	"bpp", GST_PROPS_INT (24), "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)
+	);
     XDestroyImage (ximage);
   }
-  
+
   printf ("GL_RGBImage: returning caps at %p", caps);
   return caps;
 }
 
-static GstImageConnection *	
-gst_gl_rgbimage_set_caps (GstImageInfo *info, GstCaps *caps)
+static GstImageConnection *
+gst_gl_rgbimage_set_caps (GstImageInfo * info, GstCaps * caps)
 {
-  g_warning("in set_caps !\n");
+  g_warning ("in set_caps !\n");
 
   GstGLImageConnection *new = NULL;
   Visual *visual;
   XWindowAttributes attrib;
-  GstGLImageInfo *xinfo = gst_gl_rgbimage_info (info);  
+  GstGLImageInfo *xinfo = gst_gl_rgbimage_info (info);
   guint32 format;
   gint depth;
   gint endianness;
@@ -158,26 +163,25 @@ 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;
-    
-  XGetWindowAttributes(xinfo->dpy, xinfo->win, &attrib);
-  
+  if (xinfo == NULL)
+    return NULL;
+
+  XGetWindowAttributes (xinfo->dpy, xinfo->win, &attrib);
+
   visual = attrib.visual;
 
   gst_caps_get (caps,
-		  "format", 	&format,
-		  "depth",  	&depth,
-		  "endianness", &endianness,
-		  "red_mask", 	&red_mask,
-		  "green_mask",	&green_mask,
-		  "blue_mask",	&blue_mask,
-		  "width",	&width,
-		  "height",	&height,
-		  "bpp",	&bpp,
-		  NULL);
-  
+      "format", &format,
+      "depth", &depth,
+      "endianness", &endianness,
+      "red_mask", &red_mask,
+      "green_mask", &green_mask,
+      "blue_mask", &blue_mask,
+      "width", &width, "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;
@@ -185,7 +189,7 @@ gst_gl_rgbimage_set_caps (GstImageInfo *info, GstCaps *caps)
   //if (green_mask != visual->green_mask) return NULL;
   //if (blue_mask != visual->blue_mask) return NULL;
   GST_DEBUG ("GL_RGBImage: caps %p are ok, creating image", caps);
-  
+
   new = g_new (GstGLImageConnection, 1);
   new->conn.open_conn = gst_gl_rgbimage_open_conn;
   new->conn.close_conn = gst_gl_rgbimage_close_conn;
@@ -195,34 +199,35 @@ gst_gl_rgbimage_set_caps (GstImageInfo *info, GstCaps *caps)
   new->w = width;
   new->h = height;
   new->bpp = bpp;
-  
+
   return (GstImageConnection *) new;
 }
 
 static GstImageData *
-gst_gl_rgbimage_get_image (GstImageInfo *info, GstImageConnection *conn)
+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);  
-  
+  GstGLImageInfo *xinfo = gst_gl_rgbimage_info (info);
+  GstGLImageConnection *xconn = gst_gl_rgbimage_connection (conn);
+
   image = g_new (GstGLImage, 1);
 
   /* checks */
-  if (xinfo == NULL) return NULL;
-  if (xconn == NULL) return NULL;
-  if (xinfo->dpy != xconn->dpy)
-  {
+  if (xinfo == NULL)
+    return NULL;
+  if (xconn == NULL)
+    return NULL;
+  if (xinfo->dpy != xconn->dpy) {
     g_warning ("XImage: wrong x display specified in 'get_image'\n");
     return NULL;
   }
 
   image->conn = xconn;
   image->data.size = xconn->w * xconn->h * 4;
-  image->data.data = g_malloc(image->data.size);
-  if (image->data.data == NULL)
-  {
+  image->data.data = g_malloc (image->data.size);
+  if (image->data.data == NULL) {
     g_warning ("GL_RGBImage: data allocation failed!");
     g_free (image);
     return NULL;
@@ -233,160 +238,162 @@ gst_gl_rgbimage_get_image (GstImageInfo *info, GstImageConnection *conn)
 
 
 static void
-gst_gl_rgbimage_put_image (GstImageInfo *info, GstImageData *image)
+gst_gl_rgbimage_put_image (GstImageInfo * info, GstImageData * image)
 {
   float xmax, ymax;
 
   GstGLImageInfo *xinfo = gst_gl_rgbimage_info (info);
   GstGLImage *im = (GstGLImage *) image;
 
-  int img_width = im->conn->w; 
-  int img_height = im->conn->h; 
+  int img_width = im->conn->w;
+  int img_height = im->conn->h;
 
   g_assert (xinfo != NULL);
 
   // both upload the video, and redraw the screen
-  glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
+  glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
-  glMatrixMode(GL_MODELVIEW);
-  glLoadIdentity();
-  glTranslatef(0.0, 0.0, -5.0);
+  glMatrixMode (GL_MODELVIEW);
+  glLoadIdentity ();
+  glTranslatef (0.0, 0.0, -5.0);
 
-  glEnable(GL_TEXTURE_2D);
+  glEnable (GL_TEXTURE_2D);
 
-  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);
+  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);
 
-      xinfo->rotX += 0.01;
-      xinfo->rotY -= 0.015;
-      float zoom = xinfo->zoom;
-      glScalef(zoom,zoom,zoom); 
+    xinfo->rotX += 0.01;
+    xinfo->rotY -= 0.015;
+    float zoom = xinfo->zoom;
 
-      if (xinfo->zoom > 2.0)
-	xinfo->zoomdir = -0.01;
+    glScalef (zoom, zoom, zoom);
 
-      if (xinfo->zoom < 1.0)
-	xinfo->zoomdir = 0.01;
+    if (xinfo->zoom > 2.0)
+      xinfo->zoomdir = -0.01;
 
-      xinfo->zoom += xinfo->zoomdir;
-    }  
+    if (xinfo->zoom < 1.0)
+      xinfo->zoomdir = 0.01;
 
+    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, 
-  		  GL_UNSIGNED_BYTE, im->data.data);  
-  xmax = (float)im->conn->w/TEX_XSIZE;
-  ymax = (float)im->conn->h/TEX_YSIZE;
+  glBindTexture (GL_TEXTURE_2D, im->conn->rgbatex_id);
+  glTexSubImage2D (GL_TEXTURE_2D, 0, 0, 0, im->conn->w, im->conn->h, GL_RGB,
+      GL_UNSIGNED_BYTE, im->data.data);
+  xmax = (float) im->conn->w / TEX_XSIZE;
+  ymax = (float) im->conn->h / TEX_YSIZE;
 
-  float aspect = img_width/(float)img_height;
+  float aspect = img_width / (float) img_height;
   float hor = aspect;
 
-  glColor4f(1,1,1,1);
-  glBegin(GL_QUADS);
-
-  glNormal3f(0, -1, 0);
-  
-  glTexCoord2f(xmax, 0);
-  glVertex3f(hor,1,0);
-
-  glTexCoord2f(0, 0);
-  glVertex3f(-hor,1,0);
-
-  glTexCoord2f(0, ymax);
-  glVertex3f(-hor,-1,0);
-
-  glTexCoord2f(xmax, ymax);
-  glVertex3f(hor,-1,0);
-  glEnd();
-
-  if (xinfo->info.dumpvideo)
-    {
-      static int framenr = 0; 
-      char capfilename[255];
-      static guint8 *cap_image_data = NULL, *cap_image_data2 = NULL;
-      int i;
-      
-      // hmmmm, is this reentrant ?!
-      if (cap_image_data == NULL)
-	cap_image_data = (guint8 *)malloc(img_width * img_height * 3);
-
-      if (cap_image_data2 == NULL)
-	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);
-      // 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);
-      
-      sprintf(capfilename, "cap%04d.ppm", framenr);
-      FILE *outfile = fopen(capfilename, "wb");
-      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);
-	  fclose(outfile);
-	}
-      framenr++;
+  glColor4f (1, 1, 1, 1);
+  glBegin (GL_QUADS);
+
+  glNormal3f (0, -1, 0);
+
+  glTexCoord2f (xmax, 0);
+  glVertex3f (hor, 1, 0);
+
+  glTexCoord2f (0, 0);
+  glVertex3f (-hor, 1, 0);
+
+  glTexCoord2f (0, ymax);
+  glVertex3f (-hor, -1, 0);
+
+  glTexCoord2f (xmax, ymax);
+  glVertex3f (hor, -1, 0);
+  glEnd ();
+
+  if (xinfo->info.dumpvideo) {
+    static int framenr = 0;
+    char capfilename[255];
+    static guint8 *cap_image_data = NULL, *cap_image_data2 = NULL;
+    int i;
+
+    // hmmmm, is this reentrant ?!
+    if (cap_image_data == NULL)
+      cap_image_data = (guint8 *) malloc (img_width * img_height * 3);
+
+    if (cap_image_data2 == NULL)
+      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);
+    // 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);
+
+    sprintf (capfilename, "cap%04d.ppm", framenr);
+    FILE *outfile = fopen (capfilename, "wb");
+
+    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);
+      fclose (outfile);
     }
+    framenr++;
+  }
 
-  glXSwapBuffers(xinfo->dpy, xinfo->win);
+  glXSwapBuffers (xinfo->dpy, xinfo->win);
 }
 
 void
-gst_gl_rgbimage_free_image (GstImageData *image)
+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);
 }
 
 /* Creates an OpenGL texture to upload the picture over */
 static void
-gst_gl_rgbimage_open_conn (GstImageConnection *conn, GstImageInfo *info)
+gst_gl_rgbimage_open_conn (GstImageConnection * conn, GstImageInfo * info)
 {
-  g_warning("Opening RGB Connection; classic OpenGL 1.2 renderer.");
+  g_warning ("Opening RGB Connection; classic OpenGL 1.2 renderer.");
 
   //GstGLImageInfo *xinfo = gst_gl_rgbimage_info (info);  
   GstGLImageConnection *xconn = gst_gl_rgbimage_connection (conn);
 
-  glGenTextures(1, &xconn->rgbatex_id);
-  glBindTexture(GL_TEXTURE_2D, xconn->rgbatex_id);
-  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-  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);
+  glGenTextures (1, &xconn->rgbatex_id);
+  glBindTexture (GL_TEXTURE_2D, xconn->rgbatex_id);
+  glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
+  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+  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);
 }
 
 /* Deletes the creates OpenGL textures */
-static void 
-gst_gl_rgbimage_close_conn (GstImageConnection *conn, GstImageInfo *info)
+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);
- }
+  glDeleteTextures (1, &xconn->rgbatex_id);
+}
 
 static void
-gst_gl_rgbimage_free_conn (GstImageConnection *conn)
+gst_gl_rgbimage_free_conn (GstImageConnection * conn)
 {
   GstGLImageConnection *xconn = gst_gl_rgbimage_connection (conn);
-  
+
   g_assert (xconn != NULL);
-  
+
   g_free (xconn);
 }
-
-   
diff --git a/sys/glsink/gstglsink.c b/sys/glsink/gstglsink.c
index 21cac1f3..a545c2a8 100644
--- a/sys/glsink/gstglsink.c
+++ b/sys/glsink/gstglsink.c
@@ -52,37 +52,39 @@ static GstElementDetails gst_glsink_details = {
 /* default template - initiated with class struct to allow gst-register to work
    with X running */
 GST_PAD_TEMPLATE_FACTORY (gst_glsink_sink_template_factory,
-  "sink",
-  GST_PAD_SINK,
-  GST_PAD_ALWAYS,
-  GST_CAPS_NEW ( "glsink_rgbsink", "video/x-raw-rgb",
-    "framerate", GST_PROPS_FLOAT_RANGE(0, G_MAXFLOAT),
-    "width", GST_PROPS_INT_RANGE(0, G_MAXINT),
-    "height", GST_PROPS_INT_RANGE(0, G_MAXINT)),
-  GST_CAPS_NEW ( "glsink_yuvsink", "video/x-raw-yuv",
-    "framerate", GST_PROPS_FLOAT_RANGE(0, G_MAXFLOAT),
-    "width", GST_PROPS_INT_RANGE(0, G_MAXINT),
-    "height", GST_PROPS_INT_RANGE(0, G_MAXINT))
-)
+    "sink",
+    GST_PAD_SINK,
+    GST_PAD_ALWAYS,
+    GST_CAPS_NEW ("glsink_rgbsink", "video/x-raw-rgb",
+	"framerate", GST_PROPS_FLOAT_RANGE (0, G_MAXFLOAT),
+	"width", GST_PROPS_INT_RANGE (0, G_MAXINT),
+	"height", GST_PROPS_INT_RANGE (0, G_MAXINT)),
+    GST_CAPS_NEW ("glsink_yuvsink", "video/x-raw-yuv",
+	"framerate", GST_PROPS_FLOAT_RANGE (0, G_MAXFLOAT),
+	"width", GST_PROPS_INT_RANGE (0, G_MAXINT),
+	"height", GST_PROPS_INT_RANGE (0, G_MAXINT))
+    )
 
 /* glsink signals and args */
-enum {
-  LAST_SIGNAL
-};
-
-
-enum {
-  ARG_0,
-  ARG_WIDTH,
-  ARG_HEIGHT,
-  ARG_FRAMES_DISPLAYED,
-  ARG_FRAME_TIME,
-  ARG_HOOK,
-  ARG_MUTE,
-  ARG_REPAINT,
-  ARG_DEMO,
-  ARG_DUMP
-};
+     enum
+     {
+       LAST_SIGNAL
+     };
+
+
+     enum
+     {
+       ARG_0,
+       ARG_WIDTH,
+       ARG_HEIGHT,
+       ARG_FRAMES_DISPLAYED,
+       ARG_FRAME_TIME,
+       ARG_HOOK,
+       ARG_MUTE,
+       ARG_REPAINT,
+       ARG_DEMO,
+       ARG_DUMP
+     };
 
 /* GLsink class */
 #define GST_TYPE_GLSINK		(gst_glsink_get_type())
@@ -91,96 +93,105 @@ enum {
 #define GST_IS_GLSINK(obj)		(G_TYPE_CHECK_INSTANCE_TYPE((obj), GST_TYPE_GLSINK))
 #define GST_IS_GLSINK_CLASS(obj)	(G_TYPE_CHECK_CLASS_TYPE((klass), GST_TYPE_GLSINK))
 
-typedef struct _GstGLSink GstGLSink;
-typedef struct _GstGLSinkClass GstGLSinkClass;
+     typedef struct _GstGLSink GstGLSink;
+     typedef struct _GstGLSinkClass GstGLSinkClass;
 
-struct _GstGLSink {
-  GstElement element;
+     struct _GstGLSink
+     {
+       GstElement element;
 
-  GstPad *sinkpad;
+       GstPad *sinkpad;
 
-  gint frames_displayed;
-  guint64 frame_time;
-  gint width, height;
-  gboolean muted;
-  gint demo; // some kind of fun demo mode to let GL show its 3D capabilities
-  gboolean dumpvideo; // dump the video down to .ppm:s 
-  GstBuffer *last_image; /* not thread safe ? */
-  
-  GstClock *clock;
+       gint frames_displayed;
+       guint64 frame_time;
+       gint width, height;
+       gboolean muted;
+       gint demo;		// some kind of fun demo mode to let GL show its 3D capabilities
+       gboolean dumpvideo;	// dump the video down to .ppm:s 
+       GstBuffer *last_image;	/* not thread safe ? */
 
-  GMutex *cache_lock;
-  GList *cache;
-  
-  /* plugins */
-  GstImagePlugin* plugin;
-  GstImageConnection *conn;
-  
-  /* allow anybody to hook in here */
-  GstImageInfo *hook;
-};
+       GstClock *clock;
 
-struct _GstGLSinkClass {
-  GstElementClass parent_class;
+       GMutex *cache_lock;
+       GList *cache;
 
-  /* plugins */
-  GList *plugins;
-};
+       /* plugins */
+       GstImagePlugin *plugin;
+       GstImageConnection *conn;
+
+       /* allow anybody to hook in here */
+       GstImageInfo *hook;
+     };
 
+     struct _GstGLSinkClass
+     {
+       GstElementClass parent_class;
+
+       /* plugins */
+       GList *plugins;
+     };
+
+
+     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 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 GstPadLinkReturn	gst_glsink_sinkconnect	(GstPad *pad, GstCaps *caps);
-static GstCaps *		gst_glsink_getcaps		(GstPad *pad, GstCaps *caps);
+     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 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, 
-								 const GValue *value, GParamSpec *pspec);
-static void			gst_glsink_get_property	(GObject *object, guint prop_id, 
-								 GValue *value, GParamSpec *pspec);
+     static void gst_glsink_set_property (GObject * object, guint prop_id,
+    const GValue * value, GParamSpec * pspec);
+     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 gboolean			gst_glsink_set_caps		(GstGLSink *sink, GstCaps *caps);
+     static void gst_glsink_release_conn (GstGLSink * sink);
+     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);
+     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);
-extern void			gst_glxwindow_unhook_context 		(GstImageInfo *info);
+     extern void gst_glxwindow_new (GstGLSink * sink);
+     extern void gst_glxwindow_hook_context (GstImageInfo * info);
+     extern void gst_glxwindow_unhook_context (GstImageInfo * info);
 
 
-static GstPadTemplate *sink_template;
+     static GstPadTemplate *sink_template;
+
+     static GstElementClass *parent_class = NULL;
 
-static GstElementClass *parent_class = NULL;
 /* static guint gst_glsink_signals[LAST_SIGNAL] = { 0 }; */
 
-static GType
-gst_glsink_get_type (void)
+     static GType gst_glsink_get_type (void)
 {
   static GType videosink_type = 0;
 
   if (!videosink_type) {
     static const GTypeInfo videosink_info = {
-      sizeof(GstGLSinkClass),
+      sizeof (GstGLSinkClass),
       gst_glsink_base_init,
       NULL,
       (GClassInitFunc) gst_glsink_class_init,
       NULL,
       NULL,
-      sizeof(GstGLSink),
+      sizeof (GstGLSink),
       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;
 }
@@ -189,56 +200,52 @@ static void
 gst_glsink_base_init (gpointer g_class)
 {
   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
-  
+
   gst_element_class_set_details (element_class, &gst_glsink_details);
 
-  gst_element_class_add_pad_template (
-    element_class, 
-    GST_PAD_TEMPLATE_GET (gst_glsink_sink_template_factory));
+  gst_element_class_add_pad_template (element_class,
+      GST_PAD_TEMPLATE_GET (gst_glsink_sink_template_factory));
 }
 
 static void
-gst_glsink_class_init (GstGLSinkClass *klass)
+gst_glsink_class_init (GstGLSinkClass * klass)
 {
   GObjectClass *gobject_class;
   GstElementClass *gstelement_class;
 
   gobject_class = (GObjectClass *) klass;
-  gstelement_class = (GstElementClass*) klass;
+  gstelement_class = (GstElementClass *) klass;
 
   parent_class = g_type_class_ref (GST_TYPE_ELEMENT);
 
-  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_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_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_WIDTH, g_param_spec_int ("width", "Width", "The video width", G_MININT, G_MAXINT, 0, G_PARAM_READABLE));	/* CHECKME */
+  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_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;
 
   /*gobject_class->dispose = gst_glsink_dispose; */
-  
+
   gstelement_class->change_state = gst_glsink_change_state;
   gstelement_class->set_clock = gst_glsink_set_clock;
-  
+
   /* plugins */
   klass->plugins = NULL;
   klass->plugins = g_list_append (klass->plugins, get_gl_rgbimage_plugin ());
@@ -251,7 +258,7 @@ gst_glsink_class_init (GstGLSinkClass *klass)
   buffer upload 
 */
 static void
-gst_glsink_init (GstGLSink *sink)
+gst_glsink_init (GstGLSink * sink)
 {
   sink->sinkpad = gst_pad_new_from_template (sink_template, "sink");
   gst_element_add_pad (GST_ELEMENT (sink), sink->sinkpad);
@@ -264,53 +271,52 @@ gst_glsink_init (GstGLSink *sink)
   sink->width = 0;
   sink->height = 0;
   sink->muted = FALSE;
-  sink->clock = NULL;  
-  GST_FLAG_SET(sink, GST_ELEMENT_THREAD_SUGGESTED);
+  sink->clock = NULL;
+  GST_FLAG_SET (sink, GST_ELEMENT_THREAD_SUGGESTED);
   GST_FLAG_SET (sink, GST_ELEMENT_EVENT_AWARE);
-    
+
   /* create bufferpool and image cache */
   GST_DEBUG ("glsink: creating bufferpool");
-  sink->cache_lock = g_mutex_new();
-  sink->cache = NULL; 
-  
+  sink->cache_lock = g_mutex_new ();
+  sink->cache = NULL;
+
   /* plugins */
   sink->plugin = NULL;
   sink->conn = NULL;
-  
+
   /* do initialization of default hook here */
-  gst_glxwindow_new (sink); 
+  gst_glxwindow_new (sink);
   //printf("GLSink_init: Current context %p\n", glXGetCurrentContext());
-  gst_glxwindow_unhook_context(sink->hook);
+  gst_glxwindow_unhook_context (sink->hook);
 }
 
 /** frees the temporary connection that tests the window system capabilities */
 static void
-gst_glsink_release_conn (GstGLSink *sink)
+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);
   }
   g_mutex_unlock (sink->cache_lock);
-  
+
   /* release connection */
   sink->conn->free_conn (sink->conn);
   sink->conn = NULL;
 }
 
-static void 		
-gst_glsink_append_cache (GstGLSink *sink, GstImageData *image)
+static void
+gst_glsink_append_cache (GstGLSink * sink, GstImageData * image)
 {
   g_mutex_lock (sink->cache_lock);
   sink->cache = g_list_prepend (sink->cache, image);
@@ -322,16 +328,16 @@ gst_glsink_append_cache (GstGLSink *sink, GstImageData *image)
    Create a new buffer to hand up the chain.
    This allows the plugins to make its own decoding buffers
  */
-static GstBuffer*
-gst_glsink_buffer_new (GstBufferPool *pool, gint64 location, 
-		          guint size, gpointer user_data)
+static GstBuffer *
+gst_glsink_buffer_new (GstBufferPool * pool, gint64 location,
+    guint size, gpointer user_data)
 {
   GstGLSink *sink;
   GstBuffer *buffer;
   GstImageData *image;
-  
+
   sink = GST_GLSINK (user_data);
-  
+
   /* If cache is non-empty, get buffer from there */
   if (sink->cache != NULL) {
     g_mutex_lock (sink->cache_lock);
@@ -342,12 +348,12 @@ gst_glsink_buffer_new (GstBufferPool *pool, gint64 location,
     /* otherwise, get one from the plugin */
     image = sink->plugin->get_image (sink->hook, sink->conn);
   }
-  
+
   buffer = gst_buffer_new ();
   GST_BUFFER_DATA (buffer) = image->data;
   GST_BUFFER_SIZE (buffer) = image->size;
   GST_BUFFER_POOL_PRIVATE (buffer) = image;
-  
+
   return buffer;
 }
 
@@ -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;
@@ -373,23 +383,23 @@ gst_glsink_buffer_free (GstBufferPool *pool, GstBuffer *buffer, gpointer user_da
    Go through the plugin list, finding the plugin that first fits the given parameters 
 */
 static gboolean
-gst_glsink_set_caps (GstGLSink *sink, GstCaps *caps)
+gst_glsink_set_caps (GstGLSink * sink, GstCaps * caps)
 {
-  g_warning("in glsink set caps!\n");
-  printf("Getting GLstring, context is %p\n",  glXGetCurrentContext());
-    
+  g_warning ("in glsink set caps!\n");
+  printf ("Getting GLstring, context is %p\n", glXGetCurrentContext ());
+
   GList *list = ((GstGLSinkClass *) G_OBJECT_GET_CLASS (sink))->plugins;
   GstImageConnection *conn = NULL;
-  while (list)    
-  {
-  printf("AGetting GLstring, context is %p\n",  glXGetCurrentContext());
+
+  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());
+      printf ("BGetting GLstring, context is %p\n", glXGetCurrentContext ());
       sink->conn = conn;
-  printf("CGetting GLstring, context is %p\n",  glXGetCurrentContext());
+      printf ("CGetting GLstring, context is %p\n", glXGetCurrentContext ());
       sink->plugin = plugin;
       sink->conn->open_conn (sink->conn, sink->hook);
       return TRUE;
@@ -403,9 +413,9 @@ gst_glsink_set_caps (GstGLSink *sink, GstCaps *caps)
 Link the input video sink internally.
 */
 static GstPadLinkReturn
-gst_glsink_sinkconnect (GstPad *pad, GstCaps *caps)
+gst_glsink_sinkconnect (GstPad * pad, GstCaps * caps)
 {
-  g_warning("in glsink sinkconnect!\n");
+  g_warning ("in glsink sinkconnect!\n");
   GstGLSink *sink;
   guint32 fourcc, print_format, result;
 
@@ -414,25 +424,24 @@ gst_glsink_sinkconnect (GstPad *pad, GstCaps *caps)
   /* we are not going to act on variable caps */
   if (!GST_CAPS_IS_FIXED (caps))
     return GST_PAD_LINK_DELAYED;
-  
-  gst_glxwindow_hook_context(sink->hook);
+
+  gst_glxwindow_hook_context (sink->hook);
   /* try to set the caps on the output */
   result = gst_glsink_set_caps (sink, caps);
-  gst_glxwindow_unhook_context(sink->hook);
+  gst_glxwindow_unhook_context (sink->hook);
+
+  if (result == FALSE) {
+    return GST_PAD_LINK_REFUSED;
+  }
 
-  if (result == FALSE)
-    {
-      return GST_PAD_LINK_REFUSED;
-    }
-  
   /* remember width & height */
   gst_caps_get_int (caps, "width", &sink->width);
   gst_caps_get_int (caps, "height", &sink->height);
 
   gst_caps_get_fourcc_int (caps, "format", &fourcc);
   print_format = GULONG_FROM_LE (fourcc);
-  GST_DEBUG ("glsink: setting %08x (%4.4s) %dx%d\n", 
-		  fourcc, (gchar*)&print_format, sink->width, sink->height);
+  GST_DEBUG ("glsink: setting %08x (%4.4s) %dx%d\n",
+      fourcc, (gchar *) & print_format, sink->width, sink->height);
 
   /* emit signal */
   g_object_freeze_notify (G_OBJECT (sink));
@@ -443,34 +452,35 @@ gst_glsink_sinkconnect (GstPad *pad, GstCaps *caps)
   return GST_PAD_LINK_OK;
 }
 static GstCaps *
-gst_glsink_getcaps (GstPad *pad, GstCaps *caps)
+gst_glsink_getcaps (GstPad * pad, GstCaps * caps)
 {
-  g_warning("in glsink get caps!\n");
+  g_warning ("in glsink get caps!\n");
   /* what is the "caps" parameter good for? */
   GstGLSink *sink = GST_GLSINK (gst_pad_get_parent (pad));
   GstCaps *ret = NULL;
   GList *list = ((GstGLSinkClass *) G_OBJECT_GET_CLASS (sink))->plugins;
-  
-  gst_glxwindow_hook_context(sink->hook);
-  while (list)    
-  {
-    ret = gst_caps_append (ret, ((GstImagePlugin *) list->data)->get_caps (sink->hook));
+
+  gst_glxwindow_hook_context (sink->hook);
+  while (list) {
+    ret =
+	gst_caps_append (ret,
+	((GstImagePlugin *) list->data)->get_caps (sink->hook));
     list = g_list_next (list);
   }
 
-  gst_glxwindow_unhook_context(sink->hook);
+  gst_glxwindow_unhook_context (sink->hook);
   return ret;
 }
 
 static void
-gst_glsink_set_clock (GstElement *element, GstClock *clock)
+gst_glsink_set_clock (GstElement * element, GstClock * clock)
 {
   GstGLSink *sink = GST_GLSINK (element);
-  
+
   sink->clock = clock;
 }
 static void
-gst_glsink_chain (GstPad *pad, GstData *_data)
+gst_glsink_chain (GstPad * pad, GstData * _data)
 {
   //g_warning("in glsink_chain!\n");
   GstBuffer *buf = GST_BUFFER (_data);
@@ -489,30 +499,30 @@ gst_glsink_chain (GstPad *pad, GstData *_data)
 
     switch (GST_EVENT_TYPE (event)) {
       default:
-        gst_pad_event_default (pad, event);
+	gst_pad_event_default (pad, event);
     }
     return;
   }
-  GST_DEBUG ("glsink: clock wait: %llu %u", 
-		  GST_BUFFER_TIMESTAMP (buf), GST_BUFFER_SIZE (buf));
+  GST_DEBUG ("glsink: clock wait: %llu %u",
+      GST_BUFFER_TIMESTAMP (buf), GST_BUFFER_SIZE (buf));
 
 #if 0
   GstClockTime time = GST_BUFFER_TIMESTAMP (buf);
   static int frame_drops = 0;
 
   if (sink->clock && time != -1) {
-    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);
-	frame_drops++;
-	return;
-      }
-    frame_drops = 0; // we made it - reset time
+    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);
+      frame_drops++;
+      return;
+    }
+    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,71 +539,74 @@ gst_glsink_chain (GstPad *pad, GstData *_data)
   sink->frames_displayed++;
   g_object_notify (G_OBJECT (sink), "frames_displayed");
 
-  if (!sink->muted)
-  {
-    if (glXGetCurrentContext() == NULL)
-      {
-	printf("Rehooking window !\n");
-	gst_glxwindow_hook_context(sink->hook);
+  if (!sink->muted) {
+    if (glXGetCurrentContext () == NULL) {
+      printf ("Rehooking window !\n");
+      gst_glxwindow_hook_context (sink->hook);
 
 #if 1
-	GST_DEBUG("Initializing OpenGL parameters\n");
-	/* initialize OpenGL drawing */
-	glEnable(GL_DEPTH_TEST);
-	glEnable(GL_TEXTURE_2D);
-	glClearDepth(1.0f);
-	glClearColor(0, 0, 0, 0);
-	
-	glEnable(GL_AUTO_NORMAL); // let OpenGL generate the Normals
-	
-	glDisable(GL_BLEND);
-	glDisable(GL_CULL_FACE);
-	glPolygonMode(GL_FRONT, GL_FILL);
-	glPolygonMode(GL_BACK, GL_FILL);
-	
-	glShadeModel(GL_SMOOTH);
-	glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_NICEST);
-	
-	GstGLImageInfo *window = (GstGLImageInfo *)sink->hook;
-	int w=window->width, h = window->height;
-
-	glViewport(0, 0, (GLint) w, (GLint) h);
-	glMatrixMode(GL_PROJECTION);
-	glLoadIdentity();
-	
-	GLfloat aspect = (GLfloat) w / (GLfloat) h;
-	glFrustum(-aspect, aspect, -1.0, 1.0, 5.0, 500.0);
+      GST_DEBUG ("Initializing OpenGL parameters\n");
+      /* initialize OpenGL drawing */
+      glEnable (GL_DEPTH_TEST);
+      glEnable (GL_TEXTURE_2D);
+      glClearDepth (1.0f);
+      glClearColor (0, 0, 0, 0);
+
+      glEnable (GL_AUTO_NORMAL);	// let OpenGL generate the Normals
+
+      glDisable (GL_BLEND);
+      glDisable (GL_CULL_FACE);
+      glPolygonMode (GL_FRONT, GL_FILL);
+      glPolygonMode (GL_BACK, GL_FILL);
+
+      glShadeModel (GL_SMOOTH);
+      glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
+
+      GstGLImageInfo *window = (GstGLImageInfo *) sink->hook;
+      int w = window->width, h = window->height;
+
+      glViewport (0, 0, (GLint) w, (GLint) h);
+      glMatrixMode (GL_PROJECTION);
+      glLoadIdentity ();
+
+      GLfloat aspect = (GLfloat) w / (GLfloat) h;
+
+      glFrustum (-aspect, aspect, -1.0, 1.0, 5.0, 500.0);
 
 #endif
-	gst_glxwindow_unhook_context(sink->hook);
-	gst_glxwindow_hook_context(sink->hook);
-	glMatrixMode(GL_MODELVIEW);
-#if 0 
-	sink->hook->free_info(sink->hook);
-	printf("Reallocating window brutally !\n");
-	gst_glxwindow_new(sink);
+      gst_glxwindow_unhook_context (sink->hook);
+      gst_glxwindow_hook_context (sink->hook);
+      glMatrixMode (GL_MODELVIEW);
+#if 0
+      sink->hook->free_info (sink->hook);
+      printf ("Reallocating window brutally !\n");
+      gst_glxwindow_new (sink);
 #endif
-      }
-    
+    }
+
     /* free last_image, if any */
     if (sink->last_image != NULL)
       gst_buffer_unref (sink->last_image);
     if (sink->bufferpool && GST_BUFFER_BUFFERPOOL (buf) == sink->bufferpool) {
-      
+
       // awful hack ! But I currently have no other solution without changing the API
       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), 
-		                         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 (buffer) : GST_BUFFER_SIZE (buf));
+      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 (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);
@@ -601,12 +614,13 @@ gst_glsink_chain (GstPad *pad, GstData *_data)
 
     //gst_glxwindow_unhook_context(sink->hook);
   }
-  
+
 }
 
 
 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,13 +669,14 @@ 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;
 
   /* it's not null if we got it, but it might not be ours */
-  sink = GST_GLSINK(object);
+  sink = GST_GLSINK (object);
 
   switch (prop_id) {
     case ARG_WIDTH:
@@ -674,7 +689,7 @@ gst_glsink_get_property (GObject *object, guint prop_id, GValue *value, GParamSp
       g_value_set_int (value, sink->frames_displayed);
       break;
     case ARG_FRAME_TIME:
-      g_value_set_int (value, sink->frame_time/1000000);
+      g_value_set_int (value, sink->frame_time / 1000000);
       break;
     case ARG_MUTE:
       g_value_set_boolean (value, sink->muted);
@@ -685,7 +700,7 @@ gst_glsink_get_property (GObject *object, guint prop_id, GValue *value, GParamSp
     case ARG_DUMP:
       g_value_set_boolean (value, sink->dumpvideo);
       break;
-    default: 
+    default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
   }
@@ -693,7 +708,7 @@ gst_glsink_get_property (GObject *object, guint prop_id, GValue *value, GParamSp
 
 
 static GstElementStateReturn
-gst_glsink_change_state (GstElement *element)
+gst_glsink_change_state (GstElement * element)
 {
   //g_warning("in change_state!\n");
   GstGLSink *sink;
@@ -704,23 +719,23 @@ gst_glsink_change_state (GstElement *element)
     case GST_STATE_NULL_TO_READY:
       break;
     case GST_STATE_READY_TO_PAUSED:
-      {
-	//g_warning("Going GST_STATE_READY_TO_PAUSED: %p", sink->conn);
-      }
+    {
+      //g_warning("Going GST_STATE_READY_TO_PAUSED: %p", sink->conn);
+    }
       break;
     case GST_STATE_PAUSED_TO_PLAYING:
-      {
-	//g_warning("Going GST_STATE_PAUSED_TO_PLAYING: %p", sink->conn);
-      }
+    {
+      //g_warning("Going GST_STATE_PAUSED_TO_PLAYING: %p", sink->conn);
+    }
       break;
     case GST_STATE_PLAYING_TO_PAUSED:
       break;
     case GST_STATE_PAUSED_TO_READY:
       if (sink->conn)
-        sink->conn->close_conn (sink->conn, sink->hook);
+	sink->conn->close_conn (sink->conn, sink->hook);
       if (sink->last_image) {
 	gst_buffer_unref (sink->last_image);
-        sink->last_image = NULL;
+	sink->last_image = NULL;
       }
       break;
     case GST_STATE_READY_TO_NULL:
@@ -734,18 +749,15 @@ gst_glsink_change_state (GstElement *element)
 }
 
 static gboolean
-plugin_init (GstPlugin *plugin)
+plugin_init (GstPlugin * plugin)
 {
   /* Loading the library containing GstVideoSink, our parent object */
   if (!gst_library_load ("gstvideo"))
     return FALSE;
 
   /* this is needed later on in the _real_ init (during a gst-launch) */
-  sink_template = gst_pad_template_new (
-		  "sink",
-                  GST_PAD_SINK,
-  		  GST_PAD_ALWAYS,
-		  NULL);
+  sink_template = gst_pad_template_new ("sink",
+      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_VERSION_MAJOR,
-  GST_VERSION_MINOR,
-  "glsink",
-  "An OpenGL based video sink - uses OpenGL and GLX to draw video, utilizing different acceleration options",
-  plugin_init,
-  VERSION,
-  GST_LICENSE,
-  GST_PACKAGE,
-  GST_ORIGIN
-);
+GST_PLUGIN_DEFINE (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, VERSION, GST_LICENSE, GST_PACKAGE, GST_ORIGIN);
diff --git a/sys/glsink/gstglsink.h b/sys/glsink/gstglsink.h
index 8a34df9a..036ee78d 100644
--- a/sys/glsink/gstglsink.h
+++ b/sys/glsink/gstglsink.h
@@ -25,72 +25,81 @@
 #include <gst/gst.h>
 
 #ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
+extern "C"
+{
+#endif				/* __cplusplus */
 
 #define MAX_FLIP_BUFFERS 1
 
-typedef struct _GstImageInfo GstImageInfo;
-struct _GstImageInfo {
-  gulong id;
-  int demo;
-  int dumpvideo;
-  void (*free_info) (GstImageInfo *info);
-};
-
-
-typedef struct _GstImageData GstImageData;
-struct _GstImageData {
-  gint size;
-  gchar *data;
-};
-
-typedef struct _GstImageConnection 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 GstImageData*		(*GstImagePluginGetImageFunc)	(GstImageInfo *info, GstImageConnection *conn);
-typedef void 			(*GstImagePluginPutImageFunc)	(GstImageInfo *info, GstImageData *image);
-typedef void 			(*GstImagePluginFreeImageFunc)	(GstImageData *image);
-
-typedef struct _GstImagePlugin GstImagePlugin;
-struct _GstImagePlugin {
-  GstImagePluginGetCapsFunc	get_caps;
-  GstImagePluginSetCapsFunc	set_caps;
-  GstImagePluginGetImageFunc	get_image;
-  GstImagePluginPutImageFunc	put_image;
-  GstImagePluginFreeImageFunc	free_image;
-};
-
-typedef struct _GstGLImageInfo GstGLImageInfo;
+  typedef struct _GstImageInfo GstImageInfo;
+  struct _GstImageInfo
+  {
+    gulong id;
+    int demo;
+    int dumpvideo;
+    void (*free_info) (GstImageInfo * info);
+  };
+
+
+  typedef struct _GstImageData GstImageData;
+  struct _GstImageData
+  {
+    gint size;
+    gchar *data;
+  };
+
+  typedef struct _GstImageConnection 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 GstImageData *(*GstImagePluginGetImageFunc) (GstImageInfo * info,
+      GstImageConnection * conn);
+  typedef void (*GstImagePluginPutImageFunc) (GstImageInfo * info,
+      GstImageData * image);
+  typedef void (*GstImagePluginFreeImageFunc) (GstImageData * image);
+
+  typedef struct _GstImagePlugin GstImagePlugin;
+  struct _GstImagePlugin
+  {
+    GstImagePluginGetCapsFunc get_caps;
+    GstImagePluginSetCapsFunc set_caps;
+    GstImagePluginGetImageFunc get_image;
+    GstImagePluginPutImageFunc put_image;
+    GstImagePluginFreeImageFunc free_image;
+  };
+
+  typedef struct _GstGLImageInfo GstGLImageInfo;
 /* stuff about our window grouped together */
-struct _GstGLImageInfo {
-  GstImageInfo info;
-  Display *dpy;
-  int screen;
-  Window win;
-  GLXContext ctx;
-  XSetWindowAttributes attr;
-  Bool fs;
-  //XF86VidModeModeInfo deskMode;
-  int x, y;
-  unsigned int width, height;
-  unsigned int depth;    
-  /* window specific from here */
-  GstElement *sink;
-  gulong handler_id;
-  float rotX,rotY,zoom, zoomdir;
-};
+  struct _GstGLImageInfo
+  {
+    GstImageInfo info;
+    Display *dpy;
+    int screen;
+    Window win;
+    GLXContext ctx;
+    XSetWindowAttributes attr;
+    Bool fs;
+    //XF86VidModeModeInfo deskMode;
+    int x, y;
+    unsigned int width, height;
+    unsigned int depth;
+    /* window specific from here */
+    GstElement *sink;
+    gulong handler_id;
+    float rotX, rotY, zoom, zoomdir;
+  };
 
 
 #ifdef __cplusplus
 }
-#endif /* __cplusplus */
+#endif				/* __cplusplus */
 
 
-#endif /* __GST_VIDEOSINK_H__ */
+#endif				/* __GST_VIDEOSINK_H__ */
diff --git a/sys/glsink/gstglxwindow.c b/sys/glsink/gstglxwindow.c
index 3d173b2b..8fdacb2f 100644
--- a/sys/glsink/gstglxwindow.c
+++ b/sys/glsink/gstglxwindow.c
@@ -17,128 +17,119 @@
 #include <GL/gl.h>
 #include <GL/glu.h>
 #include "gstglsink.h"
-#include <string.h> /* strncmp */
+#include <string.h>		/* strncmp */
 
 /* 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[] = 
-{
-  GLX_RGBA, GLX_RED_SIZE, 4, 
-  GLX_GREEN_SIZE, 4, 
-  GLX_BLUE_SIZE, 4, 
+static int attrListSgl[] = {
+  GLX_RGBA, GLX_RED_SIZE, 4,
+  GLX_GREEN_SIZE, 4,
+  GLX_BLUE_SIZE, 4,
   GLX_DEPTH_SIZE, 16,
   None
 };
 
 /* 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[] = 
-  { 
-    GLX_RGBA, GLX_DOUBLEBUFFER, 
-    GLX_RED_SIZE, 4, 
-    GLX_GREEN_SIZE, 4, 
-    GLX_BLUE_SIZE, 4, 
-    GLX_DEPTH_SIZE, 16,
-    None 
-  };
+static int attrListDbl[] = {
+  GLX_RGBA, GLX_DOUBLEBUFFER,
+  GLX_RED_SIZE, 4,
+  GLX_GREEN_SIZE, 4,
+  GLX_BLUE_SIZE, 4,
+  GLX_DEPTH_SIZE, 16,
+  None
+};
 
 
-GLfloat LightAmbient[] = { 0.1, 0.1, 0.1, 1.0 };  /* reddish ambient light  */
-GLfloat LightDiffuse[] = { 0.6, 0.6, 0.6, 1.0 };  /* bluish  diffuse light. */
-GLfloat LightPosition[] = { 1.5, 1.5, 1.5, 0.0 };    /* position */
+GLfloat LightAmbient[] = { 0.1, 0.1, 0.1, 1.0 };	/* reddish ambient light  */
+GLfloat LightDiffuse[] = { 0.6, 0.6, 0.6, 1.0 };	/* bluish  diffuse light. */
+GLfloat LightPosition[] = { 1.5, 1.5, 1.5, 0.0 };	/* position */
 
 
 void
-gst_glxwindow_unhook_context(GstImageInfo *info)
+gst_glxwindow_unhook_context (GstImageInfo * info)
 {
   GstGLImageInfo *window = (GstGLImageInfo *) info;
 
-  if (window->ctx)
-    {
-      if (!glXMakeCurrent(window->dpy, None, NULL))
-        {
-	  printf("Could not release drawing context.\n");
-        }
-      else
-	  printf("Released drawing context.\n");
-    }
+  if (window->ctx) {
+    if (!glXMakeCurrent (window->dpy, None, NULL)) {
+      printf ("Could not release drawing context.\n");
+    } else
+      printf ("Released drawing context.\n");
+  }
 }
 
 void
-gst_glxwindow_hook_context(GstImageInfo *info)
+gst_glxwindow_hook_context (GstImageInfo * info)
 {
   GstGLImageInfo *window = (GstGLImageInfo *) info;
 
-  if (window->ctx && window->win && window->ctx)
-    {
-      if (!glXMakeCurrent(window->dpy, window->win, window->ctx))
-        {
-	  printf("Could not acquire GLX drawing context.\n");
-        }
-      else
-	  printf("Acquired drawing context.\n");
-    }
+  if (window->ctx && window->win && window->ctx) {
+    if (!glXMakeCurrent (window->dpy, window->win, window->ctx)) {
+      printf ("Could not acquire GLX drawing context.\n");
+    } else
+      printf ("Acquired drawing context.\n");
+  }
 }
 
 static void
-gst_glxwindow_free (GstImageInfo *info)
+gst_glxwindow_free (GstImageInfo * info)
 {
   GstGLImageInfo *window = (GstGLImageInfo *) info;
-  
+
   g_signal_handler_disconnect (window->sink, window->handler_id);
 
-  if (window->ctx)
-    {
-      if (!glXMakeCurrent(window->dpy, None, NULL))
-        {
-	  printf("Could not release drawing context.\n");
-        }
-      glXDestroyContext(window->dpy, window->ctx);
-      window->ctx = NULL;
-    }
-#if 0 
-    /* switch back to original desktop resolution if we were in fs */
-    if (GLWin.fs)
-    {
-        XF86VidModeSwitchToMode(GLWin.dpy, GLWin.screen, &GLWin.deskMode);
-        XF86VidModeSetViewPort(GLWin.dpy, GLWin.screen, 0, 0);
+  if (window->ctx) {
+    if (!glXMakeCurrent (window->dpy, None, NULL)) {
+      printf ("Could not release drawing context.\n");
     }
+    glXDestroyContext (window->dpy, window->ctx);
+    window->ctx = NULL;
+  }
+#if 0
+  /* switch back to original desktop resolution if we were in fs */
+  if (GLWin.fs) {
+    XF86VidModeSwitchToMode (GLWin.dpy, GLWin.screen, &GLWin.deskMode);
+    XF86VidModeSetViewPort (GLWin.dpy, GLWin.screen, 0, 0);
+  }
 #endif
   XCloseDisplay (window->dpy);
   g_free (window);
 }
 
 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); 
+  XWindowAttributes attr;
 
-  if (strncmp (pspec->name, "width", 5) == 0 || strncmp (pspec->name, "height", 6) == 0)
-  {
+  XGetWindowAttributes (data->dpy, data->win, &attr);
+
+  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);
       XMapRaised (data->dpy, data->win);
 
       // resize OpenGL
-      g_warning("resizing in OpenGL");
-      glViewport(0, 0, (GLint) w, (GLint) h);
-      glMatrixMode(GL_PROJECTION);
-      glLoadIdentity();
-      
+      g_warning ("resizing in OpenGL");
+      glViewport (0, 0, (GLint) w, (GLint) h);
+      glMatrixMode (GL_PROJECTION);
+      glLoadIdentity ();
+
       GLfloat aspect = (GLfloat) h / (GLfloat) w;
-      glFrustum(-1.0, 1.0, -aspect, aspect, 5.0, 500.0);
+
+      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;
   }
@@ -146,57 +137,54 @@ gst_glxwindow_callback(GObject *object, GParamSpec *pspec, GstGLImageInfo *data)
 }
 
 void
-gst_glxwindow_new (GstElement *sink)
+gst_glxwindow_new (GstElement * sink)
 {
   //XGCValues values;
   GstGLImageInfo *new;
   int glxMajorVersion, glxMinorVersion;
+
   //XSetWindowAttributes attrib;
   XVisualInfo *vi;
   Atom wmDelete;
   Window winDummy;
   unsigned int borderDummy;
   Colormap cmap;
-  char* title = "GLSink (experimental)";
+  char *title = "GLSink (experimental)";
 
   new = g_new0 (GstGLImageInfo, 1);
 
-  if (sink == NULL)
-  {
+  if (sink == NULL) {
     sink = gst_element_factory_make ("glsink", "glsink");
     g_assert (sink != NULL);
   }
-  
+
   /* fill in the ImageInfo */
   new->info.id = GST_MAKE_FOURCC ('X', 'l', 'i', 'b');
   new->info.free_info = gst_glxwindow_free;
-  
+
   new->dpy = XOpenDisplay (NULL);
   if (!new->dpy) {
     g_warning ("open display failed!\n");
     g_free (new);
     return;
   }
-  new->screen = DefaultScreen(new->dpy);
+  new->screen = DefaultScreen (new->dpy);
   /* get an appropriate visual */
-  vi = glXChooseVisual(new->dpy, new->screen, attrListDbl);
-  if (vi == NULL)
-    {
-      vi = glXChooseVisual(new->dpy, new->screen, attrListSgl);
-      GST_DEBUG("Only Singlebuffered Visual!\n");
-    }
-  else
-    {
-      GST_DEBUG("Got Doublebuffered Visual!\n");
-    }
-  glXQueryVersion(new->dpy, &glxMajorVersion, &glxMinorVersion);
-  GST_DEBUG("glX-Version %d.%d\n", glxMajorVersion, glxMinorVersion);
-  
+  vi = glXChooseVisual (new->dpy, new->screen, attrListDbl);
+  if (vi == NULL) {
+    vi = glXChooseVisual (new->dpy, new->screen, attrListSgl);
+    GST_DEBUG ("Only Singlebuffered Visual!\n");
+  } else {
+    GST_DEBUG ("Got Doublebuffered Visual!\n");
+  }
+  glXQueryVersion (new->dpy, &glxMajorVersion, &glxMinorVersion);
+  GST_DEBUG ("glX-Version %d.%d\n", glxMajorVersion, glxMinorVersion);
+
   /* create a GLX context */
-  new->ctx = glXCreateContext(new->dpy, vi, 0, GL_TRUE);
+  new->ctx = glXCreateContext (new->dpy, vi, 0, GL_TRUE);
   /* create a color map */
-  cmap = XCreateColormap(new->dpy, RootWindow(new->dpy, vi->screen),
-			 vi->visual, AllocNone);
+  cmap = XCreateColormap (new->dpy, RootWindow (new->dpy, vi->screen),
+      vi->visual, AllocNone);
   new->attr.colormap = cmap;
   new->attr.border_pixel = 0;
 
@@ -206,72 +194,72 @@ gst_glxwindow_new (GstElement *sink)
   new->width = 10;
   new->height = 10;
 
-  new->rotX = 0; 
-  new->rotY = 0; 
+  new->rotX = 0;
+  new->rotY = 0;
   new->zoom = 1;
   new->zoomdir = 0.01;
 
   {
-        /* create a window in window mode*/
+    /* create a window in window mode */
     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,
-			      CWBorderPixel | CWColormap | CWEventMask, &new->attr);
-    if (!new->win) 
-      {
-	g_warning ("create window failed\n");
-	g_free (new);
-	return;
-      }
+	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, CWBorderPixel | CWColormap | CWEventMask, &new->attr);
+    if (!new->win) {
+      g_warning ("create window failed\n");
+      g_free (new);
+      return;
+    }
     /* only set window title and handle wm_delete_events if in windowed mode */
-    wmDelete = XInternAtom(new->dpy, "WM_DELETE_WINDOW", True);
-    XSetWMProtocols(new->dpy, new->win, &wmDelete, 1);
-    XSetStandardProperties(new->dpy, new->win, title,
-			   title, None, NULL, 0, NULL);
-    XMapRaised(new->dpy, new->win);
-  }       
+    wmDelete = XInternAtom (new->dpy, "WM_DELETE_WINDOW", True);
+    XSetWMProtocols (new->dpy, new->win, &wmDelete, 1);
+    XSetStandardProperties (new->dpy, new->win, title,
+	title, None, NULL, 0, NULL);
+    XMapRaised (new->dpy, new->win);
+  }
   /* connect the glx-context to the window */
-  glXMakeCurrent(new->dpy, new->win, new->ctx);
-  XGetGeometry(new->dpy, new->win, &winDummy, &new->x, &new->y,
-	       &new->width, &new->height, &borderDummy, &new->depth);
-  printf("Depth %d\n", new->depth);
-  if (glXIsDirect(new->dpy, new->ctx)) 
-      GST_DEBUG ("Congrats, you have Direct Rendering!\n");
+  glXMakeCurrent (new->dpy, new->win, new->ctx);
+  XGetGeometry (new->dpy, new->win, &winDummy, &new->x, &new->y,
+      &new->width, &new->height, &borderDummy, &new->depth);
+  printf ("Depth %d\n", new->depth);
+  if (glXIsDirect (new->dpy, new->ctx))
+    GST_DEBUG ("Congrats, you have Direct Rendering!\n");
   else
     GST_DEBUG ("Sorry, no Direct Rendering possible!\n");
 
-  g_warning("Initializing OpenGL parameters\n");
+  g_warning ("Initializing OpenGL parameters\n");
   /* initialize OpenGL drawing */
-  glEnable(GL_DEPTH_TEST);
+  glEnable (GL_DEPTH_TEST);
   //glShadeModel(GL_SMOOTH);
 
-  glEnable(GL_TEXTURE_2D);
-  glDisable(GL_CULL_FACE);
-  glClearDepth(1.0f);
-  glClearColor(0, 0, 0, 0);
+  glEnable (GL_TEXTURE_2D);
+  glDisable (GL_CULL_FACE);
+  glClearDepth (1.0f);
+  glClearColor (0, 0, 0, 0);
+
+  glLightfv (GL_LIGHT0, GL_AMBIENT, LightAmbient);	/*  add lighting. (ambient) */
+  glLightfv (GL_LIGHT0, GL_DIFFUSE, LightDiffuse);	/*  add lighting. (diffuse). */
+  glLightfv (GL_LIGHT0, GL_POSITION, LightPosition);	/*  set light position. */
 
-  glLightfv(GL_LIGHT0, GL_AMBIENT, LightAmbient);  /*  add lighting. (ambient) */
-  glLightfv(GL_LIGHT0, GL_DIFFUSE, LightDiffuse);  /*  add lighting. (diffuse). */
-  glLightfv(GL_LIGHT0, GL_POSITION,LightPosition); /*  set light position. */ 
- 
-  //glEnable(GL_LIGHT0);					// Quick And Dirty Lighting (Assumes Light0 Is Set Up)
-  //glEnable(GL_LIGHTING);					// Enable Lighting
-  glDisable(GL_COLOR_MATERIAL);				// Enable Material Coloring
-  glEnable(GL_AUTO_NORMAL); // let OpenGL generate the Normals
+  //glEnable(GL_LIGHT0);                                        // Quick And Dirty Lighting (Assumes Light0 Is Set Up)
+  //glEnable(GL_LIGHTING);                                      // Enable Lighting
+  glDisable (GL_COLOR_MATERIAL);	// Enable Material Coloring
+  glEnable (GL_AUTO_NORMAL);	// let OpenGL generate the Normals
 
-  glDisable(GL_BLEND);
+  glDisable (GL_BLEND);
 
-  glPolygonMode(GL_FRONT, GL_FILL);
-  glPolygonMode(GL_BACK, GL_FILL);
+  glPolygonMode (GL_FRONT, GL_FILL);
+  glPolygonMode (GL_BACK, GL_FILL);
 
-  glShadeModel(GL_SMOOTH);
-  glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_NICEST);
+  glShadeModel (GL_SMOOTH);
+  glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
 
   XSelectInput (new->dpy, new->win, ExposureMask | StructureNotifyMask);
 
   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);
 }
-
diff --git a/sys/glsink/regcomb_yuvrgb.c b/sys/glsink/regcomb_yuvrgb.c
index d06427f4..54727d1e 100644
--- a/sys/glsink/regcomb_yuvrgb.c
+++ b/sys/glsink/regcomb_yuvrgb.c
@@ -23,313 +23,378 @@ unsigned char *UPlane;
 unsigned char *VPlane;
 
 // YUV 4:2:2 example
-unsigned int Ywidth=512,  Yheight=512;
-unsigned int UVwidth=256, UVheight=512;
+unsigned int Ywidth = 512, Yheight = 512;
+unsigned int UVwidth = 256, UVheight = 512;
 
 int tex_xsize, tex_ysize;
 
-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)
-		       float *Uscale, // scaling color for U
-		       float *Vscale) // scaling color for V
+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)
+    float *Uscale,		// scaling color for U
+    float *Vscale)		// scaling color for V
 {
-	int i;
-	const float mat[9]= { // the modified YUV->RGB matrix
-		+1.130469478f,-0.058755723f,+1.596026304f,
-		+1.130469478f,-0.450515935f,-0.812967512f,
-		+1.130469478f,+1.958477882f, 0.0f
-	};
-	#define COMPRESS(a)(0.5f*(a)+128.0f) // counter-piece to EXPAND_NORMAL
-	#define fCOMPRESS(a) (0.5f*(a)+0.5f);
-	#define XCLAMP(a) ((a)<0.0f ? 0.0f : ((a)>255.0f ? 255.0f : (a))) // should not be necessary, but what do you know.
-	bias[0]=fCOMPRESS(-0.842580964f);
-	bias[1]=fCOMPRESS(+0.563287723f);
-	bias[2]=fCOMPRESS(-1.0f);
-	bias[3]=0.0f;
-	Uscale[0]=8.0f/255.0f;
-	Uscale[1]=60.0f/255.0f;
-	Uscale[2]=250.0f/255.0f;
-	Uscale[3]=0.0f;
-	Vscale[0]=204.0f/255.0f;
-	Vscale[1]=105.0f/255.0f;
-	Vscale[2]=0.5f;
-	Vscale[3]=0.0f;
-	for (i=0; i<256; i++) {
-		// Y-table holds unsigned values
-		Ytable[3*i  ]=(unsigned char)XCLAMP(mat[0]*(float)i); // R
-		Ytable[3*i+1]=(unsigned char)XCLAMP(mat[3]*(float)i); // G
-		Ytable[3*i+2]=(unsigned char)XCLAMP(mat[6]*(float)i); // B
-		// U-table holds signed values
-		Utable[3*i  ]=(unsigned char)XCLAMP(COMPRESS(255.0f/ 16.0f*mat[1]*(float)i)); // R
-		Utable[3*i+1]=(unsigned char)XCLAMP(COMPRESS(255.0f/120.0f*mat[4]*(float)i)); // G
-		Utable[3*i+2]=(unsigned char)XCLAMP(COMPRESS(255.0f/500.0f*mat[7]*(float)i)); // B
-		// V-table holds signed values
-		Vtable[3*i  ]=(unsigned char)XCLAMP(COMPRESS(255.0f/408.0f*mat[2]*(float)i)); // R
-		Vtable[3*i+1]=(unsigned char)XCLAMP(COMPRESS(255.0f/210.0f*mat[5]*(float)i)); // G
-		Vtable[3*i+2]=(unsigned char)(128.0f-14.0f); // G constant
-	}
-	#undef fCOMPRESS
-	#undef COMPRESS
-	#undef XCLAMP
+  int i;
+  const float mat[9] = {	// the modified YUV->RGB matrix
+    +1.130469478f, -0.058755723f, +1.596026304f,
+    +1.130469478f, -0.450515935f, -0.812967512f,
+    +1.130469478f, +1.958477882f, 0.0f
+  };
+#define COMPRESS(a)(0.5f*(a)+128.0f)	// counter-piece to EXPAND_NORMAL
+#define fCOMPRESS(a) (0.5f*(a)+0.5f);
+#define XCLAMP(a) ((a)<0.0f ? 0.0f : ((a)>255.0f ? 255.0f : (a)))	// should not be necessary, but what do you know.
+  bias[0] = fCOMPRESS (-0.842580964f);
+  bias[1] = fCOMPRESS (+0.563287723f);
+  bias[2] = fCOMPRESS (-1.0f);
+  bias[3] = 0.0f;
+  Uscale[0] = 8.0f / 255.0f;
+  Uscale[1] = 60.0f / 255.0f;
+  Uscale[2] = 250.0f / 255.0f;
+  Uscale[3] = 0.0f;
+  Vscale[0] = 204.0f / 255.0f;
+  Vscale[1] = 105.0f / 255.0f;
+  Vscale[2] = 0.5f;
+  Vscale[3] = 0.0f;
+  for (i = 0; i < 256; i++) {
+    // Y-table holds unsigned values
+    Ytable[3 * i] = (unsigned char) XCLAMP (mat[0] * (float) i);	// R
+    Ytable[3 * i + 1] = (unsigned char) XCLAMP (mat[3] * (float) i);	// G
+    Ytable[3 * i + 2] = (unsigned char) XCLAMP (mat[6] * (float) i);	// B
+    // U-table holds signed values
+    Utable[3 * i] = (unsigned char) XCLAMP (COMPRESS (255.0f / 16.0f * mat[1] * (float) i));	// R
+    Utable[3 * i + 1] = (unsigned char) XCLAMP (COMPRESS (255.0f / 120.0f * mat[4] * (float) i));	// G
+    Utable[3 * i + 2] = (unsigned char) XCLAMP (COMPRESS (255.0f / 500.0f * mat[7] * (float) i));	// B
+    // V-table holds signed values
+    Vtable[3 * i] = (unsigned char) XCLAMP (COMPRESS (255.0f / 408.0f * mat[2] * (float) i));	// R
+    Vtable[3 * i + 1] = (unsigned char) XCLAMP (COMPRESS (255.0f / 210.0f * mat[5] * (float) i));	// G
+    Vtable[3 * i + 2] = (unsigned char) (128.0f - 14.0f);	// G constant
+  }
+#undef fCOMPRESS
+#undef COMPRESS
+#undef XCLAMP
 }
 
 
 // Sets the constants. Call once prior to rendering.
-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]);
-	glCombinerParameterfvNV(GL_CONSTANT_COLOR0_NV,Uscale);
-	glCombinerParameterfvNV(GL_CONSTANT_COLOR1_NV,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]);
+  glCombinerParameterfvNV (GL_CONSTANT_COLOR0_NV, Uscale);
+  glCombinerParameterfvNV (GL_CONSTANT_COLOR1_NV, Vscale);
 }
 
 /*
  * SOFTWARE PATH
- */ 
+ */
 
-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_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) {
-	v[0]=1.0f-v[0];
-	v[1]=1.0f-v[1];
-	v[2]=1.0f-v[2];
+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) {
-	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_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) {
-	v[0]*=2.0f;
-	v[1]*=2.0f;
-	v[2]*=2.0f;
+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) {
-	v[0]*=0.5f;
-	v[1]*=0.5f;
-	v[2]*=0.5f;
+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) {
-	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_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) {
-	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]));
+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,
-					   unsigned char *tex0,
-					   unsigned char *tex1,
-					   unsigned char *tex2,
-					   float *COLOR0,
-					   float *CONST0,
-					   float *CONST1
-						) 
+void
+PerformSWCombiner (unsigned char *Result,
+    unsigned char *tex0,
+    unsigned char *tex1,
+    unsigned char *tex2, float *COLOR0, float *CONST0, float *CONST1)
 {
-	float SPARE0[3];
-	float SPARE1[3];
-	float A[3],B[3],C[3],D[3];
-	float TEX0[3],TEX1[3],TEX2[3];
-	float ZERO[3]={0.0f,0.0f,0.0f};
-	
-	TEX0[0]=(float)tex0[0]/255.0f;
-	TEX0[1]=(float)tex0[1]/255.0f;
-	TEX0[2]=(float)tex0[2]/255.0f;
-
-	TEX1[0]=(float)tex1[0]/255.0f;
-	TEX1[1]=(float)tex1[1]/255.0f;
-	TEX1[2]=(float)tex1[2]/255.0f;
-
-	TEX2[0]=(float)tex2[0]/255.0f;
-	TEX2[1]=(float)tex2[1]/255.0f;
-	TEX2[2]=(float)tex2[2]/255.0f;
-
-	// Combiner Stage 0:
-	memcpy(A,TEX0,3*sizeof(float));		map_UNSIGNED_IDENTITY(A);
-	memcpy(B,ZERO,3*sizeof(float));		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];
-	omap_SCALE_BY_ONE_HALF(SPARE0);
-	omap_RANGE(SPARE0);
-
-	// Combiner Stage 1:
-	memcpy(A,TEX1,3*sizeof(float));		map_EXPAND_NORMAL(A);
-	memcpy(B,CONST0,3*sizeof(float));	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(B,ZERO,3*sizeof(float));		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];
-	omap_SCALE_BY_TWO(SPARE0);
-	omap_RANGE(SPARE0);
-
-	// Final Combiner Stage:
-	memcpy(A,ZERO,3*sizeof(float));		map_UNSIGNED_INVERT(A);
-	memcpy(B,SPARE0,3*sizeof(float));	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];
-	omap_CLAMP_01(SPARE0);
-	Result[0]=(unsigned char)(SPARE0[0]*255.0f);
-	Result[1]=(unsigned char)(SPARE0[1]*255.0f);
-	Result[2]=(unsigned char)(SPARE0[2]*255.0f);
+  float SPARE0[3];
+  float SPARE1[3];
+  float A[3], B[3], C[3], D[3];
+  float TEX0[3], TEX1[3], TEX2[3];
+  float ZERO[3] = { 0.0f, 0.0f, 0.0f };
+
+  TEX0[0] = (float) tex0[0] / 255.0f;
+  TEX0[1] = (float) tex0[1] / 255.0f;
+  TEX0[2] = (float) tex0[2] / 255.0f;
+
+  TEX1[0] = (float) tex1[0] / 255.0f;
+  TEX1[1] = (float) tex1[1] / 255.0f;
+  TEX1[2] = (float) tex1[2] / 255.0f;
+
+  TEX2[0] = (float) tex2[0] / 255.0f;
+  TEX2[1] = (float) tex2[1] / 255.0f;
+  TEX2[2] = (float) tex2[2] / 255.0f;
+
+  // Combiner Stage 0:
+  memcpy (A, TEX0, 3 * sizeof (float));
+  map_UNSIGNED_IDENTITY (A);
+  memcpy (B, ZERO, 3 * sizeof (float));
+  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];
+  omap_SCALE_BY_ONE_HALF (SPARE0);
+  omap_RANGE (SPARE0);
+
+  // Combiner Stage 1:
+  memcpy (A, TEX1, 3 * sizeof (float));
+  map_EXPAND_NORMAL (A);
+  memcpy (B, CONST0, 3 * sizeof (float));
+  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 (B, ZERO, 3 * sizeof (float));
+  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];
+  omap_SCALE_BY_TWO (SPARE0);
+  omap_RANGE (SPARE0);
+
+  // Final Combiner Stage:
+  memcpy (A, ZERO, 3 * sizeof (float));
+  map_UNSIGNED_INVERT (A);
+  memcpy (B, SPARE0, 3 * sizeof (float));
+  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];
+  omap_CLAMP_01 (SPARE0);
+  Result[0] = (unsigned char) (SPARE0[0] * 255.0f);
+  Result[1] = (unsigned char) (SPARE0[1] * 255.0f);
+  Result[2] = (unsigned char) (SPARE0[2] * 255.0f);
 }
 
 // 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_B_NV,GL_ZERO,            GL_UNSIGNED_INVERT_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_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_B_NV,GL_CONSTANT_COLOR0_NV,GL_UNSIGNED_IDENTITY_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_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_B_NV,GL_ZERO,            GL_UNSIGNED_INVERT_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_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_B_NV,GL_SPARE0_NV,GL_UNSIGNED_IDENTITY_NV,GL_RGB);
-	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);
+  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_B_NV, GL_ZERO,
+      GL_UNSIGNED_INVERT_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_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_B_NV,
+      GL_CONSTANT_COLOR0_NV, GL_UNSIGNED_IDENTITY_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_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_B_NV, GL_ZERO,
+      GL_UNSIGNED_INVERT_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_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_B_NV, GL_SPARE0_NV,
+      GL_UNSIGNED_IDENTITY_NV, GL_RGB);
+  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 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;
-	else return (1<<shifts);
+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;
+  else
+    return (1 << shifts);
 }
 
 
 // Initializes textures. Call once prior to rendering
-void 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 char* Ypal, unsigned char *Upal, unsigned char *Vpal)
+void
+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 char *Ypal, unsigned char *Upal, unsigned char *Vpal)
 {
-  glGenTextures(1,Yhandle);
-  glGenTextures(1,Uhandle);
-  glGenTextures(1,Vhandle);
-  glBindTexture(GL_TEXTURE_2D,(*Yhandle));
+  glGenTextures (1, Yhandle);
+  glGenTextures (1, Uhandle);
+  glGenTextures (1, Vhandle);
+  glBindTexture (GL_TEXTURE_2D, (*Yhandle));
 #ifdef _WIN32
-  glColorTableEXT(GL_TEXTURE_2D,GL_RGB8,256,GL_RGB,GL_UNSIGNED_BYTE,Ypal);
+  glColorTableEXT (GL_TEXTURE_2D, GL_RGB8, 256, GL_RGB, GL_UNSIGNED_BYTE, Ypal);
 #else // Hopefully Linux
-  glColorTable(GL_TEXTURE_2D,GL_RGB8,256,GL_RGB,GL_UNSIGNED_BYTE,Ypal);
+  glColorTable (GL_TEXTURE_2D, GL_RGB8, 256, GL_RGB, GL_UNSIGNED_BYTE, Ypal);
 #endif
-  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,filter);
-  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);	
-  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);
-  
-  glBindTexture(GL_TEXTURE_2D,(*Uhandle));
+  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter);
+  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);
+  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);
+
+  glBindTexture (GL_TEXTURE_2D, (*Uhandle));
 #ifdef _WIN32
-  glColorTableEXT(GL_TEXTURE_2D,GL_RGB8,256,GL_RGB,GL_UNSIGNED_BYTE,Upal);
+  glColorTableEXT (GL_TEXTURE_2D, GL_RGB8, 256, GL_RGB, GL_UNSIGNED_BYTE, Upal);
 #else // Hopefully Linux
-  glColorTable(GL_TEXTURE_2D,GL_RGB8,256,GL_RGB,GL_UNSIGNED_BYTE,Upal);
+  glColorTable (GL_TEXTURE_2D, GL_RGB8, 256, GL_RGB, GL_UNSIGNED_BYTE, Upal);
 #endif
-  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,filter);
-  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);
-  
-  glBindTexture(GL_TEXTURE_2D,(*Vhandle));
+  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter);
+  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);
+
+  glBindTexture (GL_TEXTURE_2D, (*Vhandle));
 #ifdef _WIN32
-  glColorTableEXT(GL_TEXTURE_2D,GL_RGB8,256,GL_RGB,GL_UNSIGNED_BYTE,Vpal);
+  glColorTableEXT (GL_TEXTURE_2D, GL_RGB8, 256, GL_RGB, GL_UNSIGNED_BYTE, Vpal);
 #else // Hopefully Linux
-  glColorTable(GL_TEXTURE_2D,GL_RGB8,256,GL_RGB,GL_UNSIGNED_BYTE,Vpal);
+  glColorTable (GL_TEXTURE_2D, GL_RGB8, 256, GL_RGB, GL_UNSIGNED_BYTE, Vpal);
 #endif
-  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,filter);
-  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);
+  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter);
+  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);
 }
 
-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 *Udata,
-		   unsigned char *Vdata) 
+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 *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);
-  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);
-  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);
-  glEnable(GL_TEXTURE_2D);
+  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);
+  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);
+  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);
+  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,16 +404,20 @@ 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);
-  SetupCombiners();
-  SetConsts(bias,Uscale,Vscale);
+
+  GenerateRGBTables (Ypal, Upal, Vpal, bias, Uscale, Vscale);
+  InitYUVPlanes (&Yhandle, &Uhandle, &Vhandle, Ywidth, Yheight, UVwidth,
+      UVheight, filter, Ypal, Upal, Vpal);
+  SetupCombiners ();
+  SetConsts (bias, Uscale, Vscale);
 }
 
 
-void initialize(GLenum filter) {
-	glShadeModel(GL_SMOOTH);
-	glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_NICEST);
-	glClearColor(0.0f,0.0f,0.2f,1.0f);
-	Initialize_Backend(Ywidth,Yheight,UVwidth,UVheight,filter);
+void
+initialize (GLenum filter)
+{
+  glShadeModel (GL_SMOOTH);
+  glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
+  glClearColor (0.0f, 0.0f, 0.2f, 1.0f);
+  Initialize_Backend (Ywidth, Yheight, UVwidth, UVheight, filter);
 }