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; }
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; }
void media_stream_enable_adaptive_jittcomp(MediaStream *stream, bool_t enabled) { rtp_session_enable_adaptive_jitter_compensation(stream->sessions.rtp_session, enabled); }
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[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; #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; }
void video_stream_enable_adaptive_jittcomp(VideoStream *st, bool_t enabled) { rtp_session_enable_adaptive_jitter_compensation(st->session, enabled); }