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.1 KB
Raw Blame
package mediaedge

import (
	"errors"
	"fmt"
	"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/livekit/mediatransportutil"
	"github.com/pion/rtcp"
	"github.com/pion/rtp"
)

type groupTestConsumer struct{ source *forwarding.Source }

func (consumer *groupTestConsumer) CurrentSource() *forwarding.Source { return consumer.source }
func (consumer *groupTestConsumer) ReplaceSource(next *forwarding.Source) error {
	consumer.source = next
	return nil
}

func TestOutputGroupsShareSplitRejoinAndRetire(t *testing.T) {
	engine := &Engine{}
	source, err := engine.NewSource("vp8", 2, 2, nil)
	if err != nil {
		t.Fatal(err)
	}
	defer source.Close()
	if err = source.SetFormat(0, 640, 360); err != nil {
		t.Fatal(err)
	}
	if err = source.SetFormat(1, 1280, 720); err != nil {
		t.Fatal(err)
	}
	if err = source.ConfigureOutputs([]uint32{500_000, 2_000_000, 500_000, 500_000}); err != nil {
		t.Fatal(err)
	}
	a, b := &groupTestConsumer{source.media.Source}, &groupTestConsumer{source.media.Source}
	demands := []outputDemand{{consumer: a, budget: 100_000, active: true, lower: true}, {consumer: b, budget: 100_000, active: true, lower: true}}
	var tick time.Duration
	plan := func() OutputPlan {
		t.Helper()
		source.writeMu.Lock()
		defer source.writeMu.Unlock()
		tick += time.Second
		if err := source.beginGroupFrame(tick, time.Unix(0, 0).Add(tick)); err != nil {
			t.Fatal(err)
		}
		value, err := source.planGroups(demands)
		if err != nil {
			t.Fatal(err)
		}
		return value
	}
	shared := plan()
	if source.memberships[a] != source.memberships[b] || len(source.groups) != 1 || shared.Bitrates[0] != 100_000 || shared.Active[1] {
		t.Fatal("compatible consumers did not share one output")
	}
	demands[1].budget = 300_000
	split := plan()
	ga, gb := source.memberships[a], source.memberships[b]
	if ga == gb || split.Bitrates[ga.slot] != 100_000 || split.Bitrates[gb.slot] != 300_000 || b.CurrentSource() != source.media.Source {
		t.Fatal("different budgets coupled or moved before recovery")
	}
	source.installGroup(gb, false)
	if b.CurrentSource() != gb.media.Source {
		t.Fatal("recovery did not install prepared group")
	}
	demands[0].budget = 60_000
	changed := plan()
	if source.memberships[a] != ga || source.memberships[b] != gb || changed.Bitrates[gb.slot] != 300_000 {
		t.Fatal("one consumer's rate change altered its sibling")
	}
	demands[0].budget = 300_000
	plan()
	if source.memberships[a] != gb || a.CurrentSource() != source.media.Source {
		t.Fatal("compatible rejoin bypassed recovery")
	}
	source.installGroup(gb, false)
	rejoined := plan()
	if rejoined.Active[ga.slot] || !rejoined.Active[gb.slot] {
		t.Fatal("unused encoder did not retire after rejoin")
	}
	demands[0].lower = false
	demands[0].original = true
	pending := plan()
	if !pending.Active[1] || !pending.Active[gb.slot] || a.CurrentSource() != gb.media.Source {
		t.Fatal("original handoff retired active source")
	}
	source.installGroup(nil, true)
	if a.CurrentSource() != source.media.Source || b.CurrentSource() != gb.media.Source {
		t.Fatal("original handoff moved sibling")
	}
	demands = demands[:1]
	retired := plan()
	if retired.Active[gb.slot] {
		t.Fatal("last lower member did not release its encoder")
	}
	demands[0].active = false
	if inactive := plan(); inactive.Active[ga.slot] || inactive.Active[gb.slot] {
		t.Fatal("disconnected consumer kept an output active")
	}
	demands[0].active = true
	demands[0].lower = true
	demands[0].original = false
	demands[0].budget = 300_000
	reactivated := plan()
	if !reactivated.Active[gb.slot] || reactivated.Active[1] || source.memberships[a] != gb {
		t.Fatal("inactive compatible group could not reactivate")
	}
	source.installGroup(gb, false)
	started := gb.start
	source.groupRecovery.Store(0)
	demands[0].budget = ga.budget
	repriced := plan()
	if source.memberships[a] != gb || a.CurrentSource() != gb.media.Source ||
		!repriced.Active[gb.slot] || repriced.Active[ga.slot] || repriced.Bitrates[gb.slot] != ga.budget ||
		gb.start != started || source.groupRecovery.Load() != 0 {
		t.Fatalf("inactive budget match replaced live pipeline: member=%v source=%v active=%v rate=%d want=%d start=%v/%v recovery=%d", source.memberships[a] == gb, a.CurrentSource() == gb.media.Source, repriced.Active, repriced.Bitrates[gb.slot], ga.budget, gb.start, started, source.groupRecovery.Load())
	}
	c := &groupTestConsumer{source.media.Source}
	demands = append(demands, outputDemand{consumer: c, budget: ga.budget, active: true, lower: true})
	plan()
	if source.memberships[c] != gb {
		t.Fatal("inactive budget match took precedence over a compatible active output")
	}
	source.installGroup(gb, false)
	if settled := plan(); settled.Active[ga.slot] || c.CurrentSource() != gb.media.Source {
		t.Fatal("last handoff retained an unneeded output")
	}
	if err = gb.media.BeginFrame(tick+time.Nanosecond, time.Unix(0, 0).Add(tick+time.Nanosecond)); err != nil {
		t.Fatal(err)
	}
}

