140 lines
3.3 KiB
Go
140 lines
3.3 KiB
Go
package rtc
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"net"
|
|
"sync"
|
|
|
|
"github.com/google/uuid"
|
|
log "github.com/sirupsen/logrus"
|
|
|
|
"github.com/pion/webrtc/v4"
|
|
)
|
|
|
|
var rtc *RTC
|
|
|
|
func Get() *RTC {
|
|
return rtc
|
|
}
|
|
|
|
var ErrWebRTC = errors.New("webrtc")
|
|
var ErrWebRTCParam = func(format string, args ...any) error {
|
|
return fmt.Errorf("%w: "+format, args...)
|
|
}
|
|
var ErrPeerClosedConn = ErrWebRTCParam("peer closed conn")
|
|
|
|
type RTC struct {
|
|
peers map[string]*webrtc.PeerConnection
|
|
videoListener *net.UDPConn
|
|
audioListener *net.UDPConn
|
|
videoTrack *webrtc.TrackLocalStaticRTP
|
|
audioTrack *webrtc.TrackLocalStaticRTP
|
|
m sync.Mutex
|
|
}
|
|
|
|
func (r *RTC) AddPeer(p *webrtc.PeerConnection, offer webrtc.SessionDescription) (*webrtc.SessionDescription, error) {
|
|
peerID := uuid.New().String()
|
|
r.m.Lock()
|
|
r.peers[peerID] = p
|
|
r.m.Unlock()
|
|
|
|
p.OnConnectionStateChange(func(connState webrtc.PeerConnectionState) {
|
|
if connState == webrtc.PeerConnectionStateFailed || connState == webrtc.PeerConnectionStateClosed {
|
|
r.m.Lock()
|
|
defer r.m.Unlock()
|
|
delete(r.peers, peerID)
|
|
p.Close()
|
|
|
|
peers := make([]string, 0, len(r.peers))
|
|
for p := range r.peers {
|
|
peers = append(peers, p)
|
|
}
|
|
log.WithField("peers", peers).Infof("Peer %s disconnected and resources cleaned up.", peerID)
|
|
}
|
|
})
|
|
|
|
vSender, err := p.AddTrack(r.videoTrack)
|
|
if err != nil {
|
|
return nil, ErrWebRTCParam("failed to add video track: %v", err)
|
|
}
|
|
processRTCP(vSender)
|
|
aSender, err := p.AddTrack(r.audioTrack)
|
|
if err != nil {
|
|
return nil, ErrWebRTCParam("failed to add audio track: %v", err)
|
|
}
|
|
processRTCP(aSender)
|
|
|
|
if err := p.SetRemoteDescription(offer); err != nil {
|
|
return nil, ErrWebRTCParam("failed to set remote description: %v", err)
|
|
}
|
|
|
|
answer, err := p.CreateAnswer(nil)
|
|
if err != nil {
|
|
return nil, ErrWebRTCParam("failed to create answer: %v", err)
|
|
}
|
|
gatherComplete := webrtc.GatheringCompletePromise(p)
|
|
|
|
if err := p.SetLocalDescription(answer); err != nil {
|
|
return nil, ErrWebRTCParam("failed to set local description: %v", err)
|
|
}
|
|
<-gatherComplete
|
|
|
|
return p.LocalDescription(), nil
|
|
}
|
|
|
|
func (r *RTC) VideoListenerRead() {
|
|
listenerRead(r.videoListener, r.videoTrack)
|
|
}
|
|
|
|
func (r *RTC) AudioListenerRead() {
|
|
listenerRead(r.audioListener, r.audioTrack)
|
|
}
|
|
|
|
func (r *RTC) Close() error {
|
|
r.videoListener.Close()
|
|
r.audioListener.Close()
|
|
|
|
return nil
|
|
}
|
|
|
|
func NewPeer() (*webrtc.PeerConnection, error) {
|
|
peer, err := webrtc.NewPeerConnection(webrtc.Configuration{
|
|
ICEServers: []webrtc.ICEServer{
|
|
{
|
|
URLs: []string{"stun:stun.l.google.com:19302"},
|
|
},
|
|
},
|
|
})
|
|
if err == nil {
|
|
// Set the handler for ICE connection state
|
|
// This will notify you when the peer has connected/disconnected
|
|
peer.OnICEConnectionStateChange(func(connState webrtc.ICEConnectionState) {
|
|
log.Infof("Connection State has changed %s", connState.String())
|
|
|
|
if connState == webrtc.ICEConnectionStateFailed {
|
|
if closeErr := peer.Close(); closeErr != nil {
|
|
panic(closeErr)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
return peer, err
|
|
}
|
|
|
|
// Read incoming RTCP packets
|
|
// Before these packets are retuned they are processed by interceptors. For things
|
|
// like NACK this needs to be called.
|
|
func processRTCP(rtpSender *webrtc.RTPSender) {
|
|
go func() {
|
|
rtcpBuf := make([]byte, 1500)
|
|
|
|
for {
|
|
if _, _, rtcpErr := rtpSender.Read(rtcpBuf); rtcpErr != nil {
|
|
return
|
|
}
|
|
}
|
|
}()
|
|
}
|