srt

type AcceptFunc func(req ConnRequest) bool

type AcceptRejectFunc func(req ConnRequest) RejectReason

type BackupState int

type BindingTime int

type Config struct {
	// Latency is the TSBPD latency (receive delay).
	// The actual latency used is max(local, remote) during negotiation.
	// Default: 120ms. Minimum: 20ms.
	// If RecvLatency or PeerLatency are set, they override this value
	// for their respective directions.
	Latency time.Duration

	// RecvLatency is the TSBPD latency for receiving data (SRTO_RCVLATENCY).
	// If zero, defaults to Latency.
	RecvLatency time.Duration

	// PeerLatency is the minimum TSBPD latency requested of the peer (SRTO_PEERLATENCY).
	// If zero, defaults to Latency.
	PeerLatency time.Duration

	// MSS is the Maximum Segment Size (MTU - IP - UDP headers).
	// Negotiated to the smaller of the two sides.
	// Default: 1500. Range: 76-1500.
	MSS int

	// FC is the flow control window in packets.
	// Default: 25600.
	FC int

	// MaxBW is the maximum sending bandwidth in bytes per second.
	// When > 0, used directly (no overhead applied).
	// When 0 and InputBW > 0, InputBW * (1 + OverheadBW/100) is used.
	// When 0 and InputBW == 0, defaults to 125 MB/s (1 Gbps).
	MaxBW int64

	// OverheadBW is the bandwidth overhead percentage for retransmissions.
	// Range: 5-100. Default: 25.
	OverheadBW int

	// SendBufSize is the send buffer size in packets.
	// Default: 8192.
	SendBufSize int

	// RecvBufSize is the receive buffer size in packets.
	// Default: 8192.
	RecvBufSize int

	// PayloadSize is the maximum payload size per packet (SRTO_PAYLOADSIZE).
	// When 0 (default), derived from MSS: MSS - 44 (IP 20 + UDP 8 + SRT 16).
	// When set, must be <= MSS - 44. Used for CC pacing and fragmentation limit.
	PayloadSize int

	// StreamID is the stream identifier sent during the handshake.
	// Maximum 512 bytes. Used by the listener to route/authorize connections.
	StreamID string

	// Passphrase enables encryption. Must be 10-80 bytes if set.
	Passphrase string

	// KeyLength is the AES key size in bytes: 16 (AES-128), 24 (AES-192), or 32 (AES-256).
	// Default: 16. Only used when Passphrase is set.
	KeyLength int

	// CryptoMode selects the encryption cipher mode.
	// 0 = auto (responder adopts initiator's mode), 1 = AES-CTR, 2 = AES-GCM.
	// Default: 0 (auto, which defaults to CTR for initiators).
	// SRTO_CRYPTOMODE: CIPHER_MODE_AUTO=0, CIPHER_MODE_AES_CTR=1, CIPHER_MODE_AES_GCM=2.
	CryptoMode int

	// ConnTimeout is the handshake timeout.
	// Default: 3s.
	ConnTimeout time.Duration

	// Linger is the maximum time Close() will wait for the send buffer
	// to drain before shutting down. Default: 0 (immediate close).
	// Maximum: 3s.
	Linger time.Duration

	// PeerIdleTimeout is the duration of peer inactivity (no packets received)
	// before the connection is considered timed out.
	// Default: 5s. Minimum: 1s.
	PeerIdleTimeout time.Duration

	// KMRefreshRate is the number of packets sent before switching to a new
	// encryption key. Set to 0 to disable key rotation.
	// Default: 2^24 (~16.7M packets).
	KMRefreshRate uint64

	// KMPreAnnounce is the number of packets before the refresh point at
	// which the new key is announced to the peer via KMREQ.
	// Must be less than KMRefreshRate/2. Default: 2^16 (65536 packets).
	KMPreAnnounce uint64

	// MessageAPI enables message-oriented delivery (default: true for live mode).
	// When true, each Write/Read preserves message boundaries.
	// When false, data is treated as a byte stream (FlagStream in handshake).
	MessageAPI *bool

	// TransType selects a bundle of settings. TransTypeFile overrides
	// Congestion to "file" and sets appropriate defaults.
	// Default: TransTypeLive.
	TransType TransType

	// Congestion selects the congestion control algorithm: "live" or "file".
	// Overridden by TransType if set to TransTypeFile.
	// Default: "live".
	Congestion CongestionType

	// MinVersion is the minimum SRT version required of the peer (SRTO_MINVERSION).
	// Connections from peers with a lower version are rejected.
	// Default: 0x010000 (1.0.0).
	MinVersion uint32

	// LossMaxTTL is the maximum reorder tolerance in packets (SRTO_LOSSMAXTTL).
	// When > 0, enables the FreshLoss mechanism: NAK is deferred for up to this
	// many received packets to allow out-of-order arrivals before reporting loss.
	// Default: 0 (immediate NAK, no reorder tolerance).
	LossMaxTTL int

	// SndDropDelay is extra sender drop delay in milliseconds (SRTO_SNDDROPDELAY).
	// Added to the TSBPD latency when computing the sender-side drop threshold.
	// Set to -1 to disable sender-side too-late drop entirely.
	// Default: 0.
	SndDropDelay int

	// EnforcedEncryption when true (default), requires both sides to use
	// matching encryption. When false, allows mixed encrypted/unencrypted
	// connections (SRTO_ENFORCEDENCRYPTION).
	EnforcedEncryption *bool

	// NAKReport when true (default for live mode), enables periodic NAK reports.
	// When false, only immediate NAKs are sent on gap detection.
	// Always false for file mode (SRTO_NAKREPORT).
	NAKReport *bool

	// RetransmitAlgo selects the retransmission algorithm (SRTO_RETRANSMITALGO).
	// 0 = always immediate retransmit on NAK (no timing gate).
	// 1 = timing gate: skip retransmit if packet was recently sent (default for live).
	// Default: 1 for live mode, 0 for file mode.
	RetransmitAlgo *int

	// DriftTracer when true (default), enables TSBPD drift correction.
	// When false, drift compensation is disabled (SRTO_DRIFTTRACER).
	DriftTracer *bool

	// IPTTL sets the IP Time-To-Live for outgoing packets (SRTO_IPTTL).
	// Default: -1 (use OS default). Range: 1-255.
	IPTTL int

	// IPTOS sets the IP Type-Of-Service / DiffServ field (SRTO_IPTOS).
	// Default: -1 (use OS default). Range: 0-255.
	IPTOS int

	// InputBW is the estimated input bandwidth in bytes per second (SRTO_INPUTBW).
	// When MaxBW is 0 (auto), InputBW * (1 + OverheadBW/100) is used as the
	// effective sending rate. Default: 0 (not used).
	InputBW int64

	// MinInputBW is the minimum input bandwidth estimate in bytes per second
	// (SRTO_MININPUTBW). When auto-input-rate sampling is active (MaxBW=0 and
	// InputBW=0), the sampled rate will not drop below this floor. Default: 0.
	MinInputBW int64

	// MaxRexmitBW is the maximum retransmission bandwidth in bytes per second
	// (SRTO_MAXREXMITBW). When > 0, retransmissions are rate-limited using a
	// token bucket. 0 = unlimited (default).
	MaxRexmitBW int64

	// SndSyn when true (default), Write blocks until send buffer has space.
	// When false, Write returns ErrWouldBlock if the send buffer is full.
	// SRTO_SNDSYN (default: true).
	SndSyn *bool

	// RcvSyn when true (default), Read blocks until data is available.
	// When false, Read returns ErrWouldBlock if no data is ready.
	// SRTO_RCVSYN (default: true).
	RcvSyn *bool

	// PacketFilter is the FEC filter configuration string (SRTO_PACKETFILTER).
	// Format: "fec,cols:N,rows:M,layout:staircase,arq:onreq"
	// Empty string disables FEC. Default: "" (disabled).
	PacketFilter string

	// GroupConnect enables accepting grouped connections on a listener.
	// When true, the listener recognizes the group handshake extension
	// and allows multiple connections to join the same group.
	// Default: false (group connections rejected). Maps to SRTO_GROUPCONNECT.
	GroupConnect bool

	// GroupStabTimeout is the minimum stability timeout for backup mode.
	// A link with no response for longer than this is considered unstable.
	// Only used in GroupBackup mode. Default: 1s.
	// Maps to SRTO_GROUPMINSTABLETIMEO.
	GroupStabTimeout time.Duration

	// UDPSendBufSize sets the UDP socket send buffer size in bytes (SO_SNDBUF).
	// When 0 (default), the OS default is used. Must be >= MSS when set.
	// Maps to SRTO_UDP_SNDBUF (PREBIND option, set before I/O).
	UDPSendBufSize int

	// UDPRecvBufSize sets the UDP socket receive buffer size in bytes (SO_RCVBUF).
	// When 0 (default), the OS default is used. Must be >= MSS when set.
	// Maps to SRTO_UDP_RCVBUF (PREBIND option, set before I/O).
	UDPRecvBufSize int

	// IPv6Only controls whether an IPv6 socket accepts IPv4 connections
	// via IPv4-mapped IPv6 addresses (dual-stack). When nil, the OS default
	// is used. When true, only IPv6 is allowed. When false, dual-stack is
	// enabled. Only meaningful for IPv6 listeners. Maps to IPV6_V6ONLY.
	IPv6Only *bool

	// BindToDevice binds the socket to a specific network interface.
	// Only supported on Linux (SO_BINDTODEVICE). Empty string disables.
	BindToDevice string

	// Sender determines the data direction role for HSv4 connections.
	// When non-nil and true, this side sends HSREQ first (data sender role).
	// When nil or false, this side is the responder (data receiver role).
	// Only meaningful for HSv4 connections; HSv5 is always bidirectional.
	Sender *bool

	// Logger receives diagnostic log messages. When nil (the default),
	// no logging occurs and there is zero performance overhead.
	Logger Logger
}

