Restructure protobufs and use them everywhere

packages/relay/internal/shared/participant.go

@@ -2,43 +2,59 @@ package shared
 
 import (
 	"fmt"
+	"log/slog"
 	"relay/internal/common"
 	"relay/internal/connections"
 
+	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/oklog/ulid/v2"
+	"github.com/pion/rtp"
 	"github.com/pion/webrtc/v4"
 )
 
 type Participant struct {
 	ID             ulid.ULID
+	SessionID      string  // Track session for reconnection
+	PeerID         peer.ID // libp2p peer ID
 	PeerConnection *webrtc.PeerConnection
 	DataChannel    *connections.NestriDataChannel
+
+	// Per-viewer tracks and channels
+	VideoTrack *webrtc.TrackLocalStaticRTP
+	AudioTrack *webrtc.TrackLocalStaticRTP
+	VideoChan  chan *rtp.Packet
+	AudioChan  chan *rtp.Packet
 }
 
-func NewParticipant() (*Participant, error) {
+func NewParticipant(sessionID string, peerID peer.ID) (*Participant, error) {
 	id, err := common.NewULID()
 	if err != nil {
 		return nil, fmt.Errorf("failed to create ULID for Participant: %w", err)
 	}
 	return &Participant{
-		ID: id,
+		ID:        id,
+		SessionID: sessionID,
+		PeerID:    peerID,
+		VideoChan: make(chan *rtp.Packet, 500),
+		AudioChan: make(chan *rtp.Packet, 100),
 	}, nil
 }
 
-func (p *Participant) addTrack(trackLocal *webrtc.TrackLocalStaticRTP) error {
-	rtpSender, err := p.PeerConnection.AddTrack(trackLocal)
-	if err != nil {
-		return err
+// Close cleans up participant resources
+func (p *Participant) Close() {
+	if p.VideoChan != nil {
+		close(p.VideoChan)
+		p.VideoChan = nil
 	}
-
-	go func() {
-		rtcpBuffer := make([]byte, 1400)
-		for {
-			if _, _, rtcpErr := rtpSender.Read(rtcpBuffer); rtcpErr != nil {
-				break
-			}
+	if p.AudioChan != nil {
+		close(p.AudioChan)
+		p.AudioChan = nil
+	}
+	if p.PeerConnection != nil {
+		err := p.PeerConnection.Close()
+		if err != nil {
+			slog.Error("Failed to close Participant PeerConnection", err)
 		}
-	}()
-
-	return nil
+		p.PeerConnection = nil
+	}
 }

packages/relay/internal/shared/room.go

@@ -4,9 +4,11 @@ import (
 	"log/slog"
 	"relay/internal/common"
 	"relay/internal/connections"
+	"time"
 
 	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/oklog/ulid/v2"
+	"github.com/pion/rtp"
 	"github.com/pion/webrtc/v4"
 )
 
@@ -23,17 +25,31 @@ type Room struct {
 	VideoTrack     *webrtc.TrackLocalStaticRTP
 	DataChannel    *connections.NestriDataChannel
 	Participants   *common.SafeMap[ulid.ULID, *Participant]
+
+	// Broadcast queues (unbuffered, fan-out happens async)
+	videoBroadcastChan chan *rtp.Packet
+	audioBroadcastChan chan *rtp.Packet
+	broadcastStop      chan struct{}
 }
 
 func NewRoom(name string, roomID ulid.ULID, ownerID peer.ID) *Room {
-	return &Room{
+	r := &Room{
 		RoomInfo: RoomInfo{
 			ID:      roomID,
 			Name:    name,
 			OwnerID: ownerID,
 		},
-		Participants: common.NewSafeMap[ulid.ULID, *Participant](),
+		Participants:       common.NewSafeMap[ulid.ULID, *Participant](),
+		videoBroadcastChan: make(chan *rtp.Packet, 1000), // Large buffer for incoming packets
+		audioBroadcastChan: make(chan *rtp.Packet, 500),
+		broadcastStop:      make(chan struct{}),
 	}
+
+	// Start async broadcasters
+	go r.videoBroadcaster()
+	go r.audioBroadcaster()
+
+	return r
 }
 
 // AddParticipant adds a Participant to a Room
@@ -42,8 +58,8 @@ func (r *Room) AddParticipant(participant *Participant) {
 	r.Participants.Set(participant.ID, participant)
 }
 
-// Removes a Participant from a Room by participant's ID
-func (r *Room) removeParticipantByID(pID ulid.ULID) {
+// RemoveParticipantByID removes a Participant from a Room by participant's ID
+func (r *Room) RemoveParticipantByID(pID ulid.ULID) {
 	if _, ok := r.Participants.Get(pID); ok {
 		r.Participants.Delete(pID)
 	}
@@ -64,3 +80,92 @@ func (r *Room) SetTrack(trackType webrtc.RTPCodecType, track *webrtc.TrackLocalS
 		slog.Warn("Unknown track type", "room", r.Name, "trackType", trackType)
 	}
 }
+
+// BroadcastPacket enqueues packet for async broadcast (non-blocking)
+func (r *Room) BroadcastPacket(kind webrtc.RTPCodecType, pkt *rtp.Packet) {
+	start := time.Now()
+	if kind == webrtc.RTPCodecTypeVideo {
+		select {
+		case r.videoBroadcastChan <- pkt:
+			duration := time.Since(start)
+			if duration > 10*time.Millisecond {
+				slog.Warn("Slow video broadcast enqueue", "duration", duration, "room", r.Name)
+			}
+		default:
+			// Broadcast queue full - system overload, drop packet globally
+			slog.Warn("Video broadcast queue full, dropping packet", "room", r.Name)
+		}
+	} else {
+		select {
+		case r.audioBroadcastChan <- pkt:
+			duration := time.Since(start)
+			if duration > 10*time.Millisecond {
+				slog.Warn("Slow audio broadcast enqueue", "duration", duration, "room", r.Name)
+			}
+		default:
+			slog.Warn("Audio broadcast queue full, dropping packet", "room", r.Name)
+		}
+	}
+}
+
+// Close stops the broadcasters
+func (r *Room) Close() {
+	close(r.broadcastStop)
+	close(r.videoBroadcastChan)
+	close(r.audioBroadcastChan)
+}
+
+// videoBroadcaster runs async fan-out for video packets
+func (r *Room) videoBroadcaster() {
+	for {
+		select {
+		case pkt := <-r.videoBroadcastChan:
+			// Fan out to all participants without blocking
+			r.Participants.Range(func(_ ulid.ULID, participant *Participant) bool {
+				if participant.VideoChan != nil {
+					// Clone packet for each participant to avoid shared pointer issues
+					clonedPkt := pkt.Clone()
+					select {
+					case participant.VideoChan <- clonedPkt:
+						// Sent
+					default:
+						// Participant slow, drop packet
+						slog.Debug("Dropped video packet for slow participant",
+							"room", r.Name,
+							"participant", participant.ID)
+					}
+				}
+				return true
+			})
+		case <-r.broadcastStop:
+			return
+		}
+	}
+}
+
+// audioBroadcaster runs async fan-out for audio packets
+func (r *Room) audioBroadcaster() {
+	for {
+		select {
+		case pkt := <-r.audioBroadcastChan:
+			r.Participants.Range(func(_ ulid.ULID, participant *Participant) bool {
+				if participant.AudioChan != nil {
+					// Clone packet for each participant to avoid shared pointer issues
+					clonedPkt := pkt.Clone()
+					select {
+					case participant.AudioChan <- clonedPkt:
+						// Sent
+					default:
+						// Participant slow, drop packet
+						slog.Debug("Dropped audio packet for slow participant",
+							"room", r.Name,
+							"participant", participant.ID)
+					}
+				}
+				return true
+			})
+		case <-r.broadcastStop:
+			return
+		}
+	}
+}