diff --git a/.gitignore b/.gitignore index 87b6e38..c5efcd4 100644 --- a/.gitignore +++ b/.gitignore @@ -3,5 +3,7 @@ main mumble-discord-bridge dist bridge -.prof +*.prof +*.out +*.test cert.pem \ No newline at end of file diff --git a/Makefile b/Makefile index 5d9d6cd..80a6b48 100644 --- a/Makefile +++ b/Makefile @@ -1,4 +1,4 @@ -GOFILES=main.go mumble.go discord.go bridge.go config.go mumble-handlers.go discord-handlers.go +GOFILES=main.go mumble.go discord.go bridge.go config.go mumble-handlers.go discord-handlers.go sleepct.go mumble-discord-bridge: $(GOFILES) goreleaser build --skip-validate --rm-dist @@ -7,11 +7,17 @@ dev: $(GOFILES) goreleaser build --skip-validate --rm-dist && sudo ./dist/mumble-discord-bridge_linux_amd64/mumble-discord-bridge dev-race: $(GOFILES) - go run -race *.go + go run -race $(GOFILES) dev-profile: $(GOFILES) goreleaser build --skip-validate --rm-dist && sudo ./dist/mumble-discord-bridge_linux_amd64/mumble-discord-bridge -cpuprofile cpu.prof +test-chart: SHELL:=/bin/bash +test-chart: + go test & + until pidof mumble-discord-bridge.test; do continue; done; + psrecord --plot docs/test-cpu-memory.png $$(pidof mumble-discord-bridge.test) + docker-latest: docker build -t stieneee/mumble-discord-bridge:latest . diff --git a/README.md b/README.md index 23a072b..12ca1a1 100644 --- a/README.md +++ b/README.md @@ -12,41 +12,48 @@ The binary will also attempt to load .env file located in the working directory. ```bash Usage of ./mumble-discord-bridge: + -cpuprofile file + write cpu profile to file + -debug-level int + DEBUG_LEVEL, Discord debug level, optional, (default 1) (default 1) -discord-cid string - DISCORD_CID, discord cid, required + DISCORD_CID, discord cid, required -discord-command string - DISCORD_COMMAND, Discord command string, env alt DISCORD_COMMAND, optional, (defaults mumble-discord) (default "mumble-discord") + DISCORD_COMMAND, Discord command string, env alt DISCORD_COMMAND, optional, (defaults mumble-discord) (default "mumble-discord") -discord-disable-text - DISCORD_DISABLE_TEXT, disable sending direct messages to discord, (default false) + DISCORD_DISABLE_TEXT, disable sending direct messages to discord, (default false) -discord-gid string - DISCORD_GID, discord gid, required + DISCORD_GID, discord gid, required -discord-token string - DISCORD_TOKEN, discord bot token, required + DISCORD_TOKEN, discord bot token, required -mode string - MODE, [constant, manual, auto] determine which mode the bridge starts in, (default constant) (default "constant") + MODE, [constant, manual, auto] determine which mode the bridge starts in, (default constant) (default "constant") -mumble-address string - MUMBLE_ADDRESS, mumble server address, example example.com, required + MUMBLE_ADDRESS, mumble server address, example example.com, required + -mumble-certificate string + MUMBLE_CERTIFICATE, client certificate to use when connecting to the Mumble server -mumble-channel string - MUMBLE_CHANNEL, mumble channel to start in, using '/' to separate nested channels, optional + MUMBLE_CHANNEL, mumble channel to start in, using '/' to separate nested channels, optional -mumble-disable-text - MUMBLE_DISABLE_TEXT, disable sending text to mumble, (default false) + MUMBLE_DISABLE_TEXT, disable sending text to mumble, (default false) -mumble-insecure - MUMBLE_INSECURE, mumble insecure, optional - -mumble-certificate - MUMBLE_CERTIFICATE, mumble client certificate, optional + MUMBLE_INSECURE, mumble insecure, optional -mumble-password string - MUMBLE_PASSWORD, mumble password, optional + MUMBLE_PASSWORD, mumble password, optional -mumble-port int - MUMBLE_PORT, mumble port, (default 64738) (default 64738) + MUMBLE_PORT, mumble port, (default 64738) (default 64738) -mumble-username string - MUMBLE_USERNAME, mumble username, (default: discord) (default "Discord") + MUMBLE_USERNAME, mumble username, (default: discord) (default "Discord") -nice - NICE, whether the bridge should automatically try to 'nice' itself, (default false) - -debug - DEBUG_LEVEL, DISCORD debug level, optional (default: 1) + NICE, whether the bridge should automatically try to 'nice' itself, (default false) + -to-discord-buffer int + TO_DISCORD_BUFFER, Jitter buffer from Mumble to Discord to absorb timing issues related to network, OS and hardware quality. (Increments of 10ms) (default 50) + -to-mumble-buffer int + TO_MUMBLE_BUFFER, Jitter buffer from Discord to Mumble to absorb timing issues related to network, OS and hardware quality. (Increments of 10ms) (default 50) ``` The bridge can be run with the follow modes: + ```bash auto The bridge starts up but does not connect immediately. It can be either manually linked (see below) or will join the voice channels when there's at least one person on each side. @@ -61,14 +68,18 @@ In "auto" or "manual" modes, the bridge can be controlled in Discord with the fo ```bash !DISCORD_COMMAND link - Commands the bridge to join the Discord channel the user is in and the Mumble server + Commands the bridge to join the Discord channel the user is in and the Mumble server + !DISCORD_COMMAND unlink - Commands the bridge to leave the Discord channel the user is in and the Mumble server + Commands the bridge to leave the Discord channel the user is in and the Mumble server + !DISCORD_COMMAND refresh - Commands the bridge to unlink, then link again. + Commands the bridge to unlink, then link again. + !DISCORD_COMMAND auto - Toggle between manual and auto mode + Toggle between manual and auto mode ``` + ## Setup ### Creating a Discord Bot @@ -80,6 +91,7 @@ The guide below provides information on how to setup a Discord bot. Individual Discord servers need to invite the bot before it can connect. The bot requires the following permissions: + * View Channels * See Messages * Read Message History @@ -160,6 +172,21 @@ go build -o mumble-discord-bridge *.go make mumble-discord-bridge ``` +### OpenBSD Users + +OpenBSD users should consider compiling a custom kernel to use 1000 ticks for the best possible performance. +See [issue 20](https://github.com/Stieneee/mumble-discord-bridge/issues/20) for the latest discussion about this topic. + +## Jitter Buffer + +The bridge implements simple jitter buffers that attempt to compensate for network, OS and hardware related jitter. +These jitter buffers are configurable in both directions. +A jitter buffer will slightly the delay the transmission of audio in order to have audio packets buffered for the next time step. +The Mumble client itself includes a jitter buffer for similar reasons. +A default jitter of 50ms should be adequate for most scenarios. +A warning will be logged if short burst or audio are seen. +A single warning can be ignored multiple warnings in short time spans would suggest the need for a larger jitter buffer. + ## Known Issues Currently there is an issue opening the discord voice channel. @@ -185,5 +212,5 @@ Please consider opening an issue to discuss features and ideas. The project would not have been possible without: -- [gumble](https://github.com/layeh/gumble) -- [discordgo](https://github.com/bwmarrin/discordgo) +* [gumble](https://github.com/layeh/gumble) +* [discordgo](https://github.com/bwmarrin/discordgo) diff --git a/config.go b/config.go index 84b7558..bcf4539 100644 --- a/config.go +++ b/config.go @@ -21,16 +21,18 @@ const ( //BridgeConfig holds configuration information set at startup //It should not change during runtime type BridgeConfig struct { - MumbleConfig *gumble.Config - MumbleAddr string - MumbleInsecure bool - MumbleCertificate string - MumbleChannel []string - MumbleDisableText bool - Command string - GID string - CID string - DiscordDisableText bool + MumbleConfig *gumble.Config + MumbleAddr string + MumbleInsecure bool + MumbleCertificate string + MumbleChannel []string + mumbleStartStreamCount int + MumbleDisableText bool + Command string + GID string + CID string + DiscordStartStreamingCount int + DiscordDisableText bool } func lookupEnvOrString(key string, defaultVal string) string { diff --git a/discord.go b/discord.go index 4268780..23fe141 100644 --- a/discord.go +++ b/discord.go @@ -55,13 +55,45 @@ func (dd *DiscordDuplex) discordSendPCM(ctx context.Context, wg *sync.WaitGroup, panic(err) } - ticker := time.NewTicker(20 * time.Millisecond) + // Generate Opus Silence Frame + opusSilence := []byte{0xf8, 0xff, 0xfe} + for i := 3; i < frameSize; i++ { + opusSilence = append(opusSilence, 0x00) + } + + // ticker := NewTickerCT(20 * time.Millisecond) + sleepTick := SleepCT{ + d: 20 * time.Millisecond, + t: time.Now(), + } lastReady := true var readyTimeout *time.Timer + var speakingStart time.Time wg.Add(1) + internalSend := func(opus []byte) { + dd.Bridge.DiscordVoice.RWMutex.RLock() + if !dd.Bridge.DiscordVoice.Ready || dd.Bridge.DiscordVoice.OpusSend == nil { + if lastReady { + OnError(fmt.Sprintf("Discordgo not ready for opus packets. %+v : %+v", dd.Bridge.DiscordVoice.Ready, dd.Bridge.DiscordVoice.OpusSend), nil) + readyTimeout = time.AfterFunc(30*time.Second, func() { + log.Println("set ready timeout") + cancel() + }) + lastReady = false + } + } else if !lastReady { + fmt.Println("Discordgo ready to send opus packets") + lastReady = true + readyTimeout.Stop() + } else { + dd.Bridge.DiscordVoice.OpusSend <- opus + } + dd.Bridge.DiscordVoice.RWMutex.RUnlock() + } + for { select { case <-ctx.Done(): @@ -69,9 +101,12 @@ func (dd *DiscordDuplex) discordSendPCM(ctx context.Context, wg *sync.WaitGroup, return default: } - <-ticker.C - if len(pcm) > 1 { + + sleepTick.SleepNextTarget() + + if (len(pcm) > 1 && streaming) || (len(pcm) > dd.Bridge.BridgeConfig.DiscordStartStreamingCount && !streaming) { if !streaming { + speakingStart = time.Now() dd.Bridge.DiscordVoice.Speaking(true) streaming = true } @@ -86,27 +121,26 @@ func (dd *DiscordDuplex) discordSendPCM(ctx context.Context, wg *sync.WaitGroup, continue } - dd.Bridge.DiscordVoice.RWMutex.RLock() - if !dd.Bridge.DiscordVoice.Ready || dd.Bridge.DiscordVoice.OpusSend == nil { - if lastReady { - OnError(fmt.Sprintf("Discordgo not ready for opus packets. %+v : %+v", dd.Bridge.DiscordVoice.Ready, dd.Bridge.DiscordVoice.OpusSend), nil) - readyTimeout = time.AfterFunc(30*time.Second, func() { - log.Println("set ready timeout") - cancel() - }) - lastReady = false - } - } else if !lastReady { - fmt.Println("Discordgo ready to send opus packets") - lastReady = true - readyTimeout.Stop() - } else { - dd.Bridge.DiscordVoice.OpusSend <- opus - } - dd.Bridge.DiscordVoice.RWMutex.RUnlock() + internalSend(opus) } else { if streaming { + // Check to see if there is a short speaking cycle. + // It is possible that short speaking cycle is the result of a short input to mumble (Not a problem). ie a quick tap of push to talk button. + // Or when timing delays are introduced via network, hardware or kernel delays (Problem). + // The problem delays result in choppy or stuttering sounds, especially when the silence frames are introduced into the opus frames below. + // Multiple short cycle delays can result in a Discrod rate limiter being trigger due to of multiple JSON speaking/not-speaking state changes + if time.Since(speakingStart).Milliseconds() < 100 { + log.Println("Warning: Short Mumble to Discord speaking cycle. Consider increaseing the size of the to Discord jitter buffer.") + } + + // Send silence as suggested by Discord Documentation. + // We want to do this after alerting the user of possible short speaking cycles + for i := 0; i < 5; i++ { + internalSend(opusSilence) + sleepTick.SleepNextTarget() + } + dd.Bridge.DiscordVoice.Speaking(false) streaming = false } @@ -205,8 +239,17 @@ func (dd *DiscordDuplex) discordReceivePCM(ctx context.Context, wg *sync.WaitGro } func (dd *DiscordDuplex) fromDiscordMixer(ctx context.Context, wg *sync.WaitGroup, toMumble chan<- gumble.AudioBuffer) { - ticker := time.NewTicker(10 * time.Millisecond) + mumbleSilence := gumble.AudioBuffer{} + for i := 3; i < 480; i++ { + mumbleSilence = append(mumbleSilence, 0x00) + } + var speakingStart time.Time + sleepTick := SleepCT{ + d: 10 * time.Millisecond, + t: time.Now(), + } sendAudio := false + toMumbleStreaming := false wg.Add(1) for { @@ -214,9 +257,11 @@ func (dd *DiscordDuplex) fromDiscordMixer(ctx context.Context, wg *sync.WaitGrou case <-ctx.Done(): wg.Done() return - case <-ticker.C: + default: } + sleepTick.SleepNextTarget() + dd.discordMutex.Lock() sendAudio = false @@ -224,9 +269,16 @@ func (dd *DiscordDuplex) fromDiscordMixer(ctx context.Context, wg *sync.WaitGrou // Work through each channel for i := range dd.fromDiscordMap { - if len(dd.fromDiscordMap[i].pcm) > 0 { + bufferLength := len(dd.fromDiscordMap[i].pcm) + isStreaming := dd.fromDiscordMap[i].streaming + if (bufferLength > 0 && isStreaming) || (bufferLength > dd.Bridge.BridgeConfig.mumbleStartStreamCount && !isStreaming) { + if !toMumbleStreaming { + speakingStart = time.Now() + toMumbleStreaming = true + } sendAudio = true - if !dd.fromDiscordMap[i].streaming { + + if !isStreaming { x := dd.fromDiscordMap[i] x.streaming = true dd.fromDiscordMap[i] = x @@ -245,21 +297,44 @@ func (dd *DiscordDuplex) fromDiscordMixer(ctx context.Context, wg *sync.WaitGrou dd.discordMutex.Unlock() - outBuf := make([]int16, 480) + mumbleTimeoutSend := func(outBuf []int16) { + timeout := make(chan bool, 1) + go func() { + time.Sleep(10 * time.Millisecond) + timeout <- true + }() - for i := 0; i < len(outBuf); i++ { - for j := 0; j < len(internalMixerArr); j++ { - outBuf[i] += (internalMixerArr[j])[i] + select { + case toMumble <- outBuf: + case <-timeout: + log.Println("toMumble timeout. Dropping packet") } } if sendAudio { - select { - case toMumble <- outBuf: - default: - log.Println("toMumble buffer full. Dropping packet") + // Regular send mixed audio + outBuf := make([]int16, 480) + + for i := 0; i < len(outBuf); i++ { + for j := 0; j < len(internalMixerArr); j++ { + outBuf[i] += (internalMixerArr[j])[i] + } } + mumbleTimeoutSend(outBuf) + } else if !sendAudio && toMumbleStreaming { + // Send opus silence to mumble + // See note above about jitter buffer warning + if time.Since(speakingStart).Milliseconds() < 100 { + log.Println("Warning: Short Discord to Mumble speaking cycle. Consider increaseing the size of the to Mumble jitter buffer.") + } + + for i := 0; i < 5; i++ { + mumbleTimeoutSend(mumbleSilence) + sleepTick.SleepNextTarget() + } + + toMumbleStreaming = false } } } diff --git a/docs/audio-flow.drawio.png b/docs/audio-flow.drawio.png new file mode 100644 index 0000000..cdd02bd Binary files /dev/null and b/docs/audio-flow.drawio.png differ diff --git a/docs/test-cpu-memory.png b/docs/test-cpu-memory.png new file mode 100644 index 0000000..3d20fc2 Binary files /dev/null and b/docs/test-cpu-memory.png differ diff --git a/go.mod b/go.mod index ad4ffd3..37ad23d 100644 --- a/go.mod +++ b/go.mod @@ -7,6 +7,7 @@ require ( github.com/golang/protobuf v1.4.3 // indirect github.com/gorilla/websocket v1.4.2 // indirect github.com/joho/godotenv v1.3.0 + github.com/stieneee/tickerct v0.0.0-20210420020607-d1b092aa40e9 golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad // indirect golang.org/x/sys v0.0.0-20210108172913-0df2131ae363 // indirect google.golang.org/protobuf v1.25.0 // indirect diff --git a/go.sum b/go.sum index a7b2e37..2e6259b 100644 --- a/go.sum +++ b/go.sum @@ -46,6 +46,8 @@ github.com/joho/godotenv v1.3.0 h1:Zjp+RcGpHhGlrMbJzXTrZZPrWj+1vfm90La1wgB6Bhc= github.com/joho/godotenv v1.3.0/go.mod h1:7hK45KPybAkOC6peb+G5yklZfMxEjkZhHbwpqxOKXbg= github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4 h1:gQz4mCbXsO+nc9n1hCxHcGA3Zx3Eo+UHZoInFGUIXNM= github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= +github.com/stieneee/tickerct v0.0.0-20210420020607-d1b092aa40e9 h1:0l2H6Oj6JHMmkqm9xaBMQA5MOGhPT+Nn/thlTUcD9Iw= +github.com/stieneee/tickerct v0.0.0-20210420020607-d1b092aa40e9/go.mod h1:54+oZlabriEpT52rPAjAeEWUFgYqv325LrS3hNxHGFE= golang.org/x/crypto v0.0.0-20181030102418-4d3f4d9ffa16 h1:y6ce7gCWtnH+m3dCjzQ1PCuwl28DDIc3VNnvY29DlIA= golang.org/x/crypto v0.0.0-20181030102418-4d3f4d9ffa16/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= diff --git a/main.go b/main.go index 00e720b..5173200 100644 --- a/main.go +++ b/main.go @@ -4,6 +4,7 @@ import ( "flag" "fmt" "log" + "math" "os" "os/signal" "runtime/pprof" @@ -41,10 +42,12 @@ func main() { mumbleInsecure := flag.Bool("mumble-insecure", lookupEnvOrBool("MUMBLE_INSECURE", false), " MUMBLE_INSECURE, mumble insecure, optional") mumbleCertificate := flag.String("mumble-certificate", lookupEnvOrString("MUMBLE_CERTIFICATE", ""), "MUMBLE_CERTIFICATE, client certificate to use when connecting to the Mumble server") mumbleChannel := flag.String("mumble-channel", lookupEnvOrString("MUMBLE_CHANNEL", ""), "MUMBLE_CHANNEL, mumble channel to start in, using '/' to separate nested channels, optional") + mumbleSendBuffer := flag.Int("to-mumble-buffer", lookupEnvOrInt("TO_MUMBLE_BUFFER", 50), "TO_MUMBLE_BUFFER, Jitter buffer from Discord to Mumble to absorb timing issues related to network, OS and hardware quality. (Increments of 10ms)") mumbleDisableText := flag.Bool("mumble-disable-text", lookupEnvOrBool("MUMBLE_DISABLE_TEXT", false), "MUMBLE_DISABLE_TEXT, disable sending text to mumble, (default false)") discordToken := flag.String("discord-token", lookupEnvOrString("DISCORD_TOKEN", ""), "DISCORD_TOKEN, discord bot token, required") discordGID := flag.String("discord-gid", lookupEnvOrString("DISCORD_GID", ""), "DISCORD_GID, discord gid, required") discordCID := flag.String("discord-cid", lookupEnvOrString("DISCORD_CID", ""), "DISCORD_CID, discord cid, required") + discordSendBuffer := flag.Int("to-discord-buffer", lookupEnvOrInt("TO_DISCORD_BUFFER", 50), "TO_DISCORD_BUFFER, Jitter buffer from Mumble to Discord to absorb timing issues related to network, OS and hardware quality. (Increments of 10ms)") discordCommand := flag.String("discord-command", lookupEnvOrString("DISCORD_COMMAND", "mumble-discord"), "DISCORD_COMMAND, Discord command string, env alt DISCORD_COMMAND, optional, (defaults mumble-discord)") discordDisableText := flag.Bool("discord-disable-text", lookupEnvOrBool("DISCORD_DISABLE_TEXT", false), "DISCORD_DISABLE_TEXT, disable sending direct messages to discord, (default false)") mode := flag.String("mode", lookupEnvOrString("MODE", "constant"), "MODE, [constant, manual, auto] determine which mode the bridge starts in, (default constant)") @@ -95,20 +98,37 @@ func main() { defer pprof.StopCPUProfile() } + // Buffer Math + if *discordSendBuffer < 10 { + *discordSendBuffer = 10 + } + + if *mumbleSendBuffer < 10 { + *mumbleSendBuffer = 10 + } + + var discordStartStreamingCount int = int(math.Round(float64(*discordSendBuffer) / 10.0)) + log.Println("To Discord Jitter Buffer: ", discordStartStreamingCount*10, " ms") + + var mumbleStartStreamCount int = int(math.Round(float64(*mumbleSendBuffer) / 10.0)) + log.Println("To Mumble Jitter Buffer: ", mumbleStartStreamCount*10, " ms") + // BRIDGE SETUP Bridge := &BridgeState{ BridgeConfig: &BridgeConfig{ // MumbleConfig: config, - MumbleAddr: *mumbleAddr + ":" + strconv.Itoa(*mumblePort), - MumbleInsecure: *mumbleInsecure, - MumbleCertificate: *mumbleCertificate, - MumbleChannel: strings.Split(*mumbleChannel, "/"), - MumbleDisableText: *mumbleDisableText, - Command: *discordCommand, - GID: *discordGID, - CID: *discordCID, - DiscordDisableText: *discordDisableText, + MumbleAddr: *mumbleAddr + ":" + strconv.Itoa(*mumblePort), + MumbleInsecure: *mumbleInsecure, + MumbleCertificate: *mumbleCertificate, + MumbleChannel: strings.Split(*mumbleChannel, "/"), + mumbleStartStreamCount: mumbleStartStreamCount, + MumbleDisableText: *mumbleDisableText, + Command: *discordCommand, + GID: *discordGID, + CID: *discordCID, + DiscordStartStreamingCount: discordStartStreamingCount, + DiscordDisableText: *discordDisableText, }, Connected: false, DiscordUsers: make(map[string]discordUser), @@ -177,9 +197,16 @@ func main() { Bridge.Mode = bridgeModeConstant Bridge.DiscordChannelID = Bridge.BridgeConfig.CID go func() { + defer func() { + if r := recover(); r != nil { + fmt.Println("Bridge paniced", r) + } + }() for { Bridge.startBridge() - log.Println("Bridge died. Restarting") + log.Println("Bridge died") + time.Sleep(5 * time.Second) + log.Println("Restarting") } }() default: @@ -191,7 +218,7 @@ func main() { // Shutdown on OS signal sc := make(chan os.Signal, 1) - signal.Notify(sc, syscall.SIGINT, syscall.SIGTERM, os.Interrupt, os.Kill) + signal.Notify(sc, syscall.SIGINT, syscall.SIGTERM, os.Interrupt) <-sc log.Println("OS Signal. Bot shutting down") diff --git a/mumble.go b/mumble.go index 66a6a4a..c248b57 100644 --- a/mumble.go +++ b/mumble.go @@ -44,8 +44,13 @@ func (m MumbleDuplex) OnAudioStream(e *gumble.AudioStreamEvent) { } func (m MumbleDuplex) fromMumbleMixer(ctx context.Context, wg *sync.WaitGroup, toDiscord chan []int16) { - ticker := time.NewTicker(10 * time.Millisecond) + sleepTick := SleepCT{ + d: 10 * time.Millisecond, + t: time.Now(), + } sendAudio := false + bufferWarning := false + wg.Add(1) for { @@ -56,7 +61,7 @@ func (m MumbleDuplex) fromMumbleMixer(ctx context.Context, wg *sync.WaitGroup, t default: } - <-ticker.C + sleepTick.SleepNextTarget() mutex.Lock() @@ -84,19 +89,32 @@ func (m MumbleDuplex) fromMumbleMixer(ctx context.Context, wg *sync.WaitGroup, t mutex.Unlock() - outBuf := make([]int16, 480) - - for i := 0; i < len(outBuf); i++ { - for j := 0; j < len(internalMixerArr); j++ { - outBuf[i] += (internalMixerArr[j])[i] - } - } - if sendAudio { + + outBuf := make([]int16, 480) + + for i := 0; i < len(outBuf); i++ { + for j := 0; j < len(internalMixerArr); j++ { + outBuf[i] += (internalMixerArr[j])[i] + } + } + + if len(toDiscord) > 20 { + if !bufferWarning { + log.Println("Warning: toDiscord buffer size") + bufferWarning = true + } + } else { + if bufferWarning { + log.Println("Resolved: toDiscord buffer size") + bufferWarning = false + } + } + select { case toDiscord <- outBuf: default: - log.Println("toDiscord buffer full. Dropping packet") + log.Println("Error: toDiscord buffer full. Dropping packet") } } } diff --git a/sleepct.go b/sleepct.go new file mode 100644 index 0000000..f5277c7 --- /dev/null +++ b/sleepct.go @@ -0,0 +1,41 @@ +package main + +import ( + "fmt" + "sync" + "time" +) + +// SleepCT - Sleep constant time step crates a sleep based ticker +// designed maintain a sleep/tick interval +type SleepCT struct { + sync.Mutex + d time.Duration // duration + t time.Time // last time target +} + +func (s *SleepCT) SleepNextTarget() { + s.Lock() + + now := time.Now() + + var last time.Time + if s.t.IsZero() { + fmt.Println("SleepCT reset") + last = now.Add(-s.d) + } else { + last = s.t + } + + // Next Target + s.t = last.Add(s.d) + + d := s.t.Sub(now) + + time.Sleep(d) + + // delta := now.Sub(s.t) + // fmt.Println("delta", delta, d, time.Since(s.t)) + + s.Unlock() +} diff --git a/timing_test.go b/timing_test.go new file mode 100644 index 0000000..8592d90 --- /dev/null +++ b/timing_test.go @@ -0,0 +1,169 @@ +package main + +import ( + "fmt" + "math" + "math/rand" + "sort" + "sync" + "testing" + "time" + + "github.com/stieneee/tickerct" +) + +const testCount int64 = 10000 +const maxSleepInterval time.Duration = 15 * time.Millisecond +const tickerInterval time.Duration = 10 * time.Millisecond +const testDuration time.Duration = time.Duration(testCount * 10 * int64(time.Millisecond)) + +func testTickerBaseCase(wg *sync.WaitGroup) { + wg.Add(1) + go func(interval time.Duration) { + now := time.Now() + start := now + // start the ticker + t := time.NewTicker(interval) + var i int64 + for i = 0; i < testCount; i++ { + now = <-t.C + // fmt.Println(now) + } + t.Stop() + fmt.Println("Ticker (unloaded) after", testDuration, "drifts", time.Since(start)-testDuration) + wg.Done() + }(tickerInterval) +} + +func TestTickerBaseCase(t *testing.T) { + wg := sync.WaitGroup{} + + testTickerBaseCase(&wg) + + wg.Wait() +} + +func testTickerLoaded(wg *sync.WaitGroup) { + wg.Add(1) + go func(interval time.Duration) { + now := time.Now() + start := now + // start the ticker + t := time.NewTicker(interval) + var i int64 + for i = 0; i < testCount; i++ { + if i+1 < testCount { + time.Sleep(time.Duration(float64(maxSleepInterval) * rand.Float64())) + } + now = <-t.C + // fmt.Println(now) + } + t.Stop() + fmt.Println("Ticker (loaded) after", testDuration, "drifts", time.Since(start)-testDuration) + wg.Done() + }(tickerInterval) +} + +func TestTicker(t *testing.T) { + wg := sync.WaitGroup{} + + testTickerLoaded(&wg) + + wg.Wait() +} + +func testTickerCT(wg *sync.WaitGroup) { + wg.Add(1) + go func(interval time.Duration) { + now := time.Now() + start := now + // start the ticker + t := tickerct.NewTickerCT(interval) + var i int64 + for i = 0; i < testCount; i++ { + if i+1 < testCount { + time.Sleep(time.Duration(float64(maxSleepInterval) * rand.Float64())) + } + now = <-t.C + // fmt.Println(now) + } + t.Stop() + fmt.Println("TickerCT (loaded) after", testDuration, "drifts", time.Since(start)-testDuration) + wg.Done() + }(tickerInterval) +} + +func TestTickerCT(t *testing.T) { + wg := sync.WaitGroup{} + + testTickerCT(&wg) + + wg.Wait() +} + +func testSleepCT(wg *sync.WaitGroup) { + wg.Add(1) + go func(interval time.Duration) { + now := time.Now() + start := now + // start the ticker + s := SleepCT{ + d: interval, + t: time.Now(), + } + var i int64 + for i = 0; i < testCount; i++ { + if i+1 < testCount { + time.Sleep(time.Duration(float64(maxSleepInterval) * rand.Float64())) + } + s.SleepNextTarget() + } + fmt.Println("SleepCT (loaded) after", testDuration, "drifts", time.Since(start)-testDuration) + wg.Done() + }(tickerInterval) +} + +func TestSleepCT(t *testing.T) { + wg := sync.WaitGroup{} + + testSleepCT(&wg) + + wg.Wait() +} + +func TestIdleJitter(t *testing.T) { + wg := sync.WaitGroup{} + + const testSize = 100000 + const sleepTarget = time.Millisecond + + res := make([]time.Duration, testSize) + + for i := 0; i < testSize; i++ { + start := time.Now() + target := start.Add(sleepTarget) + + time.Sleep(sleepTarget) + + res[i] = time.Since(target) + } + + sort.Slice(res, func(i, j int) bool { + return res[i] < res[j] + }) + + var total float64 = 0 + for i := 0; i < testSize; i++ { + total += float64(res[i]) + } + avg := time.Duration(total / testSize) + + nineFive := int64(math.Round(testSize * 0.95)) + nineNine := int64(math.Round(testSize * 0.99)) + nineNineNine := int64(math.Round(testSize * 0.999)) + + fmt.Println("IdleJitter test", testSize, sleepTarget) + fmt.Println("IdleJitter results min/avg/95/99/99.9/max", res[0], avg, res[nineFive], res[nineNine], res[nineNineNine], res[testSize-1]) + + wg.Wait() +}