DotMusic Language MIDI converter README

日本語訳はここ README on my blog をブラウザ翻訳してください。

This Visual Studio Code extension converts the text written in "DotMusic language" to a standard MIDI file. The language for music notation, which I came up with for simpler and easier use on computer keybords, might add a new casual way to your desktop music. I appreciate your patience with my awkward English in the following README in advance. Thank you!

What is it for?

By "casual" I mean, something like checking a chord progression, for instance. If you aren't able to play any musical instruments, programming on DAW is all the more troublesome for that kind of needs. For that occasion, you can add some symbols to the text of the chords as follows, and run it on the extension. (This is from "Hukashigi no karte(2018)")

    tempo(95) randomizeTiming(20) randomizeVelocity(15)
    { Gm7.. C#dim7.. Dm7.. [].. }*2 Gm7.. C#dim7.. Dm/<_D _C#>.. Dm/<_C __B>.. 
    BbM7/__Bb.. A7[^bc6]/_A.. Dm7[^c4]....

Then, you might feel like to try some arrangement based on this information.

    tempo(100) randomizeTiming(15) randomizeVelocity(10)
    channel(0) !! chord information
    {Gm7..C#dim7..Dm7....}*2 Gm7..C#dim7..Dm..Dm/C..BbM7..A7[bc6]..Dm7[c4]....:
    channel(1) duration(.5) !! piano
    {_c0 [c1, c2, c3].r []._c0 [].r [].}*8 :
    channel(2)  transpose(-12) octaveSymbol(-7) !! bass
    @pb={pitchBend(0 .1 .5 .9 -.99)} @bass={c0 c.(+c r,r +c).c (+c).r r r c+-.}
    {@@bass}*5 c0.bc0.c0.bc0(@pb). {@bass}*1*rrr1:
    channel(3) octaveSymbol(7) !! pad
    {[c0 c1 c2 c3 c4]..[]..}r4r*2*r2: 
    channel(4) transpose(-24) swingTiming(0 20 0 20) !! cajon set
    {0 (0).2.0.<(2)''''(2,<1 r r 2>)>.}*8: randomizeVelocity(30) {r (r,1)*3.}*32:
    transpose(0) randomizeVelocity(5) {r 10.}r16*16:

Phrases of the bass and cajon vary a little each time it is produced because of randomness.

If you write it tactfully, a lot of effort may be saved in programming music with the assistance of controlled randomness. Of course you know nothing about the language for now, so let's take a look and check if it's worth getting into it.

What is it for?
command
basic grammar and notes
altering pitch
playing at the same time
brackets for repeat
brackets for substitution
brackets for randomization
using scales
using scale symbols
using chords -- using chord names
using chords -- using degree chords
using chords symbols
using chords -- using channel 0
using other equal temperaments
functions and others
Known issues
Release note

command

This extension has only one command, "Convert DotMusic to MIDI". To make a DotMusic file, open a new text file and save it with filename extension ".dotmusic". Then this extension recognize it as a DotMusic file to highlight text, enable completion, etc. By default, it makes the MIDI file on your desktop, from where you can relocate the directory. With the command, you can also make a MIDI player play the file. These functions are explained in the last section.

basic grammar and notes

The simplest sentence in DotMusic would be like:

0.

The sentence above consists of a note symbol "0" and a dot "." A dot signifies a length of a beat. From this sentence, the extention's command will make a MIDI file, which is rendered into the sheet music above by MuseScore (music notation software).

The default note symbols are number figures. One octave has twelve notes ranging "C" to "B", as you know, so "0" to "11" substitute them. In addition, rests and ties are needed. An "r" is used for a rest, and a "t", a tie. These notes must be separated by spaces, dots or other symbols mentioned later.

0 .. 2 4. 5 6 7. 9 t 11.. r. ^0.

DotMusic doesn't care much about time signatures or measures. Actually, the relations of notes and dots can mean all about them. The next three sentences means just the same, the first four bars of "Twinkle, Twinkle, Little Star".

0. 0. 7. 7.  9. 9. 7..  5. 5. 4. 4. 2. 2. 0..

0 0 7 7 .... 9 9 7 t .... 5 5 4 4 .... 2 2 0 t ....

0 0 7 7 9 9 7 t ........ 5 5 4 4 2 2 0 t ........

altering pitch

A normal "0" note has a pitch of Middle C, or that of MIDI note number 60. There are some ways to change it.

Sharp "#" or flat "b" (Alphabet "b" looks like a flat, so...) makes the note one step higher or lower. Attach them before the note("#0", "b4", etc. You know they are just "1", "3", but there's a matter of feeling, I think).

A "^" attached before the note raises the pitch by the octave. Moreover, "^^0" makes "0" two octaves up. To lower octaves, add "_"s. "_0" makes "0" an octave down.

The function "transpose( )" transposes all the notes after it. "transpose(-12)" makes them an octave down, etc.

transpose(-12) _0. 0. b4. ^0. 
transpose(0) _0. 0. b4. ^0.

You might see other ways to control pitches later.

playing at the same time

To play notes at the same time, on top of each other, there are some ways.

Notes inside square brackets signifies a chord. "[0 4 7]" or "[0,4,7]" made C triad chord.

Slashes "/" and a semicolon ";" divide a sentence into parts which are played simultaneously. Please grasp the concept by the example below. ("!!" works as a line comment out)

!! Erik Satie "Gymnopedie No.1"
__7... / r. [_11 2 6].. ;
__2... / r. [_9 1 6].. ;

A colon ":" makes all the notes after it start from the beginning.

!! "Gymnopedie No.1" first eight bars
!! "{ }*4" repeats four times the content in the curly brackets

r. ^6. ^9.  ^7. ^6. ^1.  11. ^1. ^2.  9 ...  6 ... ... ... ... :
{ __7... /r. [_11 2 6].. ; __2... /r. [_9 1 6].. ; }*4

Complicatedly presented by MuseScore, it's logically right, though. Sounds all right anyway.

brackets for repeat

"{ }*X" repeats X times the content in the curly brackets.

{0.2.4.5.}*2

This turns "0.2.4.5.0.2.4.5."

Secondly, "{ }rX" does NOT repeat the content at all. So

{0.2.4.5.}r2

turns "r....r....". This is for the combined use of "*" and "r" as below.

{0.2.4.7.}*4r2*2

In this case, it repeats the content four times to play, then two times to rest, and two time to play again.

There are more advanced way to repeat, but may function a little unexpectedly. Please have your attentioin to the numbers of "*" and "r" in the example below. The notes on the beat correspond to "r" are cancelled.

{0.7.0 0.7.}*rrr2*r*r2*1**r*1

brackets for substitution

An alphanumeric name that starts with at mark "@" can substitute a sentence.

@Melody_1 ={0. 2 4. 5. 7. 5 4. 2. 0. r.}

Then "@Melody_1" has the same sentence as the content.

"@@Melody_1" is also valid, which will be explained in the next section.

brackets for randomization

Round brackets generate notes randomly. For example, "(0,2,4,r,5 7)*4" generate four elements picking out randomly from the content. The content in the brackets is dvided by comma, so it might be noteworthy that the fifth element of this is "5 7". Using these brackets with brackets to repeat would be beneficial to get modified rhythm patterns.

{ 0. (7,r)*4 .}*8

The repeat brackets make first "0. (7,r)*4 . 0. (7,r)*4 .0. (7,r)*4 .0. (7,r)*4 .0. (7,r)*4 .0. (7,r)*4 .0. (7,r)*4 .0. (7,r)*4 .", so below is just one instance this sentence generates.

If you drop from "(a,b,c)*X" the last part "*X", then "(a,b,c)" means "(a,b,c)*1".

Just one element and brackets "(0)" turns "0" or nothing. "0 (0)." turns "0 0." or "0."

If you use "@" name substituting a sentence including round brackets, what happens?

@melody_2 ={ 0 (2,4). }
{ @melody_2 }*4

@melody_2 substitutes either "0 2." or "0 4.", not "0 (2,4)." So if @melody_2 is repeated, the same pattern will be repeated. Round brackets's processing order is different from in repeat brackets.

If you write @@melody_2, then it has a content that is not yet randomaized.

using scales

From the notes of the temperament, we select the notes and name them as in any scale by "scale( )" function. This can be written in many variations as below. It might be needful tips that the elements seperated by comma in the brackets don't need to be in particular order, and that the scale name must be lower-case letters (so you can't use a "b" at the first letter of a scale name, because it's probably read as a flat"b". You can neither use a "c" alone as a name, because it's reserved for the chord functions).

You can name the notes each. This may have some educational meaning.

scale(0 2 4 5 7 9 11, do re mi fa so la si) 
do. do. so. so. la. la. so. r.  
fa. fa. mi. mi. re. re. do. r.

scale(0 2 4 5 7 9 11, io)
!! io0,io1,..,io6 each indicates 0,2,..,11
io0. io0. io4. io4. io5. io5. io4. r.
io3. io3. io2. io2. io1. io1. io0. r.

This means the same musical meaning as above. Or

scale(7, 0 2 4 5 7 9 11, g)
!! g0,g1,..,g6 each indicates 7,9,..,6

The first "7" of the function designates the keynote of the scale, so the entire scale is reinterpreted so. In this case, "0 2 4 5 7 9 11" turns into G major scale "7 9 11 0 2 4 6", and can be summoned with "gN" names.

The extension has the scales of "scale(s, 0 2 4 5 7 9 11)" by default. So

scale(4) 
!! s0,s1,..,s6 each indicates 4,6,..,3

"4" designates the keynote of E major. It turns the default C major into E major. Or

scale(0 2 3 5 7 8 10) 
!! s0,s0,..,s6 each indicates 0,2,..,10

This turns the default C major scale into C natural minor scale.

using scale symbols

Now suppose that you have set a pentatonic scale "scale(pen, 0 2 4 7 9)". You can use more symbols than "pen0" etc which indicates only a specific note.

"pen?": any note of the scale

"+pen": the note in the scale one step higher than the preceding one. You can add more "+"s ("++pen","+++pen") to get a higher scale note. If there are no preceeding notes, this takes the first note of the scale (the keynote).

"-pen": the note in the scale one step lower than the preceding one. More "-"s can be added, ---you get the idea.

"+-pen","pen": the same note as the preceding one. Or the nearest note. If there are two, one of them are randomly elected.

"T": chord symbols above attached "T" at the end ("pen0T","+penT",etc) work distantly. If there are no preceeding "T" note, it takes the first note of the scale. Please see the example.

"pen+": the note in the scale one step higher than the succeeding one. You can add more "+"s ("pen++","pen+++").

"pen-": the note in the scale one step lower than the succeeding one. You can add "-" simbols likewise.

"pen+-","pen": the same note as the succeeding one. Or the nearest note. If there are two, one of them are randomly elected.

If you had named the notes respectively, the name of the first note in the scale can be used as the base symbol. (In "do re mi fa so la si" scale, like "+do","do--")

These symbols might be beneficial when used in brackets.

scale(pen, 0 2 4 7 9)
{ pen? +pen. +pen --pen. +pen +pen. t.}*4

Below is almost the same as above, but is attached "T" at the last "+pen". Following notes with "T" refer to the preceeding "T" note, so you see the end note in each measure rising a step up against its preceeding "T" note. These control might give unity and a direction to the entire phrase.

scale(pen, 0 2 4 7 9)
{ pen? +pen. +pen --pen. +pen +penT. t.}*4

Or, using more brackets:

scale(pen, 0 2 4 7 9)
@melody_1 ={ pen? (r,+pen,-pen)*7 .... } 
@melody_2 ={ pen? (r,+pen,-pen)*7 .... }
{ @melody_1 }*4 { @melody_2 }*4

If you are lucky or write it more tactfully, it may produce a thing more like a tune.

using chords -- using chord names

You can use the chord names as follows. As for C root:

C, Cm, C7, Cm7, CM7, CmM7, C6, Cm6, Caug, Caug7, C-5, C7-5, Cm-5, Cm7-5, Cdim, Cdim7, Csus4, C7sus4

Both "C#m" and "#Cm" will do.

You can add tensions to them with square brackets. Whatever the chord is, the nineth note is indicated as "c4" ("c0"-root, "c1"-third, "c2"-fifth, "c3"-seventh, "c4"-nineth, "c5"-eleventh, "c6"-thirteenth), so you can write "Cm7[c4,#c5]", for instance. The conventional form of this chord is "Cm7(9,#11)".

You can use slash chords. A new non-chord root replace the original root. A mere slash"/" just omits the root.

CM7[c4].... C#dim7[c5,bc6].... Dm7[c4,c5].... B7[#c4,bc6]/D#....

Hum, this is jammed. It may be better to put tensions an octave up and to lower the roots an ovtave down using slashes.

CM7[^c4]/_C.... C#dim7[^c5,^bc6]/_C#.... Dm7[^c4,^c5]/_D.... B7[^#c4,^bc6]/_D#....

Now it sounds and looks better, I think.

You can also "omit" any of the chord tones. For example, the chord symbols attached "o" in the bracket "CM7[c1o,c2o,^c4]" or "CM7[oc1,oc2,^c4]" omit the third and fifth from the chord sound. The chord retain information about them, so you can still use them right after having omitted them.

CM7[c1o,c2o,^c4]/_C.... ;
CM7[c1o,c2o,^c4]/_C.... / r.c1.c2.^c4.;
!! Chords with a slash might be confusing with other slashes, I'm afraid

using chords -- using degree chords

Degree symbols "I","II","III","IV","V","VI","VII"(or more) represent a triad chord built on each note in the "s" scale. By default, a normal nakid "I" represents the first chord([0,4,7]) of it.

If you set another scale, its name can be attached before degree symbols. For instance, if you set "scale(pen, 0 2 4 7 9)", then "penI" represents the first chord "I" ([0 4 9]) of the "pen" scale. They are "penI","penII","penIII","penIV","penV". But this might only be needed in kind of experimental use (like in other than 12 equal divided temperaments). So let's go back to normal degree symbols for now.

A normal nakid degree symbol can be attached a chord symbol, tensions, a slash and new root after it. For instance, you can write "VII7[#c4,bc6]/#II...." or something.

When your "s" scale is a minor scale, your "I" is a minor traid chord. If you want to turn it into a major chord, then attach it a "M", write "IM". It turns to be a major triad chord. And vice versa, to turn "I" as a major chord into a minor chord "Im".

using chords symbols

Like in the case of scales, when chord names or degree chords (not a mere chord by square brackets) are set , you can use chord symbols "c0","c1",... as the token of its chord tones.

"cX" represents a current chord tone as follows: "c0"-root, "c1"-third, "c2"-fifth, "c3"-seventh, "c4"-nineth, "c5"-eleventh, "c6"-thirteenth

"c?": any note of the current chord

"+c": the note in the current chord one step higher than the preceding one. You can add more "+"s ("++c","+++c") to get a higher chord tone. If there are no preceeding notes, this takes the root.

"-c": the note in the current chord one step lower than the preceding one. More "-"s can be added.

"+-c", "c": the same note as the preceding one. Or, the nearest note. If there are two, one of them are randomly elected.

"T": chord simbols attached "T" at the end ("c0T","+cT", etc) work distantly. The following "T" note refers to the preceeding "T" note. If there are no preceeding notes, this takes the root.

"c+": the note in the current chord one step higher than the succeeding one. You can add more "+"s ("c++","c+++").

"c-": the note in the current chord one step lower than the succeeding one. You can add likewise.

"c+-": the same note as the succeeding one. It could be a non-chord tone.

using chords -- using channel 0

These chord symbols are beneficial when chords are set in "channel(0)". You know that MIDI has channels through 1 to 16, so this channel doesn't create MIDI data. It functions to be references for chord symbols, to tell them what chord is to be sounded at each time. A simple example for this:

channel(0) CM7....Em7....Dm7....G7....: 
channel(1) { _c0..../ r. c1. [c2,c3]. c1.; }*4

Don't forget a colon at the end of the first line. I forget sometimes.

using other equal temperaments

You can try other equal temperaments by the function equalTemperament(x). Say, equalTemperament(31) sets 31-tone equal temperament. This 31-TET has 31 notes 0, 1, 2, 3, . . . , 30. You can use scales from them. Degree chords and chord symbols are also available, but there are limitations; because pitches are modulated by using an pitch-bend eqipped in each MIDI channel, they are to be monophonic in the channel for the TET pitch. So, the program automatically use another channel when the notes are to be sounded at the same time. If you write "[0 4 7]" in some TET other than 12 at MIDI channel 1, the extension automatically use channel 1, 2, and 3 to sound each note in the chord. So you have to make some plan in advance.

Whether the modulated pitch is right or not depends on your tone generator's accuracy.

    equalTemperament(31)
    0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 
    ......................

I think these are what are supposed to sound, on SampleTank 4 CS:

But on Independence Free...

And even if machines are right, please don't put too much trust on the pitches, because I'm not 100% sure yet that my program to calculate pitch-bend value is right.

functions and others

midiFileName(x) sets a MIDI file name, like "midiFileName(myMusic_01.mid)". The default name is "midifile.mid". The command makes a file in your desktop. Or with a directory, "midiFileName(C:\Users\myDocument\mySong_02.mid)" will make a file there.
midiPlayer(x) sets the path of the MIDI player program you want to get to play, like "midiPlayer(C:\Program Files\Windows Media Player\wmplayer.exe)". If the path is given right, the player will start to play the MIDI file.
tempo(x) sets a tempo value(x: 1 to 915). The default tempo is 120.
channel(x) Set a MIDI channel ranging from 1(default) to 16, like "channel(2)". This program accepts "0" too, which sets chord progressions. Please see the description for the usage.
transpose(x) transposes the notes higher by x (positive or negative) "transpose(12)", "transpose(-24)",
octaveSymbol(x): decides from which note octave symbols("^","_") to be needed to alter octave for it. Setting the keynote number to x might make things clear.
```
  @C_major ={0 2 4 5 7 9 11 ^0}
  @G_major ={7 9 11 0 2 4 6 ^7}
  @C_major.... @G_major.... octaveSymbol(7) @G_major....
```
equalTemperament(x): Please see the "using other equal temperaments" section.
velocity(x) sets a velocity value(x: 0 to 127, or, if there is a decimal point in x, x is read as a percentage to the max velocity) for notes after this. The default velocity is 100.
duration(x) sets the actual duration of the sound of the note. x should be a ratio to 1 (the default value is 0.97). If you want to play the notes staccato, set x 0.3 or something.
velocity(x), duration(x), and pitchBend(x...) can be employed globally or locally. Notes can be attached round brackets "( )", and you can put one or both functions there to effect them locally, specifically for that one note. "0( velocity(.5), duration(.3) ).", or you can substitute them by some "@" name,
```
  velocity(110) @v ={ velocity(.5), duration(.3) }
  0. 2(@v). 4. 5(@v). 7.
  !! "0","4" and "7" are played with the velocity of 110, "2" and "5" are played with half the max velocity, and shorten to 30% of the default duration.
```
randomizeVelocity(x) subtracts a randomly produced value within x from the velocities of the notes. "randomizeVelocity(15)"
swingVelocity(x y z ..., a): The arguments which are divided by a space are values(positive or negative) to increase or decrease the velocity of the notes. They are allocated to a certain location according to the number of beats you see after a comma, which is "1" when it's omitted. The examples below might make this clear.
```
  swingVelocity(20 -10 20 -10) { 0 0 0 0 .}*4
  !! These are allocated to 4 sixteenth notes on 1 beat.
```

    swingVelocity(20 -10 -10 20 -10 -10 20 -10, 4) {0 0 0 0 0 0 0 0....}*2
    !! These are allocated to 8 eighth notes on 4 beats.

swingTiming(x y z ..., a) : The arguments which are divided by a space are tick values to move the timing of the notes. If the number is positive, the timing moves forwards, delayed. And if negative, vice versa. They are allocated to a certain position according to the number of beats you see after a comma, which is "1" when it's omitted. The concepts are similar to that of swingVelocity( ). The examples would demonstrate it.(In the resolution of 960, there are 960 ticks per beat.)
```
  tempo(90) swingTiming(0 70) {0 0.}*4
  !! This makes off-beat eighth notes delayed 70 ticks, which sounds kind of swingy.
```
```
  tempo(80) swingTiming(0 30 0 30) {0 0 0 0.}*4
  !! This makes second and fourth sixteenth notes delayed 35 ticks, which has a typical sixteenth swing feel, I think.
```
```
  swingTiming(0 -100 0, 3) {0 2 2 ...}*4
  !! This makes the second beat in triple-time put 100 ticks back. Mazurka sounds like this, doesn't it?
```

These are fun, but some MIDI players may quantize them.

randomizeTiming(x) sets a tick value of positive number within which tick values are randomly produced, so that the timing of each note will be moved by those values forward or backward. But your MIDI player may quantize them automatically, I'm afraid.
scale( ): please look at the using scales section.
avoid(x) : When "1" is set to x, scale symbols "+s","-s" etc skip the avoid notes in the scale.(the notes half step up the chord tones, though I'm not familiar with the notion)
pitchBend( ): This accepts many of arguments. A unit that consists of three(a:level b:tick c:level), five(a:level b:tick c:level d:tick e:level) or four(a:tick b:level c:tick d:times) elements divided by a space could be repeated more after a comma. Pitch bend levels take a positive or negative (-8192 to 8192, or -.99 to .99) number. "0" means the normal pitch of the note in any TET. Ticks are a number of tick length or its percentage for the length of the note. Here are some examples:
```
  !! three arguments
  @pb={ pitchBend(.99 .2 0) } 0(@pb).
```

This generates scores of MIDI events from the highest level of pitch bend to the default level over the 20% of the length of the note.

    !! five arguments
    @pb={ pitchBend(0 .1 -.99 .1 0) } 0(@pb).

This, from the default level to the bottom level over 10% of the length of the note, and to the default level over 10% of the length of the note.

    !! four arguments --vibrato
    @pb={ pitchBend(.1 -.99 .1 3) } 0(@pb).

This repeats the above example three times, which is indicated at the last argument. It can make vibratos.

    !! chaining units
    @pb={ pitchBend(.99 .2 0 , .1 -.99 .1 3) } 0(@pb).

And you can chain these units with a comma. This note plays according to the first example and then at 20% of the length starts the move of the third example.

ccModulation1( ), ccModulation7( ), ccModulation10( ), ccModulation11( ): This takes a MIDI control change number before the former bracket(cc number 1: modulation: default value 0, 7: volume: 100, 10: pan: 64, 11: expression: 127). This accepts the same sort of arguments as pitchBend( ). A unit that consists of three(a:level b:tick c:level), five(a:level b:tick c:level d:tick e:level) or four(a:tick b:level c:tick d:times) elements could be repeated more after a comma. Levels take a number ranging 0 to 127, or a percentage with a comma. Ticks are a number of tick length or its percentage for the length of the note.
```
  !! volume modulation along with pitch bend
  @pbvl={ pitchBend(.99 .2 0 , .1 -.99 .1 3), ccModulation7(127 .2 100, .1 50 .1 3) } 0(@pbvl).
```
grouping brackets < >: angle brackets group notes into a unit. These can be used in a slash chord.
- 0 2 4 5 7 .... <0 2> 4 5 7 .... (<0 2>,4,5,7)*8 ....
- CM7/<_C t t _#C> .... Dm7/<_D _F> ....
backward grouping brackets < ' >: When the content of angle brackets is divided by apostrophes, the latter part has the same timing and length as usual, but those of the former part moves backward according to the number of apostrophes. With one apostrophe, the same length as the latter moves at the timing backwards. With two apostrophes, half the length of it. With three apostrophes, a third the length of it. With four apostrophes, a fourth, and so on. For example, "0. t 2. 4 r..", "0.. <r 2 '4> r..", and "0.. <2''4> r.." each has the same musical meaning. Ah, yes, they might be a little different, exactly. Anyway, the brackets might keep it simple about dots in some situation. They are probably useful when you have to write ornaments, or make syncopation(<0''t>.) or flams in a drum pattern.
sustain pedal "pdl": this is not a function but a kind of a note, which has to take dots for its length. This doesn't work in TETs other than 12-TET. Even in 12-TET, whether pdl works or not depends on how your MIDI player, or tone generator, receive the MIDI message. TMIDI player, which is my recommendation, plays well. In the next sentence, "pdl...." prolongs "0" and "4" till the end of the fourth beat.

0.4.7.. / pdl.... ;
"[]" refers to the most recent chord. "CM7[c4].. [].." means "CM7[c4].. CM7[c4]..". But don't use this in channel 0, sorry.

printChord(x): "X" is the name of the scale which had been set. Notes so interpreted, a list of degree names correspondent to the chord's root, the chord's constituents, and the location is returend on the terminal.

  !! "s" is the default scale "0 2 4 5 7 9 11".
  printChord(s) CM7.... C#dim7.... FM7.... G7/D#....
  !! Then on your terminal:
  <chord>
  I(s) CM7(0,4,7,11): 0-3840
  ?(s) C#dim7(1,4,7,10): 3840-7680
  IV(s) FM7(5,9,0,4): 7680-11520
  V(s) G7(7,11,2,5/3): 11520-15360

printNote(channel,note,time,actualtime,freq,...): Set the items (suggested by the completion) to print information of the notes where you want to check. The list will be shown on the VScode terminal. Not to print, set nothing like "printNote()".
```
  printNote(channel,note,time) (0,2,4,r)*4....
  printNote() 4 2 0 r ....
  !! randomly generated notes showed on the terminal
  <note>
  ch:1 note:0(60) 0-960
  ch:1 note:2(62) 960-1920
  ch:1 note:4(64) 1920-2880
```
comment out
- !! comment out a line
- !" comment out multi lines "!
script: Between "%%" and "%%", you can write JavaScript code which returns string data. Below is evaluated as "0.2.4.7."
```
  %%
  function script(){
      return "0.2.4.7.";
  }
  script();
  %%
```

Requirements

Known Issues

It happened that some DAW couldn't open the file expectedly, though I didn't know why. They might too closely interpret the data? Instead of opening the file directly by DAWs, I play "TMIDI player" to sound DAWs through "loopMIDI". Please look up on the internet about those MIDI things.

Release Notes

1.0.0

Initial release of the extension 2023/01/14

1.0.1

Fixed issue #.

1.1.0

Added features X, Y, and Z.

Following extension guidelines

Ensure that you've read through the extensions guidelines and follow the best practices for creating your extension.

Extension Guidelines

Working with Markdown

Note: You can author your README using Visual Studio Code. Here are some useful editor keyboard shortcuts:

Split the editor (Cmd+\ on macOS or Ctrl+\ on Windows and Linux)
Toggle preview (Shift+CMD+V on macOS or Shift+Ctrl+V on Windows and Linux)
Press Ctrl+Space (Windows, Linux) or Cmd+Space (macOS) to see a list of Markdown snippets

For more information

Enjoy!

このブログを検索

Tadano Lunch Blog