AAAAAAAAAAAAAAAAAAA

main.go

@@ -14,20 +14,14 @@ var upgrader = websocket.Upgrader{
 var room = NewRoom()
 
 func wsHandler(w http.ResponseWriter, r *http.Request) {
-	conn, err := upgrader.Upgrade(w, r, nil)
-	if err != nil {
-		return
-	}
-
-	peer := NewPeer(conn, room)
+	ws, _ := upgrader.Upgrade(w, r, nil)
+	peer := NewPeer(ws, room)
 	room.AddPeer(peer)
-
 	go peer.ReadLoop()
 }
 
 func main() {
 	http.HandleFunc("/ws", wsHandler)
-
 	log.Println("SFU listening on :8080")
 	log.Fatal(http.ListenAndServe(":8080", nil))
 }

peer.go

@@ -10,93 +10,67 @@ import (
 
 type Signal struct {
 	Type string          `json:"type"`
-	Data json.RawMessage `json:"data"`
+	Data json.RawMessage `json:"data,omitempty"`
 }
 
 type Peer struct {
 	ID   string
-	Conn *websocket.Conn
+	WS   *websocket.Conn
 	PC   *webrtc.PeerConnection
 	Room *Room
 }
 
-func NewPeer(conn *websocket.Conn, room *Room) *Peer {
-	pc, err := webrtc.NewPeerConnection(webrtc.Configuration{
+func NewPeer(ws *websocket.Conn, room *Room) *Peer {
+	pc, _ := webrtc.NewPeerConnection(webrtc.Configuration{
 		ICEServers: []webrtc.ICEServer{
 			{URLs: []string{"stun:stun.l.google.com:19302"}},
 		},
 	})
-	if err != nil {
-		panic(err)
-	}
 
-	// 🔥 ОБЯЗАТЕЛЬНО для SFU
-	_, _ = pc.AddTransceiverFromKind(
-		webrtc.RTPCodecTypeAudio,
-		webrtc.RTPTransceiverInit{
-			Direction: webrtc.RTPTransceiverDirectionSendrecv,
-		},
-	)
-
-	_, _ = pc.AddTransceiverFromKind(
-		webrtc.RTPCodecTypeVideo,
-		webrtc.RTPTransceiverInit{
-			Direction: webrtc.RTPTransceiverDirectionSendrecv,
-		},
-	)
+	// ОБЯЗАТЕЛЬНО для SFU
+	pc.AddTransceiverFromKind(webrtc.RTPCodecTypeAudio)
+	pc.AddTransceiverFromKind(webrtc.RTPCodecTypeVideo)
 
 	p := &Peer{
 		ID:   uuid.NewString(),
-		Conn: conn,
+		WS:   ws,
 		PC:   pc,
 		Room: room,
 	}
 
 	pc.OnICECandidate(func(c *webrtc.ICECandidate) {
-		if c == nil {
-			return
+		if c != nil {
+			b, _ := json.Marshal(c.ToJSON())
+			p.Send("ice", b)
 		}
-		data, _ := json.Marshal(c.ToJSON())
-		p.Send("ice", data)
 	})
 
 	pc.OnTrack(func(remote *webrtc.TrackRemote, _ *webrtc.RTPReceiver) {
-		local := NewTrack(remote)
-
-		// 🔥 регистрируем трек в комнате
-		p.Room.AddTrack(p, local)
+		track := NewTrack(remote)
+		p.Room.AddTrack(p, track)
 
 		for {
 			pkt, _, err := remote.ReadRTP()
 			if err != nil {
 				return
 			}
-			local.Write(pkt)
+			track.Write(pkt)
 		}
 	})
 
 	return p
 }
 
-func (p *Peer) AddTrack(track *Track) {
-	_, err := p.PC.AddTrack(track.Local)
-	if err != nil {
-		return
-	}
-
-	p.Send("renegotiate", nil)
-}
-
 func (p *Peer) ReadLoop() {
 	defer func() {
-		p.Conn.Close()
 		p.Room.RemovePeer(p.ID)
 		p.PC.Close()
+		p.WS.Close()
 	}()
 
 	for {
 		var msg Signal
-		if err := p.Conn.ReadJSON(&msg); err != nil {
+		if err := p.WS.ReadJSON(&msg); err != nil {
 			return
 		}
 
@@ -104,13 +78,13 @@ func (p *Peer) ReadLoop() {
 		case "offer":
 			var offer webrtc.SessionDescription
 			json.Unmarshal(msg.Data, &offer)
-
 			p.PC.SetRemoteDescription(offer)
+
 			answer, _ := p.PC.CreateAnswer(nil)
 			p.PC.SetLocalDescription(answer)
 
-			data, _ := json.Marshal(answer)
-			p.Send("answer", data)
+			b, _ := json.Marshal(answer)
+			p.Send("answer", b)
 
 		case "ice":
 			var c webrtc.ICECandidateInit
@@ -120,6 +94,11 @@ func (p *Peer) ReadLoop() {
 	}
 }
 
-func (p *Peer) Send(t string, data []byte) {
-	p.Conn.WriteJSON(Signal{Type: t, Data: data})
+func (p *Peer) AddTrack(t *Track) {
+	p.PC.AddTrack(t.Local)
+	p.Send("renegotiate", nil)
+}
+
+func (p *Peer) Send(t string, data []byte) {
+	p.WS.WriteJSON(Signal{Type: t, Data: data})
 }

room.go

@@ -11,7 +11,6 @@ type Room struct {
 func NewRoom() *Room {
 	return &Room{
 		peers: make(map[string]*Peer),
-		tracks: make([]*Track, 0),
 	}
 }
 
@@ -20,10 +19,8 @@ func (r *Room) AddPeer(p *Peer) {
 	defer r.mu.Unlock()
 
 	r.peers[p.ID] = p
-
-	// 🔥 ВАЖНО: отдать новому peer ВСЕ существующие треки
-	for _, track := range r.tracks {
-		p.AddTrack(track)
+	for _, t := range r.tracks {
+		p.AddTrack(t)
 	}
 }
 
@@ -33,17 +30,14 @@ func (r *Room) RemovePeer(id string) {
 	delete(r.peers, id)
 }
 
-func (r *Room) AddTrack(from *Peer, track *Track) {
+func (r *Room) AddTrack(from *Peer, t *Track) {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 
-	// сохраняем трек
-	r.tracks = append(r.tracks, track)
-
-	// форвардим всем, кроме источника
-	for _, peer := range r.peers {
-		if peer.ID != from.ID {
-			peer.AddTrack(track)
+	r.tracks = append(r.tracks, t)
+	for _, p := range r.peers {
+		if p.ID != from.ID {
+			p.AddTrack(t)
 		}
 	}
 }