Refactor more

1 files changed, 54 insertions, 54 deletions

diff --git a/musiclib.nim b/musiclib.nim
index 7050dd3..4984596 100644
--- a/musiclib.nim
+++ b/musiclib.nim
@@ -1,68 +1,68 @@
-import std/[algorithm, math, sugar]
+import std/[algorithm, math, sugar, strformat]
 
-type Note* = tuple
-    len: float
-    octave: float
-    step: float
-    vol: float
+type
+    OscFn* = proc (f: float, t: float): float
 
-func n*(a, b, c, d: float = 1): Note =
-    (a, b, c, d)
+    Note* = tuple
+        len: float ## seconds
+        freq: float
+        vol: float
+        osc: OscFn
 
-type ProcessedNote* = tuple
-    start: float
-    `end`: float
-    octave: float
-    step: float
-    vol: float
+    ProcessedNote* = tuple
+        start: float ## absolute time in seconds
+        stop: float  ## absolute time in seconds
+        freq: float
+        vol: float
+        osc: OscFn
 
-func process*(music: var seq[ProcessedNote], notes: openArray[Note]; m_start: float, speed: float=1, gain:float = 1) =
+## give some seconds for the note to fade out
+const HACK_DROPOFF_DELAY = 2.0
+
+const HACK_LONGEST_NOTE = 16.0
+
+func process*(music: var seq[ProcessedNote], notes: openArray[Note]; start_init: float, speed: float=1, gain:float = 1) =
     ## Adds a list of notes to the music list
-    var start = m_start
+    ##
+    ## `notes`  sequence of notes with no rests in between
+    var start = start_init
     var t = start
     for note in notes:
-        let vol = note[3]
-        start = min(t, t + note[0] / speed)
-        let `end` = max(t, t + note[0] / speed)
-        music &= ((start, `end`, note[1], note[2], vol * gain))
-        t = `end`
+        assert note.len >= 0.0
+        assert note.len <= HACK_LONGEST_NOTE, &"note too long: {note.len}"
+        start = t
+        let stop = t + note.len / speed
+        music &= (start, stop, note.freq, note.vol * gain, note.osc)
+        t = stop
 
-func bisect(music: openArray[ProcessedNote], x: (float, float)): int =
-    ## Return the index where to insert item `x` in list `music`, assuming `music` is sorted.
-    music.lowerBound(x, (m, key) => cmp((m[0], m[1]), key))
+func sortByStart*(music: var seq[ProcessedNote]) =
+    music.sort((a, b) => cmp(a.start, b.start))
 
+func bisect(music: openArray[ProcessedNote], x: float): int =
+    ## Return the index where to insert item `x` in list `music`
+    ## 
+    ## assumes `music` is sorted by `.start`
 
-func freq(octave, step: float): float =
-    ## Returns the frequency of a note
-    55 * pow(2, (octave + step / 12 - 1))
+    music.lowerBound(x, (m, key) => cmp(m.start, key))
 
-func tone(f, t: float): float =
-    ## Returns the intensity of a tone of frequency f sampled at time t
-    # https://dsp.stackexchange.com/questions/46598/mathematical-equation-for-the-sound-wave-that-a-piano-makes
-    # https://youtu.be/ogFAHvYatWs?t=254
-    # return int(2**13*(1+square(t, 440*2**(math.floor(5*t)/12))))
-    # Y = sum([math.sin(2 * i * math.pi * t * f) * math.exp(-0.0004 * 2 * math.pi * t * f) / 2**i for i in range(1, 4)])
-    # Y += Y * Y * Y
-    # Y *= 1 + 16 * t * math.exp(-6 * t)
-    let w = 2 * PI * f
-    var Y = 0.6 * math.sin(w * t) * math.exp(-0.001 * w * t)
-    Y += 0.2 * math.sin(2 * w * t) * math.exp(-0.001 * w * t)
-    Y += 0.05 * math.sin(3 * w * t) * math.exp(-0.001 * w * t)
-    Y += Y * Y * Y
-    Y *= 1 + 16 * t * math.exp(-6 * t)
-    Y
+const GAIN_BIAS: float = pow(2.0, 28.0)
 
-const bias: float = pow(2.0, 28.0)
-func at*(music: openArray[ProcessedNote], t: float): int32 =
+proc at*(music: openArray[ProcessedNote], t: float): int32 =
     ## Returns the total intensity of music sampled at time t
-    let i: int = music.bisect((t, pow(2.0, 31.0)))
-    # This is actually pretty efficient ngl
-    # Because people usually don't have that many overlapping notes
+    ## 
+    ## assumes `music` is sorted by `.start`
+
+    var i: int = music.bisect(t) - 1    
+    
     var ret: float = 0
-    # this `32` is flaky
-    # maybe some notes are longer?
-    for j in (max(i - 32, 0) ..< i):
-        let m = music[j]
-        if m[0] + m[1] > t:
-            ret += m[4] * tone(freq(m[2], m[3]), t - m[0])
-    int32(ret * bias)
+
+    while i >= 0:
+        let m = music[i]
+        assert m.start <= t
+        if m.stop + HACK_DROPOFF_DELAY >= t:
+            ret += m.vol * m.osc(m.freq, t - m.start)
+        if m.start + HACK_LONGEST_NOTE + HACK_DROPOFF_DELAY < t:
+            break
+        i -= 1
+
+    int32(ret * GAIN_BIAS)