gortsplib

type Client struct {
	//
	// Target
	//
	// Scheme. Either "rtsp" or "rtsps".
	Scheme string
	// Host and port.
	Host string

	//
	// RTSP parameters (all optional)
	//
	// timeout of read operations.
	// It defaults to 10 seconds.
	ReadTimeout time.Duration
	// timeout of write operations.
	// It defaults to 10 seconds.
	WriteTimeout time.Duration
	// a TLS configuration to connect to TLS/RTSPS servers.
	// It defaults to nil.
	TLSConfig *tls.Config
	// tunneling method.
	Tunnel Tunnel
	// transport protocol (UDP, Multicast or TCP).
	// If nil, it is chosen automatically (first UDP, then, if it fails, TCP).
	// It defaults to nil.
	Protocol *Protocol
	// enable communication with servers which don't provide UDP server ports
	// or use different server ports than the announced ones.
	// This can be a security issue.
	// It defaults to false.
	AnyPortEnable bool
	// If the client is reading with UDP, it must receive
	// at least a packet within this timeout, otherwise it switches to TCP.
	// It defaults to 3 seconds.
	InitialUDPReadTimeout time.Duration
	// Size of the UDP read buffer.
	// This can be increased to reduce packet losses.
	// It defaults to the operating system default value.
	UDPReadBufferSize int
	// Size of the queue of outgoing packets.
	// It defaults to 256.
	WriteQueueSize int
	// maximum size of outgoing RTP / RTCP packets.
	// This must be less than the UDP MTU (1472 bytes).
	// It defaults to 1472.
	MaxPacketSize int
	// user agent header.
	// It defaults to "gortsplib"
	UserAgent string
	// disable automatic RTCP sender reports.
	DisableRTCPSenderReports bool
	// explicitly request back channels to the server.
	RequestBackChannels bool

	//
	// system functions (all optional)
	//
	// function used to initialize the TCP client.
	// It defaults to (&net.Dialer{}).DialContext.
	DialContext func(ctx context.Context, network, address string) (net.Conn, error)
	// function used to initialize UDP listeners.
	// It defaults to net.ListenPacket.
	ListenPacket func(network, address string) (net.PacketConn, error)

	//
	// callbacks (all optional)
	//
	// called when sending a request to the server.
	OnRequest ClientOnRequestFunc
	// called when receiving a response from the server.
	OnResponse ClientOnResponseFunc
	// called when receiving a request from the server.
	OnServerRequest ClientOnRequestFunc
	// called when sending a response to the server.
	OnServerResponse ClientOnResponseFunc
	// called when the transport protocol changes.
	OnTransportSwitch ClientOnTransportSwitchFunc
	// called when the client detects lost packets.
	OnPacketsLost ClientOnPacketsLostFunc
	// called when a non-fatal decode error occurs.
	OnDecodeError ClientOnDecodeErrorFunc
	// contains filtered or unexported fields
}

type ClientOnDecodeErrorFunc func(err error)

type ClientOnPacketsLostFunc func(lost uint64)

type ClientOnRequestFunc func(*base.Request)

type ClientOnResponseFunc func(*base.Response)

type ClientOnTransportSwitchFunc func(err error)

type ClientStats struct {
	Conn    ConnStats
	Session SessionStats
}

type ClientTransport struct {
	Conn ConnTransport
	// present only when SETUP has been called at least once.
	Session *SessionTransport
}

type ConnStats struct {
	// received bytes
	BytesReceived uint64
	// sent bytes
	BytesSent uint64
}

type ConnTransport struct {
	Tunnel Tunnel
}

type OnPacketRTCPAnyFunc func(*description.Media, rtcp.Packet)

type OnPacketRTCPFunc func(rtcp.Packet)

type OnPacketRTPAnyFunc func(*description.Media, format.Format, *rtp.Packet)

type OnPacketRTPFunc func(*rtp.Packet)

type Protocol int