type CongestionType string

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

type ConnConfig struct {
	LocalAddr    net.Addr
	RemoteAddr   net.Addr
	SocketID     uint32
	PeerSocketID uint32
	StreamID     string
	IsServer     bool

	Mux      *mux.Mux
	OwnsMux  bool // true for client-side connections (Dial creates its own mux)
	RecvChan <-chan packet.Packet
	Clock    clock.Clock

	SendISN seq.Number
	RecvISN seq.Number

	SendBufSize         int                     // packets
	RecvBufSize         int                     // packets
	MaxBW               int64                   // bytes/sec
	TsbpdDelay          time.Duration           // local TSBPD receive latency
	PeerTsbpdDelay      time.Duration           // peer's TSBPD receive latency (for sender-side drop)
	FC                  int                     // flow control window (packets)
	PayloadSize         int                     // max payload per packet (0 = default 1456)
	CryptoCtx           *crypto.Context         // encryption context (nil = unencrypted)
	ActiveKey           packet.PacketEncryption // which key slot to use for encryption
	Linger              time.Duration           // max wait for send buffer drain on Close
	PeerIdleTimeout     time.Duration           // peer inactivity timeout
	Passphrase          string                  // for key rotation (KMREQ/KMRSP)
	KMRefreshRate       uint64                  // packets before key switch (0 = disabled)
	KMPreAnnounce       uint64                  // packets before refresh to announce new key
	MessageAPI          bool                    // true = message boundaries preserved
	Congestion          CongestionType          // "live" or "file" (empty = "live")
	NAKReport           bool                    // true = enable periodic NAK reports
	PeerNakReport       bool                    // true if peer sends periodic NAK reports
	RetransmitAlgo      int                     // SRTO_RETRANSMITALGO: 0=always immediate, 1=timing gate
	LossMaxTTL          int                     // max reorder tolerance (0 = disabled)
	SndDropDelay        int                     // extra sender drop delay in ms (-1 = disable)
	InputBW             int64                   // estimated input bandwidth (bytes/sec, 0 = unused)
	MinInputBW          int64                   // minimum input bandwidth for auto-rate (bytes/sec)
	OverheadBW          int                     // bandwidth overhead percentage
	DriftTracer         bool                    // true = enable TSBPD drift correction (default true)
	PeerSRTVersion      uint32                  // peer's SRT version from handshake HSRSP
	PeerStartTime       uint32                  // peer's timestamp from handshake (for TSBPD timebase)
	PacketFilter        string                  // negotiated FEC filter config ("" = disabled)
	GroupID             uint32                  // local group ID (0 = not grouped)
	PeerGroupID         uint32                  // peer's group ID (0 = not grouped)
	GroupType           uint8                   // group type (1=broadcast, 2=backup)
	GroupWeight         uint16                  // member weight for group operations
	SndSyn              bool                    // true = blocking Write (default)
	RcvSyn              bool                    // true = blocking Read (default)
	MaxRexmitBW         int64                   // max retransmit bandwidth (bytes/sec, 0 = unlimited)
	MinVersion          uint32                  // minimum peer SRT version
	EnforcedEncryption  bool                    // true = encryption strictly enforced
	GroupConnectEnabled bool                    // true = listener accepts grouped connections
	Logger              Logger                  // diagnostic logger (nil = disabled)
}

