gstreamer/sys/glsink/glimagesink.c
Jan Schmidt 1b26c3f023 sys/glsink/glimagesink.c: Sprinkle in some XSync calls to avoid raciness with broken drivers (ATI) when re-using a si...
Original commit message from CVS:
* sys/glsink/glimagesink.c: (gst_glimage_sink_stop),
(gst_glimage_sink_create_window), (gst_glimage_sink_init_display):
Sprinkle in some XSync calls to avoid raciness with broken
drivers (ATI) when re-using a single glimagesink.
2007-06-06 15:58:31 +00:00

985 lines
26 KiB
C

/* GStreamer
* Copyright (C) 2003 Julien Moutte <julien@moutte.net>
* Copyright (C) 2005,2006 David A. Schleef <ds@schleef.org>
*
* 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 <gst/gst.h>
#include <gst/interfaces/xoverlay.h>
#include <gst/video/gstvideosink.h>
#include <gst/video/video.h>
#include <string.h>
#include <GL/glx.h>
#include <GL/gl.h>
GST_DEBUG_CATEGORY_STATIC (gst_debug_glimage_sink);
#define GST_CAT_DEFAULT gst_debug_glimage_sink
#define GST_TYPE_GLIMAGE_SINK \
(gst_glimage_sink_get_type())
#define GST_GLIMAGE_SINK(obj) \
(G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_GLIMAGE_SINK,GstGLImageSink))
#define GST_GLIMAGE_SINK_CLASS(klass) \
(G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_GLIMAGE_SINK,GstGLImageSinkClass))
#define GST_IS_GLIMAGE_SINK(obj) \
(G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_GLIMAGE_SINK))
#define GST_IS_GLIMAGE_SINK_CLASS(klass) \
(G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_GLIMAGE_SINK))
typedef struct _GstGLImageSink GstGLImageSink;
typedef struct _GstGLImageSinkClass GstGLImageSinkClass;
struct _GstGLImageSink
{
GstVideoSink video_sink;
/* properties */
char *display_name;
/* caps */
GstCaps *caps;
int fps_n, fps_d;
int par_n, par_d;
int height, width;
Window window;
Window parent_window;
XVisualInfo *visinfo;
Display *display;
GLXContext context;
gboolean internal;
int max_texture_size;
gboolean have_yuv;
gboolean use_rgb;
gboolean use_rgbx;
gboolean use_yuy2;
};
struct _GstGLImageSinkClass
{
GstVideoSinkClass video_sink_class;
};
static void gst_glimage_sink_init_interfaces (GType type);
static void gst_glimage_sink_finalize (GObject * object);
static void gst_glimage_sink_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * param_spec);
static void gst_glimage_sink_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * param_spec);
static GstStateChangeReturn
gst_glimage_sink_change_state (GstElement * element, GstStateChange transition);
static void gst_glimage_sink_get_times (GstBaseSink * bsink, GstBuffer * buf,
GstClockTime * start, GstClockTime * end);
static GstCaps *gst_glimage_sink_get_caps (GstBaseSink * bsink);
static gboolean gst_glimage_sink_set_caps (GstBaseSink * bsink, GstCaps * caps);
static GstFlowReturn gst_glimage_sink_render (GstBaseSink * bsink,
GstBuffer * buf);
static gboolean gst_glimage_sink_start (GstBaseSink * bsink);
static gboolean gst_glimage_sink_stop (GstBaseSink * bsink);
static gboolean gst_glimage_sink_unlock (GstBaseSink * bsink);
static void gst_glimage_sink_xoverlay_init (GstXOverlayClass * iface);
static void gst_glimage_sink_set_xwindow_id (GstXOverlay * overlay,
XID window_id);
static void gst_glimage_sink_expose (GstXOverlay * overlay);
static void gst_glimage_sink_set_event_handling (GstXOverlay * overlay,
gboolean handle_events);
static gboolean gst_glimage_sink_interface_supported (GstImplementsInterface *
iface, GType type);
static void gst_glimage_sink_implements_init (GstImplementsInterfaceClass *
klass);
static void gst_glimage_sink_create_window (GstGLImageSink * glimage_sink);
static gboolean gst_glimage_sink_init_display (GstGLImageSink * glimage_sink);
static void gst_glimage_sink_update_caps (GstGLImageSink * glimage_sink);
static void gst_glimage_sink_push_image (GstGLImageSink * glimage_sink,
GstBuffer * buf);
static const GstElementDetails gst_glimage_sink_details =
GST_ELEMENT_DETAILS ("OpenGL video sink",
"Sink/Video",
"A videosink based on OpenGL",
"David Schleef <ds@schleef.org>");
#ifdef GL_YCBCR_MESA
#define YUV_CAPS ";" GST_VIDEO_CAPS_YUV ("{ UYVY, YUY2 }")
#else
#define YUV_CAPS
#endif
static GstStaticPadTemplate gst_glimage_sink_template =
GST_STATIC_PAD_TEMPLATE ("sink",
GST_PAD_SINK,
GST_PAD_ALWAYS,
GST_STATIC_CAPS (GST_VIDEO_CAPS_RGBx ";" GST_VIDEO_CAPS_BGRx YUV_CAPS)
);
enum
{
ARG_0,
ARG_DISPLAY
};
GST_BOILERPLATE_FULL (GstGLImageSink, gst_glimage_sink, GstVideoSink,
GST_TYPE_VIDEO_SINK, gst_glimage_sink_init_interfaces);
static void
gst_glimage_sink_init_interfaces (GType type)
{
static const GInterfaceInfo overlay_info = {
(GInterfaceInitFunc) gst_glimage_sink_xoverlay_init,
NULL,
NULL
};
static const GInterfaceInfo implements_info = {
(GInterfaceInitFunc) gst_glimage_sink_implements_init,
NULL,
NULL
};
g_type_add_interface_static (type, GST_TYPE_IMPLEMENTS_INTERFACE,
&implements_info);
g_type_add_interface_static (type, GST_TYPE_X_OVERLAY, &overlay_info);
}
static void
gst_glimage_sink_base_init (gpointer g_class)
{
GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
gst_element_class_set_details (element_class, &gst_glimage_sink_details);
gst_element_class_add_pad_template (element_class,
gst_static_pad_template_get (&gst_glimage_sink_template));
}
static void
gst_glimage_sink_class_init (GstGLImageSinkClass * klass)
{
GObjectClass *gobject_class;
GstElementClass *gstelement_class;
GstBaseSinkClass *gstbasesink_class;
gobject_class = (GObjectClass *) klass;
gstelement_class = (GstElementClass *) klass;
gstbasesink_class = (GstBaseSinkClass *) klass;
gobject_class->set_property = gst_glimage_sink_set_property;
gobject_class->get_property = gst_glimage_sink_get_property;
g_object_class_install_property (gobject_class, ARG_DISPLAY,
g_param_spec_string ("display", "Display", "X Display name",
NULL, G_PARAM_READWRITE));
gobject_class->finalize = gst_glimage_sink_finalize;
gstelement_class->change_state = gst_glimage_sink_change_state;
gstbasesink_class->get_caps = gst_glimage_sink_get_caps;
gstbasesink_class->set_caps = gst_glimage_sink_set_caps;
gstbasesink_class->get_times = gst_glimage_sink_get_times;
gstbasesink_class->preroll = gst_glimage_sink_render;
gstbasesink_class->render = gst_glimage_sink_render;
gstbasesink_class->start = gst_glimage_sink_start;
gstbasesink_class->stop = gst_glimage_sink_stop;
gstbasesink_class->unlock = gst_glimage_sink_unlock;
}
static void
gst_glimage_sink_init (GstGLImageSink * glimage_sink,
GstGLImageSinkClass * glimage_sink_class)
{
glimage_sink->width = -1;
glimage_sink->height = -1;
glimage_sink->display_name = NULL;
gst_glimage_sink_update_caps (glimage_sink);
}
static void
gst_glimage_sink_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstGLImageSink *glimage_sink;
g_return_if_fail (GST_IS_GLIMAGE_SINK (object));
glimage_sink = GST_GLIMAGE_SINK (object);
switch (prop_id) {
case ARG_DISPLAY:
g_free (glimage_sink->display_name);
glimage_sink->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_glimage_sink_finalize (GObject * object)
{
GstGLImageSink *glimage_sink;
g_return_if_fail (GST_IS_GLIMAGE_SINK (object));
glimage_sink = GST_GLIMAGE_SINK (object);
if (glimage_sink->caps) {
gst_caps_unref (glimage_sink->caps);
}
g_free (glimage_sink->display_name);
}
static void
gst_glimage_sink_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstGLImageSink *glimage_sink;
g_return_if_fail (GST_IS_GLIMAGE_SINK (object));
glimage_sink = GST_GLIMAGE_SINK (object);
switch (prop_id) {
case ARG_DISPLAY:
g_value_set_string (value, glimage_sink->display_name);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
/*
* GstElement methods
*/
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:
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:
/* FIXME clear window */
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:
/* FIXME dispose of window */
break;
default:
break;
}
return ret;
}
/*
* GstBaseSink methods
*/
static gboolean
gst_glimage_sink_start (GstBaseSink * bsink)
{
GstGLImageSink *glimage_sink;
gboolean ret;
glimage_sink = GST_GLIMAGE_SINK (bsink);
ret = gst_glimage_sink_init_display (glimage_sink);
return ret;
}
static gboolean
gst_glimage_sink_stop (GstBaseSink * bsink)
{
GstGLImageSink *glimage_sink;
glimage_sink = GST_GLIMAGE_SINK (bsink);
if (glimage_sink->display) {
if (glimage_sink->context) {
glXDestroyContext (glimage_sink->display, glimage_sink->context);
glimage_sink->context = NULL;
}
XSync (glimage_sink->display, False);
XCloseDisplay (glimage_sink->display);
glimage_sink->display = NULL;
}
glimage_sink->context = NULL;
glimage_sink->window = 0;
return TRUE;
}
static gboolean
gst_glimage_sink_unlock (GstBaseSink * bsink)
{
//GstGLImageSink *glimage_sink;
//glimage_sink = GST_GLIMAGE_SINK (bsink);
/* FIXME */
return TRUE;
}
static void
gst_glimage_sink_get_times (GstBaseSink * bsink, GstBuffer * buf,
GstClockTime * start, GstClockTime * end)
{
GstGLImageSink *glimagesink;
glimagesink = GST_GLIMAGE_SINK (bsink);
if (GST_BUFFER_TIMESTAMP_IS_VALID (buf)) {
*start = GST_BUFFER_TIMESTAMP (buf);
if (GST_BUFFER_DURATION_IS_VALID (buf)) {
*end = *start + GST_BUFFER_DURATION (buf);
} else {
if (glimagesink->fps_n > 0) {
*end = *start +
gst_util_uint64_scale_int (GST_SECOND, glimagesink->fps_d,
glimagesink->fps_n);
}
}
}
}
static GstCaps *
gst_glimage_sink_get_caps (GstBaseSink * bsink)
{
GstGLImageSink *glimage_sink;
glimage_sink = GST_GLIMAGE_SINK (bsink);
GST_DEBUG ("get caps returning %" GST_PTR_FORMAT, glimage_sink->caps);
return gst_caps_ref (glimage_sink->caps);
}
static gboolean
gst_glimage_sink_set_caps (GstBaseSink * bsink, GstCaps * caps)
{
GstGLImageSink *glimage_sink;
GstCaps *intersection;
GstStructure *structure;
int width;
int height;
gboolean ret;
const GValue *fps;
const GValue *par;
GST_DEBUG ("set caps with %" GST_PTR_FORMAT, caps);
glimage_sink = GST_GLIMAGE_SINK (bsink);
intersection = gst_caps_intersect (glimage_sink->caps, caps);
if (gst_caps_is_empty (intersection)) {
return FALSE;
}
gst_caps_unref (intersection);
structure = gst_caps_get_structure (caps, 0);
ret = gst_structure_get_int (structure, "width", &width);
ret &= gst_structure_get_int (structure, "height", &height);
fps = gst_structure_get_value (structure, "framerate");
ret &= (fps != NULL);
par = gst_structure_get_value (structure, "pixel-aspect-ratio");
if (!ret)
return FALSE;
glimage_sink->width = width;
glimage_sink->height = height;
glimage_sink->fps_n = gst_value_get_fraction_numerator (fps);
glimage_sink->fps_d = gst_value_get_fraction_denominator (fps);
if (par) {
glimage_sink->par_n = gst_value_get_fraction_numerator (par);
glimage_sink->par_d = gst_value_get_fraction_denominator (par);
} else {
glimage_sink->par_n = 1;
glimage_sink->par_d = 1;
}
GST_VIDEO_SINK_WIDTH (glimage_sink) = width;
GST_VIDEO_SINK_HEIGHT (glimage_sink) = height;
if (strcmp (gst_structure_get_name (structure), "video/x-raw-rgb") == 0) {
int red_mask;
GST_DEBUG ("using RGB");
glimage_sink->use_rgb = TRUE;
gst_structure_get_int (structure, "red_mask", &red_mask);
if (red_mask == 0xff000000) {
glimage_sink->use_rgbx = TRUE;
} else {
glimage_sink->use_rgbx = FALSE;
}
} else {
unsigned int fourcc;
GST_DEBUG ("using YUV");
glimage_sink->use_rgb = FALSE;
gst_structure_get_fourcc (structure, "format", &fourcc);
if (fourcc == GST_MAKE_FOURCC ('Y', 'U', 'Y', '2')) {
glimage_sink->use_yuy2 = TRUE;
} else {
glimage_sink->use_yuy2 = FALSE;
}
}
if (!glimage_sink->window) {
gst_x_overlay_prepare_xwindow_id (GST_X_OVERLAY (glimage_sink));
}
if (!glimage_sink->window) {
gst_glimage_sink_create_window (glimage_sink);
}
return TRUE;
}
static GstFlowReturn
gst_glimage_sink_render (GstBaseSink * bsink, GstBuffer * buf)
{
GstGLImageSink *glimage_sink;
glimage_sink = GST_GLIMAGE_SINK (bsink);
gst_glimage_sink_push_image (glimage_sink, buf);
return GST_FLOW_OK;
}
/*
* XOverlay
*/
static void
gst_glimage_sink_xoverlay_init (GstXOverlayClass * iface)
{
iface->set_xwindow_id = gst_glimage_sink_set_xwindow_id;
iface->expose = gst_glimage_sink_expose;
iface->handle_events = gst_glimage_sink_set_event_handling;
}
static void
gst_glimage_sink_set_xwindow_id (GstXOverlay * overlay, XID window_id)
{
GstGLImageSink *glimage_sink;
g_return_if_fail (GST_IS_GLIMAGE_SINK (overlay));
glimage_sink = GST_GLIMAGE_SINK (overlay);
if (glimage_sink->window == window_id) {
return;
}
/* FIXME check if display inited */
if (window_id == 0) {
/* go back to independent window */
/* FIXME */
glimage_sink->internal = TRUE;
} else {
XWindowAttributes attr;
glimage_sink->window = window_id;
XGetWindowAttributes (glimage_sink->display, window_id, &attr);
glimage_sink->width = attr.width;
glimage_sink->height = attr.height;
glimage_sink->internal = FALSE;
#if 0
/* FIXME */
if (glimage_sink->handle_events) {
XSelectInput (glimage_sink->display, window_id,
ExposureMask | StructureNotifyMask | PointerMotionMask | KeyPressMask
| KeyReleaseMask);
}
#endif
}
}
static void
gst_glimage_sink_expose (GstXOverlay * overlay)
{
/* FIXME */
GST_DEBUG ("expose");
}
static void
gst_glimage_sink_set_event_handling (GstXOverlay * overlay,
gboolean handle_events)
{
/* FIXME */
GST_DEBUG ("handle_events %d", handle_events);
}
/*
* GstImplementsInterface
*/
static gboolean
gst_glimage_sink_interface_supported (GstImplementsInterface * iface,
GType type)
{
return TRUE;
}
static void
gst_glimage_sink_implements_init (GstImplementsInterfaceClass * klass)
{
klass->supported = gst_glimage_sink_interface_supported;
}
/*
* helper functions
*/
static void
gst_caps_set_all (GstCaps * caps, char *field, ...)
{
GstStructure *structure;
va_list var_args;
int i;
for (i = 0; i < gst_caps_get_size (caps); i++) {
structure = gst_caps_get_structure (caps, i);
va_start (var_args, field);
gst_structure_set_valist (structure, field, var_args);
va_end (var_args);
}
}
static void
gst_glimage_sink_update_caps (GstGLImageSink * glimage_sink)
{
GstCaps *caps;
int max_size;
if (glimage_sink->display == NULL) {
caps = gst_caps_copy (gst_pad_get_pad_template_caps (GST_BASE_SINK_PAD
(glimage_sink)));
gst_caps_replace (&glimage_sink->caps, caps);
return;
}
caps = gst_caps_from_string (GST_VIDEO_CAPS_RGBx ";" GST_VIDEO_CAPS_BGRx);
#ifdef GL_YCBCR_MESA
if (glimage_sink->have_yuv) {
GstCaps *ycaps =
gst_caps_from_string (GST_VIDEO_CAPS_YUV ("{ UYVY, YUY2 }"));
gst_caps_append (ycaps, caps);
caps = ycaps;
}
#endif
max_size = glimage_sink->max_texture_size;
if (max_size == 0) {
max_size = 1024;
}
gst_caps_set_all (caps,
"width", GST_TYPE_INT_RANGE, 16, max_size,
"height", GST_TYPE_INT_RANGE, 16, max_size, NULL);
gst_caps_replace (&glimage_sink->caps, caps);
}
static void
gst_glimage_sink_create_window (GstGLImageSink * glimage_sink)
{
gboolean ret;
Window root;
XSetWindowAttributes attr;
Screen *screen;
int scrnum;
int mask;
int width, height;
screen = XDefaultScreenOfDisplay (glimage_sink->display);
scrnum = XScreenNumberOfScreen (screen);
root = XRootWindow (glimage_sink->display, scrnum);
if (glimage_sink->parent_window) {
XWindowAttributes pattr;
XGetWindowAttributes (glimage_sink->display, glimage_sink->parent_window,
&pattr);
width = pattr.width;
height = pattr.height;
} else {
width = GST_VIDEO_SINK (glimage_sink)->width;
height = GST_VIDEO_SINK (glimage_sink)->height;
}
attr.background_pixel = 0;
attr.border_pixel = 0;
attr.colormap = XCreateColormap (glimage_sink->display, root,
glimage_sink->visinfo->visual, AllocNone);
if (glimage_sink->parent_window) {
attr.override_redirect = True;
} else {
attr.override_redirect = False;
}
mask = CWBackPixel | CWBorderPixel | CWColormap | CWOverrideRedirect;
GST_DEBUG ("creating window with size %d x %d", width, height);
glimage_sink->window = XCreateWindow (glimage_sink->display, root, 0, 0,
width, height,
0, glimage_sink->visinfo->depth, InputOutput,
glimage_sink->visinfo->visual, mask, &attr);
if (glimage_sink->parent_window) {
ret = XReparentWindow (glimage_sink->display, glimage_sink->window,
glimage_sink->parent_window, 0, 0);
XMapWindow (glimage_sink->display, glimage_sink->window);
} else {
XMapWindow (glimage_sink->display, glimage_sink->window);
}
XSync (glimage_sink->display, False);
gst_x_overlay_got_xwindow_id (GST_X_OVERLAY (glimage_sink),
glimage_sink->window);
glXMakeCurrent (glimage_sink->display, glimage_sink->window,
glimage_sink->context);
glDepthFunc (GL_LESS);
glEnable (GL_DEPTH_TEST);
glClearColor (0.2, 0.2, 0.2, 1.0);
glViewport (0, 0, width, height);
}
static gboolean
gst_glimage_sink_init_display (GstGLImageSink * glimage_sink)
{
gboolean ret;
XVisualInfo *visinfo;
Screen *screen;
Window root;
int scrnum;
int attrib[] = { GLX_RGBA, GLX_DOUBLEBUFFER, GLX_RED_SIZE, 8,
GLX_GREEN_SIZE, 8, GLX_BLUE_SIZE, 8, None
};
XSetWindowAttributes attr;
int error_base;
int event_base;
int mask;
const char *extstring;
Window window;
GST_DEBUG_OBJECT (glimage_sink, "initializing display");
glimage_sink->display = XOpenDisplay (NULL);
if (glimage_sink->display == NULL) {
GST_DEBUG_OBJECT (glimage_sink, "Could not open display");
return FALSE;
}
screen = XDefaultScreenOfDisplay (glimage_sink->display);
scrnum = XScreenNumberOfScreen (screen);
root = XRootWindow (glimage_sink->display, scrnum);
ret = glXQueryExtension (glimage_sink->display, &error_base, &event_base);
if (!ret) {
GST_DEBUG_OBJECT (glimage_sink, "No GLX extension");
return FALSE;
}
visinfo = glXChooseVisual (glimage_sink->display, scrnum, attrib);
if (visinfo == NULL) {
GST_DEBUG_OBJECT (glimage_sink, "No usable visual");
return FALSE;
}
glimage_sink->visinfo = visinfo;
glimage_sink->context = glXCreateContext (glimage_sink->display,
visinfo, NULL, True);
attr.background_pixel = 0;
attr.border_pixel = 0;
attr.colormap = XCreateColormap (glimage_sink->display, root,
visinfo->visual, AllocNone);
attr.event_mask = StructureNotifyMask | ExposureMask;
attr.override_redirect = True;
//mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
mask = CWBackPixel | CWBorderPixel | CWColormap | CWOverrideRedirect;
window = XCreateWindow (glimage_sink->display, root, 0, 0,
100, 100, 0, visinfo->depth, InputOutput, visinfo->visual, mask, &attr);
XSync (glimage_sink->display, FALSE);
glXMakeCurrent (glimage_sink->display, window, glimage_sink->context);
glGetIntegerv (GL_MAX_TEXTURE_SIZE, &glimage_sink->max_texture_size);
extstring = (const char *) glGetString (GL_EXTENSIONS);
#ifdef GL_YCBCR_MESA
if (strstr (extstring, "GL_MESA_ycbcr_texture")) {
glimage_sink->have_yuv = TRUE;
} else {
glimage_sink->have_yuv = FALSE;
}
#else
glimage_sink->have_yuv = FALSE;
#endif
gst_glimage_sink_update_caps (glimage_sink);
glXMakeCurrent (glimage_sink->display, None, NULL);
XDestroyWindow (glimage_sink->display, window);
return TRUE;
}
static void
gst_glimage_sink_push_image (GstGLImageSink * glimage_sink, GstBuffer * buf)
{
int texture_size;
XWindowAttributes attr;
g_return_if_fail (buf != NULL);
if (glimage_sink->display == NULL || glimage_sink->window == 0) {
g_warning ("display or window not set up\n");
}
glXMakeCurrent (glimage_sink->display, glimage_sink->window,
glimage_sink->context);
if (glimage_sink->parent_window) {
XGetWindowAttributes (glimage_sink->display, glimage_sink->parent_window,
&attr);
//gst_glimage_sink_set_window_size (glimage_sink, attr.width, attr.height);
} else {
XGetWindowAttributes (glimage_sink->display, glimage_sink->window, &attr);
glViewport (0, 0, attr.width, attr.height);
}
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
glMatrixMode (GL_MODELVIEW);
glLoadIdentity ();
glDisable (GL_CULL_FACE);
glEnable (GL_TEXTURE_2D);
glEnableClientState (GL_TEXTURE_COORD_ARRAY);
glColor4f (1, 1, 1, 1);
#define TEXID 1000
glBindTexture (GL_TEXTURE_2D, TEXID);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
for (texture_size = 64;
(texture_size < GST_VIDEO_SINK (glimage_sink)->width ||
texture_size < GST_VIDEO_SINK (glimage_sink)->height) &&
(texture_size > 0); texture_size <<= 1);
if (glimage_sink->use_rgb) {
glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, texture_size,
texture_size, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
if (glimage_sink->use_rgbx) {
glTexSubImage2D (GL_TEXTURE_2D, 0, 0, 0,
GST_VIDEO_SINK (glimage_sink)->width,
GST_VIDEO_SINK (glimage_sink)->height,
GL_RGBA, GL_UNSIGNED_BYTE, GST_BUFFER_DATA (buf));
} else {
glTexSubImage2D (GL_TEXTURE_2D, 0, 0, 0,
GST_VIDEO_SINK (glimage_sink)->width,
GST_VIDEO_SINK (glimage_sink)->height,
GL_BGRA, GL_UNSIGNED_BYTE, GST_BUFFER_DATA (buf));
}
} else {
#ifdef GL_YCBCR_MESA
glTexImage2D (GL_TEXTURE_2D, 0, GL_YCBCR_MESA, texture_size,
texture_size, 0, GL_YCBCR_MESA, GL_UNSIGNED_SHORT_8_8_REV_MESA, NULL);
if (glimage_sink->use_yuy2) {
glTexSubImage2D (GL_TEXTURE_2D, 0, 0, 0,
GST_VIDEO_SINK (glimage_sink)->width,
GST_VIDEO_SINK (glimage_sink)->height,
GL_YCBCR_MESA, GL_UNSIGNED_SHORT_8_8_REV_MESA, GST_BUFFER_DATA (buf));
} else {
glTexSubImage2D (GL_TEXTURE_2D, 0, 0, 0,
GST_VIDEO_SINK (glimage_sink)->width,
GST_VIDEO_SINK (glimage_sink)->height,
GL_YCBCR_MESA, GL_UNSIGNED_SHORT_8_8_MESA, GST_BUFFER_DATA (buf));
}
#else
g_assert_not_reached ();
#endif
}
glColor4f (1, 0, 1, 1);
glBegin (GL_QUADS);
glNormal3f (0, 0, -1);
{
double xmax = GST_VIDEO_SINK (glimage_sink)->width / (double) texture_size;
double ymax = GST_VIDEO_SINK (glimage_sink)->height / (double) texture_size;
glTexCoord2f (xmax, 0);
glVertex3f (1.0, 1.0, 0);
glTexCoord2f (0, 0);
glVertex3f (-1.0, 1.0, 0);
glTexCoord2f (0, ymax);
glVertex3f (-1.0, -1.0, 0);
glTexCoord2f (xmax, ymax);
glVertex3f (1.0, -1.0, 0);
glEnd ();
}
glFlush ();
glXSwapBuffers (glimage_sink->display, glimage_sink->window);
}
#ifdef unused
static void gst_glimage_sink_set_window_size (GstGLImageSink * glimage_sink,
int width, int height);
static void
gst_glimage_sink_set_window_size (GstGLImageSink * glimage_sink,
int width, int height)
{
GST_DEBUG ("resizing to %d x %d",
GST_VIDEO_SINK_WIDTH (glimage_sink),
GST_VIDEO_SINK_HEIGHT (glimage_sink));
if (glimage_sink->display && glimage_sink->window) {
XResizeWindow (glimage_sink->display, glimage_sink->window, width, height);
XSync (glimage_sink->display, False);
glViewport (0, 0, width, height);
}
}
static void
gst_glimage_sink_set_xwindow_id (GstXOverlay * overlay, XID xwindow_id)
{
GstGLImageSink *glimage_sink = GST_GLIMAGE_SINK (overlay);
GST_DEBUG ("set_xwindow_id %ld", xwindow_id);
g_return_if_fail (GST_IS_GLIMAGE_SINK (glimage_sink));
/* If the element has not initialized the X11 context try to do so */
if (!glimage_sink->display) {
g_warning ("X display not inited\n");
}
if (glimage_sink->parent_window == xwindow_id)
return;
glimage_sink->parent_window = xwindow_id;
XSync (glimage_sink->display, False);
gst_glimage_sink_create_window (glimage_sink);
}
#endif
static gboolean
plugin_init (GstPlugin * plugin)
{
if (!gst_element_register (plugin, "glimagesink",
GST_RANK_MARGINAL, GST_TYPE_GLIMAGE_SINK))
return FALSE;
GST_DEBUG_CATEGORY_INIT (gst_debug_glimage_sink, "glimagesink", 0,
"glimagesink element");
return TRUE;
}
GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
GST_VERSION_MINOR,
"glimagesink",
"OpenGL video output plugin",
plugin_init, VERSION, GST_LICENSE, GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN)