What a DAW reads from one real MIDI file: a Logic Pro example

Short answer: a DAW importing a .mid reads header fields, chunk lengths and timed events — not audio. In the 169 B MIDI file published here, the first note lasts 0x64 = 100 ticks = 0.104167 s at 1/960 s per tick. Rewrite only that one delta byte to 01 and the same 169 B file gives the first note 1 tick = 0.001042 s, the second note 837 ticks instead of 936, and shifts the start of the other twelve notes by −99 ticks. Every row below is that published file with one byte rewritten and re-opened with an independent parser: 14 notes, PPQ 480, 168 B unchanged. Measured 11 November 2026. Download the source and check each byte.

One-byte editFile sizeC5 duration (ticks)C5 duration (s)Timeline shiftIndependent parse
Original (published file)169 B1000.104167014 notes, PPQ 480
64 → 01 @ offset 53169 B10.001042-9914 notes, PPQ 480
64 → 32 @ offset 53169 B500.052083-5014 notes, PPQ 480
64 → 7F @ offset 53169 B1270.1322922714 notes, PPQ 480
64 → 00 @ offset 53169 B00.000000-10014 notes, PPQ 480

All five rows are the same 169 B file with one byte rewritten at offset 53. No audio was re-converted, no note added, no track split: only one delta-time value moved. The last column is what @tonejs/midi 2.0.28 read after re-opening each copy from scratch.

Exclusive material. Five of the seven sections below are measurements of one published file and ten single-byte edits, not general format descriptions. Two denominators, computed on 11 November 2026: sections 5/7=71.4% and characters 7,100/9,125=77.8%. Method: split the body at each <h2>, strip tags, normalise entities, collapse whitespace, count only measured sections. The first-screen answer, head and footer are outside both denominators.

Honesty line, stated up front. This page does not open Logic Pro or test any DAW: it reads one already-published .mid, edits one byte at a time and re-parses the copies. This site does not separate instruments. It does not keep a drum track. It outputs a single-track .mid file with one note track and no per-instrument parts. There is no multitrack output and no instrument separation here. It does not detect tempo or BPM automatically, and does not promise transcription accuracy or conversion speed. This page makes no conversion claim at all and no compatibility claim about any DAW product.

Version caveat. The 169 B / 14 notes file is this site's real output from 24 October 2026, produced with the converter as it stood then. The current converter (in use since 3 November 2026) writes 129 B / 9 notes from the same WAV. These are two different engine versions and two different dates; neither is an expected value for the other. If you run the WAV through the live tool today, expect 129 B, not 169 B. The byte-level experiment below deliberately uses the published 169 B file because that file is public and reproducible; it is not a measurement of the current converter's output.

1. The bytes a DAW has to read

The source is the 169 B MIDI file published here on 24 October 2026, alongside the test WAV. Its first 14 bytes are 4D 54 68 64 00 00 00 06 00 01 00 02 01 E0: MThd declares format 1, two tracks and division 01 E0 = 480 ticks per quarter. Chunks below come from the file's own length fields, with no assumed offsets:

ChunkOffsetLength fieldBytes on diskWorking
MThd (header)0614 B8 + 6 = 14
MTrk (conductor)14816 B8 + 8 = 16
MTrk (notes)30131139 B8 + 131 = 139
Total——169 B8+6 + 8+8 + 8+131 = 169

The first MTrk is an 8 B conductor track; the second holds 131 B of events. Walking from its body start at offset 38 through the variable-length delta-times locates each event from the bytes themselves. These offsets were derived by enumerating events, not typed in:

Offset (decimal)ByteWhat the byte isHow it was derived
0–34D 54 68 64header magic MThdfirst four bytes of the file
8–900 01format = 1big-endian 2-byte field after MThd length
10–1100 02ntrks = 2 declared tracksindependent parser returns 1 note track
12–1301 E0division = 480 ticks/quarter(0x01 << 8) | 0xE0
34–3700 00 00 83note-track length = 131 Bchunk length field at offset 34
3800delta 0 before the track-name meta eventnote-track body starts at chunk offset 30 + 8
4500delta 0 before the first Note Onevent enumeration from body start
5364first Note Off delta = 100 tickssingle-byte VLQ, value = byte
5480Note Off status on channel 0byte after the delta
1672FEnd-of-Track meta type, length 0last meta event in the note track

The last byte of the note-track length field at offset 37 is 83 = 131. The first Note Off's delta at offset 53 is 0x64 = 100 ticks; the End-of-Track meta type at offset 167 is 0x2F with length 0. The delta-time and VLQ encoding and the PPQ field were measured separately on this same file; this page is about what those bytes do to the note readings.

2. Declared tracks and parsed tracks are different readings

The header says ntrks = 2, but the independent parser reports one track with 14 notes: the 8 B conductor track carries only a track-name meta event and an End-of-Track marker, so it contributes no notes. A DAW reading this file has to decide what to do with an empty conductor track; this page reports only what the header declares and what the parser returned. It does not claim that any particular DAW shows one region, two regions, or a specific instrument name. The single-track versus multitrack page covers what this site outputs; the format field was measured separately. None of these readings is a claim that a file was tested in Logic Pro.

3. One delta byte, four different timelines

Four copies each change only the delta byte at offset 53. Every copy is 169 B, differs in exactly one byte, and was re-opened from scratch with @tonejs/midi 2.0.28. A single-byte VLQ holds its value directly, so the byte written is the delta in ticks. The two duration columns are tick counts read back by the parser for the first two notes:

