ortplib

/* The oRTP library is an RTP (Realtime Transport Protocol - rfc3550) 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 */ #include "ortp/ortp.h" #include "ortp/telephonyevents.h" #include "rtpmod.h" #include "jitterctl.h" #include "scheduler.h" #include "utils.h" #include "ortp-config.h" #include <WinDef.h> #ifdef _WIN32 extern inet_aton (const char * cp, struct in_addr * addr); #endif #if defined(HAVE_POLL_H) #include <poll.h> #elif defined(HAVE_SYS_POLL_H) #include <sys/poll.h> #endif #ifdef HAVE_SYS_UIO_H #include <sys/uio.h> #define USE_SENDMSG 1 #endif #define ORTP_VERSION 0.9.1 /* this function initialize all session parameter's that depend on the payload type */ static void payload_type_changed(RtpSession *session, PayloadType *pt){ jitter_control_set_payload(&session->rtp.jittctl,pt); session->rtp.rtcp_report_snt_interval=RTCP_DEFAULT_REPORT_INTERVAL*pt->clock_rate; rtp_session_set_time_jump_limit(session,session->rtp.time_jump); } void wait_point_init(WaitPoint *wp){ ortp_mutex_init(&wp->lock,NULL); ortp_cond_init(&wp->cond,NULL); wp->time=0; wp->wakeup=FALSE; } void wait_point_uninit(WaitPoint *wp){ ortp_cond_destroy(&wp->cond); ortp_mutex_destroy(&wp->lock); } #define wait_point_lock(wp) ortp_mutex_lock(&(wp)->lock) #define wait_point_unlock(wp) ortp_mutex_unlock(&(wp)->lock) void wait_point_wakeup_at(WaitPoint *wp, uint32_t t, bool_t dosleep){ wp->time=t; wp->wakeup=TRUE; if (dosleep) ortp_cond_wait(&wp->cond,&wp->lock); } bool_t wait_point_check(WaitPoint *wp, uint32_t t){ bool_t ok=FALSE; if (wp->wakeup){ if (TIME_IS_NEWER_THAN(t,wp->time)){ wp->wakeup=FALSE; ok=TRUE; } } return ok; } #define wait_point_wakeup(wp) ortp_cond_signal(&(wp)->cond); extern void rtp_parse(RtpSession *session, mblk_t *mp, uint32_t local_str_ts); static uint32_t uint32_t_random(){ return random(); } void rtp_session_init (RtpSession * session, int mode) { memset (session, 0, sizeof (RtpSession)); ortp_mutex_init(&session->lock,NULL); session->rtp.max_rq_size = 100;/* maximum number of packet allowed to be queued */ session->mode = (RtpSessionMode) mode; if ((mode == RTP_SESSION_RECVONLY) || (mode == RTP_SESSION_SENDRECV)) { rtp_session_set_flag (session, RTP_SESSION_RECV_SYNC); rtp_session_set_flag (session, RTP_SESSION_RECV_NOT_STARTED); } if ((mode == RTP_SESSION_SENDONLY) || (mode == RTP_SESSION_SENDRECV)) { rtp_session_set_flag (session, RTP_SESSION_SEND_NOT_STARTED); rtp_session_set_flag (session, RTP_SESSION_SEND_SYNC); session->send_ssrc=uint32_t_random(); /* set default source description */ rtp_session_set_source_description(session,"unknown@unknown",NULL,NULL, NULL,NULL,"oRTP-0.9.1","This is free sofware (LGPL) !"); } session->telephone_events_pt=-1; /* not defined a priori */ rtp_session_set_profile (session, &av_profile); /*the default profile to work with */ session->rtp.socket=-1; session->rtcp.socket=-1; qinit(&session->rtp.rq); qinit(&session->rtp.tev_rq); qinit(&session->contributing_sources); /* init signal tables */ rtp_signal_table_init (&session->on_ssrc_changed, session,"ssrc_changed"); rtp_signal_table_init (&session->on_payload_type_changed, session,"payload_type_changed"); rtp_signal_table_init (&session->on_telephone_event, session,"telephone-event"); rtp_signal_table_init (&session->on_telephone_event_packet, session,"telephone-event_packet"); rtp_signal_table_init (&session->on_timestamp_jump,session,"timestamp_jump"); rtp_signal_table_init (&session->on_network_error,session,"network_error"); rtp_signal_table_init (&session->on_rtcp_bye,session,"rtcp_bye"); wait_point_init(&session->send_wp); wait_point_init(&session->recv_wp); /*defaults send payload type to 0 (pcmu)*/ rtp_session_set_send_payload_type(session,0); /*sets supposed recv payload type to undefined */ rtp_session_set_recv_payload_type(session,-1); rtp_session_set_jitter_compensation(session,RTP_DEFAULT_JITTER_TIME); rtp_session_enable_adaptive_jitter_compensation(session,FALSE); rtp_session_set_time_jump_limit(session,5000); session->recv_buf_size = UDP_MAX_SIZE; } /** *rtp_session_new: *@mode: One of the #RtpSessionMode flags. * * Creates a new rtp session. * If the session is able to send data (RTP_SESSION_SENDONLY or RTP_SESSION_SENDRECV), then a * random SSRC number is choosed for the outgoing stream. * *Returns: the newly created rtp session. **/ RtpSession * rtp_session_new (int mode) { RtpSession *session; session = (RtpSession *) ortp_malloc (sizeof (RtpSession)); rtp_session_init (session, mode); return session; } /** *rtp_session_set_scheduling_mode: *@session: a rtp session. *@yesno: a boolean to indicate the scheduling mode. * * Sets the scheduling mode of the rtp session. If @yesno is TRUE, the rtp session is in * the scheduled mode, that means that you can use session_set_select() to block until it's time * to receive or send on this session according to the timestamp passed to the respective functions. * You can also use blocking mode (see rtp_session_set_blocking_mode() ), to simply block within * the receive and send functions. * If @yesno is FALSE, the ortp scheduler will not manage those sessions, meaning that blocking mode * and the use of session_set_select() for this session are disabled. * **/ void rtp_session_set_scheduling_mode (RtpSession * session, int yesno) { if (yesno) { RtpScheduler *sched; sched = ortp_get_scheduler (); if (sched != NULL) { rtp_session_set_flag (session, RTP_SESSION_SCHEDULED); session->sched = sched; rtp_scheduler_add_session (sched, session); } else ortp_warning ("rtp_session_set_scheduling_mode: Cannot use scheduled mode because the " "scheduler is not started. Use ortp_scheduler_init() before."); } else rtp_session_unset_flag (session, RTP_SESSION_SCHEDULED); } /** *rtp_session_set_blocking_mode: *@session: a rtp session *@yesno: a boolean * * Using this function implies that you previously enabled scheduled mode on the session * (see rtp_session_set_scheduling_mode() ). * rtp_session_set_blocking_mode() defines the behaviour of the rtp_session_recv_with_ts() and * rtp_session_send_with_ts() functions. If @yesno is TRUE, rtp_session_recv_with_ts() * will block until it is time for the packet to be received, according to the timestamp * passed to the function. After this time, the function returns. * For rtp_session_send_with_ts(), it will block until it is time for the packet to be sent. * If @yesno is FALSE, then the two functions will return immediately. * **/ void rtp_session_set_blocking_mode (RtpSession * session, int yesno) { if (yesno) rtp_session_set_flag (session, RTP_SESSION_BLOCKING_MODE); else rtp_session_unset_flag (session, RTP_SESSION_BLOCKING_MODE); } /** *rtp_session_set_profile: *@session: a rtp session *@profile: a rtp profile * * Set the RTP profile to be used for the session. By default, all session are created by * rtp_session_new() are