Use full GM SoundFont and verify sampler timing

Dockerfile

@@ -6,7 +6,8 @@ ENV DEBIAN_FRONTEND=noninteractive \
     GRADIO_ANALYTICS_ENABLED=False
 
 RUN apt-get update && apt-get install -y --no-install-recommends \
-    ffmpeg fluidsynth libsndfile1 libgomp1 curl ca-certificates p7zip-full && \
+    ffmpeg fluidsynth fluid-soundfont-gm libsndfile1 libgomp1 \
+    curl ca-certificates p7zip-full && \
     rm -rf /var/lib/apt/lists/*
 
 # Full multi-sampled CC0 electric guitar and bass. Pin release archives so a

README.md

@@ -18,7 +18,8 @@ models:
 
 Upload a short hum or record one in the browser. One request generates seven
 source-timed comparisons. SheetSage2 extracts notes and beats; FluidSynth
-renders an instrument alone and with a GM drum kit, plus sampled electric
+uses the full [FluidR3 GM bank](https://www.fluidsynth.org/wiki/GettingStarted/)
+for the selected instrument and drum kit, plus sampled electric
 guitar and fingered bass in clean and processed versions. The bass is shifted
 down one octave, with note starts and lengths preserved. A continuous-F0 synth
 follows voice pitch and amplitude. The sampler uses full-size FreePats electric

pipeline.py

@@ -18,6 +18,8 @@ ROOT = Path(__file__).resolve().parent
 SHEET_PYTHON = Path(os.environ.get("HUM_SHEET_PYTHON", "/opt/sheet/bin/python"))
 YUE_PYTHON = Path(os.environ.get("HUM_YUE_PYTHON", "/opt/yue/bin/python"))
 SOUNDFONT_DIR = Path(os.environ.get("HUM_SOUNDFONTS", "/opt/soundfonts"))
+GM_SOUNDFONT = Path(os.environ.get("HUM_GM_SOUNDFONT",
+                                "/usr/share/sounds/sf2/FluidR3_GM.sf2"))
 VARIANTS = (
     "instrument", "instrument_drums", "contour",
     "guitar_clean", "guitar_amp", "bass_clean", "bass_amp",
@@ -77,12 +79,11 @@ def transcribe(pcm24: Path, folder: Path, log: Path) -> tuple[Path, Path, Path,
 def render_midi(midi_path: Path, output: Path, duration: float, log: Path,
                 soundfont: Path | None = None) -> Path:
     import numpy as np
-    import pretty_midi
     import soundfile as sf
 
-    soundfont = soundfont or Path(pretty_midi.__file__).parent / "TimGM6mb.sf2"
+    soundfont = soundfont or GM_SOUNDFONT
     if not soundfont.is_file():
-        raise RuntimeError("SoundFont missing from pretty_midi installation")
+        raise RuntimeError(f"SoundFont не найден: {soundfont}")
     raw = output.with_name(output.stem + "-tail.wav")
     command(["fluidsynth", "-ni", "-C", "0", "-R", "0", "-r", "48000",
              "-z", "64", "-g", ".2", "-o", "player.timing-source=sample",

test_sampler.py

@@ -0,0 +1,60 @@
+"""Sampler note timing and audio effect contracts."""
+
+from __future__ import annotations
+
+from pathlib import Path
+import tempfile
+import unittest
+from unittest.mock import patch
+
+
+class SamplerTest(unittest.TestCase):
+    def test_bass_octave_preserves_note_times(self):
+        import pretty_midi
+        from pipeline import render_preset
+
+        with tempfile.TemporaryDirectory() as directory:
+            folder = Path(directory)
+            original = pretty_midi.PrettyMIDI()
+            voice = pretty_midi.Instrument(program=0)
+            voice.notes = [
+                pretty_midi.Note(90, 60, .125, .375),
+                pretty_midi.Note(90, 64, .5, .875),
+            ]
+            original.instruments.append(voice)
+            source = folder / "source.mid"
+            original.write(str(source))
+            with patch("pipeline.render_midi", return_value=folder / "bass.wav"):
+                _, path = render_preset(source, folder, "bass", 0, 1.,
+                                        folder / "log", transpose=-12)
+            notes = pretty_midi.PrettyMIDI(str(path)).instruments[0].notes
+            self.assertEqual([n.pitch for n in notes], [48, 52])
+            for before, after in zip(voice.notes, notes):
+                self.assertAlmostEqual(before.start, after.start, places=4)
+                self.assertAlmostEqual(before.end, after.end, places=4)
+
+    def test_effects_preserve_duration_and_change_waveform(self):
+        import numpy as np
+        import soundfile as sf
+        from pipeline import apply_effect
+
+        rate = 48000
+        t = np.arange(rate, dtype=np.float32) / rate
+        source_wave = (.12 * np.sin(2 * np.pi * 220 * t)).astype("float32")
+        with tempfile.TemporaryDirectory() as directory:
+            folder = Path(directory)
+            source = folder / "source.wav"
+            sf.write(source, source_wave, rate, subtype="FLOAT")
+            for kind in ("guitar", "bass"):
+                result = apply_effect(source, folder / f"{kind}.wav", kind,
+                                      1., folder / "log")
+                output, output_rate = sf.read(result, dtype="float32",
+                                              always_2d=True)
+                self.assertEqual(output_rate, rate)
+                self.assertEqual(len(output), rate)
+                self.assertTrue(np.isfinite(output).all())
+                self.assertGreater(np.mean(np.abs(output[:, 0] - source_wave)), .001)
+
+
+if __name__ == "__main__":
+    unittest.main()