sjero.net Git - linphone/blob - linphone/mediastreamer2/tests/bench.c

   1
   2 /*
   3 mediastreamer2 library - modular sound and video processing and streaming
   4 Copyright (C) 2006  Simon MORLAT (simon.morlat@linphone.org)
   5
   6 This program is free software; you can redistribute it and/or
   7 modify it under the terms of the GNU General Public License
   8 as published by the Free Software Foundation; either version 2
   9 of the License, or (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19 */
  20
  21
  22 #include "mediastreamer2/msticker.h"
  23
  24 #include "mediastreamer2/msrtp.h"
  25 #include "mediastreamer2/msfileplayer.h"
  26 #include "mediastreamer2/msfilerec.h"
  27
  28 #include <signal.h>
  29
  30 #define MAX_RTP_SIZE    1500
  31
  32 static int run=1;
  33
  34 static void stop(int signum){
  35         run=0;
  36 }
  37
  38 struct test_session {
  39         RtpSession *rtps;
  40
  41         MSFilter *fplayer;
  42         MSFilter *encoder;
  43         MSFilter *rtpsend;
  44
  45         MSFilter *rtprecv;
  46         MSFilter *decoder;
  47         MSFilter *frecorder;
  48 };
  49
  50 struct bench_config {
  51         int num_session;
  52         int num_session_record;
  53
  54         int port_origin;
  55         char *ip_destination;
  56         int port_destination;
  57
  58         int payload;
  59         int rate;
  60         int ptime;
  61         char *wavfile;
  62
  63         MSTicker *ticker;
  64         MSList *tsessions; /* list of struct test_session */
  65 };
  66
  67 #define NUM_SESSION 50 /* num of session to start per block */
  68 #define NUM_SESSION_RECORD 1
  69
  70 struct bench_config cfg[] = {
  71         {       NUM_SESSION,NUM_SESSION_RECORD,
  72                 8000,"127.0.0.1",9000,8,8000,20,"test1.wav",NULL,NULL   },
  73         {       NUM_SESSION,NUM_SESSION_RECORD,
  74                 9000,"127.0.0.1",8000,8,8000,20,"test1.wav",NULL,NULL   },
  75
  76         {       NUM_SESSION,NUM_SESSION_RECORD,
  77                 10000,"127.0.0.1",11000,8,8000,20,"test1.wav",NULL,NULL },
  78         {       NUM_SESSION,NUM_SESSION_RECORD,
  79                 11000,"127.0.0.1",10000,8,8000,20,"test1.wav",NULL,NULL },
  80
  81         {       0,0,0,'\0',0,0,0,0,NULL,NULL,NULL       },
  82 };
  83
  84 RtpSession *create_duplex_rtpsession(int locport){
  85         RtpSession *rtpr;
  86         rtpr=rtp_session_new(RTP_SESSION_SENDRECV);
  87         rtp_session_set_recv_buf_size(rtpr,MAX_RTP_SIZE);
  88         rtp_session_set_scheduling_mode(rtpr,0);
  89         rtp_session_set_blocking_mode(rtpr,0);
  90         rtp_session_enable_adaptive_jitter_compensation(rtpr,FALSE);
  91         rtp_session_set_symmetric_rtp(rtpr,TRUE);
  92         rtp_session_set_local_addr(rtpr,"0.0.0.0",locport);
  93         rtp_session_signal_connect(rtpr,"timestamp_jump",(RtpCallback)rtp_session_resync,(long)NULL);
  94         rtp_session_signal_connect(rtpr,"ssrc_changed",(RtpCallback)rtp_session_resync,(long)NULL);
  95         return rtpr;
  96 }
  97
  98 int init_bench(struct bench_config *bench)
  99 {
 100         PayloadType *pt;
 101         int pos;
 102         int val;
 103         int count;
 104         bench->ticker=ms_ticker_new();
 105
 106         count = 0;
 107         /* creates the couple of encoder/decoder */
 108         pt=rtp_profile_get_payload(&av_profile,bench->payload);
 109         if (pt==NULL){
 110                 ms_error("audiostream.c: undefined payload type.");
 111                 return count;
 112         }
 113         if (pt->clock_rate!=8000 && pt->clock_rate!=16000 && pt->clock_rate!=32000){
 114                 ms_error("audiostream.c: wrong rate.");
 115                 return count;
 116         }
 117         for (pos=0;pos<bench->num_session;pos++)
 118                 {
 119                         struct test_session *ts = (struct test_session *)ortp_malloc(sizeof(struct test_session));
 120                         memset(ts, 0, sizeof(struct test_session));
 121
 122                         ts->rtps = create_duplex_rtpsession(bench->port_origin+pos*2);
 123                         if (ts->rtps==NULL)
 124                                 {
 125                                         ms_error("bench.c: cannot create rtp_session!");
 126                                         ortp_free(ts);
 127                                         return count;
 128                                 }
 129
 130                         rtp_session_set_payload_type(ts->rtps,bench->payload);
 131                         rtp_session_set_remote_addr_full(ts->rtps,
 132                                                                                          bench->ip_destination,
 133                                                                                          bench->port_destination+pos*2,
 134                                                                                          bench->port_destination+1+pos*2);
 135
 136                         ts->fplayer = ms_filter_new(MS_FILE_PLAYER_ID);
 137                         if (strstr(bench->wavfile, ".au")==NULL)
 138                                 ts->encoder = ms_filter_create_encoder(pt->mime_type);
 139                         ts->rtpsend = ms_filter_new(MS_RTP_SEND_ID);
 140
 141                         ts->rtprecv = ms_filter_new(MS_RTP_RECV_ID);
 142                         ts->decoder = ms_filter_create_decoder(pt->mime_type);
 143                         ts->frecorder = ms_filter_new(MS_FILE_REC_ID);
 144
 145                         if ((ts->encoder==NULL && strstr(bench->wavfile, ".au")==NULL)
 146                                 || (ts->decoder==NULL )){
 147                                 ms_error("bench.c: No decoder available for payload %i.",bench->payload);
 148                                 if (ts->fplayer) ms_filter_destroy(ts->fplayer);
 149                                 if (ts->encoder) ms_filter_destroy(ts->encoder);
 150                                 if (ts->rtpsend) ms_filter_destroy(ts->rtpsend);
 151                                 if (ts->rtprecv) ms_filter_destroy(ts->rtprecv);
 152                                 if (ts->decoder) ms_filter_destroy(ts->decoder);
 153                                 if (ts->frecorder) ms_filter_destroy(ts->frecorder);
 154                                 ortp_free(ts);
 155                                 return count;
 156                         }
 157                         if (ts->fplayer==NULL){
 158                                 ms_error("bench.c: missing player filter.");
 159                                 if (ts->fplayer) ms_filter_destroy(ts->fplayer);
 160                                 if (ts->encoder) ms_filter_destroy(ts->encoder);
 161                                 if (ts->rtpsend) ms_filter_destroy(ts->rtpsend);
 162                                 if (ts->rtprecv) ms_filter_destroy(ts->rtprecv);
 163                                 if (ts->decoder) ms_filter_destroy(ts->decoder);
 164                                 if (ts->frecorder) ms_filter_destroy(ts->frecorder);
 165                                 ortp_free(ts);
 166                                 return count;
 167                         }
 168                         if (ts->frecorder==NULL){
 169                                 ms_error("bench.c: missing recorder filter.");
 170                                 if (ts->fplayer) ms_filter_destroy(ts->fplayer);
 171                                 if (ts->encoder) ms_filter_destroy(ts->encoder);
 172                                 if (ts->rtpsend) ms_filter_destroy(ts->rtpsend);
 173                                 if (ts->rtprecv) ms_filter_destroy(ts->rtprecv);
 174                                 if (ts->decoder) ms_filter_destroy(ts->decoder);
 175                                 if (ts->frecorder) ms_filter_destroy(ts->frecorder);
 176                                 ortp_free(ts);
 177                                 return count;
 178                         }
 179                         if (ts->rtpsend==NULL){
 180                                 ms_error("bench.c: missing rtpsend filter.");
 181                                 if (ts->fplayer) ms_filter_destroy(ts->fplayer);
 182                                 if (ts->encoder) ms_filter_destroy(ts->encoder);
 183                                 if (ts->rtpsend) ms_filter_destroy(ts->rtpsend);
 184                                 if (ts->rtprecv) ms_filter_destroy(ts->rtprecv);
 185                                 if (ts->decoder) ms_filter_destroy(ts->decoder);
 186                                 if (ts->frecorder) ms_filter_destroy(ts->frecorder);
 187                                 ortp_free(ts);
 188                                 return count;
 189                         }
 190                         if (ts->rtprecv==NULL){
 191                                 ms_error("bench.c: missing rtprecv filter.");
 192                                 if (ts->fplayer) ms_filter_destroy(ts->fplayer);
 193                                 if (ts->encoder) ms_filter_destroy(ts->encoder);
 194                                 if (ts->rtpsend) ms_filter_destroy(ts->rtpsend);
 195                                 if (ts->rtprecv) ms_filter_destroy(ts->rtprecv);
 196                                 if (ts->decoder) ms_filter_destroy(ts->decoder);
 197                                 if (ts->frecorder) ms_filter_destroy(ts->frecorder);
 198                                 ortp_free(ts);
 199                                 return count;
 200                         }
 201
 202                         ms_filter_call_method(ts->rtpsend,MS_RTP_SEND_SET_SESSION,ts->rtps);
 203                         ms_filter_call_method(ts->rtprecv,MS_RTP_RECV_SET_SESSION,ts->rtps);
 204
 205                         ms_filter_call_method (ts->rtprecv, MS_FILTER_SET_SAMPLE_RATE,
 206                                                                    &pt->clock_rate);
 207
 208                         ms_filter_call_method (ts->frecorder, MS_FILTER_SET_SAMPLE_RATE,
 209                                                                    &pt->clock_rate);
 210
 211                         val = ms_filter_call_method(ts->fplayer,MS_FILE_PLAYER_OPEN,(void*)bench->wavfile);
 212                         if (val!=0)
 213                                 {
 214                                         ms_error("bench.c: Cannot open wav file (%s)", bench->wavfile);
 215                                         if (ts->fplayer) ms_filter_destroy(ts->fplayer);
 216                                         if (ts->encoder) ms_filter_destroy(ts->encoder);
 217                                         if (ts->rtpsend) ms_filter_destroy(ts->rtpsend);
 218                                         if (ts->rtprecv) ms_filter_destroy(ts->rtprecv);
 219                                         if (ts->decoder) ms_filter_destroy(ts->decoder);
 220                                         if (ts->frecorder) ms_filter_destroy(ts->frecorder);
 221                                         ortp_free(ts);
 222                                         return count;
 223                                 }
 224
 225                         val=0;
 226                         ms_filter_call_method (ts->fplayer, MS_FILTER_GET_SAMPLE_RATE,
 227                                                                    &val);
 228                         if (val!=pt->clock_rate)
 229                                 {
 230                                         ms_error("bench.c: unsupported rate for wav file: codec=%i / file=%i",
 231                                                          pt->clock_rate, val);
 232                                         if (ts->fplayer) ms_filter_destroy(ts->fplayer);
 233                                         if (ts->encoder) ms_filter_destroy(ts->encoder);
 234                                         if (ts->rtpsend) ms_filter_destroy(ts->rtpsend);
 235                                         if (ts->rtprecv) ms_filter_destroy(ts->rtprecv);
 236                                         if (ts->decoder) ms_filter_destroy(ts->decoder);
 237                                         if (ts->frecorder) ms_filter_destroy(ts->frecorder);
 238                                         ortp_free(ts);
 239                                         return count;
 240                                 }
 241                         ms_filter_call_method (ts->fplayer, MS_FILTER_GET_NCHANNELS,
 242                                                                    &val);
 243
 244                         if (val!=1)
 245                                 {
 246                                         ms_error("bench.c: unsupported number of channel for wav file: codec=1 / file=%i",
 247                                                          val);
 248                                         if (ts->fplayer) ms_filter_destroy(ts->fplayer);
 249                                         if (ts->encoder) ms_filter_destroy(ts->encoder);
 250                                         if (ts->rtpsend) ms_filter_destroy(ts->rtpsend);
 251                                         if (ts->rtprecv) ms_filter_destroy(ts->rtprecv);
 252                                         if (ts->decoder) ms_filter_destroy(ts->decoder);
 253                                         if (ts->frecorder) ms_filter_destroy(ts->frecorder);
 254                                         ortp_free(ts);
 255                                         return count;
 256                                 }
 257                         ms_filter_call_method_noarg(ts->fplayer,MS_FILE_PLAYER_START);
 258
 259                         if (strstr(bench->wavfile, ".au")==NULL)
 260                                 {
 261                                         ms_filter_link(ts->fplayer,0,ts->encoder,0);
 262                                         ms_filter_link(ts->encoder,0,ts->rtpsend,0);
 263                                 }
 264                         else
 265                                 {
 266                                         ms_filter_link(ts->fplayer,0,ts->rtpsend,0);
 267                                 }
 268
 269                         ms_filter_link(ts->rtprecv,0,ts->decoder,0);
 270                         ms_filter_link(ts->decoder,0,ts->frecorder,0);
 271
 272                         ms_ticker_attach(bench->ticker,ts->fplayer);
 273                         ms_ticker_attach(bench->ticker,ts->rtprecv);
 274
 275                         if (pos < bench->num_session_record)
 276                         {
 277                                 char rec_file[128];
 278                                 snprintf(rec_file, sizeof(rec_file), "rec_%s_%i.wav",
 279                                                  bench->ip_destination,
 280                                                  bench->port_destination+pos*2);
 281                                 ms_filter_call_method(ts->frecorder,MS_FILE_REC_OPEN,(void*)rec_file);
 282                                 ms_filter_call_method_noarg(ts->frecorder,MS_FILE_REC_START);
 283                         }
 284
 285                         bench->tsessions = ms_list_append(bench->tsessions, (void*)ts);
 286                         count++;
 287                 }
 288
 289         return count;
 290 }
 291
 292 static int uninit_bench(struct bench_config *bench)
 293 {
 294         MSList *it;
 295         for(it=bench->tsessions;it!=NULL;it=bench->tsessions){
 296                 struct test_session *ts = (struct test_session *)it->data;
 297                 bench->tsessions = ms_list_remove_link(bench->tsessions, it);
 298
 299                 ms_ticker_detach(bench->ticker,ts->fplayer);
 300                 ms_ticker_detach(bench->ticker,ts->rtprecv);
 301
 302                 ms_filter_call_method_noarg(ts->frecorder,MS_FILE_REC_CLOSE);
 303
 304                 if (strstr(bench->wavfile, ".au")==NULL)
 305                         {
 306                                 ms_filter_unlink(ts->fplayer,0,ts->encoder,0);
 307                                 ms_filter_unlink(ts->encoder,0,ts->rtpsend,0);
 308                         }
 309                 else
 310                         {
 311                                 ms_filter_unlink(ts->fplayer,0,ts->rtpsend,0);
 312                         }
 313
 314                 ms_filter_unlink(ts->rtprecv,0,ts->decoder,0);
 315                 ms_filter_unlink(ts->decoder,0,ts->frecorder,0);
 316
 317                 if (ts->fplayer) ms_filter_destroy(ts->fplayer);
 318                 if (ts->encoder) ms_filter_destroy(ts->encoder);
 319                 if (ts->rtpsend) ms_filter_destroy(ts->rtpsend);
 320
 321                 if (ts->rtprecv) ms_filter_destroy(ts->rtprecv);
 322                 if (ts->decoder) ms_filter_destroy(ts->decoder);
 323                 if (ts->frecorder) ms_filter_destroy(ts->frecorder);
 324
 325                 ortp_free(ts);
 326         }
 327
 328         ms_ticker_destroy(bench->ticker);
 329         return 0;
 330 }
 331
 332
 333 int main(int argc, char *argv[]){
 334         int pos;
 335         int count;
 336         ortp_init();
 337         ortp_set_log_level_mask(ORTP_MESSAGE|ORTP_WARNING|ORTP_ERROR|ORTP_FATAL);
 338         ms_init();
 339         rtp_profile_set_payload(&av_profile,115,&payload_type_lpc1015);
 340         rtp_profile_set_payload(&av_profile,110,&payload_type_speex_nb);
 341         rtp_profile_set_payload(&av_profile,111,&payload_type_speex_wb);
 342         rtp_profile_set_payload(&av_profile,112,&payload_type_ilbc);
 343
 344         signal(SIGINT,stop);
 345
 346         count=0;
 347         for (pos=0;cfg[pos].num_session!=0;pos++)
 348                 {
 349                         count = count + init_bench(&cfg[pos]);
 350                         ms_sleep(10);
 351                 }
 352
 353         ms_message("Number of session started: %i.", count);
 354
 355         while(run)
 356                 ms_sleep(1);
 357
 358         for (pos=0;cfg[pos].num_session!=0;pos++)
 359                 {
 360                         uninit_bench(&cfg[pos]);
 361                 }
 362
 363         return 0;
 364 }
 365