Skip to content

armgit / Piik

Public Imported from GitHub
0

Free, open-source screen sharing for private live streams with friends. Watch together in a browser or self-host Piik. 免费开源的私密屏幕共享,支持游戏直播、一起看电影与自部署。

24.5 KB
Raw Blame
package forwarding

import (
	"context"
	"net"
	"sync"
	"sync/atomic"
	"testing"
	"time"

	"github.com/livekit/livekit-server/pkg/sfu"
	"github.com/livekit/livekit-server/pkg/sfu/bwe"
	"github.com/livekit/livekit-server/pkg/sfu/ccutils"
	"github.com/livekit/livekit-server/pkg/sfu/pacer"
	packetpacer "github.com/livekit/mediatransportutil/pkg/pacer"
	"github.com/livekit/protocol/logger"
	"github.com/pion/interceptor"
	"github.com/pion/rtcp"
	"github.com/pion/rtp"
	"github.com/pion/rtp/codecs"
	"github.com/pion/webrtc/v4"
	"github.com/pion/webrtc/v4/pkg/media"
)

func TestTransportVideoFeedbackAudioAndClose(t *testing.T) {
	for _, repair := range []bool{true, false} {
		name := "RTX"
		if !repair {
			name = "primary-only"
		}
		t.Run(name, func(t *testing.T) { testTransportVideoFeedbackAudioAndClose(t, repair, false) })
	}
	t.Run("withdrawn-demand", func(t *testing.T) { testTransportVideoFeedbackAudioAndClose(t, true, true) })
}

