mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-09-09 13:48:55 +00:00
As we override the GLib item with our own structure, we cannot use any
function from GList or GQueue that would try to free the RTPJitterBufferItem.
In this patch, we move away from g_queue_new() which forces using
g_queue_free(). This this function could use g_slice_free() if there is any items
left in the queue. Passing the wrong size to GSLice may cause data corruption
and crash.
A better approach would be to use a proper intrusive linked list
implementation but that's left as an exercise for the next person
running into crashes caused by this.
Be ware that this regression was introduced 6 years ago in the following
commit [0], the call to flush() looked useless, as there was a g_queue_free()
afterward.
Signed-off-by: Nicolas Dufresne <nicolas.dufresne@collabora.com>
[0] 479c7642fd
Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/573>
1553 lines
44 KiB
C
1553 lines
44 KiB
C
/* GStreamer
|
|
* Copyright (C) <2007> Wim Taymans <wim.taymans@gmail.com>
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Library General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Library General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Library General Public
|
|
* License along with this library; if not, write to the
|
|
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
|
|
* Boston, MA 02110-1301, USA.
|
|
*/
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
|
|
#include <gst/rtp/gstrtpbuffer.h>
|
|
#include <gst/rtp/gstrtcpbuffer.h>
|
|
|
|
#include "rtpjitterbuffer.h"
|
|
|
|
GST_DEBUG_CATEGORY_STATIC (rtp_jitter_buffer_debug);
|
|
#define GST_CAT_DEFAULT rtp_jitter_buffer_debug
|
|
|
|
#define MAX_WINDOW RTP_JITTER_BUFFER_MAX_WINDOW
|
|
#define MAX_TIME (2 * GST_SECOND)
|
|
|
|
/* signals and args */
|
|
enum
|
|
{
|
|
LAST_SIGNAL
|
|
};
|
|
|
|
enum
|
|
{
|
|
PROP_0
|
|
};
|
|
|
|
/* GObject vmethods */
|
|
static void rtp_jitter_buffer_finalize (GObject * object);
|
|
|
|
GType
|
|
rtp_jitter_buffer_mode_get_type (void)
|
|
{
|
|
static GType jitter_buffer_mode_type = 0;
|
|
static const GEnumValue jitter_buffer_modes[] = {
|
|
{RTP_JITTER_BUFFER_MODE_NONE, "Only use RTP timestamps", "none"},
|
|
{RTP_JITTER_BUFFER_MODE_SLAVE, "Slave receiver to sender clock", "slave"},
|
|
{RTP_JITTER_BUFFER_MODE_BUFFER, "Do low/high watermark buffering",
|
|
"buffer"},
|
|
{RTP_JITTER_BUFFER_MODE_SYNCED, "Synchronized sender and receiver clocks",
|
|
"synced"},
|
|
{0, NULL, NULL},
|
|
};
|
|
|
|
if (!jitter_buffer_mode_type) {
|
|
jitter_buffer_mode_type =
|
|
g_enum_register_static ("RTPJitterBufferMode", jitter_buffer_modes);
|
|
}
|
|
return jitter_buffer_mode_type;
|
|
}
|
|
|
|
/* static guint rtp_jitter_buffer_signals[LAST_SIGNAL] = { 0 }; */
|
|
|
|
G_DEFINE_TYPE (RTPJitterBuffer, rtp_jitter_buffer, G_TYPE_OBJECT);
|
|
|
|
static void
|
|
rtp_jitter_buffer_class_init (RTPJitterBufferClass * klass)
|
|
{
|
|
GObjectClass *gobject_class;
|
|
|
|
gobject_class = (GObjectClass *) klass;
|
|
|
|
gobject_class->finalize = rtp_jitter_buffer_finalize;
|
|
|
|
GST_DEBUG_CATEGORY_INIT (rtp_jitter_buffer_debug, "rtpjitterbuffer", 0,
|
|
"RTP Jitter Buffer");
|
|
}
|
|
|
|
static void
|
|
rtp_jitter_buffer_init (RTPJitterBuffer * jbuf)
|
|
{
|
|
g_mutex_init (&jbuf->clock_lock);
|
|
|
|
g_queue_init (&jbuf->packets);
|
|
jbuf->mode = RTP_JITTER_BUFFER_MODE_SLAVE;
|
|
|
|
rtp_jitter_buffer_reset_skew (jbuf);
|
|
}
|
|
|
|
static void
|
|
rtp_jitter_buffer_finalize (GObject * object)
|
|
{
|
|
RTPJitterBuffer *jbuf;
|
|
|
|
jbuf = RTP_JITTER_BUFFER_CAST (object);
|
|
|
|
if (jbuf->media_clock_synced_id)
|
|
g_signal_handler_disconnect (jbuf->media_clock,
|
|
jbuf->media_clock_synced_id);
|
|
if (jbuf->media_clock) {
|
|
/* Make sure to clear any clock master before releasing the clock */
|
|
gst_clock_set_master (jbuf->media_clock, NULL);
|
|
gst_object_unref (jbuf->media_clock);
|
|
}
|
|
|
|
if (jbuf->pipeline_clock)
|
|
gst_object_unref (jbuf->pipeline_clock);
|
|
|
|
/* We cannot use g_queue_clear() as it would pass the wrong size to
|
|
* g_slice_free() which may lead to data corruption in the slice allocator.
|
|
*/
|
|
rtp_jitter_buffer_flush (jbuf, NULL, NULL);
|
|
|
|
g_mutex_clear (&jbuf->clock_lock);
|
|
|
|
G_OBJECT_CLASS (rtp_jitter_buffer_parent_class)->finalize (object);
|
|
}
|
|
|
|
/**
|
|
* rtp_jitter_buffer_new:
|
|
*
|
|
* Create an #RTPJitterBuffer.
|
|
*
|
|
* Returns: a new #RTPJitterBuffer. Use g_object_unref() after usage.
|
|
*/
|
|
RTPJitterBuffer *
|
|
rtp_jitter_buffer_new (void)
|
|
{
|
|
RTPJitterBuffer *jbuf;
|
|
|
|
jbuf = g_object_new (RTP_TYPE_JITTER_BUFFER, NULL);
|
|
|
|
return jbuf;
|
|
}
|
|
|
|
/**
|
|
* rtp_jitter_buffer_get_mode:
|
|
* @jbuf: an #RTPJitterBuffer
|
|
*
|
|
* Get the current jitterbuffer mode.
|
|
*
|
|
* Returns: the current jitterbuffer mode.
|
|
*/
|
|
RTPJitterBufferMode
|
|
rtp_jitter_buffer_get_mode (RTPJitterBuffer * jbuf)
|
|
{
|
|
return jbuf->mode;
|
|
}
|
|
|
|
/**
|
|
* rtp_jitter_buffer_set_mode:
|
|
* @jbuf: an #RTPJitterBuffer
|
|
* @mode: a #RTPJitterBufferMode
|
|
*
|
|
* Set the buffering and clock slaving algorithm used in the @jbuf.
|
|
*/
|
|
void
|
|
rtp_jitter_buffer_set_mode (RTPJitterBuffer * jbuf, RTPJitterBufferMode mode)
|
|
{
|
|
jbuf->mode = mode;
|
|
}
|
|
|
|
GstClockTime
|
|
rtp_jitter_buffer_get_delay (RTPJitterBuffer * jbuf)
|
|
{
|
|
return jbuf->delay;
|
|
}
|
|
|
|
void
|
|
rtp_jitter_buffer_set_delay (RTPJitterBuffer * jbuf, GstClockTime delay)
|
|
{
|
|
jbuf->delay = delay;
|
|
jbuf->low_level = (delay * 15) / 100;
|
|
/* the high level is at 90% in order to release packets before we fill up the
|
|
* buffer up to the latency */
|
|
jbuf->high_level = (delay * 90) / 100;
|
|
|
|
GST_DEBUG ("delay %" GST_TIME_FORMAT ", min %" GST_TIME_FORMAT ", max %"
|
|
GST_TIME_FORMAT, GST_TIME_ARGS (jbuf->delay),
|
|
GST_TIME_ARGS (jbuf->low_level), GST_TIME_ARGS (jbuf->high_level));
|
|
}
|
|
|
|
/**
|
|
* rtp_jitter_buffer_set_clock_rate:
|
|
* @jbuf: an #RTPJitterBuffer
|
|
* @clock_rate: the new clock rate
|
|
*
|
|
* Set the clock rate in the jitterbuffer.
|
|
*/
|
|
void
|
|
rtp_jitter_buffer_set_clock_rate (RTPJitterBuffer * jbuf, guint32 clock_rate)
|
|
{
|
|
if (jbuf->clock_rate != clock_rate) {
|
|
GST_DEBUG ("Clock rate changed from %" G_GUINT32_FORMAT " to %"
|
|
G_GUINT32_FORMAT, jbuf->clock_rate, clock_rate);
|
|
jbuf->clock_rate = clock_rate;
|
|
rtp_jitter_buffer_reset_skew (jbuf);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* rtp_jitter_buffer_get_clock_rate:
|
|
* @jbuf: an #RTPJitterBuffer
|
|
*
|
|
* Get the currently configure clock rate in @jbuf.
|
|
*
|
|
* Returns: the current clock-rate
|
|
*/
|
|
guint32
|
|
rtp_jitter_buffer_get_clock_rate (RTPJitterBuffer * jbuf)
|
|
{
|
|
return jbuf->clock_rate;
|
|
}
|
|
|
|
static void
|
|
media_clock_synced_cb (GstClock * clock, gboolean synced,
|
|
RTPJitterBuffer * jbuf)
|
|
{
|
|
GstClockTime internal, external;
|
|
|
|
g_mutex_lock (&jbuf->clock_lock);
|
|
if (jbuf->pipeline_clock) {
|
|
internal = gst_clock_get_internal_time (jbuf->media_clock);
|
|
external = gst_clock_get_time (jbuf->pipeline_clock);
|
|
|
|
gst_clock_set_calibration (jbuf->media_clock, internal, external, 1, 1);
|
|
}
|
|
g_mutex_unlock (&jbuf->clock_lock);
|
|
}
|
|
|
|
/**
|
|
* rtp_jitter_buffer_set_media_clock:
|
|
* @jbuf: an #RTPJitterBuffer
|
|
* @clock: (transfer full): media #GstClock
|
|
* @clock_offset: RTP time at clock epoch or -1
|
|
*
|
|
* Sets the media clock for the media and the clock offset
|
|
*
|
|
*/
|
|
void
|
|
rtp_jitter_buffer_set_media_clock (RTPJitterBuffer * jbuf, GstClock * clock,
|
|
guint64 clock_offset)
|
|
{
|
|
g_mutex_lock (&jbuf->clock_lock);
|
|
if (jbuf->media_clock) {
|
|
if (jbuf->media_clock_synced_id)
|
|
g_signal_handler_disconnect (jbuf->media_clock,
|
|
jbuf->media_clock_synced_id);
|
|
jbuf->media_clock_synced_id = 0;
|
|
gst_object_unref (jbuf->media_clock);
|
|
}
|
|
jbuf->media_clock = clock;
|
|
jbuf->media_clock_offset = clock_offset;
|
|
|
|
if (jbuf->pipeline_clock && jbuf->media_clock &&
|
|
jbuf->pipeline_clock != jbuf->media_clock) {
|
|
jbuf->media_clock_synced_id =
|
|
g_signal_connect (jbuf->media_clock, "synced",
|
|
G_CALLBACK (media_clock_synced_cb), jbuf);
|
|
if (gst_clock_is_synced (jbuf->media_clock)) {
|
|
GstClockTime internal, external;
|
|
|
|
internal = gst_clock_get_internal_time (jbuf->media_clock);
|
|
external = gst_clock_get_time (jbuf->pipeline_clock);
|
|
|
|
gst_clock_set_calibration (jbuf->media_clock, internal, external, 1, 1);
|
|
}
|
|
|
|
gst_clock_set_master (jbuf->media_clock, jbuf->pipeline_clock);
|
|
}
|
|
g_mutex_unlock (&jbuf->clock_lock);
|
|
}
|
|
|
|
/**
|
|
* rtp_jitter_buffer_set_pipeline_clock:
|
|
* @jbuf: an #RTPJitterBuffer
|
|
* @clock: pipeline #GstClock
|
|
*
|
|
* Sets the pipeline clock
|
|
*
|
|
*/
|
|
void
|
|
rtp_jitter_buffer_set_pipeline_clock (RTPJitterBuffer * jbuf, GstClock * clock)
|
|
{
|
|
g_mutex_lock (&jbuf->clock_lock);
|
|
if (jbuf->pipeline_clock)
|
|
gst_object_unref (jbuf->pipeline_clock);
|
|
jbuf->pipeline_clock = clock ? gst_object_ref (clock) : NULL;
|
|
|
|
if (jbuf->pipeline_clock && jbuf->media_clock &&
|
|
jbuf->pipeline_clock != jbuf->media_clock) {
|
|
if (gst_clock_is_synced (jbuf->media_clock)) {
|
|
GstClockTime internal, external;
|
|
|
|
internal = gst_clock_get_internal_time (jbuf->media_clock);
|
|
external = gst_clock_get_time (jbuf->pipeline_clock);
|
|
|
|
gst_clock_set_calibration (jbuf->media_clock, internal, external, 1, 1);
|
|
}
|
|
|
|
gst_clock_set_master (jbuf->media_clock, jbuf->pipeline_clock);
|
|
}
|
|
g_mutex_unlock (&jbuf->clock_lock);
|
|
}
|
|
|
|
gboolean
|
|
rtp_jitter_buffer_get_rfc7273_sync (RTPJitterBuffer * jbuf)
|
|
{
|
|
return jbuf->rfc7273_sync;
|
|
}
|
|
|
|
void
|
|
rtp_jitter_buffer_set_rfc7273_sync (RTPJitterBuffer * jbuf,
|
|
gboolean rfc7273_sync)
|
|
{
|
|
jbuf->rfc7273_sync = rfc7273_sync;
|
|
}
|
|
|
|
/**
|
|
* rtp_jitter_buffer_reset_skew:
|
|
* @jbuf: an #RTPJitterBuffer
|
|
*
|
|
* Reset the skew calculations in @jbuf.
|
|
*/
|
|
void
|
|
rtp_jitter_buffer_reset_skew (RTPJitterBuffer * jbuf)
|
|
{
|
|
jbuf->base_time = -1;
|
|
jbuf->base_rtptime = -1;
|
|
jbuf->base_extrtp = -1;
|
|
jbuf->media_clock_base_time = -1;
|
|
jbuf->ext_rtptime = -1;
|
|
jbuf->last_rtptime = -1;
|
|
jbuf->window_pos = 0;
|
|
jbuf->window_filling = TRUE;
|
|
jbuf->window_min = 0;
|
|
jbuf->skew = 0;
|
|
jbuf->prev_send_diff = -1;
|
|
jbuf->prev_out_time = -1;
|
|
jbuf->need_resync = TRUE;
|
|
|
|
GST_DEBUG ("reset skew correction");
|
|
}
|
|
|
|
/**
|
|
* rtp_jitter_buffer_disable_buffering:
|
|
* @jbuf: an #RTPJitterBuffer
|
|
* @disabled: the new state
|
|
*
|
|
* Enable or disable buffering on @jbuf.
|
|
*/
|
|
void
|
|
rtp_jitter_buffer_disable_buffering (RTPJitterBuffer * jbuf, gboolean disabled)
|
|
{
|
|
jbuf->buffering_disabled = disabled;
|
|
}
|
|
|
|
static void
|
|
rtp_jitter_buffer_resync (RTPJitterBuffer * jbuf, GstClockTime time,
|
|
GstClockTime gstrtptime, guint64 ext_rtptime, gboolean reset_skew)
|
|
{
|
|
jbuf->base_time = time;
|
|
jbuf->media_clock_base_time = -1;
|
|
jbuf->base_rtptime = gstrtptime;
|
|
jbuf->base_extrtp = ext_rtptime;
|
|
jbuf->prev_out_time = -1;
|
|
jbuf->prev_send_diff = -1;
|
|
if (reset_skew) {
|
|
jbuf->window_filling = TRUE;
|
|
jbuf->window_pos = 0;
|
|
jbuf->window_min = 0;
|
|
jbuf->window_size = 0;
|
|
jbuf->skew = 0;
|
|
}
|
|
jbuf->need_resync = FALSE;
|
|
}
|
|
|
|
static guint64
|
|
get_buffer_level (RTPJitterBuffer * jbuf)
|
|
{
|
|
RTPJitterBufferItem *high_buf = NULL, *low_buf = NULL;
|
|
guint64 level;
|
|
|
|
/* first buffer with timestamp */
|
|
high_buf = (RTPJitterBufferItem *) g_queue_peek_tail_link (&jbuf->packets);
|
|
while (high_buf) {
|
|
if (high_buf->dts != -1 || high_buf->pts != -1)
|
|
break;
|
|
|
|
high_buf = (RTPJitterBufferItem *) g_list_previous (high_buf);
|
|
}
|
|
|
|
low_buf = (RTPJitterBufferItem *) g_queue_peek_head_link (&jbuf->packets);
|
|
while (low_buf) {
|
|
if (low_buf->dts != -1 || low_buf->pts != -1)
|
|
break;
|
|
|
|
low_buf = (RTPJitterBufferItem *) g_list_next (low_buf);
|
|
}
|
|
|
|
if (!high_buf || !low_buf || high_buf == low_buf) {
|
|
level = 0;
|
|
} else {
|
|
guint64 high_ts, low_ts;
|
|
|
|
high_ts = high_buf->dts != -1 ? high_buf->dts : high_buf->pts;
|
|
low_ts = low_buf->dts != -1 ? low_buf->dts : low_buf->pts;
|
|
|
|
if (high_ts > low_ts)
|
|
level = high_ts - low_ts;
|
|
else
|
|
level = 0;
|
|
|
|
GST_LOG_OBJECT (jbuf,
|
|
"low %" GST_TIME_FORMAT " high %" GST_TIME_FORMAT " level %"
|
|
G_GUINT64_FORMAT, GST_TIME_ARGS (low_ts), GST_TIME_ARGS (high_ts),
|
|
level);
|
|
}
|
|
return level;
|
|
}
|
|
|
|
static void
|
|
update_buffer_level (RTPJitterBuffer * jbuf, gint * percent)
|
|
{
|
|
gboolean post = FALSE;
|
|
guint64 level;
|
|
|
|
level = get_buffer_level (jbuf);
|
|
GST_DEBUG ("buffer level %" GST_TIME_FORMAT, GST_TIME_ARGS (level));
|
|
|
|
if (jbuf->buffering_disabled) {
|
|
GST_DEBUG ("buffering is disabled");
|
|
level = jbuf->high_level;
|
|
}
|
|
|
|
if (jbuf->buffering) {
|
|
post = TRUE;
|
|
if (level >= jbuf->high_level) {
|
|
GST_DEBUG ("buffering finished");
|
|
jbuf->buffering = FALSE;
|
|
}
|
|
} else {
|
|
if (level < jbuf->low_level) {
|
|
GST_DEBUG ("buffering started");
|
|
jbuf->buffering = TRUE;
|
|
post = TRUE;
|
|
}
|
|
}
|
|
if (post) {
|
|
gint perc;
|
|
|
|
if (jbuf->buffering && (jbuf->high_level != 0)) {
|
|
perc = (level * 100 / jbuf->high_level);
|
|
perc = MIN (perc, 100);
|
|
} else {
|
|
perc = 100;
|
|
}
|
|
|
|
if (percent)
|
|
*percent = perc;
|
|
|
|
GST_DEBUG ("buffering %d", perc);
|
|
}
|
|
}
|
|
|
|
/* For the clock skew we use a windowed low point averaging algorithm as can be
|
|
* found in Fober, Orlarey and Letz, 2005, "Real Time Clock Skew Estimation
|
|
* over Network Delays":
|
|
* http://www.grame.fr/Ressources/pub/TR-050601.pdf
|
|
* http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.102.1546
|
|
*
|
|
* The idea is that the jitter is composed of:
|
|
*
|
|
* J = N + n
|
|
*
|
|
* N : a constant network delay.
|
|
* n : random added noise. The noise is concentrated around 0
|
|
*
|
|
* In the receiver we can track the elapsed time at the sender with:
|
|
*
|
|
* send_diff(i) = (Tsi - Ts0);
|
|
*
|
|
* Tsi : The time at the sender at packet i
|
|
* Ts0 : The time at the sender at the first packet
|
|
*
|
|
* This is the difference between the RTP timestamp in the first received packet
|
|
* and the current packet.
|
|
*
|
|
* At the receiver we have to deal with the jitter introduced by the network.
|
|
*
|
|
* recv_diff(i) = (Tri - Tr0)
|
|
*
|
|
* Tri : The time at the receiver at packet i
|
|
* Tr0 : The time at the receiver at the first packet
|
|
*
|
|
* Both of these values contain a jitter Ji, a jitter for packet i, so we can
|
|
* write:
|
|
*
|
|
* recv_diff(i) = (Cri + D + ni) - (Cr0 + D + n0))
|
|
*
|
|
* Cri : The time of the clock at the receiver for packet i
|
|
* D + ni : The jitter when receiving packet i
|
|
*
|
|
* We see that the network delay is irrelevant here as we can eliminate D:
|
|
*
|
|
* recv_diff(i) = (Cri + ni) - (Cr0 + n0))
|
|
*
|
|
* The drift is now expressed as:
|
|
*
|
|
* Drift(i) = recv_diff(i) - send_diff(i);
|
|
*
|
|
* We now keep the W latest values of Drift and find the minimum (this is the
|
|
* one with the lowest network jitter and thus the one which is least affected
|
|
* by it). We average this lowest value to smooth out the resulting network skew.
|
|
*
|
|
* Both the window and the weighting used for averaging influence the accuracy
|
|
* of the drift estimation. Finding the correct parameters turns out to be a
|
|
* compromise between accuracy and inertia.
|
|
*
|
|
* We use a 2 second window or up to 512 data points, which is statistically big
|
|
* enough to catch spikes (FIXME, detect spikes).
|
|
* We also use a rather large weighting factor (125) to smoothly adapt. During
|
|
* startup, when filling the window, we use a parabolic weighting factor, the
|
|
* more the window is filled, the faster we move to the detected possible skew.
|
|
*
|
|
* Returns: @time adjusted with the clock skew.
|
|
*/
|
|
static GstClockTime
|
|
calculate_skew (RTPJitterBuffer * jbuf, guint64 ext_rtptime,
|
|
GstClockTime gstrtptime, GstClockTime time, gint gap, gboolean is_rtx)
|
|
{
|
|
guint64 send_diff, recv_diff;
|
|
gint64 delta;
|
|
gint64 old;
|
|
gint pos, i;
|
|
GstClockTime out_time;
|
|
guint64 slope;
|
|
|
|
/* elapsed time at sender */
|
|
send_diff = gstrtptime - jbuf->base_rtptime;
|
|
|
|
/* we don't have an arrival timestamp so we can't do skew detection. we
|
|
* should still apply a timestamp based on RTP timestamp and base_time */
|
|
if (time == -1 || jbuf->base_time == -1 || is_rtx)
|
|
goto no_skew;
|
|
|
|
/* elapsed time at receiver, includes the jitter */
|
|
recv_diff = time - jbuf->base_time;
|
|
|
|
/* measure the diff */
|
|
delta = ((gint64) recv_diff) - ((gint64) send_diff);
|
|
|
|
/* measure the slope, this gives a rought estimate between the sender speed
|
|
* and the receiver speed. This should be approximately 8, higher values
|
|
* indicate a burst (especially when the connection starts) */
|
|
if (recv_diff > 0)
|
|
slope = (send_diff * 8) / recv_diff;
|
|
else
|
|
slope = 8;
|
|
|
|
GST_DEBUG ("time %" GST_TIME_FORMAT ", base %" GST_TIME_FORMAT ", recv_diff %"
|
|
GST_TIME_FORMAT ", slope %" G_GUINT64_FORMAT, GST_TIME_ARGS (time),
|
|
GST_TIME_ARGS (jbuf->base_time), GST_TIME_ARGS (recv_diff), slope);
|
|
|
|
/* if the difference between the sender timeline and the receiver timeline
|
|
* changed too quickly we have to resync because the server likely restarted
|
|
* its timestamps. */
|
|
if (ABS (delta - jbuf->skew) > GST_SECOND) {
|
|
GST_WARNING ("delta - skew: %" GST_TIME_FORMAT " too big, reset skew",
|
|
GST_TIME_ARGS (ABS (delta - jbuf->skew)));
|
|
rtp_jitter_buffer_resync (jbuf, time, gstrtptime, ext_rtptime, TRUE);
|
|
send_diff = 0;
|
|
delta = 0;
|
|
gap = 0;
|
|
}
|
|
|
|
/* only do skew calculations if we didn't have a gap. if too much time
|
|
* has elapsed despite there being a gap, we resynced already. */
|
|
if (G_UNLIKELY (gap != 0))
|
|
goto no_skew;
|
|
|
|
pos = jbuf->window_pos;
|
|
|
|
if (G_UNLIKELY (jbuf->window_filling)) {
|
|
/* we are filling the window */
|
|
GST_DEBUG ("filling %d, delta %" G_GINT64_FORMAT, pos, delta);
|
|
jbuf->window[pos++] = delta;
|
|
/* calc the min delta we observed */
|
|
if (G_UNLIKELY (pos == 1 || delta < jbuf->window_min))
|
|
jbuf->window_min = delta;
|
|
|
|
if (G_UNLIKELY (send_diff >= MAX_TIME || pos >= MAX_WINDOW)) {
|
|
jbuf->window_size = pos;
|
|
|
|
/* window filled */
|
|
GST_DEBUG ("min %" G_GINT64_FORMAT, jbuf->window_min);
|
|
|
|
/* the skew is now the min */
|
|
jbuf->skew = jbuf->window_min;
|
|
jbuf->window_filling = FALSE;
|
|
} else {
|
|
gint perc_time, perc_window, perc;
|
|
|
|
/* figure out how much we filled the window, this depends on the amount of
|
|
* time we have or the max number of points we keep. */
|
|
perc_time = send_diff * 100 / MAX_TIME;
|
|
perc_window = pos * 100 / MAX_WINDOW;
|
|
perc = MAX (perc_time, perc_window);
|
|
|
|
/* make a parabolic function, the closer we get to the MAX, the more value
|
|
* we give to the scaling factor of the new value */
|
|
perc = perc * perc;
|
|
|
|
/* quickly go to the min value when we are filling up, slowly when we are
|
|
* just starting because we're not sure it's a good value yet. */
|
|
jbuf->skew =
|
|
(perc * jbuf->window_min + ((10000 - perc) * jbuf->skew)) / 10000;
|
|
jbuf->window_size = pos + 1;
|
|
}
|
|
} else {
|
|
/* pick old value and store new value. We keep the previous value in order
|
|
* to quickly check if the min of the window changed */
|
|
old = jbuf->window[pos];
|
|
jbuf->window[pos++] = delta;
|
|
|
|
if (G_UNLIKELY (delta <= jbuf->window_min)) {
|
|
/* if the new value we inserted is smaller or equal to the current min,
|
|
* it becomes the new min */
|
|
jbuf->window_min = delta;
|
|
} else if (G_UNLIKELY (old == jbuf->window_min)) {
|
|
gint64 min = G_MAXINT64;
|
|
|
|
/* if we removed the old min, we have to find a new min */
|
|
for (i = 0; i < jbuf->window_size; i++) {
|
|
/* we found another value equal to the old min, we can stop searching now */
|
|
if (jbuf->window[i] == old) {
|
|
min = old;
|
|
break;
|
|
}
|
|
if (jbuf->window[i] < min)
|
|
min = jbuf->window[i];
|
|
}
|
|
jbuf->window_min = min;
|
|
}
|
|
/* average the min values */
|
|
jbuf->skew = (jbuf->window_min + (124 * jbuf->skew)) / 125;
|
|
GST_DEBUG ("delta %" G_GINT64_FORMAT ", new min: %" G_GINT64_FORMAT,
|
|
delta, jbuf->window_min);
|
|
}
|
|
/* wrap around in the window */
|
|
if (G_UNLIKELY (pos >= jbuf->window_size))
|
|
pos = 0;
|
|
jbuf->window_pos = pos;
|
|
|
|
no_skew:
|
|
/* the output time is defined as the base timestamp plus the RTP time
|
|
* adjusted for the clock skew .*/
|
|
if (jbuf->base_time != -1) {
|
|
out_time = jbuf->base_time + send_diff;
|
|
/* skew can be negative and we don't want to make invalid timestamps */
|
|
if (jbuf->skew < 0 && out_time < -jbuf->skew) {
|
|
out_time = 0;
|
|
} else {
|
|
out_time += jbuf->skew;
|
|
}
|
|
} else
|
|
out_time = -1;
|
|
|
|
GST_DEBUG ("skew %" G_GINT64_FORMAT ", out %" GST_TIME_FORMAT,
|
|
jbuf->skew, GST_TIME_ARGS (out_time));
|
|
|
|
return out_time;
|
|
}
|
|
|
|
static void
|
|
queue_do_insert (RTPJitterBuffer * jbuf, GList * list, GList * item)
|
|
{
|
|
GQueue *queue = &jbuf->packets;
|
|
|
|
/* It's more likely that the packet was inserted at the tail of the queue */
|
|
if (G_LIKELY (list)) {
|
|
item->prev = list;
|
|
item->next = list->next;
|
|
list->next = item;
|
|
} else {
|
|
item->prev = NULL;
|
|
item->next = queue->head;
|
|
queue->head = item;
|
|
}
|
|
if (item->next)
|
|
item->next->prev = item;
|
|
else
|
|
queue->tail = item;
|
|
queue->length++;
|
|
}
|
|
|
|
GstClockTime
|
|
rtp_jitter_buffer_calculate_pts (RTPJitterBuffer * jbuf, GstClockTime dts,
|
|
gboolean estimated_dts, guint32 rtptime, GstClockTime base_time,
|
|
gint gap, gboolean is_rtx)
|
|
{
|
|
guint64 ext_rtptime;
|
|
GstClockTime gstrtptime, pts;
|
|
GstClock *media_clock, *pipeline_clock;
|
|
guint64 media_clock_offset;
|
|
gboolean rfc7273_mode;
|
|
|
|
/* rtp time jumps are checked for during skew calculation, but bypassed
|
|
* in other mode, so mind those here and reset jb if needed.
|
|
* Only reset if valid input time, which is likely for UDP input
|
|
* where we expect this might happen due to async thread effects
|
|
* (in seek and state change cycles), but not so much for TCP input */
|
|
if (GST_CLOCK_TIME_IS_VALID (dts) && !estimated_dts &&
|
|
jbuf->mode != RTP_JITTER_BUFFER_MODE_SLAVE &&
|
|
jbuf->base_time != -1 && jbuf->last_rtptime != -1) {
|
|
GstClockTime ext_rtptime = jbuf->ext_rtptime;
|
|
|
|
ext_rtptime = gst_rtp_buffer_ext_timestamp (&ext_rtptime, rtptime);
|
|
if (ext_rtptime > jbuf->last_rtptime + 3 * jbuf->clock_rate ||
|
|
ext_rtptime + 3 * jbuf->clock_rate < jbuf->last_rtptime) {
|
|
if (!is_rtx) {
|
|
/* reset even if we don't have valid incoming time;
|
|
* still better than producing possibly very bogus output timestamp */
|
|
GST_WARNING ("rtp delta too big, reset skew");
|
|
rtp_jitter_buffer_reset_skew (jbuf);
|
|
} else {
|
|
GST_WARNING ("rtp delta too big: ignore rtx packet");
|
|
media_clock = NULL;
|
|
pipeline_clock = NULL;
|
|
pts = GST_CLOCK_TIME_NONE;
|
|
goto done;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Return the last time if we got the same RTP timestamp again */
|
|
ext_rtptime = gst_rtp_buffer_ext_timestamp (&jbuf->ext_rtptime, rtptime);
|
|
if (jbuf->last_rtptime != -1 && ext_rtptime == jbuf->last_rtptime) {
|
|
return jbuf->prev_out_time;
|
|
}
|
|
|
|
/* keep track of the last extended rtptime */
|
|
jbuf->last_rtptime = ext_rtptime;
|
|
|
|
g_mutex_lock (&jbuf->clock_lock);
|
|
media_clock = jbuf->media_clock ? gst_object_ref (jbuf->media_clock) : NULL;
|
|
pipeline_clock =
|
|
jbuf->pipeline_clock ? gst_object_ref (jbuf->pipeline_clock) : NULL;
|
|
media_clock_offset = jbuf->media_clock_offset;
|
|
g_mutex_unlock (&jbuf->clock_lock);
|
|
|
|
gstrtptime =
|
|
gst_util_uint64_scale_int (ext_rtptime, GST_SECOND, jbuf->clock_rate);
|
|
|
|
if (G_LIKELY (jbuf->base_rtptime != -1)) {
|
|
/* check elapsed time in RTP units */
|
|
if (gstrtptime < jbuf->base_rtptime) {
|
|
if (!is_rtx) {
|
|
/* elapsed time at sender, timestamps can go backwards and thus be
|
|
* smaller than our base time, schedule to take a new base time in
|
|
* that case. */
|
|
GST_WARNING ("backward timestamps at server, schedule resync");
|
|
jbuf->need_resync = TRUE;
|
|
} else {
|
|
GST_WARNING ("backward timestamps: ignore rtx packet");
|
|
pts = GST_CLOCK_TIME_NONE;
|
|
goto done;
|
|
}
|
|
}
|
|
}
|
|
|
|
switch (jbuf->mode) {
|
|
case RTP_JITTER_BUFFER_MODE_NONE:
|
|
case RTP_JITTER_BUFFER_MODE_BUFFER:
|
|
/* send 0 as the first timestamp and -1 for the other ones. This will
|
|
* interpolate them from the RTP timestamps with a 0 origin. In buffering
|
|
* mode we will adjust the outgoing timestamps according to the amount of
|
|
* time we spent buffering. */
|
|
if (jbuf->base_time == -1)
|
|
dts = 0;
|
|
else
|
|
dts = -1;
|
|
break;
|
|
case RTP_JITTER_BUFFER_MODE_SYNCED:
|
|
/* synchronized clocks, take first timestamp as base, use RTP timestamps
|
|
* to interpolate */
|
|
if (jbuf->base_time != -1 && !jbuf->need_resync)
|
|
dts = -1;
|
|
break;
|
|
case RTP_JITTER_BUFFER_MODE_SLAVE:
|
|
default:
|
|
break;
|
|
}
|
|
|
|
/* need resync, lock on to time and gstrtptime if we can, otherwise we
|
|
* do with the previous values */
|
|
if (G_UNLIKELY (jbuf->need_resync && dts != -1)) {
|
|
if (is_rtx) {
|
|
GST_DEBUG ("not resyncing on rtx packet, discard");
|
|
pts = GST_CLOCK_TIME_NONE;
|
|
goto done;
|
|
}
|
|
GST_INFO ("resync to time %" GST_TIME_FORMAT ", rtptime %"
|
|
GST_TIME_FORMAT, GST_TIME_ARGS (dts), GST_TIME_ARGS (gstrtptime));
|
|
rtp_jitter_buffer_resync (jbuf, dts, gstrtptime, ext_rtptime, FALSE);
|
|
}
|
|
|
|
GST_DEBUG ("extrtp %" G_GUINT64_FORMAT ", gstrtp %" GST_TIME_FORMAT ", base %"
|
|
GST_TIME_FORMAT ", send_diff %" GST_TIME_FORMAT, ext_rtptime,
|
|
GST_TIME_ARGS (gstrtptime), GST_TIME_ARGS (jbuf->base_rtptime),
|
|
GST_TIME_ARGS (gstrtptime - jbuf->base_rtptime));
|
|
|
|
rfc7273_mode = media_clock && pipeline_clock
|
|
&& gst_clock_is_synced (media_clock);
|
|
|
|
if (rfc7273_mode && jbuf->mode == RTP_JITTER_BUFFER_MODE_SLAVE
|
|
&& (media_clock_offset == -1 || !jbuf->rfc7273_sync)) {
|
|
GstClockTime internal, external;
|
|
GstClockTime rate_num, rate_denom;
|
|
GstClockTime nsrtptimediff, rtpntptime, rtpsystime;
|
|
|
|
gst_clock_get_calibration (media_clock, &internal, &external, &rate_num,
|
|
&rate_denom);
|
|
|
|
/* Slave to the RFC7273 media clock instead of trying to estimate it
|
|
* based on receive times and RTP timestamps */
|
|
|
|
if (jbuf->media_clock_base_time == -1) {
|
|
if (jbuf->base_time != -1) {
|
|
jbuf->media_clock_base_time =
|
|
gst_clock_unadjust_with_calibration (media_clock,
|
|
jbuf->base_time + base_time, internal, external, rate_num,
|
|
rate_denom);
|
|
} else {
|
|
if (dts != -1)
|
|
jbuf->media_clock_base_time =
|
|
gst_clock_unadjust_with_calibration (media_clock, dts + base_time,
|
|
internal, external, rate_num, rate_denom);
|
|
else
|
|
jbuf->media_clock_base_time =
|
|
gst_clock_get_internal_time (media_clock);
|
|
jbuf->base_rtptime = gstrtptime;
|
|
}
|
|
}
|
|
|
|
if (gstrtptime > jbuf->base_rtptime)
|
|
nsrtptimediff = gstrtptime - jbuf->base_rtptime;
|
|
else
|
|
nsrtptimediff = 0;
|
|
|
|
rtpntptime = nsrtptimediff + jbuf->media_clock_base_time;
|
|
|
|
rtpsystime =
|
|
gst_clock_adjust_with_calibration (media_clock, rtpntptime, internal,
|
|
external, rate_num, rate_denom);
|
|
|
|
if (rtpsystime > base_time)
|
|
pts = rtpsystime - base_time;
|
|
else
|
|
pts = 0;
|
|
|
|
GST_DEBUG ("RFC7273 clock time %" GST_TIME_FORMAT ", out %" GST_TIME_FORMAT,
|
|
GST_TIME_ARGS (rtpsystime), GST_TIME_ARGS (pts));
|
|
} else if (rfc7273_mode && (jbuf->mode == RTP_JITTER_BUFFER_MODE_SLAVE
|
|
|| jbuf->mode == RTP_JITTER_BUFFER_MODE_SYNCED)
|
|
&& media_clock_offset != -1 && jbuf->rfc7273_sync) {
|
|
GstClockTime ntptime, rtptime_tmp;
|
|
GstClockTime ntprtptime, rtpsystime;
|
|
GstClockTime internal, external;
|
|
GstClockTime rate_num, rate_denom;
|
|
|
|
/* Don't do any of the dts related adjustments further down */
|
|
dts = -1;
|
|
|
|
/* Calculate the actual clock time on the sender side based on the
|
|
* RFC7273 clock and convert it to our pipeline clock
|
|
*/
|
|
|
|
gst_clock_get_calibration (media_clock, &internal, &external, &rate_num,
|
|
&rate_denom);
|
|
|
|
ntptime = gst_clock_get_internal_time (media_clock);
|
|
|
|
ntprtptime = gst_util_uint64_scale (ntptime, jbuf->clock_rate, GST_SECOND);
|
|
ntprtptime += media_clock_offset;
|
|
ntprtptime &= 0xffffffff;
|
|
|
|
rtptime_tmp = rtptime;
|
|
/* Check for wraparounds, we assume that the diff between current RTP
|
|
* timestamp and current media clock time can't be bigger than
|
|
* 2**31 clock units */
|
|
if (ntprtptime > rtptime_tmp && ntprtptime - rtptime_tmp >= 0x80000000)
|
|
rtptime_tmp += G_GUINT64_CONSTANT (0x100000000);
|
|
else if (rtptime_tmp > ntprtptime && rtptime_tmp - ntprtptime >= 0x80000000)
|
|
ntprtptime += G_GUINT64_CONSTANT (0x100000000);
|
|
|
|
if (ntprtptime > rtptime_tmp)
|
|
ntptime -=
|
|
gst_util_uint64_scale (ntprtptime - rtptime_tmp, GST_SECOND,
|
|
jbuf->clock_rate);
|
|
else
|
|
ntptime +=
|
|
gst_util_uint64_scale (rtptime_tmp - ntprtptime, GST_SECOND,
|
|
jbuf->clock_rate);
|
|
|
|
rtpsystime =
|
|
gst_clock_adjust_with_calibration (media_clock, ntptime, internal,
|
|
external, rate_num, rate_denom);
|
|
/* All this assumes that the pipeline has enough additional
|
|
* latency to cover for the network delay */
|
|
if (rtpsystime > base_time)
|
|
pts = rtpsystime - base_time;
|
|
else
|
|
pts = 0;
|
|
|
|
GST_DEBUG ("RFC7273 clock time %" GST_TIME_FORMAT ", out %" GST_TIME_FORMAT,
|
|
GST_TIME_ARGS (rtpsystime), GST_TIME_ARGS (pts));
|
|
} else {
|
|
/* If we used the RFC7273 clock before and not anymore,
|
|
* we need to resync it later again */
|
|
jbuf->media_clock_base_time = -1;
|
|
|
|
/* do skew calculation by measuring the difference between rtptime and the
|
|
* receive dts, this function will return the skew corrected rtptime. */
|
|
pts = calculate_skew (jbuf, ext_rtptime, gstrtptime, dts, gap, is_rtx);
|
|
}
|
|
|
|
/* check if timestamps are not going backwards, we can only check this if we
|
|
* have a previous out time and a previous send_diff */
|
|
if (G_LIKELY (pts != -1 && jbuf->prev_out_time != -1
|
|
&& jbuf->prev_send_diff != -1)) {
|
|
/* now check for backwards timestamps */
|
|
if (G_UNLIKELY (
|
|
/* if the server timestamps went up and the out_time backwards */
|
|
(gstrtptime - jbuf->base_rtptime > jbuf->prev_send_diff
|
|
&& pts < jbuf->prev_out_time) ||
|
|
/* if the server timestamps went backwards and the out_time forwards */
|
|
(gstrtptime - jbuf->base_rtptime < jbuf->prev_send_diff
|
|
&& pts > jbuf->prev_out_time) ||
|
|
/* if the server timestamps did not change */
|
|
gstrtptime - jbuf->base_rtptime == jbuf->prev_send_diff)) {
|
|
GST_DEBUG ("backwards timestamps, using previous time");
|
|
pts = jbuf->prev_out_time;
|
|
}
|
|
}
|
|
|
|
if (gap == 0 && dts != -1 && pts + jbuf->delay < dts) {
|
|
/* if we are going to produce a timestamp that is later than the input
|
|
* timestamp, we need to reset the jitterbuffer. Likely the server paused
|
|
* temporarily */
|
|
GST_DEBUG ("out %" GST_TIME_FORMAT " + %" G_GUINT64_FORMAT " < time %"
|
|
GST_TIME_FORMAT ", reset jitterbuffer and discard", GST_TIME_ARGS (pts),
|
|
jbuf->delay, GST_TIME_ARGS (dts));
|
|
rtp_jitter_buffer_reset_skew (jbuf);
|
|
rtp_jitter_buffer_resync (jbuf, dts, gstrtptime, ext_rtptime, TRUE);
|
|
pts = dts;
|
|
}
|
|
|
|
jbuf->prev_out_time = pts;
|
|
jbuf->prev_send_diff = gstrtptime - jbuf->base_rtptime;
|
|
|
|
done:
|
|
if (media_clock)
|
|
gst_object_unref (media_clock);
|
|
if (pipeline_clock)
|
|
gst_object_unref (pipeline_clock);
|
|
|
|
return pts;
|
|
}
|
|
|
|
|
|
/**
|
|
* rtp_jitter_buffer_insert:
|
|
* @jbuf: an #RTPJitterBuffer
|
|
* @item: an #RTPJitterBufferItem to insert
|
|
* @head: TRUE when the head element changed.
|
|
* @percent: the buffering percent after insertion
|
|
*
|
|
* Inserts @item into the packet queue of @jbuf. The sequence number of the
|
|
* packet will be used to sort the packets. This function takes ownerhip of
|
|
* @buf when the function returns %TRUE.
|
|
*
|
|
* When @head is %TRUE, the new packet was added at the head of the queue and
|
|
* will be available with the next call to rtp_jitter_buffer_pop() and
|
|
* rtp_jitter_buffer_peek().
|
|
*
|
|
* Returns: %FALSE if a packet with the same number already existed.
|
|
*/
|
|
static gboolean
|
|
rtp_jitter_buffer_insert (RTPJitterBuffer * jbuf, RTPJitterBufferItem * item,
|
|
gboolean * head, gint * percent)
|
|
{
|
|
GList *list, *event = NULL;
|
|
guint16 seqnum;
|
|
|
|
g_return_val_if_fail (jbuf != NULL, FALSE);
|
|
g_return_val_if_fail (item != NULL, FALSE);
|
|
|
|
list = jbuf->packets.tail;
|
|
|
|
/* no seqnum, simply append then */
|
|
if (item->seqnum == -1)
|
|
goto append;
|
|
|
|
seqnum = item->seqnum;
|
|
|
|
/* loop the list to skip strictly larger seqnum buffers */
|
|
for (; list; list = g_list_previous (list)) {
|
|
guint16 qseq;
|
|
gint gap;
|
|
RTPJitterBufferItem *qitem = (RTPJitterBufferItem *) list;
|
|
|
|
if (qitem->seqnum == -1) {
|
|
/* keep a pointer to the first consecutive event if not already
|
|
* set. we will insert the packet after the event if we can't find
|
|
* a packet with lower sequence number before the event. */
|
|
if (event == NULL)
|
|
event = list;
|
|
continue;
|
|
}
|
|
|
|
qseq = qitem->seqnum;
|
|
|
|
/* compare the new seqnum to the one in the buffer */
|
|
gap = gst_rtp_buffer_compare_seqnum (seqnum, qseq);
|
|
|
|
/* we hit a packet with the same seqnum, notify a duplicate */
|
|
if (G_UNLIKELY (gap == 0))
|
|
goto duplicate;
|
|
|
|
/* seqnum > qseq, we can stop looking */
|
|
if (G_LIKELY (gap < 0))
|
|
break;
|
|
|
|
/* if we've found a packet with greater sequence number, cleanup the
|
|
* event pointer as the packet will be inserted before the event */
|
|
event = NULL;
|
|
}
|
|
|
|
/* if event is set it means that packets before the event had smaller
|
|
* sequence number, so we will insert our packet after the event */
|
|
if (event)
|
|
list = event;
|
|
|
|
append:
|
|
queue_do_insert (jbuf, list, (GList *) item);
|
|
|
|
/* buffering mode, update buffer stats */
|
|
if (jbuf->mode == RTP_JITTER_BUFFER_MODE_BUFFER)
|
|
update_buffer_level (jbuf, percent);
|
|
else if (percent)
|
|
*percent = -1;
|
|
|
|
/* head was changed when we did not find a previous packet, we set the return
|
|
* flag when requested. */
|
|
if (G_LIKELY (head))
|
|
*head = (list == NULL);
|
|
|
|
return TRUE;
|
|
|
|
/* ERRORS */
|
|
duplicate:
|
|
{
|
|
GST_DEBUG ("duplicate packet %d found", (gint) seqnum);
|
|
if (G_LIKELY (head))
|
|
*head = FALSE;
|
|
if (percent)
|
|
*percent = -1;
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* rtp_jitter_buffer_alloc_item:
|
|
* @data: The data stored in this item
|
|
* @type: User specific item type
|
|
* @dts: Decoding Timestamp
|
|
* @pts: Presentation Timestamp
|
|
* @seqnum: Sequence number
|
|
* @count: Number of packet this item represent
|
|
* @rtptime: The RTP specific timestamp
|
|
* @free_data: A function to free @data (optional)
|
|
*
|
|
* Create an item that can then be stored in the jitter buffer.
|
|
*
|
|
* Returns: a newly allocated RTPJitterbufferItem
|
|
*/
|
|
static RTPJitterBufferItem *
|
|
rtp_jitter_buffer_alloc_item (gpointer data, guint type, GstClockTime dts,
|
|
GstClockTime pts, guint seqnum, guint count, guint rtptime,
|
|
GDestroyNotify free_data)
|
|
{
|
|
RTPJitterBufferItem *item;
|
|
|
|
item = g_slice_new (RTPJitterBufferItem);
|
|
item->data = data;
|
|
item->next = NULL;
|
|
item->prev = NULL;
|
|
item->type = type;
|
|
item->dts = dts;
|
|
item->pts = pts;
|
|
item->seqnum = seqnum;
|
|
item->count = count;
|
|
item->rtptime = rtptime;
|
|
item->free_data = free_data;
|
|
|
|
return item;
|
|
}
|
|
|
|
static inline RTPJitterBufferItem *
|
|
alloc_event_item (GstEvent * event)
|
|
{
|
|
return rtp_jitter_buffer_alloc_item (event, ITEM_TYPE_EVENT, -1, -1, -1, 0,
|
|
-1, (GDestroyNotify) gst_mini_object_unref);
|
|
}
|
|
|
|
/**
|
|
* rtp_jitter_buffer_append_event:
|
|
* @jbuf: an #RTPJitterBuffer
|
|
* @event: an #GstEvent to insert
|
|
|
|
* Inserts @event into the packet queue of @jbuf.
|
|
*
|
|
* Returns: %TRUE if the event is at the head of the queue
|
|
*/
|
|
gboolean
|
|
rtp_jitter_buffer_append_event (RTPJitterBuffer * jbuf, GstEvent * event)
|
|
{
|
|
RTPJitterBufferItem *item = alloc_event_item (event);
|
|
gboolean head;
|
|
rtp_jitter_buffer_insert (jbuf, item, &head, NULL);
|
|
return head;
|
|
}
|
|
|
|
/**
|
|
* rtp_jitter_buffer_append_query:
|
|
* @jbuf: an #RTPJitterBuffer
|
|
* @query: an #GstQuery to insert
|
|
|
|
* Inserts @query into the packet queue of @jbuf.
|
|
*
|
|
* Returns: %TRUE if the query is at the head of the queue
|
|
*/
|
|
gboolean
|
|
rtp_jitter_buffer_append_query (RTPJitterBuffer * jbuf, GstQuery * query)
|
|
{
|
|
RTPJitterBufferItem *item =
|
|
rtp_jitter_buffer_alloc_item (query, ITEM_TYPE_QUERY, -1, -1, -1, 0, -1,
|
|
NULL);
|
|
gboolean head;
|
|
rtp_jitter_buffer_insert (jbuf, item, &head, NULL);
|
|
return head;
|
|
}
|
|
|
|
/**
|
|
* rtp_jitter_buffer_append_lost_event:
|
|
* @jbuf: an #RTPJitterBuffer
|
|
* @event: an #GstEvent to insert
|
|
* @seqnum: Sequence number
|
|
* @lost_packets: Number of lost packet this item represent
|
|
|
|
* Inserts @event into the packet queue of @jbuf.
|
|
*
|
|
* Returns: %TRUE if the event is at the head of the queue
|
|
*/
|
|
gboolean
|
|
rtp_jitter_buffer_append_lost_event (RTPJitterBuffer * jbuf, GstEvent * event,
|
|
guint16 seqnum, guint lost_packets)
|
|
{
|
|
RTPJitterBufferItem *item = rtp_jitter_buffer_alloc_item (event,
|
|
ITEM_TYPE_LOST, -1, -1, seqnum, lost_packets, -1,
|
|
(GDestroyNotify) gst_mini_object_unref);
|
|
gboolean head;
|
|
|
|
if (!rtp_jitter_buffer_insert (jbuf, item, &head, NULL)) {
|
|
/* Duplicate */
|
|
rtp_jitter_buffer_free_item (item);
|
|
head = FALSE;
|
|
}
|
|
|
|
return head;
|
|
}
|
|
|
|
/**
|
|
* rtp_jitter_buffer_append_buffer:
|
|
* @jbuf: an #RTPJitterBuffer
|
|
* @buf: an #GstBuffer to insert
|
|
* @seqnum: Sequence number
|
|
* @duplicate: TRUE when the packet inserted is a duplicate
|
|
* @percent: the buffering percent after insertion
|
|
*
|
|
* Inserts @buf into the packet queue of @jbuf.
|
|
*
|
|
* Returns: %TRUE if the buffer is at the head of the queue
|
|
*/
|
|
gboolean
|
|
rtp_jitter_buffer_append_buffer (RTPJitterBuffer * jbuf, GstBuffer * buf,
|
|
GstClockTime dts, GstClockTime pts, guint16 seqnum, guint rtptime,
|
|
gboolean * duplicate, gint * percent)
|
|
{
|
|
RTPJitterBufferItem *item = rtp_jitter_buffer_alloc_item (buf,
|
|
ITEM_TYPE_BUFFER, dts, pts, seqnum, 1, rtptime,
|
|
(GDestroyNotify) gst_mini_object_unref);
|
|
gboolean head;
|
|
gboolean inserted;
|
|
|
|
inserted = rtp_jitter_buffer_insert (jbuf, item, &head, percent);
|
|
if (!inserted)
|
|
rtp_jitter_buffer_free_item (item);
|
|
|
|
if (duplicate)
|
|
*duplicate = !inserted;
|
|
|
|
return head;
|
|
}
|
|
|
|
/**
|
|
* rtp_jitter_buffer_pop:
|
|
* @jbuf: an #RTPJitterBuffer
|
|
* @percent: the buffering percent
|
|
*
|
|
* Pops the oldest buffer from the packet queue of @jbuf. The popped buffer will
|
|
* have its timestamp adjusted with the incoming running_time and the detected
|
|
* clock skew.
|
|
*
|
|
* Returns: a #GstBuffer or %NULL when there was no packet in the queue.
|
|
*/
|
|
RTPJitterBufferItem *
|
|
rtp_jitter_buffer_pop (RTPJitterBuffer * jbuf, gint * percent)
|
|
{
|
|
GList *item = NULL;
|
|
GQueue *queue;
|
|
|
|
g_return_val_if_fail (jbuf != NULL, NULL);
|
|
|
|
queue = &jbuf->packets;
|
|
|
|
item = queue->head;
|
|
if (item) {
|
|
queue->head = item->next;
|
|
if (queue->head)
|
|
queue->head->prev = NULL;
|
|
else
|
|
queue->tail = NULL;
|
|
queue->length--;
|
|
}
|
|
|
|
/* buffering mode, update buffer stats */
|
|
if (jbuf->mode == RTP_JITTER_BUFFER_MODE_BUFFER)
|
|
update_buffer_level (jbuf, percent);
|
|
else if (percent)
|
|
*percent = -1;
|
|
|
|
/* let's clear the pointers so we can ensure we don't free items that are
|
|
* still in the jitterbuffer */
|
|
item->next = item->prev = NULL;
|
|
|
|
return (RTPJitterBufferItem *) item;
|
|
}
|
|
|
|
/**
|
|
* rtp_jitter_buffer_peek:
|
|
* @jbuf: an #RTPJitterBuffer
|
|
*
|
|
* Peek the oldest buffer from the packet queue of @jbuf.
|
|
*
|
|
* See rtp_jitter_buffer_insert() to check when an older packet was
|
|
* added.
|
|
*
|
|
* Returns: a #GstBuffer or %NULL when there was no packet in the queue.
|
|
*/
|
|
RTPJitterBufferItem *
|
|
rtp_jitter_buffer_peek (RTPJitterBuffer * jbuf)
|
|
{
|
|
g_return_val_if_fail (jbuf != NULL, NULL);
|
|
|
|
return (RTPJitterBufferItem *) jbuf->packets.head;
|
|
}
|
|
|
|
/**
|
|
* rtp_jitter_buffer_flush:
|
|
* @jbuf: an #RTPJitterBuffer
|
|
* @free_func: function to free each item (optional)
|
|
* @user_data: user data passed to @free_func
|
|
*
|
|
* Flush all packets from the jitterbuffer.
|
|
*/
|
|
void
|
|
rtp_jitter_buffer_flush (RTPJitterBuffer * jbuf, GFunc free_func,
|
|
gpointer user_data)
|
|
{
|
|
GList *item;
|
|
|
|
g_return_if_fail (jbuf != NULL);
|
|
|
|
if (free_func == NULL)
|
|
free_func = (GFunc) rtp_jitter_buffer_free_item;
|
|
|
|
while ((item = g_queue_pop_head_link (&jbuf->packets)))
|
|
free_func ((RTPJitterBufferItem *) item, user_data);
|
|
}
|
|
|
|
/**
|
|
* rtp_jitter_buffer_is_buffering:
|
|
* @jbuf: an #RTPJitterBuffer
|
|
*
|
|
* Check if @jbuf is buffering currently. Users of the jitterbuffer should not
|
|
* pop packets while in buffering mode.
|
|
*
|
|
* Returns: the buffering state of @jbuf
|
|
*/
|
|
gboolean
|
|
rtp_jitter_buffer_is_buffering (RTPJitterBuffer * jbuf)
|
|
{
|
|
return jbuf->buffering && !jbuf->buffering_disabled;
|
|
}
|
|
|
|
/**
|
|
* rtp_jitter_buffer_set_buffering:
|
|
* @jbuf: an #RTPJitterBuffer
|
|
* @buffering: the new buffering state
|
|
*
|
|
* Forces @jbuf to go into the buffering state.
|
|
*/
|
|
void
|
|
rtp_jitter_buffer_set_buffering (RTPJitterBuffer * jbuf, gboolean buffering)
|
|
{
|
|
jbuf->buffering = buffering;
|
|
}
|
|
|
|
/**
|
|
* rtp_jitter_buffer_get_percent:
|
|
* @jbuf: an #RTPJitterBuffer
|
|
*
|
|
* Get the buffering percent of the jitterbuffer.
|
|
*
|
|
* Returns: the buffering percent
|
|
*/
|
|
gint
|
|
rtp_jitter_buffer_get_percent (RTPJitterBuffer * jbuf)
|
|
{
|
|
gint percent;
|
|
guint64 level;
|
|
|
|
if (G_UNLIKELY (jbuf->high_level == 0))
|
|
return 100;
|
|
|
|
if (G_UNLIKELY (jbuf->buffering_disabled))
|
|
return 100;
|
|
|
|
level = get_buffer_level (jbuf);
|
|
percent = (level * 100 / jbuf->high_level);
|
|
percent = MIN (percent, 100);
|
|
|
|
return percent;
|
|
}
|
|
|
|
/**
|
|
* rtp_jitter_buffer_num_packets:
|
|
* @jbuf: an #RTPJitterBuffer
|
|
*
|
|
* Get the number of packets currently in "jbuf.
|
|
*
|
|
* Returns: The number of packets in @jbuf.
|
|
*/
|
|
guint
|
|
rtp_jitter_buffer_num_packets (RTPJitterBuffer * jbuf)
|
|
{
|
|
g_return_val_if_fail (jbuf != NULL, 0);
|
|
|
|
return jbuf->packets.length;
|
|
}
|
|
|
|
/**
|
|
* rtp_jitter_buffer_get_ts_diff:
|
|
* @jbuf: an #RTPJitterBuffer
|
|
*
|
|
* Get the difference between the timestamps of first and last packet in the
|
|
* jitterbuffer.
|
|
*
|
|
* Returns: The difference expressed in the timestamp units of the packets.
|
|
*/
|
|
guint32
|
|
rtp_jitter_buffer_get_ts_diff (RTPJitterBuffer * jbuf)
|
|
{
|
|
guint64 high_ts, low_ts;
|
|
RTPJitterBufferItem *high_buf, *low_buf;
|
|
guint32 result;
|
|
|
|
g_return_val_if_fail (jbuf != NULL, 0);
|
|
|
|
high_buf = (RTPJitterBufferItem *) g_queue_peek_tail_link (&jbuf->packets);
|
|
low_buf = (RTPJitterBufferItem *) g_queue_peek_head_link (&jbuf->packets);
|
|
|
|
if (!high_buf || !low_buf || high_buf == low_buf)
|
|
return 0;
|
|
|
|
high_ts = high_buf->rtptime;
|
|
low_ts = low_buf->rtptime;
|
|
|
|
/* it needs to work if ts wraps */
|
|
if (high_ts >= low_ts) {
|
|
result = (guint32) (high_ts - low_ts);
|
|
} else {
|
|
result = (guint32) (high_ts + G_MAXUINT32 + 1 - low_ts);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
/*
|
|
* rtp_jitter_buffer_get_seqnum_diff:
|
|
* @jbuf: an #RTPJitterBuffer
|
|
*
|
|
* Get the difference between the seqnum of first and last packet in the
|
|
* jitterbuffer.
|
|
*
|
|
* Returns: The difference expressed in seqnum.
|
|
*/
|
|
static guint16
|
|
rtp_jitter_buffer_get_seqnum_diff (RTPJitterBuffer * jbuf)
|
|
{
|
|
guint32 high_seqnum, low_seqnum;
|
|
RTPJitterBufferItem *high_buf, *low_buf;
|
|
guint16 result;
|
|
|
|
g_return_val_if_fail (jbuf != NULL, 0);
|
|
|
|
high_buf = (RTPJitterBufferItem *) g_queue_peek_tail_link (&jbuf->packets);
|
|
low_buf = (RTPJitterBufferItem *) g_queue_peek_head_link (&jbuf->packets);
|
|
|
|
while (high_buf && high_buf->seqnum == -1)
|
|
high_buf = (RTPJitterBufferItem *) high_buf->prev;
|
|
|
|
while (low_buf && low_buf->seqnum == -1)
|
|
low_buf = (RTPJitterBufferItem *) low_buf->next;
|
|
|
|
if (!high_buf || !low_buf || high_buf == low_buf)
|
|
return 0;
|
|
|
|
high_seqnum = high_buf->seqnum;
|
|
low_seqnum = low_buf->seqnum;
|
|
|
|
/* it needs to work if ts wraps */
|
|
if (high_seqnum >= low_seqnum) {
|
|
result = (guint32) (high_seqnum - low_seqnum);
|
|
} else {
|
|
result = (guint32) (high_seqnum + G_MAXUINT16 + 1 - low_seqnum);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* rtp_jitter_buffer_get_sync:
|
|
* @jbuf: an #RTPJitterBuffer
|
|
* @rtptime: result RTP time
|
|
* @timestamp: result GStreamer timestamp
|
|
* @clock_rate: clock-rate of @rtptime
|
|
* @last_rtptime: last seen rtptime.
|
|
*
|
|
* Calculates the relation between the RTP timestamp and the GStreamer timestamp
|
|
* used for constructing timestamps.
|
|
*
|
|
* For extended RTP timestamp @rtptime with a clock-rate of @clock_rate,
|
|
* the GStreamer timestamp is currently @timestamp.
|
|
*
|
|
* The last seen extended RTP timestamp with clock-rate @clock-rate is returned in
|
|
* @last_rtptime.
|
|
*/
|
|
void
|
|
rtp_jitter_buffer_get_sync (RTPJitterBuffer * jbuf, guint64 * rtptime,
|
|
guint64 * timestamp, guint32 * clock_rate, guint64 * last_rtptime)
|
|
{
|
|
if (rtptime)
|
|
*rtptime = jbuf->base_extrtp;
|
|
if (timestamp)
|
|
*timestamp = jbuf->base_time + jbuf->skew;
|
|
if (clock_rate)
|
|
*clock_rate = jbuf->clock_rate;
|
|
if (last_rtptime)
|
|
*last_rtptime = jbuf->last_rtptime;
|
|
}
|
|
|
|
/**
|
|
* rtp_jitter_buffer_can_fast_start:
|
|
* @jbuf: an #RTPJitterBuffer
|
|
* @num_packets: Number of consecutive packets needed
|
|
*
|
|
* Check if in the queue if there is enough packets with consecutive seqnum in
|
|
* order to start delivering them.
|
|
*
|
|
* Returns: %TRUE if the required number of consecutive packets was found.
|
|
*/
|
|
gboolean
|
|
rtp_jitter_buffer_can_fast_start (RTPJitterBuffer * jbuf, gint num_packet)
|
|
{
|
|
gboolean ret = TRUE;
|
|
RTPJitterBufferItem *last_item = NULL, *item;
|
|
gint i;
|
|
|
|
if (rtp_jitter_buffer_num_packets (jbuf) < num_packet)
|
|
return FALSE;
|
|
|
|
item = rtp_jitter_buffer_peek (jbuf);
|
|
for (i = 0; i < num_packet; i++) {
|
|
if (G_LIKELY (last_item)) {
|
|
guint16 expected_seqnum = last_item->seqnum + 1;
|
|
|
|
if (expected_seqnum != item->seqnum) {
|
|
ret = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
last_item = item;
|
|
item = (RTPJitterBufferItem *) last_item->next;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
gboolean
|
|
rtp_jitter_buffer_is_full (RTPJitterBuffer * jbuf)
|
|
{
|
|
return rtp_jitter_buffer_get_seqnum_diff (jbuf) >= 32765 &&
|
|
rtp_jitter_buffer_num_packets (jbuf) > 10000;
|
|
}
|
|
|
|
|
|
/**
|
|
* rtp_jitter_buffer_free_item:
|
|
* @item: the item to be freed
|
|
*
|
|
* Free the jitter buffer item.
|
|
*/
|
|
void
|
|
rtp_jitter_buffer_free_item (RTPJitterBufferItem * item)
|
|
{
|
|
g_return_if_fail (item != NULL);
|
|
/* needs to be unlinked first */
|
|
g_return_if_fail (item->next == NULL);
|
|
g_return_if_fail (item->prev == NULL);
|
|
|
|
if (item->data && item->free_data)
|
|
item->free_data (item->data);
|
|
g_slice_free (RTPJitterBufferItem, item);
|
|
}
|