type groupLowOnlyReceiver struct{ sfu.TrackReceiver }

func (receiver groupLowOnlyReceiver) GetLayeredBitrate() ([]int32, sfu.Bitrates) {
	return []int32{0}, sfu.Bitrates{{100_000}}
}

func TestOutputGroupsHonorOriginalTransportDemand(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", 2, 2, nil)
	check(err)
	defer source.Close()
	check(source.SetFormat(0, 640, 360))
	check(source.SetFormat(1, 1280, 720))
	check(source.ConfigureOutputs([]uint32{500_000, 2_000_000, 500_000}))
	edge, receiver, _ := connectedReceiver(t, engine, source, "original-demand")
	defer receiver.Close()
	plan := func(label string, original bool) {
		t.Helper()
		source.writeMu.Lock()
		defer source.writeMu.Unlock()
		value, err := source.planGroups(source.collectDemands([]*Edge{edge}, nil))
		check(err)
		if !value.Active[0] || value.Active[1] != original {
			t.Fatalf("%s plan = %+v, state = %+v", label, value, edge.transport.Output.State())
		}
	}
	plan("initial acquisition", true)
	output := edge.transport.Output
	deadline := time.Now().Add(3 * time.Second)
	for frame := 0; output.State().Current != 1; frame++ {
		if time.Now().After(deadline) {
			t.Fatalf("original never forwarded: %+v", output.State())
		}
		pts := time.Duration(frame) * time.Second / 30
		_, err = source.BeginFrame(pts)
		check(err)
		for layer := range 2 {
			check(source.WriteVideo(layer, encoded.Frame{Data: sfu.VP8KeyFrame8x8, PTS: pts,
				Duration: time.Second / 30, Recovery: true}))
		}
		time.Sleep(time.Second / 30)
	}
	plan("original target", true)
	check(edge.SetTargetLayer(0))
	if state := output.State(); state.Target != 0 || state.Current != 1 || state.Paused {
		t.Fatalf("fixture did not retain current original during lower handoff: %+v", state)
	}
	plan("original still current", true)
	output.BeginFrame()
	plan("lower handoff", false)
	edge.local = true
	plan("local lower preview", false)
	edge.local = false

	// Only the low representation is available; metadata may prepare the
	// dormant original, but may not invent its measured availability.
	output.SetReceiver(groupLowOnlyReceiver{TrackReceiver: output.Receiver()})
	edge.transport.OnTransportCCFeedback(nil, &rtcp.TransportLayerCC{})
	output.SetMaxSpatialLayer(1)
	output.SetBudget(200_000)
	plan("limited budget", false)
	output.SetBudget(2_000_000)
	// SetReceiver reset the framework's acquired layer. Its acquisition target
	// may aim at the original, but only the low layer is actually available for
	// requesting a frame; preparation is separate from accepted forwarding.
	if state := output.State(); state.Requested != 0 || state.Current > 0 || state.Prepare != 1 {
		t.Fatalf("higher budget did not prepare the dormant original: %+v", state)
	}
	plan("higher budget preparation", true)

	publication, err := engine.NewPublication(source, EdgeOptions{ConnectionID: "original-publication"})
	check(err)
	check(publication.transport.SetConnected())
	for _, count := range []int{1, 2, 0} {
		check(publication.transport.SetActiveCount(count))
		source.writeMu.Lock()
		value, err := source.planGroups(source.collectDemands(nil, []*Publication{publication}))
		source.writeMu.Unlock()
		check(err)
		if value.Active[0] != (count > 0) || value.Active[1] != (count > 1) {
			t.Fatalf("publication demand %d plan = %+v", count, value)
		}
	}
}

