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

16.3 KB
Raw Blame
package mediaedge

import (
	"context"
	"errors"
	"io"
	"log/slog"
	"strconv"
	"strings"
	"sync"
	"time"

	"github.com/TNTcraftHIM/Piik/internal/app/nativeaudio"
	"github.com/TNTcraftHIM/Piik/internal/diagnostics"
	"github.com/TNTcraftHIM/Piik/internal/media/forwarding"
	"github.com/TNTcraftHIM/Piik/internal/media/inputroute"
	"github.com/pion/ice/v4"
	"github.com/pion/webrtc/v4"
)

const maxPendingCandidates = 64

type EdgeEvents struct {
	LocalCandidate func(*webrtc.ICECandidateInit)
	// Media projections must check isCurrentState again after event queues.
	ConnectionState func(state webrtc.PeerConnectionState, pair *SelectedPair, isCurrentState func(webrtc.PeerConnectionState) bool)
}

type EdgeOptions struct {
	ConnectionID string
	ICEServers   []webrtc.ICEServer
	Audio        *AudioSource
	Local        bool
	Punched      bool
	Events       EdgeEvents
}

type Edge struct {
	connectionID  string
	engine        *Engine
	socket        *iceSocket
	source        *Source
	audioSource   *AudioSource
	connection    *webrtc.PeerConnection
	sender        *webrtc.RTPSender
	audioSender   *webrtc.RTPSender
	targetBitrate func() (int, bool)
	events        EdgeEvents
	transport     *forwarding.Transport
	local         bool

	mu                   sync.Mutex
	pendingCandidates    []webrtc.ICECandidateInit
	remoteDescriptionSet bool
	closed               bool
	qualityMu            sync.Mutex
	qualityBaseline      qualityBaseline
	answerMu             sync.Mutex
	localOfferID         string
	localCandidates      *localCandidateGathering
}

