1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24
25. 25
26. 26
27. 27
28. 28
29. 29
30. 30
31. 31
32. 32
33. 33
34. 34
35. 35
36. 36
37. 37
38. 38
39. 39
40. 40
41. 41
42. 42
43. 43
44. 44
45. 45
46. 46
47. 47
48. 48
49. 49
50. 50
51. 51
52. 52
53. 53
54. 54
55. 55
56. 56
57. 57
58. 58
59. 59
60. 60
61. 61
62. 62
63. 63
64. 64
65. 65
66. 66
67. 67
68. 68
69. 69
70. 70
71. 71
72. 72
73. 73
74. 74
75. 75

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)