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

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

midi

开发平台：

C/C++

fluid_cmd.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. #include "fluidsynth_priv.h"
  22. #include "fluid_cmd.h"
  23. #include "fluid_synth.h"
  24. #include "fluid_settings.h"
  25. #include "fluid_hash.h"
  26. #include "fluid_sys.h"
  27. #include "fluid_midi_router.h"
  28. #include "fluid_sfont.h"
  29. #include "fluid_chan.h"
  31. #if WITH_READLINE
  32. #include <readline/readline.h>
  33. #include <readline/history.h>
  34. #endif
  36. #define MAX_TOKENS 100 /* LADSPA plugins need lots of parameters */
  37. #define MAX_COMMAND_LEN 1024 /* max command length accepted by fluid_command() */
  38. #define FLUID_WORKLINELENGTH 1024 /* LADSPA plugins use long command lines */
  40. struct _fluid_shell_t {
  41.   fluid_settings_t* settings;
  42.   fluid_cmd_handler_t* handler;
  43.   fluid_thread_t* thread;
  44.   fluid_istream_t in;
  45.   fluid_ostream_t out;
  46. };
  48. static int fluid_shell_run(fluid_shell_t* shell);
  49. static void fluid_shell_init(fluid_shell_t* shell,
  50.                              fluid_settings_t* settings, fluid_cmd_handler_t* handler,
  51.                              fluid_istream_t in, fluid_ostream_t out);
  52. static int fluid_handle_voice_count (fluid_synth_t *synth, int ac, char **av,
  53.                                      fluid_ostream_t out);
  55. void fluid_shell_settings(fluid_settings_t* settings)
  56. {
  57.   fluid_settings_register_str(settings, "shell.prompt", "", 0, NULL, NULL);
  58.   fluid_settings_register_int(settings, "shell.port", 9800, 1, 65535, 0, NULL, NULL);
  59. }
  62. /** the table of all handled commands */
  64. fluid_cmd_t fluid_commands[] = {
  65.   { "help", "general", (fluid_cmd_func_t) fluid_handle_help, NULL,
  66.     "help                       Show help topics ('help TOPIC' for more info)" },
  67.   { "quit", "general", (fluid_cmd_func_t) fluid_handle_quit, NULL,
  68.     "quit                       Quit the synthesizer" },
  69.   { "noteon", "event", (fluid_cmd_func_t) fluid_handle_noteon, NULL,
  70.     "noteon chan key vel        Send noteon" },
  71.   { "noteoff", "event", (fluid_cmd_func_t) fluid_handle_noteoff, NULL,
  72.     "noteoff chan key           Send noteoff"  },
  73.   { "pitch_bend", "event", (fluid_cmd_func_t) fluid_handle_pitch_bend, NULL,
  74.     "pitch_bend chan offset           Bend pitch"  },
  75.   { "pitch_bend_range", "event", (fluid_cmd_func_t) fluid_handle_pitch_bend_range, NULL,
  76.     "pitch_bend chan range           Set bend pitch range"  },
  77.   { "cc", "event", (fluid_cmd_func_t) fluid_handle_cc, NULL,
  78.     "cc chan ctrl value         Send control-change message" },
  79.   { "prog", "event", (fluid_cmd_func_t) fluid_handle_prog, NULL,
  80.     "prog chan num              Send program-change message" },
  81.   { "select", "event", (fluid_cmd_func_t) fluid_handle_select, NULL,
  82.     "select chan sfont bank prog  Combination of bank-select and program-change" },
  83.   { "load", "general", (fluid_cmd_func_t) fluid_handle_load, NULL,
  84.     "load file [reset] [bankofs] Load SoundFont (reset=0|1, def 1; bankofs=n, def 0)" },
  85.   { "unload", "general", (fluid_cmd_func_t) fluid_handle_unload, NULL,
  86.     "unload id [reset]          Unload SoundFont by ID (reset=0|1, default 1)"},
  87.   { "reload", "general", (fluid_cmd_func_t) fluid_handle_reload, NULL,
  88.     "reload id                  Reload the SoundFont with the specified ID" },
  89.   { "fonts", "general", (fluid_cmd_func_t) fluid_handle_fonts, NULL,
  90.     "fonts                      Display the list of loaded SoundFonts" },
  91.   { "inst", "general", (fluid_cmd_func_t) fluid_handle_inst, NULL,
  92.     "inst font                  Print out the available instruments for the font" },
  93.   { "channels", "general", (fluid_cmd_func_t) fluid_handle_channels, NULL,
  94.     "channels [-verbose]        Print out preset of all channels" },
  95.   { "interp", "general", (fluid_cmd_func_t) fluid_handle_interp, NULL,
  96.     "interp num                 Choose interpolation method for all channels" },
  97.   { "interpc", "general", (fluid_cmd_func_t) fluid_handle_interpc, NULL,
  98.     "interpc chan num           Choose interpolation method for one channel" },
  99.   { "rev_preset", "reverb", (fluid_cmd_func_t) fluid_handle_reverbpreset, NULL,
  100.     "rev_preset num             Load preset num into the reverb unit" },
  101.   { "rev_setroomsize", "reverb", (fluid_cmd_func_t) fluid_handle_reverbsetroomsize, NULL,
  102.     "rev_setroomsize num        Change reverb room size" },
  103.   { "rev_setdamp", "reverb", (fluid_cmd_func_t) fluid_handle_reverbsetdamp, NULL,
  104.     "rev_setdamp num            Change reverb damping" },
  105.   { "rev_setwidth", "reverb", (fluid_cmd_func_t) fluid_handle_reverbsetwidth, NULL,
  106.     "rev_setwidth num           Change reverb width" },
  107.   { "rev_setlevel", "reverb", (fluid_cmd_func_t) fluid_handle_reverbsetlevel, NULL,
  108.     "rev_setlevel num           Change reverb level" },
  109.   { "reverb", "reverb", (fluid_cmd_func_t) fluid_handle_reverb, NULL,
  110.     "reverb [0|1|on|off]        Turn the reverb on or off" },
  111.   { "cho_set_nr", "chorus", (fluid_cmd_func_t) fluid_handle_chorusnr, NULL,
  112.     "cho_set_nr n               Use n delay lines (default 3)" },
  113.   { "cho_set_level", "chorus", (fluid_cmd_func_t) fluid_handle_choruslevel, NULL,
  114.     "cho_set_level num          Set output level of each chorus line to num" },
  115.   { "cho_set_speed", "chorus", (fluid_cmd_func_t) fluid_handle_chorusspeed, NULL,
  116.     "cho_set_speed num          Set mod speed of chorus to num (Hz)" },
  117.   { "cho_set_depth", "chorus", (fluid_cmd_func_t) fluid_handle_chorusdepth, NULL,
  118.     "cho_set_depth num          Set chorus modulation depth to num (ms)" },
  119.   { "chorus", "chorus", (fluid_cmd_func_t) fluid_handle_chorus, NULL,
  120.     "chorus [0|1|on|off]        Turn the chorus on or off" },
  121.   { "gain", "general", (fluid_cmd_func_t) fluid_handle_gain, NULL,
  122.     "gain value                 Set the master gain (0 < gain < 5)" },
  123.   { "voice_count", "general", (fluid_cmd_func_t) fluid_handle_voice_count, NULL,
  124.     "voice_count                Get number of active synthesis voices" },
  125.   { "tuning", "tuning", (fluid_cmd_func_t) fluid_handle_tuning, NULL,
  126.     "tuning name bank prog      Create a tuning with name, bank number, n"
  127.     "                           and program number (0 <= bank,prog <= 127)" },
  128.   { "tune", "tuning", (fluid_cmd_func_t) fluid_handle_tune, NULL,
  129.     "tune bank prog key pitch   Tune a key" },
  130.   { "settuning", "tuning", (fluid_cmd_func_t) fluid_handle_settuning, NULL,
  131.     "settuning chan bank prog   Set the tuning for a MIDI channel" },
  132.   { "resettuning", "tuning", (fluid_cmd_func_t) fluid_handle_resettuning, NULL,
  133.     "resettuning chan           Restore the default tuning of a MIDI channel" },
  134.   { "tunings", "tuning", (fluid_cmd_func_t) fluid_handle_tunings, NULL,
  135.     "tunings                    Print the list of available tunings" },
  136.   { "dumptuning", "tuning", (fluid_cmd_func_t) fluid_handle_dumptuning, NULL,
  137.     "dumptuning bank prog       Print the pitch details of the tuning" },
  138.   { "reset", "general", (fluid_cmd_func_t) fluid_handle_reset, NULL,
  139.     "reset                      System reset (all notes off, reset controllers)" },
  140.   { "set", "settings", (fluid_cmd_func_t) fluid_handle_set, NULL,
  141.     "set name value             Set the value of a controller or settings" },
  142.   { "get", "settings", (fluid_cmd_func_t) fluid_handle_get, NULL,
  143.     "get name                   Get the value of a controller or settings" },
  144.   { "info", "settings", (fluid_cmd_func_t) fluid_handle_info, NULL,
  145.     "info name                  Get information about a controller or settings" },
  146.   { "settings", "settings", (fluid_cmd_func_t) fluid_handle_settings, NULL,
  147.     "settings                   Print out all settings" },
  148.   { "echo", "general", (fluid_cmd_func_t) fluid_handle_echo, NULL,
  149.     "echo arg                   Print arg" },
  150.   /* LADSPA-related commands */
  151. #ifdef LADSPA
  152.   { "ladspa_clear", "ladspa", (fluid_cmd_func_t) fluid_LADSPA_handle_clear, NULL,
  153.     "ladspa_clear               Resets LADSPA effect unit to bypass state"},
  154.   { "ladspa_add", "ladspa", (fluid_cmd_func_t) fluid_LADSPA_handle_add, NULL,
  155.     "ladspa_add lib plugin n1 <- p1 n2 -> p2 ... Loads and connects LADSPA plugin"},
  156.   { "ladspa_start", "ladspa", (fluid_cmd_func_t) fluid_LADSPA_handle_start, NULL,
  157.     "ladspa_start               Starts LADSPA effect unit"},
  158.   { "ladspa_declnode", "ladspa", (fluid_cmd_func_t) fluid_LADSPA_handle_declnode, NULL,
  159.     "ladspa_declnode node value Declares control node `node' with value `value'"},
  160.   { "ladspa_setnode", "ladspa", (fluid_cmd_func_t) fluid_LADSPA_handle_setnode, NULL,
  161.     "ladspa_setnode node value  Assigns `value' to `node'"},
  162. #endif
  163.   { "router_clear", "router", (fluid_cmd_func_t) fluid_midi_router_handle_clear, NULL,
  164.     "router_clear               Clears all routing rules from the midi router"},
  165.   { "router_default", "router", (fluid_cmd_func_t) fluid_midi_router_handle_default, NULL,
  166.     "router_default             Resets the midi router to default state"},
  167.   { "router_begin", "router", (fluid_cmd_func_t) fluid_midi_router_handle_begin, NULL,
  168.     "router_begin [note|cc|prog|pbend|cpress|kpress]: Starts a new routing rule"},
  169.   { "router_chan", "router", (fluid_cmd_func_t) fluid_midi_router_handle_chan, NULL,
  170.     "router_chan min max mul add      filters and maps midi channels on current rule"},
  171.   { "router_par1", "router", (fluid_cmd_func_t) fluid_midi_router_handle_par1, NULL,
  172.     "router_par1 min max mul add      filters and maps parameter 1 (key/ctrl nr)"},
  173.   { "router_par2", "router", (fluid_cmd_func_t) fluid_midi_router_handle_par2, NULL,
  174.     "router_par2 min max mul add      filters and maps parameter 2 (vel/cc val)"},
  175.   { "router_end", "router", (fluid_cmd_func_t) fluid_midi_router_handle_end, NULL,
  176.     "router_end                 closes and commits the current routing rule"},
  177.   { NULL, NULL, NULL, NULL, NULL }
  178. };
  180. /**
  181.  * Process a string command.
  182.  * NOTE: FluidSynth 1.0.8 and above no longer modifies the 'cmd' string.
  183.  * @param handler FluidSynth command handler
  184.  * @param cmd Command string (NOTE: Gets modified by FluidSynth prior to 1.0.8)
  185.  * @param out Output stream to display command response to
  186.  * @return Integer value corresponding to: -1 on command error, 0 on success,
  187.  *   1 if 'cmd' is a comment or is empty and -2 if quit was issued
  188.  */
  189. int
  190. fluid_command(fluid_cmd_handler_t* handler, const char *cmd, fluid_ostream_t out)
  191. {
  192.   char* token[MAX_TOKENS];
  193.   char buf[MAX_COMMAND_LEN+1];
  194.   char *strtok, *tok;
  195.   int num_tokens = 0;
  197.   if (cmd[0] == '#') {
  198.     return 1;
  199.   }
  201.   if (strlen (cmd) > MAX_COMMAND_LEN)
  202.   {
  203.     fluid_ostream_printf(out, "Command exceeded max length of %d charsn",
  204.  MAX_COMMAND_LEN);
  205.     return -1;
  206.   }
  208.   FLUID_STRCPY(buf, cmd); /* copy - since fluid_strtok thrashes it */
  209.   strtok = buf;
  211.   /* tokenize the input line */
  212.   while ((tok = fluid_strtok (&strtok, " tnr")))
  213.     token[num_tokens++] = tok;
  215.   if (num_tokens == 0) return 1;
  217.   /* handle the command */
  218.   return fluid_cmd_handler_handle(handler, num_tokens, &token[0], out);
  219. }
  221. /**
  222.  * Create a new FluidSynth command shell.
  223.  * @param settings Setting parameters to use with the shell
  224.  * @param handler Command handler
  225.  * @param in Input stream
  226.  * @param out Output stream
  227.  * @param thread TRUE if shell should be run in a separate thread, FALSE to run
  228.  *   it in the current thread (function blocks until "quit")
  229.  * @return New shell instance or NULL on error
  230.  */
  231. fluid_shell_t *
  232. new_fluid_shell(fluid_settings_t* settings, fluid_cmd_handler_t* handler,
  233.                 fluid_istream_t in, fluid_ostream_t out, int thread)
  234. {
  235.   fluid_shell_t* shell = FLUID_NEW(fluid_shell_t);
  236.   if (shell == NULL) {
  237.     FLUID_LOG (FLUID_PANIC, "Out of memory");
  238.     return NULL;
  239.   }
  242.   fluid_shell_init(shell, settings, handler, in, out);
  244.   if (thread) {
  245.     shell->thread = new_fluid_thread((fluid_thread_func_t) fluid_shell_run, shell,
  246.                                      0, TRUE);
  247.     if (shell->thread == NULL) {
  248.       delete_fluid_shell(shell);
  249.       return NULL;
  250.     }
  251.   } else {
  252.     shell->thread = NULL;
  253.     fluid_shell_run(shell);
  254.   }
  256.   return shell;
  257. }
  259. static void
  260. fluid_shell_init(fluid_shell_t* shell,
  261.  fluid_settings_t* settings, fluid_cmd_handler_t* handler,
  262.  fluid_istream_t in, fluid_ostream_t out)
  263. {
  264.   shell->settings = settings;
  265.   shell->handler = handler;
  266.   shell->in = in;
  267.   shell->out = out;
  268. }
  270. /**
  271.  * Delete a FluidSynth command shell.
  272.  * @param shell Command shell instance
  273.  */
  274. void
  275. delete_fluid_shell(fluid_shell_t* shell)
  276. {
  277.   if (shell->thread != NULL) {
  278.     delete_fluid_thread(shell->thread);
  279.   }
  281.   FLUID_FREE(shell);
  282. }
  284. static int
  285. fluid_shell_run(fluid_shell_t* shell)
  286. {
  287.   char workline[FLUID_WORKLINELENGTH];
  288.   char* prompt = NULL;
  289.   int cont = 1;
  290.   int errors = 0;
  291.   int n;
  293.   if (shell->settings)
  294.     fluid_settings_dupstr(shell->settings, "shell.prompt", &prompt);    /* ++ alloc prompt */
  296.   /* handle user input */
  297.   while (cont) {
  299.     n = fluid_istream_readline(shell->in, shell->out, prompt ? prompt : "", workline, FLUID_WORKLINELENGTH);
  301.     if (n < 0) {
  302.       break;
  303.     }
  305. #if WITH_READLINE
  306.     if (shell->in == fluid_get_stdin()) {
  307.       add_history(workline);
  308.     }
  309. #endif
  311.     /* handle the command */
  312.     switch (fluid_command(shell->handler, workline, shell->out)) {
  314.     case 1: /* empty line or comment */
  315.       break;
  317.     case -1: /* erronous command */
  318.       errors++;
  319.     case 0: /* valid command */
  320.       break;
  322.     case -2: /* quit */
  323.       cont = 0;
  324.       break;
  325.     }
  327.     if (n == 0) {
  328.        break;
  329.     }
  330.   }
  332.   if (prompt) FLUID_FREE (prompt);      /* -- free prompt */
  334.   return errors;
  335. }
  337. /**
  338.  * A convenience function to create a shell interfacing to standard input/output
  339.  * console streams.
  340.  * @param settings Settings instance for the shell
  341.  * @param handler Command handler callback
  342.  */
  343. void
  344. fluid_usershell(fluid_settings_t* settings, fluid_cmd_handler_t* handler)
  345. {
  346.   fluid_shell_t shell;
  347.   fluid_shell_init(&shell, settings, handler, fluid_get_stdin(), fluid_get_stdout());
  348.   fluid_shell_run(&shell);
  349. }
  351. /**
  352.  * Execute shell commands in a file.
  353.  * @param handler Command handler callback
  354.  * @param filename File name
  355.  * @return 0 on success, a value >1 on error
  356.  */
  357. int
  358. fluid_source(fluid_cmd_handler_t* handler, const char *filename)
  359. {
  360.   int file;
  361.   fluid_shell_t shell;
  363. #ifdef WIN32
  364.   file = _open(filename, _O_RDONLY);
  365. #else
  366.   file = open(filename, O_RDONLY);
  367. #endif
  368.   if (file < 0) {
  369.     return file;
  370.   }
  371.   fluid_shell_init(&shell, NULL, handler, file, fluid_get_stdout());
  372.   return fluid_shell_run(&shell);
  373. }
  375. /**
  376.  * Get the user specific FluidSynth command file name.
  377.  * @param buf Caller supplied string buffer to store file name to.
  378.  * @param len Length of a buf
  379.  * @return Returns a buf pointer or NULL if no user command file for this system type.
  380.  */
  381. char*
  382. fluid_get_userconf(char* buf, int len)
  383. {
  384. #if defined(WIN32) || defined(MACOS9)
  385.   return NULL;
  386. #else
  387.   char* home = getenv("HOME");
  388.   if (home == NULL) {
  389.     return NULL;
  390.   } else {
  391.     snprintf(buf, len, "%s/.fluidsynth", home);
  392.     return buf;
  393.   }
  394. #endif
  395. }
  397. /**
  398.  * Get the system FluidSynth command file name.
  399.  * @param buf Caller supplied string buffer to store file name to.
  400.  * @param len Length of a buf
  401.  * @return Returns a buf pointer or NULL if no system command file for this system type.
  402.  */
  403. char*
  404. fluid_get_sysconf(char* buf, int len)
  405. {
  406. #if defined(WIN32) || defined(MACOS9)
  407.   return NULL;
  408. #else
  409.   snprintf(buf, len, "/etc/fluidsynth.conf");
  410.   return buf;
  411. #endif
  412. }
  415. /*
  416.  *  handlers
  417.  */
  418. int
  419. fluid_handle_noteon(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  420. {
  421.   if (ac < 3) {
  422.     fluid_ostream_printf(out, "noteon: too few argumentsn");
  423.     return -1;
  424.   }
  425.   if (!fluid_is_number(av[0]) || !fluid_is_number(av[1]) || !fluid_is_number(av[2])) {
  426.     fluid_ostream_printf(out, "noteon: invalid argumentn");
  427.     return -1;
  428.   }
  429.   return fluid_synth_noteon(synth, atoi(av[0]), atoi(av[1]), atoi(av[2]));
  430. }
  432. int
  433. fluid_handle_noteoff(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  434. {
  435.   if (ac < 2) {
  436.     fluid_ostream_printf(out, "noteoff: too few argumentsn");
  437.     return -1;
  438.   }
  439.   if (!fluid_is_number(av[0]) || !fluid_is_number(av[1])) {
  440.     fluid_ostream_printf(out, "noteon: invalid argumentn");
  441.     return -1;
  442.   }
  443.   return fluid_synth_noteoff(synth, atoi(av[0]), atoi(av[1]));
  444. }
  446. int
  447. fluid_handle_pitch_bend(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  448. {
  449.   if (ac < 2) {
  450.     fluid_ostream_printf(out, "pitch_bend: too few argumentsn");
  451.     return -1;
  452.   }
  453.   if (!fluid_is_number(av[0]) || !fluid_is_number(av[1])) {
  454.     fluid_ostream_printf(out, "pitch_bend: invalid argumentn");
  455.     return -1;
  456.   }
  457.   return fluid_synth_pitch_bend(synth, atoi(av[0]), atoi(av[1]));
  458. }
  460. int
  461. fluid_handle_pitch_bend_range(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  462. {
  463.   if (ac < 2) {
  464.     fluid_ostream_printf(out, "pitch_bend_range: too few argumentsn");
  465.     return -1;
  466.   }
  467.   if (!fluid_is_number(av[0]) || !fluid_is_number(av[1])) {
  468.     fluid_ostream_printf(out, "pitch_bend_range: invalid argumentn");
  469.     return -1;
  470.   }
  471.   int channum = atoi(av[0]);
  472.   int value = atoi(av[1]);
  473.   fluid_channel_set_pitch_wheel_sensitivity(synth->channel[channum], value);
  474.   return 0;
  475. }
  477. int
  478. fluid_handle_cc(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  479. {
  480.   if (ac < 3) {
  481.     fluid_ostream_printf(out, "cc: too few argumentsn");
  482.     return -1;
  483.   }
  484.   if (!fluid_is_number(av[0]) || !fluid_is_number(av[1]) || !fluid_is_number(av[2])) {
  485.     fluid_ostream_printf(out, "cc: invalid argumentn");
  486.     return -1;
  487.   }
  488.   return fluid_synth_cc(synth, atoi(av[0]), atoi(av[1]), atoi(av[2]));
  489. }
  491. int
  492. fluid_handle_prog(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  493. {
  494.   if (ac < 2) {
  495.     fluid_ostream_printf(out, "prog: too few argumentsn");
  496.     return -1;
  497.   }
  498.   if (!fluid_is_number(av[0]) || !fluid_is_number(av[1])) {
  499.     fluid_ostream_printf(out, "prog: invalid argumentn");
  500.     return -1;
  501.   }
  502.   return fluid_synth_program_change(synth, atoi(av[0]), atoi(av[1]));
  503. }
  505. int
  506. fluid_handle_select(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  507. {
  508.   int sfont_id;
  509.   int chan;
  510.   int bank;
  511.   int prog;
  513.   if (ac < 4) {
  514.     fluid_ostream_printf(out, "preset: too few argumentsn");
  515.     return -1;
  516.   }
  517.   if (!fluid_is_number(av[0]) || !fluid_is_number(av[1])
  518.       || !fluid_is_number(av[2]) || !fluid_is_number(av[3])) {
  519.     fluid_ostream_printf(out, "preset: invalid argumentn");
  520.     return -1;
  521.   }
  523.   chan = atoi(av[0]);
  524.   sfont_id = atoi(av[1]);
  525.   bank = atoi(av[2]);
  526.   prog = atoi(av[3]);
  528.   if (sfont_id != 0) {
  529.     return fluid_synth_program_select(synth, chan, sfont_id, bank, prog);
  530.   } else {
  531.     if (fluid_synth_bank_select(synth, chan, bank) == FLUID_OK) {
  532.       return fluid_synth_program_change(synth, chan, prog);
  533.     }
  534.     return FLUID_FAILED;
  535.   }
  536. }
  538. int
  539. fluid_handle_inst(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  540. {
  541.   int font;
  542.   fluid_sfont_t* sfont;
  543.   fluid_preset_t preset;
  544.   int offset;
  546.   if (ac < 1) {
  547.     fluid_ostream_printf(out, "inst: too few argumentsn");
  548.     return -1;
  549.   }
  551.   if (!fluid_is_number(av[0])) {
  552.     fluid_ostream_printf(out, "inst: invalid argumentn");
  553.     return -1;
  554.   }
  556.   font = atoi(av[0]);
  558.   sfont = fluid_synth_get_sfont_by_id(synth, font);
  559.   offset = fluid_synth_get_bank_offset(synth, font);
  561.   if (sfont == NULL) {
  562.     fluid_ostream_printf(out, "inst: invalid font numbern");
  563.     return -1;
  564.   }
  566.   fluid_sfont_iteration_start(sfont);
  568.   while (fluid_sfont_iteration_next(sfont, &preset)) {
  569.     fluid_ostream_printf(out, "%03d-%03d %sn",
  570. fluid_preset_get_banknum(&preset) + offset,
  571. fluid_preset_get_num(&preset),
  572. fluid_preset_get_name(&preset));
  573.   }
  575.   return 0;
  576. }
  579. int
  580. fluid_handle_channels(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  581. {
  582.   fluid_synth_channel_info_t info;
  583.   int verbose = 0;
  584.   int i;
  586.   if (ac > 0 && strcmp( av[0], "-verbose") == 0) verbose = 1;
  588.   for (i = 0; i < fluid_synth_count_midi_channels (synth); i++)
  589.   {
  590.     fluid_synth_get_channel_info (synth, i, &info);
  592.     if (!verbose)
  593.       fluid_ostream_printf (out, "chan %d, %sn", i,
  594.                             info.assigned ? info.name : "no preset");
  595.     else
  596.       fluid_ostream_printf (out, "chan %d, sfont %d, bank %d, preset %d, %sn", i,
  597.                             info.sfont_id, info.bank, info.program,
  598.                             info.assigned ? info.name : "no preset");
  599.   }
  601.   return 0;
  602. }
  604. int
  605. fluid_handle_load(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  606. {
  607.   char buf[1024];
  608.   int id;
  609.   int reset = 1;
  610.   int offset = 0;
  612.   if (ac < 1) {
  613.     fluid_ostream_printf(out, "load: too few argumentsn");
  614.     return -1;
  615.   }
  616.   if (ac == 2) {
  617.     reset = atoi(av[1]);
  618.   }
  619.   if (ac == 3) {
  620.     offset = atoi(av[2]);
  621.   }
  623.   /* Load the SoundFont without resetting the programs. The reset will
  624.    * be done later (if requested). */
  625.   id = fluid_synth_sfload(synth, fluid_expand_path(av[0], buf, 1024), 0);
  627.   if (id == -1) {
  628.     fluid_ostream_printf(out, "failed to load the SoundFontn");
  629.     return -1;
  630.   } else {
  631.     fluid_ostream_printf(out, "loaded SoundFont has ID %dn", id);
  632.   }
  634.   if (offset) {
  635.     fluid_synth_set_bank_offset(synth, id, offset);
  636.   }
  638.   /* The reset should be done after the offset is set. */
  639.   if (reset) {
  640.     fluid_synth_program_reset(synth);
  641.   }
  643.   return 0;
  644. }
  646. int
  647. fluid_handle_unload(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  648. {
  649.   int reset = 1;
  650.   if (ac < 1) {
  651.     fluid_ostream_printf(out, "unload: too few argumentsn");
  652.     return -1;
  653.   }
  654.   if (!fluid_is_number(av[0])) {
  655.     fluid_ostream_printf(out, "unload: expected a number as argumentn");
  656.     return -1;
  657.   }
  658.   if (ac == 2) {
  659.     reset = atoi(av[1]);
  660.   }
  661.   if (fluid_synth_sfunload(synth, atoi(av[0]), reset) != 0) {
  662.     fluid_ostream_printf(out, "failed to unload the SoundFontn");
  663.     return -1;
  664.   }
  665.   return 0;
  666. }
  668. int
  669. fluid_handle_reload(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  670. {
  671.   if (ac < 1) {
  672.     fluid_ostream_printf(out, "reload: too few argumentsn");
  673.     return -1;
  674.   }
  675.   if (!fluid_is_number(av[0])) {
  676.     fluid_ostream_printf(out, "reload: expected a number as argumentn");
  677.     return -1;
  678.   }
  679.   if (fluid_synth_sfreload(synth, atoi(av[0])) == -1) {
  680.     fluid_ostream_printf(out, "failed to reload the SoundFontn");
  681.     return -1;
  682.   }
  683.   return 0;
  684. }
  687. int
  688. fluid_handle_fonts(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  689. {
  690.   int i;
  691.   fluid_sfont_t* sfont;
  692.   int num;
  694.   num = fluid_synth_sfcount(synth);
  696.   if (num == 0) {
  697.     fluid_ostream_printf(out, "no SoundFont loaded (try load)n");
  698.     return 0;
  699.   }
  701.   fluid_ostream_printf(out, "ID  Namen");
  703.   for (i = 0; i < num; i++) {
  704.     sfont = fluid_synth_get_sfont(synth, i);
  705.     fluid_ostream_printf(out, "%2d  %sn",
  706. fluid_sfont_get_id(sfont),
  707. fluid_sfont_get_name(sfont));
  708.   }
  710.   return 0;
  711. }
  713. int
  714. fluid_handle_mstat(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  715. {
  716. /*    fluid_ostream_printf(out, "Dvr=%s, Dev=%sn",  */
  717. /*    fluid_midi_handler_get_driver_name(midi), */
  718. /*    fluid_midi_handler_get_device_name(midi)); */
  719. /*    fluid_ostream_printf(out, "Stat=%s, On=%d, Off=%d, Prog=%d, Pbend=%d, Err=%dn",  */
  720. /*    fluid_midi_handler_get_status(midi), */
  721. /*    fluid_midi_handler_get_event_count(midi, 0x90), */
  722. /*    fluid_midi_handler_get_event_count(midi, 0x80), */
  723. /*    fluid_midi_handler_get_event_count(midi, 0xc0), */
  724. /*    fluid_midi_handler_get_event_count(midi, 0xe0), */
  725. /*    fluid_midi_handler_get_event_count(midi, 0)); */
  726.   fluid_ostream_printf(out, "not yet implementedn");
  727.   return -1;
  728. }
  730. /* Purpose:
  731.  * Response to 'rev_preset' command.
  732.  * Load the values from a reverb preset into the reverb unit. */
  733. int
  734. fluid_handle_reverbpreset(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  735. {
  736.   int reverb_preset_number;
  737.   if (ac < 1) {
  738.     fluid_ostream_printf(out, "rev_preset: too few argumentsn");
  739.     return -1;
  740.   }
  741.   reverb_preset_number = atoi(av[0]);
  742.   if (fluid_synth_set_reverb_preset(synth, reverb_preset_number)!=FLUID_OK){
  743.     fluid_ostream_printf(out, "rev_preset: Failed. Parameter out of range?n");
  744.     return -1;
  745.   };
  746.   return 0;
  747. }
  749. /* Purpose:
  750.  * Response to 'rev_setroomsize' command.
  751.  * Load the new room size into the reverb unit. */
  752. int
  753. fluid_handle_reverbsetroomsize(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  754. {
  755.   fluid_real_t room_size;
  756.   if (ac < 1) {
  757.     fluid_ostream_printf(out, "rev_setroomsize: too few arguments.n");
  758.     return -1;
  759.   }
  760.   room_size = atof(av[0]);
  761.   if (room_size < 0){
  762.     fluid_ostream_printf(out, "rev_setroomsize: Room size must be positive!n");
  763.     return -1;
  764.   }
  765.   if (room_size > 1.2){
  766.     fluid_ostream_printf(out, "rev_setroomsize: Room size too big!n");
  767.     return -1;
  768.   }
  769.   fluid_synth_set_reverb_full (synth, FLUID_REVMODEL_SET_ROOMSIZE,
  770.                                room_size, 0.0, 0.0, 0.0);
  771.   return 0;
  772. }
  774. /* Purpose:
  775.  * Response to 'rev_setdamp' command.
  776.  * Load the new damp factor into the reverb unit. */
  777. int
  778. fluid_handle_reverbsetdamp(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  779. {
  780.   fluid_real_t damp;
  781.   if (ac < 1) {
  782.     fluid_ostream_printf(out, "rev_setdamp: too few arguments.n");
  783.     return -1;
  784.   }
  785.   damp = atof(av[0]);
  786.   if ((damp < 0.0f) || (damp > 1)){
  787.     fluid_ostream_printf(out, "rev_setdamp: damp must be between 0 and 1!n");
  788.     return -1;
  789.   }
  790.   fluid_synth_set_reverb_full (synth, FLUID_REVMODEL_SET_DAMPING,
  791.                                0.0, damp, 0.0, 0.0);
  792.   return 0;
  793. }
  795. /* Purpose:
  796.  * Response to 'rev_setwidth' command.
  797.  * Load the new width into the reverb unit. */
  798. int
  799. fluid_handle_reverbsetwidth(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  800. {
  801.   fluid_real_t width;
  802.   if (ac < 1) {
  803.     fluid_ostream_printf(out, "rev_setwidth: too few arguments.n");
  804.     return -1;
  805.   }
  806.   width = atof(av[0]);
  807.   if ((width < 0) || (width > 100)){
  808.     fluid_ostream_printf(out, "rev_setroomsize: Too wide! (0..100)n");
  809.     return 0;
  810.   }
  811.   fluid_synth_set_reverb_full (synth, FLUID_REVMODEL_SET_WIDTH,
  812.                                0.0, 0.0, width, 0.0);
  813.   return 0;
  814. }
  816. /* Purpose:
  817.  * Response to 'rev_setlevel' command.
  818.  * Load the new level into the reverb unit. */
  819. int
  820. fluid_handle_reverbsetlevel(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  821. {
  822.   fluid_real_t level;
  823.   if (ac < 1) {
  824.     fluid_ostream_printf(out, "rev_setlevel: too few arguments.n");
  825.     return -1;
  826.   }
  827.   level = atof(av[0]);
  828.   if (abs(level) > 30){
  829.     fluid_ostream_printf(out, "rev_setlevel: Value too high! (Value of 10 =+20 dB)n");
  830.     return 0;
  831.   }
  832.   fluid_synth_set_reverb_full (synth, FLUID_REVMODEL_SET_LEVEL,
  833.                                0.0, 0.0, 0.0, level);
  834.   return 0;
  835. }
  837. /* Purpose:
  838.  * Response to 'reverb' command.
  839.  * Change the FLUID_REVERB flag in the synth */
  840. int
  841. fluid_handle_reverb(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  842. {
  843.   if (ac < 1) {
  844.     fluid_ostream_printf(out, "reverb: too few arguments.n");
  845.     return -1;
  846.   }
  848.   if ((strcmp(av[0], "0") == 0) || (strcmp(av[0], "off") == 0)) {
  849.     fluid_synth_set_reverb_on(synth,0);
  850.   } else if ((strcmp(av[0], "1") == 0) || (strcmp(av[0], "on") == 0)) {
  851.     fluid_synth_set_reverb_on(synth,1);
  852.   } else {
  853.     fluid_ostream_printf(out, "reverb: invalid arguments %s [0|1|on|off]", av[0]);
  854.     return -1;
  855.   }
  857.   return 0;
  858. }
  861. /* Purpose:
  862.  * Response to 'chorus_setnr' command */
  863. int
  864. fluid_handle_chorusnr(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  865. {
  866.   int nr;
  867.   if (ac < 1) {
  868.     fluid_ostream_printf(out, "cho_set_nr: too few arguments.n");
  869.     return -1;
  870.   }
  871.   nr = atoi(av[0]);
  872.   return fluid_synth_set_chorus_full (synth, FLUID_CHORUS_SET_NR, nr, 0.0, 0.0, 0.0, 0);
  873. }
  875. /* Purpose:
  876.  * Response to 'chorus_setlevel' command */
  877. int
  878. fluid_handle_choruslevel(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  879. {
  880.   fluid_real_t level;
  881.   if (ac < 1) {
  882.     fluid_ostream_printf(out, "cho_set_level: too few arguments.n");
  883.     return -1;
  884.   }
  885.   level = atof(av[0]);
  886.   return fluid_synth_set_chorus_full (synth, FLUID_CHORUS_SET_LEVEL, 0, level, 0.0, 0.0, 0);
  887. }
  889. /* Purpose:
  890.  * Response to 'chorus_setspeed' command */
  891. int
  892. fluid_handle_chorusspeed(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  893. {
  894.   fluid_real_t speed;
  895.   if (ac < 1) {
  896.     fluid_ostream_printf(out, "cho_set_speed: too few arguments.n");
  897.     return -1;
  898.   }
  899.   speed = atof(av[0]);
  900.   return fluid_synth_set_chorus_full (synth, FLUID_CHORUS_SET_SPEED, 0, 0.0, speed, 0.0, 0);
  901. }
  903. /* Purpose:
  904.  * Response to 'chorus_setdepth' command */
  905. int
  906. fluid_handle_chorusdepth(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  907. {
  908.   fluid_real_t depth;
  909.   if (ac < 1) {
  910.     fluid_ostream_printf(out, "cho_set_depth: too few arguments.n");
  911.     return -1;
  912.   }
  913.   depth = atof(av[0]);
  914.   return fluid_synth_set_chorus_full (synth, FLUID_CHORUS_SET_DEPTH, 0, 0.0, 0.0, depth, 0);
  915. }
  917. int
  918. fluid_handle_chorus(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  919. {
  920.   if (ac < 1) {
  921.     fluid_ostream_printf(out, "chorus: too few argumentsn");
  922.     return -1;
  923.   }
  925.   if ((strcmp(av[0], "0") == 0) || (strcmp(av[0], "off") == 0)) {
  926.     fluid_synth_set_chorus_on(synth,0);
  927.   } else if ((strcmp(av[0], "1") == 0) || (strcmp(av[0], "on") == 0)) {
  928.     fluid_synth_set_chorus_on(synth,1);
  929.   } else {
  930.     fluid_ostream_printf(out, "chorus: invalid arguments %s [0|1|on|off]", av[0]);
  931.     return -1;
  932.   }
  934.   return 0;
  935. }
  937. /* Purpose:
  938.  * Response to the 'echo' command.
  939.  * The command itself is useful, when the synth is used via TCP/IP.
  940.  * It can signal for example, that a list of commands has been processed.
  941.  */
  942. int
  943. fluid_handle_echo(fluid_cmd_handler_t* handler, int ac, char** av, fluid_ostream_t out)
  944. {
  945.   if (ac < 1) {
  946.     fluid_ostream_printf(out, "echo: too few arguments.n");
  947.     return -1;
  948.   }
  950.   fluid_ostream_printf(out, "%sn",av[0]);
  952.   return 0;
  953. }
  955. int
  956. fluid_handle_source(fluid_cmd_handler_t* handler, int ac, char** av, fluid_ostream_t out)
  957. {
  958.   if (ac < 1) {
  959.     fluid_ostream_printf(out, "source: too few arguments.n");
  960.     return -1;
  961.   }
  963.   fluid_source(handler, av[0]);
  965.   return 0;
  966. }
  968. /* Purpose:
  969.  * Response to 'gain' command. */
  970. int
  971. fluid_handle_gain(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  972. {
  973.   float gain;
  975.   if (ac < 1) {
  976.     fluid_ostream_printf(out, "gain: too few arguments.n");
  977.     return -1;
  978.   }
  980.   gain = atof(av[0]);
  982.   if ((gain < 0.0f) || (gain > 5.0f)) {
  983.     fluid_ostream_printf(out, "gain: value should be between '0' and '5'.n");
  984.     return -1;
  985.   };
  987.   fluid_synth_set_gain(synth, gain);
  989.   return 0;
  990. }
  992. /* Response to voice_count command */
  993. static int
  994. fluid_handle_voice_count (fluid_synth_t *synth, int ac, char **av,
  995.                           fluid_ostream_t out)
  996. {
  997.   fluid_ostream_printf (out, "voice_count: %dn",
  998.                         fluid_synth_get_active_voice_count (synth));
  999.   return FLUID_OK;
  1000. }
  1002. /* Purpose:
  1003.  * Response to 'interp' command. */
  1004. int
  1005. fluid_handle_interp(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  1006. {
  1007.   int interp;
  1008.   int chan=-1; /* -1: Set all channels */
  1010.   if (ac < 1) {
  1011.     fluid_ostream_printf(out, "interp: too few arguments.n");
  1012.     return -1;
  1013.   }
  1015.   interp = atoi(av[0]);
  1017.   if ((interp < 0) || (interp > FLUID_INTERP_HIGHEST)) {
  1018.     fluid_ostream_printf(out, "interp: Bad valuen");
  1019.     return -1;
  1020.   };
  1022.   fluid_synth_set_interp_method(synth, chan, interp);
  1024.   return 0;
  1025. }
  1027. /* Purpose:
  1028.  * Response to 'interp' command. */
  1029. int
  1030. fluid_handle_interpc(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  1031. {
  1032.   int interp;
  1033.   int chan;
  1035.   if (ac < 2) {
  1036.     fluid_ostream_printf(out, "interpc: too few arguments.n");
  1037.     return -1;
  1038.   }
  1040.   chan = atoi(av[0]);
  1041.   interp = atoi(av[1]);
  1043.   if ((chan < 0) || (chan >= fluid_synth_count_midi_channels(synth))){
  1044.     fluid_ostream_printf(out, "interp: Bad value for channel number.n");
  1045.     return -1;
  1046.   };
  1047.   if ((interp < 0) || (interp > FLUID_INTERP_HIGHEST)) {
  1048.     fluid_ostream_printf(out, "interp: Bad value for interpolation method.n");
  1049.     return -1;
  1050.   };
  1052.   fluid_synth_set_interp_method(synth, chan, interp);
  1054.   return 0;
  1055. }
  1057. int
  1058. fluid_handle_tuning(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  1059. {
  1060.   char *name;
  1061.   int bank, prog;
  1063.   if (ac < 3) {
  1064.     fluid_ostream_printf(out, "tuning: too few arguments.n");
  1065.     return -1;
  1066.   }
  1068.   name = av[0];
  1070.   if (!fluid_is_number(av[1])) {
  1071.     fluid_ostream_printf(out, "tuning: 2nd argument should be a number.n");
  1072.     return -1;
  1073.   }
  1074.   bank = atoi(av[1]);
  1075.   if ((bank < 0) || (bank >= 128)){
  1076.     fluid_ostream_printf(out, "tuning: invalid bank number.n");
  1077.     return -1;
  1078.   };
  1080.   if (!fluid_is_number(av[2])) {
  1081.     fluid_ostream_printf(out, "tuning: 3rd argument should be a number.n");
  1082.     return -1;
  1083.   }
  1084.   prog = atoi(av[2]);
  1085.   if ((prog < 0) || (prog >= 128)){
  1086.     fluid_ostream_printf(out, "tuning: invalid program number.n");
  1087.     return -1;
  1088.   };
  1090.   fluid_synth_create_key_tuning(synth, bank, prog, name, NULL);
  1092.   return 0;
  1093. }
  1095. int
  1096. fluid_handle_tune(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  1097. {
  1098.   int bank, prog, key;
  1099.   double pitch;
  1101.   if (ac < 4) {
  1102.     fluid_ostream_printf(out, "tune: too few arguments.n");
  1103.     return -1;
  1104.   }
  1106.   if (!fluid_is_number(av[0])) {
  1107.     fluid_ostream_printf(out, "tune: 1st argument should be a number.n");
  1108.     return -1;
  1109.   }
  1110.   bank = atoi(av[0]);
  1111.   if ((bank < 0) || (bank >= 128)){
  1112.     fluid_ostream_printf(out, "tune: invalid bank number.n");
  1113.     return -1;
  1114.   };
  1116.   if (!fluid_is_number(av[1])) {
  1117.     fluid_ostream_printf(out, "tune: 2nd argument should be a number.n");
  1118.     return -1;
  1119.   }
  1120.   prog = atoi(av[1]);
  1121.   if ((prog < 0) || (prog >= 128)){
  1122.     fluid_ostream_printf(out, "tune: invalid program number.n");
  1123.     return -1;
  1124.   };
  1126.   if (!fluid_is_number(av[2])) {
  1127.     fluid_ostream_printf(out, "tune: 3rd argument should be a number.n");
  1128.     return -1;
  1129.   }
  1130.   key = atoi(av[2]);
  1131.   if ((key < 0) || (key >= 128)){
  1132.     fluid_ostream_printf(out, "tune: invalid key number.n");
  1133.     return -1;
  1134.   };
  1136.   pitch = atof(av[3]);
  1137.   if (pitch < 0.0f) {
  1138.     fluid_ostream_printf(out, "tune: invalid pitch.n");
  1139.     return -1;
  1140.   };
  1142.   fluid_synth_tune_notes(synth, bank, prog, 1, &key, &pitch, 0);
  1144.   return 0;
  1145. }
  1147. int
  1148. fluid_handle_settuning(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  1149. {
  1150.   int chan, bank, prog;
  1152.   if (ac < 3) {
  1153.     fluid_ostream_printf(out, "settuning: too few arguments.n");
  1154.     return -1;
  1155.   }
  1157.   if (!fluid_is_number(av[0])) {
  1158.     fluid_ostream_printf(out, "tune: 1st argument should be a number.n");
  1159.     return -1;
  1160.   }
  1161.   chan = atoi(av[0]);
  1162.   if ((chan < 0) || (chan >= fluid_synth_count_midi_channels(synth))){
  1163.     fluid_ostream_printf(out, "tune: invalid channel number.n");
  1164.     return -1;
  1165.   };
  1167.   if (!fluid_is_number(av[1])) {
  1168.     fluid_ostream_printf(out, "tuning: 2nd argument should be a number.n");
  1169.     return -1;
  1170.   }
  1171.   bank = atoi(av[1]);
  1172.   if ((bank < 0) || (bank >= 128)){
  1173.     fluid_ostream_printf(out, "tuning: invalid bank number.n");
  1174.     return -1;
  1175.   };
  1177.   if (!fluid_is_number(av[2])) {
  1178.     fluid_ostream_printf(out, "tuning: 3rd argument should be a number.n");
  1179.     return -1;
  1180.   }
  1181.   prog = atoi(av[2]);
  1182.   if ((prog < 0) || (prog >= 128)){
  1183.     fluid_ostream_printf(out, "tuning: invalid program number.n");
  1184.     return -1;
  1185.   };
  1187.   fluid_synth_select_tuning(synth, chan, bank, prog);
  1189.   return 0;
  1190. }
  1192. int
  1193. fluid_handle_resettuning(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  1194. {
  1195.   int chan;
  1197.   if (ac < 1) {
  1198.     fluid_ostream_printf(out, "resettuning: too few arguments.n");
  1199.     return -1;
  1200.   }
  1202.   if (!fluid_is_number(av[0])) {
  1203.     fluid_ostream_printf(out, "tune: 1st argument should be a number.n");
  1204.     return -1;
  1205.   }
  1206.   chan = atoi(av[0]);
  1207.   if ((chan < 0) || (chan >= fluid_synth_count_midi_channels(synth))){
  1208.     fluid_ostream_printf(out, "tune: invalid channel number.n");
  1209.     return -1;
  1210.   };
  1212.   fluid_synth_reset_tuning(synth, chan);
  1214.   return 0;
  1215. }
  1217. int
  1218. fluid_handle_tunings(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  1219. {
  1220.   int bank, prog;
  1221.   char name[256];
  1222.   int count = 0;
  1224.   fluid_synth_tuning_iteration_start(synth);
  1226.   while (fluid_synth_tuning_iteration_next(synth, &bank, &prog)) {
  1227.     fluid_synth_tuning_dump(synth, bank, prog, name, 256, NULL);
  1228.     fluid_ostream_printf(out, "%03d-%03d %sn", bank, prog, name);
  1229.     count++;
  1230.   }
  1232.   if (count == 0) {
  1233.     fluid_ostream_printf(out, "No tunings availablen");
  1234.   }
  1236.   return 0;
  1237. }
  1239. int
  1240. fluid_handle_dumptuning(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  1241. {
  1242.   int bank, prog, i;
  1243.   double pitch[128];
  1244.   char name[256];
  1246.   if (ac < 2) {
  1247.     fluid_ostream_printf(out, "dumptuning: too few arguments.n");
  1248.     return -1;
  1249.   }
  1251.   if (!fluid_is_number(av[0])) {
  1252.     fluid_ostream_printf(out, "dumptuning: 1st argument should be a number.n");
  1253.     return -1;
  1254.   }
  1255.   bank = atoi(av[0]);
  1256.   if ((bank < 0) || (bank >= 128)){
  1257.     fluid_ostream_printf(out, "dumptuning: invalid bank number.n");
  1258.     return -1;
  1259.   };
  1261.   if (!fluid_is_number(av[1])) {
  1262.     fluid_ostream_printf(out, "dumptuning: 2nd argument should be a number.n");
  1263.     return -1;
  1264.   }
  1265.   prog = atoi(av[1]);
  1266.   if ((prog < 0) || (prog >= 128)){
  1267.     fluid_ostream_printf(out, "dumptuning: invalid program number.n");
  1268.     return -1;
  1269.   };
  1271.   fluid_synth_tuning_dump(synth, bank, prog, name, 256, pitch);
  1273.   fluid_ostream_printf(out, "%03d-%03d %s:n", bank, prog, name);
  1275.   for (i = 0; i < 128; i++) {
  1276.     fluid_ostream_printf(out, "key %03d, pitch %5.2fn", i, pitch[i]);
  1277.   }
  1279.   return 0;
  1280. }
  1282. int
  1283. fluid_handle_set(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  1284. {
  1285.   int hints;
  1286.   int ival;
  1288.   if (ac < 2) {
  1289.     fluid_ostream_printf(out, "set: Too few arguments.n");
  1290.     return -1;
  1291.   }
  1293.   switch (fluid_settings_get_type (synth->settings, av[0]))
  1294.   {
  1295.     case FLUID_NO_TYPE:
  1296.       fluid_ostream_printf (out, "set: Parameter '%s' not found.n", av[0]);
  1297.       break;
  1298.     case FLUID_INT_TYPE:
  1299.       hints = fluid_settings_get_hints (synth->settings, av[0]);
  1301.       if (hints & FLUID_HINT_TOGGLED)
  1302.       {
  1303.         if (FLUID_STRCMP (av[1], "yes") == 0 || FLUID_STRCMP (av[1], "True") == 0
  1304.             || FLUID_STRCMP (av[1], "TRUE") == 0 || FLUID_STRCMP (av[1], "true") == 0
  1305.             || FLUID_STRCMP (av[1], "T") == 0)
  1306.           ival = 1;
  1307.         else ival = atoi (av[1]);
  1308.       }
  1309.       else ival = atoi (av[1]);
  1311.       fluid_synth_setint (synth, av[0], ival);
  1312.       break;
  1313.     case FLUID_NUM_TYPE:
  1314.       fluid_synth_setnum (synth, av[0], atof (av[1]));
  1315.       break;
  1316.     case FLUID_STR_TYPE:
  1317.       fluid_synth_setstr(synth, av[0], av[1]);
  1318.       break;
  1319.     case FLUID_SET_TYPE:
  1320.       fluid_ostream_printf (out, "set: Parameter '%s' is a node.n", av[0]);
  1321.       break;
  1322.   }
  1324.   return 0;
  1325. }
  1327. int
  1328. fluid_handle_get(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  1329. {
  1330.   if (ac < 1) {
  1331.     fluid_ostream_printf(out, "get: too few arguments.n");
  1332.     return -1;
  1333.   }
  1335.   switch (fluid_settings_get_type(fluid_synth_get_settings(synth), av[0])) {
  1336.   case FLUID_NO_TYPE:
  1337.     fluid_ostream_printf(out, "get: no such setting '%s'.n", av[0]);
  1338.     return -1;
  1340.   case FLUID_NUM_TYPE: {
  1341.     double value;
  1342.     fluid_synth_getnum(synth, av[0], &value);
  1343.     fluid_ostream_printf(out, "%.3f", value);
  1344.     break;
  1345.   }
  1347.   case FLUID_INT_TYPE: {
  1348.     int value;
  1349.     fluid_synth_getint(synth, av[0], &value);
  1350.     fluid_ostream_printf(out, "%d", value);
  1351.     break;
  1352.   }
  1354.   case FLUID_STR_TYPE: {
  1355.     char* s;
  1356.     fluid_synth_dupstr(synth, av[0], &s);       /* ++ alloc string */
  1357.     fluid_ostream_printf(out, "%s", s ? s : "NULL");
  1358.     if (s) FLUID_FREE (s);      /* -- free string */
  1359.     break;
  1360.   }
  1362.   case FLUID_SET_TYPE:
  1363.     fluid_ostream_printf(out, "%s is a node", av[0]);
  1364.     break;
  1365.   }
  1367.   return 0;
  1368. }
  1370. struct _fluid_handle_settings_data_t {
  1371.   int len;
  1372.   fluid_synth_t* synth;
  1373.   fluid_ostream_t out;
  1374. };
  1376. static void fluid_handle_settings_iter1(void* data, char* name, int type)
  1377. {
  1378.   struct _fluid_handle_settings_data_t* d = (struct _fluid_handle_settings_data_t*) data;
  1380.   int len = FLUID_STRLEN(name);
  1381.   if (len > d->len) {
  1382.     d->len = len;
  1383.   }
  1384. }
  1386. static void fluid_handle_settings_iter2(void* data, char* name, int type)
  1387. {
  1388.   struct _fluid_handle_settings_data_t* d = (struct _fluid_handle_settings_data_t*) data;
  1390.   int len = FLUID_STRLEN(name);
  1391.   fluid_ostream_printf(d->out, "%s", name);
  1392.   while (len++ < d->len) {
  1393.     fluid_ostream_printf(d->out, " ");
  1394.   }
  1395.   fluid_ostream_printf(d->out, "   ");
  1397.   switch (fluid_settings_get_type(fluid_synth_get_settings(d->synth), name)) {
  1398.   case FLUID_NUM_TYPE: {
  1399.     double value;
  1400.     fluid_synth_getnum(d->synth, name, &value);
  1401.     fluid_ostream_printf(d->out, "%.3fn", value);
  1402.     break;
  1403.   }
  1405.   case FLUID_INT_TYPE: {
  1406.     int value, hints;
  1407.     fluid_synth_getint(d->synth, name, &value);
  1408.     hints = fluid_settings_get_hints (d->synth->settings, name);
  1410.     if (!(hints & FLUID_HINT_TOGGLED))
  1411.       fluid_ostream_printf(d->out, "%dn", value);
  1412.     else fluid_ostream_printf(d->out, "%sn", value ? "True" : "False");
  1413.     break;
  1414.   }
  1416.   case FLUID_STR_TYPE: {
  1417.     char* s;
  1418.     fluid_synth_dupstr(d->synth, name, &s);     /* ++ alloc string */
  1419.     fluid_ostream_printf(d->out, "%sn", s ? s : "NULL");
  1420.     if (s) FLUID_FREE (s);      /* -- free string */
  1421.     break;
  1422.   }
  1423.   }
  1424. }
  1426. int
  1427. fluid_handle_settings(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  1428. {
  1429.   struct _fluid_handle_settings_data_t data;
  1431.   data.len = 0;
  1432.   data.synth = synth;
  1433.   data.out = out;
  1435.   fluid_settings_foreach(fluid_synth_get_settings(synth), &data, fluid_handle_settings_iter1);
  1436.   fluid_settings_foreach(fluid_synth_get_settings(synth), &data, fluid_handle_settings_iter2);
  1437.   return 0;
  1438. }
  1441. struct _fluid_handle_option_data_t {
  1442.   int first;
  1443.   fluid_ostream_t out;
  1444. };
  1446. void fluid_handle_print_option(void* data, char* name, char* option)
  1447. {
  1448.   struct _fluid_handle_option_data_t* d = (struct _fluid_handle_option_data_t*) data;
  1450.   if (d->first) {
  1451.     fluid_ostream_printf(d->out, "%s", option);
  1452.     d->first = 0;
  1453.   } else {
  1454.     fluid_ostream_printf(d->out, ", %s", option);
  1455.   }
  1456. }
  1458. int
  1459. fluid_handle_info(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  1460. {
  1461.   fluid_settings_t* settings = fluid_synth_get_settings(synth);
  1462.   struct _fluid_handle_option_data_t data;
  1464.   if (ac < 1) {
  1465.     fluid_ostream_printf(out, "info: too few arguments.n");
  1466.     return -1;
  1467.   }
  1469.   switch (fluid_settings_get_type(settings, av[0])) {
  1470.   case FLUID_NO_TYPE:
  1471.     fluid_ostream_printf(out, "info: no such setting '%s'.n", av[0]);
  1472.     return -1;
  1474.   case FLUID_NUM_TYPE: {
  1475.     double value, min, max;
  1476.     fluid_settings_getnum_range(settings, av[0], &min, &max);
  1477.     fluid_settings_getnum(settings, av[0], &value);
  1478.     fluid_ostream_printf(out, "%s:n", av[0]);
  1479.     fluid_ostream_printf(out, "Type:          numbern");
  1480.     fluid_ostream_printf(out, "Value:         %.3fn", value);
  1481.     fluid_ostream_printf(out, "Minimum value: %.3fn", min);
  1482.     fluid_ostream_printf(out, "Maximum value: %.3fn", max);
  1483.     fluid_ostream_printf(out, "Default value: %.3fn",
  1484. fluid_settings_getnum_default(settings, av[0]));
  1485.     fluid_ostream_printf(out, "Real-time:     %sn",
  1486. fluid_settings_is_realtime(settings, av[0])? "yes" : "no");
  1487.     break;
  1488.   }
  1490.   case FLUID_INT_TYPE: {
  1491.     int value, min, max, def, hints;
  1493.     fluid_settings_getint_range(settings, av[0], &min, &max);
  1494.     fluid_settings_getint(settings, av[0], &value);
  1495.     hints = fluid_settings_get_hints(settings, av[0]);
  1496.     def = fluid_settings_getint_default (settings, av[0]);
  1498.     fluid_ostream_printf(out, "%s:n", av[0]);
  1500.     if (!(hints & FLUID_HINT_TOGGLED))
  1501.     {
  1502.       fluid_ostream_printf(out, "Type:          integern");
  1503.       fluid_ostream_printf(out, "Value:         %dn", value);
  1504.       fluid_ostream_printf(out, "Minimum value: %dn", min);
  1505.       fluid_ostream_printf(out, "Maximum value: %dn", max);
  1506.       fluid_ostream_printf(out, "Default value: %dn", def);
  1507.     }
  1508.     else
  1509.     {
  1510.       fluid_ostream_printf(out, "Type:          booleann");
  1511.       fluid_ostream_printf(out, "Value:         %sn", value ? "True" : "False");
  1512.       fluid_ostream_printf(out, "Default value: %sn", def ? "True" : "False");
  1513.     }
  1515.     fluid_ostream_printf(out, "Real-time:     %sn",
  1516. fluid_settings_is_realtime(settings, av[0])? "yes" : "no");
  1517.     break;
  1518.   }
  1520.   case FLUID_STR_TYPE: {
  1521.     char *s;
  1522.     fluid_settings_dupstr(settings, av[0], &s);         /* ++ alloc string */
  1523.     fluid_ostream_printf(out, "%s:n", av[0]);
  1524.     fluid_ostream_printf(out, "Type:          stringn");
  1525.     fluid_ostream_printf(out, "Value:         %sn", s ? s : "NULL");
  1526.     fluid_ostream_printf(out, "Default value: %sn",
  1527. fluid_settings_getstr_default(settings, av[0]));
  1529.     if (s) FLUID_FREE (s);
  1531.     data.out = out;
  1532.     data.first = 1;
  1533.     fluid_ostream_printf(out, "Options:       ");
  1534.     fluid_settings_foreach_option (settings, av[0], &data, fluid_handle_print_option);
  1535.     fluid_ostream_printf(out, "n");
  1537.     fluid_ostream_printf(out, "Real-time:     %sn",
  1538. fluid_settings_is_realtime(settings, av[0])? "yes" : "no");
  1539.     break;
  1540.   }
  1542.   case FLUID_SET_TYPE:
  1543.     fluid_ostream_printf(out, "%s:n", av[0]);
  1544.     fluid_ostream_printf(out, "Type:          noden");
  1545.     break;
  1546.   }
  1548.   return 0;
  1549. }
  1551. int
  1552. fluid_handle_reset(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  1553. {
  1554.   fluid_synth_system_reset(synth);
  1555.   return 0;
  1556. }
  1558. int
  1559. fluid_handle_quit(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  1560. {
  1561.   fluid_ostream_printf(out, "cheers!n");
  1562.   return -2;
  1563. }
  1565. int
  1566. fluid_handle_help(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
  1567. {
  1568.   /* Purpose:
  1569.    * Prints the help text for the command line commands.
  1570.    * Can be used as follows:
  1571.    * - help
  1572.    * - help (topic), where (topic) is 'general', 'chorus', etc.
  1573.    * - help all
  1574.    */
  1576.   char* topic = "help"; /* default, if no topic is given */
  1577.   int count = 0;
  1578.   int i;
  1580.   fluid_ostream_printf(out, "n");
  1581.   /* 1st argument (optional): help topic */
  1582.   if (ac >= 1) {
  1583.     topic = av[0];
  1584.   }
  1585.   if (strcmp(topic,"help") == 0){
  1586.     /* "help help": Print a list of all topics */
  1587.     fluid_ostream_printf(out,
  1588. "*** Help topics:***n"
  1589. "help all (prints all topics)n");
  1590.     for (i = 0; fluid_commands[i].name != NULL; i++) {
  1591.       int listed_first_time = 1;
  1592.       int ii;
  1593.       for (ii = 0; ii < i; ii++){
  1594. if (strcmp(fluid_commands[i].topic, fluid_commands[ii].topic) == 0){
  1595.   listed_first_time = 0;
  1596. }; /* if topic has already been listed */
  1597.       }; /* for all topics (inner loop) */
  1598.       if (listed_first_time){
  1599. fluid_ostream_printf(out, "help %sn",fluid_commands[i].topic);
  1600.       };
  1601.     }; /* for all topics (outer loop) */
  1602.   } else {
  1603.     /* help (arbitrary topic or "all") */
  1604.     for (i = 0; fluid_commands[i].name != NULL; i++) {
  1605.       fluid_cmd_t cmd = fluid_commands[i];
  1606.       if (cmd.help != NULL) {
  1607. if (strcmp(topic,"all") == 0 || strcmp(topic,cmd.topic) == 0){
  1608.   fluid_ostream_printf(out, "%sn", fluid_commands[i].help);
  1609.   count++;
  1610. }; /* if it matches the topic */
  1611.       }; /* if help text exists */
  1612.     }; /* foreach command */
  1613.     if (count == 0){
  1614.       fluid_ostream_printf(out, "Unknown help topic. Try 'help help'.n");
  1615.     };
  1616.   };
  1617.   return 0;
  1618. }
  1620. int
  1621. fluid_is_number(char* a)
  1622. {
  1623.   while (*a != 0) {
  1624.     if (((*a < '0') || (*a > '9')) && (*a != '-') && (*a != '+') && (*a != '.')) {
  1625.       return 0;
  1626.     }
  1627.     a++;
  1628.   }
  1629.   return 1;
  1630. }
  1632. int
  1633. fluid_is_empty(char* a)
  1634. {
  1635.   while (*a != 0) {
  1636.     if ((*a != ' ') && (*a != 't') && (*a != 'n') && (*a != 'r')) {
  1637.       return 0;
  1638.     }
  1639.     a++;
  1640.   }
  1641.   return 1;
  1642. }
  1644. char*
  1645. fluid_expand_path(char* path, char* new_path, int len)
  1646. {
  1647. #if defined(WIN32) || defined(MACOS9)
  1648.   snprintf(new_path, len - 1, "%s", path);
  1649. #else
  1650.   if ((path[0] == '~') && (path[1] == '/')) {
  1651.     char* home = getenv("HOME");
  1652.     if (home == NULL) {
  1653.       snprintf(new_path, len - 1, "%s", path);
  1654.     } else {
  1655.       snprintf(new_path, len - 1, "%s%s", home, &path[1]);
  1656.     }
  1657.   } else {
  1658.     snprintf(new_path, len - 1, "%s", path);
  1659.   }
  1660. #endif
  1662.   new_path[len - 1] = 0;
  1663.   return new_path;
  1664. }
  1668. /*
  1669.  * Command
  1670.  */
  1672. fluid_cmd_t* fluid_cmd_copy(fluid_cmd_t* cmd)
  1673. {
  1674.   fluid_cmd_t* copy = FLUID_NEW(fluid_cmd_t);
  1675.   if (copy == NULL) {
  1676.     FLUID_LOG (FLUID_PANIC, "Out of memory");
  1677.     return NULL;
  1678.   }
  1680.   copy->name = FLUID_STRDUP(cmd->name);
  1681.   copy->topic = FLUID_STRDUP(cmd->topic);
  1682.   copy->help = FLUID_STRDUP(cmd->help);
  1683.   copy->handler = cmd->handler;
  1684.   copy->data = cmd->data;
  1685.   return copy;
  1686. }
  1688. void delete_fluid_cmd(fluid_cmd_t* cmd)
  1689. {
  1690.   if (cmd->name) {
  1691.     FLUID_FREE(cmd->name);
  1692.   }
  1693.   if (cmd->topic) {
  1694.     FLUID_FREE(cmd->topic);
  1695.   }
  1696.   if (cmd->help) {
  1697.     FLUID_FREE(cmd->help);
  1698.   }
  1699.   FLUID_FREE(cmd);
  1700. }
  1702. /*
  1703.  * Command handler
  1704.  */
  1706. static void
  1707. fluid_cmd_handler_destroy_hash_value (void *value)
  1708. {
  1709.   delete_fluid_cmd ((fluid_cmd_t *)value);
  1710. }
  1712. /**
  1713.  * Create a new command handler.
  1714.  * @param synth If not NULL, all the default synthesizer commands will be
  1715.  *   added to the new handler.
  1716.  * @return New command handler
  1717.  */
  1718. fluid_cmd_handler_t *
  1719. new_fluid_cmd_handler(fluid_synth_t* synth)
  1720. {
  1721.   int i;
  1722.   fluid_cmd_handler_t* handler;
  1724.   fluid_cmd_t source = {
  1725.     "source", "general", (fluid_cmd_func_t) fluid_handle_source, NULL,
  1726.     "source filename            Load a file and parse every line as a command"
  1727.   };
  1729.   handler = new_fluid_hashtable_full (fluid_str_hash, fluid_str_equal,
  1730.                                       NULL, fluid_cmd_handler_destroy_hash_value);
  1731.   if (handler == NULL) {
  1732.     return NULL;
  1733.   }
  1735.   if (synth != NULL) {
  1736.     for (i = 0; fluid_commands[i].name != NULL; i++) {
  1737.       fluid_commands[i].data = synth;
  1738.       fluid_cmd_handler_register(handler, &fluid_commands[i]);
  1739.       fluid_commands[i].data = NULL;
  1740.     }
  1741.   }
  1743.   source.data = handler;
  1744.   fluid_cmd_handler_register(handler, &source);
  1746.   return handler;
  1747. }
  1749. /**
  1750.  * Delete a command handler.
  1751.  * @param handler Command handler to delete
  1752.  */
  1753. void
  1754. delete_fluid_cmd_handler(fluid_cmd_handler_t* handler)
  1755. {
  1756.   delete_fluid_hashtable (handler);
  1757. }
  1759. /**
  1760.  * Register a new command to the handler.
  1761.  * @param handler Command handler instance
  1762.  * @param cmd Command info (gets copied)
  1763.  * @return #FLUID_OK if command was inserted, #FLUID_FAILED otherwise
  1764.  */
  1765. int
  1766. fluid_cmd_handler_register(fluid_cmd_handler_t* handler, fluid_cmd_t* cmd)
  1767. {
  1768.   fluid_cmd_t* copy = fluid_cmd_copy(cmd);
  1769.   fluid_hashtable_insert(handler, copy->name, copy);
  1770.   return FLUID_OK;
  1771. }
  1773. /**
  1774.  * Unregister a command from a command handler.
  1775.  * @param handler Command handler instance
  1776.  * @param cmd Name of the command
  1777.  * @return TRUE if command was found and unregistered, FALSE otherwise
  1778.  */
  1779. int
  1780. fluid_cmd_handler_unregister(fluid_cmd_handler_t* handler, const char *cmd)
  1781. {
  1782.   return fluid_hashtable_remove(handler, cmd);
  1783. }
  1785. int
  1786. fluid_cmd_handler_handle(fluid_cmd_handler_t* handler, int ac, char** av, fluid_ostream_t out)
  1787. {
  1788.   fluid_cmd_t* cmd;
  1790.   cmd = fluid_hashtable_lookup(handler, av[0]);
  1792.   if (cmd && cmd->handler)
  1793.     return (*cmd->handler)(cmd->data, ac - 1, av + 1, out);
  1795.   fluid_ostream_printf(out, "unknown command: %s (try help)n", av[0]);
  1796.   return -1;
  1797. }
  1800. #if !defined(WITHOUT_SERVER)
  1804. struct _fluid_server_t {
  1805.   fluid_server_socket_t* socket;
  1806.   fluid_settings_t* settings;
  1807.   fluid_server_newclient_func_t newclient;
  1808.   void* data;
  1809.   fluid_list_t* clients;
  1810.   fluid_mutex_t mutex;
  1811. };
  1813. static void fluid_server_handle_connection(fluid_server_t* server,
  1814.   fluid_socket_t client_socket,
  1815.   char* addr);
  1816. static void fluid_server_close(fluid_server_t* server);
  1818. /**
  1819.  * Create a new TCP/IP command shell server.
  1820.  * @param settings Settings instance to use for the shell
  1821.  * @param newclient Callback function to call for each new client connection
  1822.  * @param data User defined data to pass to a newclient callback
  1823.  * @return New shell server instance or NULL on error
  1824.  */
  1825. fluid_server_t*
  1826. new_fluid_server(fluid_settings_t* settings,
  1827. fluid_server_newclient_func_t newclient,
  1828. void* data)
  1829. {
  1830.   fluid_server_t* server;
  1831.   int port;
  1833.   server = FLUID_NEW(fluid_server_t);
  1834.   if (server == NULL) {
  1835.     FLUID_LOG(FLUID_ERR, "Out of memory");
  1836.     return NULL;
  1837.   }
  1839.   server->settings = settings;
  1840.   server->clients = NULL;
  1841.   server->newclient = newclient;
  1842.   server->data = data;
  1844.   fluid_mutex_init(server->mutex);
  1846.   fluid_settings_getint(settings, "shell.port", &port);
  1848.   server->socket = new_fluid_server_socket(port,
  1849.   (fluid_server_func_t) fluid_server_handle_connection,
  1850.   server);
  1851.   if (server->socket == NULL) {
  1852.     FLUID_FREE(server);
  1853.     return NULL;
  1854.   }
  1856.   return server;
  1857. }
  1859. /**
  1860.  * Delete a TCP/IP shell server.
  1861.  * @param server Shell server instance
  1862.  */
  1863. void
  1864. delete_fluid_server(fluid_server_t* server)
  1865. {
  1866.   if (server == NULL) {
  1867.     return;
  1868.   }
  1870.   fluid_server_close(server);
  1872.   FLUID_FREE(server);
  1873. }
  1875. static void fluid_server_close(fluid_server_t* server)
  1876. {
  1877.   fluid_list_t* list;
  1878.   fluid_list_t* clients;
  1879.   fluid_client_t* client;
  1881.   if (server == NULL) {
  1882.     return;
  1883.   }
  1885.   fluid_mutex_lock(server->mutex);
  1886.   clients = server->clients;
  1887.   server->clients = NULL;
  1888.   fluid_mutex_unlock(server->mutex);
  1890.   list = clients;
  1892.   while (list) {
  1893.     client = fluid_list_get(list);
  1894.     fluid_client_quit(client);
  1895.     list = fluid_list_next(list);
  1896.   }
  1898.   delete_fluid_list(clients);
  1900.   if (server->socket) {
  1901.     delete_fluid_server_socket(server->socket);
  1902.     server->socket = NULL;
  1903.   }
  1904. }
  1906. static void
  1907. fluid_server_handle_connection(fluid_server_t* server, fluid_socket_t client_socket, char* addr)
  1908. {
  1909.   fluid_client_t* client;
  1910.   fluid_cmd_handler_t* handler;
  1912.   handler = server->newclient(server->data, addr);
  1913.   if (handler == NULL) {
  1914.     return;
  1915.   }
  1917.   client = new_fluid_client(server, server->settings, handler, client_socket);
  1918.   if (client == NULL) {
  1919.     return;
  1920.   }
  1921.   fluid_server_add_client(server, client);
  1922. }
  1924. void fluid_server_add_client(fluid_server_t* server, fluid_client_t* client)
  1925. {
  1926.   fluid_mutex_lock(server->mutex);
  1927.   server->clients = fluid_list_append(server->clients, client);
  1928.   fluid_mutex_unlock(server->mutex);
  1929. }
  1931. void fluid_server_remove_client(fluid_server_t* server, fluid_client_t* client)
  1932. {
  1933.   fluid_mutex_lock(server->mutex);
  1934.   server->clients = fluid_list_remove(server->clients, client);
  1935.   fluid_mutex_unlock(server->mutex);
  1936. }
  1938. /**
  1939.  * Join a shell server thread (wait until it quits).
  1940.  * @param server Shell server instance
  1941.  * @return #FLUID_OK on success, #FLUID_FAILED otherwise
  1942.  */
  1943. int fluid_server_join(fluid_server_t* server)
  1944. {
  1945.   return fluid_server_socket_join(server->socket);
  1946. }
  1951. struct _fluid_client_t {
  1952.   fluid_server_t* server;
  1953.   fluid_settings_t* settings;
  1954.   fluid_cmd_handler_t* handler;
  1955.   fluid_socket_t socket;
  1956.   fluid_thread_t* thread;
  1957. };
  1961. static void fluid_client_run(fluid_client_t* client)
  1962. {
  1963.   fluid_shell_t shell;
  1964.   fluid_shell_init(&shell,
  1965.   client->settings,
  1966.   client->handler,
  1967.   fluid_socket_get_istream(client->socket),
  1968.   fluid_socket_get_ostream(client->socket));
  1969.   fluid_shell_run(&shell);
  1970.   fluid_server_remove_client(client->server, client);
  1971.   delete_fluid_client(client);
  1972. }
  1975. fluid_client_t*
  1976. new_fluid_client(fluid_server_t* server, fluid_settings_t* settings,
  1977. fluid_cmd_handler_t* handler, fluid_socket_t sock)
  1978. {
  1979.   fluid_client_t* client;
  1981.   client = FLUID_NEW(fluid_client_t);
  1982.   if (client == NULL) {
  1983.     FLUID_LOG(FLUID_ERR, "Out of memory");
  1984.     return NULL;
  1985.   }
  1987.   client->server = server;
  1988.   client->socket = sock;
  1989.   client->settings = settings;
  1990.   client->handler = handler;
  1992.   client->thread = new_fluid_thread((fluid_thread_func_t) fluid_client_run, client,
  1993.                                     0, FALSE);
  1995.   if (client->thread == NULL) {
  1996.     fluid_socket_close(sock);
  1997.     FLUID_FREE(client);
  1998.     return NULL;
  1999.   }
  2001.   return client;
  2002. }
  2004. void fluid_client_quit(fluid_client_t* client)
  2005. {
  2006.   if (client->socket != INVALID_SOCKET) {
  2007.     fluid_socket_close(client->socket);
  2008.     client->socket = INVALID_SOCKET;
  2009.   }
  2010.   FLUID_LOG(FLUID_DBG, "fluid_client_quit: joining");
  2011.   fluid_thread_join(client->thread);
  2012.   FLUID_LOG(FLUID_DBG, "fluid_client_quit: done");
  2013. }
  2015. void delete_fluid_client(fluid_client_t* client)
  2016. {
  2017.   if (client->socket != INVALID_SOCKET) {
  2018.     fluid_socket_close(client->socket);
  2019.     client->socket = INVALID_SOCKET;
  2020.   }
  2021.   if (client->thread != NULL) {
  2022.     delete_fluid_thread(client->thread);
  2023.     client->thread = NULL;
  2024.   }
  2025.   FLUID_FREE(client);
  2026. }
  2029. #endif /* WITHOUT_SERVER */