Changes

This file contains 64 records of 24 bytes each, they correspond to format stores the 64 WM* fieldsstandard MIDI messages (ie, but they work in the opposite direction. Each 24 byte record contains 2 scenarios, which are 12 status bytes with appropriate data bytes )plus a piecetime-stamp for each message (ie, and indicated by the second parameter. Each scenario contains the Field Id for the field a series of bytes that it should jump represent how many clock pulsesto, this is at offset 0x6wait before "playing" the event). For instanceThe format also allows saving information about tempo, when walking into North Coreltime and key signatures, there are two possible fields that it can jump to; if you fail the Corel Train missionnames of tracks and patterns, it will jump to ncorel2 map instead of ncorel. The and other data in this record is unknown, but does contains coordinates within the field to which your character will be initiatedinformation typicallyneeded by a sequencer. For instance, the Chocobo Farm One SMF can store information for numerous patterns and tracks so that anysequencer can be entered from preserve these structures when loading the bottom or from the side, depending on certain flags set within your file game save.

Offset <B><FONT COLOR=RED>NOTE:</FONT></B> A <B>track</B> usually is analogous to scenario record = (Field Table Id) * 24 + one musical part,such as a Trumpet part. A <B>pattern</B> would be analogous to all of the musical parts (Scenario * 12ie,Trumpet, Drums, Piano, etc) Length = ALWAYS 12 bytesfor one song.

