| /* | |
| * 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 | |
| #include <GL/gl.h> | |
| #define CLUTTER_VERSION_MIN_REQUIRED CLUTTER_VERSION_1_8 | |
| #define CLUTTER_VERSION_MAX_ALLOWED CLUTTER_VERSION_1_10 | |
| #define COGL_VERSION_MIN_REQUIRED COGL_VERSION_ENCODE (1, 16, 0) | |
| #define COGL_VERSION_MAX_ALLOWED COGL_VERSION_ENCODE (1, 18, 0) | |
| #include <clutter/clutter.h> | |
| #ifndef WIN32 | |
| #include <clutter/x11/clutter-x11.h> | |
| #include <GL/glx.h> | |
| #endif | |
| #include <gst/gst.h> | |
| #include <gst/video/video.h> | |
| #include <gst/video/gstvideometa.h> | |
| #include <gst/gl/gl.h> | |
| /* This example shows how to use textures that come from a | |
| * gst-plugins-gl pipeline, into the clutter framework | |
| * It requires at least clutter 0.8.6 | |
| */ | |
| /* rotation */ | |
| static void | |
| on_new_frame (ClutterTimeline * timeline, gint msecs, gpointer data) | |
| { | |
| ClutterActor *rect_actor = CLUTTER_ACTOR (data); | |
| ClutterActor *texture_actor = | |
| g_object_get_data (G_OBJECT (timeline), "texture_actor"); | |
| clutter_actor_set_rotation (rect_actor, CLUTTER_Z_AXIS, | |
| 60.0 * (gdouble) msecs / 1000.0, clutter_actor_get_width (rect_actor) / 2, | |
| clutter_actor_get_height (rect_actor) / 2, 0); | |
| clutter_actor_set_rotation (texture_actor, CLUTTER_Z_AXIS, | |
| 60.0 * (gdouble) msecs / 1000.0, | |
| clutter_actor_get_width (texture_actor) / 6, | |
| clutter_actor_get_height (texture_actor) / 6, 0); | |
| } | |
| /* clutter scene */ | |
| static ClutterActor * | |
| setup_stage (ClutterStage * stage) | |
| { | |
| ClutterTimeline *timeline = NULL; | |
| ClutterActor *texture_actor = NULL; | |
| ClutterColor rect_color = { 125, 50, 200, 255 }; | |
| ClutterActor *rect_actor = NULL; | |
| /* texture actor */ | |
| texture_actor = clutter_texture_new (); | |
| clutter_container_add_actor (CLUTTER_CONTAINER (stage), texture_actor); | |
| clutter_actor_set_position (texture_actor, 300, 170); | |
| clutter_actor_set_scale (texture_actor, 0.6, 0.6); | |
| clutter_actor_show (texture_actor); | |
| g_object_set_data (G_OBJECT (texture_actor), "stage", stage); | |
| /* rectangle actor */ | |
| rect_actor = clutter_rectangle_new_with_color (&rect_color); | |
| clutter_container_add_actor (CLUTTER_CONTAINER (stage), rect_actor); | |
| clutter_actor_set_size (rect_actor, 50, 50); | |
| clutter_actor_set_position (rect_actor, 300, 300); | |
| clutter_actor_show (rect_actor); | |
| /* timeline */ | |
| timeline = clutter_timeline_new (6000); | |
| g_object_set_data (G_OBJECT (timeline), "texture_actor", texture_actor); | |
| clutter_timeline_set_loop (timeline, TRUE); | |
| clutter_timeline_start (timeline); | |
| g_signal_connect (timeline, "new-frame", G_CALLBACK (on_new_frame), | |
| rect_actor); | |
| return texture_actor; | |
| } | |
| /* put a gst gl buffer in the texture actor */ | |
| static gboolean | |
| update_texture_actor (gpointer data) | |
| { | |
| ClutterTexture *texture_actor = (ClutterTexture *) data; | |
| GAsyncQueue *queue_input_buf = | |
| g_object_get_data (G_OBJECT (texture_actor), "queue_input_buf"); | |
| GAsyncQueue *queue_output_buf = | |
| g_object_get_data (G_OBJECT (texture_actor), "queue_output_buf"); | |
| GstBuffer *inbuf = g_async_queue_pop (queue_input_buf); | |
| ClutterActor *stage = g_object_get_data (G_OBJECT (texture_actor), "stage"); | |
| CoglHandle cogl_texture = 0; | |
| GstVideoMeta *v_meta; | |
| GstVideoInfo info; | |
| GstVideoFrame frame; | |
| guint tex_id; | |
| v_meta = gst_buffer_get_video_meta (inbuf); | |
| if (!v_meta) { | |
| g_warning ("Required Meta was not found on buffers"); | |
| return FALSE; | |
| } | |
| gst_video_info_set_format (&info, v_meta->format, v_meta->width, | |
| v_meta->height); | |
| if (!gst_video_frame_map (&frame, &info, inbuf, GST_MAP_READ | GST_MAP_GL)) { | |
| g_warning ("Failed to map video frame"); | |
| return FALSE; | |
| } | |
| if (!gst_is_gl_memory (frame.map[0].memory)) { | |
| g_warning ("Input buffer does not have GLMemory"); | |
| gst_video_frame_unmap (&frame); | |
| return FALSE; | |
| } | |
| tex_id = *(guint *) frame.data[0]; | |
| /* Create a cogl texture from the gst gl texture */ | |
| glEnable (GL_TEXTURE_2D); | |
| glBindTexture (GL_TEXTURE_2D, tex_id); | |
| if (glGetError () != GL_NO_ERROR) | |
| g_debug ("failed to bind texture that comes from gst-gl\n"); | |
| cogl_texture = cogl_texture_new_from_foreign (tex_id, | |
| GL_TEXTURE_2D, v_meta->width, v_meta->height, 0, 0, | |
| COGL_PIXEL_FORMAT_RGBA_8888); | |
| glBindTexture (GL_TEXTURE_2D, 0); | |
| gst_video_frame_unmap (&frame); | |
| /* Previous cogl texture is replaced and so its ref counter discreases to 0. | |
| * According to the source code, glDeleteTexture is not called when the previous | |
| * ref counter of the previous cogl texture is reaching 0 because is_foreign is TRUE */ | |
| clutter_texture_set_cogl_texture (CLUTTER_TEXTURE (texture_actor), | |
| cogl_texture); | |
| cogl_handle_unref (cogl_texture); | |
| /* we can now show the clutter scene if not yet visible */ | |
| if (!CLUTTER_ACTOR_IS_VISIBLE (stage)) | |
| clutter_actor_show_all (stage); | |
| /* push buffer so it can be unref later */ | |
| g_async_queue_push (queue_output_buf, inbuf); | |
| return FALSE; | |
| } | |
| /* fakesink handoff callback */ | |
| static void | |
| on_gst_buffer (GstElement * element, GstBuffer * buf, GstPad * pad, | |
| ClutterActor * texture_actor) | |
| { | |
| GAsyncQueue *queue_input_buf = NULL; | |
| GAsyncQueue *queue_output_buf = NULL; | |
| /* ref then push buffer to use it in clutter */ | |
| gst_buffer_ref (buf); | |
| queue_input_buf = | |
| g_object_get_data (G_OBJECT (texture_actor), "queue_input_buf"); | |
| g_async_queue_push (queue_input_buf, buf); | |
| if (g_async_queue_length (queue_input_buf) > 2) | |
| clutter_threads_add_idle_full (G_PRIORITY_HIGH, update_texture_actor, | |
| texture_actor, NULL); | |
| /* pop then unref buffer we have finished to use in clutter */ | |
| queue_output_buf = | |
| g_object_get_data (G_OBJECT (texture_actor), "queue_output_buf"); | |
| if (g_async_queue_length (queue_output_buf) > 2) { | |
| GstBuffer *buf_old = g_async_queue_pop (queue_output_buf); | |
| gst_buffer_unref (buf_old); | |
| } | |
| } | |
| /* gst bus signal watch callback */ | |
| static void | |
| end_stream_cb (GstBus * bus, GstMessage * msg, gpointer data) | |
| { | |
| 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=gldisplay:2 ./cluttershare\n"); | |
| 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); | |
| } | |
| break; | |
| } | |
| default: | |
| break; | |
| } | |
| clutter_main_quit (); | |
| } | |
| int | |
| main (int argc, char *argv[]) | |
| { | |
| ClutterInitError clutter_err = CLUTTER_INIT_ERROR_UNKNOWN; | |
| #ifdef WIN32 | |
| HGLRC clutter_gl_context = 0; | |
| HDC clutter_dc = 0; | |
| #else | |
| Display *clutter_display = NULL; | |
| Window clutter_win = 0; | |
| GLXContext clutter_gl_context = NULL; | |
| #endif | |
| GstPipeline *pipeline = NULL; | |
| GstBus *bus = NULL; | |
| GstElement *glfilter = NULL; | |
| GstState state = 0; | |
| ClutterActor *stage = NULL; | |
| ClutterActor *clutter_texture = NULL; | |
| GAsyncQueue *queue_input_buf = NULL; | |
| GAsyncQueue *queue_output_buf = NULL; | |
| GstElement *fakesink = NULL; | |
| /* init gstreamer then clutter */ | |
| gst_init (&argc, &argv); | |
| clutter_threads_init (); | |
| clutter_err = clutter_init (&argc, &argv); | |
| if (clutter_err != CLUTTER_INIT_SUCCESS) | |
| g_warning ("Failed to initalize clutter: %d\n", clutter_err); | |
| clutter_threads_enter (); | |
| g_print ("clutter version: %s\n", CLUTTER_VERSION_S); | |
| clutter_set_default_frame_rate (2); | |
| /* avoid to dispatch unecesary events */ | |
| clutter_ungrab_keyboard (); | |
| clutter_ungrab_pointer (); | |
| /* retrieve and turn off clutter opengl context */ | |
| stage = clutter_stage_get_default (); | |
| #ifdef WIN32 | |
| clutter_gl_context = wglGetCurrentContext (); | |
| clutter_dc = wglGetCurrentDC (); | |
| wglMakeCurrent (0, 0); | |
| #else | |
| clutter_display = clutter_x11_get_default_display (); | |
| clutter_win = clutter_x11_get_stage_window (CLUTTER_STAGE (stage)); | |
| clutter_gl_context = glXGetCurrentContext (); | |
| glXMakeCurrent (clutter_display, None, 0); | |
| #endif | |
| /* setup gstreamer pipeline */ | |
| pipeline = | |
| GST_PIPELINE (gst_parse_launch | |
| ("videotestsrc ! video/x-raw, width=320, height=240, framerate=(fraction)30/1 ! " | |
| "gleffects effect=5 ! glfiltercube ! fakesink sync=1", NULL)); | |
| /* setup bus */ | |
| bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline)); | |
| gst_bus_add_signal_watch (bus); | |
| g_signal_connect (bus, "message::error", G_CALLBACK (end_stream_cb), NULL); | |
| g_signal_connect (bus, "message::warning", G_CALLBACK (end_stream_cb), NULL); | |
| g_signal_connect (bus, "message::eos", G_CALLBACK (end_stream_cb), NULL); | |
| gst_object_unref (bus); | |
| /* clutter_gl_context is an external OpenGL context with which gst-plugins-gl want to share textures */ | |
| glfilter = gst_bin_get_by_name (GST_BIN (pipeline), "glfiltercube0"); | |
| g_object_set (G_OBJECT (glfilter), "external-opengl-context", | |
| clutter_gl_context, NULL); | |
| gst_object_unref (glfilter); | |
| /* NULL to PAUSED state pipeline to make sure the gst opengl context is created and | |
| * shared with the clutter one */ | |
| gst_element_set_state (GST_ELEMENT (pipeline), GST_STATE_PAUSED); | |
| state = GST_STATE_PAUSED; | |
| if (gst_element_get_state (GST_ELEMENT (pipeline), &state, NULL, | |
| GST_CLOCK_TIME_NONE) != GST_STATE_CHANGE_SUCCESS) { | |
| g_debug ("failed to pause pipeline\n"); | |
| return -1; | |
| } | |
| /* turn on back clutter opengl context */ | |
| #ifdef WIN32 | |
| wglMakeCurrent (clutter_dc, clutter_gl_context); | |
| #else | |
| glXMakeCurrent (clutter_display, clutter_win, clutter_gl_context); | |
| #endif | |
| /* clutter stage */ | |
| clutter_actor_set_size (stage, 640, 480); | |
| clutter_actor_set_position (stage, 0, 0); | |
| clutter_stage_set_title (CLUTTER_STAGE (stage), "clutter and gst-plugins-gl"); | |
| clutter_texture = setup_stage (CLUTTER_STAGE (stage)); | |
| /* append a gst-gl texture to this queue when you do not need it no more */ | |
| queue_input_buf = g_async_queue_new (); | |
| queue_output_buf = g_async_queue_new (); | |
| g_object_set_data (G_OBJECT (clutter_texture), "queue_input_buf", | |
| queue_input_buf); | |
| g_object_set_data (G_OBJECT (clutter_texture), "queue_output_buf", | |
| queue_output_buf); | |
| /* set a callback to retrieve the gst gl textures */ | |
| fakesink = gst_bin_get_by_name (GST_BIN (pipeline), "fakesink0"); | |
| g_object_set (G_OBJECT (fakesink), "signal-handoffs", TRUE, NULL); | |
| g_signal_connect (fakesink, "handoff", G_CALLBACK (on_gst_buffer), | |
| clutter_texture); | |
| gst_object_unref (fakesink); | |
| /* play gst */ | |
| gst_element_set_state (GST_ELEMENT (pipeline), GST_STATE_PLAYING); | |
| /* main loop */ | |
| clutter_main (); | |
| /* before to deinitialize the gst-gl-opengl context, | |
| * no shared context (here the clutter one) must be current | |
| */ | |
| #ifdef WIN32 | |
| wglMakeCurrent (0, 0); | |
| #else | |
| glXMakeCurrent (clutter_display, None, 0); | |
| #endif | |
| clutter_threads_leave (); | |
| /* stop and clean up the pipeline */ | |
| gst_element_set_state (GST_ELEMENT (pipeline), GST_STATE_NULL); | |
| gst_object_unref (pipeline); | |
| /* make sure there is no pending gst gl buffer in the communication queues | |
| * between clutter and gst-gl | |
| */ | |
| while (g_async_queue_length (queue_input_buf) > 0) { | |
| GstBuffer *buf = g_async_queue_pop (queue_input_buf); | |
| gst_buffer_unref (buf); | |
| } | |
| while (g_async_queue_length (queue_output_buf) > 0) { | |
| GstBuffer *buf = g_async_queue_pop (queue_output_buf); | |
| gst_buffer_unref (buf); | |
| } | |
| g_print ("END\n"); | |
| return 0; | |
| } |