spiffyscore: Changes On Branch 0021a3fe22fb57c5

Changes In Branch develop Through [0021a3fe22] Excluding Merge-Ins

This is equivalent to a diff from 689adc054e to 0021a3fe22

2011-11-03
19:23		Added a very, very bad set of violin samples check-in: 8293931a34 user: brian tags: develop
18:50		Merged in diskin2 mode for cfg.orc check-in: 0021a3fe22 user: brian tags: develop
18:49		By magic, fixed problem with not all bass notes playing via diskin2 Closed-Leaf check-in: 1bc01ba9c9 user: brian tags: feature/diskin2
2011-11-01
18:54		Imported the todo list from MUS306 check-in: 072fa6ad30 user: brian tags: develop
2011-06-12
20:32		Made some changes to the parser. Don't remember what. Leaf check-in: 87435601e4 user: brian tags: master
20:31		Create new branch named "develop" check-in: 9f4c4666c5 user: brian tags: develop
2011-02-10
23:50		Program generates a render order for the instruments based on their sync order check-in: 689adc054e user: brian@linux-85dd.site tags: master
22:34		Added lexical support for parens instead of quotes for chords, cleaned up the yacc parser, added lex tokens for syncopation check-in: 702d933446 user: brian@linux-85dd.site tags: master

Modified 2 3 10 11 12 13 14 15 16 17 18 19 href="/user/spiffytech/repository/spiffyscore/finfo?name=cfg.orc&m=c58361434ce4561d&ci=merge-in:0021a3f">cfg.orc piffytech/repository/spiffyscore/artifact/9f49be1cae0b83db">[9f49be1cae] ffytech/repository/spiffyscore/artifact/c58361434ce4561d">[c58361434c]. class="diffln"> 1 1 sr=44100 2 ksmps=20 3 nchnls=1 4 + 5 +instr 3 6 + if p5=105 then 7 + asig diskin2 "samples/bass/1.05.wav", 1 8 + elseif p5=1.06 then 9 + asig diskin2 "samples/bass/1.06.wav", 1 10 + elseif p5=1.07 then 11 + asig diskin2 "samples/bass/1.07.wav", 1 12 + elseif p5=1.08 then 13 + asig diskin2 "samples/bass/1.08.wav", 1 14 + elseif p5=1.08 then 15 + asig diskin2 "samples/bass/1.09.wav", 1 16 + elseif p5=1.10 then 17 + asig diskin2 "samples/bass/1.10.wav", 1 18 + elseif p5=1.11 then 19 + asig diskin2 "samples/bass/1.11.wav", 1 20 + elseif p5=2.00 then 21 + asig diskin2 "samples/bass/2.00.wav", 1 22 + elseif p5=2.01 then 23 + asig diskin2 "samples/bass/2.01.wav", 1 24 + elseif p5=2.02 then 25 + asig diskin2 "samples/bass/2.02.wav", 1 26 + elseif p5=2.03 then 27 + asig diskin2 "samples/bass/2.03.wav", 1 28 + elseif p5=2.04 then 29 + asig diskin2 "samples/bass/2.04.wav", 1 30 + elseif p5=2.05 then 31 + asig diskin2 "samples/bass/2.05.wav", 1 32 + elseif p5=2.06 then 33 + asig diskin2 "samples/bass/2.06.wav", 1 34 + elseif p5=2.07 then 35 + asig diskin2 "samples/bass/2.07.wav", 1 36 + elseif p5=2.08 then 37 + asig diskin2 "samples/bass/2.08.wav", 1 38 + elseif p5=2.09 then 39 + asig diskin2 "samples/bass/2.09.wav", 1 40 + elseif p5=2.10 then 41 + asig diskin2 "samples/bass/2.10.wav", 1 42 + elseif p5=2.11 then 43 + asig diskin2 "samples/bass/2.11.wav", 1 44 + elseif p5=3.00 then 45 + asig diskin2 "samples/bass/3.00.wav", 1 46 + elseif p5=3.01 then 47 + asig diskin2 "samples/bass/3.01.wav", 1 48 + elseif p5=3.02 then 49 + asig diskin2 "samples/bass/3.02.wav", 1 50 + elseif p5=3.03 then 51 + asig diskin2 "samples/bass/3.03.wav", 1 52 + elseif p5=3.04 then 53 + asig diskin2 "samples/bass/3.04.wav", 1 54 + elseif p5=3.05 then 55 + asig diskin2 "samples/bass/3.05.wav", 1 56 + elseif p5=3.06 then 57 + asig diskin2 "samples/bass/3.06.wav", 1 58 + elseif p5=3.07 then 59 + asig diskin2 "samples/bass/3.07.wav", 1 60 + elseif p5=3.08 then 61 + asig diskin2 "samples/bass/3.08.wav", 1 62 + elseif p5=3.09 then 63 + asig diskin2 "samples/bass/3.09.wav", 1 64 + elseif p5=3.10 then 65 + asig diskin2 "samples/bass/3.10.wav", 1 66 + elseif p5=3.11 then 67 + asig diskin2 "samples/bass/3.11.wav", 1 68 + endif 69 + outs asig 70 +endin 4 71 5 72 instr 1 6 73 asound pluck p4, cpspch(p5), cpspch(p6), p7, p8 p9 p10 7 74 out asound 8 75 endin 9 76 77 instr 2 78 kenv linen p4, .1, p3, .2; envelope 79 asound oscili kenv, cpspch(p5), p6; oscillator 80 out asound 81 endin 82 -instr 3 - asound foscili p4, cpspch(p5), 5, 2, 3, p9 - out asound 83 +instr 4 84 + aFMinst foscili p4, cpspch(p5), p6, p7, p8, p9 85 endin

