You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
288 lines
11 KiB
288 lines
11 KiB
/*
|
|
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 tqmask 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
|