Is fluidsynth Audio driver play a midi note needs 1 second?

[nijian141893]

Code like this:

 fluid_settings_t *settings = new_fluid_settings();
 fluid_synth_t *synth = new_fluid_synth(settings);
 fluid_audio_driver_t *adriver = new_fluid_audio_driver(settings, synth);

 // Load sample soundfont
 const char *soundfontPath = env->GetStringUTFChars(jSoundfontPath, nullptr);
 fluid_synth_sfload(synth, soundfontPath, 1);

 fluid_synth_noteon(synth, 0, 60, 127); // play middle C
 sleep(1); // sleep for 1 second
 fluid_synth_noteoff(synth, 0, 60); // stop playing middle C

I notice that, from a midi note play by audio driver, until it make a sound, which probably cost 1 second.

whether fluidsynth can process it more faster? thks

[derselbst]

Please stop asking questions which are already answered by the documentation:

https://www.fluidsynth.org/api/MIDIPlayer.html
https://www.fluidsynth.org/api/CreatingAudioDriver.html
https://www.fluidsynth.org/api/group__audio__driver.html#ga7c66ef86f0008807bdd955770fca6925

I've blocked you for 7 days to give you some time to read the documentation. Also, I recommend you to practice your English skills, because it's very difficult to understand you.

[derselbst]

To comment meaningfully about that we would need to know what operating system and which audio driver you are using and what settings you have with regard to the number and size of audio buffers.

We don't need to know about that. The documentation of new_fluid_audio_driver() clearly says that "As soon as an audio driver is created, the synth starts rendering audio". But instead, you are loading the soundfont afterwards. Depending on the size of the soundfont, this will take several seconds to complete. Stick to the code examples I've listed earlier and it will work correctly.

---

@jimhen3ry Pls note that you're incorrectly using URLs in markdown. Pls. look at my recent edit of your post(s).

[jimhen3ry]

My apologies if this really proves how much of a non-expert with FluidSynth I am.

I agree that fluid_synth_sfload() is the cause of the delay before the first note is heard. But wouldn't that be the case even if the soundfont were loaded before creating the audio driver? I do agree that it is better practice to load the needed soundfonts before creating the audio driver to avoid the possibility of trying to generate sound without having a soundfont loaded.

By the way it seems like example.c should be updated:

   . . .
    /* Create the settings. */
    settings = new_fluid_settings();

    /* Change the settings if necessary*/

    /* Create the synthesizer. */
    synth = new_fluid_synth(settings);

    /* Create the audio driver. The synthesizer starts playing as soon
       as the driver is created. */
    adriver = new_fluid_audio_driver(settings, synth);

    /* Load a SoundFont and reset presets (so that new instruments
     * get used from the SoundFont) */
    sfont_id = fluid_synth_sfload(synth, "example.sf2", 1);
    . . .

[derselbst]

By the way it seems like example.c should be updated:

Oh, thanks for the hint.

But wouldn't that be the case even if the soundfont were loaded before creating the audio driver?

The difference is that when using the file driver (as Nijian presumably did), you would have 1s of rendered silence in your file.

[jimhen3ry]

Aha! And a sneaky way to measure the loading time for a soundfont.

[nijian141893]

nijian141893,

I am not a FluidSynth expert but I will try to help you. It looks like the code you posted will play middle C for 1 second. If I understand correctly, you are saying that there is a delay of about 1 second before the middle C note plays. To comment meaningfully about that we would need to know what operating system and which audio driver you are using and what settings you have with regard to the number and size of audio buffers.

I will say that in my experience with FluidSynth on Windows using either the slow dsound driver or the faster WASAPI driver and reasonable buffer settings, there is very little delay from the time of calling FluidSynth to play a note until the audio is produced.

What are you using as the starting point for the 1 second delay to hearing the start of the note? If you are playing only one note, I would suspect the delay is the time it takes to load and execute the program up to the time when FluidSynth is called. I think if you play two notes, you will find that the time between them is correct.

It may be helpful to look at https://www.fluidsynth.org/api/examples.html The arpeggio and metronome examples would be particularly helpful to confirm that FluidSynth is providing audio without delays.

thank you very much, and recently, I come up with a method to resolve the delay question.

And, I use fluidsynth on Android app, across ndk to load .so library file.

So, I can init fluidsynth when my app start fisrtly， like this:

extern "C" JNIEXPORT void JNICALL
Java_com_example_myapplication_MainActivity_fluidsynthInit(JNIEnv *env, jobject jobj,
                                                                 jstring jSoundfontPath,
                                                                 jstring jOutputWavPath,
                                                                 jstring jMidiPath,
                                                                 jint jChannel,
                                                                 jint jkey,
                                                                 jint jvel) {
    settings = new_fluid_settings();
    const char *outputWavPath = env->GetStringUTFChars(jOutputWavPath, nullptr);
    fluid_settings_setstr(settings, "audio.file.name", outputWavPath);
    synth = new_fluid_synth(settings);
    renderer = new_fluid_file_renderer(synth);
    adriver = new_fluid_audio_driver(settings, synth);
    mdriver = new_fluid_midi_driver(settings, handle_midi_event, NULL);
    // Load sample soundfont
    const char *soundfontPath = env->GetStringUTFChars(jSoundfontPath, nullptr);
    fluid_synth_sfload(synth, soundfontPath, 1);
}

And then, I only call play a midi note, like this:

extern "C"
JNIEXPORT void JNICALL
Java_com_example_myapplication_MainActivity_sendMidiRealtimeNoteOn(JNIEnv *env, jobject thiz,
                                                                   jint jChannel,
                                                                   jint jkey,
                                                                   jint jvol) {
    __android_log_print(ANDROID_LOG_INFO, "nijian", "%s", "begin call note on");
    fluid_synth_noteon(synth, 0, jkey, jvol);
    __android_log_print(ANDROID_LOG_INFO, "nijian", "%s", "note on end!");
}

Across this way, I play a midi note, which can ignore fluidsynth Initialization time.
And then, My colleague help me to test when I called sendMidiRealtimeNoteOn until the
sound be detected by audacity(which help us to detect sound), It cost 300ms.

So my next work is to reduce this time from 300ms to 100ms,
now I am studying fluidsynth source code to resolve this question.