factored out envelope profile from segment

Author: ptone

birdfish/envelope.py

@@ -36,8 +36,13 @@
 a pause segment could be represented as a segment with negative duration
 
 """
+# TODO
+# Need to introduce an EnvelopeProfile for the reusable math bits
+# all cumulative update tracking should happen in the end segment
+# and a containing envelope needs to "reset" the segment as needed
 
-class EnvelopeSegment(object):
+
+class EnvelopeProfile(object):
     """
     contains one phase or segment of a multi-segment envelope
     attributes:
@@ -48,22 +53,55 @@ class EnvelopeSegment(object):
     end value represented as delta/change
     """
 
-    def __init__(self, tween=tween.LINEAR, start=0, change=1.0, duration=1.0):
+    def __init__(self, tween=tween.LINEAR, start=0, change=1.0, duration=1.0,
+            label="profile"):
         self.tween = tween
         self.start = float(start)
         self.change = float(change)
         self.duration = float(duration)
+        self.label = label
+
         assert self.duration > 0  # only a duration > 0 makes sense
 
-    def update(self, delta):
+    def get_value(self, delta):
         if delta > self.duration:
             delta = self.duration
+        # TODO save a self.value here for more consistency with envelopes?
+        print "updating %s %s at %s" % (self.label, self, delta)
         return self.tween(delta, self.start, self.change, self.duration)
 
     def get_jump_time(self, value):
         return tween.jump_time(self.tween, value, self.start, self.change, self.duration)
 
 
+class EnvelopeSegment(object):
+    """
+    An ultimate end point in a nested envelope
+    contains reference to an envelope profile"""
+    def __init__(self, tween=tween.LINEAR, start=0, change=1.0, duration=1.0,
+            profile=None, label="segment"):
+        if profile:
+            self.profile = profile
+        else:
+            self.profile = EnvelopeProfile(tween=tween, start=start,
+                    change=change, duration=duration, label="%s-profile" % label)
+        self.duration = float(duration)
+        self.label = label
+        self.elapsed = 0
+        self.value = 0
+
+        assert self.duration > 0  # only a duration > 0 makes sense
+
+    def reset(self):
+        self.elapsed = 0
+        self.value = 0
+
+    def update(self, delta):
+        print "updating %s %s at delta %s" % (self.label, self, delta)
+        self.elapsed += delta
+        self.value = self.profile.get_value(self.elapsed)
+        return self.value
+
 class StaticEnvelopeSegment(EnvelopeSegment):
     # just returns the start value unchanged - always
     # will never advance on its own without a trigger interving
@@ -73,12 +111,13 @@ def __init__(self, *args, **kwargs):
         self.duration = 0
 
     def update(self, delta):
-        return self.start
+        return self.profile.start
 
 class Envelope(EnvelopeSegment):
 
-    def __init__(self, loop=0):
+    def __init__(self, loop=0, label="envelope"):
         self.segments = []
+        self.label = label
 
         # Not sure I need this state
         self.running = False
@@ -105,39 +144,60 @@ def reset(self):
         self.index = 0
         self.value = 0
         self.current_segment_time_delta = 0
+        for segment in self.segments:
+            segment.reset()
 
     def advance(self):
-        self.index += 1
-        self.current_segment_time_delta = 0
-        if self.index + 1 > len(self.segments) and self.loop and self.loop_counter:
-            self.index = 0
-            if self.loop > 0:  # this is a finite loop
-                self.loop_counter -= 1
+        # return True if advanced
+        print "advancing"
+        print self.index, len(self.segments)
+        if self.index + 1 == len(self.segments):  # last segment
+            if self.loop and self.loop_counter:
+                print 'looping'
+                self.segments[self.index].reset()
+                self.index = 0
+                if self.loop > 0:  # this is a finite loop
+                    self.loop_counter -= 1
+                    print 'loop counter now: ', self.loop_counter
+                    return True
+                print 'infinite loop counter now: ', self.loop_counter
+            else:
+                print "not looping on advance - staying at last segment"
+                # non-looping, or done with final loop
+                pass
+        else:
+            # proceed through sequence of segments
+            self.segments[self.index].reset()
+            self.index += 1
+            self.current_segment_time_delta = 0
+            return True
+        return False
 
 
     def update(self, delta):
+        print '---------------------'
+        print "updating %s %s at delta %s" % (self.label, self, delta)
+
         # delta is time passed since last update
         if self.index + 1 > len(self.segments):
             # non looping or end of finite loop
             # just reurn last value until something resets index
             return self.value
         segment = self.segments[self.index]
         self.current_segment_time_delta += delta
-        # self.timedelta += delta
+        print "self current elapsed %s" % self.current_segment_time_delta
         if (segment.duration and
                 (self.current_segment_time_delta > segment.duration)):
             overage = self.current_segment_time_delta - segment.duration
-            self.advance()
             # TODO don't handle case where overage > new segment
             # duration - could need recursion
-            self.current_segment_time_delta = overage
-            if self.index + 1 > len(self.segments):
-                self.value = segment.update(segment.duration)
-            else:
+
+            if self.advance():
+                print 'advanced, new delta: ', overage
+                delta = self.current_segment_time_delta = overage
                 segment = self.segments[self.index]
-                self.value = segment.update(self.current_segment_time_delta)
-        else:
-            self.value = segment.update(self.current_segment_time_delta)
+
+        self.value = segment.update(delta)
         return self.value
 
     @property
@@ -155,6 +215,7 @@ class TriggeredEnvelope(Envelope):
     def __init__(self, *args, **kwargs):
         super(TriggeredEnvelope, self).__init__(*args, **kwargs)
         self.state = 0  # on:1 off:0
+        self.label = kwargs.get('label', 'triggered-envelope')
         # two states - each has a segment - which may be a envelope with sub-segments
 
     def trigger(self, state=1, value=1.0):
@@ -177,8 +238,9 @@ def trigger(self, state=1, value=1.0):
                 # off trigger
                 print 'advance'
                 self.advance()
-                if self.value != self.segments[1].start:
-                    self.current_segment_time_delta += self.segments[1].get_jump_time(self.value)
+                if self.value != self.segments[1].profile.start:
+                    print "shortcutting time"
+                    self.current_segment_time_delta += self.segments[1].profile.get_jump_time(self.value)
         self.state = state
 
     def update(self, delta):
@@ -203,28 +265,46 @@ def __init__(self, peak_value=1.0, sustain_value=0.8,
             attack_shape=tween.LINEAR, attack_duration=0.5,
             decay_shape=tween.LINEAR, decay_duration=.2,
             release_shape=tween.LINEAR, release_duration=.5,
-            bell_mode=False):
+            bell_mode=False, label='ADSR-envelope'):
+
+        super(ADSREnvelope, self).__init__(loop=0, label=label)
 
-        self.attack_envelope = EnvelopeSegment(tween=attack_shape,
-                change=peak_value, duration=attack_duration)
+        self.attack_envelope = EnvelopeSegment(
+                tween=attack_shape,
+                change=peak_value,
+                duration=attack_duration,
+                label="attack",
+                )
 
-        self.on_envelope = Envelope()
+        self.on_envelope = Envelope(label="on-envelope")
         self.on_envelope.segments = [self.attack_envelope]
 
         decay_change = -(peak_value - sustain_value)
+
         if decay_change:
-            self.decay_envelope = EnvelopeSegment(tween=decay_shape,
-                    start=peak_value, change=decay_change, duration=decay_duration)
-            self.on_evenlope.segments.append(self.decay_envelope)
+            self.decay_envelope = EnvelopeSegment(
+                    tween=decay_shape,
+                    start=peak_value,
+                    change=decay_change,
+                    duration=decay_duration,
+                    label="decay",
+                    )
+            self.on_envelope.segments.append(self.decay_envelope)
         else:
             self.decay_envelope = None
 
-        self.sustain_envelope = StaticEnvelopeSegment(start=sustain_value)
+        self.sustain_envelope = StaticEnvelopeSegment(start=sustain_value,
+                label="sustain")
         self.on_envelope.segments.append(self.sustain_envelope)
-        self.release_envelope = EnvelopeSegment(tween=release_shape,
-                start=sustain_value, change=0-sustain_value, duration=release_duration)
-        self.off_envelope = Envelope()
-        if self.release_envelope.change and self.release_envelope.duration:
+        self.release_envelope = EnvelopeSegment(
+                tween=release_shape,
+                start=sustain_value,
+                change=0-sustain_value,
+                duration=release_duration,
+                label="release",
+                )
+        self.off_envelope = Envelope(label="off-envelope")
+        if self.release_envelope.profile.change and self.release_envelope.duration:
             self.off_envelope.segments.append(self.release_envelope)
         self.segments = [self.on_envelope, self.off_envelope]
 

tests/test_envelope.py

@@ -38,10 +38,10 @@ def test_simple_evelope():
     assert val == .8
 
 def test_looping_envelope():
-    s1 = envelope.EnvelopeSegment(start=0, change=1.0, duration=1.0)
-    s2 = envelope.EnvelopeSegment(start=1, change=-1.0, duration=1.0)
-    e = envelope.Envelope(loop=2)
-    e.segments = [s1, s2]
+    s1 = envelope.EnvelopeSegment(start=0, change=1.0, duration=1.0, label='a')
+    s2 = envelope.EnvelopeSegment(start=1, change=-1.0, duration=1.0, label='b')
+    e = envelope.Envelope(loop=2, label='looping-envelope')
+    e.segments = [s1, s2] # 2 seconds for full envelope - 2 loops, 4 secs total
     # start off with 2 loops remaining
     assert e.loop_counter == 2
     for i in range(6):
@@ -55,11 +55,27 @@ def test_looping_envelope():
     assert val == 0
     e.loop = -1 # infinite loop
     e.reset()
-    for i in range(51):
+    for i in range(81):
         val = e.update(.5)
     assert e.loop_counter == -1
     assert val == .5
 
+def test_nested_envelope():
+    s1 = envelope.EnvelopeSegment(start=0, change=1.0, duration=1.0, label='seg1')
+    s2 = envelope.EnvelopeSegment(start=1, change=-1.0, duration=1.0, label='seg2')
+    s3 = envelope.EnvelopeSegment(start=0, change=1.0, duration=1.0, label='seg3')
+    s4 = envelope.EnvelopeSegment(start=1, change=-1.0, duration=1.0, label='seg4')
+    e1 = envelope.Envelope(label='e1')
+    e2 = envelope.Envelope(label='e2')
+    e3 = envelope.Envelope(label='e3')
+    e1.segments = [s1, s2]
+    e2.segments = [s3, s4]
+    e3.segments = [e1, e2]
+    e3.update(.5)
+    assert e3.value == .5
+    e3.update(.4)
+    assert e3.value == .9
+
 def test_trigger_envelope():
     s1 = envelope.StaticEnvelopeSegment(start=.3)
     s2 = envelope.EnvelopeSegment(start=.3, change=-.3, duration=1.0)
@@ -85,7 +101,7 @@ def test_trigger_envelope():
     for i in range(10):
         val = e.update(.5)
     assert val == 0
-    assert e.index == 2
+    assert e.index == 1
     e.trigger(state=1)
     assert e.index == 0
     # force state of partial value
@@ -95,4 +111,30 @@ def test_trigger_envelope():
     # value
     assert round(e.current_segment_time_delta, 2) == .33
 
+def test_adsr_envelope():
+    # envelope using defaults
+    e = envelope.ADSREnvelope()
+    e.trigger(state=1)
+    e.update(.25)
+    print e.index
+    print e.segments
+    # The attack segment of on segment
+    d1_index = e.segments[e.index].index
+    assert d1_index == 0
+    d1_seg = e.segments[e.index].segments[d1_index]
+    print d1_seg
+    print d1_seg.__dict__
+    assert e.value == .5
+    e.update(.25)
+    print e.current_segment_time_delta
+    d1_index = e.segments[e.index].index
+    assert d1_index == 0
+    assert e.value == 1.0
+    e.update(.1)
+    # should have advanced to decay
+    d1_index = e.segments[e.index].index
+    assert d1_index == 1
+    assert e.value == .9
+
+