spiffyscore

Check-in [befd61cab9]
Login

Check-in [befd61cab9]

Overview
Comment:Successfully got the program to output a MIDI file instead of a csound score
Timelines: family | ancestors | descendants | both | feature/midi
Files: files | file ages | folders
SHA1: befd61cab9abd44e8ac9a8962b3247214bf5d5b2
User & Date: brian on 2011-11-15 22:08:44
Other Links: branch diff | manifest | tags
Context
2011-11-15
22:09
Replaced csound support with midi support check-in: 0c3fb3e27f user: brian tags: develop
22:08
Successfully got the program to output a MIDI file instead of a csound score Closed-Leaf check-in: befd61cab9 user: brian tags: feature/midi
15:47
Attempted to make a csound based on midi. Failed. check-in: daa0ddb3ad user: brian tags: feature/midi
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Modified parse.py from [a8d0994825] to [bcac1af73f].

︙
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

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








-
+

-
-
+












+
+
+
+
+
+
+
+
+
+
-
+








        note.syncopate = p[2]


    def p_accidental(p):
        '''note : ACCIDENTAL note
        '''
        if p[1] == "^":
            p[2].value += "#"
            p[0] = p[2].value + 1
        else:
            p[2].value += "b"
        p[0] = p[2]
            p[0] = p[2].value - 1

    def p_octave(p):
        '''note : note OCTAVE
        '''
        count = len(p[2])
        increment_or_decrement = 1 if p[2].startswith("'") else -1
        p[1].octave += (count * increment_or_decrement)
        p[0] = p[1]

    def p_note(p):
        '''note : BASENOTE
        '''
        notes = {
            "C": 0,
            "D": 2,
            "E": 4,
            "F": 5,
            "G": 7,
            "A": 9,
            "B": 11
        }
        n = notes[p[1]]
        p[0] = Note(p[1], octave=default_octave)
        p[0] = Note(n, octave=default_octave)

    def p_rest(p):
        ''' rest : REST
                 | REST NOTE_LENGTH
        '''
        p[0] = Rest()
        if len(p) > 2:
︙

Modified spiffyscore.py from [390f3e8450] to [caa7e9ffa7]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16

17
18
19
20
21
22
23

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










+







+








#!/usr/bin/env python

from __future__ import division
import ipdb
import os
import random
import sys
import time

from midiutil.MidiFile import MIDIFile as midifile
import parse
import topsort
import yaml

import tree

random.seed(time.time())
mymidi = midifile(15)

