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

14.4 KB
Raw Blame
package forwarding

import (
	"cmp"
	"errors"
	"slices"
	"strings"
	"sync"
	"sync/atomic"
	"time"

	"github.com/TNTcraftHIM/Piik/internal/diagnostics"
	"github.com/TNTcraftHIM/Piik/internal/media/encoded"
	"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/livekit/protocol/utils"
	"github.com/livekit/protocol/utils/mono"
	"github.com/pion/rtcp"
	"github.com/pion/rtp"
	"github.com/pion/webrtc/v4"
)

type LayerFormat struct {
	Width, Height, Bitrate uint32
}

// Internal encoders and RTP copies already know the local time of their source
// RTP/NTP correlation. Received reports still need the remote clock estimate.
type sourceBuffer struct {
	*buffer.Buffer
	knownInputClock atomic.Bool
}

func (input *sourceBuffer) GetSenderReportData() *livekit.RTCPSenderReportState {
	report := input.Buffer.GetSenderReportData()
	if report != nil && input.knownInputClock.Load() {
		report.AtAdjusted = report.At
	}
	return report
}

type SourceOptions struct {
	ID, StreamID     string
	Codec            webrtc.RTPCodecParameters
	Formats          []LayerFormat
	HeaderExtensions []webrtc.RTPHeaderExtensionParameter
	MaxPackets       int
	OnRTCP           func(layer int, packets []rtcp.Packet)
}

// Source owns finite RTP layers and their mature forwarding buffers. The caller
// owns input generations, codec clocks and PeerConnections. Feedback callbacks
// run without Source's mutex and may retire the source.
type Source struct {
	*sfu.ReceiverBase
	mu                   sync.Mutex
	buffers              []*sourceBuffer
	maxPackets           int
	onRTCP               func(int, []rtcp.Packet)
	closed               bool
	currentTrackInfo     atomic.Pointer[livekit.TrackInfo]
	lowestRateControlled atomic.Bool
}

// The live codec owner sets this after startup and clears it at retirement.
func (source *Source) SetLowestLayerRateControlled(controlled bool) {
	source.lowestRateControlled.Store(controlled)
}

func (source *Source) RateControlled(layer int32) bool {
	return layer == 0 && !source.IsClosed() && source.lowestRateControlled.Load()
}

func NewSource(options SourceOptions) (*Source, error) {
	audio := strings.EqualFold(options.Codec.MimeType, webrtc.MimeTypeOpus) && options.Codec.ClockRate == 48_000
	video := options.Codec.ClockRate == 90_000 && (strings.EqualFold(options.Codec.MimeType, webrtc.MimeTypeH264) ||
		strings.EqualFold(options.Codec.MimeType, webrtc.MimeTypeVP8))
	if options.ID == "" || options.StreamID == "" || (!audio && !video) {
		return nil, errors.New("forwarded source is invalid")
	}
	minimum, defaultPackets := buffer.InitPacketBufferSizeVideo, encoded.MaxPacketWindow
	if audio {
		minimum, defaultPackets = buffer.InitPacketBufferSizeAudio, buffer.InitPacketBufferSizeAudio
	}
	if options.MaxPackets == 0 {
		options.MaxPackets = defaultPackets
	}
	if options.MaxPackets < minimum || options.MaxPackets > 1<<16 {
		return nil, errors.New("forwarded packet bound is invalid")
	}
	info := &livekit.TrackInfo{
		Sid: options.ID, Type: livekit.TrackType_VIDEO, Source: livekit.TrackSource_SCREEN_SHARE,
		MimeType: options.Codec.MimeType,
	}
	kind, layers := webrtc.RTPCodecTypeVideo, len(options.Formats)
	if audio {
		if len(options.Formats) != 0 {
			return nil, errors.New("forwarded audio cannot declare video layers")
		}
		info.Type, info.Source = livekit.TrackType_AUDIO, livekit.TrackSource_MICROPHONE
		kind, layers = webrtc.RTPCodecTypeAudio, 1
	} else {
		if err := setLayerFormats(info, options.Formats); err != nil {
			return nil, err
		}
	}
	source := &Source{
		ReceiverBase: sfu.NewReceiverBase(sfu.ReceiverBaseParams{
			TrackID: livekit.TrackID(options.ID), StreamID: options.StreamID,
			Kind: kind, Codec: options.Codec,
			HeaderExtensions: canonicalHeaderExtensions(options.HeaderExtensions), Logger: diagnostics.MediaLogger("source").WithValues("trackId", diagnostics.ID(options.ID)),
			StreamTrackerManagerConfig: sfu.DefaultStreamTrackerManagerConfig,
		}, info, sfu.ReceiverCodecStateNormal),
		buffers:    make([]*sourceBuffer, layers),
		maxPackets: options.MaxPackets, onRTCP: options.OnRTCP,
	}
	source.currentTrackInfo.Store(info)
	return source, nil
}

