Automatically fit sampled bass register with GM fallback

README.md

@@ -20,9 +20,11 @@ Upload a short hum or record one in the browser. One request generates seven
 source-timed comparisons. SheetSage2 extracts notes and beats; FluidSynth
 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 two octaves into the actual sample range, with note starts and lengths
-preserved. A continuous-F0 synth
+guitar and fingered bass in clean and processed versions. The bass octave is
+chosen automatically to fit all notes into the pinned sample's measured MIDI
+range 26..45. If no single octave fits the whole phrase, the route uses the
+full GM Fingered Bass bank instead of dropping notes. Note starts and lengths
+are preserved. A continuous-F0 synth
 follows voice pitch and amplitude. The sampler uses full-size FreePats electric
 guitar and fingered bass SoundFonts, with FFmpeg compression, filtering,
 oversampled soft clipping, and a short guitar room echo in processed versions.

app.py

@@ -72,7 +72,7 @@ with gr.Blocks(title="Hum · напев в инструмент", css=CSS, theme
             go = gr.Button("Создать все варианты", variant="primary", size="lg")
             gr.HTML("""<div class='note'><b>Текущая цель:</b> один инструмент и
             приблизительно исходное время. Электрогитара и бас используют
-            записанные сэмплы; бас звучит на две октавы ниже. Обработанные версии
+            записанные сэмплы; регистр баса выбирается автоматически. Обработанные версии
             добавляют усиление и лёгкий эффект, но не новые ноты. Барабаны
             привязаны к долям SheetSage2. YuE2 может изменить
             длительность, добавить человеческие звуки или другие инструменты;

pipeline.py

@@ -20,9 +20,9 @@ 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"))
-# FreePats Finger Bass is silent over much of the voice-minus-one-octave
-# range; two octaves put the seen 54..68 melody into its audible 30..44 range.
-BASS_TRANSPOSE = -24
+# A pinned MIDI sweep found audible notes 26..45 in Finger Bass YR. Route
+# whole phrases by octaves so no individual note silently exceeds that range.
+BASS_SAMPLE_LOW, BASS_SAMPLE_HIGH = 26, 45
 SAMPLER_VARIANTS = (
     "instrument", "instrument_drums", "contour",
     "guitar_clean", "guitar_amp", "bass_clean", "bass_amp",
@@ -134,6 +134,28 @@ def render_instrument(midi_path: Path, folder: Path, instrument: str,
                          duration, log)
 
 
+def choose_bass_route(midi_path: Path) -> tuple[int, Path, int, str]:
+    """Choose one octave for the whole phrase; use GM bass if samples cannot fit."""
+    import pretty_midi
+
+    pitches = [note.pitch for track in pretty_midi.PrettyMIDI(str(midi_path)).instruments
+               for note in track.notes]
+    if not pitches:
+        raise ValueError("В напеве нет нот для баса")
+    low, high = min(pitches), max(pitches)
+    shifts = range(-108, 61, 12)
+    sampled = [shift for shift in shifts
+               if BASS_SAMPLE_LOW <= low + shift
+               and high + shift <= BASS_SAMPLE_HIGH]
+    if sampled:
+        target = (BASS_SAMPLE_LOW + BASS_SAMPLE_HIGH) / 2
+        shift = min(sampled, key=lambda value: abs((low + high) / 2 + value - target))
+        return shift, SOUNDFONT_DIR / "finger-bass.sf2", 0, "FreePats Finger Bass YR"
+    available = [shift for shift in shifts if 0 <= low + shift and high + shift <= 127]
+    shift = min(available, key=lambda value: abs((low + high) / 2 + value - 40))
+    return shift, GM_SOUNDFONT, 33, "FluidR3 Fingered Bass fallback"
+
+
 def apply_effect(source: Path, output: Path, kind: str, duration: float,
                  log: Path) -> Path:
     # Both chains use the same sampled notes and retain the source duration.
@@ -336,6 +358,8 @@ def generate_all(source: str, instrument: str, styles: dict[str, str], seed: int
     yue_timing = {}
     drum_count = 0
     drums_midi = None
+    bass_shift = None
+    bass_source = None
 
     def deliver(name: str, raw: Path, *, normalize: bool = True,
                 max_gain: float = 4.) -> None:
@@ -351,7 +375,8 @@ def generate_all(source: str, instrument: str, styles: dict[str, str], seed: int
                     "yue_requested": include_yue, "yue_timing": dict(yue_timing),
                     "errors": dict(errors), "complete": complete,
                     "source_timing_preserved": list(SAMPLER_VARIANTS),
-                    "bass_transpose_semitones": BASS_TRANSPOSE,
+                    "bass_transpose_semitones": bass_shift,
+                    "bass_source": bass_source,
                     "yue_vocal_absence_guaranteed": False,
                     "elapsed_seconds": round(time.monotonic() - began, 2)}
         return (*(outputs[name] for name in VARIANTS), str(melody_midi),
@@ -364,6 +389,7 @@ def generate_all(source: str, instrument: str, styles: dict[str, str], seed: int
     if progress:
         progress(.12, desc="SheetSage2 извлекает мелодию и сетку долей")
     midi, melody_abc, full_abc, beat_lab = transcribe(pcm24, folder, log)
+    bass_shift, bass_font, bass_program, bass_source = choose_bass_route(midi)
     if progress:
         progress(.30, desc="Синтезирую инструмент и барабаны")
     melody_raw, melody_midi = render_instrument(midi, folder, instrument, duration, log)
@@ -388,13 +414,13 @@ def generate_all(source: str, instrument: str, styles: dict[str, str], seed: int
     yield snapshot()
     if progress:
         progress(.48, desc="Сэмплирую электрогитару и бас")
-    for name, font_name, transpose, effect in (
-        ("guitar_clean", "electric-clean.sf2", 0, "guitar"),
-        ("bass_clean", "finger-bass.sf2", BASS_TRANSPOSE, "bass"),
+    for name, font, program, transpose, effect in (
+        ("guitar_clean", SOUNDFONT_DIR / "electric-clean.sf2", 0, 0, "guitar"),
+        ("bass_clean", bass_font, bass_program, bass_shift, "bass"),
     ):
         try:
-            raw, _ = render_preset(midi, folder, name, 0, duration, log,
-                                   soundfont=SOUNDFONT_DIR / font_name,
+            raw, _ = render_preset(midi, folder, name, program, duration, log,
+                                   soundfont=font,
                                    transpose=transpose)
             deliver(name, raw, max_gain=20.)
             deliver(name.replace("clean", "amp"),

test_sampler.py

@@ -14,7 +14,7 @@ class SamplerTest(unittest.TestCase):
         import numpy as np
         import pretty_midi
         import soundfile as sf
-        from pipeline import BASS_TRANSPOSE, SOUNDFONT_DIR, render_preset
+        from pipeline import SOUNDFONT_DIR, choose_bass_route, render_preset
 
         font = SOUNDFONT_DIR / "finger-bass.sf2"
         if not font.is_file():
@@ -30,8 +30,11 @@ class SamplerTest(unittest.TestCase):
             score.instruments.append(voice)
             midi = folder / "notes.mid"
             score.write(str(midi))
+            shift, chosen_font, program, source = choose_bass_route(midi)
+            self.assertEqual((shift, chosen_font, program), (-24, font, 0))
+            self.assertEqual(source, "FreePats Finger Bass YR")
             wav, _ = render_preset(midi, folder, "bass", 0, 1., folder / "log",
-                                   soundfont=font, transpose=BASS_TRANSPOSE)
+                                   soundfont=chosen_font, transpose=shift)
             audio, rate = sf.read(wav, dtype="float32", always_2d=True)
             for start in (.12, .62):
                 span = audio[round(start * rate):round((start + .1) * rate)]
@@ -70,6 +73,7 @@ class SamplerTest(unittest.TestCase):
 
             with (patch("pipeline.decode", return_value=(wave, wave, 1.)),
                   patch("pipeline.transcribe", return_value=(midi, abc, abc, beat)),
+                  patch("pipeline.choose_bass_route", return_value=(-24, folder / "bass.sf2", 0, "test")),
                   patch("pipeline.render_instrument", return_value=(wave, midi)),
                   patch("pipeline.render_drums", return_value=(wave, midi, 3)),
                   patch("pipeline.pair_with_drums", return_value=(wave, wave)),
@@ -83,7 +87,7 @@ class SamplerTest(unittest.TestCase):
 
     def test_bass_register_preserves_note_times(self):
         import pretty_midi
-        from pipeline import BASS_TRANSPOSE, render_preset
+        from pipeline import choose_bass_route, render_preset
 
         with tempfile.TemporaryDirectory() as directory:
             folder = Path(directory)
@@ -96,15 +100,37 @@ class SamplerTest(unittest.TestCase):
             original.instruments.append(voice)
             source = folder / "source.mid"
             original.write(str(source))
+            shift, _, _, _ = choose_bass_route(source)
+            self.assertEqual(shift, -24)
             with patch("pipeline.render_midi", return_value=folder / "bass.wav"):
                 _, path = render_preset(source, folder, "bass", 0, 1.,
-                                        folder / "log", transpose=BASS_TRANSPOSE)
+                                        folder / "log", transpose=shift)
             notes = pretty_midi.PrettyMIDI(str(path)).instruments[0].notes
             self.assertEqual([n.pitch for n in notes], [36, 40])
             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_bass_route_automatically_shifts_or_uses_full_bank(self):
+        import pretty_midi
+        from pipeline import choose_bass_route, GM_SOUNDFONT
+
+        with tempfile.TemporaryDirectory() as directory:
+            midi = Path(directory) / "notes.mid"
+            for pitches, expected in (((42, 54), (-12, "FreePats Finger Bass YR")),
+                                      ((50, 80), (-24, "FluidR3 Fingered Bass fallback"))):
+                score = pretty_midi.PrettyMIDI()
+                track = pretty_midi.Instrument(0)
+                track.notes = [pretty_midi.Note(90, pitch, index * .3,
+                                                index * .3 + .2)
+                               for index, pitch in enumerate(pitches)]
+                score.instruments.append(track)
+                score.write(str(midi))
+                shift, font, program, source = choose_bass_route(midi)
+                self.assertEqual((shift, source), expected)
+                if source.endswith("fallback"):
+                    self.assertEqual((font, program), (GM_SOUNDFONT, 33))
+
     def test_effects_preserve_duration_and_change_waveform(self):
         import numpy as np
         import soundfile as sf