gortsplib

type Client struct {
	//
	// connection
	//
	// 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 &tls.Config{InsecureSkipVerify:true}
	TLSConfig *tls.Config

	//
	// initialization
	//
	// 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.
	// this can be a security issue.
	// It defaults to false.
	AnyPortEnable bool

	//
	// reading / writing
	//
	// the stream protocol (UDP, Multicast or TCP).
	// If nil, it is chosen automatically (first UDP, then, if it fails, TCP).
	// It defaults to nil.
	Protocol *ClientProtocol
	// 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 1.
	ReadBufferCount int
	// read buffer size.
	// This must be touched only when the server reports problems about buffer sizes.
	// It defaults to 2048.
	ReadBufferSize int

	//
	// callbacks
	//
	// callback called before every request.
	OnRequest func(req *base.Request)
	// callback called after every response.
	OnResponse func(res *base.Response)

	//
	// system functions
	//
	// 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)
	// contains filtered or unexported fields
}

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

type ClientProtocol int

type Server struct {
	//
	// handler
	//
	// an handler interface to handle requests.
	Handler ServerHandler

	//
	// RTSP parameters
	//
	// 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
	// a port to send and receive RTP packets with UDP.
	// If UDPRTPAddress and UDPRTCPAddress are filled, the server can read and write UDP streams.
	UDPRTPAddress string
	// a port to send and receive RTCP packets with UDP.
	// If UDPRTPAddress and UDPRTCPAddress are filled, the server can read and write UDP streams.
	UDPRTCPAddress string
	// a range of multicast IPs to use.
	// If MulticastIPRange, MulticastRTPPort, MulticastRTCPPort are filled, the server
	// can read and write UDP-multicast streams.
	MulticastIPRange string
	// a port to send RTP packets with UDP-multicast.
	// If MulticastIPRange, MulticastRTPPort, MulticastRTCPPort are filled, the server
	// can read and write UDP-multicast streams.
	MulticastRTPPort int
	// a port to send RTCP packets with UDP-multicast.
	// If MulticastIPRange, MulticastRTPPort, MulticastRTCPPort are filled, the server
	// can read and write UDP-multicast streams.
	MulticastRTCPPort int
	// 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 high when using UDP.
	// It defaults to 512
	ReadBufferCount int
	// read buffer size.
	// This must be touched only when the server reports problems about buffer sizes.
	// It defaults to 2048.
	ReadBufferSize int

	//
	// system functions
	//
	// 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
	Req     *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
	Req   *base.Request
	Path  string
	Query string
}

type ServerHandlerOnFrame interface {
	OnFrame(*ServerHandlerOnFrameCtx)
}

type ServerHandlerOnFrameCtx struct {
	Session    *ServerSession
	TrackID    int
	StreamType StreamType
	Payload    []byte
}

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

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

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

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

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

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

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

type ServerHandlerOnRecordCtx struct {
	Session *ServerSession
	Conn    *ServerConn
	Req     *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 {
	Conn  *ServerConn
	Req   *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
	Req       *base.Request
	Path      string
	Query     string
	TrackID   int
	Transport *headers.Transport
}

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

type ServerSessionAnnouncedTrack 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 StreamType = base.StreamType

type Track struct {
	// attributes in SDP format
	Media *psdp.MediaDescription
}

type TrackConfigAAC struct {
	Type              int
	SampleRate        int
	ChannelCount      int
	AOTSpecificConfig []byte
}

type TrackConfigH264 struct {
	SPS []byte
	PPS []byte
}

type Tracks []*Track