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; }