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

24.3 KB
Raw Blame
package mediaedge

import (
	"bytes"
	"encoding/hex"
	"sync/atomic"
	"testing"
	"time"

	"github.com/TNTcraftHIM/Piik/internal/app/nativecapture"
	"github.com/TNTcraftHIM/Piik/internal/media/encoded"
	"github.com/livekit/livekit-server/pkg/sfu"
	"github.com/livekit/mediatransportutil/pkg/utils"
	"github.com/pion/ice/v4"
	"github.com/pion/interceptor"
	"github.com/pion/logging"
	"github.com/pion/rtp"
	"github.com/pion/rtp/codecs"
	"github.com/pion/transport/v5/vnet"
	"github.com/pion/webrtc/v4"
)

func TestRelayInputKeepsRecoveryAndEmitsACompleteQuietFrame(t *testing.T) {
	// A single complete access unit must not need a subsequent frame or timer.
	key, err := hex.DecodeString("1000009d012aa0005a00")
	if err != nil {
		t.Fatal(err)
	}
	input := relayVideoInput{codec: "vp8"}
	if err = input.push(&rtp.Packet{Header: rtp.Header{Version: 2, SequenceNumber: 10, Timestamp: 0xfffffff0, Marker: true},
		Payload: append([]byte{0x10}, key...)}); err != nil {
		t.Fatal(err)
	}
	sample, timestamp := input.pop()
	if sample == nil || timestamp != 0xfffffff0 || !bytes.Equal(sample.Data, key) {
		t.Fatal("complete quiet frame waited for future input")
	}
	frame, err := input.frame(sample.Data)
	if err != nil || !frame.KeyFrame || frame.Width != 160 || frame.Height != 90 {
		t.Fatalf("VP8 recovery metadata = %+v, %v", frame, err)
	}
	frame, err = input.frame([]byte{1, 0, 0, 1})
	if err != nil || frame.KeyFrame || frame.Width != 160 || frame.Height != 90 {
		t.Fatal("delta frame lost the stream's dimensions")
	}

	input = relayVideoInput{codec: "h264"}
	var configuration []byte
	for _, nal := range sfu.H264KeyFrame2x2[:2] {
		configuration = append(configuration, 0, 0, 0, 1)
		configuration = append(configuration, nal...)
	}
	if _, err = input.frame(configuration); err != nil {
		t.Fatal(err)
	}
	frame, err = input.frame([]byte{0, 0, 0, 1, 0x65, 0x88, 0x84})
	if err != nil || !frame.KeyFrame || !bytes.Contains(frame.Data, configuration[:4+len(input.sps)]) ||
		!bytes.Contains(frame.Data, input.pps) {
		t.Fatal("H264 IDR lost preceding decoder configuration")
	}
}

func TestRelayInputBoundsStalledAssemblyByMediaTime(t *testing.T) {
	for _, scenario := range []struct {
		name, codec string
		partial     bool
	}{
		{"vp8-missing", "vp8", false}, {"vp8-partial", "vp8", true},
		{"h264-missing", "h264", false}, {"h264-partial", "h264", true},
	} {
		t.Run(scenario.name, func(t *testing.T) {
			requests := 0
			input := relayVideoInput{codec: scenario.codec, onPacketDropped: func() { requests++ }}
			key, _ := hex.DecodeString("1000009d012aa0005a00")
			key = append([]byte{0x10}, key...)
			delta, fragment := []byte{0x10, 1, 0}, []byte{0x10, 1, 0}
			if scenario.codec == "h264" {
				key = []byte{0x78}
				for _, nal := range [][]byte{sfu.H264KeyFrame2x2[0], sfu.H264KeyFrame2x2[1], sfu.H264KeyFrame2x2IDR} {
					key = append(key, byte(len(nal)>>8), byte(len(nal)))
					key = append(key, nal...)
				}
				delta, fragment = []byte{0x61, 1, 0}, []byte{0x7c, 0x81, 1}
			}
			origin := uint32(0xffff0000) // Exercise media-clock wrap as well.
			push := func(sequence uint16, timestamp uint32, marker bool, payload []byte) {
				t.Helper()
				if err := input.push(&rtp.Packet{Header: rtp.Header{Version: 2, SequenceNumber: sequence, Timestamp: timestamp, Marker: marker}, Payload: payload}); err != nil {
					t.Fatal(err)
				}
			}
			push(10, origin, true, key)
			if sample, _ := input.pop(); sample == nil {
				t.Fatal("no initial recovery")
			}
			if scenario.partial {
				push(11, origin+3000, false, fragment)
			}
			// Sequence 12 never arrives. At low packet rates the memory-sized
			// reorder window must not postpone keyframe feedback for minutes.
			for frame := uint32(2); frame <= 40; frame++ {
				push(uint16(11+frame), origin+frame*3000, true, delta)
				for sample, _ := input.pop(); sample != nil; sample, _ = input.pop() {
					if requests == 0 {
						t.Fatal("dependent frame escaped before loss notification")
					}
				}
				if frame < 30 && requests != 0 {
					t.Fatal("discarded within the reorder allowance")
				}
			}
			if requests == 0 {
				t.Fatal("missing media still blocked recovery after a second")
			}
			push(100, origin+123000, true, key)
			if sample, _ := input.pop(); sample == nil {
				t.Fatal("recovery remained blocked")
			}
		})
	}
}

