rtpsession: Keep local conflicting addresses in the session
[platform/upstream/gst-plugins-good.git] / gst / rtpmanager / rtpsession.h
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  * @buffer: the RTP buffer ready for sending
60  * @user_data: user data specified when registering
61  *
62  * This callback will be called when @sess has @buffer ready for sending to
63  * 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  * @all_headers: %TRUE if "all-headers" property should be set on the key unit
125  *  request
126  * @user_data: user data specified when registering
127  *
128  * Asks the encoder to produce a key unit as soon as possibly within the
129  * bandwidth constraints
130  */
131 typedef void (*RTPSessionRequestKeyUnit) (RTPSession *sess,
132     gboolean all_headers, gpointer user_data);
133
134 /**
135  * RTPSessionRequestTime:
136  * @sess: an #RTPSession
137  * @user_data: user data specified when registering
138  *
139  * This callback will be called when @sess needs the current time. The time
140  * should be returned as a #GstClockTime
141  */
142 typedef GstClockTime (*RTPSessionRequestTime) (RTPSession *sess,
143     gpointer user_data);
144
145 /**
146  * RTPSessionNotifyNACK:
147  * @sess: an #RTPSession
148  * @seqnum: the missing seqnum
149  * @blp: other missing seqnums
150  * @ssrc: SSRC of requested stream
151  * @user_data: user data specified when registering
152  *
153  * Notifies of NACKed frames.
154  */
155 typedef void (*RTPSessionNotifyNACK) (RTPSession *sess,
156     guint16 seqnum, guint16 blp, guint32 ssrc, gpointer user_data);
157
158 /**
159  * RTPSessionReconfigure:
160  * @sess: an #RTPSession
161  * @user_data: user data specified when registering
162  *
163  * This callback will be called when @sess wants to reconfigure the
164  * negotiated parameters.
165  */
166 typedef void (*RTPSessionReconfigure) (RTPSession *sess, gpointer user_data);
167
168 /**
169  * RTPSessionCallbacks:
170  * @RTPSessionProcessRTP: callback to process RTP packets
171  * @RTPSessionSendRTP: callback for sending RTP packets
172  * @RTPSessionSendRTCP: callback for sending RTCP packets
173  * @RTPSessionSyncRTCP: callback for handling SR packets
174  * @RTPSessionReconsider: callback for reconsidering the timeout
175  * @RTPSessionRequestKeyUnit: callback for requesting a new key unit
176  * @RTPSessionRequestTime: callback for requesting the current time
177  * @RTPSessionNotifyNACK: callback for notifying NACK
178  * @RTPSessionReconfigure: callback for requesting reconfiguration
179  *
180  * These callbacks can be installed on the session manager to get notification
181  * when RTP and RTCP packets are ready for further processing. These callbacks
182  * are not implemented with signals for performance reasons.
183  */
184 typedef struct {
185   RTPSessionProcessRTP  process_rtp;
186   RTPSessionSendRTP     send_rtp;
187   RTPSessionSyncRTCP    sync_rtcp;
188   RTPSessionSendRTCP    send_rtcp;
189   RTPSessionClockRate   clock_rate;
190   RTPSessionReconsider  reconsider;
191   RTPSessionRequestKeyUnit request_key_unit;
192   RTPSessionRequestTime request_time;
193   RTPSessionNotifyNACK  notify_nack;
194   RTPSessionReconfigure reconfigure;
195 } RTPSessionCallbacks;
196
197 /**
198  * RTPSession:
199  * @lock: lock to protect the session
200  * @source: the source of this session
201  * @ssrcs: Hashtable of sources indexed by SSRC
202  * @num_sources: the number of sources
203  * @activecount: the number of active sources
204  * @callbacks: callbacks
205  * @user_data: user data passed in callbacks
206  * @stats: session statistics
207  * @conflicting_addresses: GList of conflicting addresses
208  *
209  * The RTP session manager object
210  */
211 struct _RTPSession {
212   GObject       object;
213
214   GMutex        lock;
215
216   guint         header_len;
217   guint         mtu;
218
219   GstStructure *sdes;
220
221   guint         probation;
222
223   /* bandwidths */
224   gboolean     recalc_bandwidth;
225   guint        bandwidth;
226   gdouble      rtcp_bandwidth;
227   guint        rtcp_rr_bandwidth;
228   guint        rtcp_rs_bandwidth;
229
230   guint32       suggested_ssrc;
231
232   /* for sender/receiver counting */
233   guint32       key;
234   guint32       mask_idx;
235   guint32       mask;
236   GHashTable   *ssrcs[32];
237   guint         total_sources;
238
239   guint16       generation;
240   GstClockTime  next_rtcp_check_time;
241   GstClockTime  last_rtcp_send_time;
242   GstClockTime  start_time;
243   gboolean      first_rtcp;
244   gboolean      allow_early;
245
246   GstClockTime  next_early_rtcp_time;
247
248   gboolean      scheduled_bye;
249
250   RTPSessionCallbacks   callbacks;
251   gpointer              process_rtp_user_data;
252   gpointer              send_rtp_user_data;
253   gpointer              send_rtcp_user_data;
254   gpointer              sync_rtcp_user_data;
255   gpointer              clock_rate_user_data;
256   gpointer              reconsider_user_data;
257   gpointer              request_key_unit_user_data;
258   gpointer              request_time_user_data;
259   gpointer              notify_nack_user_data;
260   gpointer              reconfigure_user_data;
261
262   RTPSessionStats stats;
263   RTPSessionStats bye_stats;
264
265   gboolean      favor_new;
266   GstClockTime  rtcp_feedback_retention_window;
267   guint         rtcp_immediate_feedback_threshold;
268
269   GstClockTime last_keyframe_request;
270   gboolean     last_keyframe_all_headers;
271
272   gboolean      is_doing_ptp;
273
274   GList         *conflicting_addresses;
275 };
276
277 /**
278  * RTPSessionClass:
279  * @on_new_ssrc: emited when a new source is found
280  * @on_bye_ssrc: emited when a source is gone
281  *
282  * The session class.
283  */
284 struct _RTPSessionClass {
285   GObjectClass   parent_class;
286
287   /* action signals */
288   RTPSource* (*get_source_by_ssrc) (RTPSession *sess, guint32 ssrc);
289
290   /* signals */
291   void (*on_new_ssrc)       (RTPSession *sess, RTPSource *source);
292   void (*on_ssrc_collision) (RTPSession *sess, RTPSource *source);
293   void (*on_ssrc_validated) (RTPSession *sess, RTPSource *source);
294   void (*on_ssrc_active)    (RTPSession *sess, RTPSource *source);
295   void (*on_ssrc_sdes)      (RTPSession *sess, RTPSource *source);
296   void (*on_bye_ssrc)       (RTPSession *sess, RTPSource *source);
297   void (*on_bye_timeout)    (RTPSession *sess, RTPSource *source);
298   void (*on_timeout)        (RTPSession *sess, RTPSource *source);
299   void (*on_sender_timeout) (RTPSession *sess, RTPSource *source);
300   gboolean (*on_sending_rtcp) (RTPSession *sess, GstBuffer *buffer,
301       gboolean early);
302   void (*on_feedback_rtcp)  (RTPSession *sess, guint type, guint fbtype,
303       guint sender_ssrc, guint media_ssrc, GstBuffer *fci);
304   void (*send_rtcp)         (RTPSession *sess, GstClockTime max_delay);
305 };
306
307 GType rtp_session_get_type (void);
308
309 /* create and configure */
310 RTPSession*     rtp_session_new           (void);
311 void            rtp_session_set_callbacks          (RTPSession *sess,
312                                                     RTPSessionCallbacks *callbacks,
313                                                     gpointer user_data);
314 void            rtp_session_set_process_rtp_callback   (RTPSession * sess,
315                                                     RTPSessionProcessRTP callback,
316                                                     gpointer user_data);
317 void            rtp_session_set_send_rtp_callback  (RTPSession * sess,
318                                                     RTPSessionSendRTP callback,
319                                                     gpointer user_data);
320 void            rtp_session_set_send_rtcp_callback   (RTPSession * sess,
321                                                     RTPSessionSendRTCP callback,
322                                                     gpointer user_data);
323 void            rtp_session_set_sync_rtcp_callback   (RTPSession * sess,
324                                                     RTPSessionSyncRTCP callback,
325                                                     gpointer user_data);
326 void            rtp_session_set_clock_rate_callback   (RTPSession * sess,
327                                                     RTPSessionClockRate callback,
328                                                     gpointer user_data);
329 void            rtp_session_set_reconsider_callback (RTPSession * sess,
330                                                     RTPSessionReconsider callback,
331                                                     gpointer user_data);
332 void            rtp_session_set_request_time_callback (RTPSession * sess,
333                                                     RTPSessionRequestTime callback,
334                                                     gpointer user_data);
335
336 void            rtp_session_set_bandwidth          (RTPSession *sess, gdouble bandwidth);
337 gdouble         rtp_session_get_bandwidth          (RTPSession *sess);
338 void            rtp_session_set_rtcp_fraction      (RTPSession *sess, gdouble fraction);
339 gdouble         rtp_session_get_rtcp_fraction      (RTPSession *sess);
340
341 GstStructure *  rtp_session_get_sdes_struct        (RTPSession *sess);
342 void            rtp_session_set_sdes_struct        (RTPSession *sess, const GstStructure *sdes);
343
344 /* handling sources */
345 guint32         rtp_session_suggest_ssrc           (RTPSession *sess);
346
347 gboolean        rtp_session_add_source             (RTPSession *sess, RTPSource *src);
348 guint           rtp_session_get_num_sources        (RTPSession *sess);
349 guint           rtp_session_get_num_active_sources (RTPSession *sess);
350 RTPSource*      rtp_session_get_source_by_ssrc     (RTPSession *sess, guint32 ssrc);
351 RTPSource*      rtp_session_create_source          (RTPSession *sess);
352
353 /* processing packets from receivers */
354 GstFlowReturn   rtp_session_process_rtp            (RTPSession *sess, GstBuffer *buffer,
355                                                     GstClockTime current_time,
356                                                     GstClockTime running_time,
357                                                     guint64 ntpnstime);
358 GstFlowReturn   rtp_session_process_rtcp           (RTPSession *sess, GstBuffer *buffer,
359                                                     GstClockTime current_time,
360                                                     guint64 ntpnstime);
361
362 /* processing packets for sending */
363 void            rtp_session_update_send_caps       (RTPSession *sess, GstCaps *caps);
364 GstFlowReturn   rtp_session_send_rtp               (RTPSession *sess, gpointer data, gboolean is_list,
365                                                     GstClockTime current_time, GstClockTime running_time);
366
367 /* scheduling bye */
368 void            rtp_session_mark_all_bye           (RTPSession *sess, const gchar *reason);
369 GstFlowReturn   rtp_session_schedule_bye           (RTPSession *sess, GstClockTime current_time);
370
371 /* get interval for next RTCP interval */
372 GstClockTime    rtp_session_next_timeout           (RTPSession *sess, GstClockTime current_time);
373 GstFlowReturn   rtp_session_on_timeout             (RTPSession *sess, GstClockTime current_time,
374                                                     guint64 ntpnstime, GstClockTime running_time);
375
376 /* request the transmittion of an early RTCP packet */
377 void            rtp_session_request_early_rtcp     (RTPSession * sess, GstClockTime current_time,
378                                                     GstClockTime max_delay);
379
380 /* Notify session of a request for a new key unit */
381 gboolean        rtp_session_request_key_unit       (RTPSession * sess,
382                                                     guint32 ssrc,
383                                                     gboolean fir,
384                                                     gint count);
385 gboolean        rtp_session_request_nack           (RTPSession * sess,
386                                                     guint32 ssrc,
387                                                     guint16 seqnum,
388                                                     GstClockTime max_delay);
389
390
391 #endif /* __RTP_SESSION_H__ */