mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2025-01-12 02:15:31 +00:00
Code Issues 1 Projects Releases Wiki Activity

[008/906] gst-indent

Browse source
This commit is contained in:
Thomas Vander Stichele 2004-03-14 22:34:32 +00:00 committed by Matthew Waters
parent 925dfd952a
commit febb402b4b
10 changed files with 2188 additions and 1749 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

435
gst/gl/ARB_multitexture.h
View file

@ -19,26 +19,26 @@
#define ARB_MULTITEXTURE_INITIALIZE 1 // enable generic init-routines
#ifndef _WIN32
#define GL_GLEXT_PROTOTYPES 1
#endif
#endif /* */
#ifdef __cplusplus
extern "C" {
#endif
extern "C"
{
#endif /* */
#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__)
#define WIN32_LEAN_AND_MEAN 1
#include <windows.h>
#endif
#endif /* */
#ifndef APIENTRY
#define APIENTRY
#endif
#endif /* */
// Header file version number, required by OpenGL ABI for Linux
//#define GL_GLEXT_VERSION 7
/*
* NEW TOKENS TO OPENGL 1.2.1
*
@ -80,7 +80,7 @@ extern "C" {
#define GL_CLIENT_ACTIVE_TEXTURE_ARB 0x84E1
#define GL_MAX_TEXTURE_UNITS_ARB 0x84E2
#define GL_ARB_multitexture 1
#endif
#endif /* */
#ifndef _WIN32
#ifdef GL_GLEXT_PROTOTYPES
@ -102,58 +102,99 @@ extern void APIENTRY glMultiTexCoord2iARB (GLenum, GLint, GLint);
extern void APIENTRY glMultiTexCoord2ivARB (GLenum, const GLint *);
extern void APIENTRY glMultiTexCoord2sARB (GLenum, GLshort, GLshort);
extern void APIENTRY glMultiTexCoord2svARB (GLenum, const GLshort *);
extern void APIENTRY glMultiTexCoord3dARB (GLenum, GLdouble, GLdouble, GLdouble);
extern void APIENTRY glMultiTexCoord3dARB (GLenum, GLdouble, GLdouble,
GLdouble);
extern void APIENTRY glMultiTexCoord3dvARB (GLenum, const GLdouble *);
extern void APIENTRY glMultiTexCoord3fARB (GLenum, GLfloat, GLfloat, GLfloat);
extern void APIENTRY glMultiTexCoord3fARB (GLenum, GLfloat, GLfloat,
GLfloat);
extern void APIENTRY glMultiTexCoord3fvARB (GLenum, const GLfloat *);
extern void APIENTRY glMultiTexCoord3iARB (GLenum, GLint, GLint, GLint);
extern void APIENTRY glMultiTexCoord3ivARB (GLenum, const GLint *);
extern void APIENTRY glMultiTexCoord3sARB (GLenum, GLshort, GLshort, GLshort);
extern void APIENTRY glMultiTexCoord3sARB (GLenum, GLshort, GLshort,
GLshort);
extern void APIENTRY glMultiTexCoord3svARB (GLenum, const GLshort *);
extern void APIENTRY glMultiTexCoord4dARB (GLenum, GLdouble, GLdouble, GLdouble, GLdouble);
extern void APIENTRY glMultiTexCoord4dARB (GLenum, GLdouble, GLdouble,
GLdouble, GLdouble);
extern void APIENTRY glMultiTexCoord4dvARB (GLenum, const GLdouble *);
extern void APIENTRY glMultiTexCoord4fARB (GLenum, GLfloat, GLfloat, GLfloat, GLfloat);
extern void APIENTRY glMultiTexCoord4fARB (GLenum, GLfloat, GLfloat,
GLfloat, GLfloat);
extern void APIENTRY glMultiTexCoord4fvARB (GLenum, const GLfloat *);
extern void APIENTRY glMultiTexCoord4iARB (GLenum, GLint, GLint, GLint, GLint);
extern void APIENTRY glMultiTexCoord4iARB (GLenum, GLint, GLint, GLint,
GLint);
extern void APIENTRY glMultiTexCoord4ivARB (GLenum, const GLint *);
extern void APIENTRY glMultiTexCoord4sARB (GLenum, GLshort, GLshort, GLshort, GLshort);
extern void APIENTRY glMultiTexCoord4sARB (GLenum, GLshort, GLshort,
GLshort, GLshort);
extern void APIENTRY glMultiTexCoord4svARB (GLenum, const GLshort *);
#endif // GL_GLEXT_PROTOTYPES
#else // not _WIN32
typedef void (APIENTRY * PFNGLACTIVETEXTUREARBPROC) (GLenum texture);
typedef void (APIENTRY * PFNGLCLIENTACTIVETEXTUREARBPROC) (GLenum texture);
typedef void (APIENTRY * PFNGLMULTITEXCOORD1DARBPROC) (GLenum target, GLdouble s);
typedef void (APIENTRY * 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);
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
@ -194,9 +235,10 @@ PFNGLMULTITEXCOORD4IARBPROC glMultiTexCoord4iARB = NULL;
PFNGLMULTITEXCOORD4IVARBPROC glMultiTexCoord4ivARB = NULL;
PFNGLMULTITEXCOORD4SARBPROC glMultiTexCoord4sARB = NULL;
PFNGLMULTITEXCOORD4SVARBPROC glMultiTexCoord4svARB = NULL;
#endif // _WIN32
int CheckForARBMultitextureSupport(void) {
#endif // _WIN32
int CheckForARBMultitextureSupport (void)
{
const char search[] = "GL_ARB_multitexture";
int i, pos = 0;
int maxpos = strlen (search) - 1;
@ -205,14 +247,19 @@ int CheckForARBMultitextureSupport(void) {
strcpy (extensions, (const char *) glGetString (GL_EXTENSIONS));
printf ("Examinig GLstring\n");
int len = strlen (extensions);
for ( i=0; i<len; i++) {
for (i = 0; i < len; i++)
{
if ((i == 0) || ((i > 1) && extensions[i - 1] == ' ')) {
pos = 0;
while(extensions[i]!=' ') {
if (extensions[i]==search[pos]) pos++;
while (extensions[i] != ' ')
{
if (extensions[i] == search[pos])
pos++;
if ((pos > maxpos) && extensions[i + 1] == ' ') {
//if (debug)
{
//fprintf(stderr, search);
//fprintf(stderr, " supported.\n");
}
@ -222,82 +269,222 @@ int CheckForARBMultitextureSupport(void) {
}
}
}
//printf(search);
//printf(" not supported.\n");
return 0;
}
int GL_ARB_multitexture_Init (void)
{
if (!CheckForARBMultitextureSupport ())
return 0;
int GL_ARB_multitexture_Init(void) {
if (!CheckForARBMultitextureSupport()) return 0;
#ifdef _WIN32
glActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC) wglGetProcAddress("glActiveTextureARB");
if (glActiveTextureARB==NULL) {fprintf(stderr,"glActiveTextureARB not found.\n"); return 0; }
glClientActiveTextureARB = (PFNGLCLIENTACTIVETEXTUREARBPROC) wglGetProcAddress("glClientActiveTextureARB");
if (glClientActiveTextureARB==NULL) {fprintf(stderr,"glClientActiveTextureARB not found.\n"); return 0; }
glMultiTexCoord1dARB = (PFNGLMULTITEXCOORD1DARBPROC) wglGetProcAddress("glMultiTexCoord1dARB");
if (glMultiTexCoord1dARB==NULL) {fprintf(stderr,"glMultiTexCoord1dARB not found.\n"); return 0; }
glMultiTexCoord1dvARB = (PFNGLMULTITEXCOORD1DVARBPROC) wglGetProcAddress("glMultiTexCoord1dvARB");
if (glMultiTexCoord1dvARB==NULL) {fprintf(stderr,"glMultiTexCoord1dAvRB not found.\n"); return 0; }
glMultiTexCoord1fARB = (PFNGLMULTITEXCOORD1FARBPROC) wglGetProcAddress("glMultiTexCoord1fARB");
if (glMultiTexCoord1fARB==NULL) {fprintf(stderr,"glMultiTexCoord1fARB not found.\n"); return 0; }
glMultiTexCoord1fvARB = (PFNGLMULTITEXCOORD1FVARBPROC) wglGetProcAddress("glMultiTexCoord1fvARB");
if (glMultiTexCoord1fvARB==NULL) {fprintf(stderr,"glMultiTexCoord1fvARB not found.\n"); return 0; }
glMultiTexCoord1iARB = (PFNGLMULTITEXCOORD1IARBPROC) wglGetProcAddress("glMultiTexCoord1iARB");
if (glMultiTexCoord1iARB==NULL) {fprintf(stderr,"glMultiTexCoord1iARB not found.\n"); return 0; }
glMultiTexCoord1ivARB = (PFNGLMULTITEXCOORD1IVARBPROC) wglGetProcAddress("glMultiTexCoord1ivARB");
if (glMultiTexCoord1ivARB==NULL) {fprintf(stderr,"glMultiTexCoord1ivARB not found.\n"); return 0; }
glMultiTexCoord1sARB = (PFNGLMULTITEXCOORD1SARBPROC) wglGetProcAddress("glMultiTexCoord1sARB");
if (glMultiTexCoord1sARB==NULL) {fprintf(stderr,"glMultiTexCoord1sARB not found.\n"); return 0; }
glMultiTexCoord1svARB = (PFNGLMULTITEXCOORD1SVARBPROC) wglGetProcAddress("glMultiTexCoord1svARB");
if (glMultiTexCoord1svARB==NULL) {fprintf(stderr,"glMultiTexCoord1svARB not found.\n"); return 0; }
glMultiTexCoord2dARB = (PFNGLMULTITEXCOORD2DARBPROC) wglGetProcAddress("glMultiTexCoord2dARB");
if (glMultiTexCoord2dARB==NULL) {fprintf(stderr,"glMultiTexCoord2dARB not found.\n"); return 0; }
glMultiTexCoord2dvARB = (PFNGLMULTITEXCOORD2DVARBPROC) wglGetProcAddress("glMultiTexCoord2dvARB");
if (glMultiTexCoord2dvARB==NULL) {fprintf(stderr,"glMultiTexCoord2dAvRB not found.\n"); return 0; }
glMultiTexCoord2fARB = (PFNGLMULTITEXCOORD2FARBPROC) wglGetProcAddress("glMultiTexCoord2fARB");
if (glMultiTexCoord2fARB==NULL) {fprintf(stderr,"glMultiTexCoord2fARB not found.\n"); return 0; }
glMultiTexCoord2fvARB = (PFNGLMULTITEXCOORD2FVARBPROC) wglGetProcAddress("glMultiTexCoord2fvARB");
if (glMultiTexCoord2fvARB==NULL) {fprintf(stderr,"glMultiTexCoord2fvARB not found.\n"); return 0; }
glMultiTexCoord2iARB = (PFNGLMULTITEXCOORD2IARBPROC) wglGetProcAddress("glMultiTexCoord2iARB");
if (glMultiTexCoord2iARB==NULL) {fprintf(stderr,"glMultiTexCoord2iARB not found.\n"); return 0; }
glMultiTexCoord2ivARB = (PFNGLMULTITEXCOORD2IVARBPROC) wglGetProcAddress("glMultiTexCoord2ivARB");
if (glMultiTexCoord2ivARB==NULL) {fprintf(stderr,"glMultiTexCoord2ivARB not found.\n"); return 0; }
glMultiTexCoord2sARB = (PFNGLMULTITEXCOORD2SARBPROC) wglGetProcAddress("glMultiTexCoord2sARB");
if (glMultiTexCoord2sARB==NULL) {fprintf(stderr,"glMultiTexCoord2sARB not found.\n"); return 0; }
glMultiTexCoord2svARB = (PFNGLMULTITEXCOORD2SVARBPROC) wglGetProcAddress("glMultiTexCoord2svARB");
if (glMultiTexCoord2svARB==NULL) {fprintf(stderr,"glMultiTexCoord2svARB not found.\n"); return 0; }
glMultiTexCoord3dARB = (PFNGLMULTITEXCOORD3DARBPROC) wglGetProcAddress("glMultiTexCoord3dARB");
if (glMultiTexCoord3dARB==NULL) {fprintf(stderr,"glMultiTexCoord3dARB not found.\n"); return 0; }
glMultiTexCoord3dvARB = (PFNGLMULTITEXCOORD3DVARBPROC) wglGetProcAddress("glMultiTexCoord3dvARB");
if (glMultiTexCoord3dvARB==NULL) {fprintf(stderr,"glMultiTexCoord3dAvRB not found.\n"); return 0; }
glMultiTexCoord3fARB = (PFNGLMULTITEXCOORD3FARBPROC) wglGetProcAddress("glMultiTexCoord3fARB");
if (glMultiTexCoord3fARB==NULL) {fprintf(stderr,"glMultiTexCoord3fARB not found.\n"); return 0; }
glMultiTexCoord3fvARB = (PFNGLMULTITEXCOORD3FVARBPROC) wglGetProcAddress("glMultiTexCoord3fvARB");
if (glMultiTexCoord3fvARB==NULL) {fprintf(stderr,"glMultiTexCoord3fvARB not found.\n"); return 0; }
glMultiTexCoord3iARB = (PFNGLMULTITEXCOORD3IARBPROC) wglGetProcAddress("glMultiTexCoord3iARB");
if (glMultiTexCoord3iARB==NULL) {fprintf(stderr,"glMultiTexCoord3iARB not found.\n"); return 0; }
glMultiTexCoord3ivARB = (PFNGLMULTITEXCOORD3IVARBPROC) wglGetProcAddress("glMultiTexCoord3ivARB");
if (glMultiTexCoord3ivARB==NULL) {fprintf(stderr,"glMultiTexCoord3ivARB not found.\n"); return 0; }
glMultiTexCoord3sARB = (PFNGLMULTITEXCOORD3SARBPROC) wglGetProcAddress("glMultiTexCoord3sARB");
if (glMultiTexCoord3sARB==NULL) {fprintf(stderr,"glMultiTexCoord3sARB not found.\n"); return 0; }
glMultiTexCoord3svARB = (PFNGLMULTITEXCOORD3SVARBPROC) wglGetProcAddress("glMultiTexCoord3svARB");
if (glMultiTexCoord3svARB==NULL) {fprintf(stderr,"glMultiTexCoord3svARB not found.\n"); return 0; }
glMultiTexCoord4dARB = (PFNGLMULTITEXCOORD4DARBPROC) wglGetProcAddress("glMultiTexCoord4dARB");
if (glMultiTexCoord4dARB==NULL) {fprintf(stderr,"glMultiTexCoord4dARB not found.\n"); return 0; }
glMultiTexCoord4dvARB = (PFNGLMULTITEXCOORD4DVARBPROC) wglGetProcAddress("glMultiTexCoord4dvARB");
if (glMultiTexCoord4dvARB==NULL) {fprintf(stderr,"glMultiTexCoord4dAvRB not found.\n"); return 0; }
glMultiTexCoord4fARB = (PFNGLMULTITEXCOORD4FARBPROC) wglGetProcAddress("glMultiTexCoord4fARB");
if (glMultiTexCoord4fARB==NULL) {fprintf(stderr,"glMultiTexCoord4fARB not found.\n"); return 0; }
glMultiTexCoord4fvARB = (PFNGLMULTITEXCOORD4FVARBPROC) wglGetProcAddress("glMultiTexCoord4fvARB");
if (glMultiTexCoord4fvARB==NULL) {fprintf(stderr,"glMultiTexCoord4fvARB not found.\n"); return 0; }
glMultiTexCoord4iARB = (PFNGLMULTITEXCOORD4IARBPROC) wglGetProcAddress("glMultiTexCoord4iARB");
if (glMultiTexCoord4iARB==NULL) {fprintf(stderr,"glMultiTexCoord4iARB not found.\n"); return 0; }
glMultiTexCoord4ivARB = (PFNGLMULTITEXCOORD4IVARBPROC) wglGetProcAddress("glMultiTexCoord4ivARB");
if (glMultiTexCoord4ivARB==NULL) {fprintf(stderr,"glMultiTexCoord4ivARB not found.\n"); return 0; }
glMultiTexCoord4sARB = (PFNGLMULTITEXCOORD4SARBPROC) wglGetProcAddress("glMultiTexCoord4sARB");
if (glMultiTexCoord4sARB==NULL) {fprintf(stderr,"glMultiTexCoord4sARB not found.\n"); return 0; }
glMultiTexCoord4svARB = (PFNGLMULTITEXCOORD4SVARBPROC) wglGetProcAddress("glMultiTexCoord4svARB");
if (glMultiTexCoord4svARB==NULL) {fprintf(stderr,"glMultiTexCoord4svARB not found.\n"); return 0; }
glActiveTextureARB =
(PFNGLACTIVETEXTUREARBPROC) wglGetProcAddress ("glActiveTextureARB");
if (glActiveTextureARB == NULL) {
fprintf (stderr, "glActiveTextureARB not found.\n");
return 0;
}
glClientActiveTextureARB = (PFNGLCLIENTACTIVETEXTUREARBPROC)
wglGetProcAddress ("glClientActiveTextureARB");
if (glClientActiveTextureARB == NULL) {
fprintf (stderr, "glClientActiveTextureARB not found.\n");
return 0;
}
glMultiTexCoord1dARB = (PFNGLMULTITEXCOORD1DARBPROC)
wglGetProcAddress ("glMultiTexCoord1dARB");
if (glMultiTexCoord1dARB == NULL) {
fprintf (stderr, "glMultiTexCoord1dARB not found.\n");
return 0;
}
glMultiTexCoord1dvARB = (PFNGLMULTITEXCOORD1DVARBPROC)
wglGetProcAddress ("glMultiTexCoord1dvARB");
if (glMultiTexCoord1dvARB == NULL) {
fprintf (stderr, "glMultiTexCoord1dAvRB not found.\n");
return 0;
}
glMultiTexCoord1fARB = (PFNGLMULTITEXCOORD1FARBPROC)
wglGetProcAddress ("glMultiTexCoord1fARB");
if (glMultiTexCoord1fARB == NULL) {
fprintf (stderr, "glMultiTexCoord1fARB not found.\n");
return 0;
}
glMultiTexCoord1fvARB = (PFNGLMULTITEXCOORD1FVARBPROC)
wglGetProcAddress ("glMultiTexCoord1fvARB");
if (glMultiTexCoord1fvARB == NULL) {
fprintf (stderr, "glMultiTexCoord1fvARB not found.\n");
return 0;
}
glMultiTexCoord1iARB = (PFNGLMULTITEXCOORD1IARBPROC)
wglGetProcAddress ("glMultiTexCoord1iARB");
if (glMultiTexCoord1iARB == NULL) {
fprintf (stderr, "glMultiTexCoord1iARB not found.\n");
return 0;
}
glMultiTexCoord1ivARB = (PFNGLMULTITEXCOORD1IVARBPROC)
wglGetProcAddress ("glMultiTexCoord1ivARB");
if (glMultiTexCoord1ivARB == NULL) {
fprintf (stderr, "glMultiTexCoord1ivARB not found.\n");
return 0;
}
glMultiTexCoord1sARB = (PFNGLMULTITEXCOORD1SARBPROC)
wglGetProcAddress ("glMultiTexCoord1sARB");
if (glMultiTexCoord1sARB == NULL) {
fprintf (stderr, "glMultiTexCoord1sARB not found.\n");
return 0;
}
glMultiTexCoord1svARB = (PFNGLMULTITEXCOORD1SVARBPROC)
wglGetProcAddress ("glMultiTexCoord1svARB");
if (glMultiTexCoord1svARB == NULL) {
fprintf (stderr, "glMultiTexCoord1svARB not found.\n");
return 0;
}
glMultiTexCoord2dARB = (PFNGLMULTITEXCOORD2DARBPROC)
wglGetProcAddress ("glMultiTexCoord2dARB");
if (glMultiTexCoord2dARB == NULL) {
fprintf (stderr, "glMultiTexCoord2dARB not found.\n");
return 0;
}
glMultiTexCoord2dvARB = (PFNGLMULTITEXCOORD2DVARBPROC)
wglGetProcAddress ("glMultiTexCoord2dvARB");
if (glMultiTexCoord2dvARB == NULL) {
fprintf (stderr, "glMultiTexCoord2dAvRB not found.\n");
return 0;
}
glMultiTexCoord2fARB = (PFNGLMULTITEXCOORD2FARBPROC)
wglGetProcAddress ("glMultiTexCoord2fARB");
if (glMultiTexCoord2fARB == NULL) {
fprintf (stderr, "glMultiTexCoord2fARB not found.\n");
return 0;
}
glMultiTexCoord2fvARB = (PFNGLMULTITEXCOORD2FVARBPROC)
wglGetProcAddress ("glMultiTexCoord2fvARB");
if (glMultiTexCoord2fvARB == NULL) {
fprintf (stderr, "glMultiTexCoord2fvARB not found.\n");
return 0;
}
glMultiTexCoord2iARB = (PFNGLMULTITEXCOORD2IARBPROC)
wglGetProcAddress ("glMultiTexCoord2iARB");
if (glMultiTexCoord2iARB == NULL) {
fprintf (stderr, "glMultiTexCoord2iARB not found.\n");
return 0;
}
glMultiTexCoord2ivARB = (PFNGLMULTITEXCOORD2IVARBPROC)
wglGetProcAddress ("glMultiTexCoord2ivARB");
if (glMultiTexCoord2ivARB == NULL) {
fprintf (stderr, "glMultiTexCoord2ivARB not found.\n");
return 0;
}
glMultiTexCoord2sARB = (PFNGLMULTITEXCOORD2SARBPROC)
wglGetProcAddress ("glMultiTexCoord2sARB");
if (glMultiTexCoord2sARB == NULL) {
fprintf (stderr, "glMultiTexCoord2sARB not found.\n");
return 0;
}
glMultiTexCoord2svARB = (PFNGLMULTITEXCOORD2SVARBPROC)
wglGetProcAddress ("glMultiTexCoord2svARB");
if (glMultiTexCoord2svARB == NULL) {
fprintf (stderr, "glMultiTexCoord2svARB not found.\n");
return 0;
}
glMultiTexCoord3dARB = (PFNGLMULTITEXCOORD3DARBPROC)
wglGetProcAddress ("glMultiTexCoord3dARB");
if (glMultiTexCoord3dARB == NULL) {
fprintf (stderr, "glMultiTexCoord3dARB not found.\n");
return 0;
}
glMultiTexCoord3dvARB = (PFNGLMULTITEXCOORD3DVARBPROC)
wglGetProcAddress ("glMultiTexCoord3dvARB");
if (glMultiTexCoord3dvARB == NULL) {
fprintf (stderr, "glMultiTexCoord3dAvRB not found.\n");
return 0;
}
glMultiTexCoord3fARB = (PFNGLMULTITEXCOORD3FARBPROC)
wglGetProcAddress ("glMultiTexCoord3fARB");
if (glMultiTexCoord3fARB == NULL) {
fprintf (stderr, "glMultiTexCoord3fARB not found.\n");
return 0;
}
glMultiTexCoord3fvARB = (PFNGLMULTITEXCOORD3FVARBPROC)
wglGetProcAddress ("glMultiTexCoord3fvARB");
if (glMultiTexCoord3fvARB == NULL) {
fprintf (stderr, "glMultiTexCoord3fvARB not found.\n");
return 0;
}
glMultiTexCoord3iARB = (PFNGLMULTITEXCOORD3IARBPROC)
wglGetProcAddress ("glMultiTexCoord3iARB");
if (glMultiTexCoord3iARB == NULL) {
fprintf (stderr, "glMultiTexCoord3iARB not found.\n");
return 0;
}
glMultiTexCoord3ivARB = (PFNGLMULTITEXCOORD3IVARBPROC)
wglGetProcAddress ("glMultiTexCoord3ivARB");
if (glMultiTexCoord3ivARB == NULL) {
fprintf (stderr, "glMultiTexCoord3ivARB not found.\n");
return 0;
}
glMultiTexCoord3sARB = (PFNGLMULTITEXCOORD3SARBPROC)
wglGetProcAddress ("glMultiTexCoord3sARB");
if (glMultiTexCoord3sARB == NULL) {
fprintf (stderr, "glMultiTexCoord3sARB not found.\n");
return 0;
}
glMultiTexCoord3svARB = (PFNGLMULTITEXCOORD3SVARBPROC)
wglGetProcAddress ("glMultiTexCoord3svARB");
if (glMultiTexCoord3svARB == NULL) {
fprintf (stderr, "glMultiTexCoord3svARB not found.\n");
return 0;
}
glMultiTexCoord4dARB = (PFNGLMULTITEXCOORD4DARBPROC)
wglGetProcAddress ("glMultiTexCoord4dARB");
if (glMultiTexCoord4dARB == NULL) {
fprintf (stderr, "glMultiTexCoord4dARB not found.\n");
return 0;
}
glMultiTexCoord4dvARB = (PFNGLMULTITEXCOORD4DVARBPROC)
wglGetProcAddress ("glMultiTexCoord4dvARB");
if (glMultiTexCoord4dvARB == NULL) {
fprintf (stderr, "glMultiTexCoord4dAvRB not found.\n");
return 0;
}
glMultiTexCoord4fARB = (PFNGLMULTITEXCOORD4FARBPROC)
wglGetProcAddress ("glMultiTexCoord4fARB");
if (glMultiTexCoord4fARB == NULL) {
fprintf (stderr, "glMultiTexCoord4fARB not found.\n");
return 0;
}
glMultiTexCoord4fvARB = (PFNGLMULTITEXCOORD4FVARBPROC)
wglGetProcAddress ("glMultiTexCoord4fvARB");
if (glMultiTexCoord4fvARB == NULL) {
fprintf (stderr, "glMultiTexCoord4fvARB not found.\n");
return 0;
}
glMultiTexCoord4iARB = (PFNGLMULTITEXCOORD4IARBPROC)
wglGetProcAddress ("glMultiTexCoord4iARB");
if (glMultiTexCoord4iARB == NULL) {
fprintf (stderr, "glMultiTexCoord4iARB not found.\n");
return 0;
}
glMultiTexCoord4ivARB = (PFNGLMULTITEXCOORD4IVARBPROC)
wglGetProcAddress ("glMultiTexCoord4ivARB");
if (glMultiTexCoord4ivARB == NULL) {
fprintf (stderr, "glMultiTexCoord4ivARB not found.\n");
return 0;
}
glMultiTexCoord4sARB = (PFNGLMULTITEXCOORD4SARBPROC)
wglGetProcAddress ("glMultiTexCoord4sARB");
if (glMultiTexCoord4sARB == NULL) {
fprintf (stderr, "glMultiTexCoord4sARB not found.\n");
return 0;
}
glMultiTexCoord4svARB = (PFNGLMULTITEXCOORD4SVARBPROC)
wglGetProcAddress ("glMultiTexCoord4svARB");
if (glMultiTexCoord4svARB == NULL) {
fprintf (stderr, "glMultiTexCoord4svARB not found.\n");
return 0;
}
#endif // _WIN32
return 1;
}
@ -306,6 +493,8 @@ int GL_ARB_multitexture_Init(void) {
#ifdef __cplusplus
}
#endif
#endif /* */
#endif // not __ARB_MULTITEXTURE_H_

117
gst/gl/EXT_paletted_texture.h
View file

@ -19,26 +19,26 @@
#define EXT_PALETTED_TEXTURE_INITIALIZE 1 // enable generic init-routines
#ifndef _WIN32
#define GL_GLEXT_PROTOTYPES 1
#endif
#endif /* */
#ifdef __cplusplus
extern "C" {
#endif
extern "C"
{
#endif /* */
#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__)
#define WIN32_LEAN_AND_MEAN 1
#include <windows.h>
#endif
#endif /* */
#ifndef APIENTRY
#define APIENTRY
#endif
#endif /* */
// Header file version number, required by OpenGL ABI for Linux
//#define GL_GLEXT_VERSION 7
/*
* NEW TOKENS TO OPENGL 1.2.1
*
@ -60,22 +60,37 @@ extern "C" {
#define GL_COLOR_TABLE_INTENSITY_SIZE_EXT 0x80DF
#define GL_TEXTURE_INDEX_SIZE_EXT 0x80ED
#define GL_EXT_paletted_texture 1
#endif
#endif /* */
#ifndef _WIN32
#ifdef GL_GLEXT_PROTOTYPES
extern void APIENTRY glColorTableEXT (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *);
extern void APIENTRY glColorSubTableEXT(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
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 *);
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);
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
@ -87,21 +102,26 @@ PFNGLCOLORSUBTABLEEXTPROC glColorSubTableEXT = NULL;
PFNGLGETCOLORTABLEEXTPROC glGetColorTableEXT = NULL;
PFNGLGETCOLORTABLEPARAMETERIVEXTPROC glGetColorTableParameterivEXT = NULL;
PFNGLGETCOLORTABLEPARAMETERFVEXTPROC glGetColorTableParameterfvEXT = NULL;
#endif // _WIN32
int CheckForEXTPalettedTextureSupport(void) {
#endif // _WIN32
int CheckForEXTPalettedTextureSupport (void)
{
const char search[] = "GL_EXT_paletted_texture";
int i, pos = 0;
int maxpos = strlen (search) - 1;
char extensions[10000];
strcpy (extensions, (const char *) glGetString (GL_EXTENSIONS));
int len = strlen (extensions);
for (i=0; i<len; i++) {
for (i = 0; i < len; i++)
{
if ((i == 0) || ((i > 1) && extensions[i - 1] == ' ')) {
pos = 0;
while(extensions[i]!=' ') {
if (extensions[i]==search[pos]) pos++;
while (extensions[i] != ' ')
{
if (extensions[i] == search[pos])
pos++;
if ((pos > maxpos) && extensions[i + 1] == ' ') {
//printf(search);
//printf(" supported.\n");
return 1;
@ -110,25 +130,48 @@ int CheckForEXTPalettedTextureSupport(void) {
}
}
}
//printf(search);
//printf(" not supported.\n");
return 0;
}
int GL_EXT_paletted_texture_Init(void) {
if (!CheckForEXTPalettedTextureSupport()) return 0;
int GL_EXT_paletted_texture_Init (void)
{
if (!CheckForEXTPalettedTextureSupport ())
return 0;
#ifdef _WIN32
glColorTableEXT = (PFNGLCOLORTABLEEXTPROC) wglGetProcAddress("glColorTableEXT");
if (glColorTableEXT==NULL) {fprintf(stderr,"glColorTableEXT not found.\n"); return 0;}
glColorSubTableEXT = (PFNGLCOLORSUBTABLEEXTPROC) wglGetProcAddress("glColorSubTableEXT");
if (glColorSubTableEXT==NULL) {fprintf(stderr,"glColorSubTableEXT not found.\n"); return 0;}
glGetColorTableEXT = (PFNGLGETCOLORTABLEEXTPROC) wglGetProcAddress("glGetColorTableEXT");
if (glGetColorTableEXT==NULL) {fprintf(stderr,"glGetColorTableEXT not found.\n"); return 0;}
glGetColorTableParameterivEXT = (PFNGLGETCOLORTABLEPARAMETERIVEXTPROC) wglGetProcAddress("glGetColorTableParameterivEXT");
if (glGetColorTableParameterivEXT==NULL) {fprintf(stderr,"glGetColorTableParameterivEXT not found.\n"); return 0;}
glGetColorTableParameterfvEXT = (PFNGLGETCOLORTABLEPARAMETERFVEXTPROC) wglGetProcAddress("glGetColorTableParameterfvEXT");
if (glGetColorTableParameterfvEXT==NULL) {fprintf(stderr,"glGetColorTableParameterfvEXT not found.\n"); return 0;}
glColorTableEXT =
(PFNGLCOLORTABLEEXTPROC) wglGetProcAddress ("glColorTableEXT");
if (glColorTableEXT == NULL) {
fprintf (stderr, "glColorTableEXT not found.\n");
return 0;
}
glColorSubTableEXT =
(PFNGLCOLORSUBTABLEEXTPROC) wglGetProcAddress ("glColorSubTableEXT");
if (glColorSubTableEXT == NULL) {
fprintf (stderr, "glColorSubTableEXT not found.\n");
return 0;
}
glGetColorTableEXT =
(PFNGLGETCOLORTABLEEXTPROC) wglGetProcAddress ("glGetColorTableEXT");
if (glGetColorTableEXT == NULL) {
fprintf (stderr, "glGetColorTableEXT not found.\n");
return 0;
}
glGetColorTableParameterivEXT = (PFNGLGETCOLORTABLEPARAMETERIVEXTPROC)
wglGetProcAddress ("glGetColorTableParameterivEXT");
if (glGetColorTableParameterivEXT == NULL) {
fprintf (stderr, "glGetColorTableParameterivEXT not found.\n");
return 0;
}
glGetColorTableParameterfvEXT = (PFNGLGETCOLORTABLEPARAMETERFVEXTPROC)
wglGetProcAddress ("glGetColorTableParameterfvEXT");
if (glGetColorTableParameterfvEXT == NULL) {
fprintf (stderr, "glGetColorTableParameterfvEXT not found.\n");
return 0;
}
#endif // _WIN32
return 1;
}
@ -137,6 +180,8 @@ int GL_EXT_paletted_texture_Init(void) {
#ifdef __cplusplus
}
#endif
#endif /* */
#endif // not __EXT_PALETTED_TEXTURE_H_

247
gst/gl/NV_register_combiners.h
View file

@ -19,26 +19,26 @@
#define NV_REGISTER_COMBINERS_INITIALIZE 1 // enable generic init-routines
#ifndef _WIN32
#define GL_GLEXT_PROTOTYPES 1
#endif
#endif /* */
#ifdef __cplusplus
extern "C" {
#endif
extern "C"
{
#endif /* */
#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__)
#define WIN32_LEAN_AND_MEAN 1
#include <windows.h>
#endif
#endif /* */
#ifndef APIENTRY
#define APIENTRY
#endif
#endif /* */
// Header file version number, required by OpenGL ABI for Linux
//#define GL_GLEXT_VERSION 7
/*
* NEW TOKENS TO OPENGL 1.2.1
*
@ -96,7 +96,7 @@ extern "C" {
#define GL_COLOR_SUM_CLAMP_NV 0x854F
#define GL_MAX_GENERAL_COMBINERS_NV 0x854D
#define GL_NV_register_combiners 1
#endif
#endif /* */
#ifndef _WIN32
#ifdef GL_GLEXT_PROTOTYPES
@ -104,30 +104,63 @@ extern void APIENTRY glCombinerParameterfvNV(GLenum, const GLfloat *);
extern void APIENTRY glCombinerParameterivNV (GLenum, const GLint *);
extern void APIENTRY glCombinerParameterfNV (GLenum, GLfloat);
extern void APIENTRY glCombinerParameteriNV (GLenum, GLint);
extern void APIENTRY glCombinerInputNV (GLenum, GLenum, GLenum, GLenum, GLenum, GLenum);
extern void APIENTRY 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 *);
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);
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
@ -141,27 +174,38 @@ PFNGLCOMBINERPARAMETERINVPROC glCombinerParameteriNV
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
PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC glGetCombinerInputParameterfvNV =
NULL;
PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC glGetCombinerInputParameterivNV =
NULL;
PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC glGetCombinerOutputParameterfvNV =
NULL;
PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC glGetCombinerOutputParameterivNV =
NULL;
PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC
glGetFinalCombinerInputParameterfvNV = NULL;
PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC
glGetFinalCombinerInputParameterivNV = NULL;
int CheckForNVRegisterCombinersSupport(void) {
#endif // _WIN32
int CheckForNVRegisterCombinersSupport (void)
{
const char search[] = "GL_NV_register_combiners";
int i, pos = 0;
int maxpos = strlen (search) - 1;
char extensions[10000];
strcpy (extensions, (const char *) glGetString (GL_EXTENSIONS));
int len = strlen (extensions);
for (i=0; i<len; i++) {
for (i = 0; i < len; i++)
{
if ((i == 0) || ((i > 1) && extensions[i - 1] == ' ')) {
pos = 0;
while(extensions[i]!=' ') {
if (extensions[i]==search[pos]) pos++;
while (extensions[i] != ' ')
{
if (extensions[i] == search[pos])
pos++;
if ((pos > maxpos) && extensions[i + 1] == ' ') {
//printf(search);
// printf(" supported.\n");
return 1;
@ -170,41 +214,100 @@ int CheckForNVRegisterCombinersSupport(void) {
}
}
}
//printf(search);
//printf(" not supported.\n");
return 0;
}
int GL_NV_register_combiners_Init(void) {
if (!CheckForNVRegisterCombinersSupport()) return 0;
int GL_NV_register_combiners_Init (void)
{
if (!CheckForNVRegisterCombinersSupport ())
return 0;
#ifdef _WIN32
glCombinerParameterfvNV=(PFNGLCOMBINERPARAMETERFVNVPROC) wglGetProcAddress("glCombinerParameterfvNV");
if (glCombinerParameterfvNV==NULL) {fprintf(stderr,"glCombinerParameterfvNV not found.\n"); return 0;}
glCombinerParameterivNV=(PFNGLCOMBINERPARAMETERIVNVPROC) wglGetProcAddress("glCombinerParameterivNV");
if (glCombinerParameterivNV==NULL) {fprintf(stderr,"glCombinerParameterivNV not found.\n"); return 0;}
glCombinerParameterfNV=(PFNGLCOMBINERPARAMETERFNVPROC) wglGetProcAddress("glCombinerParameterfNV");
if (glCombinerParameterfvNV==NULL) {fprintf(stderr,"glCombinerParameterfNV not found.\n"); return 0;}
glCombinerParameteriNV=(PFNGLCOMBINERPARAMETERINVPROC) wglGetProcAddress("glCombinerParameteriNV");
if (glCombinerParameterivNV==NULL) {fprintf(stderr,"glCombinerParameteriNV not found.\n"); return 0;}
glCombinerInputNV=(PFNGLCOMBINERINPUTNVPROC) wglGetProcAddress("glCombinerInputNV");
if (glCombinerInputNV==NULL) {fprintf(stderr,"glCombinerInputNV not found.\n"); return 0;}
glCombinerOutputNV=(PFNGLCOMBINEROUTPUTNVPROC) wglGetProcAddress("glCombinerOutputNV");
if (glCombinerOutputNV==NULL) {fprintf(stderr,"glCombinerOutputNV not found.\n"); return 0;}
glFinalCombinerInputNV=(PFNGLFINALCOMBINERINPUTNVPROC) wglGetProcAddress("glFinalCombinerInputNV");
if (glFinalCombinerInputNV==NULL) {fprintf(stderr,"glFinalCombinerInputNV not found.\n"); return 0;}
glGetCombinerInputParameterfvNV=(PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC) wglGetProcAddress("glGetCombinerInputParameterfvNV");
if (glGetCombinerInputParameterfvNV==NULL) {fprintf(stderr,"glGetCombinerInputParameterfvNV not found.\n"); return 0;}
glGetCombinerInputParameterivNV=(PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC) wglGetProcAddress("glGetCombinerInputParameterivNV");
if (glGetCombinerInputParameterivNV==NULL) {fprintf(stderr,"glGetCombinerInputParameterivNV not found.\n"); return 0;}
glGetCombinerOutputParameterfvNV=(PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC) wglGetProcAddress("glGetCombinerOutputParameterfvNV");
if (glGetCombinerOutputParameterfvNV==NULL) {fprintf(stderr,"glGetCombinerOutputParameterfvNV not found.\n"); return 0;}
glGetCombinerOutputParameterivNV=(PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC) wglGetProcAddress("glGetCombinerOutputParameterivNV");
if (glGetCombinerOutputParameterivNV==NULL) {fprintf(stderr,"glGetCombinerOutputParameterivNV not found.\n"); return 0;}
glGetFinalCombinerInputParameterfvNV=(PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC) wglGetProcAddress("glGetFinalCombinerInputParameterfvNV");
if (glGetFinalCombinerInputParameterfvNV==NULL) {fprintf(stderr,"glGetFinalCombinerInputParameterfvNV not found.\n"); return 0;}
glGetFinalCombinerInputParameterivNV=(PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC) wglGetProcAddress("glGetFinalCombinerInputParameterivNV");
if (glGetFinalCombinerInputParameterivNV==NULL) {fprintf(stderr,"glGetFinalCombinerInputParameterivNV not found.\n"); return 0;}
glCombinerParameterfvNV = (PFNGLCOMBINERPARAMETERFVNVPROC)
wglGetProcAddress ("glCombinerParameterfvNV");
if (glCombinerParameterfvNV == NULL) {
fprintf (stderr, "glCombinerParameterfvNV not found.\n");
return 0;
}
glCombinerParameterivNV = (PFNGLCOMBINERPARAMETERIVNVPROC)
wglGetProcAddress ("glCombinerParameterivNV");
if (glCombinerParameterivNV == NULL) {
fprintf (stderr, "glCombinerParameterivNV not found.\n");
return 0;
}
glCombinerParameterfNV = (PFNGLCOMBINERPARAMETERFNVPROC)
wglGetProcAddress ("glCombinerParameterfNV");
if (glCombinerParameterfvNV == NULL) {
fprintf (stderr, "glCombinerParameterfNV not found.\n");
return 0;
}
glCombinerParameteriNV = (PFNGLCOMBINERPARAMETERINVPROC)
wglGetProcAddress ("glCombinerParameteriNV");
if (glCombinerParameterivNV == NULL) {
fprintf (stderr, "glCombinerParameteriNV not found.\n");
return 0;
}
glCombinerInputNV =
(PFNGLCOMBINERINPUTNVPROC) wglGetProcAddress ("glCombinerInputNV");
if (glCombinerInputNV == NULL) {
fprintf (stderr, "glCombinerInputNV not found.\n");
return 0;
}
glCombinerOutputNV =
(PFNGLCOMBINEROUTPUTNVPROC) wglGetProcAddress ("glCombinerOutputNV");
if (glCombinerOutputNV == NULL) {
fprintf (stderr, "glCombinerOutputNV not found.\n");
return 0;
}
glFinalCombinerInputNV = (PFNGLFINALCOMBINERINPUTNVPROC)
wglGetProcAddress ("glFinalCombinerInputNV");
if (glFinalCombinerInputNV == NULL) {
fprintf (stderr, "glFinalCombinerInputNV not found.\n");
return 0;
}
glGetCombinerInputParameterfvNV = (PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC)
wglGetProcAddress ("glGetCombinerInputParameterfvNV");
if (glGetCombinerInputParameterfvNV == NULL) {
fprintf (stderr, "glGetCombinerInputParameterfvNV not found.\n");
return 0;
}
glGetCombinerInputParameterivNV = (PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC)
wglGetProcAddress ("glGetCombinerInputParameterivNV");
if (glGetCombinerInputParameterivNV == NULL) {
fprintf (stderr, "glGetCombinerInputParameterivNV not found.\n");
return 0;
}
glGetCombinerOutputParameterfvNV =
(PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC)
wglGetProcAddress ("glGetCombinerOutputParameterfvNV");
if (glGetCombinerOutputParameterfvNV == NULL) {
fprintf (stderr, "glGetCombinerOutputParameterfvNV not found.\n");
return 0;
}
glGetCombinerOutputParameterivNV =
(PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC)
wglGetProcAddress ("glGetCombinerOutputParameterivNV");
if (glGetCombinerOutputParameterivNV == NULL) {
fprintf (stderr, "glGetCombinerOutputParameterivNV not found.\n");
return 0;
}
glGetFinalCombinerInputParameterfvNV =
(PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC)
wglGetProcAddress ("glGetFinalCombinerInputParameterfvNV");
if (glGetFinalCombinerInputParameterfvNV == NULL) {
fprintf (stderr, "glGetFinalCombinerInputParameterfvNV not found.\n");
return 0;
}
glGetFinalCombinerInputParameterivNV =
(PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC)
wglGetProcAddress ("glGetFinalCombinerInputParameterivNV");
if (glGetFinalCombinerInputParameterivNV == NULL) {
fprintf (stderr, "glGetFinalCombinerInputParameterivNV not found.\n");
return 0;
}
#endif // _WIN32
return 1;
}
@ -213,6 +316,8 @@ int GL_NV_register_combiners_Init(void) {
#ifdef __cplusplus
}
#endif
#endif /* */
#endif // not __NV_REGISTER_COMBINERS_H_

120
gst/gl/gstgl_nvimage.c
View file

@ -31,7 +31,8 @@
#include "gstglsink.h"
typedef struct _GstGLImageConnection GstGLImageConnection;
struct _GstGLImageConnection {
struct _GstGLImageConnection
{
GstImageConnection conn;
Display *dpy;
gint w, h;
@ -59,25 +60,33 @@ struct _GstNvImage
};
static GstGLImageInfo *gst_gl_nvimage_info (GstImageInfo * info);
static GstGLImageConnection * gst_gl_nvimage_connection (GstImageConnection *conn);
static GstGLImageConnection *gst_gl_nvimage_connection (GstImageConnection *
conn);
static gboolean gst_gl_nvimage_check_xvideo ();
static GstCaps *gst_gl_nvimage_get_caps (GstImageInfo * info);
static GstImageConnection * gst_gl_nvimage_set_caps (GstImageInfo *info, GstCaps *caps);
static GstImageData * gst_gl_nvimage_get_image (GstImageInfo *info, GstImageConnection *conn);
static void gst_gl_nvimage_put_image (GstImageInfo *info, GstImageData *image);
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_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)
GstImagePlugin *
get_gl_nvimage_plugin (void)
{
static GstImagePlugin plugin = { gst_gl_nvimage_get_caps,
gst_gl_nvimage_set_caps,
gst_gl_nvimage_get_image,
gst_gl_nvimage_put_image,
gst_gl_nvimage_free_image};
gst_gl_nvimage_free_image
};
return &plugin;
}
@ -86,8 +95,7 @@ GstImagePlugin* get_gl_nvimage_plugin(void)
static GstGLImageInfo *
gst_gl_nvimage_info (GstImageInfo * info)
{
if (info == NULL || info->id != GST_MAKE_FOURCC ('X', 'l', 'i', 'b'))
{
if (info == NULL || info->id != GST_MAKE_FOURCC ('X', 'l', 'i', 'b')) {
return NULL;
}
return (GstGLImageInfo *) info;
@ -106,9 +114,12 @@ gst_gl_nvimage_check_xvideo ()
{
//int ver, rel, req, ev, err;
printf ("Checking NVidia OpenGL extensions.\n");
if (!GL_ARB_multitexture_Init()) return FALSE;
if (!GL_EXT_paletted_texture_Init()) return FALSE;
if (!GL_NV_register_combiners_Init()) return FALSE;
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)
@ -129,22 +140,20 @@ gst_gl_nvimage_get_caps (GstImageInfo *info)
GstCaps *caps = NULL;
GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
g_warning("nvimage get caps called, context %p !\n", glXGetCurrentContext());
g_warning ("nvimage get caps called, context %p !\n",
glXGetCurrentContext ());
/* we don't handle these image information */
if (xinfo == NULL)
{
if (xinfo == NULL) {
printf ("Invalid XInfo struct !\n");
return NULL;
}
if (gst_gl_nvimage_check_xvideo () == FALSE)
{
if (gst_gl_nvimage_check_xvideo () == FALSE) {
g_warning ("GL_NVImage: Server has no NVidia extension support\n");
return NULL;
}
caps = gst_caps_append (caps, GST_CAPS_NEW (
"nvimage_caps",
caps = gst_caps_append (caps, GST_CAPS_NEW ("nvimage_caps",
"video/x-raw-yuv",
"format", GST_PROPS_FOURCC (GST_MAKE_FOURCC ('Y', 'V', '1', '2')),
"width", GST_PROPS_INT_RANGE (0, 1024),
@ -165,7 +174,8 @@ gst_gl_nvimage_set_caps (GstImageInfo *info, GstCaps *caps)
guint32 format;
/* we don't handle these image information */
if (xinfo == NULL) return NULL;
if (xinfo == NULL)
return NULL;
conn = g_new0 (GstGLImageConnection, 1);
conn->conn.open_conn = gst_gl_nvimage_open_conn;
@ -173,14 +183,10 @@ gst_gl_nvimage_set_caps (GstImageInfo *info, GstCaps *caps)
conn->conn.free_conn = gst_gl_nvimage_free_conn;
gst_caps_get (caps,
"width", &conn->w,
"height", &conn->h,
"format", &format,
NULL);
"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'))
{
if (format != GST_MAKE_FOURCC ('Y', 'V', '1', '2')) {
GST_DEBUG ("GL_NVImage: Format is invalid !\n");
return NULL;
}
@ -203,8 +209,10 @@ gst_gl_nvimage_get_image (GstImageInfo *info, GstImageConnection *conn)
GstGLImageConnection *nvconn = gst_gl_nvimage_connection (conn);
/* checks */
if (xinfo == NULL) return NULL;
if (nvconn == NULL) return NULL;
if (xinfo == NULL)
return NULL;
if (nvconn == NULL)
return NULL;
// I should also check the current GLX context !
// Ah, Don't have to, I am guarantueed to be in the same thread as put_image
@ -219,8 +227,7 @@ gst_gl_nvimage_get_image (GstImageInfo *info, GstImageConnection *conn)
image->conn = nvconn;
if (image->data.data == NULL)
{
if (image->data.data == NULL) {
g_warning ("GL_NvImage: data allocation failed!");
g_free (image);
return NULL;
@ -256,8 +263,7 @@ gst_gl_nvimage_put_image (GstImageInfo *info, GstImageData *image)
glTranslatef (0.0, 0.0, -5.0);
glDisable (GL_TEXTURE_2D);
if (xinfo->info.demo)
{
if (xinfo->info.demo) {
//g_print("Putting image, context is %p\n", glXGetCurrentContext());
glTranslatef (0.0, 0.0, -5.0); // make it avoid the clipping plane, zoom 2.0 instead
@ -267,6 +273,7 @@ gst_gl_nvimage_put_image (GstImageInfo *info, GstImageData *image)
xinfo->rotX += 0.01;
xinfo->rotY -= 0.015;
float zoom = xinfo->zoom;
glScalef (zoom, zoom, zoom);
//glScalef(0.1,0.1,0.1);
@ -278,16 +285,18 @@ gst_gl_nvimage_put_image (GstImageInfo *info, GstImageData *image)
xinfo->zoom += xinfo->zoomdir;
}
//Draws the surface rectangle
if (Ywidth != im->conn->w || Yheight != im->conn->h)
{
Ywidth = im->conn->w; Yheight = im->conn->h; UVwidth = im->conn->w/2; UVheight = im->conn->h/2;
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);
LoadYUVPlanes (Yhandle, Uhandle, Vhandle, img_width, img_height, uv_width,
uv_height, buf_y, buf_u, buf_v);
float xmax = (float) (im->conn->w - 1) / tex_xsize;
float ymax = (float) (im->conn->h - 1) / tex_ysize;
@ -324,8 +333,7 @@ gst_gl_nvimage_put_image (GstImageInfo *info, GstImageData *image)
glEnd ();
if (xinfo->info.dumpvideo)
{
if (xinfo->info.dumpvideo) {
static int framenr = 0;
char capfilename[255];
static guint8 *cap_image_data = NULL, *cap_image_data2 = NULL;
@ -339,20 +347,23 @@ gst_gl_nvimage_put_image (GstImageInfo *info, GstImageData *image)
cap_image_data2 = (guint8 *) malloc (img_width * img_height * 3);
printf ("Recording frame #%d\n", framenr);
glReadPixels(0,0,img_width,img_height,GL_RGB,GL_UNSIGNED_BYTE,cap_image_data);
glReadPixels (0, 0, img_width, img_height, GL_RGB, GL_UNSIGNED_BYTE,
cap_image_data);
// invert the pixels
for (i = 0; i < img_height; i++)
memcpy(cap_image_data2 + i * img_width * 3, cap_image_data + (img_height-1-i) * img_width * 3, img_width*3);
memcpy (cap_image_data2 + i * img_width * 3,
cap_image_data + (img_height - 1 - i) * img_width * 3, img_width * 3);
sprintf (capfilename, "cap%04d.ppm", framenr);
FILE *outfile = fopen (capfilename, "wb");
if (outfile != NULL)
{
if (outfile != NULL) {
fprintf (outfile, "P6\n");
fprintf (outfile, "# created by glsink from GStreamer\n");
fprintf (outfile, "%d %d\n", img_width, img_height);
fprintf (outfile, "255\n");
fwrite(cap_image_data2, sizeof(char), img_width*img_height*3, outfile);
fwrite (cap_image_data2, sizeof (char), img_width * img_height * 3,
outfile);
fclose (outfile);
}
framenr++;
@ -366,14 +377,13 @@ static void
gst_gl_nvimage_free_image (GstImageData * image)
{
GstNvImage *im = (GstNvImage *) image;
g_return_if_fail (im != NULL);
GstGLImageConnection *nvconn = im->conn;
if (im->slot < AGP_BUFSLOTS)
{
if (im->slot < AGP_BUFSLOTS) {
nvconn->m_bufslots[im->slot] = 0;
}
else
} else
g_free (im->data.data);
g_free (im);
@ -385,9 +395,13 @@ gst_gl_nvimage_open_conn (GstImageConnection *conn, GstImageInfo *info)
//GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
//GstGLImageConnection *xconn = gst_gl_nvimage_connection (conn);
g_print("Opening NVidia connection; OpenGL on Nvidia, using register combiners.\n");
g_print
("Opening NVidia connection; OpenGL on Nvidia, using register combiners.\n");
{
Ywidth = TEX_XSIZE; Yheight = TEX_YSIZE; UVwidth = TEX_XSIZE/2; UVheight = TEX_YSIZE/2;
Ywidth = TEX_XSIZE;
Yheight = TEX_YSIZE;
UVwidth = TEX_XSIZE / 2;
UVheight = TEX_YSIZE / 2;
Initialize_Backend (Ywidth, Yheight, UVwidth, UVheight, GL_LINEAR);
}
g_print ("Done\n");
@ -397,6 +411,7 @@ static void
gst_gl_nvimage_close_conn (GstImageConnection * conn, GstImageInfo * info)
{
GstGLImageConnection *xconn = gst_gl_nvimage_connection (conn);
//GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
// anything needed in here ? Oh, maybe drawing de-init, or something
@ -412,4 +427,3 @@ gst_gl_nvimage_free_conn (GstImageConnection *conn)
g_free (nvconn);
}

107
gst/gl/gstgl_pdrimage.c
View file

@ -31,7 +31,8 @@
#include "gstglsink.h"
typedef struct _GstGLImageConnection GstGLImageConnection;
struct _GstGLImageConnection {
struct _GstGLImageConnection
{
GstImageConnection conn;
Display *dpy;
gint w, h;
@ -59,25 +60,33 @@ struct _GstNvImage
};
static GstGLImageInfo *gst_gl_nvimage_info (GstImageInfo * info);
static GstGLImageConnection * gst_gl_nvimage_connection (GstImageConnection *conn);
static GstGLImageConnection *gst_gl_nvimage_connection (GstImageConnection *
conn);
static gboolean gst_gl_nvimage_check_xvideo ();
static GstCaps *gst_gl_nvimage_get_caps (GstImageInfo * info);
static GstImageConnection * gst_gl_nvimage_set_caps (GstImageInfo *info, GstCaps *caps);
static GstImageData * gst_gl_nvimage_get_image (GstImageInfo *info, GstImageConnection *conn);
static void gst_gl_nvimage_put_image (GstImageInfo *info, GstImageData *image);
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_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)
GstImagePlugin *
get_gl_nvimage_plugin (void)
{
static GstImagePlugin plugin = { gst_gl_nvimage_get_caps,
gst_gl_nvimage_set_caps,
gst_gl_nvimage_get_image,
gst_gl_nvimage_put_image,
gst_gl_nvimage_free_image};
gst_gl_nvimage_free_image
};
return &plugin;
}
@ -86,8 +95,7 @@ GstImagePlugin* get_gl_nvimage_plugin(void)
static GstGLImageInfo *
gst_gl_nvimage_info (GstImageInfo * info)
{
if (info == NULL || info->id != GST_MAKE_FOURCC ('X', 'l', 'i', 'b'))
{
if (info == NULL || info->id != GST_MAKE_FOURCC ('X', 'l', 'i', 'b')) {
return NULL;
}
return (GstGLImageInfo *) info;
@ -126,16 +134,15 @@ gst_gl_nvimage_get_caps (GstImageInfo *info)
GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
/* we don't handle these image information */
if (xinfo == NULL) return NULL;
if (xinfo == NULL)
return NULL;
if (gst_gl_nvimage_check_xvideo () == FALSE)
{
if (gst_gl_nvimage_check_xvideo () == FALSE) {
g_warning ("GL_NVImage: Server has no NVidia extension support\n");
return NULL;
}
caps = gst_caps_append (caps, GST_CAPS_NEW (
"xvimage_caps",
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),
@ -155,7 +162,8 @@ gst_gl_nvimage_set_caps (GstImageInfo *info, GstCaps *caps)
guint32 format;
/* we don't handle these image information */
if (xinfo == NULL) return NULL;
if (xinfo == NULL)
return NULL;
conn = g_new0 (GstGLImageConnection, 1);
conn->conn.open_conn = gst_gl_nvimage_open_conn;
@ -163,14 +171,10 @@ gst_gl_nvimage_set_caps (GstImageInfo *info, GstCaps *caps)
conn->conn.free_conn = gst_gl_nvimage_free_conn;
gst_caps_get (caps,
"width", &conn->w,
"height", &conn->h,
"format", &format,
NULL);
"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', ' '))
{
if (format != GST_MAKE_FOURCC ('R', 'G', 'B', ' ')) {
GST_DEBUG (GST_CAT_PLUGIN_INFO, "GL_NVImage: Format is invalid !\n");
return NULL;
}
@ -181,7 +185,8 @@ gst_gl_nvimage_set_caps (GstImageInfo *info, GstCaps *caps)
return NULL;
}
GST_DEBUG (GST_CAT_PLUGIN_INFO, "GL_NVImage: caps %p are ok, creating image", caps);
GST_DEBUG (GST_CAT_PLUGIN_INFO, "GL_NVImage: caps %p are ok, creating image",
caps);
return (GstImageConnection *) conn;
}
@ -194,17 +199,19 @@ gst_gl_nvimage_get_image (GstImageInfo *info, GstImageConnection *conn)
int slot = 0;
/* checks */
if (xinfo == NULL) return NULL;
if (nvconn == NULL) return NULL;
if (xinfo == NULL)
return NULL;
if (nvconn == NULL)
return NULL;
// I should also check the current GLX context !
// Ah, Don't have to, I am guarantueed to always be in the same thread
image = g_new0 (GstNvImage, 1);
for (slot = 0; slot < AGP_BUFSLOTS; slot++)
{
if (!nvconn->m_bufslots[slot]) break;
for (slot = 0; slot < AGP_BUFSLOTS; slot++) {
if (!nvconn->m_bufslots[slot])
break;
}
image->data.size = nvconn->w * nvconn->h * 3 / 2;
@ -214,17 +221,14 @@ gst_gl_nvimage_get_image (GstImageInfo *info, GstImageConnection *conn)
image->data.data = nvconn->m_memory + slot * YUVTEX_SIZE;
image->slot = slot; // store for freeing
nvconn->m_bufslots[slot] = 1; // it is now taken
}
else
{
} else {
g_warning ("Allocating from main memory !");
image->data.data = g_malloc (image->data.size);
image->slot = AGP_BUFSLOTS; // no AGP slot
}
image->conn = nvconn;
if (image->data.data == NULL)
{
if (image->data.data == NULL) {
g_warning ("GL_NvImage: data allocation failed!");
g_free (image);
return NULL;
@ -255,6 +259,7 @@ gst_gl_nvimage_put_image (GstImageInfo *info, GstImageData *image)
glRotatef (xinfo->rotX - 250, 1, 0, 0);
glRotatef (xinfo->rotY, 0, 1, 0);
int zoom = xinfo->zoom;
glScaled (zoom, zoom, zoom);
//Draws the surface rectangle
@ -292,14 +297,13 @@ static void
gst_gl_nvimage_free_image (GstImageData * image)
{
GstNvImage *im = (GstNvImage *) image;
g_return_if_fail (im != NULL);
GstGLImageConnection *nvconn = im->conn;
if (im->slot < AGP_BUFSLOTS)
{
if (im->slot < AGP_BUFSLOTS) {
nvconn->m_bufslots[im->slot] = 0;
}
else
} else
g_free (im->data.data);
g_free (im);
@ -315,18 +319,19 @@ gst_gl_nvimage_open_conn (GstImageConnection *conn, GstImageInfo *info)
int slot;
g_warning ("Opening NVidia Connection");
xconn->m_memory = (unsigned char*)glXAllocateMemoryNV(AGP_BUFSLOTS*YUVTEX_SIZE, 0, 1.0, 1.0);
xconn->m_memory =
(unsigned char *) glXAllocateMemoryNV (AGP_BUFSLOTS * YUVTEX_SIZE, 0, 1.0,
1.0);
if (!xconn->m_memory)
{
printf("Unable to acquire graphics card mem... will acquire in normal memory.\n");
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
{
} else {
// maybe this fast writable memory, awfully slow to read from, though
glPixelDataRangeNV(GL_WRITE_PIXEL_DATA_RANGE_NV, AGP_BUFSLOTS*YUVTEX_SIZE, xconn->m_memory);
glPixelDataRangeNV (GL_WRITE_PIXEL_DATA_RANGE_NV,
AGP_BUFSLOTS * YUVTEX_SIZE, xconn->m_memory);
glEnableClientState (GL_WRITE_PIXEL_DATA_RANGE_NV);
for (slot = 0; slot < AGP_BUFSLOTS; slot++)
@ -341,13 +346,15 @@ gst_gl_nvimage_open_conn (GstImageConnection *conn, GstImageInfo *info)
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE8_ALPHA8, TEX_XSIZE, TEX_YSIZE, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, NULL);
glTexImage2D (GL_TEXTURE_2D, 0, GL_LUMINANCE8_ALPHA8, TEX_XSIZE, TEX_YSIZE, 0,
GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, NULL);
glActiveTextureARB (GL_TEXTURE1_ARB);
glGenTextures (1, &xconn->uvtex_id);
glBindTexture (GL_TEXTURE_2D, xconn->uvtex_id);
glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE8_ALPHA8, TEX_XSIZE/2, TEX_YSIZE/2, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, NULL);
glTexImage2D (GL_TEXTURE_2D, 0, GL_LUMINANCE8_ALPHA8, TEX_XSIZE / 2,
TEX_YSIZE / 2, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, NULL);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
@ -358,7 +365,8 @@ gst_gl_nvimage_open_conn (GstImageConnection *conn, GstImageInfo *info)
glGenTextures (1, &xconn->septex_id);
glBindTexture (GL_TEXTURE_2D, xconn->septex_id);
glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE8, 2, 2, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, data_sep);
glTexImage2D (GL_TEXTURE_2D, 0, GL_LUMINANCE8, 2, 2, 0, GL_LUMINANCE,
GL_UNSIGNED_BYTE, data_sep);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
@ -395,4 +403,3 @@ gst_gl_nvimage_free_conn (GstImageConnection *conn)
g_free (nvconn);
}

107
gst/gl/gstgl_rgbimage.c
View file

@ -29,7 +29,8 @@
typedef struct _GstGLImageConnection GstGLImageConnection;
// this contains everything to draw an image, including all necessary graphics card data.
struct _GstGLImageConnection {
struct _GstGLImageConnection
{
GstImageConnection conn;
Display *dpy; // the Xlib drawing context
GLXContext ctx; // The GLX drawing context
@ -52,24 +53,32 @@ struct _GstGLImage
};
static GstGLImageInfo *gst_gl_rgbimage_info (GstImageInfo * info);
static GstGLImageConnection * gst_gl_rgbimage_connection (GstImageConnection *conn);
static GstGLImageConnection *gst_gl_rgbimage_connection (GstImageConnection *
conn);
static GstCaps *gst_gl_rgbimage_get_caps (GstImageInfo * info);
static GstImageConnection * gst_gl_rgbimage_set_caps (GstImageInfo *info, GstCaps *caps);
static GstImageData * gst_gl_rgbimage_get_image (GstImageInfo *info, GstImageConnection *conn);
static void gst_gl_rgbimage_put_image (GstImageInfo *info, GstImageData *image);
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_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)
GstImagePlugin *
get_gl_rgbimage_plugin (void)
{
static GstImagePlugin plugin = { gst_gl_rgbimage_get_caps,
gst_gl_rgbimage_set_caps,
gst_gl_rgbimage_get_image,
gst_gl_rgbimage_put_image,
gst_gl_rgbimage_free_image};
gst_gl_rgbimage_free_image
};
return &plugin;
}
@ -77,8 +86,7 @@ GstImagePlugin* get_gl_rgbimage_plugin(void)
static GstGLImageInfo *
gst_gl_rgbimage_info (GstImageInfo * info)
{
if (info == NULL || info->id != GST_MAKE_FOURCC ('X', 'l', 'i', 'b'))
{
if (info == NULL || info->id != GST_MAKE_FOURCC ('X', 'l', 'i', 'b')) {
return NULL;
}
return (GstGLImageInfo *) info;
@ -102,9 +110,11 @@ gst_gl_rgbimage_get_caps (GstImageInfo *info)
XImage *ximage;
GstGLImageInfo *xinfo = gst_gl_rgbimage_info (info);
g_warning("rgbimage get caps called, context %p, endianness %d !\n", glXGetCurrentContext(), G_BIG_ENDIAN);
g_warning ("rgbimage get caps called, context %p, endianness %d !\n",
glXGetCurrentContext (), G_BIG_ENDIAN);
/* we don't handle this image information */
if (xinfo == NULL) return NULL;
if (xinfo == NULL)
return NULL;
XGetWindowAttributes (xinfo->dpy, xinfo->win, &attrib);
@ -121,17 +131,12 @@ gst_gl_rgbimage_get_caps (GstImageInfo *info)
100, 100, xpad, (attrib.depth + 7) / 8 * 100);
if (ximage != NULL) {
caps =
GST_CAPS_NEW (
"forcing Video RGB",
"video/x-raw-rgb",
"format", GST_PROPS_FOURCC (GST_STR_FOURCC ("RGB ")),
"depth", GST_PROPS_INT(24),
"bpp", GST_PROPS_INT(24),
"red_mask", GST_PROPS_INT(0xff),
"green_mask", GST_PROPS_INT(0xff00),
"blue_mask", GST_PROPS_INT(0xff0000),
"endianness", GST_PROPS_INT(G_BIG_ENDIAN), /*= 1234/4321 (INT) <- endianness */
GST_CAPS_NEW ("forcing Video RGB", "video/x-raw-rgb", "format",
GST_PROPS_FOURCC (GST_STR_FOURCC ("RGB ")), "depth", GST_PROPS_INT (24),
"bpp", GST_PROPS_INT (24), "red_mask", GST_PROPS_INT (0xff),
"green_mask", GST_PROPS_INT (0xff00), "blue_mask",
GST_PROPS_INT (0xff0000), "endianness", GST_PROPS_INT (G_BIG_ENDIAN),
/*= 1234/4321 (INT) <- endianness */
"width", GST_PROPS_INT_RANGE (0, TEX_XSIZE), /* can't have videos larger than TEX_SIZE */
"height", GST_PROPS_INT_RANGE (0, TEX_YSIZE)
);
@ -158,7 +163,8 @@ gst_gl_rgbimage_set_caps (GstImageInfo *info, GstCaps *caps)
gint width, height, bpp;
/* check if this is the right image info */
if (xinfo == NULL) return NULL;
if (xinfo == NULL)
return NULL;
XGetWindowAttributes (xinfo->dpy, xinfo->win, &attrib);
@ -171,13 +177,11 @@ gst_gl_rgbimage_set_caps (GstImageInfo *info, GstCaps *caps)
"red_mask", &red_mask,
"green_mask", &green_mask,
"blue_mask", &blue_mask,
"width", &width,
"height", &height,
"bpp", &bpp,
NULL);
"width", &width, "height", &height, "bpp", &bpp, NULL);
/* check if the caps are ok */
if (format != GST_MAKE_FOURCC ('R', 'G', 'B', ' ')) return NULL;
if (format != GST_MAKE_FOURCC ('R', 'G', 'B', ' '))
return NULL;
/* if (gst_caps_get_int (caps, "bpp") != ???) return NULL; */
//if (depth != attrib.depth) return NULL;
//if (endianness != ((ImageByteOrder (xinfo->dpy) == LSBFirst) ? G_LITTLE_ENDIAN : G_BIG_ENDIAN)) return NULL;
@ -203,6 +207,7 @@ static GstImageData *
gst_gl_rgbimage_get_image (GstImageInfo * info, GstImageConnection * conn)
{
GstGLImage *image;
//XWindowAttributes attrib;
GstGLImageInfo *xinfo = gst_gl_rgbimage_info (info);
GstGLImageConnection *xconn = gst_gl_rgbimage_connection (conn);
@ -210,10 +215,11 @@ gst_gl_rgbimage_get_image (GstImageInfo *info, GstImageConnection *conn)
image = g_new (GstGLImage, 1);
/* checks */
if (xinfo == NULL) return NULL;
if (xconn == NULL) return NULL;
if (xinfo->dpy != xconn->dpy)
{
if (xinfo == NULL)
return NULL;
if (xconn == NULL)
return NULL;
if (xinfo->dpy != xconn->dpy) {
g_warning ("XImage: wrong x display specified in 'get_image'\n");
return NULL;
}
@ -221,8 +227,7 @@ gst_gl_rgbimage_get_image (GstImageInfo *info, GstImageConnection *conn)
image->conn = xconn;
image->data.size = xconn->w * xconn->h * 4;
image->data.data = g_malloc (image->data.size);
if (image->data.data == NULL)
{
if (image->data.data == NULL) {
g_warning ("GL_RGBImage: data allocation failed!");
g_free (image);
return NULL;
@ -254,8 +259,7 @@ gst_gl_rgbimage_put_image (GstImageInfo *info, GstImageData *image)
glEnable (GL_TEXTURE_2D);
if (xinfo->info.demo)
{
if (xinfo->info.demo) {
glTranslatef (0.0, 0.0, -5.0); // make it avoid the clipping plane, zoom 2.0 instead
glRotatef (180.0 * sin (xinfo->rotX), 1, 0, 0);
glRotatef (180.0 * cos (xinfo->rotY), 0, 1, 0);
@ -263,6 +267,7 @@ gst_gl_rgbimage_put_image (GstImageInfo *info, GstImageData *image)
xinfo->rotX += 0.01;
xinfo->rotY -= 0.015;
float zoom = xinfo->zoom;
glScalef (zoom, zoom, zoom);
if (xinfo->zoom > 2.0)
@ -273,7 +278,6 @@ gst_gl_rgbimage_put_image (GstImageInfo *info, GstImageData *image)
xinfo->zoom += xinfo->zoomdir;
}
//Draws the surface rectangle
glBindTexture (GL_TEXTURE_2D, im->conn->rgbatex_id);
glTexSubImage2D (GL_TEXTURE_2D, 0, 0, 0, im->conn->w, im->conn->h, GL_RGB,
@ -302,8 +306,7 @@ gst_gl_rgbimage_put_image (GstImageInfo *info, GstImageData *image)
glVertex3f (hor, -1, 0);
glEnd ();
if (xinfo->info.dumpvideo)
{
if (xinfo->info.dumpvideo) {
static int framenr = 0;
char capfilename[255];
static guint8 *cap_image_data = NULL, *cap_image_data2 = NULL;
@ -317,20 +320,23 @@ gst_gl_rgbimage_put_image (GstImageInfo *info, GstImageData *image)
cap_image_data2 = (guint8 *) malloc (img_width * img_height * 3);
printf ("Recording frame #%d\n", framenr);
glReadPixels(0,0,img_width,img_height,GL_RGB,GL_UNSIGNED_BYTE,cap_image_data);
glReadPixels (0, 0, img_width, img_height, GL_RGB, GL_UNSIGNED_BYTE,
cap_image_data);
// invert the pixels
for (i = 0; i < img_height; i++)
memcpy(cap_image_data2 + i * img_width * 3, cap_image_data + (img_height-1-i) * img_width * 3, img_width*3);
memcpy (cap_image_data2 + i * img_width * 3,
cap_image_data + (img_height - 1 - i) * img_width * 3, img_width * 3);
sprintf (capfilename, "cap%04d.ppm", framenr);
FILE *outfile = fopen (capfilename, "wb");
if (outfile != NULL)
{
if (outfile != NULL) {
fprintf (outfile, "P6\n");
fprintf (outfile, "# created by raw_zb\n");
fprintf (outfile, "%d %d\n", img_width, img_height);
fprintf (outfile, "255\n");
fwrite(cap_image_data2, sizeof(char), img_width*img_height*3, outfile);
fwrite (cap_image_data2, sizeof (char), img_width * img_height * 3,
outfile);
fclose (outfile);
}
framenr++;
@ -344,7 +350,8 @@ gst_gl_rgbimage_free_image (GstImageData *image)
{
GstGLImage *im = (GstGLImage *) image;
g_warning ("gst_gl_rgbimage_free_image doesn't do anything yet -> freeing image\n");
g_warning
("gst_gl_rgbimage_free_image doesn't do anything yet -> freeing image\n");
g_free (im->data.data);
g_free (im);
}
@ -366,7 +373,8 @@ gst_gl_rgbimage_open_conn (GstImageConnection *conn, GstImageInfo *info)
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, TEX_XSIZE, TEX_YSIZE, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, TEX_XSIZE, TEX_YSIZE, 0, GL_RGBA,
GL_UNSIGNED_BYTE, NULL);
}
/* Deletes the creates OpenGL textures */
@ -374,6 +382,7 @@ static void
gst_gl_rgbimage_close_conn (GstImageConnection * conn, GstImageInfo * info)
{
GstGLImageConnection *xconn = gst_gl_rgbimage_connection (conn);
//GstGLImageInfo *xinfo = gst_gl_rgbimage_info (info);
glDeleteTextures (1, &xconn->rgbatex_id);
@ -388,5 +397,3 @@ gst_gl_rgbimage_free_conn (GstImageConnection *conn)
g_free (xconn);
}

158
gst/gl/gstglsink.c
View file

@ -66,12 +66,14 @@ GST_PAD_TEMPLATE_FACTORY (gst_glsink_sink_template_factory,
)
/* glsink signals and args */
enum {
enum
{
LAST_SIGNAL
};
enum {
enum
{
ARG_0,
ARG_WIDTH,
ARG_HEIGHT,
@ -94,7 +96,8 @@ enum {
typedef struct _GstGLSink GstGLSink;
typedef struct _GstGLSinkClass GstGLSinkClass;
struct _GstGLSink {
struct _GstGLSink
{
GstElement element;
GstPad *sinkpad;
@ -120,7 +123,8 @@ struct _GstGLSink {
GstImageInfo *hook;
};
struct _GstGLSinkClass {
struct _GstGLSinkClass
{
GstElementClass parent_class;
/* plugins */
@ -132,12 +136,15 @@ static GType gst_glsink_get_type (void);
static void gst_glsink_base_init (gpointer g_class);
static void gst_glsink_class_init (GstGLSinkClass * klass);
static void gst_glsink_init (GstGLSink * sink);
/* static void gst_glsink_dispose (GObject *object); */
static void gst_glsink_chain (GstPad * pad, GstData * _data);
static void gst_glsink_set_clock (GstElement * element, GstClock * clock);
static GstElementStateReturn gst_glsink_change_state (GstElement *element);
static GstPadLinkReturn gst_glsink_sinkconnect (GstPad *pad, GstCaps *caps);
static GstElementStateReturn gst_glsink_change_state (GstElement *
element);
static GstPadLinkReturn gst_glsink_sinkconnect (GstPad * pad,
GstCaps * caps);
static GstCaps *gst_glsink_getcaps (GstPad * pad, GstCaps * caps);
static void gst_glsink_set_property (GObject * object, guint prop_id,
@ -146,12 +153,14 @@ static void gst_glsink_get_property (GObject *object, guint prop_id,
GValue * value, GParamSpec * pspec);
static void gst_glsink_release_conn (GstGLSink * sink);
static void gst_glsink_append_cache (GstGLSink *sink, GstImageData *image);
static void gst_glsink_append_cache (GstGLSink * sink,
GstImageData * image);
static gboolean gst_glsink_set_caps (GstGLSink * sink, GstCaps * caps);
/* prototypes from plugins */
extern GstImagePlugin *get_gl_rgbimage_plugin (void);
extern GstImagePlugin *get_gl_nvimage_plugin (void);
/* default output */
extern void gst_glxwindow_new (GstGLSink * sink);
extern void gst_glxwindow_hook_context (GstImageInfo * info);
@ -161,10 +170,10 @@ extern void gst_glxwindow_unhook_context (GstImageInfo *info);
static GstPadTemplate *sink_template;
static GstElementClass *parent_class = NULL;
/* static guint gst_glsink_signals[LAST_SIGNAL] = { 0 }; */
static GType
gst_glsink_get_type (void)
static GType gst_glsink_get_type (void)
{
static GType videosink_type = 0;
@ -180,7 +189,9 @@ gst_glsink_get_type (void)
0,
(GInstanceInitFunc) gst_glsink_init,
};
videosink_type = g_type_register_static(GST_TYPE_ELEMENT, "GstGLSink", &videosink_info, 0);
videosink_type =
g_type_register_static (GST_TYPE_ELEMENT, "GstGLSink", &videosink_info,
0);
}
return videosink_type;
}
@ -192,8 +203,7 @@ gst_glsink_base_init (gpointer g_class)
gst_element_class_set_details (element_class, &gst_glsink_details);
gst_element_class_add_pad_template (
element_class,
gst_element_class_add_pad_template (element_class,
GST_PAD_TEMPLATE_GET (gst_glsink_sink_template_factory));
}
@ -208,28 +218,25 @@ gst_glsink_class_init (GstGLSinkClass *klass)
parent_class = g_type_class_ref (GST_TYPE_ELEMENT);
g_object_class_install_property (gobject_class, ARG_WIDTH,
g_param_spec_int ("width", "Width", "The video width",
G_MININT, G_MAXINT, 0, G_PARAM_READABLE)); /* CHECKME */
g_object_class_install_property (gobject_class, ARG_HEIGHT,
g_param_spec_int ("height", "Height", "The video height",
G_MININT, G_MAXINT, 0, G_PARAM_READABLE)); /* CHECKME */
g_object_class_install_property (gobject_class, ARG_FRAMES_DISPLAYED,
g_param_spec_int ("frames_displayed", "Frames Displayed", "The number of frames displayed so far",
G_MININT,G_MAXINT, 0, G_PARAM_READWRITE)); /* CHECKME */
g_object_class_install_property (gobject_class, ARG_FRAME_TIME,
g_param_spec_int ("frame_time", "Frame time", "The interval between frames",
G_MININT, G_MAXINT, 0, G_PARAM_READWRITE)); /* CHECKME */
g_object_class_install_property (gobject_class, ARG_WIDTH, g_param_spec_int ("width", "Width", "The video width", G_MININT, G_MAXINT, 0, G_PARAM_READABLE)); /* CHECKME */
g_object_class_install_property (gobject_class, ARG_HEIGHT, g_param_spec_int ("height", "Height", "The video height", G_MININT, G_MAXINT, 0, G_PARAM_READABLE)); /* CHECKME */
g_object_class_install_property (gobject_class, ARG_FRAMES_DISPLAYED, g_param_spec_int ("frames_displayed", "Frames Displayed", "The number of frames displayed so far", G_MININT, G_MAXINT, 0, G_PARAM_READWRITE)); /* CHECKME */
g_object_class_install_property (gobject_class, ARG_FRAME_TIME, g_param_spec_int ("frame_time", "Frame time", "The interval between frames", G_MININT, G_MAXINT, 0, G_PARAM_READWRITE)); /* CHECKME */
g_object_class_install_property (gobject_class, ARG_HOOK,
g_param_spec_pointer ("hook", "Hook", "The object receiving the output", G_PARAM_WRITABLE));
g_param_spec_pointer ("hook", "Hook", "The object receiving the output",
G_PARAM_WRITABLE));
g_object_class_install_property (gobject_class, ARG_MUTE,
g_param_spec_boolean ("mute", "Mute", "mute the output ?", FALSE, G_PARAM_READWRITE));
g_param_spec_boolean ("mute", "Mute", "mute the output ?", FALSE,
G_PARAM_READWRITE));
g_object_class_install_property (gobject_class, ARG_REPAINT,
g_param_spec_boolean ("repaint", "Repaint", "repaint the current frame", FALSE, G_PARAM_WRITABLE));
g_param_spec_boolean ("repaint", "Repaint", "repaint the current frame",
FALSE, G_PARAM_WRITABLE));
g_object_class_install_property (gobject_class, ARG_DEMO,
g_param_spec_int ("demo", "Demo", "demo mode (shows 3D capabilities)",0, 1, 0, G_PARAM_READWRITE));
g_param_spec_int ("demo", "Demo", "demo mode (shows 3D capabilities)", 0,
1, 0, G_PARAM_READWRITE));
g_object_class_install_property (gobject_class, ARG_DUMP,
g_param_spec_boolean ("dump", "Dump", "stores sequence of frames in .ppm files", FALSE, G_PARAM_READWRITE));
g_param_spec_boolean ("dump", "Dump",
"stores sequence of frames in .ppm files", FALSE, G_PARAM_READWRITE));
gobject_class->set_property = gst_glsink_set_property;
gobject_class->get_property = gst_glsink_get_property;
@ -287,18 +294,17 @@ gst_glsink_init (GstGLSink *sink)
static void
gst_glsink_release_conn (GstGLSink * sink)
{
if (sink->conn == NULL) return;
if (sink->conn == NULL)
return;
/* free last image if any */
if (sink->last_image != NULL)
{
if (sink->last_image != NULL) {
gst_buffer_unref (sink->last_image);
sink->last_image = NULL;
}
/* free cache */
g_mutex_lock (sink->cache_lock);
while (sink->cache)
{
while (sink->cache) {
sink->plugin->free_image ((GstImageData *) sink->cache->data);
sink->cache = g_list_delete_link (sink->cache, sink->cache);
}
@ -355,11 +361,15 @@ gst_glsink_buffer_new (GstBufferPool *pool, gint64 location,
Free a buffer that the chain doesn't need anymore.
*/
static void
gst_glsink_buffer_free (GstBufferPool *pool, GstBuffer *buffer, gpointer user_data)
gst_glsink_buffer_free (GstBufferPool * pool, GstBuffer * buffer,
gpointer user_data)
{
GstGLSink *sink = GST_GLSINK (gst_buffer_pool_get_user_data (GST_BUFFER_BUFFERPOOL (buffer)));
GstGLSink *sink =
GST_GLSINK (gst_buffer_pool_get_user_data (GST_BUFFER_BUFFERPOOL
(buffer)));
gst_glsink_append_cache (sink, (GstImageData *) GST_BUFFER_POOL_PRIVATE (buffer));
gst_glsink_append_cache (sink,
(GstImageData *) GST_BUFFER_POOL_PRIVATE (buffer));
/* set to NULL so the data is not freed */
GST_BUFFER_DATA (buffer) = NULL;
@ -380,12 +390,12 @@ gst_glsink_set_caps (GstGLSink *sink, GstCaps *caps)
GList *list = ((GstGLSinkClass *) G_OBJECT_GET_CLASS (sink))->plugins;
GstImageConnection *conn = NULL;
while (list)
{
while (list) {
printf ("AGetting GLstring, context is %p\n", glXGetCurrentContext ());
GstImagePlugin *plugin = (GstImagePlugin *) list->data;
if ((conn = plugin->set_caps (sink->hook, caps)) != NULL)
{
if ((conn = plugin->set_caps (sink->hook, caps)) != NULL) {
//gst_glsink_release_conn (sink);
printf ("BGetting GLstring, context is %p\n", glXGetCurrentContext ());
sink->conn = conn;
@ -420,8 +430,7 @@ gst_glsink_sinkconnect (GstPad *pad, GstCaps *caps)
result = gst_glsink_set_caps (sink, caps);
gst_glxwindow_unhook_context (sink->hook);
if (result == FALSE)
{
if (result == FALSE) {
return GST_PAD_LINK_REFUSED;
}
@ -452,9 +461,10 @@ gst_glsink_getcaps (GstPad *pad, GstCaps *caps)
GList *list = ((GstGLSinkClass *) G_OBJECT_GET_CLASS (sink))->plugins;
gst_glxwindow_hook_context (sink->hook);
while (list)
{
ret = gst_caps_append (ret, ((GstImagePlugin *) list->data)->get_caps (sink->hook));
while (list) {
ret =
gst_caps_append (ret,
((GstImagePlugin *) list->data)->get_caps (sink->hook));
list = g_list_next (list);
}
@ -501,8 +511,7 @@ gst_glsink_chain (GstPad *pad, GstData *_data)
static int frame_drops = 0;
if (sink->clock && time != -1) {
if (time < gst_clock_get_time(sink->clock))
{
if (time < gst_clock_get_time (sink->clock)) {
g_warning ("Frame drop (%d consecutive) !!", frame_drops);
/* we are going to drop late buffers */
gst_buffer_unref (buf);
@ -512,7 +521,8 @@ gst_glsink_chain (GstPad *pad, GstData *_data)
frame_drops = 0; // we made it - reset time
GstClockReturn ret;
GstClockID id = gst_clock_new_single_shot_id (sink->clock, GST_BUFFER_TIMESTAMP (buf));
GstClockID id =
gst_clock_new_single_shot_id (sink->clock, GST_BUFFER_TIMESTAMP (buf));
ret = gst_element_clock_wait (GST_ELEMENT (sink), id, NULL);
gst_clock_id_free (id);
@ -529,10 +539,8 @@ gst_glsink_chain (GstPad *pad, GstData *_data)
sink->frames_displayed++;
g_object_notify (G_OBJECT (sink), "frames_displayed");
if (!sink->muted)
{
if (glXGetCurrentContext() == NULL)
{
if (!sink->muted) {
if (glXGetCurrentContext () == NULL) {
printf ("Rehooking window !\n");
gst_glxwindow_hook_context (sink->hook);
@ -562,6 +570,7 @@ gst_glsink_chain (GstPad *pad, GstData *_data)
glLoadIdentity ();
GLfloat aspect = (GLfloat) w / (GLfloat) h;
glFrustum (-aspect, aspect, -1.0, 1.0, 5.0, 500.0);
#endif
@ -584,16 +593,20 @@ gst_glsink_chain (GstPad *pad, GstData *_data)
sink->hook->demo = sink->demo;
sink->hook->dumpvideo = sink->dumpvideo;
sink->plugin->put_image (sink->hook, (GstImageData *) GST_BUFFER_POOL_PRIVATE (buf));
sink->plugin->put_image (sink->hook,
(GstImageData *) GST_BUFFER_POOL_PRIVATE (buf));
sink->last_image = buf;
} else {
buffer = gst_buffer_new_from_pool (gst_glsink_get_bufferpool (sink->sinkpad),
buffer =
gst_buffer_new_from_pool (gst_glsink_get_bufferpool (sink->sinkpad),
0, GST_BUFFER_SIZE (buf));
memcpy (GST_BUFFER_DATA (buffer), GST_BUFFER_DATA (buf),
GST_BUFFER_SIZE (buf) > GST_BUFFER_SIZE (buffer) ?
GST_BUFFER_SIZE (buffer) : GST_BUFFER_SIZE (buf));
GST_BUFFER_SIZE (buf) >
GST_BUFFER_SIZE (buffer) ? GST_BUFFER_SIZE (buffer) :
GST_BUFFER_SIZE (buf));
sink->plugin->put_image (sink->hook, (GstImageData *) GST_BUFFER_POOL_PRIVATE (buffer));
sink->plugin->put_image (sink->hook,
(GstImageData *) GST_BUFFER_POOL_PRIVATE (buffer));
sink->last_image = buffer;
gst_buffer_unref (buf);
@ -606,7 +619,8 @@ gst_glsink_chain (GstPad *pad, GstData *_data)
static void
gst_glsink_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
gst_glsink_set_property (GObject * object, guint prop_id, const GValue * value,
GParamSpec * pspec)
{
//g_warning("in set_property!\n");
GstGLSink *sink;
@ -625,8 +639,7 @@ gst_glsink_set_property (GObject *object, guint prop_id, const GValue *value, GP
sink->frame_time = g_value_get_int (value);
break;
case ARG_HOOK:
if (sink->hook)
{
if (sink->hook) {
sink->hook->free_info (sink->hook);
}
sink->hook = g_value_get_pointer (value);
@ -645,7 +658,8 @@ gst_glsink_set_property (GObject *object, guint prop_id, const GValue *value, GP
break;
case ARG_REPAINT:
if (sink->last_image != NULL) {
sink->plugin->put_image (sink->hook, (GstImageData *) GST_BUFFER_POOL_PRIVATE (sink->last_image));
sink->plugin->put_image (sink->hook,
(GstImageData *) GST_BUFFER_POOL_PRIVATE (sink->last_image));
}
break;
default:
@ -655,7 +669,8 @@ gst_glsink_set_property (GObject *object, guint prop_id, const GValue *value, GP
}
static void
gst_glsink_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
gst_glsink_get_property (GObject * object, guint prop_id, GValue * value,
GParamSpec * pspec)
{
//g_warning("in get_property!\n");
GstGLSink *sink;
@ -741,11 +756,8 @@ plugin_init (GstPlugin *plugin)
return FALSE;
/* this is needed later on in the _real_ init (during a gst-launch) */
sink_template = gst_pad_template_new (
"sink",
GST_PAD_SINK,
GST_PAD_ALWAYS,
NULL);
sink_template = gst_pad_template_new ("sink",
GST_PAD_SINK, GST_PAD_ALWAYS, NULL);
if (!gst_element_register (plugin, "glsink", GST_RANK_NONE, GST_TYPE_GLSINK))
return FALSE;
@ -753,14 +765,8 @@ plugin_init (GstPlugin *plugin)
return TRUE;
}
GST_PLUGIN_DEFINE (
GST_VERSION_MAJOR,
GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
GST_VERSION_MINOR,
"glsink",
"An OpenGL based video sink - uses OpenGL and GLX to draw video, utilizing different acceleration options",
plugin_init,
VERSION,
GST_LICENSE,
GST_PACKAGE,
GST_ORIGIN
);
plugin_init, VERSION, GST_LICENSE, GST_PACKAGE, GST_ORIGIN);

27
gst/gl/gstglsink.h
View file

@ -25,13 +25,15 @@
#include <gst/gst.h>
#ifdef __cplusplus
extern "C" {
extern "C"
{
#endif /* __cplusplus */
#define MAX_FLIP_BUFFERS 1
typedef struct _GstImageInfo GstImageInfo;
struct _GstImageInfo {
struct _GstImageInfo
{
gulong id;
int demo;
int dumpvideo;
@ -40,26 +42,32 @@ struct _GstImageInfo {
typedef struct _GstImageData GstImageData;
struct _GstImageData {
struct _GstImageData
{
gint size;
gchar *data;
};
typedef struct _GstImageConnection GstImageConnection;
struct _GstImageConnection {
struct _GstImageConnection
{
void (*open_conn) (GstImageConnection * conn, GstImageInfo * info);
void (*close_conn) (GstImageConnection * conn, GstImageInfo * info);
void (*free_conn) (GstImageConnection * conn);
};
typedef GstCaps *(*GstImagePluginGetCapsFunc) (GstImageInfo * info);
typedef GstImageConnection * (*GstImagePluginSetCapsFunc) (GstImageInfo *info, GstCaps *caps);
typedef GstImageData* (*GstImagePluginGetImageFunc) (GstImageInfo *info, GstImageConnection *conn);
typedef void (*GstImagePluginPutImageFunc) (GstImageInfo *info, GstImageData *image);
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 {
struct _GstImagePlugin
{
GstImagePluginGetCapsFunc get_caps;
GstImagePluginSetCapsFunc set_caps;
GstImagePluginGetImageFunc get_image;
@ -69,7 +77,8 @@ struct _GstImagePlugin {
typedef struct _GstGLImageInfo GstGLImageInfo;
/* stuff about our window grouped together */
struct _GstGLImageInfo {
struct _GstGLImageInfo
{
GstImageInfo info;
Display *dpy;
int screen;

72
gst/gl/gstglxwindow.c
View file

@ -21,8 +21,7 @@
/* attributes for a single buffered visual in RGBA format with at least
* 4 bits per color and a 16 bit depth buffer */
static int attrListSgl[] =
{
static int attrListSgl[] = {
GLX_RGBA, GLX_RED_SIZE, 4,
GLX_GREEN_SIZE, 4,
GLX_BLUE_SIZE, 4,
@ -32,8 +31,7 @@ static int attrListSgl[] =
/* attributes for a double buffered visual in RGBA format with at least
* 4 bits per color and a 16 bit depth buffer */
static int attrListDbl[] =
{
static int attrListDbl[] = {
GLX_RGBA, GLX_DOUBLEBUFFER,
GLX_RED_SIZE, 4,
GLX_GREEN_SIZE, 4,
@ -53,13 +51,10 @@ gst_glxwindow_unhook_context(GstImageInfo *info)
{
GstGLImageInfo *window = (GstGLImageInfo *) info;
if (window->ctx)
{
if (!glXMakeCurrent(window->dpy, None, NULL))
{
if (window->ctx) {
if (!glXMakeCurrent (window->dpy, None, NULL)) {
printf ("Could not release drawing context.\n");
}
else
} else
printf ("Released drawing context.\n");
}
}
@ -69,13 +64,10 @@ gst_glxwindow_hook_context(GstImageInfo *info)
{
GstGLImageInfo *window = (GstGLImageInfo *) info;
if (window->ctx && window->win && window->ctx)
{
if (!glXMakeCurrent(window->dpy, window->win, window->ctx))
{
if (window->ctx && window->win && window->ctx) {
if (!glXMakeCurrent (window->dpy, window->win, window->ctx)) {
printf ("Could not acquire GLX drawing context.\n");
}
else
} else
printf ("Acquired drawing context.\n");
}
}
@ -87,10 +79,8 @@ gst_glxwindow_free (GstImageInfo *info)
g_signal_handler_disconnect (window->sink, window->handler_id);
if (window->ctx)
{
if (!glXMakeCurrent(window->dpy, None, NULL))
{
if (window->ctx) {
if (!glXMakeCurrent (window->dpy, None, NULL)) {
printf ("Could not release drawing context.\n");
}
glXDestroyContext (window->dpy, window->ctx);
@ -98,8 +88,7 @@ gst_glxwindow_free (GstImageInfo *info)
}
#if 0
/* switch back to original desktop resolution if we were in fs */
if (GLWin.fs)
{
if (GLWin.fs) {
XF86VidModeSwitchToMode (GLWin.dpy, GLWin.screen, &GLWin.deskMode);
XF86VidModeSetViewPort (GLWin.dpy, GLWin.screen, 0, 0);
}
@ -109,19 +98,21 @@ gst_glxwindow_free (GstImageInfo *info)
}
static void
gst_glxwindow_callback(GObject *object, GParamSpec *pspec, GstGLImageInfo *data)
gst_glxwindow_callback (GObject * object, GParamSpec * pspec,
GstGLImageInfo * data)
{
XWindowAttributes attr;
XGetWindowAttributes (data->dpy, data->win, &attr);
if (strncmp (pspec->name, "width", 5) == 0 || strncmp (pspec->name, "height", 6) == 0)
{
if (strncmp (pspec->name, "width", 5) == 0
|| strncmp (pspec->name, "height", 6) == 0) {
gint w = 0;
gint h = 0;
g_object_get (object, "width", &w, NULL);
g_object_get (object, "height", &h, NULL);
if (w != attr.width || h != attr.height)
{
if (w != attr.width || h != attr.height) {
attr.width = w;
attr.height = h;
XResizeWindow (data->dpy, data->win, attr.width, attr.height);
@ -134,11 +125,11 @@ gst_glxwindow_callback(GObject *object, GParamSpec *pspec, GstGLImageInfo *data)
glLoadIdentity ();
GLfloat aspect = (GLfloat) h / (GLfloat) w;
glFrustum (-1.0, 1.0, -aspect, aspect, 5.0, 500.0);
}
}
if (attr.width != data->width || attr.height != data->height)
{
if (attr.width != data->width || attr.height != data->height) {
data->width = attr.width;
data->height = attr.height;
}
@ -151,6 +142,7 @@ gst_glxwindow_new (GstElement *sink)
//XGCValues values;
GstGLImageInfo *new;
int glxMajorVersion, glxMinorVersion;
//XSetWindowAttributes attrib;
XVisualInfo *vi;
Atom wmDelete;
@ -161,8 +153,7 @@ gst_glxwindow_new (GstElement *sink)
new = g_new0 (GstGLImageInfo, 1);
if (sink == NULL)
{
if (sink == NULL) {
sink = gst_element_factory_make ("glsink", "glsink");
g_assert (sink != NULL);
}
@ -180,13 +171,10 @@ gst_glxwindow_new (GstElement *sink)
new->screen = DefaultScreen (new->dpy);
/* get an appropriate visual */
vi = glXChooseVisual (new->dpy, new->screen, attrListDbl);
if (vi == NULL)
{
if (vi == NULL) {
vi = glXChooseVisual (new->dpy, new->screen, attrListSgl);
GST_DEBUG ("Only Singlebuffered Visual!\n");
}
else
{
} else {
GST_DEBUG ("Got Doublebuffered Visual!\n");
}
glXQueryVersion (new->dpy, &glxMajorVersion, &glxMinorVersion);
@ -216,10 +204,9 @@ gst_glxwindow_new (GstElement *sink)
new->attr.event_mask = ExposureMask | KeyPressMask | ButtonPressMask |
StructureNotifyMask;
new->win = XCreateWindow (new->dpy, RootWindow (new->dpy, vi->screen),
new->x, new->y, new->width, new->height, 0, vi->depth, InputOutput, vi->visual,
CWBorderPixel | CWColormap | CWEventMask, &new->attr);
if (!new->win)
{
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;
@ -272,6 +259,7 @@ gst_glxwindow_new (GstElement *sink)
g_object_set (sink, "hook", new, NULL);
new->sink = sink;
new->handler_id = g_signal_connect (sink, "notify", G_CALLBACK (gst_glxwindow_callback), new);
new->handler_id =
g_signal_connect (sink, "notify", G_CALLBACK (gst_glxwindow_callback),
new);
}

217
gst/gl/regcomb_yuvrgb.c
View file

@ -28,7 +28,8 @@ unsigned int UVwidth=256, UVheight=512;
int tex_xsize, tex_ysize;
void GenerateRGBTables(unsigned char *Ytable, // Y-palette
void
GenerateRGBTables (unsigned char *Ytable, // Y-palette
unsigned char *Utable, // U-palette
unsigned char *Vtable, // V-palette
float *bias, // bias (fourth vector to be added)
@ -77,7 +78,9 @@ void GenerateRGBTables(unsigned char *Ytable, // Y-palette
// Sets the constants. Call once prior to rendering.
void SetConsts(float *bias, float *Uscale, float *Vscale) {
void
SetConsts (float *bias, float *Uscale, float *Vscale)
{
glEnable (GL_REGISTER_COMBINERS_NV);
glColor3fv (bias);
//printf("%f %f %f\n",bias[0],bias[1],bias[2]);
@ -89,60 +92,73 @@ void SetConsts(float *bias, float *Uscale, float *Vscale) {
* SOFTWARE PATH
*/
inline void map_EXPAND_NORMAL(float *v) {
inline void
map_EXPAND_NORMAL (float *v)
{
v[0] = 2.0f * v[0] - 1.0f;
v[1] = 2.0f * v[1] - 1.0f;
v[2] = 2.0f * v[2] - 1.0f;
}
inline void map_UNSIGNED_INVERT(float *v) {
inline void
map_UNSIGNED_INVERT (float *v)
{
v[0] = 1.0f - v[0];
v[1] = 1.0f - v[1];
v[2] = 1.0f - v[2];
}
inline void map_UNSIGNED_IDENTITY(float *v) {
inline void
map_UNSIGNED_IDENTITY (float *v)
{
v[0] = (v[0] < 0.0f ? 0.0f : v[0]);
v[1] = (v[1] < 0.0f ? 0.0f : v[1]);
v[2] = (v[2] < 0.0f ? 0.0f : v[2]);
}
inline void map_SIGNED_IDENTITY(float *v) {
inline void
map_SIGNED_IDENTITY (float *v)
{
}
inline void omap_SCALE_BY_TWO(float *v) {
inline void
omap_SCALE_BY_TWO (float *v)
{
v[0] *= 2.0f;
v[1] *= 2.0f;
v[2] *= 2.0f;
}
inline void omap_SCALE_BY_ONE_HALF(float *v) {
inline void
omap_SCALE_BY_ONE_HALF (float *v)
{
v[0] *= 0.5f;
v[1] *= 0.5f;
v[2] *= 0.5f;
}
inline void omap_RANGE(float *v) {
inline void
omap_RANGE (float *v)
{
v[0] = (v[0] < -1.0f ? -1.0f : (v[0] > 1.0f ? 1.0f : v[0]));
v[1] = (v[1] < -1.0f ? -1.0f : (v[1] > 1.0f ? 1.0f : v[1]));
v[2] = (v[2] < -1.0f ? -1.0f : (v[2] > 1.0f ? 1.0f : v[2]));
}
inline void omap_CLAMP_01(float *v) {
inline void
omap_CLAMP_01 (float *v)
{
v[0] = (v[0] < 0.0f ? 0.0f : (v[0] > 1.0f ? 1.0f : v[0]));
v[1] = (v[1] < 0.0f ? 0.0f : (v[1] > 1.0f ? 1.0f : v[1]));
v[2] = (v[2] < 0.0f ? 0.0f : (v[2] > 1.0f ? 1.0f : v[2]));
}
void PerformSWCombiner(unsigned char *Result,
void
PerformSWCombiner (unsigned char *Result,
unsigned char *tex0,
unsigned char *tex1,
unsigned char *tex2,
float *COLOR0,
float *CONST0,
float *CONST1
)
unsigned char *tex2, float *COLOR0, float *CONST0, float *CONST1)
{
float SPARE0[3];
float SPARE1[3];
@ -163,10 +179,14 @@ void PerformSWCombiner(unsigned char *Result,
TEX2[2] = (float) tex2[2] / 255.0f;
// Combiner Stage 0:
memcpy(A,TEX0,3*sizeof(float)); map_UNSIGNED_IDENTITY(A);
memcpy(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);
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];
@ -174,20 +194,28 @@ void PerformSWCombiner(unsigned char *Result,
omap_RANGE (SPARE0);
// Combiner Stage 1:
memcpy(A,TEX1,3*sizeof(float)); map_EXPAND_NORMAL(A);
memcpy(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);
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);
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];
@ -195,10 +223,14 @@ void PerformSWCombiner(unsigned char *Result,
omap_RANGE (SPARE0);
// Final Combiner Stage:
memcpy(A,ZERO,3*sizeof(float)); map_UNSIGNED_INVERT(A);
memcpy(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);
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];
@ -209,56 +241,81 @@ void PerformSWCombiner(unsigned char *Result,
}
// Sets up the register combiners. Call once prior to rendering
void SetupCombiners(void)
void
SetupCombiners (void)
{
glCombinerParameteriNV (GL_NUM_GENERAL_COMBINERS_NV, 3);
// Combiner Stage 0: th. OK
glCombinerInputNV (GL_COMBINER0_NV,GL_RGB,GL_VARIABLE_A_NV,GL_TEXTURE0_ARB, GL_UNSIGNED_IDENTITY_NV,GL_RGB);
glCombinerInputNV (GL_COMBINER0_NV,GL_RGB,GL_VARIABLE_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);
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);
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);
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);
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
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);
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!
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);
@ -276,7 +333,8 @@ void InitYUVPlanes(GLuint *Yhandle, GLuint *Uhandle, GLuint *Vhandle,
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
tex_xsize = PowerOfTwo (Ywidth);
tex_ysize = PowerOfTwo (Yheight);
glTexImage2D(GL_TEXTURE_2D,0,GL_COLOR_INDEX8_EXT,PowerOfTwo(Ywidth),PowerOfTwo(Yheight),0,GL_COLOR_INDEX,GL_UNSIGNED_BYTE,NULL);
glTexImage2D (GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT, PowerOfTwo (Ywidth),
PowerOfTwo (Yheight), 0, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, NULL);
glBindTexture (GL_TEXTURE_2D, (*Uhandle));
#ifdef _WIN32
@ -288,7 +346,8 @@ void InitYUVPlanes(GLuint *Yhandle, GLuint *Uhandle, GLuint *Vhandle,
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexImage2D(GL_TEXTURE_2D,0,GL_COLOR_INDEX8_EXT,PowerOfTwo(UVwidth),PowerOfTwo(UVheight),0,GL_COLOR_INDEX,GL_UNSIGNED_BYTE,NULL);
glTexImage2D (GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT, PowerOfTwo (UVwidth),
PowerOfTwo (UVheight), 0, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, NULL);
glBindTexture (GL_TEXTURE_2D, (*Vhandle));
#ifdef _WIN32
@ -300,36 +359,42 @@ void InitYUVPlanes(GLuint *Yhandle, GLuint *Uhandle, GLuint *Vhandle,
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexImage2D(GL_TEXTURE_2D,0,GL_COLOR_INDEX8_EXT,PowerOfTwo(UVwidth),PowerOfTwo(UVheight),0,GL_COLOR_INDEX,GL_UNSIGNED_BYTE,NULL);
glTexImage2D (GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT, PowerOfTwo (UVwidth),
PowerOfTwo (UVheight), 0, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, NULL);
}
void LoadYUVPlanes(GLuint Yhandle, GLuint Uhandle, GLuint Vhandle,
void
LoadYUVPlanes (GLuint Yhandle, GLuint Uhandle, GLuint Vhandle,
unsigned int Ywidth, unsigned int Yheight,
unsigned int UVwidth, unsigned int UVheight,
unsigned char *Ydata,
unsigned char *Udata,
unsigned char *Vdata)
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);
glTexSubImage2D (GL_TEXTURE_2D, 0, 0, 0, Ywidth, Yheight, GL_COLOR_INDEX,
GL_UNSIGNED_BYTE, Ydata);
glEnable (GL_TEXTURE_2D);
glActiveTextureARB (GL_TEXTURE1_ARB);
glBindTexture (GL_TEXTURE_2D, Uhandle);
glTexSubImage2D(GL_TEXTURE_2D,0,0,0,UVwidth,UVheight,GL_COLOR_INDEX,GL_UNSIGNED_BYTE,Udata);
glTexSubImage2D (GL_TEXTURE_2D, 0, 0, 0, UVwidth, UVheight, GL_COLOR_INDEX,
GL_UNSIGNED_BYTE, Udata);
glEnable (GL_TEXTURE_2D);
glActiveTextureARB (GL_TEXTURE2_ARB);
glBindTexture (GL_TEXTURE_2D, Vhandle);
glTexSubImage2D(GL_TEXTURE_2D,0,0,0,UVwidth,UVheight,GL_COLOR_INDEX,GL_UNSIGNED_BYTE,Vdata);
glTexSubImage2D (GL_TEXTURE_2D, 0, 0, 0, UVwidth, UVheight, GL_COLOR_INDEX,
GL_UNSIGNED_BYTE, Vdata);
glEnable (GL_TEXTURE_2D);
}
void Initialize_Backend(unsigned int Ywidth, unsigned int Yheight, unsigned int UVwidth, unsigned int UVheight, GLenum filter)
void
Initialize_Backend (unsigned int Ywidth, unsigned int Yheight,
unsigned int UVwidth, unsigned int UVheight, GLenum filter)
{
printf("Reinitializing register combiner backend with res %d x %d!\n", Ywidth, Yheight);
printf ("Reinitializing register combiner backend with res %d x %d!\n",
Ywidth, Yheight);
//if (!GL_ARB_multitexture_Init()) exit(0);
//if (!GL_EXT_paletted_texture_Init()) exit(0);
//if (!GL_NV_register_combiners_Init()) exit(0);
@ -339,14 +404,18 @@ void Initialize_Backend(unsigned int Ywidth, unsigned int Yheight, unsigned int
float bias[4];
float Uscale[4];
float Vscale[4];
GenerateRGBTables (Ypal, Upal, Vpal, bias, Uscale, Vscale);
InitYUVPlanes(&Yhandle,&Uhandle,&Vhandle,Ywidth,Yheight,UVwidth,UVheight,filter,Ypal,Upal,Vpal);
InitYUVPlanes (&Yhandle, &Uhandle, &Vhandle, Ywidth, Yheight, UVwidth,
UVheight, filter, Ypal, Upal, Vpal);
SetupCombiners ();
SetConsts (bias, Uscale, Vscale);
}
void initialize(GLenum filter) {
void
initialize (GLenum filter)
{
glShadeModel (GL_SMOOTH);
glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glClearColor (0.0f, 0.0f, 0.2f, 1.0f);