121 lines
3.5 KiB
Nim
121 lines
3.5 KiB
Nim
import std/[algorithm, math, sugar, strformat, logging]
|
|
|
|
type
|
|
OscFn* = proc (f: float, t: float): float
|
|
|
|
Note* = tuple
|
|
len: float ## seconds
|
|
freq: float
|
|
vol: float
|
|
osc: OscFn
|
|
|
|
ProcessedNote* = tuple
|
|
start: float ## absolute time in seconds
|
|
stop: float ## absolute time in seconds
|
|
freq: float
|
|
vol: float
|
|
osc: OscFn
|
|
|
|
const HACK_LONGEST_NOTE = 16.0
|
|
|
|
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
|
|
var start = start_init
|
|
var t = start
|
|
for note in notes:
|
|
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, note.osc)
|
|
t = stop
|
|
|
|
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`
|
|
|
|
music.lowerBound(x, (m, key) => cmp(m.start, key))
|
|
|
|
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
|
|
##
|
|
## assumes `music` is sorted by `.start`
|
|
|
|
var i: int = music.bisect(t) - 1
|
|
|
|
var ret: float = 0
|
|
|
|
while i >= 0:
|
|
let m = music[i]
|
|
assert m.start <= t
|
|
if m.start + HACK_LONGEST_NOTE < t:
|
|
break
|
|
else:
|
|
ret += m.vol * m.osc(m.freq, t - m.start)
|
|
i -= 1
|
|
|
|
ret *= GAIN_BIAS
|
|
|
|
# clip sample
|
|
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)
|
|
|
|
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
|
|
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))
|