mirror of https://github.com/jetkvm/kvm.git
374 lines
8.7 KiB
Go
374 lines
8.7 KiB
Go
package kvm
|
|
|
|
import (
|
|
"io"
|
|
"sync"
|
|
"sync/atomic"
|
|
|
|
"github.com/jetkvm/kvm/internal/audio"
|
|
"github.com/jetkvm/kvm/internal/logging"
|
|
"github.com/pion/webrtc/v4"
|
|
"github.com/rs/zerolog"
|
|
)
|
|
|
|
var (
|
|
audioMutex sync.Mutex
|
|
setAudioTrackMutex sync.Mutex // Prevents concurrent setAudioTrack() calls
|
|
inputSourceMutex sync.Mutex // Serializes Connect() and WriteMessage() calls to input source
|
|
outputSource audio.AudioSource
|
|
inputSource atomic.Pointer[audio.AudioSource]
|
|
outputRelay *audio.OutputRelay
|
|
inputRelay *audio.InputRelay
|
|
audioInitialized bool
|
|
activeConnections atomic.Int32
|
|
audioLogger zerolog.Logger
|
|
currentAudioTrack *webrtc.TrackLocalStaticSample
|
|
currentInputTrack atomic.Pointer[string]
|
|
audioOutputEnabled atomic.Bool
|
|
audioInputEnabled atomic.Bool
|
|
)
|
|
|
|
func initAudio() {
|
|
audioLogger = logging.GetDefaultLogger().With().Str("component", "audio-manager").Logger()
|
|
|
|
ensureConfigLoaded()
|
|
audioOutputEnabled.Store(config.AudioOutputEnabled)
|
|
audioInputEnabled.Store(true)
|
|
|
|
audioLogger.Debug().Msg("Audio subsystem initialized")
|
|
audioInitialized = true
|
|
}
|
|
|
|
func getAudioConfig() audio.AudioConfig {
|
|
ensureConfigLoaded()
|
|
cfg := audio.DefaultAudioConfig()
|
|
if config.AudioBitrate >= 64 && config.AudioBitrate <= 256 {
|
|
cfg.Bitrate = uint16(config.AudioBitrate)
|
|
}
|
|
if config.AudioComplexity >= 0 && config.AudioComplexity <= 10 {
|
|
cfg.Complexity = uint8(config.AudioComplexity)
|
|
}
|
|
cfg.DTXEnabled = config.AudioDTXEnabled
|
|
cfg.FECEnabled = config.AudioFECEnabled
|
|
if config.AudioBufferPeriods >= 2 && config.AudioBufferPeriods <= 24 {
|
|
cfg.BufferPeriods = uint8(config.AudioBufferPeriods)
|
|
}
|
|
if config.AudioSampleRate == 32000 || config.AudioSampleRate == 44100 || config.AudioSampleRate == 48000 || config.AudioSampleRate == 96000 {
|
|
cfg.SampleRate = uint32(config.AudioSampleRate)
|
|
}
|
|
if config.AudioPacketLossPerc >= 0 && config.AudioPacketLossPerc <= 100 {
|
|
cfg.PacketLossPerc = uint8(config.AudioPacketLossPerc)
|
|
}
|
|
return cfg
|
|
}
|
|
|
|
func startAudio() error {
|
|
audioMutex.Lock()
|
|
defer audioMutex.Unlock()
|
|
|
|
if !audioInitialized {
|
|
audioLogger.Warn().Msg("Audio not initialized, skipping start")
|
|
return nil
|
|
}
|
|
|
|
if outputSource == nil && audioOutputEnabled.Load() && currentAudioTrack != nil {
|
|
ensureConfigLoaded()
|
|
alsaDevice := "hw:1,0"
|
|
if config.AudioOutputSource == "hdmi" {
|
|
alsaDevice = "hw:0,0"
|
|
}
|
|
|
|
source := audio.NewCgoOutputSource(alsaDevice)
|
|
source.SetConfig(getAudioConfig())
|
|
outputSource = source
|
|
outputRelay = audio.NewOutputRelay(outputSource, currentAudioTrack)
|
|
if err := outputRelay.Start(); err != nil {
|
|
audioLogger.Error().Err(err).Msg("Failed to start audio output relay")
|
|
}
|
|
}
|
|
|
|
ensureConfigLoaded()
|
|
if inputSource.Load() == nil && audioInputEnabled.Load() && config.UsbDevices != nil && config.UsbDevices.Audio {
|
|
alsaPlaybackDevice := "hw:1,0"
|
|
|
|
source := audio.NewCgoInputSource(alsaPlaybackDevice)
|
|
source.SetConfig(getAudioConfig())
|
|
var audioSource audio.AudioSource = source
|
|
inputSource.Store(&audioSource)
|
|
|
|
inputRelay = audio.NewInputRelay(audioSource)
|
|
if err := inputRelay.Start(); err != nil {
|
|
audioLogger.Error().Err(err).Msg("Failed to start input relay")
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func stopOutputAudio() {
|
|
audioMutex.Lock()
|
|
outRelay := outputRelay
|
|
outSource := outputSource
|
|
outputRelay = nil
|
|
outputSource = nil
|
|
audioMutex.Unlock()
|
|
|
|
if outRelay != nil {
|
|
outRelay.Stop()
|
|
}
|
|
if outSource != nil {
|
|
outSource.Disconnect()
|
|
}
|
|
}
|
|
|
|
func stopInputAudio() {
|
|
audioMutex.Lock()
|
|
inRelay := inputRelay
|
|
inputRelay = nil
|
|
audioMutex.Unlock()
|
|
|
|
inSource := inputSource.Swap(nil)
|
|
|
|
if inRelay != nil {
|
|
inRelay.Stop()
|
|
}
|
|
if inSource != nil {
|
|
(*inSource).Disconnect()
|
|
}
|
|
}
|
|
|
|
func stopAudio() {
|
|
stopOutputAudio()
|
|
stopInputAudio()
|
|
}
|
|
|
|
func onWebRTCConnect() {
|
|
count := activeConnections.Add(1)
|
|
if count == 1 {
|
|
if err := startAudio(); err != nil {
|
|
audioLogger.Error().Err(err).Msg("Failed to start audio")
|
|
}
|
|
}
|
|
}
|
|
|
|
func onWebRTCDisconnect() {
|
|
count := activeConnections.Add(-1)
|
|
if count == 0 {
|
|
// Stop audio immediately to release HDMI audio device which shares hardware with video device
|
|
stopAudio()
|
|
}
|
|
}
|
|
|
|
func setAudioTrack(audioTrack *webrtc.TrackLocalStaticSample) {
|
|
setAudioTrackMutex.Lock()
|
|
defer setAudioTrackMutex.Unlock()
|
|
|
|
// Capture old resources and update state in single critical section
|
|
audioMutex.Lock()
|
|
currentAudioTrack = audioTrack
|
|
oldRelay := outputRelay
|
|
oldSource := outputSource
|
|
outputRelay = nil
|
|
outputSource = nil
|
|
|
|
// Prepare new relay if needed
|
|
var newRelay *audio.OutputRelay
|
|
var newSource audio.AudioSource
|
|
if currentAudioTrack != nil && audioOutputEnabled.Load() {
|
|
ensureConfigLoaded()
|
|
alsaDevice := "hw:1,0"
|
|
if config.AudioOutputSource == "hdmi" {
|
|
alsaDevice = "hw:0,0"
|
|
}
|
|
newSource = audio.NewCgoOutputSource(alsaDevice)
|
|
newSource.SetConfig(getAudioConfig())
|
|
newRelay = audio.NewOutputRelay(newSource, currentAudioTrack)
|
|
outputSource = newSource
|
|
outputRelay = newRelay
|
|
}
|
|
audioMutex.Unlock()
|
|
|
|
// Stop old resources outside mutex to avoid blocking during CGO calls
|
|
if oldRelay != nil {
|
|
oldRelay.Stop()
|
|
}
|
|
if oldSource != nil {
|
|
oldSource.Disconnect()
|
|
}
|
|
|
|
// Start new relay outside mutex
|
|
if newRelay != nil {
|
|
if err := newRelay.Start(); err != nil {
|
|
audioLogger.Error().Err(err).Msg("Failed to start output relay")
|
|
}
|
|
}
|
|
}
|
|
|
|
func setPendingInputTrack(track *webrtc.TrackRemote) {
|
|
trackID := track.ID()
|
|
currentInputTrack.Store(&trackID)
|
|
go handleInputTrackForSession(track)
|
|
}
|
|
|
|
func SetAudioOutputEnabled(enabled bool) error {
|
|
if audioOutputEnabled.Swap(enabled) == enabled {
|
|
return nil
|
|
}
|
|
|
|
if enabled {
|
|
if activeConnections.Load() > 0 {
|
|
return startAudio()
|
|
}
|
|
} else {
|
|
stopOutputAudio()
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func SetAudioInputEnabled(enabled bool) error {
|
|
if audioInputEnabled.Swap(enabled) == enabled {
|
|
return nil
|
|
}
|
|
|
|
if enabled {
|
|
if activeConnections.Load() > 0 {
|
|
return startAudio()
|
|
}
|
|
} else {
|
|
stopInputAudio()
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func SetAudioOutputSource(source string) error {
|
|
if source != "hdmi" && source != "usb" {
|
|
return nil
|
|
}
|
|
|
|
ensureConfigLoaded()
|
|
if config.AudioOutputSource == source {
|
|
return nil
|
|
}
|
|
|
|
config.AudioOutputSource = source
|
|
|
|
stopOutputAudio()
|
|
|
|
if audioOutputEnabled.Load() && activeConnections.Load() > 0 && currentAudioTrack != nil {
|
|
alsaDevice := "hw:1,0"
|
|
if source == "hdmi" {
|
|
alsaDevice = "hw:0,0"
|
|
}
|
|
|
|
newSource := audio.NewCgoOutputSource(alsaDevice)
|
|
newSource.SetConfig(getAudioConfig())
|
|
newRelay := audio.NewOutputRelay(newSource, currentAudioTrack)
|
|
|
|
audioMutex.Lock()
|
|
outputSource = newSource
|
|
outputRelay = newRelay
|
|
audioMutex.Unlock()
|
|
|
|
if err := newRelay.Start(); err != nil {
|
|
audioLogger.Error().Err(err).Str("source", source).Msg("Failed to start audio relay with new source")
|
|
}
|
|
}
|
|
|
|
return SaveConfig()
|
|
}
|
|
|
|
func RestartAudioOutput() {
|
|
audioMutex.Lock()
|
|
hasActiveOutput := outputSource != nil && currentAudioTrack != nil && audioOutputEnabled.Load()
|
|
audioMutex.Unlock()
|
|
|
|
if !hasActiveOutput {
|
|
return
|
|
}
|
|
|
|
audioLogger.Info().Msg("Restarting audio output")
|
|
|
|
stopOutputAudio()
|
|
|
|
ensureConfigLoaded()
|
|
alsaDevice := "hw:1,0"
|
|
if config.AudioOutputSource == "hdmi" {
|
|
alsaDevice = "hw:0,0"
|
|
}
|
|
|
|
newSource := audio.NewCgoOutputSource(alsaDevice)
|
|
newSource.SetConfig(getAudioConfig())
|
|
newRelay := audio.NewOutputRelay(newSource, currentAudioTrack)
|
|
|
|
audioMutex.Lock()
|
|
outputSource = newSource
|
|
outputRelay = newRelay
|
|
audioMutex.Unlock()
|
|
|
|
if err := newRelay.Start(); err != nil {
|
|
audioLogger.Error().Err(err).Msg("Failed to restart audio output")
|
|
}
|
|
}
|
|
|
|
func handleInputTrackForSession(track *webrtc.TrackRemote) {
|
|
myTrackID := track.ID()
|
|
|
|
audioLogger.Debug().
|
|
Str("codec", track.Codec().MimeType).
|
|
Str("track_id", myTrackID).
|
|
Msg("starting input track handler")
|
|
|
|
for {
|
|
currentTrackID := currentInputTrack.Load()
|
|
if currentTrackID != nil && *currentTrackID != myTrackID {
|
|
audioLogger.Debug().
|
|
Str("my_track_id", myTrackID).
|
|
Str("current_track_id", *currentTrackID).
|
|
Msg("input track handler exiting - superseded")
|
|
return
|
|
}
|
|
|
|
rtpPacket, _, err := track.ReadRTP()
|
|
if err != nil {
|
|
if err == io.EOF {
|
|
audioLogger.Debug().Str("track_id", myTrackID).Msg("input track ended")
|
|
return
|
|
}
|
|
audioLogger.Warn().Err(err).Str("track_id", myTrackID).Msg("failed to read RTP packet")
|
|
continue
|
|
}
|
|
|
|
opusData := rtpPacket.Payload
|
|
if len(opusData) == 0 {
|
|
continue
|
|
}
|
|
|
|
if !audioInputEnabled.Load() {
|
|
continue
|
|
}
|
|
|
|
source := inputSource.Load()
|
|
if source == nil {
|
|
continue
|
|
}
|
|
|
|
inputSourceMutex.Lock()
|
|
|
|
if !(*source).IsConnected() {
|
|
if err := (*source).Connect(); err != nil {
|
|
inputSourceMutex.Unlock()
|
|
continue
|
|
}
|
|
}
|
|
|
|
if err := (*source).WriteMessage(0, opusData); err != nil {
|
|
audioLogger.Warn().Err(err).Msg("failed to write audio message")
|
|
(*source).Disconnect()
|
|
}
|
|
|
|
inputSourceMutex.Unlock()
|
|
}
|
|
}
|