gst/rtpmanager/: Remove complicated async queue and replace with more simple jitterbuffer code while also fixing some...
Original commit message from CVS:
* gst/rtpmanager/Makefile.am:
* gst/rtpmanager/async_jitter_queue.c:
* gst/rtpmanager/async_jitter_queue.h:
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_class_init),
(rtp_jitter_buffer_init), (rtp_jitter_buffer_finalize),
(rtp_jitter_buffer_new), (compare_seqnum),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_pop),
(rtp_jitter_buffer_flush), (rtp_jitter_buffer_num_packets),
(rtp_jitter_buffer_get_ts_diff):
* gst/rtpmanager/rtpjitterbuffer.h:
Remove complicated async queue and replace with more simple jitterbuffer
code while also fixing some bugs.
* gst/rtpmanager/gstrtpbin-marshal.list:
* gst/rtpmanager/gstrtpbin.c: (on_new_ssrc), (on_ssrc_collision),
(on_ssrc_validated), (on_bye_ssrc), (on_bye_timeout), (on_timeout),
(create_session), (gst_rtp_bin_class_init), (create_recv_rtp),
(create_send_rtp):
* gst/rtpmanager/gstrtpbin.h:
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_init), (gst_rtp_jitter_buffer_dispose),
(gst_jitter_buffer_sink_parse_caps),
(gst_rtp_jitter_buffer_flush_start),
(gst_rtp_jitter_buffer_flush_stop),
(gst_rtp_jitter_buffer_change_state),
(gst_rtp_jitter_buffer_sink_event), (gst_rtp_jitter_buffer_chain),
(gst_rtp_jitter_buffer_loop), (gst_rtp_jitter_buffer_set_property):
* gst/rtpmanager/gstrtpsession.c: (on_new_ssrc),
(on_ssrc_collision), (on_ssrc_validated), (on_bye_ssrc),
(on_bye_timeout), (on_timeout), (gst_rtp_session_class_init),
(gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
* gst/rtpmanager/rtpsession.c: (on_bye_ssrc), (session_cleanup):
Use new jitterbuffer code.
Expose some new signals in preparation for handling EOS.
2007-08-10 17:16:53 +00:00
|
|
|
/* GStreamer
|
2007-12-10 15:34:19 +00:00
|
|
|
* Copyright (C) <2007> Wim Taymans <wim.taymans@gmail.com>
|
gst/rtpmanager/: Remove complicated async queue and replace with more simple jitterbuffer code while also fixing some...
Original commit message from CVS:
* gst/rtpmanager/Makefile.am:
* gst/rtpmanager/async_jitter_queue.c:
* gst/rtpmanager/async_jitter_queue.h:
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_class_init),
(rtp_jitter_buffer_init), (rtp_jitter_buffer_finalize),
(rtp_jitter_buffer_new), (compare_seqnum),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_pop),
(rtp_jitter_buffer_flush), (rtp_jitter_buffer_num_packets),
(rtp_jitter_buffer_get_ts_diff):
* gst/rtpmanager/rtpjitterbuffer.h:
Remove complicated async queue and replace with more simple jitterbuffer
code while also fixing some bugs.
* gst/rtpmanager/gstrtpbin-marshal.list:
* gst/rtpmanager/gstrtpbin.c: (on_new_ssrc), (on_ssrc_collision),
(on_ssrc_validated), (on_bye_ssrc), (on_bye_timeout), (on_timeout),
(create_session), (gst_rtp_bin_class_init), (create_recv_rtp),
(create_send_rtp):
* gst/rtpmanager/gstrtpbin.h:
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_init), (gst_rtp_jitter_buffer_dispose),
(gst_jitter_buffer_sink_parse_caps),
(gst_rtp_jitter_buffer_flush_start),
(gst_rtp_jitter_buffer_flush_stop),
(gst_rtp_jitter_buffer_change_state),
(gst_rtp_jitter_buffer_sink_event), (gst_rtp_jitter_buffer_chain),
(gst_rtp_jitter_buffer_loop), (gst_rtp_jitter_buffer_set_property):
* gst/rtpmanager/gstrtpsession.c: (on_new_ssrc),
(on_ssrc_collision), (on_ssrc_validated), (on_bye_ssrc),
(on_bye_timeout), (on_timeout), (gst_rtp_session_class_init),
(gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
* gst/rtpmanager/rtpsession.c: (on_bye_ssrc), (session_cleanup):
Use new jitterbuffer code.
Expose some new signals in preparation for handling EOS.
2007-08-10 17:16:53 +00:00
|
|
|
*
|
|
|
|
* 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
|
2012-11-04 00:07:18 +00:00
|
|
|
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
|
|
|
|
* Boston, MA 02110-1301, USA.
|
gst/rtpmanager/: Remove complicated async queue and replace with more simple jitterbuffer code while also fixing some...
Original commit message from CVS:
* gst/rtpmanager/Makefile.am:
* gst/rtpmanager/async_jitter_queue.c:
* gst/rtpmanager/async_jitter_queue.h:
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_class_init),
(rtp_jitter_buffer_init), (rtp_jitter_buffer_finalize),
(rtp_jitter_buffer_new), (compare_seqnum),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_pop),
(rtp_jitter_buffer_flush), (rtp_jitter_buffer_num_packets),
(rtp_jitter_buffer_get_ts_diff):
* gst/rtpmanager/rtpjitterbuffer.h:
Remove complicated async queue and replace with more simple jitterbuffer
code while also fixing some bugs.
* gst/rtpmanager/gstrtpbin-marshal.list:
* gst/rtpmanager/gstrtpbin.c: (on_new_ssrc), (on_ssrc_collision),
(on_ssrc_validated), (on_bye_ssrc), (on_bye_timeout), (on_timeout),
(create_session), (gst_rtp_bin_class_init), (create_recv_rtp),
(create_send_rtp):
* gst/rtpmanager/gstrtpbin.h:
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_init), (gst_rtp_jitter_buffer_dispose),
(gst_jitter_buffer_sink_parse_caps),
(gst_rtp_jitter_buffer_flush_start),
(gst_rtp_jitter_buffer_flush_stop),
(gst_rtp_jitter_buffer_change_state),
(gst_rtp_jitter_buffer_sink_event), (gst_rtp_jitter_buffer_chain),
(gst_rtp_jitter_buffer_loop), (gst_rtp_jitter_buffer_set_property):
* gst/rtpmanager/gstrtpsession.c: (on_new_ssrc),
(on_ssrc_collision), (on_ssrc_validated), (on_bye_ssrc),
(on_bye_timeout), (on_timeout), (gst_rtp_session_class_init),
(gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
* gst/rtpmanager/rtpsession.c: (on_bye_ssrc), (session_cleanup):
Use new jitterbuffer code.
Expose some new signals in preparation for handling EOS.
2007-08-10 17:16:53 +00:00
|
|
|
*/
|
|
|
|
#include <string.h>
|
2007-08-13 06:16:40 +00:00
|
|
|
#include <stdlib.h>
|
gst/rtpmanager/: Remove complicated async queue and replace with more simple jitterbuffer code while also fixing some...
Original commit message from CVS:
* gst/rtpmanager/Makefile.am:
* gst/rtpmanager/async_jitter_queue.c:
* gst/rtpmanager/async_jitter_queue.h:
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_class_init),
(rtp_jitter_buffer_init), (rtp_jitter_buffer_finalize),
(rtp_jitter_buffer_new), (compare_seqnum),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_pop),
(rtp_jitter_buffer_flush), (rtp_jitter_buffer_num_packets),
(rtp_jitter_buffer_get_ts_diff):
* gst/rtpmanager/rtpjitterbuffer.h:
Remove complicated async queue and replace with more simple jitterbuffer
code while also fixing some bugs.
* gst/rtpmanager/gstrtpbin-marshal.list:
* gst/rtpmanager/gstrtpbin.c: (on_new_ssrc), (on_ssrc_collision),
(on_ssrc_validated), (on_bye_ssrc), (on_bye_timeout), (on_timeout),
(create_session), (gst_rtp_bin_class_init), (create_recv_rtp),
(create_send_rtp):
* gst/rtpmanager/gstrtpbin.h:
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_init), (gst_rtp_jitter_buffer_dispose),
(gst_jitter_buffer_sink_parse_caps),
(gst_rtp_jitter_buffer_flush_start),
(gst_rtp_jitter_buffer_flush_stop),
(gst_rtp_jitter_buffer_change_state),
(gst_rtp_jitter_buffer_sink_event), (gst_rtp_jitter_buffer_chain),
(gst_rtp_jitter_buffer_loop), (gst_rtp_jitter_buffer_set_property):
* gst/rtpmanager/gstrtpsession.c: (on_new_ssrc),
(on_ssrc_collision), (on_ssrc_validated), (on_bye_ssrc),
(on_bye_timeout), (on_timeout), (gst_rtp_session_class_init),
(gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
* gst/rtpmanager/rtpsession.c: (on_bye_ssrc), (session_cleanup):
Use new jitterbuffer code.
Expose some new signals in preparation for handling EOS.
2007-08-10 17:16:53 +00:00
|
|
|
|
|
|
|
#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
|
|
|
|
|
2007-09-28 11:17:35 +00:00
|
|
|
#define MAX_WINDOW RTP_JITTER_BUFFER_MAX_WINDOW
|
|
|
|
#define MAX_TIME (2 * GST_SECOND)
|
|
|
|
|
gst/rtpmanager/: Remove complicated async queue and replace with more simple jitterbuffer code while also fixing some...
Original commit message from CVS:
* gst/rtpmanager/Makefile.am:
* gst/rtpmanager/async_jitter_queue.c:
* gst/rtpmanager/async_jitter_queue.h:
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_class_init),
(rtp_jitter_buffer_init), (rtp_jitter_buffer_finalize),
(rtp_jitter_buffer_new), (compare_seqnum),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_pop),
(rtp_jitter_buffer_flush), (rtp_jitter_buffer_num_packets),
(rtp_jitter_buffer_get_ts_diff):
* gst/rtpmanager/rtpjitterbuffer.h:
Remove complicated async queue and replace with more simple jitterbuffer
code while also fixing some bugs.
* gst/rtpmanager/gstrtpbin-marshal.list:
* gst/rtpmanager/gstrtpbin.c: (on_new_ssrc), (on_ssrc_collision),
(on_ssrc_validated), (on_bye_ssrc), (on_bye_timeout), (on_timeout),
(create_session), (gst_rtp_bin_class_init), (create_recv_rtp),
(create_send_rtp):
* gst/rtpmanager/gstrtpbin.h:
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_init), (gst_rtp_jitter_buffer_dispose),
(gst_jitter_buffer_sink_parse_caps),
(gst_rtp_jitter_buffer_flush_start),
(gst_rtp_jitter_buffer_flush_stop),
(gst_rtp_jitter_buffer_change_state),
(gst_rtp_jitter_buffer_sink_event), (gst_rtp_jitter_buffer_chain),
(gst_rtp_jitter_buffer_loop), (gst_rtp_jitter_buffer_set_property):
* gst/rtpmanager/gstrtpsession.c: (on_new_ssrc),
(on_ssrc_collision), (on_ssrc_validated), (on_bye_ssrc),
(on_bye_timeout), (on_timeout), (gst_rtp_session_class_init),
(gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
* gst/rtpmanager/rtpsession.c: (on_bye_ssrc), (session_cleanup):
Use new jitterbuffer code.
Expose some new signals in preparation for handling EOS.
2007-08-10 17:16:53 +00:00
|
|
|
/* signals and args */
|
|
|
|
enum
|
|
|
|
{
|
|
|
|
LAST_SIGNAL
|
|
|
|
};
|
|
|
|
|
|
|
|
enum
|
|
|
|
{
|
|
|
|
PROP_0
|
|
|
|
};
|
|
|
|
|
|
|
|
/* GObject vmethods */
|
|
|
|
static void rtp_jitter_buffer_finalize (GObject * object);
|
|
|
|
|
2009-10-05 11:32:17 +00:00
|
|
|
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"},
|
2013-10-30 15:49:36 +00:00
|
|
|
{RTP_JITTER_BUFFER_MODE_SYNCED, "Synchronized sender and receiver clocks",
|
|
|
|
"synced"},
|
2009-10-05 11:32:17 +00:00
|
|
|
{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;
|
|
|
|
}
|
|
|
|
|
gst/rtpmanager/: Remove complicated async queue and replace with more simple jitterbuffer code while also fixing some...
Original commit message from CVS:
* gst/rtpmanager/Makefile.am:
* gst/rtpmanager/async_jitter_queue.c:
* gst/rtpmanager/async_jitter_queue.h:
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_class_init),
(rtp_jitter_buffer_init), (rtp_jitter_buffer_finalize),
(rtp_jitter_buffer_new), (compare_seqnum),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_pop),
(rtp_jitter_buffer_flush), (rtp_jitter_buffer_num_packets),
(rtp_jitter_buffer_get_ts_diff):
* gst/rtpmanager/rtpjitterbuffer.h:
Remove complicated async queue and replace with more simple jitterbuffer
code while also fixing some bugs.
* gst/rtpmanager/gstrtpbin-marshal.list:
* gst/rtpmanager/gstrtpbin.c: (on_new_ssrc), (on_ssrc_collision),
(on_ssrc_validated), (on_bye_ssrc), (on_bye_timeout), (on_timeout),
(create_session), (gst_rtp_bin_class_init), (create_recv_rtp),
(create_send_rtp):
* gst/rtpmanager/gstrtpbin.h:
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_init), (gst_rtp_jitter_buffer_dispose),
(gst_jitter_buffer_sink_parse_caps),
(gst_rtp_jitter_buffer_flush_start),
(gst_rtp_jitter_buffer_flush_stop),
(gst_rtp_jitter_buffer_change_state),
(gst_rtp_jitter_buffer_sink_event), (gst_rtp_jitter_buffer_chain),
(gst_rtp_jitter_buffer_loop), (gst_rtp_jitter_buffer_set_property):
* gst/rtpmanager/gstrtpsession.c: (on_new_ssrc),
(on_ssrc_collision), (on_ssrc_validated), (on_bye_ssrc),
(on_bye_timeout), (on_timeout), (gst_rtp_session_class_init),
(gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
* gst/rtpmanager/rtpsession.c: (on_bye_ssrc), (session_cleanup):
Use new jitterbuffer code.
Expose some new signals in preparation for handling EOS.
2007-08-10 17:16:53 +00:00
|
|
|
/* 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)
|
|
|
|
{
|
2016-01-05 14:15:16 +00:00
|
|
|
g_mutex_init (&jbuf->clock_lock);
|
|
|
|
|
gst/rtpmanager/: Remove complicated async queue and replace with more simple jitterbuffer code while also fixing some...
Original commit message from CVS:
* gst/rtpmanager/Makefile.am:
* gst/rtpmanager/async_jitter_queue.c:
* gst/rtpmanager/async_jitter_queue.h:
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_class_init),
(rtp_jitter_buffer_init), (rtp_jitter_buffer_finalize),
(rtp_jitter_buffer_new), (compare_seqnum),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_pop),
(rtp_jitter_buffer_flush), (rtp_jitter_buffer_num_packets),
(rtp_jitter_buffer_get_ts_diff):
* gst/rtpmanager/rtpjitterbuffer.h:
Remove complicated async queue and replace with more simple jitterbuffer
code while also fixing some bugs.
* gst/rtpmanager/gstrtpbin-marshal.list:
* gst/rtpmanager/gstrtpbin.c: (on_new_ssrc), (on_ssrc_collision),
(on_ssrc_validated), (on_bye_ssrc), (on_bye_timeout), (on_timeout),
(create_session), (gst_rtp_bin_class_init), (create_recv_rtp),
(create_send_rtp):
* gst/rtpmanager/gstrtpbin.h:
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_init), (gst_rtp_jitter_buffer_dispose),
(gst_jitter_buffer_sink_parse_caps),
(gst_rtp_jitter_buffer_flush_start),
(gst_rtp_jitter_buffer_flush_stop),
(gst_rtp_jitter_buffer_change_state),
(gst_rtp_jitter_buffer_sink_event), (gst_rtp_jitter_buffer_chain),
(gst_rtp_jitter_buffer_loop), (gst_rtp_jitter_buffer_set_property):
* gst/rtpmanager/gstrtpsession.c: (on_new_ssrc),
(on_ssrc_collision), (on_ssrc_validated), (on_bye_ssrc),
(on_bye_timeout), (on_timeout), (gst_rtp_session_class_init),
(gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
* gst/rtpmanager/rtpsession.c: (on_bye_ssrc), (session_cleanup):
Use new jitterbuffer code.
Expose some new signals in preparation for handling EOS.
2007-08-10 17:16:53 +00:00
|
|
|
jbuf->packets = g_queue_new ();
|
2009-10-01 09:20:08 +00:00
|
|
|
jbuf->mode = RTP_JITTER_BUFFER_MODE_SLAVE;
|
2007-10-02 10:27:45 +00:00
|
|
|
|
|
|
|
rtp_jitter_buffer_reset_skew (jbuf);
|
gst/rtpmanager/: Remove complicated async queue and replace with more simple jitterbuffer code while also fixing some...
Original commit message from CVS:
* gst/rtpmanager/Makefile.am:
* gst/rtpmanager/async_jitter_queue.c:
* gst/rtpmanager/async_jitter_queue.h:
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_class_init),
(rtp_jitter_buffer_init), (rtp_jitter_buffer_finalize),
(rtp_jitter_buffer_new), (compare_seqnum),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_pop),
(rtp_jitter_buffer_flush), (rtp_jitter_buffer_num_packets),
(rtp_jitter_buffer_get_ts_diff):
* gst/rtpmanager/rtpjitterbuffer.h:
Remove complicated async queue and replace with more simple jitterbuffer
code while also fixing some bugs.
* gst/rtpmanager/gstrtpbin-marshal.list:
* gst/rtpmanager/gstrtpbin.c: (on_new_ssrc), (on_ssrc_collision),
(on_ssrc_validated), (on_bye_ssrc), (on_bye_timeout), (on_timeout),
(create_session), (gst_rtp_bin_class_init), (create_recv_rtp),
(create_send_rtp):
* gst/rtpmanager/gstrtpbin.h:
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_init), (gst_rtp_jitter_buffer_dispose),
(gst_jitter_buffer_sink_parse_caps),
(gst_rtp_jitter_buffer_flush_start),
(gst_rtp_jitter_buffer_flush_stop),
(gst_rtp_jitter_buffer_change_state),
(gst_rtp_jitter_buffer_sink_event), (gst_rtp_jitter_buffer_chain),
(gst_rtp_jitter_buffer_loop), (gst_rtp_jitter_buffer_set_property):
* gst/rtpmanager/gstrtpsession.c: (on_new_ssrc),
(on_ssrc_collision), (on_ssrc_validated), (on_bye_ssrc),
(on_bye_timeout), (on_timeout), (gst_rtp_session_class_init),
(gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
* gst/rtpmanager/rtpsession.c: (on_bye_ssrc), (session_cleanup):
Use new jitterbuffer code.
Expose some new signals in preparation for handling EOS.
2007-08-10 17:16:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
rtp_jitter_buffer_finalize (GObject * object)
|
|
|
|
{
|
|
|
|
RTPJitterBuffer *jbuf;
|
|
|
|
|
|
|
|
jbuf = RTP_JITTER_BUFFER_CAST (object);
|
|
|
|
|
2016-01-05 14:15:16 +00:00
|
|
|
if (jbuf->media_clock_synced_id)
|
|
|
|
g_signal_handler_disconnect (jbuf->media_clock,
|
|
|
|
jbuf->media_clock_synced_id);
|
|
|
|
if (jbuf->media_clock)
|
|
|
|
gst_object_unref (jbuf->media_clock);
|
|
|
|
|
|
|
|
if (jbuf->pipeline_clock)
|
|
|
|
gst_object_unref (jbuf->pipeline_clock);
|
|
|
|
|
gst/rtpmanager/: Remove complicated async queue and replace with more simple jitterbuffer code while also fixing some...
Original commit message from CVS:
* gst/rtpmanager/Makefile.am:
* gst/rtpmanager/async_jitter_queue.c:
* gst/rtpmanager/async_jitter_queue.h:
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_class_init),
(rtp_jitter_buffer_init), (rtp_jitter_buffer_finalize),
(rtp_jitter_buffer_new), (compare_seqnum),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_pop),
(rtp_jitter_buffer_flush), (rtp_jitter_buffer_num_packets),
(rtp_jitter_buffer_get_ts_diff):
* gst/rtpmanager/rtpjitterbuffer.h:
Remove complicated async queue and replace with more simple jitterbuffer
code while also fixing some bugs.
* gst/rtpmanager/gstrtpbin-marshal.list:
* gst/rtpmanager/gstrtpbin.c: (on_new_ssrc), (on_ssrc_collision),
(on_ssrc_validated), (on_bye_ssrc), (on_bye_timeout), (on_timeout),
(create_session), (gst_rtp_bin_class_init), (create_recv_rtp),
(create_send_rtp):
* gst/rtpmanager/gstrtpbin.h:
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_init), (gst_rtp_jitter_buffer_dispose),
(gst_jitter_buffer_sink_parse_caps),
(gst_rtp_jitter_buffer_flush_start),
(gst_rtp_jitter_buffer_flush_stop),
(gst_rtp_jitter_buffer_change_state),
(gst_rtp_jitter_buffer_sink_event), (gst_rtp_jitter_buffer_chain),
(gst_rtp_jitter_buffer_loop), (gst_rtp_jitter_buffer_set_property):
* gst/rtpmanager/gstrtpsession.c: (on_new_ssrc),
(on_ssrc_collision), (on_ssrc_validated), (on_bye_ssrc),
(on_bye_timeout), (on_timeout), (gst_rtp_session_class_init),
(gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
* gst/rtpmanager/rtpsession.c: (on_bye_ssrc), (session_cleanup):
Use new jitterbuffer code.
Expose some new signals in preparation for handling EOS.
2007-08-10 17:16:53 +00:00
|
|
|
g_queue_free (jbuf->packets);
|
|
|
|
|
2016-01-05 14:15:16 +00:00
|
|
|
g_mutex_clear (&jbuf->clock_lock);
|
|
|
|
|
gst/rtpmanager/: Remove complicated async queue and replace with more simple jitterbuffer code while also fixing some...
Original commit message from CVS:
* gst/rtpmanager/Makefile.am:
* gst/rtpmanager/async_jitter_queue.c:
* gst/rtpmanager/async_jitter_queue.h:
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_class_init),
(rtp_jitter_buffer_init), (rtp_jitter_buffer_finalize),
(rtp_jitter_buffer_new), (compare_seqnum),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_pop),
(rtp_jitter_buffer_flush), (rtp_jitter_buffer_num_packets),
(rtp_jitter_buffer_get_ts_diff):
* gst/rtpmanager/rtpjitterbuffer.h:
Remove complicated async queue and replace with more simple jitterbuffer
code while also fixing some bugs.
* gst/rtpmanager/gstrtpbin-marshal.list:
* gst/rtpmanager/gstrtpbin.c: (on_new_ssrc), (on_ssrc_collision),
(on_ssrc_validated), (on_bye_ssrc), (on_bye_timeout), (on_timeout),
(create_session), (gst_rtp_bin_class_init), (create_recv_rtp),
(create_send_rtp):
* gst/rtpmanager/gstrtpbin.h:
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_init), (gst_rtp_jitter_buffer_dispose),
(gst_jitter_buffer_sink_parse_caps),
(gst_rtp_jitter_buffer_flush_start),
(gst_rtp_jitter_buffer_flush_stop),
(gst_rtp_jitter_buffer_change_state),
(gst_rtp_jitter_buffer_sink_event), (gst_rtp_jitter_buffer_chain),
(gst_rtp_jitter_buffer_loop), (gst_rtp_jitter_buffer_set_property):
* gst/rtpmanager/gstrtpsession.c: (on_new_ssrc),
(on_ssrc_collision), (on_ssrc_validated), (on_bye_ssrc),
(on_bye_timeout), (on_timeout), (gst_rtp_session_class_init),
(gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
* gst/rtpmanager/rtpsession.c: (on_bye_ssrc), (session_cleanup):
Use new jitterbuffer code.
Expose some new signals in preparation for handling EOS.
2007-08-10 17:16:53 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2009-10-01 09:20:08 +00:00
|
|
|
/**
|
|
|
|
* 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;
|
2009-10-01 15:14:09 +00:00
|
|
|
}
|
2009-10-01 10:46:21 +00:00
|
|
|
|
2009-10-01 15:14:09 +00:00
|
|
|
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;
|
2009-10-05 19:31:59 +00:00
|
|
|
/* the high level is at 90% in order to release packets before we fill up the
|
|
|
|
* buffer up to the latency */
|
2009-10-01 15:14:09 +00:00
|
|
|
jbuf->high_level = (delay * 90) / 100;
|
2009-10-05 18:09:30 +00:00
|
|
|
|
2009-10-01 15:14:09 +00:00
|
|
|
GST_DEBUG ("delay %" GST_TIME_FORMAT ", min %" GST_TIME_FORMAT ", max %"
|
2010-01-27 16:57:55 +00:00
|
|
|
GST_TIME_FORMAT, GST_TIME_ARGS (jbuf->delay),
|
2009-10-01 15:14:09 +00:00
|
|
|
GST_TIME_ARGS (jbuf->low_level), GST_TIME_ARGS (jbuf->high_level));
|
2009-10-01 09:20:08 +00:00
|
|
|
}
|
|
|
|
|
2013-09-20 13:35:25 +00:00
|
|
|
/**
|
|
|
|
* rtp_jitter_buffer_set_clock_rate:
|
|
|
|
* @jbuf: an #RTPJitterBuffer
|
2014-10-04 15:17:13 +00:00
|
|
|
* @clock_rate: the new clock rate
|
2013-09-20 13:35:25 +00:00
|
|
|
*
|
|
|
|
* 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) {
|
2014-10-04 15:17:13 +00:00
|
|
|
GST_DEBUG ("Clock rate changed from %" G_GUINT32_FORMAT " to %"
|
|
|
|
G_GUINT32_FORMAT, jbuf->clock_rate, clock_rate);
|
2013-09-20 13:35:25 +00:00
|
|
|
jbuf->clock_rate = clock_rate;
|
2013-09-30 09:53:08 +00:00
|
|
|
rtp_jitter_buffer_reset_skew (jbuf);
|
2013-09-20 13:35:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
}
|
2009-10-01 15:14:09 +00:00
|
|
|
|
2016-01-05 14:15:16 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2009-10-01 09:20:08 +00:00
|
|
|
/**
|
|
|
|
* rtp_jitter_buffer_reset_skew:
|
|
|
|
* @jbuf: an #RTPJitterBuffer
|
|
|
|
*
|
|
|
|
* Reset the skew calculations in @jbuf.
|
|
|
|
*/
|
2007-10-02 10:27:45 +00:00
|
|
|
void
|
|
|
|
rtp_jitter_buffer_reset_skew (RTPJitterBuffer * jbuf)
|
|
|
|
{
|
|
|
|
jbuf->base_time = -1;
|
|
|
|
jbuf->base_rtptime = -1;
|
gst/rtpmanager/gstrtpbin.*: Add signal to notify listeners when a sender becomes a receiver.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (on_sender_timeout),
(create_session), (gst_rtp_bin_associate),
(gst_rtp_bin_sync_chain), (gst_rtp_bin_class_init),
(gst_rtp_bin_request_new_pad):
* gst/rtpmanager/gstrtpbin.h:
Add signal to notify listeners when a sender becomes a receiver.
Tweak lip-sync code, don't store our own copy of the ts-offset of the
jitterbuffer, don't adjust sync if the change is less than 4msec.
Get the RTP timestamp <-> GStreamer timestamp relation directly from
the jitterbuffer instead of our inaccurate version from the source.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_chain), (gst_rtp_jitter_buffer_loop),
(gst_rtp_jitter_buffer_get_sync):
* gst/rtpmanager/gstrtpjitterbuffer.h:
Add G_LIKELY macros, use global defines for max packet reorder and
dropouts.
Reset the jitterbuffer clock skew detection when packets seqnums are
changed unexpectedly.
* gst/rtpmanager/gstrtpsession.c: (on_sender_timeout),
(gst_rtp_session_class_init), (gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
Add sender timeout signal.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_reset_skew),
(calculate_skew), (rtp_jitter_buffer_insert),
(rtp_jitter_buffer_get_sync):
* gst/rtpmanager/rtpjitterbuffer.h:
Add some G_LIKELY macros.
Keep track of the extended RTP timestamp so that we can report the RTP
timestamp <-> GStreamer timestamp relation for lip-sync.
Remove server timestamp gap detection code, the server can sometimes
make a huge gap in timestamps (talk spurts,...) see #549774.
Detect timetamp weirdness instead by observing the sender/receiver
timestamp relation and resync if it changes more than 1 second.
Add method to report about the current rtp <-> gst timestamp relation
which is needed for lip-sync.
* gst/rtpmanager/rtpsession.c: (rtp_session_class_init),
(on_sender_timeout), (check_collision), (rtp_session_process_sr),
(session_cleanup):
* gst/rtpmanager/rtpsession.h:
Add sender timeout signal.
Remove inaccurate rtp <-> gst timestamp relation code, the
jitterbuffer can now do an accurate reporting about this.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(rtp_source_update_caps), (calculate_jitter),
(rtp_source_process_rtp):
* gst/rtpmanager/rtpsource.h:
Remove inaccurate rtp <-> gst timestamp relation code.
* gst/rtpmanager/rtpstats.h:
Define global max-reorder and max-dropout constants for use in various
subsystems.
2008-09-05 13:52:34 +00:00
|
|
|
jbuf->base_extrtp = -1;
|
2016-01-05 14:15:16 +00:00
|
|
|
jbuf->media_clock_base_time = -1;
|
2007-10-02 10:27:45 +00:00
|
|
|
jbuf->ext_rtptime = -1;
|
gst/rtpmanager/gstrtpbin.c: Remove internal sync pad, use signals instead to get lip-sync notifications.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (gst_rtp_bin_associate),
(gst_rtp_bin_handle_sync), (create_stream), (free_stream),
(new_ssrc_pad_found):
Remove internal sync pad, use signals instead to get lip-sync
notifications.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_base_init),
(gst_rtp_jitter_buffer_class_init),
(gst_rtp_jitter_buffer_internal_links), (create_rtcp_sink),
(remove_rtcp_sink), (gst_rtp_jitter_buffer_request_new_pad),
(gst_rtp_jitter_buffer_release_pad),
(gst_rtp_jitter_buffer_sink_rtcp_event),
(gst_rtp_jitter_buffer_chain_rtcp),
(gst_rtp_jitter_buffer_get_property):
* gst/rtpmanager/gstrtpjitterbuffer.h:
Make it possible to send SR packets to the jitterbuffer.
Check if the SR timestamps are valid by comparing them to the RTP
timestamps.
Signal the SR packet and the timing information to listeners.
* gst/rtpmanager/gstrtpssrcdemux.c: (create_demux_pad_for_ssrc),
(gst_rtp_ssrc_demux_rtcp_chain), (gst_rtp_ssrc_demux_src_query):
Remove some unused code.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_reset_skew),
(calculate_skew), (rtp_jitter_buffer_get_sync):
* gst/rtpmanager/rtpjitterbuffer.h:
Keep track of the last seen RTP timestamp so that we can filter out
invalid SR packets.
2008-11-19 09:06:29 +00:00
|
|
|
jbuf->last_rtptime = -1;
|
2007-10-02 10:27:45 +00:00
|
|
|
jbuf->window_pos = 0;
|
|
|
|
jbuf->window_filling = TRUE;
|
|
|
|
jbuf->window_min = 0;
|
|
|
|
jbuf->skew = 0;
|
|
|
|
jbuf->prev_send_diff = -1;
|
2008-12-23 11:39:59 +00:00
|
|
|
jbuf->prev_out_time = -1;
|
2014-07-02 15:50:35 +00:00
|
|
|
jbuf->need_resync = TRUE;
|
2016-01-05 14:15:16 +00:00
|
|
|
|
2008-11-13 15:48:54 +00:00
|
|
|
GST_DEBUG ("reset skew correction");
|
2007-10-02 10:27:45 +00:00
|
|
|
}
|
gst/rtpmanager/gstrtpbin.c: Use lock to protect variable.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (gst_rtp_bin_set_property),
(gst_rtp_bin_get_property):
Use lock to protect variable.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_class_init),
(gst_jitter_buffer_sink_parse_caps), (gst_rtp_jitter_buffer_chain),
(convert_rtptime_to_gsttime), (gst_rtp_jitter_buffer_loop):
Reconstruct GST timestamp from RTP timestamps based on measured clock
skew and sync offset.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_init),
(rtp_jitter_buffer_set_tail_changed),
(rtp_jitter_buffer_set_clock_rate),
(rtp_jitter_buffer_get_clock_rate), (calculate_skew),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_peek):
* gst/rtpmanager/rtpjitterbuffer.h:
Measure clock skew.
Add callback to be notfied when a new packet was inserted at the tail.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(calculate_jitter), (rtp_source_send_rtp):
* gst/rtpmanager/rtpsource.h:
Remove clock skew detection, it's move to the jitterbuffer now.
2007-09-16 19:40:31 +00:00
|
|
|
|
2014-04-18 09:11:14 +00:00
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
|
2009-08-31 10:57:32 +00:00
|
|
|
static void
|
|
|
|
rtp_jitter_buffer_resync (RTPJitterBuffer * jbuf, GstClockTime time,
|
|
|
|
GstClockTime gstrtptime, guint64 ext_rtptime, gboolean reset_skew)
|
|
|
|
{
|
|
|
|
jbuf->base_time = time;
|
2016-01-05 14:15:16 +00:00
|
|
|
jbuf->media_clock_base_time = -1;
|
2009-08-31 10:57:32 +00:00
|
|
|
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;
|
|
|
|
}
|
2014-07-02 15:50:35 +00:00
|
|
|
jbuf->need_resync = FALSE;
|
2009-08-31 10:57:32 +00:00
|
|
|
}
|
|
|
|
|
2010-01-27 16:57:55 +00:00
|
|
|
static guint64
|
|
|
|
get_buffer_level (RTPJitterBuffer * jbuf)
|
2009-10-01 15:14:09 +00:00
|
|
|
{
|
2013-09-20 21:48:20 +00:00
|
|
|
RTPJitterBufferItem *high_buf = NULL, *low_buf = NULL;
|
2010-01-27 16:57:55 +00:00
|
|
|
guint64 level;
|
2009-10-01 15:14:09 +00:00
|
|
|
|
2015-06-22 10:45:14 +00:00
|
|
|
/* first buffer with timestamp */
|
2013-12-10 10:01:03 +00:00
|
|
|
high_buf = (RTPJitterBufferItem *) g_queue_peek_tail_link (jbuf->packets);
|
2013-09-20 21:48:20 +00:00
|
|
|
while (high_buf) {
|
2014-03-03 10:34:00 +00:00
|
|
|
if (high_buf->dts != -1 || high_buf->pts != -1)
|
2010-12-20 14:54:45 +00:00
|
|
|
break;
|
|
|
|
|
2013-12-10 10:01:03 +00:00
|
|
|
high_buf = (RTPJitterBufferItem *) g_list_previous (high_buf);
|
2010-12-20 14:54:45 +00:00
|
|
|
}
|
|
|
|
|
2013-12-10 10:01:03 +00:00
|
|
|
low_buf = (RTPJitterBufferItem *) g_queue_peek_head_link (jbuf->packets);
|
2013-09-20 21:48:20 +00:00
|
|
|
while (low_buf) {
|
2014-03-03 10:34:00 +00:00
|
|
|
if (low_buf->dts != -1 || low_buf->pts != -1)
|
2010-12-20 14:54:45 +00:00
|
|
|
break;
|
|
|
|
|
2013-12-10 10:01:03 +00:00
|
|
|
low_buf = (RTPJitterBufferItem *) g_list_next (low_buf);
|
2010-12-20 14:54:45 +00:00
|
|
|
}
|
2009-10-01 15:14:09 +00:00
|
|
|
|
|
|
|
if (!high_buf || !low_buf || high_buf == low_buf) {
|
2010-01-27 16:57:55 +00:00
|
|
|
level = 0;
|
2009-10-01 15:14:09 +00:00
|
|
|
} else {
|
|
|
|
guint64 high_ts, low_ts;
|
|
|
|
|
2014-03-03 10:34:00 +00:00
|
|
|
high_ts = high_buf->dts != -1 ? high_buf->dts : high_buf->pts;
|
|
|
|
low_ts = low_buf->dts != -1 ? low_buf->dts : low_buf->pts;
|
2009-10-01 15:14:09 +00:00
|
|
|
|
|
|
|
if (high_ts > low_ts)
|
2010-01-27 16:57:55 +00:00
|
|
|
level = high_ts - low_ts;
|
2009-10-01 15:14:09 +00:00
|
|
|
else
|
2010-01-27 16:57:55 +00:00
|
|
|
level = 0;
|
2010-12-20 14:54:45 +00:00
|
|
|
|
|
|
|
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);
|
2009-10-01 15:14:09 +00:00
|
|
|
}
|
2010-01-27 16:57:55 +00:00
|
|
|
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));
|
2009-10-01 15:14:09 +00:00
|
|
|
|
2014-04-18 09:11:14 +00:00
|
|
|
if (jbuf->buffering_disabled) {
|
|
|
|
GST_DEBUG ("buffering is disabled");
|
|
|
|
level = jbuf->high_level;
|
|
|
|
}
|
|
|
|
|
2009-10-01 15:14:09 +00:00
|
|
|
if (jbuf->buffering) {
|
|
|
|
post = TRUE;
|
2014-04-18 09:11:14 +00:00
|
|
|
if (level >= jbuf->high_level) {
|
2009-10-01 15:14:09 +00:00
|
|
|
GST_DEBUG ("buffering finished");
|
|
|
|
jbuf->buffering = FALSE;
|
|
|
|
}
|
|
|
|
} else {
|
2010-01-27 16:57:55 +00:00
|
|
|
if (level < jbuf->low_level) {
|
2009-10-01 15:14:09 +00:00
|
|
|
GST_DEBUG ("buffering started");
|
|
|
|
jbuf->buffering = TRUE;
|
|
|
|
post = TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (post) {
|
2009-10-05 17:45:35 +00:00
|
|
|
gint perc;
|
2009-10-01 15:14:09 +00:00
|
|
|
|
2011-01-25 19:56:19 +00:00
|
|
|
if (jbuf->buffering && (jbuf->high_level != 0)) {
|
2010-01-27 16:57:55 +00:00
|
|
|
perc = (level * 100 / jbuf->high_level);
|
2009-10-05 17:45:35 +00:00
|
|
|
perc = MIN (perc, 100);
|
2009-10-05 11:32:17 +00:00
|
|
|
} else {
|
2009-10-05 17:45:35 +00:00
|
|
|
perc = 100;
|
2009-10-05 11:32:17 +00:00
|
|
|
}
|
2009-10-01 15:14:09 +00:00
|
|
|
|
2009-10-05 17:45:35 +00:00
|
|
|
if (percent)
|
|
|
|
*percent = perc;
|
2009-10-01 15:14:09 +00:00
|
|
|
|
2009-10-05 17:45:35 +00:00
|
|
|
GST_DEBUG ("buffering %d", perc);
|
2009-10-01 15:14:09 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
gst/rtpmanager/gstrtpbin.c: Use lock to protect variable.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (gst_rtp_bin_set_property),
(gst_rtp_bin_get_property):
Use lock to protect variable.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_class_init),
(gst_jitter_buffer_sink_parse_caps), (gst_rtp_jitter_buffer_chain),
(convert_rtptime_to_gsttime), (gst_rtp_jitter_buffer_loop):
Reconstruct GST timestamp from RTP timestamps based on measured clock
skew and sync offset.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_init),
(rtp_jitter_buffer_set_tail_changed),
(rtp_jitter_buffer_set_clock_rate),
(rtp_jitter_buffer_get_clock_rate), (calculate_skew),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_peek):
* gst/rtpmanager/rtpjitterbuffer.h:
Measure clock skew.
Add callback to be notfied when a new packet was inserted at the tail.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(calculate_jitter), (rtp_source_send_rtp):
* gst/rtpmanager/rtpsource.h:
Remove clock skew detection, it's move to the jitterbuffer now.
2007-09-16 19:40:31 +00:00
|
|
|
/* For the clock skew we use a windowed low point averaging algorithm as can be
|
2010-10-01 09:59:10 +00:00
|
|
|
* 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:
|
gst/rtpmanager/gstrtpbin.c: Use lock to protect variable.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (gst_rtp_bin_set_property),
(gst_rtp_bin_get_property):
Use lock to protect variable.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_class_init),
(gst_jitter_buffer_sink_parse_caps), (gst_rtp_jitter_buffer_chain),
(convert_rtptime_to_gsttime), (gst_rtp_jitter_buffer_loop):
Reconstruct GST timestamp from RTP timestamps based on measured clock
skew and sync offset.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_init),
(rtp_jitter_buffer_set_tail_changed),
(rtp_jitter_buffer_set_clock_rate),
(rtp_jitter_buffer_get_clock_rate), (calculate_skew),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_peek):
* gst/rtpmanager/rtpjitterbuffer.h:
Measure clock skew.
Add callback to be notfied when a new packet was inserted at the tail.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(calculate_jitter), (rtp_source_send_rtp):
* gst/rtpmanager/rtpsource.h:
Remove clock skew detection, it's move to the jitterbuffer now.
2007-09-16 19:40:31 +00:00
|
|
|
*
|
|
|
|
* 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 elliminate 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
|
2009-09-01 10:41:36 +00:00
|
|
|
* compromise between accuracy and inertia.
|
2007-09-28 11:17:35 +00:00
|
|
|
*
|
|
|
|
* 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
|
gst/rtpmanager/: Update comment.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (create_session):
* gst/rtpmanager/rtpjitterbuffer.c:
Update comment.
* gst/rtpmanager/gstrtpsession.c: (gst_rtp_session_class_init),
(gst_rtp_session_set_property), (gst_rtp_session_get_property):
Define some GObject properties to set SDES and other configuration.
* gst/rtpmanager/rtpsession.c: (rtp_session_class_init),
(rtp_session_init), (rtp_session_finalize),
(rtp_session_set_property), (rtp_session_get_property),
(on_ssrc_sdes), (rtp_session_set_bandwidth),
(rtp_session_get_bandwidth), (rtp_session_set_rtcp_fraction),
(rtp_session_get_rtcp_fraction), (rtp_session_set_sdes_string),
(rtp_session_get_sdes_string), (obtain_source),
(rtp_session_get_internal_source), (rtp_session_process_sdes),
(rtp_session_send_rtp), (rtp_session_next_timeout), (session_sdes),
(is_rtcp_time):
* gst/rtpmanager/rtpsession.h:
Add signal when new SDES infor has been found for a source.
Create properties for SDES and other info.
Simplify the SDES API.
Add method for getting the internal source object of the session.
* gst/rtpmanager/rtpsource.c: (rtp_source_class_init),
(rtp_source_finalize), (rtp_source_set_property),
(rtp_source_get_property), (rtp_source_set_callbacks),
(rtp_source_get_ssrc), (rtp_source_set_as_csrc),
(rtp_source_is_as_csrc), (rtp_source_is_active),
(rtp_source_is_validated), (rtp_source_is_sender),
(rtp_source_received_bye), (rtp_source_get_bye_reason),
(rtp_source_set_sdes), (rtp_source_set_sdes_string),
(rtp_source_get_sdes), (rtp_source_get_sdes_string),
(rtp_source_get_new_sr), (rtp_source_get_new_rb):
* gst/rtpmanager/rtpsource.h:
Add GObject properties for various things.
Don't leak the bye reason.
2007-12-10 11:08:11 +00:00
|
|
|
* startup, when filling the window, we use a parabolic weighting factor, the
|
2007-09-28 11:17:35 +00:00
|
|
|
* more the window is filled, the faster we move to the detected possible skew.
|
|
|
|
*
|
|
|
|
* Returns: @time adjusted with the clock skew.
|
gst/rtpmanager/gstrtpbin.c: Use lock to protect variable.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (gst_rtp_bin_set_property),
(gst_rtp_bin_get_property):
Use lock to protect variable.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_class_init),
(gst_jitter_buffer_sink_parse_caps), (gst_rtp_jitter_buffer_chain),
(convert_rtptime_to_gsttime), (gst_rtp_jitter_buffer_loop):
Reconstruct GST timestamp from RTP timestamps based on measured clock
skew and sync offset.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_init),
(rtp_jitter_buffer_set_tail_changed),
(rtp_jitter_buffer_set_clock_rate),
(rtp_jitter_buffer_get_clock_rate), (calculate_skew),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_peek):
* gst/rtpmanager/rtpjitterbuffer.h:
Measure clock skew.
Add callback to be notfied when a new packet was inserted at the tail.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(calculate_jitter), (rtp_source_send_rtp):
* gst/rtpmanager/rtpsource.h:
Remove clock skew detection, it's move to the jitterbuffer now.
2007-09-16 19:40:31 +00:00
|
|
|
*/
|
2007-09-28 11:17:35 +00:00
|
|
|
static GstClockTime
|
2016-01-05 14:15:16 +00:00
|
|
|
calculate_skew (RTPJitterBuffer * jbuf, guint64 ext_rtptime,
|
|
|
|
GstClockTime gstrtptime, GstClockTime time)
|
gst/rtpmanager/gstrtpbin.c: Use lock to protect variable.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (gst_rtp_bin_set_property),
(gst_rtp_bin_get_property):
Use lock to protect variable.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_class_init),
(gst_jitter_buffer_sink_parse_caps), (gst_rtp_jitter_buffer_chain),
(convert_rtptime_to_gsttime), (gst_rtp_jitter_buffer_loop):
Reconstruct GST timestamp from RTP timestamps based on measured clock
skew and sync offset.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_init),
(rtp_jitter_buffer_set_tail_changed),
(rtp_jitter_buffer_set_clock_rate),
(rtp_jitter_buffer_get_clock_rate), (calculate_skew),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_peek):
* gst/rtpmanager/rtpjitterbuffer.h:
Measure clock skew.
Add callback to be notfied when a new packet was inserted at the tail.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(calculate_jitter), (rtp_source_send_rtp):
* gst/rtpmanager/rtpsource.h:
Remove clock skew detection, it's move to the jitterbuffer now.
2007-09-16 19:40:31 +00:00
|
|
|
{
|
|
|
|
guint64 send_diff, recv_diff;
|
|
|
|
gint64 delta;
|
|
|
|
gint64 old;
|
|
|
|
gint pos, i;
|
2016-01-05 14:15:16 +00:00
|
|
|
GstClockTime out_time;
|
2009-08-31 11:02:16 +00:00
|
|
|
guint64 slope;
|
2007-09-28 11:17:35 +00:00
|
|
|
|
2016-01-05 14:15:16 +00:00
|
|
|
/* elapsed time at sender */
|
|
|
|
send_diff = gstrtptime - jbuf->base_rtptime;
|
2007-10-02 10:27:45 +00:00
|
|
|
|
2007-09-28 14:51:58 +00:00
|
|
|
/* 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 */
|
2008-11-17 15:17:52 +00:00
|
|
|
if (time == -1 || jbuf->base_time == -1)
|
2007-09-28 14:51:58 +00:00
|
|
|
goto no_skew;
|
|
|
|
|
gst/rtpmanager/gstrtpbin.c: Use lock to protect variable.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (gst_rtp_bin_set_property),
(gst_rtp_bin_get_property):
Use lock to protect variable.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_class_init),
(gst_jitter_buffer_sink_parse_caps), (gst_rtp_jitter_buffer_chain),
(convert_rtptime_to_gsttime), (gst_rtp_jitter_buffer_loop):
Reconstruct GST timestamp from RTP timestamps based on measured clock
skew and sync offset.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_init),
(rtp_jitter_buffer_set_tail_changed),
(rtp_jitter_buffer_set_clock_rate),
(rtp_jitter_buffer_get_clock_rate), (calculate_skew),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_peek):
* gst/rtpmanager/rtpjitterbuffer.h:
Measure clock skew.
Add callback to be notfied when a new packet was inserted at the tail.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(calculate_jitter), (rtp_source_send_rtp):
* gst/rtpmanager/rtpsource.h:
Remove clock skew detection, it's move to the jitterbuffer now.
2007-09-16 19:40:31 +00:00
|
|
|
/* elapsed time at receiver, includes the jitter */
|
|
|
|
recv_diff = time - jbuf->base_time;
|
|
|
|
|
|
|
|
/* measure the diff */
|
|
|
|
delta = ((gint64) recv_diff) - ((gint64) send_diff);
|
|
|
|
|
2009-08-31 11:02:16 +00:00
|
|
|
/* 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);
|
|
|
|
|
gst/rtpmanager/gstrtpbin.*: Add signal to notify listeners when a sender becomes a receiver.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (on_sender_timeout),
(create_session), (gst_rtp_bin_associate),
(gst_rtp_bin_sync_chain), (gst_rtp_bin_class_init),
(gst_rtp_bin_request_new_pad):
* gst/rtpmanager/gstrtpbin.h:
Add signal to notify listeners when a sender becomes a receiver.
Tweak lip-sync code, don't store our own copy of the ts-offset of the
jitterbuffer, don't adjust sync if the change is less than 4msec.
Get the RTP timestamp <-> GStreamer timestamp relation directly from
the jitterbuffer instead of our inaccurate version from the source.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_chain), (gst_rtp_jitter_buffer_loop),
(gst_rtp_jitter_buffer_get_sync):
* gst/rtpmanager/gstrtpjitterbuffer.h:
Add G_LIKELY macros, use global defines for max packet reorder and
dropouts.
Reset the jitterbuffer clock skew detection when packets seqnums are
changed unexpectedly.
* gst/rtpmanager/gstrtpsession.c: (on_sender_timeout),
(gst_rtp_session_class_init), (gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
Add sender timeout signal.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_reset_skew),
(calculate_skew), (rtp_jitter_buffer_insert),
(rtp_jitter_buffer_get_sync):
* gst/rtpmanager/rtpjitterbuffer.h:
Add some G_LIKELY macros.
Keep track of the extended RTP timestamp so that we can report the RTP
timestamp <-> GStreamer timestamp relation for lip-sync.
Remove server timestamp gap detection code, the server can sometimes
make a huge gap in timestamps (talk spurts,...) see #549774.
Detect timetamp weirdness instead by observing the sender/receiver
timestamp relation and resync if it changes more than 1 second.
Add method to report about the current rtp <-> gst timestamp relation
which is needed for lip-sync.
* gst/rtpmanager/rtpsession.c: (rtp_session_class_init),
(on_sender_timeout), (check_collision), (rtp_session_process_sr),
(session_cleanup):
* gst/rtpmanager/rtpsession.h:
Add sender timeout signal.
Remove inaccurate rtp <-> gst timestamp relation code, the
jitterbuffer can now do an accurate reporting about this.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(rtp_source_update_caps), (calculate_jitter),
(rtp_source_process_rtp):
* gst/rtpmanager/rtpsource.h:
Remove inaccurate rtp <-> gst timestamp relation code.
* gst/rtpmanager/rtpstats.h:
Define global max-reorder and max-dropout constants for use in various
subsystems.
2008-09-05 13:52:34 +00:00
|
|
|
/* 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) {
|
2009-09-01 10:41:36 +00:00
|
|
|
GST_WARNING ("delta - skew: %" GST_TIME_FORMAT " too big, reset skew",
|
2013-02-07 13:32:26 +00:00
|
|
|
GST_TIME_ARGS (ABS (delta - jbuf->skew)));
|
2009-08-31 10:57:32 +00:00
|
|
|
rtp_jitter_buffer_resync (jbuf, time, gstrtptime, ext_rtptime, TRUE);
|
gst/rtpmanager/gstrtpbin.*: Add signal to notify listeners when a sender becomes a receiver.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (on_sender_timeout),
(create_session), (gst_rtp_bin_associate),
(gst_rtp_bin_sync_chain), (gst_rtp_bin_class_init),
(gst_rtp_bin_request_new_pad):
* gst/rtpmanager/gstrtpbin.h:
Add signal to notify listeners when a sender becomes a receiver.
Tweak lip-sync code, don't store our own copy of the ts-offset of the
jitterbuffer, don't adjust sync if the change is less than 4msec.
Get the RTP timestamp <-> GStreamer timestamp relation directly from
the jitterbuffer instead of our inaccurate version from the source.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_chain), (gst_rtp_jitter_buffer_loop),
(gst_rtp_jitter_buffer_get_sync):
* gst/rtpmanager/gstrtpjitterbuffer.h:
Add G_LIKELY macros, use global defines for max packet reorder and
dropouts.
Reset the jitterbuffer clock skew detection when packets seqnums are
changed unexpectedly.
* gst/rtpmanager/gstrtpsession.c: (on_sender_timeout),
(gst_rtp_session_class_init), (gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
Add sender timeout signal.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_reset_skew),
(calculate_skew), (rtp_jitter_buffer_insert),
(rtp_jitter_buffer_get_sync):
* gst/rtpmanager/rtpjitterbuffer.h:
Add some G_LIKELY macros.
Keep track of the extended RTP timestamp so that we can report the RTP
timestamp <-> GStreamer timestamp relation for lip-sync.
Remove server timestamp gap detection code, the server can sometimes
make a huge gap in timestamps (talk spurts,...) see #549774.
Detect timetamp weirdness instead by observing the sender/receiver
timestamp relation and resync if it changes more than 1 second.
Add method to report about the current rtp <-> gst timestamp relation
which is needed for lip-sync.
* gst/rtpmanager/rtpsession.c: (rtp_session_class_init),
(on_sender_timeout), (check_collision), (rtp_session_process_sr),
(session_cleanup):
* gst/rtpmanager/rtpsession.h:
Add sender timeout signal.
Remove inaccurate rtp <-> gst timestamp relation code, the
jitterbuffer can now do an accurate reporting about this.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(rtp_source_update_caps), (calculate_jitter),
(rtp_source_process_rtp):
* gst/rtpmanager/rtpsource.h:
Remove inaccurate rtp <-> gst timestamp relation code.
* gst/rtpmanager/rtpstats.h:
Define global max-reorder and max-dropout constants for use in various
subsystems.
2008-09-05 13:52:34 +00:00
|
|
|
send_diff = 0;
|
|
|
|
delta = 0;
|
|
|
|
}
|
|
|
|
|
gst/rtpmanager/gstrtpbin.c: Use lock to protect variable.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (gst_rtp_bin_set_property),
(gst_rtp_bin_get_property):
Use lock to protect variable.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_class_init),
(gst_jitter_buffer_sink_parse_caps), (gst_rtp_jitter_buffer_chain),
(convert_rtptime_to_gsttime), (gst_rtp_jitter_buffer_loop):
Reconstruct GST timestamp from RTP timestamps based on measured clock
skew and sync offset.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_init),
(rtp_jitter_buffer_set_tail_changed),
(rtp_jitter_buffer_set_clock_rate),
(rtp_jitter_buffer_get_clock_rate), (calculate_skew),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_peek):
* gst/rtpmanager/rtpjitterbuffer.h:
Measure clock skew.
Add callback to be notfied when a new packet was inserted at the tail.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(calculate_jitter), (rtp_source_send_rtp):
* gst/rtpmanager/rtpsource.h:
Remove clock skew detection, it's move to the jitterbuffer now.
2007-09-16 19:40:31 +00:00
|
|
|
pos = jbuf->window_pos;
|
|
|
|
|
gst/rtpmanager/gstrtpbin.*: Add signal to notify listeners when a sender becomes a receiver.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (on_sender_timeout),
(create_session), (gst_rtp_bin_associate),
(gst_rtp_bin_sync_chain), (gst_rtp_bin_class_init),
(gst_rtp_bin_request_new_pad):
* gst/rtpmanager/gstrtpbin.h:
Add signal to notify listeners when a sender becomes a receiver.
Tweak lip-sync code, don't store our own copy of the ts-offset of the
jitterbuffer, don't adjust sync if the change is less than 4msec.
Get the RTP timestamp <-> GStreamer timestamp relation directly from
the jitterbuffer instead of our inaccurate version from the source.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_chain), (gst_rtp_jitter_buffer_loop),
(gst_rtp_jitter_buffer_get_sync):
* gst/rtpmanager/gstrtpjitterbuffer.h:
Add G_LIKELY macros, use global defines for max packet reorder and
dropouts.
Reset the jitterbuffer clock skew detection when packets seqnums are
changed unexpectedly.
* gst/rtpmanager/gstrtpsession.c: (on_sender_timeout),
(gst_rtp_session_class_init), (gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
Add sender timeout signal.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_reset_skew),
(calculate_skew), (rtp_jitter_buffer_insert),
(rtp_jitter_buffer_get_sync):
* gst/rtpmanager/rtpjitterbuffer.h:
Add some G_LIKELY macros.
Keep track of the extended RTP timestamp so that we can report the RTP
timestamp <-> GStreamer timestamp relation for lip-sync.
Remove server timestamp gap detection code, the server can sometimes
make a huge gap in timestamps (talk spurts,...) see #549774.
Detect timetamp weirdness instead by observing the sender/receiver
timestamp relation and resync if it changes more than 1 second.
Add method to report about the current rtp <-> gst timestamp relation
which is needed for lip-sync.
* gst/rtpmanager/rtpsession.c: (rtp_session_class_init),
(on_sender_timeout), (check_collision), (rtp_session_process_sr),
(session_cleanup):
* gst/rtpmanager/rtpsession.h:
Add sender timeout signal.
Remove inaccurate rtp <-> gst timestamp relation code, the
jitterbuffer can now do an accurate reporting about this.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(rtp_source_update_caps), (calculate_jitter),
(rtp_source_process_rtp):
* gst/rtpmanager/rtpsource.h:
Remove inaccurate rtp <-> gst timestamp relation code.
* gst/rtpmanager/rtpstats.h:
Define global max-reorder and max-dropout constants for use in various
subsystems.
2008-09-05 13:52:34 +00:00
|
|
|
if (G_UNLIKELY (jbuf->window_filling)) {
|
gst/rtpmanager/gstrtpbin.c: Use lock to protect variable.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (gst_rtp_bin_set_property),
(gst_rtp_bin_get_property):
Use lock to protect variable.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_class_init),
(gst_jitter_buffer_sink_parse_caps), (gst_rtp_jitter_buffer_chain),
(convert_rtptime_to_gsttime), (gst_rtp_jitter_buffer_loop):
Reconstruct GST timestamp from RTP timestamps based on measured clock
skew and sync offset.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_init),
(rtp_jitter_buffer_set_tail_changed),
(rtp_jitter_buffer_set_clock_rate),
(rtp_jitter_buffer_get_clock_rate), (calculate_skew),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_peek):
* gst/rtpmanager/rtpjitterbuffer.h:
Measure clock skew.
Add callback to be notfied when a new packet was inserted at the tail.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(calculate_jitter), (rtp_source_send_rtp):
* gst/rtpmanager/rtpsource.h:
Remove clock skew detection, it's move to the jitterbuffer now.
2007-09-16 19:40:31 +00:00
|
|
|
/* we are filling the window */
|
2007-10-02 10:27:45 +00:00
|
|
|
GST_DEBUG ("filling %d, delta %" G_GINT64_FORMAT, pos, delta);
|
gst/rtpmanager/gstrtpbin.c: Use lock to protect variable.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (gst_rtp_bin_set_property),
(gst_rtp_bin_get_property):
Use lock to protect variable.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_class_init),
(gst_jitter_buffer_sink_parse_caps), (gst_rtp_jitter_buffer_chain),
(convert_rtptime_to_gsttime), (gst_rtp_jitter_buffer_loop):
Reconstruct GST timestamp from RTP timestamps based on measured clock
skew and sync offset.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_init),
(rtp_jitter_buffer_set_tail_changed),
(rtp_jitter_buffer_set_clock_rate),
(rtp_jitter_buffer_get_clock_rate), (calculate_skew),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_peek):
* gst/rtpmanager/rtpjitterbuffer.h:
Measure clock skew.
Add callback to be notfied when a new packet was inserted at the tail.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(calculate_jitter), (rtp_source_send_rtp):
* gst/rtpmanager/rtpsource.h:
Remove clock skew detection, it's move to the jitterbuffer now.
2007-09-16 19:40:31 +00:00
|
|
|
jbuf->window[pos++] = delta;
|
|
|
|
/* calc the min delta we observed */
|
gst/rtpmanager/gstrtpbin.*: Add signal to notify listeners when a sender becomes a receiver.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (on_sender_timeout),
(create_session), (gst_rtp_bin_associate),
(gst_rtp_bin_sync_chain), (gst_rtp_bin_class_init),
(gst_rtp_bin_request_new_pad):
* gst/rtpmanager/gstrtpbin.h:
Add signal to notify listeners when a sender becomes a receiver.
Tweak lip-sync code, don't store our own copy of the ts-offset of the
jitterbuffer, don't adjust sync if the change is less than 4msec.
Get the RTP timestamp <-> GStreamer timestamp relation directly from
the jitterbuffer instead of our inaccurate version from the source.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_chain), (gst_rtp_jitter_buffer_loop),
(gst_rtp_jitter_buffer_get_sync):
* gst/rtpmanager/gstrtpjitterbuffer.h:
Add G_LIKELY macros, use global defines for max packet reorder and
dropouts.
Reset the jitterbuffer clock skew detection when packets seqnums are
changed unexpectedly.
* gst/rtpmanager/gstrtpsession.c: (on_sender_timeout),
(gst_rtp_session_class_init), (gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
Add sender timeout signal.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_reset_skew),
(calculate_skew), (rtp_jitter_buffer_insert),
(rtp_jitter_buffer_get_sync):
* gst/rtpmanager/rtpjitterbuffer.h:
Add some G_LIKELY macros.
Keep track of the extended RTP timestamp so that we can report the RTP
timestamp <-> GStreamer timestamp relation for lip-sync.
Remove server timestamp gap detection code, the server can sometimes
make a huge gap in timestamps (talk spurts,...) see #549774.
Detect timetamp weirdness instead by observing the sender/receiver
timestamp relation and resync if it changes more than 1 second.
Add method to report about the current rtp <-> gst timestamp relation
which is needed for lip-sync.
* gst/rtpmanager/rtpsession.c: (rtp_session_class_init),
(on_sender_timeout), (check_collision), (rtp_session_process_sr),
(session_cleanup):
* gst/rtpmanager/rtpsession.h:
Add sender timeout signal.
Remove inaccurate rtp <-> gst timestamp relation code, the
jitterbuffer can now do an accurate reporting about this.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(rtp_source_update_caps), (calculate_jitter),
(rtp_source_process_rtp):
* gst/rtpmanager/rtpsource.h:
Remove inaccurate rtp <-> gst timestamp relation code.
* gst/rtpmanager/rtpstats.h:
Define global max-reorder and max-dropout constants for use in various
subsystems.
2008-09-05 13:52:34 +00:00
|
|
|
if (G_UNLIKELY (pos == 1 || delta < jbuf->window_min))
|
gst/rtpmanager/gstrtpbin.c: Use lock to protect variable.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (gst_rtp_bin_set_property),
(gst_rtp_bin_get_property):
Use lock to protect variable.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_class_init),
(gst_jitter_buffer_sink_parse_caps), (gst_rtp_jitter_buffer_chain),
(convert_rtptime_to_gsttime), (gst_rtp_jitter_buffer_loop):
Reconstruct GST timestamp from RTP timestamps based on measured clock
skew and sync offset.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_init),
(rtp_jitter_buffer_set_tail_changed),
(rtp_jitter_buffer_set_clock_rate),
(rtp_jitter_buffer_get_clock_rate), (calculate_skew),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_peek):
* gst/rtpmanager/rtpjitterbuffer.h:
Measure clock skew.
Add callback to be notfied when a new packet was inserted at the tail.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(calculate_jitter), (rtp_source_send_rtp):
* gst/rtpmanager/rtpsource.h:
Remove clock skew detection, it's move to the jitterbuffer now.
2007-09-16 19:40:31 +00:00
|
|
|
jbuf->window_min = delta;
|
|
|
|
|
gst/rtpmanager/gstrtpbin.*: Add signal to notify listeners when a sender becomes a receiver.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (on_sender_timeout),
(create_session), (gst_rtp_bin_associate),
(gst_rtp_bin_sync_chain), (gst_rtp_bin_class_init),
(gst_rtp_bin_request_new_pad):
* gst/rtpmanager/gstrtpbin.h:
Add signal to notify listeners when a sender becomes a receiver.
Tweak lip-sync code, don't store our own copy of the ts-offset of the
jitterbuffer, don't adjust sync if the change is less than 4msec.
Get the RTP timestamp <-> GStreamer timestamp relation directly from
the jitterbuffer instead of our inaccurate version from the source.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_chain), (gst_rtp_jitter_buffer_loop),
(gst_rtp_jitter_buffer_get_sync):
* gst/rtpmanager/gstrtpjitterbuffer.h:
Add G_LIKELY macros, use global defines for max packet reorder and
dropouts.
Reset the jitterbuffer clock skew detection when packets seqnums are
changed unexpectedly.
* gst/rtpmanager/gstrtpsession.c: (on_sender_timeout),
(gst_rtp_session_class_init), (gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
Add sender timeout signal.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_reset_skew),
(calculate_skew), (rtp_jitter_buffer_insert),
(rtp_jitter_buffer_get_sync):
* gst/rtpmanager/rtpjitterbuffer.h:
Add some G_LIKELY macros.
Keep track of the extended RTP timestamp so that we can report the RTP
timestamp <-> GStreamer timestamp relation for lip-sync.
Remove server timestamp gap detection code, the server can sometimes
make a huge gap in timestamps (talk spurts,...) see #549774.
Detect timetamp weirdness instead by observing the sender/receiver
timestamp relation and resync if it changes more than 1 second.
Add method to report about the current rtp <-> gst timestamp relation
which is needed for lip-sync.
* gst/rtpmanager/rtpsession.c: (rtp_session_class_init),
(on_sender_timeout), (check_collision), (rtp_session_process_sr),
(session_cleanup):
* gst/rtpmanager/rtpsession.h:
Add sender timeout signal.
Remove inaccurate rtp <-> gst timestamp relation code, the
jitterbuffer can now do an accurate reporting about this.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(rtp_source_update_caps), (calculate_jitter),
(rtp_source_process_rtp):
* gst/rtpmanager/rtpsource.h:
Remove inaccurate rtp <-> gst timestamp relation code.
* gst/rtpmanager/rtpstats.h:
Define global max-reorder and max-dropout constants for use in various
subsystems.
2008-09-05 13:52:34 +00:00
|
|
|
if (G_UNLIKELY (send_diff >= MAX_TIME || pos >= MAX_WINDOW)) {
|
2007-09-26 20:08:28 +00:00
|
|
|
jbuf->window_size = pos;
|
|
|
|
|
2007-09-28 11:17:35 +00:00
|
|
|
/* window filled */
|
gst/rtpmanager/gstrtpbin.c: Use lock to protect variable.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (gst_rtp_bin_set_property),
(gst_rtp_bin_get_property):
Use lock to protect variable.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_class_init),
(gst_jitter_buffer_sink_parse_caps), (gst_rtp_jitter_buffer_chain),
(convert_rtptime_to_gsttime), (gst_rtp_jitter_buffer_loop):
Reconstruct GST timestamp from RTP timestamps based on measured clock
skew and sync offset.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_init),
(rtp_jitter_buffer_set_tail_changed),
(rtp_jitter_buffer_set_clock_rate),
(rtp_jitter_buffer_get_clock_rate), (calculate_skew),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_peek):
* gst/rtpmanager/rtpjitterbuffer.h:
Measure clock skew.
Add callback to be notfied when a new packet was inserted at the tail.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(calculate_jitter), (rtp_source_send_rtp):
* gst/rtpmanager/rtpsource.h:
Remove clock skew detection, it's move to the jitterbuffer now.
2007-09-16 19:40:31 +00:00
|
|
|
GST_DEBUG ("min %" G_GINT64_FORMAT, jbuf->window_min);
|
|
|
|
|
2007-09-28 11:17:35 +00:00
|
|
|
/* the skew is now the min */
|
gst/rtpmanager/gstrtpbin.c: Use lock to protect variable.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (gst_rtp_bin_set_property),
(gst_rtp_bin_get_property):
Use lock to protect variable.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_class_init),
(gst_jitter_buffer_sink_parse_caps), (gst_rtp_jitter_buffer_chain),
(convert_rtptime_to_gsttime), (gst_rtp_jitter_buffer_loop):
Reconstruct GST timestamp from RTP timestamps based on measured clock
skew and sync offset.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_init),
(rtp_jitter_buffer_set_tail_changed),
(rtp_jitter_buffer_set_clock_rate),
(rtp_jitter_buffer_get_clock_rate), (calculate_skew),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_peek):
* gst/rtpmanager/rtpjitterbuffer.h:
Measure clock skew.
Add callback to be notfied when a new packet was inserted at the tail.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(calculate_jitter), (rtp_source_send_rtp):
* gst/rtpmanager/rtpsource.h:
Remove clock skew detection, it's move to the jitterbuffer now.
2007-09-16 19:40:31 +00:00
|
|
|
jbuf->skew = jbuf->window_min;
|
|
|
|
jbuf->window_filling = FALSE;
|
2007-09-26 20:08:28 +00:00
|
|
|
} else {
|
2007-09-28 11:17:35 +00:00
|
|
|
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;
|
2007-09-26 20:08:28 +00:00
|
|
|
jbuf->window_size = pos + 1;
|
gst/rtpmanager/gstrtpbin.c: Use lock to protect variable.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (gst_rtp_bin_set_property),
(gst_rtp_bin_get_property):
Use lock to protect variable.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_class_init),
(gst_jitter_buffer_sink_parse_caps), (gst_rtp_jitter_buffer_chain),
(convert_rtptime_to_gsttime), (gst_rtp_jitter_buffer_loop):
Reconstruct GST timestamp from RTP timestamps based on measured clock
skew and sync offset.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_init),
(rtp_jitter_buffer_set_tail_changed),
(rtp_jitter_buffer_set_clock_rate),
(rtp_jitter_buffer_get_clock_rate), (calculate_skew),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_peek):
* gst/rtpmanager/rtpjitterbuffer.h:
Measure clock skew.
Add callback to be notfied when a new packet was inserted at the tail.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(calculate_jitter), (rtp_source_send_rtp):
* gst/rtpmanager/rtpsource.h:
Remove clock skew detection, it's move to the jitterbuffer now.
2007-09-16 19:40:31 +00:00
|
|
|
}
|
|
|
|
} 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;
|
|
|
|
|
gst/rtpmanager/gstrtpbin.*: Add signal to notify listeners when a sender becomes a receiver.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (on_sender_timeout),
(create_session), (gst_rtp_bin_associate),
(gst_rtp_bin_sync_chain), (gst_rtp_bin_class_init),
(gst_rtp_bin_request_new_pad):
* gst/rtpmanager/gstrtpbin.h:
Add signal to notify listeners when a sender becomes a receiver.
Tweak lip-sync code, don't store our own copy of the ts-offset of the
jitterbuffer, don't adjust sync if the change is less than 4msec.
Get the RTP timestamp <-> GStreamer timestamp relation directly from
the jitterbuffer instead of our inaccurate version from the source.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_chain), (gst_rtp_jitter_buffer_loop),
(gst_rtp_jitter_buffer_get_sync):
* gst/rtpmanager/gstrtpjitterbuffer.h:
Add G_LIKELY macros, use global defines for max packet reorder and
dropouts.
Reset the jitterbuffer clock skew detection when packets seqnums are
changed unexpectedly.
* gst/rtpmanager/gstrtpsession.c: (on_sender_timeout),
(gst_rtp_session_class_init), (gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
Add sender timeout signal.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_reset_skew),
(calculate_skew), (rtp_jitter_buffer_insert),
(rtp_jitter_buffer_get_sync):
* gst/rtpmanager/rtpjitterbuffer.h:
Add some G_LIKELY macros.
Keep track of the extended RTP timestamp so that we can report the RTP
timestamp <-> GStreamer timestamp relation for lip-sync.
Remove server timestamp gap detection code, the server can sometimes
make a huge gap in timestamps (talk spurts,...) see #549774.
Detect timetamp weirdness instead by observing the sender/receiver
timestamp relation and resync if it changes more than 1 second.
Add method to report about the current rtp <-> gst timestamp relation
which is needed for lip-sync.
* gst/rtpmanager/rtpsession.c: (rtp_session_class_init),
(on_sender_timeout), (check_collision), (rtp_session_process_sr),
(session_cleanup):
* gst/rtpmanager/rtpsession.h:
Add sender timeout signal.
Remove inaccurate rtp <-> gst timestamp relation code, the
jitterbuffer can now do an accurate reporting about this.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(rtp_source_update_caps), (calculate_jitter),
(rtp_source_process_rtp):
* gst/rtpmanager/rtpsource.h:
Remove inaccurate rtp <-> gst timestamp relation code.
* gst/rtpmanager/rtpstats.h:
Define global max-reorder and max-dropout constants for use in various
subsystems.
2008-09-05 13:52:34 +00:00
|
|
|
if (G_UNLIKELY (delta <= jbuf->window_min)) {
|
gst/rtpmanager/gstrtpbin.c: Use lock to protect variable.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (gst_rtp_bin_set_property),
(gst_rtp_bin_get_property):
Use lock to protect variable.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_class_init),
(gst_jitter_buffer_sink_parse_caps), (gst_rtp_jitter_buffer_chain),
(convert_rtptime_to_gsttime), (gst_rtp_jitter_buffer_loop):
Reconstruct GST timestamp from RTP timestamps based on measured clock
skew and sync offset.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_init),
(rtp_jitter_buffer_set_tail_changed),
(rtp_jitter_buffer_set_clock_rate),
(rtp_jitter_buffer_get_clock_rate), (calculate_skew),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_peek):
* gst/rtpmanager/rtpjitterbuffer.h:
Measure clock skew.
Add callback to be notfied when a new packet was inserted at the tail.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(calculate_jitter), (rtp_source_send_rtp):
* gst/rtpmanager/rtpsource.h:
Remove clock skew detection, it's move to the jitterbuffer now.
2007-09-16 19:40:31 +00:00
|
|
|
/* if the new value we inserted is smaller or equal to the current min,
|
|
|
|
* it becomes the new min */
|
|
|
|
jbuf->window_min = delta;
|
gst/rtpmanager/gstrtpbin.*: Add signal to notify listeners when a sender becomes a receiver.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (on_sender_timeout),
(create_session), (gst_rtp_bin_associate),
(gst_rtp_bin_sync_chain), (gst_rtp_bin_class_init),
(gst_rtp_bin_request_new_pad):
* gst/rtpmanager/gstrtpbin.h:
Add signal to notify listeners when a sender becomes a receiver.
Tweak lip-sync code, don't store our own copy of the ts-offset of the
jitterbuffer, don't adjust sync if the change is less than 4msec.
Get the RTP timestamp <-> GStreamer timestamp relation directly from
the jitterbuffer instead of our inaccurate version from the source.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_chain), (gst_rtp_jitter_buffer_loop),
(gst_rtp_jitter_buffer_get_sync):
* gst/rtpmanager/gstrtpjitterbuffer.h:
Add G_LIKELY macros, use global defines for max packet reorder and
dropouts.
Reset the jitterbuffer clock skew detection when packets seqnums are
changed unexpectedly.
* gst/rtpmanager/gstrtpsession.c: (on_sender_timeout),
(gst_rtp_session_class_init), (gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
Add sender timeout signal.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_reset_skew),
(calculate_skew), (rtp_jitter_buffer_insert),
(rtp_jitter_buffer_get_sync):
* gst/rtpmanager/rtpjitterbuffer.h:
Add some G_LIKELY macros.
Keep track of the extended RTP timestamp so that we can report the RTP
timestamp <-> GStreamer timestamp relation for lip-sync.
Remove server timestamp gap detection code, the server can sometimes
make a huge gap in timestamps (talk spurts,...) see #549774.
Detect timetamp weirdness instead by observing the sender/receiver
timestamp relation and resync if it changes more than 1 second.
Add method to report about the current rtp <-> gst timestamp relation
which is needed for lip-sync.
* gst/rtpmanager/rtpsession.c: (rtp_session_class_init),
(on_sender_timeout), (check_collision), (rtp_session_process_sr),
(session_cleanup):
* gst/rtpmanager/rtpsession.h:
Add sender timeout signal.
Remove inaccurate rtp <-> gst timestamp relation code, the
jitterbuffer can now do an accurate reporting about this.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(rtp_source_update_caps), (calculate_jitter),
(rtp_source_process_rtp):
* gst/rtpmanager/rtpsource.h:
Remove inaccurate rtp <-> gst timestamp relation code.
* gst/rtpmanager/rtpstats.h:
Define global max-reorder and max-dropout constants for use in various
subsystems.
2008-09-05 13:52:34 +00:00
|
|
|
} else if (G_UNLIKELY (old == jbuf->window_min)) {
|
gst/rtpmanager/gstrtpbin.c: Use lock to protect variable.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (gst_rtp_bin_set_property),
(gst_rtp_bin_get_property):
Use lock to protect variable.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_class_init),
(gst_jitter_buffer_sink_parse_caps), (gst_rtp_jitter_buffer_chain),
(convert_rtptime_to_gsttime), (gst_rtp_jitter_buffer_loop):
Reconstruct GST timestamp from RTP timestamps based on measured clock
skew and sync offset.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_init),
(rtp_jitter_buffer_set_tail_changed),
(rtp_jitter_buffer_set_clock_rate),
(rtp_jitter_buffer_get_clock_rate), (calculate_skew),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_peek):
* gst/rtpmanager/rtpjitterbuffer.h:
Measure clock skew.
Add callback to be notfied when a new packet was inserted at the tail.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(calculate_jitter), (rtp_source_send_rtp):
* gst/rtpmanager/rtpsource.h:
Remove clock skew detection, it's move to the jitterbuffer now.
2007-09-16 19:40:31 +00:00
|
|
|
gint64 min = G_MAXINT64;
|
|
|
|
|
|
|
|
/* if we removed the old min, we have to find a new min */
|
2007-09-26 20:08:28 +00:00
|
|
|
for (i = 0; i < jbuf->window_size; i++) {
|
gst/rtpmanager/gstrtpbin.c: Use lock to protect variable.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (gst_rtp_bin_set_property),
(gst_rtp_bin_get_property):
Use lock to protect variable.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_class_init),
(gst_jitter_buffer_sink_parse_caps), (gst_rtp_jitter_buffer_chain),
(convert_rtptime_to_gsttime), (gst_rtp_jitter_buffer_loop):
Reconstruct GST timestamp from RTP timestamps based on measured clock
skew and sync offset.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_init),
(rtp_jitter_buffer_set_tail_changed),
(rtp_jitter_buffer_set_clock_rate),
(rtp_jitter_buffer_get_clock_rate), (calculate_skew),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_peek):
* gst/rtpmanager/rtpjitterbuffer.h:
Measure clock skew.
Add callback to be notfied when a new packet was inserted at the tail.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(calculate_jitter), (rtp_source_send_rtp):
* gst/rtpmanager/rtpsource.h:
Remove clock skew detection, it's move to the jitterbuffer now.
2007-09-16 19:40:31 +00:00
|
|
|
/* 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 */
|
2007-09-28 11:17:35 +00:00
|
|
|
jbuf->skew = (jbuf->window_min + (124 * jbuf->skew)) / 125;
|
2007-10-02 10:27:45 +00:00
|
|
|
GST_DEBUG ("delta %" G_GINT64_FORMAT ", new min: %" G_GINT64_FORMAT,
|
|
|
|
delta, jbuf->window_min);
|
gst/rtpmanager/gstrtpbin.c: Use lock to protect variable.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (gst_rtp_bin_set_property),
(gst_rtp_bin_get_property):
Use lock to protect variable.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_class_init),
(gst_jitter_buffer_sink_parse_caps), (gst_rtp_jitter_buffer_chain),
(convert_rtptime_to_gsttime), (gst_rtp_jitter_buffer_loop):
Reconstruct GST timestamp from RTP timestamps based on measured clock
skew and sync offset.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_init),
(rtp_jitter_buffer_set_tail_changed),
(rtp_jitter_buffer_set_clock_rate),
(rtp_jitter_buffer_get_clock_rate), (calculate_skew),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_peek):
* gst/rtpmanager/rtpjitterbuffer.h:
Measure clock skew.
Add callback to be notfied when a new packet was inserted at the tail.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(calculate_jitter), (rtp_source_send_rtp):
* gst/rtpmanager/rtpsource.h:
Remove clock skew detection, it's move to the jitterbuffer now.
2007-09-16 19:40:31 +00:00
|
|
|
}
|
|
|
|
/* wrap around in the window */
|
gst/rtpmanager/gstrtpbin.*: Add signal to notify listeners when a sender becomes a receiver.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (on_sender_timeout),
(create_session), (gst_rtp_bin_associate),
(gst_rtp_bin_sync_chain), (gst_rtp_bin_class_init),
(gst_rtp_bin_request_new_pad):
* gst/rtpmanager/gstrtpbin.h:
Add signal to notify listeners when a sender becomes a receiver.
Tweak lip-sync code, don't store our own copy of the ts-offset of the
jitterbuffer, don't adjust sync if the change is less than 4msec.
Get the RTP timestamp <-> GStreamer timestamp relation directly from
the jitterbuffer instead of our inaccurate version from the source.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_chain), (gst_rtp_jitter_buffer_loop),
(gst_rtp_jitter_buffer_get_sync):
* gst/rtpmanager/gstrtpjitterbuffer.h:
Add G_LIKELY macros, use global defines for max packet reorder and
dropouts.
Reset the jitterbuffer clock skew detection when packets seqnums are
changed unexpectedly.
* gst/rtpmanager/gstrtpsession.c: (on_sender_timeout),
(gst_rtp_session_class_init), (gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
Add sender timeout signal.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_reset_skew),
(calculate_skew), (rtp_jitter_buffer_insert),
(rtp_jitter_buffer_get_sync):
* gst/rtpmanager/rtpjitterbuffer.h:
Add some G_LIKELY macros.
Keep track of the extended RTP timestamp so that we can report the RTP
timestamp <-> GStreamer timestamp relation for lip-sync.
Remove server timestamp gap detection code, the server can sometimes
make a huge gap in timestamps (talk spurts,...) see #549774.
Detect timetamp weirdness instead by observing the sender/receiver
timestamp relation and resync if it changes more than 1 second.
Add method to report about the current rtp <-> gst timestamp relation
which is needed for lip-sync.
* gst/rtpmanager/rtpsession.c: (rtp_session_class_init),
(on_sender_timeout), (check_collision), (rtp_session_process_sr),
(session_cleanup):
* gst/rtpmanager/rtpsession.h:
Add sender timeout signal.
Remove inaccurate rtp <-> gst timestamp relation code, the
jitterbuffer can now do an accurate reporting about this.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(rtp_source_update_caps), (calculate_jitter),
(rtp_source_process_rtp):
* gst/rtpmanager/rtpsource.h:
Remove inaccurate rtp <-> gst timestamp relation code.
* gst/rtpmanager/rtpstats.h:
Define global max-reorder and max-dropout constants for use in various
subsystems.
2008-09-05 13:52:34 +00:00
|
|
|
if (G_UNLIKELY (pos >= jbuf->window_size))
|
gst/rtpmanager/gstrtpbin.c: Use lock to protect variable.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (gst_rtp_bin_set_property),
(gst_rtp_bin_get_property):
Use lock to protect variable.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_class_init),
(gst_jitter_buffer_sink_parse_caps), (gst_rtp_jitter_buffer_chain),
(convert_rtptime_to_gsttime), (gst_rtp_jitter_buffer_loop):
Reconstruct GST timestamp from RTP timestamps based on measured clock
skew and sync offset.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_init),
(rtp_jitter_buffer_set_tail_changed),
(rtp_jitter_buffer_set_clock_rate),
(rtp_jitter_buffer_get_clock_rate), (calculate_skew),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_peek):
* gst/rtpmanager/rtpjitterbuffer.h:
Measure clock skew.
Add callback to be notfied when a new packet was inserted at the tail.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(calculate_jitter), (rtp_source_send_rtp):
* gst/rtpmanager/rtpsource.h:
Remove clock skew detection, it's move to the jitterbuffer now.
2007-09-16 19:40:31 +00:00
|
|
|
pos = 0;
|
|
|
|
jbuf->window_pos = pos;
|
2007-09-28 11:17:35 +00:00
|
|
|
|
2007-09-28 14:51:58 +00:00
|
|
|
no_skew:
|
2007-09-28 11:17:35 +00:00
|
|
|
/* the output time is defined as the base timestamp plus the RTP time
|
|
|
|
* adjusted for the clock skew .*/
|
2008-12-23 11:39:59 +00:00
|
|
|
if (jbuf->base_time != -1) {
|
2009-08-31 10:47:15 +00:00
|
|
|
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;
|
|
|
|
}
|
2008-12-23 11:39:59 +00:00
|
|
|
} else
|
2008-11-17 15:17:52 +00:00
|
|
|
out_time = -1;
|
2007-09-28 11:17:35 +00:00
|
|
|
|
2007-10-02 10:27:45 +00:00
|
|
|
GST_DEBUG ("skew %" G_GINT64_FORMAT ", out %" GST_TIME_FORMAT,
|
2007-09-28 11:17:35 +00:00
|
|
|
jbuf->skew, GST_TIME_ARGS (out_time));
|
|
|
|
|
|
|
|
return out_time;
|
gst/rtpmanager/gstrtpbin.c: Use lock to protect variable.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (gst_rtp_bin_set_property),
(gst_rtp_bin_get_property):
Use lock to protect variable.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_class_init),
(gst_jitter_buffer_sink_parse_caps), (gst_rtp_jitter_buffer_chain),
(convert_rtptime_to_gsttime), (gst_rtp_jitter_buffer_loop):
Reconstruct GST timestamp from RTP timestamps based on measured clock
skew and sync offset.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_init),
(rtp_jitter_buffer_set_tail_changed),
(rtp_jitter_buffer_set_clock_rate),
(rtp_jitter_buffer_get_clock_rate), (calculate_skew),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_peek):
* gst/rtpmanager/rtpjitterbuffer.h:
Measure clock skew.
Add callback to be notfied when a new packet was inserted at the tail.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(calculate_jitter), (rtp_source_send_rtp):
* gst/rtpmanager/rtpsource.h:
Remove clock skew detection, it's move to the jitterbuffer now.
2007-09-16 19:40:31 +00:00
|
|
|
}
|
|
|
|
|
2013-09-20 21:48:20 +00:00
|
|
|
static void
|
|
|
|
queue_do_insert (RTPJitterBuffer * jbuf, GList * list, GList * item)
|
|
|
|
{
|
|
|
|
GQueue *queue = jbuf->packets;
|
|
|
|
|
2014-04-29 13:29:31 +00:00
|
|
|
/* It's more likely that the packet was inserted at the tail of the queue */
|
2013-09-20 21:48:20 +00:00
|
|
|
if (G_LIKELY (list)) {
|
2014-04-29 13:29:31 +00:00
|
|
|
item->prev = list;
|
|
|
|
item->next = list->next;
|
|
|
|
list->next = item;
|
2013-09-20 21:48:20 +00:00
|
|
|
} else {
|
2014-04-29 13:29:31 +00:00
|
|
|
item->prev = NULL;
|
|
|
|
item->next = queue->head;
|
|
|
|
queue->head = item;
|
2013-09-20 21:48:20 +00:00
|
|
|
}
|
2014-04-29 13:29:31 +00:00
|
|
|
if (item->next)
|
|
|
|
item->next->prev = item;
|
|
|
|
else
|
|
|
|
queue->tail = item;
|
2013-09-20 21:48:20 +00:00
|
|
|
queue->length++;
|
|
|
|
}
|
|
|
|
|
2016-10-09 13:59:05 +00:00
|
|
|
GstClockTime
|
|
|
|
rtp_jitter_buffer_calculate_pts (RTPJitterBuffer * jbuf, GstClockTime dts,
|
2017-02-08 13:36:00 +00:00
|
|
|
gboolean estimated_dts, guint32 rtptime, GstClockTime base_time)
|
gst/rtpmanager/: Remove complicated async queue and replace with more simple jitterbuffer code while also fixing some...
Original commit message from CVS:
* gst/rtpmanager/Makefile.am:
* gst/rtpmanager/async_jitter_queue.c:
* gst/rtpmanager/async_jitter_queue.h:
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_class_init),
(rtp_jitter_buffer_init), (rtp_jitter_buffer_finalize),
(rtp_jitter_buffer_new), (compare_seqnum),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_pop),
(rtp_jitter_buffer_flush), (rtp_jitter_buffer_num_packets),
(rtp_jitter_buffer_get_ts_diff):
* gst/rtpmanager/rtpjitterbuffer.h:
Remove complicated async queue and replace with more simple jitterbuffer
code while also fixing some bugs.
* gst/rtpmanager/gstrtpbin-marshal.list:
* gst/rtpmanager/gstrtpbin.c: (on_new_ssrc), (on_ssrc_collision),
(on_ssrc_validated), (on_bye_ssrc), (on_bye_timeout), (on_timeout),
(create_session), (gst_rtp_bin_class_init), (create_recv_rtp),
(create_send_rtp):
* gst/rtpmanager/gstrtpbin.h:
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_init), (gst_rtp_jitter_buffer_dispose),
(gst_jitter_buffer_sink_parse_caps),
(gst_rtp_jitter_buffer_flush_start),
(gst_rtp_jitter_buffer_flush_stop),
(gst_rtp_jitter_buffer_change_state),
(gst_rtp_jitter_buffer_sink_event), (gst_rtp_jitter_buffer_chain),
(gst_rtp_jitter_buffer_loop), (gst_rtp_jitter_buffer_set_property):
* gst/rtpmanager/gstrtpsession.c: (on_new_ssrc),
(on_ssrc_collision), (on_ssrc_validated), (on_bye_ssrc),
(on_bye_timeout), (on_timeout), (gst_rtp_session_class_init),
(gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
* gst/rtpmanager/rtpsession.c: (on_bye_ssrc), (session_cleanup):
Use new jitterbuffer code.
Expose some new signals in preparation for handling EOS.
2007-08-10 17:16:53 +00:00
|
|
|
{
|
2016-01-05 14:15:16 +00:00
|
|
|
guint64 ext_rtptime;
|
2016-10-09 13:59:05 +00:00
|
|
|
GstClockTime gstrtptime, pts;
|
2016-01-05 14:15:16 +00:00
|
|
|
GstClock *media_clock, *pipeline_clock;
|
|
|
|
guint64 media_clock_offset;
|
|
|
|
gboolean rfc7273_mode;
|
gst/rtpmanager/: Remove complicated async queue and replace with more simple jitterbuffer code while also fixing some...
Original commit message from CVS:
* gst/rtpmanager/Makefile.am:
* gst/rtpmanager/async_jitter_queue.c:
* gst/rtpmanager/async_jitter_queue.h:
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_class_init),
(rtp_jitter_buffer_init), (rtp_jitter_buffer_finalize),
(rtp_jitter_buffer_new), (compare_seqnum),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_pop),
(rtp_jitter_buffer_flush), (rtp_jitter_buffer_num_packets),
(rtp_jitter_buffer_get_ts_diff):
* gst/rtpmanager/rtpjitterbuffer.h:
Remove complicated async queue and replace with more simple jitterbuffer
code while also fixing some bugs.
* gst/rtpmanager/gstrtpbin-marshal.list:
* gst/rtpmanager/gstrtpbin.c: (on_new_ssrc), (on_ssrc_collision),
(on_ssrc_validated), (on_bye_ssrc), (on_bye_timeout), (on_timeout),
(create_session), (gst_rtp_bin_class_init), (create_recv_rtp),
(create_send_rtp):
* gst/rtpmanager/gstrtpbin.h:
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_init), (gst_rtp_jitter_buffer_dispose),
(gst_jitter_buffer_sink_parse_caps),
(gst_rtp_jitter_buffer_flush_start),
(gst_rtp_jitter_buffer_flush_stop),
(gst_rtp_jitter_buffer_change_state),
(gst_rtp_jitter_buffer_sink_event), (gst_rtp_jitter_buffer_chain),
(gst_rtp_jitter_buffer_loop), (gst_rtp_jitter_buffer_set_property):
* gst/rtpmanager/gstrtpsession.c: (on_new_ssrc),
(on_ssrc_collision), (on_ssrc_validated), (on_bye_ssrc),
(on_bye_timeout), (on_timeout), (gst_rtp_session_class_init),
(gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
* gst/rtpmanager/rtpsession.c: (on_bye_ssrc), (session_cleanup):
Use new jitterbuffer code.
Expose some new signals in preparation for handling EOS.
2007-08-10 17:16:53 +00:00
|
|
|
|
2011-08-18 12:12:21 +00:00
|
|
|
/* rtp time jumps are checked for during skew calculation, but bypassed
|
2011-09-01 12:47:48 +00:00
|
|
|
* 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 */
|
2017-02-08 13:36:00 +00:00
|
|
|
if (GST_CLOCK_TIME_IS_VALID (dts) && !estimated_dts &&
|
2011-09-01 12:47:48 +00:00
|
|
|
jbuf->mode != RTP_JITTER_BUFFER_MODE_SLAVE &&
|
2011-08-18 12:12:21 +00:00
|
|
|
jbuf->base_time != -1 && jbuf->last_rtptime != -1) {
|
|
|
|
GstClockTime ext_rtptime = jbuf->ext_rtptime;
|
|
|
|
|
|
|
|
ext_rtptime = gst_rtp_buffer_ext_timestamp (&ext_rtptime, rtptime);
|
2013-09-20 13:35:25 +00:00
|
|
|
if (ext_rtptime > jbuf->last_rtptime + 3 * jbuf->clock_rate ||
|
|
|
|
ext_rtptime + 3 * jbuf->clock_rate < jbuf->last_rtptime) {
|
2011-08-18 12:12:21 +00:00
|
|
|
/* 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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-05 14:15:16 +00:00
|
|
|
/* 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) {
|
2016-10-09 13:59:05 +00:00
|
|
|
return jbuf->prev_out_time;
|
2016-01-05 14:15:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* 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) {
|
|
|
|
/* 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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-10-01 09:20:08 +00:00
|
|
|
switch (jbuf->mode) {
|
|
|
|
case RTP_JITTER_BUFFER_MODE_NONE:
|
2009-10-08 17:23:53 +00:00
|
|
|
case RTP_JITTER_BUFFER_MODE_BUFFER:
|
2009-10-01 10:09:58 +00:00
|
|
|
/* send 0 as the first timestamp and -1 for the other ones. This will
|
2015-06-15 05:32:21 +00:00
|
|
|
* interpolate them from the RTP timestamps with a 0 origin. In buffering
|
2009-10-08 17:23:53 +00:00
|
|
|
* mode we will adjust the outgoing timestamps according to the amount of
|
|
|
|
* time we spent buffering. */
|
2009-10-01 10:09:58 +00:00
|
|
|
if (jbuf->base_time == -1)
|
2013-09-20 21:48:20 +00:00
|
|
|
dts = 0;
|
2009-10-01 10:09:58 +00:00
|
|
|
else
|
2013-09-20 21:48:20 +00:00
|
|
|
dts = -1;
|
2009-10-01 09:20:08 +00:00
|
|
|
break;
|
2013-10-30 15:49:36 +00:00
|
|
|
case RTP_JITTER_BUFFER_MODE_SYNCED:
|
|
|
|
/* synchronized clocks, take first timestamp as base, use RTP timestamps
|
|
|
|
* to interpolate */
|
2016-01-05 14:15:16 +00:00
|
|
|
if (jbuf->base_time != -1 && !jbuf->need_resync)
|
2013-10-30 15:49:36 +00:00
|
|
|
dts = -1;
|
|
|
|
break;
|
2009-10-01 15:14:09 +00:00
|
|
|
case RTP_JITTER_BUFFER_MODE_SLAVE:
|
2009-10-01 09:20:08 +00:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2016-01-05 14:15:16 +00:00
|
|
|
|
|
|
|
/* 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)) {
|
|
|
|
GST_INFO ("resync to time %" GST_TIME_FORMAT ", rtptime %"
|
2016-04-15 14:35:07 +00:00
|
|
|
GST_TIME_FORMAT, GST_TIME_ARGS (dts), GST_TIME_ARGS (gstrtptime));
|
2016-01-05 14:15:16 +00:00
|
|
|
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)
|
2016-10-09 13:59:05 +00:00
|
|
|
pts = rtpsystime - base_time;
|
2016-01-05 14:15:16 +00:00
|
|
|
else
|
2016-10-09 13:59:05 +00:00
|
|
|
pts = 0;
|
2016-01-05 14:15:16 +00:00
|
|
|
|
|
|
|
GST_DEBUG ("RFC7273 clock time %" GST_TIME_FORMAT ", out %" GST_TIME_FORMAT,
|
2016-10-09 13:59:05 +00:00
|
|
|
GST_TIME_ARGS (rtpsystime), GST_TIME_ARGS (pts));
|
2016-01-05 14:15:16 +00:00
|
|
|
} 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, jbuf->clock_rate,
|
|
|
|
GST_SECOND);
|
|
|
|
else
|
|
|
|
ntptime +=
|
|
|
|
gst_util_uint64_scale (rtptime_tmp - ntprtptime, jbuf->clock_rate,
|
|
|
|
GST_SECOND);
|
|
|
|
|
|
|
|
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)
|
2016-10-09 13:59:05 +00:00
|
|
|
pts = rtpsystime - base_time;
|
2016-01-05 14:15:16 +00:00
|
|
|
else
|
2016-10-09 13:59:05 +00:00
|
|
|
pts = 0;
|
2016-01-05 14:15:16 +00:00
|
|
|
|
|
|
|
GST_DEBUG ("RFC7273 clock time %" GST_TIME_FORMAT ", out %" GST_TIME_FORMAT,
|
2016-10-09 13:59:05 +00:00
|
|
|
GST_TIME_ARGS (rtpsystime), GST_TIME_ARGS (pts));
|
2016-01-05 14:15:16 +00:00
|
|
|
} 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. */
|
2016-10-09 13:59:05 +00:00
|
|
|
pts = calculate_skew (jbuf, ext_rtptime, gstrtptime, dts);
|
2016-01-05 14:15:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* check if timestamps are not going backwards, we can only check this if we
|
|
|
|
* have a previous out time and a previous send_diff */
|
2016-10-09 13:59:05 +00:00
|
|
|
if (G_LIKELY (pts != -1 && jbuf->prev_out_time != -1
|
2016-01-05 14:15:16 +00:00
|
|
|
&& 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
|
2016-10-09 13:59:05 +00:00
|
|
|
&& pts < jbuf->prev_out_time) ||
|
2016-01-05 14:15:16 +00:00
|
|
|
/* if the server timestamps went backwards and the out_time forwards */
|
|
|
|
(gstrtptime - jbuf->base_rtptime < jbuf->prev_send_diff
|
2016-10-09 13:59:05 +00:00
|
|
|
&& pts > jbuf->prev_out_time) ||
|
2016-01-05 14:15:16 +00:00
|
|
|
/* if the server timestamps did not change */
|
|
|
|
gstrtptime - jbuf->base_rtptime == jbuf->prev_send_diff)) {
|
|
|
|
GST_DEBUG ("backwards timestamps, using previous time");
|
2016-10-09 13:59:05 +00:00
|
|
|
pts = jbuf->prev_out_time;
|
2016-01-05 14:15:16 +00:00
|
|
|
}
|
|
|
|
}
|
2016-10-09 13:59:05 +00:00
|
|
|
|
|
|
|
if (dts != -1 && pts + jbuf->delay < dts) {
|
2016-01-05 14:15:16 +00:00
|
|
|
/* 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 %"
|
2016-10-09 13:59:05 +00:00
|
|
|
GST_TIME_FORMAT ", reset jitterbuffer", GST_TIME_ARGS (pts),
|
2016-04-15 14:35:07 +00:00
|
|
|
jbuf->delay, GST_TIME_ARGS (dts));
|
2016-01-05 14:15:16 +00:00
|
|
|
rtp_jitter_buffer_resync (jbuf, dts, gstrtptime, ext_rtptime, TRUE);
|
2016-10-09 13:59:05 +00:00
|
|
|
pts = dts;
|
2016-01-05 14:15:16 +00:00
|
|
|
}
|
|
|
|
|
2016-10-09 13:59:05 +00:00
|
|
|
jbuf->prev_out_time = pts;
|
2016-01-05 14:15:16 +00:00
|
|
|
jbuf->prev_send_diff = gstrtptime - jbuf->base_rtptime;
|
|
|
|
|
|
|
|
if (media_clock)
|
|
|
|
gst_object_unref (media_clock);
|
|
|
|
if (pipeline_clock)
|
|
|
|
gst_object_unref (pipeline_clock);
|
gst/rtpmanager/gstrtpbin.c: Use lock to protect variable.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (gst_rtp_bin_set_property),
(gst_rtp_bin_get_property):
Use lock to protect variable.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_class_init),
(gst_jitter_buffer_sink_parse_caps), (gst_rtp_jitter_buffer_chain),
(convert_rtptime_to_gsttime), (gst_rtp_jitter_buffer_loop):
Reconstruct GST timestamp from RTP timestamps based on measured clock
skew and sync offset.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_init),
(rtp_jitter_buffer_set_tail_changed),
(rtp_jitter_buffer_set_clock_rate),
(rtp_jitter_buffer_get_clock_rate), (calculate_skew),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_peek):
* gst/rtpmanager/rtpjitterbuffer.h:
Measure clock skew.
Add callback to be notfied when a new packet was inserted at the tail.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(calculate_jitter), (rtp_source_send_rtp):
* gst/rtpmanager/rtpsource.h:
Remove clock skew detection, it's move to the jitterbuffer now.
2007-09-16 19:40:31 +00:00
|
|
|
|
2016-10-09 13:59:05 +00:00
|
|
|
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.
|
|
|
|
*/
|
|
|
|
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;
|
|
|
|
|
2013-09-20 22:08:20 +00:00
|
|
|
append:
|
2013-09-20 21:48:20 +00:00
|
|
|
queue_do_insert (jbuf, list, (GList *) item);
|
gst/rtpmanager/: Remove complicated async queue and replace with more simple jitterbuffer code while also fixing some...
Original commit message from CVS:
* gst/rtpmanager/Makefile.am:
* gst/rtpmanager/async_jitter_queue.c:
* gst/rtpmanager/async_jitter_queue.h:
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_class_init),
(rtp_jitter_buffer_init), (rtp_jitter_buffer_finalize),
(rtp_jitter_buffer_new), (compare_seqnum),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_pop),
(rtp_jitter_buffer_flush), (rtp_jitter_buffer_num_packets),
(rtp_jitter_buffer_get_ts_diff):
* gst/rtpmanager/rtpjitterbuffer.h:
Remove complicated async queue and replace with more simple jitterbuffer
code while also fixing some bugs.
* gst/rtpmanager/gstrtpbin-marshal.list:
* gst/rtpmanager/gstrtpbin.c: (on_new_ssrc), (on_ssrc_collision),
(on_ssrc_validated), (on_bye_ssrc), (on_bye_timeout), (on_timeout),
(create_session), (gst_rtp_bin_class_init), (create_recv_rtp),
(create_send_rtp):
* gst/rtpmanager/gstrtpbin.h:
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_init), (gst_rtp_jitter_buffer_dispose),
(gst_jitter_buffer_sink_parse_caps),
(gst_rtp_jitter_buffer_flush_start),
(gst_rtp_jitter_buffer_flush_stop),
(gst_rtp_jitter_buffer_change_state),
(gst_rtp_jitter_buffer_sink_event), (gst_rtp_jitter_buffer_chain),
(gst_rtp_jitter_buffer_loop), (gst_rtp_jitter_buffer_set_property):
* gst/rtpmanager/gstrtpsession.c: (on_new_ssrc),
(on_ssrc_collision), (on_ssrc_validated), (on_bye_ssrc),
(on_bye_timeout), (on_timeout), (gst_rtp_session_class_init),
(gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
* gst/rtpmanager/rtpsession.c: (on_bye_ssrc), (session_cleanup):
Use new jitterbuffer code.
Expose some new signals in preparation for handling EOS.
2007-08-10 17:16:53 +00:00
|
|
|
|
2009-10-01 15:14:09 +00:00
|
|
|
/* buffering mode, update buffer stats */
|
|
|
|
if (jbuf->mode == RTP_JITTER_BUFFER_MODE_BUFFER)
|
2009-10-05 17:45:35 +00:00
|
|
|
update_buffer_level (jbuf, percent);
|
2013-07-30 16:52:58 +00:00
|
|
|
else if (percent)
|
2009-10-05 17:45:35 +00:00
|
|
|
*percent = -1;
|
2009-10-01 15:14:09 +00:00
|
|
|
|
2014-04-29 13:29:31 +00:00
|
|
|
/* head was changed when we did not find a previous packet, we set the return
|
2008-05-26 10:09:29 +00:00
|
|
|
* flag when requested. */
|
2014-04-29 13:29:31 +00:00
|
|
|
if (G_LIKELY (head))
|
|
|
|
*head = (list == NULL);
|
gst/rtpmanager/gstrtpbin.c: Use lock to protect variable.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (gst_rtp_bin_set_property),
(gst_rtp_bin_get_property):
Use lock to protect variable.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_class_init),
(gst_jitter_buffer_sink_parse_caps), (gst_rtp_jitter_buffer_chain),
(convert_rtptime_to_gsttime), (gst_rtp_jitter_buffer_loop):
Reconstruct GST timestamp from RTP timestamps based on measured clock
skew and sync offset.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_init),
(rtp_jitter_buffer_set_tail_changed),
(rtp_jitter_buffer_set_clock_rate),
(rtp_jitter_buffer_get_clock_rate), (calculate_skew),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_peek):
* gst/rtpmanager/rtpjitterbuffer.h:
Measure clock skew.
Add callback to be notfied when a new packet was inserted at the tail.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(calculate_jitter), (rtp_source_send_rtp):
* gst/rtpmanager/rtpsource.h:
Remove clock skew detection, it's move to the jitterbuffer now.
2007-09-16 19:40:31 +00:00
|
|
|
|
gst/rtpmanager/: Remove complicated async queue and replace with more simple jitterbuffer code while also fixing some...
Original commit message from CVS:
* gst/rtpmanager/Makefile.am:
* gst/rtpmanager/async_jitter_queue.c:
* gst/rtpmanager/async_jitter_queue.h:
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_class_init),
(rtp_jitter_buffer_init), (rtp_jitter_buffer_finalize),
(rtp_jitter_buffer_new), (compare_seqnum),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_pop),
(rtp_jitter_buffer_flush), (rtp_jitter_buffer_num_packets),
(rtp_jitter_buffer_get_ts_diff):
* gst/rtpmanager/rtpjitterbuffer.h:
Remove complicated async queue and replace with more simple jitterbuffer
code while also fixing some bugs.
* gst/rtpmanager/gstrtpbin-marshal.list:
* gst/rtpmanager/gstrtpbin.c: (on_new_ssrc), (on_ssrc_collision),
(on_ssrc_validated), (on_bye_ssrc), (on_bye_timeout), (on_timeout),
(create_session), (gst_rtp_bin_class_init), (create_recv_rtp),
(create_send_rtp):
* gst/rtpmanager/gstrtpbin.h:
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_init), (gst_rtp_jitter_buffer_dispose),
(gst_jitter_buffer_sink_parse_caps),
(gst_rtp_jitter_buffer_flush_start),
(gst_rtp_jitter_buffer_flush_stop),
(gst_rtp_jitter_buffer_change_state),
(gst_rtp_jitter_buffer_sink_event), (gst_rtp_jitter_buffer_chain),
(gst_rtp_jitter_buffer_loop), (gst_rtp_jitter_buffer_set_property):
* gst/rtpmanager/gstrtpsession.c: (on_new_ssrc),
(on_ssrc_collision), (on_ssrc_validated), (on_bye_ssrc),
(on_bye_timeout), (on_timeout), (gst_rtp_session_class_init),
(gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
* gst/rtpmanager/rtpsession.c: (on_bye_ssrc), (session_cleanup):
Use new jitterbuffer code.
Expose some new signals in preparation for handling EOS.
2007-08-10 17:16:53 +00:00
|
|
|
return TRUE;
|
2008-05-26 10:09:29 +00:00
|
|
|
|
|
|
|
/* ERRORS */
|
|
|
|
duplicate:
|
|
|
|
{
|
2016-08-10 17:26:17 +00:00
|
|
|
GST_DEBUG ("duplicate packet %d found", (gint) seqnum);
|
2016-12-01 16:08:09 +00:00
|
|
|
if (G_LIKELY (head))
|
|
|
|
*head = FALSE;
|
2008-05-26 10:09:29 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
gst/rtpmanager/: Remove complicated async queue and replace with more simple jitterbuffer code while also fixing some...
Original commit message from CVS:
* gst/rtpmanager/Makefile.am:
* gst/rtpmanager/async_jitter_queue.c:
* gst/rtpmanager/async_jitter_queue.h:
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_class_init),
(rtp_jitter_buffer_init), (rtp_jitter_buffer_finalize),
(rtp_jitter_buffer_new), (compare_seqnum),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_pop),
(rtp_jitter_buffer_flush), (rtp_jitter_buffer_num_packets),
(rtp_jitter_buffer_get_ts_diff):
* gst/rtpmanager/rtpjitterbuffer.h:
Remove complicated async queue and replace with more simple jitterbuffer
code while also fixing some bugs.
* gst/rtpmanager/gstrtpbin-marshal.list:
* gst/rtpmanager/gstrtpbin.c: (on_new_ssrc), (on_ssrc_collision),
(on_ssrc_validated), (on_bye_ssrc), (on_bye_timeout), (on_timeout),
(create_session), (gst_rtp_bin_class_init), (create_recv_rtp),
(create_send_rtp):
* gst/rtpmanager/gstrtpbin.h:
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_init), (gst_rtp_jitter_buffer_dispose),
(gst_jitter_buffer_sink_parse_caps),
(gst_rtp_jitter_buffer_flush_start),
(gst_rtp_jitter_buffer_flush_stop),
(gst_rtp_jitter_buffer_change_state),
(gst_rtp_jitter_buffer_sink_event), (gst_rtp_jitter_buffer_chain),
(gst_rtp_jitter_buffer_loop), (gst_rtp_jitter_buffer_set_property):
* gst/rtpmanager/gstrtpsession.c: (on_new_ssrc),
(on_ssrc_collision), (on_ssrc_validated), (on_bye_ssrc),
(on_bye_timeout), (on_timeout), (gst_rtp_session_class_init),
(gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
* gst/rtpmanager/rtpsession.c: (on_bye_ssrc), (session_cleanup):
Use new jitterbuffer code.
Expose some new signals in preparation for handling EOS.
2007-08-10 17:16:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* rtp_jitter_buffer_pop:
|
|
|
|
* @jbuf: an #RTPJitterBuffer
|
2009-10-05 17:45:35 +00:00
|
|
|
* @percent: the buffering percent
|
gst/rtpmanager/: Remove complicated async queue and replace with more simple jitterbuffer code while also fixing some...
Original commit message from CVS:
* gst/rtpmanager/Makefile.am:
* gst/rtpmanager/async_jitter_queue.c:
* gst/rtpmanager/async_jitter_queue.h:
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_class_init),
(rtp_jitter_buffer_init), (rtp_jitter_buffer_finalize),
(rtp_jitter_buffer_new), (compare_seqnum),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_pop),
(rtp_jitter_buffer_flush), (rtp_jitter_buffer_num_packets),
(rtp_jitter_buffer_get_ts_diff):
* gst/rtpmanager/rtpjitterbuffer.h:
Remove complicated async queue and replace with more simple jitterbuffer
code while also fixing some bugs.
* gst/rtpmanager/gstrtpbin-marshal.list:
* gst/rtpmanager/gstrtpbin.c: (on_new_ssrc), (on_ssrc_collision),
(on_ssrc_validated), (on_bye_ssrc), (on_bye_timeout), (on_timeout),
(create_session), (gst_rtp_bin_class_init), (create_recv_rtp),
(create_send_rtp):
* gst/rtpmanager/gstrtpbin.h:
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_init), (gst_rtp_jitter_buffer_dispose),
(gst_jitter_buffer_sink_parse_caps),
(gst_rtp_jitter_buffer_flush_start),
(gst_rtp_jitter_buffer_flush_stop),
(gst_rtp_jitter_buffer_change_state),
(gst_rtp_jitter_buffer_sink_event), (gst_rtp_jitter_buffer_chain),
(gst_rtp_jitter_buffer_loop), (gst_rtp_jitter_buffer_set_property):
* gst/rtpmanager/gstrtpsession.c: (on_new_ssrc),
(on_ssrc_collision), (on_ssrc_validated), (on_bye_ssrc),
(on_bye_timeout), (on_timeout), (gst_rtp_session_class_init),
(gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
* gst/rtpmanager/rtpsession.c: (on_bye_ssrc), (session_cleanup):
Use new jitterbuffer code.
Expose some new signals in preparation for handling EOS.
2007-08-10 17:16:53 +00:00
|
|
|
*
|
2007-09-28 11:17:35 +00:00
|
|
|
* Pops the oldest buffer from the packet queue of @jbuf. The popped buffer will
|
|
|
|
* have its timestamp adjusted with the incomming running_time and the detected
|
|
|
|
* clock skew.
|
gst/rtpmanager/: Remove complicated async queue and replace with more simple jitterbuffer code while also fixing some...
Original commit message from CVS:
* gst/rtpmanager/Makefile.am:
* gst/rtpmanager/async_jitter_queue.c:
* gst/rtpmanager/async_jitter_queue.h:
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_class_init),
(rtp_jitter_buffer_init), (rtp_jitter_buffer_finalize),
(rtp_jitter_buffer_new), (compare_seqnum),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_pop),
(rtp_jitter_buffer_flush), (rtp_jitter_buffer_num_packets),
(rtp_jitter_buffer_get_ts_diff):
* gst/rtpmanager/rtpjitterbuffer.h:
Remove complicated async queue and replace with more simple jitterbuffer
code while also fixing some bugs.
* gst/rtpmanager/gstrtpbin-marshal.list:
* gst/rtpmanager/gstrtpbin.c: (on_new_ssrc), (on_ssrc_collision),
(on_ssrc_validated), (on_bye_ssrc), (on_bye_timeout), (on_timeout),
(create_session), (gst_rtp_bin_class_init), (create_recv_rtp),
(create_send_rtp):
* gst/rtpmanager/gstrtpbin.h:
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_init), (gst_rtp_jitter_buffer_dispose),
(gst_jitter_buffer_sink_parse_caps),
(gst_rtp_jitter_buffer_flush_start),
(gst_rtp_jitter_buffer_flush_stop),
(gst_rtp_jitter_buffer_change_state),
(gst_rtp_jitter_buffer_sink_event), (gst_rtp_jitter_buffer_chain),
(gst_rtp_jitter_buffer_loop), (gst_rtp_jitter_buffer_set_property):
* gst/rtpmanager/gstrtpsession.c: (on_new_ssrc),
(on_ssrc_collision), (on_ssrc_validated), (on_bye_ssrc),
(on_bye_timeout), (on_timeout), (gst_rtp_session_class_init),
(gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
* gst/rtpmanager/rtpsession.c: (on_bye_ssrc), (session_cleanup):
Use new jitterbuffer code.
Expose some new signals in preparation for handling EOS.
2007-08-10 17:16:53 +00:00
|
|
|
*
|
|
|
|
* Returns: a #GstBuffer or %NULL when there was no packet in the queue.
|
|
|
|
*/
|
2013-09-20 21:48:20 +00:00
|
|
|
RTPJitterBufferItem *
|
2009-10-05 17:45:35 +00:00
|
|
|
rtp_jitter_buffer_pop (RTPJitterBuffer * jbuf, gint * percent)
|
gst/rtpmanager/: Remove complicated async queue and replace with more simple jitterbuffer code while also fixing some...
Original commit message from CVS:
* gst/rtpmanager/Makefile.am:
* gst/rtpmanager/async_jitter_queue.c:
* gst/rtpmanager/async_jitter_queue.h:
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_class_init),
(rtp_jitter_buffer_init), (rtp_jitter_buffer_finalize),
(rtp_jitter_buffer_new), (compare_seqnum),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_pop),
(rtp_jitter_buffer_flush), (rtp_jitter_buffer_num_packets),
(rtp_jitter_buffer_get_ts_diff):
* gst/rtpmanager/rtpjitterbuffer.h:
Remove complicated async queue and replace with more simple jitterbuffer
code while also fixing some bugs.
* gst/rtpmanager/gstrtpbin-marshal.list:
* gst/rtpmanager/gstrtpbin.c: (on_new_ssrc), (on_ssrc_collision),
(on_ssrc_validated), (on_bye_ssrc), (on_bye_timeout), (on_timeout),
(create_session), (gst_rtp_bin_class_init), (create_recv_rtp),
(create_send_rtp):
* gst/rtpmanager/gstrtpbin.h:
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_init), (gst_rtp_jitter_buffer_dispose),
(gst_jitter_buffer_sink_parse_caps),
(gst_rtp_jitter_buffer_flush_start),
(gst_rtp_jitter_buffer_flush_stop),
(gst_rtp_jitter_buffer_change_state),
(gst_rtp_jitter_buffer_sink_event), (gst_rtp_jitter_buffer_chain),
(gst_rtp_jitter_buffer_loop), (gst_rtp_jitter_buffer_set_property):
* gst/rtpmanager/gstrtpsession.c: (on_new_ssrc),
(on_ssrc_collision), (on_ssrc_validated), (on_bye_ssrc),
(on_bye_timeout), (on_timeout), (gst_rtp_session_class_init),
(gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
* gst/rtpmanager/rtpsession.c: (on_bye_ssrc), (session_cleanup):
Use new jitterbuffer code.
Expose some new signals in preparation for handling EOS.
2007-08-10 17:16:53 +00:00
|
|
|
{
|
2013-09-20 21:48:20 +00:00
|
|
|
GList *item = NULL;
|
|
|
|
GQueue *queue;
|
gst/rtpmanager/: Remove complicated async queue and replace with more simple jitterbuffer code while also fixing some...
Original commit message from CVS:
* gst/rtpmanager/Makefile.am:
* gst/rtpmanager/async_jitter_queue.c:
* gst/rtpmanager/async_jitter_queue.h:
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_class_init),
(rtp_jitter_buffer_init), (rtp_jitter_buffer_finalize),
(rtp_jitter_buffer_new), (compare_seqnum),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_pop),
(rtp_jitter_buffer_flush), (rtp_jitter_buffer_num_packets),
(rtp_jitter_buffer_get_ts_diff):
* gst/rtpmanager/rtpjitterbuffer.h:
Remove complicated async queue and replace with more simple jitterbuffer
code while also fixing some bugs.
* gst/rtpmanager/gstrtpbin-marshal.list:
* gst/rtpmanager/gstrtpbin.c: (on_new_ssrc), (on_ssrc_collision),
(on_ssrc_validated), (on_bye_ssrc), (on_bye_timeout), (on_timeout),
(create_session), (gst_rtp_bin_class_init), (create_recv_rtp),
(create_send_rtp):
* gst/rtpmanager/gstrtpbin.h:
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_init), (gst_rtp_jitter_buffer_dispose),
(gst_jitter_buffer_sink_parse_caps),
(gst_rtp_jitter_buffer_flush_start),
(gst_rtp_jitter_buffer_flush_stop),
(gst_rtp_jitter_buffer_change_state),
(gst_rtp_jitter_buffer_sink_event), (gst_rtp_jitter_buffer_chain),
(gst_rtp_jitter_buffer_loop), (gst_rtp_jitter_buffer_set_property):
* gst/rtpmanager/gstrtpsession.c: (on_new_ssrc),
(on_ssrc_collision), (on_ssrc_validated), (on_bye_ssrc),
(on_bye_timeout), (on_timeout), (gst_rtp_session_class_init),
(gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
* gst/rtpmanager/rtpsession.c: (on_bye_ssrc), (session_cleanup):
Use new jitterbuffer code.
Expose some new signals in preparation for handling EOS.
2007-08-10 17:16:53 +00:00
|
|
|
|
2011-06-24 09:54:29 +00:00
|
|
|
g_return_val_if_fail (jbuf != NULL, NULL);
|
gst/rtpmanager/: Remove complicated async queue and replace with more simple jitterbuffer code while also fixing some...
Original commit message from CVS:
* gst/rtpmanager/Makefile.am:
* gst/rtpmanager/async_jitter_queue.c:
* gst/rtpmanager/async_jitter_queue.h:
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_class_init),
(rtp_jitter_buffer_init), (rtp_jitter_buffer_finalize),
(rtp_jitter_buffer_new), (compare_seqnum),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_pop),
(rtp_jitter_buffer_flush), (rtp_jitter_buffer_num_packets),
(rtp_jitter_buffer_get_ts_diff):
* gst/rtpmanager/rtpjitterbuffer.h:
Remove complicated async queue and replace with more simple jitterbuffer
code while also fixing some bugs.
* gst/rtpmanager/gstrtpbin-marshal.list:
* gst/rtpmanager/gstrtpbin.c: (on_new_ssrc), (on_ssrc_collision),
(on_ssrc_validated), (on_bye_ssrc), (on_bye_timeout), (on_timeout),
(create_session), (gst_rtp_bin_class_init), (create_recv_rtp),
(create_send_rtp):
* gst/rtpmanager/gstrtpbin.h:
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_init), (gst_rtp_jitter_buffer_dispose),
(gst_jitter_buffer_sink_parse_caps),
(gst_rtp_jitter_buffer_flush_start),
(gst_rtp_jitter_buffer_flush_stop),
(gst_rtp_jitter_buffer_change_state),
(gst_rtp_jitter_buffer_sink_event), (gst_rtp_jitter_buffer_chain),
(gst_rtp_jitter_buffer_loop), (gst_rtp_jitter_buffer_set_property):
* gst/rtpmanager/gstrtpsession.c: (on_new_ssrc),
(on_ssrc_collision), (on_ssrc_validated), (on_bye_ssrc),
(on_bye_timeout), (on_timeout), (gst_rtp_session_class_init),
(gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
* gst/rtpmanager/rtpsession.c: (on_bye_ssrc), (session_cleanup):
Use new jitterbuffer code.
Expose some new signals in preparation for handling EOS.
2007-08-10 17:16:53 +00:00
|
|
|
|
2013-09-20 21:48:20 +00:00
|
|
|
queue = jbuf->packets;
|
|
|
|
|
2013-12-10 10:01:03 +00:00
|
|
|
item = queue->head;
|
2013-09-20 21:48:20 +00:00
|
|
|
if (item) {
|
2013-12-10 10:01:03 +00:00
|
|
|
queue->head = item->next;
|
|
|
|
if (queue->head)
|
|
|
|
queue->head->prev = NULL;
|
2013-09-20 21:48:20 +00:00
|
|
|
else
|
2013-12-10 10:01:03 +00:00
|
|
|
queue->tail = NULL;
|
2013-09-20 21:48:20 +00:00
|
|
|
queue->length--;
|
|
|
|
}
|
gst/rtpmanager/: Remove complicated async queue and replace with more simple jitterbuffer code while also fixing some...
Original commit message from CVS:
* gst/rtpmanager/Makefile.am:
* gst/rtpmanager/async_jitter_queue.c:
* gst/rtpmanager/async_jitter_queue.h:
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_class_init),
(rtp_jitter_buffer_init), (rtp_jitter_buffer_finalize),
(rtp_jitter_buffer_new), (compare_seqnum),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_pop),
(rtp_jitter_buffer_flush), (rtp_jitter_buffer_num_packets),
(rtp_jitter_buffer_get_ts_diff):
* gst/rtpmanager/rtpjitterbuffer.h:
Remove complicated async queue and replace with more simple jitterbuffer
code while also fixing some bugs.
* gst/rtpmanager/gstrtpbin-marshal.list:
* gst/rtpmanager/gstrtpbin.c: (on_new_ssrc), (on_ssrc_collision),
(on_ssrc_validated), (on_bye_ssrc), (on_bye_timeout), (on_timeout),
(create_session), (gst_rtp_bin_class_init), (create_recv_rtp),
(create_send_rtp):
* gst/rtpmanager/gstrtpbin.h:
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_init), (gst_rtp_jitter_buffer_dispose),
(gst_jitter_buffer_sink_parse_caps),
(gst_rtp_jitter_buffer_flush_start),
(gst_rtp_jitter_buffer_flush_stop),
(gst_rtp_jitter_buffer_change_state),
(gst_rtp_jitter_buffer_sink_event), (gst_rtp_jitter_buffer_chain),
(gst_rtp_jitter_buffer_loop), (gst_rtp_jitter_buffer_set_property):
* gst/rtpmanager/gstrtpsession.c: (on_new_ssrc),
(on_ssrc_collision), (on_ssrc_validated), (on_bye_ssrc),
(on_bye_timeout), (on_timeout), (gst_rtp_session_class_init),
(gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
* gst/rtpmanager/rtpsession.c: (on_bye_ssrc), (session_cleanup):
Use new jitterbuffer code.
Expose some new signals in preparation for handling EOS.
2007-08-10 17:16:53 +00:00
|
|
|
|
2009-10-01 15:14:09 +00:00
|
|
|
/* buffering mode, update buffer stats */
|
|
|
|
if (jbuf->mode == RTP_JITTER_BUFFER_MODE_BUFFER)
|
2009-10-05 17:45:35 +00:00
|
|
|
update_buffer_level (jbuf, percent);
|
2013-07-30 16:52:58 +00:00
|
|
|
else if (percent)
|
2009-10-05 17:45:35 +00:00
|
|
|
*percent = -1;
|
2009-10-01 15:14:09 +00:00
|
|
|
|
2013-09-20 21:48:20 +00:00
|
|
|
return (RTPJitterBufferItem *) item;
|
gst/rtpmanager/: Remove complicated async queue and replace with more simple jitterbuffer code while also fixing some...
Original commit message from CVS:
* gst/rtpmanager/Makefile.am:
* gst/rtpmanager/async_jitter_queue.c:
* gst/rtpmanager/async_jitter_queue.h:
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_class_init),
(rtp_jitter_buffer_init), (rtp_jitter_buffer_finalize),
(rtp_jitter_buffer_new), (compare_seqnum),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_pop),
(rtp_jitter_buffer_flush), (rtp_jitter_buffer_num_packets),
(rtp_jitter_buffer_get_ts_diff):
* gst/rtpmanager/rtpjitterbuffer.h:
Remove complicated async queue and replace with more simple jitterbuffer
code while also fixing some bugs.
* gst/rtpmanager/gstrtpbin-marshal.list:
* gst/rtpmanager/gstrtpbin.c: (on_new_ssrc), (on_ssrc_collision),
(on_ssrc_validated), (on_bye_ssrc), (on_bye_timeout), (on_timeout),
(create_session), (gst_rtp_bin_class_init), (create_recv_rtp),
(create_send_rtp):
* gst/rtpmanager/gstrtpbin.h:
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_init), (gst_rtp_jitter_buffer_dispose),
(gst_jitter_buffer_sink_parse_caps),
(gst_rtp_jitter_buffer_flush_start),
(gst_rtp_jitter_buffer_flush_stop),
(gst_rtp_jitter_buffer_change_state),
(gst_rtp_jitter_buffer_sink_event), (gst_rtp_jitter_buffer_chain),
(gst_rtp_jitter_buffer_loop), (gst_rtp_jitter_buffer_set_property):
* gst/rtpmanager/gstrtpsession.c: (on_new_ssrc),
(on_ssrc_collision), (on_ssrc_validated), (on_bye_ssrc),
(on_bye_timeout), (on_timeout), (gst_rtp_session_class_init),
(gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
* gst/rtpmanager/rtpsession.c: (on_bye_ssrc), (session_cleanup):
Use new jitterbuffer code.
Expose some new signals in preparation for handling EOS.
2007-08-10 17:16:53 +00:00
|
|
|
}
|
|
|
|
|
gst/rtpmanager/gstrtpbin.c: Use lock to protect variable.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (gst_rtp_bin_set_property),
(gst_rtp_bin_get_property):
Use lock to protect variable.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_class_init),
(gst_jitter_buffer_sink_parse_caps), (gst_rtp_jitter_buffer_chain),
(convert_rtptime_to_gsttime), (gst_rtp_jitter_buffer_loop):
Reconstruct GST timestamp from RTP timestamps based on measured clock
skew and sync offset.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_init),
(rtp_jitter_buffer_set_tail_changed),
(rtp_jitter_buffer_set_clock_rate),
(rtp_jitter_buffer_get_clock_rate), (calculate_skew),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_peek):
* gst/rtpmanager/rtpjitterbuffer.h:
Measure clock skew.
Add callback to be notfied when a new packet was inserted at the tail.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(calculate_jitter), (rtp_source_send_rtp):
* gst/rtpmanager/rtpsource.h:
Remove clock skew detection, it's move to the jitterbuffer now.
2007-09-16 19:40:31 +00:00
|
|
|
/**
|
|
|
|
* rtp_jitter_buffer_peek:
|
|
|
|
* @jbuf: an #RTPJitterBuffer
|
|
|
|
*
|
2014-04-29 13:29:31 +00:00
|
|
|
* Peek the oldest buffer from the packet queue of @jbuf.
|
|
|
|
*
|
|
|
|
* See rtp_jitter_buffer_insert() to check when an older packet was
|
|
|
|
* added.
|
gst/rtpmanager/gstrtpbin.c: Use lock to protect variable.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (gst_rtp_bin_set_property),
(gst_rtp_bin_get_property):
Use lock to protect variable.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_class_init),
(gst_jitter_buffer_sink_parse_caps), (gst_rtp_jitter_buffer_chain),
(convert_rtptime_to_gsttime), (gst_rtp_jitter_buffer_loop):
Reconstruct GST timestamp from RTP timestamps based on measured clock
skew and sync offset.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_init),
(rtp_jitter_buffer_set_tail_changed),
(rtp_jitter_buffer_set_clock_rate),
(rtp_jitter_buffer_get_clock_rate), (calculate_skew),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_peek):
* gst/rtpmanager/rtpjitterbuffer.h:
Measure clock skew.
Add callback to be notfied when a new packet was inserted at the tail.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(calculate_jitter), (rtp_source_send_rtp):
* gst/rtpmanager/rtpsource.h:
Remove clock skew detection, it's move to the jitterbuffer now.
2007-09-16 19:40:31 +00:00
|
|
|
*
|
|
|
|
* Returns: a #GstBuffer or %NULL when there was no packet in the queue.
|
|
|
|
*/
|
2013-09-20 21:48:20 +00:00
|
|
|
RTPJitterBufferItem *
|
gst/rtpmanager/gstrtpbin.c: Use lock to protect variable.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (gst_rtp_bin_set_property),
(gst_rtp_bin_get_property):
Use lock to protect variable.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_class_init),
(gst_jitter_buffer_sink_parse_caps), (gst_rtp_jitter_buffer_chain),
(convert_rtptime_to_gsttime), (gst_rtp_jitter_buffer_loop):
Reconstruct GST timestamp from RTP timestamps based on measured clock
skew and sync offset.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_init),
(rtp_jitter_buffer_set_tail_changed),
(rtp_jitter_buffer_set_clock_rate),
(rtp_jitter_buffer_get_clock_rate), (calculate_skew),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_peek):
* gst/rtpmanager/rtpjitterbuffer.h:
Measure clock skew.
Add callback to be notfied when a new packet was inserted at the tail.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(calculate_jitter), (rtp_source_send_rtp):
* gst/rtpmanager/rtpsource.h:
Remove clock skew detection, it's move to the jitterbuffer now.
2007-09-16 19:40:31 +00:00
|
|
|
rtp_jitter_buffer_peek (RTPJitterBuffer * jbuf)
|
|
|
|
{
|
2011-06-24 09:54:29 +00:00
|
|
|
g_return_val_if_fail (jbuf != NULL, NULL);
|
gst/rtpmanager/gstrtpbin.c: Use lock to protect variable.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (gst_rtp_bin_set_property),
(gst_rtp_bin_get_property):
Use lock to protect variable.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_class_init),
(gst_jitter_buffer_sink_parse_caps), (gst_rtp_jitter_buffer_chain),
(convert_rtptime_to_gsttime), (gst_rtp_jitter_buffer_loop):
Reconstruct GST timestamp from RTP timestamps based on measured clock
skew and sync offset.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_init),
(rtp_jitter_buffer_set_tail_changed),
(rtp_jitter_buffer_set_clock_rate),
(rtp_jitter_buffer_get_clock_rate), (calculate_skew),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_peek):
* gst/rtpmanager/rtpjitterbuffer.h:
Measure clock skew.
Add callback to be notfied when a new packet was inserted at the tail.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(calculate_jitter), (rtp_source_send_rtp):
* gst/rtpmanager/rtpsource.h:
Remove clock skew detection, it's move to the jitterbuffer now.
2007-09-16 19:40:31 +00:00
|
|
|
|
2013-12-10 10:01:03 +00:00
|
|
|
return (RTPJitterBufferItem *) jbuf->packets->head;
|
gst/rtpmanager/gstrtpbin.c: Use lock to protect variable.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (gst_rtp_bin_set_property),
(gst_rtp_bin_get_property):
Use lock to protect variable.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_class_init),
(gst_jitter_buffer_sink_parse_caps), (gst_rtp_jitter_buffer_chain),
(convert_rtptime_to_gsttime), (gst_rtp_jitter_buffer_loop):
Reconstruct GST timestamp from RTP timestamps based on measured clock
skew and sync offset.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_init),
(rtp_jitter_buffer_set_tail_changed),
(rtp_jitter_buffer_set_clock_rate),
(rtp_jitter_buffer_get_clock_rate), (calculate_skew),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_peek):
* gst/rtpmanager/rtpjitterbuffer.h:
Measure clock skew.
Add callback to be notfied when a new packet was inserted at the tail.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(calculate_jitter), (rtp_source_send_rtp):
* gst/rtpmanager/rtpsource.h:
Remove clock skew detection, it's move to the jitterbuffer now.
2007-09-16 19:40:31 +00:00
|
|
|
}
|
|
|
|
|
gst/rtpmanager/: Remove complicated async queue and replace with more simple jitterbuffer code while also fixing some...
Original commit message from CVS:
* gst/rtpmanager/Makefile.am:
* gst/rtpmanager/async_jitter_queue.c:
* gst/rtpmanager/async_jitter_queue.h:
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_class_init),
(rtp_jitter_buffer_init), (rtp_jitter_buffer_finalize),
(rtp_jitter_buffer_new), (compare_seqnum),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_pop),
(rtp_jitter_buffer_flush), (rtp_jitter_buffer_num_packets),
(rtp_jitter_buffer_get_ts_diff):
* gst/rtpmanager/rtpjitterbuffer.h:
Remove complicated async queue and replace with more simple jitterbuffer
code while also fixing some bugs.
* gst/rtpmanager/gstrtpbin-marshal.list:
* gst/rtpmanager/gstrtpbin.c: (on_new_ssrc), (on_ssrc_collision),
(on_ssrc_validated), (on_bye_ssrc), (on_bye_timeout), (on_timeout),
(create_session), (gst_rtp_bin_class_init), (create_recv_rtp),
(create_send_rtp):
* gst/rtpmanager/gstrtpbin.h:
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_init), (gst_rtp_jitter_buffer_dispose),
(gst_jitter_buffer_sink_parse_caps),
(gst_rtp_jitter_buffer_flush_start),
(gst_rtp_jitter_buffer_flush_stop),
(gst_rtp_jitter_buffer_change_state),
(gst_rtp_jitter_buffer_sink_event), (gst_rtp_jitter_buffer_chain),
(gst_rtp_jitter_buffer_loop), (gst_rtp_jitter_buffer_set_property):
* gst/rtpmanager/gstrtpsession.c: (on_new_ssrc),
(on_ssrc_collision), (on_ssrc_validated), (on_bye_ssrc),
(on_bye_timeout), (on_timeout), (gst_rtp_session_class_init),
(gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
* gst/rtpmanager/rtpsession.c: (on_bye_ssrc), (session_cleanup):
Use new jitterbuffer code.
Expose some new signals in preparation for handling EOS.
2007-08-10 17:16:53 +00:00
|
|
|
/**
|
|
|
|
* rtp_jitter_buffer_flush:
|
|
|
|
* @jbuf: an #RTPJitterBuffer
|
2013-09-23 07:58:32 +00:00
|
|
|
* @free_func: function to free each item
|
|
|
|
* @user_data: user data passed to @free_func
|
gst/rtpmanager/: Remove complicated async queue and replace with more simple jitterbuffer code while also fixing some...
Original commit message from CVS:
* gst/rtpmanager/Makefile.am:
* gst/rtpmanager/async_jitter_queue.c:
* gst/rtpmanager/async_jitter_queue.h:
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_class_init),
(rtp_jitter_buffer_init), (rtp_jitter_buffer_finalize),
(rtp_jitter_buffer_new), (compare_seqnum),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_pop),
(rtp_jitter_buffer_flush), (rtp_jitter_buffer_num_packets),
(rtp_jitter_buffer_get_ts_diff):
* gst/rtpmanager/rtpjitterbuffer.h:
Remove complicated async queue and replace with more simple jitterbuffer
code while also fixing some bugs.
* gst/rtpmanager/gstrtpbin-marshal.list:
* gst/rtpmanager/gstrtpbin.c: (on_new_ssrc), (on_ssrc_collision),
(on_ssrc_validated), (on_bye_ssrc), (on_bye_timeout), (on_timeout),
(create_session), (gst_rtp_bin_class_init), (create_recv_rtp),
(create_send_rtp):
* gst/rtpmanager/gstrtpbin.h:
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_init), (gst_rtp_jitter_buffer_dispose),
(gst_jitter_buffer_sink_parse_caps),
(gst_rtp_jitter_buffer_flush_start),
(gst_rtp_jitter_buffer_flush_stop),
(gst_rtp_jitter_buffer_change_state),
(gst_rtp_jitter_buffer_sink_event), (gst_rtp_jitter_buffer_chain),
(gst_rtp_jitter_buffer_loop), (gst_rtp_jitter_buffer_set_property):
* gst/rtpmanager/gstrtpsession.c: (on_new_ssrc),
(on_ssrc_collision), (on_ssrc_validated), (on_bye_ssrc),
(on_bye_timeout), (on_timeout), (gst_rtp_session_class_init),
(gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
* gst/rtpmanager/rtpsession.c: (on_bye_ssrc), (session_cleanup):
Use new jitterbuffer code.
Expose some new signals in preparation for handling EOS.
2007-08-10 17:16:53 +00:00
|
|
|
*
|
|
|
|
* Flush all packets from the jitterbuffer.
|
|
|
|
*/
|
|
|
|
void
|
2013-09-23 07:58:32 +00:00
|
|
|
rtp_jitter_buffer_flush (RTPJitterBuffer * jbuf, GFunc free_func,
|
|
|
|
gpointer user_data)
|
gst/rtpmanager/: Remove complicated async queue and replace with more simple jitterbuffer code while also fixing some...
Original commit message from CVS:
* gst/rtpmanager/Makefile.am:
* gst/rtpmanager/async_jitter_queue.c:
* gst/rtpmanager/async_jitter_queue.h:
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_class_init),
(rtp_jitter_buffer_init), (rtp_jitter_buffer_finalize),
(rtp_jitter_buffer_new), (compare_seqnum),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_pop),
(rtp_jitter_buffer_flush), (rtp_jitter_buffer_num_packets),
(rtp_jitter_buffer_get_ts_diff):
* gst/rtpmanager/rtpjitterbuffer.h:
Remove complicated async queue and replace with more simple jitterbuffer
code while also fixing some bugs.
* gst/rtpmanager/gstrtpbin-marshal.list:
* gst/rtpmanager/gstrtpbin.c: (on_new_ssrc), (on_ssrc_collision),
(on_ssrc_validated), (on_bye_ssrc), (on_bye_timeout), (on_timeout),
(create_session), (gst_rtp_bin_class_init), (create_recv_rtp),
(create_send_rtp):
* gst/rtpmanager/gstrtpbin.h:
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_init), (gst_rtp_jitter_buffer_dispose),
(gst_jitter_buffer_sink_parse_caps),
(gst_rtp_jitter_buffer_flush_start),
(gst_rtp_jitter_buffer_flush_stop),
(gst_rtp_jitter_buffer_change_state),
(gst_rtp_jitter_buffer_sink_event), (gst_rtp_jitter_buffer_chain),
(gst_rtp_jitter_buffer_loop), (gst_rtp_jitter_buffer_set_property):
* gst/rtpmanager/gstrtpsession.c: (on_new_ssrc),
(on_ssrc_collision), (on_ssrc_validated), (on_bye_ssrc),
(on_bye_timeout), (on_timeout), (gst_rtp_session_class_init),
(gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
* gst/rtpmanager/rtpsession.c: (on_bye_ssrc), (session_cleanup):
Use new jitterbuffer code.
Expose some new signals in preparation for handling EOS.
2007-08-10 17:16:53 +00:00
|
|
|
{
|
2013-09-23 07:58:32 +00:00
|
|
|
GList *item;
|
gst/rtpmanager/: Remove complicated async queue and replace with more simple jitterbuffer code while also fixing some...
Original commit message from CVS:
* gst/rtpmanager/Makefile.am:
* gst/rtpmanager/async_jitter_queue.c:
* gst/rtpmanager/async_jitter_queue.h:
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_class_init),
(rtp_jitter_buffer_init), (rtp_jitter_buffer_finalize),
(rtp_jitter_buffer_new), (compare_seqnum),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_pop),
(rtp_jitter_buffer_flush), (rtp_jitter_buffer_num_packets),
(rtp_jitter_buffer_get_ts_diff):
* gst/rtpmanager/rtpjitterbuffer.h:
Remove complicated async queue and replace with more simple jitterbuffer
code while also fixing some bugs.
* gst/rtpmanager/gstrtpbin-marshal.list:
* gst/rtpmanager/gstrtpbin.c: (on_new_ssrc), (on_ssrc_collision),
(on_ssrc_validated), (on_bye_ssrc), (on_bye_timeout), (on_timeout),
(create_session), (gst_rtp_bin_class_init), (create_recv_rtp),
(create_send_rtp):
* gst/rtpmanager/gstrtpbin.h:
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_init), (gst_rtp_jitter_buffer_dispose),
(gst_jitter_buffer_sink_parse_caps),
(gst_rtp_jitter_buffer_flush_start),
(gst_rtp_jitter_buffer_flush_stop),
(gst_rtp_jitter_buffer_change_state),
(gst_rtp_jitter_buffer_sink_event), (gst_rtp_jitter_buffer_chain),
(gst_rtp_jitter_buffer_loop), (gst_rtp_jitter_buffer_set_property):
* gst/rtpmanager/gstrtpsession.c: (on_new_ssrc),
(on_ssrc_collision), (on_ssrc_validated), (on_bye_ssrc),
(on_bye_timeout), (on_timeout), (gst_rtp_session_class_init),
(gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
* gst/rtpmanager/rtpsession.c: (on_bye_ssrc), (session_cleanup):
Use new jitterbuffer code.
Expose some new signals in preparation for handling EOS.
2007-08-10 17:16:53 +00:00
|
|
|
|
|
|
|
g_return_if_fail (jbuf != NULL);
|
2013-09-23 07:58:32 +00:00
|
|
|
g_return_if_fail (free_func != NULL);
|
gst/rtpmanager/: Remove complicated async queue and replace with more simple jitterbuffer code while also fixing some...
Original commit message from CVS:
* gst/rtpmanager/Makefile.am:
* gst/rtpmanager/async_jitter_queue.c:
* gst/rtpmanager/async_jitter_queue.h:
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_class_init),
(rtp_jitter_buffer_init), (rtp_jitter_buffer_finalize),
(rtp_jitter_buffer_new), (compare_seqnum),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_pop),
(rtp_jitter_buffer_flush), (rtp_jitter_buffer_num_packets),
(rtp_jitter_buffer_get_ts_diff):
* gst/rtpmanager/rtpjitterbuffer.h:
Remove complicated async queue and replace with more simple jitterbuffer
code while also fixing some bugs.
* gst/rtpmanager/gstrtpbin-marshal.list:
* gst/rtpmanager/gstrtpbin.c: (on_new_ssrc), (on_ssrc_collision),
(on_ssrc_validated), (on_bye_ssrc), (on_bye_timeout), (on_timeout),
(create_session), (gst_rtp_bin_class_init), (create_recv_rtp),
(create_send_rtp):
* gst/rtpmanager/gstrtpbin.h:
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_init), (gst_rtp_jitter_buffer_dispose),
(gst_jitter_buffer_sink_parse_caps),
(gst_rtp_jitter_buffer_flush_start),
(gst_rtp_jitter_buffer_flush_stop),
(gst_rtp_jitter_buffer_change_state),
(gst_rtp_jitter_buffer_sink_event), (gst_rtp_jitter_buffer_chain),
(gst_rtp_jitter_buffer_loop), (gst_rtp_jitter_buffer_set_property):
* gst/rtpmanager/gstrtpsession.c: (on_new_ssrc),
(on_ssrc_collision), (on_ssrc_validated), (on_bye_ssrc),
(on_bye_timeout), (on_timeout), (gst_rtp_session_class_init),
(gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
* gst/rtpmanager/rtpsession.c: (on_bye_ssrc), (session_cleanup):
Use new jitterbuffer code.
Expose some new signals in preparation for handling EOS.
2007-08-10 17:16:53 +00:00
|
|
|
|
2013-09-23 07:58:32 +00:00
|
|
|
while ((item = g_queue_pop_head_link (jbuf->packets)))
|
|
|
|
free_func ((RTPJitterBufferItem *) item, user_data);
|
gst/rtpmanager/: Remove complicated async queue and replace with more simple jitterbuffer code while also fixing some...
Original commit message from CVS:
* gst/rtpmanager/Makefile.am:
* gst/rtpmanager/async_jitter_queue.c:
* gst/rtpmanager/async_jitter_queue.h:
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_class_init),
(rtp_jitter_buffer_init), (rtp_jitter_buffer_finalize),
(rtp_jitter_buffer_new), (compare_seqnum),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_pop),
(rtp_jitter_buffer_flush), (rtp_jitter_buffer_num_packets),
(rtp_jitter_buffer_get_ts_diff):
* gst/rtpmanager/rtpjitterbuffer.h:
Remove complicated async queue and replace with more simple jitterbuffer
code while also fixing some bugs.
* gst/rtpmanager/gstrtpbin-marshal.list:
* gst/rtpmanager/gstrtpbin.c: (on_new_ssrc), (on_ssrc_collision),
(on_ssrc_validated), (on_bye_ssrc), (on_bye_timeout), (on_timeout),
(create_session), (gst_rtp_bin_class_init), (create_recv_rtp),
(create_send_rtp):
* gst/rtpmanager/gstrtpbin.h:
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_init), (gst_rtp_jitter_buffer_dispose),
(gst_jitter_buffer_sink_parse_caps),
(gst_rtp_jitter_buffer_flush_start),
(gst_rtp_jitter_buffer_flush_stop),
(gst_rtp_jitter_buffer_change_state),
(gst_rtp_jitter_buffer_sink_event), (gst_rtp_jitter_buffer_chain),
(gst_rtp_jitter_buffer_loop), (gst_rtp_jitter_buffer_set_property):
* gst/rtpmanager/gstrtpsession.c: (on_new_ssrc),
(on_ssrc_collision), (on_ssrc_validated), (on_bye_ssrc),
(on_bye_timeout), (on_timeout), (gst_rtp_session_class_init),
(gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
* gst/rtpmanager/rtpsession.c: (on_bye_ssrc), (session_cleanup):
Use new jitterbuffer code.
Expose some new signals in preparation for handling EOS.
2007-08-10 17:16:53 +00:00
|
|
|
}
|
|
|
|
|
2009-10-01 10:46:21 +00:00
|
|
|
/**
|
|
|
|
* 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)
|
|
|
|
{
|
2014-04-18 09:11:14 +00:00
|
|
|
return jbuf->buffering && !jbuf->buffering_disabled;
|
2009-10-01 10:46:21 +00:00
|
|
|
}
|
|
|
|
|
2010-01-27 16:57:55 +00:00
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
|
2010-02-23 16:19:14 +00:00
|
|
|
if (G_UNLIKELY (jbuf->high_level == 0))
|
|
|
|
return 100;
|
|
|
|
|
2014-04-18 09:11:14 +00:00
|
|
|
if (G_UNLIKELY (jbuf->buffering_disabled))
|
|
|
|
return 100;
|
|
|
|
|
2010-01-27 16:57:55 +00:00
|
|
|
level = get_buffer_level (jbuf);
|
|
|
|
percent = (level * 100 / jbuf->high_level);
|
|
|
|
percent = MIN (percent, 100);
|
|
|
|
|
|
|
|
return percent;
|
|
|
|
}
|
|
|
|
|
gst/rtpmanager/: Remove complicated async queue and replace with more simple jitterbuffer code while also fixing some...
Original commit message from CVS:
* gst/rtpmanager/Makefile.am:
* gst/rtpmanager/async_jitter_queue.c:
* gst/rtpmanager/async_jitter_queue.h:
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_class_init),
(rtp_jitter_buffer_init), (rtp_jitter_buffer_finalize),
(rtp_jitter_buffer_new), (compare_seqnum),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_pop),
(rtp_jitter_buffer_flush), (rtp_jitter_buffer_num_packets),
(rtp_jitter_buffer_get_ts_diff):
* gst/rtpmanager/rtpjitterbuffer.h:
Remove complicated async queue and replace with more simple jitterbuffer
code while also fixing some bugs.
* gst/rtpmanager/gstrtpbin-marshal.list:
* gst/rtpmanager/gstrtpbin.c: (on_new_ssrc), (on_ssrc_collision),
(on_ssrc_validated), (on_bye_ssrc), (on_bye_timeout), (on_timeout),
(create_session), (gst_rtp_bin_class_init), (create_recv_rtp),
(create_send_rtp):
* gst/rtpmanager/gstrtpbin.h:
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_init), (gst_rtp_jitter_buffer_dispose),
(gst_jitter_buffer_sink_parse_caps),
(gst_rtp_jitter_buffer_flush_start),
(gst_rtp_jitter_buffer_flush_stop),
(gst_rtp_jitter_buffer_change_state),
(gst_rtp_jitter_buffer_sink_event), (gst_rtp_jitter_buffer_chain),
(gst_rtp_jitter_buffer_loop), (gst_rtp_jitter_buffer_set_property):
* gst/rtpmanager/gstrtpsession.c: (on_new_ssrc),
(on_ssrc_collision), (on_ssrc_validated), (on_bye_ssrc),
(on_bye_timeout), (on_timeout), (gst_rtp_session_class_init),
(gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
* gst/rtpmanager/rtpsession.c: (on_bye_ssrc), (session_cleanup):
Use new jitterbuffer code.
Expose some new signals in preparation for handling EOS.
2007-08-10 17:16:53 +00:00
|
|
|
/**
|
|
|
|
* 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);
|
|
|
|
|
2009-10-01 10:46:21 +00:00
|
|
|
return jbuf->packets->length;
|
gst/rtpmanager/: Remove complicated async queue and replace with more simple jitterbuffer code while also fixing some...
Original commit message from CVS:
* gst/rtpmanager/Makefile.am:
* gst/rtpmanager/async_jitter_queue.c:
* gst/rtpmanager/async_jitter_queue.h:
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_class_init),
(rtp_jitter_buffer_init), (rtp_jitter_buffer_finalize),
(rtp_jitter_buffer_new), (compare_seqnum),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_pop),
(rtp_jitter_buffer_flush), (rtp_jitter_buffer_num_packets),
(rtp_jitter_buffer_get_ts_diff):
* gst/rtpmanager/rtpjitterbuffer.h:
Remove complicated async queue and replace with more simple jitterbuffer
code while also fixing some bugs.
* gst/rtpmanager/gstrtpbin-marshal.list:
* gst/rtpmanager/gstrtpbin.c: (on_new_ssrc), (on_ssrc_collision),
(on_ssrc_validated), (on_bye_ssrc), (on_bye_timeout), (on_timeout),
(create_session), (gst_rtp_bin_class_init), (create_recv_rtp),
(create_send_rtp):
* gst/rtpmanager/gstrtpbin.h:
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_init), (gst_rtp_jitter_buffer_dispose),
(gst_jitter_buffer_sink_parse_caps),
(gst_rtp_jitter_buffer_flush_start),
(gst_rtp_jitter_buffer_flush_stop),
(gst_rtp_jitter_buffer_change_state),
(gst_rtp_jitter_buffer_sink_event), (gst_rtp_jitter_buffer_chain),
(gst_rtp_jitter_buffer_loop), (gst_rtp_jitter_buffer_set_property):
* gst/rtpmanager/gstrtpsession.c: (on_new_ssrc),
(on_ssrc_collision), (on_ssrc_validated), (on_bye_ssrc),
(on_bye_timeout), (on_timeout), (gst_rtp_session_class_init),
(gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
* gst/rtpmanager/rtpsession.c: (on_bye_ssrc), (session_cleanup):
Use new jitterbuffer code.
Expose some new signals in preparation for handling EOS.
2007-08-10 17:16:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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)
|
|
|
|
{
|
2007-08-21 16:04:47 +00:00
|
|
|
guint64 high_ts, low_ts;
|
2013-11-19 09:10:51 +00:00
|
|
|
RTPJitterBufferItem *high_buf, *low_buf;
|
2007-08-21 16:04:47 +00:00
|
|
|
guint32 result;
|
gst/rtpmanager/: Remove complicated async queue and replace with more simple jitterbuffer code while also fixing some...
Original commit message from CVS:
* gst/rtpmanager/Makefile.am:
* gst/rtpmanager/async_jitter_queue.c:
* gst/rtpmanager/async_jitter_queue.h:
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_class_init),
(rtp_jitter_buffer_init), (rtp_jitter_buffer_finalize),
(rtp_jitter_buffer_new), (compare_seqnum),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_pop),
(rtp_jitter_buffer_flush), (rtp_jitter_buffer_num_packets),
(rtp_jitter_buffer_get_ts_diff):
* gst/rtpmanager/rtpjitterbuffer.h:
Remove complicated async queue and replace with more simple jitterbuffer
code while also fixing some bugs.
* gst/rtpmanager/gstrtpbin-marshal.list:
* gst/rtpmanager/gstrtpbin.c: (on_new_ssrc), (on_ssrc_collision),
(on_ssrc_validated), (on_bye_ssrc), (on_bye_timeout), (on_timeout),
(create_session), (gst_rtp_bin_class_init), (create_recv_rtp),
(create_send_rtp):
* gst/rtpmanager/gstrtpbin.h:
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_init), (gst_rtp_jitter_buffer_dispose),
(gst_jitter_buffer_sink_parse_caps),
(gst_rtp_jitter_buffer_flush_start),
(gst_rtp_jitter_buffer_flush_stop),
(gst_rtp_jitter_buffer_change_state),
(gst_rtp_jitter_buffer_sink_event), (gst_rtp_jitter_buffer_chain),
(gst_rtp_jitter_buffer_loop), (gst_rtp_jitter_buffer_set_property):
* gst/rtpmanager/gstrtpsession.c: (on_new_ssrc),
(on_ssrc_collision), (on_ssrc_validated), (on_bye_ssrc),
(on_bye_timeout), (on_timeout), (gst_rtp_session_class_init),
(gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
* gst/rtpmanager/rtpsession.c: (on_bye_ssrc), (session_cleanup):
Use new jitterbuffer code.
Expose some new signals in preparation for handling EOS.
2007-08-10 17:16:53 +00:00
|
|
|
|
|
|
|
g_return_val_if_fail (jbuf != NULL, 0);
|
|
|
|
|
2016-04-12 07:15:39 +00:00
|
|
|
high_buf = (RTPJitterBufferItem *) g_queue_peek_tail_link (jbuf->packets);
|
|
|
|
low_buf = (RTPJitterBufferItem *) g_queue_peek_head_link (jbuf->packets);
|
gst/rtpmanager/: Remove complicated async queue and replace with more simple jitterbuffer code while also fixing some...
Original commit message from CVS:
* gst/rtpmanager/Makefile.am:
* gst/rtpmanager/async_jitter_queue.c:
* gst/rtpmanager/async_jitter_queue.h:
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_class_init),
(rtp_jitter_buffer_init), (rtp_jitter_buffer_finalize),
(rtp_jitter_buffer_new), (compare_seqnum),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_pop),
(rtp_jitter_buffer_flush), (rtp_jitter_buffer_num_packets),
(rtp_jitter_buffer_get_ts_diff):
* gst/rtpmanager/rtpjitterbuffer.h:
Remove complicated async queue and replace with more simple jitterbuffer
code while also fixing some bugs.
* gst/rtpmanager/gstrtpbin-marshal.list:
* gst/rtpmanager/gstrtpbin.c: (on_new_ssrc), (on_ssrc_collision),
(on_ssrc_validated), (on_bye_ssrc), (on_bye_timeout), (on_timeout),
(create_session), (gst_rtp_bin_class_init), (create_recv_rtp),
(create_send_rtp):
* gst/rtpmanager/gstrtpbin.h:
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_init), (gst_rtp_jitter_buffer_dispose),
(gst_jitter_buffer_sink_parse_caps),
(gst_rtp_jitter_buffer_flush_start),
(gst_rtp_jitter_buffer_flush_stop),
(gst_rtp_jitter_buffer_change_state),
(gst_rtp_jitter_buffer_sink_event), (gst_rtp_jitter_buffer_chain),
(gst_rtp_jitter_buffer_loop), (gst_rtp_jitter_buffer_set_property):
* gst/rtpmanager/gstrtpsession.c: (on_new_ssrc),
(on_ssrc_collision), (on_ssrc_validated), (on_bye_ssrc),
(on_bye_timeout), (on_timeout), (gst_rtp_session_class_init),
(gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
* gst/rtpmanager/rtpsession.c: (on_bye_ssrc), (session_cleanup):
Use new jitterbuffer code.
Expose some new signals in preparation for handling EOS.
2007-08-10 17:16:53 +00:00
|
|
|
|
|
|
|
if (!high_buf || !low_buf || high_buf == low_buf)
|
|
|
|
return 0;
|
|
|
|
|
2013-11-19 09:10:51 +00:00
|
|
|
high_ts = high_buf->rtptime;
|
|
|
|
low_ts = low_buf->rtptime;
|
gst/rtpmanager/: Remove complicated async queue and replace with more simple jitterbuffer code while also fixing some...
Original commit message from CVS:
* gst/rtpmanager/Makefile.am:
* gst/rtpmanager/async_jitter_queue.c:
* gst/rtpmanager/async_jitter_queue.h:
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_class_init),
(rtp_jitter_buffer_init), (rtp_jitter_buffer_finalize),
(rtp_jitter_buffer_new), (compare_seqnum),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_pop),
(rtp_jitter_buffer_flush), (rtp_jitter_buffer_num_packets),
(rtp_jitter_buffer_get_ts_diff):
* gst/rtpmanager/rtpjitterbuffer.h:
Remove complicated async queue and replace with more simple jitterbuffer
code while also fixing some bugs.
* gst/rtpmanager/gstrtpbin-marshal.list:
* gst/rtpmanager/gstrtpbin.c: (on_new_ssrc), (on_ssrc_collision),
(on_ssrc_validated), (on_bye_ssrc), (on_bye_timeout), (on_timeout),
(create_session), (gst_rtp_bin_class_init), (create_recv_rtp),
(create_send_rtp):
* gst/rtpmanager/gstrtpbin.h:
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_init), (gst_rtp_jitter_buffer_dispose),
(gst_jitter_buffer_sink_parse_caps),
(gst_rtp_jitter_buffer_flush_start),
(gst_rtp_jitter_buffer_flush_stop),
(gst_rtp_jitter_buffer_change_state),
(gst_rtp_jitter_buffer_sink_event), (gst_rtp_jitter_buffer_chain),
(gst_rtp_jitter_buffer_loop), (gst_rtp_jitter_buffer_set_property):
* gst/rtpmanager/gstrtpsession.c: (on_new_ssrc),
(on_ssrc_collision), (on_ssrc_validated), (on_bye_ssrc),
(on_bye_timeout), (on_timeout), (gst_rtp_session_class_init),
(gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
* gst/rtpmanager/rtpsession.c: (on_bye_ssrc), (session_cleanup):
Use new jitterbuffer code.
Expose some new signals in preparation for handling EOS.
2007-08-10 17:16:53 +00:00
|
|
|
|
|
|
|
/* it needs to work if ts wraps */
|
|
|
|
if (high_ts >= low_ts) {
|
2007-08-21 16:04:47 +00:00
|
|
|
result = (guint32) (high_ts - low_ts);
|
gst/rtpmanager/: Remove complicated async queue and replace with more simple jitterbuffer code while also fixing some...
Original commit message from CVS:
* gst/rtpmanager/Makefile.am:
* gst/rtpmanager/async_jitter_queue.c:
* gst/rtpmanager/async_jitter_queue.h:
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_class_init),
(rtp_jitter_buffer_init), (rtp_jitter_buffer_finalize),
(rtp_jitter_buffer_new), (compare_seqnum),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_pop),
(rtp_jitter_buffer_flush), (rtp_jitter_buffer_num_packets),
(rtp_jitter_buffer_get_ts_diff):
* gst/rtpmanager/rtpjitterbuffer.h:
Remove complicated async queue and replace with more simple jitterbuffer
code while also fixing some bugs.
* gst/rtpmanager/gstrtpbin-marshal.list:
* gst/rtpmanager/gstrtpbin.c: (on_new_ssrc), (on_ssrc_collision),
(on_ssrc_validated), (on_bye_ssrc), (on_bye_timeout), (on_timeout),
(create_session), (gst_rtp_bin_class_init), (create_recv_rtp),
(create_send_rtp):
* gst/rtpmanager/gstrtpbin.h:
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_init), (gst_rtp_jitter_buffer_dispose),
(gst_jitter_buffer_sink_parse_caps),
(gst_rtp_jitter_buffer_flush_start),
(gst_rtp_jitter_buffer_flush_stop),
(gst_rtp_jitter_buffer_change_state),
(gst_rtp_jitter_buffer_sink_event), (gst_rtp_jitter_buffer_chain),
(gst_rtp_jitter_buffer_loop), (gst_rtp_jitter_buffer_set_property):
* gst/rtpmanager/gstrtpsession.c: (on_new_ssrc),
(on_ssrc_collision), (on_ssrc_validated), (on_bye_ssrc),
(on_bye_timeout), (on_timeout), (gst_rtp_session_class_init),
(gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
* gst/rtpmanager/rtpsession.c: (on_bye_ssrc), (session_cleanup):
Use new jitterbuffer code.
Expose some new signals in preparation for handling EOS.
2007-08-10 17:16:53 +00:00
|
|
|
} else {
|
2007-08-21 16:04:47 +00:00
|
|
|
result = (guint32) (high_ts + G_MAXUINT32 + 1 - low_ts);
|
gst/rtpmanager/: Remove complicated async queue and replace with more simple jitterbuffer code while also fixing some...
Original commit message from CVS:
* gst/rtpmanager/Makefile.am:
* gst/rtpmanager/async_jitter_queue.c:
* gst/rtpmanager/async_jitter_queue.h:
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_class_init),
(rtp_jitter_buffer_init), (rtp_jitter_buffer_finalize),
(rtp_jitter_buffer_new), (compare_seqnum),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_pop),
(rtp_jitter_buffer_flush), (rtp_jitter_buffer_num_packets),
(rtp_jitter_buffer_get_ts_diff):
* gst/rtpmanager/rtpjitterbuffer.h:
Remove complicated async queue and replace with more simple jitterbuffer
code while also fixing some bugs.
* gst/rtpmanager/gstrtpbin-marshal.list:
* gst/rtpmanager/gstrtpbin.c: (on_new_ssrc), (on_ssrc_collision),
(on_ssrc_validated), (on_bye_ssrc), (on_bye_timeout), (on_timeout),
(create_session), (gst_rtp_bin_class_init), (create_recv_rtp),
(create_send_rtp):
* gst/rtpmanager/gstrtpbin.h:
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_init), (gst_rtp_jitter_buffer_dispose),
(gst_jitter_buffer_sink_parse_caps),
(gst_rtp_jitter_buffer_flush_start),
(gst_rtp_jitter_buffer_flush_stop),
(gst_rtp_jitter_buffer_change_state),
(gst_rtp_jitter_buffer_sink_event), (gst_rtp_jitter_buffer_chain),
(gst_rtp_jitter_buffer_loop), (gst_rtp_jitter_buffer_set_property):
* gst/rtpmanager/gstrtpsession.c: (on_new_ssrc),
(on_ssrc_collision), (on_ssrc_validated), (on_bye_ssrc),
(on_bye_timeout), (on_timeout), (gst_rtp_session_class_init),
(gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
* gst/rtpmanager/rtpsession.c: (on_bye_ssrc), (session_cleanup):
Use new jitterbuffer code.
Expose some new signals in preparation for handling EOS.
2007-08-10 17:16:53 +00:00
|
|
|
}
|
2007-08-21 16:04:47 +00:00
|
|
|
return result;
|
gst/rtpmanager/: Remove complicated async queue and replace with more simple jitterbuffer code while also fixing some...
Original commit message from CVS:
* gst/rtpmanager/Makefile.am:
* gst/rtpmanager/async_jitter_queue.c:
* gst/rtpmanager/async_jitter_queue.h:
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_class_init),
(rtp_jitter_buffer_init), (rtp_jitter_buffer_finalize),
(rtp_jitter_buffer_new), (compare_seqnum),
(rtp_jitter_buffer_insert), (rtp_jitter_buffer_pop),
(rtp_jitter_buffer_flush), (rtp_jitter_buffer_num_packets),
(rtp_jitter_buffer_get_ts_diff):
* gst/rtpmanager/rtpjitterbuffer.h:
Remove complicated async queue and replace with more simple jitterbuffer
code while also fixing some bugs.
* gst/rtpmanager/gstrtpbin-marshal.list:
* gst/rtpmanager/gstrtpbin.c: (on_new_ssrc), (on_ssrc_collision),
(on_ssrc_validated), (on_bye_ssrc), (on_bye_timeout), (on_timeout),
(create_session), (gst_rtp_bin_class_init), (create_recv_rtp),
(create_send_rtp):
* gst/rtpmanager/gstrtpbin.h:
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_init), (gst_rtp_jitter_buffer_dispose),
(gst_jitter_buffer_sink_parse_caps),
(gst_rtp_jitter_buffer_flush_start),
(gst_rtp_jitter_buffer_flush_stop),
(gst_rtp_jitter_buffer_change_state),
(gst_rtp_jitter_buffer_sink_event), (gst_rtp_jitter_buffer_chain),
(gst_rtp_jitter_buffer_loop), (gst_rtp_jitter_buffer_set_property):
* gst/rtpmanager/gstrtpsession.c: (on_new_ssrc),
(on_ssrc_collision), (on_ssrc_validated), (on_bye_ssrc),
(on_bye_timeout), (on_timeout), (gst_rtp_session_class_init),
(gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
* gst/rtpmanager/rtpsession.c: (on_bye_ssrc), (session_cleanup):
Use new jitterbuffer code.
Expose some new signals in preparation for handling EOS.
2007-08-10 17:16:53 +00:00
|
|
|
}
|
gst/rtpmanager/gstrtpbin.*: Add signal to notify listeners when a sender becomes a receiver.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (on_sender_timeout),
(create_session), (gst_rtp_bin_associate),
(gst_rtp_bin_sync_chain), (gst_rtp_bin_class_init),
(gst_rtp_bin_request_new_pad):
* gst/rtpmanager/gstrtpbin.h:
Add signal to notify listeners when a sender becomes a receiver.
Tweak lip-sync code, don't store our own copy of the ts-offset of the
jitterbuffer, don't adjust sync if the change is less than 4msec.
Get the RTP timestamp <-> GStreamer timestamp relation directly from
the jitterbuffer instead of our inaccurate version from the source.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_chain), (gst_rtp_jitter_buffer_loop),
(gst_rtp_jitter_buffer_get_sync):
* gst/rtpmanager/gstrtpjitterbuffer.h:
Add G_LIKELY macros, use global defines for max packet reorder and
dropouts.
Reset the jitterbuffer clock skew detection when packets seqnums are
changed unexpectedly.
* gst/rtpmanager/gstrtpsession.c: (on_sender_timeout),
(gst_rtp_session_class_init), (gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
Add sender timeout signal.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_reset_skew),
(calculate_skew), (rtp_jitter_buffer_insert),
(rtp_jitter_buffer_get_sync):
* gst/rtpmanager/rtpjitterbuffer.h:
Add some G_LIKELY macros.
Keep track of the extended RTP timestamp so that we can report the RTP
timestamp <-> GStreamer timestamp relation for lip-sync.
Remove server timestamp gap detection code, the server can sometimes
make a huge gap in timestamps (talk spurts,...) see #549774.
Detect timetamp weirdness instead by observing the sender/receiver
timestamp relation and resync if it changes more than 1 second.
Add method to report about the current rtp <-> gst timestamp relation
which is needed for lip-sync.
* gst/rtpmanager/rtpsession.c: (rtp_session_class_init),
(on_sender_timeout), (check_collision), (rtp_session_process_sr),
(session_cleanup):
* gst/rtpmanager/rtpsession.h:
Add sender timeout signal.
Remove inaccurate rtp <-> gst timestamp relation code, the
jitterbuffer can now do an accurate reporting about this.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(rtp_source_update_caps), (calculate_jitter),
(rtp_source_process_rtp):
* gst/rtpmanager/rtpsource.h:
Remove inaccurate rtp <-> gst timestamp relation code.
* gst/rtpmanager/rtpstats.h:
Define global max-reorder and max-dropout constants for use in various
subsystems.
2008-09-05 13:52:34 +00:00
|
|
|
|
2019-01-11 22:53:43 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
gst/rtpmanager/gstrtpbin.*: Add signal to notify listeners when a sender becomes a receiver.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (on_sender_timeout),
(create_session), (gst_rtp_bin_associate),
(gst_rtp_bin_sync_chain), (gst_rtp_bin_class_init),
(gst_rtp_bin_request_new_pad):
* gst/rtpmanager/gstrtpbin.h:
Add signal to notify listeners when a sender becomes a receiver.
Tweak lip-sync code, don't store our own copy of the ts-offset of the
jitterbuffer, don't adjust sync if the change is less than 4msec.
Get the RTP timestamp <-> GStreamer timestamp relation directly from
the jitterbuffer instead of our inaccurate version from the source.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_chain), (gst_rtp_jitter_buffer_loop),
(gst_rtp_jitter_buffer_get_sync):
* gst/rtpmanager/gstrtpjitterbuffer.h:
Add G_LIKELY macros, use global defines for max packet reorder and
dropouts.
Reset the jitterbuffer clock skew detection when packets seqnums are
changed unexpectedly.
* gst/rtpmanager/gstrtpsession.c: (on_sender_timeout),
(gst_rtp_session_class_init), (gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
Add sender timeout signal.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_reset_skew),
(calculate_skew), (rtp_jitter_buffer_insert),
(rtp_jitter_buffer_get_sync):
* gst/rtpmanager/rtpjitterbuffer.h:
Add some G_LIKELY macros.
Keep track of the extended RTP timestamp so that we can report the RTP
timestamp <-> GStreamer timestamp relation for lip-sync.
Remove server timestamp gap detection code, the server can sometimes
make a huge gap in timestamps (talk spurts,...) see #549774.
Detect timetamp weirdness instead by observing the sender/receiver
timestamp relation and resync if it changes more than 1 second.
Add method to report about the current rtp <-> gst timestamp relation
which is needed for lip-sync.
* gst/rtpmanager/rtpsession.c: (rtp_session_class_init),
(on_sender_timeout), (check_collision), (rtp_session_process_sr),
(session_cleanup):
* gst/rtpmanager/rtpsession.h:
Add sender timeout signal.
Remove inaccurate rtp <-> gst timestamp relation code, the
jitterbuffer can now do an accurate reporting about this.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(rtp_source_update_caps), (calculate_jitter),
(rtp_source_process_rtp):
* gst/rtpmanager/rtpsource.h:
Remove inaccurate rtp <-> gst timestamp relation code.
* gst/rtpmanager/rtpstats.h:
Define global max-reorder and max-dropout constants for use in various
subsystems.
2008-09-05 13:52:34 +00:00
|
|
|
/**
|
|
|
|
* rtp_jitter_buffer_get_sync:
|
|
|
|
* @jbuf: an #RTPJitterBuffer
|
|
|
|
* @rtptime: result RTP time
|
|
|
|
* @timestamp: result GStreamer timestamp
|
2008-11-17 15:17:52 +00:00
|
|
|
* @clock_rate: clock-rate of @rtptime
|
gst/rtpmanager/gstrtpbin.c: Remove internal sync pad, use signals instead to get lip-sync notifications.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (gst_rtp_bin_associate),
(gst_rtp_bin_handle_sync), (create_stream), (free_stream),
(new_ssrc_pad_found):
Remove internal sync pad, use signals instead to get lip-sync
notifications.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_base_init),
(gst_rtp_jitter_buffer_class_init),
(gst_rtp_jitter_buffer_internal_links), (create_rtcp_sink),
(remove_rtcp_sink), (gst_rtp_jitter_buffer_request_new_pad),
(gst_rtp_jitter_buffer_release_pad),
(gst_rtp_jitter_buffer_sink_rtcp_event),
(gst_rtp_jitter_buffer_chain_rtcp),
(gst_rtp_jitter_buffer_get_property):
* gst/rtpmanager/gstrtpjitterbuffer.h:
Make it possible to send SR packets to the jitterbuffer.
Check if the SR timestamps are valid by comparing them to the RTP
timestamps.
Signal the SR packet and the timing information to listeners.
* gst/rtpmanager/gstrtpssrcdemux.c: (create_demux_pad_for_ssrc),
(gst_rtp_ssrc_demux_rtcp_chain), (gst_rtp_ssrc_demux_src_query):
Remove some unused code.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_reset_skew),
(calculate_skew), (rtp_jitter_buffer_get_sync):
* gst/rtpmanager/rtpjitterbuffer.h:
Keep track of the last seen RTP timestamp so that we can filter out
invalid SR packets.
2008-11-19 09:06:29 +00:00
|
|
|
* @last_rtptime: last seen rtptime.
|
gst/rtpmanager/gstrtpbin.*: Add signal to notify listeners when a sender becomes a receiver.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (on_sender_timeout),
(create_session), (gst_rtp_bin_associate),
(gst_rtp_bin_sync_chain), (gst_rtp_bin_class_init),
(gst_rtp_bin_request_new_pad):
* gst/rtpmanager/gstrtpbin.h:
Add signal to notify listeners when a sender becomes a receiver.
Tweak lip-sync code, don't store our own copy of the ts-offset of the
jitterbuffer, don't adjust sync if the change is less than 4msec.
Get the RTP timestamp <-> GStreamer timestamp relation directly from
the jitterbuffer instead of our inaccurate version from the source.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_chain), (gst_rtp_jitter_buffer_loop),
(gst_rtp_jitter_buffer_get_sync):
* gst/rtpmanager/gstrtpjitterbuffer.h:
Add G_LIKELY macros, use global defines for max packet reorder and
dropouts.
Reset the jitterbuffer clock skew detection when packets seqnums are
changed unexpectedly.
* gst/rtpmanager/gstrtpsession.c: (on_sender_timeout),
(gst_rtp_session_class_init), (gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
Add sender timeout signal.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_reset_skew),
(calculate_skew), (rtp_jitter_buffer_insert),
(rtp_jitter_buffer_get_sync):
* gst/rtpmanager/rtpjitterbuffer.h:
Add some G_LIKELY macros.
Keep track of the extended RTP timestamp so that we can report the RTP
timestamp <-> GStreamer timestamp relation for lip-sync.
Remove server timestamp gap detection code, the server can sometimes
make a huge gap in timestamps (talk spurts,...) see #549774.
Detect timetamp weirdness instead by observing the sender/receiver
timestamp relation and resync if it changes more than 1 second.
Add method to report about the current rtp <-> gst timestamp relation
which is needed for lip-sync.
* gst/rtpmanager/rtpsession.c: (rtp_session_class_init),
(on_sender_timeout), (check_collision), (rtp_session_process_sr),
(session_cleanup):
* gst/rtpmanager/rtpsession.h:
Add sender timeout signal.
Remove inaccurate rtp <-> gst timestamp relation code, the
jitterbuffer can now do an accurate reporting about this.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(rtp_source_update_caps), (calculate_jitter),
(rtp_source_process_rtp):
* gst/rtpmanager/rtpsource.h:
Remove inaccurate rtp <-> gst timestamp relation code.
* gst/rtpmanager/rtpstats.h:
Define global max-reorder and max-dropout constants for use in various
subsystems.
2008-09-05 13:52:34 +00:00
|
|
|
*
|
2009-02-25 09:45:05 +00:00
|
|
|
* Calculates the relation between the RTP timestamp and the GStreamer timestamp
|
gst/rtpmanager/gstrtpbin.*: Add signal to notify listeners when a sender becomes a receiver.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (on_sender_timeout),
(create_session), (gst_rtp_bin_associate),
(gst_rtp_bin_sync_chain), (gst_rtp_bin_class_init),
(gst_rtp_bin_request_new_pad):
* gst/rtpmanager/gstrtpbin.h:
Add signal to notify listeners when a sender becomes a receiver.
Tweak lip-sync code, don't store our own copy of the ts-offset of the
jitterbuffer, don't adjust sync if the change is less than 4msec.
Get the RTP timestamp <-> GStreamer timestamp relation directly from
the jitterbuffer instead of our inaccurate version from the source.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_chain), (gst_rtp_jitter_buffer_loop),
(gst_rtp_jitter_buffer_get_sync):
* gst/rtpmanager/gstrtpjitterbuffer.h:
Add G_LIKELY macros, use global defines for max packet reorder and
dropouts.
Reset the jitterbuffer clock skew detection when packets seqnums are
changed unexpectedly.
* gst/rtpmanager/gstrtpsession.c: (on_sender_timeout),
(gst_rtp_session_class_init), (gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
Add sender timeout signal.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_reset_skew),
(calculate_skew), (rtp_jitter_buffer_insert),
(rtp_jitter_buffer_get_sync):
* gst/rtpmanager/rtpjitterbuffer.h:
Add some G_LIKELY macros.
Keep track of the extended RTP timestamp so that we can report the RTP
timestamp <-> GStreamer timestamp relation for lip-sync.
Remove server timestamp gap detection code, the server can sometimes
make a huge gap in timestamps (talk spurts,...) see #549774.
Detect timetamp weirdness instead by observing the sender/receiver
timestamp relation and resync if it changes more than 1 second.
Add method to report about the current rtp <-> gst timestamp relation
which is needed for lip-sync.
* gst/rtpmanager/rtpsession.c: (rtp_session_class_init),
(on_sender_timeout), (check_collision), (rtp_session_process_sr),
(session_cleanup):
* gst/rtpmanager/rtpsession.h:
Add sender timeout signal.
Remove inaccurate rtp <-> gst timestamp relation code, the
jitterbuffer can now do an accurate reporting about this.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(rtp_source_update_caps), (calculate_jitter),
(rtp_source_process_rtp):
* gst/rtpmanager/rtpsource.h:
Remove inaccurate rtp <-> gst timestamp relation code.
* gst/rtpmanager/rtpstats.h:
Define global max-reorder and max-dropout constants for use in various
subsystems.
2008-09-05 13:52:34 +00:00
|
|
|
* used for constructing timestamps.
|
gst/rtpmanager/gstrtpbin.c: Remove internal sync pad, use signals instead to get lip-sync notifications.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (gst_rtp_bin_associate),
(gst_rtp_bin_handle_sync), (create_stream), (free_stream),
(new_ssrc_pad_found):
Remove internal sync pad, use signals instead to get lip-sync
notifications.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_base_init),
(gst_rtp_jitter_buffer_class_init),
(gst_rtp_jitter_buffer_internal_links), (create_rtcp_sink),
(remove_rtcp_sink), (gst_rtp_jitter_buffer_request_new_pad),
(gst_rtp_jitter_buffer_release_pad),
(gst_rtp_jitter_buffer_sink_rtcp_event),
(gst_rtp_jitter_buffer_chain_rtcp),
(gst_rtp_jitter_buffer_get_property):
* gst/rtpmanager/gstrtpjitterbuffer.h:
Make it possible to send SR packets to the jitterbuffer.
Check if the SR timestamps are valid by comparing them to the RTP
timestamps.
Signal the SR packet and the timing information to listeners.
* gst/rtpmanager/gstrtpssrcdemux.c: (create_demux_pad_for_ssrc),
(gst_rtp_ssrc_demux_rtcp_chain), (gst_rtp_ssrc_demux_src_query):
Remove some unused code.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_reset_skew),
(calculate_skew), (rtp_jitter_buffer_get_sync):
* gst/rtpmanager/rtpjitterbuffer.h:
Keep track of the last seen RTP timestamp so that we can filter out
invalid SR packets.
2008-11-19 09:06:29 +00:00
|
|
|
*
|
|
|
|
* 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.
|
gst/rtpmanager/gstrtpbin.*: Add signal to notify listeners when a sender becomes a receiver.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (on_sender_timeout),
(create_session), (gst_rtp_bin_associate),
(gst_rtp_bin_sync_chain), (gst_rtp_bin_class_init),
(gst_rtp_bin_request_new_pad):
* gst/rtpmanager/gstrtpbin.h:
Add signal to notify listeners when a sender becomes a receiver.
Tweak lip-sync code, don't store our own copy of the ts-offset of the
jitterbuffer, don't adjust sync if the change is less than 4msec.
Get the RTP timestamp <-> GStreamer timestamp relation directly from
the jitterbuffer instead of our inaccurate version from the source.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_chain), (gst_rtp_jitter_buffer_loop),
(gst_rtp_jitter_buffer_get_sync):
* gst/rtpmanager/gstrtpjitterbuffer.h:
Add G_LIKELY macros, use global defines for max packet reorder and
dropouts.
Reset the jitterbuffer clock skew detection when packets seqnums are
changed unexpectedly.
* gst/rtpmanager/gstrtpsession.c: (on_sender_timeout),
(gst_rtp_session_class_init), (gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
Add sender timeout signal.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_reset_skew),
(calculate_skew), (rtp_jitter_buffer_insert),
(rtp_jitter_buffer_get_sync):
* gst/rtpmanager/rtpjitterbuffer.h:
Add some G_LIKELY macros.
Keep track of the extended RTP timestamp so that we can report the RTP
timestamp <-> GStreamer timestamp relation for lip-sync.
Remove server timestamp gap detection code, the server can sometimes
make a huge gap in timestamps (talk spurts,...) see #549774.
Detect timetamp weirdness instead by observing the sender/receiver
timestamp relation and resync if it changes more than 1 second.
Add method to report about the current rtp <-> gst timestamp relation
which is needed for lip-sync.
* gst/rtpmanager/rtpsession.c: (rtp_session_class_init),
(on_sender_timeout), (check_collision), (rtp_session_process_sr),
(session_cleanup):
* gst/rtpmanager/rtpsession.h:
Add sender timeout signal.
Remove inaccurate rtp <-> gst timestamp relation code, the
jitterbuffer can now do an accurate reporting about this.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(rtp_source_update_caps), (calculate_jitter),
(rtp_source_process_rtp):
* gst/rtpmanager/rtpsource.h:
Remove inaccurate rtp <-> gst timestamp relation code.
* gst/rtpmanager/rtpstats.h:
Define global max-reorder and max-dropout constants for use in various
subsystems.
2008-09-05 13:52:34 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
rtp_jitter_buffer_get_sync (RTPJitterBuffer * jbuf, guint64 * rtptime,
|
gst/rtpmanager/gstrtpbin.c: Remove internal sync pad, use signals instead to get lip-sync notifications.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (gst_rtp_bin_associate),
(gst_rtp_bin_handle_sync), (create_stream), (free_stream),
(new_ssrc_pad_found):
Remove internal sync pad, use signals instead to get lip-sync
notifications.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_base_init),
(gst_rtp_jitter_buffer_class_init),
(gst_rtp_jitter_buffer_internal_links), (create_rtcp_sink),
(remove_rtcp_sink), (gst_rtp_jitter_buffer_request_new_pad),
(gst_rtp_jitter_buffer_release_pad),
(gst_rtp_jitter_buffer_sink_rtcp_event),
(gst_rtp_jitter_buffer_chain_rtcp),
(gst_rtp_jitter_buffer_get_property):
* gst/rtpmanager/gstrtpjitterbuffer.h:
Make it possible to send SR packets to the jitterbuffer.
Check if the SR timestamps are valid by comparing them to the RTP
timestamps.
Signal the SR packet and the timing information to listeners.
* gst/rtpmanager/gstrtpssrcdemux.c: (create_demux_pad_for_ssrc),
(gst_rtp_ssrc_demux_rtcp_chain), (gst_rtp_ssrc_demux_src_query):
Remove some unused code.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_reset_skew),
(calculate_skew), (rtp_jitter_buffer_get_sync):
* gst/rtpmanager/rtpjitterbuffer.h:
Keep track of the last seen RTP timestamp so that we can filter out
invalid SR packets.
2008-11-19 09:06:29 +00:00
|
|
|
guint64 * timestamp, guint32 * clock_rate, guint64 * last_rtptime)
|
gst/rtpmanager/gstrtpbin.*: Add signal to notify listeners when a sender becomes a receiver.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (on_sender_timeout),
(create_session), (gst_rtp_bin_associate),
(gst_rtp_bin_sync_chain), (gst_rtp_bin_class_init),
(gst_rtp_bin_request_new_pad):
* gst/rtpmanager/gstrtpbin.h:
Add signal to notify listeners when a sender becomes a receiver.
Tweak lip-sync code, don't store our own copy of the ts-offset of the
jitterbuffer, don't adjust sync if the change is less than 4msec.
Get the RTP timestamp <-> GStreamer timestamp relation directly from
the jitterbuffer instead of our inaccurate version from the source.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_chain), (gst_rtp_jitter_buffer_loop),
(gst_rtp_jitter_buffer_get_sync):
* gst/rtpmanager/gstrtpjitterbuffer.h:
Add G_LIKELY macros, use global defines for max packet reorder and
dropouts.
Reset the jitterbuffer clock skew detection when packets seqnums are
changed unexpectedly.
* gst/rtpmanager/gstrtpsession.c: (on_sender_timeout),
(gst_rtp_session_class_init), (gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
Add sender timeout signal.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_reset_skew),
(calculate_skew), (rtp_jitter_buffer_insert),
(rtp_jitter_buffer_get_sync):
* gst/rtpmanager/rtpjitterbuffer.h:
Add some G_LIKELY macros.
Keep track of the extended RTP timestamp so that we can report the RTP
timestamp <-> GStreamer timestamp relation for lip-sync.
Remove server timestamp gap detection code, the server can sometimes
make a huge gap in timestamps (talk spurts,...) see #549774.
Detect timetamp weirdness instead by observing the sender/receiver
timestamp relation and resync if it changes more than 1 second.
Add method to report about the current rtp <-> gst timestamp relation
which is needed for lip-sync.
* gst/rtpmanager/rtpsession.c: (rtp_session_class_init),
(on_sender_timeout), (check_collision), (rtp_session_process_sr),
(session_cleanup):
* gst/rtpmanager/rtpsession.h:
Add sender timeout signal.
Remove inaccurate rtp <-> gst timestamp relation code, the
jitterbuffer can now do an accurate reporting about this.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(rtp_source_update_caps), (calculate_jitter),
(rtp_source_process_rtp):
* gst/rtpmanager/rtpsource.h:
Remove inaccurate rtp <-> gst timestamp relation code.
* gst/rtpmanager/rtpstats.h:
Define global max-reorder and max-dropout constants for use in various
subsystems.
2008-09-05 13:52:34 +00:00
|
|
|
{
|
|
|
|
if (rtptime)
|
|
|
|
*rtptime = jbuf->base_extrtp;
|
|
|
|
if (timestamp)
|
|
|
|
*timestamp = jbuf->base_time + jbuf->skew;
|
2008-11-17 15:17:52 +00:00
|
|
|
if (clock_rate)
|
|
|
|
*clock_rate = jbuf->clock_rate;
|
gst/rtpmanager/gstrtpbin.c: Remove internal sync pad, use signals instead to get lip-sync notifications.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (gst_rtp_bin_associate),
(gst_rtp_bin_handle_sync), (create_stream), (free_stream),
(new_ssrc_pad_found):
Remove internal sync pad, use signals instead to get lip-sync
notifications.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_base_init),
(gst_rtp_jitter_buffer_class_init),
(gst_rtp_jitter_buffer_internal_links), (create_rtcp_sink),
(remove_rtcp_sink), (gst_rtp_jitter_buffer_request_new_pad),
(gst_rtp_jitter_buffer_release_pad),
(gst_rtp_jitter_buffer_sink_rtcp_event),
(gst_rtp_jitter_buffer_chain_rtcp),
(gst_rtp_jitter_buffer_get_property):
* gst/rtpmanager/gstrtpjitterbuffer.h:
Make it possible to send SR packets to the jitterbuffer.
Check if the SR timestamps are valid by comparing them to the RTP
timestamps.
Signal the SR packet and the timing information to listeners.
* gst/rtpmanager/gstrtpssrcdemux.c: (create_demux_pad_for_ssrc),
(gst_rtp_ssrc_demux_rtcp_chain), (gst_rtp_ssrc_demux_src_query):
Remove some unused code.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_reset_skew),
(calculate_skew), (rtp_jitter_buffer_get_sync):
* gst/rtpmanager/rtpjitterbuffer.h:
Keep track of the last seen RTP timestamp so that we can filter out
invalid SR packets.
2008-11-19 09:06:29 +00:00
|
|
|
if (last_rtptime)
|
|
|
|
*last_rtptime = jbuf->last_rtptime;
|
gst/rtpmanager/gstrtpbin.*: Add signal to notify listeners when a sender becomes a receiver.
Original commit message from CVS:
* gst/rtpmanager/gstrtpbin.c: (on_sender_timeout),
(create_session), (gst_rtp_bin_associate),
(gst_rtp_bin_sync_chain), (gst_rtp_bin_class_init),
(gst_rtp_bin_request_new_pad):
* gst/rtpmanager/gstrtpbin.h:
Add signal to notify listeners when a sender becomes a receiver.
Tweak lip-sync code, don't store our own copy of the ts-offset of the
jitterbuffer, don't adjust sync if the change is less than 4msec.
Get the RTP timestamp <-> GStreamer timestamp relation directly from
the jitterbuffer instead of our inaccurate version from the source.
* gst/rtpmanager/gstrtpjitterbuffer.c:
(gst_rtp_jitter_buffer_chain), (gst_rtp_jitter_buffer_loop),
(gst_rtp_jitter_buffer_get_sync):
* gst/rtpmanager/gstrtpjitterbuffer.h:
Add G_LIKELY macros, use global defines for max packet reorder and
dropouts.
Reset the jitterbuffer clock skew detection when packets seqnums are
changed unexpectedly.
* gst/rtpmanager/gstrtpsession.c: (on_sender_timeout),
(gst_rtp_session_class_init), (gst_rtp_session_init):
* gst/rtpmanager/gstrtpsession.h:
Add sender timeout signal.
* gst/rtpmanager/rtpjitterbuffer.c: (rtp_jitter_buffer_reset_skew),
(calculate_skew), (rtp_jitter_buffer_insert),
(rtp_jitter_buffer_get_sync):
* gst/rtpmanager/rtpjitterbuffer.h:
Add some G_LIKELY macros.
Keep track of the extended RTP timestamp so that we can report the RTP
timestamp <-> GStreamer timestamp relation for lip-sync.
Remove server timestamp gap detection code, the server can sometimes
make a huge gap in timestamps (talk spurts,...) see #549774.
Detect timetamp weirdness instead by observing the sender/receiver
timestamp relation and resync if it changes more than 1 second.
Add method to report about the current rtp <-> gst timestamp relation
which is needed for lip-sync.
* gst/rtpmanager/rtpsession.c: (rtp_session_class_init),
(on_sender_timeout), (check_collision), (rtp_session_process_sr),
(session_cleanup):
* gst/rtpmanager/rtpsession.h:
Add sender timeout signal.
Remove inaccurate rtp <-> gst timestamp relation code, the
jitterbuffer can now do an accurate reporting about this.
* gst/rtpmanager/rtpsource.c: (rtp_source_init),
(rtp_source_update_caps), (calculate_jitter),
(rtp_source_process_rtp):
* gst/rtpmanager/rtpsource.h:
Remove inaccurate rtp <-> gst timestamp relation code.
* gst/rtpmanager/rtpstats.h:
Define global max-reorder and max-dropout constants for use in various
subsystems.
2008-09-05 13:52:34 +00:00
|
|
|
}
|
2017-06-22 19:34:42 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
}
|