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         bool_t loop;
  49         bool_t pad[3];
  50 };
  51
  52 struct _LinphoneSoundDaemon {
  53         int out_rate;
  54         int out_nchans;
  55         MSFilter *mixer;
  56         MSFilter *soundout;
  57         MSTicker *ticker;
  58         MSSndCard *proxycard;
  59         LsdPlayer branches[MAX_BRANCHES];
  60 };
  61
  62 static MSFilter *create_writer(MSSndCard *c){
  63         LinphoneSoundDaemon *lsd=(LinphoneSoundDaemon*)c->data;
  64         MSFilter *itcsink=ms_filter_new(MS_ITC_SINK_ID);
  65         ms_filter_call_method(itcsink,MS_ITC_SINK_CONNECT,lsd->branches[0].player);
  66         return itcsink;
  67 }
  68
  69 static MSSndCardDesc proxycard={
  70         "Linphone Sound Daemon",
  71         /*detect*/ NULL,
  72         /*init*/ NULL,
  73         NULL,
  74         NULL,
  75         NULL,
  76         NULL,
  77         NULL,
  78         /*create_reader*/ NULL,
  79         create_writer,
  80         /*uninit,*/
  81 };
  82
  83 LsdPlayer *linphone_sound_daemon_get_player(LinphoneSoundDaemon *obj){
  84         int i;
  85         for(i=1;i<MAX_BRANCHES;++i){
  86                 LsdPlayer *b=&obj->branches[i];
  87                 MSFilter *p=b->player;
  88                 int state;
  89                 ms_filter_call_method(p,MS_PLAYER_GET_STATE,&state);
  90                 if (state==MSPlayerClosed){
  91                         lsd_player_set_gain(b,1);
  92                         lsd_player_enable_loop (b,FALSE);
  93                         return b;
  94                 }
  95         }
  96         ms_warning("No more free players !");
  97         return NULL;
  98 }
  99
 100 void linphone_sound_daemon_release_player(LinphoneSoundDaemon *obj, LsdPlayer * player){
 101         int state;
 102         ms_filter_call_method(player->player,MS_PLAYER_GET_STATE,&state);
 103         if (state!=MSPlayerClosed){
 104                 ms_filter_call_method(player->player,MS_PLAYER_CLOSE,&state);
 105         }
 106 }
 107
 108 LinphoneSoundDaemon *lsd_player_get_daemon(const LsdPlayer *p){
 109         return p->lsd;
 110 }
 111
 112 int lsd_player_stop(LsdPlayer *p){
 113         ms_filter_call_method_noarg(p->player,MS_PLAYER_PAUSE);
 114         return 0;
 115 }
 116
 117 static void lsd_player_init(LsdPlayer *p, MSConnectionPoint mixer, MSFilterId playerid, LinphoneSoundDaemon *lsd){
 118         MSConnectionHelper h;
 119         p->player=ms_filter_new(playerid);
 120         p->rateconv=ms_filter_new(MS_RESAMPLE_ID);
 121         p->chanadapter=ms_filter_new(MS_CHANNEL_ADAPTER_ID);
 122
 123         ms_connection_helper_start(&h);
 124         ms_connection_helper_link(&h,p->player,-1,0);
 125         ms_connection_helper_link(&h,p->rateconv,0,0);
 126         ms_connection_helper_link(&h,p->chanadapter,0,0);
 127         ms_connection_helper_link(&h,mixer.filter,mixer.pin,-1);
 128         p->mixer_pin=mixer.pin;
 129         p->loop=FALSE;
 130         p->lsd=lsd;
 131 }
 132
 133 static void lsd_player_uninit(LsdPlayer *p, MSConnectionPoint mixer){
 134         MSConnectionHelper h;
 135
 136         ms_connection_helper_start(&h);
 137         ms_connection_helper_unlink (&h,p->player,-1,0);
 138         ms_connection_helper_unlink(&h,p->rateconv,0,0);
 139         ms_connection_helper_unlink(&h,p->chanadapter,0,0);
 140         ms_connection_helper_unlink(&h,mixer.filter,mixer.pin,-1);
 141
 142         ms_filter_destroy(p->player);
 143         ms_filter_destroy(p->rateconv);
 144         ms_filter_destroy(p->chanadapter);
 145 }
 146
 147 void lsd_player_set_callback(LsdPlayer *p, LsdEndOfPlayCallback cb){
 148         p->eop_cb=cb;
 149 }
 150
 151 void lsd_player_set_user_pointer(LsdPlayer *p, void *up){
 152         p->user_data=up;
 153 }
 154
 155 void *lsd_player_get_user_pointer(const LsdPlayer *p){
 156         return p->user_data;
 157 }
 158
 159 static void lsd_player_on_eop(void * userdata, MSFilter *f, unsigned int id, void *arg){
 160         LsdPlayer *p=(LsdPlayer *)userdata;
 161         if (p->eop_cb!=NULL)
 162                 p->eop_cb(p);
 163 }
 164
 165 static void lsd_player_configure(LsdPlayer *b){
 166         int rate,chans;
 167         LinphoneSoundDaemon *lsd=b->lsd;
 168
 169         if (ms_filter_get_id(b->player)==MS_ITC_SOURCE_ID)
 170                 ms_message("Configuring branch coming from audio call...");
 171
 172         ms_filter_call_method(b->player,MS_FILTER_GET_SAMPLE_RATE,&rate);
 173         ms_filter_call_method(b->player,MS_FILTER_GET_NCHANNELS,&chans);
 174
 175
 176         ms_filter_call_method(b->rateconv,MS_FILTER_SET_SAMPLE_RATE,&rate);
 177         ms_filter_call_method(b->rateconv,MS_FILTER_SET_NCHANNELS,&chans);
 178         ms_filter_call_method(b->rateconv,MS_FILTER_SET_OUTPUT_SAMPLE_RATE,&lsd->out_rate);
 179
 180         ms_filter_call_method(b->chanadapter,MS_FILTER_SET_NCHANNELS,&chans);
 181         ms_filter_call_method(b->chanadapter,MS_CHANNEL_ADAPTER_SET_OUTPUT_NCHANNELS,&lsd->out_nchans);
 182         ms_message("player configured for rate=%i, channels=%i",rate,chans);
 183 }
 184
 185 int lsd_player_play(LsdPlayer *b, const char *filename ){
 186         int state;
 187
 188         ms_filter_call_method(b->player,MS_PLAYER_GET_STATE,&state);
 189         if (state!=MSPlayerClosed){
 190                 ms_filter_call_method_noarg(b->player,MS_PLAYER_CLOSE);
 191         }
 192
 193         if (ms_filter_call_method(b->player,MS_PLAYER_OPEN,(void*)filename)!=0){
 194                 ms_warning("Could not play %s",filename);
 195                 return -1;
 196         }
 197         ms_filter_set_notify_callback (b->player,lsd_player_on_eop,b);
 198         lsd_player_configure(b);
 199         ms_filter_call_method_noarg (b->player,MS_PLAYER_START);
 200         return 0;
 201 }
 202
 203 void lsd_player_enable_loop(LsdPlayer *p, bool_t loopmode){
 204         if (ms_filter_get_id(p->player)==MS_FILE_PLAYER_ID){
 205                 int arg=loopmode ? 0 : -1;
 206                 ms_filter_call_method(p->player,MS_FILE_PLAYER_LOOP,&arg);
 207                 p->loop=loopmode;
 208         }
 209 }
 210
 211 bool_t lsd_player_loop_enabled(const LsdPlayer *p){
 212         return p->loop;
 213 }
 214
 215 void lsd_player_set_gain(LsdPlayer *p, float gain){
 216         MSAudioMixerCtl gainctl;
 217         gainctl.pin=p->mixer_pin;
 218         gainctl.param.gain=gain;
 219         ms_filter_call_method(p->lsd->mixer,MS_AUDIO_MIXER_SET_INPUT_GAIN,&gainctl);
 220 }
 221
 222 LinphoneSoundDaemon * linphone_sound_daemon_new(const char *cardname, int rate, int nchannels){
 223         int i;
 224         MSConnectionPoint mp;
 225         LinphoneSoundDaemon *lsd;
 226         MSSndCard *card=ms_snd_card_manager_get_card(
 227                                                      ms_snd_card_manager_get(),
 228                                                      cardname);
 229         if (card==NULL){
 230                 card=ms_snd_card_manager_get_default_playback_card (
 231                                                                     ms_snd_card_manager_get());
 232                 if (card==NULL){
 233                         ms_error("linphone_sound_daemon_new(): No playback soundcard available");
 234                         return NULL;
 235                 }
 236         }
 237
 238         lsd=ms_new0(LinphoneSoundDaemon,1);
 239         lsd->soundout=ms_snd_card_create_writer(card);
 240         lsd->mixer=ms_filter_new(MS_AUDIO_MIXER_ID);
 241         lsd->out_rate=rate;
 242         lsd->out_nchans=nchannels;
 243         ms_filter_call_method(lsd->soundout,MS_FILTER_SET_SAMPLE_RATE,&lsd->out_rate);
 244         ms_filter_call_method(lsd->soundout,MS_FILTER_SET_NCHANNELS,&lsd->out_nchans);
 245         ms_filter_call_method(lsd->mixer,MS_FILTER_SET_SAMPLE_RATE,&lsd->out_rate);
 246         ms_filter_call_method(lsd->mixer,MS_FILTER_SET_NCHANNELS,&lsd->out_nchans);
 247
 248         mp.filter=lsd->mixer;
 249         mp.pin=0;
 250
 251         lsd_player_init(&lsd->branches[0],mp,MS_ITC_SOURCE_ID,lsd);
 252         ms_filter_set_notify_callback(lsd->branches[0].player,(MSFilterNotifyFunc)lsd_player_configure,&lsd->branches[0]);
 253         for(i=1;i<MAX_BRANCHES;++i){
 254                 mp.pin=i;
 255                 lsd_player_init(&lsd->branches[i],mp,MS_FILE_PLAYER_ID,lsd);
 256         }
 257         ms_filter_link(lsd->mixer,0,lsd->soundout,0);
 258         lsd->ticker=ms_ticker_new();
 259         ms_ticker_attach(lsd->ticker,lsd->soundout);
 260
 261         lsd->proxycard=ms_snd_card_new(&proxycard);
 262         lsd->proxycard->data=lsd;
 263         ms_message("LinphoneSoundDaemon started with rate=%i, nchannels=%i",rate,nchannels);
 264         return lsd;
 265 }
 266
 267 void linphone_sound_daemon_stop_all_players(LinphoneSoundDaemon *obj){
 268         int i;
 269         for(i=1;i<MAX_BRANCHES;++i){
 270                 lsd_player_stop(&obj->branches[i]);
 271         }
 272 }
 273
 274 void linphone_sound_daemon_release_all_players(LinphoneSoundDaemon *obj){
 275         int i;
 276         for(i=1;i<MAX_BRANCHES;++i){
 277                 linphone_sound_daemon_release_player(obj,&obj->branches[i]);
 278         }
 279 }
 280
 281 void linphone_sound_daemon_destroy(LinphoneSoundDaemon *obj){
 282         int i;
 283         MSConnectionPoint mp;
 284         ms_ticker_detach(obj->ticker,obj->soundout);
 285         mp.filter=obj->mixer;
 286         for(i=0;i<MAX_BRANCHES;++i){
 287                 mp.pin=i;
 288                 if (i!=0) linphone_sound_daemon_release_player(obj,&obj->branches[i]);
 289                 lsd_player_uninit (&obj->branches[i],mp);
 290         }
 291         ms_filter_unlink(obj->mixer,0,obj->soundout,0);
 292         ms_ticker_destroy(obj->ticker);
 293         ms_filter_destroy(obj->soundout);
 294         ms_filter_destroy(obj->mixer);
 295 }
 296
 297 MSSndCard *linphone_sound_daemon_get_proxy_card(LinphoneSoundDaemon *lsd){
 298         return lsd->proxycard;
 299 }
 300
 301 void linphone_core_use_sound_daemon(LinphoneCore *lc, LinphoneSoundDaemon *lsd){
 302         if (lsd!=NULL){
 303                 lc->sound_conf.lsd_card=linphone_sound_daemon_get_proxy_card (lsd);
 304         }else {
 305                 lc->sound_conf.lsd_card=NULL;
 306         }
 307 }