lsd.c 9 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
/*
linphone
Copyright (C) 2010 Simon MORLAT (simon.morlat@linphone.org)

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

/* Linphone Sound Daemon: is a lightweight utility to play sounds to speaker during a conversation.
 This is useful for embedded platforms, where sound apis are not performant enough to allow
 simultaneous sound access.
*/

#include "linphonecore_utils.h"
26
#include "private.h"
27
#include "mediastreamer2/msticker.h"
28
#include "mediastreamer2/mssndcard.h"
Simon Morlat's avatar
Simon Morlat committed
29 30 31
#include "mediastreamer2/msaudiomixer.h"
#include "mediastreamer2/mschanadapter.h"
#include "mediastreamer2/msfileplayer.h"
32
#include "mediastreamer2/msitc.h"
Simon Morlat's avatar
Simon Morlat committed
33

34

35
static struct _MSSndCard *linphone_sound_daemon_get_proxy_card(LinphoneSoundDaemon *obj);
36 37 38 39 40 41 42 43 44 45

#define MAX_BRANCHES 10


struct _LsdPlayer{
	struct _LinphoneSoundDaemon *lsd;
	MSFilter *player;
	MSFilter *rateconv;
	MSFilter *chanadapter;
	LsdEndOfPlayCallback eop_cb;
Simon Morlat's avatar
Simon Morlat committed
46
	int mixer_pin;
47
	void *user_data;
48 49
	bool_t loop;
	bool_t pad[3];
50 51 52 53 54 55 56
};

struct _LinphoneSoundDaemon {
	int out_rate;
	int out_nchans;
	MSFilter *mixer;
	MSFilter *soundout;
57 58
	MSTicker *ticker;
	MSSndCard *proxycard;
59 60 61
	LsdPlayer branches[MAX_BRANCHES];
};

62 63
static MSFilter *create_writer(MSSndCard *c){
	LinphoneSoundDaemon *lsd=(LinphoneSoundDaemon*)c->data;
64 65 66
	MSFilter *itcsink=ms_filter_new(MS_ITC_SINK_ID);
	ms_filter_call_method(itcsink,MS_ITC_SINK_CONNECT,lsd->branches[0].player);
	return itcsink;
67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82
}

static MSSndCardDesc proxycard={
	"Linphone Sound Daemon",
	/*detect*/ NULL,
	/*init*/ NULL,
	NULL,
	NULL,
	NULL,
	NULL,
	NULL,
	/*create_reader*/ NULL,
	create_writer,
	/*uninit,*/
};

83 84
LsdPlayer *linphone_sound_daemon_get_player(LinphoneSoundDaemon *obj){
	int i;
85
	for(i=1;i<MAX_BRANCHES;++i){
86 87 88 89 90
		LsdPlayer *b=&obj->branches[i];
		MSFilter *p=b->player;
		int state;
		ms_filter_call_method(p,MS_PLAYER_GET_STATE,&state);
		if (state==MSPlayerClosed){
Simon Morlat's avatar
Simon Morlat committed
91
			lsd_player_set_gain(b,1);
92
			lsd_player_enable_loop (b,FALSE);
93 94 95 96 97 98 99 100 101 102 103 104 105 106 107
			return b;
		}
	}
	ms_warning("No more free players !");
	return NULL;
}

void linphone_sound_daemon_release_player(LinphoneSoundDaemon *obj, LsdPlayer * player){
	int state;
	ms_filter_call_method(player->player,MS_PLAYER_GET_STATE,&state);
	if (state!=MSPlayerClosed){
		ms_filter_call_method(player->player,MS_PLAYER_CLOSE,&state);
	}
}

Simon Morlat's avatar
Simon Morlat committed
108 109 110 111
LinphoneSoundDaemon *lsd_player_get_daemon(const LsdPlayer *p){
	return p->lsd;
}

112 113 114 115 116 117 118 119 120
int lsd_player_stop(LsdPlayer *p){
	ms_filter_call_method_noarg(p->player,MS_PLAYER_PAUSE);
	return 0;
}

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);
Simon Morlat's avatar
Simon Morlat committed
121 122
	p->chanadapter=ms_filter_new(MS_CHANNEL_ADAPTER_ID);
	
123 124 125 126 127
	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);
Simon Morlat's avatar
Simon Morlat committed
128
	p->mixer_pin=mixer.pin;
129
	p->loop=FALSE;
130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154
	p->lsd=lsd;
}

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

void lsd_player_set_callback(LsdPlayer *p, LsdEndOfPlayCallback cb){
	p->eop_cb=cb;
}

void lsd_player_set_user_pointer(LsdPlayer *p, void *up){
	p->user_data=up;
}

155
void *lsd_player_get_user_pointer(const LsdPlayer *p){
156 157 158
	return p->user_data;
}

159
static void lsd_player_on_eop(void * userdata, MSFilter *f, unsigned int id, void *arg){
160 161 162
	LsdPlayer *p=(LsdPlayer *)userdata;
	if (p->eop_cb!=NULL)
		p->eop_cb(p);
163 164
}