func testTransportVideoFeedbackAudioAndClose(t *testing.T, repair, withdrawDemand bool) {
	ctx, cancel := context.WithTimeout(t.Context(), 5*time.Second)
	defer cancel()
	check := func(err error) {
		t.Helper()
		if err != nil {
			t.Fatal(err)
		}
	}
	codec := webrtc.RTPCodecParameters{RTPCodecCapability: webrtc.RTPCodecCapability{
		MimeType: webrtc.MimeTypeVP8, ClockRate: 90_000,
		RTCPFeedback: []webrtc.RTCPFeedback{{Type: "nack"}, {Type: "nack", Parameter: "pli"}, {Type: webrtc.TypeRTCPFBTransportCC}},
	}, PayloadType: 96}
	keyFrames := make(chan struct{}, 8)
	source, err := NewSource(SourceOptions{ID: "screen", StreamID: "fixture", Codec: codec,
		Formats: []LayerFormat{{Width: 8, Height: 8, Bitrate: 300_000}, {Width: 16, Height: 16, Bitrate: 3_000_000}}, OnRTCP: func(_ int, packets []rtcp.Packet) {
			for _, packet := range packets {
				if _, ok := packet.(*rtcp.PictureLossIndication); ok {
					select {
					case keyFrames <- struct{}{}:
					default:
					}
				}
			}
		}})
	check(err)
	defer source.Close()
	check(source.BindLayer(0, 1000, webrtc.RTPParameters{Codecs: []webrtc.RTPCodecParameters{codec}}))
	// This checks feedback routing independently of the buffer's bootstrap-PLI throttle.
	source.buffers[0].SetPLIThrottle(0)
	settings := webrtc.SettingEngine{}
	settings.SetNetworkTypes([]webrtc.NetworkType{webrtc.NetworkTypeUDP4})
	settings.SetIncludeLoopbackCandidate(true)
	settings.SetIPFilter(func(ip net.IP) bool { return ip.IsLoopback() })
	audio, err := webrtc.NewTrackLocalStaticSample(webrtc.RTPCodecCapability{
		MimeType: webrtc.MimeTypeOpus, ClockRate: 48_000, Channels: 2,
	}, "audio", "fixture")
	check(err)
	demandWake := make(chan struct{}, 1)
	transport, err := NewTransport(TransportOptions{Source: source, Settings: settings,
		ConnectionID: "child", InitialBitrate: 1_000_000, Audio: audio, OnDemandChanged: func() {
			select {
			case demandWake <- struct{}{}:
			default:
			}
		}})
	check(err)
	defer transport.Close()
	transport.Output.SetMaxSpatialLayer(0)
	if state := transport.Output.State(); state.VideoBudget != 1_000_000 {
		t.Fatalf("audio changed the video capacity estimate: %+v", state)
	}
	if len(source.GetDownTracks()) != 0 {
		t.Fatal("unconnected transport claimed source output")
	}
	if transport.RequiredActiveCount() != 1 {
		t.Fatal("initial configured acquisition demand was lost")
	}
	mediaEngine := &webrtc.MediaEngine{}
	if repair {
		check(mediaEngine.RegisterDefaultCodecs())
	} else {
		check(mediaEngine.RegisterCodec(codec, webrtc.RTPCodecTypeVideo))
		check(mediaEngine.RegisterCodec(webrtc.RTPCodecParameters{
			RTPCodecCapability: audio.Codec(), PayloadType: 111,
		}, webrtc.RTPCodecTypeAudio))
	}
	registry := &interceptor.Registry{}
	reports := &receiverReportGate{}
	// Inner writer also gates NACKs emitted by the default generator itself.
	registry.Add(reports)
	check(webrtc.RegisterDefaultInterceptors(mediaEngine, registry))
	receiver, err := webrtc.NewAPI(webrtc.WithMediaEngine(mediaEngine), webrtc.WithInterceptorRegistry(registry),
		webrtc.WithSettingEngine(settings)).NewPeerConnection(webrtc.Configuration{})
	check(err)
	defer receiver.Close()
	var videoPackets, audioPackets atomic.Uint32
	firstVideo := make(chan *rtp.Packet, 1)
	paddingPackets := make(chan *rtp.Packet, 8)
	var recoveryTimestamp atomic.Uint32
	var missingSequence uint16
	var videoSSRC uint32
	recovered := make(chan bool, 1)
	var readers sync.WaitGroup
	receiver.OnTrack(func(track *webrtc.TrackRemote, _ *webrtc.RTPReceiver) {
		readers.Add(1)
		defer readers.Done()
		for {
			packet, attributes, readErr := track.ReadRTP()
			if readErr != nil {
				return
			}
			if packet.Padding {
				select {
				case paddingPackets <- packet:
				default:
				}
			}
			if len(packet.Payload) == 0 {
				continue
			}
			if track.Kind() == webrtc.RTPCodecTypeVideo {
				videoPackets.Add(1)
				select {
				case firstVideo <- packet:
				default:
				}
				if packet.Timestamp == recoveryTimestamp.Load() {
					select {
					case recovered <- attributes.Get(webrtc.AttributeRtxPayloadType) != nil:
					default:
					}
				}
			} else {
				audioPackets.Add(1)
			}
		}
	})
	offer, err := transport.PC.CreateOffer(nil)
	check(err)
	gather := webrtc.GatheringCompletePromise(transport.PC)
	check(transport.PC.SetLocalDescription(offer))
	select {
	case <-gather:
	case <-ctx.Done():
		t.Fatal(ctx.Err())
	}
	check(receiver.SetRemoteDescription(*transport.PC.LocalDescription()))
	answer, err := receiver.CreateAnswer(nil)
	check(err)
	gather = webrtc.GatheringCompletePromise(receiver)
	check(receiver.SetLocalDescription(answer))
	select {
	case <-gather:
	case <-ctx.Done():
		t.Fatal(ctx.Err())
	}
	check(transport.PC.SetRemoteDescription(*receiver.LocalDescription()))
	for transport.PC.ConnectionState() != webrtc.PeerConnectionStateConnected {
		select {
		case <-time.After(5 * time.Millisecond):
		case <-ctx.Done():
			t.Fatal(ctx.Err())
		}
	}
	check(transport.SetConnected())
	check(transport.SetConnected())
	if len(source.GetDownTracks()) != 1 {
		t.Fatal("connected transport attached twice")
	}
	packetizer := rtp.NewPacketizer(1200, 96, 1000, &codecs.VP8Payloader{EnablePictureID: true}, rtp.NewRandomSequencer(), 90_000)
	for _, packet := range packetizer.Packetize(sfu.VP8KeyFrame8x8, 3000) {
		check(source.WriteRTP(0, packet))
	}
	firstFrame := false
	for !firstFrame {
		select {
		case packet := <-firstVideo:
			firstFrame = true
			recoveryTimestamp.Store(packet.Timestamp + 3000)
			missingSequence, videoSSRC = packet.SequenceNumber+1, packet.SSRC
			for len(keyFrames) > 0 {
				<-keyFrames
			}
			check(receiver.WriteRTCP([]rtcp.Packet{&rtcp.PictureLossIndication{MediaSSRC: packet.SSRC}}))
		case <-time.After(time.Second / 30):
			for _, packet := range packetizer.Packetize(sfu.VP8KeyFrame8x8, 3000) {
				check(source.WriteRTP(0, packet))
			}
		case <-ctx.Done():
			t.Fatalf("missing first frame: %+v", transport.Output.State())
		}
	}
	select {
	case <-keyFrames:
	case <-time.After(time.Second):
		t.Fatalf("first-frame PLI never reached source; output=%+v statsPLI=%d", transport.Output.State(), transport.Output.GetTrackStats().Plis)
	}
	// Force one local loss, then delay its feedback beyond the receiver's stock
	// SRTP replay window. Repair must use its negotiated RTX sequence space.
	// A peer declining RTX still supports ordinary NACK within that window.
	transport.pacer.mu.Lock()
	transport.pacer.limit = 0
	transport.pacer.mu.Unlock()
	for _, packet := range packetizer.Packetize(sfu.VP8KeyFrame8x8, 3000) {
		check(source.WriteRTP(0, packet))
	}
	for transport.Egress().DroppedPackets == 0 {
		select {
		case <-time.After(5 * time.Millisecond):
		case <-ctx.Done():
			t.Fatal("local admission loss was not exercised")
		}
	}
	transport.pacer.mu.Lock()
	transport.pacer.limit = source.maxPackets
	transport.pacer.mu.Unlock()
	deltaFrame := append([]byte(nil), sfu.VP8KeyFrame8x8...)
	deltaFrame[0] |= 1
	laterPackets := 96
	if !repair {
		laterPackets = 16
	}
	for range laterPackets {
		before := videoPackets.Load()
		for _, packet := range packetizer.Packetize(deltaFrame, 3000) {
			check(source.WriteRTP(0, packet))
		}
		for videoPackets.Load() == before {
			select {
			case <-time.After(time.Millisecond):
			case <-ctx.Done():
				t.Fatal("media stopped while delaying loss feedback")
			}
		}
	}
	reports.allowNACK.Store(true)
	check(receiver.WriteRTCP([]rtcp.Packet{&rtcp.TransportLayerNack{
		MediaSSRC: videoSSRC, Nacks: []rtcp.NackPair{{PacketID: missingSequence}},
	}}))
	ticker := time.NewTicker(time.Second / 30)
	defer ticker.Stop()
	for repaired := false; !repaired; {
		select {
		case usedRTX := <-recovered:
			if usedRTX != repair {
				t.Fatalf("repair path disagrees with negotiation: RTX=%v", usedRTX)
			}
			repaired = true
		case <-ticker.C:
			// Pion checks its repair queue between primary reads. Keep the
			// live delta stream flowing without superseding the missing keyframe.
			for _, packet := range packetizer.Packetize(deltaFrame, 3000) {
				check(source.WriteRTP(0, packet))
			}
		case <-ctx.Done():
			t.Fatal("delayed local admission loss did not recover through library NACK")
		}
	}
	for {
		_, observed := transport.TargetBitrate()
		if videoPackets.Load() >= 15 && audioPackets.Load() >= 15 && observed {
			break
		}
		select {
		case <-ctx.Done():
			t.Fatalf("media or feedback missing: video=%d audio=%d observed=%v", videoPackets.Load(), audioPackets.Load(), observed)
		case <-ticker.C:
		}
		for _, packet := range packetizer.Packetize(sfu.VP8KeyFrame8x8, 3000) {
			check(source.WriteRTP(0, packet))
		}
		check(audio.WriteSample(media.Sample{Data: []byte{0xf8, 0xff, 0xfe}, Duration: 20 * time.Millisecond}))
	}
	if egress := transport.Egress(); egress.Packets < 15 || egress.RTPBytes == 0 || egress.DroppedPackets != 1 {
		t.Fatalf("paced local egress disagrees with receiving media: %+v", egress)
	}
	if len(demandWake) == 0 || transport.RequiredActiveCount() != 1 {
		t.Fatal("typed direct-child demand was not signaled")
	}
	// Raise subscribed demand without inventing an available layer. TWCC alone
	// cannot establish the RR readiness required by the library padding sender.
	transport.Output.DownTrack.SetMaxSpatialLayer(1)
	if delta, _ := transport.Output.probeDemand(); delta <= 0 {
		t.Fatal("no-RR fixture did not establish dormant upper demand")
	}
	transport.mediaActivity()
	transport.mu.Lock()
	ready := transport.paddingReady
	transport.mu.Unlock()
	if ready || transport.prober.IsRunning() {
		t.Fatal("transport probed before a receiver report")
	}
	// Exercise the library's real padding packet through Pion SRTP. Probe bytes
	// must be stripped by RTP decoding, not exposed to the video decoder as media.
	if transport.Output.WritePaddingRTP(255, true, false) == 0 {
		t.Fatal("padding fixture did not emit a probe")
	}
	select {
	case packet := <-paddingPackets:
		if len(packet.Payload) != 0 || packet.Header.PaddingSize == 0 {
			t.Fatalf("padding reached the receiver as video: payload=%d padding=%d", len(packet.Payload), packet.Header.PaddingSize)
		}
	case <-ctx.Done():
		t.Fatal("padding packet did not arrive")
	}
	// A stopped library writer returns zero padding bytes despite a connected PC
	// and valid RR. Its probe must finish, and inconclusive feedback must not
	// promote the BWE's internal initial-capacity sentinel into a codec budget.
	if !withdrawDemand {
		transport.Output.StopWriteAndGetState()
	}
	before, _ := transport.TargetBitrate()
	reports.allow.Store(true)
	seenProbe := false
	withdrawn := false
	for {
		transport.mediaActivity()
		transport.mu.Lock()
		active := transport.probe.Id != ccutils.ProbeClusterIdInvalid
		seenProbe = seenProbe || active
		if withdrawDemand && !withdrawn && active && transport.probe.Result.EndTime == 0 {
			// A live profile change can remove the unmet source demand without
			// replacing this transport or its current allocation.
			err := source.UpdateFormats([]LayerFormat{
				{Width: 8, Height: 8, Bitrate: 300_000}, {Width: 16, Height: 16, Bitrate: 600_000},
			})
			delta, _ := transport.Output.probeDemand()
			transport.driveProbeLocked()
			// Feedback may finalize the stopped probe in this same call, clearing
			// its identity and EndTime. Both retired states must stop sending.
			ended := !transport.prober.IsRunning() && (transport.probe.Id == ccutils.ProbeClusterIdInvalid ||
				transport.probe.Result.EndTime != 0)
			transport.mu.Unlock()
			check(err)
			if delta != 0 || !ended {
				t.Fatalf("withdrawn source demand retained a probe: demand=%d ended=%v", delta, ended)
			}
			withdrawn = true
			continue
		}
		transport.mu.Unlock()
		if seenProbe && !active && !transport.prober.IsRunning() {
			break
		}
		select {
		case <-time.After(5 * time.Millisecond):
		case <-ctx.Done():
			t.Fatal("probe did not retire within its library duration/settle bound")
		}
	}
	if after, _ := transport.TargetBitrate(); !withdrawDemand && after != before {
		t.Fatalf("zero-write probe manufactured a budget: before=%d after=%d", before, after)
	}
	if withdrawDemand && !withdrawn {
		t.Fatal("profile change did not exercise an active probe")
	}
	if withdrawn {
		beforePackets := videoPackets.Load()
		for videoPackets.Load() == beforePackets {
			for _, packet := range packetizer.Packetize(sfu.VP8KeyFrame8x8, 3000) {
				check(source.WriteRTP(0, packet))
			}
			select {
			case <-ticker.C:
			case <-ctx.Done():
				t.Fatal("withdrawing probe demand interrupted existing video")
			}
		}
	}
	check(transport.Close())
	check(transport.Close())
	check(receiver.Close())
	readers.Wait()
	if len(source.GetDownTracks()) != 0 || transport.SetConnected() == nil || transport.RequiredActiveCount() != 0 {
		t.Fatal("closed transport retained a source subscription")
	}
}