func TestRelayInputKeepsReorderingAndQuietSource(t *testing.T) {
	requests := 0
	input := relayVideoInput{codec: "vp8", onPacketDropped: func() { requests++ }}
	key, _ := hex.DecodeString("1000009d012aa0005a00")
	push := func(sequence uint16, timestamp uint32, payload []byte) {
		t.Helper()
		if err := input.push(&rtp.Packet{Header: rtp.Header{Version: 2, SequenceNumber: sequence, Timestamp: timestamp, Marker: true}, Payload: payload}); err != nil {
			t.Fatal(err)
		}
	}
	push(10, 0, append([]byte{0x10}, key...))
	if sample, _ := input.pop(); sample == nil {
		t.Fatal("no recovery")
	}
	push(12, 6000, []byte{0x10, 1, 0})
	if sample, _ := input.pop(); sample != nil {
		t.Fatal("sequence gap was ignored")
	}
	push(11, 3000, []byte{0x10, 1, 0})
	for _, timestamp := range []uint32{3000, 6000} {
		if sample, got := input.pop(); sample == nil || got != timestamp {
			t.Fatal("reordered frame was lost")
		}
	}
	push(13, 30*videoClockRate, []byte{0x10, 1, 0})
	if sample, _ := input.pop(); sample == nil || requests != 0 {
		t.Fatal("quiet input became packet loss")
	}
}

func TestRelayInputRetiredLossDoesNotRequestAnotherKeyFrame(t *testing.T) {
	for _, codec := range []string{"vp8", "h264"} {
		t.Run(codec, func(t *testing.T) {
			requests := 0
			input := relayVideoInput{codec: codec, onPacketDropped: func() { requests++ }}
			key := append([]byte{0x10}, sfu.VP8KeyFrame8x8...)
			delta, fragment := []byte{0x10, 1, 0}, []byte{0x10, 1, 0}
			if codec == "h264" {
				key = []byte{0x78}
				for _, nal := range [][]byte{sfu.H264KeyFrame2x2[0], sfu.H264KeyFrame2x2[1], sfu.H264KeyFrame2x2IDR} {
					key = append(key, byte(len(nal)>>8), byte(len(nal)))
					key = append(key, nal...)
				}
				delta, fragment = []byte{0x61, 1, 0}, []byte{0x7c, 0x81, 1}
			}
			push := func(sequence uint16, timestamp uint32, marker bool, payload []byte) {
				t.Helper()
				if err := input.push(&rtp.Packet{Header: rtp.Header{Version: 2, SequenceNumber: sequence, Timestamp: timestamp, Marker: marker}, Payload: payload}); err != nil {
					t.Fatal(err)
				}
			}
			push(10, 0, true, key)
			if sample, _ := input.pop(); sample == nil {
				t.Fatal("no initial recovery")
			}
			push(11, 3000, false, fragment)
			push(13, 6000, true, delta) // The previous frame's final packet was lost.
			if sample, _ := input.pop(); sample != nil {
				t.Fatal("incomplete frame escaped")
			}
			push(14, 9000, true, key)
			if requests != 0 {
				t.Fatalf("retiring old loss requested another keyframe %d times", requests)
			}
			sample, timestamp := input.pop()
			if sample == nil || timestamp != 9000 {
				t.Fatal("replacement keyframe did not recover immediately")
			}
			frame, err := input.frame(sample.Data)
			if err != nil || !frame.KeyFrame || frame.Width == 0 || frame.Height == 0 {
				t.Fatalf("replacement recovery lost its decoder configuration: %+v, %v", frame, err)
			}
			// A lost packet in a subsequent keyframe must still request recovery.
			push(15, 12000, false, key)
			for index := uint32(0); index < 40; index++ {
				push(uint16(17+index), 15000+index*3000, true, delta)
				for sample, _ := input.pop(); sample != nil; sample, _ = input.pop() {
				}
			}
			if requests == 0 {
				t.Fatal("loss in the current keyframe no longer requests recovery")
			}
		})
	}
}