func newGroupLifecycleFixture(t *testing.T) (*Source, *groupTestConsumer, *outputGroup, []outputDemand) {
	t.Helper()
	source, err := (&Engine{}).NewSource("vp8", 2, 2, nil)
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = source.Close() })
	for layer, size := range [][2]uint32{{640, 360}, {1280, 720}} {
		if err = source.SetFormat(layer, size[0], size[1]); err != nil {
			t.Fatal(err)
		}
	}
	if err = source.ConfigureOutputs([]uint32{500_000, 2_000_000, 500_000, 500_000}); err != nil {
		t.Fatal(err)
	}
	a, b := &groupTestConsumer{source.media.Source}, &groupTestConsumer{source.media.Source}
	demands := []outputDemand{{consumer: a, budget: 100_000, active: true, lower: true},
		{consumer: b, budget: 300_000, active: true, lower: true}}
	if err = source.beginGroupFrame(10*time.Second, time.Unix(100, 0)); err != nil {
		t.Fatal(err)
	}
	if _, err = source.planGroups(demands); err != nil {
		t.Fatal(err)
	}
	group := source.memberships[b]
	if group == nil || group.slot < 2 {
		t.Fatal("fixture did not prepare an independent lower group")
	}
	return source, b, group, demands
}

func TestOutputGroupsPreserveCurrentDemandDuringAdmission(t *testing.T) {
	for _, pending := range []bool{false, true} {
		for _, reverse := range []bool{false, true} {
			t.Run(fmt.Sprintf("pending=%v/reverse=%v", pending, reverse), func(t *testing.T) {
				source, b, gb, demands := newGroupLifecycleFixture(t)
				a := demands[0].consumer
				ga := source.memberships[a]
				source.installGroup(ga, false)
				source.installGroup(gb, false)
				groupCount := len(source.groups)
				demands[1].budget = 100_000
				if pending {
					if _, err := source.planGroups(demands); err != nil {
						t.Fatal(err)
					}
					if source.memberships[b] != ga || b.CurrentSource() != gb.media.Source {
						t.Fatal("fixture did not prepare a compatible rejoin")
					}
				}
				source.groupRecovery.Store(0)
				demands[0].budget = 60_000
				if reverse {
					demands[0], demands[1] = demands[1], demands[0]
				}
				plan, err := source.planGroups(demands)
				if err != nil {
					t.Fatal(err)
				}
				if source.memberships[a] != ga || source.memberships[b] != gb || len(source.groups) != groupCount ||
					plan.Bitrates[ga.slot] != 60_000 || plan.Bitrates[gb.slot] != 100_000 || source.groupRecovery.Load() != 0 {
					t.Fatalf("admission displaced an incumbent: a=%v b=%v groups=%d/%d rates=%v recovery=%d",
						source.memberships[a] == ga, source.memberships[b] == gb, len(source.groups), groupCount,
						plan.Bitrates, source.groupRecovery.Load())
				}
			})
		}
	}
}

