mirror of
https://github.com/DrBeef/QuestZDoom.git
synced 2025-03-06 09:21:22 +00:00
1850 lines
49 KiB
C
1850 lines
49 KiB
C
/* FluidSynth - A Software Synthesizer
|
|
*
|
|
* Copyright (C) 2003 Peter Hanappe and others.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Library General Public License
|
|
* as published by the Free Software Foundation; either version 2 of
|
|
* the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Library General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Library General Public
|
|
* License along with this library; if not, write to the Free
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
|
* 02111-1307, USA
|
|
*/
|
|
|
|
#include "fluidsynth_priv.h"
|
|
#include "fluid_cmd.h"
|
|
#include "fluid_synth.h"
|
|
#include "fluid_settings.h"
|
|
#include "fluid_io.h"
|
|
#include "fluid_hash.h"
|
|
#include "fluid_sys.h"
|
|
#include "fluid_io.h"
|
|
#include "fluid_midi_router.h"
|
|
#include "fluid_sfont.h"
|
|
|
|
#if WITH_READLINE
|
|
#include <readline/readline.h>
|
|
#include <readline/history.h>
|
|
#endif
|
|
|
|
#define MAX_TOKENS 100 /* LADSPA plugins need lots of parameters */
|
|
#define MAX_COMMAND_LEN 1024 /* max command length accepted by fluid_command() */
|
|
#define FLUID_WORKLINELENGTH 1024 /* LADSPA plugins use long command lines */
|
|
|
|
void fluid_shell_settings(fluid_settings_t* settings)
|
|
{
|
|
fluid_settings_register_str(settings, "shell.prompt", "", 0, NULL, NULL);
|
|
fluid_settings_register_int(settings, "shell.port", 9800, 1, 65535, 0, NULL, NULL);
|
|
}
|
|
|
|
|
|
/** the table of all handled commands */
|
|
|
|
fluid_cmd_t fluid_commands[] = {
|
|
{ "help", "general", (fluid_cmd_func_t) fluid_handle_help, NULL,
|
|
"help Command summary. 'help help' for more help topics" },
|
|
{ "quit", "general", (fluid_cmd_func_t) fluid_handle_quit, NULL,
|
|
"quit Quit the synthesizer" },
|
|
{ "noteon", "event", (fluid_cmd_func_t) fluid_handle_noteon, NULL,
|
|
"noteon chan key vel Send noteon" },
|
|
{ "noteoff", "event", (fluid_cmd_func_t) fluid_handle_noteoff, NULL,
|
|
"noteoff chan key Send noteoff" },
|
|
{ "cc", "event", (fluid_cmd_func_t) fluid_handle_cc, NULL,
|
|
"cc chan ctrl value Send control-change message" },
|
|
{ "prog", "event", (fluid_cmd_func_t) fluid_handle_prog, NULL,
|
|
"prog chan num Send program-change message" },
|
|
{ "select", "event", (fluid_cmd_func_t) fluid_handle_select, NULL,
|
|
"select chan sfont bank prog Combination of bank-select and program-change" },
|
|
{ "load", "general", (fluid_cmd_func_t) fluid_handle_load, NULL,
|
|
"load file [reset] [bankofs] Load SoundFont (reset=0|1, def 1; bankofs=n, def 0)" },
|
|
{ "unload", "general", (fluid_cmd_func_t) fluid_handle_unload, NULL,
|
|
"unload id [reset] Unload SoundFont by ID (reset=0|1, default 1)"},
|
|
{ "reload", "general", (fluid_cmd_func_t) fluid_handle_reload, NULL,
|
|
"reload id Reload the SoundFont with the specified ID" },
|
|
{ "fonts", "general", (fluid_cmd_func_t) fluid_handle_fonts, NULL,
|
|
"fonts Display the list of loaded SoundFonts" },
|
|
{ "inst", "general", (fluid_cmd_func_t) fluid_handle_inst, NULL,
|
|
"inst font Print out the available instruments for the font" },
|
|
{ "channels", "general", (fluid_cmd_func_t) fluid_handle_channels, NULL,
|
|
"channels [-verbose] Print out preset of all channels" },
|
|
{ "interp", "general", (fluid_cmd_func_t) fluid_handle_interp, NULL,
|
|
"interp num Choose interpolation method for all channels" },
|
|
{ "interpc", "general", (fluid_cmd_func_t) fluid_handle_interpc, NULL,
|
|
"interpc chan num Choose interpolation method for one channel" },
|
|
{ "rev_preset", "reverb", (fluid_cmd_func_t) fluid_handle_reverbpreset, NULL,
|
|
"rev_preset num Load preset num into the reverb unit" },
|
|
{ "rev_setroomsize", "reverb", (fluid_cmd_func_t) fluid_handle_reverbsetroomsize, NULL,
|
|
"rev_setroomsize num Change reverb room size" },
|
|
{ "rev_setdamp", "reverb", (fluid_cmd_func_t) fluid_handle_reverbsetdamp, NULL,
|
|
"rev_setdamp num Change reverb damping" },
|
|
{ "rev_setwidth", "reverb", (fluid_cmd_func_t) fluid_handle_reverbsetwidth, NULL,
|
|
"rev_setwidth num Change reverb width" },
|
|
{ "rev_setlevel", "reverb", (fluid_cmd_func_t) fluid_handle_reverbsetlevel, NULL,
|
|
"rev_setlevel num Change reverb level" },
|
|
{ "reverb", "reverb", (fluid_cmd_func_t) fluid_handle_reverb, NULL,
|
|
"reverb [0|1|on|off] Turn the reverb on or off" },
|
|
{ "cho_set_nr", "chorus", (fluid_cmd_func_t) fluid_handle_chorusnr, NULL,
|
|
"cho_set_nr n Use n delay lines (default 3)" },
|
|
{ "cho_set_level", "chorus", (fluid_cmd_func_t) fluid_handle_choruslevel, NULL,
|
|
"cho_set_level num Set output level of each chorus line to num" },
|
|
{ "cho_set_speed", "chorus", (fluid_cmd_func_t) fluid_handle_chorusspeed, NULL,
|
|
"cho_set_speed num Set mod speed of chorus to num (Hz)" },
|
|
{ "cho_set_depth", "chorus", (fluid_cmd_func_t) fluid_handle_chorusdepth, NULL,
|
|
"cho_set_depth num Set chorus modulation depth to num (ms)" },
|
|
{ "chorus", "chorus", (fluid_cmd_func_t) fluid_handle_chorus, NULL,
|
|
"chorus [0|1|on|off] Turn the chorus on or off" },
|
|
{ "gain", "general", (fluid_cmd_func_t) fluid_handle_gain, NULL,
|
|
"gain value Set the master gain (0 < gain < 5)" },
|
|
{ "tuning", "tuning", (fluid_cmd_func_t) fluid_handle_tuning, NULL,
|
|
"tuning name bank prog Create a tuning with name, bank number, \n"
|
|
" and program number (0 <= bank,prog <= 127)" },
|
|
{ "tune", "tuning", (fluid_cmd_func_t) fluid_handle_tune, NULL,
|
|
"tune bank prog key pitch Tune a key" },
|
|
{ "settuning", "tuning", (fluid_cmd_func_t) fluid_handle_settuning, NULL,
|
|
"settuning chan bank prog Set the tuning for a MIDI channel" },
|
|
{ "resettuning", "tuning", (fluid_cmd_func_t) fluid_handle_resettuning, NULL,
|
|
"resettuning chan Restore the default tuning of a MIDI channel" },
|
|
{ "tunings", "tuning", (fluid_cmd_func_t) fluid_handle_tunings, NULL,
|
|
"tunings Print the list of available tunings" },
|
|
{ "dumptuning", "tuning", (fluid_cmd_func_t) fluid_handle_dumptuning, NULL,
|
|
"dumptuning bank prog Print the pitch details of the tuning" },
|
|
{ "reset", "general", (fluid_cmd_func_t) fluid_handle_reset, NULL,
|
|
"reset System reset (all notes off, reset controllers)" },
|
|
{ "set", "settings", (fluid_cmd_func_t) fluid_handle_set, NULL,
|
|
"set name value Set the value of a controller or settings" },
|
|
{ "get", "settings", (fluid_cmd_func_t) fluid_handle_get, NULL,
|
|
"get name Get the value of a controller or settings" },
|
|
{ "info", "settings", (fluid_cmd_func_t) fluid_handle_info, NULL,
|
|
"info name Get information about a controller or settings" },
|
|
{ "settings", "settings", (fluid_cmd_func_t) fluid_handle_settings, NULL,
|
|
"settings Print out all settings" },
|
|
{ "echo", "general", (fluid_cmd_func_t) fluid_handle_echo, NULL,
|
|
"echo arg Print arg" },
|
|
/* LADSPA-related commands */
|
|
#ifdef LADSPA
|
|
{ "ladspa_clear", "ladspa", (fluid_cmd_func_t) fluid_LADSPA_handle_clear, NULL,
|
|
"ladspa_clear Resets LADSPA effect unit to bypass state"},
|
|
{ "ladspa_add", "ladspa", (fluid_cmd_func_t) fluid_LADSPA_handle_add, NULL,
|
|
"ladspa_add lib plugin n1 <- p1 n2 -> p2 ... Loads and connects LADSPA plugin"},
|
|
{ "ladspa_start", "ladspa", (fluid_cmd_func_t) fluid_LADSPA_handle_start, NULL,
|
|
"ladspa_start Starts LADSPA effect unit"},
|
|
{ "ladspa_declnode", "ladspa", (fluid_cmd_func_t) fluid_LADSPA_handle_declnode, NULL,
|
|
"ladspa_declnode node value Declares control node `node' with value `value'"},
|
|
{ "ladspa_setnode", "ladspa", (fluid_cmd_func_t) fluid_LADSPA_handle_setnode, NULL,
|
|
"ladspa_setnode node value Assigns `value' to `node'"},
|
|
#endif
|
|
{ "router_clear", "router", (fluid_cmd_func_t) fluid_midi_router_handle_clear, NULL,
|
|
"router_clear Clears all routing rules from the midi router"},
|
|
{ "router_default", "router", (fluid_cmd_func_t) fluid_midi_router_handle_default, NULL,
|
|
"router_default Resets the midi router to default state"},
|
|
{ "router_begin", "router", (fluid_cmd_func_t) fluid_midi_router_handle_begin, NULL,
|
|
"router_begin [note|cc|prog|pbend|cpress|kpress]: Starts a new routing rule"},
|
|
{ "router_chan", "router", (fluid_cmd_func_t) fluid_midi_router_handle_chan, NULL,
|
|
"router_chan min max mul add filters and maps midi channels on current rule"},
|
|
{ "router_par1", "router", (fluid_cmd_func_t) fluid_midi_router_handle_par1, NULL,
|
|
"router_par1 min max mul add filters and maps parameter 1 (key/ctrl nr)"},
|
|
{ "router_par2", "router", (fluid_cmd_func_t) fluid_midi_router_handle_par2, NULL,
|
|
"router_par2 min max mul add filters and maps parameter 2 (vel/cc val)"},
|
|
{ "router_end", "router", (fluid_cmd_func_t) fluid_midi_router_handle_end, NULL,
|
|
"router_end closes and commits the current routing rule"},
|
|
{ NULL, NULL, NULL, NULL, NULL }
|
|
};
|
|
|
|
/**
|
|
* Process a string command.
|
|
* NOTE: FluidSynth 1.0.8+ no longer modifies the 'cmd' string.
|
|
* @param handle FluidSynth command handler
|
|
* @param cmd Command string (NOTE: Gets modified by FluidSynth prior to 1.0.8)
|
|
* @param out Output stream to display command response to
|
|
* @return Integer value corresponding to: -1 on command error, 0 on success,
|
|
* 1 if 'cmd' is a comment or is empty and -2 if quit was issued
|
|
*/
|
|
int
|
|
fluid_command(fluid_cmd_handler_t* handler, char* cmd, fluid_ostream_t out)
|
|
{
|
|
char* token[MAX_TOKENS];
|
|
char buf[MAX_COMMAND_LEN+1];
|
|
char *strtok, *tok;
|
|
int num_tokens = 0;
|
|
|
|
if (cmd[0] == '#') {
|
|
return 1;
|
|
}
|
|
|
|
if (strlen (cmd) > MAX_COMMAND_LEN)
|
|
{
|
|
fluid_ostream_printf(out, "Command exceeded max length of %d chars\n",
|
|
MAX_COMMAND_LEN);
|
|
return -1;
|
|
}
|
|
|
|
FLUID_STRCPY(buf, cmd); /* copy - since fluid_strtok thrashes it */
|
|
strtok = buf;
|
|
|
|
/* tokenize the input line */
|
|
while ((tok = fluid_strtok (&strtok, " \t\n\r")))
|
|
token[num_tokens++] = tok;
|
|
|
|
if (num_tokens == 0) return 1;
|
|
|
|
/* handle the command */
|
|
return fluid_cmd_handler_handle(handler, num_tokens, &token[0], out);
|
|
}
|
|
|
|
struct _fluid_shell_t {
|
|
fluid_settings_t* settings;
|
|
fluid_cmd_handler_t* handler;
|
|
fluid_thread_t* thread;
|
|
fluid_istream_t in;
|
|
fluid_ostream_t out;
|
|
};
|
|
|
|
int fluid_shell_run(fluid_shell_t* shell);
|
|
void fluid_shell_init(fluid_shell_t* shell,
|
|
fluid_settings_t* settings, fluid_cmd_handler_t* handler,
|
|
fluid_istream_t in, fluid_ostream_t out);
|
|
|
|
|
|
fluid_shell_t* new_fluid_shell(fluid_settings_t* settings, fluid_cmd_handler_t* handler,
|
|
fluid_istream_t in, fluid_ostream_t out, int thread)
|
|
{
|
|
fluid_shell_t* shell = FLUID_NEW(fluid_shell_t);
|
|
if (shell == NULL) {
|
|
FLUID_LOG (FLUID_PANIC, "Out of memory");
|
|
return NULL;
|
|
}
|
|
|
|
|
|
fluid_shell_init(shell, settings, handler, in, out);
|
|
|
|
if (thread) {
|
|
shell->thread = new_fluid_thread((fluid_thread_func_t) fluid_shell_run, shell, 1);
|
|
if (shell->thread == NULL) {
|
|
delete_fluid_shell(shell);
|
|
return NULL;
|
|
}
|
|
} else {
|
|
shell->thread = NULL;
|
|
fluid_shell_run(shell);
|
|
}
|
|
|
|
return shell;
|
|
|
|
}
|
|
|
|
void fluid_shell_init(fluid_shell_t* shell,
|
|
fluid_settings_t* settings, fluid_cmd_handler_t* handler,
|
|
fluid_istream_t in, fluid_ostream_t out)
|
|
{
|
|
shell->settings = settings;
|
|
shell->handler = handler;
|
|
shell->in = in;
|
|
shell->out = out;
|
|
}
|
|
|
|
void delete_fluid_shell(fluid_shell_t* shell)
|
|
{
|
|
if (shell->thread != NULL) {
|
|
delete_fluid_thread(shell->thread);
|
|
}
|
|
|
|
FLUID_FREE(shell);
|
|
}
|
|
|
|
|
|
int fluid_shell_run(fluid_shell_t* shell)
|
|
{
|
|
char workline[FLUID_WORKLINELENGTH];
|
|
char* prompt = "";
|
|
int cont = 1;
|
|
int errors = 0;
|
|
int n;
|
|
|
|
if (shell->settings) {
|
|
fluid_settings_getstr(shell->settings, "shell.prompt", &prompt);
|
|
}
|
|
|
|
/* handle user input */
|
|
while (cont) {
|
|
|
|
n = fluid_istream_readline(shell->in, prompt, workline, FLUID_WORKLINELENGTH);
|
|
|
|
if (n < 0) {
|
|
break;
|
|
}
|
|
|
|
#if WITH_READLINE
|
|
if (shell->in == fluid_get_stdin()) {
|
|
add_history(workline);
|
|
}
|
|
#endif
|
|
|
|
/* handle the command */
|
|
switch (fluid_command(shell->handler, workline, shell->out)) {
|
|
|
|
case 1: /* empty line or comment */
|
|
break;
|
|
|
|
case -1: /* erronous command */
|
|
errors++;
|
|
case 0: /* valid command */
|
|
break;
|
|
|
|
case -2: /* quit */
|
|
cont = 0;
|
|
break;
|
|
}
|
|
|
|
if (n == 0) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
return errors;
|
|
}
|
|
|
|
|
|
void
|
|
fluid_usershell(fluid_settings_t* settings, fluid_cmd_handler_t* handler)
|
|
{
|
|
fluid_shell_t shell;
|
|
fluid_shell_init(&shell, settings, handler, fluid_get_stdin(), fluid_get_stdout());
|
|
fluid_shell_run(&shell);
|
|
}
|
|
|
|
int
|
|
fluid_source(fluid_cmd_handler_t* handler, char* filename)
|
|
{
|
|
int file;
|
|
fluid_shell_t shell;
|
|
|
|
#ifdef WIN32
|
|
file = _open(filename, _O_RDONLY);
|
|
#else
|
|
file = open(filename, O_RDONLY);
|
|
#endif
|
|
if (file < 0) {
|
|
return file;
|
|
}
|
|
fluid_shell_init(&shell, NULL, handler, file, fluid_get_stdout());
|
|
return fluid_shell_run(&shell);
|
|
}
|
|
|
|
|
|
char*
|
|
fluid_get_userconf(char* buf, int len)
|
|
{
|
|
#if defined(WIN32) || defined(MACOS9)
|
|
return NULL;
|
|
#else
|
|
char* home = getenv("HOME");
|
|
if (home == NULL) {
|
|
return NULL;
|
|
} else {
|
|
snprintf(buf, len, "%s/.fluidsynth", home);
|
|
return buf;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
char*
|
|
fluid_get_sysconf(char* buf, int len)
|
|
{
|
|
#if defined(WIN32) || defined(MACOS9)
|
|
return NULL;
|
|
#else
|
|
snprintf(buf, len, "/etc/fluidsynth.conf");
|
|
return buf;
|
|
#endif
|
|
}
|
|
|
|
|
|
/*
|
|
* handlers
|
|
*/
|
|
int
|
|
fluid_handle_noteon(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
if (ac < 3) {
|
|
fluid_ostream_printf(out, "noteon: too few arguments\n");
|
|
return -1;
|
|
}
|
|
if (!fluid_is_number(av[0]) || !fluid_is_number(av[1]) || !fluid_is_number(av[2])) {
|
|
fluid_ostream_printf(out, "noteon: invalid argument\n");
|
|
return -1;
|
|
}
|
|
return fluid_synth_noteon(synth, atoi(av[0]), atoi(av[1]), atoi(av[2]));
|
|
}
|
|
|
|
int
|
|
fluid_handle_noteoff(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
if (ac < 2) {
|
|
fluid_ostream_printf(out, "noteoff: too few arguments\n");
|
|
return -1;
|
|
}
|
|
if (!fluid_is_number(av[0]) || !fluid_is_number(av[1])) {
|
|
fluid_ostream_printf(out, "noteon: invalid argument\n");
|
|
return -1;
|
|
}
|
|
return fluid_synth_noteoff(synth, atoi(av[0]), atoi(av[1]));
|
|
}
|
|
|
|
int
|
|
fluid_handle_cc(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
if (ac < 3) {
|
|
fluid_ostream_printf(out, "cc: too few arguments\n");
|
|
return -1;
|
|
}
|
|
if (!fluid_is_number(av[0]) || !fluid_is_number(av[1]) || !fluid_is_number(av[2])) {
|
|
fluid_ostream_printf(out, "cc: invalid argument\n");
|
|
return -1;
|
|
}
|
|
return fluid_synth_cc(synth, atoi(av[0]), atoi(av[1]), atoi(av[2]));
|
|
}
|
|
|
|
int
|
|
fluid_handle_prog(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
if (ac < 2) {
|
|
fluid_ostream_printf(out, "prog: too few arguments\n");
|
|
return -1;
|
|
}
|
|
if (!fluid_is_number(av[0]) || !fluid_is_number(av[1])) {
|
|
fluid_ostream_printf(out, "prog: invalid argument\n");
|
|
return -1;
|
|
}
|
|
return fluid_synth_program_change(synth, atoi(av[0]), atoi(av[1]));
|
|
}
|
|
|
|
int
|
|
fluid_handle_select(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
int sfont_id;
|
|
int chan;
|
|
int bank;
|
|
int prog;
|
|
|
|
if (ac < 4) {
|
|
fluid_ostream_printf(out, "preset: too few arguments\n");
|
|
return -1;
|
|
}
|
|
if (!fluid_is_number(av[0]) || !fluid_is_number(av[1])
|
|
|| !fluid_is_number(av[2]) || !fluid_is_number(av[3])) {
|
|
fluid_ostream_printf(out, "preset: invalid argument\n");
|
|
return -1;
|
|
}
|
|
|
|
chan = atoi(av[0]);
|
|
sfont_id = atoi(av[1]);
|
|
bank = atoi(av[2]);
|
|
prog = atoi(av[3]);
|
|
|
|
if (sfont_id != 0) {
|
|
return fluid_synth_program_select(synth, chan, sfont_id, bank, prog);
|
|
} else {
|
|
if (fluid_synth_bank_select(synth, chan, bank) == FLUID_OK) {
|
|
return fluid_synth_program_change(synth, chan, prog);
|
|
}
|
|
return FLUID_FAILED;
|
|
}
|
|
}
|
|
|
|
int
|
|
fluid_handle_inst(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
int font;
|
|
fluid_sfont_t* sfont;
|
|
fluid_preset_t preset;
|
|
int offset;
|
|
|
|
if (ac < 1) {
|
|
fluid_ostream_printf(out, "inst: too few arguments\n");
|
|
return -1;
|
|
}
|
|
|
|
if (!fluid_is_number(av[0])) {
|
|
fluid_ostream_printf(out, "inst: invalid argument\n");
|
|
return -1;
|
|
}
|
|
|
|
font = atoi(av[0]);
|
|
|
|
sfont = fluid_synth_get_sfont_by_id(synth, font);
|
|
offset = fluid_synth_get_bank_offset(synth, font);
|
|
|
|
if (sfont == NULL) {
|
|
fluid_ostream_printf(out, "inst: invalid font number\n");
|
|
return -1;
|
|
}
|
|
|
|
fluid_sfont_iteration_start(sfont);
|
|
|
|
while (fluid_sfont_iteration_next(sfont, &preset)) {
|
|
fluid_ostream_printf(out, "%03d-%03d %s\n",
|
|
fluid_preset_get_banknum(&preset) + offset,
|
|
fluid_preset_get_num(&preset),
|
|
fluid_preset_get_name(&preset));
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int
|
|
fluid_handle_channels(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
int i;
|
|
fluid_preset_t* preset;
|
|
int verbose = 0;
|
|
|
|
if (ac > 0 && strcmp( av[0], "-verbose") == 0) verbose = 1;
|
|
|
|
for (i = 0; i < fluid_synth_count_midi_channels(synth); i++) {
|
|
preset = fluid_synth_get_channel_preset(synth, i);
|
|
if (preset == NULL) fluid_ostream_printf(out, "chan %d, no preset\n", i);
|
|
else if (!verbose) fluid_ostream_printf(out, "chan %d, %s\n", i, fluid_preset_get_name(preset));
|
|
else fluid_ostream_printf(out, "chan %d, sfont %d, bank %d, preset %d, %s\n", i,
|
|
fluid_sfont_get_id( preset->sfont),
|
|
fluid_preset_get_banknum(preset),
|
|
fluid_preset_get_num(preset),
|
|
fluid_preset_get_name(preset));
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
fluid_handle_load(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
char buf[1024];
|
|
int id;
|
|
int reset = 1;
|
|
int offset = 0;
|
|
|
|
if (ac < 1) {
|
|
fluid_ostream_printf(out, "load: too few arguments\n");
|
|
return -1;
|
|
}
|
|
if (ac == 2) {
|
|
reset = atoi(av[1]);
|
|
}
|
|
if (ac == 3) {
|
|
offset = atoi(av[2]);
|
|
}
|
|
|
|
/* Load the SoundFont without resetting the programs. The reset will
|
|
* be done later (if requested). */
|
|
id = fluid_synth_sfload(synth, fluid_expand_path(av[0], buf, 1024), 0);
|
|
|
|
if (id == -1) {
|
|
fluid_ostream_printf(out, "failed to load the SoundFont\n");
|
|
return -1;
|
|
} else {
|
|
fluid_ostream_printf(out, "loaded SoundFont has ID %d\n", id);
|
|
}
|
|
|
|
if (offset) {
|
|
fluid_synth_set_bank_offset(synth, id, offset);
|
|
}
|
|
|
|
/* The reset should be done after the offset is set. */
|
|
if (reset) {
|
|
fluid_synth_program_reset(synth);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
fluid_handle_unload(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
int reset = 1;
|
|
if (ac < 1) {
|
|
fluid_ostream_printf(out, "unload: too few arguments\n");
|
|
return -1;
|
|
}
|
|
if (!fluid_is_number(av[0])) {
|
|
fluid_ostream_printf(out, "unload: expected a number as argument\n");
|
|
return -1;
|
|
}
|
|
if (ac == 2) {
|
|
reset = atoi(av[1]);
|
|
}
|
|
if (fluid_synth_sfunload(synth, atoi(av[0]), reset) != 0) {
|
|
fluid_ostream_printf(out, "failed to unload the SoundFont\n");
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
fluid_handle_reload(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
if (ac < 1) {
|
|
fluid_ostream_printf(out, "reload: too few arguments\n");
|
|
return -1;
|
|
}
|
|
if (!fluid_is_number(av[0])) {
|
|
fluid_ostream_printf(out, "reload: expected a number as argument\n");
|
|
return -1;
|
|
}
|
|
if (fluid_synth_sfreload(synth, atoi(av[0])) == -1) {
|
|
fluid_ostream_printf(out, "failed to reload the SoundFont\n");
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
int
|
|
fluid_handle_fonts(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
int i;
|
|
fluid_sfont_t* sfont;
|
|
int num;
|
|
|
|
num = fluid_synth_sfcount(synth);
|
|
|
|
if (num == 0) {
|
|
fluid_ostream_printf(out, "no SoundFont loaded (try load)\n");
|
|
return 0;
|
|
}
|
|
|
|
fluid_ostream_printf(out, "ID Name\n");
|
|
|
|
for (i = 0; i < num; i++) {
|
|
sfont = fluid_synth_get_sfont(synth, i);
|
|
fluid_ostream_printf(out, "%2d %s\n",
|
|
fluid_sfont_get_id(sfont),
|
|
fluid_sfont_get_name(sfont));
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
fluid_handle_mstat(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
/* fluid_ostream_printf(out, "Dvr=%s, Dev=%s\n", */
|
|
/* fluid_midi_handler_get_driver_name(midi), */
|
|
/* fluid_midi_handler_get_device_name(midi)); */
|
|
/* fluid_ostream_printf(out, "Stat=%s, On=%d, Off=%d, Prog=%d, Pbend=%d, Err=%d\n", */
|
|
/* fluid_midi_handler_get_status(midi), */
|
|
/* fluid_midi_handler_get_event_count(midi, 0x90), */
|
|
/* fluid_midi_handler_get_event_count(midi, 0x80), */
|
|
/* fluid_midi_handler_get_event_count(midi, 0xc0), */
|
|
/* fluid_midi_handler_get_event_count(midi, 0xe0), */
|
|
/* fluid_midi_handler_get_event_count(midi, 0)); */
|
|
fluid_ostream_printf(out, "not yet implemented\n");
|
|
return -1;
|
|
}
|
|
|
|
/* Purpose:
|
|
* Response to 'rev_preset' command.
|
|
* Load the values from a reverb preset into the reverb unit. */
|
|
int
|
|
fluid_handle_reverbpreset(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
int reverb_preset_number;
|
|
if (ac < 1) {
|
|
fluid_ostream_printf(out, "rev_preset: too few arguments\n");
|
|
return -1;
|
|
}
|
|
reverb_preset_number = atoi(av[0]);
|
|
if (fluid_synth_set_reverb_preset(synth, reverb_preset_number)!=FLUID_OK){
|
|
fluid_ostream_printf(out, "rev_preset: Failed. Parameter out of range?\n");
|
|
return -1;
|
|
};
|
|
return 0;
|
|
}
|
|
|
|
/* Purpose:
|
|
* Response to 'rev_setroomsize' command.
|
|
* Load the new room size into the reverb unit. */
|
|
int
|
|
fluid_handle_reverbsetroomsize(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
fluid_real_t room_size;
|
|
if (ac < 1) {
|
|
fluid_ostream_printf(out, "rev_setroomsize: too few arguments.\n");
|
|
return -1;
|
|
}
|
|
room_size = atof(av[0]);
|
|
if (room_size < 0){
|
|
fluid_ostream_printf(out, "rev_setroomsize: Room size must be positive!\n");
|
|
return -1;
|
|
}
|
|
if (room_size > 1.2){
|
|
fluid_ostream_printf(out, "rev_setroomsize: Room size too big!\n");
|
|
return -1;
|
|
}
|
|
fluid_revmodel_setroomsize(synth->reverb, room_size);
|
|
return 0;
|
|
}
|
|
|
|
/* Purpose:
|
|
* Response to 'rev_setdamp' command.
|
|
* Load the new damp factor into the reverb unit. */
|
|
int
|
|
fluid_handle_reverbsetdamp(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
fluid_real_t damp;
|
|
if (ac < 1) {
|
|
fluid_ostream_printf(out, "rev_setdamp: too few arguments.\n");
|
|
return -1;
|
|
}
|
|
damp = atof(av[0]);
|
|
if ((damp < 0.0f) || (damp > 1)){
|
|
fluid_ostream_printf(out, "rev_setdamp: damp must be between 0 and 1!\n");
|
|
return -1;
|
|
}
|
|
fluid_revmodel_setdamp(synth->reverb, damp);
|
|
return 0;
|
|
}
|
|
|
|
/* Purpose:
|
|
* Response to 'rev_setwidth' command.
|
|
* Load the new width into the reverb unit. */
|
|
int
|
|
fluid_handle_reverbsetwidth(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
fluid_real_t width;
|
|
if (ac < 1) {
|
|
fluid_ostream_printf(out, "rev_setwidth: too few arguments.\n");
|
|
return -1;
|
|
}
|
|
width = atof(av[0]);
|
|
if ((width < 0) || (width > 100)){
|
|
fluid_ostream_printf(out, "rev_setroomsize: Too wide! (0..100)\n");
|
|
return 0;
|
|
}
|
|
fluid_revmodel_setwidth(synth->reverb, width);
|
|
return 0;
|
|
}
|
|
|
|
/* Purpose:
|
|
* Response to 'rev_setlevel' command.
|
|
* Load the new level into the reverb unit. */
|
|
int
|
|
fluid_handle_reverbsetlevel(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
fluid_real_t level;
|
|
if (ac < 1) {
|
|
fluid_ostream_printf(out, "rev_setlevel: too few arguments.\n");
|
|
return -1;
|
|
}
|
|
level = atof(av[0]);
|
|
if (abs(level) > 30){
|
|
fluid_ostream_printf(out, "rev_setlevel: Value too high! (Value of 10 =+20 dB)\n");
|
|
return 0;
|
|
}
|
|
fluid_revmodel_setlevel(synth->reverb, level);
|
|
return 0;
|
|
}
|
|
|
|
/* Purpose:
|
|
* Response to 'reverb' command.
|
|
* Change the FLUID_REVERB flag in the synth */
|
|
int
|
|
fluid_handle_reverb(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
if (ac < 1) {
|
|
fluid_ostream_printf(out, "reverb: too few arguments.\n");
|
|
return -1;
|
|
}
|
|
|
|
if ((strcmp(av[0], "0") == 0) || (strcmp(av[0], "off") == 0)) {
|
|
fluid_synth_set_reverb_on(synth,0);
|
|
} else if ((strcmp(av[0], "1") == 0) || (strcmp(av[0], "on") == 0)) {
|
|
fluid_synth_set_reverb_on(synth,1);
|
|
} else {
|
|
fluid_ostream_printf(out, "reverb: invalid arguments %s [0|1|on|off]", av[0]);
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* Purpose:
|
|
* Response to 'chorus_setnr' command */
|
|
int
|
|
fluid_handle_chorusnr(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
int nr;
|
|
if (ac < 1) {
|
|
fluid_ostream_printf(out, "cho_set_nr: too few arguments.\n");
|
|
return -1;
|
|
}
|
|
nr = atoi(av[0]);
|
|
fluid_chorus_set_nr(synth->chorus, nr);
|
|
return fluid_chorus_update(synth->chorus);
|
|
}
|
|
|
|
/* Purpose:
|
|
* Response to 'chorus_setlevel' command */
|
|
int
|
|
fluid_handle_choruslevel(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
fluid_real_t level;
|
|
if (ac < 1) {
|
|
fluid_ostream_printf(out, "cho_set_level: too few arguments.\n");
|
|
return -1;
|
|
}
|
|
level = atof(av[0]);
|
|
fluid_chorus_set_level(synth->chorus, level);
|
|
return fluid_chorus_update(synth->chorus);
|
|
|
|
}
|
|
|
|
/* Purpose:
|
|
* Response to 'chorus_setspeed' command */
|
|
int
|
|
fluid_handle_chorusspeed(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
fluid_real_t speed;
|
|
if (ac < 1) {
|
|
fluid_ostream_printf(out, "cho_set_speed: too few arguments.\n");
|
|
return -1;
|
|
}
|
|
speed = atof(av[0]);
|
|
fluid_chorus_set_speed_Hz(synth->chorus, speed);
|
|
return fluid_chorus_update(synth->chorus);
|
|
}
|
|
|
|
/* Purpose:
|
|
* Response to 'chorus_setdepth' command */
|
|
int
|
|
fluid_handle_chorusdepth(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
fluid_real_t depth;
|
|
if (ac < 1) {
|
|
fluid_ostream_printf(out, "cho_set_depth: too few arguments.\n");
|
|
return -1;
|
|
}
|
|
depth = atof(av[0]);
|
|
fluid_chorus_set_depth_ms(synth->chorus, depth);
|
|
return fluid_chorus_update(synth->chorus);
|
|
}
|
|
|
|
int
|
|
fluid_handle_chorus(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
if (ac < 1) {
|
|
fluid_ostream_printf(out, "chorus: too few arguments\n");
|
|
return -1;
|
|
}
|
|
|
|
if ((strcmp(av[0], "0") == 0) || (strcmp(av[0], "off") == 0)) {
|
|
fluid_synth_set_chorus_on(synth,0);
|
|
} else if ((strcmp(av[0], "1") == 0) || (strcmp(av[0], "on") == 0)) {
|
|
fluid_synth_set_chorus_on(synth,1);
|
|
} else {
|
|
fluid_ostream_printf(out, "chorus: invalid arguments %s [0|1|on|off]", av[0]);
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Purpose:
|
|
* Response to the 'echo' command.
|
|
* The command itself is useful, when the synth is used via TCP/IP.
|
|
* It can signal for example, that a list of commands has been processed.
|
|
*/
|
|
int
|
|
fluid_handle_echo(fluid_cmd_handler_t* handler, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
if (ac < 1) {
|
|
fluid_ostream_printf(out, "echo: too few arguments.\n");
|
|
return -1;
|
|
}
|
|
|
|
fluid_ostream_printf(out, "%s\n",av[0]);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
fluid_handle_source(fluid_cmd_handler_t* handler, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
if (ac < 1) {
|
|
fluid_ostream_printf(out, "source: too few arguments.\n");
|
|
return -1;
|
|
}
|
|
|
|
fluid_source(handler, av[0]);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Purpose:
|
|
* Response to 'gain' command. */
|
|
int
|
|
fluid_handle_gain(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
float gain;
|
|
|
|
if (ac < 1) {
|
|
fluid_ostream_printf(out, "gain: too few arguments.\n");
|
|
return -1;
|
|
}
|
|
|
|
gain = atof(av[0]);
|
|
|
|
if ((gain < 0.0f) || (gain > 5.0f)) {
|
|
fluid_ostream_printf(out, "gain: value should be between '0' and '5'.\n");
|
|
return -1;
|
|
};
|
|
|
|
fluid_synth_set_gain(synth, gain);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Purpose:
|
|
* Response to 'interp' command. */
|
|
int
|
|
fluid_handle_interp(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
int interp;
|
|
int chan=-1; /* -1: Set all channels */
|
|
|
|
if (ac < 1) {
|
|
fluid_ostream_printf(out, "interp: too few arguments.\n");
|
|
return -1;
|
|
}
|
|
|
|
interp = atoi(av[0]);
|
|
|
|
if ((interp < 0) || (interp > FLUID_INTERP_HIGHEST)) {
|
|
fluid_ostream_printf(out, "interp: Bad value\n");
|
|
return -1;
|
|
};
|
|
|
|
fluid_synth_set_interp_method(synth, chan, interp);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Purpose:
|
|
* Response to 'interp' command. */
|
|
int
|
|
fluid_handle_interpc(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
int interp;
|
|
int chan;
|
|
|
|
if (ac < 2) {
|
|
fluid_ostream_printf(out, "interpc: too few arguments.\n");
|
|
return -1;
|
|
}
|
|
|
|
chan = atoi(av[0]);
|
|
interp = atoi(av[1]);
|
|
|
|
if ((chan < 0) || (chan >= fluid_synth_count_midi_channels(synth))){
|
|
fluid_ostream_printf(out, "interp: Bad value for channel number.\n");
|
|
return -1;
|
|
};
|
|
if ((interp < 0) || (interp > FLUID_INTERP_HIGHEST)) {
|
|
fluid_ostream_printf(out, "interp: Bad value for interpolation method.\n");
|
|
return -1;
|
|
};
|
|
|
|
fluid_synth_set_interp_method(synth, chan, interp);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
fluid_handle_tuning(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
char *name;
|
|
int bank, prog;
|
|
|
|
if (ac < 3) {
|
|
fluid_ostream_printf(out, "tuning: too few arguments.\n");
|
|
return -1;
|
|
}
|
|
|
|
name = av[0];
|
|
|
|
if (!fluid_is_number(av[1])) {
|
|
fluid_ostream_printf(out, "tuning: 2nd argument should be a number.\n");
|
|
return -1;
|
|
}
|
|
bank = atoi(av[1]);
|
|
if ((bank < 0) || (bank >= 128)){
|
|
fluid_ostream_printf(out, "tuning: invalid bank number.\n");
|
|
return -1;
|
|
};
|
|
|
|
if (!fluid_is_number(av[2])) {
|
|
fluid_ostream_printf(out, "tuning: 3rd argument should be a number.\n");
|
|
return -1;
|
|
}
|
|
prog = atoi(av[2]);
|
|
if ((prog < 0) || (prog >= 128)){
|
|
fluid_ostream_printf(out, "tuning: invalid program number.\n");
|
|
return -1;
|
|
};
|
|
|
|
fluid_synth_create_key_tuning(synth, bank, prog, name, NULL);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
fluid_handle_tune(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
int bank, prog, key;
|
|
double pitch;
|
|
|
|
if (ac < 4) {
|
|
fluid_ostream_printf(out, "tune: too few arguments.\n");
|
|
return -1;
|
|
}
|
|
|
|
if (!fluid_is_number(av[0])) {
|
|
fluid_ostream_printf(out, "tune: 1st argument should be a number.\n");
|
|
return -1;
|
|
}
|
|
bank = atoi(av[0]);
|
|
if ((bank < 0) || (bank >= 128)){
|
|
fluid_ostream_printf(out, "tune: invalid bank number.\n");
|
|
return -1;
|
|
};
|
|
|
|
if (!fluid_is_number(av[1])) {
|
|
fluid_ostream_printf(out, "tune: 2nd argument should be a number.\n");
|
|
return -1;
|
|
}
|
|
prog = atoi(av[1]);
|
|
if ((prog < 0) || (prog >= 128)){
|
|
fluid_ostream_printf(out, "tune: invalid program number.\n");
|
|
return -1;
|
|
};
|
|
|
|
if (!fluid_is_number(av[2])) {
|
|
fluid_ostream_printf(out, "tune: 3rd argument should be a number.\n");
|
|
return -1;
|
|
}
|
|
key = atoi(av[2]);
|
|
if ((key < 0) || (key >= 128)){
|
|
fluid_ostream_printf(out, "tune: invalid key number.\n");
|
|
return -1;
|
|
};
|
|
|
|
pitch = atof(av[3]);
|
|
if (pitch < 0.0f) {
|
|
fluid_ostream_printf(out, "tune: invalid pitch.\n");
|
|
return -1;
|
|
};
|
|
|
|
fluid_synth_tune_notes(synth, bank, prog, 1, &key, &pitch, 0);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
fluid_handle_settuning(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
int chan, bank, prog;
|
|
|
|
if (ac < 3) {
|
|
fluid_ostream_printf(out, "settuning: too few arguments.\n");
|
|
return -1;
|
|
}
|
|
|
|
if (!fluid_is_number(av[0])) {
|
|
fluid_ostream_printf(out, "tune: 1st argument should be a number.\n");
|
|
return -1;
|
|
}
|
|
chan = atoi(av[0]);
|
|
if ((chan < 0) || (chan >= fluid_synth_count_midi_channels(synth))){
|
|
fluid_ostream_printf(out, "tune: invalid channel number.\n");
|
|
return -1;
|
|
};
|
|
|
|
if (!fluid_is_number(av[1])) {
|
|
fluid_ostream_printf(out, "tuning: 2nd argument should be a number.\n");
|
|
return -1;
|
|
}
|
|
bank = atoi(av[1]);
|
|
if ((bank < 0) || (bank >= 128)){
|
|
fluid_ostream_printf(out, "tuning: invalid bank number.\n");
|
|
return -1;
|
|
};
|
|
|
|
if (!fluid_is_number(av[2])) {
|
|
fluid_ostream_printf(out, "tuning: 3rd argument should be a number.\n");
|
|
return -1;
|
|
}
|
|
prog = atoi(av[2]);
|
|
if ((prog < 0) || (prog >= 128)){
|
|
fluid_ostream_printf(out, "tuning: invalid program number.\n");
|
|
return -1;
|
|
};
|
|
|
|
fluid_synth_select_tuning(synth, chan, bank, prog);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
fluid_handle_resettuning(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
int chan;
|
|
|
|
if (ac < 1) {
|
|
fluid_ostream_printf(out, "resettuning: too few arguments.\n");
|
|
return -1;
|
|
}
|
|
|
|
if (!fluid_is_number(av[0])) {
|
|
fluid_ostream_printf(out, "tune: 1st argument should be a number.\n");
|
|
return -1;
|
|
}
|
|
chan = atoi(av[0]);
|
|
if ((chan < 0) || (chan >= fluid_synth_count_midi_channels(synth))){
|
|
fluid_ostream_printf(out, "tune: invalid channel number.\n");
|
|
return -1;
|
|
};
|
|
|
|
fluid_synth_reset_tuning(synth, chan);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
fluid_handle_tunings(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
int bank, prog;
|
|
char name[256];
|
|
int count = 0;
|
|
|
|
fluid_synth_tuning_iteration_start(synth);
|
|
|
|
while (fluid_synth_tuning_iteration_next(synth, &bank, &prog)) {
|
|
fluid_synth_tuning_dump(synth, bank, prog, name, 256, NULL);
|
|
fluid_ostream_printf(out, "%03d-%03d %s\n", bank, prog, name);
|
|
count++;
|
|
}
|
|
|
|
if (count == 0) {
|
|
fluid_ostream_printf(out, "No tunings available\n");
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
fluid_handle_dumptuning(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
int bank, prog, i;
|
|
double pitch[128];
|
|
char name[256];
|
|
|
|
if (ac < 2) {
|
|
fluid_ostream_printf(out, "dumptuning: too few arguments.\n");
|
|
return -1;
|
|
}
|
|
|
|
if (!fluid_is_number(av[0])) {
|
|
fluid_ostream_printf(out, "dumptuning: 1st argument should be a number.\n");
|
|
return -1;
|
|
}
|
|
bank = atoi(av[0]);
|
|
if ((bank < 0) || (bank >= 128)){
|
|
fluid_ostream_printf(out, "dumptuning: invalid bank number.\n");
|
|
return -1;
|
|
};
|
|
|
|
if (!fluid_is_number(av[1])) {
|
|
fluid_ostream_printf(out, "dumptuning: 2nd argument should be a number.\n");
|
|
return -1;
|
|
}
|
|
prog = atoi(av[1]);
|
|
if ((prog < 0) || (prog >= 128)){
|
|
fluid_ostream_printf(out, "dumptuning: invalid program number.\n");
|
|
return -1;
|
|
};
|
|
|
|
fluid_synth_tuning_dump(synth, bank, prog, name, 256, pitch);
|
|
|
|
fluid_ostream_printf(out, "%03d-%03d %s:\n", bank, prog, name);
|
|
|
|
for (i = 0; i < 128; i++) {
|
|
fluid_ostream_printf(out, "key %03d, pitch %5.2f\n", i, pitch[i]);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
fluid_handle_set(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
if (ac < 2) {
|
|
fluid_ostream_printf(out, "set: too few arguments.\n");
|
|
return -1;
|
|
}
|
|
|
|
if (fluid_is_number(av[1])) {
|
|
if (FLUID_STRCHR(av[1], '.') != NULL) {
|
|
fluid_synth_setnum(synth, av[0], atof(av[1]));
|
|
} else {
|
|
fluid_synth_setint(synth, av[0], atoi(av[1]));
|
|
}
|
|
} else {
|
|
fluid_synth_setstr(synth, av[0], av[1]);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
fluid_handle_get(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
if (ac < 1) {
|
|
fluid_ostream_printf(out, "get: too few arguments.\n");
|
|
return -1;
|
|
}
|
|
|
|
switch (fluid_settings_get_type(fluid_synth_get_settings(synth), av[0])) {
|
|
case FLUID_NO_TYPE:
|
|
fluid_ostream_printf(out, "get: no such settings '%s'.", av[0]);
|
|
return -1;
|
|
|
|
case FLUID_NUM_TYPE: {
|
|
double value;
|
|
fluid_synth_getnum(synth, av[0], &value);
|
|
fluid_ostream_printf(out, "%.3f", value);
|
|
break;
|
|
}
|
|
|
|
case FLUID_INT_TYPE: {
|
|
int value;
|
|
fluid_synth_getint(synth, av[0], &value);
|
|
fluid_ostream_printf(out, "%d", value);
|
|
break;
|
|
}
|
|
|
|
case FLUID_STR_TYPE: {
|
|
char* s;
|
|
fluid_synth_getstr(synth, av[0], &s);
|
|
fluid_ostream_printf(out, "%s", s);
|
|
break;
|
|
}
|
|
|
|
case FLUID_SET_TYPE:
|
|
fluid_ostream_printf(out, "%s is a node", av[0]);
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
struct _fluid_handle_settings_data_t {
|
|
int len;
|
|
fluid_synth_t* synth;
|
|
fluid_ostream_t out;
|
|
};
|
|
|
|
static void fluid_handle_settings_iter1(void* data, char* name, int type)
|
|
{
|
|
struct _fluid_handle_settings_data_t* d = (struct _fluid_handle_settings_data_t*) data;
|
|
|
|
int len = FLUID_STRLEN(name);
|
|
if (len > d->len) {
|
|
d->len = len;
|
|
}
|
|
}
|
|
|
|
static void fluid_handle_settings_iter2(void* data, char* name, int type)
|
|
{
|
|
struct _fluid_handle_settings_data_t* d = (struct _fluid_handle_settings_data_t*) data;
|
|
|
|
int len = FLUID_STRLEN(name);
|
|
fluid_ostream_printf(d->out, "%s", name);
|
|
while (len++ < d->len) {
|
|
fluid_ostream_printf(d->out, " ");
|
|
}
|
|
fluid_ostream_printf(d->out, " ");
|
|
|
|
switch (fluid_settings_get_type(fluid_synth_get_settings(d->synth), name)) {
|
|
case FLUID_NUM_TYPE: {
|
|
double value;
|
|
fluid_synth_getnum(d->synth, name, &value);
|
|
fluid_ostream_printf(d->out, "%.3f\n", value);
|
|
break;
|
|
}
|
|
|
|
case FLUID_INT_TYPE: {
|
|
int value;
|
|
fluid_synth_getint(d->synth, name, &value);
|
|
fluid_ostream_printf(d->out, "%d\n", value);
|
|
break;
|
|
}
|
|
|
|
case FLUID_STR_TYPE: {
|
|
char* s;
|
|
fluid_synth_getstr(d->synth, name, &s);
|
|
fluid_ostream_printf(d->out, "%s\n", s);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
int
|
|
fluid_handle_settings(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
struct _fluid_handle_settings_data_t data;
|
|
|
|
data.len = 0;
|
|
data.synth = synth;
|
|
data.out = out;
|
|
|
|
fluid_settings_foreach(fluid_synth_get_settings(synth), &data, fluid_handle_settings_iter1);
|
|
fluid_settings_foreach(fluid_synth_get_settings(synth), &data, fluid_handle_settings_iter2);
|
|
return 0;
|
|
}
|
|
|
|
|
|
struct _fluid_handle_option_data_t {
|
|
int first;
|
|
fluid_ostream_t out;
|
|
};
|
|
|
|
void fluid_handle_print_option(void* data, char* name, char* option)
|
|
{
|
|
struct _fluid_handle_option_data_t* d = (struct _fluid_handle_option_data_t*) data;
|
|
|
|
if (d->first) {
|
|
fluid_ostream_printf(d->out, "%s", option);
|
|
d->first = 0;
|
|
} else {
|
|
fluid_ostream_printf(d->out, ", %s", option);
|
|
}
|
|
}
|
|
|
|
int
|
|
fluid_handle_info(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
fluid_settings_t* settings = fluid_synth_get_settings(synth);
|
|
struct _fluid_handle_option_data_t data;
|
|
|
|
if (ac < 1) {
|
|
fluid_ostream_printf(out, "info: too few arguments.\n");
|
|
return -1;
|
|
}
|
|
|
|
switch (fluid_settings_get_type(settings, av[0])) {
|
|
case FLUID_NO_TYPE:
|
|
fluid_ostream_printf(out, "info: no such settings '%s'.", av[0]);
|
|
return -1;
|
|
|
|
case FLUID_NUM_TYPE: {
|
|
double value, min, max;
|
|
fluid_settings_getnum_range(settings, av[0], &min, &max);
|
|
fluid_settings_getnum(settings, av[0], &value);
|
|
fluid_ostream_printf(out, "%s:\n", av[0]);
|
|
fluid_ostream_printf(out, "Type: number\n");
|
|
fluid_ostream_printf(out, "Value: %.3f\n", value);
|
|
fluid_ostream_printf(out, "Minimum value: %.3f\n", min);
|
|
fluid_ostream_printf(out, "Maximum value: %.3f\n", max);
|
|
fluid_ostream_printf(out, "Default value: %.3f\n",
|
|
fluid_settings_getnum_default(settings, av[0]));
|
|
fluid_ostream_printf(out, "Real-time: %s\n",
|
|
fluid_settings_is_realtime(settings, av[0])? "yes" : "no");
|
|
break;
|
|
}
|
|
|
|
case FLUID_INT_TYPE: {
|
|
int value, min, max;
|
|
fluid_settings_getint_range(settings, av[0], &min, &max);
|
|
fluid_settings_getint(settings, av[0], &value);
|
|
fluid_ostream_printf(out, "%s:\n", av[0]);
|
|
fluid_ostream_printf(out, "Type: integer\n");
|
|
fluid_ostream_printf(out, "Value: %d\n", value);
|
|
fluid_ostream_printf(out, "Minimum value: %d\n", min);
|
|
fluid_ostream_printf(out, "Maximum value: %d\n", max);
|
|
fluid_ostream_printf(out, "Default value: %d\n",
|
|
fluid_settings_getint_default(settings, av[0]));
|
|
fluid_ostream_printf(out, "Real-time: %s\n",
|
|
fluid_settings_is_realtime(settings, av[0])? "yes" : "no");
|
|
break;
|
|
}
|
|
|
|
case FLUID_STR_TYPE: {
|
|
char *s;
|
|
fluid_settings_getstr(settings, av[0], &s);
|
|
fluid_ostream_printf(out, "%s:\n", av[0]);
|
|
fluid_ostream_printf(out, "Type: string\n");
|
|
fluid_ostream_printf(out, "Value: %s\n", s);
|
|
fluid_ostream_printf(out, "Default value: %s\n",
|
|
fluid_settings_getstr_default(settings, av[0]));
|
|
|
|
data.out = out;
|
|
data.first = 1;
|
|
fluid_ostream_printf(out, "Options: ");
|
|
fluid_settings_foreach_option(settings, av[0], &data, fluid_handle_print_option);
|
|
fluid_ostream_printf(out, "\n");
|
|
|
|
fluid_ostream_printf(out, "Real-time: %s\n",
|
|
fluid_settings_is_realtime(settings, av[0])? "yes" : "no");
|
|
break;
|
|
}
|
|
|
|
case FLUID_SET_TYPE:
|
|
fluid_ostream_printf(out, "%s is a node", av[0]);
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
fluid_handle_reset(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
fluid_synth_system_reset(synth);
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
fluid_handle_quit(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
fluid_ostream_printf(out, "cheers!\n");
|
|
return -2;
|
|
}
|
|
|
|
int
|
|
fluid_handle_help(fluid_synth_t* synth, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
/* Purpose:
|
|
* Prints the help text for the command line commands.
|
|
* Can be used as follows:
|
|
* - help
|
|
* - help (topic), where (topic) is 'general', 'chorus', etc.
|
|
* - help all
|
|
* - help help
|
|
*/
|
|
|
|
char* topic = "general"; /* default, if no topic is given */
|
|
int count = 0;
|
|
int i;
|
|
|
|
fluid_ostream_printf(out, "\n");
|
|
/* 1st argument (optional): help topic */
|
|
if (ac >= 1) {
|
|
topic = av[0];
|
|
}
|
|
if (strcmp(topic,"help") == 0){
|
|
/* "help help": Print a list of all topics */
|
|
fluid_ostream_printf(out,
|
|
"*** Help topics:***\n"
|
|
"help help (prints this list)\n"
|
|
"help all (prints all topics)\n");
|
|
for (i = 0; fluid_commands[i].name != NULL; i++) {
|
|
int listed_first_time = 1;
|
|
int ii;
|
|
for (ii = 0; ii < i; ii++){
|
|
if (strcmp(fluid_commands[i].topic, fluid_commands[ii].topic) == 0){
|
|
listed_first_time = 0;
|
|
}; /* if topic has already been listed */
|
|
}; /* for all topics (inner loop) */
|
|
if (listed_first_time){
|
|
fluid_ostream_printf(out, "help %s\n",fluid_commands[i].topic);
|
|
};
|
|
}; /* for all topics (outer loop) */
|
|
} else {
|
|
/* help (arbitrary topic or "all") */
|
|
for (i = 0; fluid_commands[i].name != NULL; i++) {
|
|
fluid_cmd_t cmd = fluid_commands[i];
|
|
if (cmd.help != NULL) {
|
|
if (strcmp(topic,"all") == 0 || strcmp(topic,cmd.topic) == 0){
|
|
fluid_ostream_printf(out, "%s\n", fluid_commands[i].help);
|
|
count++;
|
|
}; /* if it matches the topic */
|
|
}; /* if help text exists */
|
|
}; /* foreach command */
|
|
if (count == 0){
|
|
fluid_ostream_printf(out, "Unknown help topic. Try 'help help'.\n");
|
|
};
|
|
};
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
fluid_is_number(char* a)
|
|
{
|
|
while (*a != 0) {
|
|
if (((*a < '0') || (*a > '9')) && (*a != '-') && (*a != '+') && (*a != '.')) {
|
|
return 0;
|
|
}
|
|
a++;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int
|
|
fluid_is_empty(char* a)
|
|
{
|
|
while (*a != 0) {
|
|
if ((*a != ' ') && (*a != '\t') && (*a != '\n') && (*a != '\r')) {
|
|
return 0;
|
|
}
|
|
a++;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
char*
|
|
fluid_expand_path(char* path, char* new_path, int len)
|
|
{
|
|
#if defined(WIN32) || defined(MACOS9)
|
|
snprintf(new_path, len - 1, "%s", path);
|
|
#else
|
|
if ((path[0] == '~') && (path[1] == '/')) {
|
|
char* home = getenv("HOME");
|
|
if (home == NULL) {
|
|
snprintf(new_path, len - 1, "%s", path);
|
|
} else {
|
|
snprintf(new_path, len - 1, "%s%s", home, &path[1]);
|
|
}
|
|
} else {
|
|
snprintf(new_path, len - 1, "%s", path);
|
|
}
|
|
#endif
|
|
|
|
new_path[len - 1] = 0;
|
|
return new_path;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* Command
|
|
*/
|
|
|
|
fluid_cmd_t* fluid_cmd_copy(fluid_cmd_t* cmd)
|
|
{
|
|
fluid_cmd_t* copy = FLUID_NEW(fluid_cmd_t);
|
|
if (copy == NULL) {
|
|
FLUID_LOG (FLUID_PANIC, "Out of memory");
|
|
return NULL;
|
|
}
|
|
|
|
copy->name = FLUID_STRDUP(cmd->name);
|
|
copy->topic = FLUID_STRDUP(cmd->topic);
|
|
copy->help = FLUID_STRDUP(cmd->help);
|
|
copy->handler = cmd->handler;
|
|
copy->data = cmd->data;
|
|
return copy;
|
|
}
|
|
|
|
void delete_fluid_cmd(fluid_cmd_t* cmd)
|
|
{
|
|
if (cmd->name) {
|
|
FLUID_FREE(cmd->name);
|
|
}
|
|
if (cmd->topic) {
|
|
FLUID_FREE(cmd->topic);
|
|
}
|
|
if (cmd->help) {
|
|
FLUID_FREE(cmd->help);
|
|
}
|
|
FLUID_FREE(cmd);
|
|
}
|
|
|
|
/*
|
|
* Command handler
|
|
*/
|
|
|
|
void fluid_cmd_handler_delete(void* value, int type)
|
|
{
|
|
delete_fluid_cmd((fluid_cmd_t*) value);
|
|
}
|
|
|
|
fluid_cmd_handler_t* new_fluid_cmd_handler(fluid_synth_t* synth)
|
|
{
|
|
int i;
|
|
fluid_cmd_handler_t* handler;
|
|
|
|
fluid_cmd_t source = {
|
|
"source", "general", (fluid_cmd_func_t) fluid_handle_source, NULL,
|
|
"source filename Load a file and parse every line as a command"
|
|
};
|
|
|
|
handler = new_fluid_hashtable(fluid_cmd_handler_delete);
|
|
if (handler == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
if (synth != NULL) {
|
|
for (i = 0; fluid_commands[i].name != NULL; i++) {
|
|
fluid_commands[i].data = synth;
|
|
fluid_cmd_handler_register(handler, &fluid_commands[i]);
|
|
fluid_commands[i].data = NULL;
|
|
}
|
|
}
|
|
|
|
source.data = handler;
|
|
fluid_cmd_handler_register(handler, &source);
|
|
|
|
return handler;
|
|
}
|
|
|
|
void delete_fluid_cmd_handler(fluid_cmd_handler_t* handler)
|
|
{
|
|
delete_fluid_hashtable(handler);
|
|
}
|
|
|
|
int fluid_cmd_handler_register(fluid_cmd_handler_t* handler, fluid_cmd_t* cmd)
|
|
{
|
|
fluid_cmd_t* copy = fluid_cmd_copy(cmd);
|
|
fluid_hashtable_insert(handler, copy->name, copy, 0);
|
|
return 0;
|
|
}
|
|
|
|
int fluid_cmd_handler_unregister(fluid_cmd_handler_t* handler, char* cmd)
|
|
{
|
|
return fluid_hashtable_remove(handler, cmd);
|
|
}
|
|
|
|
int fluid_cmd_handler_handle(fluid_cmd_handler_t* handler, int ac, char** av, fluid_ostream_t out)
|
|
{
|
|
void *vp; /* use a void pointer to avoid GCC "type-punned pointer" warning */
|
|
fluid_cmd_t* cmd;
|
|
|
|
if (fluid_hashtable_lookup(handler, av[0], &vp, NULL)
|
|
&& ((fluid_cmd_t *)vp)->handler) {
|
|
cmd = vp;
|
|
return (*cmd->handler)(cmd->data, ac - 1, av + 1, out);
|
|
} else {
|
|
fluid_ostream_printf(out, "unknown command: %s (try help)\n", av[0]);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
|
|
#if !defined(WITHOUT_SERVER)
|
|
|
|
|
|
|
|
struct _fluid_server_t {
|
|
fluid_server_socket_t* socket;
|
|
fluid_settings_t* settings;
|
|
fluid_server_newclient_func_t newclient;
|
|
void* data;
|
|
fluid_list_t* clients;
|
|
fluid_mutex_t mutex;
|
|
};
|
|
|
|
static void fluid_server_handle_connection(fluid_server_t* server,
|
|
fluid_socket_t client_socket,
|
|
char* addr);
|
|
static void fluid_server_close(fluid_server_t* server);
|
|
|
|
fluid_server_t*
|
|
new_fluid_server(fluid_settings_t* settings,
|
|
fluid_server_newclient_func_t newclient,
|
|
void* data)
|
|
{
|
|
fluid_server_t* server;
|
|
int port;
|
|
|
|
server = FLUID_NEW(fluid_server_t);
|
|
if (server == NULL) {
|
|
FLUID_LOG(FLUID_ERR, "Out of memory");
|
|
return NULL;
|
|
}
|
|
|
|
server->settings = settings;
|
|
server->clients = NULL;
|
|
server->newclient = newclient;
|
|
server->data = data;
|
|
|
|
fluid_mutex_init(server->mutex);
|
|
|
|
fluid_settings_getint(settings, "shell.port", &port);
|
|
|
|
server->socket = new_fluid_server_socket(port,
|
|
(fluid_server_func_t) fluid_server_handle_connection,
|
|
server);
|
|
if (server->socket == NULL) {
|
|
FLUID_FREE(server);
|
|
return NULL;
|
|
}
|
|
|
|
return server;
|
|
}
|
|
|
|
void delete_fluid_server(fluid_server_t* server)
|
|
{
|
|
if (server == NULL) {
|
|
return;
|
|
}
|
|
|
|
fluid_server_close(server);
|
|
|
|
FLUID_FREE(server);
|
|
}
|
|
|
|
static void fluid_server_close(fluid_server_t* server)
|
|
{
|
|
fluid_list_t* list;
|
|
fluid_list_t* clients;
|
|
fluid_client_t* client;
|
|
|
|
if (server == NULL) {
|
|
return;
|
|
}
|
|
|
|
fluid_mutex_lock(server->mutex);
|
|
clients = server->clients;
|
|
server->clients = NULL;
|
|
fluid_mutex_unlock(server->mutex);
|
|
|
|
list = clients;
|
|
|
|
while (list) {
|
|
client = fluid_list_get(list);
|
|
fluid_client_quit(client);
|
|
list = fluid_list_next(list);
|
|
}
|
|
|
|
delete_fluid_list(clients);
|
|
|
|
if (server->socket) {
|
|
delete_fluid_server_socket(server->socket);
|
|
server->socket = NULL;
|
|
}
|
|
}
|
|
|
|
static void
|
|
fluid_server_handle_connection(fluid_server_t* server, fluid_socket_t client_socket, char* addr)
|
|
{
|
|
fluid_client_t* client;
|
|
fluid_cmd_handler_t* handler;
|
|
|
|
handler = server->newclient(server->data, addr);
|
|
if (handler == NULL) {
|
|
return;
|
|
}
|
|
|
|
client = new_fluid_client(server, server->settings, handler, client_socket);
|
|
if (client == NULL) {
|
|
return;
|
|
}
|
|
fluid_server_add_client(server, client);
|
|
}
|
|
|
|
void fluid_server_add_client(fluid_server_t* server, fluid_client_t* client)
|
|
{
|
|
fluid_mutex_lock(server->mutex);
|
|
server->clients = fluid_list_append(server->clients, client);
|
|
fluid_mutex_unlock(server->mutex);
|
|
}
|
|
|
|
void fluid_server_remove_client(fluid_server_t* server, fluid_client_t* client)
|
|
{
|
|
fluid_mutex_lock(server->mutex);
|
|
server->clients = fluid_list_remove(server->clients, client);
|
|
fluid_mutex_unlock(server->mutex);
|
|
}
|
|
|
|
int fluid_server_join(fluid_server_t* server)
|
|
{
|
|
return fluid_server_socket_join(server->socket);
|
|
}
|
|
|
|
|
|
|
|
|
|
struct _fluid_client_t {
|
|
fluid_server_t* server;
|
|
fluid_settings_t* settings;
|
|
fluid_cmd_handler_t* handler;
|
|
fluid_socket_t socket;
|
|
fluid_thread_t* thread;
|
|
};
|
|
|
|
|
|
|
|
static void fluid_client_run(fluid_client_t* client)
|
|
{
|
|
fluid_shell_t shell;
|
|
fluid_shell_init(&shell,
|
|
client->settings,
|
|
client->handler,
|
|
fluid_socket_get_istream(client->socket),
|
|
fluid_socket_get_ostream(client->socket));
|
|
fluid_shell_run(&shell);
|
|
fluid_server_remove_client(client->server, client);
|
|
delete_fluid_client(client);
|
|
}
|
|
|
|
|
|
fluid_client_t*
|
|
new_fluid_client(fluid_server_t* server, fluid_settings_t* settings,
|
|
fluid_cmd_handler_t* handler, fluid_socket_t sock)
|
|
{
|
|
fluid_client_t* client;
|
|
|
|
client = FLUID_NEW(fluid_client_t);
|
|
if (client == NULL) {
|
|
FLUID_LOG(FLUID_ERR, "Out of memory");
|
|
return NULL;
|
|
}
|
|
|
|
client->server = server;
|
|
client->socket = sock;
|
|
client->settings = settings;
|
|
client->handler = handler;
|
|
|
|
client->thread = new_fluid_thread((fluid_thread_func_t) fluid_client_run, client, 0);
|
|
|
|
if (client->thread == NULL) {
|
|
fluid_socket_close(sock);
|
|
FLUID_FREE(client);
|
|
return NULL;
|
|
}
|
|
|
|
return client;
|
|
}
|
|
|
|
void fluid_client_quit(fluid_client_t* client)
|
|
{
|
|
if (client->socket != INVALID_SOCKET) {
|
|
fluid_socket_close(client->socket);
|
|
client->socket = INVALID_SOCKET;
|
|
}
|
|
FLUID_LOG(FLUID_DBG, "fluid_client_quit: joining");
|
|
fluid_thread_join(client->thread);
|
|
FLUID_LOG(FLUID_DBG, "fluid_client_quit: done");
|
|
}
|
|
|
|
void delete_fluid_client(fluid_client_t* client)
|
|
{
|
|
if (client->socket != INVALID_SOCKET) {
|
|
fluid_socket_close(client->socket);
|
|
client->socket = INVALID_SOCKET;
|
|
}
|
|
if (client->thread != NULL) {
|
|
delete_fluid_thread(client->thread);
|
|
client->thread = NULL;
|
|
}
|
|
FLUID_FREE(client);
|
|
}
|
|
|
|
|
|
#endif /* WITHOUT_SERVER */
|