/* * 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(); }
int test_main(void) { int rc = 0; pj_caching_pool caching_pool; pj_init(); pj_caching_pool_init(&caching_pool, &pj_pool_factory_default_policy, 0); pj_log_set_decor(PJ_LOG_HAS_NEWLINE); pj_log_set_level(3); mem = &caching_pool.factory; DO_TEST(sdp_neg_test()); //DO_TEST(sdp_test (&caching_pool.factory)); //DO_TEST(rtp_test(&caching_pool.factory)); //DO_TEST(session_test (&caching_pool.factory)); DO_TEST(jbuf_main()); DO_TEST(mips_test()); DO_TEST(codec_test_vectors()); PJ_LOG(3,(THIS_FILE," ")); on_return: if (rc != 0) { PJ_LOG(3,(THIS_FILE,"Test completed with error(s)!")); } else { PJ_LOG(3,(THIS_FILE,"Looks like everything is okay!")); } pj_caching_pool_destroy(&caching_pool); return rc; }
void init_pjsip_logging(int log_level, pj_bool_t log_to_file, const std::string& directory) { pj_log_set_level(log_level); pj_log_set_decor(PJ_LOG_HAS_SENDER); pj_log_set_log_func(&pjsip_log_handler); }
static int test_inner(void) { pj_caching_pool caching_pool; int rc = 0; mem = &caching_pool.factory; #if 1 pj_log_set_level(3); pj_log_set_decor(param_log_decor); PJ_UNUSED_ARG(test_log_func); #elif 1 log_file = fopen("pjnath-test.log", "wt"); pj_log_set_level(5); orig_log_func = pj_log_get_log_func(); pj_log_set_log_func(&test_log_func); #endif rc = pj_init(); if (rc != 0) { app_perror("pj_init() error!!", rc); return rc; } pj_dump_config(); pj_caching_pool_init( &caching_pool, &pj_pool_factory_default_policy, 0 ); pjlib_util_init(); pjnath_init(); #if INCLUDE_STUN_TEST DO_TEST(stun_test()); DO_TEST(sess_auth_test()); #endif #if INCLUDE_ICE_TEST DO_TEST(ice_test()); #endif #if INCLUDE_STUN_SOCK_TEST DO_TEST(stun_sock_test()); #endif #if INCLUDE_TURN_SOCK_TEST DO_TEST(turn_sock_test()); #endif #if INCLUDE_CONCUR_TEST DO_TEST(concur_test()); #endif on_return: if (log_file) fclose(log_file); return rc; }
static int test_inner(void) { pj_caching_pool caching_pool; int rc = 0; mem = &caching_pool.factory; pj_log_set_level(3); pj_log_set_decor(param_log_decor); rc = pj_init(); if (rc != 0) { app_perror("pj_init() error!!", rc); return rc; } rc = pjlib_util_init(); pj_assert(rc == 0); pj_dump_config(); pj_caching_pool_init( &caching_pool, &pj_pool_factory_default_policy, 0 ); #if INCLUDE_XML_TEST DO_TEST(xml_test()); #endif #if INCLUDE_JSON_TEST DO_TEST(json_test()); #endif #if INCLUDE_ENCRYPTION_TEST DO_TEST(encryption_test()); DO_TEST(encryption_benchmark()); #endif #if INCLUDE_STUN_TEST DO_TEST(stun_test()); #endif #if INCLUDE_RESOLVER_TEST DO_TEST(resolver_test()); #endif #if INCLUDE_HTTP_CLIENT_TEST DO_TEST(http_client_test()); #endif on_return: return rc; }
static int test_inner(void) { pj_caching_pool caching_pool; int rc = 0; mem = &caching_pool.factory; #if 1 pj_log_set_level(5); pj_log_set_decor(param_log_decor); #endif rc = pj_init(); if (rc != 0) { app_perror("pj_init() error!!", rc); return rc; } pj_dump_config(); pj_caching_pool_init( &caching_pool, &pj_pool_factory_default_policy, 0 ); pjlib_util_init(); pjnath_init(); #if INCLUDE_STUN_TEST DO_TEST(stun_test()); DO_TEST(sess_auth_test()); #endif #if INCLUDE_ICE_TEST DO_TEST(ice_test()); #endif #if INCLUDE_STUN_SOCK_TEST DO_TEST(stun_sock_test()); #endif #if INCLUDE_TURN_SOCK_TEST DO_TEST(turn_sock_test()); #endif on_return: return rc; }
/* Application init */ static pj_status_t app_init() { unsigned i, count; pj_status_t status; /* Redirect log */ pj_log_set_log_func((void (*)(int,const char*,int)) &log_writer); pj_log_set_decor(PJ_LOG_HAS_NEWLINE); pj_log_set_level(3); /* Init pjlib */ status = pj_init(); if (status != PJ_SUCCESS) { app_perror("pj_init()", status); return status; } pj_caching_pool_init(&cp, NULL, 0); /* Init sound subsystem */ status = pjmedia_snd_init(&cp.factory); if (status != PJ_SUCCESS) { app_perror("pjmedia_snd_init()", status); pj_caching_pool_destroy(&cp); pj_shutdown(); return status; } count = pjmedia_snd_get_dev_count(); PJ_LOG(3,(THIS_FILE, "Device count: %d", count)); for (i=0; i<count; ++i) { const pjmedia_snd_dev_info *info; info = pjmedia_snd_get_dev_info(i); PJ_LOG(3, (THIS_FILE, "%d: %s %d/%d %dHz", i, info->name, info->input_count, info->output_count, info->default_samples_per_sec)); } /* Create pool */ pool = pj_pool_create(&cp.factory, THIS_FILE, 512, 512, NULL); if (pool == NULL) { app_perror("pj_pool_create()", status); pj_caching_pool_destroy(&cp); pj_shutdown(); return status; } /* Init delay buffer */ status = pjmedia_delay_buf_create(pool, THIS_FILE, CLOCK_RATE, SAMPLES_PER_FRAME, CHANNEL_COUNT, 0, 0, &delaybuf); if (status != PJ_SUCCESS) { app_perror("pjmedia_delay_buf_create()", status); //pj_caching_pool_destroy(&cp); //pj_shutdown(); //return status; } return PJ_SUCCESS; }
int test_main(void) { pj_status_t rc; pj_caching_pool caching_pool; const char *filename; unsigned tsx_test_cnt=0; struct tsx_test_param tsx_test[10]; pj_status_t status; #if INCLUDE_TSX_TEST unsigned i; pjsip_transport *tp; #if PJ_HAS_TCP pjsip_tpfactory *tpfactory; #endif /* PJ_HAS_TCP */ #endif /* INCLUDE_TSX_TEST */ int line; pj_log_set_level(log_level); pj_log_set_decor(param_log_decor); if ((rc=pj_init()) != PJ_SUCCESS) { app_perror("pj_init", rc); return rc; } if ((rc=pjlib_util_init()) != PJ_SUCCESS) { app_perror("pj_init", rc); return rc; } status = init_report(); if (status != PJ_SUCCESS) return status; pj_dump_config(); pj_caching_pool_init( &caching_pool, &pj_pool_factory_default_policy, PJSIP_TEST_MEM_SIZE ); rc = pjsip_endpt_create(&caching_pool.factory, "endpt", &endpt); if (rc != PJ_SUCCESS) { app_perror("pjsip_endpt_create", rc); pj_caching_pool_destroy(&caching_pool); return rc; } PJ_LOG(3,(THIS_FILE,"")); /* Init logger module. */ init_msg_logger(); msg_logger_set_enabled(1); /* Start transaction layer module. */ rc = pjsip_tsx_layer_init_module(endpt); if (rc != PJ_SUCCESS) { app_perror(" Error initializing transaction module", rc); goto on_return; } /* Create loop transport. */ rc = pjsip_loop_start(endpt, NULL); if (rc != PJ_SUCCESS) { app_perror(" error: unable to create datagram loop transport", rc); goto on_return; } tsx_test[tsx_test_cnt].port = 5060; tsx_test[tsx_test_cnt].tp_type = "loop-dgram"; tsx_test[tsx_test_cnt].type = PJSIP_TRANSPORT_LOOP_DGRAM; ++tsx_test_cnt; #if INCLUDE_URI_TEST DO_TEST(uri_test()); #endif #if INCLUDE_MSG_TEST DO_TEST(msg_test()); DO_TEST(msg_err_test()); #endif #if INCLUDE_MULTIPART_TEST DO_TEST(multipart_test()); #endif #if INCLUDE_TXDATA_TEST DO_TEST(txdata_test()); #endif #if INCLUDE_TSX_BENCH DO_TEST(tsx_bench()); #endif #if INCLUDE_UDP_TEST DO_TEST(transport_udp_test()); #endif #if INCLUDE_LOOP_TEST DO_TEST(transport_loop_test()); #endif #if INCLUDE_TCP_TEST DO_TEST(transport_tcp_test()); #endif #if INCLUDE_RESOLVE_TEST DO_TEST(resolve_test()); #endif #if INCLUDE_TSX_TEST status = pjsip_udp_transport_start(endpt, NULL, NULL, 1, &tp); if (status == PJ_SUCCESS) { tsx_test[tsx_test_cnt].port = tp->local_name.port; tsx_test[tsx_test_cnt].tp_type = "udp"; tsx_test[tsx_test_cnt].type = PJSIP_TRANSPORT_UDP; ++tsx_test_cnt; } #if PJ_HAS_TCP status = pjsip_tcp_transport_start(endpt, NULL, 1, &tpfactory); if (status == PJ_SUCCESS) { tsx_test[tsx_test_cnt].port = tpfactory->addr_name.port; tsx_test[tsx_test_cnt].tp_type = "tcp"; tsx_test[tsx_test_cnt].type = PJSIP_TRANSPORT_TCP; ++tsx_test_cnt; } else { app_perror("Unable to create TCP", status); rc = -4; goto on_return; } #endif for (i=0; i<tsx_test_cnt; ++i) { DO_TSX_TEST(tsx_basic_test, &tsx_test[i]); DO_TSX_TEST(tsx_uac_test, &tsx_test[i]); DO_TSX_TEST(tsx_uas_test, &tsx_test[i]); } #endif #if INCLUDE_INV_OA_TEST DO_TEST(inv_offer_answer_test()); #endif #if INCLUDE_REGC_TEST DO_TEST(regc_test()); #endif on_return: flush_events(500); /* Dumping memory pool usage */ PJ_LOG(3,(THIS_FILE, "Peak memory size=%u MB", caching_pool.peak_used_size / 1000000)); pjsip_endpt_destroy(endpt); pj_caching_pool_destroy(&caching_pool); PJ_LOG(3,(THIS_FILE, "")); pj_thread_get_stack_info(pj_thread_this(), &filename, &line); PJ_LOG(3,(THIS_FILE, "Stack max usage: %u, deepest: %s:%u", pj_thread_get_stack_max_usage(pj_thread_this()), filename, line)); if (rc == 0) PJ_LOG(3,(THIS_FILE, "Looks like everything is okay!..")); else PJ_LOG(3,(THIS_FILE, "Test completed with error(s)")); report_ival("test-status", rc, "", "Overall test status/result (0==success)"); close_report(); return rc; }
int test_inner(void) { pj_caching_pool caching_pool; const char *filename; int line; int rc = 0; mem = &caching_pool.factory; pj_log_set_level(3); pj_log_set_decor(param_log_decor); rc = pj_init(); if (rc != 0) { app_perror("pj_init() error!!", rc); return rc; } //pj_dump_config(); pj_caching_pool_init( &caching_pool, NULL, 0 ); #if INCLUDE_ERRNO_TEST DO_TEST( errno_test() ); #endif #if INCLUDE_EXCEPTION_TEST DO_TEST( exception_test() ); #endif #if INCLUDE_OS_TEST DO_TEST( os_test() ); #endif #if INCLUDE_RAND_TEST DO_TEST( rand_test() ); #endif #if INCLUDE_LIST_TEST DO_TEST( list_test() ); #endif #if INCLUDE_POOL_TEST DO_TEST( pool_test() ); #endif #if INCLUDE_POOL_PERF_TEST DO_TEST( pool_perf_test() ); #endif #if INCLUDE_STRING_TEST DO_TEST( string_test() ); #endif #if INCLUDE_FIFOBUF_TEST DO_TEST( fifobuf_test() ); #endif #if INCLUDE_RBTREE_TEST DO_TEST( rbtree_test() ); #endif #if INCLUDE_HASH_TEST DO_TEST( hash_test() ); #endif #if INCLUDE_TIMESTAMP_TEST DO_TEST( timestamp_test() ); #endif #if INCLUDE_ATOMIC_TEST DO_TEST( atomic_test() ); #endif #if INCLUDE_MUTEX_TEST DO_TEST( mutex_test() ); #endif #if INCLUDE_TIMER_TEST DO_TEST( timer_test() ); #endif #if INCLUDE_SLEEP_TEST DO_TEST( sleep_test() ); #endif #if INCLUDE_THREAD_TEST DO_TEST( thread_test() ); #endif #if INCLUDE_SOCK_TEST DO_TEST( sock_test() ); #endif #if INCLUDE_SOCK_PERF_TEST DO_TEST( sock_perf_test() ); #endif #if INCLUDE_SELECT_TEST DO_TEST( select_test() ); #endif #if INCLUDE_UDP_IOQUEUE_TEST DO_TEST( udp_ioqueue_test() ); #endif #if PJ_HAS_TCP && INCLUDE_TCP_IOQUEUE_TEST DO_TEST( tcp_ioqueue_test() ); #endif #if INCLUDE_IOQUEUE_PERF_TEST DO_TEST( ioqueue_perf_test() ); #endif #if INCLUDE_IOQUEUE_UNREG_TEST DO_TEST( udp_ioqueue_unreg_test() ); #endif #if INCLUDE_ACTIVESOCK_TEST DO_TEST( activesock_test() ); #endif #if INCLUDE_FILE_TEST DO_TEST( file_test() ); #endif #if INCLUDE_SSLSOCK_TEST DO_TEST( ssl_sock_test() ); #endif #if INCLUDE_ECHO_SERVER //echo_server(); //echo_srv_sync(); udp_echo_srv_ioqueue(); #elif INCLUDE_ECHO_CLIENT if (param_echo_sock_type == 0) param_echo_sock_type = pj_SOCK_DGRAM(); echo_client( param_echo_sock_type, param_echo_server, param_echo_port); #endif goto on_return; on_return: pj_caching_pool_destroy( &caching_pool ); PJ_LOG(3,("test", "")); pj_thread_get_stack_info(pj_thread_this(), &filename, &line); PJ_LOG(3,("test", "Stack max usage: %u, deepest: %s:%u", pj_thread_get_stack_max_usage(pj_thread_this()), filename, line)); if (rc == 0) PJ_LOG(3,("test", "Looks like everything is okay!..")); else PJ_LOG(3,("test", "Test completed with error(s)")); pj_shutdown(); return 0; }
static pj_status_t test_init(void) { struct stream_cfg strm_cfg; pj_status_t status; /* Must init PJLIB first: */ status = pj_init(); PJ_ASSERT_RETURN(status == PJ_SUCCESS, status); /* Must create a pool factory before we can allocate any memory. */ pj_caching_pool_init(&g_app.cp, &pj_pool_factory_default_policy, 0); /* Pool */ g_app.pool = pj_pool_create(&g_app.cp.factory, "g_app", 512, 512, NULL); /* Log file */ if (g_app.cfg.log_file) { status = pj_file_open(g_app.pool, g_app.cfg.log_file, PJ_O_WRONLY, &g_app.log_fd); if (status != PJ_SUCCESS) { jbsim_perror("Error writing output file", status); goto on_error; } pj_log_set_decor(PJ_LOG_HAS_SENDER | PJ_LOG_HAS_COLOR | PJ_LOG_HAS_LEVEL_TEXT); pj_log_set_log_func(&log_cb); } /* * Initialize media endpoint. * This will implicitly initialize PJMEDIA too. */ status = pjmedia_endpt_create(&g_app.cp.factory, NULL, 0, &g_app.endpt); if (status != PJ_SUCCESS) { jbsim_perror("Error creating media endpoint", status); goto on_error; } /* Register codecs */ pjmedia_codec_register_audio_codecs(g_app.endpt, NULL); /* Create the loop transport */ status = pjmedia_transport_loop_create(g_app.endpt, &g_app.loop); if (status != PJ_SUCCESS) { jbsim_perror("Error creating loop transport", status); goto on_error; } /* Create transmitter stream */ pj_bzero(&strm_cfg, sizeof(strm_cfg)); strm_cfg.name = "tx"; strm_cfg.dir = PJMEDIA_DIR_ENCODING; strm_cfg.codec = g_app.cfg.codec; strm_cfg.ptime = g_app.cfg.tx_ptime; strm_cfg.dtx = g_app.cfg.tx_dtx; strm_cfg.plc = PJ_TRUE; status = stream_init(&strm_cfg, &g_app.tx); if (status != PJ_SUCCESS) goto on_error; /* Create transmitter WAV */ status = pjmedia_wav_player_port_create(g_app.pool, g_app.cfg.tx_wav_in, g_app.cfg.tx_ptime, 0, 0, &g_app.tx_wav); if (status != PJ_SUCCESS) { jbsim_perror("Error reading input WAV file", status); goto on_error; } /* Make sure stream and WAV parameters match */ if (PJMEDIA_PIA_SRATE(&g_app.tx_wav->info) != PJMEDIA_PIA_SRATE(&g_app.tx->port->info) || PJMEDIA_PIA_CCNT(&g_app.tx_wav->info) != PJMEDIA_PIA_CCNT(&g_app.tx->port->info)) { jbsim_perror("Error: Input WAV file has different clock rate " "or number of channels than the codec", PJ_SUCCESS); goto on_error; } /* Create receiver */ pj_bzero(&strm_cfg, sizeof(strm_cfg)); strm_cfg.name = "rx"; strm_cfg.dir = PJMEDIA_DIR_DECODING; strm_cfg.codec = g_app.cfg.codec; strm_cfg.ptime = g_app.cfg.rx_ptime; strm_cfg.dtx = PJ_TRUE; strm_cfg.plc = g_app.cfg.rx_plc; status = stream_init(&strm_cfg, &g_app.rx); if (status != PJ_SUCCESS) goto on_error; /* Create receiver WAV */ status = pjmedia_wav_writer_port_create(g_app.pool, g_app.cfg.rx_wav_out, PJMEDIA_PIA_SRATE(&g_app.rx->port->info), PJMEDIA_PIA_CCNT(&g_app.rx->port->info), PJMEDIA_PIA_SPF(&g_app.rx->port->info), PJMEDIA_PIA_BITS(&g_app.rx->port->info), 0, 0, &g_app.rx_wav); if (status != PJ_SUCCESS) { jbsim_perror("Error creating output WAV file", status); goto on_error; } /* Frame buffer */ g_app.framebuf = (pj_int16_t*) pj_pool_alloc(g_app.pool, MAX(PJMEDIA_PIA_SPF(&g_app.rx->port->info), PJMEDIA_PIA_SPF(&g_app.tx->port->info)) * sizeof(pj_int16_t)); /* Set the receiver in the loop transport */ pjmedia_transport_loop_disable_rx(g_app.loop, g_app.tx->strm, PJ_TRUE); /* Done */ return PJ_SUCCESS; on_error: test_destroy(); return status; }
/* Application init */ static pj_status_t app_init() { unsigned i, count; pj_status_t status; /* Redirect log */ pj_log_set_log_func((void (*)(int,const char*,int)) &log_writer); pj_log_set_decor(PJ_LOG_HAS_NEWLINE); pj_log_set_level(3); /* Init pjlib */ status = pj_init(); if (status != PJ_SUCCESS) { app_perror("pj_init()", status); return status; } pj_caching_pool_init(&cp, NULL, 0); /* Init sound subsystem */ status = pjmedia_aud_subsys_init(&cp.factory); if (status != PJ_SUCCESS) { app_perror("pjmedia_snd_init()", status); pj_caching_pool_destroy(&cp); pj_shutdown(); return status; } count = pjmedia_aud_dev_count(); PJ_LOG(3,(THIS_FILE, "Device count: %d", count)); for (i=0; i<count; ++i) { pjmedia_aud_dev_info info; pj_status_t status; status = pjmedia_aud_dev_get_info(i, &info); pj_assert(status == PJ_SUCCESS); PJ_LOG(3, (THIS_FILE, "%d: %s %d/%d %dHz", i, info.name, info.input_count, info.output_count, info.default_samples_per_sec)); unsigned j; /* Print extended formats supported by this audio device */ PJ_LOG(3, (THIS_FILE, " Extended formats supported:")); for (j = 0; j < info.ext_fmt_cnt; ++j) { const char *fmt_name = NULL; switch (info.ext_fmt[j].id) { case PJMEDIA_FORMAT_PCMA: fmt_name = "PCMA"; break; case PJMEDIA_FORMAT_PCMU: fmt_name = "PCMU"; break; case PJMEDIA_FORMAT_AMR: fmt_name = "AMR-NB"; break; case PJMEDIA_FORMAT_G729: fmt_name = "G729"; break; case PJMEDIA_FORMAT_ILBC: fmt_name = "ILBC"; break; case PJMEDIA_FORMAT_PCM: fmt_name = "PCM"; break; default: fmt_name = "Unknown"; break; } PJ_LOG(3, (THIS_FILE, " - %s", fmt_name)); } } /* Create pool */ pool = pj_pool_create(&cp.factory, THIS_FILE, 512, 512, NULL); if (pool == NULL) { app_perror("pj_pool_create()", status); pj_caching_pool_destroy(&cp); pj_shutdown(); return status; } /* Init delay buffer */ status = pjmedia_delay_buf_create(pool, THIS_FILE, CLOCK_RATE, SAMPLES_PER_FRAME, CHANNEL_COUNT, 0, 0, &delaybuf); if (status != PJ_SUCCESS) { app_perror("pjmedia_delay_buf_create()", status); //pj_caching_pool_destroy(&cp); //pj_shutdown(); //return status; } return PJ_SUCCESS; }
int main() { pj_caching_pool cp; pj_bool_t done = PJ_FALSE; pj_status_t status; /* Init pjlib */ status = pj_init(); PJ_ASSERT_RETURN(status==PJ_SUCCESS, 1); pj_log_set_decor(PJ_LOG_HAS_NEWLINE); /* Must create a pool factory before we can allocate any memory. */ pj_caching_pool_init(&cp, &pj_pool_factory_default_policy, 0); status = pjmedia_aud_subsys_init(&cp.factory); if (status != PJ_SUCCESS) { app_perror("pjmedia_aud_subsys_init()", status); pj_caching_pool_destroy(&cp); pj_shutdown(); return 1; } list_devices(); while (!done) { char line[80]; print_menu(); if (fgets(line, sizeof(line), stdin)==NULL) break; switch (line[0]) { case 'l': list_devices(); break; case 'R': pjmedia_aud_dev_refresh(); puts("Audio device list refreshed."); break; case 'i': { unsigned dev_index; if (sscanf(line+2, "%u", &dev_index) != 1) { puts("error: device ID required"); break; } show_dev_info(dev_index); } break; case 't': { pjmedia_dir dir; int rec_id, play_id; unsigned clock_rate, ptime, chnum; int cnt; cnt = sscanf(line+2, "%d %d %u %u %u", &rec_id, &play_id, &clock_rate, &ptime, &chnum); if (cnt < 4) { puts("error: not enough parameters"); break; } if (clock_rate < 8000 || clock_rate > 128000) { puts("error: invalid clock rate"); break; } if (ptime < 10 || ptime > 500) { puts("error: invalid ptime"); break; } if (cnt==5) { if (chnum < 1 || chnum > 4) { puts("error: invalid number of channels"); break; } } else { chnum = 1; } if (rec_id >= 0 && rec_id < (int)dev_count) { if (play_id >= 0 && play_id < (int)dev_count) dir = PJMEDIA_DIR_CAPTURE_PLAYBACK; else dir = PJMEDIA_DIR_CAPTURE; } else if (play_id >= 0 && play_id < (int)dev_count) { dir = PJMEDIA_DIR_PLAYBACK; } else { puts("error: at least one valid device index required"); break; } test_device(dir, rec_id, play_id, clock_rate, ptime, chnum); } break; case 'r': /* record */ { int index; char filename[80]; int count; count = sscanf(line+2, "%d %s", &index, filename); if (count==1) record(index, NULL); else if (count==2) record(index, filename); else puts("error: invalid command syntax"); } break; case 'p': /* playback */ { int index; char filename[80]; int count; count = sscanf(line+2, "%d %s", &index, filename); if (count==1) play_file(index, NULL); else if (count==2) play_file(index, filename); else puts("error: invalid command syntax"); } break; case 'd': /* latencies */ { int rec_lat, play_lat; if (sscanf(line+2, "%d %d", &rec_lat, &play_lat) == 2) { capture_lat = (unsigned) (rec_lat>=0? rec_lat:PJMEDIA_SND_DEFAULT_REC_LATENCY); playback_lat = (unsigned) (play_lat >= 0? play_lat : PJMEDIA_SND_DEFAULT_PLAY_LATENCY); printf("Recording latency=%ums, playback latency=%ums", capture_lat, playback_lat); } else { printf("Current latencies: record=%ums, playback=%ums", capture_lat, playback_lat); } puts(""); } break; case 'v': if (pj_log_get_level() <= 3) { pj_log_set_level(5); puts("Logging set to detail"); } else { pj_log_set_level(3); puts("Logging set to quiet"); } break; case 'q': done = PJ_TRUE; break; } } pj_caching_pool_destroy(&cp); pj_shutdown(); return 0; }
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); }
JNIEXPORT jint JNICALL Java_org_sipdroid_pjlib_codec_open (JNIEnv *env, jclass cls, jstring codec_id) { int rc = 0; unsigned count = 1; LOGE("Intializing PJLIB..."); pj_init(); pj_caching_pool_init(&caching_pool, &pj_pool_factory_default_policy, 0); pj_log_set_decor(PJ_LOG_HAS_NEWLINE); pj_log_set_level(3); mem = &caching_pool.factory; char* ctmp; jboolean iscopy; const char *codec_str = env->GetStringUTFChars(codec_id, &iscopy); ctmp = const_cast<char*>(codec_str); const pj_str_t pj_codec_str = pj_str(ctmp); unsigned clock_rate = 8000; LOGE("pj_pool_create"); pool = pj_pool_create(mem, "pool", 1024, 1024, NULL); LOGE("PJ_POOL_ZALLOC_T"); cp = PJ_POOL_ZALLOC_T(pool, struct codec_port); LOGE("pjmedia_endpt_create"); status = pjmedia_endpt_create(mem, NULL, 0, &cp->endpt); if (status != PJ_SUCCESS) return NULL; cm = pjmedia_endpt_get_codec_mgr(cp->endpt); #if PJMEDIA_HAS_G711_CODEC CHECK( pjmedia_codec_g711_init(cp->endpt) ); #endif #if PJMEDIA_HAS_GSM_CODEC CHECK( pjmedia_codec_gsm_init(cp->endpt) ); #endif #if PJMEDIA_HAS_ILBC_CODEC CHECK( pjmedia_codec_ilbc_init(cp->endpt, 30) ); #endif #if PJMEDIA_HAS_SPEEX_CODEC CHECK( pjmedia_codec_speex_init(cp->endpt, 0, 5, 5) ); #endif #if PJMEDIA_HAS_G722_CODEC CHECK( pjmedia_codec_g722_init(cp->endpt) ); #endif LOGE("pjmedia_codec_mgr_find_codecs_by_id: %s", codec_str); CHECK( status = pjmedia_codec_mgr_find_codecs_by_id(cm, &pj_codec_str, &count, &ci, NULL) ); if (status != PJ_SUCCESS) { LOGE("Cannot find codec"); return NULL; } LOGE("pjmedia_codec_mgr_get_default_param"); CHECK( status = pjmedia_codec_mgr_get_default_param(cm, ci, ¶m) ); if (status != PJ_SUCCESS) { LOGE("pjmedia_codec_mgr_get_default_param failed"); return NULL; } //param.setting.vad = 1; LOGE("pjmedia_codec_mgr_alloc_codec"); CHECK( status = pjmedia_codec_mgr_alloc_codec(cm, ci, &cp->codec) ); if (status != PJ_SUCCESS) { LOGE("Cannot allocate codec"); return NULL; } LOGE("codec->op->init"); // channels=%d frm_ptime=%s", ci->channel_cnt, param.info.frm_ptime); status = (*cp->codec->op->init)(cp->codec, pool); if (status != PJ_SUCCESS) return NULL; LOGE("codec->op->open"); status = cp->codec->op->open(cp->codec, ¶m); if (status != PJ_SUCCESS) return NULL; samples_per_frame = param.info.clock_rate * param.info.frm_ptime / 1000; LOGE("Finished initializing codec..."); LOGE(" -> clock_rate=%d channel_count=%d samples_per_frame=%d pcm_bits_per_sample=%d", param.info.clock_rate, param.info.channel_cnt, \ samples_per_frame, param.info.pcm_bits_per_sample); return (jint)PJ_SUCCESS; }
pj_status_t latency_checker::start(latency_config_t &config) { pj_status_t result = PJ_EINVAL; if(m_pool == NULL) { m_dstate = 0; m_start_tone_time.u64 = 0; m_latency = 0; m_quality = 0; m_config = config; m_status_string[0] = 0; m_gain = new snd_agc("",30,1,32000,32000); m_idle_freq1_det = new tone_detector(m_config.clock_rate,IDLE_FREQ1); m_idle_freq2_det = new tone_detector(m_config.clock_rate,IDLE_FREQ2); m_active_freq1_det = new tone_detector(m_config.clock_rate,ACTIVE_FREQ1); m_active_freq2_det = new tone_detector(m_config.clock_rate,ACTIVE_FREQ2); init_generate_dual_tone(&m_idle_tone,m_config.clock_rate,IDLE_FREQ1,IDLE_FREQ2,32767); init_generate_dual_tone(&m_active_tone,m_config.clock_rate,ACTIVE_FREQ1,ACTIVE_FREQ2,32767); pj_log_set_level(0); pj_log_set_decor(PJ_LOG_HAS_NEWLINE | PJ_LOG_HAS_SENDER | PJ_LOG_HAS_TIME | PJ_LOG_HAS_MICRO_SEC); if(pj_init()==PJ_SUCCESS) { m_caching_pool = (pj_caching_pool *)malloc(sizeof(pj_caching_pool)); pj_caching_pool_init( m_caching_pool, NULL, 0 ); m_pool_factory=&m_caching_pool->factory; m_pool = pj_pool_create(m_pool_factory, "LATENCY NATIVE", 4000, 4000, NULL); pj_log_set_level(m_config.logs.level); pj_logging_init(m_pool); pj_logging_setLogToConsole(1); pj_logging_setFilename(m_config.logs.file_name); pj_logging_setMaxLogFiles(m_config.logs.max_files); pj_logging_setMaxLogFileSize(m_config.logs.max_file_size*1024*1024); pj_logging_start(); pj_get_timestamp(&m_last_get_frame_time); m_lock = new PPJ_SemaphoreLock(m_pool,NULL,1,1); pjmedia_aud_subsys_init(m_pool_factory); #if PJMEDIA_AUDIO_DEV_HAS_ANDROID #if PJ_ANDROID_DEVICE==1 pjmedia_aud_register_factory(&pjmedia_android_factory); #endif #if PJ_ANDROID_DEVICE==2 pjmedia_aud_register_factory(&pjmedia_opensl_factory); #endif #if PJ_ANDROID_DEVICE==3 pjmedia_aud_register_factory(&pjmedia_alsa_factory); #endif #endif pjmedia_aud_param params; params.dir = PJMEDIA_DIR_CAPTURE_PLAYBACK; params.rec_id = 1; params.play_id = 6; params.clock_rate = m_config.clock_rate; params.channel_count = 1; params.samples_per_frame = m_config.min_frame_length*m_config.clock_rate/1000; params.bits_per_sample = 16; params.flags = PJMEDIA_AUD_DEV_CAP_INPUT_LATENCY | PJMEDIA_AUD_DEV_CAP_OUTPUT_LATENCY; params.input_latency_ms = m_config.min_frame_length; params.output_latency_ms = m_config.min_frame_length; result = pjmedia_aud_stream_create(¶ms,&rec_cb_s,&play_cb_s,this,&m_aud_stream); if(result==PJ_SUCCESS) { result = pjmedia_aud_stream_start(m_aud_stream); if(result==PJ_SUCCESS) { } } } } if(result!=PJ_SUCCESS) internal_clean(); return result; }
static pj_status_t test_init(void) { struct stream_cfg strm_cfg; pj_status_t status; /* Must init PJLIB first: */ status = pj_init(); PJ_ASSERT_RETURN(status == PJ_SUCCESS, status); /* Must create a pool factory before we can allocate any memory. */ pj_caching_pool_init(&g_app.cp, &pj_pool_factory_default_policy, 0); /* Pool */ g_app.pool = pj_pool_create(&g_app.cp.factory, "g_app", 512, 512, NULL); /* Log file */ if (g_app.cfg.log_file) { status = pj_file_open(g_app.pool, g_app.cfg.log_file, PJ_O_WRONLY, &g_app.log_fd); if (status != PJ_SUCCESS) { jbsim_perror("Error writing output file", status); goto on_error; } pj_log_set_decor(PJ_LOG_HAS_SENDER | PJ_LOG_HAS_COLOR | PJ_LOG_HAS_LEVEL_TEXT); pj_log_set_log_func(&log_cb); } /* * Initialize media endpoint. * This will implicitly initialize PJMEDIA too. */ status = pjmedia_endpt_create(&g_app.cp.factory, NULL, 0, &g_app.endpt); if (status != PJ_SUCCESS) { jbsim_perror("Error creating media endpoint", status); goto on_error; } /* Register codecs */ #if defined(PJMEDIA_HAS_GSM_CODEC) && PJMEDIA_HAS_GSM_CODEC != 0 pjmedia_codec_gsm_init(g_app.endpt); #endif #if defined(PJMEDIA_HAS_G711_CODEC) && PJMEDIA_HAS_G711_CODEC!=0 pjmedia_codec_g711_init(g_app.endpt); #endif #if defined(PJMEDIA_HAS_SPEEX_CODEC) && PJMEDIA_HAS_SPEEX_CODEC!=0 pjmedia_codec_speex_init(g_app.endpt, 0, PJMEDIA_CODEC_SPEEX_DEFAULT_QUALITY, PJMEDIA_CODEC_SPEEX_DEFAULT_COMPLEXITY); #endif #if defined(PJMEDIA_HAS_G722_CODEC) && (PJMEDIA_HAS_G722_CODEC != 0) pjmedia_codec_g722_init(g_app.endpt); #endif #if defined(PJMEDIA_HAS_ILBC_CODEC) && PJMEDIA_HAS_ILBC_CODEC != 0 /* Init ILBC with mode=20 to make the losts occur at the same * places as other codecs. */ pjmedia_codec_ilbc_init(g_app.endpt, 20); #endif #if defined(PJMEDIA_HAS_INTEL_IPP) && PJMEDIA_HAS_INTEL_IPP != 0 pjmedia_codec_ipp_init(g_app.endpt); #endif #if defined(PJMEDIA_HAS_OPENCORE_AMRNB_CODEC) && (PJMEDIA_HAS_OPENCORE_AMRNB_CODEC != 0) pjmedia_codec_opencore_amrnb_init(g_app.endpt); #endif #if defined(PJMEDIA_HAS_L16_CODEC) && PJMEDIA_HAS_L16_CODEC != 0 pjmedia_codec_l16_init(g_app.endpt, 0); #endif /* Create the loop transport */ status = pjmedia_transport_loop_create(g_app.endpt, &g_app.loop); if (status != PJ_SUCCESS) { jbsim_perror("Error creating loop transport", status); goto on_error; } /* Create transmitter stream */ pj_bzero(&strm_cfg, sizeof(strm_cfg)); strm_cfg.name = "tx"; strm_cfg.dir = PJMEDIA_DIR_ENCODING; strm_cfg.codec = g_app.cfg.codec; strm_cfg.ptime = g_app.cfg.tx_ptime; strm_cfg.dtx = g_app.cfg.tx_dtx; strm_cfg.plc = PJ_TRUE; status = stream_init(&strm_cfg, &g_app.tx); if (status != PJ_SUCCESS) goto on_error; /* Create transmitter WAV */ status = pjmedia_wav_player_port_create(g_app.pool, g_app.cfg.tx_wav_in, g_app.cfg.tx_ptime, 0, 0, &g_app.tx_wav); if (status != PJ_SUCCESS) { jbsim_perror("Error reading input WAV file", status); goto on_error; } /* Make sure stream and WAV parameters match */ if (g_app.tx_wav->info.clock_rate != g_app.tx->port->info.clock_rate || g_app.tx_wav->info.channel_count != g_app.tx->port->info.channel_count) { jbsim_perror("Error: Input WAV file has different clock rate " "or number of channels than the codec", PJ_SUCCESS); goto on_error; } /* Create receiver */ pj_bzero(&strm_cfg, sizeof(strm_cfg)); strm_cfg.name = "rx"; strm_cfg.dir = PJMEDIA_DIR_DECODING; strm_cfg.codec = g_app.cfg.codec; strm_cfg.ptime = g_app.cfg.rx_ptime; strm_cfg.dtx = PJ_TRUE; strm_cfg.plc = g_app.cfg.rx_plc; status = stream_init(&strm_cfg, &g_app.rx); if (status != PJ_SUCCESS) goto on_error; /* Create receiver WAV */ status = pjmedia_wav_writer_port_create(g_app.pool, g_app.cfg.rx_wav_out, g_app.rx->port->info.clock_rate, g_app.rx->port->info.channel_count, g_app.rx->port->info.samples_per_frame, g_app.rx->port->info.bits_per_sample, 0, 0, &g_app.rx_wav); if (status != PJ_SUCCESS) { jbsim_perror("Error creating output WAV file", status); goto on_error; } /* Frame buffer */ g_app.framebuf = (pj_int16_t*) pj_pool_alloc(g_app.pool, MAX(g_app.rx->port->info.samples_per_frame, g_app.tx->port->info.samples_per_frame) * sizeof(pj_int16_t)); /* Set the receiver in the loop transport */ pjmedia_transport_loop_disable_rx(g_app.loop, g_app.tx->strm, PJ_TRUE); /* Done */ return PJ_SUCCESS; on_error: test_destroy(); return status; }
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)); } }
int test_main(void) { int rc = 0; pj_caching_pool caching_pool; pj_pool_t *pool; pj_init(); pj_caching_pool_init(&caching_pool, &pj_pool_factory_default_policy, 0); pool = pj_pool_create(&caching_pool.factory, "test", 1000, 512, NULL); pj_log_set_decor(PJ_LOG_HAS_NEWLINE); pj_log_set_level(3); mem = &caching_pool.factory; #if defined(PJMEDIA_HAS_VIDEO) && (PJMEDIA_HAS_VIDEO != 0) pjmedia_video_format_mgr_create(pool, 64, 0, NULL); pjmedia_converter_mgr_create(pool, NULL); pjmedia_event_mgr_create(pool, 0, NULL); pjmedia_vid_codec_mgr_create(pool, NULL); #endif #if HAS_VID_PORT_TEST DO_TEST(vid_port_test()); #endif #if HAS_VID_DEV_TEST DO_TEST(vid_dev_test()); #endif #if HAS_VID_CODEC_TEST DO_TEST(vid_codec_test()); #endif #if HAS_SDP_NEG_TEST DO_TEST(sdp_neg_test()); #endif //DO_TEST(sdp_test (&caching_pool.factory)); //DO_TEST(rtp_test(&caching_pool.factory)); //DO_TEST(session_test (&caching_pool.factory)); #if HAS_JBUF_TEST DO_TEST(jbuf_main()); #endif #if HAS_MIPS_TEST DO_TEST(mips_test()); #endif #if HAS_CODEC_VECTOR_TEST DO_TEST(codec_test_vectors()); #endif PJ_LOG(3,(THIS_FILE," ")); on_return: if (rc != 0) { PJ_LOG(3,(THIS_FILE,"Test completed with error(s)!")); } else { PJ_LOG(3,(THIS_FILE,"Looks like everything is okay!")); } #if defined(PJMEDIA_HAS_VIDEO) && (PJMEDIA_HAS_VIDEO != 0) pjmedia_video_format_mgr_destroy(pjmedia_video_format_mgr_instance()); pjmedia_converter_mgr_destroy(pjmedia_converter_mgr_instance()); pjmedia_event_mgr_destroy(pjmedia_event_mgr_instance()); pjmedia_vid_codec_mgr_destroy(pjmedia_vid_codec_mgr_instance()); #endif pj_pool_release(pool); pj_caching_pool_destroy(&caching_pool); return rc; }