gboolean
gst_gl_ensure_display (gpointer element, GstGLDisplay ** display_ptr)
{
GstGLDisplay *display;
g_return_val_if_fail (element != NULL, FALSE);
g_return_val_if_fail (display_ptr != NULL, FALSE);
/* 1) Check if the element already has a context of the specific
* type.
*/
display = *display_ptr;
if (gst_gl_display_found (element, display))
return TRUE;
gst_gl_display_context_prepare (element, display_ptr);
/* Neighbour found and it updated the display */
if (gst_gl_display_found (element, *display_ptr))
return TRUE;
/* If no neighboor, or application not interested, use system default */
display = gst_gl_display_new ();
*display_ptr = display;
gst_gl_display_context_propagate (element, display);
return display != NULL;
}
static void
setup (void)
{
display = gst_gl_display_new ();
context = gst_gl_context_new (display);
gst_gl_context_create (context, 0, NULL);
}
void
QGLRenderer::initializeGL ()
{
GstGLContext *context;
GstGLDisplay *display;
#if GST_GL_HAVE_PLATFORM_GLX
display =
(GstGLDisplay *) gst_gl_display_x11_new_with_display (QX11Info::
display ());
#else
display = gst_gl_display_new ();
#endif
/* FIXME: Allow the choice at runtime */
#if GST_GL_HAVE_PLATFORM_WGL
context =
gst_gl_context_new_wrapped (display, (guintptr) wglGetCurrentContext (),
GST_GL_PLATFORM_WGL, GST_GL_API_OPENGL);
#elif GST_GL_HAVE_PLATFORM_CGL
context =
gst_gl_context_new_wrapped (display,
(guintptr) qt_current_nsopengl_context (), GST_GL_PLATFORM_CGL,
GST_GL_API_OPENGL);
#elif GST_GL_HAVE_PLATFORM_GLX
context =
gst_gl_context_new_wrapped (display, (guintptr) glXGetCurrentContext (),
GST_GL_PLATFORM_GLX, GST_GL_API_OPENGL);
#endif
gst_object_unref (display);
// We need to unset Qt context before initializing gst-gl plugin.
// Otherwise the attempt to share gst-gl context with Qt will fail.
this->doneCurrent ();
this->gst_thread =
new GstThread (display, context, this->videoLoc,
SLOT (newFrame ()), this);
this->makeCurrent ();
QObject::connect (this->gst_thread, SIGNAL (finished ()),
this, SLOT (close ()));
QObject::connect (this, SIGNAL (closeRequested ()),
this->gst_thread, SLOT (stop ()), Qt::QueuedConnection);
qglClearColor (QApplication::palette ().color (QPalette::Active,
QPalette::Window));
//glShadeModel(GL_FLAT);
//glEnable(GL_DEPTH_TEST);
//glEnable(GL_CULL_FACE);
glEnable (GL_TEXTURE_2D); // Enable Texture Mapping
this->gst_thread->start ();
}
static void
setup (void)
{
GError *error = NULL;
display = gst_gl_display_new ();
context = gst_gl_context_new (display);
gst_gl_context_create (context, NULL, &error);
fail_if (error != NULL, "Error creating context: %s\n",
error ? error->message : "Unknown Error");
}
static GUBGraphicContext *gub_create_graphic_context_opengl(GstPipeline *pipeline, float crop_left, float crop_top, float crop_right, float crop_bottom)
{
GUBGraphicContextOpenGL *gcontext = NULL;
guintptr raw_context = gst_gl_context_get_current_gl_context(GUB_GL_PLATFORM);
if (raw_context) {
GstGLDisplay *display = gst_gl_display_new();
GstGLContext *gl_context = gst_gl_context_new_wrapped(display, raw_context, GUB_GL_PLATFORM, GST_GL_API_OPENGL);
gcontext = (GUBGraphicContextOpenGL *)malloc(sizeof(GUBGraphicContextOpenGL));
gcontext->display = display;
}
else {
gub_log("Could not retrieve current GL context");
}
return gcontext;
}
/**
* gst_gl_ensure_element_data:
* @element: the #GstElement running the query
* @display_ptr: (inout): the resulting #GstGLDisplay
* @other_context_ptr: (inout): the resulting #GstGLContext
*
* Perform the steps necessary for retrieving a #GstGLDisplay and (optionally)
* an application provided #GstGLContext from the surrounding elements or from
* the application using the #GstContext mechanism.
*
* If the contents of @display_ptr or @other_context_ptr are not %NULL, then no
* #GstContext query is necessary for #GstGLDisplay or #GstGLContext retrieval
* or is performed.
*
* This performs #GstContext queries (if necessary) for a winsys display
* connection with %GST_GL_DISPLAY_CONTEXT_TYPE, "gst.x11.display.handle", and
* "GstWaylandDisplayHandleContextType" stopping after the first successful
* retrieval.
*
* This also performs a #GstContext query (if necessary) for an optional
* application provided #GstGLContext using the name "gst.gl.app_context".
* The returned #GstGLContext will be shared with a GStreamer created OpenGL context.
*
* Returns: whether a #GstGLDisplay exists in @display_ptr
*/
gboolean
gst_gl_ensure_element_data (gpointer element, GstGLDisplay ** display_ptr,
GstGLContext ** other_context_ptr)
{
GstGLDisplay *display;
g_return_val_if_fail (element != NULL, FALSE);
g_return_val_if_fail (display_ptr != NULL, FALSE);
g_return_val_if_fail (other_context_ptr != NULL, FALSE);
/* 1) Check if the element already has a context of the specific
* type.
*/
display = *display_ptr;
if (gst_gl_display_found (element, display))
goto done;
gst_gl_display_context_query (element, display_ptr);
/* Neighbour found and it updated the display */
if (gst_gl_display_found (element, *display_ptr))
goto get_gl_context;
/* If no neighboor, or application not interested, use system default */
display = gst_gl_display_new ();
*display_ptr = display;
gst_gl_element_propagate_display_context (element, display);
get_gl_context:
if (*other_context_ptr)
goto done;
gst_gl_context_query (element);
done:
return *display_ptr != NULL;
}
static GstFlowReturn
gst_glimage_sink_render (GstBaseSink * bsink, GstBuffer * buf)
{
GstGLImageSink *glimage_sink = NULL;
GstGLBuffer *gl_buffer = NULL;
glimage_sink = GST_GLIMAGE_SINK (bsink);
GST_INFO ("buffer size: %d", GST_BUFFER_SIZE (buf));
//is gl
if (glimage_sink->is_gl) {
//increment gl buffer ref before storage
gl_buffer = GST_GL_BUFFER (gst_buffer_ref (buf));
//if glimagesink has not the display yet
if (glimage_sink->display == NULL) {
glimage_sink->display = g_object_ref (gl_buffer->display);
gst_gl_display_set_client_reshape_callback (glimage_sink->display,
glimage_sink->clientReshapeCallback);
gst_gl_display_set_client_draw_callback (glimage_sink->display,
glimage_sink->clientDrawCallback);
}
}
//is not gl
else {
//if glimagesink has not the display yet
if (glimage_sink->display == NULL) {
//create a display
glimage_sink->display = gst_gl_display_new ();
//init opengl context
gst_gl_display_create_context (glimage_sink->display,
glimage_sink->width, glimage_sink->height, 0);
//init colorspace conversion if needed
gst_gl_display_init_upload (glimage_sink->display, glimage_sink->format,
glimage_sink->width, glimage_sink->height,
glimage_sink->width, glimage_sink->height);
gst_gl_display_set_client_reshape_callback (glimage_sink->display,
glimage_sink->clientReshapeCallback);
gst_gl_display_set_client_draw_callback (glimage_sink->display,
glimage_sink->clientDrawCallback);
}
//blocking call
gl_buffer = gst_gl_buffer_new (glimage_sink->display,
glimage_sink->width, glimage_sink->height);
//blocking call
gst_gl_display_do_upload (glimage_sink->display, gl_buffer->texture,
glimage_sink->width, glimage_sink->height, GST_BUFFER_DATA (buf));
//gl_buffer is created in this block, so the gl buffer is already referenced
}
if (glimage_sink->window_id != glimage_sink->new_window_id) {
glimage_sink->window_id = glimage_sink->new_window_id;
gst_gl_display_set_window_id (glimage_sink->display,
glimage_sink->window_id);
}
//the buffer is cleared when an other comes in
if (glimage_sink->stored_buffer) {
gst_buffer_unref (GST_BUFFER_CAST (glimage_sink->stored_buffer));
glimage_sink->stored_buffer = NULL;
}
//store current buffer
glimage_sink->stored_buffer = gl_buffer;
//redisplay opengl scene
if (gl_buffer->texture &&
gst_gl_display_redisplay (glimage_sink->display,
gl_buffer->texture, gl_buffer->width, gl_buffer->height,
glimage_sink->keep_aspect_ratio))
return GST_FLOW_OK;
else
return GST_FLOW_UNEXPECTED;
}
int
main (int argc, char **argv)
{
#ifdef WIN32
HGLRC sdl_gl_context = 0;
HDC sdl_dc = 0;
#else
SDL_SysWMinfo info;
Display *sdl_display = NULL;
Window sdl_win = 0;
GLXContext sdl_gl_context = NULL;
#endif
GMainLoop *loop = NULL;
GstPipeline *pipeline = NULL;
GstBus *bus = NULL;
GstElement *glimagesink = NULL;
const gchar *platform;
/* Initialize SDL for video output */
if (SDL_Init (SDL_INIT_VIDEO) < 0) {
fprintf (stderr, "Unable to initialize SDL: %s\n", SDL_GetError ());
return -1;
}
/* Create a 640x480 OpenGL screen */
if (SDL_SetVideoMode (640, 480, 0, SDL_OPENGL) == NULL) {
fprintf (stderr, "Unable to create OpenGL screen: %s\n", SDL_GetError ());
SDL_Quit ();
return -1;
}
/* Set the title bar in environments that support it */
SDL_WM_SetCaption ("SDL and gst-plugins-gl", NULL);
/* Loop, drawing and checking events */
InitGL (640, 480);
gst_init (&argc, &argv);
loop = g_main_loop_new (NULL, FALSE);
/* retrieve and turn off sdl opengl context */
#ifdef WIN32
sdl_gl_context = wglGetCurrentContext ();
sdl_dc = wglGetCurrentDC ();
wglMakeCurrent (0, 0);
platform = "wgl";
sdl_gl_display = gst_gl_display_new ();
#else
SDL_VERSION (&info.version);
SDL_GetWMInfo (&info);
/* FIXME: This display is different to the one that SDL uses to create the
* GL context inside SDL_SetVideoMode() above which fails on Intel hardware
*/
sdl_display = info.info.x11.gfxdisplay;
sdl_win = info.info.x11.window;
sdl_gl_context = glXGetCurrentContext ();
glXMakeCurrent (sdl_display, None, 0);
platform = "glx";
sdl_gl_display =
(GstGLDisplay *) gst_gl_display_x11_new_with_display (sdl_display);
#endif
sdl_context =
gst_gl_context_new_wrapped (sdl_gl_display, (guintptr) sdl_gl_context,
gst_gl_platform_from_string (platform), GST_GL_API_OPENGL);
pipeline =
GST_PIPELINE (gst_parse_launch
("videotestsrc ! video/x-raw, width=320, height=240, framerate=(fraction)30/1 ! "
"glimagesink name=glimagesink0", NULL));
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), loop);
g_signal_connect (bus, "message::warning", G_CALLBACK (end_stream_cb), loop);
g_signal_connect (bus, "message::eos", G_CALLBACK (end_stream_cb), loop);
gst_bus_enable_sync_message_emission (bus);
g_signal_connect (bus, "sync-message", G_CALLBACK (sync_bus_call), NULL);
gst_object_unref (bus);
glimagesink = gst_bin_get_by_name (GST_BIN (pipeline), "glimagesink0");
g_signal_connect (G_OBJECT (glimagesink), "client-draw",
G_CALLBACK (on_client_draw), NULL);
gst_object_unref (glimagesink);
/* NULL to PAUSED state pipeline to make sure the gst opengl context is created and
* shared with the sdl one */
gst_element_set_state (GST_ELEMENT (pipeline), GST_STATE_PAUSED);
/* turn on back sdl opengl context */
#ifdef WIN32
wglMakeCurrent (sdl_dc, sdl_gl_context);
#else
glXMakeCurrent (sdl_display, sdl_win, sdl_gl_context);
#endif
gst_element_set_state (GST_ELEMENT (pipeline), GST_STATE_PLAYING);
g_timeout_add (100, update_sdl_scene, pipeline);
g_main_loop_run (loop);
/* before to deinitialize the gst-gl-opengl context,
* no shared context (here the sdl one) must be current
*/
#ifdef WIN32
wglMakeCurrent (0, 0);
#else
glXMakeCurrent (sdl_display, sdl_win, sdl_gl_context);
#endif
gst_element_set_state (GST_ELEMENT (pipeline), GST_STATE_NULL);
gst_object_unref (pipeline);
/* turn on back sdl opengl context */
#ifdef WIN32
wglMakeCurrent (sdl_dc, sdl_gl_context);
#else
glXMakeCurrent (sdl_display, None, 0);
#endif
SDL_Quit ();
return 0;
}
int
main (int argc, char **argv)
{
#ifdef WIN32
HGLRC sdl_gl_context = 0;
HDC sdl_dc = 0;
#else
SDL_SysWMinfo info;
Display *sdl_display = NULL;
Window sdl_win = 0;
GLXContext sdl_gl_context = NULL;
#endif
GMainLoop *loop = NULL;
GstPipeline *pipeline = NULL;
GstBus *bus = NULL;
GstElement *fakesink = NULL;
GstState state;
GAsyncQueue *queue_input_buf = NULL;
GAsyncQueue *queue_output_buf = NULL;
const gchar *platform;
/* Initialize SDL for video output */
if (SDL_Init (SDL_INIT_VIDEO) < 0) {
fprintf (stderr, "Unable to initialize SDL: %s\n", SDL_GetError ());
return -1;
}
/* Create a 640x480 OpenGL screen */
if (SDL_SetVideoMode (640, 480, 0, SDL_OPENGL) == NULL) {
fprintf (stderr, "Unable to create OpenGL screen: %s\n", SDL_GetError ());
SDL_Quit ();
return -1;
}
/* Set the title bar in environments that support it */
SDL_WM_SetCaption ("SDL and gst-plugins-gl", NULL);
/* Loop, drawing and checking events */
InitGL (640, 480);
gst_init (&argc, &argv);
loop = g_main_loop_new (NULL, FALSE);
/* retrieve and turn off sdl opengl context */
#ifdef WIN32
sdl_gl_context = wglGetCurrentContext ();
sdl_dc = wglGetCurrentDC ();
wglMakeCurrent (0, 0);
platform = "wgl";
sdl_gl_display = gst_gl_display_new ();
#else
SDL_VERSION (&info.version);
SDL_GetWMInfo (&info);
/* FIXME: This display is different to the one that SDL uses to create the
* GL context inside SDL_SetVideoMode() above which fails on Intel hardware
*/
sdl_display = info.info.x11.gfxdisplay;
sdl_win = info.info.x11.window;
sdl_gl_context = glXGetCurrentContext ();
glXMakeCurrent (sdl_display, None, 0);
platform = "glx";
sdl_gl_display =
(GstGLDisplay *) gst_gl_display_x11_new_with_display (sdl_display);
#endif
sdl_context =
gst_gl_context_new_wrapped (sdl_gl_display, (guintptr) sdl_gl_context,
gst_gl_platform_from_string (platform), GST_GL_API_OPENGL);
pipeline =
GST_PIPELINE (gst_parse_launch
("videotestsrc ! video/x-raw, width=320, height=240, framerate=(fraction)30/1 ! "
"gleffects effect=5 ! fakesink sync=1", NULL));
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), loop);
g_signal_connect (bus, "message::warning", G_CALLBACK (end_stream_cb), loop);
g_signal_connect (bus, "message::eos", G_CALLBACK (end_stream_cb), loop);
gst_bus_enable_sync_message_emission (bus);
g_signal_connect (bus, "sync-message", G_CALLBACK (sync_bus_call), NULL);
gst_object_unref (bus);
/* NULL to PAUSED state pipeline to make sure the gst opengl context is created and
* shared with the sdl 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 sdl opengl context */
#ifdef WIN32
wglMakeCurrent (sdl_dc, sdl_gl_context);
#else
glXMakeCurrent (sdl_display, sdl_win, sdl_gl_context);
#endif
/* append a gst-gl texture to this queue when you do not need it no more */
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), NULL);
queue_input_buf = g_async_queue_new ();
queue_output_buf = g_async_queue_new ();
g_object_set_data (G_OBJECT (fakesink), "queue_input_buf", queue_input_buf);
g_object_set_data (G_OBJECT (fakesink), "queue_output_buf", queue_output_buf);
g_object_set_data (G_OBJECT (fakesink), "loop", loop);
gst_object_unref (fakesink);
gst_element_set_state (GST_ELEMENT (pipeline), GST_STATE_PLAYING);
g_main_loop_run (loop);
/* before to deinitialize the gst-gl-opengl context,
* no shared context (here the sdl one) must be current
*/
#ifdef WIN32
wglMakeCurrent (0, 0);
#else
glXMakeCurrent (sdl_display, sdl_win, sdl_gl_context);
#endif
gst_element_set_state (GST_ELEMENT (pipeline), GST_STATE_NULL);
gst_object_unref (pipeline);
/* turn on back sdl opengl context */
#ifdef WIN32
wglMakeCurrent (sdl_dc, sdl_gl_context);
#else
glXMakeCurrent (sdl_display, None, 0);
#endif
SDL_Quit ();
/* 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) {
GstBuffer *buf = (GstBuffer *) g_async_queue_pop (queue_input_buf);
gst_buffer_unref (buf);
}
while (g_async_queue_length (queue_output_buf) > 0) {
GstBuffer *buf = (GstBuffer *) g_async_queue_pop (queue_output_buf);
gst_buffer_unref (buf);
}
return 0;
}
static GstStateChangeReturn
gst_glimage_sink_change_state (GstElement * element, GstStateChange transition)
{
GstGLImageSink *glimage_sink;
GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
GST_DEBUG ("change state");
glimage_sink = GST_GLIMAGE_SINK (element);
switch (transition) {
case GST_STATE_CHANGE_NULL_TO_READY:
break;
case GST_STATE_CHANGE_READY_TO_PAUSED:
if (!glimage_sink->display) {
gboolean ok = FALSE;
glimage_sink->display = gst_gl_display_new ();
/* init opengl context */
ok = gst_gl_display_create_context (glimage_sink->display, 0);
if (!ok) {
GST_ELEMENT_ERROR (glimage_sink, RESOURCE, NOT_FOUND,
GST_GL_DISPLAY_ERR_MSG (glimage_sink->display), (NULL));
if (glimage_sink->display) {
g_object_unref (glimage_sink->display);
glimage_sink->display = NULL;
}
return GST_STATE_CHANGE_FAILURE;
}
}
break;
case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
break;
default:
break;
}
ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
if (ret == GST_STATE_CHANGE_FAILURE)
return ret;
switch (transition) {
case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
break;
case GST_STATE_CHANGE_PAUSED_TO_READY:
{
if (glimage_sink->stored_buffer) {
gst_buffer_unref (GST_BUFFER_CAST (glimage_sink->stored_buffer));
glimage_sink->stored_buffer = NULL;
}
if (glimage_sink->display) {
g_object_unref (glimage_sink->display);
glimage_sink->display = NULL;
}
glimage_sink->window_id = 0;
//but do not reset glimage_sink->new_window_id
glimage_sink->fps_n = 0;
glimage_sink->fps_d = 1;
GST_VIDEO_SINK_WIDTH (glimage_sink) = 0;
GST_VIDEO_SINK_HEIGHT (glimage_sink) = 0;
}
break;
case GST_STATE_CHANGE_READY_TO_NULL:
break;
default:
break;
}
return ret;
}
static GstStateChangeReturn
gst_visual_gl_change_state (GstElement * element, GstStateChange transition)
{
GstVisualGL *visual = GST_VISUAL_GL (element);
GstStateChangeReturn ret;
switch (transition) {
case GST_STATE_CHANGE_NULL_TO_READY:
break;
case GST_STATE_CHANGE_READY_TO_PAUSED:
{
GstElement *parent = GST_ELEMENT (gst_element_get_parent (visual));
GstStructure *structure = NULL;
GstQuery *query = NULL;
gboolean isPerformed = FALSE;
gchar *name;
if (!parent) {
GST_ELEMENT_ERROR (visual, CORE, STATE_CHANGE, (NULL),
("A parent bin is required"));
return FALSE;
}
name = gst_element_get_name (visual);
structure = gst_structure_new (name, NULL);
query = gst_query_new_application (GST_QUERY_CUSTOM, structure);
g_free (name);
isPerformed = gst_element_query (parent, query);
if (isPerformed) {
const GValue *id_value =
gst_structure_get_value (structure, "gstgldisplay");
if (G_VALUE_HOLDS_POINTER (id_value))
/* at least one gl element is after in our gl chain */
visual->display =
gst_object_ref (GST_GL_DISPLAY (g_value_get_pointer (id_value)));
else {
/* this gl filter is a sink in terms of the gl chain */
visual->display = gst_gl_display_new ();
gst_gl_display_create_context (visual->display, 0);
//TODO visual->external_gl_context);
}
gst_visual_gl_reset (visual);
visual->actor =
visual_actor_new (GST_VISUAL_GL_GET_CLASS (visual)->plugin->info->
plugname);
visual->video = visual_video_new ();
visual->audio = visual_audio_new ();
if (!visual->actor || !visual->video)
goto actor_setup_failed;
gst_gl_display_thread_add (visual->display,
(GstGLDisplayThreadFunc) actor_setup, visual);
if (visual->actor_setup_result != 0)
goto actor_setup_failed;
else
visual_actor_set_video (visual->actor, visual->video);
}
gst_query_unref (query);
gst_object_unref (GST_OBJECT (parent));
if (!isPerformed)
return GST_STATE_CHANGE_FAILURE;
}
break;
case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
break;
default:
break;
}
ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
switch (transition) {
case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
break;
case GST_STATE_CHANGE_PAUSED_TO_READY:
{
if (visual->fbo) {
gst_gl_display_del_fbo (visual->display, visual->fbo,
visual->depthbuffer);
visual->fbo = 0;
visual->depthbuffer = 0;
}
if (visual->midtexture) {
gst_gl_display_del_texture (visual->display, visual->midtexture,
visual->width, visual->height);
visual->midtexture = 0;
}
if (visual->display) {
gst_object_unref (visual->display);
visual->display = NULL;
}
gst_visual_gl_clear_actors (visual);
}
break;
case GST_STATE_CHANGE_READY_TO_NULL:
break;
default:
break;
}
return ret;
/* ERRORS */
actor_setup_failed:
{
GST_ELEMENT_ERROR (visual, LIBRARY, INIT, (NULL),
("could not set up actor"));
gst_visual_gl_clear_actors (visual);
return GST_STATE_CHANGE_FAILURE;
}
}
static void
setup (void)
{
display = gst_gl_display_new ();
}
static GstStateChangeReturn
gst_egl_sink_change_state (GstElement * element, GstStateChange transition)
{
GstEGLSink *egl_sink;
GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
GST_DEBUG ("change state");
egl_sink = GST_EGL_SINK (element);
switch (transition) {
case GST_STATE_CHANGE_NULL_TO_READY:
break;
case GST_STATE_CHANGE_READY_TO_PAUSED:
if (!egl_sink->display && !egl_sink->draw_callback) {
GST_INFO("Create GLDisplay");
egl_sink->display = gst_gl_display_new ();
egl_sink->display->keep_aspect_ratio = egl_sink->keep_aspect_ratio;
/* init opengl context */
gst_gl_display_create_context (egl_sink->display, 0);
}
break;
case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
break;
default:
break;
}
ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
if (ret == GST_STATE_CHANGE_FAILURE)
return ret;
switch (transition) {
case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
break;
case GST_STATE_CHANGE_PAUSED_TO_READY:
{
if (egl_sink->display) {
gst_gl_display_destroy_context(egl_sink->display);
g_object_unref (egl_sink->display);
egl_sink->display = NULL;
}
egl_sink->window_id = 0;
//but do not reset egl_sink->new_window_id
egl_sink->fps_n = 0;
egl_sink->fps_d = 1;
egl_sink->par_n = 1;
egl_sink->par_d = 1;
GST_VIDEO_SINK_WIDTH (egl_sink) = 0;
GST_VIDEO_SINK_HEIGHT (egl_sink) = 0;
}
break;
case GST_STATE_CHANGE_READY_TO_NULL:
break;
default:
break;
}
return ret;
}