func TestRelayInputRejectsUnsafeH264Configuration(t *testing.T) {
	// Generated Constrained Baseline SPS: ID 0 is 5120x2880; ID 1 is
	// 160x90. A decoder may use either, regardless of which arrived last.
	const oversized = "6742c034da0050005a64"
	const small = "6742c015570a37e4c05a8303035280000003008000000301478b17c0"
	for _, test := range []struct {
		name string
		nals []string
	}{
		{"oversize-hidden-by-small-SPS", []string{oversized, small}},
		{"oversize-after-small-SPS", []string{small, oversized}},
		{"truncated-SPS", []string{small, "6742c015"}},
		{"truncated-VUI", []string{"6742c01eda0280b7fe5c0505050200"}},
	} {
		t.Run(test.name, func(t *testing.T) {
			var data []byte
			for _, value := range test.nals {
				nal, err := hex.DecodeString(value)
				if err != nil {
					t.Fatal(err)
				}
				data = append(data, 0, 0, 0, 1)
				data = append(data, nal...)
			}
			input := relayVideoInput{codec: "h264"}
			if _, err := input.frame(data); err == nil {
				t.Fatal("unsafe configuration reached the native decoder boundary")
			}
		})
	}
	input := relayVideoInput{codec: "h264"}
	data, err := hex.DecodeString("00000001" + small)
	if err != nil {
		t.Fatal(err)
	}
	frame, err := input.frame(data)
	if err != nil || frame.Width != 160 || frame.Height != 90 {
		t.Fatalf("valid cropped SPS was rejected: %dx%d, %v", frame.Width, frame.Height, err)
	}
}

func TestRelayH264AllocationBounds(t *testing.T) {
	// Minimal Constrained Baseline parameter sets, including valid codec padding
	// and coded dimensions hidden behind a small crop. No decoder is allocated.
	for _, test := range []struct {
		name, sps     string
		width, height uint32
	}{
		{"1440p", "6742c033da00a002d640", 2560, 1440},
		{"padded-1080p", "6742c033da01e0089f95", 1920, 1080},
		{"portrait-within-bound", "6742c033da01100b5e5d", 1080, 1440},
		{"4k", "6742c033da00f0010f90", 3840, 2160},
		{"portrait-4k", "6742c033da008701e190", 2160, 3840},
		{"level-5.2-4k", "6742c034da00f0010f90", 3840, 2160},
		{"level-5.2-portrait-4k", "6742c034da008701e190", 2160, 3840},
		{"level-5.2-dci", "6742c034da0040004864", 4096, 2304},
		{"level-5.2-ultrawide", "6742c034da005000b590", 5120, 1440},
		{"level-5.2-portrait-ultrawide", "6742c034da0168028190", 1440, 5120},
		{"padded-4k", "6742c033da00f00111f894", 3840, 2160},
		{"4k-reference-buffer-limit", "6742c033f300780087c8", 3840, 2160},
		{"4k-reference-buffer-overflow", "6742c033f380780087c8", 0, 0},
		{"level-5.2-reference-buffer-overflow", "6742c034f380780087c8", 0, 0},
		{"level-5.2-cropped-storage-overflow", "6742c034da00f001e1f8034940", 0, 0},
		{"large-cropped-storage", "6742c033da00f001e1f8034940", 0, 0},
		{"crop-overflow", "6742c033da0a37e000000300100000030004", 0, 0},
		{"coded-size-overflow", "6742c033da000003000040000003000d90", 0, 0},
		{"excessive-references", "6742c033d84828d9", 0, 0},
	} {
		t.Run(test.name, func(t *testing.T) {
			data, err := hex.DecodeString(test.sps)
			if err != nil {
				t.Fatal(err)
			}
			width, height, err := relayH264Size(data)
			if (err == nil) != (test.width != 0) || width != test.width || height != test.height {
				t.Fatalf("picture = %dx%d, %v; want %dx%d", width, height, err, test.width, test.height)
			}
		})
	}
}

