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

6.4 KB
Raw Blame
package forwarding

import (
	"bytes"
	"testing"
	"time"

	"github.com/livekit/livekit-server/pkg/sfu"
	"github.com/livekit/livekit-server/pkg/sfu/buffer"
	"github.com/livekit/mediatransportutil"
	"github.com/livekit/protocol/livekit"
	"github.com/pion/interceptor"
	"github.com/pion/rtcp"
	"github.com/pion/rtp"
	"github.com/pion/transport/v5/packetio"
	"github.com/pion/webrtc/v4"
)

// Bind at Pion's public TrackLocal boundary. Source buffers and the LiveKit
// forwarder run unchanged; the writer observes the exact RTP given to SRTP.
type audioTrackContext struct {
	webrtc.TrackLocalContext
	codec   webrtc.RTPCodecParameters
	packets chan *rtp.Packet
}

func (context *audioTrackContext) CodecParameters() []webrtc.RTPCodecParameters {
	return []webrtc.RTPCodecParameters{context.codec}
}
func (*audioTrackContext) SSRC() webrtc.SSRC                            { return 9000 }
func (*audioTrackContext) SSRCRetransmission() webrtc.SSRC              { return 0 }
func (context *audioTrackContext) WriteStream() webrtc.TrackLocalWriter { return context }
func (context *audioTrackContext) WriteRTP(header *rtp.Header, payload []byte) (int, error) {
	context.packets <- &rtp.Packet{Header: header.Clone(), Payload: bytes.Clone(payload)}
	return header.MarshalSize() + len(payload), nil
}
func (context *audioTrackContext) Write(data []byte) (int, error) {
	packet := &rtp.Packet{}
	if err := packet.Unmarshal(data); err != nil {
		return 0, err
	}
	return context.WriteRTP(&packet.Header, packet.Payload)
}

