spiffyscore

Changes On Branch 5a35ffdd27abbc2f
Login

Changes On Branch 5a35ffdd27abbc2f

Hide Diff Patch Unified Diff

Changes In Branch tld Through [5a35ffdd27] Excluding Merge-Ins

This is equivalent to a diff from 3d4ddcbab5 to 5a35ffdd27

2010-11-17
07:30
Added support for rest notes Closed-Leaf check-in: aa88358397 user: spiffytech@gmail.com tags: tld
06:57
Note duration is now counted as fraction of a whole note, as measured based on BPM check-in: 5a35ffdd27 user: spiffytech@gmail.com tags: tld
06:27
TLD now accepts ordering of movements. Also, fixed bug that caused all movements and instruments to play simultaneously. check-in: db1df2f460 user: spiffytech@gmail.com tags: tld
00:07
Added support for top-down composition check-in: 7c7ce6adb8 user: spiffytech@gmail.com tags: tld
2010-11-16
19:15
Added todo list Leaf check-in: 3d4ddcbab5 user: spiffytech@gmail.com tags: ply
18:37
Now prints csound code, both notes and chords, replicating the functionality of the original Minimaly Functional Version check-in: 9bd31df856 user: spiffytech@gmail.com tags: ply

Modified cfg.py from [8e359b2146] to [f7b2188978]. 

1
2

3
4
5
6
7
8
9
10
11



12







13
14
15






16
17

18
19





20


21

















22
23

24
25
26

27
28
29











30






31

32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

78
79
80
81
82
83



84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

#!/usr/bin/env python


import os
import random
import sys
import time
random.seed(time.time())
import parse

def main():
    key = "A"



    note_grammars = {







        "u": ["I V V V I I IV u u", "I IV u u", "I VII IV u u"  , "e"],
        "e": [""],
    }






    chord_grammars = {
        "u": ['"I" "IV" "V" "IV" "I" u u', '"I" "VII" "IV" u u', '"I" "V" "IV" u u', "e"],

        "e": [""]
    }





    compose_piece(key, note_grammars)


    compose_piece(key, chord_grammars, chords=True)


















def compose_piece(key, grammars, chords=False):

    score = ""
    while len(score.split()) < 10:
        score = "u u u"

        score = generate_score(score, grammars)
    score = parse.parse(score)
    score = transliterate_score(score, key, chords)











    score = generate_csound_score(score)






    print "f1  0   256 10  1 0 3   ; sine wave function table"

    for line in score:
        print line


def make_scale(key):
    notes = ["A", "A#", "B", "C", "C#", "D", "D#", "E", "F", "F#", "G", "G#"]
    scale = [key]
    pos = notes.index(key)
    progression = [2,2,1,2,2,2,1]
    for p in progression:
        pos = (pos + p) % 12
        scale.append(notes[pos])
    return scale


def generate_score(score, grammars):
    while 1:
        found_substitution = False
        for key,value in grammars.iteritems():
            if score.find(key) != -1:
                found_substitution = True
                while score.find(key) != -1:
                    score = score.replace(key, random.choice(grammars[key]), 1)
                    if len(score) > 200:
                        score = score.replace("u", "")
                        score = score.replace("e", "")
                        return score
        if found_substitution is False:
            break
    return score

def transliterate_score(score, key, chords=False):
    scale = make_scale(key)
    scale_conversion = {
        "I": 1,
        "II": 2,
        "III": 3,
        "IV": 4,
        "V": 5,
        "VI": 6,
        "VII": 7,
        "VIII": 8,
    }
    keyed_score = []
    if chords is False:
        for i in range(len(score)):

            score[i].value = scale[scale_conversion[score[i].value]-1]
    else:
        for i in range(len(score)):
            chord = []
            root_note_index = scale.index(key) + scale_conversion[score[i].value]
            chord.append(scale[root_note_index])



            chord.append(scale[(root_note_index+3) % 8])
            chord.append(scale[(root_note_index+5) % 8])
            score[i].chord = chord
    return score


