Free, open-source screen sharing for private live streams with friends. Watch together in a browser or self-host Piik. 免费开源的私密屏幕共享,支持游戏直播、一起看电影与自部署。
package nativeviewer
import (
"context"
"errors"
"strings"
"sync"
"time"
"github.com/TNTcraftHIM/Piik/internal/app/mediaedge"
"github.com/TNTcraftHIM/Piik/internal/app/nativecapture"
"github.com/TNTcraftHIM/Piik/internal/media/inputroute"
"github.com/pion/webrtc/v4"
)
type Event struct {
Current func() bool
Type string
ShareID string
ConnectionID string
Candidate *webrtc.ICECandidateInit
State string
LocalType string
RemoteType string
NatTraversalPath string
Quality *mediaedge.QualitySample
}
type Options struct {
ShareID string
EdgeCapacity int
PortMapping bool
Events chan<- Event
Relay *mediaedge.RelayOptions
}
type sessionEdge struct {
edge *mediaedge.Edge
sourceConnectionID string
}
type sessionReceiver struct {
*mediaedge.Receiver
input *inputroute.Relay
}
func (receiver *sessionReceiver) Close() error {
if receiver.input != nil {
receiver.input.Close()
}
return receiver.Receiver.Close()
}
// One current upstream and one prepared route may overlap during a handoff.
const receiverCapacity = 2
// Session owns the native media implementation for one Browser Viewer. Room,
// participant, route, and recovery authority remain in the Browser/server.
type Session struct {
shareID string
edgeCapacity int
engine *mediaedge.Engine
events chan<- Event
ctx context.Context
cancel context.CancelFunc
relay *mediaedge.RelayOptions
mu sync.Mutex
receivers map[string]*sessionReceiver
edges map[string]sessionEdge
profile *nativecapture.VideoProfile
closed bool
}
func Start(parent context.Context, options Options) (*Session, error) {
if parent == nil {
parent = context.Background()
}
if options.ShareID == "" || len(options.ShareID) > 256 ||
options.EdgeCapacity < 1 || options.EdgeCapacity > mediaedge.MaxRelayChildren {
return nil, errors.New("native Viewer session input is invalid")
}
engine, err := mediaedge.NewEngine(mediaedge.EngineOptions{
IncludeLoopback: true,
PortMapping: options.PortMapping,
})
if err != nil {
return nil, err
}
ctx, cancel := context.WithCancel(parent)
session := &Session{
shareID: options.ShareID, edgeCapacity: options.EdgeCapacity,
engine: engine, events: options.Events, ctx: ctx, cancel: cancel, relay: options.Relay,
receivers: make(map[string]*sessionReceiver),
edges: make(map[string]sessionEdge),
}
go session.runQuality()
return session, nil
}
func (session *Session) ShareID() string { return session.shareID }
// UpdateProfile records the Host ceiling; receiving alone never starts derivation.
func (session *Session) UpdateProfile(profile nativecapture.VideoProfile) error {
if !profile.Valid() {
return errors.New("native Viewer profile is invalid")
}
session.mu.Lock()
defer session.mu.Unlock()
if session.closed {
return errors.New("native Viewer session is closed")
}
if session.profile != nil && *session.profile == profile {
return nil
}
for _, receiver := range session.receivers {
if err := receiver.Source().SetRelayProfile(profile); err != nil {
return err
}
}
session.profile = &profile
return nil
}
type OfferResult struct {
Answer webrtc.SessionDescription
Audio bool
Codec string
Reused bool
}
func (session *Session) AcceptOffer(
connectionID string,
offer webrtc.SessionDescription,
iceServers []webrtc.ICEServer,
reuse bool,
punched bool,
) (OfferResult, error) {
if connectionID == "" || len(connectionID) > 256 {
return OfferResult{}, errors.New("native Viewer receiver identity is invalid")
}
session.mu.Lock()
closed := session.closed
receiver := session.receivers[connectionID]
atCapacity := len(session.receivers) >= receiverCapacity && receiver == nil
session.mu.Unlock()
if closed {
return OfferResult{}, errors.New("native Viewer session is closed")
}
if atCapacity {
return OfferResult{}, errors.New("native Viewer receiver capacity reached")
}
if reuse && receiver != nil {
answer, reused, err := receiver.Renegotiate(offer, iceServers)
if err != nil {
return OfferResult{}, err
}
if reused {
return OfferResult{Answer: answer, Audio: receiver.HasAudio(), Codec: receiver.Codec(), Reused: true}, nil
}
}
var punchedSocket *mediaedge.PunchedSocket
if punched {
punchedSocket = session.engine.TakePunchedSocket(connectionID, nil)
if punchedSocket == nil {
return OfferResult{}, errors.New("prepared connection is unavailable")
}
}
session.CloseReceiver(connectionID)
var input *inputroute.Relay
var onDataChannel func(*webrtc.DataChannel)
var inputTransportAvailable func(bool)
if strings.Contains(offer.SDP, "\nm=application ") {
input = inputroute.New(nil)
onDataChannel = input.AttachUp
inputTransportAvailable = input.SetUpAvailable
}
mediaReceiver, answer, err := session.engine.NewReceiver(mediaedge.ReceiverOptions{
Offer: offer,
ICEServers: iceServers,
EdgeCapacity: mediaedge.PhysicalSourceCapacity(session.edgeCapacity),
Relay: session.relay,
PunchedSocket: punchedSocket,
Events: mediaedge.ReceiverEvents{
DataChannel: onDataChannel,
InputTransportAvailable: inputTransportAvailable,
LocalCandidate: func(candidate *webrtc.ICECandidateInit, current func() bool) {
session.emit(Event{
Current: current,
Type: "edge-candidate", ShareID: session.shareID,
ConnectionID: connectionID, Candidate: candidate,
})
},
ConnectionState: func(state webrtc.PeerConnectionState, pair *mediaedge.SelectedPair, isCurrentState func(webrtc.PeerConnectionState) bool) {
session.emit(Event{
Current: func() bool { return isCurrentState(state) },
Type: "edge-state", ShareID: session.shareID,
ConnectionID: connectionID, State: state.String(),
})
if pair != nil {
session.emit(Event{
Current: func() bool { return isCurrentState(state) },
Type: "edge-path", ShareID: session.shareID,
ConnectionID: connectionID,
LocalType: pair.Local.String(),
RemoteType: pair.Remote.String(),
NatTraversalPath: pair.NatTraversalPath,
})
}
},
},
})
if err != nil {
if input != nil {
input.Close()
}
return OfferResult{}, err
}
receiver = &sessionReceiver{Receiver: mediaReceiver, input: input}
session.mu.Lock()
if session.closed || session.receivers[connectionID] != nil || len(session.receivers) >= receiverCapacity {
session.mu.Unlock()
_ = receiver.Close()
return OfferResult{}, errors.New("native Viewer receiver is unavailable")
}
if session.profile != nil {
if err = receiver.Source().SetRelayProfile(*session.profile); err != nil {
session.mu.Unlock()
_ = receiver.Close()
return OfferResult{}, err
}
}
session.receivers[connectionID] = receiver
session.mu.Unlock()
return OfferResult{Answer: answer, Audio: receiver.HasAudio(), Codec: receiver.Codec()}, nil
}
func (session *Session) AddReceiverCandidate(
connectionID string,
candidate *webrtc.ICECandidateInit,
) error {
receiver := session.receiver(connectionID)
if receiver == nil {
return nil
}
return receiver.AddRemoteCandidate(candidate)
}
func (session *Session) PrepareLocalEdge(
sourceConnectionID string,
connectionID, offerID string,
restart bool,
) (webrtc.SessionDescription, error) {
if restart {
session.mu.Lock()
current := session.edges[connectionID]
available := !session.closed && current.edge != nil && current.sourceConnectionID == sourceConnectionID
session.mu.Unlock()
if !available {
return webrtc.SessionDescription{}, errors.New("native local Viewer edge does not exist")
}
return current.edge.CreateLocalOffer(session.ctx, offerID, true)
}
return session.prepareEdge(sourceConnectionID, connectionID, nil, offerID, false)
}
func (session *Session) PrepareEdge(
sourceConnectionID string,
connectionID string,
iceServers []webrtc.ICEServer,
punched bool,
) (webrtc.SessionDescription, error) {
return session.prepareEdge(sourceConnectionID, connectionID, iceServers, "", punched)
}
func (session *Session) prepareEdge(
sourceConnectionID string,
connectionID string,
iceServers []webrtc.ICEServer,
localOfferID string,
punched bool,
) (webrtc.SessionDescription, error) {
local := localOfferID != ""
receiver := session.receiver(sourceConnectionID)
if receiver == nil {
return webrtc.SessionDescription{}, errors.New("native Viewer source does not exist")
}
session.mu.Lock()
if session.closed || session.edges[connectionID].edge != nil {
session.mu.Unlock()
return webrtc.SessionDescription{}, errors.New("native Viewer edge is unavailable")
}
if !local && session.profile == nil {
session.mu.Unlock()
return webrtc.SessionDescription{}, errors.New("native relay requires the Host profile")
}
session.mu.Unlock()
edge, err := session.engine.NewEdge(receiver.Source(), mediaedge.EdgeOptions{
ConnectionID: connectionID,
ICEServers: iceServers,
Audio: receiver.AudioSource(),
Local: local,
Punched: punched,
Events: mediaedge.EdgeEvents{
LocalCandidate: func(candidate *webrtc.ICECandidateInit) {
session.emit(Event{
Type: "edge-candidate", ShareID: session.shareID,
ConnectionID: connectionID, Candidate: candidate,
})
},
ConnectionState: func(state webrtc.PeerConnectionState, pair *mediaedge.SelectedPair, isCurrentState func(webrtc.PeerConnectionState) bool) {
session.emit(Event{
Current: func() bool { return isCurrentState(state) },
Type: "edge-state", ShareID: session.shareID,
ConnectionID: connectionID, State: state.String(),
})
if pair != nil {
session.emit(Event{
Current: func() bool { return isCurrentState(state) },
Type: "edge-path", ShareID: session.shareID,
ConnectionID: connectionID,
LocalType: pair.Local.String(),
RemoteType: pair.Remote.String(),
NatTraversalPath: pair.NatTraversalPath,
})
}
},
},
})
if err != nil {
return webrtc.SessionDescription{}, err
}
session.mu.Lock()
if session.closed || session.edges[connectionID].edge != nil ||
session.receivers[sourceConnectionID] != receiver {
session.mu.Unlock()
_ = edge.Close()
return webrtc.SessionDescription{}, errors.New("native Viewer edge is unavailable")
}
session.edges[connectionID] = sessionEdge{
edge: edge, sourceConnectionID: sourceConnectionID,
}
session.mu.Unlock()
var offer webrtc.SessionDescription
if receiver.input != nil {
channel, channelErr := edge.OpenDataChannel(inputroute.Label)
if channelErr != nil {
session.CloseEdge(connectionID)
return webrtc.SessionDescription{}, channelErr
}
edge.OnInputTransportLost(receiver.input.AttachDown(connectionID, channel))
}
if local {
offer, err = edge.CreateLocalOffer(session.ctx, localOfferID, false)
} else {
offer, err = edge.CreateOffer()
}
if err != nil {
session.CloseEdge(connectionID)
return webrtc.SessionDescription{}, err
}
return offer, nil
}
func (session *Session) SetAnswer(connectionID string, answer webrtc.SessionDescription, offerID string) error {
edge := session.edge(connectionID)
if edge == nil {
return errors.New("native Viewer edge does not exist")
}
return edge.SetAnswer(answer, offerID)
}
func (session *Session) AddCandidate(connectionID string, candidate *webrtc.ICECandidateInit) error {
edge := session.edge(connectionID)
if edge == nil {
return nil
}
return edge.AddRemoteCandidate(candidate)
}
func (session *Session) CloseReceiver(connectionID string) {
session.engine.ClosePunch(connectionID)
session.mu.Lock()
receiver := session.receivers[connectionID]
delete(session.receivers, connectionID)
edges := make([]*mediaedge.Edge, 0)
for edgeID, owned := range session.edges {
if owned.sourceConnectionID == connectionID {
edges = append(edges, owned.edge)
delete(session.edges, edgeID)
}
}
session.mu.Unlock()
for _, edge := range edges {
_ = edge.Close()
}
if receiver != nil {
_ = receiver.Close()
}
}
func (session *Session) CloseEdge(connectionID string) {
session.engine.ClosePunch(connectionID)
session.mu.Lock()
edge := session.edges[connectionID].edge
delete(session.edges, connectionID)
session.mu.Unlock()
if edge != nil {
_ = edge.Close()
}
}
func (session *Session) Close() error {
session.mu.Lock()
if session.closed {
session.mu.Unlock()
return nil
}
session.closed = true
receivers := make([]*sessionReceiver, 0, len(session.receivers))
for _, receiver := range session.receivers {
receivers = append(receivers, receiver)
}
edges := make([]*mediaedge.Edge, 0, len(session.edges))
for _, owned := range session.edges {
edges = append(edges, owned.edge)
}
session.receivers = make(map[string]*sessionReceiver)
session.edges = make(map[string]sessionEdge)
session.mu.Unlock()
session.cancel()
for _, edge := range edges {
_ = edge.Close()
}
for _, receiver := range receivers {
_ = receiver.Close()
}
return session.engine.Close()
}
func (session *Session) receiver(connectionID string) *sessionReceiver {
session.mu.Lock()
defer session.mu.Unlock()
if session.closed {
return nil
}
return session.receivers[connectionID]
}
func (session *Session) edge(connectionID string) *mediaedge.Edge {
session.mu.Lock()
defer session.mu.Unlock()
if session.closed {
return nil
}
return session.edges[connectionID].edge
}
func (session *Session) emit(event Event) {
if session.events == nil {
return
}
select {
case session.events <- event:
case <-session.ctx.Done():
}
}
func (session *Session) runQuality() {
ticker := time.NewTicker(2 * time.Second)
defer ticker.Stop()
for {
select {
case now := <-ticker.C:
session.mu.Lock()
edges := make([]*mediaedge.Edge, 0, len(session.edges))
for _, owned := range session.edges {
edges = append(edges, owned.edge)
}
session.mu.Unlock()
for _, edge := range edges {
if sample, ok := edge.QualitySample(now); ok {
session.emit(Event{
Type: "edge-quality", ShareID: session.shareID,
ConnectionID: edge.ConnectionID(), Quality: &sample,
})
}
}
case <-session.ctx.Done():
return
}
}
}