servertransport

type BufferFactory ¶

type BufferFactory func(packetType packetio.BufferPacketType, ssrc uint32) *packetio.Buffer

type DataTransport ¶

type DataTransport struct {
	// contains filtered or unexported fields
}

func NewDataTransport(params DataTransportParams) *DataTransport

func (t *DataTransport) Close() error

func (t *DataTransport) MessagesChannel() <-chan webrtc.DataChannelMessage

func (t *DataTransport) Send(message webrtc.DataChannelMessage) <-chan error

func (t *DataTransport) SendText(message string) error

type DataTransportParams ¶

type DataTransportParams struct {
	Log  logger.Logger
	Conn io.ReadWriteCloser
}

type MatchFunc ¶

type MatchFunc func([]byte) bool

MatchFunc allows custom logic for mapping packets to an Endpoint

func MatchRange(lower byte, upper byte) MatchFunc

type MediaStream ¶

type MediaStream struct {
	// contains filtered or unexported fields
}

func NewMediaStream(params MediaStreamParams) *MediaStream

func (t *MediaStream) Close() error

func (t *MediaStream) GetOrCreateBuffer(
	packetType packetio.BufferPacketType, ssrc webrtc.SSRC,
) *packetio.Buffer

func (t *MediaStream) RemoveBuffer(
	packetType packetio.BufferPacketType, ssrc webrtc.SSRC,
)

func (t *MediaStream) WriteRTCP(p []rtcp.Packet) error

func (t *MediaStream) Writer() io.Writer

type MediaStreamParams ¶

type MediaStreamParams struct {
	Log  logger.Logger
	Conn io.ReadWriteCloser

	// BufferFactory is optional.
	BufferFactory BufferFactory
	// Interceptor is optional.
	Interceptor interceptor.Interceptor
}

type MetadataTransport ¶

type MetadataTransport struct {
	// contains filtered or unexported fields
}

func NewMetadataTransport(params MetadataTransportParams) *MetadataTransport

func (t *MetadataTransport) AddTrack(track transport.Track) (transport.TrackLocal, transport.RTCPReader, error)

func (t *MetadataTransport) Close() error

func (t *MetadataTransport) LocalTracks() []transport.TrackWithMID

func (t *MetadataTransport) RemoteTracksChannel() <-chan transport.TrackRemoteWithRTCPReader

func (t *MetadataTransport) RemoveTrack(trackID identifiers.TrackID) error

type MetadataTransportParams ¶

type MetadataTransportParams struct {
	Log           logger.Logger
	Conn          io.ReadWriteCloser
	MediaStream   *MediaStream
	ClientID      identifiers.ClientID
	Interceptor   interceptor.Interceptor
	CodecRegistry *codecs.Registry
}

type Params ¶

type Params struct {
	Log                 logger.Logger
	MediaConn           io.ReadWriteCloser
	DataConn            io.ReadWriteCloser
	MetadataConn        io.ReadWriteCloser
	CodecRegistry       *codecs.Registry
	InterceptorRegistry *interceptor.Registry
}

type ServerTrack ¶

type ServerTrack struct {
	transport.SimpleTrack
	// contains filtered or unexported fields
}

func (s *ServerTrack) Sub() error

func (s *ServerTrack) Unsub() error

type Transport ¶

type Transport struct {
	*MetadataTransport
	*MediaStream
	*DataTransport
	// contains filtered or unexported fields
}

Transport is used for server to server communication. The underlying transport protocol is SCTP, and the following data is transferred:

1. Ordered Metadata stream on ID 0. This stream will contain track, as well as application level metadata.
2. Unordered Media (RTP and RTCP) streams will use odd numbered stream IDs, starting from 1.
3. Ordered DataChannel messages on even stream IDs, starting from 2.

A single Media stream transports all RTP and RTCP packets for a single room, and a single DataChannel stream will transport all datachannel messages for a single room.

A single SCTP connection can be used to transport packets from multiple rooms. Each room will take exactly one Media stream and one DataChannel stream. Following the rules above, the stream IDs for a specific room will always be N and N+1, but the metadata for all rooms will be sent on stream 0.

Track metadata is JSON encoded.

TODO subject to change

func New(params Params) *Transport

func (t *Transport) ClientID() identifiers.ClientID

func (t *Transport) Close() (err error)

func (t *Transport) Done() <-chan struct{}

func (t *Transport) Type() transport.Type