func TestOutputGroupsRetainOriginalRecoveryAfterPendingJoin(t *testing.T) {
	source, b, gb, demands := newGroupLifecycleFixture(t)
	source.installGroup(source.memberships[demands[0].consumer], false)
	source.installGroup(gb, false)
	demands[1].budget = demands[0].budget
	if _, err := source.planGroups(demands); err != nil {
		t.Fatal(err)
	}
	source.groupRecovery.Store(0)
	demands[0].budget = 60_000
	demands[1].lower, demands[1].original = false, true
	if _, err := source.planGroups(demands); err != nil {
		t.Fatal(err)
	}
	if source.memberships[b] != nil || source.groupRecovery.Load()&2 == 0 || b.CurrentSource() != gb.media.Source {
		t.Fatal("return to original lost recovery or replaced the current source early")
	}
}

func TestOutputGroupRejectsRecoveryBeforeChangingAttachment(t *testing.T) {
	for _, path := range []string{"derived", "original"} {
		for _, stamp := range []string{"future", "duplicate", "before-generation-start"} {
			t.Run(path+"/"+stamp, func(t *testing.T) {
				source, consumer, group, _ := newGroupLifecycleFixture(t)
				slot := group.slot
				if path == "original" {
					slot = 1
				}
				frame := encoded.Frame{Data: sfu.VP8KeyFrame8x8, PTS: 10 * time.Second,
					Duration: time.Second / 30, Recovery: true}
				if err := source.WriteVideo(slot, frame); err != nil {
					t.Fatal(err)
				}
				if path == "original" {
					source.installGroup(group, false)
					source.memberships[consumer] = nil
				} else {
					consumer.source = source.media.Source
				}
				previous := consumer.CurrentSource()
				if stamp == "future" {
					frame.PTS = 11 * time.Second
				} else if stamp == "before-generation-start" {
					source.BeginGeneration()
					if err := source.beginGroupFrame(time.Second, time.Unix(200, 0)); err != nil {
						t.Fatal(err)
					}
					frame.PTS = time.Second / 2
				}
				if err := source.WriteVideo(slot, frame); err == nil {
					t.Fatal("recovery without a valid input timestamp was accepted")
				}
				if consumer.CurrentSource() != previous {
					t.Fatal("rejected recovery changed the consumer's source")
				}
			})
		}
	}
}

func TestOutputGroupReactivationRejectsEarlierAccessUnits(t *testing.T) {
	source, consumer, group, demands := newGroupLifecycleFixture(t)
	source.installGroup(group, false)
	demands[1].lower = false
	demands[1].original = true
	if _, err := source.planGroups(demands); err != nil {
		t.Fatal(err)
	}
	source.installGroup(nil, true)
	if _, err := source.planGroups(demands); err != nil {
		t.Fatal(err)
	}
	if group.active {
		t.Fatal("retired group remained active")
	}
	if err := source.beginGroupFrame(12*time.Second, time.Unix(102, 0)); err != nil {
		t.Fatal(err)
	}
	demands[1].lower = true
	demands[1].original = false
	if _, err := source.planGroups(demands); err != nil {
		t.Fatal(err)
	}
	frame := encoded.Frame{Data: sfu.VP8KeyFrame8x8, PTS: 11 * time.Second,
		Duration: time.Second / 30, Recovery: true}
	if err := source.WriteVideo(group.slot, frame); err != nil {
		t.Fatal(err)
	}
	if consumer.CurrentSource() != source.media.Source {
		t.Fatal("earlier recovery installed a reactivated group")
	}
	if err := source.WriteVideo(1, frame); err != nil {
		t.Fatal(err)
	}
	if report := group.media.GetAllBuffers()[1].GetSenderReportData(); report != nil {
		t.Fatal("reactivated group borrowed an earlier original access unit")
	}
	frame.PTS = 12 * time.Second
	if err := source.WriteVideo(group.slot, frame); err != nil {
		t.Fatal(err)
	}
	if consumer.CurrentSource() != group.media.Source {
		t.Fatal("current recovery did not install the reactivated group")
	}
}

