fix generation

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() {

pkg/rtc/receiver.go

@@ -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()
-}

pkg/rtc/types/typesfakes/fake_down_track.go

@@ -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)

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()

pkg/rtc/types/typesfakes/fake_receiver.go

@@ -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)