static void
gst_fluid_dec_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstFluidDec *fluiddec = GST_FLUID_DEC (object);
switch (prop_id) {
case PROP_SOUNDFONT:
g_free (fluiddec->soundfont);
fluiddec->soundfont = g_value_dup_string (value);
break;
case PROP_SYNTH_CHORUS:
fluiddec->synth_chorus = g_value_get_boolean (value);
fluid_synth_set_chorus_on (fluiddec->synth, fluiddec->synth_chorus);
break;
case PROP_SYNTH_REVERB:
fluiddec->synth_reverb = g_value_get_boolean (value);
fluid_synth_set_reverb_on (fluiddec->synth, fluiddec->synth_reverb);
break;
case PROP_SYNTH_GAIN:
fluiddec->synth_gain = g_value_get_double (value);
fluid_synth_set_gain (fluiddec->synth, fluiddec->synth_gain);
break;
case PROP_SYNTH_POLYPHONY:
fluiddec->synth_polyphony = g_value_get_int (value);
fluid_synth_set_polyphony (fluiddec->synth, fluiddec->synth_polyphony);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
/* initialize the new element
* instantiate pads and add them to element
* set functions
* initialize structure
*/
static void
gst_fluid_dec_init (GstFluidDec * filter)
{
filter->sinkpad = gst_pad_new_from_static_template (&sink_factory, "sink");
gst_pad_set_event_function (filter->sinkpad, gst_fluid_dec_sink_event);
gst_pad_set_chain_function (filter->sinkpad, gst_fluid_dec_chain);
gst_element_add_pad (GST_ELEMENT (filter), filter->sinkpad);
filter->srcpad = gst_pad_new_from_static_template (&src_factory, "src");
gst_pad_use_fixed_caps (filter->srcpad);
gst_element_add_pad (GST_ELEMENT (filter), filter->srcpad);
filter->soundfont = g_strdup (DEFAULT_SOUNDFONT);
filter->synth_chorus = DEFAULT_SYNTH_CHORUS;
filter->synth_reverb = DEFAULT_SYNTH_REVERB;
filter->synth_gain = DEFAULT_SYNTH_GAIN;
filter->synth_polyphony = DEFAULT_SYNTH_POLYPHONY;
filter->settings = new_fluid_settings ();
filter->synth = new_fluid_synth (filter->settings);
filter->sf = -1;
fluid_synth_set_chorus_on (filter->synth, filter->synth_chorus);
fluid_synth_set_reverb_on (filter->synth, filter->synth_reverb);
fluid_synth_set_gain (filter->synth, filter->synth_gain);
fluid_synth_set_polyphony (filter->synth, filter->synth_polyphony);
}
void sf2Instrument::updateReverbOn()
{
fluid_synth_set_reverb_on( m_synth, m_reverbOn.value() ? 1 : 0 );
}
static int Open (vlc_object_t *p_this)
{
decoder_t *p_dec = (decoder_t *)p_this;
if (p_dec->fmt_in.i_codec != VLC_CODEC_MIDI)
return VLC_EGENERIC;
decoder_sys_t *p_sys = (decoder_sys_t *)malloc (sizeof (*p_sys)); // sunqueen modify
if (unlikely(p_sys == NULL))
return VLC_ENOMEM;
p_sys->settings = new_fluid_settings ();
p_sys->synth = new_fluid_synth (p_sys->settings);
p_sys->soundfont = -1;
char *font_path = var_InheritString (p_this, "soundfont");
if (font_path != NULL)
{
msg_Dbg (p_this, "loading sound fonts file %s", font_path);
p_sys->soundfont = fluid_synth_sfload (p_sys->synth, font_path, 1);
if (p_sys->soundfont == -1)
msg_Err (p_this, "cannot load sound fonts file %s", font_path);
free (font_path);
}
#ifdef _POSIX_VERSION
else
{
glob_t gl;
glob ("/usr/share/sounds/sf2/*.sf2", GLOB_NOESCAPE, NULL, &gl);
for (size_t i = 0; i < gl.gl_pathc; i++)
{
const char *path = gl.gl_pathv[i];
msg_Dbg (p_this, "loading sound fonts file %s", path);
p_sys->soundfont = fluid_synth_sfload (p_sys->synth, path, 1);
if (p_sys->soundfont != -1)
break; /* it worked! */
msg_Err (p_this, "cannot load sound fonts file %s", path);
}
globfree (&gl);
}
#endif
if (p_sys->soundfont == -1)
{
msg_Err (p_this, "sound font file required for synthesis");
dialog_Fatal (p_this, _("MIDI synthesis not set up"),
_("A sound font file (.SF2) is required for MIDI synthesis.\n"
"Please install a sound font and configure it "
"from the VLC preferences "
"(Input / Codecs > Audio codecs > FluidSynth).\n"));
delete_fluid_synth (p_sys->synth);
delete_fluid_settings (p_sys->settings);
free (p_sys);
return VLC_EGENERIC;
}
fluid_synth_set_chorus_on (p_sys->synth,
var_InheritBool (p_this, "synth-chorus"));
fluid_synth_set_gain (p_sys->synth,
var_InheritFloat (p_this, "synth-gain"));
fluid_synth_set_polyphony (p_sys->synth,
var_InheritInteger (p_this, "synth-polyphony"));
fluid_synth_set_reverb_on (p_sys->synth,
var_InheritBool (p_this, "synth-reverb"));
p_dec->fmt_out.i_cat = AUDIO_ES;
p_dec->fmt_out.audio.i_rate =
var_InheritInteger (p_this, "synth-sample-rate");;
fluid_synth_set_sample_rate (p_sys->synth, p_dec->fmt_out.audio.i_rate);
p_dec->fmt_out.audio.i_channels = 2;
p_dec->fmt_out.audio.i_original_channels =
p_dec->fmt_out.audio.i_physical_channels =
AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT;
p_dec->fmt_out.i_codec = VLC_CODEC_FL32;
p_dec->fmt_out.audio.i_bitspersample = 32;
date_Init (&p_sys->end_date, p_dec->fmt_out.audio.i_rate, 1);
date_Set (&p_sys->end_date, 0);
p_dec->p_sys = p_sys;
p_dec->pf_decode_audio = DecodeBlock;
return VLC_SUCCESS;
}
int MidiDriver_FluidSynth::open() {
if (_isOpen)
return MERR_ALREADY_OPEN;
if (!ConfMan.hasKey("soundfont"))
error("FluidSynth requires a 'soundfont' setting");
_settings = new_fluid_settings();
// The default gain setting is ridiculously low - at least for me. This
// cannot be fixed by ScummVM's volume settings because they can only
// soften the sound, not amplify it, so instead we add an option to
// adjust the gain of FluidSynth itself.
double gain = (double)ConfMan.getInt("midi_gain") / 100.0;
setNum("synth.gain", gain);
setNum("synth.sample-rate", _outputRate);
_synth = new_fluid_synth(_settings);
if (ConfMan.getBool("fluidsynth_chorus_activate")) {
fluid_synth_set_chorus_on(_synth, 1);
int chorusNr = ConfMan.getInt("fluidsynth_chorus_nr");
double chorusLevel = (double)ConfMan.getInt("fluidsynth_chorus_level") / 100.0;
double chorusSpeed = (double)ConfMan.getInt("fluidsynth_chorus_speed") / 100.0;
double chorusDepthMs = (double)ConfMan.getInt("fluidsynth_chorus_depth") / 10.0;
Common::String chorusWaveForm = ConfMan.get("fluidsynth_chorus_waveform");
int chorusType = FLUID_CHORUS_MOD_SINE;
if (chorusWaveForm == "sine") {
chorusType = FLUID_CHORUS_MOD_SINE;
} else {
chorusType = FLUID_CHORUS_MOD_TRIANGLE;
}
fluid_synth_set_chorus(_synth, chorusNr, chorusLevel, chorusSpeed, chorusDepthMs, chorusType);
} else {
fluid_synth_set_chorus_on(_synth, 0);
}
if (ConfMan.getBool("fluidsynth_reverb_activate")) {
fluid_synth_set_reverb_on(_synth, 1);
double reverbRoomSize = (double)ConfMan.getInt("fluidsynth_reverb_roomsize") / 100.0;
double reverbDamping = (double)ConfMan.getInt("fluidsynth_reverb_damping") / 100.0;
int reverbWidth = ConfMan.getInt("fluidsynth_reverb_width");
double reverbLevel = (double)ConfMan.getInt("fluidsynth_reverb_level") / 100.0;
fluid_synth_set_reverb(_synth, reverbRoomSize, reverbDamping, reverbWidth, reverbLevel);
} else {
fluid_synth_set_reverb_on(_synth, 0);
}
Common::String interpolation = ConfMan.get("fluidsynth_misc_interpolation");
int interpMethod = FLUID_INTERP_4THORDER;
if (interpolation == "none") {
interpMethod = FLUID_INTERP_NONE;
} else if (interpolation == "linear") {
interpMethod = FLUID_INTERP_LINEAR;
} else if (interpolation == "4th") {
interpMethod = FLUID_INTERP_4THORDER;
} else if (interpolation == "7th") {
interpMethod = FLUID_INTERP_7THORDER;
}
fluid_synth_set_interp_method(_synth, -1, interpMethod);
const char *soundfont = ConfMan.get("soundfont").c_str();
_soundFont = fluid_synth_sfload(_synth, soundfont, 1);
if (_soundFont == -1)
error("Failed loading custom sound font '%s'", soundfont);
MidiDriver_Emulated::open();
_mixer->playStream(Audio::Mixer::kPlainSoundType, &_mixerSoundHandle, this, -1, Audio::Mixer::kMaxChannelVolume, 0, DisposeAfterUse::NO, true);
return 0;
}
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;
}
