mediamtx/internal/core/rtsp_source.go

229 lines
4.8 KiB
Go
Raw Normal View History

package core
2020-10-19 20:17:48 +00:00
import (
2021-05-10 21:23:56 +00:00
"context"
"crypto/sha256"
"crypto/tls"
"encoding/hex"
"fmt"
"strings"
2020-10-19 20:17:48 +00:00
"time"
2023-04-01 16:39:12 +00:00
"github.com/bluenviron/gortsplib/v3"
"github.com/bluenviron/gortsplib/v3/pkg/base"
"github.com/bluenviron/gortsplib/v3/pkg/headers"
"github.com/pion/rtp"
"github.com/aler9/mediamtx/internal/conf"
"github.com/aler9/mediamtx/internal/logger"
2023-04-01 16:39:12 +00:00
"github.com/bluenviron/gortsplib/v3/pkg/url"
2020-10-19 20:17:48 +00:00
)
type rtspSourceParent interface {
logger.Writer
sourceStaticImplSetReady(req pathSourceStaticSetReadyReq) pathSourceStaticSetReadyRes
sourceStaticImplSetNotReady(req pathSourceStaticSetNotReadyReq)
2020-10-19 20:17:48 +00:00
}
type rtspSource struct {
readTimeout conf.StringDuration
writeTimeout conf.StringDuration
readBufferCount int
parent rtspSourceParent
2020-10-19 20:17:48 +00:00
}
func newRTSPSource(
readTimeout conf.StringDuration,
writeTimeout conf.StringDuration,
readBufferCount int,
2022-04-07 10:50:35 +00:00
parent rtspSourceParent,
) *rtspSource {
return &rtspSource{
2021-01-10 11:55:53 +00:00
readTimeout: readTimeout,
writeTimeout: writeTimeout,
readBufferCount: readBufferCount,
parent: parent,
2020-10-19 20:17:48 +00:00
}
}
2022-07-24 16:11:53 +00:00
func (s *rtspSource) Log(level logger.Level, format string, args ...interface{}) {
s.parent.Log(level, "[rtsp source] "+format, args...)
}
func createRangeHeader(cnf *conf.PathConf) (*headers.Range, error) {
switch cnf.RtspRangeType {
case conf.RtspRangeTypeClock:
start, err := time.Parse("20060102T150405Z", cnf.RtspRangeStart)
if err != nil {
return nil, err
}
return &headers.Range{
Value: &headers.RangeUTC{
Start: start,
},
}, nil
case conf.RtspRangeTypeNPT:
start, err := time.ParseDuration(cnf.RtspRangeStart)
if err != nil {
return nil, err
}
return &headers.Range{
Value: &headers.RangeNPT{
Start: start,
},
}, nil
case conf.RtspRangeTypeSMPTE:
start, err := time.ParseDuration(cnf.RtspRangeStart)
if err != nil {
return nil, err
}
return &headers.Range{
Value: &headers.RangeSMPTE{
Start: headers.RangeSMPTETime{
Time: start,
},
},
}, nil
default:
return nil, nil
}
}
// run implements sourceStaticImpl.
func (s *rtspSource) run(ctx context.Context, cnf *conf.PathConf, reloadConf chan *conf.PathConf) error {
2022-07-24 16:11:53 +00:00
s.Log(logger.Debug, "connecting")
2020-10-19 20:17:48 +00:00
var tlsConfig *tls.Config
if cnf.SourceFingerprint != "" {
tlsConfig = &tls.Config{
InsecureSkipVerify: true,
VerifyConnection: func(cs tls.ConnectionState) error {
h := sha256.New()
h.Write(cs.PeerCertificates[0].Raw)
hstr := hex.EncodeToString(h.Sum(nil))
fingerprintLower := strings.ToLower(cnf.SourceFingerprint)
if hstr != fingerprintLower {
return fmt.Errorf("server fingerprint do not match: expected %s, got %s",
fingerprintLower, hstr)
}
return nil
},
}
}
2021-11-12 21:29:56 +00:00
c := &gortsplib.Client{
Transport: cnf.SourceProtocol.Transport,
TLSConfig: tlsConfig,
ReadTimeout: time.Duration(s.readTimeout),
WriteTimeout: time.Duration(s.writeTimeout),
2021-05-10 21:23:56 +00:00
ReadBufferCount: s.readBufferCount,
AnyPortEnable: cnf.SourceAnyPortEnable,
2021-05-10 21:23:56 +00:00
OnRequest: func(req *base.Request) {
2022-07-24 16:11:53 +00:00
s.Log(logger.Debug, "c->s %v", req)
2021-05-10 21:23:56 +00:00
},
OnResponse: func(res *base.Response) {
2022-07-24 16:11:53 +00:00
s.Log(logger.Debug, "s->c %v", res)
2021-05-10 21:23:56 +00:00
},
2023-04-09 15:11:54 +00:00
OnTransportSwitch: func(err error) {
s.Log(logger.Warn, err.Error())
},
OnPacketLost: func(err error) {
s.Log(logger.Warn, err.Error())
},
OnDecodeError: func(err error) {
s.Log(logger.Warn, err.Error())
2022-10-31 18:10:32 +00:00
},
2021-05-10 21:23:56 +00:00
}
u, err := url.Parse(cnf.Source)
2020-10-19 20:17:48 +00:00
if err != nil {
2022-07-24 16:11:53 +00:00
return err
2020-10-19 20:17:48 +00:00
}
2021-11-12 21:29:56 +00:00
err = c.Start(u.Scheme, u.Host)
if err != nil {
2022-07-24 16:11:53 +00:00
return err
}
defer c.Close()
2021-03-23 19:37:43 +00:00
2021-05-10 21:23:56 +00:00
readErr := make(chan error)
go func() {
2021-11-12 21:29:56 +00:00
readErr <- func() error {
medias, baseURL, _, err := c.Describe(u)
2021-11-12 21:29:56 +00:00
if err != nil {
return err
}
err = c.SetupAll(medias, baseURL)
if err != nil {
return err
2021-11-12 21:29:56 +00:00
}
res := s.parent.sourceStaticImplSetReady(pathSourceStaticSetReadyReq{
medias: medias,
generateRTPPackets: false,
})
2022-01-14 22:42:41 +00:00
if res.err != nil {
return res.err
2021-11-12 21:29:56 +00:00
}
s.Log(logger.Info, "ready: %s", sourceMediaInfo(medias))
2021-11-12 21:29:56 +00:00
defer s.parent.sourceStaticImplSetNotReady(pathSourceStaticSetNotReadyReq{})
2021-11-12 21:29:56 +00:00
for _, medi := range medias {
for _, forma := range medi.Formats {
cmedi := medi
cforma := forma
c.OnPacketRTP(cmedi, cforma, func(pkt *rtp.Packet) {
res.stream.writeRTPPacket(cmedi, cforma, pkt, time.Now())
})
}
2021-11-12 21:29:56 +00:00
}
rangeHeader, err := createRangeHeader(cnf)
if err != nil {
return err
}
_, err = c.Play(rangeHeader)
2021-11-12 21:29:56 +00:00
if err != nil {
return err
}
return c.Wait()
}()
2021-05-10 21:23:56 +00:00
}()
2020-10-19 20:17:48 +00:00
for {
select {
case err := <-readErr:
return err
case <-reloadConf:
2021-11-12 21:29:56 +00:00
case <-ctx.Done():
c.Close()
<-readErr
return nil
}
2020-10-19 20:17:48 +00:00
}
}
// apiSourceDescribe implements sourceStaticImpl.
func (*rtspSource) apiSourceDescribe() pathAPISourceOrReader {
return pathAPISourceOrReader{
Type: "rtspSource",
ID: "",
}
}