func TestOutputGroupGenerationRefreshesMetadataAndClock(t *testing.T) {
	source, consumer, group, _ := newGroupLifecycleFixture(t)
	frame := encoded.Frame{Data: sfu.VP8KeyFrame8x8, PTS: 10 * time.Second,
		Duration: time.Second / 30, Recovery: true}
	if err := source.WriteVideo(group.slot, frame); err != nil {
		t.Fatal(err)
	}
	previous := group.media.GetAllBuffers()[0].GetSenderReportData()
	if previous == nil || consumer.CurrentSource() != group.media.Source {
		t.Fatal("group did not establish its original clock and attachment")
	}
	previousTimestamp := previous.RtpTimestamp
	source.BeginGeneration()
	for layer, size := range [][2]uint32{{426, 240}, {854, 480}} {
		if err := source.SetFormat(layer, size[0], size[1]); err != nil {
			t.Fatal(err)
		}
	}
	if err := source.ConfigureOutputs([]uint32{400_000, 1_600_000, 400_000, 400_000}); err != nil {
		t.Fatal(err)
	}
	if err := source.SetFormat(group.slot, 320, 180); err != nil {
		t.Fatal(err)
	}
	info := group.media.TrackInfo()
	if source.groups[group.slot] != group || consumer.CurrentSource() != group.media.Source ||
		info.Layers[0].Width != 320 || info.Layers[0].Height != 180 || info.Layers[0].Bitrate != 400_000 ||
		info.Layers[1].Width != 854 || info.Layers[1].Height != 480 || info.Layers[1].Bitrate != 1_600_000 {
		t.Fatal("replacement source changed group identity or retained old metadata")
	}
	at := time.Unix(200, 0)
	if err := source.beginGroupFrame(time.Second, at); err != nil {
		t.Fatal(err)
	}
	frame.PTS = time.Second
	if err := source.WriteVideo(group.slot, frame); err != nil {
		t.Fatal(err)
	}
	report := group.media.GetAllBuffers()[0].GetSenderReportData()
	if report == nil || report.RtpTimestamp-previousTimestamp != 100*90_000 {
		t.Fatal("new capture generation broke the group RTP clock")
	}
	correlated, ok := group.media.ReferenceTime(0, report.RtpTimestamp)
	if !ok || correlated.Sub(at) < -time.Microsecond || correlated.Sub(at) > time.Microsecond {
		t.Fatalf("new generation correlation = %v, available=%v", correlated, ok)
	}
}

func TestLateOutputGroupKeepsSharedCaptureClock(t *testing.T) {
	source, _, _, _ := newGroupLifecycleFixture(t)
	// The capture clock advances one second while input-pipe latency grows.
	if err := source.beginGroupFrame(11*time.Second, time.Unix(101, 500_000_000)); err != nil {
		t.Fatal(err)
	}
	group, err := source.newGroup(3)
	if err != nil {
		t.Fatal(err)
	}
	write := func(pts time.Duration, expected time.Time) uint32 {
		t.Helper()
		var timestamp uint32
		for _, media := range []*forwarding.EncodedSource{source.media, group.media} {
			if err := media.WriteFrame(0, encoded.Frame{Data: sfu.VP8KeyFrame8x8,
				PTS: pts, Duration: time.Second / 30, Recovery: true}); err != nil {
				t.Fatal(err)
			}
			report := media.GetAllBuffers()[0].GetSenderReportData()
			if report == nil {
				t.Fatal("output did not establish its capture clock")
			}
			at, ok := media.ReferenceTime(0, report.RtpTimestamp)
			if !ok || at.Sub(expected).Abs() > time.Microsecond {
				t.Fatalf("output capture clock = %v, expected %v", at, expected)
			}
			timestamp = report.RtpTimestamp
		}
		return timestamp
	}
	previous := write(11*time.Second, time.Unix(101, 0))
	source.BeginGeneration()
	if err := source.beginGroupFrame(time.Second, time.Unix(200, 0)); err != nil {
		t.Fatal(err)
	}
	current := write(time.Second, time.Unix(200, 0))
	if advance := current - previous; advance != 99*90_000 {
		t.Fatalf("replacement group RTP timestamp advanced %d ticks", advance)
	}
}