type receiverReportGate struct {
	interceptor.NoOp
	allow       atomic.Bool
	allowNACK   atomic.Bool
	reportDelay time.Duration
}

func (gate *receiverReportGate) NewInterceptor(string) (interceptor.Interceptor, error) {
	return gate, nil
}

func (gate *receiverReportGate) BindRTCPWriter(writer interceptor.RTCPWriter) interceptor.RTCPWriter {
	return interceptor.RTCPWriterFunc(func(packets []rtcp.Packet, attributes interceptor.Attributes) (int, error) {
		if gate.allow.Load() {
			for _, packet := range packets {
				if _, report := packet.(*rtcp.ReceiverReport); report {
					time.Sleep(gate.reportDelay)
					break
				}
			}
			return writer.Write(packets, attributes)
		}
		var filtered []rtcp.Packet
		for _, packet := range packets {
			if _, nack := packet.(*rtcp.TransportLayerNack); nack && !gate.allowNACK.Load() {
				continue
			}
			if _, report := packet.(*rtcp.ReceiverReport); !report {
				filtered = append(filtered, packet)
			}
		}
		if len(filtered) == 0 {
			return 0, nil
		}
		return writer.Write(filtered, attributes)
	})
}

type heldPacketPacer struct {
	packetpacer.Pacer
	packets []*packetpacer.Packet
}

