RtpSession* rtp_listen(const char *remote_addr, unsigned short remote_port) { RtpSession *rtpSession; recv_ts=0; send_ts=0; rtpSession=rtp_session_new(RTP_SESSION_SENDRECV); rtp_session_set_scheduling_mode(rtpSession,TRUE); rtp_session_set_blocking_mode(rtpSession,FALSE); #ifdef HAVE_RTCP_ORTP rtp_session_set_local_addr(rtpSession,INADDR_DSPSERVER,LOCAL_RTP_PORT,LOCAL_RTCP_PORT); #else rtp_session_set_local_addr(rtpSession,INADDR_DSPSERVER,LOCAL_RTP_PORT); #endif rtp_session_set_remote_addr(rtpSession, remote_addr, remote_port ); rtp_session_set_connected_mode(rtpSession,TRUE); rtp_session_set_symmetric_rtp(rtpSession,TRUE); rtp_session_enable_adaptive_jitter_compensation(rtpSession,adapt); rtp_session_set_jitter_compensation(rtpSession,jittcomp); rtp_session_set_payload_type(rtpSession,0); rtp_session_set_time_jump_limit (rtpSession, timestamp_jump_limit); //rtp_session_signal_connect(rtpSession,"ssrc_changed",(RtpCallback)ssrc_cb,0); rtp_session_signal_connect(rtpSession,"ssrc_changed",(RtpCallback)rtp_session_reset,0); rtp_session_signal_connect(rtpSession,"timestamp_jump",(RtpCallback)rtp_session_resync,0); rtp_listening = 1; rtp_connected = 1; return rtpSession; }
int main(int argc, char *argv[]) { RtpSession *session; unsigned char buffer[160]; int i; FILE *infile; char *ssrc; uint32_t user_ts=0; int tel=0; if (argc<4){ printf(help); return -1; } ortp_init(); ortp_scheduler_init(); /* set the telephony event payload type to 96 in the av profile.*/ rtp_profile_set_payload(&av_profile,96,&payload_type_telephone_event); session=rtp_session_new(RTP_SESSION_SENDONLY); rtp_session_set_scheduling_mode(session,1); rtp_session_set_blocking_mode(session,1); rtp_session_set_remote_addr(session,argv[2],atoi(argv[3])); rtp_session_set_send_payload_type(session,0); ssrc=getenv("SSRC"); if (ssrc!=NULL) { printf("using SSRC=%i.\n",atoi(ssrc)); rtp_session_set_ssrc(session,atoi(ssrc)); } infile=fopen(argv[1],"rb"); if (infile==NULL) { perror("Cannot open file"); return -1; } signal(SIGINT,stophandler); while( ((i=fread(buffer,1,160,infile))>0) && (runcond) ) { //ortp_message("Sending packet."); rtp_session_send_with_ts(session,buffer,i,user_ts); user_ts+=160; tel++; if (tel==50){ tel=0; ortp_message("Sending telephony event packet."); rtp_session_send_dtmf(session,'*',user_ts); user_ts+=160+160+160; /* the duration of the dtmf */ } } fclose(infile); rtp_session_destroy(session); ortp_exit(); ortp_global_stats_display(); return 0; }
int main(int argc, char *argv[]) { RtpSession *session; unsigned char buffer[160]; int err; FILE *outfile; uint32_t ts=0; int have_more; if (argc<3){ printf("%s",help); return -1; } ortp_init(); ortp_scheduler_init(); /* set the telephony event payload type to 96 in the av profile.*/ rtp_profile_set_payload(&av_profile,96,&payload_type_telephone_event); session=rtp_session_new(RTP_SESSION_RECVONLY); rtp_session_set_scheduling_mode(session,1); rtp_session_set_blocking_mode(session,1); rtp_session_set_local_addr(session,"0.0.0.0",atoi(argv[2])); rtp_session_set_payload_type(session,0); /* register for telephony events */ rtp_session_signal_connect(session,"telephone-event",(RtpCallback)recv_tev_cb,0); outfile=fopen(argv[1],"wb"); if (outfile==NULL) { perror("Cannot open file"); return -1; } signal(SIGINT,stophandler); while(runcond) { have_more=1; while (have_more){ err=rtp_session_recv_with_ts(session,buffer,160,ts,&have_more); if (err>0) { size_t ret = fwrite(buffer,1,err,outfile); assert( ret == err ); } } ts+=160; //ortp_message("Receiving packet."); } fclose(outfile); rtp_session_destroy(session); ortp_exit(); ortp_global_stats_display(); printf("Total dtmf events received: %i\n",dtmf_count); return 0; }
void MastTool::enable_scheduling() { // Enable packet scheduling ortp_scheduler_init(); // Enable session scheduling and blocking rtp_session_set_scheduling_mode(session, TRUE); rtp_session_set_blocking_mode(session, TRUE); }
RtpSession * create_duplex_rtpsession( int locport, bool_t ipv6){ RtpSession *rtpr; rtpr=rtp_session_new(RTP_SESSION_SENDRECV); rtp_session_set_recv_buf_size(rtpr,MAX_RTP_SIZE); rtp_session_set_scheduling_mode(rtpr,0); rtp_session_set_blocking_mode(rtpr,0); rtp_session_enable_adaptive_jitter_compensation(rtpr,TRUE); rtp_session_set_symmetric_rtp(rtpr,TRUE); rtp_session_set_local_addr(rtpr,ipv6 ? "::" : "0.0.0.0",locport); rtp_session_signal_connect(rtpr,"timestamp_jump",(RtpCallback)rtp_session_resync,(long)NULL); rtp_session_signal_connect(rtpr,"ssrc_changed",(RtpCallback)rtp_session_resync,(long)NULL); return rtpr; }
RtpSession * create_duplex_rtpsession(int loc_rtp_port, int loc_rtcp_port, bool_t ipv6) { RtpSession *rtpr; rtpr = rtp_session_new(RTP_SESSION_SENDRECV); rtp_session_set_recv_buf_size(rtpr, MAX(ms_get_mtu() , MS_MINIMAL_MTU)); rtp_session_set_scheduling_mode(rtpr, 0); rtp_session_set_blocking_mode(rtpr, 0); rtp_session_enable_adaptive_jitter_compensation(rtpr, TRUE); rtp_session_set_symmetric_rtp(rtpr, TRUE); rtp_session_set_local_addr(rtpr, ipv6 ? "::" : "0.0.0.0", loc_rtp_port, loc_rtcp_port); rtp_session_signal_connect(rtpr, "timestamp_jump", (RtpCallback)rtp_session_resync, (long)NULL); rtp_session_signal_connect(rtpr, "ssrc_changed", (RtpCallback)rtp_session_resync, (long)NULL); rtp_session_set_ssrc_changed_threshold(rtpr, 0); disable_checksums(rtp_session_get_rtp_socket(rtpr)); return rtpr; }
static int rtp_setup( struct rtp_spook_input *conf ) { // ??RTP?? conf->session=rtp_session_new(RTP_SESSION_RECVONLY); rtp_session_set_scheduling_mode(conf->session,1); rtp_session_set_blocking_mode(conf->session,1); rtp_session_set_local_addr(conf->session,"0.0.0.0", conf->localport); rtp_session_set_connected_mode(conf->session,TRUE); rtp_session_set_symmetric_rtp(conf->session,TRUE); rtp_session_enable_adaptive_jitter_compensation(conf->session,TRUE); rtp_session_set_jitter_compensation(conf->session,40); rtp_session_set_payload_type(conf->session,0); rtp_session_signal_connect(conf->session,"ssrc_changed",(RtpCallback)ssrc_cb,0); rtp_session_signal_connect(conf->session,"ssrc_changed",(RtpCallback)rtp_session_reset,0); return 0; }
RtpSession * ms_create_duplex_rtp_session(const char* local_ip, int loc_rtp_port, int loc_rtcp_port, int mtu) { RtpSession *rtpr; rtpr = rtp_session_new(RTP_SESSION_SENDRECV); rtp_session_set_recv_buf_size(rtpr, MAX(mtu , MS_MINIMAL_MTU)); rtp_session_set_scheduling_mode(rtpr, 0); rtp_session_set_blocking_mode(rtpr, 0); rtp_session_enable_adaptive_jitter_compensation(rtpr, TRUE); rtp_session_set_symmetric_rtp(rtpr, TRUE); rtp_session_set_local_addr(rtpr, local_ip, loc_rtp_port, loc_rtcp_port); rtp_session_signal_connect(rtpr, "timestamp_jump", (RtpCallback)rtp_session_resync, NULL); rtp_session_signal_connect(rtpr, "ssrc_changed", (RtpCallback)rtp_session_resync, NULL); rtp_session_set_ssrc_changed_threshold(rtpr, 0); rtp_session_set_rtcp_report_interval(rtpr, 2500); /* At the beginning of the session send more reports. */ rtp_session_set_multicast_loopback(rtpr,TRUE); /*very useful, specially for testing purposes*/ disable_checksums(rtp_session_get_rtp_socket(rtpr)); return rtpr; }
MSFilter *set_MSFilter(EndPoint *endpoint, int type, FlowDirections *fdir){ MSFilter *filter; RtpSession *rtps; switch(endpoint->protocol){ case MEDIA_RTP: rtps = rtp_session_new(RTP_SESSION_RECVONLY); rtp_session_set_local_addr(rtps,"0.0.0.0",8000); rtp_session_set_scheduling_mode(rtps,0); rtp_session_set_blocking_mode(rtps,0); if(type == 1){ filter = ms_rtp_recv_new(); ms_rtp_recv_set_session(MS_RTP_RECV(filter), rtps); fdir->rtpSessions = g_list_append(fdir->rtpSessions, rtps); return filter; } else{ //ms_rtp_send_new } case MEDIA_OSS: if(type == 1){ filter = ms_oss_read_new(); ms_sound_read_set_device(MS_SOUND_READ(filter),0); return filter; } else{ filter = ms_oss_write_new(); ms_sound_write_set_device(MS_SOUND_WRITE(filter),0); return filter; } case MEDIA_FILE: if(type == 1){ filter = ms_read_new(endpoint->file); return filter; } if(type == 0){ filter = ms_write_new(endpoint->file); return filter; } } }
int yy_init( int port) { RtpSession *session; ortp_init(); ortp_scheduler_init(); ortp_set_log_level_mask( ORTP_DEBUG | ORTP_MESSAGE | ORTP_WARNING | ORTP_ERROR); session = rtp_session_new(RTP_SESSION_RECVONLY); rtp_session_set_scheduling_mode(session, 1); rtp_session_set_blocking_mode(session, 1); rtp_session_set_local_addr(session, "0.0.0.0", port); rtp_session_set_connected_mode(session, TRUE); rtp_session_set_symmetric_rtp(session, TRUE); // rtp_session_enable_adaptive_jitter_compensation(session,adapt); // rtp_session_set_jitter_compensation(session,jittcomp); rtp_session_set_payload_type(session, 0); return (int) session; }
RtpSession *rtp_send_createSession( const char *clientIP, const int clientPort, const char *remoteIP, const int remotePort) { RtpSession *rtpsession = rtp_session_new(RTP_SESSION_SENDONLY); assert(rtpsession != NULL); rtp_session_set_scheduling_mode(rtpsession, 1); rtp_session_set_blocking_mode(rtpsession, 0); rtp_session_set_connected_mode(rtpsession, 1); // 1 means TRUE; // rtp_session_set_local_addr(rtpsession, // clientIP, clientPort, clientPort+1); rtp_session_set_remote_addr(rtpsession, remoteIP, remotePort); rtp_session_set_symmetric_rtp(rtpsession, 1); rtp_session_set_source_description( rtpsession, "cname", /*cname*/ "name", /*name*/ "*****@*****.**", /*email*/ "110", /*phone number*/ "loc", /*loc*/ "tool", /*tool*/ "note:rtp_send test"); rtp_session_enable_rtcp(rtpsession, 1); // 1 means TRUE; // set payload type to H264 (96); rtp_session_set_payload_type(rtpsession, PAYLOAD_TYPE_H264); char *ssrc = getenv("SSRC"); if (ssrc != NULL) { rtp_session_set_ssrc(rtpsession, atoi(ssrc)); } return rtpsession; }
int __cdecl main(int argc, char *argv[]) { FILE * infile = NULL; SessionSet * pSessionSet = NULL; int nCounter = 0; UINT32 m_nUser_Timestamp = 0; ProductVersion(); if (GetCommandArguments(argc, argv) != 0) { printf("==> Sorry dude...\n"); Sleep(1000); return -1; } printf("==> Starting the RTP Sender test\n"); // =============== INSTALL THE CONTROL HANDLER =============== if (SetConsoleCtrlHandler( (PHANDLER_ROUTINE) ctrlHandlerFunction, TRUE) == 0) { printf("==> Cannot handle the CTRL-C...\n"); } printf("==> Timestamp increment will be %i\n" , m_nTimestamp_Inc); printf("==> Packet size will be %i\n" , m_nPacket_Size); m_pBuffer = (char *) ortp_malloc(m_nPacket_Size); ortp_init(); ortp_scheduler_init(); printf("==> Scheduler initialized\n"); m_SSRC = getenv("SSRC"); m_nPort = atoi(argv[3]); for (nCounter=0; nCounter < m_nChannels; nCounter++) { //printf("==> Channel [#%d]\n", nCounter); m_Session[nCounter] = rtp_session_new(RTP_SESSION_SENDONLY); rtp_session_set_scheduling_mode(m_Session[nCounter],1); rtp_session_set_blocking_mode(m_Session[nCounter],0); rtp_session_set_remote_addr(m_Session[nCounter],argv[2], m_nPort); rtp_session_set_send_payload_type(m_Session[nCounter],0); if (m_SSRC != NULL) { rtp_session_set_ssrc(m_Session[nCounter],atoi(m_SSRC)); } m_nPort+=2; } infile=fopen(argv[1],"rb"); if (infile==NULL) { printf("==> Cannot open file !!!!"); Sleep(1000); return -1; } // printf("==> Open file\n"); /* Create a set */ pSessionSet = session_set_new(); // printf("==> Session set\n"); while( ((nCounter= (int) fread(m_pBuffer,1,m_nPacket_Size,infile))>0) && (m_bExit == FALSE) ) { int k; //g_message("Sending packet."); for (k=0;k<m_nChannels;k++){ /* add the session to the set */ session_set_set(pSessionSet,m_Session[k]); //printf("==> Session set set %d\n", k); } /* and then suspend the process by selecting() */ session_set_select(NULL,pSessionSet,NULL); //printf("==> Session set select\n"); for (k=0;k<m_nChannels;k++) { //printf("---\n"); /* this is stupid to do this test, because all session work the same way, as the same user_ts is used for all sessions, here. */ if (session_set_is_set(pSessionSet,m_Session[k])) { //printf("==> Session set is set %d\n", k); rtp_session_send_with_ts(m_Session[k],m_pBuffer,nCounter,m_nUser_Timestamp); //g_message("packet sended !"); } } m_nUser_Timestamp+=m_nTimestamp_Inc; } fclose(infile); printf("==> Close file\n"); for(nCounter=0;nCounter<m_nChannels;nCounter++) { rtp_session_destroy(m_Session[nCounter]); } session_set_destroy(pSessionSet); // Give us some time Sleep(250); ortp_exit(); ortp_global_stats_display(); ortp_free(m_pBuffer); printf("==> Remove the CTRL-C handler...\n"); SetConsoleCtrlHandler( (PHANDLER_ROUTINE) ctrlHandlerFunction, FALSE); // Wait for an input key printf("Waiting for exit : "); for (nCounter = 0; nCounter < 4*5; nCounter++) { printf("."); Sleep(250); } return 0; }
int main(int argc, char *argv[]) { RtpSession *session; unsigned char buffer[160]; int i; FILE *infile; char *ssrc; uint32_t packet_ts=0,send_ts=0; uint32_t send_ts_inc=160; int clockslide=0; int jitter=0; if (argc<4){ printf("%s",help); return -1; } for(i=4;i<argc;i++){ if (strcmp(argv[i],"--with-clockslide")==0){ i++; if (i>=argc) { printf("%s",help); return -1; } clockslide=atoi(argv[i]); ortp_message("Using clockslide of %i milisecond every 50 packets.",clockslide); }else if (strcmp(argv[i],"--with-ptime")==0){ ortp_message("Ptime related jitter will be added to outgoing stream."); i++; if (i>=argc) { printf("%s",help); return -1; } jitter=atoi(argv[i]); send_ts_inc=jitter*8; } } ortp_init(); ortp_scheduler_init(); ortp_set_log_level_mask(NULL, ORTP_MESSAGE|ORTP_WARNING|ORTP_ERROR); session=rtp_session_new(RTP_SESSION_SENDONLY); rtp_session_set_scheduling_mode(session,1); rtp_session_set_blocking_mode(session,1); rtp_session_set_connected_mode(session,TRUE); rtp_session_set_remote_addr(session,argv[2],atoi(argv[3])); rtp_session_set_payload_type(session,0); ssrc=getenv("SSRC"); if (ssrc!=NULL) { printf("using SSRC=%i.\n",atoi(ssrc)); rtp_session_set_ssrc(session,atoi(ssrc)); } #ifndef _WIN32 infile=fopen(argv[1],"r"); #else infile=fopen(argv[1],"rb"); #endif if (infile==NULL) { perror("Cannot open file"); return -1; } signal(SIGINT,stophandler); while( ((i=fread(buffer,1,160,infile))>0) && (runcond) ) { mblk_t *m=rtp_session_create_packet(session,RTP_FIXED_HEADER_SIZE,buffer,i); __rtp_session_sendm_with_ts(session,m,packet_ts,send_ts); packet_ts+=160; if ((send_ts+send_ts_inc)<=packet_ts){ send_ts+=send_ts_inc; } if (clockslide!=0 && send_ts%(160*50)==0){ ortp_message("Clock sliding of %i miliseconds now",clockslide); rtp_session_make_time_distorsion(session,clockslide); } } fclose(infile); rtp_session_destroy(session); ortp_exit(); ortp_global_stats_display(); return 0; }
int main(int argc, char *argv[]) { RtpSession *session[STREAMS_COUNT]; gint i; gint filefd[STREAMS_COUNT]; gint port; guint32 user_ts=0; gint channels; SessionSet *set; gchar *filename; if (argc<4){ printf(help); return -1; } channels=atoi(argv[3]); if (channels==0){ printf(help); return -1; } ortp_init(); ortp_scheduler_init(); ortp_set_debug_file("oRTP",NULL); /* set the telephony event payload type to 96 in the av profile.*/ rtp_profile_set_payload(&av_profile,96,&payload_type_telephone_event); port=atoi(argv[2]); p_channel_id = (int *)g_malloc(channels*sizeof(int)); for (i=0;i<channels;i++){ session[i]=rtp_session_new(RTP_SESSION_RECVONLY); rtp_session_set_scheduling_mode(session[i],1); rtp_session_set_blocking_mode(session[i],0); rtp_session_set_local_addr(session[i],"0.0.0.0",port); rtp_session_set_recv_payload_type(session[i],0); rtp_session_set_recv_buf_size(session[i],256); p_channel_id[i] = i; /* register for telephony events */ rtp_session_signal_connect(session[i],"telephone-event",(RtpCallback)recv_tev_cb,&p_channel_id[i]); port+=2; } filename=g_malloc(strlen(argv[1])+8); for (i=0;i<channels;i++){ sprintf(filename,"%s%4.4d.dat",argv[1],i); #ifndef _WIN32 filefd[i]=open(filename,O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP); #else filefd[i]=open(filename,_O_BINARY | O_WRONLY | O_CREAT | O_TRUNC); #endif if (filefd[i]<0) g_error("Could not open %s for writing: %s",filename,strerror(errno)); } signal(SIGINT,stophandler); /* create a set */ set=session_set_new(); while(runcond) { int k; for (k=0;k<channels;k++){ /* add the session to the set */ session_set_set(set,session[k]); } /* and then suspend the process by selecting() */ session_set_select(set,NULL,NULL); for (k=0;k<channels;k++){ if (session_set_is_set(set,session[k])){ rtp2disk(session[k],user_ts,filefd[k]); } } user_ts+=160; } for (i=0;i<channels;i++){ close(filefd[i]); rtp_session_destroy(session[i]); } session_set_destroy(set); g_free(p_channel_id); g_free(filename); ortp_exit(); ortp_global_stats_display(); return 0; }
int main(int argc, char *argv[]) { RtpSession *session[STREAMS_COUNT]; int i; int filefd[STREAMS_COUNT]; int port; uint32_t user_ts=0; int channels; SessionSet *set; char *filename; if (argc<4){ printf("%s",help); return -1; } channels=atoi(argv[3]); if (channels==0){ printf("%s",help); return -1; } ortp_init(); ortp_scheduler_init(); port=atoi(argv[2]); recvbuf=ortp_malloc(160); for (i=0;i<channels;i++){ session[i]=rtp_session_new(RTP_SESSION_RECVONLY); rtp_session_set_scheduling_mode(session[i],1); rtp_session_set_blocking_mode(session[i],0); rtp_session_set_local_addr(session[i],"0.0.0.0",port,port+1); rtp_session_set_payload_type(session[i],0); rtp_session_enable_adaptive_jitter_compensation(session[i], TRUE); rtp_session_set_recv_buf_size(session[i],256); port+=2; } filename=ortp_malloc(strlen(argv[1])+15); for (i=0;i<channels;i++){ sprintf(filename,"%s%4.4d.dat",argv[1],i); #ifndef _WIN32 filefd[i]=open(filename,O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP); #else filefd[i]=open(filename,_O_BINARY | O_WRONLY | O_CREAT | O_TRUNC); #endif if (filefd[i]<0) ortp_error("Could not open %s for writing: %s",filename,strerror(errno)); } signal(SIGINT,stophandler); /* create a set */ set=session_set_new(); while(runcond) { int k; for (k=0;k<channels;k++){ /* add the session to the set */ session_set_set(set,session[k]); //printf("session_set_set %d\n", k); } /* and then suspend the process by selecting() */ k=session_set_select(set,NULL,NULL); if (k==0) printf("warning: session_set_select() is returning 0...\n"); for (k=0;k<channels;k++){ if (session_set_is_set(set,session[k])){ rtp2disk(session[k],user_ts,filefd[k]); //printf("session_set_is_set %d\n", k); } else { //printf("warning: session %i is not set !\n",k); } } user_ts+=160; } printf("Exiting\n"); for (i=0;i<channels;i++){ close(filefd[i]); rtp_session_destroy(session[i]); } session_set_destroy(set); ortp_free(filename); ortp_exit(); ortp_global_stats_display(); ortp_free(recvbuf); return 0; }
int main(int argc, char *argv[]) { RtpSession *session; unsigned char buffer[160]; int i; FILE *infile; char *ssrc; uint32_t user_ts=0; int clockslide=0; int jitter=0; if (argc<4){ printf("%s", help); return -1; } for(i=4;i<argc;i++){ if (strcmp(argv[i],"--with-clockslide")==0){ i++; if (i>=argc) { printf("%s", help); return -1; } clockslide=atoi(argv[i]); ortp_message("Using clockslide of %i milisecond every 50 packets.",clockslide); }else if (strcmp(argv[i],"--with-jitter")==0){ ortp_message("Jitter will be added to outgoing stream."); i++; if (i>=argc) { printf("%s", help); return -1; } jitter=atoi(argv[i]); } } ortp_init(); ortp_scheduler_init(); ortp_set_log_level_mask(NULL, ORTP_MESSAGE|ORTP_WARNING|ORTP_ERROR); session=rtp_session_new(RTP_SESSION_SENDONLY); rtp_session_set_scheduling_mode(session,1); rtp_session_set_blocking_mode(session,1); rtp_session_set_connected_mode(session,TRUE); rtp_session_set_remote_addr(session,argv[2],atoi(argv[3])); rtp_session_set_payload_type(session,0); ssrc=getenv("SSRC"); if (ssrc!=NULL) { printf("using SSRC=%i.\n",atoi(ssrc)); rtp_session_set_ssrc(session,atoi(ssrc)); } #ifndef _WIN32 infile=fopen(argv[1],"r"); #else infile=fopen(argv[1],"rb"); #endif if (infile==NULL) { perror("Cannot open file"); return -1; } signal(SIGINT,stophandler); while( ((i=fread(buffer,1,160,infile))>0) && (runcond) ) { rtp_session_send_with_ts(session,buffer,i,user_ts); user_ts+=160; if (clockslide!=0 && user_ts%(160*50)==0){ ortp_message("Clock sliding of %i miliseconds now",clockslide); rtp_session_make_time_distorsion(session,clockslide); } /*this will simulate a burst of late packets */ if (jitter && (user_ts%(8000)==0)) { ortp_message("Simulating late packets now (%i milliseconds)",jitter); ortp_sleep_ms(jitter); } } fclose(infile); rtp_session_destroy(session); ortp_exit(); ortp_global_stats_display(); return 0; }
int main(int argc, char*argv[]) { RtpSession *session; unsigned char buffer[32]; int err; uint32_t ts=0; int stream_received=0; FILE *outfile; int local_port; int have_more; int i; int format=0; int soundcard=0; int sound_fd=0; int jittcomp=40; bool_t adapt=TRUE; /* init the lib */ if (argc<3){ printf("%s",help); return -1; } local_port=atoi(argv[2]); if (local_port<=0) { printf("%s",help); return -1; } for (i=3;i<argc;i++) { if (strcmp(argv[i],"--noadapt")==0) adapt=FALSE; if (strcmp(argv[i],"--format")==0){ i++; if (i<argc){ if (strcmp(argv[i],"mulaw")==0){ format=MULAW; }else if (strcmp(argv[i],"alaw")==0){ format=ALAW; }else{ printf("Unsupported format %s\n",argv[i]); return -1; } } } else if (strcmp(argv[i],"--soundcard")==0){ soundcard=1; } else if (strcmp(argv[i],"--with-jitter")==0){ i++; if (i<argc){ jittcomp=atoi(argv[i]); printf("Using a jitter buffer of %i milliseconds.\n",jittcomp); } } } outfile=fopen(argv[1],"wb"); if (outfile==NULL) { perror("Cannot open file for writing"); return -1; } if (soundcard){ sound_fd=sound_init(format); } ortp_init(); ortp_scheduler_init(); ortp_set_log_level_mask(ORTP_DEBUG|ORTP_MESSAGE|ORTP_WARNING|ORTP_ERROR); signal(SIGINT,stop_handler); session=rtp_session_new(RTP_SESSION_RECVONLY); rtp_session_set_scheduling_mode(session,1); rtp_session_set_blocking_mode(session,1); rtp_session_set_local_addr(session,"0.0.0.0",atoi(argv[2])); rtp_session_set_connected_mode(session,TRUE); rtp_session_set_symmetric_rtp(session,TRUE); rtp_session_enable_adaptive_jitter_compensation(session,adapt); rtp_session_set_jitter_compensation(session,jittcomp); rtp_session_set_payload_type(session,0); rtp_session_signal_connect(session,"ssrc_changed",(RtpCallback)ssrc_cb,0); rtp_session_signal_connect(session,"ssrc_changed",(RtpCallback)rtp_session_reset,0); fwrite("#!AMR\n",1,6,outfile); // write(sound_fd,"#!AMR\n",err); while(cond) { have_more=1; while (have_more){ err=rtp_session_recv_with_ts(session,buffer,32,ts,&have_more); if (err>0) stream_received=1; /* this is to avoid to write to disk some silence before the first RTP packet is returned*/ if ((stream_received) && (err>0)) { size_t ret = fwrite(buffer,1,err,outfile); int ii; for(ii =0 ; ii < 32 ; ii ++) printf("%x " ,buffer[ii]); printf("\n"); // while(1); if (sound_fd>0){ ret = write(sound_fd,buffer,err); if (ret==-1){ fprintf(stderr,"write to sound card failed (%s)",strerror(errno)); } } } } ts+=160; //ortp_message("Receiving packet."); } rtp_session_destroy(session); ortp_exit(); ortp_global_stats_display(); return 0; }
int main(int argc, char*argv[]) { RtpSession *session; #ifndef SBUS unsigned char buffer[160]; #else unsigned char buffer[SBUS_FRAME_SIZE]; #endif int err; uint32_t ts=0; int stream_received=0; FILE *outfile; int local_port; int have_more; int i; int format=0; int soundcard=0; int sound_fd=0; int jittcomp=40; bool_t adapt=TRUE; #ifdef SBUS RtpProfile prof; #endif /* init the lib */ if (argc<3){ printf("%s",help); return -1; } local_port=atoi(argv[2]); if (local_port<=0) { printf("%s",help); return -1; } for (i=3;i<argc;i++) { if (strcmp(argv[i],"--noadapt")==0) adapt=FALSE; if (strcmp(argv[i],"--format")==0){ i++; if (i<argc){ if (strcmp(argv[i],"mulaw")==0){ format=MULAW; }else if (strcmp(argv[i],"alaw")==0){ format=ALAW; }else{ printf("Unsupported format %s\n",argv[i]); return -1; } } } else if (strcmp(argv[i],"--soundcard")==0){ soundcard=1; } else if (strcmp(argv[i],"--with-jitter")==0){ i++; if (i<argc){ jittcomp=atoi(argv[i]); printf("Using a jitter buffer of %i milliseconds.\n",jittcomp); } } } outfile=fopen(argv[1],"wb"); if (outfile==NULL) { perror("Cannot open file for writing"); return -1; } #ifdef SBUS setvbuf(outfile, NULL, _IONBF, 0); #endif if (soundcard){ sound_fd=sound_init(format); } ortp_init(); ortp_scheduler_init(); ortp_set_log_level_mask(ORTP_DEBUG|ORTP_MESSAGE|ORTP_WARNING|ORTP_ERROR); signal(SIGINT,stop_handler); session=rtp_session_new(RTP_SESSION_RECVONLY); rtp_session_set_scheduling_mode(session,1); rtp_session_set_blocking_mode(session,1); rtp_session_set_local_addr(session,"0.0.0.0",atoi(argv[2]),-1); rtp_session_set_connected_mode(session,TRUE); rtp_session_set_symmetric_rtp(session,TRUE); rtp_session_enable_adaptive_jitter_compensation(session,adapt); rtp_session_set_jitter_compensation(session,jittcomp); #ifndef SBUS rtp_session_set_payload_type(session,0); #else rtp_profile_clear_all(&prof); //rtp_profile_set_name(&prof, "SBUS"); rtp_profile_set_payload(&prof, 71, &payload_type_sbus); rtp_session_set_profile(session, &prof); rtp_session_set_payload_type(session, 71); #endif rtp_session_signal_connect(session,"ssrc_changed",(RtpCallback)ssrc_cb,0); rtp_session_signal_connect(session,"ssrc_changed",(RtpCallback)rtp_session_reset,0); while(cond) { have_more=1; while (have_more){ #ifndef SBUS err=rtp_session_recv_with_ts(session,buffer,160,ts,&have_more); #else err=rtp_session_recv_with_ts(session,buffer,SBUS_FRAME_SIZE,ts,&have_more); #endif if (err>0) stream_received=1; /* this is to avoid to write to disk some silence before the first RTP packet is returned*/ if ((stream_received) && (err>0)) { #ifdef SBUS clock_gettime(CLOCK_REALTIME, &tsnew); printf("%09ld\n", tsnew.tv_nsec); #endif size_t ret = fwrite(buffer,1,err,outfile); if (sound_fd>0){ ret = write(sound_fd,buffer,err); if (ret==-1){ fprintf(stderr,"write to sound card failed (%s)",strerror(errno)); } } } } #ifndef SBUS ts+=160; #else ts+=70; #endif //ortp_message("Receiving packet."); } rtp_session_destroy(session); ortp_exit(); ortp_global_stats_display(); return 0; }
int ph_media_start(phcall_t *ca, int port, void (*dtmfCallback)(phcall_t *ca, int event), const char * deviceId) { int format = WAVE_FORMAT_PCM; phmstream_t *stream; #if USE_CODECS phcodec_t *codec; #endif /* !USE_CODECS */ #if DO_ECHO_CAN int taps=256; #endif /* !DO_ECHO_CAN */ #if USE_CODECS codec = ph_media_lookup_codec(ca->payload); if (!codec) return 0; #endif /* !USE_CODECS */ stream = open_sndcard(format, codec, deviceId); if (!stream) return -1; stream->payload = ca->payload; stream->rtp_session = rtp_session_new(RTP_SESSION_SENDRECV); rtp_session_set_scheduling_mode(stream->rtp_session, 0); /* yes */ rtp_session_set_blocking_mode(stream->rtp_session, 0); rtp_session_set_profile(stream->rtp_session, &av_profile); rtp_session_set_jitter_compensation(stream->rtp_session, 60); rtp_session_set_local_addr(stream->rtp_session, "0.0.0.0", port); rtp_session_set_remote_addr(stream->rtp_session, ca->remote_sdp_audio_ip, ca->remote_sdp_audio_port); rtp_session_set_payload_type(stream->rtp_session, stream->payload); rtp_session_signal_connect(stream->rtp_session, "telephone-event", (RtpCallback)ph_telephone_event, ca); ca->hasaudio = 1; stream->running = 1; ca->phstream = stream; stream->dtmfCallback = dtmfCallback; # if DO_ECHO_CAN # if AEC_BIS create_AEC(); # else /* !AEC_BIS */ stream->ec = echo_can_create(taps, 0); if(stream->ec == 0){ fprintf(stderr, "Echo CAN creating failed\n"); } if(stream->ec) { # endif /* !AEC_BIS */ stream->echocancel = taps; stream->pcm_rd = stream->pcm_wr = 0; stream->pcm_sent = malloc(PCM_TRACE_LEN); stream->sent_cnt = stream->recv_cnt = 0; if(stream->pcm_sent == 0) fprintf(stderr, "No memory for EC %d\n", stream->pcm_sent); #if !AEC_BIS } #endif /* AEC_BIS */ stream->aec_mutex = g_mutex_new(); stream->synclock = g_mutex_new(); stream->sync_cond = g_cond_new(); stream->pcm_need_resync = 1; stream->bytes_to_throw = 0; # endif /* !DO_ECHO_CAN */ stream->dtmfg_lock = g_mutex_new(); stream->dtmfq_cnt = 0; stream->dtmfg_phase = DTMF_IDLE; stream->audio_in_thread = osip_thread_create(20000, ph_audio_in_thread, stream); stream->audio_out_thread = osip_thread_create(20000, ph_audio_out_thread, stream); return 0; }
int os_sound_start(jcall_t *ca, int port) { int p,cond; int bits = 16; int stereo = 0; /* 0 is mono */ int rate = 8000; int blocksize = 512; if (port == 0) return -1; fd=open(AUDIO_DEVICE, O_RDWR|O_NONBLOCK); if (fd<0) return -EWOULDBLOCK; fcntl(fd, F_SETFL, fcntl(fd, F_GETFL)&~O_NONBLOCK); ioctl(fd, SNDCTL_DSP_RESET, 0); p = bits; /* 16 bits */ ioctl(fd, SNDCTL_DSP_SAMPLESIZE, &p); p = stereo; /* number of channels */ ioctl(fd, SNDCTL_DSP_CHANNELS, &p); #ifdef USE_PCM p = AFMT_S16_NE; /* choose LE or BE (endian) */ ioctl(fd, SNDCTL_DSP_SETFMT, &p); #else if (ca->payload==0) p = AFMT_MU_LAW; else if (ca->payload==8) p = AFMT_A_LAW; else if (ca->payload==110||ca->payload==111) p = AFMT_S16_NE; /* choose LE or BE (endian) */ ioctl(fd, SNDCTL_DSP_SETFMT, &p); #endif p = rate; /* rate in khz*/ ioctl(fd, SNDCTL_DSP_SPEED, &p); ioctl(fd, SNDCTL_DSP_GETBLKSIZE, &min_size); if (min_size>blocksize) { cond=1; p=min_size/blocksize; while(cond) { int i=ioctl(fd, SNDCTL_DSP_SUBDIVIDE, &p); /* printf("SUB_DIVIDE said error=%i,errno=%i\n",i,errno); */ if ((i==0) || (p==1)) cond=0; else p=p/2; } } ioctl(fd, SNDCTL_DSP_GETBLKSIZE, &min_size); if (min_size>blocksize) { printf("dsp block size set to %i.",min_size); exit(0); }else{ /* no need to access the card with less latency than needed*/ min_size=blocksize; } printf("blocksize = %i\n", min_size); #ifdef SPEEX_SUPPORT { float vbr_qual; int value; int quality; ca->speex_enc = speex_encoder_init(&speex_nb_mode); /* 8kHz */ /* 16kHz speex_enc = speex_encoder_init(&speex_wb_mode); */ /* 32kHz speex_enc = speex_encoder_init(&speex_uwb_mode); */ ca->speex_dec = speex_decoder_init(&speex_nb_mode); value = 1; speex_decoder_ctl(ca->speex_dec, SPEEX_SET_ENH, &value); quality = 8; /* 15kb */ speex_encoder_ctl(ca->speex_enc, SPEEX_SET_QUALITY, &quality); /* ou bien le bit rate: value = 15000; // 15kb speex_encoder_ctl(ca->speex_enc, SPEEX_SET_BITRATE, &value); */ /* silence suppression (VAD) value = 1; // 15kb speex_encoder_ctl(ca->speex_enc, SPEEX_SET_VAD, &value); Discontinuous transmission (DTX) value = 1; // 15kb speex_encoder_ctl(ca->speex_enc, SPEEX_SET_DTX, &value); Variable Bit Rate (VBR) value = 1; // 15kb speex_encoder_ctl(ca->speex_enc, SPEEX_SET_VBR, &value); vbr_qual = 5,0; // between 0 and 10 speex_encoder_ctl(ca->speex_enc, SPEEX_SET_VBR_QUALITY, &vbr_qual); Average bit rate: (ABR) value = 15000; // 15kb speex_encoder_ctl(ca->speex_enc, SPEEX_SET_ABR, &value); */ speex_encoder_ctl(ca->speex_enc, SPEEX_GET_FRAME_SIZE, &ca->speex_fsize); ca->speex_nb_packet = 1; speex_bits_init(&(ca->speex_bits)); speex_bits_init(&(ca->dec_speex_bits)); } #endif ca->rtp_session = rtp_session_new(RTP_SESSION_SENDRECV); rtp_session_set_scheduling_mode(ca->rtp_session, 1); /* yes */ rtp_session_set_blocking_mode(ca->rtp_session, 1); rtp_session_set_profile(ca->rtp_session, &av_profile); rtp_session_set_jitter_compensation(ca->rtp_session, 60); rtp_session_set_local_addr(ca->rtp_session, _localip, port); rtp_session_set_remote_addr(ca->rtp_session, ca->remote_sdp_audio_ip, ca->remote_sdp_audio_port); rtp_session_set_payload_type(ca->rtp_session, ca->payload); rtp_session_signal_connect(ca->rtp_session, "telephone-event", (RtpCallback)rcv_telephone_event, ca); /* enter a loop (thread?) to send AUDIO data with rtp_session_send_with_ts(ca->rtp_session, data, data_length, timestamp); */ ca->audio_thread = osip_thread_create(20000, os_sound_start_thread, ca); ca->out_audio_thread = osip_thread_create(20000, os_sound_start_out_thread, ca); return 0; }