474 lines
11 KiB
Go
474 lines
11 KiB
Go
package sfu
|
||
|
||
import (
|
||
"fmt"
|
||
"g365sfu/logger"
|
||
"io"
|
||
"strings"
|
||
"sync"
|
||
"time"
|
||
|
||
"github.com/pion/rtcp"
|
||
"github.com/pion/rtp"
|
||
"github.com/pion/webrtc/v4"
|
||
)
|
||
|
||
var (
|
||
pendingMu sync.Mutex
|
||
pendingCandidates = map[string][]webrtc.ICECandidateInit{} // key: roomID|peerID
|
||
|
||
renegMu sync.Map // key -> *sync.Mutex
|
||
renegPending sync.Map // key -> bool
|
||
)
|
||
|
||
const (
|
||
disconnectGracePeriod = 30 * time.Second
|
||
outboundPacketBuffer = 256
|
||
maxConsecutiveReadErrs = 25
|
||
maxConsecutiveWriteErrs = 50
|
||
packetDropLogEvery = 100
|
||
)
|
||
|
||
func peerKey(roomID, peerID string) string {
|
||
return roomID + "|" + peerID
|
||
}
|
||
|
||
func getRenegLock(roomID, peerID string) *sync.Mutex {
|
||
k := peerKey(roomID, peerID)
|
||
v, _ := renegMu.LoadOrStore(k, &sync.Mutex{})
|
||
return v.(*sync.Mutex)
|
||
}
|
||
|
||
func setRenegPending(roomID, peerID string, v bool) {
|
||
renegPending.Store(peerKey(roomID, peerID), v)
|
||
}
|
||
|
||
func popRenegPending(roomID, peerID string) bool {
|
||
k := peerKey(roomID, peerID)
|
||
v, ok := renegPending.Load(k)
|
||
if ok {
|
||
renegPending.Delete(k)
|
||
}
|
||
if !ok {
|
||
return false
|
||
}
|
||
b, _ := v.(bool)
|
||
return b
|
||
}
|
||
|
||
func extractICEUfrag(sdp string) string {
|
||
for _, line := range strings.Split(sdp, "\n") {
|
||
line = strings.TrimSpace(line)
|
||
if strings.HasPrefix(line, "a=ice-ufrag:") {
|
||
return strings.TrimPrefix(line, "a=ice-ufrag:")
|
||
}
|
||
}
|
||
return ""
|
||
}
|
||
|
||
func removeRoomTrack(roomID, trackID string) {
|
||
room, ok := GetRoom(roomID)
|
||
if !ok {
|
||
return
|
||
}
|
||
|
||
room.mu.Lock()
|
||
defer room.mu.Unlock()
|
||
|
||
out := room.Tracks[:0]
|
||
for _, t := range room.Tracks {
|
||
if t.TrackID != trackID {
|
||
out = append(out, t)
|
||
}
|
||
}
|
||
room.Tracks = out
|
||
}
|
||
|
||
func isPeerConnectionAlive(pc *webrtc.PeerConnection) bool {
|
||
state := pc.ConnectionState()
|
||
return state != webrtc.PeerConnectionStateClosed &&
|
||
state != webrtc.PeerConnectionStateFailed
|
||
}
|
||
|
||
// Вешается на каждый PeerConnection при JoinWithOffer.
|
||
// Автоматически вызывает LeaveRoom при обрыве соединения и очищает состояние ретрансляции.
|
||
func BindPeerLifecycle(roomID, peerID string, pc *webrtc.PeerConnection) {
|
||
var (
|
||
mu sync.Mutex
|
||
disconnecting bool
|
||
timer *time.Timer
|
||
leaveOnce sync.Once
|
||
)
|
||
|
||
room, exists := GetRoom(roomID)
|
||
if !exists {
|
||
logger.LogWarnMessage("BindPeerLifecycle: tried to bind non existing room " + roomID)
|
||
return
|
||
}
|
||
server := room.Server
|
||
|
||
cancelTimer := func() {
|
||
mu.Lock()
|
||
defer mu.Unlock()
|
||
|
||
if timer != nil {
|
||
timer.Stop()
|
||
timer = nil
|
||
}
|
||
disconnecting = false
|
||
}
|
||
|
||
leaveAndNotify := func(reason DisconnectReason) {
|
||
leaveOnce.Do(func() {
|
||
cancelTimer()
|
||
err := LeaveRoom(roomID, peerID)
|
||
if OnPeerDisconnected != nil && err == nil {
|
||
OnPeerDisconnected(roomID, peerID, server, reason)
|
||
}
|
||
})
|
||
}
|
||
|
||
startTimer := func() {
|
||
mu.Lock()
|
||
defer mu.Unlock()
|
||
|
||
if disconnecting {
|
||
return
|
||
}
|
||
|
||
disconnecting = true
|
||
timer = time.AfterFunc(disconnectGracePeriod, func() {
|
||
state := pc.ConnectionState()
|
||
if state == webrtc.PeerConnectionStateConnected {
|
||
mu.Lock()
|
||
disconnecting = false
|
||
mu.Unlock()
|
||
return
|
||
}
|
||
leaveAndNotify(DisconnectReasonFailed)
|
||
})
|
||
}
|
||
|
||
pc.OnICEConnectionStateChange(func(state webrtc.ICEConnectionState) {
|
||
switch state {
|
||
case webrtc.ICEConnectionStateConnected, webrtc.ICEConnectionStateCompleted:
|
||
cancelTimer()
|
||
case webrtc.ICEConnectionStateDisconnected:
|
||
startTimer()
|
||
case webrtc.ICEConnectionStateClosed:
|
||
leaveAndNotify(DisconnectReasonClosed)
|
||
case webrtc.ICEConnectionStateFailed:
|
||
leaveAndNotify(DisconnectReasonFailed)
|
||
}
|
||
})
|
||
|
||
pc.OnConnectionStateChange(func(state webrtc.PeerConnectionState) {
|
||
switch state {
|
||
case webrtc.PeerConnectionStateConnected:
|
||
cancelTimer()
|
||
case webrtc.PeerConnectionStateDisconnected:
|
||
startTimer()
|
||
case webrtc.PeerConnectionStateClosed:
|
||
leaveAndNotify(DisconnectReasonClosed)
|
||
case webrtc.PeerConnectionStateFailed:
|
||
leaveAndNotify(DisconnectReasonFailed)
|
||
}
|
||
})
|
||
}
|
||
|
||
// Вызывается при JoinWithOffer для ретрансляции RTP пакетов от издателя к другим участникам комнаты.
|
||
func SetupForwardingForPeer(roomID string, publisherPeerID string, publisherPC *webrtc.PeerConnection) {
|
||
publisherPC.OnTrack(func(remote *webrtc.TrackRemote, _ *webrtc.RTPReceiver) {
|
||
localTrackID := fmt.Sprintf("%s:%s:%s:%d",
|
||
publisherPeerID,
|
||
remote.Kind().String(),
|
||
remote.ID(),
|
||
remote.SSRC(),
|
||
)
|
||
|
||
localTrack, err := webrtc.NewTrackLocalStaticRTP(
|
||
remote.Codec().RTPCodecCapability,
|
||
localTrackID,
|
||
remote.StreamID(),
|
||
)
|
||
if err != nil {
|
||
logger.LogErrorMessage("SetupForwardingForPeer: NewTrackLocalStaticRTP error: " + err.Error())
|
||
return
|
||
}
|
||
defer removeRoomTrack(roomID, localTrack.ID())
|
||
|
||
room, ok := GetRoom(roomID)
|
||
if !ok {
|
||
return
|
||
}
|
||
|
||
room.mu.Lock()
|
||
room.Tracks = append(room.Tracks, RoomTrack{
|
||
TrackID: localTrack.ID(),
|
||
OwnerPeer: publisherPeerID,
|
||
Local: localTrack,
|
||
})
|
||
peers := make([]Peer, len(room.Peers))
|
||
copy(peers, room.Peers)
|
||
room.mu.Unlock()
|
||
|
||
for _, sub := range peers {
|
||
if sub.PeerID == publisherPeerID {
|
||
continue
|
||
}
|
||
|
||
if !isPeerConnectionAlive(sub.PeerConnection) {
|
||
continue
|
||
}
|
||
|
||
sender, err := sub.PeerConnection.AddTrack(localTrack)
|
||
if err != nil {
|
||
logger.LogWarnMessage("SetupForwardingForPeer: AddTrack error: " + sub.PeerID + " " + err.Error())
|
||
continue
|
||
}
|
||
|
||
senderCopy := sender
|
||
go func() {
|
||
buf := make([]byte, 1500)
|
||
for {
|
||
if _, _, e := senderCopy.Read(buf); e != nil {
|
||
return
|
||
}
|
||
}
|
||
}()
|
||
|
||
subID := sub.PeerID
|
||
subPC := sub.PeerConnection
|
||
|
||
go func() {
|
||
if err := renegotiatePeer(roomID, subID, subPC); err != nil {
|
||
logger.LogWarnMessage("SetupForwardingForPeer: renegotiatePeer error: " + subID + " " + err.Error())
|
||
}
|
||
}()
|
||
}
|
||
|
||
if remote.Kind() == webrtc.RTPCodecTypeVideo {
|
||
_ = publisherPC.WriteRTCP([]rtcp.Packet{
|
||
&rtcp.PictureLossIndication{MediaSSRC: uint32(remote.SSRC())},
|
||
})
|
||
}
|
||
|
||
// Отделяем чтение входящего RTP от записи в TrackLocal bounded-очередью.
|
||
// Если downstream начинает тормозить, пакеты дропаются из очереди,
|
||
// а не накапливают бесконечную задержку.
|
||
packetQueue := make(chan *rtp.Packet, outboundPacketBuffer)
|
||
writerDone := make(chan struct{})
|
||
defer close(packetQueue)
|
||
|
||
go func() {
|
||
defer close(writerDone)
|
||
|
||
consecutiveWriteErrs := 0
|
||
for pkt := range packetQueue {
|
||
if err := localTrack.WriteRTP(pkt); err != nil {
|
||
consecutiveWriteErrs++
|
||
if consecutiveWriteErrs == 1 || consecutiveWriteErrs%10 == 0 {
|
||
logger.LogWarnMessage(fmt.Sprintf(
|
||
"SetupForwardingForPeer: WriteRTP error publisher=%s track=%s count=%d err=%v",
|
||
publisherPeerID, localTrack.ID(), consecutiveWriteErrs, err,
|
||
))
|
||
}
|
||
if consecutiveWriteErrs >= maxConsecutiveWriteErrs {
|
||
logger.LogWarnMessage(fmt.Sprintf(
|
||
"SetupForwardingForPeer: too many WriteRTP errors publisher=%s track=%s",
|
||
publisherPeerID, localTrack.ID(),
|
||
))
|
||
return
|
||
}
|
||
continue
|
||
}
|
||
consecutiveWriteErrs = 0
|
||
}
|
||
}()
|
||
|
||
consecutiveReadErrs := 0
|
||
droppedPackets := 0
|
||
|
||
for {
|
||
pkt, _, err := remote.ReadRTP()
|
||
if err != nil {
|
||
if err == io.EOF {
|
||
return
|
||
}
|
||
|
||
consecutiveReadErrs++
|
||
if consecutiveReadErrs == 1 || consecutiveReadErrs%10 == 0 {
|
||
logger.LogWarnMessage(fmt.Sprintf(
|
||
"SetupForwardingForPeer: ReadRTP error publisher=%s track=%s count=%d err=%v",
|
||
publisherPeerID, localTrack.ID(), consecutiveReadErrs, err,
|
||
))
|
||
}
|
||
if consecutiveReadErrs >= maxConsecutiveReadErrs {
|
||
logger.LogWarnMessage(fmt.Sprintf(
|
||
"SetupForwardingForPeer: too many ReadRTP errors publisher=%s track=%s",
|
||
publisherPeerID, localTrack.ID(),
|
||
))
|
||
return
|
||
}
|
||
|
||
time.Sleep(10 * time.Millisecond)
|
||
continue
|
||
}
|
||
|
||
consecutiveReadErrs = 0
|
||
|
||
select {
|
||
case <-writerDone:
|
||
return
|
||
default:
|
||
}
|
||
|
||
select {
|
||
case <-writerDone:
|
||
return
|
||
case packetQueue <- pkt:
|
||
default:
|
||
droppedPackets++
|
||
if droppedPackets == 1 || droppedPackets%packetDropLogEvery == 0 {
|
||
logger.LogWarnMessage(fmt.Sprintf(
|
||
"SetupForwardingForPeer: packet queue overflow publisher=%s track=%s dropped=%d",
|
||
publisherPeerID, localTrack.ID(), droppedPackets,
|
||
))
|
||
}
|
||
}
|
||
}
|
||
})
|
||
}
|
||
|
||
func renegotiatePeer(roomID, peerID string, pc *webrtc.PeerConnection) error {
|
||
lock := getRenegLock(roomID, peerID)
|
||
lock.Lock()
|
||
defer lock.Unlock()
|
||
|
||
if !isPeerConnectionAlive(pc) {
|
||
return nil
|
||
}
|
||
|
||
if pc.SignalingState() != webrtc.SignalingStateStable {
|
||
setRenegPending(roomID, peerID, true)
|
||
return nil
|
||
}
|
||
|
||
offer, err := pc.CreateOffer(nil)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
gatherDone := webrtc.GatheringCompletePromise(pc)
|
||
if err = pc.SetLocalDescription(offer); err != nil {
|
||
return err
|
||
}
|
||
<-gatherDone
|
||
|
||
if OnServerOffer != nil && pc.LocalDescription() != nil {
|
||
OnServerOffer(roomID, peerID, *pc.LocalDescription())
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// Добавляет ICE-кандидата к пиру.
|
||
func AddICECandidate(roomID string, peerID string, candidate webrtc.ICECandidateInit) error {
|
||
room, exists := GetRoom(roomID)
|
||
if !exists {
|
||
return ErrRoomNotFound
|
||
}
|
||
|
||
room.mu.RLock()
|
||
var pc *webrtc.PeerConnection
|
||
for _, p := range room.Peers {
|
||
if p.PeerID == peerID {
|
||
pc = p.PeerConnection
|
||
break
|
||
}
|
||
}
|
||
room.mu.RUnlock()
|
||
|
||
if pc == nil {
|
||
return ErrPeerNotFound
|
||
}
|
||
|
||
rd := pc.RemoteDescription()
|
||
if rd == nil {
|
||
pendingMu.Lock()
|
||
k := peerKey(roomID, peerID)
|
||
pendingCandidates[k] = append(pendingCandidates[k], candidate)
|
||
pendingMu.Unlock()
|
||
return nil
|
||
}
|
||
|
||
if candidate.UsernameFragment != nil {
|
||
current := extractICEUfrag(rd.SDP)
|
||
if current != "" && *candidate.UsernameFragment != current {
|
||
return nil
|
||
}
|
||
}
|
||
|
||
err := pc.AddICECandidate(candidate)
|
||
if err != nil && strings.Contains(err.Error(), "doesn't match the current ufrags") {
|
||
return nil
|
||
}
|
||
return err
|
||
}
|
||
|
||
// Обрабатывает SDP answer от клиента при renegotiation.
|
||
func HandleClientAnswer(roomID string, peerID string, answer webrtc.SessionDescription) error {
|
||
if answer.Type != webrtc.SDPTypeAnswer {
|
||
return fmt.Errorf("invalid sdp type: %s", answer.Type.String())
|
||
}
|
||
|
||
room, exists := GetRoom(roomID)
|
||
if !exists {
|
||
return ErrRoomNotFound
|
||
}
|
||
|
||
room.mu.RLock()
|
||
var pc *webrtc.PeerConnection
|
||
for _, p := range room.Peers {
|
||
if p.PeerID == peerID {
|
||
pc = p.PeerConnection
|
||
break
|
||
}
|
||
}
|
||
room.mu.RUnlock()
|
||
|
||
if pc == nil {
|
||
return ErrPeerNotFound
|
||
}
|
||
|
||
if err := pc.SetRemoteDescription(answer); err != nil {
|
||
return err
|
||
}
|
||
|
||
k := peerKey(roomID, peerID)
|
||
pendingMu.Lock()
|
||
queue := pendingCandidates[k]
|
||
delete(pendingCandidates, k)
|
||
pendingMu.Unlock()
|
||
|
||
for _, c := range queue {
|
||
_ = AddICECandidate(roomID, peerID, c)
|
||
}
|
||
|
||
if popRenegPending(roomID, peerID) {
|
||
_ = renegotiatePeer(roomID, peerID, pc)
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
func cleanupForwardingState(roomID, peerID string) {
|
||
k := peerKey(roomID, peerID)
|
||
|
||
pendingMu.Lock()
|
||
delete(pendingCandidates, k)
|
||
pendingMu.Unlock()
|
||
|
||
renegPending.Delete(k)
|
||
renegMu.Delete(k)
|
||
}
|