Deleted cfg.py version [e9b556b4f3].

     1         -#!/usr/bin/env python
     2         -
     3         -from __future__ import division
     4         -import os
     5         -import random
     6         -import sys
     7         -import time
     8         -random.seed(time.time())
     9         -
    10         -import parse
    11         -import topsort
    12         -import yaml
    13         -
    14         -def main():
    15         -    key = "A"
    16         -    bps = 60/60
    17         -    tempo = 1/bps
    18         -    max_duration = 1
    19         -
    20         -    composition = yaml.load(open("score.yaml"))
    21         -
    22         -    max_t = 0  # max time encountered so far. Used for movement timing
    23         -    progression = "chorus"
    24         -
    25         -    for movement in progression.split():
    26         -        for section in ["intro", "core", "outro"]:
    27         -            if section in composition[movement].keys():
    28         -                try:
    29         -                    render_order = topsort.topsort([[composition[movement][section][instrument]["sync"], instrument] if "sync" in composition[movement][section][instrument].keys() else [None, instrument] for instrument in composition[movement][section]])
    30         -                except topsort.CycleError as ex:
    31         -                    print "Your instruments are synced in a circle! This makes no sense!"
    32         -                    print movement, section
    33         -                    print ex
    34         -                    sys.exit(1)
    35         -                
    36         -
    37         -#    for comp_name in progression.split():
    38         -#        comp_start_time = max_t
    39         -#        for instr_name, instr in composition[comp_name].iteritems():
    40         -#            generated_score = generate_score(instr["score"], instr["grammars"])  # Fill in the scores by generating them based on the grammars
    41         -##            print generated_score
    42         -#            score = parse.parse(generated_score, default_octave=instr["octave"])  # Return Node/Chord objects
    43         -#
    44         -#            # Generate timestamps for the notes 
    45         -#            t = comp_start_time
    46         -#            for note in range(len(score)):
    47         -#                score[note].time = t
    48         -#                score[note].duration *= tempo
    49         -#                t += score[note].duration
    50         -##                print "time difference =", t-comp_start_time
    51         -##                print "instrument duration =",composition[comp_name][instr_name]["duration"]
    52         -#                if (t-comp_start_time) > float(composition[comp_name][instr_name]["duration"]):
    53         -##                    print "here"
    54         -#                    score = score[:note]
    55         -#                    break
    56         -#                max_t = t if t > max_t else max_t
    57         -#            composition[comp_name][instr_name]["score"] = score
    58         -
    59         -    # Must be done after all note times keyed in, else you can't coordinate melodies with the rhythm chords
    60         -    print '''f1  0  512  10  1
    61         -            f2 0 8192 10 .24 .64 .88 .76 .06 .5 .34 .08
    62         -            f3 0 1025 10 1
    63         -    '''
    64         -    for comp_name in progression.split():
    65         -        print "; Movement:", comp_name
    66         -        for instr_name, instr in composition[comp_name].iteritems():
    67         -            composition[comp_name][instr_name]["score"] = transliterate_score(composition[comp_name][instr_name]["score"], key)
    68         -#            print "\nMovement %s instrument %s" % (comp_name, instr_name)
    69         -#            print composition[comp_name][instr_name]["score"] 
    70         -            final_score = generate_csound_score(composition[comp_name][instr_name]["score"], composition[comp_name][instr_name]["score_line"])
    71         -            for line in final_score:
    72         -                print line
    73         -            
    74         -
    75         -def make_scale(key):
    76         -    notes = ["A", "A#", "B", "C", "C#", "D", "D#", "E", "F", "F#", "G", "G#"]
    77         -    scale = [key]
    78         -    pos = notes.index(key)
    79         -    progression = [2,2,1,2,2,2,1]
    80         -    for p in progression:
    81         -        pos = (pos + p) % 12
    82         -        scale.append(notes[pos])
    83         -    return scale
    84         -
    85         -
    86         -def generate_score(score, grammars):
    87         -    while 1:
    88         -        found_substitution = False
    89         -        for key,value in grammars.iteritems():
    90         -            if score.find(key) != -1:
    91         -                found_substitution = True
    92         -                while score.find(key) != -1:
    93         -                    score = score.replace(key, random.choice(grammars[key]), 1)
    94         -#                    print scoe
    95         -                    if len(score.split()) > 2000:
    96         -                        for k in grammars.keys():
    97         -                            score = score.replace(k, "")
    98         -                        return score
    99         -        if found_substitution is False:
   100         -            break
   101         -    return score
   102         -
   103         -def transliterate_score(score, key):
   104         -    scale = make_scale(key)
   105         -    scale_conversion = {
   106         -        "I": 1,
   107         -        "II": 2,
   108         -        "III": 3,
   109         -        "IV": 4,
   110         -        "V": 5,
   111         -        "VI": 6,
   112         -        "VII": 7,
   113         -        "VIII": 8,
   114         -    }
   115         -    keyed_score = []
   116         -    for i in range(len(score)):
   117         -        if isinstance(score[i], parse.Note):
   118         -            score[i].value = scale[scale_conversion[score[i].value]-1]
   119         -        elif isinstance(score[i], parse.Chord):
   120         -            chord = []
   121         -            root_note_index = scale.index(key) + scale_conversion[score[i].value]
   122         -            chord.append(scale[root_note_index])
   123         -            chord.append(scale[(root_note_index+3) % 8])
   124         -            if score[i].chord_type == "m":  # Minor chords, flat the 5th
   125         -                chord.append(scale[(root_note_index+4) % 8])
   126         -            else:
   127         -                chord.append(scale[(root_note_index+5) % 8])
   128         -            score[i].chord = chord
   129         -        elif isinstance(score[i], parse.Rest):
   130         -            pass
   131         -    return score
   132         -
   133         -
   134         -def generate_csound_score(score, score_line):
   135         -    csound_note_values = {
   136         -        "C": "00",
   137         -        "C#": "01",
   138         -        "D": "02",
   139         -        "D#": "03",
   140         -        "E": "04",
   141         -        "F": "05",
   142         -        "F#": "06",
   143         -        "G": "07",
   144         -        "G#": "08",
   145         -        "A": "09",
   146         -        "A#": "10",
   147         -        "B": "11",
   148         -    }
   149         -    csound_score = []
   150         -    for token in score:
   151         -        if isinstance(token, parse.Chord):  # Chords
   152         -            for note in token.chord: 
   153         -                note = csound_note_values[note]
   154         -                csound_score.append(score_line % {"time": token.time, "octave": token.octave, "note": note, "duration": token.duration})
   155         -        elif isinstance(token, parse.Note):  # Individual notes
   156         -            note = csound_note_values[token.value]
   157         -            csound_score.append(score_line % {"time": token.time, "octave": token.octave, "note": note, "duration": token.duration})
   158         -    return csound_score
   159         -
   160         -
   161         -if __name__ == "__main__": main()

