1 /* GStreamer 2 * Copyright (C) <2007> Wim Taymans <wim.taymans@gmail.com> 3 * Copyright (C) 2015 Kurento (http://kurento.org/) 4 * @author: Miguel París <mparisdiaz@gmail.com> 5 * 6 * This library is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU Library General Public 8 * License as published by the Free Software Foundation; either 9 * version 2 of the License, or (at your option) any later version. 10 * 11 * This library is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 * Library General Public License for more details. 15 * 16 * You should have received a copy of the GNU Library General Public 17 * License along with this library; if not, write to the 18 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, 19 * Boston, MA 02110-1301, USA. 20 */ 21 22 #ifndef __RTP_STATS_H__ 23 #define __RTP_STATS_H__ 24 25 #include <gst/gst.h> 26 #include <gst/net/gstnetaddressmeta.h> 27 #include <gst/rtp/rtp.h> 28 #include <gio/gio.h> 29 30 /** 31 * RTPSenderReport: 32 * 33 * A sender report structure. 34 */ 35 typedef struct { 36 gboolean is_valid; 37 guint64 ntptime; 38 guint32 rtptime; 39 guint32 packet_count; 40 guint32 octet_count; 41 GstClockTime time; 42 } RTPSenderReport; 43 44 /** 45 * RTPReceiverReport: 46 * 47 * A receiver report structure. 48 */ 49 typedef struct { 50 gboolean is_valid; 51 guint32 ssrc; /* who the report is from */ 52 guint8 fractionlost; 53 guint32 packetslost; 54 guint32 exthighestseq; 55 guint32 jitter; 56 guint32 lsr; 57 guint32 dlsr; 58 guint32 round_trip; 59 } RTPReceiverReport; 60 61 /** 62 * RTPPacketInfo: 63 * @send: if this is a packet for sending 64 * @rtp: if this info is about an RTP packet 65 * @is_list: if this is a bufferlist 66 * @data: a #GstBuffer or #GstBufferList 67 * @address: address of the sender of the packet 68 * @current_time: current time according to the system clock 69 * @running_time: time of a packet as buffer running_time 70 * @ntpnstime: time of a packet NTP time in nanoseconds 71 * @header_len: number of overhead bytes per packet 72 * @bytes: bytes of the packet including lowlevel overhead 73 * @payload_len: bytes of the RTP payload 74 * @seqnum: the seqnum of the packet 75 * @pt: the payload type of the packet 76 * @rtptime: the RTP time of the packet 77 * 78 * Structure holding information about the packet. 79 */ 80 typedef struct { 81 gboolean send; 82 gboolean rtp; 83 gboolean is_list; 84 gpointer data; 85 GSocketAddress *address; 86 GstClockTime current_time; 87 GstClockTime running_time; 88 guint64 ntpnstime; 89 guint header_len; 90 guint bytes; 91 guint packets; 92 guint payload_len; 93 guint32 ssrc; 94 guint16 seqnum; 95 guint8 pt; 96 guint32 rtptime; 97 guint32 csrc_count; 98 guint32 csrcs[16]; 99 } RTPPacketInfo; 100 101 /** 102 * RTPSourceStats: 103 * @packets_received: number of received packets in total 104 * @prev_received: number of packets received in previous reporting 105 * interval 106 * @octets_received: number of payload bytes received 107 * @bytes_received: number of total bytes received including headers and lower 108 * protocol level overhead 109 * @max_seqnr: highest sequence number received 110 * @transit: previous transit time used for calculating @jitter 111 * @jitter: current jitter (in clock rate units scaled by 16 for precision) 112 * @prev_rtptime: previous time when an RTP packet was received 113 * @prev_rtcptime: previous time when an RTCP packet was received 114 * @last_rtptime: time when last RTP packet received 115 * @last_rtcptime: time when last RTCP packet received 116 * @curr_rr: index of current @rr block 117 * @rr: previous and current receiver report block 118 * @curr_sr: index of current @sr block 119 * @sr: previous and current sender report block 120 * 121 * Stats about a source. 122 */ 123 typedef struct { 124 guint64 packets_received; 125 guint64 octets_received; 126 guint64 bytes_received; 127 128 guint32 prev_expected; 129 guint32 prev_received; 130 131 guint16 max_seq; 132 guint64 cycles; 133 guint32 base_seq; 134 guint32 bad_seq; 135 guint32 transit; 136 guint32 jitter; 137 138 guint64 packets_sent; 139 guint64 octets_sent; 140 141 guint sent_pli_count; 142 guint recv_pli_count; 143 guint sent_fir_count; 144 guint recv_fir_count; 145 guint sent_nack_count; 146 guint recv_nack_count; 147 148 /* when we received stuff */ 149 GstClockTime prev_rtptime; 150 GstClockTime prev_rtcptime; 151 GstClockTime last_rtptime; 152 GstClockTime last_rtcptime; 153 154 /* sender and receiver reports */ 155 gint curr_rr; 156 RTPReceiverReport rr[2]; 157 gint curr_sr; 158 RTPSenderReport sr[2]; 159 } RTPSourceStats; 160 161 #define RTP_STATS_BANDWIDTH 64000 162 #define RTP_STATS_RTCP_FRACTION 0.05 163 /* 164 * Minimum average time between RTCP packets from this site (in 165 * seconds). This time prevents the reports from `clumping' when 166 * sessions are small and the law of large numbers isn't helping 167 * to smooth out the traffic. It also keeps the report interval 168 * from becoming ridiculously small during transient outages like 169 * a network partition. 170 */ 171 #define RTP_STATS_MIN_INTERVAL 5.0 172 /* 173 * Fraction of the RTCP bandwidth to be shared among active 174 * senders. (This fraction was chosen so that in a typical 175 * session with one or two active senders, the computed report 176 * time would be roughly equal to the minimum report time so that 177 * we don't unnecessarily slow down receiver reports.) The 178 * receiver fraction must be 1 - the sender fraction. 179 */ 180 #define RTP_STATS_SENDER_FRACTION (0.25) 181 #define RTP_STATS_RECEIVER_FRACTION (1.0 - RTP_STATS_SENDER_FRACTION) 182 183 /* 184 * When receiving a BYE from a source, remove the source from the database 185 * after this timeout. 186 */ 187 #define RTP_STATS_BYE_TIMEOUT (2 * GST_SECOND) 188 189 /* 190 * The default and minimum values of the maximum number of missing packets we tolerate. 191 * These are packets with asequence number bigger than the last seen packet. 192 */ 193 #define RTP_DEF_DROPOUT 3000 194 #define RTP_MIN_DROPOUT 30 195 196 /* 197 * The default and minimum values of the maximum number of misordered packets we tolerate. 198 * These are packets with a sequence number smaller than the last seen packet. 199 */ 200 #define RTP_DEF_MISORDER 100 201 #define RTP_MIN_MISORDER 10 202 203 /** 204 * RTPPacketRateCtx: 205 * 206 * Context to calculate the pseudo-average packet rate. 207 */ 208 typedef struct { 209 gboolean probed; 210 gint32 clock_rate; 211 guint16 last_seqnum; 212 guint64 last_ts; 213 guint32 avg_packet_rate; 214 } RTPPacketRateCtx; 215 216 void gst_rtp_packet_rate_ctx_reset (RTPPacketRateCtx * ctx, gint32 clock_rate); 217 guint32 gst_rtp_packet_rate_ctx_update (RTPPacketRateCtx *ctx, guint16 seqnum, guint32 ts); 218 guint32 gst_rtp_packet_rate_ctx_get (RTPPacketRateCtx *ctx); 219 guint32 gst_rtp_packet_rate_ctx_get_max_dropout (RTPPacketRateCtx *ctx, gint32 time_ms); 220 guint32 gst_rtp_packet_rate_ctx_get_max_misorder (RTPPacketRateCtx *ctx, gint32 time_ms); 221 222 /** 223 * RTPSessionStats: 224 * 225 * Stats kept for a session and used to produce RTCP packet timeouts. 226 */ 227 typedef struct { 228 guint bandwidth; 229 guint rtcp_bandwidth; 230 gdouble sender_fraction; 231 gdouble receiver_fraction; 232 gdouble min_interval; 233 GstClockTime bye_timeout; 234 guint internal_sources; 235 guint sender_sources; 236 guint internal_sender_sources; 237 guint active_sources; 238 guint avg_rtcp_packet_size; 239 guint bye_members; 240 guint nacks_dropped; 241 guint nacks_sent; 242 guint nacks_received; 243 } RTPSessionStats; 244 245 void rtp_stats_init_defaults (RTPSessionStats *stats); 246 247 void rtp_stats_set_bandwidths (RTPSessionStats *stats, 248 guint rtp_bw, 249 gdouble rtcp_bw, 250 guint rs, guint rr); 251 252 GstClockTime rtp_stats_calculate_rtcp_interval (RTPSessionStats *stats, gboolean sender, GstRTPProfile profile, gboolean ptp, gboolean first); 253 GstClockTime rtp_stats_add_rtcp_jitter (RTPSessionStats *stats, GstClockTime interval); 254 GstClockTime rtp_stats_calculate_bye_interval (RTPSessionStats *stats); 255 gint64 rtp_stats_get_packets_lost (const RTPSourceStats *stats); 256 257 void rtp_stats_set_min_interval (RTPSessionStats *stats, 258 gdouble min_interval); 259 260 261 gboolean __g_socket_address_equal (GSocketAddress *a, GSocketAddress *b); 262 gchar * __g_socket_address_to_string (GSocketAddress * addr); 263 264 #endif /* __RTP_STATS_H__ */ 265