1 /* GStreamer 2 * Copyright (C) <2007> Wim Taymans <wim.taymans@gmail.com> 3 * 4 * This library is free software; you can redistribute it and/or 5 * modify it under the terms of the GNU Library General Public 6 * License as published by the Free Software Foundation; either 7 * version 2 of the License, or (at your option) any later version. 8 * 9 * This library is distributed in the hope that it will be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 * Library General Public License for more details. 13 * 14 * You should have received a copy of the GNU Library General Public 15 * License along with this library; if not, write to the 16 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, 17 * Boston, MA 02110-1301, USA. 18 */ 19 20 #ifndef __RTP_SESSION_H__ 21 #define __RTP_SESSION_H__ 22 23 #include <gst/gst.h> 24 25 #include "rtpsource.h" 26 27 typedef struct _RTPSession RTPSession; 28 typedef struct _RTPSessionClass RTPSessionClass; 29 30 #define RTP_TYPE_SESSION (rtp_session_get_type()) 31 #define RTP_SESSION(sess) (G_TYPE_CHECK_INSTANCE_CAST((sess),RTP_TYPE_SESSION,RTPSession)) 32 #define RTP_SESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),RTP_TYPE_SESSION,RTPSessionClass)) 33 #define RTP_IS_SESSION(sess) (G_TYPE_CHECK_INSTANCE_TYPE((sess),RTP_TYPE_SESSION)) 34 #define RTP_IS_SESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),RTP_TYPE_SESSION)) 35 #define RTP_SESSION_CAST(sess) ((RTPSession *)(sess)) 36 37 #define RTP_SESSION_LOCK(sess) (g_mutex_lock (&(sess)->lock)) 38 #define RTP_SESSION_UNLOCK(sess) (g_mutex_unlock (&(sess)->lock)) 39 40 /** 41 * RTPSessionProcessRTP: 42 * @sess: an #RTPSession 43 * @src: the #RTPSource 44 * @buffer: the RTP buffer ready for processing 45 * @user_data: user data specified when registering 46 * 47 * This callback will be called when @sess has @buffer ready for further 48 * processing. Processing the buffer typically includes decoding and displaying 49 * the buffer. 50 * 51 * Returns: a #GstFlowReturn. 52 */ 53 typedef GstFlowReturn (*RTPSessionProcessRTP) (RTPSession *sess, RTPSource *src, GstBuffer *buffer, gpointer user_data); 54 55 /** 56 * RTPSessionSendRTP: 57 * @sess: an #RTPSession 58 * @src: the #RTPSource 59 * @data: the RTP buffer or buffer list ready for sending 60 * @user_data: user data specified when registering 61 * 62 * This callback will be called when @sess has @data (a buffer or buffer list) 63 * ready for sending to all listening participants in this session. 64 * 65 * Returns: a #GstFlowReturn. 66 */ 67 typedef GstFlowReturn (*RTPSessionSendRTP) (RTPSession *sess, RTPSource *src, gpointer data, gpointer user_data); 68 69 /** 70 * RTPSessionSendRTCP: 71 * @sess: an #RTPSession 72 * @src: the #RTPSource 73 * @buffer: the RTCP buffer ready for sending 74 * @eos: if an EOS event should be pushed 75 * @user_data: user data specified when registering 76 * 77 * This callback will be called when @sess has @buffer ready for sending to 78 * all listening participants in this session. 79 * 80 * Returns: a #GstFlowReturn. 81 */ 82 typedef GstFlowReturn (*RTPSessionSendRTCP) (RTPSession *sess, RTPSource *src, GstBuffer *buffer, 83 gboolean eos, gpointer user_data); 84 85 /** 86 * RTPSessionSyncRTCP: 87 * @sess: an #RTPSession 88 * @buffer: the RTCP buffer ready for synchronisation 89 * @user_data: user data specified when registering 90 * 91 * This callback will be called when @sess has an SR @buffer ready for doing 92 * synchronisation between streams. 93 * 94 * Returns: a #GstFlowReturn. 95 */ 96 typedef GstFlowReturn (*RTPSessionSyncRTCP) (RTPSession *sess, GstBuffer *buffer, gpointer user_data); 97 98 /** 99 * RTPSessionClockRate: 100 * @sess: an #RTPSession 101 * @payload: the payload 102 * @user_data: user data specified when registering 103 * 104 * This callback will be called when @sess needs the clock-rate of @payload. 105 * 106 * Returns: the clock-rate of @pt. 107 */ 108 typedef gint (*RTPSessionClockRate) (RTPSession *sess, guint8 payload, gpointer user_data); 109 110 /** 111 * RTPSessionReconsider: 112 * @sess: an #RTPSession 113 * @user_data: user data specified when registering 114 * 115 * This callback will be called when @sess needs to cancel the current timeout. 116 * The currently running timeout should be canceled and a new reporting interval 117 * should be requested from @sess. 118 */ 119 typedef void (*RTPSessionReconsider) (RTPSession *sess, gpointer user_data); 120 121 /** 122 * RTPSessionRequestKeyUnit: 123 * @sess: an #RTPSession 124 * @ssrc: SSRC of the source related to the key unit request 125 * @all_headers: %TRUE if "all-headers" property should be set on the key unit 126 * request 127 * @user_data: user data specified when registering 128 * 129 * Asks the encoder to produce a key unit as soon as possibly within the 130 * bandwidth constraints 131 */ 132 typedef void (*RTPSessionRequestKeyUnit) (RTPSession *sess, guint32 ssrc, 133 gboolean all_headers, gpointer user_data); 134 135 /** 136 * RTPSessionRequestTime: 137 * @sess: an #RTPSession 138 * @user_data: user data specified when registering 139 * 140 * This callback will be called when @sess needs the current time. The time 141 * should be returned as a #GstClockTime 142 */ 143 typedef GstClockTime (*RTPSessionRequestTime) (RTPSession *sess, 144 gpointer user_data); 145 146 /** 147 * RTPSessionNotifyNACK: 148 * @sess: an #RTPSession 149 * @seqnum: the missing seqnum 150 * @blp: other missing seqnums 151 * @ssrc: SSRC of requested stream 152 * @user_data: user data specified when registering 153 * 154 * Notifies of NACKed frames. 155 */ 156 typedef void (*RTPSessionNotifyNACK) (RTPSession *sess, 157 guint16 seqnum, guint16 blp, guint32 ssrc, gpointer user_data); 158 159 /** 160 * RTPSessionReconfigure: 161 * @sess: an #RTPSession 162 * @user_data: user data specified when registering 163 * 164 * This callback will be called when @sess wants to reconfigure the 165 * negotiated parameters. 166 */ 167 typedef void (*RTPSessionReconfigure) (RTPSession *sess, gpointer user_data); 168 169 /** 170 * RTPSessionNotifyEarlyRTCP: 171 * @sess: an #RTPSession 172 * @user_data: user data specified when registering 173 * 174 * Notifies of early RTCP being requested 175 */ 176 typedef void (*RTPSessionNotifyEarlyRTCP) (RTPSession *sess, 177 gpointer user_data); 178 179 /** 180 * RTPSessionCallbacks: 181 * @RTPSessionProcessRTP: callback to process RTP packets 182 * @RTPSessionSendRTP: callback for sending RTP packets 183 * @RTPSessionSendRTCP: callback for sending RTCP packets 184 * @RTPSessionSyncRTCP: callback for handling SR packets 185 * @RTPSessionReconsider: callback for reconsidering the timeout 186 * @RTPSessionRequestKeyUnit: callback for requesting a new key unit 187 * @RTPSessionRequestTime: callback for requesting the current time 188 * @RTPSessionNotifyNACK: callback for notifying NACK 189 * @RTPSessionReconfigure: callback for requesting reconfiguration 190 * @RTPSessionNotifyEarlyRTCP: callback for notifying early RTCP 191 * 192 * These callbacks can be installed on the session manager to get notification 193 * when RTP and RTCP packets are ready for further processing. These callbacks 194 * are not implemented with signals for performance reasons. 195 */ 196 typedef struct { 197 RTPSessionProcessRTP process_rtp; 198 RTPSessionSendRTP send_rtp; 199 RTPSessionSyncRTCP sync_rtcp; 200 RTPSessionSendRTCP send_rtcp; 201 RTPSessionClockRate clock_rate; 202 RTPSessionReconsider reconsider; 203 RTPSessionRequestKeyUnit request_key_unit; 204 RTPSessionRequestTime request_time; 205 RTPSessionNotifyNACK notify_nack; 206 RTPSessionReconfigure reconfigure; 207 RTPSessionNotifyEarlyRTCP notify_early_rtcp; 208 } RTPSessionCallbacks; 209 210 /** 211 * RTPSession: 212 * @lock: lock to protect the session 213 * @source: the source of this session 214 * @ssrcs: Hashtable of sources indexed by SSRC 215 * @num_sources: the number of sources 216 * @activecount: the number of active sources 217 * @callbacks: callbacks 218 * @user_data: user data passed in callbacks 219 * @stats: session statistics 220 * @conflicting_addresses: GList of conflicting addresses 221 * 222 * The RTP session manager object 223 */ 224 struct _RTPSession { 225 GObject object; 226 227 GMutex lock; 228 229 guint header_len; 230 guint mtu; 231 232 GstStructure *sdes; 233 234 guint probation; 235 guint32 max_dropout_time; 236 guint32 max_misorder_time; 237 238 GstRTPProfile rtp_profile; 239 240 gboolean reduced_size_rtcp; 241 242 /* bandwidths */ 243 gboolean recalc_bandwidth; 244 guint bandwidth; 245 gdouble rtcp_bandwidth; 246 guint rtcp_rr_bandwidth; 247 guint rtcp_rs_bandwidth; 248 249 guint32 suggested_ssrc; 250 gboolean internal_ssrc_set; 251 gboolean internal_ssrc_from_caps_or_property; 252 253 /* for sender/receiver counting */ 254 guint32 key; 255 guint32 mask_idx; 256 guint32 mask; 257 GHashTable *ssrcs[32]; 258 guint total_sources; 259 260 guint16 generation; 261 GstClockTime next_rtcp_check_time; /* tn */ 262 GstClockTime last_rtcp_check_time; /* tp */ 263 GstClockTime last_rtcp_send_time; /* t_rr_last */ 264 GstClockTime last_rtcp_interval; /* T_rr */ 265 GstClockTime start_time; 266 gboolean first_rtcp; 267 gboolean allow_early; 268 269 GstClockTime next_early_rtcp_time; 270 271 gboolean scheduled_bye; 272 273 RTPSessionCallbacks callbacks; 274 gpointer process_rtp_user_data; 275 gpointer send_rtp_user_data; 276 gpointer send_rtcp_user_data; 277 gpointer sync_rtcp_user_data; 278 gpointer clock_rate_user_data; 279 gpointer reconsider_user_data; 280 gpointer request_key_unit_user_data; 281 gpointer request_time_user_data; 282 gpointer notify_nack_user_data; 283 gpointer reconfigure_user_data; 284 gpointer notify_early_rtcp_user_data; 285 286 RTPSessionStats stats; 287 RTPSessionStats bye_stats; 288 289 gboolean favor_new; 290 GstClockTime rtcp_feedback_retention_window; 291 guint rtcp_immediate_feedback_threshold; 292 293 gboolean is_doing_ptp; 294 295 GList *conflicting_addresses; 296 297 gboolean timestamp_sender_reports; 298 }; 299 300 /** 301 * RTPSessionClass: 302 * @on_new_ssrc: emitted when a new source is found 303 * @on_bye_ssrc: emitted when a source is gone 304 * 305 * The session class. 306 */ 307 struct _RTPSessionClass { 308 GObjectClass parent_class; 309 310 /* action signals */ 311 RTPSource* (*get_source_by_ssrc) (RTPSession *sess, guint32 ssrc); 312 313 /* signals */ 314 void (*on_new_ssrc) (RTPSession *sess, RTPSource *source); 315 void (*on_ssrc_collision) (RTPSession *sess, RTPSource *source); 316 void (*on_ssrc_validated) (RTPSession *sess, RTPSource *source); 317 void (*on_ssrc_active) (RTPSession *sess, RTPSource *source); 318 void (*on_ssrc_sdes) (RTPSession *sess, RTPSource *source); 319 void (*on_bye_ssrc) (RTPSession *sess, RTPSource *source); 320 void (*on_bye_timeout) (RTPSession *sess, RTPSource *source); 321 void (*on_timeout) (RTPSession *sess, RTPSource *source); 322 void (*on_sender_timeout) (RTPSession *sess, RTPSource *source); 323 gboolean (*on_sending_rtcp) (RTPSession *sess, GstBuffer *buffer, 324 gboolean early); 325 void (*on_app_rtcp) (RTPSession *sess, guint subtype, guint ssrc, 326 const gchar *name, GstBuffer *data); 327 void (*on_feedback_rtcp) (RTPSession *sess, guint type, guint fbtype, 328 guint sender_ssrc, guint media_ssrc, GstBuffer *fci); 329 gboolean (*send_rtcp) (RTPSession *sess, GstClockTime max_delay); 330 void (*on_receiving_rtcp) (RTPSession *sess, GstBuffer *buffer); 331 void (*on_new_sender_ssrc) (RTPSession *sess, RTPSource *source); 332 void (*on_sender_ssrc_active) (RTPSession *sess, RTPSource *source); 333 guint (*on_sending_nacks) (RTPSession *sess, guint sender_ssrc, 334 guint media_ssrc, GArray *nacks, GstBuffer *buffer); 335 }; 336 337 GType rtp_session_get_type (void); 338 339 /* create and configure */ 340 RTPSession* rtp_session_new (void); 341 void rtp_session_reset (RTPSession *sess); 342 void rtp_session_set_callbacks (RTPSession *sess, 343 RTPSessionCallbacks *callbacks, 344 gpointer user_data); 345 void rtp_session_set_process_rtp_callback (RTPSession * sess, 346 RTPSessionProcessRTP callback, 347 gpointer user_data); 348 void rtp_session_set_send_rtp_callback (RTPSession * sess, 349 RTPSessionSendRTP callback, 350 gpointer user_data); 351 void rtp_session_set_send_rtcp_callback (RTPSession * sess, 352 RTPSessionSendRTCP callback, 353 gpointer user_data); 354 void rtp_session_set_sync_rtcp_callback (RTPSession * sess, 355 RTPSessionSyncRTCP callback, 356 gpointer user_data); 357 void rtp_session_set_clock_rate_callback (RTPSession * sess, 358 RTPSessionClockRate callback, 359 gpointer user_data); 360 void rtp_session_set_reconsider_callback (RTPSession * sess, 361 RTPSessionReconsider callback, 362 gpointer user_data); 363 void rtp_session_set_request_time_callback (RTPSession * sess, 364 RTPSessionRequestTime callback, 365 gpointer user_data); 366 367 void rtp_session_set_bandwidth (RTPSession *sess, gdouble bandwidth); 368 gdouble rtp_session_get_bandwidth (RTPSession *sess); 369 void rtp_session_set_rtcp_fraction (RTPSession *sess, gdouble fraction); 370 gdouble rtp_session_get_rtcp_fraction (RTPSession *sess); 371 372 GstStructure * rtp_session_get_sdes_struct (RTPSession *sess); 373 void rtp_session_set_sdes_struct (RTPSession *sess, const GstStructure *sdes); 374 375 /* handling sources */ 376 guint32 rtp_session_suggest_ssrc (RTPSession *sess, gboolean *is_random); 377 378 gboolean rtp_session_add_source (RTPSession *sess, RTPSource *src); 379 guint rtp_session_get_num_sources (RTPSession *sess); 380 guint rtp_session_get_num_active_sources (RTPSession *sess); 381 RTPSource* rtp_session_get_source_by_ssrc (RTPSession *sess, guint32 ssrc); 382 383 /* processing packets from receivers */ 384 GstFlowReturn rtp_session_process_rtp (RTPSession *sess, GstBuffer *buffer, 385 GstClockTime current_time, 386 GstClockTime running_time, 387 guint64 ntpnstime); 388 GstFlowReturn rtp_session_process_rtcp (RTPSession *sess, GstBuffer *buffer, 389 GstClockTime current_time, 390 GstClockTime running_time, 391 guint64 ntpnstime); 392 393 /* processing packets for sending */ 394 void rtp_session_update_send_caps (RTPSession *sess, GstCaps *caps); 395 GstFlowReturn rtp_session_send_rtp (RTPSession *sess, gpointer data, gboolean is_list, 396 GstClockTime current_time, GstClockTime running_time); 397 398 /* scheduling bye */ 399 void rtp_session_mark_all_bye (RTPSession *sess, const gchar *reason); 400 GstFlowReturn rtp_session_schedule_bye (RTPSession *sess, GstClockTime current_time); 401 402 /* get interval for next RTCP interval */ 403 GstClockTime rtp_session_next_timeout (RTPSession *sess, GstClockTime current_time); 404 GstFlowReturn rtp_session_on_timeout (RTPSession *sess, GstClockTime current_time, 405 guint64 ntpnstime, GstClockTime running_time); 406 407 /* request the transmittion of an early RTCP packet */ 408 gboolean rtp_session_request_early_rtcp (RTPSession * sess, GstClockTime current_time, 409 GstClockTime max_delay); 410 411 /* Notify session of a request for a new key unit */ 412 gboolean rtp_session_request_key_unit (RTPSession * sess, 413 guint32 ssrc, 414 gboolean fir, 415 gint count); 416 gboolean rtp_session_request_nack (RTPSession * sess, 417 guint32 ssrc, 418 guint16 seqnum, 419 GstClockTime max_delay); 420 421 422 #endif /* __RTP_SESSION_H__ */ 423