int main (int argc, char *argv[])
{
int port = 5060;
eXosip_event_t *event = NULL;
succeed_type flag;
#if !defined(__arc__)
struct servent *service = NULL;
#endif
struct regparam_t regparam = { 0, 3600, 0 };
int debug = 1;
port = 5060;
#if 0
if (debug > 0)
TRACE_INITIALIZE (6, NULL);
#endif
context_eXosip = eXosip_malloc ();
if (eXosip_init (context_eXosip)) {
printf("eXosip_init failed\r\n");
exit (1);
}
if (eXosip_listen_addr (context_eXosip, IPPROTO_UDP, "192.168.5.118", port, AF_INET, 0)) {
printf("eXosip_listen_addr failed\r\n");
exit (1);
}
/*start the notify thread */
#ifndef OSIP_MONOTHREAD
notify_thread = osip_thread_create(20000, notify_proc, ®param);
#endif
for(;;)
{
eXosip_event_t *event;
if (!(event = eXosip_event_wait (context_eXosip, 0, 1))) {
#ifdef OSIP_MONOTHREAD
eXosip_execute (context_eXosip);
eXosip_automatic_action (context_eXosip);
#endif
// osip_usleep (10000);
continue;
}
eXosip_lock(context_eXosip);
#ifdef OSIP_MONOTHREAD
eXosip_execute (context_eXosip);
#endif
// eXosip_automatic_action (context_eXosip);
eXosip_unlock(context_eXosip);
eXosip_automatic_action(context_eXosip);
switch (event->type) {
case EXOSIP_CALL_INVITE:
if(MSG_IS_INVITE(event->request))
{
flag = handle_request_invite(context_eXosip, event);
if(flag == succeed_type_failed)
{
printf("handle invite request failed\r\n");
}else{
printf("handle invite request succeed\r\n");
}
continue;
}
break;
case EXOSIP_CALL_REINVITE:
break;
case EXOSIP_CALL_NOANSWER:
break;
case EXOSIP_CALL_PROCEEDING:
break;
case EXOSIP_CALL_RINGING:
break;
case EXOSIP_CALL_ANSWERED:
break;
case EXOSIP_CALL_REDIRECTED:
break;
case EXOSIP_CALL_REQUESTFAILURE:
break;
case EXOSIP_CALL_SERVERFAILURE:
break;
case EXOSIP_CALL_GLOBALFAILURE:
break;
case EXOSIP_CALL_ACK:
break;
case EXOSIP_CALL_CANCELLED:
break;
case EXOSIP_CALL_MESSAGE_NEW:
break;
case EXOSIP_CALL_MESSAGE_PROCEEDING:
printf("EXOSIP_CALL_MESSAGE_PROCEEDING\r\n");
break;
case EXOSIP_CALL_MESSAGE_ANSWERED:
break;
case EXOSIP_CALL_MESSAGE_REDIRECTED:
break;
case EXOSIP_CALL_MESSAGE_REQUESTFAILURE:
break;
case EXOSIP_CALL_MESSAGE_SERVERFAILURE:
break;
case EXOSIP_CALL_MESSAGE_GLOBALFAILURE:
break;
case EXOSIP_CALL_CLOSED:
break;
case EXOSIP_CALL_RELEASED:
break;
case EXOSIP_MESSAGE_NEW:
printf("answer EXOSIP_MESSAGE_NEW\r\n");
if(MSG_IS_MESSAGE(event->request))
{
flag = handle_request_message(context_eXosip, event);
if(flag == succeed_type_failed)
{
printf("handle message request failed\r\n");
}else{
printf("handle message request succeed\r\n");
}
continue;
}
if(MSG_IS_REGISTER(event->request))
{
flag = handle_request_register(context_eXosip, event);
if(flag == succeed_type_failed)
{
printf("handle register request failed\r\n");
}else{
printf("handle register request succeed\r\n");
}
continue;
}
break;
case EXOSIP_MESSAGE_PROCEEDING:
break;
case EXOSIP_MESSAGE_ANSWERED:
break;
case EXOSIP_MESSAGE_REDIRECTED:
break;
case EXOSIP_MESSAGE_REQUESTFAILURE:
break;
case EXOSIP_MESSAGE_SERVERFAILURE:
break;
case EXOSIP_MESSAGE_GLOBALFAILURE:
break;
case EXOSIP_SUBSCRIPTION_NOANSWER:
break;
case EXOSIP_SUBSCRIPTION_PROCEEDING:
break;
case EXOSIP_SUBSCRIPTION_ANSWERED:
break;
case EXOSIP_SUBSCRIPTION_REDIRECTED:
break;
case EXOSIP_SUBSCRIPTION_REQUESTFAILURE:
break;
case EXOSIP_SUBSCRIPTION_SERVERFAILURE:
break;
case EXOSIP_SUBSCRIPTION_GLOBALFAILURE:
break;
case EXOSIP_SUBSCRIPTION_NOTIFY:
break;
case EXOSIP_IN_SUBSCRIPTION_NEW: //subscribe event
if(MSG_IS_SUBSCRIBE(event->request))
{
flag = handle_request_subscribe(context_eXosip, event);
if(flag == succeed_type_failed)
{
printf("handle subscribe request failed\r\n");
}else{
printf("handle subscribe request succeed\r\n");
}
continue;
}
break;
case EXOSIP_NOTIFICATION_NOANSWER:
break;
case EXOSIP_NOTIFICATION_PROCEEDING:
break;
case EXOSIP_NOTIFICATION_ANSWERED:
break;
case EXOSIP_NOTIFICATION_REDIRECTED:
break;
case EXOSIP_NOTIFICATION_REQUESTFAILURE:
break;
case EXOSIP_NOTIFICATION_SERVERFAILURE:
break;
case EXOSIP_NOTIFICATION_GLOBALFAILURE:
break;
case EXOSIP_EVENT_COUNT:
break;
default:
printf( "recieved unknown eXosip event (type, did, cid) = (%d, %d, %d)", event->type, event->did, event->cid);
}
eXosip_event_free (event);
}
}
int os_sound_start(jcall *ca, int port)
{
portt=port;
osip_thread_create(20000,startsound, ca);
return 0;
}
MY_DLLEXPORT OWPL_RESULT
owplInit( const int asyncCallbackMode,
const int udpPort,
const int tcpPort,
const int tlsPort,
const char* szBindToAddr,
const int bUserSequentialPorts)
{
int i;
phcb = (phCallbacks_t * ) malloc(sizeof(phCallbacks_t));
memset(phcb, 0, sizeof(phCallbacks_t));
phcfg.asyncmode = asyncCallbackMode;
ph_avcodec_init();
ph_calls_init();
if (udpPort > 0) {
snprintf(phcfg.sipport, sizeof(phcfg.sipport), "%d", udpPort);
}
if (phcfg.use_tunnel)
{
i = ph_tunnel_init();
if (i)
{
return i;
}
}
#ifdef FORCE_VAD
/* HACK for test */
#ifdef EMBED
phcfg.vad = VAD_VALID_MASK | (500 & VAD_THRESHOLD_MASK);
#else
phcfg.vad = VAD_VALID_MASK | (1000 & VAD_THRESHOLD_MASK);
#endif
#endif
#ifdef FORCE_CNG
/* HACK for test */
phcfg.cng = 1;
#endif
ph_media_init(phcfg.use_tunnel, phcfg.plugin_path);
i = eXosip_init(0, 0, atoi(phcfg.sipport), phTunnel);
if (i)
{
return OWPL_RESULT_FAILURE;
}
{
/* <UOLFONE> */
/*
const char * ua = WENGOPHONE_UA;
eXosip_set_user_agent(ua);
*/
if (phcfg.user_agent[0])
{
eXosip_set_user_agent(phcfg.user_agent);
}
else
{
const char * ua = UOLFONECLIENT_UA;
eXosip_set_user_agent(ua);
}
/* <UOLFONE> */
}
ph_nat_init();
/* This should be done in the setter of phcfg.proxy
if (phcfg.force_proxy)
{
eXosip_force_proxy(phcfg.proxy);
}
*/
{
char contact[512];
eXosip_guess_contact_uri(phcfg.identity, contact, sizeof(contact), 1);
eXosip_set_answer_contact(contact);
}
ph_vlines_init();
ph_payloads_init();
if (!phcfg.audio_dev || phcfg.audio_dev[0] == '\0')
{
// Set default audio device if no one has been set before
owplAudioSetConfigString(0);
}
/* register callbacks? */
eXosip_set_mode(EVENT_MODE);
if (!phcfg.asyncmode)
{
phWaitTimeout = 1;
}
else
{
phWaitTimeout = 500;
}
if (phcfg.asyncmode)
{
osip_thread_create(20000, ph_api_thread, 0);
}
ph_media_stop_mutex = g_mutex_new();
phIsInitialized = 1;
DEBUGTRACE("PhInit finished\n");
return OWPL_RESULT_SUCCESS;
}
int
os_sound_start (call_t * ca, int port)
{
int p, cond;
int bits = 16;
int stereo = 0; /* 0 is mono */
int rate = 8000;
int blocksize = 512;
if (ca->local_sendrecv == _SENDRECV || ca->local_sendrecv == _RECVONLY)
{
ca->fd = open (AUDIO_DEVICE, O_RDWR | O_NONBLOCK);
if (ca->fd < 0)
return -EWOULDBLOCK;
fcntl (ca->fd, F_SETFL, fcntl (ca->fd, F_GETFL) & ~O_NONBLOCK);
ioctl (ca->fd, SNDCTL_DSP_RESET, 0);
p = bits; /* 16 bits */
ioctl (ca->fd, SNDCTL_DSP_SAMPLESIZE, &p);
p = stereo; /* number of channels */
ioctl (ca->fd, SNDCTL_DSP_CHANNELS, &p);
#ifdef USE_PCM
p = AFMT_S16_NE; /* choose LE or BE (endian) */
ioctl (ca->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 (ca->fd, SNDCTL_DSP_SETFMT, &p);
#endif
p = rate; /* rate in khz */
ioctl (ca->fd, SNDCTL_DSP_SPEED, &p);
ioctl (ca->fd, SNDCTL_DSP_GETBLKSIZE, &min_size);
if (min_size > blocksize)
{
cond = 1;
p = min_size / blocksize;
while (cond)
{
int i = ioctl (ca->fd, SNDCTL_DSP_SUBDIVIDE, &p);
/* fprintf(stderr, "SUB_DIVIDE said error=%i,errno=%i\n",i,errno); */
if ((i == 0) || (p == 1))
cond = 0;
else
p = p / 2;
}
}
ioctl (ca->fd, SNDCTL_DSP_GETBLKSIZE, &min_size);
if (min_size > blocksize)
{
fprintf (stderr, "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;
}
OSIP_TRACE (osip_trace
(__FILE__, __LINE__, OSIP_INFO2, NULL,
"blocksize = %i\n", min_size));
} else
{
/* send a wav file! */
ca->fd = open (ca->wav_file, O_RDONLY);
if (ca->fd < 0)
{
OSIP_TRACE (osip_trace
(__FILE__, __LINE__, OSIP_INFO2, NULL,
"Could not open wav file: %s\n", ca->wav_file));
return -1;
}
}
#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
if (ca->local_sendrecv == _SENDRECV)
{
OSIP_TRACE (osip_trace
(__FILE__, __LINE__, OSIP_INFO2, NULL,
"starting sendrecv session\n"));
} else if (ca->local_sendrecv == _SENDONLY)
{
OSIP_TRACE (osip_trace
(__FILE__, __LINE__, OSIP_INFO2, NULL,
"starting sendonly session\n"));
} else
{
OSIP_TRACE (osip_trace
(__FILE__, __LINE__, OSIP_INFO2, NULL,
"starting recvonly session\n"));
}
ca->rtp_session = rtp_init (ca->remote_sdp_audio_ip,
port,
ca->remote_sdp_audio_port,
16, 64000, rtp_event_handler, (void *) ca);
if (ca->rtp_session)
{
const char *username = "******"; /* should be taken from the SDP */
const char *telephone = "0033-MY-NUMBER";
const char *app_name = "josua";
uint32_t my_ssrc = rtp_my_ssrc (ca->rtp_session);
/* set local participant info */
rtp_set_sdes (ca->rtp_session, my_ssrc, RTCP_SDES_NAME,
username, strlen (username));
rtp_set_sdes (ca->rtp_session, my_ssrc, RTCP_SDES_PHONE,
telephone, strlen (telephone));
rtp_set_sdes (ca->rtp_session, my_ssrc, RTCP_SDES_TOOL,
app_name, strlen (app_name));
/* Filter out local packets if requested */
/* rtp_set_option(ca->rtp_session, RTP_OPT_FILTER_MY_PACKETS, filter_me); */
rtp_set_option (ca->rtp_session, RTP_OPT_WEAK_VALIDATION, TRUE);
ca->enable_audio = 1;
ca->audio_thread = osip_thread_create (20000, os_sound_start_thread, ca);
} else
{
fprintf (stderr, "Could not initialize session for %s port %d\n",
ca->remote_sdp_audio_ip, ca->remote_sdp_audio_port);
}
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;
}
OWPL_RESULT
owplInit
(
const int asyncCallbackMode,
short udpPort,
short tcpPort,
short tlsPort,
const char* szBindToAddr,
const int bUserSequentialPorts
)
{
int return_code;
short useUdp = (udpPort == -1 ? 0 : 1);
short useTcp = (tcpPort == -1 ? 0 : 1);
short useTls = (tlsPort == -1 ? 0 : 1);
const char* ptime;
return_code = owplAdapterInitialize();
if (return_code != 0)
{
owplLogError("owplAdapterInitialize failed");
return OWPL_RESULT_FAILURE;
}
return_code = owplAdapterNortelInitialize("nortel");
if (return_code != 0)
{
owplLogError("owplAdapterNortelInitialize failed");
return OWPL_RESULT_FAILURE;
}
phcb = (phCallbacks_t * ) malloc(sizeof(phCallbacks_t));
memset(phcb, 0, sizeof(phCallbacks_t));
phcfg.asyncmode = asyncCallbackMode;
return_code = owplInitOwsl(useUdp, useTcp, useTls);
if (return_code != 0)
{
owplLogError("owplInitOwsl failed");
return OWPL_RESULT_FAILURE;
}
osip_trace_initialize_func(OSIP_INFO3, owplOsipLogFunction);
return_code = eXosip_init(0, 0, udpPort, tcpPort, tlsPort);
if (return_code != 0)
{
owplLogError("eXosip_init failed");
return OWPL_RESULT_FAILURE;
}
{
const char version[] = stringize(VOXOXVERSION);//VOXOX - CJC - 2009.06.27
// VOXOX CHANGE by ASV 06-27-2009: modified the code to be compatible with GCC
char ua[50] = "VoxOx "; // We need to define he size to make sure strcat has enough space to copy version in ua
strcat(ua, version);//VOXOX - CJC - 2009.06.27
// VOXOX CHANGE by ASV - end
eXosip_set_user_agent(ua);
}
ph_avcodec_init();
ph_calls_init();
#ifdef FORCE_VAD
/* HACK for test */
#ifdef EMBED
phcfg.vad = VAD_VALID_MASK | (500 & VAD_THRESHOLD_MASK);
#else
phcfg.vad = VAD_VALID_MASK | (1000 & VAD_THRESHOLD_MASK);
#endif
#endif
#ifdef FORCE_CNG
/* HACK for test */
phcfg.cng = 1;
#endif
ph_media_init(phcfg.plugin_path);
ph_vlines_init();
ph_payloads_init();
if (!phcfg.audio_dev || phcfg.audio_dev[0] == '\0')
{
// Set default audio device if no one has been set before
owplAudioSetConfigString(0);
}
#if 0
ptime = getenv("EXOSIP_FORCE_PTIME");
if (!ptime || !*ptime)
{
putenv("EXOSIP_FORCE_PTIME=20");
}
#endif
/* register callbacks? */
eXosip_set_mode(EVENT_MODE);
if (!phcfg.asyncmode)
{
phWaitTimeout = 1;
}
else
{
phWaitTimeout = 500;
}
if (phcfg.asyncmode)
{
osip_thread_create(20000, ph_api_thread, 0);
}
pthread_mutex_init(&ph_media_stop_mutex, NULL);
phIsInitialized = 1;
owplLogDebug("owplInit finished");
return OWPL_RESULT_SUCCESS;
}
int
main (int argc, char *argv[])
#endif
{
int c;
int port = 5060;
char *contact = NULL;
char *fromuser = NULL;
const char *localip = NULL;
const char *firewallip = NULL;
char *proxy = NULL;
#if !defined(__arc__)
struct servent *service;
#endif
char *username = NULL;
char *password = NULL;
struct regparam_t regparam = { 0, 3600, 0 };
#ifndef OSIP_MONOTHREAD
struct osip_thread *register_thread;
#endif
int debug = 0;
int nofork = 0;
#ifdef _WIN32_WCE
proxy = osip_strdup ("sip:sip.antisip.com");
fromuser = osip_strdup ("sip:[email protected]");
#else
for (;;) {
#define short_options "c:de:f:hl:p:r:u:U:P:"
#ifdef _GNU_SOURCE
int option_index = 0;
static struct option long_options[] = {
{"contact", required_argument, NULL, 'c'},
{"debug", no_argument, NULL, 'd'},
{"expiry", required_argument, NULL, 'e'},
{"firewallip", required_argument, NULL, 'f'},
{"from", required_argument, NULL, 'u'},
{"help", no_argument, NULL, 'h'},
{"localip", required_argument, NULL, 'l'},
{"port", required_argument, NULL, 'p'},
{"proxy", required_argument, NULL, 'r'},
{"username", required_argument, NULL, 'U'},
{"password", required_argument, NULL, 'P'},
{NULL, 0, NULL, 0}
};
c = getopt_long (argc, argv, short_options, long_options, &option_index);
#else
c = getopt (argc, argv, short_options);
#endif
if (c == -1)
break;
switch (c) {
case 'c':
contact = optarg;
break;
case 'd':
nofork = 1;
#ifdef LOG_PERROR
debug = LOG_PERROR;
#endif
break;
case 'e':
regparam.expiry = atoi (optarg);
break;
case 'f':
firewallip = optarg;
break;
case 'h':
usage ();
exit (0);
case 'l':
localip = optarg;
break;
case 'p':
#if !defined(__arc__)
service = getservbyname (optarg, "udp");
if (service)
port = ntohs (service->s_port);
else
port = atoi (optarg);
#else
port = atoi (optarg);
#endif
break;
case 'r':
proxy = optarg;
break;
case 'u':
fromuser = optarg;
break;
case 'U':
username = optarg;
break;
case 'P':
password = optarg;
break;
default:
break;
}
}
#endif
if (!proxy || !fromuser) {
usage ();
exit (1);
}
#ifndef _WIN32_WCE
if (!nofork) {
daemon (1, 0);
}
#endif
#if 0
openlog (PROG_NAME, LOG_PID | debug, SYSLOG_FACILITY);
#endif
syslog_wrapper (LOG_INFO, UA_STRING " up and running");
syslog_wrapper (LOG_INFO, "proxy: %s", proxy);
syslog_wrapper (LOG_INFO, "fromuser: %s", fromuser);
syslog_wrapper (LOG_INFO, "contact: %s", contact);
syslog_wrapper (LOG_INFO, "expiry: %d", regparam.expiry);
syslog_wrapper (LOG_INFO, "local port: %d", port);
if (debug > 0)
TRACE_INITIALIZE (6, NULL);
context_eXosip = eXosip_malloc ();
if (eXosip_init (context_eXosip)) {
syslog_wrapper (LOG_ERR, "eXosip_init failed");
exit (1);
}
if (eXosip_listen_addr (context_eXosip, IPPROTO_UDP, NULL, port, AF_INET, 0)) {
syslog_wrapper (LOG_ERR, "eXosip_listen_addr failed");
exit (1);
}
if (localip) {
syslog_wrapper (LOG_INFO, "local address: %s", localip);
eXosip_masquerade_contact (context_eXosip, localip, port);
}
if (firewallip) {
syslog_wrapper (LOG_INFO, "firewall address: %s:%i", firewallip, port);
eXosip_masquerade_contact (context_eXosip, firewallip, port);
}
eXosip_set_user_agent (context_eXosip, UA_STRING);
if (username && password) {
syslog_wrapper (LOG_INFO, "username: %s", username);
syslog_wrapper (LOG_INFO, "password: [removed]");
if (eXosip_add_authentication_info (context_eXosip, username, username, password, NULL, NULL)) {
syslog_wrapper (LOG_ERR, "eXosip_add_authentication_info failed");
exit (1);
}
}
{
osip_message_t *reg = NULL;
int i;
regparam.regid = eXosip_register_build_initial_register (context_eXosip, fromuser, proxy, contact, regparam.expiry * 2, ®);
if (regparam.regid < 1) {
syslog_wrapper (LOG_ERR, "eXosip_register_build_initial_register failed");
exit (1);
}
i = eXosip_register_send_register (context_eXosip, regparam.regid, reg);
if (i != 0) {
syslog_wrapper (LOG_ERR, "eXosip_register_send_register failed");
exit (1);
}
}
#ifndef OSIP_MONOTHREAD
register_thread = osip_thread_create (20000, register_proc, ®param);
if (register_thread == NULL) {
syslog_wrapper (LOG_ERR, "pthread_create failed");
exit (1);
}
#endif
for (;;) {
eXosip_event_t *event;
if (!(event = eXosip_event_wait (context_eXosip, 0, 1))) {
#ifdef OSIP_MONOTHREAD
eXosip_execute (context_eXosip);
eXosip_automatic_action (context_eXosip);
#endif
osip_usleep (10000);
continue;
}
#ifdef OSIP_MONOTHREAD
eXosip_execute (context_eXosip);
#endif
eXosip_automatic_action (context_eXosip);
switch (event->type) {
case EXOSIP_REGISTRATION_SUCCESS:
syslog_wrapper (LOG_INFO, "registrered successfully");
break;
case EXOSIP_REGISTRATION_FAILURE:
regparam.auth = 1;
break;
default:
syslog_wrapper (LOG_DEBUG, "recieved unknown eXosip event (type, did, cid) = (%d, %d, %d)", event->type, event->did, event->cid);
}
eXosip_event_free (event);
}
}
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;
}
