import shutil import gradio as gr from matplotlib import pyplot as plt from mido import Message, MidiFile, MidiTrack import os import subprocess from music21 import converter, note from pydub import AudioSegment import hexachords BASE_DIR = os.path.dirname(os.path.abspath(__file__)) os.environ["VEROVIO_FONT_PATH"] = "/usr/local/share/verovio/fonts" def install_verovio(): verovio_dir = "verovio" build_dir = os.path.join(verovio_dir, "build") cmake_source_dir = os.path.join(verovio_dir, "cmake") # The correct directory containing CMakeLists.txt verovio_executable = os.path.join(build_dir, "verovio") if not os.path.exists(verovio_executable): print("Installing Verovio...") try: # Clone the Verovio repository subprocess.run(["git", "clone", "--recursive", "https://github.com/rism-digital/verovio.git"], check=True) # Ensure build directory exists os.makedirs(build_dir, exist_ok=True) # Move into the build directory os.chdir(build_dir) # Run CMake using the correct source path (`../cmake`) subprocess.run(["cmake", "../cmake"], check=True) # Compile Verovio subprocess.run(["make", "-j4"], check=True) # Move back to the original directory os.chdir("../../") except subprocess.CalledProcessError as e: print(f"An error occurred during Verovio installation: {e}") os.chdir("../../") # Ensure returning to the original directory in case of error else: print("Verovio is already installed.") install_verovio() # Ensure Verovio is installed before running Gradio # Ensure Verovio has the Bravura font def install_bravura(): font_path = "/usr/local/share/verovio/fonts" os.makedirs(font_path, exist_ok=True) # Ensure the folder exists bravura_font = os.path.join(font_path, "Bravura.otf") if not os.path.exists(bravura_font): print("Downloading Bravura font...") os.system(f"curl -L -o {bravura_font} https://github.com/steinbergmedia/bravura/releases/download/v1.392/Bravura-1.392.otf") else: print("Bravura font already installed.") install_bravura() class HexachordApp: def __init__(self): self._hexachord = None self._hexachord_base_sequence = None self.ui = None self.on_huggingface = "HUGGINGFACE_SPACE" in os.environ def is_fsynth_installed(self): """ Check to make sure fluidsynth exists in the PATH """ for path in os.environ['PATH'].split(os.pathsep): f = os.path.join(path, 'fluidsynth') if os.path.exists(f) and os.access(f, os.X_OK): print('fluidsynth is installed') return True print('fluidsynth is NOT installed') return False def generate_chords(self, note_names, itvl): # Placeholder for your actual chord generation function # Assuming hexachord is a list of MIDI note numbers self._hexachord = hexachords.Hexachord() interval_21 = 'P5' if itvl == 'fourth': interval_21 = 'P4' self._hexachord_base_sequence = self._hexachord.generate_chord_sequence(note_names, intrvl=interval_21) return self._hexachord_base_sequence def generate_realizations(self): # returns 3 triples of midipath, piano roll, audio player reals = self._hexachord.generate_3_chords_realizations(self._hexachord_base_sequence) midi_path1 = self.create_midi(reals[0], "real1.mid") piano_roll_path1 = self.generate_piano_roll(reals[0], "real1.png") audio_path1 = self.convert_midi_to_audio(midi_path1, "real1") midi_path2 = self.create_midi(reals[1], "real2.mid") piano_roll_path2 = self.generate_piano_roll(reals[1], "real2.png") audio_path2 = self.convert_midi_to_audio(midi_path2, "real2") midi_path3 = self.create_midi(reals[2], "real3.mid") piano_roll_path3 = self.generate_piano_roll(reals[2], "real3.png") audio_path3 = self.convert_midi_to_audio(midi_path3, "real3") return midi_path1, piano_roll_path1, audio_path1, midi_path2, piano_roll_path2, audio_path2, midi_path3, piano_roll_path3, audio_path3 def create_midi(self, chords, file_name): mid = MidiFile() track = MidiTrack() mid.tracks.append(track) delta_time = 480 * 4 for i_chord, chord in enumerate(chords): for i, note in enumerate(chord): if i == 0 and i_chord != 0: track.append(Message('note_on', note=note.pitch.midi, velocity=64, time=1)) else: track.append(Message('note_on', note=note.pitch.midi, velocity=64, time=0)) for i, note in enumerate(chord): if i==0: track.append(Message('note_off', note=note.pitch.midi, velocity=0, time=delta_time - 1)) else: track.append(Message('note_off', note=note.pitch.midi, velocity=0, time=0)) midi_path = os.path.join(BASE_DIR, file_name) mid.save(midi_path) return midi_path def convert_midi_to_audio(self, midi_path, file_name): if not shutil.which("fluidsynth"): try: subprocess.run(["apt-get", "update"], check=True) subprocess.run(["apt-get", "install", "-y", "fluidsynth"], check=True) except Exception as e: return f"Error installing Fluidsynth: {str(e)}" wav_path = os.path.join(BASE_DIR, file_name + ".wav") mp3_path = os.path.join(BASE_DIR, file_name + ".mp3") soundfont_path = os.path.join(BASE_DIR, "soundfont.sf2") if not os.path.exists(soundfont_path): return "Error: SoundFont file not found. Please provide a valid .sf2 file." try: subprocess.run(["fluidsynth", "-ni", soundfont_path, midi_path, "-F", wav_path, "-r", "44100"], check=True) AudioSegment.converter = "ffmpeg" audio = AudioSegment.from_wav(wav_path) audio.export(mp3_path, format="mp3") return mp3_path except Exception as e: return f"Error converting MIDI to audio: {str(e)}" def midi_to_svg(self, midi_file, output_file_name): return self._hexachord.midi_to_svg(midi_file, output_file_name) def generate_piano_roll(self, chords, label): fig, ax = plt.subplots(figsize=(8, 4)) for i, chord in enumerate(chords): for note in chord: ax.broken_barh([(i * 1, 0.8)], (note.pitch.midi - 0.4, 0.8), facecolors='blue') ax.set_xlabel("Chord Progression") ax.set_ylabel("MIDI Note Number") min_min_chords = 128 max_max_chords = 0 for ch in chords: for note in ch: if note.pitch.midi < min_min_chords: min_min_chords = note.pitch.midi if note.pitch.midi > max_max_chords: max_max_chords = note.pitch.midi ax.set_yticks(range(min_min_chords, max_max_chords + 1, 2)) ax.set_xticks(range(len(chords))) ax.set_xticklabels([f"Chord {i + 1}" for i in range(len(chords))]) plt.grid(True, linestyle='--', alpha=0.5) plt.savefig(label) return label def launch_score_editor(self, midi_path): try: score = converter.parse(midi_path) score.show('musicxml') return "Opened MIDI file in the default score editor!" except Exception as e: return f"Error opening score editor: {str(e)}" def process_hexachord(self, hexachord_str, itvl): try: notes = [note.Note(n) for n in hexachord_str.split()] if len(notes) != 6 or len(set(notes)) != 6: return "Please enter exactly 6 unique MIDI note numbers." except ValueError: return "Invalid input. Enter 6 MIDI note numbers separated by spaces." self._hexachord = notes chords = self.generate_chords(notes, itvl) midi_path = self.create_midi(chords, "base_chords.mid") # piano_roll_path = self.generate_piano_roll(chords, "base_chords.png") score_path = self.midi_to_svg (midi_path, "score_base_chords.svg") audio_path = self.convert_midi_to_audio(midi_path, "base_chords") return midi_path, score_path, audio_path def midi_to_musicxml_string(self, midi_file): # midi_file_path = "example.mid" # Replace with your MIDI file # musicxml_string = midi_to_musicxml_string(midi_file_path) # print(musicxml_string) """Convert MIDI to MusicXML string using music21.""" score = converter.parse(midi_file) return score.write('musicxml') # Example usage def render(self): with gr.Blocks() as ui: gr.Markdown("# Hexachord-based Chord Generator") with gr.Tabs(): with gr.TabItem("Hexachord Generator"): with gr.Row(): hexachord_input = gr.Textbox( label="Enter 6 notes (pitchclass plus octave, separated by spaces)", value="C3 D3 E3 G3 A3 B3", interactive = True ) interval_switch = gr.Radio( choices=["fourth", "fifth"], label="Select Interval", value="fifth" ) generate_button = gr.Button("Generate Chords") midi_output = gr.File(label="Download MIDI File") # piano_roll_output = gr.Image(label="Piano Roll Visualization") score_output = gr.Image(label="Score Visualization") audio_output = gr.Audio(label="Play Generated Chords", value=None, interactive=False) generate_button.click( fn=self.process_hexachord, inputs=[hexachord_input, interval_switch], # outputs=[midi_output, piano_roll_output, audio_output] outputs = [midi_output, score_output, audio_output] ) # Pressing Enter in the textbox also triggers processing hexachord_input.submit( fn=self.process_hexachord, inputs=[hexachord_input, interval_switch], outputs=[midi_output, score_output, audio_output] ) with gr.TabItem("Alternative Chord Realizations"): gr.Markdown("Alternative Chord Realizations") realization_button = gr.Button("Generate Alternative Realizations") realization_outputs = [] for i in range(3): # Three alternative realizations with gr.Group(): gr.Markdown(f"#### Realization {i + 1}") midi_output = gr.File(label="Download MIDI File") piano_roll = gr.Image(label=f"Piano Roll {i + 1}") audio_player = gr.Audio(label=f"Play Chords {i + 1}", interactive=False) realization_outputs.append((midi_output, piano_roll, audio_player)) # Clicking the button triggers realization generation realization_button.click( fn=self.generate_realizations, inputs=[], outputs=[output for trip in realization_outputs for output in trip] ) with gr.TabItem("Settings"): gr.Markdown("### Configuration Options") setting_1 = gr.Checkbox(label="Enable Advanced Mode") setting_2 = gr.Slider(0, 100, label="Complexity Level") self.ui = ui def launch_app(): hex = HexachordApp() hex.is_fsynth_installed() hex.render() if hex.on_huggingface: hex.ui.launch(server_name="0.0.0.0", server_port=7860) else: hex.ui.launch() launch_app()