#include <gst/interfaces/navigation.h>
#include <gst/interfaces/xoverlay.h>
+#include <gst/video/gstmetavideo.h>
+
/* Object header */
#include "ximagesink.h"
PROP_WINDOW_HEIGHT
};
-static GstVideoSinkClass *parent_class = NULL;
+/* ============================================================= */
+/* */
+/* Public Methods */
+/* */
+/* ============================================================= */
+
+/* =========================================== */
+/* */
+/* Object typing & Creation */
+/* */
+/* =========================================== */
+static void gst_ximagesink_interface_init (GstImplementsInterfaceClass * klass);
+static void gst_ximagesink_navigation_init (GstNavigationInterface * klass);
+static void gst_ximagesink_xoverlay_init (GstXOverlayClass * klass);
+#define gst_ximagesink_parent_class parent_class
+G_DEFINE_TYPE_WITH_CODE (GstXImageSink, gst_ximagesink, GST_TYPE_VIDEO_SINK,
+ G_IMPLEMENT_INTERFACE (GST_TYPE_IMPLEMENTS_INTERFACE,
+ gst_ximagesink_interface_init);
+ G_IMPLEMENT_INTERFACE (GST_TYPE_NAVIGATION, gst_ximagesink_navigation_init);
+ G_IMPLEMENT_INTERFACE (GST_TYPE_X_OVERLAY, gst_ximagesink_xoverlay_init));
/* ============================================================= */
/* */
GstVideoRectangle src, dst, result;
gboolean draw_border = FALSE;
- g_return_val_if_fail (GST_IS_XIMAGESINK (ximagesink), FALSE);
-
/* We take the flow_lock. If expose is in there we don't want to run
concurrently from the data flow thread */
g_mutex_lock (ximagesink->flow_lock);
if (ximage && ximagesink->cur_image != ximage) {
if (ximagesink->cur_image) {
GST_LOG_OBJECT (ximagesink, "unreffing %p", ximagesink->cur_image);
- gst_buffer_unref (GST_BUFFER_CAST (ximagesink->cur_image));
+ gst_buffer_unref (ximagesink->cur_image);
}
GST_LOG_OBJECT (ximagesink, "reffing %p as our current image", ximage);
ximagesink->cur_image = gst_buffer_ref (ximage);
}
meta = gst_buffer_get_meta_ximage (ximage);
+
src.w = meta->width;
src.h = meta->height;
dst.w = ximagesink->xwindow->width;
g_mutex_lock (ximagesink->x_lock);
- hints_atom = XInternAtom (ximagesink->xcontext->disp, "_MOTIF_WM_HINTS", 1);
+ hints_atom = XInternAtom (ximagesink->xcontext->disp, "_MOTIF_WM_HINTS",
+ True);
if (hints_atom == None) {
g_mutex_unlock (ximagesink->x_lock);
return FALSE;
gst_ximagesink_xwindow_update_geometry (GstXImageSink * ximagesink)
{
XWindowAttributes attr;
+ gboolean reconfigure;
g_return_if_fail (GST_IS_XIMAGESINK (ximagesink));
XGetWindowAttributes (ximagesink->xcontext->disp,
ximagesink->xwindow->win, &attr);
+ /* Check if we would suggest a different width/height now */
+ reconfigure = (ximagesink->xwindow->width != attr.width)
+ || (ximagesink->xwindow->height != attr.height);
ximagesink->xwindow->width = attr.width;
ximagesink->xwindow->height = attr.height;
g_mutex_unlock (ximagesink->x_lock);
+
+ if (reconfigure)
+ gst_pad_push_event (GST_BASE_SINK (ximagesink)->sinkpad,
+ gst_event_new_reconfigure ());
}
static void
g_mutex_unlock (ximagesink->x_lock);
gst_navigation_send_key_event (GST_NAVIGATION (ximagesink),
e.type == KeyPress ? "key-press" : "key-release", key_str);
-
} else {
gst_navigation_send_key_event (GST_NAVIGATION (ximagesink),
e.type == KeyPress ? "key-press" : "key-release", "unknown");
g_mutex_lock (ximagesink->x_lock);
}
+ /* Handle Expose */
while (XCheckWindowEvent (ximagesink->xcontext->disp,
ximagesink->xwindow->win, ExposureMask | StructureNotifyMask, &e)) {
switch (e.type) {
g_mutex_unlock (ximagesink->x_lock);
g_free (xcontext->par);
g_free (xcontext);
- GST_ELEMENT_ERROR (ximagesink, RESOURCE, WRITE,
+ GST_ELEMENT_ERROR (ximagesink, RESOURCE, SETTINGS,
("Could not get supported pixmap formats"), (NULL));
return NULL;
}
xcontext->use_xshm = TRUE;
GST_DEBUG ("ximagesink is using XShm extension");
} else
-#endif
+#endif /* HAVE_XSHM */
{
xcontext->use_xshm = FALSE;
GST_DEBUG ("ximagesink is not using XShm extension");
/* Element stuff */
static GstCaps *
-gst_ximagesink_getcaps (GstBaseSink * bsink)
+gst_ximagesink_getcaps (GstBaseSink * bsink, GstCaps * filter)
{
GstXImageSink *ximagesink;
GstCaps *caps;
ximagesink = GST_XIMAGESINK (bsink);
- if (ximagesink->xcontext)
- return gst_caps_ref (ximagesink->xcontext->caps);
+ g_mutex_lock (ximagesink->x_lock);
+ if (ximagesink->xcontext) {
+ GstCaps *caps;
- /* get a template copy and add the pixel aspect ratio */
- caps =
- gst_caps_copy (gst_pad_get_pad_template_caps (GST_BASE_SINK
- (ximagesink)->sinkpad));
- for (i = 0; i < gst_caps_get_size (caps); ++i) {
- GstStructure *structure = gst_caps_get_structure (caps, i);
+ caps = gst_caps_ref (ximagesink->xcontext->caps);
- if (ximagesink->par) {
+ if (filter) {
+ GstCaps *intersection;
+
+ intersection =
+ gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST);
+ gst_caps_unref (caps);
+ caps = intersection;
+ }
+
+ if (ximagesink->xwindow && ximagesink->xwindow->width) {
+ GstStructure *s0, *s1;
+
+ caps = gst_caps_make_writable (caps);
+
+ /* There can only be a single structure because the xcontext
+ * caps only have a single structure */
+ s0 = gst_caps_get_structure (caps, 0);
+ s1 = gst_structure_copy (gst_caps_get_structure (caps, 0));
+
+ gst_structure_set (s0, "width", G_TYPE_INT, ximagesink->xwindow->width,
+ "height", G_TYPE_INT, ximagesink->xwindow->height, NULL);
+ gst_caps_append_structure (caps, s1);
+
+ /* This will not change the order but will remove the
+ * fixed width/height caps again if not possible
+ * upstream */
+ if (filter) {
+ GstCaps *intersection;
+
+ intersection =
+ gst_caps_intersect_full (caps, filter, GST_CAPS_INTERSECT_FIRST);
+ gst_caps_unref (caps);
+ caps = intersection;
+ }
+ }
+
+ g_mutex_unlock (ximagesink->x_lock);
+ return caps;
+ }
+ g_mutex_unlock (ximagesink->x_lock);
+
+ /* get a template copy and add the pixel aspect ratio */
+ caps = gst_pad_get_pad_template_caps (GST_BASE_SINK (ximagesink)->sinkpad);
+ if (ximagesink->par) {
+ caps = gst_caps_make_writable (caps);
+ for (i = 0; i < gst_caps_get_size (caps); ++i) {
+ GstStructure *structure = gst_caps_get_structure (caps, i);
int nom, den;
nom = gst_value_get_fraction_numerator (ximagesink->par);
}
}
+ if (filter) {
+ GstCaps *intersection;
+
+ intersection =
+ gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST);
+ gst_caps_unref (caps);
+ caps = intersection;
+ }
+
return caps;
}
gst_ximagesink_setcaps (GstBaseSink * bsink, GstCaps * caps)
{
GstXImageSink *ximagesink;
- gboolean ret = TRUE;
GstStructure *structure;
GstBufferPool *newpool, *oldpool;
+ gboolean ret = TRUE;
const GValue *par;
gint new_width, new_height;
const GValue *fps;
ret &= gst_structure_get_int (structure, "height", &new_height);
fps = gst_structure_get_value (structure, "framerate");
ret &= (fps != NULL);
+
if (!ret)
return FALSE;
}
/* Remember to draw borders for next frame */
ximagesink->draw_border = TRUE;
- g_mutex_unlock (ximagesink->flow_lock);
/* create a new pool for the new configuration */
newpool = gst_ximage_buffer_pool_new (ximagesink);
gst_buffer_pool_set_active (oldpool, FALSE);
gst_object_unref (oldpool);
}
+ g_mutex_unlock (ximagesink->flow_lock);
+
return TRUE;
/* ERRORS */
config_failed:
{
GST_ERROR_OBJECT (ximagesink, "failed to set config.");
+ g_mutex_unlock (ximagesink->flow_lock);
return FALSE;
}
activate_failed:
{
GST_ERROR_OBJECT (ximagesink, "failed to activate bufferpool.");
+ g_mutex_unlock (ximagesink->flow_lock);
return FALSE;
}
}
static GstStateChangeReturn
gst_ximagesink_change_state (GstElement * element, GstStateChange transition)
{
- GstXImageSink *ximagesink;
GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
+ GstXImageSink *ximagesink;
GstXContext *xcontext = NULL;
ximagesink = GST_XIMAGESINK (element);
switch (transition) {
case GST_STATE_CHANGE_NULL_TO_READY:
-
/* Initializing the XContext */
if (ximagesink->xcontext == NULL) {
xcontext = gst_ximagesink_xcontext_get (ximagesink);
ximagesink->fps_d = 1;
GST_VIDEO_SINK_WIDTH (ximagesink) = 0;
GST_VIDEO_SINK_HEIGHT (ximagesink) = 0;
+ g_mutex_lock (ximagesink->flow_lock);
+ if (ximagesink->pool)
+ gst_buffer_pool_set_active (ximagesink->pool, FALSE);
+ g_mutex_unlock (ximagesink->flow_lock);
break;
case GST_STATE_CHANGE_READY_TO_NULL:
gst_ximagesink_reset (ximagesink);
GstFlowReturn res;
GstXImageSink *ximagesink;
GstMetaXImage *meta;
-
- g_return_val_if_fail (buf != NULL, GST_FLOW_ERROR);
+ GstBuffer *temp;
+ gboolean unref;
ximagesink = GST_XIMAGESINK (vsink);
- /* This shouldn't really happen because state changes will fail
- * if the xcontext can't be allocated */
- if (!ximagesink->xcontext)
- return GST_FLOW_ERROR;
-
meta = gst_buffer_get_meta_ximage (buf);
if (meta) {
put the ximage which is in the PRIVATE pointer */
GST_LOG_OBJECT (ximagesink, "buffer from our pool, writing directly");
res = GST_FLOW_OK;
+ unref = FALSE;
} else {
- GstBuffer *temp;
+ guint8 *data;
+ gsize size;
/* Else we have to copy the data into our private image, */
/* if we have one... */
if (res != GST_FLOW_OK)
goto no_buffer;
- if (GST_BUFFER_SIZE (temp) < GST_BUFFER_SIZE (buf))
+ unref = TRUE;
+
+ if (gst_buffer_get_size (temp) < gst_buffer_get_size (buf))
goto wrong_size;
- memcpy (GST_BUFFER_DATA (temp), GST_BUFFER_DATA (buf),
- MIN (GST_BUFFER_SIZE (temp), GST_BUFFER_SIZE (buf)));
+ data = gst_buffer_map (temp, &size, NULL, GST_MAP_WRITE);
+ gst_buffer_extract (buf, 0, data, size);
+ gst_buffer_unmap (temp, data, size);
buf = temp;
}
if (!gst_ximagesink_ximage_put (ximagesink, buf))
goto no_window;
+done:
+ if (unref)
+ gst_buffer_unref (buf);
+
return res;
/* ERRORS */
{
GST_ELEMENT_ERROR (ximagesink, RESOURCE, WRITE,
("Failed to create output image buffer"),
- ("XServer allocated buffer size did not match input buffer"));
- return GST_FLOW_ERROR;
+ ("XServer allocated buffer size did not match input buffer %"
+ G_GSIZE_FORMAT " - %" G_GSIZE_FORMAT, gst_buffer_get_size (temp),
+ gst_buffer_get_size (buf)));
+ res = GST_FLOW_ERROR;
+ goto done;
}
no_window:
{
/* No Window available to put our image into */
GST_WARNING_OBJECT (ximagesink, "could not output image - no window");
- return GST_FLOW_ERROR;
+ res = GST_FLOW_ERROR;
+ goto done;
}
}
return TRUE;
}
-/* Buffer management
- *
- * The buffer_alloc function must either return a buffer with given size and
- * caps or create a buffer with different caps attached to the buffer. This
- * last option is called reverse negotiation, ie, where the sink suggests a
- * different format from the upstream peer.
- *
- * We try to do reverse negotiation when our geometry changes and we like a
- * resized buffer.
- */
-static GstFlowReturn
-gst_ximagesink_buffer_alloc (GstBaseSink * bsink, guint64 offset, guint size,
- GstCaps * caps, GstBuffer ** buf)
+static gboolean
+gst_ximagesink_sink_query (GstPad * sinkpad, GstQuery * query)
{
- GstXImageSink *ximagesink;
- GstBuffer *ximage = NULL;
- GstStructure *structure = NULL;
- GstFlowReturn ret = GST_FLOW_OK;
- GstCaps *alloc_caps;
- gboolean alloc_unref = FALSE;
- gint width, height;
- GstVideoRectangle dst, src, result;
- gboolean caps_accepted = FALSE;
-
- ximagesink = GST_XIMAGESINK (bsink);
-
- /* This shouldn't really happen because state changes will fail
- * if the xcontext can't be allocated */
- if (!ximagesink->xcontext)
- return GST_FLOW_ERROR;
-
- GST_LOG_OBJECT (ximagesink,
- "a buffer of %d bytes was requested with caps %" GST_PTR_FORMAT
- " and offset %" G_GUINT64_FORMAT, size, caps, offset);
-
- /* assume we're going to alloc what was requested, keep track of
- * wheter we need to unref or not. When we suggest a new format
- * upstream we will create a new caps that we need to unref. */
- alloc_caps = caps;
- alloc_unref = FALSE;
-
- /* get struct to see what is requested */
- structure = gst_caps_get_structure (caps, 0);
- if (!gst_structure_get_int (structure, "width", &width) ||
- !gst_structure_get_int (structure, "height", &height)) {
- GST_WARNING_OBJECT (ximagesink, "invalid caps for buffer allocation %"
- GST_PTR_FORMAT, caps);
- ret = GST_FLOW_NOT_NEGOTIATED;
- goto beach;
- }
-
- src.w = width;
- src.h = height;
+ GstXImageSink *ximagesink = GST_XIMAGESINK (GST_PAD_PARENT (sinkpad));
+ gboolean res = TRUE;
- /* We take the flow_lock because the window might go away */
- g_mutex_lock (ximagesink->flow_lock);
- if (!ximagesink->xwindow) {
- g_mutex_unlock (ximagesink->flow_lock);
- goto alloc;
- }
+ switch (GST_QUERY_TYPE (query)) {
+ case GST_QUERY_ALLOCATION:
+ {
+ GstBufferPool *pool;
+ GstStructure *config;
+ GstCaps *caps;
+ guint size;
+ gboolean need_pool;
- /* What is our geometry */
- dst.w = ximagesink->xwindow->width;
- dst.h = ximagesink->xwindow->height;
+ gst_query_parse_allocation (query, &caps, &need_pool);
- g_mutex_unlock (ximagesink->flow_lock);
+ if (caps == NULL)
+ goto no_caps;
- if (ximagesink->keep_aspect) {
- GST_LOG_OBJECT (ximagesink, "enforcing aspect ratio in reverse caps "
- "negotiation");
- gst_video_sink_center_rect (src, dst, &result, TRUE);
- } else {
- GST_LOG_OBJECT (ximagesink, "trying to resize to window geometry "
- "ignoring aspect ratio");
- result.x = result.y = 0;
- result.w = dst.w;
- result.h = dst.h;
- }
+ g_mutex_lock (ximagesink->flow_lock);
+ if ((pool = ximagesink->pool))
+ gst_object_ref (pool);
+ g_mutex_unlock (ximagesink->flow_lock);
- /* We would like another geometry */
- if (width != result.w || height != result.h) {
- int nom, den;
- GstCaps *desired_caps;
- GstStructure *desired_struct;
+ if (pool != NULL) {
+ const GstCaps *pcaps;
+
+ /* we had a pool, check caps */
+ config = gst_buffer_pool_get_config (pool);
+ gst_buffer_pool_config_get (config, &pcaps, &size, NULL, NULL, NULL,
+ NULL, NULL);
+
+ GST_DEBUG_OBJECT (ximagesink,
+ "we had a pool with caps %" GST_PTR_FORMAT, pcaps);
+ if (!gst_caps_is_equal (caps, pcaps)) {
+ /* different caps, we can't use this pool */
+ GST_DEBUG_OBJECT (ximagesink, "pool has different caps");
+ gst_object_unref (pool);
+ pool = NULL;
+ }
+ }
+ if (pool == NULL && need_pool) {
+ GstVideoFormat format;
+ gint width, height;
- /* make a copy of the incomming caps to create the new
- * suggestion. We can't use make_writable because we might
- * then destroy the original caps which we still need when the
- * peer does not accept the suggestion. */
- desired_caps = gst_caps_copy (caps);
- desired_struct = gst_caps_get_structure (desired_caps, 0);
+ GST_DEBUG_OBJECT (ximagesink, "create new pool");
+ pool = gst_ximage_buffer_pool_new (ximagesink);
- GST_DEBUG ("we would love to receive a %dx%d video", result.w, result.h);
- gst_structure_set (desired_struct, "width", G_TYPE_INT, result.w, NULL);
- gst_structure_set (desired_struct, "height", G_TYPE_INT, result.h, NULL);
+ if (!gst_video_format_parse_caps (caps, &format, &width, &height))
+ goto invalid_caps;
- /* PAR property overrides the X calculated one */
- if (ximagesink->par) {
- nom = gst_value_get_fraction_numerator (ximagesink->par);
- den = gst_value_get_fraction_denominator (ximagesink->par);
- gst_structure_set (desired_struct, "pixel-aspect-ratio",
- GST_TYPE_FRACTION, nom, den, NULL);
- } else if (ximagesink->xcontext->par) {
- nom = gst_value_get_fraction_numerator (ximagesink->xcontext->par);
- den = gst_value_get_fraction_denominator (ximagesink->xcontext->par);
- gst_structure_set (desired_struct, "pixel-aspect-ratio",
- GST_TYPE_FRACTION, nom, den, NULL);
- }
+ /* the normal size of a frame */
+ size = gst_video_format_get_size (format, width, height);
+ config = gst_buffer_pool_get_config (pool);
+ gst_buffer_pool_config_set (config, caps, size, 0, 0, 0, 0, 16);
+ if (!gst_buffer_pool_set_config (pool, config))
+ goto config_failed;
+ }
+ gst_query_set_allocation_params (query, size, 0, 0, 0, 16, pool);
- /* see if peer accepts our new suggestion, if there is no peer, this
- * function returns true. */
- if (!ximagesink->xcontext->last_caps ||
- !gst_caps_is_equal (desired_caps, ximagesink->xcontext->last_caps)) {
- caps_accepted =
- gst_pad_peer_accept_caps (GST_VIDEO_SINK_PAD (ximagesink),
- desired_caps);
+ /* we also support various metadata */
+ gst_query_add_allocation_meta (query, GST_META_API_VIDEO);
- /* Suggestion failed, prevent future attempts for the same caps
- * to fail as well. */
- if (!caps_accepted)
- gst_caps_replace (&ximagesink->xcontext->last_caps, desired_caps);
- }
-
- if (caps_accepted) {
- /* we will not alloc a buffer of the new suggested caps. Make sure
- * we also unref this new caps after we set it on the buffer. */
- alloc_caps = desired_caps;
- alloc_unref = TRUE;
- width = result.w;
- height = result.h;
- GST_DEBUG ("peer pad accepts our desired caps %" GST_PTR_FORMAT,
- desired_caps);
- } else {
- GST_DEBUG ("peer pad does not accept our desired caps %" GST_PTR_FORMAT,
- desired_caps);
- /* we alloc a buffer with the original incomming caps already in the
- * width and height variables */
- gst_caps_unref (desired_caps);
+ gst_object_unref (pool);
+ break;
}
+ default:
+ res = FALSE;
+ break;
}
+ return res;
-alloc:
-
- if (gst_caps_is_equal (GST_PAD_CAPS (bsink->sinkpad), alloc_caps)) {
- /* we negotiated this format before, use the pool */
- if (ximagesink->pool) {
- GST_LOG_OBJECT (ximagesink, "retrieving buffer from pool");
- ret = gst_buffer_pool_acquire_buffer (ximagesink->pool, &ximage, NULL);
- }
+ /* ERRORS */
+no_caps:
+ {
+ GST_DEBUG_OBJECT (sinkpad, "no caps specified");
+ return FALSE;
}
-
- if (ximage == NULL) {
- /* Something new make a new image a new one */
- GST_LOG_OBJECT (ximagesink, "allocating new image");
- ximage = gst_ximage_buffer_new (ximagesink, width, height);
+invalid_caps:
+ {
+ GST_DEBUG_OBJECT (sinkpad, "invalid caps specified");
+ return FALSE;
}
-
- /* Now we should have a ximage, set appropriate caps on it */
- if (ximage) {
- /* Make sure the buffer is cleared of any previously used flags */
- GST_MINI_OBJECT_CAST (ximage)->flags = 0;
- gst_buffer_set_caps (ximage, alloc_caps);
+config_failed:
+ {
+ GST_DEBUG_OBJECT (sinkpad, "failed setting config");
+ return FALSE;
}
-
- /* could be our new reffed suggestion or the original unreffed caps */
- if (alloc_unref)
- gst_caps_unref (alloc_caps);
-
- *buf = ximage;
-
-beach:
- return ret;
}
/* Interfaces stuff */
g_thread_join (thread);
if (ximagesink->cur_image) {
- gst_buffer_unref (GST_BUFFER_CAST (ximagesink->cur_image));
+ gst_buffer_unref (ximagesink->cur_image);
ximagesink->cur_image = NULL;
}
+ g_mutex_lock (ximagesink->flow_lock);
+
if (ximagesink->pool) {
gst_object_unref (ximagesink->pool);
ximagesink->pool = NULL;
}
- g_mutex_lock (ximagesink->flow_lock);
if (ximagesink->xwindow) {
gst_ximagesink_xwindow_clear (ximagesink, ximagesink->xwindow);
gst_ximagesink_xwindow_destroy (ximagesink, ximagesink->xwindow);
static void
gst_ximagesink_init (GstXImageSink * ximagesink)
{
+ /* for the ALLOCATION query */
+ gst_pad_set_query_function (GST_BASE_SINK (ximagesink)->sinkpad,
+ gst_ximagesink_sink_query);
+
ximagesink->display_name = NULL;
ximagesink->xcontext = NULL;
ximagesink->xwindow = NULL;
}
static void
-gst_ximagesink_base_init (gpointer g_class)
-{
- GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
-
- gst_element_class_set_details_simple (element_class,
- "Video sink", "Sink/Video",
- "A standard X based videosink", "Julien Moutte <julien@moutte.net>");
-
- gst_element_class_add_pad_template (element_class,
- gst_static_pad_template_get (&gst_ximagesink_sink_template_factory));
-}
-
-static void
gst_ximagesink_class_init (GstXImageSinkClass * klass)
{
GObjectClass *gobject_class;
gstbasesink_class = (GstBaseSinkClass *) klass;
videosink_class = (GstVideoSinkClass *) klass;
- parent_class = g_type_class_peek_parent (klass);
-
gobject_class->finalize = gst_ximagesink_finalize;
gobject_class->set_property = gst_ximagesink_set_property;
gobject_class->get_property = gst_ximagesink_get_property;
"Height of the window", 0, G_MAXUINT64, 0,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
+ gst_element_class_set_details_simple (gstelement_class,
+ "Video sink", "Sink/Video",
+ "A standard X based videosink", "Julien Moutte <julien@moutte.net>");
+
+ gst_element_class_add_pad_template (gstelement_class,
+ gst_static_pad_template_get (&gst_ximagesink_sink_template_factory));
+
gstelement_class->change_state = gst_ximagesink_change_state;
gstbasesink_class->get_caps = GST_DEBUG_FUNCPTR (gst_ximagesink_getcaps);
gstbasesink_class->set_caps = GST_DEBUG_FUNCPTR (gst_ximagesink_setcaps);
- gstbasesink_class->buffer_alloc =
- GST_DEBUG_FUNCPTR (gst_ximagesink_buffer_alloc);
gstbasesink_class->get_times = GST_DEBUG_FUNCPTR (gst_ximagesink_get_times);
gstbasesink_class->event = GST_DEBUG_FUNCPTR (gst_ximagesink_event);
videosink_class->show_frame = GST_DEBUG_FUNCPTR (gst_ximagesink_show_frame);
}
-
-/* ============================================================= */
-/* */
-/* Public Methods */
-/* */
-/* ============================================================= */
-
-/* =========================================== */
-/* */
-/* Object typing & Creation */
-/* */
-/* =========================================== */
-
-GType
-gst_ximagesink_get_type (void)
-{
- static GType ximagesink_type = 0;
-
- if (!ximagesink_type) {
- static const GTypeInfo ximagesink_info = {
- sizeof (GstXImageSinkClass),
- gst_ximagesink_base_init,
- NULL,
- (GClassInitFunc) gst_ximagesink_class_init,
- NULL,
- NULL,
- sizeof (GstXImageSink), 0, (GInstanceInitFunc) gst_ximagesink_init,
- };
- static const GInterfaceInfo iface_info = {
- (GInterfaceInitFunc) gst_ximagesink_interface_init, NULL, NULL,
- };
- static const GInterfaceInfo navigation_info = {
- (GInterfaceInitFunc) gst_ximagesink_navigation_init, NULL, NULL,
- };
- static const GInterfaceInfo overlay_info = {
- (GInterfaceInitFunc) gst_ximagesink_xoverlay_init, NULL, NULL,
- };
-
- ximagesink_type = g_type_register_static (GST_TYPE_VIDEO_SINK,
- "GstXImageSink", &ximagesink_info, 0);
-
- g_type_add_interface_static (ximagesink_type, GST_TYPE_IMPLEMENTS_INTERFACE,
- &iface_info);
- g_type_add_interface_static (ximagesink_type, GST_TYPE_NAVIGATION,
- &navigation_info);
- g_type_add_interface_static (ximagesink_type, GST_TYPE_X_OVERLAY,
- &overlay_info);
-
- /* register type and create class in a more safe place instead of at
- * runtime since the type registration and class creation is not
- * threadsafe. */
- g_type_class_ref (gst_ximage_buffer_pool_get_type ());
- }
-
- return ximagesink_type;
-}
projects / platform / upstream / gstreamer.git / blobdiff