snapshot of https://github.com/livekit/livekit.git @ 08c5433449c106943231037d0b892895f6e92d3b (2026-09-15)

pkg/sfu/sfufakes/fake_down_track_listener.go

@@ -0,0 +1,290 @@
+// Code generated by counterfeiter. DO NOT EDIT.
+package sfufakes
+
+import (
+	"sync"
+	"time"
+
+	"github.com/livekit/livekit-server/pkg/sfu"
+	"github.com/livekit/protocol/livekit"
+	webrtc "github.com/pion/webrtc/v4"
+)
+
+type FakeDownTrackListener struct {
+	OnBindAndConnectedStub        func()
+	onBindAndConnectedMutex       sync.RWMutex
+	onBindAndConnectedArgsForCall []struct {
+	}
+	OnCodecNegotiatedStub        func(webrtc.RTPCodecCapability)
+	onCodecNegotiatedMutex       sync.RWMutex
+	onCodecNegotiatedArgsForCall []struct {
+		arg1 webrtc.RTPCodecCapability
+	}
+	OnDownTrackCloseStub        func(bool)
+	onDownTrackCloseMutex       sync.RWMutex
+	onDownTrackCloseArgsForCall []struct {
+		arg1 bool
+	}
+	OnMaxSubscribedLayerChangedStub        func(int32)
+	onMaxSubscribedLayerChangedMutex       sync.RWMutex
+	onMaxSubscribedLayerChangedArgsForCall []struct {
+		arg1 int32
+	}
+	OnRttUpdateStub        func(uint32)
+	onRttUpdateMutex       sync.RWMutex
+	onRttUpdateArgsForCall []struct {
+		arg1 uint32
+	}
+	OnStatsUpdateStub        func(*livekit.AnalyticsStat)
+	onStatsUpdateMutex       sync.RWMutex
+	onStatsUpdateArgsForCall []struct {
+		arg1 *livekit.AnalyticsStat
+	}
+	OnStreamStartedStub        func(time.Duration)
+	onStreamStartedMutex       sync.RWMutex
+	onStreamStartedArgsForCall []struct {
+		arg1 time.Duration
+	}
+	invocations      map[string][][]interface{}
+	invocationsMutex sync.RWMutex
+}
+
+func (fake *FakeDownTrackListener) OnBindAndConnected() {
+	fake.onBindAndConnectedMutex.Lock()
+	fake.onBindAndConnectedArgsForCall = append(fake.onBindAndConnectedArgsForCall, struct {
+	}{})
+	stub := fake.OnBindAndConnectedStub
+	fake.recordInvocation("OnBindAndConnected", []interface{}{})
+	fake.onBindAndConnectedMutex.Unlock()
+	if stub != nil {
+		fake.OnBindAndConnectedStub()
+	}
+}
+
+func (fake *FakeDownTrackListener) OnBindAndConnectedCallCount() int {
+	fake.onBindAndConnectedMutex.RLock()
+	defer fake.onBindAndConnectedMutex.RUnlock()
+	return len(fake.onBindAndConnectedArgsForCall)
+}
+
+func (fake *FakeDownTrackListener) OnBindAndConnectedCalls(stub func()) {
+	fake.onBindAndConnectedMutex.Lock()
+	defer fake.onBindAndConnectedMutex.Unlock()
+	fake.OnBindAndConnectedStub = stub
+}
+
+func (fake *FakeDownTrackListener) OnCodecNegotiated(arg1 webrtc.RTPCodecCapability) {
+	fake.onCodecNegotiatedMutex.Lock()
+	fake.onCodecNegotiatedArgsForCall = append(fake.onCodecNegotiatedArgsForCall, struct {
+		arg1 webrtc.RTPCodecCapability
+	}{arg1})
+	stub := fake.OnCodecNegotiatedStub
+	fake.recordInvocation("OnCodecNegotiated", []interface{}{arg1})
+	fake.onCodecNegotiatedMutex.Unlock()
+	if stub != nil {
+		fake.OnCodecNegotiatedStub(arg1)
+	}
+}
+
+func (fake *FakeDownTrackListener) OnCodecNegotiatedCallCount() int {
+	fake.onCodecNegotiatedMutex.RLock()
+	defer fake.onCodecNegotiatedMutex.RUnlock()
+	return len(fake.onCodecNegotiatedArgsForCall)
+}
+
+func (fake *FakeDownTrackListener) OnCodecNegotiatedCalls(stub func(webrtc.RTPCodecCapability)) {
+	fake.onCodecNegotiatedMutex.Lock()
+	defer fake.onCodecNegotiatedMutex.Unlock()
+	fake.OnCodecNegotiatedStub = stub
+}
+
+func (fake *FakeDownTrackListener) OnCodecNegotiatedArgsForCall(i int) webrtc.RTPCodecCapability {
+	fake.onCodecNegotiatedMutex.RLock()
+	defer fake.onCodecNegotiatedMutex.RUnlock()
+	argsForCall := fake.onCodecNegotiatedArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeDownTrackListener) OnDownTrackClose(arg1 bool) {
+	fake.onDownTrackCloseMutex.Lock()
+	fake.onDownTrackCloseArgsForCall = append(fake.onDownTrackCloseArgsForCall, struct {
+		arg1 bool
+	}{arg1})
+	stub := fake.OnDownTrackCloseStub
+	fake.recordInvocation("OnDownTrackClose", []interface{}{arg1})
+	fake.onDownTrackCloseMutex.Unlock()
+	if stub != nil {
+		fake.OnDownTrackCloseStub(arg1)
+	}
+}
+
+func (fake *FakeDownTrackListener) OnDownTrackCloseCallCount() int {
+	fake.onDownTrackCloseMutex.RLock()
+	defer fake.onDownTrackCloseMutex.RUnlock()
+	return len(fake.onDownTrackCloseArgsForCall)
+}
+
+func (fake *FakeDownTrackListener) OnDownTrackCloseCalls(stub func(bool)) {
+	fake.onDownTrackCloseMutex.Lock()
+	defer fake.onDownTrackCloseMutex.Unlock()
+	fake.OnDownTrackCloseStub = stub
+}
+
+func (fake *FakeDownTrackListener) OnDownTrackCloseArgsForCall(i int) bool {
+	fake.onDownTrackCloseMutex.RLock()
+	defer fake.onDownTrackCloseMutex.RUnlock()
+	argsForCall := fake.onDownTrackCloseArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeDownTrackListener) OnMaxSubscribedLayerChanged(arg1 int32) {
+	fake.onMaxSubscribedLayerChangedMutex.Lock()
+	fake.onMaxSubscribedLayerChangedArgsForCall = append(fake.onMaxSubscribedLayerChangedArgsForCall, struct {
+		arg1 int32
+	}{arg1})
+	stub := fake.OnMaxSubscribedLayerChangedStub
+	fake.recordInvocation("OnMaxSubscribedLayerChanged", []interface{}{arg1})
+	fake.onMaxSubscribedLayerChangedMutex.Unlock()
+	if stub != nil {
+		fake.OnMaxSubscribedLayerChangedStub(arg1)
+	}
+}
+
+func (fake *FakeDownTrackListener) OnMaxSubscribedLayerChangedCallCount() int {
+	fake.onMaxSubscribedLayerChangedMutex.RLock()
+	defer fake.onMaxSubscribedLayerChangedMutex.RUnlock()
+	return len(fake.onMaxSubscribedLayerChangedArgsForCall)
+}
+
+func (fake *FakeDownTrackListener) OnMaxSubscribedLayerChangedCalls(stub func(int32)) {
+	fake.onMaxSubscribedLayerChangedMutex.Lock()
+	defer fake.onMaxSubscribedLayerChangedMutex.Unlock()
+	fake.OnMaxSubscribedLayerChangedStub = stub
+}
+
+func (fake *FakeDownTrackListener) OnMaxSubscribedLayerChangedArgsForCall(i int) int32 {
+	fake.onMaxSubscribedLayerChangedMutex.RLock()
+	defer fake.onMaxSubscribedLayerChangedMutex.RUnlock()
+	argsForCall := fake.onMaxSubscribedLayerChangedArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeDownTrackListener) OnRttUpdate(arg1 uint32) {
+	fake.onRttUpdateMutex.Lock()
+	fake.onRttUpdateArgsForCall = append(fake.onRttUpdateArgsForCall, struct {
+		arg1 uint32
+	}{arg1})
+	stub := fake.OnRttUpdateStub
+	fake.recordInvocation("OnRttUpdate", []interface{}{arg1})
+	fake.onRttUpdateMutex.Unlock()
+	if stub != nil {
+		fake.OnRttUpdateStub(arg1)
+	}
+}
+
+func (fake *FakeDownTrackListener) OnRttUpdateCallCount() int {
+	fake.onRttUpdateMutex.RLock()
+	defer fake.onRttUpdateMutex.RUnlock()
+	return len(fake.onRttUpdateArgsForCall)
+}
+
+func (fake *FakeDownTrackListener) OnRttUpdateCalls(stub func(uint32)) {
+	fake.onRttUpdateMutex.Lock()
+	defer fake.onRttUpdateMutex.Unlock()
+	fake.OnRttUpdateStub = stub
+}
+
+func (fake *FakeDownTrackListener) OnRttUpdateArgsForCall(i int) uint32 {
+	fake.onRttUpdateMutex.RLock()
+	defer fake.onRttUpdateMutex.RUnlock()
+	argsForCall := fake.onRttUpdateArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeDownTrackListener) OnStatsUpdate(arg1 *livekit.AnalyticsStat) {
+	fake.onStatsUpdateMutex.Lock()
+	fake.onStatsUpdateArgsForCall = append(fake.onStatsUpdateArgsForCall, struct {
+		arg1 *livekit.AnalyticsStat
+	}{arg1})
+	stub := fake.OnStatsUpdateStub
+	fake.recordInvocation("OnStatsUpdate", []interface{}{arg1})
+	fake.onStatsUpdateMutex.Unlock()
+	if stub != nil {
+		fake.OnStatsUpdateStub(arg1)
+	}
+}
+
+func (fake *FakeDownTrackListener) OnStatsUpdateCallCount() int {
+	fake.onStatsUpdateMutex.RLock()
+	defer fake.onStatsUpdateMutex.RUnlock()
+	return len(fake.onStatsUpdateArgsForCall)
+}
+
+func (fake *FakeDownTrackListener) OnStatsUpdateCalls(stub func(*livekit.AnalyticsStat)) {
+	fake.onStatsUpdateMutex.Lock()
+	defer fake.onStatsUpdateMutex.Unlock()
+	fake.OnStatsUpdateStub = stub
+}
+
+func (fake *FakeDownTrackListener) OnStatsUpdateArgsForCall(i int) *livekit.AnalyticsStat {
+	fake.onStatsUpdateMutex.RLock()
+	defer fake.onStatsUpdateMutex.RUnlock()
+	argsForCall := fake.onStatsUpdateArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeDownTrackListener) OnStreamStarted(arg1 time.Duration) {
+	fake.onStreamStartedMutex.Lock()
+	fake.onStreamStartedArgsForCall = append(fake.onStreamStartedArgsForCall, struct {
+		arg1 time.Duration
+	}{arg1})
+	stub := fake.OnStreamStartedStub
+	fake.recordInvocation("OnStreamStarted", []interface{}{arg1})
+	fake.onStreamStartedMutex.Unlock()
+	if stub != nil {
+		fake.OnStreamStartedStub(arg1)
+	}
+}
+
+func (fake *FakeDownTrackListener) OnStreamStartedCallCount() int {
+	fake.onStreamStartedMutex.RLock()
+	defer fake.onStreamStartedMutex.RUnlock()
+	return len(fake.onStreamStartedArgsForCall)
+}
+
+func (fake *FakeDownTrackListener) OnStreamStartedCalls(stub func(time.Duration)) {
+	fake.onStreamStartedMutex.Lock()
+	defer fake.onStreamStartedMutex.Unlock()
+	fake.OnStreamStartedStub = stub
+}
+
+func (fake *FakeDownTrackListener) OnStreamStartedArgsForCall(i int) time.Duration {
+	fake.onStreamStartedMutex.RLock()
+	defer fake.onStreamStartedMutex.RUnlock()
+	argsForCall := fake.onStreamStartedArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeDownTrackListener) Invocations() map[string][][]interface{} {
+	fake.invocationsMutex.RLock()
+	defer fake.invocationsMutex.RUnlock()
+	copiedInvocations := map[string][][]interface{}{}
+	for key, value := range fake.invocations {
+		copiedInvocations[key] = value
+	}
+	return copiedInvocations
+}
+
+func (fake *FakeDownTrackListener) 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 _ sfu.DownTrackListener = new(FakeDownTrackListener)

