spiffyscore

Check-in [0c3fb3e27f]
Login

Check-in [0c3fb3e27f]

Overview
Comment:Replaced csound support with midi support
Timelines: family | ancestors | descendants | both | develop
Files: files | file ages | folders
SHA1: 0c3fb3e27f6e765ff07945f9d732b84e67d2cbb6
User & Date: brian on 2011-11-15 22:09:21
Other Links: branch diff | manifest | tags
Context
2011-11-15
22:12
Removed useless samples and test csound files now that we're no longer using csound check-in: 680f187463 user: brian tags: develop
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
2011-11-07
01:39
Altered the sample-based instruments to ine Csound string formatting instead of a billion if clauses to choose what file to play check-in: 4f872339ff user: brian tags: develop
Changes
Hide Diffs Unified Diffs Ignore Whitespace Patch

Modified cfg.orc from [feddf36ca4] to [db9c923851]. 

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





sr=44100
ksmps=20
nchnls=1










instr 1
;    kcps = 220
;    icps = 220
;    ifn  = 0
;    imeth = p4
;;    asig pluck 0.7, cpspch(p5), cpspch(p6), ifn, imeth, .1, 10
    asig pluck   p4, cpspch(p5), cpspch(p6), p7, p8 p9 p10
    out asig
endin

instr 2
    kenv linen p4, .1, p3, .2; envelope
    asound oscili kenv, cpspch(p5), p6; oscillator
    out asound
endin

instr 3
;    pylassigni "note", p5
;    pylruni "sample_file = 'samples/bass/%.2f.wav' % note"
;    Ssample_file pylevali "sample_file"

    Ssample_file sprintf "samples/bass/%.2f.wav", p5
    asig diskin2 Ssample_file, 1
    outs asig
endin

instr 4
    aFMinst foscili p4, cpspch(p5), p6, p7, p8, p9
endin

instr 5
    Ssample_file sprintf "samples/bass/%.2f.wav", p5
    asig diskin2 Ssample_file, 1













    outs asig
endin







|
>
>
>
>
>
>
>
>
>








|





|









|






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

>
>
>
>

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

sr=44100
ksmps=20
nchnls=2

;isf sfload "samples/acoustic_grand_piano_ydp.sf2"
isf sfload "samples/default.sf2"
sfplist isf
sfpassign 0, isf
;gipre sfpreset 0, 0, isf, 0

;gienginenum1 fluidEngine
;isfnum1 fluidLoad "samples/default.sf2"

instr 1
;    kcps = 220
;    icps = 220
;    ifn  = 0
;    imeth = p4
;;    asig pluck 0.7, cpspch(p5), cpspch(p6), ifn, imeth, .1, 10
    asig pluck   p4, cpspch(p5), cpspch(p6), p7, p8 p9 p10
    outs asig,asig
endin

instr 2
    kenv linen p4, .1, p3, .2; envelope
    asound oscili kenv, cpspch(p5), p6; oscillator
    outs asound,asound
endin

instr 3
;    pylassigni "note", p5
;    pylruni "sample_file = 'samples/bass/%.2f.wav' % note"
;    Ssample_file pylevali "sample_file"

    Ssample_file sprintf "samples/bass/%.2f.wav", p5
    asig diskin2 Ssample_file, 1
    outs asig,asig
endin

instr 4
    aFMinst foscili p4, cpspch(p5), p6, p7, p8, p9
endin

;instr 5
;    Ssample_file sprintf "samples/violin/%.2f.wav", p5
;    asig mp3in Ssample_file, 1
;    outs asig,asig
;endin

instr 6
    mididefault 60, p3
    midinoteonkey p4, p5
    inum init p4
    ivel init p5
    ivel init ivel/127
    kamp linsegr 1, 1, 1, .1, 0
    kamp = kamp/1000
    kfreq init 1
    a1,a2 sfplay3 ivel, inum, kamp*ivel, kfreq, 0
    outs a1,a2
endin

;instr 7
;
;endin

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

        note.syncopate = p[2]


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

    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
        '''










        p[0] = Note(p[1], octave=default_octave)

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








|

<
|












>
>
>
>
>
>
>
>
>
>
|








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[0] = p[2].value + 1
        else:

            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(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

#!/usr/bin/env python

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


import parse
import topsort
import yaml

import tree

random.seed(time.time())


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",










>







>








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

                        "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",
##                    "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)"],

#                    },
#                },
                "follow_instr": {  # Instrument 'melody'
#                    "score_line": "i2 %(time)f %(duration)f 7000 %(octave)d.%(note)s 1",
                    "score_line": "i3 %(time)f %(duration)f 7000 %(octave)d.%(note)s",
#                    "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)"],

                    },
                },
#                "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,








|
|
<
|
|
|
|
|
|
|
>
|
|

|
<
|







>








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'
                    "channel": 6,

                    "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'
                    "channel": 0,

                    "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

                        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 = {}

                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):
                        print line
                longest_score = max(instrs, key=lambda i: score_len(i))
                subsection_start += score_len(longest_score)
                section_start += score_len(longest_score)

            except KeyError:
                pass





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"])









>






|
<



>


>
>
>








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)
                    generate_csound_score(instr_score, track, instr["channel"], subsection_start)

                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

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






def generate_csound_score(score, score_line, t):
    csound_note_values = {
        "C": "00",
        "C#": "01", "Db": "01",
        "D": "02",
        "D#": "03", "Eb": "03",
        "E": "04",
        "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]
                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})

        elif isinstance(token, parse.Note):  # Individual notes
            note = csound_note_values[token.value]
            csound_score.append(score_line % {"time": t, "octave": token.octave, "note": note, "duration": token.duration})

        elif isinstance(token, tree.Tree):
            continue
        t += token.duration

    return csound_score


if __name__ == "__main__": main() 








>
>
>
>
|
|
<
<
<
<
|
<
<
<
<
<
<
<
|
<



|
<
<
>

|
<
>



>
|




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, track, channel, t):
    # Assume get_midi_note()




    global mymidi









    for token in score:
        if isinstance(token, parse.Chord):  # Chords
            for note in token.chord: 
                note = get_midi_note(token.octave, note)


                mymidi.addNote(track=track, channel=channel,pitch=note, time=t, duration=token.duration, volume=100)
        elif isinstance(token, parse.Note):  # Individual notes
            note = get_midi_note(token.octave, token.value)

            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 []


if __name__ == "__main__": main()