home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
OS/2 Shareware BBS: Multimed
/
Multimed.zip
/
mididsm2.zip
/
mididsm.INF
(
.txt
)
< prev
next >
Wrap
OS/2 Help File
|
1995-08-02
|
83KB
|
2,394 lines
ΓòÉΓòÉΓòÉ 1. Introduction ΓòÉΓòÉΓòÉ
Please read this document in entirety. I took the time to make it explicit,
clear, and very useful. It took me longer to write it than it will ever take
you to read it. Therefore, you owe it to both of us to read it. OK?
MF_DSM is an OS/2 2.X command line application that converts a MIDI (sequencer)
file into a text file that can be viewed and edited with a text editor. In
other words, it "disassembles" the MIDI file into human readable "source code".
In this way, you can visually see the contents of the MIDI file; what notes are
being played, when the notes are being played, what other "events" are in the
file, etc. The display of this information is very musician friendly, allowing
one to easily change/augment/delete the contents simply by editing the text.
MF_ASM is an OS/2 2.X command line application that converts a text file such
as that produced by MF_DSM back into a MIDI file. In other words, it
"assembles" the "source code" into a MIDI file. Furthermore, MF_DSM recognizes
certain directives that tell it to further process chunks of the source code,
thus allowing one to easily transpose notes in a track, filter events (ie,
split apart tracks) by MIDI channels/note numbers/event types, remap note
numbers to new note numbers, remap events to new MIDI channels, adjust overall
volume of the notes in a track, and replace all note-offs with 0 velocity
note-ons. In addition to these "global" adjustments that can be easily applied
to an entire track of events, you also can edit each individual event of a
track in every possible way. You can change note number (ie, pitch), note
velocity (ie, volume), aftertouch amount, program change number, pitch wheel
amount, the MIDI channel of an event, controller numbers and amounts, the time
upon which the event occurs, and edit/add/delete system
exclusive/realtime/system messages. You can also edit/add/delete all of the
non-MIDI events that may be found in a MIDI file such as Tempo, Track and
Instrument names, Time and Key signatures, Cue Points and Markers, SMPTE time,
Lyrics, etc.
You could even create a text file from scratch, adding "events" as easily as
cutting and pasting text in a text editor, and then create a MIDI file from the
result using MF_ASM.
The MIDI Disassembler/Assembler offers a relatively straightforward way of
creating and editing MIDI files without requiring a sequencer program. It may
even offer editing features that aren't found in your sequencer software.
You ought to know a little about MIDI before editing any text files. I wrote
an OS/2 Online Book called "The MIDI Book" which can give you all of the
details about MIDI, as well as the MIDI File Format. The source produced by
MF_DSM is formatted using "musical terminology" wherever possible, so you don't
have to know about hexadecimal numbering and nitty gritty details like that,
but for more involved editing, you may need to reference the MIDI
specification.
Version 1.1 corrects bugs related to Unknown Chunks and the "Hold Pd" and "Soft
Pd" controllers (which are now "HoldPd" and "SoftPd". 1.1 also knows about
"Bank Switch" controller. Version 1.2 corrects bugs in interchanging the
coarse and fine NRPN controllers, adds the RPN controllers and All Sound Off
controller, and uses GENMIDI.DLL.
Some of the words in this manual are highlighted in bold text, such as
Handshake. These are words that refer to MF_ASM "keywords" or fields that are
part of the source code text file. Other words are in colored text such as
Channel Pressure. These refer to MIDI messages (ie, data). Underlined words,
such as Pitch Wheel, refer to hardware, such as if I was referring to the Pitch
Wheel on your MIDI unit. Words that are in colored text such as Read This are
meant to be emphasized. Words in italics refer to concepts, such as track.
ΓòÉΓòÉΓòÉ 2. Copyright ΓòÉΓòÉΓòÉ
MF_DSM, MF_ASM, MIDIFILE.DLL, GENMIDI.DLL and this manual are all copyright
1995 by Jeff Glatt. These items are freely distributable as long as no
internal modifications are made to the items, and copyright messages are left
intact. There are no pagan user fees, surreptitious financial charges, or
other devious capitalist trickery associated with the use of these files.
There are no warranties of any kind with this software. If swallowed, induce
vomiting immediately (by contemplating the aesthetics of Windows).
I can be contacted at:
6 Sycamore Drive East
New Hartford, NY 13413
(315) 735-5350
ΓòÉΓòÉΓòÉ 3. Invoking MF_DSM and MF_ASM ΓòÉΓòÉΓòÉ
MF_DSM and MF_ASM are both used from an OS/2 Command Prompt (window or
full-screen). Each takes arguments (ie, additional text after the program
name) when run.
The syntax for MF_DSM is:
MF_DSM midifilename [/I] [/PXXX] [/Otextfilename]
midifilename is the name of the MIDI file that you wish to convert into a text
source code file. The other 3 args are optional. The /I option produces only
a synopsis of the MIDI file contents, rather than creating a text file
containing info on every event in the MIDI file. Such a synopsis is only good
for reference (ie, gives you a quick overview of what's in the MIDI file) and
can't be assembled back into a MIDI file. Omit this option when you want to
create "source code" of a MIDI file. The /O option allows the info to be saved
to a file on disk so that you can edit it and later assemble it. The filename
must immediately follow the /O. Without this option, MF_DSM simply lists the
source code to the display, and doesn't save it. The /P option allows you to
override the MIDI file's inherent Division (which affects the way that the
time-stamps are calculated) where XXX is the desired Division (if negative,
then SMPTE times may be forced). If any errors occur in reading the MIDI file,
an appropriate message will be displayed.
The syntax for MF_ASM is:
MF_ASM textfilename [midifilename]
textfilename is the name of the text source code file that you wish to convert
back into a MIDI file. The other arg is optional. This second arg is the name
of the MIDI file to produce. If you don't supply this second arg, it defaults
to the textfilename (minus any extension), with the extension .mid added to it.
If any errors occur in creating the MIDI file, an appropriate message will be
displayed.
Both utilities require that the MIDIFILE.DLL and GENMIDI.DLL files be in some
directory along the LIBPATH as specified in config.sys file. These are dynamic
link libraries I wrote which can be used by C programmers to simplify reading,
writing and using MIDI files in their applications. The documentation and
examples for such are also available separately.
ΓòÉΓòÉΓòÉ 4. Disassembly Format ΓòÉΓòÉΓòÉ
Disassembly is the process of taking a MIDI file (ie, a binary data file) and
turning it into a text file (ie, human readable "source code"). MF_DSM does
this.
A MIDI file is made up of a series of musical events such as a note-on (ie, a
musician has started sounding a note on a MIDI controller). The MIDI file
time-stamps each event so that a sequencer will know when to play it. Some of
the events are actual MIDI events, and others are META events that don't get
output of a MIDI jack but which the sequencer uses for control of playback,
such as a Tempo event.
ΓòÉΓòÉΓòÉ 4.1. MThd Header line ΓòÉΓòÉΓòÉ
Upon the very first line of the source code, MF_DSM displays the overall
parameters of the MIDI file. This line begins with the text MThd to indicate
that the file is a MIDI file. You should never alter the MThd "ID". The MThd
header line must precede all track data (although comment lines may be placed
ahead of it), and must start with MThd in order to mark the start of your
source code.
Next, is the Format of the MIDI file. All MIDI files are either format 0,
1, or 2. Format 0 files have only 1 track. All of the data will be in that 1
track. Think of that track as a complete "song" or "pattern". Sequencers that
prefer data to be lumped together into one chunk of memory, in the order that
the events will be played, often use this format. Format 1 and 2 can have
numerous tracks of data. The tracks of a Format 1 are equivalent to the tracks
of a single "pattern" in a sequencer which has multiple tracks. In other
words, you might have a track for the drums, and a track for the piano, etc,
and all of these tracks can play simultaneously, adding up to a complete song.
The very first track in Format 1 usually contains only timing events such as
Tempo events. It may also have non-MIDI events such as Time Signature, but it
will usually not have any MIDI (ie, note) data. This is often referred to as
the tempo map track. Sequencers that prefer to separate the musical
performance into multiple tracks (usually so that the musician can better
isolate and edit specific musical parts) often use this format. The Format 2
is like a bunch of Format 0 files stuck into one MIDI file. Each track of the
Format 2 contains all of the data for one "song" or "pattern", but the MIDI
file contains many songs. Devices that can load multiple songs or patterns
(such a drum machine) often use this format.
The next, overall parameter is the # of tracks in the MIDI file. For
Format 0, this is always 1.
The last, overall parameter is the Division. This is how the time-stamping
is referenced. Normally, this tells you what the clock resolution is of the
MIDI file in terms of how many clocks are in a quarter note (ie, PPQN). For
example, 96 means that the sequencer ticks off 96 hardware clock pulses for
every quarter note. If Division is specified in terms of SMPTE rate, then
Division will be two numbers, the first being -24, -25, -29, or -30,
corresponding to the 4 SMPTE standards representing frames per second. The
second number (a positive number) is the resolution within a frame (ie,
subframe resolution). Typical values may be 4 (MIDI Time Code), 8, 10, 80
(SMPTE bit resolution), or 100. The two numbers are separated with a /
character. For example, millisecond-based timing would be specified as -25/40
(25 FPS with 40 subframes).
The Format, # of Tracks, and Division fields must be separated with a |
character (ie, above the ENTER key). This character is used throughout the
source code to separate fields on a line. Here's an example of an MThd header
line:
MThd | Format=1 | # of Tracks=2 | Division=96
Note that there are 4 fields. The | may be optionally omitted after the
last field (as it is here for Division).
The = sign is most often used to assign a value to the field. The field's
name is to the left of the = sign, and the value is on the right. For example,
the name of the second field above is Format. (The MThd is the first field
even though this isn't a field that can be assigned a value). It has been
assigned a value of 1. Generally, you can add or subtract blank spaces
wherever you like. For example, this is the same as above:
MThd|Format=1|# of Tracks=2|Division=96
You can also add blank spaces at the beginning of the line (but don't put
other characters before the MThd). You can even put blank spaces before or
after the = sign that assigns a value to the field. The only exception to
adding blank spaces is in the field's name (if it has embedded spaces, like #
of Tracks does). In other words, don't type #ofTracks. Here's another legal
variation on formatting with blank spaces:
MThd | Format = 1 |# of Tracks=2 |Division= 96
As you can see, you have some liberty with the use of blank spaces.
Furthermore, capitalization is not sensitive in the field names. For
example, DIVISION is the same as division. So, you have some liberty with the
SHIFT key as well.
Finally, for most events, the order of most fields can be rearranged, and
some fields can even be omitted. There are some exceptions though. The first
field usually has a specific purpose, and for track data events, so does the
second field. So, the first and perhaps second can't be rearranged or omitted.
But, subsequent fields often can. For the MThd header line, the MThd field
must be first, but the Format, # of Tracks, and Division fields can be in any
order, as so:
MThd | # of Tracks=2 | Division=96 | Format=1
So too, can you omit one or all of those 2 fields, as so:
MThd | Division=96
If you omit any field, it automatically is set to a default value, which
for Format, # of Tracks, and Division, are the values 0, 1, and 192
respectively. So, the above example defaults to Format 0, 1 track with 96
PPQN.
You may change the values for the Format, # of Tracks, and Division fields
(but change them to sensible values). You should set # of Tracks to the number
of track headers that will be in your source. Otherwise, you'll end up not
writing out extra tracks, or create a malformed MIDI file. For Division, you
can optionally specify a SMPTE timing as described above.
ΓòÉΓòÉΓòÉ 4.2. Track Header line ΓòÉΓòÉΓòÉ
A MIDI file may have numerous tracks of data. MF_DSM first lists all of the
events in the first track, in the order that they are to be played. Then, all
of the events in the second track are listed, in the order that they are to be
played. This repeats for as many tracks as are in the MIDI file. The events
for the last track will be at the "bottom" of the text file. Generally, each
event of a track is displayed upon its own line to make it easy to distinguish
one from the other.
So, after the MThd header line, MF_DSM starts listing the first track. The
start of a track is always indicated by the words Track # followed by a number
telling which track it is (ie, 0 being the first track. Note that there may be
a Track Number event also in the track. That will be the track's real number.
The number on the track header line is only for your reference). After the
track number, MF_DSM fills up the remainder of that line with * characters just
to highlight where the data for the track begins. MF_ASM (the assembler)
doesn't require that these filler characters be present; but a line must start
with Track # in order to mark the start of a track's data. As usual, blank
space can precede the Track #, which itself can be typed in lower or upper
case. After the Track #, you can optionally place a | character followed by
more fields to be described later. Here's an example of the track header line
for the first track:
Track #0 ******************************************
You can place blank lines between the preceding MThd header line and the
Track header line. In fact, you can place blank lines anywhere in the source
file for improved readability.
ΓòÉΓòÉΓòÉ 4.3. An Event line ΓòÉΓòÉΓòÉ
After the Track header line is the track's first event, on its own line. The
first field of an event must be its Time. This describes the point at which
the event should be played. The second field (separated from the Time field
with a | character) must be a text description of the event's Type, such as a
On Note event type. Different event types may have further fields, each
separated from the next with the | character. These additional fields are
optional, and can usually be in any order. Usually, all of the fields must be
on one line. Therefore, the entire event is contained upon one line of text.
All events must have the Time and Event Type fields, in that order, and these
must be at the start of the line.
ΓòÉΓòÉΓòÉ 4.3.1. Time Field ΓòÉΓòÉΓòÉ
The Time field is the first field of an event. This indicates the point at
which the event should be played. The Time is expressed in terms of musical
bars (measures), beats, and clocks (fractions of a beat) at the current time
signature. (Note that MIDI files can have time signature changes, and the Time
field display reflects this). The field is displayed as:
Measure: Beat: Clock
In other words, for any event, you know what measure, beat, and subbeat it gets
played upon.
The first measure of a track is #1. The first beat in a measure is #1.
The first clock within a beat is 0. So, if an event occurs precisely upon the
3rd beat of the 4th measure, then its clock display is:
4: 3: 0
Note: You can use any non-numeric key to separate the measures, beats, and
clocks, including blank spaces. For example, if using the numeric
keypad, you might separate each field with a dot as so:
5.1.0
You can also add as many blank spaces between the measures, beats, and clocks
as desired, in order to line up the measures, beats, and clocks in the same
text columns as preceding and subsequent events.
The number of beats in a measure depends upon the current time signature. If
there is no time signature event in the MIDI file, then 4/4 time is assumed
(ie, 4 beats in a measure, and a quarter note is the beat).
The number of fractional divisions of a beat depend upon the MThd Division and
the current time signature. Division tells you how many subbeats are in a
quarter note. For example, if Division is 192, then that means that there are
192 clocks per quarter note. Since there are 2 eighth notes in a quarter note,
then there must be 192/2 clock subbeats in an eighth note (ie, 96 clocks).
There are 4 sixteenth notes in a quarter note, so each is 192/4 clocks (ie, 48
clocks) in each 16th note. It's best to make a chart based upon the Division,
which you can use to determine how many subbeats are in each musical note.
Here's the formula used:
quarter Division in each note
quarter note triplet Division/1.5 in each note
eighth Division/2 in each note
eighth note triplet Division/3 in each note
sixteenth Division/4 in each note
sixteenth note triplet Division/6 in each note
32nd note Division/8 in each note
32nd note triplet Division/12 in each note
Here's a list of the number of clocks in each type of note for 192 PPQN:
quarter 192
quarter note triplet 128
eighth 96
eighth note triplet 64
sixteenth 48
sixteenth note triplet 32
32nd note 24
32nd note triplet 16
For example, assume that a pattern is in 4/4. You want to set an event's Time
to the 3rd measure, second beat, on the 3rd sixteenth note of that beat.
Because you need to set the time to a fraction of a beat (i.e. the 3rd
sixteenth note of the beat), you need to specify a non-zero subbeat when
entering the time. The first sixteenth note (or the first of ANY group of
fractional beats) occurs right on the downbeat, so it would have a clock offset
of 0. The second sixteenth would have a clock offset of 48 (according to the
above chart). The third sixteenth would have a clock offset of 48+48. Of
course, the fourth sixteenth would have an offset of 48+48+48. So to set the
event upon the 3rd measure, second beat, 3rd sixteenth note would be:
3: 2: 96
For SMPTE Divisions, the Time field is not displayed as measure, beats, and
subbeats, but rather one number that is simply the clock ticks from the start
of the song upon which the event occurs. (The start of the song is at time 0).
So, if an event has a Time of 1, then it occurs 1 clock after the start of
playback.
The Time field is separated from the next field using the | character. So,
assuming 4/4, and you wish to place an event on the first measure, fourth beat,
second eighth note of that beat (ie, first eighth note is on the beat or at 0
subbeats, and the next is at 0+96):
1: 4: 96 |
ΓòÉΓòÉΓòÉ 4.3.2. Event Type Field ΓòÉΓòÉΓòÉ
The Event Type field is the second field of an event. This indicates what type
of event it is, for example, a Tempo event. So, a Tempo event would have the
text Tempo placed into the second field. The field must be ended with the |
character.
So, let's specify a Tempo event on the first measure, second beat (ie,
right on that beat) of the track. Here are the required Time and Event Type
fields, with separators:
1: 2: 0 | tempo |
Notice that I used blank space liberally. Also, I specified the Tempo type as
all lower caps. These are allowable options.
Now, it makes sense that you'd want to specify the tempo. It just so
happens that you can add fields to the Tempo event. One field, the BPM field,
can be assigned the tempo in quarter notes per minute. Here's how to specify a
tempo of 100 BPM at the start of a track (ie, measure 1, beat 1, 0 subbeats):
1: 1: 0 | tempo | BPM=100
The BPM field is optional. If you don't supply it, tempo defaults to 120 BPM.
Although the Time and Event Type fields must be specified for an event, and
both end with the | character, additional fields are optional. Additional
fields should also be separated with the | character, but the | is optional
after the last field. These rules of thumb apply to other event types as well.
Furthermore, remember that blank space and capitalization are optional.
So, you could write the above event as so:
1:1:0| TEMPO| bpm =100
The following sections list the defined Event Types. Each page contains one
event type, such as the Tempo event. The text that you type into the Event
Type field is listed (for example, Tempo). The additional, optional fields
that can be added are also listed. A description of what the event is used for
is included. Any particular deviations from the general rules of thumb for
specifying an event are described. Finally, an example of the event as it
might appear in a source code listing is given.
ΓòÉΓòÉΓòÉ 4.3.2.1. Off Note ΓòÉΓòÉΓòÉ
Type Off Note
Occurs when You release a note that you previously pressed down on the MIDI
unit (ie, cause the note to stop sounding).
Other Fields The MIDI channel upon which the note was broadcast is assigned
to the chan field. This will be 1 of 16 (ie, a number from 1 to
16). If you don't specify this field, it defaults to the same
channel as the preceding event type which can be assigned to a
channel (or channel 1 if no preceding event). In other words,
if the preceding event is an On Note with channel 2, and you
then follow it with an Off Note event omitting the chan field,
it defaults to channel 2.
The step of the 12 tone scale and octave that the note is (ie, C
3 is middle C) is assigned to the pitch field. Note that the
bottom 2 octaves of the allowed MIDI note range are -2 and -1.
The displays on some units count MIDI octaves from 0. If you
don't specify this field, it defaults to the same pitch as the
preceding event type which can be assigned a pitch (or C3 if no
such preceding event). In other words, if the preceding event
is an On Note of D#3, and you then follow it with an Off Note
event omitting the pitch field, it defaults to D#3. Also, note
that you use a lower case B (ie, b) to specify a flat. You can
use double sharps and flats. The note name, sharp or flat, and
octave components can be separated by blank spaces. For example
C3 is the same as C 3.
The velocity (ie, how quickly you release the key) is assigned
to the vol field. This will be from 0 to 127. If you don't
specify this field, it defaults to the same volume as the
preceding On Note or Off Note (or 64 if no such preceding
event). In other words, if the preceding event is an On Note
with vol=44, and you then follow it with an Off Note event
omitting the vol field, it defaults to 44.
Note: Some MIDI units transmit Note On events with 0 velocity
in lieu of Note Off events. Such events are represented
by the (Off) Note event type (ie, the "Off" is enclosed
in parenthesis)
Examples 1: 1: 0 | Off Note | chan=1 | pitch=Db2 | vol=76
1: 2: 0 | Off Note | pitch=E 3 | vol=76 <- same chan as
preceding event
2: 1: 0 | Off Note | vol=55 | chan=2 <- different order of
fields, pitch is E3
ΓòÉΓòÉΓòÉ 4.3.2.2. On Note ΓòÉΓòÉΓòÉ
Type On Note
Occurs when You press down (ie, trigger) a note on the MIDI unit (ie, cause
the note to sound).
Other Fields The MIDI channel upon which the note was broadcast is assigned
to the chan field. This will be 1 of 16 (ie, a number from 1 to
16). If you don't specify this field, it defaults to the same
channel as the preceding event type which can be assigned to a
channel (or channel 1 if no preceding event). In other words,
if the preceding event is an On Note with channel 2, and you
then follow it with an On Note event omitting the chan field, it
defaults to channel 2.
The step of the 12 tone scale and octave that the note is (ie, C
3 is middle C) is assigned to the pitch field. Note that the
bottom 2 octaves of the allowed MIDI note range are -2 and -1.
The displays on some units count MIDI octaves from 0. If you
don't specify this field, it defaults to the same pitch as the
preceding event type which can be assigned a pitch (or C3 if no
such preceding event). In other words, if the preceding event
is an Off Note of D#3, and you then follow it with an On Note
event omitting the pitch field, it defaults to D#3. Also, note
that you use a lower case B (ie, b) to specify a flat. You can
use double sharps and flats. The note name, sharp or flat, and
octave components can be separated by blank spaces. For example
C3 is the same as C 3.
The velocity (ie, how quickly you press down the key) is
assigned to the vol field. This will be from 1 to 127. Note
that 0 for a Note On volume really means that this is a Note off
event. If you want that, use the (Off) Note event. A Note on
event can't have a zero velocity, and if you specify that,
MF_ASM will automatically generate a velocity of 1. If you
don't specify this field, it defaults to the same volume as the
preceding On Note or Off Note (or 64 if no such preceding
event). In other words, if the preceding event is an On Note
with vol=44, and you then follow it with a On Note event
omitting the vol field, it defaults to 44.
Examples 1: 1: 0 | On Note | chan=16 | pitch=A#-1 | vol=127
1: 2: 0 | On Note | pitch=E 1 | vol=76 <- same chan as
preceding event
2: 1: 0 | On Note | vol=55 | chan=2 <- different order of
fields, pitch is E1
ΓòÉΓòÉΓòÉ 4.3.2.3. (Off) Note ΓòÉΓòÉΓòÉ
Type (Off) Note
Occurs when You release a note that you previously pressed down on the MIDI
unit (ie, cause the note to stop sounding).
Other Fields The MIDI channel upon which the note was broadcast is assigned
to the chan field. This will be 1 of 16 (ie, a number from 1 to
16). If you don't specify this field, it defaults to the same
channel as the preceding event type which can be assigned to a
channel (or channel 1 if no preceding event). In other words,
if the preceding event is an On Note with channel 2, and you
then follow it with an (Off) Note event omitting the chan field,
it defaults to channel 2.
The step of the 12 tone scale and octave that the note is (ie, C
3 is middle C) is assigned to the pitch field. Note that the
bottom 2 octaves of the allowed MIDI note range are -2 and -1.
The displays on some units count MIDI octaves from 0. If you
don't specify this field, it defaults to the same pitch as the
preceding event type which can be assigned a pitch (or C3 if no
such preceding event). In other words, if the preceding event
is an On Note of D#3, and you then follow it with an (Off) Note
event omitting the pitch field, it defaults to D#3. Also, note
that you use a lower case B (ie, b) to specify a flat. You can
use double sharps and flats. The note name, sharp or flat, and
octave components can be separated by blank spaces. For example
C3 is the same as C 3.
Note: This is essentially the same thing as an Off Note event,
except that it is often more efficient for broadcast over
MIDI to use this event in lieu of Off Note. The only
advantage of Off Note is that it has a velocity field,
which is useful only if your MIDI unit can make use of
key release velocity (many units ignore it).
Examples 1: 1: 0 | (Off) Note | chan=1 | pitch=Db2
1: 2: 0 | (Off) Note | pitch=E 3 <- same chan as preceding
event
ΓòÉΓòÉΓòÉ 4.3.2.4. Aftertouch ΓòÉΓòÉΓòÉ
Type Aftertouch
Occurs when You apply pressure to (ie, press down harder or softer on) the
keys of a MIDI keyboard. Or, aftertouch can be generated in
other ways by different controllers, such as a wind controller
measuring changes in wind pressure.
Other Fields The MIDI channel upon which the message was broadcast is
assigned to the chan field. This will be 1 of 16 (ie, a number
from 1 to 16). If you don't specify this field, it defaults to
the same channel as the preceding event type which can be
assigned to a channel (or channel 1 if no preceding event). In
other words, if the preceding event is an On Note with channel
2, and you then follow it with an Aftertouch event omitting the
chan field, it defaults to channel 2.
The step of the 12 tone scale and octave of the note that this
message affects is assigned to the pitch field. Note that the
bottom 2 octaves of the allowed MIDI note range are -2 and -1.
The displays on some units count MIDI octaves from 0. If you
don't specify this field, it defaults to the same pitch as the
preceding event type which can be assigned a pitch (or C3 if no
such preceding event). In other words, if the preceding event
is an On Note of D#3, and you then follow it with an Aftertouch
event omitting the pitch field, it defaults to D#3. Also, note
that you use a lower case B (ie, b) to specify a flat. You can
use double sharps and flats. The note name, sharp or flat, and
octave components can be separated by blank spaces. For example
C3 is the same as C 3.
The aftertouch amount is assigned to the press field. This will
be from 0 to 127. If omitted, it defaults to the same value as
any preceding Aftertouch event (or 0 if no such preceding
event).
Examples 1: 1: 0 | Aftertouch | chan=16 | pitch=A2 | press=127
1: 2: 0 | Aftertouch | press=76 <- same chan and pitch as
preceding event
2: 1: 0 | Aftertouch | press=55 | chan=1 <- different order of
fields, pitch is E1
ΓòÉΓòÉΓòÉ 4.3.2.5. Controller ΓòÉΓòÉΓòÉ
Type Controller
Occurs when You operate one of 128 different controllers.
Other Fields The MIDI channel upon which the message was broadcast is
assigned to the chan field. This will be 1 of 16 (ie, a number
from 1 to 16). If you don't specify this field, it defaults to
the same channel as the preceding event type which can be
assigned to a channel (or channel 1 if no preceding event). In
other words, if the preceding event is an On Note with channel
2, and you then follow it with a Controller event omitting the
chan field, it defaults to channel 2.
The controller number; from 0 to 127 is assigned to the contr
field. This tells which one of the 128 controllers was
operated. There are a number of defined controllers. There are
also some undefined controllers. MF_DSM displays the controller
number if the controller isn't defined, and if it's defined, a
Controller ID is substituted instead. Here are the IDs for
defined controllers:
BankSw (Bank Switch -- some units have more than 128 patches,
and use this to select one of several groups of 128 patches)
Mod H (MOD wheel -- coarse)
Wind H (Breath controller -- coarse)
Foot H (Foot pedal -- coarse)
PTme H (Portamento Time -- coarse)
SlidrH (Slider -- coarse)
Vol H (Volume -- coarse)
Bal H (Balance -- coarse)
Pan H (Pan -- coarse)
Exp H (Expression -- coarse)
Genr 1 (General Purpose Slider 1)
Genr 2
Genr 3
Genr 4
Mod L (MOD wheel -- fine)
Wind L
Foot L
PTme L
SlidrL
Vol L
Bal L
Pan L
Exp L
HoldPd (Hold pedal On/Off)
Porta (Portamento On/Off)
Susten (Sustenuto pedal On/Off)
SoftPd (Soft pedal On/Off)
Hold2 (Hold 2 pedal On/Off)
Genr 5 (General Purpose Button 5 On/Off)
Genr 6
Genr 7
Genr 8
Effect (Effects On/Off)
Tremul (Tremulo On/Off)
Chorus (Chorus On/Off)
Celest (Celeste On/Off)
Phaser (Phaser On/Off)
Data + (Data button increment)
Data - (Data button decrement)
NRPN H (Non-registered parameter - coarse)
NRPN L (Non-registered parameter - fine)
RPN H (Registered parameter - coarse)
RPN L (Registered parameter - fine)
CtlOff (All Controllers Off)
SndOff (All Sound Off)
LocalK (Local keyboard On/Off)
NoteOf (All Notes Off)
OmniOf (Omni Mode Off)
OmniOn (Omni Mode On)
MonoOn (Mono Mode On)
PolyOn (Poly Mode On)
If you prefer, you can specify one of these IDs for the contr
field, rather than the actual number. If you don't supply a
controller number or ID, it defaults to the same controller as
the preceding Controller event (or 1, ie, Mod H, if no preceding
Controller event).
The controller's value is assigned to the value field. This is
a number from 0 to 127. For button types, 64 to 127 values are
ON; 0 to 63 values are OFF. If you don't supply the value, it
defaults to 0.
Examples 1: 1: 0 | Controller | chan=1 | contr=Chorus | value=40
1: 2: 0 | Controller | value=76 <- same chan and cntrl as
preceding event
2: 1: 0 | Controller | contr=2 <- controller 2 is set to 0
ΓòÉΓòÉΓòÉ 4.3.2.6. Program ΓòÉΓòÉΓòÉ
Type Program
Occurs when You change a patch/preset/instrument/etc. on the MIDI unit.
Other Fields The MIDI channel upon which the message was broadcast is
assigned to the chan field. This will be 1 of 16 (ie, a number
from 1 to 16). If you don't specify this field, it defaults to
the same channel as the preceding event type which can be
assigned to a channel (or channel 1 if no preceding event). In
other words, if the preceding event is an On Note with channel
2, and you then follow it with a Program event omitting the chan
field, it defaults to channel 2.
The program number; from 1 to 128 is assigned to the pgm #
field. This tells which one of the 128 programs (or patches) on
your MIDI unit is selected. MF_DSM also displays the patch name
as it should be on a MIDI unit with a General MIDI patch set, as
a comment at the end of the line. If you don't supply the
Program number, it defaults to 1.
Examples 1: 1: 0 | Program | chan=1 | pgm #=1
1: 2: 0 | Program | pgm #=128 <- same chan as preceding event
ΓòÉΓòÉΓòÉ 4.3.2.7. Poly Press ΓòÉΓòÉΓòÉ
Type Poly Press
Occurs when You apply pressure to (ie, press down harder or softer on) the
keys of a MIDI keyboard. Or, pressure can be generated in other
ways by different controllers, such as a wind controller
measuring changes in wind pressure.
Note: The difference between Aftertouch and Polyphonic
(Channel) Pressure is that the latter affects all notes
currently sounding on the MIDI channel whereas the former
only affects the one note that a particular Aftertouch
event is associated with.
Other Fields The MIDI channel upon which the message was broadcast is
assigned to the chan field. This will be 1 of 16 (ie, a number
from 1 to 16). If you don't specify this field, it defaults to
the same channel as the preceding event type which can be
assigned to a channel (or channel 1 if no preceding event). In
other words, if the preceding event is an On Note with channel
2, and you then follow it with a Poly Press event omitting the
chan field, it defaults to channel 2.
The pressure amount is assigned to the press field. This will
be from 0 to 127. If omitted, it defaults to 0.
Examples 2: 1: 0 | Poly Press | chan=16 | press=127
2: 2: 0 | Poly Press | press=76 <- same chan as preceding
event
3: 1: 0 | Poly Press | press=55 | chan=1 <- different order of
fields
ΓòÉΓòÉΓòÉ 4.3.2.8. PWhl ΓòÉΓòÉΓòÉ
Type Pitch Wheel
Occurs when You move the pitch wheel.
Other Fields The MIDI channel upon which the message was broadcast is
assigned to the chan field. This will be 1 of 16 (ie, a number
from 1 to 16). If you don't specify this field, it defaults to
the same channel as the preceding event type which can be
assigned to a channel (or channel 1 if no preceding event). In
other words, if the preceding event is an On Note with channel
2, and you then follow it with a Pitch Wheel event omitting the
chan field, it defaults to channel 2.
The pitch transposition is assigned to the bend field. This
will be from -8192 to 8192. Negative numbers indicate that the
pitch is being lowered, and positive values indicate that the
pitch is being raised. A 0 indicates that the pitch wheel is
centered (and therefore not transposing the pitch of the note).
If you don't supply the bend amount, it defaults to 0.
Examples 1: 1: 0 | Pitch Wheel | chan=4 | bend=-1000
1: 2: 0 | Pitch Wheel | bend=206 <- same chan as preceding
event
2: 1: 0 | Pitch Wheel | <- same chan, centered
ΓòÉΓòÉΓòÉ 4.3.2.9. Sysex ΓòÉΓòÉΓòÉ
Type Sysex
Occurs when The MIDI unit is sending some info that is specific to that
unit, such as a dump of its patch memory or waveform data.
Other Fields After the Sysex event type field, you must supply a len field,
which tells how many data values are to be in this message
(including the 0xF0 value that always starts a Sysex message).
Sysex messages can be any length. Then, you specify each one of
those values on the lines below that event line. In other
words, a Sysex event can span any number of lines in the source
code. You only need be certain that you supply as many values
as the len indicates. You can place as many or as few values as
you wish on each line. You can specify either decimal values or
hexadecimal values (with an 0x prepended to indicate hex).
Examples Assume that we wish to send the following hexadecimal values as
a System exclusive message: F0 00 01 50 F7. (Note that all
Sysex messages start with F0 and almost always end with F7). We
wish to send this message on the 2nd measure, first beat. Note
that there are 5 values in this message.
2: 1: 0 | Sysex | len=5
0xF0 0x00 0x01 0x50 0xF7
Note that I indented the values. You can add or remove blank
spaces before or after any values. Also, note that I placed all
of the values upon one line. I could have placed values on
several lines, as so:
2: 1: 0 | Sysex | len=5
0xF0 0x00
0x01 0x50 0xF7
For this event type, it's best to place any comment lines only after all of the
data value lines.
ΓòÉΓòÉΓòÉ 4.3.2.10. First Packet/Packet/Last Packet ΓòÉΓòÉΓòÉ
Type First Packet/Packet/Last Packet
Occurs when The MIDI unit is sending some info that is specific to that
unit, such as a dump of its patch memory or waveform data.
Other Fields These 3 event types of First Packet, Packet, and Last Packet
essentially amount to one Sysex event. It's just that some
cheesy MIDI gear (like Casio trash) can't handle a complete
Sysex message sent all at one time. It needs the Sysex message
to be broken up into several pieces, each sent at specific
times. So, the First Packet gets sent. It always starts with a
0xF0, but unlike the Sysex event type, it doesn't end with 0xF7.
That's because this isn't the end of the system exclusive
message yet. Each one of the Packet event types contains more
data values. The Packet doesn't start with 0xF0, because it
isn't the start of the system exclusive. (The First Packet was
the start). Neither does the Packet end with 0xF7, because it
isn't the end of the system exclusive (ie, there is more data to
come). Eventually, the Last Packet is the final "chunk" of
data. It ends with 0xF7. Confused? Well, so are the Casio
engineers who thought up this aberration. Like the Sysex event,
you must supply a len with each event type, and then specify the
values on the lines below the event line.
Examples 1: 1: 0 | First Packet | len=3
0xF0 0x00 0x01
2: 1: 0 | Packet | len=4
0x30 0x01 0x55 0x40
3: 1: 0 | Packet | len=1
0x20
4: 1: 0 | Last Packet | len=2
0x50 0xF7
For these event types, it's best to place any comment lines only after all of
the data value lines.
ΓòÉΓòÉΓòÉ 4.3.2.11. Tempo ΓòÉΓòÉΓòÉ
Type Tempo
Occurs when The tempo changes.
Other Fields The tempo in "quarter notes per minute" (ie, BPM) is assigned to
the BPM field.
The tempo in "microseconds per quarter note" is assigned to the
micros field. The micros field allows you to specify the tempo
in fractions of a beat.
Note: MF_DSM labels this field as micros\quarter which is also acceptable.
You can specify both fields, and if you do, the micros field has
precedence over the BPM field. (In other words, if you wish to
change a tempo event of some source code produced by MF_DSM, and
you want to change only the BPM field, then simply delete the
micros field altogether). If you omit both fields, the tempo
defaults to 120 BPM.
If a Format 1 file, this event should only be placed in the
first track.
Examples 1: 1: 0 | Tempo | BPM=100
2: 1: 0 | Tempo | micros=500000
3: 1: 0 | Tempo | BPM=120 | micros=500000 <- micros has
precedence
4: 1: 0 | Tempo | <- 120 BPM default
ΓòÉΓòÉΓòÉ 4.3.2.12. Time Signature ΓòÉΓòÉΓòÉ
Type Time Sig
Occurs when The time signature changes.
Other Fields The time signature is placed into its own field. The time
signature is expressed as two numbers separated by a /
character, such as 3/4 (ie, Waltz time). If you don't supply
the signature, it defaults to 4/4.
The number of MIDI clocks in a metronome click is assigned to
the click field. This determines how often the metronome
clicks. There always 24 MIDI clocks in a quarter note. So, to
have the metronome click every quarter note, set click to 24.
To click every eighth note, set click to 12 (ie, half of 24).
Etc.
Note: MF_DSM labels this field as MIDI-clocks\click which is
also acceptable.
The number of 32nd notes in a quarter note is assigned to the
32nds field. Generally, this will always be 8, but some
notation programs allow different settings.
Note: MF_DSM labels this field as 32nds\quarter which is also acceptable.
If a Format 1 file, this event should only be placed in the
first track.
Examples 1: 1: 0 | Time Sig | 4/4 | click=24 | 32nds=8
2: 1: 0 | Time Sig | 6/8 | click=12 <- 6/8 time, metronome
clicks every eighth
You have be careful when changing the Time Signature, since that can invalidate
the times of other, subsequent events in the track (or subsequent events in all
other tracks in Format 1). For example, assume that you have the following:
1: 1: 0 | Time Signature | 4/4
1: 4: 0 | On Note | chan=1 | pitch=C3 | vol=127
You change the Time signature to 3/4.
1: 1: 0 | Time Sig | 3/4
1: 4: 0 | On Note | chan=1 | pitch=C3 | vol=127
Now you have a problem with the On Note event. It's supposed to be on the
fourth beat of the first measure, but a song in 3/4 only has 3 beats in each
measure. There is no fourth beat. If you want to maintain the original
timing, that On Note would be on the first beat of measure 2.
It only makes sense to place a Time Signature on the first beat of a measure.
After all, how can you change a Time Signature in the middle of a measure? In
other words, the beat and subbeat field of a Time Signature's Time field should
always be 1 and 0 respectively. Only the measure number may be different.
ΓòÉΓòÉΓòÉ 4.3.2.13. Key Signature ΓòÉΓòÉΓòÉ
Type Key Sig
Occurs when The key signature changes.
Other Fields The key signature is contained in its own field. You specify
the root note, and whether the key is Major or Minor. If you
don't supply the key signature, it defaults to C Major.
Examples 1: 1: 0 | Key Sig | G Major
2: 1: 0 | Key Sig | <- C Major default
3: 1: 0 | Key Sig | F# minor
ΓòÉΓòÉΓòÉ 4.3.2.14. SMPTE ΓòÉΓòÉΓòÉ
Type SMPTE
Occurs at The SMPTE time needs to be set to a certain value.
Other Fields The SMPTE hour is assigned to the hour field. If you don't
supply this, it defaults to the same hour as the preceding SMPTE
event (or 0 if no such event). The SMPTE minutes is assigned to
the min field. If you don't supply this, it defaults to the
same minute as the preceding SMPTE event (or 0 if no such
event). The SMPTE second is assigned to the sec field. If you
don't supply this, it defaults to the same second as the
preceding SMPTE event (or 0 if no such event). The SMPTE frame
is assigned to the frame field. If you don't supply this, it
defaults to the same frame as the preceding SMPTE event (or 0 if
no such event). The SMPTE subframe is assigned to the subs
field. If you don't supply this, it defaults to the same
subframe as the preceding SMPTE event (or 0 if no such event).
Note: The range of the subframe field will depend upon the
resolution of your SMPTE rate. Usually, the MThd's
Division is expressed as a SMPTE rate, in which case, the
subframe resolution is specified there.
Examples 1: 1: 0 | SMPTE | hour=1 | min=30 | sec=10 | frame=1 | subs=1
ΓòÉΓòÉΓòÉ 4.3.2.15. End of track ΓòÉΓòÉΓòÉ
Type End of track
Occurs when The track is ended.
Other Fields None. Every track must end with an End of track event. It must
be the last event. The time of this event tells you exactly
when the track stops playing. Make certain that you don't
forget the | character after the event type.
Examples 33: 1: 0 | End of track |
ΓòÉΓòÉΓòÉ 4.3.2.16. Seq # ΓòÉΓòÉΓòÉ
Type Seq #
Other Fields The sequencer number is contained in its own field. This can be
any number from 0 to 65,535. It's used to identify the track,
and differentiate it from other tracks. If you don't supply the
sequence number, it defaults to which track this happens to be
(ie, the first track in your source code is 0).
The track's name is assigned to the name field. This can be any
amount of text. You should enclose the text between the
characters < and > if you wish to place a comment at the end of
the line or use numbers in the track name.
If you use this event in a track, it must be the very first
event in the track. You can only have one such event in the
track. Two tracks should not have the same sequence number.
Examples 1: 1: 0 | Seq # | 5 | name=<My track name>
ΓòÉΓòÉΓòÉ 4.3.2.17. Text event ΓòÉΓòÉΓòÉ
Type Text event
Occurs when At any point. Generally, the sequencer uses this event to
display text to the enduser or to somehow "mark" or label
something at a certain point in the song.
Other Fields After the Text event event type field, you must supply a len
field, which tells how many data values (ie, text characters)
are to be in this event. Text events can be any length. Then,
you specify each one of those values on the lines below that
event line. In other words, a Text event can span any number of
lines in the source code. You only need be certain that you
supply as many values as the len indicates. You can place as
many or as few values as you wish on each line. You can specify
either decimal values or hexadecimal values (prepended with 0x)
that represent the ascii characters. For example, an 'A'
character is 0x41. You could specify some values as
hexidecimal, and others as decimal. Alternately, you can write
the actual text, enclosed between the characters < and >. If
the text spans several lines, you must enclose each line's text
with < and >. You could supply data values as well as text
enclosed between < and > on the same line, but if so, MF_ASM
uses one or the other, whichever comes first. In other words,
if the data values are placed before the text enclosed within <
and >, then the data values are used and the text is ignored.
Note: MF_DSM notates Text events with both data values,
followed by the equivalent text (ie, ascii characters)
enclosed within < and >. If you want to subsequently
edit a Text event, and you wish to make changes via the
text, then simply delete the preceding data values.
Examples 1: 1: 0 | Text event | len=5
0x48 0x65 0x6c 0x6c 0x6f <Hello> note: data values
followed by equivalent text
2: 1: 0 | Text event | len=5
<Hello> note: only the text
3: 1: 0 | Text event | len=5
0x48 0x65 0x6c 0x6c 0x6f note: only the data values
If desired, I could break up the data values and text onto
multiple lines, as so:
1: 1: 0 | Text event | len=5
0x48 0x65 <He>
0x6c 0x6c 0x6f <llo>
3: 1: 0 | Text event | len=34
<Here's one that also>
<spans 2 lines.>
For this event type, it's best to place any comment lines only after all of the
data value or text lines. In addition to the | character, don't use the < or >
characters in the comments.
Normally, a text event contains data values that are in the ascii range of
printable characters (ie, 32 to 126). If MF_DSM disassembles a MIDI file that
has a weird text event with a non-printable character in it, that character is
replaced by the . (ie, dot) character. Consider the following:
1: 1: 0 | Text event | len=1
0x10 <.>
The text indicates a . character, but if that were really meant to be a dot
character, the data value would be 0x2E. What you have here is a replacement
occurring. If you see a dot character in the text, check that the
corresponding data value for it is 0x2E. If so, then that's really meant to be
a dot character in the event. Otherwise, you'll have to deal with data values
when editing the event, rather than being able to express it entirely as text.
It's possible to express some lines starting with data values, and other lines
starting with text. For example, assume that you wish to create a text event
for the string Hello and null-terminate it (ie, add a zero byte to the end).
1: 1: 0 | Text event | len=1
<Hello> 0x48 0x65 0x6c 0x6c 0x6f note: text before data values so MF_ASM
uses text
0x00 <.> note: data values before text so MF_ASM uses data values
ΓòÉΓòÉΓòÉ 4.3.2.18. Copyright ΓòÉΓòÉΓòÉ
Type Copyright
Occurs when At any point. Generally, the sequencer uses this event to imbed
a copyright message in the data file.
Other Fields This is just a specialized version of a Text event. See Text
event for details of how to supply the data values and/or actual
text for the event.
Examples 1: 1: 0 | Copyright | len=19
<(C) 1994 Jeff Glatt>
ΓòÉΓòÉΓòÉ 4.3.2.19. Lyric ΓòÉΓòÉΓòÉ
Type Lyric
Occurs when A syllable of a word in the song's lyrics occurs. Scoring
programs use this.
Other Fields This is just a specialized version of a Text event. See Text
event for details of how to supply the data values and/or actual
text for the event.
Examples 1: 1: 0 | Lyric | len=3
<Let>
1: 3: 0 | Lyric | len=2
<me>
2: 1: 0 | Lyric | len=4
<call>
2: 3: 0 | Lyric | len=3
<you>
3: 1: 0 | Lyric | len=6
<sweet->
3: 2: 0 | Lyric | len=5
<heart>
ΓòÉΓòÉΓòÉ 4.3.2.20. Marker ΓòÉΓòÉΓòÉ
Type Marker
Occurs when At any point. Generally, the sequencer uses this event to
display text to the enduser or to somehow "mark" or label
something at a certain point in the song.
Other Fields This is just a specialized version of a Text event. See Text
event for details of how to supply the data values and/or actual
text for the event.
Examples 3: 1: 0 | Marker | len=10
<Loop Start>
ΓòÉΓòÉΓòÉ 4.3.2.21. Cue Point ΓòÉΓòÉΓòÉ
Type Cue Point
Occurs when At any point. Generally, the sequencer uses this event to
designate a special, non-MIDI event such as indicating a sampled
waveform to load and play, or allowing the user to imbed cueing
instructions in the MIDI file.
Other Fields This is just a specialized version of a Text event. See Text
event for details of how to supply the data values and/or actual
text for the event.
Examples 1: 1: 0 | Cue Point | len=12
<A gun fires.>
1: 2: 0 | Cue Point | len=12
<She screams.>
ΓòÉΓòÉΓòÉ 4.3.2.22. Track name ΓòÉΓòÉΓòÉ
Type Track name
Occurs when At the beginning of a track usually. The sequencer uses this
event to designate a textual name for the track.
Other Fields This is just a specialized version of a Text event. See Text
event for details of how to supply the data values and/or actual
text for the event.
Note: If you specify a Seq # event with a name field, then you
don't need to use this event. The Seq # event duplicates
the function of this event. Of course, if you have
multiple musical parts in one track (ie, a Format 0
file), you might want to specify the names of all parts
in the track with numerous Track name events.
Examples 1: 1: 0 | Track name | len=11
<Weird stuff>
ΓòÉΓòÉΓòÉ 4.3.2.23. Instrument ΓòÉΓòÉΓòÉ
Type Instrument
Occurs when At the beginning of a track usually. The sequencer uses this
event to indicate what kind of instrument might be playing the
data in the track, such as a Piano.
Other Fields This is just a specialized version of a Text event. See Text
event for details of how to supply the data values and/or actual
text for the event.
Examples 1: 1: 0 | Instrument | len=5
<Piano>
ΓòÉΓòÉΓòÉ 4.3.2.24. Unknown Meta ΓòÉΓòÉΓòÉ
Type Unknown Meta
Occurs when ???
Other Fields This exists only in case some MetaEvent is added to the MIDI
file specification in the future. In that case, you can use
this to indicate that. This is just a specialized version of a
Text event. See Text event for details of how to supply the
data values and/or actual text for the event. But, this has an
additional field that must be supplied; the Type field. This
should be the type of that yet-to-be-defined MetaEvent.
Examples Assume that a MetaEvent known as "Loop Iterations" is defined
with a type of 0x0F. Perhaps it needs one data byte that
specifies the number of times that a track is looped. Here's
our event:
1: 1: 0 | Unknown Meta | type=0x0f | len=1
12 note: I specified decimal instead of hex. That's OK.
ΓòÉΓòÉΓòÉ 4.3.2.25. Specific ΓòÉΓòÉΓòÉ
Type Specific
Occurs when ???
Other Fields A program would use this to store data that is specific (ie,
Proprietary) to that program. For example, maybe a program
wants to save a flag that indicates whether its "event list"
window is displayed or its "score window". This is just a
specialized version of a Text event. See Text event for details
of how to supply the data values and/or actual text for the
event.
Examples Assume that a program wants to store an event that contains 1
data byte which specifies upon what MIDI channel the program
recognizes controller messages sent to it (ie, for remote
control).
1: 1: 0 | Specific | len=1
2 note: I specified decimal instead of hex. That's OK.
ΓòÉΓòÉΓòÉ 4.3.2.26. Escape event ΓòÉΓòÉΓòÉ
Type Escape event
Occurs when At any time. This is used to imbed MIDI messages that normally
aren't found in a sequencer data file, such as MIDI Common and
Realtime messages, like Song Position Pointer.
Other Fields This is just a specialized version of a Text event. See Text
event for details of how to supply the data values and/or actual
text for the event.
Examples Assume that you want to imbed a MIDI Song Select message in a
MIDI file. That has 2 bytes; the 0xF3 status, and a byte that
indicates the song number. Let's make an event for song number
50.
1: 1: 0 | Escape event | len=2
0xF3 50 note: I mixed decimal with hex. That's OK.
ΓòÉΓòÉΓòÉ 4.3.3. Abbreviating the Event Type field ΓòÉΓòÉΓòÉ
You don't need to specify the entire Event Type field on an event line. You
only need specify enough characters to distinguish the desired type. You can
safely use a minimum of the first 3 characters of an event type in order to
identify it. For example, instead of typing On Note, you can simply type On.
Instead of typing Off Note, you can simply type Off. This saves some time when
entering lots of events.
ΓòÉΓòÉΓòÉ 4.3.4. Omitting Time Components ΓòÉΓòÉΓòÉ
Let's assume that we have a Tempo event on measure 1, beat 1 (ie, right on the
downbeat), followed by a Note off event upon the same measure, but on the third
beat. Here are 2 such events, in the order that they must be listed:
1: 1: 0 | tempo | BPM=100
1: 3: 0 | note off | chan=1 | pitch=C3 | vol=100
Notice that both events are on measure 1. When an event is on the same measure
as the preceding event, it's measure number can be omitted, as so:
1: 1: 0 | tempo | BPM=100
3: 0 | note off | chan=1 | pitch=C3 | vol=100
This blank space makes it easier to see that the second event is in the same
measure as the preceding event. It doesn't matter if the preceding event is
the same type or a different type. You can omit the measure field of an event
if the preceding event, whatever the type, is on the same measure.
Furthermore, if the preceding event is upon the same measure and beat, you can
omit both the measure and beat for the second event. Let's assume that we have
a third, note on event that occurs upon measure 1, beat 1, the second eighth of
that beat (assume 192 Division).
1: 1: 0 | tempo | BPM=100
96 | note on | chan=1 | pitch=C3 | vol=100
3: 0 | note off | chan=1 | pitch=C3 | vol=100
Of course, if an event is upon the same measure, beat, and subbeat, you can
omit all 3 fields.
1: 1: 0 | tempo | BPM=100
96 | note on | chan=1 | pitch=C3 | vol=100
3: 0 | note off | chan=1 | pitch=C3 | vol=100
| tempo | BPM=150
The above 150 BPM tempo event gets "played" upon the exact same time as the
preceding note off event.
When you have large amounts of events occurring upon the same measure,
beats, and/or subbeats, omitting time components makes it much easier to see
where the measure and beat boundaries occur. That makes editing easier.
Furthermore, if you wish to move an entire excerpt of events to a new playback
time (ie, maybe move all events in measure 4 over to measure 6), you'll have
less time components to edit.
You aren't required to omit time components. You can always specify the
measure, beat, and subbeat for every event. But, doing otherwise can improve
readability and make editing time fields easier.
Furthermore, note that in order to omit the beat component, the measure
component must also be the same as the preceding event. To omit the subbeat
component, both the beat and measure components must be the same as the
preceding components.
ΓòÉΓòÉΓòÉ 4.4. Unknown Chunk Header line ΓòÉΓòÉΓòÉ
A MIDI file may contain a chunk that is defined by the application that created
the file. Obviously, the purpose and contents of that chunk would be unknown
to any other application. An Unknown Chunk can occur anyplace that you might
put a Track Header. (ie, It must come after the MThd Header line, and of
course, you can't put an Unknown Chunk in the middle of a track's data).
Every chunk must have an ID. This is 4, ascii characters that uniquely
identify the chunk. For example, Xtra is a legal ID for a chunk. The only 2
ID's you can't use are MThd and MTrk, as these are already used for defined
chunks in a MIDI file.
Every chunk must also have a len which is how many data values (ie, bytes)
are contained in the chunk.
When MF_DSM encounters such a chunk, it displays an Unknown Chunk Header
line with 3 fields. The first field contains the text Unknown Chunk. The
second field contains the chunk's ID, enclosed with the characters < and >.
The last field is the len.
The data values are then displayed upon subsequent lines, with the
equivalent ascii characters to the left, enclosed with the characters < and >.
(ie, This is much the same layout as with text type of events).
ΓòÉΓòÉΓòÉ 5. Assembly Format ΓòÉΓòÉΓòÉ
Assembly is the process of taking a text file (ie, human readable "source
code") describing events and headers in a MIDI file and converting it back into
a MIDI (binary) file. MF_ASM does this. MF_ASM requires that you follow the
guidelines used by MF_DSM in formatting your source code. In addition, MF_ASM
also supports a few additional features that you can add to the source code
which allows further processing.
ΓòÉΓòÉΓòÉ 5.1. Track Header fields ΓòÉΓòÉΓòÉ
As mentioned, the start of a track is indicated with a Track Header line. This
is a line that must start with the text Track # usually followed by the number
of the track. After this mandatory initial field, there are several other
fields that can be added to the Track Header line. These fields apply to all
events within that track, and offer numerous ways of easily processing the
entire track as a whole.
Just as with the Event lines and MThd Header line, a | character is used to
separate the fields on the Track Header line. An = sign is used to assign
values to fields. The | can optionally be omitted after the last field. For
example, here's how you might specify a Track Header line with two of its
possible, additional fields:
Track #0 | transpose = -2 | chan=3
Note how the fields are separated by a | character. Optional fields (ie, after
the Track # field) can appear in any order, and you may include any or all of
the possible fields.
Note: If editing a Track Header line created by MF_DSM, it's OK to leave the *
filler characters at the end of the line.
Note that whatever fields you include on a Track Header line only affect the
events in those tracks, and not events in other tracks. So, you can have
separate map and filter files, and various settings for each track. If you
wanted a specific setting for all tracks in the source code, you'd have to add
the appropriate field to every Track Header line.
The following sections list each possible field that can be added to the Track
Header line. Each page tells what the field's name is, what its purpose is,
what values can be assigned to it, and gives an example of its use.
ΓòÉΓòÉΓòÉ 5.1.1. Chan ΓòÉΓòÉΓòÉ
Field Chan
Purpose This is a global MIDI channel setting which will override the
channel assignments of individual events in a track. In other
words, it forces all MIDI events in the track to be on this one
MIDI channel. If all of the events in a track happen to be for
a single musical part (which is common in Format 1 files), it
would make sense that all of the events would be on the same
MIDI channel. In this case, the global chan can quickly
reassign that musical part to a different channel.
Values The desired MIDI channel is assigned to this field. This will
be 1 of 16 (ie, a number from 1 to 16).
Examples Track #0 | chan=12 <- Forces all events to MIDI channel 12
ΓòÉΓòÉΓòÉ 5.1.2. Transpose ΓòÉΓòÉΓòÉ
Field Transpose
Purpose Tranposes all of the On Note, Off Note, (Off) Note, and
Aftertouch events in the track up or down by half steps.
Values The transpose amount, in +/- half steps is assigned to this
field. This will be a number from -127 to 127.
Note: If you specify a transpose amount that happens to
transpose a note out of the MIDI note range, MF_ASM will
abort with an error. You'll have to locate that Event
Line and change the note's pitch so that it remains in
the legal note range after transposition (or delete the
event if it isn't needed).
Examples Track #0 | transpose=-1 <- transposes down a half step
Track #0 | transpose=2 <- transposes up a whole step
Track #0 | transpose = 12 <- transposes up an octave
ΓòÉΓòÉΓòÉ 5.1.3. Vol ΓòÉΓòÉΓòÉ
Field Vol
Purpose Scales the volume (ie, note velocity) of all On Note and Off
Note events in the track by a specified percentage. Since note
velocity is most often tied to the VCA on most MIDI units, this
effects an overall master volume control for the track.
Values The volume percentage is assigned to this field. This can be
any number from 1 to several thousand (although every note will
be clipped using percentages > 12800). Percentages less than
100% lower the volume of a track. Percentages > 100% raise the
volume of a track. A percentage of 100% is a special case.
This signifies that you want MF_ASM to set all the volumes of
all On Note and Off Note events in the track to the same volume
as the first such event in the track. Thus, you can force all
notes to a particular volume.
Note: If a Vol > 100% causes some event's volume to be clipped
(ie, MIDI velocity only goes up to 127), then MF_ASM will
display a warning message but not abort. Clipping a MIDI
note's volume doesn't cause "distortion" the way that an
overloading amp might, but rather is more like a limiter.
Examples Track #0 | vol=200% <- double the volume
Track #0 | vol=50% <- halve the volume
Track #0 | vol=100%
1: 1: 0 | On Note | pitch=C3 | vol=64 <- all volumes are forced
to 64
ΓòÉΓòÉΓòÉ 5.1.4. Exclude ΓòÉΓòÉΓòÉ
Field Exclude
Purpose Allows you to specify a list of MIDI channels to filter. In
other words, all events on those MIDI channels will be filtered
out of the track when MF_ASM assembles the source code. This is
useful for extracting particular musical parts from a track
since most musical parts are entirely contained upon one MIDI
channel. This also allows converting a Format 0 file (ie, one
track which likely contains numerous MIDI channels) into Format
1 by assembling several versions of the original source listing,
each with a different Exclude assignment, disassembling the
resulting MIDI files into source listings, and combining those
into a source listing with multiple tracks and Format=1.
Values The MIDI channels that are to be excluded are assigned to this
field. Each channel should be separated by a space or
non-numeric character other than | or =. If you wish to place a
comment after this field, it's best to end the field with the |
character.
Examples Track #0 | exclude= 1, 14, 15 | <-filters out events on
channels 1, 14, and 15
Track # | exclude = 1 14 15 | <- same thing, with spaces
instead of ,
ΓòÉΓòÉΓòÉ 5.1.5. Options ΓòÉΓòÉΓòÉ
Field Options
Purpose Specifies various options.
Values The specific options that you desire are assigned to this field.
Each option should be separated by a space. This field should
always be ended with a | character. The allowable options are:
0vel -- This converts all Off Note events in the track to (Off)
Note events which may reduce the size of the MIDI file or make
it more efficient for playback over MIDI (assuming that the file
has Off Note events in it). If your MIDI unit can't make use of
key release velocity, you may as well use this option.
off -- Causes MF_ASM to add (Off) Note events at the end of a
track if any On Note events within it haven't been turned off.
In other words, it turns off notes that might otherwise be
"stuck" if you played back the track. If you're editing
deleting or editing the note pitches of On Note events, remember
that you also have to make the respective change to the
subsequent Off Note or (Off) Note event that goes with that On
Note. The opposite is also true. Furthermore, if you're
changing around the order of events, make sure that you don't
reverse the order of On Note and its respective Off or (Off).
The Off or (Off) must come after the On. Finally, if you're
inserting new On Note events, you have to make Off or (Off)
events for them. This option will at least help account for
sloppy editing that violates the preceding rules, and result in
a MIDI file that doesn't have inherent stuck notes. (But, a
note may end up held all of the way to the end of the track,
which could be musically unpleasant). Note that MF_ASM also
deletes Off or (Off) events that don't have a preceding On
event. (In that case, a WARNING message is displayed). So,
with this option, you're at least safe from stuck notes upon
playing a MIDI file in which you've performed some of the
described edits.
Examples Track #0 | options = off | Just "off" option
Track #0 | options = 0vel | <- Just 0vel option
Track #0 | options = 0vel off | <- both options
ΓòÉΓòÉΓòÉ 5.1.6. Filter ΓòÉΓòÉΓòÉ
Field Filter
Purpose Allows you to specify which Event Types are to be filtered from
the track. You can filter any of the event types listed in the
Disassembly Format's Event Type Field sections. For example,
you can filter all Tempo event types from a track, making it
possible to easily extract a "tempo map" from a Format 0's
track. Or you can do other processing such as removing
Aftertouch events, etc.
Values You must create another text file (in addition to your source
code) that contains a list of all the Event Types that you wish
to filter out of the track. Each Event Type should be on its
own line. You can use Event Type abbreviations if desired to
save typing. Then, you assign the name of that text file to the
Filter field. You should enclose the filename in double quotes
and end the field with a | character. You may fully qualify the
filename (ie, prepend the complete path as you would on a
command line).
Examples Assume that you wish to filter all note events (ie, On Note, Off
Note, and (Off) Note) in a track. We'll create a text file
called DataFile on the C: drive. This text file should contain
those 3 Event Types, each on its own line, as so:
On Note
Off Note
(Off) Note
Now, we specify the Filter field as so:
Track #0 | filter="c:\datafile"
ΓòÉΓòÉΓòÉ 5.1.7. Map ΓòÉΓòÉΓòÉ
Field Map
Purpose Allows you to specify which note (and aftertouch) pitches get
mapped to other note pitches, and also can specify which
specific note (and aftertouch) pitches are to be filtered from
the track. For example, you can filter all note and aftertouch
pitches from C3 to C4, and remap any D5 note and aftertouch to
F1. This is very useful for remapping drum note assignments, or
filtering out musical parts that are all on the same MIDI
channel (in different note ranges, such as a split-keyboard
might produce).
Values You must create another text file (in addition to your source
code) that contains a list of all the pitches that you wish to
remap, as well as any pitches that you wish to filter out of the
track. Each pitch remapping or filtering should be on its own
line. For remapping, you specify the pitch that you want to be
remapped, followed by the pitch that you want it to be mapped
to. Separate the two with an = sign. For pitch filtering,
start with an = sign, and follow it with the pitch that you want
filtered from the track.
Examples For the following example, we'll always create a text file
called DataFile on the C: drive. So, our Track Header would
always look like:
Track #0 | map = "c:\datafile" |
Assume that you wish to remap all C4 pitches to D#5 and all B3
to F#-1. Here's what the data file should look like:
C4 = D#5
B3 = F#-1
Note: Blank spaces can be added anywhere to improve
readability, just like when you specify the pitch in your
source code. Also, capitalization is optional.
Assume that you wish to filter all D#5 and B3 pitches from the
track. Here's what the data file should look like:
= D#5
= B3
Assume that you wish to remap C4 to D#5 and filter F#-1. Here's
what the data file should look like:
C4 = D#5
= F#-1
It doesn't matter which order you specify pitches in the file
(ie, low pitches before higher, etc). But, if you normally
specify lower pitches first, then you can save typing on the
pitch after the = sign (ie, destination pitch). If you omit the
destination pitch, it defaults to one higher than the previous
destination pitch. For example:
C3 = C4
C#3 = ;C#3 is remapped to C#4 because the preceding
destination pitch is C4
D3 = ;D3 is remapped to D4 because the preceding
destination pitch is C#4
This also works on filtering. For example, here's how to filter
all notes and aftertouch in the range C3 to B3 inclusive.
= C3 ;filter C3
= ;filter C#3 because the preceding destination pitch is C3
= ;filter D3 because the preceding destination pitch is C#3
= ;filter D#3 because the preceding destination pitch is D3
= ;filter E3 because the preceding destination pitch is D#3
= ;filter F3 because the preceding destination pitch is E3
= ;filter F#3 because the preceding destination pitch is F3
= ;filter G3 because the preceding destination pitch is F#3
= ;filter G#3 because the preceding destination pitch is G3
= ;filter A3 because the preceding destination pitch is G#3
= ;filter A#3 because the preceding destination pitch is A3
= ;filter B3 because the preceding destination pitch is A#3
Note: If you wish to put comments in a map file, it would be
best to preface them with a ; or /* character, or some
other non alphabetic character (other than =).
ΓòÉΓòÉΓòÉ 5.2. Commenting the source ΓòÉΓòÉΓòÉ
Often, it's convenient to add comments to your source code which MF_ASM should
ignore when assembling the code. Generally, comments are placed at the end of
a line, or on a separate line. An important point is that you should never use
the | character anywhere in a comment since this is used by MF_ASM to find the
end of fields. Furthermore, if the comment is to appear at the end of an MThd
Header, Track Header, or event line, you should not use the = character
anywhere in a comment. There may be other exceptions for individual Event
Types. For example, avoid using the / character in a comment at the end of a
Time Signature event line. Avoid using the < or > characters in a comment at
the end of any Text type of event (ie, Marker, Cue Point, Lyric, Instrument,
etc).
Generally, it's always safe to put a comment on its own line, begin the
comment with some non alphabetic character (such as ;), and don't use the |
character. Follow this policy, and your comments should be transparent to the
assembler.
ΓòÉΓòÉΓòÉ 6. Error Messages ΓòÉΓòÉΓòÉ
Here are the possible error messages that you may see. Following each message
is a description of likely causes for that error and possible remedies.
ΓòÉΓòÉΓòÉ 6.1. Memory Commitment Fail/Memory Allocation ΓòÉΓòÉΓòÉ
Synopsis The assembler and disassembler need to allocate some memory to
do their work. Either of these 2 errors means that OS/2 did not
grant that memory, and therefore the program can't continue.
Cause Not enough free RAM in your system, and your swap file is full.
Cure Terminate other programs that you don't need running. Buy more
RAM.
ΓòÉΓòÉΓòÉ 6.2. Can't open input file ΓòÉΓòÉΓòÉ
Synopsis A file, that you asked MF_ASM to convert to MIDI, or that you
asked MF_DSM to convert to text, didn't open.
Cause The filename that you specified is incorrect.
Cure Check the filename that you entered. Does it exist? Did you
specify the path if it was needed?
Cause Some other program has this filename currently in use, and is
preventing SHARED access.
Cure Make that other program close this filename.
ΓòÉΓòÉΓòÉ 6.3. Can't open the MIDI file to save ΓòÉΓòÉΓòÉ
Synopsis A file, that you asked MF_ASM or MF_DSM to create, didn't open.
Cause The filename that you specified is incorrect.
Cure Check the filename that you entered. Did you specify some
directory that doesn't exist? The utilities only creates files;
not new directories.
Cause Some other program has this filename currently in use, and is
preventing SHARED access.
Cure Make that other program close this filename.
Cause You chose to save data upon some media that is write-protected.
Cure Remove the write-protection.
ΓòÉΓòÉΓòÉ 6.4. Format 0 can only have 1 Track ΓòÉΓòÉΓòÉ
Synopsis You've asked MF_ASM to assemble a source listing where you set
the MThd's Format=0 but the # of Tracks is greater than 1. A
Format 0 file can only have 1 track.
Cure Either change the Format to 1 or 2 if you want more than one
track in the file, or change # of Tracks to 1.
ΓòÉΓòÉΓòÉ 6.5. No MThd! Must not be a MIDI text file ΓòÉΓòÉΓòÉ
Synopsis MF_ASM can't find your MThd Header line in your source code.
Cause You placed characters (other than spaces) before the MThd field
of the MThd Header line.
Cure Delete those characters.
Cause You forgot to put an MThd Header line in your source code.
Cure Put it in, dummy.
Cause You didn't spell MThd properly. Capitalization isn't important,
but you do need the correct letters.
Cure Learn to spell.
ΓòÉΓòÉΓòÉ 6.6. Line XXX: Event time out of order ΓòÉΓòÉΓòÉ
Synopsis An event's time is out of order with respect to its placement in
the source code. The XXX in the message will be the line number
within the source code where the error occurred.
Cause The event has a measure:beat:clock that puts it ahead of the
event that is on the line above it.
Cure You must place the events in the source code with respect to
their time-stamps. The earliest events in a track are first
after their Track Header line. Check the event before the
erroneous event. Is the preceding event on a later measure
number than the erroneous event? If the measures are the same,
is the preceding event on a later beat number than the erroneous
event? If the measures and beats are both the same, is the
preceding event on a later clock number than the erroneous
event? If so, reverse the order of the events.
Cause That erroneous line was supposed to be a comment, but MF_ASM
thought it was an event line, which it didn't make sense as.
Cure Make sure that you didn't use the | character in your comment.
Also make sure that you didn't forget the End of track event at
the end of any track prior to where the error occurred.
ΓòÉΓòÉΓòÉ 6.7. Line XXX: Event time exceeds current time signature ΓòÉΓòÉΓòÉ
Synopsis An event's time is out of order with respect to the current time
signature. The XXX in the message will be the line number
within the source code where the error occurred.
Cause You changed a Time Signature such that it invalidated some event
time in a track, but neglected to resolve that invalidation. In
other words, if an event supposedly occurs on beat 4 of some
measure, and you change the time signature to 3/4 (ie, there is
no fourth beat), then you invalidate the event's time. This
could cause problems with MF_ASM calculating an event's time,
and result in this error message. Furthermore, it's possible to
also have problems with the subbeat component if you've changed
the denominator of the time signature. For example, in going
from 4/4 to 4/8, the beat changes from a quarter note to an
eighth note. Therefore, at 192 PPQN, the beat goes from
spanning 192 subbeats to spanning only 192/2 subbeats. If you
have a subsequent event supposedly on the 97th subbeat of a
beat, then you've got an invalid time.
Cure Check the Time Signature event that comes before the erroneous
event. (In a Format 1, all of the Time Signatures should be in
the first track, and these determine time references for all
tracks). That's the current time signature. Does the beat of
the erroneous event jive with the Time Signature's "numerator"?
Does the subbeat of the erroneous event jive with the Time
Signature's "denominator"?
ΓòÉΓòÉΓòÉ 6.8. Line XXX: Number of bytes supplied is less than specified length ΓòÉΓòÉΓòÉ
Synopsis You didn't supply as many bytes as the len field indicates for
some text event (ie, Text event, Marker, Lyric, Cue Point, Track
name, etc) or an Unknown Chunk. The XXX indicates the line
number in the source code where the erroneous event began (ie,
on the first line of the event, before all of the subsequent
data values or text).
Cause The len field specifies more values than you intended, or you
forgot to specify all of those values.
Cure Check the len field of the event. Then, count how many values
or text characters you've supplied. Make sure that the two
match.
Cause You specified text instead of data values, but forget to enclose
the text inbetween < and > characters.
Cure Make sure that the text is enclosed within < and >. If your
text spans multiple lines, make sure that each line of text is
separately enclosed with < and >.
ΓòÉΓòÉΓòÉ 6.9. Line XXX: Can't open map file ΓòÉΓòÉΓòÉ
Synopsis The filename that you supplied for a Track Header's map field
can't be opened. The XXX indicates the line number where the
erroneous Track Header occurs in the source code.
Cause The filename that you specified is incorrect.
Cure Check the filename that you entered. Does it exist? Did you
specify the path if it was needed?
Cause Some other program has this filename currently in use, and is
preventing SHARED access.
Cure Make that other program close this filename.
ΓòÉΓòÉΓòÉ 6.10. Line XXX: Can't open filter file ΓòÉΓòÉΓòÉ
Synopsis The filename that you supplied for a Track Header's filter field
can't be opened. The XXX indicates the line number where the
erroneous Track Header occurs in the source code.
Cause The filename that you specified is incorrect.
Cure Check the filename that you entered. Does it exist? Did you
specify the path if it was needed?
Cause Some other program has this filename currently in use, and is
preventing SHARED access.
Cure Make that other program close this filename.
ΓòÉΓòÉΓòÉ 6.11. map file line XXX: Note out of range ΓòÉΓòÉΓòÉ
Synopsis Some pitch listed in the map file is beyond the legal MIDI note
range. For example G#33 is way out of range. The XXX indicates
the line number upon which the bad pitch occurs in the map file.
Cure Check the pitches specified on that line. If you have comments
at the end of the line, try putting a ; character at the start
of the comment to ensure that no numbers or letters in the
comment are being misinterpreted as a pitch.
ΓòÉΓòÉΓòÉ 6.12. Line XXX: Bad channel for 'exclude' ΓòÉΓòÉΓòÉ
Synopsis One of the MIDI channels that you supplied for a Track Header's
exclude field is not a legal MIDI channel number. The XXX
indicates the line number where the erroneous Track Header
occurs in the source code.
Cause You specified a channel of 0 or a channel > 16.
Cure MIDI channels are 1 to 16.
Cause If the Exclude field is the last field on the Track Header line,
a | character hasn't closed the field, and what follows is a
comment, MF_DSM may be regarding numbers in the comment as MIDI
channels.
Cure End the Exclude field with the | character.
Cause You separated the channels with more than one, non-space
character (ie, exclude = 3 /// 14 /// 4).
Cure Only use blank space to separate channels, or one non-space
character.
ΓòÉΓòÉΓòÉ 6.13. Line XXX: Unknown 'option' SSS ΓòÉΓòÉΓòÉ
Synopsis One of the options that you supplied for a Track Header's
options field is not a defined option. There are only 2; 0vel
and off. The XXX indicates the line number where the erroneous
Track Header occurs in the source code.
Cause If the Options field is the last field on the Track Header line,
a | character hasn't closed the field, and what follows is a
comment, MF_DSM may be regarding text in the comment as options.
Cure Always end the Options field with the | character.
Cause You separated the options with a non-space character(s).
Cure Only use blank space to separate options.
ΓòÉΓòÉΓòÉ 6.14. Line XXX: There are less Tracks defined than the '# of Tracks' indicates ΓòÉΓòÉΓòÉ
Synopsis There are less Track Header lines in your source code than your
MThd Header's # of Tracks field indicates. The XXX indicates
the line number where MF_ASM started searching for another Track
Header which it expected to find but never did.
Cause If your source does indeed have some Track Header line after the
line number displayed in the error message, then you've probably
made a mistake specifying the Track Header.
Cure Make sure that the Track Header line begins with Track #, and
that it is the first text on that line.
Cause The MThd # of Tracks indicates more tracks than you intended, or
you forgot to add that many Track Header lines to the source
code.
Cure Make sure that these conditions match.
ΓòÉΓòÉΓòÉ 6.15. Line XXX: Undefined Event Type ΓòÉΓòÉΓòÉ
Synopsis The second field of an event line (ie, the Event Type field) has
some text that isn't recognized as one of the defined event
types (as listed in the Disassembly Format's Event Type Field
sections). The XXX indicates the line number where MF_ASM found
an event type that it didn't understand.
Cause That erroneous line was supposed to be a comment, but MF_ASM
thought it was an event line, which it didn't make sense as.
Cure Make sure that you didn't use the | character in your comment.
Also make sure that you didn't forget the End of track event at
the end of any track prior to where the error occurred.
Cause You misspelled the Event Type.
Cure Learn to spell.
Cause You forgot the Event Type field entirely, or didn't place it as
the second field.
Cure Read this entire book again, dummy, this time with your eyes
open.
ΓòÉΓòÉΓòÉ 6.16. Line XXX: Missing Event Type ΓòÉΓòÉΓòÉ
Synopsis MF_ASM encounters what appears to be an event line with only a
Time field (ie, missing all other fields). The XXX indicates
the line number where MF_ASM found the erroneous line.
Cause That erroneous line was supposed to be a comment, but MF_ASM
thought it was an event line, which it didn't make sense as.
Cure Make sure that you didn't use the | character in your comment.
Also make sure that you didn't forget the End of track event at
the end of any track prior to where the error occurred.
Cause You forgot the Event Type field entirely, or didn't place it as
the second field.
Cure Read this entire book again, dummy, this time with your eyes
open.
ΓòÉΓòÉΓòÉ 6.17. Line XXX: No 'End of Track' event for Track ΓòÉΓòÉΓòÉ
Synopsis MF_ASM nevers found the required End of track event line at the
end of a track. The XXX indicates the line number where MF_ASM
might have expected such an event.
Cure Make sure that the Track Header line before where the error
occurred has a subsequent End of track event.
ΓòÉΓòÉΓòÉ 6.18. Line XXX: Sysex data byte has value > 127 (ie, 0x7F) ΓòÉΓòÉΓòÉ
Synopsis While processing a Sysex, First Packet, Packet, or Last Packet
event, MF_ASM encountered a data value greater than 0x7F. This
is not a legal value for a data byte in a sysex message (with
the exception of the first and last bytes). The XXX indicates
the line number where MF_ASM encountered the illegal value.
Cause The len field of that event specifies more values than you
intended, or you forgot to specify all of those values.
Cure Check the len field of the event. Then, count how many values
you've supplied. Make sure that the two match.
Cause You have a comment at the end of the line which contains numeric
characters (ie, 1 ,2, 3, etc).
Cure For these Sysex events, it's best to place comments only after
all of the data values.
ΓòÉΓòÉΓòÉ 6.19. Line XXX: Note transposed out of range ΓòÉΓòÉΓòÉ
Synopsis The pitch ended up being transposed above or below the legal
MIDI note range. For example, transposing a C-1 more than 12
half steps down will cause it to be transposed out of range.
The XXX indicates the line number upon which the out of range
transposition occurred.
Cure Change the pitch specified on that line so that it doesn't
transpose out of range. Or, delete that event if it isn't
needed. Or, change the Transpose amount for that track so that
it doesn't force the event out of range.
ΓòÉΓòÉΓòÉ 6.20. Line XXX: Note out of range ΓòÉΓòÉΓòÉ
Synopsis The specified pitch for this event is beyond the legal MIDI note
range. For example G#33 is way out of range. The XXX indicates
the line number in the source code upon which the bad pitch
occurs.
Cure Check the pitch specified on that line. If you have a comment
at the end of the line, make sure that the pitch field is ended
with a | character, and that the comment doesn't contain | or =
characters.
ΓòÉΓòÉΓòÉ 6.21. Line XXX: Unknown contr ID SSS ΓòÉΓòÉΓòÉ
Synopsis The controller ID text specified for the contrl # field isn't
one of the defined ID's. The XXX indicates the line number in
the source code upon which the erroneous event occurs.
Cure Make sure that the ID you specified is one of the ID's specified
on the Controller Event Type page.
ΓòÉΓòÉΓòÉ 6.22. Line XXX: N/D Time signature doesn't make sense ΓòÉΓòÉΓòÉ
Synopsis The time signature field of a Time Signature event is illegal.
The XXX is the line number in the source code upon which the
erroneous event occurs. N is the "numerator" that MF_ASM found,
and D is the "denominator".
Cure Make sure that you only specify 2, 4, 8, 16, 32 for the
denominator. Don't specify a 0 numerator.
ΓòÉΓòÉΓòÉ 6.23. Line XXX: Bad KKK key signature ΓòÉΓòÉΓòÉ
Synopsis The key signature field of a Key Signature event is incorrectly
specified. The XXX is the line number in the source code upon
which the erroneous event occurs. KKK is the key that MF_ASM
found.
Cure Make sure that you only specify one of the following keys (in
major or minor):
Cb Gb Db Ab Eb Bb F C G D A E B F# C#
ΓòÉΓòÉΓòÉ 6.24. Had an error while saving the MIDI file ΓòÉΓòÉΓòÉ
Synopsis MF_ASM encountered an error trying to write data to the MIDI
file that it is creating.
Cause There is no more free space upon the media to which MF_ASM is
writing.
Cure Save to a drive or floppy with more free space.
ΓòÉΓòÉΓòÉ 6.25. Line XXX: Unknown field for event ΓòÉΓòÉΓòÉ
Synopsis While processing an event line, MF_ASM encountered some field
containing a field name that it doesn't recognize for that event
type. The XXX is the line number in the source code upon which
the extraneous field occurs.
Cause You misspelled a field name (ie, transpoze).
Cure Learn to spell.
Cause You used a | or = character in a comment at the end of the event
line.
Cure Do not use either of these characters in a comment at the end of
any event line.
Cause You used a field name that doesn't belong to this event. For
example, a Poly Press event does not have a Pitch field even
though an On Note event does.
Cure Consult the appropriate section in the Event Types to determine
what field names a particular event allows.
ΓòÉΓòÉΓòÉ 6.26. Line XXX: Deleting a note-off without a matching note-on before it ΓòÉΓòÉΓòÉ
Synopsis While processing an Off Note or (Off) Note event line, MF_ASM
recognizes that this event does not have a respective On Note
event preceding it. MF_ASM therefore deletes this Off or (Off)
Note since it has no purpose in the track. The XXX is the line
number in the source code upon which the extraneous event
occurs.
Cause You deleted the preceding On Note for this (Off) or Off.
Cure Remember to always delete On Note and Off or (Off) events in
pairs. Every On Note must have a subsequent Off or (Off) on the
same channel and with the same pitch.
Cause You edited the Chan and/or Pitch fields of the preceding On Note
for this (Off) or Off without making the same changes to the Off
or (Off).
Cure Make sure that each On Note is paired with a subsequent Off or
(Off) event on the same channel and with the same pitch.
ΓòÉΓòÉΓòÉ 6.27. Line XXX: Unknown field for MThd Header ΓòÉΓòÉΓòÉ
Synopsis While processing an MThd Header line, MF_ASM encountered some
field containing a field name that it doesn't recognize for the
MThd. The XXX is the line number in the source code upon which
the extraneous field occurs.
Cause You misspelled a field name (ie, # of traks).
Cure Learn to spell.
Cause You used a | or = character in a comment at the end of the MThd
Header line.
Cure Do not use either of these characters in a comment at the end of
any event line.
Cause You used a field name that doesn't belong to the MThd. For
example, the MThd Header does not have a Chan field.
Cure Consult the MThd Header line section to determine what field
names an MThd Header allows.
ΓòÉΓòÉΓòÉ 6.28. Line XXX: Unknown field for Track Header ΓòÉΓòÉΓòÉ
Synopsis While processing a Track Header line, MF_ASM encountered some
field containing a field name that it doesn't recognize for the
Track Header. The XXX is the line number in the source code
upon which the extraneous field occurs.
Cause You misspelled a field name (ie, transpoze).
Cure Learn to spell.
Cause You used a | or = character in a comment at the end of the Track
Header line.
Cure Do not use either of these characters in a comment at the end of
any event line.
Cause You used a field name that doesn't belong to the Track Header.
For example, the Track Header does not have a Format field.
Cure Consult the Track Header Fields section to determine what field
names a Track Header allows.
Cause You forget the | character at end of a field that requires it
(ie, the fields that require filenames such as map or filter
need to be terminated with a |, even if at the end of the Track
Header line).
Cure Make sure that there's a | character at the end of each field.
ΓòÉΓòÉΓòÉ 6.29. Line XXX: Unknown field for Unknown Chunk ΓòÉΓòÉΓòÉ
Synopsis While processing an Unknown Chunk, MF_ASM encountered some field
containing a field name that it doesn't recognize. The XXX is
the line number in the source code upon which the extraneous
field occurs.
Cause You misspelled a field name (ie, length instead of len).
Cure Use the abbreviation.
Cause You used a | or = character in a comment at the end of the line
after the Unknown Chunk Header.
Cure Do not use either of these characters in a comment at the end of
any event line.
Cause You used a field name that doesn't belong to the Unknown Chunk.
The Unknown Chunk only has 2 fields; the ID and len fields.
Cure Consult the Unknown Chunk Fields section to determine what field
names an Unknown Chunk allows.
ΓòÉΓòÉΓòÉ 6.30. Line XXX: Unwritten Track Header ΓòÉΓòÉΓòÉ
Synopsis MF_ASM encountered more Track Header lines than the MThd # of
Tracks indicates. The XXX is the line number in the source code
upon which the extraneous Track Header line occurs.
Cause The MThd # of Tracks indicates less tracks than you intended, or
you forgot to remove extra Track Header lines (and their events)
from the source code.
Cure Make sure that these conditions are resolved.
ΓòÉΓòÉΓòÉ 6.31. Line XXX: Volume Clipped ΓòÉΓòÉΓòÉ
Synopsis The volume supplied for an On Note or Off Note was beyond 127.
It was therefore clipped to 127. The XXX is the line number in
the source code of the event whose volume was clipped.
Cause You set the Track Header's Vol to a very high percentage such
that clipping occurred.
Cure Lower the percentage, or lower the individual vol field of the
event that clipped.
Cause You specified a vol greater than 127.
Cure Observe that upper limit.
ΓòÉΓòÉΓòÉ 6.32. Line XXX: The following notes haven't been turned off for Track XXX ΓòÉΓòÉΓòÉ
Synopsis The end of a track was reached and there were On Note events in
the track which didn't have subsequent, matching Off or (Off)
events (ie, with the same Chan and Pitch). MF_ASM simply
displays this warning message. If you invoke the off Option
field in the Track Header line, then MF_ASM will automatically
generate the missing Off Note events. The XXX is the Track #
which has "stuck notes" in it. MF_ASM then also displays which
notes on each of the 16 possible MIDI channels in a track are
"stuck on".
Cause You deleted the respective Off Note for an On Note without also
deleting that On Note.
Cure Remember to always delete On Note and Off or (Off) events in
pairs. Every On Note must have a subsequent Off or (Off) on the
same channel and with the same pitch.
Cause You edited the Chan and/or Pitch fields of an Off Note without
making the same changes to its preceding, respective On Note.
Cure Make sure that each On Note is paired with a subsequent Off or
(Off) event on the same channel and with the same pitch.
ΓòÉΓòÉΓòÉ 6.33. Doesn't contain a MThd. Not a MIDI file ΓòÉΓòÉΓòÉ
Synopsis You tried to disassemble a binary file that isn't a MIDI file.
All MIDI files must begin with an MThd header. This one doesn't
and so it isn't a MIDI file.
ΓòÉΓòÉΓòÉ 6.34. Found misplaced running status. ΓòÉΓòÉΓòÉ
Synopsis While disassembling a MIDI file, MF_DSM discovered an aberration
in the format of some event in a track. This may be a corrupt
file.
ΓòÉΓòÉΓòÉ 6.35. Found an undefined status in the MIDI file ΓòÉΓòÉΓòÉ
Synopsis While disassembling a MIDI file, MF_DSM discovered an aberration
in the format of some track. This may be a corrupt file.
ΓòÉΓòÉΓòÉ 6.36. This is a mal-formed MIDI file ΓòÉΓòÉΓòÉ
Synopsis While disassembling a MIDI file, MF_DSM discovered an aberration
in the format. This may be a corrupt file.
ΓòÉΓòÉΓòÉ 6.37. Line XXX: Possibly less data values than len indicates ΓòÉΓòÉΓòÉ
Synopsis While processing a Sysex, First Packet, Packet, or Last Packet
event, MF_ASM encountered what appears to be less data values
specified than the event's len indicates. The XXX indicates the
line number where MF_ASM expected more data values, but instead
found a line that looks like the next event line.
Cause The len field of that event specifies more values than you
intended, or you forgot to specify all of those values.
Cure Check the len field of the event. Then, count how many values
you've supplied. Make sure that the two match.
Cause You have a comment which contains a | character.
Cure For these Sysex events, it's best to place comments only after
all of the data values, and don't use the | character.
ΓòÉΓòÉΓòÉ 6.38. Line XXX: Possibly less data values or text than len indicates ΓòÉΓòÉΓòÉ
Synopsis While processing a text type of event (ie, Track name,
Instrument, Marker, Cue Point, etc), MF_ASM encountered what
appears to be less data values or text specified than the
event's len indicates. The XXX indicates the line number where
MF_ASM expected more data values or text, but instead found a
line that looks like the next event line.
Cause The len field of that event specifies more values or text
characters than you intended, or you forgot to specify all of
those values.
Cure Check the len field of the event. Then, count how many values
or text characters you've supplied. Make sure that the two
match.
Cause You have a comment which contains a | character.
Cure For these text events, it's best to place comments only after
all of the data values or text, and don't use the | character.
Cause You omitted the closing > character at the end of a line's text.
Cure Make sure that each line upon which you specify the actual text
(as opposed to data values representing those ascii characters)
has < and > characters enclosing the text.