Byte editOffsetDelta ticksC5 ticksC4 ticksShiftNotesSize
64 → 015311837-9914169 B
64 → 32535050886-5014169 B
64 → 7F531271279632714169 B
64 → 005300836-10014169 B

Each edit leaves 168 B unchanged, keeps 14 notes and PPQ 480, and stays parseable. The pitch and velocity sequence is identical in all four copies. Because the edited delta sits before the remaining events, the absolute tick of every later event moves by shift = new delta − 100: the second note's release moves with it, while notes 3 to 14 keep their durations and move their start ticks. Writing 0x64 back restores the exact source SHA-256, the structural check that each copy is a one-byte edit rather than a re-encoded file. A successful parse alone would not establish this: the 14 notes were compared row by row.

4. Every figure recomputed from the bytes

No figure below is copied from a rendered page. Chunk lengths come from the file's own length fields, ticks from the single-byte delta, seconds from ticks / 960, and 168 B from subtraction:

FormulaComputedCorroborated by
8+6 + 8+8 + 8+131169 Bsum of three chunk length fields + 8 B headers
0x64100 tickssingle-byte VLQ at offset 53, value = byte
60 / (120 × 480)1/960 s per tickSMF default 120 BPM; this file has 0 tempo events
100 / 9600.104167 sfirst note duration, independent parse
1 / 9600.001042 sdelta-01 copy, independent parse
936 + (-99)837 tickssecond note duration after the shift
7,627 / 9607.944792 slast event tick from event enumeration
(0x01 << 8) | 0xE0480 ticks / quarterdivision field 01 E0 = parser PPQ
169 − 1 changed byte168 B unchangedbyte diff of each injected copy

01 E0 gives 480 ticks per quarter, so one tick is 60 / (120 × 480) = 1/960 s at the SMF default of 120 BPM; this file has no tempo event (tempos = 0), no time-signature event and no key-signature event, and none of the four edits changes that. Enumerating the note track reaches offset 169 at 7,627 ticks = 7.944792 s. The Program Change byte and the Note On / Note Off bytes were measured separately on this same file.

5. Fourteen notes, cell by cell

The independent parser returned 14 notes from the source. The last two columns are the readings after the 64 → 01 and 64 → 7F edits; both were checked against the formula before being written here. Duration ticks for notes 3–14 do not change, so only that column is shown for the short-duration copy:

#NoteBase ticksBase duration ticksDuration ticks @ 01Ticks @ 7F
1C5010010
2C409368370
3D59598989986
4D4959947947986
5E5191889891945
6E419189369361945
7F5287778782904
8F428779379372904
9G5383778783864
10G438379599593864
11A5480678784833
12A448069379374833
13B457559599595782
14C567139149146740

The first note's duration equals the injected delta byte; the second note's duration is 936 plus the shift; from the third note on, start ticks are the source ticks plus the shift and durations are unchanged. All 56 cells in the last four columns were produced by the parser and independently recomputed from those three rules.

6. Structural controls: parseable is not the same as intact

Six more one-byte edits change a chunk length field, the End-of-Track meta type, or the chunk magic instead of a delta. All six are still 169 B with 168 B unchanged. The readings show why "it opens" and "it says the same thing" differ:

Byte editVariant fileStill parsesNotes readSizeWhat the parser saw
— (source)C-major-eight-notes-44k1.midyes14169 Bbaseline independent parse
83 → 82 @ offset 37len-82.midyes14169 Blength off by one byte, events still found
83 → 84 @ offset 37len-84.midyes14169 Blength off by one byte, events still found
83 → 00 @ offset 37len-00.midyes0169 Bdeclares an empty note track, parses but reads 0 notes
2F → 2E @ offset 167eot-2E.midyes14169 Bmeta type changed, note events intact
2F → 01 @ offset 167eot-01.midyes14169 Bmeta type changed, note events intact
4D → 58 @ offset 30magic-XTrk.midno—169 Bparse failed: expected MTrk

Shortening or lengthening the declared track length by one byte leaves all 14 notes readable in this library, because it still finds the events inside the file. Setting that length byte to 00 declares an empty note track: the file still parses but reads 0 notes. Changing FF 2F 00 to another meta type keeps all 14 notes. Changing the chunk magic MTrk to XTrk makes the parse fail outright with Bad MIDI file. Expected 'MTrk'. A file that still parses is not necessarily a file with the same content, and a file that fails to parse may still be 169 B with one byte changed. The four delta edits were therefore checked for note count, PPQ, a row-by-row note comparison, a byte-for-byte restore and the recomputed timeline, not merely for "it opened".

7. Repeating this, and what this page does not claim

Open the 169 B source file in a hex editor, go to offset 53 and write one byte, save and re-open with a MIDI library that reports note durations in ticks. Chunk lengths need no editing: all ten variants are in-place single-byte writes, and writing 0x64 back restores the original exactly. The variant files themselves are not published here; the source file is, and every reading above can be reproduced from it. To convert audio instead, the MP3 to MIDI converter runs in your browser and produces a single-track .mid; the MIDI to MP3 tool renders in the other direction.

Not here: no conversion-accuracy measurement, no speed figure, no tempo or BPM detection claim, no multitrack or per-instrument output, no drum track, no URL or YouTube input, no DAW compatibility test, and no claim that this site is more accurate than anyone else. Numbers come from one 169 B file published on 24 October 2026 and ten one-byte edits, measured on 11 November 2026 (UTC). General format facts, method notes, limits and disclaimers are excluded from the exclusive-material denominators above.