T14: SF host bridge native (FluidSynth runtime DLL) + golden test

2026-08-11 17:11:29 +07:00
parent b9817e1aed
commit 500384a226
6 changed files with 862 additions and 0 deletions
@@ -0,0 +1,434 @@
+// SFHost.cpp — FluidSynth native bridge (T14)
+//
+// DLL export C API để chạy libfluidsynth (native, không WASM) trong audio
+// loop chung (SPSC + WASAPI, giống VST2/VST3 bridge). Mục tiêu T14: track
+// SF chơi bằng FluidSynth native cùng master với track VSTi; gain/pan/master
+// limiter (NativeMixer) áp cho cả 2; preview/items/offline nhất quán.
+//
+// QUYẾT ĐỊNH (T14): KHÔNG link tĩnh libfluidsynth (runtime DLL 12MB + phụ
+// thuộc) — load động qua GetProcAddress từ native_host/fluidsynth_runtime/
+// (gitignore; tái tạo bằng scripts/dl_fluidsynth_runtime.py). Load bằng
+// LoadLibraryExW(LOAD_WITH_ALTERED_SEARCH_PATH) để các DLL phụ thuộc cùng
+// thư mục được tìm thấy.
+//
+// Thread-safety: fluid_synth_* KHÔNG thread-safe — mọi gọi synth (sfload,
+// noteon/off, write_float, set_gain) chỉ trên audio thread; sfload CHỈ trước
+// AudioStart. MIDI từ UI thread → SPSC (AudioEngine) → audio thread drain.
+#include <windows.h>
+
+#include <atomic>
+#include <cstdio>
+#include <cstring>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <vector>
+
+#include "AudioEngine.h"
+#include "NativeMixer.h"
+
+using int32 = int32_t;
+
+namespace {
+
+// FluidSynth C API (runtime load — xem fluidsynth/synth.h, settings.h)
+typedef void* fluid_settings_t;
+typedef void* fluid_synth_t;
+
+typedef fluid_settings_t (*FS_SettingsNew) (void);
+typedef int (*FS_SettingsSetnum) (fluid_settings_t, const char*, double);
+typedef int (*FS_SettingsSetstr) (fluid_settings_t, const char*, const char*);
+typedef void (*FS_SettingsDelete) (fluid_settings_t);
+typedef fluid_synth_t (*FS_SynthNew) (fluid_settings_t);
+typedef int (*FS_SynthDelete) (fluid_synth_t);
+typedef int (*FS_SynthSfload) (fluid_synth_t, const char*, int);
+typedef int (*FS_SynthNoteon) (fluid_synth_t, int, int, int);
+typedef int (*FS_SynthNoteoff) (fluid_synth_t, int, int);
+typedef int (*FS_SynthAllNotesOff) (fluid_synth_t, int);
+typedef void (*FS_SynthWriteFloat) (fluid_synth_t, int, float*, int, int,
+                                    float*, int, int);
+typedef int (*FS_SynthSetGain) (fluid_synth_t, float);
+typedef int (*FS_SynthProgramSelect) (fluid_synth_t, int, int, int, int);
+
+struct FS
+{
+    FS_SettingsNew settings_new = nullptr;
+    FS_SettingsSetnum settings_setnum = nullptr;
+    FS_SettingsSetstr settings_setstr = nullptr;
+    FS_SettingsDelete settings_delete = nullptr;
+    FS_SynthNew synth_new = nullptr;
+    FS_SynthDelete synth_delete = nullptr;
+    FS_SynthSfload synth_sfload = nullptr;
+    FS_SynthNoteon synth_noteon = nullptr;
+    FS_SynthNoteoff synth_noteoff = nullptr;
+    FS_SynthAllNotesOff synth_all_notes_off = nullptr;
+    FS_SynthWriteFloat synth_write_float = nullptr;
+    FS_SynthSetGain synth_set_gain = nullptr;
+    FS_SynthProgramSelect synth_program_select = nullptr;
+};
+
+bool load_fs (HMODULE m, FS& fs)
+{
+    // FluidSynth 2.5.x exports: new_fluid_*/delete_fluid_* (prefix), còn lại
+    // fluid_* — xác minh bằng dumpbin /exports trên libfluidsynth-3.dll.
+    fs.settings_new = reinterpret_cast<FS_SettingsNew> (GetProcAddress (m, "new_fluid_settings"));
+    fs.settings_setnum = reinterpret_cast<FS_SettingsSetnum> (GetProcAddress (m, "fluid_settings_setnum"));
+    fs.settings_setstr = reinterpret_cast<FS_SettingsSetstr> (GetProcAddress (m, "fluid_settings_setstr"));
+    fs.settings_delete = reinterpret_cast<FS_SettingsDelete> (GetProcAddress (m, "delete_fluid_settings"));
+    fs.synth_new = reinterpret_cast<FS_SynthNew> (GetProcAddress (m, "new_fluid_synth"));
+    fs.synth_delete = reinterpret_cast<FS_SynthDelete> (GetProcAddress (m, "delete_fluid_synth"));
+    fs.synth_sfload = reinterpret_cast<FS_SynthSfload> (GetProcAddress (m, "fluid_synth_sfload"));
+    fs.synth_noteon = reinterpret_cast<FS_SynthNoteon> (GetProcAddress (m, "fluid_synth_noteon"));
+    fs.synth_noteoff = reinterpret_cast<FS_SynthNoteoff> (GetProcAddress (m, "fluid_synth_noteoff"));
+    fs.synth_all_notes_off = reinterpret_cast<FS_SynthAllNotesOff> (GetProcAddress (m, "fluid_synth_all_notes_off"));
+    fs.synth_write_float = reinterpret_cast<FS_SynthWriteFloat> (GetProcAddress (m, "fluid_synth_write_float"));
+    fs.synth_set_gain = reinterpret_cast<FS_SynthSetGain> (GetProcAddress (m, "fluid_synth_set_gain"));
+    fs.synth_program_select = reinterpret_cast<FS_SynthProgramSelect> (GetProcAddress (m, "fluid_synth_program_select"));
+    return fs.settings_new && fs.settings_setnum && fs.synth_new && fs.synth_sfload &&
+           fs.synth_noteon && fs.synth_noteoff && fs.synth_write_float && fs.synth_set_gain;
+}
+
+struct Instance
+{
+    HMODULE fsLib = nullptr;
+    FS fs;
+    fluid_settings_t settings = nullptr;
+    fluid_synth_t synth = nullptr;
+    int sfid = -1; // sfont id tra ve tu fluid_synth_sfload
+    int32 sampleRate = 44100;
+    int32 blockSize = 512;
+    int32 handle = 0;
+    sonicforge::AudioEngine audio;
+    std::atomic<bool> audioRunning {false};
+    sonicforge::NativeMixer mixer;
+};
+
+std::mutex g_mutex;
+std::map<int32, std::unique_ptr<Instance>> g_instances;
+int32 g_next_handle = 1;
+
+void set_err (char* err, int32 err_cap, const char* msg)
+{
+    if (err && err_cap > 0)
+        std::snprintf (err, static_cast<size_t> (err_cap), "%s", msg);
+}
+
+// Audio thread callback (WASAPI render thread): drain MIDI SPSC → synth
+// noteon/noteoff → fluid_synth_write_float → mixer (gain/pan/limiter).
+bool fsAudioProcess (const sonicforge::MidiEvent* events, int32 eventCount,
+                     float* outL, float* outR, int32 frames, void* userdata)
+{
+    Instance* inst = static_cast<Instance*> (userdata);
+    if (!inst || !inst->synth)
+        return false;
+
+    for (int32 i = 0; i < eventCount; ++i)
+    {
+        const sonicforge::MidiEvent& e = events[i];
+        if (e.noteOn)
+            inst->fs.synth_noteon (inst->synth, e.channel, e.pitch,
+                                   static_cast<int> (e.velocity * 127.0f));
+        else
+            inst->fs.synth_noteoff (inst->synth, e.channel, e.pitch);
+    }
+
+    inst->fs.synth_write_float (inst->synth, frames, outL, 0, 1, outR, 0, 1);
+    inst->mixer.processInPlace (outL, outR, frames);
+    return true;
+}
+
+} // namespace
+
+extern "C" {
+
+// Tạo synth + load runtime DLL. sfload CHỈ sau Create (trước AudioStart).
+// Trả handle (>= 1) hoặc 0 + err.
+__declspec (dllexport) int32 SF_FS_Create (int32 sampleRate, int32 blockSize,
+                                           char* err, int32 err_cap)
+{
+    std::lock_guard<std::mutex> lock (g_mutex);
+
+    auto inst = std::make_unique<Instance> ();
+    inst->sampleRate = sampleRate > 0 ? sampleRate : 44100;
+    inst->blockSize = blockSize > 0 ? blockSize : 512;
+
+    // Runtime DLL trong native_host/fluidsynth_runtime/ (gitignore) — tìm
+    // tương đối với chính sf_host_bridge.dll (GetModuleHandleW) chứ không
+    // phải exe host: bridge có thể được load từ python test / Tauri app.
+    HMODULE self = GetModuleHandleW (L"sf_host_bridge");
+    wchar_t selfPath[MAX_PATH] = {};
+    DWORD selfLen = self ? GetModuleFileNameW (self, selfPath, MAX_PATH) : 0;
+    std::wstring dir;
+    if (selfLen > 0)
+    {
+        dir = selfPath;
+        auto slash = dir.find_last_of (L'\\');
+        if (slash != std::wstring::npos)
+            dir.resize (slash + 1);
+    }
+    std::wstring fsDll = dir + L"fluidsynth_runtime\\libfluidsynth-3.dll";
+
+    inst->fsLib = LoadLibraryExW (fsDll.c_str (), nullptr, LOAD_WITH_ALTERED_SEARCH_PATH);
+    if (!inst->fsLib)
+    {
+        set_err (err, err_cap, "LoadLibraryExW libfluidsynth failed");
+        return 0;
+    }
+    if (!load_fs (inst->fsLib, inst->fs))
+    {
+        FreeLibrary (inst->fsLib);
+        set_err (err, err_cap, "libfluidsynth exports missing");
+        return 0;
+    }
+
+    inst->settings = inst->fs.settings_new ();
+    inst->fs.settings_setnum (inst->settings, "synth.sample-rate",
+                              static_cast<double> (inst->sampleRate));
+    // T14: render thẳng ra float stereo, không qua audio driver của fluidsynth.
+    inst->fs.settings_setstr (inst->settings, "audio.driver", "file");
+    inst->synth = inst->fs.synth_new (inst->settings);
+    if (!inst->synth)
+    {
+        inst->fs.settings_delete (inst->settings);
+        FreeLibrary (inst->fsLib);
+        set_err (err, err_cap, "fluid_synth_new failed");
+        return 0;
+    }
+    // WASM client dùng gain 1.0 — mirror.
+    inst->fs.synth_set_gain (inst->synth, 1.0f);
+
+    int32 handle = g_next_handle++;
+    inst->handle = handle;
+    g_instances[handle] = std::move (inst);
+    return handle;
+}
+
+// Load SF2/SF3 vào synth. reset=0: giữ preset đã chọn. CHỈ trước AudioStart.
+__declspec (dllexport) int32 SF_FS_LoadSF2 (int32 handle, const char* path_utf8,
+                                            char* err, int32 err_cap)
+{
+    std::lock_guard<std::mutex> lock (g_mutex);
+    auto it = g_instances.find (handle);
+    if (it == g_instances.end ())
+    {
+        set_err (err, err_cap, "bad handle");
+        return -1;
+    }
+    Instance* inst = it->second.get ();
+    if (!inst->synth || !path_utf8)
+    {
+        set_err (err, err_cap, "not created or null path");
+        return -2;
+    }
+    if (inst->audioRunning.load (std::memory_order_acquire))
+    {
+        set_err (err, err_cap, "sfload only before AudioStart");
+        return -3;
+    }
+    int sfid = inst->fs.synth_sfload (inst->synth, path_utf8, 0);
+    if (sfid < 0)
+    {
+        set_err (err, err_cap, "fluid_synth_sfload failed");
+        return -4;
+    }
+    inst->sfid = sfid;
+    return 0;
+}
+
+// Chọn instrument channel (bank/program) — mirror WASM selectInstrument.
+// sfont_id: id trả từ SF_FS_LoadSF2 (0..n-1); fluid_synth_program_select
+// signature: (synth, chan, sfont_id, bank_num, preset_num).
+__declspec (dllexport) int32 SF_FS_SelectInstrument (int32 handle, int32 channel,
+                                                     int32 sfontId, int32 bank,
+                                                     int32 program)
+{
+    std::lock_guard<std::mutex> lock (g_mutex);
+    auto it = g_instances.find (handle);
+    if (it == g_instances.end ())
+        return -1;
+    Instance* inst = it->second.get ();
+    if (!inst->synth)
+        return -2;
+    int fid = (sfontId < 0) ? inst->sfid : sfontId;
+    return inst->fs.synth_program_select (inst->synth, channel, fid, bank, program);
+}
+
+__declspec (dllexport) int32 SF_FS_NoteOn (int32 handle, int32 channel, int32 pitch,
+                                           int32 velocity)
+{
+    std::lock_guard<std::mutex> lock (g_mutex);
+    auto it = g_instances.find (handle);
+    if (it == g_instances.end ())
+        return -1;
+    Instance* inst = it->second.get ();
+    if (!inst->synth)
+        return -2;
+    if (inst->audioRunning.load (std::memory_order_acquire))
+    {
+        sonicforge::MidiEvent ev = {};
+        ev.channel = channel;
+        ev.pitch = pitch;
+        ev.velocity = static_cast<float> (velocity) / 127.0f;
+        ev.noteOn = true;
+        inst->audio.pushMidi (ev);
+        return 0;
+    }
+    return inst->fs.synth_noteon (inst->synth, channel, pitch, velocity);
+}
+
+__declspec (dllexport) int32 SF_FS_NoteOff (int32 handle, int32 channel, int32 pitch)
+{
+    std::lock_guard<std::mutex> lock (g_mutex);
+    auto it = g_instances.find (handle);
+    if (it == g_instances.end ())
+        return -1;
+    Instance* inst = it->second.get ();
+    if (!inst->synth)
+        return -2;
+    if (inst->audioRunning.load (std::memory_order_acquire))
+    {
+        sonicforge::MidiEvent ev = {};
+        ev.channel = channel;
+        ev.pitch = pitch;
+        ev.velocity = 0.0f;
+        ev.noteOn = false;
+        inst->audio.pushMidi (ev);
+        return 0;
+    }
+    return inst->fs.synth_noteoff (inst->synth, channel, pitch);
+}
+
+__declspec (dllexport) int32 SF_FS_AllNotesOff (int32 handle, int32 channel)
+{
+    std::lock_guard<std::mutex> lock (g_mutex);
+    auto it = g_instances.find (handle);
+    if (it == g_instances.end ())
+        return -1;
+    Instance* inst = it->second.get ();
+    if (!inst->synth)
+        return -2;
+    return inst->fs.synth_all_notes_off (inst->synth, channel);
+}
+
+// Render offline 1 block thẳng ra buffer (không qua WASAPI): fluid_synth_write_float
+// + mixer. Dùng cho golden test T14 (so với server reference) và offline path.
+// outL/outR: frames mẫu mỗi kênh. Trả 0 nếu OK.
+__declspec (dllexport) int32 SF_FS_RenderBlock (int32 handle, int32 frames,
+                                                float* outL, float* outR)
+{
+    std::lock_guard<std::mutex> lock (g_mutex);
+    auto it = g_instances.find (handle);
+    if (it == g_instances.end ())
+        return -1;
+    Instance* inst = it->second.get ();
+    if (!inst->synth || !outL || !outR || frames <= 0)
+        return -2;
+    inst->fs.synth_write_float (inst->synth, frames, outL, 0, 1, outR, 0, 1);
+    inst->mixer.processInPlace (outL, outR, frames);
+    return 0;
+}
+
+__declspec (dllexport) int32 SF_FS_AudioStart (int32 handle, int32 sampleRate,
+                                               int32 blockSize, char* err, int32 err_cap)
+{
+    std::lock_guard<std::mutex> lock (g_mutex);
+    auto it = g_instances.find (handle);
+    if (it == g_instances.end ())
+        return -1;
+    Instance* inst = it->second.get ();
+    if (!inst->synth)
+        return -2;
+    inst->audioRunning.store (true, std::memory_order_release);
+    if (!inst->audio.start (sampleRate > 0 ? sampleRate : inst->sampleRate,
+                            blockSize > 0 ? blockSize : inst->blockSize,
+                            &fsAudioProcess, inst, err, err_cap))
+    {
+        inst->audioRunning.store (false, std::memory_order_release);
+        return -3;
+    }
+    return 0;
+}
+
+__declspec (dllexport) int32 SF_FS_AudioStop (int32 handle)
+{
+    std::lock_guard<std::mutex> lock (g_mutex);
+    auto it = g_instances.find (handle);
+    if (it == g_instances.end ())
+        return -1;
+    it->second->audioRunning.store (false, std::memory_order_release);
+    it->second->audio.stop ();
+    return 0;
+}
+
+__declspec (dllexport) int32 SF_FS_AudioUnderruns (int32 handle)
+{
+    std::lock_guard<std::mutex> lock (g_mutex);
+    auto it = g_instances.find (handle);
+    if (it == g_instances.end ())
+        return -1;
+    return it->second->audio.underruns ();
+}
+
+__declspec (dllexport) int32 SF_FS_AudioLatency (int32 handle)
+{
+    std::lock_guard<std::mutex> lock (g_mutex);
+    auto it = g_instances.find (handle);
+    if (it == g_instances.end ())
+        return -1;
+    return it->second->audio.latencySamples ();
+}
+
+__declspec (dllexport) int32 SF_FS_AudioBlocks (int32 handle)
+{
+    std::lock_guard<std::mutex> lock (g_mutex);
+    auto it = g_instances.find (handle);
+    if (it == g_instances.end ())
+        return -1;
+    return it->second->audio.blocksRendered ();
+}
+
+// T13 chung: track gain/pan + master limiter qua NativeMixer.
+__declspec (dllexport) int32 SF_FS_SetTrackGainPan (int32 handle, float gainDb, float pan)
+{
+    std::lock_guard<std::mutex> lock (g_mutex);
+    auto it = g_instances.find (handle);
+    if (it == g_instances.end ())
+        return -1;
+    it->second->mixer.setTrack (sonicforge::TrackGainPan::fromDbPan (gainDb, pan));
+    return 0;
+}
+
+__declspec (dllexport) int32 SF_FS_SetMasterLimiter (int32 handle, int32 active, float thresholdDb)
+{
+    std::lock_guard<std::mutex> lock (g_mutex);
+    auto it = g_instances.find (handle);
+    if (it == g_instances.end ())
+        return -1;
+    it->second->mixer.setLimiter (active != 0, thresholdDb);
+    return 0;
+}
+
+// Đóng: stop audio loop, xóa synth, giải phóng DLL.
+__declspec (dllexport) int32 SF_FS_Close (int32 handle, char* err, int32 err_cap)
+{
+    (void) err;
+    (void) err_cap;
+    std::lock_guard<std::mutex> lock (g_mutex);
+    auto it = g_instances.find (handle);
+    if (it == g_instances.end ())
+        return -1;
+    Instance* inst = it->second.get ();
+    inst->audioRunning.store (false, std::memory_order_release);
+    inst->audio.stop ();
+    if (inst->synth)
+        inst->fs.synth_delete (inst->synth);
+    if (inst->settings)
+        inst->fs.settings_delete (inst->settings);
+    if (inst->fsLib)
+        FreeLibrary (inst->fsLib);
+    g_instances.erase (it);
+    return 0;
+}
+
+} // extern "C"