seydx
516 lines
9.7 KiB
Go
516 lines
9.7 KiB
Go
package rtsp
|
|
|
|
import (
|
|
"bufio"
|
|
"encoding/binary"
|
|
"fmt"
|
|
"io"
|
|
"net"
|
|
"net/url"
|
|
"strconv"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/AlexxIT/go2rtc/pkg/core"
|
|
"github.com/AlexxIT/go2rtc/pkg/tcp"
|
|
"github.com/pion/rtcp"
|
|
"github.com/pion/rtp"
|
|
)
|
|
|
|
type Conn struct {
|
|
core.Connection
|
|
core.Listener
|
|
|
|
// public
|
|
|
|
Backchannel bool
|
|
Media string
|
|
OnClose func() error
|
|
PacketSize uint16
|
|
SessionName string
|
|
Timeout int
|
|
Transport string // custom transport support, ex. RTSP over WebSocket
|
|
|
|
URL *url.URL
|
|
|
|
// internal
|
|
|
|
auth *tcp.Auth
|
|
conn net.Conn
|
|
keepalive int
|
|
mode core.Mode
|
|
playOK bool
|
|
playErr error
|
|
reader *bufio.Reader
|
|
sequence int
|
|
session string
|
|
uri string
|
|
|
|
state State
|
|
stateMu sync.Mutex
|
|
|
|
transportMode TransportMode
|
|
|
|
// UDP
|
|
|
|
udpRtpConns map[byte]*UDPConnection
|
|
udpRtcpConns map[byte]*UDPConnection
|
|
udpRtpListeners map[byte]*UDPConnection
|
|
udpRtcpListeners map[byte]*UDPConnection
|
|
portToChannel map[int]byte
|
|
channelCounter byte
|
|
}
|
|
|
|
type UDPConnection struct {
|
|
Conn net.UDPConn
|
|
Channel byte
|
|
}
|
|
|
|
type TransportMode int
|
|
|
|
const (
|
|
TransportTCP TransportMode = iota
|
|
TransportUDP
|
|
ReceiveMTU = 1500
|
|
)
|
|
|
|
const (
|
|
ProtoRTSP = "RTSP/1.0"
|
|
MethodOptions = "OPTIONS"
|
|
MethodSetup = "SETUP"
|
|
MethodTeardown = "TEARDOWN"
|
|
MethodDescribe = "DESCRIBE"
|
|
MethodPlay = "PLAY"
|
|
MethodPause = "PAUSE"
|
|
MethodAnnounce = "ANNOUNCE"
|
|
MethodRecord = "RECORD"
|
|
)
|
|
|
|
type State byte
|
|
|
|
func (s State) String() string {
|
|
switch s {
|
|
case StateNone:
|
|
return "NONE"
|
|
case StateConn:
|
|
return "CONN"
|
|
case StateSetup:
|
|
return MethodSetup
|
|
case StatePlay:
|
|
return MethodPlay
|
|
}
|
|
return strconv.Itoa(int(s))
|
|
}
|
|
|
|
const (
|
|
StateNone State = iota
|
|
StateConn
|
|
StateSetup
|
|
StatePlay
|
|
)
|
|
|
|
func (c *Conn) Handle() (err error) {
|
|
var timeout time.Duration
|
|
|
|
var keepaliveDT time.Duration
|
|
var keepaliveTS time.Time
|
|
|
|
switch c.mode {
|
|
case core.ModeActiveProducer:
|
|
if c.keepalive > 5 {
|
|
keepaliveDT = time.Duration(c.keepalive-5) * time.Second
|
|
} else {
|
|
keepaliveDT = 25 * time.Second
|
|
}
|
|
keepaliveTS = time.Now().Add(keepaliveDT)
|
|
|
|
if c.Timeout == 0 {
|
|
// polling frames from remote RTSP Server (ex Camera)
|
|
timeout = time.Second * 5
|
|
|
|
if len(c.Receivers) == 0 {
|
|
// if we only send audio to camera
|
|
// https://github.com/AlexxIT/go2rtc/issues/659
|
|
timeout += keepaliveDT
|
|
}
|
|
} else {
|
|
timeout = time.Second * time.Duration(c.Timeout)
|
|
}
|
|
|
|
case core.ModePassiveProducer:
|
|
// polling frames from remote RTSP Client (ex FFmpeg)
|
|
if c.Timeout == 0 {
|
|
timeout = time.Second * 15
|
|
} else {
|
|
timeout = time.Second * time.Duration(c.Timeout)
|
|
}
|
|
|
|
case core.ModePassiveConsumer:
|
|
// pushing frames to remote RTSP Client (ex VLC)
|
|
timeout = time.Second * 60
|
|
|
|
default:
|
|
return fmt.Errorf("wrong RTSP conn mode: %d", c.mode)
|
|
}
|
|
|
|
for c.state != StateNone {
|
|
ts := time.Now()
|
|
time := ts.Add(timeout)
|
|
|
|
if err = c.conn.SetReadDeadline(time); err != nil {
|
|
return
|
|
}
|
|
|
|
if c.transportMode == TransportUDP {
|
|
if err = c.handleUDPClientData(time); err != nil {
|
|
return err
|
|
}
|
|
} else {
|
|
if err = c.handleTCPClientData(); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if keepaliveDT != 0 && ts.After(keepaliveTS) {
|
|
req := &tcp.Request{Method: MethodOptions, URL: c.URL}
|
|
if err = c.WriteRequest(req); err != nil {
|
|
return
|
|
}
|
|
|
|
keepaliveTS = ts.Add(keepaliveDT)
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (c *Conn) handleUDPClientData(time time.Time) error {
|
|
if c.playErr != nil {
|
|
return c.playErr
|
|
}
|
|
|
|
if c.state == StatePlay && c.playOK {
|
|
return nil
|
|
}
|
|
|
|
var buf4 []byte
|
|
|
|
buf4, err := c.reader.Peek(4)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
switch string(buf4) {
|
|
case "RTSP":
|
|
var res *tcp.Response
|
|
if res, err = c.ReadResponse(); err != nil {
|
|
return err
|
|
}
|
|
|
|
c.Fire(res)
|
|
c.playOK = true
|
|
|
|
for _, listener := range c.udpRtpListeners {
|
|
go func(listener *UDPConnection) {
|
|
defer listener.Conn.Close()
|
|
|
|
for c.state != StateNone {
|
|
if err := listener.Conn.SetReadDeadline(time); err != nil {
|
|
c.playErr = err
|
|
return
|
|
}
|
|
|
|
buffer := make([]byte, ReceiveMTU)
|
|
n, _, err := listener.Conn.ReadFromUDP(buffer)
|
|
if err != nil {
|
|
c.playErr = err
|
|
break
|
|
}
|
|
|
|
packet := &rtp.Packet{}
|
|
if err := packet.Unmarshal(buffer[:n]); err != nil {
|
|
c.playErr = err
|
|
return
|
|
}
|
|
|
|
for _, receiver := range c.Receivers {
|
|
if receiver.ID == listener.Channel {
|
|
receiver.WriteRTP(packet)
|
|
break
|
|
}
|
|
}
|
|
|
|
c.Recv += len(buffer[:n])
|
|
}
|
|
}(listener)
|
|
}
|
|
|
|
for _, listener := range c.udpRtcpListeners {
|
|
go func(listener *UDPConnection) {
|
|
defer listener.Conn.Close()
|
|
|
|
for c.state != StateNone {
|
|
if err := listener.Conn.SetReadDeadline(time); err != nil {
|
|
return
|
|
}
|
|
|
|
buffer := make([]byte, ReceiveMTU)
|
|
n, _, err := listener.Conn.ReadFromUDP(buffer)
|
|
if err != nil {
|
|
break
|
|
}
|
|
|
|
msg := &RTCP{Channel: listener.Channel}
|
|
|
|
if err := msg.Header.Unmarshal(buffer[:n]); err != nil {
|
|
continue
|
|
}
|
|
|
|
msg.Packets, err = rtcp.Unmarshal(buffer[:n])
|
|
if err != nil {
|
|
continue
|
|
}
|
|
|
|
c.Fire(msg)
|
|
}
|
|
}(listener)
|
|
}
|
|
|
|
case "OPTI", "TEAR", "DESC", "SETU", "PLAY", "PAUS", "RECO", "ANNO", "GET_", "SET_":
|
|
var req *tcp.Request
|
|
if req, err = c.ReadRequest(); err != nil {
|
|
return err
|
|
}
|
|
c.Fire(req)
|
|
if req.Method == MethodOptions {
|
|
res := &tcp.Response{Request: req}
|
|
if err = c.WriteResponse(res); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
default:
|
|
return fmt.Errorf("RTSP wrong input")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (c *Conn) handleTCPClientData() error {
|
|
// we can read:
|
|
// 1. RTP interleaved: `$` + 1B channel number + 2B size
|
|
// 2. RTSP response: RTSP/1.0 200 OK
|
|
// 3. RTSP request: OPTIONS ...
|
|
var buf4 []byte // `$` + 1B channel number + 2B size
|
|
var err error
|
|
|
|
buf4, err = c.reader.Peek(4)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var channel byte
|
|
var size uint16
|
|
|
|
if buf4[0] != '$' {
|
|
switch string(buf4) {
|
|
case "RTSP":
|
|
var res *tcp.Response
|
|
if res, err = c.ReadResponse(); err != nil {
|
|
return err
|
|
}
|
|
c.Fire(res)
|
|
// for playing backchannel only after OK response on play
|
|
c.playOK = true
|
|
return nil
|
|
|
|
case "OPTI", "TEAR", "DESC", "SETU", "PLAY", "PAUS", "RECO", "ANNO", "GET_", "SET_":
|
|
var req *tcp.Request
|
|
if req, err = c.ReadRequest(); err != nil {
|
|
return err
|
|
}
|
|
c.Fire(req)
|
|
if req.Method == MethodOptions {
|
|
res := &tcp.Response{Request: req}
|
|
if err = c.WriteResponse(res); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
|
|
default:
|
|
c.Fire("RTSP wrong input")
|
|
|
|
for i := 0; ; i++ {
|
|
// search next start symbol
|
|
if _, err = c.reader.ReadBytes('$'); err != nil {
|
|
return err
|
|
}
|
|
|
|
if channel, err = c.reader.ReadByte(); err != nil {
|
|
return err
|
|
}
|
|
|
|
// TODO: better check maximum good channel ID
|
|
if channel >= 20 {
|
|
continue
|
|
}
|
|
|
|
buf4 = make([]byte, 2)
|
|
if _, err = io.ReadFull(c.reader, buf4); err != nil {
|
|
return err
|
|
}
|
|
|
|
// check if size good for RTP
|
|
size = binary.BigEndian.Uint16(buf4)
|
|
if size <= 1500 {
|
|
break
|
|
}
|
|
|
|
// 10 tries to find good packet
|
|
if i >= 10 {
|
|
return fmt.Errorf("RTSP wrong input")
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
// hope that the odd channels are always RTCP
|
|
channel = buf4[1]
|
|
|
|
// get data size
|
|
size = binary.BigEndian.Uint16(buf4[2:])
|
|
|
|
// skip 4 bytes from c.reader.Peek
|
|
if _, err = c.reader.Discard(4); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
// init memory for data
|
|
buf := make([]byte, size)
|
|
if _, err = io.ReadFull(c.reader, buf); err != nil {
|
|
return err
|
|
}
|
|
|
|
c.Recv += int(size)
|
|
|
|
if channel&1 == 0 {
|
|
packet := &rtp.Packet{}
|
|
if err = packet.Unmarshal(buf); err != nil {
|
|
return err
|
|
}
|
|
|
|
for _, receiver := range c.Receivers {
|
|
if receiver.ID == channel {
|
|
receiver.WriteRTP(packet)
|
|
break
|
|
}
|
|
}
|
|
} else {
|
|
msg := &RTCP{Channel: channel}
|
|
|
|
if err = msg.Header.Unmarshal(buf); err != nil {
|
|
return nil
|
|
}
|
|
|
|
msg.Packets, err = rtcp.Unmarshal(buf)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
|
|
c.Fire(msg)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (c *Conn) WriteRequest(req *tcp.Request) error {
|
|
if req.Proto == "" {
|
|
req.Proto = ProtoRTSP
|
|
}
|
|
|
|
if req.Header == nil {
|
|
req.Header = make(map[string][]string)
|
|
}
|
|
|
|
c.sequence++
|
|
// important to send case sensitive CSeq
|
|
// https://github.com/AlexxIT/go2rtc/issues/7
|
|
req.Header["CSeq"] = []string{strconv.Itoa(c.sequence)}
|
|
|
|
c.auth.Write(req)
|
|
|
|
if c.session != "" {
|
|
req.Header.Set("Session", c.session)
|
|
}
|
|
|
|
if req.Body != nil {
|
|
val := strconv.Itoa(len(req.Body))
|
|
req.Header.Set("Content-Length", val)
|
|
}
|
|
|
|
c.Fire(req)
|
|
|
|
if err := c.conn.SetWriteDeadline(time.Now().Add(Timeout)); err != nil {
|
|
return err
|
|
}
|
|
|
|
return req.Write(c.conn)
|
|
}
|
|
|
|
func (c *Conn) ReadRequest() (*tcp.Request, error) {
|
|
if err := c.conn.SetReadDeadline(time.Now().Add(Timeout)); err != nil {
|
|
return nil, err
|
|
}
|
|
return tcp.ReadRequest(c.reader)
|
|
}
|
|
|
|
func (c *Conn) WriteResponse(res *tcp.Response) error {
|
|
if res.Proto == "" {
|
|
res.Proto = ProtoRTSP
|
|
}
|
|
|
|
if res.Status == "" {
|
|
res.Status = "200 OK"
|
|
}
|
|
|
|
if res.Header == nil {
|
|
res.Header = make(map[string][]string)
|
|
}
|
|
|
|
if res.Request != nil && res.Request.Header != nil {
|
|
seq := res.Request.Header.Get("CSeq")
|
|
if seq != "" {
|
|
res.Header.Set("CSeq", seq)
|
|
}
|
|
}
|
|
|
|
if c.session != "" {
|
|
if res.Request != nil && res.Request.Method == MethodSetup {
|
|
res.Header.Set("Session", c.session+";timeout=60")
|
|
} else {
|
|
res.Header.Set("Session", c.session)
|
|
}
|
|
}
|
|
|
|
if res.Body != nil {
|
|
val := strconv.Itoa(len(res.Body))
|
|
res.Header.Set("Content-Length", val)
|
|
}
|
|
|
|
c.Fire(res)
|
|
|
|
if err := c.conn.SetWriteDeadline(time.Now().Add(Timeout)); err != nil {
|
|
return err
|
|
}
|
|
|
|
return res.Write(c.conn)
|
|
}
|
|
|
|
func (c *Conn) ReadResponse() (*tcp.Response, error) {
|
|
if err := c.conn.SetReadDeadline(time.Now().Add(Timeout)); err != nil {
|
|
return nil, err
|
|
}
|
|
return tcp.ReadResponse(c.reader)
|
|
}
|