Merge branch 'master' into 0.11
[platform/upstream/gst-plugins-good.git] / gst / rtpmanager / rtpjitterbuffer.c
1 /* GStreamer
2  * Copyright (C) <2007> Wim Taymans <wim.taymans@gmail.com>
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Library General Public
6  * License as published by the Free Software Foundation; either
7  * version 2 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Library General Public License for more details.
13  *
14  * You should have received a copy of the GNU Library General Public
15  * License along with this library; if not, write to the
16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17  * Boston, MA 02111-1307, USA.
18  */
19 #include <string.h>
20 #include <stdlib.h>
21
22 #include <gst/rtp/gstrtpbuffer.h>
23 #include <gst/rtp/gstrtcpbuffer.h>
24
25 #include "rtpjitterbuffer.h"
26
27 GST_DEBUG_CATEGORY_STATIC (rtp_jitter_buffer_debug);
28 #define GST_CAT_DEFAULT rtp_jitter_buffer_debug
29
30 #define MAX_WINDOW      RTP_JITTER_BUFFER_MAX_WINDOW
31 #define MAX_TIME        (2 * GST_SECOND)
32
33 /* signals and args */
34 enum
35 {
36   LAST_SIGNAL
37 };
38
39 enum
40 {
41   PROP_0
42 };
43
44 /* GObject vmethods */
45 static void rtp_jitter_buffer_finalize (GObject * object);
46
47 GType
48 rtp_jitter_buffer_mode_get_type (void)
49 {
50   static GType jitter_buffer_mode_type = 0;
51   static const GEnumValue jitter_buffer_modes[] = {
52     {RTP_JITTER_BUFFER_MODE_NONE, "Only use RTP timestamps", "none"},
53     {RTP_JITTER_BUFFER_MODE_SLAVE, "Slave receiver to sender clock", "slave"},
54     {RTP_JITTER_BUFFER_MODE_BUFFER, "Do low/high watermark buffering",
55         "buffer"},
56     {0, NULL, NULL},
57   };
58
59   if (!jitter_buffer_mode_type) {
60     jitter_buffer_mode_type =
61         g_enum_register_static ("RTPJitterBufferMode", jitter_buffer_modes);
62   }
63   return jitter_buffer_mode_type;
64 }
65
66 /* static guint rtp_jitter_buffer_signals[LAST_SIGNAL] = { 0 }; */
67
68 G_DEFINE_TYPE (RTPJitterBuffer, rtp_jitter_buffer, G_TYPE_OBJECT);
69
70 static void
71 rtp_jitter_buffer_class_init (RTPJitterBufferClass * klass)
72 {
73   GObjectClass *gobject_class;
74
75   gobject_class = (GObjectClass *) klass;
76
77   gobject_class->finalize = rtp_jitter_buffer_finalize;
78
79   GST_DEBUG_CATEGORY_INIT (rtp_jitter_buffer_debug, "rtpjitterbuffer", 0,
80       "RTP Jitter Buffer");
81 }
82
83 static void
84 rtp_jitter_buffer_init (RTPJitterBuffer * jbuf)
85 {
86   jbuf->packets = g_queue_new ();
87   jbuf->mode = RTP_JITTER_BUFFER_MODE_SLAVE;
88
89   rtp_jitter_buffer_reset_skew (jbuf);
90 }
91
92 static void
93 rtp_jitter_buffer_finalize (GObject * object)
94 {
95   RTPJitterBuffer *jbuf;
96
97   jbuf = RTP_JITTER_BUFFER_CAST (object);
98
99   rtp_jitter_buffer_flush (jbuf);
100   g_queue_free (jbuf->packets);
101
102   G_OBJECT_CLASS (rtp_jitter_buffer_parent_class)->finalize (object);
103 }
104
105 /**
106  * rtp_jitter_buffer_new:
107  *
108  * Create an #RTPJitterBuffer.
109  *
110  * Returns: a new #RTPJitterBuffer. Use g_object_unref() after usage.
111  */
112 RTPJitterBuffer *
113 rtp_jitter_buffer_new (void)
114 {
115   RTPJitterBuffer *jbuf;
116
117   jbuf = g_object_new (RTP_TYPE_JITTER_BUFFER, NULL);
118
119   return jbuf;
120 }
121
122 /**
123  * rtp_jitter_buffer_get_mode:
124  * @jbuf: an #RTPJitterBuffer
125  *
126  * Get the current jitterbuffer mode.
127  *
128  * Returns: the current jitterbuffer mode.
129  */
130 RTPJitterBufferMode
131 rtp_jitter_buffer_get_mode (RTPJitterBuffer * jbuf)
132 {
133   return jbuf->mode;
134 }
135
136 /**
137  * rtp_jitter_buffer_set_mode:
138  * @jbuf: an #RTPJitterBuffer
139  * @mode: a #RTPJitterBufferMode
140  *
141  * Set the buffering and clock slaving algorithm used in the @jbuf.
142  */
143 void
144 rtp_jitter_buffer_set_mode (RTPJitterBuffer * jbuf, RTPJitterBufferMode mode)
145 {
146   jbuf->mode = mode;
147 }
148
149 GstClockTime
150 rtp_jitter_buffer_get_delay (RTPJitterBuffer * jbuf)
151 {
152   return jbuf->delay;
153 }
154
155 void
156 rtp_jitter_buffer_set_delay (RTPJitterBuffer * jbuf, GstClockTime delay)
157 {
158   jbuf->delay = delay;
159   jbuf->low_level = (delay * 15) / 100;
160   /* the high level is at 90% in order to release packets before we fill up the
161    * buffer up to the latency */
162   jbuf->high_level = (delay * 90) / 100;
163
164   GST_DEBUG ("delay %" GST_TIME_FORMAT ", min %" GST_TIME_FORMAT ", max %"
165       GST_TIME_FORMAT, GST_TIME_ARGS (jbuf->delay),
166       GST_TIME_ARGS (jbuf->low_level), GST_TIME_ARGS (jbuf->high_level));
167 }
168
169
170 /**
171  * rtp_jitter_buffer_reset_skew:
172  * @jbuf: an #RTPJitterBuffer
173  *
174  * Reset the skew calculations in @jbuf.
175  */
176 void
177 rtp_jitter_buffer_reset_skew (RTPJitterBuffer * jbuf)
178 {
179   jbuf->base_time = -1;
180   jbuf->base_rtptime = -1;
181   jbuf->base_extrtp = -1;
182   jbuf->clock_rate = -1;
183   jbuf->ext_rtptime = -1;
184   jbuf->last_rtptime = -1;
185   jbuf->window_pos = 0;
186   jbuf->window_filling = TRUE;
187   jbuf->window_min = 0;
188   jbuf->skew = 0;
189   jbuf->prev_send_diff = -1;
190   jbuf->prev_out_time = -1;
191   GST_DEBUG ("reset skew correction");
192 }
193
194 static void
195 rtp_jitter_buffer_resync (RTPJitterBuffer * jbuf, GstClockTime time,
196     GstClockTime gstrtptime, guint64 ext_rtptime, gboolean reset_skew)
197 {
198   jbuf->base_time = time;
199   jbuf->base_rtptime = gstrtptime;
200   jbuf->base_extrtp = ext_rtptime;
201   jbuf->prev_out_time = -1;
202   jbuf->prev_send_diff = -1;
203   if (reset_skew) {
204     jbuf->window_filling = TRUE;
205     jbuf->window_pos = 0;
206     jbuf->window_min = 0;
207     jbuf->window_size = 0;
208     jbuf->skew = 0;
209   }
210 }
211
212 static guint64
213 get_buffer_level (RTPJitterBuffer * jbuf)
214 {
215   GstBuffer *high_buf = NULL, *low_buf = NULL;
216   guint64 level;
217   GList *find;
218
219   /* first first buffer with timestamp */
220   find = g_queue_peek_head_link (jbuf->packets);
221   while (find) {
222     high_buf = find->data;
223     if (GST_BUFFER_TIMESTAMP (high_buf) != -1)
224       break;
225
226     high_buf = NULL;
227     find = g_list_next (find);
228   }
229
230   find = g_queue_peek_tail_link (jbuf->packets);
231   while (find) {
232     low_buf = find->data;
233     if (GST_BUFFER_TIMESTAMP (low_buf) != -1)
234       break;
235
236     low_buf = NULL;
237     find = g_list_previous (find);
238   }
239
240   if (!high_buf || !low_buf || high_buf == low_buf) {
241     level = 0;
242   } else {
243     guint64 high_ts, low_ts;
244
245     high_ts = GST_BUFFER_TIMESTAMP (high_buf);
246     low_ts = GST_BUFFER_TIMESTAMP (low_buf);
247
248     if (high_ts > low_ts)
249       level = high_ts - low_ts;
250     else
251       level = 0;
252
253     GST_LOG_OBJECT (jbuf,
254         "low %" GST_TIME_FORMAT " high %" GST_TIME_FORMAT " level %"
255         G_GUINT64_FORMAT, GST_TIME_ARGS (low_ts), GST_TIME_ARGS (high_ts),
256         level);
257   }
258   return level;
259 }
260
261 static void
262 update_buffer_level (RTPJitterBuffer * jbuf, gint * percent)
263 {
264   gboolean post = FALSE;
265   guint64 level;
266
267   level = get_buffer_level (jbuf);
268   GST_DEBUG ("buffer level %" GST_TIME_FORMAT, GST_TIME_ARGS (level));
269
270   if (jbuf->buffering) {
271     post = TRUE;
272     if (level > jbuf->high_level) {
273       GST_DEBUG ("buffering finished");
274       jbuf->buffering = FALSE;
275     }
276   } else {
277     if (level < jbuf->low_level) {
278       GST_DEBUG ("buffering started");
279       jbuf->buffering = TRUE;
280       post = TRUE;
281     }
282   }
283   if (post) {
284     gint perc;
285
286     if (jbuf->buffering && (jbuf->high_level != 0)) {
287       perc = (level * 100 / jbuf->high_level);
288       perc = MIN (perc, 100);
289     } else {
290       perc = 100;
291     }
292
293     if (percent)
294       *percent = perc;
295
296     GST_DEBUG ("buffering %d", perc);
297   }
298 }
299
300 /* For the clock skew we use a windowed low point averaging algorithm as can be
301  * found in Fober, Orlarey and Letz, 2005, "Real Time Clock Skew Estimation
302  * over Network Delays":
303  * http://www.grame.fr/Ressources/pub/TR-050601.pdf
304  * http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.102.1546
305  *
306  * The idea is that the jitter is composed of:
307  *
308  *  J = N + n
309  *
310  *   N   : a constant network delay.
311  *   n   : random added noise. The noise is concentrated around 0
312  *
313  * In the receiver we can track the elapsed time at the sender with:
314  *
315  *  send_diff(i) = (Tsi - Ts0);
316  *
317  *   Tsi : The time at the sender at packet i
318  *   Ts0 : The time at the sender at the first packet
319  *
320  * This is the difference between the RTP timestamp in the first received packet
321  * and the current packet.
322  *
323  * At the receiver we have to deal with the jitter introduced by the network.
324  *
325  *  recv_diff(i) = (Tri - Tr0)
326  *
327  *   Tri : The time at the receiver at packet i
328  *   Tr0 : The time at the receiver at the first packet
329  *
330  * Both of these values contain a jitter Ji, a jitter for packet i, so we can
331  * write:
332  *
333  *  recv_diff(i) = (Cri + D + ni) - (Cr0 + D + n0))
334  *
335  *    Cri    : The time of the clock at the receiver for packet i
336  *    D + ni : The jitter when receiving packet i
337  *
338  * We see that the network delay is irrelevant here as we can elliminate D:
339  *
340  *  recv_diff(i) = (Cri + ni) - (Cr0 + n0))
341  *
342  * The drift is now expressed as:
343  *
344  *  Drift(i) = recv_diff(i) - send_diff(i);
345  *
346  * We now keep the W latest values of Drift and find the minimum (this is the
347  * one with the lowest network jitter and thus the one which is least affected
348  * by it). We average this lowest value to smooth out the resulting network skew.
349  *
350  * Both the window and the weighting used for averaging influence the accuracy
351  * of the drift estimation. Finding the correct parameters turns out to be a
352  * compromise between accuracy and inertia.
353  *
354  * We use a 2 second window or up to 512 data points, which is statistically big
355  * enough to catch spikes (FIXME, detect spikes).
356  * We also use a rather large weighting factor (125) to smoothly adapt. During
357  * startup, when filling the window, we use a parabolic weighting factor, the
358  * more the window is filled, the faster we move to the detected possible skew.
359  *
360  * Returns: @time adjusted with the clock skew.
361  */
362 static GstClockTime
363 calculate_skew (RTPJitterBuffer * jbuf, guint32 rtptime, GstClockTime time,
364     guint32 clock_rate)
365 {
366   guint64 ext_rtptime;
367   guint64 send_diff, recv_diff;
368   gint64 delta;
369   gint64 old;
370   gint pos, i;
371   GstClockTime gstrtptime, out_time;
372   guint64 slope;
373
374   ext_rtptime = gst_rtp_buffer_ext_timestamp (&jbuf->ext_rtptime, rtptime);
375
376   gstrtptime = gst_util_uint64_scale_int (ext_rtptime, GST_SECOND, clock_rate);
377
378   /* keep track of the last extended rtptime */
379   jbuf->last_rtptime = ext_rtptime;
380
381   if (jbuf->clock_rate != clock_rate) {
382     if (jbuf->clock_rate == -1) {
383       GST_DEBUG ("Clock rate changed from %" G_GUINT32_FORMAT " to %"
384           G_GUINT32_FORMAT, jbuf->clock_rate, clock_rate);
385     } else {
386       GST_WARNING ("Clock rate changed from %" G_GUINT32_FORMAT " to %"
387           G_GUINT32_FORMAT, jbuf->clock_rate, clock_rate);
388     }
389     jbuf->base_time = -1;
390     jbuf->base_rtptime = -1;
391     jbuf->clock_rate = clock_rate;
392     jbuf->prev_out_time = -1;
393     jbuf->prev_send_diff = -1;
394   }
395
396   /* first time, lock on to time and gstrtptime */
397   if (G_UNLIKELY (jbuf->base_time == -1)) {
398     jbuf->base_time = time;
399     jbuf->prev_out_time = -1;
400     GST_DEBUG ("Taking new base time %" GST_TIME_FORMAT, GST_TIME_ARGS (time));
401   }
402   if (G_UNLIKELY (jbuf->base_rtptime == -1)) {
403     jbuf->base_rtptime = gstrtptime;
404     jbuf->base_extrtp = ext_rtptime;
405     jbuf->prev_send_diff = -1;
406     GST_DEBUG ("Taking new base rtptime %" GST_TIME_FORMAT,
407         GST_TIME_ARGS (gstrtptime));
408   }
409
410   if (G_LIKELY (gstrtptime >= jbuf->base_rtptime))
411     send_diff = gstrtptime - jbuf->base_rtptime;
412   else if (time != -1) {
413     /* elapsed time at sender, timestamps can go backwards and thus be smaller
414      * than our base time, take a new base time in that case. */
415     GST_WARNING ("backward timestamps at server, taking new base time");
416     rtp_jitter_buffer_resync (jbuf, time, gstrtptime, ext_rtptime, FALSE);
417     send_diff = 0;
418   } else {
419     GST_WARNING ("backward timestamps at server but no timestamps");
420     send_diff = 0;
421     /* at least try to get a new timestamp.. */
422     jbuf->base_time = -1;
423   }
424
425   GST_DEBUG ("extrtp %" G_GUINT64_FORMAT ", gstrtp %" GST_TIME_FORMAT ", base %"
426       GST_TIME_FORMAT ", send_diff %" GST_TIME_FORMAT, ext_rtptime,
427       GST_TIME_ARGS (gstrtptime), GST_TIME_ARGS (jbuf->base_rtptime),
428       GST_TIME_ARGS (send_diff));
429
430   /* we don't have an arrival timestamp so we can't do skew detection. we
431    * should still apply a timestamp based on RTP timestamp and base_time */
432   if (time == -1 || jbuf->base_time == -1)
433     goto no_skew;
434
435   /* elapsed time at receiver, includes the jitter */
436   recv_diff = time - jbuf->base_time;
437
438   /* measure the diff */
439   delta = ((gint64) recv_diff) - ((gint64) send_diff);
440
441   /* measure the slope, this gives a rought estimate between the sender speed
442    * and the receiver speed. This should be approximately 8, higher values
443    * indicate a burst (especially when the connection starts) */
444   if (recv_diff > 0)
445     slope = (send_diff * 8) / recv_diff;
446   else
447     slope = 8;
448
449   GST_DEBUG ("time %" GST_TIME_FORMAT ", base %" GST_TIME_FORMAT ", recv_diff %"
450       GST_TIME_FORMAT ", slope %" G_GUINT64_FORMAT, GST_TIME_ARGS (time),
451       GST_TIME_ARGS (jbuf->base_time), GST_TIME_ARGS (recv_diff), slope);
452
453   /* if the difference between the sender timeline and the receiver timeline
454    * changed too quickly we have to resync because the server likely restarted
455    * its timestamps. */
456   if (ABS (delta - jbuf->skew) > GST_SECOND) {
457     GST_WARNING ("delta - skew: %" GST_TIME_FORMAT " too big, reset skew",
458         GST_TIME_ARGS (delta - jbuf->skew));
459     rtp_jitter_buffer_resync (jbuf, time, gstrtptime, ext_rtptime, TRUE);
460     send_diff = 0;
461     delta = 0;
462   }
463
464   pos = jbuf->window_pos;
465
466   if (G_UNLIKELY (jbuf->window_filling)) {
467     /* we are filling the window */
468     GST_DEBUG ("filling %d, delta %" G_GINT64_FORMAT, pos, delta);
469     jbuf->window[pos++] = delta;
470     /* calc the min delta we observed */
471     if (G_UNLIKELY (pos == 1 || delta < jbuf->window_min))
472       jbuf->window_min = delta;
473
474     if (G_UNLIKELY (send_diff >= MAX_TIME || pos >= MAX_WINDOW)) {
475       jbuf->window_size = pos;
476
477       /* window filled */
478       GST_DEBUG ("min %" G_GINT64_FORMAT, jbuf->window_min);
479
480       /* the skew is now the min */
481       jbuf->skew = jbuf->window_min;
482       jbuf->window_filling = FALSE;
483     } else {
484       gint perc_time, perc_window, perc;
485
486       /* figure out how much we filled the window, this depends on the amount of
487        * time we have or the max number of points we keep. */
488       perc_time = send_diff * 100 / MAX_TIME;
489       perc_window = pos * 100 / MAX_WINDOW;
490       perc = MAX (perc_time, perc_window);
491
492       /* make a parabolic function, the closer we get to the MAX, the more value
493        * we give to the scaling factor of the new value */
494       perc = perc * perc;
495
496       /* quickly go to the min value when we are filling up, slowly when we are
497        * just starting because we're not sure it's a good value yet. */
498       jbuf->skew =
499           (perc * jbuf->window_min + ((10000 - perc) * jbuf->skew)) / 10000;
500       jbuf->window_size = pos + 1;
501     }
502   } else {
503     /* pick old value and store new value. We keep the previous value in order
504      * to quickly check if the min of the window changed */
505     old = jbuf->window[pos];
506     jbuf->window[pos++] = delta;
507
508     if (G_UNLIKELY (delta <= jbuf->window_min)) {
509       /* if the new value we inserted is smaller or equal to the current min,
510        * it becomes the new min */
511       jbuf->window_min = delta;
512     } else if (G_UNLIKELY (old == jbuf->window_min)) {
513       gint64 min = G_MAXINT64;
514
515       /* if we removed the old min, we have to find a new min */
516       for (i = 0; i < jbuf->window_size; i++) {
517         /* we found another value equal to the old min, we can stop searching now */
518         if (jbuf->window[i] == old) {
519           min = old;
520           break;
521         }
522         if (jbuf->window[i] < min)
523           min = jbuf->window[i];
524       }
525       jbuf->window_min = min;
526     }
527     /* average the min values */
528     jbuf->skew = (jbuf->window_min + (124 * jbuf->skew)) / 125;
529     GST_DEBUG ("delta %" G_GINT64_FORMAT ", new min: %" G_GINT64_FORMAT,
530         delta, jbuf->window_min);
531   }
532   /* wrap around in the window */
533   if (G_UNLIKELY (pos >= jbuf->window_size))
534     pos = 0;
535   jbuf->window_pos = pos;
536
537 no_skew:
538   /* the output time is defined as the base timestamp plus the RTP time
539    * adjusted for the clock skew .*/
540   if (jbuf->base_time != -1) {
541     out_time = jbuf->base_time + send_diff;
542     /* skew can be negative and we don't want to make invalid timestamps */
543     if (jbuf->skew < 0 && out_time < -jbuf->skew) {
544       out_time = 0;
545     } else {
546       out_time += jbuf->skew;
547     }
548     /* check if timestamps are not going backwards, we can only check this if we
549      * have a previous out time and a previous send_diff */
550     if (G_LIKELY (jbuf->prev_out_time != -1 && jbuf->prev_send_diff != -1)) {
551       /* now check for backwards timestamps */
552       if (G_UNLIKELY (
553               /* if the server timestamps went up and the out_time backwards */
554               (send_diff > jbuf->prev_send_diff
555                   && out_time < jbuf->prev_out_time) ||
556               /* if the server timestamps went backwards and the out_time forwards */
557               (send_diff < jbuf->prev_send_diff
558                   && out_time > jbuf->prev_out_time) ||
559               /* if the server timestamps did not change */
560               send_diff == jbuf->prev_send_diff)) {
561         GST_DEBUG ("backwards timestamps, using previous time");
562         out_time = jbuf->prev_out_time;
563       }
564     }
565     if (time != -1 && out_time + jbuf->delay < time) {
566       /* if we are going to produce a timestamp that is later than the input
567        * timestamp, we need to reset the jitterbuffer. Likely the server paused
568        * temporarily */
569       GST_DEBUG ("out %" GST_TIME_FORMAT " + %" G_GUINT64_FORMAT " < time %"
570           GST_TIME_FORMAT ", reset jitterbuffer", GST_TIME_ARGS (out_time),
571           jbuf->delay, GST_TIME_ARGS (time));
572       rtp_jitter_buffer_resync (jbuf, time, gstrtptime, ext_rtptime, TRUE);
573       out_time = time;
574       send_diff = 0;
575     }
576   } else
577     out_time = -1;
578
579   jbuf->prev_out_time = out_time;
580   jbuf->prev_send_diff = send_diff;
581
582   GST_DEBUG ("skew %" G_GINT64_FORMAT ", out %" GST_TIME_FORMAT,
583       jbuf->skew, GST_TIME_ARGS (out_time));
584
585   return out_time;
586 }
587
588 /**
589  * rtp_jitter_buffer_insert:
590  * @jbuf: an #RTPJitterBuffer
591  * @buf: a buffer
592  * @time: a running_time when this buffer was received in nanoseconds
593  * @clock_rate: the clock-rate of the payload of @buf
594  * @max_delay: the maximum lateness of @buf
595  * @tail: TRUE when the tail element changed.
596  *
597  * Inserts @buf into the packet queue of @jbuf. The sequence number of the
598  * packet will be used to sort the packets. This function takes ownerhip of
599  * @buf when the function returns %TRUE.
600  * @buf should have writable metadata when calling this function.
601  *
602  * Returns: %FALSE if a packet with the same number already existed.
603  */
604 gboolean
605 rtp_jitter_buffer_insert (RTPJitterBuffer * jbuf, GstBuffer * buf,
606     GstClockTime time, guint32 clock_rate, gboolean * tail, gint * percent)
607 {
608   GList *list;
609   guint32 rtptime;
610   guint16 seqnum;
611   GstRTPBuffer rtp;
612
613   g_return_val_if_fail (jbuf != NULL, FALSE);
614   g_return_val_if_fail (buf != NULL, FALSE);
615
616   gst_rtp_buffer_map (buf, GST_MAP_READ, &rtp);
617
618   seqnum = gst_rtp_buffer_get_seq (&rtp);
619
620   /* loop the list to skip strictly smaller seqnum buffers */
621   for (list = jbuf->packets->head; list; list = g_list_next (list)) {
622     guint16 qseq;
623     gint gap;
624     GstRTPBuffer rtpb;
625
626     gst_rtp_buffer_map (GST_BUFFER_CAST (list->data), GST_MAP_READ, &rtpb);
627     qseq = gst_rtp_buffer_get_seq (&rtpb);
628     gst_rtp_buffer_unmap (&rtpb);
629
630     /* compare the new seqnum to the one in the buffer */
631     gap = gst_rtp_buffer_compare_seqnum (seqnum, qseq);
632
633     /* we hit a packet with the same seqnum, notify a duplicate */
634     if (G_UNLIKELY (gap == 0))
635       goto duplicate;
636
637     /* seqnum > qseq, we can stop looking */
638     if (G_LIKELY (gap < 0))
639       break;
640   }
641
642   rtptime = gst_rtp_buffer_get_timestamp (&rtp);
643   switch (jbuf->mode) {
644     case RTP_JITTER_BUFFER_MODE_NONE:
645     case RTP_JITTER_BUFFER_MODE_BUFFER:
646       /* send 0 as the first timestamp and -1 for the other ones. This will
647        * interpollate them from the RTP timestamps with a 0 origin. In buffering
648        * mode we will adjust the outgoing timestamps according to the amount of
649        * time we spent buffering. */
650       if (jbuf->base_time == -1)
651         time = 0;
652       else
653         time = -1;
654       break;
655     case RTP_JITTER_BUFFER_MODE_SLAVE:
656     default:
657       break;
658   }
659   /* do skew calculation by measuring the difference between rtptime and the
660    * receive time, this function will retimestamp @buf with the skew corrected
661    * running time. */
662   time = calculate_skew (jbuf, rtptime, time, clock_rate);
663   GST_BUFFER_TIMESTAMP (buf) = time;
664
665   /* It's more likely that the packet was inserted in the front of the buffer */
666   if (G_LIKELY (list))
667     g_queue_insert_before (jbuf->packets, list, buf);
668   else
669     g_queue_push_tail (jbuf->packets, buf);
670
671   /* buffering mode, update buffer stats */
672   if (jbuf->mode == RTP_JITTER_BUFFER_MODE_BUFFER)
673     update_buffer_level (jbuf, percent);
674   else
675     *percent = -1;
676
677   /* tail was changed when we did not find a previous packet, we set the return
678    * flag when requested. */
679   if (G_LIKELY (tail))
680     *tail = (list == NULL);
681
682   gst_rtp_buffer_unmap (&rtp);
683
684   return TRUE;
685
686   /* ERRORS */
687 duplicate:
688   {
689     gst_rtp_buffer_unmap (&rtp);
690     GST_WARNING ("duplicate packet %d found", (gint) seqnum);
691     return FALSE;
692   }
693 }
694
695 /**
696  * rtp_jitter_buffer_pop:
697  * @jbuf: an #RTPJitterBuffer
698  * @percent: the buffering percent
699  *
700  * Pops the oldest buffer from the packet queue of @jbuf. The popped buffer will
701  * have its timestamp adjusted with the incomming running_time and the detected
702  * clock skew.
703  *
704  * Returns: a #GstBuffer or %NULL when there was no packet in the queue.
705  */
706 GstBuffer *
707 rtp_jitter_buffer_pop (RTPJitterBuffer * jbuf, gint * percent)
708 {
709   GstBuffer *buf;
710
711   g_return_val_if_fail (jbuf != NULL, NULL);
712
713   buf = g_queue_pop_tail (jbuf->packets);
714
715   /* buffering mode, update buffer stats */
716   if (jbuf->mode == RTP_JITTER_BUFFER_MODE_BUFFER)
717     update_buffer_level (jbuf, percent);
718   else
719     *percent = -1;
720
721   return buf;
722 }
723
724 /**
725  * rtp_jitter_buffer_peek:
726  * @jbuf: an #RTPJitterBuffer
727  *
728  * Peek the oldest buffer from the packet queue of @jbuf. Register a callback
729  * with rtp_jitter_buffer_set_tail_changed() to be notified when an older packet
730  * was inserted in the queue.
731  *
732  * Returns: a #GstBuffer or %NULL when there was no packet in the queue.
733  */
734 GstBuffer *
735 rtp_jitter_buffer_peek (RTPJitterBuffer * jbuf)
736 {
737   GstBuffer *buf;
738
739   g_return_val_if_fail (jbuf != NULL, NULL);
740
741   buf = g_queue_peek_tail (jbuf->packets);
742
743   return buf;
744 }
745
746 /**
747  * rtp_jitter_buffer_flush:
748  * @jbuf: an #RTPJitterBuffer
749  *
750  * Flush all packets from the jitterbuffer.
751  */
752 void
753 rtp_jitter_buffer_flush (RTPJitterBuffer * jbuf)
754 {
755   GstBuffer *buffer;
756
757   g_return_if_fail (jbuf != NULL);
758
759   while ((buffer = g_queue_pop_head (jbuf->packets)))
760     gst_buffer_unref (buffer);
761 }
762
763 /**
764  * rtp_jitter_buffer_is_buffering:
765  * @jbuf: an #RTPJitterBuffer
766  *
767  * Check if @jbuf is buffering currently. Users of the jitterbuffer should not
768  * pop packets while in buffering mode.
769  *
770  * Returns: the buffering state of @jbuf
771  */
772 gboolean
773 rtp_jitter_buffer_is_buffering (RTPJitterBuffer * jbuf)
774 {
775   return jbuf->buffering;
776 }
777
778 /**
779  * rtp_jitter_buffer_set_buffering:
780  * @jbuf: an #RTPJitterBuffer
781  * @buffering: the new buffering state
782  *
783  * Forces @jbuf to go into the buffering state.
784  */
785 void
786 rtp_jitter_buffer_set_buffering (RTPJitterBuffer * jbuf, gboolean buffering)
787 {
788   jbuf->buffering = buffering;
789 }
790
791 /**
792  * rtp_jitter_buffer_get_percent:
793  * @jbuf: an #RTPJitterBuffer
794  *
795  * Get the buffering percent of the jitterbuffer.
796  *
797  * Returns: the buffering percent
798  */
799 gint
800 rtp_jitter_buffer_get_percent (RTPJitterBuffer * jbuf)
801 {
802   gint percent;
803   guint64 level;
804
805   if (G_UNLIKELY (jbuf->high_level == 0))
806     return 100;
807
808   level = get_buffer_level (jbuf);
809   percent = (level * 100 / jbuf->high_level);
810   percent = MIN (percent, 100);
811
812   return percent;
813 }
814
815 /**
816  * rtp_jitter_buffer_num_packets:
817  * @jbuf: an #RTPJitterBuffer
818  *
819  * Get the number of packets currently in "jbuf.
820  *
821  * Returns: The number of packets in @jbuf.
822  */
823 guint
824 rtp_jitter_buffer_num_packets (RTPJitterBuffer * jbuf)
825 {
826   g_return_val_if_fail (jbuf != NULL, 0);
827
828   return jbuf->packets->length;
829 }
830
831 /**
832  * rtp_jitter_buffer_get_ts_diff:
833  * @jbuf: an #RTPJitterBuffer
834  *
835  * Get the difference between the timestamps of first and last packet in the
836  * jitterbuffer.
837  *
838  * Returns: The difference expressed in the timestamp units of the packets.
839  */
840 guint32
841 rtp_jitter_buffer_get_ts_diff (RTPJitterBuffer * jbuf)
842 {
843   guint64 high_ts, low_ts;
844   GstBuffer *high_buf, *low_buf;
845   guint32 result;
846   GstRTPBuffer rtp;
847
848   g_return_val_if_fail (jbuf != NULL, 0);
849
850   high_buf = g_queue_peek_head (jbuf->packets);
851   low_buf = g_queue_peek_tail (jbuf->packets);
852
853   if (!high_buf || !low_buf || high_buf == low_buf)
854     return 0;
855
856   gst_rtp_buffer_map (high_buf, GST_MAP_READ, &rtp);
857   high_ts = gst_rtp_buffer_get_timestamp (&rtp);
858   gst_rtp_buffer_unmap (&rtp);
859   gst_rtp_buffer_map (low_buf, GST_MAP_READ, &rtp);
860   low_ts = gst_rtp_buffer_get_timestamp (&rtp);
861   gst_rtp_buffer_unmap (&rtp);
862
863   /* it needs to work if ts wraps */
864   if (high_ts >= low_ts) {
865     result = (guint32) (high_ts - low_ts);
866   } else {
867     result = (guint32) (high_ts + G_MAXUINT32 + 1 - low_ts);
868   }
869   return result;
870 }
871
872 /**
873  * rtp_jitter_buffer_get_sync:
874  * @jbuf: an #RTPJitterBuffer
875  * @rtptime: result RTP time
876  * @timestamp: result GStreamer timestamp
877  * @clock_rate: clock-rate of @rtptime
878  * @last_rtptime: last seen rtptime.
879  *
880  * Calculates the relation between the RTP timestamp and the GStreamer timestamp
881  * used for constructing timestamps.
882  *
883  * For extended RTP timestamp @rtptime with a clock-rate of @clock_rate,
884  * the GStreamer timestamp is currently @timestamp.
885  *
886  * The last seen extended RTP timestamp with clock-rate @clock-rate is returned in
887  * @last_rtptime.
888  */
889 void
890 rtp_jitter_buffer_get_sync (RTPJitterBuffer * jbuf, guint64 * rtptime,
891     guint64 * timestamp, guint32 * clock_rate, guint64 * last_rtptime)
892 {
893   if (rtptime)
894     *rtptime = jbuf->base_extrtp;
895   if (timestamp)
896     *timestamp = jbuf->base_time + jbuf->skew;
897   if (clock_rate)
898     *clock_rate = jbuf->clock_rate;
899   if (last_rtptime)
900     *last_rtptime = jbuf->last_rtptime;
901 }