From 7a508ad33dcb316ae5f3fa98eba7fe932c3d5f61 Mon Sep 17 00:00:00 2001
From: Locria Cyber
Date: Sun, 12 Mar 2023 16:35:35 +0000
Subject: Refactor more

---
 .gitignore   |   3 +-
 music.nim    | 482 +++++++++++++++++++++++++++++++----------------------------
 musiclib.nim | 108 ++++++-------
 3 files changed, 310 insertions(+), 283 deletions(-)

diff --git a/.gitignore b/.gitignore
index 705d80c..37c3b88 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,2 @@
-/music
\ No newline at end of file
+/music
+/music.s32
\ No newline at end of file
diff --git a/music.nim b/music.nim
index 0ad3e3f..15a2fc3 100644
--- a/music.nim
+++ b/music.nim
@@ -1,250 +1,276 @@
-import musiclib
+import musiclib, std/math
 
 # Number of times to sample each second
 let bitrate = 44100
 
+func osc_piano*(f, t: float): float =
+    ## Returns the intensity of a tone of frequency f sampled at time t
+    ## t starts at 0 (note start)
+    # 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
+
+func freq*(octave, step: float): float =
+    ## Returns the frequency of a note
+    55 * pow(2, (octave + step / 12 - 1))
+
+func p*(len, octave, step, vol: float = 1): Note =
+    ## Note helper constructor
+    let osc: OscFn = osc_piano
+    (len, freq(octave, step), vol, osc)
+
 let intro = [
-    n(1,3,3),
-    n(1,3,7),
-    n(1,3,10),
-    n(6,4,2),
-
-    n(1,3,1),
-    n(1,3,5),
-    n(1,3,8),
-    n(3,4,0),
-
-    n(1,2,11),
-    n(1,3,3),
-    n(1,3,6),
-    n(3,3,10),
-
-    n(1,2,8),
-    n(1,3,0),
-    n(1,3,3),
-    n(8,3,7),
+    p(1,3,3),
+    p(1,3,7),
+    p(1,3,10),
+    p(6,4,2),
+
+    p(1,3,1),
+    p(1,3,5),
+    p(1,3,8),
+    p(3,4,0),
+
+    p(1,2,11),
+    p(1,3,3),
+    p(1,3,6),
+    p(3,3,10),
+
+    p(1,2,8),
+    p(1,3,0),
+    p(1,3,3),
+    p(8,3,7),
 ]
 
 let melody = [
-    n(1,3,3),
-    n(1,3,7),
-    n(1,3,10),
-    n(1,4,2),
-    n(1,4,3),
-    n(1,4,7),
-    n(2,4,8),
-
-    n(1,3,1),
-    n(1,3,5),
-    n(1,3,8),
-    n(1,4,0),
-    n(1,4,1),
-    n(1,4,5),
-    n(2,4,8),
-
-    n(1,3,3),
-    n(1,3,7),
-    n(1,3,10),
-    n(1,4,2),
-    n(1,4,3),
-    n(1,4,10),
-    n(2,4,3),
-
-    n(1,3,1),
-    n(1,3,5),
-    n(1,3,8),
-    n(1,4,0),
-    n(1,4,10),
-    n(1,4,8),
-    n(2,4,10),
-
-
-    n(1,3,3),
-    n(1,3,7),
-    n(1,3,10),
-    n(1,4,2),
-    n(1,4,3),
-    n(1,4,7),
-    n(2,4,8),
-
-    n(1,3,1),
-    n(1,3,5),
-    n(1,3,8),
-    n(1,4,0),
-    n(1,4,1),
-    n(1,4,5),
-    n(2,4,1),
-
-    n(1,3,3),
-    n(1,3,7),
-    n(1,3,10),
-    n(1,4,2),
-    n(1,4,3),
-    n(1,4,10),
-    n(1,4,8),
-    n(1,4,7),
-
-    n(1,3,1),
-    n(1,3,5),
-    n(1,3,8),
-    n(1,4,0),
-    n(1,4,10),
-    n(1,4,8),
-    n(2,4,10),
+    p(1,3,3),
+    p(1,3,7),
+    p(1,3,10),
+    p(1,4,2),
+    p(1,4,3),
+    p(1,4,7),
+    p(2,4,8),
+
+    p(1,3,1),
+    p(1,3,5),
+    p(1,3,8),
+    p(1,4,0),
+    p(1,4,1),
+    p(1,4,5),
+    p(2,4,8),
+
+    p(1,3,3),
+    p(1,3,7),
+    p(1,3,10),
+    p(1,4,2),
+    p(1,4,3),
+    p(1,4,10),
+    p(2,4,3),
+
+    p(1,3,1),
+    p(1,3,5),
+    p(1,3,8),
+    p(1,4,0),
+    p(1,4,10),
+    p(1,4,8),
+    p(2,4,10),
+
+
+    p(1,3,3),
+    p(1,3,7),
+    p(1,3,10),
+    p(1,4,2),
+    p(1,4,3),
+    p(1,4,7),
+    p(2,4,8),
+
+    p(1,3,1),
+    p(1,3,5),
+    p(1,3,8),
+    p(1,4,0),
+    p(1,4,1),
+    p(1,4,5),
+    p(2,4,1),
+
+    p(1,3,3),
+    p(1,3,7),
+    p(1,3,10),
+    p(1,4,2),
+    p(1,4,3),
+    p(1,4,10),
+    p(1,4,8),
+    p(1,4,7),
+
+    p(1,3,1),
+    p(1,3,5),
+    p(1,3,8),
+    p(1,4,0),
+    p(1,4,10),
+    p(1,4,8),
+    p(2,4,10),
 ]
 
 let bass = [
-    n(1,1,3),
-    n(1,1,10),
-    n(1,1,1),
-    n(1,1,8),
-    n(1,1,3),
-    n(1,2,3),
-    n(1,1,1),
-    n(1,1,10),
+    p(1,1,3),
+    p(1,1,10),
+    p(1,1,1),
+    p(1,1,8),
+    p(1,1,3),
+    p(1,2,3),
+    p(1,1,1),
+    p(1,1,10),
 ]
 
 let melody2 = [
-    n(1,0,0),
-    n(1,5,10),
-    n(1,5,8),
-    n(1,5,7),
-    n(1,5,8),
-    n(3,5,7,2),
-
-    n(1,5,3),
-    n(1,4,10),
-    n(6,5,1,2),
-
-    n(1/2,5,0,2),
-    n(1/2,5,1,2),
-    n(3,5,3,2),
-    n(1/2,5,10,2),
-    n(7/2,5,3,2),
-
-    n(8,0,0),
-
-    n(1,0,0),
-    n(1,5,3),
-    n(1,5,10),
-    n(1,5,10),
-    n(4/3,5,10),
-    n(4/3,5,8),
-    n(4/3,5,7),
-
-    n(1,0,0),
-    n(1,5,1),
-    n(1,5,8),
-    n(1,5,8),
-    n(4/3,5,8),
-    n(4/3,5,8),
-    n(4/3,5,10),
-
-    n(8,0,0),
-
-    n(1,0,0),
-    n(5,5,3,2),
-    n(2,5,10,2),
+    p(1,0,0),
+    p(1,5,10),
+    p(1,5,8),
+    p(1,5,7),
+    p(1,5,8),
+    p(3,5,7,2),
+
+    p(1,5,3),
+    p(1,4,10),
+    p(6,5,1,2),
+
+    p(1/2,5,0,2),
+    p(1/2,5,1,2),
+    p(3,5,3,2),
+    p(1/2,5,10,2),
+    p(7/2,5,3,2),
+
+    p(8,0,0),
+
+    p(1,0,0),
+    p(1,5,3),
+    p(1,5,10),
+    p(1,5,10),
+    p(4/3,5,10),
+    p(4/3,5,8),
+    p(4/3,5,7),
+
+    p(1,0,0),
+    p(1,5,1),
+    p(1,5,8),
+    p(1,5,8),
+    p(4/3,5,8),
+    p(4/3,5,8),
+    p(4/3,5,10),
+
+    p(8,0,0),
+
+    p(1,0,0),
+    p(5,5,3,2),
+    p(2,5,10,2),
 ]
 
 let melody3 = [
-    n(1,0,0),
-    n(1,5,10),
-    n(1/2,5,8,2/3),
-    n(1/2,5,7,2/3),
-    n(1/4,5,8,1/2),
-    n(1/4,5,7,1/2),
-    n(1/4,5,8,1/2),
-    n(1/4,5,7,1/2),
-    n(1,5,8),
-    n(3,5,7,2),
-
-    n(1,5,3),
-    n(1,4,10),
-    n(1,5,1),
-    n(5,5,7,2),
-
-    n(1/2,5,7),
-    n(1/2,5,10),
-    n(1/4,5,7),
-    n(1/4,5,10),
-    n(1/4,5,7),
-    n(1/4,5,10),
-    n(1,6,3),
-    n(2,5,3,2),
-    n(1/2,6,3),
-    n(5/2,5,3,2),
-
-    n(1/2,5,10),
-    n(1/2,5,8),
-    n(1/2,5,7),
-    n(1/2,5,8),
-    n(1/2,5,7),
-    n(1/2,5,3),
-    n(1/2,4,10),
-    n(1/2,5,1),
-    n(1/2,5,0),
-    n(1/2,4,10),
-    n(1/2,4,8),
-    n(1/2,4,10),
-    n(1/2,5,3),
-    n(1/2,5,7),
-    n(1/2,5,3),
-    n(1/2,5,10),
-
-    n(4/3,5,7),
-    n(4/3,6,3),
-    n(4/3,6,3),
-    n(4/3,6,2),
-    n(4/3,5,10),
-    n(4/3,5,7),
-
-    n(3,5,5),
-    n(2,5,7),
-    n(2,5,8),
-    n(1,6,1),
-
-    n(1,5,3),
-    n(1,5,5),
-    n(2,5,7),
-    n(1,5,3),
-    n(1,5,8),
-    n(2,5,10),
-
-    n(3/2,6,0),
-    n(3/2,6,1),
-    n(5,6,3,2),
+    p(1,0,0),
+    p(1,5,10),
+    p(1/2,5,8,2/3),
+    p(1/2,5,7,2/3),
+    p(1/4,5,8,1/2),
+    p(1/4,5,7,1/2),
+    p(1/4,5,8,1/2),
+    p(1/4,5,7,1/2),
+    p(1,5,8),
+    p(3,5,7,2),
+
+    p(1,5,3),
+    p(1,4,10),
+    p(1,5,1),
+    p(5,5,7,2),
+
+    p(1/2,5,7),
+    p(1/2,5,10),
+    p(1/4,5,7),
+    p(1/4,5,10),
+    p(1/4,5,7),
+    p(1/4,5,10),
+    p(1,6,3),
+    p(2,5,3,2),
+    p(1/2,6,3),
+    p(5/2,5,3,2),
+
+    p(1/2,5,10),
+    p(1/2,5,8),
+    p(1/2,5,7),
+    p(1/2,5,8),
+    p(1/2,5,7),
+    p(1/2,5,3),
+    p(1/2,4,10),
+    p(1/2,5,1),
+    p(1/2,5,0),
+    p(1/2,4,10),
+    p(1/2,4,8),
+    p(1/2,4,10),
+    p(1/2,5,3),
+    p(1/2,5,7),
+    p(1/2,5,3),
+    p(1/2,5,10),
+
+    p(4/3,5,7),
+    p(4/3,6,3),
+    p(4/3,6,3),
+    p(4/3,6,2),
+    p(4/3,5,10),
+    p(4/3,5,7),
+
+    p(3,5,5),
+    p(2,5,7),
+    p(2,5,8),
+    p(1,6,1),
+
+    p(1,5,3),
+    p(1,5,5),
+    p(2,5,7),
+    p(1,5,3),
+    p(1,5,8),
+    p(2,5,10),
+
+    p(3/2,6,0),
+    p(3/2,6,1),
+    p(5,6,3,2),
 ]
 
 let outro = [
-    n(1,3,3),
-    n(1,3,7),
-    n(1,3,10),
-    n(1,4,2),
-    n(1,4,3),
-    n(1,4,7),
-    n(2,4,8),
-
-    n(1,3,1),
-    n(1,3,5),
-    n(1,3,8),
-    n(1,4,0),
-    n(1,4,1),
-    n(1,4,5),
-    n(2,4,8),
-
-    n(1,2,11),
-    n(1,3,3),
-    n(1,3,6),
-    n(1,3,10),
-    n(1.5,3,11),
-    n(1.5,4,3),
-    n(3,4,8),
-
-    n(1.5,2,8),
-    n(1.5,3,0),
-    n(2,3,3),
-    n(16,3,7,2),
+    p(1,3,3),
+    p(1,3,7),
+    p(1,3,10),
+    p(1,4,2),
+    p(1,4,3),
+    p(1,4,7),
+    p(2,4,8),
+
+    p(1,3,1),
+    p(1,3,5),
+    p(1,3,8),
+    p(1,4,0),
+    p(1,4,1),
+    p(1,4,5),
+    p(2,4,8),
+
+    p(1,2,11),
+    p(1,3,3),
+    p(1,3,6),
+    p(1,3,10),
+    p(1.5,3,11),
+    p(1.5,4,3),
+    p(3,4,8),
+
+    p(1.5,2,8),
+    p(1.5,3,0),
+    p(2,3,3),
+    p(16,3,7,2),
 ]
 
 from std/algorithm import sort
@@ -265,7 +291,7 @@ music.process(melody3, 56, 4)
 music.process(bass, 56, gain=1.5)
 music.process(bass, 64, gain=1.5)
 music.process(outro, 72, 4)
-music.sort()
+music.sortByStart()
 
 # Print out music encoded in s16 to standard output
 for i in (0 * bitrate ..< 84 * bitrate):
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)
-- 
cgit v1.2.3-70-g09d2