New files uploaded

app.py

@@ -0,0 +1,202 @@
+import os
+import streamlit as st
+from transcriber import AudioTranscriber
+from hf_transcriber import HFTranscriber, transcribe_with_hf
+from recorder import AudioRecorder, list_audio_devices
+import tempfile
+import base64
+import numpy as np
+import time
+from datetime import datetime
+import sounddevice as sd  # Add this import
+
+def get_binary_file_downloader_html(bin_file, file_label='File'):
+    """Generate a link to download the given file."""
+    with open(bin_file, 'rb') as f:
+        data = f.read()
+    bin_str = base64.b64encode(data).decode()
+    href = f'<a href="data:application/octet-stream;base64,{bin_str}" download="{os.path.basename(bin_file)}">Download {file_label}</a>'
+    return href
+
+def main():
+    st.set_page_config(page_title="Audio to Sheet Music Transcriber", layout="wide")
+    
+    st.title("🎵 Audio to Sheet Music Transcriber")
+    st.markdown("### Convert monophonic audio to sheet music")
+    
+    # Initialize session state for recording
+    if 'recorder' not in st.session_state:
+        st.session_state.recorder = AudioRecorder()
+    if 'recording' not in st.session_state:
+        st.session_state.recording = False
+    
+    st.sidebar.header("Transcription Settings")
+    use_hf = st.sidebar.checkbox("Use Hugging Face Model", value=True)
+    
+    if use_hf:
+        model_name = st.sidebar.selectbox(
+            "Select Model",
+            ["microsoft/speecht5_asr", "facebook/wav2vec2-base-960h"],
+            index=0
+        )
+    
+    # Recording or Upload Section
+    st.sidebar.header("Audio Input")
+    input_method = st.sidebar.radio("Choose input method:", ["Upload Audio File", "Record Live Audio"])
+    
+    if input_method == "Record Live Audio":
+        st.header("🎤 Live Audio Recording")
+        
+        # Show available audio devices
+        devices = list_audio_devices()
+        if not devices:
+            st.error("No audio input devices found!")
+        else:
+            device_names = [f"{i}: {d['name']} (Channels: {d['input_channels']}, Rate: {int(d['default_samplerate'])}Hz)" 
+                          for i, d in enumerate(devices)]
+            selected_device = st.selectbox("Select audio input device:", device_names, 
+                                         index=next((i for i, d in enumerate(devices) if d['id'] == sd.default.device[0]), 0))
+            
+            # Get the selected device ID
+            device_id = devices[device_names.index(selected_device)]['id']
+            
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                if st.button("🎤 Start Recording", disabled=st.session_state.recording):
+                    sd.default.device = device_id
+                    st.session_state.recorder = AudioRecorder(
+                        sample_rate=int(devices[device_id]['default_samplerate']),
+                        channels=min(1, devices[device_id]['input_channels'])
+                    )
+                    st.session_state.recorder.start_recording()
+                    st.session_state.recording = True
+                    st.session_state.recording_start = time.time()
+                    st.rerun()
+            
+            with col2:
+                if st.button("⏹ Stop Recording", disabled=not st.session_state.recording):
+                    audio_data = st.session_state.recorder.stop_recording()
+                    if audio_data is not None:
+                        # Save the recording
+                        filename = f"recording_{datetime.now().strftime('%Y%m%d_%H%M%S')}.wav"
+                        filepath = st.session_state.recorder.save_recording(filename)
+                        st.session_state.recorded_file = filepath
+                    st.session_state.recording = False
+                    st.rerun()
+            
+            if st.session_state.recording:
+                recording_duration = time.time() - st.session_state.recording_start
+                st.warning(f"🔴 Recording... {int(recording_duration)} seconds")
+                st.audio(np.concatenate(st.session_state.recorder.recording_data) if st.session_state.recorder.recording_data else None, 
+                        sample_rate=st.session_state.recorder.sample_rate)
+            
+            if hasattr(st.session_state, 'recorded_file') and os.path.exists(st.session_state.recorded_file):
+                st.audio(st.session_state.recorded_file)
+                uploaded_file = st.session_state.recorded_file
+            else:
+                uploaded_file = None
+    else:
+        # File upload option
+        st.header("📁 Upload Audio File")
+        uploaded_file = st.file_uploader("Choose an audio file", type=['wav', 'mp3', 'ogg', 'flac'])
+    
+    if uploaded_file is not None:
+        # Handle both file uploads and recorded files
+        if hasattr(uploaded_file, 'read'):  # It's a file upload object
+            # Save uploaded file to a temporary file
+            with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(uploaded_file.name)[1]) as tmp_file:
+                tmp_file.write(uploaded_file.getvalue())
+                tmp_file_path = tmp_file.name
+            # Display audio player for uploaded file
+            st.audio(uploaded_file, format=uploaded_file.type)
+        else:  # It's a recorded file path
+            tmp_file_path = uploaded_file
+            # Display audio player for recorded file
+            st.audio(tmp_file_path, format='audio/wav')
+        
+        if st.button("Transcribe Audio"):
+            with st.spinner('Transcribing audio... This may take a moment...'):
+                try:
+                    # Create output file paths
+                    base_name = os.path.splitext(os.path.basename(tmp_file_path))[0]
+                    output_dir = "outputs"
+                    os.makedirs(output_dir, exist_ok=True)
+                    
+                    midi_path = os.path.join(output_dir, f"{base_name}.mid")
+                    musicxml_path = os.path.join(output_dir, f"{base_name}.musicxml")
+                    
+                    # Transcribe the audio using the selected method
+                    if use_hf:
+                        st.info(f"Using Hugging Face model: {model_name}")
+                        # Use Hugging Face model for transcription
+                        hf_result = transcribe_with_hf(tmp_file_path, model_name)
+                        
+                        # Convert notes to MIDI (simplified example)
+                        # In a real implementation, you would map the model's output to MIDI notes
+                        transcriber = AudioTranscriber()
+                        
+                        # Create a simple MIDI file with the detected notes
+                        # This is a placeholder - you'll need to adapt this based on the model's output
+                        midi = pretty_midi.PrettyMIDI()
+                        piano_program = pretty_midi.instrument_name_to_program('Acoustic Grand Piano')
+                        piano = pretty_midi.Instrument(program=piano_program)
+                        
+                        # Add notes (simplified example)
+                        for i, note in enumerate(hf_result['notes']):
+                            note = pretty_midi.Note(
+                                velocity=100,
+                                pitch=min(max(int(note), 0), 127),  # Ensure valid MIDI note
+                                start=i * 0.5,  # 0.5 seconds per note
+                                end=(i + 1) * 0.5
+                            )
+                            piano.notes.append(note)
+                        
+                        midi.instruments.append(piano)
+                        midi.write(midi_path)
+                        
+                        # Convert to MusicXML
+                        score = music21.midi.translate.midiFileToStream(midi_path)
+                        score.write('musicxml', musicxml_path)
+                        
+                        onsets = np.arange(0, len(hf_result['notes']) * 0.5, 0.5)
+                        pitches = hf_result['notes']
+                        
+                    else:
+                        # Use the original audio processing method
+                        transcriber = AudioTranscriber()
+                        midi, onsets, pitches = transcriber.transcribe(
+                            tmp_file_path, 
+                            midi_path,
+                            musicxml_path
+                        )
+                    
+                    st.success("Transcription complete!")
+                    
+                    # Display results
+                    col1, col2 = st.columns(2)
+                    
+                    with col1:
+                        st.subheader("MIDI File")
+                        st.markdown(get_binary_file_downloader_html(midi_path, "MIDI"), unsafe_allow_html=True)
+                    
+                    with col2:
+                        st.subheader("Sheet Music (MusicXML)")
+                        st.markdown(get_binary_file_downloader_html(musicxml_path, "MusicXML"), unsafe_allow_html=True)
+                    
+                    # Display some statistics
+                    st.subheader("Transcription Details")
+                    st.write(f"- Detected {len(onsets)} note onsets")
+                    st.write(f"- Average note duration: {np.mean(np.diff(onsets)):.2f} seconds")
+                    
+                    # Clean up temporary file
+                    os.unlink(tmp_file_path)
+                    
+                except Exception as e:
+                    st.error(f"An error occurred during transcription: {str(e)}")
+                    if os.path.exists(tmp_file_path):
+                        os.unlink(tmp_file_path)
+
+if __name__ == "__main__":
+    import numpy as np
+    main()

