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