Use solo piano optimizer for full-song melodic stem, reduce LH bass notes

Switch full-song pipeline from optimize_other to the full solo piano optimizer
for the melodic stem — produces much better rhythm, playability, and note
accuracy. Also reduces left-hand concurrent notes limit (2 normal, 3 complex)
to avoid muddy bass chords while keeping right hand at 4-5.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

api/server.py

@@ -157,35 +157,44 @@ def run_full_transcription(job_id, audio_path, job_dir):
         run_transcribe(stems["bass"], str(bass_raw))
 
         # Step 3: Optimize transcriptions
+        # Use the full solo piano optimizer for the melodic stem — it produces
+        # much better rhythm, playability, and note accuracy. Also runs chord
+        # detection and spectral analysis internally.
         job_status[job_id] = {"step": 3, "label": "Optimizing note accuracy...", "done": False}
-        from optimize_other import optimize_other
+        from optimize import optimize as optimize_piano
         from optimize_bass import optimize_bass
 
-        piano_opt = job_dir / "piano_optimized.mid"
-        optimize_other(stems["other"], str(piano_raw), str(piano_opt),
-                       mix_audio_path=str(audio_path))
+        piano_opt = job_dir / "transcription.tmp.mid"
+        optimize_piano(stems["other"], str(piano_raw), str(piano_opt))
+
+        # Solo optimizer writes chords to {stem}_chords.json next to the output
+        auto_chords = job_dir / "transcription.tmp_chords.json"
+        chords_path = job_dir / "transcription_chords.json"
+        if auto_chords.exists():
+            auto_chords.rename(chords_path)
+
+        # Rename to final path
+        piano_final = job_dir / "piano_optimized.mid"
+        piano_opt.rename(piano_final)
+        piano_opt = piano_final
 
         bass_opt = job_dir / "bass_optimized.mid"
         optimize_bass(stems["bass"], str(bass_raw), str(bass_opt))
 
-        # Step 4: Chord detection on "other" stem
-        job_status[job_id] = {"step": 4, "label": "Detecting chords...", "done": False}
-        from chords import detect_chords
-        chords_path = job_dir / "transcription_chords.json"
-        detect_chords(str(piano_opt), str(chords_path))
+        # Load chord data
         chord_data = None
         if chords_path.exists():
             with open(chords_path) as f:
                 chord_data = json.load(f)
 
-        # Step 5: Transcribe drums
-        job_status[job_id] = {"step": 5, "label": "Transcribing drums...", "done": False}
+        # Step 4: Transcribe drums
+        job_status[job_id] = {"step": 4, "label": "Transcribing drums...", "done": False}
         from drums import transcribe_drums
         drum_tab_path = job_dir / "drum_tab.json"
         transcribe_drums(stems["drums"], str(drum_tab_path))
 
-        # Step 6: Generate guitar and bass tabs
-        job_status[job_id] = {"step": 6, "label": "Generating tabs...", "done": False}
+        # Step 5: Generate guitar and bass tabs
+        job_status[job_id] = {"step": 5, "label": "Generating tabs...", "done": False}
         from tabs import midi_to_guitar_tab, midi_to_bass_tab
 
         guitar_tab = midi_to_guitar_tab(str(piano_opt), str(chords_path))
@@ -198,8 +207,8 @@ def run_full_transcription(job_id, audio_path, job_dir):
         with open(bass_tab_path, 'w') as f:
             json.dump(bass_tab, f)
 
-        # Step 7: Merge melodic + bass into final MIDI
-        job_status[job_id] = {"step": 7, "label": "Assembling final result...", "done": False}
+        # Step 6: Merge melodic + bass into final MIDI
+        job_status[job_id] = {"step": 6, "label": "Assembling final result...", "done": False}
         merged_path = job_dir / "transcription.mid"
         merge_stems(str(piano_opt), str(bass_opt), str(merged_path))
 