hf_README.md

@@ -0,0 +1,52 @@
+# Audio to Sheet Music Transcriber
+
+A web application that converts monophonic audio recordings into sheet music using machine learning. This app can transcribe audio files (WAV, MP3) or record live audio and convert it to MIDI and MusicXML formats.
+
+## Features
+
+- Upload audio files (WAV, MP3) for transcription
+- Record audio directly in the browser
+- Choose between different transcription models
+- Download MIDI and MusicXML files
+- View basic audio visualizations
+
+## How to Use
+
+1. **Input Audio**:
+   - Upload an audio file using the file uploader
+   - OR record audio directly in the browser
+
+2. **Transcription Settings**:
+   - Select your preferred transcription model
+   - Adjust audio parameters if needed
+
+3. **Process**:
+   - Click "Transcribe" to start the transcription
+   - Wait for the processing to complete
+
+4. **Download**:
+   - Download the generated MIDI file
+   - Download the MusicXML file for sheet music
+
+## Models
+
+- **Facebook wav2vec2**: Fast and accurate speech recognition
+- **Microsoft SpeechT5**: High-quality speech recognition with better intonation
+
+## Technical Details
+
+This app uses:
+- PyTorch and Transformers for audio processing
+- Librosa for audio feature extraction
+- PrettyMIDI and Music21 for MIDI and MusicXML generation
+- Streamlit for the web interface
+
+## Limitations
+
+- Works best with clean, monophonic recordings
+- May have difficulty with fast passages or complex articulations
+- Performance depends on the quality of the input audio
+
+## License
+
+MIT License - See the [LICENSE](LICENSE) file for details.