def generate_csound_score(score):
    csound_note_values = {
        "C": "00",
        "C#": "01",
        "D": "02",
        "D#": "03",
        "E": "04",
        "F": "05",
        "F#": "06",
        "G": "07",
        "G#": "08",
        "A": "09",
        "A#": "10",
        "B": "11",
    }
    t = 0 
    csound_score = []
    for token in score:
        if isinstance(token, parse.Chord):  # Chords
            for note in token.chord: 
                note = csound_note_values[note]
                csound_score.append("i2 %(time)f 1 7000 %(octave)d.%(note)s %(octave)d.%(note)s 0 6" % {"time": t, "octave": random.choice([7,8]), "note": note})
            t += 1
        else:  # Individual notes
            note = csound_note_values[token.value]
            csound_score.append("i2 %(time)f 1 7000 %(octave)d.%(note)s %(octave)d.%(note)s 0 6" % {"time": t, "octave": random.choice([8,9]), "note": note})
            t += .25
    return csound_score


if __name__ == "__main__": main() 



>









>
>
>
|
>
>
>
>
>
>
>
|
|
|
>
>
>
>
>
>
|
|
>
|
|
>
>
>
>
>
|
>
>
|
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
|
|
>
|
|
|
>
|
|
|
>
>
>
>
>
>
>
>
>
>
>
|
>
>
>
>
>
>
|
>
|
|
|




















|







|












<
|
>

|
<



>
>
>
|




















<





|
<


|
<





1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

138
139
140
141

142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168

169
170
171
172
173
174

175
176
177

178
179
180
181

#!/usr/bin/env python

from __future__ import division
import os
import random
import sys
import time
random.seed(time.time())
import parse

def main():
    key = "A"
    bps = 80/60
    print bps
    tempo = 1/bps

    composition = {
        "a": {  # Movement block 'a' for reuse throughout the piece
            "melody": {  # Instrument 'melody'
                "csound_parameters": {
                    "instrument": 1,
                },
                "grammars": {  # Notes for this instrument to use in this piece
                    "u": ["I V V V I I IV u u", "I IV u u", "I VII IV u u"  , "e"],
                    "e": [""],
                },
                "score": "u u u u u",
            },
            "rhythm": {
                "csound_parameters": {
                    "instrument": 1,
                },
                "grammars": {
                    "u": ['"I" "ii"/4 "ii"/4 "IV"/2 "V"2 "IV" "I" u u', '"I" "vii" "IV" u u', '"I" "v" "IV" u u', "e"],
#                    "u": ['"i" "I" "ii" "II" "v" "V" u', "e"],
                    "e": [""]
                },
                "score": "u u u",
            },
        },
        "b": {
            "melody": {  # Instrument 'melody'
                "csound_parameters": {
                    "instrument": 1,
                },
                "grammars": {  # Notes for this instrument to use in this piece
                    "u": ["I V I I/2 IV/2 u u", "I2 IV u u", "I IV IV VI V u u" , "e"],
#                    "u": ["I IV I V u u u", "e"],
                    "e": [""],
                },
                "score": "u u u",
            },
            "rhythm": {
                "csound_parameters": {
                    "instrument": 1,
                },
                "grammars": {
                    "u": ['"I" "IV"/2 "V"2 "IV" "I" u u', '"I" "VII" "IV" u u', '"I" "V" "IV" u u', "e"],
                    "e": [""]
                },
                "score": "u u u",
            },
        },
    }

    max_t = 0  # max time encountered so far. Used for movement timing
    progression = "a b"
    for comp_name in progression.split():
        instr_start_time = max_t
        for instr_name, instr in composition[comp_name].iteritems():
            generated_score = generate_score(instr["score"], instr["grammars"])  # Fill in the scores by generating them based on the grammars
            score = parse.parse(generated_score)  # Return Node/Chord objects

            # Generate timestamps for the notes 
            t = instr_start_time
            for note in range(len(score)):
                score[note].time = t
#                print "Original duration:", score[note].duration
                score[note].duration *= tempo
#                print "New duration:", score[note].duration
                t += score[note].duration
