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. 免费开源的私密屏幕共享,支持游戏直播、一起看电影与自部署。

14.0 KB
Raw Blame
package forwarding

import (
	"testing"
	"time"

	"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/pacer"
	"github.com/livekit/protocol/livekit"
	"github.com/livekit/protocol/logger"
	"github.com/pion/webrtc/v4"
)

// This fixture supplies allocation metadata, not simulated network evidence.
type allocationReceiver struct {
	*sfu.ReceiverBase
	rates      sfu.Bitrates
	available  []int32
	controlled bool
}

func (receiver *allocationReceiver) RateControlled(layer int32) bool {
	return receiver.controlled && layer == 0
}

func (receiver *allocationReceiver) GetLayeredBitrate() ([]int32, sfu.Bitrates) {
	return receiver.available, receiver.rates
}

type outputListener struct{}

func (*outputListener) OnBindAndConnected()                         {}
func (*outputListener) OnStatsUpdate(*livekit.AnalyticsStat)        {}
func (*outputListener) OnMaxSubscribedLayerChanged(int32)           {}
func (*outputListener) OnRttUpdate(uint32)                          {}
func (*outputListener) OnCodecNegotiated(webrtc.RTPCodecCapability) {}
func (*outputListener) OnDownTrackClose(bool)                       {}
func (*outputListener) OnStreamStarted(time.Duration)               {}