type ConnRequest struct {
	// StreamID is the stream identifier from the caller's handshake.
	StreamID string
	// RemoteAddr is the caller's address.
	RemoteAddr net.Addr
	// HSVersion is the handshake version (4 or 5).
	HSVersion uint32
	// GroupID is the peer's group ID (0 = not a group connection).
	GroupID uint32
	// GroupType is the group type (1=broadcast, 2=backup).
	GroupType uint8
}

type ConnState int

type ConnStats struct {
	// Timing
	StartTime time.Time     // connection creation time
	Duration  time.Duration // time since connection start

	// Sent packet/byte counters
	SentPackets       uint64 // total DATA packets sent (including retransmissions)
	SentBytes         uint64 // payload bytes sent
	SentUniquePackets uint64 // unique DATA packets sent (SentPackets - Retransmits)
	SentUniqueBytes   uint64 // payload bytes for unique sends
	Retransmits       uint64 // retransmitted packets sent
	RetransBytes      uint64 // payload bytes for retransmitted packets

	// Received packet/byte counters
	RecvPackets       uint64 // total DATA packets received (including retransmissions)
	RecvBytes         uint64 // payload bytes received
	RecvUniquePackets uint64 // unique DATA packets received (RecvPackets - RecvRetrans)
	RecvUniqueBytes   uint64 // payload bytes for unique receives
	RecvRetrans       uint64 // retransmitted packets received
	RecvRetransBytes  uint64 // payload bytes of retransmitted packets received

	// Loss
	LostPackets  uint64  // packets reported as lost at sender side (from NAKs)
	RecvLoss     uint64  // packets detected as missing at receiver side (gap detection)
	SendLossRate float64 // LostPackets / SentPackets * 100
	RecvLossRate float64 // RecvDropped / (RecvPackets + RecvDropped) * 100

	// Total bytes including IP/UDP/SRT header overhead (44 bytes per packet)
	// These match byteSentTotal/byteRecvTotal semantics.
	SentTotalBytes          uint64 // payload + headers for all sent packets
	RecvTotalBytes          uint64 // payload + headers for all received packets
	SentUniqueTotalBytes    uint64 // payload + headers for unique sent packets
	RecvUniqueTotalBytes    uint64 // payload + headers for unique received packets
	RecvLossBytes           uint64 // estimated bytes for lost packets (pkt count * avg payload + headers)
	RetransTotalBytes       uint64 // payload + headers for retransmitted packets
	RecvRetransTotalBytes   uint64 // payload + headers for received retransmissions
	SentDropTotalBytes      uint64 // payload + headers for sender-dropped packets
	RecvDropTotalBytes      uint64 // payload + headers for receiver-dropped packets
	RecvBelatedTotalBytes   uint64 // payload + headers for belated packets
	RecvUndecryptTotalBytes uint64 // payload + headers for undecrypted packets

	// Bitrates (interval mode: computed from interval bytes/duration)
	MbpsSendRate float64 // send bitrate in Mbps
	MbpsRecvRate float64 // receive bitrate in Mbps

	// RTT
	RTT       time.Duration
	RTTVar    time.Duration
	RTTFactor float64 // RTT / NegotiatedLatency

	// Flight and buffer state
	FlowWindow       int // flow window size in packets
	FlightSize       int // packets in flight (sent but not ACK'd)
	SendBufSize      int // packets in send buffer
	SendBufAvailable int // free slots in send buffer
	SendBufBytes     int // estimated payload bytes in send buffer
	RecvBufSize      int // packets in receive buffer
	RecvBufAvailable int // free slots in receive buffer
	RecvBufBytes     int // estimated payload bytes in receive buffer

	// Instantaneous measurements
	NegotiatedLatency  time.Duration // negotiated TSBPD delay
	PacketReceiveRate  uint32        // packets/sec
	EstimatedBandwidth uint32        // probe link capacity (packets/sec)
	UsPktSndPeriod     float64       // inter-packet send period in μs
	MbpsMaxBW          float64       // configured max bandwidth in Mbps
	MsSndBuf           time.Duration // age of oldest unacked packet in send buffer
	MsRcvBuf           time.Duration // timespan of data in receive buffer

	// Control packet counters
	SentACKs    uint64
	SentNAKs    uint64
	SentACKACKs uint64
	RecvACKs    uint64
	RecvNAKs    uint64
	RecvACKACKs uint64

	// Receiver-side counters
	RecvDropped        uint64 // packets dropped due to too-late arrival
	RecvDroppedBytes   uint64 // payload bytes of receiver-dropped packets
	RecvBelated        uint64 // packets arrived after already dropped/ACK'd
	RecvBelatedBytes   uint64 // payload bytes of belated packets
	RecvUndecrypt      uint64 // packets that failed decryption
	RecvUndecryptBytes uint64 // payload bytes of undecrypted packets

	// Sender-side counters
	SentDropped      uint64 // packets dropped from send buffer (too late)
	SentDroppedBytes uint64 // payload bytes of sender-dropped packets

	// Key management counters
	SentKM uint64 // KMREQ packets sent
	RecvKM uint64 // KMREQ/KMRSP packets received

	// Key management state (matches m_SndKmState / m_RcvKmState)
	// 0=unsecured, 1=securing, 2=secured, 3=nosecret, 4=badsecret, 5=badcryptomode
	SndKmState int
	RcvKmState int

	// Sender duration and congestion
	UsSndDuration    int64 // accumulated microseconds sender had data to transmit
	CongestionWindow int   // congestion window in packets (= FC for live mode)

	// Reorder tracking
	ReorderTolerance int32 // configured reorder tolerance (packets)
	ReorderDistance  int32 // maximum observed reorder distance (packets)

	// Belated arrival timing
	RcvAvgBelatedTime time.Duration // average lateness of belated packets

	// FEC statistics
	SndFilterExtra  uint64 // FEC control packets sent
	RcvFilterExtra  uint64 // FEC control packets received
	RcvFilterSupply uint64 // packets recovered by FEC
	RcvFilterLoss   uint64 // irrecoverable losses reported to ARQ

	// Negotiated parameters
	NegotiatedMSS   int           // negotiated maximum segment size
	NegotiatedFC    int           // negotiated flow control window
	MsSndTsbPdDelay time.Duration // peer's TSBPD delay (sender side)
	MsRcvTsbPdDelay time.Duration // local TSBPD delay (receiver side)
}

