Android how to convert a midi input to wav file

[nijian141893]

I konw how to convert a midi file to wav, and it's successful

but, I can't convert a midi input ,like some note，then convert to wav file

please help me, tks.

[derselbst]

I'm not sure what you're asking for in particular. However, I can tell that currently fluidsynth does not provide a MIDI driver for android. Downstream apps will have to implement their own MIDI handling and dispatch the events to fluidsynth.

[nijian141893]

I'm not sure what you're asking for in particular. However, I can tell that currently fluidsynth does not provide a MIDI driver for android. Downstream apps will have to implement their own MIDI handling and dispatch the events to fluidsynth.

I mean not midi driver， for example：

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

this code simulate a midi input then to play

fluid_player_add(player, midiPath);
fluid_player_play(player);

// set basic channel to export
channelToExport = jChannel;
fluid_player_set_playback_callback(player, handle_midi_event , synth);

// start conversion
renderer = new_fluid_file_renderer (synth);
while (fluid_player_get_status(player) == FLUID_PLAYER_PLAYING)
{
    if (fluid_file_renderer_process_block(renderer) != FLUID_OK)
    {
        break;
    }
}

this code can convert a midi file to .wav file to somewhere.

I want write some code in my .cpp program, I want use like fluid_synth_noteon(xxx) to simulate a midi note,
then use fluid_file_renderer_process_block(xxx) to convert it to .wav file。

now, I don't know how to write this code, please help me , thanks

[derselbst]

Did you had a look at the sequencer example?

https://www.fluidsynth.org/api/Sequencer.html

Instead of using new_fluid_audio_driver() you would use the new_fluid_file_renderer() as you already did. And instead of sleep(100000); your main function would constantly call fluid_file_renderer_process_block(renderer) until you think you've rendered enough audio.

[nijian141893]

firstly tks, I see your doc, and write code like this:

#include <jni.h>
#include <unistd.h>
#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;
fluid_file_renderer_t *renderer;

// prototype
void seq_callback(unsigned int time, fluid_event_t *event, fluid_sequencer_t *seq, void *data);

void createsynth(JNIEnv *env, jstring jOutputWavPath) {
    fluid_settings_t *settings;
    settings = new_fluid_settings();
    fluid_settings_setint(settings, "synth.reverb.active", 0);
    fluid_settings_setint(settings, "synth.chorus.active", 0);
    // specify the file to store the audio to
    const char *outputWavPath = env->GetStringUTFChars(jOutputWavPath, nullptr);
    fluid_settings_setstr(settings, "audio.file.name", outputWavPath);
    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(JNIEnv *env, jstring jSoundfontPath) {
    int fluid_res;
    // put your own path here
    // Load sample soundfont
    const char *soundfontPath = env->GetStringUTFChars(jSoundfontPath, nullptr);
    fluid_res = fluid_synth_sfload(synth, soundfontPath, 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();
}

void convert() {
    // start conversion
    renderer = new_fluid_file_renderer(synth);
    fluid_file_renderer_process_block(renderer);
}

extern "C" JNIEXPORT void JNICALL
Java_com_example_myapplication_MainActivity2_fluidsynthHelloWorld(JNIEnv *env, jobject,
                                                                  jstring jSoundfontPath,
                                                                  jstring jOutputWavPath,
                                                                  jstring jMidiPath,
                                                                  jint jChannel) {
    createsynth(env, jOutputWavPath);
    loadsoundfont(env, jSoundfontPath);
    // initialize our absolute date
    now = fluid_sequencer_get_tick(sequencer);
    schedule_next_sequence();
    convert();

    sleep(30000);
    deletesynth();
}

this is my java code:

String tempSoundfontPath = copyAssetToTmpFile("aaa.sf2");
String midiPath = copyAssetToTmpFile("second.mid");
fluidsynthHelloWorld(tempSoundfontPath, getFilesDir().toString()+"/test2.wav", midiPath, 1);

and the fluidsynth can play the midi, I can hear the sound, but it convert test2.wav can't to play.
So it can produce test2.wav, but it seem to be a bad audio file , which can't play.

please help me , how could I modify my code , thank you very much.

[derselbst]

So it can produce test2.wav, but it seem to be a bad audio file , who can't play.

So, this is how much attention you pay to the documentation?! This particular issue is explained in the same example that you just wrote earlier: here. It is also mentioned here, and here.

In any case the rendered file will contain garbage, because you're now having an audio driver AND a file driver, both rendering audio from the same synth. I suggest you read my notes more carefully and pay more attention to the documentation.

and the fluidsynth can play the midi,

How can it play the MIDI when you're not even using the midiPath parameter? What you hear are the events from the demo program. Why are you mixing up those use-cases? It's not clear to me what you're trying to achieve.

[nijian141893]

forgive me, I am a newer for c or c++，I read your doc difficult. sorry

I want do, for example, A midi keyboard press a key, then across ble send midi signal to my cellphone,
and then my cellphone use this midi signal to do my work.
1> use fluidsynth to load my .sf2 file
2> use fluidsynth to play the midi signal
3> then produce .wav file, the .wav file is I want achieve.

so .wav file is corresponding with the midi signal

and the doc you say, https://www.fluidsynth.org/api/FileRenderer.html
Fast file renderer for non-realtime MIDI file rendering
this teach me about file render from not-realtime MIDI file, BUT I want realtime MIDI signal render.

thank you, please..

[derselbst]

I want realtime MIDI signal render.

You could have mentioned that earlier...

I want do, for example, A midi keyboard press a key, then across ble send midi signal to my cellphone,
and then my cellphone use this midi signal to do my work.

This is what I said in my very first answer: A MIDI driver would do this, but there is none on Android. Hence, you would have to implement your handling, like this one: https://www.fluidsynth.org/api/SendingMIDI.html

And you would create the audio driver like so:

fluid_settings_setstr(settings, "audio.driver", "file");
adriver = new_fluid_audio_driver(settings, synth);

[nijian141893]

fluid_settings_setstr(settings, "audio.driver", "file");

this setting is great!

now I can convert my realtime midi to .wav file. thank you very much.

you are the best people in the world.