From 290e100d0d8215a67f6ade1d0e2311afd1dce35c Mon Sep 17 00:00:00 2001 From: David Zhao Date: Sat, 6 Feb 2021 23:15:30 -0800 Subject: [PATCH] fix generation --- pkg/rtc/participant.go | 8 +- pkg/rtc/receiver.go | 99 --- pkg/rtc/types/typesfakes/fake_down_track.go | 755 ------------------- pkg/rtc/types/typesfakes/fake_participant.go | 133 ++-- pkg/rtc/types/typesfakes/fake_receiver.go | 192 ----- 5 files changed, 73 insertions(+), 1114 deletions(-) delete mode 100644 pkg/rtc/receiver.go delete mode 100644 pkg/rtc/types/typesfakes/fake_down_track.go delete mode 100644 pkg/rtc/types/typesfakes/fake_receiver.go diff --git a/pkg/rtc/participant.go b/pkg/rtc/participant.go index b12ac767a..6fc1a1057 100644 --- a/pkg/rtc/participant.go +++ b/pkg/rtc/participant.go @@ -470,7 +470,13 @@ func (p *ParticipantImpl) RemoveSubscribedTrack(pubId string, subTrack types.Sub "participant", p.Identity()) p.lock.Lock() defer p.lock.Unlock() - p.subscribedTracks[pubId] = funk.Without(p.subscribedTracks[pubId], subTrack).([]types.SubscribedTrack) + tracks := make([]types.SubscribedTrack, 0, len(p.subscribedTracks[pubId])) + for _, tr := range p.subscribedTracks[pubId] { + if tr != subTrack { + tracks = append(tracks, tr) + } + } + p.subscribedTracks[pubId] = tracks } func (p *ParticipantImpl) scheduleNegotiate() { diff --git a/pkg/rtc/receiver.go b/pkg/rtc/receiver.go deleted file mode 100644 index 84b779ca9..000000000 --- a/pkg/rtc/receiver.go +++ /dev/null @@ -1,99 +0,0 @@ -package rtc - -import ( - "github.com/pion/ion-sfu/pkg/buffer" - "github.com/pion/rtcp" - "github.com/pion/rtp" - "github.com/pion/webrtc/v3" - - "github.com/livekit/livekit-server/pkg/logger" - "github.com/livekit/livekit-server/pkg/utils" -) - -const ( - // TODO: could probably increase this depending on Configuration/memory - maxChanSize = 1024 -) - -// A receiver is responsible for pulling from a single logical track -type ReceiverImpl struct { - rtpReceiver *webrtc.RTPReceiver - track *webrtc.TrackRemote - buffer *buffer.Buffer - rtcpReader *buffer.RTCPReader - rtcpChan *utils.CalmChannel -} - -func NewReceiver(rtcpCh *utils.CalmChannel, rtpReceiver *webrtc.RTPReceiver, track *webrtc.TrackRemote, config ReceiverConfig) *ReceiverImpl { - r := &ReceiverImpl{ - rtpReceiver: rtpReceiver, - rtcpChan: rtcpCh, - track: track, - } - - r.buffer, r.rtcpReader = bufferFactory.GetBufferPair(uint32(track.SSRC())) - - // when we have feedback for the sender, send through the rtcp channel - r.buffer.OnFeedback(func(fb []rtcp.Packet) { - RecoverSilent() - // rtcpChan could be closed - if r.rtcpChan != nil { - r.rtcpChan.Write(fb) - } - }) - - r.buffer.OnTransportWideCC(func(sn uint16, timeNS int64, marker bool) { - // TODO: figure out how to handle this - }) - - r.buffer.Bind(rtpReceiver.GetParameters(), buffer.Options{ - BufferTime: config.maxBufferTime, - MaxBitRate: config.maxBitrate, - }) - - // received sender updates - r.rtcpReader.OnPacket(func(bytes []byte) { - pkts, err := rtcp.Unmarshal(bytes) - if err != nil { - logger.Warnw("could not unmarshal RTCP packet") - return - } - for _, pkt := range pkts { - switch p := pkt.(type) { - case *rtcp.SenderReport: - r.buffer.SetSenderReportData(p.RTPTime, p.NTPTime) - case *rtcp.SourceDescription: - // TODO: see what we'd want to do with this - } - } - }) - - return r -} - -func (r *ReceiverImpl) Close() { - r.rtcpChan = nil - r.buffer.OnFeedback(nil) - r.buffer.Close() - r.rtpReceiver.Stop() - r.rtcpReader.Close() -} - -// PacketBuffer interface, retrieves a packet from buffer and deserializes -// it's possible that the packet can't be found, or the connection has been closed (io.EOF) -func (r *ReceiverImpl) GetBufferedPacket(pktBuf []byte, sn uint16, snOffset uint16) (p rtp.Packet, err error) { - if pktBuf == nil { - pktBuf = make([]byte, rtpPacketMaxSize) - } - size, err := r.buffer.GetPacket(pktBuf, sn+snOffset) - if err != nil { - return - } - - err = p.Unmarshal(pktBuf[:size]) - return -} - -func (r *ReceiverImpl) RTPChan() <-chan buffer.ExtPacket { - return r.buffer.PacketChan() -} diff --git a/pkg/rtc/types/typesfakes/fake_down_track.go b/pkg/rtc/types/typesfakes/fake_down_track.go deleted file mode 100644 index b96a0b06d..000000000 --- a/pkg/rtc/types/typesfakes/fake_down_track.go +++ /dev/null @@ -1,755 +0,0 @@ -// Code generated by counterfeiter. DO NOT EDIT. -package typesfakes - -import ( - "sync" - - "github.com/livekit/livekit-server/pkg/rtc/types" - "github.com/pion/rtcp" - "github.com/pion/rtp" -) - -type FakeDownTrack struct { - CloseStub func() - closeMutex sync.RWMutex - closeArgsForCall []struct { - } - CreateSourceDescriptionChunksStub func() []rtcp.SourceDescriptionChunk - createSourceDescriptionChunksMutex sync.RWMutex - createSourceDescriptionChunksArgsForCall []struct { - } - createSourceDescriptionChunksReturns struct { - result1 []rtcp.SourceDescriptionChunk - } - createSourceDescriptionChunksReturnsOnCall map[int]struct { - result1 []rtcp.SourceDescriptionChunk - } - GetNACKSeqNoStub func([]uint16) []uint16 - getNACKSeqNoMutex sync.RWMutex - getNACKSeqNoArgsForCall []struct { - arg1 []uint16 - } - getNACKSeqNoReturns struct { - result1 []uint16 - } - getNACKSeqNoReturnsOnCall map[int]struct { - result1 []uint16 - } - IDStub func() string - iDMutex sync.RWMutex - iDArgsForCall []struct { - } - iDReturns struct { - result1 string - } - iDReturnsOnCall map[int]struct { - result1 string - } - IsBoundStub func() bool - isBoundMutex sync.RWMutex - isBoundArgsForCall []struct { - } - isBoundReturns struct { - result1 bool - } - isBoundReturnsOnCall map[int]struct { - result1 bool - } - LastSSRCStub func() uint32 - lastSSRCMutex sync.RWMutex - lastSSRCArgsForCall []struct { - } - lastSSRCReturns struct { - result1 uint32 - } - lastSSRCReturnsOnCall map[int]struct { - result1 uint32 - } - OnBindStub func(func()) - onBindMutex sync.RWMutex - onBindArgsForCall []struct { - arg1 func() - } - OnCloseHandlerStub func(func()) - onCloseHandlerMutex sync.RWMutex - onCloseHandlerArgsForCall []struct { - arg1 func() - } - SSRCStub func() uint32 - sSRCMutex sync.RWMutex - sSRCArgsForCall []struct { - } - sSRCReturns struct { - result1 uint32 - } - sSRCReturnsOnCall map[int]struct { - result1 uint32 - } - SnOffsetStub func() uint16 - snOffsetMutex sync.RWMutex - snOffsetArgsForCall []struct { - } - snOffsetReturns struct { - result1 uint16 - } - snOffsetReturnsOnCall map[int]struct { - result1 uint16 - } - TsOffsetStub func() uint32 - tsOffsetMutex sync.RWMutex - tsOffsetArgsForCall []struct { - } - tsOffsetReturns struct { - result1 uint32 - } - tsOffsetReturnsOnCall map[int]struct { - result1 uint32 - } - WriteRTPStub func(rtp.Packet) error - writeRTPMutex sync.RWMutex - writeRTPArgsForCall []struct { - arg1 rtp.Packet - } - writeRTPReturns struct { - result1 error - } - writeRTPReturnsOnCall map[int]struct { - result1 error - } - invocations map[string][][]interface{} - invocationsMutex sync.RWMutex -} - -func (fake *FakeDownTrack) Close() { - fake.closeMutex.Lock() - fake.closeArgsForCall = append(fake.closeArgsForCall, struct { - }{}) - stub := fake.CloseStub - fake.recordInvocation("Close", []interface{}{}) - fake.closeMutex.Unlock() - if stub != nil { - fake.CloseStub() - } -} - -func (fake *FakeDownTrack) CloseCallCount() int { - fake.closeMutex.RLock() - defer fake.closeMutex.RUnlock() - return len(fake.closeArgsForCall) -} - -func (fake *FakeDownTrack) CloseCalls(stub func()) { - fake.closeMutex.Lock() - defer fake.closeMutex.Unlock() - fake.CloseStub = stub -} - -func (fake *FakeDownTrack) CreateSourceDescriptionChunks() []rtcp.SourceDescriptionChunk { - fake.createSourceDescriptionChunksMutex.Lock() - ret, specificReturn := fake.createSourceDescriptionChunksReturnsOnCall[len(fake.createSourceDescriptionChunksArgsForCall)] - fake.createSourceDescriptionChunksArgsForCall = append(fake.createSourceDescriptionChunksArgsForCall, struct { - }{}) - stub := fake.CreateSourceDescriptionChunksStub - fakeReturns := fake.createSourceDescriptionChunksReturns - fake.recordInvocation("CreateSourceDescriptionChunks", []interface{}{}) - fake.createSourceDescriptionChunksMutex.Unlock() - if stub != nil { - return stub() - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeDownTrack) CreateSourceDescriptionChunksCallCount() int { - fake.createSourceDescriptionChunksMutex.RLock() - defer fake.createSourceDescriptionChunksMutex.RUnlock() - return len(fake.createSourceDescriptionChunksArgsForCall) -} - -func (fake *FakeDownTrack) CreateSourceDescriptionChunksCalls(stub func() []rtcp.SourceDescriptionChunk) { - fake.createSourceDescriptionChunksMutex.Lock() - defer fake.createSourceDescriptionChunksMutex.Unlock() - fake.CreateSourceDescriptionChunksStub = stub -} - -func (fake *FakeDownTrack) CreateSourceDescriptionChunksReturns(result1 []rtcp.SourceDescriptionChunk) { - fake.createSourceDescriptionChunksMutex.Lock() - defer fake.createSourceDescriptionChunksMutex.Unlock() - fake.CreateSourceDescriptionChunksStub = nil - fake.createSourceDescriptionChunksReturns = struct { - result1 []rtcp.SourceDescriptionChunk - }{result1} -} - -func (fake *FakeDownTrack) CreateSourceDescriptionChunksReturnsOnCall(i int, result1 []rtcp.SourceDescriptionChunk) { - fake.createSourceDescriptionChunksMutex.Lock() - defer fake.createSourceDescriptionChunksMutex.Unlock() - fake.CreateSourceDescriptionChunksStub = nil - if fake.createSourceDescriptionChunksReturnsOnCall == nil { - fake.createSourceDescriptionChunksReturnsOnCall = make(map[int]struct { - result1 []rtcp.SourceDescriptionChunk - }) - } - fake.createSourceDescriptionChunksReturnsOnCall[i] = struct { - result1 []rtcp.SourceDescriptionChunk - }{result1} -} - -func (fake *FakeDownTrack) GetNACKSeqNo(arg1 []uint16) []uint16 { - var arg1Copy []uint16 - if arg1 != nil { - arg1Copy = make([]uint16, len(arg1)) - copy(arg1Copy, arg1) - } - fake.getNACKSeqNoMutex.Lock() - ret, specificReturn := fake.getNACKSeqNoReturnsOnCall[len(fake.getNACKSeqNoArgsForCall)] - fake.getNACKSeqNoArgsForCall = append(fake.getNACKSeqNoArgsForCall, struct { - arg1 []uint16 - }{arg1Copy}) - stub := fake.GetNACKSeqNoStub - fakeReturns := fake.getNACKSeqNoReturns - fake.recordInvocation("GetNACKSeqNo", []interface{}{arg1Copy}) - fake.getNACKSeqNoMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeDownTrack) GetNACKSeqNoCallCount() int { - fake.getNACKSeqNoMutex.RLock() - defer fake.getNACKSeqNoMutex.RUnlock() - return len(fake.getNACKSeqNoArgsForCall) -} - -func (fake *FakeDownTrack) GetNACKSeqNoCalls(stub func([]uint16) []uint16) { - fake.getNACKSeqNoMutex.Lock() - defer fake.getNACKSeqNoMutex.Unlock() - fake.GetNACKSeqNoStub = stub -} - -func (fake *FakeDownTrack) GetNACKSeqNoArgsForCall(i int) []uint16 { - fake.getNACKSeqNoMutex.RLock() - defer fake.getNACKSeqNoMutex.RUnlock() - argsForCall := fake.getNACKSeqNoArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeDownTrack) GetNACKSeqNoReturns(result1 []uint16) { - fake.getNACKSeqNoMutex.Lock() - defer fake.getNACKSeqNoMutex.Unlock() - fake.GetNACKSeqNoStub = nil - fake.getNACKSeqNoReturns = struct { - result1 []uint16 - }{result1} -} - -func (fake *FakeDownTrack) GetNACKSeqNoReturnsOnCall(i int, result1 []uint16) { - fake.getNACKSeqNoMutex.Lock() - defer fake.getNACKSeqNoMutex.Unlock() - fake.GetNACKSeqNoStub = nil - if fake.getNACKSeqNoReturnsOnCall == nil { - fake.getNACKSeqNoReturnsOnCall = make(map[int]struct { - result1 []uint16 - }) - } - fake.getNACKSeqNoReturnsOnCall[i] = struct { - result1 []uint16 - }{result1} -} - -func (fake *FakeDownTrack) ID() string { - fake.iDMutex.Lock() - ret, specificReturn := fake.iDReturnsOnCall[len(fake.iDArgsForCall)] - fake.iDArgsForCall = append(fake.iDArgsForCall, struct { - }{}) - stub := fake.IDStub - fakeReturns := fake.iDReturns - fake.recordInvocation("ID", []interface{}{}) - fake.iDMutex.Unlock() - if stub != nil { - return stub() - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeDownTrack) IDCallCount() int { - fake.iDMutex.RLock() - defer fake.iDMutex.RUnlock() - return len(fake.iDArgsForCall) -} - -func (fake *FakeDownTrack) IDCalls(stub func() string) { - fake.iDMutex.Lock() - defer fake.iDMutex.Unlock() - fake.IDStub = stub -} - -func (fake *FakeDownTrack) IDReturns(result1 string) { - fake.iDMutex.Lock() - defer fake.iDMutex.Unlock() - fake.IDStub = nil - fake.iDReturns = struct { - result1 string - }{result1} -} - -func (fake *FakeDownTrack) IDReturnsOnCall(i int, result1 string) { - fake.iDMutex.Lock() - defer fake.iDMutex.Unlock() - fake.IDStub = nil - if fake.iDReturnsOnCall == nil { - fake.iDReturnsOnCall = make(map[int]struct { - result1 string - }) - } - fake.iDReturnsOnCall[i] = struct { - result1 string - }{result1} -} - -func (fake *FakeDownTrack) IsBound() bool { - fake.isBoundMutex.Lock() - ret, specificReturn := fake.isBoundReturnsOnCall[len(fake.isBoundArgsForCall)] - fake.isBoundArgsForCall = append(fake.isBoundArgsForCall, struct { - }{}) - stub := fake.IsBoundStub - fakeReturns := fake.isBoundReturns - fake.recordInvocation("IsBound", []interface{}{}) - fake.isBoundMutex.Unlock() - if stub != nil { - return stub() - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeDownTrack) IsBoundCallCount() int { - fake.isBoundMutex.RLock() - defer fake.isBoundMutex.RUnlock() - return len(fake.isBoundArgsForCall) -} - -func (fake *FakeDownTrack) IsBoundCalls(stub func() bool) { - fake.isBoundMutex.Lock() - defer fake.isBoundMutex.Unlock() - fake.IsBoundStub = stub -} - -func (fake *FakeDownTrack) IsBoundReturns(result1 bool) { - fake.isBoundMutex.Lock() - defer fake.isBoundMutex.Unlock() - fake.IsBoundStub = nil - fake.isBoundReturns = struct { - result1 bool - }{result1} -} - -func (fake *FakeDownTrack) IsBoundReturnsOnCall(i int, result1 bool) { - fake.isBoundMutex.Lock() - defer fake.isBoundMutex.Unlock() - fake.IsBoundStub = nil - if fake.isBoundReturnsOnCall == nil { - fake.isBoundReturnsOnCall = make(map[int]struct { - result1 bool - }) - } - fake.isBoundReturnsOnCall[i] = struct { - result1 bool - }{result1} -} - -func (fake *FakeDownTrack) LastSSRC() uint32 { - fake.lastSSRCMutex.Lock() - ret, specificReturn := fake.lastSSRCReturnsOnCall[len(fake.lastSSRCArgsForCall)] - fake.lastSSRCArgsForCall = append(fake.lastSSRCArgsForCall, struct { - }{}) - stub := fake.LastSSRCStub - fakeReturns := fake.lastSSRCReturns - fake.recordInvocation("LastSSRC", []interface{}{}) - fake.lastSSRCMutex.Unlock() - if stub != nil { - return stub() - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeDownTrack) LastSSRCCallCount() int { - fake.lastSSRCMutex.RLock() - defer fake.lastSSRCMutex.RUnlock() - return len(fake.lastSSRCArgsForCall) -} - -func (fake *FakeDownTrack) LastSSRCCalls(stub func() uint32) { - fake.lastSSRCMutex.Lock() - defer fake.lastSSRCMutex.Unlock() - fake.LastSSRCStub = stub -} - -func (fake *FakeDownTrack) LastSSRCReturns(result1 uint32) { - fake.lastSSRCMutex.Lock() - defer fake.lastSSRCMutex.Unlock() - fake.LastSSRCStub = nil - fake.lastSSRCReturns = struct { - result1 uint32 - }{result1} -} - -func (fake *FakeDownTrack) LastSSRCReturnsOnCall(i int, result1 uint32) { - fake.lastSSRCMutex.Lock() - defer fake.lastSSRCMutex.Unlock() - fake.LastSSRCStub = nil - if fake.lastSSRCReturnsOnCall == nil { - fake.lastSSRCReturnsOnCall = make(map[int]struct { - result1 uint32 - }) - } - fake.lastSSRCReturnsOnCall[i] = struct { - result1 uint32 - }{result1} -} - -func (fake *FakeDownTrack) OnBind(arg1 func()) { - fake.onBindMutex.Lock() - fake.onBindArgsForCall = append(fake.onBindArgsForCall, struct { - arg1 func() - }{arg1}) - stub := fake.OnBindStub - fake.recordInvocation("OnBind", []interface{}{arg1}) - fake.onBindMutex.Unlock() - if stub != nil { - fake.OnBindStub(arg1) - } -} - -func (fake *FakeDownTrack) OnBindCallCount() int { - fake.onBindMutex.RLock() - defer fake.onBindMutex.RUnlock() - return len(fake.onBindArgsForCall) -} - -func (fake *FakeDownTrack) OnBindCalls(stub func(func())) { - fake.onBindMutex.Lock() - defer fake.onBindMutex.Unlock() - fake.OnBindStub = stub -} - -func (fake *FakeDownTrack) OnBindArgsForCall(i int) func() { - fake.onBindMutex.RLock() - defer fake.onBindMutex.RUnlock() - argsForCall := fake.onBindArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeDownTrack) OnCloseHandler(arg1 func()) { - fake.onCloseHandlerMutex.Lock() - fake.onCloseHandlerArgsForCall = append(fake.onCloseHandlerArgsForCall, struct { - arg1 func() - }{arg1}) - stub := fake.OnCloseHandlerStub - fake.recordInvocation("OnCloseHandler", []interface{}{arg1}) - fake.onCloseHandlerMutex.Unlock() - if stub != nil { - fake.OnCloseHandlerStub(arg1) - } -} - -func (fake *FakeDownTrack) OnCloseHandlerCallCount() int { - fake.onCloseHandlerMutex.RLock() - defer fake.onCloseHandlerMutex.RUnlock() - return len(fake.onCloseHandlerArgsForCall) -} - -func (fake *FakeDownTrack) OnCloseHandlerCalls(stub func(func())) { - fake.onCloseHandlerMutex.Lock() - defer fake.onCloseHandlerMutex.Unlock() - fake.OnCloseHandlerStub = stub -} - -func (fake *FakeDownTrack) OnCloseHandlerArgsForCall(i int) func() { - fake.onCloseHandlerMutex.RLock() - defer fake.onCloseHandlerMutex.RUnlock() - argsForCall := fake.onCloseHandlerArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeDownTrack) SSRC() uint32 { - fake.sSRCMutex.Lock() - ret, specificReturn := fake.sSRCReturnsOnCall[len(fake.sSRCArgsForCall)] - fake.sSRCArgsForCall = append(fake.sSRCArgsForCall, struct { - }{}) - stub := fake.SSRCStub - fakeReturns := fake.sSRCReturns - fake.recordInvocation("SSRC", []interface{}{}) - fake.sSRCMutex.Unlock() - if stub != nil { - return stub() - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeDownTrack) SSRCCallCount() int { - fake.sSRCMutex.RLock() - defer fake.sSRCMutex.RUnlock() - return len(fake.sSRCArgsForCall) -} - -func (fake *FakeDownTrack) SSRCCalls(stub func() uint32) { - fake.sSRCMutex.Lock() - defer fake.sSRCMutex.Unlock() - fake.SSRCStub = stub -} - -func (fake *FakeDownTrack) SSRCReturns(result1 uint32) { - fake.sSRCMutex.Lock() - defer fake.sSRCMutex.Unlock() - fake.SSRCStub = nil - fake.sSRCReturns = struct { - result1 uint32 - }{result1} -} - -func (fake *FakeDownTrack) SSRCReturnsOnCall(i int, result1 uint32) { - fake.sSRCMutex.Lock() - defer fake.sSRCMutex.Unlock() - fake.SSRCStub = nil - if fake.sSRCReturnsOnCall == nil { - fake.sSRCReturnsOnCall = make(map[int]struct { - result1 uint32 - }) - } - fake.sSRCReturnsOnCall[i] = struct { - result1 uint32 - }{result1} -} - -func (fake *FakeDownTrack) SnOffset() uint16 { - fake.snOffsetMutex.Lock() - ret, specificReturn := fake.snOffsetReturnsOnCall[len(fake.snOffsetArgsForCall)] - fake.snOffsetArgsForCall = append(fake.snOffsetArgsForCall, struct { - }{}) - stub := fake.SnOffsetStub - fakeReturns := fake.snOffsetReturns - fake.recordInvocation("SnOffset", []interface{}{}) - fake.snOffsetMutex.Unlock() - if stub != nil { - return stub() - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeDownTrack) SnOffsetCallCount() int { - fake.snOffsetMutex.RLock() - defer fake.snOffsetMutex.RUnlock() - return len(fake.snOffsetArgsForCall) -} - -func (fake *FakeDownTrack) SnOffsetCalls(stub func() uint16) { - fake.snOffsetMutex.Lock() - defer fake.snOffsetMutex.Unlock() - fake.SnOffsetStub = stub -} - -func (fake *FakeDownTrack) SnOffsetReturns(result1 uint16) { - fake.snOffsetMutex.Lock() - defer fake.snOffsetMutex.Unlock() - fake.SnOffsetStub = nil - fake.snOffsetReturns = struct { - result1 uint16 - }{result1} -} - -func (fake *FakeDownTrack) SnOffsetReturnsOnCall(i int, result1 uint16) { - fake.snOffsetMutex.Lock() - defer fake.snOffsetMutex.Unlock() - fake.SnOffsetStub = nil - if fake.snOffsetReturnsOnCall == nil { - fake.snOffsetReturnsOnCall = make(map[int]struct { - result1 uint16 - }) - } - fake.snOffsetReturnsOnCall[i] = struct { - result1 uint16 - }{result1} -} - -func (fake *FakeDownTrack) TsOffset() uint32 { - fake.tsOffsetMutex.Lock() - ret, specificReturn := fake.tsOffsetReturnsOnCall[len(fake.tsOffsetArgsForCall)] - fake.tsOffsetArgsForCall = append(fake.tsOffsetArgsForCall, struct { - }{}) - stub := fake.TsOffsetStub - fakeReturns := fake.tsOffsetReturns - fake.recordInvocation("TsOffset", []interface{}{}) - fake.tsOffsetMutex.Unlock() - if stub != nil { - return stub() - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeDownTrack) TsOffsetCallCount() int { - fake.tsOffsetMutex.RLock() - defer fake.tsOffsetMutex.RUnlock() - return len(fake.tsOffsetArgsForCall) -} - -func (fake *FakeDownTrack) TsOffsetCalls(stub func() uint32) { - fake.tsOffsetMutex.Lock() - defer fake.tsOffsetMutex.Unlock() - fake.TsOffsetStub = stub -} - -func (fake *FakeDownTrack) TsOffsetReturns(result1 uint32) { - fake.tsOffsetMutex.Lock() - defer fake.tsOffsetMutex.Unlock() - fake.TsOffsetStub = nil - fake.tsOffsetReturns = struct { - result1 uint32 - }{result1} -} - -func (fake *FakeDownTrack) TsOffsetReturnsOnCall(i int, result1 uint32) { - fake.tsOffsetMutex.Lock() - defer fake.tsOffsetMutex.Unlock() - fake.TsOffsetStub = nil - if fake.tsOffsetReturnsOnCall == nil { - fake.tsOffsetReturnsOnCall = make(map[int]struct { - result1 uint32 - }) - } - fake.tsOffsetReturnsOnCall[i] = struct { - result1 uint32 - }{result1} -} - -func (fake *FakeDownTrack) WriteRTP(arg1 rtp.Packet) error { - fake.writeRTPMutex.Lock() - ret, specificReturn := fake.writeRTPReturnsOnCall[len(fake.writeRTPArgsForCall)] - fake.writeRTPArgsForCall = append(fake.writeRTPArgsForCall, struct { - arg1 rtp.Packet - }{arg1}) - stub := fake.WriteRTPStub - fakeReturns := fake.writeRTPReturns - fake.recordInvocation("WriteRTP", []interface{}{arg1}) - fake.writeRTPMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeDownTrack) WriteRTPCallCount() int { - fake.writeRTPMutex.RLock() - defer fake.writeRTPMutex.RUnlock() - return len(fake.writeRTPArgsForCall) -} - -func (fake *FakeDownTrack) WriteRTPCalls(stub func(rtp.Packet) error) { - fake.writeRTPMutex.Lock() - defer fake.writeRTPMutex.Unlock() - fake.WriteRTPStub = stub -} - -func (fake *FakeDownTrack) WriteRTPArgsForCall(i int) rtp.Packet { - fake.writeRTPMutex.RLock() - defer fake.writeRTPMutex.RUnlock() - argsForCall := fake.writeRTPArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeDownTrack) WriteRTPReturns(result1 error) { - fake.writeRTPMutex.Lock() - defer fake.writeRTPMutex.Unlock() - fake.WriteRTPStub = nil - fake.writeRTPReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeDownTrack) WriteRTPReturnsOnCall(i int, result1 error) { - fake.writeRTPMutex.Lock() - defer fake.writeRTPMutex.Unlock() - fake.WriteRTPStub = nil - if fake.writeRTPReturnsOnCall == nil { - fake.writeRTPReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.writeRTPReturnsOnCall[i] = struct { - result1 error - }{result1} -} - -func (fake *FakeDownTrack) Invocations() map[string][][]interface{} { - fake.invocationsMutex.RLock() - defer fake.invocationsMutex.RUnlock() - fake.closeMutex.RLock() - defer fake.closeMutex.RUnlock() - fake.createSourceDescriptionChunksMutex.RLock() - defer fake.createSourceDescriptionChunksMutex.RUnlock() - fake.getNACKSeqNoMutex.RLock() - defer fake.getNACKSeqNoMutex.RUnlock() - fake.iDMutex.RLock() - defer fake.iDMutex.RUnlock() - fake.isBoundMutex.RLock() - defer fake.isBoundMutex.RUnlock() - fake.lastSSRCMutex.RLock() - defer fake.lastSSRCMutex.RUnlock() - fake.onBindMutex.RLock() - defer fake.onBindMutex.RUnlock() - fake.onCloseHandlerMutex.RLock() - defer fake.onCloseHandlerMutex.RUnlock() - fake.sSRCMutex.RLock() - defer fake.sSRCMutex.RUnlock() - fake.snOffsetMutex.RLock() - defer fake.snOffsetMutex.RUnlock() - fake.tsOffsetMutex.RLock() - defer fake.tsOffsetMutex.RUnlock() - fake.writeRTPMutex.RLock() - defer fake.writeRTPMutex.RUnlock() - copiedInvocations := map[string][][]interface{}{} - for key, value := range fake.invocations { - copiedInvocations[key] = value - } - return copiedInvocations -} - -func (fake *FakeDownTrack) recordInvocation(key string, args []interface{}) { - fake.invocationsMutex.Lock() - defer fake.invocationsMutex.Unlock() - if fake.invocations == nil { - fake.invocations = map[string][][]interface{}{} - } - if fake.invocations[key] == nil { - fake.invocations[key] = [][]interface{}{} - } - fake.invocations[key] = append(fake.invocations[key], args) -} - -var _ types.DownTrack = new(FakeDownTrack) diff --git a/pkg/rtc/types/typesfakes/fake_participant.go b/pkg/rtc/types/typesfakes/fake_participant.go index 34d1ad8e7..acedc6451 100644 --- a/pkg/rtc/types/typesfakes/fake_participant.go +++ b/pkg/rtc/types/typesfakes/fake_participant.go @@ -7,18 +7,11 @@ import ( "github.com/livekit/livekit-server/pkg/routing" "github.com/livekit/livekit-server/pkg/rtc/types" "github.com/livekit/livekit-server/proto/livekit" - "github.com/pion/ion-sfu/pkg/sfu" "github.com/pion/rtcp" webrtc "github.com/pion/webrtc/v3" ) type FakeParticipant struct { - AddDownTrackStub func(string, *sfu.DownTrack) - addDownTrackMutex sync.RWMutex - addDownTrackArgsForCall []struct { - arg1 string - arg2 *sfu.DownTrack - } AddICECandidateStub func(webrtc.ICECandidateInit) error addICECandidateMutex sync.RWMutex addICECandidateArgsForCall []struct { @@ -30,6 +23,12 @@ type FakeParticipant struct { addICECandidateReturnsOnCall map[int]struct { result1 error } + AddSubscribedTrackStub func(string, types.SubscribedTrack) + addSubscribedTrackMutex sync.RWMutex + addSubscribedTrackArgsForCall []struct { + arg1 string + arg2 types.SubscribedTrack + } AddSubscriberStub func(types.Participant) error addSubscriberMutex sync.RWMutex addSubscriberArgsForCall []struct { @@ -171,11 +170,11 @@ type FakeParticipant struct { rTCPChanReturnsOnCall map[int]struct { result1 chan []rtcp.Packet } - RemoveDownTrackStub func(string, *sfu.DownTrack) - removeDownTrackMutex sync.RWMutex - removeDownTrackArgsForCall []struct { + RemoveSubscribedTrackStub func(string, types.SubscribedTrack) + removeSubscribedTrackMutex sync.RWMutex + removeSubscribedTrackArgsForCall []struct { arg1 string - arg2 *sfu.DownTrack + arg2 types.SubscribedTrack } RemoveSubscriberStub func(string) removeSubscriberMutex sync.RWMutex @@ -244,39 +243,6 @@ type FakeParticipant struct { invocationsMutex sync.RWMutex } -func (fake *FakeParticipant) AddSubscribedTrack(arg1 string, arg2 *sfu.DownTrack) { - fake.addDownTrackMutex.Lock() - fake.addDownTrackArgsForCall = append(fake.addDownTrackArgsForCall, struct { - arg1 string - arg2 *sfu.DownTrack - }{arg1, arg2}) - stub := fake.AddDownTrackStub - fake.recordInvocation("AddSubscribedTrack", []interface{}{arg1, arg2}) - fake.addDownTrackMutex.Unlock() - if stub != nil { - fake.AddDownTrackStub(arg1, arg2) - } -} - -func (fake *FakeParticipant) AddDownTrackCallCount() int { - fake.addDownTrackMutex.RLock() - defer fake.addDownTrackMutex.RUnlock() - return len(fake.addDownTrackArgsForCall) -} - -func (fake *FakeParticipant) AddDownTrackCalls(stub func(string, *sfu.DownTrack)) { - fake.addDownTrackMutex.Lock() - defer fake.addDownTrackMutex.Unlock() - fake.AddDownTrackStub = stub -} - -func (fake *FakeParticipant) AddDownTrackArgsForCall(i int) (string, *sfu.DownTrack) { - fake.addDownTrackMutex.RLock() - defer fake.addDownTrackMutex.RUnlock() - argsForCall := fake.addDownTrackArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 -} - func (fake *FakeParticipant) AddICECandidate(arg1 webrtc.ICECandidateInit) error { fake.addICECandidateMutex.Lock() ret, specificReturn := fake.addICECandidateReturnsOnCall[len(fake.addICECandidateArgsForCall)] @@ -338,6 +304,39 @@ func (fake *FakeParticipant) AddICECandidateReturnsOnCall(i int, result1 error) }{result1} } +func (fake *FakeParticipant) AddSubscribedTrack(arg1 string, arg2 types.SubscribedTrack) { + fake.addSubscribedTrackMutex.Lock() + fake.addSubscribedTrackArgsForCall = append(fake.addSubscribedTrackArgsForCall, struct { + arg1 string + arg2 types.SubscribedTrack + }{arg1, arg2}) + stub := fake.AddSubscribedTrackStub + fake.recordInvocation("AddSubscribedTrack", []interface{}{arg1, arg2}) + fake.addSubscribedTrackMutex.Unlock() + if stub != nil { + fake.AddSubscribedTrackStub(arg1, arg2) + } +} + +func (fake *FakeParticipant) AddSubscribedTrackCallCount() int { + fake.addSubscribedTrackMutex.RLock() + defer fake.addSubscribedTrackMutex.RUnlock() + return len(fake.addSubscribedTrackArgsForCall) +} + +func (fake *FakeParticipant) AddSubscribedTrackCalls(stub func(string, types.SubscribedTrack)) { + fake.addSubscribedTrackMutex.Lock() + defer fake.addSubscribedTrackMutex.Unlock() + fake.AddSubscribedTrackStub = stub +} + +func (fake *FakeParticipant) AddSubscribedTrackArgsForCall(i int) (string, types.SubscribedTrack) { + fake.addSubscribedTrackMutex.RLock() + defer fake.addSubscribedTrackMutex.RUnlock() + argsForCall := fake.addSubscribedTrackArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + func (fake *FakeParticipant) AddSubscriber(arg1 types.Participant) error { fake.addSubscriberMutex.Lock() ret, specificReturn := fake.addSubscriberReturnsOnCall[len(fake.addSubscriberArgsForCall)] @@ -1113,36 +1112,36 @@ func (fake *FakeParticipant) RTCPChanReturnsOnCall(i int, result1 chan []rtcp.Pa }{result1} } -func (fake *FakeParticipant) RemoveDownTrack(arg1 string, arg2 *sfu.DownTrack) { - fake.removeDownTrackMutex.Lock() - fake.removeDownTrackArgsForCall = append(fake.removeDownTrackArgsForCall, struct { +func (fake *FakeParticipant) RemoveSubscribedTrack(arg1 string, arg2 types.SubscribedTrack) { + fake.removeSubscribedTrackMutex.Lock() + fake.removeSubscribedTrackArgsForCall = append(fake.removeSubscribedTrackArgsForCall, struct { arg1 string - arg2 *sfu.DownTrack + arg2 types.SubscribedTrack }{arg1, arg2}) - stub := fake.RemoveDownTrackStub + stub := fake.RemoveSubscribedTrackStub fake.recordInvocation("RemoveSubscribedTrack", []interface{}{arg1, arg2}) - fake.removeDownTrackMutex.Unlock() + fake.removeSubscribedTrackMutex.Unlock() if stub != nil { - fake.RemoveDownTrackStub(arg1, arg2) + fake.RemoveSubscribedTrackStub(arg1, arg2) } } -func (fake *FakeParticipant) RemoveDownTrackCallCount() int { - fake.removeDownTrackMutex.RLock() - defer fake.removeDownTrackMutex.RUnlock() - return len(fake.removeDownTrackArgsForCall) +func (fake *FakeParticipant) RemoveSubscribedTrackCallCount() int { + fake.removeSubscribedTrackMutex.RLock() + defer fake.removeSubscribedTrackMutex.RUnlock() + return len(fake.removeSubscribedTrackArgsForCall) } -func (fake *FakeParticipant) RemoveDownTrackCalls(stub func(string, *sfu.DownTrack)) { - fake.removeDownTrackMutex.Lock() - defer fake.removeDownTrackMutex.Unlock() - fake.RemoveDownTrackStub = stub +func (fake *FakeParticipant) RemoveSubscribedTrackCalls(stub func(string, types.SubscribedTrack)) { + fake.removeSubscribedTrackMutex.Lock() + defer fake.removeSubscribedTrackMutex.Unlock() + fake.RemoveSubscribedTrackStub = stub } -func (fake *FakeParticipant) RemoveDownTrackArgsForCall(i int) (string, *sfu.DownTrack) { - fake.removeDownTrackMutex.RLock() - defer fake.removeDownTrackMutex.RUnlock() - argsForCall := fake.removeDownTrackArgsForCall[i] +func (fake *FakeParticipant) RemoveSubscribedTrackArgsForCall(i int) (string, types.SubscribedTrack) { + fake.removeSubscribedTrackMutex.RLock() + defer fake.removeSubscribedTrackMutex.RUnlock() + argsForCall := fake.removeSubscribedTrackArgsForCall[i] return argsForCall.arg1, argsForCall.arg2 } @@ -1509,10 +1508,10 @@ func (fake *FakeParticipant) ToProtoReturnsOnCall(i int, result1 *livekit.Partic func (fake *FakeParticipant) Invocations() map[string][][]interface{} { fake.invocationsMutex.RLock() defer fake.invocationsMutex.RUnlock() - fake.addDownTrackMutex.RLock() - defer fake.addDownTrackMutex.RUnlock() fake.addICECandidateMutex.RLock() defer fake.addICECandidateMutex.RUnlock() + fake.addSubscribedTrackMutex.RLock() + defer fake.addSubscribedTrackMutex.RUnlock() fake.addSubscriberMutex.RLock() defer fake.addSubscriberMutex.RUnlock() fake.addTrackMutex.RLock() @@ -1547,8 +1546,8 @@ func (fake *FakeParticipant) Invocations() map[string][][]interface{} { defer fake.peerConnectionMutex.RUnlock() fake.rTCPChanMutex.RLock() defer fake.rTCPChanMutex.RUnlock() - fake.removeDownTrackMutex.RLock() - defer fake.removeDownTrackMutex.RUnlock() + fake.removeSubscribedTrackMutex.RLock() + defer fake.removeSubscribedTrackMutex.RUnlock() fake.removeSubscriberMutex.RLock() defer fake.removeSubscriberMutex.RUnlock() fake.sendJoinResponseMutex.RLock() diff --git a/pkg/rtc/types/typesfakes/fake_receiver.go b/pkg/rtc/types/typesfakes/fake_receiver.go deleted file mode 100644 index 173f5c945..000000000 --- a/pkg/rtc/types/typesfakes/fake_receiver.go +++ /dev/null @@ -1,192 +0,0 @@ -// Code generated by counterfeiter. DO NOT EDIT. -package typesfakes - -import ( - "sync" - - "github.com/livekit/livekit-server/pkg/rtc/types" - "github.com/pion/ion-sfu/pkg/buffer" - "github.com/pion/rtp" -) - -type FakeReceiver struct { - GetBufferedPacketStub func([]byte, uint16, uint16) (rtp.Packet, error) - getBufferedPacketMutex sync.RWMutex - getBufferedPacketArgsForCall []struct { - arg1 []byte - arg2 uint16 - arg3 uint16 - } - getBufferedPacketReturns struct { - result1 rtp.Packet - result2 error - } - getBufferedPacketReturnsOnCall map[int]struct { - result1 rtp.Packet - result2 error - } - RTPChanStub func() <-chan buffer.ExtPacket - rTPChanMutex sync.RWMutex - rTPChanArgsForCall []struct { - } - rTPChanReturns struct { - result1 <-chan buffer.ExtPacket - } - rTPChanReturnsOnCall map[int]struct { - result1 <-chan buffer.ExtPacket - } - invocations map[string][][]interface{} - invocationsMutex sync.RWMutex -} - -func (fake *FakeReceiver) GetBufferedPacket(arg1 []byte, arg2 uint16, arg3 uint16) (rtp.Packet, error) { - var arg1Copy []byte - if arg1 != nil { - arg1Copy = make([]byte, len(arg1)) - copy(arg1Copy, arg1) - } - fake.getBufferedPacketMutex.Lock() - ret, specificReturn := fake.getBufferedPacketReturnsOnCall[len(fake.getBufferedPacketArgsForCall)] - fake.getBufferedPacketArgsForCall = append(fake.getBufferedPacketArgsForCall, struct { - arg1 []byte - arg2 uint16 - arg3 uint16 - }{arg1Copy, arg2, arg3}) - stub := fake.GetBufferedPacketStub - fakeReturns := fake.getBufferedPacketReturns - fake.recordInvocation("GetBufferedPacket", []interface{}{arg1Copy, arg2, arg3}) - fake.getBufferedPacketMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeReceiver) GetBufferedPacketCallCount() int { - fake.getBufferedPacketMutex.RLock() - defer fake.getBufferedPacketMutex.RUnlock() - return len(fake.getBufferedPacketArgsForCall) -} - -func (fake *FakeReceiver) GetBufferedPacketCalls(stub func([]byte, uint16, uint16) (rtp.Packet, error)) { - fake.getBufferedPacketMutex.Lock() - defer fake.getBufferedPacketMutex.Unlock() - fake.GetBufferedPacketStub = stub -} - -func (fake *FakeReceiver) GetBufferedPacketArgsForCall(i int) ([]byte, uint16, uint16) { - fake.getBufferedPacketMutex.RLock() - defer fake.getBufferedPacketMutex.RUnlock() - argsForCall := fake.getBufferedPacketArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeReceiver) GetBufferedPacketReturns(result1 rtp.Packet, result2 error) { - fake.getBufferedPacketMutex.Lock() - defer fake.getBufferedPacketMutex.Unlock() - fake.GetBufferedPacketStub = nil - fake.getBufferedPacketReturns = struct { - result1 rtp.Packet - result2 error - }{result1, result2} -} - -func (fake *FakeReceiver) GetBufferedPacketReturnsOnCall(i int, result1 rtp.Packet, result2 error) { - fake.getBufferedPacketMutex.Lock() - defer fake.getBufferedPacketMutex.Unlock() - fake.GetBufferedPacketStub = nil - if fake.getBufferedPacketReturnsOnCall == nil { - fake.getBufferedPacketReturnsOnCall = make(map[int]struct { - result1 rtp.Packet - result2 error - }) - } - fake.getBufferedPacketReturnsOnCall[i] = struct { - result1 rtp.Packet - result2 error - }{result1, result2} -} - -func (fake *FakeReceiver) RTPChan() <-chan buffer.ExtPacket { - fake.rTPChanMutex.Lock() - ret, specificReturn := fake.rTPChanReturnsOnCall[len(fake.rTPChanArgsForCall)] - fake.rTPChanArgsForCall = append(fake.rTPChanArgsForCall, struct { - }{}) - stub := fake.RTPChanStub - fakeReturns := fake.rTPChanReturns - fake.recordInvocation("RTPChan", []interface{}{}) - fake.rTPChanMutex.Unlock() - if stub != nil { - return stub() - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeReceiver) RTPChanCallCount() int { - fake.rTPChanMutex.RLock() - defer fake.rTPChanMutex.RUnlock() - return len(fake.rTPChanArgsForCall) -} - -func (fake *FakeReceiver) RTPChanCalls(stub func() <-chan buffer.ExtPacket) { - fake.rTPChanMutex.Lock() - defer fake.rTPChanMutex.Unlock() - fake.RTPChanStub = stub -} - -func (fake *FakeReceiver) RTPChanReturns(result1 <-chan buffer.ExtPacket) { - fake.rTPChanMutex.Lock() - defer fake.rTPChanMutex.Unlock() - fake.RTPChanStub = nil - fake.rTPChanReturns = struct { - result1 <-chan buffer.ExtPacket - }{result1} -} - -func (fake *FakeReceiver) RTPChanReturnsOnCall(i int, result1 <-chan buffer.ExtPacket) { - fake.rTPChanMutex.Lock() - defer fake.rTPChanMutex.Unlock() - fake.RTPChanStub = nil - if fake.rTPChanReturnsOnCall == nil { - fake.rTPChanReturnsOnCall = make(map[int]struct { - result1 <-chan buffer.ExtPacket - }) - } - fake.rTPChanReturnsOnCall[i] = struct { - result1 <-chan buffer.ExtPacket - }{result1} -} - -func (fake *FakeReceiver) Invocations() map[string][][]interface{} { - fake.invocationsMutex.RLock() - defer fake.invocationsMutex.RUnlock() - fake.getBufferedPacketMutex.RLock() - defer fake.getBufferedPacketMutex.RUnlock() - fake.rTPChanMutex.RLock() - defer fake.rTPChanMutex.RUnlock() - copiedInvocations := map[string][][]interface{}{} - for key, value := range fake.invocations { - copiedInvocations[key] = value - } - return copiedInvocations -} - -func (fake *FakeReceiver) recordInvocation(key string, args []interface{}) { - fake.invocationsMutex.Lock() - defer fake.invocationsMutex.Unlock() - if fake.invocations == nil { - fake.invocations = map[string][][]interface{}{} - } - if fake.invocations[key] == nil { - fake.invocations[key] = [][]interface{}{} - } - fake.invocations[key] = append(fake.invocations[key], args) -} - -var _ types.Receiver = new(FakeReceiver)