func (held *heldPacketPacer) Enqueue(packet *packetpacer.Packet) {
	held.packets = append(held.packets, packet)
}

type countingPacketWriter struct{ bytes int }

func (writer *countingPacketWriter) WriteRTP(header *rtp.Header, payload []byte) (int, error) {
	written := header.MarshalSize() + len(payload) + int(header.PaddingSize)
	writer.bytes += written
	return written, nil
}

func (*countingPacketWriter) Write([]byte) (int, error) { panic("unexpected byte write") }

func TestTransportDoesNotPromoteUnverifiedCongestionCapacity(t *testing.T) {
	transport := &Transport{}
	transport.target.Store(1_200_000)
	// A pending probe can leave the framework's initial 100 Mbps estimate in
	// state-change callbacks. It is not proof that the connection can send it.
	transport.OnCongestionStateChange(bwe.CongestionStateNone, bwe.CongestionStateEarlyWarning, 100_000_000)
	transport.OnCongestionStateChange(bwe.CongestionStateEarlyWarning, bwe.CongestionStateCongested, 100_000_000)
	if bitrate, _ := transport.TargetBitrate(); bitrate != 1_200_000 {
		t.Fatalf("congestion promoted an unverified capacity: %d", bitrate)
	}
	transport.OnCongestionStateChange(bwe.CongestionStateCongested, bwe.CongestionStateCongested, 500_000)
	transport.OnCongestionStateChange(bwe.CongestionStateCongested, bwe.CongestionStateNone, 800_000)
	if bitrate, _ := transport.TargetBitrate(); bitrate != 500_000 {
		t.Fatalf("clearing congestion replaced the committed reduction without a probe: %d", bitrate)
	}
	// A recovery probe deliberately exceeds the current media allocation. Its
	// congestion, including late feedback while settling, cancels exploration
	// without cutting the already committed capacity (LiveKit's allocator rule).
	transport.probe = ccutils.ProbeClusterInfo{Id: 1}
	for _, ended := range []bool{false, true} {
		if ended {
			transport.probe.Result.EndTime = 1
		}
		transport.OnCongestionStateChange(bwe.CongestionStateNone, bwe.CongestionStateCongested, 250_000)
		if bitrate, _ := transport.TargetBitrate(); bitrate != 500_000 {
			t.Fatalf("probe congestion cut committed media capacity (settling=%v): %d", ended, bitrate)
		}
	}
	transport.probe = ccutils.ProbeClusterInfoInvalid
	transport.OnCongestionStateChange(bwe.CongestionStateCongested, bwe.CongestionStateCongested, 250_000)
	if bitrate, _ := transport.TargetBitrate(); bitrate != 250_000 {
		t.Fatalf("post-probe media congestion did not reduce capacity: %d", bitrate)
	}
}

