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

17.1 KB
Raw Blame
package mediaedge

import (
	"context"
	"encoding/binary"
	"errors"
	"fmt"
	"io"
	"slices"
	"testing"
	"time"

	"github.com/TNTcraftHIM/Piik/internal/app/nativecapture"
	"github.com/TNTcraftHIM/Piik/internal/media/encoded"
	"github.com/TNTcraftHIM/Piik/internal/media/forwarding"
	"github.com/livekit/livekit-server/pkg/sfu"
	"github.com/livekit/livekit-server/pkg/sfu/streamtracker"
	"github.com/pion/rtcp"
	"github.com/pion/rtp"
	"github.com/pion/webrtc/v4"
	"google.golang.org/protobuf/proto"
)

func TestSourceRecoveryCoalescesTargetsWithoutWakingUnrelatedOutputs(t *testing.T) {
	for _, all := range []bool{false, true} {
		t.Run(fmt.Sprint(all), func(t *testing.T) {
			requested := make(chan []int, 8)
			// Queue several requests before starting the existing notification worker.
			source := &Source{engine: &Engine{}, requestKeyFrame: func(layers []int) { requested <- layers },
				recoveryRequests: make(chan struct{}, 1), recoveryStopped: make(chan struct{})}
			source.requestLayerKeyFrame(0)
			source.requestLayerKeyFrame(2)
			source.requestLayerKeyFrame(0)
			if all {
				source.RequestRecoveryFrame()
			}
			done := make(chan struct{})
			go func() { defer close(done); source.runRecovery() }()
			defer func() { close(source.recoveryStopped); <-done }()
			want := []int{0, 2}
			if all {
				want = []int{-1}
			}
			select {
			case layers := <-requested:
				if !slices.Equal(layers, want) {
					t.Fatalf("requested outputs %v instead of %v", layers, want)
				}
			case <-time.After(time.Second):
				t.Fatal("lost output recovery request")
			}
			if source.groupRecovery.Load() != 0 {
				t.Fatal("direct capture queued a second recovery through the frame plan")
			}
			select {
			case layers := <-requested:
				t.Fatalf("unexpected extra callback: %v", layers)
			default:
			}
		})
	}
}

