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)