func (source *Source) TrackInfo() *livekit.TrackInfo {
	return utils.CloneProto(source.currentTrackInfo.Load())
}

// ReceiverBase reads initial metadata before registering the subscriber. A
// concurrent discovery notification can fall into that gap. Refresh after
// registration; DownTrack's seen-layer setters retain the highest observation.
// Replay accepted clocks so a new forwarder need not await another wire report.
func (source *Source) AddDownTrack(track sfu.TrackSender) error {
	if err := source.ReceiverBase.AddDownTrack(track); err != nil {
		return err
	}
	if source.Kind() == webrtc.RTPCodecTypeVideo {
		tracker := source.StreamTrackerManager()
		track.UpTrackMaxPublishedLayerChange(tracker.GetMaxPublishedLayer())
		track.UpTrackMaxTemporalLayerSeenChange(tracker.GetMaxTemporalLayerSeen())
	}
	for layer, input := range source.ReceiverBase.GetAllBuffers() {
		if input != nil {
			if report := input.GetSenderReportData(); report != nil {
				_ = track.HandleRTCPSenderReportData(source.Codec().PayloadType, int32(layer), report)
			}
		}
	}
	return nil
}

func (source *Source) currentSenderReport(layer int32) *livekit.RTCPSenderReportState {
	inputs := source.ReceiverBase.GetAllBuffers()
	if layer < 0 || int(layer) >= len(inputs) || inputs[layer] == nil {
		return nil
	}
	return inputs[layer].GetSenderReportData()
}

func canonicalHeaderExtensions(extensions []webrtc.RTPHeaderExtensionParameter) []webrtc.RTPHeaderExtensionParameter {
	result := slices.Clone(extensions)
	slices.SortFunc(result, func(left, right webrtc.RTPHeaderExtensionParameter) int {
		if order := cmp.Compare(left.ID, right.ID); order != 0 {
			return order
		}
		return cmp.Compare(left.URI, right.URI)
	})
	return result
}

func setLayerFormats(info *livekit.TrackInfo, formats []LayerFormat) error {
	if len(formats) < 1 || len(formats) > int(buffer.DefaultMaxLayerSpatial)+1 {
		return errors.New("forwarded video layer count is invalid")
	}
	layers := make([]*livekit.VideoLayer, len(formats))
	for index, format := range formats {
		if (format.Width == 0) != (format.Height == 0) {
			return errors.New("forwarded video layer format is invalid")
		}
		quality := livekit.VideoQuality(index)
		if index == len(formats)-1 {
			quality = livekit.VideoQuality_HIGH
		}
		layers[index] = &livekit.VideoLayer{
			Quality: quality, SpatialLayer: int32(index), Rid: buffer.DefaultVideoLayersRid[index],
			Width: format.Width, Height: format.Height, Bitrate: format.Bitrate,
		}
	}
	highest := formats[len(formats)-1]
	info.Width, info.Height = highest.Width, highest.Height
	info.Simulcast, info.Layers = len(layers) > 1, layers
	info.Codecs = []*livekit.SimulcastCodecInfo{{
		MimeType: info.MimeType, VideoLayerMode: livekit.VideoLayer_ONE_SPATIAL_LAYER_PER_STREAM, Layers: layers,
	}}
	return nil
}

