* </para>
* <para>
* The session manager needs the clock-rate of the payload types it is handling
- * and will signal the GstRTPSession::request-pt-map signal when it needs such a
- * mapping. One can clear the cached values with the GstRTPSession::clear-pt-map
+ * and will signal the GstRtpSession::request-pt-map signal when it needs such a
+ * mapping. One can clear the cached values with the GstRtpSession::clear-pt-map
* signal.
* </para>
* <title>Example pipelines</title>
);
#define GST_RTP_BIN_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_RTP_BIN, GstRTPBinPrivate))
+ (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_RTP_BIN, GstRtpBinPrivate))
#define GST_RTP_BIN_LOCK(bin) g_mutex_lock ((bin)->priv->bin_lock)
#define GST_RTP_BIN_UNLOCK(bin) g_mutex_unlock ((bin)->priv->bin_lock)
-struct _GstRTPBinPrivate
+struct _GstRtpBinPrivate
{
GMutex *bin_lock;
};
};
/* helper objects */
-typedef struct _GstRTPBinSession GstRTPBinSession;
-typedef struct _GstRTPBinStream GstRTPBinStream;
-typedef struct _GstRTPBinClient GstRTPBinClient;
+typedef struct _GstRtpBinSession GstRtpBinSession;
+typedef struct _GstRtpBinStream GstRtpBinStream;
+typedef struct _GstRtpBinClient GstRtpBinClient;
static guint gst_rtp_bin_signals[LAST_SIGNAL] = { 0 };
static GstCaps *pt_map_requested (GstElement * element, guint pt,
- GstRTPBinSession * session);
+ GstRtpBinSession * session);
/* Manages the RTP stream for one SSRC.
*
* We pipe the stream (comming from the SSRC demuxer) into a jitterbuffer.
* If we see an SDES RTCP packet that links multiple SSRCs together based on a
- * common CNAME, we create a GstRTPBinClient structure to group the SSRCs
+ * common CNAME, we create a GstRtpBinClient structure to group the SSRCs
* together (see below).
*/
-struct _GstRTPBinStream
+struct _GstRtpBinStream
{
/* the SSRC of this stream */
guint32 ssrc;
/* parent bin */
- GstRTPBin *bin;
+ GstRtpBin *bin;
/* the session this SSRC belongs to */
- GstRTPBinSession *session;
+ GstRtpBinSession *session;
/* the jitterbuffer of the SSRC */
GstElement *buffer;
/* the PT demuxer of the SSRC */
* We get the RTP/RTCP packets and stuff them into the session manager. From
* there they are pushed into an SSRC demuxer that splits the stream based on
* SSRC. Each of the SSRC streams go into their own jitterbuffer (managed with
- * the GstRTPBinStream above).
+ * the GstRtpBinStream above).
*/
-struct _GstRTPBinSession
+struct _GstRtpBinSession
{
/* session id */
gint id;
/* the parent bin */
- GstRTPBin *bin;
+ GstRtpBin *bin;
/* the session element */
GstElement *session;
/* the SSRC demuxer */
GMutex *lock;
- /* list of GstRTPBinStream */
+ /* list of GstRtpBinStream */
GSList *streams;
/* mapping of payload type to caps */
};
/* find a session with the given id. Must be called with RTP_BIN_LOCK */
-static GstRTPBinSession *
-find_session_by_id (GstRTPBin * rtpbin, gint id)
+static GstRtpBinSession *
+find_session_by_id (GstRtpBin * rtpbin, gint id)
{
GSList *walk;
for (walk = rtpbin->sessions; walk; walk = g_slist_next (walk)) {
- GstRTPBinSession *sess = (GstRTPBinSession *) walk->data;
+ GstRtpBinSession *sess = (GstRtpBinSession *) walk->data;
if (sess->id == id)
return sess;
}
static void
-on_new_ssrc (GstElement * session, guint32 ssrc, GstRTPBinSession * sess)
+on_new_ssrc (GstElement * session, guint32 ssrc, GstRtpBinSession * sess)
{
g_signal_emit (sess->bin, gst_rtp_bin_signals[SIGNAL_ON_NEW_SSRC], 0,
sess->id, ssrc);
}
static void
-on_ssrc_collision (GstElement * session, guint32 ssrc, GstRTPBinSession * sess)
+on_ssrc_collision (GstElement * session, guint32 ssrc, GstRtpBinSession * sess)
{
g_signal_emit (sess->bin, gst_rtp_bin_signals[SIGNAL_ON_SSRC_COLLISION], 0,
sess->id, ssrc);
}
static void
-on_ssrc_validated (GstElement * session, guint32 ssrc, GstRTPBinSession * sess)
+on_ssrc_validated (GstElement * session, guint32 ssrc, GstRtpBinSession * sess)
{
g_signal_emit (sess->bin, gst_rtp_bin_signals[SIGNAL_ON_SSRC_VALIDATED], 0,
sess->id, ssrc);
}
static void
-on_bye_ssrc (GstElement * session, guint32 ssrc, GstRTPBinSession * sess)
+on_bye_ssrc (GstElement * session, guint32 ssrc, GstRtpBinSession * sess)
{
g_signal_emit (sess->bin, gst_rtp_bin_signals[SIGNAL_ON_BYE_SSRC], 0,
sess->id, ssrc);
}
static void
-on_bye_timeout (GstElement * session, guint32 ssrc, GstRTPBinSession * sess)
+on_bye_timeout (GstElement * session, guint32 ssrc, GstRtpBinSession * sess)
{
g_signal_emit (sess->bin, gst_rtp_bin_signals[SIGNAL_ON_BYE_TIMEOUT], 0,
sess->id, ssrc);
}
static void
-on_timeout (GstElement * session, guint32 ssrc, GstRTPBinSession * sess)
+on_timeout (GstElement * session, guint32 ssrc, GstRtpBinSession * sess)
{
g_signal_emit (sess->bin, gst_rtp_bin_signals[SIGNAL_ON_TIMEOUT], 0,
sess->id, ssrc);
}
/* create a session with the given id. Must be called with RTP_BIN_LOCK */
-static GstRTPBinSession *
-create_session (GstRTPBin * rtpbin, gint id)
+static GstRtpBinSession *
+create_session (GstRtpBin * rtpbin, gint id)
{
- GstRTPBinSession *sess;
+ GstRtpBinSession *sess;
GstElement *session, *demux;
if (!(session = gst_element_factory_make ("gstrtpsession", NULL)))
if (!(demux = gst_element_factory_make ("gstrtpssrcdemux", NULL)))
goto no_demux;
- sess = g_new0 (GstRTPBinSession, 1);
+ sess = g_new0 (GstRtpBinSession, 1);
sess->lock = g_mutex_new ();
sess->id = id;
sess->bin = rtpbin;
}
#if 0
-static GstRTPBinStream *
-find_stream_by_ssrc (GstRTPBinSession * session, guint32 ssrc)
+static GstRtpBinStream *
+find_stream_by_ssrc (GstRtpBinSession * session, guint32 ssrc)
{
GSList *walk;
for (walk = session->streams; walk; walk = g_slist_next (walk)) {
- GstRTPBinStream *stream = (GstRTPBinStream *) walk->data;
+ GstRtpBinStream *stream = (GstRtpBinStream *) walk->data;
if (stream->ssrc == ssrc)
return stream;
/* get the payload type caps for the specific payload @pt in @session */
static GstCaps *
-get_pt_map (GstRTPBinSession * session, guint pt)
+get_pt_map (GstRtpBinSession * session, guint pt)
{
GstCaps *caps = NULL;
- GstRTPBin *bin;
+ GstRtpBin *bin;
GValue ret = { 0 };
GValue args[3] = { {0}, {0}, {0} };
}
static void
-gst_rtp_bin_clear_pt_map (GstRTPBin * bin)
+gst_rtp_bin_clear_pt_map (GstRtpBin * bin)
{
GSList *walk;
GST_RTP_BIN_LOCK (bin);
for (walk = bin->sessions; walk; walk = g_slist_next (walk)) {
- GstRTPBinSession *session = (GstRTPBinSession *) walk->data;
+ GstRtpBinSession *session = (GstRtpBinSession *) walk->data;
GST_RTP_SESSION_LOCK (session);
#if 0
/* create a new stream with @ssrc in @session. Must be called with
* RTP_SESSION_LOCK. */
-static GstRTPBinStream *
-create_stream (GstRTPBinSession * session, guint32 ssrc)
+static GstRtpBinStream *
+create_stream (GstRtpBinSession * session, guint32 ssrc)
{
GstElement *buffer, *demux;
- GstRTPBinStream *stream;
+ GstRtpBinStream *stream;
if (!(buffer = gst_element_factory_make ("gstrtpjitterbuffer", NULL)))
goto no_jitterbuffer;
if (!(demux = gst_element_factory_make ("gstrtpptdemux", NULL)))
goto no_demux;
- stream = g_new0 (GstRTPBinStream, 1);
+ stream = g_new0 (GstRtpBinStream, 1);
stream->ssrc = ssrc;
stream->bin = session->bin;
stream->session = session;
/* Manages the RTP streams that come from one client and should therefore be
* synchronized.
*/
-struct _GstRTPBinClient
+struct _GstRtpBinClient
{
/* the common CNAME for the streams */
gchar *cname;
static GstPad *gst_rtp_bin_request_new_pad (GstElement * element,
GstPadTemplate * templ, const gchar * name);
static void gst_rtp_bin_release_pad (GstElement * element, GstPad * pad);
-static void gst_rtp_bin_clear_pt_map (GstRTPBin * bin);
+static void gst_rtp_bin_clear_pt_map (GstRtpBin * bin);
-GST_BOILERPLATE (GstRTPBin, gst_rtp_bin, GstBin, GST_TYPE_BIN);
+GST_BOILERPLATE (GstRtpBin, gst_rtp_bin, GstBin, GST_TYPE_BIN);
static void
gst_rtp_bin_base_init (gpointer klass)
}
static void
-gst_rtp_bin_class_init (GstRTPBinClass * klass)
+gst_rtp_bin_class_init (GstRtpBinClass * klass)
{
GObjectClass *gobject_class;
GstElementClass *gstelement_class;
gobject_class = (GObjectClass *) klass;
gstelement_class = (GstElementClass *) klass;
- g_type_class_add_private (klass, sizeof (GstRTPBinPrivate));
+ g_type_class_add_private (klass, sizeof (GstRtpBinPrivate));
gobject_class->finalize = gst_rtp_bin_finalize;
gobject_class->set_property = gst_rtp_bin_set_property;
G_MAXUINT, DEFAULT_LATENCY_MS, G_PARAM_READWRITE));
/**
- * GstRTPBin::request-pt-map:
+ * GstRtpBin::request-pt-map:
* @rtpbin: the object which received the signal
* @session: the session
* @pt: the pt
*/
gst_rtp_bin_signals[SIGNAL_REQUEST_PT_MAP] =
g_signal_new ("request-pt-map", G_TYPE_FROM_CLASS (klass),
- G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTPBinClass, request_pt_map),
+ G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRtpBinClass, request_pt_map),
NULL, NULL, gst_rtp_bin_marshal_BOXED__UINT_UINT, GST_TYPE_CAPS, 2,
G_TYPE_UINT, G_TYPE_UINT);
/**
- * GstRTPBin::clear-pt-map:
+ * GstRtpBin::clear-pt-map:
* @rtpbin: the object which received the signal
*
* Clear all previously cached pt-mapping obtained with
- * GstRTPBin::request-pt-map.
+ * GstRtpBin::request-pt-map.
*/
gst_rtp_bin_signals[SIGNAL_CLEAR_PT_MAP] =
g_signal_new ("clear-pt-map", G_TYPE_FROM_CLASS (klass),
- G_SIGNAL_ACTION, G_STRUCT_OFFSET (GstRTPBinClass, clear_pt_map),
+ G_SIGNAL_ACTION, G_STRUCT_OFFSET (GstRtpBinClass, clear_pt_map),
NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0, G_TYPE_NONE);
/**
- * GstRTPBin::on-new-ssrc:
+ * GstRtpBin::on-new-ssrc:
* @rtpbin: the object which received the signal
* @session: the session
* @ssrc: the SSRC
*/
gst_rtp_bin_signals[SIGNAL_ON_NEW_SSRC] =
g_signal_new ("on-new-ssrc", G_TYPE_FROM_CLASS (klass),
- G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTPBinClass, on_new_ssrc),
+ G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRtpBinClass, on_new_ssrc),
NULL, NULL, gst_rtp_bin_marshal_VOID__UINT_UINT, G_TYPE_NONE, 2,
G_TYPE_UINT, G_TYPE_UINT);
/**
- * GstRTPBin::on-ssrc_collision:
+ * GstRtpBin::on-ssrc_collision:
* @rtpbin: the object which received the signal
* @session: the session
* @ssrc: the SSRC
*/
gst_rtp_bin_signals[SIGNAL_ON_SSRC_COLLISION] =
g_signal_new ("on-ssrc-collision", G_TYPE_FROM_CLASS (klass),
- G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTPBinClass, on_ssrc_collision),
+ G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRtpBinClass, on_ssrc_collision),
NULL, NULL, gst_rtp_bin_marshal_VOID__UINT_UINT, G_TYPE_NONE, 2,
G_TYPE_UINT, G_TYPE_UINT);
/**
- * GstRTPBin::on-ssrc_validated:
+ * GstRtpBin::on-ssrc_validated:
* @rtpbin: the object which received the signal
* @session: the session
* @ssrc: the SSRC
*/
gst_rtp_bin_signals[SIGNAL_ON_SSRC_VALIDATED] =
g_signal_new ("on-ssrc-validated", G_TYPE_FROM_CLASS (klass),
- G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTPBinClass, on_ssrc_validated),
+ G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRtpBinClass, on_ssrc_validated),
NULL, NULL, gst_rtp_bin_marshal_VOID__UINT_UINT, G_TYPE_NONE, 2,
G_TYPE_UINT, G_TYPE_UINT);
/**
- * GstRTPBin::on-bye-ssrc:
+ * GstRtpBin::on-bye-ssrc:
* @rtpbin: the object which received the signal
* @session: the session
* @ssrc: the SSRC
*/
gst_rtp_bin_signals[SIGNAL_ON_BYE_SSRC] =
g_signal_new ("on-bye-ssrc", G_TYPE_FROM_CLASS (klass),
- G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTPBinClass, on_bye_ssrc),
+ G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRtpBinClass, on_bye_ssrc),
NULL, NULL, gst_rtp_bin_marshal_VOID__UINT_UINT, G_TYPE_NONE, 2,
G_TYPE_UINT, G_TYPE_UINT);
/**
- * GstRTPBin::on-bye-timeout:
+ * GstRtpBin::on-bye-timeout:
* @rtpbin: the object which received the signal
* @session: the session
* @ssrc: the SSRC
*/
gst_rtp_bin_signals[SIGNAL_ON_BYE_TIMEOUT] =
g_signal_new ("on-bye-timeout", G_TYPE_FROM_CLASS (klass),
- G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTPBinClass, on_bye_timeout),
+ G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRtpBinClass, on_bye_timeout),
NULL, NULL, gst_rtp_bin_marshal_VOID__UINT_UINT, G_TYPE_NONE, 2,
G_TYPE_UINT, G_TYPE_UINT);
/**
- * GstRTPBin::on-timeout:
+ * GstRtpBin::on-timeout:
* @rtpbin: the object which received the signal
* @session: the session
* @ssrc: the SSRC
*/
gst_rtp_bin_signals[SIGNAL_ON_TIMEOUT] =
g_signal_new ("on-timeout", G_TYPE_FROM_CLASS (klass),
- G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTPBinClass, on_timeout),
+ G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRtpBinClass, on_timeout),
NULL, NULL, gst_rtp_bin_marshal_VOID__UINT_UINT, G_TYPE_NONE, 2,
G_TYPE_UINT, G_TYPE_UINT);
}
static void
-gst_rtp_bin_init (GstRTPBin * rtpbin, GstRTPBinClass * klass)
+gst_rtp_bin_init (GstRtpBin * rtpbin, GstRtpBinClass * klass)
{
rtpbin->priv = GST_RTP_BIN_GET_PRIVATE (rtpbin);
rtpbin->priv->bin_lock = g_mutex_new ();
static void
gst_rtp_bin_finalize (GObject * object)
{
- GstRTPBin *rtpbin;
+ GstRtpBin *rtpbin;
rtpbin = GST_RTP_BIN (object);
gst_rtp_bin_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
- GstRTPBin *rtpbin;
+ GstRtpBin *rtpbin;
rtpbin = GST_RTP_BIN (object);
gst_rtp_bin_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
- GstRTPBin *rtpbin;
+ GstRtpBin *rtpbin;
rtpbin = GST_RTP_BIN (object);
static GstClock *
gst_rtp_bin_provide_clock (GstElement * element)
{
- GstRTPBin *rtpbin;
+ GstRtpBin *rtpbin;
rtpbin = GST_RTP_BIN (element);
gst_rtp_bin_change_state (GstElement * element, GstStateChange transition)
{
GstStateChangeReturn res;
- GstRTPBin *rtpbin;
+ GstRtpBin *rtpbin;
rtpbin = GST_RTP_BIN (element);
/* a new pad (SSRC) was created in @session */
static void
new_payload_found (GstElement * element, guint pt, GstPad * pad,
- GstRTPBinStream * stream)
+ GstRtpBinStream * stream)
{
- GstRTPBin *rtpbin;
+ GstRtpBin *rtpbin;
GstElementClass *klass;
GstPadTemplate *templ;
gchar *padname;
}
static GstCaps *
-pt_map_requested (GstElement * element, guint pt, GstRTPBinSession * session)
+pt_map_requested (GstElement * element, guint pt, GstRtpBinSession * session)
{
- GstRTPBin *rtpbin;
+ GstRtpBin *rtpbin;
GstCaps *caps;
rtpbin = session->bin;
/* a new pad (SSRC) was created in @session */
static void
new_ssrc_pad_found (GstElement * element, guint ssrc, GstPad * pad,
- GstRTPBinSession * session)
+ GstRtpBinSession * session)
{
- GstRTPBinStream *stream;
+ GstRtpBinStream *stream;
GstPad *sinkpad;
GST_DEBUG_OBJECT (session->bin, "new SSRC pad %08x", ssrc);
* RTP_BIN_LOCK.
*/
static GstPad *
-create_recv_rtp (GstRTPBin * rtpbin, GstPadTemplate * templ, const gchar * name)
+create_recv_rtp (GstRtpBin * rtpbin, GstPadTemplate * templ, const gchar * name)
{
GstPad *result, *sinkdpad;
guint sessid;
- GstRTPBinSession *session;
+ GstRtpBinSession *session;
GstPadLinkReturn lres;
/* first get the session number */
* RTP_BIN_LOCK.
*/
static GstPad *
-create_recv_rtcp (GstRTPBin * rtpbin, GstPadTemplate * templ,
+create_recv_rtcp (GstRtpBin * rtpbin, GstPadTemplate * templ,
const gchar * name)
{
GstPad *result;
guint sessid;
- GstRTPBinSession *session;
+ GstRtpBinSession *session;
#if 0
GstPad *sinkdpad;
* RTP_BIN_LOCK.
*/
static GstPad *
-create_send_rtp (GstRTPBin * rtpbin, GstPadTemplate * templ, const gchar * name)
+create_send_rtp (GstRtpBin * rtpbin, GstPadTemplate * templ, const gchar * name)
{
GstPad *result, *srcghost;
gchar *gname;
guint sessid;
- GstRTPBinSession *session;
+ GstRtpBinSession *session;
GstElementClass *klass;
/* first get the session number */
* RTP_BIN_LOCK.
*/
static GstPad *
-create_rtcp (GstRTPBin * rtpbin, GstPadTemplate * templ, const gchar * name)
+create_rtcp (GstRtpBin * rtpbin, GstPadTemplate * templ, const gchar * name)
{
GstPad *result;
guint sessid;
- GstRTPBinSession *session;
+ GstRtpBinSession *session;
/* first get the session number */
if (name == NULL || sscanf (name, "send_rtcp_src_%d", &sessid) != 1)
gst_rtp_bin_request_new_pad (GstElement * element,
GstPadTemplate * templ, const gchar * name)
{
- GstRTPBin *rtpbin;
+ GstRtpBin *rtpbin;
GstElementClass *klass;
GstPad *result;
#define GST_TYPE_RTP_BIN \
(gst_rtp_bin_get_type())
#define GST_RTP_BIN(obj) \
- (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_RTP_BIN,GstRTPBin))
+ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_RTP_BIN,GstRtpBin))
#define GST_RTP_BIN_CLASS(klass) \
- (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_RTP_BIN,GstRTPBinClass))
+ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_RTP_BIN,GstRtpBinClass))
#define GST_IS_RTP_BIN(obj) \
(G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_RTP_BIN))
#define GST_IS_RTP_BIN_CLASS(klass) \
(G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_RTP_BIN))
-typedef struct _GstRTPBin GstRTPBin;
-typedef struct _GstRTPBinClass GstRTPBinClass;
-typedef struct _GstRTPBinPrivate GstRTPBinPrivate;
+typedef struct _GstRtpBin GstRtpBin;
+typedef struct _GstRtpBinClass GstRtpBinClass;
+typedef struct _GstRtpBinPrivate GstRtpBinPrivate;
-struct _GstRTPBin {
+struct _GstRtpBin {
GstBin bin;
/*< private >*/
GstClock *provided_clock;
/*< private >*/
- GstRTPBinPrivate *priv;
+ GstRtpBinPrivate *priv;
};
-struct _GstRTPBinClass {
+struct _GstRtpBinClass {
GstBinClass parent_class;
/* get the caps for pt */
- GstCaps* (*request_pt_map) (GstRTPBin *rtpbin, guint session, guint pt);
- void (*clear_pt_map) (GstRTPBin *rtpbin);
+ GstCaps* (*request_pt_map) (GstRtpBin *rtpbin, guint session, guint pt);
+ void (*clear_pt_map) (GstRtpBin *rtpbin);
- void (*on_new_ssrc) (GstRTPBin *rtpbin, guint session, guint32 ssrc);
- void (*on_ssrc_collision) (GstRTPBin *rtpbin, guint session, guint32 ssrc);
- void (*on_ssrc_validated) (GstRTPBin *rtpbin, guint session, guint32 ssrc);
- void (*on_bye_ssrc) (GstRTPBin *rtpbin, guint session, guint32 ssrc);
- void (*on_bye_timeout) (GstRTPBin *rtpbin, guint session, guint32 ssrc);
- void (*on_timeout) (GstRTPBin *rtpbin, guint session, guint32 ssrc);
+ void (*on_new_ssrc) (GstRtpBin *rtpbin, guint session, guint32 ssrc);
+ void (*on_ssrc_collision) (GstRtpBin *rtpbin, guint session, guint32 ssrc);
+ void (*on_ssrc_validated) (GstRtpBin *rtpbin, guint session, guint32 ssrc);
+ void (*on_bye_ssrc) (GstRtpBin *rtpbin, guint session, guint32 ssrc);
+ void (*on_bye_timeout) (GstRtpBin *rtpbin, guint session, guint32 ssrc);
+ void (*on_timeout) (GstRtpBin *rtpbin, guint session, guint32 ssrc);
};
GType gst_rtp_bin_get_type (void);
);
#define GST_RTP_CLIENT_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_RTP_CLIENT, GstRTPClientPrivate))
+ (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_RTP_CLIENT, GstRtpClientPrivate))
-struct _GstRTPClientPrivate
+struct _GstRtpClientPrivate
{
gint foo;
};
/* all the info needed to handle the stream with SSRC */
typedef struct
{
- GstRTPClient *client;
+ GstRtpClient *client;
/* the SSRC of this stream */
guint32 ssrc;
GstElement *ptdemux;
/* the new-pad signal */
gulong new_pad_sig;
-} GstRTPClientStream;
+} GstRtpClientStream;
/* the PT demuxer found a new payload type */
static void
-new_pad (GstElement * element, GstPad * pad, GstRTPClientStream * stream)
+new_pad (GstElement * element, GstPad * pad, GstRtpClientStream * stream)
{
}
* / +-----------------+ +---------------+
*
*/
-static GstRTPClientStream *
-create_stream (GstRTPClient * rtpclient, guint32 ssrc)
+static GstRtpClientStream *
+create_stream (GstRtpClient * rtpclient, guint32 ssrc)
{
- GstRTPClientStream *stream;
+ GstRtpClientStream *stream;
gchar *name;
GstPad *srcpad, *sinkpad;
GstPadLinkReturn res;
- stream = g_new0 (GstRTPClientStream, 1);
+ stream = g_new0 (GstRtpClientStream, 1);
stream->ssrc = ssrc;
stream->client = rtpclient;
#if 0
static void
-free_stream (GstRTPClientStream * stream)
+free_stream (GstRtpClientStream * stream)
{
gst_object_unref (stream->jitterbuffer);
g_free (stream);
/* find the stream for the given SSRC, return NULL if the stream did not exist
*/
-static GstRTPClientStream *
-find_stream_by_ssrc (GstRTPClient * client, guint32 ssrc)
+static GstRtpClientStream *
+find_stream_by_ssrc (GstRtpClient * client, guint32 ssrc)
{
- GstRTPClientStream *stream;
+ GstRtpClientStream *stream;
GList *walk;
for (walk = client->streams; walk; walk = g_list_next (walk)) {
- stream = (GstRTPClientStream *) walk->data;
+ stream = (GstRtpClientStream *) walk->data;
if (stream->ssrc == ssrc)
return stream;
}
/*static guint gst_rtp_client_signals[LAST_SIGNAL] = { 0 }; */
-GST_BOILERPLATE (GstRTPClient, gst_rtp_client, GstBin, GST_TYPE_BIN);
+GST_BOILERPLATE (GstRtpClient, gst_rtp_client, GstBin, GST_TYPE_BIN);
static void
gst_rtp_client_base_init (gpointer klass)
}
static void
-gst_rtp_client_class_init (GstRTPClientClass * klass)
+gst_rtp_client_class_init (GstRtpClientClass * klass)
{
GObjectClass *gobject_class;
GstElementClass *gstelement_class;
gobject_class = (GObjectClass *) klass;
gstelement_class = (GstElementClass *) klass;
- g_type_class_add_private (klass, sizeof (GstRTPClientPrivate));
+ g_type_class_add_private (klass, sizeof (GstRtpClientPrivate));
gobject_class->finalize = gst_rtp_client_finalize;
gobject_class->set_property = gst_rtp_client_set_property;
}
static void
-gst_rtp_client_init (GstRTPClient * rtpclient, GstRTPClientClass * klass)
+gst_rtp_client_init (GstRtpClient * rtpclient, GstRtpClientClass * klass)
{
rtpclient->priv = GST_RTP_CLIENT_GET_PRIVATE (rtpclient);
}
static void
gst_rtp_client_finalize (GObject * object)
{
- GstRTPClient *rtpclient;
+ GstRtpClient *rtpclient;
rtpclient = GST_RTP_CLIENT (object);
gst_rtp_client_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
- GstRTPClient *rtpclient;
+ GstRtpClient *rtpclient;
rtpclient = GST_RTP_CLIENT (object);
gst_rtp_client_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
- GstRTPClient *rtpclient;
+ GstRtpClient *rtpclient;
rtpclient = GST_RTP_CLIENT (object);
gst_rtp_client_change_state (GstElement * element, GstStateChange transition)
{
GstStateChangeReturn res;
- GstRTPClient *rtpclient;
+ GstRtpClient *rtpclient;
rtpclient = GST_RTP_CLIENT (element);
gst_rtp_client_request_new_pad (GstElement * element,
GstPadTemplate * templ, const gchar * name)
{
- GstRTPClient *rtpclient;
+ GstRtpClient *rtpclient;
GstElementClass *klass;
GstPadTemplate *rtp_sink_templ, *sync_sink_templ;
guint32 ssrc;
- GstRTPClientStream *stream;
+ GstRtpClientStream *stream;
GstPad *result;
g_return_val_if_fail (templ != NULL, NULL);
#define GST_TYPE_RTP_CLIENT \
(gst_rtp_client_get_type())
#define GST_RTP_CLIENT(obj) \
- (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_RTP_CLIENT,GstRTPClient))
+ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_RTP_CLIENT,GstRtpClient))
#define GST_RTP_CLIENT_CLASS(klass) \
- (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_RTP_CLIENT,GstRTPClientClass))
+ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_RTP_CLIENT,GstRtpClientClass))
#define GST_IS_RTP_CLIENT(obj) \
(G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_RTP_CLIENT))
#define GST_IS_RTP_CLIENT_CLASS(klass) \
(G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_RTP_CLIENT))
-typedef struct _GstRTPClient GstRTPClient;
-typedef struct _GstRTPClientClass GstRTPClientClass;
-typedef struct _GstRTPClientPrivate GstRTPClientPrivate;
+typedef struct _GstRtpClient GstRtpClient;
+typedef struct _GstRtpClientClass GstRtpClientClass;
+typedef struct _GstRtpClientPrivate GstRtpClientPrivate;
-struct _GstRTPClient {
+struct _GstRtpClient {
GstBin parent_bin;
/* a list of streams from a client */
GList *streams;
/*< private >*/
- GstRTPClientPrivate *priv;
+ GstRtpClientPrivate *priv;
};
-struct _GstRTPClientClass {
+struct _GstRtpClientClass {
GstBinClass parent_class;
};
#define JBUF_SIGNAL(priv) (g_cond_signal ((priv)->jbuf_cond))
-struct _GstRTPJitterBufferPrivate
+struct _GstRtpJitterBufferPrivate
{
GstPad *sinkpad, *srcpad;
#define GST_RTP_JITTER_BUFFER_GET_PRIVATE(o) \
(G_TYPE_INSTANCE_GET_PRIVATE ((o), GST_TYPE_RTP_JITTER_BUFFER, \
- GstRTPJitterBufferPrivate))
+ GstRtpJitterBufferPrivate))
static GstStaticPadTemplate gst_rtp_jitter_buffer_sink_template =
GST_STATIC_PAD_TEMPLATE ("sink",
static guint gst_rtp_jitter_buffer_signals[LAST_SIGNAL] = { 0 };
-GST_BOILERPLATE (GstRTPJitterBuffer, gst_rtp_jitter_buffer, GstElement,
+GST_BOILERPLATE (GstRtpJitterBuffer, gst_rtp_jitter_buffer, GstElement,
GST_TYPE_ELEMENT);
/* object overrides */
/* srcpad overrides */
static gboolean
gst_rtp_jitter_buffer_src_activate_push (GstPad * pad, gboolean active);
-static void gst_rtp_jitter_buffer_loop (GstRTPJitterBuffer * jitterbuffer);
+static void gst_rtp_jitter_buffer_loop (GstRtpJitterBuffer * jitterbuffer);
static gboolean gst_rtp_jitter_buffer_query (GstPad * pad, GstQuery * query);
static void
-gst_rtp_jitter_buffer_clear_pt_map (GstRTPJitterBuffer * jitterbuffer);
+gst_rtp_jitter_buffer_clear_pt_map (GstRtpJitterBuffer * jitterbuffer);
static void
gst_rtp_jitter_buffer_base_init (gpointer klass)
}
static void
-gst_rtp_jitter_buffer_class_init (GstRTPJitterBufferClass * klass)
+gst_rtp_jitter_buffer_class_init (GstRtpJitterBufferClass * klass)
{
GObjectClass *gobject_class;
GstElementClass *gstelement_class;
gobject_class = (GObjectClass *) klass;
gstelement_class = (GstElementClass *) klass;
- g_type_class_add_private (klass, sizeof (GstRTPJitterBufferPrivate));
+ g_type_class_add_private (klass, sizeof (GstRtpJitterBufferPrivate));
gobject_class->dispose = GST_DEBUG_FUNCPTR (gst_rtp_jitter_buffer_dispose);
gobject_class->get_property = gst_rtp_jitter_buffer_get_property;
/**
- * GstRTPJitterBuffer::latency:
+ * GstRtpJitterBuffer::latency:
*
* The maximum latency of the jitterbuffer. Packets will be kept in the buffer
* for at most this time.
"Amount of ms to buffer", 0, G_MAXUINT, DEFAULT_LATENCY_MS,
G_PARAM_READWRITE));
/**
- * GstRTPJitterBuffer::drop-on-latency:
+ * GstRtpJitterBuffer::drop-on-latency:
*
* Drop oldest buffers when the queue is completely filled.
*/
"Tells the jitterbuffer to never exceed the given latency in size",
DEFAULT_DROP_ON_LATENCY, G_PARAM_READWRITE));
/**
- * GstRTPJitterBuffer::request-pt-map:
+ * GstRtpJitterBuffer::request-pt-map:
* @buffer: the object which received the signal
* @pt: the pt
*
*/
gst_rtp_jitter_buffer_signals[SIGNAL_REQUEST_PT_MAP] =
g_signal_new ("request-pt-map", G_TYPE_FROM_CLASS (klass),
- G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTPJitterBufferClass,
+ G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRtpJitterBufferClass,
request_pt_map), NULL, NULL, gst_rtp_bin_marshal_BOXED__UINT,
GST_TYPE_CAPS, 1, G_TYPE_UINT);
/**
- * GstRTPJitterBuffer::clear-pt-map:
+ * GstRtpJitterBuffer::clear-pt-map:
* @buffer: the object which received the signal
*
* Invalidate the clock-rate as obtained with the ::request-pt-map signal.
*/
gst_rtp_jitter_buffer_signals[SIGNAL_CLEAR_PT_MAP] =
g_signal_new ("clear-pt-map", G_TYPE_FROM_CLASS (klass),
- G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTPJitterBufferClass,
+ G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRtpJitterBufferClass,
clear_pt_map), NULL, NULL, g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0, G_TYPE_NONE);
}
static void
-gst_rtp_jitter_buffer_init (GstRTPJitterBuffer * jitterbuffer,
- GstRTPJitterBufferClass * klass)
+gst_rtp_jitter_buffer_init (GstRtpJitterBuffer * jitterbuffer,
+ GstRtpJitterBufferClass * klass)
{
- GstRTPJitterBufferPrivate *priv;
+ GstRtpJitterBufferPrivate *priv;
priv = GST_RTP_JITTER_BUFFER_GET_PRIVATE (jitterbuffer);
jitterbuffer->priv = priv;
static void
gst_rtp_jitter_buffer_dispose (GObject * object)
{
- GstRTPJitterBuffer *jitterbuffer;
+ GstRtpJitterBuffer *jitterbuffer;
jitterbuffer = GST_RTP_JITTER_BUFFER (object);
if (jitterbuffer->priv->jbuf) {
}
static void
-gst_rtp_jitter_buffer_clear_pt_map (GstRTPJitterBuffer * jitterbuffer)
+gst_rtp_jitter_buffer_clear_pt_map (GstRtpJitterBuffer * jitterbuffer)
{
- GstRTPJitterBufferPrivate *priv;
+ GstRtpJitterBufferPrivate *priv;
priv = jitterbuffer->priv;
static GstCaps *
gst_rtp_jitter_buffer_getcaps (GstPad * pad)
{
- GstRTPJitterBuffer *jitterbuffer;
- GstRTPJitterBufferPrivate *priv;
+ GstRtpJitterBuffer *jitterbuffer;
+ GstRtpJitterBufferPrivate *priv;
GstPad *other;
GstCaps *caps;
const GstCaps *templ;
}
static gboolean
-gst_jitter_buffer_sink_parse_caps (GstRTPJitterBuffer * jitterbuffer,
+gst_jitter_buffer_sink_parse_caps (GstRtpJitterBuffer * jitterbuffer,
GstCaps * caps)
{
- GstRTPJitterBufferPrivate *priv;
+ GstRtpJitterBufferPrivate *priv;
GstStructure *caps_struct;
const GValue *value;
static gboolean
gst_jitter_buffer_sink_setcaps (GstPad * pad, GstCaps * caps)
{
- GstRTPJitterBuffer *jitterbuffer;
- GstRTPJitterBufferPrivate *priv;
+ GstRtpJitterBuffer *jitterbuffer;
+ GstRtpJitterBufferPrivate *priv;
gboolean res;
jitterbuffer = GST_RTP_JITTER_BUFFER (gst_pad_get_parent (pad));
}
static void
-gst_rtp_jitter_buffer_flush_start (GstRTPJitterBuffer * jitterbuffer)
+gst_rtp_jitter_buffer_flush_start (GstRtpJitterBuffer * jitterbuffer)
{
- GstRTPJitterBufferPrivate *priv;
+ GstRtpJitterBufferPrivate *priv;
priv = jitterbuffer->priv;
}
static void
-gst_rtp_jitter_buffer_flush_stop (GstRTPJitterBuffer * jitterbuffer)
+gst_rtp_jitter_buffer_flush_stop (GstRtpJitterBuffer * jitterbuffer)
{
- GstRTPJitterBufferPrivate *priv;
+ GstRtpJitterBufferPrivate *priv;
priv = jitterbuffer->priv;
gst_rtp_jitter_buffer_src_activate_push (GstPad * pad, gboolean active)
{
gboolean result = TRUE;
- GstRTPJitterBuffer *jitterbuffer = NULL;
+ GstRtpJitterBuffer *jitterbuffer = NULL;
jitterbuffer = GST_RTP_JITTER_BUFFER (gst_pad_get_parent (pad));
gst_rtp_jitter_buffer_change_state (GstElement * element,
GstStateChange transition)
{
- GstRTPJitterBuffer *jitterbuffer;
- GstRTPJitterBufferPrivate *priv;
+ GstRtpJitterBuffer *jitterbuffer;
+ GstRtpJitterBufferPrivate *priv;
GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
jitterbuffer = GST_RTP_JITTER_BUFFER (element);
gst_rtp_jitter_buffer_sink_event (GstPad * pad, GstEvent * event)
{
gboolean ret = TRUE;
- GstRTPJitterBuffer *jitterbuffer;
- GstRTPJitterBufferPrivate *priv;
+ GstRtpJitterBuffer *jitterbuffer;
+ GstRtpJitterBufferPrivate *priv;
jitterbuffer = GST_RTP_JITTER_BUFFER (gst_pad_get_parent (pad));
priv = jitterbuffer->priv;
}
static gboolean
-gst_rtp_jitter_buffer_get_clock_rate (GstRTPJitterBuffer * jitterbuffer,
+gst_rtp_jitter_buffer_get_clock_rate (GstRtpJitterBuffer * jitterbuffer,
guint8 pt)
{
GValue ret = { 0 };
static GstFlowReturn
gst_rtp_jitter_buffer_chain (GstPad * pad, GstBuffer * buffer)
{
- GstRTPJitterBuffer *jitterbuffer;
- GstRTPJitterBufferPrivate *priv;
+ GstRtpJitterBuffer *jitterbuffer;
+ GstRtpJitterBufferPrivate *priv;
guint16 seqnum;
GstFlowReturn ret = GST_FLOW_OK;
* missing packet to arrive up to the rtp timestamp of buffer B.
*/
static void
-gst_rtp_jitter_buffer_loop (GstRTPJitterBuffer * jitterbuffer)
+gst_rtp_jitter_buffer_loop (GstRtpJitterBuffer * jitterbuffer)
{
- GstRTPJitterBufferPrivate *priv;
+ GstRtpJitterBufferPrivate *priv;
GstBuffer *outbuf = NULL;
GstFlowReturn result;
guint16 seqnum;
static gboolean
gst_rtp_jitter_buffer_query (GstPad * pad, GstQuery * query)
{
- GstRTPJitterBuffer *jitterbuffer;
- GstRTPJitterBufferPrivate *priv;
+ GstRtpJitterBuffer *jitterbuffer;
+ GstRtpJitterBufferPrivate *priv;
gboolean res = FALSE;
jitterbuffer = GST_RTP_JITTER_BUFFER (gst_pad_get_parent (pad));
gst_rtp_jitter_buffer_set_property (GObject * object,
guint prop_id, const GValue * value, GParamSpec * pspec)
{
- GstRTPJitterBuffer *jitterbuffer = GST_RTP_JITTER_BUFFER (object);
+ GstRtpJitterBuffer *jitterbuffer = GST_RTP_JITTER_BUFFER (object);
switch (prop_id) {
case PROP_LATENCY:
gst_rtp_jitter_buffer_get_property (GObject * object,
guint prop_id, GValue * value, GParamSpec * pspec)
{
- GstRTPJitterBuffer *jitterbuffer = GST_RTP_JITTER_BUFFER (object);
+ GstRtpJitterBuffer *jitterbuffer = GST_RTP_JITTER_BUFFER (object);
switch (prop_id) {
case PROP_LATENCY:
(gst_rtp_jitter_buffer_get_type())
#define GST_RTP_JITTER_BUFFER(obj) \
(G_TYPE_CHECK_INSTANCE_CAST((obj), \
- GST_TYPE_RTP_JITTER_BUFFER,GstRTPJitterBuffer))
+ GST_TYPE_RTP_JITTER_BUFFER,GstRtpJitterBuffer))
#define GST_RTP_JITTER_BUFFER_CLASS(klass) \
(G_TYPE_CHECK_CLASS_CAST((klass), \
- GST_TYPE_RTP_JITTER_BUFFER,GstRTPJitterBufferClass))
+ GST_TYPE_RTP_JITTER_BUFFER,GstRtpJitterBufferClass))
#define GST_IS_RTP_JITTER_BUFFER(obj) \
(G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_RTP_JITTER_BUFFER))
#define GST_IS_RTP_JITTER_BUFFER_CLASS(obj) \
(G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_RTP_JITTER_BUFFER))
-typedef struct _GstRTPJitterBuffer GstRTPJitterBuffer;
-typedef struct _GstRTPJitterBufferClass GstRTPJitterBufferClass;
-typedef struct _GstRTPJitterBufferPrivate GstRTPJitterBufferPrivate;
+typedef struct _GstRtpJitterBuffer GstRtpJitterBuffer;
+typedef struct _GstRtpJitterBufferClass GstRtpJitterBufferClass;
+typedef struct _GstRtpJitterBufferPrivate GstRtpJitterBufferPrivate;
/**
- * GstRTPJitterBuffer:
+ * GstRtpJitterBuffer:
*
* Opaque jitterbuffer structure.
*/
-struct _GstRTPJitterBuffer
+struct _GstRtpJitterBuffer
{
GstElement parent;
/*< private >*/
- GstRTPJitterBufferPrivate *priv;
+ GstRtpJitterBufferPrivate *priv;
gpointer _gst_reserved[GST_PADDING];
};
-struct _GstRTPJitterBufferClass
+struct _GstRtpJitterBufferClass
{
GstElementClass parent_class;
/* signals */
- GstCaps* (*request_pt_map) (GstRTPJitterBuffer *buffer, guint pt);
+ GstCaps* (*request_pt_map) (GstRtpJitterBuffer *buffer, guint pt);
- void (*clear_pt_map) (GstRTPJitterBuffer *buffer);
+ void (*clear_pt_map) (GstRtpJitterBuffer *buffer);
/*< private > */
gpointer _gst_reserved[GST_PADDING];
/**
* Item for storing GstPad<->pt pairs.
*/
-struct _GstRTPPtDemuxPad
+struct _GstRtpPtDemuxPad
{
GstPad *pad; /**< pointer to the actual pad */
gint pt; /**< RTP payload-type attached to pad */
LAST_SIGNAL
};
-GST_BOILERPLATE (GstRTPPtDemux, gst_rtp_pt_demux, GstElement, GST_TYPE_ELEMENT);
+GST_BOILERPLATE (GstRtpPtDemux, gst_rtp_pt_demux, GstElement, GST_TYPE_ELEMENT);
static void gst_rtp_pt_demux_finalize (GObject * object);
static GstFlowReturn gst_rtp_pt_demux_chain (GstPad * pad, GstBuffer * buf);
static GstStateChangeReturn gst_rtp_pt_demux_change_state (GstElement * element,
GstStateChange transition);
-static void gst_rtp_pt_demux_clear_pt_map (GstRTPPtDemux * rtpdemux);
+static void gst_rtp_pt_demux_clear_pt_map (GstRtpPtDemux * rtpdemux);
-static GstPad *find_pad_for_pt (GstRTPPtDemux * rtpdemux, guint8 pt);
+static GstPad *find_pad_for_pt (GstRtpPtDemux * rtpdemux, guint8 pt);
static guint gst_rtp_pt_demux_signals[LAST_SIGNAL] = { 0 };
}
static void
-gst_rtp_pt_demux_class_init (GstRTPPtDemuxClass * klass)
+gst_rtp_pt_demux_class_init (GstRtpPtDemuxClass * klass)
{
GObjectClass *gobject_klass;
GstElementClass *gstelement_klass;
gstelement_klass = (GstElementClass *) klass;
/**
- * GstRTPPtDemux::request-pt-map:
+ * GstRtpPtDemux::request-pt-map:
* @demux: the object which received the signal
* @pt: the payload type
*
*/
gst_rtp_pt_demux_signals[SIGNAL_REQUEST_PT_MAP] =
g_signal_new ("request-pt-map", G_TYPE_FROM_CLASS (klass),
- G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTPPtDemuxClass, request_pt_map),
+ G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRtpPtDemuxClass, request_pt_map),
NULL, NULL, gst_rtp_bin_marshal_BOXED__UINT, GST_TYPE_CAPS, 1,
G_TYPE_UINT);
/**
- * GstRTPPtDemux::new-payload-type:
+ * GstRtpPtDemux::new-payload-type:
* @demux: the object which received the signal
* @pt: the payload type
* @pad: the pad with the new payload
*/
gst_rtp_pt_demux_signals[SIGNAL_NEW_PAYLOAD_TYPE] =
g_signal_new ("new-payload-type", G_TYPE_FROM_CLASS (klass),
- G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTPPtDemuxClass, new_payload_type),
+ G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRtpPtDemuxClass, new_payload_type),
NULL, NULL, gst_rtp_bin_marshal_VOID__UINT_OBJECT, G_TYPE_NONE, 2,
G_TYPE_UINT, GST_TYPE_PAD);
/**
- * GstRTPPtDemux::payload-type-change:
+ * GstRtpPtDemux::payload-type-change:
* @demux: the object which received the signal
* @pt: the new payload type
*
*/
gst_rtp_pt_demux_signals[SIGNAL_PAYLOAD_TYPE_CHANGE] =
g_signal_new ("payload-type-change", G_TYPE_FROM_CLASS (klass),
- G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTPPtDemuxClass,
+ G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRtpPtDemuxClass,
payload_type_change), NULL, NULL, g_cclosure_marshal_VOID__UINT,
G_TYPE_NONE, 1, G_TYPE_UINT);
/**
- * GstRTPPtDemux::clear-pt-map:
+ * GstRtpPtDemux::clear-pt-map:
* @demux: the object which received the signal
*
* The application can call this signal to instruct the element to discard the
*/
gst_rtp_pt_demux_signals[SIGNAL_CLEAR_PT_MAP] =
g_signal_new ("clear-pt-map", G_TYPE_FROM_CLASS (klass),
- G_SIGNAL_ACTION | G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTPPtDemuxClass,
+ G_SIGNAL_ACTION | G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRtpPtDemuxClass,
clear_pt_map), NULL, NULL, g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0, G_TYPE_NONE);
}
static void
-gst_rtp_pt_demux_init (GstRTPPtDemux * ptdemux, GstRTPPtDemuxClass * g_class)
+gst_rtp_pt_demux_init (GstRtpPtDemux * ptdemux, GstRtpPtDemuxClass * g_class)
{
GstElementClass *klass = GST_ELEMENT_GET_CLASS (ptdemux);
}
static void
-gst_rtp_pt_demux_clear_pt_map (GstRTPPtDemux * rtpdemux)
+gst_rtp_pt_demux_clear_pt_map (GstRtpPtDemux * rtpdemux)
{
/* FIXME, do something */
}
gst_rtp_pt_demux_chain (GstPad * pad, GstBuffer * buf)
{
GstFlowReturn ret = GST_FLOW_OK;
- GstRTPPtDemux *rtpdemux;
+ GstRtpPtDemux *rtpdemux;
GstElement *element = GST_ELEMENT (GST_OBJECT_PARENT (pad));
guint8 pt;
GstPad *srcpad;
GstPadTemplate *templ;
gchar *padname;
GstCaps *caps;
- GstRTPPtDemuxPad *rtpdemuxpad;
+ GstRtpPtDemuxPad *rtpdemuxpad;
GValue ret = { 0 };
GValue args[2] = { {0}
, {0}
gst_pad_set_caps (srcpad, caps);
GST_DEBUG ("Adding pt=%d to the list.", pt);
- rtpdemuxpad = g_new0 (GstRTPPtDemuxPad, 1);
+ rtpdemuxpad = g_new0 (GstRtpPtDemuxPad, 1);
rtpdemuxpad->pt = pt;
rtpdemuxpad->pad = srcpad;
rtpdemux->srcpads = g_slist_append (rtpdemux->srcpads, rtpdemuxpad);
}
static GstPad *
-find_pad_for_pt (GstRTPPtDemux * rtpdemux, guint8 pt)
+find_pad_for_pt (GstRtpPtDemux * rtpdemux, guint8 pt)
{
GstPad *respad = NULL;
GSList *item = rtpdemux->srcpads;
for (; item; item = g_slist_next (item)) {
- GstRTPPtDemuxPad *pad = item->data;
+ GstRtpPtDemuxPad *pad = item->data;
if (pad->pt == pt) {
respad = pad->pad;
static gboolean
gst_rtp_pt_demux_setup (GstElement * element)
{
- GstRTPPtDemux *ptdemux = GST_RTP_PT_DEMUX (element);
+ GstRtpPtDemux *ptdemux = GST_RTP_PT_DEMUX (element);
gboolean res = TRUE;
if (ptdemux) {
static void
gst_rtp_pt_demux_release (GstElement * element)
{
- GstRTPPtDemux *ptdemux = GST_RTP_PT_DEMUX (element);
+ GstRtpPtDemux *ptdemux = GST_RTP_PT_DEMUX (element);
if (ptdemux) {
/* note: GstElement's dispose() will handle the pads */
gst_rtp_pt_demux_change_state (GstElement * element, GstStateChange transition)
{
GstStateChangeReturn ret;
- GstRTPPtDemux *ptdemux;
+ GstRtpPtDemux *ptdemux;
ptdemux = GST_RTP_PT_DEMUX (element);
#include <gst/gst.h>
#define GST_TYPE_RTP_PT_DEMUX (gst_rtp_pt_demux_get_type())
-#define GST_RTP_PT_DEMUX(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_RTP_PT_DEMUX,GstRTPPtDemux))
-#define GST_RTP_PT_DEMUX_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_RTP_PT_DEMUX,GstRTPPtDemuxClass))
+#define GST_RTP_PT_DEMUX(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_RTP_PT_DEMUX,GstRtpPtDemux))
+#define GST_RTP_PT_DEMUX_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_RTP_PT_DEMUX,GstRtpPtDemuxClass))
#define GST_IS_RTP_PT_DEMUX(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_RTP_PT_DEMUX))
#define GST_IS_RTP_PT_DEMUX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_RTP_PT_DEMUX))
-typedef struct _GstRTPPtDemux GstRTPPtDemux;
-typedef struct _GstRTPPtDemuxClass GstRTPPtDemuxClass;
-typedef struct _GstRTPPtDemuxPad GstRTPPtDemuxPad;
+typedef struct _GstRtpPtDemux GstRtpPtDemux;
+typedef struct _GstRtpPtDemuxClass GstRtpPtDemuxClass;
+typedef struct _GstRtpPtDemuxPad GstRtpPtDemuxPad;
-struct _GstRTPPtDemux
+struct _GstRtpPtDemux
{
GstElement parent; /**< parent class */
GstPad *sink; /**< the sink pad */
guint16 last_pt; /**< pt of the last packet 0xFFFF if none */
- GSList *srcpads; /**< a linked list of GstRTPPtDemuxPad objects */
+ GSList *srcpads; /**< a linked list of GstRtpPtDemuxPad objects */
};
-struct _GstRTPPtDemuxClass
+struct _GstRtpPtDemuxClass
{
GstElementClass parent_class;
/* get the caps for pt */
- GstCaps* (*request_pt_map) (GstRTPPtDemux *demux, guint pt);
+ GstCaps* (*request_pt_map) (GstRtpPtDemux *demux, guint pt);
/* signal emmited when a new PT is found from the incoming stream */
- void (*new_payload_type) (GstRTPPtDemux *demux, guint pt, GstPad * pad);
+ void (*new_payload_type) (GstRtpPtDemux *demux, guint pt, GstPad * pad);
/* signal emitted when the payload type changes */
- void (*payload_type_change) (GstRTPPtDemux *demux, guint pt);
+ void (*payload_type_change) (GstRtpPtDemux *demux, guint pt);
- void (*clear_pt_map) (GstRTPPtDemux *demux);
+ void (*clear_pt_map) (GstRtpPtDemux *demux);
};
GType gst_rtp_pt_demux_get_type (void);
* </para>
* <para>
* The session manager needs the clock-rate of the payload types it is handling
- * and will signal the GstRTPSession::request-pt-map signal when it needs such a
- * mapping. One can clear the cached values with the GstRTPSession::clear-pt-map
+ * and will signal the GstRtpSession::request-pt-map signal when it needs such a
+ * mapping. One can clear the cached values with the GstRtpSession::clear-pt-map
* signal.
* </para>
* <title>Example pipelines</title>
};
#define GST_RTP_SESSION_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_RTP_SESSION, GstRTPSessionPrivate))
+ (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_RTP_SESSION, GstRtpSessionPrivate))
#define GST_RTP_SESSION_LOCK(sess) g_mutex_lock ((sess)->priv->lock)
#define GST_RTP_SESSION_UNLOCK(sess) g_mutex_unlock ((sess)->priv->lock)
-struct _GstRTPSessionPrivate
+struct _GstRtpSessionPrivate
{
GMutex *lock;
RTPSession *session;
GstPadTemplate * templ, const gchar * name);
static void gst_rtp_session_release_pad (GstElement * element, GstPad * pad);
-static void gst_rtp_session_clear_pt_map (GstRTPSession * rtpsession);
+static void gst_rtp_session_clear_pt_map (GstRtpSession * rtpsession);
static guint gst_rtp_session_signals[LAST_SIGNAL] = { 0 };
static void
-on_new_ssrc (RTPSession * session, RTPSource * src, GstRTPSession * sess)
+on_new_ssrc (RTPSession * session, RTPSource * src, GstRtpSession * sess)
{
g_signal_emit (sess, gst_rtp_session_signals[SIGNAL_ON_NEW_SSRC], 0,
src->ssrc);
}
static void
-on_ssrc_collision (RTPSession * session, RTPSource * src, GstRTPSession * sess)
+on_ssrc_collision (RTPSession * session, RTPSource * src, GstRtpSession * sess)
{
g_signal_emit (sess, gst_rtp_session_signals[SIGNAL_ON_SSRC_COLLISION], 0,
src->ssrc);
}
static void
-on_ssrc_validated (RTPSession * session, RTPSource * src, GstRTPSession * sess)
+on_ssrc_validated (RTPSession * session, RTPSource * src, GstRtpSession * sess)
{
g_signal_emit (sess, gst_rtp_session_signals[SIGNAL_ON_SSRC_VALIDATED], 0,
src->ssrc);
}
static void
-on_bye_ssrc (RTPSession * session, RTPSource * src, GstRTPSession * sess)
+on_bye_ssrc (RTPSession * session, RTPSource * src, GstRtpSession * sess)
{
g_signal_emit (sess, gst_rtp_session_signals[SIGNAL_ON_BYE_SSRC], 0,
src->ssrc);
}
static void
-on_bye_timeout (RTPSession * session, RTPSource * src, GstRTPSession * sess)
+on_bye_timeout (RTPSession * session, RTPSource * src, GstRtpSession * sess)
{
g_signal_emit (sess, gst_rtp_session_signals[SIGNAL_ON_BYE_TIMEOUT], 0,
src->ssrc);
}
static void
-on_timeout (RTPSession * session, RTPSource * src, GstRTPSession * sess)
+on_timeout (RTPSession * session, RTPSource * src, GstRtpSession * sess)
{
g_signal_emit (sess, gst_rtp_session_signals[SIGNAL_ON_TIMEOUT], 0,
src->ssrc);
}
-GST_BOILERPLATE (GstRTPSession, gst_rtp_session, GstElement, GST_TYPE_ELEMENT);
+GST_BOILERPLATE (GstRtpSession, gst_rtp_session, GstElement, GST_TYPE_ELEMENT);
static void
gst_rtp_session_base_init (gpointer klass)
}
static void
-gst_rtp_session_class_init (GstRTPSessionClass * klass)
+gst_rtp_session_class_init (GstRtpSessionClass * klass)
{
GObjectClass *gobject_class;
GstElementClass *gstelement_class;
gobject_class = (GObjectClass *) klass;
gstelement_class = (GstElementClass *) klass;
- g_type_class_add_private (klass, sizeof (GstRTPSessionPrivate));
+ g_type_class_add_private (klass, sizeof (GstRtpSessionPrivate));
gobject_class->finalize = gst_rtp_session_finalize;
gobject_class->set_property = gst_rtp_session_set_property;
gobject_class->get_property = gst_rtp_session_get_property;
/**
- * GstRTPSession::request-pt-map:
+ * GstRtpSession::request-pt-map:
* @sess: the object which received the signal
* @pt: the pt
*
*/
gst_rtp_session_signals[SIGNAL_REQUEST_PT_MAP] =
g_signal_new ("request-pt-map", G_TYPE_FROM_CLASS (klass),
- G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTPSessionClass, request_pt_map),
+ G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRtpSessionClass, request_pt_map),
NULL, NULL, gst_rtp_bin_marshal_BOXED__UINT, GST_TYPE_CAPS, 1,
G_TYPE_UINT);
/**
- * GstRTPSession::clear-pt-map:
+ * GstRtpSession::clear-pt-map:
* @sess: the object which received the signal
*
- * Clear the cached pt-maps requested with GstRTPSession::request-pt-map.
+ * Clear the cached pt-maps requested with GstRtpSession::request-pt-map.
*/
gst_rtp_session_signals[SIGNAL_CLEAR_PT_MAP] =
g_signal_new ("clear-pt-map", G_TYPE_FROM_CLASS (klass),
- G_SIGNAL_ACTION, G_STRUCT_OFFSET (GstRTPSessionClass, clear_pt_map),
+ G_SIGNAL_ACTION, G_STRUCT_OFFSET (GstRtpSessionClass, clear_pt_map),
NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0, G_TYPE_NONE);
/**
- * GstRTPSession::on-new-ssrc:
+ * GstRtpSession::on-new-ssrc:
* @sess: the object which received the signal
* @ssrc: the SSRC
*
*/
gst_rtp_session_signals[SIGNAL_ON_NEW_SSRC] =
g_signal_new ("on-new-ssrc", G_TYPE_FROM_CLASS (klass),
- G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTPSessionClass, on_new_ssrc),
+ G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRtpSessionClass, on_new_ssrc),
NULL, NULL, g_cclosure_marshal_VOID__UINT, G_TYPE_NONE, 1, G_TYPE_UINT);
/**
- * GstRTPSession::on-ssrc_collision:
+ * GstRtpSession::on-ssrc_collision:
* @sess: the object which received the signal
* @ssrc: the SSRC
*
*/
gst_rtp_session_signals[SIGNAL_ON_SSRC_COLLISION] =
g_signal_new ("on-ssrc-collision", G_TYPE_FROM_CLASS (klass),
- G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTPSessionClass,
+ G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRtpSessionClass,
on_ssrc_collision), NULL, NULL, g_cclosure_marshal_VOID__UINT,
G_TYPE_NONE, 1, G_TYPE_UINT);
/**
- * GstRTPSession::on-ssrc_validated:
+ * GstRtpSession::on-ssrc_validated:
* @sess: the object which received the signal
* @ssrc: the SSRC
*
*/
gst_rtp_session_signals[SIGNAL_ON_SSRC_VALIDATED] =
g_signal_new ("on-ssrc-validated", G_TYPE_FROM_CLASS (klass),
- G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTPSessionClass,
+ G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRtpSessionClass,
on_ssrc_validated), NULL, NULL, g_cclosure_marshal_VOID__UINT,
G_TYPE_NONE, 1, G_TYPE_UINT);
/**
- * GstRTPSession::on-bye-ssrc:
+ * GstRtpSession::on-bye-ssrc:
* @sess: the object which received the signal
* @ssrc: the SSRC
*
*/
gst_rtp_session_signals[SIGNAL_ON_BYE_SSRC] =
g_signal_new ("on-bye-ssrc", G_TYPE_FROM_CLASS (klass),
- G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTPSessionClass, on_bye_ssrc),
+ G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRtpSessionClass, on_bye_ssrc),
NULL, NULL, g_cclosure_marshal_VOID__UINT, G_TYPE_NONE, 1, G_TYPE_UINT);
/**
- * GstRTPSession::on-bye-timeout:
+ * GstRtpSession::on-bye-timeout:
* @sess: the object which received the signal
* @ssrc: the SSRC
*
*/
gst_rtp_session_signals[SIGNAL_ON_BYE_TIMEOUT] =
g_signal_new ("on-bye-timeout", G_TYPE_FROM_CLASS (klass),
- G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTPSessionClass, on_bye_timeout),
+ G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRtpSessionClass, on_bye_timeout),
NULL, NULL, g_cclosure_marshal_VOID__UINT, G_TYPE_NONE, 1, G_TYPE_UINT);
/**
- * GstRTPSession::on-timeout:
+ * GstRtpSession::on-timeout:
* @sess: the object which received the signal
* @ssrc: the SSRC
*
*/
gst_rtp_session_signals[SIGNAL_ON_TIMEOUT] =
g_signal_new ("on-timeout", G_TYPE_FROM_CLASS (klass),
- G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRTPSessionClass, on_timeout),
+ G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstRtpSessionClass, on_timeout),
NULL, NULL, g_cclosure_marshal_VOID__UINT, G_TYPE_NONE, 1, G_TYPE_UINT);
gstelement_class->change_state =
}
static void
-gst_rtp_session_init (GstRTPSession * rtpsession, GstRTPSessionClass * klass)
+gst_rtp_session_init (GstRtpSession * rtpsession, GstRtpSessionClass * klass)
{
rtpsession->priv = GST_RTP_SESSION_GET_PRIVATE (rtpsession);
rtpsession->priv->lock = g_mutex_new ();
static void
gst_rtp_session_finalize (GObject * object)
{
- GstRTPSession *rtpsession;
+ GstRtpSession *rtpsession;
rtpsession = GST_RTP_SESSION (object);
g_mutex_free (rtpsession->priv->lock);
gst_rtp_session_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
- GstRTPSession *rtpsession;
+ GstRtpSession *rtpsession;
rtpsession = GST_RTP_SESSION (object);
gst_rtp_session_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
- GstRTPSession *rtpsession;
+ GstRtpSession *rtpsession;
rtpsession = GST_RTP_SESSION (object);
}
static void
-rtcp_thread (GstRTPSession * rtpsession)
+rtcp_thread (GstRtpSession * rtpsession)
{
GstClock *clock;
GstClockID id;
}
static gboolean
-start_rtcp_thread (GstRTPSession * rtpsession)
+start_rtcp_thread (GstRtpSession * rtpsession)
{
GError *error = NULL;
gboolean res;
}
static void
-stop_rtcp_thread (GstRTPSession * rtpsession)
+stop_rtcp_thread (GstRtpSession * rtpsession)
{
GST_DEBUG_OBJECT (rtpsession, "stopping RTCP thread");
gst_rtp_session_change_state (GstElement * element, GstStateChange transition)
{
GstStateChangeReturn res;
- GstRTPSession *rtpsession;
+ GstRtpSession *rtpsession;
rtpsession = GST_RTP_SESSION (element);
}
static void
-gst_rtp_session_clear_pt_map (GstRTPSession * rtpsession)
+gst_rtp_session_clear_pt_map (GstRtpSession * rtpsession)
{
/* FIXME, do something */
}
GstBuffer * buffer, gpointer user_data)
{
GstFlowReturn result;
- GstRTPSession *rtpsession;
- GstRTPSessionPrivate *priv;
+ GstRtpSession *rtpsession;
+ GstRtpSessionPrivate *priv;
rtpsession = GST_RTP_SESSION (user_data);
priv = rtpsession->priv;
GstBuffer * buffer, gpointer user_data)
{
GstFlowReturn result;
- GstRTPSession *rtpsession;
- GstRTPSessionPrivate *priv;
+ GstRtpSession *rtpsession;
+ GstRtpSessionPrivate *priv;
rtpsession = GST_RTP_SESSION (user_data);
priv = rtpsession->priv;
GstBuffer * buffer, gpointer user_data)
{
GstFlowReturn result;
- GstRTPSession *rtpsession;
- GstRTPSessionPrivate *priv;
+ GstRtpSession *rtpsession;
+ GstRtpSessionPrivate *priv;
rtpsession = GST_RTP_SESSION (user_data);
priv = rtpsession->priv;
gpointer user_data)
{
gint result = -1;
- GstRTPSession *rtpsession;
+ GstRtpSession *rtpsession;
GValue ret = { 0 };
GValue args[2] = { {0}, {0} };
GstCaps *caps;
gst_rtp_session_get_time (RTPSession * sess, gpointer user_data)
{
GstClockTime result;
- GstRTPSession *rtpsession;
+ GstRtpSession *rtpsession;
GstClock *clock;
rtpsession = GST_RTP_SESSION_CAST (user_data);
static void
gst_rtp_session_reconsider (RTPSession * sess, gpointer user_data)
{
- GstRTPSession *rtpsession;
+ GstRtpSession *rtpsession;
rtpsession = GST_RTP_SESSION_CAST (user_data);
static GstFlowReturn
gst_rtp_session_event_recv_rtp_sink (GstPad * pad, GstEvent * event)
{
- GstRTPSession *rtpsession;
- GstRTPSessionPrivate *priv;
+ GstRtpSession *rtpsession;
+ GstRtpSessionPrivate *priv;
gboolean ret = FALSE;
rtpsession = GST_RTP_SESSION (gst_pad_get_parent (pad));
static GstFlowReturn
gst_rtp_session_chain_recv_rtp (GstPad * pad, GstBuffer * buffer)
{
- GstRTPSession *rtpsession;
- GstRTPSessionPrivate *priv;
+ GstRtpSession *rtpsession;
+ GstRtpSessionPrivate *priv;
GstFlowReturn ret;
rtpsession = GST_RTP_SESSION (gst_pad_get_parent (pad));
static GstFlowReturn
gst_rtp_session_event_recv_rtcp_sink (GstPad * pad, GstEvent * event)
{
- GstRTPSession *rtpsession;
- GstRTPSessionPrivate *priv;
+ GstRtpSession *rtpsession;
+ GstRtpSessionPrivate *priv;
gboolean ret = FALSE;
rtpsession = GST_RTP_SESSION (gst_pad_get_parent (pad));
static GstFlowReturn
gst_rtp_session_chain_recv_rtcp (GstPad * pad, GstBuffer * buffer)
{
- GstRTPSession *rtpsession;
- GstRTPSessionPrivate *priv;
+ GstRtpSession *rtpsession;
+ GstRtpSessionPrivate *priv;
GstFlowReturn ret;
rtpsession = GST_RTP_SESSION (gst_pad_get_parent (pad));
static GstFlowReturn
gst_rtp_session_event_send_rtp_sink (GstPad * pad, GstEvent * event)
{
- GstRTPSession *rtpsession;
- GstRTPSessionPrivate *priv;
+ GstRtpSession *rtpsession;
+ GstRtpSessionPrivate *priv;
gboolean ret = FALSE;
rtpsession = GST_RTP_SESSION (gst_pad_get_parent (pad));
static GstFlowReturn
gst_rtp_session_chain_send_rtp (GstPad * pad, GstBuffer * buffer)
{
- GstRTPSession *rtpsession;
- GstRTPSessionPrivate *priv;
+ GstRtpSession *rtpsession;
+ GstRtpSessionPrivate *priv;
GstFlowReturn ret;
rtpsession = GST_RTP_SESSION (gst_pad_get_parent (pad));
* srcpad for the RTP packets.
*/
static GstPad *
-create_recv_rtp_sink (GstRTPSession * rtpsession)
+create_recv_rtp_sink (GstRtpSession * rtpsession)
{
GST_DEBUG_OBJECT (rtpsession, "creating RTP sink pad");
* sync_src pad for the SR packets.
*/
static GstPad *
-create_recv_rtcp_sink (GstRTPSession * rtpsession)
+create_recv_rtcp_sink (GstRtpSession * rtpsession)
{
GST_DEBUG_OBJECT (rtpsession, "creating RTCP sink pad");
* send_rtp_src pad.
*/
static GstPad *
-create_send_rtp_sink (GstRTPSession * rtpsession)
+create_send_rtp_sink (GstRtpSession * rtpsession)
{
GST_DEBUG_OBJECT (rtpsession, "creating pad");
* RTCP packets.
*/
static GstPad *
-create_send_rtcp_src (GstRTPSession * rtpsession)
+create_send_rtcp_src (GstRtpSession * rtpsession)
{
GST_DEBUG_OBJECT (rtpsession, "creating pad");
gst_rtp_session_request_new_pad (GstElement * element,
GstPadTemplate * templ, const gchar * name)
{
- GstRTPSession *rtpsession;
+ GstRtpSession *rtpsession;
GstElementClass *klass;
GstPad *result;
#define GST_TYPE_RTP_SESSION \
(gst_rtp_session_get_type())
#define GST_RTP_SESSION(obj) \
- (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_RTP_SESSION,GstRTPSession))
+ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_RTP_SESSION,GstRtpSession))
#define GST_RTP_SESSION_CLASS(klass) \
- (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_RTP_SESSION,GstRTPSessionClass))
+ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_RTP_SESSION,GstRtpSessionClass))
#define GST_IS_RTP_SESSION(obj) \
(G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_RTP_SESSION))
#define GST_IS_RTP_SESSION_CLASS(klass) \
(G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_RTP_SESSION))
-#define GST_RTP_SESSION_CAST(obj) ((GstRTPSession *)(obj))
+#define GST_RTP_SESSION_CAST(obj) ((GstRtpSession *)(obj))
-typedef struct _GstRTPSession GstRTPSession;
-typedef struct _GstRTPSessionClass GstRTPSessionClass;
-typedef struct _GstRTPSessionPrivate GstRTPSessionPrivate;
+typedef struct _GstRtpSession GstRtpSession;
+typedef struct _GstRtpSessionClass GstRtpSessionClass;
+typedef struct _GstRtpSessionPrivate GstRtpSessionPrivate;
-struct _GstRTPSession {
+struct _GstRtpSession {
GstElement element;
/*< private >*/
GstPad *send_rtp_src;
GstPad *send_rtcp_src;
- GstRTPSessionPrivate *priv;
+ GstRtpSessionPrivate *priv;
};
-struct _GstRTPSessionClass {
+struct _GstRtpSessionClass {
GstElementClass parent_class;
/* signals */
- GstCaps* (*request_pt_map) (GstRTPSession *sess, guint pt);
- void (*clear_pt_map) (GstRTPSession *sess);
+ GstCaps* (*request_pt_map) (GstRtpSession *sess, guint pt);
+ void (*clear_pt_map) (GstRtpSession *sess);
- void (*on_new_ssrc) (GstRTPSession *sess, guint32 ssrc);
- void (*on_ssrc_collision) (GstRTPSession *sess, guint32 ssrc);
- void (*on_ssrc_validated) (GstRTPSession *sess, guint32 ssrc);
- void (*on_bye_ssrc) (GstRTPSession *sess, guint32 ssrc);
- void (*on_bye_timeout) (GstRTPSession *sess, guint32 ssrc);
- void (*on_timeout) (GstRTPSession *sess, guint32 ssrc);
+ void (*on_new_ssrc) (GstRtpSession *sess, guint32 ssrc);
+ void (*on_ssrc_collision) (GstRtpSession *sess, guint32 ssrc);
+ void (*on_ssrc_validated) (GstRtpSession *sess, guint32 ssrc);
+ void (*on_bye_ssrc) (GstRtpSession *sess, guint32 ssrc);
+ void (*on_bye_timeout) (GstRtpSession *sess, guint32 ssrc);
+ void (*on_timeout) (GstRtpSession *sess, guint32 ssrc);
};
GType gst_rtp_session_get_type (void);
LAST_SIGNAL
};
-GST_BOILERPLATE (GstRTPSsrcDemux, gst_rtp_ssrc_demux, GstElement,
+GST_BOILERPLATE (GstRtpSsrcDemux, gst_rtp_ssrc_demux, GstElement,
GST_TYPE_ELEMENT);
/**
* Item for storing GstPad <-> SSRC pairs.
*/
-struct _GstRTPSsrcDemuxPad
+struct _GstRtpSsrcDemuxPad
{
GstPad *pad;
guint32 ssrc;
/* find a src pad for a given SSRC, returns NULL if the SSRC was not found
*/
static GstPad *
-find_rtp_pad_for_ssrc (GstRTPSsrcDemux * demux, guint32 ssrc)
+find_rtp_pad_for_ssrc (GstRtpSsrcDemux * demux, guint32 ssrc)
{
GSList *walk;
for (walk = demux->rtp_srcpads; walk; walk = g_slist_next (walk)) {
- GstRTPSsrcDemuxPad *pad = (GstRTPSsrcDemuxPad *) walk->data;
+ GstRtpSsrcDemuxPad *pad = (GstRtpSsrcDemuxPad *) walk->data;
if (pad->ssrc == ssrc)
return pad->pad;
}
static GstPad *
-create_rtp_pad_for_ssrc (GstRTPSsrcDemux * demux, guint32 ssrc)
+create_rtp_pad_for_ssrc (GstRtpSsrcDemux * demux, guint32 ssrc)
{
GstPad *result;
GstElementClass *klass;
GstPadTemplate *templ;
gchar *padname;
- GstRTPSsrcDemuxPad *demuxpad;
+ GstRtpSsrcDemuxPad *demuxpad;
klass = GST_ELEMENT_GET_CLASS (demux);
templ = gst_element_class_get_pad_template (klass, "src_%d");
g_free (padname);
/* wrap in structure and add to list */
- demuxpad = g_new0 (GstRTPSsrcDemuxPad, 1);
+ demuxpad = g_new0 (GstRtpSsrcDemuxPad, 1);
demuxpad->ssrc = ssrc;
demuxpad->pad = result;
demux->rtp_srcpads = g_slist_prepend (demux->rtp_srcpads, demuxpad);
}
static void
-gst_rtp_ssrc_demux_class_init (GstRTPSsrcDemuxClass * klass)
+gst_rtp_ssrc_demux_class_init (GstRtpSsrcDemuxClass * klass)
{
GObjectClass *gobject_klass;
GstElementClass *gstelement_klass;
gobject_klass->finalize = GST_DEBUG_FUNCPTR (gst_rtp_ssrc_demux_finalize);
/**
- * GstRTPSsrcDemux::new-ssrc-pad:
+ * GstRtpSsrcDemux::new-ssrc-pad:
* @demux: the object which received the signal
* @ssrc: the SSRC of the pad
* @pad: the new pad.
gst_rtp_ssrc_demux_signals[SIGNAL_NEW_SSRC_PAD] =
g_signal_new ("new-ssrc-pad",
G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (GstRTPSsrcDemuxClass, new_ssrc_pad),
+ G_STRUCT_OFFSET (GstRtpSsrcDemuxClass, new_ssrc_pad),
NULL, NULL, gst_rtp_bin_marshal_VOID__UINT_OBJECT,
G_TYPE_NONE, 2, G_TYPE_UINT, GST_TYPE_PAD);
}
static void
-gst_rtp_ssrc_demux_init (GstRTPSsrcDemux * demux,
- GstRTPSsrcDemuxClass * g_class)
+gst_rtp_ssrc_demux_init (GstRtpSsrcDemux * demux,
+ GstRtpSsrcDemuxClass * g_class)
{
GstElementClass *klass = GST_ELEMENT_GET_CLASS (demux);
static void
gst_rtp_ssrc_demux_finalize (GObject * object)
{
- GstRTPSsrcDemux *demux;
+ GstRtpSsrcDemux *demux;
demux = GST_RTP_SSRC_DEMUX (object);
static gboolean
gst_rtp_ssrc_demux_sink_event (GstPad * pad, GstEvent * event)
{
- GstRTPSsrcDemux *demux;
+ GstRtpSsrcDemux *demux;
gboolean res = FALSE;
demux = GST_RTP_SSRC_DEMUX (gst_pad_get_parent (pad));
gst_rtp_ssrc_demux_chain (GstPad * pad, GstBuffer * buf)
{
GstFlowReturn ret;
- GstRTPSsrcDemux *demux;
+ GstRtpSsrcDemux *demux;
guint32 ssrc;
GstPad *srcpad;
static gboolean
gst_rtp_ssrc_demux_src_event (GstPad * pad, GstEvent * event)
{
- GstRTPSsrcDemux *demux;
+ GstRtpSsrcDemux *demux;
gboolean res = FALSE;
demux = GST_RTP_SSRC_DEMUX (gst_pad_get_parent (pad));
GstStateChange transition)
{
GstStateChangeReturn ret;
- GstRTPSsrcDemux *demux;
+ GstRtpSsrcDemux *demux;
demux = GST_RTP_SSRC_DEMUX (element);
#include <gst/gst.h>
#define GST_TYPE_RTP_SSRC_DEMUX (gst_rtp_ssrc_demux_get_type())
-#define GST_RTP_SSRC_DEMUX(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_RTP_SSRC_DEMUX,GstRTPSsrcDemux))
-#define GST_RTP_SSRC_DEMUX_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_RTP_SSRC_DEMUX,GstRTPSsrcDemuxClass))
+#define GST_RTP_SSRC_DEMUX(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_RTP_SSRC_DEMUX,GstRtpSsrcDemux))
+#define GST_RTP_SSRC_DEMUX_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_RTP_SSRC_DEMUX,GstRtpSsrcDemuxClass))
#define GST_IS_RTP_SSRC_DEMUX(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_RTP_SSRC_DEMUX))
#define GST_IS_RTP_SSRC_DEMUX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_RTP_SSRC_DEMUX))
-typedef struct _GstRTPSsrcDemux GstRTPSsrcDemux;
-typedef struct _GstRTPSsrcDemuxClass GstRTPSsrcDemuxClass;
-typedef struct _GstRTPSsrcDemuxPad GstRTPSsrcDemuxPad;
+typedef struct _GstRtpSsrcDemux GstRtpSsrcDemux;
+typedef struct _GstRtpSsrcDemuxClass GstRtpSsrcDemuxClass;
+typedef struct _GstRtpSsrcDemuxPad GstRtpSsrcDemuxPad;
-struct _GstRTPSsrcDemux
+struct _GstRtpSsrcDemux
{
GstElement parent;
GSList *rtp_srcpads;
};
-struct _GstRTPSsrcDemuxClass
+struct _GstRtpSsrcDemuxClass
{
GstElementClass parent_class;
projects / platform / upstream / gst-plugins-good.git / commitdiff