Slipmat Lead-In

#!/usr/bin/env python
#
# Slipmat Lead-In
#
# Copyright (c) 2010 Jacob Joaquin
# Email jacobjoaquin@gmail.com
# Visit Slipmat -- http://slipmat.noisepages.com/
#
# Code License: GNU LESSER GENERAL PUBLIC LICENSE Version 3, 29 June 2007
# http://www.gnu.org/licenses/lgpl-3.0.txt 
#
# Music License:
# This work is licensed under the Creative Commons Attribution 3.0
# United States License. To view a copy of this license, visit
# http://creativecommons.org/licenses/by/3.0/us/ or send a letter to
# Creative Commons, 171 Second Street, Suite 300, San Francisco,
# California, 94105, USA.
 
import math
import operator
import struct
 
sr = 44100
ksmps = 1
 
class UnitGenerator:
    '''All unit generator classes inherit from this.'''
 
    def __init__(self): pass
    def __iter__(self): pass
    def next(self): raise StopIteration
    def __add__(self, ugen): return Add(self, ugen)
    def __mul__(self, ugen): return Mul(self, ugen)
 
class Instr():
    '''Decorator for creating a UnitGenerator from a definition.'''
 
    def __init__(self, ugen_def): self.ugen_def = ugen_def
    def __call__(self, *args): return self.Iter(self.ugen_def, *args)
 
    class Iter(UnitGenerator):
        def __init__(self, ugen_def, *args): self.ugen_def = ugen_def(*args)
 
        def __iter__(self):
            self.index = 0
            self._iter = (i for i in self.ugen_def)
            return self
 
        def next(self):
            if self.index >= ksmps: raise StopIteration
            self.index += 1
            return self._iter.next()
 
class IterReduce(UnitGenerator):
    '''Reduces a list of iterators with the op function.'''
 
    op = operator.add
 
    def __init__(self, *ugens):
        self.ugens = ugens
 
    def __iter__(self):
        self.index = 0
        self.iters = [(j for j in i) for i in self.ugens]
        return self
 
    def next(self):
        if self.index >= ksmps: raise StopIteration
        self.index += 1
        return reduce(self.op, (i.next() for i in self.iters))
 
class Mul(IterReduce): op = operator.mul
class Add(IterReduce): pass
 
class RiseFall(UnitGenerator):
    '''A rise-fall envelope generator.'''
 
    def __init__(self, dur, peak=0.5):
        self.frames = sec_to_frames(dur)
        self.rise = int(peak * self.frames)
        self.fall = int(self.frames - self.rise)
        self.inc = 0
        self.v = 0
 
    def __iter__(self):
        self.index = 0
 
        if self.inc <= self.rise and self.rise != 0:
            self.v = self.inc / float(self.rise)
        else:
            self.v = (self.fall - (self.inc - self.rise)) / float(self.fall)
 
        self.inc += 1
        return self
 
    def next(self):
        if self.index >= ksmps: raise StopIteration
        self.index += 1
        return self.v
 
class Sine(UnitGenerator):
    '''A sine wave oscillator.'''
 
    def __init__(self, amp=1.0, freq=440, phase=0.0):
        self.amp = amp
        self.freq = float(freq)
        self.phase = phase
 
    def __iter__(self):
        self.index = 0
        return self
 
    def next(self):
        if self.index >= ksmps: raise StopIteration
        self.index += 1
 
        v = math.sin(self.phase * 2 * math.pi)
        self.phase += self.freq / sr
        return v * self.amp
 
class UVal(UnitGenerator):
    '''Convert a numeric value to a unit generator object'''
 
    def __init__(self, v):
        self.v = v
 
    def __iter__(self):
        self.index = 0
        return self
 
    def next(self):
        if self.index >= ksmps: raise StopIteration
        self.index += 1
        return self.v
 
class ScoreEvents:
    '''Schedule events for unit generators.'''
 
    def __init__(self, tempo=60):
        self.tempo = tempo
        self.event_dict = {}
        self.ID = 0
        self.last_frame = 0
 
    def event(self, start, dur, ugen):
        ugen_start = sec_to_frames(start * 60 / float(self.tempo))
        ugen_end = ugen_start + sec_to_frames(dur * 60 / float(self.tempo))
        self.last_frame = max(ugen_start, ugen_end, self.last_frame)
 
        if ugen_start not in self.event_dict.keys():
            self.event_dict.update({ugen_start: [(self.ID, 'start', ugen)]})
        else:
            self.event_dict[ugen_start].append((self.ID, 'start', ugen))
 
        if ugen_end not in self.event_dict.keys():
            self.event_dict.update({ugen_end: [(self.ID, 'stop', None)]})
        else:
            self.event_dict[ugen_end].append((self.ID, 'stop', None))
 
        self.ID += 1
 
