void text_stream_stop(TextStream *stream) {
if (stream->ms.sessions.ticker) {
if (stream->ms.state == MSStreamPreparing) {
text_stream_unprepare_text(stream);
} else if (stream->ms.state == MSStreamStarted) {
MSConnectionHelper h;
stream->ms.state = MSStreamStopped;
ms_ticker_detach(stream->ms.sessions.ticker, stream->rttsource);
ms_ticker_detach(stream->ms.sessions.ticker, stream->ms.rtprecv);
if (stream->ms.ice_check_list != NULL) {
ice_check_list_print_route(stream->ms.ice_check_list, "Text session's route");
stream->ms.ice_check_list = NULL;
}
rtp_stats_display(rtp_session_get_stats(stream->ms.sessions.rtp_session),
" TEXT SESSION'S RTP STATISTICS ");
ms_connection_helper_start(&h);
ms_connection_helper_unlink(&h, stream->rttsource, -1, 0);
ms_connection_helper_unlink(&h, stream->ms.rtpsend, 0, -1);
ms_connection_helper_start(&h);
ms_connection_helper_unlink(&h, stream->ms.rtprecv, -1, 0);
ms_connection_helper_unlink(&h, stream->rttsink, 0, -1);
}
}
text_stream_free(stream);
ms_filter_log_statistics();
}
static void dtmfgen_tonedet(void) {
MSConnectionHelper h;
unsigned int filter_mask = FILTER_MASK_VOIDSOURCE | FILTER_MASK_DTMFGEN | FILTER_MASK_TONEDET | FILTER_MASK_VOIDSINK;
bool_t send_silence = TRUE;
ms_filter_reset_statistics();
ms_tester_create_ticker();
ms_tester_create_filters(filter_mask);
ms_filter_add_notify_callback(ms_tester_tonedet, (MSFilterNotifyFunc)tone_detected_cb, NULL,TRUE);
ms_filter_call_method(ms_tester_voidsource, MS_VOID_SOURCE_SEND_SILENCE, &send_silence);
ms_connection_helper_start(&h);
ms_connection_helper_link(&h, ms_tester_voidsource, -1, 0);
ms_connection_helper_link(&h, ms_tester_dtmfgen, 0, 0);
ms_connection_helper_link(&h, ms_tester_tonedet, 0, 0);
ms_connection_helper_link(&h, ms_tester_voidsink, 0, -1);
ms_ticker_attach(ms_tester_ticker, ms_tester_voidsource);
ms_tester_tone_generation_and_detection_loop();
/*try unrecognized DTMF*/
BC_ASSERT_NOT_EQUAL(ms_filter_call_method(ms_tester_dtmfgen, MS_DTMF_GEN_PLAY, "F"),0,int,"%d");
ms_ticker_detach(ms_tester_ticker, ms_tester_voidsource);
ms_connection_helper_start(&h);
ms_connection_helper_unlink(&h, ms_tester_voidsource, -1, 0);
ms_connection_helper_unlink(&h, ms_tester_dtmfgen, 0, 0);
ms_connection_helper_unlink(&h, ms_tester_tonedet, 0, 0);
ms_connection_helper_unlink(&h, ms_tester_voidsink, 0, -1);
ms_filter_log_statistics();
ms_tester_destroy_filters(filter_mask);
ms_tester_destroy_ticker();
}
static void dtmfgen_tonedet(void) {
MSConnectionHelper h;
unsigned int filter_mask = FILTER_MASK_VOIDSOURCE | FILTER_MASK_DTMFGEN | FILTER_MASK_TONEDET | FILTER_MASK_VOIDSINK;
ms_filter_reset_statistics();
ms_tester_create_ticker();
ms_tester_create_filters(filter_mask);
ms_filter_set_notify_callback(ms_tester_tonedet, (MSFilterNotifyFunc)tone_detected_cb, NULL);
ms_connection_helper_start(&h);
ms_connection_helper_link(&h, ms_tester_voidsource, -1, 0);
ms_connection_helper_link(&h, ms_tester_dtmfgen, 0, 0);
ms_connection_helper_link(&h, ms_tester_tonedet, 0, 0);
ms_connection_helper_link(&h, ms_tester_voidsink, 0, -1);
ms_ticker_attach(ms_tester_ticker, ms_tester_voidsource);
ms_tester_tone_generation_and_detection_loop();
ms_ticker_detach(ms_tester_ticker, ms_tester_voidsource);
ms_connection_helper_start(&h);
ms_connection_helper_unlink(&h, ms_tester_voidsource, -1, 0);
ms_connection_helper_unlink(&h, ms_tester_dtmfgen, 0, 0);
ms_connection_helper_unlink(&h, ms_tester_tonedet, 0, 0);
ms_connection_helper_unlink(&h, ms_tester_voidsink, 0, -1);
ms_filter_log_statistics();
ms_tester_destroy_filters(filter_mask);
ms_tester_destroy_ticker();
}
static bool_t _link_all(MSMediaPlayer *obj) {
MSConnectionHelper helper;
if(obj->player == NULL) {
ms_error("Could not link graph. There is no playing filter");
return FALSE;
}
if(obj->audio_sink == NULL && obj->video_sink == NULL) {
ms_error("Could not link graph. There is neither audio sink nor video sink");
return FALSE;
}
if(obj->audio_pin_fmt.fmt && obj->audio_sink) {
ms_connection_helper_start(&helper);
ms_connection_helper_link(&helper, obj->player, -1, obj->audio_pin_fmt.pin);
if(obj->audio_decoder) ms_connection_helper_link(&helper, obj->audio_decoder, 0, 0);
if(obj->resampler) ms_connection_helper_link(&helper, obj->resampler, 0, 0);
ms_connection_helper_link(&helper, obj->audio_sink, 0, -1);
}
if(obj->video_pin_fmt.fmt && obj->video_sink) {
ms_connection_helper_start(&helper);
ms_connection_helper_link(&helper, obj->player, -1, obj->video_pin_fmt.pin);
if(obj->video_decoder) ms_connection_helper_link(&helper, obj->video_decoder, 0 , 0);
ms_connection_helper_link(&helper, obj->video_sink, 0, -1);
}
return TRUE;
}
void audio_stream_stop(AudioStream * stream)
{
if (stream->ticker){
MSConnectionHelper h;
#ifdef ENABLE_UDT
if (stream->udt) ms_ticker_detach (stream->ticker, stream->udt);
#endif // ENABLE_UDT
ms_ticker_detach(stream->ticker,stream->soundread);
ms_ticker_detach(stream->ticker,stream->rtprecv);
rtp_stats_display(rtp_session_get_stats(stream->session),"Audio session's RTP statistics");
/*dismantle the outgoing graph*/
ms_connection_helper_start(&h);
ms_connection_helper_unlink(&h,stream->soundread,-1,0);
if (stream->read_resampler!=NULL)
ms_connection_helper_unlink(&h,stream->read_resampler,0,0);
#ifndef ENABLED_MCU_MEDIA_SERVER
if (stream->ec!=NULL)
ms_connection_helper_unlink(&h,stream->ec,1,1);
if (stream->volsend!=NULL)
ms_connection_helper_unlink(&h,stream->volsend,0,0);
#endif // ENABLED_MCU_MEDIA_SERVER
if (stream->dtmfgen_rtp)
ms_connection_helper_unlink(&h,stream->dtmfgen_rtp,0,0);
ms_connection_helper_unlink(&h,stream->encoder,0,0);
ms_connection_helper_unlink(&h,stream->rtpsend,0,-1);
/*dismantle the receiving graph*/
ms_connection_helper_start(&h);
ms_connection_helper_unlink(&h,stream->rtprecv,-1,0);
ms_connection_helper_unlink(&h,stream->decoder,0,0);
ms_connection_helper_unlink(&h,stream->dtmfgen,0,0);
#ifndef ENABLED_MCU_MEDIA_SERVER
if (stream->equalizer)
ms_connection_helper_unlink(&h,stream->equalizer,0,0);
if (stream->volrecv!=NULL)
ms_connection_helper_unlink(&h,stream->volrecv,0,0);
if (stream->ec!=NULL)
ms_connection_helper_unlink(&h,stream->ec,0,0);
#endif // ENABLED_MCU_MEDIA_SERVER
if (stream->write_resampler!=NULL)
ms_connection_helper_unlink(&h,stream->write_resampler,0,0);
if(stream->mic_tee && stream->recordmixer)
ms_filter_unlink(stream->spk_tee,1,stream->recordmixer,1);
if(stream->spk_tee)
ms_connection_helper_unlink(&h,stream->spk_tee,0,0);
if (stream->tee2){
ms_connection_helper_unlink(&h,stream->tee2,0,0);
if(stream->audio_record)
ms_filter_unlink(stream->tee2,1,stream->audio_record,0);
}
ms_connection_helper_unlink(&h,stream->soundwrite,0,-1);
}
audio_stream_free(stream);
}
static void fileplay_soundwrite(const char *filename) {
MSConnectionHelper h;
bool_t need_resampler = FALSE;
unsigned int filter_mask = FILTER_MASK_FILEPLAY | FILTER_MASK_SOUNDWRITE;
int sample_rate = 8000;
int nchannels = 1;
int done = FALSE;
ms_filter_reset_statistics();
ms_tester_create_ticker();
ms_tester_create_filters(filter_mask);
ms_filter_set_notify_callback(ms_tester_fileplay, fileplay_eof, &done);
ms_filter_call_method_noarg(ms_tester_fileplay, MS_FILE_PLAYER_CLOSE);
ms_filter_call_method(ms_tester_fileplay, MS_FILE_PLAYER_OPEN, (void *)filename);
ms_filter_call_method(ms_tester_fileplay, MS_FILTER_GET_SAMPLE_RATE, &sample_rate);
ms_filter_call_method(ms_tester_fileplay, MS_FILTER_GET_NCHANNELS, &nchannels);
if (ms_filter_call_method(ms_tester_soundwrite, MS_FILTER_SET_BITRATE, &sample_rate) != 0) {
int soundwrite_sample_rate = 48000;
ms_filter_call_method(ms_tester_soundwrite, MS_FILTER_GET_BITRATE, &soundwrite_sample_rate);
if (sample_rate != soundwrite_sample_rate) need_resampler = TRUE;
}
if (ms_filter_call_method(ms_tester_soundwrite, MS_FILTER_SET_NCHANNELS, &nchannels) != 0) {
int soundwrite_nchannels = 1;
ms_filter_call_method(ms_tester_soundwrite, MS_FILTER_GET_NCHANNELS, &soundwrite_nchannels);
if (nchannels != soundwrite_nchannels) need_resampler = TRUE;
}
if (need_resampler == TRUE) {
ms_tester_create_filters(FILTER_MASK_RESAMPLER);
configure_resampler(ms_tester_resampler, ms_tester_fileplay, ms_tester_soundwrite);
}
ms_filter_call_method_noarg(ms_tester_fileplay, MS_FILE_PLAYER_START);
ms_connection_helper_start(&h);
ms_connection_helper_link(&h, ms_tester_fileplay, -1, 0);
if (need_resampler == TRUE) {
ms_connection_helper_link(&h, ms_tester_resampler, 0, 0);
}
ms_connection_helper_link(&h, ms_tester_soundwrite, 0, -1);
ms_ticker_attach(ms_tester_ticker, ms_tester_fileplay);
while (done != TRUE) {
ms_usleep(10000);
}
ms_filter_call_method_noarg(ms_tester_fileplay, MS_FILE_PLAYER_CLOSE);
ms_ticker_detach(ms_tester_ticker, ms_tester_fileplay);
ms_connection_helper_start(&h);
ms_connection_helper_unlink(&h, ms_tester_fileplay, -1, 0);
if (need_resampler == TRUE) {
ms_connection_helper_unlink(&h, ms_tester_resampler, 0, 0);
}
ms_connection_helper_unlink(&h, ms_tester_soundwrite, 0, -1);
if (need_resampler == TRUE) {
ms_tester_destroy_filters(FILTER_MASK_RESAMPLER);
}
ms_filter_log_statistics();
ms_tester_destroy_filters(filter_mask);
ms_tester_destroy_ticker();
}
static void dtmfgen_enc_dec_tonedet(char *mime, int sample_rate, int nchannels) {
MSConnectionHelper h;
unsigned int filter_mask = FILTER_MASK_VOIDSOURCE | FILTER_MASK_DTMFGEN | FILTER_MASK_ENCODER
| FILTER_MASK_DECODER | FILTER_MASK_TONEDET | FILTER_MASK_VOIDSINK;
bool_t send_silence = TRUE;
MSSndCardManager *scm = ms_factory_get_snd_card_manager(factory);
ms_factory_reset_statistics(scm->factory);
//ms_filter_reset_statistics();
ms_tester_create_ticker();
ms_tester_codec_mime = mime;
ms_tester_create_filters(filter_mask, scm->factory);
/* set sample rate and channel number to all filters (might need to check the return value to insert a resampler if needed?) */
ms_filter_call_method(ms_tester_voidsource, MS_FILTER_SET_SAMPLE_RATE, &sample_rate);
ms_filter_call_method(ms_tester_voidsource, MS_FILTER_SET_NCHANNELS, &nchannels);
ms_filter_call_method(ms_tester_voidsource, MS_VOID_SOURCE_SEND_SILENCE, &send_silence);
ms_filter_call_method(ms_tester_dtmfgen, MS_FILTER_SET_SAMPLE_RATE, &sample_rate);
ms_filter_call_method(ms_tester_dtmfgen, MS_FILTER_SET_NCHANNELS, &nchannels);
ms_filter_call_method(ms_tester_encoder, MS_FILTER_SET_SAMPLE_RATE, &sample_rate);
ms_filter_call_method(ms_tester_encoder, MS_FILTER_SET_NCHANNELS, &nchannels);
ms_filter_call_method(ms_tester_decoder, MS_FILTER_SET_SAMPLE_RATE, &sample_rate);
ms_filter_call_method(ms_tester_decoder, MS_FILTER_SET_NCHANNELS, &nchannels);
ms_filter_call_method(ms_tester_tonedet, MS_FILTER_SET_SAMPLE_RATE, &sample_rate);
ms_filter_call_method(ms_tester_tonedet, MS_FILTER_SET_NCHANNELS, &nchannels);
ms_filter_call_method(ms_tester_voidsink, MS_FILTER_SET_SAMPLE_RATE, &sample_rate);
ms_filter_call_method(ms_tester_voidsink, MS_FILTER_SET_NCHANNELS, &nchannels);
ms_filter_add_notify_callback(ms_tester_tonedet, (MSFilterNotifyFunc)tone_detected_cb, NULL,TRUE);
ms_connection_helper_start(&h);
ms_connection_helper_link(&h, ms_tester_voidsource, -1, 0);
ms_connection_helper_link(&h, ms_tester_dtmfgen, 0, 0);
ms_connection_helper_link(&h, ms_tester_encoder, 0, 0);
ms_connection_helper_link(&h, ms_tester_decoder, 0, 0);
ms_connection_helper_link(&h, ms_tester_tonedet, 0, 0);
ms_connection_helper_link(&h, ms_tester_voidsink, 0, -1);
ms_ticker_attach(ms_tester_ticker, ms_tester_voidsource);
ms_tester_tone_generation_and_detection_loop();
ms_ticker_detach(ms_tester_ticker, ms_tester_voidsource);
ms_connection_helper_start(&h);
ms_connection_helper_unlink(&h, ms_tester_voidsource, -1, 0);
ms_connection_helper_unlink(&h, ms_tester_dtmfgen, 0, 0);
ms_connection_helper_unlink(&h, ms_tester_encoder, 0, 0);
ms_connection_helper_unlink(&h, ms_tester_decoder, 0, 0);
ms_connection_helper_unlink(&h, ms_tester_tonedet, 0, 0);
ms_connection_helper_unlink(&h, ms_tester_voidsink, 0, -1);
// ms_filter_log_statistics();
ms_factory_log_statistics(scm->factory);
ms_tester_destroy_filters(filter_mask);
ms_tester_destroy_ticker();
}
TextStream* text_stream_start(TextStream *stream, RtpProfile *profile, const char *rem_rtp_addr, int rem_rtp_port, const char *rem_rtcp_addr, int rem_rtcp_port, int payload_type /* ignored */) {
RtpSession *rtps = stream->ms.sessions.rtp_session;
MSConnectionHelper h;
rtp_session_set_profile(rtps, profile);
if (rem_rtp_port > 0) rtp_session_set_remote_addr_full(rtps, rem_rtp_addr, rem_rtp_port, rem_rtcp_addr, rem_rtcp_port);
if (rem_rtcp_port > 0) {
rtp_session_enable_rtcp(rtps, TRUE);
} else {
rtp_session_enable_rtcp(rtps, FALSE);
}
stream->pt_t140 = rtp_profile_get_payload_number_from_mime(profile, "t140");
stream->pt_red = rtp_profile_get_payload_number_from_mime(profile, "red");
if (payload_type == stream->pt_t140) {
ms_message("Text payload type is T140");
} else if (payload_type == stream->pt_red) {
ms_message("Text payload type is RED");
} else {
/* we dont know this kind of textstream... */
ms_warning("unkown type of textstream");
}
rtp_session_set_payload_type(rtps, payload_type);
if (rem_rtp_port > 0) ms_filter_call_method(stream->ms.rtpsend, MS_RTP_SEND_SET_SESSION, rtps);
stream->ms.rtprecv = ms_filter_new(MS_RTP_RECV_ID);
ms_filter_call_method(stream->ms.rtprecv, MS_RTP_RECV_SET_SESSION, rtps);
stream->ms.sessions.rtp_session = rtps;
if (stream->ms.sessions.ticker == NULL) media_stream_start_ticker(&stream->ms);
stream->rttsource = ms_filter_new(MS_RTT_4103_SOURCE_ID);
stream->rttsink = ms_filter_new(MS_RTT_4103_SINK_ID);
ms_filter_call_method(stream->rttsource, MS_RTT_4103_SOURCE_SET_T140_PAYLOAD_TYPE_NUMBER, &stream->pt_t140);
ms_filter_call_method(stream->rttsink, MS_RTT_4103_SINK_SET_T140_PAYLOAD_TYPE_NUMBER, &stream->pt_t140);
if (payload_type == stream->pt_red) {
ms_filter_call_method(stream->rttsource, MS_RTT_4103_SOURCE_SET_RED_PAYLOAD_TYPE_NUMBER, &stream->pt_red);
ms_filter_call_method(stream->rttsink, MS_RTT_4103_SINK_SET_RED_PAYLOAD_TYPE_NUMBER, &stream->pt_red);
}
ms_connection_helper_start(&h);
ms_connection_helper_link(&h, stream->rttsource, -1, 0);
ms_connection_helper_link(&h, stream->ms.rtpsend, 0, -1);
ms_connection_helper_start(&h);
ms_connection_helper_link(&h, stream->ms.rtprecv, -1, 0);
ms_connection_helper_link(&h, stream->rttsink, 0, -1);
ms_ticker_attach_multiple(stream->ms.sessions.ticker, stream->rttsource, stream->ms.rtprecv, NULL);
stream->ms.start_time = stream->ms.last_packet_time = ms_time(NULL);
stream->ms.is_beginning = TRUE;
stream->ms.state = MSStreamStarted;
return stream;
}
static void dtmfgen_filerec_fileplay_tonedet(void) {
MSConnectionHelper h;
unsigned int filter_mask = FILTER_MASK_VOIDSOURCE | FILTER_MASK_DTMFGEN | FILTER_MASK_FILEREC
| FILTER_MASK_FILEPLAY | FILTER_MASK_TONEDET | FILTER_MASK_VOIDSINK;
bool_t send_silence = TRUE;
char* recorded_file = bc_tester_file(DTMFGEN_FILE_NAME);
ms_factory_reset_statistics(factory);
ms_tester_create_ticker();
ms_tester_create_filters(filter_mask, factory);
ms_filter_add_notify_callback(ms_tester_tonedet, (MSFilterNotifyFunc)tone_detected_cb, NULL,TRUE);
// Generate tones and save them to a file
ms_filter_call_method_noarg(ms_tester_filerec, MS_FILE_REC_CLOSE);
ms_filter_call_method(ms_tester_filerec, MS_FILE_REC_OPEN, recorded_file);
ms_filter_call_method_noarg(ms_tester_filerec, MS_FILE_REC_START);
ms_filter_call_method(ms_tester_voidsource, MS_VOID_SOURCE_SEND_SILENCE, &send_silence);
ms_connection_helper_start(&h);
ms_connection_helper_link(&h, ms_tester_voidsource, -1, 0);
ms_connection_helper_link(&h, ms_tester_dtmfgen, 0, 0);
ms_connection_helper_link(&h, ms_tester_filerec, 0, -1);
ms_ticker_attach(ms_tester_ticker, ms_tester_voidsource);
ms_tester_tone_generation_loop();
ms_filter_call_method_noarg(ms_tester_filerec, MS_FILE_REC_CLOSE);
ms_ticker_detach(ms_tester_ticker, ms_tester_voidsource);
ms_connection_helper_start(&h);
ms_connection_helper_unlink(&h, ms_tester_voidsource, -1, 0);
ms_connection_helper_unlink(&h, ms_tester_dtmfgen, 0, 0);
ms_connection_helper_unlink(&h, ms_tester_filerec, 0, -1);
// Read the previous file and detect the tones
ms_filter_call_method_noarg(ms_tester_fileplay, MS_FILE_PLAYER_CLOSE);
ms_filter_call_method(ms_tester_fileplay, MS_FILE_PLAYER_OPEN, recorded_file);
ms_filter_call_method_noarg(ms_tester_fileplay, MS_FILE_PLAYER_START);
ms_connection_helper_start(&h);
ms_connection_helper_link(&h, ms_tester_fileplay, -1, 0);
ms_connection_helper_link(&h, ms_tester_tonedet, 0, 0);
ms_connection_helper_link(&h, ms_tester_voidsink, 0, -1);
ms_ticker_attach(ms_tester_ticker, ms_tester_fileplay);
ms_tester_tone_detection_loop();
ms_filter_call_method_noarg(ms_tester_fileplay, MS_FILE_PLAYER_CLOSE);
ms_ticker_detach(ms_tester_ticker, ms_tester_fileplay);
ms_connection_helper_start(&h);
ms_connection_helper_unlink(&h, ms_tester_fileplay, -1, 0);
ms_connection_helper_unlink(&h, ms_tester_tonedet, 0, 0);
ms_connection_helper_unlink(&h, ms_tester_voidsink, 0, -1);
ms_factory_log_statistics(factory);
// ms_filter_log_statistics();
ms_tester_destroy_filters(filter_mask);
ms_tester_destroy_ticker();
unlink(recorded_file);
free(recorded_file);
}
static void dtmfgen_enc_rtp_dec_tonedet(void) {
MSConnectionHelper h;
RtpSession *rtps;
unsigned int filter_mask = FILTER_MASK_VOIDSOURCE | FILTER_MASK_DTMFGEN | FILTER_MASK_ENCODER
| FILTER_MASK_RTPSEND | FILTER_MASK_RTPRECV | FILTER_MASK_DECODER | FILTER_MASK_TONEDET | FILTER_MASK_VOIDSINK;
bool_t send_silence = TRUE;
MSSndCardManager *scm = ms_factory_get_snd_card_manager(factory);
ms_factory_reset_statistics(factory);
//ms_filter_reset_statistics();
ms_tester_create_ticker();
ms_tester_codec_mime = "pcmu";
ms_tester_create_filters(filter_mask, factory);
ms_filter_add_notify_callback(ms_tester_tonedet, (MSFilterNotifyFunc)tone_detected_cb, NULL,TRUE);
rtps = ms_create_duplex_rtp_session("0.0.0.0", 50060, 0, ms_factory_get_mtu(factory));
rtp_session_set_remote_addr_full(rtps, "127.0.0.1", 50060, "127.0.0.1", 50061);
rtp_session_set_payload_type(rtps, 8);
rtp_session_enable_rtcp(rtps,FALSE);
ms_filter_call_method(ms_tester_rtprecv, MS_RTP_RECV_SET_SESSION, rtps);
ms_filter_call_method(ms_tester_rtpsend, MS_RTP_SEND_SET_SESSION, rtps);
ms_filter_call_method(ms_tester_voidsource, MS_VOID_SOURCE_SEND_SILENCE, &send_silence);
ms_connection_helper_start(&h);
ms_connection_helper_link(&h, ms_tester_voidsource, -1, 0);
ms_connection_helper_link(&h, ms_tester_dtmfgen, 0, 0);
ms_connection_helper_link(&h, ms_tester_encoder, 0, 0);
ms_connection_helper_link(&h, ms_tester_rtpsend, 0, -1);
ms_connection_helper_start(&h);
ms_connection_helper_link(&h, ms_tester_rtprecv, -1, 0);
ms_connection_helper_link(&h, ms_tester_decoder, 0, 0);
ms_connection_helper_link(&h, ms_tester_tonedet, 0, 0);
ms_connection_helper_link(&h, ms_tester_voidsink, 0, -1);
ms_ticker_attach_multiple(ms_tester_ticker, ms_tester_voidsource, ms_tester_rtprecv, NULL);
ms_tester_tone_generation_and_detection_loop();
ms_ticker_detach(ms_tester_ticker, ms_tester_voidsource);
ms_ticker_detach(ms_tester_ticker, ms_tester_rtprecv);
ms_connection_helper_start(&h);
ms_connection_helper_unlink(&h, ms_tester_voidsource, -1, 0);
ms_connection_helper_unlink(&h, ms_tester_dtmfgen, 0, 0);
ms_connection_helper_unlink(&h, ms_tester_encoder, 0, 0);
ms_connection_helper_unlink(&h, ms_tester_rtpsend, 0, -1);
ms_connection_helper_start(&h);
ms_connection_helper_unlink(&h, ms_tester_rtprecv, -1, 0);
ms_connection_helper_unlink(&h, ms_tester_decoder, 0, 0);
ms_connection_helper_unlink(&h, ms_tester_tonedet, 0, 0);
ms_connection_helper_unlink(&h, ms_tester_voidsink, 0, -1);
// ms_filter_log_statistics();
ms_factory_log_statistics(scm->factory);
ms_tester_destroy_filters(filter_mask);
ms_tester_destroy_ticker();
rtp_session_destroy(rtps);
}
static void dtmfgen_soundwrite(void) {
MSConnectionHelper h;
bool_t need_resampler = FALSE;
unsigned int filter_mask = FILTER_MASK_VOIDSOURCE | FILTER_MASK_DTMFGEN | FILTER_MASK_SOUNDWRITE;
int sample_rate = 8000;
int nchannels = 1;
bool_t send_silence = TRUE;
ms_filter_reset_statistics();
ms_tester_create_ticker();
ms_tester_create_filters(filter_mask);
ms_filter_call_method(ms_tester_voidsource, MS_FILTER_SET_SAMPLE_RATE, &sample_rate);
ms_filter_call_method(ms_tester_voidsource, MS_FILTER_SET_NCHANNELS, &nchannels);
ms_filter_call_method(ms_tester_voidsource, MS_VOID_SOURCE_SEND_SILENCE, &send_silence);
ms_filter_call_method(ms_tester_dtmfgen, MS_FILTER_SET_SAMPLE_RATE, &sample_rate);
ms_filter_call_method(ms_tester_dtmfgen, MS_FILTER_SET_NCHANNELS, &nchannels);
if (ms_filter_call_method(ms_tester_soundwrite, MS_FILTER_SET_SAMPLE_RATE, &sample_rate) != 0) {
need_resampler = TRUE;
}
if (ms_filter_call_method(ms_tester_soundwrite, MS_FILTER_SET_NCHANNELS, &nchannels) != 0) {
need_resampler = TRUE;
}
if (need_resampler == TRUE) {
ms_tester_create_filters(FILTER_MASK_RESAMPLER);
configure_resampler(ms_tester_resampler, ms_tester_dtmfgen, ms_tester_soundwrite);
}
ms_connection_helper_start(&h);
ms_connection_helper_link(&h, ms_tester_voidsource, -1, 0);
ms_connection_helper_link(&h, ms_tester_dtmfgen, 0, 0);
if (need_resampler == TRUE) {
ms_connection_helper_link(&h, ms_tester_resampler, 0, 0);
}
ms_connection_helper_link(&h, ms_tester_soundwrite, 0, -1);
ms_ticker_attach(ms_tester_ticker, ms_tester_voidsource);
ms_tester_tone_generation_loop();
ms_ticker_detach(ms_tester_ticker, ms_tester_voidsource);
ms_connection_helper_start(&h);
ms_connection_helper_unlink(&h, ms_tester_voidsource, -1, 0);
ms_connection_helper_unlink(&h, ms_tester_dtmfgen, 0, 0);
if (need_resampler == TRUE) {
ms_connection_helper_unlink(&h, ms_tester_resampler, 0, 0);
}
ms_connection_helper_unlink(&h, ms_tester_soundwrite, 0, -1);
if (need_resampler == TRUE) {
ms_tester_destroy_filters(FILTER_MASK_RESAMPLER);
}
ms_filter_log_statistics();
ms_tester_destroy_filters(filter_mask);
ms_tester_destroy_ticker();
}
void audio_stream_stop(AudioStream * stream)
{
if (stream->ticker){
MSConnectionHelper h;
if(stream->record_enabled) audio_stream_record_stop(stream);
ms_ticker_detach(stream->ticker,stream->soundread);
ms_ticker_detach(stream->ticker,stream->rtprecv);
rtp_stats_display(rtp_session_get_stats(stream->session),"Audio session's RTP statistics");
/*dismantle the outgoing graph*/
ms_connection_helper_start(&h);
ms_connection_helper_unlink(&h,stream->soundread,-1,0);
if (stream->read_resampler!=NULL)
ms_connection_helper_unlink(&h,stream->read_resampler,0,0);
if (stream->ec!=NULL)
ms_connection_helper_unlink(&h,stream->ec,1,1);
if (stream->volsend!=NULL)
ms_connection_helper_unlink(&h,stream->volsend,0,0);
if(stream->mic_tee && stream->recordmixer)
ms_filter_unlink(stream->mic_tee,1,stream->recordmixer,0);
if(stream->mic_tee)
ms_connection_helper_unlink(&h,stream->mic_tee,0,0);
ms_connection_helper_unlink(&h,stream->encoder,0,0);
ms_connection_helper_unlink(&h,stream->rtpsend,0,-1);
/*dismantle the receiving graph*/
ms_connection_helper_start(&h);
ms_connection_helper_unlink(&h,stream->rtprecv,-1,0);
ms_connection_helper_unlink(&h,stream->decoder,0,0);
ms_connection_helper_unlink(&h,stream->dtmfgen,0,0);
if (stream->equalizer)
ms_connection_helper_unlink(&h,stream->equalizer,0,0);
if (stream->volrecv!=NULL)
ms_connection_helper_unlink(&h,stream->volrecv,0,0);
if (stream->ec!=NULL)
ms_connection_helper_unlink(&h,stream->ec,0,0);
if (stream->write_resampler!=NULL)
ms_connection_helper_unlink(&h,stream->write_resampler,0,0);
if(stream->mic_tee && stream->recordmixer)
ms_filter_unlink(stream->spk_tee,1,stream->recordmixer,1);
if(stream->spk_tee)
ms_connection_helper_unlink(&h,stream->spk_tee,0,0);
ms_connection_helper_unlink(&h,stream->soundwrite,0,-1);
}
audio_stream_free(stream);
}
static void soundread_soundwrite(void) {
MSConnectionHelper h;
bool_t need_resampler = FALSE;
unsigned int filter_mask = FILTER_MASK_SOUNDREAD | FILTER_MASK_SOUNDWRITE;
int sample_rate = 8000;
int nchannels = 1;
ms_filter_reset_statistics();
ms_tester_create_ticker();
ms_tester_create_filters(filter_mask);
ms_filter_call_method(ms_tester_soundread, MS_FILTER_GET_SAMPLE_RATE, &sample_rate);
ms_filter_call_method(ms_tester_soundread, MS_FILTER_GET_NCHANNELS, &nchannels);
if (ms_filter_call_method(ms_tester_soundwrite, MS_FILTER_SET_BITRATE, &sample_rate) != 0) {
int soundwrite_sample_rate = 48000;
ms_filter_call_method(ms_tester_soundwrite, MS_FILTER_GET_BITRATE, &soundwrite_sample_rate);
if (sample_rate != soundwrite_sample_rate) need_resampler = TRUE;
}
if (ms_filter_call_method(ms_tester_soundwrite, MS_FILTER_SET_NCHANNELS, &nchannels) != 0) {
int soundwrite_nchannels = 1;
ms_filter_call_method(ms_tester_soundwrite, MS_FILTER_GET_NCHANNELS, &soundwrite_nchannels);
if (nchannels != soundwrite_nchannels) need_resampler = TRUE;
}
if (need_resampler == TRUE) {
ms_tester_create_filters(FILTER_MASK_RESAMPLER);
configure_resampler(ms_tester_resampler, ms_tester_soundread, ms_tester_soundwrite);
}
ms_connection_helper_start(&h);
ms_connection_helper_link(&h, ms_tester_soundread, -1, 0);
if (need_resampler == TRUE) {
ms_connection_helper_link(&h, ms_tester_resampler, 0, 0);
}
ms_connection_helper_link(&h, ms_tester_soundwrite, 0, -1);
ms_ticker_attach(ms_tester_ticker, ms_tester_soundread);
ms_sleep(3);
ms_ticker_detach(ms_tester_ticker, ms_tester_soundread);
ms_connection_helper_start(&h);
ms_connection_helper_unlink(&h, ms_tester_soundread, -1, 0);
if (need_resampler == TRUE) {
ms_connection_helper_unlink(&h, ms_tester_resampler, 0, 0);
}
ms_connection_helper_unlink(&h, ms_tester_soundwrite, 0, -1);
if (need_resampler == TRUE) {
ms_tester_destroy_filters(FILTER_MASK_RESAMPLER);
}
ms_filter_log_statistics();
ms_tester_destroy_filters(filter_mask);
ms_tester_destroy_ticker();
}
static void _unlink_all(MSMediaPlayer *obj) {
MSConnectionHelper helper;
if(obj->audio_pin_fmt.fmt && obj->audio_sink) {
ms_connection_helper_start(&helper);
ms_connection_helper_unlink(&helper, obj->player, -1, obj->audio_pin_fmt.pin);
if(obj->audio_decoder) ms_connection_helper_unlink(&helper, obj->audio_decoder, 0, 0);
if(obj->resampler) ms_connection_helper_unlink(&helper, obj->resampler, 0, 0);
ms_connection_helper_unlink(&helper, obj->audio_sink, 0, -1);
}
if(obj->video_pin_fmt.fmt && obj->video_sink) {
ms_connection_helper_start(&helper);
ms_connection_helper_unlink(&helper, obj->player, -1, obj->video_pin_fmt.pin);
if(obj->video_decoder) ms_connection_helper_unlink(&helper, obj->video_decoder, 0 , 0);
ms_connection_helper_unlink(&helper, obj->video_sink, 0, -1);
}
}
RingStream * ring_start_with_cb(const char *file,int interval,MSSndCard *sndcard, MSFilterNotifyFunc func,void * user_data)
{
RingStream *stream;
int srcchannels, dstchannels;
int srcrate,dstrate;
MSConnectionHelper h;
MSTickerParams params={0};
stream=(RingStream *)ms_new0(RingStream,1);
stream->source=ms_filter_new(MS_FILE_PLAYER_ID);
if (file)
ms_filter_call_method(stream->source,MS_FILE_PLAYER_OPEN,(void*)file);
ms_filter_call_method(stream->source,MS_FILE_PLAYER_LOOP,&interval);
ms_filter_call_method_noarg(stream->source,MS_FILE_PLAYER_START);
if (func!=NULL)
ms_filter_set_notify_callback(stream->source,func,user_data);
stream->gendtmf=ms_filter_new(MS_DTMF_GEN_ID);
stream->sndwrite=ms_snd_card_create_writer(sndcard);
ms_filter_call_method(stream->source,MS_FILTER_GET_SAMPLE_RATE,&srcrate);
ms_filter_call_method(stream->gendtmf,MS_FILTER_SET_SAMPLE_RATE,&srcrate);
ms_filter_call_method(stream->sndwrite,MS_FILTER_SET_SAMPLE_RATE,&srcrate);
ms_filter_call_method(stream->sndwrite,MS_FILTER_GET_SAMPLE_RATE,&dstrate);
if (srcrate!=dstrate){
stream->write_resampler=ms_filter_new(MS_RESAMPLE_ID);
ms_filter_call_method(stream->write_resampler,MS_FILTER_SET_SAMPLE_RATE,&srcrate);
ms_filter_call_method(stream->write_resampler,MS_FILTER_SET_OUTPUT_SAMPLE_RATE,&dstrate);
ms_message("configuring resampler from rate [%i] to rate [%i]", srcrate,dstrate);
}
ms_filter_call_method(stream->source,MS_FILTER_GET_NCHANNELS,&srcchannels);
ms_filter_call_method(stream->gendtmf,MS_FILTER_SET_NCHANNELS,&srcchannels);
ms_filter_call_method(stream->sndwrite,MS_FILTER_SET_NCHANNELS,&srcchannels);
ms_filter_call_method(stream->sndwrite,MS_FILTER_GET_NCHANNELS,&dstchannels);
if (srcchannels != dstchannels) {
if (!stream->write_resampler) {
stream->write_resampler=ms_filter_new(MS_RESAMPLE_ID);
}
ms_filter_call_method(stream->write_resampler,MS_FILTER_SET_NCHANNELS,&srcchannels);
ms_filter_call_method(stream->write_resampler,MS_FILTER_SET_OUTPUT_NCHANNELS,&dstchannels);
ms_message("configuring resampler from channels [%i] to channels [%i]", srcchannels, dstchannels);
}
params.name="Ring MSTicker";
params.prio=MS_TICKER_PRIO_HIGH;
stream->ticker=ms_ticker_new_with_params(¶ms);
ms_connection_helper_start(&h);
ms_connection_helper_link(&h,stream->source,-1,0);
ms_connection_helper_link(&h,stream->gendtmf,0,0);
if (stream->write_resampler)
ms_connection_helper_link(&h,stream->write_resampler,0,0);
ms_connection_helper_link(&h,stream->sndwrite,0,-1);
ms_ticker_attach(stream->ticker,stream->source);
return stream;
}
static void lsd_player_uninit(LsdPlayer *p, MSConnectionPoint mixer){
MSConnectionHelper h;
ms_connection_helper_start(&h);
ms_connection_helper_unlink (&h,p->player,-1,0);
ms_connection_helper_unlink(&h,p->rateconv,0,0);
ms_connection_helper_unlink(&h,p->chanadapter,0,0);
ms_connection_helper_unlink(&h,mixer.filter,mixer.pin,-1);
ms_filter_destroy(p->player);
ms_filter_destroy(p->rateconv);
ms_filter_destroy(p->chanadapter);
}
static void lsd_player_init(LsdPlayer *p, MSConnectionPoint mixer, MSFilterId playerid, LinphoneSoundDaemon *lsd){
MSConnectionHelper h;
p->player=ms_filter_new(playerid);
p->rateconv=ms_filter_new(MS_RESAMPLE_ID);
p->chanadapter=ms_filter_new(MS_CHANNEL_ADAPTER_ID);
ms_connection_helper_start(&h);
ms_connection_helper_link(&h,p->player,-1,0);
ms_connection_helper_link(&h,p->rateconv,0,0);
ms_connection_helper_link(&h,p->chanadapter,0,0);
ms_connection_helper_link(&h,mixer.filter,mixer.pin,-1);
p->mixer_pin=mixer.pin;
p->loop=FALSE;
p->lsd=lsd;
}
void
video_stream_stop (VideoStream * stream)
{
stream->eventcb = NULL;
stream->event_pointer = NULL;
if (stream->ticker){
if (stream->voidsink) {
stop_preload_graph(stream);
} else {
if (stream->source)
ms_ticker_detach(stream->ticker,stream->source);
if (stream->rtprecv)
ms_ticker_detach(stream->ticker,stream->rtprecv);
if (stream->ice_check_list != NULL) {
ice_check_list_print_route(stream->ice_check_list, "Video session's route");
stream->ice_check_list = NULL;
}
rtp_stats_display(rtp_session_get_stats(stream->session),"Video session's RTP statistics");
if (stream->source){
ms_filter_unlink(stream->source,0,stream->pixconv,0);
ms_filter_unlink (stream->pixconv, 0, stream->sizeconv, 0);
ms_filter_unlink (stream->sizeconv, 0, stream->tee, 0);
ms_filter_unlink(stream->tee,0,stream->encoder,0);
ms_filter_unlink(stream->encoder, 0, stream->rtpsend,0);
if (stream->output2){
ms_filter_unlink(stream->tee,1,stream->output2,0);
}
}
if (stream->rtprecv){
MSConnectionHelper h;
ms_connection_helper_start (&h);
ms_connection_helper_unlink (&h,stream->rtprecv,-1,0);
ms_connection_helper_unlink (&h,stream->decoder,0,0);
if (stream->tee2){
ms_connection_helper_unlink (&h,stream->tee2,0,0);
ms_filter_unlink(stream->tee2,1,stream->jpegwriter,0);
}
if(stream->output)
ms_connection_helper_unlink (&h,stream->output,0,-1);
if (stream->tee && stream->output && stream->output2==NULL)
ms_filter_unlink(stream->tee,1,stream->output,1);
}
}
}
video_stream_free (stream);
}
static void clear_mediastreams(MediastreamDatas *args)
{
MSConnectionHelper h;
ms_message("stopping all...\n");
if (args->read) {
ms_ticker_detach(args->ticker, args->read);
ms_connection_helper_start(&h);
ms_connection_helper_unlink(&h, args->read, -1, 0);
ms_connection_helper_unlink(&h, args->decoder, 0, 0);
ms_connection_helper_unlink(&h, args->write, 0, -1);
}
rtp_profile_destroy(args->profile);
ms_exit();
}
void ring_stop(RingStream *stream){
MSConnectionHelper h;
ms_ticker_detach(stream->ticker,stream->source);
ms_connection_helper_start(&h);
ms_connection_helper_unlink(&h,stream->source,-1,0);
ms_connection_helper_unlink(&h,stream->gendtmf,0,0);
if (stream->write_resampler)
ms_connection_helper_unlink(&h,stream->write_resampler,0,0);
ms_connection_helper_unlink(&h,stream->sndwrite,0,-1);
ms_ticker_destroy(stream->ticker);
ms_filter_destroy(stream->source);
ms_filter_destroy(stream->gendtmf);
ms_filter_destroy(stream->sndwrite);
if (stream->write_resampler)
ms_filter_destroy(stream->write_resampler);
ms_free(stream);
}
void ring_stop(RingStream *stream){
MSConnectionHelper h;
ms_ticker_detach(stream->ticker,stream->source);
ms_connection_helper_start(&h);
ms_connection_helper_unlink(&h,stream->source,-1,0);
ms_connection_helper_unlink(&h,stream->gendtmf,0,0);
if (stream->write_resampler)
ms_connection_helper_unlink(&h,stream->write_resampler,0,0);
ms_connection_helper_unlink(&h,stream->sndwrite,0,-1);
ms_ticker_destroy(stream->ticker);
ms_filter_destroy(stream->source);
ms_filter_destroy(stream->gendtmf);
ms_filter_destroy(stream->sndwrite);
ms_free(stream);
#ifdef _WIN32_WCE
ms_warning("Sleeping a bit after closing the audio device...");
ms_sleep(1);
#endif
}
void
video_stream_stop (VideoStream * stream)
{
if (stream->ticker){
if (stream->source)
ms_ticker_detach(stream->ticker,stream->source);
if (stream->rtprecv)
ms_ticker_detach(stream->ticker,stream->rtprecv);
rtp_stats_display(rtp_session_get_stats(stream->session),"Video session's RTP statistics");
if (stream->source){
ms_filter_unlink(stream->source,0,stream->pixconv,0);
ms_filter_unlink (stream->pixconv, 0, stream->sizeconv, 0);
ms_filter_unlink (stream->sizeconv, 0, stream->tee, 0);
ms_filter_unlink(stream->tee,0,stream->encoder,0);
ms_filter_unlink(stream->encoder, 0, stream->rtpsend,0);
if (stream->output2){
ms_filter_unlink(stream->tee,1,stream->output2,0);
}
}
if (stream->rtprecv){
MSConnectionHelper h;
ms_connection_helper_start (&h);
ms_connection_helper_unlink (&h,stream->rtprecv,-1,0);
ms_connection_helper_unlink (&h,stream->decoder,0,0);
if (stream->tee2){
ms_connection_helper_unlink (&h,stream->tee2,0,0);
ms_filter_unlink(stream->tee2,1,stream->jpegwriter,0);
if(stream->video_record)
ms_filter_unlink(stream->tee2,2,stream->video_record,0);
}
ms_connection_helper_unlink (&h,stream->output,0,-1);
if (stream->tee && stream->output2==NULL && ms_filter_get_id(stream->output)!=MS_CONF_ITC_SINK_ID)
ms_filter_unlink(stream->tee,1,stream->output,1);
}
}
video_stream_free (stream);
}
void video_mail_record_stop(VideoMailRecord *vp)
{
MSConnectionHelper h;
VideoRecoder *os= vp->os;
if(vp->ticker)
{
if(vp->snd_read!=NULL && vp->snd_sink!=NULL){
ms_ticker_detach(vp->ticker,vp->snd_read);
ms_filter_unlink(vp->snd_read,0,vp->snd_sink,0);
}
if(vp->video_source!=NULL && vp->video_output!=NULL){
ms_ticker_detach(vp->ticker,vp->video_source);
ms_connection_helper_start(&h);
ms_connection_helper_unlink(&h,vp->video_source,-1,0);
ms_connection_helper_unlink(&h,vp->pixconv,0,0);
ms_connection_helper_unlink(&h,vp->sizeconv,0,0);
ms_connection_helper_unlink(&h,vp->video_tee,0,0);
ms_filter_unlink(vp->video_tee,1,vp->video_output,0);
ms_connection_helper_unlink(&h,vp->video_sink,0,-1);
}
}
if(vp->os) {
video_recoder_stop(os);
video_recoder_destory(os);
}
video_mail_record_free(vp);
}
static void soundread_speexenc_speexdec_soundwrite(void) {
MSConnectionHelper h;
MSFilter *read_resampler = NULL, *write_resampler = NULL;
bool_t need_read_resampler = FALSE, need_write_resampler = FALSE;
unsigned int filter_mask = FILTER_MASK_SOUNDREAD | FILTER_MASK_ENCODER | FILTER_MASK_DECODER | FILTER_MASK_SOUNDWRITE;
int sample_rate = 8000;
int nchannels = 1;
ms_filter_reset_statistics();
ms_tester_create_ticker();
ms_tester_codec_mime = "speex";
ms_tester_create_filters(filter_mask);
ms_filter_call_method(ms_tester_encoder, MS_FILTER_GET_BITRATE, &sample_rate);
ms_filter_call_method(ms_tester_decoder, MS_FILTER_SET_BITRATE, &sample_rate);
if (ms_filter_call_method(ms_tester_soundread, MS_FILTER_SET_BITRATE, &sample_rate) != 0) {
int soundread_sample_rate = 48000;
ms_filter_call_method(ms_tester_soundread, MS_FILTER_GET_BITRATE, &soundread_sample_rate);
if (sample_rate != soundread_sample_rate) need_read_resampler = TRUE;
}
if (ms_filter_call_method(ms_tester_soundread, MS_FILTER_SET_NCHANNELS, &nchannels) != 0) {
int soundread_nchannels = 1;
ms_filter_call_method(ms_tester_soundread, MS_FILTER_GET_NCHANNELS, &soundread_nchannels);
if (nchannels != soundread_nchannels) need_read_resampler = TRUE;
}
if (need_read_resampler == TRUE) {
ms_tester_create_filter(&read_resampler, MS_RESAMPLE_ID);
configure_resampler(read_resampler, ms_tester_soundread, ms_tester_encoder);
}
if (ms_filter_call_method(ms_tester_soundwrite, MS_FILTER_SET_BITRATE, &sample_rate) != 0) {
int soundwrite_sample_rate = 48000;
ms_filter_call_method(ms_tester_soundwrite, MS_FILTER_GET_BITRATE, &soundwrite_sample_rate);
if (sample_rate != soundwrite_sample_rate) need_write_resampler = TRUE;
}
if (ms_filter_call_method(ms_tester_soundwrite, MS_FILTER_SET_NCHANNELS, &nchannels) != 0) {
int soundwrite_nchannels = 1;
ms_filter_call_method(ms_tester_soundwrite, MS_FILTER_GET_NCHANNELS, &soundwrite_nchannels);
if (nchannels != soundwrite_nchannels) need_write_resampler = TRUE;
}
if (need_write_resampler == TRUE) {
ms_tester_create_filter(&write_resampler, MS_RESAMPLE_ID);
configure_resampler(write_resampler, ms_tester_decoder, ms_tester_soundwrite);
}
ms_connection_helper_start(&h);
ms_connection_helper_link(&h, ms_tester_soundread, -1, 0);
if (need_read_resampler == TRUE) {
ms_connection_helper_link(&h, read_resampler, 0, 0);
}
ms_connection_helper_link(&h, ms_tester_encoder, 0, 0);
ms_connection_helper_link(&h, ms_tester_decoder, 0, 0);
if (need_write_resampler == TRUE) {
ms_connection_helper_link(&h, write_resampler, 0, 0);
}
ms_connection_helper_link(&h, ms_tester_soundwrite, 0, -1);
ms_ticker_attach(ms_tester_ticker, ms_tester_soundread);
ms_sleep(5);
ms_ticker_detach(ms_tester_ticker, ms_tester_soundread);
ms_connection_helper_start(&h);
ms_connection_helper_unlink(&h, ms_tester_soundread, -1, 0);
if (need_read_resampler == TRUE) {
ms_connection_helper_unlink(&h, read_resampler, 0, 0);
}
ms_connection_helper_unlink(&h, ms_tester_encoder, 0, 0);
ms_connection_helper_unlink(&h, ms_tester_decoder, 0, 0);
if (need_write_resampler == TRUE) {
ms_connection_helper_unlink(&h, write_resampler, 0, 0);
}
ms_connection_helper_unlink(&h, ms_tester_soundwrite, 0, -1);
if (need_read_resampler == TRUE) {
ms_tester_destroy_filter(&read_resampler);
}
if (need_write_resampler == TRUE) {
ms_tester_destroy_filter(&write_resampler);
}
ms_filter_log_statistics();
ms_tester_destroy_filters(filter_mask);
ms_tester_destroy_ticker();
}
void audio_stream_stop(AudioStream * stream)
{
if (stream->ms.ticker){
MSConnectionHelper h;
if (stream->dummy){
stop_preload_graph(stream);
}else if (stream->ms.start_time!=0){
ms_ticker_detach(stream->ms.ticker,stream->soundread);
ms_ticker_detach(stream->ms.ticker,stream->ms.rtprecv);
if (stream->ms.ice_check_list != NULL) {
ice_check_list_print_route(stream->ms.ice_check_list, "Audio session's route");
stream->ms.ice_check_list = NULL;
}
rtp_stats_display(rtp_session_get_stats(stream->ms.session),
" AUDIO SESSION'S RTP STATISTICS ");
/*dismantle the outgoing graph*/
ms_connection_helper_start(&h);
ms_connection_helper_unlink(&h,stream->soundread,-1,0);
if (stream->read_resampler!=NULL)
ms_connection_helper_unlink(&h,stream->read_resampler,0,0);
if (stream->ec!=NULL)
ms_connection_helper_unlink(&h,stream->ec,1,1);
if (stream->volsend!=NULL)
ms_connection_helper_unlink(&h,stream->volsend,0,0);
if (stream->dtmfgen_rtp)
ms_connection_helper_unlink(&h,stream->dtmfgen_rtp,0,0);
if (stream->send_tee)
ms_connection_helper_unlink(&h,stream->send_tee,0,0);
ms_connection_helper_unlink(&h,stream->ms.encoder,0,0);
ms_connection_helper_unlink(&h,stream->ms.rtpsend,0,-1);
/*dismantle the receiving graph*/
ms_connection_helper_start(&h);
ms_connection_helper_unlink(&h,stream->ms.rtprecv,-1,0);
ms_connection_helper_unlink(&h,stream->ms.decoder,0,0);
if (stream->plc!=NULL)
ms_connection_helper_unlink(&h,stream->plc,0,0);
if (stream->dtmfgen!=NULL)
ms_connection_helper_unlink(&h,stream->dtmfgen,0,0);
if (stream->volrecv!=NULL)
ms_connection_helper_unlink(&h,stream->volrecv,0,0);
if (stream->recv_tee)
ms_connection_helper_unlink(&h,stream->recv_tee,0,0);
if (stream->equalizer!=NULL)
ms_connection_helper_unlink(&h,stream->equalizer,0,0);
if (stream->ec!=NULL)
ms_connection_helper_unlink(&h,stream->ec,0,0);
if (stream->write_resampler!=NULL)
ms_connection_helper_unlink(&h,stream->write_resampler,0,0);
ms_connection_helper_unlink(&h,stream->soundwrite,0,-1);
/*dismantle the call recording */
if (stream->recorder){
ms_filter_unlink(stream->send_tee,1,stream->recorder_mixer,0);
ms_filter_unlink(stream->recv_tee,1,stream->recorder_mixer,1);
ms_filter_unlink(stream->recorder_mixer,0,stream->recorder,0);
}
}
}
audio_stream_free(stream);
ms_filter_log_statistics();
}
int audio_stream_start_full(AudioStream *stream, RtpProfile *profile, const char *rem_rtp_ip,int rem_rtp_port,
const char *rem_rtcp_ip, int rem_rtcp_port, int payload,int jitt_comp, const char *infile, const char *outfile,
MSSndCard *playcard, MSSndCard *captcard, bool_t use_ec)
{
RtpSession *rtps=stream->ms.session;
PayloadType *pt,*tel_ev;
int tmp;
MSConnectionHelper h;
int sample_rate;
MSRtpPayloadPickerContext picker_context;
bool_t has_builtin_ec=FALSE;
rtp_session_set_profile(rtps,profile);
if (rem_rtp_port>0) rtp_session_set_remote_addr_full(rtps,rem_rtp_ip,rem_rtp_port,rem_rtcp_ip,rem_rtcp_port);
if (rem_rtcp_port<=0){
rtp_session_enable_rtcp(rtps,FALSE);
}
rtp_session_set_payload_type(rtps,payload);
rtp_session_set_jitter_compensation(rtps,jitt_comp);
if (rem_rtp_port>0)
ms_filter_call_method(stream->ms.rtpsend,MS_RTP_SEND_SET_SESSION,rtps);
stream->ms.rtprecv=ms_filter_new(MS_RTP_RECV_ID);
ms_filter_call_method(stream->ms.rtprecv,MS_RTP_RECV_SET_SESSION,rtps);
stream->ms.session=rtps;
if((stream->features & AUDIO_STREAM_FEATURE_DTMF) != 0)
stream->dtmfgen=ms_filter_new(MS_DTMF_GEN_ID);
else
stream->dtmfgen=NULL;
rtp_session_signal_connect(rtps,"telephone-event",(RtpCallback)on_dtmf_received,(unsigned long)stream);
rtp_session_signal_connect(rtps,"payload_type_changed",(RtpCallback)mediastream_payload_type_changed,(unsigned long)&stream->ms);
/* creates the local part */
if (captcard!=NULL){
if (stream->soundread==NULL)
stream->soundread=ms_snd_card_create_reader(captcard);
has_builtin_ec=!!(ms_snd_card_get_capabilities(captcard) & MS_SND_CARD_CAP_BUILTIN_ECHO_CANCELLER);
}else {
stream->soundread=ms_filter_new(MS_FILE_PLAYER_ID);
stream->read_resampler=ms_filter_new(MS_RESAMPLE_ID);
if (infile!=NULL) audio_stream_play(stream,infile);
}
if (playcard!=NULL) {
if (stream->soundwrite==NULL)
stream->soundwrite=ms_snd_card_create_writer(playcard);
}else {
stream->soundwrite=ms_filter_new(MS_FILE_REC_ID);
if (outfile!=NULL) audio_stream_record(stream,outfile);
}
/* creates the couple of encoder/decoder */
pt=rtp_profile_get_payload(profile,payload);
if (pt==NULL){
ms_error("audiostream.c: undefined payload type.");
return -1;
}
tel_ev=rtp_profile_get_payload_from_mime (profile,"telephone-event");
if ((stream->features & AUDIO_STREAM_FEATURE_DTMF_ECHO) != 0 && (tel_ev==NULL || ( (tel_ev->flags & PAYLOAD_TYPE_FLAG_CAN_RECV) && !(tel_ev->flags & PAYLOAD_TYPE_FLAG_CAN_SEND)))
&& ( strcasecmp(pt->mime_type,"pcmu")==0 || strcasecmp(pt->mime_type,"pcma")==0)){
/*if no telephone-event payload is usable and pcma or pcmu is used, we will generate
inband dtmf*/
stream->dtmfgen_rtp=ms_filter_new (MS_DTMF_GEN_ID);
} else {
stream->dtmfgen_rtp=NULL;
}
if (ms_filter_call_method(stream->ms.rtpsend,MS_FILTER_GET_SAMPLE_RATE,&sample_rate)!=0){
ms_error("Sample rate is unknown for RTP side !");
return -1;
}
stream->ms.encoder=ms_filter_create_encoder(pt->mime_type);
stream->ms.decoder=ms_filter_create_decoder(pt->mime_type);
if ((stream->ms.encoder==NULL) || (stream->ms.decoder==NULL)){
/* big problem: we have not a registered codec for this payload...*/
ms_error("audio_stream_start_full: No decoder or encoder available for payload %s.",pt->mime_type);
return -1;
}
if (ms_filter_has_method(stream->ms.decoder, MS_FILTER_SET_RTP_PAYLOAD_PICKER)) {
ms_message(" decoder has FEC capabilities");
picker_context.filter_graph_manager=stream;
picker_context.picker=&audio_stream_payload_picker;
ms_filter_call_method(stream->ms.decoder,MS_FILTER_SET_RTP_PAYLOAD_PICKER, &picker_context);
}
if((stream->features & AUDIO_STREAM_FEATURE_VOL_SND) != 0)
stream->volsend=ms_filter_new(MS_VOLUME_ID);
else
stream->volsend=NULL;
if((stream->features & AUDIO_STREAM_FEATURE_VOL_RCV) != 0)
stream->volrecv=ms_filter_new(MS_VOLUME_ID);
else
stream->volrecv=NULL;
audio_stream_enable_echo_limiter(stream,stream->el_type);
audio_stream_enable_noise_gate(stream,stream->use_ng);
if (stream->use_agc){
int tmp=1;
if (stream->volsend==NULL)
stream->volsend=ms_filter_new(MS_VOLUME_ID);
ms_filter_call_method(stream->volsend,MS_VOLUME_ENABLE_AGC,&tmp);
}
if (stream->dtmfgen) {
ms_filter_call_method(stream->dtmfgen,MS_FILTER_SET_SAMPLE_RATE,&sample_rate);
ms_filter_call_method(stream->dtmfgen,MS_FILTER_SET_NCHANNELS,&pt->channels);
}
if (stream->dtmfgen_rtp) {
ms_filter_call_method(stream->dtmfgen_rtp,MS_FILTER_SET_SAMPLE_RATE,&sample_rate);
ms_filter_call_method(stream->dtmfgen_rtp,MS_FILTER_SET_NCHANNELS,&pt->channels);
}
/* give the sound filters some properties */
if (ms_filter_call_method(stream->soundread,MS_FILTER_SET_SAMPLE_RATE,&sample_rate) != 0) {
/* need to add resampler*/
if (stream->read_resampler == NULL) stream->read_resampler=ms_filter_new(MS_RESAMPLE_ID);
}
ms_filter_call_method(stream->soundread,MS_FILTER_SET_NCHANNELS,&pt->channels);
if (ms_filter_call_method(stream->soundwrite,MS_FILTER_SET_SAMPLE_RATE,&sample_rate) != 0) {
/* need to add resampler*/
if (stream->write_resampler == NULL) stream->write_resampler=ms_filter_new(MS_RESAMPLE_ID);
}
ms_filter_call_method(stream->soundwrite,MS_FILTER_SET_NCHANNELS,&pt->channels);
// Override feature
if ( ((stream->features & AUDIO_STREAM_FEATURE_EC) && !use_ec) || has_builtin_ec )
stream->features &=~AUDIO_STREAM_FEATURE_EC;
/*configure the echo canceller if required */
if ((stream->features & AUDIO_STREAM_FEATURE_EC) == 0 && stream->ec != NULL) {
ms_filter_destroy(stream->ec);
stream->ec=NULL;
}
if (stream->ec){
if (!stream->is_ec_delay_set){
int delay_ms=ms_snd_card_get_minimal_latency(captcard);
if (delay_ms!=0){
ms_message("Setting echo canceller delay with value provided by soundcard: %i ms",delay_ms);
ms_filter_call_method(stream->ec,MS_ECHO_CANCELLER_SET_DELAY,&delay_ms);
}
}
ms_filter_call_method(stream->ec,MS_FILTER_SET_SAMPLE_RATE,&sample_rate);
}
if (stream->features & AUDIO_STREAM_FEATURE_MIXED_RECORDING){
int val=0;
int pin=1;
stream->recorder=ms_filter_new(MS_FILE_REC_ID);
stream->recorder_mixer=ms_filter_new(MS_AUDIO_MIXER_ID);
stream->recv_tee=ms_filter_new(MS_TEE_ID);
stream->send_tee=ms_filter_new(MS_TEE_ID);
ms_filter_call_method(stream->recorder_mixer,MS_AUDIO_MIXER_ENABLE_CONFERENCE_MODE,&val);
ms_filter_call_method(stream->recorder_mixer,MS_FILTER_SET_SAMPLE_RATE,&sample_rate);
ms_filter_call_method(stream->recorder_mixer,MS_FILTER_SET_NCHANNELS,&pt->channels);
ms_filter_call_method(stream->recv_tee,MS_TEE_MUTE,&pin);
ms_filter_call_method(stream->send_tee,MS_TEE_MUTE,&pin);
ms_filter_call_method(stream->recorder,MS_FILTER_SET_SAMPLE_RATE,&sample_rate);
ms_filter_call_method(stream->recorder,MS_FILTER_SET_NCHANNELS,&pt->channels);
}
/* give the encoder/decoder some parameters*/
ms_filter_call_method(stream->ms.encoder,MS_FILTER_SET_SAMPLE_RATE,&sample_rate);
ms_message("Payload's bitrate is %i",pt->normal_bitrate);
if (pt->normal_bitrate>0){
ms_message("Setting audio encoder network bitrate to %i",pt->normal_bitrate);
ms_filter_call_method(stream->ms.encoder,MS_FILTER_SET_BITRATE,&pt->normal_bitrate);
}
ms_filter_call_method(stream->ms.encoder,MS_FILTER_SET_NCHANNELS,&pt->channels);
ms_filter_call_method(stream->ms.decoder,MS_FILTER_SET_SAMPLE_RATE,&sample_rate);
ms_filter_call_method(stream->ms.decoder,MS_FILTER_SET_NCHANNELS,&pt->channels);
if (pt->send_fmtp!=NULL) {
char value[16]={0};
int ptime;
if (ms_filter_has_method(stream->ms.encoder,MS_AUDIO_ENCODER_SET_PTIME)){
if (fmtp_get_value(pt->send_fmtp,"ptime",value,sizeof(value)-1)){
ptime=atoi(value);
ms_filter_call_method(stream->ms.encoder,MS_AUDIO_ENCODER_SET_PTIME,&ptime);
}
}
ms_filter_call_method(stream->ms.encoder,MS_FILTER_ADD_FMTP, (void*)pt->send_fmtp);
}
if (pt->recv_fmtp!=NULL) ms_filter_call_method(stream->ms.decoder,MS_FILTER_ADD_FMTP,(void*)pt->recv_fmtp);
/*create the equalizer*/
if ((stream->features & AUDIO_STREAM_FEATURE_EQUALIZER) != 0){
stream->equalizer=ms_filter_new(MS_EQUALIZER_ID);
if(stream->equalizer) {
tmp=stream->eq_active;
ms_filter_call_method(stream->equalizer,MS_EQUALIZER_SET_ACTIVE,&tmp);
}
}else
stream->equalizer=NULL;
/*configure resampler if needed*/
ms_filter_call_method(stream->ms.rtpsend, MS_FILTER_SET_NCHANNELS, &pt->channels);
ms_filter_call_method(stream->ms.rtprecv, MS_FILTER_SET_NCHANNELS, &pt->channels);
if (stream->read_resampler){
audio_stream_configure_resampler(stream->read_resampler,stream->soundread,stream->ms.rtpsend);
}
if (stream->write_resampler){
audio_stream_configure_resampler(stream->write_resampler,stream->ms.rtprecv,stream->soundwrite);
}
if (stream->ms.use_rc){
stream->ms.rc=ms_audio_bitrate_controller_new(stream->ms.session,stream->ms.encoder,0);
}
/* Create PLC */
if ((stream->features & AUDIO_STREAM_FEATURE_PLC) != 0) {
int decoder_have_plc = 0;
if (ms_filter_has_method(stream->ms.decoder, MS_AUDIO_DECODER_HAVE_PLC)) {
if (ms_filter_call_method(stream->ms.decoder, MS_AUDIO_DECODER_HAVE_PLC, &decoder_have_plc) != 0) {
ms_warning("MS_AUDIO_DECODER_HAVE_PLC function error: enable default plc");
}
} else {
ms_warning("MS_DECODER_HAVE_PLC function not implemented by the decoder: enable default plc");
}
if (decoder_have_plc == 0) {
stream->plc = ms_filter_new(MS_GENERIC_PLC_ID);
}
if (stream->plc) {
ms_filter_call_method(stream->plc, MS_FILTER_SET_NCHANNELS, &pt->channels);
ms_filter_call_method(stream->plc, MS_FILTER_SET_SAMPLE_RATE, &sample_rate);
}
} else {
stream->plc = NULL;
}
/* create ticker */
if (stream->ms.ticker==NULL) start_ticker(&stream->ms);
else{
/*we were using the dummy preload graph, destroy it*/
if (stream->dummy) stop_preload_graph(stream);
}
/* and then connect all */
/* tip: draw yourself the picture if you don't understand */
/*sending graph*/
ms_connection_helper_start(&h);
ms_connection_helper_link(&h,stream->soundread,-1,0);
if (stream->read_resampler)
ms_connection_helper_link(&h,stream->read_resampler,0,0);
if (stream->ec)
ms_connection_helper_link(&h,stream->ec,1,1);
if (stream->volsend)
ms_connection_helper_link(&h,stream->volsend,0,0);
if (stream->dtmfgen_rtp)
ms_connection_helper_link(&h,stream->dtmfgen_rtp,0,0);
if (stream->send_tee)
ms_connection_helper_link(&h,stream->send_tee,0,0);
ms_connection_helper_link(&h,stream->ms.encoder,0,0);
ms_connection_helper_link(&h,stream->ms.rtpsend,0,-1);
/*receiving graph*/
ms_connection_helper_start(&h);
ms_connection_helper_link(&h,stream->ms.rtprecv,-1,0);
ms_connection_helper_link(&h,stream->ms.decoder,0,0);
if (stream->plc)
ms_connection_helper_link(&h,stream->plc,0,0);
if (stream->dtmfgen)
ms_connection_helper_link(&h,stream->dtmfgen,0,0);
if (stream->volrecv)
ms_connection_helper_link(&h,stream->volrecv,0,0);
if (stream->recv_tee)
ms_connection_helper_link(&h,stream->recv_tee,0,0);
if (stream->equalizer)
ms_connection_helper_link(&h,stream->equalizer,0,0);
if (stream->ec)
ms_connection_helper_link(&h,stream->ec,0,0);
if (stream->write_resampler)
ms_connection_helper_link(&h,stream->write_resampler,0,0);
ms_connection_helper_link(&h,stream->soundwrite,0,-1);
/*call recording part, attached to both outgoing and incoming graphs*/
if (stream->recorder){
ms_filter_link(stream->send_tee,1,stream->recorder_mixer,0);
ms_filter_link(stream->recv_tee,1,stream->recorder_mixer,1);
ms_filter_link(stream->recorder_mixer,0,stream->recorder,0);
}
/*to make sure all preprocess are done before befre processing audio*/
ms_ticker_attach_multiple(stream->ms.ticker
,stream->soundread
,stream->ms.rtprecv
,NULL);
stream->ms.start_time=ms_time(NULL);
stream->ms.is_beginning=TRUE;
return 0;
}
void
video_stream_stop (VideoStream * stream)
{
stream->eventcb = NULL;
stream->event_pointer = NULL;
if (stream->ms.ticker){
if (stream->prepare_ongoing == TRUE) {
stop_preload_graph(stream);
} else {
if (stream->source)
ms_ticker_detach(stream->ms.ticker,stream->source);
if (stream->ms.rtprecv)
ms_ticker_detach(stream->ms.ticker,stream->ms.rtprecv);
if (stream->ms.ice_check_list != NULL) {
ice_check_list_print_route(stream->ms.ice_check_list, "Video session's route");
stream->ms.ice_check_list = NULL;
}
rtp_stats_display(rtp_session_get_stats(stream->ms.session),
" VIDEO SESSION'S RTP STATISTICS ");
if (stream->source){
MSConnectionHelper ch;
ms_connection_helper_start(&ch);
ms_connection_helper_unlink(&ch, stream->source, -1, 0);
if (stream->pixconv) {
ms_connection_helper_unlink(&ch, stream->pixconv, 0, 0);
}
if (stream->sizeconv) {
ms_connection_helper_unlink(&ch, stream->sizeconv, 0, 0);
}
ms_connection_helper_unlink(&ch, stream->tee, 0, 0);
if (stream->source_performs_encoding == FALSE) {
ms_connection_helper_unlink(&ch, stream->ms.encoder, 0, 0);
}
ms_connection_helper_unlink(&ch, stream->ms.rtpsend, 0, -1);
if (stream->output2){
ms_filter_unlink(stream->tee,1,stream->output2,0);
}
}
if (stream->ms.voidsink) {
ms_filter_unlink(stream->ms.rtprecv, 0, stream->ms.voidsink, 0);
} else if (stream->ms.rtprecv){
MSConnectionHelper h;
ms_connection_helper_start (&h);
ms_connection_helper_unlink (&h,stream->ms.rtprecv,-1,0);
if (stream->output_performs_decoding == FALSE) {
ms_connection_helper_unlink (&h,stream->ms.decoder,0,0);
}
if (stream->tee2){
ms_connection_helper_unlink (&h,stream->tee2,0,0);
ms_filter_unlink(stream->tee2,1,stream->jpegwriter,0);
}
if(stream->output)
ms_connection_helper_unlink (&h,stream->output,0,-1);
if (stream->tee && stream->output && stream->output2==NULL)
ms_filter_unlink(stream->tee,1,stream->output,1);
}
}
}
video_stream_free (stream);
}
int video_stream_start (VideoStream *stream, RtpProfile *profile, const char *rem_rtp_ip, int rem_rtp_port,
const char *rem_rtcp_ip, int rem_rtcp_port, int payload, int jitt_comp, MSWebCam *cam){
PayloadType *pt;
RtpSession *rtps=stream->ms.session;
MSPixFmt format;
MSVideoSize disp_size;
int tmp;
JBParameters jbp;
const int socket_buf_size=2000000;
if (cam==NULL){
cam=ms_web_cam_manager_get_default_cam (
ms_web_cam_manager_get());
}
pt=rtp_profile_get_payload(profile,payload);
if (pt==NULL){
ms_error("videostream.c: undefined payload type.");
return -1;
}
if ((cam != NULL) && (cam->desc->encode_to_mime_type != NULL) && (cam->desc->encode_to_mime_type(cam, pt->mime_type) == TRUE)) {
stream->source_performs_encoding = TRUE;
}
rtp_session_set_profile(rtps,profile);
if (rem_rtp_port>0) rtp_session_set_remote_addr_full(rtps,rem_rtp_ip,rem_rtp_port,rem_rtcp_ip,rem_rtcp_port);
rtp_session_set_payload_type(rtps,payload);
rtp_session_set_jitter_compensation(rtps,jitt_comp);
rtp_session_signal_connect(stream->ms.session,"payload_type_changed",
(RtpCallback)mediastream_payload_type_changed,(unsigned long)&stream->ms);
rtp_session_get_jitter_buffer_params(stream->ms.session,&jbp);
jbp.max_packets=1000;//needed for high resolution video
rtp_session_set_jitter_buffer_params(stream->ms.session,&jbp);
rtp_session_set_rtp_socket_recv_buffer_size(stream->ms.session,socket_buf_size);
rtp_session_set_rtp_socket_send_buffer_size(stream->ms.session,socket_buf_size);
if (stream->dir==VideoStreamSendRecv || stream->dir==VideoStreamSendOnly){
MSConnectionHelper ch;
/*plumb the outgoing stream */
if (rem_rtp_port>0) ms_filter_call_method(stream->ms.rtpsend,MS_RTP_SEND_SET_SESSION,stream->ms.session);
if (stream->source_performs_encoding == FALSE) {
stream->ms.encoder=ms_filter_create_encoder(pt->mime_type);
if ((stream->ms.encoder==NULL) ){
/* big problem: we don't have a registered codec for this payload...*/
ms_error("videostream.c: No encoder available for payload %i:%s.",payload,pt->mime_type);
return -1;
}
}
/* creates the filters */
stream->cam=cam;
stream->source = ms_web_cam_create_reader(cam);
stream->tee = ms_filter_new(MS_TEE_ID);
if (stream->source_performs_encoding == TRUE) {
stream->ms.encoder = stream->source; /* Consider the encoder is the source */
}
if (pt->normal_bitrate>0){
MSVideoConfiguration *vconf_list = NULL;
ms_message("Limiting bitrate of video encoder to %i bits/s",pt->normal_bitrate);
ms_filter_call_method(stream->ms.encoder, MS_VIDEO_ENCODER_GET_CONFIGURATION_LIST, &vconf_list);
if (vconf_list != NULL) {
MSVideoConfiguration vconf = ms_video_find_best_configuration_for_bitrate(vconf_list, pt->normal_bitrate);
ms_filter_call_method(stream->ms.encoder, MS_VIDEO_ENCODER_SET_CONFIGURATION, &vconf);
} else {
ms_filter_call_method(stream->ms.encoder, MS_FILTER_SET_BITRATE, &pt->normal_bitrate);
}
}
if (pt->send_fmtp){
ms_filter_call_method(stream->ms.encoder,MS_FILTER_ADD_FMTP,pt->send_fmtp);
}
if (stream->use_preview_window){
if (stream->rendercb==NULL){
stream->output2=ms_filter_new_from_name (stream->display_name);
}
}
configure_video_source (stream);
/* and then connect all */
ms_connection_helper_start(&ch);
ms_connection_helper_link(&ch, stream->source, -1, 0);
if (stream->pixconv) {
ms_connection_helper_link(&ch, stream->pixconv, 0, 0);
}
if (stream->sizeconv) {
ms_connection_helper_link(&ch, stream->sizeconv, 0, 0);
}
ms_connection_helper_link(&ch, stream->tee, 0, 0);
if (stream->source_performs_encoding == FALSE) {
ms_connection_helper_link(&ch, stream->ms.encoder, 0, 0);
}
ms_connection_helper_link(&ch, stream->ms.rtpsend, 0, -1);
if (stream->output2){
if (stream->preview_window_id!=0){
ms_filter_call_method(stream->output2, MS_VIDEO_DISPLAY_SET_NATIVE_WINDOW_ID,&stream->preview_window_id);
}
ms_filter_link(stream->tee,1,stream->output2,0);
}
}
if (stream->dir==VideoStreamSendRecv || stream->dir==VideoStreamRecvOnly){
MSConnectionHelper ch;
MSVideoDisplayDecodingSupport decoding_support;
if (stream->rendercb!=NULL){
stream->output=ms_filter_new(MS_EXT_DISPLAY_ID);
ms_filter_set_notify_callback(stream->output,ext_display_cb,stream);
}else{
stream->output=ms_filter_new_from_name (stream->display_name);
}
/* Don't allow null output */
if(stream->output == NULL) {
ms_fatal("No video display filter could be instantiated. Please check build-time configuration");
}
/* Check if the output filter can perform the decoding process */
decoding_support.mime_type = pt->mime_type;
decoding_support.supported = FALSE;
ms_filter_call_method(stream->output, MS_VIDEO_DISPLAY_SUPPORT_DECODING, &decoding_support);
stream->output_performs_decoding = decoding_support.supported;
/*plumb the incoming stream */
if (stream->output_performs_decoding == TRUE) {
stream->ms.decoder = stream->output; /* Consider the decoder is the output */
} else {
stream->ms.decoder=ms_filter_create_decoder(pt->mime_type);
if ((stream->ms.decoder==NULL) ){
/* big problem: we don't have a registered decoderfor this payload...*/
ms_error("videostream.c: No decoder available for payload %i:%s.",payload,pt->mime_type);
ms_filter_destroy(stream->output);
return -1;
}
}
ms_filter_set_notify_callback(stream->ms.decoder, event_cb, stream);
stream->ms.rtprecv = ms_filter_new (MS_RTP_RECV_ID);
ms_filter_call_method(stream->ms.rtprecv,MS_RTP_RECV_SET_SESSION,stream->ms.session);
if (stream->output_performs_decoding == FALSE) {
stream->jpegwriter=ms_filter_new(MS_JPEG_WRITER_ID);
if (stream->jpegwriter)
stream->tee2=ms_filter_new(MS_TEE_ID);
}
/* set parameters to the decoder*/
if (pt->send_fmtp){
ms_filter_call_method(stream->ms.decoder,MS_FILTER_ADD_FMTP,pt->send_fmtp);
}
if (pt->recv_fmtp!=NULL)
ms_filter_call_method(stream->ms.decoder,MS_FILTER_ADD_FMTP,(void*)pt->recv_fmtp);
/*force the decoder to output YUV420P */
format=MS_YUV420P;
ms_filter_call_method(stream->ms.decoder,MS_FILTER_SET_PIX_FMT,&format);
/*configure the display window */
if(stream->output != NULL) {
disp_size.width=MS_VIDEO_SIZE_CIF_W;
disp_size.height=MS_VIDEO_SIZE_CIF_H;
tmp=1;
ms_filter_call_method(stream->output,MS_FILTER_SET_VIDEO_SIZE,&disp_size);
ms_filter_call_method(stream->output,MS_VIDEO_DISPLAY_ENABLE_AUTOFIT,&tmp);
ms_filter_call_method(stream->output,MS_FILTER_SET_PIX_FMT,&format);
ms_filter_call_method(stream->output,MS_VIDEO_DISPLAY_SET_LOCAL_VIEW_MODE,&stream->corner);
if (stream->window_id!=0){
ms_filter_call_method(stream->output, MS_VIDEO_DISPLAY_SET_NATIVE_WINDOW_ID,&stream->window_id);
}
if (stream->display_filter_auto_rotate_enabled) {
ms_filter_call_method(stream->output,MS_VIDEO_DISPLAY_SET_DEVICE_ORIENTATION,&stream->device_orientation);
}
}
/* and connect the filters */
ms_connection_helper_start (&ch);
ms_connection_helper_link (&ch,stream->ms.rtprecv,-1,0);
if (stream->output_performs_decoding == FALSE) {
ms_connection_helper_link (&ch,stream->ms.decoder,0,0);
}
if (stream->tee2){
ms_connection_helper_link (&ch,stream->tee2,0,0);
ms_filter_link(stream->tee2,1,stream->jpegwriter,0);
}
if (stream->output!=NULL)
ms_connection_helper_link (&ch,stream->output,0,-1);
/* the video source must be send for preview , if it exists*/
if (stream->tee!=NULL && stream->output!=NULL && stream->output2==NULL)
ms_filter_link(stream->tee,1,stream->output,1);
}
if (stream->dir == VideoStreamSendOnly) {
stream->ms.rtprecv = ms_filter_new (MS_RTP_RECV_ID);
ms_filter_call_method(stream->ms.rtprecv, MS_RTP_RECV_SET_SESSION, stream->ms.session);
stream->ms.voidsink = ms_filter_new(MS_VOID_SINK_ID);
ms_filter_link(stream->ms.rtprecv, 0, stream->ms.voidsink, 0);
}
/* create the ticker */
if (stream->ms.ticker==NULL) start_ticker(&stream->ms);
stream->ms.start_time=ms_time(NULL);
stream->ms.is_beginning=TRUE;
/* attach the graphs */
if (stream->source)
ms_ticker_attach (stream->ms.ticker, stream->source);
if (stream->ms.rtprecv)
ms_ticker_attach (stream->ms.ticker, stream->ms.rtprecv);
return 0;
}
int video_mail_record_start(VideoMailRecord *vp, MSSndCard *sndcard,MSWebCam *webcam,unsigned long video_window_id,const char *filename){
MSConnectionHelper h;
MSPixFmt format=MS_YUV420P;
{
strcpy(vp->filename, filename);
vp->os = video_recoder_new();
video_recoder_init(vp->os);
video_recoder_set_vsize(vp->os,vp->vsize);
video_recoder_set_rate(vp->os,vp->rate);
video_recoder_set_audio_bit_rate(vp->os, get_bit_rate_by_samples_rate(vp->rate));
video_recoder_set_video_bit_rate(vp->os, vp->bit_rate - get_bit_rate_by_samples_rate(vp->rate));
video_recoder_set_nbchannels(vp->os,vp->nchannels);
if(video_recoder_open_file(vp->os,vp->filename)<0){
video_recoder_destory(vp->os);
vp->os=NULL;
return -1;
}
video_mail_record_set_audio_sink(vp,video_recoder_create_audio_filter(vp->os));
video_mail_record_set_video_sink(vp,video_recoder_create_video_filter(vp->os));
video_recoder_start(vp->os);
}
{
if (sndcard!=NULL) vp->snd_read=ms_snd_card_create_reader(sndcard);
if(vp->snd_read){
ms_filter_call_method(vp->snd_read,MS_FILTER_SET_NCHANNELS,&vp->nchannels);
ms_filter_call_method(vp->snd_read,MS_FILTER_SET_SAMPLE_RATE,&vp->rate);
}
}
{
if (webcam==NULL){
webcam=ms_web_cam_manager_get_default_cam (
ms_web_cam_manager_get());
}
vp->video_source = ms_web_cam_create_reader(webcam);
vp->video_tee = ms_filter_new(MS_TEE_ID);
ms_message("Setting sent vsize=%ix%i, fps=%f",vp->vsize.width,vp->vsize.height,vp->fps);
/* configure the filters */
if (ms_filter_get_id(vp->video_source)!=MS_STATIC_IMAGE_ID) {
ms_filter_call_method(vp->video_source,MS_FILTER_SET_FPS,&vp->fps);
}
ms_filter_call_method(vp->video_source,MS_FILTER_SET_VIDEO_SIZE,&vp->vsize);
ms_filter_call_method(vp->video_source,MS_FILTER_GET_PIX_FMT,&format);
if (format==MS_MJPEG){
vp->pixconv=ms_filter_new(MS_MJPEG_DEC_ID);
}else{
vp->pixconv = ms_filter_new(MS_PIX_CONV_ID);
/*set it to the pixconv */
ms_filter_call_method(vp->pixconv,MS_FILTER_SET_PIX_FMT,&format);
ms_filter_call_method(vp->video_source,MS_FILTER_GET_VIDEO_SIZE,&vp->vsize);
ms_filter_call_method(vp->pixconv,MS_FILTER_SET_VIDEO_SIZE,&vp->vsize);
}
vp->sizeconv=ms_filter_new(MS_SIZE_CONV_ID);
ms_filter_call_method(vp->sizeconv,MS_FILTER_SET_VIDEO_SIZE,&vp->vsize);
choose_display_name(vp);
vp->video_output=ms_filter_new_from_name (vp->display_name);
if (video_window_id!=0)
ms_filter_call_method(vp->video_output, MS_VIDEO_DISPLAY_SET_NATIVE_WINDOW_ID,&video_window_id);
}
if(vp->snd_read!=NULL && vp->snd_sink!=NULL){
ms_filter_link(vp->snd_read,0,vp->snd_sink,0);
}
if(vp->video_source!=NULL && vp->video_output!=NULL)
{
ms_connection_helper_start(&h);
ms_connection_helper_link(&h,vp->video_source,-1,0);
ms_connection_helper_link(&h,vp->pixconv,0,0);
ms_connection_helper_link(&h,vp->sizeconv,0,0);
ms_connection_helper_link(&h,vp->video_tee,0,0);
ms_filter_link(vp->video_tee,1,vp->video_output,0);
ms_connection_helper_link(&h,vp->video_sink,0,-1);
}
vp->ticker = ms_ticker_new();
ms_ticker_set_name(vp->ticker,"VideoMailRecord");
if(vp->snd_read!=NULL && vp->snd_sink!=NULL)
ms_ticker_attach(vp->ticker,vp->snd_read);
if(vp->video_source!=NULL && vp->video_output!=NULL)
ms_ticker_attach(vp->ticker,vp->video_source);
return 0;
}
static void soundread_filerec_fileplay_soundwrite(void) {
MSConnectionHelper h;
unsigned int filter_mask = FILTER_MASK_SOUNDREAD | FILTER_MASK_FILEREC | FILTER_MASK_FILEPLAY | FILTER_MASK_SOUNDWRITE;
int capture_sample_rate = 8000;
int playback_sample_rate = 8000;
int capture_nchannels = 1;
int playback_nchannels = 1;
char *writable_filename = bc_tester_file(SOUNDREAD_FILE_NAME);
ms_filter_reset_statistics();
ms_tester_create_ticker();
ms_tester_create_filters(filter_mask);
// Write audio capture to a file
ms_filter_call_method(ms_tester_soundread, MS_FILTER_GET_SAMPLE_RATE, &capture_sample_rate);
ms_filter_call_method(ms_tester_soundread, MS_FILTER_GET_NCHANNELS, &capture_nchannels);
ms_filter_call_method(ms_tester_filerec, MS_FILTER_SET_SAMPLE_RATE, &capture_sample_rate);
ms_filter_call_method(ms_tester_filerec, MS_FILTER_SET_NCHANNELS, &capture_nchannels);
ms_filter_call_method_noarg(ms_tester_filerec, MS_FILE_REC_CLOSE);
ms_filter_call_method(ms_tester_filerec, MS_FILE_REC_OPEN, writable_filename);
ms_filter_call_method_noarg(ms_tester_filerec, MS_FILE_REC_START);
ms_connection_helper_start(&h);
ms_connection_helper_link(&h, ms_tester_soundread, -1, 0);
ms_connection_helper_link(&h, ms_tester_filerec, 0, -1);
ms_ticker_attach(ms_tester_ticker, ms_tester_soundread);
ms_sleep(4);
ms_filter_call_method_noarg(ms_tester_filerec, MS_FILE_REC_CLOSE);
ms_ticker_detach(ms_tester_ticker, ms_tester_soundread);
ms_connection_helper_start(&h);
ms_connection_helper_unlink(&h, ms_tester_soundread, -1, 0);
ms_connection_helper_unlink(&h, ms_tester_filerec, 0, -1);
// Read the previous file and play it
ms_filter_call_method(ms_tester_soundwrite, MS_FILTER_GET_SAMPLE_RATE, &playback_sample_rate);
ms_filter_call_method(ms_tester_soundwrite, MS_FILTER_GET_NCHANNELS, &playback_nchannels);
if ((capture_sample_rate != playback_sample_rate) || (capture_nchannels != playback_nchannels)) {
ms_tester_create_filter(&ms_tester_resampler, MS_RESAMPLE_ID);
}
ms_filter_call_method_noarg(ms_tester_fileplay, MS_FILE_PLAYER_CLOSE);
ms_filter_call_method(ms_tester_fileplay, MS_FILE_PLAYER_OPEN, writable_filename);
ms_filter_call_method_noarg(ms_tester_fileplay, MS_FILE_PLAYER_START);
ms_connection_helper_start(&h);
ms_connection_helper_link(&h, ms_tester_fileplay, -1, 0);
if (ms_tester_resampler != NULL) {
ms_connection_helper_link(&h, ms_tester_resampler, 0, 0);
ms_filter_call_method(ms_tester_resampler, MS_FILTER_SET_SAMPLE_RATE, &capture_sample_rate);
ms_filter_call_method(ms_tester_resampler, MS_FILTER_SET_OUTPUT_SAMPLE_RATE, &playback_sample_rate);
ms_filter_call_method(ms_tester_resampler, MS_FILTER_SET_NCHANNELS, &capture_nchannels);
ms_filter_call_method(ms_tester_resampler, MS_FILTER_SET_OUTPUT_NCHANNELS, &capture_nchannels);
}
ms_connection_helper_link(&h, ms_tester_soundwrite, 0, -1);
ms_ticker_attach(ms_tester_ticker, ms_tester_fileplay);
ms_sleep(4);
ms_filter_call_method_noarg(ms_tester_fileplay, MS_FILE_PLAYER_CLOSE);
ms_ticker_detach(ms_tester_ticker, ms_tester_fileplay);
ms_connection_helper_start(&h);
ms_connection_helper_unlink(&h, ms_tester_fileplay, -1, 0);
if (ms_tester_resampler != NULL) {
ms_connection_helper_unlink(&h, ms_tester_resampler, 0, 0);
}
ms_connection_helper_unlink(&h, ms_tester_soundwrite, 0, -1);
ms_filter_log_statistics();
ms_tester_destroy_filters(filter_mask);
ms_tester_destroy_ticker();
unlink(writable_filename);
free(writable_filename);
}