317 lines
7.9 KiB
Go
317 lines
7.9 KiB
Go
package webrtc
|
|
|
|
import (
|
|
"fmt"
|
|
"net"
|
|
"slices"
|
|
|
|
"github.com/AlexxIT/go2rtc/pkg/core"
|
|
"github.com/AlexxIT/go2rtc/pkg/xnet"
|
|
"github.com/pion/ice/v4"
|
|
"github.com/pion/interceptor"
|
|
"github.com/pion/webrtc/v4"
|
|
)
|
|
|
|
// ReceiveMTU = Ethernet MTU (1500) - IP Header (20) - UDP Header (8)
|
|
// https://ffmpeg.org/ffmpeg-all.html#Muxer
|
|
const ReceiveMTU = 1472
|
|
|
|
func NewAPI() (*webrtc.API, error) {
|
|
return NewServerAPI("", "", nil)
|
|
}
|
|
|
|
type Filters struct {
|
|
Candidates []string `yaml:"candidates"`
|
|
Loopback bool `yaml:"loopback"`
|
|
Interfaces []string `yaml:"interfaces"`
|
|
IPs []string `yaml:"ips"`
|
|
Networks []string `yaml:"networks"`
|
|
UDPPorts []uint16 `yaml:"udp_ports"`
|
|
}
|
|
|
|
func (f *Filters) Network(protocol string) string {
|
|
if f == nil || f.Networks == nil {
|
|
return protocol
|
|
}
|
|
v4 := slices.Contains(f.Networks, protocol+"4")
|
|
v6 := slices.Contains(f.Networks, protocol+"6")
|
|
if v4 && v6 {
|
|
return protocol
|
|
} else if v4 {
|
|
return protocol + "4"
|
|
} else if v6 {
|
|
return protocol + "6"
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (f *Filters) NetIPs() (ips []net.IP) {
|
|
itfs, _ := net.Interfaces()
|
|
for _, itf := range itfs {
|
|
if itf.Flags&net.FlagUp == 0 {
|
|
continue
|
|
}
|
|
if !f.IncludeLoopback() && itf.Flags&net.FlagLoopback != 0 {
|
|
continue
|
|
}
|
|
if !f.InterfaceFilter(itf.Name) {
|
|
continue
|
|
}
|
|
|
|
addrs, _ := itf.Addrs()
|
|
for _, addr := range addrs {
|
|
ip := parseNetAddr(addr)
|
|
if ip == nil || !f.IPFilter(ip) {
|
|
continue
|
|
}
|
|
ips = append(ips, ip)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
func parseNetAddr(addr net.Addr) net.IP {
|
|
switch addr := addr.(type) {
|
|
case *net.IPNet:
|
|
return addr.IP
|
|
case *net.IPAddr:
|
|
return addr.IP
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (f *Filters) IncludeLoopback() bool {
|
|
return f != nil && f.Loopback
|
|
}
|
|
|
|
func (f *Filters) InterfaceFilter(name string) bool {
|
|
return f == nil || f.Interfaces == nil || slices.Contains(f.Interfaces, name)
|
|
}
|
|
|
|
func (f *Filters) IPFilter(ip net.IP) bool {
|
|
return f == nil || f.IPs == nil || core.Contains(f.IPs, ip.String())
|
|
}
|
|
|
|
func NewServerAPI(network, address string, filters *Filters) (*webrtc.API, error) {
|
|
// for debug logs add to env: `PION_LOG_DEBUG=all`
|
|
m := &webrtc.MediaEngine{}
|
|
//if err := m.RegisterDefaultCodecs(); err != nil {
|
|
// return nil, err
|
|
//}
|
|
if err := RegisterDefaultCodecs(m); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
i := &interceptor.Registry{}
|
|
if err := webrtc.RegisterDefaultInterceptors(m, i); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
s := webrtc.SettingEngine{}
|
|
|
|
// fix https://github.com/pion/webrtc/pull/2407
|
|
s.SetDTLSInsecureSkipHelloVerify(true)
|
|
|
|
if filters != nil && filters.Loopback {
|
|
s.SetIncludeLoopbackCandidate(true)
|
|
}
|
|
|
|
var interfaceFilter func(name string) bool
|
|
if filters != nil && filters.Interfaces != nil {
|
|
interfaceFilter = func(name string) bool {
|
|
return core.Contains(filters.Interfaces, name)
|
|
}
|
|
} else {
|
|
// default interfaces - all, except loopback
|
|
}
|
|
s.SetInterfaceFilter(interfaceFilter)
|
|
|
|
var ipFilter func(ip net.IP) bool
|
|
if filters != nil && filters.IPs != nil {
|
|
ipFilter = func(ip net.IP) bool {
|
|
return core.Contains(filters.IPs, ip.String())
|
|
}
|
|
} else {
|
|
// try filter all Docker-like interfaces
|
|
ipFilter = func(ip net.IP) bool {
|
|
return !xnet.Docker.Contains(ip)
|
|
}
|
|
// if there are no such interfaces - disable the filter
|
|
// the user will need to enable port forwarding
|
|
if nets, _ := xnet.IPNets(ipFilter); len(nets) == 0 {
|
|
ipFilter = nil
|
|
}
|
|
}
|
|
s.SetIPFilter(ipFilter)
|
|
|
|
var networkTypes []webrtc.NetworkType
|
|
if filters != nil && filters.Networks != nil {
|
|
for _, s := range filters.Networks {
|
|
if networkType, err := webrtc.NewNetworkType(s); err == nil {
|
|
networkTypes = append(networkTypes, networkType)
|
|
}
|
|
}
|
|
} else {
|
|
// default network types - all
|
|
networkTypes = []webrtc.NetworkType{
|
|
webrtc.NetworkTypeUDP4, webrtc.NetworkTypeUDP6,
|
|
webrtc.NetworkTypeTCP4, webrtc.NetworkTypeTCP6,
|
|
}
|
|
}
|
|
s.SetNetworkTypes(networkTypes)
|
|
|
|
if filters != nil && len(filters.UDPPorts) == 2 {
|
|
_ = s.SetEphemeralUDPPortRange(filters.UDPPorts[0], filters.UDPPorts[1])
|
|
}
|
|
|
|
// If you don't specify an address, this won't cause an error.
|
|
// Connections can still be established using random UDP addresses.
|
|
if address != "" {
|
|
// Both newMux functions respect filters and do not raise an error
|
|
// if the port cannot be listened on.
|
|
if network == "" || network == "tcp" {
|
|
tcpMux := newTCPMux(address, filters)
|
|
s.SetICETCPMux(tcpMux)
|
|
}
|
|
if network == "" || network == "udp" {
|
|
udpMux := newUDPMux(address, filters)
|
|
s.SetICEUDPMux(udpMux)
|
|
}
|
|
}
|
|
|
|
return webrtc.NewAPI(
|
|
webrtc.WithMediaEngine(m),
|
|
webrtc.WithInterceptorRegistry(i),
|
|
webrtc.WithSettingEngine(s),
|
|
), nil
|
|
}
|
|
|
|
// OnNewListener temporary ugly solution for log
|
|
var OnNewListener = func(ln any) {}
|
|
|
|
func newTCPMux(address string, filters *Filters) ice.TCPMux {
|
|
networkTCP := filters.Network("tcp") // tcp or tcp4 or tcp6
|
|
if ln, _ := net.Listen(networkTCP, address); ln != nil {
|
|
OnNewListener(ln)
|
|
return webrtc.NewICETCPMux(nil, ln, 8)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func newUDPMux(address string, filters *Filters) ice.UDPMux {
|
|
host, port, err := net.SplitHostPort(address)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
|
|
// UDPMux should not listening on unspecified address.
|
|
// So we will create a listener on all available interfaces.
|
|
// We can't use ice.NewMultiUDPMuxFromPort, because it sometimes crashes with an error:
|
|
// listen udp [***]:8555: bind: cannot assign requested address
|
|
var addrs []string
|
|
if host == "" {
|
|
for _, ip := range filters.NetIPs() {
|
|
addrs = append(addrs, fmt.Sprintf("%s:%s", ip, port))
|
|
}
|
|
} else {
|
|
addrs = []string{address}
|
|
}
|
|
|
|
networkUDP := filters.Network("udp") // udp or udp4 or udp6
|
|
|
|
var muxes []ice.UDPMux
|
|
for _, addr := range addrs {
|
|
if ln, _ := net.ListenPacket(networkUDP, addr); ln != nil {
|
|
OnNewListener(ln)
|
|
mux := ice.NewUDPMuxDefault(ice.UDPMuxParams{UDPConn: ln})
|
|
muxes = append(muxes, mux)
|
|
}
|
|
}
|
|
|
|
switch len(muxes) {
|
|
case 0:
|
|
return nil
|
|
case 1:
|
|
return muxes[0]
|
|
}
|
|
return ice.NewMultiUDPMuxDefault(muxes...)
|
|
}
|
|
|
|
func RegisterDefaultCodecs(m *webrtc.MediaEngine) error {
|
|
for _, codec := range []webrtc.RTPCodecParameters{
|
|
{
|
|
RTPCodecCapability: webrtc.RTPCodecCapability{
|
|
MimeType: webrtc.MimeTypeOpus, ClockRate: 48000, Channels: 2, SDPFmtpLine: "minptime=10;useinbandfec=1",
|
|
},
|
|
PayloadType: 101, //111,
|
|
},
|
|
{
|
|
RTPCodecCapability: webrtc.RTPCodecCapability{
|
|
MimeType: webrtc.MimeTypePCMU, ClockRate: 8000,
|
|
},
|
|
PayloadType: 0,
|
|
},
|
|
{
|
|
RTPCodecCapability: webrtc.RTPCodecCapability{
|
|
MimeType: webrtc.MimeTypePCMA, ClockRate: 8000,
|
|
},
|
|
PayloadType: 8,
|
|
},
|
|
} {
|
|
if err := m.RegisterCodec(codec, webrtc.RTPCodecTypeAudio); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
videoRTCPFeedback := []webrtc.RTCPFeedback{
|
|
{"goog-remb", ""},
|
|
{"ccm", "fir"},
|
|
{"nack", ""},
|
|
{"nack", "pli"},
|
|
}
|
|
for _, codec := range []webrtc.RTPCodecParameters{
|
|
{
|
|
RTPCodecCapability: webrtc.RTPCodecCapability{
|
|
MimeType: webrtc.MimeTypeH264,
|
|
ClockRate: 90000,
|
|
SDPFmtpLine: "level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42001f",
|
|
RTCPFeedback: videoRTCPFeedback,
|
|
},
|
|
PayloadType: 96, // Chrome v110 - PayloadType: 102
|
|
},
|
|
{
|
|
RTPCodecCapability: webrtc.RTPCodecCapability{
|
|
MimeType: webrtc.MimeTypeH264,
|
|
ClockRate: 90000,
|
|
SDPFmtpLine: "level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f",
|
|
RTCPFeedback: videoRTCPFeedback,
|
|
},
|
|
PayloadType: 97, // Chrome v110 - PayloadType: 106
|
|
},
|
|
{
|
|
RTPCodecCapability: webrtc.RTPCodecCapability{
|
|
MimeType: webrtc.MimeTypeH264,
|
|
ClockRate: 90000,
|
|
SDPFmtpLine: "level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=640032",
|
|
RTCPFeedback: videoRTCPFeedback,
|
|
},
|
|
PayloadType: 98, // Chrome v110 - PayloadType: 112
|
|
},
|
|
// macOS Safari 15.1
|
|
{
|
|
RTPCodecCapability: webrtc.RTPCodecCapability{
|
|
MimeType: webrtc.MimeTypeH265,
|
|
ClockRate: 90000,
|
|
RTCPFeedback: videoRTCPFeedback,
|
|
},
|
|
PayloadType: 100,
|
|
},
|
|
} {
|
|
if err := m.RegisterCodec(codec, webrtc.RTPCodecTypeVideo); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|