@@ -211,7 +220,7 @@ def run_full_transcription(job_id, audio_path, job_dir):
             f.unlink(missing_ok=True)
 
         job_status[job_id] = {
-            "step": 8, "label": "Done!", "done": True,
+            "step": 7, "label": "Done!", "done": True,
             "result": {
                 "job_id": job_id,
                 "midi_url": f"/api/jobs/{job_id}/midi",

transcriber/optimize.py

@@ -612,13 +612,19 @@ def apply_pitch_ceiling(midi_data, max_pitch=96):
     return midi_out, removed
 
 
-def limit_concurrent_notes(midi_data, max_per_hand=4, hand_split=60):
+def limit_concurrent_notes(midi_data, max_per_hand=4, hand_split=60, max_left_hand=None):
     """Limit notes per chord to max_per_hand per hand.
 
     Groups notes by onset time (within 30ms) and splits into left/right hand.
     Removes excess notes — protects melody (highest RH pitch) and bass
     (lowest LH pitch), then removes lowest velocity.
+
+    Args:
+        max_per_hand: Max notes for right hand (default 4)
+        max_left_hand: Max notes for left hand (defaults to max_per_hand)
     """
+    if max_left_hand is None:
+        max_left_hand = max_per_hand
     midi_out = copy.deepcopy(midi_data)
     removed = 0
 
@@ -643,7 +649,8 @@ def limit_concurrent_notes(midi_data, max_per_hand=4, hand_split=60):
             right = [idx for idx in chord_indices if notes[idx].pitch >= hand_split]
 
             for is_right, hand_indices in [(True, right), (False, left)]:
-                if len(hand_indices) <= max_per_hand:
+                limit = max_per_hand if is_right else max_left_hand
+                if len(hand_indices) <= limit:
                     continue
 
                 # Protect melody (highest RH) or bass (lowest LH)
@@ -656,7 +663,7 @@ def limit_concurrent_notes(midi_data, max_per_hand=4, hand_split=60):
                 scored = [(notes[idx].velocity, idx) for idx in trimmable]
                 scored.sort()
 
-                excess = len(hand_indices) - max_per_hand
+                excess = len(hand_indices) - limit
                 for _, idx in scored[:excess]:
                     to_remove.add(idx)
 
@@ -666,14 +673,20 @@ def limit_concurrent_notes(midi_data, max_per_hand=4, hand_split=60):
     return midi_out, removed
 
 
-def limit_total_concurrent(midi_data, max_per_hand=4, hand_split=60):
+def limit_total_concurrent(midi_data, max_per_hand=4, hand_split=60, max_left_hand=None):
     """Limit concurrent sounding notes to max_per_hand per hand.
 
     Splits notes into left hand (< hand_split) and right hand (>= hand_split).
-    At each note onset, count concurrent notes in that hand. If > max_per_hand,
+    At each note onset, count concurrent notes in that hand. If > limit,
     trim sustained notes — but protect the melody (highest RH pitch) and bass
     (lowest LH pitch). Among the rest, trim lowest velocity first.
+
+    Args:
+        max_per_hand: Max concurrent notes for right hand (default 4)
+        max_left_hand: Max concurrent notes for left hand (defaults to max_per_hand)
     """
+    if max_left_hand is None:
+        max_left_hand = max_per_hand
     midi_out = copy.deepcopy(midi_data)
     trimmed = 0
 
@@ -684,6 +697,7 @@ def limit_total_concurrent(midi_data, max_per_hand=4, hand_split=60):
 
         for i, note in enumerate(notes):
             is_right = note.pitch >= hand_split
+            limit = max_per_hand if is_right else max_left_hand
 
             # Find all notes in the same hand currently sounding
             sounding = []
@@ -693,8 +707,8 @@ def limit_total_concurrent(midi_data, max_per_hand=4, hand_split=60):
                     if same_hand:
                         sounding.append(j)
 
-            if len(sounding) + 1 > max_per_hand:
-                excess = len(sounding) + 1 - max_per_hand
+            if len(sounding) + 1 > limit:
+                excess = len(sounding) + 1 - limit
                 # All indices including the current note
                 all_indices = sounding + [i]
 
@@ -1458,14 +1472,20 @@ def optimize(original_audio_path, midi_path, output_path=None):
 
     # Step 8f: Playability filter — limit per-onset chord size
     # Complex pieces get 5 notes/hand to preserve dense voicings
-    max_hand = 5 if complexity == 'complex' else 4
-    print(f"\nStep 8f: Playability filter (max {max_hand} notes per hand per chord)...")
-    midi_data, playability_removed = limit_concurrent_notes(midi_data, max_per_hand=max_hand)
+    # Left hand (bass) gets a tighter limit to avoid muddy chords
+    max_rh = 5 if complexity == 'complex' else 4
+    max_lh = 3 if complexity == 'complex' else 2
+    print(f"\nStep 8f: Playability filter (RH max {max_rh}, LH max {max_lh} per chord)...")
+    midi_data, playability_removed = limit_concurrent_notes(
+        midi_data, max_per_hand=max_rh, max_left_hand=max_lh
+    )
     print(f"  Removed {playability_removed} excess chord notes")
 
     # Step 8g: Limit total concurrent sounding notes
-    print(f"\nStep 8g: Concurrent sounding limit (max {max_hand} per hand)...")
-    midi_data, sustain_trimmed = limit_total_concurrent(midi_data, max_per_hand=max_hand)
+    print(f"\nStep 8g: Concurrent sounding limit (RH max {max_rh}, LH max {max_lh})...")
+    midi_data, sustain_trimmed = limit_total_concurrent(
+        midi_data, max_per_hand=max_rh, max_left_hand=max_lh
+    )
     print(f"  Trimmed {sustain_trimmed} sustained notes to reduce pileup")
 
     # Final metrics

transcriber/optimize_other.py

@@ -158,14 +158,19 @@ def optimize_other(original_audio_path, midi_path, output_path=None, mix_audio_p
     print(f"  Trimmed {notes_trimmed}, enforced min duration on {durations_enforced}")
 
     # Step 8b: Playability filter — limit per-onset chord size
-    max_hand = 5 if complexity == 'complex' else 4
-    print(f"\nStep 8b: Playability filter (max {max_hand} notes per hand per chord)...")
-    midi_data, playability_removed = limit_concurrent_notes(midi_data, max_per_hand=max_hand)
+    max_rh = 5 if complexity == 'complex' else 4
+    max_lh = 3 if complexity == 'complex' else 2
+    print(f"\nStep 8b: Playability filter (RH max {max_rh}, LH max {max_lh} per chord)...")
+    midi_data, playability_removed = limit_concurrent_notes(
+        midi_data, max_per_hand=max_rh, max_left_hand=max_lh
+    )
     print(f"  Removed {playability_removed} excess chord notes")
 
     # Step 8c: Limit total concurrent sounding notes
-    print(f"\nStep 8c: Concurrent sounding limit (max {max_hand} per hand)...")
-    midi_data, sustain_trimmed = limit_total_concurrent(midi_data, max_per_hand=max_hand)
+    print(f"\nStep 8c: Concurrent sounding limit (RH max {max_rh}, LH max {max_lh})...")
+    midi_data, sustain_trimmed = limit_total_concurrent(
+        midi_data, max_per_hand=max_rh, max_left_hand=max_lh
+    )
     print(f"  Trimmed {sustain_trimmed} sustained notes to reduce pileup")
 
     # Shift to t=0 if there was leading silence