// UpdateFormats changes one source owner's declared layer metadata without
// replacing its buffers or packet identities. Zero values remain unknown.
// The caller serializes updates with its capture/source generation changes.
func (source *Source) UpdateFormats(formats []LayerFormat) error {
	source.mu.Lock()
	closed, count := source.closed, len(source.buffers)
	source.mu.Unlock()
	if closed {
		return sfu.ErrReceiverClosed
	}
	if source.Kind() != webrtc.RTPCodecTypeVideo || len(formats) != count {
		return errors.New("forwarded video layer count changed")
	}
	info := source.TrackInfo()
	if err := setLayerFormats(info, formats); err != nil {
		return err
	}
	source.currentTrackInfo.Store(info)
	// The library can notify downtracks while applying metadata.
	source.UpdateTrackInfo(info)
	return nil
}

// UpdateDimensions publishes actual encoder dimensions without UpdateTrackInfo's
// mute propagation, which resets every active layer's tracker and bitrate.
func (source *Source) UpdateDimensions(layer int, width, height uint32) error {
	source.mu.Lock()
	defer source.mu.Unlock()
	if source.closed {
		return sfu.ErrReceiverClosed
	}
	if source.Kind() != webrtc.RTPCodecTypeVideo || layer < 0 || layer >= len(source.buffers) || width == 0 || height == 0 {
		return errors.New("forwarded video layer dimensions are invalid")
	}
	current := source.currentTrackInfo.Load()
	if current.Layers[layer].Width == width && current.Layers[layer].Height == height {
		return nil
	}
	info := utils.CloneProto(current)
	info.Layers[layer].Width, info.Layers[layer].Height = width, height
	info.Codecs[0].Layers[layer].Width, info.Codecs[0].Layers[layer].Height = width, height
	if layer == len(source.buffers)-1 {
		info.Width, info.Height = width, height
	}
	source.currentTrackInfo.Store(info)
	return nil
}

// BindLayer installs a single source identity. A different SSRC requires the
// caller's source-generation replacement, not silent buffer reuse.
func (source *Source) BindLayer(layer int, ssrc uint32, parameters webrtc.RTPParameters) error {
	source.mu.Lock()
	defer source.mu.Unlock()
	if source.closed {
		return sfu.ErrReceiverClosed
	}
	if layer < 0 || layer >= len(source.buffers) || ssrc == 0 {
		return sfu.ErrInvalidLayer
	}
	if source.buffers[layer] != nil {
		return sfu.ErrDuplicateLayer
	}
	codec := source.Codec()
	if !slices.ContainsFunc(parameters.Codecs, func(candidate webrtc.RTPCodecParameters) bool {
		return candidate.PayloadType == codec.PayloadType && candidate.ClockRate == codec.ClockRate &&
			strings.EqualFold(candidate.MimeType, codec.MimeType) && candidate.SDPFmtpLine == codec.SDPFmtpLine
	}) || !slices.Equal(canonicalHeaderExtensions(parameters.HeaderExtensions), source.HeaderExtensions()) {
		return errors.New("forwarded layer codec does not match the source")
	}
	for _, existing := range source.buffers {
		if existing != nil && existing.SSRC() == ssrc {
			return errors.New("forwarded video layers cannot share an SSRC")
		}
	}
	audioPackets, bitrate := buffer.InitPacketBufferSizeAudio, 0
	if source.Kind() == webrtc.RTPCodecTypeAudio {
		audioPackets = source.maxPackets
	} else {
		bitrate = int(source.TrackInfo().Layers[layer].Bitrate)
	}
	input := &sourceBuffer{Buffer: buffer.NewBuffer(ssrc, source.maxPackets, audioPackets)}
	input.SetLogger(diagnostics.MediaLogger("rtp-buffer").WithValues("trackId", diagnostics.ID(string(source.TrackID()))))
	if err := input.Bind(parameters, codec.RTPCodecCapability, bitrate); err != nil {
		_ = input.Close()
		return err
	}
	if source.onRTCP != nil {
		input.OnRtcpFeedback(func(packets []rtcp.Packet) { source.onRTCP(layer, packets) })
	}
	source.AddBuffer(input, int32(layer))
	source.buffers[layer] = input
	source.StartBuffer(input, int32(layer))
	return nil
}