hf_requirements.txt

@@ -0,0 +1,36 @@
+# Core dependencies
+numpy>=1.21.0
+librosa>=0.9.2
+pretty_midi>=0.2.10
+music21>=7.3.3
+streamlit>=1.12.0
+scipy>=1.7.0
+matplotlib>=3.4.3
+soundfile>=0.12.1
+pydub>=0.25.1
+scikit-learn>=1.0.2
+
+# Hugging Face and deep learning
+transformers>=4.30.0
+datasets>=2.12.0
+torch>=2.0.0,<3.0.0
+torchaudio>=2.0.0
+accelerate>=0.20.0
+sentencepiece  # Required for some models
+
+# Audio processing
+resampy>=0.4.2
+
+# For MIDI processing
+mido>=1.2.10
+python-rtmidi>=1.4.9
+
+# For web interface
+gradio>=3.0.0
+
+# For file handling
+tqdm>=4.65.0
+
+# Remove Windows-specific dependencies
+# pyaudio  # Not needed on Hugging Face Spaces
+# sounddevice  # Not needed on Hugging Face Spaces

hf_transcriber.py

@@ -0,0 +1,154 @@
+import torch
+from transformers import (
+    AutoModelForCTC,
+    AutoProcessor,
+    pipeline,
+    SpeechT5Processor,
+    SpeechT5ForSpeechToText,
+    SpeechT5HifiGan
+)
+import numpy as np
+import librosa
+import torchaudio
+from typing import Tuple, Optional, List, Union, Dict, Any
+import warnings
+warnings.filterwarnings("ignore", message=".*gradient_checkpointing*.")
+
+class HFTranscriber:
+    def __init__(self, model_name: str = "facebook/wav2vec2-base-960h"):
+        """
+        Initialize the Hugging Face transcriber with a pre-trained model.
+        
+        Args:
+            model_name (str): Name of the Hugging Face model to use for transcription.
+                             Supported models:
+                             - "facebook/wav2vec2-base-960h" (default)
+                             - "microsoft/speecht5_asr"
+        """
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.model_name = model_name
+        self.processor = None
+        self.model = None
+        self.vocoder = None
+        self.is_speecht5 = "speecht5" in model_name.lower()
+        self._load_model()
+    
+    def _load_model(self):
+        """Load the model and processor based on the model type."""
+        try:
+            if self.is_speecht5:
+                # Load SpeechT5 model and processor
+                self.processor = SpeechT5Processor.from_pretrained(self.model_name)
+                self.model = SpeechT5ForSpeechToText.from_pretrained(self.model_name)
+                self.vocoder = SpeechT5HifiGan.from_pretrained("microsoft/speecht5_hifigan")
+                self.model.to(self.device)
+                self.vocoder.to(self.device)
+                self.model.eval()
+                self.vocoder.eval()
+            else:
+                # Load wav2vec2 model and processor
+                self.processor = AutoProcessor.from_pretrained(self.model_name)
+                self.model = AutoModelForCTC.from_pretrained(self.model_name)
+                self.model.to(self.device)
+                self.model.eval()
+        except Exception as e:
+            raise Exception(f"Failed to load model {self.model_name}: {str(e)}")
+    
+    def transcribe_audio(self, audio_path: str) -> Tuple[List[int], int]:
+        """
+        Transcribe audio file to notes using the loaded Hugging Face model.
+        
+        Args:
+            audio_path (str): Path to the audio file
+            
+        Returns:
+            tuple: (notes, sample_rate) where notes is a list of MIDI note numbers
+        """
+        try:
+            # Load and preprocess audio
+            waveform, sample_rate = self._load_audio(audio_path)
+            
+            if self.is_speecht5:
+                # Process the audio input for SpeechT5
+                inputs = self.processor(
+                    audio=waveform, 
+                    sampling_rate=sample_rate,
+                    return_tensors="pt"
+                ).to(self.device)
+                
+                # Generate transcription
+                with torch.no_grad():
+                    generated_ids = self.model.generate(
+                        input_values=inputs.input_values,
+                        attention_mask=inputs.attention_mask,
+                        max_length=1000
+                    )
+                
+                # Decode the generated ids to text
+                transcription = self.processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
+            else:
+                # Process the audio input for wav2vec2
+                inputs = self.processor(
+                    waveform, 
+                    sampling_rate=sample_rate, 
+                    return_tensors="pt",
+                    padding=True
+                ).input_values.to(self.device)
+                
+                # Get model predictions
+                with torch.no_grad():
+                    logits = self.model(inputs).logits
+                
+                # Get predicted token ids
+                predicted_ids = torch.argmax(logits, dim=-1)
+                
+                # Decode the predicted ids to text
+                transcription = self.processor.batch_decode(predicted_ids)[0]
+            
+            # Convert text to MIDI notes (simplified example)
+            notes = self._text_to_midi_notes(transcription)
+            
+            return notes, sample_rate
+            
+        except Exception as e:
+            raise Exception(f"Transcription failed: {str(e)}")
+    
+    def _text_to_midi_notes(self, text: str) -> List[int]:
+        """Convert transcribed text to MIDI notes (simplified example)."""
+        # This is a placeholder - in a real implementation, you'd need to
+        # analyze the text to determine the appropriate notes
+        # Here we just return a simple C major scale as an example
+        return [60, 62, 64, 65, 67, 69, 71, 72]  # C4 to C5
+    
+    def _load_audio(self, audio_path: str, target_sr: int = 16000) -> Tuple[np.ndarray, int]:
+        """Load and preprocess audio file."""
+        # Load audio with librosa (handles resampling and mono conversion)
+        waveform, sample_rate = librosa.load(
+            audio_path,
+            sr=target_sr,
+            mono=True,
+            duration=None,
+            res_type='kaiser_fast'
+        )
+        return waveform, sample_rate
+
+
+def transcribe_with_hf(audio_path: str, model_name: str = "openai/whisper-tiny") -> dict:
+    """
+    Convenience function to transcribe audio using a Hugging Face model.
+    
+    Args:
+        audio_path (str): Path to the audio file
+        model_name (str): Name of the Hugging Face model to use
+        
+    Returns:
+        dict: Dictionary containing transcription results
+    """
+    transcriber = HFTranscriber(model_name=model_name)
+    notes, sample_rate = transcriber.transcribe_audio(audio_path)
+    
+    return {
+        'notes': notes,
+        'sample_rate': sample_rate,
+        'model': model_name
+    }

