void linphone_call_init_media_streams(LinphoneCall *call){
LinphoneCore *lc=call->core;
SalMediaDescription *md=call->localdesc;
AudioStream *audiostream;
call->audiostream=audiostream=audio_stream_new(md->streams[0].port,linphone_core_ipv6_enabled(lc));
if (linphone_core_echo_limiter_enabled(lc)){
const char *type=lp_config_get_string(lc->config,"sound","el_type","mic");
if (strcasecmp(type,"mic")==0)
audio_stream_enable_echo_limiter(audiostream,ELControlMic);
else if (strcasecmp(type,"full")==0)
audio_stream_enable_echo_limiter(audiostream,ELControlFull);
}
audio_stream_enable_gain_control(audiostream,TRUE);
if (linphone_core_echo_cancellation_enabled(lc)){
int len,delay,framesize;
const char *statestr=lp_config_get_string(lc->config,"sound","ec_state",NULL);
len=lp_config_get_int(lc->config,"sound","ec_tail_len",0);
delay=lp_config_get_int(lc->config,"sound","ec_delay",0);
framesize=lp_config_get_int(lc->config,"sound","ec_framesize",0);
audio_stream_set_echo_canceller_params(audiostream,len,delay,framesize);
if (statestr && audiostream->ec){
ms_filter_call_method(audiostream->ec,MS_ECHO_CANCELLER_SET_STATE_STRING,(void*)statestr);
}
}
audio_stream_enable_automatic_gain_control(audiostream,linphone_core_agc_enabled(lc));
{
int enabled=lp_config_get_int(lc->config,"sound","noisegate",0);
audio_stream_enable_noise_gate(audiostream,enabled);
}
if (lc->a_rtp)
rtp_session_set_transports(audiostream->session,lc->a_rtp,lc->a_rtcp);
call->audiostream_app_evq = ortp_ev_queue_new();
rtp_session_register_event_queue(audiostream->session,call->audiostream_app_evq);
#ifdef VIDEO_ENABLED
if ((lc->video_conf.display || lc->video_conf.capture) && md->streams[1].port>0){
call->videostream=video_stream_new(md->streams[1].port,linphone_core_ipv6_enabled(lc));
if( lc->video_conf.displaytype != NULL)
video_stream_set_display_filter_name(call->videostream,lc->video_conf.displaytype);
video_stream_set_event_callback(call->videostream,video_stream_event_cb, call);
if (lc->v_rtp)
rtp_session_set_transports(call->videostream->session,lc->v_rtp,lc->v_rtcp);
call->videostream_app_evq = ortp_ev_queue_new();
rtp_session_register_event_queue(call->videostream->session,call->videostream_app_evq);
#ifdef TEST_EXT_RENDERER
video_stream_set_render_callback(call->videostream,rendercb,NULL);
#endif
}
#else
call->videostream=NULL;
#endif
}
static UDT_transport *UDT_transport_connecting(RtpSession *session)
{
RtpTransport * rtp_transport = NULL;
libudt_init_check();
UDT_transport *udt = UDT_transport_new();
UDT_transport_set_rtp_session(udt,session);
if(UDT_transport_connect(udt) < 0)
{
UDT_transport_disconnect(udt);
ms_message("Can't start udt transport !!");
udt =NULL;
return NULL;
}
else
{
rtp_transport = UDT_create_rtp_transport(udt);
if(rtp_transport){
rtp_session_set_transports(session,rtp_transport,NULL);
ms_message("enable mediastreamer2 udt transport !!");
udt->run = TRUE;
ms_thread_create(&udt->monitor_thread,NULL,&monitor,udt);
}
return udt;
}
}
static OrtpZrtpContext* ortp_zrtp_configure_context(OrtpZrtpContext *userData, RtpSession *s, OrtpZrtpParams *params) {
ZrtpContext *context=userData->zrtpContext;
if (s->rtp.tr || s->rtcp.tr)
ortp_warning("Overwriting rtp or rtcp transport with ZRTP one");
userData->rtpt.data=context;
userData->rtpt.t_getsocket=ozrtp_rtp_getsocket;
userData->rtpt.t_sendto=ozrtp_rtp_sendto;
userData->rtpt.t_recvfrom=ozrtp_rtp_recvfrom;
userData->rtcpt.data=context;
userData->rtcpt.t_getsocket=ozrtp_rtcp_getsocket;
userData->rtcpt.t_sendto=ozrtp_rtcp_sendto;
userData->rtcpt.t_recvfrom=ozrtp_rtcp_recvfrom;
rtp_session_set_transports(s, &userData->rtpt, &userData->rtcpt);
ortp_message("Starting ZRTP engine");
zrtp_setEnrollmentMode(context,FALSE);//because it is uninitialized in zrtpcpp.
zrtp_startZrtpEngine(context);
return userData;
}
void ms_media_stream_sessions_uninit(MSMediaStreamSessions *sessions){
if (sessions->srtp_session) {
RtpTransport *rtptr=NULL,*rtcptr=NULL;
ortp_srtp_dealloc(sessions->srtp_session);
if (sessions->rtp_session){
rtp_session_get_transports(sessions->rtp_session,&rtptr,&rtcptr);
rtp_session_set_transports(sessions->rtp_session,NULL,NULL);
if (rtptr) srtp_transport_destroy(rtptr);
if (rtcptr) srtp_transport_destroy(rtcptr);
}
sessions->srtp_session=NULL;
}
if (sessions->rtp_session) {
rtp_session_destroy(sessions->rtp_session);
sessions->rtp_session=NULL;
}
if (sessions->zrtp_context != NULL) {
ortp_zrtp_context_destroy(sessions->zrtp_context);
sessions->zrtp_context = NULL;
}
if (sessions->ticker){
ms_ticker_destroy(sessions->ticker);
sessions->ticker=NULL;
}
}
bool_t video_stream_enable_strp(VideoStream* stream, enum ortp_srtp_crypto_suite_t suite, const char* snd_key, const char* rcv_key) {
// assign new srtp transport to stream->session
// with 2 Master Keys
RtpTransport *rtp_tpt, *rtcp_tpt;
if (!ortp_srtp_supported()) {
ms_error("ortp srtp support not enabled");
return FALSE;
}
ms_message("%s: stream=%p key='%s' key='%s'", __FUNCTION__,
stream, snd_key, rcv_key);
stream->srtp_session = ortp_srtp_create_configure_session(suite,
rtp_session_get_send_ssrc(stream->session),
snd_key,
rcv_key);
if (!stream->srtp_session) {
return FALSE;
}
// TODO: check who will free rtp_tpt ?
srtp_transport_new(stream->srtp_session, &rtp_tpt, &rtcp_tpt);
rtp_session_set_transports(stream->session, rtp_tpt, rtcp_tpt);
return TRUE;
}
static int check_srtp_session_created(MediaStream *stream){
if (stream->sessions.srtp_session==NULL){
err_status_t err;
srtp_t session;
RtpTransport *rtp=NULL,*rtcp=NULL;
err = ortp_srtp_create(&session, NULL);
if (err != 0) {
ms_error("Failed to create srtp session (%d)", err);
return -1;
}
stream->sessions.srtp_session=session;
srtp_transport_new(session,&rtp,&rtcp);
rtp_session_set_transports(stream->sessions.rtp_session,rtp,rtcp);
stream->sessions.is_secured=TRUE;
}
return 0;
}
