static pj_status_t avi_event_cb(pjmedia_event *event,
void *user_data)
{
avi_port_t *ap = (avi_port_t *)user_data;
switch (event->type) {
case PJMEDIA_EVENT_WND_CLOSED:
ap->is_quitting = PJ_TRUE;
break;
case PJMEDIA_EVENT_MOUSE_BTN_DOWN:
if (ap->is_running) {
pjmedia_vid_port_stop(ap->vid_port);
if (ap->snd_port)
pjmedia_aud_stream_stop(
pjmedia_snd_port_get_snd_stream(ap->snd_port));
} else {
pjmedia_vid_port_start(ap->vid_port);
if (ap->snd_port)
pjmedia_aud_stream_start(
pjmedia_snd_port_get_snd_stream(ap->snd_port));
}
ap->is_running = !ap->is_running;
break;
default:
return PJ_SUCCESS;
}
/* We handled the event on our own, so return non-PJ_SUCCESS here */
return -1;
}
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();
}
/* Stop sound */
static pj_status_t snd_stop()
{
pj_time_val now;
pj_status_t status;
if (strm == NULL) {
app_perror("snd not open", PJ_EINVALIDOP);
return PJ_EINVALIDOP;
}
status = pjmedia_aud_stream_stop(strm);
if (status != PJ_SUCCESS) {
app_perror("snd failed to stop", status);
}
status = pjmedia_aud_stream_destroy(strm);
strm = NULL;
pj_gettimeofday(&now);
PJ_TIME_VAL_SUB(now, t_start);
PJ_LOG(3,(THIS_FILE, "Duration: %d.%03d", now.sec, now.msec));
PJ_LOG(3,(THIS_FILE, "Captured: %d", rec_cnt));
PJ_LOG(3,(THIS_FILE, "Played: %d", play_cnt));
return status;
}
static void record(unsigned rec_index, const char *filename)
{
pj_pool_t *pool = NULL;
pjmedia_port *wav = NULL;
pjmedia_aud_param param;
pjmedia_aud_stream *strm = NULL;
char line[10], *dummy;
pj_status_t status;
if (filename == NULL)
filename = WAV_FILE;
pool = pj_pool_create(pjmedia_aud_subsys_get_pool_factory(), "wav",
1000, 1000, NULL);
status = pjmedia_wav_writer_port_create(pool, filename, 16000,
1, 320, 16, 0, 0, &wav);
if (status != PJ_SUCCESS) {
app_perror("Error creating WAV file", status);
goto on_return;
}
status = pjmedia_aud_dev_default_param(rec_index, ¶m);
if (status != PJ_SUCCESS) {
app_perror("pjmedia_aud_dev_default_param()", status);
goto on_return;
}
param.dir = PJMEDIA_DIR_CAPTURE;
param.clock_rate = PJMEDIA_PIA_SRATE(&wav->info);
param.samples_per_frame = PJMEDIA_PIA_SPF(&wav->info);
param.channel_count = PJMEDIA_PIA_CCNT(&wav->info);
param.bits_per_sample = PJMEDIA_PIA_BITS(&wav->info);
status = pjmedia_aud_stream_create(¶m, &wav_rec_cb, NULL, wav,
&strm);
if (status != PJ_SUCCESS) {
app_perror("Error opening the sound device", status);
goto on_return;
}
status = pjmedia_aud_stream_start(strm);
if (status != PJ_SUCCESS) {
app_perror("Error starting the sound device", status);
goto on_return;
}
PJ_LOG(3,(THIS_FILE, "Recording started, press ENTER to stop"));
dummy = fgets(line, sizeof(line), stdin);
on_return:
if (strm) {
pjmedia_aud_stream_stop(strm);
pjmedia_aud_stream_destroy(strm);
}
if (wav)
pjmedia_port_destroy(wav);
if (pool)
pj_pool_release(pool);
}
static void play_file(unsigned play_index, const char *filename)
{
pj_pool_t *pool = NULL;
pjmedia_port *wav = NULL;
pjmedia_aud_param param;
pjmedia_aud_stream *strm = NULL;
char line[10], *dummy;
pj_status_t status;
if (filename == NULL)
filename = WAV_FILE;
pool = pj_pool_create(pjmedia_aud_subsys_get_pool_factory(), "wav",
1000, 1000, NULL);
status = pjmedia_wav_player_port_create(pool, filename, 20, 0, 0, &wav);
if (status != PJ_SUCCESS) {
app_perror("Error opening WAV file", status);
goto on_return;
}
status = pjmedia_aud_dev_default_param(play_index, ¶m);
if (status != PJ_SUCCESS) {
app_perror("pjmedia_aud_dev_default_param()", status);
goto on_return;
}
param.dir = PJMEDIA_DIR_PLAYBACK;
param.clock_rate = wav->info.clock_rate;
param.samples_per_frame = wav->info.samples_per_frame;
param.channel_count = wav->info.channel_count;
param.bits_per_sample = wav->info.bits_per_sample;
status = pjmedia_aud_stream_create(¶m, NULL, &wav_play_cb, wav,
&strm);
if (status != PJ_SUCCESS) {
app_perror("Error opening the sound device", status);
goto on_return;
}
status = pjmedia_aud_stream_start(strm);
if (status != PJ_SUCCESS) {
app_perror("Error starting the sound device", status);
goto on_return;
}
PJ_LOG(3,(THIS_FILE, "Playback started, press ENTER to stop"));
dummy = fgets(line, sizeof(line), stdin);
on_return:
if (strm) {
pjmedia_aud_stream_stop(strm);
pjmedia_aud_stream_destroy(strm);
}
if (wav)
pjmedia_port_destroy(wav);
if (pool)
pj_pool_release(pool);
}
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;
}
}
/*
* Stop the sound device.
* This may be called even when there's no sound device in the port.
*/
static pj_status_t stop_sound_device( pjmedia_snd_port *snd_port )
{
/* Check if we have sound stream device. */
if (snd_port->aud_stream) {
pjmedia_aud_stream_stop(snd_port->aud_stream);
pjmedia_aud_stream_destroy(snd_port->aud_stream);
snd_port->aud_stream = NULL;
}
/* Destroy AEC */
if (snd_port->ec_state) {
pjmedia_echo_destroy(snd_port->ec_state);
snd_port->ec_state = NULL;
}
return PJ_SUCCESS;
}
PJ_DEF(pj_status_t) pjmedia_snd_stream_stop(pjmedia_snd_stream *stream)
{
return pjmedia_aud_stream_stop(stream->aud_strm);
}