type Server struct {
	//
	// RTSP parameters (all optional except RTSPAddress)
	//
	// the RTSP address of the server, to accept connections and send and receive
	// packets with the TCP transport.
	RTSPAddress string
	// a port to send and receive RTP packets with the UDP transport.
	// If UDPRTPAddress and UDPRTCPAddress are filled, the server can support the UDP transport.
	UDPRTPAddress string
	// a port to send and receive RTCP packets with the UDP transport.
	// If UDPRTPAddress and UDPRTCPAddress are filled, the server can support the UDP transport.
	UDPRTCPAddress string
	// a range of multicast IPs to use with the UDP-multicast transport.
	// If MulticastIPRange, MulticastRTPPort, MulticastRTCPPort are filled, the server
	// can support the UDP-multicast transport.
	MulticastIPRange string
	// a port to send RTP packets with the UDP-multicast transport.
	// If MulticastIPRange, MulticastRTPPort, MulticastRTCPPort are filled, the server
	// can support the UDP-multicast transport.
	MulticastRTPPort int
	// a port to send RTCP packets with the UDP-multicast transport.
	// If MulticastIPRange, MulticastRTPPort, MulticastRTCPPort are filled, the server
	// can support the UDP-multicast transport.
	MulticastRTCPPort int
	// timeout of read operations.
	// It defaults to 10 seconds.
	ReadTimeout time.Duration
	// timeout of write operations.
	// It defaults to 10 seconds.
	WriteTimeout time.Duration
	// read timeout of idle connections and sessions.
	// It defaults to 60 seconds.
	IdleTimeout time.Duration
	// a TLS configuration to accept TLS (RTSPS) connections.
	TLSConfig *tls.Config
	// Size of the UDP read buffer.
	// This can be increased to reduce packet losses.
	// It defaults to the operating system default value.
	UDPReadBufferSize int
	// Size of the queue of outgoing packets.
	// It defaults to 256.
	WriteQueueSize int
	// maximum size of outgoing RTP / RTCP packets.
	// This must be less than the UDP MTU (1472 bytes).
	// It defaults to 1472.
	MaxPacketSize int
	// disable automatic RTCP sender reports.
	DisableRTCPSenderReports bool
	// authentication methods.
	// It defaults to plain and digest+MD5.
	AuthMethods []auth.VerifyMethod

	//
	// handler (optional)
	//
	// an handler to handle server events.
	// It may implement one or more of the ServerHandler* interfaces.
	Handler ServerHandler

	//
	// system functions (all optional)
	//
	// function used to initialize the TCP listener.
	// It defaults to net.Listen.
	Listen func(network string, address string) (net.Listener, error)
	// function used to initialize UDP listeners.
	// It defaults to net.ListenPacket.
	ListenPacket func(network, address string) (net.PacketConn, error)
	// contains filtered or unexported fields
}

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

type ServerHandler interface{}

type ServerHandlerOnAnnounce interface {
	// called when receiving an ANNOUNCE request.
	OnAnnounce(*ServerHandlerOnAnnounceCtx) (*base.Response, error)
}

type ServerHandlerOnAnnounceCtx struct {
	Session     *ServerSession
	Conn        *ServerConn
	Request     *base.Request
	Path        string
	Query       string
	Description *description.Session
}

type ServerHandlerOnConnClose interface {
	// called when a connection is closed.
	OnConnClose(*ServerHandlerOnConnCloseCtx)
}

type ServerHandlerOnConnCloseCtx struct {
	Conn  *ServerConn
	Error error
}

type ServerHandlerOnConnOpen interface {
	// called when a connection is opened.
	OnConnOpen(*ServerHandlerOnConnOpenCtx)
}

type ServerHandlerOnConnOpenCtx struct {
	Conn *ServerConn
}

type ServerHandlerOnDecodeError interface {
	// called when a non-fatal decode error occurs.
	OnDecodeError(*ServerHandlerOnDecodeErrorCtx)
}

type ServerHandlerOnDecodeErrorCtx struct {
	Session *ServerSession
	Error   error
}

type ServerHandlerOnDescribe interface {
	// called when receiving a DESCRIBE request.
	OnDescribe(*ServerHandlerOnDescribeCtx) (*base.Response, *ServerStream, error)
}

type ServerHandlerOnDescribeCtx struct {
	Conn    *ServerConn
	Request *base.Request
	Path    string
	Query   string
}

type ServerHandlerOnGetParameter interface {
	// called when receiving a GET_PARAMETER request.
	OnGetParameter(*ServerHandlerOnGetParameterCtx) (*base.Response, error)
}

type ServerHandlerOnGetParameterCtx struct {
	Session *ServerSession
	Conn    *ServerConn
	Request *base.Request
	Path    string
	Query   string
}

type ServerHandlerOnPacketsLost interface {
	// called when the server detects lost packets.
	OnPacketsLost(*ServerHandlerOnPacketsLostCtx)
}

type ServerHandlerOnPacketsLostCtx struct {
	Session *ServerSession
	Lost    uint64
}

type ServerHandlerOnPause interface {
	// called when receiving a PAUSE request.
	OnPause(*ServerHandlerOnPauseCtx) (*base.Response, error)
}

type ServerHandlerOnPauseCtx struct {
	Session *ServerSession
	Conn    *ServerConn
	Request *base.Request
	Path    string
	Query   string
}

type ServerHandlerOnPlay interface {
	// called when receiving a PLAY request.
	OnPlay(*ServerHandlerOnPlayCtx) (*base.Response, error)
}

type ServerHandlerOnPlayCtx struct {
	Session *ServerSession
	Conn    *ServerConn
	Request *base.Request
	Path    string
	Query   string
}

type ServerHandlerOnRecord interface {
	// called when receiving a RECORD request.
	OnRecord(*ServerHandlerOnRecordCtx) (*base.Response, error)
}

type ServerHandlerOnRecordCtx struct {
	Session *ServerSession
	Conn    *ServerConn
	Request *base.Request
	Path    string
	Query   string
}