func TestSingleRenditionFollowsSharedRemoteBudget(t *testing.T) {
	engine, err := NewEngine(EngineOptions{BindAddress: "127.0.0.1:0", IncludeLoopback: true, InitialBitrate: 200_000})
	if err != nil {
		t.Fatal(err)
	}
	defer engine.Close()
	source, err := engine.NewSource("vp8", 2, 1, nil)
	if err != nil {
		t.Fatal(err)
	}
	defer source.Close()
	check := func(err error) {
		t.Helper()
		if err != nil {
			t.Fatal(err)
		}
	}
	check(source.SetFormat(0, 640, 360))
	check(source.ConfigureOutputs([]uint32{1_000_000}))
	source.SetLowestLayerRateControlled(true)
	var pts time.Duration
	plan := func(label string, active bool, bitrate uint32) {
		t.Helper()
		value, err := source.BeginFrame(pts)
		check(err)
		pts += time.Second / 30
		if len(value.Active) != 1 || value.Active[0] != active || len(value.Bitrates) != 1 || value.Bitrates[0] != bitrate {
			t.Fatalf("%s: plan = %+v, want active=%t bitrate=%d", label, value, active, bitrate)
		}
	}
	plan("no consumers", false, 1_000_000)
	preview, err := engine.NewEdge(source, EdgeOptions{ConnectionID: "preview", Local: true})
	check(err)
	previewReceiver := newReceiver(t)
	defer previewReceiver.Close()
	ctx, cancel := context.WithTimeout(t.Context(), 5*time.Second)
	defer cancel()
	offer, err := preview.CreateLocalOffer(ctx, "preview-offer", false)
	check(err)
	check(previewReceiver.SetRemoteDescription(offer))
	answer, err := previewReceiver.CreateAnswer(nil)
	check(err)
	gathered := webrtc.GatheringCompletePromise(previewReceiver)
	check(previewReceiver.SetLocalDescription(answer))
	waitSignal(t, gathered, "preview ICE gathering")
	check(preview.SetAnswer(*previewReceiver.LocalDescription(), "preview-offer"))
	for preview.State() != webrtc.PeerConnectionStateConnected {
		select {
		case <-ctx.Done():
			t.Fatal("preview did not connect")
		case <-time.After(10 * time.Millisecond):
		}
	}
	plan("preview alone", true, 1_000_000)
	weak, weakReceiver, _ := connectedReceiver(t, engine, source, "weak")
	defer weakReceiver.Close()
	weak.transport.OnTransportCCFeedback(nil, &rtcp.TransportLayerCC{})
	weak.transport.Output.SetBudget(100_000)
	plan("preview does not mask weak child", true, 100_000)
	healthy, healthyReceiver, _ := connectedReceiver(t, engine, source, "healthy")
	defer healthyReceiver.Close()
	healthy.transport.OnTransportCCFeedback(nil, &rtcp.TransportLayerCC{})
	healthy.transport.Output.SetBudget(700_000)
	plan("weak child does not lower healthy sibling", true, 700_000)
	healthy.transport.Output.SetBudget(0)
	plan("parked sibling", true, 100_000)
	healthy.transport.Output.SetBudget(900_000)
	plan("reactivated sibling", true, 900_000)
	check(healthy.Close())
	plan("retired sibling", true, 100_000)
	check(weak.Close())
	plan("preview remains", true, 1_000_000)
	check(preview.Close())
	plan("all consumers retired", false, 1_000_000)

	publication, err := engine.NewPublication(source, EdgeOptions{ConnectionID: "single-publication"})
	check(err)
	check(publication.transport.SetConnected())
	plan("SFU upload budget", true, 200_000)
	check(publication.SetActiveCount(0))
	plan("SFU upload parked", false, 1_000_000)
	check(publication.SetActiveCount(1))
	plan("SFU upload reactivated", true, 200_000)
	check(source.ConfigureOutputs([]uint32{150_000}))
	source.BeginGeneration()
	pts = 0
	plan("new generation ceiling", true, 150_000)
	check(publication.Close())
	plan("publication retired", false, 150_000)
}

func TestSourceStartupFeedbackRequestsRecovery(t *testing.T) {
	for _, relay := range []*RelayOptions{nil, {}} {
		t.Run(fmt.Sprintf("relay-%t", relay != nil), func(t *testing.T) {
			requested := make(chan []int, 4)
			source, err := (&Engine{}).newSource("vp8", 2, 2, relay, func(layers []int) {
				select {
				case requested <- layers:
				default:
				}
			})
			if err != nil {
				t.Fatal(err)
			}
			defer source.Close()
			// LiveKit can request startup keyframes as soon as its buffers are bound.
			// Wait for that real asynchronous callback, without manually sending PLI.
			select {
			case layers := <-requested:
				if len(layers) == 0 {
					t.Fatal("startup recovery has no output identity")
				}
				if (source.groupRecovery.Load() != 0) != (relay != nil) {
					t.Fatal("startup recovery used the wrong capture/relay owner")
				}
			case <-time.After(3 * time.Second):
				t.Fatal("startup feedback lost its recovery notification")
			}
		})
	}
}

func TestSourceRecoveryRetainsLocalPlanWithoutDirectCaptureCallback(t *testing.T) {
	for _, relay := range []bool{false, true} {
		t.Run(fmt.Sprint(relay), func(t *testing.T) {
			source := &Source{}
			if relay {
				source.relay = &relayDerivation{source: source}
				source.requestKeyFrame = func([]int) {}
				source.recoveryRequests = make(chan struct{}, 1)
			}
			source.requestLayerKeyFrame(0)
			source.requestLayerKeyFrame(2)
			if source.groupRecovery.Load() != 5 {
				t.Fatal("local recovery was lost when the callback cannot reach its encoders")
			}
			if relay && source.pendingRecovery.Load() != 5 {
				t.Fatal("relay recovery did not also request its upstream input")
			}
			source.RequestRecoveryFrame()
			if source.groupRecovery.Load() != 5 || relay && source.pendingRecovery.Load() != allRecoveryLayers {
				t.Fatal("upstream wake widened or lost the local recovery targets")
			}
		})
	}
}

