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

659
gst/gl/ARB_multitexture.h
View file

@ -7,42 +7,42 @@
* *
* version 1.0ß *
* *
*************************************************************/
*************************************************************/
#ifndef __ARB_MULTITEXTURE_H_
#define __ARB_MULTITEXTURE_H_
/*
* GLOBAL SWITCHES - enable/disable advanced features of this header
*
*/
#define ARB_MULTITEXTURE_INITIALIZE 1 // enable generic init-routines
*/
#define ARB_MULTITEXTURE_INITIALIZE 1 // enable generic init-routines
#ifndef _WIN32
#define GL_GLEXT_PROTOTYPES 1
#endif
#endif /* */
#ifdef __cplusplus
extern "C" {
#endif
extern "C"
{
#endif /* */
#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__)
#define WIN32_LEAN_AND_MEAN 1
#include <windows.h>
#endif
#endif /* */
#ifndef APIENTRY
#define APIENTRY
#endif
#endif /* */
// Header file version number, required by OpenGL ABI for Linux
//#define GL_GLEXT_VERSION 7
/*
* NEW TOKENS TO OPENGL 1.2.1
*
*/
*/
#ifndef GL_ARB_multitexture
#define GL_TEXTURE0_ARB 0x84C0
#define GL_TEXTURE1_ARB 0x84C1
@ -80,232 +80,421 @@ extern "C" {
#define GL_CLIENT_ACTIVE_TEXTURE_ARB 0x84E1
#define GL_MAX_TEXTURE_UNITS_ARB 0x84E2
#define GL_ARB_multitexture 1
#endif
#endif /* */
#ifndef _WIN32
#ifdef GL_GLEXT_PROTOTYPES
extern void APIENTRY glActiveTextureARB (GLenum);
extern void APIENTRY glClientActiveTextureARB (GLenum);
extern void APIENTRY glMultiTexCoord1dARB (GLenum, GLdouble);
extern void APIENTRY glMultiTexCoord1dvARB (GLenum, const GLdouble *);
extern void APIENTRY glMultiTexCoord1fARB (GLenum, GLfloat);
extern void APIENTRY glMultiTexCoord1fvARB (GLenum, const GLfloat *);
extern void APIENTRY glMultiTexCoord1iARB (GLenum, GLint);
extern void APIENTRY glMultiTexCoord1ivARB (GLenum, const GLint *);
extern void APIENTRY glMultiTexCoord1sARB (GLenum, GLshort);
extern void APIENTRY glMultiTexCoord1svARB (GLenum, const GLshort *);
extern void APIENTRY glMultiTexCoord2dARB (GLenum, GLdouble, GLdouble);
extern void APIENTRY glMultiTexCoord2dvARB (GLenum, const GLdouble *);
extern void APIENTRY glMultiTexCoord2fARB (GLenum, GLfloat, GLfloat);
extern void APIENTRY glMultiTexCoord2fvARB (GLenum, const GLfloat *);
extern void APIENTRY glMultiTexCoord2iARB (GLenum, GLint, GLint);
extern void APIENTRY glMultiTexCoord2ivARB (GLenum, const GLint *);
extern void APIENTRY glMultiTexCoord2sARB (GLenum, GLshort, GLshort);
extern void APIENTRY glMultiTexCoord2svARB (GLenum, const GLshort *);
extern void APIENTRY glMultiTexCoord3dARB (GLenum, GLdouble, GLdouble, GLdouble);
extern void APIENTRY glMultiTexCoord3dvARB (GLenum, const GLdouble *);
extern void APIENTRY glMultiTexCoord3fARB (GLenum, GLfloat, GLfloat, GLfloat);
extern void APIENTRY glMultiTexCoord3fvARB (GLenum, const GLfloat *);
extern void APIENTRY glMultiTexCoord3iARB (GLenum, GLint, GLint, GLint);
extern void APIENTRY glMultiTexCoord3ivARB (GLenum, const GLint *);
extern void APIENTRY glMultiTexCoord3sARB (GLenum, GLshort, GLshort, GLshort);
extern void APIENTRY glMultiTexCoord3svARB (GLenum, const GLshort *);
extern void APIENTRY glMultiTexCoord4dARB (GLenum, GLdouble, GLdouble, GLdouble, GLdouble);
extern void APIENTRY glMultiTexCoord4dvARB (GLenum, const GLdouble *);
extern void APIENTRY glMultiTexCoord4fARB (GLenum, GLfloat, GLfloat, GLfloat, GLfloat);
extern void APIENTRY glMultiTexCoord4fvARB (GLenum, const GLfloat *);
extern void APIENTRY glMultiTexCoord4iARB (GLenum, GLint, GLint, GLint, GLint);
extern void APIENTRY glMultiTexCoord4ivARB (GLenum, const GLint *);
extern void APIENTRY glMultiTexCoord4sARB (GLenum, GLshort, GLshort, GLshort, GLshort);
extern void APIENTRY glMultiTexCoord4svARB (GLenum, const GLshort *);
#endif // GL_GLEXT_PROTOTYPES
#else // not _WIN32
typedef void (APIENTRY * PFNGLACTIVETEXTUREARBPROC) (GLenum texture);
typedef void (APIENTRY * PFNGLCLIENTACTIVETEXTUREARBPROC) (GLenum texture);
typedef void (APIENTRY * PFNGLMULTITEXCOORD1DARBPROC) (GLenum target, GLdouble s);
typedef void (APIENTRY * PFNGLMULTITEXCOORD1DVARBPROC) (GLenum target, const GLdouble *v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD1FARBPROC) (GLenum target, GLfloat s);
typedef void (APIENTRY * PFNGLMULTITEXCOORD1FVARBPROC) (GLenum target, const GLfloat *v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD1IARBPROC) (GLenum target, GLint s);
typedef void (APIENTRY * PFNGLMULTITEXCOORD1IVARBPROC) (GLenum target, const GLint *v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD1SARBPROC) (GLenum target, GLshort s);
typedef void (APIENTRY * PFNGLMULTITEXCOORD1SVARBPROC) (GLenum target, const GLshort *v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD2DARBPROC) (GLenum target, GLdouble s, GLdouble t);
typedef void (APIENTRY * PFNGLMULTITEXCOORD2DVARBPROC) (GLenum target, const GLdouble *v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD2FARBPROC) (GLenum target, GLfloat s, GLfloat t);
typedef void (APIENTRY * PFNGLMULTITEXCOORD2FVARBPROC) (GLenum target, const GLfloat *v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD2IARBPROC) (GLenum target, GLint s, GLint t);
typedef void (APIENTRY * PFNGLMULTITEXCOORD2IVARBPROC) (GLenum target, const GLint *v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD2SARBPROC) (GLenum target, GLshort s, GLshort t);
typedef void (APIENTRY * PFNGLMULTITEXCOORD2SVARBPROC) (GLenum target, const GLshort *v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD3DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r);
typedef void (APIENTRY * PFNGLMULTITEXCOORD3DVARBPROC) (GLenum target, const GLdouble *v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD3FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r);
typedef void (APIENTRY * PFNGLMULTITEXCOORD3FVARBPROC) (GLenum target, const GLfloat *v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD3IARBPROC) (GLenum target, GLint s, GLint t, GLint r);
typedef void (APIENTRY * PFNGLMULTITEXCOORD3IVARBPROC) (GLenum target, const GLint *v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD3SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r);
typedef void (APIENTRY * PFNGLMULTITEXCOORD3SVARBPROC) (GLenum target, const GLshort *v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD4DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
typedef void (APIENTRY * PFNGLMULTITEXCOORD4DVARBPROC) (GLenum target, const GLdouble *v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD4FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
typedef void (APIENTRY * PFNGLMULTITEXCOORD4FVARBPROC) (GLenum target, const GLfloat *v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD4IARBPROC) (GLenum target, GLint s, GLint t, GLint r, GLint q);
typedef void (APIENTRY * PFNGLMULTITEXCOORD4IVARBPROC) (GLenum target, const GLint *v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD4SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
typedef void (APIENTRY * PFNGLMULTITEXCOORD4SVARBPROC) (GLenum target, const GLshort *v);
#endif // _WIN32
extern void APIENTRY glActiveTextureARB (GLenum);
extern void APIENTRY glClientActiveTextureARB (GLenum);
extern void APIENTRY glMultiTexCoord1dARB (GLenum, GLdouble);
extern void APIENTRY glMultiTexCoord1dvARB (GLenum, const GLdouble *);
extern void APIENTRY glMultiTexCoord1fARB (GLenum, GLfloat);
extern void APIENTRY glMultiTexCoord1fvARB (GLenum, const GLfloat *);
extern void APIENTRY glMultiTexCoord1iARB (GLenum, GLint);
extern void APIENTRY glMultiTexCoord1ivARB (GLenum, const GLint *);
extern void APIENTRY glMultiTexCoord1sARB (GLenum, GLshort);
extern void APIENTRY glMultiTexCoord1svARB (GLenum, const GLshort *);
extern void APIENTRY glMultiTexCoord2dARB (GLenum, GLdouble, GLdouble);
extern void APIENTRY glMultiTexCoord2dvARB (GLenum, const GLdouble *);
extern void APIENTRY glMultiTexCoord2fARB (GLenum, GLfloat, GLfloat);
extern void APIENTRY glMultiTexCoord2fvARB (GLenum, const GLfloat *);
extern void APIENTRY glMultiTexCoord2iARB (GLenum, GLint, GLint);
extern void APIENTRY glMultiTexCoord2ivARB (GLenum, const GLint *);
extern void APIENTRY glMultiTexCoord2sARB (GLenum, GLshort, GLshort);
extern void APIENTRY glMultiTexCoord2svARB (GLenum, const GLshort *);
extern void APIENTRY glMultiTexCoord3dARB (GLenum, GLdouble, GLdouble,
GLdouble);
extern void APIENTRY glMultiTexCoord3dvARB (GLenum, const GLdouble *);
extern void APIENTRY glMultiTexCoord3fARB (GLenum, GLfloat, GLfloat,
GLfloat);
extern void APIENTRY glMultiTexCoord3fvARB (GLenum, const GLfloat *);
extern void APIENTRY glMultiTexCoord3iARB (GLenum, GLint, GLint, GLint);
extern void APIENTRY glMultiTexCoord3ivARB (GLenum, const GLint *);
extern void APIENTRY glMultiTexCoord3sARB (GLenum, GLshort, GLshort,
GLshort);
extern void APIENTRY glMultiTexCoord3svARB (GLenum, const GLshort *);
extern void APIENTRY glMultiTexCoord4dARB (GLenum, GLdouble, GLdouble,
GLdouble, GLdouble);
extern void APIENTRY glMultiTexCoord4dvARB (GLenum, const GLdouble *);
extern void APIENTRY glMultiTexCoord4fARB (GLenum, GLfloat, GLfloat,
GLfloat, GLfloat);
extern void APIENTRY glMultiTexCoord4fvARB (GLenum, const GLfloat *);
extern void APIENTRY glMultiTexCoord4iARB (GLenum, GLint, GLint, GLint,
GLint);
extern void APIENTRY glMultiTexCoord4ivARB (GLenum, const GLint *);
extern void APIENTRY glMultiTexCoord4sARB (GLenum, GLshort, GLshort,
GLshort, GLshort);
extern void APIENTRY glMultiTexCoord4svARB (GLenum, const GLshort *);
#endif // GL_GLEXT_PROTOTYPES
#else // not _WIN32
typedef void (APIENTRY * PFNGLACTIVETEXTUREARBPROC) (GLenum texture);
typedef void (APIENTRY * PFNGLCLIENTACTIVETEXTUREARBPROC) (GLenum texture);
typedef void (APIENTRY * PFNGLMULTITEXCOORD1DARBPROC) (GLenum target,
GLdouble s);
typedef void (APIENTRY * PFNGLMULTITEXCOORD1DVARBPROC) (GLenum target,
const GLdouble * v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD1FARBPROC) (GLenum target,
GLfloat s);
typedef void (APIENTRY * PFNGLMULTITEXCOORD1FVARBPROC) (GLenum target,
const GLfloat * v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD1IARBPROC) (GLenum target,
GLint s);
typedef void (APIENTRY * PFNGLMULTITEXCOORD1IVARBPROC) (GLenum target,
const GLint * v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD1SARBPROC) (GLenum target,
GLshort s);
typedef void (APIENTRY * PFNGLMULTITEXCOORD1SVARBPROC) (GLenum target,
const GLshort * v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD2DARBPROC) (GLenum target,
GLdouble s, GLdouble t);
typedef void (APIENTRY * PFNGLMULTITEXCOORD2DVARBPROC) (GLenum target,
const GLdouble * v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD2FARBPROC) (GLenum target,
GLfloat s, GLfloat t);
typedef void (APIENTRY * PFNGLMULTITEXCOORD2FVARBPROC) (GLenum target,
const GLfloat * v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD2IARBPROC) (GLenum target,
GLint s, GLint t);
typedef void (APIENTRY * PFNGLMULTITEXCOORD2IVARBPROC) (GLenum target,
const GLint * v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD2SARBPROC) (GLenum target,
GLshort s, GLshort t);
typedef void (APIENTRY * PFNGLMULTITEXCOORD2SVARBPROC) (GLenum target,
const GLshort * v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD3DARBPROC) (GLenum target,
GLdouble s, GLdouble t, GLdouble r);
typedef void (APIENTRY * PFNGLMULTITEXCOORD3DVARBPROC) (GLenum target,
const GLdouble * v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD3FARBPROC) (GLenum target,
GLfloat s, GLfloat t, GLfloat r);
typedef void (APIENTRY * PFNGLMULTITEXCOORD3FVARBPROC) (GLenum target,
const GLfloat * v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD3IARBPROC) (GLenum target,
GLint s, GLint t, GLint r);
typedef void (APIENTRY * PFNGLMULTITEXCOORD3IVARBPROC) (GLenum target,
const GLint * v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD3SARBPROC) (GLenum target,
GLshort s, GLshort t, GLshort r);
typedef void (APIENTRY * PFNGLMULTITEXCOORD3SVARBPROC) (GLenum target,
const GLshort * v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD4DARBPROC) (GLenum target,
GLdouble s, GLdouble t, GLdouble r, GLdouble q);
typedef void (APIENTRY * PFNGLMULTITEXCOORD4DVARBPROC) (GLenum target,
const GLdouble * v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD4FARBPROC) (GLenum target,
GLfloat s, GLfloat t, GLfloat r, GLfloat q);
typedef void (APIENTRY * PFNGLMULTITEXCOORD4FVARBPROC) (GLenum target,
const GLfloat * v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD4IARBPROC) (GLenum target,
GLint s, GLint t, GLint r, GLint q);
typedef void (APIENTRY * PFNGLMULTITEXCOORD4IVARBPROC) (GLenum target,
const GLint * v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD4SARBPROC) (GLenum target,
GLshort s, GLshort t, GLshort r, GLshort q);
typedef void (APIENTRY * PFNGLMULTITEXCOORD4SVARBPROC) (GLenum target,
const GLshort * v);
#endif // _WIN32
#ifdef ARB_MULTITEXTURE_INITIALIZE
#include<string.h> // string manipulation for runtime-check
#ifdef _WIN32
PFNGLACTIVETEXTUREARBPROC glActiveTextureARB = NULL;
PFNGLCLIENTACTIVETEXTUREARBPROC glClientActiveTextureARB = NULL;
PFNGLMULTITEXCOORD1DARBPROC glMultiTexCoord1dARB = NULL;
PFNGLMULTITEXCOORD1DVARBPROC glMultiTexCoord1dvARB = NULL;
PFNGLMULTITEXCOORD1FARBPROC glMultiTexCoord1fARB = NULL;
PFNGLMULTITEXCOORD1FVARBPROC glMultiTexCoord1fvARB = NULL;
PFNGLMULTITEXCOORD1IARBPROC glMultiTexCoord1iARB = NULL;
PFNGLMULTITEXCOORD1IVARBPROC glMultiTexCoord1ivARB = NULL;
PFNGLMULTITEXCOORD1SARBPROC glMultiTexCoord1sARB = NULL;
PFNGLMULTITEXCOORD1SVARBPROC glMultiTexCoord1svARB = NULL;
PFNGLMULTITEXCOORD2DARBPROC glMultiTexCoord2dARB = NULL;
PFNGLMULTITEXCOORD2DVARBPROC glMultiTexCoord2dvARB = NULL;
PFNGLMULTITEXCOORD2FARBPROC glMultiTexCoord2fARB = NULL;
PFNGLMULTITEXCOORD2FVARBPROC glMultiTexCoord2fvARB = NULL;
PFNGLMULTITEXCOORD2IARBPROC glMultiTexCoord2iARB = NULL;
PFNGLMULTITEXCOORD2IVARBPROC glMultiTexCoord2ivARB = NULL;
PFNGLMULTITEXCOORD2SARBPROC glMultiTexCoord2sARB = NULL;
PFNGLMULTITEXCOORD2SVARBPROC glMultiTexCoord2svARB = NULL;
PFNGLMULTITEXCOORD3DARBPROC glMultiTexCoord3dARB = NULL;
PFNGLMULTITEXCOORD3DVARBPROC glMultiTexCoord3dvARB = NULL;
PFNGLMULTITEXCOORD3FARBPROC glMultiTexCoord3fARB = NULL;
PFNGLMULTITEXCOORD3FVARBPROC glMultiTexCoord3fvARB = NULL;
PFNGLMULTITEXCOORD3IARBPROC glMultiTexCoord3iARB = NULL;
PFNGLMULTITEXCOORD3IVARBPROC glMultiTexCoord3ivARB = NULL;
PFNGLMULTITEXCOORD3SARBPROC glMultiTexCoord3sARB = NULL;
PFNGLMULTITEXCOORD3SVARBPROC glMultiTexCoord3svARB = NULL;
PFNGLMULTITEXCOORD4DARBPROC glMultiTexCoord4dARB = NULL;
PFNGLMULTITEXCOORD4DVARBPROC glMultiTexCoord4dvARB = NULL;
PFNGLMULTITEXCOORD4FARBPROC glMultiTexCoord4fARB = NULL;
PFNGLMULTITEXCOORD4FVARBPROC glMultiTexCoord4fvARB = NULL;
PFNGLMULTITEXCOORD4IARBPROC glMultiTexCoord4iARB = NULL;
PFNGLMULTITEXCOORD4IVARBPROC glMultiTexCoord4ivARB = NULL;
PFNGLMULTITEXCOORD4SARBPROC glMultiTexCoord4sARB = NULL;
PFNGLMULTITEXCOORD4SVARBPROC glMultiTexCoord4svARB = NULL;
#endif // _WIN32
int CheckForARBMultitextureSupport(void) {
const char search[]="GL_ARB_multitexture";
int i, pos=0;
int maxpos=strlen(search)-1;
char extensions[10000];
printf("Getting GLstring, context is %p\n", glXGetCurrentContext());
strcpy(extensions,(const char *)glGetString(GL_EXTENSIONS));
printf("Examinig GLstring\n");
int len=strlen(extensions);
for ( i=0; i<len; i++) {
if ((i==0) || ((i>1) && extensions[i-1]==' ')) {
pos=0;
while(extensions[i]!=' ') {
if (extensions[i]==search[pos]) pos++;
if ((pos>maxpos) && extensions[i+1]==' ') {
//if (debug)
{
//fprintf(stderr, search);
//fprintf(stderr, " supported.\n");
}
return 1;
}
++i;
}
}
PFNGLACTIVETEXTUREARBPROC glActiveTextureARB = NULL;
PFNGLCLIENTACTIVETEXTUREARBPROC glClientActiveTextureARB = NULL;
PFNGLMULTITEXCOORD1DARBPROC glMultiTexCoord1dARB = NULL;
PFNGLMULTITEXCOORD1DVARBPROC glMultiTexCoord1dvARB = NULL;
PFNGLMULTITEXCOORD1FARBPROC glMultiTexCoord1fARB = NULL;
PFNGLMULTITEXCOORD1FVARBPROC glMultiTexCoord1fvARB = NULL;
PFNGLMULTITEXCOORD1IARBPROC glMultiTexCoord1iARB = NULL;
PFNGLMULTITEXCOORD1IVARBPROC glMultiTexCoord1ivARB = NULL;
PFNGLMULTITEXCOORD1SARBPROC glMultiTexCoord1sARB = NULL;
PFNGLMULTITEXCOORD1SVARBPROC glMultiTexCoord1svARB = NULL;
PFNGLMULTITEXCOORD2DARBPROC glMultiTexCoord2dARB = NULL;
PFNGLMULTITEXCOORD2DVARBPROC glMultiTexCoord2dvARB = NULL;
PFNGLMULTITEXCOORD2FARBPROC glMultiTexCoord2fARB = NULL;
PFNGLMULTITEXCOORD2FVARBPROC glMultiTexCoord2fvARB = NULL;
PFNGLMULTITEXCOORD2IARBPROC glMultiTexCoord2iARB = NULL;
PFNGLMULTITEXCOORD2IVARBPROC glMultiTexCoord2ivARB = NULL;
PFNGLMULTITEXCOORD2SARBPROC glMultiTexCoord2sARB = NULL;
PFNGLMULTITEXCOORD2SVARBPROC glMultiTexCoord2svARB = NULL;
PFNGLMULTITEXCOORD3DARBPROC glMultiTexCoord3dARB = NULL;
PFNGLMULTITEXCOORD3DVARBPROC glMultiTexCoord3dvARB = NULL;
PFNGLMULTITEXCOORD3FARBPROC glMultiTexCoord3fARB = NULL;
PFNGLMULTITEXCOORD3FVARBPROC glMultiTexCoord3fvARB = NULL;
PFNGLMULTITEXCOORD3IARBPROC glMultiTexCoord3iARB = NULL;
PFNGLMULTITEXCOORD3IVARBPROC glMultiTexCoord3ivARB = NULL;
PFNGLMULTITEXCOORD3SARBPROC glMultiTexCoord3sARB = NULL;
PFNGLMULTITEXCOORD3SVARBPROC glMultiTexCoord3svARB = NULL;
PFNGLMULTITEXCOORD4DARBPROC glMultiTexCoord4dARB = NULL;
PFNGLMULTITEXCOORD4DVARBPROC glMultiTexCoord4dvARB = NULL;
PFNGLMULTITEXCOORD4FARBPROC glMultiTexCoord4fARB = NULL;
PFNGLMULTITEXCOORD4FVARBPROC glMultiTexCoord4fvARB = NULL;
PFNGLMULTITEXCOORD4IARBPROC glMultiTexCoord4iARB = NULL;
PFNGLMULTITEXCOORD4IVARBPROC glMultiTexCoord4ivARB = NULL;
PFNGLMULTITEXCOORD4SARBPROC glMultiTexCoord4sARB = NULL;
PFNGLMULTITEXCOORD4SVARBPROC glMultiTexCoord4svARB = NULL;
#endif // _WIN32
int CheckForARBMultitextureSupport (void)
{
const char search[] = "GL_ARB_multitexture";
int i, pos = 0;
int maxpos = strlen (search) - 1;
char extensions[10000];
printf ("Getting GLstring, context is %p\n", glXGetCurrentContext ());
strcpy (extensions, (const char *) glGetString (GL_EXTENSIONS));
printf ("Examinig GLstring\n");
int len = strlen (extensions);
for (i = 0; i < len; i++)
{
if ((i == 0) || ((i > 1) && extensions[i - 1] == ' ')) {
pos = 0;
while (extensions[i] != ' ')
{
if (extensions[i] == search[pos])
pos++;
if ((pos > maxpos) && extensions[i + 1] == ' ') {
//if (debug)
{
//fprintf(stderr, search);
//fprintf(stderr, " supported.\n");
}
return 1;
}
++i;
}
}
}
//printf(search);
//printf(" not supported.\n");
return 0;
}
int GL_ARB_multitexture_Init (void)
{
if (!CheckForARBMultitextureSupport ())
return 0;
#ifdef _WIN32
glActiveTextureARB =
(PFNGLACTIVETEXTUREARBPROC) wglGetProcAddress ("glActiveTextureARB");
if (glActiveTextureARB == NULL) {
fprintf (stderr, "glActiveTextureARB not found.\n");
return 0;
}
//printf(search);
//printf(" not supported.\n");
return 0;
}
int GL_ARB_multitexture_Init(void) {
if (!CheckForARBMultitextureSupport()) return 0;
#ifdef _WIN32
glActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC) wglGetProcAddress("glActiveTextureARB");
if (glActiveTextureARB==NULL) {fprintf(stderr,"glActiveTextureARB not found.\n"); return 0; }
glClientActiveTextureARB = (PFNGLCLIENTACTIVETEXTUREARBPROC) wglGetProcAddress("glClientActiveTextureARB");
if (glClientActiveTextureARB==NULL) {fprintf(stderr,"glClientActiveTextureARB not found.\n"); return 0; }
glMultiTexCoord1dARB = (PFNGLMULTITEXCOORD1DARBPROC) wglGetProcAddress("glMultiTexCoord1dARB");
if (glMultiTexCoord1dARB==NULL) {fprintf(stderr,"glMultiTexCoord1dARB not found.\n"); return 0; }
glMultiTexCoord1dvARB = (PFNGLMULTITEXCOORD1DVARBPROC) wglGetProcAddress("glMultiTexCoord1dvARB");
if (glMultiTexCoord1dvARB==NULL) {fprintf(stderr,"glMultiTexCoord1dAvRB not found.\n"); return 0; }
glMultiTexCoord1fARB = (PFNGLMULTITEXCOORD1FARBPROC) wglGetProcAddress("glMultiTexCoord1fARB");
if (glMultiTexCoord1fARB==NULL) {fprintf(stderr,"glMultiTexCoord1fARB not found.\n"); return 0; }
glMultiTexCoord1fvARB = (PFNGLMULTITEXCOORD1FVARBPROC) wglGetProcAddress("glMultiTexCoord1fvARB");
if (glMultiTexCoord1fvARB==NULL) {fprintf(stderr,"glMultiTexCoord1fvARB not found.\n"); return 0; }
glMultiTexCoord1iARB = (PFNGLMULTITEXCOORD1IARBPROC) wglGetProcAddress("glMultiTexCoord1iARB");
if (glMultiTexCoord1iARB==NULL) {fprintf(stderr,"glMultiTexCoord1iARB not found.\n"); return 0; }
glMultiTexCoord1ivARB = (PFNGLMULTITEXCOORD1IVARBPROC) wglGetProcAddress("glMultiTexCoord1ivARB");
if (glMultiTexCoord1ivARB==NULL) {fprintf(stderr,"glMultiTexCoord1ivARB not found.\n"); return 0; }
glMultiTexCoord1sARB = (PFNGLMULTITEXCOORD1SARBPROC) wglGetProcAddress("glMultiTexCoord1sARB");
if (glMultiTexCoord1sARB==NULL) {fprintf(stderr,"glMultiTexCoord1sARB not found.\n"); return 0; }
glMultiTexCoord1svARB = (PFNGLMULTITEXCOORD1SVARBPROC) wglGetProcAddress("glMultiTexCoord1svARB");
if (glMultiTexCoord1svARB==NULL) {fprintf(stderr,"glMultiTexCoord1svARB not found.\n"); return 0; }
glMultiTexCoord2dARB = (PFNGLMULTITEXCOORD2DARBPROC) wglGetProcAddress("glMultiTexCoord2dARB");
if (glMultiTexCoord2dARB==NULL) {fprintf(stderr,"glMultiTexCoord2dARB not found.\n"); return 0; }
glMultiTexCoord2dvARB = (PFNGLMULTITEXCOORD2DVARBPROC) wglGetProcAddress("glMultiTexCoord2dvARB");
if (glMultiTexCoord2dvARB==NULL) {fprintf(stderr,"glMultiTexCoord2dAvRB not found.\n"); return 0; }
glMultiTexCoord2fARB = (PFNGLMULTITEXCOORD2FARBPROC) wglGetProcAddress("glMultiTexCoord2fARB");
if (glMultiTexCoord2fARB==NULL) {fprintf(stderr,"glMultiTexCoord2fARB not found.\n"); return 0; }
glMultiTexCoord2fvARB = (PFNGLMULTITEXCOORD2FVARBPROC) wglGetProcAddress("glMultiTexCoord2fvARB");
if (glMultiTexCoord2fvARB==NULL) {fprintf(stderr,"glMultiTexCoord2fvARB not found.\n"); return 0; }
glMultiTexCoord2iARB = (PFNGLMULTITEXCOORD2IARBPROC) wglGetProcAddress("glMultiTexCoord2iARB");
if (glMultiTexCoord2iARB==NULL) {fprintf(stderr,"glMultiTexCoord2iARB not found.\n"); return 0; }
glMultiTexCoord2ivARB = (PFNGLMULTITEXCOORD2IVARBPROC) wglGetProcAddress("glMultiTexCoord2ivARB");
if (glMultiTexCoord2ivARB==NULL) {fprintf(stderr,"glMultiTexCoord2ivARB not found.\n"); return 0; }
glMultiTexCoord2sARB = (PFNGLMULTITEXCOORD2SARBPROC) wglGetProcAddress("glMultiTexCoord2sARB");
if (glMultiTexCoord2sARB==NULL) {fprintf(stderr,"glMultiTexCoord2sARB not found.\n"); return 0; }
glMultiTexCoord2svARB = (PFNGLMULTITEXCOORD2SVARBPROC) wglGetProcAddress("glMultiTexCoord2svARB");
if (glMultiTexCoord2svARB==NULL) {fprintf(stderr,"glMultiTexCoord2svARB not found.\n"); return 0; }
glMultiTexCoord3dARB = (PFNGLMULTITEXCOORD3DARBPROC) wglGetProcAddress("glMultiTexCoord3dARB");
if (glMultiTexCoord3dARB==NULL) {fprintf(stderr,"glMultiTexCoord3dARB not found.\n"); return 0; }
glMultiTexCoord3dvARB = (PFNGLMULTITEXCOORD3DVARBPROC) wglGetProcAddress("glMultiTexCoord3dvARB");
if (glMultiTexCoord3dvARB==NULL) {fprintf(stderr,"glMultiTexCoord3dAvRB not found.\n"); return 0; }
glMultiTexCoord3fARB = (PFNGLMULTITEXCOORD3FARBPROC) wglGetProcAddress("glMultiTexCoord3fARB");
if (glMultiTexCoord3fARB==NULL) {fprintf(stderr,"glMultiTexCoord3fARB not found.\n"); return 0; }
glMultiTexCoord3fvARB = (PFNGLMULTITEXCOORD3FVARBPROC) wglGetProcAddress("glMultiTexCoord3fvARB");
if (glMultiTexCoord3fvARB==NULL) {fprintf(stderr,"glMultiTexCoord3fvARB not found.\n"); return 0; }
glMultiTexCoord3iARB = (PFNGLMULTITEXCOORD3IARBPROC) wglGetProcAddress("glMultiTexCoord3iARB");
if (glMultiTexCoord3iARB==NULL) {fprintf(stderr,"glMultiTexCoord3iARB not found.\n"); return 0; }
glMultiTexCoord3ivARB = (PFNGLMULTITEXCOORD3IVARBPROC) wglGetProcAddress("glMultiTexCoord3ivARB");
if (glMultiTexCoord3ivARB==NULL) {fprintf(stderr,"glMultiTexCoord3ivARB not found.\n"); return 0; }
glMultiTexCoord3sARB = (PFNGLMULTITEXCOORD3SARBPROC) wglGetProcAddress("glMultiTexCoord3sARB");
if (glMultiTexCoord3sARB==NULL) {fprintf(stderr,"glMultiTexCoord3sARB not found.\n"); return 0; }
glMultiTexCoord3svARB = (PFNGLMULTITEXCOORD3SVARBPROC) wglGetProcAddress("glMultiTexCoord3svARB");
if (glMultiTexCoord3svARB==NULL) {fprintf(stderr,"glMultiTexCoord3svARB not found.\n"); return 0; }
glMultiTexCoord4dARB = (PFNGLMULTITEXCOORD4DARBPROC) wglGetProcAddress("glMultiTexCoord4dARB");
if (glMultiTexCoord4dARB==NULL) {fprintf(stderr,"glMultiTexCoord4dARB not found.\n"); return 0; }
glMultiTexCoord4dvARB = (PFNGLMULTITEXCOORD4DVARBPROC) wglGetProcAddress("glMultiTexCoord4dvARB");
if (glMultiTexCoord4dvARB==NULL) {fprintf(stderr,"glMultiTexCoord4dAvRB not found.\n"); return 0; }
glMultiTexCoord4fARB = (PFNGLMULTITEXCOORD4FARBPROC) wglGetProcAddress("glMultiTexCoord4fARB");
if (glMultiTexCoord4fARB==NULL) {fprintf(stderr,"glMultiTexCoord4fARB not found.\n"); return 0; }
glMultiTexCoord4fvARB = (PFNGLMULTITEXCOORD4FVARBPROC) wglGetProcAddress("glMultiTexCoord4fvARB");
if (glMultiTexCoord4fvARB==NULL) {fprintf(stderr,"glMultiTexCoord4fvARB not found.\n"); return 0; }
glMultiTexCoord4iARB = (PFNGLMULTITEXCOORD4IARBPROC) wglGetProcAddress("glMultiTexCoord4iARB");
if (glMultiTexCoord4iARB==NULL) {fprintf(stderr,"glMultiTexCoord4iARB not found.\n"); return 0; }
glMultiTexCoord4ivARB = (PFNGLMULTITEXCOORD4IVARBPROC) wglGetProcAddress("glMultiTexCoord4ivARB");
if (glMultiTexCoord4ivARB==NULL) {fprintf(stderr,"glMultiTexCoord4ivARB not found.\n"); return 0; }
glMultiTexCoord4sARB = (PFNGLMULTITEXCOORD4SARBPROC) wglGetProcAddress("glMultiTexCoord4sARB");
if (glMultiTexCoord4sARB==NULL) {fprintf(stderr,"glMultiTexCoord4sARB not found.\n"); return 0; }
glMultiTexCoord4svARB = (PFNGLMULTITEXCOORD4SVARBPROC) wglGetProcAddress("glMultiTexCoord4svARB");
if (glMultiTexCoord4svARB==NULL) {fprintf(stderr,"glMultiTexCoord4svARB not found.\n"); return 0; }
glClientActiveTextureARB = (PFNGLCLIENTACTIVETEXTUREARBPROC)
wglGetProcAddress ("glClientActiveTextureARB");
if (glClientActiveTextureARB == NULL) {
fprintf (stderr, "glClientActiveTextureARB not found.\n");
return 0;
}
glMultiTexCoord1dARB = (PFNGLMULTITEXCOORD1DARBPROC)
wglGetProcAddress ("glMultiTexCoord1dARB");
if (glMultiTexCoord1dARB == NULL) {
fprintf (stderr, "glMultiTexCoord1dARB not found.\n");
return 0;
}
glMultiTexCoord1dvARB = (PFNGLMULTITEXCOORD1DVARBPROC)
wglGetProcAddress ("glMultiTexCoord1dvARB");
if (glMultiTexCoord1dvARB == NULL) {
fprintf (stderr, "glMultiTexCoord1dAvRB not found.\n");
return 0;
}
glMultiTexCoord1fARB = (PFNGLMULTITEXCOORD1FARBPROC)
wglGetProcAddress ("glMultiTexCoord1fARB");
if (glMultiTexCoord1fARB == NULL) {
fprintf (stderr, "glMultiTexCoord1fARB not found.\n");
return 0;
}
glMultiTexCoord1fvARB = (PFNGLMULTITEXCOORD1FVARBPROC)
wglGetProcAddress ("glMultiTexCoord1fvARB");
if (glMultiTexCoord1fvARB == NULL) {
fprintf (stderr, "glMultiTexCoord1fvARB not found.\n");
return 0;
}
glMultiTexCoord1iARB = (PFNGLMULTITEXCOORD1IARBPROC)
wglGetProcAddress ("glMultiTexCoord1iARB");
if (glMultiTexCoord1iARB == NULL) {
fprintf (stderr, "glMultiTexCoord1iARB not found.\n");
return 0;
}
glMultiTexCoord1ivARB = (PFNGLMULTITEXCOORD1IVARBPROC)
wglGetProcAddress ("glMultiTexCoord1ivARB");
if (glMultiTexCoord1ivARB == NULL) {
fprintf (stderr, "glMultiTexCoord1ivARB not found.\n");
return 0;
}
glMultiTexCoord1sARB = (PFNGLMULTITEXCOORD1SARBPROC)
wglGetProcAddress ("glMultiTexCoord1sARB");
if (glMultiTexCoord1sARB == NULL) {
fprintf (stderr, "glMultiTexCoord1sARB not found.\n");
return 0;
}
glMultiTexCoord1svARB = (PFNGLMULTITEXCOORD1SVARBPROC)
wglGetProcAddress ("glMultiTexCoord1svARB");
if (glMultiTexCoord1svARB == NULL) {
fprintf (stderr, "glMultiTexCoord1svARB not found.\n");
return 0;
}
glMultiTexCoord2dARB = (PFNGLMULTITEXCOORD2DARBPROC)
wglGetProcAddress ("glMultiTexCoord2dARB");
if (glMultiTexCoord2dARB == NULL) {
fprintf (stderr, "glMultiTexCoord2dARB not found.\n");
return 0;
}
glMultiTexCoord2dvARB = (PFNGLMULTITEXCOORD2DVARBPROC)
wglGetProcAddress ("glMultiTexCoord2dvARB");
if (glMultiTexCoord2dvARB == NULL) {
fprintf (stderr, "glMultiTexCoord2dAvRB not found.\n");
return 0;
}
glMultiTexCoord2fARB = (PFNGLMULTITEXCOORD2FARBPROC)
wglGetProcAddress ("glMultiTexCoord2fARB");
if (glMultiTexCoord2fARB == NULL) {
fprintf (stderr, "glMultiTexCoord2fARB not found.\n");
return 0;
}
glMultiTexCoord2fvARB = (PFNGLMULTITEXCOORD2FVARBPROC)
wglGetProcAddress ("glMultiTexCoord2fvARB");
if (glMultiTexCoord2fvARB == NULL) {
fprintf (stderr, "glMultiTexCoord2fvARB not found.\n");
return 0;
}
glMultiTexCoord2iARB = (PFNGLMULTITEXCOORD2IARBPROC)
wglGetProcAddress ("glMultiTexCoord2iARB");
if (glMultiTexCoord2iARB == NULL) {
fprintf (stderr, "glMultiTexCoord2iARB not found.\n");
return 0;
}
glMultiTexCoord2ivARB = (PFNGLMULTITEXCOORD2IVARBPROC)
wglGetProcAddress ("glMultiTexCoord2ivARB");
if (glMultiTexCoord2ivARB == NULL) {
fprintf (stderr, "glMultiTexCoord2ivARB not found.\n");
return 0;
}
glMultiTexCoord2sARB = (PFNGLMULTITEXCOORD2SARBPROC)
wglGetProcAddress ("glMultiTexCoord2sARB");
if (glMultiTexCoord2sARB == NULL) {
fprintf (stderr, "glMultiTexCoord2sARB not found.\n");
return 0;
}
glMultiTexCoord2svARB = (PFNGLMULTITEXCOORD2SVARBPROC)
wglGetProcAddress ("glMultiTexCoord2svARB");
if (glMultiTexCoord2svARB == NULL) {
fprintf (stderr, "glMultiTexCoord2svARB not found.\n");
return 0;
}
glMultiTexCoord3dARB = (PFNGLMULTITEXCOORD3DARBPROC)
wglGetProcAddress ("glMultiTexCoord3dARB");
if (glMultiTexCoord3dARB == NULL) {
fprintf (stderr, "glMultiTexCoord3dARB not found.\n");
return 0;
}
glMultiTexCoord3dvARB = (PFNGLMULTITEXCOORD3DVARBPROC)
wglGetProcAddress ("glMultiTexCoord3dvARB");
if (glMultiTexCoord3dvARB == NULL) {
fprintf (stderr, "glMultiTexCoord3dAvRB not found.\n");
return 0;
}
glMultiTexCoord3fARB = (PFNGLMULTITEXCOORD3FARBPROC)
wglGetProcAddress ("glMultiTexCoord3fARB");
if (glMultiTexCoord3fARB == NULL) {
fprintf (stderr, "glMultiTexCoord3fARB not found.\n");
return 0;
}
glMultiTexCoord3fvARB = (PFNGLMULTITEXCOORD3FVARBPROC)
wglGetProcAddress ("glMultiTexCoord3fvARB");
if (glMultiTexCoord3fvARB == NULL) {
fprintf (stderr, "glMultiTexCoord3fvARB not found.\n");
return 0;
}
glMultiTexCoord3iARB = (PFNGLMULTITEXCOORD3IARBPROC)
wglGetProcAddress ("glMultiTexCoord3iARB");
if (glMultiTexCoord3iARB == NULL) {
fprintf (stderr, "glMultiTexCoord3iARB not found.\n");
return 0;
}
glMultiTexCoord3ivARB = (PFNGLMULTITEXCOORD3IVARBPROC)
wglGetProcAddress ("glMultiTexCoord3ivARB");
if (glMultiTexCoord3ivARB == NULL) {
fprintf (stderr, "glMultiTexCoord3ivARB not found.\n");
return 0;
}
glMultiTexCoord3sARB = (PFNGLMULTITEXCOORD3SARBPROC)
wglGetProcAddress ("glMultiTexCoord3sARB");
if (glMultiTexCoord3sARB == NULL) {
fprintf (stderr, "glMultiTexCoord3sARB not found.\n");
return 0;
}
glMultiTexCoord3svARB = (PFNGLMULTITEXCOORD3SVARBPROC)
wglGetProcAddress ("glMultiTexCoord3svARB");
if (glMultiTexCoord3svARB == NULL) {
fprintf (stderr, "glMultiTexCoord3svARB not found.\n");
return 0;
}
glMultiTexCoord4dARB = (PFNGLMULTITEXCOORD4DARBPROC)
wglGetProcAddress ("glMultiTexCoord4dARB");
if (glMultiTexCoord4dARB == NULL) {
fprintf (stderr, "glMultiTexCoord4dARB not found.\n");
return 0;
}
glMultiTexCoord4dvARB = (PFNGLMULTITEXCOORD4DVARBPROC)
wglGetProcAddress ("glMultiTexCoord4dvARB");
if (glMultiTexCoord4dvARB == NULL) {
fprintf (stderr, "glMultiTexCoord4dAvRB not found.\n");
return 0;
}
glMultiTexCoord4fARB = (PFNGLMULTITEXCOORD4FARBPROC)
wglGetProcAddress ("glMultiTexCoord4fARB");
if (glMultiTexCoord4fARB == NULL) {
fprintf (stderr, "glMultiTexCoord4fARB not found.\n");
return 0;
}
glMultiTexCoord4fvARB = (PFNGLMULTITEXCOORD4FVARBPROC)
wglGetProcAddress ("glMultiTexCoord4fvARB");
if (glMultiTexCoord4fvARB == NULL) {
fprintf (stderr, "glMultiTexCoord4fvARB not found.\n");
return 0;
}
glMultiTexCoord4iARB = (PFNGLMULTITEXCOORD4IARBPROC)
wglGetProcAddress ("glMultiTexCoord4iARB");
if (glMultiTexCoord4iARB == NULL) {
fprintf (stderr, "glMultiTexCoord4iARB not found.\n");
return 0;
}
glMultiTexCoord4ivARB = (PFNGLMULTITEXCOORD4IVARBPROC)
wglGetProcAddress ("glMultiTexCoord4ivARB");
if (glMultiTexCoord4ivARB == NULL) {
fprintf (stderr, "glMultiTexCoord4ivARB not found.\n");
return 0;
}
glMultiTexCoord4sARB = (PFNGLMULTITEXCOORD4SARBPROC)
wglGetProcAddress ("glMultiTexCoord4sARB");
if (glMultiTexCoord4sARB == NULL) {
fprintf (stderr, "glMultiTexCoord4sARB not found.\n");
return 0;
}
glMultiTexCoord4svARB = (PFNGLMULTITEXCOORD4SVARBPROC)
wglGetProcAddress ("glMultiTexCoord4svARB");
if (glMultiTexCoord4svARB == NULL) {
fprintf (stderr, "glMultiTexCoord4svARB not found.\n");
return 0;
}
#endif // _WIN32
return 1;
}
return 1;
}
#endif // ARB_MULTITEXTURE_INITIALIZE
#ifdef __cplusplus
}
#endif
#endif /* */
#endif // not __ARB_MULTITEXTURE_H_

217
gst/gl/EXT_paletted_texture.h
View file

@ -7,42 +7,42 @@
* *
* version 1.0ß *
* *
*************************************************************/
*************************************************************/
#ifndef __EXT_paletted_texture_H_
#define __EXT_paletted_texture_H_
/*
* GLOBAL SWITCHES - enable/disable advanced features of this header
*
*/
#define EXT_PALETTED_TEXTURE_INITIALIZE 1 // enable generic init-routines
*/
#define EXT_PALETTED_TEXTURE_INITIALIZE 1 // enable generic init-routines
#ifndef _WIN32
#define GL_GLEXT_PROTOTYPES 1
#endif
#endif /* */
#ifdef __cplusplus
extern "C" {
#endif
extern "C"
{
#endif /* */
#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__)
#define WIN32_LEAN_AND_MEAN 1
#include <windows.h>
#endif
#endif /* */
#ifndef APIENTRY
#define APIENTRY
#endif
#endif /* */
// Header file version number, required by OpenGL ABI for Linux
//#define GL_GLEXT_VERSION 7
/*
* NEW TOKENS TO OPENGL 1.2.1
*
*/
*/
#ifndef GL_EXT_paletted_texture
#define GL_COLOR_INDEX1_EXT 0x80E2
#define GL_COLOR_INDEX2_EXT 0x80E3
@ -60,83 +60,128 @@ extern "C" {
#define GL_COLOR_TABLE_INTENSITY_SIZE_EXT 0x80DF
#define GL_TEXTURE_INDEX_SIZE_EXT 0x80ED
#define GL_EXT_paletted_texture 1
#endif
#endif /* */
#ifndef _WIN32
#ifdef GL_GLEXT_PROTOTYPES
extern void APIENTRY glColorTableEXT (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *);
extern void APIENTRY glColorSubTableEXT(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
extern void APIENTRY glGetColorTableEXT(GLenum, GLenum, GLenum, GLvoid *);
extern void APIENTRY glGetColorTableParameterivEXT(GLenum, GLenum, GLint *);
extern void APIENTRY glGetColorTableParameterfvEXT(GLenum, GLenum, GLfloat *);
#endif // GL_GLEXT_PROTOTYPES
#else // _WIN32
typedef void (APIENTRY * PFNGLCOLORTABLEEXTPROC) (GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const GLvoid *data);
typedef void (APIENTRY * PFNGLCOLORSUBTABLEEXTPROC)(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data);
typedef void (APIENTRY * PFNGLGETCOLORTABLEEXTPROC)(GLenum target, GLenum format, GLenum type, GLvoid *data);
typedef void (APIENTRY * PFNGLGETCOLORTABLEPARAMETERIVEXTPROC)(GLenum target, GLenum pname, GLint *params);
typedef void (APIENTRY * PFNGLGETCOLORTABLEPARAMETERFVEXTPROC)(GLenum target, GLenum pname, GLfloat *params);
#endif // not _WIN32
extern void APIENTRY glColorTableEXT (GLenum, GLenum, GLsizei, GLenum, GLenum,
const GLvoid *);
extern void APIENTRY glColorSubTableEXT (GLenum, GLsizei, GLsizei, GLenum,
GLenum, const GLvoid *);
extern void APIENTRY glGetColorTableEXT (GLenum, GLenum, GLenum, GLvoid *);
extern void APIENTRY glGetColorTableParameterivEXT (GLenum, GLenum,
GLint *);
extern void APIENTRY glGetColorTableParameterfvEXT (GLenum, GLenum,
GLfloat *);
#endif // GL_GLEXT_PROTOTYPES
#else // _WIN32
typedef void (APIENTRY * PFNGLCOLORTABLEEXTPROC) (GLenum target,
GLenum internalFormat, GLsizei width, GLenum format, GLenum type,
const GLvoid * data);
typedef void (APIENTRY * PFNGLCOLORSUBTABLEEXTPROC) (GLenum target,
GLsizei start, GLsizei count, GLenum format, GLenum type,
const GLvoid * data);
typedef void (APIENTRY * PFNGLGETCOLORTABLEEXTPROC) (GLenum target,
GLenum format, GLenum type, GLvoid * data);
typedef void (APIENTRY *
PFNGLGETCOLORTABLEPARAMETERIVEXTPROC) (GLenum target, GLenum pname,
GLint * params);
typedef void (APIENTRY *
PFNGLGETCOLORTABLEPARAMETERFVEXTPROC) (GLenum target, GLenum pname,
GLfloat * params);
#endif // not _WIN32
#ifdef EXT_PALETTED_TEXTURE_INITIALIZE
#include<string.h> // string manipulation for runtime-check
#include<string.h> // string manipulation for runtime-check
#ifdef _WIN32
PFNGLCOLORTABLEEXTPROC glColorTableEXT = NULL;
PFNGLCOLORSUBTABLEEXTPROC glColorSubTableEXT = NULL;
PFNGLGETCOLORTABLEEXTPROC glGetColorTableEXT = NULL;
PFNGLGETCOLORTABLEPARAMETERIVEXTPROC glGetColorTableParameterivEXT = NULL;
PFNGLGETCOLORTABLEPARAMETERFVEXTPROC glGetColorTableParameterfvEXT = NULL;
#endif // _WIN32
int CheckForEXTPalettedTextureSupport(void) {
const char search[]="GL_EXT_paletted_texture";
int i, pos=0;
int maxpos=strlen(search)-1;
char extensions[10000];
strcpy(extensions,(const char *)glGetString(GL_EXTENSIONS));
int len=strlen(extensions);
for (i=0; i<len; i++) {
if ((i==0) || ((i>1) && extensions[i-1]==' ')) {
pos=0;
while(extensions[i]!=' ') {
if (extensions[i]==search[pos]) pos++;
if ((pos>maxpos) && extensions[i+1]==' ') {
//printf(search);
//printf(" supported.\n");
return 1;
}
i++;
}
}
PFNGLCOLORTABLEEXTPROC glColorTableEXT = NULL;
PFNGLCOLORSUBTABLEEXTPROC glColorSubTableEXT = NULL;
PFNGLGETCOLORTABLEEXTPROC glGetColorTableEXT = NULL;
PFNGLGETCOLORTABLEPARAMETERIVEXTPROC glGetColorTableParameterivEXT = NULL;
PFNGLGETCOLORTABLEPARAMETERFVEXTPROC glGetColorTableParameterfvEXT = NULL;
#endif // _WIN32
int CheckForEXTPalettedTextureSupport (void)
{
const char search[] = "GL_EXT_paletted_texture";
int i, pos = 0;
int maxpos = strlen (search) - 1;
char extensions[10000];
strcpy (extensions, (const char *) glGetString (GL_EXTENSIONS));
int len = strlen (extensions);
for (i = 0; i < len; i++)
{
if ((i == 0) || ((i > 1) && extensions[i - 1] == ' ')) {
pos = 0;
while (extensions[i] != ' ')
{
if (extensions[i] == search[pos])
pos++;
if ((pos > maxpos) && extensions[i + 1] == ' ') {
//printf(search);
//printf(" supported.\n");
return 1;
}
i++;
}
}
}
//printf(search);
//printf(" not supported.\n");
return 0;
}
int GL_EXT_paletted_texture_Init (void)
{
if (!CheckForEXTPalettedTextureSupport ())
return 0;
#ifdef _WIN32
glColorTableEXT =
(PFNGLCOLORTABLEEXTPROC) wglGetProcAddress ("glColorTableEXT");
if (glColorTableEXT == NULL) {
fprintf (stderr, "glColorTableEXT not found.\n");
return 0;
}
//printf(search);
//printf(" not supported.\n");
return 0;
}
int GL_EXT_paletted_texture_Init(void) {
if (!CheckForEXTPalettedTextureSupport()) return 0;
#ifdef _WIN32
glColorTableEXT = (PFNGLCOLORTABLEEXTPROC) wglGetProcAddress("glColorTableEXT");
if (glColorTableEXT==NULL) {fprintf(stderr,"glColorTableEXT not found.\n"); return 0;}
glColorSubTableEXT = (PFNGLCOLORSUBTABLEEXTPROC) wglGetProcAddress("glColorSubTableEXT");
if (glColorSubTableEXT==NULL) {fprintf(stderr,"glColorSubTableEXT not found.\n"); return 0;}
glGetColorTableEXT = (PFNGLGETCOLORTABLEEXTPROC) wglGetProcAddress("glGetColorTableEXT");
if (glGetColorTableEXT==NULL) {fprintf(stderr,"glGetColorTableEXT not found.\n"); return 0;}
glGetColorTableParameterivEXT = (PFNGLGETCOLORTABLEPARAMETERIVEXTPROC) wglGetProcAddress("glGetColorTableParameterivEXT");
if (glGetColorTableParameterivEXT==NULL) {fprintf(stderr,"glGetColorTableParameterivEXT not found.\n"); return 0;}
glGetColorTableParameterfvEXT = (PFNGLGETCOLORTABLEPARAMETERFVEXTPROC) wglGetProcAddress("glGetColorTableParameterfvEXT");
if (glGetColorTableParameterfvEXT==NULL) {fprintf(stderr,"glGetColorTableParameterfvEXT not found.\n"); return 0;}
glColorSubTableEXT =
(PFNGLCOLORSUBTABLEEXTPROC) wglGetProcAddress ("glColorSubTableEXT");
if (glColorSubTableEXT == NULL) {
fprintf (stderr, "glColorSubTableEXT not found.\n");
return 0;
}
glGetColorTableEXT =
(PFNGLGETCOLORTABLEEXTPROC) wglGetProcAddress ("glGetColorTableEXT");
if (glGetColorTableEXT == NULL) {
fprintf (stderr, "glGetColorTableEXT not found.\n");
return 0;
}
glGetColorTableParameterivEXT = (PFNGLGETCOLORTABLEPARAMETERIVEXTPROC)
wglGetProcAddress ("glGetColorTableParameterivEXT");
if (glGetColorTableParameterivEXT == NULL) {
fprintf (stderr, "glGetColorTableParameterivEXT not found.\n");
return 0;
}
glGetColorTableParameterfvEXT = (PFNGLGETCOLORTABLEPARAMETERFVEXTPROC)
wglGetProcAddress ("glGetColorTableParameterfvEXT");
if (glGetColorTableParameterfvEXT == NULL) {
fprintf (stderr, "glGetColorTableParameterfvEXT not found.\n");
return 0;
}
#endif // _WIN32
return 1;
}
}
#endif // EXT_PALETTED_TEXTURE_INITIALIZE
#ifdef __cplusplus
}
#endif
#endif /* */
#endif // not __EXT_PALETTED_TEXTURE_H_

359
gst/gl/NV_register_combiners.h
View file

@ -7,42 +7,42 @@
* *
* version 2.0ß *
* *
*************************************************************/
*************************************************************/
#ifndef __NV_register_combiners_H_
#define __NV_register_combiners_H_
/*
* GLOBAL SWITCHES - enable/disable advanced features of this header
*
*/
#define NV_REGISTER_COMBINERS_INITIALIZE 1 // enable generic init-routines
*/
#define NV_REGISTER_COMBINERS_INITIALIZE 1 // enable generic init-routines
#ifndef _WIN32
#define GL_GLEXT_PROTOTYPES 1
#endif
#endif /* */
#ifdef __cplusplus
extern "C" {
#endif
extern "C"
{
#endif /* */
#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__)
#define WIN32_LEAN_AND_MEAN 1
#include <windows.h>
#endif
#endif /* */
#ifndef APIENTRY
#define APIENTRY
#endif
#endif /* */
// Header file version number, required by OpenGL ABI for Linux
//#define GL_GLEXT_VERSION 7
/*
* NEW TOKENS TO OPENGL 1.2.1
*
*/
*/
#ifndef GL_NV_register_combiners
#define GL_REGISTER_COMBINERS_NV 0x8522
#define GL_COMBINER0_NV 0x8550
@ -96,123 +96,228 @@ extern "C" {
#define GL_COLOR_SUM_CLAMP_NV 0x854F
#define GL_MAX_GENERAL_COMBINERS_NV 0x854D
#define GL_NV_register_combiners 1
#endif
#endif /* */
#ifndef _WIN32
#ifdef GL_GLEXT_PROTOTYPES
extern void APIENTRY glCombinerParameterfvNV(GLenum, const GLfloat *);
extern void APIENTRY glCombinerParameterivNV(GLenum, const GLint *);
extern void APIENTRY glCombinerParameterfNV (GLenum, GLfloat);
extern void APIENTRY glCombinerParameteriNV (GLenum, GLint);
extern void APIENTRY glCombinerInputNV (GLenum, GLenum, GLenum, GLenum, GLenum, GLenum);
extern void APIENTRY glCombinerOutputNV (GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLboolean, GLboolean, GLboolean);
extern void APIENTRY glFinalCombinerInputNV (GLenum, GLenum, GLenum, GLenum);
extern void APIENTRY glGetCombinerInputParameterfvNV (GLenum, GLenum, GLenum, GLenum, GLfloat *);
extern void APIENTRY glGetCombinerInputParameterivNV (GLenum, GLenum, GLenum, GLenum, GLint *);
extern void APIENTRY glGetCombinerOutputParameterfvNV(GLenum, GLenum, GLenum, GLfloat *);
extern void APIENTRY glGetCombinerOutputParameterivNV(GLenum, GLenum, GLenum, GLint *);
extern void APIENTRY glGetFinalCombinerInputParameterfvNV(GLenum, GLenum, GLfloat *);
extern void APIENTRY glGetFinalCombinerInputParameterivNV(GLenum, GLenum, GLint *);
#endif // GL_GLEXT_PROTOTYPES
#else // _WIN32
typedef void (APIENTRY * PFNGLCOMBINERPARAMETERFVNVPROC) (GLenum pname, const GLfloat *params);
typedef void (APIENTRY * PFNGLCOMBINERPARAMETERIVNVPROC) (GLenum pname, const GLint *params);
typedef void (APIENTRY * PFNGLCOMBINERPARAMETERFNVPROC) (GLenum pname, GLfloat param);
typedef void (APIENTRY * PFNGLCOMBINERPARAMETERINVPROC) (GLenum pname, GLint param);
typedef void (APIENTRY * PFNGLCOMBINERINPUTNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage);
typedef void (APIENTRY * PFNGLCOMBINEROUTPUTNVPROC) (GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum);
typedef void (APIENTRY * PFNGLFINALCOMBINERINPUTNVPROC) (GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage);
typedef void (APIENTRY * PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat *params);
typedef void (APIENTRY * PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint *params);
typedef void (APIENTRY * PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC)(GLenum stage, GLenum portion, GLenum pname, GLfloat *params);
typedef void (APIENTRY * PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC)(GLenum stage, GLenum portion, GLenum pname, GLint *params);
typedef void (APIENTRY * PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC)(GLenum variable, GLenum pname, GLfloat *params);
typedef void (APIENTRY * PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC)(GLenum variable, GLenum pname, GLint *params);
#endif // not _WIN32
extern void APIENTRY glCombinerParameterfvNV (GLenum, const GLfloat *);
extern void APIENTRY glCombinerParameterivNV (GLenum, const GLint *);
extern void APIENTRY glCombinerParameterfNV (GLenum, GLfloat);
extern void APIENTRY glCombinerParameteriNV (GLenum, GLint);
extern void APIENTRY glCombinerInputNV (GLenum, GLenum, GLenum, GLenum,
GLenum, GLenum);
extern void APIENTRY glCombinerOutputNV (GLenum, GLenum, GLenum, GLenum,
GLenum, GLenum, GLenum, GLboolean, GLboolean, GLboolean);
extern void APIENTRY glFinalCombinerInputNV (GLenum, GLenum, GLenum,
GLenum);
extern void APIENTRY glGetCombinerInputParameterfvNV (GLenum, GLenum,
GLenum, GLenum, GLfloat *);
extern void APIENTRY glGetCombinerInputParameterivNV (GLenum, GLenum,
GLenum, GLenum, GLint *);
extern void APIENTRY glGetCombinerOutputParameterfvNV (GLenum, GLenum,
GLenum, GLfloat *);
extern void APIENTRY glGetCombinerOutputParameterivNV (GLenum, GLenum,
GLenum, GLint *);
extern void APIENTRY glGetFinalCombinerInputParameterfvNV (GLenum, GLenum,
GLfloat *);
extern void APIENTRY glGetFinalCombinerInputParameterivNV (GLenum, GLenum,
GLint *);
#endif // GL_GLEXT_PROTOTYPES
#else // _WIN32
typedef void (APIENTRY * PFNGLCOMBINERPARAMETERFVNVPROC) (GLenum pname,
const GLfloat * params);
typedef void (APIENTRY * PFNGLCOMBINERPARAMETERIVNVPROC) (GLenum pname,
const GLint * params);
typedef void (APIENTRY * PFNGLCOMBINERPARAMETERFNVPROC) (GLenum pname,
GLfloat param);
typedef void (APIENTRY * PFNGLCOMBINERPARAMETERINVPROC) (GLenum pname,
GLint param);
typedef void (APIENTRY * PFNGLCOMBINERINPUTNVPROC) (GLenum stage,
GLenum portion, GLenum variable, GLenum input, GLenum mapping,
GLenum componentUsage);
typedef void (APIENTRY * PFNGLCOMBINEROUTPUTNVPROC) (GLenum stage,
GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput,
GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct,
GLboolean muxSum);
typedef void (APIENTRY * PFNGLFINALCOMBINERINPUTNVPROC) (GLenum variable,
GLenum input, GLenum mapping, GLenum componentUsage);
typedef void (APIENTRY *
PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC) (GLenum stage, GLenum portion,
GLenum variable, GLenum pname, GLfloat * params);
typedef void (APIENTRY *
PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC) (GLenum stage, GLenum portion,
GLenum variable, GLenum pname, GLint * params);
typedef void (APIENTRY *
PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC) (GLenum stage, GLenum portion,
GLenum pname, GLfloat * params);
typedef void (APIENTRY *
PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC) (GLenum stage, GLenum portion,
GLenum pname, GLint * params);
typedef void (APIENTRY *
PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC) (GLenum variable,
GLenum pname, GLfloat * params);
typedef void (APIENTRY *
PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC) (GLenum variable,
GLenum pname, GLint * params);
#endif // not _WIN32
#ifdef NV_REGISTER_COMBINERS_INITIALIZE
#include<string.h> // string manipulation for runtime-check
#include<string.h> // string manipulation for runtime-check
#ifdef _WIN32
PFNGLCOMBINERPARAMETERFVNVPROC glCombinerParameterfvNV = NULL;
PFNGLCOMBINERPARAMETERIVNVPROC glCombinerParameterivNV = NULL;
PFNGLCOMBINERPARAMETERFNVPROC glCombinerParameterfNV = NULL;
PFNGLCOMBINERPARAMETERINVPROC glCombinerParameteriNV = NULL;
PFNGLCOMBINERINPUTNVPROC glCombinerInputNV = NULL;
PFNGLCOMBINEROUTPUTNVPROC glCombinerOutputNV = NULL;
PFNGLFINALCOMBINERINPUTNVPROC glFinalCombinerInputNV = NULL;
PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC glGetCombinerInputParameterfvNV = NULL;
PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC glGetCombinerInputParameterivNV = NULL;
PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC glGetCombinerOutputParameterfvNV = NULL;
PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC glGetCombinerOutputParameterivNV = NULL;
PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC glGetFinalCombinerInputParameterfvNV = NULL;
PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC glGetFinalCombinerInputParameterivNV = NULL;
#endif // _WIN32
int CheckForNVRegisterCombinersSupport(void) {
const char search[]="GL_NV_register_combiners";
int i, pos=0;
int maxpos=strlen(search)-1;
char extensions[10000];
strcpy(extensions,(const char *)glGetString(GL_EXTENSIONS));
int len=strlen(extensions);
for (i=0; i<len; i++) {
if ((i==0) || ((i>1) && extensions[i-1]==' ')) {
pos=0;
while(extensions[i]!=' ') {
if (extensions[i]==search[pos]) pos++;
if ((pos>maxpos) && extensions[i+1]==' ') {
//printf(search);
// printf(" supported.\n");
return 1;
}
i++;
}
}
PFNGLCOMBINERPARAMETERFVNVPROC glCombinerParameterfvNV = NULL;
PFNGLCOMBINERPARAMETERIVNVPROC glCombinerParameterivNV = NULL;
PFNGLCOMBINERPARAMETERFNVPROC glCombinerParameterfNV = NULL;
PFNGLCOMBINERPARAMETERINVPROC glCombinerParameteriNV = NULL;
PFNGLCOMBINERINPUTNVPROC glCombinerInputNV = NULL;
PFNGLCOMBINEROUTPUTNVPROC glCombinerOutputNV = NULL;
PFNGLFINALCOMBINERINPUTNVPROC glFinalCombinerInputNV = NULL;
PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC glGetCombinerInputParameterfvNV =
NULL;
PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC glGetCombinerInputParameterivNV =
NULL;
PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC glGetCombinerOutputParameterfvNV =
NULL;
PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC glGetCombinerOutputParameterivNV =
NULL;
PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC
glGetFinalCombinerInputParameterfvNV = NULL;
PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC
glGetFinalCombinerInputParameterivNV = NULL;
#endif // _WIN32
int CheckForNVRegisterCombinersSupport (void)
{
const char search[] = "GL_NV_register_combiners";
int i, pos = 0;
int maxpos = strlen (search) - 1;
char extensions[10000];
strcpy (extensions, (const char *) glGetString (GL_EXTENSIONS));
int len = strlen (extensions);
for (i = 0; i < len; i++)
{
if ((i == 0) || ((i > 1) && extensions[i - 1] == ' ')) {
pos = 0;
while (extensions[i] != ' ')
{
if (extensions[i] == search[pos])
pos++;
if ((pos > maxpos) && extensions[i + 1] == ' ') {
//printf(search);
// printf(" supported.\n");
return 1;
}
i++;
}
}
}
//printf(search);
//printf(" not supported.\n");
return 0;
}
int GL_NV_register_combiners_Init (void)
{
if (!CheckForNVRegisterCombinersSupport ())
return 0;
#ifdef _WIN32
glCombinerParameterfvNV = (PFNGLCOMBINERPARAMETERFVNVPROC)
wglGetProcAddress ("glCombinerParameterfvNV");
if (glCombinerParameterfvNV == NULL) {
fprintf (stderr, "glCombinerParameterfvNV not found.\n");
return 0;
}
//printf(search);
//printf(" not supported.\n");
return 0;
}
int GL_NV_register_combiners_Init(void) {
if (!CheckForNVRegisterCombinersSupport()) return 0;
#ifdef _WIN32
glCombinerParameterfvNV=(PFNGLCOMBINERPARAMETERFVNVPROC) wglGetProcAddress("glCombinerParameterfvNV");
if (glCombinerParameterfvNV==NULL) {fprintf(stderr,"glCombinerParameterfvNV not found.\n"); return 0;}
glCombinerParameterivNV=(PFNGLCOMBINERPARAMETERIVNVPROC) wglGetProcAddress("glCombinerParameterivNV");
if (glCombinerParameterivNV==NULL) {fprintf(stderr,"glCombinerParameterivNV not found.\n"); return 0;}
glCombinerParameterfNV=(PFNGLCOMBINERPARAMETERFNVPROC) wglGetProcAddress("glCombinerParameterfNV");
if (glCombinerParameterfvNV==NULL) {fprintf(stderr,"glCombinerParameterfNV not found.\n"); return 0;}
glCombinerParameteriNV=(PFNGLCOMBINERPARAMETERINVPROC) wglGetProcAddress("glCombinerParameteriNV");
if (glCombinerParameterivNV==NULL) {fprintf(stderr,"glCombinerParameteriNV not found.\n"); return 0;}
glCombinerInputNV=(PFNGLCOMBINERINPUTNVPROC) wglGetProcAddress("glCombinerInputNV");
if (glCombinerInputNV==NULL) {fprintf(stderr,"glCombinerInputNV not found.\n"); return 0;}
glCombinerOutputNV=(PFNGLCOMBINEROUTPUTNVPROC) wglGetProcAddress("glCombinerOutputNV");
if (glCombinerOutputNV==NULL) {fprintf(stderr,"glCombinerOutputNV not found.\n"); return 0;}
glFinalCombinerInputNV=(PFNGLFINALCOMBINERINPUTNVPROC) wglGetProcAddress("glFinalCombinerInputNV");
if (glFinalCombinerInputNV==NULL) {fprintf(stderr,"glFinalCombinerInputNV not found.\n"); return 0;}
glGetCombinerInputParameterfvNV=(PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC) wglGetProcAddress("glGetCombinerInputParameterfvNV");
if (glGetCombinerInputParameterfvNV==NULL) {fprintf(stderr,"glGetCombinerInputParameterfvNV not found.\n"); return 0;}
glGetCombinerInputParameterivNV=(PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC) wglGetProcAddress("glGetCombinerInputParameterivNV");
if (glGetCombinerInputParameterivNV==NULL) {fprintf(stderr,"glGetCombinerInputParameterivNV not found.\n"); return 0;}
glGetCombinerOutputParameterfvNV=(PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC) wglGetProcAddress("glGetCombinerOutputParameterfvNV");
if (glGetCombinerOutputParameterfvNV==NULL) {fprintf(stderr,"glGetCombinerOutputParameterfvNV not found.\n"); return 0;}
glGetCombinerOutputParameterivNV=(PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC) wglGetProcAddress("glGetCombinerOutputParameterivNV");
if (glGetCombinerOutputParameterivNV==NULL) {fprintf(stderr,"glGetCombinerOutputParameterivNV not found.\n"); return 0;}
glGetFinalCombinerInputParameterfvNV=(PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC) wglGetProcAddress("glGetFinalCombinerInputParameterfvNV");
if (glGetFinalCombinerInputParameterfvNV==NULL) {fprintf(stderr,"glGetFinalCombinerInputParameterfvNV not found.\n"); return 0;}
glGetFinalCombinerInputParameterivNV=(PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC) wglGetProcAddress("glGetFinalCombinerInputParameterivNV");
if (glGetFinalCombinerInputParameterivNV==NULL) {fprintf(stderr,"glGetFinalCombinerInputParameterivNV not found.\n"); return 0;}
glCombinerParameterivNV = (PFNGLCOMBINERPARAMETERIVNVPROC)
wglGetProcAddress ("glCombinerParameterivNV");
if (glCombinerParameterivNV == NULL) {
fprintf (stderr, "glCombinerParameterivNV not found.\n");
return 0;
}
glCombinerParameterfNV = (PFNGLCOMBINERPARAMETERFNVPROC)
wglGetProcAddress ("glCombinerParameterfNV");
if (glCombinerParameterfvNV == NULL) {
fprintf (stderr, "glCombinerParameterfNV not found.\n");
return 0;
}
glCombinerParameteriNV = (PFNGLCOMBINERPARAMETERINVPROC)
wglGetProcAddress ("glCombinerParameteriNV");
if (glCombinerParameterivNV == NULL) {
fprintf (stderr, "glCombinerParameteriNV not found.\n");
return 0;
}
glCombinerInputNV =
(PFNGLCOMBINERINPUTNVPROC) wglGetProcAddress ("glCombinerInputNV");
if (glCombinerInputNV == NULL) {
fprintf (stderr, "glCombinerInputNV not found.\n");
return 0;
}
glCombinerOutputNV =
(PFNGLCOMBINEROUTPUTNVPROC) wglGetProcAddress ("glCombinerOutputNV");
if (glCombinerOutputNV == NULL) {
fprintf (stderr, "glCombinerOutputNV not found.\n");
return 0;
}
glFinalCombinerInputNV = (PFNGLFINALCOMBINERINPUTNVPROC)
wglGetProcAddress ("glFinalCombinerInputNV");
if (glFinalCombinerInputNV == NULL) {
fprintf (stderr, "glFinalCombinerInputNV not found.\n");
return 0;
}
glGetCombinerInputParameterfvNV = (PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC)
wglGetProcAddress ("glGetCombinerInputParameterfvNV");
if (glGetCombinerInputParameterfvNV == NULL) {
fprintf (stderr, "glGetCombinerInputParameterfvNV not found.\n");
return 0;
}
glGetCombinerInputParameterivNV = (PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC)
wglGetProcAddress ("glGetCombinerInputParameterivNV");
if (glGetCombinerInputParameterivNV == NULL) {
fprintf (stderr, "glGetCombinerInputParameterivNV not found.\n");
return 0;
}
glGetCombinerOutputParameterfvNV =
(PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC)
wglGetProcAddress ("glGetCombinerOutputParameterfvNV");
if (glGetCombinerOutputParameterfvNV == NULL) {
fprintf (stderr, "glGetCombinerOutputParameterfvNV not found.\n");
return 0;
}
glGetCombinerOutputParameterivNV =
(PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC)
wglGetProcAddress ("glGetCombinerOutputParameterivNV");
if (glGetCombinerOutputParameterivNV == NULL) {
fprintf (stderr, "glGetCombinerOutputParameterivNV not found.\n");
return 0;
}
glGetFinalCombinerInputParameterfvNV =
(PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC)
wglGetProcAddress ("glGetFinalCombinerInputParameterfvNV");
if (glGetFinalCombinerInputParameterfvNV == NULL) {
fprintf (stderr, "glGetFinalCombinerInputParameterfvNV not found.\n");
return 0;
}
glGetFinalCombinerInputParameterivNV =
(PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC)
wglGetProcAddress ("glGetFinalCombinerInputParameterivNV");
if (glGetFinalCombinerInputParameterivNV == NULL) {
fprintf (stderr, "glGetFinalCombinerInputParameterivNV not found.\n");
return 0;
}
#endif // _WIN32
return 1;
}
return 1;
}
#endif // NV_REGISTER_COMBINERS_INITIALIZE
#ifdef __cplusplus
}
#endif
#endif /* */
#endif // not __NV_REGISTER_COMBINERS_H_

400
gst/gl/gstgl_nvimage.c
View file

@ -23,7 +23,7 @@
//#include <GL/glext.h>
#include <GL/glu.h>
#include <string.h>
#include <math.h>
#include <math.h>
// too lazy to write an API for this ;)
#include "regcomb_yuvrgb.c"
@ -31,15 +31,16 @@
#include "gstglsink.h"
typedef struct _GstGLImageConnection GstGLImageConnection;
struct _GstGLImageConnection {
struct _GstGLImageConnection
{
GstImageConnection conn;
Display *dpy;
gint w, h;
gint bpp;
int ytex_id;
int uvtex_id;
int septex_id;
int septex_id;
unsigned char *m_memory;
int m_bufslots[4];
};
@ -54,50 +55,57 @@ typedef struct _GstNvImage GstNvImage;
struct _GstNvImage
{
GstImageData data;
int slot; // < AGP_BUFSLOTS: allocated from AGP mem, otherwise from CPU mem
int slot; // < AGP_BUFSLOTS: allocated from AGP mem, otherwise from CPU mem
GstGLImageConnection *conn;
};
static GstGLImageInfo * gst_gl_nvimage_info (GstImageInfo *info);
static GstGLImageConnection * gst_gl_nvimage_connection (GstImageConnection *conn);
static gboolean gst_gl_nvimage_check_xvideo ();
static GstGLImageInfo *gst_gl_nvimage_info (GstImageInfo * info);
static GstGLImageConnection *gst_gl_nvimage_connection (GstImageConnection *
conn);
static gboolean gst_gl_nvimage_check_xvideo ();
static GstCaps * gst_gl_nvimage_get_caps (GstImageInfo *info);
static GstImageConnection * gst_gl_nvimage_set_caps (GstImageInfo *info, GstCaps *caps);
static GstImageData * gst_gl_nvimage_get_image (GstImageInfo *info, GstImageConnection *conn);
static void gst_gl_nvimage_put_image (GstImageInfo *info, GstImageData *image);
static void gst_gl_nvimage_free_image (GstImageData *image);
static void gst_gl_nvimage_open_conn (GstImageConnection *conn, GstImageInfo *info);
static void gst_gl_nvimage_close_conn (GstImageConnection *conn, GstImageInfo *info);
static void gst_gl_nvimage_free_conn (GstImageConnection *conn);
static GstCaps *gst_gl_nvimage_get_caps (GstImageInfo * info);
static GstImageConnection *gst_gl_nvimage_set_caps (GstImageInfo * info,
GstCaps * caps);
static GstImageData *gst_gl_nvimage_get_image (GstImageInfo * info,
GstImageConnection * conn);
static void gst_gl_nvimage_put_image (GstImageInfo * info,
GstImageData * image);
static void gst_gl_nvimage_free_image (GstImageData * image);
static void gst_gl_nvimage_open_conn (GstImageConnection * conn,
GstImageInfo * info);
static void gst_gl_nvimage_close_conn (GstImageConnection * conn,
GstImageInfo * info);
static void gst_gl_nvimage_free_conn (GstImageConnection * conn);
GstImagePlugin* get_gl_nvimage_plugin(void)
GstImagePlugin *
get_gl_nvimage_plugin (void)
{
static GstImagePlugin plugin = { gst_gl_nvimage_get_caps,
gst_gl_nvimage_set_caps,
gst_gl_nvimage_get_image,
gst_gl_nvimage_put_image,
gst_gl_nvimage_free_image};
gst_gl_nvimage_set_caps,
gst_gl_nvimage_get_image,
gst_gl_nvimage_put_image,
gst_gl_nvimage_free_image
};
return &plugin;
}
static GstGLImageInfo *
gst_gl_nvimage_info (GstImageInfo *info)
gst_gl_nvimage_info (GstImageInfo * info)
{
if (info == NULL || info->id != GST_MAKE_FOURCC ('X', 'l', 'i', 'b'))
{
if (info == NULL || info->id != GST_MAKE_FOURCC ('X', 'l', 'i', 'b')) {
return NULL;
}
return (GstGLImageInfo *) info;
}
static GstGLImageConnection *
gst_gl_nvimage_connection (GstImageConnection *conn)
gst_gl_nvimage_connection (GstImageConnection * conn)
{
if (conn == NULL || conn->free_conn != gst_gl_nvimage_free_conn)
return NULL;
return NULL;
return (GstGLImageConnection *) conn;
}
@ -105,57 +113,58 @@ gboolean
gst_gl_nvimage_check_xvideo ()
{
//int ver, rel, req, ev, err;
printf("Checking NVidia OpenGL extensions.\n");
if (!GL_ARB_multitexture_Init()) return FALSE;
if (!GL_EXT_paletted_texture_Init()) return FALSE;
if (!GL_NV_register_combiners_Init()) return FALSE;
printf ("Checking NVidia OpenGL extensions.\n");
if (!GL_ARB_multitexture_Init ())
return FALSE;
if (!GL_EXT_paletted_texture_Init ())
return FALSE;
if (!GL_NV_register_combiners_Init ())
return FALSE;
#if 0
#if 0
if (display == NULL)
return FALSE;
if (Success == XvQueryExtension (display,&ver,&rel,&req,&ev,&err))
if (Success == XvQueryExtension (display, &ver, &rel, &req, &ev, &err))
return TRUE;
#endif
return TRUE;
}
static GstCaps *
gst_gl_nvimage_get_caps (GstImageInfo *info)
static GstCaps *
gst_gl_nvimage_get_caps (GstImageInfo * info)
{
//gint i;
//int adaptors;
//int formats;
GstCaps *caps = NULL;
GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
g_warning("nvimage get caps called, context %p !\n", glXGetCurrentContext());
/* we don't handle these image information */
if (xinfo == NULL)
{
printf("Invalid XInfo struct !\n");
return NULL;
}
if (gst_gl_nvimage_check_xvideo () == FALSE)
{
g_warning("GL_NVImage: Server has no NVidia extension support\n");
g_warning ("nvimage get caps called, context %p !\n",
glXGetCurrentContext ());
/* we don't handle these image information */
if (xinfo == NULL) {
printf ("Invalid XInfo struct !\n");
return NULL;
}
caps = gst_caps_append (caps, GST_CAPS_NEW (
"nvimage_caps",
"video/x-raw-yuv",
"format", GST_PROPS_FOURCC (GST_MAKE_FOURCC ('Y', 'V', '1', '2')),
"width", GST_PROPS_INT_RANGE (0, 1024),
"height", GST_PROPS_INT_RANGE (0, 1024))
);
g_warning("nvimage returns caps !\n");
if (gst_gl_nvimage_check_xvideo () == FALSE) {
g_warning ("GL_NVImage: Server has no NVidia extension support\n");
return NULL;
}
caps = gst_caps_append (caps, GST_CAPS_NEW ("nvimage_caps",
"video/x-raw-yuv",
"format", GST_PROPS_FOURCC (GST_MAKE_FOURCC ('Y', 'V', '1', '2')),
"width", GST_PROPS_INT_RANGE (0, 1024),
"height", GST_PROPS_INT_RANGE (0, 1024))
);
g_warning ("nvimage returns caps !\n");
return caps;
}
static GstImageConnection *
gst_gl_nvimage_set_caps (GstImageInfo *info, GstCaps *caps)
gst_gl_nvimage_set_caps (GstImageInfo * info, GstCaps * caps)
{
//gint i, j = 0;
//int adaptors;
@ -163,64 +172,62 @@ gst_gl_nvimage_set_caps (GstImageInfo *info, GstCaps *caps)
GstGLImageConnection *conn;
GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
guint32 format;
/* we don't handle these image information */
if (xinfo == NULL) return NULL;
if (xinfo == NULL)
return NULL;
conn = g_new0 (GstGLImageConnection, 1);
conn->conn.open_conn = gst_gl_nvimage_open_conn;
conn->conn.close_conn = gst_gl_nvimage_close_conn;
conn->conn.free_conn = gst_gl_nvimage_free_conn;
gst_caps_get (caps,
"width", &conn->w,
"height", &conn->h,
"format", &format,
NULL);
gst_caps_get (caps,
"width", &conn->w, "height", &conn->h, "format", &format, NULL);
// maybe I should a bit more checking here, e.g. maximum size smaller than maximum texture extents
if (format != GST_MAKE_FOURCC ('Y', 'V', '1', '2'))
{
GST_DEBUG ("GL_NVImage: Format is invalid !\n");
return NULL;
}
if (0) //conn->port == (XvPortID) -1)
if (format != GST_MAKE_FOURCC ('Y', 'V', '1', '2')) {
GST_DEBUG ("GL_NVImage: Format is invalid !\n");
return NULL;
}
if (0) //conn->port == (XvPortID) -1)
{
/* this happens if the plugin can't handle the caps, so no warning */
g_free (conn);
return NULL;
}
GST_DEBUG ("GL_NVImage: caps %p are ok, creating image", caps);
return (GstImageConnection *) conn;
}
static GstImageData *
gst_gl_nvimage_get_image (GstImageInfo *info, GstImageConnection *conn)
gst_gl_nvimage_get_image (GstImageInfo * info, GstImageConnection * conn)
{
GstNvImage *image;
GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
GstGLImageConnection *nvconn = gst_gl_nvimage_connection (conn);
GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
GstGLImageConnection *nvconn = gst_gl_nvimage_connection (conn);
/* checks */
if (xinfo == NULL) return NULL;
if (nvconn == NULL) return NULL;
if (xinfo == NULL)
return NULL;
if (nvconn == NULL)
return NULL;
// I should also check the current GLX context !
// Ah, Don't have to, I am guarantueed to be in the same thread as put_image
image = g_new0(GstNvImage, 1);
image = g_new0 (GstNvImage, 1);
image->data.size = nvconn->w * nvconn->h * 3/2;
image->data.size = nvconn->w * nvconn->h * 3 / 2;
//g_warning("Allocating %d bytes from main memory !", image->data.size);
image->data.data = g_malloc(image->data.size);
image->data.data = g_malloc (image->data.size);
//image->slot = AGP_BUFSLOTS; // no AGP slot
image->conn = nvconn;
if (image->data.data == NULL)
{
if (image->data.data == NULL) {
g_warning ("GL_NvImage: data allocation failed!");
g_free (image);
return NULL;
@ -229,187 +236,194 @@ gst_gl_nvimage_get_image (GstImageInfo *info, GstImageConnection *conn)
return (GstImageData *) image;
}
static void
gst_gl_nvimage_put_image (GstImageInfo *info, GstImageData *image)
static void
gst_gl_nvimage_put_image (GstImageInfo * info, GstImageData * image)
{
GstNvImage *im = (GstNvImage *) image;
GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
int img_width = im->conn->w;
int img_height = im->conn->h;
GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
int img_width = im->conn->w;
int img_height = im->conn->h;
int uv_width = img_width >> 1;
int uv_height = img_height >> 1;
unsigned char *buf_y = im->data.data;
unsigned char *buf_v = (buf_y + img_width * img_height);
unsigned char *buf_u = buf_v + ((img_width/2) * (img_height/2));
unsigned char *buf_u = buf_v + ((img_width / 2) * (img_height / 2));
/* checks omitted for speed (and lazyness), do we need them? */
g_assert (xinfo != NULL);
// both upload the video, and redraw the screen
//glClearColor(0,0.5, 0.3,1.0); // a test color
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0.0, 0.0, -5.0);
glDisable(GL_TEXTURE_2D);
glMatrixMode (GL_MODELVIEW);
glLoadIdentity ();
glTranslatef (0.0, 0.0, -5.0);
glDisable (GL_TEXTURE_2D);
if (xinfo->info.demo)
{
//g_print("Putting image, context is %p\n", glXGetCurrentContext());
if (xinfo->info.demo) {
//g_print("Putting image, context is %p\n", glXGetCurrentContext());
glTranslatef(0.0, 0.0, -5.0); // make it avoid the clipping plane, zoom 2.0 instead
glRotatef(180.0*sin(xinfo->rotX),1,0,0);
glRotatef(180.0*cos(xinfo->rotY),0,1,0);
glTranslatef (0.0, 0.0, -5.0); // make it avoid the clipping plane, zoom 2.0 instead
glRotatef (180.0 * sin (xinfo->rotX), 1, 0, 0);
glRotatef (180.0 * cos (xinfo->rotY), 0, 1, 0);
xinfo->rotX += 0.01;
xinfo->rotY -= 0.015;
float zoom = xinfo->zoom;
glScalef(zoom,zoom,zoom);
//glScalef(0.1,0.1,0.1);
xinfo->rotX += 0.01;
xinfo->rotY -= 0.015;
float zoom = xinfo->zoom;
if (xinfo->zoom > 2.0)
xinfo->zoomdir = -0.01;
glScalef (zoom, zoom, zoom);
//glScalef(0.1,0.1,0.1);
if (xinfo->zoom < 1.0)
xinfo->zoomdir = 0.01;
if (xinfo->zoom > 2.0)
xinfo->zoomdir = -0.01;
xinfo->zoom += xinfo->zoomdir;
}
if (xinfo->zoom < 1.0)
xinfo->zoomdir = 0.01;
xinfo->zoom += xinfo->zoomdir;
}
//Draws the surface rectangle
if (Ywidth != im->conn->w || Yheight != im->conn->h)
{
Ywidth = im->conn->w; Yheight = im->conn->h; UVwidth = im->conn->w/2; UVheight = im->conn->h/2;
Initialize_Backend(Ywidth,Yheight,UVwidth,UVheight,GL_LINEAR);
if (Ywidth != im->conn->w || Yheight != im->conn->h) {
Ywidth = im->conn->w;
Yheight = im->conn->h;
UVwidth = im->conn->w / 2;
UVheight = im->conn->h / 2;
Initialize_Backend (Ywidth, Yheight, UVwidth, UVheight, GL_LINEAR);
}
LoadYUVPlanes(Yhandle,Uhandle,Vhandle,img_width,img_height,uv_width,uv_height,buf_y,buf_u,buf_v);
float xmax = (float)(im->conn->w-1)/tex_xsize;
float ymax = (float)(im->conn->h-1)/tex_ysize;
LoadYUVPlanes (Yhandle, Uhandle, Vhandle, img_width, img_height, uv_width,
uv_height, buf_y, buf_u, buf_v);
float xmax = (float) (im->conn->w - 1) / tex_xsize;
float ymax = (float) (im->conn->h - 1) / tex_ysize;
/* Upload the texture here */
//g_warning("PUTTING IMAGE %f %f %d %d\n", xmax, ymax, tex_xsize, tex_ysize);
//glColor4f(1,1,1,1); // do NOT set a color here ! Done by Initialize_Backend, or actually SetConst !
glBegin(GL_QUADS);
glBegin (GL_QUADS);
float aspect = img_width/(float)img_height;
float aspect = img_width / (float) img_height;
float hor = aspect;
//g_print("Drawing vertices, context is %p\n", glXGetCurrentContext());
glNormal3f(0, -1, 0);
glMultiTexCoord2fARB(GL_TEXTURE0_ARB,0,0);
glMultiTexCoord2fARB(GL_TEXTURE1_ARB,0,0);
glMultiTexCoord2fARB(GL_TEXTURE2_ARB,0,0);
glVertex3f(-hor,1,0);
glNormal3f (0, -1, 0);
glMultiTexCoord2fARB (GL_TEXTURE0_ARB, 0, 0);
glMultiTexCoord2fARB (GL_TEXTURE1_ARB, 0, 0);
glMultiTexCoord2fARB (GL_TEXTURE2_ARB, 0, 0);
glVertex3f (-hor, 1, 0);
glMultiTexCoord2fARB(GL_TEXTURE0_ARB,0,ymax);
glMultiTexCoord2fARB(GL_TEXTURE1_ARB,0,ymax);
glMultiTexCoord2fARB(GL_TEXTURE2_ARB,0,ymax);
glVertex3f(-hor,-1,0);
glMultiTexCoord2fARB (GL_TEXTURE0_ARB, 0, ymax);
glMultiTexCoord2fARB (GL_TEXTURE1_ARB, 0, ymax);
glMultiTexCoord2fARB (GL_TEXTURE2_ARB, 0, ymax);
glVertex3f (-hor, -1, 0);
glMultiTexCoord2fARB(GL_TEXTURE0_ARB,xmax,ymax);
glMultiTexCoord2fARB(GL_TEXTURE1_ARB,xmax,ymax);
glMultiTexCoord2fARB(GL_TEXTURE2_ARB,xmax,ymax);
glVertex3f(hor,-1,0);
glMultiTexCoord2fARB (GL_TEXTURE0_ARB, xmax, ymax);
glMultiTexCoord2fARB (GL_TEXTURE1_ARB, xmax, ymax);
glMultiTexCoord2fARB (GL_TEXTURE2_ARB, xmax, ymax);
glVertex3f (hor, -1, 0);
glMultiTexCoord2fARB(GL_TEXTURE0_ARB,xmax,0);
glMultiTexCoord2fARB(GL_TEXTURE1_ARB,xmax,0);
glMultiTexCoord2fARB(GL_TEXTURE2_ARB,xmax,0);
glVertex3f(hor,1,0);
glMultiTexCoord2fARB (GL_TEXTURE0_ARB, xmax, 0);
glMultiTexCoord2fARB (GL_TEXTURE1_ARB, xmax, 0);
glMultiTexCoord2fARB (GL_TEXTURE2_ARB, xmax, 0);
glVertex3f (hor, 1, 0);
glEnd();
glEnd ();
if (xinfo->info.dumpvideo)
{
static int framenr = 0;
char capfilename[255];
static guint8 *cap_image_data = NULL, *cap_image_data2 = NULL;
int i;
// hmmmm, is this reentrant ?!
if (cap_image_data == NULL)
cap_image_data = (guint8 *)malloc(img_width * img_height * 3);
if (xinfo->info.dumpvideo) {
static int framenr = 0;
char capfilename[255];
static guint8 *cap_image_data = NULL, *cap_image_data2 = NULL;
int i;
if (cap_image_data2 == NULL)
cap_image_data2 = (guint8 *)malloc(img_width * img_height * 3);
printf("Recording frame #%d\n", framenr);
glReadPixels(0,0,img_width,img_height,GL_RGB,GL_UNSIGNED_BYTE,cap_image_data);
// invert the pixels
for (i = 0; i < img_height; i++)
memcpy(cap_image_data2 + i * img_width * 3, cap_image_data + (img_height-1-i) * img_width * 3, img_width*3);
sprintf(capfilename, "cap%04d.ppm", framenr);
FILE *outfile = fopen(capfilename, "wb");
if (outfile != NULL)
{
fprintf(outfile, "P6\n");
fprintf(outfile,"# created by glsink from GStreamer\n");
fprintf(outfile,"%d %d\n",img_width,img_height);
fprintf(outfile,"255\n");
fwrite(cap_image_data2, sizeof(char), img_width*img_height*3, outfile);
fclose(outfile);
}
framenr++;
// hmmmm, is this reentrant ?!
if (cap_image_data == NULL)
cap_image_data = (guint8 *) malloc (img_width * img_height * 3);
if (cap_image_data2 == NULL)
cap_image_data2 = (guint8 *) malloc (img_width * img_height * 3);
printf ("Recording frame #%d\n", framenr);
glReadPixels (0, 0, img_width, img_height, GL_RGB, GL_UNSIGNED_BYTE,
cap_image_data);
// invert the pixels
for (i = 0; i < img_height; i++)
memcpy (cap_image_data2 + i * img_width * 3,
cap_image_data + (img_height - 1 - i) * img_width * 3, img_width * 3);
sprintf (capfilename, "cap%04d.ppm", framenr);
FILE *outfile = fopen (capfilename, "wb");
if (outfile != NULL) {
fprintf (outfile, "P6\n");
fprintf (outfile, "# created by glsink from GStreamer\n");
fprintf (outfile, "%d %d\n", img_width, img_height);
fprintf (outfile, "255\n");
fwrite (cap_image_data2, sizeof (char), img_width * img_height * 3,
outfile);
fclose (outfile);
}
framenr++;
}
glXSwapBuffers(xinfo->dpy, xinfo->win);
glXSwapBuffers (xinfo->dpy, xinfo->win);
}
static void
gst_gl_nvimage_free_image (GstImageData *image)
static void
gst_gl_nvimage_free_image (GstImageData * image)
{
GstNvImage *im = (GstNvImage *) image;
g_return_if_fail (im != NULL);
GstGLImageConnection *nvconn = im->conn;
if (im->slot < AGP_BUFSLOTS)
{
nvconn->m_bufslots[im->slot] = 0;
}
else
g_free(im->data.data);
g_return_if_fail (im != NULL);
GstGLImageConnection *nvconn = im->conn;
if (im->slot < AGP_BUFSLOTS) {
nvconn->m_bufslots[im->slot] = 0;
} else
g_free (im->data.data);
g_free (im);
}
static void
gst_gl_nvimage_open_conn (GstImageConnection *conn, GstImageInfo *info)
gst_gl_nvimage_open_conn (GstImageConnection * conn, GstImageInfo * info)
{
//GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
//GstGLImageConnection *xconn = gst_gl_nvimage_connection (conn);
g_print("Opening NVidia connection; OpenGL on Nvidia, using register combiners.\n");
g_print
("Opening NVidia connection; OpenGL on Nvidia, using register combiners.\n");
{
Ywidth = TEX_XSIZE; Yheight = TEX_YSIZE; UVwidth = TEX_XSIZE/2; UVheight = TEX_YSIZE/2;
Initialize_Backend(Ywidth,Yheight,UVwidth,UVheight,GL_LINEAR);
Ywidth = TEX_XSIZE;
Yheight = TEX_YSIZE;
UVwidth = TEX_XSIZE / 2;
UVheight = TEX_YSIZE / 2;
Initialize_Backend (Ywidth, Yheight, UVwidth, UVheight, GL_LINEAR);
}
g_print("Done\n");
g_print ("Done\n");
}
static void
gst_gl_nvimage_close_conn (GstImageConnection *conn, GstImageInfo *info)
gst_gl_nvimage_close_conn (GstImageConnection * conn, GstImageInfo * info)
{
GstGLImageConnection *xconn = gst_gl_nvimage_connection (conn);
//GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
// anything needed in here ? Oh, maybe drawing de-init, or something
glDeleteTextures(1, &xconn->ytex_id);
glDeleteTextures(1, &xconn->uvtex_id);
glDeleteTextures(1, &xconn->septex_id);
glDeleteTextures (1, &xconn->ytex_id);
glDeleteTextures (1, &xconn->uvtex_id);
glDeleteTextures (1, &xconn->septex_id);
}
static void
gst_gl_nvimage_free_conn (GstImageConnection *conn)
static void
gst_gl_nvimage_free_conn (GstImageConnection * conn)
{
GstGLImageConnection *nvconn = gst_gl_nvimage_connection (conn);
GstGLImageConnection *nvconn = gst_gl_nvimage_connection (conn);
g_free (nvconn);
}

395
gst/gl/gstgl_pdrimage.c
View file

@ -31,15 +31,16 @@
#include "gstglsink.h"
typedef struct _GstGLImageConnection GstGLImageConnection;
struct _GstGLImageConnection {
struct _GstGLImageConnection
{
GstImageConnection conn;
Display *dpy;
gint w, h;
gint bpp;
int ytex_id;
int uvtex_id;
int septex_id;
int septex_id;
unsigned char *m_memory;
int m_bufslots[4];
};
@ -54,50 +55,57 @@ typedef struct _GstNvImage GstNvImage;
struct _GstNvImage
{
GstImageData data;
int slot; // < AGP_BUFSLOTS: allocated from AGP mem, otherwise from CPU mem
int slot; // < AGP_BUFSLOTS: allocated from AGP mem, otherwise from CPU mem
GstGLImageConnection *conn;
};
static GstGLImageInfo * gst_gl_nvimage_info (GstImageInfo *info);
static GstGLImageConnection * gst_gl_nvimage_connection (GstImageConnection *conn);
static gboolean gst_gl_nvimage_check_xvideo ();
static GstGLImageInfo *gst_gl_nvimage_info (GstImageInfo * info);
static GstGLImageConnection *gst_gl_nvimage_connection (GstImageConnection *
conn);
static gboolean gst_gl_nvimage_check_xvideo ();
static GstCaps * gst_gl_nvimage_get_caps (GstImageInfo *info);
static GstImageConnection * gst_gl_nvimage_set_caps (GstImageInfo *info, GstCaps *caps);
static GstImageData * gst_gl_nvimage_get_image (GstImageInfo *info, GstImageConnection *conn);
static void gst_gl_nvimage_put_image (GstImageInfo *info, GstImageData *image);
static void gst_gl_nvimage_free_image (GstImageData *image);
static void gst_gl_nvimage_open_conn (GstImageConnection *conn, GstImageInfo *info);
static void gst_gl_nvimage_close_conn (GstImageConnection *conn, GstImageInfo *info);
static void gst_gl_nvimage_free_conn (GstImageConnection *conn);
static GstCaps *gst_gl_nvimage_get_caps (GstImageInfo * info);
static GstImageConnection *gst_gl_nvimage_set_caps (GstImageInfo * info,
GstCaps * caps);
static GstImageData *gst_gl_nvimage_get_image (GstImageInfo * info,
GstImageConnection * conn);
static void gst_gl_nvimage_put_image (GstImageInfo * info,
GstImageData * image);
static void gst_gl_nvimage_free_image (GstImageData * image);
static void gst_gl_nvimage_open_conn (GstImageConnection * conn,
GstImageInfo * info);
static void gst_gl_nvimage_close_conn (GstImageConnection * conn,
GstImageInfo * info);
static void gst_gl_nvimage_free_conn (GstImageConnection * conn);
GstImagePlugin* get_gl_nvimage_plugin(void)
GstImagePlugin *
get_gl_nvimage_plugin (void)
{
static GstImagePlugin plugin = { gst_gl_nvimage_get_caps,
gst_gl_nvimage_set_caps,
gst_gl_nvimage_get_image,
gst_gl_nvimage_put_image,
gst_gl_nvimage_free_image};
gst_gl_nvimage_set_caps,
gst_gl_nvimage_get_image,
gst_gl_nvimage_put_image,
gst_gl_nvimage_free_image
};
return &plugin;
}
static GstGLImageInfo *
gst_gl_nvimage_info (GstImageInfo *info)
gst_gl_nvimage_info (GstImageInfo * info)
{
if (info == NULL || info->id != GST_MAKE_FOURCC ('X', 'l', 'i', 'b'))
{
if (info == NULL || info->id != GST_MAKE_FOURCC ('X', 'l', 'i', 'b')) {
return NULL;
}
return (GstGLImageInfo *) info;
}
static GstGLImageConnection *
gst_gl_nvimage_connection (GstImageConnection *conn)
gst_gl_nvimage_connection (GstImageConnection * conn)
{
if (conn == NULL || conn->free_conn != gst_gl_nvimage_free_conn)
return NULL;
return NULL;
return (GstGLImageConnection *) conn;
}
@ -105,47 +113,46 @@ gboolean
gst_gl_nvimage_check_xvideo ()
{
int ver, rel, req, ev, err;
#if 0
#if 0
if (display == NULL)
return FALSE;
if (Success == XvQueryExtension (display,&ver,&rel,&req,&ev,&err))
if (Success == XvQueryExtension (display, &ver, &rel, &req, &ev, &err))
return TRUE;
#endif
return FALSE;
}
static GstCaps *
gst_gl_nvimage_get_caps (GstImageInfo *info)
static GstCaps *
gst_gl_nvimage_get_caps (GstImageInfo * info)
{
gint i;
int adaptors;
int formats;
GstCaps *caps = NULL;
GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
/* we don't handle these image information */
if (xinfo == NULL) return NULL;
if (gst_gl_nvimage_check_xvideo () == FALSE)
{
g_warning("GL_NVImage: Server has no NVidia extension support\n");
/* we don't handle these image information */
if (xinfo == NULL)
return NULL;
if (gst_gl_nvimage_check_xvideo () == FALSE) {
g_warning ("GL_NVImage: Server has no NVidia extension support\n");
return NULL;
}
caps = gst_caps_append (caps, GST_CAPS_NEW (
"xvimage_caps",
"video/raw",
"format", GST_PROPS_FOURCC (GST_MAKE_FOURCC ('Y', 'C', '1', '2')),
"width", GST_PROPS_INT_RANGE (0, 1024),
"height", GST_PROPS_INT_RANGE (0, 1024))
);
caps = gst_caps_append (caps, GST_CAPS_NEW ("xvimage_caps",
"video/raw",
"format", GST_PROPS_FOURCC (GST_MAKE_FOURCC ('Y', 'C', '1', '2')),
"width", GST_PROPS_INT_RANGE (0, 1024),
"height", GST_PROPS_INT_RANGE (0, 1024))
);
return caps;
}
static GstImageConnection *
gst_gl_nvimage_set_caps (GstImageInfo *info, GstCaps *caps)
gst_gl_nvimage_set_caps (GstImageInfo * info, GstCaps * caps)
{
gint i, j = 0;
int adaptors;
@ -153,78 +160,75 @@ gst_gl_nvimage_set_caps (GstImageInfo *info, GstCaps *caps)
GstGLImageConnection *conn;
GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
guint32 format;
/* we don't handle these image information */
if (xinfo == NULL) return NULL;
if (xinfo == NULL)
return NULL;
conn = g_new0 (GstGLImageConnection, 1);
conn->conn.open_conn = gst_gl_nvimage_open_conn;
conn->conn.close_conn = gst_gl_nvimage_close_conn;
conn->conn.free_conn = gst_gl_nvimage_free_conn;
gst_caps_get (caps,
"width", &conn->w,
"height", &conn->h,
"format", &format,
NULL);
gst_caps_get (caps,
"width", &conn->w, "height", &conn->h, "format", &format, NULL);
// maybe I should a bit more checking here, e.g. maximum size smaller than maximum texture extents
if (format != GST_MAKE_FOURCC ('R', 'G', 'B', ' '))
{
GST_DEBUG (GST_CAT_PLUGIN_INFO, "GL_NVImage: Format is invalid !\n");
return NULL;
}
if (0) //conn->port == (XvPortID) -1)
if (format != GST_MAKE_FOURCC ('R', 'G', 'B', ' ')) {
GST_DEBUG (GST_CAT_PLUGIN_INFO, "GL_NVImage: Format is invalid !\n");
return NULL;
}
if (0) //conn->port == (XvPortID) -1)
{
/* this happens if the plugin can't handle the caps, so no warning */
g_free (conn);
return NULL;
}
GST_DEBUG (GST_CAT_PLUGIN_INFO, "GL_NVImage: caps %p are ok, creating image", caps);
GST_DEBUG (GST_CAT_PLUGIN_INFO, "GL_NVImage: caps %p are ok, creating image",
caps);
return (GstImageConnection *) conn;
}
static GstImageData *
gst_gl_nvimage_get_image (GstImageInfo *info, GstImageConnection *conn)
gst_gl_nvimage_get_image (GstImageInfo * info, GstImageConnection * conn)
{
GstNvImage *image;
GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
GstGLImageConnection *nvconn = gst_gl_nvimage_connection (conn);
GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
GstGLImageConnection *nvconn = gst_gl_nvimage_connection (conn);
int slot = 0;
/* checks */
if (xinfo == NULL) return NULL;
if (nvconn == NULL) return NULL;
if (xinfo == NULL)
return NULL;
if (nvconn == NULL)
return NULL;
// I should also check the current GLX context !
// Ah, Don't have to, I am guarantueed to always be in the same thread
image = g_new0(GstNvImage, 1);
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;
image->data.size = nvconn->w * nvconn->h * 3 / 2;
if (slot < AGP_BUFSLOTS) // found an AGP buffer slot
{
image->data.data = nvconn->m_memory + slot * YUVTEX_SIZE;
image->slot = slot; // store for freeing
nvconn->m_bufslots[slot] = 1; // it is now taken
}
else
{
g_warning("Allocating from main memory !");
image->data.data = g_malloc(image->data.size);
image->slot = AGP_BUFSLOTS; // no AGP slot
}
if (slot < AGP_BUFSLOTS) // found an AGP buffer slot
{
image->data.data = nvconn->m_memory + slot * YUVTEX_SIZE;
image->slot = slot; // store for freeing
nvconn->m_bufslots[slot] = 1; // it is now taken
} else {
g_warning ("Allocating from main memory !");
image->data.data = g_malloc (image->data.size);
image->slot = AGP_BUFSLOTS; // no AGP slot
}
image->conn = nvconn;
if (image->data.data == NULL)
{
if (image->data.data == NULL) {
g_warning ("GL_NvImage: data allocation failed!");
g_free (image);
return NULL;
@ -233,166 +237,169 @@ gst_gl_nvimage_get_image (GstImageInfo *info, GstImageConnection *conn)
return (GstImageData *) image;
}
static void
gst_gl_nvimage_put_image (GstImageInfo *info, GstImageData *image)
static void
gst_gl_nvimage_put_image (GstImageInfo * info, GstImageData * image)
{
GstNvImage *im = (GstNvImage *) image;
GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
/* checks omitted for speed (and lazyness), do we need them? */
g_assert (xinfo != NULL);
/* Upload the texture here */
g_warning("PUTTING IMAGE - BROOOKEN");
g_warning ("PUTTING IMAGE - BROOOKEN");
// both upload the video, and redraw the screen
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_TEXTURE_2D);
glEnable (GL_TEXTURE_2D);
glPushMatrix();
glPushMatrix ();
//glTranslatef(0,1,0);
glRotatef(xinfo->rotX-250,1,0,0);
glRotatef(xinfo->rotY,0,1,0);
glRotatef (xinfo->rotX - 250, 1, 0, 0);
glRotatef (xinfo->rotY, 0, 1, 0);
int zoom = xinfo->zoom;
glScaled(zoom,zoom,zoom);
glScaled (zoom, zoom, zoom);
//Draws the surface rectangle
glBindTexture(GL_TEXTURE_2D, im->conn->ytex_id);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, im->conn->w, im->conn->h, GL_RGBA,
GL_UNSIGNED_BYTE, im->data.data);
float xmax = (float)im->conn->w/TEX_XSIZE;
float ymax = (float)im->conn->h/TEX_YSIZE;
glBindTexture (GL_TEXTURE_2D, im->conn->ytex_id);
glTexSubImage2D (GL_TEXTURE_2D, 0, 0, 0, im->conn->w, im->conn->h, GL_RGBA,
GL_UNSIGNED_BYTE, im->data.data);
float xmax = (float) im->conn->w / TEX_XSIZE;
float ymax = (float) im->conn->h / TEX_YSIZE;
glColor4f(1,1,1,1);
glBegin(GL_QUADS);
glColor4f (1, 1, 1, 1);
glBegin (GL_QUADS);
glNormal3f(0, -1, 0);
glTexCoord2f(xmax, 0);
glVertex3f(4,0,-4);
glNormal3f (0, -1, 0);
glTexCoord2f(0, 0);
glVertex3f(-4,0,-4);
glTexCoord2f (xmax, 0);
glVertex3f (4, 0, -4);
glTexCoord2f(0, ymax);
glVertex3f(-4,0,4);
glTexCoord2f (0, 0);
glVertex3f (-4, 0, -4);
glTexCoord2f(xmax, ymax);
glVertex3f(4,0,4);
glTexCoord2f (0, ymax);
glVertex3f (-4, 0, 4);
glEnd();
glTexCoord2f (xmax, ymax);
glVertex3f (4, 0, 4);
glPopMatrix();
glEnd ();
glXSwapBuffers(xinfo->dpy, xinfo->win);
glPopMatrix ();
glXSwapBuffers (xinfo->dpy, xinfo->win);
}
static void
gst_gl_nvimage_free_image (GstImageData *image)
static void
gst_gl_nvimage_free_image (GstImageData * image)
{
GstNvImage *im = (GstNvImage *) image;
g_return_if_fail (im != NULL);
GstGLImageConnection *nvconn = im->conn;
if (im->slot < AGP_BUFSLOTS)
{
nvconn->m_bufslots[im->slot] = 0;
}
else
g_free(im->data.data);
g_return_if_fail (im != NULL);
GstGLImageConnection *nvconn = im->conn;
if (im->slot < AGP_BUFSLOTS) {
nvconn->m_bufslots[im->slot] = 0;
} else
g_free (im->data.data);
g_free (im);
}
static void
gst_gl_nvimage_open_conn (GstImageConnection *conn, GstImageInfo *info)
gst_gl_nvimage_open_conn (GstImageConnection * conn, GstImageInfo * info)
{
GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
GstGLImageConnection *xconn = gst_gl_nvimage_connection (conn);
unsigned char data_sep[2][2] = {{0, 255}, {0, 255}};
unsigned char data_sep[2][2] = { {0, 255}, {0, 255} };
int slot;
g_warning("Opening NVidia Connection");
xconn->m_memory = (unsigned char*)glXAllocateMemoryNV(AGP_BUFSLOTS*YUVTEX_SIZE, 0, 1.0, 1.0);
if (!xconn->m_memory)
{
printf("Unable to acquire graphics card mem... will acquire in normal memory.\n");
for (slot = 0; slot < AGP_BUFSLOTS; slot++)
xconn->m_bufslots[slot] = 1;
}
else
{
// maybe this fast writable memory, awfully slow to read from, though
glPixelDataRangeNV(GL_WRITE_PIXEL_DATA_RANGE_NV, AGP_BUFSLOTS*YUVTEX_SIZE, xconn->m_memory);
glEnableClientState(GL_WRITE_PIXEL_DATA_RANGE_NV);
g_warning ("Opening NVidia Connection");
xconn->m_memory =
(unsigned char *) glXAllocateMemoryNV (AGP_BUFSLOTS * YUVTEX_SIZE, 0, 1.0,
1.0);
for (slot = 0; slot < AGP_BUFSLOTS; slot++)
xconn->m_bufslots[slot] = 0;
}
if (!xconn->m_memory) {
printf
("Unable to acquire graphics card mem... will acquire in normal memory.\n");
for (slot = 0; slot < AGP_BUFSLOTS; slot++)
xconn->m_bufslots[slot] = 1;
} else {
// maybe this fast writable memory, awfully slow to read from, though
glPixelDataRangeNV (GL_WRITE_PIXEL_DATA_RANGE_NV,
AGP_BUFSLOTS * YUVTEX_SIZE, xconn->m_memory);
glEnableClientState (GL_WRITE_PIXEL_DATA_RANGE_NV);
glGenTextures(1, &xconn->ytex_id);
glBindTexture(GL_TEXTURE_2D, xconn->ytex_id);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE8_ALPHA8, TEX_XSIZE, TEX_YSIZE, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, NULL);
for (slot = 0; slot < AGP_BUFSLOTS; slot++)
xconn->m_bufslots[slot] = 0;
}
glActiveTextureARB(GL_TEXTURE1_ARB);
glGenTextures(1, &xconn->uvtex_id);
glBindTexture(GL_TEXTURE_2D, xconn->uvtex_id);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE8_ALPHA8, TEX_XSIZE/2, TEX_YSIZE/2, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD);
glGenTextures (1, &xconn->ytex_id);
glBindTexture (GL_TEXTURE_2D, xconn->ytex_id);
glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glTexImage2D (GL_TEXTURE_2D, 0, GL_LUMINANCE8_ALPHA8, TEX_XSIZE, TEX_YSIZE, 0,
GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, NULL);
glActiveTextureARB(GL_TEXTURE2_ARB);
glGenTextures(1, &xconn->septex_id);
glBindTexture(GL_TEXTURE_2D, xconn->septex_id);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE8, 2, 2, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, data_sep);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD);
glActiveTextureARB (GL_TEXTURE1_ARB);
glGenTextures (1, &xconn->uvtex_id);
glBindTexture (GL_TEXTURE_2D, xconn->uvtex_id);
glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
glTexImage2D (GL_TEXTURE_2D, 0, GL_LUMINANCE8_ALPHA8, TEX_XSIZE / 2,
TEX_YSIZE / 2, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, NULL);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD);
glFlushPixelDataRangeNV(GL_WRITE_PIXEL_DATA_RANGE_NV);
glActiveTextureARB (GL_TEXTURE2_ARB);
glGenTextures (1, &xconn->septex_id);
glBindTexture (GL_TEXTURE_2D, xconn->septex_id);
glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
glTexImage2D (GL_TEXTURE_2D, 0, GL_LUMINANCE8, 2, 2, 0, GL_LUMINANCE,
GL_UNSIGNED_BYTE, data_sep);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD);
glFlushPixelDataRangeNV (GL_WRITE_PIXEL_DATA_RANGE_NV);
//glEnable(GL_TEXTURE_2D);
glActiveTextureARB(GL_TEXTURE0_ARB);
glEnable(GL_TEXTURE_2D);
glActiveTextureARB(GL_TEXTURE1_ARB);
glEnable(GL_TEXTURE_2D);
glActiveTextureARB(GL_TEXTURE2_ARB);
glEnable(GL_TEXTURE_2D);
glActiveTextureARB(GL_TEXTURE0_ARB);
glActiveTextureARB (GL_TEXTURE0_ARB);
glEnable (GL_TEXTURE_2D);
glActiveTextureARB (GL_TEXTURE1_ARB);
glEnable (GL_TEXTURE_2D);
glActiveTextureARB (GL_TEXTURE2_ARB);
glEnable (GL_TEXTURE_2D);
glActiveTextureARB (GL_TEXTURE0_ARB);
}
static void
gst_gl_nvimage_close_conn (GstImageConnection *conn, GstImageInfo *info)
gst_gl_nvimage_close_conn (GstImageConnection * conn, GstImageInfo * info)
{
GstGLImageConnection *xconn = gst_gl_nvimage_connection (conn);
GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
// anything needed in here ? Oh, maybe drawing de-init, or something
glDeleteTextures(1, &xconn->ytex_id);
glDeleteTextures(1, &xconn->uvtex_id);
glDeleteTextures(1, &xconn->septex_id);
glDeleteTextures (1, &xconn->ytex_id);
glDeleteTextures (1, &xconn->uvtex_id);
glDeleteTextures (1, &xconn->septex_id);
}
static void
gst_gl_nvimage_free_conn (GstImageConnection *conn)
static void
gst_gl_nvimage_free_conn (GstImageConnection * conn)
{
GstGLImageConnection *nvconn = gst_gl_nvimage_connection (conn);
GstGLImageConnection *nvconn = gst_gl_nvimage_connection (conn);
g_free (nvconn);
}

377
gst/gl/gstgl_rgbimage.c
View file

@ -22,20 +22,21 @@
#include <GL/glx.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <math.h>
#include <math.h>
#include "gstglsink.h"
typedef struct _GstGLImageConnection GstGLImageConnection;
// this contains everything to draw an image, including all necessary graphics card data.
struct _GstGLImageConnection {
struct _GstGLImageConnection
{
GstImageConnection conn;
Display *dpy; // the Xlib drawing context
GLXContext ctx; // The GLX drawing context
Display *dpy; // the Xlib drawing context
GLXContext ctx; // The GLX drawing context
gint w, h;
gint bpp;
int rgbatex_id;
unsigned char *m_memory;
};
@ -51,49 +52,56 @@ struct _GstGLImage
GstGLImageConnection *conn;
};
static GstGLImageInfo * gst_gl_rgbimage_info (GstImageInfo *info);
static GstGLImageConnection * gst_gl_rgbimage_connection (GstImageConnection *conn);
static GstGLImageInfo *gst_gl_rgbimage_info (GstImageInfo * info);
static GstGLImageConnection *gst_gl_rgbimage_connection (GstImageConnection *
conn);
static GstCaps * gst_gl_rgbimage_get_caps (GstImageInfo *info);
static GstImageConnection * gst_gl_rgbimage_set_caps (GstImageInfo *info, GstCaps *caps);
static GstImageData * gst_gl_rgbimage_get_image (GstImageInfo *info, GstImageConnection *conn);
static void gst_gl_rgbimage_put_image (GstImageInfo *info, GstImageData *image);
static void gst_gl_rgbimage_free_image (GstImageData *image);
static void gst_gl_rgbimage_open_conn (GstImageConnection *conn, GstImageInfo *info);
static void gst_gl_rgbimage_close_conn (GstImageConnection *conn, GstImageInfo *info);
static void gst_gl_rgbimage_free_conn (GstImageConnection *conn);
static GstCaps *gst_gl_rgbimage_get_caps (GstImageInfo * info);
static GstImageConnection *gst_gl_rgbimage_set_caps (GstImageInfo * info,
GstCaps * caps);
static GstImageData *gst_gl_rgbimage_get_image (GstImageInfo * info,
GstImageConnection * conn);
static void gst_gl_rgbimage_put_image (GstImageInfo * info,
GstImageData * image);
static void gst_gl_rgbimage_free_image (GstImageData * image);
static void gst_gl_rgbimage_open_conn (GstImageConnection * conn,
GstImageInfo * info);
static void gst_gl_rgbimage_close_conn (GstImageConnection * conn,
GstImageInfo * info);
static void gst_gl_rgbimage_free_conn (GstImageConnection * conn);
GstImagePlugin* get_gl_rgbimage_plugin(void)
GstImagePlugin *
get_gl_rgbimage_plugin (void)
{
static GstImagePlugin plugin = { gst_gl_rgbimage_get_caps,
gst_gl_rgbimage_set_caps,
gst_gl_rgbimage_get_image,
gst_gl_rgbimage_put_image,
gst_gl_rgbimage_free_image};
gst_gl_rgbimage_set_caps,
gst_gl_rgbimage_get_image,
gst_gl_rgbimage_put_image,
gst_gl_rgbimage_free_image
};
return &plugin;
}
static GstGLImageInfo *
gst_gl_rgbimage_info (GstImageInfo *info)
gst_gl_rgbimage_info (GstImageInfo * info)
{
if (info == NULL || info->id != GST_MAKE_FOURCC ('X', 'l', 'i', 'b'))
{
if (info == NULL || info->id != GST_MAKE_FOURCC ('X', 'l', 'i', 'b')) {
return NULL;
}
return (GstGLImageInfo *) info;
}
static GstGLImageConnection *
gst_gl_rgbimage_connection (GstImageConnection *conn)
gst_gl_rgbimage_connection (GstImageConnection * conn)
{
if (conn == NULL || conn->free_conn != gst_gl_rgbimage_free_conn)
return NULL;
return NULL;
return (GstGLImageConnection *) conn;
}
GstCaps *
gst_gl_rgbimage_get_caps (GstImageInfo *info)
gst_gl_rgbimage_get_caps (GstImageInfo * info)
{
GstCaps *caps = NULL;
Visual *visual;
@ -101,13 +109,15 @@ gst_gl_rgbimage_get_caps (GstImageInfo *info)
XWindowAttributes attrib;
XImage *ximage;
GstGLImageInfo *xinfo = gst_gl_rgbimage_info (info);
g_warning("rgbimage get caps called, context %p, endianness %d !\n", glXGetCurrentContext(), G_BIG_ENDIAN);
/* we don't handle this image information */
if (xinfo == NULL) return NULL;
XGetWindowAttributes(xinfo->dpy, xinfo->win, &attrib);
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;
XGetWindowAttributes (xinfo->dpy, xinfo->win, &attrib);
visual = attrib.visual;
if (attrib.depth <= 8)
xpad = 8;
@ -115,42 +125,37 @@ gst_gl_rgbimage_get_caps (GstImageInfo *info)
xpad = 16;
else
xpad = 32;
// create a temporary image
ximage = XCreateImage (xinfo->dpy, visual, attrib.depth, ZPixmap, 0, NULL,
100, 100, xpad, (attrib.depth + 7) / 8 * 100);
ximage = XCreateImage (xinfo->dpy, visual, attrib.depth, ZPixmap, 0, NULL,
100, 100, xpad, (attrib.depth + 7) / 8 * 100);
if (ximage != NULL) {
caps =
GST_CAPS_NEW (
"forcing Video RGB",
"video/x-raw-rgb",
"format", GST_PROPS_FOURCC (GST_STR_FOURCC ("RGB ")),
"depth", GST_PROPS_INT(24),
"bpp", GST_PROPS_INT(24),
"red_mask", GST_PROPS_INT(0xff),
"green_mask", GST_PROPS_INT(0xff00),
"blue_mask", GST_PROPS_INT(0xff0000),
"endianness", GST_PROPS_INT(G_BIG_ENDIAN), /*= 1234/4321 (INT) <- endianness */
"width", GST_PROPS_INT_RANGE (0, TEX_XSIZE), /* can't have videos larger than TEX_SIZE */
"height", GST_PROPS_INT_RANGE (0, TEX_YSIZE)
);
caps =
GST_CAPS_NEW ("forcing Video RGB", "video/x-raw-rgb", "format",
GST_PROPS_FOURCC (GST_STR_FOURCC ("RGB ")), "depth", GST_PROPS_INT (24),
"bpp", GST_PROPS_INT (24), "red_mask", GST_PROPS_INT (0xff),
"green_mask", GST_PROPS_INT (0xff00), "blue_mask",
GST_PROPS_INT (0xff0000), "endianness", GST_PROPS_INT (G_BIG_ENDIAN),
/*= 1234/4321 (INT) <- endianness */
"width", GST_PROPS_INT_RANGE (0, TEX_XSIZE), /* can't have videos larger than TEX_SIZE */
"height", GST_PROPS_INT_RANGE (0, TEX_YSIZE)
);
XDestroyImage (ximage);
}
printf ("GL_RGBImage: returning caps at %p", caps);
return caps;
}
static GstImageConnection *
gst_gl_rgbimage_set_caps (GstImageInfo *info, GstCaps *caps)
static GstImageConnection *
gst_gl_rgbimage_set_caps (GstImageInfo * info, GstCaps * caps)
{
g_warning("in set_caps !\n");
g_warning ("in set_caps !\n");
GstGLImageConnection *new = NULL;
Visual *visual;
XWindowAttributes attrib;
GstGLImageInfo *xinfo = gst_gl_rgbimage_info (info);
GstGLImageInfo *xinfo = gst_gl_rgbimage_info (info);
guint32 format;
gint depth;
gint endianness;
@ -158,26 +163,25 @@ gst_gl_rgbimage_set_caps (GstImageInfo *info, GstCaps *caps)
gint width, height, bpp;
/* check if this is the right image info */
if (xinfo == NULL) return NULL;
XGetWindowAttributes(xinfo->dpy, xinfo->win, &attrib);
if (xinfo == NULL)
return NULL;
XGetWindowAttributes (xinfo->dpy, xinfo->win, &attrib);
visual = attrib.visual;
gst_caps_get (caps,
"format", &format,
"depth", &depth,
"endianness", &endianness,
"red_mask", &red_mask,
"green_mask", &green_mask,
"blue_mask", &blue_mask,
"width", &width,
"height", &height,
"bpp", &bpp,
NULL);
"format", &format,
"depth", &depth,
"endianness", &endianness,
"red_mask", &red_mask,
"green_mask", &green_mask,
"blue_mask", &blue_mask,
"width", &width, "height", &height, "bpp", &bpp, NULL);
/* check if the caps are ok */
if (format != GST_MAKE_FOURCC ('R', 'G', 'B', ' ')) return NULL;
if (format != GST_MAKE_FOURCC ('R', 'G', 'B', ' '))
return NULL;
/* if (gst_caps_get_int (caps, "bpp") != ???) return NULL; */
//if (depth != attrib.depth) return NULL;
//if (endianness != ((ImageByteOrder (xinfo->dpy) == LSBFirst) ? G_LITTLE_ENDIAN : G_BIG_ENDIAN)) return NULL;
@ -185,7 +189,7 @@ gst_gl_rgbimage_set_caps (GstImageInfo *info, GstCaps *caps)
//if (green_mask != visual->green_mask) return NULL;
//if (blue_mask != visual->blue_mask) return NULL;
GST_DEBUG ("GL_RGBImage: caps %p are ok, creating image", caps);
new = g_new (GstGLImageConnection, 1);
new->conn.open_conn = gst_gl_rgbimage_open_conn;
new->conn.close_conn = gst_gl_rgbimage_close_conn;
@ -195,34 +199,35 @@ gst_gl_rgbimage_set_caps (GstImageInfo *info, GstCaps *caps)
new->w = width;
new->h = height;
new->bpp = bpp;
return (GstImageConnection *) new;
}
static GstImageData *
gst_gl_rgbimage_get_image (GstImageInfo *info, GstImageConnection *conn)
gst_gl_rgbimage_get_image (GstImageInfo * info, GstImageConnection * conn)
{
GstGLImage *image;
//XWindowAttributes attrib;
GstGLImageInfo *xinfo = gst_gl_rgbimage_info (info);
GstGLImageConnection *xconn = gst_gl_rgbimage_connection (conn);
GstGLImageInfo *xinfo = gst_gl_rgbimage_info (info);
GstGLImageConnection *xconn = gst_gl_rgbimage_connection (conn);
image = g_new (GstGLImage, 1);
/* checks */
if (xinfo == NULL) return NULL;
if (xconn == NULL) return NULL;
if (xinfo->dpy != xconn->dpy)
{
if (xinfo == NULL)
return NULL;
if (xconn == NULL)
return NULL;
if (xinfo->dpy != xconn->dpy) {
g_warning ("XImage: wrong x display specified in 'get_image'\n");
return NULL;
}
image->conn = xconn;
image->data.size = xconn->w * xconn->h * 4;
image->data.data = g_malloc(image->data.size);
if (image->data.data == NULL)
{
image->data.data = g_malloc (image->data.size);
if (image->data.data == NULL) {
g_warning ("GL_RGBImage: data allocation failed!");
g_free (image);
return NULL;
@ -233,160 +238,162 @@ gst_gl_rgbimage_get_image (GstImageInfo *info, GstImageConnection *conn)
static void
gst_gl_rgbimage_put_image (GstImageInfo *info, GstImageData *image)
gst_gl_rgbimage_put_image (GstImageInfo * info, GstImageData * image)
{
float xmax, ymax;
GstGLImageInfo *xinfo = gst_gl_rgbimage_info (info);
GstGLImage *im = (GstGLImage *) image;
int img_width = im->conn->w;
int img_height = im->conn->h;
int img_width = im->conn->w;
int img_height = im->conn->h;
g_assert (xinfo != NULL);
// both upload the video, and redraw the screen
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0.0, 0.0, -5.0);
glMatrixMode (GL_MODELVIEW);
glLoadIdentity ();
glTranslatef (0.0, 0.0, -5.0);
glEnable(GL_TEXTURE_2D);
glEnable (GL_TEXTURE_2D);
if (xinfo->info.demo)
{
glTranslatef(0.0, 0.0, -5.0); // make it avoid the clipping plane, zoom 2.0 instead
glRotatef(180.0*sin(xinfo->rotX),1,0,0);
glRotatef(180.0*cos(xinfo->rotY),0,1,0);
if (xinfo->info.demo) {
glTranslatef (0.0, 0.0, -5.0); // make it avoid the clipping plane, zoom 2.0 instead
glRotatef (180.0 * sin (xinfo->rotX), 1, 0, 0);
glRotatef (180.0 * cos (xinfo->rotY), 0, 1, 0);
xinfo->rotX += 0.01;
xinfo->rotY -= 0.015;
float zoom = xinfo->zoom;
glScalef(zoom,zoom,zoom);
xinfo->rotX += 0.01;
xinfo->rotY -= 0.015;
float zoom = xinfo->zoom;
if (xinfo->zoom > 2.0)
xinfo->zoomdir = -0.01;
glScalef (zoom, zoom, zoom);
if (xinfo->zoom < 1.0)
xinfo->zoomdir = 0.01;
if (xinfo->zoom > 2.0)
xinfo->zoomdir = -0.01;
xinfo->zoom += xinfo->zoomdir;
}
if (xinfo->zoom < 1.0)
xinfo->zoomdir = 0.01;
xinfo->zoom += xinfo->zoomdir;
}
//Draws the surface rectangle
glBindTexture(GL_TEXTURE_2D, im->conn->rgbatex_id);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, im->conn->w, im->conn->h, GL_RGB,
GL_UNSIGNED_BYTE, im->data.data);
xmax = (float)im->conn->w/TEX_XSIZE;
ymax = (float)im->conn->h/TEX_YSIZE;
glBindTexture (GL_TEXTURE_2D, im->conn->rgbatex_id);
glTexSubImage2D (GL_TEXTURE_2D, 0, 0, 0, im->conn->w, im->conn->h, GL_RGB,
GL_UNSIGNED_BYTE, im->data.data);
xmax = (float) im->conn->w / TEX_XSIZE;
ymax = (float) im->conn->h / TEX_YSIZE;
float aspect = img_width/(float)img_height;
float aspect = img_width / (float) img_height;
float hor = aspect;
glColor4f(1,1,1,1);
glBegin(GL_QUADS);
glColor4f (1, 1, 1, 1);
glBegin (GL_QUADS);
glNormal3f(0, -1, 0);
glTexCoord2f(xmax, 0);
glVertex3f(hor,1,0);
glNormal3f (0, -1, 0);
glTexCoord2f(0, 0);
glVertex3f(-hor,1,0);
glTexCoord2f (xmax, 0);
glVertex3f (hor, 1, 0);
glTexCoord2f(0, ymax);
glVertex3f(-hor,-1,0);
glTexCoord2f (0, 0);
glVertex3f (-hor, 1, 0);
glTexCoord2f(xmax, ymax);
glVertex3f(hor,-1,0);
glEnd();
glTexCoord2f (0, ymax);
glVertex3f (-hor, -1, 0);
if (xinfo->info.dumpvideo)
{
static int framenr = 0;
char capfilename[255];
static guint8 *cap_image_data = NULL, *cap_image_data2 = NULL;
int i;
// hmmmm, is this reentrant ?!
if (cap_image_data == NULL)
cap_image_data = (guint8 *)malloc(img_width * img_height * 3);
glTexCoord2f (xmax, ymax);
glVertex3f (hor, -1, 0);
glEnd ();
if (cap_image_data2 == NULL)
cap_image_data2 = (guint8 *)malloc(img_width * img_height * 3);
printf("Recording frame #%d\n", framenr);
glReadPixels(0,0,img_width,img_height,GL_RGB,GL_UNSIGNED_BYTE,cap_image_data);
// invert the pixels
for (i = 0; i < img_height; i++)
memcpy(cap_image_data2 + i * img_width * 3, cap_image_data + (img_height-1-i) * img_width * 3, img_width*3);
sprintf(capfilename, "cap%04d.ppm", framenr);
FILE *outfile = fopen(capfilename, "wb");
if (outfile != NULL)
{
fprintf(outfile, "P6\n");
fprintf(outfile,"# created by raw_zb\n");
fprintf(outfile,"%d %d\n",img_width,img_height);
fprintf(outfile,"255\n");
fwrite(cap_image_data2, sizeof(char), img_width*img_height*3, outfile);
fclose(outfile);
}
framenr++;
if (xinfo->info.dumpvideo) {
static int framenr = 0;
char capfilename[255];
static guint8 *cap_image_data = NULL, *cap_image_data2 = NULL;
int i;
// hmmmm, is this reentrant ?!
if (cap_image_data == NULL)
cap_image_data = (guint8 *) malloc (img_width * img_height * 3);
if (cap_image_data2 == NULL)
cap_image_data2 = (guint8 *) malloc (img_width * img_height * 3);
printf ("Recording frame #%d\n", framenr);
glReadPixels (0, 0, img_width, img_height, GL_RGB, GL_UNSIGNED_BYTE,
cap_image_data);
// invert the pixels
for (i = 0; i < img_height; i++)
memcpy (cap_image_data2 + i * img_width * 3,
cap_image_data + (img_height - 1 - i) * img_width * 3, img_width * 3);
sprintf (capfilename, "cap%04d.ppm", framenr);
FILE *outfile = fopen (capfilename, "wb");
if (outfile != NULL) {
fprintf (outfile, "P6\n");
fprintf (outfile, "# created by raw_zb\n");
fprintf (outfile, "%d %d\n", img_width, img_height);
fprintf (outfile, "255\n");
fwrite (cap_image_data2, sizeof (char), img_width * img_height * 3,
outfile);
fclose (outfile);
}
framenr++;
}
glXSwapBuffers(xinfo->dpy, xinfo->win);
glXSwapBuffers (xinfo->dpy, xinfo->win);
}
void
gst_gl_rgbimage_free_image (GstImageData *image)
gst_gl_rgbimage_free_image (GstImageData * image)
{
GstGLImage *im = (GstGLImage *) image;
g_warning ("gst_gl_rgbimage_free_image doesn't do anything yet -> freeing image\n");
g_warning
("gst_gl_rgbimage_free_image doesn't do anything yet -> freeing image\n");
g_free (im->data.data);
g_free (im);
}
/* Creates an OpenGL texture to upload the picture over */
static void
gst_gl_rgbimage_open_conn (GstImageConnection *conn, GstImageInfo *info)
gst_gl_rgbimage_open_conn (GstImageConnection * conn, GstImageInfo * info)
{
g_warning("Opening RGB Connection; classic OpenGL 1.2 renderer.");
g_warning ("Opening RGB Connection; classic OpenGL 1.2 renderer.");
//GstGLImageInfo *xinfo = gst_gl_rgbimage_info (info);
GstGLImageConnection *xconn = gst_gl_rgbimage_connection (conn);
glGenTextures(1, &xconn->rgbatex_id);
glBindTexture(GL_TEXTURE_2D, xconn->rgbatex_id);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, TEX_XSIZE, TEX_YSIZE, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glGenTextures (1, &xconn->rgbatex_id);
glBindTexture (GL_TEXTURE_2D, xconn->rgbatex_id);
glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, TEX_XSIZE, TEX_YSIZE, 0, GL_RGBA,
GL_UNSIGNED_BYTE, NULL);
}
/* Deletes the creates OpenGL textures */
static void
gst_gl_rgbimage_close_conn (GstImageConnection *conn, GstImageInfo *info)
static void
gst_gl_rgbimage_close_conn (GstImageConnection * conn, GstImageInfo * info)
{
GstGLImageConnection *xconn = gst_gl_rgbimage_connection (conn);
//GstGLImageInfo *xinfo = gst_gl_rgbimage_info (info);
glDeleteTextures(1, &xconn->rgbatex_id);
}
static void
gst_gl_rgbimage_free_conn (GstImageConnection *conn)
{
GstGLImageConnection *xconn = gst_gl_rgbimage_connection (conn);
g_assert (xconn != NULL);
g_free (xconn);
glDeleteTextures (1, &xconn->rgbatex_id);
}
static void
gst_gl_rgbimage_free_conn (GstImageConnection * conn)
{
GstGLImageConnection *xconn = gst_gl_rgbimage_connection (conn);
g_assert (xconn != NULL);
g_free (xconn);
}

544
gst/gl/gstglsink.c
View file

@ -52,37 +52,39 @@ static GstElementDetails gst_glsink_details = {
/* default template - initiated with class struct to allow gst-register to work
with X running */
GST_PAD_TEMPLATE_FACTORY (gst_glsink_sink_template_factory,
"sink",
GST_PAD_SINK,
GST_PAD_ALWAYS,
GST_CAPS_NEW ( "glsink_rgbsink", "video/x-raw-rgb",
"framerate", GST_PROPS_FLOAT_RANGE(0, G_MAXFLOAT),
"width", GST_PROPS_INT_RANGE(0, G_MAXINT),
"height", GST_PROPS_INT_RANGE(0, G_MAXINT)),
GST_CAPS_NEW ( "glsink_yuvsink", "video/x-raw-yuv",
"framerate", GST_PROPS_FLOAT_RANGE(0, G_MAXFLOAT),
"width", GST_PROPS_INT_RANGE(0, G_MAXINT),
"height", GST_PROPS_INT_RANGE(0, G_MAXINT))
)
"sink",
GST_PAD_SINK,
GST_PAD_ALWAYS,
GST_CAPS_NEW ("glsink_rgbsink", "video/x-raw-rgb",
"framerate", GST_PROPS_FLOAT_RANGE (0, G_MAXFLOAT),
"width", GST_PROPS_INT_RANGE (0, G_MAXINT),
"height", GST_PROPS_INT_RANGE (0, G_MAXINT)),
GST_CAPS_NEW ("glsink_yuvsink", "video/x-raw-yuv",
"framerate", GST_PROPS_FLOAT_RANGE (0, G_MAXFLOAT),
"width", GST_PROPS_INT_RANGE (0, G_MAXINT),
"height", GST_PROPS_INT_RANGE (0, G_MAXINT))
)
/* glsink signals and args */
enum {
LAST_SIGNAL
};
enum
{
LAST_SIGNAL
};
enum {
ARG_0,
ARG_WIDTH,
ARG_HEIGHT,
ARG_FRAMES_DISPLAYED,
ARG_FRAME_TIME,
ARG_HOOK,
ARG_MUTE,
ARG_REPAINT,
ARG_DEMO,
ARG_DUMP
};
enum
{
ARG_0,
ARG_WIDTH,
ARG_HEIGHT,
ARG_FRAMES_DISPLAYED,
ARG_FRAME_TIME,
ARG_HOOK,
ARG_MUTE,
ARG_REPAINT,
ARG_DEMO,
ARG_DUMP
};
/* GLsink class */
#define GST_TYPE_GLSINK (gst_glsink_get_type())
@ -91,96 +93,105 @@ enum {
#define GST_IS_GLSINK(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), GST_TYPE_GLSINK))
#define GST_IS_GLSINK_CLASS(obj) (G_TYPE_CHECK_CLASS_TYPE((klass), GST_TYPE_GLSINK))
typedef struct _GstGLSink GstGLSink;
typedef struct _GstGLSinkClass GstGLSinkClass;
typedef struct _GstGLSink GstGLSink;
typedef struct _GstGLSinkClass GstGLSinkClass;
struct _GstGLSink {
GstElement element;
struct _GstGLSink
{
GstElement element;
GstPad *sinkpad;
GstPad *sinkpad;
gint frames_displayed;
guint64 frame_time;
gint width, height;
gboolean muted;
gint demo; // some kind of fun demo mode to let GL show its 3D capabilities
gboolean dumpvideo; // dump the video down to .ppm:s
GstBuffer *last_image; /* not thread safe ? */
GstClock *clock;
gint frames_displayed;
guint64 frame_time;
gint width, height;
gboolean muted;
gint demo; // some kind of fun demo mode to let GL show its 3D capabilities
gboolean dumpvideo; // dump the video down to .ppm:s
GstBuffer *last_image; /* not thread safe ? */
GMutex *cache_lock;
GList *cache;
/* plugins */
GstImagePlugin* plugin;
GstImageConnection *conn;
/* allow anybody to hook in here */
GstImageInfo *hook;
};
GstClock *clock;
struct _GstGLSinkClass {
GstElementClass parent_class;
GMutex *cache_lock;
GList *cache;
/* plugins */
GList *plugins;
};
/* plugins */
GstImagePlugin *plugin;
GstImageConnection *conn;
/* allow anybody to hook in here */
GstImageInfo *hook;
};
struct _GstGLSinkClass
{
GstElementClass parent_class;
/* plugins */
GList *plugins;
};
static GType gst_glsink_get_type (void);
static void gst_glsink_base_init (gpointer g_class);
static void gst_glsink_class_init (GstGLSinkClass *klass);
static void gst_glsink_init (GstGLSink *sink);
static GType gst_glsink_get_type (void);
static void gst_glsink_base_init (gpointer g_class);
static void gst_glsink_class_init (GstGLSinkClass * klass);
static void gst_glsink_init (GstGLSink * sink);
/* static void gst_glsink_dispose (GObject *object); */
static void gst_glsink_chain (GstPad *pad, GstData *_data);
static void gst_glsink_set_clock (GstElement *element, GstClock *clock);
static GstElementStateReturn gst_glsink_change_state (GstElement *element);
static GstPadLinkReturn gst_glsink_sinkconnect (GstPad *pad, GstCaps *caps);
static GstCaps * gst_glsink_getcaps (GstPad *pad, GstCaps *caps);
static void gst_glsink_chain (GstPad * pad, GstData * _data);
static void gst_glsink_set_clock (GstElement * element, GstClock * clock);
static GstElementStateReturn gst_glsink_change_state (GstElement *
element);
static GstPadLinkReturn gst_glsink_sinkconnect (GstPad * pad,
GstCaps * caps);
static GstCaps *gst_glsink_getcaps (GstPad * pad, GstCaps * caps);
static void gst_glsink_set_property (GObject *object, guint prop_id,
const GValue *value, GParamSpec *pspec);
static void gst_glsink_get_property (GObject *object, guint prop_id,
GValue *value, GParamSpec *pspec);
static void gst_glsink_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec);
static void gst_glsink_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec);
static void gst_glsink_release_conn (GstGLSink *sink);
static void gst_glsink_append_cache (GstGLSink *sink, GstImageData *image);
static gboolean gst_glsink_set_caps (GstGLSink *sink, GstCaps *caps);
static void gst_glsink_release_conn (GstGLSink * sink);
static void gst_glsink_append_cache (GstGLSink * sink,
GstImageData * image);
static gboolean gst_glsink_set_caps (GstGLSink * sink, GstCaps * caps);
/* prototypes from plugins */
extern GstImagePlugin* get_gl_rgbimage_plugin (void);
extern GstImagePlugin* get_gl_nvimage_plugin (void);
extern GstImagePlugin *get_gl_rgbimage_plugin (void);
extern GstImagePlugin *get_gl_nvimage_plugin (void);
/* default output */
extern void gst_glxwindow_new (GstGLSink *sink);
extern void gst_glxwindow_hook_context (GstImageInfo *info);
extern void gst_glxwindow_unhook_context (GstImageInfo *info);
extern void gst_glxwindow_new (GstGLSink * sink);
extern void gst_glxwindow_hook_context (GstImageInfo * info);
extern void gst_glxwindow_unhook_context (GstImageInfo * info);
static GstPadTemplate *sink_template;
static GstPadTemplate *sink_template;
static GstElementClass *parent_class = NULL;
static GstElementClass *parent_class = NULL;
/* static guint gst_glsink_signals[LAST_SIGNAL] = { 0 }; */
static GType
gst_glsink_get_type (void)
static GType gst_glsink_get_type (void)
{
static GType videosink_type = 0;
if (!videosink_type) {
static const GTypeInfo videosink_info = {
sizeof(GstGLSinkClass),
sizeof (GstGLSinkClass),
gst_glsink_base_init,
NULL,
(GClassInitFunc) gst_glsink_class_init,
NULL,
NULL,
sizeof(GstGLSink),
sizeof (GstGLSink),
0,
(GInstanceInitFunc) gst_glsink_init,
};
videosink_type = g_type_register_static(GST_TYPE_ELEMENT, "GstGLSink", &videosink_info, 0);
videosink_type =
g_type_register_static (GST_TYPE_ELEMENT, "GstGLSink", &videosink_info,
0);
}
return videosink_type;
}
@ -189,56 +200,52 @@ static void
gst_glsink_base_init (gpointer g_class)
{
GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
gst_element_class_set_details (element_class, &gst_glsink_details);
gst_element_class_add_pad_template (
element_class,
GST_PAD_TEMPLATE_GET (gst_glsink_sink_template_factory));
gst_element_class_add_pad_template (element_class,
GST_PAD_TEMPLATE_GET (gst_glsink_sink_template_factory));
}
static void
gst_glsink_class_init (GstGLSinkClass *klass)
gst_glsink_class_init (GstGLSinkClass * klass)
{
GObjectClass *gobject_class;
GstElementClass *gstelement_class;
gobject_class = (GObjectClass *) klass;
gstelement_class = (GstElementClass*) klass;
gstelement_class = (GstElementClass *) klass;
parent_class = g_type_class_ref (GST_TYPE_ELEMENT);
g_object_class_install_property (gobject_class, ARG_WIDTH,
g_param_spec_int ("width", "Width", "The video width",
G_MININT, G_MAXINT, 0, G_PARAM_READABLE)); /* CHECKME */
g_object_class_install_property (gobject_class, ARG_HEIGHT,
g_param_spec_int ("height", "Height", "The video height",
G_MININT, G_MAXINT, 0, G_PARAM_READABLE)); /* CHECKME */
g_object_class_install_property (gobject_class, ARG_FRAMES_DISPLAYED,
g_param_spec_int ("frames_displayed", "Frames Displayed", "The number of frames displayed so far",
G_MININT,G_MAXINT, 0, G_PARAM_READWRITE)); /* CHECKME */
g_object_class_install_property (gobject_class, ARG_FRAME_TIME,
g_param_spec_int ("frame_time", "Frame time", "The interval between frames",
G_MININT, G_MAXINT, 0, G_PARAM_READWRITE)); /* CHECKME */
g_object_class_install_property (gobject_class, ARG_WIDTH, g_param_spec_int ("width", "Width", "The video width", G_MININT, G_MAXINT, 0, G_PARAM_READABLE)); /* CHECKME */
g_object_class_install_property (gobject_class, ARG_HEIGHT, g_param_spec_int ("height", "Height", "The video height", G_MININT, G_MAXINT, 0, G_PARAM_READABLE)); /* CHECKME */
g_object_class_install_property (gobject_class, ARG_FRAMES_DISPLAYED, g_param_spec_int ("frames_displayed", "Frames Displayed", "The number of frames displayed so far", G_MININT, G_MAXINT, 0, G_PARAM_READWRITE)); /* CHECKME */
g_object_class_install_property (gobject_class, ARG_FRAME_TIME, g_param_spec_int ("frame_time", "Frame time", "The interval between frames", G_MININT, G_MAXINT, 0, G_PARAM_READWRITE)); /* CHECKME */
g_object_class_install_property (gobject_class, ARG_HOOK,
g_param_spec_pointer ("hook", "Hook", "The object receiving the output", G_PARAM_WRITABLE));
g_param_spec_pointer ("hook", "Hook", "The object receiving the output",
G_PARAM_WRITABLE));
g_object_class_install_property (gobject_class, ARG_MUTE,
g_param_spec_boolean ("mute", "Mute", "mute the output ?", FALSE, G_PARAM_READWRITE));
g_param_spec_boolean ("mute", "Mute", "mute the output ?", FALSE,
G_PARAM_READWRITE));
g_object_class_install_property (gobject_class, ARG_REPAINT,
g_param_spec_boolean ("repaint", "Repaint", "repaint the current frame", FALSE, G_PARAM_WRITABLE));
g_param_spec_boolean ("repaint", "Repaint", "repaint the current frame",
FALSE, G_PARAM_WRITABLE));
g_object_class_install_property (gobject_class, ARG_DEMO,
g_param_spec_int ("demo", "Demo", "demo mode (shows 3D capabilities)",0, 1, 0, G_PARAM_READWRITE));
g_param_spec_int ("demo", "Demo", "demo mode (shows 3D capabilities)", 0,
1, 0, G_PARAM_READWRITE));
g_object_class_install_property (gobject_class, ARG_DUMP,
g_param_spec_boolean ("dump", "Dump", "stores sequence of frames in .ppm files", FALSE, G_PARAM_READWRITE));
g_param_spec_boolean ("dump", "Dump",
"stores sequence of frames in .ppm files", FALSE, G_PARAM_READWRITE));
gobject_class->set_property = gst_glsink_set_property;
gobject_class->get_property = gst_glsink_get_property;
/*gobject_class->dispose = gst_glsink_dispose; */
gstelement_class->change_state = gst_glsink_change_state;
gstelement_class->set_clock = gst_glsink_set_clock;
/* plugins */
klass->plugins = NULL;
klass->plugins = g_list_append (klass->plugins, get_gl_rgbimage_plugin ());
@ -251,7 +258,7 @@ gst_glsink_class_init (GstGLSinkClass *klass)
buffer upload
*/
static void
gst_glsink_init (GstGLSink *sink)
gst_glsink_init (GstGLSink * sink)
{
sink->sinkpad = gst_pad_new_from_template (sink_template, "sink");
gst_element_add_pad (GST_ELEMENT (sink), sink->sinkpad);
@ -264,53 +271,52 @@ gst_glsink_init (GstGLSink *sink)
sink->width = 0;
sink->height = 0;
sink->muted = FALSE;
sink->clock = NULL;
GST_FLAG_SET(sink, GST_ELEMENT_THREAD_SUGGESTED);
sink->clock = NULL;
GST_FLAG_SET (sink, GST_ELEMENT_THREAD_SUGGESTED);
GST_FLAG_SET (sink, GST_ELEMENT_EVENT_AWARE);
/* create bufferpool and image cache */
GST_DEBUG ("glsink: creating bufferpool");
sink->cache_lock = g_mutex_new();
sink->cache = NULL;
sink->cache_lock = g_mutex_new ();
sink->cache = NULL;
/* plugins */
sink->plugin = NULL;
sink->conn = NULL;
/* do initialization of default hook here */
gst_glxwindow_new (sink);
gst_glxwindow_new (sink);
//printf("GLSink_init: Current context %p\n", glXGetCurrentContext());
gst_glxwindow_unhook_context(sink->hook);
gst_glxwindow_unhook_context (sink->hook);
}
/** frees the temporary connection that tests the window system capabilities */
static void
gst_glsink_release_conn (GstGLSink *sink)
gst_glsink_release_conn (GstGLSink * sink)
{
if (sink->conn == NULL) return;
if (sink->conn == NULL)
return;
/* free last image if any */
if (sink->last_image != NULL)
{
if (sink->last_image != NULL) {
gst_buffer_unref (sink->last_image);
sink->last_image = NULL;
}
/* free cache */
g_mutex_lock (sink->cache_lock);
while (sink->cache)
{
while (sink->cache) {
sink->plugin->free_image ((GstImageData *) sink->cache->data);
sink->cache = g_list_delete_link (sink->cache, sink->cache);
}
g_mutex_unlock (sink->cache_lock);
/* release connection */
sink->conn->free_conn (sink->conn);
sink->conn = NULL;
}
static void
gst_glsink_append_cache (GstGLSink *sink, GstImageData *image)
static void
gst_glsink_append_cache (GstGLSink * sink, GstImageData * image)
{
g_mutex_lock (sink->cache_lock);
sink->cache = g_list_prepend (sink->cache, image);
@ -322,16 +328,16 @@ gst_glsink_append_cache (GstGLSink *sink, GstImageData *image)
Create a new buffer to hand up the chain.
This allows the plugins to make its own decoding buffers
*/
static GstBuffer*
gst_glsink_buffer_new (GstBufferPool *pool, gint64 location,
guint size, gpointer user_data)
static GstBuffer *
gst_glsink_buffer_new (GstBufferPool * pool, gint64 location,
guint size, gpointer user_data)
{
GstGLSink *sink;
GstBuffer *buffer;
GstImageData *image;
sink = GST_GLSINK (user_data);
/* If cache is non-empty, get buffer from there */
if (sink->cache != NULL) {
g_mutex_lock (sink->cache_lock);
@ -342,12 +348,12 @@ gst_glsink_buffer_new (GstBufferPool *pool, gint64 location,
/* otherwise, get one from the plugin */
image = sink->plugin->get_image (sink->hook, sink->conn);
}
buffer = gst_buffer_new ();
GST_BUFFER_DATA (buffer) = image->data;
GST_BUFFER_SIZE (buffer) = image->size;
GST_BUFFER_POOL_PRIVATE (buffer) = image;
return buffer;
}
@ -355,11 +361,15 @@ gst_glsink_buffer_new (GstBufferPool *pool, gint64 location,
Free a buffer that the chain doesn't need anymore.
*/
static void
gst_glsink_buffer_free (GstBufferPool *pool, GstBuffer *buffer, gpointer user_data)
gst_glsink_buffer_free (GstBufferPool * pool, GstBuffer * buffer,
gpointer user_data)
{
GstGLSink *sink = GST_GLSINK (gst_buffer_pool_get_user_data (GST_BUFFER_BUFFERPOOL (buffer)));
GstGLSink *sink =
GST_GLSINK (gst_buffer_pool_get_user_data (GST_BUFFER_BUFFERPOOL
(buffer)));
gst_glsink_append_cache (sink, (GstImageData *) GST_BUFFER_POOL_PRIVATE (buffer));
gst_glsink_append_cache (sink,
(GstImageData *) GST_BUFFER_POOL_PRIVATE (buffer));
/* set to NULL so the data is not freed */
GST_BUFFER_DATA (buffer) = NULL;
@ -373,23 +383,23 @@ gst_glsink_buffer_free (GstBufferPool *pool, GstBuffer *buffer, gpointer user_da
Go through the plugin list, finding the plugin that first fits the given parameters
*/
static gboolean
gst_glsink_set_caps (GstGLSink *sink, GstCaps *caps)
gst_glsink_set_caps (GstGLSink * sink, GstCaps * caps)
{
g_warning("in glsink set caps!\n");
printf("Getting GLstring, context is %p\n", glXGetCurrentContext());
g_warning ("in glsink set caps!\n");
printf ("Getting GLstring, context is %p\n", glXGetCurrentContext ());
GList *list = ((GstGLSinkClass *) G_OBJECT_GET_CLASS (sink))->plugins;
GstImageConnection *conn = NULL;
while (list)
{
printf("AGetting GLstring, context is %p\n", glXGetCurrentContext());
while (list) {
printf ("AGetting GLstring, context is %p\n", glXGetCurrentContext ());
GstImagePlugin *plugin = (GstImagePlugin *) list->data;
if ((conn = plugin->set_caps (sink->hook, caps)) != NULL)
{
if ((conn = plugin->set_caps (sink->hook, caps)) != NULL) {
//gst_glsink_release_conn (sink);
printf("BGetting GLstring, context is %p\n", glXGetCurrentContext());
printf ("BGetting GLstring, context is %p\n", glXGetCurrentContext ());
sink->conn = conn;
printf("CGetting GLstring, context is %p\n", glXGetCurrentContext());
printf ("CGetting GLstring, context is %p\n", glXGetCurrentContext ());
sink->plugin = plugin;
sink->conn->open_conn (sink->conn, sink->hook);
return TRUE;
@ -403,9 +413,9 @@ gst_glsink_set_caps (GstGLSink *sink, GstCaps *caps)
Link the input video sink internally.
*/
static GstPadLinkReturn
gst_glsink_sinkconnect (GstPad *pad, GstCaps *caps)
gst_glsink_sinkconnect (GstPad * pad, GstCaps * caps)
{
g_warning("in glsink sinkconnect!\n");
g_warning ("in glsink sinkconnect!\n");
GstGLSink *sink;
guint32 fourcc, print_format, result;
@ -414,25 +424,24 @@ gst_glsink_sinkconnect (GstPad *pad, GstCaps *caps)
/* we are not going to act on variable caps */
if (!GST_CAPS_IS_FIXED (caps))
return GST_PAD_LINK_DELAYED;
gst_glxwindow_hook_context(sink->hook);
gst_glxwindow_hook_context (sink->hook);
/* try to set the caps on the output */
result = gst_glsink_set_caps (sink, caps);
gst_glxwindow_unhook_context(sink->hook);
gst_glxwindow_unhook_context (sink->hook);
if (result == FALSE) {
return GST_PAD_LINK_REFUSED;
}
if (result == FALSE)
{
return GST_PAD_LINK_REFUSED;
}
/* remember width & height */
gst_caps_get_int (caps, "width", &sink->width);
gst_caps_get_int (caps, "height", &sink->height);
gst_caps_get_fourcc_int (caps, "format", &fourcc);
print_format = GULONG_FROM_LE (fourcc);
GST_DEBUG ("glsink: setting %08x (%4.4s) %dx%d\n",
fourcc, (gchar*)&print_format, sink->width, sink->height);
GST_DEBUG ("glsink: setting %08x (%4.4s) %dx%d\n",
fourcc, (gchar *) & print_format, sink->width, sink->height);
/* emit signal */
g_object_freeze_notify (G_OBJECT (sink));
@ -443,34 +452,35 @@ gst_glsink_sinkconnect (GstPad *pad, GstCaps *caps)
return GST_PAD_LINK_OK;
}
static GstCaps *
gst_glsink_getcaps (GstPad *pad, GstCaps *caps)
gst_glsink_getcaps (GstPad * pad, GstCaps * caps)
{
g_warning("in glsink get caps!\n");
g_warning ("in glsink get caps!\n");
/* what is the "caps" parameter good for? */
GstGLSink *sink = GST_GLSINK (gst_pad_get_parent (pad));
GstCaps *ret = NULL;
GList *list = ((GstGLSinkClass *) G_OBJECT_GET_CLASS (sink))->plugins;
gst_glxwindow_hook_context(sink->hook);
while (list)
{
ret = gst_caps_append (ret, ((GstImagePlugin *) list->data)->get_caps (sink->hook));
gst_glxwindow_hook_context (sink->hook);
while (list) {
ret =
gst_caps_append (ret,
((GstImagePlugin *) list->data)->get_caps (sink->hook));
list = g_list_next (list);
}
gst_glxwindow_unhook_context(sink->hook);
gst_glxwindow_unhook_context (sink->hook);
return ret;
}
static void
gst_glsink_set_clock (GstElement *element, GstClock *clock)
gst_glsink_set_clock (GstElement * element, GstClock * clock)
{
GstGLSink *sink = GST_GLSINK (element);
sink->clock = clock;
}
static void
gst_glsink_chain (GstPad *pad, GstData *_data)
gst_glsink_chain (GstPad * pad, GstData * _data)
{
//g_warning("in glsink_chain!\n");
GstBuffer *buf = GST_BUFFER (_data);
@ -489,30 +499,30 @@ gst_glsink_chain (GstPad *pad, GstData *_data)
switch (GST_EVENT_TYPE (event)) {
default:
gst_pad_event_default (pad, event);
gst_pad_event_default (pad, event);
}
return;
}
GST_DEBUG ("glsink: clock wait: %llu %u",
GST_BUFFER_TIMESTAMP (buf), GST_BUFFER_SIZE (buf));
GST_DEBUG ("glsink: clock wait: %llu %u",
GST_BUFFER_TIMESTAMP (buf), GST_BUFFER_SIZE (buf));
#if 0
GstClockTime time = GST_BUFFER_TIMESTAMP (buf);
static int frame_drops = 0;
if (sink->clock && time != -1) {
if (time < gst_clock_get_time(sink->clock))
{
g_warning("Frame drop (%d consecutive) !!", frame_drops);
/* we are going to drop late buffers */
gst_buffer_unref (buf);
frame_drops++;
return;
}
frame_drops = 0; // we made it - reset time
if (time < gst_clock_get_time (sink->clock)) {
g_warning ("Frame drop (%d consecutive) !!", frame_drops);
/* we are going to drop late buffers */
gst_buffer_unref (buf);
frame_drops++;
return;
}
frame_drops = 0; // we made it - reset time
GstClockReturn ret;
GstClockID id = gst_clock_new_single_shot_id (sink->clock, GST_BUFFER_TIMESTAMP (buf));
GstClockID id =
gst_clock_new_single_shot_id (sink->clock, GST_BUFFER_TIMESTAMP (buf));
ret = gst_element_clock_wait (GST_ELEMENT (sink), id, NULL);
gst_clock_id_free (id);
@ -529,71 +539,74 @@ gst_glsink_chain (GstPad *pad, GstData *_data)
sink->frames_displayed++;
g_object_notify (G_OBJECT (sink), "frames_displayed");
if (!sink->muted)
{
if (glXGetCurrentContext() == NULL)
{
printf("Rehooking window !\n");
gst_glxwindow_hook_context(sink->hook);
if (!sink->muted) {
if (glXGetCurrentContext () == NULL) {
printf ("Rehooking window !\n");
gst_glxwindow_hook_context (sink->hook);
#if 1
GST_DEBUG("Initializing OpenGL parameters\n");
/* initialize OpenGL drawing */
glEnable(GL_DEPTH_TEST);
glEnable(GL_TEXTURE_2D);
glClearDepth(1.0f);
glClearColor(0, 0, 0, 0);
glEnable(GL_AUTO_NORMAL); // let OpenGL generate the Normals
glDisable(GL_BLEND);
glDisable(GL_CULL_FACE);
glPolygonMode(GL_FRONT, GL_FILL);
glPolygonMode(GL_BACK, GL_FILL);
glShadeModel(GL_SMOOTH);
glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_NICEST);
GstGLImageInfo *window = (GstGLImageInfo *)sink->hook;
int w=window->width, h = window->height;
GST_DEBUG ("Initializing OpenGL parameters\n");
/* initialize OpenGL drawing */
glEnable (GL_DEPTH_TEST);
glEnable (GL_TEXTURE_2D);
glClearDepth (1.0f);
glClearColor (0, 0, 0, 0);
glViewport(0, 0, (GLint) w, (GLint) h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
GLfloat aspect = (GLfloat) w / (GLfloat) h;
glFrustum(-aspect, aspect, -1.0, 1.0, 5.0, 500.0);
glEnable (GL_AUTO_NORMAL); // let OpenGL generate the Normals
glDisable (GL_BLEND);
glDisable (GL_CULL_FACE);
glPolygonMode (GL_FRONT, GL_FILL);
glPolygonMode (GL_BACK, GL_FILL);
glShadeModel (GL_SMOOTH);
glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
GstGLImageInfo *window = (GstGLImageInfo *) sink->hook;
int w = window->width, h = window->height;
glViewport (0, 0, (GLint) w, (GLint) h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
GLfloat aspect = (GLfloat) w / (GLfloat) h;
glFrustum (-aspect, aspect, -1.0, 1.0, 5.0, 500.0);
#endif
gst_glxwindow_unhook_context(sink->hook);
gst_glxwindow_hook_context(sink->hook);
glMatrixMode(GL_MODELVIEW);
#if 0
sink->hook->free_info(sink->hook);
printf("Reallocating window brutally !\n");
gst_glxwindow_new(sink);
gst_glxwindow_unhook_context (sink->hook);
gst_glxwindow_hook_context (sink->hook);
glMatrixMode (GL_MODELVIEW);
#if 0
sink->hook->free_info (sink->hook);
printf ("Reallocating window brutally !\n");
gst_glxwindow_new (sink);
#endif
}
}
/* free last_image, if any */
if (sink->last_image != NULL)
gst_buffer_unref (sink->last_image);
if (sink->bufferpool && GST_BUFFER_BUFFERPOOL (buf) == sink->bufferpool) {
// awful hack ! But I currently have no other solution without changing the API
sink->hook->demo = sink->demo;
sink->hook->dumpvideo = sink->dumpvideo;
sink->plugin->put_image (sink->hook, (GstImageData *) GST_BUFFER_POOL_PRIVATE (buf));
sink->plugin->put_image (sink->hook,
(GstImageData *) GST_BUFFER_POOL_PRIVATE (buf));
sink->last_image = buf;
} else {
buffer = gst_buffer_new_from_pool (gst_glsink_get_bufferpool (sink->sinkpad),
0, GST_BUFFER_SIZE (buf));
memcpy (GST_BUFFER_DATA (buffer), GST_BUFFER_DATA (buf),
GST_BUFFER_SIZE (buf) > GST_BUFFER_SIZE (buffer) ?
GST_BUFFER_SIZE (buffer) : GST_BUFFER_SIZE (buf));
buffer =
gst_buffer_new_from_pool (gst_glsink_get_bufferpool (sink->sinkpad),
0, GST_BUFFER_SIZE (buf));
memcpy (GST_BUFFER_DATA (buffer), GST_BUFFER_DATA (buf),
GST_BUFFER_SIZE (buf) >
GST_BUFFER_SIZE (buffer) ? GST_BUFFER_SIZE (buffer) :
GST_BUFFER_SIZE (buf));
sink->plugin->put_image (sink->hook, (GstImageData *) GST_BUFFER_POOL_PRIVATE (buffer));
sink->plugin->put_image (sink->hook,
(GstImageData *) GST_BUFFER_POOL_PRIVATE (buffer));
sink->last_image = buffer;
gst_buffer_unref (buf);
@ -601,12 +614,13 @@ gst_glsink_chain (GstPad *pad, GstData *_data)
//gst_glxwindow_unhook_context(sink->hook);
}
}
static void
gst_glsink_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
gst_glsink_set_property (GObject * object, guint prop_id, const GValue * value,
GParamSpec * pspec)
{
//g_warning("in set_property!\n");
GstGLSink *sink;
@ -625,8 +639,7 @@ gst_glsink_set_property (GObject *object, guint prop_id, const GValue *value, GP
sink->frame_time = g_value_get_int (value);
break;
case ARG_HOOK:
if (sink->hook)
{
if (sink->hook) {
sink->hook->free_info (sink->hook);
}
sink->hook = g_value_get_pointer (value);
@ -645,7 +658,8 @@ gst_glsink_set_property (GObject *object, guint prop_id, const GValue *value, GP
break;
case ARG_REPAINT:
if (sink->last_image != NULL) {
sink->plugin->put_image (sink->hook, (GstImageData *) GST_BUFFER_POOL_PRIVATE (sink->last_image));
sink->plugin->put_image (sink->hook,
(GstImageData *) GST_BUFFER_POOL_PRIVATE (sink->last_image));
}
break;
default:
@ -655,13 +669,14 @@ gst_glsink_set_property (GObject *object, guint prop_id, const GValue *value, GP
}
static void
gst_glsink_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
gst_glsink_get_property (GObject * object, guint prop_id, GValue * value,
GParamSpec * pspec)
{
//g_warning("in get_property!\n");
GstGLSink *sink;
/* it's not null if we got it, but it might not be ours */
sink = GST_GLSINK(object);
sink = GST_GLSINK (object);
switch (prop_id) {
case ARG_WIDTH:
@ -674,7 +689,7 @@ gst_glsink_get_property (GObject *object, guint prop_id, GValue *value, GParamSp
g_value_set_int (value, sink->frames_displayed);
break;
case ARG_FRAME_TIME:
g_value_set_int (value, sink->frame_time/1000000);
g_value_set_int (value, sink->frame_time / 1000000);
break;
case ARG_MUTE:
g_value_set_boolean (value, sink->muted);
@ -685,7 +700,7 @@ gst_glsink_get_property (GObject *object, guint prop_id, GValue *value, GParamSp
case ARG_DUMP:
g_value_set_boolean (value, sink->dumpvideo);
break;
default:
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
@ -693,7 +708,7 @@ gst_glsink_get_property (GObject *object, guint prop_id, GValue *value, GParamSp
static GstElementStateReturn
gst_glsink_change_state (GstElement *element)
gst_glsink_change_state (GstElement * element)
{
//g_warning("in change_state!\n");
GstGLSink *sink;
@ -704,23 +719,23 @@ gst_glsink_change_state (GstElement *element)
case GST_STATE_NULL_TO_READY:
break;
case GST_STATE_READY_TO_PAUSED:
{
//g_warning("Going GST_STATE_READY_TO_PAUSED: %p", sink->conn);
}
{
//g_warning("Going GST_STATE_READY_TO_PAUSED: %p", sink->conn);
}
break;
case GST_STATE_PAUSED_TO_PLAYING:
{
//g_warning("Going GST_STATE_PAUSED_TO_PLAYING: %p", sink->conn);
}
{
//g_warning("Going GST_STATE_PAUSED_TO_PLAYING: %p", sink->conn);
}
break;
case GST_STATE_PLAYING_TO_PAUSED:
break;
case GST_STATE_PAUSED_TO_READY:
if (sink->conn)
sink->conn->close_conn (sink->conn, sink->hook);
sink->conn->close_conn (sink->conn, sink->hook);
if (sink->last_image) {
gst_buffer_unref (sink->last_image);
sink->last_image = NULL;
sink->last_image = NULL;
}
break;
case GST_STATE_READY_TO_NULL:
@ -734,18 +749,15 @@ gst_glsink_change_state (GstElement *element)
}
static gboolean
plugin_init (GstPlugin *plugin)
plugin_init (GstPlugin * plugin)
{
/* Loading the library containing GstVideoSink, our parent object */
if (!gst_library_load ("gstvideo"))
return FALSE;
/* this is needed later on in the _real_ init (during a gst-launch) */
sink_template = gst_pad_template_new (
"sink",
GST_PAD_SINK,
GST_PAD_ALWAYS,
NULL);
sink_template = gst_pad_template_new ("sink",
GST_PAD_SINK, GST_PAD_ALWAYS, NULL);
if (!gst_element_register (plugin, "glsink", GST_RANK_NONE, GST_TYPE_GLSINK))
return FALSE;
@ -753,14 +765,8 @@ plugin_init (GstPlugin *plugin)
return TRUE;
}
GST_PLUGIN_DEFINE (
GST_VERSION_MAJOR,
GST_VERSION_MINOR,
"glsink",
"An OpenGL based video sink - uses OpenGL and GLX to draw video, utilizing different acceleration options",
plugin_init,
VERSION,
GST_LICENSE,
GST_PACKAGE,
GST_ORIGIN
);
GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
GST_VERSION_MINOR,
"glsink",
"An OpenGL based video sink - uses OpenGL and GLX to draw video, utilizing different acceleration options",
plugin_init, VERSION, GST_LICENSE, GST_PACKAGE, GST_ORIGIN);

115
gst/gl/gstglsink.h
View file

@ -25,72 +25,81 @@
#include <gst/gst.h>
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
extern "C"
{
#endif /* __cplusplus */
#define MAX_FLIP_BUFFERS 1
typedef struct _GstImageInfo GstImageInfo;
struct _GstImageInfo {
gulong id;
int demo;
int dumpvideo;
void (*free_info) (GstImageInfo *info);
};
typedef struct _GstImageInfo GstImageInfo;
struct _GstImageInfo
{
gulong id;
int demo;
int dumpvideo;
void (*free_info) (GstImageInfo * info);
};
typedef struct _GstImageData GstImageData;
struct _GstImageData {
gint size;
gchar *data;
};
typedef struct _GstImageData GstImageData;
struct _GstImageData
{
gint size;
gchar *data;
};
typedef struct _GstImageConnection GstImageConnection;
struct _GstImageConnection {
void (*open_conn) (GstImageConnection *conn, GstImageInfo *info);
void (*close_conn) (GstImageConnection *conn, GstImageInfo *info);
void (*free_conn) (GstImageConnection *conn);
};
typedef struct _GstImageConnection GstImageConnection;
struct _GstImageConnection
{
void (*open_conn) (GstImageConnection * conn, GstImageInfo * info);
void (*close_conn) (GstImageConnection * conn, GstImageInfo * info);
void (*free_conn) (GstImageConnection * conn);
};
typedef GstCaps * (*GstImagePluginGetCapsFunc) (GstImageInfo *info);
typedef GstImageConnection * (*GstImagePluginSetCapsFunc) (GstImageInfo *info, GstCaps *caps);
typedef GstImageData* (*GstImagePluginGetImageFunc) (GstImageInfo *info, GstImageConnection *conn);
typedef void (*GstImagePluginPutImageFunc) (GstImageInfo *info, GstImageData *image);
typedef void (*GstImagePluginFreeImageFunc) (GstImageData *image);
typedef GstCaps *(*GstImagePluginGetCapsFunc) (GstImageInfo * info);
typedef GstImageConnection *(*GstImagePluginSetCapsFunc) (GstImageInfo * info,
GstCaps * caps);
typedef GstImageData *(*GstImagePluginGetImageFunc) (GstImageInfo * info,
GstImageConnection * conn);
typedef void (*GstImagePluginPutImageFunc) (GstImageInfo * info,
GstImageData * image);
typedef void (*GstImagePluginFreeImageFunc) (GstImageData * image);
typedef struct _GstImagePlugin GstImagePlugin;
struct _GstImagePlugin {
GstImagePluginGetCapsFunc get_caps;
GstImagePluginSetCapsFunc set_caps;
GstImagePluginGetImageFunc get_image;
GstImagePluginPutImageFunc put_image;
GstImagePluginFreeImageFunc free_image;
};
typedef struct _GstImagePlugin GstImagePlugin;
struct _GstImagePlugin
{
GstImagePluginGetCapsFunc get_caps;
GstImagePluginSetCapsFunc set_caps;
GstImagePluginGetImageFunc get_image;
GstImagePluginPutImageFunc put_image;
GstImagePluginFreeImageFunc free_image;
};
typedef struct _GstGLImageInfo GstGLImageInfo;
typedef struct _GstGLImageInfo GstGLImageInfo;
/* stuff about our window grouped together */
struct _GstGLImageInfo {
GstImageInfo info;
Display *dpy;
int screen;
Window win;
GLXContext ctx;
XSetWindowAttributes attr;
Bool fs;
//XF86VidModeModeInfo deskMode;
int x, y;
unsigned int width, height;
unsigned int depth;
/* window specific from here */
GstElement *sink;
gulong handler_id;
float rotX,rotY,zoom, zoomdir;
};
struct _GstGLImageInfo
{
GstImageInfo info;
Display *dpy;
int screen;
Window win;
GLXContext ctx;
XSetWindowAttributes attr;
Bool fs;
//XF86VidModeModeInfo deskMode;
int x, y;
unsigned int width, height;
unsigned int depth;
/* window specific from here */
GstElement *sink;
gulong handler_id;
float rotX, rotY, zoom, zoomdir;
};
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __cplusplus */
#endif /* __GST_VIDEOSINK_H__ */
#endif /* __GST_VIDEOSINK_H__ */

266
gst/gl/gstglxwindow.c
View file

@ -17,128 +17,119 @@
#include <GL/gl.h>
#include <GL/glu.h>
#include "gstglsink.h"
#include <string.h> /* strncmp */
#include <string.h> /* strncmp */
/* attributes for a single buffered visual in RGBA format with at least
* 4 bits per color and a 16 bit depth buffer */
static int attrListSgl[] =
{
GLX_RGBA, GLX_RED_SIZE, 4,
GLX_GREEN_SIZE, 4,
GLX_BLUE_SIZE, 4,
static int attrListSgl[] = {
GLX_RGBA, GLX_RED_SIZE, 4,
GLX_GREEN_SIZE, 4,
GLX_BLUE_SIZE, 4,
GLX_DEPTH_SIZE, 16,
None
};
/* attributes for a double buffered visual in RGBA format with at least
* 4 bits per color and a 16 bit depth buffer */
static int attrListDbl[] =
{
GLX_RGBA, GLX_DOUBLEBUFFER,
GLX_RED_SIZE, 4,
GLX_GREEN_SIZE, 4,
GLX_BLUE_SIZE, 4,
GLX_DEPTH_SIZE, 16,
None
};
static int attrListDbl[] = {
GLX_RGBA, GLX_DOUBLEBUFFER,
GLX_RED_SIZE, 4,
GLX_GREEN_SIZE, 4,
GLX_BLUE_SIZE, 4,
GLX_DEPTH_SIZE, 16,
None
};
GLfloat LightAmbient[] = { 0.1, 0.1, 0.1, 1.0 }; /* reddish ambient light */
GLfloat LightDiffuse[] = { 0.6, 0.6, 0.6, 1.0 }; /* bluish diffuse light. */
GLfloat LightPosition[] = { 1.5, 1.5, 1.5, 0.0 }; /* position */
GLfloat LightAmbient[] = { 0.1, 0.1, 0.1, 1.0 }; /* reddish ambient light */
GLfloat LightDiffuse[] = { 0.6, 0.6, 0.6, 1.0 }; /* bluish diffuse light. */
GLfloat LightPosition[] = { 1.5, 1.5, 1.5, 0.0 }; /* position */
void
gst_glxwindow_unhook_context(GstImageInfo *info)
gst_glxwindow_unhook_context (GstImageInfo * info)
{
GstGLImageInfo *window = (GstGLImageInfo *) info;
if (window->ctx)
{
if (!glXMakeCurrent(window->dpy, None, NULL))
{
printf("Could not release drawing context.\n");
}
else
printf("Released drawing context.\n");
}
if (window->ctx) {
if (!glXMakeCurrent (window->dpy, None, NULL)) {
printf ("Could not release drawing context.\n");
} else
printf ("Released drawing context.\n");
}
}
void
gst_glxwindow_hook_context(GstImageInfo *info)
gst_glxwindow_hook_context (GstImageInfo * info)
{
GstGLImageInfo *window = (GstGLImageInfo *) info;
if (window->ctx && window->win && window->ctx)
{
if (!glXMakeCurrent(window->dpy, window->win, window->ctx))
{
printf("Could not acquire GLX drawing context.\n");
}
else
printf("Acquired drawing context.\n");
}
if (window->ctx && window->win && window->ctx) {
if (!glXMakeCurrent (window->dpy, window->win, window->ctx)) {
printf ("Could not acquire GLX drawing context.\n");
} else
printf ("Acquired drawing context.\n");
}
}
static void
gst_glxwindow_free (GstImageInfo *info)
gst_glxwindow_free (GstImageInfo * info)
{
GstGLImageInfo *window = (GstGLImageInfo *) info;
g_signal_handler_disconnect (window->sink, window->handler_id);
if (window->ctx)
{
if (!glXMakeCurrent(window->dpy, None, NULL))
{
printf("Could not release drawing context.\n");
}
glXDestroyContext(window->dpy, window->ctx);
window->ctx = NULL;
}
#if 0
/* switch back to original desktop resolution if we were in fs */
if (GLWin.fs)
{
XF86VidModeSwitchToMode(GLWin.dpy, GLWin.screen, &GLWin.deskMode);
XF86VidModeSetViewPort(GLWin.dpy, GLWin.screen, 0, 0);
if (window->ctx) {
if (!glXMakeCurrent (window->dpy, None, NULL)) {
printf ("Could not release drawing context.\n");
}
glXDestroyContext (window->dpy, window->ctx);
window->ctx = NULL;
}
#if 0
/* switch back to original desktop resolution if we were in fs */
if (GLWin.fs) {
XF86VidModeSwitchToMode (GLWin.dpy, GLWin.screen, &GLWin.deskMode);
XF86VidModeSetViewPort (GLWin.dpy, GLWin.screen, 0, 0);
}
#endif
XCloseDisplay (window->dpy);
g_free (window);
}
static void
gst_glxwindow_callback(GObject *object, GParamSpec *pspec, GstGLImageInfo *data)
gst_glxwindow_callback (GObject * object, GParamSpec * pspec,
GstGLImageInfo * data)
{
XWindowAttributes attr;
XGetWindowAttributes(data->dpy, data->win, &attr);
XWindowAttributes attr;
if (strncmp (pspec->name, "width", 5) == 0 || strncmp (pspec->name, "height", 6) == 0)
{
XGetWindowAttributes (data->dpy, data->win, &attr);
if (strncmp (pspec->name, "width", 5) == 0
|| strncmp (pspec->name, "height", 6) == 0) {
gint w = 0;
gint h = 0;
g_object_get (object, "width", &w, NULL);
g_object_get (object, "height", &h, NULL);
if (w != attr.width || h != attr.height)
{
if (w != attr.width || h != attr.height) {
attr.width = w;
attr.height = h;
XResizeWindow (data->dpy, data->win, attr.width, attr.height);
XMapRaised (data->dpy, data->win);
// resize OpenGL
g_warning("resizing in OpenGL");
glViewport(0, 0, (GLint) w, (GLint) h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
g_warning ("resizing in OpenGL");
glViewport (0, 0, (GLint) w, (GLint) h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
GLfloat aspect = (GLfloat) h / (GLfloat) w;
glFrustum(-1.0, 1.0, -aspect, aspect, 5.0, 500.0);
glFrustum (-1.0, 1.0, -aspect, aspect, 5.0, 500.0);
}
}
if (attr.width != data->width || attr.height != data->height)
{
if (attr.width != data->width || attr.height != data->height) {
data->width = attr.width;
data->height = attr.height;
}
@ -146,57 +137,54 @@ gst_glxwindow_callback(GObject *object, GParamSpec *pspec, GstGLImageInfo *data)
}
void
gst_glxwindow_new (GstElement *sink)
gst_glxwindow_new (GstElement * sink)
{
//XGCValues values;
GstGLImageInfo *new;
int glxMajorVersion, glxMinorVersion;
//XSetWindowAttributes attrib;
XVisualInfo *vi;
Atom wmDelete;
Window winDummy;
unsigned int borderDummy;
Colormap cmap;
char* title = "GLSink (experimental)";
char *title = "GLSink (experimental)";
new = g_new0 (GstGLImageInfo, 1);
if (sink == NULL)
{
if (sink == NULL) {
sink = gst_element_factory_make ("glsink", "glsink");
g_assert (sink != NULL);
}
/* fill in the ImageInfo */
new->info.id = GST_MAKE_FOURCC ('X', 'l', 'i', 'b');
new->info.free_info = gst_glxwindow_free;
new->dpy = XOpenDisplay (NULL);
if (!new->dpy) {
g_warning ("open display failed!\n");
g_free (new);
return;
}
new->screen = DefaultScreen(new->dpy);
new->screen = DefaultScreen (new->dpy);
/* get an appropriate visual */
vi = glXChooseVisual(new->dpy, new->screen, attrListDbl);
if (vi == NULL)
{
vi = glXChooseVisual(new->dpy, new->screen, attrListSgl);
GST_DEBUG("Only Singlebuffered Visual!\n");
}
else
{
GST_DEBUG("Got Doublebuffered Visual!\n");
}
glXQueryVersion(new->dpy, &glxMajorVersion, &glxMinorVersion);
GST_DEBUG("glX-Version %d.%d\n", glxMajorVersion, glxMinorVersion);
vi = glXChooseVisual (new->dpy, new->screen, attrListDbl);
if (vi == NULL) {
vi = glXChooseVisual (new->dpy, new->screen, attrListSgl);
GST_DEBUG ("Only Singlebuffered Visual!\n");
} else {
GST_DEBUG ("Got Doublebuffered Visual!\n");
}
glXQueryVersion (new->dpy, &glxMajorVersion, &glxMinorVersion);
GST_DEBUG ("glX-Version %d.%d\n", glxMajorVersion, glxMinorVersion);
/* create a GLX context */
new->ctx = glXCreateContext(new->dpy, vi, 0, GL_TRUE);
new->ctx = glXCreateContext (new->dpy, vi, 0, GL_TRUE);
/* create a color map */
cmap = XCreateColormap(new->dpy, RootWindow(new->dpy, vi->screen),
vi->visual, AllocNone);
cmap = XCreateColormap (new->dpy, RootWindow (new->dpy, vi->screen),
vi->visual, AllocNone);
new->attr.colormap = cmap;
new->attr.border_pixel = 0;
@ -206,72 +194,72 @@ gst_glxwindow_new (GstElement *sink)
new->width = 10;
new->height = 10;
new->rotX = 0;
new->rotY = 0;
new->rotX = 0;
new->rotY = 0;
new->zoom = 1;
new->zoomdir = 0.01;
{
/* create a window in window mode*/
/* create a window in window mode */
new->attr.event_mask = ExposureMask | KeyPressMask | ButtonPressMask |
StructureNotifyMask;
new->win = XCreateWindow(new->dpy, RootWindow(new->dpy, vi->screen),
new->x, new->y, new->width, new->height, 0, vi->depth, InputOutput, vi->visual,
CWBorderPixel | CWColormap | CWEventMask, &new->attr);
if (!new->win)
{
g_warning ("create window failed\n");
g_free (new);
return;
}
StructureNotifyMask;
new->win = XCreateWindow (new->dpy, RootWindow (new->dpy, vi->screen),
new->x, new->y, new->width, new->height, 0, vi->depth, InputOutput,
vi->visual, CWBorderPixel | CWColormap | CWEventMask, &new->attr);
if (!new->win) {
g_warning ("create window failed\n");
g_free (new);
return;
}
/* only set window title and handle wm_delete_events if in windowed mode */
wmDelete = XInternAtom(new->dpy, "WM_DELETE_WINDOW", True);
XSetWMProtocols(new->dpy, new->win, &wmDelete, 1);
XSetStandardProperties(new->dpy, new->win, title,
title, None, NULL, 0, NULL);
XMapRaised(new->dpy, new->win);
}
wmDelete = XInternAtom (new->dpy, "WM_DELETE_WINDOW", True);
XSetWMProtocols (new->dpy, new->win, &wmDelete, 1);
XSetStandardProperties (new->dpy, new->win, title,
title, None, NULL, 0, NULL);
XMapRaised (new->dpy, new->win);
}
/* connect the glx-context to the window */
glXMakeCurrent(new->dpy, new->win, new->ctx);
XGetGeometry(new->dpy, new->win, &winDummy, &new->x, &new->y,
&new->width, &new->height, &borderDummy, &new->depth);
printf("Depth %d\n", new->depth);
if (glXIsDirect(new->dpy, new->ctx))
GST_DEBUG ("Congrats, you have Direct Rendering!\n");
glXMakeCurrent (new->dpy, new->win, new->ctx);
XGetGeometry (new->dpy, new->win, &winDummy, &new->x, &new->y,
&new->width, &new->height, &borderDummy, &new->depth);
printf ("Depth %d\n", new->depth);
if (glXIsDirect (new->dpy, new->ctx))
GST_DEBUG ("Congrats, you have Direct Rendering!\n");
else
GST_DEBUG ("Sorry, no Direct Rendering possible!\n");
g_warning("Initializing OpenGL parameters\n");
g_warning ("Initializing OpenGL parameters\n");
/* initialize OpenGL drawing */
glEnable(GL_DEPTH_TEST);
glEnable (GL_DEPTH_TEST);
//glShadeModel(GL_SMOOTH);
glEnable(GL_TEXTURE_2D);
glDisable(GL_CULL_FACE);
glClearDepth(1.0f);
glClearColor(0, 0, 0, 0);
glEnable (GL_TEXTURE_2D);
glDisable (GL_CULL_FACE);
glClearDepth (1.0f);
glClearColor (0, 0, 0, 0);
glLightfv(GL_LIGHT0, GL_AMBIENT, LightAmbient); /* add lighting. (ambient) */
glLightfv(GL_LIGHT0, GL_DIFFUSE, LightDiffuse); /* add lighting. (diffuse). */
glLightfv(GL_LIGHT0, GL_POSITION,LightPosition); /* set light position. */
//glEnable(GL_LIGHT0); // Quick And Dirty Lighting (Assumes Light0 Is Set Up)
//glEnable(GL_LIGHTING); // Enable Lighting
glDisable(GL_COLOR_MATERIAL); // Enable Material Coloring
glEnable(GL_AUTO_NORMAL); // let OpenGL generate the Normals
glLightfv (GL_LIGHT0, GL_AMBIENT, LightAmbient); /* add lighting. (ambient) */
glLightfv (GL_LIGHT0, GL_DIFFUSE, LightDiffuse); /* add lighting. (diffuse). */
glLightfv (GL_LIGHT0, GL_POSITION, LightPosition); /* set light position. */
glDisable(GL_BLEND);
//glEnable(GL_LIGHT0); // Quick And Dirty Lighting (Assumes Light0 Is Set Up)
//glEnable(GL_LIGHTING); // Enable Lighting
glDisable (GL_COLOR_MATERIAL); // Enable Material Coloring
glEnable (GL_AUTO_NORMAL); // let OpenGL generate the Normals
glPolygonMode(GL_FRONT, GL_FILL);
glPolygonMode(GL_BACK, GL_FILL);
glDisable (GL_BLEND);
glShadeModel(GL_SMOOTH);
glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_NICEST);
glPolygonMode (GL_FRONT, GL_FILL);
glPolygonMode (GL_BACK, GL_FILL);
glShadeModel (GL_SMOOTH);
glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
XSelectInput (new->dpy, new->win, ExposureMask | StructureNotifyMask);
g_object_set (sink, "hook", new, NULL);
new->sink = sink;
new->handler_id = g_signal_connect (sink, "notify", G_CALLBACK (gst_glxwindow_callback), new);
new->handler_id =
g_signal_connect (sink, "notify", G_CALLBACK (gst_glxwindow_callback),
new);
}

605
gst/gl/regcomb_yuvrgb.c
View file

@ -23,313 +23,378 @@ unsigned char *UPlane;
unsigned char *VPlane;
// YUV 4:2:2 example
unsigned int Ywidth=512, Yheight=512;
unsigned int UVwidth=256, UVheight=512;
unsigned int Ywidth = 512, Yheight = 512;
unsigned int UVwidth = 256, UVheight = 512;
int tex_xsize, tex_ysize;
void GenerateRGBTables(unsigned char *Ytable, // Y-palette
unsigned char *Utable, // U-palette
unsigned char *Vtable, // V-palette
float *bias, // bias (fourth vector to be added)
float *Uscale, // scaling color for U
float *Vscale) // scaling color for V
void
GenerateRGBTables (unsigned char *Ytable, // Y-palette
unsigned char *Utable, // U-palette
unsigned char *Vtable, // V-palette
float *bias, // bias (fourth vector to be added)
float *Uscale, // scaling color for U
float *Vscale) // scaling color for V
{
int i;
const float mat[9]= { // the modified YUV->RGB matrix
+1.130469478f,-0.058755723f,+1.596026304f,
+1.130469478f,-0.450515935f,-0.812967512f,
+1.130469478f,+1.958477882f, 0.0f
};
#define COMPRESS(a)(0.5f*(a)+128.0f) // counter-piece to EXPAND_NORMAL
#define fCOMPRESS(a) (0.5f*(a)+0.5f);
#define XCLAMP(a) ((a)<0.0f ? 0.0f : ((a)>255.0f ? 255.0f : (a))) // should not be necessary, but what do you know.
bias[0]=fCOMPRESS(-0.842580964f);
bias[1]=fCOMPRESS(+0.563287723f);
bias[2]=fCOMPRESS(-1.0f);
bias[3]=0.0f;
Uscale[0]=8.0f/255.0f;
Uscale[1]=60.0f/255.0f;
Uscale[2]=250.0f/255.0f;
Uscale[3]=0.0f;
Vscale[0]=204.0f/255.0f;
Vscale[1]=105.0f/255.0f;
Vscale[2]=0.5f;
Vscale[3]=0.0f;
for (i=0; i<256; i++) {
// Y-table holds unsigned values
Ytable[3*i ]=(unsigned char)XCLAMP(mat[0]*(float)i); // R
Ytable[3*i+1]=(unsigned char)XCLAMP(mat[3]*(float)i); // G
Ytable[3*i+2]=(unsigned char)XCLAMP(mat[6]*(float)i); // B
// U-table holds signed values
Utable[3*i ]=(unsigned char)XCLAMP(COMPRESS(255.0f/ 16.0f*mat[1]*(float)i)); // R
Utable[3*i+1]=(unsigned char)XCLAMP(COMPRESS(255.0f/120.0f*mat[4]*(float)i)); // G
Utable[3*i+2]=(unsigned char)XCLAMP(COMPRESS(255.0f/500.0f*mat[7]*(float)i)); // B
// V-table holds signed values
Vtable[3*i ]=(unsigned char)XCLAMP(COMPRESS(255.0f/408.0f*mat[2]*(float)i)); // R
Vtable[3*i+1]=(unsigned char)XCLAMP(COMPRESS(255.0f/210.0f*mat[5]*(float)i)); // G
Vtable[3*i+2]=(unsigned char)(128.0f-14.0f); // G constant
}
#undef fCOMPRESS
#undef COMPRESS
#undef XCLAMP
int i;
const float mat[9] = { // the modified YUV->RGB matrix
+1.130469478f, -0.058755723f, +1.596026304f,
+1.130469478f, -0.450515935f, -0.812967512f,
+1.130469478f, +1.958477882f, 0.0f
};
#define COMPRESS(a)(0.5f*(a)+128.0f) // counter-piece to EXPAND_NORMAL
#define fCOMPRESS(a) (0.5f*(a)+0.5f);
#define XCLAMP(a) ((a)<0.0f ? 0.0f : ((a)>255.0f ? 255.0f : (a))) // should not be necessary, but what do you know.
bias[0] = fCOMPRESS (-0.842580964f);
bias[1] = fCOMPRESS (+0.563287723f);
bias[2] = fCOMPRESS (-1.0f);
bias[3] = 0.0f;
Uscale[0] = 8.0f / 255.0f;
Uscale[1] = 60.0f / 255.0f;
Uscale[2] = 250.0f / 255.0f;
Uscale[3] = 0.0f;
Vscale[0] = 204.0f / 255.0f;
Vscale[1] = 105.0f / 255.0f;
Vscale[2] = 0.5f;
Vscale[3] = 0.0f;
for (i = 0; i < 256; i++) {
// Y-table holds unsigned values
Ytable[3 * i] = (unsigned char) XCLAMP (mat[0] * (float) i); // R
Ytable[3 * i + 1] = (unsigned char) XCLAMP (mat[3] * (float) i); // G
Ytable[3 * i + 2] = (unsigned char) XCLAMP (mat[6] * (float) i); // B
// U-table holds signed values
Utable[3 * i] = (unsigned char) XCLAMP (COMPRESS (255.0f / 16.0f * mat[1] * (float) i)); // R
Utable[3 * i + 1] = (unsigned char) XCLAMP (COMPRESS (255.0f / 120.0f * mat[4] * (float) i)); // G
Utable[3 * i + 2] = (unsigned char) XCLAMP (COMPRESS (255.0f / 500.0f * mat[7] * (float) i)); // B
// V-table holds signed values
Vtable[3 * i] = (unsigned char) XCLAMP (COMPRESS (255.0f / 408.0f * mat[2] * (float) i)); // R
Vtable[3 * i + 1] = (unsigned char) XCLAMP (COMPRESS (255.0f / 210.0f * mat[5] * (float) i)); // G
Vtable[3 * i + 2] = (unsigned char) (128.0f - 14.0f); // G constant
}
#undef fCOMPRESS
#undef COMPRESS
#undef XCLAMP
}
// Sets the constants. Call once prior to rendering.
void SetConsts(float *bias, float *Uscale, float *Vscale) {
glEnable(GL_REGISTER_COMBINERS_NV);
glColor3fv(bias);
//printf("%f %f %f\n",bias[0],bias[1],bias[2]);
glCombinerParameterfvNV(GL_CONSTANT_COLOR0_NV,Uscale);
glCombinerParameterfvNV(GL_CONSTANT_COLOR1_NV,Vscale);
void
SetConsts (float *bias, float *Uscale, float *Vscale)
{
glEnable (GL_REGISTER_COMBINERS_NV);
glColor3fv (bias);
//printf("%f %f %f\n",bias[0],bias[1],bias[2]);
glCombinerParameterfvNV (GL_CONSTANT_COLOR0_NV, Uscale);
glCombinerParameterfvNV (GL_CONSTANT_COLOR1_NV, Vscale);
}
/*
* SOFTWARE PATH
*/
*/
inline void map_EXPAND_NORMAL(float *v) {
v[0]=2.0f*v[0]-1.0f;
v[1]=2.0f*v[1]-1.0f;
v[2]=2.0f*v[2]-1.0f;
}
inline void map_UNSIGNED_INVERT(float *v) {
v[0]=1.0f-v[0];
v[1]=1.0f-v[1];
v[2]=1.0f-v[2];
}
inline void map_UNSIGNED_IDENTITY(float *v) {
v[0]=(v[0]<0.0f ? 0.0f : v[0]);
v[1]=(v[1]<0.0f ? 0.0f : v[1]);
v[2]=(v[2]<0.0f ? 0.0f : v[2]);
}
inline void map_SIGNED_IDENTITY(float *v) {
}
inline void omap_SCALE_BY_TWO(float *v) {
v[0]*=2.0f;
v[1]*=2.0f;
v[2]*=2.0f;
}
inline void omap_SCALE_BY_ONE_HALF(float *v) {
v[0]*=0.5f;
v[1]*=0.5f;
v[2]*=0.5f;
}
inline void omap_RANGE(float *v) {
v[0]=(v[0]<-1.0f ? -1.0f : (v[0]>1.0f ? 1.0f : v[0]));
v[1]=(v[1]<-1.0f ? -1.0f : (v[1]>1.0f ? 1.0f : v[1]));
v[2]=(v[2]<-1.0f ? -1.0f : (v[2]>1.0f ? 1.0f : v[2]));
}
inline void omap_CLAMP_01(float *v) {
v[0]=(v[0]<0.0f ? 0.0f : (v[0]>1.0f ? 1.0f : v[0]));
v[1]=(v[1]<0.0f ? 0.0f : (v[1]>1.0f ? 1.0f : v[1]));
v[2]=(v[2]<0.0f ? 0.0f : (v[2]>1.0f ? 1.0f : v[2]));
}
void PerformSWCombiner(unsigned char *Result,
unsigned char *tex0,
unsigned char *tex1,
unsigned char *tex2,
float *COLOR0,
float *CONST0,
float *CONST1
)
inline void
map_EXPAND_NORMAL (float *v)
{
float SPARE0[3];
float SPARE1[3];
float A[3],B[3],C[3],D[3];
float TEX0[3],TEX1[3],TEX2[3];
float ZERO[3]={0.0f,0.0f,0.0f};
TEX0[0]=(float)tex0[0]/255.0f;
TEX0[1]=(float)tex0[1]/255.0f;
TEX0[2]=(float)tex0[2]/255.0f;
v[0] = 2.0f * v[0] - 1.0f;
v[1] = 2.0f * v[1] - 1.0f;
v[2] = 2.0f * v[2] - 1.0f;
}
TEX1[0]=(float)tex1[0]/255.0f;
TEX1[1]=(float)tex1[1]/255.0f;
TEX1[2]=(float)tex1[2]/255.0f;
inline void
map_UNSIGNED_INVERT (float *v)
{
v[0] = 1.0f - v[0];
v[1] = 1.0f - v[1];
v[2] = 1.0f - v[2];
}
TEX2[0]=(float)tex2[0]/255.0f;
TEX2[1]=(float)tex2[1]/255.0f;
TEX2[2]=(float)tex2[2]/255.0f;
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]);
}
// Combiner Stage 0:
memcpy(A,TEX0,3*sizeof(float)); map_UNSIGNED_IDENTITY(A);
memcpy(B,ZERO,3*sizeof(float)); map_UNSIGNED_INVERT(B);
memcpy(C,COLOR0,3*sizeof(float)); map_EXPAND_NORMAL(C);
memcpy(D,ZERO,3*sizeof(float)); map_UNSIGNED_INVERT(D);
SPARE0[0]=A[0]*B[0]+C[0]*D[0];
SPARE0[1]=A[1]*B[1]+C[1]*D[1];
SPARE0[2]=A[2]*B[2]+C[2]*D[2];
omap_SCALE_BY_ONE_HALF(SPARE0);
omap_RANGE(SPARE0);
inline void
map_SIGNED_IDENTITY (float *v)
{
}
// Combiner Stage 1:
memcpy(A,TEX1,3*sizeof(float)); map_EXPAND_NORMAL(A);
memcpy(B,CONST0,3*sizeof(float)); map_UNSIGNED_IDENTITY(B);
memcpy(C,TEX2,3*sizeof(float)); map_EXPAND_NORMAL(C);
memcpy(D,CONST1,3*sizeof(float)); map_UNSIGNED_IDENTITY(D);
SPARE1[0]=A[0]*B[0]+C[0]*D[0];
SPARE1[1]=A[1]*B[1]+C[1]*D[1];
SPARE1[2]=A[2]*B[2]+C[2]*D[2];
omap_RANGE(SPARE1);
inline void
omap_SCALE_BY_TWO (float *v)
{
v[0] *= 2.0f;
v[1] *= 2.0f;
v[2] *= 2.0f;
}
// Combiner Stage 2:
memcpy(A,SPARE0,3*sizeof(float)); map_SIGNED_IDENTITY(A);
memcpy(B,ZERO,3*sizeof(float)); map_UNSIGNED_INVERT(B);
memcpy(C,SPARE1,3*sizeof(float)); map_SIGNED_IDENTITY(C);
memcpy(D,ZERO,3*sizeof(float)); map_UNSIGNED_INVERT(D);
SPARE0[0]=A[0]*B[0]+C[0]*D[0];
SPARE0[1]=A[1]*B[1]+C[1]*D[1];
SPARE0[2]=A[2]*B[2]+C[2]*D[2];
omap_SCALE_BY_TWO(SPARE0);
omap_RANGE(SPARE0);
inline void
omap_SCALE_BY_ONE_HALF (float *v)
{
v[0] *= 0.5f;
v[1] *= 0.5f;
v[2] *= 0.5f;
}
// Final Combiner Stage:
memcpy(A,ZERO,3*sizeof(float)); map_UNSIGNED_INVERT(A);
memcpy(B,SPARE0,3*sizeof(float)); map_UNSIGNED_IDENTITY(B);
memcpy(C,ZERO,3*sizeof(float)); map_UNSIGNED_IDENTITY(C);
memcpy(D,ZERO,3*sizeof(float)); map_UNSIGNED_IDENTITY(D);
SPARE0[0]=A[0]*B[0]+(1.0f-A[0])*C[0]+D[0];
SPARE0[1]=A[1]*B[1]+(1.0f-A[1])*C[1]+D[1];
SPARE0[2]=A[2]*B[2]+(1.0f-A[2])*C[2]+D[2];
omap_CLAMP_01(SPARE0);
Result[0]=(unsigned char)(SPARE0[0]*255.0f);
Result[1]=(unsigned char)(SPARE0[1]*255.0f);
Result[2]=(unsigned char)(SPARE0[2]*255.0f);
inline void
omap_RANGE (float *v)
{
v[0] = (v[0] < -1.0f ? -1.0f : (v[0] > 1.0f ? 1.0f : v[0]));
v[1] = (v[1] < -1.0f ? -1.0f : (v[1] > 1.0f ? 1.0f : v[1]));
v[2] = (v[2] < -1.0f ? -1.0f : (v[2] > 1.0f ? 1.0f : v[2]));
}
inline void
omap_CLAMP_01 (float *v)
{
v[0] = (v[0] < 0.0f ? 0.0f : (v[0] > 1.0f ? 1.0f : v[0]));
v[1] = (v[1] < 0.0f ? 0.0f : (v[1] > 1.0f ? 1.0f : v[1]));
v[2] = (v[2] < 0.0f ? 0.0f : (v[2] > 1.0f ? 1.0f : v[2]));
}
void
PerformSWCombiner (unsigned char *Result,
unsigned char *tex0,
unsigned char *tex1,
unsigned char *tex2, float *COLOR0, float *CONST0, float *CONST1)
{
float SPARE0[3];
float SPARE1[3];
float A[3], B[3], C[3], D[3];
float TEX0[3], TEX1[3], TEX2[3];
float ZERO[3] = { 0.0f, 0.0f, 0.0f };
TEX0[0] = (float) tex0[0] / 255.0f;
TEX0[1] = (float) tex0[1] / 255.0f;
TEX0[2] = (float) tex0[2] / 255.0f;
TEX1[0] = (float) tex1[0] / 255.0f;
TEX1[1] = (float) tex1[1] / 255.0f;
TEX1[2] = (float) tex1[2] / 255.0f;
TEX2[0] = (float) tex2[0] / 255.0f;
TEX2[1] = (float) tex2[1] / 255.0f;
TEX2[2] = (float) tex2[2] / 255.0f;
// Combiner Stage 0:
memcpy (A, TEX0, 3 * sizeof (float));
map_UNSIGNED_IDENTITY (A);
memcpy (B, ZERO, 3 * sizeof (float));
map_UNSIGNED_INVERT (B);
memcpy (C, COLOR0, 3 * sizeof (float));
map_EXPAND_NORMAL (C);
memcpy (D, ZERO, 3 * sizeof (float));
map_UNSIGNED_INVERT (D);
SPARE0[0] = A[0] * B[0] + C[0] * D[0];
SPARE0[1] = A[1] * B[1] + C[1] * D[1];
SPARE0[2] = A[2] * B[2] + C[2] * D[2];
omap_SCALE_BY_ONE_HALF (SPARE0);
omap_RANGE (SPARE0);
// Combiner Stage 1:
memcpy (A, TEX1, 3 * sizeof (float));
map_EXPAND_NORMAL (A);
memcpy (B, CONST0, 3 * sizeof (float));
map_UNSIGNED_IDENTITY (B);
memcpy (C, TEX2, 3 * sizeof (float));
map_EXPAND_NORMAL (C);
memcpy (D, CONST1, 3 * sizeof (float));
map_UNSIGNED_IDENTITY (D);
SPARE1[0] = A[0] * B[0] + C[0] * D[0];
SPARE1[1] = A[1] * B[1] + C[1] * D[1];
SPARE1[2] = A[2] * B[2] + C[2] * D[2];
omap_RANGE (SPARE1);
// Combiner Stage 2:
memcpy (A, SPARE0, 3 * sizeof (float));
map_SIGNED_IDENTITY (A);
memcpy (B, ZERO, 3 * sizeof (float));
map_UNSIGNED_INVERT (B);
memcpy (C, SPARE1, 3 * sizeof (float));
map_SIGNED_IDENTITY (C);
memcpy (D, ZERO, 3 * sizeof (float));
map_UNSIGNED_INVERT (D);
SPARE0[0] = A[0] * B[0] + C[0] * D[0];
SPARE0[1] = A[1] * B[1] + C[1] * D[1];
SPARE0[2] = A[2] * B[2] + C[2] * D[2];
omap_SCALE_BY_TWO (SPARE0);
omap_RANGE (SPARE0);
// Final Combiner Stage:
memcpy (A, ZERO, 3 * sizeof (float));
map_UNSIGNED_INVERT (A);
memcpy (B, SPARE0, 3 * sizeof (float));
map_UNSIGNED_IDENTITY (B);
memcpy (C, ZERO, 3 * sizeof (float));
map_UNSIGNED_IDENTITY (C);
memcpy (D, ZERO, 3 * sizeof (float));
map_UNSIGNED_IDENTITY (D);
SPARE0[0] = A[0] * B[0] + (1.0f - A[0]) * C[0] + D[0];
SPARE0[1] = A[1] * B[1] + (1.0f - A[1]) * C[1] + D[1];
SPARE0[2] = A[2] * B[2] + (1.0f - A[2]) * C[2] + D[2];
omap_CLAMP_01 (SPARE0);
Result[0] = (unsigned char) (SPARE0[0] * 255.0f);
Result[1] = (unsigned char) (SPARE0[1] * 255.0f);
Result[2] = (unsigned char) (SPARE0[2] * 255.0f);
}
// Sets up the register combiners. Call once prior to rendering
void SetupCombiners(void)
void
SetupCombiners (void)
{
glCombinerParameteriNV(GL_NUM_GENERAL_COMBINERS_NV,3);
// Combiner Stage 0: th. OK
glCombinerInputNV (GL_COMBINER0_NV,GL_RGB,GL_VARIABLE_A_NV,GL_TEXTURE0_ARB, GL_UNSIGNED_IDENTITY_NV,GL_RGB);
glCombinerInputNV (GL_COMBINER0_NV,GL_RGB,GL_VARIABLE_B_NV,GL_ZERO, GL_UNSIGNED_INVERT_NV, GL_RGB);
glCombinerInputNV (GL_COMBINER0_NV,GL_RGB,GL_VARIABLE_C_NV,GL_PRIMARY_COLOR_NV,GL_EXPAND_NORMAL_NV, GL_RGB);
glCombinerInputNV (GL_COMBINER0_NV,GL_RGB,GL_VARIABLE_D_NV,GL_ZERO, GL_UNSIGNED_INVERT_NV, GL_RGB);
glCombinerOutputNV(GL_COMBINER0_NV,GL_RGB,GL_DISCARD_NV,GL_DISCARD_NV,GL_SPARE0_NV,GL_SCALE_BY_ONE_HALF_NV,GL_NONE,GL_FALSE,GL_FALSE,GL_FALSE);
// Combiner Stage 1: th. OK
glCombinerInputNV (GL_COMBINER1_NV,GL_RGB,GL_VARIABLE_A_NV,GL_TEXTURE1_ARB, GL_EXPAND_NORMAL_NV, GL_RGB);
glCombinerInputNV (GL_COMBINER1_NV,GL_RGB,GL_VARIABLE_B_NV,GL_CONSTANT_COLOR0_NV,GL_UNSIGNED_IDENTITY_NV,GL_RGB);
glCombinerInputNV (GL_COMBINER1_NV,GL_RGB,GL_VARIABLE_C_NV,GL_TEXTURE2_ARB, GL_EXPAND_NORMAL_NV, GL_RGB);
glCombinerInputNV (GL_COMBINER1_NV,GL_RGB,GL_VARIABLE_D_NV,GL_CONSTANT_COLOR1_NV,GL_UNSIGNED_IDENTITY_NV,GL_RGB);
glCombinerOutputNV(GL_COMBINER1_NV,GL_RGB,GL_DISCARD_NV,GL_DISCARD_NV,GL_SPARE1_NV,GL_NONE,GL_NONE,GL_FALSE,GL_FALSE,GL_FALSE);
// Combiner Stage 2: th. OK
glCombinerInputNV (GL_COMBINER2_NV,GL_RGB,GL_VARIABLE_A_NV,GL_SPARE0_NV, GL_SIGNED_IDENTITY_NV, GL_RGB);
glCombinerInputNV (GL_COMBINER2_NV,GL_RGB,GL_VARIABLE_B_NV,GL_ZERO, GL_UNSIGNED_INVERT_NV, GL_RGB);
glCombinerInputNV (GL_COMBINER2_NV,GL_RGB,GL_VARIABLE_C_NV,GL_SPARE1_NV, GL_SIGNED_IDENTITY_NV, GL_RGB);
glCombinerInputNV (GL_COMBINER2_NV,GL_RGB,GL_VARIABLE_D_NV,GL_ZERO, GL_UNSIGNED_INVERT_NV, GL_RGB);
glCombinerOutputNV(GL_COMBINER2_NV,GL_RGB,GL_DISCARD_NV,GL_DISCARD_NV,GL_SPARE0_NV,GL_SCALE_BY_TWO_NV,GL_NONE,GL_FALSE,GL_FALSE,GL_FALSE);
// Final Sage: th. OK
glFinalCombinerInputNV(GL_VARIABLE_A_NV,GL_ZERO, GL_UNSIGNED_INVERT_NV, GL_RGB);
glFinalCombinerInputNV(GL_VARIABLE_B_NV,GL_SPARE0_NV,GL_UNSIGNED_IDENTITY_NV,GL_RGB);
glFinalCombinerInputNV(GL_VARIABLE_C_NV,GL_ZERO, GL_UNSIGNED_IDENTITY_NV,GL_RGB);
glFinalCombinerInputNV(GL_VARIABLE_D_NV,GL_ZERO, GL_UNSIGNED_IDENTITY_NV,GL_RGB);
glFinalCombinerInputNV(GL_VARIABLE_G_NV,GL_ZERO, GL_UNSIGNED_INVERT_NV, GL_ALPHA);
glCombinerParameteriNV (GL_NUM_GENERAL_COMBINERS_NV, 3);
// Combiner Stage 0: th. OK
glCombinerInputNV (GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_A_NV, GL_TEXTURE0_ARB,
GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glCombinerInputNV (GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_B_NV, GL_ZERO,
GL_UNSIGNED_INVERT_NV, GL_RGB);
glCombinerInputNV (GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_C_NV,
GL_PRIMARY_COLOR_NV, GL_EXPAND_NORMAL_NV, GL_RGB);
glCombinerInputNV (GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_D_NV, GL_ZERO,
GL_UNSIGNED_INVERT_NV, GL_RGB);
glCombinerOutputNV (GL_COMBINER0_NV, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV,
GL_SPARE0_NV, GL_SCALE_BY_ONE_HALF_NV, GL_NONE, GL_FALSE, GL_FALSE,
GL_FALSE);
// Combiner Stage 1: th. OK
glCombinerInputNV (GL_COMBINER1_NV, GL_RGB, GL_VARIABLE_A_NV, GL_TEXTURE1_ARB,
GL_EXPAND_NORMAL_NV, GL_RGB);
glCombinerInputNV (GL_COMBINER1_NV, GL_RGB, GL_VARIABLE_B_NV,
GL_CONSTANT_COLOR0_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glCombinerInputNV (GL_COMBINER1_NV, GL_RGB, GL_VARIABLE_C_NV, GL_TEXTURE2_ARB,
GL_EXPAND_NORMAL_NV, GL_RGB);
glCombinerInputNV (GL_COMBINER1_NV, GL_RGB, GL_VARIABLE_D_NV,
GL_CONSTANT_COLOR1_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glCombinerOutputNV (GL_COMBINER1_NV, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV,
GL_SPARE1_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE);
// Combiner Stage 2: th. OK
glCombinerInputNV (GL_COMBINER2_NV, GL_RGB, GL_VARIABLE_A_NV, GL_SPARE0_NV,
GL_SIGNED_IDENTITY_NV, GL_RGB);
glCombinerInputNV (GL_COMBINER2_NV, GL_RGB, GL_VARIABLE_B_NV, GL_ZERO,
GL_UNSIGNED_INVERT_NV, GL_RGB);
glCombinerInputNV (GL_COMBINER2_NV, GL_RGB, GL_VARIABLE_C_NV, GL_SPARE1_NV,
GL_SIGNED_IDENTITY_NV, GL_RGB);
glCombinerInputNV (GL_COMBINER2_NV, GL_RGB, GL_VARIABLE_D_NV, GL_ZERO,
GL_UNSIGNED_INVERT_NV, GL_RGB);
glCombinerOutputNV (GL_COMBINER2_NV, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV,
GL_SPARE0_NV, GL_SCALE_BY_TWO_NV, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE);
// Final Sage: th. OK
glFinalCombinerInputNV (GL_VARIABLE_A_NV, GL_ZERO, GL_UNSIGNED_INVERT_NV,
GL_RGB);
glFinalCombinerInputNV (GL_VARIABLE_B_NV, GL_SPARE0_NV,
GL_UNSIGNED_IDENTITY_NV, GL_RGB);
glFinalCombinerInputNV (GL_VARIABLE_C_NV, GL_ZERO, GL_UNSIGNED_IDENTITY_NV,
GL_RGB);
glFinalCombinerInputNV (GL_VARIABLE_D_NV, GL_ZERO, GL_UNSIGNED_IDENTITY_NV,
GL_RGB);
glFinalCombinerInputNV (GL_VARIABLE_G_NV, GL_ZERO, GL_UNSIGNED_INVERT_NV,
GL_ALPHA);
}
unsigned int PowerOfTwo(unsigned int i) {
unsigned int bitsum=0;
unsigned int shifts=0;
unsigned int j=(unsigned int)i;
// Check wether i is a power of two - may contain at most one set bit
do {
bitsum+=j&1;
j=j>>1;
++shifts;
} while (j>0);
if (bitsum==1) return i;
else return (1<<shifts);
unsigned int
PowerOfTwo (unsigned int i)
{
unsigned int bitsum = 0;
unsigned int shifts = 0;
unsigned int j = (unsigned int) i;
// Check wether i is a power of two - may contain at most one set bit
do {
bitsum += j & 1;
j = j >> 1;
++shifts;
} while (j > 0);
if (bitsum == 1)
return i;
else
return (1 << shifts);
}
// Initializes textures. Call once prior to rendering
void InitYUVPlanes(GLuint *Yhandle, GLuint *Uhandle, GLuint *Vhandle,
unsigned int Ywidth, unsigned int Yheight,
unsigned int UVwidth, unsigned int UVheight,
GLenum filter, // filter should be either GL_NEAREST or GL_LINEAR. Test this!
unsigned char* Ypal, unsigned char *Upal, unsigned char *Vpal)
void
InitYUVPlanes (GLuint * Yhandle, GLuint * Uhandle, GLuint * Vhandle, unsigned int Ywidth, unsigned int Yheight, unsigned int UVwidth, unsigned int UVheight, GLenum filter, // filter should be either GL_NEAREST or GL_LINEAR. Test this!
unsigned char *Ypal, unsigned char *Upal, unsigned char *Vpal)
{
glGenTextures(1,Yhandle);
glGenTextures(1,Uhandle);
glGenTextures(1,Vhandle);
glBindTexture(GL_TEXTURE_2D,(*Yhandle));
glGenTextures (1, Yhandle);
glGenTextures (1, Uhandle);
glGenTextures (1, Vhandle);
glBindTexture (GL_TEXTURE_2D, (*Yhandle));
#ifdef _WIN32
glColorTableEXT(GL_TEXTURE_2D,GL_RGB8,256,GL_RGB,GL_UNSIGNED_BYTE,Ypal);
glColorTableEXT (GL_TEXTURE_2D, GL_RGB8, 256, GL_RGB, GL_UNSIGNED_BYTE, Ypal);
#else // Hopefully Linux
glColorTable(GL_TEXTURE_2D,GL_RGB8,256,GL_RGB,GL_UNSIGNED_BYTE,Ypal);
glColorTable (GL_TEXTURE_2D, GL_RGB8, 256, GL_RGB, GL_UNSIGNED_BYTE, Ypal);
#endif
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,filter);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,filter);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP);
tex_xsize = PowerOfTwo(Ywidth);
tex_ysize = PowerOfTwo(Yheight);
glTexImage2D(GL_TEXTURE_2D,0,GL_COLOR_INDEX8_EXT,PowerOfTwo(Ywidth),PowerOfTwo(Yheight),0,GL_COLOR_INDEX,GL_UNSIGNED_BYTE,NULL);
glBindTexture(GL_TEXTURE_2D,(*Uhandle));
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
tex_xsize = PowerOfTwo (Ywidth);
tex_ysize = PowerOfTwo (Yheight);
glTexImage2D (GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT, PowerOfTwo (Ywidth),
PowerOfTwo (Yheight), 0, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, NULL);
glBindTexture (GL_TEXTURE_2D, (*Uhandle));
#ifdef _WIN32
glColorTableEXT(GL_TEXTURE_2D,GL_RGB8,256,GL_RGB,GL_UNSIGNED_BYTE,Upal);
glColorTableEXT (GL_TEXTURE_2D, GL_RGB8, 256, GL_RGB, GL_UNSIGNED_BYTE, Upal);
#else // Hopefully Linux
glColorTable(GL_TEXTURE_2D,GL_RGB8,256,GL_RGB,GL_UNSIGNED_BYTE,Upal);
glColorTable (GL_TEXTURE_2D, GL_RGB8, 256, GL_RGB, GL_UNSIGNED_BYTE, Upal);
#endif
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,filter);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,filter);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP);
glTexImage2D(GL_TEXTURE_2D,0,GL_COLOR_INDEX8_EXT,PowerOfTwo(UVwidth),PowerOfTwo(UVheight),0,GL_COLOR_INDEX,GL_UNSIGNED_BYTE,NULL);
glBindTexture(GL_TEXTURE_2D,(*Vhandle));
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexImage2D (GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT, PowerOfTwo (UVwidth),
PowerOfTwo (UVheight), 0, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, NULL);
glBindTexture (GL_TEXTURE_2D, (*Vhandle));
#ifdef _WIN32
glColorTableEXT(GL_TEXTURE_2D,GL_RGB8,256,GL_RGB,GL_UNSIGNED_BYTE,Vpal);
glColorTableEXT (GL_TEXTURE_2D, GL_RGB8, 256, GL_RGB, GL_UNSIGNED_BYTE, Vpal);
#else // Hopefully Linux
glColorTable(GL_TEXTURE_2D,GL_RGB8,256,GL_RGB,GL_UNSIGNED_BYTE,Vpal);
glColorTable (GL_TEXTURE_2D, GL_RGB8, 256, GL_RGB, GL_UNSIGNED_BYTE, Vpal);
#endif
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,filter);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,filter);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP);
glTexImage2D(GL_TEXTURE_2D,0,GL_COLOR_INDEX8_EXT,PowerOfTwo(UVwidth),PowerOfTwo(UVheight),0,GL_COLOR_INDEX,GL_UNSIGNED_BYTE,NULL);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexImage2D (GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT, PowerOfTwo (UVwidth),
PowerOfTwo (UVheight), 0, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, NULL);
}
void LoadYUVPlanes(GLuint Yhandle, GLuint Uhandle, GLuint Vhandle,
unsigned int Ywidth, unsigned int Yheight,
unsigned int UVwidth, unsigned int UVheight,
unsigned char *Ydata,
unsigned char *Udata,
unsigned char *Vdata)
void
LoadYUVPlanes (GLuint Yhandle, GLuint Uhandle, GLuint Vhandle,
unsigned int Ywidth, unsigned int Yheight,
unsigned int UVwidth, unsigned int UVheight,
unsigned char *Ydata, unsigned char *Udata, unsigned char *Vdata)
{
glActiveTextureARB(GL_TEXTURE0_ARB);
glBindTexture(GL_TEXTURE_2D,Yhandle);
glTexSubImage2D(GL_TEXTURE_2D,0,0,0,Ywidth,Yheight,GL_COLOR_INDEX,GL_UNSIGNED_BYTE,Ydata);
glEnable(GL_TEXTURE_2D);
glActiveTextureARB(GL_TEXTURE1_ARB);
glBindTexture(GL_TEXTURE_2D,Uhandle);
glTexSubImage2D(GL_TEXTURE_2D,0,0,0,UVwidth,UVheight,GL_COLOR_INDEX,GL_UNSIGNED_BYTE,Udata);
glEnable(GL_TEXTURE_2D);
glActiveTextureARB(GL_TEXTURE2_ARB);
glBindTexture(GL_TEXTURE_2D,Vhandle);
glTexSubImage2D(GL_TEXTURE_2D,0,0,0,UVwidth,UVheight,GL_COLOR_INDEX,GL_UNSIGNED_BYTE,Vdata);
glEnable(GL_TEXTURE_2D);
glActiveTextureARB (GL_TEXTURE0_ARB);
glBindTexture (GL_TEXTURE_2D, Yhandle);
glTexSubImage2D (GL_TEXTURE_2D, 0, 0, 0, Ywidth, Yheight, GL_COLOR_INDEX,
GL_UNSIGNED_BYTE, Ydata);
glEnable (GL_TEXTURE_2D);
glActiveTextureARB (GL_TEXTURE1_ARB);
glBindTexture (GL_TEXTURE_2D, Uhandle);
glTexSubImage2D (GL_TEXTURE_2D, 0, 0, 0, UVwidth, UVheight, GL_COLOR_INDEX,
GL_UNSIGNED_BYTE, Udata);
glEnable (GL_TEXTURE_2D);
glActiveTextureARB (GL_TEXTURE2_ARB);
glBindTexture (GL_TEXTURE_2D, Vhandle);
glTexSubImage2D (GL_TEXTURE_2D, 0, 0, 0, UVwidth, UVheight, GL_COLOR_INDEX,
GL_UNSIGNED_BYTE, Vdata);
glEnable (GL_TEXTURE_2D);
}
void Initialize_Backend(unsigned int Ywidth, unsigned int Yheight, unsigned int UVwidth, unsigned int UVheight, GLenum filter)
void
Initialize_Backend (unsigned int Ywidth, unsigned int Yheight,
unsigned int UVwidth, unsigned int UVheight, GLenum filter)
{
printf("Reinitializing register combiner backend with res %d x %d!\n", Ywidth, Yheight);
printf ("Reinitializing register combiner backend with res %d x %d!\n",
Ywidth, Yheight);
//if (!GL_ARB_multitexture_Init()) exit(0);
//if (!GL_EXT_paletted_texture_Init()) exit(0);
//if (!GL_NV_register_combiners_Init()) exit(0);
@ -339,16 +404,20 @@ void Initialize_Backend(unsigned int Ywidth, unsigned int Yheight, unsigned int
float bias[4];
float Uscale[4];
float Vscale[4];
GenerateRGBTables(Ypal,Upal,Vpal,bias,Uscale,Vscale);
InitYUVPlanes(&Yhandle,&Uhandle,&Vhandle,Ywidth,Yheight,UVwidth,UVheight,filter,Ypal,Upal,Vpal);
SetupCombiners();
SetConsts(bias,Uscale,Vscale);
GenerateRGBTables (Ypal, Upal, Vpal, bias, Uscale, Vscale);
InitYUVPlanes (&Yhandle, &Uhandle, &Vhandle, Ywidth, Yheight, UVwidth,
UVheight, filter, Ypal, Upal, Vpal);
SetupCombiners ();
SetConsts (bias, Uscale, Vscale);
}
void initialize(GLenum filter) {
glShadeModel(GL_SMOOTH);
glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_NICEST);
glClearColor(0.0f,0.0f,0.2f,1.0f);
Initialize_Backend(Ywidth,Yheight,UVwidth,UVheight,filter);
void
initialize (GLenum filter)
{
glShadeModel (GL_SMOOTH);
glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glClearColor (0.0f, 0.0f, 0.2f, 1.0f);
Initialize_Backend (Ywidth, Yheight, UVwidth, UVheight, filter);
}