* @author: Olivier Crete <olivier.crete@collabora.co.uk>
* Copyright 2009 Nokia Corp.
*
- * fs-app-stream-transmitter.c - A Farstream Shared memory stream transmitter
+ * fs-app-stream-transmitter.c - A Farstream GstAppShared memory stream transmitter
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* SECTION:fs-app-stream-transmitter
* @short_description: A stream transmitter object for Shared Memory
*
- * The name of this transmitter is "shm".
+ * The name of this transmitter is "app".
*
* This transmitter is meant to send and received the data from another process
* on the same system while minimizing the memory pressure associated with the
/* temporary socket directy in case we made one */
gchar *socket_dir;
- ShmSrc **shm_src;
- ShmSink **shm_sink;
+ AppSrc **app_src;
+ AppSink **app_sink;
};
#define FS_APP_STREAM_TRANSMITTER_GET_PRIVATE(o) \
pspec = g_param_spec_boolean ("create-local-candidates",
"CreateLocalCandidates",
"Whether the transmitter should automatically create local candidates",
- FALSE,
+ TRUE,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
g_object_class_install_property (gobject_class,
PROP_CREATE_LOCAL_CANDIDATES,
for (c = 1; c <= self->priv->transmitter->components; c++)
{
- if (self->priv->shm_src[c])
+ if (self->priv->app_src[c])
{
- fs_app_transmitter_check_shm_src (self->priv->transmitter,
- self->priv->shm_src[c], NULL);
+ fs_app_transmitter_check_app_src (self->priv->transmitter,
+ self->priv->app_src[c], NULL);
}
- self->priv->shm_src[c] = NULL;
+ self->priv->app_src[c] = NULL;
- if (self->priv->shm_sink[c])
+ if (self->priv->app_sink[c])
{
- fs_app_transmitter_check_shm_sink (self->priv->transmitter,
- self->priv->shm_sink[c], NULL);
+ fs_app_transmitter_check_app_sink (self->priv->transmitter,
+ self->priv->app_sink[c], NULL);
}
- self->priv->shm_sink[c] = NULL;
+ self->priv->app_sink[c] = NULL;
}
if (self->priv->socket_dir != NULL)
fs_candidate_list_destroy (self->priv->preferred_local_candidates);
- g_free (self->priv->shm_src);
- g_free (self->priv->shm_sink);
+ g_free (self->priv->app_src);
+ g_free (self->priv->app_sink);
g_mutex_clear (&self->priv->mutex);
parent_class->finalize (object);
case PROP_SENDING:
FS_APP_STREAM_TRANSMITTER_LOCK (self);
self->priv->sending = g_value_get_boolean (value);
- if (self->priv->shm_sink[1])
+ if (self->priv->app_sink[1])
fs_app_transmitter_sink_set_sending (self->priv->transmitter,
- self->priv->shm_sink[1], self->priv->sending);
+ self->priv->app_sink[1], self->priv->sending);
FS_APP_STREAM_TRANSMITTER_UNLOCK (self);
break;
case PROP_PREFERRED_LOCAL_CANDIDATES:
fs_app_stream_transmitter_build (FsAppStreamTransmitter *self,
GError **error)
{
- self->priv->shm_src = g_new0 (ShmSrc *,
+ self->priv->app_src = g_new0 (AppSrc *,
self->priv->transmitter->components + 1);
- self->priv->shm_sink = g_new0 (ShmSink *,
+ self->priv->app_sink = g_new0 (AppSink *,
self->priv->transmitter->components + 1);
return TRUE;
if (!candidate->ip || !candidate->ip[0])
return TRUE;
- if (self->priv->shm_sink[candidate->component_id])
+ if (self->priv->app_sink[candidate->component_id])
{
- if (fs_app_transmitter_check_shm_sink (self->priv->transmitter,
- self->priv->shm_sink[candidate->component_id], candidate->ip))
+ if (fs_app_transmitter_check_app_sink (self->priv->transmitter,
+ self->priv->app_sink[candidate->component_id], candidate->ip))
return TRUE;
- self->priv->shm_sink[candidate->component_id] = NULL;
+ self->priv->app_sink[candidate->component_id] = NULL;
}
- self->priv->shm_sink[candidate->component_id] =
- fs_app_transmitter_get_shm_sink (self->priv->transmitter,
+ self->priv->app_sink[candidate->component_id] =
+ fs_app_transmitter_get_app_sink (self->priv->transmitter,
candidate->component_id, candidate->ip, ready_cb, connected_cb,
self, error);
- if (self->priv->shm_sink[candidate->component_id] == NULL)
+ if (self->priv->app_sink[candidate->component_id] == NULL)
return FALSE;
- if (candidate->component_id == 1)
+ if (candidate->component_id == 1) {
fs_app_transmitter_sink_set_sending (self->priv->transmitter,
- self->priv->shm_sink[candidate->component_id], self->priv->sending);
-
+ self->priv->app_sink[candidate->component_id], self->priv->sending);
+ // connected_cb(1, 0, self);
+ }
return TRUE;
}
if (path && path[0])
{
- if (self->priv->shm_src[candidate->component_id])
+ if (self->priv->app_src[candidate->component_id])
{
- if (fs_app_transmitter_check_shm_src (self->priv->transmitter,
- self->priv->shm_src[candidate->component_id], path))
+ if (fs_app_transmitter_check_app_src (self->priv->transmitter,
+ self->priv->app_src[candidate->component_id], path))
return TRUE;
- self->priv->shm_src[candidate->component_id] = NULL;
+ self->priv->app_src[candidate->component_id] = NULL;
}
- self->priv->shm_src[candidate->component_id] =
- fs_app_transmitter_get_shm_src (self->priv->transmitter,
+ self->priv->app_src[candidate->component_id] =
+ fs_app_transmitter_get_app_src (self->priv->transmitter,
candidate->component_id, path, got_buffer_func, disconnected_cb,
self, error);
- if (self->priv->shm_src[candidate->component_id] == NULL)
+ if (self->priv->app_src[candidate->component_id] == NULL)
return FALSE;
}
(!candidate->username || !candidate->username[0]))
{
g_set_error (error, FS_ERROR, FS_ERROR_INVALID_ARGUMENTS,
- "The candidate does not have a SINK shm segment in its ip"
- " or a SRC shm segment in its username");
+ "The candidate does not have a SINK app segment in its ip"
+ " or a SRC app segment in its username");
return FALSE;
}
}
gchar *socket_dir;
socket_dir = g_build_filename (g_get_tmp_dir (),
- "farstream-shm-XXXXXX", NULL);
+ "farstream-app-XXXXXX", NULL);
if (g_mkdtemp (socket_dir) == NULL)
return FALSE;
for (c = 1; c <= self->priv->transmitter->components; c++)
{
- gchar *path = g_strdup_printf ("%s/shm-sink-socket-%d", socket_dir, c);
+ gchar *path = g_strdup_printf ("%s/app-sink-socket-%d", socket_dir, c);
- self->priv->shm_sink[c] =
- fs_app_transmitter_get_shm_sink (self->priv->transmitter,
+ self->priv->app_sink[c] =
+ fs_app_transmitter_get_app_sink (self->priv->transmitter,
c, path, ready_cb, connected_cb, self, error);
g_free (path);
- if (self->priv->shm_sink[c] == NULL)
+ if (self->priv->app_sink[c] == NULL)
return FALSE;
- if (c == 1)
+ if (c == 1) {
fs_app_transmitter_sink_set_sending (self->priv->transmitter,
- self->priv->shm_sink[c], self->priv->sending);
+ self->priv->app_sink[c], self->priv->sending);
+ // connected_cb(1, 0, self);
+ }
}
return TRUE;
/*
- * Farstream - Farstream Shm UDP Transmitter
+ * Farstream - Farstream App UDP Transmitter
*
* Copyright 2007-2008 Collabora Ltd.
* @author: Olivier Crete <olivier.crete@collabora.co.uk>
* Copyright 2007-2008 Nokia Corp.
*
- * fs-app-transmitter.c - A Farstream shm UDP transmitter
+ * fs-app-transmitter.c - A Farstream appsink/appsrc transmitter
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
/**
* SECTION:fs-app-transmitter
- * @short_description: A transmitter for shm UDP
+ * @short_description: A transmitter for appsink/appsrc I/O
*
- * This transmitter provides shm udp
+ * This transmitter provides appsink/appsrc I/O
*
*/
};
static guint bin_signals[BIN_LAST_SIGNAL] = { 0 };
-static GType shm_bin_type = 0;
-gpointer shm_bin_parent_class = NULL;
+static GType app_bin_type = 0;
+gpointer app_bin_parent_class = NULL;
-typedef struct _FsShmBin
+typedef struct _FsAppBin
{
GstBin parent;
-} FsShmBin;
+} FsAppBin;
-typedef struct _FsShmBinClass
+typedef struct _FsAppBinClass
{
GstBinClass parent_class;
-} FsShmBinClass;
+} FsAppBinClass;
-static void fs_shm_bin_init (FsShmBin *self)
+static void fs_app_bin_init (FsAppBin *self)
{
}
static GstElement *
-fs_shm_bin_new (void)
+fs_app_bin_new (void)
{
- return g_object_new (shm_bin_type, NULL);
+ return g_object_new (app_bin_type, NULL);
}
static void
-fs_shm_bin_handle_message (GstBin *bin, GstMessage *message)
+fs_app_bin_handle_message (GstBin *bin, GstMessage *message)
{
GstState old, new, pending;
GError *gerror;
break;
}
- GST_BIN_CLASS (shm_bin_parent_class)->handle_message (bin, message);
+ GST_BIN_CLASS (app_bin_parent_class)->handle_message (bin, message);
}
-static void fs_shm_bin_class_init (FsShmBinClass *klass)
+static void fs_app_bin_class_init (FsAppBinClass *klass)
{
GstBinClass *bin_class = GST_BIN_CLASS (klass);
- shm_bin_parent_class = g_type_class_peek_parent (klass);
+ app_bin_parent_class = g_type_class_peek_parent (klass);
bin_signals[BIN_SIGNAL_READY] =
g_signal_new ("ready", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST, 0, NULL, NULL,
g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, GST_TYPE_ELEMENT);
- bin_class->handle_message = GST_DEBUG_FUNCPTR (fs_shm_bin_handle_message);
+ bin_class->handle_message = GST_DEBUG_FUNCPTR (fs_app_bin_handle_message);
}
/*
};
static const GTypeInfo bin_info = {
- sizeof (FsShmBinClass),
+ sizeof (FsAppBinClass),
NULL,
NULL,
- (GClassInitFunc) fs_shm_bin_class_init,
+ (GClassInitFunc) fs_app_bin_class_init,
NULL,
NULL,
- sizeof (FsShmBin),
+ sizeof (FsAppBin),
0,
- (GInstanceInitFunc) fs_shm_bin_init
+ (GInstanceInitFunc) fs_app_bin_init
};
GST_DEBUG_CATEGORY_INIT (fs_app_transmitter_debug,
- "fsshmtransmitter", 0,
- "Farstream shm UDP transmitter");
+ "fsapptransmitter", 0,
+ "Farstream app UDP transmitter");
fs_app_stream_transmitter_register_type (module);
type = g_type_register_static (FS_TYPE_TRANSMITTER, "FsAppTransmitter",
&info, 0);
- shm_bin_type = g_type_register_static (
- GST_TYPE_BIN, "FsShmBin", &bin_info, 0);
+ app_bin_type = g_type_register_static (
+ GST_TYPE_BIN, "FsAppBin", &bin_info, 0);
return type;
}
/* First we need the src elemnet */
- self->priv->gst_src = fs_shm_bin_new ();
+ self->priv->gst_src = fs_app_bin_new ();
if (!self->priv->gst_src) {
trans->construction_error = g_error_new (FS_ERROR,
/* Second, we do the sink element */
- self->priv->gst_sink = fs_shm_bin_new ();
+ self->priv->gst_sink = fs_app_bin_new ();
if (!self->priv->gst_sink) {
trans->construction_error = g_error_new (FS_ERROR,
}
-struct _ShmSrc {
+struct _AppSrc {
guint component;
gchar *path;
GstElement *src;
static GstPadProbeReturn
src_buffer_probe_cb (GstPad *pad, GstPadProbeInfo *info, gpointer user_data)
{
- ShmSrc *shm = user_data;
+ AppSrc *app = user_data;
GstBuffer *buffer = GST_PAD_PROBE_INFO_BUFFER (info);
- shm->got_buffer_func (buffer, shm->component, shm->cb_data);
+ app->got_buffer_func (buffer, app->component, app->cb_data);
return TRUE;
}
static void
-disconnected_cb (GstBin *bin, GstElement *elem, ShmSrc *shm)
+disconnected_cb (GstBin *bin, GstElement *elem, AppSrc *app)
{
- if (elem != shm->src)
+ if (elem != app->src)
return;
- shm->disconnected_func (shm->component, 0, shm->cb_data);
+ app->disconnected_func (app->component, 0, app->cb_data);
}
-ShmSrc *
-fs_app_transmitter_get_shm_src (FsAppTransmitter *self,
+AppSrc *
+fs_app_transmitter_get_app_src (FsAppTransmitter *self,
guint component,
const gchar *path,
got_buffer got_buffer_func,
gpointer cb_data,
GError **error)
{
- ShmSrc *shm = g_slice_new0 (ShmSrc);
+ AppSrc *app = g_slice_new0 (AppSrc);
GstElement *elem;
GstPad *pad;
- shm->component = component;
- shm->got_buffer_func = got_buffer_func;
- shm->disconnected_func = disconnected_func;
- shm->cb_data = cb_data;
+ app->component = component;
+ app->got_buffer_func = got_buffer_func;
+ app->disconnected_func = disconnected_func;
+ app->cb_data = cb_data;
- shm->path = g_strdup (path);
+ app->path = g_strdup (path);
- elem = gst_element_factory_make ("shmsrc", NULL);
+ elem = gst_element_factory_make ("audiotestsrc", NULL);
if (!elem)
{
g_set_error (error, FS_ERROR, FS_ERROR_CONSTRUCTION,
- "Could not make shmsrc");
+ "Could not make appsrc");
goto error;
}
"is-live", TRUE,
NULL);
- if (shm->disconnected_func)
+ if (app->disconnected_func)
g_signal_connect (self->priv->gst_src, "disconnected",
- G_CALLBACK (disconnected_cb), shm);
+ G_CALLBACK (disconnected_cb), app);
if (!gst_bin_add (GST_BIN (self->priv->gst_src), elem))
{
goto error;
}
- shm->src = elem;
+ app->src = elem;
- shm->funnelpad = gst_element_get_request_pad (self->priv->funnels[component],
+ app->funnelpad = gst_element_get_request_pad (self->priv->funnels[component],
"sink_%u");
- if (!shm->funnelpad)
+ if (!app->funnelpad)
{
g_set_error (error, FS_ERROR, FS_ERROR_CONSTRUCTION,
"Could not get funnelpad");
goto error;
}
- pad = gst_element_get_static_pad (shm->src, "src");
- if (GST_PAD_LINK_FAILED (gst_pad_link (pad, shm->funnelpad)))
+ pad = gst_element_get_static_pad (app->src, "src");
+ if (GST_PAD_LINK_FAILED (gst_pad_link (pad, app->funnelpad)))
{
g_set_error (error, FS_ERROR, FS_ERROR_CONSTRUCTION, "Could not link tee"
" and valve");
gst_object_unref (pad);
if (got_buffer_func)
- shm->buffer_probe = gst_pad_add_probe (shm->funnelpad,
+ app->buffer_probe = gst_pad_add_probe (app->funnelpad,
GST_PAD_PROBE_TYPE_BUFFER,
- src_buffer_probe_cb, shm, NULL);
+ src_buffer_probe_cb, app, NULL);
- if (!gst_element_sync_state_with_parent (shm->src))
+ if (!gst_element_sync_state_with_parent (app->src))
{
g_set_error (error, FS_ERROR, FS_ERROR_CONSTRUCTION,
- "Could not sync the state of the new shmsrc with its parent");
+ "Could not sync the state of the new appsrc with its parent");
goto error;
}
- return shm;
+ return app;
error:
- fs_app_transmitter_check_shm_src (self, shm, NULL);
+ fs_app_transmitter_check_app_src (self, app, NULL);
return NULL;
}
/*
- * Returns: %TRUE if the path is the same, other %FALSE and freeds the ShmSrc
+ * Returns: %TRUE if the path is the same, other %FALSE and freeds the AppSrc
*/
gboolean
-fs_app_transmitter_check_shm_src (FsAppTransmitter *self, ShmSrc *shm,
+fs_app_transmitter_check_app_src (FsAppTransmitter *self, AppSrc *app,
const gchar *path)
{
- if (path && !strcmp (path, shm->path))
+ if (path && !strcmp (path, app->path))
return TRUE;
- if (shm->buffer_probe)
- gst_pad_remove_probe (shm->funnelpad, shm->buffer_probe);
- shm->buffer_probe = 0;
+ if (app->buffer_probe)
+ gst_pad_remove_probe (app->funnelpad, app->buffer_probe);
+ app->buffer_probe = 0;
- if (shm->funnelpad) {
- gst_element_release_request_pad (self->priv->funnels[shm->component],
- shm->funnelpad);
- gst_object_unref (shm->funnelpad);
+ if (app->funnelpad) {
+ gst_element_release_request_pad (self->priv->funnels[app->component],
+ app->funnelpad);
+ gst_object_unref (app->funnelpad);
}
- shm->funnelpad = NULL;
+ app->funnelpad = NULL;
- if (shm->src)
+ if (app->src)
{
- gst_element_set_locked_state (shm->src, TRUE);
- gst_element_set_state (shm->src, GST_STATE_NULL);
- gst_bin_remove (GST_BIN (self->priv->gst_src), shm->src);
+ gst_element_set_locked_state (app->src, TRUE);
+ gst_element_set_state (app->src, GST_STATE_NULL);
+ gst_bin_remove (GST_BIN (self->priv->gst_src), app->src);
}
- shm->src = NULL;
+ app->src = NULL;
- g_free (shm->path);
- g_slice_free (ShmSrc, shm);
+ g_free (app->path);
+ g_slice_free (AppSrc, app);
return FALSE;
}
-struct _ShmSink {
+struct _AppSink {
guint component;
gchar *path;
GstElement *sink;
static void
-ready_cb (GstBin *bin, GstElement *elem, ShmSink *shm)
+ready_cb (GstBin *bin, GstElement *elem, AppSink *app)
{
gchar *path = NULL;
- if (elem != shm->sink)
+ if (elem != app->sink)
return;
g_object_get (elem, "socket-path", &path, NULL);
- shm->ready_func (shm->component, path, shm->cb_data);
+ app->ready_func (app->component, path, app->cb_data);
g_free (path);
}
static void
-connected_cb (GstBin *bin, gint id, ShmSink *shm)
+connected_cb (GstBin *bin, gint id, AppSink *app)
{
- shm->connected_func (shm->component, id, shm->cb_data);
+ app->connected_func (app->component, id, app->cb_data);
}
-ShmSink *
-fs_app_transmitter_get_shm_sink (FsAppTransmitter *self,
+AppSink *
+fs_app_transmitter_get_app_sink (FsAppTransmitter *self,
guint component,
const gchar *path,
ready ready_func,
gpointer cb_data,
GError **error)
{
- ShmSink *shm = g_slice_new0 (ShmSink);
+ AppSink *app = g_slice_new0 (AppSink);
GstElement *elem;
GstPad *pad;
- GST_DEBUG ("Trying to add shm sink for c:%u path %s", component, path);
+ GST_DEBUG ("Trying to add app sink for c:%u path %s", component, path);
- shm->component = component;
+ app->component = component;
- shm->path = g_strdup (path);
+ app->path = g_strdup (path);
- shm->ready_func = ready_func;
- shm->connected_func = connected_func;
- shm->cb_data = cb_data;
+ app->ready_func = ready_func;
+ app->connected_func = connected_func;
+ app->cb_data = cb_data;
/* First add the sink */
- elem = gst_element_factory_make ("shmsink", NULL);
+ elem = gst_element_factory_make ("appsink", NULL);
if (!elem)
{
g_set_error (error, FS_ERROR, FS_ERROR_CONSTRUCTION,
- "Could not make shmsink");
+ "Could not make appsink");
goto error;
}
g_object_set (elem,
- "socket-path", path,
+ "location", "/tmp/pidgin.s16",
"wait-for-connection", FALSE,
"async", FALSE,
"sync" , FALSE,
if (ready_func)
g_signal_connect (self->priv->gst_sink, "ready", G_CALLBACK (ready_cb),
- shm);
+ app);
if (connected_func)
- g_signal_connect (elem, "client-connected", G_CALLBACK (connected_cb), shm);
+ g_signal_connect (elem, "client-connected", G_CALLBACK (connected_cb), app);
if (!gst_bin_add (GST_BIN (self->priv->gst_sink), elem))
{
g_set_error (error, FS_ERROR, FS_ERROR_CONSTRUCTION,
- "Could not add shmsink to bin");
+ "Could not add appsink to bin");
gst_object_unref (elem);
goto error;
}
- shm->sink = elem;
+ app->sink = elem;
/* Second add the recvonly filter */
goto error;
}
- shm->recvonly_filter = elem;
+ app->recvonly_filter = elem;
/* Third connect these */
- if (!gst_element_link (shm->recvonly_filter, shm->sink))
+ if (!gst_element_link (app->recvonly_filter, app->sink))
{
g_set_error (error, FS_ERROR, FS_ERROR_CONSTRUCTION,
- "Could not link recvonly filter and shmsink");
+ "Could not link recvonly filter and appsink");
goto error;
}
- if (!gst_element_sync_state_with_parent (shm->sink))
+ if (!gst_element_sync_state_with_parent (app->sink))
{
g_set_error (error, FS_ERROR, FS_ERROR_CONSTRUCTION,
- "Could not sync the state of the new shmsink with its parent");
+ "Could not sync the state of the new appsink with its parent");
goto error;
}
- if (!gst_element_sync_state_with_parent (shm->recvonly_filter))
+ if (!gst_element_sync_state_with_parent (app->recvonly_filter))
{
g_set_error (error, FS_ERROR, FS_ERROR_CONSTRUCTION,
"Could not sync the state of the new recvonly filter with its parent");
goto error;
}
- shm->teepad = gst_element_get_request_pad (self->priv->tees[component],
+ app->teepad = gst_element_get_request_pad (self->priv->tees[component],
"src_%u");
- if (!shm->teepad)
+ if (!app->teepad)
{
g_set_error (error, FS_ERROR, FS_ERROR_CONSTRUCTION,
"Could not get teepad");
goto error;
}
- pad = gst_element_get_static_pad (shm->recvonly_filter, "sink");
- if (GST_PAD_LINK_FAILED (gst_pad_link (shm->teepad, pad)))
+ pad = gst_element_get_static_pad (app->recvonly_filter, "sink");
+ if (GST_PAD_LINK_FAILED (gst_pad_link (app->teepad, pad)))
{
g_set_error (error, FS_ERROR, FS_ERROR_CONSTRUCTION, "Could not link tee"
" and valve");
}
gst_object_unref (pad);
- return shm;
+ return app;
error:
- fs_app_transmitter_check_shm_sink (self, shm, NULL);
+ fs_app_transmitter_check_app_sink (self, app, NULL);
return NULL;
}
gboolean
-fs_app_transmitter_check_shm_sink (FsAppTransmitter *self, ShmSink *shm,
+fs_app_transmitter_check_app_sink (FsAppTransmitter *self, AppSink *app,
const gchar *path)
{
- if (path && !strcmp (path, shm->path))
+ if (path && !strcmp (path, app->path))
return TRUE;
if (path)
- GST_DEBUG ("Replacing shm socket %s with %s", shm->path, path);
+ GST_DEBUG ("Replacing app socket %s with %s", app->path, path);
else
- GST_DEBUG ("Freeing shm socket %s", shm->path);
+ GST_DEBUG ("Freeing app socket %s", app->path);
- if (shm->teepad)
+ if (app->teepad)
{
- gst_element_release_request_pad (self->priv->tees[shm->component],
- shm->teepad);
- gst_object_unref (shm->teepad);
+ gst_element_release_request_pad (self->priv->tees[app->component],
+ app->teepad);
+ gst_object_unref (app->teepad);
}
- shm->teepad = NULL;
+ app->teepad = NULL;
- if (shm->sink)
+ if (app->sink)
{
- gst_element_set_locked_state (shm->sink, TRUE);
- gst_element_set_state (shm->sink, GST_STATE_NULL);
- gst_bin_remove (GST_BIN (self->priv->gst_sink), shm->sink);
+ gst_element_set_locked_state (app->sink, TRUE);
+ gst_element_set_state (app->sink, GST_STATE_NULL);
+ gst_bin_remove (GST_BIN (self->priv->gst_sink), app->sink);
}
- shm->sink = NULL;
+ app->sink = NULL;
- if (shm->recvonly_filter)
+ if (app->recvonly_filter)
{
- gst_element_set_locked_state (shm->recvonly_filter, TRUE);
- gst_element_set_state (shm->recvonly_filter, GST_STATE_NULL);
- gst_bin_remove (GST_BIN (self->priv->gst_sink), shm->recvonly_filter);
+ gst_element_set_locked_state (app->recvonly_filter, TRUE);
+ gst_element_set_state (app->recvonly_filter, GST_STATE_NULL);
+ gst_bin_remove (GST_BIN (self->priv->gst_sink), app->recvonly_filter);
}
- shm->recvonly_filter = NULL;
+ app->recvonly_filter = NULL;
- g_free (shm->path);
- g_slice_free (ShmSink, shm);
+ g_free (app->path);
+ g_slice_free (AppSink, app);
return FALSE;
}
void
-fs_app_transmitter_sink_set_sending (FsAppTransmitter *self, ShmSink *shm,
+fs_app_transmitter_sink_set_sending (FsAppTransmitter *self, AppSink *app,
gboolean sending)
{
- GObjectClass *klass = G_OBJECT_GET_CLASS (shm->recvonly_filter);
+ GObjectClass *klass = G_OBJECT_GET_CLASS (app->recvonly_filter);
if (g_object_class_find_property (klass, "drop"))
- g_object_set (shm->recvonly_filter, "drop", !sending, NULL);
+ g_object_set (app->recvonly_filter, "drop", !sending, NULL);
if (sending)
- gst_element_send_event (shm->sink,
+ gst_element_send_event (app->sink,
gst_event_new_custom (GST_EVENT_CUSTOM_UPSTREAM,
gst_structure_new ("GstForceKeyUnit",
"all-headers", G_TYPE_BOOLEAN, TRUE,
projects / pidgin-chime.git / commitdiff