mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-10-01 00:02:24 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/subprojects/gst-plugins-base/tests/examples/gl/sdl/sdlshare.c

660 lines
19 KiB
C
Raw Blame History

/*
* GStreamer
* Copyright (C) 2009 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., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#ifdef WIN32
#include <windows.h>
#endif
#include <GL/gl.h>
#include <SDL2/SDL.h>
#include <SDL2/SDL_opengl.h>
#ifndef WIN32
#include <GL/glx.h>
#include <SDL2/SDL_syswm.h>
#include <gst/gl/x11/gstgldisplay_x11.h>
#endif
#include <gst/gst.h>
#include <gst/gl/gl.h>
#include <gst/gl/gstglfuncs.h>
static GstStaticCaps render_caps =
GST_STATIC_CAPS
("video/x-raw(memory:GLMemory),format=RGBA,width=320,height=240,framerate=(fraction)30/1,texture-target=2D");
static GstVideoInfo render_video_info;
static GstPipeline *pipeline = NULL;
static GstGLContext *sdl_context;
static GstGLContext *gst_context;
static GstGLDisplay *sdl_gl_display;
static GstGLShader *texture_shader;
static GLuint texture_vao;
static GLuint texture_vbo;
static GLint texture_vertex_attr;
static GLint texture_texcoord_attr;
static GstGLShader *triangle_shader;
static GLuint triangle_vao;
static GLuint triangle_vbo;
static GLint triangle_vertex_attr;
static GLint triangle_color_attr;
static GLuint index_buffer;
/* OpenGL shaders */
static const gchar *triangle_vert = "attribute vec4 a_position;\n\
attribute vec4 a_color;\n\
uniform float yrot;\n\
varying vec4 v_color;\n\
void main()\n\
{\n\
mat4 rotate_y = mat4 (\n\
cos(yrot), 0.0, -sin(yrot), 0.0,\n\
0.0, 1.0, 0.0, 0.0,\n\
sin(yrot), 0.0, cos(yrot), 0.0,\n\
0.0, 0.0, 0.0, 1.0 );\n\
mat4 translate_x = mat4 (\n\
1.0, 0.0, 0.0, 0.0,\n\
0.0, 1.0, 0.0, 0.0,\n\
0.0, 0.0, 1.0, 0.0,\n\
-0.4, 0.0, 0.0, 1.0 );\n\
gl_Position = translate_x * rotate_y * a_position;\n\
v_color = a_color;\n\
}";
static const gchar *triangle_frag = "#ifdef GL_ES\n\
precision mediump float;\n\
#endif\n\
varying vec4 v_color;\n\
void main()\n\
{\n\
gl_FragColor = v_color;\n\
}";
static const gchar *texture_vert = "attribute vec4 a_position;\n\
attribute vec2 a_texcoord;\n\
uniform float xrot;\n\
varying vec2 v_texcoord;\n\
void main()\n\
{\n\
mat4 rotate_x = mat4 (\n\
1.0, 0.0, 0.0, 0.0,\n\
0.0, cos(xrot), sin(xrot), 0.0,\n\
0.0, -sin(xrot), cos(xrot), 0.0,\n\
0.0, 0.0, 0.0, 1.0 );\n\
gl_Position = rotate_x * a_position;\n\
v_texcoord = a_texcoord;\n\
}";
static const gchar *texture_frag = "#ifdef GL_ES\n\
precision mediump float;\n\
#endif\n\
varying vec2 v_texcoord;\n\
uniform sampler2D tex;\n\
void main()\n\
{\n\
gl_FragColor = texture2D(tex, v_texcoord);\n\
}";
/* *INDENT-OFF* */
static const float texture_vertices[] = {
/* X Y Z S T */
0.1f, 0.4f, 0.0f, 0.0f, 0.0f,
0.9f, 0.4f, 0.0f, 1.0f, 0.0f,
0.9f, -0.4f, 0.0f, 1.0f, 1.0f,
0.1f, -0.4f, 0.0f, 0.0f, 1.0f,
};
static const float triangle_vertices[] = {
/* X Y Z R G B A */
0.0f, 0.4f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f,
0.4f, -0.4f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f,
-0.4f, -0.4f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f
};
static const GLushort indices[] = { 0, 1, 2, 0, 2, 3 };
/* *INDENT-ON* */
static guint32 sdl_message_event = -1;
static SDL_Window *sdl_window;
static SDL_GLContext sdl_gl_context;
static GAsyncQueue *queue_input_buf;
static GAsyncQueue *queue_output_buf;
/* rotation angle for the triangle. */
static float rtri = 0.0f;
/* rotation angle for the quadrilateral. */
static float rquad = 0.0f;
/* A general OpenGL initialization function. Sets all of the initial parameters. */
static gboolean
InitGL (int width, int height) // We call this right after our OpenGL window is created.
{
const GstGLFuncs *gl = sdl_context->gl_vtable;
GError *error = NULL;
gboolean ret = TRUE;
gl->Viewport (0, 0, width, height);
gl->ClearColor (0.0f, 0.0f, 0.0f, 0.0f); // This Will Clear The Background Color To Black
gl->ClearDepth (1.0); // Enables Clearing Of The Depth Buffer
gl->DepthFunc (GL_LESS); // The Type Of Depth Test To Do
gl->Enable (GL_DEPTH_TEST); // Enables Depth Testing
/* setup the index buffer shared between the texture and triangle draw code */
gl->GenBuffers (1, &index_buffer);
gl->BindBuffer (GL_ELEMENT_ARRAY_BUFFER, index_buffer);
gl->BufferData (GL_ELEMENT_ARRAY_BUFFER, sizeof (indices), indices,
GL_STATIC_DRAW);
gl->BindBuffer (GL_ELEMENT_ARRAY_BUFFER, 0);
/* setup texture shader */
texture_shader = gst_gl_shader_new_link_with_stages (sdl_context, &error,
gst_glsl_stage_new_with_string (sdl_context, GL_VERTEX_SHADER,
GST_GLSL_VERSION_NONE,
GST_GLSL_PROFILE_ES | GST_GLSL_PROFILE_COMPATIBILITY, texture_vert),
gst_glsl_stage_new_with_string (sdl_context, GL_FRAGMENT_SHADER,
GST_GLSL_VERSION_NONE,
GST_GLSL_PROFILE_ES | GST_GLSL_PROFILE_COMPATIBILITY, texture_frag),
NULL);
if (!texture_shader) {
g_warning ("Failed to compile and link shader: %s", error->message);
g_clear_error (&error);
ret = FALSE;
goto out;
}
/* setup buffers for drawing the texture */
gl->GenVertexArrays (1, &texture_vao);
gl->BindVertexArray (texture_vao);
gl->BindBuffer (GL_ELEMENT_ARRAY_BUFFER, index_buffer);
gl->GenBuffers (1, &texture_vbo);
gl->BindBuffer (GL_ARRAY_BUFFER, texture_vbo);
gl->BufferData (GL_ARRAY_BUFFER, sizeof (texture_vertices), texture_vertices,
GL_STATIC_DRAW);
texture_vertex_attr = gst_gl_shader_get_attribute_location (texture_shader,
"a_position");
gl->VertexAttribPointer (texture_vertex_attr, 3, GL_FLOAT, GL_FALSE,
5 * sizeof (float), (void *) 0);
texture_texcoord_attr = gst_gl_shader_get_attribute_location (texture_shader,
"a_texcoord");
gl->VertexAttribPointer (texture_texcoord_attr, 2, GL_FLOAT, GL_FALSE,
5 * sizeof (float), (void *) (3 * sizeof (float)));
gl->EnableVertexAttribArray (texture_vertex_attr);
gl->EnableVertexAttribArray (texture_texcoord_attr);
gl->BindVertexArray (0);
/* setup triangle shader */
triangle_shader = gst_gl_shader_new_link_with_stages (sdl_context, &error,
gst_glsl_stage_new_with_string (sdl_context, GL_VERTEX_SHADER,
GST_GLSL_VERSION_NONE,
GST_GLSL_PROFILE_ES | GST_GLSL_PROFILE_COMPATIBILITY, triangle_vert),
gst_glsl_stage_new_with_string (sdl_context, GL_FRAGMENT_SHADER,
GST_GLSL_VERSION_NONE,
GST_GLSL_PROFILE_ES | GST_GLSL_PROFILE_COMPATIBILITY, triangle_frag),
NULL);
if (!triangle_shader) {
g_warning ("Failed to compile and link shader: %s", error->message);
gst_clear_object (&texture_shader);
g_clear_error (&error);
ret = FALSE;
goto out;
}
/* setup buffers for drawing the triangle */
gl->GenVertexArrays (1, &triangle_vao);
gl->BindVertexArray (triangle_vao);
gl->BindBuffer (GL_ELEMENT_ARRAY_BUFFER, index_buffer);
gl->GenBuffers (1, &triangle_vbo);
gl->BindBuffer (GL_ARRAY_BUFFER, triangle_vbo);
gl->BufferData (GL_ARRAY_BUFFER, sizeof (triangle_vertices),
triangle_vertices, GL_STATIC_DRAW);
/* reuse the index buffer */
triangle_vertex_attr = gst_gl_shader_get_attribute_location (triangle_shader,
"a_position");
gl->VertexAttribPointer (triangle_vertex_attr, 3, GL_FLOAT, GL_FALSE,
7 * sizeof (float), (void *) 0);
triangle_color_attr = gst_gl_shader_get_attribute_location (triangle_shader,
"a_color");
gl->VertexAttribPointer (triangle_color_attr, 4, GL_FLOAT, GL_FALSE,
7 * sizeof (float), (void *) (3 * sizeof (float)));
gl->EnableVertexAttribArray (triangle_vertex_attr);
gl->EnableVertexAttribArray (triangle_color_attr);
gl->BindVertexArray (0);
out:
return ret;
}
static void
DeinitGL (void)
{
const GstGLFuncs *gl = sdl_context->gl_vtable;
gst_gl_context_activate (sdl_context, TRUE);
gst_clear_object (&texture_shader);
gst_clear_object (&triangle_shader);
gst_gl_context_activate (sdl_context, FALSE);
gl->DeleteBuffers (1, &triangle_vbo);
gl->DeleteBuffers (1, &texture_vbo);
gl->DeleteBuffers (1, &index_buffer);
gl->DeleteVertexArrays (1, &triangle_vao);
gl->DeleteVertexArrays (1, &texture_vao);
}
/* The main drawing function. */
static void
DrawGLScene (GstVideoFrame * vframe)
{
const GstGLFuncs *gl = sdl_context->gl_vtable;
guint texture;
texture = *(guint *) vframe->data[0];
gl->Clear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear The Screen And The Depth Buffer
/* draw the triangle */
gl->BindVertexArray (triangle_vao);
gst_gl_shader_use (triangle_shader);
gst_gl_shader_set_uniform_1f (triangle_shader, "yrot", rtri);
gl->DrawElements (GL_TRIANGLES, 3, GL_UNSIGNED_SHORT, 0);
/* draw the textured quad */
gl->BindVertexArray (texture_vao);
gl->ActiveTexture (GL_TEXTURE0);
gl->BindTexture (GL_TEXTURE_2D, texture);
gst_gl_shader_use (texture_shader);
gst_gl_shader_set_uniform_1i (texture_shader, "tex", 0);
gst_gl_shader_set_uniform_1f (texture_shader, "xrot", rquad);
gl->DrawElements (GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);
/* reset GL state we have changed to the default */
gl->BindTexture (GL_TEXTURE_2D, 0);
gl->BindVertexArray (0);
gst_gl_context_clear_shader (sdl_context);
rtri += 1.0f * G_PI / 360.0; // Increase The Rotation Variable For The Triangle
rquad -= 1.0f * G_PI / 360.0; // Decrease The Rotation Variable For The Quad
// swap buffers to display, since we're double buffered.
SDL_GL_SwapWindow (sdl_window);
}
/* appsink new-sample callback */
static GstFlowReturn
on_new_sample (GstElement * appsink, gpointer data)
{
GstSample *sample = NULL;
GstBuffer *buf;
GstVideoFrame *vframe;
GstGLSyncMeta *sync_meta;
g_signal_emit_by_name (appsink, "pull-sample", &sample, NULL);
if (!sample)
return GST_FLOW_FLUSHING;
buf = gst_buffer_ref (gst_sample_get_buffer (sample));
gst_sample_unref (sample);
if (!gst_context) {
GstMemory *mem = gst_buffer_peek_memory (buf, 0);
gst_context = gst_object_ref (((GstGLBaseMemory *) mem)->context);
}
sync_meta = gst_buffer_get_gl_sync_meta (buf);
if (!sync_meta) {
buf = gst_buffer_make_writable (buf);
sync_meta = gst_buffer_add_gl_sync_meta (gst_context, buf);
}
gst_gl_sync_meta_set_sync_point (sync_meta, gst_context);
vframe = g_new0 (GstVideoFrame, 1);
if (!gst_video_frame_map (vframe, &render_video_info, buf,
GST_MAP_READ | GST_MAP_GL)) {
g_warning ("Failed to map the video buffer");
gst_buffer_unref (buf);
return GST_FLOW_ERROR;
}
// Another reference is owned by the video frame now and we can
// get rid of our own
gst_buffer_unref (buf);
g_async_queue_push (queue_input_buf, vframe);
/* pop then unref buffer we have finished to use in sdl */
if (g_async_queue_length (queue_output_buf) > 3) {
vframe = (GstVideoFrame *) g_async_queue_pop (queue_output_buf);
gst_video_frame_unmap (vframe);
g_free (vframe);
}
return GST_FLOW_OK;
}
static void
sync_bus_call (GstBus * bus, GstMessage * msg, gpointer data)
{
switch (GST_MESSAGE_TYPE (msg)) {
case GST_MESSAGE_NEED_CONTEXT:
{
const gchar *context_type;
gst_message_parse_context_type (msg, &context_type);
g_print ("got need context %s\n", context_type);
if (g_strcmp0 (context_type, GST_GL_DISPLAY_CONTEXT_TYPE) == 0) {
GstContext *display_context =
gst_context_new (GST_GL_DISPLAY_CONTEXT_TYPE, TRUE);
gst_context_set_gl_display (display_context, sdl_gl_display);
gst_element_set_context (GST_ELEMENT (msg->src), display_context);
gst_context_unref (display_context);
} else if (g_strcmp0 (context_type, "gst.gl.app_context") == 0) {
GstContext *app_context = gst_context_new ("gst.gl.app_context", TRUE);
GstStructure *s = gst_context_writable_structure (app_context);
gst_structure_set (s, "context", GST_TYPE_GL_CONTEXT, sdl_context,
NULL);
gst_element_set_context (GST_ELEMENT (msg->src), app_context);
gst_context_unref (app_context);
}
break;
}
default:
{
SDL_Event event = { 0, };
event.type = sdl_message_event;
SDL_PushEvent (&event);
break;
}
}
}
static void
sdl_event_loop (GstBus * bus)
{
GstVideoFrame *vframe = NULL;
gboolean quit = FALSE;
SDL_GL_MakeCurrent (sdl_window, sdl_gl_context);
SDL_GL_SetSwapInterval (1);
if (!InitGL (640, 480))
return;
while (!quit) {
SDL_Event event;
while (SDL_PollEvent (&event)) {
if (event.type == SDL_QUIT) {
quit = TRUE;
}
if (event.type == SDL_KEYDOWN) {
if (event.key.keysym.sym == SDLK_ESCAPE) {
quit = TRUE;
}
}
if (event.type == sdl_message_event) {
GstMessage *msg;
while ((msg = gst_bus_pop (bus))) {
switch (GST_MESSAGE_TYPE (msg)) {
case GST_MESSAGE_EOS:
g_print ("End-of-stream\n");
g_print
("For more information, try to run: GST_DEBUG=gl*:3 ./sdlshare\n");
quit = TRUE;
break;
case GST_MESSAGE_ERROR:
{
gchar *debug = NULL;
GError *err = NULL;
gst_message_parse_error (msg, &err, &debug);
g_print ("Error: %s\n", err->message);
g_error_free (err);
if (debug) {
g_print ("Debug deails: %s\n", debug);
g_free (debug);
}
quit = TRUE;
break;
}
default:
break;
}
gst_message_unref (msg);
}
}
}
if (g_async_queue_length (queue_input_buf) > 3) {
GstGLSyncMeta *sync_meta;
if (vframe) {
g_async_queue_push (queue_output_buf, vframe);
vframe = NULL;
}
while (g_async_queue_length (queue_input_buf) > 3) {
if (vframe) {
gst_video_frame_unmap (vframe);
g_free (vframe);
}
vframe = (GstVideoFrame *) g_async_queue_pop (queue_input_buf);
}
sync_meta = gst_buffer_get_gl_sync_meta (vframe->buffer);
if (sync_meta)
gst_gl_sync_meta_wait (sync_meta, sdl_context);
}
if (vframe)
DrawGLScene (vframe);
}
SDL_GL_MakeCurrent (sdl_window, NULL);
if (vframe)
g_async_queue_push (queue_output_buf, vframe);
DeinitGL ();
}
int
main (int argc, char **argv)
{
#ifdef WIN32
HGLRC gl_context = 0;
HDC sdl_dc = 0;
#else
SDL_SysWMinfo info;
Display *sdl_display = NULL;
GLXContext gl_context = NULL;
#endif
GstBus *bus = NULL;
GstCaps *caps;
GstElement *appsink;
GstGLPlatform gl_platform;
GError *err = NULL;
GstGLAPI gl_api;
/* Initialize SDL for video output */
if (SDL_Init (SDL_INIT_VIDEO) < 0) {
fprintf (stderr, "Unable to initialize SDL: %s\n", SDL_GetError ());
return -1;
}
gst_init (&argc, &argv);
SDL_GL_SetAttribute (SDL_GL_CONTEXT_PROFILE_MASK,
SDL_GL_CONTEXT_PROFILE_CORE);
SDL_GL_SetAttribute (SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute (SDL_GL_CONTEXT_MINOR_VERSION, 2);
sdl_message_event = SDL_RegisterEvents (1);
g_assert (sdl_message_event != -1);
/* Create a 640x480 OpenGL window */
sdl_window =
SDL_CreateWindow ("SDL and gst-plugins-gl", SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED, 640, 480, SDL_WINDOW_OPENGL);
if (sdl_window == NULL) {
fprintf (stderr, "Unable to create OpenGL screen: %s\n", SDL_GetError ());
SDL_Quit ();
return -1;
}
/* Create GL context and a wrapped GStreamer context around it */
sdl_gl_context = SDL_GL_CreateContext (sdl_window);
SDL_GL_MakeCurrent (sdl_window, sdl_gl_context);
#ifdef WIN32
gl_context = wglGetCurrentContext ();
sdl_dc = wglGetCurrentDC ();
gl_platform = GST_GL_PLATFORM_WGL;
sdl_gl_display = gst_gl_display_new ();
#else
SDL_VERSION (&info.version);
SDL_GetWindowWMInfo (sdl_window, &info);
sdl_display = info.info.x11.display;
gl_context = glXGetCurrentContext ();
gl_platform = GST_GL_PLATFORM_GLX;
sdl_gl_display =
(GstGLDisplay *) gst_gl_display_x11_new_with_display (sdl_display);
#endif
gl_api = gst_gl_context_get_current_gl_api (gl_platform, NULL, NULL);
sdl_context =
gst_gl_context_new_wrapped (sdl_gl_display, (guintptr) gl_context,
gl_platform, gl_api);
gst_gl_context_activate (sdl_context, TRUE);
if (!gst_gl_context_fill_info (sdl_context, &err)) {
fprintf (stderr, "Failed to fill in wrapped GStreamer context: %s\n",
err->message);
g_clear_error (&err);
SDL_Quit ();
return -1;
}
SDL_GL_MakeCurrent (sdl_window, NULL);
pipeline =
GST_PIPELINE (gst_parse_launch
("videotestsrc ! glupload name=upload ! gleffects effect=5 ! "
"appsink name=sink", NULL));
bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
gst_bus_enable_sync_message_emission (bus);
g_signal_connect (bus, "sync-message", G_CALLBACK (sync_bus_call), NULL);
queue_input_buf = g_async_queue_new ();
queue_output_buf = g_async_queue_new ();
appsink = gst_bin_get_by_name (GST_BIN (pipeline), "sink");
caps = gst_static_caps_get (&render_caps);
if (!gst_video_info_from_caps (&render_video_info, caps))
g_assert_not_reached ();
g_object_set (appsink, "emit-signals", TRUE, "sync", TRUE, "caps", caps,
NULL);
g_signal_connect (appsink, "new-sample", G_CALLBACK (on_new_sample), NULL);
gst_object_unref (appsink);
gst_caps_unref (caps);
gst_element_set_state (GST_ELEMENT (pipeline), GST_STATE_PLAYING);
sdl_event_loop (bus);
gst_element_set_state (GST_ELEMENT (pipeline), GST_STATE_NULL);
gst_object_unref (pipeline);
gst_object_unref (bus);
gst_gl_context_activate (sdl_context, FALSE);
gst_object_unref (sdl_context);
gst_object_unref (sdl_gl_display);
if (gst_context)
gst_object_unref (gst_context);
/* make sure there is no pending gst gl buffer in the communication queues
* between sdl and gst-gl
*/
while (g_async_queue_length (queue_input_buf) > 0) {
GstVideoFrame *vframe =
(GstVideoFrame *) g_async_queue_pop (queue_input_buf);
gst_video_frame_unmap (vframe);
g_free (vframe);
}
while (g_async_queue_length (queue_output_buf) > 0) {
GstVideoFrame *vframe =
(GstVideoFrame *) g_async_queue_pop (queue_output_buf);
gst_video_frame_unmap (vframe);
g_free (vframe);
}
SDL_GL_DeleteContext (gl_context);
SDL_DestroyWindow (sdl_window);
SDL_Quit ();
return 0;
}
Reference in a new issue View git blame Copy permalink