165
static void lsd_player_configure(LsdPlayer *b){
166 167
	int rate,chans;
	LinphoneSoundDaemon *lsd=b->lsd;
168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186

	if (ms_filter_get_id(b->player)==MS_ITC_SOURCE_ID)
		ms_message("Configuring branch coming from audio call...");
	
	ms_filter_call_method(b->player,MS_FILTER_GET_SAMPLE_RATE,&rate);
	ms_filter_call_method(b->player,MS_FILTER_GET_NCHANNELS,&chans);
	
	
	ms_filter_call_method(b->rateconv,MS_FILTER_SET_SAMPLE_RATE,&rate);
	ms_filter_call_method(b->rateconv,MS_FILTER_SET_NCHANNELS,&chans);
	ms_filter_call_method(b->rateconv,MS_FILTER_SET_OUTPUT_SAMPLE_RATE,&lsd->out_rate);

	ms_filter_call_method(b->chanadapter,MS_FILTER_SET_NCHANNELS,&chans);
	ms_filter_call_method(b->chanadapter,MS_CHANNEL_ADAPTER_SET_OUTPUT_NCHANNELS,&lsd->out_nchans);
	ms_message("player configured for rate=%i, channels=%i",rate,chans);
}

int lsd_player_play(LsdPlayer *b, const char *filename ){
	int state;
187 188 189 190 191 192 193
	
	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){
194
		ms_warning("Could not play %s",filename);
195 196
		return -1;
	}
197
	ms_filter_add_notify_callback (b->player,lsd_player_on_eop,b,FALSE);
198
	lsd_player_configure(b);
199
	ms_filter_call_method_noarg (b->player,MS_PLAYER_START);
200 201 202
	return 0;
}

Simon Morlat's avatar
Simon Morlat committed
203 204 205 206
void lsd_player_enable_loop(LsdPlayer *p, bool_t loopmode){
	if (ms_filter_get_id(p->player)==MS_FILE_PLAYER_ID){
		int arg=loopmode ? 0 : -1;
		ms_filter_call_method(p->player,MS_FILE_PLAYER_LOOP,&arg);
207
		p->loop=loopmode;
Simon Morlat's avatar
Simon Morlat committed
208 209 210
	}
}

211 212 213 214
bool_t lsd_player_loop_enabled(const LsdPlayer *p){
	return p->loop;
}

Simon Morlat's avatar
Simon Morlat committed
215 216 217
void lsd_player_set_gain(LsdPlayer *p, float gain){
	MSAudioMixerCtl gainctl;
	gainctl.pin=p->mixer_pin;
218
	gainctl.param.gain=gain;
Simon Morlat's avatar
Simon Morlat committed
219 220
	ms_filter_call_method(p->lsd->mixer,MS_AUDIO_MIXER_SET_INPUT_GAIN,&gainctl);
}
221

222
LinphoneSoundDaemon * linphone_sound_daemon_new(const char *cardname, int rate, int nchannels){
223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239
	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);
240
	lsd->mixer=ms_filter_new(MS_AUDIO_MIXER_ID);
241 242
	lsd->out_rate=rate;
	lsd->out_nchans=nchannels;
243 244
	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);
245 246
	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);
247

Simon Morlat's avatar
Simon Morlat committed
248
	mp.filter=lsd->mixer;
249 250
	mp.pin=0;

251
	lsd_player_init(&lsd->branches[0],mp,MS_ITC_SOURCE_ID,lsd);
252
	ms_filter_add_notify_callback(lsd->branches[0].player,(MSFilterNotifyFunc)lsd_player_configure,&lsd->branches[0],FALSE);
253 254
	for(i=1;i<MAX_BRANCHES;++i){
		mp.pin=i;
Simon Morlat's avatar
Simon Morlat committed
255
		lsd_player_init(&lsd->branches[i],mp,MS_FILE_PLAYER_ID,lsd);
256
	}
257 258 259 260 261 262
	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;
263
	ms_message("LinphoneSoundDaemon started with rate=%i, nchannels=%i",rate,nchannels);
264 265 266
	return lsd;
}

267 268 269 270 271 272 273
void linphone_sound_daemon_stop_all_players(LinphoneSoundDaemon *obj){
	int i;
	for(i=1;i<MAX_BRANCHES;++i){
		lsd_player_stop(&obj->branches[i]);
	}
}

274 275 276 277 278 279 280
void linphone_sound_daemon_release_all_players(LinphoneSoundDaemon *obj){
	int i;
	for(i=1;i<MAX_BRANCHES;++i){
		linphone_sound_daemon_release_player(obj,&obj->branches[i]);
	}
}

281 282 283 284 285 286 287
void linphone_sound_daemon_destroy(LinphoneSoundDaemon *obj){
	int i;
	MSConnectionPoint mp;
	ms_ticker_detach(obj->ticker,obj->soundout);
	mp.filter=obj->mixer;
	for(i=0;i<MAX_BRANCHES;++i){
		mp.pin=i;
288
		if (i!=0) linphone_sound_daemon_release_player(obj,&obj->branches[i]);
289 290
		lsd_player_uninit (&obj->branches[i],mp);
	}
291
	ms_filter_unlink(obj->mixer,0,obj->soundout,0);
292 293 294 295 296 297 298 299
	ms_ticker_destroy(obj->ticker);
	ms_filter_destroy(obj->soundout);
	ms_filter_destroy(obj->mixer);
}

MSSndCard *linphone_sound_daemon_get_proxy_card(LinphoneSoundDaemon *lsd){
	return lsd->proxycard;
}
300 301

void linphone_core_use_sound_daemon(LinphoneCore *lc, LinphoneSoundDaemon *lsd){
Simon Morlat's avatar
Simon Morlat committed
302 303 304 305 306
	if (lsd!=NULL){
		lc->sound_conf.lsd_card=linphone_sound_daemon_get_proxy_card (lsd);
	}else {
		lc->sound_conf.lsd_card=NULL;
	}
307
}