mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-11-24 10:41:04 +00:00
Code Issues 1 Projects Releases Wiki Activity

[012/906] * sys/glsink/ARB_multitexture.h: Remove old files. * sys/glsink/EXT_paletted_texture.h: * sys/glsink/NV_register_combiners.h: * sys/glsink/gstgl_nvimage.c: * sys/glsink/gstgl_pdrimage.c: * sys/glsink/gstgl_rgbimage.c: * sys/glsink/gstglsink.c: * sys/glsink/gstglsink.h: * sys/glsink/gstglxwindow.c: * sys/glsink/regcomb_yuvrgb.c:

Browse source
This commit is contained in:
David Schleef 2004-08-09 20:16:48 +00:00 committed by Matthew Waters
parent 6d3b83f990
commit 435d10633f
10 changed files with 0 additions and 3462 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

311
gst/gl/ARB_multitexture.h
View file

@ -1,311 +0,0 @@
/*************************************************************
* *
* file : ARB_multitexture.h *
* author: Jens Schneider *
* date : 01.Mar.2001-10.Jul.2001 *
* e-mail: jens@glHint.de *
* *
* version 1.0ß *
* *
*************************************************************/
#ifndef __ARB_MULTITEXTURE_H_
#define __ARB_MULTITEXTURE_H_
/*
* GLOBAL SWITCHES - enable/disable advanced features of this header
*
*/
#define ARB_MULTITEXTURE_INITIALIZE 1 // enable generic init-routines
#ifndef _WIN32
#define GL_GLEXT_PROTOTYPES 1
#endif
#ifdef __cplusplus
extern "C" {
#endif
#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__)
#define WIN32_LEAN_AND_MEAN 1
#include <windows.h>
#endif
#ifndef APIENTRY
#define APIENTRY
#endif
// Header file version number, required by OpenGL ABI for Linux
//#define GL_GLEXT_VERSION 7
/*
* NEW TOKENS TO OPENGL 1.2.1
*
*/
#ifndef GL_ARB_multitexture
#define GL_TEXTURE0_ARB 0x84C0
#define GL_TEXTURE1_ARB 0x84C1
#define GL_TEXTURE2_ARB 0x84C2
#define GL_TEXTURE3_ARB 0x84C3
#define GL_TEXTURE4_ARB 0x84C4
#define GL_TEXTURE5_ARB 0x84C5
#define GL_TEXTURE6_ARB 0x84C6
#define GL_TEXTURE7_ARB 0x84C7
#define GL_TEXTURE8_ARB 0x84C8
#define GL_TEXTURE9_ARB 0x84C9
#define GL_TEXTURE10_ARB 0x84CA
#define GL_TEXTURE11_ARB 0x84CB
#define GL_TEXTURE12_ARB 0x84CC
#define GL_TEXTURE13_ARB 0x84CD
#define GL_TEXTURE14_ARB 0x84CE
#define GL_TEXTURE15_ARB 0x84CF
#define GL_TEXTURE16_ARB 0x84D0
#define GL_TEXTURE17_ARB 0x84D1
#define GL_TEXTURE18_ARB 0x84D2
#define GL_TEXTURE19_ARB 0x84D3
#define GL_TEXTURE20_ARB 0x84D4
#define GL_TEXTURE21_ARB 0x84D5
#define GL_TEXTURE22_ARB 0x84D6
#define GL_TEXTURE23_ARB 0x84D7
#define GL_TEXTURE24_ARB 0x84D8
#define GL_TEXTURE25_ARB 0x84D9
#define GL_TEXTURE26_ARB 0x84DA
#define GL_TEXTURE27_ARB 0x84DB
#define GL_TEXTURE28_ARB 0x84DC
#define GL_TEXTURE29_ARB 0x84DD
#define GL_TEXTURE30_ARB 0x84DE
#define GL_TEXTURE31_ARB 0x84DF
#define GL_ACTIVE_TEXTURE_ARB 0x84E0
#define GL_CLIENT_ACTIVE_TEXTURE_ARB 0x84E1
#define GL_MAX_TEXTURE_UNITS_ARB 0x84E2
#define GL_ARB_multitexture 1
#endif
#ifndef _WIN32
#ifdef GL_GLEXT_PROTOTYPES
extern void APIENTRY glActiveTextureARB (GLenum);
extern void APIENTRY glClientActiveTextureARB (GLenum);
extern void APIENTRY glMultiTexCoord1dARB (GLenum, GLdouble);
extern void APIENTRY glMultiTexCoord1dvARB (GLenum, const GLdouble *);
extern void APIENTRY glMultiTexCoord1fARB (GLenum, GLfloat);
extern void APIENTRY glMultiTexCoord1fvARB (GLenum, const GLfloat *);
extern void APIENTRY glMultiTexCoord1iARB (GLenum, GLint);
extern void APIENTRY glMultiTexCoord1ivARB (GLenum, const GLint *);
extern void APIENTRY glMultiTexCoord1sARB (GLenum, GLshort);
extern void APIENTRY glMultiTexCoord1svARB (GLenum, const GLshort *);
extern void APIENTRY glMultiTexCoord2dARB (GLenum, GLdouble, GLdouble);
extern void APIENTRY glMultiTexCoord2dvARB (GLenum, const GLdouble *);
extern void APIENTRY glMultiTexCoord2fARB (GLenum, GLfloat, GLfloat);
extern void APIENTRY glMultiTexCoord2fvARB (GLenum, const GLfloat *);
extern void APIENTRY glMultiTexCoord2iARB (GLenum, GLint, GLint);
extern void APIENTRY glMultiTexCoord2ivARB (GLenum, const GLint *);
extern void APIENTRY glMultiTexCoord2sARB (GLenum, GLshort, GLshort);
extern void APIENTRY glMultiTexCoord2svARB (GLenum, const GLshort *);
extern void APIENTRY glMultiTexCoord3dARB (GLenum, GLdouble, GLdouble, GLdouble);
extern void APIENTRY glMultiTexCoord3dvARB (GLenum, const GLdouble *);
extern void APIENTRY glMultiTexCoord3fARB (GLenum, GLfloat, GLfloat, GLfloat);
extern void APIENTRY glMultiTexCoord3fvARB (GLenum, const GLfloat *);
extern void APIENTRY glMultiTexCoord3iARB (GLenum, GLint, GLint, GLint);
extern void APIENTRY glMultiTexCoord3ivARB (GLenum, const GLint *);
extern void APIENTRY glMultiTexCoord3sARB (GLenum, GLshort, GLshort, GLshort);
extern void APIENTRY glMultiTexCoord3svARB (GLenum, const GLshort *);
extern void APIENTRY glMultiTexCoord4dARB (GLenum, GLdouble, GLdouble, GLdouble, GLdouble);
extern void APIENTRY glMultiTexCoord4dvARB (GLenum, const GLdouble *);
extern void APIENTRY glMultiTexCoord4fARB (GLenum, GLfloat, GLfloat, GLfloat, GLfloat);
extern void APIENTRY glMultiTexCoord4fvARB (GLenum, const GLfloat *);
extern void APIENTRY glMultiTexCoord4iARB (GLenum, GLint, GLint, GLint, GLint);
extern void APIENTRY glMultiTexCoord4ivARB (GLenum, const GLint *);
extern void APIENTRY glMultiTexCoord4sARB (GLenum, GLshort, GLshort, GLshort, GLshort);
extern void APIENTRY glMultiTexCoord4svARB (GLenum, const GLshort *);
#endif // GL_GLEXT_PROTOTYPES
#else // not _WIN32
typedef void (APIENTRY * PFNGLACTIVETEXTUREARBPROC) (GLenum texture);
typedef void (APIENTRY * PFNGLCLIENTACTIVETEXTUREARBPROC) (GLenum texture);
typedef void (APIENTRY * PFNGLMULTITEXCOORD1DARBPROC) (GLenum target, GLdouble s);
typedef void (APIENTRY * PFNGLMULTITEXCOORD1DVARBPROC) (GLenum target, const GLdouble *v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD1FARBPROC) (GLenum target, GLfloat s);
typedef void (APIENTRY * PFNGLMULTITEXCOORD1FVARBPROC) (GLenum target, const GLfloat *v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD1IARBPROC) (GLenum target, GLint s);
typedef void (APIENTRY * PFNGLMULTITEXCOORD1IVARBPROC) (GLenum target, const GLint *v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD1SARBPROC) (GLenum target, GLshort s);
typedef void (APIENTRY * PFNGLMULTITEXCOORD1SVARBPROC) (GLenum target, const GLshort *v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD2DARBPROC) (GLenum target, GLdouble s, GLdouble t);
typedef void (APIENTRY * PFNGLMULTITEXCOORD2DVARBPROC) (GLenum target, const GLdouble *v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD2FARBPROC) (GLenum target, GLfloat s, GLfloat t);
typedef void (APIENTRY * PFNGLMULTITEXCOORD2FVARBPROC) (GLenum target, const GLfloat *v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD2IARBPROC) (GLenum target, GLint s, GLint t);
typedef void (APIENTRY * PFNGLMULTITEXCOORD2IVARBPROC) (GLenum target, const GLint *v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD2SARBPROC) (GLenum target, GLshort s, GLshort t);
typedef void (APIENTRY * PFNGLMULTITEXCOORD2SVARBPROC) (GLenum target, const GLshort *v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD3DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r);
typedef void (APIENTRY * PFNGLMULTITEXCOORD3DVARBPROC) (GLenum target, const GLdouble *v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD3FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r);
typedef void (APIENTRY * PFNGLMULTITEXCOORD3FVARBPROC) (GLenum target, const GLfloat *v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD3IARBPROC) (GLenum target, GLint s, GLint t, GLint r);
typedef void (APIENTRY * PFNGLMULTITEXCOORD3IVARBPROC) (GLenum target, const GLint *v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD3SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r);
typedef void (APIENTRY * PFNGLMULTITEXCOORD3SVARBPROC) (GLenum target, const GLshort *v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD4DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
typedef void (APIENTRY * PFNGLMULTITEXCOORD4DVARBPROC) (GLenum target, const GLdouble *v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD4FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
typedef void (APIENTRY * PFNGLMULTITEXCOORD4FVARBPROC) (GLenum target, const GLfloat *v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD4IARBPROC) (GLenum target, GLint s, GLint t, GLint r, GLint q);
typedef void (APIENTRY * PFNGLMULTITEXCOORD4IVARBPROC) (GLenum target, const GLint *v);
typedef void (APIENTRY * PFNGLMULTITEXCOORD4SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
typedef void (APIENTRY * PFNGLMULTITEXCOORD4SVARBPROC) (GLenum target, const GLshort *v);
#endif // _WIN32
#ifdef ARB_MULTITEXTURE_INITIALIZE
#include<string.h> // string manipulation for runtime-check
#ifdef _WIN32
PFNGLACTIVETEXTUREARBPROC glActiveTextureARB = NULL;
PFNGLCLIENTACTIVETEXTUREARBPROC glClientActiveTextureARB = NULL;
PFNGLMULTITEXCOORD1DARBPROC glMultiTexCoord1dARB = NULL;
PFNGLMULTITEXCOORD1DVARBPROC glMultiTexCoord1dvARB = NULL;
PFNGLMULTITEXCOORD1FARBPROC glMultiTexCoord1fARB = NULL;
PFNGLMULTITEXCOORD1FVARBPROC glMultiTexCoord1fvARB = NULL;
PFNGLMULTITEXCOORD1IARBPROC glMultiTexCoord1iARB = NULL;
PFNGLMULTITEXCOORD1IVARBPROC glMultiTexCoord1ivARB = NULL;
PFNGLMULTITEXCOORD1SARBPROC glMultiTexCoord1sARB = NULL;
PFNGLMULTITEXCOORD1SVARBPROC glMultiTexCoord1svARB = NULL;
PFNGLMULTITEXCOORD2DARBPROC glMultiTexCoord2dARB = NULL;
PFNGLMULTITEXCOORD2DVARBPROC glMultiTexCoord2dvARB = NULL;
PFNGLMULTITEXCOORD2FARBPROC glMultiTexCoord2fARB = NULL;
PFNGLMULTITEXCOORD2FVARBPROC glMultiTexCoord2fvARB = NULL;
PFNGLMULTITEXCOORD2IARBPROC glMultiTexCoord2iARB = NULL;
PFNGLMULTITEXCOORD2IVARBPROC glMultiTexCoord2ivARB = NULL;
PFNGLMULTITEXCOORD2SARBPROC glMultiTexCoord2sARB = NULL;
PFNGLMULTITEXCOORD2SVARBPROC glMultiTexCoord2svARB = NULL;
PFNGLMULTITEXCOORD3DARBPROC glMultiTexCoord3dARB = NULL;
PFNGLMULTITEXCOORD3DVARBPROC glMultiTexCoord3dvARB = NULL;
PFNGLMULTITEXCOORD3FARBPROC glMultiTexCoord3fARB = NULL;
PFNGLMULTITEXCOORD3FVARBPROC glMultiTexCoord3fvARB = NULL;
PFNGLMULTITEXCOORD3IARBPROC glMultiTexCoord3iARB = NULL;
PFNGLMULTITEXCOORD3IVARBPROC glMultiTexCoord3ivARB = NULL;
PFNGLMULTITEXCOORD3SARBPROC glMultiTexCoord3sARB = NULL;
PFNGLMULTITEXCOORD3SVARBPROC glMultiTexCoord3svARB = NULL;
PFNGLMULTITEXCOORD4DARBPROC glMultiTexCoord4dARB = NULL;
PFNGLMULTITEXCOORD4DVARBPROC glMultiTexCoord4dvARB = NULL;
PFNGLMULTITEXCOORD4FARBPROC glMultiTexCoord4fARB = NULL;
PFNGLMULTITEXCOORD4FVARBPROC glMultiTexCoord4fvARB = NULL;
PFNGLMULTITEXCOORD4IARBPROC glMultiTexCoord4iARB = NULL;
PFNGLMULTITEXCOORD4IVARBPROC glMultiTexCoord4ivARB = NULL;
PFNGLMULTITEXCOORD4SARBPROC glMultiTexCoord4sARB = NULL;
PFNGLMULTITEXCOORD4SVARBPROC glMultiTexCoord4svARB = NULL;
#endif // _WIN32
int CheckForARBMultitextureSupport(void) {
const char search[]="GL_ARB_multitexture";
int i, pos=0;
int maxpos=strlen(search)-1;
char extensions[10000];
printf("Getting GLstring, context is %p\n", glXGetCurrentContext());
strcpy(extensions,(const char *)glGetString(GL_EXTENSIONS));
printf("Examinig GLstring\n");
int len=strlen(extensions);
for ( i=0; i<len; i++) {
if ((i==0) || ((i>1) && extensions[i-1]==' ')) {
pos=0;
while(extensions[i]!=' ') {
if (extensions[i]==search[pos]) pos++;
if ((pos>maxpos) && extensions[i+1]==' ') {
//if (debug)
{
//fprintf(stderr, search);
//fprintf(stderr, " supported.\n");
}
return 1;
}
++i;
}
}
}
//printf(search);
//printf(" not supported.\n");
return 0;
}
int GL_ARB_multitexture_Init(void) {
if (!CheckForARBMultitextureSupport()) return 0;
#ifdef _WIN32
glActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC) wglGetProcAddress("glActiveTextureARB");
if (glActiveTextureARB==NULL) {fprintf(stderr,"glActiveTextureARB not found.\n"); return 0; }
glClientActiveTextureARB = (PFNGLCLIENTACTIVETEXTUREARBPROC) wglGetProcAddress("glClientActiveTextureARB");
if (glClientActiveTextureARB==NULL) {fprintf(stderr,"glClientActiveTextureARB not found.\n"); return 0; }
glMultiTexCoord1dARB = (PFNGLMULTITEXCOORD1DARBPROC) wglGetProcAddress("glMultiTexCoord1dARB");
if (glMultiTexCoord1dARB==NULL) {fprintf(stderr,"glMultiTexCoord1dARB not found.\n"); return 0; }
glMultiTexCoord1dvARB = (PFNGLMULTITEXCOORD1DVARBPROC) wglGetProcAddress("glMultiTexCoord1dvARB");
if (glMultiTexCoord1dvARB==NULL) {fprintf(stderr,"glMultiTexCoord1dAvRB not found.\n"); return 0; }
glMultiTexCoord1fARB = (PFNGLMULTITEXCOORD1FARBPROC) wglGetProcAddress("glMultiTexCoord1fARB");
if (glMultiTexCoord1fARB==NULL) {fprintf(stderr,"glMultiTexCoord1fARB not found.\n"); return 0; }
glMultiTexCoord1fvARB = (PFNGLMULTITEXCOORD1FVARBPROC) wglGetProcAddress("glMultiTexCoord1fvARB");
if (glMultiTexCoord1fvARB==NULL) {fprintf(stderr,"glMultiTexCoord1fvARB not found.\n"); return 0; }
glMultiTexCoord1iARB = (PFNGLMULTITEXCOORD1IARBPROC) wglGetProcAddress("glMultiTexCoord1iARB");
if (glMultiTexCoord1iARB==NULL) {fprintf(stderr,"glMultiTexCoord1iARB not found.\n"); return 0; }
glMultiTexCoord1ivARB = (PFNGLMULTITEXCOORD1IVARBPROC) wglGetProcAddress("glMultiTexCoord1ivARB");
if (glMultiTexCoord1ivARB==NULL) {fprintf(stderr,"glMultiTexCoord1ivARB not found.\n"); return 0; }
glMultiTexCoord1sARB = (PFNGLMULTITEXCOORD1SARBPROC) wglGetProcAddress("glMultiTexCoord1sARB");
if (glMultiTexCoord1sARB==NULL) {fprintf(stderr,"glMultiTexCoord1sARB not found.\n"); return 0; }
glMultiTexCoord1svARB = (PFNGLMULTITEXCOORD1SVARBPROC) wglGetProcAddress("glMultiTexCoord1svARB");
if (glMultiTexCoord1svARB==NULL) {fprintf(stderr,"glMultiTexCoord1svARB not found.\n"); return 0; }
glMultiTexCoord2dARB = (PFNGLMULTITEXCOORD2DARBPROC) wglGetProcAddress("glMultiTexCoord2dARB");
if (glMultiTexCoord2dARB==NULL) {fprintf(stderr,"glMultiTexCoord2dARB not found.\n"); return 0; }
glMultiTexCoord2dvARB = (PFNGLMULTITEXCOORD2DVARBPROC) wglGetProcAddress("glMultiTexCoord2dvARB");
if (glMultiTexCoord2dvARB==NULL) {fprintf(stderr,"glMultiTexCoord2dAvRB not found.\n"); return 0; }
glMultiTexCoord2fARB = (PFNGLMULTITEXCOORD2FARBPROC) wglGetProcAddress("glMultiTexCoord2fARB");
if (glMultiTexCoord2fARB==NULL) {fprintf(stderr,"glMultiTexCoord2fARB not found.\n"); return 0; }
glMultiTexCoord2fvARB = (PFNGLMULTITEXCOORD2FVARBPROC) wglGetProcAddress("glMultiTexCoord2fvARB");
if (glMultiTexCoord2fvARB==NULL) {fprintf(stderr,"glMultiTexCoord2fvARB not found.\n"); return 0; }
glMultiTexCoord2iARB = (PFNGLMULTITEXCOORD2IARBPROC) wglGetProcAddress("glMultiTexCoord2iARB");
if (glMultiTexCoord2iARB==NULL) {fprintf(stderr,"glMultiTexCoord2iARB not found.\n"); return 0; }
glMultiTexCoord2ivARB = (PFNGLMULTITEXCOORD2IVARBPROC) wglGetProcAddress("glMultiTexCoord2ivARB");
if (glMultiTexCoord2ivARB==NULL) {fprintf(stderr,"glMultiTexCoord2ivARB not found.\n"); return 0; }
glMultiTexCoord2sARB = (PFNGLMULTITEXCOORD2SARBPROC) wglGetProcAddress("glMultiTexCoord2sARB");
if (glMultiTexCoord2sARB==NULL) {fprintf(stderr,"glMultiTexCoord2sARB not found.\n"); return 0; }
glMultiTexCoord2svARB = (PFNGLMULTITEXCOORD2SVARBPROC) wglGetProcAddress("glMultiTexCoord2svARB");
if (glMultiTexCoord2svARB==NULL) {fprintf(stderr,"glMultiTexCoord2svARB not found.\n"); return 0; }
glMultiTexCoord3dARB = (PFNGLMULTITEXCOORD3DARBPROC) wglGetProcAddress("glMultiTexCoord3dARB");
if (glMultiTexCoord3dARB==NULL) {fprintf(stderr,"glMultiTexCoord3dARB not found.\n"); return 0; }
glMultiTexCoord3dvARB = (PFNGLMULTITEXCOORD3DVARBPROC) wglGetProcAddress("glMultiTexCoord3dvARB");
if (glMultiTexCoord3dvARB==NULL) {fprintf(stderr,"glMultiTexCoord3dAvRB not found.\n"); return 0; }
glMultiTexCoord3fARB = (PFNGLMULTITEXCOORD3FARBPROC) wglGetProcAddress("glMultiTexCoord3fARB");
if (glMultiTexCoord3fARB==NULL) {fprintf(stderr,"glMultiTexCoord3fARB not found.\n"); return 0; }
glMultiTexCoord3fvARB = (PFNGLMULTITEXCOORD3FVARBPROC) wglGetProcAddress("glMultiTexCoord3fvARB");
if (glMultiTexCoord3fvARB==NULL) {fprintf(stderr,"glMultiTexCoord3fvARB not found.\n"); return 0; }
glMultiTexCoord3iARB = (PFNGLMULTITEXCOORD3IARBPROC) wglGetProcAddress("glMultiTexCoord3iARB");
if (glMultiTexCoord3iARB==NULL) {fprintf(stderr,"glMultiTexCoord3iARB not found.\n"); return 0; }
glMultiTexCoord3ivARB = (PFNGLMULTITEXCOORD3IVARBPROC) wglGetProcAddress("glMultiTexCoord3ivARB");
if (glMultiTexCoord3ivARB==NULL) {fprintf(stderr,"glMultiTexCoord3ivARB not found.\n"); return 0; }
glMultiTexCoord3sARB = (PFNGLMULTITEXCOORD3SARBPROC) wglGetProcAddress("glMultiTexCoord3sARB");
if (glMultiTexCoord3sARB==NULL) {fprintf(stderr,"glMultiTexCoord3sARB not found.\n"); return 0; }
glMultiTexCoord3svARB = (PFNGLMULTITEXCOORD3SVARBPROC) wglGetProcAddress("glMultiTexCoord3svARB");
if (glMultiTexCoord3svARB==NULL) {fprintf(stderr,"glMultiTexCoord3svARB not found.\n"); return 0; }
glMultiTexCoord4dARB = (PFNGLMULTITEXCOORD4DARBPROC) wglGetProcAddress("glMultiTexCoord4dARB");
if (glMultiTexCoord4dARB==NULL) {fprintf(stderr,"glMultiTexCoord4dARB not found.\n"); return 0; }
glMultiTexCoord4dvARB = (PFNGLMULTITEXCOORD4DVARBPROC) wglGetProcAddress("glMultiTexCoord4dvARB");
if (glMultiTexCoord4dvARB==NULL) {fprintf(stderr,"glMultiTexCoord4dAvRB not found.\n"); return 0; }
glMultiTexCoord4fARB = (PFNGLMULTITEXCOORD4FARBPROC) wglGetProcAddress("glMultiTexCoord4fARB");
if (glMultiTexCoord4fARB==NULL) {fprintf(stderr,"glMultiTexCoord4fARB not found.\n"); return 0; }
glMultiTexCoord4fvARB = (PFNGLMULTITEXCOORD4FVARBPROC) wglGetProcAddress("glMultiTexCoord4fvARB");
if (glMultiTexCoord4fvARB==NULL) {fprintf(stderr,"glMultiTexCoord4fvARB not found.\n"); return 0; }
glMultiTexCoord4iARB = (PFNGLMULTITEXCOORD4IARBPROC) wglGetProcAddress("glMultiTexCoord4iARB");
if (glMultiTexCoord4iARB==NULL) {fprintf(stderr,"glMultiTexCoord4iARB not found.\n"); return 0; }
glMultiTexCoord4ivARB = (PFNGLMULTITEXCOORD4IVARBPROC) wglGetProcAddress("glMultiTexCoord4ivARB");
if (glMultiTexCoord4ivARB==NULL) {fprintf(stderr,"glMultiTexCoord4ivARB not found.\n"); return 0; }
glMultiTexCoord4sARB = (PFNGLMULTITEXCOORD4SARBPROC) wglGetProcAddress("glMultiTexCoord4sARB");
if (glMultiTexCoord4sARB==NULL) {fprintf(stderr,"glMultiTexCoord4sARB not found.\n"); return 0; }
glMultiTexCoord4svARB = (PFNGLMULTITEXCOORD4SVARBPROC) wglGetProcAddress("glMultiTexCoord4svARB");
if (glMultiTexCoord4svARB==NULL) {fprintf(stderr,"glMultiTexCoord4svARB not found.\n"); return 0; }
#endif // _WIN32
return 1;
}
#endif // ARB_MULTITEXTURE_INITIALIZE
#ifdef __cplusplus
}
#endif
#endif // not __ARB_MULTITEXTURE_H_

142
gst/gl/EXT_paletted_texture.h
View file

@ -1,142 +0,0 @@
/*************************************************************
* *
* file : EXT_paletted_texture.h *
* author: Jens Schneider *
* date : 14.Mar.2001-10.Jul.2001 *
* e-mail: jens@glHint.de *
* *
* version 1.0ß *
* *
*************************************************************/
#ifndef __EXT_paletted_texture_H_
#define __EXT_paletted_texture_H_
/*
* GLOBAL SWITCHES - enable/disable advanced features of this header
*
*/
#define EXT_PALETTED_TEXTURE_INITIALIZE 1 // enable generic init-routines
#ifndef _WIN32
#define GL_GLEXT_PROTOTYPES 1
#endif
#ifdef __cplusplus
extern "C" {
#endif
#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__)
#define WIN32_LEAN_AND_MEAN 1
#include <windows.h>
#endif
#ifndef APIENTRY
#define APIENTRY
#endif
// Header file version number, required by OpenGL ABI for Linux
//#define GL_GLEXT_VERSION 7
/*
* NEW TOKENS TO OPENGL 1.2.1
*
*/
#ifndef GL_EXT_paletted_texture
#define GL_COLOR_INDEX1_EXT 0x80E2
#define GL_COLOR_INDEX2_EXT 0x80E3
#define GL_COLOR_INDEX4_EXT 0x80E4
#define GL_COLOR_INDEX8_EXT 0x80E5
#define GL_COLOR_INDEX12_EXT 0x80E6
#define GL_COLOR_INDEX16_EXT 0x80E7
#define GL_COLOR_TABLE_FORMAT_EXT 0x80D8
#define GL_COLOR_TABLE_WIDTH_EXT 0x80D9
#define GL_COLOR_TABLE_RED_SIZE_EXT 0x80DA
#define GL_COLOR_TABLE_GREEN_SIZE_EXT 0x80DB
#define GL_COLOR_TABLE_BLUE_SIZE_EXT 0x80DC
#define GL_COLOR_TABLE_ALPHA_SIZE_EXT 0x80DD
#define GL_COLOR_TABLE_LUMINANCE_SIZE_EXT 0x80DE
#define GL_COLOR_TABLE_INTENSITY_SIZE_EXT 0x80DF
#define GL_TEXTURE_INDEX_SIZE_EXT 0x80ED
#define GL_EXT_paletted_texture 1
#endif
#ifndef _WIN32
#ifdef GL_GLEXT_PROTOTYPES
extern void APIENTRY glColorTableEXT (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *);
extern void APIENTRY glColorSubTableEXT(GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
extern void APIENTRY glGetColorTableEXT(GLenum, GLenum, GLenum, GLvoid *);
extern void APIENTRY glGetColorTableParameterivEXT(GLenum, GLenum, GLint *);
extern void APIENTRY glGetColorTableParameterfvEXT(GLenum, GLenum, GLfloat *);
#endif // GL_GLEXT_PROTOTYPES
#else // _WIN32
typedef void (APIENTRY * PFNGLCOLORTABLEEXTPROC) (GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const GLvoid *data);
typedef void (APIENTRY * PFNGLCOLORSUBTABLEEXTPROC)(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data);
typedef void (APIENTRY * PFNGLGETCOLORTABLEEXTPROC)(GLenum target, GLenum format, GLenum type, GLvoid *data);
typedef void (APIENTRY * PFNGLGETCOLORTABLEPARAMETERIVEXTPROC)(GLenum target, GLenum pname, GLint *params);
typedef void (APIENTRY * PFNGLGETCOLORTABLEPARAMETERFVEXTPROC)(GLenum target, GLenum pname, GLfloat *params);
#endif // not _WIN32
#ifdef EXT_PALETTED_TEXTURE_INITIALIZE
#include<string.h> // string manipulation for runtime-check
#ifdef _WIN32
PFNGLCOLORTABLEEXTPROC glColorTableEXT = NULL;
PFNGLCOLORSUBTABLEEXTPROC glColorSubTableEXT = NULL;
PFNGLGETCOLORTABLEEXTPROC glGetColorTableEXT = NULL;
PFNGLGETCOLORTABLEPARAMETERIVEXTPROC glGetColorTableParameterivEXT = NULL;
PFNGLGETCOLORTABLEPARAMETERFVEXTPROC glGetColorTableParameterfvEXT = NULL;
#endif // _WIN32
int CheckForEXTPalettedTextureSupport(void) {
const char search[]="GL_EXT_paletted_texture";
int i, pos=0;
int maxpos=strlen(search)-1;
char extensions[10000];
strcpy(extensions,(const char *)glGetString(GL_EXTENSIONS));
int len=strlen(extensions);
for (i=0; i<len; i++) {
if ((i==0) || ((i>1) && extensions[i-1]==' ')) {
pos=0;
while(extensions[i]!=' ') {
if (extensions[i]==search[pos]) pos++;
if ((pos>maxpos) && extensions[i+1]==' ') {
//printf(search);
//printf(" supported.\n");
return 1;
}
i++;
}
}
}
//printf(search);
//printf(" not supported.\n");
return 0;
}
int GL_EXT_paletted_texture_Init(void) {
if (!CheckForEXTPalettedTextureSupport()) return 0;
#ifdef _WIN32
glColorTableEXT = (PFNGLCOLORTABLEEXTPROC) wglGetProcAddress("glColorTableEXT");
if (glColorTableEXT==NULL) {fprintf(stderr,"glColorTableEXT not found.\n"); return 0;}
glColorSubTableEXT = (PFNGLCOLORSUBTABLEEXTPROC) wglGetProcAddress("glColorSubTableEXT");
if (glColorSubTableEXT==NULL) {fprintf(stderr,"glColorSubTableEXT not found.\n"); return 0;}
glGetColorTableEXT = (PFNGLGETCOLORTABLEEXTPROC) wglGetProcAddress("glGetColorTableEXT");
if (glGetColorTableEXT==NULL) {fprintf(stderr,"glGetColorTableEXT not found.\n"); return 0;}
glGetColorTableParameterivEXT = (PFNGLGETCOLORTABLEPARAMETERIVEXTPROC) wglGetProcAddress("glGetColorTableParameterivEXT");
if (glGetColorTableParameterivEXT==NULL) {fprintf(stderr,"glGetColorTableParameterivEXT not found.\n"); return 0;}
glGetColorTableParameterfvEXT = (PFNGLGETCOLORTABLEPARAMETERFVEXTPROC) wglGetProcAddress("glGetColorTableParameterfvEXT");
if (glGetColorTableParameterfvEXT==NULL) {fprintf(stderr,"glGetColorTableParameterfvEXT not found.\n"); return 0;}
#endif // _WIN32
return 1;
}
#endif // EXT_PALETTED_TEXTURE_INITIALIZE
#ifdef __cplusplus
}
#endif
#endif // not __EXT_PALETTED_TEXTURE_H_

218
gst/gl/NV_register_combiners.h
View file

@ -1,218 +0,0 @@
/*************************************************************
* *
* file : NV_register_combiners.h *
* author: Jens Schneider *
* date : 12.Mar.2001-04.Jul.2001 *
* e-mail: jens@glHint.de *
* *
* version 2.0ß *
* *
*************************************************************/
#ifndef __NV_register_combiners_H_
#define __NV_register_combiners_H_
/*
* GLOBAL SWITCHES - enable/disable advanced features of this header
*
*/
#define NV_REGISTER_COMBINERS_INITIALIZE 1 // enable generic init-routines
#ifndef _WIN32
#define GL_GLEXT_PROTOTYPES 1
#endif
#ifdef __cplusplus
extern "C" {
#endif
#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__)
#define WIN32_LEAN_AND_MEAN 1
#include <windows.h>
#endif
#ifndef APIENTRY
#define APIENTRY
#endif
// Header file version number, required by OpenGL ABI for Linux
//#define GL_GLEXT_VERSION 7
/*
* NEW TOKENS TO OPENGL 1.2.1
*
*/
#ifndef GL_NV_register_combiners
#define GL_REGISTER_COMBINERS_NV 0x8522
#define GL_COMBINER0_NV 0x8550
#define GL_COMBINER1_NV 0x8551
#define GL_COMBINER2_NV 0x8552
#define GL_COMBINER3_NV 0x8553
#define GL_COMBINER4_NV 0x8554
#define GL_COMBINER5_NV 0x8555
#define GL_COMBINER6_NV 0x8556
#define GL_COMBINER7_NV 0x8557
#define GL_VARIABLE_A_NV 0x8523
#define GL_VARIABLE_B_NV 0x8524
#define GL_VARIABLE_C_NV 0x8525
#define GL_VARIABLE_D_NV 0x8526
#define GL_VARIABLE_E_NV 0x8527
#define GL_VARIABLE_F_NV 0x8528
#define GL_VARIABLE_G_NV 0x8529
#define GL_CONSTANT_COLOR0_NV 0x852A
#define GL_CONSTANT_COLOR1_NV 0x852B
#define GL_PRIMARY_COLOR_NV 0x852C
#define GL_SECONDARY_COLOR_NV 0x852D
#define GL_SPARE0_NV 0x852E
#define GL_SPARE1_NV 0x852F
#define GL_UNSIGNED_IDENTITY_NV 0x8536
#define GL_UNSIGNED_INVERT_NV 0x8537
#define GL_EXPAND_NORMAL_NV 0x8538
#define GL_EXPAND_NEGATE_NV 0x8539
#define GL_HALF_BIAS_NORMAL_NV 0x853A
#define GL_HALF_BIAS_NEGATE_NV 0x853B
#define GL_SIGNED_IDENTITY_NV 0x853C
#define GL_SIGNED_NEGATE_NV 0x853D
#define GL_E_TIMES_F_NV 0x8531
#define GL_SPARE0_PLUS_SECONDARY_COLOR_NV 0x8532
#define GL_SCALE_BY_TWO_NV 0x853E
#define GL_SCALE_BY_FOUR_NV 0x853F
#define GL_SCALE_BY_ONE_HALF_NV 0x8540
#define GL_BIAS_BY_NEGATIVE_ONE_HALF_NV 0x8541
#define GL_DISCARD_NV 0x8530
#define GL_COMBINER_INPUT_NV 0x8542
#define GL_COMBINER_MAPPING_NV 0x8543
#define GL_COMBINER_COMPONENT_USAGE_NV 0x8544
#define GL_COMBINER_AB_DOT_PRODUCT_NV 0x8545
#define GL_COMBINER_CD_DOT_PRODUCT_NV 0x8546
#define GL_COMBINER_MUX_SUM_NV 0x8547
#define GL_COMBINER_SCALE_NV 0x8548
#define GL_COMBINER_BIAS_NV 0x8549
#define GL_COMBINER_AB_OUTPUT_NV 0x854A
#define GL_COMBINER_CD_OUTPUT_NV 0x854B
#define GL_COMBINER_SUM_OUTPUT_NV 0x854C
#define GL_NUM_GENERAL_COMBINERS_NV 0x854E
#define GL_COLOR_SUM_CLAMP_NV 0x854F
#define GL_MAX_GENERAL_COMBINERS_NV 0x854D
#define GL_NV_register_combiners 1
#endif
#ifndef _WIN32
#ifdef GL_GLEXT_PROTOTYPES
extern void APIENTRY glCombinerParameterfvNV(GLenum, const GLfloat *);
extern void APIENTRY glCombinerParameterivNV(GLenum, const GLint *);
extern void APIENTRY glCombinerParameterfNV (GLenum, GLfloat);
extern void APIENTRY glCombinerParameteriNV (GLenum, GLint);
extern void APIENTRY glCombinerInputNV (GLenum, GLenum, GLenum, GLenum, GLenum, GLenum);
extern void APIENTRY glCombinerOutputNV (GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLboolean, GLboolean, GLboolean);
extern void APIENTRY glFinalCombinerInputNV (GLenum, GLenum, GLenum, GLenum);
extern void APIENTRY glGetCombinerInputParameterfvNV (GLenum, GLenum, GLenum, GLenum, GLfloat *);
extern void APIENTRY glGetCombinerInputParameterivNV (GLenum, GLenum, GLenum, GLenum, GLint *);
extern void APIENTRY glGetCombinerOutputParameterfvNV(GLenum, GLenum, GLenum, GLfloat *);
extern void APIENTRY glGetCombinerOutputParameterivNV(GLenum, GLenum, GLenum, GLint *);
extern void APIENTRY glGetFinalCombinerInputParameterfvNV(GLenum, GLenum, GLfloat *);
extern void APIENTRY glGetFinalCombinerInputParameterivNV(GLenum, GLenum, GLint *);
#endif // GL_GLEXT_PROTOTYPES
#else // _WIN32
typedef void (APIENTRY * PFNGLCOMBINERPARAMETERFVNVPROC) (GLenum pname, const GLfloat *params);
typedef void (APIENTRY * PFNGLCOMBINERPARAMETERIVNVPROC) (GLenum pname, const GLint *params);
typedef void (APIENTRY * PFNGLCOMBINERPARAMETERFNVPROC) (GLenum pname, GLfloat param);
typedef void (APIENTRY * PFNGLCOMBINERPARAMETERINVPROC) (GLenum pname, GLint param);
typedef void (APIENTRY * PFNGLCOMBINERINPUTNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage);
typedef void (APIENTRY * PFNGLCOMBINEROUTPUTNVPROC) (GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum);
typedef void (APIENTRY * PFNGLFINALCOMBINERINPUTNVPROC) (GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage);
typedef void (APIENTRY * PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat *params);
typedef void (APIENTRY * PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint *params);
typedef void (APIENTRY * PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC)(GLenum stage, GLenum portion, GLenum pname, GLfloat *params);
typedef void (APIENTRY * PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC)(GLenum stage, GLenum portion, GLenum pname, GLint *params);
typedef void (APIENTRY * PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC)(GLenum variable, GLenum pname, GLfloat *params);
typedef void (APIENTRY * PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC)(GLenum variable, GLenum pname, GLint *params);
#endif // not _WIN32
#ifdef NV_REGISTER_COMBINERS_INITIALIZE
#include<string.h> // string manipulation for runtime-check
#ifdef _WIN32
PFNGLCOMBINERPARAMETERFVNVPROC glCombinerParameterfvNV = NULL;
PFNGLCOMBINERPARAMETERIVNVPROC glCombinerParameterivNV = NULL;
PFNGLCOMBINERPARAMETERFNVPROC glCombinerParameterfNV = NULL;
PFNGLCOMBINERPARAMETERINVPROC glCombinerParameteriNV = NULL;
PFNGLCOMBINERINPUTNVPROC glCombinerInputNV = NULL;
PFNGLCOMBINEROUTPUTNVPROC glCombinerOutputNV = NULL;
PFNGLFINALCOMBINERINPUTNVPROC glFinalCombinerInputNV = NULL;
PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC glGetCombinerInputParameterfvNV = NULL;
PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC glGetCombinerInputParameterivNV = NULL;
PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC glGetCombinerOutputParameterfvNV = NULL;
PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC glGetCombinerOutputParameterivNV = NULL;
PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC glGetFinalCombinerInputParameterfvNV = NULL;
PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC glGetFinalCombinerInputParameterivNV = NULL;
#endif // _WIN32
int CheckForNVRegisterCombinersSupport(void) {
const char search[]="GL_NV_register_combiners";
int i, pos=0;
int maxpos=strlen(search)-1;
char extensions[10000];
strcpy(extensions,(const char *)glGetString(GL_EXTENSIONS));
int len=strlen(extensions);
for (i=0; i<len; i++) {
if ((i==0) || ((i>1) && extensions[i-1]==' ')) {
pos=0;
while(extensions[i]!=' ') {
if (extensions[i]==search[pos]) pos++;
if ((pos>maxpos) && extensions[i+1]==' ') {
//printf(search);
// printf(" supported.\n");
return 1;
}
i++;
}
}
}
//printf(search);
//printf(" not supported.\n");
return 0;
}
int GL_NV_register_combiners_Init(void) {
if (!CheckForNVRegisterCombinersSupport()) return 0;
#ifdef _WIN32
glCombinerParameterfvNV=(PFNGLCOMBINERPARAMETERFVNVPROC) wglGetProcAddress("glCombinerParameterfvNV");
if (glCombinerParameterfvNV==NULL) {fprintf(stderr,"glCombinerParameterfvNV not found.\n"); return 0;}
glCombinerParameterivNV=(PFNGLCOMBINERPARAMETERIVNVPROC) wglGetProcAddress("glCombinerParameterivNV");
if (glCombinerParameterivNV==NULL) {fprintf(stderr,"glCombinerParameterivNV not found.\n"); return 0;}
glCombinerParameterfNV=(PFNGLCOMBINERPARAMETERFNVPROC) wglGetProcAddress("glCombinerParameterfNV");
if (glCombinerParameterfvNV==NULL) {fprintf(stderr,"glCombinerParameterfNV not found.\n"); return 0;}
glCombinerParameteriNV=(PFNGLCOMBINERPARAMETERINVPROC) wglGetProcAddress("glCombinerParameteriNV");
if (glCombinerParameterivNV==NULL) {fprintf(stderr,"glCombinerParameteriNV not found.\n"); return 0;}
glCombinerInputNV=(PFNGLCOMBINERINPUTNVPROC) wglGetProcAddress("glCombinerInputNV");
if (glCombinerInputNV==NULL) {fprintf(stderr,"glCombinerInputNV not found.\n"); return 0;}
glCombinerOutputNV=(PFNGLCOMBINEROUTPUTNVPROC) wglGetProcAddress("glCombinerOutputNV");
if (glCombinerOutputNV==NULL) {fprintf(stderr,"glCombinerOutputNV not found.\n"); return 0;}
glFinalCombinerInputNV=(PFNGLFINALCOMBINERINPUTNVPROC) wglGetProcAddress("glFinalCombinerInputNV");
if (glFinalCombinerInputNV==NULL) {fprintf(stderr,"glFinalCombinerInputNV not found.\n"); return 0;}
glGetCombinerInputParameterfvNV=(PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC) wglGetProcAddress("glGetCombinerInputParameterfvNV");
if (glGetCombinerInputParameterfvNV==NULL) {fprintf(stderr,"glGetCombinerInputParameterfvNV not found.\n"); return 0;}
glGetCombinerInputParameterivNV=(PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC) wglGetProcAddress("glGetCombinerInputParameterivNV");
if (glGetCombinerInputParameterivNV==NULL) {fprintf(stderr,"glGetCombinerInputParameterivNV not found.\n"); return 0;}
glGetCombinerOutputParameterfvNV=(PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC) wglGetProcAddress("glGetCombinerOutputParameterfvNV");
if (glGetCombinerOutputParameterfvNV==NULL) {fprintf(stderr,"glGetCombinerOutputParameterfvNV not found.\n"); return 0;}
glGetCombinerOutputParameterivNV=(PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC) wglGetProcAddress("glGetCombinerOutputParameterivNV");
if (glGetCombinerOutputParameterivNV==NULL) {fprintf(stderr,"glGetCombinerOutputParameterivNV not found.\n"); return 0;}
glGetFinalCombinerInputParameterfvNV=(PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC) wglGetProcAddress("glGetFinalCombinerInputParameterfvNV");
if (glGetFinalCombinerInputParameterfvNV==NULL) {fprintf(stderr,"glGetFinalCombinerInputParameterfvNV not found.\n"); return 0;}
glGetFinalCombinerInputParameterivNV=(PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC) wglGetProcAddress("glGetFinalCombinerInputParameterivNV");
if (glGetFinalCombinerInputParameterivNV==NULL) {fprintf(stderr,"glGetFinalCombinerInputParameterivNV not found.\n"); return 0;}
#endif // _WIN32
return 1;
}
#endif // NV_REGISTER_COMBINERS_INITIALIZE
#ifdef __cplusplus
}
#endif
#endif // not __NV_REGISTER_COMBINERS_H_

429
gst/gl/gstgl_nvimage.c
View file

@ -1,429 +0,0 @@
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <gst/gst.h>
/* gcc -ansi -pedantic on GNU/Linux causes warnings and errors
* unless this is defined:
* warning: #warning "Files using this header must be compiled with _SVID_SOURCE or _XOPEN_SOURCE"
*/
#ifndef _XOPEN_SOURCE
# define _XOPEN_SOURCE 1
#endif
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <GL/glx.h>
#include <GL/gl.h>
//#include <GL/glext.h>
#include <GL/glu.h>
#include <string.h>
#include <math.h>
// too lazy to write an API for this ;)
#include "regcomb_yuvrgb.c"
#include "gstglsink.h"
typedef struct _GstGLImageConnection GstGLImageConnection;
struct _GstGLImageConnection
{
GstImageConnection conn;
Display *dpy;
gint w, h;
gint bpp;
int ytex_id;
int uvtex_id;
int septex_id;
unsigned char *m_memory;
int m_bufslots[4];
};
#define TEX_XSIZE 1024
#define TEX_YSIZE 1024
#define YUVTEX_SIZE ((TEX_XSIZE * TEX_YSIZE) * 3 /2)
#define AGP_BUFSLOTS 4
typedef struct _GstNvImage GstNvImage;
struct _GstNvImage
{
GstImageData data;
int slot; // < AGP_BUFSLOTS: allocated from AGP mem, otherwise from CPU mem
GstGLImageConnection *conn;
};
static GstGLImageInfo *gst_gl_nvimage_info (GstImageInfo * info);
static GstGLImageConnection *gst_gl_nvimage_connection (GstImageConnection *
conn);
static gboolean gst_gl_nvimage_check_xvideo ();
static GstCaps *gst_gl_nvimage_get_caps (GstImageInfo * info);
static GstImageConnection *gst_gl_nvimage_set_caps (GstImageInfo * info,
GstCaps * caps);
static GstImageData *gst_gl_nvimage_get_image (GstImageInfo * info,
GstImageConnection * conn);
static void gst_gl_nvimage_put_image (GstImageInfo * info,
GstImageData * image);
static void gst_gl_nvimage_free_image (GstImageData * image);
static void gst_gl_nvimage_open_conn (GstImageConnection * conn,
GstImageInfo * info);
static void gst_gl_nvimage_close_conn (GstImageConnection * conn,
GstImageInfo * info);
static void gst_gl_nvimage_free_conn (GstImageConnection * conn);
GstImagePlugin *
get_gl_nvimage_plugin (void)
{
static GstImagePlugin plugin = { gst_gl_nvimage_get_caps,
gst_gl_nvimage_set_caps,
gst_gl_nvimage_get_image,
gst_gl_nvimage_put_image,
gst_gl_nvimage_free_image
};
return &plugin;
}
static GstGLImageInfo *
gst_gl_nvimage_info (GstImageInfo * info)
{
if (info == NULL || info->id != GST_MAKE_FOURCC ('X', 'l', 'i', 'b')) {
return NULL;
}
return (GstGLImageInfo *) info;
}
static GstGLImageConnection *
gst_gl_nvimage_connection (GstImageConnection * conn)
{
if (conn == NULL || conn->free_conn != gst_gl_nvimage_free_conn)
return NULL;
return (GstGLImageConnection *) conn;
}
gboolean
gst_gl_nvimage_check_xvideo ()
{
//int ver, rel, req, ev, err;
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 (display == NULL)
return FALSE;
if (Success == XvQueryExtension (display, &ver, &rel, &req, &ev, &err))
return TRUE;
#endif
return TRUE;
}
static GstCaps *
gst_gl_nvimage_get_caps (GstImageInfo * info)
{
//gint i;
//int adaptors;
//int formats;
GstCaps *caps = NULL;
GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
g_warning ("nvimage get caps called, 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");
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)
{
//gint i, j = 0;
//int adaptors;
//int formats;
GstGLImageConnection *conn;
GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
guint32 format;
/* we don't handle these image information */
if (xinfo == NULL)
return NULL;
conn = g_new0 (GstGLImageConnection, 1);
conn->conn.open_conn = gst_gl_nvimage_open_conn;
conn->conn.close_conn = gst_gl_nvimage_close_conn;
conn->conn.free_conn = gst_gl_nvimage_free_conn;
gst_caps_get (caps,
"width", &conn->w, "height", &conn->h, "format", &format, NULL);
// maybe I should a bit more checking here, e.g. maximum size smaller than maximum texture extents
if (format != GST_MAKE_FOURCC ('Y', 'V', '1', '2')) {
GST_DEBUG ("GL_NVImage: Format is invalid !\n");
return NULL;
}
if (0) //conn->port == (XvPortID) -1)
{
/* this happens if the plugin can't handle the caps, so no warning */
g_free (conn);
return NULL;
}
GST_DEBUG ("GL_NVImage: caps %p are ok, creating image", caps);
return (GstImageConnection *) conn;
}
static GstImageData *
gst_gl_nvimage_get_image (GstImageInfo * info, GstImageConnection * conn)
{
GstNvImage *image;
GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
GstGLImageConnection *nvconn = gst_gl_nvimage_connection (conn);
/* checks */
if (xinfo == NULL)
return NULL;
if (nvconn == NULL)
return NULL;
// I should also check the current GLX context !
// Ah, Don't have to, I am guarantueed to be in the same thread as put_image
image = g_new0 (GstNvImage, 1);
image->data.size = nvconn->w * nvconn->h * 3 / 2;
//g_warning("Allocating %d bytes from main memory !", image->data.size);
image->data.data = g_malloc (image->data.size);
//image->slot = AGP_BUFSLOTS; // no AGP slot
image->conn = nvconn;
if (image->data.data == NULL) {
g_warning ("GL_NvImage: data allocation failed!");
g_free (image);
return NULL;
}
return (GstImageData *) image;
}
static void
gst_gl_nvimage_put_image (GstImageInfo * info, GstImageData * image)
{
GstNvImage *im = (GstNvImage *) image;
GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
int img_width = im->conn->w;
int img_height = im->conn->h;
int uv_width = img_width >> 1;
int uv_height = img_height >> 1;
unsigned char *buf_y = im->data.data;
unsigned char *buf_v = (buf_y + img_width * img_height);
unsigned char *buf_u = buf_v + ((img_width / 2) * (img_height / 2));
/* checks omitted for speed (and lazyness), do we need them? */
g_assert (xinfo != NULL);
// both upload the video, and redraw the screen
//glClearColor(0,0.5, 0.3,1.0); // a test color
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
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());
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);
if (xinfo->zoom > 2.0)
xinfo->zoomdir = -0.01;
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);
}
LoadYUVPlanes (Yhandle, Uhandle, Vhandle, img_width, img_height, uv_width,
uv_height, buf_y, buf_u, buf_v);
float xmax = (float) (im->conn->w - 1) / tex_xsize;
float ymax = (float) (im->conn->h - 1) / tex_ysize;
/* Upload the texture here */
//g_warning("PUTTING IMAGE %f %f %d %d\n", xmax, ymax, tex_xsize, tex_ysize);
//glColor4f(1,1,1,1); // do NOT set a color here ! Done by Initialize_Backend, or actually SetConst !
glBegin (GL_QUADS);
float aspect = img_width / (float) img_height;
float hor = aspect;
//g_print("Drawing vertices, context is %p\n", glXGetCurrentContext());
glNormal3f (0, -1, 0);
glMultiTexCoord2fARB (GL_TEXTURE0_ARB, 0, 0);
glMultiTexCoord2fARB (GL_TEXTURE1_ARB, 0, 0);
glMultiTexCoord2fARB (GL_TEXTURE2_ARB, 0, 0);
glVertex3f (-hor, 1, 0);
glMultiTexCoord2fARB (GL_TEXTURE0_ARB, 0, ymax);
glMultiTexCoord2fARB (GL_TEXTURE1_ARB, 0, ymax);
glMultiTexCoord2fARB (GL_TEXTURE2_ARB, 0, ymax);
glVertex3f (-hor, -1, 0);
glMultiTexCoord2fARB (GL_TEXTURE0_ARB, xmax, ymax);
glMultiTexCoord2fARB (GL_TEXTURE1_ARB, xmax, ymax);
glMultiTexCoord2fARB (GL_TEXTURE2_ARB, xmax, ymax);
glVertex3f (hor, -1, 0);
glMultiTexCoord2fARB (GL_TEXTURE0_ARB, xmax, 0);
glMultiTexCoord2fARB (GL_TEXTURE1_ARB, xmax, 0);
glMultiTexCoord2fARB (GL_TEXTURE2_ARB, xmax, 0);
glVertex3f (hor, 1, 0);
glEnd ();
if (xinfo->info.dumpvideo) {
static int framenr = 0;
char capfilename[255];
static guint8 *cap_image_data = NULL, *cap_image_data2 = NULL;
int i;
// hmmmm, is this reentrant ?!
if (cap_image_data == NULL)
cap_image_data = (guint8 *) malloc (img_width * img_height * 3);
if (cap_image_data2 == NULL)
cap_image_data2 = (guint8 *) malloc (img_width * img_height * 3);
printf ("Recording frame #%d\n", framenr);
glReadPixels (0, 0, img_width, img_height, GL_RGB, GL_UNSIGNED_BYTE,
cap_image_data);
// invert the pixels
for (i = 0; i < img_height; i++)
memcpy (cap_image_data2 + i * img_width * 3,
cap_image_data + (img_height - 1 - i) * img_width * 3, img_width * 3);
sprintf (capfilename, "cap%04d.ppm", framenr);
FILE *outfile = fopen (capfilename, "wb");
if (outfile != NULL) {
fprintf (outfile, "P6\n");
fprintf (outfile, "# created by glsink from GStreamer\n");
fprintf (outfile, "%d %d\n", img_width, img_height);
fprintf (outfile, "255\n");
fwrite (cap_image_data2, sizeof (char), img_width * img_height * 3,
outfile);
fclose (outfile);
}
framenr++;
}
glXSwapBuffers (xinfo->dpy, xinfo->win);
}
static void
gst_gl_nvimage_free_image (GstImageData * image)
{
GstNvImage *im = (GstNvImage *) image;
g_return_if_fail (im != NULL);
GstGLImageConnection *nvconn = im->conn;
if (im->slot < AGP_BUFSLOTS) {
nvconn->m_bufslots[im->slot] = 0;
} else
g_free (im->data.data);
g_free (im);
}
static void
gst_gl_nvimage_open_conn (GstImageConnection * conn, GstImageInfo * info)
{
//GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
//GstGLImageConnection *xconn = gst_gl_nvimage_connection (conn);
g_print
("Opening NVidia connection; OpenGL on Nvidia, using register combiners.\n");
{
Ywidth = TEX_XSIZE;
Yheight = TEX_YSIZE;
UVwidth = TEX_XSIZE / 2;
UVheight = TEX_YSIZE / 2;
Initialize_Backend (Ywidth, Yheight, UVwidth, UVheight, GL_LINEAR);
}
g_print ("Done\n");
}
static void
gst_gl_nvimage_close_conn (GstImageConnection * conn, GstImageInfo * info)
{
GstGLImageConnection *xconn = gst_gl_nvimage_connection (conn);
//GstGLImageInfo *xinfo = gst_gl_nvimage_info (info);
// anything needed in here ? Oh, maybe drawing de-init, or something
glDeleteTextures (1, &xconn->ytex_id);
glDeleteTextures (1, &xconn->uvtex_id);
glDeleteTextures (1, &xconn->septex_id);
}
static void
gst_gl_nvimage_free_conn (GstImageConnection * conn)
{
GstGLImageConnection *nvconn = gst_gl_nvimage_connection (conn);
g_free (nvconn);
}