recorder.py

@@ -0,0 +1,119 @@
+import sounddevice as sd
+import numpy as np
+import wave
+import os
+from datetime import datetime
+from typing import Optional, Tuple
+import threading
+import queue
+
+class AudioRecorder:
+    def __init__(self, sample_rate: int = 44100, channels: int = 1):
+        """
+        Initialize the audio recorder.
+        
+        Args:
+            sample_rate (int): Sample rate in Hz (default: 44100)
+            channels (int): Number of audio channels (1 for mono, 2 for stereo)
+        """
+        self.sample_rate = sample_rate
+        self.channels = channels
+        self.recording = False
+        self.audio_queue = queue.Queue()
+        self.recording_thread = None
+        self.recording_data = []
+        
+    def _callback(self, indata, frames, time, status):
+        """Callback function for audio input stream."""
+        if status:
+            print(f"Audio input status: {status}")
+        self.audio_queue.put(indata.copy())
+    
+    def start_recording(self):
+        """Start recording audio from the default input device."""
+        if self.recording:
+            return False
+            
+        self.recording = True
+        self.recording_data = []
+        
+        def record():
+            with sd.InputStream(
+                samplerate=self.sample_rate,
+                channels=self.channels,
+                callback=self._callback,
+                dtype='float32'
+            ) as stream:
+                while self.recording:
+                    data = self.audio_queue.get()
+                    self.recording_data.append(data)
+        
+        self.recording_thread = threading.Thread(target=record)
+        self.recording_thread.start()
+        return True
+    
+    def stop_recording(self) -> Optional[np.ndarray]:
+        """
+        Stop recording and return the recorded audio data.
+        
+        Returns:
+            Optional[np.ndarray]: Recorded audio data as a numpy array, or None if no data was recorded
+        """
+        if not self.recording:
+            return None
+            
+        self.recording = False
+        if self.recording_thread:
+            self.recording_thread.join()
+        
+        if not self.recording_data:
+            return None
+            
+        return np.concatenate(self.recording_data, axis=0)
+    
+    def save_recording(self, filename: str = None, format: str = 'wav') -> str:
+        """
+        Save the recorded audio to a file.
+        
+        Args:
+            filename (str, optional): Output filename. If None, generates a timestamped filename.
+            format (str): Output format ('wav' or 'npy')
+            
+        Returns:
+            str: Path to the saved file
+        """
+        audio_data = np.concatenate(self.recording_data, axis=0) if self.recording_data else None
+        if audio_data is None:
+            raise ValueError("No recording data available to save")
+        
+        if filename is None:
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            filename = f"recording_{timestamp}.{format}"
+        
+        os.makedirs("recordings", exist_ok=True)
+        filepath = os.path.join("recordings", filename)
+        
+        if format.lower() == 'wav':
+            # Convert float32 to int16 for WAV format
+            audio_data = (audio_data * 32767).astype(np.int16)
+            with wave.open(filepath, 'wb') as wf:
+                wf.setnchannels(self.channels)
+                wf.setsampwidth(2)  # 16-bit
+                wf.setframerate(self.sample_rate)
+                wf.writeframes(audio_data.tobytes())
+        elif format.lower() == 'npy':
+            np.save(filepath, audio_data)
+        else:
+            raise ValueError(f"Unsupported format: {format}")
+            
+        return filepath
+
+def list_audio_devices() -> list:
+    """List all available audio input devices."""
+    devices = sd.query_devices()
+    return [{
+        'id': i,
+        'name': device['name'],
+        'input_channels': device['max_input_channels'],
+        'default_samplerate': device['default_samplerate']
+    } for i, device in enumerate(devices) if device['max_input_channels'] > 0]