Another note The format was designed to be generic so that the most important data can be read by allsequencers. Think of a MIDI file as a musical version of an ASCII text file (exceptthat the MIDI file contains binary data), and the various sequencer programs as text editorsall capable of reading that file. But, unlike ASCII, MIDI file format saves data in <B>chunks</B>(ie, groups of bytes preceded by an ID and size) which can be parsed, loaded, skipped, etc.Therefore, SMF format is flexible enough for a particular sequencer to storeits own proprietary, "extra" data in such a way that another sequencer won't be confused whenloading the file and can safely ignore this extra stuff that it doesn't need.For example, maybe a sequencer wants to save a "flag byte"that indicates whether the user has turned on an audible metronome click. The sequencer can savethis flag byte in such a way that another sequencer can skip this byte withouthaving to understand what that byte is for. In the future, the SMF format can also beextended to include new "official" chunks that all sequencer programs may elect to load and use.This can be done without making old data files obsolete, nor making old sequencers no longerable to load the new files. So, the format is designed to beextensible in a backwardly compatible way. Of course, SMF files may be used by other MIDI software than just sequencers.Since SMF files can store any and all types of MIDI messages, including System Exclusivemessages, they may be used to store/load data by all kinds of MIDI software, such as a PatchEditor that wants to save some System Exclusive messages it received from a MIDI module. (The"timestamp" for each message may be irrelevant to such a Patch Editor. But it's easilyignored for programs that don't really need it). In conclusion, any software that saves or loads MIDI data should use SMF format for its datafiles. == Chunks == Data is always saved within a <B>chunk</B>. There can be many chunks inside of a MIDI file. Each chunk can be a different size (and likely will be). A chunk's size is how many (8-bit)bytes are contained in the chunk. The data bytes in a chunk are typically related in some way. For example, all of the bytes in one chunk may be for one particular sequencer track. The bytes for another sequencer track may be put ina different chunk. So, a chunk is simply a group of related bytes. Each chunk must begin with a 4 character (ie, 4 ascii bytes) <B>ID</B> which tells what "type"of chunk this is. The next 4 bytes must form a 32-bit length (ie, size) of the chunk. <U>All chunks must begin with these two fields</U> (ie, 8 bytes), which are referred to as the<B>chunk header</B>. Here's what a chunk's header looks like if you defined it in C:<pre>struct CHUNK_HEADER{ char ID[4]; unsigned long Length; };</pre><B><FONT COLOR=RED>NOTE:</FONT></B> The <B>Length</B> does not include the 8 byte chunkheader. It simply tells you how many bytes of interestdata are in the chunk <U>following this header</U>. And here's an example chunk header (with bytes expressed in hex) if you examined it with a hex editor: As mentioned 4D 54 68 64 00 00 00 06 Note that the first 4 bytes make up the ascii ID of <B>MThd</B> (ie, the first fourbytes are the ascii values for 'M', 'T', 'h', and 'd'). The next 4 bytes tell us that there are 64 entries shouldbe 6 more data bytes in FIELDthe chunk (and after that we should find the next chunk header or the endof the file).TBL === MThd Chunk === The MThd header has an ID of <B>MThd</B>, and a Length of <B>6</B>. Let's examine the 6 data bytes (which correspond follow the MThd header) in an MThd chunk. The first two data bytes tell the <B>Format</B> (which I prefer to call "type").There are actually 3 different types (ie, formats) of MIDI files. A type of 0 means that the filecontains one single track containing midi data on possibly all 16 midi channels. If your sequencersorts/stores all of its midi data in one single block of memory with the 64 WM fieldsdata in the order that it's"played", then it should read/write this type. As knownA type of 1 means that the file contains one ormore simultaneous (ie, when transitioning all start from an assumed time of 0) tracks, perhaps each on a single midichannel. Together, all of these tracks are considered one sequence or pattern. If yoursequencer separates its midi data (i.e. tracks) into different blocks of memory but plays them backsimultaneously (ie, as one "pattern"), it will read/write this type. A type of 2 means that thefile contains one or more sequentially independant single-track patterns. If your sequencerseparates its midi data into different blocks of memory, but plays only one block at a time (ie,each block is considered a different "excerpt" or "song"), then it will read/write this type. The next 2 bytes tell how many tracks are stored in the file, <B>NumTracks</B>. Of course,for format type 0, this is always 1. For the other 2 types, there can be numerous tracks. The last two bytes indicate how many Pulses (i.e. clocks) Per Quarter Note (abbreviated as PPQN) resolution the time-stamps are based upon, <B>Division</B>. For example, if your sequencer has 96 ppqn, this field maps would be (in hex): 00 60 <B><FONT COLOR=RED>NOTE:</FONT></B> The 4 bytes that make up the <B>Length</B> are stored in (Motorola) "Big Endian" byte order, not (Intel) "Little Endian" reverse byte order. (ie, The 06 is the fourth byte insteadof the first of the four). In fact, all MIDI files begin with the above <B>MThd header</B> (and that's how you know that it'sa MIDI file). Alternately, if the first byte of Division is negative, then this represents the divisionof a second that the time-stamps are based upon. The first byte will be -24, -25, -29, or -30,corresponding to the world map4 SMPTE standards representing frames per second. The second byte (apositive number) is the resolution within a frame (ie, subframe). Typical values may be 4 (MIDITime Code), 8, 10, 80 (SMPTE bit resolution), or 100. You can specify millisecond-based timing by the data bytes of -25 and 40 subframes. Here's what an MThd chunk looks like if you defined it in C: <pre>struct MTHD_CHUNK{ /* Here's the 8 byte header that all chunks must have */ char ID[4]; /* This will be 'M','T','h', 'd' */ unsigned long Length; /* This will be 6 */  /* Here are the game uses 6 bytes */ unsigned short Format; unsigned short NumTracks; unsigned short Division;};</pre> And here's an example of a complete MThd chunk (with header) if you examined it in a hex editor:<pre>4D 54 68 64 dummy MThd ID00 00 00 06 Length of the MThd chunk is always 6.00 01 The Format type is 1.00 02 There are 2 MTrk chunks in this file.E7 28 Each increment of delta-time represents a millisecond.</pre> === MTrk Chunk ===After the MThd chunk, you should find an <B>MTrk chunk</B>, as this is the only othercurrently defined chunk. (If you find some other chunk ID, it must be proprietary to some otherprogram, so skip it by ignoring the following data bytes indicated by the chunk'sLength). An MTrk chunk contains all of the midi data (with timing bytes), plus optional non-midi datafor <U>one track</U>. Obviously, you should encounter as many MTrk chunks in the file as theMThd chunk's NumTracks field indicated. The MTrk header begins with the ID of <b>MTrk</B>, followed by the Length (ie, number of data bytes for this track). The Length will likely be different for each track. (After all, a track containing the violin part for a Bach concerto will likely contain more data than a track containing a simple 2 bar drum beat). Here's what an MTrk chunk looks like if you defined it in C:<pre>struct MTRK_CHUNK{ /* Here's the 8 byte header that all chunks must have */ char ID[4]; /* This will be 'M','T','r','k' */ unsigned long Length; /* This will be the actual size of Data[] */  /* Here are the data bytes */ unsigned char Data[]; /* Its actual size is Data[Length] */};</pre>  ==== Variable Quantities ====Think of a track in the MIDI file in the same way that you normally think of a track in asequencer. A sequencer track contains a series of <B>events</B>. For example, the firstevent in the track may be to sound a middle C note. The second event may be to sound theE above middle C. These two events may both happen at the same time. The third event maybe to release the middle C note. This event may happen a few musical beats after the firsttwo events (ie, the middle C note is held down for a few musical beats). Each event has a"time" when it must occur, and the events are arranged within a "chunk" of memory in the orderthat they occur. In a MIDI file, an event's "time" precedes the data bytes that make up that event itself. Inother words, the bytes that make up the event's time-stamp come first. A given event'stime-stamp is referenced from the previous event. For example, if the first event occurs 4 clocksafter the start of play, then its "delta-time" is 04. If the next event occurs simultaneously withthat first event, its time is 00. So, a delta-time is the duration (in clocks) between an eventand the preceding event. <B><FONT COLOR=RED>NOTE:</FONT></B> Since all tracks start with an assumed time of 0, the firstevent's delta-time is referenced from 0. A delta-type fields time is stored as a series of bytes which is called a <B>variable lengthquantity</B>. Only the first 7 bits of each byte is significant (right-justified; sort of like anASCII byte). So, if you have a 32-bit delta-time, you have to unpack it into a series of 7-bitbytes (ie, as if you were going to transmit it over midi in a SYSEX message). Of course, youwill have a variable number of bytes depending upon your delta-time. To indicate 64 different points which is thelast byte of the series, you leave bit #7 clear. In all of the preceding bytes, you set bit #7. So,if a delta-time is between 0-127, it can be represented as one byte. The largest delta-timeallowed is 0FFFFFFF, which translates to 4 bytes variable length. Here are examples of entry delta-times as 32-bit values, and the variable length quantities that they translate to: <pre> NUMBER VARIABLE QUANTITY00000000 0000000040 400000007F 7F00000080 81 0000002000 C0 0000003FFF FF 7F00004000 81 80 0000100000 C0 80 00001FFFFF FF FF 7F00200000 81 80 80 0008000000 C0 80 80 000FFFFFFF FF FF FF 7F</pre> Here are some C routines to read and write variable length quantities such as delta-times. With<B>WriteVarLen()</B>, you pass a 32-bit value (per coordinatesie, unsigned long) and it spits out the correctseries of bytes to a file. <B>ReadVarLen()</B> reads a series of bytes from a file until itreaches the world map last byte of a variable length quantity, and returns a 32-bit value. <pre>void WriteVarLen(register unsigned long value){ register unsigned long buffer; buffer = value & 0x7F;  while ( (value >>= 7) ) { buffer <<= 8; buffer |= (some (value & 0x7F) | 0x80); }  while (TRUE) { putc(buffer,outfile); if (buffer & 0x80) buffer >>= 8; else break; }} unsigned long ReadVarLen(){ register unsigned long value; register unsigned char c;  if ( (value = getc(infile)) & 0x80 ) { value &= 0x7F; do { value = (value << 7) + ((c = getc(infile)) & 0x7F); } while (c & 0x80); }  return(value);}</pre> <B><FONT COLOR=RED>NOTE:</FONT></B> The concept of variable length quantities (ie, breaking up alarge value into a series of bytes) is used with other fields in a MIDI file besides delta-times,as you'll see later. For those not writing in C, you may benefit from a psuedo-code explanation of the above routines. In pseudo-code, ReadVarLen() is: <OL><LI>Initialize the variable which are relative coordinates will hold the value. Set it to 0. We'llcall this variable 'result'.</LI><LI>Read the next byte of the Variable Length quantity from the MIDI file.</LI><LI>Shift all of the bits in 'result' 7 places to the left. (ie, Multiply 'result' by 128).</LI><LI>Logically OR 'result' with the byte that was read in, but first mask off bit #7of the byte. (ie, AND the byte with hexadecimal 7F before you OR with'result'. But make sure you save the original value of the byte for the testin the next step).</LI><LI>Test if bit #7 of the byte is set. (ie, Is the byte AND hexadecimal80 equal to hexadecimal 80)? If so, loop back to where step #2. Otherwise,you're done, and 'result' now has the appropriate value.</LI></OL> In pseudo code, WriteVarLen() could be: <OL><LI>Assume that you have a variable named 'result' whichcontains the value to write out as a Variable Length Quantity.</LI> <LI>Declare an array which can contain 4 numbers. We'll callthis variable 'array'. Initialize a variable named 'count' to 0.</LI><LI>Is 'result' less than 128? If so, skip to step #8.</LI><LI>Take the value 'result' AND with hexadecimal 7F, and ORwith hexadecimal 80, and store it in 'count' element of 'array'.(ie, The first time through the loop, this gets stored in the firstelement of 'array'). NOTE: Don't alter the value of 'result' itself.<LI>Increment 'count' by 1.</LI><LI>Shift all bits in 'result' 7 places to the right. (This can be done by dividing by 128).</LI><LI>Loop back to step #3.</LI><LI>Take the value 'result' AND with hexadecimal 7F, and storeit in 'count' element of 'array'.</LI><LI>Increment 'count' by 1.</LI><LI>Write out the values stored in 'array'. Start with the lastelement stored above, and finish with the first element stored.(ie, Write them out in reverse order so that the first element of'array' gets written to the MIDI file last were on ). NOTE: The variable'count' tells you how many total bytes to write. It also can beused as an index into the world maparray (if you subtract one from it, andkeep writing out bytes until it is -1).</LI></OL> ==== Events in an MTrk ==== An MTrk can contain MIDI events and non-MIDI events (ie, events that contain data such astempo settings, track names, etc). The first (1 to 4) byte(s)in an MTrk will be the first event's delta-time as a variable lengthquantity. The coordinates next data byte is actually the first byte of that event itself. I'll refer to this asthe event's <B>Status</B>. For MIDI events, this will be the actual MIDI Status byte(or the first midi data byte if running status). For example, if the byte is hex 90, then thisevent is a <B>Note-On</B> upon midi channel 0. If for example, the byte was hex 23, you'd have torecall the previous event's status (ie, midi running status). Obviously, the first MIDI event inthe MTrk <U>must</U> have a status byte. After a midi status byte comes its 1 or 2 data bytes(depending upon the status - some MIDI messages only have 1 subsequent data byte). After that you'll find the next event's delta time (as a variable quantity), etc. ---- <CENTER><FONT COLOR=RED><B>SYSEX events</B></FONT></CENTER> SYSEX (system exclusive) events (status = F0) are a special case because a SYSEX event canbe any length. After the F0 status (which is always stored -- no running status here), you'll findyet another series of variable length bytes. Combine them with ReadVarLen() and you'll come upwith a 32-bit value that tells you how many more bytes follow which make up this SYSEX event.This length doesn't include the F0 status. For example, consider the following SYSEX MIDI message: F0 7F 7F 04 01 7F 7F F7 This would be stored in a MIDI file as the following series of bytes (minus the delta-timebytes which would precede it transports ): F0 07 7F 7F 04 01 7F 7F F7 The 07 above is the variable length quantity (which happens to fit in just one byte for thisexample). It indicates that there are currently unknownseven, following bytes that comprise this SYSEX message. Really oddball midi units send a system exclusive message as a series of small "packets" (witha time delay inbetween transmission of each packet). The first packet begins with an F0, but itdoesn't end with an F7. The subsequent packets don't start with an F0 nor end with F7. The lastpacket doesn't start with an F0, but likely contained within FIELDdoes end with the F7. So, between the first packet's opening F0 andthe last packet's closing F7, there's 1 SYSEX message there. (Note: only extremely poor designs,such as the crap marketed by Casio exhibit such horrid behavior). Of course, since a delay isneeded inbetween each packet, you need to store each packet as a separate event with its owntime in the MTrk. Also, you need some way of knowing which events shouldn't begin with an F0(ie, all of them except the first packet). So, the MIDI file redefines a midi status of F7(normally used as an end mark for SYSEX packets) as a way to indicate an event that doesn'tbegin with F0. If such an event follows an F0 event, then it's assumed that the F7 event is thesecond "packet" of a series. In this context, it's referred to as a SYSEX CONTINUATION event.Just like the F0 type of event, it has a variable length followed by data bytes. On the otherhand, the F7 event could be used to store MIDI REALTIME or MIDI COMMON messages. In this case,after the variable length bytes, you should expect to find a MIDI Status byte of F1, F2, F3, F6,F8, FA, FB, FC, or FE. (Note that you wouldn't find any such bytes inside of a SYSEX CONTINUATIONevent).TBLWhen used in this manner, the F7 event is referred to as an ESCAPED event. It ----<CENTER><FONT COLOR=RED><B>Non-MIDI events</B></FONT></CENTER> A status of FF is also important reserved to note indicate a special non-MIDI event. (Note that FF is used in MIDIto mean "reset", so it wouldn't be all entry points map exactly that useful to store in a data file. Therefore, the MIDIfile arbitrarily redefines the use of this status). After the exit points; FF status byte is another byte that tells you what <B>Type</B> of non-MIDI event it is. It's sort of like a second status byte. Thenafter this byte is another byte(s -- a variable length quantity again) that tells how many moredata bytes follow in this event (ie, its Length). This Length doesn't include the FF, Typebyte, nor the Length byte. These special, non-MIDI events are called <B>Meta-Events</B>, andmost are optional unless otherwise noted. The section of this online book entitled "Meta-Events"lists the currently defined Meta-Events. Note that unless otherwise mentioned, more than one ofthese events can be placed in an MTrk (even the same Meta-Event) at any delta-time. (Just likeall midi events, Meta-Events have a delta-time from the previous event regardless of what typeof event that may be. So, when you leave Midgarcan freely intermix MIDI and Meta events). ==== Meta-Events in an MTrk ====----===== Sequence Number =====FF 00 02 <I><FONT COLOR=RED><B>ss ss</B></FONT></I> or... FF 00 00 This optional event must occur at the beginning of a MTrk (ie, before any non-zerodelta-times and before any midi events). It specifies the sequence number. The two data bytes<I><FONT COLOR=RED><B>ss ss</B></FONT></I>, are that number which corresponds to the <B>MIDICue</B> message. In a format 2 MIDI file, this number identifies each "pattern" (ie, you Mtrk) sothat a "song" sequence can use the MIDI Cue message to refer to patterns. If the <I><FONT COLOR=RED><B>ss ss</B></FONT></I> numbers are omitted (ie, the second formshown above), then the MTrk's location in map mds5_5 the file is used. (ie, The first MTrk chunk issequence number 0. The second MTrk is sequence number 1. Etc). In format 0 or 1, which contain only one "pattern" (even though format 1 containsseveral MTrks), this event is placed in only the first MTrk. So, a group of format 0 or 1 fileswith different sequence numbers can comprise a "song collection". There can be only one of these events per MTrk chunk in a Format 2. There can be only oneof these events in a Format 0 or 1, and it MAPJUMPs must be in the first MTrk.----===== Text =====FF 01 <I><FONT COLOR=GREEN><B>len</B></FONT></I> <I><FONT COLOR=RED><B>text</B></FONT></I> Any amount of text (amount of bytes = <I><FONT COLOR=GREEN><B>len</B></FONT></I>) for anypurpose. It's best to wm0put this event at the beginning of an MTrk. Although this text could beused for any purpose, there are other text-based Meta-Events for such things as orchestration,lyrics, track name, etc. This event is primarily used to add "comments" to a MIDI file which puts aprogram would be expected to ignore when loading that file. Note that <I><FONT COLOR=GREEN><B>len</B></FONT></I> could be a series of bytes since itis expressed as a variable length quantity.----===== Copyright =====FF 02 <I><FONT COLOR=GREEN><B>len</B></FONT></I> <I><FONT COLOR=RED><B>text</B></FONT></I> A copyright message. It's best to put this event at the beginning of an MTrk. Note that <I><FONT COLOR=GREEN><B>len</B></FONT></I> could be a series of bytes since itis expressed as a variable length quantity.----===== Sequence/Track Name =====FF 03 <I><FONT COLOR=GREEN><B>len</B></FONT></I> <I><FONT COLOR=RED><B>text</B></FONT></I> The name of the sequence or track. It's best to put this event at the beginning of anMTrk. Note that <I><FONT COLOR=GREEN><B>len</B></FONT></I> could be a series of bytes since itis expressed as a variable length quantity.----===== Instrument =====FF 04 <I><FONT COLOR=GREEN><B>len</B></FONT></I> <I><FONT COLOR=RED><B>text</B></FONT></I> The name of the instrument (ie, MIDI module) being used to play the track. This may bedifferent than the Sequence/Track Name. For example, maybe the name of your sequence (ie, Mtrk)is "Butterfly", but since the track is played upon a Roland S-770, you may also include anInstrument Name of "Roland S-770". It's best to put one (or more) of this event at the beginning of an MTrk to provide the userwith identification of what instrument(s) is playing the track. Usually, the instruments (ie,patches, tones, banks, etc) are setup on the audio devices via <B>MIDI Program Change</B>and <B>MIDI Bank Select Controller</B> events within the MTrk. So, this event exists merely toprovide the user with visual feedback of what instruments are used for a track. Note that <I><FONT COLOR=GREEN><B>len</B></FONT></I> could be a series of bytes since itis expressed as a variable length quantity.----===== Lyric =====FF 05 <I><FONT COLOR=GREEN><B>len</B></FONT></I> <I><FONT COLOR=RED><B>text</B></FONT></I> A song lyric which occurs on a given beat. A single LyricMetaEvent should contain only one syllable. Note that <I><FONT COLOR=GREEN><B>len</B></FONT></I> could be a series of bytes since itis expressed as a variable length quantity.----===== Marker ===== FF 06 <I><FONT COLOR=GREEN><B>len</B></FONT></I> <I><FONT COLOR=RED><B>text</B></FONT></I> The text for a marker which occurs on a given beat. Marker events might be used to denote a loop start and loop end (ie, where the sequence loops back to a previous event). Note that <I><FONT COLOR=GREEN><B>len</B></FONT></I> could be a series of bytes since itis expressed as a variable length quantity.----===== Cue Point=====FF 07 <I><FONT COLOR=GREEN><B>len</B></FONT></I> <I><FONT COLOR=RED><B>text</B></FONT></I> The text for a cue point which occurs on a given beat. A Cue Point might be used to denotewhere a WAVE (ie, sampled sound) file starts playing, for example, where the south side <I><FONT COLOR=RED><B>text</B></FONT></I> would be the WAVE's filename. Note that <I><FONT COLOR=GREEN><B>len</B></FONT></I> could be a series of bytes since itis expressed as a variable length quantity.----===== Program (Patch) Name =====FF 08 <I><FONT COLOR=GREEN><B>len</B></FONT></I> <I><FONT COLOR=RED><B>text</B></FONT></I> The name of Midgarthe program (ie, patch) used to play the MTrk. This may bedifferent than the Sequence/Track Name. For example, maybe the name of your sequence (ie, Mtrk)is "Butterfly", but when since the track is played upon an electric piano patch, you walk into Midgar from may also include aProgram Name of "ELECTRIC PIANO". Usually, the instruments (ie, patches, tones, banks, etc) are setup on the audio devices via<B>MIDI Program Change</B> and <B>MIDI Bank Select Controller</B> events within the world mapMTrk. So, this event exists merely to provide the user with visual feedback of what particular patch isused for a track. But it'll can also give a hint to intelligent software if patch remapping needsto be record 0 in FIELDdone.TBLFor example, which directs if the MIDI file was created on a non-General MIDI instrument, thenthe <B>MIDI Program Change</B> event will likely contain thewrong value when played on a General MIDI instrument. Intelligent software can use the game Program Name event to jump to mds5_5look up the correct value for the <B>MIDI Program Change</B> event. Note that <I><FONT COLOR=GREEN><B>len</B></FONT></I> could be a series of bytes since itis expressed as a variable length quantity.