/music.nim at 46911993234b7c9cc07546f56843b35621b7f811

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
  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))

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)

#------- song region -------

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),
]

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),
]

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),
]

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),
]

# 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),
]

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)
music.process(bass, 32)
music.process(melody, 40, 4)
music.process(melody2, 40, 4)
music.process(bass, 40)
music.process(bass, 48)
music.process(melody, 56, 4)
music.process(melody3, 56, 4)
music.process(bass, 56)
music.process(bass, 64)
music.process(outro, 72, 4)
music.sortByStart()

# Print out music encoded in s32 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)