func (engine *Engine) NewEdge(source *Source, options EdgeOptions) (_ *Edge, err error) {
	if source == nil || source.engine != engine || options.ConnectionID == "" ||
		len(options.ConnectionID) > 256 {
		return nil, errors.New("native media edge input is invalid")
	}
	if options.Audio != nil && options.Audio.engine != engine {
		return nil, errors.New("native audio edge source belongs to another engine")
	}
	if err := source.reserve(options.Local); err != nil {
		return nil, err
	}
	if options.Audio != nil {
		if err := options.Audio.reserve(options.Local); err != nil {
			source.releaseReservation(options.Local)
			return nil, err
		}
	}
	var socket *iceSocket
	if options.Punched && !options.Local {
		connection := engine.TakePunchedSocket(options.ConnectionID, source)
		if connection == nil {
			err = errors.New("prepared connection is unavailable")
		} else {
			socket, err = engine.adoptICESocket(connection, options.ICEServers, true)
		}
	} else {
		engine.ClosePunch(options.ConnectionID)
		socket, err = engine.newICESocket(options.ICEServers, !options.Local)
	}
	if err != nil {
		source.releaseReservation(options.Local)
		if options.Audio != nil {
			options.Audio.releaseReservation(options.Local)
		}
		return nil, err
	}
	defer func() {
		if err != nil {
			socket.close()
		}
	}()
	var prepareMapping func() int
	if socket.portMapping != nil {
		prepareMapping = socket.portMapping.Prepare
	}
	var audio webrtc.TrackLocal
	if options.Audio != nil {
		audio = options.Audio.track
	}
	transport, err := forwarding.NewTransport(forwarding.TransportOptions{
		Source: source.media.Source, Settings: socket.settings(), ConnectionID: options.ConnectionID,
		InitialBitrate: engine.initialBitrate, Audio: audio,
	})
	if err != nil {
		source.releaseReservation(options.Local)
		if options.Audio != nil {
			options.Audio.releaseReservation(options.Local)
		}
		return nil, err
	}
	connection := transport.PC
	log := slog.Default().With("connectionId", diagnostics.ID(options.ConnectionID), "rtcPeerId", diagnostics.ID(connection.ID()))
	edge := &Edge{
		connectionID:  options.ConnectionID,
		engine:        engine,
		socket:        socket,
		source:        source,
		audioSource:   options.Audio,
		connection:    connection,
		transport:     transport,
		local:         options.Local,
		targetBitrate: transport.TargetBitrate,
		events:        options.Events,
		sender:        transport.VideoSender,
		audioSender:   transport.AudioSender,
	}
	if err = engine.register(edge); err != nil {
		source.releaseReservation(options.Local)
		if options.Audio != nil {
			options.Audio.releaseReservation(options.Local)
		}
		_ = transport.Close()
		return nil, err
	}
	if err = source.attach(edge, options.Local); err != nil {
		if options.Audio != nil {
			options.Audio.releaseReservation(options.Local)
		}
		engine.remove(edge)
		_ = transport.Close()
		return nil, err
	}
	if options.Audio != nil {
		if err = options.Audio.attach(edge, options.Local); err != nil {
			source.detach(edge)
			engine.remove(edge)
			_ = transport.Close()
			return nil, err
		}
	}
	if !options.Local {
		parameters, parametersErr := connection.SCTP().Transport().ICETransport().GetLocalParameters()
		if parametersErr != nil {
			_ = edge.Close()
			return nil, parametersErr
		}
		edge.localCandidates = newLocalCandidateGathering(
			socket, options.ICEServers, prepareMapping, parameters.UsernameFragment, options.Events.LocalCandidate,
		)
		connection.OnICECandidate(func(candidate *webrtc.ICECandidate) {
			edge.localCandidates.addPion(candidate)
		})
	}
	connection.OnICEConnectionStateChange(func(state webrtc.ICEConnectionState) {
		log.Debug("piik-client", "event", "media-ice-state", "direction", "outbound", "local", options.Local, "state", state.String())
	})
	if dtls := edge.sender.Transport(); dtls != nil {
		dtls.OnStateChange(func(state webrtc.DTLSTransportState) {
			log.Debug("piik-client", "event", "media-dtls-state", "direction", "outbound", "local", options.Local, "state", state.String())
		})
	}
	connection.OnConnectionStateChange(func(state webrtc.PeerConnectionState) {
		isCurrentState := func(expected webrtc.PeerConnectionState) bool { return connection.ConnectionState() == expected }
		debug := slog.Default().Enabled(engine.ctx, slog.LevelDebug)
		if debug {
			log.Debug("piik-client", "event", "media-connection-state", "direction", "outbound", "local", options.Local, "state", state.String())
		}
		if state == webrtc.PeerConnectionStateConnected && isCurrentState(state) {
			if err := edge.transport.SetConnected(); err != nil {
				if debug {
					log.Debug("piik-client", "event", "media-activation-failed", diagnostics.Error(err))
				}
				_ = connection.Close()
				return
			}
			edge.source.RequestRecoveryFrame()
		}
		var selected *SelectedPair
		if state == webrtc.PeerConnectionStateConnected && isCurrentState(state) && (edge.events.ConnectionState != nil || debug) {
			if pair, pairErr := edge.SelectedPair(); pairErr == nil {
				selected = &pair
				if debug {
					log.Debug("piik-client", "event", "media-selected-path", "direction", "outbound", "local", options.Local,
						"localType", pair.Local.String(), "remoteType", pair.Remote.String(), "natTraversalPath", pair.NatTraversalPath)
				}
			}
		}
		if edge.events.ConnectionState != nil {
			edge.events.ConnectionState(state, selected, isCurrentState)
		}
	})
	return edge, nil
}

func (edge *Edge) ConnectionID() string {
	return edge.connectionID
}

// SetTargetLayer is a media-component input, not a route change or UI setting.
func (edge *Edge) SetTargetLayer(layer int) error {
	source := edge.source
	changed := false
	source.writeMu.Lock()
	defer func() {
		source.writeMu.Unlock()
		if changed {
			source.RequestRecoveryFrame()
		}
	}()
	source.mu.Lock()
	_, attached := source.edges[edge]
	closed := source.closed
	source.mu.Unlock()
	if closed || !attached {
		return io.ErrClosedPipe
	}
	if layer < 0 || layer >= len(source.formats) {
		return errors.New("native output layer is invalid")
	}
	if len(source.outputBitrates) > 0 && source.outputBitrates[layer] == 0 {
		return errors.New("native output layer is unavailable")
	}
	changed = edge.transport.Output.MaxLayer().Spatial != int32(layer)
	edge.transport.Output.SetMaxSpatialLayer(int32(layer))
	return nil
}

func (edge *Edge) CreateOffer() (webrtc.SessionDescription, error) {
	if edge.local {
		return webrtc.SessionDescription{}, errors.New("local media requires an identified offer")
	}
	offer, err := edge.connection.CreateOffer(nil)
	if err != nil {
		return webrtc.SessionDescription{}, err
	}
	if err = edge.connection.SetLocalDescription(offer); err != nil {
		return webrtc.SessionDescription{}, err
	}
	edge.localCandidates.start()
	return offer, nil
}

// OpenDataChannel adds an optional channel before the initial offer. The edge's
// PeerConnection owns its transport and closes it with the media connection.
func (edge *Edge) OpenDataChannel(label string) (*webrtc.DataChannel, error) {
	return edge.connection.CreateDataChannel(label, nil)
}

