What MIDI Cannot Capture — Expression, Velocity, and Timing Feel After MP3 Conversion

Velocity: every note gets the same hit

In a real performance, a pianist strikes some keys harder than others. A singer pushes a phrase louder, then pulls back. A guitarist digs into a note and lets it decay. This dynamic variation is part of the audio waveform — louder moments have higher amplitude.

The converter on this site does not preserve that variation. In the source code, the buildMidi function assigns the same note-on velocity to every single note:

evs.push({t:Math.round(n.startSec*tps), kind:'on', note:n.midi, vel:90});

The value 90 is hardcoded. Whether the original note was a loud accented downbeat or a soft ghost note, the MIDI file says velocity 90. Note-off events carry velocity 0 — 0x80, e.note & 0x7f, 0 — which is the standard "note released" signal and carries no release-velocity information either.

This means every note in the converted MIDI file has identical loudness when played back through any instrument. The dynamic arc of the original performance — the rises and falls, the accents, the gentle phrases — is gone. To restore it, you need to open the MIDI in your DAW's piano roll and manually draw or edit velocity values per note.

Timing: quantized to a fixed grid

MIDI stores timing as integer "ticks" relative to a clock defined by PPQ (pulses per quarter note) and BPM (beats per minute). The converter writes SMF format 0 with PPQ=480 and BPM=120. This means the clock ticks 480 * 120 / 60 = 960 times per second.

Every note's start time and end time are quantized to this grid:

evs.push({t:Math.round(n.startSec*tps), kind:'on', ...})

evs.push({t:Math.round((n.startSec+n.durSec)*tps), kind:'off', ...})

The Math.round call means each event is snapped to the nearest tick. If a note actually started at a time that falls between two ticks, it gets pushed to whichever tick is closer. The original audio's micro-timing — the human push and pull against the beat, the slight rushing of a melody, the laid-back feel of a groove — is flattened onto a uniform grid.

Furthermore, the detection itself introduces timing quantization. The detectNotes function steps through audio in hops of 0.023 * sampleRate samples with a window of 0.046 * sampleRate samples. This means pitch is sampled at discrete intervals, not continuously. A note that starts between two hops will be detected at the next hop position, not at its true onset. The note's reported start time is the hop boundary, not the exact moment the sound began.

Pitch bend and slides: flattened to the nearest semitone

The detector maps each frequency to a MIDI note number using Math.round(69 + 12 * Math.log2(f / 440)). The Math.round call snaps the frequency to the nearest integer MIDI note — the nearest semitone on a piano keyboard.

This means any pitch movement within a semitone is lost:

• Vibrato — a singer oscillating slightly above and below a center pitch — becomes a single held note, because the oscillation stays within the ±1 semitone merge threshold and does not cross into a different note number.
• Slides and portamento — a guitarist sliding from one fret to another, or a singer sliding between two pitches — are represented as two discrete notes, not a continuous pitch movement. The transition between them disappears.
• Quarter tones and microtonal pitches — common in some vocal traditions and non-Western music — are snapped to the nearest semitone in the 12-tone equal temperament scale.

MIDI does support pitch bend as a continuous controller (Pitch Wheel), but the converter does not write pitch bend events. The output contains only note-on and note-off messages. Any pitch movement that happened inside a note is absent from the file.

Additionally, consecutive detection frames with the same pitch (within ±1 semitone) are merged into a single note object: if(Math.abs(midi-active.midi)<=1){ active.endSample = s+HOP; }. This merge rule means that if a note drifts slightly in pitch without crossing into the next semitone, the drift is invisible in the output. One long note appears, regardless of how much the pitch wavered inside it.

Articulation: staccato and legato are not preserved

MIDI can represent articulation through gaps between notes (staccato = short note with a gap before the next; legato = notes touch or overlap). But the converter's output depends entirely on what the detector found, and the detection pipeline introduces its own artifacts:

• Minimum duration filter. Notes shorter than 0.05 seconds (enforced as if(durSec >= 0.05) out.push(...)) are removed. Quick grace notes, rapid trills, or staccato spikes that fall below this threshold are deleted entirely. They do not appear in the MIDI file at all.
• Hop-based grouping. Notes are detected at hop intervals of 0.023 * sampleRate. The exact boundary between one note and the next depends on where the hop falls relative to the actual note transition. Two notes played legato (no gap) may appear as two separate notes with a tiny gap, or as one merged note — depending on whether the detector caught the transition or not.
• No sustain pedal data. A pianist holding the sustain pedal creates a wash of overlapping notes. The monophonic detector picks up the loudest pitch in each window and ignores the rest. The resulting MIDI will have a simplified sequence that does not reflect what the pedal was doing.

Timbre and tone: MIDI has no concept of sound

MIDI is a performance protocol, not an audio format. A MIDI note says "play note C4" — it does not say "play it with a warm cello tone" or "play it with a distorted electric guitar." The instrument sound depends entirely on the synthesizer or sampler that plays back the MIDI file.

