SoundFont(R) is a registered trademark of E-mu Systems, Inc.
API additions:
All settings have a name that follows the "dotted-name" notation. For example, "synth.polyphony" refers to the number of voices (polyphony) preallocated by the synthesizer. The settings also have a type. There are currently three types: strings, numbers (double floats), and integers. You can change the values of a setting using the fluid_settings_setstr(), fluid_settings_setnum(), and fluid_settings_setint() functions. For example:
#include <fluidsynth.h> int main(int argc, char** argv) { fluid_settings_t* settings = new_fluid_settings(); fluid_synth_setint(settings, "synth.polyphony", 128); /* ... */ delete_fluid_settings(settings); return 0; }
The API contains the functions to query the type, the current value, the default value, the range and the "hints" of a setting. The range is the minimum and maximum value of the setting. The hints gives additional information about a setting. For example, whether a string represents a filename. Or whether a number should be interpreted on on a logarithmic scale. Check the settings.h API documentation for a description of all functions.
#include <fluidsynth.h> int main(int argc, char** argv) { fluid_settings_t* settings; fluid_synth_t* synth; settings = new_fluid_settings(); synth = new_fluid_synth(settings); /* Do useful things here */ delete_fluid_synth(synth); delete_fluid_settings(settings); return 0; }
The following table provides details on all the settings used by the synthesizer.
synth.audio-channels | Type | integer |
Default | 1 | |
Min-Max | 1-128 | |
Description | By default, the synthesizer outputs a single stereo signal. Using this option, the synthesizer can output multichannel audio. Sets the number of stereo channel pairs. So 1 is actually 2 channels (a stereo pair).
| |
synth.audio-groups | Type | integer |
Default | 1 | |
Min-Max | 1-128 | |
Description | Normally the same value as synth.audio-channels. LADSPA effects subsystem can use this value though, in which case it may differ.
| |
synth.chorus.active | Type | boolean |
Default | 1 (TRUE) | |
Description | When set to 1 (TRUE) the chorus effects module is activated. Otherwise, no chorus will be added to the output signal. Note that the amount of signal sent to the chorus module depends on the "chorus send" generator defined in the SoundFont.
| |
synth.cpu-cores | Type | integer |
Default | 1 | |
Min-Max | 1-256 | |
Description | (Experimental) Sets the number of synthesis CPU cores. If set to a value greater than 1, then additional synthesis threads will be created to take advantage of a multi CPU or CPU core system. This has the affect of utilizing more of the total CPU for voices or decreasing render times when synthesizing audio to a file.
| |
synth.device-id | Type | integer |
Default | 0 | |
Min-Max | 0-126 | |
Description | Device identifier used for SYSEX commands, such as MIDI Tuning Standard commands. Only those SYSEX commands destined for this ID or to all devices will be acted upon.
| |
synth.dump | Type | boolean |
Default | 0 (FALSE) | |
Description | Does nothing currently.
| |
synth.effects-channels | Type | integer |
Default | 2 | |
Min-Max | 2-2 | |
Description |
| |
synth.gain | Type | number |
Default | 0.2 | |
Min-Max | 0.0-10.0 | |
Description | The gain is applied to the final or master output of the synthesizer. It is set to a low value by default to avoid the saturation of the output when many notes are played.
| |
synth.ladspa.active | Type | boolean |
Default | 0 (FALSE) | |
Description | When set to "yes" the LADSPA subsystem will be enabled. This subsystem allows to load and interconnect LADSPA plug-ins. The output of the synthesizer is processed by the LADSPA subsystem. Note that the synthesizer has to be compiled with LADSPA support. More information about the LADSPA subsystem later.
| |
synth.midi-channels | Type | integer |
Default | 16 | |
Min-Max | 16-256 | |
Description | This setting defines the number of MIDI channels of the synthesizer. The MIDI standard defines 16 channels, so MIDI hardware is limited to this number. Internally FluidSynth can use more channels which can be mapped to different MIDI sources.
| |
synth.midi-bank-select | Type | string |
Default | gs | |
Options | gm, gs, xg, mma | |
Description | This setting defines how the synthesizer interprets Bank Select messages.
| |
synth.min-note-length | Type | integer |
Default | 10 | |
Min-Max | 0-65535 | |
Description | Sets the minimum note duration in milliseconds. This ensures that really short duration note events, such as percussion notes, have a better chance of sounding as intended. Set to 0 to disable this feature.
| |
synth.parallel-render | Type | boolean |
Default | 1 (TRUE) | |
Description | synth.parallel-render is the low-latency setting. If on, you're allowed to call fluid_synth_write_s16, fluid_synth_write_float, fluid_synth_nwrite_float or fluid_synth_process in parallel with the rest of the calls, and it won't be blocked by time intensive calls to the synth. Turn it off if throughput is more important than latency, e g in rendering-to-file scenarios where underruns is not an issue.
| |
synth.polyphony | Type | integer |
Default | 256 | |
Min-Max | 1-65535 | |
Description | The polyphony defines how many voices can be played in parallel. A note event produces one or more voices. Its good to set this to a value which the system can handle and will thus limit FluidSynth's CPU usage. When FluidSynth runs out of voices it will begin terminating lower priority voices for new note events.
| |
synth.reverb.active | Type | boolean |
Default | 1 (TRUE) | |
Description | When set to 1 (TRUE) the reverb effects module is activated. Otherwise, no reverb will be added to the output signal. Note that the amount of signal sent to the reverb module depends on the "reverb send" generator defined in the SoundFont.
| |
synth.sample-rate | Type | number |
Default | 44100 | |
Min-Max | 22050-96000 | |
Description | The sample rate of the audio generated by the synthesizer.
| |
synth.threadsafe-api | Type | boolean |
Default | 1 (TRUE) | |
Description | synth.threadsafe-api controls whether the synth's public API is protected by a mutex or not. Default is on, turn it off for slightly better performance if you know you're only accessing the synth from one thread only, this could be the case in many embedded use cases for example. Note that libfluidsynth can use many threads by itself (shell is one, midi driver is one, midi player is one etc) so you should usually leave it on. Also see synth.parallel-render.
| |
synth.verbose | Type | boolean |
Default | 0 (FALSE) | |
Description | When set to 1 (TRUE) the synthesizer will print out information about the received MIDI events to the stdout. This can be helpful for debugging. This setting cannot be changed after the synthesizer has started. |
Creating the audio driver is straightforward: set the appropriate settings and create the driver object. Because the FluidSynth has support for several audio systems, you may want to change which one you want to use. The list below shows the audio systems that are currently supported. It displays the name, as used by the fluidsynth library, and a description.
The default audio driver depends on the settings with which FluidSynth was compiled. You can get the default driver with fluid_settings_getstr_default(). To get the list of available drivers use the fluid_settings_foreach_option() function. Finally, you can set the driver with fluid_settings_setstr(). In most cases, the default driver should work out of the box.
Additional options that define the audio quality and latency are "audio.sample-format", "audio.period-size", and "audio.periods". The details are described later.
You create the audio driver with the new_fluid_audio_driver() function. This function takes the settings and synthesizer object as arguments. For example:
void init() { fluid_settings_t* settings; fluid_synth_t* synth; fluid_audio_driver_t* adriver; settings = new_fluid_settings(); /* Set the synthesizer settings, if necessary */ synth = new_fluid_synth(settings); fluid_settings_setstr(settings, "audio.driver", "jack"); adriver = new_fluid_audio_driver(settings, synth); }
As soon as the audio driver is created, it will start playing. The audio driver creates a separate thread that uses the synthesizer object to generate the audio.
There are a number of general audio driver settings. The audio.driver settings define the audio subsystem that will be used. The audio.periods and audio.period-size settings define the latency and robustness against scheduling delays. There are additional settings for the audio subsystems used which are documented in another table.
audio.driver | Type | string |
Default | jack (Linux), dsound (Windows), sndman (MacOS9), coreaudio (Mac OS X), dart (OS/2) | |
Options | jack, alsa, oss, pulseaudio, coreaudio, dsound, portaudio, sndman, dart, file | |
Description | The audio system to be used.
| |
audio.periods | Type | int |
Default | 16 (Linux, Mac OS X), 8 (Windows) | |
Min-Max | 2-64 | |
Description | The number of the audio buffers used by the driver. This number of buffers, multiplied by the buffer size (see setting audio.period-size), determines the maximum latency of the audio driver.
| |
audio.period-size | Type | integer |
Default | 64 (Linux, Mac OS X), 512 (Windows) | |
Min-Max | 64-8192 | |
Description | The size of the audio buffers (in frames).
| |
audio.realtime-prio | Type | integer |
Default | 60 | |
Min-Max | 0-99 | |
Description | Sets the realtime scheduling priority of the audio synthesis thread (0 disables high priority scheduling). Linux is the only platform which currently makes use of different priority levels. Drivers which use this option: alsa, oss and pulseaudio
| |
audio.sample-format | Type | string |
Default | "16bits" | |
Options | "16bits", "float" | |
Description | The format of the audio samples. This is currently only an indication; the audio driver may ignore this setting if it can't handle the specified format. |
The following table describes audio driver specific settings.
audio.alsa.device | Type | string |
Default | "default" | |
Options | ALSA device string, such as: "hw:0", "plughw:1", etc. | |
Description | Selects the ALSA audio device to use.
| |
audio.coreaudio.device | Type | string |
Default | "default" | |
Description | Selects the CoreAudio device to use.
| |
audio.dart.device | Type | string |
Default | "default" | |
Description | Selects the Dart (OS/2 driver) device to use.
| |
audio.dsound.device | Type | string |
Default | "default" | |
Description | Selects the DirectSound (Windows) device to use.
| |
audio.file.endian | Type | string |
Default | 'auto' if libsndfile support is built in, 'cpu' otherwise. | |
Options | auto, big, cpu, little ('cpu' is all that is supported if libsndfile support is not built in) | |
Description | Defines the byte order when using the 'file' driver or file renderer to store audio to a file. 'auto' uses the default for the given file type, 'cpu' uses the CPU byte order, 'big' uses big endian byte order and 'little' uses little endian byte order.
| |
audio.file.format | Type | string |
Default | s16 | |
Options | double, float, s16, s24, s32, s8, u8 ('s16' is all that is supported if libsndfile support not built in) | |
Description | Defines the audio format when rendering audio to a file. 'double' is 64 bit floating point, 'float' is 32 bit floating point, 's16' is 16 bit signed PCM, 's24' is 24 bit signed PCM, 's32' is 32 bit signed PCM, 's8' is 8 bit signed PCM and 'u8' is 8 bit unsigned PCM.
| |
audio.file.name | Type | string |
Default | 'fluidsynth.wav' if libsndfile support is built in, 'fluidsynth.raw' otherwise. | |
Description | Specifies the file name to store the audio to, when rendering audio to a file.
| |
audio.file.type | Type | string |
Default | 'auto' if libsndfile support is built in, 'raw' otherwise. | |
Options | aiff, au, auto, avr, caf, flac, htk, iff, mat, oga, paf, pvf, raw, sd2, sds, sf, voc, w64, wav, xi (actual list of types may vary and depends on the libsndfile library used, 'raw' is the only type available if no libsndfile support is built in). | |
Description | Sets the file type of the file which the audio will be stored to. 'auto' attempts to determine the file type from the audio.file.name file extension and falls back to 'wav' if the extension doesn't match any types.
| |
audio.jack.autoconnect | Type | boolean |
Default | 0 (FALSE) | |
Description | If 1 (TRUE), then FluidSynth output is automatically connected to jack system audio output.
| |
audio.jack.id | Type | string |
Default | fluidsynth | |
Description | ID used when creating Jack client connection.
| |
audio.jack.multi | Type | boolean |
Default | 0 (FALSE) | |
Description | If 1 (TRUE), then multi-channel Jack output will be enabled if synth.audio-channels is greater than 1.
| |
audio.jack.server | Type | string |
Default | ||
Description | Jack server to connect to. Defaults to an empty string, which uses default Jack server.
| |
audio.oss.device | Type | string |
Default | /dev/dsp | |
Description | Device to use for OSS audio output.
| |
audio.portaudio.device | Type | string |
Default | PortAudio Default | |
Description | Device to use for PortAudio driver output. Note that 'PortAudio Default' is a special value which outputs to the default PortAudio device.
| |
audio.pulseaudio.device | Type | string |
Default | "default" | |
Description | Device to use for PulseAudio driver output
| |
audio.pulseaudio.server | Type | string |
Default | "default" | |
Description | Server to use for PulseAudio driver output |
fluid_synth_write_s16() fills two buffers (left and right channel) with samples coded as signed 16 bits (the endian-ness is machine dependent). fluid_synth_write_float() fills a left and right audio buffer with 32 bits floating point samples. For multi channel audio output, the function fluid_synth_nwrite_float() has to be used.
The function fluid_synth_process() is still experimental and its use is therefore not recommended but it will probably become the generic interface in future versions.
SoundFonts are loaded with the fluid_synth_sfload() function. The function takes the path to a SoundFont file and a boolean to indicate whether the presets of the MIDI channels should be updated after the SoundFont is loaded. When the boolean value is TRUE, all MIDI channel bank and program numbers will be refreshed, which may cause new instruments to be selected from the newly loaded SoundFont.
The synthesizer can load any number of SoundFonts. The loaded SoundFonts are treated as a stack, where each new loaded SoundFont is placed at the top of the stack. When selecting presets by bank and program numbers, SoundFonts are searched beginning at the top of the stack. In the case where there are presets in different SoundFonts with identical bank and program numbers, the preset from the most recently loaded SoundFont is used. The fluid_synth_program_select() can be used for unambiguously selecting a preset or bank offsets could be applied to each SoundFont with fluid_synth_set_bank_offset(), to try and ensure that each preset has unique bank and program numbers.
The fluid_synth_sfload() function returns the unique identifier of the loaded SoundFont, or -1 in case of an error. This identifier is used in subsequent management functions: fluid_synth_sfunload() removes the SoundFont, fluid_synth_sfreload() reloads the SoundFont. When a SoundFont is reloaded, it retains it's ID and position on the SoundFont stack.
Additional API functions are provided to get the number of loaded SoundFonts and to get a pointer to the SoundFont.
The following example show a generic graphical button that plays a note when clicked:
class SoundButton : public SomeButton { public: SoundButton() : SomeButton() { if (!_synth) { initSynth(); } } static void initSynth() { _settings = new_fluid_settings(); _synth = new_fluid_synth(_settings); _adriver = new_fluid_audio_driver(_settings, _synth); } /* ... */ virtual int handleMouseDown(int x, int y) { /* Play a note on key 60 with velocity 100 on MIDI channel 0 */ fluid_synth_noteon(_synth, 0, 60, 100); } virtual int handleMouseUp(int x, int y) { /* Release the note on key 60 */ fluid_synth_noteoff(_synth, 0, 60); } protected: static fluid_settings_t* _settings; static fluid_synth_t* _synth; static fluid_audio_driver_t* _adriver; };
#include <fluidsynth.h> int handle_midi_event(void* data, fluid_midi_event_t* event) { printf("event type: %d\n", fluid_midi_event_get_type(event)); } int main(int argc, char** argv) { fluid_settings_t* settings; fluid_midi_driver_t* mdriver; settings = new_fluid_settings(); mdriver = new_fluid_midi_driver(settings, handle_midi_event, NULL); /* ... */ delete_fluid_midi_driver(mdriver); return 0; }
There are a number of general MIDI driver settings. The midi.driver setting defines the MIDI subsystem that will be used. There are additional settings for the MIDI subsystems used, which are described in a following table.
midi.driver | Type | string |
Default | alsa_seq (Linux), winmidi (Windows), jack (Mac OS X) | |
Options | alsa_raw, alsa_seq, coremidi, jack, midishare, oss, winmidi | |
Description | The MIDI system to be used.
| |
midi.realtime-prio | Type | integer |
Default | 50 | |
Min-Max | 0-99 | |
Description | Sets the realtime scheduling priority of the MIDI thread (0 disables high priority scheduling). Linux is the only platform which currently makes use of different priority levels. Drivers which use this option: alsa_raw, alsa_seq, oss |
The following table defines MIDI driver specific settings.
midi.alsa.device | Type | string |
Default | "default" | |
Description | ALSA MIDI device to use for RAW ALSA MIDI driver.
| |
midi.alsa_seq.device | Type | string |
Default | "default" | |
Description | ALSA sequencer device to use for ALSA sequencer driver.
| |
midi.alsa_seq.id | Type | string |
Default | pid | |
Description | ID to use when registering ports with the ALSA sequencer driver. If set to "pid" then the ID will be "FLUID Synth (PID)", where PID is the FluidSynth process ID of the audio thread otherwise the provided string will be used in place of PID.
| |
midi.jack.id | Type | string |
Default | fluidsynth-midi | |
Description | Client ID to use with the Jack MIDI driver.
| |
midi.jack.server | Type | string |
Default | ||
Description | Jack server to connect to for Jack MIDI driver. If an empty string then the default server will be used.
| |
midi.oss.device | Type | string |
Default | /dev/midi | |
Description | Device to use for OSS MIDI driver.
| |
midi.portname | Type | string |
Default | ||
Description | Used by coremidi and alsa_seq drivers for the portnames registered with the MIDI subsystem. |
#include <fluidsynth.h> int main(int argc, char** argv) { int i; fluid_settings_t* settings; fluid_synth_t* synth; fluid_player_t* player; fluid_audio_driver_t* adriver; settings = new_fluid_settings(); synth = new_fluid_synth(settings); player = new_fluid_player(synth); adriver = new_fluid_audio_driver(settings, synth); /* process command line arguments */ for (i = 1; i < argc; i++) { if (fluid_is_soundfont(argv[i])) { fluid_synth_sfload(synth, argv[1], 1); } if (fluid_is_midifile(argv[i])) { fluid_player_add(player, argv[i]); } } /* play the midi files, if any */ fluid_player_play(player); /* wait for playback termination */ fluid_player_join(player); /* cleanup */ delete_fluid_audio_driver(adriver); delete_fluid_player(player); delete_fluid_synth(synth); delete_fluid_settings(settings); return 0; }
Settings which the MIDI player uses are documented below.
player.reset-synth | type | boolean |
default | 1 (TRUE) | |
description | If true, reset the synth before starting a new MIDI song, so the state of a previous song can't affect the new song. Turn it off for seamless looping of a song.
| |
player.timing-source | type | string |
default | 'sample' | |
options | 'sample', 'system' | |
description | Determines the timing source of the player sequencer. 'sample' uses the sample clock (how much audio has been output) to sequence events, in which case audio is synchronized with MIDI events. 'system' uses the system clock, audio and MIDI are not synchronized exactly. |
Some examples of MIDI router usage:
The MIDI driver API has a clean separation between the midi thread and the synthesizer. That opens the door to add a midi router module.
MIDI events coming from the MIDI player do not pass through the MIDI router.
#include <fluidsynth.h> int main(int argc, char** argv) { fluid_settings_t* settings; fluid_synth_t* synth; fluid_midi_router_t* router; fluid_midi_router_rule_t* rule; settings = new_fluid_settings(); synth = new_fluid_synth(settings); /* Create the MIDI router and pass events to the synthesizer */ router = new_fluid_midi_router (settings, fluid_synth_handle_midi_event, synth); /* Clear default rules */ fluid_midi_router_clear_rules (router); /* Add rule to map all notes < MIDI note #60 on any channel to channel 4 */ rule = new_fluid_midi_router_rule (); fluid_midi_router_rule_set_chan (rule, 0, 15, 0.0, 4); /* Map all to channel 4 */ fluid_midi_router_rule_set_param1 (rule, 0, 59, 1.0, 0); /* Match notes < 60 */ fluid_midi_router_add_rule (router, rule, FLUID_MIDI_ROUTER_RULE_NOTE); /* Add rule to map all notes >= MIDI note #60 on any channel to channel 5 */ rule = new_fluid_midi_router_rule (); fluid_midi_router_rule_set_chan (rule, 0, 15, 0.0, 5); /* Map all to channel 5 */ fluid_midi_router_rule_set_param1 (rule, 60, 127, 1.0, 0); /* Match notes >= 60 */ fluid_midi_router_add_rule (router, rule, FLUID_MIDI_ROUTER_RULE_NOTE); /* Add rule to reverse direction of pitch bender on channel 7 */ rule = new_fluid_midi_router_rule (); fluid_midi_router_rule_set_chan (rule, 7, 7, 1.0, 0); /* Match channel 7 only */ fluid_midi_router_rule_set_param1 (rule, 0, 16383, -1.0, 16383); /* Reverse pitch bender */ fluid_midi_router_add_rule (router, rule, FLUID_MIDI_ROUTER_RULE_PITCH_BEND); /* ... Create audio driver, process events, etc ... */ /* cleanup */ delete_fluid_midi_router(router); delete_fluid_synth(synth); delete_fluid_settings(settings); return 0; }
The client program should first initialize the sequencer instance using the function new_fluid_sequencer2(). There is a complementary function delete_fluid_sequencer() to delete it. After creating the sequencer instance, the destinations can be registered using fluid_sequencer_register_fluidsynth() for the synthesizer destination, and optionally using fluid_sequencer_register_client() for the client destination providing a suitable callback function. It can be unregistered using fluid_sequencer_unregister_client(). After the initialization, events can be sent with fluid_sequencer_send_now() and scheduled to the future with fluid_sequencer_send_at(). The registration functions return identifiers, that can be used as destinations of an event using fluid_event_set_dest().
The function fluid_sequencer_get_tick() returns the current playing position. A program may choose a new timescale in milliseconds using fluid_sequencer_set_time_scale().
The following example uses the fluidsynth sequencer to implement a sort of music box. FluidSynth internal clock is used to schedule repetitive sequences of notes. The next sequence is scheduled on advance before the end of the current one, using a timer event that triggers a callback function. The scheduling times are always absolute values, to avoid slippage.
#include "fluidsynth.h" fluid_synth_t* synth; fluid_audio_driver_t* adriver; fluid_sequencer_t* sequencer; short synthSeqID, mySeqID; unsigned int now; unsigned int seqduration; // prototype void seq_callback(unsigned int time, fluid_event_t* event, fluid_sequencer_t* seq, void* data); void createsynth() { fluid_settings_t* settings; settings = new_fluid_settings(); fluid_settings_setstr(settings, "synth.reverb.active", "yes"); fluid_settings_setstr(settings, "synth.chorus.active", "no"); synth = new_fluid_synth(settings); adriver = new_fluid_audio_driver(settings, synth); sequencer = new_fluid_sequencer2(0); // register synth as first destination synthSeqID = fluid_sequencer_register_fluidsynth(sequencer, synth); // register myself as second destination mySeqID = fluid_sequencer_register_client(sequencer, "me", seq_callback, NULL); // the sequence duration, in ms seqduration = 1000; } void deletesynth() { delete_fluid_sequencer(sequencer); delete_fluid_audio_driver(adriver); delete_fluid_synth(synth); } void loadsoundfont() { int fluid_res; // put your own path here fluid_res = fluid_synth_sfload(synth, "Inside:VintageDreamsWaves-v2.sf2", 1); } void sendnoteon(int chan, short key, unsigned int date) { int fluid_res; fluid_event_t *evt = new_fluid_event(); fluid_event_set_source(evt, -1); fluid_event_set_dest(evt, synthSeqID); fluid_event_noteon(evt, chan, key, 127); fluid_res = fluid_sequencer_send_at(sequencer, evt, date, 1); delete_fluid_event(evt); } void schedule_next_callback() { int fluid_res; // I want to be called back before the end of the next sequence unsigned int callbackdate = now + seqduration/2; fluid_event_t *evt = new_fluid_event(); fluid_event_set_source(evt, -1); fluid_event_set_dest(evt, mySeqID); fluid_event_timer(evt, NULL); fluid_res = fluid_sequencer_send_at(sequencer, evt, callbackdate, 1); delete_fluid_event(evt); } void schedule_next_sequence() { // Called more or less before each sequence start // the next sequence start date now = now + seqduration; // the sequence to play // the beat : 2 beats per sequence sendnoteon(0, 60, now + seqduration/2); sendnoteon(0, 60, now + seqduration); // melody sendnoteon(1, 45, now + seqduration/10); sendnoteon(1, 50, now + 4*seqduration/10); sendnoteon(1, 55, now + 8*seqduration/10); // so that we are called back early enough to schedule the next sequence schedule_next_callback(); } /* sequencer callback */ void seq_callback(unsigned int time, fluid_event_t* event, fluid_sequencer_t* seq, void* data) { schedule_next_sequence(); } int main(void) { createsynth(); loadsoundfont(); // initialize our absolute date now = fluid_sequencer_get_tick(sequencer); schedule_next_sequence(); sleep(100000); deletesynth(); return 0; }
shell.prompt | type | string |
default | "" | |
description | In dump mode we set the prompt to "". the ui cannot easily handle lines, which don't end with cr. changing the prompt cannot be done through a command, because the current shell does not handle empty arguments. | |
shell.port | type | number |
default | 9800 | |
min-max | 1-65535 | |
description | The shell can be used in a client/server mode. This setting controls what TCP/IP port the server uses. |