def cpspch(p):
    '''Convert pitch class to frequency.'''
 
    octave, note = divmod(p, 1)
    return 440 * 2 ** (((octave - 8) * 12 + ((note * 100) - 9)) / 12.0)
 
def sec_to_frames(dur): return int(dur * sr / float(ksmps))
 
def ScoreEventsToWave(score, filename):
    events = {}
    wave = open(filename, 'wb')
    chunk_2_size = score.last_frame * ksmps * 2  
    wave.write(struct.pack('< 4s I 4s', 'RIFF', 36 + chunk_2_size, 'WAVE'))
    wave.write(struct.pack('< 4s I 2h 2I 2h', 'fmt ', 16, 1, 1, sr, \
                           sr * 2, 2, 16))                        
    wave.write(struct.pack('< 4s I', 'data', chunk_2_size))
 
    for f in range(score.last_frame + 1):
        print '%d:' % f
 
        if f in score.event_dict:
            for L in score.event_dict[f]:
                ID, command, function = L
 
                if command == 'start':
                    events.update({ID: function})
                elif command == 'stop':
                    del events[ID]
 
        iters = [(j for j in v) for v in events.itervalues()]
 
        for i in range(ksmps):
            if iters:
                v = reduce(operator.add, (i.next() for i in iters))
            else:
                v = 0
 
            if v > 1: v = 1
            if v < -1: v = -1
 
            wave.write(struct.pack('h', int(v * 32767)))
 
    wave.close()
 
if __name__ == "__main__":
    import random
 
    # Instruments
    @Instr
    def RingTine(dur, amp, freq_1, freq_2, peak=0):
        '''Two ring modulated sine waves with an amplitude envelope.'''
 
        return Sine(amp, freq_1) * Sine(amp, freq_2) * RiseFall(dur, peak)
 
    @Instr
    def DirtySine(dur, amp, freq, peak):
        amp = 1.0 / 1.44 * amp
        a1 = Sine(1, freq)
        a2 = Sine(0.1, freq * 3)
        a3 = Sine(0.24, freq * 5)
        a4 = Sine(0.1, freq * 1.15)
        ring = a1 + (a2 + a3 + a4) * Sine(1, 1.003)
        return ring * RiseFall(dur, peak) * UVal(amp)
 
    # Event Generators
    def dusty_vinyl(s, start, dur, amp, freq_min, freq_max, density):
        '''Granular Sine Event Generator.'''
 
        for i in range(int(density * dur)):
            freq = random.random() * (freq_max - freq_min) + freq_min
            t = random.random() * (dur - start) + start
            s.event(t, 1 / freq, Sine(amp * random.random(), freq))
 
    def sine_arp(s, start, bars, res, amp, note_list, decay):
        offset = start
        b = 60.0 / s.tempo  # duration of a beat in seconds
 
        for bar in range(bars):
            n = 0
            while n < 4.0 / res:
                note = cpspch(note_list[n % len(note_list)])
                ugen = Sine(amp, note) * RiseFall(decay * b, 0)
                s.event(offset, decay, ugen)
                n += 1
                offset = start + bar * 4 + n * res
 
    # Score
    s = ScoreEvents(tempo=169)
    b = 60.0 / s.tempo
 
    dusty_vinyl(s, 0, 80, 0.25, 1000, 10000, 30 * 60 / 169.0)
 
    s.event(6, 16, DirtySine(16 * b, 0.15, cpspch(8.07), 0.95))
    s.event(22, 4, RingTine(4, 0.5, cpspch(10.10), 55, 0))
 
    n = [8.00, 8.03, 8.02, 8.07, 8.05, 8.10, 8.09, 9.00]    
    sine_arp(s, 22, 8, 0.25, 0.1, n, 0.8)
 
    s.event(26, 9, RingTine(9, 0.3, cpspch(9.03), 33, 0.9))
    s.event(33, 9, RingTine(9, 0.5, cpspch(8.10), 55, 0))
    s.event(40, 9, RingTine(9, 0.25, cpspch(7.00), 11, 0))
 
    s.event(54.5, 9, RingTine(9 * b, 0.3, cpspch(9.03), 33, 0.1))
    s.event(54, 9, RingTine(9 * b, 0.5, cpspch(8.07), 44, 0))
    s.event(54, 8, DirtySine(8 * b, 0.15, cpspch(7.07), 0.1))
    s.event(60, 4, DirtySine(4 * b, 0.15, cpspch(6.07), 0.1))
 
    ScoreEventsToWave(s, 'slipmat_lead-in.wav')