type stalledPacketWriter struct {
	ready, release chan struct{}
	written        chan struct{}
	once           sync.Once
}

func (writer *stalledPacketWriter) WriteRTP(header *rtp.Header, payload []byte) (int, error) {
	writer.once.Do(func() { close(writer.ready); <-writer.release })
	writer.written <- struct{}{}
	return header.MarshalSize() + len(payload), nil
}

func (*stalledPacketWriter) Write([]byte) (int, error) { panic("unexpected byte write") }

func TestSendQueuesDrainAfterBandwidthReduction(t *testing.T) {
	for _, kind := range []string{"transport", "publication"} {
		t.Run(kind, func(t *testing.T) {
			codec := webrtc.RTPCodecParameters{RTPCodecCapability: webrtc.RTPCodecCapability{
				MimeType: webrtc.MimeTypeVP8, ClockRate: 90_000,
			}, PayloadType: 96}
			source, err := NewSource(SourceOptions{ID: "queue", StreamID: "queue", Codec: codec,
				Formats: []LayerFormat{{Width: 320, Height: 180, Bitrate: 500_000}}, MaxPackets: 500})
			if err != nil {
				t.Fatal(err)
			}
			defer source.Close()
			options := TransportOptions{Source: source, ConnectionID: "queue", InitialBitrate: 500_000}
			var queue *boundedPacer
			if kind == "publication" {
				publication, err := NewPublication(options)
				if err != nil {
					t.Fatal(err)
				}
				defer publication.Close()
				queue = publication.pacer.boundedPacer
			} else {
				transport, err := NewTransport(options)
				if err != nil {
					t.Fatal(err)
				}
				defer transport.Close()
				queue = transport.pacer
			}
			writer := &stalledPacketWriter{ready: make(chan struct{}), release: make(chan struct{}), written: make(chan struct{}, 32)}
			release := sync.OnceFunc(func() { close(writer.release) })
			defer release()
			for index := range 32 {
				header := &rtp.Header{Version: 2, SSRC: 1, SequenceNumber: uint16(index)}
				queue.Enqueue(&pacer.Packet{Header: header, HeaderSize: header.MarshalSize(),
					Payload: make([]byte, 1200), WriteStream: writer})
			}
			select {
			case <-writer.ready:
			case <-time.After(2 * time.Second):
				t.Fatal("transport did not reach the stalled writer")
			}
			// A short outage reduces the bandwidth estimate after these packets were
			// encoded. The recovered writer must not spend tens of seconds sending old
			// video before it can deliver a new frame.
			queue.SetBitrate(8_000)
			release()
			deadline := time.NewTimer(2 * time.Second)
			defer deadline.Stop()
			for range 32 {
				select {
				case <-writer.written:
				case <-deadline.C:
					t.Fatalf("writable transport retained old video: pending=%d sent=%d", queue.pendingCount(), queue.stats().Packets)
				}
			}
		})
	}
}

