update confs

cmd/server/grpc/main.go

@@ -80,7 +80,7 @@ func load() bool {
 		return false
 	}
 
-	if len(conf.WebRTC.ICEPortRange) != 0 && conf.WebRTC.ICEPortRange[1]-conf.WebRTC.ICEPortRange[0] <= portRangeLimit {
+	if len(conf.WebRTC.ICEPortRange) != 0 && conf.WebRTC.ICEPortRange[1]-conf.WebRTC.ICEPortRange[0] < portRangeLimit {
 		fmt.Printf("config file %s loaded failed. range port must be [min, max] and max - min >= %d\n", file, portRangeLimit)
 		return false
 	}

cmd/server/json-rpc/main.go

@@ -66,7 +66,7 @@ func load() bool {
 		return false
 	}
 
-	if len(conf.WebRTC.ICEPortRange) != 0 && conf.WebRTC.ICEPortRange[1]-conf.WebRTC.ICEPortRange[0] <= portRangeLimit {
+	if len(conf.WebRTC.ICEPortRange) != 0 && conf.WebRTC.ICEPortRange[1]-conf.WebRTC.ICEPortRange[0] < portRangeLimit {
 		fmt.Printf("config file %s loaded failed. range port must be [min, max] and max - min >= %d\n", file, portRangeLimit)
 		return false
 	}

config.toml

@@ -18,7 +18,6 @@ maxbandwidth = 1000
 maxbuffertime = 1000
 
 [webrtc]
-
 # Range of ports that ion accepts WebRTC traffic on
 # Format: [min, max]   and max - min >= 100
 # portrange = [50000, 60000]
@@ -29,5 +28,6 @@ maxbuffertime = 1000
 # urls = ["turn:turn.awsome.org:3478"]
 # username = "awsome"
 # credential = "awsome"
+
 [log]
 level = "debug"

pkg/session_test.go

@@ -14,7 +14,7 @@ import (
 )
 
 func createPeer(t *testing.T, session *Session, api *webrtc.API) (*WebRTCTransport, *webrtc.PeerConnection, *webrtc.Track, error) {
-	remote, err := api.NewPeerConnection(cfg)
+	remote, err := api.NewPeerConnection(conf.configuration)
 	if err != nil {
 		return nil, nil, nil, err
 	}
@@ -67,7 +67,7 @@ func TestSession(t *testing.T) {
 	<-gatherComplete
 
 	session := NewSession("session")
-	peer, err := NewWebRTCTransport(session, *remote.LocalDescription())
+	peer, err := NewWebRTCTransport(session, *remote.LocalDescription(), conf)
 	assert.NoError(t, err)
 
 	onCloseFired, onCloseFiredFunc := context.WithCancel(context.Background())
@@ -282,7 +282,7 @@ func Test3PeerStaggerJoin(t *testing.T) {
 	me.RegisterDefaultCodecs()
 	api := webrtc.NewAPI(webrtc.WithMediaEngine(me))
 
-	remoteA, err := api.NewPeerConnection(cfg)
+	remoteA, err := api.NewPeerConnection(conf.configuration)
 	assert.NoError(t, err)
 
 	// Add a pub track for remote A
@@ -302,7 +302,7 @@ func Test3PeerStaggerJoin(t *testing.T) {
 	trackADone := waitForRouter(peerA, trackA.SSRC())
 	sendRTPUntilDone(trackADone, t, []*webrtc.Track{trackA})
 
-	remoteB, err := api.NewPeerConnection(cfg)
+	remoteB, err := api.NewPeerConnection(conf.configuration)
 	assert.NoError(t, err)
 	// Add a pub track for remote B
 	trackB, err := remoteB.NewTrack(webrtc.DefaultPayloadTypeVP8, rand.Uint32(), "video", "pion")
@@ -314,7 +314,7 @@ func Test3PeerStaggerJoin(t *testing.T) {
 	err = remoteB.SetLocalDescription(offer)
 	assert.NoError(t, err)
 	gatherComplete := webrtc.GatheringCompletePromise(remoteB)
-	peerB, err := NewWebRTCTransport(session, offer)
+	peerB, err := NewWebRTCTransport(session, offer, conf)
 	session.AddTransport(peerB)
 	assert.NoError(t, err)
 	<-gatherComplete
@@ -351,7 +351,7 @@ func Test3PeerStaggerJoin(t *testing.T) {
 	trackBDone := waitForRouter(peerB, trackB.SSRC())
 	sendRTPUntilDone(trackBDone, t, []*webrtc.Track{trackB})
 
-	remoteC, err := api.NewPeerConnection(cfg)
+	remoteC, err := api.NewPeerConnection(conf.configuration)
 	assert.NoError(t, err)
 	// Add transceiver to match number of recv tracks
 	_, err = remoteC.AddTransceiverFromTrack(trackB)
@@ -367,7 +367,7 @@ func Test3PeerStaggerJoin(t *testing.T) {
 	err = remoteC.SetLocalDescription(offer)
 	assert.NoError(t, err)
 	gatherComplete = webrtc.GatheringCompletePromise(remoteC)
-	peerC, err := NewWebRTCTransport(session, offer)
+	peerC, err := NewWebRTCTransport(session, offer, conf)
 	session.AddTransport(peerC)
 	assert.NoError(t, err)
 	<-gatherComplete

pkg/sfu.go

@@ -35,24 +35,26 @@ type Config struct {
 }
 
 var (
-	// only support unified plan
-	cfg = webrtc.Configuration{
-		SDPSemantics: webrtc.SDPSemanticsUnifiedPlanWithFallback,
-	}
-
-	config  Config
-	setting webrtc.SettingEngine
+	config Config
 )
 
 // SFU represents an sfu instance
 type SFU struct {
+	webrtc   WebRTCTransportConfig
 	mu       sync.RWMutex
 	sessions map[string]*Session
 }
 
 // NewSFU creates a new sfu instance
 func NewSFU(c Config) *SFU {
+	w := WebRTCTransportConfig{
+		configuration: webrtc.Configuration{
+			SDPSemantics: webrtc.SDPSemanticsUnifiedPlan,
+		},
+		setting: webrtc.SettingEngine{},
+	}
 	s := &SFU{
+		webrtc:   w,
 		sessions: make(map[string]*Session),
 	}
 
@@ -68,7 +70,7 @@ func NewSFU(c Config) *SFU {
 	}
 
 	if icePortStart != 0 || icePortEnd != 0 {
-		if err := setting.SetEphemeralUDPPortRange(icePortStart, icePortEnd); err != nil {
+		if err := s.webrtc.setting.SetEphemeralUDPPortRange(icePortStart, icePortEnd); err != nil {
 			panic(err)
 		}
 	}
@@ -83,7 +85,7 @@ func NewSFU(c Config) *SFU {
 		iceServers = append(iceServers, s)
 	}
 
-	cfg.ICEServers = iceServers
+	s.webrtc.configuration.ICEServers = iceServers
 
 	go s.stats()
 
@@ -120,7 +122,7 @@ func (s *SFU) NewWebRTCTransport(sid string, offer webrtc.SessionDescription) (*
 		session = s.newSession(sid)
 	}
 
-	t, err := NewWebRTCTransport(session, offer)
+	t, err := NewWebRTCTransport(session, offer, s.webrtc)
 	if err != nil {
 		return nil, err
 	}

pkg/sfu_test.go

@@ -22,7 +22,7 @@ func TestSFU(t *testing.T) {
 	me := webrtc.MediaEngine{}
 	me.RegisterDefaultCodecs()
 	api := webrtc.NewAPI(webrtc.WithMediaEngine(me))
-	remote, err := api.NewPeerConnection(cfg)
+	remote, err := api.NewPeerConnection(conf.configuration)
 	assert.NoError(t, err)
 
 	offer, err := remote.CreateOffer(nil)

pkg/webrtctransport.go

@@ -16,6 +16,12 @@ const (
 	statCycle = 6 * time.Second
 )
 
+// WebRTCTransportConfig represents configuration options
+type WebRTCTransportConfig struct {
+	configuration webrtc.Configuration
+	setting       webrtc.SettingEngine
+}
+
 // WebRTCTransport represents a sfu peer connection
 type WebRTCTransport struct {
 	id                         string
@@ -30,16 +36,16 @@ type WebRTCTransport struct {
 }
 
 // NewWebRTCTransport creates a new WebRTCTransport
-func NewWebRTCTransport(session *Session, offer webrtc.SessionDescription) (*WebRTCTransport, error) {
+func NewWebRTCTransport(session *Session, offer webrtc.SessionDescription, cfg WebRTCTransportConfig) (*WebRTCTransport, error) {
 	// We make our own mediaEngine so we can place the sender's codecs in it.  This because we must use the
 	// dynamic media type from the sender in our answer. This is not required if we are the offerer
 	me := MediaEngine{}
 	if err := me.PopulateFromSDP(offer); err != nil {
 		return nil, errSdpParseFailed
 	}
 
-	api := webrtc.NewAPI(webrtc.WithMediaEngine(me.MediaEngine), webrtc.WithSettingEngine(setting))
-	pc, err := api.NewPeerConnection(cfg)
+	api := webrtc.NewAPI(webrtc.WithMediaEngine(me.MediaEngine), webrtc.WithSettingEngine(cfg.setting))
+	pc, err := api.NewPeerConnection(cfg.configuration)
 
 	if err != nil {
 		log.Errorf("NewPeer error: %v", err)

pkg/webrtctransport_test.go

@@ -10,6 +10,13 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
+var conf = WebRTCTransportConfig{
+	configuration: webrtc.Configuration{
+		SDPSemantics: webrtc.SDPSemanticsUnifiedPlan,
+	},
+	setting: webrtc.SettingEngine{},
+}
+
 // newPair creates two new peer connections (an offerer and an answerer) using
 // the api.
 func newPair(cfg webrtc.Configuration, api *webrtc.API) (pcOffer *webrtc.PeerConnection, pcAnswer *webrtc.PeerConnection, err error) {
@@ -36,7 +43,7 @@ func signalPeer(session *Session, remote *webrtc.PeerConnection) (*WebRTCTranspo
 	}
 	gatherComplete := webrtc.GatheringCompletePromise(remote)
 
-	peer, err := NewWebRTCTransport(session, offer)
+	peer, err := NewWebRTCTransport(session, offer, conf)
 	if err != nil {
 		return nil, err
 	}
@@ -156,7 +163,7 @@ func TestPeerPairRemoteBGetsOnTrack(t *testing.T) {
 	assert.NoError(t, err)
 	gatherComplete := webrtc.GatheringCompletePromise(remoteB)
 
-	peerB, err := NewWebRTCTransport(session, offer)
+	peerB, err := NewWebRTCTransport(session, offer, conf)
 	assert.NoError(t, err)
 
 	// Subscribe to remoteA track
@@ -296,7 +303,7 @@ func TestEventHandlers(t *testing.T) {
 	assert.NoError(t, err)
 	gatherComplete := webrtc.GatheringCompletePromise(remoteB)
 
-	peerB, err := NewWebRTCTransport(session, offer)
+	peerB, err := NewWebRTCTransport(session, offer, conf)
 	assert.NoError(t, err)
 
 	// Subscribe to remoteA track