dndmusicbot/speaker/discord.go

180 lines
2.8 KiB
Go
Raw Permalink Normal View History

2022-11-18 21:18:12 +00:00
package discordspeaker
import (
2022-12-05 17:24:06 +00:00
"context"
"fmt"
"io"
2022-11-18 21:18:12 +00:00
"log"
"sync"
"time"
2022-11-18 21:18:12 +00:00
2022-12-05 17:24:06 +00:00
"github.com/diamondburned/arikawa/v3/voice"
"github.com/diamondburned/arikawa/v3/voice/voicegateway"
"github.com/gopxl/beep"
2022-11-18 21:18:12 +00:00
"github.com/pkg/errors"
"golang.org/x/time/rate"
"gopkg.in/hraban/opus.v2"
cc "github.com/tejzpr/ordered-concurrently/v3"
2022-11-18 21:18:12 +00:00
)
var (
mu sync.Mutex
mixer beep.Mixer
samples [][2]float64
done chan struct{}
encoder *opus.Encoder
2022-11-18 21:18:12 +00:00
frameSize int = 960
channels int = 2
sampleRate int = 48000
maxBytes int = (frameSize * 2) * 2
buf []byte
2022-12-05 17:24:06 +00:00
session *voice.Session
spk bool
input chan cc.WorkFunction
pw *io.PipeWriter
pr *io.PipeReader
spklimit = rate.NewLimiter(rate.Every(2*time.Second), 1)
2022-11-18 21:18:12 +00:00
)
var Silence = [2]float64{}
2022-12-05 17:24:06 +00:00
func Init(dgv *voice.Session) error {
2022-11-18 21:18:12 +00:00
var err error
mu.Lock()
defer mu.Unlock()
Close()
pr, pw = io.Pipe()
2022-11-18 21:18:12 +00:00
buf = make([]byte, maxBytes)
mixer = beep.Mixer{}
2022-11-18 21:18:12 +00:00
samples = make([][2]float64, frameSize)
2022-12-05 17:24:06 +00:00
session = dgv
2022-11-18 21:18:12 +00:00
encoder, err = opus.NewEncoder(sampleRate, channels, opus.AppVoIP)
encoder.SetBitrateToMax()
2022-11-18 21:18:12 +00:00
if err != nil {
return errors.Wrap(err, "failed to initialize speaker")
}
input = make(chan cc.WorkFunction)
ctx := context.Background()
output := cc.Process(ctx, input, &cc.Options{PoolSize: 4, OutChannelBuffer: 4})
2022-11-18 21:18:12 +00:00
go func() {
for {
select {
default:
update()
case out := <-output:
fmt.Println(pw.Write(out.Value.([]byte)))
2022-11-18 21:18:12 +00:00
case <-done:
return
}
}
}()
go ReadSend()
2022-11-18 21:18:12 +00:00
return nil
}
func ReadSend() {
for {
buf := make([]byte, maxBytes)
n, err := pr.Read(buf)
if err != nil {
log.Println(err)
return
}
_, err = session.Write(buf[:n])
if err != nil {
log.Println(err)
return
}
}
}
2022-11-18 21:18:12 +00:00
func Close() {
}
func Lock() {
mu.Lock()
}
// Unlock unlocks the speaker. Call after modifying any currently playing Streamer.
func Unlock() {
mu.Unlock()
}
func Play(s ...beep.Streamer) {
mu.Lock()
mixer.Add(s...)
mu.Unlock()
}
func Clear() {
mu.Lock()
mixer.Clear()
mu.Unlock()
}
func Speak(s bool) {
switch s {
case true:
case false:
}
}
2022-11-18 21:18:12 +00:00
func update() {
mu.Lock()
mixer.Stream(samples)
mu.Unlock()
if IsSilent(samples) {
if spk && spklimit.Allow() {
2022-12-05 17:24:06 +00:00
log.Println("Notspeaking")
session.Speaking(context.Background(), voicegateway.NotSpeaking)
spk = false
}
return
}
if !spk && spklimit.Allow() {
2022-12-05 17:24:06 +00:00
log.Println("Speaking")
session.Speaking(context.Background(), voicegateway.Microphone)
spk = true
}
var f32 []float32
for _, sample := range samples {
f32 = append(f32, float32(sample[0]))
f32 = append(f32, float32(sample[1]))
2022-11-18 21:18:12 +00:00
}
n, err := encoder.EncodeFloat32(f32, buf)
2022-12-05 17:24:06 +00:00
if err != nil {
log.Println(err)
2022-11-18 21:18:12 +00:00
return
}
pw.Write(buf[:n])
2022-11-18 21:18:12 +00:00
}
func IsSilent(in [][2]float64) bool {
for _, v := range in {
if v != Silence {
return false
}
}
return true
}