type ConnType int

type ConnectFunc func(req ConnRequest) ConnType

type Event struct {
	// Conn is the connection that generated the event.
	Conn *Conn
	// Type indicates what kind of readiness triggered the event.
	Type EventType
	// Err is non-nil for EventError, describing why the connection failed.
	Err error
}

type EventType int

type ExtendedConnStats struct {
	ConnStats

	// IIR-8 smoothed buffer occupancy
	AvgSndBufPkts  float64 // average send buffer occupancy in packets
	AvgSndBufBytes float64 // average send buffer occupancy in bytes
	AvgRcvBufPkts  float64 // average receive buffer occupancy in packets
	AvgRcvBufBytes float64 // average receive buffer occupancy in bytes

	// Send rate from circular buffer estimator
	SendRatePps int64 // smoothed send rate in packets/sec
	SendRateBps int64 // smoothed send rate in bytes/sec
}

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

type GroupMemberData struct {
	// State is the backup state of this member (e.g., ActiveStable, Standby).
	State BackupState
	// Weight is the member's priority weight (higher = preferred for backup).
	Weight uint16
	// RTT is the member's current smoothed round-trip time.
	RTT time.Duration
}

type GroupMode int

type GroupStats struct {
	Members       int    // total member connections
	ActiveMembers int    // members in Running state
	SentPackets   uint64 // total packets sent across all members
	RecvPackets   uint64 // total packets received (before dedup)
	RecvDedups    uint64 // packets dropped as duplicates
}

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

