143 lines
3.4 KiB
Go
143 lines
3.4 KiB
Go
package main
|
|
|
|
import "math"
|
|
import "errors"
|
|
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"
|
|
import "git.tebibyte.media/sashakoshka/tomo/layouts/basic"
|
|
import "git.tebibyte.media/sashakoshka/tomo/elements/basic"
|
|
import "git.tebibyte.media/sashakoshka/tomo/elements/fun/music"
|
|
import _ "git.tebibyte.media/sashakoshka/tomo/backends/x"
|
|
|
|
const sampleRate = 44100
|
|
const bufferSize = 256
|
|
var tuning = music.EqualTemparment { A4: 440 }
|
|
var waveform = 0
|
|
var playing = map[music.Note] *beep.Ctrl { }
|
|
|
|
func main () {
|
|
speaker.Init(sampleRate, bufferSize)
|
|
tomo.Run(run)
|
|
}
|
|
|
|
func run () {
|
|
window, _ := tomo.NewWindow(2, 2)
|
|
window.SetTitle("Piano")
|
|
container := basicElements.NewContainer(basicLayouts.Vertical { true, true })
|
|
window.Adopt(container)
|
|
|
|
controlBar := basicElements.NewContainer(basicLayouts.Horizontal { true, false })
|
|
label := basicElements.NewLabel("Play a song!", false)
|
|
controlBar.Adopt(label, true)
|
|
waveformButton := basicElements.NewButton("Sine")
|
|
waveformButton.OnClick (func () {
|
|
waveform = (waveform + 1) % 5
|
|
switch waveform {
|
|
case 0: waveformButton.SetText("Sine")
|
|
case 1: waveformButton.SetText("Square")
|
|
case 2: waveformButton.SetText("Saw")
|
|
case 3: waveformButton.SetText("Triangle")
|
|
case 4: waveformButton.SetText("Supersaw")
|
|
}
|
|
})
|
|
controlBar.Adopt(waveformButton, false)
|
|
container.Adopt(controlBar, false)
|
|
|
|
piano := fun.NewPiano(2, 5)
|
|
container.Adopt(piano, true)
|
|
piano.OnPress(playNote)
|
|
piano.OnRelease(stopNote)
|
|
|
|
window.OnClose(tomo.Stop)
|
|
window.Show()
|
|
}
|
|
|
|
func stopNote (note music.Note) {
|
|
if _, is := playing[note]; !is { return }
|
|
|
|
speaker.Lock()
|
|
playing[note].Streamer = nil
|
|
delete(playing, note)
|
|
speaker.Unlock()
|
|
}
|
|
|
|
func playNote (note music.Note) {
|
|
streamer, _ := Tone(sampleRate, int(tuning.Tune(note)), waveform, 0.3)
|
|
|
|
stopNote(note)
|
|
speaker.Lock()
|
|
playing[note] = &beep.Ctrl { Streamer: streamer }
|
|
speaker.Unlock()
|
|
speaker.Play(playing[note])
|
|
}
|
|
|
|
// https://github.com/faiface/beep/blob/v1.1.0/generators/toner.go
|
|
// Adapted to be a bit more versatile.
|
|
|
|
type toneStreamer struct {
|
|
position float64
|
|
delta float64
|
|
waveform int
|
|
gain float64
|
|
}
|
|
|
|
func Tone (
|
|
sr beep.SampleRate,
|
|
freq int,
|
|
waveform int,
|
|
gain float64,
|
|
) (
|
|
beep.Streamer,
|
|
error,
|
|
) {
|
|
if int(sr) / freq < 2 {
|
|
return nil, errors.New (
|
|
"tone generator: samplerate must be at least " +
|
|
"2 times greater then frequency")
|
|
}
|
|
tone := new(toneStreamer)
|
|
tone.position = 0.0
|
|
tone.waveform = waveform
|
|
steps := float64(sr) / float64(freq)
|
|
tone.delta = 1.0 / steps
|
|
tone.gain = gain
|
|
return tone, nil
|
|
}
|
|
|
|
func (tone *toneStreamer) nextSample () (sample float64) {
|
|
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:
|
|
sample =
|
|
-1 + 13.7 * tone.position +
|
|
28.32 * tone.position * tone.position +
|
|
15.62 * tone.position * tone.position * tone.position
|
|
}
|
|
_, tone.position = math.Modf(tone.position + tone.delta)
|
|
return
|
|
}
|
|
|
|
func (tone *toneStreamer) Stream (buf [][2]float64) (int, bool) {
|
|
for i := 0; i < len(buf); i++ {
|
|
sample := tone.nextSample() * tone.gain
|
|
buf[i] = [2]float64{sample, sample}
|
|
}
|
|
return len(buf), true
|
|
}
|
|
func (tone *toneStreamer) Err () error {
|
|
return nil
|
|
}
|