GstXImageSink
<SUBSECTION Standard>
GstXImageSinkClass
-GST_XIMAGESINK
-GST_IS_XIMAGESINK
-GST_XIMAGESINK_CLASS
-GST_IS_XIMAGESINK_CLASS
-GST_TYPE_XIMAGESINK
+GST_X_IMAGE_SINK
+GST_IS_X_IMAGE_SINK
+GST_X_IMAGE_SINK_CLASS
+GST_IS_X_IMAGE_SINK_CLASS
+GST_TYPE_X_IMAGE_SINK
GstXImageBuffer
GstXImageBufferClass
GstXContext
GstXWindow
<SUBSECTION Private>
-gst_ximage_sink_get_type
+gst_x_image_sink_get_type
</SECTION>
<SECTION>
GstXvImageSink
<SUBSECTION Standard>
GstXvImageSinkClass
-GST_XVIMAGESINK
-GST_IS_XVIMAGESINK
-GST_XVIMAGESINK_CLASS
-GST_IS_XVIMAGESINK_CLASS
-GST_TYPE_XVIMAGESINK
+GST_XV_IMAGE_SINK
+GST_IS_XV_IMAGE_SINK
+GST_XV_IMAGE_SINK_CLASS
+GST_IS_XV_IMAGE_SINK_CLASS
+GST_TYPE_XV_IMAGE_SINK
GstXvImageBuffer
GstXvImageBufferClass
GstXvImageFormat
<SUBSECTION Private>
-gst_xvimage_sink_get_type
+gst_xv_image_sink_get_type
</SECTION>
#include "ximagesink.h"
-GST_DEBUG_CATEGORY (gst_debug_ximagepool);
-GST_DEBUG_CATEGORY (gst_debug_ximagesink);
+GST_DEBUG_CATEGORY (gst_debug_x_image_pool);
+GST_DEBUG_CATEGORY (gst_debug_x_image_sink);
GST_DEBUG_CATEGORY_STATIC (GST_CAT_PERFORMANCE);
static gboolean
plugin_init (GstPlugin * plugin)
{
if (!gst_element_register (plugin, "ximagesink",
- GST_RANK_SECONDARY, GST_TYPE_XIMAGESINK))
+ GST_RANK_SECONDARY, GST_TYPE_X_IMAGE_SINK))
return FALSE;
- GST_DEBUG_CATEGORY_INIT (gst_debug_ximagesink, "ximagesink", 0,
+ GST_DEBUG_CATEGORY_INIT (gst_debug_x_image_sink, "ximagesink", 0,
"ximagesink element");
- GST_DEBUG_CATEGORY_INIT (gst_debug_ximagepool, "ximagepool", 0,
+ GST_DEBUG_CATEGORY_INIT (gst_debug_x_image_pool, "ximagepool", 0,
"ximagepool object");
GST_DEBUG_CATEGORY_GET (GST_CAT_PERFORMANCE, "GST_PERFORMANCE");
#include <gst/video/gstvideometa.h>
#include <gst/video/gstvideopool.h>
-GST_DEBUG_CATEGORY_EXTERN (gst_debug_ximagepool);
-#define GST_CAT_DEFAULT gst_debug_ximagepool
+GST_DEBUG_CATEGORY_EXTERN (gst_debug_x_image_pool);
+#define GST_CAT_DEFAULT gst_debug_x_image_pool
/* X11 stuff */
static gboolean error_caught = FALSE;
/* This function checks that it is actually really possible to create an image
using XShm */
gboolean
-gst_ximagesink_check_xshm_calls (GstXImageSink * ximagesink,
+gst_x_image_sink_check_xshm_calls (GstXImageSink * ximagesink,
GstXContext * xcontext)
{
XImage *ximage;
{
GstXImageBufferPool *pool;
- g_return_val_if_fail (GST_IS_XIMAGESINK (ximagesink), NULL);
+ g_return_val_if_fail (GST_IS_X_IMAGE_SINK (ximagesink), NULL);
pool = g_object_new (GST_TYPE_XIMAGE_BUFFER_POOL, NULL);
pool->sink = gst_object_ref (ximagesink);
GstBufferPool * gst_ximage_buffer_pool_new (GstXImageSink * ximagesink);
-gboolean gst_ximagesink_check_xshm_calls (GstXImageSink * ximagesink,
+gboolean gst_x_image_sink_check_xshm_calls (GstXImageSink * ximagesink,
GstXContext * xcontext);
G_END_DECLS
/* for XkbKeycodeToKeysym */
#include <X11/XKBlib.h>
-GST_DEBUG_CATEGORY_EXTERN (gst_debug_ximagesink);
+GST_DEBUG_CATEGORY_EXTERN (gst_debug_x_image_sink);
GST_DEBUG_CATEGORY_EXTERN (GST_CAT_PERFORMANCE);
-#define GST_CAT_DEFAULT gst_debug_ximagesink
+#define GST_CAT_DEFAULT gst_debug_x_image_sink
typedef struct
{
#define MWM_HINTS_DECORATIONS (1L << 1)
-static void gst_ximagesink_reset (GstXImageSink * ximagesink);
-static void gst_ximagesink_xwindow_update_geometry (GstXImageSink * ximagesink);
-static void gst_ximagesink_expose (GstVideoOverlay * overlay);
+static void gst_x_image_sink_reset (GstXImageSink * ximagesink);
+static void gst_x_image_sink_xwindow_update_geometry (GstXImageSink *
+ ximagesink);
+static void gst_x_image_sink_expose (GstVideoOverlay * overlay);
-static GstStaticPadTemplate gst_ximagesink_sink_template_factory =
+static GstStaticPadTemplate gst_x_image_sink_sink_template_factory =
GST_STATIC_PAD_TEMPLATE ("sink",
GST_PAD_SINK,
GST_PAD_ALWAYS,
/* Object typing & Creation */
/* */
/* =========================================== */
-static void gst_ximagesink_navigation_init (GstNavigationInterface * iface);
-static void gst_ximagesink_video_overlay_init (GstVideoOverlayInterface *
+static void gst_x_image_sink_navigation_init (GstNavigationInterface * iface);
+static void gst_x_image_sink_video_overlay_init (GstVideoOverlayInterface *
iface);
-#define gst_ximagesink_parent_class parent_class
-G_DEFINE_TYPE_WITH_CODE (GstXImageSink, gst_ximagesink, GST_TYPE_VIDEO_SINK,
- G_IMPLEMENT_INTERFACE (GST_TYPE_NAVIGATION, gst_ximagesink_navigation_init);
+#define gst_x_image_sink_parent_class parent_class
+G_DEFINE_TYPE_WITH_CODE (GstXImageSink, gst_x_image_sink, GST_TYPE_VIDEO_SINK,
+ G_IMPLEMENT_INTERFACE (GST_TYPE_NAVIGATION,
+ gst_x_image_sink_navigation_init);
G_IMPLEMENT_INTERFACE (GST_TYPE_VIDEO_OVERLAY,
- gst_ximagesink_video_overlay_init));
+ gst_x_image_sink_video_overlay_init));
/* ============================================================= */
/* */
/* We are called with the x_lock taken */
static void
-gst_ximagesink_xwindow_draw_borders (GstXImageSink * ximagesink,
+gst_x_image_sink_xwindow_draw_borders (GstXImageSink * ximagesink,
GstXWindow * xwindow, GstVideoRectangle rect)
{
- g_return_if_fail (GST_IS_XIMAGESINK (ximagesink));
+ g_return_if_fail (GST_IS_X_IMAGE_SINK (ximagesink));
g_return_if_fail (xwindow != NULL);
XSetForeground (ximagesink->xcontext->disp, xwindow->gc,
/* This function puts a GstXImageBuffer on a GstXImageSink's window */
static gboolean
-gst_ximagesink_ximage_put (GstXImageSink * ximagesink, GstBuffer * ximage)
+gst_x_image_sink_ximage_put (GstXImageSink * ximagesink, GstBuffer * ximage)
{
GstXImageMemory *mem;
GstVideoCropMeta *crop;
g_mutex_lock (&ximagesink->x_lock);
if (draw_border) {
- gst_ximagesink_xwindow_draw_borders (ximagesink, ximagesink->xwindow,
+ gst_x_image_sink_xwindow_draw_borders (ximagesink, ximagesink->xwindow,
result);
ximagesink->draw_border = FALSE;
}
}
static gboolean
-gst_ximagesink_xwindow_decorate (GstXImageSink * ximagesink,
+gst_x_image_sink_xwindow_decorate (GstXImageSink * ximagesink,
GstXWindow * window)
{
Atom hints_atom = None;
MotifWmHints *hints;
- g_return_val_if_fail (GST_IS_XIMAGESINK (ximagesink), FALSE);
+ g_return_val_if_fail (GST_IS_X_IMAGE_SINK (ximagesink), FALSE);
g_return_val_if_fail (window != NULL, FALSE);
g_mutex_lock (&ximagesink->x_lock);
}
static void
-gst_ximagesink_xwindow_set_title (GstXImageSink * ximagesink,
+gst_x_image_sink_xwindow_set_title (GstXImageSink * ximagesink,
GstXWindow * xwindow, const gchar * media_title)
{
if (media_title) {
/* This function handles a GstXWindow creation */
static GstXWindow *
-gst_ximagesink_xwindow_new (GstXImageSink * ximagesink, gint width, gint height)
+gst_x_image_sink_xwindow_new (GstXImageSink * ximagesink, gint width,
+ gint height)
{
GstXWindow *xwindow = NULL;
XGCValues values;
- g_return_val_if_fail (GST_IS_XIMAGESINK (ximagesink), NULL);
+ g_return_val_if_fail (GST_IS_X_IMAGE_SINK (ximagesink), NULL);
xwindow = g_new0 (GstXWindow, 1);
XSetWindowBackgroundPixmap (ximagesink->xcontext->disp, xwindow->win, None);
/* set application name as a title */
- gst_ximagesink_xwindow_set_title (ximagesink, xwindow, NULL);
+ gst_x_image_sink_xwindow_set_title (ximagesink, xwindow, NULL);
if (ximagesink->handle_events) {
Atom wm_delete;
g_mutex_unlock (&ximagesink->x_lock);
- gst_ximagesink_xwindow_decorate (ximagesink, xwindow);
+ gst_x_image_sink_xwindow_decorate (ximagesink, xwindow);
gst_video_overlay_got_window_handle (GST_VIDEO_OVERLAY (ximagesink),
xwindow->win);
/* This function destroys a GstXWindow */
static void
-gst_ximagesink_xwindow_destroy (GstXImageSink * ximagesink,
+gst_x_image_sink_xwindow_destroy (GstXImageSink * ximagesink,
GstXWindow * xwindow)
{
g_return_if_fail (xwindow != NULL);
- g_return_if_fail (GST_IS_XIMAGESINK (ximagesink));
+ g_return_if_fail (GST_IS_X_IMAGE_SINK (ximagesink));
g_mutex_lock (&ximagesink->x_lock);
}
static void
-gst_ximagesink_xwindow_update_geometry (GstXImageSink * ximagesink)
+gst_x_image_sink_xwindow_update_geometry (GstXImageSink * ximagesink)
{
XWindowAttributes attr;
gboolean reconfigure;
- g_return_if_fail (GST_IS_XIMAGESINK (ximagesink));
+ g_return_if_fail (GST_IS_X_IMAGE_SINK (ximagesink));
/* Update the window geometry */
g_mutex_lock (&ximagesink->x_lock);
}
static void
-gst_ximagesink_xwindow_clear (GstXImageSink * ximagesink, GstXWindow * xwindow)
+gst_x_image_sink_xwindow_clear (GstXImageSink * ximagesink,
+ GstXWindow * xwindow)
{
g_return_if_fail (xwindow != NULL);
- g_return_if_fail (GST_IS_XIMAGESINK (ximagesink));
+ g_return_if_fail (GST_IS_X_IMAGE_SINK (ximagesink));
g_mutex_lock (&ximagesink->x_lock);
GstEvent that will be sent upstream in the pipeline to handle interactivity
and navigation.*/
static void
-gst_ximagesink_handle_xevents (GstXImageSink * ximagesink)
+gst_x_image_sink_handle_xevents (GstXImageSink * ximagesink)
{
XEvent e;
guint pointer_x = 0, pointer_y = 0;
gboolean pointer_moved = FALSE;
gboolean exposed = FALSE, configured = FALSE;
- g_return_if_fail (GST_IS_XIMAGESINK (ximagesink));
+ g_return_if_fail (GST_IS_X_IMAGE_SINK (ximagesink));
/* Then we get all pointer motion events, only the last position is
interesting. */
break;
case ConfigureNotify:
g_mutex_unlock (&ximagesink->x_lock);
- gst_ximagesink_xwindow_update_geometry (ximagesink);
+ gst_x_image_sink_xwindow_update_geometry (ximagesink);
g_mutex_lock (&ximagesink->x_lock);
configured = TRUE;
break;
g_mutex_unlock (&ximagesink->x_lock);
g_mutex_unlock (&ximagesink->flow_lock);
- gst_ximagesink_expose (GST_VIDEO_OVERLAY (ximagesink));
+ gst_x_image_sink_expose (GST_VIDEO_OVERLAY (ximagesink));
g_mutex_lock (&ximagesink->flow_lock);
g_mutex_lock (&ximagesink->x_lock);
("Output window was closed"), (NULL));
g_mutex_unlock (&ximagesink->x_lock);
- gst_ximagesink_xwindow_destroy (ximagesink, ximagesink->xwindow);
+ gst_x_image_sink_xwindow_destroy (ximagesink, ximagesink->xwindow);
ximagesink->xwindow = NULL;
g_mutex_lock (&ximagesink->x_lock);
}
}
static gpointer
-gst_ximagesink_event_thread (GstXImageSink * ximagesink)
+gst_x_image_sink_event_thread (GstXImageSink * ximagesink)
{
- g_return_val_if_fail (GST_IS_XIMAGESINK (ximagesink), NULL);
+ g_return_val_if_fail (GST_IS_X_IMAGE_SINK (ximagesink), NULL);
GST_OBJECT_LOCK (ximagesink);
while (ximagesink->running) {
GST_OBJECT_UNLOCK (ximagesink);
if (ximagesink->xwindow) {
- gst_ximagesink_handle_xevents (ximagesink);
+ gst_x_image_sink_handle_xevents (ximagesink);
}
/* FIXME: do we want to align this with the framerate or anything else? */
g_usleep (G_USEC_PER_SEC / 20);
}
static void
-gst_ximagesink_manage_event_thread (GstXImageSink * ximagesink)
+gst_x_image_sink_manage_event_thread (GstXImageSink * ximagesink)
{
GThread *thread = NULL;
ximagesink->handle_expose, ximagesink->handle_events);
ximagesink->running = TRUE;
ximagesink->event_thread = g_thread_try_new ("ximagesink-events",
- (GThreadFunc) gst_ximagesink_event_thread, ximagesink, NULL);
+ (GThreadFunc) gst_x_image_sink_event_thread, ximagesink, NULL);
}
} else {
if (ximagesink->event_thread) {
/* This function calculates the pixel aspect ratio based on the properties
* in the xcontext structure and stores it there. */
static void
-gst_ximagesink_calculate_pixel_aspect_ratio (GstXContext * xcontext)
+gst_x_image_sink_calculate_pixel_aspect_ratio (GstXContext * xcontext)
{
static const gint par[][2] = {
{1, 1}, /* regular screen */
here that caps for supported format are generated without any window or
image creation */
static GstXContext *
-gst_ximagesink_xcontext_get (GstXImageSink * ximagesink)
+gst_x_image_sink_xcontext_get (GstXImageSink * ximagesink)
{
GstXContext *xcontext = NULL;
XPixmapFormatValues *px_formats = NULL;
GstVideoFormat vformat;
guint32 alpha_mask;
- g_return_val_if_fail (GST_IS_XIMAGESINK (ximagesink), NULL);
+ g_return_val_if_fail (GST_IS_X_IMAGE_SINK (ximagesink), NULL);
xcontext = g_new0 (GstXContext, 1);
GST_DEBUG_OBJECT (ximagesink, "X reports %dx%d pixels and %d mm x %d mm",
xcontext->width, xcontext->height, xcontext->widthmm, xcontext->heightmm);
- gst_ximagesink_calculate_pixel_aspect_ratio (xcontext);
+ gst_x_image_sink_calculate_pixel_aspect_ratio (xcontext);
/* We get supported pixmap formats at supported depth */
px_formats = XListPixmapFormats (xcontext->disp, &nb_formats);
/* Search for XShm extension support */
#ifdef HAVE_XSHM
if (XShmQueryExtension (xcontext->disp) &&
- gst_ximagesink_check_xshm_calls (ximagesink, xcontext)) {
+ gst_x_image_sink_check_xshm_calls (ximagesink, xcontext)) {
xcontext->use_xshm = TRUE;
GST_DEBUG ("ximagesink is using XShm extension");
} else
/* This function cleans the X context. Closing the Display and unrefing the
caps for supported formats. */
static void
-gst_ximagesink_xcontext_clear (GstXImageSink * ximagesink)
+gst_x_image_sink_xcontext_clear (GstXImageSink * ximagesink)
{
GstXContext *xcontext;
- g_return_if_fail (GST_IS_XIMAGESINK (ximagesink));
+ g_return_if_fail (GST_IS_X_IMAGE_SINK (ximagesink));
GST_OBJECT_LOCK (ximagesink);
if (ximagesink->xcontext == NULL) {
/* Element stuff */
static GstCaps *
-gst_ximagesink_getcaps (GstBaseSink * bsink, GstCaps * filter)
+gst_x_image_sink_getcaps (GstBaseSink * bsink, GstCaps * filter)
{
GstXImageSink *ximagesink;
GstCaps *caps;
int i;
- ximagesink = GST_XIMAGESINK (bsink);
+ ximagesink = GST_X_IMAGE_SINK (bsink);
g_mutex_lock (&ximagesink->x_lock);
if (ximagesink->xcontext) {
}
static GstBufferPool *
-gst_ximagesink_create_pool (GstXImageSink * ximagesink, GstCaps * caps,
+gst_x_image_sink_create_pool (GstXImageSink * ximagesink, GstCaps * caps,
gsize size, gint min)
{
static GstAllocationParams params = { 0, 15, 0, 0, };
}
static gboolean
-gst_ximagesink_setcaps (GstBaseSink * bsink, GstCaps * caps)
+gst_x_image_sink_setcaps (GstBaseSink * bsink, GstCaps * caps)
{
GstXImageSink *ximagesink;
GstStructure *structure;
GstBufferPool *newpool, *oldpool;
const GValue *par;
- ximagesink = GST_XIMAGESINK (bsink);
+ ximagesink = GST_X_IMAGE_SINK (bsink);
if (!ximagesink->xcontext)
return FALSE;
g_mutex_lock (&ximagesink->flow_lock);
if (!ximagesink->xwindow) {
- ximagesink->xwindow = gst_ximagesink_xwindow_new (ximagesink,
+ ximagesink->xwindow = gst_x_image_sink_xwindow_new (ximagesink,
GST_VIDEO_SINK_WIDTH (ximagesink), GST_VIDEO_SINK_HEIGHT (ximagesink));
}
ximagesink->draw_border = TRUE;
/* create a new internal pool for the new configuration */
- newpool = gst_ximagesink_create_pool (ximagesink, caps, info.size, 2);
+ newpool = gst_x_image_sink_create_pool (ximagesink, caps, info.size, 2);
/* we don't activate the internal pool yet as it may not be needed */
oldpool = ximagesink->pool;
}
static GstStateChangeReturn
-gst_ximagesink_change_state (GstElement * element, GstStateChange transition)
+gst_x_image_sink_change_state (GstElement * element, GstStateChange transition)
{
GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
GstXImageSink *ximagesink;
GstXContext *xcontext = NULL;
- ximagesink = GST_XIMAGESINK (element);
+ ximagesink = GST_X_IMAGE_SINK (element);
switch (transition) {
case GST_STATE_CHANGE_NULL_TO_READY:
/* Initializing the XContext */
if (ximagesink->xcontext == NULL) {
- xcontext = gst_ximagesink_xcontext_get (ximagesink);
+ xcontext = gst_x_image_sink_xcontext_get (ximagesink);
if (xcontext == NULL) {
ret = GST_STATE_CHANGE_FAILURE;
goto beach;
g_mutex_lock (&ximagesink->x_lock);
XSynchronize (ximagesink->xcontext->disp, ximagesink->synchronous);
g_mutex_unlock (&ximagesink->x_lock);
- gst_ximagesink_manage_event_thread (ximagesink);
+ gst_x_image_sink_manage_event_thread (ximagesink);
break;
case GST_STATE_CHANGE_READY_TO_PAUSED:
g_mutex_lock (&ximagesink->flow_lock);
if (ximagesink->xwindow)
- gst_ximagesink_xwindow_clear (ximagesink, ximagesink->xwindow);
+ gst_x_image_sink_xwindow_clear (ximagesink, ximagesink->xwindow);
g_mutex_unlock (&ximagesink->flow_lock);
break;
case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
g_mutex_unlock (&ximagesink->flow_lock);
break;
case GST_STATE_CHANGE_READY_TO_NULL:
- gst_ximagesink_reset (ximagesink);
+ gst_x_image_sink_reset (ximagesink);
break;
default:
break;
}
static void
-gst_ximagesink_get_times (GstBaseSink * bsink, GstBuffer * buf,
+gst_x_image_sink_get_times (GstBaseSink * bsink, GstBuffer * buf,
GstClockTime * start, GstClockTime * end)
{
GstXImageSink *ximagesink;
- ximagesink = GST_XIMAGESINK (bsink);
+ ximagesink = GST_X_IMAGE_SINK (bsink);
if (GST_BUFFER_TIMESTAMP_IS_VALID (buf)) {
*start = GST_BUFFER_TIMESTAMP (buf);
}
static GstFlowReturn
-gst_ximagesink_show_frame (GstVideoSink * vsink, GstBuffer * buf)
+gst_x_image_sink_show_frame (GstVideoSink * vsink, GstBuffer * buf)
{
GstFlowReturn res;
GstXImageSink *ximagesink;
GstXImageMemory *mem;
GstBuffer *to_put = NULL;
- ximagesink = GST_XIMAGESINK (vsink);
+ ximagesink = GST_X_IMAGE_SINK (vsink);
if (gst_buffer_n_memory (buf) == 1
&& (mem = (GstXImageMemory *) gst_buffer_peek_memory (buf, 0))
gst_video_frame_unmap (&src);
}
- if (!gst_ximagesink_ximage_put (ximagesink, to_put))
+ if (!gst_x_image_sink_ximage_put (ximagesink, to_put))
goto no_window;
done:
}
static gboolean
-gst_ximagesink_event (GstBaseSink * sink, GstEvent * event)
+gst_x_image_sink_event (GstBaseSink * sink, GstEvent * event)
{
- GstXImageSink *ximagesink = GST_XIMAGESINK (sink);
+ GstXImageSink *ximagesink = GST_X_IMAGE_SINK (sink);
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_TAG:{
if (title) {
GST_DEBUG_OBJECT (ximagesink, "got tags, title='%s'", title);
- gst_ximagesink_xwindow_set_title (ximagesink, ximagesink->xwindow,
+ gst_x_image_sink_xwindow_set_title (ximagesink, ximagesink->xwindow,
title);
g_free (title);
}
static gboolean
-gst_ximagesink_propose_allocation (GstBaseSink * bsink, GstQuery * query)
+gst_x_image_sink_propose_allocation (GstBaseSink * bsink, GstQuery * query)
{
- GstXImageSink *ximagesink = GST_XIMAGESINK (bsink);
+ GstXImageSink *ximagesink = GST_X_IMAGE_SINK (bsink);
GstBufferPool *pool = NULL;
GstCaps *caps;
guint size;
if (!gst_video_info_from_caps (&info, caps))
goto invalid_caps;
- pool = gst_ximagesink_create_pool (ximagesink, caps, info.size, 0);
+ pool = gst_x_image_sink_create_pool (ximagesink, caps, info.size, 0);
/* the normal size of a frame */
size = info.size;
/* Interfaces stuff */
static void
-gst_ximagesink_navigation_send_event (GstNavigation * navigation,
+gst_x_image_sink_navigation_send_event (GstNavigation * navigation,
GstStructure * structure)
{
- GstXImageSink *ximagesink = GST_XIMAGESINK (navigation);
+ GstXImageSink *ximagesink = GST_X_IMAGE_SINK (navigation);
GstEvent *event;
gint x_offset, y_offset;
gdouble x, y;
}
static void
-gst_ximagesink_navigation_init (GstNavigationInterface * iface)
+gst_x_image_sink_navigation_init (GstNavigationInterface * iface)
{
- iface->send_event = gst_ximagesink_navigation_send_event;
+ iface->send_event = gst_x_image_sink_navigation_send_event;
}
static void
-gst_ximagesink_set_window_handle (GstVideoOverlay * overlay, guintptr id)
+gst_x_image_sink_set_window_handle (GstVideoOverlay * overlay, guintptr id)
{
XID xwindow_id = id;
- GstXImageSink *ximagesink = GST_XIMAGESINK (overlay);
+ GstXImageSink *ximagesink = GST_X_IMAGE_SINK (overlay);
GstXWindow *xwindow = NULL;
XWindowAttributes attr;
/* If the element has not initialized the X11 context try to do so */
if (!ximagesink->xcontext &&
- !(ximagesink->xcontext = gst_ximagesink_xcontext_get (ximagesink))) {
+ !(ximagesink->xcontext = gst_x_image_sink_xcontext_get (ximagesink))) {
g_mutex_unlock (&ximagesink->flow_lock);
/* we have thrown a GST_ELEMENT_ERROR now */
return;
/* If a window is there already we destroy it */
if (ximagesink->xwindow) {
- gst_ximagesink_xwindow_destroy (ximagesink, ximagesink->xwindow);
+ gst_x_image_sink_xwindow_destroy (ximagesink, ximagesink->xwindow);
ximagesink->xwindow = NULL;
}
/* If no width/height caps nego did not happen window will be created
during caps nego then */
if (GST_VIDEO_SINK_WIDTH (ximagesink) && GST_VIDEO_SINK_HEIGHT (ximagesink)) {
- xwindow = gst_ximagesink_xwindow_new (ximagesink,
+ xwindow = gst_x_image_sink_xwindow_new (ximagesink,
GST_VIDEO_SINK_WIDTH (ximagesink),
GST_VIDEO_SINK_HEIGHT (ximagesink));
}
}
static void
-gst_ximagesink_expose (GstVideoOverlay * overlay)
+gst_x_image_sink_expose (GstVideoOverlay * overlay)
{
- GstXImageSink *ximagesink = GST_XIMAGESINK (overlay);
+ GstXImageSink *ximagesink = GST_X_IMAGE_SINK (overlay);
- gst_ximagesink_xwindow_update_geometry (ximagesink);
- gst_ximagesink_ximage_put (ximagesink, NULL);
+ gst_x_image_sink_xwindow_update_geometry (ximagesink);
+ gst_x_image_sink_ximage_put (ximagesink, NULL);
}
static void
-gst_ximagesink_set_event_handling (GstVideoOverlay * overlay,
+gst_x_image_sink_set_event_handling (GstVideoOverlay * overlay,
gboolean handle_events)
{
- GstXImageSink *ximagesink = GST_XIMAGESINK (overlay);
+ GstXImageSink *ximagesink = GST_X_IMAGE_SINK (overlay);
ximagesink->handle_events = handle_events;
}
static void
-gst_ximagesink_video_overlay_init (GstVideoOverlayInterface * iface)
+gst_x_image_sink_video_overlay_init (GstVideoOverlayInterface * iface)
{
- iface->set_window_handle = gst_ximagesink_set_window_handle;
- iface->expose = gst_ximagesink_expose;
- iface->handle_events = gst_ximagesink_set_event_handling;
+ iface->set_window_handle = gst_x_image_sink_set_window_handle;
+ iface->expose = gst_x_image_sink_expose;
+ iface->handle_events = gst_x_image_sink_set_event_handling;
}
/* =========================================== */
/* =========================================== */
static void
-gst_ximagesink_set_property (GObject * object, guint prop_id,
+gst_x_image_sink_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstXImageSink *ximagesink;
- g_return_if_fail (GST_IS_XIMAGESINK (object));
+ g_return_if_fail (GST_IS_X_IMAGE_SINK (object));
- ximagesink = GST_XIMAGESINK (object);
+ ximagesink = GST_X_IMAGE_SINK (object);
switch (prop_id) {
case PROP_DISPLAY:
}
break;
case PROP_HANDLE_EVENTS:
- gst_ximagesink_set_event_handling (GST_VIDEO_OVERLAY (ximagesink),
+ gst_x_image_sink_set_event_handling (GST_VIDEO_OVERLAY (ximagesink),
g_value_get_boolean (value));
- gst_ximagesink_manage_event_thread (ximagesink);
+ gst_x_image_sink_manage_event_thread (ximagesink);
break;
case PROP_HANDLE_EXPOSE:
ximagesink->handle_expose = g_value_get_boolean (value);
- gst_ximagesink_manage_event_thread (ximagesink);
+ gst_x_image_sink_manage_event_thread (ximagesink);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
static void
-gst_ximagesink_get_property (GObject * object, guint prop_id,
+gst_x_image_sink_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstXImageSink *ximagesink;
- g_return_if_fail (GST_IS_XIMAGESINK (object));
+ g_return_if_fail (GST_IS_X_IMAGE_SINK (object));
- ximagesink = GST_XIMAGESINK (object);
+ ximagesink = GST_X_IMAGE_SINK (object);
switch (prop_id) {
case PROP_DISPLAY:
}
static void
-gst_ximagesink_reset (GstXImageSink * ximagesink)
+gst_x_image_sink_reset (GstXImageSink * ximagesink)
{
GThread *thread;
}
if (ximagesink->xwindow) {
- gst_ximagesink_xwindow_clear (ximagesink, ximagesink->xwindow);
- gst_ximagesink_xwindow_destroy (ximagesink, ximagesink->xwindow);
+ gst_x_image_sink_xwindow_clear (ximagesink, ximagesink->xwindow);
+ gst_x_image_sink_xwindow_destroy (ximagesink, ximagesink->xwindow);
ximagesink->xwindow = NULL;
}
g_mutex_unlock (&ximagesink->flow_lock);
- gst_ximagesink_xcontext_clear (ximagesink);
+ gst_x_image_sink_xcontext_clear (ximagesink);
}
static void
-gst_ximagesink_finalize (GObject * object)
+gst_x_image_sink_finalize (GObject * object)
{
GstXImageSink *ximagesink;
- ximagesink = GST_XIMAGESINK (object);
+ ximagesink = GST_X_IMAGE_SINK (object);
- gst_ximagesink_reset (ximagesink);
+ gst_x_image_sink_reset (ximagesink);
if (ximagesink->display_name) {
g_free (ximagesink->display_name);
}
static void
-gst_ximagesink_init (GstXImageSink * ximagesink)
+gst_x_image_sink_init (GstXImageSink * ximagesink)
{
ximagesink->display_name = NULL;
ximagesink->xcontext = NULL;
}
static void
-gst_ximagesink_class_init (GstXImageSinkClass * klass)
+gst_x_image_sink_class_init (GstXImageSinkClass * klass)
{
GObjectClass *gobject_class;
GstElementClass *gstelement_class;
gstbasesink_class = (GstBaseSinkClass *) klass;
videosink_class = (GstVideoSinkClass *) klass;
- gobject_class->finalize = gst_ximagesink_finalize;
- gobject_class->set_property = gst_ximagesink_set_property;
- gobject_class->get_property = gst_ximagesink_get_property;
+ gobject_class->finalize = gst_x_image_sink_finalize;
+ gobject_class->set_property = gst_x_image_sink_set_property;
+ gobject_class->get_property = gst_x_image_sink_get_property;
g_object_class_install_property (gobject_class, PROP_DISPLAY,
g_param_spec_string ("display", "Display", "X Display name",
"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));
+ gst_static_pad_template_get (&gst_x_image_sink_sink_template_factory));
- gstelement_class->change_state = gst_ximagesink_change_state;
+ gstelement_class->change_state = gst_x_image_sink_change_state;
- gstbasesink_class->get_caps = GST_DEBUG_FUNCPTR (gst_ximagesink_getcaps);
- gstbasesink_class->set_caps = GST_DEBUG_FUNCPTR (gst_ximagesink_setcaps);
- gstbasesink_class->get_times = GST_DEBUG_FUNCPTR (gst_ximagesink_get_times);
+ gstbasesink_class->get_caps = GST_DEBUG_FUNCPTR (gst_x_image_sink_getcaps);
+ gstbasesink_class->set_caps = GST_DEBUG_FUNCPTR (gst_x_image_sink_setcaps);
+ gstbasesink_class->get_times = GST_DEBUG_FUNCPTR (gst_x_image_sink_get_times);
gstbasesink_class->propose_allocation =
- GST_DEBUG_FUNCPTR (gst_ximagesink_propose_allocation);
- gstbasesink_class->event = GST_DEBUG_FUNCPTR (gst_ximagesink_event);
+ GST_DEBUG_FUNCPTR (gst_x_image_sink_propose_allocation);
+ gstbasesink_class->event = GST_DEBUG_FUNCPTR (gst_x_image_sink_event);
- videosink_class->show_frame = GST_DEBUG_FUNCPTR (gst_ximagesink_show_frame);
+ videosink_class->show_frame = GST_DEBUG_FUNCPTR (gst_x_image_sink_show_frame);
}
* Boston, MA 02110-1301, USA.
*/
-#ifndef __GST_XIMAGESINK_H__
-#define __GST_XIMAGESINK_H__
+#ifndef __GST_X_IMAGE_SINK_H__
+#define __GST_X_IMAGE_SINK_H__
#include <gst/video/gstvideosink.h>
#include <gst/video/video.h>
G_BEGIN_DECLS
-#define GST_TYPE_XIMAGESINK \
- (gst_ximagesink_get_type())
-#define GST_XIMAGESINK(obj) \
- (G_TYPE_CHECK_INSTANCE_CAST((obj), GST_TYPE_XIMAGESINK, GstXImageSink))
-#define GST_XIMAGESINK_CLASS(klass) \
- (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_XIMAGESINK, GstXImageSinkClass))
-#define GST_IS_XIMAGESINK(obj) \
- (G_TYPE_CHECK_INSTANCE_TYPE((obj), GST_TYPE_XIMAGESINK))
-#define GST_IS_XIMAGESINK_CLASS(klass) \
- (G_TYPE_CHECK_CLASS_TYPE((klass), GST_TYPE_XIMAGESINK))
+#define GST_TYPE_X_IMAGE_SINK \
+ (gst_x_image_sink_get_type())
+#define GST_X_IMAGE_SINK(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST((obj), GST_TYPE_X_IMAGE_SINK, GstXImageSink))
+#define GST_X_IMAGE_SINK_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_X_IMAGE_SINK, GstXImageSinkClass))
+#define GST_IS_X_IMAGE_SINK(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE((obj), GST_TYPE_X_IMAGE_SINK))
+#define GST_IS_X_IMAGE_SINK_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_TYPE((klass), GST_TYPE_X_IMAGE_SINK))
typedef struct _GstXContext GstXContext;
typedef struct _GstXWindow GstXWindow;
GstVideoSinkClass parent_class;
};
-GType gst_ximagesink_get_type (void);
+GType gst_x_image_sink_get_type (void);
G_END_DECLS
-#endif /* __GST_XIMAGESINK_H__ */
+#endif /* __GST_X_IMAGE_SINK_H__ */
/* for XkbKeycodeToKeysym */
#include <X11/XKBlib.h>
-GST_DEBUG_CATEGORY_EXTERN (gst_debug_xvcontext);
+GST_DEBUG_CATEGORY_EXTERN (gst_debug_xv_context);
GST_DEBUG_CATEGORY_EXTERN (GST_CAT_PERFORMANCE);
-#define GST_CAT_DEFAULT gst_debug_xvcontext
+#define GST_CAT_DEFAULT gst_debug_xv_context
void
gst_xvcontext_config_clear (GstXvContextConfig * config)
#include "xvimagesink.h"
-GST_DEBUG_CATEGORY (gst_debug_xvcontext);
-GST_DEBUG_CATEGORY (gst_debug_xvimagepool);
-GST_DEBUG_CATEGORY (gst_debug_xvimagesink);
+GST_DEBUG_CATEGORY (gst_debug_xv_context);
+GST_DEBUG_CATEGORY (gst_debug_xv_image_pool);
+GST_DEBUG_CATEGORY (gst_debug_xv_image_sink);
GST_DEBUG_CATEGORY_STATIC (GST_CAT_PERFORMANCE);
static gboolean
plugin_init (GstPlugin * plugin)
{
if (!gst_element_register (plugin, "xvimagesink",
- GST_RANK_PRIMARY, GST_TYPE_XVIMAGESINK))
+ GST_RANK_PRIMARY, GST_TYPE_XV_IMAGE_SINK))
return FALSE;
- GST_DEBUG_CATEGORY_INIT (gst_debug_xvcontext, "xcontext", 0,
+ GST_DEBUG_CATEGORY_INIT (gst_debug_xv_context, "xcontext", 0,
"xcontext miniobject");
- GST_DEBUG_CATEGORY_INIT (gst_debug_xvimagesink, "xvimagesink", 0,
+ GST_DEBUG_CATEGORY_INIT (gst_debug_xv_image_sink, "xvimagesink", 0,
"xvimagesink element");
- GST_DEBUG_CATEGORY_INIT (gst_debug_xvimagepool, "xvimagepool", 0,
+ GST_DEBUG_CATEGORY_INIT (gst_debug_xv_image_pool, "xvimagepool", 0,
"xvimagepool object");
GST_DEBUG_CATEGORY_GET (GST_CAT_PERFORMANCE, "GST_PERFORMANCE");
#include <gst/video/gstvideopool.h>
-GST_DEBUG_CATEGORY_EXTERN (gst_debug_xvimagepool);
-#define GST_CAT_DEFAULT gst_debug_xvimagepool
+GST_DEBUG_CATEGORY_EXTERN (gst_debug_xv_image_pool);
+#define GST_CAT_DEFAULT gst_debug_xv_image_pool
/* bufferpool */
static void gst_xvimage_buffer_pool_finalize (GObject * object);
/* for XkbKeycodeToKeysym */
#include <X11/XKBlib.h>
-GST_DEBUG_CATEGORY_EXTERN (gst_debug_xvimagesink);
+GST_DEBUG_CATEGORY_EXTERN (gst_debug_xv_image_sink);
GST_DEBUG_CATEGORY_EXTERN (GST_CAT_PERFORMANCE);
-#define GST_CAT_DEFAULT gst_debug_xvimagesink
+#define GST_CAT_DEFAULT gst_debug_xv_image_sink
typedef struct
{
#define MWM_HINTS_DECORATIONS (1L << 1)
-static gboolean gst_xvimagesink_open (GstXvImageSink * xvimagesink);
-static void gst_xvimagesink_close (GstXvImageSink * xvimagesink);
-static void gst_xvimagesink_xwindow_update_geometry (GstXvImageSink *
+static gboolean gst_xv_image_sink_open (GstXvImageSink * xvimagesink);
+static void gst_xv_image_sink_close (GstXvImageSink * xvimagesink);
+static void gst_xv_image_sink_xwindow_update_geometry (GstXvImageSink *
xvimagesink);
-static void gst_xvimagesink_expose (GstVideoOverlay * overlay);
+static void gst_xv_image_sink_expose (GstVideoOverlay * overlay);
/* Default template - initiated with class struct to allow gst-register to work
without X running */
-static GstStaticPadTemplate gst_xvimagesink_sink_template_factory =
+static GstStaticPadTemplate gst_xv_image_sink_sink_template_factory =
GST_STATIC_PAD_TEMPLATE ("sink",
GST_PAD_SINK,
GST_PAD_ALWAYS,
/* Object typing & Creation */
/* */
/* =========================================== */
-static void gst_xvimagesink_navigation_init (GstNavigationInterface * iface);
-static void gst_xvimagesink_video_overlay_init (GstVideoOverlayInterface *
+static void gst_xv_image_sink_navigation_init (GstNavigationInterface * iface);
+static void gst_xv_image_sink_video_overlay_init (GstVideoOverlayInterface *
iface);
-static void gst_xvimagesink_colorbalance_init (GstColorBalanceInterface *
+static void gst_xv_image_sink_colorbalance_init (GstColorBalanceInterface *
iface);
-#define gst_xvimagesink_parent_class parent_class
-G_DEFINE_TYPE_WITH_CODE (GstXvImageSink, gst_xvimagesink, GST_TYPE_VIDEO_SINK,
+#define gst_xv_image_sink_parent_class parent_class
+G_DEFINE_TYPE_WITH_CODE (GstXvImageSink, gst_xv_image_sink, GST_TYPE_VIDEO_SINK,
G_IMPLEMENT_INTERFACE (GST_TYPE_NAVIGATION,
- gst_xvimagesink_navigation_init);
+ gst_xv_image_sink_navigation_init);
G_IMPLEMENT_INTERFACE (GST_TYPE_VIDEO_OVERLAY,
- gst_xvimagesink_video_overlay_init);
+ gst_xv_image_sink_video_overlay_init);
G_IMPLEMENT_INTERFACE (GST_TYPE_COLOR_BALANCE,
- gst_xvimagesink_colorbalance_init));
+ gst_xv_image_sink_colorbalance_init));
/* ============================================================= */
/* This function puts a GstXvImage on a GstXvImageSink's window. Returns FALSE
* if no window was available */
static gboolean
-gst_xvimagesink_xvimage_put (GstXvImageSink * xvimagesink, GstBuffer * xvimage)
+gst_xv_image_sink_xvimage_put (GstXvImageSink * xvimagesink,
+ GstBuffer * xvimage)
{
GstXvImageMemory *mem;
GstVideoCropMeta *crop;
}
static void
-gst_xvimagesink_xwindow_set_title (GstXvImageSink * xvimagesink,
+gst_xv_image_sink_xwindow_set_title (GstXvImageSink * xvimagesink,
GstXWindow * xwindow, const gchar * media_title)
{
if (media_title) {
/* This function handles a GstXWindow creation
* The width and height are the actual pixel size on the display */
static GstXWindow *
-gst_xvimagesink_xwindow_new (GstXvImageSink * xvimagesink,
+gst_xv_image_sink_xwindow_new (GstXvImageSink * xvimagesink,
gint width, gint height)
{
GstXWindow *xwindow = NULL;
GstXvContext *context;
- g_return_val_if_fail (GST_IS_XVIMAGESINK (xvimagesink), NULL);
+ g_return_val_if_fail (GST_IS_XV_IMAGE_SINK (xvimagesink), NULL);
context = xvimagesink->context;
xwindow = gst_xvcontext_create_xwindow (context, width, height);
/* set application name as a title */
- gst_xvimagesink_xwindow_set_title (xvimagesink, xwindow, NULL);
+ gst_xv_image_sink_xwindow_set_title (xvimagesink, xwindow, NULL);
gst_xwindow_set_event_handling (xwindow, xvimagesink->handle_events);
}
static void
-gst_xvimagesink_xwindow_update_geometry (GstXvImageSink * xvimagesink)
+gst_xv_image_sink_xwindow_update_geometry (GstXvImageSink * xvimagesink)
{
- g_return_if_fail (GST_IS_XVIMAGESINK (xvimagesink));
+ g_return_if_fail (GST_IS_XV_IMAGE_SINK (xvimagesink));
/* Update the window geometry */
g_mutex_lock (&xvimagesink->flow_lock);
/* This function commits our internal colorbalance settings to our grabbed Xv
port. If the context is not initialized yet it simply returns */
static void
-gst_xvimagesink_update_colorbalance (GstXvImageSink * xvimagesink)
+gst_xv_image_sink_update_colorbalance (GstXvImageSink * xvimagesink)
{
GstXvContext *context;
- g_return_if_fail (GST_IS_XVIMAGESINK (xvimagesink));
+ g_return_if_fail (GST_IS_XV_IMAGE_SINK (xvimagesink));
/* If we haven't initialized the X context we can't update anything */
if ((context = xvimagesink->context) == NULL)
and navigation. It will also listen for configure events on the window to
trigger caps renegotiation so on the fly software scaling can work. */
static void
-gst_xvimagesink_handle_xevents (GstXvImageSink * xvimagesink)
+gst_xv_image_sink_handle_xevents (GstXvImageSink * xvimagesink)
{
XEvent e;
guint pointer_x = 0, pointer_y = 0;
gboolean pointer_moved = FALSE;
gboolean exposed = FALSE, configured = FALSE;
- g_return_if_fail (GST_IS_XVIMAGESINK (xvimagesink));
+ g_return_if_fail (GST_IS_XV_IMAGE_SINK (xvimagesink));
/* Handle Interaction, produces navigation events */
g_mutex_unlock (&xvimagesink->context->lock);
g_mutex_unlock (&xvimagesink->flow_lock);
- gst_xvimagesink_xwindow_update_geometry (xvimagesink);
+ gst_xv_image_sink_xwindow_update_geometry (xvimagesink);
g_mutex_lock (&xvimagesink->flow_lock);
g_mutex_lock (&xvimagesink->context->lock);
g_mutex_unlock (&xvimagesink->context->lock);
g_mutex_unlock (&xvimagesink->flow_lock);
- gst_xvimagesink_expose (GST_VIDEO_OVERLAY (xvimagesink));
+ gst_xv_image_sink_expose (GST_VIDEO_OVERLAY (xvimagesink));
g_mutex_lock (&xvimagesink->flow_lock);
g_mutex_lock (&xvimagesink->context->lock);
}
static gpointer
-gst_xvimagesink_event_thread (GstXvImageSink * xvimagesink)
+gst_xv_image_sink_event_thread (GstXvImageSink * xvimagesink)
{
- g_return_val_if_fail (GST_IS_XVIMAGESINK (xvimagesink), NULL);
+ g_return_val_if_fail (GST_IS_XV_IMAGE_SINK (xvimagesink), NULL);
GST_OBJECT_LOCK (xvimagesink);
while (xvimagesink->running) {
GST_OBJECT_UNLOCK (xvimagesink);
if (xvimagesink->xwindow) {
- gst_xvimagesink_handle_xevents (xvimagesink);
+ gst_xv_image_sink_handle_xevents (xvimagesink);
}
/* FIXME: do we want to align this with the framerate or anything else? */
g_usleep (G_USEC_PER_SEC / 20);
}
static void
-gst_xvimagesink_manage_event_thread (GstXvImageSink * xvimagesink)
+gst_xv_image_sink_manage_event_thread (GstXvImageSink * xvimagesink)
{
GThread *thread = NULL;
xvimagesink->handle_expose, xvimagesink->handle_events);
xvimagesink->running = TRUE;
xvimagesink->event_thread = g_thread_try_new ("xvimagesink-events",
- (GThreadFunc) gst_xvimagesink_event_thread, xvimagesink, NULL);
+ (GThreadFunc) gst_xv_image_sink_event_thread, xvimagesink, NULL);
}
} else {
if (xvimagesink->event_thread) {
/* Element stuff */
static GstCaps *
-gst_xvimagesink_getcaps (GstBaseSink * bsink, GstCaps * filter)
+gst_xv_image_sink_getcaps (GstBaseSink * bsink, GstCaps * filter)
{
GstXvImageSink *xvimagesink;
GstCaps *caps;
- xvimagesink = GST_XVIMAGESINK (bsink);
+ xvimagesink = GST_XV_IMAGE_SINK (bsink);
if (xvimagesink->context) {
if (filter)
}
static GstBufferPool *
-gst_xvimagesink_create_pool (GstXvImageSink * xvimagesink, GstCaps * caps,
+gst_xv_image_sink_create_pool (GstXvImageSink * xvimagesink, GstCaps * caps,
gsize size, gint min)
{
GstBufferPool *pool;
}
static gboolean
-gst_xvimagesink_setcaps (GstBaseSink * bsink, GstCaps * caps)
+gst_xv_image_sink_setcaps (GstBaseSink * bsink, GstCaps * caps)
{
GstXvImageSink *xvimagesink;
GstXvContext *context;
gint display_par_n, display_par_d; /* display's PAR */
guint num, den;
- xvimagesink = GST_XVIMAGESINK (bsink);
+ xvimagesink = GST_XV_IMAGE_SINK (bsink);
context = xvimagesink->context;
GST_DEBUG_OBJECT (xvimagesink,
g_mutex_lock (&xvimagesink->flow_lock);
if (!xvimagesink->xwindow) {
- xvimagesink->xwindow = gst_xvimagesink_xwindow_new (xvimagesink,
+ xvimagesink->xwindow = gst_xv_image_sink_xwindow_new (xvimagesink,
GST_VIDEO_SINK_WIDTH (xvimagesink),
GST_VIDEO_SINK_HEIGHT (xvimagesink));
}
xvimagesink->redraw_border = TRUE;
/* create a new pool for the new configuration */
- newpool = gst_xvimagesink_create_pool (xvimagesink, caps, info.size, 2);
+ newpool = gst_xv_image_sink_create_pool (xvimagesink, caps, info.size, 2);
/* we don't activate the internal pool yet as it may not be needed */
oldpool = xvimagesink->pool;
}
static GstStateChangeReturn
-gst_xvimagesink_change_state (GstElement * element, GstStateChange transition)
+gst_xv_image_sink_change_state (GstElement * element, GstStateChange transition)
{
GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
GstXvImageSink *xvimagesink;
- xvimagesink = GST_XVIMAGESINK (element);
+ xvimagesink = GST_XV_IMAGE_SINK (element);
switch (transition) {
case GST_STATE_CHANGE_NULL_TO_READY:
- if (!gst_xvimagesink_open (xvimagesink))
+ if (!gst_xv_image_sink_open (xvimagesink))
goto error;
break;
case GST_STATE_CHANGE_READY_TO_PAUSED:
g_mutex_unlock (&xvimagesink->flow_lock);
break;
case GST_STATE_CHANGE_READY_TO_NULL:
- gst_xvimagesink_close (xvimagesink);
+ gst_xv_image_sink_close (xvimagesink);
break;
default:
break;
}
static void
-gst_xvimagesink_get_times (GstBaseSink * bsink, GstBuffer * buf,
+gst_xv_image_sink_get_times (GstBaseSink * bsink, GstBuffer * buf,
GstClockTime * start, GstClockTime * end)
{
GstXvImageSink *xvimagesink;
- xvimagesink = GST_XVIMAGESINK (bsink);
+ xvimagesink = GST_XV_IMAGE_SINK (bsink);
if (GST_BUFFER_TIMESTAMP_IS_VALID (buf)) {
*start = GST_BUFFER_TIMESTAMP (buf);
}
static GstFlowReturn
-gst_xvimagesink_show_frame (GstVideoSink * vsink, GstBuffer * buf)
+gst_xv_image_sink_show_frame (GstVideoSink * vsink, GstBuffer * buf)
{
GstFlowReturn res;
GstXvImageSink *xvimagesink;
GstBuffer *to_put = NULL;
GstMemory *mem;
- xvimagesink = GST_XVIMAGESINK (vsink);
+ xvimagesink = GST_XV_IMAGE_SINK (vsink);
if (gst_buffer_n_memory (buf) == 1 && (mem = gst_buffer_peek_memory (buf, 0))
&& gst_xvimage_memory_is_from_context (mem, xvimagesink->context)) {
gst_video_frame_unmap (&src);
}
- if (!gst_xvimagesink_xvimage_put (xvimagesink, to_put))
+ if (!gst_xv_image_sink_xvimage_put (xvimagesink, to_put))
goto no_window;
done:
}
static gboolean
-gst_xvimagesink_event (GstBaseSink * sink, GstEvent * event)
+gst_xv_image_sink_event (GstBaseSink * sink, GstEvent * event)
{
- GstXvImageSink *xvimagesink = GST_XVIMAGESINK (sink);
+ GstXvImageSink *xvimagesink = GST_XV_IMAGE_SINK (sink);
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_TAG:{
if (title) {
GST_DEBUG_OBJECT (xvimagesink, "got tags, title='%s'", title);
- gst_xvimagesink_xwindow_set_title (xvimagesink, xvimagesink->xwindow,
+ gst_xv_image_sink_xwindow_set_title (xvimagesink, xvimagesink->xwindow,
title);
g_free (title);
}
static gboolean
-gst_xvimagesink_propose_allocation (GstBaseSink * bsink, GstQuery * query)
+gst_xv_image_sink_propose_allocation (GstBaseSink * bsink, GstQuery * query)
{
- GstXvImageSink *xvimagesink = GST_XVIMAGESINK (bsink);
+ GstXvImageSink *xvimagesink = GST_XV_IMAGE_SINK (bsink);
GstBufferPool *pool = NULL;
GstCaps *caps;
guint size;
goto invalid_caps;
GST_DEBUG_OBJECT (xvimagesink, "create new pool");
- pool = gst_xvimagesink_create_pool (xvimagesink, caps, info.size, 0);
+ pool = gst_xv_image_sink_create_pool (xvimagesink, caps, info.size, 0);
/* the normal size of a frame */
size = info.size;
/* Interfaces stuff */
static void
-gst_xvimagesink_navigation_send_event (GstNavigation * navigation,
+gst_xv_image_sink_navigation_send_event (GstNavigation * navigation,
GstStructure * structure)
{
- GstXvImageSink *xvimagesink = GST_XVIMAGESINK (navigation);
+ GstXvImageSink *xvimagesink = GST_XV_IMAGE_SINK (navigation);
GstPad *peer;
gboolean handled = FALSE;
GstEvent *event = NULL;
}
static void
-gst_xvimagesink_navigation_init (GstNavigationInterface * iface)
+gst_xv_image_sink_navigation_init (GstNavigationInterface * iface)
{
- iface->send_event = gst_xvimagesink_navigation_send_event;
+ iface->send_event = gst_xv_image_sink_navigation_send_event;
}
static void
-gst_xvimagesink_set_window_handle (GstVideoOverlay * overlay, guintptr id)
+gst_xv_image_sink_set_window_handle (GstVideoOverlay * overlay, guintptr id)
{
XID xwindow_id = id;
- GstXvImageSink *xvimagesink = GST_XVIMAGESINK (overlay);
+ GstXvImageSink *xvimagesink = GST_XV_IMAGE_SINK (overlay);
GstXWindow *xwindow = NULL;
GstXvContext *context;
- g_return_if_fail (GST_IS_XVIMAGESINK (xvimagesink));
+ g_return_if_fail (GST_IS_XV_IMAGE_SINK (xvimagesink));
g_mutex_lock (&xvimagesink->flow_lock);
context = xvimagesink->context;
- gst_xvimagesink_update_colorbalance (xvimagesink);
+ gst_xv_image_sink_update_colorbalance (xvimagesink);
/* If a window is there already we destroy it */
if (xvimagesink->xwindow) {
if (GST_VIDEO_SINK_WIDTH (xvimagesink)
&& GST_VIDEO_SINK_HEIGHT (xvimagesink)) {
xwindow =
- gst_xvimagesink_xwindow_new (xvimagesink,
+ gst_xv_image_sink_xwindow_new (xvimagesink,
GST_VIDEO_SINK_WIDTH (xvimagesink),
GST_VIDEO_SINK_HEIGHT (xvimagesink));
}
}
static void
-gst_xvimagesink_expose (GstVideoOverlay * overlay)
+gst_xv_image_sink_expose (GstVideoOverlay * overlay)
{
- GstXvImageSink *xvimagesink = GST_XVIMAGESINK (overlay);
+ GstXvImageSink *xvimagesink = GST_XV_IMAGE_SINK (overlay);
GST_DEBUG ("doing expose");
- gst_xvimagesink_xwindow_update_geometry (xvimagesink);
- gst_xvimagesink_xvimage_put (xvimagesink, NULL);
+ gst_xv_image_sink_xwindow_update_geometry (xvimagesink);
+ gst_xv_image_sink_xvimage_put (xvimagesink, NULL);
}
static void
-gst_xvimagesink_set_event_handling (GstVideoOverlay * overlay,
+gst_xv_image_sink_set_event_handling (GstVideoOverlay * overlay,
gboolean handle_events)
{
- GstXvImageSink *xvimagesink = GST_XVIMAGESINK (overlay);
+ GstXvImageSink *xvimagesink = GST_XV_IMAGE_SINK (overlay);
g_mutex_lock (&xvimagesink->flow_lock);
xvimagesink->handle_events = handle_events;
}
static void
-gst_xvimagesink_set_render_rectangle (GstVideoOverlay * overlay, gint x, gint y,
- gint width, gint height)
+gst_xv_image_sink_set_render_rectangle (GstVideoOverlay * overlay, gint x,
+ gint y, gint width, gint height)
{
- GstXvImageSink *xvimagesink = GST_XVIMAGESINK (overlay);
+ GstXvImageSink *xvimagesink = GST_XV_IMAGE_SINK (overlay);
g_mutex_lock (&xvimagesink->flow_lock);
if (G_LIKELY (xvimagesink->xwindow))
}
static void
-gst_xvimagesink_video_overlay_init (GstVideoOverlayInterface * iface)
+gst_xv_image_sink_video_overlay_init (GstVideoOverlayInterface * iface)
{
- iface->set_window_handle = gst_xvimagesink_set_window_handle;
- iface->expose = gst_xvimagesink_expose;
- iface->handle_events = gst_xvimagesink_set_event_handling;
- iface->set_render_rectangle = gst_xvimagesink_set_render_rectangle;
+ iface->set_window_handle = gst_xv_image_sink_set_window_handle;
+ iface->expose = gst_xv_image_sink_expose;
+ iface->handle_events = gst_xv_image_sink_set_event_handling;
+ iface->set_render_rectangle = gst_xv_image_sink_set_render_rectangle;
}
static const GList *
-gst_xvimagesink_colorbalance_list_channels (GstColorBalance * balance)
+gst_xv_image_sink_colorbalance_list_channels (GstColorBalance * balance)
{
- GstXvImageSink *xvimagesink = GST_XVIMAGESINK (balance);
+ GstXvImageSink *xvimagesink = GST_XV_IMAGE_SINK (balance);
- g_return_val_if_fail (GST_IS_XVIMAGESINK (xvimagesink), NULL);
+ g_return_val_if_fail (GST_IS_XV_IMAGE_SINK (xvimagesink), NULL);
if (xvimagesink->context)
return xvimagesink->context->channels_list;
}
static void
-gst_xvimagesink_colorbalance_set_value (GstColorBalance * balance,
+gst_xv_image_sink_colorbalance_set_value (GstColorBalance * balance,
GstColorBalanceChannel * channel, gint value)
{
- GstXvImageSink *xvimagesink = GST_XVIMAGESINK (balance);
+ GstXvImageSink *xvimagesink = GST_XV_IMAGE_SINK (balance);
- g_return_if_fail (GST_IS_XVIMAGESINK (xvimagesink));
+ g_return_if_fail (GST_IS_XV_IMAGE_SINK (xvimagesink));
g_return_if_fail (channel->label != NULL);
xvimagesink->config.cb_changed = TRUE;
return;
}
- gst_xvimagesink_update_colorbalance (xvimagesink);
+ gst_xv_image_sink_update_colorbalance (xvimagesink);
}
static gint
-gst_xvimagesink_colorbalance_get_value (GstColorBalance * balance,
+gst_xv_image_sink_colorbalance_get_value (GstColorBalance * balance,
GstColorBalanceChannel * channel)
{
- GstXvImageSink *xvimagesink = GST_XVIMAGESINK (balance);
+ GstXvImageSink *xvimagesink = GST_XV_IMAGE_SINK (balance);
gint value = 0;
- g_return_val_if_fail (GST_IS_XVIMAGESINK (xvimagesink), 0);
+ g_return_val_if_fail (GST_IS_XV_IMAGE_SINK (xvimagesink), 0);
g_return_val_if_fail (channel->label != NULL, 0);
if (g_ascii_strcasecmp (channel->label, "XV_HUE") == 0) {
}
static GstColorBalanceType
-gst_xvimagesink_colorbalance_get_balance_type (GstColorBalance * balance)
+gst_xv_image_sink_colorbalance_get_balance_type (GstColorBalance * balance)
{
return GST_COLOR_BALANCE_HARDWARE;
}
static void
-gst_xvimagesink_colorbalance_init (GstColorBalanceInterface * iface)
+gst_xv_image_sink_colorbalance_init (GstColorBalanceInterface * iface)
{
- iface->list_channels = gst_xvimagesink_colorbalance_list_channels;
- iface->set_value = gst_xvimagesink_colorbalance_set_value;
- iface->get_value = gst_xvimagesink_colorbalance_get_value;
- iface->get_balance_type = gst_xvimagesink_colorbalance_get_balance_type;
+ iface->list_channels = gst_xv_image_sink_colorbalance_list_channels;
+ iface->set_value = gst_xv_image_sink_colorbalance_set_value;
+ iface->get_value = gst_xv_image_sink_colorbalance_get_value;
+ iface->get_balance_type = gst_xv_image_sink_colorbalance_get_balance_type;
}
#if 0
static const GList *
-gst_xvimagesink_probe_get_properties (GstPropertyProbe * probe)
+gst_xv_image_sink_probe_get_properties (GstPropertyProbe * probe)
{
GObjectClass *klass = G_OBJECT_GET_CLASS (probe);
static GList *list = NULL;
}
static void
-gst_xvimagesink_probe_probe_property (GstPropertyProbe * probe,
+gst_xv_image_sink_probe_probe_property (GstPropertyProbe * probe,
guint prop_id, const GParamSpec * pspec)
{
- GstXvImageSink *xvimagesink = GST_XVIMAGESINK (probe);
+ GstXvImageSink *xvimagesink = GST_XV_IMAGE_SINK (probe);
switch (prop_id) {
case PROP_DEVICE:
"probing device list and get capabilities");
if (!xvimagesink->context) {
GST_DEBUG_OBJECT (xvimagesink, "generating context");
- xvimagesink->context = gst_xvimagesink_context_get (xvimagesink);
+ xvimagesink->context = gst_xv_image_sink_context_get (xvimagesink);
}
break;
default:
}
static gboolean
-gst_xvimagesink_probe_needs_probe (GstPropertyProbe * probe,
+gst_xv_image_sink_probe_needs_probe (GstPropertyProbe * probe,
guint prop_id, const GParamSpec * pspec)
{
- GstXvImageSink *xvimagesink = GST_XVIMAGESINK (probe);
+ GstXvImageSink *xvimagesink = GST_XV_IMAGE_SINK (probe);
gboolean ret = FALSE;
switch (prop_id) {
}
static GValueArray *
-gst_xvimagesink_probe_get_values (GstPropertyProbe * probe,
+gst_xv_image_sink_probe_get_values (GstPropertyProbe * probe,
guint prop_id, const GParamSpec * pspec)
{
- GstXvImageSink *xvimagesink = GST_XVIMAGESINK (probe);
+ GstXvImageSink *xvimagesink = GST_XV_IMAGE_SINK (probe);
GValueArray *array = NULL;
if (G_UNLIKELY (!xvimagesink->context)) {
}
static void
-gst_xvimagesink_property_probe_interface_init (GstPropertyProbeInterface *
+gst_xv_image_sink_property_probe_interface_init (GstPropertyProbeInterface *
iface)
{
- iface->get_properties = gst_xvimagesink_probe_get_properties;
- iface->probe_property = gst_xvimagesink_probe_probe_property;
- iface->needs_probe = gst_xvimagesink_probe_needs_probe;
- iface->get_values = gst_xvimagesink_probe_get_values;
+ iface->get_properties = gst_xv_image_sink_probe_get_properties;
+ iface->probe_property = gst_xv_image_sink_probe_probe_property;
+ iface->needs_probe = gst_xv_image_sink_probe_needs_probe;
+ iface->get_values = gst_xv_image_sink_probe_get_values;
}
#endif
/* =========================================== */
static void
-gst_xvimagesink_set_property (GObject * object, guint prop_id,
+gst_xv_image_sink_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstXvImageSink *xvimagesink;
- g_return_if_fail (GST_IS_XVIMAGESINK (object));
+ g_return_if_fail (GST_IS_XV_IMAGE_SINK (object));
- xvimagesink = GST_XVIMAGESINK (object);
+ xvimagesink = GST_XV_IMAGE_SINK (object);
switch (prop_id) {
case PROP_HUE:
xvimagesink->config.hue = g_value_get_int (value);
xvimagesink->config.cb_changed = TRUE;
- gst_xvimagesink_update_colorbalance (xvimagesink);
+ gst_xv_image_sink_update_colorbalance (xvimagesink);
break;
case PROP_CONTRAST:
xvimagesink->config.contrast = g_value_get_int (value);
xvimagesink->config.cb_changed = TRUE;
- gst_xvimagesink_update_colorbalance (xvimagesink);
+ gst_xv_image_sink_update_colorbalance (xvimagesink);
break;
case PROP_BRIGHTNESS:
xvimagesink->config.brightness = g_value_get_int (value);
xvimagesink->config.cb_changed = TRUE;
- gst_xvimagesink_update_colorbalance (xvimagesink);
+ gst_xv_image_sink_update_colorbalance (xvimagesink);
break;
case PROP_SATURATION:
xvimagesink->config.saturation = g_value_get_int (value);
xvimagesink->config.cb_changed = TRUE;
- gst_xvimagesink_update_colorbalance (xvimagesink);
+ gst_xv_image_sink_update_colorbalance (xvimagesink);
break;
case PROP_DISPLAY:
g_free (xvimagesink->config.display_name);
xvimagesink->keep_aspect = g_value_get_boolean (value);
break;
case PROP_HANDLE_EVENTS:
- gst_xvimagesink_set_event_handling (GST_VIDEO_OVERLAY (xvimagesink),
+ gst_xv_image_sink_set_event_handling (GST_VIDEO_OVERLAY (xvimagesink),
g_value_get_boolean (value));
- gst_xvimagesink_manage_event_thread (xvimagesink);
+ gst_xv_image_sink_manage_event_thread (xvimagesink);
break;
case PROP_DEVICE:
xvimagesink->config.adaptor_nr = atoi (g_value_get_string (value));
break;
case PROP_HANDLE_EXPOSE:
xvimagesink->handle_expose = g_value_get_boolean (value);
- gst_xvimagesink_manage_event_thread (xvimagesink);
+ gst_xv_image_sink_manage_event_thread (xvimagesink);
break;
case PROP_DOUBLE_BUFFER:
xvimagesink->double_buffer = g_value_get_boolean (value);
}
static void
-gst_xvimagesink_get_property (GObject * object, guint prop_id,
+gst_xv_image_sink_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstXvImageSink *xvimagesink;
- g_return_if_fail (GST_IS_XVIMAGESINK (object));
+ g_return_if_fail (GST_IS_XV_IMAGE_SINK (object));
- xvimagesink = GST_XVIMAGESINK (object);
+ xvimagesink = GST_XV_IMAGE_SINK (object);
switch (prop_id) {
case PROP_HUE:
}
static gboolean
-gst_xvimagesink_open (GstXvImageSink * xvimagesink)
+gst_xv_image_sink_open (GstXvImageSink * xvimagesink)
{
GError *error = NULL;
/* call XSynchronize with the current value of synchronous */
gst_xvcontext_set_synchronous (xvimagesink->context,
xvimagesink->synchronous);
- gst_xvimagesink_update_colorbalance (xvimagesink);
- gst_xvimagesink_manage_event_thread (xvimagesink);
+ gst_xv_image_sink_update_colorbalance (xvimagesink);
+ gst_xv_image_sink_manage_event_thread (xvimagesink);
return TRUE;
}
static void
-gst_xvimagesink_close (GstXvImageSink * xvimagesink)
+gst_xv_image_sink_close (GstXvImageSink * xvimagesink)
{
GThread *thread;
GstXvContext *context;
* We use mutexes and don't reset stuff to NULL here so let's register
* as a finalize. */
static void
-gst_xvimagesink_finalize (GObject * object)
+gst_xv_image_sink_finalize (GObject * object)
{
GstXvImageSink *xvimagesink;
- xvimagesink = GST_XVIMAGESINK (object);
+ xvimagesink = GST_XV_IMAGE_SINK (object);
- gst_xvimagesink_close (xvimagesink);
+ gst_xv_image_sink_close (xvimagesink);
gst_xvcontext_config_clear (&xvimagesink->config);
}
static void
-gst_xvimagesink_init (GstXvImageSink * xvimagesink)
+gst_xv_image_sink_init (GstXvImageSink * xvimagesink)
{
xvimagesink->config.display_name = NULL;
xvimagesink->config.adaptor_nr = 0;
}
static void
-gst_xvimagesink_class_init (GstXvImageSinkClass * klass)
+gst_xv_image_sink_class_init (GstXvImageSinkClass * klass)
{
GObjectClass *gobject_class;
GstElementClass *gstelement_class;
parent_class = g_type_class_peek_parent (klass);
- gobject_class->set_property = gst_xvimagesink_set_property;
- gobject_class->get_property = gst_xvimagesink_get_property;
+ gobject_class->set_property = gst_xv_image_sink_set_property;
+ gobject_class->get_property = gst_xv_image_sink_get_property;
g_object_class_install_property (gobject_class, PROP_CONTRAST,
g_param_spec_int ("contrast", "Contrast", "The contrast of the video",
"Height of the window", 0, G_MAXUINT64, 0,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
- gobject_class->finalize = gst_xvimagesink_finalize;
+ gobject_class->finalize = gst_xv_image_sink_finalize;
gst_element_class_set_static_metadata (gstelement_class,
"Video sink", "Sink/Video",
"A Xv based videosink", "Julien Moutte <julien@moutte.net>");
gst_element_class_add_pad_template (gstelement_class,
- gst_static_pad_template_get (&gst_xvimagesink_sink_template_factory));
+ gst_static_pad_template_get (&gst_xv_image_sink_sink_template_factory));
gstelement_class->change_state =
- GST_DEBUG_FUNCPTR (gst_xvimagesink_change_state);
+ GST_DEBUG_FUNCPTR (gst_xv_image_sink_change_state);
- gstbasesink_class->get_caps = GST_DEBUG_FUNCPTR (gst_xvimagesink_getcaps);
- gstbasesink_class->set_caps = GST_DEBUG_FUNCPTR (gst_xvimagesink_setcaps);
- gstbasesink_class->get_times = GST_DEBUG_FUNCPTR (gst_xvimagesink_get_times);
+ gstbasesink_class->get_caps = GST_DEBUG_FUNCPTR (gst_xv_image_sink_getcaps);
+ gstbasesink_class->set_caps = GST_DEBUG_FUNCPTR (gst_xv_image_sink_setcaps);
+ gstbasesink_class->get_times =
+ GST_DEBUG_FUNCPTR (gst_xv_image_sink_get_times);
gstbasesink_class->propose_allocation =
- GST_DEBUG_FUNCPTR (gst_xvimagesink_propose_allocation);
- gstbasesink_class->event = GST_DEBUG_FUNCPTR (gst_xvimagesink_event);
+ GST_DEBUG_FUNCPTR (gst_xv_image_sink_propose_allocation);
+ gstbasesink_class->event = GST_DEBUG_FUNCPTR (gst_xv_image_sink_event);
- videosink_class->show_frame = GST_DEBUG_FUNCPTR (gst_xvimagesink_show_frame);
+ videosink_class->show_frame =
+ GST_DEBUG_FUNCPTR (gst_xv_image_sink_show_frame);
}
* Boston, MA 02110-1301, USA.
*/
-#ifndef __GST_XVIMAGESINK_H__
-#define __GST_XVIMAGESINK_H__
+#ifndef __GST_XV_IMAGE_SINK_H__
+#define __GST_XV_IMAGE_SINK_H__
#include <gst/video/gstvideosink.h>
#include <gst/video/video.h>
G_BEGIN_DECLS
-#define GST_TYPE_XVIMAGESINK \
- (gst_xvimagesink_get_type())
-#define GST_XVIMAGESINK(obj) \
- (G_TYPE_CHECK_INSTANCE_CAST((obj), GST_TYPE_XVIMAGESINK, GstXvImageSink))
-#define GST_XVIMAGESINK_CLASS(klass) \
- (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_XVIMAGESINK, GstXvImageSinkClass))
-#define GST_IS_XVIMAGESINK(obj) \
- (G_TYPE_CHECK_INSTANCE_TYPE((obj), GST_TYPE_XVIMAGESINK))
-#define GST_IS_XVIMAGESINK_CLASS(klass) \
- (G_TYPE_CHECK_CLASS_TYPE((klass), GST_TYPE_XVIMAGESINK))
+#define GST_TYPE_XV_IMAGE_SINK \
+ (gst_xv_image_sink_get_type())
+#define GST_XV_IMAGE_SINK(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST((obj), GST_TYPE_XV_IMAGE_SINK, GstXvImageSink))
+#define GST_XV_IMAGE_SINK_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_XV_IMAGE_SINK, GstXvImageSinkClass))
+#define GST_IS_XV_IMAGE_SINK(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE((obj), GST_TYPE_XV_IMAGE_SINK))
+#define GST_IS_XV_IMAGE_SINK_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_TYPE((klass), GST_TYPE_XV_IMAGE_SINK))
typedef struct _GstXvImageSink GstXvImageSink;
typedef struct _GstXvImageSinkClass GstXvImageSinkClass;
GstVideoSinkClass parent_class;
};
-GType gst_xvimagesink_get_type (void);
+GType gst_xv_image_sink_get_type (void);
G_END_DECLS
-#endif /* __GST_XVIMAGESINK_H__ */
+#endif /* __GST_XV_IMAGE_SINK_H__ */
projects / platform / upstream / gstreamer.git / commitdiff