From 1d75a69ccf4b4ff63037cf5b4ddf9491dad7ca4b Mon Sep 17 00:00:00 2001 From: Wim Taymans Date: Wed, 18 Apr 2007 18:58:53 +0000 Subject: configure.ac: Disable rtpmanager for now because it depends on CVS -base. Original commit message from CVS: * configure.ac: Disable rtpmanager for now because it depends on CVS -base. * gst/rtpmanager/Makefile.am: Added new files for session manager. * gst/rtpmanager/gstrtpjitterbuffer.h: * gst/rtpmanager/gstrtpbin.c: (create_session), (get_pt_map), (create_stream), (pt_map_requested), (new_ssrc_pad_found): Some cleanups. the session manager can now also request a pt-map. * gst/rtpmanager/gstrtpsession.c: (gst_rtp_session_base_init), (gst_rtp_session_class_init), (gst_rtp_session_init), (gst_rtp_session_finalize), (rtcp_thread), (start_rtcp_thread), (stop_rtcp_thread), (gst_rtp_session_change_state), (gst_rtp_session_process_rtp), (gst_rtp_session_send_rtp), (gst_rtp_session_send_rtcp), (gst_rtp_session_clock_rate), (gst_rtp_session_get_time), (gst_rtp_session_event_recv_rtp_sink), (gst_rtp_session_chain_recv_rtp), (gst_rtp_session_event_recv_rtcp_sink), (gst_rtp_session_chain_recv_rtcp), (gst_rtp_session_event_send_rtp_sink), (gst_rtp_session_chain_send_rtp), (create_send_rtcp_src), (gst_rtp_session_request_new_pad): * gst/rtpmanager/gstrtpsession.h: We can ask for pt-map now too when the session manager needs it. Hook up to the new session manager, implement the needed callbacks for pushing data, getting clock time and requesting clock-rates. Rename rtcp_src to send_rtcp_src to make it clear that this RTCP is to be send to clients. Add code to start and stop the thread that will schedule RTCP through the session manager. * gst/rtpmanager/rtpsession.c: (rtp_session_class_init), (rtp_session_init), (rtp_session_finalize), (rtp_session_set_property), (rtp_session_get_property), (on_new_ssrc), (on_ssrc_collision), (on_ssrc_validated), (on_bye_ssrc), (rtp_session_new), (rtp_session_set_callbacks), (rtp_session_set_bandwidth), (rtp_session_get_bandwidth), (rtp_session_set_rtcp_bandwidth), (rtp_session_get_rtcp_bandwidth), (source_push_rtp), (source_clock_rate), (check_collision), (obtain_source), (rtp_session_add_source), (rtp_session_get_num_sources), (rtp_session_get_num_active_sources), (rtp_session_get_source_by_ssrc), (rtp_session_get_source_by_cname), (rtp_session_create_source), (update_arrival_stats), (rtp_session_process_rtp), (rtp_session_process_sr), (rtp_session_process_rr), (rtp_session_process_sdes), (rtp_session_process_bye), (rtp_session_process_app), (rtp_session_process_rtcp), (rtp_session_send_rtp), (rtp_session_get_rtcp_interval), (rtp_session_produce_rtcp): * gst/rtpmanager/rtpsession.h: The advanced beginnings of the main session manager that handles the participant database of RTPSources, SSRC probation, SSRC collisions, parse RTCP to update source stats. etc.. * gst/rtpmanager/rtpsource.c: (rtp_source_class_init), (rtp_source_init), (rtp_source_finalize), (rtp_source_new), (rtp_source_set_callbacks), (rtp_source_set_as_csrc), (rtp_source_set_rtp_from), (rtp_source_set_rtcp_from), (push_packet), (get_clock_rate), (calculate_jitter), (rtp_source_process_rtp), (rtp_source_process_bye), (rtp_source_send_rtp), (rtp_source_process_sr), (rtp_source_process_rb): * gst/rtpmanager/rtpsource.h: Object that encapsulates an SSRC and its state in the database. Calculates the jitter and transit times of data packets. * gst/rtpmanager/rtpstats.c: (rtp_stats_init_defaults), (rtp_stats_calculate_rtcp_interval), (rtp_stats_add_rtcp_jitter): * gst/rtpmanager/rtpstats.h: Various stats regarding the session and sources. Used to calculate the RTCP interval. --- gst/rtpmanager/rtpstats.h | 161 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 161 insertions(+) create mode 100644 gst/rtpmanager/rtpstats.h (limited to 'gst/rtpmanager/rtpstats.h') diff --git a/gst/rtpmanager/rtpstats.h b/gst/rtpmanager/rtpstats.h new file mode 100644 index 00000000..66aa7bf7 --- /dev/null +++ b/gst/rtpmanager/rtpstats.h @@ -0,0 +1,161 @@ +/* GStreamer + * Copyright (C) <2007> Wim Taymans + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#ifndef __RTP_STATS_H__ +#define __RTP_STATS_H__ + +#include +#include + +/** + * RTPSenderReport: + * + * A sender report structure. + */ +typedef struct { + gboolean is_valid; + guint64 ntptime; + guint32 rtptime; + guint32 packet_count; + guint32 octet_count; +} RTPSenderReport; + +/** + * RTPReceiverReport: + * + * A receiver report structure. + */ +typedef struct { + gboolean is_valid; + guint32 ssrc; /* who the report is from */ + guint8 fractionlost; + guint32 packetslost; + guint32 exthighestseq; + guint32 jitter; + guint32 lsr; + guint32 dlsr; +} RTPReceiverReport; + +/** + * RTPArrivalStats: + * @time: arrival time of a packet + * @address: address of the sender of the packet + * @bytes: bytes of the packet including lowlevel overhead + * @payload_len: bytes of the RTP payload + * + * Structure holding information about the arrival stats of a packet. + */ +typedef struct { + GstClockTime time; + gboolean have_address; + GstNetAddress address; + guint bytes; + guint payload_len; +} RTPArrivalStats; + +/** + * RTPSourceStats: + * @packetsreceived: number of received packets in total + * @prevpacketsreceived: number of packets received in previous reporting + * interval + * @octetsreceived: number of payload bytes received + * @bytesreceived: number of total bytes received including headers and lower + * protocol level overhead + * @max_seqnr: highest sequence number received + * @transit: previous transit time used for calculating @jitter + * @jitter: current jitter + * @prev_rtptime: previous time when an RTP packet was received + * @prev_rtcptime: previous time when an RTCP packet was received + * @last_rtptime: time when last RTP packet received + * @last_rtcptime: time when last RTCP packet received + * @curr_rr: index of current @rr block + * @rr: previous and current receiver report block + * @curr_sr: index of current @sr block + * @sr: previous and current sender report block + * + * Stats about a source. + */ +typedef struct { + guint64 packetsreceived; + guint64 prevpacketsreceived; + guint64 octetsreceived; + guint64 bytesreceived; + guint16 max_seqnr; + guint32 transit; + guint32 jitter; + + /* when we received stuff */ + GstClockTime prev_rtptime; + GstClockTime prev_rtcptime; + GstClockTime last_rtptime; + GstClockTime last_rtcptime; + + /* sender and receiver reports */ + gint curr_rr; + RTPReceiverReport rr[2]; + gint curr_sr; + RTPSenderReport sr[2]; +} RTPSourceStats; + +#define RTP_STATS_BANDWIDTH 64000.0 +#define RTP_STATS_RTCP_BANDWIDTH 3000.0 +/* + * Minimum average time between RTCP packets from this site (in + * seconds). This time prevents the reports from `clumping' when + * sessions are small and the law of large numbers isn't helping + * to smooth out the traffic. It also keeps the report interval + * from becoming ridiculously small during transient outages like + * a network partition. + */ +#define RTP_STATS_MIN_INTERVAL 5.0 + /* + * Fraction of the RTCP bandwidth to be shared among active + * senders. (This fraction was chosen so that in a typical + * session with one or two active senders, the computed report + * time would be roughly equal to the minimum report time so that + * we don't unnecessarily slow down receiver reports.) The + * receiver fraction must be 1 - the sender fraction. + */ +#define RTP_STATS_SENDER_FRACTION (0.25) +#define RTP_STATS_RECEIVER_FRACTION (1.0 - RTP_STATS_SENDER_FRACTION) + +/** + * RTPSessionStats: + * + * Stats kept for a session and used to produce RTCP packet timeouts. + */ +typedef struct { + gdouble bandwidth; + gdouble sender_fraction; + gdouble receiver_fraction; + gdouble rtcp_bandwidth; + gdouble min_interval; + guint sender_sources; + guint active_sources; + guint avg_rtcp_packet_size; + guint avg_bye_packet_size; + gboolean sent_rtcp; +} RTPSessionStats; + +void rtp_stats_init_defaults (RTPSessionStats *stats); + +gdouble rtp_stats_calculate_rtcp_interval (RTPSessionStats *stats, gboolean sender); +gdouble rtp_stats_add_rtcp_jitter (RTPSessionStats *stats, gdouble interval); + +#endif /* __RTP_STATS_H__ */ -- cgit v1.2.1