Create trap_transformer.py

trap_transformer.py

@@ -0,0 +1,180 @@
+#!/usr/bin/env python3
+"""
+Trap Style Transformer - Convert MIDI to Trap Beat
+Adds 808s, hi-hats, and trap patterns to existing MIDI
+"""
+
+import pretty_midi as pm
+import numpy as np
+from pathlib import Path
+import random
+
+class TrapTransformer:
+    def __init__(self, bpm=140):
+        self.bpm = bpm
+        self.beat_duration = 60.0 / bpm
+        
+    def extract_bass_notes(self, midi_data):
+        """Extract low notes (bass/808 candidate)"""
+        bass_notes = []
+        for track in midi_data.instruments:
+            for note in track.notes:
+                # Notes below C3 (~130Hz) are bass candidates
+                if note.pitch < 48:  # C3
+                    bass_notes.append(note)
+        return bass_notes
+    
+    def create_808_bass_pattern(self, original_bass_notes, duration_seconds):
+        """Enhance bass with longer 808 sustain"""
+        enhanced_bass = []
+        
+        for note in original_bass_notes:
+            # Make bass longer (808 characteristic)
+            new_note = pm.Note(
+                velocity=min(note.velocity + 20, 127),  # Louder
+                pitch=note.pitch,
+                start=note.start,
+                end=min(note.end + 0.3, duration_seconds)  # Extend by 300ms
+            )
+            enhanced_bass.append(new_note)
+        
+        return enhanced_bass
+    
+    def add_hi_hat_patterns(self, duration_seconds):
+        """Add trap hi-hat rolls (triplets/fast hats)"""
+        hat_track = pm.Instrument(program=0, is_drum=True)
+        
+        # Hi-hat pattern: fast 1/32 notes with occasional rolls
+        hat_start = 0.0
+        while hat_start < duration_seconds:
+            # Regular 1/8 or 1/16 hi-hats
+            hat_duration = self.beat_duration / 4  # 1/16 notes
+            
+            # Random chance for roll (1/32 or 1/64)
+            if random.random() < 0.3:  # 30% chance of roll
+                roll_count = random.choice([4, 8, 16])  # Number of rolled hats
+                for i in range(roll_count):
+                    hat = pm.Note(
+                        velocity=random.randint(80, 120),
+                        pitch=42,  # Closed hi-hat
+                        start=hat_start + (i * hat_duration / roll_count),
+                        end=hat_start + ((i + 1) * hat_duration / roll_count)
+                    )
+                    hat_track.notes.append(hat)
+                hat_start += hat_duration
+            else:
+                hat = pm.Note(
+                    velocity=random.randint(90, 115),
+                    pitch=42,  # Closed hi-hat
+                    start=hat_start,
+                    end=hat_start + hat_duration * 0.5
+                )
+                hat_track.notes.append(hat)
+                hat_start += hat_duration
+        
+        return hat_track
+    
+    def add_trap_drums(self, duration_seconds):
+        """Add 808 kick and snare/clap pattern"""
+        drum_track = pm.Instrument(program=0, is_drum=True)
+        
+        # Kick pattern: every 1st and 3rd beat (typical trap half-time)
+        kick_times = [beat * self.beat_duration * 2 for beat in range(int(duration_seconds / (self.beat_duration * 2)))]
+        
+        for kick_time in kick_times:
+            if kick_time < duration_seconds:
+                kick = pm.Note(
+                    velocity=120,  # Punchy kick
+                    pitch=36,  # Kick drum
+                    start=kick_time,
+                    end=kick_time + 0.1
+                )
+                drum_track.notes.append(kick)
+        
+        # Snare/clap on beats 2 and 4
+        snare_times = [(beat + 1) * self.beat_duration * 2 for beat in range(int(duration_seconds / (self.beat_duration * 2)))]
+        
+        for snare_time in snare_times:
+            if snare_time < duration_seconds:
+                snare = pm.Note(
+                    velocity=110,
+                    pitch=38,  # Snare
+                    start=snare_time,
+                    end=snare_time + 0.08
+                )
+                drum_track.notes.append(snare)
+        
+        return drum_track
+    
+    def apply_sidechain_compression(self, midi_data, kick_times):
+        """Simulate sidechain pumping effect"""
+        # Lower melody volume slightly before each kick
+        for instrument in midi_data.instruments:
+            if not instrument.is_drum:
+                for note in instrument.notes:
+                    # Find kicks that overlap with this note
+                    for kick_time in kick_times:
+                        if note.start <= kick_time <= note.end:
+                            # Reduce velocity slightly
+                            note.velocity = max(0, note.velocity - 10)
+        return midi_data
+    
+    def transform_to_trap(self, input_midi_path, output_midi_path=None):
+        """Main function: Transform any MIDI to Trap style"""
+        midi_data = pm.PrettyMIDI(str(input_midi_path))
+        
+        # Calculate duration
+        duration = midi_data.get_end_time()
+        
+        # Extract and enhance bass
+        bass_notes = self.extract_bass_notes(midi_data)
+        enhanced_bass = self.create_808_bass_pattern(bass_notes, duration)
+        
+        # Create new trap tracks
+        hat_track = self.add_hi_hat_patterns(duration)
+        drum_track = self.add_trap_drums(duration)
+        
+        # Replace bass track with enhanced version
+        # (or add as new track depending on preference)
+        
+        # Apply sidechain compression
+        kick_times = [n.start for n in drum_track.notes if n.pitch == 36]
+        midi_data = self.apply_sidechain_compression(midi_data, kick_times)
+        
+        # Add trap tracks to the MIDI
+        midi_data.instruments.append(hat_track)
+        midi_data.instruments.append(drum_track)
+        
+        # Update tempo to trap range
+        midi_data.tempos = [self.bpm]
+        
+        # Save if output path provided
+        if output_midi_path:
+            midi_data.write(str(output_midi_path))
+        
+        return midi_data
+
+def transcribe_and_convert(audio_path, model_size="medium", trap_output_path=None):
+    """Full pipeline: Transcribe audio → Transform to Trap → Save MIDI"""
+    from muscriptor import TranscriptionModel
+    
+    # Step 1: Transcribe with MuScriptor
+    print("🎹 Transcribing audio...")
+    model = TranscriptionModel.load_model(model_size)
+    
+    # Get MIDI bytes from original transcription
+    midi_bytes = model.transcribe_to_midi(str(audio_path))
+    
+    # Save temporary MIDI file
+    temp_midi = Path(tempfile.mktemp(suffix=".mid"))
+    temp_midi.write_bytes(midi_bytes)
+    
+    # Step 2: Transform to Trap
+    print("🔥 Converting to Trap style...")
+    transformer = TrapTransformer(bpm=140)
+    trap_midi = transformer.transform_to_trap(temp_midi, trap_output_path)
+    
+    # Cleanup
+    temp_midi.unlink()
+    
+    return trap_midi