|
|
// Copyright 2020, Chef. All rights reserved.
|
|
|
// https://github.com/q191201771/lal
|
|
|
//
|
|
|
// Use of this source code is governed by a MIT-style license
|
|
|
// that can be found in the License file.
|
|
|
//
|
|
|
// Author: Chef (191201771@qq.com)
|
|
|
|
|
|
package rtsp
|
|
|
|
|
|
import (
|
|
|
"net"
|
|
|
"strings"
|
|
|
"sync"
|
|
|
"sync/atomic"
|
|
|
"time"
|
|
|
|
|
|
"github.com/q191201771/naza/pkg/connection"
|
|
|
|
|
|
"github.com/q191201771/naza/pkg/nazanet"
|
|
|
|
|
|
"github.com/q191201771/lal/pkg/base"
|
|
|
"github.com/q191201771/lal/pkg/rtprtcp"
|
|
|
"github.com/q191201771/lal/pkg/sdp"
|
|
|
|
|
|
"github.com/q191201771/naza/pkg/unique"
|
|
|
|
|
|
"github.com/q191201771/naza/pkg/nazalog"
|
|
|
)
|
|
|
|
|
|
// PubSession会同时向上层回调rtp packet，以及rtp合并后的av packet
|
|
|
type PubSessionObserver interface {
|
|
|
OnRTPPacket(pkt rtprtcp.RTPPacket)
|
|
|
|
|
|
// @param asc: AAC AudioSpecificConfig，注意，如果不存在音频，则为nil
|
|
|
// @param vps: 视频为H264时为nil，视频为H265时不为nil
|
|
|
OnAVConfig(asc, vps, sps, pps []byte)
|
|
|
|
|
|
// @param pkt: pkt结构体中字段含义见rtprtcp.OnAVPacket
|
|
|
OnAVPacket(pkt base.AVPacket)
|
|
|
}
|
|
|
|
|
|
type PubSession struct {
|
|
|
UniqueKey string
|
|
|
StreamName string // presentation
|
|
|
observer PubSessionObserver
|
|
|
avPacketQueue *AVPacketQueue
|
|
|
|
|
|
audioUnpacker *rtprtcp.RTPUnpacker
|
|
|
videoUnpacker *rtprtcp.RTPUnpacker
|
|
|
audioRRProducer *rtprtcp.RRProducer
|
|
|
videoRRProducer *rtprtcp.RRProducer
|
|
|
audioSsrc uint32
|
|
|
videoSsrc uint32
|
|
|
audioPayloadType base.AVPacketPT
|
|
|
videoPayloadType base.AVPacketPT
|
|
|
audioAControl string
|
|
|
videoAControl string
|
|
|
|
|
|
audioRTPConn *nazanet.UDPConnection
|
|
|
videoRTPConn *nazanet.UDPConnection
|
|
|
audioRTCPConn *nazanet.UDPConnection
|
|
|
videoRTCPConn *nazanet.UDPConnection
|
|
|
currConnStat connection.Stat
|
|
|
prevConnStat connection.Stat
|
|
|
stat base.StatPub
|
|
|
|
|
|
vps []byte // 如果是H265的话
|
|
|
sps []byte
|
|
|
pps []byte
|
|
|
asc []byte
|
|
|
|
|
|
m sync.Mutex
|
|
|
rawSDP []byte
|
|
|
}
|
|
|
|
|
|
func NewPubSession(streamName string) *PubSession {
|
|
|
uk := unique.GenUniqueKey("RTSPPUB")
|
|
|
ps := &PubSession{
|
|
|
UniqueKey: uk,
|
|
|
StreamName: streamName,
|
|
|
stat: base.StatPub{
|
|
|
StatSession: base.StatSession{
|
|
|
Protocol: base.ProtocolRTSP,
|
|
|
StartTime: time.Now().Format("2006-01-02 15:04:05.999"),
|
|
|
},
|
|
|
},
|
|
|
}
|
|
|
nazalog.Infof("[%s] lifecycle new rtsp PubSession. session=%p, streamName=%s", uk, ps, streamName)
|
|
|
return ps
|
|
|
}
|
|
|
|
|
|
func (p *PubSession) SetObserver(observer PubSessionObserver) {
|
|
|
p.observer = observer
|
|
|
|
|
|
p.observer.OnAVConfig(p.asc, p.vps, p.sps, p.pps)
|
|
|
}
|
|
|
|
|
|
func (p *PubSession) InitWithSDP(rawSDP []byte, sdpCtx sdp.SDPContext) {
|
|
|
p.m.Lock()
|
|
|
p.rawSDP = rawSDP
|
|
|
p.m.Unlock()
|
|
|
|
|
|
var err error
|
|
|
|
|
|
var audioClockRate int
|
|
|
var videoClockRate int
|
|
|
|
|
|
for i, item := range sdpCtx.ARTPMapList {
|
|
|
switch item.PayloadType {
|
|
|
case base.RTPPacketTypeAVCOrHEVC:
|
|
|
videoClockRate = item.ClockRate
|
|
|
if item.EncodingName == "H265" {
|
|
|
p.videoPayloadType = base.AVPacketPTHEVC
|
|
|
} else {
|
|
|
p.videoPayloadType = base.AVPacketPTAVC
|
|
|
}
|
|
|
if i < len(sdpCtx.AControlList) {
|
|
|
p.videoAControl = sdpCtx.AControlList[i].Value
|
|
|
}
|
|
|
case base.RTPPacketTypeAAC:
|
|
|
audioClockRate = item.ClockRate
|
|
|
p.audioPayloadType = base.AVPacketPTAAC
|
|
|
if i < len(sdpCtx.AControlList) {
|
|
|
p.audioAControl = sdpCtx.AControlList[i].Value
|
|
|
}
|
|
|
default:
|
|
|
nazalog.Errorf("unknown payloadType. type=%d", item.PayloadType)
|
|
|
}
|
|
|
}
|
|
|
|
|
|
for _, item := range sdpCtx.AFmtPBaseList {
|
|
|
switch item.Format {
|
|
|
case base.RTPPacketTypeAVCOrHEVC:
|
|
|
if p.videoPayloadType == base.AVPacketPTHEVC {
|
|
|
p.vps, p.sps, p.pps, err = sdp.ParseVPSSPSPPS(item)
|
|
|
} else {
|
|
|
p.sps, p.pps, err = sdp.ParseSPSPPS(item)
|
|
|
}
|
|
|
if err != nil {
|
|
|
nazalog.Errorf("parse sps pps from sdp failed.")
|
|
|
}
|
|
|
case base.RTPPacketTypeAAC:
|
|
|
p.asc, err = sdp.ParseASC(item)
|
|
|
if err != nil {
|
|
|
nazalog.Errorf("parse asc from sdp failed.")
|
|
|
}
|
|
|
default:
|
|
|
nazalog.Errorf("unknown format. fmt=%d", item.Format)
|
|
|
}
|
|
|
}
|
|
|
|
|
|
p.audioUnpacker = rtprtcp.NewRTPUnpacker(p.audioPayloadType, audioClockRate, unpackerItemMaxSize, p.onAVPacketUnpacked)
|
|
|
p.videoUnpacker = rtprtcp.NewRTPUnpacker(p.videoPayloadType, videoClockRate, unpackerItemMaxSize, p.onAVPacketUnpacked)
|
|
|
|
|
|
p.audioRRProducer = rtprtcp.NewRRProducer(audioClockRate)
|
|
|
p.videoRRProducer = rtprtcp.NewRRProducer(videoClockRate)
|
|
|
|
|
|
if p.audioPayloadType != 0 && p.videoPayloadType != 0 {
|
|
|
p.avPacketQueue = NewAVPacketQueue(p.onAVPacket)
|
|
|
}
|
|
|
}
|
|
|
|
|
|
func (p *PubSession) Setup(uri string, rtpConn, rtcpConn *nazanet.UDPConnection) error {
|
|
|
if strings.HasSuffix(uri, p.audioAControl) {
|
|
|
p.audioRTPConn = rtpConn
|
|
|
p.audioRTCPConn = rtcpConn
|
|
|
} else if strings.HasSuffix(uri, p.videoAControl) {
|
|
|
p.videoRTPConn = rtpConn
|
|
|
p.videoRTCPConn = rtcpConn
|
|
|
} else {
|
|
|
return ErrRTSP
|
|
|
}
|
|
|
|
|
|
go rtpConn.RunLoop(p.onReadUDPPacket)
|
|
|
go rtcpConn.RunLoop(p.onReadUDPPacket)
|
|
|
|
|
|
return nil
|
|
|
}
|
|
|
|
|
|
func (p *PubSession) Dispose() {
|
|
|
if p.audioRTPConn != nil {
|
|
|
_ = p.audioRTPConn.Dispose()
|
|
|
}
|
|
|
if p.audioRTCPConn != nil {
|
|
|
_ = p.audioRTCPConn.Dispose()
|
|
|
}
|
|
|
if p.videoRTPConn != nil {
|
|
|
_ = p.videoRTPConn.Dispose()
|
|
|
}
|
|
|
if p.videoRTCPConn != nil {
|
|
|
_ = p.videoRTCPConn.Dispose()
|
|
|
}
|
|
|
}
|
|
|
|
|
|
func (p *PubSession) GetStat() base.StatPub {
|
|
|
p.stat.ReadBytesSum = atomic.LoadUint64(&p.currConnStat.ReadBytesSum)
|
|
|
p.stat.WroteBytesSum = atomic.LoadUint64(&p.currConnStat.WroteBytesSum)
|
|
|
return p.stat
|
|
|
}
|
|
|
|
|
|
func (p *PubSession) UpdateStat(tickCount uint32) {
|
|
|
diff := p.currConnStat.ReadBytesSum - p.prevConnStat.ReadBytesSum
|
|
|
p.stat.Bitrate = int(diff * 8 / 1024 / 5)
|
|
|
p.prevConnStat = p.currConnStat
|
|
|
}
|
|
|
|
|
|
func (p *PubSession) GetSDP() []byte {
|
|
|
p.m.Lock()
|
|
|
defer p.m.Unlock()
|
|
|
return p.rawSDP
|
|
|
}
|
|
|
|
|
|
// callback by UDPConnection
|
|
|
// TODO yoko: 因为rtp和rtcp使用了两个连接，所以分成两个回调也行
|
|
|
func (p *PubSession) onReadUDPPacket(b []byte, rAddr *net.UDPAddr, err error) bool {
|
|
|
if err != nil {
|
|
|
nazalog.Errorf("read udp packet failed. err=%+v", err)
|
|
|
return true
|
|
|
}
|
|
|
|
|
|
atomic.AddUint64(&p.currConnStat.ReadBytesSum, uint64(len(b)))
|
|
|
|
|
|
if len(b) < 2 {
|
|
|
nazalog.Errorf("read udp packet length invalid. len=%d", len(b))
|
|
|
return true
|
|
|
}
|
|
|
|
|
|
// try RTCP
|
|
|
switch b[1] {
|
|
|
case rtprtcp.RTCPPacketTypeSR:
|
|
|
sr := rtprtcp.ParseSR(b)
|
|
|
var rrBuf []byte
|
|
|
switch sr.SenderSSRC {
|
|
|
case p.audioSsrc:
|
|
|
rrBuf = p.audioRRProducer.Produce(sr.GetMiddleNTP())
|
|
|
if rrBuf != nil {
|
|
|
_ = p.audioRTCPConn.Write2Addr(rrBuf, rAddr)
|
|
|
atomic.AddUint64(&p.currConnStat.WroteBytesSum, uint64(len(b)))
|
|
|
}
|
|
|
case p.videoSsrc:
|
|
|
rrBuf = p.videoRRProducer.Produce(sr.GetMiddleNTP())
|
|
|
if rrBuf != nil {
|
|
|
_ = p.videoRTCPConn.Write2Addr(rrBuf, rAddr)
|
|
|
atomic.AddUint64(&p.currConnStat.WroteBytesSum, uint64(len(b)))
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return true
|
|
|
}
|
|
|
|
|
|
// try RTP
|
|
|
packetType := b[1] & 0x7F
|
|
|
if packetType == base.RTPPacketTypeAVCOrHEVC || packetType == base.RTPPacketTypeAAC {
|
|
|
h, err := rtprtcp.ParseRTPPacket(b)
|
|
|
if err != nil {
|
|
|
nazalog.Errorf("read invalid rtp packet. err=%+v", err)
|
|
|
}
|
|
|
//nazalog.Debugf("%+v", h)
|
|
|
var pkt rtprtcp.RTPPacket
|
|
|
pkt.Header = h
|
|
|
pkt.Raw = b
|
|
|
|
|
|
if packetType == base.RTPPacketTypeAVCOrHEVC {
|
|
|
p.videoSsrc = h.Ssrc
|
|
|
p.observer.OnRTPPacket(pkt)
|
|
|
p.videoUnpacker.Feed(pkt)
|
|
|
p.videoRRProducer.FeedRTPPacket(h.Seq)
|
|
|
} else {
|
|
|
p.audioSsrc = h.Ssrc
|
|
|
p.observer.OnRTPPacket(pkt)
|
|
|
p.audioUnpacker.Feed(pkt)
|
|
|
p.audioRRProducer.FeedRTPPacket(h.Seq)
|
|
|
}
|
|
|
|
|
|
if p.stat.RemoteAddr == "" {
|
|
|
p.stat.RemoteAddr = rAddr.String()
|
|
|
}
|
|
|
|
|
|
return true
|
|
|
}
|
|
|
|
|
|
nazalog.Errorf("unknown PT. pt=%d", b[1])
|
|
|
return true
|
|
|
}
|
|
|
|
|
|
// callback by RTPUnpacker
|
|
|
func (p *PubSession) onAVPacketUnpacked(pkt base.AVPacket) {
|
|
|
if p.avPacketQueue != nil {
|
|
|
p.avPacketQueue.Feed(pkt)
|
|
|
} else {
|
|
|
p.observer.OnAVPacket(pkt)
|
|
|
}
|
|
|
//if p.audioUnpacker != nil && p.videoUnpacker != nil {
|
|
|
//} else {
|
|
|
// p.observer.OnAVPacket(pkt)
|
|
|
//}
|
|
|
}
|
|
|
|
|
|
// callback by avpacket queue
|
|
|
func (p *PubSession) onAVPacket(pkt base.AVPacket) {
|
|
|
p.observer.OnAVPacket(pkt)
|
|
|
}
|