#                print "t:", t
                max_t = t if t > max_t else max_t
            composition[comp_name][instr_name]["score"] = score

    # Must be done after all note times keyed in, else you can't coordinate melodies with the rhythm chords
    for comp_name in progression.split():
        for instr_name, instr in composition[comp_name].iteritems():
            composition[comp_name][instr_name]["score"] = transliterate_score(composition[comp_name][instr_name]["score"], key)
#            print "\nMovement %s instrument %s" % (comp_name, instr_name)
#            print composition[comp_name][instr_name]["score"] 
            print "f1  0   256 10  1 0 3   ; sine wave function table"
            final_score = generate_csound_score(composition[comp_name][instr_name]["score"])
            for line in final_score:
                print line
            

def make_scale(key):
    notes = ["A", "A#", "B", "C", "C#", "D", "D#", "E", "F", "F#", "G", "G#"]
    scale = [key]
    pos = notes.index(key)
    progression = [2,2,1,2,2,2,1]
    for p in progression:
        pos = (pos + p) % 12
        scale.append(notes[pos])
    return scale


def generate_score(score, grammars):
    while 1:
        found_substitution = False
        for key,value in grammars.iteritems():
            if score.find(key) != -1:
                found_substitution = True
                while score.find(key) != -1:
                    score = score.replace(key, random.choice(grammars[key]), 1)
                    if len(score.split()) > 20:
                        score = score.replace("u", "")
                        score = score.replace("e", "")
                        return score
        if found_substitution is False:
            break
    return score

def transliterate_score(score, key):
    scale = make_scale(key)
    scale_conversion = {
        "I": 1,
        "II": 2,
        "III": 3,
        "IV": 4,
        "V": 5,
        "VI": 6,
        "VII": 7,
        "VIII": 8,
    }
    keyed_score = []

    for i in range(len(score)):
        if isinstance(score[i], parse.Note):
            score[i].value = scale[scale_conversion[score[i].value]-1]
        else:

            chord = []
            root_note_index = scale.index(key) + scale_conversion[score[i].value]
            chord.append(scale[root_note_index])
            if score[i].chord_type == "m":  # Minor chords, flat the 3rd
                chord.append(scale[(root_note_index+2) % 8])
            else:
                chord.append(scale[(root_note_index+3) % 8])
            chord.append(scale[(root_note_index+5) % 8])
            score[i].chord = chord
    return score


def generate_csound_score(score):
    csound_note_values = {
        "C": "00",
        "C#": "01",
        "D": "02",
        "D#": "03",
        "E": "04",
        "F": "05",
        "F#": "06",
        "G": "07",
        "G#": "08",
        "A": "09",
        "A#": "10",
        "B": "11",
    }

    csound_score = []
    for token in score:
        if isinstance(token, parse.Chord):  # Chords
            for note in token.chord: 
                note = csound_note_values[note]
                csound_score.append("i2 %(time)f %(duration)f 7000 %(octave)d.%(note)s %(octave)d.%(note)s 0 6" % {"time": token.time, "octave": random.choice([7,8]), "note": note, "duration": token.duration})

        else:  # Individual notes
            note = csound_note_values[token.value]
            csound_score.append("i2 %(time)f %(duration)f 7000 %(octave)d.%(note)s %(octave)d.%(note)s 0 6" % {"time": token.time, "octave": random.choice([8,9]), "note": note, "duration": token.duration})

    return csound_score


if __name__ == "__main__": main()

Modified parse.py from [503badc6f2] to [00dc77f47f]. 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

#!/usr/bin/env python

from ply import lex, yacc
class Note():
    def __init__(self, value, duration=.25, octave=8):
        self.value = value
        self.duration = duration
        self.octave = octave
        self.accidental = None
    def __repr__(self):
        return "Note %s %s %s" % (self.value, self.duration, self.octave)

class Chord():
    def __init__(self, value, duration=.25, chord_type="major"):
        self.value = value
        self.duration = duration
        self.chord_type = chord_type
    def __repr__(self):
        return "Chord %s %s %s" % (self.value, self.duration, self.chord_type)
















|








1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

#!/usr/bin/env python