type LogCategory string

type LogLevel int

type Logger interface {
	// Log emits a log message. socketID is 0 for non-connection-scoped messages.
	// Implementations should not block or perform expensive operations.
	Log(level LogLevel, category LogCategory, socketID uint32, msg string)
}

type MemberInfo struct {
	Token       int
	Status      MemberStatus
	BackupState BackupState // only meaningful in Backup mode
	Weight      uint16
	LocalAddr   net.Addr
	RemoteAddr  net.Addr
	RTT         time.Duration
}

type MemberStatus int

type MsgCtrl struct {
	// SrcTime is a custom source timestamp for the message (send only).
	// When zero, the current time is used (default behavior).
	SrcTime time.Time

	// MsgTTL is a per-message time-to-live (send only). Packets older than
	// this are dropped from the send buffer before retransmission.
	// Zero means no per-message TTL (use the global TSBPD drop threshold).
	MsgTTL time.Duration

	// InOrder specifies whether this message must be delivered in order (send only).
	// When true, the receiver will only deliver this message after all
	// earlier messages have been delivered. When false, the receiver may
	// deliver this message out of order if it arrives before earlier ones.
	// Default true for live, false allowed for file.
	InOrder bool

	// Boundary indicates the packet position within a message (read only).
	// One of: packet.PositionSingle, PositionFirst, PositionMiddle, PositionLast.
	Boundary int

	// PktSeq is the first packet sequence number of the message (read only).
	PktSeq uint32

	// MsgNo is the message number (read only).
	MsgNo uint32

	// GroupData provides per-member status when reading from a bonded group.
	// Each entry corresponds to one group member connection and reports its
	// current state and RTT. Nil for non-group connections.
	GroupData []GroupMemberData
}