func (source *Source) layerBuffer(layer int) (*sourceBuffer, error) {
	source.mu.Lock()
	defer source.mu.Unlock()
	if source.closed {
		return nil, sfu.ErrReceiverClosed
	}
	if layer < 0 || layer >= len(source.buffers) || source.buffers[layer] == nil {
		return nil, sfu.ErrInvalidLayer
	}
	return source.buffers[layer], nil
}

func (source *Source) WriteRTP(layer int, packet *rtp.Packet) error {
	input, err := source.layerBuffer(layer)
	if err != nil {
		return err
	}
	if packet == nil || packet.Version != 2 || packet.SSRC != input.SSRC() ||
		packet.PayloadType != uint8(source.Codec().PayloadType) {
		return errors.New("forwarded RTP packet does not match its layer")
	}
	data, err := packet.Marshal()
	if err != nil {
		return err
	}
	_, err = input.Write(data)
	return err
}

func (source *Source) SenderReport(layer int, report *rtcp.SenderReport) error {
	input, err := source.layerBuffer(layer)
	if err != nil {
		return err
	}
	if report == nil || report.SSRC != input.SSRC() {
		return errors.New("forwarded sender report does not match its layer")
	}
	input.SetSenderReportData(&livekit.RTCPSenderReportState{
		RtpTimestamp: report.RTPTime, NtpTimestamp: report.NTPTime,
		Packets: report.PacketCount, Octets: uint64(report.OctetCount), At: mono.UnixNano(),
	})
	return nil
}

// ReferenceTime keeps derived outputs on the received source's RTP/NTP clock.
// The bounded input history makes the nearest 32-bit timestamp delta unambiguous.
func (source *Source) ReferenceTime(layer int, timestamp uint32) (time.Time, bool) {
	input, err := source.layerBuffer(layer)
	if err != nil {
		return time.Time{}, false
	}
	report := input.GetSenderReportData()
	if report == nil || report.NtpTimestamp == 0 {
		return time.Time{}, false
	}
	delta := time.Duration(int32(timestamp-report.RtpTimestamp)) * time.Second / time.Duration(source.Codec().ClockRate)
	return mediatransportutil.NtpTime(report.NtpTimestamp).Time().Add(delta), true
}

// LocalTime projects the source's clock through its current received report.
// A derived encoder shares this clock offset with the untouched original layer.
func (source *Source) LocalTime(layer int, sourceTime time.Time) (time.Time, bool) {
	input, err := source.layerBuffer(layer)
	if err != nil {
		return time.Time{}, false
	}
	report := input.GetSenderReportData()
	if report == nil || report.NtpTimestamp == 0 || report.AtAdjusted == 0 {
		return time.Time{}, false
	}
	delta := sourceTime.Sub(mediatransportutil.NtpTime(report.NtpTimestamp).Time())
	return time.Unix(0, report.AtAdjusted).Add(delta), true
}

// CopyCorrelation shares an already received clock with an internal RTP copy.
// The original owns network-delay estimation; this buffer still extends and
// orders its own RTP timestamps, including when it starts after a wrap.
func (source *Source) CopyCorrelation(layer int, original *Source) error {
	input, err := original.layerBuffer(layer)
	if err != nil {
		return err
	}
	report := input.GetSenderReportData()
	if report == nil {
		return nil
	}
	report.At = report.AtAdjusted
	return source.SetCorrelation(layer, report)
}

// SetCorrelation receives the source owner's RTP/NTP mapping and its known
// local input time in At. Encoder completion is not a network delay observation.
// The layer must already have received RTP; the media core owns report ordering.
func (source *Source) SetCorrelation(layer int, correlation *livekit.RTCPSenderReportState) error {
	input, err := source.layerBuffer(layer)
	if err != nil {
		return err
	}
	if correlation == nil {
		return errors.New("forwarded source correlation is absent")
	}
	input.knownInputClock.Store(true)
	input.SetSenderReportData(correlation)
	return nil
}

func (source *Source) Close() {
	source.mu.Lock()
	if source.closed {
		source.mu.Unlock()
		return
	}
	source.closed = true
	source.mu.Unlock()
	source.ReceiverBase.Close("source closed", true)
}