sjero.net Git - linphone/blob - coreapi/lsd.c

   1 /*
   2 linphone
   3 Copyright (C) 2010 Simon MORLAT (simon.morlat@linphone.org)
   4
   5 This program is free software; you can redistribute it and/or
   6 modify it under the terms of the GNU General Public License
   7 as published by the Free Software Foundation; either version 2
   8 of the License, or (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18 */
  19
  20 /* Linphone Sound Daemon: is a lightweight utility to play sounds to speaker during a conversation.
  21  This is useful for embedded platforms, where sound apis are not performant enough to allow
  22  simultaneous sound access.
  23 */
  24
  25 #include "linphonecore_utils.h"
  26 #include "private.h"
  27 #include "mediastreamer2/msticker.h"
  28 #include "mediastreamer2/mssndcard.h"
  29 #include "mediastreamer2/msaudiomixer.h"
  30 #include "mediastreamer2/mschanadapter.h"
  31 #include "mediastreamer2/msfileplayer.h"
  32 #include "mediastreamer2/msitc.h"
  33
  34
  35 static struct _MSSndCard *linphone_sound_daemon_get_proxy_card(LinphoneSoundDaemon *obj);
  36
  37 #define MAX_BRANCHES 10
  38
  39
  40 struct _LsdPlayer{
  41         struct _LinphoneSoundDaemon *lsd;
  42         MSFilter *player;
  43         MSFilter *rateconv;
  44         MSFilter *chanadapter;
  45         LsdEndOfPlayCallback eop_cb;
  46         int mixer_pin;
  47         void *user_data;
  48 };
  49
  50 struct _LinphoneSoundDaemon {
  51         int out_rate;
  52         int out_nchans;
  53         MSFilter *mixer;
  54         MSFilter *soundout;
  55         MSFilter *itcsink;
  56         MSTicker *ticker;
  57         MSSndCard *proxycard;
  58         LsdPlayer branches[MAX_BRANCHES];
  59 };
  60
  61 static MSFilter *create_writer(MSSndCard *c){
  62         LinphoneSoundDaemon *lsd=(LinphoneSoundDaemon*)c->data;
  63         return lsd->itcsink;
  64 }
  65
  66 static MSSndCardDesc proxycard={
  67         "Linphone Sound Daemon",
  68         /*detect*/ NULL,
  69         /*init*/ NULL,
  70         NULL,
  71         NULL,
  72         NULL,
  73         NULL,
  74         NULL,
  75         /*create_reader*/ NULL,
  76         create_writer,
  77         /*uninit,*/
  78 };
  79
  80 LsdPlayer *linphone_sound_daemon_get_player(LinphoneSoundDaemon *obj){
  81         int i;
  82         for(i=1;i<MAX_BRANCHES;++i){
  83                 LsdPlayer *b=&obj->branches[i];
  84                 MSFilter *p=b->player;
  85                 int state;
  86                 ms_filter_call_method(p,MS_PLAYER_GET_STATE,&state);
  87                 if (state==MSPlayerClosed){
  88                         lsd_player_set_gain(b,1);
  89                         return b;
  90                 }
  91         }
  92         ms_warning("No more free players !");
  93         return NULL;
  94 }
  95
  96 void linphone_sound_daemon_release_player(LinphoneSoundDaemon *obj, LsdPlayer * player){
  97         int state;
  98         ms_filter_call_method(player->player,MS_PLAYER_GET_STATE,&state);
  99         if (state!=MSPlayerClosed){
 100                 ms_filter_call_method(player->player,MS_PLAYER_CLOSE,&state);
 101         }
 102 }
 103
 104 int lsd_player_stop(LsdPlayer *p){
 105         ms_filter_call_method_noarg(p->player,MS_PLAYER_PAUSE);
 106         return 0;
 107 }
 108
 109 static void lsd_player_init(LsdPlayer *p, MSConnectionPoint mixer, MSFilterId playerid, LinphoneSoundDaemon *lsd){
 110         MSConnectionHelper h;
 111         p->player=ms_filter_new(playerid);
 112         p->rateconv=ms_filter_new(MS_RESAMPLE_ID);
 113         p->chanadapter=ms_filter_new(MS_CHANNEL_ADAPTER_ID);
 114
 115         ms_connection_helper_start(&h);
 116         ms_connection_helper_link(&h,p->player,-1,0);
 117         ms_connection_helper_link(&h,p->rateconv,0,0);
 118         ms_connection_helper_link(&h,p->chanadapter,0,0);
 119         ms_connection_helper_link(&h,mixer.filter,mixer.pin,-1);
 120         p->mixer_pin=mixer.pin;
 121         p->lsd=lsd;
 122 }
 123
 124 static void lsd_player_uninit(LsdPlayer *p, MSConnectionPoint mixer){
 125         MSConnectionHelper h;
 126
 127         ms_connection_helper_start(&h);
 128         ms_connection_helper_unlink (&h,p->player,-1,0);
 129         ms_connection_helper_unlink(&h,p->rateconv,0,0);
 130         ms_connection_helper_unlink(&h,p->chanadapter,0,0);
 131         ms_connection_helper_unlink(&h,mixer.filter,mixer.pin,-1);
 132
 133         ms_filter_destroy(p->player);
 134         ms_filter_destroy(p->rateconv);
 135         ms_filter_destroy(p->chanadapter);
 136 }
 137
 138 void lsd_player_set_callback(LsdPlayer *p, LsdEndOfPlayCallback cb){
 139         p->eop_cb=cb;
 140 }
 141
 142 void lsd_player_set_user_pointer(LsdPlayer *p, void *up){
 143         p->user_data=up;
 144 }
 145
 146 void *lsd_player_get_user_pointer(LsdPlayer *p){
 147         return p->user_data;
 148 }
 149
 150 static void lsd_player_on_eop(void * userdata, unsigned int id, void *arg){
 151 }
 152
 153 int lsd_player_play(LsdPlayer *b, const char *filename ){
 154         int rate,chans;
 155         int state;
 156         LinphoneSoundDaemon *lsd=b->lsd;
 157
 158         ms_filter_call_method(b->player,MS_PLAYER_GET_STATE,&state);
 159         if (state!=MSPlayerClosed){
 160                 ms_filter_call_method_noarg(b->player,MS_PLAYER_CLOSE);
 161         }
 162
 163         if (ms_filter_call_method(b->player,MS_PLAYER_OPEN,(void*)filename)!=0){
 164                 return -1;
 165         }
 166         ms_filter_call_method(b->player,MS_FILTER_GET_SAMPLE_RATE,&rate);
 167         ms_filter_call_method(b->player,MS_FILTER_GET_NCHANNELS,&chans);
 168         ms_filter_set_notify_callback (b->player,lsd_player_on_eop,b);
 169
 170         ms_filter_call_method(b->rateconv,MS_FILTER_SET_SAMPLE_RATE,&rate);
 171         ms_filter_call_method(b->rateconv,MS_FILTER_SET_NCHANNELS,&chans);
 172         ms_filter_call_method(b->rateconv,MS_FILTER_SET_OUTPUT_SAMPLE_RATE,&lsd->out_rate);
 173
 174         ms_filter_call_method(b->chanadapter,MS_FILTER_SET_NCHANNELS,&chans);
 175         ms_filter_call_method(b->chanadapter,MS_CHANNEL_ADAPTER_SET_OUTPUT_NCHANNELS,&lsd->out_nchans);
 176         return 0;
 177 }
 178
 179 void lsd_player_enable_loop(LsdPlayer *p, bool_t loopmode){
 180         if (ms_filter_get_id(p->player)==MS_FILE_PLAYER_ID){
 181                 int arg=loopmode ? 0 : -1;
 182                 ms_filter_call_method(p->player,MS_FILE_PLAYER_LOOP,&arg);
 183         }
 184 }
 185
 186 void lsd_player_set_gain(LsdPlayer *p, float gain){
 187         MSAudioMixerCtl gainctl;
 188         gainctl.pin=p->mixer_pin;
 189         gainctl.gain=gain;
 190         ms_filter_call_method(p->lsd->mixer,MS_AUDIO_MIXER_SET_INPUT_GAIN,&gainctl);
 191 }
 192
 193 LinphoneSoundDaemon * linphone_sound_daemon_new(const char *cardname){
 194         int i;
 195         MSConnectionPoint mp;
 196         LinphoneSoundDaemon *lsd;
 197         MSSndCard *card=ms_snd_card_manager_get_card(
 198                                                      ms_snd_card_manager_get(),
 199                                                      cardname);
 200         if (card==NULL){
 201                 card=ms_snd_card_manager_get_default_playback_card (
 202                                                                     ms_snd_card_manager_get());
 203                 if (card==NULL){
 204                         ms_error("linphone_sound_daemon_new(): No playback soundcard available");
 205                         return NULL;
 206                 }
 207         }
 208
 209         lsd=ms_new0(LinphoneSoundDaemon,1);
 210         lsd->soundout=ms_snd_card_create_writer(card);
 211         lsd->mixer=ms_filter_new(MS_AUDIO_MIXER_ID);
 212         lsd->itcsink=ms_filter_new(MS_ITC_SINK_ID);
 213         lsd->out_rate=44100;
 214         lsd->out_nchans=2;
 215         ms_filter_call_method(lsd->soundout,MS_FILTER_SET_SAMPLE_RATE,&lsd->out_rate);
 216         ms_filter_call_method(lsd->soundout,MS_FILTER_SET_NCHANNELS,&lsd->out_nchans);
 217         ms_filter_call_method(lsd->mixer,MS_FILTER_SET_SAMPLE_RATE,&lsd->out_rate);
 218         ms_filter_call_method(lsd->mixer,MS_FILTER_SET_NCHANNELS,&lsd->out_nchans);
 219
 220         mp.filter=lsd->mixer;
 221         mp.pin=0;
 222
 223         lsd_player_init(&lsd->branches[0],mp,MS_ITC_SINK_ID,lsd);
 224         for(i=1;i<MAX_BRANCHES;++i){
 225                 mp.pin=i;
 226                 lsd_player_init(&lsd->branches[i],mp,MS_FILE_PLAYER_ID,lsd);
 227         }
 228         ms_filter_link(lsd->mixer,0,lsd->soundout,0);
 229         lsd->ticker=ms_ticker_new();
 230         ms_ticker_attach(lsd->ticker,lsd->soundout);
 231
 232         lsd->proxycard=ms_snd_card_new(&proxycard);
 233         lsd->proxycard->data=lsd;
 234
 235         ms_filter_call_method(lsd->itcsink,MS_ITC_SINK_CONNECT,lsd->branches[0].player);
 236
 237         return lsd;
 238 }
 239
 240 void linphone_sound_daemon_destroy(LinphoneSoundDaemon *obj){
 241         int i;
 242         MSConnectionPoint mp;
 243         ms_ticker_detach(obj->ticker,obj->soundout);
 244         mp.filter=obj->mixer;
 245         for(i=0;i<MAX_BRANCHES;++i){
 246                 mp.pin=i;
 247                 lsd_player_uninit (&obj->branches[i],mp);
 248         }
 249         ms_ticker_destroy(obj->ticker);
 250         ms_filter_destroy(obj->soundout);
 251         ms_filter_destroy(obj->mixer);
 252         ms_filter_destroy(obj->itcsink);
 253 }
 254
 255 MSSndCard *linphone_sound_daemon_get_proxy_card(LinphoneSoundDaemon *lsd){
 256         return lsd->proxycard;
 257 }
 258
 259 void linphone_core_use_sound_daemon(LinphoneCore *lc, LinphoneSoundDaemon *lsd){
 260         lc->sound_conf.lsd_card=linphone_sound_daemon_get_proxy_card (lsd);
 261 }