Index: cfg.py ================================================================== --- cfg.py +++ cfg.py @@ -1,10 +1,10 @@ #!/usr/bin/env python from __future__ import division +import ipdb import os -import pdb import random import sys import time import parse @@ -101,93 +101,140 @@ "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", + "octave": 8, + "duration": 30, + "grammars": { # Notes for this instrument to use in this piece + "u": ["D/4 D/4 D/4 D/4"], + "v": ["C/4 C/4 C/4 C/4"], + }, + }, + "follow_instr": { # Instrument 'melody' + "score_line": "i2 %(time)f %(duration)f 7000 %(octave)d.%(note)s 1", + "sync": "lead_instr", + "octave": 8, + "duration": 30, + "grammars": { # Notes for this instrument to use in this piece + "u": ["D/4 D/4 D/4 D/4"], + "v": ["C/4 C/4 C/4 C/4"], + }, + }, + }, + }, } print '''f1 0 512 10 1 f2 0 8192 10 .24 .64 .88 .76 .06 .5 .34 .08 f3 0 1025 10 1 t 0 100 ''' section_start = 0 # for section in ["verse1", "verse2"]: - for section in ["fm_test"]: + for section in ["sync_test"]: print "; Section " + section subsection_start = section_start section = composition[section] for subsection in ["intro", "body", "outro"]: try: print "; Subsection " + subsection subsection = section[subsection] + unordered_instrs = [] for instr in subsection: - if not "sync" in subsection[instr]: + subsection[instr]["name"] = instr + if not "sync" in subsection[instr].keys(): subsection[instr]["sync"] = None unordered_instrs.append([subsection[instr]["sync"], instr]) ordered_instrs = topsort.topsort(unordered_instrs) - ordered_instrs.remove(None) - pdb.set_trace() + 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] - sync = None max_time = instr["duration"] - instr_score = render_instr(instr, sync, max_time) + 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, sync, max_time): - grammars = instr["grammars"] +def render_instr(instr, syncs, max_time): for g in instr["grammars"]: - for i in range(len(grammars[g])): - grammars[g][i] = parse.parse(grammars[g][i]) - init_node = random.choice(instr["grammars"].keys()) - init_score = random.choice(instr["grammars"][init_node]) - score = init_score - while True: - time_remaining = max_time - score_len(score) - try: - score = choose_node(score, grammars, time_remaining, sync) - except ValueError: - break - return score - - -def choose_node(score, grammars, time_remaining, sync): - if time_remaining <= 0: - raise ValueError("No time remaining in the score") - node = None - node_index = None - for item in range(len(score)): - if isinstance(score[item], tree.Tree): - node = score[item].name - node_index = item - if node is None: - raise ValueError("No more nodes to fill in") - options = [] - for g in range(len(grammars[node])): - if score_len(grammars[node][g]) <= time_remaining: - options.append(grammars[node][g]) - if len(options) == 0: + for i in range(len(instr["grammars"][g])): + instr["grammars"][g][i] = parse.parse(instr["grammars"][g][i]) + + score= [] + try: + score, syncs = choose_phrase(instr, syncs, 0, max_time) + + while True: + score_index_to_replace = None + for item in range(len(score)): # Optimize this by caching the index of the last node I replaced and startng there + if isinstance(score[item], tree.Tree): + score_index_to_replace = item + if score_index_to_replace is None: + raise ValueError("No more nodes to fill in") + + time_remaining = max_time - score_len(score) + new_phrase, syncs = choose_phrase(instr, syncs, score_len(score), time_remaining) + score = score[:node_index-1] + new_phrase + score[node_index+1:] + + except ValueError: + return (score, syncs) + + +def choose_phrase(instr, syncs, current_time, time_remaining): + '''Filters grammars for ones that match the sync option, and phrases that fit the time remaining in the score''' + time_filtered_grammars = {} + for grammar in instr["grammars"]: + time_filtered_grammars[grammar] = get_phrases_that_fit(instr["grammars"][grammar], time_remaining) + if len(time_filtered_grammars.keys()) == 0: raise ValueError("No available grammars that will fit in the score") - if sync: - pass - else: - phrase = random.choice(options) - score = score[:node_index-1] + phrase + score[node_index+1:] - return score + + grammar = None +# if instr["name"] == "follow_instr": +# ipdb.set_trace() + if instr["sync"] is not None: + guiding_instr = instr["sync"] + sync_node = get_sync_node_at_time(syncs[guiding_instr], current_time) + if sync_node in time_filtered_grammars.keys(): + grammar = sync_node + if grammar is None: + grammar = random.choice(time_filtered_grammars.keys()) + phrases = time_filtered_grammars[grammar] + if instr["name"] not in syncs.keys(): + syncs[instr["name"]] = [] + syncs[instr["name"]].append({"node": grammar, "time": current_time}) + + return random.choice(phrases), syncs + + +def get_phrases_that_fit(grammar, time_remaining): + valid_phrases = [] + for phrase in grammar: + if score_len(phrase) <= time_remaining: + valid_phrases.append(phrase) + return valid_phrases + + +def get_sync_node_at_time(syncs, t): + for s in range(len(syncs)): + if syncs[s]["time"] >= t: + return syncs[s]["node"] def score_len(score): total = 0 for n in score: