mirror of
https://github.com/mgerb/go-discord-bot
synced 2026-01-10 09:02:49 +00:00
429 lines
9.4 KiB
Go
429 lines
9.4 KiB
Go
package bothandlers
|
|
|
|
import (
|
|
"bufio"
|
|
"encoding/binary"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"io/ioutil"
|
|
"log"
|
|
"os"
|
|
"os/exec"
|
|
"strconv"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"layeh.com/gopus"
|
|
|
|
"github.com/bwmarrin/discordgo"
|
|
"github.com/cryptix/wav"
|
|
"github.com/mgerb/go-discord-bot/server/config"
|
|
)
|
|
|
|
const (
|
|
channels int = 2 // 1 for mono, 2 for stereo
|
|
frameRate int = 48000 // audio sampling rate
|
|
frameSize int = 960 // uint16 size of each audio frame
|
|
maxBytes int = (frameSize * 2) * 2 // max size of opus data
|
|
maxSoundQueue int = 10 // max amount of sounds that can be queued at one time
|
|
|
|
// TODO: figure out why api isn't returning bitrate
|
|
bitRate int = 64000
|
|
sampleRate int = 96000
|
|
)
|
|
|
|
// store our connection objects in a map tied to a guild id
|
|
var activeConnections = make(map[string]*audioConnection)
|
|
|
|
type audioConnection struct {
|
|
guild *discordgo.Guild
|
|
session *discordgo.Session
|
|
sounds map[string]*audioClip
|
|
soundQueue chan string
|
|
voiceConnection *discordgo.VoiceConnection
|
|
currentChannel *discordgo.Channel
|
|
soundPlayingLock bool
|
|
mutex *sync.Mutex // mutex for single audio connection
|
|
}
|
|
|
|
type audioClip struct {
|
|
Name string
|
|
Extension string
|
|
Content [][]byte
|
|
}
|
|
|
|
// SoundsHandler -
|
|
func SoundsHandler(s *discordgo.Session, m *discordgo.MessageCreate) {
|
|
|
|
// get channel state to get guild id
|
|
c, err := s.State.Channel(m.ChannelID)
|
|
if err != nil {
|
|
// Could not find channel.
|
|
fmt.Println("Unable to find channel.")
|
|
return
|
|
}
|
|
|
|
// check to see if active connection object exists
|
|
if _, ok := activeConnections[c.GuildID]; !ok {
|
|
|
|
// Find the guild for that channel.
|
|
newGuild, err := s.State.Guild(c.GuildID)
|
|
if err != nil {
|
|
log.Println(err)
|
|
return
|
|
}
|
|
|
|
// create new connection instance
|
|
newInstance := &audioConnection{
|
|
guild: newGuild,
|
|
session: s,
|
|
sounds: make(map[string]*audioClip, 0),
|
|
soundQueue: make(chan string, maxSoundQueue),
|
|
mutex: &sync.Mutex{},
|
|
}
|
|
|
|
activeConnections[c.GuildID] = newInstance
|
|
|
|
// start listening on the sound channel
|
|
go activeConnections[c.GuildID].playSounds()
|
|
}
|
|
|
|
// start new go routine handling the message
|
|
go activeConnections[c.GuildID].handleMessage(m)
|
|
}
|
|
|
|
func (conn *audioConnection) handleMessage(m *discordgo.MessageCreate) {
|
|
|
|
// check if valid command
|
|
if strings.HasPrefix(m.Content, config.Config.BotPrefix) {
|
|
|
|
command := strings.TrimPrefix(m.Content, config.Config.BotPrefix)
|
|
|
|
switch command {
|
|
|
|
case "summon":
|
|
conn.summon(m)
|
|
|
|
case "dismiss":
|
|
conn.dismiss()
|
|
|
|
case "clip":
|
|
conn.clipAudio()
|
|
|
|
default:
|
|
conn.playAudio(command, m)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (conn *audioConnection) dismiss() {
|
|
if conn.voiceConnection != nil && !conn.soundPlayingLock && len(conn.soundQueue) == 0 {
|
|
conn.voiceConnection.Disconnect()
|
|
}
|
|
}
|
|
|
|
func (conn *audioConnection) summon(m *discordgo.MessageCreate) {
|
|
// Join the channel the user issued the command from if not in it
|
|
if conn.voiceConnection == nil || conn.voiceConnection.ChannelID != m.ChannelID {
|
|
var err error
|
|
|
|
// Find the channel that the message came from.
|
|
c, err := conn.session.State.Channel(m.ChannelID)
|
|
if err != nil {
|
|
// Could not find channel.
|
|
fmt.Println("User channel not found.")
|
|
return
|
|
}
|
|
|
|
// Find the guild for that channel.
|
|
g, err := conn.session.State.Guild(c.GuildID)
|
|
if err != nil {
|
|
log.Println(err)
|
|
return
|
|
}
|
|
|
|
// Look for the message sender in that guilds current voice states.
|
|
for _, vs := range g.VoiceStates {
|
|
if vs.UserID == m.Author.ID {
|
|
|
|
conn.voiceConnection, err = conn.session.ChannelVoiceJoin(g.ID, vs.ChannelID, false, false)
|
|
|
|
if err != nil {
|
|
log.Println(err)
|
|
}
|
|
|
|
// set the current channel
|
|
conn.currentChannel = c
|
|
|
|
// start listening to audio after joining channel
|
|
go conn.startAudioListener()
|
|
|
|
return
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
func (conn *audioConnection) playAudio(soundName string, m *discordgo.MessageCreate) {
|
|
|
|
// check if sound exists in memory
|
|
if _, ok := conn.sounds[soundName]; !ok {
|
|
// try to load the sound if not found in memory
|
|
err := conn.loadFile(soundName)
|
|
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
return
|
|
}
|
|
}
|
|
|
|
// summon bot to channel
|
|
conn.summon(m)
|
|
|
|
// add sound to queue if queue isn't full
|
|
select {
|
|
case conn.soundQueue <- soundName:
|
|
|
|
default:
|
|
return
|
|
}
|
|
|
|
}
|
|
|
|
// load dca file into memory
|
|
func (conn *audioConnection) loadFile(fileName string) error {
|
|
|
|
// scan directory for file
|
|
files, _ := ioutil.ReadDir(config.Config.SoundsPath)
|
|
var fextension string
|
|
var fname string
|
|
for _, f := range files {
|
|
fname = strings.Split(f.Name(), ".")[0]
|
|
fextension = "." + strings.Split(f.Name(), ".")[1]
|
|
|
|
if fname == fileName {
|
|
break
|
|
}
|
|
|
|
fname = ""
|
|
}
|
|
|
|
if fname == "" {
|
|
return errors.New("File not found")
|
|
}
|
|
|
|
fmt.Println("Loading file: " + fname + fextension)
|
|
|
|
// use ffmpeg to convert file into a format we can use
|
|
cmd := exec.Command("ffmpeg", "-i", config.Config.SoundsPath+fname+fextension, "-f", "s16le", "-ar", strconv.Itoa(frameRate), "-ac", strconv.Itoa(channels), "pipe:1")
|
|
|
|
ffmpegout, err := cmd.StdoutPipe()
|
|
|
|
if err != nil {
|
|
return errors.New("Unable to execute ffmpeg. To set permissions on this file run chmod +x ffmpeg_linux (or ffmpeg_mac depending which operating system you are on)")
|
|
}
|
|
|
|
ffmpegbuf := bufio.NewReaderSize(ffmpegout, 16348)
|
|
|
|
err = cmd.Start()
|
|
|
|
if err != nil {
|
|
return errors.New("Unable to execute ffmpeg. To set permissions on this file run chmod +x ffmpeg_linux (or ffmpeg_mac depending which operating system you are on)")
|
|
}
|
|
|
|
// crate encoder to convert audio to opus codec
|
|
opusEncoder, err := gopus.NewEncoder(frameRate, channels, gopus.Audio)
|
|
|
|
if err != nil {
|
|
return errors.New("NewEncoder error.")
|
|
}
|
|
|
|
conn.sounds[fileName] = &audioClip{
|
|
Content: make([][]byte, 0),
|
|
Name: fileName,
|
|
Extension: fextension,
|
|
}
|
|
|
|
for {
|
|
// read data from ffmpeg stdout
|
|
audiobuf := make([]int16, frameSize*channels)
|
|
err = binary.Read(ffmpegbuf, binary.LittleEndian, &audiobuf)
|
|
if err == io.EOF || err == io.ErrUnexpectedEOF {
|
|
return nil
|
|
}
|
|
if err != nil {
|
|
return errors.New("Error reading from ffmpeg stdout.")
|
|
}
|
|
|
|
// convert audio to opus codec
|
|
opus, err := opusEncoder.Encode(audiobuf, frameSize, maxBytes)
|
|
if err != nil {
|
|
return errors.New("Encoding error.")
|
|
}
|
|
|
|
// append sound bytes to the content for this audio file
|
|
conn.sounds[fileName].Content = append(conn.sounds[fileName].Content, opus)
|
|
}
|
|
|
|
}
|
|
|
|
func (conn *audioConnection) clipAudio() {
|
|
|
|
}
|
|
|
|
func (conn *audioConnection) startAudioListener() {
|
|
|
|
speakers := make(map[uint32]*gopus.Decoder)
|
|
voicePackets := []*discordgo.Packet{}
|
|
var err error
|
|
|
|
loop:
|
|
for {
|
|
|
|
select {
|
|
case opusChannel, ok := <-conn.voiceConnection.OpusRecv:
|
|
if !ok {
|
|
continue
|
|
}
|
|
|
|
_, ok = speakers[opusChannel.SSRC]
|
|
|
|
if !ok {
|
|
speakers[opusChannel.SSRC], err = gopus.NewDecoder(frameRate, 1)
|
|
if err != nil {
|
|
log.Println("error creating opus decoder", err)
|
|
continue
|
|
}
|
|
}
|
|
|
|
opusChannel.PCM, err = speakers[opusChannel.SSRC].Decode(opusChannel.Opus, frameSize, false)
|
|
if err != nil {
|
|
log.Println("Error decoding opus data", err)
|
|
continue
|
|
}
|
|
|
|
voicePackets = append(voicePackets, opusChannel)
|
|
|
|
// TODO:
|
|
fmt.Println(len(voicePackets))
|
|
fmt.Println(int(opusChannel.Timestamp) / bitRate)
|
|
if len(voicePackets) > bitRate*5 {
|
|
voicePackets = voicePackets[1:]
|
|
}
|
|
|
|
default:
|
|
if !conn.voiceConnection.Ready {
|
|
break loop
|
|
}
|
|
|
|
// cleanOldPackets(voicePackets)
|
|
}
|
|
|
|
}
|
|
|
|
writeWavFile(voicePackets)
|
|
|
|
}
|
|
|
|
// // remove packets that are more than 1 minute old
|
|
// func cleanOldPackets(packets []*discordgo.Packet) {
|
|
|
|
// if len(packets) < 1 {
|
|
// return
|
|
// }
|
|
|
|
// // latest timestamp divided by bitrate
|
|
// currentTime := int(packets[len(packets)-1].Timestamp) / bitRate
|
|
|
|
// index := 0
|
|
// // grab the index of the first object less than a minute ago
|
|
// for i, p := range packets {
|
|
// timestamp := int(p.Timestamp) / bitRate
|
|
// if timestamp < currentTime-5 {
|
|
// index = i
|
|
// break
|
|
// } else if timestamp > currentTime-5 {
|
|
// break
|
|
// }
|
|
// }
|
|
|
|
// if index != 0 {
|
|
|
|
// log.Println("cleaning")
|
|
// log.Println(index)
|
|
// }
|
|
|
|
// packets = packets[index:]
|
|
|
|
// }
|
|
|
|
func writeWavFile(packets []*discordgo.Packet) {
|
|
|
|
wavOut, err := os.Create("test.wav")
|
|
checkErr(err)
|
|
defer wavOut.Close()
|
|
|
|
meta := wav.File{
|
|
Channels: 1,
|
|
SampleRate: uint32(sampleRate),
|
|
SignificantBits: 16,
|
|
}
|
|
|
|
writer, err := meta.NewWriter(wavOut)
|
|
checkErr(err)
|
|
defer writer.Close()
|
|
|
|
for _, p := range packets {
|
|
for _, pcm := range p.PCM {
|
|
err := writer.WriteInt32(int32(pcm))
|
|
checkErr(err)
|
|
}
|
|
}
|
|
}
|
|
|
|
// playSounds - plays the current buffer to the provided channel.
|
|
func (conn *audioConnection) playSounds() (err error) {
|
|
|
|
for {
|
|
newSoundName := <-conn.soundQueue
|
|
|
|
conn.toggleSoundPlayingLock(true)
|
|
|
|
if !conn.voiceConnection.Ready {
|
|
continue
|
|
}
|
|
|
|
// Start speaking.
|
|
_ = conn.voiceConnection.Speaking(true)
|
|
|
|
// Send the buffer data.
|
|
for _, buff := range conn.sounds[newSoundName].Content {
|
|
conn.voiceConnection.OpusSend <- buff
|
|
}
|
|
|
|
// Stop speaking
|
|
_ = conn.voiceConnection.Speaking(false)
|
|
|
|
// Sleep for a specificed amount of time before ending.
|
|
time.Sleep(50 * time.Millisecond)
|
|
|
|
conn.toggleSoundPlayingLock(false)
|
|
}
|
|
|
|
}
|
|
|
|
func (conn *audioConnection) toggleSoundPlayingLock(playing bool) {
|
|
conn.mutex.Lock()
|
|
conn.soundPlayingLock = playing
|
|
conn.mutex.Unlock()
|
|
}
|
|
|
|
func checkErr(err error) {
|
|
if err != nil {
|
|
log.Println(err)
|
|
}
|
|
}
|