from ply import lex, yacc
class Note():
    def __init__(self, value, duration=.25, octave=8):
        self.value = value
        self.duration = duration
        self.octave = octave
        self.accidental = None
    def __repr__(self):
        return "Note %s %s %s" % (self.value, self.duration, self.octave)

class Chord():
    def __init__(self, value, duration=.5, chord_type="major"):
        self.value = value
        self.duration = duration
        self.chord_type = chord_type
    def __repr__(self):
        return "Chord %s %s %s" % (self.value, self.duration, self.chord_type)
︙︙
100
101
102
103
104
105
106


107
108
109
110
111
112
113
114

        p[0] = new_note


    def p_chord(p):
        '''chord : QUOTE pitch QUOTE
                | QUOTE pitch CHORD_TYPE QUOTE
        '''


        p[0] = Chord(value=p[2].value)
        if len(p) > 3:
            p[0].chord_type = p[3]


    def p_accidental(p):
        '''pitch : ACCIDENTAL pitch
        '''








>
>
|








100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

        p[0] = new_note


    def p_chord(p):
        '''chord : QUOTE pitch QUOTE
                | QUOTE pitch CHORD_TYPE QUOTE
        '''
        pitch = p[2].value
        pitch = pitch.upper()
        p[0] = Chord(value=pitch)
        if len(p) > 3:
            p[0].chord_type = p[3]


    def p_accidental(p):
        '''pitch : ACCIDENTAL pitch
        '''
︙︙

Modified test.sco from [da39a3ee5e] to [a5eee77281]. 























































































































































































































































































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

