Free, open-source screen sharing for private live streams with friends. Watch together in a browser or self-host Piik. 免费开源的私密屏幕共享,支持游戏直播、一起看电影与自部署。
package mediaedge
import (
"testing"
"time"
"github.com/TNTcraftHIM/Piik/internal/media/encoded"
"github.com/TNTcraftHIM/Piik/internal/media/forwarding"
"github.com/livekit/livekit-server/pkg/sfu"
"github.com/pion/rtcp"
)
type qualityAllocationReceiver struct{ sfu.TrackReceiver }
func (receiver qualityAllocationReceiver) GetLayeredBitrate() ([]int32, sfu.Bitrates) {
return []int32{0, 1}, sfu.Bitrates{{100_000}, {900_000}}
}
func TestQualityDimensionsFollowAssignedSource(t *testing.T) {
check := func(err error) {
t.Helper()
if err != nil {
t.Fatal(err)
}
}
engine, err := NewEngine(EngineOptions{BindAddress: "127.0.0.1:0", IncludeLoopback: true})
check(err)
defer engine.Close()
source, err := engine.NewSource("vp8", 1, 2, nil)
check(err)
defer source.Close()
check(source.SetFormat(0, 320, 180))
check(source.SetFormat(1, 640, 360))
check(source.ConfigureOutputs([]uint32{90_000, 300_000}))
edge, receiver, _ := connectedReceiver(t, engine, source, "assigned-quality")
defer receiver.Close()
assigned, err := forwarding.NewEncodedSource(forwarding.SourceOptions{
ID: string(source.media.TrackID()), StreamID: source.media.StreamID(), Codec: source.media.Codec(), MaxPackets: encoded.MaxPacketWindow,
Formats: []forwarding.LayerFormat{{Width: 4, Height: 4, Bitrate: 45_000}, {Width: 8, Height: 8, Bitrate: 150_000}},
})
check(err)
defer assigned.Close()
check(assigned.BeginFrame(0, time.Now()))
check(assigned.WriteFrame(1, encoded.Frame{Data: sfu.VP8KeyFrame8x8, Duration: time.Second / 30, Recovery: true}))
check(edge.transport.ReplaceSource(assigned.Source))
deadline := time.Now().Add(3 * time.Second)
for frame := 1; time.Now().Before(deadline); frame++ {
pts := time.Duration(frame) * time.Second / 30
check(assigned.BeginFrame(pts, time.Now()))
check(assigned.WriteFrame(1, encoded.Frame{Data: sfu.VP8KeyFrame8x8, PTS: pts, Duration: time.Second / 30, Recovery: true}))
frames, _, format := edge.videoCounters()
if frames > 0 && format == uint64(8)<<32|8 {
return
}
time.Sleep(time.Second / 30)
}
frames, _, format := edge.videoCounters()
available, rates := assigned.GetLayeredBitrate()
t.Fatalf("assigned quality: %dx%d, frames=%d, source=%t, state=%+v, layers=%v, rates=%v",
uint32(format>>32), uint32(format), frames, edge.transport.CurrentSource() == assigned.Source,
edge.transport.Output.State(), available, rates)
}
func TestQualitySampleUsesAllocationNotPacketRate(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("h264", 1, 2, nil)
if err != nil {
t.Fatal(err)
}
edge, receiver, _ := connectedReceiver(t, engine, source, "limited-edge")
t.Cleanup(func() { _ = receiver.Close() })
edge.targetBitrate = func() (int, bool) { return 100_000, true }
// Packet throughput can exceed a stale estimate without an allocation
// restriction. The counter window alone must not request route convergence.
started := time.Now()
if _, ok := edge.QualitySample(started); ok {
t.Fatal("first quality sample did not establish a baseline")
}
stats := edge.transport.Output.GetState().RTPStats
stats.SetClockRate(videoClockRate)
for frame := 0; frame < 60; frame++ {
size := 16_666
if frame == 59 {
size += 40
}
stats.Update(started.Add(time.Duration(frame)*time.Second/30).UnixNano(),
uint64(frame+1), uint64(frame*3000), true, 12, size, 0, false)
}
// The library does not publish a zero-duration statistics snapshot.
time.Sleep(time.Millisecond)
sample, ok := edge.QualitySample(started.Add(2 * time.Second))
if !ok || sample.State != "healthy" || sample.Reason == nil ||
*sample.Reason != "none" || sample.IntervalFramesSent != 60 ||
sample.FramesPerSecond != 30 || sample.BitrateKbps != 4_000 ||
sample.AvailableOutgoingKbps != 100 {
t.Fatalf("quality sample = %+v, %v", sample, ok)
}
// Real library allocation remains deficient after selecting a layer that
// fits the link; steady low delivery must not cancel quality convergence.
// This fixture supplies observed capacity, beyond first-feedback bootstrap.
edge.transport.OnTransportCCFeedback(nil, &rtcp.TransportLayerCC{})
output := edge.transport.Output
output.SetReceiver(qualityAllocationReceiver{TrackReceiver: output.Receiver()})
output.UpTrackMaxPublishedLayerChange(1)
output.UpTrackMaxTemporalLayerSeenChange(0)
output.SetMaxSpatialLayer(1)
edge.audioSource = &AudioSource{}
for index, check := range []struct {
budget, sent int
layer int32
state string
}{
{200_000, 100_000, 0, "degraded"},
{1_000_000, 900_000, 1, "healthy"},
{1_000_000, 1_050_000, 1, "healthy"},
} {
output.SetBudget(int64(check.budget))
edge.targetBitrate = func() (int, bool) { return check.budget, true }
if output.State().Target != check.layer || output.IsDeficient() != (check.state == "degraded") {
t.Fatalf("fixture did not establish the expected committed allocation: %+v", output.State())
}
bytes := check.sent / 4
for frame := 0; frame < 60; frame++ {
number := uint64((index+1)*60 + frame + 1)
size := bytes / 60
if frame == 59 {
size += bytes % 60
}
stats.Update(started.Add(time.Duration(number)*time.Second/30).UnixNano(), number,
number*3000, true, 12, size, 0, false)
}
// Audio remains in total traffic diagnostics, but cannot turn a healthy
// 900 kbps video into an apparent overrun of its 1 Mbps video estimate.
edge.audioSource.bytes.Add(80_000) // 320 kbps during this two-second window.
sample, ok = edge.QualitySample(started.Add(time.Duration(index+2) * 2 * time.Second))
if !ok || sample.State != check.state || sample.BitrateKbps != float64(check.sent)/1000+320 {
t.Fatalf("allocation %d quality = %+v, %v", index, sample, ok)
}
}
}