func TestOutputUsesLibraryAllocationAndExactLifetime(t *testing.T) {
	codec := webrtc.RTPCodecParameters{RTPCodecCapability: webrtc.RTPCodecCapability{
		MimeType: webrtc.MimeTypeVP8, ClockRate: 90_000,
	}, PayloadType: 96}
	log := logger.GetLogger()
	base := sfu.NewReceiverBase(sfu.ReceiverBaseParams{
		TrackID: "fixture", StreamID: "fixture", Kind: webrtc.RTPCodecTypeVideo,
		Codec: codec, Logger: log, StreamTrackerManagerConfig: sfu.DefaultStreamTrackerManagerConfig,
	}, &livekit.TrackInfo{Sid: "fixture", Type: livekit.TrackType_VIDEO,
		Source: livekit.TrackSource_SCREEN_SHARE, Layers: []*livekit.VideoLayer{
			{SpatialLayer: 0, Bitrate: 100_000}, {SpatialLayer: 1, Bitrate: 300_000},
			{SpatialLayer: 2, Bitrate: 900_000},
		}}, sfu.ReceiverCodecStateNormal)
	defer base.Close("test complete", true)
	receiver := &allocationReceiver{ReceiverBase: base}
	packetPacer := pacer.NewPassThrough(log, nil)
	defer packetPacer.Stop()
	track, err := sfu.NewDownTrack(sfu.DownTrackParams{
		Codecs: []webrtc.RTPCodecParameters{codec}, Receiver: receiver,
		BufferFactory: buffer.NewFactoryOfBufferFactory(64, 16).CreateBufferFactory(),
		SubID:         "child", StreamID: "fixture", MaxTrack: 64,
		Pacer: packetPacer, Logger: log, Listener: &outputListener{},
	})
	if err != nil {
		t.Fatal(err)
	}
	output := NewOutput(track, 1_000_000)
	defer output.Close()
	output.SetMaxSpatialLayer(2)
	output.SetMaxTemporalLayer(0)
	if state := output.State(); state.Target != -1 || state.Current != -1 {
		t.Fatalf("unmeasured source pretended to have a target: %+v", state)
	}
	// LiveKit publishes layer discovery asynchronously. Availability can arrive
	// first; allocation must use that observation without waiting for its notice.
	receiver.available = []int32{0}
	output.UpTrackLayersChange()
	if state := output.State(); state.Target != 0 || state.Paused {
		t.Fatalf("available source waited for its discovery notification: %+v", state)
	}
	output.UpTrackMaxPublishedLayerChange(2)
	output.UpTrackMaxTemporalLayerSeenChange(0)
	output.SetBudget(0)
	if state := output.State(); !state.Paused || state.Prepare != -1 || state.VideoBudget != 0 {
		t.Fatalf("bootstrap ignored an exhausted video budget: %+v", state)
	}
	receiver.rates = sfu.Bitrates{{100_000}, {300_000}, {900_000}}
	receiver.available = []int32{0, 1, 2}
	siblingTrack, err := sfu.NewDownTrack(sfu.DownTrackParams{
		Codecs: []webrtc.RTPCodecParameters{codec}, Receiver: receiver,
		BufferFactory: buffer.NewFactoryOfBufferFactory(64, 16).CreateBufferFactory(),
		SubID:         "healthy", StreamID: "fixture", MaxTrack: 64,
		Pacer: packetPacer, Logger: log, Listener: &outputListener{},
	})
	if err != nil {
		t.Fatal(err)
	}
	sibling := NewOutput(siblingTrack, 1_000_000)
	defer sibling.Close()
	sibling.SetMaxTemporalLayer(0)
	sibling.SetMaxSpatialLayer(2)
	sibling.UpTrackMaxPublishedLayerChange(2)
	sibling.UpTrackMaxTemporalLayerSeenChange(0)
	for _, check := range []struct {
		budget int64
		layer  int32
	}{{1_000_000, 2}, {200_000, 0}, {0, -1}, {400_000, 1}, {1_000_000, 2}} {
		output.SetBudget(check.budget)
		state := output.State()
		if state.Target != check.layer || state.Paused != (check.layer == -1) || state.Current != -1 || state.VideoBudget != check.budget {
			t.Fatalf("budget %d: %+v", check.budget, state)
		}
	}
	// A budget below every nominal output still reaches the lowest codec, while
	// only actual reduced media may make the library resume its network target.
	output.SetBudget(60_000)
	if state := output.State(); !state.Paused || state.Target != -1 || state.Prepare != 0 || state.VideoBudget != 60_000 {
		t.Fatalf("below-lowest budget cannot request codec adaptation: %+v", state)
	}
	// A new child's seed cannot veto a warm source's first video. Receiving
	// feedback alone is not congestion; a committed reduction constrains it again.
	observed := false
	output.feedbackObserved = func() bool { return observed }
	output.Reconcile()
	if state := output.State(); state.Paused || state.Target < 0 {
		t.Fatalf("warm source could not establish first feedback: %+v", state)
	}
	observed = true
	output.Reconcile()
	if state := output.State(); state.Paused {
		t.Fatalf("first feedback reinterpreted the seed as a capacity reduction: %+v", state)
	}
	output.SetBudget(50_000)
	if state := output.State(); !state.Paused {
		t.Fatalf("bootstrap bypassed a committed capacity reduction: %+v", state)
	}
	output.SetBudget(60_000)
	receiver.controlled = true
	output.Reconcile()
	if state := output.State(); state.Paused || state.Target != 0 {
		t.Fatalf("live lowest codec could not continue bitrate adaptation: %+v", state)
	}
	// An adapting encoder can be constrained inside its current logical layer.
	// Restore that layer's own ceiling before probing a higher spatial output,
	// including when there is no higher output at all.
	receiver.rates[0][0] = 50_000
	output.Reconcile()
	for _, maximum := range []int32{2, 0} {
		output.SetMaxSpatialLayer(maximum)
		if delta, usage := output.probeDemand(); delta != 50_000 || usage != 50_000 {
			t.Fatalf("current codec recovery skipped (maximum=%d): delta=%d usage=%d", maximum, delta, usage)
		}
		if !output.BandwidthLimited() {
			t.Fatalf("same-layer encoder restriction was reported as healthy (maximum=%d)", maximum)
		}
	}
	output.SetBudget(100_000)
	if delta, _ := output.probeDemand(); delta != 0 {
		t.Fatalf("satisfied codec ceiling retained probe demand: %d", delta)
	}
	if output.BandwidthLimited() {
		t.Fatal("satisfied codec ceiling retained a bandwidth restriction")
	}
	receiver.controlled = false
	output.SetBudget(60_000)
	if delta, _ := output.probeDemand(); delta != 0 {
		t.Fatalf("raw forwarding invented same-layer codec demand: %d", delta)
	}
	if output.BandwidthLimited() {
		t.Fatal("raw forwarding invented a local encoder restriction")
	}
	receiver.controlled = true
	output.SetMaxSpatialLayer(2)
	receiver.rates[0][0] = 100_000
	output.SetBudget(0)
	if state := output.State(); !state.Paused {
		t.Fatalf("codec control overrode exhausted connection budget: %+v", state)
	}
	receiver.available = []int32{1, 2}
	receiver.rates[0][0] = 0
	output.SetBudget(60_000)
	if state := output.State(); !state.Paused {
		t.Fatalf("codec control selected an unavailable lowest layer: %+v", state)
	}
	receiver.available = []int32{0, 1, 2}
	receiver.controlled = false
	receiver.rates[0][0] = 50_000
	output.Reconcile()
	if state := output.State(); state.Paused || state.Target != 0 || state.VideoBudget != 60_000 {
		t.Fatalf("real reduced output did not resume library allocation: %+v", state)
	}
	sibling.Reconcile()
	if state := sibling.State(); state.Paused || state.Target != 2 || state.VideoBudget != 1_000_000 || receiver.rates[2][0] != 900_000 {
		t.Fatalf("weak-child adaptation changed the shared high output: %+v", state)
	}
	// Frame complexity and RTP overhead can briefly exceed a nominal ceiling.
	// A source measurement is not new evidence that this connection lost capacity.
	// The layers' measurement windows can also become available independently.
	receiver.rates[2][0] = 0
	sibling.UpTrackBitrateAvailabilityChange()
	if state := sibling.State(); state.Target != 2 {
		t.Fatalf("unmeasured active layer was treated as unavailable: %+v", state)
	}
	receiver.rates[2][0] = 1_050_000
	sibling.UpTrackBitrateReport(receiver.available, receiver.rates)
	sibling.SetBudget(1_000_000)
	if state := sibling.State(); state.Target != 2 || state.VideoBudget != 1_000_000 {
		t.Fatalf("unchanged connection budget downgraded a healthy output: %+v", state)
	}
	sibling.SetBudget(1_020_000)
	if state := sibling.State(); state.Target != 2 {
		t.Fatalf("increased capacity downgraded an existing output: %+v", state)
	}
	sibling.SetBudget(800_000)
	if state := sibling.State(); state.Target != 1 {
		t.Fatalf("actual capacity reduction failed to constrain the output: %+v", state)
	}
	receiver.rates[1][0] = 850_000
	sibling.UpTrackBitrateReport(receiver.available, receiver.rates)
	sibling.SetBudget(800_000)
	if state := sibling.State(); state.Target != 1 {
		t.Fatalf("measured variation downgraded an already constrained output: %+v", state)
	}
	sibling.congestionState = func() bwe.CongestionState { return bwe.CongestionStateCongested }
	sibling.Reconcile()
	if state := sibling.State(); state.Target != 0 {
		t.Errorf("confirmed congestion retained an output above the unchanged budget: %+v", state)
	}
	sibling.congestionState = nil

	// A recovered low layer does not authorize an unmeasured high layer.
	receiver.rates = sfu.Bitrates{{50_000}, {0}, {0}}
	receiver.available = []int32{0}
	sibling.SetBudget(60_000)
	if state := sibling.State(); state.Target != 0 {
		t.Fatalf("recovery did not select the measured affordable layer: %+v", state)
	}
	receiver.available = []int32{0, 1, 2}
	sibling.Reconcile()
	if state := sibling.State(); state.Target != 0 {
		t.Errorf("a resumed unmeasured layer bypassed the connection budget: %+v", state)
	}
	receiver.rates[1][0] = 300_000
	receiver.rates[2][0] = 900_000
	sibling.SetBudget(1_000_000)
	if state := sibling.State(); state.Target != 2 {
		t.Fatalf("increased capacity did not restore the high output: %+v", state)
	}
	// Missing rate windows retain a legal target, but cannot override source
	// availability or subscription limits. The connection budget stays unchanged.
	receiver.rates = sfu.Bitrates{}
	sibling.Reconcile()
	if state := sibling.State(); state.Target != 2 || state.VideoBudget != 1_000_000 {
		t.Fatalf("missing rate windows changed a legal allocation: %+v", state)
	}
	receiver.available = []int32{0}
	sibling.UpTrackLayersChange()
	if state := sibling.State(); state.Target > 0 || state.VideoBudget != 1_000_000 {
		t.Fatalf("missing rate windows retained an unavailable target: %+v", state)
	}
	receiver.available = []int32{0, 1, 2}
	receiver.rates = sfu.Bitrates{{50_000}, {300_000}, {900_000}}
	sibling.Reconcile()
	if state := sibling.State(); state.Target != 2 {
		t.Fatalf("restored source did not resume before subscription change: %+v", state)
	}
	receiver.rates = sfu.Bitrates{}
	sibling.SetMaxSpatialLayer(0)
	if state := sibling.State(); state.Target > 0 || state.VideoBudget != 1_000_000 {
		t.Fatalf("missing rate windows retained a target above the subscription: %+v", state)
	}
	receiver.rates = sfu.Bitrates{{50_000}, {300_000}, {900_000}}
	sibling.Reconcile()
	if state := sibling.State(); state.Target != 0 {
		t.Fatalf("stable allocation ignored a changed subscription limit: %+v", state)
	}
	receiver.rates[0][0] = 100_000
	// A stopped upper output has no actual bitrate. Admission may prepare it,
	// but the library must not select it until it is genuinely available again.
	receiver.rates = sfu.Bitrates{{100_000}}
	receiver.available = []int32{0}
	output.SetBudget(1_000_000)
	if state := output.State(); state.Prepare != 2 || state.Target != 0 {
		t.Fatalf("stopped output preparation changed real availability: %+v", state)
	}
	output.SetBudget(200_000)
	if state := output.State(); state.Prepare != 0 || state.Target != 0 {
		t.Fatalf("low budget prepared an unaffordable upper output: %+v", state)
	}
	output.SetMaxSpatialLayer(1)
	output.SetBudget(1_000_000)
	if state := output.State(); state.Prepare != 1 {
		t.Fatalf("preparation exceeded child maximum: %+v", state)
	}
	output.SetMaxSpatialLayer(2)
	// Allocation-only fixture: put the accepted frame on a different layer so
	// BeginFrame must fence it. The real RTP gate verifies emitted frames.
	output.current = (output.State().Target + 1) % 3
	before := output.State()
	output.BeginFrame()
	after := output.State()
	if after.Current != -1 || after.Target != before.Target || after.Requested != before.Requested {
		t.Fatalf("controlled frame fence replaced its allocation: before=%+v after=%+v", before, after)
	}
	output.SetBudget(200_000)
	output.Resync()
	if state := output.State(); state.Target != -1 || state.Current != -1 {
		t.Fatalf("source resync retained old output state: %+v", state)
	}
	output.Reconcile()
	if state := output.State(); state.Target != 0 || state.VideoBudget != 200_000 {
		t.Fatalf("source resync discarded the established connection budget: %+v", state)
	}
	receiver.available = []int32{0, 1, 2}
	receiver.rates = sfu.Bitrates{{100_000}, {300_000}, {900_000}}
	sibling.SetMaxSpatialLayer(2)
	if state := sibling.State(); state.Target != 2 {
		t.Fatalf("high layer did not resume before source resync: %+v", state)
	}
	sibling.Resync()
	receiver.rates = sfu.Bitrates{{100_000}}
	sibling.Reconcile()
	if state := sibling.State(); state.Target != 0 {
		t.Fatalf("source resync reused an unmeasured retired allocation: %+v", state)
	}
	output.SetBudget(1_000_000)
	output.ReceiverRestart(receiver)
	if state := output.State(); state.Current != -1 {
		t.Fatalf("receiver restart retained old output state: %+v", state)
	}
	output.Close()
	output.SetBudget(1_000_000)
	if state := output.State(); state != (Snapshot{Prepare: -1, Target: -1, Requested: -1, Current: -1, Paused: true}) {
		t.Fatalf("closed output revived: %+v", state)
	}
}