type ServerHandlerOnRequest interface {
	// called when receiving a request from a connection.
	OnRequest(*ServerConn, *base.Request)
}

type ServerHandlerOnResponse interface {
	// called when sending a response to a connection.
	OnResponse(*ServerConn, *base.Response)
}

type ServerHandlerOnSessionClose interface {
	// called when a session is closed.
	OnSessionClose(*ServerHandlerOnSessionCloseCtx)
}

type ServerHandlerOnSessionCloseCtx struct {
	Session *ServerSession
	Error   error
}

type ServerHandlerOnSessionOpen interface {
	// called when a session is opened.
	OnSessionOpen(*ServerHandlerOnSessionOpenCtx)
}

type ServerHandlerOnSessionOpenCtx struct {
	Session *ServerSession
	Conn    *ServerConn
}

type ServerHandlerOnSetParameter interface {
	// called when receiving a SET_PARAMETER request.
	OnSetParameter(*ServerHandlerOnSetParameterCtx) (*base.Response, error)
}

type ServerHandlerOnSetParameterCtx struct {
	Session *ServerSession
	Conn    *ServerConn
	Request *base.Request
	Path    string
	Query   string
}

type ServerHandlerOnSetup interface {
	// called when receiving a SETUP request.
	// must return a Response and a stream.
	// the stream is needed to
	// - add the session the the stream's readers
	// - send the stream SSRC to the session
	OnSetup(*ServerHandlerOnSetupCtx) (*base.Response, *ServerStream, error)
}

type ServerHandlerOnSetupCtx struct {
	Session   *ServerSession
	Conn      *ServerConn
	Request   *base.Request
	Path      string
	Query     string
	Transport *SessionTransport
}

type ServerHandlerOnStreamWriteError interface {
	// called when a ServerStream is unable to write packets to a session.
	OnStreamWriteError(*ServerHandlerOnStreamWriteErrorCtx)
}

type ServerHandlerOnStreamWriteErrorCtx struct {
	Session *ServerSession
	Error   error
}

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

type ServerSessionState int

type ServerStream struct {
	Server *Server
	Desc   *description.Session
	// contains filtered or unexported fields
}

type ServerStreamStats struct {
	// sent bytes
	BytesSent uint64
	// number of sent RTP packets
	RTPPacketsSent uint64
	// number of sent RTCP packets
	RTCPPacketsSent uint64

	// media statistics
	Medias map[*description.Media]ServerStreamStatsMedia
}

type ServerStreamStatsFormat struct {
	// number of sent RTP packets
	RTPPacketsSent uint64
	// local SSRC
	LocalSSRC uint32
}

type ServerStreamStatsMedia struct {
	// sent bytes
	BytesSent uint64
	// number of sent RTCP packets
	RTCPPacketsSent uint64

	// format statistics
	Formats map[format.Format]ServerStreamStatsFormat
}

type SessionStats struct {
	// received bytes
	BytesReceived uint64
	// sent bytes
	BytesSent uint64
	// number of RTP packets correctly received and processed
	RTPPacketsReceived uint64
	// number of sent RTP packets
	RTPPacketsSent uint64
	// number of lost RTP packets
	RTPPacketsLost uint64
	// number of RTP packets that could not be processed
	RTPPacketsInError uint64
	// mean jitter of received RTP packets
	RTPPacketsJitter float64
	// number of RTCP packets correctly received and processed
	RTCPPacketsReceived uint64
	// number of sent RTCP packets
	RTCPPacketsSent uint64
	// number of RTCP packets that could not be processed
	RTCPPacketsInError uint64

	// media statistics
	Medias map[*description.Media]SessionStatsMedia
}

type SessionStatsFormat struct {
	// number of RTP packets correctly received and processed
	RTPPacketsReceived uint64
	// number of sent RTP packets
	RTPPacketsSent uint64
	// number of lost RTP packets
	RTPPacketsLost uint64
	// mean jitter of received RTP packets
	RTPPacketsJitter float64
	// local SSRC
	LocalSSRC uint32
	// remote SSRC
	RemoteSSRC uint32
	// last sequence number of incoming/outgoing RTP packets
	RTPPacketsLastSequenceNumber uint16
	// last RTP time of incoming/outgoing RTP packets
	RTPPacketsLastRTP uint32
	// last NTP time of incoming/outgoing NTP packets
	RTPPacketsLastNTP time.Time
}

type SessionStatsMedia struct {
	// received bytes
	BytesReceived uint64
	// sent bytes
	BytesSent uint64
	// number of RTP packets that could not be processed
	RTPPacketsInError uint64
	// number of RTCP packets correctly received and processed
	RTCPPacketsReceived uint64
	// number of sent RTCP packets
	RTCPPacketsSent uint64
	// number of RTCP packets that could not be processed
	RTCPPacketsInError uint64

	// format statistics
	Formats map[format.Format]SessionStatsFormat
}

type SessionTransport struct {
	Protocol Protocol
	Profile  headers.TransportProfile
}

type Tunnel int