Free, open-source screen sharing for private live streams with friends. Watch together in a browser or self-host Piik. 免费开源的私密屏幕共享,支持游戏直播、一起看电影与自部署。
package mediaedge
import (
"context"
"errors"
"net"
"slices"
"strings"
"sync"
"testing"
"time"
"github.com/TNTcraftHIM/Piik/internal/app/nativeaudio"
"github.com/TNTcraftHIM/Piik/internal/app/nativecapture"
"github.com/TNTcraftHIM/Piik/internal/media/encoded"
"github.com/livekit/livekit-server/pkg/sfu"
"github.com/livekit/livekit-server/pkg/sfu/streamtracker"
"github.com/pion/interceptor"
"github.com/pion/logging"
"github.com/pion/rtcp"
"github.com/pion/rtp"
"github.com/pion/rtp/codecs"
"github.com/pion/webrtc/v4"
)
func writeSourceFrame(source *Source, data []byte, timestamp, duration time.Duration) error {
if _, err := source.BeginFrame(timestamp); err != nil {
return err
}
return source.WriteVideo(0, encoded.Frame{Data: data, PTS: timestamp, Duration: duration, Recovery: true})
}
func TestOutputPlanRetiresOnlyFailedLayerConsumers(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() })
wake := make(chan struct{}, 8)
source, err := engine.NewSource("vp8", 2, 2, func([]int) { wake <- struct{}{} })
if err != nil {
t.Fatal(err)
}
if err = source.ConfigureOutputs([]uint32{150_000, 600_000}); err != nil {
t.Fatal(err)
}
high, _, _ := connectedReceiver(t, engine, source, "high")
low, _, _ := connectedReceiver(t, engine, source, "low")
if _, err = source.BeginFrame(0); err != nil {
t.Fatal(err)
}
for len(wake) > 0 {
<-wake
}
if err = low.SetTargetLayer(0); err != nil {
t.Fatal(err)
}
waitSignal(t, wake, "quiet source target-change wakeup")
plan, err := source.BeginFrame(time.Second / 30)
if err != nil || !slices.Equal(plan.Active, []bool{true, true}) || len(plan.Bitrates) != 2 {
t.Fatalf("output plan = %+v, %v", plan, err)
}
plan.Bitrates[0] = 1
trackers := source.media.StreamTrackerManager()
lowerTracker, higherTracker := trackers.AddTracker(0), trackers.AddTracker(1)
lowerTracker.Observe(0, 1200, 1188, true, 90000, nil)
higherTracker.Observe(0, 1200, 1188, true, 90000, nil)
retire, err := source.MarkLayerUnavailable(0)
if err != nil {
t.Fatal(err)
}
retire()
if low.State() != webrtc.PeerConnectionStateClosed || high.State() != webrtc.PeerConnectionStateConnected {
t.Fatalf("failed/sibling state = %s/%s", low.State(), high.State())
}
if err = high.SetTargetLayer(0); err == nil {
t.Fatal("failed output accepted a new demand")
}
lowerTracker.Observe(0, 1200, 1188, true, 93000, nil)
if lowerTracker.Status() != streamtracker.StreamStatusStopped || higherTracker.Status() != streamtracker.StreamStatusActive {
t.Fatal("failed tracker revived or reset a healthy sibling")
}
plan, err = source.BeginFrame(2 * time.Second / 30)
if err != nil || !slices.Equal(plan.Active, []bool{false, true}) || plan.Bitrates[0] != 0 || plan.Bitrates[1] != 600_000 {
t.Fatalf("surviving output plan = %+v, %v", plan, err)
}
if err = source.WriteVideo(0, encoded.Frame{Data: sfu.VP8KeyFrame8x8, PTS: 2 * time.Second / 30, Duration: time.Second / 30}); err == nil {
t.Fatal("late output revived a failed encoder slot")
}
for index, input := range []string{"capture", "relay"} {
candidate, _, _ := connectedReceiver(t, engine, source, "failed-demand-"+input)
// Exercise a framework request independently of the explicit Native
// setter. This is admission metadata, not simulated network evidence.
candidate.transport.OnTransportCCFeedback(nil, &rtcp.TransportLayerCC{})
candidate.transport.Output.SetMaxSpatialLayer(0)
candidate.transport.Output.SetBudget(80_000)
if input == "capture" {
plan, err = source.BeginFrame(time.Duration(index+3) * time.Second / 30)
if err != nil || !slices.Equal(plan.Active, []bool{false, true}) || plan.Bitrates[0] != 0 {
t.Fatalf("failed demand changed the capture plan: %+v, %v", plan, err)
}
} else {
err = source.WriteRTP(&rtp.Packet{Header: rtp.Header{Version: 2, SSRC: 42, PayloadType: 96,
SequenceNumber: 1, Timestamp: 90000, Marker: true}, Payload: append([]byte{0x10}, sfu.VP8KeyFrame8x8...)})
if err != nil {
t.Fatal(err)
}
}
if candidate.State() != webrtc.PeerConnectionStateClosed || high.State() != webrtc.PeerConnectionStateConnected {
t.Fatalf("%s failed/sibling state = %s/%s", input, candidate.State(), high.State())
}
}
if err = source.ConfigureOutputs([]uint32{150_000, 600_000}); err != nil {
t.Fatal(err)
}
lowerTracker.Observe(0, 1200, 1188, true, 96000, nil)
if lowerTracker.Status() != streamtracker.StreamStatusActive || high.SetTargetLayer(0) != nil {
t.Fatal("validated capture output did not restore the failed slot")
}
}
func TestRelayFailureCannotRetireReconfiguredProfile(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", 1, 2, &RelayOptions{}, nil)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = source.Close() })
_ = source.SetFormat(1, 640, 360)
profile := nativecapture.VideoProfile{Width: 1280, Height: 720, Framerate: 30, Bitrate: 3_000_000, Preference: "balanced"}
if err = source.SetRelayProfile(profile); err != nil {
t.Fatal(err)
}
low, _, _ := connectedReceiver(t, engine, source, "relay-failure")
if err = low.SetTargetLayer(0); err != nil {
t.Fatal(err)
}
ctx, cancel := context.WithCancelCause(t.Context())
defer cancel(nil)
done := make(chan struct{})
close(done)
old := &relayRun{owner: source.relay, ctx: ctx, cancel: cancel, done: done,
plan: relayPlan{profile: source.relayProfile, format: source.formats[1].Load()}}
source.relay.run = old
cancel(errors.New("old decoder failed"))
profile.Preference = "maintain-resolution"
if err = source.SetRelayProfile(profile); err != nil {
t.Fatal(err)
}
profile.Preference = "balanced"
if err = source.SetRelayProfile(profile); err != nil {
t.Fatal(err)
}
if source.relayProfile == old.plan.profile || *source.relayProfile != *old.plan.profile {
t.Fatal("fixture did not return to equal settings with a new owner")
}
retire, err := source.markLayerUnavailable(0, old)
if err != nil || retire != nil || source.outputBitrates[0] == 0 || low.State() != webrtc.PeerConnectionStateConnected {
t.Fatal("late failed decoder retired reconfigured output")
}
current := &relayRun{owner: source.relay, ctx: ctx, cancel: cancel, done: done,
plan: relayPlan{profile: source.relayProfile, format: source.formats[1].Load()}}
source.relay.run = current
retire, err = source.markLayerUnavailable(0, current)
if err != nil || retire == nil || low.State() != webrtc.PeerConnectionStateConnected {
t.Fatal("current failure did not defer transport retirement until after owner locks")
}
retire()
if source.outputBitrates[0] != 0 || low.State() != webrtc.PeerConnectionStateClosed {
t.Fatal("current decoder failure was not retired")
}
}
func TestRetiredRelayFailureCannotDisableLaterDemand(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, 2, &RelayOptions{}, nil)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = source.Close() })
if err = source.SetFormat(1, 640, 360); err != nil {
t.Fatal(err)
}
if err = source.SetRelayProfile(nativecapture.VideoProfile{
Width: 1280, Height: 720, Framerate: 30, Bitrate: 3_000_000, Preference: "balanced",
}); err != nil {
t.Fatal(err)
}
high, _, _ := connectedReceiver(t, engine, source, "retiring-relay-high")
low, _, _ := connectedReceiver(t, engine, source, "retiring-relay-low")
if err = low.SetTargetLayer(0); err != nil {
t.Fatal(err)
}
ctx, cancel := context.WithCancelCause(t.Context())
defer cancel(nil)
done := make(chan struct{})
t.Cleanup(func() { close(done) })
run := &relayRun{owner: source.relay, ctx: ctx, cancel: cancel, done: done,
plan: relayPlan{profile: source.relayProfile, format: source.formats[1].Load()}}
source.relay.run = run
if err = low.Close(); err != nil {
t.Fatal(err)
}
if !errors.Is(context.Cause(ctx), context.Canceled) {
t.Fatal("last lower consumer did not retire the derivation normally")
}
// A failure already read from the old process can reach the source lock
// after cancellation, before the process exits and the next run starts.
retire, err := source.markLayerUnavailable(0, run)
if err != nil || retire != nil || source.outputBitrates[0] == 0 {
t.Fatal("normal retirement disabled a reusable output slot")
}
rejoined, _, _ := connectedReceiver(t, engine, source, "retiring-relay-rejoined")
if err = rejoined.SetTargetLayer(0); err != nil {
t.Fatalf("later lower demand was rejected: %v", err)
}
if rejoined.State() != webrtc.PeerConnectionStateConnected || high.State() != webrtc.PeerConnectionStateConnected {
t.Fatal("late failure retired a current consumer or healthy sibling")
}
}
func TestShutdownClosesSiblingTransportsBeforeWaitingForWrites(t *testing.T) {
for _, owner := range []string{"source", "engine"} {
t.Run(owner, 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, 1, nil)
if err != nil {
t.Fatal(err)
}
closed := []chan struct{}{make(chan struct{}, 1), make(chan struct{}, 1)}
for index := range closed {
_, err := engine.NewEdge(source, EdgeOptions{
ConnectionID: "shutdown-" + owner + string(rune('a'+index)),
Events: EdgeEvents{ConnectionState: func(state webrtc.PeerConnectionState, _ *SelectedPair, _ func(webrtc.PeerConnectionState) bool) {
if state == webrtc.PeerConnectionStateClosed {
closed[index] <- struct{}{}
}
}},
})
if err != nil {
t.Fatal(err)
}
}
source.writeMu.Lock()
unlock := sync.OnceFunc(source.writeMu.Unlock)
done := make(chan struct{})
t.Cleanup(func() { unlock(); waitSignal(t, done, "shutdown cleanup") })
go func() {
if owner == "source" {
_ = source.Close()
} else {
_ = engine.Close()
}
close(done)
}()
for _, transport := range closed {
waitSignal(t, transport, "sibling transport close")
}
unlock()
waitSignal(t, done, "shutdown completion")
})
}
}
func TestPortMappingCandidateUsesObservedPublicAddress(t *testing.T) {
var emitted []*webrtc.ICECandidateInit
gathering := &localCandidateGathering{
socket: &iceSocket{localPort: 43210},
mappedPort: 43211,
mappedCandidates: make(map[string]struct{}),
emit: func(candidate *webrtc.ICECandidateInit) {
emitted = append(emitted, candidate)
},
}
mapped := mappedAddress{address: "203.0.113.7", port: 41000}
gathering.emitMappedCandidate(mapped)
gathering.emitMappedCandidate(mapped)
if len(emitted) != 1 {
t.Fatalf("emitted candidates = %d, want one mapped", len(emitted))
}
fields := strings.Fields(emitted[0].Candidate)
if len(fields) < 8 || fields[0] != "candidate:mp1" ||
fields[3] != "1694498559" ||
fields[4] != "203.0.113.7" || fields[5] != "43211" ||
fields[7] != "srflx" {
t.Fatalf("mapped candidate = %q", emitted[0].Candidate)
}
}
func TestOneEncodedSourceFeedsTwoIndependentEdges(t *testing.T) {
for _, codec := range []string{"h264", "vp8"} {
t.Run(codec, func(t *testing.T) { testEncodedSourceFanout(t, codec) })
}
}
func testEncodedSourceFanout(t *testing.T, codec string) {
engine, err := NewEngine(EngineOptions{
BindAddress: "127.0.0.1:0",
IncludeLoopback: true,
})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = engine.Close() })
keyFrames := make(chan struct{}, 1)
source, err := engine.NewSource(codec, 2, 1, func([]int) {
select {
case keyFrames <- struct{}{}:
default:
}
})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = source.Close() })
edgeA, receiverA, packetA := connectedReceiver(t, engine, source, "edge-a")
edgeB, receiverB, packetB := connectedReceiver(t, engine, source, "edge-b")
t.Cleanup(func() { _ = receiverA.Close() })
t.Cleanup(func() { _ = receiverB.Close() })
if edgeA.connection == edgeB.connection || edgeA.socket == edgeB.socket || edgeA.socket.localPort == edgeB.socket.localPort {
t.Fatal("media edges did not keep independent transports")
}
if edgeA.transport == edgeB.transport {
t.Fatal("media edges shared one bandwidth estimator")
}
if _, err = engine.NewEdge(source, EdgeOptions{ConnectionID: "edge-c"}); !errors.Is(err, ErrSourceCapacity) {
t.Fatalf("third edge error = %v", err)
}
select {
case <-keyFrames:
case <-time.After(3 * time.Second):
t.Fatal("connected edge did not request a recovery frame")
}
accessUnit := []byte{
0, 0, 0, 1, 0x67, 0x42, 0xc0, 0x1f, 0x96, 0x54, 0x05, 0x01,
0, 0, 0, 1, 0x68, 0xce, 0x3c, 0x80,
0, 0, 0, 1, 0x65, 0x88, 0x84, 0x00,
}
if codec == "vp8" {
accessUnit = []byte{0x10, 0, 0, 0x9d, 0x01, 0x2a, 0x80, 0x02, 0xe0, 0x01, 0}
}
if err = writeSourceFrame(source, accessUnit, time.Second, time.Second/30); err != nil {
t.Fatal(err)
}
first := waitPacket(t, packetA)
_ = waitPacket(t, packetB)
if codec == "vp8" {
packet := &codecs.VP8Packet{}
payload, parseErr := packet.Unmarshal(first.Payload)
if parseErr != nil || string(payload) != string(accessUnit) || packet.S != 1 {
t.Fatalf("VP8 packetizer changed its encoded source: %v", parseErr)
}
}
// Verify feedback delivery independently of the upstream bootstrap throttle.
source.media.GetAllBuffers()[0].SetPLIThrottle(0)
for len(keyFrames) > 0 {
<-keyFrames
}
if err = receiverA.WriteRTCP([]rtcp.Packet{
&rtcp.PictureLossIndication{MediaSSRC: first.SSRC},
}); err != nil {
t.Fatal(err)
}
select {
case <-keyFrames:
case <-time.After(3 * time.Second):
t.Fatal("PLI did not reach the shared source")
}
if err = edgeA.Close(); err != nil {
t.Fatal(err)
}
edgeC, err := engine.NewEdge(source, EdgeOptions{ConnectionID: "edge-c"})
if err != nil {
t.Fatalf("released source slot was not reusable: %v", err)
}
_ = edgeC.Close()
}
func TestRemoteCandidatesAreBoundedUntilTheAnswer(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, 1, nil)
if err != nil {
t.Fatal(err)
}
edge, err := engine.NewEdge(source, EdgeOptions{ConnectionID: "edge"})
if err != nil {
t.Fatal(err)
}
if err = edge.AddRemoteCandidate(&webrtc.ICECandidateInit{
Candidate: "candidate:garbage",
}); err != nil {
t.Fatalf("malformed candidate escaped the edge boundary: %v", err)
}
if len(edge.pendingCandidates) != 0 {
t.Fatalf("malformed candidate was queued: %d", len(edge.pendingCandidates))
}
for index := 0; index < maxPendingCandidates; index++ {
if err = edge.AddRemoteCandidate(&webrtc.ICECandidateInit{
Candidate: "candidate:1 1 udp 1 127.0.0.1 9 typ host",
}); err != nil {
t.Fatalf("candidate %d: %v", index, err)
}
}
if err = edge.AddRemoteCandidate(&webrtc.ICECandidateInit{
Candidate: "candidate:1 1 udp 1 127.0.0.1 9 typ host",
}); err != nil {
t.Fatalf("excess candidate was not discarded: %v", err)
}
if len(edge.pendingCandidates) != maxPendingCandidates {
t.Fatalf("candidate queue grew beyond the bound: %d", len(edge.pendingCandidates))
}
}
func TestSelectedNatTraversalPathKeepsOnlyAnonymousProvenance(t *testing.T) {
if got := selectedNatTraversalPath("ordinary", "sp3"); got != "predicted" {
t.Fatalf("predicted path = %q", got)
}
if got := selectedNatTraversalPath("ordinary", "remote"); got != "ordinary" {
t.Fatalf("ordinary path = %q", got)
}
if got := selectedNatTraversalPath("", ""); got != "unknown" {
t.Fatalf("unknown path = %q", got)
}
}
func TestRepeatedAnswerIsIdempotent(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, 1, nil)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = source.Close() })
edge, receiver, _ := connectedReceiver(t, engine, source, "repeat-answer")
t.Cleanup(func() { _ = receiver.Close() })
answer := receiver.LocalDescription()
if answer == nil {
t.Fatal("receiver did not retain its answer")
}
if err = edge.SetAnswer(*answer, ""); err != nil {
t.Fatalf("repeated answer was not idempotent: %v", err)
}
}
func TestCaptureTimestampsDriveTheRTPClock(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", 1, 1, nil)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = source.Close() })
edge, receiver, packets := connectedReceiver(t, engine, source, "timed-edge")
t.Cleanup(func() { _ = receiver.Close() })
accessUnit := sfu.VP8KeyFrame8x8
start := 10 * time.Second
frameDuration := time.Second / 30
if err = writeSourceFrame(source, accessUnit, start, frameDuration); err != nil {
t.Fatal(err)
}
first := waitPacket(t, packets, edge)
if err = writeSourceFrame(source, accessUnit, start+frameDuration, frameDuration); err != nil {
t.Fatal(err)
}
second := waitPacket(t, packets, edge)
if got := second.Timestamp - first.Timestamp; got < 2_999 || got > 3_001 {
t.Fatalf("steady timestamp delta = %d", got)
}
if err = writeSourceFrame(source, accessUnit, start+5*time.Second, frameDuration); err != nil {
t.Fatal(err)
}
third := waitPacket(t, packets, edge)
if got := third.Timestamp - second.Timestamp; got < 446_999 || got > 447_001 {
t.Fatalf("sparse timestamp delta = %d", got)
}
}
func TestNewCaptureGenerationKeepsTheRTPClockContinuous(t *testing.T) {
engine, err := NewEngine(EngineOptions{})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = engine.Close() })
source, err := engine.NewSource("vp8", 1, 1, nil)
if err != nil {
t.Fatal(err)
}
edge, receiver, packets := connectedReceiver(t, engine, source, "generation-edge")
t.Cleanup(func() { _ = receiver.Close() })
accessUnit := sfu.VP8KeyFrame8x8
frameDuration := time.Second / 30
origin := time.Now()
if _, err = source.beginFrame(50*time.Second, origin); err != nil {
t.Fatal(err)
}
if err = source.WriteVideo(0, encoded.Frame{Data: accessUnit, PTS: 50 * time.Second, Duration: frameDuration, Recovery: true}); err != nil {
t.Fatal(err)
}
first := waitPacket(t, packets, edge)
source.BeginGeneration()
if _, err = source.beginFrame(100*time.Millisecond, origin.Add(200*time.Millisecond)); err != nil {
t.Fatal(err)
}
if err = source.WriteVideo(0, encoded.Frame{Data: accessUnit, PTS: 100 * time.Millisecond, Duration: frameDuration, Recovery: true}); err != nil {
t.Fatal(err)
}
second := waitPacket(t, packets, edge)
if got := second.Timestamp - first.Timestamp; got < 17_999 || got > 18_001 {
t.Fatalf("generation timestamp delta = %d", got)
}
}
func TestOneLocalBridgeDoesNotConsumeRouteCapacity(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, 1, nil)
if err != nil {
t.Fatal(err)
}
audio, err := engine.NewAudioSource(1, 128_000)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = audio.Close() })
local, err := engine.NewEdge(source, EdgeOptions{
ConnectionID: "local-preview", Local: true, Audio: audio,
})
if err != nil {
t.Fatal(err)
}
route, err := engine.NewEdge(source, EdgeOptions{
ConnectionID: "route-edge", Audio: audio,
})
if err != nil {
t.Fatal(err)
}
if _, err = engine.NewEdge(source, EdgeOptions{
ConnectionID: "second-local", Local: true,
}); !errors.Is(err, ErrSourceCapacity) {
t.Fatalf("second local edge error = %v", err)
}
if _, err = engine.NewEdge(source, EdgeOptions{
ConnectionID: "second-route",
}); !errors.Is(err, ErrSourceCapacity) {
t.Fatalf("second route edge error = %v", err)
}
_ = local.Close()
_ = route.Close()
if replacement, replaceErr := engine.NewEdge(source, EdgeOptions{
ConnectionID: "replacement-local", Local: true, Audio: audio,
}); replaceErr != nil {
t.Fatalf("released local slot was not reusable: %v", replaceErr)
} else {
_ = replacement.Close()
}
}
func TestBandwidthObserverReceivesTransportFeedbackWithoutPacing(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, 1, nil)
if err != nil {
t.Fatal(err)
}
edge, receiver, packets := connectedReceiver(t, engine, source, "quality-edge")
t.Cleanup(func() { _ = receiver.Close() })
if !strings.Contains(edge.connection.LocalDescription().SDP, "transport-cc") {
t.Fatal("native media offer did not negotiate transport feedback")
}
source.SetFormat(0, 1280, 720)
started := time.Now()
if _, ok := edge.QualitySample(started); ok {
t.Fatal("first quality sample did not establish a baseline")
}
accessUnit := []byte{
0, 0, 0, 1, 0x67, 0x42, 0xc0, 0x1f, 0x96, 0x54, 0x05, 0x01,
0, 0, 0, 1, 0x68, 0xce, 0x3c, 0x80,
0, 0, 0, 1, 0x65, 0x88, 0x84, 0x00,
}
deadline := time.Now().Add(5 * time.Second)
captureTimestamp := time.Second
for time.Now().Before(deadline) {
if err = writeSourceFrame(source,
accessUnit,
captureTimestamp,
time.Second/30,
); err != nil {
t.Fatal(err)
}
captureTimestamp += time.Second / 30
select {
case <-packets:
default:
}
if bitrate, observed := edge.targetBitrate(); observed && time.Since(started) >= time.Second {
if bitrate <= 0 {
t.Fatalf("observed target bitrate = %d", bitrate)
}
sample, ok := edge.QualitySample(time.Now())
if !ok || sample.State != "healthy" || sample.Reason == nil ||
*sample.Reason != "none" || sample.IntervalFramesSent == 0 ||
sample.RTPStatsID == "" || sample.TrackIdentifier == "" {
t.Fatalf("quality sample = %+v, %v", sample, ok)
}
return
}
time.Sleep(time.Second / 30)
}
t.Fatal("transport feedback did not produce a bandwidth estimate")
}
func TestAudioUsesTheSamePeerConnectionAndCapacityAsVideo(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() })
video, err := engine.NewSource("h264", 1, 1, nil)
if err != nil {
t.Fatal(err)
}
audio, err := engine.NewAudioSource(1, 128_000)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = video.Close(); _ = audio.Close() })
edge, err := engine.NewEdge(video, EdgeOptions{
ConnectionID: "audio-edge",
Audio: audio,
})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = edge.Close() })
if edge.audioSender == nil {
t.Fatal("audio sender was not attached")
}
if _, err = engine.NewEdge(video, EdgeOptions{ConnectionID: "video-only"}); !errors.Is(err, ErrSourceCapacity) {
t.Fatalf("video capacity was not shared: %v", err)
}
if _, err = engine.NewEdge(video, EdgeOptions{ConnectionID: "audio-only", Audio: audio}); !errors.Is(err, ErrSourceCapacity) {
t.Fatalf("audio capacity was not shared: %v", err)
}
offer, err := edge.CreateOffer()
if err != nil {
t.Fatal(err)
}
if !strings.Contains(offer.SDP, "m=audio") || !strings.Contains(offer.SDP, "opus/48000") {
t.Fatalf("same connection offer has no Opus section: %s", offer.SDP)
}
}
func TestAudioSourceDeliversOpusOnTheVideoPeerConnection(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() })
video, err := engine.NewSource("h264", 2, 1, nil)
if err != nil {
t.Fatal(err)
}
audio, err := engine.NewAudioSource(2, 128_000)
if err != nil {
t.Fatal(err)
}
edge, err := engine.NewEdge(video, EdgeOptions{ConnectionID: "audio-edge", Audio: audio})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = edge.Close(); _ = video.Close(); _ = audio.Close() })
receiver := newAudioReceiver(t)
t.Cleanup(func() { _ = receiver.Close() })
audioPackets := make(chan *rtp.Packet, 1)
receiver.OnTrack(func(track *webrtc.TrackRemote, _ *webrtc.RTPReceiver) {
if track.Kind() != webrtc.RTPCodecTypeAudio {
return
}
packet, _, readErr := track.ReadRTP()
if readErr == nil {
audioPackets <- packet
}
})
connectEdgeToReceiver(t, edge, receiver)
limited, err := engine.NewEdge(video, EdgeOptions{ConnectionID: "limited-audio-edge", Audio: audio})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = limited.Close() })
limitedReceiver := newAudioReceiver(t)
t.Cleanup(func() { _ = limitedReceiver.Close() })
offer, err := limited.CreateOffer()
if err != nil {
t.Fatal(err)
}
if err = limitedReceiver.SetRemoteDescription(offer); err != nil {
t.Fatal(err)
}
answer, err := (&Receiver{connection: limitedReceiver}).createAnswer()
if err != nil {
t.Fatal(err)
}
answer.SDP = strings.ReplaceAll(answer.SDP, "maxaveragebitrate=510000", "maxaveragebitrate=192000")
if err = limited.SetAnswer(answer, ""); err == nil {
t.Fatal("shared audio accepted an insufficient receiver limit")
}
if limited.connection.RemoteDescription() != nil {
t.Fatal("rejected answer was applied before admission")
}
if err = limited.Close(); err != nil {
t.Fatal(err)
}
// Rejecting and retiring this edge must leave the shared audio source and
// the first receiver usable, without reducing the source's live setting.
if audio.configuredBitrate() != 128_000 {
t.Fatal("receiver admission changed the shared audio setting")
}
if err = audio.WritePCM(make([]byte, nativeaudio.FrameBytes), 20*time.Millisecond); err != nil {
t.Fatal(err)
}
select {
case packet := <-audioPackets:
if packet.PayloadType != 111 || len(packet.Payload) == 0 {
t.Fatalf("unexpected Opus RTP packet: payload type %d, %d bytes", packet.PayloadType, len(packet.Payload))
}
case <-time.After(5 * time.Second):
t.Fatal("timed out waiting for Opus RTP")
}
}
func connectedReceiver(
t *testing.T,
engine *Engine,
source *Source,
connectionID string,
) (*Edge, *webrtc.PeerConnection, <-chan *rtp.Packet) {
t.Helper()
connected := make(chan struct{}, 1)
edge, err := engine.NewEdge(source, EdgeOptions{ConnectionID: connectionID, Events: EdgeEvents{
ConnectionState: func(state webrtc.PeerConnectionState, _ *SelectedPair, _ func(webrtc.PeerConnectionState) bool) {
if state == webrtc.PeerConnectionStateConnected {
select {
case connected <- struct{}{}:
default:
}
}
},
}})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = edge.Close() })
receiver := newReceiver(t)
packets := make(chan *rtp.Packet, 64)
receiver.OnTrack(func(track *webrtc.TrackRemote, _ *webrtc.RTPReceiver) {
go func() {
for {
packet, _, readErr := track.ReadRTP()
if readErr != nil {
return
}
select {
case packets <- packet:
default:
}
}
}()
})
connectEdgeToReceiver(t, edge, receiver)
// Pion publishes Connected before our callback activates the media output.
// A one-frame test must await that callback, not race it with its only frame.
waitSignal(t, connected, "media activation")
return edge, receiver, packets
}
func connectEdgeToReceiver(
t *testing.T,
edge *Edge,
receiver *webrtc.PeerConnection,
) {
t.Helper()
gatherOffer := webrtc.GatheringCompletePromise(edge.connection)
if _, err := edge.CreateOffer(); err != nil {
t.Fatal(err)
}
waitSignal(t, gatherOffer, "offer ICE gathering")
if err := receiver.SetRemoteDescription(*edge.connection.LocalDescription()); err != nil {
t.Fatal(err)
}
gatherAnswer := webrtc.GatheringCompletePromise(receiver)
// Use the product's receive preferences rather than Pion's generic defaults.
_, err := (&Receiver{connection: receiver}).createAnswer()
if err != nil {
t.Fatal(err)
}
waitSignal(t, gatherAnswer, "answer ICE gathering")
if err = edge.SetAnswer(*receiver.LocalDescription(), ""); err != nil {
t.Fatal(err)
}
deadline := time.Now().Add(5 * time.Second)
for edge.State() != webrtc.PeerConnectionStateConnected {
if time.Now().After(deadline) {
t.Fatalf("edge state = %s", edge.State())
}
time.Sleep(10 * time.Millisecond)
}
}
func newReceiver(t *testing.T) *webrtc.PeerConnection {
return newReceiverWithAudio(t, false, "127.0.0.1:0")
}
func newAudioReceiver(t *testing.T) *webrtc.PeerConnection {
return newReceiverWithAudio(t, true, "127.0.0.1:0")
}
func newReceiverWithAudio(t *testing.T, includeAudio bool, bindAddress string) *webrtc.PeerConnection {
t.Helper()
mediaEngine := &webrtc.MediaEngine{}
for _, codec := range []string{"h264", "vp8"} {
if err := mediaEngine.RegisterCodec(videoCodecs[codec], webrtc.RTPCodecTypeVideo); err != nil {
t.Fatal(err)
}
}
if includeAudio {
if err := mediaEngine.RegisterCodec(webrtc.RTPCodecParameters{
RTPCodecCapability: opusCapability,
PayloadType: 111,
}, webrtc.RTPCodecTypeAudio); err != nil {
t.Fatal(err)
}
}
registry := &interceptor.Registry{}
if err := webrtc.RegisterDefaultInterceptors(mediaEngine, registry); err != nil {
t.Fatal(err)
}
settings := webrtc.SettingEngine{}
settings.SetIncludeLoopbackCandidate(true)
address, err := net.ResolveUDPAddr("udp", bindAddress)
if err != nil {
t.Fatal(err)
}
udp, err := net.ListenUDP("udp", address)
if err != nil {
t.Fatal(err)
}
mux := webrtc.NewICEUDPMux(logging.NewDefaultLoggerFactory().NewLogger("mediaedge-test"), udp)
settings.SetICEUDPMux(mux)
t.Cleanup(func() { _ = mux.Close() })
api := webrtc.NewAPI(
webrtc.WithMediaEngine(mediaEngine),
webrtc.WithInterceptorRegistry(registry),
webrtc.WithSettingEngine(settings),
)
connection, err := api.NewPeerConnection(webrtc.Configuration{})
if err != nil {
t.Fatal(err)
}
if includeAudio {
if _, err = connection.AddTransceiverFromKind(
webrtc.RTPCodecTypeAudio,
webrtc.RTPTransceiverInit{Direction: webrtc.RTPTransceiverDirectionRecvonly},
); err != nil {
t.Fatal(err)
}
}
return connection
}
func waitSignal(t *testing.T, signal <-chan struct{}, label string) {
t.Helper()
select {
case <-signal:
case <-time.After(5 * time.Second):
t.Fatalf("timed out waiting for %s", label)
}
}
func waitPacket(t *testing.T, packets <-chan *rtp.Packet, edges ...*Edge) *rtp.Packet {
t.Helper()
select {
case packet := <-packets:
return packet
case <-time.After(5 * time.Second):
for _, edge := range edges {
t.Logf("edge=%s output=%+v egress=%+v source=%+v", edge.State(),
edge.transport.Output.State(), edge.transport.Egress(), edge.source.media.DebugInfo())
t.Logf("forwarder=%+v", edge.transport.Output.DebugInfo())
for index, input := range edge.source.media.GetAllBuffers() {
if input != nil {
t.Logf("input=%d stats=%+v", index, input.GetStats())
}
}
}
t.Fatal("timed out waiting for RTP")
return nil
}
}
// Connection callbacks and the final event writer can run after Pion has moved
// on. Retain the real callback until the PC closes, then consume its projection.
func TestEdgeDelayedConnectionStateIsNotCurrent(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, 2, nil)
if err != nil {
t.Fatal(err)
}
connected := make(chan func(webrtc.PeerConnectionState) bool, 1)
release := make(chan struct{})
delivered := make(chan bool, 1)
var releaseOnce sync.Once
resume := func() { releaseOnce.Do(func() { close(release) }) }
t.Cleanup(resume)
edge, err := engine.NewEdge(source, EdgeOptions{ConnectionID: "delayed-state", Events: EdgeEvents{
ConnectionState: func(state webrtc.PeerConnectionState, _ *SelectedPair, current func(webrtc.PeerConnectionState) bool) {
if state == webrtc.PeerConnectionStateConnected {
connected <- current
<-release
delivered <- current(state)
}
},
}})
if err != nil {
t.Fatal(err)
}
receiver := newReceiver(t)
t.Cleanup(func() { _ = receiver.Close() })
connectEdgeToReceiver(t, edge, receiver)
var current func(webrtc.PeerConnectionState) bool
select {
case current = <-connected:
case <-time.After(5 * time.Second):
t.Fatal("no connected Native callback")
}
if !current(webrtc.PeerConnectionStateConnected) {
t.Fatal("live connection was not current")
}
if err = edge.Close(); err != nil {
t.Fatal(err)
}
resume()
select {
case valid := <-delivered:
if valid {
t.Fatal("delayed connected event survived PC closure")
}
case <-time.After(5 * time.Second):
t.Fatal("Native callback did not resume")
}
if !current(webrtc.PeerConnectionStateClosed) {
t.Fatal("current-state predicate retained a historical snapshot")
}
}