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 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]),-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);
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);
while(cond)
{
have_more=1;
while (have_more){
err=rtp_session_recv_with_ts(session,buffer,160,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);
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;
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(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 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(help);
return -1;
}
channels=atoi(argv[3]);
if (channels==0){
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);
port=atoi(argv[2]);
p_channel_id = (int *)ortp_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,(long)&p_channel_id[i]);
port+=2;
}
filename=ortp_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) 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]);
}
/* 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);
ortp_free(p_channel_id);
ortp_free(filename);
ortp_exit();
ortp_global_stats_display();
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;
}