func TestBoundedPacerReleasesPacketsAndIsolatesBlockedQueue(t *testing.T) {
	log := logger.GetDiscardLogger()
	sender := packetpacer.NewPassThrough(log)
	held := &heldPacketPacer{Pacer: sender}
	queue := newBoundedPacer(held, log, 2)
	defer queue.Stop()
	healthy := newBoundedPacer(sender, log, 2)
	defer healthy.Stop()
	writer := &countingPacketWriter{}
	var originals []*pacer.Packet
	packet := func() *pacer.Packet {
		header := &rtp.Header{Version: 2, SSRC: 1}
		payload := make([]byte, 100)
		original := &pacer.Packet{Header: header, HeaderSize: header.MarshalSize(),
			HeaderPool: &sync.Pool{}, Pool: &sync.Pool{}, PoolEntity: &payload,
			Payload: payload, WriteStream: writer}
		originals = append(originals, original)
		return original
	}
	queue.Enqueue(packet())
	queue.Enqueue(packet())
	queue.Enqueue(packet())
	if len(queue.pending) != 2 || queue.stats().DroppedPackets != 1 || len(held.packets) != 2 {
		t.Fatalf("queue exceeded its bound: pending=%d stats=%+v", len(queue.pending), queue.stats())
	}
	healthy.Enqueue(packet())
	if healthy.stats().Packets != 1 || queue.stats().Packets != 0 {
		t.Fatal("held sibling blocked a ready packet")
	}
	sender.Enqueue(held.packets[0])
	queue.Enqueue(packet())
	queue.Stop()
	queue.Stop()
	queue.Enqueue(packet())
	// Upstream may still hold scheduling tickets when it stops. Visiting one
	// after cancellation must neither send nor return the original a second time.
	for _, proxy := range held.packets[1:] {
		sender.Enqueue(proxy)
	}
	if stats := queue.stats(); stats != (EgressStats{Packets: 1, RTPBytes: 112, DroppedPackets: 4}) {
		t.Fatalf("incorrect sent/drop accounting: %+v", stats)
	}
	for _, original := range originals {
		if original.Header != nil || original.Payload != nil || original.WriteStream != nil || original.PoolEntity != nil {
			t.Fatalf("send/Stop retained pooled packet ownership: %+v", original)
		}
	}
	if writer.bytes != 224 {
		t.Fatalf("canceled packets reached the writer: %d bytes", writer.bytes)
	}
}

