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