int main(int argc, char *argv[]){
MSFilter *f1,*f2;
MSSndCard *card;
MSTicker *ticker;
char *card_id=NULL;
ms_init();
signal(SIGINT,stop);
if (argc>1)
card_id=argv[1];
if (card_id!=NULL)
card=ms_snd_card_manager_get_card(ms_snd_card_manager_get(),card_id);
else card=ms_snd_card_manager_get_default_card(ms_snd_card_manager_get());
if (card==NULL){
ms_error("No card.");
return -1;
}
f1=ms_snd_card_create_reader(card);
f2=ms_snd_card_create_writer(card);
ticker=ms_ticker_new();
ms_filter_link(f1,0,f2,0);
ms_ticker_attach(ticker,f1);
while(run)
sleep(1);
ms_ticker_detach(ticker,f1);
ms_ticker_destroy(ticker);
ms_filter_unlink(f1,0,f2,0);
ms_filter_destroy(f1);
ms_filter_destroy(f2);
return 0;
}
void ms_tester_create_filters(unsigned int filter_mask) {
MSSndCardManager *snd_manager;
MSWebCamManager *cam_manager;
MSSndCard *playcard;
MSSndCard *captcard;
MSWebCam *camera;
CREATE_FILTER(FILTER_MASK_FILEPLAY, ms_tester_fileplay, MS_FILE_PLAYER_ID);
CREATE_FILTER(FILTER_MASK_FILEREC, ms_tester_filerec, MS_FILE_REC_ID);
CREATE_FILTER(FILTER_MASK_DTMFGEN, ms_tester_dtmfgen, MS_DTMF_GEN_ID);
CREATE_FILTER(FILTER_MASK_TONEDET, ms_tester_tonedet, MS_TONE_DETECTOR_ID);
CREATE_FILTER(FILTER_MASK_VOIDSOURCE, ms_tester_voidsource, MS_VOID_SOURCE_ID);
CREATE_FILTER(FILTER_MASK_VOIDSINK, ms_tester_voidsink, MS_VOID_SINK_ID);
if (filter_mask & FILTER_MASK_ENCODER) {
CU_ASSERT_PTR_NULL(ms_tester_encoder);
ms_tester_encoder = ms_filter_create_encoder(ms_tester_codec_mime);
CU_ASSERT_PTR_NOT_NULL_FATAL(ms_tester_encoder);
}
if (filter_mask & FILTER_MASK_DECODER) {
CU_ASSERT_PTR_NULL(ms_tester_decoder);
ms_tester_decoder = ms_filter_create_decoder(ms_tester_codec_mime);
CU_ASSERT_PTR_NOT_NULL_FATAL(ms_tester_decoder);
}
CREATE_FILTER(FILTER_MASK_RTPRECV, ms_tester_rtprecv, MS_RTP_RECV_ID);
CREATE_FILTER(FILTER_MASK_RTPSEND, ms_tester_rtpsend, MS_RTP_SEND_ID);
CREATE_FILTER(FILTER_MASK_RESAMPLER, ms_tester_resampler, MS_RESAMPLE_ID);
if (filter_mask & FILTER_MASK_SOUNDWRITE) {
CU_ASSERT_PTR_NULL(ms_tester_soundwrite);
snd_manager = ms_snd_card_manager_get();
playcard = ms_snd_card_manager_get_default_playback_card(snd_manager);
CU_ASSERT_PTR_NOT_NULL_FATAL(playcard);
ms_tester_soundwrite = ms_snd_card_create_writer(playcard);
CU_ASSERT_PTR_NOT_NULL_FATAL(ms_tester_soundwrite);
}
if (filter_mask & FILTER_MASK_SOUNDREAD) {
CU_ASSERT_PTR_NULL(ms_tester_soundread);
snd_manager = ms_snd_card_manager_get();
captcard = ms_snd_card_manager_get_default_capture_card(snd_manager);
CU_ASSERT_PTR_NOT_NULL_FATAL(captcard);
ms_tester_soundread = ms_snd_card_create_reader(captcard);
CU_ASSERT_PTR_NOT_NULL_FATAL(ms_tester_soundread);
}
if (filter_mask & FILTER_MASK_VIDEOCAPTURE) {
CU_ASSERT_PTR_NULL(ms_tester_videocapture);
cam_manager = ms_web_cam_manager_get();
camera = ms_web_cam_manager_get_default_cam(cam_manager);
CU_ASSERT_PTR_NOT_NULL_FATAL(camera);
ms_tester_videocapture = ms_web_cam_create_reader(camera);
CU_ASSERT_PTR_NOT_NULL_FATAL(ms_tester_videocapture);
}
}
AudioStream * audio_stream_start(RtpProfile *prof,int locport,const char *remip,int remport,int profile,int jitt_comp,bool_t use_ec)
{
MSSndCard *sndcard_playback;
MSSndCard *sndcard_capture;
AudioStream *stream;
sndcard_capture=ms_snd_card_manager_get_default_capture_card(ms_snd_card_manager_get());
sndcard_playback=ms_snd_card_manager_get_default_playback_card(ms_snd_card_manager_get());
if (sndcard_capture==NULL || sndcard_playback==NULL)
return NULL;
stream=audio_stream_new(locport, locport+1, ms_is_ipv6(remip));
if (audio_stream_start_full(stream,prof,remip,remport,remip,remport+1,profile,jitt_comp,NULL,NULL,sndcard_playback,sndcard_capture,use_ec)==0) return stream;
audio_stream_free(stream);
return NULL;
}
static void play_file(const char *filepath, bool_t unsupported_format, bool_t seeking_test, bool_t play_twice) {
bool_t succeed;
Eof eof;
MSMediaPlayer *file_player = NULL;
MSSndCard *snd_card = ms_snd_card_manager_get_default_playback_card(ms_snd_card_manager_get());
const char *display_name = video_stream_get_default_video_renderer();
int duration, timeout;
const int seek_time = 6100;
const double timeout_prec = 0.05;
eof_init(&eof);
BC_ASSERT_PTR_NOT_NULL(snd_card);
file_player = ms_media_player_new(snd_card, display_name, 0);
BC_ASSERT_PTR_NOT_NULL(file_player);
if(file_player == NULL) return;
BC_ASSERT_EQUAL(ms_media_player_get_state(file_player), MSPlayerClosed, int, "%d");
ms_media_player_set_eof_callback(file_player, eof_callback, &eof);
succeed = ms_media_player_open(file_player, filepath);
if(unsupported_format) {
BC_ASSERT_FALSE(succeed);
BC_ASSERT_EQUAL(ms_media_player_get_state(file_player), MSPlayerClosed, int, "%d");
} else {
int main(int argc, char *argv[]){
RingStream *r;
const char *file;
MSSndCard *sc;
const char * card_id=NULL;
ortp_init();
ortp_set_log_level_mask(ORTP_MESSAGE|ORTP_WARNING|ORTP_ERROR|ORTP_FATAL);
ms_init();
if (argc>1){
file=argv[1];
}else file="/usr/share/sounds/linphone/rings/oldphone.wav";
if (argc>2){
card_id=argv[2];
}
sc=ms_snd_card_manager_get_card(ms_snd_card_manager_get(),card_id);
#ifdef __linux
if (sc==NULL)
sc = ms_alsa_card_new_custom(card_id, card_id);
#endif
r=ring_start(file,2000,sc);
ms_sleep(10);
ring_stop(r);
return 0;
}
static void prepare(GtkAssistant *w){
AudioStream *audio_stream = NULL;
LinphoneCore *lc=linphone_gtk_get_core();
int page = gtk_assistant_get_current_page(w);
GtkWidget *mic_audiolevel = get_widget_from_assistant("mic_audiolevel");
GtkWidget *label_audiolevel = get_widget_from_assistant("label_audiolevel");
//Speaker page
if(page == 1){
MSSndCardManager *manager = ms_snd_card_manager_get();
audio_stream = audio_stream_start_with_sndcards(&av_profile,9898,"127.0.0.1",19898,0,0,ms_snd_card_manager_get_card(manager,linphone_core_get_playback_device(lc)),ms_snd_card_manager_get_card(manager,linphone_core_get_capture_device(lc)),FALSE);
if (mic_audiolevel != NULL && audio_stream != NULL){
g_object_set_data(G_OBJECT(audio_assistant),"stream",audio_stream);
linphone_gtk_init_audio_meter(mic_audiolevel,(get_volume_t)audio_stream_get_record_volume,audio_stream);
linphone_gtk_init_audio_label(label_audiolevel,(get_volume_t)audio_stream_get_max_volume,audio_stream);
}
} else if(page == 2 || page == 0){
if(mic_audiolevel != NULL && label_audiolevel != NULL){
audio_stream = (AudioStream *)g_object_get_data(G_OBJECT(audio_assistant),"stream");
if(audio_stream != NULL){
linphone_gtk_uninit_audio_meter(mic_audiolevel);
linphone_gtk_uninit_audio_label(label_audiolevel);
audio_stream_stop(audio_stream);
g_object_set_data(G_OBJECT(audio_assistant),"stream",NULL);
}
}
}
}
void ms_init(){
int i;
MSSndCardManager *cm;
#if !defined(_WIN32_WCE)
if (getenv("MEDIASTREAMER_DEBUG")!=NULL){
ortp_set_log_level_mask(ORTP_DEBUG|ORTP_MESSAGE|ORTP_WARNING|ORTP_ERROR|ORTP_FATAL);
}
#endif
ms_message("Registering all filters...");
/* register builtin MSFilter's */
for (i=0;ms_filter_descs[i]!=NULL;i++){
ms_filter_register(ms_filter_descs[i]);
}
ms_message("Registering all soundcard handlers");
cm=ms_snd_card_manager_get();
for (i=0;ms_snd_card_descs[i]!=NULL;i++){
ms_snd_card_manager_register_desc(cm,ms_snd_card_descs[i]);
}
#ifdef VIDEO_ENABLED
ms_message("Registering all webcam handlers");
{
MSWebCamManager *wm;
wm=ms_web_cam_manager_get();
for (i=0;ms_web_cam_descs[i]!=NULL;i++){
ms_web_cam_manager_register_desc(wm,ms_web_cam_descs[i]);
}
}
__register_ffmpeg_encoders_if_possible();
#endif
ms_message("Loading plugins");
ms_load_plugins(PACKAGE_PLUGINS_DIR);
ms_message("ms_init() done");
}
void linphone_gtk_start_record_sound(GtkWidget *w, gpointer data){
LinphoneCore *lc = linphone_gtk_get_core();
AudioStream *stream = NULL;
MSSndCardManager *manager = ms_snd_card_manager_get();
gboolean active=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w));
if(active){
gchar *path = get_record_file();
stream=audio_stream_new(8888, 8889, FALSE);
if(stream != NULL){
audio_stream_start_full(stream,&av_profile,"127.0.0.1",8888,"127.0.0.1",8889,0,0,NULL,
path,NULL,ms_snd_card_manager_get_card(manager,linphone_core_get_capture_device(lc)),FALSE);
g_object_set_data(G_OBJECT(audio_assistant),"record_stream",stream);
}
gint timeout_id = gtk_timeout_add(6000,(GtkFunction)linphone_gtk_stop_record,NULL);
g_object_set_data(G_OBJECT(audio_assistant),"timeout_id",GINT_TO_POINTER(timeout_id));
g_object_set_data(G_OBJECT(audio_assistant),"path",path);
} else {
stream = (AudioStream *)g_object_get_data(G_OBJECT(audio_assistant),"record_stream");
gint timeout_id = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(audio_assistant),"timeout_id"));
gtk_timeout_remove(timeout_id);
if(stream != NULL){
audio_stream_stop(stream);
g_object_set_data(G_OBJECT(audio_assistant),"record_stream",NULL);
}
update_record_button(FALSE);
update_play_button(TRUE);
}
}
LinphoneSoundDaemon * linphone_sound_daemon_new(const char *cardname, int rate, int nchannels){
int i;
MSConnectionPoint mp;
LinphoneSoundDaemon *lsd;
MSSndCard *card=ms_snd_card_manager_get_card(
ms_snd_card_manager_get(),
cardname);
if (card==NULL){
card=ms_snd_card_manager_get_default_playback_card (
ms_snd_card_manager_get());
if (card==NULL){
ms_error("linphone_sound_daemon_new(): No playback soundcard available");
return NULL;
}
}
lsd=ms_new0(LinphoneSoundDaemon,1);
lsd->soundout=ms_snd_card_create_writer(card);
lsd->mixer=ms_filter_new(MS_AUDIO_MIXER_ID);
lsd->out_rate=rate;
lsd->out_nchans=nchannels;
ms_filter_call_method(lsd->soundout,MS_FILTER_SET_SAMPLE_RATE,&lsd->out_rate);
ms_filter_call_method(lsd->soundout,MS_FILTER_SET_NCHANNELS,&lsd->out_nchans);
ms_filter_call_method(lsd->mixer,MS_FILTER_SET_SAMPLE_RATE,&lsd->out_rate);
ms_filter_call_method(lsd->mixer,MS_FILTER_SET_NCHANNELS,&lsd->out_nchans);
mp.filter=lsd->mixer;
mp.pin=0;
lsd_player_init(&lsd->branches[0],mp,MS_ITC_SOURCE_ID,lsd);
ms_filter_set_notify_callback(lsd->branches[0].player,(MSFilterNotifyFunc)lsd_player_configure,&lsd->branches[0]);
ms_filter_enable_synchronous_notifcations (lsd->branches[0].player,TRUE);
for(i=1;i<MAX_BRANCHES;++i){
mp.pin=i;
lsd_player_init(&lsd->branches[i],mp,MS_FILE_PLAYER_ID,lsd);
}
ms_filter_link(lsd->mixer,0,lsd->soundout,0);
lsd->ticker=ms_ticker_new();
ms_ticker_attach(lsd->ticker,lsd->soundout);
lsd->proxycard=ms_snd_card_new(&proxycard);
lsd->proxycard->data=lsd;
ms_message("LinphoneSoundDaemon started with rate=%i, nchannels=%i",rate,nchannels);
return lsd;
}
void ms_factory_init_voip(MSFactory *obj) {
MSSndCardManager *cm;
int i;
/* register builtin VoIP MSFilter's */
for (i=0; ms_voip_filter_descs[i]!=NULL; i++) {
ms_factory_register_filter(obj,ms_voip_filter_descs[i]);
}
if (managers_ref==0) {
managers_ref++;
cm=ms_snd_card_manager_get();
if (cm->descs==NULL) {
ms_message("Registering all soundcard handlers");
for (i=0; ms_snd_card_descs[i]!=NULL; i++) {
ms_snd_card_manager_register_desc(cm,ms_snd_card_descs[i]);
}
}
#ifdef VIDEO_ENABLED
{
MSWebCamManager *wm;
wm=ms_web_cam_manager_get();
if (wm->descs==NULL) {
ms_message("Registering all webcam handlers");
for (i=0; ms_web_cam_descs[i]!=NULL; i++) {
ms_web_cam_manager_register_desc(wm,ms_web_cam_descs[i]);
}
}
}
#endif
}
#ifdef VIDEO_ENABLED
{
MSVideoPresetsManager *vpm = ms_video_presets_manager_new(obj);
register_video_preset_high_fps(vpm);
}
#endif
#if defined(VIDEO_ENABLED) && defined(MS2_FILTERS) && !defined(NO_FFMPEG) && defined(HAVE_LIBAVCODEC_AVCODEC_H)
ms_ffmpeg_check_init();
__register_ffmpeg_encoders_if_possible(obj);
#endif
#if defined(ANDROID) && defined (VIDEO_ENABLED)
if (1) {
libmsandroidopengldisplay_init(obj);
} else {
if (!libmsandroiddisplay_init(obj)) {
libmsandroiddisplaybad_init(obj);
}
}
#endif
obj->voip_initd=TRUE;
ms_message("ms_factory_init_voip() done");
}
static void play_file(const char *filepath, bool_t unsupported_format, bool_t seeking_test, bool_t play_twice, int timeout) {
bool_t succeed;
Eof eof;
MSMediaPlayer *file_player = NULL;
MSSndCard *snd_card = ms_snd_card_manager_get_default_card(ms_snd_card_manager_get());
const char *display_name = video_stream_get_default_video_renderer();
eof_init(&eof);
file_player = ms_media_player_new(snd_card, display_name, NULL);
CU_ASSERT_PTR_NOT_NULL(file_player);
if(file_player == NULL) return;
CU_ASSERT_EQUAL(ms_media_player_get_state(file_player), MSPlayerClosed);
ms_media_player_set_eof_callback(file_player, eof_callback, &eof);
succeed = ms_media_player_open(file_player, filepath);
if(unsupported_format) {
CU_ASSERT_FALSE(succeed);
CU_ASSERT_EQUAL(ms_media_player_get_state(file_player), MSPlayerClosed);
} else {
CU_ASSERT_TRUE(succeed);
CU_ASSERT_EQUAL(ms_media_player_get_state(file_player), MSPlayerPaused);
}
if(!succeed) {
ms_media_player_free(file_player);
return;
}
succeed = ms_media_player_start(file_player);
CU_ASSERT_TRUE(succeed);
CU_ASSERT_EQUAL(ms_media_player_get_state(file_player), MSPlayerPlaying);
if(seeking_test) {
CU_ASSERT_TRUE(ms_media_player_seek(file_player, 5000));
}
if(succeed) {
wait_for_eof(&eof, 100, timeout);
CU_ASSERT_TRUE(eof.eof);
}
ms_media_player_close(file_player);
CU_ASSERT_EQUAL(ms_media_player_get_state(file_player), MSPlayerClosed);
if(play_twice) {
eof_init(&eof);
CU_ASSERT_TRUE(ms_media_player_open(file_player, filepath));
CU_ASSERT_TRUE(ms_media_player_start(file_player));
wait_for_eof(&eof, 100, timeout);
ms_media_player_close(file_player);
CU_ASSERT_TRUE(eof.eof);
}
ms_media_player_free(file_player);
}
bool myAudioStream::init_card()
{
QSettings settings("Shadowrun Comlink","MetaLink");
QString card_id;
if (settings.contains("Audio playback card")) {
card_id = settings.value("Audio playback card").toString();
} else {
const MSList *list = ms_snd_card_manager_get_list(ms_snd_card_manager_get());
QStringList cards;
while (list != NULL) {
cards << ms_snd_card_get_string_id((MSSndCard*)list->data);
list = list->next;
}
if (cards.isEmpty()) {
QMessageBox::information(0, QObject::tr("No cards detected!"), QObject::tr("No cards detected!"));
return false;
}
bool ok;
card_id = QInputDialog::getItem(0, QObject::tr("Select playback card"),
QObject::tr("Select playback card"),
cards, 0, false, &ok);
if (!ok) {
return false;
}
settings.setValue("Audio playback card",card_id);
}
playcard = ms_snd_card_manager_get_card(ms_snd_card_manager_get(), card_id.toStdString().c_str());
if (playcard==NULL){
ms_error("No playback card found.");
return false;
} else {
ms_message("Got card: %s", ms_snd_card_get_string_id(playcard));
}
return true;
}
void ms_voip_init(){
MSSndCardManager *cm;
int i;
/* register builtin VoIP MSFilter's */
for (i=0;ms_voip_filter_descs[i]!=NULL;i++){
ms_filter_register(ms_voip_filter_descs[i]);
}
ms_message("Registering all soundcard handlers");
cm=ms_snd_card_manager_get();
for (i=0;ms_snd_card_descs[i]!=NULL;i++){
ms_snd_card_manager_register_desc(cm,ms_snd_card_descs[i]);
}
#ifdef VIDEO_ENABLED
ms_message("Registering all webcam handlers");
{
MSWebCamManager *wm;
wm=ms_web_cam_manager_get();
for (i=0;ms_web_cam_descs[i]!=NULL;i++){
ms_web_cam_manager_register_desc(wm,ms_web_cam_descs[i]);
}
}
#if defined(MS2_FILTERS) && !defined(NO_FFMPEG) && defined(HAVE_LIBAVCODEC_AVCODEC_H)
ms_ffmpeg_check_init();
__register_ffmpeg_encoders_if_possible();
#endif
#endif
#if defined(ANDROID) && defined (VIDEO_ENABLED)
if (1) {
libmsandroidopengldisplay_init();
} else {
if (!libmsandroiddisplay_init()) {
libmsandroiddisplaybad_init();
}
}
#endif
ms_message("ms_voip_init() done");
}
void linphone_gtk_start_play_record_sound(GtkWidget *w,gpointer data){
LinphoneCore *lc = linphone_gtk_get_core();
gboolean active=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w));
AudioStream *stream = NULL;
MSSndCardManager *manager = ms_snd_card_manager_get();
if(active){
gchar *path = g_object_get_data(G_OBJECT(audio_assistant),"path");
stream=audio_stream_new(8888, 8889, FALSE);
if(path != NULL){
audio_stream_start_full(stream,&av_profile,"127.0.0.1",8888,"127.0.0.1",8889,0,0,path,
NULL,ms_snd_card_manager_get_card(manager,linphone_core_get_playback_device(lc)),NULL,FALSE);
ms_filter_add_notify_callback(stream->soundread,endoffile_cb,stream,FALSE);
g_object_set_data(G_OBJECT(audio_assistant),"play_stream",stream);
}
} else {
stream = (AudioStream *)g_object_get_data(G_OBJECT(audio_assistant),"play_stream");
if(stream != NULL){
audio_stream_stop(stream);
g_object_set_data(G_OBJECT(audio_assistant),"play_stream",NULL);
}
}
}
void playback(char *filename)
{
MSFilter *f1_w,*play;
MSSndCard *card_playback1;
MSTicker *ticker1;
int i;
int done = FALSE;
struct msg_st data_w;
long int msgtype = 0;
int rate = 16000;
int nchan=2;
int msgid = msgget((key_t)1234, 0666 | IPC_CREAT);
if(msgid == -1)
{
fprintf(stderr, "msgget failed with error: %d\n", errno);
exit(-1);
}
ortp_init();
ortp_set_log_level_mask(/*ORTP_MESSAGE|ORTP_WARNING|ORTP_ERROR|*/ORTP_FATAL);
ms_init();
card_playback1 = ms_snd_card_manager_get_default_playback_card(ms_snd_card_manager_get());
if (card_playback1==NULL)
{
if(card_playback1==NULL)
ms_error("No card. card_playback");
}
else
{
ms_warning("card_playback1 %s|%s|%s|%d|%d|%d",card_playback1->name,card_playback1->id,card_playback1->desc->driver_type,
card_playback1->capabilities,card_playback1->latency,card_playback1->preferred_sample_rate);
}
play=ms_filter_new(MS_FILE_PLAYER_ID);
if(ms_filter_call_method(play,MS_FILE_PLAYER_OPEN,(void*)filename)!=0)
printf("play open file %s failed\n",filename);
ms_filter_set_notify_callback(play, fileplay_eof, &done);
f1_w=ms_snd_card_create_writer(card_playback1);
if(f1_w!=NULL&&play!=NULL)
{
ms_filter_call_method(play, MS_FILTER_GET_SAMPLE_RATE, &rate);
ms_filter_call_method(play, MS_FILTER_GET_NCHANNELS, &nchan);
if(ms_filter_call_method(f1_w, MS_FILTER_SET_SAMPLE_RATE, &rate)!=0)
printf("set sample rate f1_r failed\n");
if(ms_filter_call_method(f1_w, MS_FILTER_SET_NCHANNELS,&nchan)!=0)
printf("set sample rate record failed\n");
ms_filter_call_method_noarg(play,MS_FILE_PLAYER_START);
ticker1=ms_ticker_new();
ms_ticker_set_name(ticker1,"card1 to card2");
ms_filter_link(play,0,f1_w,0);
ms_ticker_attach(ticker1,play);
while (done != TRUE) {
ms_usleep(10000);
}
ms_filter_call_method_noarg(play, MS_FILE_PLAYER_CLOSE);
if(ticker1) ms_ticker_detach(ticker1,play);
if(f1_w&&play) ms_filter_unlink(play,0,f1_w,0);
if(ticker1) ms_ticker_destroy(ticker1);
if(f1_w) ms_filter_destroy(f1_w);
if(play) ms_filter_destroy(play);
data_w.msg_type = 2; //注意2
strcpy(data_w.text, filename);
//向队列发送数据
// if(msgsnd(msgid, (void*)&data_w, 512, IPC_NOWAIT) == -1)
// {
// fprintf(stderr, "msgsnd failed\n");
// exit(1);
// }
printf("playing finished\n");
}
}
void ms_au_register_card() {
/**
* register audio unit plugin should be move to linphone code
*/
ms_snd_card_manager_register_desc(ms_snd_card_manager_get(),&au_card_desc);
}
int main(int argc, char *argv[]){
MSFilter *f1,*f2,*g729en,*g729de;
MSSndCard *card_capture;
MSSndCard *card_playback;
MSTicker *ticker;
char *capt_card=NULL,*play_card=NULL;
int rate = 8000;
int loop = -2;
int i;
const char *name="test.wav";
#ifdef __linux
const char *alsadev=NULL;
#endif
ortp_init();
ortp_set_log_level_mask(ORTP_MESSAGE|ORTP_WARNING|ORTP_ERROR|ORTP_FATAL);
ms_init();
#ifndef _WIN32_WCE
signal(SIGINT,stop);
#endif
#ifdef __linux
alsadev=getenv("MS2_ALSADEV");
if (alsadev!=NULL){
ms_snd_card_manager_add_card(ms_snd_card_manager_get(),
ms_alsa_card_new_custom (alsadev,alsadev));
}
#endif
for(i=1;i<argc;++i){
if (strcmp(argv[i],"--help")==0){
print_usage();
}else if (strcmp(argv[i],"--card")==0){
i++;
capt_card=play_card=argv[i];
}else if (strcmp(argv[i],"--capt-card")==0){
i++;
capt_card=argv[i];
}else if (strcmp(argv[i],"--file-name")==0){
i++;
name=argv[i];
}else if (strcmp(argv[i],"--play-card")==0){
i++;
play_card=argv[i];
}
}
if (capt_card)
card_capture = ms_snd_card_manager_get_card(ms_snd_card_manager_get(),capt_card);
else card_capture = ms_snd_card_manager_get_default_capture_card(ms_snd_card_manager_get());
if (play_card)
card_playback = ms_snd_card_manager_get_card(ms_snd_card_manager_get(),play_card);
else card_playback = ms_snd_card_manager_get_default_playback_card(ms_snd_card_manager_get());
if (card_playback==NULL || card_capture==NULL){
ms_error("No card.");
return -1;
}
f1=ms_filter_new(MS_FILE_PLAYER_ID);
f2=ms_snd_card_create_writer(card_playback);
g729de=ms_filter_create_decoder("G729");
ms_filter_call_method (f1, MS_FILTER_SET_SAMPLE_RATE,
&rate);
ms_filter_call_method (f2, MS_FILTER_SET_SAMPLE_RATE,
&rate);
ms_filter_call_method(g729de, MS_FILTER_SET_SAMPLE_RATE,
&rate);
ms_filter_call_method_noarg(f1,MS_FILE_PLAYER_CLOSE);
ms_filter_call_method(f1,MS_FILE_PLAYER_OPEN,(void*)name);
ms_filter_call_method_noarg(f1,MS_FILE_PLAYER_START);
ms_filter_call_method(f1,MS_FILE_PLAYER_LOOP,&loop);
ticker=ms_ticker_new();
ms_filter_link(f1,0,g729de,0);
ms_filter_link(g729de,0,f2,0);
ms_ticker_attach(ticker,f1);
#ifndef _WIN32_WCE
while(run)
ms_sleep(1);
#else
ms_sleep(5);
#endif
ms_ticker_detach(ticker,f1);
ms_ticker_destroy(ticker);
ms_filter_unlink(g729de,0,f2,0);
ms_filter_unlink(f1,0,g729de,0);
ms_filter_destroy(f1);
ms_filter_destroy(g729de);
ms_filter_destroy(f2);
return 0;
}
static void setup_media_streams(MediastreamDatas *args)
{
MSConnectionHelper h;
MSTickerParams params = {0};
/*create the rtp session */
ortp_init();
if (args->is_verbose) {
ortp_set_log_level_mask(ORTP_DEBUG | ORTP_MESSAGE | ORTP_WARNING | ORTP_ERROR | ORTP_FATAL);
} else {
ortp_set_log_level_mask(ORTP_MESSAGE | ORTP_WARNING | ORTP_ERROR | ORTP_FATAL);
}
rtp_profile_set_payload(&av_profile, 110, &payload_type_speex_nb);
rtp_profile_set_payload(&av_profile, 111, &payload_type_speex_wb);
rtp_profile_set_payload(&av_profile, 112, &payload_type_ilbc);
rtp_profile_set_payload(&av_profile, 113, &payload_type_amr);
rtp_profile_set_payload(&av_profile, 115, &payload_type_lpc1015);
#ifdef VIDEO_ENABLED
rtp_profile_set_payload(&av_profile, 26, &payload_type_jpeg);
rtp_profile_set_payload(&av_profile, 98, &payload_type_h263_1998);
rtp_profile_set_payload(&av_profile, 97, &payload_type_theora);
rtp_profile_set_payload(&av_profile, 99, &payload_type_mp4v);
rtp_profile_set_payload(&av_profile, 100, &payload_type_x_snow);
rtp_profile_set_payload(&av_profile, 102, &payload_type_h264);
rtp_profile_set_payload(&av_profile, 103, &payload_type_vp8);
#endif
args->profile = rtp_profile_clone_full(&av_profile);
ms_init();
ms_filter_enable_statistics(TRUE);
ms_filter_reset_statistics();
signal(SIGINT, stop_handler);
if (args->pt==NULL)
args->pt = rtp_profile_get_payload(args->profile, args->payload);
if (args->pt == NULL) {
printf("Error: no payload defined with number %i.", args->payload);
exit(-1);
}
if (args->pt->type == PAYLOAD_VIDEO) {
#ifdef VIDEO_ENABLED
const char *display_name;
MSPixFmt format;
MSVideoSize disp_size;
int tmp = 1;
#if defined(HAVE_GL)
display_name = "MSGLXVideo";
#elif defined(HAVE_XV)
display_name = "MSX11Video";
#elif __APPLE__ && !defined(__ios)
display_name ="MSOSXGLDisplay";
#else
display_name = "MSVideoOut";
#endif
args->read = ms_filter_new(MS_FILE_PLAYER_ID);
args->write = ms_filter_new_from_name(display_name);
args->decoder = ms_filter_create_decoder(args->pt->mime_type);
ms_filter_call_method_noarg(args->read, MS_FILE_PLAYER_CLOSE);
ms_filter_call_method(args->read, MS_FILE_PLAYER_OPEN, args->infile);
ms_filter_call_method(args->read, MS_FILTER_SET_SAMPLE_RATE, &args->pt->clock_rate);
ms_filter_call_method_noarg(args->read, MS_FILE_PLAYER_START);
ms_filter_add_notify_callback(args->read, reader_notify_cb, NULL,FALSE);
/*force the decoder to output YUV420P */
format = MS_YUV420P;
ms_filter_call_method(args->decoder, MS_FILTER_SET_PIX_FMT, &format);
/*configure the display window */
disp_size.width = MS_VIDEO_SIZE_CIF_W;
disp_size.height = MS_VIDEO_SIZE_CIF_H;
ms_filter_call_method(args->write, MS_FILTER_SET_VIDEO_SIZE, &disp_size);
ms_filter_call_method(args->write, MS_VIDEO_DISPLAY_ENABLE_AUTOFIT, &tmp);
ms_filter_call_method(args->write, MS_FILTER_SET_PIX_FMT, &format);
params.name = "Video MSTicker";
params.prio = MS_TICKER_PRIO_REALTIME;
args->ticker = ms_ticker_new_with_params(¶ms);
ms_connection_helper_start(&h);
ms_connection_helper_link(&h, args->read, -1, 0);
ms_connection_helper_link(&h, args->decoder, 0, 0);
ms_connection_helper_link(&h, args->write, 0, -1);
ms_ticker_attach(args->ticker, args->read);
#else
printf("Error: video support not compiled.\n");
#endif
} else {
MSSndCardManager *manager = ms_snd_card_manager_get();
MSSndCard *play = args->playback_card == NULL ? ms_snd_card_manager_get_default_playback_card(manager) :
ms_snd_card_manager_get_card(manager, args->playback_card);
args->read = ms_filter_new(MS_FILE_PLAYER_ID);
args->write = ms_snd_card_create_writer(play);
args->decoder = ms_filter_create_decoder(args->pt->mime_type);
ms_filter_call_method_noarg(args->read, MS_FILE_PLAYER_CLOSE);
ms_filter_call_method(args->read, MS_FILE_PLAYER_OPEN, args->infile);
ms_filter_call_method_noarg(args->read, MS_FILE_PLAYER_START);
ms_filter_call_method(args->read, MS_FILTER_SET_SAMPLE_RATE, &args->pt->clock_rate);
ms_filter_call_method(args->decoder, MS_FILTER_SET_SAMPLE_RATE, &args->pt->clock_rate);
ms_filter_call_method(args->decoder, MS_FILTER_SET_NCHANNELS, &args->pt->channels);
ms_filter_call_method(args->write, MS_FILTER_SET_SAMPLE_RATE, &args->pt->clock_rate);
ms_filter_call_method(args->write, MS_FILTER_SET_NCHANNELS, &args->pt->channels);
params.name = "Audio MSTicker";
params.prio = MS_TICKER_PRIO_REALTIME;
args->ticker = ms_ticker_new_with_params(¶ms);
ms_connection_helper_start(&h);
ms_connection_helper_link(&h, args->read, -1, 0);
ms_connection_helper_link(&h, args->decoder, 0, 0);
ms_connection_helper_link(&h, args->write, 0, -1);
ms_ticker_attach(args->ticker, args->read);
}
}
static void play_file(const char *filename, bool_t unsupported_format, const char *audio_mime, const char *video_mime) {
LinphoneCoreManager *lc_manager;
LinphonePlayer *player;
int res, time = 0;
bool_t eof = FALSE;
lc_manager = linphone_core_manager_new("marie_rc");
CU_ASSERT_PTR_NOT_NULL(lc_manager);
if(lc_manager == NULL) return;
player = linphone_core_create_local_player(lc_manager->lc, ms_snd_card_manager_get_default_card(ms_snd_card_manager_get()), video_stream_get_default_video_renderer(), 0);
CU_ASSERT_PTR_NOT_NULL(player);
if(player == NULL) goto fail;
res = linphone_player_open(player, filename, eof_callback, &eof);
if(unsupported_format
|| (audio_mime == NULL && video_mime == NULL)
|| (video_mime == NULL && audio_mime && !ms_filter_codec_supported(audio_mime))
|| (audio_mime == NULL && video_mime && !ms_filter_codec_supported(video_mime))) {
CU_ASSERT_EQUAL(res, -1);
} else {
CU_ASSERT_EQUAL(res, 0);
}
if(res == -1) goto fail;
CU_ASSERT_EQUAL((res = linphone_player_start(player)), 0);
if(res == -1) goto fail;
CU_ASSERT_TRUE(wait_for_eof(&eof, &time, 100, 13000));
linphone_player_close(player);
fail:
if(player) linphone_player_destroy(player);
if(lc_manager) linphone_core_manager_destroy(lc_manager);
}
void rec(char *filename)
{
MSFilter *f1_r,*f1_w,*record;
MSSndCard *card_capture1;
MSSndCard *card_playback1;
MSTicker *ticker1;
struct msg_st data_w;
long int msgtype = 0;
char *capt_card1=NULL,*play_card1=NULL;
int rate = 8000;
int nchan=2;
int i;
const char *alsadev=NULL;
int msgid = msgget((key_t)1234, 0666 | IPC_CREAT);
if(msgid == -1)
{
fprintf(stderr, "msgget failed with error: %d\n", errno);
exit(-1);
}
ortp_init();
ortp_set_log_level_mask(/*ORTP_MESSAGE|ORTP_WARNING|ORTP_ERROR|*/ORTP_FATAL);
ms_init();
card_capture1 = ms_snd_card_manager_get_default_capture_card(ms_snd_card_manager_get());
card_playback1 = ms_snd_card_manager_get_default_playback_card(ms_snd_card_manager_get());
if (card_playback1==NULL || card_capture1==NULL)
{
if(card_playback1==NULL)
ms_error("No card. card_playback1 %s",capt_card1);
if(card_capture1==NULL)
ms_error("No card. card_capture1 %s",capt_card1);
//return -1;
}
else
{
ms_warning("card_playback1 %s|%s|%s|%d|%d|%d",card_playback1->name,card_playback1->id,card_playback1->desc->driver_type,
card_playback1->capabilities,card_playback1->latency,card_playback1->preferred_sample_rate);
}
record=ms_filter_new(MS_FILE_REC_ID);
if(ms_filter_call_method(record,MS_FILE_REC_OPEN,(void*)filename)!=0)
printf("record open file %s failed\n",filename);
f1_r=ms_snd_card_create_reader(card_capture1);
if(f1_r!=NULL&&record!=NULL)
{
if(ms_filter_call_method(f1_r, MS_FILTER_SET_SAMPLE_RATE, &rate)!=0)
printf("set sample rate f1_r failed\n");
if(ms_filter_call_method(record, MS_FILTER_SET_SAMPLE_RATE,&rate)!=0)
printf("set sample rate record failed\n");
if(ms_filter_call_method(f1_r, MS_FILTER_SET_NCHANNELS, &nchan)!=0)
printf("set nchan f1_r failed\n");
if(ms_filter_call_method(record, MS_FILTER_SET_NCHANNELS,&nchan)!=0)
printf("set nchan record failed\n");
ms_filter_call_method_noarg(record,MS_FILE_REC_START);
ticker1=ms_ticker_new();
ms_ticker_set_name(ticker1,"card1 to card2");
ms_filter_link(f1_r,0,record,0);
ms_ticker_attach(ticker1,f1_r);
msgtype=8;
while(1)
{
msgrcv(msgid, (void*)&data_w, sizeof(struct msg_st)-sizeof(long int), msgtype, IPC_NOWAIT);
if(data_w.id==1)
break;
ms_sleep(1);
}
ms_filter_call_method(record,MS_FILE_REC_STOP,NULL);
ms_filter_call_method(record,MS_FILE_REC_CLOSE,NULL);
if(ticker1) ms_ticker_detach(ticker1,f1_r);
if(f1_r&&record) ms_filter_unlink(f1_r,0,record,0);
if(ticker1) ms_ticker_destroy(ticker1);
if(f1_r) ms_filter_destroy(f1_r);
if(record) ms_filter_destroy(record);
printf("to get string from server\n");
data_w.msg_type = 7;
data_w.id=0;
char *tmp=strrchr(get_from_server(filename),'=');
if(tmp==NULL)
strcpy(data_w.text,"can not find result from server");
else
strcpy(data_w.text, tmp+1);
if(msgsnd(msgid, (void*)&data_w, 512, IPC_NOWAIT) == -1)
{
fprintf(stderr, "msgsnd failed\n");
//exit(1);
}
}
}
int main(int argc, char* argv[]){
ms_init();
ortp_init();
RtpSession* temp_session;
temp_session=rtp_session_new(1);
MSSndCard *sndcard;
sndcard=ms_snd_card_manager_get_default_card(ms_snd_card_manager_get());
/*define sample audio capture filter */
MSFilter *soundread=ms_snd_card_create_reader(sndcard);
MSFilter *soundwrite=ms_snd_card_create_writer(sndcard);
MSFilter *encoder=ms_filter_create_encoder("PCMU");
MSFilter *decoder=ms_filter_create_decoder("PCMU");
MSFilter *rtpsend=ms_filter_new(MS_RTP_SEND_ID);
MSFilter *rtprecv=ms_filter_new(MS_RTP_RECV_ID);
RtpSession *rtp_session = temp_session ;
ms_filter_call_method(rtpsend,MS_RTP_SEND_SET_SESSION,rtp_session);
ms_filter_call_method(rtprecv,MS_RTP_RECV_SET_SESSION,rtp_session);
/*define capture rate and initialize filters*/
MSFilter *dtmfgen=ms_filter_new(MS_DTMF_GEN_ID);
int sr = 8000;
int chan=1;
ms_filter_call_method(soundread,MS_FILTER_SET_SAMPLE_RATE,&sr);
ms_filter_call_method(soundwrite,MS_FILTER_SET_SAMPLE_RATE,&sr);
ms_filter_call_method(encoder,MS_FILTER_SET_SAMPLE_RATE,&sr);
ms_filter_call_method(decoder,MS_FILTER_SET_SAMPLE_RATE,&sr);
ms_filter_call_method(soundwrite,MS_FILTER_SET_NCHANNELS, &chan);
/*link the filters and run the graph*/
ms_filter_link(soundread,0, encoder,0);
ms_filter_link( encoder,0, rtpsend,0);
ms_filter_link( rtprecv,0, decoder,0);
ms_filter_link( decoder,0, dtmfgen,0);
ms_filter_link( dtmfgen,0, soundwrite,0);
/*create tiker*/
MSTicker *ticker=ms_ticker_new();
ms_ticker_attach(ticker,soundread);
ms_ticker_attach(ticker,rtprecv);
ms_ticker_detach(ticker,soundread);
ms_ticker_detach(ticker,rtprecv);
/*unlink filters and destroy the MS objects*/
ms_filter_unlink( soundread,0, encoder,0);
ms_filter_unlink( encoder,0, rtpsend,0);
ms_filter_unlink( rtprecv,0, decoder,0);
ms_filter_unlink( decoder,0, dtmfgen,0);
ms_filter_unlink( dtmfgen,0, soundwrite,0);
if (rtp_session!=NULL) rtp_session_destroy(rtp_session);
if (rtpsend!=NULL) ms_filter_destroy(rtpsend);
if (rtprecv!=NULL) ms_filter_destroy(rtprecv);
if (soundread!=NULL) ms_filter_destroy(soundread);
if (soundwrite!=NULL) ms_filter_destroy(soundwrite);
if (encoder!=NULL) ms_filter_destroy(encoder);
if (decoder!=NULL) ms_filter_destroy(decoder);
if (dtmfgen!=NULL) ms_filter_destroy(dtmfgen);
if (ticker!=NULL) ms_ticker_destroy(ticker);
}
static void run_media_streams(int localport, const char *remote_ip, int remoteport, int payload, const char *fmtp,
int jitter, int bitrate, MSVideoSize vs, bool_t ec, bool_t agc, bool_t eq)
{
AudioStream *audio=NULL;
#ifdef VIDEO_ENABLED
VideoStream *video=NULL;
#endif
RtpSession *session=NULL;
PayloadType *pt;
RtpProfile *profile=rtp_profile_clone_full(&av_profile);
OrtpEvQueue *q=ortp_ev_queue_new();
ms_init();
signal(SIGINT,stop_handler);
pt=rtp_profile_get_payload(profile,payload);
if (pt==NULL){
printf("Error: no payload defined with number %i.",payload);
exit(-1);
}
if (fmtp!=NULL) payload_type_set_send_fmtp(pt,fmtp);
if (bitrate>0) pt->normal_bitrate=bitrate;
if (pt->type!=PAYLOAD_VIDEO){
MSSndCardManager *manager=ms_snd_card_manager_get();
MSSndCard *capt= capture_card==NULL ? ms_snd_card_manager_get_default_capture_card(manager) :
ms_snd_card_manager_get_card(manager,capture_card);
MSSndCard *play= playback_card==NULL ? ms_snd_card_manager_get_default_playback_card(manager) :
ms_snd_card_manager_get_card(manager,playback_card);
audio=audio_stream_new(localport,ms_is_ipv6(remote_ip));
audio_stream_enable_automatic_gain_control(audio,agc);
audio_stream_enable_noise_gate(audio,use_ng);
audio_stream_set_echo_canceller_params(audio,ec_len_ms,ec_delay_ms,ec_framesize);
printf("Starting audio stream.\n");
audio_stream_start_full(audio,profile,remote_ip,remoteport,remoteport+1, payload, jitter,infile,outfile,
outfile==NULL ? play : NULL ,infile==NULL ? capt : NULL,infile!=NULL ? FALSE: ec);
if (audio) {
if (use_ng && ng_threshold!=-1)
ms_filter_call_method(audio->volsend,MS_VOLUME_SET_NOISE_GATE_THRESHOLD,&ng_threshold);
session=audio->session;
}
}else{
#ifdef VIDEO_ENABLED
if (eq){
ms_fatal("Cannot put an audio equalizer in a video stream !");
exit(-1);
}
printf("Starting video stream.\n");
video=video_stream_new(localport, ms_is_ipv6(remote_ip));
video_stream_set_sent_video_size(video,vs);
video_stream_use_preview_video_window(video,two_windows);
video_stream_start(video,profile,
remote_ip,
remoteport,remoteport+1,
payload,
jitter,
ms_web_cam_manager_get_default_cam(ms_web_cam_manager_get()));
session=video->session;
#else
printf("Error: video support not compiled.\n");
#endif
}
if (eq || ec){ /*read from stdin interactive commands */
char commands[128];
commands[127]='\0';
ms_sleep(1); /* ensure following text be printed after ortp messages */
if (eq)
printf("\nPlease enter equalizer requests, such as 'eq active 1', 'eq active 0', 'eq 1200 0.1 200'\n");
if (ec)
printf("\nPlease enter echo canceller requests: ec reset; ec <delay ms> <tail_length ms'\n");
while(fgets(commands,sizeof(commands)-1,stdin)!=NULL){
int active,freq,freq_width;
int delay_ms, tail_ms;
float gain;
if (sscanf(commands,"eq active %i",&active)==1){
audio_stream_enable_equalizer(audio,active);
printf("OK\n");
}else if (sscanf(commands,"eq %i %f %i",&freq,&gain,&freq_width)==3){
audio_stream_equalizer_set_gain(audio,freq,gain,freq_width);
printf("OK\n");
}else if (sscanf(commands,"eq %i %f",&freq,&gain)==2){
audio_stream_equalizer_set_gain(audio,freq,gain,0);
printf("OK\n");
}else if (strstr(commands,"dump")){
int n=0,i;
float *t;
ms_filter_call_method(audio->equalizer,MS_EQUALIZER_GET_NUM_FREQUENCIES,&n);
t=(float*)alloca(sizeof(float)*n);
ms_filter_call_method(audio->equalizer,MS_EQUALIZER_DUMP_STATE,t);
for(i=0;i<n;++i){
if (fabs(t[i]-1)>0.01){
printf("%i:%f:0 ",(i*pt->clock_rate)/(2*n),t[i]);
}
}
printf("\nOK\n");
}else if (sscanf(commands,"ec reset %i",&active)==1){
//audio_stream_enable_equalizer(audio,active);
//printf("OK\n");
}else if (sscanf(commands,"ec active %i",&active)==1){
//audio_stream_enable_equalizer(audio,active);
//printf("OK\n");
}else if (sscanf(commands,"ec %i %i",&delay_ms,&tail_ms)==2){
audio_stream_set_echo_canceller_params(audio,tail_ms,delay_ms,128);
// revisit: workaround with old method call to force echo reset
delay_ms*=8;
ms_filter_call_method(audio->ec,MS_FILTER_SET_PLAYBACKDELAY,&delay_ms);
printf("OK\n");
}else if (strstr(commands,"quit")){
break;
}else printf("Cannot understand this.\n");
}
}else{ /* no interactive stuff - continuous debug output */
rtp_session_register_event_queue(session,q);
while(cond)
{
int n;
for(n=0;n<100;++n){
#ifdef WIN32
MSG msg;
Sleep(10);
while (PeekMessage(&msg, NULL, 0, 0,1)){
TranslateMessage(&msg);
DispatchMessage(&msg);
}
#else
struct timespec ts;
ts.tv_sec=0;
ts.tv_nsec=10000000;
nanosleep(&ts,NULL);
#endif
#if defined(VIDEO_ENABLED)
if (video) video_stream_iterate(video);
#endif
}
ortp_global_stats_display();
if (session){
printf("Bandwidth usage: download=%f kbits/sec, upload=%f kbits/sec\n",
rtp_session_compute_recv_bandwidth(session)*1e-3,
rtp_session_compute_send_bandwidth(session)*1e-3);
parse_events(q);
}
}
}
printf("stopping all...\n");
if (audio) audio_stream_stop(audio);
#ifdef VIDEO_ENABLED
if (video) video_stream_stop(video);
#endif
ortp_ev_queue_destroy(q);
rtp_profile_destroy(profile);
}
