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