{"id":3043,"date":"2009-03-01T13:00:00","date_gmt":"2009-03-01T13:00:00","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/vbteam\/2009\/03\/01\/veni-midi-vici-generating-a-simple-midi-file-using-vb-part-2-matt-gertz\/"},"modified":"2024-07-05T13:31:52","modified_gmt":"2024-07-05T20:31:52","slug":"veni-midi-vici-generating-a-simple-midi-file-using-vb-part-2-matt-gertz","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/vbteam\/veni-midi-vici-generating-a-simple-midi-file-using-vb-part-2-matt-gertz\/","title":{"rendered":"Veni, MIDI, Vici: Generating a simple MIDI file using VB, part 2 (Matt Gertz)"},"content":{"rendered":"

In part 1 of this series, I constructed a pair of classes to supporting persisting MIDI data to files.  <\/span>In this entry, I\u2019ll now leverage that code to support an (admittedly limited) music editor experience.<\/font><\/p>\n

\n

Caveat<\/b>:  <\/span>As I mentioned in the first post, I\u2019m sure many readers will be far more knowledgeable about MIDI than I am, and will justifiably roll their eyes at this code due to its limited scope.  <\/span>I will only be generating simple type-1 MIDI files that only use the Note On and Note Off events, and which don\u2019t use metadata, targeting a \u201cSave\u201d scenario only.  <\/span>The idea of this exercise was to understand MIDI and how to code against it in VB, not to generate a fully-functional music generation program.  <\/span>Coding up \u201cLoad\u201d and supporting more of the MIDI functionality would be a more time-consuming process which maybe I\u2019ll get to one day.<\/font><\/font><\/p>\n<\/div>\n

I would love to be able to write a full-fledged editor with all of the music printed out, all WYSIWYG, but unfortunately I have a day job which would be impacted and so I\u2019m opting for the Commodore-128 experience I mentioned in the previous post.  <\/span>Basically, I will (arbitrarily) support four tracks of music, each track containing notes, and each note derived from the following format:<\/font><\/p>\n

d<\/b>Tv<\/i><\/font><\/font><\/p>\n

Where:<\/font><\/p>\n

\u00b7<\/font>         <\/span><\/span><\/span>d<\/b> is the duration of the note (a floating-point value; i.e., since 4\/4 time is assumed, 1.0 would be a quarter note, 1.5 would be a dotted quarter note, 0.5 an eighth note, etc.)<\/font><\/font><\/p>\n

\u00b7<\/font>         <\/span><\/span><\/span>T is the tone of the note (i.e., anything from ””’C through G””” or R (for rest))<\/font><\/p>\n

\u00b7<\/font>         <\/span><\/span><\/span>v<\/i> is the volume from 0 to 127 (i.e., &H0 through &HFF), which is never used for a rest.<\/font><\/font><\/p>\n

So, in my design, a track which played a whole-note (4 beats) middle C, rested for a half-note (2 beats), and then dropped down to ‘G for dotted quarter-note (1.5 beats), all at a volume of 60, would look like this:<\/font><\/p>\n

4.0C60, 2.0R, 1.5’G60<\/font><\/font><\/b><\/p>\n

That\u2019s not nearly as nice to look at as the actual musical score, but it will allow me to give an example of parsing text data, so on we go\u2026<\/font><\/p>\n

The form<\/font><\/h2>\n

On my Windows application, I have four combo boxes in a vertical pattern, with a long text box adjacent to each.  <\/span>The combos\u2019 DropDownStyle properties are all set to DropDownList, and the Items property for each is preset to be the numbers 1 through 15 (these numbers indicate MIDI channels), plus \u201cblank\u201d (a simple carriage return) \u2013 blank is the default value (i.e., unused track).  <\/span>The text boxes (which will contain the \u201cd<\/b>Tv<\/i>\u201d notes) all start out as ReadOnly = True, and switch to editable only if the corresponding combo channel is non-blank.  <\/span>I also have a \u201cSave\u201d button to generate the MIDI output, and I added a SaveDialog object as well.  <\/span>That\u2019s pretty much the extent of the form.  <\/span><\/font><\/font><\/p>\n

Back in the code, I\u2019ll add an instance of the MIDI object I defined in the previous post:<\/font><\/p>\n

Public<\/span> Class<\/span> Form1<\/span><\/p>\n

    <\/span>Private<\/span> Song As<\/span> New<\/span> MIDI<\/span><\/p>\n

 <\/span><\/p>\n

Now, I need to deal with the notes!<\/font><\/p>\n

Specifying the notes that can be used<\/font><\/h2>\n

In order to support the parsing of the track information, I\u2019ll need to translate the tone values from characters to the numbers that MIDI expects (of which there are 128).  <\/span>The best way to do this is to create a collection mapping the text value to the numeric value, so we can create the mapping once and be done with it:<\/font><\/p>\n

    <\/span>Private<\/span> Notes As<\/span> New<\/span> Collection<\/span><\/p>\n

    <\/span>Const<\/span> NumberOfNotes As<\/span> Integer<\/span> = 128<\/span><\/p>\n

Now, I could do something lame like:<\/font><\/p>\n

Notes.Add(60, <\/span>“<\/span>C<\/span>“<\/span>)<\/span><\/p>\n

Notes.Add(61, <\/span>“<\/span>C#<\/span>“<\/span>)<\/span><\/p>\n

 <\/font><\/span><\/p>\n

And so on, but there are 128 potential values, and some of them have multiple names (for every sharp, there\u2019s a corresponding flat), so that would be a lot of work.  <\/span>So, I wrote some helper routines to try to do this in a smarter way.<\/font><\/p>\n

First, I need to find out how many single quote marks I need to add to the note.  <\/span>Each quote preceding the note indicates an octave one lower than the one occupied by middle C; conversely, a quote following a note is indicative of a higher octave.  <\/span>(That is, \u2018C indicates a note that is one octave lower than middle C, whereas C\u2019 indicates a note that is one octave higher.)  <\/span>There are twelve distinct notes in an octave, including accidentals (flats and sharps), so for a given value, I divide by twelve to determine its octave, and use the remainder (modulus) to determine its position within that octave:<\/font><\/p>\n

    <\/span>Private<\/span> Sub<\/span> InitializeNotes()<\/span><\/p>\n

        <\/span>For<\/span> i As<\/span> Integer<\/span> = 0 To<\/span> NumberOfNotes – 1<\/span><\/p>\n

            <\/span>Dim<\/span> octave As<\/span> Integer<\/span> = i \\ 12<\/span><\/p>\n

            <\/span>Dim<\/span> tone As<\/span> Integer<\/span> = i Mod<\/span> 12<\/span><\/p>\n

 <\/span><\/p>\n

Then, for each number, I call a helper function to do the actual work of creating the textual representation of the corresponding note.  <\/span>\u201cC\u201d is the first note in MIDI, and so would have a remainder of zero:<\/font><\/p>\n

            <\/span>Select<\/span> Case<\/span> tone<\/span><\/p>\n

                <\/span>Case<\/span> 0<\/span><\/p>\n

                    <\/span>AddNote(i, octave, “C”<\/span>)<\/span><\/p>\n

                    <\/span>AddNote(i, octave – 1, “B#”<\/span>) ‘ A sharped B is technically in the next lower octave<\/span><\/span><\/p>\n

                <\/span>Case<\/span> 1<\/span><\/p>\n

                    <\/span>AddNote(i, octave, “C#”<\/span>)<\/span><\/p>\n

                    <\/span>AddNote(i, octave, “Db”<\/span>)<\/span><\/p>\n

                <\/span>Case<\/span> 2<\/span><\/p>\n

                    <\/span>AddNote(i, octave, “D”<\/span>)<\/span><\/p>\n

 <\/span><\/p>\n

(And so on.)  <\/span>Note that I am adding two notes for each accidental (one for its sharp representation, and one for its flat representation), since I don\u2019t want to force the user to use a specific one.  <\/span>I also accommodate B# (= C), E# (= F), Fb ( = E), and Cb (= B), though these are rarely used in most music.  <\/span>(I don\u2019t currently support double-flats or double-sharps, though it would be easy enough to do \u2013 just add more entries.) <\/font><\/p>\n

At the end of these 128 additions, I also add an entry for rests directly:<\/font><\/p>\n

      <\/span>          <\/span>Case<\/span> 11<\/span><\/p>\n

                    <\/span>AddNote(i, octave, “B”<\/span>)<\/span><\/p>\n

                    <\/span>AddNote(i, octave + 1, “Cb”<\/span>) ‘ A flatted C is technically in the next higher octave<\/span><\/span><\/p>\n

            <\/span>End<\/span> Select<\/span><\/span><\/p>\n

        <\/span>Next<\/span><\/span><\/p>\n

 <\/span><\/p>\n

        <\/span>Notes.Add(NumberOfNotes, “R”<\/span>)<\/span><\/p>\n

    <\/span>End<\/span> Sub<\/span><\/span><\/p>\n

 <\/span><\/p>\n

AddNote() is a simple method that determine the quotes (if any) for the note and appends them or prepends them in the right order.  <\/span>(The 5th<\/sup> octave is the middle octave and therefore has no quotes.)<\/font><\/p>\n

    <\/span>Private<\/span> Sub<\/span> AddNote(ByVal<\/span> value As<\/span> Integer<\/span>, ByVal<\/span> octave As<\/span> Integer<\/span>, ByVal<\/span> noteName As<\/span> String<\/span>)<\/span><\/p>\n

        <\/span>Dim<\/span> octaveQuotes As<\/span> String<\/span> = GetOctaveQuotes(octave)<\/span><\/p>\n

        <\/span>If<\/span> octave < 5 Then<\/span><\/span><\/p>\n

            <\/span>Notes.Add(value, octaveQuotes & noteName)<\/span><\/p>\n

        <\/span>ElseIf<\/span> octave > 5 Then<\/span><\/span><\/p>\n

            <\/span>Notes.Add(value, noteName & octaveQuotes)<\/span><\/p>\n

        <\/span>Else<\/span><\/span><\/p>\n

            <\/span>Notes.Add(value, noteName)<\/span><\/p>\n

        <\/span>End<\/span> If<\/span><\/span><\/p>\n

    <\/span>End<\/span> Sub<\/span><\/span><\/p>\n

 <\/span><\/p>\n

You\u2019ll note that I use yet another helper function (GetOctaveQuotes) to get the actual number of quotes which are appended or prepended.  <\/span>The number of quotes increases as you move away from the middle octave:<\/font><\/p>\n

    <\/span>Private<\/span> Function<\/span> GetOctaveQuotes(ByVal<\/span> octave As<\/span> Integer<\/span>) As<\/span> String<\/span><\/span><\/p>\n

        <\/span>Dim<\/span> octaveQuotes As<\/span> New<\/span> StringBuilder<\/span><\/p>\n

        <\/span>If<\/span> octave < 5 Then<\/span><\/span><\/p>\n

            <\/span>octaveQuotes.Append(“‘”<\/span>, 5 – octave)<\/span><\/p>\n

        <\/span>Else<\/span><\/span><\/p>\n

            <\/span>octaveQuotes.Append(“‘”<\/span>, octave – 5)<\/span><\/p>\n

        <\/span>End<\/span> If<\/span><\/span><\/p>\n

        <\/span>Return<\/span> octaveQuotes.ToString<\/span><\/p>\n

    <\/span>End<\/span> Function<\/span><\/span><\/p>\n

 <\/span><\/p>\n

And now we have everything we need to initialize the notes.  <\/span>My form\u2019s Load() event calls that initialization, and also creates the four tracks that we\u2019ll support:<\/font><\/p>\n

    <\/span>Private<\/span> Sub<\/span> Form1_Load(ByVal<\/span> sender As<\/span> System.Object, ByVal<\/span> e As<\/span> System.EventArgs) Handles<\/span> MyBase<\/span>.Load<\/span><\/p>\n

        <\/span>Song.AddTrack()<\/span><\/p>\n

        <\/span>Song.AddTrack()<\/span><\/p>\n

        <\/span>Song.AddTrack()<\/span><\/p>\n

        <\/span>Song.AddTrack()<\/span><\/p>\n

 <\/span><\/p>\n

        <\/span>InitializeNotes()<\/span><\/p>\n

    <\/span>End<\/span> Sub<\/span><\/span><\/span><\/p>\n

Form events<\/font><\/h2>\n

There are only two interesting events in my code \u2013 changing the channel on a track, and saving the music to a MIDI file.<\/font><\/p>\n

Track changes<\/font><\/h3>\n

When the track changes, I want to disable or enable the corresponding text box based on whether or not the channel is blank.  <\/span>If it is blank, then I disable the text box and clear its contents; otherwise, I enable it.  <\/span>Rather than create a separate event handler for each combo box, I address them all in one handler:<\/font><\/p>\n

    <\/span>Private<\/span> Sub<\/span> Track1Channel_SelectedIndexChanged(ByVal<\/span> sender As<\/span> System.Object, ByVal<\/span> e As<\/span> System.EventArgs) _<\/span><\/p>\n

        <\/span>Handles<\/span> Track1Channel.SelectedIndexChanged, Track2Channel.SelectedIndexChanged, Track3Channel.SelectedIndexChanged, Track4Channel.SelectedIndexChanged<\/span><\/p>\n

 <\/span><\/p>\n

By casting the sender<\/b> object to a ComboBox, I\u2019ll be able to determine which combo box sent the event, and which text box corresponds with it.  <\/span>(The index<\/b> value will be used later to identify the song\u2019s specific track which corresponds to a given combo\/text set.)<\/font><\/p>\n

        <\/span>Dim<\/span> combo As<\/span> ComboBox = CType<\/span>(sender, ComboBox)<\/span><\/p>\n

        <\/span>Dim<\/span> text As<\/span> TextBox<\/span><\/p>\n

        <\/span>Dim<\/span> index As<\/span> Integer<\/span> = 0<\/span><\/p>\n

        <\/span>If<\/span> combo Is<\/span> Track1Channel Then<\/span><\/span><\/p>\n

            <\/span>text = Track1<\/span><\/p>\n

            <\/span>index = 0<\/span><\/p>\n

        <\/span>ElseIf<\/span> combo Is<\/span> Track2Channel Then<\/span><\/span><\/p>\n

            <\/span>text = Track2<\/span><\/p>\n

            <\/span>index = 1<\/span><\/p>\n

        <\/span>ElseIf<\/span> combo Is<\/span> Track3Channel Then<\/span><\/span><\/p>\n

            <\/span>text = Track3<\/span><\/p>\n

            <\/span>index = 2<\/span><\/p>\n

        <\/span>Else<\/span><\/span><\/p>\n

            <\/span>text = Track4<\/span><\/p>\n

            <\/span>index = 3<\/span><\/p>\n

        <\/span>End<\/span> If<\/span><\/span><\/p>\n

 <\/span><\/p>\n

Now, it\u2019s pretty straightforward to the activations or deactivations.  <\/span>The \u201cblank\u201d choice is in index 0 in my combobox, so if the selected index is 0, I turn everything off (after a prompt, of course), otherwise, I turn everything on.  <\/span>In either case, I update the appropriate track with its new channel:<\/font><\/p>\n

        <\/span>If<\/span> combo.SelectedIndex = 0 Then<\/span><\/span><\/p>\n

            <\/span>If<\/span> MsgBox(“Delete all of the track information?”<\/span>) = MsgBoxResult.Ok Then<\/span><\/span><\/p>\n

                <\/span>text.ReadOnly = True<\/span><\/span><\/p>\n

                <\/span>text.Text = “”<\/span><\/span><\/p>\n

                <\/span>Song.Tracks(index).TrackData.Clear()<\/span><\/p>\n

                <\/span>Song.Tracks(index).Channel = -1<\/span><\/p>\n

            <\/span>Else<\/span><\/span><\/p>\n

                <\/span>‘ Change the index back — Channel must be non-zero<\/span><\/span><\/p>\n

                <\/span>combo.SelectedIndex = Song.Tracks(index).Channel – 1<\/span><\/p>\n

            <\/span>End<\/span> If<\/span><\/span><\/p>\n

        <\/span>Else<\/span><\/span><\/p>\n

            <\/span>text.ReadOnly = False<\/span><\/span><\/p>\n

            <\/span>Song.Tracks(index).Channel = combo.SelectedIndex – 1<\/span><\/p>\n

        <\/span>End<\/span> If<\/span><\/span><\/p>\n

 <\/span><\/p>\n

Note that I\u2019m cheating a little in that code \u2013 I happen to know that channel 0 is in index 1, channel 1 is in index 2, etc.  <\/span>This allows me to take a shortcut and a priori<\/i> know that the channel is simply the selected index minus 1, rather than getting the text from the combobox and converting it to an integer.<\/font><\/p>\n

Saving the music to a MIDI file<\/font><\/h3>\n

In order to save the music the user has specified, I need to translate the text he or she entered into MIDI format bytes and insert them into the tracks.  <\/span>I do the bulk of this work via a function called GenerateTrack, which takes a textbox and it\u2019s corresponding track index as arguments, and which returns False if the track generation failed (because of a bad format or because it was not a valid track). Throughout this method, I will throw an exception any time I see a badly formatted music string so I can handle those errors all in one place.  <\/span><\/font><\/font><\/p>\n

    <\/span>Private<\/span> Function<\/span> GenerateTrack(ByVal<\/span> trackTextBox As<\/span> TextBox, ByVal<\/span> index As<\/span> Integer<\/span>) As<\/span> Boolean<\/span><\/span><\/p>\n

 <\/span><\/p>\n

The first thing to do verify that that track is valid (i.e., has a valid channel assigned to it), and clear out any existing track information:<\/font><\/p>\n

        <\/span>If<\/span> Not<\/span> Song.Tracks(index).ValidTrack Then<\/span><\/span><\/p>\n

            <\/span>Return<\/span> False<\/span><\/span><\/p>\n

        <\/span>End<\/span> If<\/span><\/span><\/p>\n

        <\/span>Song.Tracks(index).TrackData.Clear()<\/span><\/p>\n

 <\/span><\/p>\n

Next, I retrieve the music text and remove any spaces in the text:<\/font><\/p>\n

        <\/span>Dim<\/span> musicText As<\/span> String<\/span> = trackTextBox.Text<\/span><\/p>\n

        <\/span>musicText = musicText.Replace(” “<\/span>, “”<\/span>) ‘ Remove whitespace characters<\/span><\/span><\/p>\n

 <\/span><\/p>\n

I\u2019ve then defined a couple of index counters to allow me to walk through the musicText<\/b>, as well as a Double which will allow me to remember rests (which, in my application, are just delays between two notes and not really a thing in and of themselves):<\/font><\/p>\n

        <\/span>Dim<\/span> currentIndex As<\/span> Integer<\/span> = 0<\/span><\/p>\n

        <\/span>Dim<\/span> count As<\/span> Integer<\/span> = 0<\/span><\/p>\n

        <\/span>Dim<\/span> restBeats As<\/span> Double<\/span> = 0.0<\/span><\/p>\n

 <\/span><\/p>\n

Now, I loop over the characters in the string to begin parsing them:<\/font><\/p>\n

        <\/span>While<\/span> currentIndex < musicText.Length() <\/span><\/p>\n

 <\/span><\/p>\n

Step 1 is to get the beats associated with a note.  <\/span>I start with the current character and keep stepping until I find something that isn\u2019t a number or a decimal point.  <\/span>(And If I find a decimal point, I make sure that I haven\u2019t already found one on this note.)  <\/span>If I find no numbers, or too many decimals, or a decimal without a fractional part, I throw an error.  <\/span>Otherwise, I convert the number to a true Double.  <\/span>During all of this, currentIndex<\/b> points to the presumed beginning of the beats<\/b>, and count<\/b> contains the number of characters to consume in the beats<\/b>:<\/font><\/p>\n

            <\/span>Dim<\/span> beats As<\/span> Double<\/span> = 0.0<\/span><\/p>\n

            <\/span>Dim<\/span> dot As<\/span> Boolean<\/span> = False<\/span><\/span><\/p>\n

            <\/span>While<\/span> (musicText(currentIndex + count) >= “0”<\/span> _<\/span><\/p>\n

             <\/span>AndAlso<\/span> musicText(currentIndex + count) <= “9”<\/span>) _<\/span><\/p>\n

              <\/span>OrElse<\/span> musicText(currentIndex + count) = “.”<\/span><\/span><\/p>\n

                <\/span>If<\/span> musicText(currentIndex + count) = “.”<\/span> Then<\/span><\/span><\/p>\n

                    <\/span>If<\/span> dot = True<\/span> Then<\/span><\/span><\/p>\n

                        <\/span>Throw<\/span> New<\/span> ApplicationException(“Bad beat format in track “<\/span> & _<\/span><\/p>\n

                           <\/span>index.ToString())<\/span><\/p>\n

                    <\/span>Else<\/span><\/span><\/p>\n

                        <\/span>dot = True<\/span><\/span><\/p>\n

                    <\/span>End<\/span> If<\/span><\/span><\/p>\n

                <\/span>End<\/span> If<\/span><\/span><\/p>\n

                <\/span>count += 1<\/span><\/p>\n

            <\/span>End<\/span> While<\/span><\/span><\/p>\n

 <\/span><\/p>\n

            <\/span>‘ Now get the beats!<\/span><\/span><\/p>\n

            <\/span>If<\/span> count = 0 OrElse<\/span> (count = 1 AndAlso<\/span> dot = True<\/span>) Then<\/span><\/span><\/p>\n

                <\/span>Throw<\/span> New<\/span> ApplicationException(“No beats found for a note in track “<\/span> & _<\/span><\/p>\n

                   <\/span>index.ToString())<\/span><\/p>\n

            <\/span>End<\/span> If<\/span><\/span><\/p>\n

            <\/span>beats = Double<\/span>.Parse(musicText.Substring(currentIndex, count))<\/span><\/p>\n

 <\/span><\/p>\n

Having gotten this far, I update currentIndex point past the beats and reset count to zero \u2013 time to get the note!<\/font><\/p>\n

            <\/span>currentIndex = currentIndex + count<\/span><\/p>\n

            <\/span>count = 0<\/span><\/p>\n

 <\/span><\/p>\n

            <\/span>Dim<\/span> note As<\/span> Integer<\/span> = 0<\/span><\/p>\n

 <\/span><\/p>\n

Getting the note is very similar to getting the beats, except in this case I\u2019m paying attention to quotes and accidentals instead of decimal points.  <\/span>Quotes can appear on either the left side or the right, but not both, so I need to have a Boolean to indicate if I\u2019ve already found quotes on the left side:<\/font><\/p>\n

            <\/span>Dim<\/span> foundQuotes As<\/span> Boolean<\/span> = False<\/span><\/span><\/p>\n

            <\/span>While<\/span> musicText(currentIndex + count) = “‘”<\/span><\/span><\/p>\n

                <\/span>count += 1<\/span><\/p>\n

                <\/span>foundQuotes = True<\/span><\/span><\/p>\n

            <\/span>End<\/span> While<\/span><\/span><\/p>\n

 <\/span><\/p>\n

Next I\u2019ll look for the note.  <\/span>Since the note (excluding the # or b) only takes one character, this is an easy check to see if the next character is A through G (notes) or R (a rest):<\/font><\/p>\n

           <\/span>If<\/span> (musicText(currentIndex + count) < “A”<\/span> _<\/span><\/p>\n

           <\/span>  <\/span>OrElse<\/span> musicText(currentIndex + count) > “G”<\/span>) _<\/span><\/p>\n

AndAlso<\/span> musicText(currentIndex + count) <> “R”<\/span> Then<\/span><\/span><\/p>\n

                <\/span>Throw<\/span> New<\/span> ApplicationException(“Unrecognized note in track “<\/span> & _<\/span><\/p>\n

                  <\/span>index.ToString())<\/span><\/p>\n

            <\/span>End<\/span> If<\/span><\/span><\/p>\n

            <\/span>count += 1<\/span><\/p>\n

 <\/span><\/p>\n

And then I check for a flat or sharp and update the counter if I find one.  <\/span><\/font><\/font><\/p>\n

            <\/span>If<\/span> musicText(currentIndex + count) = “#”<\/span> _<\/span><\/p>\n

              <\/span>OrElse<\/span> musicText(currentIndex + count) = “b”<\/span> Then<\/span><\/span><\/p>\n

                <\/span>count += 1<\/span><\/p>\n

            <\/span>End<\/span> If<\/span><\/span><\/p>\n

 <\/span><\/p>\n

Now I check again for quote marks, remembering that if I found them on the left side, I\u2019d better not find them on the right side (a note can\u2019t be both higher and lower than the middle octave):<\/font><\/p>\n

            <\/span>While<\/span> musicText(currentIndex + count) = “‘”<\/span><\/span><\/p>\n

                <\/span>If<\/span> foundQuotes = True<\/span> Then<\/span><\/span><\/p>\n

                    <\/span>Throw<\/span> New<\/span> ApplicationException(“Quotes on both side of a note in track “<\/span> & _<\/span><\/p>\n

                       <\/span>index.ToString())<\/span><\/p>\n

                <\/span>End<\/span> If<\/span><\/span><\/p>\n

                <\/span>count += 1<\/span><\/p>\n

            <\/span>End<\/span> While<\/span><\/span><\/p>\n

 <\/span><\/p>\n

Now I can get the note and look it up in my collection, and then update the counters again to grab the volume:<\/font><\/p>\n

            <\/span>Dim<\/span> key As<\/span> String<\/span> = musicText.Substring(currentIndex, count)<\/span><\/p>\n

            <\/span>note = Notes(key)<\/span><\/p>\n

 <\/span><\/p>\n

            <\/span>currentIndex = currentIndex + count<\/span><\/p>\n

            <\/span>count = 0<\/span><\/p>\n

 <\/span><\/p>\n

Okay, that\u2019s two down.  <\/span>The final thing I need to retrieve from a given \u201cd<\/b>Tv\u201d <\/i>triplet is the volume, which is an integer.  <\/span>However, rests don\u2019t have volumes, and since I\u2019ve defined a rest as NumberOfNotes, I can just check that value to see if I need to read a volume:<\/font><\/p>\n

            <\/span>Dim<\/span> volume As<\/span> Integer<\/span> = 0<\/span><\/p>\n

            <\/span>If<\/span> note <> NumberOfNotes Then<\/span> ‘ Rests don’t have volumes<\/span><\/span><\/p>\n

 <\/span><\/p>\n

(If the user provided a volume for a rest, I\u2019ll catch that later and correctly throw an error when I try to parse the next note.) <\/font><\/p>\n

Since this is just an integer, the rest of the code is easy \u2013 I keep crawling while the current character is 0 through 9, and if I get to the end and have found nothing, I\u2019ll throw an error.  <\/span>Otherwise, I\u2019ll just translate the volume to a true Integer and update the counters for the next thing to find:<\/font><\/p>\n

                <\/span>While<\/span> currentIndex + count < musicText.Length() _<\/span><\/p>\n

               <\/span>  <\/span>AndAlso<\/span> musicText(currentIndex + count) >= “0”<\/span> _<\/span><\/p>\n

                 <\/span>AndAlso<\/span> musicText(currentIndex + count) <= “9”<\/span><\/span><\/p>\n

                    <\/span>count += 1<\/span><\/p>\n

                <\/span>End<\/span> While<\/span><\/span><\/p>\n

 <\/span><\/p>\n

                <\/span>If<\/span> currentIndex = 0 Then<\/span><\/span><\/p>\n

                    <\/span>Throw<\/span> New<\/span> ApplicationException(“No volume found for a note in track “<\/span> & index.ToString())<\/span><\/p>\n

                <\/span>End<\/span> If<\/span><\/span><\/p>\n

 <\/span><\/p>\n

                <\/span>volume = Integer<\/span>.Parse(musicText.Substring(currentIndex, count))<\/span><\/p>\n

 <\/span><\/p>\n

                <\/span>currentIndex = currentIndex + count<\/span><\/p>\n

                <\/span>count = 0<\/span><\/p>\n

            <\/span>End<\/span> If<\/span><\/span><\/p>\n

 <\/span><\/p>\n

That\u2019s it for the parsing of that note; now I can update the track with the results.  <\/span>There are two cases here: either I have a note, or I have a rest.  <\/span>In the case of a rest, all I do is cache the duration of the rest.  <\/span>If it\u2019s a note, I turn the note on after any cached rest, turn it off after a certain number of beats, and then clear the rest cache:<\/font><\/p>\n

            <\/span>If<\/span> note = NumberOfNotes Then<\/span><\/span><\/p>\n

                <\/span>restBeats = beats ‘ A rest; just have the next note start later<\/span><\/span><\/p>\n

            <\/span>Else<\/span><\/span><\/p>\n

                <\/span>Song.Tracks(index).AddNoteOnOffEvent(restBeats,_<\/span><\/p>\n

                       <\/span>MIDI.Track.NoteEvent.NoteOn, CByte<\/span>(note), CByte<\/span>(volume))<\/span><\/p>\n

                <\/span>Song.Tracks(index).AddNoteOnOffEvent(beats, _<\/span><\/p>\n

                       <\/span>MIDI.Track.NoteEvent.NoteOff, CByte<\/span>(note), 0)<\/span><\/p>\n

                <\/span>restBeats = 0<\/span><\/p>\n

            <\/span>End<\/span> If<\/span><\/span><\/p>\n

 <\/span><\/p>\n

I\u2019ve finished working with the note, so I\u2019ll see if there\u2019s another note by checking the value of currentIndex<\/b> compared to the length of the string.  <\/span>If I\u2019m at the end, I can exit the while loop:<\/font><\/p>\n

            <\/span>If<\/span> currentIndex >= musicText.Length Then<\/span><\/span><\/p>\n

                <\/span>Exit<\/span> While<\/span> ‘ No more notes!<\/span><\/span><\/p>\n

            <\/span>End<\/span> If<\/span><\/span><\/p>\n

 <\/span><\/p>\n

Otherwise, I\u2019ll verify that the next character is a comma.  <\/span>If it is, then I\u2019ll increment appropriately and loop back.  <\/span>Otherwise, it\u2019s an error:<\/font><\/p>\n

            <\/span>If<\/span> musicText(currentIndex) = “,”<\/span> Then<\/span><\/span><\/p>\n

                <\/span>currentIndex += 1<\/span><\/p>\n

            <\/span>Else<\/span><\/span><\/p>\n

                <\/span>Throw<\/span> New<\/span> ApplicationException<\/span> <\/span>(“Missing comma in track “<\/span> & index.ToString())<\/span><\/p>\n

            <\/span>End<\/span> If<\/span><\/span><\/p>\n

        <\/span>End<\/span> While<\/span><\/span><\/p>\n

 <\/span><\/p>\n

Being out of the While<\/b> loop, I need to verify that data got saved.  <\/span>If currentIndex is non-zero, then I know that I saved data (because it I ran into trouble later, I would have thrown an error). If I didn\u2019t save data, then I need to return False:<\/font><\/p>\n

        <\/span>If<\/span> currentIndex = 0 Then<\/span><\/span><\/p>\n

            <\/span>Return<\/span> False<\/span> ‘ Nothing got written out<\/span><\/span><\/p>\n

        <\/span>End<\/span> If<\/span><\/span><\/p>\n

 <\/span><\/p>\n

If we\u2019ve gotten this far, then the generation was successful, and we\u2019re done:<\/font><\/p>\n

        <\/span>Return<\/span> True<\/span><\/span><\/p>\n

    <\/span>End<\/span> Function<\/span><\/span><\/p>\n

 <\/span><\/p>\n

Now, finally, I can support the \u201cSave\u201d button.  <\/span>I\u2019ll double click on it to generate the handler, and then start adding code.  <\/span>First, I need try to generate each track.  <\/span>If all of them returned False, then there was nothing to save, and I\u2019ll abort the operation.  <\/span>But, since GenerateTrack() can also throw exceptions, I\u2019ll add a Try-Catch structure to catch those.  <\/span>The catch handler will display the error to the user, and then abort the save:<\/font><\/p>\n

    <\/span>Private<\/span> Sub<\/span> Save_Click(ByVal<\/span> sender As<\/span> System.Object, ByVal<\/span> e As<\/span> System.EventArgs) Handles<\/span> Save.Click<\/span><\/p>\n

        <\/span>Try<\/span><\/span><\/p>\n

            <\/span>If<\/span> GenerateTrack(Track1, 0) = False<\/span> And<\/span> _<\/span><\/p>\n

               <\/span>GenerateTrack(Track2, 1) = False<\/span> And<\/span> _<\/span><\/p>\n

               <\/span>GenerateTrack(Track3, 2) = False<\/span> And<\/span> _<\/span><\/p>\n

               <\/span>GenerateTrack(Track4, 3) = False<\/span> Then<\/span><\/span><\/p>\n

                <\/span>MsgBox(“No tracks had valid data to write out”<\/span>)<\/span><\/p>\n

                <\/span>Return<\/span><\/span><\/p>\n

            <\/span>End<\/span> If<\/span><\/span><\/p>\n

        <\/span>Catch<\/span> ex As<\/span> Exception<\/span><\/p>\n

            <\/span>MsgBox(“Error while saving: “<\/span> & ex.Message.ToString)<\/span><\/p>\n

            <\/span>Return<\/span><\/span><\/p>\n

        <\/span>End<\/span> Try<\/span><\/span><\/p>\n

 <\/span><\/p>\n

It\u2019s important to use \u201cAnd\u201d for that instead of \u201cAndAlso,\u201d because otherwise you\u2019ll short-circuit tracks and not write them in.<\/font><\/p>\n

Next, I need to pop up the save dialog box to determine where to save the file to.  <\/span>I\u2019ll pre-populate this to call the file \u201cUntitled.mid\u201d and have it point to \u201cMy Documents:\u201d<\/font><\/p>\n

        <\/span>Me<\/span>.SaveMIDIDialog.DefaultExt = “MID”<\/span><\/span><\/p>\n

        <\/span>Me<\/span>.SaveMIDIDialog.FileName = _<\/span><\/p>\n

My<\/span>.Computer.FileSystem.CombinePath(My<\/span>.Computer.FileSystem.SpecialDirectories.MyDocuments, _<\/span><\/p>\n

“Untitled.mid”<\/span>)<\/span><\/p>\n

        <\/span>Me<\/span>.SaveMIDIDialog.InitialDirectory = _<\/span><\/p>\n

            <\/span>My<\/span>.Computer.FileSystem.SpecialDirectories.MyDocuments<\/span><\/p>\n

        <\/span>Me<\/span>.SaveMIDIDialog.Filter = “VB MIDI files (*.MID)|*.MID”<\/span><\/span><\/p>\n

 <\/span><\/p>\n

Then, assuming that the user didn\u2019t cancel, I just call Save on the MIDI song:<\/font><\/p>\n

        <\/span>Dim<\/span> result As<\/span> DialogResult = Me<\/span>.SaveMIDIDialog.ShowDialog<\/span><\/p>\n

        <\/span>If<\/span> result = DialogResult.OK Then<\/span><\/span><\/p>\n

            <\/span>Song.Save(SaveMIDIDialog.FileName)<\/span><\/p>\n

        <\/span>End<\/span> If<\/span><\/span><\/p>\n

 <\/span><\/p>\n

    <\/span>End<\/span> Sub<\/span><\/span><\/p>\n

 <\/span><\/p>\n

And that\u2019s it!  <\/span>Launch the app, and you can start inserting music, save it, and then double-click on the resulting file to play it in Windows Media Player (or whatever you\u2019ve got MIDI file set to).  <\/span>Here\u2019s a couple samples from Howard Shore\u2019s \u201cThe Fellowship of the Ring\u201d score:<\/font><\/p>\n

Sample 1:<\/font><\/font><\/u><\/b><\/p>\n

First track, channel 0<\/b>: 1B’60,1.75C”65, 0.25B’70, 0.25C”75, 0.25B’80, 0.25A’85, 0.25C”90, 1.0B’95, 3.0E’80<\/font><\/font><\/p>\n

Second track, channel 1<\/b>: 4.0G60, 4.0A60<\/font><\/font><\/p>\n

Third track, channel 2<\/b>: 4.0’D#60, 4.0’F#60<\/font><\/font><\/p>\n

Fourth track, channel 3<\/b>: 4.0”C60, 2.0”’B80, 1.0”C#60, 1.0”D60<\/font><\/font><\/p>\n

 <\/font><\/p>\n

Sample 2:<\/font><\/font><\/u><\/b><\/p>\n

First track, channel 0<\/b>: 2.0D60, 1.5C70, 0.25C70,0.25C70, 3.5D70, 0.25G60, 0.25A60, 1.5Bb60, 0.25A70, 0.25G70, 1.5F70, 0.25G70, 0.25A70, 2.0G70, 1.0F65, 1.0E60<\/font><\/font><\/p>\n

Second track, channel 1<\/b>2.0’A60, 1.5’A60, 0.25’A70,0.25’A70, 3.5’A70,0.25’G60, 0.25’A60, 2.0’F60, 2.0’A70, 2.0’G70, 1.0’F65, 1.0’G60<\/font><\/font><\/p>\n

Third track, channel 2<\/b>: 2.0’F#60, 1.5’F60, 0.25’F70,0.25’F70, 4.0’F#70, 2.0’D60, 2.0’F70, 2.0’D70, 1.0’D65, 1.0’E60<\/font><\/font><\/p>\n

Fourth track, channel 3<\/b>: 2.0”D60, 1.5”F60, 0.25”F70,0.25”F70,4.0”D70, 2.0”Bb60, 2.0”A70, 2.0”D70, 1.0”Bb65, 1.0’C60<\/font><\/font><\/p>\n

 <\/font><\/p>\n

This is obviously just the tip of the iceberg \u2013 by adding to this application, I could assign different instruments to different tracks (via the \u201cProgramChange\u201d event), persist metadata containing lyrics, and so on.  <\/span>(I don\u2019t plan on doing that myself, since for me I simply wanted to learn more about MIDI, but who knows?  <\/span>Maybe later….)  <\/span>The completed code (along with another method which describes setting metadata) is attached to this blog post, and will also be posted on my <\/span><\/font><\/font>Temple of VB<\/font><\/span><\/a> site.<\/font><\/span><\/p>\n

\u2018Til next time,<\/font><\/span><\/p>\n

  <\/span>–Matt–*<\/font><\/font><\/span><\/p>\n

VBMidiEditor.zip<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"

In part 1 of this series, I constructed a pair of classes to supporting persisting MIDI data to files.  In this entry, I\u2019ll now leverage that code to support an (admittedly limited) music editor experience. Caveat:  As I mentioned in the first post, I\u2019m sure many readers will be far more knowledgeable about MIDI than […]<\/p>\n","protected":false},"author":258,"featured_media":8818,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[22,195],"tags":[101,165,166],"class_list":["post-3043","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-matt-gertz","category-visual-basic","tag-matt-gertz","tag-vb2005","tag-vb2008"],"acf":[],"blog_post_summary":"

In part 1 of this series, I constructed a pair of classes to supporting persisting MIDI data to files.  In this entry, I\u2019ll now leverage that code to support an (admittedly limited) music editor experience. Caveat:  As I mentioned in the first post, I\u2019m sure many readers will be far more knowledgeable about MIDI than […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/posts\/3043","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/users\/258"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/comments?post=3043"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/posts\/3043\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/media\/8818"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/media?parent=3043"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/categories?post=3043"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/tags?post=3043"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}