This repository has been archived on 2023-08-08. You can view files and clone it, but cannot push or open issues or pull requests.
tomo-old/examples/piano/main.go

263 lines
6.2 KiB
Go
Raw Normal View History

package main
2023-02-08 22:01:39 -07:00
import "math"
2023-02-09 21:52:27 -07:00
import "time"
2023-02-08 22:01:39 -07:00
import "errors"
2023-02-08 21:41:31 -07:00
import "github.com/faiface/beep"
import "github.com/faiface/beep/speaker"
import "git.tebibyte.media/sashakoshka/tomo"
import "git.tebibyte.media/sashakoshka/tomo/elements/fun"
2023-02-08 21:41:31 -07:00
import "git.tebibyte.media/sashakoshka/tomo/layouts/basic"
import "git.tebibyte.media/sashakoshka/tomo/elements/basic"
2023-02-08 21:41:31 -07:00
import "git.tebibyte.media/sashakoshka/tomo/elements/fun/music"
import _ "git.tebibyte.media/sashakoshka/tomo/backends/x"
2023-02-08 21:41:31 -07:00
const sampleRate = 44100
const bufferSize = 256
var tuning = music.EqualTemparment { A4: 440 }
2023-02-08 22:01:39 -07:00
var waveform = 0
var playing = map[music.Note] *toneStreamer { }
var adsr = ADSR {
Attack: 5 * time.Millisecond,
Decay: 400 * time.Millisecond,
Sustain: 0.7,
Release: 500 * time.Millisecond,
}
2023-02-08 21:41:31 -07:00
func main () {
2023-02-08 21:41:31 -07:00
speaker.Init(sampleRate, bufferSize)
tomo.Run(run)
}
func run () {
window, _ := tomo.NewWindow(2, 2)
window.SetTitle("Piano")
container := basicElements.NewContainer(basicLayouts.Vertical { true, true })
2023-02-08 22:01:39 -07:00
controlBar := basicElements.NewContainer(basicLayouts.Horizontal { true, false })
label := basicElements.NewLabel("Play a song!", false)
2023-02-08 22:01:39 -07:00
waveformButton := basicElements.NewButton("Sine")
waveformButton.OnClick (func () {
2023-02-09 00:04:58 -07:00
waveform = (waveform + 1) % 5
2023-02-08 22:01:39 -07:00
switch waveform {
case 0: waveformButton.SetText("Sine")
case 1: waveformButton.SetText("Square")
2023-02-09 00:04:58 -07:00
case 2: waveformButton.SetText("Saw")
case 3: waveformButton.SetText("Triangle")
case 4: waveformButton.SetText("Supersaw")
2023-02-08 22:01:39 -07:00
}
})
attackSlider := basicElements.NewLerpSlider(0, 3 * time.Second, adsr.Attack, true)
decaySlider := basicElements.NewLerpSlider(0, 3 * time.Second, adsr.Decay, true)
sustainSlider := basicElements.NewSlider(adsr.Sustain, true)
releaseSlider := basicElements.NewLerpSlider(0, 3 * time.Second, adsr.Release, true)
attackSlider.OnRelease (func () {
adsr.Attack = attackSlider.Value()
})
decaySlider.OnRelease (func () {
adsr.Decay = decaySlider.Value()
})
sustainSlider.OnRelease (func () {
adsr.Sustain = sustainSlider.Value()
})
releaseSlider.OnRelease (func () {
adsr.Release = releaseSlider.Value()
})
2023-02-08 22:01:39 -07:00
2023-02-09 09:38:01 -07:00
piano := fun.NewPiano(2, 5)
2023-02-08 21:41:31 -07:00
piano.OnPress(playNote)
piano.OnRelease(stopNote)
2023-02-09 14:36:38 -07:00
piano.Focus()
window.Adopt(container)
controlBar.Adopt(label, true)
controlBar.Adopt(waveformButton, false)
controlBar.Adopt(basicElements.NewSpacer(true), false)
controlBar.Adopt(attackSlider, false)
controlBar.Adopt(decaySlider, false)
controlBar.Adopt(sustainSlider, false)
controlBar.Adopt(releaseSlider, false)
container.Adopt(controlBar, true)
container.Adopt(piano, false)
window.OnClose(tomo.Stop)
window.Show()
}
2023-02-08 21:41:31 -07:00
func stopNote (note music.Note) {
if _, is := playing[note]; !is { return }
speaker.Lock()
2023-02-09 21:52:27 -07:00
playing[note].Release()
2023-02-08 21:41:31 -07:00
delete(playing, note)
speaker.Unlock()
}
func playNote (note music.Note) {
2023-02-09 21:52:27 -07:00
streamer, _ := Tone (
sampleRate,
int(tuning.Tune(note)),
waveform,
0.3,
adsr)
2023-02-08 21:41:31 -07:00
stopNote(note)
speaker.Lock()
2023-02-09 21:52:27 -07:00
playing[note] = streamer
2023-02-08 21:41:31 -07:00
speaker.Unlock()
speaker.Play(playing[note])
}
2023-02-08 22:01:39 -07:00
// https://github.com/faiface/beep/blob/v1.1.0/generators/toner.go
2023-02-09 00:04:58 -07:00
// Adapted to be a bit more versatile.
2023-02-08 22:01:39 -07:00
type toneStreamer struct {
2023-02-09 00:04:58 -07:00
position float64
cycles uint64
2023-02-09 00:04:58 -07:00
delta float64
2023-02-09 21:52:27 -07:00
2023-02-09 00:04:58 -07:00
waveform int
2023-02-09 14:15:02 -07:00
gain float64
2023-02-09 21:52:27 -07:00
adsr ADSR
released bool
complete bool
adsrPhase int
adsrPosition float64
adsrDeltas [4]float64
}
type ADSR struct {
Attack time.Duration
Decay time.Duration
Sustain float64
Release time.Duration
2023-02-08 22:01:39 -07:00
}
2023-02-09 14:15:02 -07:00
func Tone (
2023-02-09 21:52:27 -07:00
sampleRate beep.SampleRate,
frequency int,
2023-02-09 14:15:02 -07:00
waveform int,
gain float64,
2023-02-09 21:52:27 -07:00
adsr ADSR,
2023-02-09 14:15:02 -07:00
) (
2023-02-09 21:52:27 -07:00
*toneStreamer,
2023-02-09 14:15:02 -07:00
error,
) {
2023-02-09 21:52:27 -07:00
if int(sampleRate) / frequency < 2 {
2023-02-08 22:01:39 -07:00
return nil, errors.New (
2023-02-09 14:15:02 -07:00
"tone generator: samplerate must be at least " +
2023-02-08 22:01:39 -07:00
"2 times greater then frequency")
}
2023-02-09 21:52:27 -07:00
2023-02-08 22:01:39 -07:00
tone := new(toneStreamer)
2023-02-09 00:04:58 -07:00
tone.waveform = waveform
2023-02-09 21:52:27 -07:00
tone.position = 0.0
steps := float64(sampleRate) / float64(frequency)
2023-02-08 22:01:39 -07:00
tone.delta = 1.0 / steps
2023-02-09 14:15:02 -07:00
tone.gain = gain
2023-02-09 21:52:27 -07:00
if adsr.Attack < time.Millisecond { adsr.Attack = time.Millisecond }
if adsr.Decay < time.Millisecond { adsr.Decay = time.Millisecond }
if adsr.Release < time.Millisecond { adsr.Release = time.Millisecond }
tone.adsr = adsr
attackSteps := adsr.Attack.Seconds() * float64(sampleRate)
decaySteps := adsr.Decay.Seconds() * float64(sampleRate)
releaseSteps := adsr.Release.Seconds() * float64(sampleRate)
tone.adsrDeltas[0] = 1 / attackSteps
tone.adsrDeltas[1] = 1 / decaySteps
tone.adsrDeltas[2] = 0
tone.adsrDeltas[3] = 1 / releaseSteps
2023-02-08 22:01:39 -07:00
return tone, nil
}
func (tone *toneStreamer) nextSample () (sample float64) {
2023-02-09 00:04:58 -07:00
switch tone.waveform {
case 0:
sample = math.Sin(tone.position * 2.0 * math.Pi)
case 1:
if tone.position > 0.5 {
sample = 1
} else {
sample = -1
}
case 2:
sample = (tone.position - 0.5) * 2
case 3:
sample = 1 - math.Abs(tone.position - 0.5) * 4
case 4:
unison := 5
detuneDelta := 0.00005
detune := 0.0 - (float64(unison) / 2) * detuneDelta
for i := 0; i < unison; i ++ {
_, offset := math.Modf(detune * float64(tone.cycles) + tone.position)
sample += (offset - 0.5) * 2
detune += detuneDelta
}
sample /= float64(unison)
2023-02-08 22:01:39 -07:00
}
2023-02-09 21:52:27 -07:00
adsrGain := 0.0
switch tone.adsrPhase {
case 0: adsrGain = tone.adsrPosition
if tone.adsrPosition > 1 {
tone.adsrPosition = 0
tone.adsrPhase = 1
}
case 1: adsrGain = 1 + tone.adsrPosition * (tone.adsr.Sustain - 1)
if tone.adsrPosition > 1 {
tone.adsrPosition = 0
tone.adsrPhase = 2
}
case 2: adsrGain = tone.adsr.Sustain
if tone.released {
tone.adsrPhase = 3
}
case 3: adsrGain = (1 - tone.adsrPosition) * tone.adsr.Sustain
if tone.adsrPosition > 1 {
tone.adsrPosition = 0
tone.complete = true
}
}
sample *= adsrGain * adsrGain
tone.adsrPosition += tone.adsrDeltas[tone.adsrPhase]
2023-02-09 00:04:58 -07:00
_, tone.position = math.Modf(tone.position + tone.delta)
tone.cycles ++
2023-02-08 22:01:39 -07:00
return
}
func (tone *toneStreamer) Stream (buf [][2]float64) (int, bool) {
2023-02-09 21:52:27 -07:00
if tone.complete {
return 0, false
}
2023-02-08 22:01:39 -07:00
for i := 0; i < len(buf); i++ {
2023-02-09 21:52:27 -07:00
sample := 0.0
if !tone.complete {
sample = tone.nextSample() * tone.gain
}
2023-02-09 00:04:58 -07:00
buf[i] = [2]float64{sample, sample}
2023-02-08 22:01:39 -07:00
}
return len(buf), true
}
2023-02-09 21:52:27 -07:00
2023-02-08 22:01:39 -07:00
func (tone *toneStreamer) Err () error {
return nil
}
2023-02-09 21:52:27 -07:00
func (tone *toneStreamer) Release () {
tone.released = true
}