summaryrefslogtreecommitdiffstats
path: root/sys
diff options
context:
space:
mode:
authorGernot Ziegler <gz@lysator.liu.se>2003-10-28 18:54:20 +0000
committerGernot Ziegler <gz@lysator.liu.se>2003-10-28 18:54:20 +0000
commit8d8a2b7939502b86a22e0ec00eecbc2298dcfac0 (patch)
tree5adc5672ce819f149c3635fd727179c8e723df42 /sys
parent61a739d5fed74d9ab041ee6aafc83f2075585db3 (diff)
downloadgst-plugins-bad-8d8a2b7939502b86a22e0ec00eecbc2298dcfac0.tar.gz
gst-plugins-bad-8d8a2b7939502b86a22e0ec00eecbc2298dcfac0.tar.bz2
gst-plugins-bad-8d8a2b7939502b86a22e0ec00eecbc2298dcfac0.zip
welcome to glsink for 0.7.x :)
Original commit message from CVS: welcome to glsink for 0.7.x :)
Diffstat (limited to 'sys')
-rw-r--r--sys/glsink/ARB_multitexture.h309
-rw-r--r--sys/glsink/EXT_paletted_texture.h142
-rw-r--r--sys/glsink/Makefile.am10
-rw-r--r--sys/glsink/NV_register_combiners.h218
-rw-r--r--sys/glsink/gstgl_nvimage.c404
-rw-r--r--sys/glsink/gstgl_pdrimage.c396
-rw-r--r--sys/glsink/gstgl_rgbimage.c388
-rw-r--r--sys/glsink/gstglsink.c723
-rw-r--r--sys/glsink/gstglsink.h96
-rw-r--r--sys/glsink/gstglxwindow.c241
-rw-r--r--sys/glsink/regcomb_yuvrgb.c349
11 files changed, 3276 insertions, 0 deletions
diff --git a/sys/glsink/ARB_multitexture.h b/sys/glsink/ARB_multitexture.h
new file mode 100644
index 00000000..af6de323
--- /dev/null
+++ b/sys/glsink/ARB_multitexture.h
@@ -0,0 +1,309 @@
+/*************************************************************
+ * *
+ * file : ARB_multitexture.h *
+ * author: Jens Schneider *
+ * date : 01.Mar.2001-10.Jul.2001 *
+ * e-mail: jens@glHint.de *
+ * *
+ * 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
+#ifndef _WIN32
+#define GL_GLEXT_PROTOTYPES 1
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__)
+#define WIN32_LEAN_AND_MEAN 1
+#include <windows.h>
+#endif
+
+#ifndef APIENTRY
+#define APIENTRY
+#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
+#define GL_TEXTURE2_ARB 0x84C2
+#define GL_TEXTURE3_ARB 0x84C3
+#define GL_TEXTURE4_ARB 0x84C4
+#define GL_TEXTURE5_ARB 0x84C5
+#define GL_TEXTURE6_ARB 0x84C6
+#define GL_TEXTURE7_ARB 0x84C7
+#define GL_TEXTURE8_ARB 0x84C8
+#define GL_TEXTURE9_ARB 0x84C9
+#define GL_TEXTURE10_ARB 0x84CA
+#define GL_TEXTURE11_ARB 0x84CB
+#define GL_TEXTURE12_ARB 0x84CC
+#define GL_TEXTURE13_ARB 0x84CD
+#define GL_TEXTURE14_ARB 0x84CE
+#define GL_TEXTURE15_ARB 0x84CF
+#define GL_TEXTURE16_ARB 0x84D0
+#define GL_TEXTURE17_ARB 0x84D1
+#define GL_TEXTURE18_ARB 0x84D2
+#define GL_TEXTURE19_ARB 0x84D3
+#define GL_TEXTURE20_ARB 0x84D4
+#define GL_TEXTURE21_ARB 0x84D5
+#define GL_TEXTURE22_ARB 0x84D6
+#define GL_TEXTURE23_ARB 0x84D7
+#define GL_TEXTURE24_ARB 0x84D8
+#define GL_TEXTURE25_ARB 0x84D9
+#define GL_TEXTURE26_ARB 0x84DA
+#define GL_TEXTURE27_ARB 0x84DB
+#define GL_TEXTURE28_ARB 0x84DC
+#define GL_TEXTURE29_ARB 0x84DD
+#define GL_TEXTURE30_ARB 0x84DE
+#define GL_TEXTURE31_ARB 0x84DF
+#define GL_ACTIVE_TEXTURE_ARB 0x84E0
+#define GL_CLIENT_ACTIVE_TEXTURE_ARB 0x84E1
+#define GL_MAX_TEXTURE_UNITS_ARB 0x84E2
+#define GL_ARB_multitexture 1
+#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
+
+#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];
+ 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]==' ') {
+ //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; }
+#endif // _WIN32
+ return 1;
+}
+
+#endif // ARB_MULTITEXTURE_INITIALIZE
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // not __ARB_MULTITEXTURE_H_
diff --git a/sys/glsink/EXT_paletted_texture.h b/sys/glsink/EXT_paletted_texture.h
new file mode 100644
index 00000000..37e9a9bf
--- /dev/null
+++ b/sys/glsink/EXT_paletted_texture.h
@@ -0,0 +1,142 @@
+/*************************************************************
+ * *
+ * file : EXT_paletted_texture.h *
+ * author: Jens Schneider *
+ * date : 14.Mar.2001-10.Jul.2001 *
+ * e-mail: jens@glHint.de *
+ * *
+ * 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
+#ifndef _WIN32
+#define GL_GLEXT_PROTOTYPES 1
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__)
+#define WIN32_LEAN_AND_MEAN 1
+#include <windows.h>
+#endif
+
+#ifndef APIENTRY
+#define APIENTRY
+#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
+#define GL_COLOR_INDEX4_EXT 0x80E4
+#define GL_COLOR_INDEX8_EXT 0x80E5
+#define GL_COLOR_INDEX12_EXT 0x80E6
+#define GL_COLOR_INDEX16_EXT 0x80E7
+#define GL_COLOR_TABLE_FORMAT_EXT 0x80D8
+#define GL_COLOR_TABLE_WIDTH_EXT 0x80D9
+#define GL_COLOR_TABLE_RED_SIZE_EXT 0x80DA
+#define GL_COLOR_TABLE_GREEN_SIZE_EXT 0x80DB
+#define GL_COLOR_TABLE_BLUE_SIZE_EXT 0x80DC
+#define GL_COLOR_TABLE_ALPHA_SIZE_EXT 0x80DD
+#define GL_COLOR_TABLE_LUMINANCE_SIZE_EXT 0x80DE
+#define GL_COLOR_TABLE_INTENSITY_SIZE_EXT 0x80DF
+#define GL_TEXTURE_INDEX_SIZE_EXT 0x80ED
+#define GL_EXT_paletted_texture 1
+#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
+
+#ifdef EXT_PALETTED_TEXTURE_INITIALIZE
+#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;
+
+#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;}
+#endif // _WIN32
+ return 1;
+}
+
+#endif // EXT_PALETTED_TEXTURE_INITIALIZE
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // not __EXT_PALETTED_TEXTURE_H_
diff --git a/sys/glsink/Makefile.am b/sys/glsink/Makefile.am
new file mode 100644
index 00000000..8c7838c8
--- /dev/null
+++ b/sys/glsink/Makefile.am
@@ -0,0 +1,10 @@
+plugindir = $(libdir)/gstreamer-@GST_MAJORMINOR@
+
+plugin_LTLIBRARIES = libgstglsink.la
+
+libgstglsink_la_SOURCES = gstglsink.c gstglxwindow.c gstgl_rgbimage.c gstgl_nvimage.c
+libgstglsink_la_CFLAGS = $(GST_CFLAGS)
+libgstglsink_la_LIBADD = $(X_LIBS) $(XVIDEO_LIBS) -lGL -lGLU -lglut
+libgstglsink_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)
+
+noinst_HEADERS = gstglsink.h
diff --git a/sys/glsink/NV_register_combiners.h b/sys/glsink/NV_register_combiners.h
new file mode 100644
index 00000000..52b74c39
--- /dev/null
+++ b/sys/glsink/NV_register_combiners.h
@@ -0,0 +1,218 @@
+/*************************************************************
+ * *
+ * file : NV_register_combiners.h *
+ * author: Jens Schneider *
+ * date : 12.Mar.2001-04.Jul.2001 *
+ * e-mail: jens@glHint.de *
+ * *
+ * 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
+#ifndef _WIN32
+#define GL_GLEXT_PROTOTYPES 1
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__)
+#define WIN32_LEAN_AND_MEAN 1
+#include <windows.h>
+#endif
+
+#ifndef APIENTRY
+#define APIENTRY
+#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
+#define GL_COMBINER1_NV 0x8551
+#define GL_COMBINER2_NV 0x8552
+#define GL_COMBINER3_NV 0x8553
+#define GL_COMBINER4_NV 0x8554
+#define GL_COMBINER5_NV 0x8555
+#define GL_COMBINER6_NV 0x8556
+#define GL_COMBINER7_NV 0x8557
+#define GL_VARIABLE_A_NV 0x8523
+#define GL_VARIABLE_B_NV 0x8524
+#define GL_VARIABLE_C_NV 0x8525
+#define GL_VARIABLE_D_NV 0x8526
+#define GL_VARIABLE_E_NV 0x8527
+#define GL_VARIABLE_F_NV 0x8528
+#define GL_VARIABLE_G_NV 0x8529
+#define GL_CONSTANT_COLOR0_NV 0x852A
+#define GL_CONSTANT_COLOR1_NV 0x852B
+#define GL_PRIMARY_COLOR_NV 0x852C
+#define GL_SECONDARY_COLOR_NV 0x852D
+#define GL_SPARE0_NV 0x852E
+#define GL_SPARE1_NV 0x852F
+#define GL_UNSIGNED_IDENTITY_NV 0x8536
+#define GL_UNSIGNED_INVERT_NV 0x8537
+#define GL_EXPAND_NORMAL_NV 0x8538
+#define GL_EXPAND_NEGATE_NV 0x8539
+#define GL_HALF_BIAS_NORMAL_NV 0x853A
+#define GL_HALF_BIAS_NEGATE_NV 0x853B
+#define GL_SIGNED_IDENTITY_NV 0x853C
+#define GL_SIGNED_NEGATE_NV 0x853D
+#define GL_E_TIMES_F_NV 0x8531
+#define GL_SPARE0_PLUS_SECONDARY_COLOR_NV 0x8532
+#define GL_SCALE_BY_TWO_NV 0x853E
+#define GL_SCALE_BY_FOUR_NV 0x853F
+#define GL_SCALE_BY_ONE_HALF_NV 0x8540
+#define GL_BIAS_BY_NEGATIVE_ONE_HALF_NV 0x8541
+#define GL_DISCARD_NV 0x8530
+#define GL_COMBINER_INPUT_NV 0x8542
+#define GL_COMBINER_MAPPING_NV 0x8543
+#define GL_COMBINER_COMPONENT_USAGE_NV 0x8544
+#define GL_COMBINER_AB_DOT_PRODUCT_NV 0x8545
+#define GL_COMBINER_CD_DOT_PRODUCT_NV 0x8546
+#define GL_COMBINER_MUX_SUM_NV 0x8547
+#define GL_COMBINER_SCALE_NV 0x8548
+#define GL_COMBINER_BIAS_NV 0x8549
+#define GL_COMBINER_AB_OUTPUT_NV 0x854A
+#define GL_COMBINER_CD_OUTPUT_NV 0x854B
+#define GL_COMBINER_SUM_OUTPUT_NV 0x854C
+#define GL_NUM_GENERAL_COMBINERS_NV 0x854E
+#define GL_COLOR_SUM_CLAMP_NV 0x854F
+#define GL_MAX_GENERAL_COMBINERS_NV 0x854D
+#define GL_NV_register_combiners 1
+#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
+
+#ifdef NV_REGISTER_COMBINERS_INITIALIZE
+#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;
+
+#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;}
+#endif // _WIN32
+ return 1;
+}
+
+#endif // NV_REGISTER_COMBINERS_INITIALIZE
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // not __NV_REGISTER_COMBINERS_H_
diff --git a/sys/glsink/gstgl_nvimage.c b/sys/glsink/gstgl_nvimage.c
new file mode 100644
index 00000000..e7ee1b62
--- /dev/null
+++ b/sys/glsink/gstgl_nvimage.c
@@ -0,0 +1,404 @@
+#include "config.h"
+
+#include <gst/gst.h>
+/* gcc -ansi -pedantic on GNU/Linux causes warnings and errors
+ * unless this is defined:
+ * warning: #warning "Files using this header must be compiled with _SVID_SOURCE or _XOPEN_SOURCE"
+ */
+#ifndef _XOPEN_SOURCE
+# define _XOPEN_SOURCE 1
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <GL/glx.h>
+#include <GL/gl.h>
+//#include <GL/glext.h>
+#include <GL/glu.h>
+#include <string.h>
+#include <math.h>
+
+// too lazy to write an API for this ;)
+#include "regcomb_yuvrgb.c"
+
+#include "gstglsink.h"
+
+typedef struct _GstGLImageConnection GstGLImageConnection;
+struct _GstGLImageConnection {
+ GstImageConnection conn;
+ Display *dpy;
+ gint w, h;
+ gint bpp;
+
+ int ytex_id;
+ int uvtex_id;
+ int septex_id;
+ unsigned char *m_memory;
+ int m_bufslots[4];
+};
+
+#define TEX_XSIZE 1024
+#define TEX_YSIZE 1024
+#define YUVTEX_SIZE ((TEX_XSIZE * TEX_YSIZE) * 3 /2)
+
+#define AGP_BUFSLOTS 4
+
+typedef struct _GstNvImage GstNvImage;
+struct _GstNvImage
+{
+ GstImageData data;
+ 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 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};
+
+ return &plugin;
+}
+
+
+static GstGLImageInfo *
+gst_gl_nvimage_info (GstImageInfo *info)
+{
+ 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)
+{
+ if (conn == NULL || conn->free_conn != gst_gl_nvimage_free_conn)
+ return NULL;
+ return (GstGLImageConnection *) conn;
+}
+
+gboolean
+gst_gl_nvimage_check_xvideo ()
+{
+ //int ver, rel, req, ev, err;
+
+ 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 (display == NULL)
+ return FALSE;
+ if (Success == XvQueryExtension (display,&ver,&rel,&req,&ev,&err))
+ return TRUE;
+#endif
+
+ return TRUE;
+}
+
+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 !\n");
+ /* we don't handle these image information */
+ if (xinfo == NULL) return NULL;
+
+ 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/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)
+{
+ //gint i, j = 0;
+ //int adaptors;
+ //int formats;
+ GstGLImageConnection *conn;
+ GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
+ guint32 format;
+
+ /* we don't handle these image information */
+ 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);
+
+ // 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)
+ {
+ /* 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)
+{
+ GstNvImage *image;
+ 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;
+
+ // 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);
+
+ 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->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;
+ }
+
+ return (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;
+ 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));
+
+ /* checks omitted for speed (and lazyness), do we need them? */
+ g_assert (xinfo != NULL);
+
+ // both upload the video, and redraw the screen
+ glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
+
+ glMatrixMode(GL_MODELVIEW);
+ glLoadIdentity();
+ glTranslatef(0.0, 0.0, -25.0);
+ glEnable(GL_TEXTURE_2D);
+
+ if (xinfo->info.demo)
+ {
+
+ 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);
+
+ if (xinfo->zoom > 1.0)
+ xinfo->zoomdir = -0.01;
+
+ if (xinfo->zoom < 0.5)
+ 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);
+ }
+
+ 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);
+
+ float aspect = img_width/(float)img_height;
+ float hor = 4 * aspect;
+
+ glNormal3f(0, -1, 0);
+ glMultiTexCoord2fARB(GL_TEXTURE0_ARB,0,0);
+ glMultiTexCoord2fARB(GL_TEXTURE1_ARB,0,0);
+ glMultiTexCoord2fARB(GL_TEXTURE2_ARB,0,0);
+ glVertex3f(-hor,4,0);
+
+ glMultiTexCoord2fARB(GL_TEXTURE0_ARB,0,ymax);
+ glMultiTexCoord2fARB(GL_TEXTURE1_ARB,0,ymax);
+ glMultiTexCoord2fARB(GL_TEXTURE2_ARB,0,ymax);
+ glVertex3f(-hor,-4,0);
+
+ glMultiTexCoord2fARB(GL_TEXTURE0_ARB,xmax,ymax);
+ glMultiTexCoord2fARB(GL_TEXTURE1_ARB,xmax,ymax);
+ glMultiTexCoord2fARB(GL_TEXTURE2_ARB,xmax,ymax);
+ glVertex3f(hor,-4,0);
+
+ glMultiTexCoord2fARB(GL_TEXTURE0_ARB,xmax,0);
+ glMultiTexCoord2fARB(GL_TEXTURE1_ARB,xmax,0);
+ glMultiTexCoord2fARB(GL_TEXTURE2_ARB,xmax,0);
+ glVertex3f(hor,4,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);
+}
+
+static void
+gst_gl_nvimage_free_image (GstImageData *image)
+{
+ GstNvImage *im = (GstNvImage *) image;
+ g_return_if_fail (im != NULL);
+ GstGLImageConnection *nvconn = im->conn;
+
+ if (im->slot < AGP_BUFSLOTS)
+ {
+ 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)
+{
+ //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");
+ {
+ Ywidth = TEX_XSIZE; Yheight = TEX_YSIZE; UVwidth = TEX_XSIZE/2; UVheight = TEX_YSIZE/2;
+ Initialize_Backend(Ywidth,Yheight,UVwidth,UVheight,GL_LINEAR);
+ }
+}
+
+static void
+gst_gl_nvimage_close_conn (GstImageConnection *conn, GstImageInfo *info)
+{
+ GstGLImageConnection *xconn = gst_gl_nvimage_connection (conn);
+ //GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
+
+ // anything needed in here ? Oh, maybe drawing de-init, or something
+ glDeleteTextures(1, &xconn->ytex_id);
+ glDeleteTextures(1, &xconn->uvtex_id);
+ glDeleteTextures(1, &xconn->septex_id);
+}
+
+static void
+gst_gl_nvimage_free_conn (GstImageConnection *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
new file mode 100644
index 00000000..00df9a60
--- /dev/null
+++ b/sys/glsink/gstgl_pdrimage.c
@@ -0,0 +1,396 @@
+#include "config.h"
+
+#include <gst/gst.h>
+/* gcc -ansi -pedantic on GNU/Linux causes warnings and errors
+ * unless this is defined:
+ * warning: #warning "Files using this header must be compiled with _SVID_SOURCE or _XOPEN_SOURCE"
+ */
+#ifndef _XOPEN_SOURCE
+# define _XOPEN_SOURCE 1
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+
+#define GL_GLEXT_PROTOTYPES
+
+// VERY dangerous:
+#define GL_WRITE_PIXEL_DATA_RANGE_NV 0x8878
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <GL/glx.h>
+#include <GL/gl.h>
+#include <GL/glext.h>
+#include <GL/glu.h>
+#include <string.h>
+
+#include "gstglsink.h"
+
+typedef struct _GstGLImageConnection GstGLImageConnection;
+struct _GstGLImageConnection {
+ GstImageConnection conn;
+ Display *dpy;
+ gint w, h;
+ gint bpp;
+
+ int ytex_id;
+ int uvtex_id;
+ int septex_id;
+ unsigned char *m_memory;
+ int m_bufslots[4];
+};
+
+#define TEX_XSIZE 1024
+#define TEX_YSIZE 1024
+#define YUVTEX_SIZE ((TEX_XSIZE * TEX_YSIZE) * 3 /2)
+
+#define AGP_BUFSLOTS 4
+
+typedef struct _GstNvImage GstNvImage;
+struct _GstNvImage
+{
+ GstImageData data;
+ 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 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};
+
+ return &plugin;
+}
+
+
+static GstGLImageInfo *
+gst_gl_nvimage_info (GstImageInfo *info)
+{
+ 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)
+{
+ if (conn == NULL || conn->free_conn != gst_gl_nvimage_free_conn)
+ return NULL;
+ return (GstGLImageConnection *) conn;
+}
+
+gboolean
+gst_gl_nvimage_check_xvideo ()
+{
+ int ver, rel, req, ev, err;
+
+#if 0
+ if (display == NULL)
+ return FALSE;
+ if (Success == XvQueryExtension (display,&ver,&rel,&req,&ev,&err))
+ return TRUE;
+#endif
+
+ return FALSE;
+}
+
+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 (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))
+ );
+ return caps;
+}
+
+static GstImageConnection *
+gst_gl_nvimage_set_caps (GstImageInfo *info, GstCaps *caps)
+{
+ gint i, j = 0;
+ int adaptors;
+ int formats;
+ GstGLImageConnection *conn;
+ GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
+ guint32 format;
+
+ /* we don't handle these image information */
+ 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);
+
+ // 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)
+ {
+ /* 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);
+ return (GstImageConnection *) conn;
+}
+
+static GstImageData *
+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);
+ int slot = 0;
+
+ /* checks */
+ 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;
+
+ if (image->data.data == NULL)
+ {
+ g_warning ("GL_NvImage: data allocation failed!");
+ g_free (image);
+ return NULL;
+ }
+
+ return (GstImageData *) image;
+}
+
+static void
+gst_gl_nvimage_put_image (GstImageInfo *info, GstImageData *image)
+{
+ GstNvImage *im = (GstNvImage *) image;
+ 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");
+
+ // both upload the video, and redraw the screen
+ glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
+
+ glEnable(GL_TEXTURE_2D);
+
+ glPushMatrix();
+ //glTranslatef(0,1,0);
+ glRotatef(xinfo->rotX-250,1,0,0);
+ glRotatef(xinfo->rotY,0,1,0);
+ int zoom = xinfo->zoom;
+ glScaled(zoom,zoom,zoom);
+ //Draws the surface rectangle
+
+ 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);
+
+ glNormal3f(0, -1, 0);
+
+ glTexCoord2f(xmax, 0);
+ glVertex3f(4,0,-4);
+
+ glTexCoord2f(0, 0);
+ glVertex3f(-4,0,-4);
+
+ glTexCoord2f(0, ymax);
+ glVertex3f(-4,0,4);
+
+ glTexCoord2f(xmax, ymax);
+ glVertex3f(4,0,4);
+
+ glEnd();
+
+ glPopMatrix();
+
+ glXSwapBuffers(xinfo->dpy, xinfo->win);
+}
+
+static void
+gst_gl_nvimage_free_image (GstImageData *image)
+{
+ GstNvImage *im = (GstNvImage *) image;
+ g_return_if_fail (im != NULL);
+ GstGLImageConnection *nvconn = im->conn;
+
+ if (im->slot < AGP_BUFSLOTS)
+ {
+ 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)
+{
+ GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
+ GstGLImageConnection *xconn = gst_gl_nvimage_connection (conn);
+
+ 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);
+ //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);
+}
+
+static void
+gst_gl_nvimage_close_conn (GstImageConnection *conn, GstImageInfo *info)
+{
+ GstGLImageConnection *xconn = gst_gl_nvimage_connection (conn);
+ GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
+
+ // anything needed in here ? Oh, maybe drawing de-init, or something
+ glDeleteTextures(1, &xconn->ytex_id);
+ glDeleteTextures(1, &xconn->uvtex_id);
+ glDeleteTextures(1, &xconn->septex_id);
+}
+
+static void
+gst_gl_nvimage_free_conn (GstImageConnection *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
new file mode 100644
index 00000000..68a1329a
--- /dev/null
+++ b/sys/glsink/gstgl_rgbimage.c
@@ -0,0 +1,388 @@
+#include <gst/gst.h>
+
+/* gcc -ansi -pedantic on GNU/Linux causes warnings and errors
+ * unless this is defined:
+ * warning: #warning "Files using this header must be compiled with _SVID_SOURCE or _XOPEN_SOURCE"
+ */
+#ifndef _XOPEN_SOURCE
+# define _XOPEN_SOURCE 1
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <GL/glx.h>
+#include <GL/gl.h>
+#include <GL/glu.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 {
+ GstImageConnection conn;
+ Display *dpy; // the Xlib drawing context
+ GLXContext ctx; // The GLX drawing context
+ gint w, h;
+ gint bpp;
+
+ int rgbatex_id;
+ unsigned char *m_memory;
+};
+
+#define TEX_XSIZE 1024
+#define TEX_YSIZE 1024
+
+
+typedef struct _GstGLImage GstGLImage;
+struct _GstGLImage
+{
+ GstImageData data;
+ 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 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};
+
+ return &plugin;
+}
+
+static GstGLImageInfo *
+gst_gl_rgbimage_info (GstImageInfo *info)
+{
+ 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)
+{
+ if (conn == NULL || conn->free_conn != gst_gl_rgbimage_free_conn)
+ return NULL;
+ return (GstGLImageConnection *) conn;
+}
+
+GstCaps *
+gst_gl_rgbimage_get_caps (GstImageInfo *info)
+{
+ GstCaps *caps = NULL;
+ Visual *visual;
+ int xpad;
+ XWindowAttributes attrib;
+ XImage *ximage;
+ GstGLImageInfo *xinfo = gst_gl_rgbimage_info (info);
+
+ /* we don't handle this image information */
+ if (xinfo == NULL) return NULL;
+
+ XGetWindowAttributes(xinfo->dpy, xinfo->win, &attrib);
+
+ visual = attrib.visual;
+ if (attrib.depth <= 8)
+ xpad = 8;
+ else if (attrib.depth <= 16)
+ 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);
+ 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(0xff0000),
+ "green_mask", GST_PROPS_INT(0xff00),
+ "blue_mask", GST_PROPS_INT(0xff),
+ "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);
+ }
+
+ GST_DEBUG ("GL_RGBImage: returning caps at %p", caps);
+ return caps;
+}
+
+static GstImageConnection *
+gst_gl_rgbimage_set_caps (GstImageInfo *info, GstCaps *caps)
+{
+ g_warning("in set_caps !\n");
+
+ GstGLImageConnection *new = NULL;
+ Visual *visual;
+ XWindowAttributes attrib;
+ GstGLImageInfo *xinfo = gst_gl_rgbimage_info (info);
+ guint32 format;
+ gint depth;
+ gint endianness;
+ gint red_mask, green_mask, blue_mask;
+ gint width, height, bpp;
+
+ /* check if this is the right image info */
+ 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);
+
+ /* check if the caps are ok */
+ 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;
+ //if (red_mask != visual->red_mask) return NULL;
+ //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;
+ new->conn.free_conn = gst_gl_rgbimage_free_conn;
+ new->dpy = xinfo->dpy;
+ new->ctx = xinfo->ctx;
+ new->w = width;
+ new->h = height;
+ new->bpp = bpp;
+
+ return (GstImageConnection *) new;
+}
+
+static GstImageData *
+gst_gl_rgbimage_get_image (GstImageInfo *info, GstImageConnection *conn)
+{
+ GstGLImage *image;
+ //XWindowAttributes attrib;
+ GstGLImageInfo *xinfo = gst_gl_rgbimage_info (info);
+ GstGLImageConnection *xconn = gst_gl_rgbimage_connection (conn);
+
+ image = g_new (GstGLImage, 1);
+
+ /* checks */
+ 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)
+ {
+ g_warning ("GL_RGBImage: data allocation failed!");
+ g_free (image);
+ return NULL;
+ }
+
+ return (GstImageData *) image;
+}
+
+
+static void
+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;
+
+ g_assert (xinfo != NULL);
+
+ // both upload the video, and redraw the screen
+ glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
+
+ glMatrixMode(GL_MODELVIEW);
+ glLoadIdentity();
+ glTranslatef(0.0, 0.0, -25.0);
+
+ glEnable(GL_TEXTURE_2D);
+
+ if (xinfo->info.demo)
+ {
+
+ 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);
+
+ if (xinfo->zoom > 1.0)
+ xinfo->zoomdir = -0.01;
+
+ if (xinfo->zoom < 0.5)
+ 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;
+
+ float aspect = img_width/(float)img_height;
+ float hor = 4 * aspect;
+
+ glColor4f(1,1,1,1);
+ glBegin(GL_QUADS);
+
+ glNormal3f(0, -1, 0);
+
+ glTexCoord2f(xmax, 0);
+ glVertex3f(hor,4,0);
+
+ glTexCoord2f(0, 0);
+ glVertex3f(-hor,4,0);
+
+ glTexCoord2f(0, ymax);
+ glVertex3f(-hor,-4,0);
+
+ glTexCoord2f(xmax, ymax);
+ glVertex3f(hor,-4,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);
+}
+
+void
+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_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)
+{
+ 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);
+}
+
+/* Deletes the creates OpenGL textures */
+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);
+ }
+
+static void
+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
new file mode 100644
index 00000000..8a4449fa
--- /dev/null
+++ b/sys/glsink/gstglsink.c
@@ -0,0 +1,723 @@
+/* GStreamer
+ * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <config.h>
+#include <string.h>
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <GL/glx.h>
+#include <GL/gl.h>
+#include <GL/glu.h>
+#include <sys/time.h>
+
+/*#define GST_DEBUG_FORCE_DISABLE*/
+
+#include "gstglsink.h"
+
+/* elementfactory information */
+static GstElementDetails gst_glsink_details = {
+ "OpenGL Sink/GLX",
+ "Sink/GLVideo",
+ "LGPL",
+ "An OpenGL based video sink - uses OpenGL and GLX to draw video, utilizing different acceleration options",
+ VERSION,
+ "Gernot Ziegler <gz@lysator.liu.se>",
+ "(C) 2002",
+};
+
+/* 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
+};
+
+/* GLsink class */
+#define GST_TYPE_GLSINK (gst_glsink_get_type())
+#define GST_GLSINK(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GST_TYPE_GLSINK,GstGLSink))
+#define GST_GLSINK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_GLSINK,GstGLSink))
+#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;
+
+struct _GstGLSink {
+ GstElement element;
+
+ 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;
+
+ /* bufferpool stuff */
+ GstBufferPool *bufferpool;
+ GMutex *cache_lock;
+ GList *cache;
+
+ /* 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_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 GstBufferPool* gst_glsink_get_bufferpool (GstPad *pad);
+
+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);
+/* bufferpool stuff */
+static GstBuffer* gst_glsink_buffer_new (GstBufferPool *pool,
+ gint64 location,
+ guint size, gpointer user_data);
+static void gst_glsink_buffer_free (GstBufferPool *pool,
+ GstBuffer *buffer,
+ gpointer user_data);
+
+/* prototypes from plugins */
+extern GstImagePlugin* get_gl_rgbimage_plugin (void);
+extern GstImagePlugin* get_gl_nvimage_plugin (void);
+/* default output */
+extern void gst_glxwindow_new (GstGLSink *sink);
+
+
+static GstPadTemplate *sink_template;
+
+static GstElementClass *parent_class = NULL;
+/* static guint gst_glsink_signals[LAST_SIGNAL] = { 0 }; */
+
+static GType
+gst_glsink_get_type (void)
+{
+ static GType videosink_type = 0;
+
+ if (!videosink_type) {
+ static const GTypeInfo videosink_info = {
+ sizeof(GstGLSinkClass),
+ NULL,
+ NULL,
+ (GClassInitFunc) gst_glsink_class_init,
+ NULL,
+ NULL,
+ sizeof(GstGLSink),
+ 0,
+ (GInstanceInitFunc) gst_glsink_init,
+ };
+ videosink_type = g_type_register_static(GST_TYPE_ELEMENT, "GstGLSink", &videosink_info, 0);
+ }
+ return videosink_type;
+}
+
+static void
+gst_glsink_class_init (GstGLSinkClass *klass)
+{
+ GObjectClass *gobject_class;
+ GstElementClass *gstelement_class;
+
+ gobject_class = (GObjectClass *) 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_HOOK,
+ 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_object_class_install_property (gobject_class, ARG_REPAINT,
+ 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_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));
+
+ 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 ());
+ klass->plugins = g_list_append (klass->plugins, get_gl_nvimage_plugin ());
+}
+
+
+/*
+ GLSink has its own Buffer management - this allows special plugins to create special memory areas for
+ buffer upload
+*/
+static void
+gst_glsink_init (GstGLSink *sink)
+{
+ sink->sinkpad = gst_pad_new_from_template (sink_template, "sink");
+ gst_element_add_pad (GST_ELEMENT (sink), sink->sinkpad);
+ gst_pad_set_chain_function (sink->sinkpad, gst_glsink_chain);
+ gst_pad_set_link_function (sink->sinkpad, gst_glsink_sinkconnect);
+ gst_pad_set_getcaps_function (sink->sinkpad, gst_glsink_getcaps);
+ gst_pad_set_bufferpool_function (sink->sinkpad, gst_glsink_get_bufferpool);
+
+ sink->last_image = NULL;
+ sink->width = 0;
+ sink->height = 0;
+ sink->muted = FALSE;
+ 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->bufferpool = gst_buffer_pool_new (
+ NULL,
+ NULL,
+ (GstBufferPoolBufferNewFunction)gst_glsink_buffer_new,
+ NULL,
+ (GstBufferPoolBufferFreeFunction)gst_glsink_buffer_free,
+ sink);
+ 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);
+}
+
+static void
+gst_glsink_release_conn (GstGLSink *sink)
+{
+ if (sink->conn == NULL) return;
+
+ /* free last image if any */
+ 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)
+ {
+ 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)
+{
+ g_mutex_lock (sink->cache_lock);
+ sink->cache = g_list_prepend (sink->cache, image);
+ g_mutex_unlock (sink->cache_lock);
+}
+
+/*
+ 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)
+{
+ 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);
+ image = (GstImageData *) sink->cache->data;
+ sink->cache = g_list_delete_link (sink->cache, sink->cache);
+ g_mutex_unlock (sink->cache_lock);
+ } else {
+ /* 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;
+}
+
+/*
+ Free a buffer that the chain doesn't need anymore.
+*/
+static void
+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)));
+
+ 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;
+
+ gst_buffer_default_free (buffer);
+}
+
+static GstBufferPool*
+gst_glsink_get_bufferpool (GstPad *pad)
+{
+ GstGLSink *sink = GST_GLSINK (gst_pad_get_parent (pad));
+
+ return sink->bufferpool;
+}
+
+/*
+ Set the caps that the application desires.
+ Go through the plugin list, finding the plugin that first fits the given parameters
+*/
+static gboolean
+gst_glsink_set_caps (GstGLSink *sink, GstCaps *caps)
+{
+ //g_warning("in set caps!\n");
+ GList *list = ((GstGLSinkClass *) G_OBJECT_GET_CLASS (sink))->plugins;
+ GstImageConnection *conn = NULL;
+ while (list)
+ {
+ GstImagePlugin *plugin = (GstImagePlugin *) list->data;
+ if ((conn = plugin->set_caps (sink->hook, caps)) != NULL)
+ {
+ gst_glsink_release_conn (sink);
+ sink->conn = conn;
+ sink->plugin = plugin;
+ sink->conn->open_conn (sink->conn, sink->hook);
+ return TRUE;
+ }
+ list = g_list_next (list);
+ }
+ return FALSE;
+}
+
+/**
+Link the input video sink internally.
+*/
+static GstPadLinkReturn
+gst_glsink_sinkconnect (GstPad *pad, GstCaps *caps)
+{
+ fprintf(stderr, "in sinkconnect!\n");
+ GstGLSink *sink;
+ guint32 fourcc, print_format;
+
+ sink = GST_GLSINK (gst_pad_get_parent (pad));
+
+ /* we are not going to act on variable caps */
+ if (!GST_CAPS_IS_FIXED (caps))
+ return GST_PAD_LINK_DELAYED;
+
+ /* try to set the caps on the output */
+ if (gst_glsink_set_caps (sink, caps) == 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);
+
+ /* emit signal */
+ g_object_freeze_notify (G_OBJECT (sink));
+ g_object_notify (G_OBJECT (sink), "width");
+ g_object_notify (G_OBJECT (sink), "height");
+ g_object_thaw_notify (G_OBJECT (sink));
+
+ return GST_PAD_LINK_OK;
+}
+static GstCaps *
+gst_glsink_getcaps (GstPad *pad, GstCaps *caps)
+{
+ //g_warning("in 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;
+
+ while (list)
+ {
+ ret = gst_caps_append (ret, ((GstImagePlugin *) list->data)->get_caps (sink->hook));
+ list = g_list_next (list);
+ }
+
+ return ret;
+}
+
+static void
+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)
+{
+ //g_warning("in glsink_chain!\n");
+ GstBuffer *buf = GST_BUFFER (_data);
+ GstGLSink *sink;
+ //GstClockTime time = GST_BUFFER_TIMESTAMP (buf);
+ GstBuffer *buffer;
+ //static int frame_drops = 0;
+
+ g_return_if_fail (pad != NULL);
+ g_return_if_fail (GST_IS_PAD (pad));
+ g_return_if_fail (buf != NULL);
+
+ sink = GST_GLSINK (gst_pad_get_parent (pad));
+
+ if (GST_IS_EVENT (buf)) {
+ GstEvent *event = GST_EVENT (buf);
+
+ switch (GST_EVENT_TYPE (event)) {
+ default:
+ gst_pad_event_default (pad, event);
+ }
+ return;
+ }
+ GST_DEBUG ("glsink: clock wait: %llu %u",
+ GST_BUFFER_TIMESTAMP (buf), GST_BUFFER_SIZE (buf));
+
+#if 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
+
+ GstClockReturn ret;
+ 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);
+
+ /* we are going to drop early buffers */
+ if (ret == GST_CLOCK_EARLY) {
+ gst_buffer_unref (buf);
+ return;
+ }
+ }
+#endif
+
+ /* call the notify _before_ displaying so the handlers can react */
+ sink->frames_displayed++;
+ g_object_notify (G_OBJECT (sink), "frames_displayed");
+
+ if (!sink->muted)
+ {
+ /* 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->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));
+
+ sink->plugin->put_image (sink->hook, (GstImageData *) GST_BUFFER_POOL_PRIVATE (buffer));
+
+ sink->last_image = buffer;
+ gst_buffer_unref (buf);
+ }
+ }
+
+}
+
+
+static void
+gst_glsink_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
+{
+ //g_warning("in set_property!\n");
+ GstGLSink *sink;
+
+ /* it's not null if we got it, but it might not be ours */
+ g_return_if_fail (GST_IS_GLSINK (object));
+
+ sink = GST_GLSINK (object);
+
+ switch (prop_id) {
+ case ARG_FRAMES_DISPLAYED:
+ sink->frames_displayed = g_value_get_int (value);
+ g_object_notify (object, "frames_displayed");
+ break;
+ case ARG_FRAME_TIME:
+ sink->frame_time = g_value_get_int (value);
+ break;
+ case ARG_HOOK:
+ if (sink->hook)
+ {
+ sink->hook->free_info (sink->hook);
+ }
+ sink->hook = g_value_get_pointer (value);
+ break;
+ case ARG_MUTE:
+ sink->muted = g_value_get_boolean (value);
+ g_object_notify (object, "mute");
+ break;
+ case ARG_DEMO:
+ sink->demo = g_value_get_int (value);
+ g_object_notify (object, "demo");
+ break;
+ case ARG_DUMP:
+ sink->dumpvideo = g_value_get_boolean (value);
+ g_object_notify (object, "dump");
+ break;
+ case ARG_REPAINT:
+ if (sink->last_image != NULL) {
+ sink->plugin->put_image (sink->hook, (GstImageData *) GST_BUFFER_POOL_PRIVATE (sink->last_image));
+ }
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+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);
+
+ switch (prop_id) {
+ case ARG_WIDTH:
+ g_value_set_int (value, sink->width);
+ break;
+ case ARG_HEIGHT:
+ g_value_set_int (value, sink->height);
+ break;
+ case ARG_FRAMES_DISPLAYED:
+ g_value_set_int (value, sink->frames_displayed);
+ break;
+ case ARG_FRAME_TIME:
+ g_value_set_int (value, sink->frame_time/1000000);
+ break;
+ case ARG_MUTE:
+ g_value_set_boolean (value, sink->muted);
+ break;
+ case ARG_DEMO:
+ g_value_set_int (value, sink->demo);
+ break;
+ case ARG_DUMP:
+ g_value_set_boolean (value, sink->dumpvideo);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+
+static GstElementStateReturn
+gst_glsink_change_state (GstElement *element)
+{
+ //g_warning("in change_state!\n");
+ GstGLSink *sink;
+
+ sink = GST_GLSINK (element);
+
+ switch (GST_STATE_TRANSITION (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);
+ }
+ break;
+ case GST_STATE_PAUSED_TO_PLAYING:
+ {
+ //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);
+ if (sink->last_image) {
+ gst_buffer_unref (sink->last_image);
+ sink->last_image = NULL;
+ }
+ break;
+ case GST_STATE_READY_TO_NULL:
+ gst_glsink_release_conn (sink);
+ break;
+ }
+
+ parent_class->change_state (element);
+
+ return GST_STATE_SUCCESS;
+}
+
+#if 1
+/* 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))
+)
+#endif
+
+
+static gboolean
+plugin_init (GModule *module, GstPlugin *plugin)
+{
+ GstElementFactory *factory;
+
+ /* Loading the library containing GstVideoSink, our parent object */
+ if (!gst_library_load ("gstvideo"))
+ return FALSE;
+
+ /* create an elementfactory for the xvideosink element */
+ factory = gst_element_factory_new("glsink",GST_TYPE_GLSINK,
+ &gst_glsink_details);
+
+ if (factory == NULL)
+ {
+ g_warning("DANGER; WILL !\n");
+ }
+
+ g_warning("INIT GST_LITTLE_ENDIAN %d!\n", G_LITTLE_ENDIAN);
+ g_return_val_if_fail(factory != NULL, 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);
+
+#if 0
+ gst_element_factory_add_pad_template (factory, sink_template);
+#else
+ gst_element_factory_add_pad_template (
+ factory,
+ GST_PAD_TEMPLATE_GET (gst_glsink_sink_template_factory));
+#endif
+
+ gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (factory));
+
+ return TRUE;
+}
+
+GstPluginDesc plugin_desc = {
+ GST_VERSION_MAJOR,
+ GST_VERSION_MINOR,
+ "glsink",
+ plugin_init
+};
diff --git a/sys/glsink/gstglsink.h b/sys/glsink/gstglsink.h
new file mode 100644
index 00000000..8a34df9a
--- /dev/null
+++ b/sys/glsink/gstglsink.h
@@ -0,0 +1,96 @@
+/* GStreamer
+ * Copyright (C) 2002 The GStreamer Team
+ * <gstreamer-devel@lists.sourceforge.net>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#ifndef __GST_VIDEOSINK_H__
+#define __GST_VIDEOSINK_H__
+
+#include <gst/gst.h>
+
+#ifdef __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;
+/* 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;
+};
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GST_VIDEOSINK_H__ */
diff --git a/sys/glsink/gstglxwindow.c b/sys/glsink/gstglxwindow.c
new file mode 100644
index 00000000..79b743a0
--- /dev/null
+++ b/sys/glsink/gstglxwindow.c
@@ -0,0 +1,241 @@
+/* This stores the common OpenGL initialization stuff for all instances */
+
+/* gcc -ansi -pedantic on GNU/Linux causes warnings and errors
+ * unless this is defined:
+ * warning: #warning "Files using this header must be compiled with _SVID_SOURCE or _XOPEN_SOURCE"
+ */
+#ifndef _XOPEN_SOURCE
+# define _XOPEN_SOURCE 1
+#endif
+
+#include <X11/Xlib.h>
+#include <GL/glx.h>
+#include <GL/gl.h>
+#include <GL/glu.h>
+#include "gstglsink.h"
+#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,
+ 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
+ };
+
+
+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 */
+
+
+static void
+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);
+ }
+#endif
+ XCloseDisplay (window->dpy);
+ g_free (window);
+}
+
+static void
+gst_glxwindow_callback(GObject *object, GParamSpec *pspec, GstGLImageInfo *data)
+{
+ XWindowAttributes attr;
+ XGetWindowAttributes(data->dpy, data->win, &attr);
+
+ if (strncmp (pspec->name, "width", 5) == 0 || strncmp (pspec->name, "height", 6) == 0)
+ {
+ 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)
+ {
+ 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();
+
+ GLfloat aspect = (GLfloat) h / (GLfloat) w;
+ glFrustum(-1.0, 1.0, -aspect, aspect, 5.0, 500.0);
+ }
+ }
+ if (attr.width != data->width || attr.height != data->height)
+ {
+ data->width = attr.width;
+ data->height = attr.height;
+ }
+
+}
+
+void
+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)";
+
+ new = g_new0 (GstGLImageInfo, 1);
+
+ 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);
+ /* 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);
+
+ /* create a GLX context */
+ 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);
+ new->attr.colormap = cmap;
+ new->attr.border_pixel = 0;
+
+ /* set sizes */
+ new->x = 0;
+ new->y = 0;
+ new->width = 10;
+ new->height = 10;
+
+ new->rotX = 0;
+ new->rotY = 0;
+ new->zoom = 1;
+ new->zoomdir = 0.01;
+
+ {
+ /* 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;
+ }
+ /* 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);
+ }
+ /* 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");
+ else
+ GST_DEBUG ("Sorry, no Direct Rendering possible!\n");
+
+ GST_DEBUG("Initializing OpenGL parameters\n");
+ /* initialize OpenGL drawing */
+ glEnable(GL_DEPTH_TEST);
+ //glShadeModel(GL_SMOOTH);
+
+ 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. */
+
+ //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);
+
+ glPolygonMode(GL_FRONT, GL_FILL);
+ glPolygonMode(GL_BACK, GL_FILL);
+
+ 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);
+}
+
diff --git a/sys/glsink/regcomb_yuvrgb.c b/sys/glsink/regcomb_yuvrgb.c
new file mode 100644
index 00000000..0c953c6f
--- /dev/null
+++ b/sys/glsink/regcomb_yuvrgb.c
@@ -0,0 +1,349 @@
+// these includes don't do a lot in Linux, they are more needed in Win32 (for the OpenGL function call pointers)
+// but they are used at least for checking if the necessary extensions are present
+#include "ARB_multitexture.h"
+#include "NV_register_combiners.h"
+#include "EXT_paletted_texture.h"
+
+/***********************************************************************************************
+ INTERESTING PART: *
+ handles initialization of the Nvidia register combiners for YUV->RGB conversion.
+ This code was created by Jens Schneider <schneider@glhint.de>
+ ***********************************************************************************************/
+
+GLuint Yhandle;
+GLuint Uhandle;
+GLuint Vhandle;
+unsigned char *YPlane;
+unsigned char *UPlane;
+unsigned char *VPlane;
+
+// YUV 4:2:2 example
+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
+{
+ 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);
+}
+
+/*
+ * 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_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_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_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_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
+ )
+{
+ 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)
+{
+ 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);
+}
+
+
+// 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)
+{
+ 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);
+#else // Hopefully Linux
+ 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));
+#ifdef _WIN32
+ 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);
+#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));
+#ifdef _WIN32
+ 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);
+#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);
+}
+
+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);
+}
+
+
+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);
+ if (!GL_ARB_multitexture_Init()) exit(0);
+ if (!GL_EXT_paletted_texture_Init()) exit(0);
+ if (!GL_NV_register_combiners_Init()) exit(0);
+ unsigned char Ypal[768];
+ unsigned char Upal[768];
+ unsigned char Vpal[768];
+ 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);
+}
+
+
+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);
+}
generated by cgit v1.2.1 (git 2.18.0) at 2024-12-25 06:15:55 +0000