func FuzzRelayH264Size(f *testing.F) {
	for _, value := range []string{"6742c033da00f0010f90", "6742c033da008701e190", "6742c033da00f00111f894", "6742c015"} {
		data, err := hex.DecodeString(value)
		if err != nil {
			f.Fatal(err)
		}
		f.Add(data)
	}
	f.Fuzz(func(t *testing.T, data []byte) {
		width, height, err := relayH264Size(data)
		if err == nil && !nativecapture.ValidVideoSize(width, height) {
			t.Fatalf("unbounded picture accepted: %dx%d", width, height)
		}
	})
}

func TestLargeRecoveryUsesTheDefaultPacketWindow(t *testing.T) {
	check := func(err error) {
		t.Helper()
		if err != nil {
			t.Fatal(err)
		}
	}
	// Standard user-data SEI plus the library's valid H264 keyframe. The SEI
	// makes this AU exceed 500 RTP packets without a codec/GPU test dependency.
	var data []byte
	for _, nal := range sfu.H264KeyFrame2x2[:2] {
		data = append(data, 0, 0, 0, 1)
		data = append(data, nal...)
	}
	data = append(data, 0, 0, 0, 1, 0x06, 5)
	const userBytes = 1024 * 1024
	for size := userBytes; size >= 255; size -= 255 {
		data = append(data, 255)
	}
	data = append(data, userBytes%255)
	data = append(data, bytes.Repeat([]byte{0x55}, userBytes)...)
	data = append(data, 0x80, 0, 0, 0, 1)
	data = append(data, sfu.H264KeyFrame2x2IDR...)
	packetizer := encoded.NewPacketizer(&codecs.H264Payloader{}, h264PayloadType, videoPacketMTU)
	packets, err := packetizer.Packetize(data, 0, time.Second)
	check(err)
	if len(packets) <= 500 || len(packets) > encoded.MaxPacketWindow {
		t.Fatal("fixture does not exercise the packet window boundary")
	}
	// Isolate packet-window capacity from host UDP receive-buffer overflow.
	// The production sender, SRTP transport and frame assembler still run here.
	router, err := vnet.NewRouter(&vnet.RouterConfig{CIDR: "10.0.0.0/24",
		QueueSize: encoded.MaxPacketWindow, LoggerFactory: logging.NewDefaultLoggerFactory()})
	check(err)
	sendNet, err := vnet.NewNet(&vnet.NetConfig{StaticIPs: []string{"10.0.0.1"}})
	check(err)
	receiveNet, err := vnet.NewNet(&vnet.NetConfig{StaticIPs: []string{"10.0.0.2"}})
	check(err)
	check(router.AddNet(sendNet))
	check(router.AddNet(receiveNet))
	check(router.Start())
	defer router.Stop()
	engine, err := NewEngine(EngineOptions{BindAddress: "127.0.0.1:0", IncludeLoopback: true, InitialBitrate: 12_000_000})
	check(err)
	defer engine.Close()
	engine.listenPacket = sendNet.ListenPacket
	engine.bindAddress = "10.0.0.1:0"
	engine.settings.SetNet(sendNet)
	engine.settings.SetNetworkTypes([]webrtc.NetworkType{webrtc.NetworkTypeUDP4})
	engine.settings.SetICEMulticastDNSMode(ice.MulticastDNSModeDisabled)
	source, err := engine.NewSource("h264", 1, 1, nil)
	check(err)
	defer source.Close()
	check(source.SetFormat(0, 2, 2))
	check(source.ConfigureOutputs([]uint32{12_000_000}))
	edge, err := engine.NewEdge(source, EdgeOptions{ConnectionID: "large-recovery"})
	check(err)
	defer edge.Close()
	media := &webrtc.MediaEngine{}
	check(media.RegisterDefaultCodecs())
	registry := &interceptor.Registry{}
	check(webrtc.RegisterDefaultInterceptors(media, registry))
	settings := webrtc.SettingEngine{}
	settings.SetNet(receiveNet)
	settings.SetNetworkTypes([]webrtc.NetworkType{webrtc.NetworkTypeUDP4})
	settings.SetICEMulticastDNSMode(ice.MulticastDNSModeDisabled)
	receiver, err := webrtc.NewAPI(webrtc.WithMediaEngine(media), webrtc.WithInterceptorRegistry(registry),
		webrtc.WithSettingEngine(settings)).NewPeerConnection(webrtc.Configuration{})
	check(err)
	defer receiver.Close()
	var complete atomic.Bool
	receiver.OnTrack(func(track *webrtc.TrackRemote, _ *webrtc.RTPReceiver) {
		input := relayVideoInput{codec: "h264"}
		var parts []byte
		var previous uint32
		for {
			packet, _, err := track.ReadRTP()
			if err != nil {
				return
			}
			if err = input.push(packet); err != nil {
				t.Error(err)
				return
			}
			for {
				sample, timestamp := input.pop()
				if sample == nil {
					break
				}
				if timestamp != previous {
					parts = parts[:0]
					previous = timestamp
				}
				parts = append(parts, sample.Data...)
				if bytes.Equal(parts, data) {
					complete.Store(true)
				}
			}
		}
	})
	connectEdgeToReceiver(t, edge, receiver)
	for attempt := 1; attempt <= 4 && !complete.Load(); attempt++ {
		check(writeSourceFrame(source, data, time.Duration(attempt)*time.Second, time.Second))
		time.Sleep(time.Second)
	}
	if !complete.Load() || edge.transport.Egress().DroppedPackets != 0 {
		t.Fatalf("large recovery did not survive source, pacer and assembly: packets=%d complete=%v egress=%+v", len(packets), complete.Load(), edge.transport.Egress())
	}
}

