void SetupSynth()
{
fluidSettings = new_fluid_settings();
if(fluidSettings)
{
fluid_settings_setnum(fluidSettings, "synth.gain", 0.5);
fluid_settings_setstr(fluidSettings, "synth.reverb.active", "yes");
fluid_settings_setstr(fluidSettings, "synth.chorus.active", "yes");
fluid_settings_setint(fluidSettings, "synth.polyphony", 256);
fluid_settings_setnum(fluidSettings, "synth.sample-rate", (double)sampleRate);
fluidSynth = new_fluid_synth(fluidSettings);
}
}
void MusicDriver_FluidSynth::SetVolume(byte vol)
{
/* Allowed range of synth.gain is 0.0 to 10.0 */
if (fluid_settings_setnum(_midi.settings, "synth.gain", 1.0 * vol / 128.0) != 1) {
DEBUG(driver, 0, "Could not set volume");
}
}
void FluidSynthMidiDriver::setNum(const char *name, double val) {
//char *name2 = strdup(name);
char *name2 = const_cast<char*>(name);
fluid_settings_setnum(_settings, name2, val);
//std::free(name2);
}
static void FSynth_setGain(FSynth *self, ALfloat gain)
{
/* Scale gain by an additional 0.2 (-14dB), to help keep the mix from clipping. */
fluid_settings_setnum(self->Settings, "synth.gain", 0.2 * gain);
fluid_synth_set_gain(self->Synth, 0.2f * gain);
MidiSynth_setGain(STATIC_CAST(MidiSynth, self), gain);
}
/* Process a command line option -o setting=value, for example: -o synth.polyhony=16 */
void process_o_cmd_line_option(fluid_settings_t* settings, char* optarg)
{
char* val;
int hints;
int ival;
for (val = optarg; *val != '\0'; val++) {
if (*val == '=') {
*val++ = 0;
break;
}
}
/* did user request list of settings */
if (strcmp (optarg, "help") == 0)
{
option_help = 1;
return;
}
switch(fluid_settings_get_type(settings, optarg)){
case FLUID_NUM_TYPE:
if (!fluid_settings_setnum (settings, optarg, atof (val)))
{
fprintf (stderr, "Failed to set floating point parameter '%s'\n", optarg);
exit (1);
}
break;
case FLUID_INT_TYPE:
hints = fluid_settings_get_hints (settings, optarg);
if (hints & FLUID_HINT_TOGGLED)
{
if (FLUID_STRCMP (val, "yes") == 0 || FLUID_STRCMP (val, "True") == 0
|| FLUID_STRCMP (val, "TRUE") == 0 || FLUID_STRCMP (val, "true") == 0
|| FLUID_STRCMP (val, "T") == 0)
ival = 1;
else ival = atoi (val);
}
else ival = atoi (val);
if (!fluid_settings_setint (settings, optarg, ival))
{
fprintf (stderr, "Failed to set integer parameter '%s'\n", optarg);
exit (1);
}
break;
case FLUID_STR_TYPE:
if (!fluid_settings_setstr (settings, optarg, val))
{
fprintf (stderr, "Failed to set string parameter '%s'\n", optarg);
exit (1);
}
break;
default:
fprintf (stderr, "Setting parameter '%s' not found\n", optarg);
exit (1);
}
}
static int
fluidsynth_init(sfx_softseq_t *self, byte *data_ptr, int data_length,
byte *data2_ptr, int data2_length)
{
int sfont_id;
double min, max;
if (0) {
sciprintf("FluidSynth ERROR: Mono sound output not supported.\n");
return SFX_ERROR;
}
gmseq = sfx_find_sequencer("General MIDI");
if (!gmseq) {
sciprintf("FluidSynth ERROR: Unable to find General MIDI sequencer.\n");
return SFX_ERROR;
}
settings = new_fluid_settings();
fluid_settings_getnum_range(settings, "synth.sample-rate", &min, &max);
if (SAMPLE_RATE < min || SAMPLE_RATE > max) {
sciprintf("FluidSynth ERROR: Sample rate '%i' not supported. Valid "
"range is (%i-%i).\n", SAMPLE_RATE, (int) min, (int) max);
delete_fluid_settings(settings);
return SFX_ERROR;
}
fluid_settings_setnum(settings, "synth.sample-rate", SAMPLE_RATE);
fluid_settings_setnum(settings, "synth.gain", 0.5f);
synth = new_fluid_synth(settings);
if ((sfont_id = fluid_synth_sfload(synth, soundfont, 1)) < 0) {
delete_fluid_synth(synth);
delete_fluid_settings(settings);
return SFX_ERROR;
}
gmseq->open(data_length, data_ptr, data2_length, data2_ptr,
&midi_writer_fluidsynth);
return SFX_OK;
}
int
fluidsynth_init (DenemoPrefs * config, unsigned int samplerate)
{
g_debug ("Starting FLUIDSYNTH");
settings = new_fluid_settings ();
if (!settings)
{
g_warning ("Failed to create the settings");
return -1;
}
fluid_settings_setnum (settings, "synth.sample-rate", (double) samplerate);
fluid_settings_setint (settings, "synth.reverb.active", config->fluidsynth_reverb ? 1 : 0);
fluid_settings_setint (settings, "synth.chorus.active", config->fluidsynth_chorus ? 1 : 0);
// create the synthesizer
synth = new_fluid_synth (settings);
if (!synth)
{
g_warning ("Failed to create the settings");
fluidsynth_shutdown ();
return -1;
}
if(g_file_test(config->fluidsynth_soundfont->str, G_FILE_TEST_EXISTS))
sfont_id = fluid_synth_sfload (synth, config->fluidsynth_soundfont->str, FALSE);
if (sfont_id == -1)
{
g_debug ("Failed to load the user soundfont. Now trying the default soundfont.");
gchar *default_soundfont = find_denemo_file(DENEMO_DIR_SOUNDFONTS, "A320U.sf2");
if(default_soundfont)
sfont_id = fluid_synth_sfload (synth, default_soundfont, FALSE);
g_string_assign (Denemo.prefs.fluidsynth_soundfont, default_soundfont);
g_free (default_soundfont);
}
if (sfont_id == -1)
{
fluidsynth_shutdown ();
return -1;
}
else
{
g_message ("The default fluidsynth soundfont has been loaded");
}
reset_synth_channels ();
return 0;
}
bool ISynth::init(const char* name)
{
fluid_settings_t* settings;
settings = new_fluid_settings();
fluid_settings_setnum(settings, (char*) "synth.sample-rate", float(sampleRate()));
_fluidsynth = new_fluid_synth(settings);
//---------------------------------------
// create non realtime helper thread
// create message channels
//
int filedes[2]; // 0 - reading 1 - writing
if (pipe(filedes) == -1) {
perror("ISynth::thread:creating pipe");
return true;
}
readFd = filedes[0];
writeFd = filedes[1];
pthread_attr_t* attributes = (pthread_attr_t*) malloc(sizeof(pthread_attr_t));
pthread_attr_init(attributes);
if (pthread_create(&helperThread, attributes, ::helper, this))
perror("creating thread failed:");
pthread_attr_destroy(attributes);
char* p = getenv("DEFAULT_SOUNDFONT");
if (p) {
sfont = new char[strlen(p)+1];
strcpy(sfont, p);
char c = 'x';
_busy = true;
write(writeFd, &c, 1);
}
gui = new FLUIDGui;
gui->setWindowTitle(QString(name));
gui->show();
return false;
}
static ALboolean FSynth_init(FSynth *self, ALCdevice *device)
{
self->Settings = new_fluid_settings();
if(!self->Settings)
{
ERR("Failed to create FluidSettings\n");
return AL_FALSE;
}
fluid_settings_setint(self->Settings, "synth.reverb.active", 1);
fluid_settings_setint(self->Settings, "synth.chorus.active", 1);
fluid_settings_setint(self->Settings, "synth.polyphony", 256);
fluid_settings_setnum(self->Settings, "synth.sample-rate", device->Frequency);
self->Synth = new_fluid_synth(self->Settings);
if(!self->Synth)
{
ERR("Failed to create FluidSynth\n");
return AL_FALSE;
}
return AL_TRUE;
}
/*
* main
*/
int main(int argc, char** argv)
{
fluid_settings_t* settings;
int arg1 = 1;
char buf[512];
int c, i;
int interactive = 1;
int midi_in = 1;
fluid_player_t* player = NULL;
fluid_midi_router_t* router = NULL;
//fluid_sequencer_t* sequencer = NULL;
fluid_midi_driver_t* mdriver = NULL;
fluid_audio_driver_t* adriver = NULL;
fluid_synth_t* synth = NULL;
fluid_server_t* server = NULL;
char* config_file = NULL;
int audio_groups = 0;
int audio_channels = 0;
int with_server = 0;
int dump = 0;
int fast_render = 0;
int connect_lash = 1;
char *optchars = "a:C:c:dE:f:F:G:g:hijK:L:lm:nO:o:p:R:r:sT:Vvz:";
#ifdef LASH_ENABLED
int enabled_lash = 0; /* set to TRUE if lash gets enabled */
fluid_lash_args_t *lash_args;
lash_args = fluid_lash_extract_args (&argc, &argv);
#endif
print_welcome ();
settings = new_fluid_settings();
#ifdef GETOPT_SUPPORT /* pre section of GETOPT supported argument handling */
opterr = 0;
while (1) {
int option_index = 0;
static struct option long_options[] = {
{"audio-bufcount", 1, 0, 'c'},
{"audio-bufsize", 1, 0, 'z'},
{"audio-channels", 1, 0, 'L'},
{"audio-driver", 1, 0, 'a'},
{"audio-file-endian", 1, 0, 'E'},
{"audio-file-format", 1, 0, 'O'},
{"audio-file-type", 1, 0, 'T'},
{"audio-groups", 1, 0, 'G'},
{"chorus", 1, 0, 'C'},
{"connect-jack-outputs", 0, 0, 'j'},
{"disable-lash", 0, 0, 'l'},
{"dump", 0, 0, 'd'},
{"fast-render", 1, 0, 'F'},
{"gain", 1, 0, 'g'},
{"help", 0, 0, 'h'},
{"load-config", 1, 0, 'f'},
{"midi-channels", 1, 0, 'K'},
{"midi-driver", 1, 0, 'm'},
{"no-midi-in", 0, 0, 'n'},
{"no-shell", 0, 0, 'i'},
{"option", 1, 0, 'o'},
{"portname", 1, 0, 'p'},
{"reverb", 1, 0, 'R'},
{"sample-rate", 1, 0, 'r'},
{"server", 0, 0, 's'},
{"verbose", 0, 0, 'v'},
{"version", 0, 0, 'V'},
{0, 0, 0, 0}
};
c = getopt_long(argc, argv, optchars, long_options, &option_index);
if (c == -1) {
break;
}
#else /* "pre" section to non getopt argument handling */
for (i = 1; i < argc; i++) {
char *optarg;
/* Skip non switch arguments (assume they are file names) */
if ((argv[i][0] != '-') || (argv[i][1] == '\0')) break;
c = argv[i][1];
optarg = strchr (optchars, c); /* find the option character in optchars */
if (optarg && optarg[1] == ':') /* colon follows if switch argument expected */
{
if (++i >= argc)
{
printf ("Option -%c requires an argument\n", c);
print_usage();
exit(0);
}
else
{
optarg = argv[i];
if (optarg[0] == '-')
{
printf ("Expected argument to option -%c found switch instead\n", c);
print_usage();
exit(0);
}
}
}
else optarg = "";
#endif
switch (c) {
#ifdef GETOPT_SUPPORT
case 0: /* shouldn't normally happen, a long option's flag is set to NULL */
printf ("option %s", long_options[option_index].name);
if (optarg) {
printf (" with arg %s", optarg);
}
printf ("\n");
break;
#endif
case 'a':
if (FLUID_STRCMP (optarg, "help") == 0)
{
printf ("-a options (audio driver):\n ");
show_settings_str_options (settings, "audio.driver");
exit (0);
}
else fluid_settings_setstr(settings, "audio.driver", optarg);
break;
case 'C':
if ((optarg != NULL) && ((strcmp(optarg, "0") == 0) || (strcmp(optarg, "no") == 0))) {
fluid_settings_setint(settings, "synth.chorus.active", FALSE);
} else {
fluid_settings_setint(settings, "synth.chorus.active", TRUE);
}
break;
case 'c':
fluid_settings_setint(settings, "audio.periods", atoi(optarg));
break;
case 'd':
fluid_settings_setint(settings, "synth.dump", TRUE);
dump = 1;
break;
case 'E':
if (FLUID_STRCMP (optarg, "help") == 0)
{
printf ("-E options (audio file byte order):\n ");
show_settings_str_options (settings, "audio.file.endian");
#if LIBSNDFILE_SUPPORT
printf ("\nauto: Use audio file format's default endian byte order\n"
"cpu: Use CPU native byte order\n");
#else
printf ("\nNOTE: No libsndfile support!\n"
"cpu: Use CPU native byte order\n");
#endif
exit (0);
}
else fluid_settings_setstr(settings, "audio.file.endian", optarg);
break;
case 'f':
config_file = optarg;
break;
case 'F':
fluid_settings_setstr(settings, "audio.file.name", optarg);
fast_render = 1;
break;
case 'G':
audio_groups = atoi(optarg);
break;
case 'g':
fluid_settings_setnum(settings, "synth.gain", atof(optarg));
break;
case 'h':
print_help(settings);
break;
case 'i':
interactive = 0;
break;
case 'j':
fluid_settings_setint(settings, "audio.jack.autoconnect", 1);
break;
case 'K':
fluid_settings_setint(settings, "synth.midi-channels", atoi(optarg));
break;
case 'L':
audio_channels = atoi(optarg);
fluid_settings_setint(settings, "synth.audio-channels", audio_channels);
break;
case 'l': /* disable LASH */
connect_lash = 0;
break;
case 'm':
if (FLUID_STRCMP (optarg, "help") == 0)
{
printf ("-m options (MIDI driver):\n ");
show_settings_str_options (settings, "midi.driver");
exit (0);
}
else fluid_settings_setstr(settings, "midi.driver", optarg);
break;
case 'n':
midi_in = 0;
break;
case 'O':
if (FLUID_STRCMP (optarg, "help") == 0)
{
printf ("-O options (audio file format):\n ");
show_settings_str_options (settings, "audio.file.format");
#if LIBSNDFILE_SUPPORT
printf ("\ns8, s16, s24, s32: Signed PCM audio of the given number of bits\n");
printf ("float, double: 32 bit and 64 bit floating point audio\n");
printf ("u8: Unsigned 8 bit audio\n");
#else
printf ("\nNOTE: No libsndfile support!\n");
#endif
exit (0);
}
else fluid_settings_setstr(settings, "audio.file.format", optarg);
break;
case 'o':
process_o_cmd_line_option(settings, optarg);
break;
case 'p' :
fluid_settings_setstr(settings, "midi.portname", optarg);
break;
case 'R':
if ((optarg != NULL) && ((strcmp(optarg, "0") == 0) || (strcmp(optarg, "no") == 0))) {
fluid_settings_setint(settings, "synth.reverb.active", FALSE);
} else {
fluid_settings_setint(settings, "synth.reverb.active", TRUE);
}
break;
case 'r':
fluid_settings_setnum(settings, "synth.sample-rate", atof(optarg));
break;
case 's':
with_server = 1;
break;
case 'T':
if (FLUID_STRCMP (optarg, "help") == 0)
{
printf ("-T options (audio file type):\n ");
show_settings_str_options (settings, "audio.file.type");
#if LIBSNDFILE_SUPPORT
printf ("\nauto: Determine type from file name extension, defaults to \"wav\"\n");
#else
printf ("\nNOTE: No libsndfile support!\n");
#endif
exit (0);
}
else fluid_settings_setstr(settings, "audio.file.type", optarg);
break;
case 'V':
printf("FluidSynth %s\n", VERSION);
exit (0);
break;
case 'v':
fluid_settings_setint(settings, "synth.verbose", TRUE);
break;
case 'z':
fluid_settings_setint(settings, "audio.period-size", atoi(optarg));
break;
#ifdef GETOPT_SUPPORT
case '?':
printf ("Unknown option %c\n", optopt);
print_usage();
exit(0);
break;
default:
printf ("?? getopt returned character code 0%o ??\n", c);
break;
#else /* Non getopt default case */
default:
printf ("Unknown switch '%c'\n", c);
print_usage();
exit(0);
break;
#endif
} /* end of switch statement */
} /* end of loop */
#ifdef GETOPT_SUPPORT
arg1 = optind;
#else
arg1 = i;
#endif
/* option help requested? "-o help" */
if (option_help)
{
printf ("FluidSynth settings:\n");
fluid_settings_foreach (settings, settings, settings_foreach_func);
exit (0);
}
#ifdef WIN32
SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);
#endif
#ifdef LASH_ENABLED
/* connect to the lash server */
if (connect_lash)
{
enabled_lash = fluid_lash_connect (lash_args);
fluid_settings_setint (settings, "lash.enable", enabled_lash ? 1 : 0);
}
#endif
/* The 'groups' setting is only relevant for LADSPA operation
* If not given, set number groups to number of audio channels, because
* they are the same (there is nothing between synth output and 'sound card')
*/
if ((audio_groups == 0) && (audio_channels != 0)) {
audio_groups = audio_channels;
}
fluid_settings_setint(settings, "synth.audio-groups", audio_groups);
if (fast_render) {
midi_in = 0;
interactive = 0;
with_server = 0;
fluid_settings_setstr(settings, "player.timing-source", "sample");
fluid_settings_setint(settings, "synth.parallel-render", 1); /* TODO: Fast_render should not need this, but currently do */
}
/* create the synthesizer */
synth = new_fluid_synth(settings);
if (synth == NULL) {
fprintf(stderr, "Failed to create the synthesizer\n");
exit(-1);
}
cmd_handler = new_fluid_cmd_handler(synth);
if (cmd_handler == NULL) {
fprintf(stderr, "Failed to create the command handler\n");
goto cleanup;
}
/* load the soundfonts (check that all non options are SoundFont or MIDI files) */
for (i = arg1; i < argc; i++) {
if (fluid_is_soundfont(argv[i]))
{
if (fluid_synth_sfload(synth, argv[i], 1) == -1)
fprintf(stderr, "Failed to load the SoundFont %s\n", argv[i]);
}
else if (!fluid_is_midifile(argv[i]))
fprintf (stderr, "Parameter '%s' not a SoundFont or MIDI file or error occurred identifying it.\n",
argv[i]);
}
#ifdef HAVE_SIGNAL_H
/* signal(SIGINT, handle_signal); */
#endif
/* start the synthesis thread */
if (!fast_render) {
adriver = new_fluid_audio_driver(settings, synth);
if (adriver == NULL) {
fprintf(stderr, "Failed to create the audio driver\n");
goto cleanup;
}
}
/* start the midi router and link it to the synth */
#if WITH_MIDI
if (midi_in) {
/* In dump mode, text output is generated for events going into and out of the router.
* The example dump functions are put into the chain before and after the router..
*/
//sequencer = new_fluid_sequencer2(0);
router = new_fluid_midi_router(
settings,
dump ? fluid_midi_dump_postrouter : fluid_synth_handle_midi_event,
(void*)synth);
if (router == NULL) {
fprintf(stderr, "Failed to create the MIDI input router; no MIDI input\n"
"will be available. You can access the synthesizer \n"
"through the console.\n");
} else {
fluid_synth_set_midi_router(synth, router); /* Fixme, needed for command handler */
// fluid_sequencer_register_fluidsynth(sequencer, synth);
mdriver = new_fluid_midi_driver(
settings,
dump ? fluid_midi_dump_prerouter : fluid_midi_router_handle_midi_event,
(void*) router);
if (mdriver == NULL) {
fprintf(stderr, "Failed to create the MIDI thread; no MIDI input\n"
"will be available. You can access the synthesizer \n"
"through the console.\n");
}
}
}
#endif
/* run commands specified in config file */
if (config_file != NULL) {
fluid_source(cmd_handler, config_file);
} else if (fluid_get_userconf(buf, 512) != NULL) {
fluid_source(cmd_handler, buf);
} else if (fluid_get_sysconf(buf, 512) != NULL) {
fluid_source(cmd_handler, buf);
}
/* play the midi files, if any */
for (i = arg1; i < argc; i++) {
if ((argv[i][0] != '-') && fluid_is_midifile(argv[i])) {
if (player == NULL) {
player = new_fluid_player(synth);
if (player == NULL) {
fprintf(stderr, "Failed to create the midifile player.\n"
"Continuing without a player.\n");
break;
}
}
fluid_player_add(player, argv[i]);
}
}
if (player != NULL) {
fluid_player_play(player);
}
/* run the server, if requested */
#if !defined(MACINTOSH)
if (with_server) {
server = new_fluid_server(settings, newclient, synth);
if (server == NULL) {
fprintf(stderr, "Failed to create the server.\n"
"Continuing without it.\n");
}
}
#endif
#ifdef LASH_ENABLED
if (enabled_lash)
fluid_lash_create_thread (synth);
#endif
/* run the shell */
if (interactive) {
printf ("Type 'help' for help topics.\n\n");
/* 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. The ordinary case is dump ==
* 0.
*/
fluid_settings_setstr(settings, "shell.prompt", dump ? "" : "> ");
fluid_usershell(settings, cmd_handler);
}
if (fast_render) {
char *filename;
if (player == NULL) {
fprintf(stderr, "No midi file specified!\n");
goto cleanup;
}
fluid_settings_dupstr (settings, "audio.file.name", &filename);
printf ("Rendering audio to file '%s'..\n", filename);
if (filename) FLUID_FREE (filename);
fast_render_loop(settings, synth, player);
}
cleanup:
#if !defined(MACINTOSH) && !defined(WIN32)
if (server != NULL) {
/* if the user typed 'quit' in the shell, kill the server */
if (!interactive) {
fluid_server_join(server);
}
delete_fluid_server(server);
}
#endif
if (cmd_handler != NULL) {
delete_fluid_cmd_handler(cmd_handler);
}
if (player != NULL) {
/* if the user typed 'quit' in the shell, stop the player */
if (interactive) {
fluid_player_stop(player);
}
if (adriver != NULL || !fluid_settings_str_equal(settings, "player.timing-source", "sample")) {
/* if no audio driver and sample timers are used, nothing makes the player advance */
fluid_player_join(player);
}
delete_fluid_player(player);
}
if (router) {
#if WITH_MIDI
if (mdriver) {
delete_fluid_midi_driver(mdriver);
}
delete_fluid_midi_router(router);
#endif
}
/*if (sequencer) {
delete_fluid_sequencer(sequencer);
}*/
if (adriver) {
delete_fluid_audio_driver(adriver);
}
if (synth) {
delete_fluid_synth(synth);
}
if (settings) {
delete_fluid_settings(settings);
}
return 0;
}
static fluid_cmd_handler_t* newclient(void* data, char* addr)
{
fluid_synth_t* synth = (fluid_synth_t*) data;
return new_fluid_cmd_handler(synth);
}
static void
fluidsynth_file_decode(struct decoder *decoder, const char *path_fs)
{
char setting_sample_rate[] = "synth.sample-rate";
/*
char setting_verbose[] = "synth.verbose";
char setting_yes[] = "yes";
*/
fluid_settings_t *settings;
fluid_synth_t *synth;
fluid_player_t *player;
int ret;
enum decoder_command cmd;
/* set up fluid settings */
settings = new_fluid_settings();
if (settings == NULL)
return;
fluid_settings_setnum(settings, setting_sample_rate, sample_rate);
/*
fluid_settings_setstr(settings, setting_verbose, setting_yes);
*/
/* create the fluid synth */
synth = new_fluid_synth(settings);
if (synth == NULL) {
delete_fluid_settings(settings);
return;
}
ret = fluid_synth_sfload(synth, soundfont_path, true);
if (ret < 0) {
g_warning("fluid_synth_sfload() failed");
delete_fluid_synth(synth);
delete_fluid_settings(settings);
return;
}
/* create the fluid player */
player = new_fluid_player(synth);
if (player == NULL) {
delete_fluid_synth(synth);
delete_fluid_settings(settings);
return;
}
ret = fluid_player_add(player, path_fs);
if (ret != 0) {
g_warning("fluid_player_add() failed");
delete_fluid_player(player);
delete_fluid_synth(synth);
delete_fluid_settings(settings);
return;
}
/* start the player */
ret = fluid_player_play(player);
if (ret != 0) {
g_warning("fluid_player_play() failed");
delete_fluid_player(player);
delete_fluid_synth(synth);
delete_fluid_settings(settings);
return;
}
/* initialization complete - announce the audio format to the
MPD core */
struct audio_format audio_format;
audio_format_init(&audio_format, sample_rate, SAMPLE_FORMAT_S16, 2);
decoder_initialized(decoder, &audio_format, false, -1);
while (fluid_player_get_status(player) == FLUID_PLAYER_PLAYING) {
int16_t buffer[2048];
const unsigned max_frames = G_N_ELEMENTS(buffer) / 2;
/* read samples from fluidsynth and send them to the
MPD core */
ret = fluid_synth_write_s16(synth, max_frames,
buffer, 0, 2,
buffer, 1, 2);
if (ret != 0)
break;
cmd = decoder_data(decoder, NULL, buffer, sizeof(buffer),
0);
if (cmd != DECODE_COMMAND_NONE)
break;
}
/* clean up */
fluid_player_stop(player);
fluid_player_join(player);
delete_fluid_player(player);
delete_fluid_synth(synth);
delete_fluid_settings(settings);
}
void MidiDriver_FluidSynth::setNum(const char *name, double val) {
char *name2 = strdup(name);
fluid_settings_setnum(_settings, name2, val);
free(name2);
}
static void
fluidsynth_file_decode(struct decoder *decoder, const char *path_fs)
{
static const struct audio_format audio_format = {
.sample_rate = 48000,
.bits = 16,
.channels = 2,
};
char setting_sample_rate[] = "synth.sample-rate";
/*
char setting_verbose[] = "synth.verbose";
char setting_yes[] = "yes";
*/
const char *soundfont_path;
fluid_settings_t *settings;
fluid_synth_t *synth;
fluid_player_t *player;
char *path_dup;
int ret;
Timer *timer;
enum decoder_command cmd;
soundfont_path =
config_get_string("soundfont",
"/usr/share/sounds/sf2/FluidR3_GM.sf2");
/* set up fluid settings */
settings = new_fluid_settings();
if (settings == NULL)
return;
fluid_settings_setnum(settings, setting_sample_rate, 48000);
/*
fluid_settings_setstr(settings, setting_verbose, setting_yes);
*/
/* create the fluid synth */
synth = new_fluid_synth(settings);
if (synth == NULL) {
delete_fluid_settings(settings);
return;
}
ret = fluid_synth_sfload(synth, soundfont_path, true);
if (ret < 0) {
g_warning("fluid_synth_sfload() failed");
delete_fluid_synth(synth);
delete_fluid_settings(settings);
return;
}
/* create the fluid player */
player = new_fluid_player(synth);
if (player == NULL) {
delete_fluid_synth(synth);
delete_fluid_settings(settings);
return;
}
/* temporarily duplicate the path_fs string, because
fluidsynth wants a writable string */
path_dup = g_strdup(path_fs);
ret = fluid_player_add(player, path_dup);
g_free(path_dup);
if (ret != 0) {
g_warning("fluid_player_add() failed");
delete_fluid_player(player);
delete_fluid_synth(synth);
delete_fluid_settings(settings);
return;
}
/* start the player */
ret = fluid_player_play(player);
if (ret != 0) {
g_warning("fluid_player_play() failed");
delete_fluid_player(player);
delete_fluid_synth(synth);
delete_fluid_settings(settings);
return;
}
/* set up a timer for synchronization; fluidsynth always
decodes in real time, which forces us to synchronize */
/* XXX is there any way to switch off real-time decoding? */
timer = timer_new(&audio_format);
timer_start(timer);
/* initialization complete - announce the audio format to the
MPD core */
decoder_initialized(decoder, &audio_format, false, -1);
do {
int16_t buffer[2048];
const unsigned max_frames = G_N_ELEMENTS(buffer) / 2;
/* synchronize with the fluid player */
timer_add(timer, sizeof(buffer));
timer_sync(timer);
/* read samples from fluidsynth and send them to the
MPD core */
ret = fluid_synth_write_s16(synth, max_frames,
buffer, 0, 2,
buffer, 1, 2);
/* XXX how do we see whether the player is done? We
can't access the private attribute
player->status */
if (ret != 0)
break;
cmd = decoder_data(decoder, NULL, buffer, sizeof(buffer),
0, 0, NULL);
} while (cmd == DECODE_COMMAND_NONE);
/* clean up */
timer_free(timer);
fluid_player_stop(player);
fluid_player_join(player);
delete_fluid_player(player);
delete_fluid_synth(synth);
delete_fluid_settings(settings);
}
static struct tag *
fluidsynth_tag_dup(const char *file)
{
struct tag *tag = tag_new();
/* to be implemented */
(void)file;
return tag;
}
static const char *const fluidsynth_suffixes[] = {
"mid",
NULL
};
const struct decoder_plugin fluidsynth_decoder_plugin = {
.name = "fluidsynth",
.init = fluidsynth_init,
.file_decode = fluidsynth_file_decode,
.tag_dup = fluidsynth_tag_dup,
.suffixes = fluidsynth_suffixes,
};
static void *create_data(const wchar_t *filename, float samplerate){
Data *data = calloc(1,sizeof(Data));
data->pitch = 16384/2;
data->pitch_range = 1;
data->modulation = 0;
data->sustain_on = 0;
data->signal_from_RT = RSEMAPHORE_create(0);
data->settings = new_fluid_settings();
if(data->settings==NULL){
RError("Unable to create fluidsynth settings");
delete_data(data);
return NULL;
}
if(fluid_settings_setnum(data->settings, "synth.sample-rate", samplerate)==0){
RError("Unable to set sample rate of fluidsynth to %f\n",samplerate);
//delete_data(data);
//return NULL;
}
if(fluid_settings_setint(data->settings, "synth.threadsafe-api", 0)==0){
printf("Unable to set threadsafe-api to 0 (we don't need it)\n");
}
if(fluid_settings_setint(data->settings, "synth.chorus.active", 0)==0){
printf("Unable to set synth.chorus.active to 0 (we don't use it)\n");
}
if(fluid_settings_setint(data->settings, "synth.reverb.active", 0)==0){
printf("Unable to set synth.reverb.active to 0 (we don't use it)\n");
}
// TODO: Decide whether we need fluidsynth's reverb and chorus.
//fluid_settings_setstr(settings, "synth.reverb.active", "yes");
//fluid_settings_setstr(settings, "synth.chorus.active", "no");
data->synth = new_fluid_synth(data->settings);
if(data->synth==NULL){
RError("Unable to create fluidsynth synth");
delete_data(data);
return NULL;
}
data->sequencer = new_fluid_sequencer2(0);
if(data->sequencer==NULL){
RError("Unable to create fluidsynth sequencer");
delete_data(data);
return NULL;
}
fluid_sequencer_set_time_scale(data->sequencer, samplerate); // it's a shame that time in fluidsynth is only 32 bit. Hopefully the values wrap properly around.......
data->time_scale = fluid_sequencer_get_time_scale(data->sequencer);
data->samplerate = samplerate;
#if 0 // This test always succeeds. Max time_scale in fluidsynth is 1000.0. :-(
if( data->time_scale != sample_rate){
RError("Could not set time scale to %f (set to %f instead)\n",(float)samplerate,(float)fluid_sequencer_get_time_scale(data->sequencer));
}
#endif
data->synth_seq_ID = fluid_sequencer_register_fluidsynth(data->sequencer, data->synth);
data->event = new_fluid_event();
if(data->event==NULL){
RError("Unable to create fluidsynth event");
delete_data(data);
return NULL;
}
data->filename = wcsdup(OS_loading_get_resolved_file_path(filename));
data->soundfont_id = fluid_synth_sfload(data->synth,STRING_get_chars(data->filename),true);
if(data->soundfont_id==FLUID_FAILED){
printf("Soundfont loading failed for \"%s\"\n",STRING_get_chars(data->filename));
delete_data(data);
return NULL;
}
return data;
}
void sf2Instrument::updateSampleRate()
{
double tempRate;
// Set & get, returns the true sample rate
fluid_settings_setnum( m_settings, (char *) "synth.sample-rate", engine::mixer()->processingSampleRate() );
fluid_settings_getnum( m_settings, (char *) "synth.sample-rate", &tempRate );
m_internalSampleRate = static_cast<int>( tempRate );
if( m_font )
{
// Now, delete the old one and replace
m_synthMutex.lock();
fluid_synth_remove_sfont( m_synth, m_font->fluidFont );
delete_fluid_synth( m_synth );
// New synth
m_synth = new_fluid_synth( m_settings );
m_fontId = fluid_synth_add_sfont( m_synth, m_font->fluidFont );
m_synthMutex.unlock();
// synth program change (set bank and patch)
updatePatch();
updateGain();
}
else
{
// Recreate synth with no soundfonts
m_synthMutex.lock();
delete_fluid_synth( m_synth );
m_synth = new_fluid_synth( m_settings );
m_synthMutex.unlock();
}
m_synthMutex.lock();
if( engine::mixer()->currentQualitySettings().interpolation >=
Mixer::qualitySettings::Interpolation_SincFastest )
{
fluid_synth_set_interp_method( m_synth, -1, FLUID_INTERP_7THORDER );
}
else
{
fluid_synth_set_interp_method( m_synth, -1, FLUID_INTERP_DEFAULT );
}
m_synthMutex.unlock();
if( m_internalSampleRate < engine::mixer()->processingSampleRate() )
{
m_synthMutex.lock();
if( m_srcState != NULL )
{
src_delete( m_srcState );
}
int error;
m_srcState = src_new( engine::mixer()->currentQualitySettings().libsrcInterpolation(), DEFAULT_CHANNELS, &error );
if( m_srcState == NULL || error )
{
qCritical( "error while creating libsamplerate data structure in Sf2Instrument::updateSampleRate()" );
}
m_synthMutex.unlock();
}
updateReverb();
updateChorus();
}
static void FSynth_update(FSynth *self, ALCdevice *device)
{
fluid_settings_setnum(self->Settings, "synth.sample-rate", device->Frequency);
fluid_synth_set_sample_rate(self->Synth, device->Frequency);
MidiSynth_update(STATIC_CAST(MidiSynth, self), device);
}
void MidiDriver_FluidSynth::setNum(const char *name, double val) {
char *name2 = scumm_strdup(name);
fluid_settings_setnum(_settings, name2, val);
delete[] name2;
}
int init(CSOUND *csound) {
int result = OK;
#pragma omp critical (critical_section_fluid_engine)
{
fluid_synth_t *fluidSynth = 0;
fluid_settings_t *fluidSettings = 0;
chorusEnabled = (int) *iChorusEnabled;
reverbEnabled = (int) *iReverbEnabled;
channelCount = (int) *iChannelCount;
voiceCount = (int) *iVoiceCount;
if (channelCount <= 0) {
channelCount = 256;
} else if (channelCount < 16) {
channelCount = 16;
} else if (channelCount > 256) {
channelCount = 256;
}
if (voiceCount <= 0) {
voiceCount = 4096;
} else if (voiceCount < 16) {
voiceCount = 16;
} else if (voiceCount > 4096) {
voiceCount = 4096;
}
//csound_global_mutex_lock();
fluidSettings = new_fluid_settings();
if (fluidSettings != NULL) {
fluid_settings_setnum(fluidSettings,
(char *)"synth.sample-rate",
(double) csound->GetSr(csound));
fluid_settings_setint(fluidSettings,
(char *)"synth.midi-channels", channelCount);
fluid_settings_setint(fluidSettings,
(char *)"synth.polyphony", voiceCount);
fluidSynth = new_fluid_synth(fluidSettings);
}
//csound_global_mutex_unlock();
if (!fluidSynth) {
if (fluidSettings) {
delete_fluid_settings(fluidSettings);
}
result = csound->InitError(csound,
Str("error allocating fluid engine\n"));
} else {
//csound_global_mutex_lock();
fluid_synth_set_chorus_on(fluidSynth, chorusEnabled);
fluid_synth_set_reverb_on(fluidSynth, reverbEnabled);
//csound_global_mutex_unlock();
log(csound, "Created fluidEngine 0x%p with sampling rate = %f, "
"chorus %s, reverb %s, channels %d, voices %d.\n",
fluidSynth, (double) csound->GetSr(csound),
chorusEnabled ? "on" : "off",
reverbEnabled ? "on" : "off",
channelCount,
voiceCount);
tof(fluidSynth, iFluidSynth);
getFluidSynthsForCsoundInstances()[csound].push_back(fluidSynth);
}
}
return result;
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* Configure the MPU attributes as Write Through */
MPU_Config();
/* Enable the CPU Cache */
CPU_CACHE_Enable();
/* STM32F7xx HAL library initialization:
- Configure the Flash ART accelerator on ITCM interface
- Systick timer is configured by default as source of time base, but user
can eventually implement his proper time base source (a general purpose
timer for example or other time source), keeping in mind that Time base
duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and
handled in milliseconds basis.
- Set NVIC Group Priority to 4
- Low Level Initialization
*/
HAL_Init();
/* Configure the system clock to 200 MHz */
SystemClock_Config();
/* Configure LED1 and LED3 */
BSP_LED_Init(LED1);
HAL_Delay(100);
setbuf(stdout, NULL);
BSP_LED_On(LED1);
SD_init();
HAL_Delay(100);
fluid_settings_t* settings;
int sfont_id;
/* Create the settings. */
settings = new_fluid_settings();
fluid_settings_setnum(settings, "synth.sample-rate", SAMPLE_RATE);
fluid_settings_setstr(settings, "synth.reverb.active", "no");
fluid_settings_setstr(settings, "synth.chorus.active", "no");
fluid_settings_setint(settings, "synth.polyphony", POLYPHONY);
/* Create the synthesizer. */
synth = new_fluid_synth(settings);
sfont_id = fluid_synth_sfload(synth, SOUNDFONT_FILE, 1);
fluid_synth_set_interp_method(synth, -1, FLUID_INTERP_NONE);
// fluid_synth_set_interp_method(synth, -1, FLUID_INTERP_LINEAR);
/* Make the connection and initialize to USB_OTG/usbdc_core */
USBD_Init(&USBD_Device, &AUDIO_Desc, 0);
USBD_RegisterClass(&USBD_Device, &USBD_Midi_ClassDriver);
USBD_Midi_RegisterInterface(&USBD_Device, &USBD_Midi_fops);
USBD_Start(&USBD_Device);
HAL_Delay(5);
BSP_AUDIO_OUT_Init(OUTPUT_DEVICE_AUTO, MASTER_VOLUME, SAMPLE_RATE);
BSP_AUDIO_OUT_SetAudioFrameSlot(CODEC_AUDIOFRAME_SLOT_02); // PCM 2-channel
#ifdef AUDIO_FORMAT_32BITS
BSP_AUDIO_OUT_Play((uint32_t *)&buf[0], AUDIO_BUF_SIZE);
#else
BSP_AUDIO_OUT_Play((uint16_t *)&buf[0], AUDIO_BUF_SIZE);
#endif
BSP_LED_Off(LED1);
while (1)
{
BSP_LED_Toggle(LED1);
HAL_Delay(1000);
}
}
static int midoflus_init(void *arg)
{
int ret;
char *sfont;
char *def_sfonts[] = {
"/usr/share/soundfonts/default.sf2", // fedora
"/usr/share/soundfonts/FluidR3_GM.sf2", // fedora
"/usr/share/sounds/sf2/FluidR3_GM.sf2.flac", // ubuntu
"/usr/share/sounds/sf2/FluidR3_GM.sf2", // debian
NULL };
int use_defsf = 0;
settings = new_fluid_settings();
fluid_settings_setint(settings, "synth.lock-memory", 0);
fluid_settings_setnum(settings, "synth.gain", flus_gain);
ret = fluid_settings_setint(settings, "synth.threadsafe-api", 1);
if (ret == 0) {
warn("fluidsynth: no threadsafe API\n");
goto err1;
}
ret = fluid_settings_getnum(settings, "synth.sample-rate", &flus_srate);
if (ret == 0) {
warn("fluidsynth: cannot get samplerate\n");
goto err1;
}
ret = fluid_settings_getstr(settings, "synth.default-soundfont", &sfont);
if (ret == 0) {
int i = 0;
warn("Your fluidsynth is too old\n");
while (def_sfonts[i]) {
if (access(def_sfonts[i], R_OK) == 0) {
sfont = def_sfonts[i];
use_defsf = 1;
break;
}
i++;
}
if (!use_defsf) {
error("Your fluidsynth is too old and soundfonts not found\n");
goto err1;
}
}
synth = new_fluid_synth(settings);
ret = fluid_synth_sfload(synth, sfont, TRUE);
if (ret == FLUID_FAILED) {
warn("fluidsynth: cannot load soundfont %s\n", sfont);
if (use_defsf)
error("Your fluidsynth is too old\n");
goto err2;
}
fluid_settings_setstr(settings, "synth.midi-bank-select", "gm");
S_printf("fluidsynth: loaded soundfont %s ID=%i\n", sfont, ret);
sequencer = new_fluid_sequencer2(0);
synthSeqID = fluid_sequencer_register_fluidsynth2(sequencer, synth);
sem_init(&syn_sem, 0, 0);
pthread_create(&syn_thr, NULL, synth_thread, NULL);
#ifdef HAVE_PTHREAD_SETNAME_NP
pthread_setname_np(syn_thr, "dosemu: fluid");
#endif
pcm_stream = pcm_allocate_stream(FLUS_CHANNELS, "MIDI",
(void*)MC_MIDI);
return 1;
err2:
delete_fluid_synth(synth);
err1:
delete_fluid_settings(settings);
return 0;
}
