diff --git a/gst-libs/gst/gl/Makefile.am b/gst-libs/gst/gl/Makefile.am index aee4816f94..ce16fcba0c 100644 --- a/gst-libs/gst/gl/Makefile.am +++ b/gst-libs/gst/gl/Makefile.am @@ -2,6 +2,7 @@ lib_LTLIBRARIES = libgstgl-@GST_MAJORMINOR@.la libgstgl_@GST_MAJORMINOR@_la_SOURCES = \ + gstglwindow_x11.c \ gstgldisplay.c \ gstglbuffer.c \ gstglfilter.c \ @@ -9,6 +10,7 @@ libgstgl_@GST_MAJORMINOR@_la_SOURCES = \ libgstgl_@GST_MAJORMINOR@includedir = $(includedir)/gstreamer-@GST_MAJORMINOR@/gst/gl libgstgl_@GST_MAJORMINOR@include_HEADERS = \ + gstglwindow.h \ gstgldisplay.h \ gstglbuffer.h \ gstglfilter.h \ diff --git a/gst-libs/gst/gl/gstgldisplay.c b/gst-libs/gst/gl/gstgldisplay.c index 2b479175f7..31c94dbc26 100644 --- a/gst-libs/gst/gl/gstgldisplay.c +++ b/gst-libs/gst/gl/gstgldisplay.c @@ -439,9 +439,9 @@ gst_gl_display_thread_create_context (GstGLDisplay *display) } //setup callbacks - gst_gl_window_set_resize_callback (display->gl_window, gst_gl_display_on_resize, display); - gst_gl_window_set_draw_callback (display->gl_window, gst_gl_display_on_draw, display); - gst_gl_window_set_close_callback (display->gl_window, gst_gl_display_on_close, display); + gst_gl_window_set_resize_callback (display->gl_window, GST_GL_WINDOW_CB2 (gst_gl_display_on_resize), display); + gst_gl_window_set_draw_callback (display->gl_window, GST_GL_WINDOW_CB (gst_gl_display_on_draw), display); + gst_gl_window_set_close_callback (display->gl_window, GST_GL_WINDOW_CB (gst_gl_display_on_close), display); g_cond_signal (display->cond_create_context); @@ -578,7 +578,7 @@ gst_gl_display_thread_destroy_context (GstGLDisplay *display) gst_gl_window_set_resize_callback (display->gl_window, NULL, NULL); gst_gl_window_set_draw_callback (display->gl_window, NULL, NULL); gst_gl_window_set_close_callback (display->gl_window, NULL, NULL); - + GST_INFO ("Context destroyed"); } @@ -646,7 +646,7 @@ gst_gl_display_thread_init_upload (GstGLDisplay *display) GST_INFO ("Context, ARB_fragment_shader supported: yes"); display->upload_colorspace_conversion = GST_GL_DISPLAY_CONVERSION_GLSL; - + gst_gl_display_thread_init_upload_fbo (display); if (!display->isAlive) break; @@ -1393,7 +1393,7 @@ gst_gl_display_glgen_texture (GstGLDisplay* display, GLuint* pTexture, GLint wid guint key = (gint)width; key <<= 16; key |= (gint)height; - sub_texture_pool = g_hash_table_lookup (display->texture_pool, GUINT_TO_POINTER((guint64)key)); + sub_texture_pool = g_hash_table_lookup (display->texture_pool, GUINT_TO_POINTER (key)); //if there is a sub texture pool associated to th given key if (sub_texture_pool && g_queue_get_length(sub_texture_pool) > 0) @@ -1410,7 +1410,7 @@ gst_gl_display_glgen_texture (GstGLDisplay* display, GLuint* pTexture, GLint wid //sub texture pool does not exist yet or empty glGenTextures (1, pTexture); glBindTexture (GL_TEXTURE_RECTANGLE_ARB, *pTexture); - + switch (display->upload_video_format) { case GST_VIDEO_FORMAT_RGB: @@ -1457,7 +1457,7 @@ gst_gl_display_glgen_texture (GstGLDisplay* display, GLuint* pTexture, GLint wid default: g_assert_not_reached (); } - + 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); @@ -1488,13 +1488,13 @@ gst_gl_display_gldel_texture (GstGLDisplay* display, GLuint* pTexture, GLint wid guint key = (gint)width; key <<= 16; key |= (gint)height; - sub_texture_pool = g_hash_table_lookup (display->texture_pool, GUINT_TO_POINTER((guint64)key)); + sub_texture_pool = g_hash_table_lookup (display->texture_pool, GUINT_TO_POINTER (key)); //if the size is known if (!sub_texture_pool) { sub_texture_pool = g_queue_new (); - g_hash_table_insert (display->texture_pool, GUINT_TO_POINTER((guint64)key), sub_texture_pool); + g_hash_table_insert (display->texture_pool, GUINT_TO_POINTER (key), sub_texture_pool); GST_INFO ("one more sub texture pool inserted: %d ", key); GST_INFO ("nb sub texture pools: %d", g_hash_table_size (display->texture_pool)); @@ -1637,7 +1637,7 @@ gst_gl_display_thread_add (GstGLDisplay *display, gst_gl_display_lock (display); display->data = data; display->generic_callback = func; - gst_gl_window_send_message (display->gl_window, gst_gl_display_thread_run_generic, display); + gst_gl_window_send_message (display->gl_window, GST_GL_WINDOW_CB (gst_gl_display_thread_run_generic), display); gst_gl_display_unlock (display); } @@ -1648,7 +1648,7 @@ gst_gl_display_gen_texture (GstGLDisplay* display, GLuint* pTexture, GLint width gst_gl_display_lock (display); display->gen_texture_width = width; display->gen_texture_height = height; - gst_gl_window_send_message (display->gl_window, gst_gl_display_thread_gen_texture, display); + gst_gl_window_send_message (display->gl_window, GST_GL_WINDOW_CB (gst_gl_display_thread_gen_texture), display); *pTexture = display->gen_texture; gst_gl_display_unlock (display); } @@ -1664,7 +1664,7 @@ gst_gl_display_del_texture (GstGLDisplay* display, GLuint texture, GLint width, display->del_texture = texture; display->del_texture_width = width; display->del_texture_height = height; - gst_gl_window_send_message (display->gl_window, gst_gl_display_thread_del_texture, display); + gst_gl_window_send_message (display->gl_window, GST_GL_WINDOW_CB (gst_gl_display_thread_del_texture), display); } gst_gl_display_unlock (display); } @@ -1682,7 +1682,7 @@ gst_gl_display_init_upload (GstGLDisplay* display, GstVideoFormat video_format, display->upload_height = gl_height; display->upload_data_width = video_width; display->upload_data_height = video_height; - gst_gl_window_send_message (display->gl_window, gst_gl_display_thread_init_upload, display); + gst_gl_window_send_message (display->gl_window, GST_GL_WINDOW_CB (gst_gl_display_thread_init_upload), display); gst_gl_display_unlock (display); } @@ -1703,7 +1703,7 @@ gst_gl_display_do_upload (GstGLDisplay *display, GLuint texture, display->upload_data_width = data_width; display->upload_data_height = data_height; display->upload_data = data; - gst_gl_window_send_message (display->gl_window, gst_gl_display_thread_do_upload, display); + gst_gl_window_send_message (display->gl_window, GST_GL_WINDOW_CB (gst_gl_display_thread_do_upload), display); } gst_gl_display_unlock (display); @@ -1720,7 +1720,7 @@ gst_gl_display_init_download (GstGLDisplay* display, GstVideoFormat video_format display->download_video_format = video_format; display->download_width = width; display->download_height = height; - gst_gl_window_send_message (display->gl_window, gst_gl_display_thread_init_download, display); + gst_gl_window_send_message (display->gl_window, GST_GL_WINDOW_CB (gst_gl_display_thread_init_download), display); gst_gl_display_unlock (display); } @@ -1742,7 +1742,7 @@ gst_gl_display_do_download (GstGLDisplay* display, GLuint texture, display->ouput_texture = texture; display->ouput_texture_width = width; display->ouput_texture_height = height; - gst_gl_window_send_message (display->gl_window, gst_gl_display_thread_do_download, display); + gst_gl_window_send_message (display->gl_window, GST_GL_WINDOW_CB (gst_gl_display_thread_do_download), display); } gst_gl_display_unlock (display); @@ -1760,7 +1760,7 @@ gst_gl_display_gen_fbo (GstGLDisplay* display, gint width, gint height, { display->gen_fbo_width = width; display->gen_fbo_height = height; - gst_gl_window_send_message (display->gl_window, gst_gl_display_thread_gen_fbo, display); + gst_gl_window_send_message (display->gl_window, GST_GL_WINDOW_CB (gst_gl_display_thread_gen_fbo), display); *fbo = display->generated_fbo; *depthbuffer = display->generated_depth_buffer; } @@ -1805,7 +1805,7 @@ gst_gl_display_use_fbo (GstGLDisplay* display, gint texture_fbo_width, gint text display->input_texture_width = input_texture_width; display->input_texture_height = input_texture_height; display->input_texture = input_texture; - gst_gl_window_send_message (display->gl_window, gst_gl_display_thread_use_fbo, display); + gst_gl_window_send_message (display->gl_window, GST_GL_WINDOW_CB (gst_gl_display_thread_use_fbo), display); } gst_gl_display_unlock (display); @@ -1821,7 +1821,7 @@ gst_gl_display_del_fbo (GstGLDisplay* display, GLuint fbo, gst_gl_display_lock (display); display->del_fbo = fbo; display->del_depth_buffer = depth_buffer; - gst_gl_window_send_message (display->gl_window, gst_gl_display_thread_del_fbo, display); + gst_gl_window_send_message (display->gl_window, GST_GL_WINDOW_CB (gst_gl_display_thread_del_fbo), display); gst_gl_display_unlock (display); } @@ -1836,7 +1836,7 @@ gst_gl_display_gen_shader (GstGLDisplay* display, gst_gl_display_lock (display); display->gen_shader_vertex_source = shader_vertex_source; display->gen_shader_fragment_source = shader_fragment_source; - gst_gl_window_send_message (display->gl_window, gst_gl_display_thread_gen_shader, display); + gst_gl_window_send_message (display->gl_window, GST_GL_WINDOW_CB (gst_gl_display_thread_gen_shader), display); if (shader) *shader = display->gen_shader; display->gen_shader = NULL; @@ -1852,7 +1852,7 @@ gst_gl_display_del_shader (GstGLDisplay* display, GstGLShader* shader) { gst_gl_display_lock (display); display->del_shader = shader; - gst_gl_window_send_message (display->gl_window, gst_gl_display_thread_del_shader, display); + gst_gl_window_send_message (display->gl_window, GST_GL_WINDOW_CB (gst_gl_display_thread_del_shader), display); gst_gl_display_unlock (display); } diff --git a/gst-libs/gst/gl/gstgldisplay.h b/gst-libs/gst/gl/gstgldisplay.h index 0f3c323cc3..40706cc413 100644 --- a/gst-libs/gst/gl/gstgldisplay.h +++ b/gst-libs/gst/gl/gstgldisplay.h @@ -23,9 +23,9 @@ #ifndef __GST_GL_H__ #define __GST_GL_H__ -#include #include +#include "gstglwindow.h" #include "gstglshader.h" #define GST_TYPE_GL_DISPLAY \ @@ -241,7 +241,7 @@ gboolean gst_gl_display_use_fbo (GstGLDisplay* display, gint texture_fbo_width, void gst_gl_display_del_fbo (GstGLDisplay* display, GLuint fbo, GLuint depth_buffer); -void gst_gl_display_gen_shader (GstGLDisplay* display, +void gst_gl_display_gen_shader (GstGLDisplay* display, const gchar* shader_vertex_source, const gchar* shader_fragment_source, GstGLShader** shader); diff --git a/gst-libs/gst/gl/gstglshader.c b/gst-libs/gst/gl/gstglshader.c index 8cd281e52e..6e630459ac 100644 --- a/gst-libs/gst/gl/gstglshader.c +++ b/gst-libs/gst/gl/gstglshader.c @@ -1,4 +1,4 @@ -/* +/* * GStreamer * Copyright (C) 2008 Filippo Argiolas * @@ -140,12 +140,6 @@ gst_gl_shader_log_handler (const gchar *domain, GLogLevelFlags flags, } } -static void -gst_gl_shader_base_init (gpointer g_class) -{ -} - - static void gst_gl_shader_class_init (GstGLShaderClass * klass) { @@ -516,7 +510,7 @@ gst_gl_shader_set_uniform_1i (GstGLShader * shader, const gchar * name, glUniform1iARB (location, value); } -GLint +GLint gst_gl_shader_get_attribute_location (GstGLShader * shader, const gchar *name) { GstGLShaderPrivate *priv; diff --git a/gst-libs/gst/gl/gstglwindow.h b/gst-libs/gst/gl/gstglwindow.h index c42b332d89..31ae879cb2 100644 --- a/gst-libs/gst/gl/gstglwindow.h +++ b/gst-libs/gst/gl/gstglwindow.h @@ -1,4 +1,4 @@ -/* +/* * GStreamer * Copyright (C) 2008 Julien Isorce * @@ -40,6 +40,9 @@ G_BEGIN_DECLS typedef void (* GstGLWindowCB) ( gpointer ); typedef void (* GstGLWindowCB2) ( gpointer, gint, gint ); +#define GST_GL_WINDOW_CB(f) ((GstGLWindowCB) (f)) +#define GST_GL_WINDOW_CB2(f) ((GstGLWindowCB2) (f)) + typedef struct _GstGLWindow GstGLWindow; typedef struct _GstGLWindowPrivate GstGLWindowPrivate; typedef struct _GstGLWindowClass GstGLWindowClass; diff --git a/gst-libs/gst/gl/gstglwindow_x11.c b/gst-libs/gst/gl/gstglwindow_x11.c new file mode 100644 index 0000000000..62b5d9ca28 --- /dev/null +++ b/gst-libs/gst/gl/gstglwindow_x11.c @@ -0,0 +1,596 @@ +/* + * GStreamer + * Copyright (C) 2008 Julien Isorce + * + * 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 "gstglwindow.h" + +#include + + +//#define WM_GSTGLWINDOW (WM_APP+1) + +//void gst_gl_window_set_pixel_format (GstGLWindow *window); +//LRESULT CALLBACK window_proc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam); +//LRESULT FAR PASCAL sub_class_proc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam); + +#define GST_GL_WINDOW_GET_PRIVATE(o) \ + (G_TYPE_INSTANCE_GET_PRIVATE((o), GST_GL_TYPE_WINDOW, GstGLWindowPrivate)) + +enum +{ + ARG_0, + ARG_DISPLAY +}; + +struct _GstGLWindowPrivate +{ + gchar *display_name; + Display *device; + gint screen; + Window root; + gint device_width; + gint device_height; + gint connection; + Atom atom_delete_window; + XVisualInfo *visual_info; + + Window internal_win_id; + GLXContext gl_context; + + GstGLWindowCB draw_cb; + gpointer draw_data; + GstGLWindowCB2 resize_cb; + gpointer resize_data; + GstGLWindowCB close_cb; + + gpointer close_data; + gboolean is_closed; +}; + +G_DEFINE_TYPE (GstGLWindow, gst_gl_window, G_TYPE_OBJECT); + +#undef G_LOG_DOMAIN +#define G_LOG_DOMAIN "GstGLWindow" + +gboolean _gst_gl_window_debug = FALSE; + +/* Must be called in the gl thread */ +static void +gst_gl_window_finalize (GObject * object) +{ + G_OBJECT_CLASS (gst_gl_window_parent_class)->finalize (object); +} + +static void +gst_gl_window_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec) +{ + GstGLWindow *window; + GstGLWindowPrivate *priv = window->priv; + + g_return_if_fail (GST_GL_IS_WINDOW (object)); + + window = GST_GL_WINDOW (object); + + priv = window->priv; + + switch (prop_id) { + case ARG_DISPLAY: + priv->display_name = g_strdup (g_value_get_string (value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gst_gl_window_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * pspec) +{ + GstGLWindow *window; + GstGLWindowPrivate *priv = window->priv; + + g_return_if_fail (GST_GL_IS_WINDOW (object)); + + window = GST_GL_WINDOW (object); + + priv = window->priv; + + switch (prop_id) { + case ARG_DISPLAY: + g_value_set_string (value, priv->display_name); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gst_gl_window_log_handler (const gchar *domain, GLogLevelFlags flags, + const gchar *message, gpointer user_data) +{ + if (_gst_gl_window_debug) { + g_log_default_handler (domain, flags, message, user_data); + } +} + +static void +gst_gl_window_class_init (GstGLWindowClass * klass) +{ + GObjectClass *obj_class = G_OBJECT_CLASS (klass); + + g_type_class_add_private (klass, sizeof (GstGLWindowPrivate)); + + obj_class->finalize = gst_gl_window_finalize; + obj_class->set_property = gst_gl_window_set_property; + obj_class->get_property = gst_gl_window_get_property; + + g_object_class_install_property (obj_class, ARG_DISPLAY, + g_param_spec_string ("display", "Display", "X Display name", NULL, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); +} + +static void +gst_gl_window_init (GstGLWindow *window) +{ + window->priv = GST_GL_WINDOW_GET_PRIVATE (window); + + if (g_getenv ("GST_GL_WINDOW_DEBUG") != NULL) + _gst_gl_window_debug = TRUE; + + g_log_set_handler ("GstGLWindow", G_LOG_LEVEL_DEBUG, + gst_gl_window_log_handler, NULL); +} + +/* Must be called in the gl thread */ +GstGLWindow * +gst_gl_window_new (gint width, gint height) +{ + GstGLWindow *window = g_object_new (GST_GL_TYPE_WINDOW, NULL); + GstGLWindowPrivate *priv = window->priv; + + gint attrib[] = { + GLX_RGBA, + GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1, + GLX_DOUBLEBUFFER, + GLX_DEPTH_SIZE, 1, + None + }; + + XSetWindowAttributes win_attr; + XTextProperty text_property; + XSizeHints size_hints; + XWMHints wm_hints; + unsigned long mask; + const gchar *title = "OpenGL renderer"; + + static gint x = 0; + static gint y = 0; + + x += 20; + y += 20; + + priv->device = XOpenDisplay (priv->display_name); + priv->screen = DefaultScreen (priv->device); + priv->root = RootWindow (priv->device, priv->screen); + + priv->device_width = DisplayWidth (priv->device, priv->screen); + priv->device_height = DisplayHeight (priv->device, priv->screen); + + priv->connection = ConnectionNumber (priv->device); + priv->atom_delete_window = XInternAtom (priv->device, "WM_DELETE_WINDOW", FALSE); + + priv->visual_info = glXChooseVisual (priv->device, priv->screen, attrib); + + win_attr.event_mask = + StructureNotifyMask | SubstructureNotifyMask | ExposureMask | + ButtonPressMask | ButtonReleaseMask | KeyPressMask | KeyReleaseMask | + VisibilityChangeMask | EnterWindowMask | LeaveWindowMask | + PointerMotionMask | ButtonMotionMask; + + win_attr.background_pixmap = None; + win_attr.background_pixel = 0; + win_attr.border_pixel = 0; + + win_attr.colormap = XCreateColormap(priv->device, priv->root, priv->visual_info->visual, AllocNone); + + mask = CWBackPixmap | CWBorderPixel | CWColormap | CWEventMask; + + priv->internal_win_id = XCreateWindow (priv->device, priv->root, x, y, + width, height, 0, priv->visual_info->depth, InputOutput, + priv->visual_info->visual, mask, &win_attr); + + priv->gl_context = glXCreateContext (priv->device, priv->visual_info, NULL, TRUE); + + if (!glXIsDirect(priv->device, priv->gl_context)) + g_debug ("direct rendering failed\n"); + + size_hints.flags = USPosition | USSize; + size_hints.x = x; + size_hints.y = y; + size_hints.width = width; + size_hints.height= height; + + wm_hints.flags = StateHint; + wm_hints.initial_state = NormalState; + + XStringListToTextProperty ((char**)&title, 1, &text_property); + + XSetWMProperties (priv->device, priv->internal_win_id, &text_property, &text_property, 0, 0, + &size_hints, &wm_hints, NULL); + + XFree (text_property.value); + + XSetWMProtocols (priv->device, priv->internal_win_id, &priv->atom_delete_window, 1); + + glXMakeCurrent (priv->device, priv->internal_win_id, priv->gl_context); + + return window; +} + +GQuark +gst_gl_window_error_quark (void) +{ + return g_quark_from_static_string ("gst-gl-window-error"); +} + +void +gst_gl_window_set_external_window_id (GstGLWindow *window, guint64 id) +{ + /*stGLWindowPrivate *priv = window->priv; + WNDPROC window_parent_proc = (WNDPROC) (guint64) GetWindowLongPtr((HWND)id, GWL_WNDPROC); + RECT rect; + + SetProp (priv->internal_win_id, "gl_window_parent_id", (HWND)id); + SetProp ((HWND)id, "gl_window_id", priv->internal_win_id); + SetProp ((HWND)id, "gl_window_parent_proc", (WNDPROC) window_parent_proc); + SetWindowLongPtr ((HWND)id, GWL_WNDPROC, (DWORD) (guint64) sub_class_proc); + + SetWindowLongPtr (priv->internal_win_id, GWL_STYLE, WS_CHILD | WS_MAXIMIZE); + SetParent (priv->internal_win_id, (HWND)id); + + //take changes into account: SWP_FRAMECHANGED + GetClientRect ((HWND)id, &rect); + SetWindowPos (priv->internal_win_id, HWND_TOP, rect.left, rect.top, rect.right, rect.bottom, + SWP_ASYNCWINDOWPOS | SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED | SWP_NOACTIVATE); + MoveWindow (priv->internal_win_id, rect.left, rect.top, rect.right, rect.bottom, FALSE);*/ +} + +void +gst_gl_window_set_external_gl_context (GstGLWindow *window, guint64 context) +{ + g_warning ("gst_gl_window_set_external_gl_context: not implemented\n"); +} + +/* Must be called in the gl thread */ +void +gst_gl_window_set_draw_callback (GstGLWindow *window, GstGLWindowCB callback, gpointer data) +{ + GstGLWindowPrivate *priv = window->priv; + + priv->draw_cb = callback; + priv->draw_data = data; +} + +/* Must be called in the gl thread */ +void +gst_gl_window_set_resize_callback (GstGLWindow *window, GstGLWindowCB2 callback , gpointer data) +{ + GstGLWindowPrivate *priv = window->priv; + + priv->resize_cb = callback; + priv->resize_data = data; +} + +/* Must be called in the gl thread */ +void +gst_gl_window_set_close_callback (GstGLWindow *window, GstGLWindowCB callback, gpointer data) +{ + GstGLWindowPrivate *priv = window->priv; + + priv->close_cb = callback; + priv->close_data = data; +} + +/* Thread safe */ +void +gst_gl_window_visible (GstGLWindow *window, gboolean visible) +{ + /*GstGLWindowPrivate *priv = window->priv; + BOOL ret = FALSE; + + g_debug ("set visible %d\n", priv->internal_win_id); + + if (visible) + ret = ShowWindowAsync (priv->internal_win_id, SW_SHOW); + else + ret = ShowWindowAsync (priv->internal_win_id, SW_HIDE);*/ +} + +/* Thread safe */ +void +gst_gl_window_draw (GstGLWindow *window) +{ + /*GstGLWindowPrivate *priv = window->priv; + RedrawWindow (priv->internal_win_id, NULL, NULL, + RDW_NOERASE | RDW_INTERNALPAINT | RDW_INVALIDATE);*/ +} + +void +gst_gl_window_run_loop (GstGLWindow *window) +{ + /*GstGLWindowPrivate *priv = window->priv; + gboolean running = TRUE; + gboolean bRet = FALSE; + MSG msg; + + g_debug ("begin loop\n"); + + while (running && (bRet = GetMessage (&msg, NULL, 0, 0)) != 0) + { + if (bRet == -1) + { + g_error ("Failed to get message %x\r\n", GetLastError()); + running = FALSE; + } + else + { + TranslateMessage (&msg); + DispatchMessage (&msg); + } + } + + g_debug ("end loop\n");*/ +} + +/* Thread safe */ +void +gst_gl_window_quit_loop (GstGLWindow *window) +{ + /*if (window) + { + GstGLWindowPrivate *priv = window->priv; + LRESULT res = PostMessage(priv->internal_win_id, WM_CLOSE, 0, 0); + g_assert (SUCCEEDED (res)); + g_debug ("end loop requested\n"); + }*/ +} + +/* Thread safe */ +void +gst_gl_window_send_message (GstGLWindow *window, GstGLWindowCB callback, gpointer data) +{ + /*if (window) + { + GstGLWindowPrivate *priv = window->priv; + LRESULT res = SendMessage (priv->internal_win_id, WM_GSTGLWINDOW, (WPARAM) data, (LPARAM) callback); + g_assert (SUCCEEDED (res)); + }*/ +} + +/* PRIVATE */ +/* +void +gst_gl_window_set_pixel_format (GstGLWindow *window) +{ + GstGLWindowPrivate *priv = window->priv; + PIXELFORMATDESCRIPTOR pfd; + gint pixelformat = 0; + gboolean res = FALSE; + + pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR); + pfd.nVersion = 1; + pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER; + pfd.iPixelType = PFD_TYPE_RGBA; + pfd.cColorBits = 24; + pfd.cRedBits = 0; + pfd.cRedShift = 0; + pfd.cGreenBits = 0; + pfd.cGreenShift = 0; + pfd.cBlueBits = 0; + pfd.cBlueShift = 0; + pfd.cAlphaBits = 0; + pfd.cAlphaShift = 0; + pfd.cAccumBits = 0; + pfd.cAccumRedBits = 0; + pfd.cAccumGreenBits = 0; + pfd.cAccumBlueBits = 0; + pfd.cAccumAlphaBits = 0; + pfd.cDepthBits = 32; + pfd.cStencilBits = 8; + pfd.cAuxBuffers = 0; + pfd.iLayerType = PFD_MAIN_PLANE; + pfd.bReserved = 0; + pfd.dwLayerMask = 0; + pfd.dwVisibleMask = 0; + pfd.dwDamageMask = 0; + + pfd.cColorBits = (BYTE) GetDeviceCaps (priv->device, BITSPIXEL); + + pixelformat = ChoosePixelFormat (priv->device, &pfd ); + + g_assert (pixelformat); + + res = SetPixelFormat (priv->device, pixelformat, &pfd); + + g_assert (res); +}*/ +/* +LRESULT CALLBACK window_proc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) +{ + if (uMsg == WM_CREATE) { + + GstGLWindow *window = (GstGLWindow *) (((LPCREATESTRUCT) lParam)->lpCreateParams); + + g_debug ("WM_CREATE\n"); + + g_assert (window); + + { + GstGLWindowPrivate *priv = window->priv; + priv->device = GetDC (hWnd); + gst_gl_window_set_pixel_format (window); + priv->gl_context = wglCreateContext (priv->device); + if (priv->gl_context) + g_debug ("gl context created: %d\n", priv->gl_context); + else + g_debug ("failed to create glcontext %d, %x\r\n", hWnd, GetLastError()); + g_assert (priv->gl_context); + ReleaseDC (hWnd, priv->device); + if (!wglMakeCurrent (priv->device, priv->gl_context)) + g_debug ("failed to make opengl context current %d, %x\r\n", hWnd, GetLastError()); + } + + SetProp (hWnd, "gl_window", window); + + return 0; + } + else if (GetProp(hWnd, "gl_window")) { + + GstGLWindow *window = GetProp(hWnd, "gl_window"); + GstGLWindowPrivate *priv = NULL; + + g_assert (window); + + priv = window->priv; + + g_assert (priv); + + g_assert (priv->internal_win_id == hWnd); + + g_assert (priv->gl_context == wglGetCurrentContext()); + + switch ( uMsg ) { + + case WM_SIZE: + { + if (priv->resize_cb) + priv->resize_cb (priv->resize_data, LOWORD(lParam), HIWORD(lParam)); + break; + } + + case WM_PAINT: + { + if (priv->draw_cb) + { + PAINTSTRUCT ps; + BeginPaint (hWnd, &ps); + priv->draw_cb (priv->draw_data); + SwapBuffers (priv->device); + EndPaint (hWnd, &ps); + } + break; + } + + case WM_CLOSE: + { + HWND parent_id = 0; + + g_debug ("WM_CLOSE\n"); + + parent_id = GetProp (hWnd, "gl_window_parent_id"); + if (parent_id) + { + WNDPROC parent_proc = GetProp (parent_id, "gl_window_parent_proc"); + + g_assert (parent_proc); + + SetWindowLongPtr (parent_id, GWL_WNDPROC, (LONG) (guint64) parent_proc); + SetParent (hWnd, NULL); + + RemoveProp (parent_id, "gl_window_parent_proc"); + RemoveProp (hWnd, "gl_window_parent_id"); + } + + priv->is_closed = TRUE; + RemoveProp (hWnd, "gl_window"); + + if (!wglMakeCurrent (NULL, NULL)) + g_debug ("failed to make current %d, %x\r\n", hWnd, GetLastError()); + + if (priv->gl_context) + { + if (!wglDeleteContext (priv->gl_context)) + g_debug ("failed to destroy context %d, %x\r\n", priv->gl_context, GetLastError()); + } + + if (priv->internal_win_id) + { + g_debug ("BEFORE\n"); + if (!DestroyWindow(priv->internal_win_id)) + g_debug ("failed to destroy window %d, %x\r\n", hWnd, GetLastError()); + g_debug ("AFTER\n"); + } + + PostQuitMessage (0); + break; + } + + case WM_CAPTURECHANGED: + { + g_debug ("WM_CAPTURECHANGED\n"); + if (priv->draw_cb) + priv->draw_cb (priv->draw_data); + break; + } + + case WM_GSTGLWINDOW: + { + if (priv->is_closed && priv->close_cb) + priv->close_cb (priv->close_data); + else + { + GstGLWindowCB custom_cb = (GstGLWindowCB) lParam; + custom_cb ((gpointer) wParam); + } + break; + } + + case WM_ERASEBKGND: + return TRUE; + + default: + return DefWindowProc( hWnd, uMsg, wParam, lParam ); + } + + return 0; + } + else + return DefWindowProc( hWnd, uMsg, wParam, lParam ); +} + +LRESULT FAR PASCAL sub_class_proc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) +{ + WNDPROC window_parent_proc = GetProp (hWnd, "gl_window_parent_proc"); + + if (uMsg == WM_SIZE) + { + HWND gl_window_id = GetProp (hWnd, "gl_window_id"); + MoveWindow (gl_window_id, 0, 0, LOWORD(lParam), HIWORD(lParam), FALSE); + } + + return CallWindowProc (window_parent_proc, hWnd, uMsg, wParam, lParam); +} +*/ diff --git a/gst/gl/gstglupload.c b/gst/gl/gstglupload.c index 2b20eb52b9..77e3417a2a 100644 --- a/gst/gl/gstglupload.c +++ b/gst/gl/gstglupload.c @@ -27,7 +27,7 @@ * * Color space conversion * - * Depends on the driver and when needed, the color space conversion is made + * Depends on the driver and when needed, the color space conversion is made * in a fragment shader using one frame buffer object instance, or using * mesa ycbcr . * @@ -42,7 +42,7 @@ * |[ * gst-launch -v videotestsrc ! "video/x-raw-yuv, format=(fourcc)I420" ! glupload ! glimagesink * ]| A pipeline to test hardware scaling and hardware colorspace conversion. - * When your driver supports GLSL (OpenGL Shading Language needs OpenGL >= 2.1), + * When your driver supports GLSL (OpenGL Shading Language needs OpenGL >= 2.1), * the 4 following format YUY2, UYVY, I420, YV12 and AYUV are converted to RGB32 * through some fragment shaders and using one framebuffer (FBO extension OpenGL >= 1.4). * If your driver does not support GLSL but supports MESA_YCbCr extension then @@ -59,7 +59,7 @@ * "video/x-raw-gl, width=640, height=480" ! glimagesink * ]| A pipeline to test hardware scaling. * Frame buffer extension is required. Inded one FBO is used bettween glupload and glimagesink, - * because the texture needs to be resized. Depends on your driver the color space conversion + * because the texture needs to be resized. Depends on your driver the color space conversion * is made in a fragment shader using one frame buffer object instance, or using mesa ycbcr . * */ @@ -425,7 +425,6 @@ gst_gl_upload_set_caps (GstBaseTransform* bt, GstCaps* incaps, GstGLUpload* upload = GST_GL_UPLOAD (bt); gboolean ret = FALSE; GstVideoFormat video_format = GST_VIDEO_FORMAT_UNKNOWN; - static gint y_pos = 0; GST_DEBUG ("called with %" GST_PTR_FORMAT, incaps);