Modified parse.py from [3ec57c3fbe] to [a8d0994825].

     1      1   #!/usr/bin/env python
            2  +
            3  +import tree
     2      4   
     3      5   from ply import lex, yacc
     4      6   class Note():
     5         -    def __init__(self, value, duration=.25, octave=8):
            7  +    def __init__(self, value, duration=1, octave=8):
     6      8           self.value = value
     7      9           self.duration = duration
     8     10           self.octave = octave
     9         -        self.accidental = None
    10     11       def __repr__(self):
    11     12           return "Note %s %s %s" % (self.value, self.duration, self.octave)
    12     13   
    13     14   class Chord():
    14         -    def __init__(self, value, duration=.5, chord_type="major", octave=5):
           15  +    def __init__(self, value, duration=1, chord_type="major", octave=5):
    15     16           self.value = value
    16     17           self.duration = duration
    17     18           self.chord_type = chord_type
    18     19           self.octave = octave
    19     20       def __repr__(self):
    20     21           return "Chord %s %s %s" % (self.value, self.duration, self.chord_type, self.octave)
    21     22   
    22     23   class Rest():
    23         -    def __init__(self, duration=.25):
           24  +    def __init__(self, duration=1):
    24     25           self.duration = duration
    25     26       def __repr__(self):
    26     27           return "Rest node %s" % self.duration
    27     28   
    28     29   
    29     30   def parse(score, default_octave=8):
    30     31       # Tokenize (lex)
