开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
fluidsynth.c
资源名称：trunk-r284.zip　[点击查看]
上传用户：tjmskj2
上传日期：2020-08-17
资源大小：577k
文件大小：24k
源码类别：

midi

开发平台：

C/C++

fluidsynth.c：源码内容
  1. /* FluidSynth - A Software Synthesizer
  2.  *
  3.  * Copyright (C) 2003  Peter Hanappe and others.
  4.  *
  5.  * This library is free software; you can redistribute it and/or
  6.  * modify it under the terms of the GNU Library General Public License
  7.  * as published by the Free Software Foundation; either version 2 of
  8.  * the License, or (at your option) any later version.
  9.  *
  10.  * This library is distributed in the hope that it will be useful, but
  11.  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13.  * Library General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU Library General Public
  16.  * License along with this library; if not, write to the Free
  17.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18.  * 02111-1307, USA
  19.  */
  21. #if HAVE_CONFIG_H
  22. #include "config.h"
  23. #endif
  25. #include <stdlib.h>
  26. #include <stdio.h>
  27. #include <string.h>
  29. #include "fluidsynth_priv.h"
  31. #if !defined(WIN32) && !defined(MACINTOSH)
  32. #define _GNU_SOURCE
  33. #include <getopt.h>
  34. #endif
  36. #include "fluidsynth.h"
  38. #if defined(WIN32) && !defined(MINGW32)
  39. #include "config_win32.h"
  40. #endif
  42. #ifdef HAVE_SIGNAL_H
  43. #include "signal.h"
  44. #endif
  46. #include "fluid_lash.h"
  48. #ifndef WITH_MIDI
  49. #define WITH_MIDI 1
  50. #endif
  52. void print_usage(void);
  53. void print_help(fluid_settings_t *settings);
  54. void print_welcome(void);
  56. static fluid_cmd_handler_t* newclient(void* data, char* addr);
  58. /*
  59.  * the globals
  60.  */
  61. fluid_cmd_handler_t* cmd_handler = NULL;
  62. int option_help = 0; /* set to 1 if "-o help" is specified */
  64. /*
  65.  * support for the getopt function
  66.  */
  67. #if !defined(WIN32) && !defined(MACINTOSH)
  68. #define GETOPT_SUPPORT 1
  69. int getopt(int argc, char * const argv[], const char *optstring);
  70. extern char *optarg;
  71. extern int optind, opterr, optopt;
  72. #endif
  75. /* Process a command line option -o setting=value, for example: -o synth.polyhony=16 */
  76. void process_o_cmd_line_option(fluid_settings_t* settings, char* optarg)
  77. {
  78.   char* val;
  79.   int hints;
  80.   int ival;
  82.   for (val = optarg; *val != ''; val++) {
  83.     if (*val == '=') {
  84.       *val++ = 0;
  85.       break;
  86.     }
  87.   }
  89.   /* did user request list of settings */
  90.   if (strcmp (optarg, "help") == 0)
  91.   {
  92.     option_help = 1;
  93.     return;
  94.   }
  96.   switch(fluid_settings_get_type(settings, optarg)){
  97.   case FLUID_NUM_TYPE:
  98.     if (!fluid_settings_setnum (settings, optarg, atof (val)))
  99.     {
  100.       fprintf (stderr, "Failed to set floating point parameter '%s'n", optarg);
  101.       exit (1);
  102.     }
  103.     break;
  104.   case FLUID_INT_TYPE:
  105.     hints = fluid_settings_get_hints (settings, optarg);
  107.     if (hints & FLUID_HINT_TOGGLED)
  108.     {
  109.       if (FLUID_STRCMP (val, "yes") == 0 || FLUID_STRCMP (val, "True") == 0
  110.           || FLUID_STRCMP (val, "TRUE") == 0 || FLUID_STRCMP (val, "true") == 0
  111.           || FLUID_STRCMP (val, "T") == 0)
  112.         ival = 1;
  113.       else ival = atoi (val);
  114.     }
  115.     else ival = atoi (val);
  117.     if (!fluid_settings_setint (settings, optarg, ival))
  118.     {
  119.       fprintf (stderr, "Failed to set integer parameter '%s'n", optarg);
  120.       exit (1);
  121.     }
  122.     break;
  123.   case FLUID_STR_TYPE:
  124.     if (!fluid_settings_setstr (settings, optarg, val))
  125.     {
  126.       fprintf (stderr, "Failed to set string parameter '%s'n", optarg);
  127.       exit (1);
  128.     }
  129.     break;
  130.   default:
  131.     fprintf (stderr, "Setting parameter '%s' not foundn", optarg);
  132.     exit (1);
  133.   }
  134. }
  136. static void
  137. print_pretty_int (int i)
  138. {
  139.   if (i == INT_MAX) printf ("MAXINT");
  140.   else if (i == INT_MIN) printf ("MININT");
  141.   else printf ("%d", i);
  142. }
  144. typedef struct
  145. {
  146.   int count;            /* Total count of options */
  147.   int curindex;         /* Current index in options */
  148. } OptionBag;
  150. /* Function to display each string option value */
  151. static void
  152. settings_option_foreach_func (void *data, char *name, char *option)
  153. {
  154.   OptionBag *bag = data;
  156.   bag->curindex++;
  158.   if (bag->curindex < bag->count)
  159.     printf ("'%s',", option);
  160.   else printf ("'%s'", option);
  161. }
  163. /* fluid_settings_foreach function for displaying option help  "-o help" */
  164. static void
  165. settings_foreach_func (void *data, char *name, int type)
  166. {
  167.   fluid_settings_t *settings = (fluid_settings_t *)data;
  168.   double dmin, dmax, ddef;
  169.   int imin, imax, idef, hints;
  170.   char *defstr;
  171.   int count;
  172.   OptionBag bag;
  174.   switch (type)
  175.   {
  176.   case FLUID_NUM_TYPE:
  177.     fluid_settings_getnum_range (settings, name, &dmin, &dmax);
  178.     ddef = fluid_settings_getnum_default (settings, name);
  179.     printf ("%-24s FLOAT [min=%0.3f, max=%0.3f, def=%0.3f]n",
  180.     name, dmin, dmax, ddef);
  181.     break;
  182.   case FLUID_INT_TYPE:
  183.     fluid_settings_getint_range (settings, name, &imin, &imax);
  184.     idef = fluid_settings_getint_default (settings, name);
  185.     hints = fluid_settings_get_hints (settings, name);
  187.     if (!(hints & FLUID_HINT_TOGGLED))
  188.     {
  189.       printf ("%-24s INT   [min=", name);
  190.       print_pretty_int (imin);
  191.       printf (", max=");
  192.       print_pretty_int (imax);
  193.       printf (", def=");
  194.       print_pretty_int (idef);
  195.       printf ("]n");
  196.     }
  197.     else printf ("%-24s BOOL  [def=%s]n", name, idef ? "True" : "False");
  198.     break;
  199.   case FLUID_STR_TYPE:
  200.     printf ("%-24s STR", name);
  202.     defstr = fluid_settings_getstr_default (settings, name);
  203.     count = fluid_settings_option_count (settings, name);
  205.     if (defstr || count > 0)
  206.     {
  207.       if (defstr && count > 0) printf ("   [def='%s' vals:", defstr);
  208.       else if (defstr) printf ("   [def='%s'", defstr);
  209.       else printf ("   [vals:");
  211.       if (count > 0)
  212.       {
  213.         bag.count = count;
  214.         bag.curindex = 0;
  215.         fluid_settings_foreach_option (settings, name, &bag,
  216.                                        settings_option_foreach_func);
  217.       }
  219.       printf ("]n");
  220.     }
  221.     else printf ("n");
  222.     break;
  223.   case FLUID_SET_TYPE:
  224.     printf ("%-24s SETn", name);
  225.     break;
  226.   }
  227. }
  229. /* Output options for a setting string to stdout */
  230. static void
  231. show_settings_str_options (fluid_settings_t *settings, char *name)
  232. {
  233.   OptionBag bag;
  235.   bag.count = fluid_settings_option_count (settings, name);
  236.   bag.curindex = 0;
  237.   fluid_settings_foreach_option (settings, name, &bag,
  238.                                  settings_option_foreach_func);
  239.   printf ("n");
  240. }
  242. static void
  243. fast_render_loop(fluid_settings_t* settings, fluid_synth_t* synth, fluid_player_t* player)
  244. {
  245.   fluid_file_renderer_t* renderer;
  247.   renderer = new_fluid_file_renderer (synth);
  248.   if (!renderer) return;
  250.   while (fluid_player_get_status(player) == FLUID_PLAYER_PLAYING) {
  251.     if (fluid_file_renderer_process_block(renderer) != FLUID_OK) {
  252.       break;
  253.     }
  254.   }
  255.   delete_fluid_file_renderer(renderer);
  256. }
  258. #ifdef HAVE_SIGNAL_H
  259. /*
  260.  * handle_signal
  261.  */
  262. void handle_signal(int sig_num)
  263. {
  264. }
  265. #endif
  268. /*
  269.  * main
  270.  */
  271. int main(int argc, char** argv)
  272. {
  273.   fluid_settings_t* settings;
  274.   int arg1 = 1;
  275.   char buf[512];
  276.   int c, i;
  277.   int interactive = 1;
  278.   int midi_in = 1;
  279.   fluid_player_t* player = NULL;
  280.   fluid_midi_router_t* router = NULL;
  281.   //fluid_sequencer_t* sequencer = NULL;
  282.   fluid_midi_driver_t* mdriver = NULL;
  283.   fluid_audio_driver_t* adriver = NULL;
  284.   fluid_synth_t* synth = NULL;
  285.   fluid_server_t* server = NULL;
  286.   char* config_file = NULL;
  287.   int audio_groups = 0;
  288.   int audio_channels = 0;
  289.   int with_server = 0;
  290.   int dump = 0;
  291.   int fast_render = 0;
  292.   int connect_lash = 1;
  293.   char *optchars = "a:C:c:dE:f:F:G:g:hijK:L:lm:nO:o:p:R:r:sT:Vvz:";
  294. #ifdef LASH_ENABLED
  295.   int enabled_lash = 0; /* set to TRUE if lash gets enabled */
  296.   fluid_lash_args_t *lash_args;
  298.   lash_args = fluid_lash_extract_args (&argc, &argv);
  299. #endif
  301.   print_welcome ();
  303.   settings = new_fluid_settings();
  305. #ifdef GETOPT_SUPPORT /* pre section of GETOPT supported argument handling */
  306.   opterr = 0;
  308.   while (1) {
  309.     int option_index = 0;
  311.     static struct option long_options[] = {
  312.       {"audio-bufcount", 1, 0, 'c'},
  313.       {"audio-bufsize", 1, 0, 'z'},
  314.       {"audio-channels", 1, 0, 'L'},
  315.       {"audio-driver", 1, 0, 'a'},
  316.       {"audio-file-endian", 1, 0, 'E'},
  317.       {"audio-file-format", 1, 0, 'O'},
  318.       {"audio-file-type", 1, 0, 'T'},
  319.       {"audio-groups", 1, 0, 'G'},
  320.       {"chorus", 1, 0, 'C'},
  321.       {"connect-jack-outputs", 0, 0, 'j'},
  322.       {"disable-lash", 0, 0, 'l'},
  323.       {"dump", 0, 0, 'd'},
  324.       {"fast-render", 1, 0, 'F'},
  325.       {"gain", 1, 0, 'g'},
  326.       {"help", 0, 0, 'h'},
  327.       {"load-config", 1, 0, 'f'},
  328.       {"midi-channels", 1, 0, 'K'},
  329.       {"midi-driver", 1, 0, 'm'},
  330.       {"no-midi-in", 0, 0, 'n'},
  331.       {"no-shell", 0, 0, 'i'},
  332.       {"option", 1, 0, 'o'},
  333.       {"portname", 1, 0, 'p'},
  334.       {"reverb", 1, 0, 'R'},
  335.       {"sample-rate", 1, 0, 'r'},
  336.       {"server", 0, 0, 's'},
  337.       {"verbose", 0, 0, 'v'},
  338.       {"version", 0, 0, 'V'},
  339.       {0, 0, 0, 0}
  340.     };
  342.     c = getopt_long(argc, argv, optchars, long_options, &option_index);
  343.     if (c == -1) {
  344.       break;
  345.     }
  346. #else /* "pre" section to non getopt argument handling */
  347.   for (i = 1; i < argc; i++) {
  348.     char *optarg;
  350.     /* Skip non switch arguments (assume they are file names) */
  351.     if ((argv[i][0] != '-') || (argv[i][1] == '')) break;
  353.     c = argv[i][1];
  355.     optarg = strchr (optchars, c); /* find the option character in optchars */
  356.     if (optarg && optarg[1] == ':') /* colon follows if switch argument expected */
  357.     {
  358.       if (++i >= argc)
  359.       {
  360. printf ("Option -%c requires an argumentn", c);
  361. print_usage();
  362. exit(0);
  363.       }
  364.       else
  365.       {
  366. optarg = argv[i];
  367. if (optarg[0] == '-')
  368. {
  369.   printf ("Expected argument to option -%c found switch insteadn", c);
  370.   print_usage();
  371.   exit(0);
  372. }
  373.       }
  374.     }
  375.     else optarg = "";
  376. #endif
  378.     switch (c) {
  379. #ifdef GETOPT_SUPPORT
  380.     case 0: /* shouldn't normally happen, a long option's flag is set to NULL */
  381.       printf ("option %s", long_options[option_index].name);
  382.       if (optarg) {
  383. printf (" with arg %s", optarg);
  384.       }
  385.       printf ("n");
  386.       break;
  387. #endif
  388.     case 'a':
  389.       if (FLUID_STRCMP (optarg, "help") == 0)
  390.       {
  391.         printf ("-a options (audio driver):n   ");
  392.         show_settings_str_options (settings, "audio.driver");
  393.         exit (0);
  394.       }
  395.       else fluid_settings_setstr(settings, "audio.driver", optarg);
  396.       break;
  397.     case 'C':
  398.       if ((optarg != NULL) && ((strcmp(optarg, "0") == 0) || (strcmp(optarg, "no") == 0))) {
  399. fluid_settings_setint(settings, "synth.chorus.active", FALSE);
  400.       } else {
  401. fluid_settings_setint(settings, "synth.chorus.active", TRUE);
  402.       }
  403.       break;
  404.     case 'c':
  405.       fluid_settings_setint(settings, "audio.periods", atoi(optarg));
  406.       break;
  407.     case 'd':
  408.       fluid_settings_setint(settings, "synth.dump", TRUE);
  409.       dump = 1;
  410.       break;
  411.     case 'E':
  412.       if (FLUID_STRCMP (optarg, "help") == 0)
  413.       {
  414.         printf ("-E options (audio file byte order):n   ");
  415.         show_settings_str_options (settings, "audio.file.endian");
  417. #if LIBSNDFILE_SUPPORT
  418.         printf ("nauto: Use audio file format's default endian byte ordern"
  419.                 "cpu: Use CPU native byte ordern");
  420. #else
  421.         printf ("nNOTE: No libsndfile support!n"
  422.                 "cpu: Use CPU native byte ordern");
  423. #endif
  424.         exit (0);
  425.       }
  426.       else fluid_settings_setstr(settings, "audio.file.endian", optarg);
  427.       break;
  428.     case 'f':
  429.       config_file = optarg;
  430.       break;
  431.     case 'F':
  432.       fluid_settings_setstr(settings, "audio.file.name", optarg);
  433.       fast_render = 1;
  434.       break;
  435.     case 'G':
  436.       audio_groups = atoi(optarg);
  437.       break;
  438.     case 'g':
  439.       fluid_settings_setnum(settings, "synth.gain", atof(optarg));
  440.       break;
  441.     case 'h':
  442.       print_help(settings);
  443.       break;
  444.     case 'i':
  445.       interactive = 0;
  446.       break;
  447.     case 'j':
  448.       fluid_settings_setint(settings, "audio.jack.autoconnect", 1);
  449.       break;
  450.     case 'K':
  451.       fluid_settings_setint(settings, "synth.midi-channels", atoi(optarg));
  452.       break;
  453.     case 'L':
  454.       audio_channels = atoi(optarg);
  455.       fluid_settings_setint(settings, "synth.audio-channels", audio_channels);
  456.       break;
  457.     case 'l': /* disable LASH */
  458.       connect_lash = 0;
  459.       break;
  460.     case 'm':
  461.       if (FLUID_STRCMP (optarg, "help") == 0)
  462.       {
  463.         printf ("-m options (MIDI driver):n   ");
  464.         show_settings_str_options (settings, "midi.driver");
  465.         exit (0);
  466.       }
  467.       else fluid_settings_setstr(settings, "midi.driver", optarg);
  468.       break;
  469.     case 'n':
  470.       midi_in = 0;
  471.       break;
  472.     case 'O':
  473.       if (FLUID_STRCMP (optarg, "help") == 0)
  474.       {
  475.         printf ("-O options (audio file format):n   ");
  476.         show_settings_str_options (settings, "audio.file.format");
  478. #if LIBSNDFILE_SUPPORT
  479.         printf ("ns8, s16, s24, s32: Signed PCM audio of the given number of bitsn");
  480.         printf ("float, double: 32 bit and 64 bit floating point audion");
  481.         printf ("u8: Unsigned 8 bit audion");
  482. #else
  483.         printf ("nNOTE: No libsndfile support!n");
  484. #endif
  485.         exit (0);
  486.       }
  487.       else fluid_settings_setstr(settings, "audio.file.format", optarg);
  488.       break;
  489.     case 'o':
  490.       process_o_cmd_line_option(settings, optarg);
  491.       break;
  492.     case 'p' :
  493.       fluid_settings_setstr(settings, "midi.portname", optarg);
  494.       break;
  495.     case 'R':
  496.       if ((optarg != NULL) && ((strcmp(optarg, "0") == 0) || (strcmp(optarg, "no") == 0))) {
  497. fluid_settings_setint(settings, "synth.reverb.active", FALSE);
  498.       } else {
  499. fluid_settings_setint(settings, "synth.reverb.active", TRUE);
  500.       }
  501.       break;
  502.     case 'r':
  503.       fluid_settings_setnum(settings, "synth.sample-rate", atof(optarg));
  504.       break;
  505.     case 's':
  506.       with_server = 1;
  507.       break;
  508.     case 'T':
  509.       if (FLUID_STRCMP (optarg, "help") == 0)
  510.       {
  511.         printf ("-T options (audio file type):n   ");
  512.         show_settings_str_options (settings, "audio.file.type");
  514. #if LIBSNDFILE_SUPPORT
  515.         printf ("nauto: Determine type from file name extension, defaults to "wav"n");
  516. #else
  517.         printf ("nNOTE: No libsndfile support!n");
  518. #endif
  519.         exit (0);
  520.       }
  521.       else fluid_settings_setstr(settings, "audio.file.type", optarg);
  522.       break;
  523.     case 'V':
  524.       printf("FluidSynth %sn", VERSION);
  525.       exit (0);
  526.       break;
  527.     case 'v':
  528.       fluid_settings_setint(settings, "synth.verbose", TRUE);
  529.       break;
  530.     case 'z':
  531.       fluid_settings_setint(settings, "audio.period-size", atoi(optarg));
  532.       break;
  533. #ifdef GETOPT_SUPPORT
  534.     case '?':
  535.       printf ("Unknown option %cn", optopt);
  536.       print_usage();
  537.       exit(0);
  538.       break;
  539.     default:
  540.       printf ("?? getopt returned character code 0%o ??n", c);
  541.       break;
  542. #else /* Non getopt default case */
  543.     default:
  544.       printf ("Unknown switch '%c'n", c);
  545.       print_usage();
  546.       exit(0);
  547.       break;
  548. #endif
  549.     } /* end of switch statement */
  550.   } /* end of loop */
  552. #ifdef GETOPT_SUPPORT
  553.   arg1 = optind;
  554. #else
  555.   arg1 = i;
  556. #endif
  558.   /* option help requested?  "-o help" */
  559.   if (option_help)
  560.   {
  561.     printf ("FluidSynth settings:n");
  562.     fluid_settings_foreach (settings, settings, settings_foreach_func);
  563.     exit (0);
  564.   }
  566. #ifdef WIN32
  567.   SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);
  568. #endif
  570. #ifdef LASH_ENABLED
  571.   /* connect to the lash server */
  572.   if (connect_lash)
  573.     {
  574.       enabled_lash = fluid_lash_connect (lash_args);
  575.       fluid_settings_setint (settings, "lash.enable", enabled_lash ? 1 : 0);
  576.     }
  577. #endif
  579.   /* The 'groups' setting is only relevant for LADSPA operation
  580.    * If not given, set number groups to number of audio channels, because
  581.    * they are the same (there is nothing between synth output and 'sound card')
  582.    */
  583.   if ((audio_groups == 0) && (audio_channels != 0)) {
  584.       audio_groups = audio_channels;
  585.   }
  586.   fluid_settings_setint(settings, "synth.audio-groups", audio_groups);
  588.   /* create the synthesizer */
  589.   synth = new_fluid_synth(settings);
  590.   if (synth == NULL) {
  591.     fprintf(stderr, "Failed to create the synthesizern");
  592.     exit(-1);
  593.   }
  595.   cmd_handler = new_fluid_cmd_handler(synth);
  596.   if (cmd_handler == NULL) {
  597.     fprintf(stderr, "Failed to create the command handlern");
  598.     goto cleanup;
  599.   }
  601.   /* load the soundfonts (check that all non options are SoundFont or MIDI files) */
  602.   for (i = arg1; i < argc; i++) {
  603.     if (fluid_is_soundfont(argv[i]))
  604.     {
  605.       if (fluid_synth_sfload(synth, argv[i], 1) == -1)
  606. fprintf(stderr, "Failed to load the SoundFont %sn", argv[i]);
  607.     }
  608.     else if (!fluid_is_midifile(argv[i]))
  609.       fprintf (stderr, "Parameter '%s' not a SoundFont or MIDI file or error occurred identifying it.n",
  610.        argv[i]);
  611.   }
  613. #ifdef HAVE_SIGNAL_H
  614. /*   signal(SIGINT, handle_signal); */
  615. #endif
  617.   if (fast_render) {
  618.     midi_in = 0;
  619.     interactive = 0;
  620.     with_server = 0;
  621.     fluid_settings_setstr(settings, "player.timing-source", "sample");    
  622.   }
  624.   /* start the synthesis thread */
  625.   if (!fast_render) {
  626.     adriver = new_fluid_audio_driver(settings, synth);
  627.     if (adriver == NULL) {
  628.       fprintf(stderr, "Failed to create the audio drivern");
  629.       goto cleanup;
  630.     }
  631.   }
  634.   /* start the midi router and link it to the synth */
  635. #if WITH_MIDI
  636.   if (midi_in) {
  637.     /* In dump mode, text output is generated for events going into and out of the router.
  638.      * The example dump functions are put into the chain before and after the router..
  639.      */
  640.     //sequencer = new_fluid_sequencer2(0);
  642.     router = new_fluid_midi_router(
  643.       settings,
  644.       dump ? fluid_midi_dump_postrouter : fluid_synth_handle_midi_event,
  645.       (void*)synth);
  647.     if (router == NULL) {
  648.       fprintf(stderr, "Failed to create the MIDI input router; no MIDI inputn"
  649.       "will be available. You can access the synthesizer n"
  650.       "through the console.n");
  651.     } else {
  652.       fluid_synth_set_midi_router(synth, router); /* Fixme, needed for command handler */
  653. //      fluid_sequencer_register_fluidsynth(sequencer, synth);
  654.       mdriver = new_fluid_midi_driver(
  655. settings,
  656. dump ? fluid_midi_dump_prerouter : fluid_midi_router_handle_midi_event,
  657. (void*) router);
  658.       if (mdriver == NULL) {
  659. fprintf(stderr, "Failed to create the MIDI thread; no MIDI inputn"
  660. "will be available. You can access the synthesizer n"
  661. "through the console.n");
  662.       }
  663.     }
  664.   }
  665. #endif
  667.   /* run commands specified in config file */
  668.   if (config_file != NULL) {
  669.     fluid_source(cmd_handler, config_file);
  670.   } else if (fluid_get_userconf(buf, 512) != NULL) {
  671.     fluid_source(cmd_handler, buf);
  672.   } else if (fluid_get_sysconf(buf, 512) != NULL) {
  673.     fluid_source(cmd_handler, buf);
  674.   }
  678.   /* play the midi files, if any */
  679.   for (i = arg1; i < argc; i++) {
  680.     if ((argv[i][0] != '-') && fluid_is_midifile(argv[i])) {
  682.       if (player == NULL) {
  683. player = new_fluid_player(synth);
  684. if (player == NULL) {
  685.   fprintf(stderr, "Failed to create the midifile player.n"
  686.   "Continuing without a player.n");
  687.   break;
  688. }
  689.       }
  691.       fluid_player_add(player, argv[i]);
  692.     }
  693.   }
  695.   if (player != NULL) {
  696.     fluid_player_play(player);
  697.   }
  699.   /* run the server, if requested */
  700. #if !defined(MACINTOSH)
  701.   if (with_server) {
  702.     server = new_fluid_server(settings, newclient, synth);
  703.     if (server == NULL) {
  704.       fprintf(stderr, "Failed to create the server.n"
  705.      "Continuing without it.n");
  706.     }
  707.   }
  708. #endif
  711. #ifdef LASH_ENABLED
  712.   if (enabled_lash)
  713.     fluid_lash_create_thread (synth);
  714. #endif
  716.   /* run the shell */
  717.   if (interactive) {
  718.     printf ("Type 'help' for help topics.nn");
  720.     /* In dump mode we set the prompt to "". The UI cannot easily
  721.      * handle lines, which don't end with CR.  Changing the prompt
  722.      * cannot be done through a command, because the current shell
  723.      * does not handle empty arguments.  The ordinary case is dump ==
  724.      * 0.
  725.      */
  726.     fluid_settings_setstr(settings, "shell.prompt", dump ? "" : "> ");
  727.     fluid_usershell(settings, cmd_handler);
  728.   }
  730.   if (fast_render) {
  731.     char *filename;
  733.     fluid_settings_dupstr (settings, "audio.file.name", &filename);
  734.     printf ("Rendering audio to file '%s'..n", filename);
  735.     if (filename) FLUID_FREE (filename);
  737.     fast_render_loop(settings, synth, player);
  738.   }
  740.  cleanup:
  742. #if !defined(MACINTOSH) && !defined(WIN32)
  743.   if (server != NULL) {
  744.     /* if the user typed 'quit' in the shell, kill the server */
  745.     if (!interactive) {
  746.       fluid_server_join(server);
  747.     }
  748.     delete_fluid_server(server);
  749.   }
  750. #endif
  752.   if (cmd_handler != NULL) {
  753.     delete_fluid_cmd_handler(cmd_handler);
  754.   }
  756.   if (player != NULL) {
  757.     /* if the user typed 'quit' in the shell, stop the player */
  758.     if (interactive) {
  759.       fluid_player_stop(player);
  760.     }
  761.     if (adriver != NULL || !fluid_settings_str_equal(settings,  "player.timing-source", "sample")) {
  762.       /* if no audio driver and sample timers are used, nothing makes the player advance */  
  763.       fluid_player_join(player);
  764.     }
  765.     delete_fluid_player(player);
  766.   }
  768.   if (router) {
  769. #if WITH_MIDI
  770.     if (mdriver) {
  771.       delete_fluid_midi_driver(mdriver);
  772.     }
  773.     delete_fluid_midi_router(router);
  774. #endif
  775.   }
  777.   /*if (sequencer) {
  778.     delete_fluid_sequencer(sequencer);
  779.   }*/
  781.   if (adriver) {
  782.     delete_fluid_audio_driver(adriver);
  783.   }
  785.   if (synth) {
  786.     delete_fluid_synth(synth);
  787.   }
  789.   if (settings) {
  790.     delete_fluid_settings(settings);
  791.   }
  793.   return 0;
  794. }
  796. static fluid_cmd_handler_t* newclient(void* data, char* addr)
  797. {
  798.   fluid_synth_t* synth = (fluid_synth_t*) data;
  799.   return new_fluid_cmd_handler(synth);
  800. }
  803. /*
  804.  * print_usage
  805.  */
  806. void
  807. print_usage()
  808. {
  809.   fprintf(stderr, "Usage: fluidsynth [options] [soundfonts]n");
  810.   fprintf(stderr, "Try -h for help.n");
  811.   exit(0);
  812. }
  814. void
  815. print_welcome()
  816. {
  817.   printf("FluidSynth version %sn"
  818.  "Copyright (C) 2000-2009 Peter Hanappe and others.n"
  819.  "Distributed under the LGPL license.n"
  820.  "SoundFont(R) is a registered trademark of E-mu Systems, Inc.nn",
  821.  FLUIDSYNTH_VERSION);
  822. }
  824. /*
  825.  * print_help
  826.  */
  827. void
  828. print_help (fluid_settings_t *settings)
  829. {
  830.   char *audio_options;
  831.   char *midi_options;
  833.   audio_options = fluid_settings_option_concat (settings, "audio.driver", NULL);
  834.   midi_options = fluid_settings_option_concat (settings, "midi.driver", NULL);
  836.   printf("Usage: n");
  837.   printf("  fluidsynth [options] [soundfonts] [midifiles]n");
  838.   printf("Possible options:n");
  839.   printf(" -a, --audio-driver=[label]n"
  840.  "    The name of the audio driver to use.n"
  841.  "    Valid values: %sn", audio_options ? audio_options : "ERROR");
  842.   printf(" -c, --audio-bufcount=[count]n"
  843.  "    Number of audio buffersn");
  844.   printf(" -C, --chorusn"
  845.  "    Turn the chorus on or off [0|1|yes|no, default = on]n");
  846.   printf(" -d, --dumpn"
  847.  "    Dump incoming and outgoing MIDI events to stdoutn");
  848.   printf(" -E, --audio-file-endiann"
  849.  "    Audio file endian for fast rendering or aufile driver ("help" for list)n");
  850.   printf(" -f, --load-confign"
  851.  "    Load command configuration file (shell commands)n");
  852.   printf(" -F, --fast-render=[file]n"
  853.  "    Render MIDI file to raw audio data and store in [file]n");
  854.   printf(" -g, --gainn"
  855.  "    Set the master gain [0 < gain < 10, default = 0.2]n");
  856.   printf(" -G, --audio-groupsn"
  857.  "    Defines the number of LADSPA audio nodesn");
  858.   printf(" -h, --helpn"
  859.  "    Print out this help summaryn");
  860.   printf(" -i, --no-shelln"
  861.  "    Don't read commands from the shell [default = yes]n");
  862.   printf(" -j, --connect-jack-outputsn"
  863.  "    Attempt to connect the jack outputs to the physical portsn");
  864.   printf(" -K, --midi-channels=[num]n"
  865.  "    The number of midi channels [default = 16]n");
  866. #ifdef LASH_ENABLED
  867.   printf(" -l, --disable-lashn"
  868.  "    Don't connect to LASH servern");
  869. #endif
  870.   printf(" -L, --audio-channels=[num]n"
  871.  "    The number of stereo audio channels [default = 1]n");
  872.   printf(" -m, --midi-driver=[label]n"
  873.  "    The name of the midi driver to use.n"
  874.  "    Valid values: %sn", midi_options ? midi_options : "ERROR");
  875.   printf(" -n, --no-midi-inn"
  876.  "    Don't create a midi driver to read MIDI input events [default = yes]n");
  877.   printf(" -on"
  878.  "    Define a setting, -o name=value ("-o help" to dump current values)n");
  879.   printf(" -O, --audio-file-formatn"
  880.  "    Audio file format for fast rendering or aufile driver ("help" for list)n");
  881.   printf(" -p, --portname=[label]n"
  882.  "    Set MIDI port name (alsa_seq, coremidi drivers)n");
  883.   printf(" -r, --sample-raten"
  884.  "    Set the sample raten");
  885.   printf(" -R, --reverbn"
  886.  "    Turn the reverb on or off [0|1|yes|no, default = on]n");
  887.   printf(" -s, --servern"
  888.  "    Start FluidSynth as a server processn");
  889.   printf(" -T, --audio-file-typen"
  890.  "    Audio file type for fast rendering or aufile driver ("help" for list)n");
  891.   printf(" -v, --verbosen"
  892.  "    Print out verbose messages about midi eventsn");
  893.   printf(" -V, --versionn"
  894.  "    Show version of programn");
  895.   printf(" -z, --audio-bufsize=[size]n"
  896.  "    Size of each audio buffern");
  898.   if (audio_options) FLUID_FREE (audio_options);
  899.   if (midi_options) FLUID_FREE (midi_options);
  901.   delete_fluid_settings (settings);
  903.   exit(0);
  904. }