func TestSourcePLIUsesPhysicalOutputIdentity(t *testing.T) {
	requested := make(chan []int, 16)
	source, err := (&Engine{}).NewSource("vp8", 2, 2, func(layers []int) { requested <- layers })
	if err != nil {
		t.Fatal(err)
	}
	defer source.Close()
	if err = source.ConfigureOutputs([]uint32{300_000, 1_200_000, 300_000}); err != nil {
		t.Fatal(err)
	}
	if _, err = source.planGroups(nil); err != nil {
		t.Fatal(err)
	}
	group, err := source.newGroup(2)
	if err != nil {
		t.Fatal(err)
	}
	for _, media := range []*forwarding.EncodedSource{source.media, group.media} {
		if err = media.BeginFrame(time.Second, time.Now()); err != nil {
			t.Fatal(err)
		}
		for layer := range 2 {
			if err = media.WriteFrame(layer, encoded.Frame{Data: sfu.VP8KeyFrame8x8, PTS: time.Second,
				Duration: time.Second / 30, Recovery: true}); err != nil {
				t.Fatal(err)
			}
		}
	}
	for _, request := range []struct {
		media           *forwarding.EncodedSource
		layer, physical int
	}{
		{source.media, 0, 0}, {source.media, 1, 1}, {group.media, 0, 2}, {group.media, 1, 1},
	} {
		request.media.SendPLI(int32(request.layer), true)
		select {
		case layers := <-requested:
			if !slices.Equal(layers, []int{request.physical}) {
				t.Fatalf("logical %d requested physical %v, want %d", request.layer, layers, request.physical)
			}
		case <-time.After(time.Second):
			t.Fatal("PLI did not wake its output")
		}
		if source.groupRecovery.Load() != 0 {
			t.Fatal("forwarded PLI would request the direct capture output twice")
		}
	}
}

func TestSourceFrameSurvivesRetiringEdge(t *testing.T) {
	for _, layers := range []int{1, 2} {
		t.Run(fmt.Sprint(layers), func(t *testing.T) {
			engine, err := NewEngine(EngineOptions{BindAddress: "127.0.0.1:0", IncludeLoopback: true})
			if err != nil {
				t.Fatal(err)
			}
			t.Cleanup(func() { _ = engine.Close() })
			source, err := engine.NewSource("vp8", 2, layers, nil)
			if err != nil {
				t.Fatal(err)
			}
			t.Cleanup(func() { _ = source.Close() })
			if err = source.ConfigureOutputs([]uint32{300_000, 1_200_000}[:layers]); err != nil {
				t.Fatal(err)
			}
			healthy, _, packets := connectedReceiver(t, engine, source, "healthy")
			observed, _, _ := connectedReceiver(t, engine, source, "retiring-observation")
			retired, err := forwarding.NewTransport(forwarding.TransportOptions{
				Source: source.media.Source, ConnectionID: "retiring", InitialBitrate: 1_200_000,
			})
			if err != nil {
				t.Fatal(err)
			}
			if err = retired.Close(); err != nil {
				t.Fatal(err)
			}
			// Model the interleaving after observing connected but before attachment:
			// the transport has closed, while the source still holds the edge snapshot.
			// Borrow an independently live PC for that observation; no running edge is mutated.
			stale := &Edge{engine: engine, source: source, connection: observed.connection, transport: retired}
			source.mu.Lock()
			delete(source.edges, observed)
			source.edges[stale] = false
			source.mu.Unlock()
			for i := 0; i < 3; i++ {
				pts := time.Duration(i) * time.Second / 30
				if _, err = source.BeginFrame(pts); err != nil {
					t.Fatalf("edge close stopped source: %v", err)
				}
				if err = source.WriteVideo(layers-1, encoded.Frame{Data: sfu.VP8KeyFrame8x8, PTS: pts, Duration: time.Second / 30, Recovery: true}); err != nil {
					t.Fatal(err)
				}
			}
			if !stale.closed || healthy.State() != webrtc.PeerConnectionStateConnected {
				t.Fatal("retirement did not isolate the failed edge")
			}
			select {
			case <-packets:
			case <-time.After(5 * time.Second):
				t.Fatal("healthy sibling lost media")
			}
			if err = source.Close(); err != nil {
				t.Fatal(err)
			}
			if _, err = source.BeginFrame(time.Second); !errors.Is(err, io.ErrClosedPipe) {
				t.Fatalf("actual source closure was hidden: %v", err)
			}
		})
	}
}