1.33333333333
f1  0   256 10  1 0 3   ; sine wave function table
i2 0.000000 0.187500 7000 9.09 9.09 0 6
i2 0.187500 0.187500 7000 9.02 9.02 0 6
i2 0.375000 0.187500 7000 9.09 9.09 0 6
i2 0.562500 0.187500 7000 9.02 9.02 0 6
i2 0.750000 0.187500 7000 8.09 8.09 0 6
i2 0.937500 0.187500 7000 9.04 9.04 0 6
i2 1.125000 0.187500 7000 9.04 9.04 0 6
i2 1.312500 0.187500 7000 8.04 8.04 0 6
i2 1.500000 0.187500 7000 9.09 9.09 0 6
i2 1.687500 0.187500 7000 9.09 9.09 0 6
i2 1.875000 0.187500 7000 8.02 8.02 0 6
i2 2.062500 0.187500 7000 8.09 8.09 0 6
i2 2.250000 0.187500 7000 9.04 9.04 0 6
i2 2.437500 0.187500 7000 9.04 9.04 0 6
i2 2.625000 0.187500 7000 8.04 8.04 0 6
i2 2.812500 0.187500 7000 9.09 9.09 0 6
i2 3.000000 0.187500 7000 8.09 8.09 0 6
i2 3.187500 0.187500 7000 8.02 8.02 0 6
f1  0   256 10  1 0 3   ; sine wave function table
i2 0.000000 0.375000 7000 8.11 8.11 0 6
i2 0.000000 0.375000 7000 8.04 8.04 0 6
i2 0.000000 0.375000 7000 7.08 7.08 0 6
i2 0.375000 0.375000 7000 7.06 7.06 0 6
i2 0.375000 0.375000 7000 7.09 7.09 0 6
i2 0.375000 0.375000 7000 7.01 7.01 0 6
i2 0.750000 0.375000 7000 7.04 7.04 0 6
i2 0.750000 0.375000 7000 8.09 8.09 0 6
i2 0.750000 0.375000 7000 7.11 7.11 0 6
i2 1.125000 0.375000 7000 7.11 7.11 0 6
i2 1.125000 0.375000 7000 8.04 8.04 0 6
i2 1.125000 0.375000 7000 7.08 7.08 0 6
i2 1.500000 0.187500 7000 7.01 7.01 0 6
i2 1.500000 0.187500 7000 7.06 7.06 0 6
i2 1.500000 0.187500 7000 8.09 8.09 0 6
i2 1.687500 0.187500 7000 7.01 7.01 0 6
i2 1.687500 0.187500 7000 8.06 8.06 0 6
i2 1.687500 0.187500 7000 7.09 7.09 0 6
i2 1.875000 0.375000 7000 7.04 7.04 0 6
i2 1.875000 0.375000 7000 8.09 8.09 0 6
i2 1.875000 0.375000 7000 7.11 7.11 0 6
i2 2.250000 1.500000 7000 7.06 7.06 0 6
i2 2.250000 1.500000 7000 7.09 7.09 0 6
i2 2.250000 1.500000 7000 7.01 7.01 0 6
i2 3.750000 0.375000 7000 7.04 7.04 0 6
i2 3.750000 0.375000 7000 8.09 8.09 0 6
i2 3.750000 0.375000 7000 7.11 7.11 0 6
i2 4.125000 0.375000 7000 7.11 7.11 0 6
i2 4.125000 0.375000 7000 7.04 7.04 0 6
i2 4.125000 0.375000 7000 8.08 8.08 0 6
i2 4.500000 0.375000 7000 8.11 8.11 0 6
i2 4.500000 0.375000 7000 8.04 8.04 0 6
i2 4.500000 0.375000 7000 7.08 7.08 0 6
i2 4.875000 0.187500 7000 8.01 8.01 0 6
i2 4.875000 0.187500 7000 8.06 8.06 0 6
i2 4.875000 0.187500 7000 7.09 7.09 0 6
i2 5.062500 0.187500 7000 7.01 7.01 0 6
i2 5.062500 0.187500 7000 7.06 7.06 0 6
i2 5.062500 0.187500 7000 8.09 8.09 0 6
i2 5.250000 0.375000 7000 8.04 8.04 0 6
i2 5.250000 0.375000 7000 8.09 8.09 0 6
i2 5.250000 0.375000 7000 8.11 8.11 0 6
i2 5.625000 1.500000 7000 8.06 8.06 0 6
i2 5.625000 1.500000 7000 7.09 7.09 0 6
i2 5.625000 1.500000 7000 7.01 7.01 0 6
i2 7.125000 0.375000 7000 7.04 7.04 0 6
i2 7.125000 0.375000 7000 7.09 7.09 0 6
i2 7.125000 0.375000 7000 7.11 7.11 0 6
i2 7.500000 0.375000 7000 8.11 8.11 0 6
i2 7.500000 0.375000 7000 8.04 8.04 0 6
i2 7.500000 0.375000 7000 8.08 8.08 0 6
f1  0   256 10  1 0 3   ; sine wave function table
i2 7.875000 1.500000 7000 8.09 8.09 0 6
i2 9.375000 0.187500 7000 9.02 9.02 0 6
i2 9.562500 0.187500 7000 8.09 8.09 0 6
i2 9.750000 0.187500 7000 9.04 9.04 0 6
i2 9.937500 0.187500 7000 8.09 8.09 0 6
i2 10.125000 0.375000 7000 8.09 8.09 0 6
i2 10.500000 0.375000 7000 8.02 8.02 0 6
i2 10.875000 1.500000 7000 9.09 9.09 0 6
i2 12.375000 0.187500 7000 8.02 8.02 0 6
i2 12.562500 1.500000 7000 8.09 8.09 0 6
i2 14.062500 0.187500 7000 8.02 8.02 0 6
i2 14.250000 0.187500 7000 8.09 8.09 0 6
i2 14.437500 0.187500 7000 8.04 8.04 0 6
i2 14.625000 0.187500 7000 8.09 8.09 0 6
i2 14.812500 0.375000 7000 8.09 8.09 0 6
i2 15.187500 0.375000 7000 8.02 8.02 0 6
f1  0   256 10  1 0 3   ; sine wave function table
i2 7.875000 0.375000 7000 7.11 7.11 0 6
i2 7.875000 0.375000 7000 7.04 7.04 0 6
i2 7.875000 0.375000 7000 8.08 8.08 0 6
i2 8.250000 0.375000 7000 7.04 7.04 0 6
i2 8.250000 0.375000 7000 8.09 8.09 0 6
i2 8.250000 0.375000 7000 8.11 8.11 0 6
i2 8.625000 1.500000 7000 7.06 7.06 0 6
i2 8.625000 1.500000 7000 8.09 8.09 0 6
i2 8.625000 1.500000 7000 8.01 8.01 0 6
i2 10.125000 0.375000 7000 7.04 7.04 0 6
i2 10.125000 0.375000 7000 7.09 7.09 0 6
i2 10.125000 0.375000 7000 7.11 7.11 0 6
i2 10.500000 0.375000 7000 7.11 7.11 0 6
i2 10.500000 0.375000 7000 8.04 8.04 0 6
i2 10.500000 0.375000 7000 7.08 7.08 0 6
i2 10.875000 0.375000 7000 7.11 7.11 0 6
i2 10.875000 0.375000 7000 8.04 8.04 0 6
i2 10.875000 0.375000 7000 7.08 7.08 0 6
i2 11.250000 0.375000 7000 7.04 7.04 0 6
i2 11.250000 0.375000 7000 7.09 7.09 0 6
i2 11.250000 0.375000 7000 8.11 8.11 0 6
i2 11.625000 1.500000 7000 7.06 7.06 0 6
i2 11.625000 1.500000 7000 8.09 8.09 0 6
i2 11.625000 1.500000 7000 7.01 7.01 0 6
i2 13.125000 0.375000 7000 8.04 8.04 0 6
i2 13.125000 0.375000 7000 8.09 8.09 0 6
i2 13.125000 0.375000 7000 7.11 7.11 0 6
i2 13.500000 0.375000 7000 8.11 8.11 0 6
i2 13.500000 0.375000 7000 8.04 8.04 0 6
i2 13.500000 0.375000 7000 8.08 8.08 0 6
i2 13.875000 0.375000 7000 8.11 8.11 0 6
i2 13.875000 0.375000 7000 7.04 7.04 0 6
i2 13.875000 0.375000 7000 7.08 7.08 0 6
i2 14.250000 0.375000 7000 8.09 8.09 0 6
i2 14.250000 0.375000 7000 7.01 7.01 0 6
i2 14.250000 0.375000 7000 7.04 7.04 0 6
i2 14.625000 0.375000 7000 8.04 8.04 0 6
i2 14.625000 0.375000 7000 7.09 7.09 0 6
i2 14.625000 0.375000 7000 8.11 8.11 0 6
i2 15.000000 0.375000 7000 8.11 8.11 0 6
i2 15.000000 0.375000 7000 7.04 7.04 0 6
i2 15.000000 0.375000 7000 7.08 7.08 0 6
i2 15.375000 0.375000 7000 8.09 8.09 0 6
i2 15.375000 0.375000 7000 7.01 7.01 0 6
i2 15.375000 0.375000 7000 8.04 8.04 0 6
i2 15.750000 0.375000 7000 7.04 7.04 0 6
i2 15.750000 0.375000 7000 8.09 8.09 0 6
i2 15.750000 0.375000 7000 7.11 7.11 0 6

Modified todo.org from [9c9ed49773] to [1f5e1e7f07]. 

1
2
3
4


5
6


7









* Features [0/5]
- [ ] Top-down composition
- [ ] Transition the melody between chords appropriately
- [ ] Set maximum song length



* Bugs [0/1]


- [ ] Doesn't handle minor chords









|
|


>
>

|
>
>
|
>
>
>
>
>
>
>
>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

* Features [1/5]
- [X] Top-down composition
- [ ] Transition the melody between chords appropriately
- [ ] Set maximum song length
- [ ] Need to support all chord types
- [ ] Doesn't handle rest notes

* Bugs [4/5]
- [X] TLD resets clock for each movement
- [X] TLD doesn't accept an ordering for the movements
- [X] Doesn't handle minor chords    
- [X] Calculated duration is absolute, not relative to BPM
- [ ] Chords don't respect octaves


* Structure [0/3]    
- [ ] Chords should be composed of Notes, not ordinary arrays
- [ ] Generate score with proper generation tools
- [ ] Store csound score lines with instruments