def main():
    composition = {
        "fm_test": {
            "intro": {
                "melody": {  # Instrument 'melody'
                    "score_line": "i2 %(time)f %(duration)f 7000 %(octave)d.%(note)s 2 6 5 1",
︙
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

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








-
-
+
+
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+

-
+
-
-
+







+








                        "u": ["C/4 C/4 C/4 C/4"],
                    },
                },
            },
        },
        "sync_test": {
            "body": {
#                "lead_instr": {  # Instrument 'melody'
#                    "score_line": "i1 %(time)f %(duration)f 7000 %(octave)d.%(note)s %(octave)d.%(note)s 0 6",
                "lead_instr": {  # Instrument 'melody'
                    "channel": 6,
##                    "score_line": "i5 %(time)f %(duration)f 7000 %(octave)d.%(note)s",
#                    "octave": 7,
#                    "duration": 30,
#                    "grammars": {  # Notes for this instrument to use in this piece
##                        "u": ["A ^A B C ^C D ^D E F ^F G ^G"],
#                        "u": ["A/2, B/2, C/2 D/2 (u)", "D/2' D/2' D/2' D/2' (v)"],
#                        "v": ["C/2 C/2 C/2 C/2 (w)"],
#                        "w": ["E/2 F/2 E/2 F/2 (u)"],
#                    },
#                },
                    "octave": 4,
                    "duration": 30,
                    "grammars": {  # Notes for this instrument to use in this piece
#                        "u": ["A ^A B C ^C D ^D E F ^F G ^G"],
                        "u": ["A/2, B/2, C/2 D/2 (u)", "D/2' D/2' D/2' D/2' (x)"],
                        "v": ["C/2 C/2 C/2 C/2 (w)"],
                        "w": ["E/2 F/2 E/2 F/2 (u)"],
                        "x": ["z4 (v)"],
                    },
                },
                "follow_instr": {  # Instrument 'melody'
#                    "score_line": "i2 %(time)f %(duration)f 7000 %(octave)d.%(note)s 1",
                    "channel": 0,
                    "score_line": "i3 %(time)f %(duration)f 7000 %(octave)d.%(note)s",
#                    "sync": "lead_instr",
                    "sync": "lead_instr",
                    "octave": 2,
                    "duration": 30,
                    "grammars": {  # Notes for this instrument to use in this piece
#                        "u": ["A ^A B C ^C D ^D E F ^F G ^G"],
                        "u": ["E F G E (v)"],
                        "v": ["G A A A (e)", "G A A A (v)"],
                        "e": ["B A G A (u)"],
                        "x": ["z4 (e)"],
                    },
                },
#                "instr2": {  # Instrument 'melody'
#                    "score_line": "i1 %(time)f %(duration)f 7000 %(octave)d.%(note)s %(octave)d.%(note)s 0 6",
#                    "score_line": "i1 %(time)f %(duration)f 7000 %(octave)d.%(note)s %(octave)d.%(note)s",
#                    "octave": 5,
#                    "duration": 30,
︙
169
170
171
172
173
174
175

176
177
178
179
180
181
182

183
184
185
186

187
188



189
190
191
192
193
194
195

171
172
173
174
175
176
177
178
179
180
181
182
183
184

185

186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201








+






-
+
-



+


+
+
+








                        subsection[instr]["sync"] = None
                    unordered_instrs.append([subsection[instr]["sync"], instr])
                ordered_instrs = topsort.topsort(unordered_instrs)
                ordered_instrs.remove(None)  # None used as a placeholder for sort order for instruments with no sync setting

                instrs = []
                syncs = {}
                track = 0
                for instr in ordered_instrs:
                    print ";Instrument " + instr
                    instr = subsection[instr]
                    max_time = instr["duration"]
                    instr_score, syncs = render_instr(instr, syncs, max_time)
                    instrs.append(instr_score)
                    for line in generate_csound_score(instr_score, instr["score_line"], subsection_start):
                    generate_csound_score(instr_score, track, instr["channel"], subsection_start)
                        print line
                longest_score = max(instrs, key=lambda i: score_len(i))
                subsection_start += score_len(longest_score)
                section_start += score_len(longest_score)
                track += 1
            except KeyError:
                pass
    with open("out.mid", "wb") as outfile:
        mymidi.writeFile(outfile)



def render_instr(instr, syncs, max_time):
    for g in instr["grammars"]:
        for i in range(len(instr["grammars"][g])):
            instr["grammars"][g][i] = parse.parse(instr["grammars"][g][i], default_octave=instr["octave"])
︙
266
267
268
269
270
271
272




273
274


275
276
277
278
279

280
281
282
283
284
285
286
287

288
289
290
291
292

293
294

295
296

297

298
299
300

301

302
303
304

272
273
274
275
276
277
278
279
280
281
282


283
284





285








286

287
288
289

290


291
292

293

294
295
296
297
298

299
300
301
302








+
+
+
+
-
-
+
+
-
-
-
-
-
+
-
-
-
-
-
-
-
-
+
-



-
+
-
-
+

-
+
-
+



+
-
+




    total = 0
    for n in score:
        if not isinstance(n, tree.Tree):
            total += n.duration
    return total


def get_midi_note(octave, note):
    return note + 12 * (octave+1)


def generate_csound_score(score, score_line, t):
    csound_note_values = {
def generate_csound_score(score, track, channel, t):
    # Assume get_midi_note()
        "C": "00",
        "C#": "01", "Db": "01",
        "D": "02",
        "D#": "03", "Eb": "03",
        "E": "04",
    global mymidi
        "F": "05",
        "F#": "06", "Gb": "06",
        "G": "07",
        "G#": "08", "Ab": "08",
        "A": "09",
        "A#": "10", "Bb": "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]
                note = get_midi_note(token.octave, note)
                csound_score.append(score_line % {"time": t, "octave": token.octave, "note": note, "duration": token.duration})
                csound_score.append(score_line % {"time": t, "octave": token.octave, "note": note, "duration": token.duration})
                mymidi.addNote(track=track, channel=channel,pitch=note, time=t, duration=token.duration, volume=100)
        elif isinstance(token, parse.Note):  # Individual notes
            note = csound_note_values[token.value]
            note = get_midi_note(token.octave, token.value)
            csound_score.append(score_line % {"time": t, "octave": token.octave, "note": note, "duration": token.duration})
            mymidi.addNote(track=track, channel=channel,pitch=note, time=t, duration=token.duration, volume=100)
        elif isinstance(token, tree.Tree):
            continue
        t += token.duration

    return csound_score
    return []


if __name__ == "__main__": main()