Free, open-source screen sharing for private live streams with friends. Watch together in a browser or self-host Piik. 免费开源的私密屏幕共享,支持游戏直播、一起看电影与自部署。
package mediaedge
import (
"errors"
"log/slog"
"slices"
"strconv"
"strings"
"sync"
"github.com/TNTcraftHIM/Piik/internal/app/nativeaudio"
"github.com/TNTcraftHIM/Piik/internal/app/nativecapture"
"github.com/TNTcraftHIM/Piik/internal/media/forwarding"
"github.com/TNTcraftHIM/Piik/internal/media/inputroute"
"github.com/pion/rtcp"
"github.com/pion/sdp/v3"
"github.com/pion/webrtc/v4"
)
type ReceiverEvents struct {
// The final consumer must check current again after any event queues.
LocalCandidate func(candidate *webrtc.ICECandidateInit, current func() bool)
ConnectionState func(state webrtc.PeerConnectionState, pair *SelectedPair, isCurrentState func(webrtc.PeerConnectionState) bool)
DataChannel func(*webrtc.DataChannel)
// Bound before SDP starts the transport; runs in Pion's ordered ICE observer.
InputTransportAvailable func(bool)
}
type ReceiverOptions struct {
Offer webrtc.SessionDescription
ICEServers []webrtc.ICEServer
EdgeCapacity int
Events ReceiverEvents
Relay *RelayOptions
// A consumed preparation transfers ownership even if offer validation fails.
PunchedSocket *PunchedSocket
}
// Receiver owns one inbound WebRTC connection and exposes its encoded media as
// ordinary bounded Sources. Consumers can attach local playback and downstream
// P2P edges without adding a decoder or encoder.
type Receiver struct {
socket *iceSocket
connection *webrtc.PeerConnection
source *Source
audioSource *AudioSource
events ReceiverEvents
localCandidates *localCandidateGathering
iceServers []webrtc.ICEServer
prepareMapping func() int
offerMu sync.Mutex
candidateMu sync.Mutex
mu sync.Mutex
closed bool
videoSSRC webrtc.SSRC
}
func (engine *Engine) NewReceiver(options ReceiverOptions) (_ *Receiver, _ webrtc.SessionDescription, err error) {
if options.PunchedSocket != nil {
defer func() {
if err != nil {
_ = options.PunchedSocket.Close()
}
}()
}
if options.Offer.Type != webrtc.SDPTypeOffer || options.Offer.SDP == "" {
return nil, webrtc.SessionDescription{}, errors.New("native media receiver input is invalid")
}
hasAudio, err := offerSendsCodec(options.Offer.SDP, "audio", "opus")
if err != nil {
return nil, webrtc.SessionDescription{}, err
}
var prepareMapping func() int
var socket *iceSocket
if options.PunchedSocket != nil {
socket, err = engine.adoptICESocket(options.PunchedSocket, options.ICEServers, true)
} else {
socket, err = engine.newICESocket(options.ICEServers, true)
}
if err != nil {
return nil, webrtc.SessionDescription{}, err
}
defer func() {
if err != nil {
socket.close()
}
}()
if socket.portMapping != nil {
prepareMapping = socket.portMapping.Prepare
}
connection, err := socket.newPeerConnection()
if err != nil {
return nil, webrtc.SessionDescription{}, err
}
if options.Events.InputTransportAvailable != nil {
inputroute.ObserveTransport(connection.SCTP().Transport().ICETransport(), options.Events.InputTransportAvailable)
}
if err = connection.SetRemoteDescription(options.Offer); err != nil {
_ = connection.Close()
return nil, webrtc.SessionDescription{}, err
}
if err = socket.addPunchedPeer(connection); err != nil {
_ = connection.Close()
return nil, webrtc.SessionDescription{}, err
}
videoCodec, err := selectReceiverVideoCodec(connection)
if err != nil {
_ = connection.Close()
return nil, webrtc.SessionDescription{}, err
}
receiver := &Receiver{
socket: socket,
connection: connection,
events: options.Events,
iceServers: options.ICEServers,
prepareMapping: prepareMapping,
}
layers := 1
var relay *RelayOptions
if _, supported := relayBackend(videoCodec, options.Relay); supported {
layers = 2
relay = options.Relay
}
receiver.source, err = engine.newSource(videoCodec, options.EdgeCapacity, layers, relay, func([]int) {
// Local output slots all derive from this one upstream encoded stream.
receiver.RequestKeyFrame()
})
if err != nil {
_ = connection.Close()
return nil, webrtc.SessionDescription{}, err
}
// Install before OnTrack can feed the source. Only the received original
// requests upstream repair; derived outputs keep their existing recovery.
receiver.source.writeNACK = func(nack *rtcp.TransportLayerNack) {
receiver.mu.Lock()
ssrc, closed := receiver.videoSSRC, receiver.closed
receiver.mu.Unlock()
if !closed && ssrc != 0 {
nack.MediaSSRC = uint32(ssrc)
_ = connection.WriteRTCP([]rtcp.Packet{nack})
}
}
if hasAudio {
receiver.audioSource, err = engine.NewRelayedAudioSource(options.EdgeCapacity)
if err != nil {
_ = receiver.source.Close()
_ = connection.Close()
return nil, webrtc.SessionDescription{}, err
}
}
// Pion announces gathering before emitting candidates, including when a
// remote ICE restart starts inside SetRemoteDescription. Ordinary SDP
// renegotiation leaves this collector and its completion fence alone.
connection.OnICEGatheringStateChange(func(state webrtc.ICEGatheringState) {
if state == webrtc.ICEGatheringStateGathering {
receiver.beginGathering()
}
})
connection.OnConnectionStateChange(func(state webrtc.PeerConnectionState) {
isCurrentState := func(expected webrtc.PeerConnectionState) bool {
return receiver.active() && connection.ConnectionState() == expected
}
if !receiver.active() {
return
}
if state == webrtc.PeerConnectionStateConnected && isCurrentState(state) {
// A retained source can have lost a frame's dependencies while ICE
// restarted. Refresh it when transport resumes, before downstream
// decoders have to exhaust NACK repair and request their own key.
receiver.RequestKeyFrame()
}
debug := slog.Default().Enabled(engine.ctx, slog.LevelDebug)
if debug {
slog.Debug("piik-client", "event", "media-connection-state", "direction", "inbound", "state", state.String())
}
var selected *SelectedPair
if state == webrtc.PeerConnectionStateConnected && isCurrentState(state) && (receiver.events.ConnectionState != nil || debug) {
if pair, pairErr := receiver.SelectedPair(); pairErr == nil {
selected = &pair
if debug {
slog.Debug("piik-client", "event", "media-selected-path", "direction", "inbound",
"localType", pair.Local.String(), "remoteType", pair.Remote.String(), "natTraversalPath", pair.NatTraversalPath)
}
}
}
if receiver.events.ConnectionState != nil {
receiver.events.ConnectionState(state, selected, isCurrentState)
}
})
connection.OnTrack(func(track *webrtc.TrackRemote, rtpReceiver *webrtc.RTPReceiver) {
go receiver.readRTCP(track, rtpReceiver)
receiver.consumeTrack(track, rtpReceiver)
})
if options.Events.DataChannel != nil {
connection.OnDataChannel(options.Events.DataChannel)
}
answer, err := receiver.createAnswer()
if err != nil {
_ = receiver.Close()
return nil, webrtc.SessionDescription{}, err
}
return receiver, answer, nil
}
func (receiver *Receiver) Source() *Source { return receiver.source }
func (receiver *Receiver) AudioSource() *AudioSource { return receiver.audioSource }
func (receiver *Receiver) HasAudio() bool { return receiver.audioSource != nil }
func (receiver *Receiver) Codec() string { return receiver.source.Codec() }
func (receiver *Receiver) active() bool {
receiver.mu.Lock()
defer receiver.mu.Unlock()
return !receiver.closed
}
// Renegotiate keeps the encoded source and its consumers when the offer still
// describes the same media shape. A changed codec/audio shape needs replacement.
func (receiver *Receiver) Renegotiate(offer webrtc.SessionDescription, servers []webrtc.ICEServer) (webrtc.SessionDescription, bool, error) {
receiver.offerMu.Lock()
defer receiver.offerMu.Unlock()
if offer.Type != webrtc.SDPTypeOffer || offer.SDP == "" {
return webrtc.SessionDescription{}, false, errors.New("native media receiver input is invalid")
}
hasAudio, err := offerSendsCodec(offer.SDP, "audio", "opus")
if err != nil {
return webrtc.SessionDescription{}, false, err
}
sameVideo, err := offerSendsCodec(offer.SDP, "video", receiver.Codec())
if err != nil || !sameVideo || hasAudio != receiver.HasAudio() {
return webrtc.SessionDescription{}, false, err
}
receiver.mu.Lock()
closed := receiver.closed
receiver.iceServers = servers
receiver.mu.Unlock()
if closed {
return webrtc.SessionDescription{}, false, errors.New("native media receiver is closed")
}
if err = receiver.connection.SetRemoteDescription(offer); err != nil {
return webrtc.SessionDescription{}, false, err
}
answer, err := receiver.createAnswer()
return answer, err == nil, err
}
func (receiver *Receiver) beginGathering() {
parameters, err := receiver.connection.SCTP().Transport().ICETransport().GetLocalParameters()
if err != nil {
return
}
// Serialize candidate delivery with collector replacement, without holding
// the receiver state lock across the caller's event delivery.
receiver.candidateMu.Lock()
defer receiver.candidateMu.Unlock()
receiver.mu.Lock()
if receiver.closed {
receiver.mu.Unlock()
return
}
previous := receiver.localCandidates
var gathering *localCandidateGathering
current := func() bool {
receiver.mu.Lock()
defer receiver.mu.Unlock()
return !receiver.closed && receiver.localCandidates == gathering
}
gathering = newLocalCandidateGathering(receiver.socket, receiver.iceServers, receiver.prepareMapping, parameters.UsernameFragment,
func(candidate *webrtc.ICECandidateInit) {
receiver.candidateMu.Lock()
defer receiver.candidateMu.Unlock()
if current() && receiver.events.LocalCandidate != nil {
receiver.events.LocalCandidate(candidate, current)
}
})
receiver.localCandidates = gathering
receiver.mu.Unlock()
if previous != nil {
previous.close()
}
receiver.connection.OnICECandidate(gathering.addPion)
gathering.start()
}
func (receiver *Receiver) createAnswer() (webrtc.SessionDescription, error) {
receiver.mu.Lock()
if receiver.closed {
receiver.mu.Unlock()
return webrtc.SessionDescription{}, errors.New("native media receiver is closed")
}
receiver.mu.Unlock()
// Opus stereo is a local receive preference, not a property inherited from
// the offer. Apply it on every answer, including same-source renegotiation.
for _, transceiver := range receiver.connection.GetTransceivers() {
if transceiver.Kind() != webrtc.RTPCodecTypeAudio || transceiver.Receiver() == nil ||
(transceiver.Direction() != webrtc.RTPTransceiverDirectionRecvonly &&
transceiver.Direction() != webrtc.RTPTransceiverDirectionSendrecv) {
continue
}
for _, codec := range transceiver.Receiver().GetParameters().Codecs {
if !strings.EqualFold(codec.MimeType, webrtc.MimeTypeOpus) {
continue
}
codec.SDPFmtpLine = opusSDPFmtpLine + ";stereo=1;maxaveragebitrate=" + strconv.Itoa(nativeaudio.MaxBitrate)
if err := transceiver.SetCodecPreferences([]webrtc.RTPCodecParameters{codec}); err != nil {
return webrtc.SessionDescription{}, err
}
break
}
}
answer, err := receiver.connection.CreateAnswer(nil)
if err != nil {
return webrtc.SessionDescription{}, err
}
if err = receiver.connection.SetLocalDescription(answer); err != nil {
return webrtc.SessionDescription{}, err
}
local := receiver.connection.LocalDescription()
if local == nil {
return webrtc.SessionDescription{}, errors.New("native media receiver produced no SDP answer")
}
// This is a trickled answer: Pion can finish before the extra STUN/mapping
// observations. Only the merged collector may announce their completion.
return webrtc.SessionDescription{Type: local.Type,
SDP: strings.ReplaceAll(local.SDP, "a=end-of-candidates\r\n", "")}, nil
}
func (receiver *Receiver) AddRemoteCandidate(candidate *webrtc.ICECandidateInit) error {
if malformedRemoteCandidate(candidate) {
return nil
}
value := webrtc.ICECandidateInit{}
if candidate != nil {
value = *candidate
}
receiver.mu.Lock()
if receiver.closed {
receiver.mu.Unlock()
return nil
}
receiver.mu.Unlock()
_ = forwarding.AddICECandidate(receiver.connection, value)
return nil
}
func (receiver *Receiver) SelectedPair() (SelectedPair, error) {
for _, transceiver := range receiver.connection.GetTransceivers() {
inbound := transceiver.Receiver()
if inbound == nil || inbound.Transport() == nil || inbound.Transport().ICETransport() == nil {
continue
}
pair, err := inbound.Transport().ICETransport().GetSelectedCandidatePair()
if err == nil && pair != nil {
return SelectedPair{
Local: pair.Local.Typ, Remote: pair.Remote.Typ,
NatTraversalPath: selectedNatTraversalPath(
pair.Local.Foundation,
pair.Remote.Foundation,
),
}, nil
}
}
return SelectedPair{}, errors.New("native media receiver ICE pair is unavailable")
}
func (receiver *Receiver) RequestKeyFrame() {
receiver.mu.Lock()
ssrc := receiver.videoSSRC
closed := receiver.closed
receiver.mu.Unlock()
if closed || ssrc == 0 {
return
}
_ = receiver.connection.WriteRTCP([]rtcp.Packet{
&rtcp.PictureLossIndication{MediaSSRC: uint32(ssrc)},
})
}
func (receiver *Receiver) Close() error {
receiver.mu.Lock()
if receiver.closed {
receiver.mu.Unlock()
return nil
}
receiver.closed = true
localCandidates := receiver.localCandidates
receiver.mu.Unlock()
if localCandidates != nil {
localCandidates.close()
}
err := receiver.connection.Close()
receiver.socket.close()
_ = receiver.source.Close()
if receiver.audioSource != nil {
_ = receiver.audioSource.Close()
}
return err
}
func (receiver *Receiver) consumeTrack(track *webrtc.TrackRemote, _ *webrtc.RTPReceiver) {
if track == nil {
return
}
if track.Kind() == webrtc.RTPCodecTypeVideo {
if !strings.EqualFold(track.Codec().MimeType, videoCodecs[receiver.source.codec].MimeType) {
return
}
receiver.mu.Lock()
receiver.videoSSRC = track.SSRC()
receiver.mu.Unlock()
for {
packet, _, err := forwarding.ReadRTP(track)
if err != nil {
return
}
// Pion completes all bindings; each edge owns its write failure.
_ = receiver.source.WriteRTP(packet)
}
}
if track.Kind() == webrtc.RTPCodecTypeAudio && receiver.audioSource != nil &&
strings.EqualFold(track.Codec().MimeType, webrtc.MimeTypeOpus) {
for {
packet, _, err := forwarding.ReadRTP(track)
if err != nil {
return
}
_ = receiver.audioSource.WriteRTP(packet)
}
}
}
func (receiver *Receiver) readRTCP(track *webrtc.TrackRemote, rtpReceiver *webrtc.RTPReceiver) {
if rtpReceiver == nil {
return
}
for {
packets, _, err := rtpReceiver.ReadRTCP()
if err != nil {
return
}
if track.Kind() == webrtc.RTPCodecTypeVideo {
for _, packet := range packets {
if report, ok := packet.(*rtcp.SenderReport); ok && report.SSRC == uint32(track.SSRC()) {
_ = receiver.source.SenderReport(report)
}
}
}
}
}
func offerSendsCodec(raw, kind, codecName string) (bool, error) {
var description sdp.SessionDescription
if err := description.UnmarshalString(raw); err != nil {
return false, errors.New("native media receiver SDP is invalid")
}
for _, media := range description.MediaDescriptions {
// A zero-port bundle-only section still offers media on the bundle's
// transport (RFC 9143). Only an ordinary zero port rejects the track.
_, bundleOnly := media.Attribute("bundle-only")
if media.MediaName.Media != kind || (media.MediaName.Port.Value == 0 && !bundleOnly) {
continue
}
if _, inactive := media.Attribute("inactive"); inactive {
continue
}
if _, receiveOnly := media.Attribute("recvonly"); receiveOnly {
continue
}
codecs := (&sdp.SessionDescription{MediaDescriptions: []*sdp.MediaDescription{media}}).GetCodecMap()
for payload, codec := range codecs {
if !slices.Contains(media.MediaName.Formats, strconv.Itoa(int(payload))) ||
!strings.EqualFold(codec.Name, codecName) {
continue
}
if codecName != "h264" || forwardableH264(codec.Fmtp) {
return true, nil
}
}
}
return false, nil
}
func selectReceiverVideoCodec(connection *webrtc.PeerConnection) (string, error) {
for _, transceiver := range connection.GetTransceivers() {
if transceiver.Kind() != webrtc.RTPCodecTypeVideo || transceiver.Receiver() == nil ||
(transceiver.Direction() != webrtc.RTPTransceiverDirectionRecvonly &&
transceiver.Direction() != webrtc.RTPTransceiverDirectionSendrecv) {
continue
}
// Pion may fall back to a MIME-only match. Encoded fanout cannot advertise
// Constrained Baseline downstream after accepting a different profile.
negotiated := transceiver.Receiver().GetParameters().Codecs
for _, parameters := range negotiated {
name := strings.TrimPrefix(strings.ToLower(parameters.MimeType), "video/")
if _, supported := videoCodecs[name]; !supported {
continue
}
if name == "h264" && !forwardableH264(parameters.SDPFmtpLine) {
continue
}
if err := transceiver.SetCodecPreferences(forwarding.WithRTX(parameters, negotiated)); err != nil {
return "", err
}
return name, nil
}
}
return "", errors.New("native media receiver offer has no supported video")
}
func forwardableH264(fmtp string) bool {
// Absent profile-level-id does not promise Constrained Baseline (RFC 6184).
var profile, packetization string
for _, parameter := range strings.Split(fmtp, ";") {
key, value, _ := strings.Cut(strings.TrimSpace(parameter), "=")
switch strings.ToLower(strings.TrimSpace(key)) {
case "profile-level-id":
profile = strings.TrimSpace(value)
case "packetization-mode":
packetization = strings.TrimSpace(value)
}
}
return packetization == "1" && nativecapture.SupportedH264ProfileLevelID(profile)
}