405
gst/gl/gstgl_pdrimage.c
View file

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

399
gst/gl/gstgl_rgbimage.c
View file

@ -1,399 +0,0 @@
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <gst/gst.h>
/* gcc -ansi -pedantic on GNU/Linux causes warnings and errors
* unless this is defined:
* warning: #warning "Files using this header must be compiled with _SVID_SOURCE or _XOPEN_SOURCE"
*/
#ifndef _XOPEN_SOURCE
# define _XOPEN_SOURCE 1
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <GL/glx.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <math.h>
#include "gstglsink.h"
typedef struct _GstGLImageConnection GstGLImageConnection;
// this contains everything to draw an image, including all necessary graphics card data.
struct _GstGLImageConnection
{
GstImageConnection conn;
Display *dpy; // the Xlib drawing context
GLXContext ctx; // The GLX drawing context
gint w, h;
gint bpp;
int rgbatex_id;
unsigned char *m_memory;
};
#define TEX_XSIZE 1024
#define TEX_YSIZE 1024
typedef struct _GstGLImage GstGLImage;
struct _GstGLImage
{
GstImageData data;
GstGLImageConnection *conn;
};
static GstGLImageInfo *gst_gl_rgbimage_info (GstImageInfo * info);
static GstGLImageConnection *gst_gl_rgbimage_connection (GstImageConnection *
conn);
static GstCaps *gst_gl_rgbimage_get_caps (GstImageInfo * info);
static GstImageConnection *gst_gl_rgbimage_set_caps (GstImageInfo * info,
GstCaps * caps);
static GstImageData *gst_gl_rgbimage_get_image (GstImageInfo * info,
GstImageConnection * conn);
static void gst_gl_rgbimage_put_image (GstImageInfo * info,
GstImageData * image);
static void gst_gl_rgbimage_free_image (GstImageData * image);
static void gst_gl_rgbimage_open_conn (GstImageConnection * conn,
GstImageInfo * info);
static void gst_gl_rgbimage_close_conn (GstImageConnection * conn,
GstImageInfo * info);
static void gst_gl_rgbimage_free_conn (GstImageConnection * conn);
GstImagePlugin *
get_gl_rgbimage_plugin (void)
{
static GstImagePlugin plugin = { gst_gl_rgbimage_get_caps,
gst_gl_rgbimage_set_caps,
gst_gl_rgbimage_get_image,
gst_gl_rgbimage_put_image,
gst_gl_rgbimage_free_image
};
return &plugin;
}
static GstGLImageInfo *
gst_gl_rgbimage_info (GstImageInfo * info)
{
if (info == NULL || info->id != GST_MAKE_FOURCC ('X', 'l', 'i', 'b')) {
return NULL;
}
return (GstGLImageInfo *) info;
}
static GstGLImageConnection *
gst_gl_rgbimage_connection (GstImageConnection * conn)
{
if (conn == NULL || conn->free_conn != gst_gl_rgbimage_free_conn)
return NULL;
return (GstGLImageConnection *) conn;
}
GstCaps *
gst_gl_rgbimage_get_caps (GstImageInfo * info)
{
GstCaps *caps = NULL;
Visual *visual;
int xpad;
XWindowAttributes attrib;
XImage *ximage;
GstGLImageInfo *xinfo = gst_gl_rgbimage_info (info);
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;
else if (attrib.depth <= 16)
xpad = 16;
else
xpad = 32;
// create a temporary image
ximage = XCreateImage (xinfo->dpy, visual, attrib.depth, ZPixmap, 0, NULL,
100, 100, xpad, (attrib.depth + 7) / 8 * 100);
if (ximage != NULL) {
caps =
GST_CAPS_NEW ("forcing Video RGB", "video/x-raw-rgb", "format",
GST_PROPS_FOURCC (GST_STR_FOURCC ("RGB ")), "depth", GST_PROPS_INT (24),
"bpp", GST_PROPS_INT (24), "red_mask", GST_PROPS_INT (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)
{
g_warning ("in set_caps !\n");
GstGLImageConnection *new = NULL;
Visual *visual;
XWindowAttributes attrib;
GstGLImageInfo *xinfo = gst_gl_rgbimage_info (info);
guint32 format;
gint depth;
gint endianness;
gint red_mask, green_mask, blue_mask;
gint width, height, bpp;
/* check if this is the right image info */
if (xinfo == NULL)
return NULL;
XGetWindowAttributes (xinfo->dpy, xinfo->win, &attrib);
visual = attrib.visual;
gst_caps_get (caps,
"format", &format,
"depth", &depth,
"endianness", &endianness,
"red_mask", &red_mask,
"green_mask", &green_mask,
"blue_mask", &blue_mask,
"width", &width, "height", &height, "bpp", &bpp, NULL);
/* check if the caps are ok */
if (format != GST_MAKE_FOURCC ('R', 'G', 'B', ' '))
return NULL;
/* if (gst_caps_get_int (caps, "bpp") != ???) return NULL; */
//if (depth != attrib.depth) return NULL;
//if (endianness != ((ImageByteOrder (xinfo->dpy) == LSBFirst) ? G_LITTLE_ENDIAN : G_BIG_ENDIAN)) return NULL;
//if (red_mask != visual->red_mask) return NULL;
//if (green_mask != visual->green_mask) return NULL;
//if (blue_mask != visual->blue_mask) return NULL;
GST_DEBUG ("GL_RGBImage: caps %p are ok, creating image", caps);
new = g_new (GstGLImageConnection, 1);
new->conn.open_conn = gst_gl_rgbimage_open_conn;
new->conn.close_conn = gst_gl_rgbimage_close_conn;
new->conn.free_conn = gst_gl_rgbimage_free_conn;
new->dpy = xinfo->dpy;
new->ctx = xinfo->ctx;
new->w = width;
new->h = height;
new->bpp = bpp;
return (GstImageConnection *) new;
}
static GstImageData *
gst_gl_rgbimage_get_image (GstImageInfo * info, GstImageConnection * conn)
{
GstGLImage *image;
//XWindowAttributes attrib;
GstGLImageInfo *xinfo = gst_gl_rgbimage_info (info);
GstGLImageConnection *xconn = gst_gl_rgbimage_connection (conn);
image = g_new (GstGLImage, 1);
/* checks */
if (xinfo == NULL)
return NULL;
if (xconn == NULL)
return NULL;
if (xinfo->dpy != xconn->dpy) {
g_warning ("XImage: wrong x display specified in 'get_image'\n");
return NULL;
}
image->conn = xconn;
image->data.size = xconn->w * xconn->h * 4;
image->data.data = g_malloc (image->data.size);
if (image->data.data == NULL) {
g_warning ("GL_RGBImage: data allocation failed!");
g_free (image);
return NULL;
}
return (GstImageData *) image;
}
static void
gst_gl_rgbimage_put_image (GstImageInfo * info, GstImageData * image)
{
float xmax, ymax;
GstGLImageInfo *xinfo = gst_gl_rgbimage_info (info);
GstGLImage *im = (GstGLImage *) image;
int img_width = im->conn->w;
int img_height = im->conn->h;
g_assert (xinfo != NULL);
// both upload the video, and redraw the screen
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode (GL_MODELVIEW);
glLoadIdentity ();
glTranslatef (0.0, 0.0, -5.0);
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);
xinfo->rotX += 0.01;
xinfo->rotY -= 0.015;
float zoom = xinfo->zoom;
glScalef (zoom, zoom, zoom);
if (xinfo->zoom > 2.0)
xinfo->zoomdir = -0.01;
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;
float aspect = img_width / (float) img_height;
float hor = aspect;
glColor4f (1, 1, 1, 1);
glBegin (GL_QUADS);
glNormal3f (0, -1, 0);
glTexCoord2f (xmax, 0);
glVertex3f (hor, 1, 0);
glTexCoord2f (0, 0);
glVertex3f (-hor, 1, 0);
glTexCoord2f (0, ymax);
glVertex3f (-hor, -1, 0);
glTexCoord2f (xmax, ymax);
glVertex3f (hor, -1, 0);
glEnd ();
if (xinfo->info.dumpvideo) {
static int framenr = 0;
char capfilename[255];
static guint8 *cap_image_data = NULL, *cap_image_data2 = NULL;
int i;
// hmmmm, is this reentrant ?!
if (cap_image_data == NULL)
cap_image_data = (guint8 *) malloc (img_width * img_height * 3);
if (cap_image_data2 == NULL)
cap_image_data2 = (guint8 *) malloc (img_width * img_height * 3);
printf ("Recording frame #%d\n", framenr);
glReadPixels (0, 0, img_width, img_height, GL_RGB, GL_UNSIGNED_BYTE,
cap_image_data);
// invert the pixels
for (i = 0; i < img_height; i++)
memcpy (cap_image_data2 + i * img_width * 3,
cap_image_data + (img_height - 1 - i) * img_width * 3, img_width * 3);
sprintf (capfilename, "cap%04d.ppm", framenr);
FILE *outfile = fopen (capfilename, "wb");
if (outfile != NULL) {
fprintf (outfile, "P6\n");
fprintf (outfile, "# created by raw_zb\n");
fprintf (outfile, "%d %d\n", img_width, img_height);
fprintf (outfile, "255\n");
fwrite (cap_image_data2, sizeof (char), img_width * img_height * 3,
outfile);
fclose (outfile);
}
framenr++;
}
glXSwapBuffers (xinfo->dpy, xinfo->win);
}
void
gst_gl_rgbimage_free_image (GstImageData * image)
{
GstGLImage *im = (GstGLImage *) image;
g_warning
("gst_gl_rgbimage_free_image doesn't do anything yet -> freeing image\n");
g_free (im->data.data);
g_free (im);
}
/* Creates an OpenGL texture to upload the picture over */
static void
gst_gl_rgbimage_open_conn (GstImageConnection * conn, GstImageInfo * info)
{
g_warning ("Opening RGB Connection; classic OpenGL 1.2 renderer.");
//GstGLImageInfo *xinfo = gst_gl_rgbimage_info (info);
GstGLImageConnection *xconn = gst_gl_rgbimage_connection (conn);
glGenTextures (1, &xconn->rgbatex_id);
glBindTexture (GL_TEXTURE_2D, xconn->rgbatex_id);
glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, TEX_XSIZE, TEX_YSIZE, 0, GL_RGBA,
GL_UNSIGNED_BYTE, NULL);
}
/* Deletes the creates OpenGL textures */
static void
gst_gl_rgbimage_close_conn (GstImageConnection * conn, GstImageInfo * info)
{
GstGLImageConnection *xconn = gst_gl_rgbimage_connection (conn);
//GstGLImageInfo *xinfo = gst_gl_rgbimage_info (info);
glDeleteTextures (1, &xconn->rgbatex_id);
}
static void
gst_gl_rgbimage_free_conn (GstImageConnection * conn)
{
GstGLImageConnection *xconn = gst_gl_rgbimage_connection (conn);
g_assert (xconn != NULL);
g_free (xconn);
}

773
gst/gl/gstglsink.c
View file

@ -1,773 +0,0 @@
/* GStreamer
* Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
/*
<ds-work> your element belongs to a scheduler, which calls some functions from the same thread
<ds-work> all the other functions could be called from any random thread
<gernot> ds-work: which are the "some" function in that case ?
<gernot> It is quite costly to do glXGetCurrentContext for every function call.
<ds-work> _chain, -get, _loop
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <string.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <GL/glx.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <sys/time.h>
/*#define GST_DEBUG_FORCE_DISABLE*/
#include "gstglsink.h"
/* elementfactory information */
static GstElementDetails gst_glsink_details = {
"OpenGL Sink/GLX",
"Sink/GLVideo",
"An OpenGL based video sink - uses OpenGL and GLX to draw video, utilizing different acceleration options",
"Gernot Ziegler <gz@lysator.liu.se>"
};
/* 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))
)
/* glsink signals and args */
enum
{
LAST_SIGNAL
};
enum
{
ARG_0,
ARG_WIDTH,
ARG_HEIGHT,
ARG_FRAMES_DISPLAYED,
ARG_FRAME_TIME,
ARG_HOOK,
ARG_MUTE,
ARG_REPAINT,
ARG_DEMO,
ARG_DUMP
};
/* GLsink class */
#define GST_TYPE_GLSINK (gst_glsink_get_type())
#define GST_GLSINK(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GST_TYPE_GLSINK,GstGLSink))
#define GST_GLSINK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_GLSINK,GstGLSink))
#define GST_IS_GLSINK(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), GST_TYPE_GLSINK))
#define GST_IS_GLSINK_CLASS(obj) (G_TYPE_CHECK_CLASS_TYPE((klass), GST_TYPE_GLSINK))
typedef struct _GstGLSink GstGLSink;
typedef struct _GstGLSinkClass GstGLSinkClass;
struct _GstGLSink
{
GstElement element;
GstPad *sinkpad;
gint frames_displayed;
guint64 frame_time;
gint width, height;
gboolean muted;
gint demo; // some kind of fun demo mode to let GL show its 3D capabilities
gboolean dumpvideo; // dump the video down to .ppm:s
GstBuffer *last_image; /* not thread safe ? */
GstClock *clock;
GMutex *cache_lock;
GList *cache;
/* plugins */
GstImagePlugin *plugin;
GstImageConnection *conn;
/* allow anybody to hook in here */
GstImageInfo *hook;
};
struct _GstGLSinkClass
{
GstElementClass parent_class;
/* plugins */
GList *plugins;
};
static GType gst_glsink_get_type (void);
static void gst_glsink_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_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);
/* prototypes from plugins */
extern GstImagePlugin *get_gl_rgbimage_plugin (void);
extern GstImagePlugin *get_gl_nvimage_plugin (void);
/* default output */
extern void gst_glxwindow_new (GstGLSink * sink);
extern void gst_glxwindow_hook_context (GstImageInfo * info);
extern void gst_glxwindow_unhook_context (GstImageInfo * info);
static GstPadTemplate *sink_template;
static GstElementClass *parent_class = NULL;
/* static guint gst_glsink_signals[LAST_SIGNAL] = { 0 }; */
static GType gst_glsink_get_type (void)
{
static GType videosink_type = 0;
if (!videosink_type) {
static const GTypeInfo videosink_info = {
sizeof (GstGLSinkClass),
gst_glsink_base_init,
NULL,
(GClassInitFunc) gst_glsink_class_init,
NULL,
NULL,
sizeof (GstGLSink),
0,
(GInstanceInitFunc) gst_glsink_init,
};
videosink_type =
g_type_register_static (GST_TYPE_ELEMENT, "GstGLSink", &videosink_info,
0);
}
return videosink_type;
}
static void
gst_glsink_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));
}
static void
gst_glsink_class_init (GstGLSinkClass * klass)
{
GObjectClass *gobject_class;
GstElementClass *gstelement_class;
gobject_class = (GObjectClass *) klass;
gstelement_class = (GstElementClass *) klass;
parent_class = g_type_class_ref (GST_TYPE_ELEMENT);
g_object_class_install_property (gobject_class, ARG_WIDTH, g_param_spec_int ("width", "Width", "The video width", G_MININT, G_MAXINT, 0, G_PARAM_READABLE)); /* CHECKME */
g_object_class_install_property (gobject_class, ARG_HEIGHT, g_param_spec_int ("height", "Height", "The video height", G_MININT, G_MAXINT, 0, G_PARAM_READABLE)); /* CHECKME */
g_object_class_install_property (gobject_class, ARG_FRAMES_DISPLAYED, g_param_spec_int ("frames_displayed", "Frames Displayed", "The number of frames displayed so far", G_MININT, G_MAXINT, 0, G_PARAM_READWRITE)); /* CHECKME */
g_object_class_install_property (gobject_class, ARG_FRAME_TIME, g_param_spec_int ("frame_time", "Frame time", "The interval between frames", G_MININT, G_MAXINT, 0, G_PARAM_READWRITE)); /* CHECKME */
g_object_class_install_property (gobject_class, ARG_HOOK,
g_param_spec_pointer ("hook", "Hook", "The object receiving the output",
G_PARAM_WRITABLE));
g_object_class_install_property (gobject_class, ARG_MUTE,
g_param_spec_boolean ("mute", "Mute", "mute the output ?", FALSE,
G_PARAM_READWRITE));
g_object_class_install_property (gobject_class, ARG_REPAINT,
g_param_spec_boolean ("repaint", "Repaint", "repaint the current frame",
FALSE, G_PARAM_WRITABLE));
g_object_class_install_property (gobject_class, ARG_DEMO,
g_param_spec_int ("demo", "Demo", "demo mode (shows 3D capabilities)", 0,
1, 0, G_PARAM_READWRITE));
g_object_class_install_property (gobject_class, ARG_DUMP,
g_param_spec_boolean ("dump", "Dump",
"stores sequence of frames in .ppm files", FALSE, G_PARAM_READWRITE));
gobject_class->set_property = gst_glsink_set_property;
gobject_class->get_property = gst_glsink_get_property;
/*gobject_class->dispose = gst_glsink_dispose; */
gstelement_class->change_state = gst_glsink_change_state;
gstelement_class->set_clock = gst_glsink_set_clock;
/* plugins */
klass->plugins = NULL;
klass->plugins = g_list_append (klass->plugins, get_gl_rgbimage_plugin ());
klass->plugins = g_list_append (klass->plugins, get_gl_nvimage_plugin ());
}
/*
GLSink has its own Buffer management - this allows special plugins to create special memory areas for
buffer upload
*/
static void
gst_glsink_init (GstGLSink * sink)
{
sink->sinkpad = gst_pad_new_from_template (sink_template, "sink");
gst_element_add_pad (GST_ELEMENT (sink), sink->sinkpad);
gst_pad_set_chain_function (sink->sinkpad, gst_glsink_chain);
gst_pad_set_link_function (sink->sinkpad, gst_glsink_sinkconnect);
gst_pad_set_getcaps_function (sink->sinkpad, gst_glsink_getcaps);
gst_pad_set_bufferpool_function (sink->sinkpad, gst_glsink_get_bufferpool);
sink->last_image = NULL;
sink->width = 0;
sink->height = 0;
sink->muted = FALSE;
sink->clock = NULL;
GST_FLAG_SET (sink, GST_ELEMENT_THREAD_SUGGESTED);
GST_FLAG_SET (sink, GST_ELEMENT_EVENT_AWARE);
/* create bufferpool and image cache */
GST_DEBUG ("glsink: creating bufferpool");
sink->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);
//printf("GLSink_init: Current context %p\n", glXGetCurrentContext());
gst_glxwindow_unhook_context (sink->hook);
}
/** frees the temporary connection that tests the window system capabilities */
static void
gst_glsink_release_conn (GstGLSink * sink)
{
if (sink->conn == NULL)
return;
/* free last image if any */
if (sink->last_image != NULL) {
gst_buffer_unref (sink->last_image);
sink->last_image = NULL;
}
/* free cache */
g_mutex_lock (sink->cache_lock);
while (sink->cache) {
sink->plugin->free_image ((GstImageData *) sink->cache->data);
sink->cache = g_list_delete_link (sink->cache, sink->cache);
}
g_mutex_unlock (sink->cache_lock);
/* release connection */
sink->conn->free_conn (sink->conn);
sink->conn = NULL;
}
static void
gst_glsink_append_cache (GstGLSink * sink, GstImageData * image)
{
g_mutex_lock (sink->cache_lock);
sink->cache = g_list_prepend (sink->cache, image);
g_mutex_unlock (sink->cache_lock);
}
#if 0
/*
Create a new buffer to hand up the chain.
This allows the plugins to make its own decoding buffers
*/
static GstBuffer *
gst_glsink_buffer_new (GstBufferPool * pool, gint64 location,
guint size, gpointer user_data)
{
GstGLSink *sink;
GstBuffer *buffer;
GstImageData *image;
sink = GST_GLSINK (user_data);
/* If cache is non-empty, get buffer from there */
if (sink->cache != NULL) {
g_mutex_lock (sink->cache_lock);
image = (GstImageData *) sink->cache->data;
sink->cache = g_list_delete_link (sink->cache, sink->cache);
g_mutex_unlock (sink->cache_lock);
} else {
/* otherwise, get one from the plugin */
image = sink->plugin->get_image (sink->hook, sink->conn);
}
buffer = gst_buffer_new ();
GST_BUFFER_DATA (buffer) = image->data;
GST_BUFFER_SIZE (buffer) = image->size;
GST_BUFFER_POOL_PRIVATE (buffer) = image;
return buffer;
}
/*
Free a buffer that the chain doesn't need anymore.
*/
static void
gst_glsink_buffer_free (GstBufferPool * pool, GstBuffer * buffer,
gpointer user_data)
{
GstGLSink *sink =
GST_GLSINK (gst_buffer_pool_get_user_data (GST_BUFFER_BUFFERPOOL
(buffer)));
gst_glsink_append_cache (sink,
(GstImageData *) GST_BUFFER_POOL_PRIVATE (buffer));
/* set to NULL so the data is not freed */
GST_BUFFER_DATA (buffer) = NULL;
gst_buffer_default_free (buffer);
}
#endif
/*
Set the caps that the application desires.
Go through the plugin list, finding the plugin that first fits the given parameters
*/
static gboolean
gst_glsink_set_caps (GstGLSink * sink, GstCaps * caps)
{
g_warning ("in 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 ());
GstImagePlugin *plugin = (GstImagePlugin *) list->data;
if ((conn = plugin->set_caps (sink->hook, caps)) != NULL) {
//gst_glsink_release_conn (sink);
printf ("BGetting GLstring, context is %p\n", glXGetCurrentContext ());
sink->conn = conn;
printf ("CGetting GLstring, context is %p\n", glXGetCurrentContext ());
sink->plugin = plugin;
sink->conn->open_conn (sink->conn, sink->hook);
return TRUE;
}
list = g_list_next (list);
}
return FALSE;
}
/**
Link the input video sink internally.
*/
static GstPadLinkReturn
gst_glsink_sinkconnect (GstPad * pad, GstCaps * caps)
{
g_warning ("in glsink sinkconnect!\n");
GstGLSink *sink;
guint32 fourcc, print_format, result;
sink = GST_GLSINK (gst_pad_get_parent (pad));
/* we are not going to act on variable caps */
if (!GST_CAPS_IS_FIXED (caps))
return GST_PAD_LINK_DELAYED;
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);
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);
/* emit signal */
g_object_freeze_notify (G_OBJECT (sink));
g_object_notify (G_OBJECT (sink), "width");
g_object_notify (G_OBJECT (sink), "height");
g_object_thaw_notify (G_OBJECT (sink));
return GST_PAD_LINK_OK;
}
static GstCaps *
gst_glsink_getcaps (GstPad * pad, GstCaps * caps)
{
g_warning ("in 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));
list = g_list_next (list);
}
gst_glxwindow_unhook_context (sink->hook);
return ret;
}
static void
gst_glsink_set_clock (GstElement * element, GstClock * clock)
{
GstGLSink *sink = GST_GLSINK (element);
sink->clock = clock;
}
static void
gst_glsink_chain (GstPad * pad, GstData * _data)
{
//g_warning("in glsink_chain!\n");
GstBuffer *buf = GST_BUFFER (_data);
GstGLSink *sink;
GstBuffer *buffer;
g_return_if_fail (pad != NULL);
g_return_if_fail (GST_IS_PAD (pad));
g_return_if_fail (buf != NULL);
sink = GST_GLSINK (gst_pad_get_parent (pad));
if (GST_IS_EVENT (buf)) {
GstEvent *event = GST_EVENT (buf);
switch (GST_EVENT_TYPE (event)) {
default:
gst_pad_event_default (pad, event);
}
return;
}
GST_DEBUG ("glsink: clock wait: %llu %u",
GST_BUFFER_TIMESTAMP (buf), GST_BUFFER_SIZE (buf));
#if 0
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
GstClockReturn ret;
GstClockID id =
gst_clock_new_single_shot_id (sink->clock, GST_BUFFER_TIMESTAMP (buf));
ret = gst_element_clock_wait (GST_ELEMENT (sink), id, NULL);
gst_clock_id_free (id);
/* we are going to drop early buffers */
if (ret == GST_CLOCK_EARLY) {
gst_buffer_unref (buf);
return;
}
}
#endif
/* call the notify _before_ displaying so the handlers can react */
sink->frames_displayed++;
g_object_notify (G_OBJECT (sink), "frames_displayed");
if (!sink->muted) {
if (glXGetCurrentContext () == NULL) {
printf ("Rehooking window !\n");
gst_glxwindow_hook_context (sink->hook);
#if 1
GST_DEBUG ("Initializing OpenGL parameters\n");
/* initialize OpenGL drawing */
glEnable (GL_DEPTH_TEST);
glEnable (GL_TEXTURE_2D);
glClearDepth (1.0f);
glClearColor (0, 0, 0, 0);
glEnable (GL_AUTO_NORMAL); // let OpenGL generate the Normals
glDisable (GL_BLEND);
glDisable (GL_CULL_FACE);
glPolygonMode (GL_FRONT, GL_FILL);
glPolygonMode (GL_BACK, GL_FILL);
glShadeModel (GL_SMOOTH);
glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
GstGLImageInfo *window = (GstGLImageInfo *) sink->hook;
int w = window->width, h = window->height;
glViewport (0, 0, (GLint) w, (GLint) h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
GLfloat aspect = (GLfloat) w / (GLfloat) h;
glFrustum (-aspect, aspect, -1.0, 1.0, 5.0, 500.0);
#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);
#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->last_image = buf;
} else {
buffer =
gst_buffer_new_from_pool (gst_glsink_get_bufferpool (sink->sinkpad),
0, GST_BUFFER_SIZE (buf));
memcpy (GST_BUFFER_DATA (buffer), GST_BUFFER_DATA (buf),
GST_BUFFER_SIZE (buf) >
GST_BUFFER_SIZE (buffer) ? GST_BUFFER_SIZE (buffer) :
GST_BUFFER_SIZE (buf));
sink->plugin->put_image (sink->hook,
(GstImageData *) GST_BUFFER_POOL_PRIVATE (buffer));
sink->last_image = buffer;
gst_buffer_unref (buf);
}
//gst_glxwindow_unhook_context(sink->hook);
}
}
static void
gst_glsink_set_property (GObject * object, guint prop_id, const GValue * value,
GParamSpec * pspec)
{
//g_warning("in set_property!\n");
GstGLSink *sink;
/* it's not null if we got it, but it might not be ours */
g_return_if_fail (GST_IS_GLSINK (object));
sink = GST_GLSINK (object);
switch (prop_id) {
case ARG_FRAMES_DISPLAYED:
sink->frames_displayed = g_value_get_int (value);
g_object_notify (object, "frames_displayed");
break;
case ARG_FRAME_TIME:
sink->frame_time = g_value_get_int (value);
break;
case ARG_HOOK:
if (sink->hook) {
sink->hook->free_info (sink->hook);
}
sink->hook = g_value_get_pointer (value);
break;
case ARG_MUTE:
sink->muted = g_value_get_boolean (value);
g_object_notify (object, "mute");
break;
case ARG_DEMO:
sink->demo = g_value_get_int (value);
g_object_notify (object, "demo");
break;
case ARG_DUMP:
sink->dumpvideo = g_value_get_boolean (value);
g_object_notify (object, "dump");
break;
case ARG_REPAINT:
if (sink->last_image != NULL) {
sink->plugin->put_image (sink->hook,
(GstImageData *) GST_BUFFER_POOL_PRIVATE (sink->last_image));
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_glsink_get_property (GObject * object, guint prop_id, GValue * value,
GParamSpec * pspec)
{
//g_warning("in get_property!\n");
GstGLSink *sink;
/* it's not null if we got it, but it might not be ours */
sink = GST_GLSINK (object);
switch (prop_id) {
case ARG_WIDTH:
g_value_set_int (value, sink->width);
break;
case ARG_HEIGHT:
g_value_set_int (value, sink->height);
break;
case ARG_FRAMES_DISPLAYED:
g_value_set_int (value, sink->frames_displayed);
break;
case ARG_FRAME_TIME:
g_value_set_int (value, sink->frame_time / 1000000);
break;
case ARG_MUTE:
g_value_set_boolean (value, sink->muted);
break;
case ARG_DEMO:
g_value_set_int (value, sink->demo);
break;
case ARG_DUMP:
g_value_set_boolean (value, sink->dumpvideo);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static GstElementStateReturn
gst_glsink_change_state (GstElement * element)
{
//g_warning("in change_state!\n");
GstGLSink *sink;
sink = GST_GLSINK (element);
switch (GST_STATE_TRANSITION (element)) {
case GST_STATE_NULL_TO_READY:
break;
case GST_STATE_READY_TO_PAUSED:
{
//g_warning("Going GST_STATE_READY_TO_PAUSED: %p", sink->conn);
}
break;
case GST_STATE_PAUSED_TO_PLAYING:
{
//g_warning("Going GST_STATE_PAUSED_TO_PLAYING: %p", sink->conn);
}
break;
case GST_STATE_PLAYING_TO_PAUSED:
break;
case GST_STATE_PAUSED_TO_READY:
if (sink->conn)
sink->conn->close_conn (sink->conn, sink->hook);
if (sink->last_image) {
gst_buffer_unref (sink->last_image);
sink->last_image = NULL;
}
break;
case GST_STATE_READY_TO_NULL:
gst_glsink_release_conn (sink);
break;
}
parent_class->change_state (element);
return GST_STATE_SUCCESS;
}
static gboolean
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);
if (!gst_element_register (plugin, "glsink", GST_RANK_NONE, GST_TYPE_GLSINK))
return FALSE;
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);

96
gst/gl/gstglsink.h
View file

@ -1,96 +0,0 @@
/* GStreamer
* Copyright (C) 2002 The GStreamer Team
* <gstreamer-devel@lists.sourceforge.net>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __GST_VIDEOSINK_H__
#define __GST_VIDEOSINK_H__
#include <gst/gst.h>
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
#define MAX_FLIP_BUFFERS 1
typedef struct _GstImageInfo GstImageInfo;
struct _GstImageInfo {
gulong id;
int demo;
int dumpvideo;
void (*free_info) (GstImageInfo *info);
};
typedef struct _GstImageData GstImageData;
struct _GstImageData {
gint size;
gchar *data;
};
typedef struct _GstImageConnection GstImageConnection;
struct _GstImageConnection {
void (*open_conn) (GstImageConnection *conn, GstImageInfo *info);
void (*close_conn) (GstImageConnection *conn, GstImageInfo *info);
void (*free_conn) (GstImageConnection *conn);
};
typedef GstCaps * (*GstImagePluginGetCapsFunc) (GstImageInfo *info);
typedef GstImageConnection * (*GstImagePluginSetCapsFunc) (GstImageInfo *info, GstCaps *caps);
typedef GstImageData* (*GstImagePluginGetImageFunc) (GstImageInfo *info, GstImageConnection *conn);
typedef void (*GstImagePluginPutImageFunc) (GstImageInfo *info, GstImageData *image);
typedef void (*GstImagePluginFreeImageFunc) (GstImageData *image);
typedef struct _GstImagePlugin GstImagePlugin;
struct _GstImagePlugin {
GstImagePluginGetCapsFunc get_caps;
GstImagePluginSetCapsFunc set_caps;
GstImagePluginGetImageFunc get_image;
GstImagePluginPutImageFunc put_image;
GstImagePluginFreeImageFunc free_image;
};
typedef struct _GstGLImageInfo GstGLImageInfo;
/* stuff about our window grouped together */
struct _GstGLImageInfo {
GstImageInfo info;
Display *dpy;
int screen;
Window win;
GLXContext ctx;
XSetWindowAttributes attr;
Bool fs;
//XF86VidModeModeInfo deskMode;
int x, y;
unsigned int width, height;
unsigned int depth;
/* window specific from here */
GstElement *sink;
gulong handler_id;
float rotX,rotY,zoom, zoomdir;
};
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __GST_VIDEOSINK_H__ */

265
gst/gl/gstglxwindow.c
View file

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

424
gst/gl/regcomb_yuvrgb.c
View file

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