func TestRelayAssemblyRecoversAtNewIndependentFrame(t *testing.T) {
	key, _ := hex.DecodeString("1000009d012aa0005a00")
	sps, pps := sfu.H264KeyFrame2x2[0], sfu.H264KeyFrame2x2[1]
	idr := sfu.H264KeyFrame2x2IDR
	stap := []byte{0x78}
	for _, nal := range [][]byte{sps, pps, idr} {
		stap = append(stap, byte(len(nal)>>8), byte(len(nal)))
		stap = append(stap, nal...)
	}
	for _, check := range []struct {
		name, codec string
		recovery    [][]byte
	}{
		{"vp8", "vp8", [][]byte{append([]byte{0x10}, key...), {0x00, 0x01}}},
		{"h264-nals", "h264", [][]byte{sps, pps, idr}},
		{"h264-stap", "h264", [][]byte{stap}},
		{"h264-fu", "h264", [][]byte{append([]byte{0x7c, 0x87}, sps[1:5]...), append([]byte{0x7c, 0x47}, sps[5:]...), pps, idr}},
	} {
		t.Run(check.name, func(t *testing.T) {
			input := relayVideoInput{codec: check.codec}
			old := uint32(0xffffe000)
			fresh := uint32(0x1000)
			push := func(sequence uint16, timestamp uint32, marker bool, payload []byte) {
				t.Helper()
				if err := input.push(&rtp.Packet{Header: rtp.Header{Version: 2, SequenceNumber: sequence, Timestamp: timestamp, Marker: marker}, Payload: payload}); err != nil {
					t.Fatal(err)
				}
			}
			for index, payload := range check.recovery {
				push(uint16(10+index), old, index+1 == len(check.recovery), payload)
			}
			if sample, _ := input.pop(); sample == nil {
				t.Fatal("initial complete recovery did not assemble")
			}
			for sample, _ := input.pop(); sample != nil; sample, _ = input.pop() {
			}
			// A missing sequence and partial frame must not block later independent recovery.
			partial := []byte{0x10, 0x01, 0x00}
			if check.codec == "h264" {
				partial = []byte{0x7c, 0x81, 0x01}
			}
			push(30, old+3000, false, partial)
			if sample, _ := input.pop(); sample != nil {
				t.Fatal("incomplete frame unexpectedly assembled")
			}
			for index, payload := range check.recovery {
				push(uint16(40+index), fresh, index+1 == len(check.recovery), payload)
				if index == 0 {
					push(40, fresh, index+1 == len(check.recovery), payload)
					push(10, old, false, payload)
				}
			}
			sample, timestamp := input.pop()
			if sample == nil || timestamp != fresh {
				t.Fatalf("new recovery remained blocked: sample=%v timestamp=%x recovery=%x", sample != nil, timestamp, input.recoveryTimestamp)
			}
			recovered := false
			for ; sample != nil; sample, timestamp = input.pop() {
				if timestamp != fresh {
					t.Fatal("old frame was replayed after recovery")
				}
				frame, err := input.frame(sample.Data)
				if err != nil {
					t.Fatal(err)
				}
				if frame.KeyFrame {
					if frame.Width == 0 || frame.Height == 0 {
						t.Fatal("recovered dimensions missing")
					}
					recovered = true
				}
			}
			if !recovered {
				t.Fatal("complete independent recovery was not assembled")
			}
		})
	}
}