pkg/sfu/sfufakes/fake_down_track_stream_allocator_listener.go

@@ -0,0 +1,586 @@
+// Code generated by counterfeiter. DO NOT EDIT.
+package sfufakes
+
+import (
+	"sync"
+
+	"github.com/livekit/livekit-server/pkg/sfu"
+	"github.com/livekit/livekit-server/pkg/sfu/buffer"
+	"github.com/livekit/livekit-server/pkg/sfu/bwe"
+	"github.com/pion/rtcp"
+)
+
+type FakeDownTrackStreamAllocatorListener struct {
+	BWETypeStub        func() bwe.BWEType
+	bWETypeMutex       sync.RWMutex
+	bWETypeArgsForCall []struct {
+	}
+	bWETypeReturns struct {
+		result1 bwe.BWEType
+	}
+	bWETypeReturnsOnCall map[int]struct {
+		result1 bwe.BWEType
+	}
+	IsBWEEnabledStub        func(*sfu.DownTrack) bool
+	isBWEEnabledMutex       sync.RWMutex
+	isBWEEnabledArgsForCall []struct {
+		arg1 *sfu.DownTrack
+	}
+	isBWEEnabledReturns struct {
+		result1 bool
+	}
+	isBWEEnabledReturnsOnCall map[int]struct {
+		result1 bool
+	}
+	IsSubscribeMutableStub        func(*sfu.DownTrack) bool
+	isSubscribeMutableMutex       sync.RWMutex
+	isSubscribeMutableArgsForCall []struct {
+		arg1 *sfu.DownTrack
+	}
+	isSubscribeMutableReturns struct {
+		result1 bool
+	}
+	isSubscribeMutableReturnsOnCall map[int]struct {
+		result1 bool
+	}
+	OnAvailableLayersChangedStub        func(*sfu.DownTrack)
+	onAvailableLayersChangedMutex       sync.RWMutex
+	onAvailableLayersChangedArgsForCall []struct {
+		arg1 *sfu.DownTrack
+	}
+	OnBitrateAvailabilityChangedStub        func(*sfu.DownTrack)
+	onBitrateAvailabilityChangedMutex       sync.RWMutex
+	onBitrateAvailabilityChangedArgsForCall []struct {
+		arg1 *sfu.DownTrack
+	}
+	OnMaxPublishedSpatialChangedStub        func(*sfu.DownTrack)
+	onMaxPublishedSpatialChangedMutex       sync.RWMutex
+	onMaxPublishedSpatialChangedArgsForCall []struct {
+		arg1 *sfu.DownTrack
+	}
+	OnMaxPublishedTemporalChangedStub        func(*sfu.DownTrack)
+	onMaxPublishedTemporalChangedMutex       sync.RWMutex
+	onMaxPublishedTemporalChangedArgsForCall []struct {
+		arg1 *sfu.DownTrack
+	}
+	OnREMBStub        func(*sfu.DownTrack, *rtcp.ReceiverEstimatedMaximumBitrate)
+	onREMBMutex       sync.RWMutex
+	onREMBArgsForCall []struct {
+		arg1 *sfu.DownTrack
+		arg2 *rtcp.ReceiverEstimatedMaximumBitrate
+	}
+	OnResumeStub        func(*sfu.DownTrack)
+	onResumeMutex       sync.RWMutex
+	onResumeArgsForCall []struct {
+		arg1 *sfu.DownTrack
+	}
+	OnSubscribedLayerChangedStub        func(*sfu.DownTrack, buffer.VideoLayer)
+	onSubscribedLayerChangedMutex       sync.RWMutex
+	onSubscribedLayerChangedArgsForCall []struct {
+		arg1 *sfu.DownTrack
+		arg2 buffer.VideoLayer
+	}
+	OnSubscriptionChangedStub        func(*sfu.DownTrack)
+	onSubscriptionChangedMutex       sync.RWMutex
+	onSubscriptionChangedArgsForCall []struct {
+		arg1 *sfu.DownTrack
+	}
+	OnTransportCCFeedbackStub        func(*sfu.DownTrack, *rtcp.TransportLayerCC)
+	onTransportCCFeedbackMutex       sync.RWMutex
+	onTransportCCFeedbackArgsForCall []struct {
+		arg1 *sfu.DownTrack
+		arg2 *rtcp.TransportLayerCC
+	}
+	invocations      map[string][][]interface{}
+	invocationsMutex sync.RWMutex
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) BWEType() bwe.BWEType {
+	fake.bWETypeMutex.Lock()
+	ret, specificReturn := fake.bWETypeReturnsOnCall[len(fake.bWETypeArgsForCall)]
+	fake.bWETypeArgsForCall = append(fake.bWETypeArgsForCall, struct {
+	}{})
+	stub := fake.BWETypeStub
+	fakeReturns := fake.bWETypeReturns
+	fake.recordInvocation("BWEType", []interface{}{})
+	fake.bWETypeMutex.Unlock()
+	if stub != nil {
+		return stub()
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) BWETypeCallCount() int {
+	fake.bWETypeMutex.RLock()
+	defer fake.bWETypeMutex.RUnlock()
+	return len(fake.bWETypeArgsForCall)
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) BWETypeCalls(stub func() bwe.BWEType) {
+	fake.bWETypeMutex.Lock()
+	defer fake.bWETypeMutex.Unlock()
+	fake.BWETypeStub = stub
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) BWETypeReturns(result1 bwe.BWEType) {
+	fake.bWETypeMutex.Lock()
+	defer fake.bWETypeMutex.Unlock()
+	fake.BWETypeStub = nil
+	fake.bWETypeReturns = struct {
+		result1 bwe.BWEType
+	}{result1}
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) BWETypeReturnsOnCall(i int, result1 bwe.BWEType) {
+	fake.bWETypeMutex.Lock()
+	defer fake.bWETypeMutex.Unlock()
+	fake.BWETypeStub = nil
+	if fake.bWETypeReturnsOnCall == nil {
+		fake.bWETypeReturnsOnCall = make(map[int]struct {
+			result1 bwe.BWEType
+		})
+	}
+	fake.bWETypeReturnsOnCall[i] = struct {
+		result1 bwe.BWEType
+	}{result1}
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) IsBWEEnabled(arg1 *sfu.DownTrack) bool {
+	fake.isBWEEnabledMutex.Lock()
+	ret, specificReturn := fake.isBWEEnabledReturnsOnCall[len(fake.isBWEEnabledArgsForCall)]
+	fake.isBWEEnabledArgsForCall = append(fake.isBWEEnabledArgsForCall, struct {
+		arg1 *sfu.DownTrack
+	}{arg1})
+	stub := fake.IsBWEEnabledStub
+	fakeReturns := fake.isBWEEnabledReturns
+	fake.recordInvocation("IsBWEEnabled", []interface{}{arg1})
+	fake.isBWEEnabledMutex.Unlock()
+	if stub != nil {
+		return stub(arg1)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) IsBWEEnabledCallCount() int {
+	fake.isBWEEnabledMutex.RLock()
+	defer fake.isBWEEnabledMutex.RUnlock()
+	return len(fake.isBWEEnabledArgsForCall)
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) IsBWEEnabledCalls(stub func(*sfu.DownTrack) bool) {
+	fake.isBWEEnabledMutex.Lock()
+	defer fake.isBWEEnabledMutex.Unlock()
+	fake.IsBWEEnabledStub = stub
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) IsBWEEnabledArgsForCall(i int) *sfu.DownTrack {
+	fake.isBWEEnabledMutex.RLock()
+	defer fake.isBWEEnabledMutex.RUnlock()
+	argsForCall := fake.isBWEEnabledArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) IsBWEEnabledReturns(result1 bool) {
+	fake.isBWEEnabledMutex.Lock()
+	defer fake.isBWEEnabledMutex.Unlock()
+	fake.IsBWEEnabledStub = nil
+	fake.isBWEEnabledReturns = struct {
+		result1 bool
+	}{result1}
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) IsBWEEnabledReturnsOnCall(i int, result1 bool) {
+	fake.isBWEEnabledMutex.Lock()
+	defer fake.isBWEEnabledMutex.Unlock()
+	fake.IsBWEEnabledStub = nil
+	if fake.isBWEEnabledReturnsOnCall == nil {
+		fake.isBWEEnabledReturnsOnCall = make(map[int]struct {
+			result1 bool
+		})
+	}
+	fake.isBWEEnabledReturnsOnCall[i] = struct {
+		result1 bool
+	}{result1}
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) IsSubscribeMutable(arg1 *sfu.DownTrack) bool {
+	fake.isSubscribeMutableMutex.Lock()
+	ret, specificReturn := fake.isSubscribeMutableReturnsOnCall[len(fake.isSubscribeMutableArgsForCall)]
+	fake.isSubscribeMutableArgsForCall = append(fake.isSubscribeMutableArgsForCall, struct {
+		arg1 *sfu.DownTrack
+	}{arg1})
+	stub := fake.IsSubscribeMutableStub
+	fakeReturns := fake.isSubscribeMutableReturns
+	fake.recordInvocation("IsSubscribeMutable", []interface{}{arg1})
+	fake.isSubscribeMutableMutex.Unlock()
+	if stub != nil {
+		return stub(arg1)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) IsSubscribeMutableCallCount() int {
+	fake.isSubscribeMutableMutex.RLock()
+	defer fake.isSubscribeMutableMutex.RUnlock()
+	return len(fake.isSubscribeMutableArgsForCall)
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) IsSubscribeMutableCalls(stub func(*sfu.DownTrack) bool) {
+	fake.isSubscribeMutableMutex.Lock()
+	defer fake.isSubscribeMutableMutex.Unlock()
+	fake.IsSubscribeMutableStub = stub
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) IsSubscribeMutableArgsForCall(i int) *sfu.DownTrack {
+	fake.isSubscribeMutableMutex.RLock()
+	defer fake.isSubscribeMutableMutex.RUnlock()
+	argsForCall := fake.isSubscribeMutableArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) IsSubscribeMutableReturns(result1 bool) {
+	fake.isSubscribeMutableMutex.Lock()
+	defer fake.isSubscribeMutableMutex.Unlock()
+	fake.IsSubscribeMutableStub = nil
+	fake.isSubscribeMutableReturns = struct {
+		result1 bool
+	}{result1}
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) IsSubscribeMutableReturnsOnCall(i int, result1 bool) {
+	fake.isSubscribeMutableMutex.Lock()
+	defer fake.isSubscribeMutableMutex.Unlock()
+	fake.IsSubscribeMutableStub = nil
+	if fake.isSubscribeMutableReturnsOnCall == nil {
+		fake.isSubscribeMutableReturnsOnCall = make(map[int]struct {
+			result1 bool
+		})
+	}
+	fake.isSubscribeMutableReturnsOnCall[i] = struct {
+		result1 bool
+	}{result1}
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) OnAvailableLayersChanged(arg1 *sfu.DownTrack) {
+	fake.onAvailableLayersChangedMutex.Lock()
+	fake.onAvailableLayersChangedArgsForCall = append(fake.onAvailableLayersChangedArgsForCall, struct {
+		arg1 *sfu.DownTrack
+	}{arg1})
+	stub := fake.OnAvailableLayersChangedStub
+	fake.recordInvocation("OnAvailableLayersChanged", []interface{}{arg1})
+	fake.onAvailableLayersChangedMutex.Unlock()
+	if stub != nil {
+		fake.OnAvailableLayersChangedStub(arg1)
+	}
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) OnAvailableLayersChangedCallCount() int {
+	fake.onAvailableLayersChangedMutex.RLock()
+	defer fake.onAvailableLayersChangedMutex.RUnlock()
+	return len(fake.onAvailableLayersChangedArgsForCall)
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) OnAvailableLayersChangedCalls(stub func(*sfu.DownTrack)) {
+	fake.onAvailableLayersChangedMutex.Lock()
+	defer fake.onAvailableLayersChangedMutex.Unlock()
+	fake.OnAvailableLayersChangedStub = stub
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) OnAvailableLayersChangedArgsForCall(i int) *sfu.DownTrack {
+	fake.onAvailableLayersChangedMutex.RLock()
+	defer fake.onAvailableLayersChangedMutex.RUnlock()
+	argsForCall := fake.onAvailableLayersChangedArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) OnBitrateAvailabilityChanged(arg1 *sfu.DownTrack) {
+	fake.onBitrateAvailabilityChangedMutex.Lock()
+	fake.onBitrateAvailabilityChangedArgsForCall = append(fake.onBitrateAvailabilityChangedArgsForCall, struct {
+		arg1 *sfu.DownTrack
+	}{arg1})
+	stub := fake.OnBitrateAvailabilityChangedStub
+	fake.recordInvocation("OnBitrateAvailabilityChanged", []interface{}{arg1})
+	fake.onBitrateAvailabilityChangedMutex.Unlock()
+	if stub != nil {
+		fake.OnBitrateAvailabilityChangedStub(arg1)
+	}
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) OnBitrateAvailabilityChangedCallCount() int {
+	fake.onBitrateAvailabilityChangedMutex.RLock()
+	defer fake.onBitrateAvailabilityChangedMutex.RUnlock()
+	return len(fake.onBitrateAvailabilityChangedArgsForCall)
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) OnBitrateAvailabilityChangedCalls(stub func(*sfu.DownTrack)) {
+	fake.onBitrateAvailabilityChangedMutex.Lock()
+	defer fake.onBitrateAvailabilityChangedMutex.Unlock()
+	fake.OnBitrateAvailabilityChangedStub = stub
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) OnBitrateAvailabilityChangedArgsForCall(i int) *sfu.DownTrack {
+	fake.onBitrateAvailabilityChangedMutex.RLock()
+	defer fake.onBitrateAvailabilityChangedMutex.RUnlock()
+	argsForCall := fake.onBitrateAvailabilityChangedArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) OnMaxPublishedSpatialChanged(arg1 *sfu.DownTrack) {
+	fake.onMaxPublishedSpatialChangedMutex.Lock()
+	fake.onMaxPublishedSpatialChangedArgsForCall = append(fake.onMaxPublishedSpatialChangedArgsForCall, struct {
+		arg1 *sfu.DownTrack
+	}{arg1})
+	stub := fake.OnMaxPublishedSpatialChangedStub
+	fake.recordInvocation("OnMaxPublishedSpatialChanged", []interface{}{arg1})
+	fake.onMaxPublishedSpatialChangedMutex.Unlock()
+	if stub != nil {
+		fake.OnMaxPublishedSpatialChangedStub(arg1)
+	}
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) OnMaxPublishedSpatialChangedCallCount() int {
+	fake.onMaxPublishedSpatialChangedMutex.RLock()
+	defer fake.onMaxPublishedSpatialChangedMutex.RUnlock()
+	return len(fake.onMaxPublishedSpatialChangedArgsForCall)
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) OnMaxPublishedSpatialChangedCalls(stub func(*sfu.DownTrack)) {
+	fake.onMaxPublishedSpatialChangedMutex.Lock()
+	defer fake.onMaxPublishedSpatialChangedMutex.Unlock()
+	fake.OnMaxPublishedSpatialChangedStub = stub
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) OnMaxPublishedSpatialChangedArgsForCall(i int) *sfu.DownTrack {
+	fake.onMaxPublishedSpatialChangedMutex.RLock()
+	defer fake.onMaxPublishedSpatialChangedMutex.RUnlock()
+	argsForCall := fake.onMaxPublishedSpatialChangedArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) OnMaxPublishedTemporalChanged(arg1 *sfu.DownTrack) {
+	fake.onMaxPublishedTemporalChangedMutex.Lock()
+	fake.onMaxPublishedTemporalChangedArgsForCall = append(fake.onMaxPublishedTemporalChangedArgsForCall, struct {
+		arg1 *sfu.DownTrack
+	}{arg1})
+	stub := fake.OnMaxPublishedTemporalChangedStub
+	fake.recordInvocation("OnMaxPublishedTemporalChanged", []interface{}{arg1})
+	fake.onMaxPublishedTemporalChangedMutex.Unlock()
+	if stub != nil {
+		fake.OnMaxPublishedTemporalChangedStub(arg1)
+	}
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) OnMaxPublishedTemporalChangedCallCount() int {
+	fake.onMaxPublishedTemporalChangedMutex.RLock()
+	defer fake.onMaxPublishedTemporalChangedMutex.RUnlock()
+	return len(fake.onMaxPublishedTemporalChangedArgsForCall)
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) OnMaxPublishedTemporalChangedCalls(stub func(*sfu.DownTrack)) {
+	fake.onMaxPublishedTemporalChangedMutex.Lock()
+	defer fake.onMaxPublishedTemporalChangedMutex.Unlock()
+	fake.OnMaxPublishedTemporalChangedStub = stub
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) OnMaxPublishedTemporalChangedArgsForCall(i int) *sfu.DownTrack {
+	fake.onMaxPublishedTemporalChangedMutex.RLock()
+	defer fake.onMaxPublishedTemporalChangedMutex.RUnlock()
+	argsForCall := fake.onMaxPublishedTemporalChangedArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) OnREMB(arg1 *sfu.DownTrack, arg2 *rtcp.ReceiverEstimatedMaximumBitrate) {
+	fake.onREMBMutex.Lock()
+	fake.onREMBArgsForCall = append(fake.onREMBArgsForCall, struct {
+		arg1 *sfu.DownTrack
+		arg2 *rtcp.ReceiverEstimatedMaximumBitrate
+	}{arg1, arg2})
+	stub := fake.OnREMBStub
+	fake.recordInvocation("OnREMB", []interface{}{arg1, arg2})
+	fake.onREMBMutex.Unlock()
+	if stub != nil {
+		fake.OnREMBStub(arg1, arg2)
+	}
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) OnREMBCallCount() int {
+	fake.onREMBMutex.RLock()
+	defer fake.onREMBMutex.RUnlock()
+	return len(fake.onREMBArgsForCall)
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) OnREMBCalls(stub func(*sfu.DownTrack, *rtcp.ReceiverEstimatedMaximumBitrate)) {
+	fake.onREMBMutex.Lock()
+	defer fake.onREMBMutex.Unlock()
+	fake.OnREMBStub = stub
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) OnREMBArgsForCall(i int) (*sfu.DownTrack, *rtcp.ReceiverEstimatedMaximumBitrate) {
+	fake.onREMBMutex.RLock()
+	defer fake.onREMBMutex.RUnlock()
+	argsForCall := fake.onREMBArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) OnResume(arg1 *sfu.DownTrack) {
+	fake.onResumeMutex.Lock()
+	fake.onResumeArgsForCall = append(fake.onResumeArgsForCall, struct {
+		arg1 *sfu.DownTrack
+	}{arg1})
+	stub := fake.OnResumeStub
+	fake.recordInvocation("OnResume", []interface{}{arg1})
+	fake.onResumeMutex.Unlock()
+	if stub != nil {
+		fake.OnResumeStub(arg1)
+	}
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) OnResumeCallCount() int {
+	fake.onResumeMutex.RLock()
+	defer fake.onResumeMutex.RUnlock()
+	return len(fake.onResumeArgsForCall)
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) OnResumeCalls(stub func(*sfu.DownTrack)) {
+	fake.onResumeMutex.Lock()
+	defer fake.onResumeMutex.Unlock()
+	fake.OnResumeStub = stub
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) OnResumeArgsForCall(i int) *sfu.DownTrack {
+	fake.onResumeMutex.RLock()
+	defer fake.onResumeMutex.RUnlock()
+	argsForCall := fake.onResumeArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) OnSubscribedLayerChanged(arg1 *sfu.DownTrack, arg2 buffer.VideoLayer) {
+	fake.onSubscribedLayerChangedMutex.Lock()
+	fake.onSubscribedLayerChangedArgsForCall = append(fake.onSubscribedLayerChangedArgsForCall, struct {
+		arg1 *sfu.DownTrack
+		arg2 buffer.VideoLayer
+	}{arg1, arg2})
+	stub := fake.OnSubscribedLayerChangedStub
+	fake.recordInvocation("OnSubscribedLayerChanged", []interface{}{arg1, arg2})
+	fake.onSubscribedLayerChangedMutex.Unlock()
+	if stub != nil {
+		fake.OnSubscribedLayerChangedStub(arg1, arg2)
+	}
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) OnSubscribedLayerChangedCallCount() int {
+	fake.onSubscribedLayerChangedMutex.RLock()
+	defer fake.onSubscribedLayerChangedMutex.RUnlock()
+	return len(fake.onSubscribedLayerChangedArgsForCall)
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) OnSubscribedLayerChangedCalls(stub func(*sfu.DownTrack, buffer.VideoLayer)) {
+	fake.onSubscribedLayerChangedMutex.Lock()
+	defer fake.onSubscribedLayerChangedMutex.Unlock()
+	fake.OnSubscribedLayerChangedStub = stub
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) OnSubscribedLayerChangedArgsForCall(i int) (*sfu.DownTrack, buffer.VideoLayer) {
+	fake.onSubscribedLayerChangedMutex.RLock()
+	defer fake.onSubscribedLayerChangedMutex.RUnlock()
+	argsForCall := fake.onSubscribedLayerChangedArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) OnSubscriptionChanged(arg1 *sfu.DownTrack) {
+	fake.onSubscriptionChangedMutex.Lock()
+	fake.onSubscriptionChangedArgsForCall = append(fake.onSubscriptionChangedArgsForCall, struct {
+		arg1 *sfu.DownTrack
+	}{arg1})
+	stub := fake.OnSubscriptionChangedStub
+	fake.recordInvocation("OnSubscriptionChanged", []interface{}{arg1})
+	fake.onSubscriptionChangedMutex.Unlock()
+	if stub != nil {
+		fake.OnSubscriptionChangedStub(arg1)
+	}
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) OnSubscriptionChangedCallCount() int {
+	fake.onSubscriptionChangedMutex.RLock()
+	defer fake.onSubscriptionChangedMutex.RUnlock()
+	return len(fake.onSubscriptionChangedArgsForCall)
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) OnSubscriptionChangedCalls(stub func(*sfu.DownTrack)) {
+	fake.onSubscriptionChangedMutex.Lock()
+	defer fake.onSubscriptionChangedMutex.Unlock()
+	fake.OnSubscriptionChangedStub = stub
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) OnSubscriptionChangedArgsForCall(i int) *sfu.DownTrack {
+	fake.onSubscriptionChangedMutex.RLock()
+	defer fake.onSubscriptionChangedMutex.RUnlock()
+	argsForCall := fake.onSubscriptionChangedArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) OnTransportCCFeedback(arg1 *sfu.DownTrack, arg2 *rtcp.TransportLayerCC) {
+	fake.onTransportCCFeedbackMutex.Lock()
+	fake.onTransportCCFeedbackArgsForCall = append(fake.onTransportCCFeedbackArgsForCall, struct {
+		arg1 *sfu.DownTrack
+		arg2 *rtcp.TransportLayerCC
+	}{arg1, arg2})
+	stub := fake.OnTransportCCFeedbackStub
+	fake.recordInvocation("OnTransportCCFeedback", []interface{}{arg1, arg2})
+	fake.onTransportCCFeedbackMutex.Unlock()
+	if stub != nil {
+		fake.OnTransportCCFeedbackStub(arg1, arg2)
+	}
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) OnTransportCCFeedbackCallCount() int {
+	fake.onTransportCCFeedbackMutex.RLock()
+	defer fake.onTransportCCFeedbackMutex.RUnlock()
+	return len(fake.onTransportCCFeedbackArgsForCall)
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) OnTransportCCFeedbackCalls(stub func(*sfu.DownTrack, *rtcp.TransportLayerCC)) {
+	fake.onTransportCCFeedbackMutex.Lock()
+	defer fake.onTransportCCFeedbackMutex.Unlock()
+	fake.OnTransportCCFeedbackStub = stub
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) OnTransportCCFeedbackArgsForCall(i int) (*sfu.DownTrack, *rtcp.TransportLayerCC) {
+	fake.onTransportCCFeedbackMutex.RLock()
+	defer fake.onTransportCCFeedbackMutex.RUnlock()
+	argsForCall := fake.onTransportCCFeedbackArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) Invocations() map[string][][]interface{} {
+	fake.invocationsMutex.RLock()
+	defer fake.invocationsMutex.RUnlock()
+	copiedInvocations := map[string][][]interface{}{}
+	for key, value := range fake.invocations {
+		copiedInvocations[key] = value
+	}
+	return copiedInvocations
+}
+
+func (fake *FakeDownTrackStreamAllocatorListener) 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 _ sfu.DownTrackStreamAllocatorListener = new(FakeDownTrackStreamAllocatorListener)

pkg/sfu/sfufakes/fake_track_sender.go

@@ -0,0 +1,683 @@
+// Code generated by counterfeiter. DO NOT EDIT.
+package sfufakes
+
+import (
+	"sync"
+
+	"github.com/livekit/livekit-server/pkg/sfu"
+	"github.com/livekit/livekit-server/pkg/sfu/buffer"
+	"github.com/livekit/protocol/livekit"
+	webrtc "github.com/pion/webrtc/v4"
+)
+
+type FakeTrackSender struct {
+	CloseStub        func()
+	closeMutex       sync.RWMutex
+	closeArgsForCall []struct {
+	}
+	HandleRTCPSenderReportDataStub        func(webrtc.PayloadType, int32, *livekit.RTCPSenderReportState) error
+	handleRTCPSenderReportDataMutex       sync.RWMutex
+	handleRTCPSenderReportDataArgsForCall []struct {
+		arg1 webrtc.PayloadType
+		arg2 int32
+		arg3 *livekit.RTCPSenderReportState
+	}
+	handleRTCPSenderReportDataReturns struct {
+		result1 error
+	}
+	handleRTCPSenderReportDataReturnsOnCall map[int]struct {
+		result1 error
+	}
+	IDStub        func() string
+	iDMutex       sync.RWMutex
+	iDArgsForCall []struct {
+	}
+	iDReturns struct {
+		result1 string
+	}
+	iDReturnsOnCall map[int]struct {
+		result1 string
+	}
+	IsClosedStub        func() bool
+	isClosedMutex       sync.RWMutex
+	isClosedArgsForCall []struct {
+	}
+	isClosedReturns struct {
+		result1 bool
+	}
+	isClosedReturnsOnCall map[int]struct {
+		result1 bool
+	}
+	ReceiverRestartStub        func(sfu.TrackReceiver)
+	receiverRestartMutex       sync.RWMutex
+	receiverRestartArgsForCall []struct {
+		arg1 sfu.TrackReceiver
+	}
+	ResyncStub        func()
+	resyncMutex       sync.RWMutex
+	resyncArgsForCall []struct {
+	}
+	SetReceiverStub        func(sfu.TrackReceiver)
+	setReceiverMutex       sync.RWMutex
+	setReceiverArgsForCall []struct {
+		arg1 sfu.TrackReceiver
+	}
+	SubscriberIDStub        func() livekit.ParticipantID
+	subscriberIDMutex       sync.RWMutex
+	subscriberIDArgsForCall []struct {
+	}
+	subscriberIDReturns struct {
+		result1 livekit.ParticipantID
+	}
+	subscriberIDReturnsOnCall map[int]struct {
+		result1 livekit.ParticipantID
+	}
+	UpTrackBitrateAvailabilityChangeStub        func()
+	upTrackBitrateAvailabilityChangeMutex       sync.RWMutex
+	upTrackBitrateAvailabilityChangeArgsForCall []struct {
+	}
+	UpTrackBitrateReportStub        func([]int32, sfu.Bitrates)
+	upTrackBitrateReportMutex       sync.RWMutex
+	upTrackBitrateReportArgsForCall []struct {
+		arg1 []int32
+		arg2 sfu.Bitrates
+	}
+	UpTrackLayersChangeStub        func()
+	upTrackLayersChangeMutex       sync.RWMutex
+	upTrackLayersChangeArgsForCall []struct {
+	}
+	UpTrackMaxPublishedLayerChangeStub        func(int32)
+	upTrackMaxPublishedLayerChangeMutex       sync.RWMutex
+	upTrackMaxPublishedLayerChangeArgsForCall []struct {
+		arg1 int32
+	}
+	UpTrackMaxTemporalLayerSeenChangeStub        func(int32)
+	upTrackMaxTemporalLayerSeenChangeMutex       sync.RWMutex
+	upTrackMaxTemporalLayerSeenChangeArgsForCall []struct {
+		arg1 int32
+	}
+	WriteRTPStub        func(*buffer.ExtPacket, int32) int32
+	writeRTPMutex       sync.RWMutex
+	writeRTPArgsForCall []struct {
+		arg1 *buffer.ExtPacket
+		arg2 int32
+	}
+	writeRTPReturns struct {
+		result1 int32
+	}
+	writeRTPReturnsOnCall map[int]struct {
+		result1 int32
+	}
+	invocations      map[string][][]interface{}
+	invocationsMutex sync.RWMutex
+}
+
+func (fake *FakeTrackSender) 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 *FakeTrackSender) CloseCallCount() int {
+	fake.closeMutex.RLock()
+	defer fake.closeMutex.RUnlock()
+	return len(fake.closeArgsForCall)
+}
+
+func (fake *FakeTrackSender) CloseCalls(stub func()) {
+	fake.closeMutex.Lock()
+	defer fake.closeMutex.Unlock()
+	fake.CloseStub = stub
+}
+
+func (fake *FakeTrackSender) HandleRTCPSenderReportData(arg1 webrtc.PayloadType, arg2 int32, arg3 *livekit.RTCPSenderReportState) error {
+	fake.handleRTCPSenderReportDataMutex.Lock()
+	ret, specificReturn := fake.handleRTCPSenderReportDataReturnsOnCall[len(fake.handleRTCPSenderReportDataArgsForCall)]
+	fake.handleRTCPSenderReportDataArgsForCall = append(fake.handleRTCPSenderReportDataArgsForCall, struct {
+		arg1 webrtc.PayloadType
+		arg2 int32
+		arg3 *livekit.RTCPSenderReportState
+	}{arg1, arg2, arg3})
+	stub := fake.HandleRTCPSenderReportDataStub
+	fakeReturns := fake.handleRTCPSenderReportDataReturns
+	fake.recordInvocation("HandleRTCPSenderReportData", []interface{}{arg1, arg2, arg3})
+	fake.handleRTCPSenderReportDataMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2, arg3)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeTrackSender) HandleRTCPSenderReportDataCallCount() int {
+	fake.handleRTCPSenderReportDataMutex.RLock()
+	defer fake.handleRTCPSenderReportDataMutex.RUnlock()
+	return len(fake.handleRTCPSenderReportDataArgsForCall)
+}
+
+func (fake *FakeTrackSender) HandleRTCPSenderReportDataCalls(stub func(webrtc.PayloadType, int32, *livekit.RTCPSenderReportState) error) {
+	fake.handleRTCPSenderReportDataMutex.Lock()
+	defer fake.handleRTCPSenderReportDataMutex.Unlock()
+	fake.HandleRTCPSenderReportDataStub = stub
+}
+
+func (fake *FakeTrackSender) HandleRTCPSenderReportDataArgsForCall(i int) (webrtc.PayloadType, int32, *livekit.RTCPSenderReportState) {
+	fake.handleRTCPSenderReportDataMutex.RLock()
+	defer fake.handleRTCPSenderReportDataMutex.RUnlock()
+	argsForCall := fake.handleRTCPSenderReportDataArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
+}
+
+func (fake *FakeTrackSender) HandleRTCPSenderReportDataReturns(result1 error) {
+	fake.handleRTCPSenderReportDataMutex.Lock()
+	defer fake.handleRTCPSenderReportDataMutex.Unlock()
+	fake.HandleRTCPSenderReportDataStub = nil
+	fake.handleRTCPSenderReportDataReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeTrackSender) HandleRTCPSenderReportDataReturnsOnCall(i int, result1 error) {
+	fake.handleRTCPSenderReportDataMutex.Lock()
+	defer fake.handleRTCPSenderReportDataMutex.Unlock()
+	fake.HandleRTCPSenderReportDataStub = nil
+	if fake.handleRTCPSenderReportDataReturnsOnCall == nil {
+		fake.handleRTCPSenderReportDataReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.handleRTCPSenderReportDataReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeTrackSender) 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 *FakeTrackSender) IDCallCount() int {
+	fake.iDMutex.RLock()
+	defer fake.iDMutex.RUnlock()
+	return len(fake.iDArgsForCall)
+}
+
+func (fake *FakeTrackSender) IDCalls(stub func() string) {
+	fake.iDMutex.Lock()
+	defer fake.iDMutex.Unlock()
+	fake.IDStub = stub
+}
+
+func (fake *FakeTrackSender) IDReturns(result1 string) {
+	fake.iDMutex.Lock()
+	defer fake.iDMutex.Unlock()
+	fake.IDStub = nil
+	fake.iDReturns = struct {
+		result1 string
+	}{result1}
+}
+
+func (fake *FakeTrackSender) 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 *FakeTrackSender) IsClosed() bool {
+	fake.isClosedMutex.Lock()
+	ret, specificReturn := fake.isClosedReturnsOnCall[len(fake.isClosedArgsForCall)]
+	fake.isClosedArgsForCall = append(fake.isClosedArgsForCall, struct {
+	}{})
+	stub := fake.IsClosedStub
+	fakeReturns := fake.isClosedReturns
+	fake.recordInvocation("IsClosed", []interface{}{})
+	fake.isClosedMutex.Unlock()
+	if stub != nil {
+		return stub()
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeTrackSender) IsClosedCallCount() int {
+	fake.isClosedMutex.RLock()
+	defer fake.isClosedMutex.RUnlock()
+	return len(fake.isClosedArgsForCall)
+}
+
+func (fake *FakeTrackSender) IsClosedCalls(stub func() bool) {
+	fake.isClosedMutex.Lock()
+	defer fake.isClosedMutex.Unlock()
+	fake.IsClosedStub = stub
+}
+
+func (fake *FakeTrackSender) IsClosedReturns(result1 bool) {
+	fake.isClosedMutex.Lock()
+	defer fake.isClosedMutex.Unlock()
+	fake.IsClosedStub = nil
+	fake.isClosedReturns = struct {
+		result1 bool
+	}{result1}
+}
+
+func (fake *FakeTrackSender) IsClosedReturnsOnCall(i int, result1 bool) {
+	fake.isClosedMutex.Lock()
+	defer fake.isClosedMutex.Unlock()
+	fake.IsClosedStub = nil
+	if fake.isClosedReturnsOnCall == nil {
+		fake.isClosedReturnsOnCall = make(map[int]struct {
+			result1 bool
+		})
+	}
+	fake.isClosedReturnsOnCall[i] = struct {
+		result1 bool
+	}{result1}
+}
+
+func (fake *FakeTrackSender) ReceiverRestart(arg1 sfu.TrackReceiver) {
+	fake.receiverRestartMutex.Lock()
+	fake.receiverRestartArgsForCall = append(fake.receiverRestartArgsForCall, struct {
+		arg1 sfu.TrackReceiver
+	}{arg1})
+	stub := fake.ReceiverRestartStub
+	fake.recordInvocation("ReceiverRestart", []interface{}{arg1})
+	fake.receiverRestartMutex.Unlock()
+	if stub != nil {
+		fake.ReceiverRestartStub(arg1)
+	}
+}
+
+func (fake *FakeTrackSender) ReceiverRestartCallCount() int {
+	fake.receiverRestartMutex.RLock()
+	defer fake.receiverRestartMutex.RUnlock()
+	return len(fake.receiverRestartArgsForCall)
+}
+
+func (fake *FakeTrackSender) ReceiverRestartCalls(stub func(sfu.TrackReceiver)) {
+	fake.receiverRestartMutex.Lock()
+	defer fake.receiverRestartMutex.Unlock()
+	fake.ReceiverRestartStub = stub
+}
+
+func (fake *FakeTrackSender) ReceiverRestartArgsForCall(i int) sfu.TrackReceiver {
+	fake.receiverRestartMutex.RLock()
+	defer fake.receiverRestartMutex.RUnlock()
+	argsForCall := fake.receiverRestartArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeTrackSender) Resync() {
+	fake.resyncMutex.Lock()
+	fake.resyncArgsForCall = append(fake.resyncArgsForCall, struct {
+	}{})
+	stub := fake.ResyncStub
+	fake.recordInvocation("Resync", []interface{}{})
+	fake.resyncMutex.Unlock()
+	if stub != nil {
+		fake.ResyncStub()
+	}
+}
+
+func (fake *FakeTrackSender) ResyncCallCount() int {
+	fake.resyncMutex.RLock()
+	defer fake.resyncMutex.RUnlock()
+	return len(fake.resyncArgsForCall)
+}
+
+func (fake *FakeTrackSender) ResyncCalls(stub func()) {
+	fake.resyncMutex.Lock()
+	defer fake.resyncMutex.Unlock()
+	fake.ResyncStub = stub
+}
+
+func (fake *FakeTrackSender) SetReceiver(arg1 sfu.TrackReceiver) {
+	fake.setReceiverMutex.Lock()
+	fake.setReceiverArgsForCall = append(fake.setReceiverArgsForCall, struct {
+		arg1 sfu.TrackReceiver
+	}{arg1})
+	stub := fake.SetReceiverStub
+	fake.recordInvocation("SetReceiver", []interface{}{arg1})
+	fake.setReceiverMutex.Unlock()
+	if stub != nil {
+		fake.SetReceiverStub(arg1)
+	}
+}
+
+func (fake *FakeTrackSender) SetReceiverCallCount() int {
+	fake.setReceiverMutex.RLock()
+	defer fake.setReceiverMutex.RUnlock()
+	return len(fake.setReceiverArgsForCall)
+}
+
+func (fake *FakeTrackSender) SetReceiverCalls(stub func(sfu.TrackReceiver)) {
+	fake.setReceiverMutex.Lock()
+	defer fake.setReceiverMutex.Unlock()
+	fake.SetReceiverStub = stub
+}
+
+func (fake *FakeTrackSender) SetReceiverArgsForCall(i int) sfu.TrackReceiver {
+	fake.setReceiverMutex.RLock()
+	defer fake.setReceiverMutex.RUnlock()
+	argsForCall := fake.setReceiverArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeTrackSender) SubscriberID() livekit.ParticipantID {
+	fake.subscriberIDMutex.Lock()
+	ret, specificReturn := fake.subscriberIDReturnsOnCall[len(fake.subscriberIDArgsForCall)]
+	fake.subscriberIDArgsForCall = append(fake.subscriberIDArgsForCall, struct {
+	}{})
+	stub := fake.SubscriberIDStub
+	fakeReturns := fake.subscriberIDReturns
+	fake.recordInvocation("SubscriberID", []interface{}{})
+	fake.subscriberIDMutex.Unlock()
+	if stub != nil {
+		return stub()
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeTrackSender) SubscriberIDCallCount() int {
+	fake.subscriberIDMutex.RLock()
+	defer fake.subscriberIDMutex.RUnlock()
+	return len(fake.subscriberIDArgsForCall)
+}
+
+func (fake *FakeTrackSender) SubscriberIDCalls(stub func() livekit.ParticipantID) {
+	fake.subscriberIDMutex.Lock()
+	defer fake.subscriberIDMutex.Unlock()
+	fake.SubscriberIDStub = stub
+}
+
+func (fake *FakeTrackSender) SubscriberIDReturns(result1 livekit.ParticipantID) {
+	fake.subscriberIDMutex.Lock()
+	defer fake.subscriberIDMutex.Unlock()
+	fake.SubscriberIDStub = nil
+	fake.subscriberIDReturns = struct {
+		result1 livekit.ParticipantID
+	}{result1}
+}
+
+func (fake *FakeTrackSender) SubscriberIDReturnsOnCall(i int, result1 livekit.ParticipantID) {
+	fake.subscriberIDMutex.Lock()
+	defer fake.subscriberIDMutex.Unlock()
+	fake.SubscriberIDStub = nil
+	if fake.subscriberIDReturnsOnCall == nil {
+		fake.subscriberIDReturnsOnCall = make(map[int]struct {
+			result1 livekit.ParticipantID
+		})
+	}
+	fake.subscriberIDReturnsOnCall[i] = struct {
+		result1 livekit.ParticipantID
+	}{result1}
+}
+
+func (fake *FakeTrackSender) UpTrackBitrateAvailabilityChange() {
+	fake.upTrackBitrateAvailabilityChangeMutex.Lock()
+	fake.upTrackBitrateAvailabilityChangeArgsForCall = append(fake.upTrackBitrateAvailabilityChangeArgsForCall, struct {
+	}{})
+	stub := fake.UpTrackBitrateAvailabilityChangeStub
+	fake.recordInvocation("UpTrackBitrateAvailabilityChange", []interface{}{})
+	fake.upTrackBitrateAvailabilityChangeMutex.Unlock()
+	if stub != nil {
+		fake.UpTrackBitrateAvailabilityChangeStub()
+	}
+}
+
+func (fake *FakeTrackSender) UpTrackBitrateAvailabilityChangeCallCount() int {
+	fake.upTrackBitrateAvailabilityChangeMutex.RLock()
+	defer fake.upTrackBitrateAvailabilityChangeMutex.RUnlock()
+	return len(fake.upTrackBitrateAvailabilityChangeArgsForCall)
+}
+
+func (fake *FakeTrackSender) UpTrackBitrateAvailabilityChangeCalls(stub func()) {
+	fake.upTrackBitrateAvailabilityChangeMutex.Lock()
+	defer fake.upTrackBitrateAvailabilityChangeMutex.Unlock()
+	fake.UpTrackBitrateAvailabilityChangeStub = stub
+}
+
+func (fake *FakeTrackSender) UpTrackBitrateReport(arg1 []int32, arg2 sfu.Bitrates) {
+	var arg1Copy []int32
+	if arg1 != nil {
+		arg1Copy = make([]int32, len(arg1))
+		copy(arg1Copy, arg1)
+	}
+	fake.upTrackBitrateReportMutex.Lock()
+	fake.upTrackBitrateReportArgsForCall = append(fake.upTrackBitrateReportArgsForCall, struct {
+		arg1 []int32
+		arg2 sfu.Bitrates
+	}{arg1Copy, arg2})
+	stub := fake.UpTrackBitrateReportStub
+	fake.recordInvocation("UpTrackBitrateReport", []interface{}{arg1Copy, arg2})
+	fake.upTrackBitrateReportMutex.Unlock()
+	if stub != nil {
+		fake.UpTrackBitrateReportStub(arg1, arg2)
+	}
+}
+
+func (fake *FakeTrackSender) UpTrackBitrateReportCallCount() int {
+	fake.upTrackBitrateReportMutex.RLock()
+	defer fake.upTrackBitrateReportMutex.RUnlock()
+	return len(fake.upTrackBitrateReportArgsForCall)
+}
+
+func (fake *FakeTrackSender) UpTrackBitrateReportCalls(stub func([]int32, sfu.Bitrates)) {
+	fake.upTrackBitrateReportMutex.Lock()
+	defer fake.upTrackBitrateReportMutex.Unlock()
+	fake.UpTrackBitrateReportStub = stub
+}
+
+func (fake *FakeTrackSender) UpTrackBitrateReportArgsForCall(i int) ([]int32, sfu.Bitrates) {
+	fake.upTrackBitrateReportMutex.RLock()
+	defer fake.upTrackBitrateReportMutex.RUnlock()
+	argsForCall := fake.upTrackBitrateReportArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeTrackSender) UpTrackLayersChange() {
+	fake.upTrackLayersChangeMutex.Lock()
+	fake.upTrackLayersChangeArgsForCall = append(fake.upTrackLayersChangeArgsForCall, struct {
+	}{})
+	stub := fake.UpTrackLayersChangeStub
+	fake.recordInvocation("UpTrackLayersChange", []interface{}{})
+	fake.upTrackLayersChangeMutex.Unlock()
+	if stub != nil {
+		fake.UpTrackLayersChangeStub()
+	}
+}
+
+func (fake *FakeTrackSender) UpTrackLayersChangeCallCount() int {
+	fake.upTrackLayersChangeMutex.RLock()
+	defer fake.upTrackLayersChangeMutex.RUnlock()
+	return len(fake.upTrackLayersChangeArgsForCall)
+}
+
+func (fake *FakeTrackSender) UpTrackLayersChangeCalls(stub func()) {
+	fake.upTrackLayersChangeMutex.Lock()
+	defer fake.upTrackLayersChangeMutex.Unlock()
+	fake.UpTrackLayersChangeStub = stub
+}
+
+func (fake *FakeTrackSender) UpTrackMaxPublishedLayerChange(arg1 int32) {
+	fake.upTrackMaxPublishedLayerChangeMutex.Lock()
+	fake.upTrackMaxPublishedLayerChangeArgsForCall = append(fake.upTrackMaxPublishedLayerChangeArgsForCall, struct {
+		arg1 int32
+	}{arg1})
+	stub := fake.UpTrackMaxPublishedLayerChangeStub
+	fake.recordInvocation("UpTrackMaxPublishedLayerChange", []interface{}{arg1})
+	fake.upTrackMaxPublishedLayerChangeMutex.Unlock()
+	if stub != nil {
+		fake.UpTrackMaxPublishedLayerChangeStub(arg1)
+	}
+}
+
+func (fake *FakeTrackSender) UpTrackMaxPublishedLayerChangeCallCount() int {
+	fake.upTrackMaxPublishedLayerChangeMutex.RLock()
+	defer fake.upTrackMaxPublishedLayerChangeMutex.RUnlock()
+	return len(fake.upTrackMaxPublishedLayerChangeArgsForCall)
+}
+
+func (fake *FakeTrackSender) UpTrackMaxPublishedLayerChangeCalls(stub func(int32)) {
+	fake.upTrackMaxPublishedLayerChangeMutex.Lock()
+	defer fake.upTrackMaxPublishedLayerChangeMutex.Unlock()
+	fake.UpTrackMaxPublishedLayerChangeStub = stub
+}
+
+func (fake *FakeTrackSender) UpTrackMaxPublishedLayerChangeArgsForCall(i int) int32 {
+	fake.upTrackMaxPublishedLayerChangeMutex.RLock()
+	defer fake.upTrackMaxPublishedLayerChangeMutex.RUnlock()
+	argsForCall := fake.upTrackMaxPublishedLayerChangeArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeTrackSender) UpTrackMaxTemporalLayerSeenChange(arg1 int32) {
+	fake.upTrackMaxTemporalLayerSeenChangeMutex.Lock()
+	fake.upTrackMaxTemporalLayerSeenChangeArgsForCall = append(fake.upTrackMaxTemporalLayerSeenChangeArgsForCall, struct {
+		arg1 int32
+	}{arg1})
+	stub := fake.UpTrackMaxTemporalLayerSeenChangeStub
+	fake.recordInvocation("UpTrackMaxTemporalLayerSeenChange", []interface{}{arg1})
+	fake.upTrackMaxTemporalLayerSeenChangeMutex.Unlock()
+	if stub != nil {
+		fake.UpTrackMaxTemporalLayerSeenChangeStub(arg1)
+	}
+}
+
+func (fake *FakeTrackSender) UpTrackMaxTemporalLayerSeenChangeCallCount() int {
+	fake.upTrackMaxTemporalLayerSeenChangeMutex.RLock()
+	defer fake.upTrackMaxTemporalLayerSeenChangeMutex.RUnlock()
+	return len(fake.upTrackMaxTemporalLayerSeenChangeArgsForCall)
+}
+
+func (fake *FakeTrackSender) UpTrackMaxTemporalLayerSeenChangeCalls(stub func(int32)) {
+	fake.upTrackMaxTemporalLayerSeenChangeMutex.Lock()
+	defer fake.upTrackMaxTemporalLayerSeenChangeMutex.Unlock()
+	fake.UpTrackMaxTemporalLayerSeenChangeStub = stub
+}
+
+func (fake *FakeTrackSender) UpTrackMaxTemporalLayerSeenChangeArgsForCall(i int) int32 {
+	fake.upTrackMaxTemporalLayerSeenChangeMutex.RLock()
+	defer fake.upTrackMaxTemporalLayerSeenChangeMutex.RUnlock()
+	argsForCall := fake.upTrackMaxTemporalLayerSeenChangeArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeTrackSender) WriteRTP(arg1 *buffer.ExtPacket, arg2 int32) int32 {
+	fake.writeRTPMutex.Lock()
+	ret, specificReturn := fake.writeRTPReturnsOnCall[len(fake.writeRTPArgsForCall)]
+	fake.writeRTPArgsForCall = append(fake.writeRTPArgsForCall, struct {
+		arg1 *buffer.ExtPacket
+		arg2 int32
+	}{arg1, arg2})
+	stub := fake.WriteRTPStub
+	fakeReturns := fake.writeRTPReturns
+	fake.recordInvocation("WriteRTP", []interface{}{arg1, arg2})
+	fake.writeRTPMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeTrackSender) WriteRTPCallCount() int {
+	fake.writeRTPMutex.RLock()
+	defer fake.writeRTPMutex.RUnlock()
+	return len(fake.writeRTPArgsForCall)
+}
+
+func (fake *FakeTrackSender) WriteRTPCalls(stub func(*buffer.ExtPacket, int32) int32) {
+	fake.writeRTPMutex.Lock()
+	defer fake.writeRTPMutex.Unlock()
+	fake.WriteRTPStub = stub
+}
+
+func (fake *FakeTrackSender) WriteRTPArgsForCall(i int) (*buffer.ExtPacket, int32) {
+	fake.writeRTPMutex.RLock()
+	defer fake.writeRTPMutex.RUnlock()
+	argsForCall := fake.writeRTPArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeTrackSender) WriteRTPReturns(result1 int32) {
+	fake.writeRTPMutex.Lock()
+	defer fake.writeRTPMutex.Unlock()
+	fake.WriteRTPStub = nil
+	fake.writeRTPReturns = struct {
+		result1 int32
+	}{result1}
+}
+
+func (fake *FakeTrackSender) WriteRTPReturnsOnCall(i int, result1 int32) {
+	fake.writeRTPMutex.Lock()
+	defer fake.writeRTPMutex.Unlock()
+	fake.WriteRTPStub = nil
+	if fake.writeRTPReturnsOnCall == nil {
+		fake.writeRTPReturnsOnCall = make(map[int]struct {
+			result1 int32
+		})
+	}
+	fake.writeRTPReturnsOnCall[i] = struct {
+		result1 int32
+	}{result1}
+}
+
+func (fake *FakeTrackSender) Invocations() map[string][][]interface{} {
+	fake.invocationsMutex.RLock()
+	defer fake.invocationsMutex.RUnlock()
+	copiedInvocations := map[string][][]interface{}{}
+	for key, value := range fake.invocations {
+		copiedInvocations[key] = value
+	}
+	return copiedInvocations
+}
+
+func (fake *FakeTrackSender) 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 _ sfu.TrackSender = new(FakeTrackSender)