From c415caf533cc0896e2f2cf78024e751bc44739b0 Mon Sep 17 00:00:00 2001
From: Locria Cyber
Date: Sun, 12 Mar 2023 15:48:41 +0000
Subject: Add nim impl

---
 .gitignore   |   1 +
 README.md    |   7 ++
 music.nim    | 273 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 musiclib.nim |  68 +++++++++++++++
 4 files changed, 349 insertions(+)
 create mode 100644 .gitignore
 create mode 100644 music.nim
 create mode 100644 musiclib.nim

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..705d80c
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+/music
\ No newline at end of file
diff --git a/README.md b/README.md
index 7a50d67..eb1259f 100644
--- a/README.md
+++ b/README.md
@@ -5,3 +5,10 @@ Lambeat is a new way to make music using functional programming. It's heavily in
 First, install [Sox](https://sox.sourceforge.net/) and clone this repo. Write some music in `music.scm`. Enjoy your music with `guile --fresh-auto-compile lambeat.scm | play -r 8000 -t s16 -`!
 
 For the Python version, use `pypy3 music.py | play -r 44100 -t s32 -` to listen and `pypy3 music.py | sox -r 44100 -t s32 - example.ogg` to save to a file.
+
+For the nim version
+```
+nim c --mm:orc -d:release music.nim
+./music > music.s32
+play -r 44100 -t s32 music.s32
+```
diff --git a/music.nim b/music.nim
new file mode 100644
index 0000000..0ad3e3f
--- /dev/null
+++ b/music.nim
@@ -0,0 +1,273 @@
+import musiclib
+
+# Number of times to sample each second
+let bitrate = 44100
+
+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),
+]
+
+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),
+]
+
+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),
+]
+
+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),
+]
+
+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),
+]
+
+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),
+]
+
+from std/algorithm import sort
+
+# Process all lists of notes
+var music: seq[ProcessedNote] = @[]
+music.process(intro, 0, 4)
+music.process(melody, 8, 4)
+music.process(melody, 24, 4)
+music.process(bass, 24, gain=1.5)
+music.process(bass, 32, gain=1.5)
+music.process(melody, 40, 4)
+music.process(melody2, 40, 4)
+music.process(bass, 40, gain=1.5)
+music.process(bass, 48, gain=1.5)
+music.process(melody, 56, 4)
+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()
+
+# Print out music encoded in s16 to standard output
+for i in (0 * bitrate ..< 84 * bitrate):
+    let bytes = cast[array[4, uint8]](music.at(i / bitrate))
+    doAssert 4 == stdout.writeBytes(bytes, 0, 4)
diff --git a/musiclib.nim b/musiclib.nim
new file mode 100644
index 0000000..7050dd3
--- /dev/null
+++ b/musiclib.nim
@@ -0,0 +1,68 @@
+import std/[algorithm, math, sugar]
+
+type Note* = tuple
+    len: float
+    octave: float
+    step: float
+    vol: float
+
+func n*(a, b, c, d: float = 1): Note =
+    (a, b, c, d)
+
+type ProcessedNote* = tuple
+    start: float
+    `end`: float
+    octave: float
+    step: float
+    vol: float
+
+func process*(music: var seq[ProcessedNote], notes: openArray[Note]; m_start: float, speed: float=1, gain:float = 1) =
+    ## Adds a list of notes to the music list
+    var start = m_start
+    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`
+
+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 freq(octave, step: float): float =
+    ## Returns the frequency of a note
+    55 * pow(2, (octave + step / 12 - 1))
+
+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 bias: float = pow(2.0, 28.0)
+func 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
+    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)
-- 
cgit v1.2.3-70-g09d2


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


From ba6e3c375728eff3510e877f594653a5e373fc5c Mon Sep 17 00:00:00 2001
From: Locria Cyber
Date: Sun, 12 Mar 2023 17:08:21 +0000
Subject: handle clipping move osc&gain to the user side

---
 music.nim    | 59 ++++++++++++++++++++++++++++++++++++++---------------------
 musiclib.nim | 20 ++++++++++----------
 2 files changed, 48 insertions(+), 31 deletions(-)

diff --git a/music.nim b/music.nim
index 15a2fc3..24c01ca 100644
--- a/music.nim
+++ b/music.nim
@@ -1,7 +1,7 @@
-import musiclib, std/math
+import musiclib, std/[math, sugar]
 
 # Number of times to sample each second
-let bitrate = 44100
+const bitrate = 44100
 
 func osc_piano*(f, t: float): float =
     ## Returns the intensity of a tone of frequency f sampled at time t
@@ -20,15 +20,28 @@ func osc_piano*(f, t: float): float =
     Y *= 1 + 16 * t * math.exp(-6 * t)
     Y
 
+func osc_pulse*(f,t:float):float =
+    let width = (1.0 / f) / 2
+    let phase: float = t mod (width * 2)
+    if phase < width: 1.0 else: -1.0
+
 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 =
+var osc: OscFn = (f, t: float) => 0.0
+
+proc p*(len, octave, step, vol: float = 1): Note =
     ## Note helper constructor
-    let osc: OscFn = osc_piano
     (len, freq(octave, step), vol, osc)
 
+
+#------- song region -------
+
+const GAIN_NORMAL = 0.24
+
+osc = (f, t: float) => osc_piano(f, t) * GAIN_NORMAL
+
 let intro = [
     p(1,3,3),
     p(1,3,7),
@@ -51,6 +64,8 @@ let intro = [
     p(8,3,7),
 ]
 
+# osc = osc_pulse
+
 let melody = [
     p(1,3,3),
     p(1,3,7),
@@ -119,17 +134,6 @@ let melody = [
     p(2,4,10),
 ]
 
-let bass = [
-    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 = [
     p(1,0,0),
     p(1,5,10),
@@ -273,6 +277,19 @@ let outro = [
     p(16,3,7,2),
 ]
 
+osc = (f, t: float) => osc_piano(f, t) * GAIN_NORMAL * 1.5
+
+let bass = [
+    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),
+]
+
 from std/algorithm import sort
 
 # Process all lists of notes
@@ -280,16 +297,16 @@ var music: seq[ProcessedNote] = @[]
 music.process(intro, 0, 4)
 music.process(melody, 8, 4)
 music.process(melody, 24, 4)
-music.process(bass, 24, gain=1.5)
-music.process(bass, 32, gain=1.5)
+music.process(bass, 24)
+music.process(bass, 32)
 music.process(melody, 40, 4)
 music.process(melody2, 40, 4)
-music.process(bass, 40, gain=1.5)
-music.process(bass, 48, gain=1.5)
+music.process(bass, 40)
+music.process(bass, 48)
 music.process(melody, 56, 4)
 music.process(melody3, 56, 4)
-music.process(bass, 56, gain=1.5)
-music.process(bass, 64, gain=1.5)
+music.process(bass, 56)
+music.process(bass, 64)
 music.process(outro, 72, 4)
 music.sortByStart()
 
diff --git a/musiclib.nim b/musiclib.nim
index 4984596..91e63c4 100644
--- a/musiclib.nim
+++ b/musiclib.nim
@@ -16,12 +16,9 @@ type
         vol: float
         osc: OscFn
 
-## 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) =
+func process*(music: var seq[ProcessedNote], notes: openArray[Note]; start_init: float, speed: float=1) =
     ## Adds a list of notes to the music list
     ##
     ## `notes`  sequence of notes with no rests in between
@@ -32,7 +29,7 @@ func process*(music: var seq[ProcessedNote], notes: openArray[Note]; start_init:
         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)
+        music &= (start, stop, note.freq, note.vol, note.osc)
         t = stop
 
 func sortByStart*(music: var seq[ProcessedNote]) =
@@ -45,7 +42,7 @@ func bisect(music: openArray[ProcessedNote], x: float): int =
 
     music.lowerBound(x, (m, key) => cmp(m.start, key))
 
-const GAIN_BIAS: float = pow(2.0, 28.0)
+const GAIN_BIAS: float = pow(2.0, 31.0)
 
 proc at*(music: openArray[ProcessedNote], t: float): int32 =
     ## Returns the total intensity of music sampled at time t
@@ -59,10 +56,13 @@ proc at*(music: openArray[ProcessedNote], t: float): int32 =
     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:
+        if m.start + HACK_LONGEST_NOTE < t:
             break
+        else:
+            ret += m.vol * m.osc(m.freq, t - m.start)
         i -= 1
 
-    int32(ret * GAIN_BIAS)
+    ret *= GAIN_BIAS
+    
+    # clip sample
+    clamp(ret, int32.low.float..int32.high.float).int32
-- 
cgit v1.2.3-70-g09d2


From 5fe21ce19c52326c79c1fe09000218af66f386c5 Mon Sep 17 00:00:00 2001
From: Locria Cyber
Date: Sun, 12 Mar 2023 17:34:15 +0000
Subject: Add OSC with dubious construction

---
 music.nim    | 542 +++++++++++++++++++++++++++++++----------------------------
 musiclib.nim |  11 +-
 2 files changed, 292 insertions(+), 261 deletions(-)

diff --git a/music.nim b/music.nim
index 24c01ca..2ad0e3f 100644
--- a/music.nim
+++ b/music.nim
@@ -3,291 +3,315 @@ import musiclib, std/[math, sugar]
 # Number of times to sample each second
 const bitrate = 44100
 
+func osc_weird_pluck*(f, t: float): float =
+  # I got this as a bug
+  let w = 2 * PI * f
+  let wxt = w * t
+  let exp_swxt = math.exp(-0.001 * wxt)
+  let y0 = 0.6 * math.sin(wxt)
+  let y1 = 0.2 * math.sin(2 * wxt)
+  let y2 = 0.05 * math.sin(3 * wxt)
+  let y3 = (y0 + y1 + y2) * exp_swxt
+  let y4 = (1+y3)*y3*y3 # this line is different
+  y4 * (1 + 16 * t * math.exp(-6 * t))
+
 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 osc_pulse*(f,t:float):float =
-    let width = (1.0 / f) / 2
-    let phase: float = t mod (width * 2)
-    if phase < width: 1.0 else: -1.0
+  ## 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
+  let ewt = math.exp(-0.001 * w * t)
+  var Y = 0.6 * math.sin(w * t) * ewt +
+        0.2 * math.sin(2 * w * t) * ewt +
+        0.05 * math.sin(3 * w * t) * ewt
+  
+  let Y2 = Y * (Y * Y + 1)
+  Y2 * (1 + 16 * t * math.exp(-6 * t))
+
+func osc_pulse*(f, t: float, phasedrift: float = 0.0): float =
+  let doublewidth = 1.0 / f
+  let width = doublewidth / 2
+  let phase: float = (t + doublewidth * phasedrift) mod doublewidth
+  if phase < width: 1.0 else: -1.0
+
+func osc_saw*(f,t:float, phasedrift: float = 0.0):float =
+  let doublewidth = 1.0 / f
+  let width = doublewidth / 2
+  let phase: float = (t + doublewidth * phasedrift) mod doublewidth
+  if phase < width:
+    -1.0 + 2.0 * phase / width
+  else:
+    1.0 - 2.0 * (phase - width) / (1.0 - width)
 
 func freq*(octave, step: float): float =
-    ## Returns the frequency of a note
-    55 * pow(2, (octave + step / 12 - 1))
+  ## Returns the frequency of a note
+  55 * pow(2, (octave + step / 12 - 1))
 
 var osc: OscFn = (f, t: float) => 0.0
 
 proc p*(len, octave, step, vol: float = 1): Note =
-    ## Note helper constructor
-    (len, freq(octave, step), vol, osc)
-
+  ## Note helper constructor
+  (len, freq(octave, step), vol, osc)
 
 #------- song region -------
 
-const GAIN_NORMAL = 0.24
+const GAIN_NORMAL = 0.22
 
 osc = (f, t: float) => osc_piano(f, t) * GAIN_NORMAL
 
 let intro = [
-    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),
+    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),
 ]
 
-# osc = osc_pulse
+let outro = [
+    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),
+]
 
 let melody = [
-    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),
+    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),
 ]
 
+osc = (f, t: float) => osc_weird_pluck(f, t) * GAIN_NORMAL
+
 let melody2 = [
-    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),
+    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 = [
-    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 = [
-    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),
+    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),
 ]
 
-osc = (f, t: float) => osc_piano(f, t) * GAIN_NORMAL * 1.5
+# clip length to 1 second
+osc = (f, t: float) => (if t > 1: 0.0 else:
+  (osc_saw(f, t) * GAIN_NORMAL * 0.06) + (osc_pulse(f, t) * GAIN_NORMAL * 0.3))
 
 let bass = [
-    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),
+    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),
 ]
 
 from std/algorithm import sort
@@ -312,5 +336,5 @@ music.sortByStart()
 
 # Print out music encoded in s16 to standard output
 for i in (0 * bitrate ..< 84 * bitrate):
-    let bytes = cast[array[4, uint8]](music.at(i / bitrate))
-    doAssert 4 == stdout.writeBytes(bytes, 0, 4)
+  let bytes = cast[array[4, uint8]](music.at(i / bitrate))
+  doAssert 4 == stdout.writeBytes(bytes, 0, 4)
diff --git a/musiclib.nim b/musiclib.nim
index 91e63c4..c21cb95 100644
--- a/musiclib.nim
+++ b/musiclib.nim
@@ -1,4 +1,4 @@
-import std/[algorithm, math, sugar, strformat]
+import std/[algorithm, math, sugar, strformat, logging]
 
 type
     OscFn* = proc (f: float, t: float): float
@@ -65,4 +65,11 @@ proc at*(music: openArray[ProcessedNote], t: float): int32 =
     ret *= GAIN_BIAS
     
     # clip sample
-    clamp(ret, int32.low.float..int32.high.float).int32
+    if ret >= int32.high.float:
+        warn(&"audio clipping at t={t}")
+        int32.high
+    elif ret <= int32.low.float:
+        warn(&"audio clipping at t={t}")
+        int32.low
+    else:
+        int32(ret)
-- 
cgit v1.2.3-70-g09d2