................................................................................
    33     34           "BASENOTE",
    34     35           "ACCIDENTAL",
    35     36           "REST",
    36     37           "OCTAVE",
    37     38           "CHORD_TYPE",
    38     39           "PAREN",
    39     40           "SYNCOPATE",
           41  +        "NODE",
    40     42       )
    41     43   
    42     44       t_ignore = " |"
    43     45   
    44         -    #t_BASENOTE = r"[A-Ga-g]"
    45         -    t_BASENOTE = r"I+V?|VI*|i+v?|vi*"
    46         -    t_ACCIDENTAL = r"\^{1,2}|_{1,2}|="
           46  +    t_BASENOTE = r"[A-Ga-g]"
           47  +#    t_BASENOTE = r"I+V?|VI*|i+v?|vi*"
           48  +    t_ACCIDENTAL = r"\^{1}|_{1}|="
    47     49       t_REST = r"z"
    48     50       t_OCTAVE = r"'+|,+"
    49     51       t_CHORD_TYPE = r"m|7|m7|0|o|\+|mb5|sus|sus4|maj7|mmaj7|7sus4|dim|dim7|7b5|m7b5|6|b6|m6|mb6|46|maj9|9|add9|7b9|m9"
    50     52       t_PAREN = "\(|\)"
    51     53       t_SYNCOPATE = "\+|-"
           54  +    t_NODE = r"\([a-zA-Z0-9_-]+\)"
    52     55   
    53     56       def t_NOTE_LENGTH(t):
    54     57           r"/?\d+"
    55     58           multiplier = float(t.value.strip("/"))
    56     59           if t.value.startswith("/"):
    57     60               multiplier = 1/multiplier
    58     61           t.value = multiplier
................................................................................
    67     70   
    68     71       # Parse (yacc)
    69     72   
    70     73       def p_note_list(p):
    71     74           '''score : score note
    72     75                    | score chord
    73     76                    | score rest
           77  +            | score node
    74     78           '''
    75     79           p[0] = p[1] + [p[2]]
    76     80   
    77     81       def p_score(p):
    78     82           '''score : note
    79     83                    | chord
    80     84                    | rest
           85  +            | node
    81     86           '''
    82     87           p[0] = [p[1]]
    83     88   
    84     89   
    85     90       def p_chord_length(p):
    86     91           ''' chord : chord NOTE_LENGTH
    87     92           '''
................................................................................
   114    119           '''
   115    120           note.syncopate = p[2]
   116    121   
   117    122   
   118    123       def p_accidental(p):
   119    124           '''note : ACCIDENTAL note
   120    125           '''
   121         -        p[2].accidental = p[1]
          126  +        if p[1] == "^":
          127  +            p[2].value += "#"
          128  +        else:
          129  +            p[2].value += "b"
   122    130           p[0] = p[2]
   123    131   
   124    132       def p_octave(p):
   125    133           '''note : note OCTAVE
   126    134           '''
   127    135           count = len(p[2])
   128    136           increment_or_decrement = 1 if p[2].startswith("'") else -1
................................................................................
   137    145       def p_rest(p):
   138    146           ''' rest : REST
   139    147                    | REST NOTE_LENGTH
   140    148           '''
   141    149           p[0] = Rest()
   142    150           if len(p) > 2:
   143    151               p[0].duration = p[2]
          152  +
          153  +    def p_node(p):
          154  +        '''node : NODE
          155  +        '''
          156  +        p[0] = tree.Tree(p[1].strip("(").strip(")"))
          157  +
   144    158   
   145    159       def p_error(p):
          160  +#        import ipdb
          161  +#        ipdb.set_trace()
          162  +        print p
   146    163           raise Exception("Syntax error at '%s' of element type %s" % (p.value, p.type))
   147    164           
   148    165       yacc.yacc()
   149    166   
   150    167       return yacc.parse(score)

Added samples/bass/1.05.wav version [e6f01c2d0c].