|
|
|
@ -14,30 +14,29 @@ import ( |
|
|
|
) |
|
|
|
) |
|
|
|
|
|
|
|
|
|
|
|
const ( |
|
|
|
const ( |
|
|
|
_DIAL_TIMEOUT = 10 * time.Second |
|
|
|
_STREAMER_RETRY_INTERVAL = 5 * time.Second |
|
|
|
_RETRY_INTERVAL = 5 * time.Second |
|
|
|
_STREAMER_CHECK_STREAM_INTERVAL = 5 * time.Second |
|
|
|
_CHECK_STREAM_INTERVAL = 6 * time.Second |
|
|
|
_STREAMER_STREAM_DEAD_AFTER = 15 * time.Second |
|
|
|
_STREAM_DEAD_AFTER = 5 * time.Second |
|
|
|
_STREAMER_KEEPALIVE_INTERVAL = 60 * time.Second |
|
|
|
_KEEPALIVE_INTERVAL = 60 * time.Second |
|
|
|
_STREAMER_RECEIVER_REPORT_INTERVAL = 10 * time.Second |
|
|
|
) |
|
|
|
) |
|
|
|
|
|
|
|
|
|
|
|
type streamerUdpListenerPair struct { |
|
|
|
type streamerUdpListenerPair struct { |
|
|
|
udplRtp *streamerUdpListener |
|
|
|
rtpl *streamerUdpListener |
|
|
|
udplRtcp *streamerUdpListener |
|
|
|
rtcpl *streamerUdpListener |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
type streamer struct { |
|
|
|
type streamer struct { |
|
|
|
p *program |
|
|
|
p *program |
|
|
|
path string |
|
|
|
path string |
|
|
|
ur *url.URL |
|
|
|
ur *url.URL |
|
|
|
proto streamProtocol |
|
|
|
proto streamProtocol |
|
|
|
ready bool |
|
|
|
ready bool |
|
|
|
clientSdpParsed *sdp.Message |
|
|
|
clientSdpParsed *sdp.Message |
|
|
|
serverSdpText []byte |
|
|
|
serverSdpText []byte |
|
|
|
serverSdpParsed *sdp.Message |
|
|
|
serverSdpParsed *sdp.Message |
|
|
|
firstTime bool |
|
|
|
rtcpReceivers []*rtcpReceiver |
|
|
|
udpLastFrameTime time.Time |
|
|
|
readBuf *doubleBuffer |
|
|
|
readBuf *doubleBuffer |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
terminate chan struct{} |
|
|
|
terminate chan struct{} |
|
|
|
done chan struct{} |
|
|
|
done chan struct{} |
|
|
|
@ -82,7 +81,6 @@ func newStreamer(p *program, path string, source string, sourceProtocol string) |
|
|
|
path: path, |
|
|
|
path: path, |
|
|
|
ur: ur, |
|
|
|
ur: ur, |
|
|
|
proto: proto, |
|
|
|
proto: proto, |
|
|
|
firstTime: true, |
|
|
|
|
|
|
|
readBuf: newDoubleBuffer(512 * 1024), |
|
|
|
readBuf: newDoubleBuffer(512 * 1024), |
|
|
|
terminate: make(chan struct{}), |
|
|
|
terminate: make(chan struct{}), |
|
|
|
done: make(chan struct{}), |
|
|
|
done: make(chan struct{}), |
|
|
|
@ -113,30 +111,26 @@ func (s *streamer) run() { |
|
|
|
if !ok { |
|
|
|
if !ok { |
|
|
|
break |
|
|
|
break |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
close(s.done) |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
func (s *streamer) do() bool { |
|
|
|
t := time.NewTimer(_STREAMER_RETRY_INTERVAL) |
|
|
|
if s.firstTime { |
|
|
|
|
|
|
|
s.firstTime = false |
|
|
|
|
|
|
|
} else { |
|
|
|
|
|
|
|
t := time.NewTimer(_RETRY_INTERVAL) |
|
|
|
|
|
|
|
select { |
|
|
|
select { |
|
|
|
case <-s.terminate: |
|
|
|
case <-s.terminate: |
|
|
|
return false |
|
|
|
break |
|
|
|
case <-t.C: |
|
|
|
case <-t.C: |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
close(s.done) |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
func (s *streamer) do() bool { |
|
|
|
s.log("initializing with protocol %s", s.proto) |
|
|
|
s.log("initializing with protocol %s", s.proto) |
|
|
|
|
|
|
|
|
|
|
|
var nconn net.Conn |
|
|
|
var nconn net.Conn |
|
|
|
var err error |
|
|
|
var err error |
|
|
|
dialDone := make(chan struct{}) |
|
|
|
dialDone := make(chan struct{}) |
|
|
|
go func() { |
|
|
|
go func() { |
|
|
|
nconn, err = net.DialTimeout("tcp", s.ur.Host, _DIAL_TIMEOUT) |
|
|
|
nconn, err = net.DialTimeout("tcp", s.ur.Host, s.p.conf.ReadTimeout) |
|
|
|
close(dialDone) |
|
|
|
close(dialDone) |
|
|
|
}() |
|
|
|
}() |
|
|
|
|
|
|
|
|
|
|
|
@ -251,16 +245,16 @@ func (s *streamer) runUdp(conn *gortsplib.ConnClient) bool { |
|
|
|
|
|
|
|
|
|
|
|
defer func() { |
|
|
|
defer func() { |
|
|
|
for _, pair := range streamerUdpListenerPairs { |
|
|
|
for _, pair := range streamerUdpListenerPairs { |
|
|
|
pair.udplRtp.close() |
|
|
|
pair.rtpl.close() |
|
|
|
pair.udplRtcp.close() |
|
|
|
pair.rtcpl.close() |
|
|
|
} |
|
|
|
} |
|
|
|
}() |
|
|
|
}() |
|
|
|
|
|
|
|
|
|
|
|
for i, media := range s.clientSdpParsed.Medias { |
|
|
|
for i, media := range s.clientSdpParsed.Medias { |
|
|
|
var rtpPort int |
|
|
|
var rtpPort int |
|
|
|
var rtcpPort int |
|
|
|
var rtcpPort int |
|
|
|
var udplRtp *streamerUdpListener |
|
|
|
var rtpl *streamerUdpListener |
|
|
|
var udplRtcp *streamerUdpListener |
|
|
|
var rtcpl *streamerUdpListener |
|
|
|
func() { |
|
|
|
func() { |
|
|
|
for { |
|
|
|
for { |
|
|
|
// choose two consecutive ports in range 65536-10000
|
|
|
|
// choose two consecutive ports in range 65536-10000
|
|
|
|
@ -269,16 +263,16 @@ func (s *streamer) runUdp(conn *gortsplib.ConnClient) bool { |
|
|
|
rtcpPort = rtpPort + 1 |
|
|
|
rtcpPort = rtpPort + 1 |
|
|
|
|
|
|
|
|
|
|
|
var err error |
|
|
|
var err error |
|
|
|
udplRtp, err = newStreamerUdpListener(s.p, rtpPort, s, i, |
|
|
|
rtpl, err = newStreamerUdpListener(s.p, rtpPort, s, i, |
|
|
|
_TRACK_FLOW_TYPE_RTP, publisherIp) |
|
|
|
_TRACK_FLOW_TYPE_RTP, publisherIp) |
|
|
|
if err != nil { |
|
|
|
if err != nil { |
|
|
|
continue |
|
|
|
continue |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
udplRtcp, err = newStreamerUdpListener(s.p, rtcpPort, s, i, |
|
|
|
rtcpl, err = newStreamerUdpListener(s.p, rtcpPort, s, i, |
|
|
|
_TRACK_FLOW_TYPE_RTCP, publisherIp) |
|
|
|
_TRACK_FLOW_TYPE_RTCP, publisherIp) |
|
|
|
if err != nil { |
|
|
|
if err != nil { |
|
|
|
udplRtp.close() |
|
|
|
rtpl.close() |
|
|
|
continue |
|
|
|
continue |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
@ -338,23 +332,23 @@ func (s *streamer) runUdp(conn *gortsplib.ConnClient) bool { |
|
|
|
}) |
|
|
|
}) |
|
|
|
if err != nil { |
|
|
|
if err != nil { |
|
|
|
s.log("ERR: %s", err) |
|
|
|
s.log("ERR: %s", err) |
|
|
|
udplRtp.close() |
|
|
|
rtpl.close() |
|
|
|
udplRtcp.close() |
|
|
|
rtcpl.close() |
|
|
|
return true |
|
|
|
return true |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
if res.StatusCode != gortsplib.StatusOK { |
|
|
|
if res.StatusCode != gortsplib.StatusOK { |
|
|
|
s.log("ERR: SETUP returned code %d (%s)", res.StatusCode, res.StatusMessage) |
|
|
|
s.log("ERR: SETUP returned code %d (%s)", res.StatusCode, res.StatusMessage) |
|
|
|
udplRtp.close() |
|
|
|
rtpl.close() |
|
|
|
udplRtcp.close() |
|
|
|
rtcpl.close() |
|
|
|
return true |
|
|
|
return true |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
tsRaw, ok := res.Header["Transport"] |
|
|
|
tsRaw, ok := res.Header["Transport"] |
|
|
|
if !ok || len(tsRaw) != 1 { |
|
|
|
if !ok || len(tsRaw) != 1 { |
|
|
|
s.log("ERR: transport header not provided") |
|
|
|
s.log("ERR: transport header not provided") |
|
|
|
udplRtp.close() |
|
|
|
rtpl.close() |
|
|
|
udplRtcp.close() |
|
|
|
rtcpl.close() |
|
|
|
return true |
|
|
|
return true |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
@ -362,17 +356,17 @@ func (s *streamer) runUdp(conn *gortsplib.ConnClient) bool { |
|
|
|
rtpServerPort, rtcpServerPort := th.GetPorts("server_port") |
|
|
|
rtpServerPort, rtcpServerPort := th.GetPorts("server_port") |
|
|
|
if rtpServerPort == 0 { |
|
|
|
if rtpServerPort == 0 { |
|
|
|
s.log("ERR: server ports not provided") |
|
|
|
s.log("ERR: server ports not provided") |
|
|
|
udplRtp.close() |
|
|
|
rtpl.close() |
|
|
|
udplRtcp.close() |
|
|
|
rtcpl.close() |
|
|
|
return true |
|
|
|
return true |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
udplRtp.publisherPort = rtpServerPort |
|
|
|
rtpl.publisherPort = rtpServerPort |
|
|
|
udplRtcp.publisherPort = rtcpServerPort |
|
|
|
rtcpl.publisherPort = rtcpServerPort |
|
|
|
|
|
|
|
|
|
|
|
streamerUdpListenerPairs = append(streamerUdpListenerPairs, streamerUdpListenerPair{ |
|
|
|
streamerUdpListenerPairs = append(streamerUdpListenerPairs, streamerUdpListenerPair{ |
|
|
|
udplRtp: udplRtp, |
|
|
|
rtpl: rtpl, |
|
|
|
udplRtcp: udplRtcp, |
|
|
|
rtcpl: rtcpl, |
|
|
|
}) |
|
|
|
}) |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
@ -395,30 +389,32 @@ func (s *streamer) runUdp(conn *gortsplib.ConnClient) bool { |
|
|
|
return true |
|
|
|
return true |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
for _, pair := range streamerUdpListenerPairs { |
|
|
|
s.rtcpReceivers = make([]*rtcpReceiver, len(s.clientSdpParsed.Medias)) |
|
|
|
pair.udplRtp.start() |
|
|
|
for trackId := range s.clientSdpParsed.Medias { |
|
|
|
pair.udplRtcp.start() |
|
|
|
s.rtcpReceivers[trackId] = newRtcpReceiver() |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
tickerSendKeepalive := time.NewTicker(_KEEPALIVE_INTERVAL) |
|
|
|
for _, pair := range streamerUdpListenerPairs { |
|
|
|
defer tickerSendKeepalive.Stop() |
|
|
|
pair.rtpl.start() |
|
|
|
|
|
|
|
pair.rtcpl.start() |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
s.udpLastFrameTime = time.Now() |
|
|
|
sendKeepaliveTicker := time.NewTicker(_STREAMER_KEEPALIVE_INTERVAL) |
|
|
|
tickerCheckStream := time.NewTicker(_CHECK_STREAM_INTERVAL) |
|
|
|
checkStreamTicker := time.NewTicker(_STREAMER_CHECK_STREAM_INTERVAL) |
|
|
|
defer tickerCheckStream.Stop() |
|
|
|
receiverReportTicker := time.NewTicker(_STREAMER_RECEIVER_REPORT_INTERVAL) |
|
|
|
|
|
|
|
|
|
|
|
s.p.events <- programEventStreamerReady{s} |
|
|
|
s.p.events <- programEventStreamerReady{s} |
|
|
|
|
|
|
|
|
|
|
|
defer func() { |
|
|
|
var ret bool |
|
|
|
s.p.events <- programEventStreamerNotReady{s} |
|
|
|
|
|
|
|
}() |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
outer: |
|
|
|
for { |
|
|
|
for { |
|
|
|
select { |
|
|
|
select { |
|
|
|
case <-s.terminate: |
|
|
|
case <-s.terminate: |
|
|
|
return false |
|
|
|
ret = false |
|
|
|
|
|
|
|
break outer |
|
|
|
|
|
|
|
|
|
|
|
case <-tickerSendKeepalive.C: |
|
|
|
case <-sendKeepaliveTicker.C: |
|
|
|
_, err = conn.WriteRequest(&gortsplib.Request{ |
|
|
|
_, err = conn.WriteRequest(&gortsplib.Request{ |
|
|
|
Method: gortsplib.OPTIONS, |
|
|
|
Method: gortsplib.OPTIONS, |
|
|
|
Url: &url.URL{ |
|
|
|
Url: &url.URL{ |
|
|
|
@ -429,16 +425,50 @@ func (s *streamer) runUdp(conn *gortsplib.ConnClient) bool { |
|
|
|
}) |
|
|
|
}) |
|
|
|
if err != nil { |
|
|
|
if err != nil { |
|
|
|
s.log("ERR: %s", err) |
|
|
|
s.log("ERR: %s", err) |
|
|
|
return true |
|
|
|
ret = true |
|
|
|
|
|
|
|
break outer |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
case <-tickerCheckStream.C: |
|
|
|
case <-checkStreamTicker.C: |
|
|
|
if time.Since(s.udpLastFrameTime) >= _STREAM_DEAD_AFTER { |
|
|
|
for trackId := range s.clientSdpParsed.Medias { |
|
|
|
s.log("ERR: stream is dead") |
|
|
|
if time.Since(s.rtcpReceivers[trackId].lastFrameTime()) >= _STREAMER_STREAM_DEAD_AFTER { |
|
|
|
return true |
|
|
|
s.log("ERR: stream is dead") |
|
|
|
|
|
|
|
ret = true |
|
|
|
|
|
|
|
break outer |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
case <-receiverReportTicker.C: |
|
|
|
|
|
|
|
for trackId := range s.clientSdpParsed.Medias { |
|
|
|
|
|
|
|
frame := s.rtcpReceivers[trackId].report() |
|
|
|
|
|
|
|
streamerUdpListenerPairs[trackId].rtcpl.writeChan <- &udpAddrBufPair{ |
|
|
|
|
|
|
|
addr: &net.UDPAddr{ |
|
|
|
|
|
|
|
IP: conn.NetConn().RemoteAddr().(*net.TCPAddr).IP, |
|
|
|
|
|
|
|
Zone: conn.NetConn().RemoteAddr().(*net.TCPAddr).Zone, |
|
|
|
|
|
|
|
Port: streamerUdpListenerPairs[trackId].rtcpl.publisherPort, |
|
|
|
|
|
|
|
}, |
|
|
|
|
|
|
|
buf: frame, |
|
|
|
|
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
sendKeepaliveTicker.Stop() |
|
|
|
|
|
|
|
checkStreamTicker.Stop() |
|
|
|
|
|
|
|
receiverReportTicker.Stop() |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
s.p.events <- programEventStreamerNotReady{s} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
for _, pair := range streamerUdpListenerPairs { |
|
|
|
|
|
|
|
pair.rtpl.stop() |
|
|
|
|
|
|
|
pair.rtcpl.stop() |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
for trackId := range s.clientSdpParsed.Medias { |
|
|
|
|
|
|
|
s.rtcpReceivers[trackId].close() |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
return ret |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
func (s *streamer) runTcp(conn *gortsplib.ConnClient) bool { |
|
|
|
func (s *streamer) runTcp(conn *gortsplib.ConnClient) bool { |
|
|
|
@ -536,7 +566,7 @@ func (s *streamer) runTcp(conn *gortsplib.ConnClient) bool { |
|
|
|
|
|
|
|
|
|
|
|
frame := &gortsplib.InterleavedFrame{} |
|
|
|
frame := &gortsplib.InterleavedFrame{} |
|
|
|
|
|
|
|
|
|
|
|
outer: |
|
|
|
outer1: |
|
|
|
for { |
|
|
|
for { |
|
|
|
frame.Content = s.readBuf.swap() |
|
|
|
frame.Content = s.readBuf.swap() |
|
|
|
frame.Content = frame.Content[:cap(frame.Content)] |
|
|
|
frame.Content = frame.Content[:cap(frame.Content)] |
|
|
|
@ -553,18 +583,19 @@ outer: |
|
|
|
s.log("ERR: PLAY returned code %d (%s)", recvt.StatusCode, recvt.StatusMessage) |
|
|
|
s.log("ERR: PLAY returned code %d (%s)", recvt.StatusCode, recvt.StatusMessage) |
|
|
|
return true |
|
|
|
return true |
|
|
|
} |
|
|
|
} |
|
|
|
break outer |
|
|
|
break outer1 |
|
|
|
|
|
|
|
|
|
|
|
case *gortsplib.InterleavedFrame: |
|
|
|
case *gortsplib.InterleavedFrame: |
|
|
|
// ignore the frames sent before the response
|
|
|
|
// ignore the frames sent before the response
|
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
s.p.events <- programEventStreamerReady{s} |
|
|
|
s.rtcpReceivers = make([]*rtcpReceiver, len(s.clientSdpParsed.Medias)) |
|
|
|
|
|
|
|
for trackId := range s.clientSdpParsed.Medias { |
|
|
|
|
|
|
|
s.rtcpReceivers[trackId] = newRtcpReceiver() |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
defer func() { |
|
|
|
s.p.events <- programEventStreamerReady{s} |
|
|
|
s.p.events <- programEventStreamerNotReady{s} |
|
|
|
|
|
|
|
}() |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
chanConnError := make(chan struct{}) |
|
|
|
chanConnError := make(chan struct{}) |
|
|
|
go func() { |
|
|
|
go func() { |
|
|
|
@ -580,16 +611,60 @@ outer: |
|
|
|
|
|
|
|
|
|
|
|
trackId, trackFlowType := interleavedChannelToTrackFlowType(frame.Channel) |
|
|
|
trackId, trackFlowType := interleavedChannelToTrackFlowType(frame.Channel) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
s.rtcpReceivers[trackId].onFrame(trackFlowType, frame.Content) |
|
|
|
s.p.events <- programEventStreamerFrame{s, trackId, trackFlowType, frame.Content} |
|
|
|
s.p.events <- programEventStreamerFrame{s, trackId, trackFlowType, frame.Content} |
|
|
|
} |
|
|
|
} |
|
|
|
}() |
|
|
|
}() |
|
|
|
|
|
|
|
|
|
|
|
select { |
|
|
|
checkStreamTicker := time.NewTicker(_STREAMER_CHECK_STREAM_INTERVAL) |
|
|
|
case <-s.terminate: |
|
|
|
receiverReportTicker := time.NewTicker(_STREAMER_RECEIVER_REPORT_INTERVAL) |
|
|
|
return false |
|
|
|
|
|
|
|
case <-chanConnError: |
|
|
|
var ret bool |
|
|
|
return true |
|
|
|
|
|
|
|
|
|
|
|
outer2: |
|
|
|
|
|
|
|
for { |
|
|
|
|
|
|
|
select { |
|
|
|
|
|
|
|
case <-s.terminate: |
|
|
|
|
|
|
|
ret = false |
|
|
|
|
|
|
|
break outer2 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
case <-chanConnError: |
|
|
|
|
|
|
|
ret = true |
|
|
|
|
|
|
|
break outer2 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
case <-checkStreamTicker.C: |
|
|
|
|
|
|
|
for trackId := range s.clientSdpParsed.Medias { |
|
|
|
|
|
|
|
if time.Since(s.rtcpReceivers[trackId].lastFrameTime()) >= _STREAMER_STREAM_DEAD_AFTER { |
|
|
|
|
|
|
|
s.log("ERR: stream is dead") |
|
|
|
|
|
|
|
ret = true |
|
|
|
|
|
|
|
break outer2 |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
case <-receiverReportTicker.C: |
|
|
|
|
|
|
|
for trackId := range s.clientSdpParsed.Medias { |
|
|
|
|
|
|
|
frame := s.rtcpReceivers[trackId].report() |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
channel := trackFlowTypeToInterleavedChannel(trackId, _TRACK_FLOW_TYPE_RTCP) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
conn.WriteInterleavedFrame(&gortsplib.InterleavedFrame{ |
|
|
|
|
|
|
|
Channel: channel, |
|
|
|
|
|
|
|
Content: frame, |
|
|
|
|
|
|
|
}) |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
checkStreamTicker.Stop() |
|
|
|
|
|
|
|
receiverReportTicker.Stop() |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
s.p.events <- programEventStreamerNotReady{s} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
for trackId := range s.clientSdpParsed.Medias { |
|
|
|
|
|
|
|
s.rtcpReceivers[trackId].close() |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
return ret |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
func (s *streamer) close() { |
|
|
|
func (s *streamer) close() { |
|
|
|
|
aler9
5 years ago