static BOOL OnInitStack (void)
{
pjsua_config cfg;
pjsua_logging_config log_cfg;
pjsua_media_config media_cfg;
pjsua_transport_config udp_cfg;
pjsua_transport_config rtp_cfg;
pjsua_transport_id transport_id;
pjsua_transport_info transport_info;
pj_str_t tmp;
pj_status_t status;
/* Create pjsua */
status = pjsua_create();
if (status != PJ_SUCCESS) {
OnError (TEXT ("Error creating pjsua"), status);
return FALSE;
}
/* Create global pool for application */
g_pool = pjsua_pool_create ("pjsua", 4000, 4000);
/* Init configs */
pjsua_config_default (&cfg);
pjsua_media_config_default (&media_cfg);
pjsua_transport_config_default (&udp_cfg);
udp_cfg.port = SIP_PORT;
pjsua_transport_config_default (&rtp_cfg);
rtp_cfg.port = 40000;
pjsua_logging_config_default (&log_cfg);
log_cfg.level = 5;
log_cfg.log_filename = pj_str ("\\pjsua.txt");
log_cfg.msg_logging = 1;
log_cfg.decor = pj_log_get_decor() | PJ_LOG_HAS_CR;
/* Setup media */
media_cfg.clock_rate = 8000;
media_cfg.ec_options = PJMEDIA_ECHO_SIMPLE;
media_cfg.ec_tail_len = 256;
// use default quality setting
//media_cfg.quality = 1;
media_cfg.ptime = 20;
media_cfg.enable_ice = USE_ICE;
/* Initialize application callbacks */
cfg.cb.on_call_state = &on_call_state;
cfg.cb.on_call_media_state = &on_call_media_state;
cfg.cb.on_incoming_call = &on_incoming_call;
cfg.cb.on_reg_state = &on_reg_state;
cfg.cb.on_buddy_state = &on_buddy_state;
cfg.cb.on_pager = &on_pager;
cfg.cb.on_typing = &on_typing;
cfg.cb.on_nat_detect = &nat_detect_cb;
if (SIP_PROXY) {
cfg.outbound_proxy_cnt = 1;
cfg.outbound_proxy[0] = pj_str (SIP_PROXY);
}
if (NAMESERVER) {
cfg.nameserver_count = 1;
cfg.nameserver[0] = pj_str (NAMESERVER);
}
if (NAMESERVER && STUN_DOMAIN) {
cfg.stun_domain = pj_str (STUN_DOMAIN);
} else if (STUN_SERVER) {
cfg.stun_host = pj_str (STUN_SERVER);
}
/* Initialize pjsua */
status = pjsua_init (&cfg, &log_cfg, &media_cfg);
if (status != PJ_SUCCESS) {
OnError (TEXT ("Initialization error"), status);
return FALSE;
}
/* Set codec priority */
pjsua_codec_set_priority (pj_cstr (&tmp, "pcmu"), 240);
pjsua_codec_set_priority (pj_cstr (&tmp, "pcma"), 230);
pjsua_codec_set_priority (pj_cstr (&tmp, "speex/8000"), 190);
pjsua_codec_set_priority (pj_cstr (&tmp, "ilbc"), 189);
pjsua_codec_set_priority (pj_cstr (&tmp, "speex/16000"), 180);
pjsua_codec_set_priority (pj_cstr (&tmp, "speex/32000"), 0);
pjsua_codec_set_priority (pj_cstr (&tmp, "gsm"), 100);
/* Add UDP transport and the corresponding PJSUA account */
status = pjsua_transport_create (PJSIP_TRANSPORT_UDP,
&udp_cfg, &transport_id);
if (status != PJ_SUCCESS) {
OnError (TEXT ("Error starting SIP transport"), status);
return FALSE;
}
pjsua_transport_get_info (transport_id, &transport_info);
g_local_uri.ptr = (char*) pj_pool_alloc (g_pool, 128);
g_local_uri.slen = pj_ansi_sprintf (g_local_uri.ptr,
"<sip:%.*s:%d>",
(int) transport_info.local_name.host.slen,
transport_info.local_name.host.ptr,
transport_info.local_name.port);
/* Add local account */
pjsua_acc_add_local (transport_id, PJ_TRUE, &g_current_acc);
pjsua_acc_set_online_status (g_current_acc, PJ_TRUE);
/* Add account */
if (HAS_SIP_ACCOUNT) {
pjsua_acc_config cfg;
pjsua_acc_config_default (&cfg);
cfg.id = pj_str ("sip:" SIP_USER "@" SIP_DOMAIN);
cfg.reg_uri = pj_str ("sip:" SIP_DOMAIN);
cfg.cred_count = 1;
cfg.cred_info[0].realm = pj_str (SIP_REALM);
cfg.cred_info[0].scheme = pj_str ("digest");
cfg.cred_info[0].username = pj_str (SIP_USER);
cfg.cred_info[0].data_type = PJSIP_CRED_DATA_PLAIN_PASSWD;
cfg.cred_info[0].data = pj_str (SIP_PASSWD);
status = pjsua_acc_add (&cfg, PJ_TRUE, &g_current_acc);
if (status != PJ_SUCCESS) {
pjsua_destroy();
return PJ_FALSE;
}
}
/* Add buddy */
if (SIP_DST_URI) {
pjsua_buddy_config bcfg;
pjsua_buddy_config_default (&bcfg);
bcfg.uri = pj_str (SIP_DST_URI);
bcfg.subscribe = PJ_FALSE;
pjsua_buddy_add (&bcfg, NULL);
}
/* Start pjsua */
status = pjsua_start();
if (status != PJ_SUCCESS) {
OnError (TEXT ("Error starting pjsua"), status);
return FALSE;
}
return TRUE;
}
/*
* Print log of call states. Since call states may be too long for logger,
* printing it is a bit tricky, it should be printed part by part as long
* as the logger can accept.
*/
void log_call_dump(int call_id)
{
unsigned call_dump_len;
unsigned part_len;
unsigned part_idx;
unsigned log_decor;
pjsua_call_dump(call_id, PJ_TRUE, some_buf, sizeof(some_buf), " ");
call_dump_len = (unsigned)strlen(some_buf);
log_decor = pj_log_get_decor();
pj_log_set_decor(log_decor & ~(PJ_LOG_HAS_NEWLINE | PJ_LOG_HAS_CR));
PJ_LOG(3,(THIS_FILE, "\n"));
pj_log_set_decor(0);
part_idx = 0;
part_len = PJ_LOG_MAX_SIZE-80;
while (part_idx < call_dump_len) {
char p_orig, *p;
p = &some_buf[part_idx];
if (part_idx + part_len > call_dump_len)
part_len = call_dump_len - part_idx;
p_orig = p[part_len];
p[part_len] = '\0';
PJ_LOG(3,(THIS_FILE, "%s", p));
p[part_len] = p_orig;
part_idx += part_len;
}
pj_log_set_decor(log_decor);
}
/*****************************************************************************
* The test session
*/
static void test_destroy(void)
{
if (g_app.tx)
stream_destroy(g_app.tx);
if (g_app.tx_wav)
pjmedia_port_destroy(g_app.tx_wav);
if (g_app.rx)
stream_destroy(g_app.rx);
if (g_app.rx_wav)
pjmedia_port_destroy(g_app.rx_wav);
if (g_app.loop)
pjmedia_transport_close(g_app.loop);
if (g_app.endpt)
pjmedia_endpt_destroy( g_app.endpt );
if (g_app.log_fd) {
pj_log_set_log_func(&pj_log_write);
pj_log_set_decor(pj_log_get_decor() | PJ_LOG_HAS_NEWLINE);
pj_file_close(g_app.log_fd);
g_app.log_fd = NULL;
}
if (g_app.pool)
pj_pool_release(g_app.pool);
pj_caching_pool_destroy( &g_app.cp );
pj_shutdown();
}
PJ_DEF(void) pj_log_write(int level, const char *buffer, int len)
{
PJ_CHECK_STACK();
PJ_UNUSED_ARG(len);
/* Copy to terminal/file. */
if (pj_log_get_decor() & PJ_LOG_HAS_COLOR) {
term_set_color(level);
printf("%s", buffer);
term_restore_color();
} else {
printf("%s", buffer);
}
}
static void print_stream_data(const char *title,
struct test_data *test_data,
struct stream_data *strm_data,
int verbose)
{
unsigned i, dur;
int ptime;
unsigned min_jitter, max_jitter, sum_jitter, avg_jitter=0;
PJ_LOG(3,(THIS_FILE, " %s stream report:", title));
/* Check that frames are captured/played */
if (strm_data->counter == 0) {
PJ_LOG(1,(THIS_FILE, " Error: no frames are captured/played!"));
test_data->has_error = 1;
return;
}
/* Duration */
dur = (strm_data->counter+1) * test_data->samples_per_frame * 1000 /
test_data->clock_rate;
PJ_LOG(3,(THIS_FILE, " Duration: %ds.%03d",
dur/1000, dur%1000));
/* Frame interval */
if (strm_data->max_delay - strm_data->min_delay < WARN_JITTER_USEC) {
PJ_LOG(3,(THIS_FILE,
" Frame interval: min=%d.%03dms, max=%d.%03dms",
strm_data->min_delay/1000, strm_data->min_delay%1000,
strm_data->max_delay/1000, strm_data->max_delay%1000));
} else {
test_data->has_error = 1;
PJ_LOG(2,(THIS_FILE,
" Frame interval: min=%d.%03dms, max=%d.%03dms",
strm_data->min_delay/1000, strm_data->min_delay%1000,
strm_data->max_delay/1000, strm_data->max_delay%1000));
}
if (verbose) {
unsigned i;
unsigned decor = pj_log_get_decor();
PJ_LOG(3,(THIS_FILE, " Dumping frame delays:"));
pj_log_set_decor(0);
for (i=0; i<strm_data->counter; ++i)
PJ_LOG(3,(THIS_FILE, " %d.%03d", strm_data->delay[i]/1000,
strm_data->delay[i]%1000));
PJ_LOG(3,(THIS_FILE, "\r\n"));
pj_log_set_decor(decor);
}
/* Calculate frame ptime in usec */
ptime = test_data->samples_per_frame * 1000000 /
test_data->clock_rate;
/* Calculate jitter */
min_jitter = 0xFFFFF;
max_jitter = 0;
sum_jitter = 0;
for (i=1; i<strm_data->counter; ++i) {
int jitter1, jitter2, jitter;
/* jitter1 is interarrival difference */
jitter1 = strm_data->delay[i] - strm_data->delay[i-1];
if (jitter1 < 0) jitter1 = -jitter1;
/* jitter2 is difference between actual and scheduled arrival.
* This is intended to capture situation when frames are coming
* instantaneously, which will calculate as zero jitter with
* jitter1 calculation.
*/
jitter2 = ptime - strm_data->delay[i];
if (jitter2 < 0) jitter2 = -jitter2;
/* Set jitter as the maximum of the two jitter calculations.
* This is intended to show the worst result.
*/
jitter = (jitter1>jitter2) ? jitter1 : jitter2;
/* Calculate min, max, avg jitter */
if (jitter < (int)min_jitter) min_jitter = jitter;
if (jitter > (int)max_jitter) max_jitter = jitter;
sum_jitter += jitter;
}
avg_jitter = (sum_jitter) / (strm_data->counter - 1);
if (max_jitter < WARN_JITTER_USEC) {
PJ_LOG(3,(THIS_FILE,
" Jitter: min=%d.%03dms, avg=%d.%03dms, max=%d.%03dms",
min_jitter/1000, min_jitter%1000,
avg_jitter/1000, avg_jitter%1000,
max_jitter/1000, max_jitter%1000));
} else {
test_data->has_error = 1;
PJ_LOG(2,(THIS_FILE,
" Jitter: min=%d.%03dms, avg=%d.%03dms, max=%d.%03dms",
min_jitter/1000, min_jitter%1000,
avg_jitter/1000, avg_jitter%1000,
max_jitter/1000, max_jitter%1000));
}
}
static void print_call(int call_index)
{
struct call *call = &app.call[call_index];
int len;
pjsip_inv_session *inv = call->inv;
pjsip_dialog *dlg = inv->dlg;
struct media_stream *audio = &call->media[0];
char userinfo[128];
char duration[80], last_update[80];
char bps[16], ipbps[16], packets[16], bytes[16], ipbytes[16];
unsigned decor;
pj_time_val now;
decor = pj_log_get_decor();
pj_log_set_decor(PJ_LOG_HAS_NEWLINE);
pj_gettimeofday(&now);
if (app.report_filename)
puts(app.report_filename);
/* Print duration */
if (inv->state >= PJSIP_INV_STATE_CONFIRMED && call->connect_time.sec) {
PJ_TIME_VAL_SUB(now, call->connect_time);
sprintf(duration, " [duration: %02ld:%02ld:%02ld.%03ld]",
now.sec / 3600,
(now.sec % 3600) / 60,
(now.sec % 60),
now.msec);
} else {
duration[0] = '\0';
}
/* Call number and state */
PJ_LOG(3, (THIS_FILE,
"Call #%d: %s%s",
call_index, pjsip_inv_state_name(inv->state),
duration));
/* Call identification */
len = pjsip_hdr_print_on(dlg->remote.info, userinfo, sizeof(userinfo));
if (len < 0)
pj_ansi_strcpy(userinfo, "<--uri too long-->");
else
userinfo[len] = '\0';
PJ_LOG(3, (THIS_FILE, " %s", userinfo));
if (call->inv == NULL || call->inv->state < PJSIP_INV_STATE_CONFIRMED ||
call->connect_time.sec == 0)
{
pj_log_set_decor(decor);
return;
}
/* Signaling quality */
{
char pdd[64], connectdelay[64];
pj_time_val t;
if (call->response_time.sec) {
t = call->response_time;
PJ_TIME_VAL_SUB(t, call->start_time);
sprintf(pdd, "got 1st response in %ld ms", PJ_TIME_VAL_MSEC(t));
} else {
pdd[0] = '\0';
}
if (call->connect_time.sec) {
t = call->connect_time;
PJ_TIME_VAL_SUB(t, call->start_time);
sprintf(connectdelay, ", connected after: %ld ms",
PJ_TIME_VAL_MSEC(t));
} else {
connectdelay[0] = '\0';
}
PJ_LOG(3, (THIS_FILE,
" Signaling quality: %s%s", pdd, connectdelay));
}
PJ_LOG(3, (THIS_FILE,
" Stream #0: audio %.*s@%dHz, %dms/frame, %sB/s (%sB/s +IP hdr)",
(int)audio->si.fmt.encoding_name.slen,
audio->si.fmt.encoding_name.ptr,
audio->clock_rate,
audio->samples_per_frame * 1000 / audio->clock_rate,
good_number(bps, audio->bytes_per_frame * audio->clock_rate / audio->samples_per_frame),
good_number(ipbps, (audio->bytes_per_frame+32) * audio->clock_rate / audio->samples_per_frame)));
if (audio->rtcp.stat.rx.update_cnt == 0)
strcpy(last_update, "never");
else {
pj_gettimeofday(&now);
PJ_TIME_VAL_SUB(now, audio->rtcp.stat.rx.update);
sprintf(last_update, "%02ldh:%02ldm:%02ld.%03lds ago",
now.sec / 3600,
(now.sec % 3600) / 60,
now.sec % 60,
now.msec);
}
PJ_LOG(3, (THIS_FILE,
" RX stat last update: %s\n"
" total %s packets %sB received (%sB +IP hdr)%s\n"
" pkt loss=%d (%3.1f%%), dup=%d (%3.1f%%), reorder=%d (%3.1f%%)%s\n"
" (msec) min avg max last\n"
" loss period: %7.3f %7.3f %7.3f %7.3f%s\n"
" jitter : %7.3f %7.3f %7.3f %7.3f%s",
last_update,
good_number(packets, audio->rtcp.stat.rx.pkt),
good_number(bytes, audio->rtcp.stat.rx.bytes),
good_number(ipbytes, audio->rtcp.stat.rx.bytes + audio->rtcp.stat.rx.pkt * 32),
"",
audio->rtcp.stat.rx.loss,
audio->rtcp.stat.rx.loss * 100.0 / (audio->rtcp.stat.rx.pkt + audio->rtcp.stat.rx.loss),
audio->rtcp.stat.rx.dup,
audio->rtcp.stat.rx.dup * 100.0 / (audio->rtcp.stat.rx.pkt + audio->rtcp.stat.rx.loss),
audio->rtcp.stat.rx.reorder,
audio->rtcp.stat.rx.reorder * 100.0 / (audio->rtcp.stat.rx.pkt + audio->rtcp.stat.rx.loss),
"",
audio->rtcp.stat.rx.loss_period.min / 1000.0,
audio->rtcp.stat.rx.loss_period.mean / 1000.0,
audio->rtcp.stat.rx.loss_period.max / 1000.0,
audio->rtcp.stat.rx.loss_period.last / 1000.0,
"",
audio->rtcp.stat.rx.jitter.min / 1000.0,
audio->rtcp.stat.rx.jitter.mean / 1000.0,
audio->rtcp.stat.rx.jitter.max / 1000.0,
audio->rtcp.stat.rx.jitter.last / 1000.0,
""
));
if (audio->rtcp.stat.tx.update_cnt == 0)
strcpy(last_update, "never");
else {
pj_gettimeofday(&now);
PJ_TIME_VAL_SUB(now, audio->rtcp.stat.tx.update);
sprintf(last_update, "%02ldh:%02ldm:%02ld.%03lds ago",
now.sec / 3600,
(now.sec % 3600) / 60,
now.sec % 60,
now.msec);
}
PJ_LOG(3, (THIS_FILE,
" TX stat last update: %s\n"
" total %s packets %sB sent (%sB +IP hdr)%s\n"
" pkt loss=%d (%3.1f%%), dup=%d (%3.1f%%), reorder=%d (%3.1f%%)%s\n"
" (msec) min avg max last\n"
" loss period: %7.3f %7.3f %7.3f %7.3f%s\n"
" jitter : %7.3f %7.3f %7.3f %7.3f%s",
last_update,
good_number(packets, audio->rtcp.stat.tx.pkt),
good_number(bytes, audio->rtcp.stat.tx.bytes),
good_number(ipbytes, audio->rtcp.stat.tx.bytes + audio->rtcp.stat.tx.pkt * 32),
"",
audio->rtcp.stat.tx.loss,
audio->rtcp.stat.tx.loss * 100.0 / (audio->rtcp.stat.tx.pkt + audio->rtcp.stat.tx.loss),
audio->rtcp.stat.tx.dup,
audio->rtcp.stat.tx.dup * 100.0 / (audio->rtcp.stat.tx.pkt + audio->rtcp.stat.tx.loss),
audio->rtcp.stat.tx.reorder,
audio->rtcp.stat.tx.reorder * 100.0 / (audio->rtcp.stat.tx.pkt + audio->rtcp.stat.tx.loss),
"",
audio->rtcp.stat.tx.loss_period.min / 1000.0,
audio->rtcp.stat.tx.loss_period.mean / 1000.0,
audio->rtcp.stat.tx.loss_period.max / 1000.0,
audio->rtcp.stat.tx.loss_period.last / 1000.0,
"",
audio->rtcp.stat.tx.jitter.min / 1000.0,
audio->rtcp.stat.tx.jitter.mean / 1000.0,
audio->rtcp.stat.tx.jitter.max / 1000.0,
audio->rtcp.stat.tx.jitter.last / 1000.0,
""
));
PJ_LOG(3, (THIS_FILE,
" RTT delay : %7.3f %7.3f %7.3f %7.3f%s\n",
audio->rtcp.stat.rtt.min / 1000.0,
audio->rtcp.stat.rtt.mean / 1000.0,
audio->rtcp.stat.rtt.max / 1000.0,
audio->rtcp.stat.rtt.last / 1000.0,
""
));
pj_log_set_decor(decor);
}
