func NewRtpClient(listenIP string, listenPort int) (*RtpClient, error) { localAddr, err := net.ResolveIPAddr("ip", listenIP) if err != nil { return nil, err } rtpTransport, err := rtp.NewTransportUDP(localAddr, listenPort) if err != nil { return nil, err } session := rtp.NewSession(rtpTransport, rtpTransport) err = session.StartSession() if err != nil { return nil, err } client := &RtpClient{ listenPort: listenPort, ReceiveStats: stats.NewStats("RTP received"), MissedStats: stats.NewStats("RTP missed"), CtrlStats: stats.NewStats("RTCP events"), RtpSession: session, ctrlChan: session.CreateCtrlEventChan(rtpCtrlBuffer), dataChan: session.CreateDataReceiveChan(rtpDataBuffer), stopped: golib.NewOneshotCondition(), } client.wg.Add(1) go client.handleCtrlEvents() client.wg.Add(1) go client.handleDataPackets() return client, nil }
// NewSession creates a new RTP session. // // A RTP session requires two transports: // tpw - a transport that implements the RtpTransportWrite interface // tpr - a transport that implements the RtpTransportRecv interface // func NewSession(tpw TransportWrite, tpr TransportRecv) *Session { rs := new(Session) // Maps grow dynamically, set size to avoid resizing in normal cases. rs.streamsOut = make(streamOutMap, maxNumberOutStreams) rs.streamsIn = make(streamInMap, maxNumberInStreams) rs.remotes = make(remoteMap, 2) rs.conflicts = make(conflictMap, 2) rs.MaxNumberOutStreams = maxNumberOutStreams rs.MaxNumberInStreams = maxNumberInStreams rs.transportWrite = tpw rs.transportRecv = tpr rs.transportEnd = make(TransportEnd, 2) rs.rtcpCtrlChan = make(rtcpCtrlChan, 1) tpr.SetCallUpper(rs) tpr.SetEndChannel(rs.transportEnd) rs.DroppedDataPackets = stats.NewStats("Dropped RTP data packets") rs.DroppedCtrlPackets = stats.NewStats("Dropped RTP ctrl packets") return rs }
func NewUdpProxy(listenAddr, targetAddr string) (*UdpProxy, error) { var listenUDP, targetUDP *net.UDPAddr var err error if listenUDP, err = net.ResolveUDPAddr("udp", listenAddr); err != nil { return nil, err } if targetUDP, err = net.ResolveUDPAddr("udp", targetAddr); err != nil { return nil, err } listenConn, err := net.ListenUDP("udp", listenUDP) if err != nil { return nil, err } // TODO http://play.golang.org/p/ygGFr9oLpW // for per-UDP-packet addressing in case one proxy handles multiple connections targetConn, err := net.DialUDP("udp", nil, targetUDP) if err != nil { listenConn.Close() return nil, err } return &UdpProxy{ listenConn: listenConn, listenAddr: listenUDP, targetConn: targetConn, targetAddr: targetUDP, packets: make(chan []byte, BufferedPackets), proxyClosed: golib.NewOneshotCondition(), writeErrors: make(chan error, buf_write_errors), Stats: stats.NewStats("UDP Proxy " + listenAddr), OnError: OnErrorClose, writePausedCond: sync.Cond{L: new(sync.Mutex)}, }, nil }
func RegisterServer(server *protocols.Server) (*LoadStats, error) { if err := server.Protocol().CheckIncludesFragment(Protocol.Name()); err != nil { return nil, err } stats := &LoadStats{ server: server, Received: stats.NewStats("Received"), Missed: stats.NewStats("Missed"), } err := server.RegisterHandlers(protocols.ServerHandlerMap{ codeLoad: stats.handleLoad, }) if err != nil { return nil, err } return stats, nil }