mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2025-02-05 14:02:26 +00:00
Code Issues 1 Projects Releases Wiki Activity

[624/906] OPENGL_ES2 => HAVE_GLES2 and add HAVE_OPENGL

Browse source 
use GstGLAPI to determine which code paths to execute.
perform some cleanups
This commit is contained in:
Matthew Waters 2012-12-06 18:40:26 +11:00
parent bbd3b4dbd9
commit cc8e54541b
38 changed files with 2283 additions and 1486 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
gst-libs/gst/gl/Makefile.am
View file

@ -55,7 +55,8 @@ libgstgl_@GST_API_VERSION@include_HEADERS = \
gstglshadervariables.h \ gstglshadervariables.h \
gstglshader.h \ gstglshader.h \
gstgldownload.h \ gstgldownload.h \
gstglupload.h gstglupload.h \
gstglapi.h
libgstgl_@GST_API_VERSION@_la_CFLAGS = \ libgstgl_@GST_API_VERSION@_la_CFLAGS = \
$(GL_CFLAGS) \ $(GL_CFLAGS) \

872
gst-libs/gst/gl/gstgldisplay.c
View file

File diff suppressed because it is too large Load diff

29
gst-libs/gst/gl/gstgldisplay.h
View file

@ -25,8 +25,11 @@
#include <gst/video/video.h> #include <gst/video/video.h>
typedef struct _GstGLUpload GstGLUpload;
typedef struct _GstGLDownload GstGLDownload;
typedef struct _GstGLShader GstGLShader;
#include "gstglwindow.h" #include "gstglwindow.h"
#include "gstglrenderer.h"
#include "gstglshader.h" #include "gstglshader.h"
#include "gstglupload.h" #include "gstglupload.h"
#include "gstgldownload.h" #include "gstgldownload.h"
@ -34,18 +37,19 @@
G_BEGIN_DECLS G_BEGIN_DECLS
GType gst_gl_display_get_type (void); GType gst_gl_display_get_type (void);
#define GST_TYPE_GL_DISPLAY (gst_gl_display_get_type()) #define GST_GL_TYPE_DISPLAY (gst_gl_display_get_type())
#define GST_GL_DISPLAY(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_GL_DISPLAY,GstGLDisplay)) #define GST_GL_DISPLAY(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_GL_TYPE_DISPLAY,GstGLDisplay))
#define GST_GL_DISPLAY_CLASS(klass) \ #define GST_GL_DISPLAY_CLASS(klass) \
(G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_GL_DISPLAY,GstGLDisplayClass)) (G_TYPE_CHECK_CLASS_CAST((klass),GST_GL_TYPE_DISPLAY,GstGLDisplayClass))
#define GST_IS_GL_DISPLAY(obj) \ #define GST_IS_GL_DISPLAY(obj) \
(G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_GL_DISPLAY)) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_GL_TYPE_DISPLAY))
#define GST_IS_GL_DISPLAY_CLASS(klass) \ #define GST_IS_GL_DISPLAY_CLASS(klass) \
(G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_GL_DISPLAY)) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_GL_TYPE_DISPLAY))
#define GST_GL_DISPLAY_CAST(obj) ((GstGLDisplay*)(obj)) #define GST_GL_DISPLAY_CAST(obj) ((GstGLDisplay*)(obj))
typedef struct _GstGLDisplay GstGLDisplay; typedef struct _GstGLDisplay GstGLDisplay;
typedef struct _GstGLDisplayClass GstGLDisplayClass; typedef struct _GstGLDisplayClass GstGLDisplayClass;
typedef struct _GstGLDisplayPrivate GstGLDisplayPrivate;
/** /**
* GstGLDisplayConversion: * GstGLDisplayConversion:
@ -139,6 +143,9 @@ struct _GstGLDisplay
GstGLWindow *gl_window; GstGLWindow *gl_window;
gboolean isAlive; gboolean isAlive;
/* gl API we are using */
GstGLAPI gl_api;
/* conditions */ /* conditions */
GCond *cond_create_context; GCond *cond_create_context;
GCond *cond_destroy_context; GCond *cond_destroy_context;
@ -152,10 +159,10 @@ struct _GstGLDisplay
GLuint redisplay_texture_width; GLuint redisplay_texture_width;
GLuint redisplay_texture_height; GLuint redisplay_texture_height;
gboolean keep_aspect_ratio; gboolean keep_aspect_ratio;
#ifdef OPENGL_ES2 #if HAVE_GLES2
GstGLShader *redisplay_shader; GstGLShader *redisplay_shader;
gchar *redisplay_vertex_shader_str; gchar *redisplay_vertex_shader_str_gles2;
gchar *redisplay_fragment_shader_str; gchar *redisplay_fragment_shader_str_gles2;
GLint redisplay_attr_position_loc; GLint redisplay_attr_position_loc;
GLint redisplay_attr_texture_loc; GLint redisplay_attr_texture_loc;
#endif #endif
@ -214,6 +221,8 @@ struct _GstGLDisplay
GstGLShader *del_shader; GstGLShader *del_shader;
gchar *error_message; gchar *error_message;
GstGLDisplayPrivate *priv;
}; };
@ -277,6 +286,8 @@ void gst_gl_display_check_framebuffer_status (void);
void gst_gl_display_lock (GstGLDisplay * display); void gst_gl_display_lock (GstGLDisplay * display);
void gst_gl_display_unlock (GstGLDisplay * display); void gst_gl_display_unlock (GstGLDisplay * display);
GstGLAPI gst_gl_display_get_gl_api (GstGLDisplay * display);
GstGLAPI gst_gl_display_get_gl_api_unlocked (GstGLDisplay * display);
G_END_DECLS G_END_DECLS

807
gst-libs/gst/gl/gstgldownload.c
View file

File diff suppressed because it is too large Load diff

13
gst-libs/gst/gl/gstgldownload.h
View file

@ -24,8 +24,8 @@
#include <gst/video/video.h> #include <gst/video/video.h>
#include <gst/gstmemory.h> #include <gst/gstmemory.h>
#include "gstglshader.h"
#include "gstgldisplay.h" #include "gstgldisplay.h"
#include "gstglshader.h"
G_BEGIN_DECLS G_BEGIN_DECLS
@ -43,6 +43,7 @@ GType gst_gl_download_get_type (void);
typedef struct _GstGLDownload GstGLDownload; typedef struct _GstGLDownload GstGLDownload;
typedef struct _GstGLDownloadClass GstGLDownloadClass; typedef struct _GstGLDownloadClass GstGLDownloadClass;
typedef struct _GstGLDownloadPrivate GstGLDownloadPrivate;
/** /**
* GstGLDownload * GstGLDownload
@ -74,10 +75,10 @@ struct _GstGLDownload
GLuint in_texture; GLuint in_texture;
GLuint out_texture[GST_VIDEO_MAX_PLANES]; GLuint out_texture[GST_VIDEO_MAX_PLANES];
GstGLShader *shader; GstGLShader *shader;
#ifdef OPENGL_ES2
GLint shader_attr_position_loc; GLint shader_attr_position_loc;
GLint shader_attr_texture_loc; GLint shader_attr_texture_loc;
#endif
GstGLDownloadPrivate *priv;
gpointer _reserved[GST_PADDING]; gpointer _reserved[GST_PADDING];
}; };
@ -97,12 +98,12 @@ struct _GstGLDownloadClass
* *
* The currently supported formats that can be downloaded * The currently supported formats that can be downloaded
*/ */
#ifndef OPENGL_ES2 #if !HAVE_GLES2
# define GST_GL_DOWNLOAD_FORMATS "{ RGB, RGBx, RGBA, BGR, BGRx, BGRA, xRGB, " \ # define GST_GL_DOWNLOAD_FORMATS "{ RGB, RGBx, RGBA, BGR, BGRx, BGRA, xRGB, " \
"xBGR, ARGB, ABGR, I420, YV12, YUY2, UYVY, AYUV }" "xBGR, ARGB, ABGR, I420, YV12, YUY2, UYVY, AYUV }"
#else /* OPENGL_ES2 */ #else /* HAVE_GLES2 */
# define GST_GL_DOWNLOAD_FORMATS "{ RGB, RGBx, RGBA, I420, YV12, YUY2, UYVY, AYUV }" # define GST_GL_DOWNLOAD_FORMATS "{ RGB, RGBx, RGBA, I420, YV12, YUY2, UYVY, AYUV }"
#endif /* !OPENGL_ES2 */ #endif /* !HAVE_GLES2 */
/** /**
* GST_GL_DOWNLOAD_VIDEO_CAPS: * GST_GL_DOWNLOAD_VIDEO_CAPS:

7
gst-libs/gst/gl/gstglfilter.c
View file

@ -1075,7 +1075,7 @@ gst_gl_filter_render_to_target (GstGLFilter * filter, gboolean resize,
in_width, 0, in_height, GST_GL_DISPLAY_PROJECTION_ORTHO2D, data); in_width, 0, in_height, GST_GL_DISPLAY_PROJECTION_ORTHO2D, data);
} }
#ifndef OPENGL_ES2 #if HAVE_OPENGL
static void static void
_draw_with_shader_cb (gint width, gint height, guint texture, gpointer stuff) _draw_with_shader_cb (gint width, gint height, guint texture, gpointer stuff)
{ {
@ -1116,6 +1116,9 @@ void
gst_gl_filter_render_to_target_with_shader (GstGLFilter * filter, gst_gl_filter_render_to_target_with_shader (GstGLFilter * filter,
gboolean resize, GLuint input, GLuint target, GstGLShader * shader) gboolean resize, GLuint input, GLuint target, GstGLShader * shader)
{ {
g_return_if_fail (gst_gl_display_get_gl_api (filter->display) &
GST_GL_API_OPENGL);
filter->default_shader = shader; filter->default_shader = shader;
gst_gl_filter_render_to_target (filter, resize, input, target, gst_gl_filter_render_to_target (filter, resize, input, target,
_draw_with_shader_cb, filter); _draw_with_shader_cb, filter);
@ -1153,4 +1156,4 @@ gst_gl_filter_draw_texture (GstGLFilter * filter, GLuint texture,
glEnd (); glEnd ();
} }
#endif #endif /* HAVE_OPENGL */

4
gst-libs/gst/gl/gstglfilter.h
View file

