Free, open-source screen sharing for private live streams with friends. Watch together in a browser or self-host Piik. 免费开源的私密屏幕共享,支持游戏直播、一起看电影与自部署。
package nativehost
import (
"errors"
"github.com/TNTcraftHIM/Piik/internal/app/mediaedge"
"github.com/TNTcraftHIM/Piik/internal/app/remoteinput"
"github.com/pion/webrtc/v4"
)
type publicationKey struct {
generation, connectionID string
}
func (session *Session) PreparePublication(generation, connectionID string, servers []webrtc.ICEServer) (webrtc.SessionDescription, mediaedge.PublicationMedia, error) {
session.mu.Lock()
key := publicationKey{generation: generation, connectionID: connectionID}
if session.closed || len(session.publications) >= 2 || session.publications[key] != nil || session.source == nil {
session.mu.Unlock()
return webrtc.SessionDescription{}, mediaedge.PublicationMedia{}, errors.New("native publication is unavailable")
}
source, audio := session.source, session.audioSource
session.mu.Unlock()
var publication *mediaedge.Publication
current := func() bool {
session.mu.Lock()
defer session.mu.Unlock()
return !session.closed && publication != nil && session.publications[key] == publication
}
created, err := session.engine.NewPublication(source, mediaedge.EdgeOptions{
ConnectionID: connectionID, ICEServers: servers, Audio: audio,
Events: mediaedge.EdgeEvents{
LocalCandidate: func(candidate *webrtc.ICECandidateInit) {
session.emit(Event{Type: "publication-candidate", ShareID: session.shareID,
Current: current,
PublicationGeneration: generation, ConnectionID: connectionID, Candidate: candidate})
},
ConnectionState: func(state webrtc.PeerConnectionState, _ *mediaedge.SelectedPair, isCurrentState func(webrtc.PeerConnectionState) bool) {
session.emit(Event{Type: "publication-state", ShareID: session.shareID,
Current: func() bool { return current() && isCurrentState(state) },
PublicationGeneration: generation, ConnectionID: connectionID, State: state.String()})
},
},
})
if err != nil {
return webrtc.SessionDescription{}, mediaedge.PublicationMedia{}, err
}
session.mu.Lock()
if session.closed || len(session.publications) >= 2 || session.publications[key] != nil {
session.mu.Unlock()
_ = created.Close()
return webrtc.SessionDescription{}, mediaedge.PublicationMedia{}, errors.New("native publication changed")
}
if session.publications == nil {
session.publications = make(map[publicationKey]*mediaedge.Publication)
}
publication = created
session.publications[key] = publication
session.mu.Unlock()
if session.remoteInput != nil {
channel, channelErr := publication.OpenDataChannel(remoteinput.ChannelLabel)
if channelErr == nil {
publication.OnInputTransportLost(session.remoteInput.Attach(connectionID, channel))
}
}
offer, err := publication.CreateOffer()
if err != nil {
session.ClosePublication(generation, connectionID)
return webrtc.SessionDescription{}, mediaedge.PublicationMedia{}, err
}
return offer, publication.Media(), nil
}
func (session *Session) ownsPublication(key publicationKey, publication *mediaedge.Publication) bool {
session.mu.Lock()
defer session.mu.Unlock()
// A current encoder failure still needs its terminal event. Retirement is
// determined by map ownership, not by the transport's closed state.
return !session.closed && publication != nil && session.publications[key] == publication
}
func (session *Session) Publication(generation, connectionID string) (*mediaedge.Publication, error) {
session.mu.Lock()
defer session.mu.Unlock()
publication := session.publications[publicationKey{generation: generation, connectionID: connectionID}]
if session.closed || publication == nil {
return nil, errors.New("native publication identity changed")
}
return publication, nil
}
func (session *Session) ClosePublication(generation, connectionID string) {
session.mu.Lock()
key := publicationKey{generation: generation, connectionID: connectionID}
publication := session.publications[key]
if publication == nil {
session.mu.Unlock()
return
}
delete(session.publications, key)
session.mu.Unlock()
_ = publication.Close()
}