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 Side-by-Side 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





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=1
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
    out asig
    outs asig,asig
endin

instr 2
    kenv linen p4, .1, p3, .2; envelope
    asound oscili kenv, cpspch(p5), p6; oscillator
    out asound
    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
    outs asig,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
;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

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