func TestSourceFormatAdaptationPreservesLiveLayers(t *testing.T) {
	// A source needs no socket or codec process to exercise its RTP state.
	source, err := (&Engine{}).NewSource("vp8", 2, 2, nil)
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = source.Close() })
	check := func(err error) {
		t.Helper()
		if err != nil {
			t.Fatal(err)
		}
	}
	check(source.SetFormat(0, 640, 360))
	check(source.SetFormat(1, 1280, 720))
	check(source.ConfigureOutputs([]uint32{300_000, 1_200_000}))
	check(source.media.UpdateDimensions(0, 320, 180))
	check(source.SetFormat(0, 640, 360))
	if source.media.TrackInfo().Layers[0].Width != 640 {
		t.Fatal("unchanged actual dimensions did not replace stale metadata")
	}
	initialInfo := source.media.TrackInfo()
	buffers := source.media.GetAllBuffers()
	trackers := source.media.StreamTrackerManager()
	const period = time.Second / 25
	var pts time.Duration
	write := func() {
		t.Helper()
		// This check owns input explicitly; no consumer is present to request
		// codec activation through the separate demand planner.
		check(source.beginGroupFrame(pts, time.Now()))
		for layer := range 2 {
			check(source.WriteVideo(layer, encoded.Frame{Data: sfu.VP8KeyFrame8x8, PTS: pts, Duration: period, Recovery: true}))
		}
		pts += period
	}
	ticker := time.NewTicker(period)
	defer ticker.Stop()
	deadline := time.NewTimer(6 * time.Second)
	defer deadline.Stop()
	for {
		select {
		case <-ticker.C:
		case <-deadline.C:
			t.Fatal("live layers produced no measured bitrate")
		}
		write()
		_, rates := source.media.GetLayeredBitrate()
		if rates[0][0] > 0 && rates[1][0] > 0 {
			break
		}
	}
	want := source.media.TrackInfo()
	for _, width := range []uint32{320, 320, 640} {
		before := source.media.TrackInfo()
		clock := buffers[0].GetSenderReportData()
		check(source.SetFormat(0, width, width*9/16))
		want.Layers[0].Width, want.Layers[0].Height = width, width*9/16
		want.Codecs[0].Layers[0].Width, want.Codecs[0].Layers[0].Height = width, width*9/16
		if !proto.Equal(source.media.TrackInfo(), want) || source.formats[0].Load() != uint64(width)<<32|uint64(width*9/16) {
			t.Fatal("adapted dimensions did not reach layer and codec metadata")
		}
		before.Layers[1].Width = 1
		if source.media.TrackInfo().Layers[1].Width != 1280 || initialInfo.Layers[0].Width != 640 {
			t.Fatal("dimension metadata escaped its immutable snapshot")
		}
		for layer := range 2 {
			tracker := trackers.GetTracker(int32(layer))
			if tracker == nil || tracker.Status() != streamtracker.StreamStatusActive || tracker.BitrateTemporalCumulative()[0] == 0 ||
				source.media.GetAllBuffers()[layer] != buffers[layer] {
				t.Fatalf("dimension update reset live layer %d", layer)
			}
		}
		if !proto.Equal(clock, buffers[0].GetSenderReportData()) {
			t.Fatal("dimension update changed the source clock or counters")
		}
		write()
		after := buffers[0].GetSenderReportData()
		if after.Packets != clock.Packets+1 || after.Octets <= clock.Octets || after.RtpTimestamp-clock.RtpTimestamp != 3600 ||
			after.NtpTimestamp <= clock.NtpTimestamp {
			t.Fatal("adapted output did not retain the source RTP timeline")
		}
	}
	for _, format := range [][3]int{{-1, 320, 180}, {2, 320, 180}, {0, 0, 180}, {0, 320, 0}} {
		if source.SetFormat(format[0], uint32(format[1]), uint32(format[2])) == nil ||
			source.media.UpdateDimensions(format[0], uint32(format[1]), uint32(format[2])) == nil {
			t.Fatal("invalid output dimensions were accepted")
		}
	}
	if !proto.Equal(source.media.TrackInfo(), want) {
		t.Fatal("invalid format changed source metadata")
	}
	check(source.Close())
	if !errors.Is(source.SetFormat(0, 640, 360), io.ErrClosedPipe) ||
		!errors.Is(source.media.UpdateDimensions(0, 640, 360), sfu.ErrReceiverClosed) {
		t.Fatal("closed source accepted new dimensions")
	}
}

