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(); }
void audio_stream_record_stop(AudioStream *st) { if (st->filewriter != NULL && ms_filter_get_id(st->filewriter)==MS_FILE_REC_ID){ ms_filter_call_method_noarg(st->filewriter,MS_FILE_REC_STOP); ms_filter_call_method_noarg(st->filewriter,MS_FILE_REC_CLOSE); }else{ ms_error("Cannot stop record !"); } }
void audio_stream_record_start(AudioStream *st, const char *filename){ if (st->filewriter != NULL && ms_filter_get_id(st->filewriter)==MS_FILE_REC_ID){ ms_filter_call_method_noarg(st->filewriter,MS_FILE_REC_CLOSE); ms_filter_call_method(st->filewriter,MS_FILE_REC_OPEN,(void*)filename); ms_filter_call_method_noarg(st->filewriter,MS_FILE_REC_START); }else{ ms_error("Cannot record file: no st->filewriter Filter !"); } }
int audio_stream_mixed_record_stop(AudioStream *st){ if (st->recorder && st->recorder_file){ int pin=1; ms_filter_call_method_noarg(st->recorder,MS_RECORDER_PAUSE); ms_filter_call_method(st->recv_tee,MS_TEE_MUTE,&pin); ms_filter_call_method(st->send_tee,MS_TEE_MUTE,&pin); ms_filter_call_method_noarg(st->recorder,MS_RECORDER_CLOSE); } return 0; }
void audio_stream_play(AudioStream *st, const char *name){ if (ms_filter_get_id(st->soundread)==MS_FILE_PLAYER_ID){ ms_filter_call_method_noarg(st->soundread,MS_FILE_PLAYER_CLOSE); ms_filter_call_method(st->soundread,MS_FILE_PLAYER_OPEN,(void*)name); ms_filter_call_method_noarg(st->soundread,MS_FILE_PLAYER_START); }else{ ms_error("Cannot play file: the stream hasn't been started with" " audio_stream_start_with_files"); } }
void video_stream_play_file_stop(VideoStream *st) { if (ms_filter_get_id(st->source)==MS_VIDEO_FILE_PLAYER_ID){ ms_filter_call_method_noarg(st->source,MS_VIDEO_FILE_PLAYER_STOP); ms_filter_call_method_noarg(st->source,MS_VIDEO_FILE_PLAYER_CLOSE); }else{ ms_error("Cannot play file: the stream hasn't been started with" " video_stream_play"); } }
void audio_stream_record(AudioStream *st, const char *name){ if (ms_filter_get_id(st->soundwrite)==MS_FILE_REC_ID){ ms_filter_call_method_noarg(st->soundwrite,MS_FILE_REC_CLOSE); ms_filter_call_method(st->soundwrite,MS_FILE_REC_OPEN,(void*)name); ms_filter_call_method_noarg(st->soundwrite,MS_FILE_REC_START); }else{ ms_error("Cannot record file: the stream hasn't been started with" " audio_stream_start_with_files"); } }
void video_stream_play_file(VideoStream *st, const char *name) { if (ms_filter_get_id(st->source)==MS_VIDEO_FILE_PLAYER_ID){ ms_filter_call_method_noarg(st->source,MS_VIDEO_FILE_PLAYER_CLOSE); ms_filter_call_method(st->source,MS_VIDEO_FILE_PLAYER_OPEN,(void*)name); ms_filter_call_method_noarg(st->source,MS_VIDEO_FILE_PLAYER_START); }else{ ms_error("Cannot play file: the stream hasn't been started with" " video_stream_play"); } }
void linphone_conference_play_audio_stop(struct _LinphoneCore *lc, LinphoneConference *conf){ LinphoneConferenceStream *conf_stream = conf->conf_stream; if(conf==NULL && conf_stream==NULL) return; if (conf_stream->audio_fileplayer != NULL && ms_filter_get_id(conf_stream->audio_fileplayer)==MS_FILE_PLAYER_ID){ ms_filter_call_method_noarg(conf_stream->audio_fileplayer,MS_FILE_PLAYER_STOP); ms_filter_call_method_noarg(conf_stream->audio_fileplayer,MS_FILE_PLAYER_CLOSE); }else{ ms_error("Cannot record file: not inited conf->audio_fileplayer Filter !"); } }
void linphone_conference_record_audio_stop(struct _LinphoneCore *lc, LinphoneConference *conf){ LinphoneConferenceStream *conf_stream = conf->conf_stream; if(conf==NULL && conf_stream==NULL) return; if (conf_stream->audio_filerecorder != NULL && ms_filter_get_id(conf_stream->audio_filerecorder)==MS_FILE_REC_ID){ ms_filter_call_method_noarg(conf_stream->audio_filerecorder,MS_FILE_REC_STOP); ms_filter_call_method_noarg(conf_stream->audio_filerecorder,MS_FILE_REC_CLOSE); }else{ ms_error("Cannot stop conference record !"); } }
//录制当前会议 void linphone_conference_record_audio(struct _LinphoneCore *lc, LinphoneConference *conf, const char *filename){ LinphoneConferenceStream *conf_stream = conf->conf_stream; if(conf==NULL && conf_stream==NULL) return; if (conf_stream->audio_filerecorder != NULL && ms_filter_get_id(conf_stream->audio_filerecorder)==MS_FILE_REC_ID){ ms_filter_call_method_noarg(conf_stream->audio_filerecorder,MS_FILE_REC_CLOSE); ms_filter_call_method(conf_stream->audio_filerecorder,MS_FILE_REC_OPEN,(void*)filename); ms_filter_call_method_noarg(conf_stream->audio_filerecorder,MS_FILE_REC_START); }else{ ms_error("Cannot record file: not conf->audio_filerecorder st->filewrite Filter !"); } }
int ms_audio_recorder_endpoint_start(MSAudioEndpoint *ep, const char *path){ int err; MSRecorderState state; if (!ep->recorder){ ms_error("This endpoint isn't a recorder endpoint."); return -1; } ms_filter_call_method(ep->recorder,MS_RECORDER_GET_STATE,&state); if (state!=MSRecorderClosed) ms_filter_call_method_noarg(ep->recorder,MS_RECORDER_CLOSE); err=ms_filter_call_method(ep->recorder,MS_RECORDER_OPEN,(void*)path); if (err==-1) return -1; return ms_filter_call_method_noarg(ep->recorder,MS_RECORDER_START); }
RingStream * ring_start_with_cb(const char *file,int interval,MSSndCard *sndcard, MSFilterNotifyFunc func,void * user_data) { RingStream *stream; int tmp; stream=(RingStream *)ms_new0(RingStream,1); stream->source=ms_filter_new(MS_FILE_PLAYER_ID); if (ms_filter_call_method(stream->source,MS_FILE_PLAYER_OPEN,(void*)file)<0){ ms_filter_destroy(stream->source); ms_free(stream); return NULL; } 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->sndwrite=ms_snd_card_create_writer(sndcard); ms_filter_call_method(stream->source,MS_FILTER_GET_SAMPLE_RATE,&tmp); ms_filter_call_method(stream->sndwrite,MS_FILTER_SET_SAMPLE_RATE,&tmp); ms_filter_call_method(stream->source,MS_FILTER_GET_NCHANNELS,&tmp); ms_filter_call_method(stream->sndwrite,MS_FILTER_SET_NCHANNELS,&tmp); stream->ticker=ms_ticker_new(); ms_ticker_set_name(stream->ticker,"Audio (ring) MSTicker"); ms_filter_link(stream->source,0,stream->sndwrite,0); ms_ticker_attach(stream->ticker,stream->source); return stream; }
void linphone_conference_enable_auto_layout(LinphoneConference *conf,bool_t enabled){ LinphoneConferenceStream *stream = conf->conf_stream; if(!conf || !conf->conf_stream) return; stream->auto_layout = enabled; MSList *list = stream->video_ports; int port_index =0; for(;list!=NULL;list=list->next){ ConfVideoPort* port = (ConfVideoPort*) list->data; if(stream->auto_layout){ /*自动布局模式下,关闭所有视频端口的 no signal 图片输出,0 号通道除外*/ if((port->sink_connected==FALSE && port->source_connected==FALSE) && port_index !=0 ) ms_filter_call_method(stream->video_static_image_tee,MS_TEE_MUTE,&port_index); }else{ /*如视频端口为连接call或camera,输出静态图片 0号通道除外*/ if((port->sink_connected==FALSE && port->source_connected==FALSE) && port_index !=0 ) ms_filter_call_method(stream->video_static_image_tee,MS_TEE_UNMUTE,&port_index); } port_index++; } /*请求视频Mixer刷新布局*/ ms_filter_call_method_noarg(stream->video_mixer,MS_FILTER_REQ_VFU); linphone_conference_send_vfu(conf); }
void ms_media_player_stop(MSMediaPlayer *obj) { int seek_pos = 0; if(obj->is_open) { ms_filter_call_method_noarg(obj->player, MS_PLAYER_PAUSE); ms_filter_call_method(obj->player, MS_PLAYER_SEEK_MS, &seek_pos); } }
int linphone_conference_remove_local_webcam(LinphoneConference *conf, ConfWebCam *localcam) { if(conf==NULL || localcam==NULL) return -1; ConfVideoPort *video_port = find_video_slot_at_index(conf->conf_stream,localcam->video_port_index); if(localcam->ticker && video_port) { ms_message("Remove Local Camera: conf_stream [%d] <----> local_webcam !!",video_port->index); ms_filter_call_method(video_port->video_itc_source,MS_CONF_ITC_SOURCE_CONNECT,NULL); ms_filter_call_method(localcam->itc_sink,MS_CONF_ITC_SINK_CONNECT,NULL); video_port->sink_connected = FALSE; video_port->source_connected = FALSE; localcam->video_port_index = -1; int tmp = video_port->index; if(conf->conf_stream->auto_layout)//自动布局模式下只开启 0 号端口的静态图片 { if(tmp==0) ms_filter_call_method(conf->conf_stream->video_static_image_tee,MS_TEE_UNMUTE,&tmp); }else{ ms_filter_call_method(conf->conf_stream->video_static_image_tee,MS_TEE_UNMUTE,&tmp); } ms_filter_call_method_noarg(conf->conf_stream->video_mixer,MS_FILTER_REQ_VFU); } }
int lsd_player_play(LsdPlayer *b, const char *filename ){ int state; ms_filter_call_method(b->player,MS_PLAYER_GET_STATE,&state); if (state!=MSPlayerClosed){ ms_filter_call_method_noarg(b->player,MS_PLAYER_CLOSE); } if (ms_filter_call_method(b->player,MS_PLAYER_OPEN,(void*)filename)!=0){ ms_warning("Could not play %s",filename); return -1; } ms_filter_set_notify_callback (b->player,lsd_player_on_eop,b); lsd_player_configure(b); ms_filter_call_method_noarg (b->player,MS_PLAYER_START); return 0; }
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; }
void ms_media_player_close(MSMediaPlayer *obj) { if(obj->is_open) { ms_ticker_detach(obj->ticker, obj->player); ms_filter_call_method_noarg(obj->player, MS_PLAYER_CLOSE); _unlink_all(obj); _destroy_graph(obj); obj->is_open = FALSE; ms_free(obj->filename); obj->filename = NULL; } }
// Pass NULL to stop playing void audio_stream_play(AudioStream *st, const char *name){ if (st->soundread == NULL) { ms_warning("Cannot play file: the stream hasn't been started"); return; } if (ms_filter_get_id(st->soundread)==MS_FILE_PLAYER_ID){ ms_filter_call_method_noarg(st->soundread,MS_FILE_PLAYER_CLOSE); if (name != NULL) { ms_filter_call_method(st->soundread,MS_FILE_PLAYER_OPEN,(void*)name); if (st->read_resampler){ audio_stream_configure_resampler(st->read_resampler,st->soundread,st->ms.rtpsend); } ms_filter_call_method_noarg(st->soundread,MS_FILE_PLAYER_START); } }else{ ms_error("Cannot play file: the stream hasn't been started with" " audio_stream_start_with_files"); } }
bool_t ms_media_player_start(MSMediaPlayer *obj) { if(!obj->is_open) { ms_error("Cannot start playing. No file has been opened"); return FALSE; } if(ms_filter_call_method_noarg(obj->player, MS_PLAYER_START) == -1) { ms_error("Could not play %s. Playing filter failed to start", obj->filename); return FALSE; } return TRUE; }
void video_stream_iterate(VideoStream *stream){ if (stream->output!=NULL) ms_filter_call_method_noarg(stream->output, MS_VIDEO_OUT_HANDLE_RESIZING); if (stream->evq){ OrtpEvent *ev=ortp_ev_queue_get(stream->evq); if (ev!=NULL){ if (ortp_event_get_type(ev)==ORTP_EVENT_RTCP_PACKET_RECEIVED){ OrtpEventData *evd=ortp_event_get_data(ev); video_steam_process_rtcp(stream,evd->packet); } ortp_event_destroy(ev); } } }
int audio_stream_mixed_record_start(AudioStream *st){ if (st->recorder && st->recorder_file){ int pin=1; MSRecorderState state; ms_filter_call_method(st->recorder,MS_RECORDER_GET_STATE,&state); if (state==MSRecorderClosed){ if (ms_filter_call_method(st->recorder,MS_RECORDER_OPEN,st->recorder_file)==-1) return -1; } ms_filter_call_method_noarg(st->recorder,MS_RECORDER_START); ms_filter_call_method(st->recv_tee,MS_TEE_UNMUTE,&pin); ms_filter_call_method(st->send_tee,MS_TEE_UNMUTE,&pin); return 0; } return -1; }
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 int uninit_bench(struct bench_config *bench) { MSList *it; for(it=bench->tsessions;it!=NULL;it=bench->tsessions){ struct test_session *ts = (struct test_session *)it->data; bench->tsessions = ms_list_remove_link(bench->tsessions, it); ms_ticker_detach(bench->ticker,ts->fplayer); ms_ticker_detach(bench->ticker,ts->rtprecv); ms_filter_call_method_noarg(ts->frecorder,MS_FILE_REC_CLOSE); if (strstr(bench->wavfile, ".au")==NULL) { ms_filter_unlink(ts->fplayer,0,ts->encoder,0); ms_filter_unlink(ts->encoder,0,ts->rtpsend,0); } else { ms_filter_unlink(ts->fplayer,0,ts->rtpsend,0); } ms_filter_unlink(ts->rtprecv,0,ts->decoder,0); ms_filter_unlink(ts->decoder,0,ts->frecorder,0); if (ts->fplayer) ms_filter_destroy(ts->fplayer); if (ts->encoder) ms_filter_destroy(ts->encoder); if (ts->rtpsend) ms_filter_destroy(ts->rtpsend); if (ts->rtprecv) ms_filter_destroy(ts->rtprecv); if (ts->decoder) ms_filter_destroy(ts->decoder); if (ts->frecorder) ms_filter_destroy(ts->frecorder); ortp_free(ts); } ms_ticker_destroy(bench->ticker); return 0; }
static int call_player_pause(LinphonePlayer *player){ LinphoneCall *call=(LinphoneCall*)player->impl; if (!call_player_check_state(player,TRUE)) return -1; return ms_filter_call_method_noarg(call->audiostream->av_player.player,MS_PLAYER_PAUSE); }
int main(int argc, char *argv[]){ MSFilter *src, *gen, *det, *rec; MSTicker *ticker; ms_base_init(); ortp_set_log_level_mask (ORTP_MESSAGE|ORTP_WARNING|ORTP_ERROR|ORTP_FATAL); src=ms_filter_new(MS_FILE_PLAYER_ID); rec=ms_filter_new(MS_FILE_REC_ID); gen=ms_filter_new(MS_DTMF_GEN_ID); det=ms_filter_new(MS_TONE_DETECTOR_ID); ms_filter_link(src,0,gen,0); ms_filter_link(gen,0,det,0); //ms_filter_link(gen,0,rec,0); ms_filter_link(det,0,rec,0); ticker=ms_ticker_new(); ms_ticker_attach(ticker,src); ms_filter_call_method(rec,MS_FILE_REC_OPEN,"/tmp/output.wav"); ms_filter_call_method_noarg(rec,MS_FILE_REC_START); { /*generate and detect the tones*/ MSDtmfGenCustomTone tone; MSToneDetectorDef expected_tone; char dtmf='*'; tone.frequency=2000; tone.duration=400; tone.amplitude=0.6; expected_tone.frequency=2000; expected_tone.min_duration=200; expected_tone.min_amplitude=0.5; ms_filter_set_notify_callback(det,(MSFilterNotifyFunc)tone_detected_cb,NULL); ms_filter_set_notify_callback(gen,(MSFilterNotifyFunc)tone_sent_cb,NULL); ms_filter_call_method(det,MS_TONE_DETECTOR_ADD_SCAN,&expected_tone); ms_filter_call_method(gen,MS_DTMF_GEN_PLAY,&dtmf); ms_sleep(1); ms_filter_call_method(gen,MS_DTMF_GEN_PLAY_CUSTOM,&tone); ms_sleep(1); ms_filter_call_method(gen,MS_DTMF_GEN_PLAY_CUSTOM,&tone); ms_sleep(1); ms_filter_call_method(gen,MS_DTMF_GEN_PLAY_CUSTOM,&tone); ms_sleep(1); tone.frequency=1500; tone.amplitude=1.0; ms_filter_call_method(gen,MS_DTMF_GEN_PLAY_CUSTOM,&tone); ms_sleep(1); } ms_filter_call_method_noarg(rec,MS_FILE_REC_CLOSE); ms_ticker_detach(ticker,src); ms_filter_unlink(src,0,gen,0); ms_filter_unlink(gen,0,det,0); //ms_filter_unlink(gen,0,rec,0); ms_filter_unlink(det,0,rec,0); ms_ticker_destroy(ticker); ms_filter_destroy(src); ms_filter_destroy(gen); ms_filter_destroy(det); ms_filter_destroy(rec); ms_base_exit(); return 0; }
void video_stream_send_vfu(VideoStream *stream){ if (stream->ms.encoder) ms_filter_call_method_noarg(stream->ms.encoder, MS_VIDEO_ENCODER_REQ_VFU); }
int ms_audio_recorder_endpoint_stop(MSAudioEndpoint *ep){ if (!ep->recorder){ return -1; } return ms_filter_call_method_noarg(ep->recorder,MS_RECORDER_CLOSE); }
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); }