voice

type Control interface {
	// Provision admits one connection and returns the SDP answer to the client's offer. issued is a
	// snowflake the backend took when it authorized the connection; Evict compares against it.
	Provision(ctx context.Context, room, user, conn, issued snowflake.ID, offer string) (string, error)
	// Evict closes the user's connections in the room issued at or before cutoff, and refuses any
	// provision issued at or before it that arrives afterwards.
	Evict(ctx context.Context, room, user, cutoff snowflake.ID) error
	// EvictConnection closes one connection, and refuses that connection's provision if it arrives
	// afterwards. A connection already gone is not an error.
	EvictConnection(ctx context.Context, conn snowflake.ID) error
	// SetExclusion sets the users whose tracks are never forwarded to receiver, over the client's own
	// subscription; a pin does not override it. Empty until M70 decides what fills it.
	SetExclusion(ctx context.Context, room, receiver snowflake.ID, excluded []snowflake.ID) error
	// CloseRoom closes every connection in the room, and refuses any provision for the room issued at or
	// before cutoff that arrives afterwards: a deleted channel is not reopened by a join already in flight.
	CloseRoom(ctx context.Context, room, cutoff snowflake.ID) error
}

type Limits struct {
	// Rooms is the most rooms one SFU holds, ParticipantsPerRoom the most connections in one, and
	// ConnsPerUser the most connections one user holds in one room (a second machine, M105's video).
	Rooms               int
	ParticipantsPerRoom int
	ConnsPerUser        int

	// Tracks bounds, per kind, how many tracks a connection sends and how many slots it receives on.
	// Video is zero until M105–M107 raise it.
	Tracks map[string]TrackBounds

	// MaxCandidates bounds the ICE candidates an offer carries.
	MaxCandidates int

	// ProvisionTimeout is how long a provision waits for its connection. It also bounds how long an
	// eviction's cutoff is remembered: a provision older than this is refused for its age alone.
	ProvisionTimeout time.Duration

	// PacketsPerSecond and BitsPerSecond bound what one track may send. Above either, packets are dropped
	// unforwarded and do not count towards the active speaker; StrikesToEvict seconds in a row at more
	// than twice the bound close the connection.
	PacketsPerSecond int
	BitsPerSecond    int
	StrikesToEvict   int

	// RTCPPerSecond bounds the RTCP packets one connection sends, with the same strikes.
	RTCPPerSecond int

	// MessagesPerSecond bounds data-channel messages; voiceproto.MaxMessage bounds their size.
	MessagesPerSecond int

	// ExtraChannels is how many data channels beyond the first a peer may open, each closed at once,
	// before the connection is closed.
	ExtraChannels int
}

type Options struct {
	// Conn is the one UDP socket every connection's media arrives on, through ICE's UDP mux. The SFU owns
	// it from New and closes it on Close.
	Conn net.PacketConn
	// Loopback admits loopback candidates, for tests and the harness on one machine.
	Loopback bool
	// Public are the addresses the SFU announces in place of the ones its socket is bound to: a server
	// behind a 1:1 NAT or a port-forwarding router cannot be reached at an address it can see. Empty
	// announces what is bound.
	Public []netip.Addr
	// Relays are the addresses TURN's relay sockets are bound on, one a family, admitted as remote
	// candidates whatever range they are in. Empty when there is no relay.
	Relays []netip.Addr
	// Version is the server's version, against which a data channel's hello is checked.
	Version string
	Limits  Limits
	Logger  zerolog.Logger
	// Now is the clock; nil is time.Now.
	Now func() time.Time
}

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

type Stack struct {
	SFU    *SFU
	TURN   *turn.Server
	Secret []byte
}

type StackOptions struct {
	// MediaListen is the SFU's UDP socket; Public what it announces instead of the bound address.
	MediaListen string
	Public      []netip.Addr

	// TURNListen is TURN's UDP and TCP address. TURNTLSListen, with a certificate's two files, is TURN
	// over TLS; empty for none.
	TURNListen    string
	TURNTLSListen string
	TLSCert       string
	TLSKey        string

	// Relay is where relay sockets are bound, SFU where they reach the SFU, and RelayPorts their range.
	// OtherRelay and OtherSFU are the same in IPv6 when the SFU is reached on loopback in both families,
	// used only if the media socket listens on both and this host can bind ::1.
	Relay      netip.Addr
	SFU        netip.AddrPort
	OtherRelay netip.Addr
	OtherSFU   netip.AddrPort
	RelayPorts [2]uint16

	// RelayPerAddress is how many allocations, and how many TCP and TLS connections, one address may
	// hold on TURN, an IPv6 /64 being one; zero for TURN's default.
	RelayPerAddress int

	// SigningKey is the instance's, which TURN's secret is derived from.
	SigningKey []byte

	// Loopback admits loopback candidates, for the harness on one machine.
	Loopback bool
	Version  string
	Logger   zerolog.Logger
}

type TrackBounds struct {
	Send  int
	Slots int
}