type RejectReason = packet.HandshakeType

type Server struct {
	// Addr is the address to listen on (e.g., ":6000").
	Addr string

	// Config is the SRT configuration. If nil, DefaultConfig() is used.
	Config *Config

	// HandleConnect is called during the handshake to classify and
	// authorize the connection. If nil, all connections are rejected.
	// This is called once per connection, during the handshake phase.
	HandleConnect ConnectFunc

	// HandlePublish is called for connections classified as Publish.
	// It blocks for the lifetime of the connection. The connection is
	// closed when the handler returns.
	HandlePublish func(conn *Conn)

	// HandleSubscribe is called for connections classified as Subscribe.
	// It blocks for the lifetime of the connection. The connection is
	// closed when the handler returns.
	HandleSubscribe func(conn *Conn)
	// contains filtered or unexported fields
}

type SockOpt int

type StreamIDInfo struct {
	UserName     string            // "u" — user/application name
	ResourceName string            // "r" — resource path (e.g. "live/stream")
	HostName     string            // "h" — host name
	SessionID    string            // "s" — session identifier
	Type         StreamType        // "t" — session type
	Mode         StreamMode        // "m" — data direction
	Extra        map[string]string // any non-standard keys
}

type StreamMode string

type StreamType string

type TransType int

type WatchOpts struct {
	// EdgeTriggered enables edge-triggered mode (like epoll EPOLLET).
	// When true, events fire only on state transitions (e.g., not-readable -> readable),
	// not while the condition persists. After an ET event is delivered, it will not
	// fire again until the condition clears and re-triggers.
	// Default: false (level-triggered, matching standard epoll behavior).
	EdgeTriggered bool
}

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