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   g_mutex_init (&jbuf->clock_lock);
  89
  90   jbuf->packets = g_queue_new ();
  91   jbuf->mode = RTP_JITTER_BUFFER_MODE_SLAVE;
  92
  93   rtp_jitter_buffer_reset_skew (jbuf);
  94 }
  95
  96 static void
  97 rtp_jitter_buffer_finalize (GObject * object)
  98 {
  99   RTPJitterBuffer *jbuf;
 100
 101   jbuf = RTP_JITTER_BUFFER_CAST (object);
 102
 103   if (jbuf->media_clock_synced_id)
 104     g_signal_handler_disconnect (jbuf->media_clock,
 105         jbuf->media_clock_synced_id);
 106   if (jbuf->media_clock)
 107     gst_object_unref (jbuf->media_clock);
 108
 109   if (jbuf->pipeline_clock)
 110     gst_object_unref (jbuf->pipeline_clock);
 111
 112   g_queue_free (jbuf->packets);
 113
 114   g_mutex_clear (&jbuf->clock_lock);
 115
 116   G_OBJECT_CLASS (rtp_jitter_buffer_parent_class)->finalize (object);
 117 }
 118
 119 /**
 120  * rtp_jitter_buffer_new:
 121  *
 122  * Create an #RTPJitterBuffer.
 123  *
 124  * Returns: a new #RTPJitterBuffer. Use g_object_unref() after usage.
 125  */
 126 RTPJitterBuffer *
 127 rtp_jitter_buffer_new (void)
 128 {
 129   RTPJitterBuffer *jbuf;
 130
 131   jbuf = g_object_new (RTP_TYPE_JITTER_BUFFER, NULL);
 132
 133   return jbuf;
 134 }
 135
 136 /**
 137  * rtp_jitter_buffer_get_mode:
 138  * @jbuf: an #RTPJitterBuffer
 139  *
 140  * Get the current jitterbuffer mode.
 141  *
 142  * Returns: the current jitterbuffer mode.
 143  */
 144 RTPJitterBufferMode
 145 rtp_jitter_buffer_get_mode (RTPJitterBuffer * jbuf)
 146 {
 147   return jbuf->mode;
 148 }
 149
 150 /**
 151  * rtp_jitter_buffer_set_mode:
 152  * @jbuf: an #RTPJitterBuffer
 153  * @mode: a #RTPJitterBufferMode
 154  *
 155  * Set the buffering and clock slaving algorithm used in the @jbuf.
 156  */
 157 void
 158 rtp_jitter_buffer_set_mode (RTPJitterBuffer * jbuf, RTPJitterBufferMode mode)
 159 {
 160   jbuf->mode = mode;
 161 }
 162
 163 GstClockTime
 164 rtp_jitter_buffer_get_delay (RTPJitterBuffer * jbuf)
 165 {
 166   return jbuf->delay;
 167 }
 168
 169 void
 170 rtp_jitter_buffer_set_delay (RTPJitterBuffer * jbuf, GstClockTime delay)
 171 {
 172   jbuf->delay = delay;
 173   jbuf->low_level = (delay * 15) / 100;
 174   /* the high level is at 90% in order to release packets before we fill up the
 175    * buffer up to the latency */
 176   jbuf->high_level = (delay * 90) / 100;
 177
 178   GST_DEBUG ("delay %" GST_TIME_FORMAT ", min %" GST_TIME_FORMAT ", max %"
 179       GST_TIME_FORMAT, GST_TIME_ARGS (jbuf->delay),
 180       GST_TIME_ARGS (jbuf->low_level), GST_TIME_ARGS (jbuf->high_level));
 181 }
 182
 183 /**
 184  * rtp_jitter_buffer_set_clock_rate:
 185  * @jbuf: an #RTPJitterBuffer
 186  * @clock_rate: the new clock rate
 187  *
 188  * Set the clock rate in the jitterbuffer.
 189  */
 190 void
 191 rtp_jitter_buffer_set_clock_rate (RTPJitterBuffer * jbuf, guint32 clock_rate)
 192 {
 193   if (jbuf->clock_rate != clock_rate) {
 194     GST_DEBUG ("Clock rate changed from %" G_GUINT32_FORMAT " to %"
 195         G_GUINT32_FORMAT, jbuf->clock_rate, clock_rate);
 196     jbuf->clock_rate = clock_rate;
 197     rtp_jitter_buffer_reset_skew (jbuf);
 198   }
 199 }
 200
 201 /**
 202  * rtp_jitter_buffer_get_clock_rate:
 203  * @jbuf: an #RTPJitterBuffer
 204  *
 205  * Get the currently configure clock rate in @jbuf.
 206  *
 207  * Returns: the current clock-rate
 208  */
 209 guint32
 210 rtp_jitter_buffer_get_clock_rate (RTPJitterBuffer * jbuf)
 211 {
 212   return jbuf->clock_rate;
 213 }
 214
 215 static void
 216 media_clock_synced_cb (GstClock * clock, gboolean synced,
 217     RTPJitterBuffer * jbuf)
 218 {
 219   GstClockTime internal, external;
 220
 221   g_mutex_lock (&jbuf->clock_lock);
 222   if (jbuf->pipeline_clock) {
 223     internal = gst_clock_get_internal_time (jbuf->media_clock);
 224     external = gst_clock_get_time (jbuf->pipeline_clock);
 225
 226     gst_clock_set_calibration (jbuf->media_clock, internal, external, 1, 1);
 227   }
 228   g_mutex_unlock (&jbuf->clock_lock);
 229 }
 230
 231 /**
 232  * rtp_jitter_buffer_set_media_clock:
 233  * @jbuf: an #RTPJitterBuffer
 234  * @clock: (transfer full): media #GstClock
 235  * @clock_offset: RTP time at clock epoch or -1
 236  *
 237  * Sets the media clock for the media and the clock offset
 238  *
 239  */
 240 void
 241 rtp_jitter_buffer_set_media_clock (RTPJitterBuffer * jbuf, GstClock * clock,
 242     guint64 clock_offset)
 243 {
 244   g_mutex_lock (&jbuf->clock_lock);
 245   if (jbuf->media_clock) {
 246     if (jbuf->media_clock_synced_id)
 247       g_signal_handler_disconnect (jbuf->media_clock,
 248           jbuf->media_clock_synced_id);
 249     jbuf->media_clock_synced_id = 0;
 250     gst_object_unref (jbuf->media_clock);
 251   }
 252   jbuf->media_clock = clock;
 253   jbuf->media_clock_offset = clock_offset;
 254
 255   if (jbuf->pipeline_clock && jbuf->media_clock &&
 256       jbuf->pipeline_clock != jbuf->media_clock) {
 257     jbuf->media_clock_synced_id =
 258         g_signal_connect (jbuf->media_clock, "synced",
 259         G_CALLBACK (media_clock_synced_cb), jbuf);
 260     if (gst_clock_is_synced (jbuf->media_clock)) {
 261       GstClockTime internal, external;
 262
 263       internal = gst_clock_get_internal_time (jbuf->media_clock);
 264       external = gst_clock_get_time (jbuf->pipeline_clock);
 265
 266       gst_clock_set_calibration (jbuf->media_clock, internal, external, 1, 1);
 267     }
 268
 269     gst_clock_set_master (jbuf->media_clock, jbuf->pipeline_clock);
 270   }
 271   g_mutex_unlock (&jbuf->clock_lock);
 272 }
 273
 274 /**
 275  * rtp_jitter_buffer_set_pipeline_clock:
 276  * @jbuf: an #RTPJitterBuffer
 277  * @clock: pipeline #GstClock
 278  *
 279  * Sets the pipeline clock
 280  *
 281  */
 282 void
 283 rtp_jitter_buffer_set_pipeline_clock (RTPJitterBuffer * jbuf, GstClock * clock)
 284 {
 285   g_mutex_lock (&jbuf->clock_lock);
 286   if (jbuf->pipeline_clock)
 287     gst_object_unref (jbuf->pipeline_clock);
 288   jbuf->pipeline_clock = clock ? gst_object_ref (clock) : NULL;
 289
 290   if (jbuf->pipeline_clock && jbuf->media_clock &&
 291       jbuf->pipeline_clock != jbuf->media_clock) {
 292     if (gst_clock_is_synced (jbuf->media_clock)) {
 293       GstClockTime internal, external;
 294
 295       internal = gst_clock_get_internal_time (jbuf->media_clock);
 296       external = gst_clock_get_time (jbuf->pipeline_clock);
 297
 298       gst_clock_set_calibration (jbuf->media_clock, internal, external, 1, 1);
 299     }
 300
 301     gst_clock_set_master (jbuf->media_clock, jbuf->pipeline_clock);
 302   }
 303   g_mutex_unlock (&jbuf->clock_lock);
 304 }
 305
 306 gboolean
 307 rtp_jitter_buffer_get_rfc7273_sync (RTPJitterBuffer * jbuf)
 308 {
 309   return jbuf->rfc7273_sync;
 310 }
 311
 312 void
 313 rtp_jitter_buffer_set_rfc7273_sync (RTPJitterBuffer * jbuf,
 314     gboolean rfc7273_sync)
 315 {
 316   jbuf->rfc7273_sync = rfc7273_sync;
 317 }
 318
 319 /**
 320  * rtp_jitter_buffer_reset_skew:
 321  * @jbuf: an #RTPJitterBuffer
 322  *
 323  * Reset the skew calculations in @jbuf.
 324  */
 325 void
 326 rtp_jitter_buffer_reset_skew (RTPJitterBuffer * jbuf)
 327 {
 328   jbuf->base_time = -1;
 329   jbuf->base_rtptime = -1;
 330   jbuf->base_extrtp = -1;
 331   jbuf->media_clock_base_time = -1;
 332   jbuf->ext_rtptime = -1;
 333   jbuf->last_rtptime = -1;
 334   jbuf->window_pos = 0;
 335   jbuf->window_filling = TRUE;
 336   jbuf->window_min = 0;
 337   jbuf->skew = 0;
 338   jbuf->prev_send_diff = -1;
 339   jbuf->prev_out_time = -1;
 340   jbuf->need_resync = TRUE;
 341
 342   GST_DEBUG ("reset skew correction");
 343 }
 344
 345 /**
 346  * rtp_jitter_buffer_disable_buffering:
 347  * @jbuf: an #RTPJitterBuffer
 348  * @disabled: the new state
 349  *
 350  * Enable or disable buffering on @jbuf.
 351  */
 352 void
 353 rtp_jitter_buffer_disable_buffering (RTPJitterBuffer * jbuf, gboolean disabled)
 354 {
 355   jbuf->buffering_disabled = disabled;
 356 }
 357
 358 static void
 359 rtp_jitter_buffer_resync (RTPJitterBuffer * jbuf, GstClockTime time,
 360     GstClockTime gstrtptime, guint64 ext_rtptime, gboolean reset_skew)
 361 {
 362   jbuf->base_time = time;
 363   jbuf->media_clock_base_time = -1;
 364   jbuf->base_rtptime = gstrtptime;
 365   jbuf->base_extrtp = ext_rtptime;
 366   jbuf->prev_out_time = -1;
 367   jbuf->prev_send_diff = -1;
 368   if (reset_skew) {
 369     jbuf->window_filling = TRUE;
 370     jbuf->window_pos = 0;
 371     jbuf->window_min = 0;
 372     jbuf->window_size = 0;
 373     jbuf->skew = 0;
 374   }
 375   jbuf->need_resync = FALSE;
 376 }
 377
 378 static guint64
 379 get_buffer_level (RTPJitterBuffer * jbuf)
 380 {
 381   RTPJitterBufferItem *high_buf = NULL, *low_buf = NULL;
 382   guint64 level;
 383
 384   /* first buffer with timestamp */
 385   high_buf = (RTPJitterBufferItem *) g_queue_peek_tail_link (jbuf->packets);
 386   while (high_buf) {
 387     if (high_buf->dts != -1 || high_buf->pts != -1)
 388       break;
 389
 390     high_buf = (RTPJitterBufferItem *) g_list_previous (high_buf);
 391   }
 392
 393   low_buf = (RTPJitterBufferItem *) g_queue_peek_head_link (jbuf->packets);
 394   while (low_buf) {
 395     if (low_buf->dts != -1 || low_buf->pts != -1)
 396       break;
 397
 398     low_buf = (RTPJitterBufferItem *) g_list_next (low_buf);
 399   }
 400
 401   if (!high_buf || !low_buf || high_buf == low_buf) {
 402     level = 0;
 403   } else {
 404     guint64 high_ts, low_ts;
 405
 406     high_ts = high_buf->dts != -1 ? high_buf->dts : high_buf->pts;
 407     low_ts = low_buf->dts != -1 ? low_buf->dts : low_buf->pts;
 408
 409     if (high_ts > low_ts)
 410       level = high_ts - low_ts;
 411     else
 412       level = 0;
 413
 414     GST_LOG_OBJECT (jbuf,
 415         "low %" GST_TIME_FORMAT " high %" GST_TIME_FORMAT " level %"
 416         G_GUINT64_FORMAT, GST_TIME_ARGS (low_ts), GST_TIME_ARGS (high_ts),
 417         level);
 418   }
 419   return level;
 420 }
 421
 422 static void
 423 update_buffer_level (RTPJitterBuffer * jbuf, gint * percent)
 424 {
 425   gboolean post = FALSE;
 426   guint64 level;
 427
 428   level = get_buffer_level (jbuf);
 429   GST_DEBUG ("buffer level %" GST_TIME_FORMAT, GST_TIME_ARGS (level));
 430
 431   if (jbuf->buffering_disabled) {
 432     GST_DEBUG ("buffering is disabled");
 433     level = jbuf->high_level;
 434   }
 435
 436   if (jbuf->buffering) {
 437     post = TRUE;
 438     if (level >= jbuf->high_level) {
 439       GST_DEBUG ("buffering finished");
 440       jbuf->buffering = FALSE;
 441     }
 442   } else {
 443     if (level < jbuf->low_level) {
 444       GST_DEBUG ("buffering started");
 445       jbuf->buffering = TRUE;
 446       post = TRUE;
 447     }
 448   }
 449   if (post) {
 450     gint perc;
 451
 452     if (jbuf->buffering && (jbuf->high_level != 0)) {
 453       perc = (level * 100 / jbuf->high_level);
 454       perc = MIN (perc, 100);
 455     } else {
 456       perc = 100;
 457     }
 458
 459     if (percent)
 460       *percent = perc;
 461
 462     GST_DEBUG ("buffering %d", perc);
 463   }
 464 }
 465
 466 /* For the clock skew we use a windowed low point averaging algorithm as can be
 467  * found in Fober, Orlarey and Letz, 2005, "Real Time Clock Skew Estimation
 468  * over Network Delays":
 469  * http://www.grame.fr/Ressources/pub/TR-050601.pdf
 470  * http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.102.1546
 471  *
 472  * The idea is that the jitter is composed of:
 473  *
 474  *  J = N + n
 475  *
 476  *   N   : a constant network delay.
 477  *   n   : random added noise. The noise is concentrated around 0
 478  *
 479  * In the receiver we can track the elapsed time at the sender with:
 480  *
 481  *  send_diff(i) = (Tsi - Ts0);
 482  *
 483  *   Tsi : The time at the sender at packet i
 484  *   Ts0 : The time at the sender at the first packet
 485  *
 486  * This is the difference between the RTP timestamp in the first received packet
 487  * and the current packet.
 488  *
 489  * At the receiver we have to deal with the jitter introduced by the network.
 490  *
 491  *  recv_diff(i) = (Tri - Tr0)
 492  *
 493  *   Tri : The time at the receiver at packet i
 494  *   Tr0 : The time at the receiver at the first packet
 495  *
 496  * Both of these values contain a jitter Ji, a jitter for packet i, so we can
 497  * write:
 498  *
 499  *  recv_diff(i) = (Cri + D + ni) - (Cr0 + D + n0))
 500  *
 501  *    Cri    : The time of the clock at the receiver for packet i
 502  *    D + ni : The jitter when receiving packet i
 503  *
 504  * We see that the network delay is irrelevant here as we can elliminate D:
 505  *
 506  *  recv_diff(i) = (Cri + ni) - (Cr0 + n0))
 507  *
 508  * The drift is now expressed as:
 509  *
 510  *  Drift(i) = recv_diff(i) - send_diff(i);
 511  *
 512  * We now keep the W latest values of Drift and find the minimum (this is the
 513  * one with the lowest network jitter and thus the one which is least affected
 514  * by it). We average this lowest value to smooth out the resulting network skew.
 515  *
 516  * Both the window and the weighting used for averaging influence the accuracy
 517  * of the drift estimation. Finding the correct parameters turns out to be a
 518  * compromise between accuracy and inertia.
 519  *
 520  * We use a 2 second window or up to 512 data points, which is statistically big
 521  * enough to catch spikes (FIXME, detect spikes).
 522  * We also use a rather large weighting factor (125) to smoothly adapt. During
 523  * startup, when filling the window, we use a parabolic weighting factor, the
 524  * more the window is filled, the faster we move to the detected possible skew.
 525  *
 526  * Returns: @time adjusted with the clock skew.
 527  */
 528 static GstClockTime
 529 calculate_skew (RTPJitterBuffer * jbuf, guint64 ext_rtptime,
 530     GstClockTime gstrtptime, GstClockTime time)
 531 {
 532   guint64 send_diff, recv_diff;
 533   gint64 delta;
 534   gint64 old;
 535   gint pos, i;
 536   GstClockTime out_time;
 537   guint64 slope;
 538
 539   /* elapsed time at sender */
 540   send_diff = gstrtptime - jbuf->base_rtptime;
 541
 542   /* we don't have an arrival timestamp so we can't do skew detection. we
 543    * should still apply a timestamp based on RTP timestamp and base_time */
 544   if (time == -1 || jbuf->base_time == -1)
 545     goto no_skew;
 546
 547   /* elapsed time at receiver, includes the jitter */
 548   recv_diff = time - jbuf->base_time;
 549
 550   /* measure the diff */
 551   delta = ((gint64) recv_diff) - ((gint64) send_diff);
 552
 553   /* measure the slope, this gives a rought estimate between the sender speed
 554    * and the receiver speed. This should be approximately 8, higher values
 555    * indicate a burst (especially when the connection starts) */
 556   if (recv_diff > 0)
 557     slope = (send_diff * 8) / recv_diff;
 558   else
 559     slope = 8;
 560
 561   GST_DEBUG ("time %" GST_TIME_FORMAT ", base %" GST_TIME_FORMAT ", recv_diff %"
 562       GST_TIME_FORMAT ", slope %" G_GUINT64_FORMAT, GST_TIME_ARGS (time),
 563       GST_TIME_ARGS (jbuf->base_time), GST_TIME_ARGS (recv_diff), slope);
 564
 565   /* if the difference between the sender timeline and the receiver timeline
 566    * changed too quickly we have to resync because the server likely restarted
 567    * its timestamps. */
 568   if (ABS (delta - jbuf->skew) > GST_SECOND) {
 569     GST_WARNING ("delta - skew: %" GST_TIME_FORMAT " too big, reset skew",
 570         GST_TIME_ARGS (ABS (delta - jbuf->skew)));
 571     rtp_jitter_buffer_resync (jbuf, time, gstrtptime, ext_rtptime, TRUE);
 572     send_diff = 0;
 573     delta = 0;
 574   }
 575
 576   pos = jbuf->window_pos;
 577
 578   if (G_UNLIKELY (jbuf->window_filling)) {
 579     /* we are filling the window */
 580     GST_DEBUG ("filling %d, delta %" G_GINT64_FORMAT, pos, delta);
 581     jbuf->window[pos++] = delta;
 582     /* calc the min delta we observed */
 583     if (G_UNLIKELY (pos == 1 || delta < jbuf->window_min))
 584       jbuf->window_min = delta;
 585
 586     if (G_UNLIKELY (send_diff >= MAX_TIME || pos >= MAX_WINDOW)) {
 587       jbuf->window_size = pos;
 588
 589       /* window filled */
 590       GST_DEBUG ("min %" G_GINT64_FORMAT, jbuf->window_min);
 591
 592       /* the skew is now the min */
 593       jbuf->skew = jbuf->window_min;
 594       jbuf->window_filling = FALSE;
 595     } else {
 596       gint perc_time, perc_window, perc;
 597
 598       /* figure out how much we filled the window, this depends on the amount of
 599        * time we have or the max number of points we keep. */
 600       perc_time = send_diff * 100 / MAX_TIME;
 601       perc_window = pos * 100 / MAX_WINDOW;
 602       perc = MAX (perc_time, perc_window);
 603
 604       /* make a parabolic function, the closer we get to the MAX, the more value
 605        * we give to the scaling factor of the new value */
 606       perc = perc * perc;
 607
 608       /* quickly go to the min value when we are filling up, slowly when we are
 609        * just starting because we're not sure it's a good value yet. */
 610       jbuf->skew =
 611           (perc * jbuf->window_min + ((10000 - perc) * jbuf->skew)) / 10000;
 612       jbuf->window_size = pos + 1;
 613     }
 614   } else {
 615     /* pick old value and store new value. We keep the previous value in order
 616      * to quickly check if the min of the window changed */
 617     old = jbuf->window[pos];
 618     jbuf->window[pos++] = delta;
 619
 620     if (G_UNLIKELY (delta <= jbuf->window_min)) {
 621       /* if the new value we inserted is smaller or equal to the current min,
 622        * it becomes the new min */
 623       jbuf->window_min = delta;
 624     } else if (G_UNLIKELY (old == jbuf->window_min)) {
 625       gint64 min = G_MAXINT64;
 626
 627       /* if we removed the old min, we have to find a new min */
 628       for (i = 0; i < jbuf->window_size; i++) {
 629         /* we found another value equal to the old min, we can stop searching now */
 630         if (jbuf->window[i] == old) {
 631           min = old;
 632           break;
 633         }
 634         if (jbuf->window[i] < min)
 635           min = jbuf->window[i];
 636       }
 637       jbuf->window_min = min;
 638     }
 639     /* average the min values */
 640     jbuf->skew = (jbuf->window_min + (124 * jbuf->skew)) / 125;
 641     GST_DEBUG ("delta %" G_GINT64_FORMAT ", new min: %" G_GINT64_FORMAT,
 642         delta, jbuf->window_min);
 643   }
 644   /* wrap around in the window */
 645   if (G_UNLIKELY (pos >= jbuf->window_size))
 646     pos = 0;
 647   jbuf->window_pos = pos;
 648
 649 no_skew:
 650   /* the output time is defined as the base timestamp plus the RTP time
 651    * adjusted for the clock skew .*/
 652   if (jbuf->base_time != -1) {
 653     out_time = jbuf->base_time + send_diff;
 654     /* skew can be negative and we don't want to make invalid timestamps */
 655     if (jbuf->skew < 0 && out_time < -jbuf->skew) {
 656       out_time = 0;
 657     } else {
 658       out_time += jbuf->skew;
 659     }
 660   } else
 661     out_time = -1;
 662
 663   GST_DEBUG ("skew %" G_GINT64_FORMAT ", out %" GST_TIME_FORMAT,
 664       jbuf->skew, GST_TIME_ARGS (out_time));
 665
 666   return out_time;
 667 }
 668
 669 static void
 670 queue_do_insert (RTPJitterBuffer * jbuf, GList * list, GList * item)
 671 {
 672   GQueue *queue = jbuf->packets;
 673
 674   /* It's more likely that the packet was inserted at the tail of the queue */
 675   if (G_LIKELY (list)) {
 676     item->prev = list;
 677     item->next = list->next;
 678     list->next = item;
 679   } else {
 680     item->prev = NULL;
 681     item->next = queue->head;
 682     queue->head = item;
 683   }
 684   if (item->next)
 685     item->next->prev = item;
 686   else
 687     queue->tail = item;
 688   queue->length++;
 689 }
 690
 691 GstClockTime
 692 rtp_jitter_buffer_calculate_pts (RTPJitterBuffer * jbuf, GstClockTime dts,
 693     gboolean estimated_dts, guint32 rtptime, GstClockTime base_time)
 694 {
 695   guint64 ext_rtptime;
 696   GstClockTime gstrtptime, pts;
 697   GstClock *media_clock, *pipeline_clock;
 698   guint64 media_clock_offset;
 699   gboolean rfc7273_mode;
 700
 701   /* rtp time jumps are checked for during skew calculation, but bypassed
 702    * in other mode, so mind those here and reset jb if needed.
 703    * Only reset if valid input time, which is likely for UDP input
 704    * where we expect this might happen due to async thread effects
 705    * (in seek and state change cycles), but not so much for TCP input */
 706   if (GST_CLOCK_TIME_IS_VALID (dts) && !estimated_dts &&
 707       jbuf->mode != RTP_JITTER_BUFFER_MODE_SLAVE &&
 708       jbuf->base_time != -1 && jbuf->last_rtptime != -1) {
 709     GstClockTime ext_rtptime = jbuf->ext_rtptime;
 710
 711     ext_rtptime = gst_rtp_buffer_ext_timestamp (&ext_rtptime, rtptime);
 712     if (ext_rtptime > jbuf->last_rtptime + 3 * jbuf->clock_rate ||
 713         ext_rtptime + 3 * jbuf->clock_rate < jbuf->last_rtptime) {
 714       /* reset even if we don't have valid incoming time;
 715        * still better than producing possibly very bogus output timestamp */
 716       GST_WARNING ("rtp delta too big, reset skew");
 717       rtp_jitter_buffer_reset_skew (jbuf);
 718     }
 719   }
 720
 721   /* Return the last time if we got the same RTP timestamp again */
 722   ext_rtptime = gst_rtp_buffer_ext_timestamp (&jbuf->ext_rtptime, rtptime);
 723   if (jbuf->last_rtptime != -1 && ext_rtptime == jbuf->last_rtptime) {
 724     return jbuf->prev_out_time;
 725   }
 726
 727   /* keep track of the last extended rtptime */
 728   jbuf->last_rtptime = ext_rtptime;
 729
 730   g_mutex_lock (&jbuf->clock_lock);
 731   media_clock = jbuf->media_clock ? gst_object_ref (jbuf->media_clock) : NULL;
 732   pipeline_clock =
 733       jbuf->pipeline_clock ? gst_object_ref (jbuf->pipeline_clock) : NULL;
 734   media_clock_offset = jbuf->media_clock_offset;
 735   g_mutex_unlock (&jbuf->clock_lock);
 736
 737   gstrtptime =
 738       gst_util_uint64_scale_int (ext_rtptime, GST_SECOND, jbuf->clock_rate);
 739
 740   if (G_LIKELY (jbuf->base_rtptime != -1)) {
 741     /* check elapsed time in RTP units */
 742     if (gstrtptime < jbuf->base_rtptime) {
 743       /* elapsed time at sender, timestamps can go backwards and thus be
 744        * smaller than our base time, schedule to take a new base time in
 745        * that case. */
 746       GST_WARNING ("backward timestamps at server, schedule resync");
 747       jbuf->need_resync = TRUE;
 748     }
 749   }
 750
 751   switch (jbuf->mode) {
 752     case RTP_JITTER_BUFFER_MODE_NONE:
 753     case RTP_JITTER_BUFFER_MODE_BUFFER:
 754       /* send 0 as the first timestamp and -1 for the other ones. This will
 755        * interpolate them from the RTP timestamps with a 0 origin. In buffering
 756        * mode we will adjust the outgoing timestamps according to the amount of
 757        * time we spent buffering. */
 758       if (jbuf->base_time == -1)
 759         dts = 0;
 760       else
 761         dts = -1;
 762       break;
 763     case RTP_JITTER_BUFFER_MODE_SYNCED:
 764       /* synchronized clocks, take first timestamp as base, use RTP timestamps
 765        * to interpolate */
 766       if (jbuf->base_time != -1 && !jbuf->need_resync)
 767         dts = -1;
 768       break;
 769     case RTP_JITTER_BUFFER_MODE_SLAVE:
 770     default:
 771       break;
 772   }
 773
 774   /* need resync, lock on to time and gstrtptime if we can, otherwise we
 775    * do with the previous values */
 776   if (G_UNLIKELY (jbuf->need_resync && dts != -1)) {
 777     GST_INFO ("resync to time %" GST_TIME_FORMAT ", rtptime %"
 778         GST_TIME_FORMAT, GST_TIME_ARGS (dts), GST_TIME_ARGS (gstrtptime));
 779     rtp_jitter_buffer_resync (jbuf, dts, gstrtptime, ext_rtptime, FALSE);
 780   }
 781
 782   GST_DEBUG ("extrtp %" G_GUINT64_FORMAT ", gstrtp %" GST_TIME_FORMAT ", base %"
 783       GST_TIME_FORMAT ", send_diff %" GST_TIME_FORMAT, ext_rtptime,
 784       GST_TIME_ARGS (gstrtptime), GST_TIME_ARGS (jbuf->base_rtptime),
 785       GST_TIME_ARGS (gstrtptime - jbuf->base_rtptime));
 786
 787   rfc7273_mode = media_clock && pipeline_clock
 788       && gst_clock_is_synced (media_clock);
 789
 790   if (rfc7273_mode && jbuf->mode == RTP_JITTER_BUFFER_MODE_SLAVE
 791       && (media_clock_offset == -1 || !jbuf->rfc7273_sync)) {
 792     GstClockTime internal, external;
 793     GstClockTime rate_num, rate_denom;
 794     GstClockTime nsrtptimediff, rtpntptime, rtpsystime;
 795
 796     gst_clock_get_calibration (media_clock, &internal, &external, &rate_num,
 797         &rate_denom);
 798
 799     /* Slave to the RFC7273 media clock instead of trying to estimate it
 800      * based on receive times and RTP timestamps */
 801
 802     if (jbuf->media_clock_base_time == -1) {
 803       if (jbuf->base_time != -1) {
 804         jbuf->media_clock_base_time =
 805             gst_clock_unadjust_with_calibration (media_clock,
 806             jbuf->base_time + base_time, internal, external, rate_num,
 807             rate_denom);
 808       } else {
 809         if (dts != -1)
 810           jbuf->media_clock_base_time =
 811               gst_clock_unadjust_with_calibration (media_clock, dts + base_time,
 812               internal, external, rate_num, rate_denom);
 813         else
 814           jbuf->media_clock_base_time =
 815               gst_clock_get_internal_time (media_clock);
 816         jbuf->base_rtptime = gstrtptime;
 817       }
 818     }
 819
 820     if (gstrtptime > jbuf->base_rtptime)
 821       nsrtptimediff = gstrtptime - jbuf->base_rtptime;
 822     else
 823       nsrtptimediff = 0;
 824
 825     rtpntptime = nsrtptimediff + jbuf->media_clock_base_time;
 826
 827     rtpsystime =
 828         gst_clock_adjust_with_calibration (media_clock, rtpntptime, internal,
 829         external, rate_num, rate_denom);
 830
 831     if (rtpsystime > base_time)
 832       pts = rtpsystime - base_time;
 833     else
 834       pts = 0;
 835
 836     GST_DEBUG ("RFC7273 clock time %" GST_TIME_FORMAT ", out %" GST_TIME_FORMAT,
 837         GST_TIME_ARGS (rtpsystime), GST_TIME_ARGS (pts));
 838   } else if (rfc7273_mode && (jbuf->mode == RTP_JITTER_BUFFER_MODE_SLAVE
 839           || jbuf->mode == RTP_JITTER_BUFFER_MODE_SYNCED)
 840       && media_clock_offset != -1 && jbuf->rfc7273_sync) {
 841     GstClockTime ntptime, rtptime_tmp;
 842     GstClockTime ntprtptime, rtpsystime;
 843     GstClockTime internal, external;
 844     GstClockTime rate_num, rate_denom;
 845
 846     /* Don't do any of the dts related adjustments further down */
 847     dts = -1;
 848
 849     /* Calculate the actual clock time on the sender side based on the
 850      * RFC7273 clock and convert it to our pipeline clock
 851      */
 852
 853     gst_clock_get_calibration (media_clock, &internal, &external, &rate_num,
 854         &rate_denom);
 855
 856     ntptime = gst_clock_get_internal_time (media_clock);
 857
 858     ntprtptime = gst_util_uint64_scale (ntptime, jbuf->clock_rate, GST_SECOND);
 859     ntprtptime += media_clock_offset;
 860     ntprtptime &= 0xffffffff;
 861
 862     rtptime_tmp = rtptime;
 863     /* Check for wraparounds, we assume that the diff between current RTP
 864      * timestamp and current media clock time can't be bigger than
 865      * 2**31 clock units */
 866     if (ntprtptime > rtptime_tmp && ntprtptime - rtptime_tmp >= 0x80000000)
 867       rtptime_tmp += G_GUINT64_CONSTANT (0x100000000);
 868     else if (rtptime_tmp > ntprtptime && rtptime_tmp - ntprtptime >= 0x80000000)
 869       ntprtptime += G_GUINT64_CONSTANT (0x100000000);
 870
 871     if (ntprtptime > rtptime_tmp)
 872       ntptime -=
 873           gst_util_uint64_scale (ntprtptime - rtptime_tmp, jbuf->clock_rate,
 874           GST_SECOND);
 875     else
 876       ntptime +=
 877           gst_util_uint64_scale (rtptime_tmp - ntprtptime, jbuf->clock_rate,
 878           GST_SECOND);
 879
 880     rtpsystime =
 881         gst_clock_adjust_with_calibration (media_clock, ntptime, internal,
 882         external, rate_num, rate_denom);
 883     /* All this assumes that the pipeline has enough additional
 884      * latency to cover for the network delay */
 885     if (rtpsystime > base_time)
 886       pts = rtpsystime - base_time;
 887     else
 888       pts = 0;
 889
 890     GST_DEBUG ("RFC7273 clock time %" GST_TIME_FORMAT ", out %" GST_TIME_FORMAT,
 891         GST_TIME_ARGS (rtpsystime), GST_TIME_ARGS (pts));
 892   } else {
 893     /* If we used the RFC7273 clock before and not anymore,
 894      * we need to resync it later again */
 895     jbuf->media_clock_base_time = -1;
 896
 897     /* do skew calculation by measuring the difference between rtptime and the
 898      * receive dts, this function will return the skew corrected rtptime. */
 899     pts = calculate_skew (jbuf, ext_rtptime, gstrtptime, dts);
 900   }
 901
 902   /* check if timestamps are not going backwards, we can only check this if we
 903    * have a previous out time and a previous send_diff */
 904   if (G_LIKELY (pts != -1 && jbuf->prev_out_time != -1
 905           && jbuf->prev_send_diff != -1)) {
 906     /* now check for backwards timestamps */
 907     if (G_UNLIKELY (
 908             /* if the server timestamps went up and the out_time backwards */
 909             (gstrtptime - jbuf->base_rtptime > jbuf->prev_send_diff
 910                 && pts < jbuf->prev_out_time) ||
 911             /* if the server timestamps went backwards and the out_time forwards */
 912             (gstrtptime - jbuf->base_rtptime < jbuf->prev_send_diff
 913                 && pts > jbuf->prev_out_time) ||
 914             /* if the server timestamps did not change */
 915             gstrtptime - jbuf->base_rtptime == jbuf->prev_send_diff)) {
 916       GST_DEBUG ("backwards timestamps, using previous time");
 917       pts = jbuf->prev_out_time;
 918     }
 919   }
 920
 921   if (dts != -1 && pts + jbuf->delay < dts) {
 922     /* if we are going to produce a timestamp that is later than the input
 923      * timestamp, we need to reset the jitterbuffer. Likely the server paused
 924      * temporarily */
 925     GST_DEBUG ("out %" GST_TIME_FORMAT " + %" G_GUINT64_FORMAT " < time %"
 926         GST_TIME_FORMAT ", reset jitterbuffer", GST_TIME_ARGS (pts),
 927         jbuf->delay, GST_TIME_ARGS (dts));
 928     rtp_jitter_buffer_resync (jbuf, dts, gstrtptime, ext_rtptime, TRUE);
 929     pts = dts;
 930   }
 931
 932   jbuf->prev_out_time = pts;
 933   jbuf->prev_send_diff = gstrtptime - jbuf->base_rtptime;
 934
 935   if (media_clock)
 936     gst_object_unref (media_clock);
 937   if (pipeline_clock)
 938     gst_object_unref (pipeline_clock);
 939
 940   return pts;
 941 }
 942
 943
 944 /**
 945  * rtp_jitter_buffer_insert:
 946  * @jbuf: an #RTPJitterBuffer
 947  * @item: an #RTPJitterBufferItem to insert
 948  * @head: TRUE when the head element changed.
 949  * @percent: the buffering percent after insertion
 950  *
 951  * Inserts @item into the packet queue of @jbuf. The sequence number of the
 952  * packet will be used to sort the packets. This function takes ownerhip of
 953  * @buf when the function returns %TRUE.
 954  *
 955  * When @head is %TRUE, the new packet was added at the head of the queue and
 956  * will be available with the next call to rtp_jitter_buffer_pop() and
 957  * rtp_jitter_buffer_peek().
 958  *
 959  * Returns: %FALSE if a packet with the same number already existed.
 960  */
 961 gboolean
 962 rtp_jitter_buffer_insert (RTPJitterBuffer * jbuf, RTPJitterBufferItem * item,
 963     gboolean * head, gint * percent)
 964 {
 965   GList *list, *event = NULL;
 966   guint16 seqnum;
 967
 968   g_return_val_if_fail (jbuf != NULL, FALSE);
 969   g_return_val_if_fail (item != NULL, FALSE);
 970
 971   list = jbuf->packets->tail;
 972
 973   /* no seqnum, simply append then */
 974   if (item->seqnum == -1)
 975     goto append;
 976
 977   seqnum = item->seqnum;
 978
 979   /* loop the list to skip strictly larger seqnum buffers */
 980   for (; list; list = g_list_previous (list)) {
 981     guint16 qseq;
 982     gint gap;
 983     RTPJitterBufferItem *qitem = (RTPJitterBufferItem *) list;
 984
 985     if (qitem->seqnum == -1) {
 986       /* keep a pointer to the first consecutive event if not already
 987        * set. we will insert the packet after the event if we can't find
 988        * a packet with lower sequence number before the event. */
 989       if (event == NULL)
 990         event = list;
 991       continue;
 992     }
 993
 994     qseq = qitem->seqnum;
 995
 996     /* compare the new seqnum to the one in the buffer */
 997     gap = gst_rtp_buffer_compare_seqnum (seqnum, qseq);
 998
 999     /* we hit a packet with the same seqnum, notify a duplicate */
1000     if (G_UNLIKELY (gap == 0))
1001       goto duplicate;
1002
1003     /* seqnum > qseq, we can stop looking */
1004     if (G_LIKELY (gap < 0))
1005       break;
1006
1007     /* if we've found a packet with greater sequence number, cleanup the
1008      * event pointer as the packet will be inserted before the event */
1009     event = NULL;
1010   }
1011
1012   /* if event is set it means that packets before the event had smaller
1013    * sequence number, so we will insert our packet after the event */
1014   if (event)
1015     list = event;
1016
1017 append:
1018   queue_do_insert (jbuf, list, (GList *) item);
1019
1020   /* buffering mode, update buffer stats */
1021   if (jbuf->mode == RTP_JITTER_BUFFER_MODE_BUFFER)
1022     update_buffer_level (jbuf, percent);
1023   else if (percent)
1024     *percent = -1;
1025
1026   /* head was changed when we did not find a previous packet, we set the return
1027    * flag when requested. */
1028   if (G_LIKELY (head))
1029     *head = (list == NULL);
1030
1031   return TRUE;
1032
1033   /* ERRORS */
1034 duplicate:
1035   {
1036     GST_DEBUG ("duplicate packet %d found", (gint) seqnum);
1037     if (G_LIKELY (head))
1038       *head = FALSE;
1039     return FALSE;
1040   }
1041 }
1042
1043 /**
1044  * rtp_jitter_buffer_pop:
1045  * @jbuf: an #RTPJitterBuffer
1046  * @percent: the buffering percent
1047  *
1048  * Pops the oldest buffer from the packet queue of @jbuf. The popped buffer will
1049  * have its timestamp adjusted with the incomming running_time and the detected
1050  * clock skew.
1051  *
1052  * Returns: a #GstBuffer or %NULL when there was no packet in the queue.
1053  */
1054 RTPJitterBufferItem *
1055 rtp_jitter_buffer_pop (RTPJitterBuffer * jbuf, gint * percent)
1056 {
1057   GList *item = NULL;
1058   GQueue *queue;
1059
1060   g_return_val_if_fail (jbuf != NULL, NULL);
1061
1062   queue = jbuf->packets;
1063
1064   item = queue->head;
1065   if (item) {
1066     queue->head = item->next;
1067     if (queue->head)
1068       queue->head->prev = NULL;
1069     else
1070       queue->tail = NULL;
1071     queue->length--;
1072   }
1073
1074   /* buffering mode, update buffer stats */
1075   if (jbuf->mode == RTP_JITTER_BUFFER_MODE_BUFFER)
1076     update_buffer_level (jbuf, percent);
1077   else if (percent)
1078     *percent = -1;
1079
1080   return (RTPJitterBufferItem *) item;
1081 }
1082
1083 /**
1084  * rtp_jitter_buffer_peek:
1085  * @jbuf: an #RTPJitterBuffer
1086  *
1087  * Peek the oldest buffer from the packet queue of @jbuf.
1088  *
1089  * See rtp_jitter_buffer_insert() to check when an older packet was
1090  * added.
1091  *
1092  * Returns: a #GstBuffer or %NULL when there was no packet in the queue.
1093  */
1094 RTPJitterBufferItem *
1095 rtp_jitter_buffer_peek (RTPJitterBuffer * jbuf)
1096 {
1097   g_return_val_if_fail (jbuf != NULL, NULL);
1098
1099   return (RTPJitterBufferItem *) jbuf->packets->head;
1100 }
1101
1102 /**
1103  * rtp_jitter_buffer_flush:
1104  * @jbuf: an #RTPJitterBuffer
1105  * @free_func: function to free each item
1106  * @user_data: user data passed to @free_func
1107  *
1108  * Flush all packets from the jitterbuffer.
1109  */
1110 void
1111 rtp_jitter_buffer_flush (RTPJitterBuffer * jbuf, GFunc free_func,
1112     gpointer user_data)
1113 {
1114   GList *item;
1115
1116   g_return_if_fail (jbuf != NULL);
1117   g_return_if_fail (free_func != NULL);
1118
1119   while ((item = g_queue_pop_head_link (jbuf->packets)))
1120     free_func ((RTPJitterBufferItem *) item, user_data);
1121 }
1122
1123 /**
1124  * rtp_jitter_buffer_is_buffering:
1125  * @jbuf: an #RTPJitterBuffer
1126  *
1127  * Check if @jbuf is buffering currently. Users of the jitterbuffer should not
1128  * pop packets while in buffering mode.
1129  *
1130  * Returns: the buffering state of @jbuf
1131  */
1132 gboolean
1133 rtp_jitter_buffer_is_buffering (RTPJitterBuffer * jbuf)
1134 {
1135   return jbuf->buffering && !jbuf->buffering_disabled;
1136 }
1137
1138 /**
1139  * rtp_jitter_buffer_set_buffering:
1140  * @jbuf: an #RTPJitterBuffer
1141  * @buffering: the new buffering state
1142  *
1143  * Forces @jbuf to go into the buffering state.
1144  */
1145 void
1146 rtp_jitter_buffer_set_buffering (RTPJitterBuffer * jbuf, gboolean buffering)
1147 {
1148   jbuf->buffering = buffering;
1149 }
1150
1151 /**
1152  * rtp_jitter_buffer_get_percent:
1153  * @jbuf: an #RTPJitterBuffer
1154  *
1155  * Get the buffering percent of the jitterbuffer.
1156  *
1157  * Returns: the buffering percent
1158  */
1159 gint
1160 rtp_jitter_buffer_get_percent (RTPJitterBuffer * jbuf)
1161 {
1162   gint percent;
1163   guint64 level;
1164
1165   if (G_UNLIKELY (jbuf->high_level == 0))
1166     return 100;
1167
1168   if (G_UNLIKELY (jbuf->buffering_disabled))
1169     return 100;
1170
1171   level = get_buffer_level (jbuf);
1172   percent = (level * 100 / jbuf->high_level);
1173   percent = MIN (percent, 100);
1174
1175   return percent;
1176 }
1177
1178 /**
1179  * rtp_jitter_buffer_num_packets:
1180  * @jbuf: an #RTPJitterBuffer
1181  *
1182  * Get the number of packets currently in "jbuf.
1183  *
1184  * Returns: The number of packets in @jbuf.
1185  */
1186 guint
1187 rtp_jitter_buffer_num_packets (RTPJitterBuffer * jbuf)
1188 {
1189   g_return_val_if_fail (jbuf != NULL, 0);
1190
1191   return jbuf->packets->length;
1192 }
1193
1194 /**
1195  * rtp_jitter_buffer_get_ts_diff:
1196  * @jbuf: an #RTPJitterBuffer
1197  *
1198  * Get the difference between the timestamps of first and last packet in the
1199  * jitterbuffer.
1200  *
1201  * Returns: The difference expressed in the timestamp units of the packets.
1202  */
1203 guint32
1204 rtp_jitter_buffer_get_ts_diff (RTPJitterBuffer * jbuf)
1205 {
1206   guint64 high_ts, low_ts;
1207   RTPJitterBufferItem *high_buf, *low_buf;
1208   guint32 result;
1209
1210   g_return_val_if_fail (jbuf != NULL, 0);
1211
1212   high_buf = (RTPJitterBufferItem *) g_queue_peek_tail_link (jbuf->packets);
1213   low_buf = (RTPJitterBufferItem *) g_queue_peek_head_link (jbuf->packets);
1214
1215   if (!high_buf || !low_buf || high_buf == low_buf)
1216     return 0;
1217
1218   high_ts = high_buf->rtptime;
1219   low_ts = low_buf->rtptime;
1220
1221   /* it needs to work if ts wraps */
1222   if (high_ts >= low_ts) {
1223     result = (guint32) (high_ts - low_ts);
1224   } else {
1225     result = (guint32) (high_ts + G_MAXUINT32 + 1 - low_ts);
1226   }
1227   return result;
1228 }
1229
1230 /**
1231  * rtp_jitter_buffer_get_sync:
1232  * @jbuf: an #RTPJitterBuffer
1233  * @rtptime: result RTP time
1234  * @timestamp: result GStreamer timestamp
1235  * @clock_rate: clock-rate of @rtptime
1236  * @last_rtptime: last seen rtptime.
1237  *
1238  * Calculates the relation between the RTP timestamp and the GStreamer timestamp
1239  * used for constructing timestamps.
1240  *
1241  * For extended RTP timestamp @rtptime with a clock-rate of @clock_rate,
1242  * the GStreamer timestamp is currently @timestamp.
1243  *
1244  * The last seen extended RTP timestamp with clock-rate @clock-rate is returned in
1245  * @last_rtptime.
1246  */
1247 void
1248 rtp_jitter_buffer_get_sync (RTPJitterBuffer * jbuf, guint64 * rtptime,
1249     guint64 * timestamp, guint32 * clock_rate, guint64 * last_rtptime)
1250 {
1251   if (rtptime)
1252     *rtptime = jbuf->base_extrtp;
1253   if (timestamp)
1254     *timestamp = jbuf->base_time + jbuf->skew;
1255   if (clock_rate)
1256     *clock_rate = jbuf->clock_rate;
1257   if (last_rtptime)
1258     *last_rtptime = jbuf->last_rtptime;
1259 }
1260
1261 /**
1262  * rtp_jitter_buffer_can_fast_start:
1263  * @jbuf: an #RTPJitterBuffer
1264  * @num_packets: Number of consecutive packets needed
1265  *
1266  * Check if in the queue if there is enough packets with consecutive seqnum in
1267  * order to start delivering them.
1268  *
1269  * Returns: %TRUE if the required number of consecutive packets was found.
1270  */
1271 gboolean
1272 rtp_jitter_buffer_can_fast_start (RTPJitterBuffer * jbuf, gint num_packet)
1273 {
1274   gboolean ret = TRUE;
1275   RTPJitterBufferItem *last_item = NULL, *item;
1276   gint i;
1277
1278   if (rtp_jitter_buffer_num_packets (jbuf) < num_packet)
1279     return FALSE;
1280
1281   item = rtp_jitter_buffer_peek (jbuf);
1282   for (i = 0; i < num_packet; i++) {
1283     if (G_LIKELY (last_item)) {
1284       guint16 expected_seqnum = last_item->seqnum + 1;
1285
1286       if (expected_seqnum != item->seqnum) {
1287         ret = FALSE;
1288         break;
1289       }
1290     }
1291
1292     last_item = item;
1293     item = (RTPJitterBufferItem *) last_item->next;
1294   }
1295
1296   return ret;
1297 }