Upload 4 files

app.py

@@ -0,0 +1,98 @@
+import streamlit as st
+import base64
+import os
+import time
+from moonarch import MusicToChordsConverter
+from mido import MidiFile, MidiTrack, Message
+import pretty_midi
+
+# Set the home directory path for moonarch
+home_directory = os.getcwd()
+
+# Your app content
+st.title("Moonarch Chords Analyzer: Chords")
+st.write("Extract chords from any given music.")
+
+# Set the title of the app
+st.title("Your Music, Perfected by AI")
+
+# Display the header text
+st.header("Experience the Future of Sound")
+st.write("""
+Everything you need to create and release your music, including samples, plugins, unlimited distribution, and the world's best AI mastering engine.
+""")
+
+# Display the Start button
+if st.button("Start using Monaarch"):
+    st.write("Welcome to Monaarch! Let's start creating amazing music.")
+
+# Add upload option
+audio_file = st.file_uploader("Upload a song", type=["mp3", "wav"])
+
+if audio_file is not None:
+    st.write("File uploaded successfully.")
+    
+    # Placeholder for progress bar
+    progress_bar = st.progress(0)
+    
+    # Simulate file processing
+    for percent_complete in range(100):
+        time.sleep(0.01)
+        progress_bar.progress(percent_complete + 1)
+    
+    st.write("File processing complete.")
+
+    if st.button('Find Chords'):
+        with st.spinner('Extracting chords and generating MIDI...'):
+            # Convert the uploaded file to a file path
+            file_name_without_ext = os.path.splitext(audio_file.name)[0]
+            audio_file_path = os.path.join('/tmp', audio_file.name)
+            with open(audio_file_path, 'wb') as f:
+                f.write(audio_file.getbuffer())
+
+            # Convert music to chords and save as MIDI
+            output_midi_file = f'{file_name_without_ext}.mid'
+            converter = MusicToChordsConverter(audio_file_path)
+            converter.recognize_chords()
+            converter.generate_midi()
+
+            # Updated save_midi method to handle PrettyMIDI object and proper message formatting
+            def save_midi(self, output_file):
+                midi = MidiFile()
+                track = MidiTrack()
+                midi.tracks.append(track)
+
+                # Ensure self.midi_chords is a PrettyMIDI object
+                if not isinstance(self.midi_chords, pretty_midi.PrettyMIDI):
+                    raise TypeError(f"self.midi_chords is not a PrettyMIDI object: {type(self.midi_chords)}")
+
+                # Iterate over instruments and notes in the PrettyMIDI object
+                for instrument in self.midi_chords.instruments:
+                    for note in instrument.notes:
+                        # Ensure note, velocity, and time are within valid MIDI data byte range
+                        midi_note = min(max(note.pitch, 0), 127)
+                        velocity = min(max(note.velocity, 0), 127)
+                        start_time = max(int(note.start * 1000), 0)  # Convert to milliseconds
+                        end_time = max(int(note.end * 1000), 0)  # Convert to milliseconds
+                        duration = end_time - start_time  # Calculate duration
+
+                        # Add note_on and note_off messages with correct formatting
+                        track.append(Message('note_on', note=midi_note, velocity=velocity, time=start_time))
+                        track.append(Message('note_off', note=midi_note, velocity=0, time=duration))
+
+                midi.save(output_file)
+
+            # Assign the updated method to the converter instance
+            converter.save_midi = save_midi.__get__(converter, MusicToChordsConverter)
+            converter.save_midi(output_midi_file)
+
+            st.success('Chords extraction and MIDI generation complete!')
+
+            # Provide a button to download the MIDI file
+            with open(output_midi_file, 'rb') as f:
+                st.download_button(
+                    label="Download MIDI file",
+                    data=f,
+                    file_name=output_midi_file,
+                    mime='audio/midi'
+                )

chords.lab

@@ -0,0 +1,4 @@
+0.0	1.6718367346938776	D:maj
+1.6718367346938776	3.4829931972789114	Bb:maj
+3.4829931972789114	5.340589569160998	C:maj
+5.340589569160998	8.17342403628118	D:maj

moonarch.py

@@ -0,0 +1,74 @@
+import autochord
+import pretty_midi
+import librosa
+class MusicToChordsConverter:
+    def __init__(self, audio_file):
+        self.audio_file = audio_file
+        self.chords = None
+        self.midi_chords = pretty_midi.PrettyMIDI()
+        self.instrument_chords = pretty_midi.Instrument(program=0)  # Acoustic Grand Piano
+
+    def recognize_chords(self):
+        """
+        Perform chord recognition on the audio file.
+        """
+        self.chords = autochord.recognize(self.audio_file, lab_fn='chords.lab')
+
+    def chord_to_midi_notes(self, chord_name):
+        """
+        Map chord names to MIDI notes.
+
+        Args:
+        chord_name (str): The chord name to be mapped.
+
+        Returns:
+        list: A list of MIDI notes corresponding to the chord.
+        """
+        note_mapping = {
+            'C:maj': ['C4', 'E4', 'G4'],
+            'C:min': ['C4', 'E-4', 'G4'],
+            'D:maj': ['D4', 'F#4', 'A4'],
+            'D:min': ['D4', 'F4', 'A4'],
+            'E:maj': ['E4', 'G#4', 'B4'],
+            'E:min': ['E4', 'G4', 'B4'],
+            'F:maj': ['F4', 'A4', 'C5'],
+            'F:min': ['F4', 'A-4', 'C5'],
+            'G:maj': ['G4', 'B4', 'D5'],
+            'G:min': ['G4', 'B-4', 'D5'],
+            'A:maj': ['A4', 'C#5', 'E5'],
+            'A:min': ['A4', 'C5', 'E5'],
+            'B:maj': ['B4', 'D#5', 'F#5'],
+            'B:min': ['B4', 'D5', 'F#5']
+        }
+        return note_mapping.get(chord_name, [])
+
+    def generate_midi(self):
+        """
+        Generate a MIDI file from the recognized chords.
+        """
+        for chord in self.chords:
+            start_time = chord[0]
+            end_time = chord[1]
+            chord_name = chord[2]
+            if chord_name != 'N':  # Ignore no-chord
+                chord_notes = self.chord_to_midi_notes(chord_name)
+                for note_name in chord_notes:
+                    midi_note = pretty_midi.Note(
+                        velocity=100,
+                        pitch=librosa.note_to_midi(note_name),
+                        start=start_time,
+                        end=end_time
+                    )
+                    self.instrument_chords.notes.append(midi_note)
+
+        self.midi_chords.instruments.append(self.instrument_chords)
+
+    def save_midi(self, output_file):
+        """
+        Save the generated MIDI file to disk.
+
+        Args:
+        output_file (str): The path where the MIDI file should be saved.
+        """
+        self.midi_chords.write(output_file)
+        print(f"Saved chords to {output_file}")

requirements.txt

@@ -0,0 +1,5 @@
+streamlit
+autochord
+tf_keras
+keras==3
+pretty_midi