/* 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;
}
}
/**
* This funcion will push out buffers on the source pad.
*
* For each pushed buffer, the seqnum is recorded, if the next buffer B has a
* different seqnum (missing packets before B), this function will wait for the
* missing packet to arrive up to the timestamp of buffer B.
*/
static void
gst_rtp_jitter_buffer_loop (GstRtpJitterBuffer * jitterbuffer)
{
GstRtpJitterBufferPrivate *priv;
GstBuffer *outbuf;
GstFlowReturn result;
guint16 seqnum;
guint32 next_seqnum;
GstClockTime timestamp, out_time;
gboolean discont = FALSE;
gint gap;
priv = jitterbuffer->priv;
JBUF_LOCK_CHECK (priv, flushing);
again:
GST_DEBUG_OBJECT (jitterbuffer, "Peeking item");
while (TRUE) {
/* always wait if we are blocked */
if (!priv->blocked) {
/* if we have a packet, we can exit the loop and grab it */
if (rtp_jitter_buffer_num_packets (priv->jbuf) > 0)
break;
/* no packets but we are EOS, do eos logic */
if (priv->eos)
goto do_eos;
}
/* underrun, wait for packets or flushing now */
priv->waiting = TRUE;
JBUF_WAIT_CHECK (priv, flushing);
priv->waiting = FALSE;
}
/* peek a buffer, we're just looking at the timestamp and the sequence number.
* If all is fine, we'll pop and push it. If the sequence number is wrong we
* wait on the timestamp. In the chain function we will unlock the wait when a
* new buffer is available. The peeked buffer is valid for as long as we hold
* the jitterbuffer lock. */
outbuf = rtp_jitter_buffer_peek (priv->jbuf);
/* get the seqnum and the next expected seqnum */
seqnum = gst_rtp_buffer_get_seq (outbuf);
next_seqnum = priv->next_seqnum;
/* get the timestamp, this is already corrected for clock skew by the
* jitterbuffer */
timestamp = GST_BUFFER_TIMESTAMP (outbuf);
GST_DEBUG_OBJECT (jitterbuffer,
"Peeked buffer #%d, expect #%d, timestamp %" GST_TIME_FORMAT
", now %d left", seqnum, next_seqnum, GST_TIME_ARGS (timestamp),
rtp_jitter_buffer_num_packets (priv->jbuf));
/* apply our timestamp offset to the incomming buffer, this will be our output
* timestamp. */
out_time = apply_offset (jitterbuffer, timestamp);
/* get the gap between this and the previous packet. If we don't know the
* previous packet seqnum assume no gap. */
if (next_seqnum != -1) {
gap = gst_rtp_buffer_compare_seqnum (next_seqnum, seqnum);
/* if we have a packet that we already pushed or considered dropped, pop it
* off and get the next packet */
if (gap < 0) {
GST_DEBUG_OBJECT (jitterbuffer, "Old packet #%d, next #%d dropping",
seqnum, next_seqnum);
outbuf = rtp_jitter_buffer_pop (priv->jbuf);
gst_buffer_unref (outbuf);
goto again;
}
} else {
GST_DEBUG_OBJECT (jitterbuffer, "no next seqnum known, first packet");
gap = -1;
}
/* If we don't know what the next seqnum should be (== -1) we have to wait
* because it might be possible that we are not receiving this buffer in-order,
* a buffer with a lower seqnum could arrive later and we want to push that
* earlier buffer before this buffer then.
* If we know the expected seqnum, we can compare it to the current seqnum to
* determine if we have missing a packet. If we have a missing packet (which
* must be before this packet) we can wait for it until the deadline for this
* packet expires. */
if (gap != 0 && out_time != -1) {
GstClockID id;
GstClockTime sync_time;
GstClockReturn ret;
GstClock *clock;
GstClockTime duration = GST_CLOCK_TIME_NONE;
if (gap > 0) {
/* we have a gap */
GST_WARNING_OBJECT (jitterbuffer,
"Sequence number GAP detected: expected %d instead of %d (%d missing)",
next_seqnum, seqnum, gap);
if (priv->last_out_time != -1) {
GST_DEBUG_OBJECT (jitterbuffer,
"out_time %" GST_TIME_FORMAT ", last %" GST_TIME_FORMAT,
GST_TIME_ARGS (out_time), GST_TIME_ARGS (priv->last_out_time));
/* interpolate between the current time and the last time based on
* number of packets we are missing, this is the estimated duration
* for the missing packet based on equidistant packet spacing. Also make
* sure we never go negative. */
if (out_time > priv->last_out_time)
duration = (out_time - priv->last_out_time) / (gap + 1);
else
goto lost;
GST_DEBUG_OBJECT (jitterbuffer, "duration %" GST_TIME_FORMAT,
GST_TIME_ARGS (duration));
/* add this duration to the timestamp of the last packet we pushed */
out_time = (priv->last_out_time + duration);
}
} else {
/* we don't know what the next_seqnum should be, wait for the last
* possible moment to push this buffer, maybe we get an earlier seqnum
* while we wait */
GST_DEBUG_OBJECT (jitterbuffer, "First buffer %d, do sync", seqnum);
}
GST_OBJECT_LOCK (jitterbuffer);
clock = GST_ELEMENT_CLOCK (jitterbuffer);
if (!clock) {
GST_OBJECT_UNLOCK (jitterbuffer);
/* let's just push if there is no clock */
goto push_buffer;
}
GST_DEBUG_OBJECT (jitterbuffer, "sync to timestamp %" GST_TIME_FORMAT,
GST_TIME_ARGS (out_time));
/* prepare for sync against clock */
sync_time = out_time + GST_ELEMENT_CAST (jitterbuffer)->base_time;
/* add latency, this includes our own latency and the peer latency. */
sync_time += (priv->latency_ms * GST_MSECOND);
sync_time += priv->peer_latency;
/* create an entry for the clock */
id = priv->clock_id = gst_clock_new_single_shot_id (clock, sync_time);
GST_OBJECT_UNLOCK (jitterbuffer);
/* release the lock so that the other end can push stuff or unlock */
JBUF_UNLOCK (priv);
ret = gst_clock_id_wait (id, NULL);
JBUF_LOCK (priv);
/* and free the entry */
gst_clock_id_unref (id);
priv->clock_id = NULL;
/* at this point, the clock could have been unlocked by a timeout, a new
* tail element was added to the queue or because we are shutting down. Check
* for shutdown first. */
if (priv->srcresult != GST_FLOW_OK)
goto flushing;
/* if we got unscheduled and we are not flushing, it's because a new tail
* element became available in the queue. Grab it and try to push or sync. */
if (ret == GST_CLOCK_UNSCHEDULED) {
GST_DEBUG_OBJECT (jitterbuffer,
"Wait got unscheduled, will retry to push with new buffer");
goto again;
}
lost:
/* we now timed out, this means we lost a packet or finished synchronizing
* on the first buffer. */
if (gap > 0) {
GstEvent *event;
/* we had a gap and thus we lost a packet. Create an event for this. */
GST_DEBUG_OBJECT (jitterbuffer, "Packet #%d lost", next_seqnum);
priv->num_late++;
discont = TRUE;
if (priv->do_lost) {
/* create paket lost event */
event = gst_event_new_custom (GST_EVENT_CUSTOM_DOWNSTREAM,
gst_structure_new ("GstRTPPacketLost",
"seqnum", G_TYPE_UINT, (guint) next_seqnum,
"timestamp", G_TYPE_UINT64, out_time,
"duration", G_TYPE_UINT64, duration, NULL));
gst_pad_push_event (priv->srcpad, event);
}
/* update our expected next packet */
priv->last_popped_seqnum = next_seqnum;
priv->last_out_time = out_time;
priv->next_seqnum = (next_seqnum + 1) & 0xffff;
/* look for next packet */
goto again;
}
/* there was no known gap,just the first packet, exit the loop and push */
GST_DEBUG_OBJECT (jitterbuffer, "First packet #%d synced", seqnum);
/* get new timestamp, latency might have changed */
out_time = apply_offset (jitterbuffer, timestamp);
}
push_buffer:
/* when we get here we are ready to pop and push the buffer */
outbuf = rtp_jitter_buffer_pop (priv->jbuf);
if (discont || priv->discont) {
/* set DISCONT flag when we missed a packet. */
outbuf = gst_buffer_make_metadata_writable (outbuf);
GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_DISCONT);
priv->discont = FALSE;
}
/* apply timestamp with offset to buffer now */
GST_BUFFER_TIMESTAMP (outbuf) = out_time;
/* now we are ready to push the buffer. Save the seqnum and release the lock
* so the other end can push stuff in the queue again. */
priv->last_popped_seqnum = seqnum;
priv->last_out_time = out_time;
priv->next_seqnum = (seqnum + 1) & 0xffff;
JBUF_UNLOCK (priv);
/* push buffer */
GST_DEBUG_OBJECT (jitterbuffer,
"Pushing buffer %d, timestamp %" GST_TIME_FORMAT, seqnum,
GST_TIME_ARGS (out_time));
result = gst_pad_push (priv->srcpad, outbuf);
if (result != GST_FLOW_OK)
goto pause;
return;
/* ERRORS */
do_eos:
{
/* store result, we are flushing now */
GST_DEBUG_OBJECT (jitterbuffer, "We are EOS, pushing EOS downstream");
priv->srcresult = GST_FLOW_UNEXPECTED;
gst_pad_pause_task (priv->srcpad);
gst_pad_push_event (priv->srcpad, gst_event_new_eos ());
JBUF_UNLOCK (priv);
return;
}
flushing:
{
GST_DEBUG_OBJECT (jitterbuffer, "we are flushing");
gst_pad_pause_task (priv->srcpad);
JBUF_UNLOCK (priv);
return;
}
pause:
{
const gchar *reason = gst_flow_get_name (result);
GST_DEBUG_OBJECT (jitterbuffer, "pausing task, reason %s", reason);
JBUF_LOCK (priv);
/* store result */
priv->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 (priv->srcpad);
JBUF_UNLOCK (priv);
return;
}
}