func TestCaptureGenerationNormalizesOneSharedClock(t *testing.T) {
	source, err := (&Engine{}).NewSource("vp8", 2, 2, nil)
	if err != nil {
		t.Fatal(err)
	}
	defer source.Close()
	if err = source.ConfigureOutputs([]uint32{500_000, 2_000_000, 500_000, 500_000}); err != nil {
		t.Fatal(err)
	}
	if err = source.beginGroupFrame(10*time.Second, time.Unix(100, 0)); 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)
	}
	write := func(media *forwarding.EncodedSource, layer int, pts time.Duration, expected time.Time) {
		t.Helper()
		if err := media.WriteFrame(layer, encoded.Frame{Data: sfu.VP8KeyFrame8x8,
			PTS: pts, Duration: time.Second / 30, Recovery: true}); err != nil {
			t.Fatal(err)
		}
		report := media.GetAllBuffers()[layer].GetSenderReportData()
		at, ok := media.ReferenceTime(layer, report.RtpTimestamp)
		if !ok || at.Sub(expected).Abs() > time.Microsecond {
			t.Fatalf("output clock = %v, expected %v", at, expected)
		}
	}
	for _, media := range []*forwarding.EncodedSource{source.media, group.media} {
		for layer := range 2 {
			write(media, layer, 10*time.Second, time.Unix(100, 0))
		}
	}
	// Later input completes faster than the first one. Its capture timeline
	// advances to 101 even though the input arrives at 100.1.
	if err := source.beginGroupFrame(11*time.Second, time.Unix(100, 100_000_000)); err != nil {
		t.Fatal(err)
	}
	write(source.media, 0, 11*time.Second, time.Unix(101, 0))
	source.BeginGeneration()
	if err := source.beginGroupFrame(0, time.Unix(100, 200_000_000)); err != nil {
		t.Fatal(err)
	}
	origin := time.Unix(101, 0).Add(time.Second/videoClockRate + time.Nanosecond)
	write(source.media, 0, 0, origin)
	late, err := source.newGroup(3)
	if err != nil {
		t.Fatal(err)
	}
	// Original and derived outputs resume after different dormant intervals;
	// the newly created group inherits the same normalized generation origin.
	if err = source.beginGroupFrame(5*time.Second, time.Unix(100, 300_000_000)); err != nil {
		t.Fatal(err)
	}
	for _, media := range []*forwarding.EncodedSource{source.media, group.media, late.media} {
		for layer := range 2 {
			write(media, layer, 5*time.Second, origin.Add(5*time.Second))
		}
	}
	if err = source.beginGroupFrame(4*time.Second, time.Unix(200, 0)); !errors.Is(err, encoded.ErrInvalidTimestamp) {
		t.Fatalf("same-generation reverse PTS = %v", err)
	}
	source.BeginGeneration()
	if err = source.beginGroupFrame(0, time.Unix(200, 0)); err != nil {
		t.Fatal(err)
	}
	write(source.media, 0, 0, time.Unix(200, 0))
}