func TestRelayInputRejectsTruncatedH264BeforeIndependentRecovery(t *testing.T) {
	for _, leadingNAL := range []bool{false, true} {
		t.Run(map[bool]string{false: "fragment-only", true: "complete-NAL-before-fragment"}[leadingNAL], func(t *testing.T) {
			requests := 0
			input := relayVideoInput{codec: "h264", onPacketDropped: func() { requests++ }}
			payloader := &codecs.H264Payloader{}
			var key []byte
			for _, nalu := range sfu.H264KeyFrame2x2 {
				key = append(key, 0, 0, 0, 1)
				key = append(key, nalu...)
			}
			sequence := uint16(10)
			push := func(timestamp uint32, marker bool, payload []byte) {
				t.Helper()
				if err := input.push(&rtp.Packet{Header: rtp.Header{Version: 2, SequenceNumber: sequence, Timestamp: timestamp, Marker: marker}, Payload: payload}); err != nil {
					t.Fatal(err)
				}
				sequence++
			}
			payloads := payloader.Payload(1200, key)
			for i, payload := range payloads {
				push(0, i == len(payloads)-1, payload)
			}
			recovered := false
			assembled := 0
			for sample, _ := input.pop(); sample != nil; sample, _ = input.pop() {
				assembled++
				frame, err := input.frame(sample.Data)
				if err != nil {
					t.Fatal(err)
				}
				recovered = recovered || frame.KeyFrame
			}
			if !recovered {
				t.Fatal("initial IDR did not establish recovery")
			}
			if assembled != 1 {
				t.Fatal("same-timestamp SPS/PPS/IDR was split before its marker")
			}
			partial := []byte{0, 0, 0, 1}
			if leadingNAL {
				partial = append(partial, 0x61, 0x80, 0, 0, 0, 1)
			}
			partial = append(partial, 0x61)
			partial = append(partial, bytes.Repeat([]byte{0x55}, 70)...)
			payloads = payloader.Payload(16, partial)
			if len(payloads) < 3 || payloads[len(payloads)-1][1]&0x40 == 0 {
				t.Fatal("fixture is not a real fragmented NAL")
			}
			// Chrome can abandon a FU without reserving its unsent tail sequence.
			for _, payload := range payloads[:len(payloads)-1] {
				push(3000, false, payload)
				if sample, _ := input.pop(); sample != nil {
					t.Fatal("unmarked FU escaped during incremental input")
				}
			}
			push(6000, true, []byte{0x61, 0x80})
			for sample, timestamp := input.pop(); sample != nil; sample, timestamp = input.pop() {
				if timestamp == 3000 {
					t.Fatalf("truncated AU escaped: bytes=%d", len(sample.Data))
				}
			}
			if requests == 0 {
				t.Fatal("truncated AU did not request independent recovery")
			}
			// An IDR NAL in the same damaged AU is not independent recovery.
			payloads = payloader.Payload(16, partial)
			for _, payload := range payloads[:len(payloads)-1] {
				push(7000, false, payload)
				if sample, _ := input.pop(); sample != nil {
					t.Fatal("unmarked FU escaped during incremental input")
				}
			}
			push(7000, true, sfu.H264KeyFrame2x2IDR)
			if sample, _ := input.pop(); sample != nil {
				t.Fatal("same-timestamp IDR revived a truncated AU")
			}

			payloads = payloader.Payload(1200, key)
			for i, payload := range payloads {
				push(9000, i == len(payloads)-1, payload)
			}
			recovered = false
			for sample, timestamp := input.pop(); sample != nil; sample, timestamp = input.pop() {
				frame, err := input.frame(sample.Data)
				if err != nil || timestamp != 9000 {
					t.Fatalf("recovery lost original RTP time: %d, %v", timestamp, err)
				}
				recovered = recovered || frame.KeyFrame && frame.Width > 0 && frame.Height > 0
			}
			if !recovered {
				t.Fatal("fresh IDR did not recover immediately")
			}
			push(12000, false, []byte{0x61, 0x81})
			if sample, _ := input.pop(); sample != nil {
				t.Fatal("multi-NAL AU escaped before its marker")
			}
			push(12000, true, []byte{0x61, 0x82})
			sample, timestamp := input.pop()
			if sample == nil || timestamp != 12000 ||
				!bytes.Equal(sample.Data, []byte{0, 0, 0, 1, 0x61, 0x81, 0, 0, 0, 1, 0x61, 0x82}) {
				t.Fatal("quiet multi-NAL frame did not resume on the original RTP timeline")
			}

			// Drain after every arrival, as run.write does. Padding occupies a
			// sequence between real FU fragments but has no media timestamp.
			requestsBefore := requests
			completeNAL := append([]byte{0x61}, bytes.Repeat([]byte{0x55}, 70)...)
			payloads = payloader.Payload(16, completeNAL)
			packets := make([]*rtp.Packet, 0, len(payloads)+1)
			for i, payload := range payloads {
				packets = append(packets, &rtp.Packet{Header: rtp.Header{Version: 2,
					SequenceNumber: sequence, Timestamp: 15000, Marker: i == len(payloads)-1}, Payload: payload})
				sequence++
				if i == 0 {
					padding := &rtp.Packet{Header: rtp.Header{Version: 2, Padding: true,
						SequenceNumber: sequence}, PaddingSize: 4}
					wire, err := padding.Marshal()
					if err != nil {
						t.Fatal(err)
					}
					padding = &rtp.Packet{}
					if err = padding.Unmarshal(wire); err != nil {
						t.Fatal(err)
					}
					if len(padding.Payload) != 0 {
						t.Fatal("fixture is not padding-only RTP")
					}
					packets = append(packets, padding)
					sequence++
				}
			}
			// The SDK must also keep a middle fragment behind its missing
			// predecessor after earlier packets have already been consumed.
			packets[2], packets[3] = packets[3], packets[2]
			assembled = 0
			for _, packet := range packets {
				if err := input.push(packet); err != nil {
					t.Fatal(err)
				}
				for sample, timestamp := input.pop(); sample != nil; sample, timestamp = input.pop() {
					assembled++
					if timestamp != 15000 || !bytes.Equal(sample.Data, append([]byte{0, 0, 0, 1}, completeNAL...)) {
						t.Fatal("padding or reordering changed the complete FU access unit")
					}
				}
			}
			if assembled != 1 || requests != requestsBefore {
				t.Fatalf("FU with padding/reordering: complete=%d recovery requests=%d", assembled, requests-requestsBefore)
			}
		})
	}
}

func TestRelayFrameTimingUsesOneSourceClockAcrossWrap(t *testing.T) {
	clock := utils.NewWrapAround[uint32, uint64](utils.WrapAroundParams{})
	anchor := uint32(0xfffff000)
	clock.Update(anchor)
	for _, sample := range []struct {
		ticks         uint32
		pts, duration time.Duration
	}{
		{3000, time.Second / 30, 0}, // First frame retains the caller's nominal fallback.
		{6000, time.Second / 15, time.Second / 30},
		{3000, time.Second / 30, 0}, // Reordering cannot create a negative interval.
		{9000, 100 * time.Millisecond, time.Second / 30},
	} {
		pts, duration, ok := relayFrameTiming(clock, anchor+sample.ticks)
		if !ok || pts != sample.pts || duration != sample.duration {
			t.Fatalf("source ticks %d: pts=%v duration=%v accepted=%v", sample.ticks, pts, duration, ok)
		}
	}
	if _, _, ok := relayFrameTiming(clock, anchor-1); ok {
		t.Fatal("frame before the source anchor was accepted")
	}
}