func TestBoundedPacerCanceledProbesRetainAdmission(t *testing.T) {
	log := logger.GetDiscardLogger()
	sender := packetpacer.NewPassThrough(log)
	held := &heldPacketPacer{Pacer: sender}
	queue := newBoundedPacer(held, log, 2)
	defer queue.Stop()
	packet := func() *pacer.Packet {
		return &pacer.Packet{Header: &rtp.Header{Version: 2}, HeaderSize: 12,
			Payload: make([]byte, 100), WriteStream: &countingPacketWriter{}, IsProbe: true, ProbeClusterId: 1}
	}
	queue.Enqueue(packet())
	queue.Enqueue(packet())
	for range 10 {
		queue.cancelProbes(1)
		queue.Enqueue(packet())
	}
	if len(queue.pending) != 2 || len(held.packets) != 2 || queue.stats().DroppedPackets != 12 {
		t.Fatalf("canceled proxies freed admission before dequeue: pending=%d queued=%d stats=%+v",
			len(queue.pending), len(held.packets), queue.stats())
	}
	sender.Enqueue(held.packets[0])
	queue.Enqueue(packet())
	if len(queue.pending) != 2 || len(held.packets) != 3 {
		t.Fatal("actual dequeue did not return its admission slot")
	}
	queue.Stop()
	for _, proxy := range held.packets[1:] {
		sender.Enqueue(proxy)
	}
	if stats := queue.stats(); stats.Packets != 0 || stats.DroppedPackets != 13 {
		t.Fatalf("canceled ownership was sent or retired twice: %+v", stats)
	}
}

func TestBoundedPacerAccountsForPaddingExactlyOnce(t *testing.T) {
	for _, sizes := range []struct{ payload, padding int }{{100, 0}, {0, 255}, {20, 16}} {
		log := logger.GetDiscardLogger()
		sender := packetpacer.NewPassThrough(log)
		held := &heldPacketPacer{Pacer: sender}
		queue := newBoundedPacer(held, log, 1)
		defer queue.Stop()
		header := &rtp.Header{Version: 2, SSRC: 1, Padding: sizes.padding > 0, PaddingSize: byte(sizes.padding)}
		writer := &countingPacketWriter{}
		want := header.MarshalSize() + sizes.payload + sizes.padding
		queue.Enqueue(&pacer.Packet{Header: header, HeaderSize: header.MarshalSize(),
			Payload: make([]byte, sizes.payload), WriteStream: writer})
		proxy := held.packets[0]
		if scheduled := proxy.Header.MarshalSize() + len(proxy.Payload); scheduled != want {
			t.Fatalf("scheduled %d bytes for a %d-byte RTP packet: %+v", scheduled, want, sizes)
		}
		sender.Enqueue(proxy)
		queue.Stop()
		if writer.bytes != want || queue.stats().RTPBytes != uint64(want) || queue.pendingCount() != 0 {
			t.Fatalf("padding was serialized or counted twice: written=%d stats=%+v want=%d", writer.bytes, queue.stats(), want)
		}
	}
}

func BenchmarkBoundedPacerAdmission(b *testing.B) {
	log := logger.GetDiscardLogger()
	for _, bounded := range []bool{false, true} {
		name := "pass-through"
		if bounded {
			name = "bounded-admission"
		}
		b.Run(name, func(b *testing.B) {
			var queue pacer.Pacer = pacer.NewPassThrough(log, nil)
			if bounded {
				queue = newBoundedPacer(packetpacer.NewPassThrough(log), log, 500)
			}
			defer queue.Stop()
			writer := &countingPacketWriter{}
			header := &rtp.Header{Version: 2, SSRC: 1}
			payload := make([]byte, 1200)
			b.ReportAllocs()
			b.ResetTimer()
			for b.Loop() {
				packet := pacer.PacketFactory.Get().(*pacer.Packet)
				*packet = pacer.Packet{Header: header, HeaderSize: header.MarshalSize(), Payload: payload, WriteStream: writer}
				queue.Enqueue(packet)
			}
		})
	}
}