func TestRelayGroupSharesReceivedClockAcrossWrap(t *testing.T) {
	check := func(err error) {
		t.Helper()
		if err != nil {
			t.Fatal(err)
		}
	}
	source, err := (&Engine{}).newSource("vp8", 2, 2, &RelayOptions{}, nil)
	check(err)
	defer source.Close()
	check(source.SetFormat(0, 8, 8))
	check(source.SetFormat(1, 8, 8))
	check(source.ConfigureOutputs([]uint32{100_000, 1_000_000, 100_000, 100_000}))
	source.groups = make(map[int]*outputGroup)
	source.memberships = make(map[groupConsumer]*outputGroup)
	origin := time.Now()
	write := func(sequence uint16, timestamp uint32, pts time.Duration) {
		t.Helper()
		check(source.beginGroupFrame(pts, origin.Add(pts)))
		check(source.WriteRTP(&rtp.Packet{Header: rtp.Header{
			Version: 2, SSRC: 99, PayloadType: 96, SequenceNumber: sequence, Timestamp: timestamp, Marker: true,
		}, Payload: append([]byte{0x10}, sfu.VP8KeyFrame8x8...)}))
		if group := source.groups[2]; group != nil && group.active {
			copied := group.media.GetAllBuffers()[1].GetSenderReportData()
			accepted := source.media.GetAllBuffers()[1].GetSenderReportData()
			if copied == nil || copied.RtpTimestamp != accepted.RtpTimestamp || copied.NtpTimestamp != accepted.NtpTimestamp {
				t.Fatal("first copied RTP waited for another wire report")
			}
		}
		check(source.SenderReport(&rtcp.SenderReport{SSRC: 99, RTPTime: timestamp,
			NTPTime:     uint64(mediatransportutil.ToNtpTime(origin.Add(pts))),
			PacketCount: uint32(sequence), OctetCount: uint32(sequence) * 20}))
	}
	write(1, 0xffff_ff00, 0)
	write(2, 644, 10*time.Millisecond)
	// The original already observed the path; a later group first sees a delayed
	// report. That internal copy must not establish another network clock.
	time.Sleep(120 * time.Millisecond)
	group, err := source.newGroup(2)
	check(err)
	group.active = true
	earlier := &rtcp.SenderReport{SSRC: 99, RTPTime: 0xffff_ff00,
		NTPTime: uint64(mediatransportutil.ToNtpTime(origin)), PacketCount: 1, OctetCount: 20}
	check(source.SenderReport(earlier))
	if group.media.GetAllBuffers()[1].GetSenderReportData() != nil {
		t.Fatal("a group without RTP accepted a sender report")
	}
	write(3, 1544, 20*time.Millisecond)
	check(source.WriteVideo(2, encoded.Frame{Data: sfu.VP8KeyFrame8x8,
		PTS: 20 * time.Millisecond, Duration: time.Second / 30, Recovery: true}))
	// A delayed older wire report is rejected by the original owner before
	// either internal copy can adopt it.
	check(source.SenderReport(earlier))
	base := source.media.GetAllBuffers()[1].GetSenderReportData()
	copied := group.media.GetAllBuffers()[1].GetSenderReportData()
	if base == nil || copied == nil || base.RtpTimestamp != copied.RtpTimestamp ||
		base.NtpTimestamp != copied.NtpTimestamp || base.Packets != copied.Packets || base.Octets != copied.Octets {
		t.Fatal("copied original changed the accepted sender report")
	}
	if base.RtpTimestampExt-copied.RtpTimestampExt != 1<<32 {
		t.Fatal("late group did not retain its own RTP wrap epoch")
	}
	for _, media := range []*forwarding.EncodedSource{source.media, group.media} {
		for layer, buffer := range media.GetAllBuffers() {
			if buffer == nil || buffer.GetSenderReportData() == nil {
				continue
			}
			local, ok := media.LocalTime(layer, origin.Add(20*time.Millisecond))
			if !ok || local.UnixNano() != base.AtAdjusted {
				t.Fatalf("layer %d split the received clock: local=%v expected=%v", layer, local, time.Unix(0, base.AtAdjusted))
			}
		}
	}
	group.active = false
	write(4, 3344, 40*time.Millisecond)
	consumer := &groupTestConsumer{group.media.Source}
	_, err = source.planGroups([]outputDemand{{consumer: consumer, budget: group.budget, active: true, lower: true}})
	check(err)
	if !group.active {
		t.Fatal("fixture did not reactivate the relay group")
	}
	write(5, 4244, 50*time.Millisecond)
}