fluidstudio

compiler.py (5769B)

---

 """FluidStudio project compiler.
 
 Usage:
     from gondry.compiler import compile_project
     compile_project("projects/marimba_demo")
 
 Or CLI:
     python -m gondry.compiler projects/marimba_demo
 """
 
 import sys
 import subprocess
 import time
 from datetime import datetime
 from pathlib import Path
 
 from .parser import parse_header, parse_gondry, VoiceHeader
 from .midi_gen import render_midi, render_wav
 
 
 def compile_project(project_dir: str | Path, sf2_root: str | Path = "asset/soundfonts"):
     """Compile a gondry project: partition -> stems -> mix."""
     project = Path(project_dir)
     partition_dir = project / "partition"
     stems_dir = project / "stems"
     mix_dir = project / "mix"
     midi_dir = project / "midi"
 
     stems_dir.mkdir(exist_ok=True)
     mix_dir.mkdir(exist_ok=True)
     midi_dir.mkdir(exist_ok=True)
 
     log_lines = []
 
     def log(msg):
         print(msg)
         log_lines.append(msg)
 
     header_path = partition_dir / "header.json"
     if not header_path.exists():
         raise FileNotFoundError(f"No header.json in {partition_dir}")
 
     header = parse_header(header_path)
     bpm = header.bpm
     sec_per_beat = 60.0 / bpm
     sf2_root = Path(sf2_root)
 
     log(f"=== FluidStudio Compile === {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
     log(f"Project: {project}")
     log(f"BPM: {bpm} ({sec_per_beat:.4f}s/beat)")
     log(f"Octave: {header.octave} | Mode: {header.mode}")
     log(f"Channels: {[ch['name'] for ch in header.channels]}")
     log("")
 
     # Find all .flsp files
     gondry_files = sorted(partition_dir.glob("*.flsp"))
     if not gondry_files:
         raise FileNotFoundError(f"No .flsp files in {partition_dir}")
 
     stem_paths = []
     max_beat_total = 0.0
 
     for gondry_path in gondry_files:
         voice_name = gondry_path.stem  # e.g. "melody"
 
         # Match voice to channel config
         channel_config = None
         for ch in header.channels:
             if ch["name"] == voice_name:
                 channel_config = ch
                 break
 
         if channel_config is None:
             # Try partial match
             for ch in header.channels:
                 if voice_name.startswith(ch["name"]) or ch["name"].startswith(voice_name):
                     channel_config = ch
                     break
 
         if channel_config is None:
             log(f"  SKIP {voice_name} — no matching channel in header")
             continue
 
         # Parse
         voice_header = VoiceHeader(
             project=header.project,
             bpm=header.bpm,
             octave=header.octave,
             mode=header.mode,
             channels=header.channels,
             channel_name=voice_name,
             channel_config=channel_config,
         )
 
         events = parse_gondry(gondry_path, voice_header)
         if not events:
             log(f"  SKIP {voice_name} — no events")
             continue
 
         # Log all events
         log(f"  --- {voice_name} ---")
         log(f"  sf2: {channel_config['sf2']}")
         log(f"  octave: {channel_config.get('octave', header.octave)}")
         log(f"  events ({len(events)}):")
         for ev in events:
             if ev.midi_notes:
                 log(f"    beat={ev.beat_position:.3f}  dur={ev.duration_beats:.3f}  notes={ev.midi_notes}  vel={ev.velocity}")
             else:
                 log(f"    beat={ev.beat_position:.3f}  dur={ev.duration_beats:.3f}  rest")
 
         # Calculate exact duration from last note-off
         max_beat = max(e.beat_position + e.duration_beats for e in events)
         max_beat_total = max(max_beat_total, max_beat)
         duration = max_beat * sec_per_beat
 
         # Render MIDI
         midi_path = midi_dir / f"{voice_name}.mid"
         render_midi(events, voice_header, midi_path)
         log(f"  -> {midi_path} ({duration:.4f}s)")
 
         # Render WAV (trimmed to exact beat duration)
         sf2_path = sf2_root / channel_config["sf2"]
         stem_path = stems_dir / f"{voice_name}.wav"
         if not sf2_path.exists():
             log(f"  WARN: SF2 not found at {sf2_path}")
 
         render_wav(midi_path, sf2_path, stem_path, duration=duration)
 
         # Verify stem has audio
         result = subprocess.run(
             ["ffmpeg", "-i", str(stem_path), "-af", "volumedetect", "-f", "null", "-"],
             capture_output=True, text=True
         )
         max_vol = "?"
         for line in result.stderr.splitlines():
             if "max_volume" in line:
                 max_vol = line.split(":")[-1].strip()
         log(f"  -> {stem_path} ({duration:.4f}s, peak={max_vol})")
         log("")
 
         stem_paths.append(stem_path)
 
     # Mix all stems
     if stem_paths:
         total_duration = max_beat_total * sec_per_beat
         inputs = []
         filter_parts = []
         for i, sp in enumerate(stem_paths):
             inputs += ["-i", str(sp)]
             filter_parts.append(f"[{i}:a]")
 
         mix_path = mix_dir / "mix.wav"
         filter_str = "".join(filter_parts) + f"amix=inputs={len(stem_paths)}:duration=first[mix]"
         cmd = ["ffmpeg", "-y"] + inputs + [
             "-filter_complex", filter_str,
             "-map", "[mix]",
             str(mix_path),
         ]
         r = subprocess.run(cmd, capture_output=True)
         if r.returncode != 0:
             log(f"  MIX ERROR: ffmpeg failed")
             log(f"  stderr: {r.stderr.decode()[-500:]}")
         else:
             log(f"  mix: {total_duration:.4f}s -> {mix_path}")
 
     # Write log file
     log_path = project / "compile.log"
     log_path.write_text("\n".join(log_lines) + "\n")
     log(f"  log -> {log_path}")
 
     return project
 
 
 if __name__ == "__main__":
     if len(sys.argv) < 2:
         print("Usage: python -m gondry.compiler <project_dir>")
         sys.exit(1)
     compile_project(sys.argv[1])