static void kms_rtp_synchronizer_process_rtcp_packet (KmsRtpSynchronizer * self, GstRTCPPacket * packet, GstClockTime current_time) { GstRTCPType type; guint32 ssrc, rtp_time; guint64 ntp_time, ntp_ns_time; type = gst_rtcp_packet_get_type (packet); GST_DEBUG_OBJECT (self, "Received RTCP buffer of type: %d", type); if (type != GST_RTCP_TYPE_SR) { return; } gst_rtcp_packet_sr_get_sender_info (packet, &ssrc, &ntp_time, &rtp_time, NULL, NULL); /* convert ntp_time to nanoseconds */ ntp_ns_time = gst_util_uint64_scale (ntp_time, GST_SECOND, (G_GINT64_CONSTANT (1) << 32)); KMS_RTP_SYNCHRONIZER_LOCK (self); GST_DEBUG_OBJECT (self, "Received RTCP SR packet SSRC: %u, rtp_time: %u, ntp_time: %" G_GUINT64_FORMAT ", ntp_ns_time: %" GST_TIME_FORMAT, ssrc, rtp_time, ntp_time, GST_TIME_ARGS (ntp_ns_time)); if (!self->priv->base_initiated) { kms_rtp_sync_context_get_time_matching (self->priv->context, ntp_ns_time, current_time, &self->priv->base_ntp_ns_time, &self->priv->base_sync_time); self->priv->base_initiated = TRUE; } self->priv->last_sr_ext_ts = gst_rtp_buffer_ext_timestamp (&self->priv->ext_ts, rtp_time); self->priv->last_sr_ntp_ns_time = ntp_ns_time; KMS_RTP_SYNCHRONIZER_UNLOCK (self); }
/* For the clock skew we use a windowed low point averaging algorithm as can be * found in http://www.grame.fr/pub/TR-050601.pdf. The idea is that the jitter is * composed of: * * J = N + n * * N : a constant network delay. * n : random added noise. The noise is concentrated around 0 * * In the receiver we can track the elapsed time at the sender with: * * send_diff(i) = (Tsi - Ts0); * * Tsi : The time at the sender at packet i * Ts0 : The time at the sender at the first packet * * This is the difference between the RTP timestamp in the first received packet * and the current packet. * * At the receiver we have to deal with the jitter introduced by the network. * * recv_diff(i) = (Tri - Tr0) * * Tri : The time at the receiver at packet i * Tr0 : The time at the receiver at the first packet * * Both of these values contain a jitter Ji, a jitter for packet i, so we can * write: * * recv_diff(i) = (Cri + D + ni) - (Cr0 + D + n0)) * * Cri : The time of the clock at the receiver for packet i * D + ni : The jitter when receiving packet i * * We see that the network delay is irrelevant here as we can elliminate D: * * recv_diff(i) = (Cri + ni) - (Cr0 + n0)) * * The drift is now expressed as: * * Drift(i) = recv_diff(i) - send_diff(i); * * We now keep the W latest values of Drift and find the minimum (this is the * one with the lowest network jitter and thus the one which is least affected * by it). We average this lowest value to smooth out the resulting network skew. * * Both the window and the weighting used for averaging influence the accuracy * of the drift estimation. Finding the correct parameters turns out to be a * compromise between accuracy and inertia. * * We use a 2 second window or up to 512 data points, which is statistically big * enough to catch spikes (FIXME, detect spikes). * We also use a rather large weighting factor (125) to smoothly adapt. During * startup, when filling the window, we use a parabolic weighting factor, the * more the window is filled, the faster we move to the detected possible skew. * * Returns: @time adjusted with the clock skew. */ static GstClockTime calculate_skew (RTPJitterBuffer * jbuf, guint32 rtptime, GstClockTime time, guint32 clock_rate, GstClockTime max_delay) { guint64 ext_rtptime; guint64 send_diff, recv_diff; gint64 delta; gint64 old; gint pos, i; GstClockTime gstrtptime, out_time; guint64 slope; ext_rtptime = gst_rtp_buffer_ext_timestamp (&jbuf->ext_rtptime, rtptime); gstrtptime = gst_util_uint64_scale_int (ext_rtptime, GST_SECOND, clock_rate); /* keep track of the last extended rtptime */ jbuf->last_rtptime = ext_rtptime; if (jbuf->clock_rate != clock_rate) { if (jbuf->clock_rate == -1) { GST_DEBUG ("Clock rate changed from %" G_GUINT32_FORMAT " to %" G_GUINT32_FORMAT, jbuf->clock_rate, clock_rate); } else { GST_WARNING ("Clock rate changed from %" G_GUINT32_FORMAT " to %" G_GUINT32_FORMAT, jbuf->clock_rate, clock_rate); } jbuf->base_time = -1; jbuf->base_rtptime = -1; jbuf->clock_rate = clock_rate; jbuf->prev_out_time = -1; jbuf->prev_send_diff = -1; } /* first time, lock on to time and gstrtptime */ if (G_UNLIKELY (jbuf->base_time == -1)) { jbuf->base_time = time; jbuf->prev_out_time = -1; GST_DEBUG ("Taking new base time %" GST_TIME_FORMAT, GST_TIME_ARGS (time)); } if (G_UNLIKELY (jbuf->base_rtptime == -1)) { jbuf->base_rtptime = gstrtptime; jbuf->base_extrtp = ext_rtptime; jbuf->prev_send_diff = -1; GST_DEBUG ("Taking new base rtptime %" GST_TIME_FORMAT, GST_TIME_ARGS (gstrtptime)); } if (G_LIKELY (gstrtptime >= jbuf->base_rtptime)) send_diff = gstrtptime - jbuf->base_rtptime; else { /* elapsed time at sender, timestamps can go backwards and thus be smaller * than our base time, take a new base time in that case. */ GST_WARNING ("backward timestamps at server, taking new base time"); rtp_jitter_buffer_resync (jbuf, time, gstrtptime, ext_rtptime, FALSE); send_diff = 0; } GST_DEBUG ("extrtp %" G_GUINT64_FORMAT ", gstrtp %" GST_TIME_FORMAT ", base %" GST_TIME_FORMAT ", send_diff %" GST_TIME_FORMAT, ext_rtptime, GST_TIME_ARGS (gstrtptime), GST_TIME_ARGS (jbuf->base_rtptime), GST_TIME_ARGS (send_diff)); /* we don't have an arrival timestamp so we can't do skew detection. we * should still apply a timestamp based on RTP timestamp and base_time */ if (time == -1 || jbuf->base_time == -1) goto no_skew; /* elapsed time at receiver, includes the jitter */ recv_diff = time - jbuf->base_time; /* measure the diff */ delta = ((gint64) recv_diff) - ((gint64) send_diff); /* measure the slope, this gives a rought estimate between the sender speed * and the receiver speed. This should be approximately 8, higher values * indicate a burst (especially when the connection starts) */ if (recv_diff > 0) slope = (send_diff * 8) / recv_diff; else slope = 8; GST_DEBUG ("time %" GST_TIME_FORMAT ", base %" GST_TIME_FORMAT ", recv_diff %" GST_TIME_FORMAT ", slope %" G_GUINT64_FORMAT, GST_TIME_ARGS (time), GST_TIME_ARGS (jbuf->base_time), GST_TIME_ARGS (recv_diff), slope); /* if the difference between the sender timeline and the receiver timeline * changed too quickly we have to resync because the server likely restarted * its timestamps. */ if (ABS (delta - jbuf->skew) > GST_SECOND) { GST_WARNING ("delta - skew: %" GST_TIME_FORMAT " too big, reset skew", GST_TIME_ARGS (delta - jbuf->skew)); rtp_jitter_buffer_resync (jbuf, time, gstrtptime, ext_rtptime, TRUE); send_diff = 0; delta = 0; } pos = jbuf->window_pos; if (G_UNLIKELY (jbuf->window_filling)) { /* we are filling the window */ GST_DEBUG ("filling %d, delta %" G_GINT64_FORMAT, pos, delta); jbuf->window[pos++] = delta; /* calc the min delta we observed */ if (G_UNLIKELY (pos == 1 || delta < jbuf->window_min)) jbuf->window_min = delta; if (G_UNLIKELY (send_diff >= MAX_TIME || pos >= MAX_WINDOW)) { jbuf->window_size = pos; /* window filled */ GST_DEBUG ("min %" G_GINT64_FORMAT, jbuf->window_min); /* the skew is now the min */ jbuf->skew = jbuf->window_min; jbuf->window_filling = FALSE; } else { gint perc_time, perc_window, perc; /* figure out how much we filled the window, this depends on the amount of * time we have or the max number of points we keep. */ perc_time = send_diff * 100 / MAX_TIME; perc_window = pos * 100 / MAX_WINDOW; perc = MAX (perc_time, perc_window); /* make a parabolic function, the closer we get to the MAX, the more value * we give to the scaling factor of the new value */ perc = perc * perc; /* quickly go to the min value when we are filling up, slowly when we are * just starting because we're not sure it's a good value yet. */ jbuf->skew = (perc * jbuf->window_min + ((10000 - perc) * jbuf->skew)) / 10000; jbuf->window_size = pos + 1; } } else { /* pick old value and store new value. We keep the previous value in order * to quickly check if the min of the window changed */ old = jbuf->window[pos]; jbuf->window[pos++] = delta; if (G_UNLIKELY (delta <= jbuf->window_min)) { /* if the new value we inserted is smaller or equal to the current min, * it becomes the new min */ jbuf->window_min = delta; } else if (G_UNLIKELY (old == jbuf->window_min)) { gint64 min = G_MAXINT64; /* if we removed the old min, we have to find a new min */ for (i = 0; i < jbuf->window_size; i++) { /* we found another value equal to the old min, we can stop searching now */ if (jbuf->window[i] == old) { min = old; break; } if (jbuf->window[i] < min) min = jbuf->window[i]; } jbuf->window_min = min; } /* average the min values */ jbuf->skew = (jbuf->window_min + (124 * jbuf->skew)) / 125; GST_DEBUG ("delta %" G_GINT64_FORMAT ", new min: %" G_GINT64_FORMAT, delta, jbuf->window_min); } /* wrap around in the window */ if (G_UNLIKELY (pos >= jbuf->window_size)) pos = 0; jbuf->window_pos = pos; no_skew: /* the output time is defined as the base timestamp plus the RTP time * adjusted for the clock skew .*/ if (jbuf->base_time != -1) { out_time = jbuf->base_time + send_diff; /* skew can be negative and we don't want to make invalid timestamps */ if (jbuf->skew < 0 && out_time < -jbuf->skew) { out_time = 0; } else { out_time += jbuf->skew; } /* check if timestamps are not going backwards, we can only check this if we * have a previous out time and a previous send_diff */ if (G_LIKELY (jbuf->prev_out_time != -1 && jbuf->prev_send_diff != -1)) { /* now check for backwards timestamps */ if (G_UNLIKELY ( /* if the server timestamps went up and the out_time backwards */ (send_diff > jbuf->prev_send_diff && out_time < jbuf->prev_out_time) || /* if the server timestamps went backwards and the out_time forwards */ (send_diff < jbuf->prev_send_diff && out_time > jbuf->prev_out_time) || /* if the server timestamps did not change */ send_diff == jbuf->prev_send_diff)) { GST_DEBUG ("backwards timestamps, using previous time"); out_time = jbuf->prev_out_time; } } if (time != -1 && out_time + max_delay < time) { /* if we are going to produce a timestamp that is later than the input * timestamp, we need to reset the jitterbuffer. Likely the server paused * temporarily */ GST_DEBUG ("out %" GST_TIME_FORMAT " + %" G_GUINT64_FORMAT " < time %" GST_TIME_FORMAT ", reset jitterbuffer", GST_TIME_ARGS (out_time), max_delay, GST_TIME_ARGS (time)); rtp_jitter_buffer_resync (jbuf, time, gstrtptime, ext_rtptime, TRUE); out_time = time; send_diff = 0; } } else out_time = -1; jbuf->prev_out_time = out_time; jbuf->prev_send_diff = send_diff; GST_DEBUG ("skew %" G_GINT64_FORMAT ", out %" GST_TIME_FORMAT, jbuf->skew, GST_TIME_ARGS (out_time)); return out_time; }
gboolean kms_rtp_synchronizer_process_rtp_buffer_mapped (KmsRtpSynchronizer * self, GstRTPBuffer * rtp_buffer, GError ** error) { GstBuffer *buffer = rtp_buffer->buffer; guint64 pts_orig, ext_ts, last_sr_ext_ts, last_sr_ntp_ns_time; guint64 diff_ntp_ns_time; guint8 pt; guint32 ssrc, ts; gint32 clock_rate; gboolean ret = TRUE; ssrc = gst_rtp_buffer_get_ssrc (rtp_buffer); KMS_RTP_SYNCHRONIZER_LOCK (self); if (self->priv->ssrc == 0) { self->priv->ssrc = ssrc; } else if (ssrc != self->priv->ssrc) { gchar *msg = g_strdup_printf ("Invalid SSRC (%u), not matching with %u", ssrc, self->priv->ssrc); GST_ERROR_OBJECT (self, "%s", msg); g_set_error_literal (error, KMS_RTP_SYNC_ERROR, KMS_RTP_SYNC_INVALID_DATA, msg); g_free (msg); KMS_RTP_SYNCHRONIZER_UNLOCK (self); return FALSE; } pt = gst_rtp_buffer_get_payload_type (rtp_buffer); if (pt != self->priv->pt || self->priv->clock_rate <= 0) { gchar *msg = g_strdup_printf ("Invalid clock-rate %d for PT %u, not changing PTS", self->priv->clock_rate, pt); GST_ERROR_OBJECT (self, "%s", msg); g_set_error_literal (error, KMS_RTP_SYNC_ERROR, KMS_RTP_SYNC_INVALID_DATA, msg); g_free (msg); KMS_RTP_SYNCHRONIZER_UNLOCK (self); return FALSE; } pts_orig = GST_BUFFER_PTS (buffer); ts = gst_rtp_buffer_get_timestamp (rtp_buffer); gst_rtp_buffer_ext_timestamp (&self->priv->ext_ts, ts); if (self->priv->feeded_sorted) { if (self->priv->fs_last_ext_ts != -1 && self->priv->ext_ts < self->priv->fs_last_ext_ts) { guint16 seq = gst_rtp_buffer_get_seq (rtp_buffer); gchar *msg = g_strdup_printf ("Received an unsorted RTP buffer when expecting sorted (ssrc: %" G_GUINT32_FORMAT ", seq: %" G_GUINT16_FORMAT ", ts: %" G_GUINT32_FORMAT ", ext_ts: %" G_GUINT64_FORMAT "). Moving to unsorted mode", ssrc, seq, ts, self->priv->ext_ts); GST_ERROR_OBJECT (self, "%s", msg); g_set_error_literal (error, KMS_RTP_SYNC_ERROR, KMS_RTP_SYNC_INVALID_DATA, msg); g_free (msg); self->priv->feeded_sorted = FALSE; ret = FALSE; } else if (self->priv->ext_ts == self->priv->fs_last_ext_ts) { GST_BUFFER_PTS (buffer) = self->priv->fs_last_pts; goto end; } } if (!self->priv->base_initiated) { GST_DEBUG_OBJECT (self, "Do not sync data for SSRC %u and PT %u, interpolating PTS", ssrc, pt); if (!self->priv->base_interpolate_initiated) { self->priv->base_interpolate_ext_ts = self->priv->ext_ts; self->priv->base_interpolate_time = GST_BUFFER_PTS (buffer); self->priv->base_interpolate_initiated = TRUE; } else { buffer = gst_buffer_make_writable (buffer); GST_BUFFER_PTS (buffer) = self->priv->base_interpolate_time; kms_rtp_synchronizer_rtp_diff (self, rtp_buffer, self->priv->clock_rate, self->priv->base_interpolate_ext_ts); } } else { gboolean wrapped_down, wrapped_up; wrapped_down = wrapped_up = FALSE; buffer = gst_buffer_make_writable (buffer); GST_BUFFER_PTS (buffer) = self->priv->base_sync_time; if (self->priv->last_sr_ntp_ns_time > self->priv->base_ntp_ns_time) { diff_ntp_ns_time = self->priv->last_sr_ntp_ns_time - self->priv->base_ntp_ns_time; wrapped_up = diff_ntp_ns_time > (G_MAXUINT64 - GST_BUFFER_PTS (buffer)); GST_BUFFER_PTS (buffer) += diff_ntp_ns_time; } else if (self->priv->last_sr_ntp_ns_time < self->priv->base_ntp_ns_time) { diff_ntp_ns_time = self->priv->base_ntp_ns_time - self->priv->last_sr_ntp_ns_time; wrapped_down = GST_BUFFER_PTS (buffer) < diff_ntp_ns_time; GST_BUFFER_PTS (buffer) -= diff_ntp_ns_time; } /* if equals do nothing */ kms_rtp_synchronizer_rtp_diff_full (self, rtp_buffer, self->priv->clock_rate, self->priv->last_sr_ext_ts, wrapped_down, wrapped_up); } if (self->priv->feeded_sorted) { if (GST_BUFFER_PTS (buffer) < self->priv->fs_last_pts) { guint16 seq = gst_rtp_buffer_get_seq (rtp_buffer); GST_WARNING_OBJECT (self, "Non monotonic PTS assignment in sorted mode (ssrc: %" G_GUINT32_FORMAT ", seq: %" G_GUINT16_FORMAT ", ts: %" G_GUINT32_FORMAT ", ext_ts: %" G_GUINT64_FORMAT "). Forcing monotonic", ssrc, seq, ts, self->priv->ext_ts); GST_BUFFER_PTS (buffer) = self->priv->fs_last_pts; } self->priv->fs_last_ext_ts = self->priv->ext_ts; self->priv->fs_last_pts = GST_BUFFER_PTS (buffer); } end: clock_rate = self->priv->clock_rate; ext_ts = self->priv->ext_ts; last_sr_ext_ts = self->priv->last_sr_ext_ts; last_sr_ntp_ns_time = self->priv->last_sr_ntp_ns_time; KMS_RTP_SYNCHRONIZER_UNLOCK (self); kms_rtp_sync_context_write_stats (self->priv->context, ssrc, clock_rate, pts_orig, GST_BUFFER_PTS (buffer), GST_BUFFER_DTS (buffer), ext_ts, last_sr_ntp_ns_time, last_sr_ext_ts); return ret; }
/** * rtp_jitter_buffer_insert: * @jbuf: an #RTPJitterBuffer * @item: an #RTPJitterBufferItem to insert * @tail: TRUE when the tail element changed. * @percent: the buffering percent after insertion * * Inserts @item into the packet queue of @jbuf. The sequence number of the * packet will be used to sort the packets. This function takes ownerhip of * @buf when the function returns %TRUE. * * Returns: %FALSE if a packet with the same number already existed. */ gboolean rtp_jitter_buffer_insert (RTPJitterBuffer * jbuf, RTPJitterBufferItem * item, gboolean * tail, gint * percent) { GList *list = NULL; guint32 rtptime; guint16 seqnum; GstClockTime dts; g_return_val_if_fail (jbuf != NULL, FALSE); g_return_val_if_fail (item != NULL, FALSE); /* no seqnum, simply append then */ if (item->seqnum == -1) { goto append; } seqnum = item->seqnum; /* loop the list to skip strictly smaller seqnum buffers */ for (list = jbuf->packets->head; list; list = g_list_next (list)) { guint16 qseq; gint gap; RTPJitterBufferItem *qitem = (RTPJitterBufferItem *) list; if (qitem->seqnum == -1) continue; qseq = qitem->seqnum; /* compare the new seqnum to the one in the buffer */ gap = gst_rtp_buffer_compare_seqnum (seqnum, qseq); /* we hit a packet with the same seqnum, notify a duplicate */ if (G_UNLIKELY (gap == 0)) goto duplicate; /* seqnum < qseq, we can stop looking */ if (G_LIKELY (gap > 0)) break; } dts = item->dts; if (item->rtptime == -1) goto append; rtptime = item->rtptime; /* rtp time jumps are checked for during skew calculation, but bypassed * in other mode, so mind those here and reset jb if needed. * Only reset if valid input time, which is likely for UDP input * where we expect this might happen due to async thread effects * (in seek and state change cycles), but not so much for TCP input */ if (GST_CLOCK_TIME_IS_VALID (dts) && jbuf->mode != RTP_JITTER_BUFFER_MODE_SLAVE && jbuf->base_time != -1 && jbuf->last_rtptime != -1) { GstClockTime ext_rtptime = jbuf->ext_rtptime; ext_rtptime = gst_rtp_buffer_ext_timestamp (&ext_rtptime, rtptime); if (ext_rtptime > jbuf->last_rtptime + 3 * jbuf->clock_rate || ext_rtptime + 3 * jbuf->clock_rate < jbuf->last_rtptime) { /* reset even if we don't have valid incoming time; * still better than producing possibly very bogus output timestamp */ GST_WARNING ("rtp delta too big, reset skew"); rtp_jitter_buffer_reset_skew (jbuf); } } switch (jbuf->mode) { case RTP_JITTER_BUFFER_MODE_NONE: case RTP_JITTER_BUFFER_MODE_BUFFER: /* send 0 as the first timestamp and -1 for the other ones. This will * interpollate them from the RTP timestamps with a 0 origin. In buffering * mode we will adjust the outgoing timestamps according to the amount of * time we spent buffering. */ if (jbuf->base_time == -1) dts = 0; else dts = -1; break; case RTP_JITTER_BUFFER_MODE_SYNCED: /* synchronized clocks, take first timestamp as base, use RTP timestamps * to interpolate */ if (jbuf->base_time != -1) dts = -1; break; case RTP_JITTER_BUFFER_MODE_SLAVE: default: break; } /* do skew calculation by measuring the difference between rtptime and the * receive dts, this function will return the skew corrected rtptime. */ item->pts = calculate_skew (jbuf, rtptime, dts); append: queue_do_insert (jbuf, list, (GList *) item); /* buffering mode, update buffer stats */ if (jbuf->mode == RTP_JITTER_BUFFER_MODE_BUFFER) update_buffer_level (jbuf, percent); else if (percent) *percent = -1; /* tail was changed when we did not find a previous packet, we set the return * flag when requested. */ if (G_LIKELY (tail)) *tail = (list == NULL); return TRUE; /* ERRORS */ duplicate: { GST_WARNING ("duplicate packet %d found", (gint) seqnum); return FALSE; } }
static GstEvent * create_segment_event (GstRTPBaseDepayload * filter, guint rtptime, GstClockTime position) { GstEvent *event; GstClockTime start, stop, running_time; GstRTPBaseDepayloadPrivate *priv; GstSegment segment; priv = filter->priv; /* We don't need the object lock around - the segment * can't change here while we're holding the STREAM_LOCK */ /* determining the start of the segment */ start = filter->segment.start; if (priv->clock_base != -1 && position != -1) { GstClockTime exttime, gap; exttime = priv->clock_base; gst_rtp_buffer_ext_timestamp (&exttime, rtptime); gap = gst_util_uint64_scale_int (exttime - priv->clock_base, filter->clock_rate, GST_SECOND); /* account for lost packets */ if (position > gap) { GST_DEBUG_OBJECT (filter, "Found gap of %" GST_TIME_FORMAT ", adjusting start: %" GST_TIME_FORMAT " = %" GST_TIME_FORMAT " - %" GST_TIME_FORMAT, GST_TIME_ARGS (gap), GST_TIME_ARGS (position - gap), GST_TIME_ARGS (position), GST_TIME_ARGS (gap)); start = position - gap; } } /* determining the stop of the segment */ stop = filter->segment.stop; if (priv->npt_stop != -1) stop = start + (priv->npt_stop - priv->npt_start); if (position == -1) position = start; running_time = gst_segment_to_running_time (&filter->segment, GST_FORMAT_TIME, start); gst_segment_init (&segment, GST_FORMAT_TIME); segment.rate = priv->play_speed; segment.applied_rate = priv->play_scale; segment.start = start; segment.stop = stop; segment.time = priv->npt_start; segment.position = position; segment.base = running_time; GST_DEBUG_OBJECT (filter, "Creating segment event %" GST_SEGMENT_FORMAT, &segment); event = gst_event_new_segment (&segment); return event; }
/** * rtp_jitter_buffer_insert: * @jbuf: an #RTPJitterBuffer * @buf: a buffer * @time: a running_time when this buffer was received in nanoseconds * @clock_rate: the clock-rate of the payload of @buf * @max_delay: the maximum lateness of @buf * @tail: TRUE when the tail element changed. * * Inserts @buf into the packet queue of @jbuf. The sequence number of the * packet will be used to sort the packets. This function takes ownerhip of * @buf when the function returns %TRUE. * @buf should have writable metadata when calling this function. * * Returns: %FALSE if a packet with the same number already existed. */ gboolean rtp_jitter_buffer_insert (RTPJitterBuffer * jbuf, GstBuffer * buf, GstClockTime time, guint32 clock_rate, gboolean * tail, gint * percent) { GList *list; guint32 rtptime; guint16 seqnum; GstRTPBuffer rtp = {NULL}; g_return_val_if_fail (jbuf != NULL, FALSE); g_return_val_if_fail (buf != NULL, FALSE); gst_rtp_buffer_map (buf, GST_MAP_READ, &rtp); seqnum = gst_rtp_buffer_get_seq (&rtp); /* loop the list to skip strictly smaller seqnum buffers */ for (list = jbuf->packets->head; list; list = g_list_next (list)) { guint16 qseq; gint gap; GstRTPBuffer rtpb = {NULL}; gst_rtp_buffer_map (GST_BUFFER_CAST (list->data), GST_MAP_READ, &rtpb); qseq = gst_rtp_buffer_get_seq (&rtpb); gst_rtp_buffer_unmap (&rtpb); /* compare the new seqnum to the one in the buffer */ gap = gst_rtp_buffer_compare_seqnum (seqnum, qseq); /* we hit a packet with the same seqnum, notify a duplicate */ if (G_UNLIKELY (gap == 0)) goto duplicate; /* seqnum > qseq, we can stop looking */ if (G_LIKELY (gap < 0)) break; } rtptime = gst_rtp_buffer_get_timestamp (&rtp); /* rtp time jumps are checked for during skew calculation, but bypassed * in other mode, so mind those here and reset jb if needed. * Only reset if valid input time, which is likely for UDP input * where we expect this might happen due to async thread effects * (in seek and state change cycles), but not so much for TCP input */ if (GST_CLOCK_TIME_IS_VALID (time) && jbuf->mode != RTP_JITTER_BUFFER_MODE_SLAVE && jbuf->base_time != -1 && jbuf->last_rtptime != -1) { GstClockTime ext_rtptime = jbuf->ext_rtptime; ext_rtptime = gst_rtp_buffer_ext_timestamp (&ext_rtptime, rtptime); if (ext_rtptime > jbuf->last_rtptime + 3 * clock_rate || ext_rtptime + 3 * clock_rate < jbuf->last_rtptime) { /* reset even if we don't have valid incoming time; * still better than producing possibly very bogus output timestamp */ GST_WARNING ("rtp delta too big, reset skew"); rtp_jitter_buffer_reset_skew (jbuf); } } switch (jbuf->mode) { case RTP_JITTER_BUFFER_MODE_NONE: case RTP_JITTER_BUFFER_MODE_BUFFER: /* send 0 as the first timestamp and -1 for the other ones. This will * interpollate them from the RTP timestamps with a 0 origin. In buffering * mode we will adjust the outgoing timestamps according to the amount of * time we spent buffering. */ if (jbuf->base_time == -1) time = 0; else time = -1; break; case RTP_JITTER_BUFFER_MODE_SLAVE: default: break; } /* do skew calculation by measuring the difference between rtptime and the * receive time, this function will retimestamp @buf with the skew corrected * running time. */ time = calculate_skew (jbuf, rtptime, time, clock_rate); GST_BUFFER_TIMESTAMP (buf) = time; /* It's more likely that the packet was inserted in the front of the buffer */ if (G_LIKELY (list)) g_queue_insert_before (jbuf->packets, list, buf); else g_queue_push_tail (jbuf->packets, buf); /* buffering mode, update buffer stats */ if (jbuf->mode == RTP_JITTER_BUFFER_MODE_BUFFER) update_buffer_level (jbuf, percent); else *percent = -1; /* tail was changed when we did not find a previous packet, we set the return * flag when requested. */ if (G_LIKELY (tail)) *tail = (list == NULL); gst_rtp_buffer_unmap (&rtp); return TRUE; /* ERRORS */ duplicate: { gst_rtp_buffer_unmap (&rtp); GST_WARNING ("duplicate packet %d found", (gint) seqnum); return FALSE; } }