mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-12-01 06:01:04 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/gst-libs/gst/gl/gstgldisplay.c
Julien Isorce 3778a85f01 [092/906] Finish to revive the gltestsrc. Next step is to do some refactoring. 
git-svn-id: svn://svn.wobow.com/GStreamer_playground/gst-plugins-gl@504 93df14bb-0f41-7a43-8087-d3e2a2f0e464
2014-03-15 18:36:20 +01:00

2358 lines
78 KiB
C
Raw Blame History

/*
* GStreamer
* Copyright (C) 2008 Julien Isorce <julien.isorce@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "gstgldisplay.h"
#include <gst/gst.h>
static void gst_gl_display_finalize (GObject * object);
static gpointer gst_gl_display_glutThreadFunc (GstGLDisplay* display);
static void gst_gl_display_glutCreateWindow (GstGLDisplay* display);
static void gst_gldisplay_glutGenerateOutputVideoFBO (GstGLDisplay *display);
static void gst_gl_display_glutGenerateFBO (GstGLDisplay *display);
static void gst_gl_display_glutUseFBO (GstGLDisplay *display);
static void gst_gl_display_glutUseFBO2 (GstGLDisplay *display);
static void gst_gl_display_glutDestroyFBO (GstGLDisplay *display);
static void gst_gl_display_glutDestroyWindow (GstGLDisplay* display);
static void gst_gl_display_glutSetVisibleWindow (GstGLDisplay* display);
static void gst_gl_display_glutReshapeWindow (GstGLDisplay* display);
static void gst_gl_display_glutPrepareTexture (GstGLDisplay* display);
static void gst_gl_display_glutUpdateTexture (GstGLDisplay* display);
static void gst_gl_display_glutCleanTexture (GstGLDisplay* display);
static void gst_gl_display_glutUpdateVideo (GstGLDisplay* display);
static void gst_gl_display_glutPostRedisplay (GstGLDisplay* display);
static void gst_gl_display_glut_idle (void);
static void gst_gl_display_glutDispatchAction (GstGLDisplayMsg *msg);
static gboolean gst_gl_display_checkMsgValidity (GstGLDisplayMsg *msg);
void gst_gl_display_lock (GstGLDisplay* display);
void gst_gl_display_unlock (GstGLDisplay* display);
void gst_gl_display_postMessage (GstGLDisplayAction action, GstGLDisplay* display);
void gst_gl_display_onReshape(gint width, gint height);
void gst_gl_display_draw (void);
void gst_gl_display_onClose (void);
void gst_gl_display_make_texture (GstGLDisplay* display);
void gst_gl_display_fill_texture (GstGLDisplay* display);
void gst_gl_display_draw_texture (GstGLDisplay* display);
void gst_gl_display_draw_graphic (GstGLDisplay* display);
void gst_gl_display_fill_video (GstGLDisplay* display);
GLhandleARB gst_gl_display_loadGLSLprogram (gchar* textFProgram);
void checkFramebufferStatus(void);
GST_BOILERPLATE (GstGLDisplay, gst_gl_display, GObject, G_TYPE_OBJECT);
//------------------------------------------------------------
//-------------------- Glut context management ---------------
//------------------------------------------------------------
//(key=int glutWinId) and (value=GstGLDisplay *display)
static GHashTable *gst_gl_display_map = NULL;
//all glut functions and opengl primitives are called in this thread
static GThread *gst_gl_display_glutThread = NULL;
//-timepoped by glutIdleFunc
static GAsyncQueue *gst_gl_display_messageQueue = NULL;
//------------------------------------------------------------
//---------------------- For klass GstGLDisplay ---------------
//------------------------------------------------------------
static void
gst_gl_display_base_init (gpointer g_class)
{
}
static void
gst_gl_display_class_init (GstGLDisplayClass * klass)
{
G_OBJECT_CLASS (klass)->finalize = gst_gl_display_finalize;
}
static void
gst_gl_display_init (GstGLDisplay *display, GstGLDisplayClass *klass)
{
display->mutex = g_mutex_new ();
display->texturePool = g_queue_new ();
display->cond_make = g_cond_new ();
display->cond_fill = g_cond_new ();
display->cond_clear = g_cond_new ();
display->cond_video = g_cond_new ();
display->cond_generateFBO = g_cond_new ();
display->cond_useFBO = g_cond_new ();
display->cond_useFBO2 = g_cond_new ();
display->cond_destroyFBO = g_cond_new ();
display->cond_create = g_cond_new ();
display->cond_destroy = g_cond_new ();
display->cond_download = g_cond_new ();
display->fbo = 0;
display->depthBuffer = 0;
display->textureFBO = 0;
display->textureFBOWidth = 0;
display->textureFBOHeight = 0;
display->graphicFBO = 0;
display->graphicDepthBuffer = 0;
display->graphicTexture = 0;
display->requestedFBO = 0;
display->requestedDepthBuffer = 0;
display->requestedTextureFBO = 0;
display->requestedTextureFBOWidth = 0;
display->requestedTextureFBOHeight = 0;
display->usedFBO = 0;
display->usedDepthBuffer = 0;
display->usedTextureFBO = 0;
display->usedTextureFBOWidth = 0;
display->usedTextureFBOHeight = 0;
display->glsceneFBO_cb = NULL;
display->glsceneFBO_cb2 = NULL;
display->p1 = NULL;
display->p2 = NULL;
display->inputTextureWidth = 0;
display->inputTextureHeight = 0;
display->inputTexture = 0;
display->rejectedFBO = 0;
display->rejectedDepthBuffer = 0;
display->rejectedTextureFBO = 0;
display->displayedTexture = 0;
display->displayedTextureWidth = 0;
display->displayedTextureHeight = 0;
display->requestedTexture = 0;
display->requestedTexture_u = 0;
display->requestedTexture_v = 0;
display->requestedVideo_format = 0;
display->requestedTextureWidth = 0;
display->requestedTextureHeight = 0;
display->candidateTexture = 0;
display->candidateTexture_u = 0;
display->candidateTexture_v = 0;
display->candidateVideo_format = 0;
display->candidateTextureWidth = 0;
display->candidateTextureHeight = 0;
display->candidateData = NULL;
display->currentTexture = 0;
display->currentTexture_u = 0;
display->currentTexture_v = 0;
display->currentVideo_format = 0;
display->currentTextureWidth = 0;
display->currentTextureHeight = 0;
display->textureTrash = 0;
display->textureTrash_u = 0;
display->textureTrash_v = 0;
display->videoFBO = 0;
display->videoDepthBuffer = 0;
display->videoTexture = 0;
display->videoTexture_u = 0;
display->videoTexture_v = 0;
display->outputWidth = 0;
display->outputHeight = 0;
display->outputVideo_format = 0;
display->outputData = NULL;
display->recordedTexture = 0;
display->recordedTextureWidth = 0;
display->recordedTextureHeight = 0;
display->glutWinId = -1;
display->winId = 0;
display->win_xpos = 0;
display->win_ypos = 0;
display->glcontext_width = 0;
display->glcontext_height = 0;
display->visible = FALSE;
display->isAlive = TRUE;
display->clientReshapeCallback = NULL;
display->clientDrawCallback = NULL;
display->title = g_string_new ("OpenGL renderer ");
display->GLSLProgram_YUY2 = 0;
display->GLSLProgram_UYVY = 0;
display->GLSLProgram_I420_YV12 = 0;
display->GLSLProgram_AYUV = 0;
display->GLSLProgram_to_YUY2 = 0;
display->GLSLProgram_to_UYVY = 0;
display->GLSLProgram_to_I420_YV12 = 0;
display->GLSLProgram_to_AYUV = 0;
//YUY2:r,g,a
//UYVY:a,b,r
display->textFProgram_YUY2_UYVY =
"uniform sampler2DRect Ytex, UVtex;\n"
"void main(void) {\n"
" float fx, fy, y, u, v, r, g, b;\n"
" fx = gl_TexCoord[0].x;\n"
" fy = gl_TexCoord[0].y;\n"
" y = texture2DRect(Ytex,vec2(fx,fy)).%c;\n"
" u = texture2DRect(UVtex,vec2(fx*0.5,fy)).%c;\n"
" v = texture2DRect(UVtex,vec2(fx*0.5,fy)).%c;\n"
" y=1.164*(y-0.0627);\n"
" u=u-0.5;\n"
" v=v-0.5;\n"
" r = y+1.5958*v;\n"
" g = y-0.39173*u-0.81290*v;\n"
" b = y+2.017*u;\n"
" gl_FragColor = vec4(r, g, b, 1.0);\n"
"}\n";
display->textFProgram_I420_YV12 =
"uniform sampler2DRect Ytex,Utex,Vtex;\n"
"void main(void) {\n"
" float r,g,b,y,u,v;\n"
" vec2 nxy=gl_TexCoord[0].xy;\n"
" y=texture2DRect(Ytex,nxy).r;\n"
" u=texture2DRect(Utex,nxy*0.5).r;\n"
" v=texture2DRect(Vtex,nxy*0.5).r;\n"
" y=1.1643*(y-0.0625);\n"
" u=u-0.5;\n"
" v=v-0.5;\n"
" r=y+1.5958*v;\n"
" g=y-0.39173*u-0.81290*v;\n"
" b=y+2.017*u;\n"
" gl_FragColor=vec4(r,g,b,1.0);\n"
"}\n";
display->textFProgram_AYUV =
"uniform sampler2DRect tex;\n"
"void main(void) {\n"
" float r,g,b,y,u,v;\n"
" vec2 nxy=gl_TexCoord[0].xy;\n"
" y=texture2DRect(tex,nxy).r;\n"
" u=texture2DRect(tex,nxy).g;\n"
" v=texture2DRect(tex,nxy).b;\n"
" y=1.1643*(y-0.0625);\n"
" u=u-0.5;\n"
" v=v-0.5;\n"
" r=y+1.5958*v;\n"
" g=y-0.39173*u-0.81290*v;\n"
" b=y+2.017*u;\n"
" gl_FragColor=vec4(r,g,b,1.0);\n"
"}\n";
//YUY2:y2,u,y1,v
//UYVY:v,y1,u,y2
display->textFProgram_to_YUY2_UYVY =
"uniform sampler2DRect tex;\n"
"void main(void) {\n"
" float fx,fy,r,g,b,r2,g2,b2,y1,y2,u,v;\n"
" fx = gl_TexCoord[0].x;\n"
" fy = gl_TexCoord[0].y;\n"
" r=texture2DRect(tex,vec2(fx*2.0,fy)).r;\n"
" g=texture2DRect(tex,vec2(fx*2.0,fy)).g;\n"
" b=texture2DRect(tex,vec2(fx*2.0,fy)).b;\n"
" r2=texture2DRect(tex,vec2(fx*2.0+1.0,fy)).r;\n"
" g2=texture2DRect(tex,vec2(fx*2.0+1.0,fy)).g;\n"
" b2=texture2DRect(tex,vec2(fx*2.0+1.0,fy)).b;\n"
" y1=0.299011*r + 0.586987*g + 0.114001*b;\n"
" y2=0.299011*r2 + 0.586987*g2 + 0.114001*b2;\n"
" u=-0.148246*r -0.29102*g + 0.439266*b;\n"
" v=0.439271*r - 0.367833*g - 0.071438*b ;\n"
" y1=0.858885*y1 + 0.0625;\n"
" y2=0.858885*y2 + 0.0625;\n"
" u=u + 0.5;\n"
" v=v + 0.5;\n"
" gl_FragColor=vec4(%s);\n"
"}\n";
display->textFProgram_to_I420_YV12 =
"uniform sampler2DRect tex;\n"
"uniform float w, h;\n"
"void main(void) {\n"
" float r,g,b,r2,b2,g2,y,u,v;\n"
" vec2 nxy=gl_TexCoord[0].xy;\n"
" vec2 nxy2=mod(2.0*nxy, vec2(w, h));\n"
" r=texture2DRect(tex,nxy).r;\n"
" g=texture2DRect(tex,nxy).g;\n"
" b=texture2DRect(tex,nxy).b;\n"
" r2=texture2DRect(tex,nxy2).r;\n"
" g2=texture2DRect(tex,nxy2).g;\n"
" b2=texture2DRect(tex,nxy2).b;\n"
" y=0.299011*r + 0.586987*g + 0.114001*b;\n"
" u=-0.148246*r2 -0.29102*g2 + 0.439266*b2;\n"
" v=0.439271*r2 - 0.367833*g2 - 0.071438*b2 ;\n"
" y=0.858885*y + 0.0625;\n"
" u=u + 0.5;\n"
" v=v + 0.5;\n"
" gl_FragData[0] = vec4(y, 0.0, 0.0, 1.0);\n"
" gl_FragData[1] = vec4(u, 0.0, 0.0, 1.0);\n"
" gl_FragData[2] = vec4(v, 0.0, 0.0, 1.0);\n"
"}\n";
display->textFProgram_to_AYUV =
"uniform sampler2DRect tex;\n"
"void main(void) {\n"
" float r,g,b,y,u,v;\n"
" vec2 nxy=gl_TexCoord[0].xy;\n"
" r=texture2DRect(tex,nxy).r;\n"
" g=texture2DRect(tex,nxy).g;\n"
" b=texture2DRect(tex,nxy).b;\n"
" y=0.299011*r + 0.586987*g + 0.114001*b;\n"
" u=-0.148246*r -0.29102*g + 0.439266*b;\n"
" v=0.439271*r - 0.367833*g - 0.071438*b ;\n"
" y=0.858885*y + 0.0625;\n"
" u=u + 0.5;\n"
" v=v + 0.5;\n"
" gl_FragColor=vec4(y,u,v,1.0);\n"
"}\n";
}
static void
gst_gl_display_finalize (GObject *object)
{
GstGLDisplay *display = GST_GL_DISPLAY (object);
//request glut window destruction
//blocking call because display must be alive
gst_gl_display_lock (display);
gst_gl_display_postMessage (GST_GL_DISPLAY_ACTION_DESTROY, display);
g_cond_wait (display->cond_destroy, display->mutex);
gst_gl_display_unlock (display);
if (display->texturePool) {
g_queue_free (display->texturePool);
display->texturePool = NULL;
}
if (display->title) {
g_string_free (display->title, TRUE);
display->title = NULL;
}
if (display->mutex) {
g_mutex_free (display->mutex);
display->mutex = NULL;
}
if (display->cond_make) {
g_cond_free (display->cond_make);
display->cond_make = NULL;
}
if (display->cond_fill) {
g_cond_free (display->cond_fill);
display->cond_fill = NULL;
}
if (display->cond_clear) {
g_cond_free (display->cond_clear);
display->cond_clear = NULL;
}
if (display->cond_video) {
g_cond_free (display->cond_video);
display->cond_video = NULL;
}
if (display->cond_download) {
g_cond_free (display->cond_download);
display->cond_download = NULL;
}
if (display->cond_generateFBO) {
g_cond_free (display->cond_generateFBO);
display->cond_generateFBO = NULL;
}
if (display->cond_useFBO) {
g_cond_free (display->cond_useFBO);
display->cond_useFBO = NULL;
}
if (display->cond_useFBO2) {
g_cond_free (display->cond_useFBO2);
display->cond_useFBO2 = NULL;
}
if (display->cond_destroyFBO) {
g_cond_free (display->cond_destroyFBO);
display->cond_destroyFBO = NULL;
}
if (display->cond_create) {
g_cond_free (display->cond_create);
display->cond_create = NULL;
}
if (display->cond_destroy) {
g_cond_free (display->cond_destroy);
display->cond_destroy = NULL;
}
if (display->clientReshapeCallback)
display->clientReshapeCallback = NULL;
if (display->clientDrawCallback)
display->clientDrawCallback = NULL;
if (display->glsceneFBO_cb)
display->glsceneFBO_cb = NULL;
if (display->glsceneFBO_cb2)
display->glsceneFBO_cb2 = NULL;
if (display->p1)
display->p1 = NULL;
if (display->p2)
display->p2 = NULL;
//at this step, the next condition imply that the last display has been pushed
if (g_hash_table_size (gst_gl_display_map) == 0)
{
g_thread_join (gst_gl_display_glutThread);
g_print ("Glut thread joined\n");
gst_gl_display_glutThread = NULL;
g_async_queue_unref (gst_gl_display_messageQueue);
g_hash_table_unref (gst_gl_display_map);
}
}
/* The glut thread handles glut events and GstGLDisplayMsg messages */
static gpointer
gst_gl_display_glutThreadFunc (GstGLDisplay *display)
{
static char *argv = "gst-launch-0.10";
static gint argc = 1;
//-display DISPLAY
//Specify the X server to connect to. If not specified, the value of the DISPLAY environment variable is used.
//Should be pass through a glimagesink property
glutInit(&argc, &argv);
glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_CONTINUE_EXECUTION);
glutIdleFunc (gst_gl_display_glut_idle);
gst_gl_display_lock (display);
gst_gl_display_glutCreateWindow (display);
gst_gl_display_unlock (display);
g_print ("Glut mainLoop start\n");
glutMainLoop ();
g_print ("Glut mainLoop exited\n");
return NULL;
}
/* Called by the idle function or when creating glut_thread */
static void
gst_gl_display_glutCreateWindow (GstGLDisplay *display)
{
gint glutWinId = 0;
gchar buffer[5];
GLenum err = 0;
//prepare opengl context
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
glutInitWindowPosition(display->win_xpos, display->win_ypos);
glutInitWindowSize(display->glcontext_width, display->glcontext_height);
//create opengl context
sprintf(buffer, "%d", glutWinId);
display->title = g_string_append (display->title, buffer);
glutWinId = glutCreateWindow (display->title->str, display->winId);
g_print ("Context %d created\n", glutWinId);
if (display->visible)
glutShowWindow ();
else
glutHideWindow ();
//Init glew
err = glewInit();
if (err != GLEW_OK)
GST_DEBUG ("Error: %s", glewGetErrorString(err));
else
{
//OpenGL > 2.1.0 and Glew > 1.5.0
GString* opengl_version = g_string_new ((gchar*) glGetString (GL_VERSION));
gboolean check_versions = g_str_has_prefix (opengl_version->str, "2.1");
GString* glew_version = g_string_new ((gchar*) glewGetString (GLEW_VERSION));
check_versions = check_versions && g_str_has_prefix (glew_version->str, "1.5");
GST_DEBUG ("GL_VERSION: %s", opengl_version->str);
GST_DEBUG ("GLEW_VERSION: %s", glew_version->str);
GST_DEBUG ("GL_VENDOR: %s\n", glGetString (GL_VENDOR));
GST_DEBUG ("GL_RENDERER: %s\n", glGetString (GL_RENDERER));
g_string_free (opengl_version, TRUE);
g_string_free (glew_version, TRUE);
if (!check_versions)
{
GST_DEBUG ("Required OpenGL > 2.1.0 and Glew > 1.5.0");
g_assert_not_reached ();
}
}
if (GLEW_EXT_framebuffer_object)
{
GST_DEBUG ("Context %d, EXT_framebuffer_object supported: yes", glutWinId);
//-- init intput frame buffer object (video -> GL)
//setup FBO
glGenFramebuffersEXT (1, &display->fbo);
glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, display->fbo);
//setup the render buffer for depth
glGenRenderbuffersEXT(1, &display->depthBuffer);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, display->depthBuffer);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT,
display->textureFBOWidth, display->textureFBOHeight);
//setup a texture to render to
glGenTextures (1, &display->textureFBO);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, display->textureFBO);
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA8,
display->textureFBOWidth, display->textureFBOHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
//attach the texture to the FBO to renderer to
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_RECTANGLE_ARB, display->textureFBO, 0);
//attach the depth render buffer to the FBO
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT,
GL_RENDERBUFFER_EXT, display->depthBuffer);
g_assert (glCheckFramebufferStatusEXT (GL_FRAMEBUFFER_EXT) ==
GL_FRAMEBUFFER_COMPLETE_EXT);
//unbind the FBO
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
}
else
{
GST_DEBUG ("Context %d, EXT_framebuffer_object supported: no", glutWinId);
g_assert_not_reached ();
}
//check if fragment program is available, then load them
if (GLEW_ARB_vertex_program)
{
gchar program[2048];
GST_DEBUG ("Context %d, ARB_fragment_program supported: yes", glutWinId);
//from video to texture
sprintf (program, display->textFProgram_YUY2_UYVY, 'r', 'g', 'a');
display->GLSLProgram_YUY2 = gst_gl_display_loadGLSLprogram (program);
sprintf (program, display->textFProgram_YUY2_UYVY, 'a', 'b', 'r');
display->GLSLProgram_UYVY = gst_gl_display_loadGLSLprogram (program);
display->GLSLProgram_I420_YV12 = gst_gl_display_loadGLSLprogram (display->textFProgram_I420_YV12);
display->GLSLProgram_AYUV = gst_gl_display_loadGLSLprogram (display->textFProgram_AYUV);
}
else
{
GST_DEBUG ("Context %d, ARB_fragment_program supported: no", glutWinId);
g_assert_not_reached ();
}
//setup callbacks
glutReshapeFunc (gst_gl_display_onReshape);
glutDisplayFunc (gst_gl_display_draw);
glutCloseFunc (gst_gl_display_onClose);
//insert glut context to the map
display->glutWinId = glutWinId;
g_hash_table_insert (gst_gl_display_map, GUINT_TO_POINTER (glutWinId), display);
//check glut id validity
g_assert (glutGetWindow() == glutWinId);
GST_DEBUG ("Context %d initialized", display->glutWinId);
//release display constructor
g_cond_signal (display->cond_create);
}
/* Called by the idle funtion */
static void
gst_gldisplay_glutGenerateOutputVideoFBO (GstGLDisplay *display)
{
glutSetWindow (display->glutWinId);
if (GLEW_EXT_framebuffer_object)
{
GST_DEBUG ("Context %d, EXT_framebuffer_object supported: yes", display->glutWinId);
//-- init graphic frame buffer object (GL texture -> GL scene)
//setup FBO
glGenFramebuffersEXT (1, &display->graphicFBO);
glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, display->graphicFBO);
//setup the render buffer for depth
glGenRenderbuffersEXT(1, &display->graphicDepthBuffer);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, display->graphicDepthBuffer);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT,
display->glcontext_width, display->glcontext_height);
//setup a texture to render to
glGenTextures (1, &display->graphicTexture);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, display->graphicTexture);
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA8,
display->glcontext_width, display->glcontext_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
//attach the texture to the FBO to renderer to
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_RECTANGLE_ARB, display->graphicTexture, 0);
//attach the depth render buffer to the FBO
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT,
GL_RENDERBUFFER_EXT, display->graphicDepthBuffer);
g_assert (glCheckFramebufferStatusEXT (GL_FRAMEBUFFER_EXT) ==
GL_FRAMEBUFFER_COMPLETE_EXT);
//unbind the FBO
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
//-- init output frame buffer object (GL -> video)
display->outputWidth = display->glcontext_width;
display->outputHeight = display->glcontext_height;
//setup FBO
glGenFramebuffersEXT (1, &display->videoFBO);
glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, display->videoFBO);
//setup the render buffer for depth
glGenRenderbuffersEXT(1, &display->videoDepthBuffer);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, display->videoDepthBuffer);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT,
display->outputWidth, display->outputHeight);
//setup a first texture to render to
glGenTextures (1, &display->videoTexture);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, display->videoTexture);
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA8,
display->outputWidth, display->outputHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
//attach the first texture to the FBO to renderer to
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_RECTANGLE_ARB, display->videoTexture, 0);
//setup a second texture to render to
glGenTextures (1, &display->videoTexture_u);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, display->videoTexture_u);
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA8,
display->outputWidth, display->outputHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
//attach the second texture to the FBO to renderer to
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT1_EXT,
GL_TEXTURE_RECTANGLE_ARB, display->videoTexture_u, 0);
//setup a third texture to render to
glGenTextures (1, &display->videoTexture_v);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, display->videoTexture_v);
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA8,
display->outputWidth, display->outputHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
//attach the third texture to the FBO to renderer to
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT2_EXT,
GL_TEXTURE_RECTANGLE_ARB, display->videoTexture_v, 0);
//attach the depth render buffer to the FBO
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT,
GL_RENDERBUFFER_EXT, display->videoDepthBuffer);
checkFramebufferStatus();
g_assert (glCheckFramebufferStatusEXT (GL_FRAMEBUFFER_EXT) ==
GL_FRAMEBUFFER_COMPLETE_EXT);
//unbind the FBO
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
display->multipleRT[0] = GL_COLOR_ATTACHMENT0_EXT;
display->multipleRT[1] = GL_COLOR_ATTACHMENT1_EXT;
display->multipleRT[2] = GL_COLOR_ATTACHMENT2_EXT;
}
else
{
GST_DEBUG ("Context %d, EXT_framebuffer_object supported: no", display->glutWinId);
g_assert_not_reached ();
}
if (GLEW_ARB_vertex_program)
{
gchar program[2048];
//from texture to video
sprintf (program, display->textFProgram_to_YUY2_UYVY, "y2,u,y1,v");
display->GLSLProgram_to_YUY2 = gst_gl_display_loadGLSLprogram (program);
sprintf (program, display->textFProgram_to_YUY2_UYVY, "v,y1,u,y2");
display->GLSLProgram_to_UYVY = gst_gl_display_loadGLSLprogram (program);
display->GLSLProgram_to_I420_YV12 = gst_gl_display_loadGLSLprogram (display->textFProgram_to_I420_YV12);
display->GLSLProgram_to_AYUV = gst_gl_display_loadGLSLprogram (display->textFProgram_to_AYUV);
}
else
{
GST_DEBUG ("Context %d, ARB_fragment_program supported: no", display->glutWinId);
g_assert_not_reached ();
}
g_cond_signal (display->cond_download);
}
/* Called by the idle funtion */
static void
gst_gl_display_glutGenerateFBO (GstGLDisplay *display)
{
glutSetWindow (display->glutWinId);
//-- generate frame buffer object
//setup FBO
glGenFramebuffersEXT (1, &display->requestedFBO);
glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, display->requestedFBO);
//setup the render buffer for depth
glGenRenderbuffersEXT(1, &display->requestedDepthBuffer);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, display->requestedDepthBuffer);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT,
display->requestedTextureFBOWidth, display->requestedTextureFBOHeight);
//setup a texture to render to
glGenTextures (1, &display->requestedTextureFBO);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, display->requestedTextureFBO);
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA8,
display->requestedTextureFBOWidth, display->requestedTextureFBOHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
//attach the texture to the FBO to renderer to
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_RECTANGLE_ARB, display->requestedTextureFBO, 0);
//attach the depth render buffer to the FBO
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT,
GL_RENDERBUFFER_EXT, display->requestedDepthBuffer);
g_assert (glCheckFramebufferStatusEXT (GL_FRAMEBUFFER_EXT) ==
GL_FRAMEBUFFER_COMPLETE_EXT);
//unbind the FBO
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
g_cond_signal (display->cond_generateFBO);
}
/* Called by the idle funtion */
static void
gst_gl_display_glutUseFBO (GstGLDisplay *display)
{
glutSetWindow (display->glutWinId);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, display->usedFBO);
glPushAttrib(GL_VIEWPORT_BIT);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluPerspective(45, (gfloat)display->usedTextureFBOWidth/(gfloat)display->usedTextureFBOHeight, 0.1, 100);
//gluOrtho2D(0.0, display->usedTextureFBOWidth, 0.0, display->usedTextureFBOHeight);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glViewport(0, 0, display->usedTextureFBOWidth, display->usedTextureFBOHeight);
glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);
glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//the opengl scene
display->glsceneFBO_cb (display->inputTextureWidth, display->inputTextureHeight, display->inputTexture);
glDrawBuffer(GL_NONE);
glUseProgramObjectARB (0);
glDisable(GL_TEXTURE_RECTANGLE_ARB);
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopAttrib();
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
g_cond_signal (display->cond_useFBO);
}
/* Called by the idle funtion */
static void
gst_gl_display_glutUseFBO2 (GstGLDisplay *display)
{
glutSetWindow (display->glutWinId);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, display->usedFBO);
glPushAttrib(GL_VIEWPORT_BIT);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
//gluPerspective(45, (gfloat)display->usedTextureFBOWidth/(gfloat)display->usedTextureFBOHeight, 0.1, 100);
gluOrtho2D(0.0, display->usedTextureFBOWidth, 0.0, display->usedTextureFBOHeight);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glViewport(0, 0, display->usedTextureFBOWidth, display->usedTextureFBOHeight);
glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);
glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//the opengl scene
display->glsceneFBO_cb2 (display->p1, display->p2, display->usedTextureFBOWidth, display->usedTextureFBOHeight);
glDrawBuffer(GL_NONE);
glUseProgramObjectARB (0);
glDisable(GL_TEXTURE_RECTANGLE_ARB);
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopAttrib();
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
g_cond_signal (display->cond_useFBO2);
}
/* Called by the idle funtion */
static void
gst_gl_display_glutDestroyFBO (GstGLDisplay *display)
{
glutSetWindow (display->glutWinId);
glDeleteFramebuffersEXT (1, &display->rejectedFBO);
glDeleteRenderbuffersEXT(1, &display->rejectedDepthBuffer);
glDeleteTextures (1, &display->rejectedTextureFBO);
display->rejectedFBO = 0;
display->rejectedDepthBuffer = 0;
display->rejectedTextureFBO = 0;
g_cond_signal (display->cond_destroyFBO);
}
/* Called by the idle function */
static void
gst_gl_display_glutDestroyWindow (GstGLDisplay *display)
{
glutSetWindow (display->glutWinId);
glutReshapeFunc (NULL);
glutDestroyWindow (display->glutWinId);
glUseProgramObjectARB (0);
glDeleteObjectARB (display->GLSLProgram_YUY2);
glDeleteObjectARB (display->GLSLProgram_UYVY);
glDeleteObjectARB (display->GLSLProgram_I420_YV12);
glDeleteObjectARB (display->GLSLProgram_AYUV);
glDeleteObjectARB (display->GLSLProgram_to_YUY2);
glDeleteObjectARB (display->GLSLProgram_to_UYVY);
glDeleteObjectARB (display->GLSLProgram_to_I420_YV12);
glDeleteObjectARB (display->GLSLProgram_to_AYUV);
glDeleteFramebuffersEXT (1, &display->fbo);
glDeleteRenderbuffersEXT(1, &display->depthBuffer);
glDeleteTextures (1, &display->textureFBO);
glDeleteFramebuffersEXT (1, &display->graphicFBO);
glDeleteRenderbuffersEXT(1, &display->graphicDepthBuffer);
glDeleteTextures (1, &display->graphicTexture);
glDeleteFramebuffersEXT (1, &display->videoFBO);
glDeleteRenderbuffersEXT(1, &display->videoDepthBuffer);
glDeleteTextures (1, &display->videoTexture);
glDeleteTextures (1, &display->videoTexture_u);
glDeleteTextures (1, &display->videoTexture_v);
//clean up the texture pool
while (g_queue_get_length (display->texturePool))
{
GstGLDisplayTex* tex = g_queue_pop_head (display->texturePool);
//delete textures
glDeleteTextures (1, &tex->texture);
if (tex->texture_u) {
glDeleteTextures (1, &tex->texture_u);
}
if (tex->texture_v) {
glDeleteTextures (1, &tex->texture_v);
}
}
g_hash_table_remove (gst_gl_display_map, GINT_TO_POINTER (display->glutWinId));
g_print ("glut window destroyed: %d\n", display->glutWinId);
//if the map is empty, leaveMainloop and join the thread
if (g_hash_table_size (gst_gl_display_map) == 0)
glutLeaveMainLoop ();
//release display destructor
g_cond_signal (display->cond_destroy);
}
/* Called by the idle function */
static void
gst_gl_display_glutSetVisibleWindow (GstGLDisplay *display)
{
glutSetWindow (display->glutWinId);
if (display->visible)
glutShowWindow ();
else
glutHideWindow ();
}
/* Called by the idle function */
static void
gst_gl_display_glutReshapeWindow (GstGLDisplay* display)
{
glutSetWindow (display->glutWinId);
glutReshapeWindow (display->glcontext_width, display->glcontext_height);
//should reset glcontext_width and height
}
/* Called by the idle function */
static void
gst_gl_display_glutPrepareTexture (GstGLDisplay * display)
{
glutSetWindow (display->glutWinId);
gst_gl_display_make_texture (display);
g_cond_signal (display->cond_make);
}
/* Called by the idle function */
static void
gst_gl_display_glutUpdateTexture (GstGLDisplay * display)
{
glutSetWindow (display->glutWinId);
gst_gl_display_fill_texture (display);
gst_gl_display_draw_texture (display);
g_cond_signal (display->cond_fill);
}
/* Called by the idle function */
static void
gst_gl_display_glutCleanTexture (GstGLDisplay * display)
{
GstGLDisplayTex* tex = NULL;
glutSetWindow (display->glutWinId);
//contructuct a texture pool element
tex = g_new0 (GstGLDisplayTex, 1);
tex->texture = display->textureTrash;
tex->texture_u = display->textureTrash_u;
tex->texture_v = display->textureTrash_v;
display->textureTrash = 0;
display->textureTrash_u = 0;
display->textureTrash_v = 0;
//add tex to the pool, it makes texture allocation reusable
g_queue_push_tail (display->texturePool, tex);
g_cond_signal (display->cond_clear);
}
/* Called by the idle function */
static void
gst_gl_display_glutUpdateVideo (GstGLDisplay * display)
{
glutSetWindow (display->glutWinId);
gst_gl_display_draw_graphic (display);
gst_gl_display_fill_video (display);
g_cond_signal (display->cond_video);
}
/* Called by the idle function */
static void
gst_gl_display_glutPostRedisplay (GstGLDisplay * display)
{
glutSetWindow (display->glutWinId);
glutPostRedisplay ();
}
/* Called continuously from freeglut while no events are pending */
static void
gst_gl_display_glut_idle (void)
{
GTimeVal timeout;
GstGLDisplayMsg *msg;
//check for pending actions that require a glut context
g_get_current_time (&timeout);
g_time_val_add (&timeout, 1000000L); //timeout 1 sec
msg = g_async_queue_timed_pop (gst_gl_display_messageQueue, &timeout);
if (msg)
{
if (gst_gl_display_checkMsgValidity (msg))
gst_gl_display_glutDispatchAction (msg);
while (g_async_queue_length (gst_gl_display_messageQueue))
{
msg = g_async_queue_pop (gst_gl_display_messageQueue);
if (gst_gl_display_checkMsgValidity (msg))
gst_gl_display_glutDispatchAction (msg);
}
}
else g_print ("timeout reached in idle func\n");
}
/* Called by the glut idle function */
static void
gst_gl_display_glutDispatchAction (GstGLDisplayMsg* msg)
{
gst_gl_display_lock (msg->display);
switch (msg->action)
{
case GST_GL_DISPLAY_ACTION_CREATE:
gst_gl_display_glutCreateWindow (msg->display);
break;
case GST_GL_DISPLAY_ACTION_DESTROY:
gst_gl_display_glutDestroyWindow (msg->display);
break;
case GST_GL_DISPLAY_ACTION_VISIBLE:
gst_gl_display_glutSetVisibleWindow (msg->display);
break;
case GST_GL_DISPLAY_ACTION_RESHAPE:
gst_gl_display_glutReshapeWindow (msg->display);
break;
case GST_GL_DISPLAY_ACTION_PREPARE:
gst_gl_display_glutPrepareTexture (msg->display);
break;
case GST_GL_DISPLAY_ACTION_CHANGE:
gst_gl_display_glutUpdateTexture (msg->display);
break;
case GST_GL_DISPLAY_ACTION_CLEAR:
gst_gl_display_glutCleanTexture (msg->display);
break;
case GST_GL_DISPLAY_ACTION_VIDEO:
gst_gl_display_glutUpdateVideo (msg->display);
break;
case GST_GL_DISPLAY_ACTION_REDISPLAY:
gst_gl_display_glutPostRedisplay (msg->display);
break;
case GST_GL_DISPLAY_ACTION_GENFBO:
gst_gl_display_glutGenerateFBO (msg->display);
break;
case GST_GL_DISPLAY_ACTION_DELFBO:
gst_gl_display_glutDestroyFBO (msg->display);
break;
case GST_GL_DISPLAY_ACTION_USEFBO:
gst_gl_display_glutUseFBO (msg->display);
break;
case GST_GL_DISPLAY_ACTION_USEFBO2:
gst_gl_display_glutUseFBO2 (msg->display);
break;
case GST_GL_DISPLAY_ACTION_OVFBO:
gst_gldisplay_glutGenerateOutputVideoFBO (msg->display);
break;
default:
g_assert_not_reached ();
}
gst_gl_display_unlock (msg->display);
g_free (msg);
}
/* Return false if the message is out of date */
static gboolean
gst_gl_display_checkMsgValidity (GstGLDisplayMsg *msg)
{
gboolean valid = TRUE;
switch (msg->action)
{
case GST_GL_DISPLAY_ACTION_CREATE:
valid = TRUE;
break;
case GST_GL_DISPLAY_ACTION_DESTROY:
case GST_GL_DISPLAY_ACTION_VISIBLE:
case GST_GL_DISPLAY_ACTION_RESHAPE:
case GST_GL_DISPLAY_ACTION_PREPARE:
case GST_GL_DISPLAY_ACTION_CHANGE:
case GST_GL_DISPLAY_ACTION_CLEAR:
case GST_GL_DISPLAY_ACTION_VIDEO:
case GST_GL_DISPLAY_ACTION_REDISPLAY:
case GST_GL_DISPLAY_ACTION_GENFBO:
case GST_GL_DISPLAY_ACTION_DELFBO:
case GST_GL_DISPLAY_ACTION_USEFBO:
case GST_GL_DISPLAY_ACTION_USEFBO2:
case GST_GL_DISPLAY_ACTION_OVFBO:
//msg is out of date if the associated display is not in the map
if (!g_hash_table_lookup (gst_gl_display_map, GINT_TO_POINTER (msg->glutWinId)))
valid = FALSE;
break;
default:
g_assert_not_reached ();
}
return valid;
}
//------------------------------------------------------------
//---------------------- For each GstGLDisplay ---------------
//------------------------------------------------------------
GstGLDisplay *
gst_gl_display_new (void)
{
return g_object_new (GST_TYPE_GL_DISPLAY, NULL);
}
/* Init an opengl context */
void
gst_gl_display_initGLContext (GstGLDisplay *display,
GLint x, GLint y,
GLint graphic_width, GLint graphic_height,
GLint video_width, GLint video_height,
gulong winId,
gboolean visible)
{
gst_gl_display_lock (display);
display->winId = winId;
display->win_xpos = x;
display->win_ypos = y;
display->glcontext_width = graphic_width;
display->glcontext_height = graphic_height;
display->textureFBOWidth = video_width;
display->textureFBOHeight = video_height;
display->visible = visible;
//if no glut_thread exists, create it with a window associated to the display
if (!gst_gl_display_map)
{
gst_gl_display_messageQueue = g_async_queue_new ();
gst_gl_display_map = g_hash_table_new (g_direct_hash, g_direct_equal);
gst_gl_display_glutThread = g_thread_create (
(GThreadFunc) gst_gl_display_glutThreadFunc, display, TRUE, NULL);
g_cond_wait (display->cond_create, display->mutex);
}
//request glut window creation
else
{
//blocking call because glut context must be alive
gst_gl_display_postMessage (GST_GL_DISPLAY_ACTION_CREATE, display);
g_cond_wait (display->cond_create, display->mutex);
}
gst_gl_display_unlock (display);
}
void
gst_gl_display_lock (GstGLDisplay * display)
{
g_mutex_lock (display->mutex);
}
void
gst_gl_display_unlock (GstGLDisplay * display)
{
g_mutex_unlock (display->mutex);
}
/* Post a message that will be handled by the idle function */
void
gst_gl_display_postMessage (GstGLDisplayAction action, GstGLDisplay* display)
{
GstGLDisplayMsg* msg = g_new0 (GstGLDisplayMsg, 1);
msg->action = action;
msg->glutWinId = display->glutWinId;
msg->display = display;
g_async_queue_push (gst_gl_display_messageQueue, msg);
}
/* Called by gst_gl elements */
void
gst_gl_display_setClientReshapeCallback (GstGLDisplay * display, CRCB cb)
{
gst_gl_display_lock (display);
display->clientReshapeCallback = cb;
gst_gl_display_unlock (display);
}
/* Called by gst_gl elements */
void
gst_gl_display_setClientDrawCallback (GstGLDisplay * display, CDCB cb)
{
gst_gl_display_lock (display);
display->clientDrawCallback = cb;
gst_gl_display_unlock (display);
}
/* Called by gst gl elements */
void
gst_gl_display_setVisibleWindow (GstGLDisplay* display, gboolean visible)
{
gst_gl_display_lock (display);
if (display->visible != visible)
{
display->visible = visible;
gst_gl_display_postMessage (GST_GL_DISPLAY_ACTION_VISIBLE, display);
}
gst_gl_display_unlock (display);
}
/* Called by gst gl elements */
void
gst_gl_display_resizeWindow (GstGLDisplay* display, gint width, gint height)
{
gst_gl_display_lock (display);
display->glcontext_width = width;
display->glcontext_height = height;
gst_gl_display_postMessage (GST_GL_DISPLAY_ACTION_RESHAPE, display);
gst_gl_display_unlock (display);
}
/* Called by gstglbuffer */
void
gst_gl_display_textureRequested (GstGLDisplay* display, GstVideoFormat video_format,
gint width, gint height, guint* texture,
guint* texture_u, guint* texture_v)
{
gst_gl_display_lock (display);
display->requestedVideo_format = video_format;
display->requestedTextureWidth = width;
display->requestedTextureHeight = height;
gst_gl_display_postMessage (GST_GL_DISPLAY_ACTION_PREPARE, display);
g_cond_wait (display->cond_make, display->mutex);
*texture = display->requestedTexture;
*texture_u = display->requestedTexture_u;
*texture_v = display->requestedTexture_v;
gst_gl_display_unlock (display);
}
/* Called by gst_gl elements */
void
gst_gl_display_textureChanged (GstGLDisplay* display, GstVideoFormat video_format,
GLuint texture, GLuint texture_u, GLuint texture_v,
gint width, gint height, gpointer data, GLuint* outputTexture)
{
gst_gl_display_lock (display);
display->candidateTexture = texture;
display->candidateTexture_u = texture_u;
display->candidateTexture_v = texture_v;
display->candidateVideo_format = video_format;
display->candidateTextureWidth = width;
display->candidateTextureHeight = height;
display->candidateData = data;
gst_gl_display_postMessage (GST_GL_DISPLAY_ACTION_CHANGE, display);
g_cond_wait (display->cond_fill, display->mutex);
//Here texture width and height are always the same than the fbo
if (outputTexture)
*outputTexture = display->textureFBO;
gst_gl_display_unlock (display);
}
/* Called by gstglbuffer */
void
gst_gl_display_clearTexture (GstGLDisplay* display, guint texture,
guint texture_u, guint texture_v)
{
gst_gl_display_lock (display);
display->textureTrash = texture;
display->textureTrash_u = texture_u;
display->textureTrash_v = texture_v;
gst_gl_display_postMessage (GST_GL_DISPLAY_ACTION_CLEAR, display);
g_cond_wait (display->cond_clear, display->mutex);
gst_gl_display_unlock (display);
}
/* Called by gst_gl elements */
void
gst_gl_display_videoChanged (GstGLDisplay* display, GstVideoFormat video_format,
gint width, gint height, GLuint recordedTexture, gpointer data)
{
gst_gl_display_lock (display);
//data size is aocciated to the glcontext size
display->outputVideo_format = video_format;
display->outputData = data;
display->recordedTexture = recordedTexture;
display->recordedTextureWidth = width;
display->recordedTextureHeight = height;
gst_gl_display_postMessage (GST_GL_DISPLAY_ACTION_VIDEO, display);
g_cond_wait (display->cond_video, display->mutex);
gst_gl_display_unlock (display);
}
/* Called by gst_gl elements */
gboolean
gst_gl_display_postRedisplay (GstGLDisplay* display, GLuint texture, gint width , gint height)
{
gboolean isAlive = TRUE;
gst_gl_display_lock (display);
isAlive = display->isAlive;
if (texture)
{
display->displayedTexture = texture;
display->displayedTextureWidth = width;
display->displayedTextureHeight = height;
}
gst_gl_display_postMessage (GST_GL_DISPLAY_ACTION_REDISPLAY, display);
gst_gl_display_unlock (display);
return isAlive;
}
/* Called by gst_gl elements */
void
gst_gl_display_requestFBO (GstGLDisplay* display, gint width, gint height,
guint* fbo, guint* depthbuffer, guint* texture)
{
gst_gl_display_lock (display);
display->requestedTextureFBOWidth = width;
display->requestedTextureFBOHeight = height;
gst_gl_display_postMessage (GST_GL_DISPLAY_ACTION_GENFBO, display);
g_cond_wait (display->cond_generateFBO, display->mutex);
*fbo = display->requestedFBO;
*depthbuffer = display->requestedDepthBuffer;
*texture = display->requestedTextureFBO;
gst_gl_display_unlock (display);
}
/* Called by gst_gl elements */
void
gst_gl_display_useFBO (GstGLDisplay* display, gint textureFBOWidth, gint textureFBOheight,
guint fbo, guint depthbuffer, guint textureFBO, GLCB cb,
guint inputTextureWidth, guint inputTextureHeight, guint inputTexture)
{
gst_gl_display_lock (display);
display->usedFBO = fbo;
display->usedDepthBuffer = depthbuffer;
display->usedTextureFBO = textureFBO;
display->usedTextureFBOWidth = textureFBOWidth;
display->usedTextureFBOHeight = textureFBOheight;
display->glsceneFBO_cb = cb;
display->inputTextureWidth = inputTextureWidth;
display->inputTextureHeight = inputTextureHeight;
display->inputTexture = inputTexture;
gst_gl_display_postMessage (GST_GL_DISPLAY_ACTION_USEFBO, display);
g_cond_wait (display->cond_useFBO, display->mutex);
gst_gl_display_unlock (display);
}
/* Called by gst_gl elements */
void
gst_gl_display_useFBO2 (GstGLDisplay* display, gint textureFBOWidth, gint textureFBOheight,
guint fbo, guint depthbuffer, guint textureFBO, GLCB2 cb2,
gpointer* p1, gpointer* p2)
{
gst_gl_display_lock (display);
display->usedFBO = fbo;
display->usedDepthBuffer = depthbuffer;
display->usedTextureFBO = textureFBO;
display->usedTextureFBOWidth = textureFBOWidth;
display->usedTextureFBOHeight = textureFBOheight;
display->glsceneFBO_cb2 = cb2;
gst_gl_display_postMessage (GST_GL_DISPLAY_ACTION_USEFBO2, display);
g_cond_wait (display->cond_useFBO2, display->mutex);
gst_gl_display_unlock (display);
}
/* Called by gst_gl elements */
void
gst_gl_display_rejectFBO (GstGLDisplay* display, guint fbo,
guint depthbuffer, guint texture)
{
gst_gl_display_lock (display);
display->rejectedFBO = fbo;
display->rejectedDepthBuffer = depthbuffer;
display->rejectedTextureFBO = texture;
gst_gl_display_postMessage (GST_GL_DISPLAY_ACTION_DELFBO, display);
g_cond_wait (display->cond_destroyFBO, display->mutex);
gst_gl_display_unlock (display);
}
/* Called by gst_gl elements */
void
gst_gl_display_initDonwloadFBO (GstGLDisplay* display, gint width, gint height)
{
gst_gl_display_lock (display);
display->glcontext_width = width;
display->glcontext_height = height;
gst_gl_display_postMessage (GST_GL_DISPLAY_ACTION_OVFBO, display);
g_cond_wait (display->cond_download, display->mutex);
gst_gl_display_unlock (display);
}
/* Called by gst_gl elements */
void
gst_gl_display_set_windowId (GstGLDisplay* display, gulong winId)
{
static gint glheight = 0;
gst_gl_display_lock (display);
gst_gl_display_postMessage (GST_GL_DISPLAY_ACTION_DESTROY, display);
g_cond_wait (display->cond_destroy, display->mutex);
gst_gl_display_unlock (display);
if (g_hash_table_size (gst_gl_display_map) == 0)
{
g_thread_join (gst_gl_display_glutThread);
g_print ("Glut thread joined when setting winId\n");
gst_gl_display_glutThread = NULL;
g_async_queue_unref (gst_gl_display_messageQueue);
g_hash_table_unref (gst_gl_display_map);
gst_gl_display_map = NULL;
}
//init opengl context
gst_gl_display_initGLContext (display,
50, glheight++ * (display->glcontext_height+50) + 50,
display->glcontext_width, display->glcontext_height,
display->textureFBOWidth, display->textureFBOHeight,
winId,
TRUE);
}
/* glutReshapeFunc callback */
void
gst_gl_display_onReshape(gint width, gint height)
{
gint glutWinId = 0;
GstGLDisplay *display = NULL;
//retrieve the display associated to the glut context
glutWinId = glutGetWindow ();
display = g_hash_table_lookup (gst_gl_display_map, GINT_TO_POINTER (glutWinId));
//glutGetWindow return 0 if no windows exists, then g_hash_table_lookup return NULL
if (display == NULL) return;
gst_gl_display_lock (display);
//check if a client reshape callback is registered
if (display->clientReshapeCallback)
display->clientReshapeCallback(width, height);
//default reshape
else
{
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0, width, 0, height);
glMatrixMode(GL_MODELVIEW);
}
gst_gl_display_unlock (display);
}
/* glutDisplayFunc callback */
void gst_gl_display_draw(void)
{
gint glutWinId = 0;
GstGLDisplay *display = NULL;
//retrieve the display associated to the glut context
glutWinId = glutGetWindow ();
display = g_hash_table_lookup (gst_gl_display_map, GINT_TO_POINTER (glutWinId));
//glutGetWindow return 0 if no windows exists, then g_hash_table_lookup return NULL
if (display == NULL) return;
//lock the display because gstreamer elements
//(and so the main thread) may modify it
gst_gl_display_lock (display);
//check if video format has been setup
if (!display->displayedTexture)
{
gst_gl_display_unlock (display);
return;
}
//opengl scene
glUseProgramObjectARB (0);
glDisable (GL_TEXTURE_RECTANGLE_ARB);
glBindTexture (GL_TEXTURE_RECTANGLE_ARB, 0);
//check if a client draw callback is registered
if (display->clientDrawCallback)
{
gboolean doRedisplay =
display->clientDrawCallback(display->displayedTexture,
display->displayedTextureWidth, display->displayedTextureHeight);
glFlush();
glutSwapBuffers();
if (doRedisplay)
gst_gl_display_postMessage (GST_GL_DISPLAY_ACTION_REDISPLAY, display);
}
//default opengl scene
else
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->displayedTexture);
glEnable (GL_TEXTURE_RECTANGLE_ARB);
glBegin (GL_QUADS);
glTexCoord2i (display->displayedTextureWidth, 0);
glVertex2f (1.0f, 1.0f);
glTexCoord2i (0, 0);
glVertex2f (-1.0f, 1.0f);
glTexCoord2i (0, display->displayedTextureHeight);
glVertex2f (-1.0f, -1.0f);
glTexCoord2i (display->displayedTextureWidth, display->displayedTextureHeight);
glVertex2f (1.0f, -1.0f);
glEnd ();
glDisable(GL_TEXTURE_RECTANGLE_ARB);
glFlush();
glutSwapBuffers();
}//end default opengl scene
gst_gl_display_unlock (display);
}
/* glutCloseFunc callback */
void gst_gl_display_onClose (void)
{
gint glutWinId = 0;
GstGLDisplay* display = NULL;
//retrieve the display associated to the glut context
glutWinId = glutGetWindow ();
display = g_hash_table_lookup (gst_gl_display_map, GINT_TO_POINTER (glutWinId));
//glutGetWindow return 0 if no windows exists, then g_hash_table_lookup return NULL
if (display == NULL) return;
GST_DEBUG ("on close");
gst_gl_display_lock (display);
display->isAlive = FALSE;
gst_gl_display_unlock (display);
}
/* called by gst_gl_display_glutPrepareTexture (in the glut thread) */
void gst_gl_display_make_texture (GstGLDisplay * display)
{
GstGLDisplayTex* tex = NULL;
//check if there is a tex available in the pool
if (g_queue_get_length (display->texturePool))
tex = g_queue_pop_head (display->texturePool);
//one tex is available
if (tex)
display->requestedTexture = tex->texture;
else
glGenTextures (1, &display->requestedTexture);
glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->requestedTexture);
switch (display->requestedVideo_format) {
case GST_VIDEO_FORMAT_RGBx:
case GST_VIDEO_FORMAT_BGRx:
case GST_VIDEO_FORMAT_xRGB:
case GST_VIDEO_FORMAT_xBGR:
case GST_VIDEO_FORMAT_RGBA:
case GST_VIDEO_FORMAT_BGRA:
case GST_VIDEO_FORMAT_ARGB:
case GST_VIDEO_FORMAT_ABGR:
case GST_VIDEO_FORMAT_AYUV:
glTexImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA,
display->requestedTextureWidth, display->requestedTextureHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
break;
case GST_VIDEO_FORMAT_RGB:
case GST_VIDEO_FORMAT_BGR:
glTexImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGB,
display->requestedTextureWidth, display->requestedTextureHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
break;
case GST_VIDEO_FORMAT_YUY2:
case GST_VIDEO_FORMAT_UYVY:
glTexImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE_ALPHA,
display->requestedTextureWidth, display->requestedTextureHeight,
0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, NULL);
//one tex is available
if (tex)
display->requestedTexture_u = tex->texture_u;
else
glGenTextures (1, &display->requestedTexture_u);
glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->requestedTexture_u);
glTexImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA8,
display->requestedTextureWidth, display->requestedTextureHeight,
0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL);
break;
case GST_VIDEO_FORMAT_I420:
case GST_VIDEO_FORMAT_YV12:
glTexImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE,
display->requestedTextureWidth, display->requestedTextureHeight,
0, GL_LUMINANCE, GL_UNSIGNED_BYTE, NULL);
//one tex is available
if (tex)
display->requestedTexture_u = tex->texture_u;
else
glGenTextures (1, &display->requestedTexture_u);
glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->requestedTexture_u);
glTexImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE,
GST_ROUND_UP_2 (display->requestedTextureWidth) / 2,
GST_ROUND_UP_2 (display->requestedTextureHeight) / 2,
0, GL_LUMINANCE, GL_UNSIGNED_BYTE, NULL);
//one tex is available
if (tex)
display->requestedTexture_v = tex->texture_v;
else
glGenTextures (1, &display->requestedTexture_v);
glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->requestedTexture_v);
glTexImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, GL_LUMINANCE,
GST_ROUND_UP_2 (display->requestedTextureWidth) / 2,
GST_ROUND_UP_2 (display->requestedTextureHeight) / 2,
0, GL_LUMINANCE, GL_UNSIGNED_BYTE, NULL);
break;
default:
g_assert_not_reached ();
}
if (tex)
g_free (tex);
}
/* called by gst_gl_display_glutUpdateTexture (in the glut thread) */
void
gst_gl_display_fill_texture (GstGLDisplay * display)
{
GstVideoFormat video_format = display->candidateVideo_format;
gint width = display->candidateTextureWidth;
gint height = display->candidateTextureHeight;
gpointer data = display->candidateData;
glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->candidateTexture);
switch (video_format) {
case GST_VIDEO_FORMAT_RGBx:
glTexSubImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, 0, 0, width, height,
GL_RGBA, GL_UNSIGNED_BYTE, data);
break;
case GST_VIDEO_FORMAT_BGRx:
glTexSubImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, 0, 0, width, height,
GL_BGRA, GL_UNSIGNED_BYTE, data);
break;
case GST_VIDEO_FORMAT_AYUV:
case GST_VIDEO_FORMAT_xRGB:
glTexSubImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, 0, 0, width, height,
GL_BGRA, GL_UNSIGNED_INT_8_8_8_8, data);
break;
case GST_VIDEO_FORMAT_xBGR:
glTexSubImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, 0, 0, width, height,
GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, data);
break;
case GST_VIDEO_FORMAT_YUY2:
case GST_VIDEO_FORMAT_UYVY:
glTexSubImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, 0, 0, width, height,
GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, data);
glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->candidateTexture_u);
glTexSubImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, 0, 0,
GST_ROUND_UP_2 (width) / 2, height,
GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, data);
break;
case GST_VIDEO_FORMAT_I420:
case GST_VIDEO_FORMAT_YV12:
{
gint offsetU = 0;
gint offsetV = 0;
switch (video_format)
{
case GST_VIDEO_FORMAT_I420:
offsetU = 1;
offsetV = 2;
break;
case GST_VIDEO_FORMAT_YV12:
offsetU = 2;
offsetV = 1;
break;
default:
g_assert_not_reached ();
}
glTexSubImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, 0, 0, width, height,
GL_LUMINANCE, GL_UNSIGNED_BYTE, data);
glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->candidateTexture_u);
glTexSubImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, 0, 0,
GST_ROUND_UP_2 (width) / 2, GST_ROUND_UP_2 (height) / 2,
GL_LUMINANCE, GL_UNSIGNED_BYTE,
(guint8 *) data +
gst_video_format_get_component_offset (video_format, offsetU, width, height));
glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->candidateTexture_v);
glTexSubImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, 0, 0,
GST_ROUND_UP_2 (width) / 2, GST_ROUND_UP_2 (height) / 2,
GL_LUMINANCE, GL_UNSIGNED_BYTE,
(guint8 *) data +
gst_video_format_get_component_offset (video_format, offsetV, width, height));
}
break;
default:
g_assert_not_reached ();
}
//candidate textures can now be used
display->currentTexture = display->candidateTexture;
display->currentTexture_u = display->candidateTexture_u;
display->currentTexture_v = display->candidateTexture_v;
display->currentVideo_format = display->candidateVideo_format;
display->currentTextureWidth = display->candidateTextureWidth;
display->currentTextureHeight = display->candidateTextureHeight;
}
/* called by gst_gl_display_glutUpdateTexture (in the glut thread) */
void
gst_gl_display_draw_texture (GstGLDisplay* display)
{
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, display->fbo);
glPushAttrib(GL_VIEWPORT_BIT);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluOrtho2D(0.0, display->textureFBOWidth, 0.0, display->textureFBOHeight);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glViewport(0, 0, display->textureFBOWidth, display->textureFBOHeight);
glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);
glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
switch (display->currentVideo_format)
{
case GST_VIDEO_FORMAT_RGBx:
case GST_VIDEO_FORMAT_BGRx:
case GST_VIDEO_FORMAT_xRGB:
case GST_VIDEO_FORMAT_xBGR:
{
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
glEnable(GL_TEXTURE_RECTANGLE_ARB);
glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->currentTexture);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
}
break;
case GST_VIDEO_FORMAT_YUY2:
case GST_VIDEO_FORMAT_UYVY:
{
gint i=0;
GLhandleARB GLSLProgram_YUY2_UYVY = 0;
switch (display->currentVideo_format)
{
case GST_VIDEO_FORMAT_YUY2:
GLSLProgram_YUY2_UYVY = display->GLSLProgram_YUY2;
break;
case GST_VIDEO_FORMAT_UYVY:
GLSLProgram_YUY2_UYVY = display->GLSLProgram_UYVY;
break;
default:
g_assert_not_reached ();
}
glUseProgramObjectARB (GLSLProgram_YUY2_UYVY);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
glActiveTextureARB(GL_TEXTURE1_ARB);
i = glGetUniformLocationARB (GLSLProgram_YUY2_UYVY, "UVtex");
glUniform1iARB (i, 1);
glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->currentTexture_u);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glActiveTextureARB(GL_TEXTURE0_ARB);
i = glGetUniformLocationARB (GLSLProgram_YUY2_UYVY, "Ytex");
glUniform1iARB (i, 0);
glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->currentTexture);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
}
break;
case GST_VIDEO_FORMAT_I420:
case GST_VIDEO_FORMAT_YV12:
{
gint i=0;
glUseProgramObjectARB (display->GLSLProgram_I420_YV12);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
glActiveTextureARB(GL_TEXTURE1_ARB);
i = glGetUniformLocationARB (display->GLSLProgram_I420_YV12, "Utex");
glUniform1iARB (i, 1);
glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->currentTexture_u);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glActiveTextureARB(GL_TEXTURE2_ARB);
i = glGetUniformLocationARB (display->GLSLProgram_I420_YV12, "Vtex");
glUniform1iARB (i, 2);
glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->currentTexture_v);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glActiveTextureARB(GL_TEXTURE0_ARB);
i = glGetUniformLocationARB (display->GLSLProgram_I420_YV12, "Ytex");
glUniform1iARB (i, 0);
glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->currentTexture);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
}
break;
case GST_VIDEO_FORMAT_AYUV:
{
gint i=0;
glUseProgramObjectARB (display->GLSLProgram_AYUV);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
glActiveTextureARB(GL_TEXTURE0_ARB);
i = glGetUniformLocationARB (display->GLSLProgram_AYUV, "tex");
glUniform1iARB (i, 0);
glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->currentTexture);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri (GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
}
break;
default:
g_assert_not_reached ();
}//end switch display->currentVideo_format
glBegin (GL_QUADS);
glTexCoord2i (display->currentTextureWidth, 0);
glVertex2f (1.0f, -1.0f);
glTexCoord2i (0, 0);
glVertex2f (-1.0f, -1.0f);
glTexCoord2i (0, display->currentTextureHeight);
glVertex2f (-1.0f, 1.0f);
glTexCoord2i (display->currentTextureWidth, display->currentTextureHeight);
glVertex2f (1.0f, 1.0f);
glEnd ();
glDrawBuffer(GL_NONE);
glUseProgramObjectARB (0);
glDisable(GL_TEXTURE_RECTANGLE_ARB);
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopAttrib();
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
checkFramebufferStatus();
}
/* called by gst_gl_display_glutUpdateTexture (in the glut thread) */
void
gst_gl_display_draw_graphic (GstGLDisplay* display)
{
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, display->graphicFBO);
glPushAttrib(GL_VIEWPORT_BIT);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluPerspective(45, (gfloat)display->glcontext_width/(gfloat)display->glcontext_height, 0.1, 100);
//gluOrtho2D(0.0, display->glcontext_width, 0.0, display->glcontext_height);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glViewport(0, 0, display->glcontext_width, display->glcontext_height);
glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);
glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//check if a client draw callback is registered
if (display->clientDrawCallback)
{
display->clientDrawCallback(display->recordedTexture,
display->recordedTextureWidth, display->recordedTextureHeight);
}
else
{
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->recordedTexture);
glEnable (GL_TEXTURE_RECTANGLE_ARB);
glBegin (GL_QUADS);
glTexCoord2i (display->recordedTextureWidth, 0);
glVertex2f (1.0f, 1.0f);
glTexCoord2i (0, 0);
glVertex2f (-1.0f, 1.0f);
glTexCoord2i (0, display->recordedTextureHeight);
glVertex2f (-1.0f, -1.0f);
glTexCoord2i (display->recordedTextureWidth, display->recordedTextureHeight);
glVertex2f (1.0f, -1.0f);
glEnd ();
}
glDrawBuffer(GL_NONE);
glUseProgramObjectARB (0);
glDisable(GL_TEXTURE_RECTANGLE_ARB);
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopAttrib();
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
checkFramebufferStatus();
}
/* called by gst_gl_display_glutUpdateVideo (in the glut thread) */
void
gst_gl_display_fill_video (GstGLDisplay* display)
{
gint width = display->outputWidth;
gint height = display->outputHeight;
GstVideoFormat outputVideo_format = display->outputVideo_format;
gpointer data = display->outputData;
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, display->videoFBO);
glPushAttrib(GL_VIEWPORT_BIT);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluOrtho2D(0.0, width, 0.0, height);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glViewport(0, 0, width, height);
switch (outputVideo_format)
{
case GST_VIDEO_FORMAT_RGBx:
case GST_VIDEO_FORMAT_BGRx:
case GST_VIDEO_FORMAT_xRGB:
case GST_VIDEO_FORMAT_xBGR:
{
glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);
glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->graphicTexture);
glEnable(GL_TEXTURE_RECTANGLE_ARB);
}
break;
case GST_VIDEO_FORMAT_YUY2:
case GST_VIDEO_FORMAT_UYVY:
{
gint i=0;
GLhandleARB GLSLProgram_to_YUY2_UYVY = 0;
switch (outputVideo_format)
{
case GST_VIDEO_FORMAT_YUY2:
GLSLProgram_to_YUY2_UYVY = display->GLSLProgram_to_YUY2;
break;
case GST_VIDEO_FORMAT_UYVY:
GLSLProgram_to_YUY2_UYVY = display->GLSLProgram_to_UYVY;
break;
default:
g_assert_not_reached ();
}
glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);
glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glUseProgramObjectARB (GLSLProgram_to_YUY2_UYVY);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
glActiveTextureARB(GL_TEXTURE0_ARB);
i = glGetUniformLocationARB (GLSLProgram_to_YUY2_UYVY, "tex");
glUniform1iARB (i, 0);
glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->graphicTexture);
}
break;
case GST_VIDEO_FORMAT_I420:
case GST_VIDEO_FORMAT_YV12:
{
gint i=0;
glDrawBuffers(3, display->multipleRT);
glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glUseProgramObjectARB (display->GLSLProgram_to_I420_YV12);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
glActiveTextureARB(GL_TEXTURE0_ARB);
i = glGetUniformLocationARB (display->GLSLProgram_to_I420_YV12, "tex");
glUniform1iARB (i, 0);
i = glGetUniformLocationARB (display->GLSLProgram_to_I420_YV12, "w");
glUniform1fARB (i, (gfloat)width);
i = glGetUniformLocationARB (display->GLSLProgram_to_I420_YV12, "h");
glUniform1fARB (i, (gfloat)height);
glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->graphicTexture);
}
break;
case GST_VIDEO_FORMAT_AYUV:
{
gint i=0;
glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);
glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glUseProgramObjectARB (display->GLSLProgram_to_AYUV);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
glActiveTextureARB(GL_TEXTURE0_ARB);
i = glGetUniformLocationARB (display->GLSLProgram_to_AYUV, "tex");
glUniform1iARB (i, 0);
glBindTexture (GL_TEXTURE_RECTANGLE_ARB, display->graphicTexture);
}
break;
default:
g_assert_not_reached ();
}//end switch display->currentVideo_format
glBegin (GL_QUADS);
glTexCoord2i (width, 0);
glVertex2f (1.0f, 1.0f);
glTexCoord2i (0, 0);
glVertex2f (-1.0f, 1.0f);
glTexCoord2i (0, height);
glVertex2f (-1.0f, -1.0f);
glTexCoord2i (width, height);
glVertex2f (1.0f, -1.0f);
glEnd ();
glDrawBuffer(GL_NONE);
glUseProgramObjectARB (0);
glDisable(GL_TEXTURE_RECTANGLE_ARB);
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopAttrib();
glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, 0);
checkFramebufferStatus();
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, display->videoFBO);
glReadBuffer(GL_COLOR_ATTACHMENT0_EXT);
switch (outputVideo_format) {
case GST_VIDEO_FORMAT_RGBx:
glReadPixels (0, 0, width, height, GL_RGBA,
GL_UNSIGNED_BYTE, data);
break;
case GST_VIDEO_FORMAT_BGRx:
glReadPixels (0, 0, width, height, GL_BGRA,
GL_UNSIGNED_BYTE, data);
break;
case GST_VIDEO_FORMAT_xBGR:
glReadPixels (0, 0, width, height, GL_RGBA,
GL_UNSIGNED_INT_8_8_8_8, data);
break;
case GST_VIDEO_FORMAT_AYUV:
case GST_VIDEO_FORMAT_xRGB:
glReadPixels (0, 0, width, height, GL_BGRA,
GL_UNSIGNED_INT_8_8_8_8, data);
break;
case GST_VIDEO_FORMAT_YUY2:
case GST_VIDEO_FORMAT_UYVY:
glReadPixels (0, 0, GST_ROUND_UP_2 (width) / 2, height, GL_BGRA,
GL_UNSIGNED_INT_8_8_8_8_REV, data);
break;
case GST_VIDEO_FORMAT_I420:
case GST_VIDEO_FORMAT_YV12:
{
gint offsetU = 0;
gint offsetV = 0;
switch (outputVideo_format)
{
case GST_VIDEO_FORMAT_I420:
offsetU = 1;
offsetV = 2;
break;
case GST_VIDEO_FORMAT_YV12:
offsetU = 2;
offsetV = 1;
break;
default:
g_assert_not_reached ();
}
glReadPixels (0, 0, width, height, GL_LUMINANCE,
GL_UNSIGNED_BYTE, data);
glReadBuffer(GL_COLOR_ATTACHMENT1_EXT);
glReadPixels (0, 0, GST_ROUND_UP_2 (width) / 2, GST_ROUND_UP_2 (height) / 2,
GL_LUMINANCE, GL_UNSIGNED_BYTE,
(guint8 *) data +
gst_video_format_get_component_offset (outputVideo_format, offsetU, width, height));
glReadBuffer(GL_COLOR_ATTACHMENT2_EXT);
glReadPixels (0, 0, GST_ROUND_UP_2 (width) / 2, GST_ROUND_UP_2 (height) / 2,
GL_LUMINANCE, GL_UNSIGNED_BYTE,
(guint8 *) data +
gst_video_format_get_component_offset (outputVideo_format, offsetV, width, height));
}
break;
default:
g_assert_not_reached ();
}
glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, 0);
checkFramebufferStatus();
}
/* called by gst_gl_display_glutCreateWindow (in the glut thread) */
GLhandleARB
gst_gl_display_loadGLSLprogram (gchar* textFProgram)
{
GLhandleARB FHandle = 0;
GLhandleARB PHandle = 0;
gchar s[32768];
gint i = 0;
//Set up program objects
PHandle = glCreateProgramObjectARB ();
//Compile the shader
FHandle = glCreateShaderObjectARB (GL_FRAGMENT_SHADER_ARB);
glShaderSourceARB (FHandle, 1, (const GLcharARB**)&textFProgram, NULL);
glCompileShaderARB (FHandle);
//Print the compilation log
glGetObjectParameterivARB (FHandle, GL_OBJECT_COMPILE_STATUS_ARB, &i);
glGetInfoLogARB (FHandle, sizeof(s)/sizeof(char), NULL, s);
GST_DEBUG ("Compile Log: %s", s);
//link the shader
glAttachObjectARB (PHandle, FHandle);
glLinkProgramARB (PHandle);
//Print the link log
glGetInfoLogARB (PHandle, sizeof(s)/sizeof(char), NULL, s);
GST_DEBUG ("Link Log: %s", s);
return PHandle;
}
/* Called by gst_gl_display_fill_video */
void
checkFramebufferStatus(void)
{
GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
switch(status)
{
case GL_FRAMEBUFFER_COMPLETE_EXT:
break;
case GL_FRAMEBUFFER_UNSUPPORTED_EXT:
GST_DEBUG("GL_FRAMEBUFFER_UNSUPPORTED_EXT");
break;
default:
GST_DEBUG("General FBO error");
}
}
Reference in a new issue View git blame Copy permalink