static gboolean
gst_rdt_manager_event_rdt (GstPad * pad, GstObject * parent, GstEvent * event)
{
GstRDTManager *rdtmanager;
GstRDTManagerSession *session;
gboolean res;
rdtmanager = GST_RDT_MANAGER (parent);
/* find session */
session = gst_pad_get_element_private (pad);
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_CAPS:
{
GstCaps *caps;
gst_event_parse_caps (event, &caps);
res = gst_rdt_manager_parse_caps (rdtmanager, session, caps);
gst_event_unref (event);
break;
}
default:
res = gst_pad_event_default (pad, parent, event);
break;
}
return res;
}
static GstPad *
gst_rdt_manager_request_new_pad (GstElement * element,
GstPadTemplate * templ, const gchar * name, const GstCaps * caps)
{
GstRDTManager *rdtmanager;
GstElementClass *klass;
GstPad *result;
g_return_val_if_fail (templ != NULL, NULL);
g_return_val_if_fail (GST_IS_RDT_MANAGER (element), NULL);
rdtmanager = GST_RDT_MANAGER (element);
klass = GST_ELEMENT_GET_CLASS (element);
/* figure out the template */
if (templ == gst_element_class_get_pad_template (klass, "recv_rtp_sink_%u")) {
result = create_recv_rtp (rdtmanager, templ, name);
} else if (templ == gst_element_class_get_pad_template (klass,
"recv_rtcp_sink_%u")) {
result = create_recv_rtcp (rdtmanager, templ, name);
} else if (templ == gst_element_class_get_pad_template (klass, "rtcp_src_%u")) {
result = create_rtcp (rdtmanager, templ, name);
} else
goto wrong_template;
return result;
/* ERRORS */
wrong_template:
{
g_warning ("rdtmanager: this is not our template");
return NULL;
}
}
static gboolean
gst_rdt_manager_query_src (GstPad * pad, GstObject * parent, GstQuery * query)
{
GstRDTManager *rdtmanager;
gboolean res;
rdtmanager = GST_RDT_MANAGER (parent);
switch (GST_QUERY_TYPE (query)) {
case GST_QUERY_LATENCY:
{
GstClockTime latency;
latency = rdtmanager->latency * GST_MSECOND;
/* we pretend to be live with a 3 second latency */
gst_query_set_latency (query, TRUE, latency, -1);
GST_DEBUG_OBJECT (rdtmanager, "reporting %" GST_TIME_FORMAT " of latency",
GST_TIME_ARGS (latency));
res = TRUE;
break;
}
default:
res = gst_pad_query_default (pad, parent, query);
break;
}
return res;
}
static GstStateChangeReturn
gst_rdt_manager_change_state (GstElement * element, GstStateChange transition)
{
GstStateChangeReturn ret;
GstRDTManager *rdtmanager;
rdtmanager = GST_RDT_MANAGER (element);
switch (transition) {
default:
break;
}
ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
switch (transition) {
case GST_STATE_CHANGE_READY_TO_PAUSED:
case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
/* we're NO_PREROLL when going to PAUSED */
ret = GST_STATE_CHANGE_NO_PREROLL;
break;
default:
break;
}
return ret;
}
static GstClock *
gst_rdt_manager_provide_clock (GstElement * element)
{
GstRDTManager *rdtmanager;
rdtmanager = GST_RDT_MANAGER (element);
return GST_CLOCK_CAST (gst_object_ref (rdtmanager->provided_clock));
}
static void
gst_rdt_manager_finalize (GObject * object)
{
GstRDTManager *rdtmanager;
rdtmanager = GST_RDT_MANAGER (object);
g_slist_foreach (rdtmanager->sessions, (GFunc) free_session, NULL);
g_slist_free (rdtmanager->sessions);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static gboolean
gst_rdt_manager_setcaps (GstPad * pad, GstCaps * caps)
{
GstRDTManager *rdtmanager;
GstRDTManagerSession *session;
gboolean res;
rdtmanager = GST_RDT_MANAGER (GST_PAD_PARENT (pad));
/* find session */
session = gst_pad_get_element_private (pad);
res = gst_rdt_manager_parse_caps (rdtmanager, session, caps);
return res;
}
static void
gst_rdt_manager_get_property (GObject * object, guint prop_id, GValue * value,
GParamSpec * pspec)
{
GstRDTManager *src;
src = GST_RDT_MANAGER (object);
switch (prop_id) {
case PROP_LATENCY:
g_value_set_uint (value, src->latency);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static GstFlowReturn
gst_rdt_manager_chain_rtcp (GstPad * pad, GstObject * parent,
GstBuffer * buffer)
{
GstRDTManager *src;
#ifdef HAVE_RTCP
gboolean valid;
GstRTCPPacket packet;
gboolean more;
#endif
src = GST_RDT_MANAGER (parent);
GST_DEBUG_OBJECT (src, "got rtcp packet");
#ifdef HAVE_RTCP
valid = gst_rtcp_buffer_validate (buffer);
if (!valid)
goto bad_packet;
/* position on first packet */
more = gst_rtcp_buffer_get_first_packet (buffer, &packet);
while (more) {
switch (gst_rtcp_packet_get_type (&packet)) {
case GST_RTCP_TYPE_SR:
{
guint32 ssrc, rtptime, packet_count, octet_count;
guint64 ntptime;
guint count, i;
gst_rtcp_packet_sr_get_sender_info (&packet, &ssrc, &ntptime, &rtptime,
&packet_count, &octet_count);
GST_DEBUG_OBJECT (src,
"got SR packet: SSRC %08x, NTP %" G_GUINT64_FORMAT
", RTP %u, PC %u, OC %u", ssrc, ntptime, rtptime, packet_count,
octet_count);
count = gst_rtcp_packet_get_rb_count (&packet);
for (i = 0; i < count; i++) {
guint32 ssrc, exthighestseq, jitter, lsr, dlsr;
guint8 fractionlost;
gint32 packetslost;
gst_rtcp_packet_get_rb (&packet, i, &ssrc, &fractionlost,
&packetslost, &exthighestseq, &jitter, &lsr, &dlsr);
GST_DEBUG_OBJECT (src, "got RB packet %d: SSRC %08x, FL %u"
", PL %u, HS %u, JITTER %u, LSR %u, DLSR %u", ssrc, fractionlost,
packetslost, exthighestseq, jitter, lsr, dlsr);
}
break;
}
case GST_RTCP_TYPE_RR:
{
guint32 ssrc;
guint count, i;
ssrc = gst_rtcp_packet_rr_get_ssrc (&packet);
GST_DEBUG_OBJECT (src, "got RR packet: SSRC %08x", ssrc);
count = gst_rtcp_packet_get_rb_count (&packet);
for (i = 0; i < count; i++) {
guint32 ssrc, exthighestseq, jitter, lsr, dlsr;
guint8 fractionlost;
gint32 packetslost;
gst_rtcp_packet_get_rb (&packet, i, &ssrc, &fractionlost,
&packetslost, &exthighestseq, &jitter, &lsr, &dlsr);
GST_DEBUG_OBJECT (src, "got RB packet %d: SSRC %08x, FL %u"
", PL %u, HS %u, JITTER %u, LSR %u, DLSR %u", ssrc, fractionlost,
packetslost, exthighestseq, jitter, lsr, dlsr);
}
break;
}
case GST_RTCP_TYPE_SDES:
{
guint chunks, i, j;
gboolean more_chunks, more_items;
chunks = gst_rtcp_packet_sdes_get_chunk_count (&packet);
GST_DEBUG_OBJECT (src, "got SDES packet with %d chunks", chunks);
more_chunks = gst_rtcp_packet_sdes_first_chunk (&packet);
i = 0;
while (more_chunks) {
guint32 ssrc;
ssrc = gst_rtcp_packet_sdes_get_ssrc (&packet);
GST_DEBUG_OBJECT (src, "chunk %d, SSRC %08x", i, ssrc);
more_items = gst_rtcp_packet_sdes_first_item (&packet);
j = 0;
while (more_items) {
GstRTCPSDESType type;
guint8 len;
gchar *data;
gst_rtcp_packet_sdes_get_item (&packet, &type, &len, &data);
GST_DEBUG_OBJECT (src, "item %d, type %d, len %d, data %s", j,
type, len, data);
more_items = gst_rtcp_packet_sdes_next_item (&packet);
j++;
}
more_chunks = gst_rtcp_packet_sdes_next_chunk (&packet);
i++;
}
break;
}
case GST_RTCP_TYPE_BYE:
{
guint count, i;
gchar *reason;
reason = gst_rtcp_packet_bye_get_reason (&packet);
GST_DEBUG_OBJECT (src, "got BYE packet (reason: %s)",
GST_STR_NULL (reason));
g_free (reason);
count = gst_rtcp_packet_bye_get_ssrc_count (&packet);
for (i = 0; i < count; i++) {
guint32 ssrc;
ssrc = gst_rtcp_packet_bye_get_nth_ssrc (&packet, i);
GST_DEBUG_OBJECT (src, "SSRC: %08x", ssrc);
}
break;
}
case GST_RTCP_TYPE_APP:
GST_DEBUG_OBJECT (src, "got APP packet");
break;
default:
GST_WARNING_OBJECT (src, "got unknown RTCP packet");
break;
}
more = gst_rtcp_packet_move_to_next (&packet);
}
gst_buffer_unref (buffer);
return GST_FLOW_OK;
bad_packet:
{
GST_WARNING_OBJECT (src, "got invalid RTCP packet");
return GST_FLOW_OK;
}
#else
return GST_FLOW_OK;
#endif
}
/* push packets from the queue to the downstream demuxer */
static void
gst_rdt_manager_loop (GstPad * pad)
{
GstRDTManager *rdtmanager;
GstRDTManagerSession *session;
GstBuffer *buffer;
GstFlowReturn result;
rdtmanager = GST_RDT_MANAGER (GST_PAD_PARENT (pad));
session = gst_pad_get_element_private (pad);
JBUF_LOCK_CHECK (session, flushing);
GST_DEBUG_OBJECT (rdtmanager, "Peeking item");
while (TRUE) {
/* always wait if we are blocked */
if (!session->blocked) {
/* if we have a packet, we can exit the loop and grab it */
if (rdt_jitter_buffer_num_packets (session->jbuf) > 0)
break;
/* no packets but we are EOS, do eos logic */
if (session->eos)
goto do_eos;
}
/* underrun, wait for packets or flushing now */
session->waiting = TRUE;
JBUF_WAIT_CHECK (session, flushing);
session->waiting = FALSE;
}
buffer = rdt_jitter_buffer_pop (session->jbuf);
GST_DEBUG_OBJECT (rdtmanager, "Got item %p", buffer);
if (session->discont) {
GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DISCONT);
session->discont = FALSE;
}
JBUF_UNLOCK (session);
result = gst_pad_push (session->recv_rtp_src, buffer);
if (result != GST_FLOW_OK)
goto pause;
return;
/* ERRORS */
flushing:
{
GST_DEBUG_OBJECT (rdtmanager, "we are flushing");
gst_pad_pause_task (session->recv_rtp_src);
JBUF_UNLOCK (session);
return;
}
do_eos:
{
/* store result, we are flushing now */
GST_DEBUG_OBJECT (rdtmanager, "We are EOS, pushing EOS downstream");
session->srcresult = GST_FLOW_EOS;
gst_pad_pause_task (session->recv_rtp_src);
gst_pad_push_event (session->recv_rtp_src, gst_event_new_eos ());
JBUF_UNLOCK (session);
return;
}
pause:
{
GST_DEBUG_OBJECT (rdtmanager, "pausing task, reason %s",
gst_flow_get_name (result));
JBUF_LOCK (session);
/* store result */
session->srcresult = result;
/* we don't post errors or anything because upstream will do that for us
* when we pass the return value upstream. */
gst_pad_pause_task (session->recv_rtp_src);
JBUF_UNLOCK (session);
return;
}
}
static GstFlowReturn
gst_rdt_manager_chain_rdt (GstPad * pad, GstObject * parent, GstBuffer * buffer)
{
GstFlowReturn res;
GstRDTManager *rdtmanager;
GstRDTManagerSession *session;
GstClockTime timestamp;
GstRDTPacket packet;
guint32 ssrc;
guint8 pt;
gboolean more;
rdtmanager = GST_RDT_MANAGER (parent);
GST_DEBUG_OBJECT (rdtmanager, "got RDT packet");
ssrc = 0;
pt = 0;
GST_DEBUG_OBJECT (rdtmanager, "SSRC %08x, PT %d", ssrc, pt);
/* find session */
session = gst_pad_get_element_private (pad);
/* see if we have the pad */
if (!session->active) {
activate_session (rdtmanager, session, ssrc, pt);
session->active = TRUE;
}
if (GST_BUFFER_IS_DISCONT (buffer)) {
GST_DEBUG_OBJECT (rdtmanager, "received discont");
session->discont = TRUE;
}
res = GST_FLOW_OK;
/* take the timestamp of the buffer. This is the time when the packet was
* received and is used to calculate jitter and clock skew. We will adjust
* this timestamp with the smoothed value after processing it in the
* jitterbuffer. */
timestamp = GST_BUFFER_TIMESTAMP (buffer);
/* bring to running time */
timestamp = gst_segment_to_running_time (&session->segment, GST_FORMAT_TIME,
timestamp);
more = gst_rdt_buffer_get_first_packet (buffer, &packet);
while (more) {
GstRDTType type;
type = gst_rdt_packet_get_type (&packet);
GST_DEBUG_OBJECT (rdtmanager, "Have packet of type %04x", type);
if (GST_RDT_IS_DATA_TYPE (type)) {
GST_DEBUG_OBJECT (rdtmanager, "We have a data packet");
res = gst_rdt_manager_handle_data_packet (session, timestamp, &packet);
} else {
switch (type) {
default:
GST_DEBUG_OBJECT (rdtmanager, "Ignoring packet");
break;
}
}
if (res != GST_FLOW_OK)
break;
more = gst_rdt_packet_move_to_next (&packet);
}
gst_buffer_unref (buffer);
return res;
}