@ -124,12 +124,12 @@ gboolean gst_gl_filter_filter_texture (GstGLFilter * filter, GstBuffer * inbuf,
void gst_gl_filter_render_to_target (GstGLFilter *filter, gboolean resize, GLuint input, void gst_gl_filter_render_to_target (GstGLFilter *filter, gboolean resize, GLuint input,
GLuint target, GLCB func, gpointer data); GLuint target, GLCB func, gpointer data);
#ifndef OPENGL_ES2 #if HAVE_OPENGL
void gst_gl_filter_render_to_target_with_shader (GstGLFilter * filter, gboolean resize, void gst_gl_filter_render_to_target_with_shader (GstGLFilter * filter, gboolean resize,
GLuint input, GLuint target, GstGLShader *shader); GLuint input, GLuint target, GstGLShader *shader);
void gst_gl_filter_draw_texture (GstGLFilter *filter, GLuint texture, guint width, guint height); void gst_gl_filter_draw_texture (GstGLFilter *filter, GLuint texture, guint width, guint height);
#endif /* !OPENGL_ES2 */ #endif /* HAVE_OPENGL */
G_END_DECLS G_END_DECLS

37
gst-libs/gst/gl/gstglmemory.c
View file

@ -40,6 +40,12 @@
* Data is uploaded or downloaded from the GPU as is necessary. * Data is uploaded or downloaded from the GPU as is necessary.
*/ */
#define USING_OPENGL(display) (display->gl_api & GST_GL_API_OPENGL)
#define USING_OPENGL3(display) (display->gl_api & GST_GL_API_OPENGL3)
#define USING_GLES(display) (display->gl_api & GST_GL_API_GLES)
#define USING_GLES2(display) (display->gl_api & GST_GL_API_GLES2)
#define USING_GLES3(display) (display->gl_api & GST_GL_API_GLES3)
GST_DEBUG_CATEGORY_STATIC (GST_CAT_GL_MEMORY); GST_DEBUG_CATEGORY_STATIC (GST_CAT_GL_MEMORY);
#define GST_CAT_DEFUALT GST_CAT_GL_MEMORY #define GST_CAT_DEFUALT GST_CAT_GL_MEMORY
@ -220,22 +226,29 @@ _gl_mem_copy_thread (GstGLDisplay * display, gpointer data)
glGenRenderbuffersEXT (1, &rboId); glGenRenderbuffersEXT (1, &rboId);
glBindRenderbufferEXT (GL_RENDERBUFFER_EXT, rboId); glBindRenderbufferEXT (GL_RENDERBUFFER_EXT, rboId);
#ifndef OPENGL_ES2 #if HAVE_OPENGL
glRenderbufferStorageEXT (GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, width, if (USING_OPENGL (display)) {
height); glRenderbufferStorageEXT (GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, width,
glRenderbufferStorageEXT (GL_RENDERBUFFER_EXT, GL_DEPTH24_STENCIL8_EXT, height);
width, height); glRenderbufferStorageEXT (GL_RENDERBUFFER_EXT, GL_DEPTH24_STENCIL8_EXT,
#else width, height);
glRenderbufferStorageEXT (GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT16, }
width, height); #endif
#if HAVE_GLES2
if (USING_GLES2 (display)) {
glRenderbufferStorageEXT (GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT16,
width, height);
}
#endif #endif
/* attach the renderbuffer to depth attachment point */ /* attach the renderbuffer to depth attachment point */
glFramebufferRenderbufferEXT (GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, glFramebufferRenderbufferEXT (GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT,
GL_RENDERBUFFER_EXT, rboId); GL_RENDERBUFFER_EXT, rboId);
#ifndef OPENGL_ES2 #if HAVE_OPENGL
glFramebufferRenderbufferEXT (GL_FRAMEBUFFER_EXT, if (USING_OPENGL (display)) {
GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, rboId); glFramebufferRenderbufferEXT (GL_FRAMEBUFFER_EXT,
GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, rboId);
}
#endif #endif
glFramebufferTexture2DEXT (GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, glFramebufferTexture2DEXT (GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
@ -264,7 +277,7 @@ _gl_mem_copy_thread (GstGLDisplay * display, gpointer data)
GST_CAT_ERROR (GST_CAT_GL_MEMORY, GST_CAT_ERROR (GST_CAT_GL_MEMORY,
"GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS"); "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS");
break; break;
#ifndef OPENGL_ES2 #if HAVE_OPENGL
case GL_FRAMEBUFFER_UNDEFINED: case GL_FRAMEBUFFER_UNDEFINED:
GST_CAT_ERROR (GST_CAT_GL_MEMORY, "GL_FRAMEBUFFER_UNDEFINED"); GST_CAT_ERROR (GST_CAT_GL_MEMORY, "GL_FRAMEBUFFER_UNDEFINED");
break; break;

172
gst-libs/gst/gl/gstglshader.c
View file

@ -27,6 +27,12 @@
#define GST_GL_SHADER_GET_PRIVATE(o) \ #define GST_GL_SHADER_GET_PRIVATE(o) \
(G_TYPE_INSTANCE_GET_PRIVATE((o), GST_GL_TYPE_SHADER, GstGLShaderPrivate)) (G_TYPE_INSTANCE_GET_PRIVATE((o), GST_GL_TYPE_SHADER, GstGLShaderPrivate))
#define USING_OPENGL(display) (gst_gl_display_get_gl_api_unlocked (display) & GST_GL_API_OPENGL)
#define USING_OPENGL3(display) (gst_gl_display_get_gl_api_unlocked (display) & GST_GL_API_OPENGL3)
#define USING_GLES(display) (gst_gl_display_get_gl_api_unlocked (display) & GST_GL_API_GLES)
#define USING_GLES2(display) (gst_gl_display_get_gl_api_unlocked (display) & GST_GL_API_GLES2)
#define USING_GLES3(display) (gst_gl_display_get_gl_api_unlocked (display) & GST_GL_API_GLES3)
enum enum
{ {
PROP_0, PROP_0,
@ -251,9 +257,13 @@ gst_gl_shader_init (GstGLShader * self)
} }
GstGLShader * GstGLShader *
gst_gl_shader_new (void) gst_gl_shader_new (GstGLDisplay * display)
{ {
return g_object_new (GST_GL_TYPE_SHADER, NULL); GstGLShader *shader = g_object_new (GST_GL_TYPE_SHADER, NULL);
shader->display = display;
return shader;
} }
gboolean gboolean
@ -270,7 +280,7 @@ gst_gl_shader_compile (GstGLShader * shader, GError ** error)
GstGLShaderPrivate *priv; GstGLShaderPrivate *priv;
gchar info_buffer[2048]; gchar info_buffer[2048];
GLsizei len = 0; gint len = 0;
GLint status = GL_FALSE; GLint status = GL_FALSE;
g_return_val_if_fail (GST_GL_IS_SHADER (shader), FALSE); g_return_val_if_fail (GST_GL_IS_SHADER (shader), FALSE);
@ -293,12 +303,15 @@ gst_gl_shader_compile (GstGLShader * shader, GError ** error)
glGetObjectParameterivARB (priv->vertex_handle, glGetObjectParameterivARB (priv->vertex_handle,
GL_OBJECT_COMPILE_STATUS_ARB, &status); GL_OBJECT_COMPILE_STATUS_ARB, &status);
#ifndef OPENGL_ES2 #if HAVE_OPENGL
glGetInfoLogARB (priv->vertex_handle, if (USING_OPENGL (shader->display))
sizeof (info_buffer) - 1, &len, info_buffer); glGetInfoLogARB (priv->vertex_handle,
#else sizeof (info_buffer) - 1, &len, info_buffer);
glGetShaderInfoLog (priv->vertex_handle, #endif
sizeof (info_buffer) - 1, &len, info_buffer); #if HAVE_GLES2
if (USING_GLES2 (shader->display))
glGetShaderInfoLog (priv->vertex_handle,
sizeof (info_buffer) - 1, &len, info_buffer);
#endif #endif
info_buffer[len] = '\0'; info_buffer[len] = '\0';
@ -329,12 +342,15 @@ gst_gl_shader_compile (GstGLShader * shader, GError ** error)
glGetObjectParameterivARB (priv->fragment_handle, glGetObjectParameterivARB (priv->fragment_handle,
GL_OBJECT_COMPILE_STATUS_ARB, &status); GL_OBJECT_COMPILE_STATUS_ARB, &status);
#ifndef OPENGL_ES2 #if HAVE_OPENGL
glGetInfoLogARB (priv->fragment_handle, if (USING_OPENGL (shader->display))
sizeof (info_buffer) - 1, &len, info_buffer); glGetInfoLogARB (priv->fragment_handle,
#else sizeof (info_buffer) - 1, &len, info_buffer);
glGetShaderInfoLog (priv->fragment_handle, #endif
sizeof (info_buffer) - 1, &len, info_buffer); #if HAVE_GLES2
if (USING_GLES2 (shader->display))
glGetShaderInfoLog (priv->fragment_handle,
sizeof (info_buffer) - 1, &len, info_buffer);
#endif #endif
info_buffer[len] = '\0'; info_buffer[len] = '\0';
if (status != GL_TRUE) { if (status != GL_TRUE) {
@ -356,10 +372,13 @@ gst_gl_shader_compile (GstGLShader * shader, GError ** error)
/* if nothing failed link shaders */ /* if nothing failed link shaders */
glLinkProgramARB (priv->program_handle); glLinkProgramARB (priv->program_handle);
#ifndef OPENGL_ES2 #if HAVE_OPENGL
glGetObjectParameterivARB (priv->program_handle, GL_LINK_STATUS, &status); if (USING_OPENGL (shader->display))
#else glGetObjectParameterivARB (priv->program_handle, GL_LINK_STATUS, &status);
glGetProgramiv (priv->program_handle, GL_LINK_STATUS, &status); #endif
#if HAVE_GLES2
if (USING_GLES2 (shader->display))
glGetProgramiv (priv->program_handle, GL_LINK_STATUS, &status);
#endif #endif
glGetInfoLogARB (priv->program_handle, glGetInfoLogARB (priv->program_handle,
@ -400,10 +419,13 @@ gst_gl_shader_release (GstGLShader * shader)
if (priv->vertex_handle) { /* not needed but nvidia doesn't care to respect the spec */ if (priv->vertex_handle) { /* not needed but nvidia doesn't care to respect the spec */
GST_TRACE ("finalizing vertex shader %u", priv->vertex_handle); GST_TRACE ("finalizing vertex shader %u", priv->vertex_handle);
#ifndef OPENGL_ES2 #if HAVE_OPENGL
glDeleteObjectARB (priv->vertex_handle); if (USING_OPENGL (shader->display))
#else glDeleteObjectARB (priv->vertex_handle);
glDeleteShader (priv->vertex_handle); #endif
#if HAVE_GLES2
if (USING_GLES2 (shader->display))
glDeleteShader (priv->vertex_handle);
#endif #endif
/* err = glGetError (); */ /* err = glGetError (); */
@ -415,10 +437,14 @@ gst_gl_shader_release (GstGLShader * shader)
if (priv->fragment_handle) { if (priv->fragment_handle) {
GST_TRACE ("finalizing fragment shader %u", priv->fragment_handle); GST_TRACE ("finalizing fragment shader %u", priv->fragment_handle);
#ifndef OPENGL_ES2
glDeleteObjectARB (priv->fragment_handle); #if HAVE_OPENGL
#else if (USING_OPENGL (shader->display))
glDeleteShader (priv->fragment_handle); glDeleteObjectARB (priv->fragment_handle);
#endif
#if HAVE_GLES2
if (USING_GLES2 (shader->display))
glDeleteShader (priv->fragment_handle);
#endif #endif
/* err = glGetError (); */ /* err = glGetError (); */
@ -748,7 +774,7 @@ gst_gl_shader_set_uniform_4iv (GstGLShader * shader, const gchar * name,
void void
gst_gl_shader_set_uniform_matrix_2fv (GstGLShader * shader, const gchar * name, gst_gl_shader_set_uniform_matrix_2fv (GstGLShader * shader, const gchar * name,
GLsizei count, GLboolean transpose, const GLfloat * value) gint count, gboolean transpose, const gfloat * value)
{ {
GstGLShaderPrivate *priv; GstGLShaderPrivate *priv;
GLint location = -1; GLint location = -1;
@ -762,11 +788,42 @@ gst_gl_shader_set_uniform_matrix_2fv (GstGLShader * shader, const gchar * name,
glUniformMatrix2fvARB (location, count, transpose, value); glUniformMatrix2fvARB (location, count, transpose, value);
} }
#ifndef OPENGL_ES2 void
gst_gl_shader_set_uniform_matrix_3fv (GstGLShader * shader, const gchar * name,
gint count, gboolean transpose, const gfloat * value)
{
GstGLShaderPrivate *priv;
GLint location = -1;
priv = shader->priv;
g_return_if_fail (priv->program_handle != 0);
location = glGetUniformLocationARB (priv->program_handle, name);
glUniformMatrix3fvARB (location, count, transpose, value);
}
void
gst_gl_shader_set_uniform_matrix_4fv (GstGLShader * shader, const gchar * name,
gint count, gboolean transpose, const gfloat * value)
{
GstGLShaderPrivate *priv;
GLint location = -1;
priv = shader->priv;
g_return_if_fail (priv->program_handle != 0);
location = glGetUniformLocationARB (priv->program_handle, name);
glUniformMatrix4fvARB (location, count, transpose, value);
}
#if HAVE_OPENGL
void void
gst_gl_shader_set_uniform_matrix_2x3fv (GstGLShader * shader, gst_gl_shader_set_uniform_matrix_2x3fv (GstGLShader * shader,
const gchar * name, GLsizei count, GLboolean transpose, const gchar * name, gint count, gboolean transpose, const gfloat * value)
const GLfloat * value)
{ {
GstGLShaderPrivate *priv; GstGLShaderPrivate *priv;
GLint location = -1; GLint location = -1;
@ -782,8 +839,7 @@ gst_gl_shader_set_uniform_matrix_2x3fv (GstGLShader * shader,
void void
gst_gl_shader_set_uniform_matrix_2x4fv (GstGLShader * shader, gst_gl_shader_set_uniform_matrix_2x4fv (GstGLShader * shader,
const gchar * name, GLsizei count, GLboolean transpose, const gchar * name, gint count, gboolean transpose, const gfloat * value)
const GLfloat * value)
{ {
GstGLShaderPrivate *priv; GstGLShaderPrivate *priv;
GLint location = -1; GLint location = -1;
@ -796,29 +852,10 @@ gst_gl_shader_set_uniform_matrix_2x4fv (GstGLShader * shader,
glUniformMatrix2x4fv (location, count, transpose, value); glUniformMatrix2x4fv (location, count, transpose, value);
} }
#endif
void
gst_gl_shader_set_uniform_matrix_3fv (GstGLShader * shader, const gchar * name,
GLsizei count, GLboolean transpose, const GLfloat * value)
{
GstGLShaderPrivate *priv;
GLint location = -1;
priv = shader->priv;
g_return_if_fail (priv->program_handle != 0);
location = glGetUniformLocationARB (priv->program_handle, name);
glUniformMatrix3fvARB (location, count, transpose, value);
}
#ifndef OPENGL_ES2
void void
gst_gl_shader_set_uniform_matrix_3x2fv (GstGLShader * shader, gst_gl_shader_set_uniform_matrix_3x2fv (GstGLShader * shader,
const gchar * name, GLsizei count, GLboolean transpose, const gchar * name, gint count, gboolean transpose, const gfloat * value)
const GLfloat * value)
{ {
GstGLShaderPrivate *priv; GstGLShaderPrivate *priv;
GLint location = -1; GLint location = -1;
@ -834,8 +871,7 @@ gst_gl_shader_set_uniform_matrix_3x2fv (GstGLShader * shader,
void void
gst_gl_shader_set_uniform_matrix_3x4fv (GstGLShader * shader, gst_gl_shader_set_uniform_matrix_3x4fv (GstGLShader * shader,
const gchar * name, GLsizei count, GLboolean transpose, const gchar * name, gint count, gboolean transpose, const gfloat * value)
const GLfloat * value)
{ {
GstGLShaderPrivate *priv; GstGLShaderPrivate *priv;
GLint location = -1; GLint location = -1;
@ -848,29 +884,10 @@ gst_gl_shader_set_uniform_matrix_3x4fv (GstGLShader * shader,
glUniformMatrix3x4fv (location, count, transpose, value); glUniformMatrix3x4fv (location, count, transpose, value);
} }
#endif
void
gst_gl_shader_set_uniform_matrix_4fv (GstGLShader * shader, const gchar * name,
GLsizei count, GLboolean transpose, const GLfloat * value)
{
GstGLShaderPrivate *priv;
GLint location = -1;
priv = shader->priv;
g_return_if_fail (priv->program_handle != 0);
location = glGetUniformLocationARB (priv->program_handle, name);
glUniformMatrix4fvARB (location, count, transpose, value);
}
#ifndef OPENGL_ES2
void void
gst_gl_shader_set_uniform_matrix_4x2fv (GstGLShader * shader, gst_gl_shader_set_uniform_matrix_4x2fv (GstGLShader * shader,
const gchar * name, GLsizei count, GLboolean transpose, const gchar * name, gint count, gboolean transpose, const gfloat * value)
const GLfloat * value)
{ {
GstGLShaderPrivate *priv; GstGLShaderPrivate *priv;
GLint location = -1; GLint location = -1;
@ -886,8 +903,7 @@ gst_gl_shader_set_uniform_matrix_4x2fv (GstGLShader * shader,
void void
gst_gl_shader_set_uniform_matrix_4x3fv (GstGLShader * shader, gst_gl_shader_set_uniform_matrix_4x3fv (GstGLShader * shader,
const gchar * name, GLsizei count, GLboolean transpose, const gchar * name, gint count, gboolean transpose, const gfloat * value)
const GLfloat * value)
{ {
GstGLShaderPrivate *priv; GstGLShaderPrivate *priv;
GLint location = -1; GLint location = -1;
@ -900,7 +916,7 @@ gst_gl_shader_set_uniform_matrix_4x3fv (GstGLShader * shader,
glUniformMatrix4x3fv (location, count, transpose, value); glUniformMatrix4x3fv (location, count, transpose, value);
} }
#endif #endif /* HAVE_OPENGL */
GLint GLint
gst_gl_shader_get_attribute_location (GstGLShader * shader, const gchar * name) gst_gl_shader_get_attribute_location (GstGLShader * shader, const gchar * name)

107
gst-libs/gst/gl/gstglshader.h
View file

@ -21,18 +21,17 @@
#ifndef __GST_GL_SHADER_H__ #ifndef __GST_GL_SHADER_H__
#define __GST_GL_SHADER_H__ #define __GST_GL_SHADER_H__
/* OpenGL 2.0 for Embedded Systems */ #ifdef HAVE_CONFIG_H
#ifdef OPENGL_ES2 #include "config.h"
#include <GLES2/gl2.h>
#include "gstgles2.h"
/* OpenGL for usual systems */
#else
#include <GL/glew.h>
#endif #endif
#include "gstgldisplay.h"
#include <gst/gst.h> #include <gst/gst.h>
G_BEGIN_DECLS G_BEGIN_DECLS
typedef struct _GstGLDisplay GstGLDisplay;
#define GST_GL_TYPE_SHADER (gst_gl_shader_get_type()) #define GST_GL_TYPE_SHADER (gst_gl_shader_get_type())
#define GST_GL_SHADER(o) (G_TYPE_CHECK_INSTANCE_CAST((o), GST_GL_TYPE_SHADER, GstGLShader)) #define GST_GL_SHADER(o) (G_TYPE_CHECK_INSTANCE_CAST((o), GST_GL_TYPE_SHADER, GstGLShader))
#define GST_GL_SHADER_CLASS(k) (G_TYPE_CHECK_CLASS((k), GST_GL_TYPE_SHADER, GstGLShaderClass)) #define GST_GL_SHADER_CLASS(k) (G_TYPE_CHECK_CLASS((k), GST_GL_TYPE_SHADER, GstGLShaderClass))
@ -60,6 +59,9 @@ typedef struct _GstGLShaderClass GstGLShaderClass;
struct _GstGLShader { struct _GstGLShader {
/*< private >*/ /*< private >*/
GObject parent; GObject parent;
GstGLDisplay *display;
GstGLShaderPrivate *priv; GstGLShaderPrivate *priv;
}; };
@ -73,68 +75,51 @@ struct _GstGLShaderClass {
GQuark gst_gl_shader_error_quark (void); GQuark gst_gl_shader_error_quark (void);
GType gst_gl_shader_get_type (void); GType gst_gl_shader_get_type (void);
GstGLShader * gst_gl_shader_new (void); GstGLShader * gst_gl_shader_new (GstGLDisplay *display);
void gst_gl_shader_set_vertex_source (GstGLShader *shader, void gst_gl_shader_set_vertex_source (GstGLShader *shader, const gchar *src);
const gchar *src); void gst_gl_shader_set_fragment_source (GstGLShader *shader, const gchar *src);
void gst_gl_shader_set_fragment_source (GstGLShader *shader, const gchar * gst_gl_shader_get_vertex_source (GstGLShader *shader);
const gchar *src);
const gchar * gst_gl_shader_get_vertex_source (GstGLShader *shader);
const gchar * gst_gl_shader_get_fragment_source (GstGLShader *shader); const gchar * gst_gl_shader_get_fragment_source (GstGLShader *shader);
void gst_gl_shader_set_active (GstGLShader *shader, void gst_gl_shader_set_active (GstGLShader *shader, gboolean active);
gboolean active); gboolean gst_gl_shader_is_compiled (GstGLShader *shader);
gboolean gst_gl_shader_compile (GstGLShader *shader, GError **error);
gboolean gst_gl_shader_is_compiled (GstGLShader *shader);
gboolean gst_gl_shader_compile (GstGLShader *shader, GError **error);
gboolean gst_gl_shader_compile_and_check (GstGLShader *shader, const gchar *source, GstGLShaderSourceType type); gboolean gst_gl_shader_compile_and_check (GstGLShader *shader, const gchar *source, GstGLShaderSourceType type);
void gst_gl_shader_release (GstGLShader *shader); void gst_gl_shader_release (GstGLShader *shader);
void gst_gl_shader_use (GstGLShader *shader); void gst_gl_shader_use (GstGLShader *shader);
void gst_gl_shader_set_uniform_1i (GstGLShader *shader, const gchar *name, gint value); void gst_gl_shader_set_uniform_1i (GstGLShader *shader, const gchar *name, gint value);
void gst_gl_shader_set_uniform_1iv (GstGLShader *shader, const gchar *name, guint count, gint * value); void gst_gl_shader_set_uniform_1iv (GstGLShader *shader, const gchar *name, guint count, gint *value);
void gst_gl_shader_set_uniform_1f (GstGLShader *shader, const gchar *name, gfloat value); void gst_gl_shader_set_uniform_1f (GstGLShader *shader, const gchar *name, gfloat value);
void gst_gl_shader_set_uniform_1fv (GstGLShader *shader, const gchar *name, guint count, gfloat * value); void gst_gl_shader_set_uniform_1fv (GstGLShader *shader, const gchar *name, guint count, gfloat *value);
void gst_gl_shader_set_uniform_2i (GstGLShader *shader, const gchar *name, gint v0, gint v1); void gst_gl_shader_set_uniform_2i (GstGLShader *shader, const gchar *name, gint v0, gint v1);
void gst_gl_shader_set_uniform_2iv (GstGLShader *shader, const gchar *name, guint count, gint * value); void gst_gl_shader_set_uniform_2iv (GstGLShader *shader, const gchar *name, guint count, gint *value);
void gst_gl_shader_set_uniform_2f (GstGLShader *shader, const gchar *name, gfloat v0, gfloat v1); void gst_gl_shader_set_uniform_2f (GstGLShader *shader, const gchar *name, gfloat v0, gfloat v1);
void gst_gl_shader_set_uniform_2fv (GstGLShader *shader, const gchar *name, guint count, gfloat * value); void gst_gl_shader_set_uniform_2fv (GstGLShader *shader, const gchar *name, guint count, gfloat *value);
void gst_gl_shader_set_uniform_3i (GstGLShader *shader, const gchar *name, gint v0, gint v1, gint v2); void gst_gl_shader_set_uniform_3i (GstGLShader *shader, const gchar *name, gint v0, gint v1, gint v2);
void gst_gl_shader_set_uniform_3iv (GstGLShader *shader, const gchar *name, guint count, gint * value); void gst_gl_shader_set_uniform_3iv (GstGLShader *shader, const gchar *name, guint count, gint * value);
void gst_gl_shader_set_uniform_3f (GstGLShader *shader, const gchar *name, gfloat v0, gfloat v1, gfloat v2); void gst_gl_shader_set_uniform_3f (GstGLShader *shader, const gchar *name, gfloat v0, gfloat v1, gfloat v2);
void gst_gl_shader_set_uniform_3fv (GstGLShader *shader, const gchar *name, guint count, gfloat * value); void gst_gl_shader_set_uniform_3fv (GstGLShader *shader, const gchar *name, guint count, gfloat *value);
void gst_gl_shader_set_uniform_4i (GstGLShader *shader, const gchar *name, gint v0, gint v1, gint v2, gint v3); void gst_gl_shader_set_uniform_4i (GstGLShader *shader, const gchar *name, gint v0, gint v1, gint v2, gint v3);
void gst_gl_shader_set_uniform_4iv (GstGLShader *shader, const gchar *name, guint count, gint * value); void gst_gl_shader_set_uniform_4iv (GstGLShader *shader, const gchar *name, guint count, gint *value);
void gst_gl_shader_set_uniform_4f (GstGLShader *shader, const gchar *name, gfloat v0, gfloat v1, gfloat v2, gfloat v3); void gst_gl_shader_set_uniform_4f (GstGLShader *shader, const gchar *name, gfloat v0, gfloat v1, gfloat v2, gfloat v3);
void gst_gl_shader_set_uniform_4fv (GstGLShader *shader, const gchar *name, guint count, gfloat * value); void gst_gl_shader_set_uniform_4fv (GstGLShader *shader, const gchar *name, guint count, gfloat *value);
void gst_gl_shader_set_uniform_matrix_2fv (GstGLShader * shader, const gchar * name, void gst_gl_shader_set_uniform_matrix_2fv (GstGLShader *shader, const gchar *name, gint count, gboolean transpose, const gfloat* value);
GLsizei count, GLboolean transpose, const GLfloat* value); void gst_gl_shader_set_uniform_matrix_3fv (GstGLShader *shader, const gchar *name, gint count, gboolean transpose, const gfloat* value);
#ifndef OPENGL_ES2 void gst_gl_shader_set_uniform_matrix_4fv (GstGLShader *shader, const gchar *name, gint count, gboolean transpose, const gfloat* value);
void gst_gl_shader_set_uniform_matrix_2x3fv (GstGLShader * shader, const gchar * name, #if HAVE_OPENGL
GLsizei count, GLboolean transpose, const GLfloat* value); void gst_gl_shader_set_uniform_matrix_2x3fv (GstGLShader *shader, const gchar *name, gint count, gboolean transpose, const gfloat* value);
void gst_gl_shader_set_uniform_matrix_2x4fv (GstGLShader * shader, const gchar * name, void gst_gl_shader_set_uniform_matrix_2x4fv (GstGLShader *shader, const gchar *name, gint count, gboolean transpose, const gfloat* value);
GLsizei count, GLboolean transpose, const GLfloat* value); void gst_gl_shader_set_uniform_matrix_3x2fv (GstGLShader *shader, const gchar *name, gint count, gboolean transpose, const gfloat* value);
#endif void gst_gl_shader_set_uniform_matrix_3x4fv (GstGLShader *shader, const gchar *name, gint count, gboolean transpose, const gfloat* value);
void gst_gl_shader_set_uniform_matrix_3fv (GstGLShader * shader, const gchar * name, void gst_gl_shader_set_uniform_matrix_4x2fv (GstGLShader *shader, const gchar *name, gint count, gboolean transpose, const gfloat* value);
GLsizei count, GLboolean transpose, const GLfloat* value); void gst_gl_shader_set_uniform_matrix_4x3fv (GstGLShader *shader, const gchar *name, gint count, gboolean transpose, const gfloat* value);
#ifndef OPENGL_ES2
void gst_gl_shader_set_uniform_matrix_3x2fv (GstGLShader * shader, const gchar * name,
GLsizei count, GLboolean transpose, const GLfloat* value);
void gst_gl_shader_set_uniform_matrix_3x4fv (GstGLShader * shader, const gchar * name,
GLsizei count, GLboolean transpose, const GLfloat* value);
#endif
void gst_gl_shader_set_uniform_matrix_4fv (GstGLShader * shader, const gchar * name,
GLsizei count, GLboolean transpose, const GLfloat* value);
#ifndef OPENGL_ES2
void gst_gl_shader_set_uniform_matrix_4x2fv (GstGLShader * shader, const gchar * name,
GLsizei count, GLboolean transpose, const GLfloat* value);
void gst_gl_shader_set_uniform_matrix_4x3fv (GstGLShader * shader, const gchar * name,
GLsizei count, GLboolean transpose, const GLfloat* value);
#endif #endif
GLint gst_gl_shader_get_attribute_location (GstGLShader *shader, const gchar *name); gint gst_gl_shader_get_attribute_location (GstGLShader *shader, const gchar *name);
void gst_gl_shader_bind_attribute_location (GstGLShader * shader, GLuint index, const gchar * name); void gst_gl_shader_bind_attribute_location (GstGLShader * shader, guint index, const gchar * name);
G_END_DECLS G_END_DECLS

27
gst-libs/gst/gl/gstglshadervariables.c
View file

@ -554,7 +554,19 @@ gst_gl_shadervariable_set (GstGLShader * shader,
(float *) ret->value); (float *) ret->value);
break; break;
#ifndef OPENGL_ES2 case _mat3:
case _mat3x3:
gst_gl_shader_set_uniform_matrix_3fv (shader, ret->name, ret->count, 0,
(float *) ret->value);
break;
case _mat4:
case _mat4x4:
gst_gl_shader_set_uniform_matrix_4fv (shader, ret->name, ret->count, 0,
(float *) ret->value);
break;
#if HAVE_OPENGL
case _mat2x3: case _mat2x3:
gst_gl_shader_set_uniform_matrix_2x3fv (shader, ret->name, ret->count, 0, gst_gl_shader_set_uniform_matrix_2x3fv (shader, ret->name, ret->count, 0,
(float *) ret->value); (float *) ret->value);
@ -574,13 +586,7 @@ gst_gl_shadervariable_set (GstGLShader * shader,
gst_gl_shader_set_uniform_matrix_4x2fv (shader, ret->name, ret->count, 0, gst_gl_shader_set_uniform_matrix_4x2fv (shader, ret->name, ret->count, 0,
(float *) ret->value); (float *) ret->value);
break; break;
#endif
case _mat3:
case _mat3x3:
gst_gl_shader_set_uniform_matrix_3fv (shader, ret->name, ret->count, 0,
(float *) ret->value);
break;
#ifndef OPENGL_ES2
case _mat3x4: case _mat3x4:
gst_gl_shader_set_uniform_matrix_3x4fv (shader, ret->name, ret->count, 0, gst_gl_shader_set_uniform_matrix_3x4fv (shader, ret->name, ret->count, 0,
(float *) ret->value); (float *) ret->value);
@ -591,11 +597,6 @@ gst_gl_shadervariable_set (GstGLShader * shader,
(float *) ret->value); (float *) ret->value);
break; break;
#endif #endif
case _mat4:
case _mat4x4:
gst_gl_shader_set_uniform_matrix_4fv (shader, ret->name, ret->count, 0,
(float *) ret->value);
break;
default: default:
return -1; return -1;

814
gst-libs/gst/gl/gstglupload.c
View file

File diff suppressed because it is too large Load diff

13
gst-libs/gst/gl/gstglupload.h
View file

@ -43,6 +43,7 @@ GType gst_gl_upload_get_type (void);
typedef struct _GstGLUpload GstGLUpload; typedef struct _GstGLUpload GstGLUpload;
typedef struct _GstGLUploadClass GstGLUploadClass; typedef struct _GstGLUploadClass GstGLUploadClass;
typedef struct _GstGLUploadPrivate GstGLUploadPrivate;
/** /**
* GstGLUpload * GstGLUpload
@ -76,12 +77,12 @@ struct _GstGLUpload
guint in_width; guint in_width;
guint in_height; guint in_height;
GstGLShader *shader; GstGLShader *shader;
#ifdef OPENGL_ES2
GLint shader_attr_position_loc; GLint shader_attr_position_loc;
GLint shader_attr_texture_loc; GLint shader_attr_texture_loc;
#endif
/* <private> */ /* <private> */
GstGLUploadPrivate *priv;
gpointer _reserved[GST_PADDING]; gpointer _reserved[GST_PADDING];
}; };
@ -100,12 +101,12 @@ struct _GstGLUploadClass
* *
* The currently supported formats that can be uploaded * The currently supported formats that can be uploaded
*/ */
#ifndef OPENGL_ES2 #if !HAVE_GLES2
# define GST_GL_UPLOAD_FORMATS "{ RGB, RGBx, RGBA, BGR, BGRx, BGRA, xRGB, " \ #define GST_GL_UPLOAD_FORMATS "{ RGB, RGBx, RGBA, BGR, BGRx, BGRA, xRGB, " \
"xBGR, ARGB, ABGR, I420, YV12, YUY2, UYVY, AYUV }" "xBGR, ARGB, ABGR, I420, YV12, YUY2, UYVY, AYUV }"
#else /* OPENGL_ES2 */ #else /* HAVE_GLES2 */
# define GST_GL_UPLOAD_FORMATS "{ RGB, RGBx, RGBA, I420, YV12, YUY2, UYVY, AYUV }" # define GST_GL_UPLOAD_FORMATS "{ RGB, RGBx, RGBA, I420, YV12, YUY2, UYVY, AYUV }"
#endif #endif /* !HAVE_GLES2 */
/** /**
* GST_GL_UPLOAD_VIDEO_CAPS: * GST_GL_UPLOAD_VIDEO_CAPS:

2
gst/gl/Makefile.am
View file

@ -5,7 +5,7 @@ AM_CFLAGS = $(GST_PLUGINS_BASE_CFLAGS) $(GST_BASE_CFLAGS) $(GST_CFLAGS)
AM_LIBS = $(GST_BASE_LIBS) $(GST_PLUGINS_BASE_LIBS) AM_LIBS = $(GST_BASE_LIBS) $(GST_PLUGINS_BASE_LIBS)
# full opengl required # full opengl required
if USE_GL if USE_OPENGL
OPENGL_SOURCES = \ OPENGL_SOURCES = \
gstglfiltershader.c \ gstglfiltershader.c \
gstglfiltershader.h \ gstglfiltershader.h \

2
gst/gl/effects/gstgleffectbulge.c
View file

@ -31,7 +31,7 @@ gst_gl_effects_bulge_callback (gint width, gint height, guint texture,
shader = g_hash_table_lookup (effects->shaderstable, "bulge0"); shader = g_hash_table_lookup (effects->shaderstable, "bulge0");
if (!shader) { if (!shader) {
shader = gst_gl_shader_new (); shader = gst_gl_shader_new (GST_GL_FILTER (effects)->display);
g_hash_table_insert (effects->shaderstable, "bulge0", shader); g_hash_table_insert (effects->shaderstable, "bulge0", shader);
} }

2
gst/gl/effects/gstgleffectfisheye.c
View file

@ -31,7 +31,7 @@ gst_gl_effects_fisheye_callback (gint width, gint height, guint texture,
shader = g_hash_table_lookup (effects->shaderstable, "fisheye0"); shader = g_hash_table_lookup (effects->shaderstable, "fisheye0");
if (!shader) { if (!shader) {
shader = gst_gl_shader_new (); shader = gst_gl_shader_new (GST_GL_FILTER (effects)->display);
g_hash_table_insert (effects->shaderstable, "fisheye0", shader); g_hash_table_insert (effects->shaderstable, "fisheye0", shader);
} }

8
gst/gl/effects/gstgleffectglow.c
View file

@ -34,7 +34,7 @@ gst_gl_effects_glow_step_one (gint width, gint height, guint texture,
shader = g_hash_table_lookup (effects->shaderstable, "glow0"); shader = g_hash_table_lookup (effects->shaderstable, "glow0");
if (!shader) { if (!shader) {
shader = gst_gl_shader_new (); shader = gst_gl_shader_new (GST_GL_FILTER (effects)->display);
g_hash_table_insert (effects->shaderstable, "glow0", shader); g_hash_table_insert (effects->shaderstable, "glow0", shader);
} }
@ -71,7 +71,7 @@ gst_gl_effects_glow_step_two (gint width, gint height, guint texture,
shader = g_hash_table_lookup (effects->shaderstable, "glow1"); shader = g_hash_table_lookup (effects->shaderstable, "glow1");
if (!shader) { if (!shader) {
shader = gst_gl_shader_new (); shader = gst_gl_shader_new (GST_GL_FILTER (effects)->display);
g_hash_table_insert (effects->shaderstable, "glow1", shader); g_hash_table_insert (effects->shaderstable, "glow1", shader);
} }
@ -115,7 +115,7 @@ gst_gl_effects_glow_step_three (gint width, gint height, guint texture,
shader = g_hash_table_lookup (effects->shaderstable, "glow2"); shader = g_hash_table_lookup (effects->shaderstable, "glow2");
if (!shader) { if (!shader) {
shader = gst_gl_shader_new (); shader = gst_gl_shader_new (GST_GL_FILTER (effects)->display);
g_hash_table_insert (effects->shaderstable, "glow2", shader); g_hash_table_insert (effects->shaderstable, "glow2", shader);
} }
@ -154,7 +154,7 @@ gst_gl_effects_glow_step_four (gint width, gint height, guint texture,
shader = g_hash_table_lookup (effects->shaderstable, "glow3"); shader = g_hash_table_lookup (effects->shaderstable, "glow3");
if (!shader) { if (!shader) {
shader = gst_gl_shader_new (); shader = gst_gl_shader_new (GST_GL_FILTER (effects)->display);
g_hash_table_insert (effects->shaderstable, "glow3", shader); g_hash_table_insert (effects->shaderstable, "glow3", shader);
} }

76
gst/gl/effects/gstgleffectidentity.c
View file

@ -20,51 +20,61 @@
#include <gstgleffects.h> #include <gstgleffects.h>
#define USING_OPENGL(display) (gst_gl_display_get_gl_api_unlocked (display) & GST_GL_API_OPENGL)
#define USING_OPENGL3(display) (gst_gl_display_get_gl_api_unlocked (display) & GST_GL_API_OPENGL3)
#define USING_GLES(display) (gst_gl_display_get_gl_api_unlocked (display) & GST_GL_API_GLES)
#define USING_GLES2(display) (gst_gl_display_get_gl_api_unlocked (display) & GST_GL_API_GLES2)
#define USING_GLES3(display) (gst_gl_display_get_gl_api_unlocked (display) & GST_GL_API_GLES3)
static void static void
gst_gl_effects_identity_callback (gint width, gint height, guint texture, gst_gl_effects_identity_callback (gint width, gint height, guint texture,
gpointer data) gpointer data)
{ {
GstGLEffects *effects = GST_GL_EFFECTS (data); GstGLEffects *effects = GST_GL_EFFECTS (data);
GstGLFilter *filter = GST_GL_FILTER (effects);
#ifndef OPENGL_ES2 #if HAVE_OPENGL
glMatrixMode (GL_PROJECTION); if (USING_OPENGL (filter->display)) {
glLoadIdentity (); glMatrixMode (GL_PROJECTION);
#else glLoadIdentity ();
GstGLShader *shader = }
g_hash_table_lookup (effects->shaderstable, "identity0"); #endif
#if HAVE_GLES2
if (USING_GLES2 (filter->display)) {
GstGLShader *shader =
g_hash_table_lookup (effects->shaderstable, "identity0");
if (!shader) { if (!shader) {
shader = gst_gl_shader_new (); shader = gst_gl_shader_new (filter->display);
g_hash_table_insert (effects->shaderstable, "identity0", shader); g_hash_table_insert (effects->shaderstable, "identity0", shader);
if (shader) {
GError *error = NULL;
gst_gl_shader_set_vertex_source (shader, vertex_shader_source);
gst_gl_shader_set_fragment_source (shader, identity_fragment_source);
if (shader) { gst_gl_shader_compile (shader, &error);
GError *error = NULL; if (error) {
gst_gl_shader_set_vertex_source (shader, vertex_shader_source); GST_ERROR ("%s", error->message);
gst_gl_shader_set_fragment_source (shader, identity_fragment_source); g_error_free (error);
error = NULL;
gst_gl_shader_compile (shader, &error); gst_gl_shader_use (NULL);
if (error) { } else {
GST_ERROR ("%s", error->message); effects->draw_attr_position_loc =
g_error_free (error); gst_gl_shader_get_attribute_location (shader, "a_position");
error = NULL; effects->draw_attr_texture_loc =
gst_gl_shader_use (NULL); gst_gl_shader_get_attribute_location (shader, "a_texCoord");
} else { }
effects->draw_attr_position_loc =
gst_gl_shader_get_attribute_location (shader, "a_position");
effects->draw_attr_texture_loc =
gst_gl_shader_get_attribute_location (shader, "a_texCoord");
} }
} }
gst_gl_shader_use (shader);
glActiveTexture (GL_TEXTURE0);
glEnable (GL_TEXTURE_RECTANGLE_ARB);
glBindTexture (GL_TEXTURE_RECTANGLE_ARB, texture);
gst_gl_shader_set_uniform_1i (shader, "tex", 0);
} }
gst_gl_shader_use (shader);
glActiveTexture (GL_TEXTURE0);
glEnable (GL_TEXTURE_RECTANGLE_ARB);
glBindTexture (GL_TEXTURE_RECTANGLE_ARB, texture);
gst_gl_shader_set_uniform_1i (shader, "tex", 0);
#endif #endif
gst_gl_effects_draw_texture (effects, texture, width, height); gst_gl_effects_draw_texture (effects, texture, width, height);

2
gst/gl/effects/gstgleffectlumatocurve.c
View file

@ -31,7 +31,7 @@ gst_gl_effects_luma_to_curve (GstGLEffects * effects,
shader = g_hash_table_lookup (effects->shaderstable, "lumamap0"); shader = g_hash_table_lookup (effects->shaderstable, "lumamap0");
if (!shader) { if (!shader) {
shader = gst_gl_shader_new (); shader = gst_gl_shader_new (GST_GL_FILTER (effects)->display);
g_hash_table_insert (effects->shaderstable, "lumamap0", shader); g_hash_table_insert (effects->shaderstable, "lumamap0", shader);
} }

86
gst/gl/effects/gstgleffectmirror.c
View file

@ -20,57 +20,69 @@
#include <gstgleffects.h> #include <gstgleffects.h>
#define USING_OPENGL(display) (gst_gl_display_get_gl_api_unlocked (display) & GST_GL_API_OPENGL)
#define USING_OPENGL3(display) (gst_gl_display_get_gl_api_unlocked (display) & GST_GL_API_OPENGL3)
#define USING_GLES(display) (gst_gl_display_get_gl_api_unlocked (display) & GST_GL_API_GLES)
#define USING_GLES2(display) (gst_gl_display_get_gl_api_unlocked (display) & GST_GL_API_GLES2)
#define USING_GLES3(display) (gst_gl_display_get_gl_api_unlocked (display) & GST_GL_API_GLES3)
static void static void
gst_gl_effects_mirror_callback (gint width, gint height, guint texture, gst_gl_effects_mirror_callback (gint width, gint height, guint texture,
gpointer data) gpointer data)
{ {
GstGLEffects *effects = GST_GL_EFFECTS (data); GstGLEffects *effects = GST_GL_EFFECTS (data);
GstGLFilter *filter = GST_GL_FILTER (effects);
GstGLShader *shader; GstGLShader *shader;
shader = g_hash_table_lookup (effects->shaderstable, "mirror0"); shader = g_hash_table_lookup (effects->shaderstable, "mirror0");
if (!shader) { if (!shader) {
shader = gst_gl_shader_new (); shader = gst_gl_shader_new (filter->display);
g_hash_table_insert (effects->shaderstable, "mirror0", shader); g_hash_table_insert (effects->shaderstable, "mirror0", shader);
#ifdef OPENGL_ES2 #if HAVE_GLES2
if (shader) { if (USING_GLES2 (filter->display)) {
GError *error = NULL; if (shader) {
gst_gl_shader_set_vertex_source (shader, vertex_shader_source); GError *error = NULL;
gst_gl_shader_set_fragment_source (shader, mirror_fragment_source); gst_gl_shader_set_vertex_source (shader, vertex_shader_source);
gst_gl_shader_set_fragment_source (shader,
mirror_fragment_source_gles2);
gst_gl_shader_compile (shader, &error); gst_gl_shader_compile (shader, &error);
if (error) { if (error) {
gst_gl_display_set_error (GST_GL_FILTER (effects)->display, gst_gl_display_set_error (GST_GL_FILTER (effects)->display,
"Failed to initialize mirror shader, %s", error->message); "Failed to initialize mirror shader, %s", error->message);
g_error_free (error); g_error_free (error);
error = NULL; error = NULL;
gst_gl_shader_use (NULL); gst_gl_shader_use (NULL);
GST_ELEMENT_ERROR (effects, RESOURCE, NOT_FOUND, GST_ELEMENT_ERROR (effects, RESOURCE, NOT_FOUND,
GST_GL_DISPLAY_ERR_MSG (GST_GL_FILTER (effects)->display), (NULL)); GST_GL_DISPLAY_ERR_MSG (GST_GL_FILTER (effects)->display),
} else { (NULL));
effects->draw_attr_position_loc = } else {
gst_gl_shader_get_attribute_location (shader, "a_position"); effects->draw_attr_position_loc =
effects->draw_attr_texture_loc = gst_gl_shader_get_attribute_location (shader, "a_position");
gst_gl_shader_get_attribute_location (shader, "a_texCoord"); effects->draw_attr_texture_loc =
gst_gl_shader_get_attribute_location (shader, "a_texCoord");
}
} }
} }
#endif #endif
} #if HAVE_OPENGL
#ifndef OPENGL_ES2 if (USING_OPENGL (filter->display)) {
if (!gst_gl_shader_compile_and_check (shader, if (!gst_gl_shader_compile_and_check (shader,
mirror_fragment_source, GST_GL_SHADER_FRAGMENT_SOURCE)) { mirror_fragment_source_opengl, GST_GL_SHADER_FRAGMENT_SOURCE)) {
gst_gl_display_set_error (GST_GL_FILTER (effects)->display, gst_gl_display_set_error (GST_GL_FILTER (effects)->display,
"Failed to initialize mirror shader"); "Failed to initialize mirror shader");
GST_ELEMENT_ERROR (effects, RESOURCE, NOT_FOUND, GST_ELEMENT_ERROR (effects, RESOURCE, NOT_FOUND,
GST_GL_DISPLAY_ERR_MSG (GST_GL_FILTER (effects)->display), (NULL)); GST_GL_DISPLAY_ERR_MSG (GST_GL_FILTER (effects)->display), (NULL));
return; return;
} }
glMatrixMode (GL_PROJECTION); glMatrixMode (GL_PROJECTION);
glLoadIdentity (); glLoadIdentity ();
}
#endif #endif
}
gst_gl_shader_use (shader); gst_gl_shader_use (shader);
@ -80,9 +92,11 @@ gst_gl_effects_mirror_callback (gint width, gint height, guint texture,
gst_gl_shader_set_uniform_1i (shader, "tex", 0); gst_gl_shader_set_uniform_1i (shader, "tex", 0);
#ifndef OPENGL_ES2 #if HAVE_OPENGL
gst_gl_shader_set_uniform_1f (shader, "width", (gfloat) width / 2.0f); if (USING_OPENGL (filter->display)) {
gst_gl_shader_set_uniform_1f (shader, "height", (gfloat) height / 2.0f); gst_gl_shader_set_uniform_1f (shader, "width", (gfloat) width / 2.0f);
gst_gl_shader_set_uniform_1f (shader, "height", (gfloat) height / 2.0f);
}
#endif #endif
gst_gl_effects_draw_texture (effects, texture, width, height); gst_gl_effects_draw_texture (effects, texture, width, height);

2
gst/gl/effects/gstgleffectrgbtocurve.c
View file

@ -31,7 +31,7 @@ gst_gl_effects_rgb_to_curve (GstGLEffects * effects,
shader = g_hash_table_lookup (effects->shaderstable, "rgbmap0"); shader = g_hash_table_lookup (effects->shaderstable, "rgbmap0");
if (!shader) { if (!shader) {
shader = gst_gl_shader_new (); shader = gst_gl_shader_new (GST_GL_FILTER (effects)->display);
g_hash_table_insert (effects->shaderstable, "rgbmap0", shader); g_hash_table_insert (effects->shaderstable, "rgbmap0", shader);
} }

2
gst/gl/effects/gstgleffectsin.c
View file

@ -31,7 +31,7 @@ gst_gl_effects_sin_callback (gint width, gint height, guint texture,
shader = g_hash_table_lookup (effects->shaderstable, "sin0"); shader = g_hash_table_lookup (effects->shaderstable, "sin0");
if (!shader) { if (!shader) {
shader = gst_gl_shader_new (); shader = gst_gl_shader_new (GST_GL_FILTER (effects)->display);
g_hash_table_insert (effects->shaderstable, "sin0", shader); g_hash_table_insert (effects->shaderstable, "sin0", shader);
} }

2
gst/gl/effects/gstgleffectsquare.c
View file

@ -31,7 +31,7 @@ gst_gl_effects_square_callback (gint width, gint height, guint texture,
shader = g_hash_table_lookup (effects->shaderstable, "square0"); shader = g_hash_table_lookup (effects->shaderstable, "square0");
if (!shader) { if (!shader) {
shader = gst_gl_shader_new (); shader = gst_gl_shader_new (GST_GL_FILTER (effects)->display);
g_hash_table_insert (effects->shaderstable, "square0", shader); g_hash_table_insert (effects->shaderstable, "square0", shader);
} }

88
gst/gl/effects/gstgleffectsqueeze.c
View file

@ -20,57 +20,69 @@
#include <gstgleffects.h> #include <gstgleffects.h>
#define USING_OPENGL(display) (gst_gl_display_get_gl_api_unlocked (display) & GST_GL_API_OPENGL)
#define USING_OPENGL3(display) (gst_gl_display_get_gl_api_unlocked (display) & GST_GL_API_OPENGL3)
#define USING_GLES(display) (gst_gl_display_get_gl_api_unlocked (display) & GST_GL_API_GLES)
#define USING_GLES2(display) (gst_gl_display_get_gl_api_unlocked (display) & GST_GL_API_GLES2)
#define USING_GLES3(display) (gst_gl_display_get_gl_api_unlocked (display) & GST_GL_API_GLES3)
static void static void
gst_gl_effects_squeeze_callback (gint width, gint height, guint texture, gst_gl_effects_squeeze_callback (gint width, gint height, guint texture,
gpointer data) gpointer data)
{ {
GstGLEffects *effects = GST_GL_EFFECTS (data); GstGLEffects *effects = GST_GL_EFFECTS (data);
GstGLFilter *filter = GST_GL_FILTER (effects);
GstGLShader *shader; GstGLShader *shader;
shader = g_hash_table_lookup (effects->shaderstable, "squeeze0"); shader = g_hash_table_lookup (effects->shaderstable, "squeeze0");
if (!shader) { if (!shader) {
shader = gst_gl_shader_new (); shader = gst_gl_shader_new (filter->display);
g_hash_table_insert (effects->shaderstable, "squeeze0", shader); g_hash_table_insert (effects->shaderstable, "squeeze0", shader);
#ifdef OPENGL_ES2 #if HAVE_GLES2
if (shader) { if (USING_GLES2 (filter->display)) {
GError *error = NULL; if (shader) {
gst_gl_shader_set_vertex_source (shader, vertex_shader_source); GError *error = NULL;
gst_gl_shader_set_fragment_source (shader, squeeze_fragment_source); gst_gl_shader_set_vertex_source (shader, vertex_shader_source);
gst_gl_shader_set_fragment_source (shader,
squeeze_fragment_source_gles2);
gst_gl_shader_compile (shader, &error); gst_gl_shader_compile (shader, &error);
if (error) { if (error) {
GstGLFilter *filter = GST_GL_FILTER (effects); GstGLFilter *filter = GST_GL_FILTER (effects);
gst_gl_display_set_error (filter->display, gst_gl_display_set_error (filter->display,
"Failed to initialize squeeze shader, %s", error->message); "Failed to initialize squeeze shader, %s", error->message);
g_error_free (error); g_error_free (error);
error = NULL; error = NULL;
gst_gl_shader_use (NULL); gst_gl_shader_use (NULL);
GST_ELEMENT_ERROR (effects, RESOURCE, NOT_FOUND, GST_ELEMENT_ERROR (effects, RESOURCE, NOT_FOUND,
GST_GL_DISPLAY_ERR_MSG (GST_GL_FILTER (effects)->display), (NULL)); GST_GL_DISPLAY_ERR_MSG (GST_GL_FILTER (effects)->display),
} else { (NULL));
effects->draw_attr_position_loc = } else {
gst_gl_shader_get_attribute_location (shader, "a_position"); effects->draw_attr_position_loc =
effects->draw_attr_texture_loc = gst_gl_shader_get_attribute_location (shader, "a_position");
gst_gl_shader_get_attribute_location (shader, "a_texCoord"); effects->draw_attr_texture_loc =
gst_gl_shader_get_attribute_location (shader, "a_texCoord");
}
} }
} }
#endif #endif
} #if HAVE_OPENGL
#ifndef OPENGL_ES2 if (USING_OPENGL (filter->display)) {
if (!gst_gl_shader_compile_and_check (shader, if (!gst_gl_shader_compile_and_check (shader,
squeeze_fragment_source, GST_GL_SHADER_FRAGMENT_SOURCE)) { squeeze_fragment_source_opengl, GST_GL_SHADER_FRAGMENT_SOURCE)) {
gst_gl_display_set_error (GST_GL_FILTER (effects)->display, gst_gl_display_set_error (GST_GL_FILTER (effects)->display,
"Failed to initialize squeeze shader"); "Failed to initialize squeeze shader");
GST_ELEMENT_ERROR (effects, RESOURCE, NOT_FOUND, GST_ELEMENT_ERROR (effects, RESOURCE, NOT_FOUND,
GST_GL_DISPLAY_ERR_MSG (GST_GL_FILTER (effects)->display), (NULL)); GST_GL_DISPLAY_ERR_MSG (GST_GL_FILTER (effects)->display), (NULL));
return; return;
} }
glMatrixMode (GL_PROJECTION); glMatrixMode (GL_PROJECTION);
glLoadIdentity (); glLoadIdentity ();
}
#endif #endif
}
gst_gl_shader_use (shader); gst_gl_shader_use (shader);
@ -80,9 +92,11 @@ gst_gl_effects_squeeze_callback (gint width, gint height, guint texture,
gst_gl_shader_set_uniform_1i (shader, "tex", 0); gst_gl_shader_set_uniform_1i (shader, "tex", 0);
#ifndef OPENGL_ES2 #if HAVE_GLES2
gst_gl_shader_set_uniform_1f (shader, "width", (gfloat) width / 2.0f); if (USING_GLES2 (filter->display)) {
gst_gl_shader_set_uniform_1f (shader, "height", (gfloat) height / 2.0f); gst_gl_shader_set_uniform_1f (shader, "width", (gfloat) width / 2.0f);
gst_gl_shader_set_uniform_1f (shader, "height", (gfloat) height / 2.0f);
}
#endif #endif
gst_gl_effects_draw_texture (effects, texture, width, height); gst_gl_effects_draw_texture (effects, texture, width, height);

44
gst/gl/effects/gstgleffectssources.c
View file

@ -80,18 +80,12 @@ const gchar *identity_fragment_source =
"}"; "}";
/* Mirror effect */ /* Mirror effect */
const gchar *mirror_fragment_source = #if HAVE_OPENGL
#ifndef OPENGL_ES2 const gchar *mirror_fragment_source_opengl =
"#extension GL_ARB_texture_rectangle : enable\n" "#extension GL_ARB_texture_rectangle : enable\n"
"uniform sampler2DRect tex;" "uniform sampler2DRect tex;"
"uniform float width, height;" "uniform float width, height;"
#else
"precision mediump float;"
"varying vec2 v_texCoord;"
"uniform sampler2D tex;"
#endif
"void main () {" "void main () {"
#ifndef OPENGL_ES2
" vec2 tex_size = vec2 (width, height);" " vec2 tex_size = vec2 (width, height);"
" vec2 texturecoord = gl_TexCoord[0].xy;" " vec2 texturecoord = gl_TexCoord[0].xy;"
" vec2 normcoord;" " vec2 normcoord;"
@ -100,29 +94,29 @@ const gchar *mirror_fragment_source =
" texturecoord = (normcoord + 1.0) * tex_size;" " texturecoord = (normcoord + 1.0) * tex_size;"
" vec4 color = texture2DRect (tex, texturecoord);" " vec4 color = texture2DRect (tex, texturecoord);"
" gl_FragColor = color * gl_Color;" " gl_FragColor = color * gl_Color;"
#else "}";
#endif
#if HAVE_GLES2
const gchar *mirror_fragment_source_gles2 =
"precision mediump float;"
"varying vec2 v_texCoord;"
"uniform sampler2D tex;"
"void main () {"
" vec2 texturecoord = v_texCoord.xy;" " vec2 texturecoord = v_texCoord.xy;"
" float normcoord = texturecoord.x - 0.5;" " float normcoord = texturecoord.x - 0.5;"
" normcoord *= sign (normcoord);" " normcoord *= sign (normcoord);"
" texturecoord.x = (normcoord + 0.5);" " texturecoord.x = (normcoord + 0.5);"
" gl_FragColor = texture2D (tex, texturecoord);" " gl_FragColor = texture2D (tex, texturecoord);"
#endif
"}"; "}";
#endif
/* Squeeze effect */ /* Squeeze effect */
const gchar *squeeze_fragment_source = #if HAVE_OPENGL
#ifndef OPENGL_ES2 const gchar *squeeze_fragment_source_opengl =
"#extension GL_ARB_texture_rectangle : enable\n" "#extension GL_ARB_texture_rectangle : enable\n"
"uniform sampler2DRect tex;" "uniform sampler2DRect tex;"
"uniform float width, height;" "uniform float width, height;"
#else
"precision mediump float;"
"varying vec2 v_texCoord;"
"uniform sampler2D tex;"
#endif
"void main () {" "void main () {"
#ifndef OPENGL_ES2
" vec2 tex_size = vec2 (width, height);" " vec2 tex_size = vec2 (width, height);"
" vec2 texturecoord = gl_TexCoord[0].xy;" " vec2 texturecoord = gl_TexCoord[0].xy;"
" vec2 normcoord;" " vec2 normcoord;"
@ -133,7 +127,14 @@ const gchar *squeeze_fragment_source =
" texturecoord = (normcoord + 1.0) * tex_size;" " texturecoord = (normcoord + 1.0) * tex_size;"
" vec4 color = texture2DRect (tex, texturecoord); " " vec4 color = texture2DRect (tex, texturecoord); "
" gl_FragColor = color * gl_Color;" " gl_FragColor = color * gl_Color;"
#else "}";
#endif
#if HAVE_GLES2
const gchar *squeeze_fragment_source_gles2 =
"precision mediump float;"
"varying vec2 v_texCoord;"
"uniform sampler2D tex;"
"void main () {"
" vec2 texturecoord = v_texCoord.xy;" " vec2 texturecoord = v_texCoord.xy;"
" vec2 normcoord = texturecoord - 0.5;" " vec2 normcoord = texturecoord - 0.5;"
" float r = length (normcoord);" " float r = length (normcoord);"
@ -141,9 +142,8 @@ const gchar *squeeze_fragment_source =
" normcoord = normcoord / r;" " normcoord = normcoord / r;"
" texturecoord = (normcoord + 0.5);" " texturecoord = (normcoord + 0.5);"
" gl_FragColor = texture2D (tex, texturecoord);" " gl_FragColor = texture2D (tex, texturecoord);"
#endif
"}"; "}";
#endif
/* Stretch Effect */ /* Stretch Effect */
const gchar *stretch_fragment_source = const gchar *stretch_fragment_source =

14
gst/gl/effects/gstgleffectssources.h
View file

@ -21,10 +21,20 @@
#ifndef __GST_GL_EFFECTS_SOURCES_H__ #ifndef __GST_GL_EFFECTS_SOURCES_H__
#define __GST_GL_EFFECTS_SOURCES_H__ #define __GST_GL_EFFECTS_SOURCES_H__
#if HAVE_CONFIG_H
#include "config.h"
#endif
extern const gchar *vertex_shader_source; extern const gchar *vertex_shader_source;
extern const gchar *identity_fragment_source; extern const gchar *identity_fragment_source;
extern const gchar *mirror_fragment_source; #if HAVE_OPENGL
extern const gchar *squeeze_fragment_source; extern const gchar *mirror_fragment_source_opengl;
extern const gchar *squeeze_fragment_source_opengl;
#endif
#if HAVE_GLES2
extern const gchar *mirror_fragment_source_gles2;
extern const gchar *squeeze_fragment_source_gles2;
#endif
extern const gchar *stretch_fragment_source; extern const gchar *stretch_fragment_source;
extern const gchar *tunnel_fragment_source; extern const gchar *tunnel_fragment_source;
extern const gchar *fisheye_fragment_source; extern const gchar *fisheye_fragment_source;

2
gst/gl/effects/gstgleffectstretch.c
View file

@ -31,7 +31,7 @@ gst_gl_effects_stretch_callback (gint width, gint height, guint texture,
shader = g_hash_table_lookup (effects->shaderstable, "stretch0"); shader = g_hash_table_lookup (effects->shaderstable, "stretch0");
if (!shader) { if (!shader) {
shader = gst_gl_shader_new (); shader = gst_gl_shader_new (GST_GL_FILTER (effects)->display);
g_hash_table_insert (effects->shaderstable, "stretch0", shader); g_hash_table_insert (effects->shaderstable, "stretch0", shader);
} }

2
gst/gl/effects/gstgleffecttunnel.c
View file

@ -31,7 +31,7 @@ gst_gl_effects_tunnel_callback (gint width, gint height, guint texture,
shader = g_hash_table_lookup (effects->shaderstable, "tunnel0"); shader = g_hash_table_lookup (effects->shaderstable, "tunnel0");
if (!shader) { if (!shader) {
shader = gst_gl_shader_new (); shader = gst_gl_shader_new (GST_GL_FILTER (effects)->display);
g_hash_table_insert (effects->shaderstable, "tunnel0", shader); g_hash_table_insert (effects->shaderstable, "tunnel0", shader);
} }

2
gst/gl/effects/gstgleffecttwirl.c
View file

@ -31,7 +31,7 @@ gst_gl_effects_twirl_callback (gint width, gint height, guint texture,
shader = g_hash_table_lookup (effects->shaderstable, "twirl0"); shader = g_hash_table_lookup (effects->shaderstable, "twirl0");
if (!shader) { if (!shader) {
shader = gst_gl_shader_new (); shader = gst_gl_shader_new (GST_GL_FILTER (effects)->display);
g_hash_table_insert (effects->shaderstable, "twirl0", shader); g_hash_table_insert (effects->shaderstable, "twirl0", shader);
} }

14
gst/gl/effects/gstgleffectxray.c
View file

@ -45,7 +45,7 @@ gst_gl_effects_xray_step_two (gint width, gint height, guint texture,
shader = g_hash_table_lookup (effects->shaderstable, "xray1"); shader = g_hash_table_lookup (effects->shaderstable, "xray1");
if (!shader) { if (!shader) {
shader = gst_gl_shader_new (); shader = gst_gl_shader_new (GST_GL_FILTER (effects)->display);
g_hash_table_insert (effects->shaderstable, "xray1", shader); g_hash_table_insert (effects->shaderstable, "xray1", shader);
} }
@ -89,7 +89,7 @@ gst_gl_effects_xray_step_three (gint width, gint height, guint texture,
shader = g_hash_table_lookup (effects->shaderstable, "xray2"); shader = g_hash_table_lookup (effects->shaderstable, "xray2");
if (!shader) { if (!shader) {
shader = gst_gl_shader_new (); shader = gst_gl_shader_new (GST_GL_FILTER (effects)->display);
g_hash_table_insert (effects->shaderstable, "xray2", shader); g_hash_table_insert (effects->shaderstable, "xray2", shader);
} }
@ -129,7 +129,7 @@ gst_gl_effects_xray_desaturate (gint width, gint height, guint texture,
shader = g_hash_table_lookup (effects->shaderstable, "xray_desat"); shader = g_hash_table_lookup (effects->shaderstable, "xray_desat");
if (!shader) { if (!shader) {
shader = gst_gl_shader_new (); shader = gst_gl_shader_new (GST_GL_FILTER (effects)->display);
g_hash_table_insert (effects->shaderstable, "xray_desat", shader); g_hash_table_insert (effects->shaderstable, "xray_desat", shader);
} }
@ -166,7 +166,7 @@ gst_gl_effects_xray_sobel_hconv (gint width, gint height, guint texture,
shader = g_hash_table_lookup (effects->shaderstable, "xray_sob_hconv"); shader = g_hash_table_lookup (effects->shaderstable, "xray_sob_hconv");
if (!shader) { if (!shader) {
shader = gst_gl_shader_new (); shader = gst_gl_shader_new (GST_GL_FILTER (effects)->display);
g_hash_table_insert (effects->shaderstable, "xray_sob_hconv", shader); g_hash_table_insert (effects->shaderstable, "xray_sob_hconv", shader);
} }
@ -203,7 +203,7 @@ gst_gl_effects_xray_sobel_vconv (gint width, gint height, guint texture,
shader = g_hash_table_lookup (effects->shaderstable, "xray_sob_vconv"); shader = g_hash_table_lookup (effects->shaderstable, "xray_sob_vconv");
if (!shader) { if (!shader) {
shader = gst_gl_shader_new (); shader = gst_gl_shader_new (GST_GL_FILTER (effects)->display);
g_hash_table_insert (effects->shaderstable, "xray_sob_vconv", shader); g_hash_table_insert (effects->shaderstable, "xray_sob_vconv", shader);
} }
@ -240,7 +240,7 @@ gst_gl_effects_xray_sobel_length (gint width, gint height, guint texture,
shader = g_hash_table_lookup (effects->shaderstable, "xray_sob_len"); shader = g_hash_table_lookup (effects->shaderstable, "xray_sob_len");
if (!shader) { if (!shader) {
shader = gst_gl_shader_new (); shader = gst_gl_shader_new (GST_GL_FILTER (effects)->display);
g_hash_table_insert (effects->shaderstable, "xray_sob_len", shader); g_hash_table_insert (effects->shaderstable, "xray_sob_len", shader);
} }
@ -280,7 +280,7 @@ gst_gl_effects_xray_step_five (gint width, gint height, guint texture,
shader = g_hash_table_lookup (effects->shaderstable, "xray4"); shader = g_hash_table_lookup (effects->shaderstable, "xray4");
if (!shader) { if (!shader) {
shader = gst_gl_shader_new (); shader = gst_gl_shader_new (GST_GL_FILTER (effects)->display);
g_hash_table_insert (effects->shaderstable, "xray4", shader); g_hash_table_insert (effects->shaderstable, "xray4", shader);
} }

207
gst/gl/gltestsrc.c
View file

@ -25,8 +25,6 @@
#include "gltestsrc.h" #include "gltestsrc.h"
#include <string.h> #include <string.h>
#include <stdlib.h> #include <stdlib.h>
#include <math.h> #include <math.h>
@ -85,135 +83,148 @@ gst_gl_test_src_unicolor (GstGLTestSrc * v, GstBuffer * buffer, int w,
void void
gst_gl_test_src_smpte (GstGLTestSrc * v, GstBuffer * buffer, int w, int h) gst_gl_test_src_smpte (GstGLTestSrc * v, GstBuffer * buffer, int w, int h)
{ {
#if HAVE_OPENGL
int i; int i;
glClearColor (0.0, 0.0, 0.0, 1.0); if (gst_gl_display_get_gl_api_unlocked (v->display) & GST_GL_API_OPENGL) {
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glDisable (GL_CULL_FACE); glClearColor (0.0, 0.0, 0.0, 1.0);
glDisable (GL_TEXTURE_RECTANGLE_ARB); glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode (GL_PROJECTION); glDisable (GL_CULL_FACE);
glLoadIdentity (); glDisable (GL_TEXTURE_RECTANGLE_ARB);
for (i = 0; i < 7; i++) { glMatrixMode (GL_PROJECTION);
glColor4f (vts_colors[i].R * (1 / 255.0f), vts_colors[i].G * (1 / 255.0f), glLoadIdentity ();
vts_colors[i].B * (1 / 255.0f), 1.0f);
glBegin (GL_QUADS);
glVertex3f (-1.0f + i * (2.0f / 7.0f), -1.0f + 2.0 * (2.0f / 3.0f), 0);
glVertex3f (-1.0f + (i + 1.0f) * (2.0f / 7.0f),
-1.0f + 2.0f * (2.0f / 3.0f), 0);
glVertex3f (-1.0f + (i + 1.0f) * (2.0f / 7.0f), -1.0f, 0);
glVertex3f (-1.0f + i * (2.0f / 7.0f), -1.0f, 0);
glEnd ();
}
for (i = 0; i < 7; i++) { for (i = 0; i < 7; i++) {
int k; glColor4f (vts_colors[i].R * (1 / 255.0f), vts_colors[i].G * (1 / 255.0f),
vts_colors[i].B * (1 / 255.0f), 1.0f);
if (i & 1) { glBegin (GL_QUADS);
k = 7; glVertex3f (-1.0f + i * (2.0f / 7.0f), -1.0f + 2.0 * (2.0f / 3.0f), 0);
} else { glVertex3f (-1.0f + (i + 1.0f) * (2.0f / 7.0f),
k = 6 - i; -1.0f + 2.0f * (2.0f / 3.0f), 0);
glVertex3f (-1.0f + (i + 1.0f) * (2.0f / 7.0f), -1.0f, 0);
glVertex3f (-1.0f + i * (2.0f / 7.0f), -1.0f, 0);
glEnd ();
} }
glColor4f (vts_colors[k].R * (1 / 255.0f), vts_colors[k].G * (1 / 255.0f), for (i = 0; i < 7; i++) {
vts_colors[k].B * (1 / 255.0f), 1.0f); int k;
glBegin (GL_QUADS);
glVertex3f (-1.0f + i * (2.0f / 7.0f), -1.0f + 2.0f * (3.0f / 4.0f), 0);
glVertex3f (-1.0f + (i + 1) * (2.0f / 7.0f), -1.0f + 2.0f * (3.0f / 4.0f),
0);
glVertex3f (-1.0f + (i + 1) * (2.0f / 7.0f), -1.0f + 2.0f * (2.0f / 3.0f),
0);
glVertex3f (-1.0f + i * (2.0f / 7.0f), -1.0f + 2.0f * (2.0f / 3.0f), 0);
glEnd ();
}
for (i = 0; i < 3; i++) { if (i & 1) {
int k; k = 7;
} else {
k = 6 - i;
}
if (i == 0) { glColor4f (vts_colors[k].R * (1 / 255.0f), vts_colors[k].G * (1 / 255.0f),
k = 8; vts_colors[k].B * (1 / 255.0f), 1.0f);
} else if (i == 1) { glBegin (GL_QUADS);
k = 0; glVertex3f (-1.0f + i * (2.0f / 7.0f), -1.0f + 2.0f * (3.0f / 4.0f), 0);
} else { glVertex3f (-1.0f + (i + 1) * (2.0f / 7.0f), -1.0f + 2.0f * (3.0f / 4.0f),
k = 9; 0);
glVertex3f (-1.0f + (i + 1) * (2.0f / 7.0f), -1.0f + 2.0f * (2.0f / 3.0f),
0);
glVertex3f (-1.0f + i * (2.0f / 7.0f), -1.0f + 2.0f * (2.0f / 3.0f), 0);
glEnd ();
} }
glColor4f (vts_colors[k].R * (1 / 255.0f), vts_colors[k].G * (1 / 255.0f), for (i = 0; i < 3; i++) {
vts_colors[k].B * (1 / 255.0f), 1.0f); int k;
glBegin (GL_QUADS);
glVertex3f (-1.0f + i * (2.0f / 6.0f), -1.0f + 2.0f * 1, 0);
glVertex3f (-1.0f + (i + 1) * (2.0f / 6.0f), -1.0f + 2.0f * 1, 0);
glVertex3f (-1.0f + (i + 1) * (2.0f / 6.0f), -1.0f + 2.0f * (3.0f / 4.0f),
0);
glVertex3f (-1.0f + i * (2.0f / 6.0f), -1.0f + 2.0f * (3.0f / 4.0f), 0);
glEnd ();
}
for (i = 0; i < 3; i++) { if (i == 0) {
int k; k = 8;
} else if (i == 1) {
k = 0;
} else {
k = 9;
}
if (i == 0) { glColor4f (vts_colors[k].R * (1 / 255.0f), vts_colors[k].G * (1 / 255.0f),
k = COLOR_SUPER_BLACK; vts_colors[k].B * (1 / 255.0f), 1.0f);
} else if (i == 1) { glBegin (GL_QUADS);
k = COLOR_BLACK; glVertex3f (-1.0f + i * (2.0f / 6.0f), -1.0f + 2.0f * 1, 0);
} else { glVertex3f (-1.0f + (i + 1) * (2.0f / 6.0f), -1.0f + 2.0f * 1, 0);
k = COLOR_DARK_GREY; glVertex3f (-1.0f + (i + 1) * (2.0f / 6.0f), -1.0f + 2.0f * (3.0f / 4.0f),
0);
glVertex3f (-1.0f + i * (2.0f / 6.0f), -1.0f + 2.0f * (3.0f / 4.0f), 0);
glEnd ();
} }
glColor4f (vts_colors[k].R * (1 / 255.0f), vts_colors[k].G * (1 / 255.0f), for (i = 0; i < 3; i++) {
vts_colors[k].B * (1 / 255.0f), 1.0f); int k;
if (i == 0) {
k = COLOR_SUPER_BLACK;
} else if (i == 1) {
k = COLOR_BLACK;
} else {
k = COLOR_DARK_GREY;
}
glColor4f (vts_colors[k].R * (1 / 255.0f), vts_colors[k].G * (1 / 255.0f),
vts_colors[k].B * (1 / 255.0f), 1.0f);
glBegin (GL_QUADS);
glVertex3f (-1.0f + 2.0f * (0.5f + i * (1.0f / 12.0f)), -1.0 + 2.0f * 1,
0);
glVertex3f (-1.0f + 2.0f * (0.5f + (i + 1) * (1.0f / 12.0f)),
-1.0f + 2.0f * 1, 0);
glVertex3f (-1.0f + 2.0f * (0.5f + (i + 1) * (1.0f / 12.0f)),
-1.0f + 2.0f * (3.0f / 4.0f), 0);
glVertex3f (-1.0f + 2.0f * (0.5f + i * (1.0f / 12.0f)),
-1.0f + 2.0f * (3.0f / 4.0f), 0);
glEnd ();
}
glColor4f (1.0, 1.0, 1.0, 1.0);
glBegin (GL_QUADS); glBegin (GL_QUADS);
glVertex3f (-1.0f + 2.0f * (0.5f + i * (1.0f / 12.0f)), -1.0 + 2.0f * 1, 0); glVertex3f (-1.0 + 2.0 * (0.75), -1.0 + 2.0 * 1, 0);
glVertex3f (-1.0f + 2.0f * (0.5f + (i + 1) * (1.0f / 12.0f)), glVertex3f (-1.0 + 2.0 * (1.0), -1.0 + 2.0 * 1, 0);
-1.0f + 2.0f * 1, 0); glVertex3f (-1.0 + 2.0 * (1.0), -1.0 + 2.0 * (3.0 / 4.0), 0);
glVertex3f (-1.0f + 2.0f * (0.5f + (i + 1) * (1.0f / 12.0f)), glVertex3f (-1.0 + 2.0 * (0.75), -1.0 + 2.0 * (3.0 / 4.0), 0);
-1.0f + 2.0f * (3.0f / 4.0f), 0);
glVertex3f (-1.0f + 2.0f * (0.5f + i * (1.0f / 12.0f)),
-1.0f + 2.0f * (3.0f / 4.0f), 0);
glEnd (); glEnd ();
} }
#endif
glColor4f (1.0, 1.0, 1.0, 1.0);
glBegin (GL_QUADS);
glVertex3f (-1.0 + 2.0 * (0.75), -1.0 + 2.0 * 1, 0);
glVertex3f (-1.0 + 2.0 * (1.0), -1.0 + 2.0 * 1, 0);
glVertex3f (-1.0 + 2.0 * (1.0), -1.0 + 2.0 * (3.0 / 4.0), 0);
glVertex3f (-1.0 + 2.0 * (0.75), -1.0 + 2.0 * (3.0 / 4.0), 0);
glEnd ();
} }
void void
gst_gl_test_src_snow (GstGLTestSrc * v, GstBuffer * buffer, int w, int h) gst_gl_test_src_snow (GstGLTestSrc * v, GstBuffer * buffer, int w, int h)
{ {
glClearColor (0.0, 0.0, 0.0, 1.0); #if HAVE_OPENGL
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); if (gst_gl_display_get_gl_api_unlocked (v->display) & GST_GL_API_OPENGL) {
glClearColor (0.0, 0.0, 0.0, 1.0);
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode (GL_PROJECTION); glMatrixMode (GL_PROJECTION);
glLoadIdentity (); glLoadIdentity ();
glMatrixMode (GL_MODELVIEW); glMatrixMode (GL_MODELVIEW);
glLoadIdentity (); glLoadIdentity ();
/* FIXME snow requires a fragment shader. Please write. */ /* FIXME snow requires a fragment shader. Please write. */
glColor4f (0.5, 0.5, 0.5, 1.0); glColor4f (0.5, 0.5, 0.5, 1.0);
glBegin (GL_QUADS); glBegin (GL_QUADS);
glVertex3f (-1.0 + 2.0 * (0.0), -1.0 + 2.0 * 1, 0); glVertex3f (-1.0 + 2.0 * (0.0), -1.0 + 2.0 * 1, 0);
glVertex3f (-1.0 + 2.0 * (1.0), -1.0 + 2.0 * 1, 0); glVertex3f (-1.0 + 2.0 * (1.0), -1.0 + 2.0 * 1, 0);
glVertex3f (-1.0 + 2.0 * (1.0), -1.0 + 2.0 * (0.0), 0); glVertex3f (-1.0 + 2.0 * (1.0), -1.0 + 2.0 * (0.0), 0);
glVertex3f (-1.0 + 2.0 * (0.0), -1.0 + 2.0 * (0.0), 0); glVertex3f (-1.0 + 2.0 * (0.0), -1.0 + 2.0 * (0.0), 0);
glEnd (); glEnd ();
}
#endif
} }
static void static void
gst_gl_test_src_unicolor (GstGLTestSrc * v, GstBuffer * buffer, int w, gst_gl_test_src_unicolor (GstGLTestSrc * v, GstBuffer * buffer, int w,
int h, const struct vts_color_struct *color) int h, const struct vts_color_struct *color)
{ {
glClearColor (color->R * (1 / 255.0f), color->G * (1 / 255.0f), #if HAVE_OPENGL
color->B * (1 / 255.0f), 1.0f); if (gst_gl_display_get_gl_api_unlocked (v->display) & GST_GL_API_OPENGL) {
glClear (GL_COLOR_BUFFER_BIT); glClearColor (color->R * (1 / 255.0f), color->G * (1 / 255.0f),
color->B * (1 / 255.0f), 1.0f);
glClear (GL_COLOR_BUFFER_BIT);
}
#endif
} }
void void

2
gst/gl/gstgldifferencematte.c
View file

@ -97,7 +97,7 @@ gst_gl_differencematte_init_gl_resources (GstGLFilter * filter)
GL_CLAMP_TO_EDGE); GL_CLAMP_TO_EDGE);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T,
GL_CLAMP_TO_EDGE); GL_CLAMP_TO_EDGE);
differencematte->shader[i] = gst_gl_shader_new (); differencematte->shader[i] = gst_gl_shader_new (filter->display);
} }
if (!gst_gl_shader_compile_and_check (differencematte->shader[0], if (!gst_gl_shader_compile_and_check (differencematte->shader[0],

147
gst/gl/gstgleffects.c
View file

@ -97,7 +97,7 @@ gst_gl_effects_effect_get_type (void)
{GST_GL_EFFECT_IDENTITY, "Do nothing Effect", "identity"}, {GST_GL_EFFECT_IDENTITY, "Do nothing Effect", "identity"},
{GST_GL_EFFECT_MIRROR, "Mirror Effect", "mirror"}, {GST_GL_EFFECT_MIRROR, "Mirror Effect", "mirror"},
{GST_GL_EFFECT_SQUEEZE, "Squeeze Effect", "squeeze"}, {GST_GL_EFFECT_SQUEEZE, "Squeeze Effect", "squeeze"},
#ifndef OPENGL_ES2 #if HAVE_OPENGL
{GST_GL_EFFECT_STRETCH, "Stretch Effect", "stretch"}, {GST_GL_EFFECT_STRETCH, "Stretch Effect", "stretch"},
{GST_GL_EFFECT_FISHEYE, "FishEye Effect", "fisheye"}, {GST_GL_EFFECT_FISHEYE, "FishEye Effect", "fisheye"},
{GST_GL_EFFECT_TWIRL, "Twirl Effect", "twirl"}, {GST_GL_EFFECT_TWIRL, "Twirl Effect", "twirl"},
@ -136,7 +136,7 @@ gst_gl_effects_set_effect (GstGLEffects * effects, gint effect_type)
case GST_GL_EFFECT_SQUEEZE: case GST_GL_EFFECT_SQUEEZE:
effects->effect = (GstGLEffectProcessFunc) gst_gl_effects_squeeze; effects->effect = (GstGLEffectProcessFunc) gst_gl_effects_squeeze;
break; break;
#ifndef OPENGL_ES2 #if HAVE_OPENGL
case GST_GL_EFFECT_STRETCH: case GST_GL_EFFECT_STRETCH:
effects->effect = (GstGLEffectProcessFunc) gst_gl_effects_stretch; effects->effect = (GstGLEffectProcessFunc) gst_gl_effects_stretch;
break; break;
@ -270,83 +270,84 @@ void
gst_gl_effects_draw_texture (GstGLEffects * effects, GLuint tex, guint width, gst_gl_effects_draw_texture (GstGLEffects * effects, GLuint tex, guint width,
guint height) guint height)
{ {
#ifndef OPENGL_ES2 #if HAVE_OPENGL
glActiveTexture (GL_TEXTURE0); if (gst_gl_display_get_gl_api_unlocked (GST_GL_FILTER (effects)->display) &
glEnable (GL_TEXTURE_RECTANGLE_ARB); GST_GL_API_OPENGL) {
glBindTexture (GL_TEXTURE_RECTANGLE_ARB, tex); glActiveTexture (GL_TEXTURE0);
glEnable (GL_TEXTURE_RECTANGLE_ARB);
glBindTexture (GL_TEXTURE_RECTANGLE_ARB, tex);
glBegin (GL_QUADS); glBegin (GL_QUADS);
glTexCoord2f (0.0, 0.0); glTexCoord2f (0.0, 0.0);
glVertex2f (-1.0, -1.0); glVertex2f (-1.0, -1.0);
glTexCoord2f ((gfloat) width, 0.0); glTexCoord2f ((gfloat) width, 0.0);
glVertex2f (1.0, -1.0); glVertex2f (1.0, -1.0);
glTexCoord2f ((gfloat) width, (gfloat) height); glTexCoord2f ((gfloat) width, (gfloat) height);
glVertex2f (1.0, 1.0); glVertex2f (1.0, 1.0);
glTexCoord2f (0.0, (gfloat) height); glTexCoord2f (0.0, (gfloat) height);
glVertex2f (-1.0, 1.0); glVertex2f (-1.0, 1.0);
glEnd (); glEnd ();
#else }
#endif
#if HAVE_GLES2
if (gst_gl_display_get_gl_api_unlocked (GST_GL_FILTER (effects)->display) &
GST_GL_API_GLES2)
) {
const GLfloat vVertices[] = {
-1.0f, -1.0f, 0.0f,
0.0f, 0.0f,
1.0, -1.0f, 0.0f,
1.0f, 0.0f,
1.0f, 1.0f, 0.0f, 1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f};
const GLfloat vVertices[] = { -1.0f, -1.0f, 0.0f, GLushort indices[] = {
0.0f, 0.0f, 0, 1, 2, 0, 2, 3};
1.0, -1.0f, 0.0f,
1.0f, 0.0f,
1.0f, 1.0f, 0.0f,
1.0f, 1.0f,
-1.0f, 1.0f, 0.0f,
0.0f, 1.0f
};
GLushort indices[] = { 0, 1, 2, 0, 2, 3 }; /* glClear (GL_COLOR_BUFFER_BIT); */
//glClear (GL_COLOR_BUFFER_BIT); /* Load the vertex position */
glVertexAttribPointer (effects->draw_attr_position_loc, 3, GL_FLOAT,
GL_FALSE, 5 * sizeof (GLfloat), vVertices);
//Load the vertex position /* Load the texture coordinate */
glVertexAttribPointer (effects->draw_attr_position_loc, 3, GL_FLOAT, glVertexAttribPointer (effects->draw_attr_texture_loc, 2, GL_FLOAT,
GL_FALSE, 5 * sizeof (GLfloat), vVertices); GL_FALSE, 5 * sizeof (GLfloat), &vVertices[3]);
//Load the texture coordinate glEnableVertexAttribArray (effects->draw_attr_position_loc);
glVertexAttribPointer (effects->draw_attr_texture_loc, 2, GL_FLOAT, glEnableVertexAttribArray (effects->draw_attr_texture_loc);
GL_FALSE, 5 * sizeof (GLfloat), &vVertices[3]);
glEnableVertexAttribArray (effects->draw_attr_position_loc); glDrawElements (GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices);
glEnableVertexAttribArray (effects->draw_attr_texture_loc); }
glDrawElements (GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices);
#endif #endif
glUseProgramObjectARB (0); glUseProgramObjectARB (0);
} }
static void static void set_horizontal_swap (GstGLDisplay * display, gpointer data)
set_horizontal_swap (GstGLDisplay * display, gpointer data)
{ {
// GstGLEffects *effects = GST_GL_EFFECTS (data); #if HAVE_OPENGL
if (USING_OPENGL (display)) {
#ifndef OPENGL_ES2 const double mirrormatrix[16] = {
const double mirrormatrix[16] = {
-1.0, 0.0, 0.0, 0.0, -1.0, 0.0, 0.0, 0.0,
0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0};
0.0, 0.0, 1.0, 0.0,
0.0, 0.0, 0.0, 1.0
};
glMatrixMode (GL_MODELVIEW); glMatrixMode (GL_MODELVIEW);
glLoadMatrixd (mirrormatrix); glLoadMatrixd (mirrormatrix);
}
#endif #endif
} }
static void static void gst_gl_effects_init (GstGLEffects * effects)
gst_gl_effects_init (GstGLEffects * effects)
{ {
effects->effect = gst_gl_effects_identity; effects->effect = gst_gl_effects_identity;
effects->horizontal_swap = FALSE; effects->horizontal_swap = FALSE;
} }
static void static void
gst_gl_effects_ghash_func_clean (gpointer key, gpointer value, gpointer data) gst_gl_effects_ghash_func_clean (gpointer key, gpointer value,
gpointer data)
{ {
GstGLShader *shader = (GstGLShader *) value; GstGLShader *shader = (GstGLShader *) value;
GstGLFilter *filter = (GstGLFilter *) data; GstGLFilter *filter = (GstGLFilter *) data;
@ -357,26 +358,23 @@ gst_gl_effects_ghash_func_clean (gpointer key, gpointer value, gpointer data)
value = NULL; value = NULL;
} }
static void static void gst_gl_effects_reset_resources (GstGLFilter * filter)
gst_gl_effects_reset_resources (GstGLFilter * filter)
{ {
GstGLEffects *effects = GST_GL_EFFECTS (filter); GstGLEffects *effects = GST_GL_EFFECTS (filter);
// g_message ("reset resources"); /* release shaders in the gl thread */
//release shaders in the gl thread
g_hash_table_foreach (effects->shaderstable, gst_gl_effects_ghash_func_clean, g_hash_table_foreach (effects->shaderstable, gst_gl_effects_ghash_func_clean,
filter); filter);
//clean the htable without calling values destructors /* clean the htable without calling values destructors
//because shaders have been released in the glthread * because shaders have been released in the glthread
//through the foreach func * through the foreach func */
g_hash_table_unref (effects->shaderstable); g_hash_table_unref (effects->shaderstable);
effects->shaderstable = NULL; effects->shaderstable = NULL;
} }
static void static void
gst_gl_effects_set_property (GObject * object, guint prop_id, gst_gl_effects_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec) const GValue * value, GParamSpec * pspec)
{ {
GstGLEffects *effects = GST_GL_EFFECTS (object); GstGLEffects *effects = GST_GL_EFFECTS (object);
@ -385,17 +383,15 @@ gst_gl_effects_set_property (GObject * object, guint prop_id,
case PROP_EFFECT: case PROP_EFFECT:
gst_gl_effects_set_effect (effects, g_value_get_enum (value)); gst_gl_effects_set_effect (effects, g_value_get_enum (value));
break; break;
case PROP_HSWAP: case PROP_HSWAP:effects->horizontal_swap = g_value_get_boolean (value);
effects->horizontal_swap = g_value_get_boolean (value);
break; break;
default: default:G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break; break;
} }
} }
static void static void
gst_gl_effects_get_property (GObject * object, guint prop_id, gst_gl_effects_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec) GValue * value, GParamSpec * pspec)
{ {
GstGLEffects *effects = GST_GL_EFFECTS (object); GstGLEffects *effects = GST_GL_EFFECTS (object);
@ -413,15 +409,13 @@ gst_gl_effects_get_property (GObject * object, guint prop_id,
} }
} }
static void static void gst_gl_effects_init_resources (GstGLFilter * filter)
gst_gl_effects_init_resources (GstGLFilter * filter)
{ {
GstGLEffects *effects = GST_GL_EFFECTS (filter); GstGLEffects *effects = GST_GL_EFFECTS (filter);
gint i; gint i;
// g_message ("init resources");
// g_message ("init hashtable");
effects->shaderstable = g_hash_table_new (g_str_hash, g_str_equal); effects->shaderstable = g_hash_table_new (g_str_hash, g_str_equal);
// g_message ("zero textures and curves");
for (i = 0; i < NEEDED_TEXTURES; i++) { for (i = 0; i < NEEDED_TEXTURES; i++) {
effects->midtexture[i] = 0; effects->midtexture[i] = 0;
} }
@ -430,16 +424,15 @@ gst_gl_effects_init_resources (GstGLFilter * filter)
} }
} }
static gboolean static gboolean gst_gl_effects_on_init_gl_context (GstGLFilter * filter)
gst_gl_effects_on_init_gl_context (GstGLFilter * filter)
{ {
//check that your hardware supports shader /* check that your hardware supports shader
//if not the pipeline correctly shut down * if not the pipeline correctly shut down */
return gst_gl_display_gen_shader (filter->display, 0, 0, NULL); return gst_gl_display_gen_shader (filter->display, 0, 0, NULL);
} }
static gboolean static gboolean
gst_gl_effects_filter_texture (GstGLFilter * filter, guint in_tex, gst_gl_effects_filter_texture (GstGLFilter * filter, guint in_tex,
guint out_tex) guint out_tex)
{ {
GstGLEffects *effects = GST_GL_EFFECTS (filter); GstGLEffects *effects = GST_GL_EFFECTS (filter);

2
gst/gl/gstgleffects.h
View file

@ -71,7 +71,7 @@ struct _GstGLEffects
gboolean horizontal_swap; /* switch left to right */ gboolean horizontal_swap; /* switch left to right */
#ifdef OPENGL_ES2 #if HAVE_GLES2
GLint draw_attr_position_loc; GLint draw_attr_position_loc;
GLint draw_attr_texture_loc; GLint draw_attr_texture_loc;
#endif #endif

116
gst/gl/gstglfiltercube.c
View file

@ -44,6 +44,7 @@
#include "config.h" #include "config.h"
#endif #endif
#include <gst/gl/gstglapi.h>
#include "gstglfiltercube.h" #include "gstglfiltercube.h"
#define GST_CAT_DEFAULT gst_gl_filter_cube_debug #define GST_CAT_DEFAULT gst_gl_filter_cube_debug
@ -74,17 +75,21 @@ static void gst_gl_filter_cube_get_property (GObject * object, guint prop_id,
static gboolean gst_gl_filter_cube_set_caps (GstGLFilter * filter, static gboolean gst_gl_filter_cube_set_caps (GstGLFilter * filter,
GstCaps * incaps, GstCaps * outcaps); GstCaps * incaps, GstCaps * outcaps);
#ifdef OPENGL_ES2 #if HAVE_GLES2
static void gst_gl_filter_cube_reset (GstGLFilter * filter); static void gst_gl_filter_cube_reset (GstGLFilter * filter);
static gboolean gst_gl_filter_cube_init_shader (GstGLFilter * filter); static gboolean gst_gl_filter_cube_init_shader (GstGLFilter * filter);
static void _callback_gles2 (gint width, gint height, guint texture,
gpointer stuff);
#endif
#if HAVE_OPENGL
static void _callback_opengl (gint width, gint height, guint texture,
gpointer stuff);
#endif #endif
static gboolean gst_gl_filter_cube_filter_texture (GstGLFilter * filter, static gboolean gst_gl_filter_cube_filter_texture (GstGLFilter * filter,
guint in_tex, guint out_tex); guint in_tex, guint out_tex);
static void gst_gl_filter_cube_callback (gint width, gint height, guint texture,
gpointer stuff);
#ifdef OPENGL_ES2 #if HAVE_GLES2
//vertex source /* vertex source */
static const gchar *cube_v_src = static const gchar *cube_v_src =
"attribute vec4 a_position; \n" "attribute vec4 a_position; \n"
"attribute vec2 a_texCoord; \n" "attribute vec2 a_texCoord; \n"
@ -116,7 +121,7 @@ static const gchar *cube_v_src =
" v_texCoord = a_texCoord; \n" " v_texCoord = a_texCoord; \n"
"} \n"; "} \n";
//fragment source /* fragment source */
static const gchar *cube_f_src = static const gchar *cube_f_src =
"precision mediump float; \n" "precision mediump float; \n"
"varying vec2 v_texCoord; \n" "varying vec2 v_texCoord; \n"
@ -139,7 +144,7 @@ gst_gl_filter_cube_class_init (GstGLFilterCubeClass * klass)
gobject_class->set_property = gst_gl_filter_cube_set_property; gobject_class->set_property = gst_gl_filter_cube_set_property;
gobject_class->get_property = gst_gl_filter_cube_get_property; gobject_class->get_property = gst_gl_filter_cube_get_property;
#ifdef OPENGL_ES2 #if HAVE_GLES2
GST_GL_FILTER_CLASS (klass)->onInitFBO = gst_gl_filter_cube_init_shader; GST_GL_FILTER_CLASS (klass)->onInitFBO = gst_gl_filter_cube_init_shader;
GST_GL_FILTER_CLASS (klass)->onReset = gst_gl_filter_cube_reset; GST_GL_FILTER_CLASS (klass)->onReset = gst_gl_filter_cube_reset;
#endif #endif
@ -186,9 +191,7 @@ gst_gl_filter_cube_class_init (GstGLFilterCubeClass * klass)
static void static void
gst_gl_filter_cube_init (GstGLFilterCube * filter) gst_gl_filter_cube_init (GstGLFilterCube * filter)
{ {
#ifdef OPENGL_ES
filter->shader = NULL; filter->shader = NULL;
#endif
filter->fovy = 45; filter->fovy = 45;
filter->aspect = 0; filter->aspect = 0;
filter->znear = 0.1; filter->znear = 0.1;
@ -233,8 +236,6 @@ static void
gst_gl_filter_cube_get_property (GObject * object, guint prop_id, gst_gl_filter_cube_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec) GValue * value, GParamSpec * pspec)
{ {
//GstGLFilterCube* filter = GST_GL_FILTER_CUBE (object);
switch (prop_id) { switch (prop_id) {
default: default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@ -255,14 +256,15 @@ gst_gl_filter_cube_set_caps (GstGLFilter * filter, GstCaps * incaps,
return TRUE; return TRUE;
} }
#ifdef OPENGL_ES2 #if HAVE_GLES2
static void static void
gst_gl_filter_cube_reset (GstGLFilter * filter) gst_gl_filter_cube_reset (GstGLFilter * filter)
{ {
GstGLFilterCube *cube_filter = GST_GL_FILTER_CUBE (filter); GstGLFilterCube *cube_filter = GST_GL_FILTER_CUBE (filter);
//blocking call, wait the opengl thread has destroyed the shader /* blocking call, wait the opengl thread has destroyed the shader */
gst_gl_display_del_shader (filter->display, cube_filter->shader); if (cube_filter->shader)
gst_gl_display_del_shader (filter->display, cube_filter->shader);
} }
static gboolean static gboolean
@ -270,9 +272,12 @@ gst_gl_filter_cube_init_shader (GstGLFilter * filter)
{ {
GstGLFilterCube *cube_filter = GST_GL_FILTER_CUBE (filter); GstGLFilterCube *cube_filter = GST_GL_FILTER_CUBE (filter);
//blocking call, wait the opengl thread has compiled the shader if (gst_gl_display_get_gl_api (filter->display) & GST_GL_API_GLES2) {
return gst_gl_display_gen_shader (filter->display, cube_v_src, cube_f_src, /* blocking call, wait the opengl thread has compiled the shader */
&cube_filter->shader); return gst_gl_display_gen_shader (filter->display, cube_v_src, cube_f_src,
&cube_filter->shader);
}
return TRUE;
} }
#endif #endif
@ -281,13 +286,27 @@ gst_gl_filter_cube_filter_texture (GstGLFilter * filter, guint in_tex,
guint out_tex) guint out_tex)
{ {
GstGLFilterCube *cube_filter = GST_GL_FILTER_CUBE (filter); GstGLFilterCube *cube_filter = GST_GL_FILTER_CUBE (filter);
GLCB cb = NULL;
GstGLAPI api;
//blocking call, use a FBO api =
gst_gl_display_get_gl_api_unlocked (GST_GL_FILTER (cube_filter)->display);
#if HAVE_OPENGL
if (api & GST_GL_API_OPENGL)
cb = _callback_opengl;
#endif
#if HAVE_GLES2
if (api & GST_GL_API_GLES2)
cb = _callback_gles2;
#endif
/* blocking call, use a FBO */
gst_gl_display_use_fbo (filter->display, gst_gl_display_use_fbo (filter->display,
GST_VIDEO_INFO_WIDTH (&filter->out_info), GST_VIDEO_INFO_WIDTH (&filter->out_info),
GST_VIDEO_INFO_HEIGHT (&filter->out_info), GST_VIDEO_INFO_HEIGHT (&filter->out_info),
filter->fbo, filter->depthbuffer, out_tex, filter->fbo, filter->depthbuffer, out_tex,
gst_gl_filter_cube_callback, cb,
GST_VIDEO_INFO_WIDTH (&filter->in_info), GST_VIDEO_INFO_WIDTH (&filter->in_info),
GST_VIDEO_INFO_HEIGHT (&filter->in_info), GST_VIDEO_INFO_HEIGHT (&filter->in_info),
in_tex, cube_filter->fovy, cube_filter->aspect, in_tex, cube_filter->fovy, cube_filter->aspect,
@ -297,10 +316,10 @@ gst_gl_filter_cube_filter_texture (GstGLFilter * filter, guint in_tex,
return TRUE; return TRUE;
} }
//opengl scene, params: input texture (not the output filter->texture) /* opengl scene, params: input texture (not the output filter->texture) */
#if HAVE_OPENGL
static void static void
gst_gl_filter_cube_callback (gint width, gint height, guint texture, _callback_opengl (gint width, gint height, guint texture, gpointer stuff)
gpointer stuff)
{ {
GstGLFilterCube *cube_filter = GST_GL_FILTER_CUBE (stuff); GstGLFilterCube *cube_filter = GST_GL_FILTER_CUBE (stuff);
@ -308,7 +327,6 @@ gst_gl_filter_cube_callback (gint width, gint height, guint texture,
static GLfloat yrot = 0; static GLfloat yrot = 0;
static GLfloat zrot = 0; static GLfloat zrot = 0;
#ifndef OPENGL_ES2
glEnable (GL_DEPTH_TEST); glEnable (GL_DEPTH_TEST);
glEnable (GL_TEXTURE_RECTANGLE_ARB); glEnable (GL_TEXTURE_RECTANGLE_ARB);
@ -319,9 +337,7 @@ gst_gl_filter_cube_callback (gint width, gint height, guint texture,
GL_CLAMP_TO_EDGE); GL_CLAMP_TO_EDGE);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T,
GL_CLAMP_TO_EDGE); GL_CLAMP_TO_EDGE);
#ifndef OPENGL_ES2
glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
#endif
glClearColor (cube_filter->red, cube_filter->green, cube_filter->blue, 0.0); glClearColor (cube_filter->red, cube_filter->green, cube_filter->blue, 0.0);
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
@ -336,7 +352,7 @@ gst_gl_filter_cube_callback (gint width, gint height, guint texture,
glRotatef (zrot, 0.0f, 0.0f, 1.0f); glRotatef (zrot, 0.0f, 0.0f, 1.0f);
glBegin (GL_QUADS); glBegin (GL_QUADS);
// Front Face /* Front Face */
glTexCoord2f ((gfloat) width, 0.0f); glTexCoord2f ((gfloat) width, 0.0f);
glVertex3f (-1.0f, -1.0f, 1.0f); glVertex3f (-1.0f, -1.0f, 1.0f);
glTexCoord2f (0.0f, 0.0f); glTexCoord2f (0.0f, 0.0f);
@ -345,7 +361,7 @@ gst_gl_filter_cube_callback (gint width, gint height, guint texture,
glVertex3f (1.0f, 1.0f, 1.0f); glVertex3f (1.0f, 1.0f, 1.0f);
glTexCoord2f ((gfloat) width, (gfloat) height); glTexCoord2f ((gfloat) width, (gfloat) height);
glVertex3f (-1.0f, 1.0f, 1.0f); glVertex3f (-1.0f, 1.0f, 1.0f);
// Back Face /* Back Face */
glTexCoord2f (0.0f, 0.0f); glTexCoord2f (0.0f, 0.0f);
glVertex3f (-1.0f, -1.0f, -1.0f); glVertex3f (-1.0f, -1.0f, -1.0f);
glTexCoord2f (0.0f, (gfloat) height); glTexCoord2f (0.0f, (gfloat) height);
@ -354,7 +370,7 @@ gst_gl_filter_cube_callback (gint width, gint height, guint texture,
glVertex3f (1.0f, 1.0f, -1.0f); glVertex3f (1.0f, 1.0f, -1.0f);
glTexCoord2f ((gfloat) width, 0.0f); glTexCoord2f ((gfloat) width, 0.0f);
glVertex3f (1.0f, -1.0f, -1.0f); glVertex3f (1.0f, -1.0f, -1.0f);
// Top Face /* Top Face */
glTexCoord2f ((gfloat) width, (gfloat) height); glTexCoord2f ((gfloat) width, (gfloat) height);
glVertex3f (-1.0f, 1.0f, -1.0f); glVertex3f (-1.0f, 1.0f, -1.0f);
glTexCoord2f ((gfloat) width, 0.0f); glTexCoord2f ((gfloat) width, 0.0f);
@ -363,7 +379,7 @@ gst_gl_filter_cube_callback (gint width, gint height, guint texture,
glVertex3f (1.0f, 1.0f, 1.0f); glVertex3f (1.0f, 1.0f, 1.0f);
glTexCoord2f (0.0f, (gfloat) height); glTexCoord2f (0.0f, (gfloat) height);
glVertex3f (1.0f, 1.0f, -1.0f); glVertex3f (1.0f, 1.0f, -1.0f);
// Bottom Face /* Bottom Face */
glTexCoord2f ((gfloat) width, 0.0f); glTexCoord2f ((gfloat) width, 0.0f);
glVertex3f (-1.0f, -1.0f, -1.0f); glVertex3f (-1.0f, -1.0f, -1.0f);
glTexCoord2f (0.0f, 0.0f); glTexCoord2f (0.0f, 0.0f);
@ -372,7 +388,7 @@ gst_gl_filter_cube_callback (gint width, gint height, guint texture,
glVertex3f (1.0f, -1.0f, 1.0f); glVertex3f (1.0f, -1.0f, 1.0f);
glTexCoord2f ((gfloat) width, (gfloat) height); glTexCoord2f ((gfloat) width, (gfloat) height);
glVertex3f (-1.0f, -1.0f, 1.0f); glVertex3f (-1.0f, -1.0f, 1.0f);
// Right face /* Right face */
glTexCoord2f (0.0f, 0.0f); glTexCoord2f (0.0f, 0.0f);
glVertex3f (1.0f, -1.0f, -1.0f); glVertex3f (1.0f, -1.0f, -1.0f);
glTexCoord2f (0.0f, (gfloat) height); glTexCoord2f (0.0f, (gfloat) height);
@ -381,7 +397,7 @@ gst_gl_filter_cube_callback (gint width, gint height, guint texture,
glVertex3f (1.0f, 1.0f, 1.0f); glVertex3f (1.0f, 1.0f, 1.0f);
glTexCoord2f ((gfloat) width, 0.0f); glTexCoord2f ((gfloat) width, 0.0f);
glVertex3f (1.0f, -1.0f, 1.0f); glVertex3f (1.0f, -1.0f, 1.0f);
// Left Face /* Left Face */
glTexCoord2f ((gfloat) width, 0.0f); glTexCoord2f ((gfloat) width, 0.0f);
glVertex3f (-1.0f, -1.0f, -1.0f); glVertex3f (-1.0f, -1.0f, -1.0f);
glTexCoord2f (0.0f, 0.0f); glTexCoord2f (0.0f, 0.0f);
@ -391,10 +407,28 @@ gst_gl_filter_cube_callback (gint width, gint height, guint texture,
glTexCoord2f ((gfloat) width, (gfloat) height); glTexCoord2f ((gfloat) width, (gfloat) height);
glVertex3f (-1.0f, 1.0f, -1.0f); glVertex3f (-1.0f, 1.0f, -1.0f);
glEnd (); glEnd ();
#else
glDisable (GL_DEPTH_TEST);
xrot += 0.3f;
yrot += 0.2f;
zrot += 0.4f;
}
#endif
#if HAVE_GLES2
static void
_callback_gles2 (gint width, gint height, guint texture, gpointer stuff)
{
GstGLFilterCube *cube_filter = GST_GL_FILTER_CUBE (stuff);
static GLfloat xrot = 0;
static GLfloat yrot = 0;
static GLfloat zrot = 0;
const GLfloat v_vertices[] = { const GLfloat v_vertices[] = {
//front face /* front face */
1.0f, 1.0f, -1.0f, 1.0f, 1.0f, -1.0f,
1.0f, 0.0f, 1.0f, 0.0f,
1.0f, -1.0f, -1.0f, 1.0f, -1.0f, -1.0f,
@ -403,7 +437,7 @@ gst_gl_filter_cube_callback (gint width, gint height, guint texture,
0.0f, 1.0f, 0.0f, 1.0f,
-1.0f, 1.0f, -1.0f, -1.0f, 1.0f, -1.0f,
0.0f, 0.0f, 0.0f, 0.0f,
//back face /* back face */
1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,
1.0f, 0.0f, 1.0f, 0.0f,
-1.0f, 1.0f, 1.0f, -1.0f, 1.0f, 1.0f,
@ -412,7 +446,7 @@ gst_gl_filter_cube_callback (gint width, gint height, guint texture,
0.0f, 1.0f, 0.0f, 1.0f,
1.0f, -1.0f, 1.0f, 1.0f, -1.0f, 1.0f,
1.0f, 1.0f, 1.0f, 1.0f,
//right face /* right face */
1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,
1.0f, 0.0f, 1.0f, 0.0f,
1.0f, -1.0f, 1.0f, 1.0f, -1.0f, 1.0f,
@ -421,7 +455,7 @@ gst_gl_filter_cube_callback (gint width, gint height, guint texture,
0.0f, 1.0f, 0.0f, 1.0f,
1.0f, 1.0f, -1.0f, 1.0f, 1.0f, -1.0f,
1.0f, 1.0f, 1.0f, 1.0f,
//left face /* left face */
-1.0f, 1.0f, 1.0f, -1.0f, 1.0f, 1.0f,
1.0f, 0.0f, 1.0f, 0.0f,
-1.0f, 1.0f, -1.0f, -1.0f, 1.0f, -1.0f,
@ -430,7 +464,7 @@ gst_gl_filter_cube_callback (gint width, gint height, guint texture,
0.0f, 1.0f, 0.0f, 1.0f,
-1.0f, -1.0f, 1.0f, -1.0f, -1.0f, 1.0f,
0.0f, 0.0f, 0.0f, 0.0f,
//top face /* top face */
1.0f, -1.0f, 1.0f, 1.0f, -1.0f, 1.0f,
1.0f, 0.0f, 1.0f, 0.0f,
-1.0f, -1.0f, 1.0f, -1.0f, -1.0f, 1.0f,
@ -439,7 +473,7 @@ gst_gl_filter_cube_callback (gint width, gint height, guint texture,
0.0f, 1.0f, 0.0f, 1.0f,
1.0f, -1.0f, -1.0f, 1.0f, -1.0f, -1.0f,
1.0f, 1.0f, 1.0f, 1.0f,
//bottom face /* bottom face */
1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,
1.0f, 0.0f, 1.0f, 0.0f,
1.0f, 1.0f, -1.0f, 1.0f, 1.0f, -1.0f,
@ -487,11 +521,11 @@ gst_gl_filter_cube_callback (gint width, gint height, guint texture,
attr_texture_loc = attr_texture_loc =
gst_gl_shader_get_attribute_location (cube_filter->shader, "a_texCoord"); gst_gl_shader_get_attribute_location (cube_filter->shader, "a_texCoord");
//Load the vertex position /* Load the vertex position */
glVertexAttribPointer (attr_position_loc, 3, GL_FLOAT, glVertexAttribPointer (attr_position_loc, 3, GL_FLOAT,
GL_FALSE, 5 * sizeof (GLfloat), v_vertices); GL_FALSE, 5 * sizeof (GLfloat), v_vertices);
//Load the texture coordinate /* Load the texture coordinate */
glVertexAttribPointer (attr_texture_loc, 2, GL_FLOAT, glVertexAttribPointer (attr_texture_loc, 2, GL_FLOAT,
GL_FALSE, 5 * sizeof (GLfloat), &v_vertices[3]); GL_FALSE, 5 * sizeof (GLfloat), &v_vertices[3]);
@ -511,7 +545,6 @@ gst_gl_filter_cube_callback (gint width, gint height, guint texture,
glDisableVertexAttribArray (attr_position_loc); glDisableVertexAttribArray (attr_position_loc);
glDisableVertexAttribArray (attr_texture_loc); glDisableVertexAttribArray (attr_texture_loc);
#endif
glDisable (GL_DEPTH_TEST); glDisable (GL_DEPTH_TEST);
@ -519,3 +552,4 @@ gst_gl_filter_cube_callback (gint width, gint height, guint texture,
yrot += 0.2f; yrot += 0.2f;
zrot += 0.4f; zrot += 0.4f;
} }
#endif

6
gst/gl/gstglfiltercube.h
View file

@ -39,16 +39,14 @@ struct _GstGLFilterCube
{ {
GstGLFilter filter; GstGLFilter filter;
#ifdef OPENGL_ES2
GstGLShader *shader; GstGLShader *shader;
#endif
//background color /* background color */
gfloat red; gfloat red;
gfloat green; gfloat green;
gfloat blue; gfloat blue;
//perspective /* perspective */
gdouble fovy; gdouble fovy;
gdouble aspect; gdouble aspect;
gdouble znear; gdouble znear;

24
gst/gl/gstopengl.c
View file

@ -51,7 +51,7 @@
GType gst_gl_filter_cube_get_type (void); GType gst_gl_filter_cube_get_type (void);
GType gst_gl_effects_get_type (void); GType gst_gl_effects_get_type (void);
#ifndef OPENGL_ES2 #if HAVE_OPENGL
#include "gstgltestsrc.h" #include "gstgltestsrc.h"
#include "gstglfilterlaplacian.h" #include "gstglfilterlaplacian.h"
#include "gstglfilterglass.h" #include "gstglfilterglass.h"
@ -72,21 +72,21 @@ GType gst_gl_filter_laplacian_get_type (void);
GType gst_gl_filter_glass_get_type (void); GType gst_gl_filter_glass_get_type (void);
GType gst_gl_mosaic_get_type (void); GType gst_gl_mosaic_get_type (void);
#ifdef HAVE_PNG #if HAVE_PNG
#include "gstgldifferencematte.h" #include "gstgldifferencematte.h"
#include "gstglbumper.h" #include "gstglbumper.h"
GType gst_gl_differencematte_get_type (void); GType gst_gl_differencematte_get_type (void);
GType gst_gl_bumper_get_type (void); GType gst_gl_bumper_get_type (void);
#ifdef HAVE_JPEG #if HAVE_JPEG
#include "gstgloverlay.h" #include "gstgloverlay.h"
GType gst_gl_overlay_get_type (void); GType gst_gl_overlay_get_type (void);
#endif #endif /* HAVE_JPEG */
#endif #endif /* HAVE_PNG */
#endif #endif /* HAVE_OPENGL */
#define GST_CAT_DEFAULT gst_gl_gstgl_debug #define GST_CAT_DEFAULT gst_gl_gstgl_debug
GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT); GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT);
@ -111,7 +111,7 @@ plugin_init (GstPlugin * plugin)
GST_RANK_NONE, gst_gl_effects_get_type ())) { GST_RANK_NONE, gst_gl_effects_get_type ())) {
return FALSE; return FALSE;
} }
#ifndef OPENGL_ES2 #if HAVE_OPENGL
if (!gst_element_register (plugin, "gltestsrc", if (!gst_element_register (plugin, "gltestsrc",
GST_RANK_NONE, GST_TYPE_GL_TEST_SRC)) { GST_RANK_NONE, GST_TYPE_GL_TEST_SRC)) {
return FALSE; return FALSE;
@ -166,7 +166,7 @@ plugin_init (GstPlugin * plugin)
GST_RANK_NONE, GST_TYPE_GL_MOSAIC)) { GST_RANK_NONE, GST_TYPE_GL_MOSAIC)) {
return FALSE; return FALSE;
} }
#ifdef HAVE_PNG #if HAVE_PNG
if (!gst_element_register (plugin, "gldifferencematte", if (!gst_element_register (plugin, "gldifferencematte",
GST_RANK_NONE, gst_gl_differencematte_get_type ())) { GST_RANK_NONE, gst_gl_differencematte_get_type ())) {
return FALSE; return FALSE;
@ -176,14 +176,14 @@ plugin_init (GstPlugin * plugin)
GST_RANK_NONE, gst_gl_bumper_get_type ())) { GST_RANK_NONE, gst_gl_bumper_get_type ())) {
return FALSE; return FALSE;
} }
#ifdef HAVE_JPEG #if HAVE_JPEG
if (!gst_element_register (plugin, "gloverlay", if (!gst_element_register (plugin, "gloverlay",
GST_RANK_NONE, gst_gl_overlay_get_type ())) { GST_RANK_NONE, gst_gl_overlay_get_type ())) {
return FALSE; return FALSE;
} }
#endif #endif /* HAVE_JPEG */
#endif #endif /* HAVE_PNG */
#endif #endif /* HAVE_OPENGL */
return TRUE; return TRUE;
} }

8
tests/check/pipelines/simple-launch-lines.c
View file

@ -154,7 +154,7 @@ GST_START_TEST (test_gleffects)
GST_END_TEST GST_END_TEST
#undef N_EFFECTS #undef N_EFFECTS
#ifndef OPENGL_ES2 #if HAVE_OPENGL
#define N_SRCS 13 #define N_SRCS 13
GST_START_TEST (test_gltestsrc) GST_START_TEST (test_gltestsrc)
{ {
@ -311,7 +311,7 @@ GST_START_TEST (test_glfilterapp)
GST_END_TEST GST_END_TEST
#endif /* 0 */ #endif /* 0 */
#endif /* !OPENGL_ES2 */ #endif /* HAVE_OPENGL */
#endif /* !GST_DISABLE_PARSE */ #endif /* !GST_DISABLE_PARSE */
Suite * simple_launch_lines_suite (void) Suite * simple_launch_lines_suite (void)
{ {
@ -326,7 +326,7 @@ GST_END_TEST
tcase_add_test (tc_chain, test_glimagesink); tcase_add_test (tc_chain, test_glimagesink);
tcase_add_test (tc_chain, test_glfiltercube); tcase_add_test (tc_chain, test_glfiltercube);
tcase_add_test (tc_chain, test_gleffects); tcase_add_test (tc_chain, test_gleffects);
#ifndef OPENGL_ES2 #if HAVE_OPENGL
tcase_add_test (tc_chain, test_gltestsrc); tcase_add_test (tc_chain, test_gltestsrc);
tcase_add_test (tc_chain, test_glfilterblur); tcase_add_test (tc_chain, test_glfilterblur);
tcase_add_test (tc_chain, test_glfiltersobel); tcase_add_test (tc_chain, test_glfiltersobel);
@ -345,7 +345,7 @@ GST_END_TEST
#endif /* HAVE_JPEG */ #endif /* HAVE_JPEG */
#endif /* HAVE_PNG */ #endif /* HAVE_PNG */
#endif #endif
#endif /* !OPENGL_ES2 */ #endif /* HAVE_OPENGL */
#endif /* !GST_DISABLE_PARSE */ #endif /* !GST_DISABLE_PARSE */
return s; return s;
} }