func TestAudioOutputRetainsClockAcrossInputLifetimeAndPacketLoss(t *testing.T) {
	check := func(err error) {
		t.Helper()
		if err != nil {
			t.Fatal(err)
		}
	}
	codec := webrtc.RTPCodecParameters{PayloadType: 111, RTPCodecCapability: webrtc.RTPCodecCapability{
		MimeType: webrtc.MimeTypeOpus, ClockRate: 48_000, Channels: 2, SDPFmtpLine: "minptime=10;useinbandfec=1",
	}}
	settings, registry := webrtc.SettingEngine{}, &interceptor.Registry{}
	factory, err := ConfigureAudioForwarding(&settings, registry, func(uint32) *sfu.DownTrack { return nil })
	check(err)
	output, err := NewAudioOutput(AudioOutputOptions{ID: "slot", StreamID: "room", Codec: codec,
		BufferFactory: factory, RTCPWriter: func([]rtcp.Packet) error { return nil },
	})
	check(err)
	t.Cleanup(output.Close)
	context := &audioTrackContext{codec: codec, packets: make(chan *rtp.Packet, 32)}
	_, err = output.Track().Bind(context)
	check(err)
	output.SetConnected()
	makeSource := func(id string, ssrc uint32) *Source {
		t.Helper()
		source, err := NewSource(SourceOptions{ID: id, StreamID: id, Codec: codec})
		check(err)
		t.Cleanup(source.Close)
		check(source.BindLayer(0, ssrc, webrtc.RTPParameters{Codecs: []webrtc.RTPCodecParameters{codec}}))
		if info := source.TrackInfo(); info.Type != livekit.TrackType_AUDIO || len(info.Layers) != 0 {
			t.Fatalf("audio acquired video allocation metadata: %+v", info)
		}
		return source
	}
	write := func(source *Source, ssrc uint32, sequence uint16, timestamp uint32) *rtp.Packet {
		t.Helper()
		check(source.WriteRTP(0, &rtp.Packet{Header: rtp.Header{Version: 2, PayloadType: 111,
			SSRC: ssrc, SequenceNumber: sequence, Timestamp: timestamp}, Payload: []byte{0xf8, 0xff, 0xfe}}))
		select {
		case packet := <-context.packets:
			return packet
		case <-time.After(time.Second):
			t.Fatal("audio did not reach the bound output")
			return nil
		}
	}
	first := makeSource("first", 1000)
	check(output.ReplaceSource(first))
	stale := first.GetDownTracks()[0]
	a := write(first, 1000, 20_000, 9_600_000)
	b := write(first, 1000, 20_001, 9_600_960)
	if b.SequenceNumber-a.SequenceNumber != 1 || b.Timestamp-a.Timestamp != 960 {
		t.Fatal("ordinary audio timing changed")
	}
	// Preserve a lost packet's sequence/timestamp space and a later DTX gap.
	c := write(first, 1000, 20_003, 9_602_880)
	late := write(first, 1000, 20_002, 9_601_920)
	d := write(first, 1000, 20_004, 9_607_680)
	if c.SequenceNumber-b.SequenceNumber != 2 || c.Timestamp-b.Timestamp != 1920 ||
		late.SequenceNumber-b.SequenceNumber != 1 || late.Timestamp-b.Timestamp != 960 ||
		d.SequenceNumber-c.SequenceNumber != 1 || d.Timestamp-c.Timestamp != 4800 {
		t.Fatal("loss or DTX was compressed out of the output timeline")
	}
	check(first.SenderReport(0, &rtcp.SenderReport{SSRC: 1000, RTPTime: 9_607_680,
		NTPTime: uint64(mediatransportutil.ToNtpTime(time.Now())), PacketCount: 4, OctetCount: 12}))
	if report := output.DownTrack().CreateSenderReport(); report == nil || report.SSRC != a.SSRC {
		t.Fatal("output did not retain its own sender report identity")
	}
	next := makeSource("next", 2000)
	check(output.ReplaceSource(next))
	// A detached source's already queued close/report cannot retire or re-clock
	// the reusable slot. The source itself may close after the new one attaches.
	stale.Close()
	check(stale.HandleRTCPSenderReportData(111, 0, nil))
	if stale.WriteRTP(&buffer.ExtPacket{Packet: &rtp.Packet{}}, 0) != 0 {
		t.Fatal("a detached broadcast wrote into the replacement")
	}
	first.Close()
	e := write(next, 2000, 1000, 480_000)
	if e.SSRC != d.SSRC || e.SequenceNumber-d.SequenceNumber != 1 || int32(e.Timestamp-d.Timestamp) <= 0 {
		t.Fatalf("independent input clock escaped into the reused slot: before=%+v after=%+v", d.Header, e.Header)
	}
	// Closing the current input detaches it, while the same output remains usable
	// for a later publication, including one which reuses its predecessor's SSRC.
	next.Close()
	if output.DownTrack().IsClosed() || output.receiver != output.idle {
		t.Fatal("input retirement destroyed the reusable output slot")
	}
	last := makeSource("last", 2000)
	check(output.ReplaceSource(last))
	f := write(last, 2000, 100, 48_000)
	if f.SSRC != e.SSRC || f.SequenceNumber-e.SequenceNumber != 1 || int32(f.Timestamp-e.Timestamp) <= 0 {
		t.Fatal("a later input could not resume the existing output clock")
	}
	output.DetachSource()
	if len(last.GetDownTracks()) != 0 || output.DownTrack().IsClosed() {
		t.Fatal("subscription removal did not detach the live input")
	}
	// The shared factory claims only outgoing DownTrack RTCP; ingress reports
	// must still be readable by the receiving connection's ordinary RTCP loop.
	input := settings.BufferFactory(packetio.RTCPBufferPacket, 1234)
	defer input.Close()
	report, err := (&rtcp.SenderReport{SSRC: 1234}).Marshal()
	check(err)
	_, err = input.Write(report)
	check(err)
	read := make([]byte, 1500)
	n, err := input.Read(read)
	check(err)
	if !bytes.Equal(read[:n], report) {
		t.Fatal("incoming RTCP was consumed by an output callback")
	}
}