gilles/go2rtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Big rewrite for WebRTC processing

Browse Source
This commit is contained in:
Alexey Khit
2023-02-25 17:10:45 +03:00
parent ad3c5440fe
commit 218eea6806
10 changed files with 625 additions and 253 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pkg/webrtc/client.go
+34
View File
@@ -0,0 +1,34 @@
package webrtc
import "github.com/pion/webrtc/v3"
func (c *Conn) CreateOffer() (string, error) {
init := webrtc.RTPTransceiverInit{Direction: webrtc.RTPTransceiverDirectionRecvonly}
_, _ = c.pc.AddTransceiverFromKind(webrtc.RTPCodecTypeVideo, init)
_, _ = c.pc.AddTransceiverFromKind(webrtc.RTPCodecTypeAudio, init)
desc, err := c.pc.CreateOffer(nil)
if err != nil {
return "", err
}
if err = c.pc.SetLocalDescription(desc); err != nil {
return "", err
}
return desc.SDP, nil
}
func (c *Conn) CreateCompleteOffer() (string, error) {
if _, err := c.CreateOffer(); err != nil {
return "", err
}
<-webrtc.GatheringCompletePromise(c.pc)
return c.pc.LocalDescription().SDP, nil
}
func (c *Conn) SetAnswer(answer string) (err error) {
desc := webrtc.SessionDescription{SDP: answer, Type: webrtc.SDPTypeAnswer}
return c.pc.SetRemoteDescription(desc)
}
pkg/webrtc/conn.go
+148
View File
@@ -0,0 +1,148 @@
package webrtc
import (
"github.com/AlexxIT/go2rtc/pkg/streamer"
"github.com/pion/webrtc/v3"
)
type Conn struct {
streamer.Element
UserAgent string
pc *webrtc.PeerConnection
medias []*streamer.Media
tracks []*streamer.Track
receive int
send int
offer string
}
func NewConn(pc *webrtc.PeerConnection) *Conn {
c := &Conn{pc: pc}
pc.OnICECandidate(func(candidate *webrtc.ICECandidate) {
c.Fire(candidate)
})
pc.OnDataChannel(func(channel *webrtc.DataChannel) {
c.Fire(channel)
})
pc.OnTrack(func(remote *webrtc.TrackRemote, _ *webrtc.RTPReceiver) {
track := c.getTrack(remote)
if track == nil {
println("ERROR: webrtc: can't find track")
return
}
for {
packet, _, err := remote.ReadRTP()
if err != nil {
return
}
if len(packet.Payload) == 0 {
continue
}
c.receive += len(packet.Payload)
_ = track.WriteRTP(packet)
}
})
// OK connection:
// 15:01:46 ICE connection state changed: checking
// 15:01:46 peer connection state changed: connected
// 15:01:54 peer connection state changed: disconnected
// 15:02:20 peer connection state changed: failed
//
// Fail connection:
// 14:53:08 ICE connection state changed: checking
// 14:53:39 peer connection state changed: failed
pc.OnConnectionStateChange(func(state webrtc.PeerConnectionState) {
c.Fire(state)
// TODO: rewrite?
switch state {
case webrtc.PeerConnectionStateDisconnected:
// disconnect event comes earlier, than failed
// but it comes only for success connections
_ = pc.Close()
case webrtc.PeerConnectionStateFailed:
_ = pc.Close()
}
})
return c
}
func (c *Conn) Close() error {
return c.pc.Close()
}
func (c *Conn) AddCandidate(candidate string) error {
// pion uses only candidate value from json/object candidate struct
return c.pc.AddICECandidate(webrtc.ICECandidateInit{Candidate: candidate})
}
func (c *Conn) getTrack(remote *webrtc.TrackRemote) *streamer.Track {
payloadType := uint8(remote.PayloadType())
// search existing track (two way audio)
for _, track := range c.tracks {
if track.Codec.PayloadType == payloadType {
return track
}
}
// create new track (incoming WebRTC WHIP)
for _, media := range c.medias {
for _, codec := range media.Codecs {
if codec.PayloadType == payloadType {
track := streamer.NewTrack(codec, media.Direction)
c.tracks = append(c.tracks, track)
return track
}
}
}
return nil
}
func (c *Conn) remote() string {
if c.pc == nil {
return ""
}
for _, trans := range c.pc.GetTransceivers() {
if trans == nil {
continue
}
receiver := trans.Receiver()
if receiver == nil {
continue
}
transport := receiver.Transport()
if transport == nil {
continue
}
iceTransport := transport.ICETransport()
if iceTransport == nil {
continue
}
pair, _ := iceTransport.GetSelectedCandidatePair()
if pair == nil || pair.Remote == nil {
continue
}
return pair.Remote.String()
}
return ""
}
pkg/webrtc/consumer.go
+34 -25
View File
@@ -9,11 +9,11 @@ import (
"github.com/pion/webrtc/v3"
)
func (c *Server) GetMedias() []*streamer.Media {
func (c *Conn) GetMedias() []*streamer.Media {
return c.medias
}
func (c *Server) AddTrack(media *streamer.Media, track *streamer.Track) *streamer.Track {
func (c *Conn) AddTrack(media *streamer.Media, track *streamer.Track) *streamer.Track {
switch track.Direction {
// send our track to WebRTC consumer
case streamer.DirectionSendonly:
@@ -41,7 +41,14 @@ func (c *Server) AddTrack(media *streamer.Media, track *streamer.Track) *streame
return nil
}
if _, err = c.conn.AddTrack(trackLocal); err != nil {
init := webrtc.RTPTransceiverInit{Direction: webrtc.RTPTransceiverDirectionSendonly}
tr, err := c.pc.AddTransceiverFromTrack(trackLocal, init)
if err != nil {
return nil
}
codecs := []webrtc.RTPCodecParameters{{RTPCodecCapability: caps}}
if err = tr.SetCodecPreferences(codecs); err != nil {
return nil
}
@@ -78,37 +85,39 @@ func (c *Server) AddTrack(media *streamer.Media, track *streamer.Track) *streame
// receive track from WebRTC consumer (microphone, backchannel, two way audio)
case streamer.DirectionRecvonly:
for _, tr := range c.conn.GetTransceivers() {
if tr.Mid() != media.MID {
continue
}
codec := track.Codec
caps := webrtc.RTPCodecCapability{
MimeType: MimeType(codec),
ClockRate: codec.ClockRate,
Channels: codec.Channels,
}
codecs := []webrtc.RTPCodecParameters{
{RTPCodecCapability: caps},
}
if err := tr.SetCodecPreferences(codecs); err != nil {
return nil
}
c.tracks = append(c.tracks, track)
return track
caps := webrtc.RTPCodecCapability{
MimeType: MimeType(track.Codec),
ClockRate: track.Codec.ClockRate,
Channels: track.Codec.Channels,
}
init := webrtc.RTPTransceiverInit{Direction: webrtc.RTPTransceiverDirectionRecvonly}
tr, err := c.pc.AddTransceiverFromKind(webrtc.RTPCodecTypeAudio, init)
if err != nil {
return nil
}
codecs := []webrtc.RTPCodecParameters{
{RTPCodecCapability: caps, PayloadType: webrtc.PayloadType(track.Codec.PayloadType)},
}
if err = tr.SetCodecPreferences(codecs); err != nil {
return nil
}
c.tracks = append(c.tracks, track)
return track
}
panic("wrong direction")
}
func (c *Server) MarshalJSON() ([]byte, error) {
func (c *Conn) MarshalJSON() ([]byte, error) {
info := &streamer.Info{
Type: "WebRTC client",
Type: "WebRTC",
RemoteAddr: c.remote(),
UserAgent: c.UserAgent,
Medias: c.medias,
Tracks: c.tracks,
Recv: uint32(c.receive),
Send: uint32(c.send),
}
pkg/webrtc/producer.go
+20
View File
@@ -0,0 +1,20 @@
package webrtc
import "github.com/AlexxIT/go2rtc/pkg/streamer"
func (c *Conn) GetTrack(media *streamer.Media, codec *streamer.Codec) *streamer.Track {
for _, track := range c.tracks {
if track.Codec == codec {
return track
}
}
return nil
}
func (c *Conn) Start() error {
return nil
}
func (c *Conn) Stop() error {
return c.pc.Close()
}
pkg/webrtc/server.go
+22 -153
View File
@@ -6,96 +6,11 @@ import (
"github.com/pion/webrtc/v3"
)
type Server struct {
streamer.Element
func (c *Conn) SetOffer(offer string) (err error) {
c.offer = offer
UserAgent string
conn *webrtc.PeerConnection
medias []*streamer.Media
tracks []*streamer.Track
receive int
send int
}
func NewServer(conn *webrtc.PeerConnection) *Server {
c := &Server{conn: conn}
conn.OnICECandidate(func(candidate *webrtc.ICECandidate) {
c.Fire(candidate)
})
conn.OnTrack(func(remote *webrtc.TrackRemote, receiver *webrtc.RTPReceiver) {
for _, track := range c.tracks {
if track.Direction != streamer.DirectionRecvonly {
continue
}
if track.Codec.PayloadType != uint8(remote.PayloadType()) {
continue
}
for {
packet, _, err := remote.ReadRTP()
if err != nil {
return
}
if len(packet.Payload) == 0 {
continue
}
c.receive += len(packet.Payload)
_ = track.WriteRTP(packet)
}
}
//fmt.Printf("TODO: webrtc ontrack %+v\n", remote)
})
conn.OnDataChannel(func(channel *webrtc.DataChannel) {
c.Fire(channel)
})
// OK connection:
// 15:01:46 ICE connection state changed: checking
// 15:01:46 peer connection state changed: connected
// 15:01:54 peer connection state changed: disconnected
// 15:02:20 peer connection state changed: failed
//
// Fail connection:
// 14:53:08 ICE connection state changed: checking
// 14:53:39 peer connection state changed: failed
conn.OnConnectionStateChange(func(state webrtc.PeerConnectionState) {
c.Fire(state)
// TODO: remove
switch state {
case webrtc.PeerConnectionStateConnected:
c.Fire(streamer.StatePlaying) // TODO: remove
case webrtc.PeerConnectionStateDisconnected:
c.Fire(streamer.StateNull) // TODO: remove
// disconnect event comes earlier, than failed
// but it comes only for success connections
_ = conn.Close()
case webrtc.PeerConnectionStateFailed:
_ = conn.Close()
}
})
return c
}
func (c *Server) SetOffer(offer string) (err error) {
desc := webrtc.SessionDescription{
Type: webrtc.SDPTypeOffer, SDP: offer,
}
if err = c.conn.SetRemoteDescription(desc); err != nil {
return
}
rawSDP := []byte(c.conn.RemoteDescription().SDP)
sd := &sdp.SessionDescription{}
if err = sd.Unmarshal(rawSDP); err != nil {
if err = sd.Unmarshal([]byte(offer)); err != nil {
return
}
@@ -117,85 +32,39 @@ func (c *Server) SetOffer(offer string) (err error) {
return
}
func (c *Server) GetAnswer() (answer string, err error) {
for _, tr := range c.conn.GetTransceivers() {
if tr.Direction() != webrtc.RTPTransceiverDirectionSendonly {
continue
}
func (c *Conn) GetAnswer() (answer string, err error) {
// we need to process remote offer after we create transeivers
desc := webrtc.SessionDescription{Type: webrtc.SDPTypeOffer, SDP: c.offer}
if err = c.pc.SetRemoteDescription(desc); err != nil {
return "", err
}
// disable transceivers if we don't have track
// make direction=inactive
// don't really necessary, but anyway
if tr.Sender() == nil {
// disable transceivers if we don't have track
// make direction=inactive
// don't really necessary, but anyway
for _, tr := range c.pc.GetTransceivers() {
if tr.Direction() == webrtc.RTPTransceiverDirectionSendonly && tr.Sender() == nil {
if err = tr.Stop(); err != nil {
return
}
}
}
var sdAnswer webrtc.SessionDescription
sdAnswer, err = c.conn.CreateAnswer(nil)
if err != nil {
if desc, err = c.pc.CreateAnswer(nil); err != nil {
return
}
if err = c.pc.SetLocalDescription(desc); err != nil {
return
}
if err = c.conn.SetLocalDescription(sdAnswer); err != nil {
return
}
return sdAnswer.SDP, nil
return desc.SDP, nil
}
func (c *Server) GetCompleteAnswer() (answer string, err error) {
func (c *Conn) GetCompleteAnswer() (answer string, err error) {
if _, err = c.GetAnswer(); err != nil {
return
}
<-webrtc.GatheringCompletePromise(c.conn)
return c.conn.LocalDescription().SDP, nil
}
func (c *Server) Close() error {
return c.conn.Close()
}
func (c *Server) AddCandidate(candidate string) {
// pion uses only candidate value from json/object candidate struct
_ = c.conn.AddICECandidate(webrtc.ICECandidateInit{Candidate: candidate})
}
func (c *Server) remote() string {
if c.conn == nil {
return ""
}
for _, trans := range c.conn.GetTransceivers() {
if trans == nil {
continue
}
receiver := trans.Receiver()
if receiver == nil {
continue
}
transport := receiver.Transport()
if transport == nil {
continue
}
iceTransport := transport.ICETransport()
if iceTransport == nil {
continue
}
pair, _ := iceTransport.GetSelectedCandidatePair()
if pair == nil || pair.Remote == nil {
continue
}
return pair.Remote.String()
}
return ""
<-webrtc.GatheringCompletePromise(c.pc)
return c.pc.LocalDescription().SDP, nil
}