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 video_stream_recv_only_start (VideoStream *stream, RtpProfile *profile, const char *remip, int remport,int payload, int jitt_comp){ PayloadType *pt; MSPixFmt format; MSVideoSize vsize; RtpSession *rtps=stream->session; vsize.width=MS_VIDEO_SIZE_CIF_W; vsize.height=MS_VIDEO_SIZE_CIF_H; rtp_session_set_profile(rtps,profile); if (remport>0) rtp_session_set_remote_addr(rtps,remip,remport); rtp_session_set_payload_type(rtps,payload); rtp_session_set_jitter_compensation(rtps,jitt_comp); /* creates rtp filters to recv streams */ rtp_session_set_recv_buf_size(rtps,MAX_RTP_SIZE); stream->rtprecv = ms_filter_new (MS_RTP_RECV_ID); ms_filter_call_method(stream->rtprecv,MS_RTP_RECV_SET_SESSION,rtps); /* creates the filters */ pt=rtp_profile_get_payload(profile,payload); if (pt==NULL){ ms_error("videostream.c: undefined payload type."); return -1; } stream->decoder=ms_filter_create_decoder(pt->mime_type); if (stream->decoder==NULL){ /* big problem: we have not a registered codec for this payload...*/ ms_error("videostream.c: No codecs available for payload %i:%s.",payload,pt->mime_type); return -1; } stream->output=ms_filter_new(MS_VIDEO_OUT_ID); /*force the decoder to output YUV420P */ format=MS_YUV420P; /*ask the size-converter to always output CIF */ vsize.width=MS_VIDEO_SIZE_CIF_W; vsize.height=MS_VIDEO_SIZE_CIF_H; ms_message("Setting output vsize=%ix%i",vsize.width,vsize.height); ms_filter_call_method(stream->decoder,MS_FILTER_SET_PIX_FMT,&format); ms_filter_call_method(stream->output,MS_FILTER_SET_PIX_FMT,&format); ms_filter_call_method(stream->output,MS_FILTER_SET_VIDEO_SIZE,&vsize); if (pt->recv_fmtp!=NULL) { ms_message("pt->recv_fmtp: %s", pt->recv_fmtp); ms_filter_call_method(stream->decoder,MS_FILTER_ADD_FMTP,(void*)pt->recv_fmtp); } /* and then connect all */ ms_filter_link (stream->rtprecv, 0, stream->decoder, 0); ms_filter_link (stream->decoder,0 , stream->output, 0); /* create the ticker */ stream->ticker = ms_ticker_new(); /* attach it the graph */ ms_ticker_attach (stream->ticker, stream->rtprecv); return 0; }
void MastTool::set_session_address( const char* in_addr ) { char* address = strdup( in_addr ); char* portstr = NULL; int port = DEFAULT_RTP_PORT; // Look for port in the address portstr = strchr(address, '/'); if (portstr && strlen(portstr)>1) { *portstr = 0; portstr++; port = atoi(portstr); } // Make sure the port number is even if (port%2 == 1) port--; // Send of recieve address? if (this->session->mode == RTP_SESSION_RECVONLY) { // Set the local address/port if (rtp_session_set_local_addr( session, address, port )) { MAST_FATAL("Failed to set local address/port (%s/%d)", address, port); } else { MAST_INFO( "Local address: %s/%d", address, port ); } } else if (this->session->mode == RTP_SESSION_SENDONLY) { // Set the remote address/port if (rtp_session_set_remote_addr( session, address, port )) { MAST_FATAL("Failed to set remote address/port (%s/%d)", address, port); } else { MAST_INFO( "Remote address: %s/%d", address, port ); } } else { MAST_FATAL("Mode unsupported by MastTool: %d", this->session->mode); } free( address ); }
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 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 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 __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 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 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; }