func TestRelayFormatAdaptationPreservesLiveLayers(t *testing.T) {
	source, err := (&Engine{}).newSource("vp8", 2, 2, &RelayOptions{}, nil)
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = source.Close() })
	check := func(err error) {
		t.Helper()
		if err != nil {
			t.Fatal(err)
		}
	}
	check(source.SetRelayProfile(nativecapture.VideoProfile{
		Width: 1280, Height: 720, Framerate: 30, Bitrate: 1_200_000, Preference: "balanced",
	}))
	check(source.SetFormat(0, 640, 360))
	check(source.SetFormat(1, 1280, 720))
	source.groups = make(map[int]*outputGroup)
	group, err := source.newGroup(2)
	check(err)
	group.active = true
	media := []*forwarding.EncodedSource{source.media, group.media}
	// Warm both the received representation and an independent derived group.
	// No capture process or connection is needed to exercise these real trackers.
	packet := &rtp.Packet{Header: rtp.Header{Version: 2, Marker: true, PayloadType: vp8PayloadType},
		Payload: append([]byte{0x10}, sfu.VP8KeyFrame8x8...)}
	ticker := time.NewTicker(time.Second / 25)
	defer ticker.Stop()
	deadline := time.NewTimer(6 * time.Second)
	defer deadline.Stop()
	for {
		select {
		case <-ticker.C:
		case <-deadline.C:
			t.Fatal("relay layers produced no measured bitrate")
		}
		packet.SequenceNumber++
		packet.Timestamp += 3600
		ready := true
		for _, input := range media {
			for layer := range 2 {
				packet.SSRC = uint32(layer + 1)
				check(input.Source.WriteRTP(layer, packet))
			}
			_, rates := input.GetLayeredBitrate()
			ready = ready && rates[0][0] > 0 && rates[1][0] > 0
		}
		if ready {
			break
		}
	}
	// The first packet of a keyframe carries the new dimensions. Merely
	// learning them must not reset either representation's bitrate history.
	packet.Marker = false
	for _, width := range []uint16{640, 1280} {
		packet.SequenceNumber++
		packet.Timestamp += 3600
		binary.LittleEndian.PutUint16(packet.Payload[7:9], width)
		binary.LittleEndian.PutUint16(packet.Payload[9:11], width*9/16)
		check(source.WriteRTP(packet))
		for _, input := range media {
			for layer := range 2 {
				tracker := input.StreamTrackerManager().GetTracker(int32(layer))
				if tracker == nil || tracker.Status() != streamtracker.StreamStatusActive || tracker.BitrateTemporalCumulative()[0] == 0 {
					t.Fatalf("received dimension update reset live layer %d", layer)
				}
			}
			info := input.TrackInfo()
			if info.Layers[1].Width != uint32(width) || info.Layers[1].Height != uint32(width)*9/16 ||
				info.Layers[0].Width != 640 || info.Layers[0].Height != 360 {
				t.Fatal("received dimensions did not update independently of derived output")
			}
		}
	}
	if source.relay.run != nil {
		t.Fatal("dimension metadata alone started a decoder")
	}
}