fluidstudio

clips.py (6665B)

---

 """FluidStudio clip generator — per-frame CSV for video sync.
 
 Usage:
     python -m gondry.clips projects/minipops_demo
     python -m gondry.clips projects/minipops_demo --fps 30
 
 Output: one CSV per bar in projects/<song>/clip/
 Each CSV: 1 row = 1 frame, columns = instruments, ";" delimiter, multiple notes "," separated.
 """
 
 import csv
 import sys
 from pathlib import Path
 
 from .parser import parse_header, parse_gondry, VoiceHeader, GondryEvent
 from .fps import bpm_to_fps
 
 
 def events_to_frames(events: list[GondryEvent], fps: int, bpm: float,
                      total_frames: int) -> list[list[int]]:
     """Convert events to per-frame note lists.
 
     Returns: list of length total_frames, each entry is list of MIDI notes active at that frame.
     """
     frames = [[] for _ in range(total_frames)]
     sec_per_frame = 1.0 / fps
 
     for ev in events:
         if not ev.midi_notes:
             continue
 
         # Event timing in seconds
         sec_per_beat = 60.0 / bpm
         start_sec = ev.beat_position * sec_per_beat
         end_sec = start_sec + (ev.duration_beats * sec_per_beat)
 
         # Convert to frame indices
         start_frame = int(start_sec / sec_per_frame)
         end_frame = int(end_sec / sec_per_frame)
 
         # Clamp
         start_frame = max(0, min(start_frame, total_frames - 1))
         end_frame = max(0, min(end_frame, total_frames))
 
         for frame_idx in range(start_frame, end_frame):
             frames[frame_idx].extend(ev.midi_notes)
 
     return frames
 
 
 def generate_clips(project_dir: str | Path, fps: int | None = None):
     """Generate per-frame CSVs for video sync.
 
     Each bar gets its own CSV with all instruments as columns.
     If fps not specified, auto-calculated from BPM for clean frame sync.
     """
     project = Path(project_dir)
     partition_dir = project / "partition"
     clip_dir = project / "clip"
 
     clip_dir.mkdir(exist_ok=True)
 
     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
 
     # Auto-calculate fps if not specified
     if fps is None:
         fps_info = bpm_to_fps(bpm)
         fps = int(fps_info["fps"])
         print(f"Auto-calculated fps: {fps} (multiplier: {fps_info['multiplier']}x)")
     else:
         # Verify clean sync
         fpm = fps * 60
         fpb = fpm / bpm
         if fpb != int(fpb):
             print(f"WARNING: {fps}fps at {bpm}BPM = {fpb:.2f} frames/beat (not integer)")
             print(f"  Consider: {int(bpm/5)}fps (1x), {int(bpm/5*2)}fps (2x), or {int(bpm/5*3)}fps (3x)")
 
     # Find all .flsp files
     gondry_files = sorted(partition_dir.glob("*.flsp"))
     if not gondry_files:
         raise FileNotFoundError(f"No .flsp files in {partition_dir}")
 
     # Parse all voices and collect events
     voices = {}  # name -> list[GondryEvent]
     for gondry_path in gondry_files:
         voice_name = gondry_path.stem
 
         # 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:
             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:
             print(f"  SKIP {voice_name} — no matching channel in header")
             continue
 
         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)
         voices[voice_name] = events
 
     if not voices:
         print("No voices found")
         return
 
     # Determine total duration in beats (max across all voices)
     max_beat = 0.0
     for events in voices.values():
         if events:
             max_beat = max(max_beat, max(e.beat_position + e.duration_beats for e in events))
 
     # Calculate frames
     total_beats = max_beat
     frames_per_beat = fps * 60.0 / bpm
     total_frames = int(total_beats * frames_per_beat)
 
     print(f"Project: {project}")
     print(f"BPM: {bpm} | FPS: {fps} | Frames/beat: {frames_per_beat:.2f}")
     print(f"Total: {total_beats:.1f} beats = {total_frames} frames")
     print(f"Voices: {list(voices.keys())}")
     print()
 
     # Convert each voice to per-frame data
     voice_frames = {}
     for name, events in voices.items():
         voice_frames[name] = events_to_frames(events, fps, bpm, total_frames)
 
     # Write one CSV per bar
     beats_per_bar = 4  # assume 4/4 time
     frames_per_bar = int(beats_per_bar * frames_per_beat)
     num_bars = int(total_beats / beats_per_bar)
 
     for bar_idx in range(num_bars):
         start_frame = bar_idx * frames_per_bar
         end_frame = min(start_frame + frames_per_bar, total_frames)
 
         # Determine which voices have activity in this bar
         active_voices = []
         for name in voices:
             bar_frames = voice_frames[name][start_frame:end_frame]
             if any(bar_frames):
                 active_voices.append(name)
 
         if not active_voices:
             continue
 
         clip_path = clip_dir / f"bar_{bar_idx + 1:03d}.csv"
 
         with open(clip_path, 'w', newline='') as f:
             writer = csv.writer(f, delimiter=';')
 
             # Header row
             writer.writerow(['frame'] + active_voices)
 
             # Data rows
             for frame_offset in range(frames_per_bar):
                 frame_idx = start_frame + frame_offset
                 if frame_idx >= total_frames:
                     break
 
                 row = [frame_offset]
                 for name in active_voices:
                     notes = voice_frames[name][frame_idx]
                     row.append(','.join(str(n) for n in notes))
 
                 writer.writerow(row)
 
         print(f"  {clip_path.name}: {len(active_voices)} voices, {end_frame - start_frame} frames")
 
     print(f"\n  {num_bars} clips written to {clip_dir}")
 
 
 if __name__ == "__main__":
     if len(sys.argv) < 2:
         print("Usage: python -m gondry.clips <project_dir> [--fps N]")
         sys.exit(1)
 
     project_dir = sys.argv[1]
     fps = None
 
     if '--fps' in sys.argv:
         idx = sys.argv.index('--fps')
         fps = int(sys.argv[idx + 1])
 
     generate_clips(project_dir, fps)