gortsplib

type Client struct {
	//
	// 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
	// disable being redirected to other servers, that can happen during Describe().
	// It defaults to false.
	RedirectDisable bool
	// enable communication with servers which don't provide server ports or use
	// different server ports than the ones announced.
	// This can be a security issue.
	// It defaults to false.
	AnyPortEnable bool
	// the stream transport (UDP, Multicast or TCP).
	// If nil, it is chosen automatically (first UDP, then, if it fails, TCP).
	// It defaults to nil.
	Transport *Transport
	// If the client is reading with UDP, it must receive
	// at least a packet within this timeout.
	// It defaults to 3 seconds.
	InitialUDPReadTimeout time.Duration
	// read buffer count.
	// If greater than 1, allows to pass buffers to routines different than the one
	// that is reading frames.
	// It defaults to 256.
	ReadBufferCount int
	// write buffer count.
	// It allows to queue packets before sending them.
	// It defaults to 256.
	WriteBufferCount int
	// user agent header
	// It defaults to "gortsplib"
	UserAgent string

	//
	// 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 before every request.
	OnRequest func(*base.Request)
	// called after every response.
	OnResponse func(*base.Response)
	// called when a RTP packet arrives.
	OnPacketRTP func(*ClientOnPacketRTPCtx)
	// called when a RTCP packet arrives.
	OnPacketRTCP func(*ClientOnPacketRTCPCtx)
	// contains filtered or unexported fields
}

type ClientOnPacketRTCPCtx struct {
	TrackID int
	Packet  rtcp.Packet
}

type ClientOnPacketRTPCtx struct {
	TrackID      int
	Packet       *rtp.Packet
	PTSEqualsDTS bool
	H264NALUs    [][]byte
	H264PTS      time.Duration
}

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
	// a TLS configuration to accept TLS (RTSPS) connections.
	TLSConfig *tls.Config
	// read buffer count.
	// If greater than 1, allows to pass buffers to routines different than the one
	// that is reading frames.
	// It also allows to buffer routed frames and mitigate network fluctuations
	// that are particularly relevant when using UDP.
	// It defaults to 256.
	ReadBufferCount int
	// write buffer count.
	// It allows to queue packets before sending them.
	// It defaults to 256.
	WriteBufferCount int

	//
	// handler (optional)
	//
	// an handler to handle server events.
	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 {
	OnAnnounce(*ServerHandlerOnAnnounceCtx) (*base.Response, error)
}

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

type ServerHandlerOnConnClose interface {
	OnConnClose(*ServerHandlerOnConnCloseCtx)
}

type ServerHandlerOnConnCloseCtx struct {
	Conn  *ServerConn
	Error error
}

type ServerHandlerOnConnOpen interface {
	OnConnOpen(*ServerHandlerOnConnOpenCtx)
}

type ServerHandlerOnConnOpenCtx struct {
	Conn *ServerConn
}

type ServerHandlerOnDescribe interface {
	OnDescribe(*ServerHandlerOnDescribeCtx) (*base.Response, *ServerStream, error)
}

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

type ServerHandlerOnGetParameter interface {
	OnGetParameter(*ServerHandlerOnGetParameterCtx) (*base.Response, error)
}

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

type ServerHandlerOnPacketRTCP interface {
	OnPacketRTCP(*ServerHandlerOnPacketRTCPCtx)
}

type ServerHandlerOnPacketRTCPCtx struct {
	Session *ServerSession
	TrackID int
	Packet  rtcp.Packet
}

type ServerHandlerOnPacketRTP interface {
	OnPacketRTP(*ServerHandlerOnPacketRTPCtx)
}

type ServerHandlerOnPacketRTPCtx struct {
	Session      *ServerSession
	TrackID      int
	Packet       *rtp.Packet
	PTSEqualsDTS bool
	H264NALUs    [][]byte
	H264PTS      time.Duration
}

type ServerHandlerOnPause interface {
	OnPause(*ServerHandlerOnPauseCtx) (*base.Response, error)
}

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

type ServerHandlerOnPlay interface {
	OnPlay(*ServerHandlerOnPlayCtx) (*base.Response, error)
}

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

type ServerHandlerOnRecord interface {
	OnRecord(*ServerHandlerOnRecordCtx) (*base.Response, error)
}

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

type ServerHandlerOnRequest interface {
	OnRequest(*ServerConn, *base.Request)
}

type ServerHandlerOnResponse interface {
	OnResponse(*ServerConn, *base.Response)
}

type ServerHandlerOnSessionClose interface {
	OnSessionClose(*ServerHandlerOnSessionCloseCtx)
}

type ServerHandlerOnSessionCloseCtx struct {
	Session *ServerSession
	Error   error
}

type ServerHandlerOnSessionOpen interface {
	OnSessionOpen(*ServerHandlerOnSessionOpenCtx)
}

type ServerHandlerOnSessionOpenCtx struct {
	Session *ServerSession
	Conn    *ServerConn
}

type ServerHandlerOnSetParameter interface {
	OnSetParameter(*ServerHandlerOnSetParameterCtx) (*base.Response, error)
}

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

type ServerHandlerOnSetup interface {
	// 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 {
	Server    *Server
	Session   *ServerSession
	Conn      *ServerConn
	Request   *base.Request
	Path      string
	Query     string
	TrackID   int
	Transport Transport
}

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

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

type ServerSessionState int

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

type Track interface {
	// ClockRate returns the track clock rate.
	ClockRate() int

	// GetControl returns the track control attribute.
	GetControl() string

	// SetControl sets the track control attribute.
	SetControl(string)

	// MediaDescription returns the track media description in SDP format.
	MediaDescription() *psdp.MediaDescription
	// contains filtered or unexported methods
}

type TrackGeneric struct {
	Media   string
	Formats []string
	RTPMap  string
	FMTP    string
	// contains filtered or unexported fields
}

type TrackH264 struct {
	PayloadType uint8
	SPS         []byte
	PPS         []byte
	// contains filtered or unexported fields
}

type TrackH265 struct {
	PayloadType uint8
	VPS         []byte
	SPS         []byte
	PPS         []byte
	// contains filtered or unexported fields
}

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

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

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

type TrackMPEG4Audio struct {
	PayloadType      uint8
	Config           *mpeg4audio.Config
	SizeLength       int
	IndexLength      int
	IndexDeltaLength int
	// contains filtered or unexported fields
}

type TrackOpus struct {
	PayloadType  uint8
	SampleRate   int
	ChannelCount int
	// contains filtered or unexported fields
}

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

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

type TrackVP8 struct {
	PayloadType uint8
	MaxFR       *int
	MaxFS       *int
	// contains filtered or unexported fields
}

type TrackVP9 struct {
	PayloadType uint8
	MaxFR       *int
	MaxFS       *int
	ProfileID   *int
	// contains filtered or unexported fields
}

type Tracks []Track

type Transport int