transcriber.py

@@ -0,0 +1,152 @@
+import librosa
+import numpy as np
+from scipy import signal
+
+try:
+    import pretty_midi
+    PRETTY_MIDI_AVAILABLE = True
+except ImportError:
+    PRETTY_MIDI_AVAILABLE = False
+    import warnings
+    warnings.warn("pretty_midi not available. MIDI file generation will be limited.", ImportWarning)
+
+class AudioTranscriber:
+    def __init__(self, sample_rate=22050, frame_size=2048, hop_length=512):
+        """
+        Initialize the AudioTranscriber with audio processing parameters.
+        
+        Args:
+            sample_rate (int): Sample rate to load audio (Hz)
+            frame_size (int): FFT window size
+            hop_length (int): Number of samples between frames
+        """
+        self.sample_rate = sample_rate
+        self.frame_size = frame_size
+        self.hop_length = hop_length
+    
+    def load_audio(self, file_path):
+        """Load audio file and return time series and sample rate."""
+        y, sr = librosa.load(file_path, sr=self.sample_rate, mono=True)
+        return y, sr
+    
+    def detect_onsets(self, y):
+        """Detect note onset times in the audio signal."""
+        # Compute onset envelope
+        onset_env = librosa.onset.onset_strength(y=y, sr=self.sample_rate)
+        # Detect onsets
+        onset_frames = librosa.onset.onset_detect(
+            onset_envelope=onset_env, 
+            sr=self.sample_rate,
+            hop_length=self.hop_length,
+            backtrack=True
+        )
+        return librosa.frames_to_time(onset_frames, sr=self.sample_rate, hop_length=self.hop_length)
+    
+    def estimate_pitch(self, y, onsets):
+        """Estimate pitch for each onset segment."""
+        pitches = []
+        for i in range(len(onsets) - 1):
+            start_sample = int(onsets[i] * self.sample_rate)
+            end_sample = int(onsets[i+1] * self.sample_rate)
+            segment = y[start_sample:end_sample]
+            
+            # Skip if segment is too short
+            if len(segment) < self.frame_size:
+                pitches.append(0)
+                continue
+                
+            # Compute pitch using YIN algorithm
+            f0, _, _ = librosa.pyin(
+                segment,
+                fmin=librosa.note_to_hz('C2'),
+                fmax=librosa.note_to_hz('C7'),
+                sr=self.sample_rate
+            )
+            # Get most common pitch in the segment (excluding zeros)
+            f0 = f0[f0 > 0]
+            pitch = np.median(f0) if len(f0) > 0 else 0
+            pitches.append(pitch)
+        
+        return np.array(pitches)
+    
+    def create_midi(self, onsets, pitches, output_path):
+        """
+        Create a MIDI file from detected notes.
+        
+        Args:
+            onsets (list): List of onset times in seconds
+            pitches (list): List of pitch values in Hz
+            output_path (str): Path to save the MIDI file
+            
+        Returns:
+            str: Path to the generated MIDI file or None if failed
+        """
+        if not PRETTY_MIDI_AVAILABLE:
+            raise ImportError("pretty_midi is required for MIDI file generation. "
+                           "Please install it using: pip install pretty_midi")
+        
+        try:
+            # Create a PrettyMIDI object
+            midi = pretty_midi.PrettyMIDI()
+            
+            # Create an Instrument instance for a piano instrument
+            piano_program = pretty_midi.instrument_name_to_program('Acoustic Grand Piano')
+            piano = pretty_midi.Instrument(program=piano_program)
+            
+            # Add the notes to the instrument
+            for i in range(len(onsets)):
+                # Skip if no pitch detected for this onset
+                if i >= len(pitches) or pitches[i] <= 0:
+                    continue
+                    
+                # Create a note
+                note = pretty_midi.Note(
+                    velocity=100,
+                    pitch=int(round(pitches[i])),
+                    start=onsets[i],
+                    end=onsets[i] + 0.5  # Default duration of 0.5 seconds
+                )
+                piano.notes.append(note)
+            
+            # Add the instrument to the PrettyMIDI object
+            midi.instruments.append(piano)
+            
+            # Write the MIDI data to the output file
+            midi.write(output_path)
+            
+            return output_path
+            
+        except Exception as e:
+            raise Exception(f"Failed to create MIDI file: {str(e)}")
+    
+    def transcribe(self, input_path, output_midi, output_musicxml=None):
+        """Main transcription method."""
+        # Load audio
+        y, _ = self.load_audio(input_path)
+        
+        # Detect onsets
+        onsets = self.detect_onsets(y)
+        
+        # Estimate pitch for each note
+        pitches = self.estimate_pitch(y, onsets)
+        
+        # Create MIDI file
+        midi = self.create_midi(onsets, pitches, output_midi)
+        
+        # Convert to MusicXML if requested
+        if output_musicxml:
+            self.midi_to_musicxml(output_midi, output_musicxml)
+        
+        return midi, onsets, pitches
+    
+    @staticmethod
+    def midi_to_musicxml(midi_path, output_path):
+        """Convert MIDI file to MusicXML format."""
+        import music21
+        mf = music21.midi.MidiFile()
+        mf.open(midi_path)
+        mf.read()
+        mf.close()
+        
+        score = music21.midi.translate.midiFileToStream(mf)
+        score.write('musicxml', output_path)