// OnInputTransportLost binds the input leg before the initial offer. Pion's
// ordered ICE observer is separate from its asynchronous PC state projection.
func (edge *Edge) OnInputTransportLost(lost func()) {
	inputroute.ObserveTransport(edge.connection.SCTP().Transport().ICETransport(), func(available bool) {
		if !available {
			lost()
		}
	})
}

// Local bridges have no STUN or gateway discovery. Complete SDP keeps their
// candidates and answer in one bounded negotiation, including ICE restarts.
func (edge *Edge) CreateLocalOffer(ctx context.Context, offerID string, restart bool) (webrtc.SessionDescription, error) {
	edge.answerMu.Lock()
	defer edge.answerMu.Unlock()
	edge.mu.Lock()
	available := edge.local && !edge.closed && offerID != "" && offerID != edge.localOfferID &&
		((!restart && edge.localOfferID == "") || (restart && edge.remoteDescriptionSet))
	edge.mu.Unlock()
	if !available {
		return webrtc.SessionDescription{}, errors.New("local media negotiation is unavailable")
	}
	ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
	defer cancel()
	if err := ctx.Err(); err != nil {
		return webrtc.SessionDescription{}, err
	}
	offer, err := edge.connection.CreateOffer(&webrtc.OfferOptions{ICERestart: restart})
	if err != nil {
		return webrtc.SessionDescription{}, err
	}
	gathered := webrtc.GatheringCompletePromise(edge.connection)
	if err = edge.connection.SetLocalDescription(offer); err != nil {
		return webrtc.SessionDescription{}, err
	}
	edge.localOfferID = offerID
	edge.mu.Lock()
	edge.remoteDescriptionSet = false
	edge.mu.Unlock()
	select {
	case <-gathered:
		if description := edge.connection.LocalDescription(); description != nil {
			return *description, nil
		}
		return webrtc.SessionDescription{}, io.ErrClosedPipe
	case <-ctx.Done():
		return webrtc.SessionDescription{}, ctx.Err()
	case <-edge.socket.ctx.Done():
		return webrtc.SessionDescription{}, io.ErrClosedPipe
	}
}

func (edge *Edge) SetAnswer(answer webrtc.SessionDescription, offerID string) error {
	edge.answerMu.Lock()
	defer edge.answerMu.Unlock()
	if (edge.local && (offerID == "" || offerID != edge.localOfferID)) || (!edge.local && offerID != "") {
		return errors.New("native media answer does not match its offer")
	}
	if answer.Type != webrtc.SDPTypeAnswer {
		return errors.New("native media edge requires an SDP answer")
	}
	edge.mu.Lock()
	if edge.closed {
		edge.mu.Unlock()
		return errors.New("native media edge is closed")
	}
	if edge.remoteDescriptionSet {
		// A repeated answer within the same connection/offer is a
		// retransmission; its first applied description remains authoritative.
		edge.mu.Unlock()
		return nil
	}
	edge.mu.Unlock()
	if edge.audioSource != nil {
		if err := forwarding.CheckAudioReceiveLimit(answer.SDP, nativeaudio.MaxBitrate); err != nil {
			return err
		}
	}
	if err := edge.connection.SetRemoteDescription(answer); err != nil {
		return err
	}
	if err := edge.socket.addPunchedPeer(edge.connection); err != nil {
		return err
	}
	edge.mu.Lock()
	edge.remoteDescriptionSet = true
	pending := edge.pendingCandidates
	edge.pendingCandidates = nil
	edge.mu.Unlock()
	for _, candidate := range pending {
		// Candidates are disposable edge input. The connection state callback
		// remains the authority for a real media failure.
		if err := forwarding.AddICECandidate(edge.connection, candidate); err != nil {
			slog.Debug("media-candidate-rejected", "connectionId", diagnostics.ID(edge.connectionID), "stage", "drain", diagnostics.Error(err))
		}
	}
	return nil
}