When you convert a saxophone solo to MIDI, the output contains the pitch sequence. If you play it back through a piano synth, it sounds like a piano playing those pitches. The timbre of the saxophone — the breathiness, the growl, the reed quality — is not in the MIDI data and cannot be. MIDI stores note events. It does not store audio characteristics.

This is true of all MP3 to MIDI converters, not just this one. The MIDI format itself does not have a field for "this note was played on a Stratocaster with the neck pickup." You assign the instrument after conversion, in your DAW or notation software.

What the MIDI file does contain

After listing everything that is lost, here is what the converted MIDI file does contain — the things you can rely on:

How to add expression back in your DAW

Since the MIDI file gives you pitch and timing but nothing else, here is what you need to do manually to make the output sound musical:

1. Edit velocity per note

Open the piano roll in your DAW (Ableton, FL Studio, Logic, Cubase, Studio One, Reaper, Bitwig — all support this). Select each note and adjust the velocity value. Listen to your original MP3 alongside the MIDI playback and match the dynamic contour. Accented notes get higher velocity; ghost notes get lower velocity. This is the single biggest improvement you can make — going from uniform velocity 90 to a varied velocity curve transforms the feel of the MIDI.

2. Add pitch bend where needed

If the original performance had slides, bends, or vibrato, draw pitch bend automation in your DAW's piano roll. MIDI Pitch Wheel events let you bend notes up or down continuously. This is how you restore a vocal slide or a guitar bend that the converter flattened to discrete semitone steps.

3. Adjust timing for human feel

The converter quantizes all timing to a grid at BPM=120. If your original audio was at a different tempo, or if the performance pushed and pulled against the beat, you need to adjust note positions manually. Some DAWs have "humanize" features that add slight random timing variation. You can also drag individual notes slightly off the grid to restore groove.

If the original audio was not at 120 BPM, the MIDI file will still play back at 120 BPM — the tempo is hardcoded in the SMF header as Math.round(60000000/120). Change the project tempo in your DAW to match the original recording's tempo before working with the MIDI.

4. Choose the right instrument

The MIDI file does not specify an instrument. Assign one that matches the character of your original recording. If you converted a vocal melody, try a lead synth, a piano, or a wind instrument patch. The right instrument choice can make a simple pitch sequence sound expressive even before you edit velocity and timing. You can also use MIDI to WAV on this site to render the MIDI back to audio with whatever instrument you assign.

5. Trim and clean up

Run through the detected-note list and remove obvious false detections. The autocorrelation method can lock onto harmonics or produce spurious notes in noisy passages. Compare the note list against your original audio — if a note appears where you do not hear one, delete it. If a note is missing where you do hear one, add it manually. The converter's note list is a starting point, not a final result.

Why these limits are not bugs

The missing expression data is not a flaw in the code that could be patched. It is a consequence of two things:

1. The detection method. Autocorrelation finds one fundamental frequency per analysis window. It returns a single number — the detected pitch. There is no amplitude envelope, no spectral envelope, no harmonic content, and no phase information in the output. The detector answers one question per window: "what is the dominant pitch?" It does not answer "how loud is it," "what is the timbre," or "is the pitch bending."
2. The MIDI format. Standard MIDI Files store note-on events (pitch, velocity, time) and note-off events (pitch, time). Even if the detector extracted rich expression data from the audio, a basic SMF format 0 file with note-on/note-off events would not carry it. MIDI does support additional controllers — pitch bend, sustain pedal, expression, breath control — but writing those requires analyzing the audio for the corresponding information, which the autocorrelation pipeline does not do.

Tools that promise richer expression data from audio-to-MIDI conversion use different technology — neural networks that analyze spectro-temporal features, amplitude tracking, or models trained to map audio characteristics to MIDI controller data. These are fundamentally different systems from autocorrelation, and they require significant compute. The free, browser-based converter on this site uses autocorrelation because it runs on your device's CPU in real time, without a server, without a login, and without cost.

What to do with the MIDI you get

The converted MIDI file is a skeleton — pitch and timing, nothing else. That skeleton is still useful:

• As a starting point for production. Import the MIDI into your DAW, assign an instrument, and edit velocity, timing, and pitch bend until it matches your vision. The pitch sequence is the hard part — the converter solved that. Expression is the creative part — that is yours.
• As a notation reference. Import the MIDI into MuseScore or another notation program to see the pitch sequence as sheet music. For more on the difference, see MP3 to MIDI vs sheet music.
• As a remix foundation. Take the melody, reassign the instrument, change the tempo, add your own expression data, and build a new arrangement around it.
• As a learning tool. See what notes the detector found, compare them to what you hear in the original, and train your ear to identify pitches. The detected-note list on the converter page shows each note's name, start time, and duration.

For more on what the converter does and does not detect, read about MP3 to MIDI accuracy and why MIDI cannot hear chords.