From 13e4aaec2bffcafa4d39831ad7ba82fd33c0dc2a Mon Sep 17 00:00:00 2001 From: Raja Subramanian Date: Mon, 20 Jul 2026 20:15:07 +0530 Subject: [PATCH] Tests for down stream packet push. (#4692) * Tests for down stream packet push. A recent issue (padding bit in RTP header) surfaced a gap which slipped through due to lack of tests. Changes in pion/rtp were not adopted properly. So, adding some tests (thank you Claude for the heavy lifting) to test the down stream packet path using the whole pion chain. Split out some interfaces so it is easier to have it all in one place and create fakes. Will help adding more tests, for example include the upstream path also in the integration test. May have to create more interfaces and make things testable, but this is a start. * missed file * rtx specific test --- go.mod | 2 +- pkg/sfu/downtrack.go | 73 - .../downtrack_downstream_integration_test.go | 1020 +++++++++ pkg/sfu/export_test.go | 71 + pkg/sfu/forwarder.go | 8 + pkg/sfu/interfaces.go | 187 ++ pkg/sfu/receiver_base.go | 76 - pkg/sfu/sfufakes/fake_down_track_listener.go | 280 +++ ...ke_down_track_stream_allocator_listener.go | 586 +++++ pkg/sfu/sfufakes/fake_redtransformer.go | 1913 +++++++++++++++++ pkg/sfu/sfufakes/fake_track_receiver.go | 1613 ++++++++++++++ pkg/sfu/sfufakes/fake_track_sender.go | 683 ++++++ 12 files changed, 6362 insertions(+), 150 deletions(-) create mode 100644 pkg/sfu/downtrack_downstream_integration_test.go create mode 100644 pkg/sfu/export_test.go create mode 100644 pkg/sfu/interfaces.go create mode 100644 pkg/sfu/sfufakes/fake_down_track_listener.go create mode 100644 pkg/sfu/sfufakes/fake_down_track_stream_allocator_listener.go create mode 100644 pkg/sfu/sfufakes/fake_redtransformer.go create mode 100644 pkg/sfu/sfufakes/fake_track_receiver.go create mode 100644 pkg/sfu/sfufakes/fake_track_sender.go diff --git a/go.mod b/go.mod index 357709865..a37991613 100644 --- a/go.mod +++ b/go.mod @@ -131,7 +131,7 @@ require ( github.com/nats-io/nuid v1.0.1 // indirect github.com/opencontainers/go-digest v1.0.0 // indirect github.com/opencontainers/image-spec v1.1.1 // indirect - github.com/pion/logging v0.2.4 // indirect + github.com/pion/logging v0.2.4 github.com/pion/mdns/v2 v2.1.0 // indirect github.com/pion/randutil v0.1.0 // indirect github.com/pion/srtp/v3 v3.0.12 // indirect diff --git a/pkg/sfu/downtrack.go b/pkg/sfu/downtrack.go index 7a13ae464..aeb3725ac 100644 --- a/pkg/sfu/downtrack.go +++ b/pkg/sfu/downtrack.go @@ -51,29 +51,6 @@ import ( "github.com/livekit/livekit-server/pkg/sfu/utils" ) -// TrackSender defines an interface send media to remote peer -type TrackSender interface { - UpTrackLayersChange() - UpTrackBitrateAvailabilityChange() - UpTrackMaxPublishedLayerChange(maxPublishedLayer int32) - UpTrackMaxTemporalLayerSeenChange(maxTemporalLayerSeen int32) - UpTrackBitrateReport(availableLayers []int32, bitrates Bitrates) - WriteRTP(p *buffer.ExtPacket, layer int32) int32 - Close() - IsClosed() bool - // ID is the globally unique identifier for this Track. - ID() string - SubscriberID() livekit.ParticipantID - HandleRTCPSenderReportData( - payloadType webrtc.PayloadType, - layer int32, - publisherSRData *livekit.RTCPSenderReportState, - ) error - Resync() - SetReceiver(TrackReceiver) - ReceiverRestart(TrackReceiver) -} - // ------------------------------------------------------------------- const ( @@ -217,56 +194,6 @@ func (d DownTrackState) MarshalLogObject(e zapcore.ObjectEncoder) error { // ------------------------------------------------------------------- -type DownTrackStreamAllocatorListener interface { - // RTCP received - OnREMB(dt *DownTrack, remb *rtcp.ReceiverEstimatedMaximumBitrate) - OnTransportCCFeedback(dt *DownTrack, cc *rtcp.TransportLayerCC) - - // video layer availability changed - OnAvailableLayersChanged(dt *DownTrack) - - // video layer bitrate availability changed - OnBitrateAvailabilityChanged(dt *DownTrack) - - // max published spatial layer changed - OnMaxPublishedSpatialChanged(dt *DownTrack) - - // max published temporal layer changed - OnMaxPublishedTemporalChanged(dt *DownTrack) - - // subscription changed - mute/unmute - OnSubscriptionChanged(dt *DownTrack) - - // subscribed max video layer changed - OnSubscribedLayerChanged(dt *DownTrack, layers buffer.VideoLayer) - - // stream resumed - OnResume(dt *DownTrack) - - // check if track should participate in BWE - IsBWEEnabled(dt *DownTrack) bool - - // get the BWE type in use - BWEType() bwe.BWEType - - // check if subscription mute can be applied - IsSubscribeMutable(dt *DownTrack) bool -} - -// ------------------------------------------------------------------- - -type DownTrackListener interface { - OnBindAndConnected() - OnStatsUpdate(stat *livekit.AnalyticsStat) - OnMaxSubscribedLayerChanged(layer int32) - OnRttUpdate(rtt uint32) - OnCodecNegotiated(webrtc.RTPCodecCapability) - OnDownTrackClose(isExpectedToResume bool) - OnStreamStarted() -} - -// ------------------------------------------------------------------- - type bindState int const ( diff --git a/pkg/sfu/downtrack_downstream_integration_test.go b/pkg/sfu/downtrack_downstream_integration_test.go new file mode 100644 index 000000000..2d52d35ca --- /dev/null +++ b/pkg/sfu/downtrack_downstream_integration_test.go @@ -0,0 +1,1020 @@ +// Copyright 2026 LiveKit, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package sfu_test + +// This file contains real-pion integration tests for the DownTrack downstream +// packet push path. +// +// Rather than mocking the pacer/write stream, these tests wire a real DownTrack +// (optionally with a real StreamAllocator + Pacer + BWE) to a real pion +// PeerConnection and push packets over an in-memory pion vnet to a second real +// pion PeerConnection, which reads them back off the wire. +// +// The suite drives the four ways a DownTrack emits packets downstream and +// verifies the on-wire RTP header and payload produced by each: SSRC, payload +// type, sequence number, timestamp, marker, payload bytes, and the padding +// bit / padding size. +// +// WriteRTP - forwarding translated media +// retransmitPacket - retransmitting (RTX) media +// WritePaddingRTP - padding-only packets +// WriteProbePackets - RTX probe packets +// +// pion's rtp.Packet.Unmarshal rejects a packet whose padding bit is set but whose +// trailing padding-size byte is invalid/zero (errInvalidRTPPadding), so a +// malformed packet is dropped by the receiver and never arrives. Arrival on the +// far side is therefore itself evidence that the packet was serialized correctly. + +import ( + "bytes" + "encoding/binary" + "io" + "sync" + "testing" + "time" + + "github.com/pion/interceptor" + "github.com/pion/logging" + "github.com/pion/rtcp" + "github.com/pion/rtp" + "github.com/pion/sdp/v3" + "github.com/pion/transport/v4/vnet" + "github.com/pion/webrtc/v4" + "github.com/stretchr/testify/require" + + "github.com/livekit/mediatransportutil/pkg/codec" + "github.com/livekit/protocol/codecs/mime" + "github.com/livekit/protocol/livekit" + "github.com/livekit/protocol/logger" + + . "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/livekit/livekit-server/pkg/sfu/bwe/remotebwe" + "github.com/livekit/livekit-server/pkg/sfu/bwe/sendsidebwe" + "github.com/livekit/livekit-server/pkg/sfu/ccutils" + "github.com/livekit/livekit-server/pkg/sfu/pacer" + "github.com/livekit/livekit-server/pkg/sfu/sfufakes" + "github.com/livekit/livekit-server/pkg/sfu/streamallocator" + "github.com/livekit/livekit-server/pkg/sfu/testutils" +) + +// ----------------------------------------------------------------------------- +// vnet harness +// ----------------------------------------------------------------------------- + +type vnetHarness struct { + wan *vnet.Router + offerNet *vnet.Net + answerNet *vnet.Net +} + +func buildVNet(t *testing.T) *vnetHarness { + t.Helper() + + wan, err := vnet.NewRouter(&vnet.RouterConfig{ + CIDR: "1.2.3.0/24", + LoggerFactory: logging.NewDefaultLoggerFactory(), + }) + require.NoError(t, err) + + offerNet, err := vnet.NewNet(&vnet.NetConfig{StaticIPs: []string{"1.2.3.4"}}) + require.NoError(t, err) + require.NoError(t, wan.AddNet(offerNet)) + + answerNet, err := vnet.NewNet(&vnet.NetConfig{StaticIPs: []string{"1.2.3.5"}}) + require.NoError(t, err) + require.NoError(t, wan.AddNet(answerNet)) + + require.NoError(t, wan.Start()) + t.Cleanup(func() { _ = wan.Stop() }) + + return &vnetHarness{wan: wan, offerNet: offerNet, answerNet: answerNet} +} + +// mediaEngineConfig describes what codecs / header extensions to register on a PC. +type mediaEngineConfig struct { + video bool // register VP8 (+ RTX); otherwise register opus + headerExtensions bool // register abs-send-time + transport-cc header extensions +} + +func newMediaPC(t *testing.T, net *vnet.Net, factory *buffer.Factory, cfg mediaEngineConfig) *webrtc.PeerConnection { + t.Helper() + + me := &webrtc.MediaEngine{} + if cfg.video { + require.NoError(t, me.RegisterCodec(webrtc.RTPCodecParameters{ + RTPCodecCapability: webrtc.RTPCodecCapability{ + MimeType: webrtc.MimeTypeVP8, ClockRate: 90000, RTCPFeedback: videoRTCPFeedback(), + }, + PayloadType: 96, + }, webrtc.RTPCodecTypeVideo)) + require.NoError(t, me.RegisterCodec(webrtc.RTPCodecParameters{ + RTPCodecCapability: webrtc.RTPCodecCapability{ + MimeType: webrtc.MimeTypeRTX, ClockRate: 90000, SDPFmtpLine: "apt=96", + }, + PayloadType: 97, + }, webrtc.RTPCodecTypeVideo)) + } else { + require.NoError(t, me.RegisterCodec(webrtc.RTPCodecParameters{ + RTPCodecCapability: webrtc.RTPCodecCapability{ + MimeType: webrtc.MimeTypeOpus, ClockRate: 48000, Channels: 2, + }, + PayloadType: 111, + }, webrtc.RTPCodecTypeAudio)) + } + + if cfg.headerExtensions { + kind := webrtc.RTPCodecTypeAudio + if cfg.video { + kind = webrtc.RTPCodecTypeVideo + } + require.NoError(t, me.RegisterHeaderExtension(webrtc.RTPHeaderExtensionCapability{URI: sdp.ABSSendTimeURI}, kind)) + require.NoError(t, me.RegisterHeaderExtension(webrtc.RTPHeaderExtensionCapability{URI: sdp.TransportCCURI}, kind)) + } + + // no pion default interceptors: the DownTrack/pacer fill abs-send-time and + // transport-cc themselves, and the tests drive RTCP feedback synthetically, so + // pion's own feedback generators would only add nondeterminism. + ir := &interceptor.Registry{} + + se := webrtc.SettingEngine{} + se.SetNet(net) + se.SetICETimeouts(time.Second, time.Second, 200*time.Millisecond) + se.SetNetworkTypes([]webrtc.NetworkType{webrtc.NetworkTypeUDP4}) + if factory != nil { + se.BufferFactory = factory.GetOrNew + } + + api := webrtc.NewAPI( + webrtc.WithMediaEngine(me), + webrtc.WithInterceptorRegistry(ir), + webrtc.WithSettingEngine(se), + ) + pc, err := api.NewPeerConnection(webrtc.Configuration{}) + require.NoError(t, err) + t.Cleanup(func() { _ = pc.Close() }) + + return pc +} + +func videoRTCPFeedback() []webrtc.RTCPFeedback { + return []webrtc.RTCPFeedback{ + {Type: "nack"}, + {Type: "nack", Parameter: "pli"}, + {Type: webrtc.TypeRTCPFBTransportCC}, + {Type: webrtc.TypeRTCPFBGoogREMB}, + } +} + +// signalPair performs a full offer/answer exchange between two PCs (adapted from +// pion's own test helper) and waits for both to reach the connected state. +func signalPair(t *testing.T, offerer, answerer *webrtc.PeerConnection) { + t.Helper() + + connected := untilConnected(offerer, answerer) + + offer, err := offerer.CreateOffer(nil) + require.NoError(t, err) + gatherOffer := webrtc.GatheringCompletePromise(offerer) + require.NoError(t, offerer.SetLocalDescription(offer)) + <-gatherOffer + + require.NoError(t, answerer.SetRemoteDescription(*offerer.LocalDescription())) + + answer, err := answerer.CreateAnswer(nil) + require.NoError(t, err) + gatherAnswer := webrtc.GatheringCompletePromise(answerer) + require.NoError(t, answerer.SetLocalDescription(answer)) + <-gatherAnswer + + require.NoError(t, offerer.SetRemoteDescription(*answerer.LocalDescription())) + + select { + case <-connected: + case <-time.After(10 * time.Second): + t.Fatal("timed out waiting for peer connections to connect") + } +} + +func untilConnected(pcs ...*webrtc.PeerConnection) <-chan struct{} { + var wg sync.WaitGroup + wg.Add(len(pcs)) + for _, pc := range pcs { + var once sync.Once + pc.OnConnectionStateChange(func(s webrtc.PeerConnectionState) { + if s == webrtc.PeerConnectionStateConnected { + once.Do(wg.Done) + } + }) + } + done := make(chan struct{}) + go func() { + wg.Wait() + close(done) + }() + return done +} + +// ----------------------------------------------------------------------------- +// packet capture on the far side +// ----------------------------------------------------------------------------- + +type packetCapture struct { + lock sync.Mutex + packets []*rtp.Packet +} + +func (c *packetCapture) add(p *rtp.Packet) { + c.lock.Lock() + defer c.lock.Unlock() + cp := *p + c.packets = append(c.packets, &cp) +} + +func (c *packetCapture) count() int { + c.lock.Lock() + defer c.lock.Unlock() + return len(c.packets) +} + +func (c *packetCapture) all() []*rtp.Packet { + c.lock.Lock() + defer c.lock.Unlock() + return append([]*rtp.Packet(nil), c.packets...) +} + +// captureTrack wires an OnTrack handler on the receiving PC that reads RTP packets +// into the capture until the track ends. +func captureTrack(pc *webrtc.PeerConnection) *packetCapture { + cap := &packetCapture{} + pc.OnTrack(func(track *webrtc.TrackRemote, _ *webrtc.RTPReceiver) { + go func() { + for { + pkt, _, err := track.ReadRTP() + if err != nil { + return + } + cap.add(pkt) + } + }() + }) + return cap +} + +// ----------------------------------------------------------------------------- +// fakes (from pkg/sfu/sfufakes) + a null BWE +// ----------------------------------------------------------------------------- + +// newFakeTrackReceiver returns a counterfeiter FakeTrackReceiver configured just +// enough for a DownTrack to bind and forward: it reports the given codec and fires +// its readiness callback immediately so Bind completes. +func newFakeTrackReceiver(codecParams webrtc.RTPCodecParameters) *sfufakes.FakeTrackReceiver { + r := &sfufakes.FakeTrackReceiver{} + r.TrackIDReturns("fake-track") + r.StreamIDReturns("fake-stream") + r.CodecReturns(codecParams) + r.MimeReturns(mime.NormalizeMimeType(codecParams.MimeType)) + r.VideoLayerModeReturns(livekit.VideoLayer_MODE_UNUSED) + r.HeaderExtensionsReturns(nil) + r.IsClosedReturns(false) + r.TrackInfoReturns(&livekit.TrackInfo{}) + r.CodecStateReturns(ReceiverCodecStateNormal) + r.GetPrimaryReceiverForRedReturns(r) + r.GetRedReceiverReturns(r) + r.ReadRTPReturns(0, io.EOF) + // AddOnReady must invoke its callback immediately so Bind reaches the bound state. + r.AddOnReadyCalls(func(f func()) { f() }) + return r +} + +// nullBWE is a complete no-op bwe.BWE for tests that do not exercise estimation. +// bwe.NullBWE is meant to be embedded and lacks a couple of interface methods. +type nullBWE struct { + *bwe.NullBWE +} + +func newNullBWE() *nullBWE { return &nullBWE{NullBWE: &bwe.NullBWE{}} } +func (nullBWE) Type() bwe.BWEType { return bwe.BWETypeNone } + +// ----------------------------------------------------------------------------- +// DownTrack harness +// ----------------------------------------------------------------------------- + +var ( + opusCodecParams = webrtc.RTPCodecParameters{ + RTPCodecCapability: webrtc.RTPCodecCapability{MimeType: webrtc.MimeTypeOpus, ClockRate: 48000, Channels: 2}, + PayloadType: 111, + } + vp8CodecParams = webrtc.RTPCodecParameters{ + RTPCodecCapability: webrtc.RTPCodecCapability{MimeType: webrtc.MimeTypeVP8, ClockRate: 90000, RTCPFeedback: videoRTCPFeedback()}, + PayloadType: 96, + } +) + +type downTrackHarness struct { + dt *DownTrack + receiver *sfufakes.FakeTrackReceiver + pacer pacer.Pacer + capture *packetCapture + sender *webrtc.PeerConnection + sub *webrtc.PeerConnection +} + +// newBoundDownTrack builds a real DownTrack, attaches it to a real sender PC, +// negotiates with a real subscriber PC over vnet, and makes it writable. +func newBoundDownTrack(t *testing.T, h *vnetHarness, factory *buffer.Factory, codecParams webrtc.RTPCodecParameters, p pacer.Pacer, meCfg mediaEngineConfig) *downTrackHarness { + t.Helper() + + sender := newMediaPC(t, h.offerNet, factory, meCfg) + sub := newMediaPC(t, h.answerNet, factory, meCfg) + capture := captureTrack(sub) + + rcv := newFakeTrackReceiver(codecParams) + dt, err := NewDownTrack(DownTrackParams{ + Codecs: []webrtc.RTPCodecParameters{codecParams}, + Receiver: rcv, + BufferFactory: factory, + Pacer: p, + Logger: logger.GetLogger(), + Listener: &sfufakes.FakeDownTrackListener{}, + StreamID: "fake-stream", + SubID: "fake-sub", + MaxTrack: 500, + }) + require.NoError(t, err) + + tr, err := sender.AddTransceiverFromTrack(dt, webrtc.RTPTransceiverInit{Direction: webrtc.RTPTransceiverDirectionSendonly}) + require.NoError(t, err) + dt.SetTransceiver(tr) + + signalPair(t, sender, sub) + dt.SetConnected() + + require.Eventually(t, func() bool { + return dt.IsWritableForTest() + }, 10*time.Second, 20*time.Millisecond, "downtrack did not become writable") + + return &downTrackHarness{ + dt: dt, + receiver: rcv, + pacer: p, + capture: capture, + sender: sender, + sub: sub, + } +} + +// distinctivePayload builds a per-packet payload with recognizable bytes so payload +// fidelity can be asserted end-to-end. +func distinctivePayload(seed byte, n int) []byte { + b := make([]byte, n) + for j := range b { + b[j] = seed + byte(j) + } + return b +} + +// ----------------------------------------------------------------------------- +// spike: confirm vnet + real pion media forwarding works with this pion version +// ----------------------------------------------------------------------------- + +func TestPionVNetForwardingSpike(t *testing.T) { + h := buildVNet(t) + + sender := newMediaPC(t, h.offerNet, nil, mediaEngineConfig{video: true}) + receiver := newMediaPC(t, h.answerNet, nil, mediaEngineConfig{video: true}) + + track, err := webrtc.NewTrackLocalStaticRTP( + webrtc.RTPCodecCapability{MimeType: webrtc.MimeTypeVP8, ClockRate: 90000}, + "video", "pion-spike", + ) + require.NoError(t, err) + _, err = sender.AddTrack(track) + require.NoError(t, err) + + cap := captureTrack(receiver) + + signalPair(t, sender, receiver) + + // pump a few RTP packets from the sender track + go func() { + sn := uint16(1000) + ts := uint32(0) + for i := 0; i < 200; i++ { + _ = track.WriteRTP(&rtp.Packet{ + Header: rtp.Header{ + Version: 2, + PayloadType: 96, + SequenceNumber: sn, + Timestamp: ts, + SSRC: 0x1234, + }, + Payload: []byte{0x10, 0x00, 0x00, 0x01, 0x02, 0x03}, + }) + sn++ + ts += 3000 + time.Sleep(2 * time.Millisecond) + } + }() + + require.Eventually(t, func() bool { + return cap.count() >= 5 + }, 10*time.Second, 20*time.Millisecond, "expected to receive forwarded RTP over vnet") +} + +// ----------------------------------------------------------------------------- +// WriteRTP: media forwarding +// ----------------------------------------------------------------------------- + +// TestDownTrackForwardsMedia exercises the WriteRTP media forwarding path and +// verifies the full forwarded header/payload on the far side: SSRC, payload type, +// contiguous sequence numbers, timestamps, payload bytes, and that the padding bit +// is cleared regardless of the source packet's padding bit. +func TestDownTrackForwardsMedia(t *testing.T) { + h := buildVNet(t) + factory := buffer.NewFactoryOfBufferFactory(500, 500).CreateBufferFactory() + p := pacer.NewPassThrough(logger.GetLogger(), newNullBWE()) + t.Cleanup(p.Stop) + + dh := newBoundDownTrack(t, h, factory, opusCodecParams, p, mediaEngineConfig{video: false}) + + const numPackets = 20 + sn := uint16(23333) + ts := uint32(0xabcdef) + wantPayload := map[uint16][]byte{} + wantTS := map[uint16]uint32{} + for i := 0; i < numPackets; i++ { + ep, err := testutils.GetTestExtPacket(&testutils.TestExtPacketParams{ + SequenceNumber: sn, + Timestamp: ts, + SSRC: 0x12345678, + PayloadType: 111, + PayloadSize: 40, + }) + require.NoError(t, err) + // distinctive payload so payload fidelity can be checked on the far side + payload := distinctivePayload(byte(i+1), 40) + ep.Packet.Payload = payload + // every other source packet carries the padding bit; the forwarded packet + // must not inherit it. + if i%2 == 0 { + ep.Packet.Header.Padding = true + } + wantPayload[sn] = payload + wantTS[sn] = ts + + require.Equal(t, int32(1), dh.dt.WriteRTP(ep, 0), "packet %d should be forwarded", i) + sn++ + ts += 960 + } + + require.Eventually(t, func() bool { + return dh.capture.count() >= numPackets + }, 10*time.Second, 20*time.Millisecond, "expected all forwarded media packets to arrive") + + pkts := dh.capture.all() + seen := map[uint16]bool{} + for _, pkt := range pkts { + require.EqualValues(t, dh.dt.SSRC(), pkt.SSRC, "forwarded packet on wrong SSRC") + require.EqualValues(t, 111, pkt.PayloadType, "forwarded packet has wrong payload type") + require.False(t, pkt.Header.Padding, "forwarded media packet must not carry padding bit (sn=%d)", pkt.SequenceNumber) + + wp, ok := wantPayload[pkt.SequenceNumber] + require.True(t, ok, "received unexpected sequence number %d", pkt.SequenceNumber) + require.Equal(t, wp, pkt.Payload, "forwarded payload mismatch (sn=%d)", pkt.SequenceNumber) + require.Equal(t, wantTS[pkt.SequenceNumber], pkt.Timestamp, "forwarded timestamp mismatch (sn=%d)", pkt.SequenceNumber) + seen[pkt.SequenceNumber] = true + } + + // every source packet must have been forwarded, and the forwarded sequence + // numbers must be contiguous. + for want := uint16(23333); want < 23333+numPackets; want++ { + require.True(t, seen[want], "sequence number %d was not forwarded", want) + } +} + +// ----------------------------------------------------------------------------- +// retransmitPacket: RTX / retransmission +// ----------------------------------------------------------------------------- + +// TestDownTrackRetransmitsPacketsAsIs exercises the retransmit path when no RTX +// stream is negotiated, so the packet is re-sent as-is on the primary SSRC/payload +// type. It verifies the retransmitted header/payload on the far side: SSRC, payload +// type, sequence number, timestamp, payload bytes, and that the padding bit is +// cleared regardless of the source packet's padding bit. +func TestDownTrackRetransmitsPacketsAsIs(t *testing.T) { + h := buildVNet(t) + factory := buffer.NewFactoryOfBufferFactory(500, 500).CreateBufferFactory() + p := pacer.NewPassThrough(logger.GetLogger(), newNullBWE()) + t.Cleanup(p.Stop) + + dh := newBoundDownTrack(t, h, factory, opusCodecParams, p, mediaEngineConfig{video: false}) + + const numPackets = 10 + targetSN := uint16(40000) + wantPayload := map[uint16][]byte{} + wantTS := map[uint16]uint32{} + for i := 0; i < numPackets; i++ { + // build a source packet that carries the padding bit (valid padding trailer) + // and a distinctive payload. + payload := distinctivePayload(byte(i+100), 30) + src := &rtp.Packet{ + Header: rtp.Header{ + Version: 2, + Padding: true, + PaddingSize: 20, + PayloadType: 111, + SequenceNumber: uint16(1000 + i), + Timestamp: uint32(90000 + i*960), + SSRC: 0x22222222, + }, + Payload: payload, + } + raw, err := src.Marshal() + require.NoError(t, err) + + ts := uint32(500000 + i*960) + wantPayload[targetSN] = payload + wantTS[targetSN] = ts + + _, err = dh.dt.RetransmitForTest( + uint64(src.SequenceNumber), + targetSN, + ts, + uint64(ts), + 0, + raw, + ) + require.NoError(t, err) + targetSN++ + } + + require.Eventually(t, func() bool { + return dh.capture.count() >= numPackets + }, 10*time.Second, 20*time.Millisecond, "expected all retransmitted packets to arrive") + + seen := map[uint16]bool{} + for _, pkt := range dh.capture.all() { + require.EqualValues(t, dh.dt.SSRC(), pkt.SSRC, "retransmitted packet on wrong SSRC") + require.EqualValues(t, 111, pkt.PayloadType, "retransmitted packet has wrong payload type") + require.False(t, pkt.Header.Padding, "retransmitted packet must not carry padding bit (sn=%d)", pkt.SequenceNumber) + + wp, ok := wantPayload[pkt.SequenceNumber] + require.True(t, ok, "received unexpected sequence number %d", pkt.SequenceNumber) + require.Equal(t, wp, pkt.Payload, "retransmitted payload mismatch (sn=%d)", pkt.SequenceNumber) + require.Equal(t, wantTS[pkt.SequenceNumber], pkt.Timestamp, "retransmitted timestamp mismatch (sn=%d)", pkt.SequenceNumber) + seen[pkt.SequenceNumber] = true + } + + for want := uint16(40000); want < 40000+numPackets; want++ { + require.True(t, seen[want], "retransmitted sequence number %d did not arrive", want) + } +} + +// TestDownTrackRetransmitsPacketsViaRTX exercises the retransmit path when an RTX +// stream is negotiated. Each retransmitted packet must be emitted on the RTX SSRC +// with the RTX payload type, carry the original media sequence number as the OSN +// prefix (the first two payload bytes), draw its sequence number from the DownTrack's +// RTX sequence space, and clear the padding bit. +// +// RTX packets are captured at the pacer as the DownTrack builds them: pion's +// receiver-side RTX handling de-RTXes / consumes them, so the RTX-specific header +// fields are not observable on the far side. The packets are still handed to the real +// pacer (and written over pion). +func TestDownTrackRetransmitsPacketsViaRTX(t *testing.T) { + h := buildVNet(t) + factory := buffer.NewFactoryOfBufferFactory(500, 500).CreateBufferFactory() + cp := &capturingPacer{inner: pacer.NewPassThrough(logger.GetLogger(), newNullBWE())} + t.Cleanup(cp.Stop) + + // VP8 registers an RTX codec, so the bound DownTrack has an RTX SSRC / payload type. + dh := newBoundDownTrack(t, h, factory, vp8CodecParams, cp, mediaEngineConfig{video: true}) + require.NotZero(t, dh.dt.SSRCRTX(), "RTX ssrc should be negotiated") + require.NotZero(t, dh.dt.PayloadTypeRTXForTest(), "RTX payload type should be negotiated") + + type want struct { + payload []byte + ts uint32 + } + const numPackets = 10 + osnBase := uint16(50000) + wants := map[uint16]want{} // keyed by OSN (the original media sequence number) + targetSN := osnBase + for i := 0; i < numPackets; i++ { + // build a source packet that carries the padding bit (valid padding trailer) + // and a distinctive payload. + payload := distinctivePayload(byte(i+100), 30) + src := &rtp.Packet{ + Header: rtp.Header{ + Version: 2, + Padding: true, + PaddingSize: 20, + PayloadType: 96, + SequenceNumber: uint16(2000 + i), + Timestamp: uint32(180000 + i*3000), + SSRC: 0x33333333, + }, + Payload: payload, + } + raw, err := src.Marshal() + require.NoError(t, err) + + ts := uint32(700000 + i*3000) + wants[targetSN] = want{payload: payload, ts: ts} + + _, err = dh.dt.RetransmitForTest(uint64(src.SequenceNumber), targetSN, ts, uint64(ts), 0, raw) + require.NoError(t, err) + targetSN++ + } + + require.Eventually(t, func() bool { + return len(cp.rtxPackets()) >= numPackets + }, 5*time.Second, 20*time.Millisecond, "expected RTX packets to be emitted") + + seen := map[uint16]bool{} + rtxSeqs := make([]uint16, 0, numPackets) + for _, pr := range cp.rtxPackets() { + require.EqualValues(t, dh.dt.SSRCRTX(), pr.hdr.SSRC, "retransmitted packet must be on the RTX SSRC") + require.EqualValues(t, dh.dt.PayloadTypeRTXForTest(), pr.hdr.PayloadType, "retransmitted packet must use the RTX payload type") + require.False(t, pr.hdr.Padding, "retransmitted packet must not carry padding bit") + require.GreaterOrEqual(t, len(pr.payload), 2, "RTX payload must contain the OSN prefix") + + osn := binary.BigEndian.Uint16(pr.payload[0:2]) + w, ok := wants[osn] + require.True(t, ok, "unexpected OSN %d", osn) + require.Equal(t, w.payload, pr.payload[2:], "RTX media payload mismatch (osn=%d)", osn) + require.Equal(t, w.ts, pr.hdr.Timestamp, "RTX timestamp mismatch (osn=%d)", osn) + seen[osn] = true + rtxSeqs = append(rtxSeqs, pr.hdr.SequenceNumber) + } + + for osn := osnBase; osn < osnBase+numPackets; osn++ { + require.True(t, seen[osn], "OSN %d was not retransmitted via RTX", osn) + } + + // RTX-stream sequence numbers come from the DownTrack's own RTX sequence space + // and must advance by one per packet. + require.Len(t, rtxSeqs, numPackets) + for i := 1; i < len(rtxSeqs); i++ { + require.EqualValues(t, rtxSeqs[i-1]+1, rtxSeqs[i], "RTX sequence numbers must be contiguous") + } +} + +// ----------------------------------------------------------------------------- +// WritePaddingRTP: padding-only packets +// ----------------------------------------------------------------------------- + +// TestDownTrackSendsPaddingOnlyPackets exercises the WritePaddingRTP padding-only +// path. It first forwards a video keyframe (verifying the media header/payload), +// then emits padding-only packets and verifies each one on the far side: it is on +// the primary SSRC/payload type, carries the padding bit, and declares a full +// padding block. +// +// A padding-only packet is entirely padding; pion/srtp serializes the padding block +// from header.PaddingSize (via rtp.MarshalPacketTo), and the pion receiver strips it +// and reports both the padding bit and the padding size, so the received payload +// length equals the declared padding size (RTPPaddingMaxPayloadSize). +func TestDownTrackSendsPaddingOnlyPackets(t *testing.T) { + h := buildVNet(t) + factory := buffer.NewFactoryOfBufferFactory(500, 500).CreateBufferFactory() + p := pacer.NewPassThrough(logger.GetLogger(), newNullBWE()) + t.Cleanup(p.Stop) + + dh := newBoundDownTrack(t, h, factory, vp8CodecParams, p, mediaEngineConfig{video: true}) + + // force a valid target/current layer so the video forwarder will forward (test seam + // also used by forwarder_test.go's disable()). + dh.dt.ForceForwardLayerForTest(buffer.VideoLayer{Spatial: 0, Temporal: 0}) + + // forward a keyframe so rtpStats becomes active and the stream is running + vp8 := &codec.VP8{ + FirstByte: 0x10, + S: true, + PictureID: 1, + IsKeyFrame: true, + } + keyframePayload := distinctivePayload(0x40, 50) + ep, err := testutils.GetTestExtPacketVP8(&testutils.TestExtPacketParams{ + SequenceNumber: 5000, + Timestamp: 180000, + SSRC: 0x33333333, + PayloadType: 96, + PayloadSize: 50, + IsKeyFrame: true, + Marker: true, // end of frame, so padding can be emitted on the frame boundary + }, vp8) + require.NoError(t, err) + ep.Packet.Payload = keyframePayload + require.Equal(t, int32(1), dh.dt.WriteRTP(ep, 0), "keyframe should forward") + + require.True(t, dh.dt.RTPStatsActiveForTest(), "rtpStats should be active after forwarding") + + // wait for the media keyframe to arrive, then take the baseline count. + require.Eventually(t, func() bool { + return dh.capture.count() >= 1 + }, 10*time.Second, 20*time.Millisecond, "expected media keyframe to arrive") + baseline := dh.capture.count() + + // emit padding-only packets. paddingOnMute=true bypasses the RR/active gating so + // this stays deterministic; the header construction (Padding + PaddingSize) is the + // same code path either way. + const numPadding = 3 + sent := 0 + require.Eventually(t, func() bool { + if dh.dt.WritePaddingRTP(500, true, false) > 0 { + sent++ + } + return sent >= numPadding + }, 5*time.Second, 20*time.Millisecond, "expected WritePaddingRTP to emit padding packets") + + // the padding-only packets must arrive on the far side. + require.Eventually(t, func() bool { + return dh.capture.count() >= baseline+numPadding + }, 10*time.Second, 20*time.Millisecond, "expected padding-only packets to arrive on the far side") + + sawKeyframe := 0 + sawPadding := 0 + for _, pkt := range dh.capture.all() { + require.EqualValues(t, dh.dt.SSRC(), pkt.SSRC, "packet on wrong SSRC") + require.EqualValues(t, 96, pkt.PayloadType, "packet has wrong payload type") + + if !pkt.Header.Padding { + // the forwarded media keyframe + require.True(t, pkt.Header.Marker, "forwarded keyframe should carry the marker bit") + // the forwarder prepends the VP8 payload descriptor, so the media bytes + // appear as a suffix of the forwarded payload. + require.True(t, bytes.HasSuffix(pkt.Payload, keyframePayload), "forwarded keyframe payload mismatch") + sawKeyframe++ + continue + } + + // a padding-only packet: it must declare a full padding block. + require.EqualValues(t, RTPPaddingMaxPayloadSize, pkt.Header.PaddingSize, + "padding-only packet must declare full padding size (sn=%d)", pkt.SequenceNumber) + require.Equal(t, RTPPaddingMaxPayloadSize, len(pkt.Payload), + "padding-only packet must serialize a full padding block (sn=%d)", pkt.SequenceNumber) + sawPadding++ + } + require.Equal(t, 1, sawKeyframe, "expected exactly one forwarded media keyframe") + require.GreaterOrEqual(t, sawPadding, numPadding, "expected the padding-only packets to be observed") +} + +// ----------------------------------------------------------------------------- +// WriteProbePackets: RTX probe packets (with StreamAllocator + Pacer + BWE) +// ----------------------------------------------------------------------------- + +// capturingProbe records what the DownTrack handed the pacer for a probe packet. +type capturingProbe struct { + hdr rtp.Header + payloadLen int + lastByte byte +} + +// capturedRTX records what the DownTrack handed the pacer for an RTX packet. +type capturedRTX struct { + hdr rtp.Header + payload []byte +} + +// capturingPacer wraps a real pacer.Pacer, records probe and RTX packets as the +// DownTrack constructs them (before the real pacer patches/marshals them), and +// delegates everything to the wrapped pacer so packets are still sent over real pion. +type capturingPacer struct { + inner pacer.Pacer + + lock sync.Mutex + probes []capturingProbe + rtx []capturedRTX +} + +func (c *capturingPacer) Enqueue(p *pacer.Packet) { + if p.Header != nil { + switch { + case p.IsProbe: + cp := capturingProbe{hdr: *p.Header, payloadLen: len(p.Payload)} + if len(p.Payload) > 0 { + cp.lastByte = p.Payload[len(p.Payload)-1] + } + c.lock.Lock() + c.probes = append(c.probes, cp) + c.lock.Unlock() + case p.IsRTX: + c.lock.Lock() + c.rtx = append(c.rtx, capturedRTX{hdr: *p.Header, payload: append([]byte(nil), p.Payload...)}) + c.lock.Unlock() + } + } + c.inner.Enqueue(p) +} + +func (c *capturingPacer) probePackets() []capturingProbe { + c.lock.Lock() + defer c.lock.Unlock() + return append([]capturingProbe(nil), c.probes...) +} + +func (c *capturingPacer) rtxPackets() []capturedRTX { + c.lock.Lock() + defer c.lock.Unlock() + return append([]capturedRTX(nil), c.rtx...) +} + +func (c *capturingPacer) Stop() { c.inner.Stop() } +func (c *capturingPacer) SetInterval(i time.Duration) { c.inner.SetInterval(i) } +func (c *capturingPacer) SetBitrate(b int) { c.inner.SetBitrate(b) } +func (c *capturingPacer) TimeSinceLastSentPacket() time.Duration { + return c.inner.TimeSinceLastSentPacket() +} +func (c *capturingPacer) SetPacerProbeObserverListener(l pacer.PacerProbeObserverListener) { + c.inner.SetPacerProbeObserverListener(l) +} +func (c *capturingPacer) StartProbeCluster(pci ccutils.ProbeClusterInfo) { + c.inner.StartProbeCluster(pci) +} +func (c *capturingPacer) EndProbeCluster(id ccutils.ProbeClusterId) ccutils.ProbeClusterInfo { + return c.inner.EndProbeCluster(id) +} + +// feedReceiverReport hands the DownTrack a synthetic RTCP receiver report for its +// primary SSRC via the same handleRTCP path production uses. This deterministically +// sets LastReceiverReportTime() (a precondition for WriteProbePackets) without +// depending on the timing of the far side's periodic RRs. +func feedReceiverReport(t *testing.T, dt *DownTrack, lastSeqNo uint16) { + t.Helper() + rr := &rtcp.ReceiverReport{ + SSRC: 0x9999, + Reports: []rtcp.ReceptionReport{{ + SSRC: dt.SSRC(), + LastSenderReport: 0, + LastSequenceNumber: uint32(lastSeqNo), + }}, + } + raw, err := rr.Marshal() + require.NoError(t, err) + dt.HandleRTCPForTest(raw) + require.NotZero(t, dt.LastReceiverReportTimeForTest(), "synthetic RR should set LastReceiverReportTime") +} + +// TestDownTrackSendsProbePackets exercises the WriteProbePackets RTX probe path +// while wiring the DownTrack to a real StreamAllocator + Pacer + BWE. It runs +// against BOTH bandwidth estimators (send-side / remote). +// +// The RTX probe packets are captured at the pacer as the DownTrack builds them (they +// are padding-only on the RTX stream and are not surfaced as a media track by the +// pion receiver, so far-side capture is not reliable for them). Each probe is +// verified to be on the RTX SSRC/payload type, carry the padding bit, declare a full +// padding size, and serialize a full padding block whose trailing byte is the +// padding count. +// +// The media path is exercised end-to-end over real pion with the allocator, the +// pacer and the specific BWE wired in; BWE estimate values themselves are +// intentionally not asserted (they are timing dependent) — the test verifies the +// pipeline stays healthy and the probe serialization is correct with each estimator. +func TestDownTrackSendsProbePackets(t *testing.T) { + cases := []struct { + name string + makeBWE func() bwe.BWE + }{ + { + name: "sendside", + makeBWE: func() bwe.BWE { + return sendsidebwe.NewSendSideBWE(sendsidebwe.SendSideBWEParams{ + Config: sendsidebwe.DefaultSendSideBWEConfig, + Logger: logger.GetLogger(), + }) + }, + }, + { + name: "remote", + makeBWE: func() bwe.BWE { + return remotebwe.NewRemoteBWE(remotebwe.RemoteBWEParams{ + Config: remotebwe.DefaultRemoteBWEConfig, + Logger: logger.GetLogger(), + }) + }, + }, + } + + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + h := buildVNet(t) + factory := buffer.NewFactoryOfBufferFactory(500, 500).CreateBufferFactory() + + b := tc.makeBWE() + cp := &capturingPacer{inner: pacer.NewPassThrough(logger.GetLogger(), b)} + t.Cleanup(cp.Stop) + + // header extensions (abs-send-time for remote BWE, transport-cc for send-side) + // are needed for the DownTrack to pick up an ext id, which WriteProbePackets + // requires. + dh := newBoundDownTrack(t, h, factory, vp8CodecParams, cp, mediaEngineConfig{ + video: true, + headerExtensions: true, + }) + + require.NotZero(t, dh.dt.SSRCRTX(), "RTX ssrc should be negotiated") + require.NotZero(t, dh.dt.PayloadTypeRTXForTest(), "RTX payload type should be negotiated") + + sa := streamallocator.NewStreamAllocator(streamallocator.StreamAllocatorParams{ + Config: streamallocator.DefaultStreamAllocatorConfig, + BWE: b, + Pacer: cp, + RTTGetter: func() (float64, bool) { return 0, false }, + Logger: logger.GetLogger(), + }, true, false) + // AddTrack wires the allocator as the DownTrack's stream-allocator listener + // (which is what supplies the BWE type used to resolve the abs-send-time / + // transport-cc ext id that WriteProbePackets requires). We intentionally do + // NOT Start() the allocator's event loop: its asynchronous re-allocation would + // race with (and override) the layer we force below, making the forwarding + // non-deterministic. The probe path is driven directly instead. + sa.AddTrack(dh.dt, streamallocator.AddTrackParams{ + Source: livekit.TrackSource_CAMERA, + PublisherID: "fake-pub", + }) + + // now that the StreamAllocator listener is set and negotiation is complete, + // (re)resolve the negotiated header extension ids. + dh.dt.SetRTPHeaderExtensionsForTest() + require.Eventually(t, func() bool { + abs, twcc := dh.dt.ExtIDsForTest() + return abs != 0 || twcc != 0 + }, 3*time.Second, 20*time.Millisecond, "expected an abs-send-time or transport-cc ext id to be negotiated") + + // force a valid target/current layer so the video forwarder will forward. + dh.dt.ForceForwardLayerForTest(buffer.VideoLayer{Spatial: 0, Temporal: 0}) + + // forward a keyframe end-to-end (exercises DownTrack + allocator + pacer + BWE) + // and verify it arrives with the expected header/payload. + vp8 := &codec.VP8{FirstByte: 0x10, S: true, PictureID: 1, IsKeyFrame: true} + keyframePayload := distinctivePayload(0x50, 60) + ep, err := testutils.GetTestExtPacketVP8(&testutils.TestExtPacketParams{ + SequenceNumber: 6000, + Timestamp: 270000, + SSRC: 0x44444444, + PayloadType: 96, + PayloadSize: 60, + IsKeyFrame: true, + Marker: true, + }, vp8) + require.NoError(t, err) + ep.Packet.Payload = keyframePayload + require.Equal(t, int32(1), dh.dt.WriteRTP(ep, 0), "keyframe should forward") + require.True(t, dh.dt.RTPStatsActiveForTest()) + + require.Eventually(t, func() bool { + return dh.capture.count() >= 1 + }, 10*time.Second, 20*time.Millisecond, "expected forwarded media to arrive over the full pipeline") + + media := dh.capture.all()[0] + require.EqualValues(t, dh.dt.SSRC(), media.SSRC, "forwarded media on wrong SSRC") + require.EqualValues(t, 96, media.PayloadType, "forwarded media has wrong payload type") + require.False(t, media.Header.Padding, "forwarded media must not carry padding bit") + // the forwarder prepends the VP8 payload descriptor, so the media bytes + // appear as a suffix of the forwarded payload. + require.True(t, bytes.HasSuffix(media.Payload, keyframePayload), "forwarded media payload mismatch") + + // satisfy the RR precondition deterministically, referencing the + // subscriber-facing sequence number of the forwarded keyframe. + feedReceiverReport(t, dh.dt, media.SequenceNumber) + + // emit RTX probe packets. + const numProbe = 3 + require.Eventually(t, func() bool { + dh.dt.WriteProbePackets(2000, true) + return len(cp.probePackets()) >= numProbe + }, 5*time.Second, 20*time.Millisecond, "expected WriteProbePackets to emit RTX probe packets") + + // every probe packet must be on the RTX stream, carry the padding bit, declare + // the full padding size, and serialize a full padding block ending in the + // padding count byte. + for _, pr := range cp.probePackets() { + require.EqualValues(t, 2, pr.hdr.Version, "probe packet version") + require.EqualValues(t, dh.dt.SSRCRTX(), pr.hdr.SSRC, "probe packet must be on the RTX stream") + require.EqualValues(t, dh.dt.PayloadTypeRTXForTest(), pr.hdr.PayloadType, "probe packet must use the RTX payload type") + require.True(t, pr.hdr.Padding, "probe packet must carry padding bit") + require.EqualValues(t, RTPPaddingMaxPayloadSize, pr.hdr.PaddingSize, "probe packet must set header.PaddingSize") + require.Equal(t, RTPPaddingMaxPayloadSize, pr.payloadLen, "probe packet must carry a full padding block") + require.EqualValues(t, RTPPaddingMaxPayloadSize, pr.lastByte, "probe packet trailing byte must be the padding count") + } + + // the BWE is wired and exercised (the pacer records every send into it); + // its state must be queryable without panicking. Exact estimate values are + // timing dependent and intentionally not asserted. + require.NotPanics(t, func() { _ = b.CongestionState() }) + }) + } +} diff --git a/pkg/sfu/export_test.go b/pkg/sfu/export_test.go new file mode 100644 index 000000000..da31e2b75 --- /dev/null +++ b/pkg/sfu/export_test.go @@ -0,0 +1,71 @@ +// Copyright 2026 LiveKit, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package sfu + +import "github.com/livekit/livekit-server/pkg/sfu/buffer" + +// Test-only seams that expose DownTrack internals to the external sfu_test package. +// This file is only compiled into the test binary (its name ends in _test.go), so it +// does not affect the production API. The external test package is required because the +// integration tests import the streamallocator package, which itself imports sfu (an +// import cycle that an in-package test cannot resolve). + +func (d *DownTrack) IsWritableForTest() bool { return d.writable.Load() } + +func (d *DownTrack) PayloadTypeRTXForTest() uint32 { return d.payloadTypeRTX.Load() } + +func (d *DownTrack) RTPStatsActiveForTest() bool { return d.rtpStats.IsActive() } + +func (d *DownTrack) LastReceiverReportTimeForTest() int64 { + return d.rtpStats.LastReceiverReportTime() +} + +func (d *DownTrack) ExtIDsForTest() (absSendTime int, transportWide int) { + return d.absSendTimeExtID, d.transportWideExtID +} + +func (d *DownTrack) HandleRTCPForTest(pkt []byte) { d.handleRTCP(pkt) } + +func (d *DownTrack) SetRTPHeaderExtensionsForTest() { d.setRTPHeaderExtensions() } + +// ForceForwardLayerForTest forces the forwarder onto a valid current/target layer so a +// (non-simulcast) video packet will be forwarded without driving full allocation. +func (d *DownTrack) ForceForwardLayerForTest(layer buffer.VideoLayer) { + d.forwarder.ForceLayerForTest(layer) +} + +// RetransmitForTest drives the (unexported) retransmitPacket path with an in-package +// extPacketMeta built from exported values, so the external test can exercise the +// retransmit path. +func (d *DownTrack) RetransmitForTest( + sourceSeqNo uint64, + targetSeqNo uint16, + timestamp uint32, + extTimestamp uint64, + layer int8, + sourcePkt []byte, +) (int, error) { + epm := extPacketMeta{ + packetMeta: packetMeta{ + sourceSeqNo: sourceSeqNo, + targetSeqNo: targetSeqNo, + timestamp: timestamp, + layer: layer, + }, + extSequenceNumber: uint64(targetSeqNo), + extTimestamp: extTimestamp, + } + return d.retransmitPacket(&epm, sourcePkt, false) +} diff --git a/pkg/sfu/forwarder.go b/pkg/sfu/forwarder.go index 398a2d2b7..599cdfd17 100644 --- a/pkg/sfu/forwarder.go +++ b/pkg/sfu/forwarder.go @@ -1728,6 +1728,14 @@ func (f *Forwarder) Restart() { f.refVideoLayerMode = livekit.VideoLayer_MODE_UNUSED } +func (f *Forwarder) ForceLayerForTest(layer buffer.VideoLayer) { + f.lock.Lock() + defer f.lock.Unlock() + + f.vls.SetCurrent(layer) + f.vls.SetTarget(layer) +} + func (f *Forwarder) FilterRTX(nacks []uint16) (filtered []uint16, disallowedLayers [buffer.DefaultMaxLayerSpatial + 1]bool) { f.lock.RLock() defer f.lock.RUnlock() diff --git a/pkg/sfu/interfaces.go b/pkg/sfu/interfaces.go new file mode 100644 index 000000000..c66a6879b --- /dev/null +++ b/pkg/sfu/interfaces.go @@ -0,0 +1,187 @@ +// Copyright 2023 LiveKit, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package sfu + +import ( + "github.com/pion/rtcp" + "github.com/pion/webrtc/v4" + + "github.com/livekit/mediatransportutil/pkg/codec" + "github.com/livekit/protocol/codecs/mime" + "github.com/livekit/protocol/livekit" + + "github.com/livekit/livekit-server/pkg/sfu/buffer" + "github.com/livekit/livekit-server/pkg/sfu/bwe" +) + +//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate + +// TrackReceiver defines an interface receive media from remote peer +// +//counterfeiter:generate . TrackReceiver +type TrackReceiver interface { + TrackID() livekit.TrackID + StreamID() string + + // returns the initial codec of the receiver, it is determined by the track's codec + // and will not change if the codec changes during the session (publisher changes codec) + Codec() webrtc.RTPCodecParameters + Mime() mime.MimeType + VideoLayerMode() livekit.VideoLayer_Mode + HeaderExtensions() []webrtc.RTPHeaderExtensionParameter + IsClosed() bool + + ReadRTP(buf []byte, layer uint8, esn uint64) (int, error) + GetLayeredBitrate() ([]int32, Bitrates) + + GetAudioLevel() (float64, bool) + + SendPLI(layer int32, force bool) + + SetMaxExpectedSpatialLayer(layer int32) + + AddDownTrack(track TrackSender) error + DeleteDownTrack(participantID livekit.ParticipantID) + GetDownTracks() []TrackSender + + DebugInfo() map[string]any + + TrackInfo() *livekit.TrackInfo + UpdateTrackInfo(ti *livekit.TrackInfo) + + // Get primary receiver if this receiver represents a RED codec; otherwise it will return itself + GetPrimaryReceiverForRed() TrackReceiver + + // Get red receiver for primary codec, used by forward red encodings for opus only codec + GetRedReceiver() TrackReceiver + + GetTemporalLayerFpsForSpatial(layer int32) []float32 + + GetTrackStats() *livekit.RTPStats + + // AddOnReady adds a function to be called when the receiver is ready, the callback + // could be called immediately if the receiver is ready when the callback is added + AddOnReady(func()) + + AddOnCodecStateChange(func(webrtc.RTPCodecParameters, ReceiverCodecState)) + CodecState() ReceiverCodecState + + // VideoSizes returns the video size parsed from rtp packet for each spatial layer. + VideoSizes() []codec.VideoSize + + // closes all associated buffers and issues a resync to all attached downtracks so that + // they can resync and have proper sequncing without gaps in sequence numbers / timestamps + Restart(reason string) +} + +// -------------------------------------- + +//counterfeiter:generate . REDTransformer +type REDTransformer interface { + TrackReceiver + SetLBThreshold(lbThreshold int) + ForwardRTP(pkt *buffer.ExtPacket, spatialLayer int32) int32 + ForwardRTCPSenderReport( + payloadType webrtc.PayloadType, + layer int32, + publisherSRData *livekit.RTCPSenderReportState, + ) + GetDownTracks() []TrackSender + ResyncDownTracks() + OnStreamRestart() + CanClose() bool + Close() +} + +// -------------------------------------- + +// TrackSender defines an interface send media to remote peer +// +//counterfeiter:generate . TrackSender +type TrackSender interface { + UpTrackLayersChange() + UpTrackBitrateAvailabilityChange() + UpTrackMaxPublishedLayerChange(maxPublishedLayer int32) + UpTrackMaxTemporalLayerSeenChange(maxTemporalLayerSeen int32) + UpTrackBitrateReport(availableLayers []int32, bitrates Bitrates) + WriteRTP(p *buffer.ExtPacket, layer int32) int32 + Close() + IsClosed() bool + // ID is the globally unique identifier for this Track. + ID() string + SubscriberID() livekit.ParticipantID + HandleRTCPSenderReportData( + payloadType webrtc.PayloadType, + layer int32, + publisherSRData *livekit.RTCPSenderReportState, + ) error + Resync() + SetReceiver(TrackReceiver) + ReceiverRestart(TrackReceiver) +} + +// ------------------------------------------------------------------- + +//counterfeiter:generate . DownTrackStreamAllocatorListener +type DownTrackStreamAllocatorListener interface { + // RTCP received + OnREMB(dt *DownTrack, remb *rtcp.ReceiverEstimatedMaximumBitrate) + OnTransportCCFeedback(dt *DownTrack, cc *rtcp.TransportLayerCC) + + // video layer availability changed + OnAvailableLayersChanged(dt *DownTrack) + + // video layer bitrate availability changed + OnBitrateAvailabilityChanged(dt *DownTrack) + + // max published spatial layer changed + OnMaxPublishedSpatialChanged(dt *DownTrack) + + // max published temporal layer changed + OnMaxPublishedTemporalChanged(dt *DownTrack) + + // subscription changed - mute/unmute + OnSubscriptionChanged(dt *DownTrack) + + // subscribed max video layer changed + OnSubscribedLayerChanged(dt *DownTrack, layers buffer.VideoLayer) + + // stream resumed + OnResume(dt *DownTrack) + + // check if track should participate in BWE + IsBWEEnabled(dt *DownTrack) bool + + // get the BWE type in use + BWEType() bwe.BWEType + + // check if subscription mute can be applied + IsSubscribeMutable(dt *DownTrack) bool +} + +// ------------------------------------------------------------------- + +//counterfeiter:generate . DownTrackListener +type DownTrackListener interface { + OnBindAndConnected() + OnStatsUpdate(stat *livekit.AnalyticsStat) + OnMaxSubscribedLayerChanged(layer int32) + OnRttUpdate(rtt uint32) + OnCodecNegotiated(webrtc.RTPCodecCapability) + OnDownTrackClose(isExpectedToResume bool) + OnStreamStarted() +} + +// ------------------------------------------------------------------- diff --git a/pkg/sfu/receiver_base.go b/pkg/sfu/receiver_base.go index 31cc25aa9..3e0cd102a 100644 --- a/pkg/sfu/receiver_base.go +++ b/pkg/sfu/receiver_base.go @@ -97,82 +97,6 @@ const ( // -------------------------------------- -// TrackReceiver defines an interface receive media from remote peer -type TrackReceiver interface { - TrackID() livekit.TrackID - StreamID() string - - // returns the initial codec of the receiver, it is determined by the track's codec - // and will not change if the codec changes during the session (publisher changes codec) - Codec() webrtc.RTPCodecParameters - Mime() mime.MimeType - VideoLayerMode() livekit.VideoLayer_Mode - HeaderExtensions() []webrtc.RTPHeaderExtensionParameter - IsClosed() bool - - ReadRTP(buf []byte, layer uint8, esn uint64) (int, error) - GetLayeredBitrate() ([]int32, Bitrates) - - GetAudioLevel() (float64, bool) - - SendPLI(layer int32, force bool) - - SetMaxExpectedSpatialLayer(layer int32) - - AddDownTrack(track TrackSender) error - DeleteDownTrack(participantID livekit.ParticipantID) - GetDownTracks() []TrackSender - - DebugInfo() map[string]any - - TrackInfo() *livekit.TrackInfo - UpdateTrackInfo(ti *livekit.TrackInfo) - - // Get primary receiver if this receiver represents a RED codec; otherwise it will return itself - GetPrimaryReceiverForRed() TrackReceiver - - // Get red receiver for primary codec, used by forward red encodings for opus only codec - GetRedReceiver() TrackReceiver - - GetTemporalLayerFpsForSpatial(layer int32) []float32 - - GetTrackStats() *livekit.RTPStats - - // AddOnReady adds a function to be called when the receiver is ready, the callback - // could be called immediately if the receiver is ready when the callback is added - AddOnReady(func()) - - AddOnCodecStateChange(func(webrtc.RTPCodecParameters, ReceiverCodecState)) - CodecState() ReceiverCodecState - - // VideoSizes returns the video size parsed from rtp packet for each spatial layer. - VideoSizes() []codec.VideoSize - - // closes all associated buffers and issues a resync to all attached downtracks so that - // they can resync and have proper sequncing without gaps in sequence numbers / timestamps - Restart(reason string) -} - -// -------------------------------------- - -type REDTransformer interface { - TrackReceiver - SetLBThreshold(lbThreshold int) - ForwardRTP(pkt *buffer.ExtPacket, spatialLayer int32) int32 - ForwardRTCPSenderReport( - payloadType webrtc.PayloadType, - layer int32, - publisherSRData *livekit.RTCPSenderReportState, - ) - GetDownTracks() []TrackSender - ResyncDownTracks() - OnStreamRestart() - CanClose() bool - Close() -} - -// -------------------------------------- - type bufferPromise struct { ready chan struct{} } diff --git a/pkg/sfu/sfufakes/fake_down_track_listener.go b/pkg/sfu/sfufakes/fake_down_track_listener.go new file mode 100644 index 000000000..6b2222712 --- /dev/null +++ b/pkg/sfu/sfufakes/fake_down_track_listener.go @@ -0,0 +1,280 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package sfufakes + +import ( + "sync" + + "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() + onStreamStartedMutex sync.RWMutex + onStreamStartedArgsForCall []struct { + } + 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() { + fake.onStreamStartedMutex.Lock() + fake.onStreamStartedArgsForCall = append(fake.onStreamStartedArgsForCall, struct { + }{}) + stub := fake.OnStreamStartedStub + fake.recordInvocation("OnStreamStarted", []interface{}{}) + fake.onStreamStartedMutex.Unlock() + if stub != nil { + fake.OnStreamStartedStub() + } +} + +func (fake *FakeDownTrackListener) OnStreamStartedCallCount() int { + fake.onStreamStartedMutex.RLock() + defer fake.onStreamStartedMutex.RUnlock() + return len(fake.onStreamStartedArgsForCall) +} + +func (fake *FakeDownTrackListener) OnStreamStartedCalls(stub func()) { + fake.onStreamStartedMutex.Lock() + defer fake.onStreamStartedMutex.Unlock() + fake.OnStreamStartedStub = stub +} + +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) diff --git a/pkg/sfu/sfufakes/fake_down_track_stream_allocator_listener.go b/pkg/sfu/sfufakes/fake_down_track_stream_allocator_listener.go new file mode 100644 index 000000000..4dcf03e3e --- /dev/null +++ b/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) diff --git a/pkg/sfu/sfufakes/fake_redtransformer.go b/pkg/sfu/sfufakes/fake_redtransformer.go new file mode 100644 index 000000000..b1a1b54c7 --- /dev/null +++ b/pkg/sfu/sfufakes/fake_redtransformer.go @@ -0,0 +1,1913 @@ +// 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/mediatransportutil/pkg/codec" + "github.com/livekit/protocol/codecs/mime" + "github.com/livekit/protocol/livekit" + webrtc "github.com/pion/webrtc/v4" +) + +type FakeREDTransformer struct { + AddDownTrackStub func(sfu.TrackSender) error + addDownTrackMutex sync.RWMutex + addDownTrackArgsForCall []struct { + arg1 sfu.TrackSender + } + addDownTrackReturns struct { + result1 error + } + addDownTrackReturnsOnCall map[int]struct { + result1 error + } + AddOnCodecStateChangeStub func(func(webrtc.RTPCodecParameters, sfu.ReceiverCodecState)) + addOnCodecStateChangeMutex sync.RWMutex + addOnCodecStateChangeArgsForCall []struct { + arg1 func(webrtc.RTPCodecParameters, sfu.ReceiverCodecState) + } + AddOnReadyStub func(func()) + addOnReadyMutex sync.RWMutex + addOnReadyArgsForCall []struct { + arg1 func() + } + CanCloseStub func() bool + canCloseMutex sync.RWMutex + canCloseArgsForCall []struct { + } + canCloseReturns struct { + result1 bool + } + canCloseReturnsOnCall map[int]struct { + result1 bool + } + CloseStub func() + closeMutex sync.RWMutex + closeArgsForCall []struct { + } + CodecStub func() webrtc.RTPCodecParameters + codecMutex sync.RWMutex + codecArgsForCall []struct { + } + codecReturns struct { + result1 webrtc.RTPCodecParameters + } + codecReturnsOnCall map[int]struct { + result1 webrtc.RTPCodecParameters + } + CodecStateStub func() sfu.ReceiverCodecState + codecStateMutex sync.RWMutex + codecStateArgsForCall []struct { + } + codecStateReturns struct { + result1 sfu.ReceiverCodecState + } + codecStateReturnsOnCall map[int]struct { + result1 sfu.ReceiverCodecState + } + DebugInfoStub func() map[string]any + debugInfoMutex sync.RWMutex + debugInfoArgsForCall []struct { + } + debugInfoReturns struct { + result1 map[string]any + } + debugInfoReturnsOnCall map[int]struct { + result1 map[string]any + } + DeleteDownTrackStub func(livekit.ParticipantID) + deleteDownTrackMutex sync.RWMutex + deleteDownTrackArgsForCall []struct { + arg1 livekit.ParticipantID + } + ForwardRTCPSenderReportStub func(webrtc.PayloadType, int32, *livekit.RTCPSenderReportState) + forwardRTCPSenderReportMutex sync.RWMutex + forwardRTCPSenderReportArgsForCall []struct { + arg1 webrtc.PayloadType + arg2 int32 + arg3 *livekit.RTCPSenderReportState + } + ForwardRTPStub func(*buffer.ExtPacket, int32) int32 + forwardRTPMutex sync.RWMutex + forwardRTPArgsForCall []struct { + arg1 *buffer.ExtPacket + arg2 int32 + } + forwardRTPReturns struct { + result1 int32 + } + forwardRTPReturnsOnCall map[int]struct { + result1 int32 + } + GetAudioLevelStub func() (float64, bool) + getAudioLevelMutex sync.RWMutex + getAudioLevelArgsForCall []struct { + } + getAudioLevelReturns struct { + result1 float64 + result2 bool + } + getAudioLevelReturnsOnCall map[int]struct { + result1 float64 + result2 bool + } + GetDownTracksStub func() []sfu.TrackSender + getDownTracksMutex sync.RWMutex + getDownTracksArgsForCall []struct { + } + getDownTracksReturns struct { + result1 []sfu.TrackSender + } + getDownTracksReturnsOnCall map[int]struct { + result1 []sfu.TrackSender + } + GetLayeredBitrateStub func() ([]int32, sfu.Bitrates) + getLayeredBitrateMutex sync.RWMutex + getLayeredBitrateArgsForCall []struct { + } + getLayeredBitrateReturns struct { + result1 []int32 + result2 sfu.Bitrates + } + getLayeredBitrateReturnsOnCall map[int]struct { + result1 []int32 + result2 sfu.Bitrates + } + GetPrimaryReceiverForRedStub func() sfu.TrackReceiver + getPrimaryReceiverForRedMutex sync.RWMutex + getPrimaryReceiverForRedArgsForCall []struct { + } + getPrimaryReceiverForRedReturns struct { + result1 sfu.TrackReceiver + } + getPrimaryReceiverForRedReturnsOnCall map[int]struct { + result1 sfu.TrackReceiver + } + GetRedReceiverStub func() sfu.TrackReceiver + getRedReceiverMutex sync.RWMutex + getRedReceiverArgsForCall []struct { + } + getRedReceiverReturns struct { + result1 sfu.TrackReceiver + } + getRedReceiverReturnsOnCall map[int]struct { + result1 sfu.TrackReceiver + } + GetTemporalLayerFpsForSpatialStub func(int32) []float32 + getTemporalLayerFpsForSpatialMutex sync.RWMutex + getTemporalLayerFpsForSpatialArgsForCall []struct { + arg1 int32 + } + getTemporalLayerFpsForSpatialReturns struct { + result1 []float32 + } + getTemporalLayerFpsForSpatialReturnsOnCall map[int]struct { + result1 []float32 + } + GetTrackStatsStub func() *livekit.RTPStats + getTrackStatsMutex sync.RWMutex + getTrackStatsArgsForCall []struct { + } + getTrackStatsReturns struct { + result1 *livekit.RTPStats + } + getTrackStatsReturnsOnCall map[int]struct { + result1 *livekit.RTPStats + } + HeaderExtensionsStub func() []webrtc.RTPHeaderExtensionParameter + headerExtensionsMutex sync.RWMutex + headerExtensionsArgsForCall []struct { + } + headerExtensionsReturns struct { + result1 []webrtc.RTPHeaderExtensionParameter + } + headerExtensionsReturnsOnCall map[int]struct { + result1 []webrtc.RTPHeaderExtensionParameter + } + IsClosedStub func() bool + isClosedMutex sync.RWMutex + isClosedArgsForCall []struct { + } + isClosedReturns struct { + result1 bool + } + isClosedReturnsOnCall map[int]struct { + result1 bool + } + MimeStub func() mime.MimeType + mimeMutex sync.RWMutex + mimeArgsForCall []struct { + } + mimeReturns struct { + result1 mime.MimeType + } + mimeReturnsOnCall map[int]struct { + result1 mime.MimeType + } + OnStreamRestartStub func() + onStreamRestartMutex sync.RWMutex + onStreamRestartArgsForCall []struct { + } + ReadRTPStub func([]byte, uint8, uint64) (int, error) + readRTPMutex sync.RWMutex + readRTPArgsForCall []struct { + arg1 []byte + arg2 uint8 + arg3 uint64 + } + readRTPReturns struct { + result1 int + result2 error + } + readRTPReturnsOnCall map[int]struct { + result1 int + result2 error + } + RestartStub func(string) + restartMutex sync.RWMutex + restartArgsForCall []struct { + arg1 string + } + ResyncDownTracksStub func() + resyncDownTracksMutex sync.RWMutex + resyncDownTracksArgsForCall []struct { + } + SendPLIStub func(int32, bool) + sendPLIMutex sync.RWMutex + sendPLIArgsForCall []struct { + arg1 int32 + arg2 bool + } + SetLBThresholdStub func(int) + setLBThresholdMutex sync.RWMutex + setLBThresholdArgsForCall []struct { + arg1 int + } + SetMaxExpectedSpatialLayerStub func(int32) + setMaxExpectedSpatialLayerMutex sync.RWMutex + setMaxExpectedSpatialLayerArgsForCall []struct { + arg1 int32 + } + StreamIDStub func() string + streamIDMutex sync.RWMutex + streamIDArgsForCall []struct { + } + streamIDReturns struct { + result1 string + } + streamIDReturnsOnCall map[int]struct { + result1 string + } + TrackIDStub func() livekit.TrackID + trackIDMutex sync.RWMutex + trackIDArgsForCall []struct { + } + trackIDReturns struct { + result1 livekit.TrackID + } + trackIDReturnsOnCall map[int]struct { + result1 livekit.TrackID + } + TrackInfoStub func() *livekit.TrackInfo + trackInfoMutex sync.RWMutex + trackInfoArgsForCall []struct { + } + trackInfoReturns struct { + result1 *livekit.TrackInfo + } + trackInfoReturnsOnCall map[int]struct { + result1 *livekit.TrackInfo + } + UpdateTrackInfoStub func(*livekit.TrackInfo) + updateTrackInfoMutex sync.RWMutex + updateTrackInfoArgsForCall []struct { + arg1 *livekit.TrackInfo + } + VideoLayerModeStub func() livekit.VideoLayer_Mode + videoLayerModeMutex sync.RWMutex + videoLayerModeArgsForCall []struct { + } + videoLayerModeReturns struct { + result1 livekit.VideoLayer_Mode + } + videoLayerModeReturnsOnCall map[int]struct { + result1 livekit.VideoLayer_Mode + } + VideoSizesStub func() []codec.VideoSize + videoSizesMutex sync.RWMutex + videoSizesArgsForCall []struct { + } + videoSizesReturns struct { + result1 []codec.VideoSize + } + videoSizesReturnsOnCall map[int]struct { + result1 []codec.VideoSize + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeREDTransformer) AddDownTrack(arg1 sfu.TrackSender) error { + fake.addDownTrackMutex.Lock() + ret, specificReturn := fake.addDownTrackReturnsOnCall[len(fake.addDownTrackArgsForCall)] + fake.addDownTrackArgsForCall = append(fake.addDownTrackArgsForCall, struct { + arg1 sfu.TrackSender + }{arg1}) + stub := fake.AddDownTrackStub + fakeReturns := fake.addDownTrackReturns + fake.recordInvocation("AddDownTrack", []interface{}{arg1}) + fake.addDownTrackMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeREDTransformer) AddDownTrackCallCount() int { + fake.addDownTrackMutex.RLock() + defer fake.addDownTrackMutex.RUnlock() + return len(fake.addDownTrackArgsForCall) +} + +func (fake *FakeREDTransformer) AddDownTrackCalls(stub func(sfu.TrackSender) error) { + fake.addDownTrackMutex.Lock() + defer fake.addDownTrackMutex.Unlock() + fake.AddDownTrackStub = stub +} + +func (fake *FakeREDTransformer) AddDownTrackArgsForCall(i int) sfu.TrackSender { + fake.addDownTrackMutex.RLock() + defer fake.addDownTrackMutex.RUnlock() + argsForCall := fake.addDownTrackArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeREDTransformer) AddDownTrackReturns(result1 error) { + fake.addDownTrackMutex.Lock() + defer fake.addDownTrackMutex.Unlock() + fake.AddDownTrackStub = nil + fake.addDownTrackReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeREDTransformer) AddDownTrackReturnsOnCall(i int, result1 error) { + fake.addDownTrackMutex.Lock() + defer fake.addDownTrackMutex.Unlock() + fake.AddDownTrackStub = nil + if fake.addDownTrackReturnsOnCall == nil { + fake.addDownTrackReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.addDownTrackReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeREDTransformer) AddOnCodecStateChange(arg1 func(webrtc.RTPCodecParameters, sfu.ReceiverCodecState)) { + fake.addOnCodecStateChangeMutex.Lock() + fake.addOnCodecStateChangeArgsForCall = append(fake.addOnCodecStateChangeArgsForCall, struct { + arg1 func(webrtc.RTPCodecParameters, sfu.ReceiverCodecState) + }{arg1}) + stub := fake.AddOnCodecStateChangeStub + fake.recordInvocation("AddOnCodecStateChange", []interface{}{arg1}) + fake.addOnCodecStateChangeMutex.Unlock() + if stub != nil { + fake.AddOnCodecStateChangeStub(arg1) + } +} + +func (fake *FakeREDTransformer) AddOnCodecStateChangeCallCount() int { + fake.addOnCodecStateChangeMutex.RLock() + defer fake.addOnCodecStateChangeMutex.RUnlock() + return len(fake.addOnCodecStateChangeArgsForCall) +} + +func (fake *FakeREDTransformer) AddOnCodecStateChangeCalls(stub func(func(webrtc.RTPCodecParameters, sfu.ReceiverCodecState))) { + fake.addOnCodecStateChangeMutex.Lock() + defer fake.addOnCodecStateChangeMutex.Unlock() + fake.AddOnCodecStateChangeStub = stub +} + +func (fake *FakeREDTransformer) AddOnCodecStateChangeArgsForCall(i int) func(webrtc.RTPCodecParameters, sfu.ReceiverCodecState) { + fake.addOnCodecStateChangeMutex.RLock() + defer fake.addOnCodecStateChangeMutex.RUnlock() + argsForCall := fake.addOnCodecStateChangeArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeREDTransformer) AddOnReady(arg1 func()) { + fake.addOnReadyMutex.Lock() + fake.addOnReadyArgsForCall = append(fake.addOnReadyArgsForCall, struct { + arg1 func() + }{arg1}) + stub := fake.AddOnReadyStub + fake.recordInvocation("AddOnReady", []interface{}{arg1}) + fake.addOnReadyMutex.Unlock() + if stub != nil { + fake.AddOnReadyStub(arg1) + } +} + +func (fake *FakeREDTransformer) AddOnReadyCallCount() int { + fake.addOnReadyMutex.RLock() + defer fake.addOnReadyMutex.RUnlock() + return len(fake.addOnReadyArgsForCall) +} + +func (fake *FakeREDTransformer) AddOnReadyCalls(stub func(func())) { + fake.addOnReadyMutex.Lock() + defer fake.addOnReadyMutex.Unlock() + fake.AddOnReadyStub = stub +} + +func (fake *FakeREDTransformer) AddOnReadyArgsForCall(i int) func() { + fake.addOnReadyMutex.RLock() + defer fake.addOnReadyMutex.RUnlock() + argsForCall := fake.addOnReadyArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeREDTransformer) CanClose() bool { + fake.canCloseMutex.Lock() + ret, specificReturn := fake.canCloseReturnsOnCall[len(fake.canCloseArgsForCall)] + fake.canCloseArgsForCall = append(fake.canCloseArgsForCall, struct { + }{}) + stub := fake.CanCloseStub + fakeReturns := fake.canCloseReturns + fake.recordInvocation("CanClose", []interface{}{}) + fake.canCloseMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeREDTransformer) CanCloseCallCount() int { + fake.canCloseMutex.RLock() + defer fake.canCloseMutex.RUnlock() + return len(fake.canCloseArgsForCall) +} + +func (fake *FakeREDTransformer) CanCloseCalls(stub func() bool) { + fake.canCloseMutex.Lock() + defer fake.canCloseMutex.Unlock() + fake.CanCloseStub = stub +} + +func (fake *FakeREDTransformer) CanCloseReturns(result1 bool) { + fake.canCloseMutex.Lock() + defer fake.canCloseMutex.Unlock() + fake.CanCloseStub = nil + fake.canCloseReturns = struct { + result1 bool + }{result1} +} + +func (fake *FakeREDTransformer) CanCloseReturnsOnCall(i int, result1 bool) { + fake.canCloseMutex.Lock() + defer fake.canCloseMutex.Unlock() + fake.CanCloseStub = nil + if fake.canCloseReturnsOnCall == nil { + fake.canCloseReturnsOnCall = make(map[int]struct { + result1 bool + }) + } + fake.canCloseReturnsOnCall[i] = struct { + result1 bool + }{result1} +} + +func (fake *FakeREDTransformer) 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 *FakeREDTransformer) CloseCallCount() int { + fake.closeMutex.RLock() + defer fake.closeMutex.RUnlock() + return len(fake.closeArgsForCall) +} + +func (fake *FakeREDTransformer) CloseCalls(stub func()) { + fake.closeMutex.Lock() + defer fake.closeMutex.Unlock() + fake.CloseStub = stub +} + +func (fake *FakeREDTransformer) Codec() webrtc.RTPCodecParameters { + fake.codecMutex.Lock() + ret, specificReturn := fake.codecReturnsOnCall[len(fake.codecArgsForCall)] + fake.codecArgsForCall = append(fake.codecArgsForCall, struct { + }{}) + stub := fake.CodecStub + fakeReturns := fake.codecReturns + fake.recordInvocation("Codec", []interface{}{}) + fake.codecMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeREDTransformer) CodecCallCount() int { + fake.codecMutex.RLock() + defer fake.codecMutex.RUnlock() + return len(fake.codecArgsForCall) +} + +func (fake *FakeREDTransformer) CodecCalls(stub func() webrtc.RTPCodecParameters) { + fake.codecMutex.Lock() + defer fake.codecMutex.Unlock() + fake.CodecStub = stub +} + +func (fake *FakeREDTransformer) CodecReturns(result1 webrtc.RTPCodecParameters) { + fake.codecMutex.Lock() + defer fake.codecMutex.Unlock() + fake.CodecStub = nil + fake.codecReturns = struct { + result1 webrtc.RTPCodecParameters + }{result1} +} + +func (fake *FakeREDTransformer) CodecReturnsOnCall(i int, result1 webrtc.RTPCodecParameters) { + fake.codecMutex.Lock() + defer fake.codecMutex.Unlock() + fake.CodecStub = nil + if fake.codecReturnsOnCall == nil { + fake.codecReturnsOnCall = make(map[int]struct { + result1 webrtc.RTPCodecParameters + }) + } + fake.codecReturnsOnCall[i] = struct { + result1 webrtc.RTPCodecParameters + }{result1} +} + +func (fake *FakeREDTransformer) CodecState() sfu.ReceiverCodecState { + fake.codecStateMutex.Lock() + ret, specificReturn := fake.codecStateReturnsOnCall[len(fake.codecStateArgsForCall)] + fake.codecStateArgsForCall = append(fake.codecStateArgsForCall, struct { + }{}) + stub := fake.CodecStateStub + fakeReturns := fake.codecStateReturns + fake.recordInvocation("CodecState", []interface{}{}) + fake.codecStateMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeREDTransformer) CodecStateCallCount() int { + fake.codecStateMutex.RLock() + defer fake.codecStateMutex.RUnlock() + return len(fake.codecStateArgsForCall) +} + +func (fake *FakeREDTransformer) CodecStateCalls(stub func() sfu.ReceiverCodecState) { + fake.codecStateMutex.Lock() + defer fake.codecStateMutex.Unlock() + fake.CodecStateStub = stub +} + +func (fake *FakeREDTransformer) CodecStateReturns(result1 sfu.ReceiverCodecState) { + fake.codecStateMutex.Lock() + defer fake.codecStateMutex.Unlock() + fake.CodecStateStub = nil + fake.codecStateReturns = struct { + result1 sfu.ReceiverCodecState + }{result1} +} + +func (fake *FakeREDTransformer) CodecStateReturnsOnCall(i int, result1 sfu.ReceiverCodecState) { + fake.codecStateMutex.Lock() + defer fake.codecStateMutex.Unlock() + fake.CodecStateStub = nil + if fake.codecStateReturnsOnCall == nil { + fake.codecStateReturnsOnCall = make(map[int]struct { + result1 sfu.ReceiverCodecState + }) + } + fake.codecStateReturnsOnCall[i] = struct { + result1 sfu.ReceiverCodecState + }{result1} +} + +func (fake *FakeREDTransformer) DebugInfo() map[string]any { + fake.debugInfoMutex.Lock() + ret, specificReturn := fake.debugInfoReturnsOnCall[len(fake.debugInfoArgsForCall)] + fake.debugInfoArgsForCall = append(fake.debugInfoArgsForCall, struct { + }{}) + stub := fake.DebugInfoStub + fakeReturns := fake.debugInfoReturns + fake.recordInvocation("DebugInfo", []interface{}{}) + fake.debugInfoMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeREDTransformer) DebugInfoCallCount() int { + fake.debugInfoMutex.RLock() + defer fake.debugInfoMutex.RUnlock() + return len(fake.debugInfoArgsForCall) +} + +func (fake *FakeREDTransformer) DebugInfoCalls(stub func() map[string]any) { + fake.debugInfoMutex.Lock() + defer fake.debugInfoMutex.Unlock() + fake.DebugInfoStub = stub +} + +func (fake *FakeREDTransformer) DebugInfoReturns(result1 map[string]any) { + fake.debugInfoMutex.Lock() + defer fake.debugInfoMutex.Unlock() + fake.DebugInfoStub = nil + fake.debugInfoReturns = struct { + result1 map[string]any + }{result1} +} + +func (fake *FakeREDTransformer) DebugInfoReturnsOnCall(i int, result1 map[string]any) { + fake.debugInfoMutex.Lock() + defer fake.debugInfoMutex.Unlock() + fake.DebugInfoStub = nil + if fake.debugInfoReturnsOnCall == nil { + fake.debugInfoReturnsOnCall = make(map[int]struct { + result1 map[string]any + }) + } + fake.debugInfoReturnsOnCall[i] = struct { + result1 map[string]any + }{result1} +} + +func (fake *FakeREDTransformer) DeleteDownTrack(arg1 livekit.ParticipantID) { + fake.deleteDownTrackMutex.Lock() + fake.deleteDownTrackArgsForCall = append(fake.deleteDownTrackArgsForCall, struct { + arg1 livekit.ParticipantID + }{arg1}) + stub := fake.DeleteDownTrackStub + fake.recordInvocation("DeleteDownTrack", []interface{}{arg1}) + fake.deleteDownTrackMutex.Unlock() + if stub != nil { + fake.DeleteDownTrackStub(arg1) + } +} + +func (fake *FakeREDTransformer) DeleteDownTrackCallCount() int { + fake.deleteDownTrackMutex.RLock() + defer fake.deleteDownTrackMutex.RUnlock() + return len(fake.deleteDownTrackArgsForCall) +} + +func (fake *FakeREDTransformer) DeleteDownTrackCalls(stub func(livekit.ParticipantID)) { + fake.deleteDownTrackMutex.Lock() + defer fake.deleteDownTrackMutex.Unlock() + fake.DeleteDownTrackStub = stub +} + +func (fake *FakeREDTransformer) DeleteDownTrackArgsForCall(i int) livekit.ParticipantID { + fake.deleteDownTrackMutex.RLock() + defer fake.deleteDownTrackMutex.RUnlock() + argsForCall := fake.deleteDownTrackArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeREDTransformer) ForwardRTCPSenderReport(arg1 webrtc.PayloadType, arg2 int32, arg3 *livekit.RTCPSenderReportState) { + fake.forwardRTCPSenderReportMutex.Lock() + fake.forwardRTCPSenderReportArgsForCall = append(fake.forwardRTCPSenderReportArgsForCall, struct { + arg1 webrtc.PayloadType + arg2 int32 + arg3 *livekit.RTCPSenderReportState + }{arg1, arg2, arg3}) + stub := fake.ForwardRTCPSenderReportStub + fake.recordInvocation("ForwardRTCPSenderReport", []interface{}{arg1, arg2, arg3}) + fake.forwardRTCPSenderReportMutex.Unlock() + if stub != nil { + fake.ForwardRTCPSenderReportStub(arg1, arg2, arg3) + } +} + +func (fake *FakeREDTransformer) ForwardRTCPSenderReportCallCount() int { + fake.forwardRTCPSenderReportMutex.RLock() + defer fake.forwardRTCPSenderReportMutex.RUnlock() + return len(fake.forwardRTCPSenderReportArgsForCall) +} + +func (fake *FakeREDTransformer) ForwardRTCPSenderReportCalls(stub func(webrtc.PayloadType, int32, *livekit.RTCPSenderReportState)) { + fake.forwardRTCPSenderReportMutex.Lock() + defer fake.forwardRTCPSenderReportMutex.Unlock() + fake.ForwardRTCPSenderReportStub = stub +} + +func (fake *FakeREDTransformer) ForwardRTCPSenderReportArgsForCall(i int) (webrtc.PayloadType, int32, *livekit.RTCPSenderReportState) { + fake.forwardRTCPSenderReportMutex.RLock() + defer fake.forwardRTCPSenderReportMutex.RUnlock() + argsForCall := fake.forwardRTCPSenderReportArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeREDTransformer) ForwardRTP(arg1 *buffer.ExtPacket, arg2 int32) int32 { + fake.forwardRTPMutex.Lock() + ret, specificReturn := fake.forwardRTPReturnsOnCall[len(fake.forwardRTPArgsForCall)] + fake.forwardRTPArgsForCall = append(fake.forwardRTPArgsForCall, struct { + arg1 *buffer.ExtPacket + arg2 int32 + }{arg1, arg2}) + stub := fake.ForwardRTPStub + fakeReturns := fake.forwardRTPReturns + fake.recordInvocation("ForwardRTP", []interface{}{arg1, arg2}) + fake.forwardRTPMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeREDTransformer) ForwardRTPCallCount() int { + fake.forwardRTPMutex.RLock() + defer fake.forwardRTPMutex.RUnlock() + return len(fake.forwardRTPArgsForCall) +} + +func (fake *FakeREDTransformer) ForwardRTPCalls(stub func(*buffer.ExtPacket, int32) int32) { + fake.forwardRTPMutex.Lock() + defer fake.forwardRTPMutex.Unlock() + fake.ForwardRTPStub = stub +} + +func (fake *FakeREDTransformer) ForwardRTPArgsForCall(i int) (*buffer.ExtPacket, int32) { + fake.forwardRTPMutex.RLock() + defer fake.forwardRTPMutex.RUnlock() + argsForCall := fake.forwardRTPArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeREDTransformer) ForwardRTPReturns(result1 int32) { + fake.forwardRTPMutex.Lock() + defer fake.forwardRTPMutex.Unlock() + fake.ForwardRTPStub = nil + fake.forwardRTPReturns = struct { + result1 int32 + }{result1} +} + +func (fake *FakeREDTransformer) ForwardRTPReturnsOnCall(i int, result1 int32) { + fake.forwardRTPMutex.Lock() + defer fake.forwardRTPMutex.Unlock() + fake.ForwardRTPStub = nil + if fake.forwardRTPReturnsOnCall == nil { + fake.forwardRTPReturnsOnCall = make(map[int]struct { + result1 int32 + }) + } + fake.forwardRTPReturnsOnCall[i] = struct { + result1 int32 + }{result1} +} + +func (fake *FakeREDTransformer) GetAudioLevel() (float64, bool) { + fake.getAudioLevelMutex.Lock() + ret, specificReturn := fake.getAudioLevelReturnsOnCall[len(fake.getAudioLevelArgsForCall)] + fake.getAudioLevelArgsForCall = append(fake.getAudioLevelArgsForCall, struct { + }{}) + stub := fake.GetAudioLevelStub + fakeReturns := fake.getAudioLevelReturns + fake.recordInvocation("GetAudioLevel", []interface{}{}) + fake.getAudioLevelMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeREDTransformer) GetAudioLevelCallCount() int { + fake.getAudioLevelMutex.RLock() + defer fake.getAudioLevelMutex.RUnlock() + return len(fake.getAudioLevelArgsForCall) +} + +func (fake *FakeREDTransformer) GetAudioLevelCalls(stub func() (float64, bool)) { + fake.getAudioLevelMutex.Lock() + defer fake.getAudioLevelMutex.Unlock() + fake.GetAudioLevelStub = stub +} + +func (fake *FakeREDTransformer) GetAudioLevelReturns(result1 float64, result2 bool) { + fake.getAudioLevelMutex.Lock() + defer fake.getAudioLevelMutex.Unlock() + fake.GetAudioLevelStub = nil + fake.getAudioLevelReturns = struct { + result1 float64 + result2 bool + }{result1, result2} +} + +func (fake *FakeREDTransformer) GetAudioLevelReturnsOnCall(i int, result1 float64, result2 bool) { + fake.getAudioLevelMutex.Lock() + defer fake.getAudioLevelMutex.Unlock() + fake.GetAudioLevelStub = nil + if fake.getAudioLevelReturnsOnCall == nil { + fake.getAudioLevelReturnsOnCall = make(map[int]struct { + result1 float64 + result2 bool + }) + } + fake.getAudioLevelReturnsOnCall[i] = struct { + result1 float64 + result2 bool + }{result1, result2} +} + +func (fake *FakeREDTransformer) GetDownTracks() []sfu.TrackSender { + fake.getDownTracksMutex.Lock() + ret, specificReturn := fake.getDownTracksReturnsOnCall[len(fake.getDownTracksArgsForCall)] + fake.getDownTracksArgsForCall = append(fake.getDownTracksArgsForCall, struct { + }{}) + stub := fake.GetDownTracksStub + fakeReturns := fake.getDownTracksReturns + fake.recordInvocation("GetDownTracks", []interface{}{}) + fake.getDownTracksMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeREDTransformer) GetDownTracksCallCount() int { + fake.getDownTracksMutex.RLock() + defer fake.getDownTracksMutex.RUnlock() + return len(fake.getDownTracksArgsForCall) +} + +func (fake *FakeREDTransformer) GetDownTracksCalls(stub func() []sfu.TrackSender) { + fake.getDownTracksMutex.Lock() + defer fake.getDownTracksMutex.Unlock() + fake.GetDownTracksStub = stub +} + +func (fake *FakeREDTransformer) GetDownTracksReturns(result1 []sfu.TrackSender) { + fake.getDownTracksMutex.Lock() + defer fake.getDownTracksMutex.Unlock() + fake.GetDownTracksStub = nil + fake.getDownTracksReturns = struct { + result1 []sfu.TrackSender + }{result1} +} + +func (fake *FakeREDTransformer) GetDownTracksReturnsOnCall(i int, result1 []sfu.TrackSender) { + fake.getDownTracksMutex.Lock() + defer fake.getDownTracksMutex.Unlock() + fake.GetDownTracksStub = nil + if fake.getDownTracksReturnsOnCall == nil { + fake.getDownTracksReturnsOnCall = make(map[int]struct { + result1 []sfu.TrackSender + }) + } + fake.getDownTracksReturnsOnCall[i] = struct { + result1 []sfu.TrackSender + }{result1} +} + +func (fake *FakeREDTransformer) GetLayeredBitrate() ([]int32, sfu.Bitrates) { + fake.getLayeredBitrateMutex.Lock() + ret, specificReturn := fake.getLayeredBitrateReturnsOnCall[len(fake.getLayeredBitrateArgsForCall)] + fake.getLayeredBitrateArgsForCall = append(fake.getLayeredBitrateArgsForCall, struct { + }{}) + stub := fake.GetLayeredBitrateStub + fakeReturns := fake.getLayeredBitrateReturns + fake.recordInvocation("GetLayeredBitrate", []interface{}{}) + fake.getLayeredBitrateMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeREDTransformer) GetLayeredBitrateCallCount() int { + fake.getLayeredBitrateMutex.RLock() + defer fake.getLayeredBitrateMutex.RUnlock() + return len(fake.getLayeredBitrateArgsForCall) +} + +func (fake *FakeREDTransformer) GetLayeredBitrateCalls(stub func() ([]int32, sfu.Bitrates)) { + fake.getLayeredBitrateMutex.Lock() + defer fake.getLayeredBitrateMutex.Unlock() + fake.GetLayeredBitrateStub = stub +} + +func (fake *FakeREDTransformer) GetLayeredBitrateReturns(result1 []int32, result2 sfu.Bitrates) { + fake.getLayeredBitrateMutex.Lock() + defer fake.getLayeredBitrateMutex.Unlock() + fake.GetLayeredBitrateStub = nil + fake.getLayeredBitrateReturns = struct { + result1 []int32 + result2 sfu.Bitrates + }{result1, result2} +} + +func (fake *FakeREDTransformer) GetLayeredBitrateReturnsOnCall(i int, result1 []int32, result2 sfu.Bitrates) { + fake.getLayeredBitrateMutex.Lock() + defer fake.getLayeredBitrateMutex.Unlock() + fake.GetLayeredBitrateStub = nil + if fake.getLayeredBitrateReturnsOnCall == nil { + fake.getLayeredBitrateReturnsOnCall = make(map[int]struct { + result1 []int32 + result2 sfu.Bitrates + }) + } + fake.getLayeredBitrateReturnsOnCall[i] = struct { + result1 []int32 + result2 sfu.Bitrates + }{result1, result2} +} + +func (fake *FakeREDTransformer) GetPrimaryReceiverForRed() sfu.TrackReceiver { + fake.getPrimaryReceiverForRedMutex.Lock() + ret, specificReturn := fake.getPrimaryReceiverForRedReturnsOnCall[len(fake.getPrimaryReceiverForRedArgsForCall)] + fake.getPrimaryReceiverForRedArgsForCall = append(fake.getPrimaryReceiverForRedArgsForCall, struct { + }{}) + stub := fake.GetPrimaryReceiverForRedStub + fakeReturns := fake.getPrimaryReceiverForRedReturns + fake.recordInvocation("GetPrimaryReceiverForRed", []interface{}{}) + fake.getPrimaryReceiverForRedMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeREDTransformer) GetPrimaryReceiverForRedCallCount() int { + fake.getPrimaryReceiverForRedMutex.RLock() + defer fake.getPrimaryReceiverForRedMutex.RUnlock() + return len(fake.getPrimaryReceiverForRedArgsForCall) +} + +func (fake *FakeREDTransformer) GetPrimaryReceiverForRedCalls(stub func() sfu.TrackReceiver) { + fake.getPrimaryReceiverForRedMutex.Lock() + defer fake.getPrimaryReceiverForRedMutex.Unlock() + fake.GetPrimaryReceiverForRedStub = stub +} + +func (fake *FakeREDTransformer) GetPrimaryReceiverForRedReturns(result1 sfu.TrackReceiver) { + fake.getPrimaryReceiverForRedMutex.Lock() + defer fake.getPrimaryReceiverForRedMutex.Unlock() + fake.GetPrimaryReceiverForRedStub = nil + fake.getPrimaryReceiverForRedReturns = struct { + result1 sfu.TrackReceiver + }{result1} +} + +func (fake *FakeREDTransformer) GetPrimaryReceiverForRedReturnsOnCall(i int, result1 sfu.TrackReceiver) { + fake.getPrimaryReceiverForRedMutex.Lock() + defer fake.getPrimaryReceiverForRedMutex.Unlock() + fake.GetPrimaryReceiverForRedStub = nil + if fake.getPrimaryReceiverForRedReturnsOnCall == nil { + fake.getPrimaryReceiverForRedReturnsOnCall = make(map[int]struct { + result1 sfu.TrackReceiver + }) + } + fake.getPrimaryReceiverForRedReturnsOnCall[i] = struct { + result1 sfu.TrackReceiver + }{result1} +} + +func (fake *FakeREDTransformer) GetRedReceiver() sfu.TrackReceiver { + fake.getRedReceiverMutex.Lock() + ret, specificReturn := fake.getRedReceiverReturnsOnCall[len(fake.getRedReceiverArgsForCall)] + fake.getRedReceiverArgsForCall = append(fake.getRedReceiverArgsForCall, struct { + }{}) + stub := fake.GetRedReceiverStub + fakeReturns := fake.getRedReceiverReturns + fake.recordInvocation("GetRedReceiver", []interface{}{}) + fake.getRedReceiverMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeREDTransformer) GetRedReceiverCallCount() int { + fake.getRedReceiverMutex.RLock() + defer fake.getRedReceiverMutex.RUnlock() + return len(fake.getRedReceiverArgsForCall) +} + +func (fake *FakeREDTransformer) GetRedReceiverCalls(stub func() sfu.TrackReceiver) { + fake.getRedReceiverMutex.Lock() + defer fake.getRedReceiverMutex.Unlock() + fake.GetRedReceiverStub = stub +} + +func (fake *FakeREDTransformer) GetRedReceiverReturns(result1 sfu.TrackReceiver) { + fake.getRedReceiverMutex.Lock() + defer fake.getRedReceiverMutex.Unlock() + fake.GetRedReceiverStub = nil + fake.getRedReceiverReturns = struct { + result1 sfu.TrackReceiver + }{result1} +} + +func (fake *FakeREDTransformer) GetRedReceiverReturnsOnCall(i int, result1 sfu.TrackReceiver) { + fake.getRedReceiverMutex.Lock() + defer fake.getRedReceiverMutex.Unlock() + fake.GetRedReceiverStub = nil + if fake.getRedReceiverReturnsOnCall == nil { + fake.getRedReceiverReturnsOnCall = make(map[int]struct { + result1 sfu.TrackReceiver + }) + } + fake.getRedReceiverReturnsOnCall[i] = struct { + result1 sfu.TrackReceiver + }{result1} +} + +func (fake *FakeREDTransformer) GetTemporalLayerFpsForSpatial(arg1 int32) []float32 { + fake.getTemporalLayerFpsForSpatialMutex.Lock() + ret, specificReturn := fake.getTemporalLayerFpsForSpatialReturnsOnCall[len(fake.getTemporalLayerFpsForSpatialArgsForCall)] + fake.getTemporalLayerFpsForSpatialArgsForCall = append(fake.getTemporalLayerFpsForSpatialArgsForCall, struct { + arg1 int32 + }{arg1}) + stub := fake.GetTemporalLayerFpsForSpatialStub + fakeReturns := fake.getTemporalLayerFpsForSpatialReturns + fake.recordInvocation("GetTemporalLayerFpsForSpatial", []interface{}{arg1}) + fake.getTemporalLayerFpsForSpatialMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeREDTransformer) GetTemporalLayerFpsForSpatialCallCount() int { + fake.getTemporalLayerFpsForSpatialMutex.RLock() + defer fake.getTemporalLayerFpsForSpatialMutex.RUnlock() + return len(fake.getTemporalLayerFpsForSpatialArgsForCall) +} + +func (fake *FakeREDTransformer) GetTemporalLayerFpsForSpatialCalls(stub func(int32) []float32) { + fake.getTemporalLayerFpsForSpatialMutex.Lock() + defer fake.getTemporalLayerFpsForSpatialMutex.Unlock() + fake.GetTemporalLayerFpsForSpatialStub = stub +} + +func (fake *FakeREDTransformer) GetTemporalLayerFpsForSpatialArgsForCall(i int) int32 { + fake.getTemporalLayerFpsForSpatialMutex.RLock() + defer fake.getTemporalLayerFpsForSpatialMutex.RUnlock() + argsForCall := fake.getTemporalLayerFpsForSpatialArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeREDTransformer) GetTemporalLayerFpsForSpatialReturns(result1 []float32) { + fake.getTemporalLayerFpsForSpatialMutex.Lock() + defer fake.getTemporalLayerFpsForSpatialMutex.Unlock() + fake.GetTemporalLayerFpsForSpatialStub = nil + fake.getTemporalLayerFpsForSpatialReturns = struct { + result1 []float32 + }{result1} +} + +func (fake *FakeREDTransformer) GetTemporalLayerFpsForSpatialReturnsOnCall(i int, result1 []float32) { + fake.getTemporalLayerFpsForSpatialMutex.Lock() + defer fake.getTemporalLayerFpsForSpatialMutex.Unlock() + fake.GetTemporalLayerFpsForSpatialStub = nil + if fake.getTemporalLayerFpsForSpatialReturnsOnCall == nil { + fake.getTemporalLayerFpsForSpatialReturnsOnCall = make(map[int]struct { + result1 []float32 + }) + } + fake.getTemporalLayerFpsForSpatialReturnsOnCall[i] = struct { + result1 []float32 + }{result1} +} + +func (fake *FakeREDTransformer) GetTrackStats() *livekit.RTPStats { + fake.getTrackStatsMutex.Lock() + ret, specificReturn := fake.getTrackStatsReturnsOnCall[len(fake.getTrackStatsArgsForCall)] + fake.getTrackStatsArgsForCall = append(fake.getTrackStatsArgsForCall, struct { + }{}) + stub := fake.GetTrackStatsStub + fakeReturns := fake.getTrackStatsReturns + fake.recordInvocation("GetTrackStats", []interface{}{}) + fake.getTrackStatsMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeREDTransformer) GetTrackStatsCallCount() int { + fake.getTrackStatsMutex.RLock() + defer fake.getTrackStatsMutex.RUnlock() + return len(fake.getTrackStatsArgsForCall) +} + +func (fake *FakeREDTransformer) GetTrackStatsCalls(stub func() *livekit.RTPStats) { + fake.getTrackStatsMutex.Lock() + defer fake.getTrackStatsMutex.Unlock() + fake.GetTrackStatsStub = stub +} + +func (fake *FakeREDTransformer) GetTrackStatsReturns(result1 *livekit.RTPStats) { + fake.getTrackStatsMutex.Lock() + defer fake.getTrackStatsMutex.Unlock() + fake.GetTrackStatsStub = nil + fake.getTrackStatsReturns = struct { + result1 *livekit.RTPStats + }{result1} +} + +func (fake *FakeREDTransformer) GetTrackStatsReturnsOnCall(i int, result1 *livekit.RTPStats) { + fake.getTrackStatsMutex.Lock() + defer fake.getTrackStatsMutex.Unlock() + fake.GetTrackStatsStub = nil + if fake.getTrackStatsReturnsOnCall == nil { + fake.getTrackStatsReturnsOnCall = make(map[int]struct { + result1 *livekit.RTPStats + }) + } + fake.getTrackStatsReturnsOnCall[i] = struct { + result1 *livekit.RTPStats + }{result1} +} + +func (fake *FakeREDTransformer) HeaderExtensions() []webrtc.RTPHeaderExtensionParameter { + fake.headerExtensionsMutex.Lock() + ret, specificReturn := fake.headerExtensionsReturnsOnCall[len(fake.headerExtensionsArgsForCall)] + fake.headerExtensionsArgsForCall = append(fake.headerExtensionsArgsForCall, struct { + }{}) + stub := fake.HeaderExtensionsStub + fakeReturns := fake.headerExtensionsReturns + fake.recordInvocation("HeaderExtensions", []interface{}{}) + fake.headerExtensionsMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeREDTransformer) HeaderExtensionsCallCount() int { + fake.headerExtensionsMutex.RLock() + defer fake.headerExtensionsMutex.RUnlock() + return len(fake.headerExtensionsArgsForCall) +} + +func (fake *FakeREDTransformer) HeaderExtensionsCalls(stub func() []webrtc.RTPHeaderExtensionParameter) { + fake.headerExtensionsMutex.Lock() + defer fake.headerExtensionsMutex.Unlock() + fake.HeaderExtensionsStub = stub +} + +func (fake *FakeREDTransformer) HeaderExtensionsReturns(result1 []webrtc.RTPHeaderExtensionParameter) { + fake.headerExtensionsMutex.Lock() + defer fake.headerExtensionsMutex.Unlock() + fake.HeaderExtensionsStub = nil + fake.headerExtensionsReturns = struct { + result1 []webrtc.RTPHeaderExtensionParameter + }{result1} +} + +func (fake *FakeREDTransformer) HeaderExtensionsReturnsOnCall(i int, result1 []webrtc.RTPHeaderExtensionParameter) { + fake.headerExtensionsMutex.Lock() + defer fake.headerExtensionsMutex.Unlock() + fake.HeaderExtensionsStub = nil + if fake.headerExtensionsReturnsOnCall == nil { + fake.headerExtensionsReturnsOnCall = make(map[int]struct { + result1 []webrtc.RTPHeaderExtensionParameter + }) + } + fake.headerExtensionsReturnsOnCall[i] = struct { + result1 []webrtc.RTPHeaderExtensionParameter + }{result1} +} + +func (fake *FakeREDTransformer) 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 *FakeREDTransformer) IsClosedCallCount() int { + fake.isClosedMutex.RLock() + defer fake.isClosedMutex.RUnlock() + return len(fake.isClosedArgsForCall) +} + +func (fake *FakeREDTransformer) IsClosedCalls(stub func() bool) { + fake.isClosedMutex.Lock() + defer fake.isClosedMutex.Unlock() + fake.IsClosedStub = stub +} + +func (fake *FakeREDTransformer) IsClosedReturns(result1 bool) { + fake.isClosedMutex.Lock() + defer fake.isClosedMutex.Unlock() + fake.IsClosedStub = nil + fake.isClosedReturns = struct { + result1 bool + }{result1} +} + +func (fake *FakeREDTransformer) 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 *FakeREDTransformer) Mime() mime.MimeType { + fake.mimeMutex.Lock() + ret, specificReturn := fake.mimeReturnsOnCall[len(fake.mimeArgsForCall)] + fake.mimeArgsForCall = append(fake.mimeArgsForCall, struct { + }{}) + stub := fake.MimeStub + fakeReturns := fake.mimeReturns + fake.recordInvocation("Mime", []interface{}{}) + fake.mimeMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeREDTransformer) MimeCallCount() int { + fake.mimeMutex.RLock() + defer fake.mimeMutex.RUnlock() + return len(fake.mimeArgsForCall) +} + +func (fake *FakeREDTransformer) MimeCalls(stub func() mime.MimeType) { + fake.mimeMutex.Lock() + defer fake.mimeMutex.Unlock() + fake.MimeStub = stub +} + +func (fake *FakeREDTransformer) MimeReturns(result1 mime.MimeType) { + fake.mimeMutex.Lock() + defer fake.mimeMutex.Unlock() + fake.MimeStub = nil + fake.mimeReturns = struct { + result1 mime.MimeType + }{result1} +} + +func (fake *FakeREDTransformer) MimeReturnsOnCall(i int, result1 mime.MimeType) { + fake.mimeMutex.Lock() + defer fake.mimeMutex.Unlock() + fake.MimeStub = nil + if fake.mimeReturnsOnCall == nil { + fake.mimeReturnsOnCall = make(map[int]struct { + result1 mime.MimeType + }) + } + fake.mimeReturnsOnCall[i] = struct { + result1 mime.MimeType + }{result1} +} + +func (fake *FakeREDTransformer) OnStreamRestart() { + fake.onStreamRestartMutex.Lock() + fake.onStreamRestartArgsForCall = append(fake.onStreamRestartArgsForCall, struct { + }{}) + stub := fake.OnStreamRestartStub + fake.recordInvocation("OnStreamRestart", []interface{}{}) + fake.onStreamRestartMutex.Unlock() + if stub != nil { + fake.OnStreamRestartStub() + } +} + +func (fake *FakeREDTransformer) OnStreamRestartCallCount() int { + fake.onStreamRestartMutex.RLock() + defer fake.onStreamRestartMutex.RUnlock() + return len(fake.onStreamRestartArgsForCall) +} + +func (fake *FakeREDTransformer) OnStreamRestartCalls(stub func()) { + fake.onStreamRestartMutex.Lock() + defer fake.onStreamRestartMutex.Unlock() + fake.OnStreamRestartStub = stub +} + +func (fake *FakeREDTransformer) ReadRTP(arg1 []byte, arg2 uint8, arg3 uint64) (int, error) { + var arg1Copy []byte + if arg1 != nil { + arg1Copy = make([]byte, len(arg1)) + copy(arg1Copy, arg1) + } + fake.readRTPMutex.Lock() + ret, specificReturn := fake.readRTPReturnsOnCall[len(fake.readRTPArgsForCall)] + fake.readRTPArgsForCall = append(fake.readRTPArgsForCall, struct { + arg1 []byte + arg2 uint8 + arg3 uint64 + }{arg1Copy, arg2, arg3}) + stub := fake.ReadRTPStub + fakeReturns := fake.readRTPReturns + fake.recordInvocation("ReadRTP", []interface{}{arg1Copy, arg2, arg3}) + fake.readRTPMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeREDTransformer) ReadRTPCallCount() int { + fake.readRTPMutex.RLock() + defer fake.readRTPMutex.RUnlock() + return len(fake.readRTPArgsForCall) +} + +func (fake *FakeREDTransformer) ReadRTPCalls(stub func([]byte, uint8, uint64) (int, error)) { + fake.readRTPMutex.Lock() + defer fake.readRTPMutex.Unlock() + fake.ReadRTPStub = stub +} + +func (fake *FakeREDTransformer) ReadRTPArgsForCall(i int) ([]byte, uint8, uint64) { + fake.readRTPMutex.RLock() + defer fake.readRTPMutex.RUnlock() + argsForCall := fake.readRTPArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeREDTransformer) ReadRTPReturns(result1 int, result2 error) { + fake.readRTPMutex.Lock() + defer fake.readRTPMutex.Unlock() + fake.ReadRTPStub = nil + fake.readRTPReturns = struct { + result1 int + result2 error + }{result1, result2} +} + +func (fake *FakeREDTransformer) ReadRTPReturnsOnCall(i int, result1 int, result2 error) { + fake.readRTPMutex.Lock() + defer fake.readRTPMutex.Unlock() + fake.ReadRTPStub = nil + if fake.readRTPReturnsOnCall == nil { + fake.readRTPReturnsOnCall = make(map[int]struct { + result1 int + result2 error + }) + } + fake.readRTPReturnsOnCall[i] = struct { + result1 int + result2 error + }{result1, result2} +} + +func (fake *FakeREDTransformer) Restart(arg1 string) { + fake.restartMutex.Lock() + fake.restartArgsForCall = append(fake.restartArgsForCall, struct { + arg1 string + }{arg1}) + stub := fake.RestartStub + fake.recordInvocation("Restart", []interface{}{arg1}) + fake.restartMutex.Unlock() + if stub != nil { + fake.RestartStub(arg1) + } +} + +func (fake *FakeREDTransformer) RestartCallCount() int { + fake.restartMutex.RLock() + defer fake.restartMutex.RUnlock() + return len(fake.restartArgsForCall) +} + +func (fake *FakeREDTransformer) RestartCalls(stub func(string)) { + fake.restartMutex.Lock() + defer fake.restartMutex.Unlock() + fake.RestartStub = stub +} + +func (fake *FakeREDTransformer) RestartArgsForCall(i int) string { + fake.restartMutex.RLock() + defer fake.restartMutex.RUnlock() + argsForCall := fake.restartArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeREDTransformer) ResyncDownTracks() { + fake.resyncDownTracksMutex.Lock() + fake.resyncDownTracksArgsForCall = append(fake.resyncDownTracksArgsForCall, struct { + }{}) + stub := fake.ResyncDownTracksStub + fake.recordInvocation("ResyncDownTracks", []interface{}{}) + fake.resyncDownTracksMutex.Unlock() + if stub != nil { + fake.ResyncDownTracksStub() + } +} + +func (fake *FakeREDTransformer) ResyncDownTracksCallCount() int { + fake.resyncDownTracksMutex.RLock() + defer fake.resyncDownTracksMutex.RUnlock() + return len(fake.resyncDownTracksArgsForCall) +} + +func (fake *FakeREDTransformer) ResyncDownTracksCalls(stub func()) { + fake.resyncDownTracksMutex.Lock() + defer fake.resyncDownTracksMutex.Unlock() + fake.ResyncDownTracksStub = stub +} + +func (fake *FakeREDTransformer) SendPLI(arg1 int32, arg2 bool) { + fake.sendPLIMutex.Lock() + fake.sendPLIArgsForCall = append(fake.sendPLIArgsForCall, struct { + arg1 int32 + arg2 bool + }{arg1, arg2}) + stub := fake.SendPLIStub + fake.recordInvocation("SendPLI", []interface{}{arg1, arg2}) + fake.sendPLIMutex.Unlock() + if stub != nil { + fake.SendPLIStub(arg1, arg2) + } +} + +func (fake *FakeREDTransformer) SendPLICallCount() int { + fake.sendPLIMutex.RLock() + defer fake.sendPLIMutex.RUnlock() + return len(fake.sendPLIArgsForCall) +} + +func (fake *FakeREDTransformer) SendPLICalls(stub func(int32, bool)) { + fake.sendPLIMutex.Lock() + defer fake.sendPLIMutex.Unlock() + fake.SendPLIStub = stub +} + +func (fake *FakeREDTransformer) SendPLIArgsForCall(i int) (int32, bool) { + fake.sendPLIMutex.RLock() + defer fake.sendPLIMutex.RUnlock() + argsForCall := fake.sendPLIArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeREDTransformer) SetLBThreshold(arg1 int) { + fake.setLBThresholdMutex.Lock() + fake.setLBThresholdArgsForCall = append(fake.setLBThresholdArgsForCall, struct { + arg1 int + }{arg1}) + stub := fake.SetLBThresholdStub + fake.recordInvocation("SetLBThreshold", []interface{}{arg1}) + fake.setLBThresholdMutex.Unlock() + if stub != nil { + fake.SetLBThresholdStub(arg1) + } +} + +func (fake *FakeREDTransformer) SetLBThresholdCallCount() int { + fake.setLBThresholdMutex.RLock() + defer fake.setLBThresholdMutex.RUnlock() + return len(fake.setLBThresholdArgsForCall) +} + +func (fake *FakeREDTransformer) SetLBThresholdCalls(stub func(int)) { + fake.setLBThresholdMutex.Lock() + defer fake.setLBThresholdMutex.Unlock() + fake.SetLBThresholdStub = stub +} + +func (fake *FakeREDTransformer) SetLBThresholdArgsForCall(i int) int { + fake.setLBThresholdMutex.RLock() + defer fake.setLBThresholdMutex.RUnlock() + argsForCall := fake.setLBThresholdArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeREDTransformer) SetMaxExpectedSpatialLayer(arg1 int32) { + fake.setMaxExpectedSpatialLayerMutex.Lock() + fake.setMaxExpectedSpatialLayerArgsForCall = append(fake.setMaxExpectedSpatialLayerArgsForCall, struct { + arg1 int32 + }{arg1}) + stub := fake.SetMaxExpectedSpatialLayerStub + fake.recordInvocation("SetMaxExpectedSpatialLayer", []interface{}{arg1}) + fake.setMaxExpectedSpatialLayerMutex.Unlock() + if stub != nil { + fake.SetMaxExpectedSpatialLayerStub(arg1) + } +} + +func (fake *FakeREDTransformer) SetMaxExpectedSpatialLayerCallCount() int { + fake.setMaxExpectedSpatialLayerMutex.RLock() + defer fake.setMaxExpectedSpatialLayerMutex.RUnlock() + return len(fake.setMaxExpectedSpatialLayerArgsForCall) +} + +func (fake *FakeREDTransformer) SetMaxExpectedSpatialLayerCalls(stub func(int32)) { + fake.setMaxExpectedSpatialLayerMutex.Lock() + defer fake.setMaxExpectedSpatialLayerMutex.Unlock() + fake.SetMaxExpectedSpatialLayerStub = stub +} + +func (fake *FakeREDTransformer) SetMaxExpectedSpatialLayerArgsForCall(i int) int32 { + fake.setMaxExpectedSpatialLayerMutex.RLock() + defer fake.setMaxExpectedSpatialLayerMutex.RUnlock() + argsForCall := fake.setMaxExpectedSpatialLayerArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeREDTransformer) StreamID() string { + fake.streamIDMutex.Lock() + ret, specificReturn := fake.streamIDReturnsOnCall[len(fake.streamIDArgsForCall)] + fake.streamIDArgsForCall = append(fake.streamIDArgsForCall, struct { + }{}) + stub := fake.StreamIDStub + fakeReturns := fake.streamIDReturns + fake.recordInvocation("StreamID", []interface{}{}) + fake.streamIDMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeREDTransformer) StreamIDCallCount() int { + fake.streamIDMutex.RLock() + defer fake.streamIDMutex.RUnlock() + return len(fake.streamIDArgsForCall) +} + +func (fake *FakeREDTransformer) StreamIDCalls(stub func() string) { + fake.streamIDMutex.Lock() + defer fake.streamIDMutex.Unlock() + fake.StreamIDStub = stub +} + +func (fake *FakeREDTransformer) StreamIDReturns(result1 string) { + fake.streamIDMutex.Lock() + defer fake.streamIDMutex.Unlock() + fake.StreamIDStub = nil + fake.streamIDReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeREDTransformer) StreamIDReturnsOnCall(i int, result1 string) { + fake.streamIDMutex.Lock() + defer fake.streamIDMutex.Unlock() + fake.StreamIDStub = nil + if fake.streamIDReturnsOnCall == nil { + fake.streamIDReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.streamIDReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FakeREDTransformer) TrackID() livekit.TrackID { + fake.trackIDMutex.Lock() + ret, specificReturn := fake.trackIDReturnsOnCall[len(fake.trackIDArgsForCall)] + fake.trackIDArgsForCall = append(fake.trackIDArgsForCall, struct { + }{}) + stub := fake.TrackIDStub + fakeReturns := fake.trackIDReturns + fake.recordInvocation("TrackID", []interface{}{}) + fake.trackIDMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeREDTransformer) TrackIDCallCount() int { + fake.trackIDMutex.RLock() + defer fake.trackIDMutex.RUnlock() + return len(fake.trackIDArgsForCall) +} + +func (fake *FakeREDTransformer) TrackIDCalls(stub func() livekit.TrackID) { + fake.trackIDMutex.Lock() + defer fake.trackIDMutex.Unlock() + fake.TrackIDStub = stub +} + +func (fake *FakeREDTransformer) TrackIDReturns(result1 livekit.TrackID) { + fake.trackIDMutex.Lock() + defer fake.trackIDMutex.Unlock() + fake.TrackIDStub = nil + fake.trackIDReturns = struct { + result1 livekit.TrackID + }{result1} +} + +func (fake *FakeREDTransformer) TrackIDReturnsOnCall(i int, result1 livekit.TrackID) { + fake.trackIDMutex.Lock() + defer fake.trackIDMutex.Unlock() + fake.TrackIDStub = nil + if fake.trackIDReturnsOnCall == nil { + fake.trackIDReturnsOnCall = make(map[int]struct { + result1 livekit.TrackID + }) + } + fake.trackIDReturnsOnCall[i] = struct { + result1 livekit.TrackID + }{result1} +} + +func (fake *FakeREDTransformer) TrackInfo() *livekit.TrackInfo { + fake.trackInfoMutex.Lock() + ret, specificReturn := fake.trackInfoReturnsOnCall[len(fake.trackInfoArgsForCall)] + fake.trackInfoArgsForCall = append(fake.trackInfoArgsForCall, struct { + }{}) + stub := fake.TrackInfoStub + fakeReturns := fake.trackInfoReturns + fake.recordInvocation("TrackInfo", []interface{}{}) + fake.trackInfoMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeREDTransformer) TrackInfoCallCount() int { + fake.trackInfoMutex.RLock() + defer fake.trackInfoMutex.RUnlock() + return len(fake.trackInfoArgsForCall) +} + +func (fake *FakeREDTransformer) TrackInfoCalls(stub func() *livekit.TrackInfo) { + fake.trackInfoMutex.Lock() + defer fake.trackInfoMutex.Unlock() + fake.TrackInfoStub = stub +} + +func (fake *FakeREDTransformer) TrackInfoReturns(result1 *livekit.TrackInfo) { + fake.trackInfoMutex.Lock() + defer fake.trackInfoMutex.Unlock() + fake.TrackInfoStub = nil + fake.trackInfoReturns = struct { + result1 *livekit.TrackInfo + }{result1} +} + +func (fake *FakeREDTransformer) TrackInfoReturnsOnCall(i int, result1 *livekit.TrackInfo) { + fake.trackInfoMutex.Lock() + defer fake.trackInfoMutex.Unlock() + fake.TrackInfoStub = nil + if fake.trackInfoReturnsOnCall == nil { + fake.trackInfoReturnsOnCall = make(map[int]struct { + result1 *livekit.TrackInfo + }) + } + fake.trackInfoReturnsOnCall[i] = struct { + result1 *livekit.TrackInfo + }{result1} +} + +func (fake *FakeREDTransformer) UpdateTrackInfo(arg1 *livekit.TrackInfo) { + fake.updateTrackInfoMutex.Lock() + fake.updateTrackInfoArgsForCall = append(fake.updateTrackInfoArgsForCall, struct { + arg1 *livekit.TrackInfo + }{arg1}) + stub := fake.UpdateTrackInfoStub + fake.recordInvocation("UpdateTrackInfo", []interface{}{arg1}) + fake.updateTrackInfoMutex.Unlock() + if stub != nil { + fake.UpdateTrackInfoStub(arg1) + } +} + +func (fake *FakeREDTransformer) UpdateTrackInfoCallCount() int { + fake.updateTrackInfoMutex.RLock() + defer fake.updateTrackInfoMutex.RUnlock() + return len(fake.updateTrackInfoArgsForCall) +} + +func (fake *FakeREDTransformer) UpdateTrackInfoCalls(stub func(*livekit.TrackInfo)) { + fake.updateTrackInfoMutex.Lock() + defer fake.updateTrackInfoMutex.Unlock() + fake.UpdateTrackInfoStub = stub +} + +func (fake *FakeREDTransformer) UpdateTrackInfoArgsForCall(i int) *livekit.TrackInfo { + fake.updateTrackInfoMutex.RLock() + defer fake.updateTrackInfoMutex.RUnlock() + argsForCall := fake.updateTrackInfoArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeREDTransformer) VideoLayerMode() livekit.VideoLayer_Mode { + fake.videoLayerModeMutex.Lock() + ret, specificReturn := fake.videoLayerModeReturnsOnCall[len(fake.videoLayerModeArgsForCall)] + fake.videoLayerModeArgsForCall = append(fake.videoLayerModeArgsForCall, struct { + }{}) + stub := fake.VideoLayerModeStub + fakeReturns := fake.videoLayerModeReturns + fake.recordInvocation("VideoLayerMode", []interface{}{}) + fake.videoLayerModeMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeREDTransformer) VideoLayerModeCallCount() int { + fake.videoLayerModeMutex.RLock() + defer fake.videoLayerModeMutex.RUnlock() + return len(fake.videoLayerModeArgsForCall) +} + +func (fake *FakeREDTransformer) VideoLayerModeCalls(stub func() livekit.VideoLayer_Mode) { + fake.videoLayerModeMutex.Lock() + defer fake.videoLayerModeMutex.Unlock() + fake.VideoLayerModeStub = stub +} + +func (fake *FakeREDTransformer) VideoLayerModeReturns(result1 livekit.VideoLayer_Mode) { + fake.videoLayerModeMutex.Lock() + defer fake.videoLayerModeMutex.Unlock() + fake.VideoLayerModeStub = nil + fake.videoLayerModeReturns = struct { + result1 livekit.VideoLayer_Mode + }{result1} +} + +func (fake *FakeREDTransformer) VideoLayerModeReturnsOnCall(i int, result1 livekit.VideoLayer_Mode) { + fake.videoLayerModeMutex.Lock() + defer fake.videoLayerModeMutex.Unlock() + fake.VideoLayerModeStub = nil + if fake.videoLayerModeReturnsOnCall == nil { + fake.videoLayerModeReturnsOnCall = make(map[int]struct { + result1 livekit.VideoLayer_Mode + }) + } + fake.videoLayerModeReturnsOnCall[i] = struct { + result1 livekit.VideoLayer_Mode + }{result1} +} + +func (fake *FakeREDTransformer) VideoSizes() []codec.VideoSize { + fake.videoSizesMutex.Lock() + ret, specificReturn := fake.videoSizesReturnsOnCall[len(fake.videoSizesArgsForCall)] + fake.videoSizesArgsForCall = append(fake.videoSizesArgsForCall, struct { + }{}) + stub := fake.VideoSizesStub + fakeReturns := fake.videoSizesReturns + fake.recordInvocation("VideoSizes", []interface{}{}) + fake.videoSizesMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeREDTransformer) VideoSizesCallCount() int { + fake.videoSizesMutex.RLock() + defer fake.videoSizesMutex.RUnlock() + return len(fake.videoSizesArgsForCall) +} + +func (fake *FakeREDTransformer) VideoSizesCalls(stub func() []codec.VideoSize) { + fake.videoSizesMutex.Lock() + defer fake.videoSizesMutex.Unlock() + fake.VideoSizesStub = stub +} + +func (fake *FakeREDTransformer) VideoSizesReturns(result1 []codec.VideoSize) { + fake.videoSizesMutex.Lock() + defer fake.videoSizesMutex.Unlock() + fake.VideoSizesStub = nil + fake.videoSizesReturns = struct { + result1 []codec.VideoSize + }{result1} +} + +func (fake *FakeREDTransformer) VideoSizesReturnsOnCall(i int, result1 []codec.VideoSize) { + fake.videoSizesMutex.Lock() + defer fake.videoSizesMutex.Unlock() + fake.VideoSizesStub = nil + if fake.videoSizesReturnsOnCall == nil { + fake.videoSizesReturnsOnCall = make(map[int]struct { + result1 []codec.VideoSize + }) + } + fake.videoSizesReturnsOnCall[i] = struct { + result1 []codec.VideoSize + }{result1} +} + +func (fake *FakeREDTransformer) 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 *FakeREDTransformer) 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.REDTransformer = new(FakeREDTransformer) diff --git a/pkg/sfu/sfufakes/fake_track_receiver.go b/pkg/sfu/sfufakes/fake_track_receiver.go new file mode 100644 index 000000000..baaec2ba8 --- /dev/null +++ b/pkg/sfu/sfufakes/fake_track_receiver.go @@ -0,0 +1,1613 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package sfufakes + +import ( + "sync" + + "github.com/livekit/livekit-server/pkg/sfu" + "github.com/livekit/mediatransportutil/pkg/codec" + "github.com/livekit/protocol/codecs/mime" + "github.com/livekit/protocol/livekit" + webrtc "github.com/pion/webrtc/v4" +) + +type FakeTrackReceiver struct { + AddDownTrackStub func(sfu.TrackSender) error + addDownTrackMutex sync.RWMutex + addDownTrackArgsForCall []struct { + arg1 sfu.TrackSender + } + addDownTrackReturns struct { + result1 error + } + addDownTrackReturnsOnCall map[int]struct { + result1 error + } + AddOnCodecStateChangeStub func(func(webrtc.RTPCodecParameters, sfu.ReceiverCodecState)) + addOnCodecStateChangeMutex sync.RWMutex + addOnCodecStateChangeArgsForCall []struct { + arg1 func(webrtc.RTPCodecParameters, sfu.ReceiverCodecState) + } + AddOnReadyStub func(func()) + addOnReadyMutex sync.RWMutex + addOnReadyArgsForCall []struct { + arg1 func() + } + CodecStub func() webrtc.RTPCodecParameters + codecMutex sync.RWMutex + codecArgsForCall []struct { + } + codecReturns struct { + result1 webrtc.RTPCodecParameters + } + codecReturnsOnCall map[int]struct { + result1 webrtc.RTPCodecParameters + } + CodecStateStub func() sfu.ReceiverCodecState + codecStateMutex sync.RWMutex + codecStateArgsForCall []struct { + } + codecStateReturns struct { + result1 sfu.ReceiverCodecState + } + codecStateReturnsOnCall map[int]struct { + result1 sfu.ReceiverCodecState + } + DebugInfoStub func() map[string]any + debugInfoMutex sync.RWMutex + debugInfoArgsForCall []struct { + } + debugInfoReturns struct { + result1 map[string]any + } + debugInfoReturnsOnCall map[int]struct { + result1 map[string]any + } + DeleteDownTrackStub func(livekit.ParticipantID) + deleteDownTrackMutex sync.RWMutex + deleteDownTrackArgsForCall []struct { + arg1 livekit.ParticipantID + } + GetAudioLevelStub func() (float64, bool) + getAudioLevelMutex sync.RWMutex + getAudioLevelArgsForCall []struct { + } + getAudioLevelReturns struct { + result1 float64 + result2 bool + } + getAudioLevelReturnsOnCall map[int]struct { + result1 float64 + result2 bool + } + GetDownTracksStub func() []sfu.TrackSender + getDownTracksMutex sync.RWMutex + getDownTracksArgsForCall []struct { + } + getDownTracksReturns struct { + result1 []sfu.TrackSender + } + getDownTracksReturnsOnCall map[int]struct { + result1 []sfu.TrackSender + } + GetLayeredBitrateStub func() ([]int32, sfu.Bitrates) + getLayeredBitrateMutex sync.RWMutex + getLayeredBitrateArgsForCall []struct { + } + getLayeredBitrateReturns struct { + result1 []int32 + result2 sfu.Bitrates + } + getLayeredBitrateReturnsOnCall map[int]struct { + result1 []int32 + result2 sfu.Bitrates + } + GetPrimaryReceiverForRedStub func() sfu.TrackReceiver + getPrimaryReceiverForRedMutex sync.RWMutex + getPrimaryReceiverForRedArgsForCall []struct { + } + getPrimaryReceiverForRedReturns struct { + result1 sfu.TrackReceiver + } + getPrimaryReceiverForRedReturnsOnCall map[int]struct { + result1 sfu.TrackReceiver + } + GetRedReceiverStub func() sfu.TrackReceiver + getRedReceiverMutex sync.RWMutex + getRedReceiverArgsForCall []struct { + } + getRedReceiverReturns struct { + result1 sfu.TrackReceiver + } + getRedReceiverReturnsOnCall map[int]struct { + result1 sfu.TrackReceiver + } + GetTemporalLayerFpsForSpatialStub func(int32) []float32 + getTemporalLayerFpsForSpatialMutex sync.RWMutex + getTemporalLayerFpsForSpatialArgsForCall []struct { + arg1 int32 + } + getTemporalLayerFpsForSpatialReturns struct { + result1 []float32 + } + getTemporalLayerFpsForSpatialReturnsOnCall map[int]struct { + result1 []float32 + } + GetTrackStatsStub func() *livekit.RTPStats + getTrackStatsMutex sync.RWMutex + getTrackStatsArgsForCall []struct { + } + getTrackStatsReturns struct { + result1 *livekit.RTPStats + } + getTrackStatsReturnsOnCall map[int]struct { + result1 *livekit.RTPStats + } + HeaderExtensionsStub func() []webrtc.RTPHeaderExtensionParameter + headerExtensionsMutex sync.RWMutex + headerExtensionsArgsForCall []struct { + } + headerExtensionsReturns struct { + result1 []webrtc.RTPHeaderExtensionParameter + } + headerExtensionsReturnsOnCall map[int]struct { + result1 []webrtc.RTPHeaderExtensionParameter + } + IsClosedStub func() bool + isClosedMutex sync.RWMutex + isClosedArgsForCall []struct { + } + isClosedReturns struct { + result1 bool + } + isClosedReturnsOnCall map[int]struct { + result1 bool + } + MimeStub func() mime.MimeType + mimeMutex sync.RWMutex + mimeArgsForCall []struct { + } + mimeReturns struct { + result1 mime.MimeType + } + mimeReturnsOnCall map[int]struct { + result1 mime.MimeType + } + ReadRTPStub func([]byte, uint8, uint64) (int, error) + readRTPMutex sync.RWMutex + readRTPArgsForCall []struct { + arg1 []byte + arg2 uint8 + arg3 uint64 + } + readRTPReturns struct { + result1 int + result2 error + } + readRTPReturnsOnCall map[int]struct { + result1 int + result2 error + } + RestartStub func(string) + restartMutex sync.RWMutex + restartArgsForCall []struct { + arg1 string + } + SendPLIStub func(int32, bool) + sendPLIMutex sync.RWMutex + sendPLIArgsForCall []struct { + arg1 int32 + arg2 bool + } + SetMaxExpectedSpatialLayerStub func(int32) + setMaxExpectedSpatialLayerMutex sync.RWMutex + setMaxExpectedSpatialLayerArgsForCall []struct { + arg1 int32 + } + StreamIDStub func() string + streamIDMutex sync.RWMutex + streamIDArgsForCall []struct { + } + streamIDReturns struct { + result1 string + } + streamIDReturnsOnCall map[int]struct { + result1 string + } + TrackIDStub func() livekit.TrackID + trackIDMutex sync.RWMutex + trackIDArgsForCall []struct { + } + trackIDReturns struct { + result1 livekit.TrackID + } + trackIDReturnsOnCall map[int]struct { + result1 livekit.TrackID + } + TrackInfoStub func() *livekit.TrackInfo + trackInfoMutex sync.RWMutex + trackInfoArgsForCall []struct { + } + trackInfoReturns struct { + result1 *livekit.TrackInfo + } + trackInfoReturnsOnCall map[int]struct { + result1 *livekit.TrackInfo + } + UpdateTrackInfoStub func(*livekit.TrackInfo) + updateTrackInfoMutex sync.RWMutex + updateTrackInfoArgsForCall []struct { + arg1 *livekit.TrackInfo + } + VideoLayerModeStub func() livekit.VideoLayer_Mode + videoLayerModeMutex sync.RWMutex + videoLayerModeArgsForCall []struct { + } + videoLayerModeReturns struct { + result1 livekit.VideoLayer_Mode + } + videoLayerModeReturnsOnCall map[int]struct { + result1 livekit.VideoLayer_Mode + } + VideoSizesStub func() []codec.VideoSize + videoSizesMutex sync.RWMutex + videoSizesArgsForCall []struct { + } + videoSizesReturns struct { + result1 []codec.VideoSize + } + videoSizesReturnsOnCall map[int]struct { + result1 []codec.VideoSize + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeTrackReceiver) AddDownTrack(arg1 sfu.TrackSender) error { + fake.addDownTrackMutex.Lock() + ret, specificReturn := fake.addDownTrackReturnsOnCall[len(fake.addDownTrackArgsForCall)] + fake.addDownTrackArgsForCall = append(fake.addDownTrackArgsForCall, struct { + arg1 sfu.TrackSender + }{arg1}) + stub := fake.AddDownTrackStub + fakeReturns := fake.addDownTrackReturns + fake.recordInvocation("AddDownTrack", []interface{}{arg1}) + fake.addDownTrackMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeTrackReceiver) AddDownTrackCallCount() int { + fake.addDownTrackMutex.RLock() + defer fake.addDownTrackMutex.RUnlock() + return len(fake.addDownTrackArgsForCall) +} + +func (fake *FakeTrackReceiver) AddDownTrackCalls(stub func(sfu.TrackSender) error) { + fake.addDownTrackMutex.Lock() + defer fake.addDownTrackMutex.Unlock() + fake.AddDownTrackStub = stub +} + +func (fake *FakeTrackReceiver) AddDownTrackArgsForCall(i int) sfu.TrackSender { + fake.addDownTrackMutex.RLock() + defer fake.addDownTrackMutex.RUnlock() + argsForCall := fake.addDownTrackArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeTrackReceiver) AddDownTrackReturns(result1 error) { + fake.addDownTrackMutex.Lock() + defer fake.addDownTrackMutex.Unlock() + fake.AddDownTrackStub = nil + fake.addDownTrackReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeTrackReceiver) AddDownTrackReturnsOnCall(i int, result1 error) { + fake.addDownTrackMutex.Lock() + defer fake.addDownTrackMutex.Unlock() + fake.AddDownTrackStub = nil + if fake.addDownTrackReturnsOnCall == nil { + fake.addDownTrackReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.addDownTrackReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeTrackReceiver) AddOnCodecStateChange(arg1 func(webrtc.RTPCodecParameters, sfu.ReceiverCodecState)) { + fake.addOnCodecStateChangeMutex.Lock() + fake.addOnCodecStateChangeArgsForCall = append(fake.addOnCodecStateChangeArgsForCall, struct { + arg1 func(webrtc.RTPCodecParameters, sfu.ReceiverCodecState) + }{arg1}) + stub := fake.AddOnCodecStateChangeStub + fake.recordInvocation("AddOnCodecStateChange", []interface{}{arg1}) + fake.addOnCodecStateChangeMutex.Unlock() + if stub != nil { + fake.AddOnCodecStateChangeStub(arg1) + } +} + +func (fake *FakeTrackReceiver) AddOnCodecStateChangeCallCount() int { + fake.addOnCodecStateChangeMutex.RLock() + defer fake.addOnCodecStateChangeMutex.RUnlock() + return len(fake.addOnCodecStateChangeArgsForCall) +} + +func (fake *FakeTrackReceiver) AddOnCodecStateChangeCalls(stub func(func(webrtc.RTPCodecParameters, sfu.ReceiverCodecState))) { + fake.addOnCodecStateChangeMutex.Lock() + defer fake.addOnCodecStateChangeMutex.Unlock() + fake.AddOnCodecStateChangeStub = stub +} + +func (fake *FakeTrackReceiver) AddOnCodecStateChangeArgsForCall(i int) func(webrtc.RTPCodecParameters, sfu.ReceiverCodecState) { + fake.addOnCodecStateChangeMutex.RLock() + defer fake.addOnCodecStateChangeMutex.RUnlock() + argsForCall := fake.addOnCodecStateChangeArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeTrackReceiver) AddOnReady(arg1 func()) { + fake.addOnReadyMutex.Lock() + fake.addOnReadyArgsForCall = append(fake.addOnReadyArgsForCall, struct { + arg1 func() + }{arg1}) + stub := fake.AddOnReadyStub + fake.recordInvocation("AddOnReady", []interface{}{arg1}) + fake.addOnReadyMutex.Unlock() + if stub != nil { + fake.AddOnReadyStub(arg1) + } +} + +func (fake *FakeTrackReceiver) AddOnReadyCallCount() int { + fake.addOnReadyMutex.RLock() + defer fake.addOnReadyMutex.RUnlock() + return len(fake.addOnReadyArgsForCall) +} + +func (fake *FakeTrackReceiver) AddOnReadyCalls(stub func(func())) { + fake.addOnReadyMutex.Lock() + defer fake.addOnReadyMutex.Unlock() + fake.AddOnReadyStub = stub +} + +func (fake *FakeTrackReceiver) AddOnReadyArgsForCall(i int) func() { + fake.addOnReadyMutex.RLock() + defer fake.addOnReadyMutex.RUnlock() + argsForCall := fake.addOnReadyArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeTrackReceiver) Codec() webrtc.RTPCodecParameters { + fake.codecMutex.Lock() + ret, specificReturn := fake.codecReturnsOnCall[len(fake.codecArgsForCall)] + fake.codecArgsForCall = append(fake.codecArgsForCall, struct { + }{}) + stub := fake.CodecStub + fakeReturns := fake.codecReturns + fake.recordInvocation("Codec", []interface{}{}) + fake.codecMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeTrackReceiver) CodecCallCount() int { + fake.codecMutex.RLock() + defer fake.codecMutex.RUnlock() + return len(fake.codecArgsForCall) +} + +func (fake *FakeTrackReceiver) CodecCalls(stub func() webrtc.RTPCodecParameters) { + fake.codecMutex.Lock() + defer fake.codecMutex.Unlock() + fake.CodecStub = stub +} + +func (fake *FakeTrackReceiver) CodecReturns(result1 webrtc.RTPCodecParameters) { + fake.codecMutex.Lock() + defer fake.codecMutex.Unlock() + fake.CodecStub = nil + fake.codecReturns = struct { + result1 webrtc.RTPCodecParameters + }{result1} +} + +func (fake *FakeTrackReceiver) CodecReturnsOnCall(i int, result1 webrtc.RTPCodecParameters) { + fake.codecMutex.Lock() + defer fake.codecMutex.Unlock() + fake.CodecStub = nil + if fake.codecReturnsOnCall == nil { + fake.codecReturnsOnCall = make(map[int]struct { + result1 webrtc.RTPCodecParameters + }) + } + fake.codecReturnsOnCall[i] = struct { + result1 webrtc.RTPCodecParameters + }{result1} +} + +func (fake *FakeTrackReceiver) CodecState() sfu.ReceiverCodecState { + fake.codecStateMutex.Lock() + ret, specificReturn := fake.codecStateReturnsOnCall[len(fake.codecStateArgsForCall)] + fake.codecStateArgsForCall = append(fake.codecStateArgsForCall, struct { + }{}) + stub := fake.CodecStateStub + fakeReturns := fake.codecStateReturns + fake.recordInvocation("CodecState", []interface{}{}) + fake.codecStateMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeTrackReceiver) CodecStateCallCount() int { + fake.codecStateMutex.RLock() + defer fake.codecStateMutex.RUnlock() + return len(fake.codecStateArgsForCall) +} + +func (fake *FakeTrackReceiver) CodecStateCalls(stub func() sfu.ReceiverCodecState) { + fake.codecStateMutex.Lock() + defer fake.codecStateMutex.Unlock() + fake.CodecStateStub = stub +} + +func (fake *FakeTrackReceiver) CodecStateReturns(result1 sfu.ReceiverCodecState) { + fake.codecStateMutex.Lock() + defer fake.codecStateMutex.Unlock() + fake.CodecStateStub = nil + fake.codecStateReturns = struct { + result1 sfu.ReceiverCodecState + }{result1} +} + +func (fake *FakeTrackReceiver) CodecStateReturnsOnCall(i int, result1 sfu.ReceiverCodecState) { + fake.codecStateMutex.Lock() + defer fake.codecStateMutex.Unlock() + fake.CodecStateStub = nil + if fake.codecStateReturnsOnCall == nil { + fake.codecStateReturnsOnCall = make(map[int]struct { + result1 sfu.ReceiverCodecState + }) + } + fake.codecStateReturnsOnCall[i] = struct { + result1 sfu.ReceiverCodecState + }{result1} +} + +func (fake *FakeTrackReceiver) DebugInfo() map[string]any { + fake.debugInfoMutex.Lock() + ret, specificReturn := fake.debugInfoReturnsOnCall[len(fake.debugInfoArgsForCall)] + fake.debugInfoArgsForCall = append(fake.debugInfoArgsForCall, struct { + }{}) + stub := fake.DebugInfoStub + fakeReturns := fake.debugInfoReturns + fake.recordInvocation("DebugInfo", []interface{}{}) + fake.debugInfoMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeTrackReceiver) DebugInfoCallCount() int { + fake.debugInfoMutex.RLock() + defer fake.debugInfoMutex.RUnlock() + return len(fake.debugInfoArgsForCall) +} + +func (fake *FakeTrackReceiver) DebugInfoCalls(stub func() map[string]any) { + fake.debugInfoMutex.Lock() + defer fake.debugInfoMutex.Unlock() + fake.DebugInfoStub = stub +} + +func (fake *FakeTrackReceiver) DebugInfoReturns(result1 map[string]any) { + fake.debugInfoMutex.Lock() + defer fake.debugInfoMutex.Unlock() + fake.DebugInfoStub = nil + fake.debugInfoReturns = struct { + result1 map[string]any + }{result1} +} + +func (fake *FakeTrackReceiver) DebugInfoReturnsOnCall(i int, result1 map[string]any) { + fake.debugInfoMutex.Lock() + defer fake.debugInfoMutex.Unlock() + fake.DebugInfoStub = nil + if fake.debugInfoReturnsOnCall == nil { + fake.debugInfoReturnsOnCall = make(map[int]struct { + result1 map[string]any + }) + } + fake.debugInfoReturnsOnCall[i] = struct { + result1 map[string]any + }{result1} +} + +func (fake *FakeTrackReceiver) DeleteDownTrack(arg1 livekit.ParticipantID) { + fake.deleteDownTrackMutex.Lock() + fake.deleteDownTrackArgsForCall = append(fake.deleteDownTrackArgsForCall, struct { + arg1 livekit.ParticipantID + }{arg1}) + stub := fake.DeleteDownTrackStub + fake.recordInvocation("DeleteDownTrack", []interface{}{arg1}) + fake.deleteDownTrackMutex.Unlock() + if stub != nil { + fake.DeleteDownTrackStub(arg1) + } +} + +func (fake *FakeTrackReceiver) DeleteDownTrackCallCount() int { + fake.deleteDownTrackMutex.RLock() + defer fake.deleteDownTrackMutex.RUnlock() + return len(fake.deleteDownTrackArgsForCall) +} + +func (fake *FakeTrackReceiver) DeleteDownTrackCalls(stub func(livekit.ParticipantID)) { + fake.deleteDownTrackMutex.Lock() + defer fake.deleteDownTrackMutex.Unlock() + fake.DeleteDownTrackStub = stub +} + +func (fake *FakeTrackReceiver) DeleteDownTrackArgsForCall(i int) livekit.ParticipantID { + fake.deleteDownTrackMutex.RLock() + defer fake.deleteDownTrackMutex.RUnlock() + argsForCall := fake.deleteDownTrackArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeTrackReceiver) GetAudioLevel() (float64, bool) { + fake.getAudioLevelMutex.Lock() + ret, specificReturn := fake.getAudioLevelReturnsOnCall[len(fake.getAudioLevelArgsForCall)] + fake.getAudioLevelArgsForCall = append(fake.getAudioLevelArgsForCall, struct { + }{}) + stub := fake.GetAudioLevelStub + fakeReturns := fake.getAudioLevelReturns + fake.recordInvocation("GetAudioLevel", []interface{}{}) + fake.getAudioLevelMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeTrackReceiver) GetAudioLevelCallCount() int { + fake.getAudioLevelMutex.RLock() + defer fake.getAudioLevelMutex.RUnlock() + return len(fake.getAudioLevelArgsForCall) +} + +func (fake *FakeTrackReceiver) GetAudioLevelCalls(stub func() (float64, bool)) { + fake.getAudioLevelMutex.Lock() + defer fake.getAudioLevelMutex.Unlock() + fake.GetAudioLevelStub = stub +} + +func (fake *FakeTrackReceiver) GetAudioLevelReturns(result1 float64, result2 bool) { + fake.getAudioLevelMutex.Lock() + defer fake.getAudioLevelMutex.Unlock() + fake.GetAudioLevelStub = nil + fake.getAudioLevelReturns = struct { + result1 float64 + result2 bool + }{result1, result2} +} + +func (fake *FakeTrackReceiver) GetAudioLevelReturnsOnCall(i int, result1 float64, result2 bool) { + fake.getAudioLevelMutex.Lock() + defer fake.getAudioLevelMutex.Unlock() + fake.GetAudioLevelStub = nil + if fake.getAudioLevelReturnsOnCall == nil { + fake.getAudioLevelReturnsOnCall = make(map[int]struct { + result1 float64 + result2 bool + }) + } + fake.getAudioLevelReturnsOnCall[i] = struct { + result1 float64 + result2 bool + }{result1, result2} +} + +func (fake *FakeTrackReceiver) GetDownTracks() []sfu.TrackSender { + fake.getDownTracksMutex.Lock() + ret, specificReturn := fake.getDownTracksReturnsOnCall[len(fake.getDownTracksArgsForCall)] + fake.getDownTracksArgsForCall = append(fake.getDownTracksArgsForCall, struct { + }{}) + stub := fake.GetDownTracksStub + fakeReturns := fake.getDownTracksReturns + fake.recordInvocation("GetDownTracks", []interface{}{}) + fake.getDownTracksMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeTrackReceiver) GetDownTracksCallCount() int { + fake.getDownTracksMutex.RLock() + defer fake.getDownTracksMutex.RUnlock() + return len(fake.getDownTracksArgsForCall) +} + +func (fake *FakeTrackReceiver) GetDownTracksCalls(stub func() []sfu.TrackSender) { + fake.getDownTracksMutex.Lock() + defer fake.getDownTracksMutex.Unlock() + fake.GetDownTracksStub = stub +} + +func (fake *FakeTrackReceiver) GetDownTracksReturns(result1 []sfu.TrackSender) { + fake.getDownTracksMutex.Lock() + defer fake.getDownTracksMutex.Unlock() + fake.GetDownTracksStub = nil + fake.getDownTracksReturns = struct { + result1 []sfu.TrackSender + }{result1} +} + +func (fake *FakeTrackReceiver) GetDownTracksReturnsOnCall(i int, result1 []sfu.TrackSender) { + fake.getDownTracksMutex.Lock() + defer fake.getDownTracksMutex.Unlock() + fake.GetDownTracksStub = nil + if fake.getDownTracksReturnsOnCall == nil { + fake.getDownTracksReturnsOnCall = make(map[int]struct { + result1 []sfu.TrackSender + }) + } + fake.getDownTracksReturnsOnCall[i] = struct { + result1 []sfu.TrackSender + }{result1} +} + +func (fake *FakeTrackReceiver) GetLayeredBitrate() ([]int32, sfu.Bitrates) { + fake.getLayeredBitrateMutex.Lock() + ret, specificReturn := fake.getLayeredBitrateReturnsOnCall[len(fake.getLayeredBitrateArgsForCall)] + fake.getLayeredBitrateArgsForCall = append(fake.getLayeredBitrateArgsForCall, struct { + }{}) + stub := fake.GetLayeredBitrateStub + fakeReturns := fake.getLayeredBitrateReturns + fake.recordInvocation("GetLayeredBitrate", []interface{}{}) + fake.getLayeredBitrateMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeTrackReceiver) GetLayeredBitrateCallCount() int { + fake.getLayeredBitrateMutex.RLock() + defer fake.getLayeredBitrateMutex.RUnlock() + return len(fake.getLayeredBitrateArgsForCall) +} + +func (fake *FakeTrackReceiver) GetLayeredBitrateCalls(stub func() ([]int32, sfu.Bitrates)) { + fake.getLayeredBitrateMutex.Lock() + defer fake.getLayeredBitrateMutex.Unlock() + fake.GetLayeredBitrateStub = stub +} + +func (fake *FakeTrackReceiver) GetLayeredBitrateReturns(result1 []int32, result2 sfu.Bitrates) { + fake.getLayeredBitrateMutex.Lock() + defer fake.getLayeredBitrateMutex.Unlock() + fake.GetLayeredBitrateStub = nil + fake.getLayeredBitrateReturns = struct { + result1 []int32 + result2 sfu.Bitrates + }{result1, result2} +} + +func (fake *FakeTrackReceiver) GetLayeredBitrateReturnsOnCall(i int, result1 []int32, result2 sfu.Bitrates) { + fake.getLayeredBitrateMutex.Lock() + defer fake.getLayeredBitrateMutex.Unlock() + fake.GetLayeredBitrateStub = nil + if fake.getLayeredBitrateReturnsOnCall == nil { + fake.getLayeredBitrateReturnsOnCall = make(map[int]struct { + result1 []int32 + result2 sfu.Bitrates + }) + } + fake.getLayeredBitrateReturnsOnCall[i] = struct { + result1 []int32 + result2 sfu.Bitrates + }{result1, result2} +} + +func (fake *FakeTrackReceiver) GetPrimaryReceiverForRed() sfu.TrackReceiver { + fake.getPrimaryReceiverForRedMutex.Lock() + ret, specificReturn := fake.getPrimaryReceiverForRedReturnsOnCall[len(fake.getPrimaryReceiverForRedArgsForCall)] + fake.getPrimaryReceiverForRedArgsForCall = append(fake.getPrimaryReceiverForRedArgsForCall, struct { + }{}) + stub := fake.GetPrimaryReceiverForRedStub + fakeReturns := fake.getPrimaryReceiverForRedReturns + fake.recordInvocation("GetPrimaryReceiverForRed", []interface{}{}) + fake.getPrimaryReceiverForRedMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeTrackReceiver) GetPrimaryReceiverForRedCallCount() int { + fake.getPrimaryReceiverForRedMutex.RLock() + defer fake.getPrimaryReceiverForRedMutex.RUnlock() + return len(fake.getPrimaryReceiverForRedArgsForCall) +} + +func (fake *FakeTrackReceiver) GetPrimaryReceiverForRedCalls(stub func() sfu.TrackReceiver) { + fake.getPrimaryReceiverForRedMutex.Lock() + defer fake.getPrimaryReceiverForRedMutex.Unlock() + fake.GetPrimaryReceiverForRedStub = stub +} + +func (fake *FakeTrackReceiver) GetPrimaryReceiverForRedReturns(result1 sfu.TrackReceiver) { + fake.getPrimaryReceiverForRedMutex.Lock() + defer fake.getPrimaryReceiverForRedMutex.Unlock() + fake.GetPrimaryReceiverForRedStub = nil + fake.getPrimaryReceiverForRedReturns = struct { + result1 sfu.TrackReceiver + }{result1} +} + +func (fake *FakeTrackReceiver) GetPrimaryReceiverForRedReturnsOnCall(i int, result1 sfu.TrackReceiver) { + fake.getPrimaryReceiverForRedMutex.Lock() + defer fake.getPrimaryReceiverForRedMutex.Unlock() + fake.GetPrimaryReceiverForRedStub = nil + if fake.getPrimaryReceiverForRedReturnsOnCall == nil { + fake.getPrimaryReceiverForRedReturnsOnCall = make(map[int]struct { + result1 sfu.TrackReceiver + }) + } + fake.getPrimaryReceiverForRedReturnsOnCall[i] = struct { + result1 sfu.TrackReceiver + }{result1} +} + +func (fake *FakeTrackReceiver) GetRedReceiver() sfu.TrackReceiver { + fake.getRedReceiverMutex.Lock() + ret, specificReturn := fake.getRedReceiverReturnsOnCall[len(fake.getRedReceiverArgsForCall)] + fake.getRedReceiverArgsForCall = append(fake.getRedReceiverArgsForCall, struct { + }{}) + stub := fake.GetRedReceiverStub + fakeReturns := fake.getRedReceiverReturns + fake.recordInvocation("GetRedReceiver", []interface{}{}) + fake.getRedReceiverMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeTrackReceiver) GetRedReceiverCallCount() int { + fake.getRedReceiverMutex.RLock() + defer fake.getRedReceiverMutex.RUnlock() + return len(fake.getRedReceiverArgsForCall) +} + +func (fake *FakeTrackReceiver) GetRedReceiverCalls(stub func() sfu.TrackReceiver) { + fake.getRedReceiverMutex.Lock() + defer fake.getRedReceiverMutex.Unlock() + fake.GetRedReceiverStub = stub +} + +func (fake *FakeTrackReceiver) GetRedReceiverReturns(result1 sfu.TrackReceiver) { + fake.getRedReceiverMutex.Lock() + defer fake.getRedReceiverMutex.Unlock() + fake.GetRedReceiverStub = nil + fake.getRedReceiverReturns = struct { + result1 sfu.TrackReceiver + }{result1} +} + +func (fake *FakeTrackReceiver) GetRedReceiverReturnsOnCall(i int, result1 sfu.TrackReceiver) { + fake.getRedReceiverMutex.Lock() + defer fake.getRedReceiverMutex.Unlock() + fake.GetRedReceiverStub = nil + if fake.getRedReceiverReturnsOnCall == nil { + fake.getRedReceiverReturnsOnCall = make(map[int]struct { + result1 sfu.TrackReceiver + }) + } + fake.getRedReceiverReturnsOnCall[i] = struct { + result1 sfu.TrackReceiver + }{result1} +} + +func (fake *FakeTrackReceiver) GetTemporalLayerFpsForSpatial(arg1 int32) []float32 { + fake.getTemporalLayerFpsForSpatialMutex.Lock() + ret, specificReturn := fake.getTemporalLayerFpsForSpatialReturnsOnCall[len(fake.getTemporalLayerFpsForSpatialArgsForCall)] + fake.getTemporalLayerFpsForSpatialArgsForCall = append(fake.getTemporalLayerFpsForSpatialArgsForCall, struct { + arg1 int32 + }{arg1}) + stub := fake.GetTemporalLayerFpsForSpatialStub + fakeReturns := fake.getTemporalLayerFpsForSpatialReturns + fake.recordInvocation("GetTemporalLayerFpsForSpatial", []interface{}{arg1}) + fake.getTemporalLayerFpsForSpatialMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeTrackReceiver) GetTemporalLayerFpsForSpatialCallCount() int { + fake.getTemporalLayerFpsForSpatialMutex.RLock() + defer fake.getTemporalLayerFpsForSpatialMutex.RUnlock() + return len(fake.getTemporalLayerFpsForSpatialArgsForCall) +} + +func (fake *FakeTrackReceiver) GetTemporalLayerFpsForSpatialCalls(stub func(int32) []float32) { + fake.getTemporalLayerFpsForSpatialMutex.Lock() + defer fake.getTemporalLayerFpsForSpatialMutex.Unlock() + fake.GetTemporalLayerFpsForSpatialStub = stub +} + +func (fake *FakeTrackReceiver) GetTemporalLayerFpsForSpatialArgsForCall(i int) int32 { + fake.getTemporalLayerFpsForSpatialMutex.RLock() + defer fake.getTemporalLayerFpsForSpatialMutex.RUnlock() + argsForCall := fake.getTemporalLayerFpsForSpatialArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeTrackReceiver) GetTemporalLayerFpsForSpatialReturns(result1 []float32) { + fake.getTemporalLayerFpsForSpatialMutex.Lock() + defer fake.getTemporalLayerFpsForSpatialMutex.Unlock() + fake.GetTemporalLayerFpsForSpatialStub = nil + fake.getTemporalLayerFpsForSpatialReturns = struct { + result1 []float32 + }{result1} +} + +func (fake *FakeTrackReceiver) GetTemporalLayerFpsForSpatialReturnsOnCall(i int, result1 []float32) { + fake.getTemporalLayerFpsForSpatialMutex.Lock() + defer fake.getTemporalLayerFpsForSpatialMutex.Unlock() + fake.GetTemporalLayerFpsForSpatialStub = nil + if fake.getTemporalLayerFpsForSpatialReturnsOnCall == nil { + fake.getTemporalLayerFpsForSpatialReturnsOnCall = make(map[int]struct { + result1 []float32 + }) + } + fake.getTemporalLayerFpsForSpatialReturnsOnCall[i] = struct { + result1 []float32 + }{result1} +} + +func (fake *FakeTrackReceiver) GetTrackStats() *livekit.RTPStats { + fake.getTrackStatsMutex.Lock() + ret, specificReturn := fake.getTrackStatsReturnsOnCall[len(fake.getTrackStatsArgsForCall)] + fake.getTrackStatsArgsForCall = append(fake.getTrackStatsArgsForCall, struct { + }{}) + stub := fake.GetTrackStatsStub + fakeReturns := fake.getTrackStatsReturns + fake.recordInvocation("GetTrackStats", []interface{}{}) + fake.getTrackStatsMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeTrackReceiver) GetTrackStatsCallCount() int { + fake.getTrackStatsMutex.RLock() + defer fake.getTrackStatsMutex.RUnlock() + return len(fake.getTrackStatsArgsForCall) +} + +func (fake *FakeTrackReceiver) GetTrackStatsCalls(stub func() *livekit.RTPStats) { + fake.getTrackStatsMutex.Lock() + defer fake.getTrackStatsMutex.Unlock() + fake.GetTrackStatsStub = stub +} + +func (fake *FakeTrackReceiver) GetTrackStatsReturns(result1 *livekit.RTPStats) { + fake.getTrackStatsMutex.Lock() + defer fake.getTrackStatsMutex.Unlock() + fake.GetTrackStatsStub = nil + fake.getTrackStatsReturns = struct { + result1 *livekit.RTPStats + }{result1} +} + +func (fake *FakeTrackReceiver) GetTrackStatsReturnsOnCall(i int, result1 *livekit.RTPStats) { + fake.getTrackStatsMutex.Lock() + defer fake.getTrackStatsMutex.Unlock() + fake.GetTrackStatsStub = nil + if fake.getTrackStatsReturnsOnCall == nil { + fake.getTrackStatsReturnsOnCall = make(map[int]struct { + result1 *livekit.RTPStats + }) + } + fake.getTrackStatsReturnsOnCall[i] = struct { + result1 *livekit.RTPStats + }{result1} +} + +func (fake *FakeTrackReceiver) HeaderExtensions() []webrtc.RTPHeaderExtensionParameter { + fake.headerExtensionsMutex.Lock() + ret, specificReturn := fake.headerExtensionsReturnsOnCall[len(fake.headerExtensionsArgsForCall)] + fake.headerExtensionsArgsForCall = append(fake.headerExtensionsArgsForCall, struct { + }{}) + stub := fake.HeaderExtensionsStub + fakeReturns := fake.headerExtensionsReturns + fake.recordInvocation("HeaderExtensions", []interface{}{}) + fake.headerExtensionsMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeTrackReceiver) HeaderExtensionsCallCount() int { + fake.headerExtensionsMutex.RLock() + defer fake.headerExtensionsMutex.RUnlock() + return len(fake.headerExtensionsArgsForCall) +} + +func (fake *FakeTrackReceiver) HeaderExtensionsCalls(stub func() []webrtc.RTPHeaderExtensionParameter) { + fake.headerExtensionsMutex.Lock() + defer fake.headerExtensionsMutex.Unlock() + fake.HeaderExtensionsStub = stub +} + +func (fake *FakeTrackReceiver) HeaderExtensionsReturns(result1 []webrtc.RTPHeaderExtensionParameter) { + fake.headerExtensionsMutex.Lock() + defer fake.headerExtensionsMutex.Unlock() + fake.HeaderExtensionsStub = nil + fake.headerExtensionsReturns = struct { + result1 []webrtc.RTPHeaderExtensionParameter + }{result1} +} + +func (fake *FakeTrackReceiver) HeaderExtensionsReturnsOnCall(i int, result1 []webrtc.RTPHeaderExtensionParameter) { + fake.headerExtensionsMutex.Lock() + defer fake.headerExtensionsMutex.Unlock() + fake.HeaderExtensionsStub = nil + if fake.headerExtensionsReturnsOnCall == nil { + fake.headerExtensionsReturnsOnCall = make(map[int]struct { + result1 []webrtc.RTPHeaderExtensionParameter + }) + } + fake.headerExtensionsReturnsOnCall[i] = struct { + result1 []webrtc.RTPHeaderExtensionParameter + }{result1} +} + +func (fake *FakeTrackReceiver) 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 *FakeTrackReceiver) IsClosedCallCount() int { + fake.isClosedMutex.RLock() + defer fake.isClosedMutex.RUnlock() + return len(fake.isClosedArgsForCall) +} + +func (fake *FakeTrackReceiver) IsClosedCalls(stub func() bool) { + fake.isClosedMutex.Lock() + defer fake.isClosedMutex.Unlock() + fake.IsClosedStub = stub +} + +func (fake *FakeTrackReceiver) IsClosedReturns(result1 bool) { + fake.isClosedMutex.Lock() + defer fake.isClosedMutex.Unlock() + fake.IsClosedStub = nil + fake.isClosedReturns = struct { + result1 bool + }{result1} +} + +func (fake *FakeTrackReceiver) 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 *FakeTrackReceiver) Mime() mime.MimeType { + fake.mimeMutex.Lock() + ret, specificReturn := fake.mimeReturnsOnCall[len(fake.mimeArgsForCall)] + fake.mimeArgsForCall = append(fake.mimeArgsForCall, struct { + }{}) + stub := fake.MimeStub + fakeReturns := fake.mimeReturns + fake.recordInvocation("Mime", []interface{}{}) + fake.mimeMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeTrackReceiver) MimeCallCount() int { + fake.mimeMutex.RLock() + defer fake.mimeMutex.RUnlock() + return len(fake.mimeArgsForCall) +} + +func (fake *FakeTrackReceiver) MimeCalls(stub func() mime.MimeType) { + fake.mimeMutex.Lock() + defer fake.mimeMutex.Unlock() + fake.MimeStub = stub +} + +func (fake *FakeTrackReceiver) MimeReturns(result1 mime.MimeType) { + fake.mimeMutex.Lock() + defer fake.mimeMutex.Unlock() + fake.MimeStub = nil + fake.mimeReturns = struct { + result1 mime.MimeType + }{result1} +} + +func (fake *FakeTrackReceiver) MimeReturnsOnCall(i int, result1 mime.MimeType) { + fake.mimeMutex.Lock() + defer fake.mimeMutex.Unlock() + fake.MimeStub = nil + if fake.mimeReturnsOnCall == nil { + fake.mimeReturnsOnCall = make(map[int]struct { + result1 mime.MimeType + }) + } + fake.mimeReturnsOnCall[i] = struct { + result1 mime.MimeType + }{result1} +} + +func (fake *FakeTrackReceiver) ReadRTP(arg1 []byte, arg2 uint8, arg3 uint64) (int, error) { + var arg1Copy []byte + if arg1 != nil { + arg1Copy = make([]byte, len(arg1)) + copy(arg1Copy, arg1) + } + fake.readRTPMutex.Lock() + ret, specificReturn := fake.readRTPReturnsOnCall[len(fake.readRTPArgsForCall)] + fake.readRTPArgsForCall = append(fake.readRTPArgsForCall, struct { + arg1 []byte + arg2 uint8 + arg3 uint64 + }{arg1Copy, arg2, arg3}) + stub := fake.ReadRTPStub + fakeReturns := fake.readRTPReturns + fake.recordInvocation("ReadRTP", []interface{}{arg1Copy, arg2, arg3}) + fake.readRTPMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeTrackReceiver) ReadRTPCallCount() int { + fake.readRTPMutex.RLock() + defer fake.readRTPMutex.RUnlock() + return len(fake.readRTPArgsForCall) +} + +func (fake *FakeTrackReceiver) ReadRTPCalls(stub func([]byte, uint8, uint64) (int, error)) { + fake.readRTPMutex.Lock() + defer fake.readRTPMutex.Unlock() + fake.ReadRTPStub = stub +} + +func (fake *FakeTrackReceiver) ReadRTPArgsForCall(i int) ([]byte, uint8, uint64) { + fake.readRTPMutex.RLock() + defer fake.readRTPMutex.RUnlock() + argsForCall := fake.readRTPArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeTrackReceiver) ReadRTPReturns(result1 int, result2 error) { + fake.readRTPMutex.Lock() + defer fake.readRTPMutex.Unlock() + fake.ReadRTPStub = nil + fake.readRTPReturns = struct { + result1 int + result2 error + }{result1, result2} +} + +func (fake *FakeTrackReceiver) ReadRTPReturnsOnCall(i int, result1 int, result2 error) { + fake.readRTPMutex.Lock() + defer fake.readRTPMutex.Unlock() + fake.ReadRTPStub = nil + if fake.readRTPReturnsOnCall == nil { + fake.readRTPReturnsOnCall = make(map[int]struct { + result1 int + result2 error + }) + } + fake.readRTPReturnsOnCall[i] = struct { + result1 int + result2 error + }{result1, result2} +} + +func (fake *FakeTrackReceiver) Restart(arg1 string) { + fake.restartMutex.Lock() + fake.restartArgsForCall = append(fake.restartArgsForCall, struct { + arg1 string + }{arg1}) + stub := fake.RestartStub + fake.recordInvocation("Restart", []interface{}{arg1}) + fake.restartMutex.Unlock() + if stub != nil { + fake.RestartStub(arg1) + } +} + +func (fake *FakeTrackReceiver) RestartCallCount() int { + fake.restartMutex.RLock() + defer fake.restartMutex.RUnlock() + return len(fake.restartArgsForCall) +} + +func (fake *FakeTrackReceiver) RestartCalls(stub func(string)) { + fake.restartMutex.Lock() + defer fake.restartMutex.Unlock() + fake.RestartStub = stub +} + +func (fake *FakeTrackReceiver) RestartArgsForCall(i int) string { + fake.restartMutex.RLock() + defer fake.restartMutex.RUnlock() + argsForCall := fake.restartArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeTrackReceiver) SendPLI(arg1 int32, arg2 bool) { + fake.sendPLIMutex.Lock() + fake.sendPLIArgsForCall = append(fake.sendPLIArgsForCall, struct { + arg1 int32 + arg2 bool + }{arg1, arg2}) + stub := fake.SendPLIStub + fake.recordInvocation("SendPLI", []interface{}{arg1, arg2}) + fake.sendPLIMutex.Unlock() + if stub != nil { + fake.SendPLIStub(arg1, arg2) + } +} + +func (fake *FakeTrackReceiver) SendPLICallCount() int { + fake.sendPLIMutex.RLock() + defer fake.sendPLIMutex.RUnlock() + return len(fake.sendPLIArgsForCall) +} + +func (fake *FakeTrackReceiver) SendPLICalls(stub func(int32, bool)) { + fake.sendPLIMutex.Lock() + defer fake.sendPLIMutex.Unlock() + fake.SendPLIStub = stub +} + +func (fake *FakeTrackReceiver) SendPLIArgsForCall(i int) (int32, bool) { + fake.sendPLIMutex.RLock() + defer fake.sendPLIMutex.RUnlock() + argsForCall := fake.sendPLIArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeTrackReceiver) SetMaxExpectedSpatialLayer(arg1 int32) { + fake.setMaxExpectedSpatialLayerMutex.Lock() + fake.setMaxExpectedSpatialLayerArgsForCall = append(fake.setMaxExpectedSpatialLayerArgsForCall, struct { + arg1 int32 + }{arg1}) + stub := fake.SetMaxExpectedSpatialLayerStub + fake.recordInvocation("SetMaxExpectedSpatialLayer", []interface{}{arg1}) + fake.setMaxExpectedSpatialLayerMutex.Unlock() + if stub != nil { + fake.SetMaxExpectedSpatialLayerStub(arg1) + } +} + +func (fake *FakeTrackReceiver) SetMaxExpectedSpatialLayerCallCount() int { + fake.setMaxExpectedSpatialLayerMutex.RLock() + defer fake.setMaxExpectedSpatialLayerMutex.RUnlock() + return len(fake.setMaxExpectedSpatialLayerArgsForCall) +} + +func (fake *FakeTrackReceiver) SetMaxExpectedSpatialLayerCalls(stub func(int32)) { + fake.setMaxExpectedSpatialLayerMutex.Lock() + defer fake.setMaxExpectedSpatialLayerMutex.Unlock() + fake.SetMaxExpectedSpatialLayerStub = stub +} + +func (fake *FakeTrackReceiver) SetMaxExpectedSpatialLayerArgsForCall(i int) int32 { + fake.setMaxExpectedSpatialLayerMutex.RLock() + defer fake.setMaxExpectedSpatialLayerMutex.RUnlock() + argsForCall := fake.setMaxExpectedSpatialLayerArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeTrackReceiver) StreamID() string { + fake.streamIDMutex.Lock() + ret, specificReturn := fake.streamIDReturnsOnCall[len(fake.streamIDArgsForCall)] + fake.streamIDArgsForCall = append(fake.streamIDArgsForCall, struct { + }{}) + stub := fake.StreamIDStub + fakeReturns := fake.streamIDReturns + fake.recordInvocation("StreamID", []interface{}{}) + fake.streamIDMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeTrackReceiver) StreamIDCallCount() int { + fake.streamIDMutex.RLock() + defer fake.streamIDMutex.RUnlock() + return len(fake.streamIDArgsForCall) +} + +func (fake *FakeTrackReceiver) StreamIDCalls(stub func() string) { + fake.streamIDMutex.Lock() + defer fake.streamIDMutex.Unlock() + fake.StreamIDStub = stub +} + +func (fake *FakeTrackReceiver) StreamIDReturns(result1 string) { + fake.streamIDMutex.Lock() + defer fake.streamIDMutex.Unlock() + fake.StreamIDStub = nil + fake.streamIDReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeTrackReceiver) StreamIDReturnsOnCall(i int, result1 string) { + fake.streamIDMutex.Lock() + defer fake.streamIDMutex.Unlock() + fake.StreamIDStub = nil + if fake.streamIDReturnsOnCall == nil { + fake.streamIDReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.streamIDReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FakeTrackReceiver) TrackID() livekit.TrackID { + fake.trackIDMutex.Lock() + ret, specificReturn := fake.trackIDReturnsOnCall[len(fake.trackIDArgsForCall)] + fake.trackIDArgsForCall = append(fake.trackIDArgsForCall, struct { + }{}) + stub := fake.TrackIDStub + fakeReturns := fake.trackIDReturns + fake.recordInvocation("TrackID", []interface{}{}) + fake.trackIDMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeTrackReceiver) TrackIDCallCount() int { + fake.trackIDMutex.RLock() + defer fake.trackIDMutex.RUnlock() + return len(fake.trackIDArgsForCall) +} + +func (fake *FakeTrackReceiver) TrackIDCalls(stub func() livekit.TrackID) { + fake.trackIDMutex.Lock() + defer fake.trackIDMutex.Unlock() + fake.TrackIDStub = stub +} + +func (fake *FakeTrackReceiver) TrackIDReturns(result1 livekit.TrackID) { + fake.trackIDMutex.Lock() + defer fake.trackIDMutex.Unlock() + fake.TrackIDStub = nil + fake.trackIDReturns = struct { + result1 livekit.TrackID + }{result1} +} + +func (fake *FakeTrackReceiver) TrackIDReturnsOnCall(i int, result1 livekit.TrackID) { + fake.trackIDMutex.Lock() + defer fake.trackIDMutex.Unlock() + fake.TrackIDStub = nil + if fake.trackIDReturnsOnCall == nil { + fake.trackIDReturnsOnCall = make(map[int]struct { + result1 livekit.TrackID + }) + } + fake.trackIDReturnsOnCall[i] = struct { + result1 livekit.TrackID + }{result1} +} + +func (fake *FakeTrackReceiver) TrackInfo() *livekit.TrackInfo { + fake.trackInfoMutex.Lock() + ret, specificReturn := fake.trackInfoReturnsOnCall[len(fake.trackInfoArgsForCall)] + fake.trackInfoArgsForCall = append(fake.trackInfoArgsForCall, struct { + }{}) + stub := fake.TrackInfoStub + fakeReturns := fake.trackInfoReturns + fake.recordInvocation("TrackInfo", []interface{}{}) + fake.trackInfoMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeTrackReceiver) TrackInfoCallCount() int { + fake.trackInfoMutex.RLock() + defer fake.trackInfoMutex.RUnlock() + return len(fake.trackInfoArgsForCall) +} + +func (fake *FakeTrackReceiver) TrackInfoCalls(stub func() *livekit.TrackInfo) { + fake.trackInfoMutex.Lock() + defer fake.trackInfoMutex.Unlock() + fake.TrackInfoStub = stub +} + +func (fake *FakeTrackReceiver) TrackInfoReturns(result1 *livekit.TrackInfo) { + fake.trackInfoMutex.Lock() + defer fake.trackInfoMutex.Unlock() + fake.TrackInfoStub = nil + fake.trackInfoReturns = struct { + result1 *livekit.TrackInfo + }{result1} +} + +func (fake *FakeTrackReceiver) TrackInfoReturnsOnCall(i int, result1 *livekit.TrackInfo) { + fake.trackInfoMutex.Lock() + defer fake.trackInfoMutex.Unlock() + fake.TrackInfoStub = nil + if fake.trackInfoReturnsOnCall == nil { + fake.trackInfoReturnsOnCall = make(map[int]struct { + result1 *livekit.TrackInfo + }) + } + fake.trackInfoReturnsOnCall[i] = struct { + result1 *livekit.TrackInfo + }{result1} +} + +func (fake *FakeTrackReceiver) UpdateTrackInfo(arg1 *livekit.TrackInfo) { + fake.updateTrackInfoMutex.Lock() + fake.updateTrackInfoArgsForCall = append(fake.updateTrackInfoArgsForCall, struct { + arg1 *livekit.TrackInfo + }{arg1}) + stub := fake.UpdateTrackInfoStub + fake.recordInvocation("UpdateTrackInfo", []interface{}{arg1}) + fake.updateTrackInfoMutex.Unlock() + if stub != nil { + fake.UpdateTrackInfoStub(arg1) + } +} + +func (fake *FakeTrackReceiver) UpdateTrackInfoCallCount() int { + fake.updateTrackInfoMutex.RLock() + defer fake.updateTrackInfoMutex.RUnlock() + return len(fake.updateTrackInfoArgsForCall) +} + +func (fake *FakeTrackReceiver) UpdateTrackInfoCalls(stub func(*livekit.TrackInfo)) { + fake.updateTrackInfoMutex.Lock() + defer fake.updateTrackInfoMutex.Unlock() + fake.UpdateTrackInfoStub = stub +} + +func (fake *FakeTrackReceiver) UpdateTrackInfoArgsForCall(i int) *livekit.TrackInfo { + fake.updateTrackInfoMutex.RLock() + defer fake.updateTrackInfoMutex.RUnlock() + argsForCall := fake.updateTrackInfoArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeTrackReceiver) VideoLayerMode() livekit.VideoLayer_Mode { + fake.videoLayerModeMutex.Lock() + ret, specificReturn := fake.videoLayerModeReturnsOnCall[len(fake.videoLayerModeArgsForCall)] + fake.videoLayerModeArgsForCall = append(fake.videoLayerModeArgsForCall, struct { + }{}) + stub := fake.VideoLayerModeStub + fakeReturns := fake.videoLayerModeReturns + fake.recordInvocation("VideoLayerMode", []interface{}{}) + fake.videoLayerModeMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeTrackReceiver) VideoLayerModeCallCount() int { + fake.videoLayerModeMutex.RLock() + defer fake.videoLayerModeMutex.RUnlock() + return len(fake.videoLayerModeArgsForCall) +} + +func (fake *FakeTrackReceiver) VideoLayerModeCalls(stub func() livekit.VideoLayer_Mode) { + fake.videoLayerModeMutex.Lock() + defer fake.videoLayerModeMutex.Unlock() + fake.VideoLayerModeStub = stub +} + +func (fake *FakeTrackReceiver) VideoLayerModeReturns(result1 livekit.VideoLayer_Mode) { + fake.videoLayerModeMutex.Lock() + defer fake.videoLayerModeMutex.Unlock() + fake.VideoLayerModeStub = nil + fake.videoLayerModeReturns = struct { + result1 livekit.VideoLayer_Mode + }{result1} +} + +func (fake *FakeTrackReceiver) VideoLayerModeReturnsOnCall(i int, result1 livekit.VideoLayer_Mode) { + fake.videoLayerModeMutex.Lock() + defer fake.videoLayerModeMutex.Unlock() + fake.VideoLayerModeStub = nil + if fake.videoLayerModeReturnsOnCall == nil { + fake.videoLayerModeReturnsOnCall = make(map[int]struct { + result1 livekit.VideoLayer_Mode + }) + } + fake.videoLayerModeReturnsOnCall[i] = struct { + result1 livekit.VideoLayer_Mode + }{result1} +} + +func (fake *FakeTrackReceiver) VideoSizes() []codec.VideoSize { + fake.videoSizesMutex.Lock() + ret, specificReturn := fake.videoSizesReturnsOnCall[len(fake.videoSizesArgsForCall)] + fake.videoSizesArgsForCall = append(fake.videoSizesArgsForCall, struct { + }{}) + stub := fake.VideoSizesStub + fakeReturns := fake.videoSizesReturns + fake.recordInvocation("VideoSizes", []interface{}{}) + fake.videoSizesMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeTrackReceiver) VideoSizesCallCount() int { + fake.videoSizesMutex.RLock() + defer fake.videoSizesMutex.RUnlock() + return len(fake.videoSizesArgsForCall) +} + +func (fake *FakeTrackReceiver) VideoSizesCalls(stub func() []codec.VideoSize) { + fake.videoSizesMutex.Lock() + defer fake.videoSizesMutex.Unlock() + fake.VideoSizesStub = stub +} + +func (fake *FakeTrackReceiver) VideoSizesReturns(result1 []codec.VideoSize) { + fake.videoSizesMutex.Lock() + defer fake.videoSizesMutex.Unlock() + fake.VideoSizesStub = nil + fake.videoSizesReturns = struct { + result1 []codec.VideoSize + }{result1} +} + +func (fake *FakeTrackReceiver) VideoSizesReturnsOnCall(i int, result1 []codec.VideoSize) { + fake.videoSizesMutex.Lock() + defer fake.videoSizesMutex.Unlock() + fake.VideoSizesStub = nil + if fake.videoSizesReturnsOnCall == nil { + fake.videoSizesReturnsOnCall = make(map[int]struct { + result1 []codec.VideoSize + }) + } + fake.videoSizesReturnsOnCall[i] = struct { + result1 []codec.VideoSize + }{result1} +} + +func (fake *FakeTrackReceiver) 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 *FakeTrackReceiver) 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.TrackReceiver = new(FakeTrackReceiver) diff --git a/pkg/sfu/sfufakes/fake_track_sender.go b/pkg/sfu/sfufakes/fake_track_sender.go new file mode 100644 index 000000000..01df20592 --- /dev/null +++ b/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)