func (edge *Edge) AddRemoteCandidate(candidate *webrtc.ICECandidateInit) error {
	if edge.local {
		return errors.New("local media candidates belong in the SDP answer")
	}
	if malformedRemoteCandidate(candidate) {
		slog.Debug("media-candidate-rejected", "connectionId", diagnostics.ID(edge.connectionID), "stage", "malformed")
		return nil
	}
	value := webrtc.ICECandidateInit{}
	if candidate != nil {
		value = *candidate
	}
	edge.mu.Lock()
	if edge.closed {
		edge.mu.Unlock()
		return nil
	}
	if !edge.remoteDescriptionSet {
		if len(edge.pendingCandidates) >= maxPendingCandidates {
			edge.mu.Unlock()
			slog.Debug("media-candidate-rejected", "connectionId", diagnostics.ID(edge.connectionID), "stage", "queue-full", "capacity", maxPendingCandidates)
			return nil
		}
		edge.pendingCandidates = append(edge.pendingCandidates, value)
		edge.mu.Unlock()
		return nil
	}
	edge.mu.Unlock()
	// A candidate may become stale between validation and delivery. Dropping
	// that one edge input keeps the shared control session alive; ICE state
	// events still report whether the edge itself can connect.
	if err := forwarding.AddICECandidate(edge.connection, value); err != nil {
		slog.Debug("media-candidate-rejected", "connectionId", diagnostics.ID(edge.connectionID), "stage", "apply", diagnostics.Error(err))
	}
	return nil
}

func malformedRemoteCandidate(candidate *webrtc.ICECandidateInit) bool {
	if candidate == nil || candidate.Candidate == "" {
		return false
	}
	_, err := ice.UnmarshalCandidate(strings.TrimPrefix(candidate.Candidate, "candidate:"))
	return err != nil
}

type SelectedPair struct {
	Local            webrtc.ICECandidateType
	Remote           webrtc.ICECandidateType
	NatTraversalPath string
}

func (edge *Edge) SelectedPair() (SelectedPair, error) {
	transport := edge.sender.Transport()
	if transport == nil || transport.ICETransport() == nil {
		return SelectedPair{}, errors.New("native media ICE transport is unavailable")
	}
	pair, err := transport.ICETransport().GetSelectedCandidatePair()
	if err != nil || pair == nil {
		return SelectedPair{}, errors.New("native media ICE pair is unavailable")
	}
	return SelectedPair{
		Local: pair.Local.Typ, Remote: pair.Remote.Typ,
		NatTraversalPath: selectedNatTraversalPath(
			pair.Local.Foundation,
			pair.Remote.Foundation,
		),
	}, nil
}

func selectedNatTraversalPath(foundations ...string) string {
	for _, foundation := range foundations {
		if len(foundation) < 3 || foundation[0] != 's' ||
			(foundation[1] != 'p' && foundation[1] != 'm') {
			continue
		}
		if _, err := strconv.Atoi(foundation[2:]); err == nil {
			return "predicted"
		}
	}
	for _, foundation := range foundations {
		if foundation != "" {
			return "ordinary"
		}
	}
	return "unknown"
}

func (edge *Edge) State() webrtc.PeerConnectionState {
	return edge.connection.ConnectionState()
}

func (edge *Edge) Close() error {
	edge.mu.Lock()
	if edge.closed {
		edge.mu.Unlock()
		return nil
	}
	edge.closed = true
	if edge.localCandidates != nil {
		edge.localCandidates.close()
	}
	edge.pendingCandidates = nil
	edge.mu.Unlock()
	if edge.local && slog.Default().Enabled(edge.engine.ctx, slog.LevelDebug) {
		logLocalMediaCandidateCounts(slog.Default(), edge.connection.GetStats())
	}
	err := edge.transport.Close()
	edge.socket.close()
	edge.source.detach(edge)
	if edge.audioSource != nil {
		edge.audioSource.detach(edge)
	}
	edge.engine.remove(edge)
	return err
}

func logLocalMediaCandidateCounts(logger *slog.Logger, report webrtc.StatsReport) {
	for _, direction := range []webrtc.StatsType{webrtc.StatsTypeLocalCandidate, webrtc.StatsTypeRemoteCandidate} {
		for _, kind := range []webrtc.ICECandidateType{webrtc.ICECandidateTypeHost, webrtc.ICECandidateTypeSrflx, webrtc.ICECandidateTypePrflx, webrtc.ICECandidateTypeRelay} {
			udp, tcp := 0, 0
			for _, entry := range report {
				candidate, ok := entry.(webrtc.ICECandidateStats)
				if !ok || candidate.Type != direction || candidate.CandidateType != kind || candidate.Deleted {
					continue
				}
				switch candidate.Protocol {
				case "udp":
					udp++
				case "tcp":
					tcp++
				}
			}
			logger.Debug("piik-client", "event", "media-candidate-counts", "local", true,
				"direction", string(direction), "type", kind.String(), "udp", udp, "tcp", tcp)
		}
	}
}

// Shutdown must release every transport before waiting on shared source writes.
func closeEdges(edges []*Edge) {
	for _, edge := range edges {
		_ = edge.connection.Close()
	}
	for _, edge := range edges {
		_ = edge.Close()
	}
}