static void cleanup()
{
if (app.srtp) pjmedia_transport_close(app.srtp);
if (app.wav) {
pj_ssize_t pos = pjmedia_wav_writer_port_get_pos(app.wav);
if (pos >= 0) {
unsigned msec;
msec = (unsigned)pos / 2 * 1000 / PJMEDIA_PIA_SRATE(&app.wav->info);
printf("Written: %dm:%02ds.%03d\n",
msec / 1000 / 60,
(msec / 1000) % 60,
msec % 1000);
}
pjmedia_port_destroy(app.wav);
}
if (app.pcap) pj_pcap_close(app.pcap);
if (app.codec) {
pjmedia_codec_mgr *cmgr;
pjmedia_codec_close(app.codec);
cmgr = pjmedia_endpt_get_codec_mgr(app.mept);
pjmedia_codec_mgr_dealloc_codec(cmgr, app.codec);
}
if (app.aud_strm) {
pjmedia_aud_stream_stop(app.aud_strm);
pjmedia_aud_stream_destroy(app.aud_strm);
}
if (app.mept) pjmedia_endpt_destroy(app.mept);
if (app.pool) pj_pool_release(app.pool);
pj_caching_pool_destroy(&app.cp);
pj_shutdown();
}
/*****************************************************************************
* 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();
}
/* Utility: display error message and exit application (usually
* because of fatal error.
*/
static void err_exit(const char *title, pj_status_t status)
{
if (status != PJ_SUCCESS) {
icedemo_perror(title, status);
}
PJ_LOG(3,(THIS_FILE, "Shutting down.."));
if (icedemo.icest)
pj_ice_strans_destroy(icedemo.icest);
pj_thread_sleep(500);
icedemo.thread_quit_flag = PJ_TRUE;
if (icedemo.thread) {
pj_thread_join(icedemo.thread);
pj_thread_destroy(icedemo.thread);
}
if (icedemo.ice_cfg.stun_cfg.ioqueue)
pj_ioqueue_destroy(icedemo.ice_cfg.stun_cfg.ioqueue);
if (icedemo.ice_cfg.stun_cfg.timer_heap)
pj_timer_heap_destroy(icedemo.ice_cfg.stun_cfg.timer_heap);
pj_caching_pool_destroy(&icedemo.cp);
pj_shutdown();
if (icedemo.log_fhnd) {
fclose(icedemo.log_fhnd);
icedemo.log_fhnd = NULL;
}
exit(status != PJ_SUCCESS);
}
SIPPresence::SIPPresence(SIPAccount *acc)
: publish_sess_()
, status_data_()
, enabled_(false)
, publish_supported_(false)
, subscribe_supported_(false)
, status_(false)
, note_(" ")
, acc_(acc)
, sub_server_list_() //IP2IP context
, sub_client_list_()
, mutex_()
, mutex_nesting_level_()
, mutex_owner_()
, cp_()
, pool_()
{
/* init pool */
pj_caching_pool_init(&cp_, &pj_pool_factory_default_policy, 0);
pool_ = pj_pool_create(&cp_.factory, "pres", 1000, 1000, NULL);
if (!pool_)
throw std::runtime_error("Could not allocate pool for presence");
/* Create mutex */
if (pj_mutex_create_recursive(pool_, "pres", &mutex_) != PJ_SUCCESS) {
pj_pool_release(pool_);
pj_caching_pool_destroy(&cp_);
throw std::runtime_error("Unable to create mutex");
}
/* init default status */
updateStatus(false, " ");
}
void term_pjsip()
{
pjsip_endpt_destroy(stack_data.endpt);
pj_pool_release(stack_data.pool);
pj_caching_pool_destroy(&stack_data.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;
}
/*
* main()
*/
int main(int argc, char *argv[])
{
pj_caching_pool cp;
pj_status_t status;
if (argc < 2 || argc > 3) {
puts("Usage: httpdemo URL [output-filename]");
return 1;
}
pj_log_set_level(5);
pj_init();
pj_caching_pool_init(&cp, NULL, 0);
mem = &cp.factory;
pjlib_util_init();
if (argc > 2)
f = fopen(argv[2], "wb");
else
f = stdout;
status = getURL(argv[1]);
if (status != PJ_SUCCESS) {
PJ_PERROR(1, (THIS_FILE, status, "Error"));
}
if (f != stdout)
fclose(f);
pj_caching_pool_destroy(&cp);
pj_shutdown();
return 0;
}
/*
* Destroy SIP
*/
static void destroy_app()
{
unsigned i;
app.thread_quit = 1;
for (i=0; i<app.thread_count; ++i) {
if (app.thread[i]) {
pj_thread_join(app.thread[i]);
pj_thread_destroy(app.thread[i]);
app.thread[i] = NULL;
}
}
if (app.sip_endpt) {
pjsip_endpt_destroy(app.sip_endpt);
app.sip_endpt = NULL;
}
if (app.pool) {
pj_pool_release(app.pool);
app.pool = NULL;
PJ_LOG(3,(THIS_FILE, "Peak memory size: %uMB",
app.cp.peak_used_size / 1000000));
pj_caching_pool_destroy(&app.cp);
}
/* Shutdown PJLIB */
pj_shutdown();
}
/* Destroy stack */
static void destroy_stack(void)
{
pjsip_endpt_destroy(global.endpt);
pj_pool_release(global.pool);
pj_caching_pool_destroy(&global.cp);
pj_shutdown();
}
static pj_status_t deinit()
{
pjmedia_codec_mgr *cm;
cm = pj_med_mgr_get_codec_mgr (mm);
codec->op->close(codec);
pjmedia_codec_mgr_dealloc_codec (cm, codec);
pj_med_mgr_destroy (mm);
pj_caching_pool_destroy(&caching_pool);
return 0;
}
/* Shutdown application */
static void app_fini()
{
if (strm)
snd_stop();
pjmedia_aud_subsys_shutdown();
pjmedia_delay_buf_destroy(delaybuf);
pj_pool_release(pool);
pj_caching_pool_destroy(&cp);
pj_shutdown();
}
JNIEXPORT jint JNICALL Java_org_sipdroid_pjlib_codec_close
(JNIEnv *env, jclass cls) {
LOGE("Closing PJLIB...");
pj_caching_pool_destroy(&caching_pool);
pjmedia_port_destroy(port);
pj_pool_release(pool);
pj_shutdown();
return (jint)0;
}
int main(int argc, char *argv[])
{
pj_caching_pool cp;
pj_time_val t0, t1;
pj_status_t status;
if (argc != 4) {
puts(desc);
return 1;
}
CHECK( pj_init() );
pj_caching_pool_init(&cp, NULL, 0);
CHECK( pjmedia_endpt_create(&cp.factory, NULL, 1, &mept) );
/* Register all codecs */
#if PJMEDIA_HAS_G711_CODEC
CHECK( pjmedia_codec_g711_init(mept) );
#endif
#if PJMEDIA_HAS_GSM_CODEC
CHECK( pjmedia_codec_gsm_init(mept) );
#endif
#if PJMEDIA_HAS_ILBC_CODEC
CHECK( pjmedia_codec_ilbc_init(mept, 30) );
#endif
#if PJMEDIA_HAS_SPEEX_CODEC
CHECK( pjmedia_codec_speex_init(mept, 0, 5, 5) );
#endif
#if PJMEDIA_HAS_G722_CODEC
CHECK( pjmedia_codec_g722_init(mept) );
#endif
pj_gettimeofday(&t0);
status = enc_dec_test(argv[1], argv[2], argv[3]);
pj_gettimeofday(&t1);
PJ_TIME_VAL_SUB(t1, t0);
pjmedia_endpt_destroy(mept);
pj_caching_pool_destroy(&cp);
pj_shutdown();
if (status == PJ_SUCCESS) {
puts("");
puts("Success");
printf("Duration: %ds.%03d\n", file_msec_duration/1000,
file_msec_duration%1000);
printf("Time: %lds.%03ld\n", t1.sec, t1.msec);
}
return 0;
}
void latency_checker::internal_clean()
{
if(m_aud_stream)
{
pjmedia_aud_stream_stop(m_aud_stream);
pjmedia_aud_stream_destroy(m_aud_stream);
m_aud_stream = NULL;
}
if(m_pool)
pjmedia_aud_subsys_shutdown();
pj_logging_shutdown();
pj_logging_destroy();
if(m_lock)
{
delete m_lock;
m_lock = NULL;
}
if(m_pool)
{
pj_pool_release(m_pool);
m_pool = NULL;
}
if(m_caching_pool)
pj_caching_pool_destroy(m_caching_pool);
m_pool_factory = NULL;
m_caching_pool = NULL;
pj_shutdown();
if(m_idle_freq1_det)
{
delete m_idle_freq1_det;
m_idle_freq1_det = NULL;
}
if(m_idle_freq2_det)
{
delete m_idle_freq2_det;
m_idle_freq2_det = NULL;
}
if(m_active_freq1_det)
{
delete m_active_freq1_det;
m_active_freq1_det = NULL;
}
if(m_active_freq2_det)
{
delete m_active_freq2_det;
m_active_freq2_det = NULL;
}
if(m_gain)
{
delete m_gain;
m_gain = NULL;
}
}
int main()
{
pj_turn_srv *srv;
pj_turn_listener *listener;
pj_status_t status;
status = pj_init();
if (status != PJ_SUCCESS)
return err("pj_init() error", status);
pjlib_util_init();
pjnath_init();
pj_caching_pool_init(&g_cp, NULL, 0);
pj_turn_auth_init(REALM);
status = pj_turn_srv_create(&g_cp.factory, &srv);
if (status != PJ_SUCCESS)
return err("Error creating server", status);
status = pj_turn_listener_create_udp(srv, pj_AF_INET(), NULL,
TURN_PORT, 1, 0, &listener);
if (status != PJ_SUCCESS)
return err("Error creating UDP listener", status);
#if PJ_HAS_TCP
status = pj_turn_listener_create_tcp(srv, pj_AF_INET(), NULL,
TURN_PORT, 1, 0, &listener);
if (status != PJ_SUCCESS)
return err("Error creating listener", status);
#endif
status = pj_turn_srv_add_listener(srv, listener);
if (status != PJ_SUCCESS)
return err("Error adding listener", status);
puts("Server is running");
pj_log_set_level(LOG_LEVEL);
console_main(srv);
pj_turn_srv_destroy(srv);
pj_caching_pool_destroy(&g_cp);
pj_shutdown();
return 0;
}
SIPPresence::~SIPPresence()
{
/* Flush the lists */
// FIXME: Can't destroy/unsubscribe buddies properly.
// Is the transport usable when the account is being destroyed?
//for (const auto & c : sub_client_list_)
// delete(c);
sub_client_list_.clear();
sub_server_list_.clear();
if (mutex_ and pj_mutex_destroy(mutex_) != PJ_SUCCESS)
ERROR("Error destroying mutex");
pj_pool_release(pool_);
pj_caching_pool_destroy(&cp_);
}
int main()
{
pj_caching_pool cp;
pj_status_t status;
// Must init PJLIB before anything else
status = pj_init();
if (status != PJ_SUCCESS) {
my_perror("Error initializing PJLIB", status);
return 1;
}
// Create the pool factory, in this case, a caching pool,
// using default pool policy.
pj_caching_pool_init(&cp, NULL, 1024*1024 );
pj_pool_t *pool = pj_pool_create(&cp.factory, "pool1", 4000, 4000, NULL);
pj_str_t test1_str = test1();
PRINT_PSTR_DETAILS(&test1_str);
pj_str_t test2_str = test2();
PRINT_PSTR_DETAILS(&test2_str);
pj_str_t test3_str = test3();
PRINT_PSTR_DETAILS(&test3_str);
PRINT_PSTR_DETAILS(test4());
PRINT_PSTR_DETAILS(test5());
PRINT_PSTR_DETAILS(test6(pool));
pj_str_t test7_str = test7();
PRINT_PSTR_DETAILS(&test7_str);
pj_str_t test8_str = test8(pool);
PRINT_PSTR_DETAILS(&test8_str);
pj_pool_release(pool);
// Done with demos, destroy caching pool before exiting app.
pj_caching_pool_destroy(&cp);
return 0;
}
static void destroy_stack(void)
{
enum { WAIT_CLEAR = 5000, WAIT_INTERVAL = 500 };
unsigned i;
PJ_LOG(3,(THIS_FILE, "Shutting down.."));
/* Wait until all clear */
hangup_all();
for (i=0; i<WAIT_CLEAR/WAIT_INTERVAL; ++i) {
unsigned j;
for (j=0; j<MAX_CALLS; ++j) {
call_t *call = &app.call[j];
if (call->inv && call->inv->state <= PJSIP_INV_STATE_CONFIRMED)
break;
}
if (j==MAX_CALLS)
return;
pj_thread_sleep(WAIT_INTERVAL);
}
app.quit = PJ_TRUE;
if (app.worker_thread) {
pj_thread_join(app.worker_thread);
app.worker_thread = NULL;
}
//if (app.med_endpt)
//pjmedia_endpt_destroy(app.med_endpt);
if (app.sip_endpt)
pjsip_endpt_destroy(app.sip_endpt);
if (app.pool)
pj_pool_release(app.pool);
dump_pool_usage(THIS_FILE, &app.cp);
pj_caching_pool_destroy(&app.cp);
}
static int client_shutdown()
{
unsigned i;
if (g.thread) {
g.quit = 1;
pj_thread_join(g.thread);
pj_thread_destroy(g.thread);
g.thread = NULL;
}
if (g.relay) {
pj_turn_sock_destroy(g.relay);
g.relay = NULL;
}
for (i=0; i<PJ_ARRAY_SIZE(g.peer); ++i) {
if (g.peer[i].stun_sock) {
pj_stun_sock_destroy(g.peer[i].stun_sock);
g.peer[i].stun_sock = NULL;
}
}
if (g.stun_config.timer_heap) {
pj_timer_heap_destroy(g.stun_config.timer_heap);
g.stun_config.timer_heap = NULL;
}
if (g.stun_config.ioqueue) {
pj_ioqueue_destroy(g.stun_config.ioqueue);
g.stun_config.ioqueue = NULL;
}
if (g.pool) {
pj_pool_release(g.pool);
g.pool = NULL;
}
pj_pool_factory_dump(&g.cp.factory, PJ_TRUE);
pj_caching_pool_destroy(&g.cp);
return PJ_SUCCESS;
}
int main() {
pj_caching_pool cp;
pj_pool_t *pool;
int i;
pj_thread_t *thread1;
pj_log_set_level(3);
CHECK(__FILE__, pj_init());
pj_srand(123765);
pj_caching_pool_init(&cp, NULL, 1024);
pool = pj_pool_create(&cp.factory, "objpool", 128, 128, NULL);
pj_thread_create(pool, "thread1", &do_test, pool, PJ_THREAD_DEFAULT_STACK_SIZE, 0, &thread1);
pj_thread_sleep(500);
do_test(pool);
pj_thread_join(thread1);
pj_pool_release(pool);
pj_caching_pool_destroy(&cp);
pj_shutdown();
return 0;
}
static int stun_destroy_test(void)
{
enum { LOOP = 500 };
struct stun_test_session test_sess;
pj_sockaddr bind_addr;
int addr_len;
pj_caching_pool cp;
pj_pool_t *pool;
unsigned i;
pj_status_t status;
int rc = 0;
PJ_LOG(3,(THIS_FILE, " STUN destroy concurrency test"));
pj_bzero(&test_sess, sizeof(test_sess));
pj_caching_pool_init(&cp, NULL, 0);
pool = pj_pool_create(&cp.factory, "testsess", 512, 512, NULL);
pj_stun_config_init(&test_sess.stun_cfg, &cp.factory, 0, NULL, NULL);
status = pj_timer_heap_create(pool, 1023, &test_sess.stun_cfg.timer_heap);
pj_assert(status == PJ_SUCCESS);
status = pj_lock_create_recursive_mutex(pool, NULL, &test_sess.lock);
pj_assert(status == PJ_SUCCESS);
pj_timer_heap_set_lock(test_sess.stun_cfg.timer_heap, test_sess.lock, PJ_TRUE);
pj_assert(status == PJ_SUCCESS);
status = pj_ioqueue_create(pool, 512, &test_sess.stun_cfg.ioqueue);
pj_assert(status == PJ_SUCCESS);
pj_sock_socket(pj_AF_INET(), pj_SOCK_DGRAM(), 0, &test_sess.server_sock);
pj_sockaddr_init(pj_AF_INET(), &bind_addr, NULL, 0);
status = pj_sock_bind(test_sess.server_sock, &bind_addr, pj_sockaddr_get_len(&bind_addr));
pj_assert(status == PJ_SUCCESS);
addr_len = sizeof(bind_addr);
status = pj_sock_getsockname(test_sess.server_sock, &bind_addr, &addr_len);
pj_assert(status == PJ_SUCCESS);
test_sess.server_port = pj_sockaddr_get_port(&bind_addr);
status = pj_event_create(pool, NULL, PJ_TRUE, PJ_FALSE, &test_sess.server_event);
pj_assert(status == PJ_SUCCESS);
for (i=0; i<SERVER_THREAD_CNT; ++i) {
status = pj_thread_create(pool, NULL,
&server_thread_proc, &test_sess,
0, 0, &test_sess.server_threads[i]);
pj_assert(status == PJ_SUCCESS);
}
for (i=0; i<WORKER_THREAD_CNT; ++i) {
status = pj_thread_create(pool, NULL,
&worker_thread_proc, &test_sess,
0, 0, &test_sess.worker_threads[i]);
pj_assert(status == PJ_SUCCESS);
}
/* Test 1: Main thread calls destroy while callback is processing response */
PJ_LOG(3,(THIS_FILE, " Destroy in main thread while callback is running"));
for (i=0; i<LOOP; ++i) {
int sleep = pj_rand() % 5;
PJ_LOG(3,(THIS_FILE, " Try %-3d of %d", i+1, LOOP));
/* Test 1: destroy at the same time when receiving response */
pj_bzero(&test_sess.param, sizeof(test_sess.param));
test_sess.param.client_sleep_after_start = 20;
test_sess.param.client_sleep_before_destroy = sleep;
test_sess.param.server_wait_for_event = PJ_TRUE;
stun_destroy_test_session(&test_sess);
PJ_LOG(3,(THIS_FILE,
" stun test a: sleep delay:%d: clients with response: %d",
sleep, test_sess.param.client_got_response));
/* Test 2: destroy at the same time with STUN retransmit timer */
test_sess.param.server_drop_request = PJ_TRUE;
test_sess.param.client_sleep_after_start = 0;
test_sess.param.client_sleep_before_destroy = PJ_STUN_RTO_VALUE;
test_sess.param.server_wait_for_event = PJ_FALSE;
stun_destroy_test_session(&test_sess);
PJ_LOG(3,(THIS_FILE, " stun test b: retransmit concurrency"));
/* Test 3: destroy at the same time with receiving response
* AND STUN retransmit timer */
test_sess.param.client_got_response = 0;
test_sess.param.server_drop_request = PJ_FALSE;
test_sess.param.client_sleep_after_start = PJ_STUN_RTO_VALUE;
test_sess.param.client_sleep_before_destroy = 0;
test_sess.param.server_wait_for_event = PJ_TRUE;
stun_destroy_test_session(&test_sess);
PJ_LOG(3,(THIS_FILE,
" stun test c: clients with response: %d",
test_sess.param.client_got_response));
pj_thread_sleep(10);
ice_one_conc_test(&test_sess.stun_cfg, PJ_FALSE);
pj_thread_sleep(10);
}
/* Avoid compiler warning */
goto on_return;
on_return:
test_sess.thread_quit_flag = PJ_TRUE;
for (i=0; i<SERVER_THREAD_CNT; ++i) {
pj_thread_join(test_sess.server_threads[i]);
}
for (i=0; i<WORKER_THREAD_CNT; ++i) {
pj_thread_join(test_sess.worker_threads[i]);
}
pj_event_destroy(test_sess.server_event);
pj_sock_close(test_sess.server_sock);
pj_ioqueue_destroy(test_sess.stun_cfg.ioqueue);
pj_timer_heap_destroy(test_sess.stun_cfg.timer_heap);
pj_pool_release(pool);
pj_caching_pool_destroy(&cp);
PJ_LOG(3,(THIS_FILE, " Done. rc=%d", rc));
return rc;
}
//
// Destroy caching pool.
//
~Pj_Caching_Pool()
{
pj_caching_pool_destroy(&cp_);
}
/*
* main()
*/
int main(int argc, char *argv[])
{
enum { NSAMPLES = 160, COUNT=100 };
pj_caching_pool cp;
pj_pool_t *pool;
pjmedia_port *wav;
pj_status_t status;
/* Verify cmd line arguments. */
if (argc != 2) {
puts("Error: missing argument(s)");
puts("Usage: latency REV.WAV");
return 1;
}
pj_log_set_level(0);
status = pj_init();
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
pj_caching_pool_init(&cp, &pj_pool_factory_default_policy, 0);
pool = pj_pool_create( &cp.factory, /* pool factory */
"wav", /* pool name. */
4000, /* init size */
4000, /* increment size */
NULL /* callback on error */
);
status = pj_register_strerror(PJMEDIA_ERRNO_START, PJ_ERRNO_SPACE_SIZE,
&pjmedia_strerror);
pj_assert(status == PJ_SUCCESS);
/* Wav */
status = pjmedia_wav_player_port_create( pool, /* memory pool */
argv[1], /* file to play */
0, /* use default ptime*/
0, /* flags */
0, /* default buffer */
&wav /* returned port */
);
if (status != PJ_SUCCESS) {
app_perror(THIS_FILE, argv[1], status);
return 1;
}
status = calculate_latency(pool, wav);
if (status != PJ_SUCCESS)
return 1;
status = pjmedia_port_destroy( wav );
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
pj_pool_release( pool );
pj_caching_pool_destroy( &cp );
pj_shutdown();
/* Done. */
return 0;
}
/*
* main()
*/
int main(int argc, char *argv[])
{
pj_caching_pool cp;
pjmedia_endpt *med_endpt;
pj_pool_t *pool;
pjmedia_port *wav_play;
pjmedia_port *wav_rec;
pjmedia_port *wav_out;
pj_status_t status;
pjmedia_echo_state *ec;
pjmedia_frame play_frame, rec_frame;
unsigned opt = 0;
unsigned latency_ms = 25;
unsigned tail_ms = TAIL_LENGTH;
pj_timestamp t0, t1;
int i, repeat=1, interactive=0, c;
pj_optind = 0;
while ((c=pj_getopt(argc, argv, "d:l:a:r:i")) !=-1) {
switch (c) {
case 'd':
latency_ms = atoi(pj_optarg);
if (latency_ms < 25) {
puts("Invalid delay");
puts(desc);
}
break;
case 'l':
tail_ms = atoi(pj_optarg);
break;
case 'a':
{
int alg = atoi(pj_optarg);
switch (alg) {
case 0:
opt = 0;
case 1:
opt = PJMEDIA_ECHO_SPEEX;
break;
case 3:
opt = PJMEDIA_ECHO_SIMPLE;
break;
default:
puts("Invalid algorithm");
puts(desc);
return 1;
}
}
break;
case 'r':
repeat = atoi(pj_optarg);
if (repeat < 1) {
puts("Invalid repeat count");
puts(desc);
return 1;
}
break;
case 'i':
interactive = 1;
break;
}
}
if (argc - pj_optind != 3) {
puts("Error: missing argument(s)");
puts(desc);
return 1;
}
/* Must init PJLIB first: */
status = pj_init();
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/* Must create a pool factory before we can allocate any memory. */
pj_caching_pool_init(&cp, &pj_pool_factory_default_policy, 0);
/*
* Initialize media endpoint.
* This will implicitly initialize PJMEDIA too.
*/
status = pjmedia_endpt_create(&cp.factory, NULL, 1, &med_endpt);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/* Create memory pool for our file player */
pool = pj_pool_create( &cp.factory, /* pool factory */
"wav", /* pool name. */
4000, /* init size */
4000, /* increment size */
NULL /* callback on error */
);
/* Open wav_play */
status = pjmedia_wav_player_port_create(pool, argv[pj_optind], PTIME,
PJMEDIA_FILE_NO_LOOP, 0,
&wav_play);
if (status != PJ_SUCCESS) {
app_perror(THIS_FILE, "Error opening playback WAV file", status);
return 1;
}
/* Open recorded wav */
status = pjmedia_wav_player_port_create(pool, argv[pj_optind+1], PTIME,
PJMEDIA_FILE_NO_LOOP, 0,
&wav_rec);
if (status != PJ_SUCCESS) {
app_perror(THIS_FILE, "Error opening recorded WAV file", status);
return 1;
}
/* play and rec WAVs must have the same clock rate */
if (wav_play->info.clock_rate != wav_rec->info.clock_rate) {
puts("Error: clock rate mismatch in the WAV files");
return 1;
}
/* .. and channel count */
if (wav_play->info.channel_count != wav_rec->info.channel_count) {
puts("Error: clock rate mismatch in the WAV files");
return 1;
}
/* Create output wav */
status = pjmedia_wav_writer_port_create(pool, argv[pj_optind+2],
wav_play->info.clock_rate,
wav_play->info.channel_count,
wav_play->info.samples_per_frame,
wav_play->info.bits_per_sample,
0, 0, &wav_out);
if (status != PJ_SUCCESS) {
app_perror(THIS_FILE, "Error opening output WAV file", status);
return 1;
}
/* Create echo canceller */
status = pjmedia_echo_create2(pool, wav_play->info.clock_rate,
wav_play->info.channel_count,
wav_play->info.samples_per_frame,
tail_ms, latency_ms,
opt, &ec);
if (status != PJ_SUCCESS) {
app_perror(THIS_FILE, "Error creating EC", status);
return 1;
}
/* Processing loop */
play_frame.buf = pj_pool_alloc(pool, wav_play->info.samples_per_frame<<1);
rec_frame.buf = pj_pool_alloc(pool, wav_play->info.samples_per_frame<<1);
pj_get_timestamp(&t0);
for (i=0; i < repeat; ++i) {
for (;;) {
play_frame.size = wav_play->info.samples_per_frame << 1;
status = pjmedia_port_get_frame(wav_play, &play_frame);
if (status != PJ_SUCCESS)
break;
status = pjmedia_echo_playback(ec, (short*)play_frame.buf);
rec_frame.size = wav_play->info.samples_per_frame << 1;
status = pjmedia_port_get_frame(wav_rec, &rec_frame);
if (status != PJ_SUCCESS)
break;
status = pjmedia_echo_capture(ec, (short*)rec_frame.buf, 0);
//status = pjmedia_echo_cancel(ec, (short*)rec_frame.buf,
// (short*)play_frame.buf, 0, NULL);
pjmedia_port_put_frame(wav_out, &rec_frame);
}
pjmedia_wav_player_port_set_pos(wav_play, 0);
pjmedia_wav_player_port_set_pos(wav_rec, 0);
}
pj_get_timestamp(&t1);
i = pjmedia_wav_writer_port_get_pos(wav_out) / sizeof(pj_int16_t) * 1000 /
(wav_out->info.clock_rate * wav_out->info.channel_count);
PJ_LOG(3,(THIS_FILE, "Processed %3d.%03ds audio",
i / 1000, i % 1000));
PJ_LOG(3,(THIS_FILE, "Completed in %u msec\n", pj_elapsed_msec(&t0, &t1)));
/* Destroy file port(s) */
status = pjmedia_port_destroy( wav_play );
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
status = pjmedia_port_destroy( wav_rec );
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
status = pjmedia_port_destroy( wav_out );
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/* Destroy ec */
pjmedia_echo_destroy(ec);
/* Release application pool */
pj_pool_release( pool );
/* Destroy media endpoint. */
pjmedia_endpt_destroy( med_endpt );
/* Destroy pool factory */
pj_caching_pool_destroy( &cp );
/* Shutdown PJLIB */
pj_shutdown();
if (interactive) {
char s[10], *dummy;
puts("ENTER to quit");
dummy = fgets(s, sizeof(s), stdin);
}
/* Done. */
return 0;
}
static int main_func(int argc, char *argv[])
{
pj_caching_pool cp;
pj_pool_t *pool;
int rc = 0;
pj_status_t status = PJ_SUCCESS;
if (argc != 2) {
puts("Error: filename required");
puts(desc);
return 1;
}
/* Must init PJLIB first: */
status = pj_init();
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/* Must create a pool factory before we can allocate any memory. */
pj_caching_pool_init(&cp, &pj_pool_factory_default_policy, 0);
/* Create memory pool for our file player */
pool = pj_pool_create( &cp.factory, /* pool factory */
"AVI", /* pool name. */
4000, /* init size */
4000, /* increment size */
NULL /* callback on error */
);
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);
status = pjmedia_vid_dev_subsys_init(&cp.factory);
if (status != PJ_SUCCESS)
goto on_return;
status = pjmedia_aud_subsys_init(&cp.factory);
if (status != PJ_SUCCESS) {
goto on_return;
}
#if PJMEDIA_HAS_FFMPEG_VID_CODEC
status = pjmedia_codec_ffmpeg_vid_init(NULL, &cp.factory);
if (status != PJ_SUCCESS)
goto on_return;
#endif
rc = aviplay(pool, argv[1]);
/*
* File should be playing and looping now
*/
/* Without this sleep, Windows/DirectSound will repeteadly
* play the last frame during destroy.
*/
pj_thread_sleep(100);
on_return:
#if PJMEDIA_HAS_FFMPEG_VID_CODEC
pjmedia_codec_ffmpeg_vid_deinit();
#endif
pjmedia_aud_subsys_shutdown();
pjmedia_vid_dev_subsys_shutdown();
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());
/* Release application pool */
pj_pool_release( pool );
/* Destroy pool factory */
pj_caching_pool_destroy( &cp );
/* Shutdown PJLIB */
pj_shutdown();
/* Done. */
return 0;
}
/*
* main()
*/
int main(int argc, char *argv[])
{
pj_caching_pool cp;
pjmedia_endpt *med_endpt;
pj_pool_t *pool;
pj_status_t status;
/* Codec */
char *codec_id = (char*)"H264";
const pjmedia_vid_codec_info *codec_info;
pjmedia_vid_codec_param codec_param;
pjmedia_vid_codec *codec = NULL;
//const char *save_filename =
// "/home/bennylp/Desktop/opt/src/openh264-svn/testbin/test.264";
const char *save_filename = NULL;
/* File */
enum
{
WIDTH = 320,
HEIGHT = 192,
FPS = 12,
YUV_SIZE = WIDTH * HEIGHT * 3 >> 1,
YUV_BUF_SIZE = YUV_SIZE + WIDTH,
MAX_FRAMES = 32,
MTU = 1500
};
FILE *fyuv = NULL;
FILE *f264 = NULL;
typedef pj_uint8_t enc_buf_type[MTU];
pj_uint8_t yuv_frame[YUV_BUF_SIZE];
enc_buf_type enc_buf[MAX_FRAMES];
unsigned read_cnt = 0,
pkt_cnt = 0,
dec_cnt = 0,
enc_cnt;
if (0) {
diff_file();
return 1;
}
/* init PJLIB : */
status = pj_init();
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/* Must create a pool factory before we can allocate any memory. */
pj_caching_pool_init(&cp, &pj_pool_factory_default_policy, 0);
/* Initialize media endpoint. */
status = pjmedia_endpt_create(&cp.factory, NULL, 1, &med_endpt);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/* Create memory pool for application purpose */
pool = pj_pool_create( &cp.factory, /* pool factory */
"app", /* pool name. */
4000, /* init size */
4000, /* increment size */
NULL /* callback on error */
);
/* Init video format manager */
pjmedia_video_format_mgr_create(pool, 64, 0, NULL);
/* Init video converter manager */
pjmedia_converter_mgr_create(pool, NULL);
/* Init event manager */
pjmedia_event_mgr_create(pool, 0, NULL);
/* Init video codec manager */
pjmedia_vid_codec_mgr_create(pool, NULL);
/* Register all supported codecs */
status = init_codecs(&cp.factory);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/* Open YUV file */
fyuv = fopen("pjsip-apps/bin/CiscoVT2people_320x192_12fps.yuv", "rb");
if (!fyuv) {
puts("Unable to open ../CiscoVT2people_320x192_12fps.yuv");
status = -1;
goto on_exit;
}
/* Write 264 file if wanted */
if (save_filename) {
f264 = fopen(save_filename, "wb");
}
/* Find which codec to use. */
if (codec_id) {
unsigned count = 1;
pj_str_t str_codec_id = pj_str(codec_id);
status = pjmedia_vid_codec_mgr_find_codecs_by_id(NULL,
&str_codec_id, &count,
&codec_info, NULL);
if (status != PJ_SUCCESS) {
printf("Error: unable to find codec %s\n", codec_id);
return 1;
}
} else {
static pjmedia_vid_codec_info info[1];
unsigned count = PJ_ARRAY_SIZE(info);
/* Default to first codec */
pjmedia_vid_codec_mgr_enum_codecs(NULL, &count, info, NULL);
codec_info = &info[0];
}
/* Get codec default param for info */
status = pjmedia_vid_codec_mgr_get_default_param(NULL, codec_info,
&codec_param);
pj_assert(status == PJ_SUCCESS);
/* Alloc encoder */
status = pjmedia_vid_codec_mgr_alloc_codec(NULL, codec_info, &codec);
if (status != PJ_SUCCESS) {
PJ_PERROR(3,(THIS_FILE, status, "Error allocating codec"));
goto on_exit;
}
codec_param.dir = PJMEDIA_DIR_ENCODING_DECODING;
codec_param.packing = PJMEDIA_VID_PACKING_PACKETS;
codec_param.enc_mtu = MTU;
codec_param.enc_fmt.det.vid.size.w = WIDTH;
codec_param.enc_fmt.det.vid.size.h = HEIGHT;
codec_param.enc_fmt.det.vid.fps.num = FPS;
codec_param.enc_fmt.det.vid.avg_bps = WIDTH * HEIGHT * FPS;
status = pjmedia_vid_codec_init(codec, pool);
if (status != PJ_SUCCESS) {
PJ_PERROR(3,(THIS_FILE, status, "Error initializing codec"));
goto on_exit;
}
status = pjmedia_vid_codec_open(codec, &codec_param);
if (status != PJ_SUCCESS) {
PJ_PERROR(3,(THIS_FILE, status, "Error opening codec"));
goto on_exit;
}
while (fread(yuv_frame, 1, YUV_SIZE, fyuv) == YUV_SIZE) {
pjmedia_frame frm_yuv, frm_enc[MAX_FRAMES];
pj_bool_t has_more = PJ_FALSE;
const pj_uint8_t start_nal[] = { 0, 0, 1 };
unsigned i;
++ read_cnt;
pj_bzero(&frm_enc, sizeof(frm_enc));
pj_bzero(&frm_yuv, sizeof(frm_yuv));
frm_yuv.buf = yuv_frame;
frm_yuv.size = YUV_SIZE;
enc_cnt = 0;
frm_enc[enc_cnt].buf = enc_buf[enc_cnt];
frm_enc[enc_cnt].size = MTU;
status = pjmedia_vid_codec_encode_begin(codec, NULL, &frm_yuv,
MTU, &frm_enc[enc_cnt],
&has_more);
if (status != PJ_SUCCESS) {
PJ_PERROR(3,(THIS_FILE, status, "Codec encode error"));
goto on_exit;
}
if (frm_enc[enc_cnt].size) {
if (f264) {
fwrite(start_nal, 1, sizeof(start_nal), f264);
fwrite(frm_enc[enc_cnt].buf, 1, frm_enc[enc_cnt].size, f264);
}
++pkt_cnt;
++enc_cnt;
}
while (has_more) {
if (enc_cnt >= MAX_FRAMES) {
status = -1;
puts("Error: too many encoded frames");
goto on_exit;
}
has_more = PJ_FALSE;
frm_enc[enc_cnt].buf = enc_buf[enc_cnt];
frm_enc[enc_cnt].size = MTU;
status = pjmedia_vid_codec_encode_more(codec, MTU,
&frm_enc[enc_cnt],
&has_more);
if (status != PJ_SUCCESS) {
PJ_PERROR(3,(THIS_FILE, status, "Codec encode error"));
goto on_exit;
}
if (frm_enc[enc_cnt].size) {
if (f264) {
fwrite(start_nal, 1, sizeof(start_nal), f264);
fwrite(frm_enc[enc_cnt].buf, 1, frm_enc[enc_cnt].size,
f264);
}
++pkt_cnt;
++enc_cnt;
}
}
if (enc_cnt) {
frm_yuv.buf = yuv_frame;
frm_yuv.size = YUV_BUF_SIZE;
status = pjmedia_vid_codec_decode(codec, enc_cnt,
frm_enc,
YUV_BUF_SIZE,
&frm_yuv);
if (status != PJ_SUCCESS) {
PJ_PERROR(3,(THIS_FILE, status, "Codec decode error"));
goto on_exit;
}
if (frm_yuv.size != 0) {
++dec_cnt;
}
}
}
printf("Done.\n"
" Read YUV frames: %d\n"
" Encoded packets: %d\n"
" Decoded YUV frames: %d\n",
read_cnt, pkt_cnt, dec_cnt);
/* Start deinitialization: */
on_exit:
if (codec) {
pjmedia_vid_codec_close(codec);
pjmedia_vid_codec_mgr_dealloc_codec(NULL, codec);
}
if (f264)
fclose(f264);
if (fyuv)
fclose(fyuv);
/* Deinit codecs */
deinit_codecs();
/* Destroy event manager */
pjmedia_event_mgr_destroy(NULL);
/* Release application pool */
pj_pool_release( pool );
/* Destroy media endpoint. */
pjmedia_endpt_destroy( med_endpt );
/* Destroy pool factory */
pj_caching_pool_destroy( &cp );
/* Shutdown PJLIB */
pj_shutdown();
return (status == PJ_SUCCESS) ? 0 : 1;
}
#else
int main(int argc, char *argv[])
{
PJ_UNUSED_ARG(argc);
PJ_UNUSED_ARG(argv);
puts("Error: this sample requires video capability "
"(PJMEDIA_HAS_VIDEO == 1)");
return -1;
}
int main()
{
pj_caching_pool cp;
pj_cli_cfg cli_cfg;
pj_cli_telnet_cfg tcfg;
pj_str_t xml;
pj_status_t status;
int i;
pj_init();
pj_caching_pool_init(&cp, NULL, 0);
pjlib_util_init();
/*
* Create CLI app.
*/
pj_cli_cfg_default(&cli_cfg);
cli_cfg.pf = &cp.factory;
cli_cfg.name = pj_str("mycliapp");
cli_cfg.title = pj_str("My CLI Application");
status = pj_cli_create(&cli_cfg, &cli);
if (status != PJ_SUCCESS)
goto on_return;
/*
* Register some commands.
*/
for (i = 0; i < sizeof(cmd_xmls)/sizeof(cmd_xmls[0]); i++) {
xml = pj_str(cmd_xmls[i].xml);
status = pj_cli_add_cmd_from_xml(cli, NULL, &xml,
cmd_xmls[i].handler, NULL, get_codec_list);
if (status != PJ_SUCCESS)
goto on_return;
}
/*
* Start telnet daemon
*/
pj_cli_telnet_cfg_default(&tcfg);
// tcfg.passwd = pj_str("pjsip");
#if USE_RANDOM_PORT
tcfg.port = 0;
#else
tcfg.port = 2233;
#endif
tcfg.prompt_str = pj_str("CoolWater% ");
status = pj_cli_telnet_create(cli, &tcfg, NULL);
if (status != PJ_SUCCESS)
goto on_return;
/*
* Run the system specific main loop.
*/
status = app_main(cli);
on_return:
/*
* Destroy
*/
pj_cli_destroy(cli);
cli = NULL;
pj_caching_pool_destroy(&cp);
pj_shutdown();
return (status != PJ_SUCCESS ? 1 : 0);
}
/*
* main()
*/
int main(int argc, char *argv[])
{
pj_caching_pool cp;
pjmedia_endpt *med_endpt;
pj_pool_t *pool;
pjmedia_port *sine_port;
pjmedia_snd_port *snd_port;
char tmp[10];
int channel_count = 1;
pj_status_t status;
if (argc == 2) {
channel_count = atoi(argv[1]);
if (channel_count < 1 || channel_count > 2) {
puts("Error: invalid arguments");
usage();
return 1;
}
}
/* Must init PJLIB first: */
status = pj_init();
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/* Must create a pool factory before we can allocate any memory. */
pj_caching_pool_init(&cp, &pj_pool_factory_default_policy, 0);
/*
* Initialize media endpoint.
* This will implicitly initialize PJMEDIA too.
*/
status = pjmedia_endpt_create(&cp.factory, NULL, 1, &med_endpt);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/* Create memory pool for our sine generator */
pool = pj_pool_create( &cp.factory, /* pool factory */
"wav", /* pool name. */
4000, /* init size */
4000, /* increment size */
NULL /* callback on error */
);
/* Create a media port to generate sine wave samples. */
status = create_sine_port( pool, /* memory pool */
11025, /* sampling rate */
channel_count,/* # of channels */
&sine_port /* returned port */
);
if (status != PJ_SUCCESS) {
app_perror(THIS_FILE, "Unable to create sine port", status);
return 1;
}
/* Create sound player port. */
status = pjmedia_snd_port_create_player(
pool, /* pool */
-1, /* use default dev. */
sine_port->info.clock_rate, /* clock rate. */
sine_port->info.channel_count, /* # of channels. */
sine_port->info.samples_per_frame, /* samples per frame. */
sine_port->info.bits_per_sample, /* bits per sample. */
0, /* options */
&snd_port /* returned port */
);
if (status != PJ_SUCCESS) {
app_perror(THIS_FILE, "Unable to open sound device", status);
return 1;
}
/* Connect sine generator port to the sound player
* Stream playing will commence immediately.
*/
status = pjmedia_snd_port_connect( snd_port, sine_port);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/*
* Audio should be playing in a loop now, using sound device's thread.
*/
/* Sleep to allow log messages to flush */
pj_thread_sleep(100);
puts("Playing sine wave..");
puts("");
puts("Press <ENTER> to stop playing and quit");
fgets(tmp, sizeof(tmp), stdin);
/* Start deinitialization: */
/* Disconnect sound port from file port */
status = pjmedia_snd_port_disconnect(snd_port);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/* Without this sleep, Windows/DirectSound will repeteadly
* play the last frame during destroy.
*/
pj_thread_sleep(100);
/* Destroy sound device */
status = pjmedia_snd_port_destroy( snd_port );
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/* Destroy sine generator */
status = pjmedia_port_destroy( sine_port );
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/* Release application pool */
pj_pool_release( pool );
/* Destroy media endpoint. */
pjmedia_endpt_destroy( med_endpt );
/* Destroy pool factory */
pj_caching_pool_destroy( &cp );
/* Shutdown PJLIB */
pj_shutdown();
/* Done. */
return 0;
}
/*
* main()
*/
int main(int argc, char *argv[])
{
pj_caching_pool cp;
pjmedia_endpt *med_endpt;
pj_pool_t *pool;
pjmedia_port *file_port;
pjmedia_snd_port *snd_port;
char tmp[10];
pj_status_t status;
if (argc != 2) {
puts("Error: filename required");
puts(desc);
return 1;
}
/* Must init PJLIB first: */
status = pj_init();
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/* Must create a pool factory before we can allocate any memory. */
pj_caching_pool_init(&cp, &pj_pool_factory_default_policy, 0);
/*
* Initialize media endpoint.
* This will implicitly initialize PJMEDIA too.
*/
status = pjmedia_endpt_create(&cp.factory, NULL, 1, &med_endpt);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/* Create memory pool for our file player */
pool = pj_pool_create( &cp.factory, /* pool factory */
"wav", /* pool name. */
4000, /* init size */
4000, /* increment size */
NULL /* callback on error */
);
/* Create file media port from the WAV file */
status = pjmedia_wav_player_port_create( pool, /* memory pool */
argv[1], /* file to play */
20, /* ptime. */
0, /* flags */
0, /* default buffer */
&file_port/* returned port */
);
if (status != PJ_SUCCESS) {
app_perror(THIS_FILE, "Unable to use WAV file", status);
return 1;
}
/* Create sound player port. */
status = pjmedia_snd_port_create_player(
pool, /* pool */
-1, /* use default dev. */
file_port->info.clock_rate, /* clock rate. */
file_port->info.channel_count, /* # of channels. */
file_port->info.samples_per_frame, /* samples per frame. */
file_port->info.bits_per_sample, /* bits per sample. */
0, /* options */
&snd_port /* returned port */
);
if (status != PJ_SUCCESS) {
app_perror(THIS_FILE, "Unable to open sound device", status);
return 1;
}
/* Connect file port to the sound player.
* Stream playing will commence immediately.
*/
status = pjmedia_snd_port_connect( snd_port, file_port);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/*
* File should be playing and looping now, using sound device's thread.
*/
/* Sleep to allow log messages to flush */
pj_thread_sleep(100);
printf("Playing %s..\n", argv[1]);
puts("");
puts("Press <ENTER> to stop playing and quit");
if (fgets(tmp, sizeof(tmp), stdin) == NULL) {
puts("EOF while reading stdin, will quit now..");
}
/* Start deinitialization: */
/* Disconnect sound port from file port */
status = pjmedia_snd_port_disconnect(snd_port);
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/* Without this sleep, Windows/DirectSound will repeteadly
* play the last frame during destroy.
*/
pj_thread_sleep(100);
/* Destroy sound device */
status = pjmedia_snd_port_destroy( snd_port );
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/* Destroy file port */
status = pjmedia_port_destroy( file_port );
PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
/* Release application pool */
pj_pool_release( pool );
/* Destroy media endpoint. */
pjmedia_endpt_destroy( med_endpt );
/* Destroy pool factory */
pj_caching_pool_destroy( &cp );
/* Shutdown PJLIB */
pj_shutdown();
/* Done. */
return 0;
}
int main(int argc, char *argv[])
{
pj_caching_pool cp;
pj_pool_t *pool;
pjmedia_conf *conf;
pjmedia_port *player_port1, *player_port2, *writer_port;
pjmedia_master_port *master_port;
unsigned slot1, slot2;
pj_status_t status;
char tmp[10];
slot1 = 1;
slot2 = 2;
pj_ssize_t len;
if (argc < 5) {
printf("Usage: %s <clock_rate> <player file 1> <player file 2> <mix file>\n", argv[0]);
exit(-1);
}
unsigned clock_rate = atoi(argv[1]);
// Initialialize
pj_init() ;
pj_caching_pool_init(&cp, NULL, 0);
pool = pj_pool_create(&cp.factory, "pool", 1000, 1000, NULL);
// Create player port
pjmedia_wav_player_port_create(pool, argv[2], 20, PJMEDIA_FILE_NO_LOOP, 0, &player_port1);
pjmedia_wav_player_port_create(pool, argv[3], 20, PJMEDIA_FILE_NO_LOOP, 0, &player_port2);
// Create the bridge
pjmedia_conf_create(pool, MAX_WAV+4, clock_rate, 1, clock_rate * PTIME / 1000, 16, PJMEDIA_CONF_NO_DEVICE, &conf);
pjmedia_conf_add_port(conf, pool, player_port2, NULL, &slot2);
pjmedia_conf_add_port(conf, pool, player_port1, NULL, &slot1);
pjmedia_conf_connect_port(conf, slot1, 0, 0);
pjmedia_conf_connect_port(conf, slot2, 0, 0);
pjmedia_port *port = pjmedia_conf_get_master_port(conf);
//Both ports MUST have equal clock rate, samples per frame and channel count
pjmedia_wav_writer_port_create(pool, argv[4],
PJMEDIA_PIA_SRATE(&port->info),
PJMEDIA_PIA_CCNT(&port->info),
PJMEDIA_PIA_SPF(&port->info),
PJMEDIA_PIA_BITS(&port->info),
0, 0, &writer_port);
pjmedia_master_port_create(pool, port, writer_port, 0, &master_port);
if (status != PJ_SUCCESS) {
return 1;
}
status = pjmedia_master_port_start(master_port);
pj_thread_sleep(5000);
/* Shutdown everything */
pjmedia_master_port_destroy(master_port, PJ_TRUE);
pj_pool_release(pool);
pj_caching_pool_destroy(&cp);
pj_shutdown();
return 0;
}
