1 files changed, 287 insertions, 0 deletions
diff --git a/kopete/protocols/jabber/jingle/libjingle/talk/third_party/ortp/rtpsession.h b/kopete/protocols/jabber/jingle/libjingle/talk/third_party/ortp/rtpsession.h
new file mode 100644
index 00000000..e7702000
--- /dev/null
+++ b/kopete/protocols/jabber/jingle/libjingle/talk/third_party/ortp/rtpsession.h
@@ -0,0 +1,287 @@
+ /*
+  The oRTP library is an RTP (Realtime Transport Protocol - rfc1889) stack.
+  Copyright (C) 2001  Simon MORLAT simon.morlat@linphone.org
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 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
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser 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 RTPSESSION_H
+#define RTPSESSION_H
+
+
+#include <rtpport.h>
+#include <rtp.h>
+#include <payloadtype.h>
+#include <sessionset.h>
+#include <rtcp.h>
+#include <str_utils.h>
+#include <rtpsignaltable.h>
+
+#include <stdio.h>
+
+
+#ifndef _WIN32
+# include <sys/types.h>
+# include <sys/socket.h>
+# include <errno.h>
+# include <netinet/in.h>
+# ifdef _XOPEN_SOURCE_EXTENDED
+#  include <arpa/inet.h>
+# endif
+# include <unistd.h>
+# include <sys/time.h>
+#else
+# include <winsock2.h>
+#endif   /* _WIN32 */
+
+
+
+typedef enum {
+	RTP_SESSION_RECVONLY,
+	RTP_SESSION_SENDONLY,
+	RTP_SESSION_SENDRECV
+} RtpSessionMode;
+
+
+
+typedef enum {
+	RTP_SESSION_RECV_SYNC=1,	/* the rtp session is synchronising in the incoming stream */
+	RTP_SESSION_SEND_SYNC=1<<1, /* the rtp session is synchronising in the outgoing stream */
+	RTP_SESSION_SCHEDULED=1<<2, /* the rtp session has to be scheduled */
+	RTP_SESSION_BLOCKING_MODE=1<<3, /* in blocking mode */
+	RTP_SESSION_RECV_NOT_STARTED=1<<4,	/* the application has not started to try to recv */
+	RTP_SESSION_SEND_NOT_STARTED=1<<5,  /* the application has not started to send something */
+	RTP_SESSION_IN_SCHEDULER=1<<6,	/* the rtp session is in the scheduler list */
+	RTP_SESSION_USING_EXT_SOCKETS=1<<7 /* the session is using externaly supplied sockets */
+}RtpSessionFlags;
+
+
+typedef struct _JitterControl
+{
+	gint jitt_comp;   /* the user jitt_comp in miliseconds*/
+	gint jitt_comp_ts; /* the jitt_comp converted in rtp time (same unit as timestamp) */
+	gint adapt_jitt_comp_ts;
+	float slide;
+	float jitter;
+	gint count;
+	gint olddiff;
+	float inter_jitter;	/* interarrival jitter as defined in the RFC */
+	gint corrective_step;
+	gint corrective_slide;
+	gboolean adaptive;
+} JitterControl;
+
+typedef struct _WaitPoint
+{
+	GMutex *lock;
+	GCond *cond;
+	guint32 time;
+	gboolean wakeup;
+} WaitPoint;
+	
+typedef struct _RtpStream
+{
+	gint socket;
+	gint socktype;
+	gint max_rq_size;
+	gint time_jump;
+	guint32 ts_jump;
+	queue_t rq;
+	queue_t tev_rq;
+	mblk_t *cached_mp;
+#ifdef INET6
+	struct sockaddr_storage loc_addr;
+	struct sockaddr_storage rem_addr;
+#else
+	struct sockaddr_in loc_addr;
+	struct sockaddr_in rem_addr;
+#endif
+	int addrlen;
+	JitterControl jittctl;
+	guint32 snd_time_offset;/*the scheduler time when the application send its first timestamp*/	
+	guint32 snd_ts_offset;	/* the first application timestamp sent by the application */
+	guint32 snd_rand_offset;	/* a random number added to the user offset to make the stream timestamp*/
+	guint32 snd_last_ts;	/* the last stream timestamp sended */
+	guint32 rcv_time_offset; /*the scheduler time when the application ask for its first timestamp*/
+	guint32 rcv_ts_offset;  /* the first stream timestamp */
+	guint32 rcv_query_ts_offset;	/* the first user timestamp asked by the application */
+	guint32 rcv_diff_ts;	/* difference between the first user timestamp and first stream timestamp */
+	guint32 hwrcv_diff_ts;
+	guint32 rcv_ts;			/* to be unused */
+	guint32 rcv_last_ts;	/* the last stream timestamp got by the application */
+	guint32 rcv_last_app_ts; /* the last application timestamp asked by the application */	
+	guint32 rcv_last_ret_ts; /* the timestamp of the last sample returned (only for continuous audio)*/
+	poly32_t hwrcv_extseq; /* last received on socket extended sequence number */
+	guint32 hwrcv_seq_at_last_SR;
+	guint hwrcv_since_last_SR;
+	guint32 last_rcv_SR_ts;     /* NTP timestamp (middle 32 bits) of last received SR */
+	struct timeval last_rcv_SR_time;   /* time at which last SR was received  */
+	guint16 snd_seq; /* send sequence number */
+	guint32 last_rtcp_report_snt_r;	/* the time of the last rtcp report sent, in recv timestamp unit */
+	guint32 last_rtcp_report_snt_s;	/* the time of the last rtcp report sent, in send timestamp unit */
+	guint32 rtcp_report_snt_interval; /* the interval in timestamp unit between rtcp report sent */
+	rtp_stats_t stats;
+}RtpStream;
+
+typedef struct _RtcpStream
+{
+	gint socket;
+	gint socktype;
+	mblk_t *cached_mp;
+#ifdef INET6
+	struct sockaddr_storage loc_addr;
+	struct sockaddr_storage rem_addr;
+#else
+	struct sockaddr_in loc_addr;
+	struct sockaddr_in rem_addr;
+#endif
+	int addrlen;
+} RtcpStream;
+
+typedef struct _RtpSession RtpSession;
+
+
+
+struct _RtpSession
+{
+	RtpSession *next;	/* next RtpSession, when the session are enqueued by the scheduler */
+	RtpProfile *profile;
+	WaitPoint recv_wp;
+	WaitPoint send_wp;
+	GMutex *lock;
+	guint32 send_ssrc;
+	guint32 recv_ssrc;
+	gint payload_type;
+	gint max_buf_size;
+	RtpSignalTable on_ssrc_changed;
+	RtpSignalTable on_payload_type_changed;
+	RtpSignalTable on_telephone_event_packet;
+	RtpSignalTable on_telephone_event;
+	RtpSignalTable on_timestamp_jump;
+	RtpSignalTable on_network_error;
+	struct _OList *signal_tables;
+	RtpStream rtp;
+	RtcpStream rtcp;
+	RtpSessionMode mode;
+	struct _RtpScheduler *sched;
+	guint32 flags;
+	gint mask_pos;	/* the position in the scheduler mask of RtpSession */
+	gpointer user_data;
+	
+	/* telephony events extension */
+	gint telephone_events_pt;	/* the payload type used for telephony events */
+	mblk_t *current_tev;		/* the pending telephony events */
+	mblk_t *sd;
+	queue_t contributing_sources;
+};
+	
+
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*private */
+void rtp_session_init(RtpSession *session, gint mode);
+#define rtp_session_lock(session) 	g_mutex_lock(session->lock)
+#define rtp_session_unlock(session) g_mutex_unlock(session->lock)
+#define rtp_session_set_flag(session,flag) (session)->flags|=(flag)
+#define rtp_session_unset_flag(session,flag) (session)->flags&=~(flag)
+void rtp_session_uninit(RtpSession *session);
+
+/* public API */
+RtpSession *rtp_session_new(gint mode);
+void rtp_session_set_scheduling_mode(RtpSession *session, gint yesno);
+void rtp_session_set_blocking_mode(RtpSession *session, gint yesno);
+void rtp_session_set_profile(RtpSession *session,RtpProfile *profile);
+#define rtp_session_get_profile(session)	(session)->profile
+int rtp_session_signal_connect(RtpSession *session,const gchar *signal, RtpCallback cb, gpointer user_data);
+int rtp_session_signal_disconnect_by_callback(RtpSession *session,const gchar *signal, RtpCallback cb);
+void rtp_session_set_ssrc(RtpSession *session, guint32 ssrc);
+void rtp_session_set_seq_number(RtpSession *session, guint16 seq);
+guint16 rtp_session_get_seq_number(RtpSession *session);
+void rtp_session_set_jitter_compensation(RtpSession *session, int milisec);
+void rtp_session_enable_adaptive_jitter_compensation(RtpSession *session, gboolean val);
+gboolean rtp_session_adaptive_jitter_compensation_enabled(RtpSession *session);
+void rtp_session_set_time_jump_limit(RtpSession *session, gint miliseconds);
+int rtp_session_set_local_addr(RtpSession *session,const gchar *addr, gint port);
+gint rtp_session_set_remote_addr(RtpSession *session,const gchar *addr, gint port);
+/* alternatively to the set_remote_addr() and set_local_addr(), an application can give
+a valid socket (potentially connect()ed )to be used by the RtpSession */
+void rtp_session_set_sockets(RtpSession *session, gint rtpfd, gint rtcpfd);
+int rtp_session_set_payload_type(RtpSession *session, int paytype);
+int rtp_session_get_payload_type(RtpSession *session);
+int rtp_session_set_payload_type_with_string (RtpSession * session, const char * mime);
+/*low level recv and send functions */
+mblk_t * rtp_session_recvm_with_ts (RtpSession * session, guint32 user_ts);
+mblk_t * rtp_session_create_packet(RtpSession *session,gint header_size, const char *payload, gint payload_size);
+mblk_t * rtp_session_create_packet_with_data(RtpSession *session, char *payload, gint payload_size, void (*freefn)(void*));
+mblk_t * rtp_session_create_packet_in_place(RtpSession *session,char *buffer, gint size, void (*freefn)(void*) );
+gint rtp_session_sendm_with_ts (RtpSession * session, mblk_t *mp, guint32 userts);
+/* high level recv and send functions */
+gint rtp_session_recv_with_ts(RtpSession *session, gchar *buffer, gint len, guint32 time, gint *have_more);
+gint rtp_session_send_with_ts(RtpSession *session, const gchar *buffer, gint len, guint32 userts);
+
+
+guint32 rtp_session_get_current_send_ts(RtpSession *session);
+guint32 rtp_session_get_current_recv_ts(RtpSession *session);
+void rtp_session_flush_sockets(RtpSession *session);
+void rtp_session_reset(RtpSession *session);
+void rtp_session_destroy(RtpSession *session);
+
+#define rtp_session_get_stats(session) (&(session)->stats)
+#define rtp_session_reset_stats(session)	memset(&(session)->stats,0,sizeof(rtp_stats_t))
+#define rtp_session_set_data(session,data)	(session)->user_data=(data)
+#define rtp_session_get_data(session,data)	((session)->user_data)
+
+#define rtp_session_max_buf_size_set(session,bufsize)	(session)->max_buf_size=(bufsize)
+
+/* in use with the scheduler to convert a timestamp in scheduler time unit (ms) */
+guint32 rtp_session_ts_to_time(RtpSession *session,guint32 timestamp);
+guint32 rtp_session_time_to_ts(RtpSession *session, gint time);
+/* this function aims at simulating senders with "imprecise" clocks, resulting in 
+rtp packets sent with timestamp uncorrelated with the system clock .
+This is only availlable to sessions working with the oRTP scheduler */
+void rtp_session_make_time_distorsion(RtpSession *session, gint milisec);
+
+/*RTCP functions */
+void rtp_session_set_source_description(RtpSession *session, const gchar *cname,
+	const gchar *name, const gchar *email, const gchar *phone, 
+    const gchar *loc, const gchar *tool, const gchar *note);
+void rtp_session_add_contributing_source(RtpSession *session, guint32 csrc, 
+    const gchar *cname, const gchar *name, const gchar *email, const gchar *phone, 
+    const gchar *loc, const gchar *tool, const gchar *note);
+void rtp_session_remove_contributing_sources(RtpSession *session, guint32 csrc);
+mblk_t* rtp_session_create_rtcp_sdes_packet(RtpSession *session);
+
+
+/* packet api */
+/* the first argument is a mblk_t. The header is supposed to be not splitted  */
+#define rtp_set_markbit(mp,value)		((rtp_header_t*)((mp)->b_rptr))->markbit=(value)
+#define rtp_set_seqnumber(mp,seq)	((rtp_header_t*)((mp)->b_rptr))->seq_number=(seq)
+#define rtp_set_timestamp(mp,ts)	((rtp_header_t*)((mp)->b_rptr))->timestamp=(ts)
+#define rtp_set_ssrc(mp,_ssrc)		((rtp_header_t*)((mp)->b_rptr))->ssrc=(_ssrc)
+void rtp_add_csrc(mblk_t *mp,guint32 csrc);
+#define rtp_set_payload_type(mp,pt)	((rtp_header_t*)((mp)->b_rptr))->paytype=(pt)
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif