audio_to_music_sheet.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from mingus.midi import fluidsynth as fs\n",
    "# from mingus.midi import midi_track\n",
    "# import mingus.midi.midi_file_out as mfo\n",
    "# from mingus.containers.note_container import NoteContainer\n",
    "# import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import soundfile\n",
    "import resampy\n",
    "import vamp\n",
    "import argparse\n",
    "import os\n",
    "import numpy as np\n",
    "from midiutil.MidiFile import MIDIFile\n",
    "from scipy.signal import medfilt\n",
    "import jams"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def save_jams(jamsfile, notes, track_duration, orig_filename):\n",
    "\n",
    "    # Construct a new JAMS object and annotation records\n",
    "    jam = jams.JAMS()\n",
    "\n",
    "    # Store the track duration\n",
    "    jam.file_metadata.duration = track_duration\n",
    "    jam.file_metadata.title = orig_filename\n",
    "\n",
    "    midi_an = jams.Annotation(namespace='pitch_midi',\n",
    "                              duration=track_duration)\n",
    "#     midi_an.annotation_metadata = \\\n",
    "#         jams.AnnotationMetadata(\n",
    "#             data_source='audio_to_midi_melodia.py v%s' %0.0,\n",
    "#             annotation_tools='audio_to_midi_melodia.py (https://github.com/'\n",
    "#                              'justinsalamon/audio_to_midi_melodia)')\n",
    "\n",
    "    # Add midi notes to the annotation record.\n",
    "    for n in notes:\n",
    "        midi_an.append(time=n[0], duration=n[1], value=n[2], confidence=0)\n",
    "\n",
    "    # Store the new annotation in the jam\n",
    "    jam.annotations.append(midi_an)\n",
    "\n",
    "    # Save to disk\n",
    "    jam.save(jamsfile)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def save_midi(outfile, notes, tempo):\n",
    "\n",
    "    track = 0\n",
    "    time = 0\n",
    "    midifile = MIDIFile(1)\n",
    "\n",
    "    # Add track name and tempo.\n",
    "    midifile.addTrackName(track, time, \"MIDI TRACK\")\n",
    "    midifile.addTempo(track, time, tempo)\n",
    "\n",
    "    channel = 0\n",
    "    volume = 100\n",
    "\n",
    "    for note in notes:\n",
    "        onset = note[0] * (tempo/60.)\n",
    "        duration = note[1] * (tempo/60.)\n",
    "        # duration = 1\n",
    "        pitch = note[2]\n",
    "        midifile.addNote(track, channel, int(pitch), onset, duration, volume)\n",
    "\n",
    "    # And write it to disk.\n",
    "    binfile = open(outfile, 'wb')\n",
    "    midifile.writeFile(binfile)\n",
    "    binfile.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def midi_to_notes(midi, fs, hop, smooth, minduration):\n",
    "\n",
    "    # smooth midi pitch sequence first\n",
    "    if (smooth > 0):\n",
    "        filter_duration = smooth  # in seconds\n",
    "        filter_size = int(filter_duration * fs / float(hop))\n",
    "        if filter_size % 2 == 0:\n",
    "            filter_size += 1\n",
    "        midi_filt = medfilt(midi, filter_size)\n",
    "    else:\n",
    "        midi_filt = midi\n",
    "    # print(len(midi),len(midi_filt))\n",
    "\n",
    "    notes = []\n",
    "    p_prev = 0\n",
    "    duration = 0\n",
    "    onset = 0\n",
    "    for n, p in enumerate(midi_filt):\n",
    "        if p == p_prev:\n",
    "            duration += 1\n",
    "        else:\n",
    "            # treat 0 as silence\n",
    "            if p_prev > 0:\n",
    "                # add note\n",
    "                duration_sec = duration * hop / float(fs)\n",
    "                # only add notes that are long enough\n",
    "                if duration_sec >= minduration:\n",
    "                    onset_sec = onset * hop / float(fs)\n",
    "                    notes.append((onset_sec, duration_sec, p_prev))\n",
    "\n",
    "            # start new note\n",
    "            onset = n\n",
    "            duration = 1\n",
    "            p_prev = p\n",
    "\n",
    "    # add last note\n",
    "    if p_prev > 0:\n",
    "        # add note\n",
    "        duration_sec = duration * hop / float(fs)\n",
    "        onset_sec = onset * hop / float(fs)\n",
    "        notes.append((onset_sec, duration_sec, p_prev))\n",
    "\n",
    "    return notes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hz2midi(hz):\n",
    "\n",
    "    # convert from Hz to midi note\n",
    "    hz_nonneg = hz.copy()\n",
    "    idx = hz_nonneg <= 0\n",
    "    hz_nonneg[idx] = 1\n",
    "    midi = 69 + 12*np.log2(hz_nonneg/440.)\n",
    "    midi[idx] = 0\n",
    "\n",
    "    # round\n",
    "    midi = np.round(midi)\n",
    "\n",
    "    return midi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def audio_to_midi_melodia(infile, outfile, bpm, smooth=0.25, minduration=0.1,\n",
    "                          savejams=False):\n",
    "\n",
    "    # define analysis parameters\n",
    "    fs = 44100\n",
    "    hop = 128\n",
    "\n",
    "    # load audio using librosa\n",
    "    print(\"Loading audio...\")\n",
    "    data, sr = soundfile.read(infile)\n",
    "    # mixdown to mono if needed\n",
    "    if len(data.shape) > 1 and data.shape[1] > 1:\n",
    "        data = data.mean(axis=1)\n",
    "    # resample to 44100 if needed\n",
    "    if sr != fs:\n",
    "        data = resampy.resample(data, sr, fs)\n",
    "        sr = fs\n",
    "\n",
    "    # extract melody using melodia vamp plugin\n",
    "    print(\"Extracting melody f0 with MELODIA...\")\n",
    "    melody = vamp.collect(data, sr, \"mtg-melodia:melodia\",\n",
    "                          parameters={\"voicing\": 0.2})\n",
    "\n",
    "    # hop = melody['vector'][0]\n",
    "    pitch = melody['vector'][1]\n",
    "\n",
    "    # impute missing 0's to compensate for starting timestamp\n",
    "    pitch = np.insert(pitch, 0, [0]*8)\n",
    "\n",
    "    # debug\n",
    "    # np.asarray(pitch).dump('f0.npy')\n",
    "    # print(len(pitch))\n",
    "\n",
    "    # convert f0 to midi notes\n",
    "    print(\"Converting Hz to MIDI notes...\")\n",
    "    midi_pitch = hz2midi(pitch)\n",
    "\n",
    "    # segment sequence into individual midi notes\n",
    "    notes = midi_to_notes(midi_pitch, fs, hop, smooth, minduration)\n",
    "\n",
    "    # save note sequence to a midi file\n",
    "    print(\"Saving MIDI to disk...\")\n",
    "    save_midi(outfile, notes, bpm)\n",
    "\n",
    "    if savejams:\n",
    "        print(\"Saving JAMS to disk...\")\n",
    "        jamsfile = os.path.splitext(outfile)[0] + \".jams\"\n",
    "        track_duration = len(data) / float(fs)\n",
    "        save_jams(jamsfile, notes, track_duration, os.path.basename(infile))\n",
    "\n",
    "    print(\"Conversion complete.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading audio...\n",
      "Extracting melody f0 with MELODIA...\n",
      "Converting Hz to MIDI notes...\n",
      "Saving MIDI to disk...\n",
      "Saving JAMS to disk...\n",
      "Conversion complete.\n"
     ]
    }
   ],
   "source": [
    "if __name__ == \"__main__\":\n",
    "    audio_to_midi_melodia('./sample.wav','./test_2.mid',120,0.25,0.1,True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}