兼容海康设备推流,处理流为tcp 协议时将sdp中y放到最后

:解决端口没有回收的问题,明确错误提示

README.md

@@ -18,65 +18,28 @@ _ "m7s.live/plugin/gb28181/v4"
 
 ```yaml
 gb28181:
-  autoinvite:     true
+  invitemode:     1 #0、手动invite 1、表示自动发起invite，当Server（SIP）接收到设备信息时，立即向设备发送invite命令获取流,2、按需拉流，既等待订阅者触发
-  prefetchrecord: false
+  position:
-  udpcachesize:   0
+    autosubposition: false #是否自动订阅定位
-  sipnetwork:     udp
+    expires: 3600s #订阅周期(单位：秒)，默认3600
-  sipip:          ""
+    interval: 6s #订阅间隔（单位：秒），默认6
-  sipport:        5060
+  sipip:          "" #sip服务器地址 默认 自动适配设备网段
   serial:         "34020000002000000001"
   realm:          "3402000000"
   username:       ""
   password:       ""
-  
+  registervalidity:  60s #注册有效期
-  acktimeout:        10
+  mediaip:          "" #媒体服务器地址 默认 自动适配设备网段
-  registervalidity:  60
+  port:
-  registerinterval:  60
+    sip: udp:5060 #sip服务器端口
-  heartbeatinterval: 60
+    media: tcp:58200-59200 #媒体服务器端口，用于接收设备的流
-  heartbeatretry:    3
+    fdm: false #端口复用,单端口默认多路复用,多端口多路复用根据这个
-  
-  mediaip:          ""
-  mediaport:        58200
-  mediaidletimeout: 30
-  medianetwork:     udp
-  mediaportmin:     0
-  meidaportmax:     0
 
-  removebaninterval: 600
+  removebaninterval: 10m #定时移除注册失败的设备黑名单，单位秒，默认10分钟（600秒）
   loglevel:         info
 ```
 
-- `AutoInvite`     bool 表示自动发起invite，当Server（SIP）接收到设备信息时，立即向设备发送invite命令获取流
+**如果配置了端口范围（默认为范围端口），将采用范围端口机制，每一个流对应一个端口
-- `PreFetchRecord` bool
-
-* sip服务器的配置
-- `SipNetwork` string 传输协议，默认UDP，可选TCP
-- `SipIP`      string sip 服务器公网IP 默认 自动适配设备网段
-- `SipPort`    uint16 sip 服务器端口，默认 5060
-- `Serial`     string sip 服务器 id, 默认 34020000002000000001
-- `Realm`      string sip 服务器域，默认 3402000000
-- `Username`   string sip 服务器账号
-- `Password`   string sip 服务器密码
-
-- `AckTimeout`        uint16 sip 服务应答超时，单位秒
-- `RegisterValidity`  int    注册有效期，单位秒，默认 3600
-- `RegisterInterval`  int    注册间隔，单位秒，默认 60
-- `HeartbeatInterval` int    心跳间隔，单位秒，默认 60
-- `HeartbeatRetry`    int    心跳超时次数，默认 3
-
-* 媒体服务器配置
-- `MediaIP`          string 媒体服务器地址 默认 自动适配设备网段
-- `MediaPort`        uint16 媒体服务器端口
-- `MediaNetwork`     string 媒体传输协议，默认UDP，可选TCP
-- `MediaIdleTimeout` uint16 推流超时时间，超过则断开链接，让设备重连
-- `MediaPortMin`     uint16 媒体服务器端口范围最小值
-- `MediaPortMax`     uint16 媒体服务器端口范围最大值
-- `AudioEnable`       bool 是否开启音频
-- `LogLevel`        string 日志级别，默认 info（trace，debug，info，warn，error，fatal, panic）
-- `RemoveBanInterval` int  定时移除注册失败的设备黑名单，单位秒，默认10分钟（600秒）
-- `UdpCacheSize`      int  表示UDP缓存大小，默认为0，不开启。仅当TCP关闭，切缓存大于0时才开启，会最多缓存最多N个包，并排序，修复乱序造成的无法播放问题，注意开启后，会有一定的性能损耗，并丢失部分包。
-
-**如果配置了端口范围，将采用范围端口机制，每一个流对应一个端口
 
 **注意某些摄像机没有设置用户名的地方，摄像机会以自身的国标id作为用户名，这个时候m7s会忽略使用摄像机的用户名，忽略配置的用户名**
 如果设备配置了错误的用户名和密码，连续三次上报错误后，m7s会记录设备id，并在10分钟内禁止设备注册
@@ -97,10 +60,6 @@ gb28181:
 - 当invite设备的**实时**视频流时，会在m7s中创建对应的流，StreamPath由设备编号和通道编号组成，即[设备编号]/[通道编号],如果有多个层级，通道编号是最后一个层级的编号
 - 当invite设备的**录像**视频流时，StreamPath由设备编号和通道编号以及录像的起止时间拼接而成即[设备编号]/[通道编号]/[开始时间]-[结束时间]
 
-### 如何设置UDP缓存大小
-
-通过wireshark抓包，分析rtp，然后看一下大概多少个包可以有序
-
 ## 接口API
 
 ### 罗列所有的gb28181协议的设备
@@ -130,51 +89,74 @@ type Device struct {
 
 `/gb28181/api/invite`
 
-参数名 | 必传 | 含义
+| 参数名    | 必传 | 含义                         |
-|----|---|---
+| --------- | ---- | ---------------------------- |
-id|是 | 设备ID
+| id        | 是   | 设备ID                       |
-channel|是|通道编号
+| channel   | 是   | 通道编号                     |
-startTime|否|开始时间（纯数字Unix时间戳）
+| startTime | 否   | 开始时间（纯数字Unix时间戳） |
-endTime|否|结束时间（纯数字Unix时间戳）
+| endTime   | 否   | 结束时间（纯数字Unix时间戳） |
 
-返回200代表成功
+返回200代表成功, 304代表已经在拉取中，不能重复拉（仅仅针对直播流）
 
 ### 停止从设备拉流
 
 `/gb28181/api/bye`
 
-参数名 | 必传 | 含义
+| 参数名  | 必传 | 含义     |
-|----|---|---
+| ------- | ---- | -------- |
-id|是 | 设备ID
+| id      | 是   | 设备ID   |
-channel|是|通道编号
+| channel | 是   | 通道编号 |
+
+http 200 表示成功，404流不存在
 
 ### 发送控制命令
 
 `/gb28181/api/control`
 
-参数名 | 必传 | 含义
+| 参数名  | 必传 | 含义        |
-|----|---|---
+| ------- | ---- | ----------- |
-id|是 | 设备ID
+| id      | 是   | 设备ID      |
-channel|是|通道编号
+| channel | 是   | 通道编号    |
-ptzcmd|是|PTZ控制指令
+| ptzcmd  | 是   | PTZ控制指令 |
 
 ### 查询录像
 
 `/gb28181/api/records`
 
-参数名 | 必传 | 含义
+| 参数名    | 必传 | 含义                                         |
-|----|---|---
+| --------- | ---- | -------------------------------------------- |
-id|是 | 设备ID
+| id        | 是   | 设备ID                                       |
-channel|是|通道编号
+| channel   | 是   | 通道编号                                     |
-startTime|否|开始时间（字符串，格式：2021-7-23T12:00:00）
+| startTime | 否   | 开始时间（Unix时间戳） |
-endTime|否|结束时间（字符串格式同上）
+| endTime   | 否   | 结束时间（Unix时间戳）                   |
 
 ### 移动位置订阅
 
 `/gb28181/api/position`
 
-参数名 | 必传 | 含义
+| 参数名   | 必传 | 含义           |
-|----|---|---
+| -------- | ---- | -------------- |
-id|是 | 设备ID
+| id       | 是   | 设备ID         |
-expires|是|订阅周期（秒）
+| expires  | 是   | 订阅周期（秒） |
-interval|是|订阅间隔（秒）
+| interval | 是   | 订阅间隔（秒） |
+
+### 预置位列表查询
+
+`/gb28181/api/preset/list`
+
+| 参数名   | 必传 | 含义           |
+| -------- | ---- | -------------- |
+| id       | 是   | 设备ID         |
+| channel   | 是   | 通道编号                                     |
+
+
+### 预置位操作
+
+`/gb28181/api/preset/control`
+
+| 参数名   | 必传 | 含义                  |
+| -------- | ---- |---------------------|
+| id       | 是   | 设备ID                |
+| channel   | 是   | 通道编号                |
+| cmd | 是   | 操作指令 0=新增,1=删除,2=调用 |
+| point | 是   | 预置点位1-255           |

channel.go

@@ -1,41 +1,159 @@
 package gb28181
 
 import (
-	"errors"
 	"fmt"
-	"math/rand"
 	"net/http"
 	"strconv"
 	"strings"
-	"sync"
 	"time"
 
-	. "m7s.live/engine/v4"
+	"sync/atomic"
+
 	"github.com/ghettovoice/gosip/sip"
+	"github.com/goccy/go-json"
 	"go.uber.org/zap"
+	. "m7s.live/engine/v4"
+	"m7s.live/engine/v4/log"
 	"m7s.live/plugin/gb28181/v4/utils"
+	"m7s.live/plugin/ps/v4"
 )
 
-type ChannelEx struct {
+var QUERY_RECORD_TIMEOUT = time.Second * 5
-	device          *Device
+
-	RecordPublisher *GBPublisher `json:"-"`
+type PullStream struct {
-	LivePublisher   *GBPublisher
+	opt       *InviteOptions
-	LiveSubSP       string //实时子码流
+	channel   *Channel
-	Records         []*Record
+	inviteRes sip.Response
-	RecordStartTime string
+}
-	RecordEndTime   string
+
-	recordStartTime time.Time
+func (p *PullStream) CreateRequest(method sip.RequestMethod) (req sip.Request) {
-	recordEndTime   time.Time
+	res := p.inviteRes
-	liveInviteLock  sync.Mutex
+	req = p.channel.CreateRequst(method)
-	tcpPortIndex    uint16
+	from, _ := res.From()
-	GpsTime         time.Time //gps时间
+	to, _ := res.To()
-	Longitude       string    //经度
+
-	Latitude        string    //纬度
+	callId, _ := res.CallID()
+	req.ReplaceHeaders(from.Name(), []sip.Header{from})
+	req.ReplaceHeaders(to.Name(), []sip.Header{to})
+	req.ReplaceHeaders(callId.Name(), []sip.Header{callId})
+	return
+}
+
+func (p *PullStream) Bye() int {
+	req := p.CreateRequest(sip.BYE)
+	resp, err := p.channel.Device.SipRequestForResponse(req)
+	if p.opt.IsLive() {
+		p.channel.State.Store(0)
+	}
+	if p.opt.recyclePort != nil {
+		p.opt.recyclePort(p.opt.MediaPort)
+	}
+	if err != nil {
+		return http.StatusInternalServerError
+	}
+	return int(resp.StatusCode())
+}
+
+func (p *PullStream) info(body string) int {
+	d := p.channel.Device
+	req := p.CreateRequest(sip.INFO)
+	contentType := sip.ContentType("Application/MANSRTSP")
+	req.AppendHeader(&contentType)
+	req.SetBody(body, true)
+
+	resp, err := d.SipRequestForResponse(req)
+	if err != nil {
+		log.Warnf("Send info to stream error: %v, stream=%s, body=%s", err, p.opt.StreamPath, body)
+		return getSipRespErrorCode(err)
+	}
+	return int(resp.StatusCode())
+}
+
+// 暂停播放
+func (p *PullStream) Pause() int {
+	body := fmt.Sprintf(`PAUSE RTSP/1.0
+CSeq: %d
+PauseTime: now
+`, p.channel.Device.SN)
+	return p.info(body)
+}
+
+// 恢复播放
+func (p *PullStream) Resume() int {
+	d := p.channel.Device
+	body := fmt.Sprintf(`PLAY RTSP/1.0
+CSeq: %d
+Range: npt=now-
+`, d.SN)
+	return p.info(body)
+}
+
+// 跳转到播放时间
+// second: 相对于起始点调整到第 sec 秒播放
+func (p *PullStream) PlayAt(second uint) int {
+	d := p.channel.Device
+	body := fmt.Sprintf(`PLAY RTSP/1.0
+CSeq: %d
+Range: npt=%d-
+`, d.SN, second)
+	return p.info(body)
+}
+
+// 快进/快退播放
+// speed 取值： 0.25 0.5 1 2 4 或者其对应的负数表示倒放
+func (p *PullStream) PlayForward(speed float32) int {
+	d := p.channel.Device
+	body := fmt.Sprintf(`PLAY RTSP/1.0
+CSeq: %d
+Scale: %0.6f
+`, d.SN, speed)
+	return p.info(body)
+}
+
+type Channel struct {
+	Device      *Device      `json:"-" yaml:"-"` // 所属设备
+	State       atomic.Int32 `json:"-" yaml:"-"` // 通道状态,0:空闲,1:正在invite,2:正在播放/对讲
+	LiveSubSP   string       // 实时子码流，通过rtsp
+	GpsTime     time.Time    // gps时间
+	Longitude   string       // 经度
+	Latitude    string       // 纬度
+	*log.Logger `json:"-" yaml:"-"`
+	ChannelInfo
+}
+
+type PresetInfo struct {
+	PresetID   int    `json:"-" yaml:"-"` //
+	PresetName string `json:"-" yaml:"-"` //
+}
+
+func (c *Channel) MarshalJSON() ([]byte, error) {
+	m := map[string]any{
+		"DeviceID":     c.DeviceID,
+		"ParentID":     c.ParentID,
+		"Name":         c.Name,
+		"Manufacturer": c.Manufacturer,
+		"Model":        c.Model,
+		"Owner":        c.Owner,
+		"CivilCode":    c.CivilCode,
+		"Address":      c.Address,
+		"Port":         c.Port,
+		"Parental":     c.Parental,
+		"SafetyWay":    c.SafetyWay,
+		"RegisterWay":  c.RegisterWay,
+		"Secrecy":      c.Secrecy,
+		"Status":       c.Status,
+		"Longitude":    c.Longitude,
+		"Latitude":     c.Latitude,
+		"GpsTime":      c.GpsTime,
+		"LiveSubSP":    c.LiveSubSP,
+		"LiveStatus":   c.State.Load(),
+	}
+	return json.Marshal(m)
 }
 
 // Channel 通道
-type Channel struct {
+type ChannelInfo struct {
-	DeviceID     string
+	DeviceID     string // 通道ID
 	ParentID     string
 	Name         string
 	Manufacturer string
@@ -43,45 +161,30 @@ type Channel struct {
 	Owner        string
 	CivilCode    string
 	Address      string
+	Port         int
 	Parental     int
 	SafetyWay    int
 	RegisterWay  int
 	Secrecy      int
-	Status       string
+	Status       ChannelStatus
-	Children     []*Channel `json:"-"`
-	*ChannelEx              //自定义属性
 }
 
-func (c *Channel) Copy(v *Channel) {
+type ChannelStatus string
-	if v == nil {
-		return
-	}
 
-	c.DeviceID = v.DeviceID
+const (
-	c.ParentID = v.ParentID
+	ChannelOnStatus  = "ON"
-	c.Name = v.Name
+	ChannelOffStatus = "OFF"
-	c.Manufacturer = v.Manufacturer
+)
-	c.Model = v.Model
-	c.Owner = v.Owner
-	c.CivilCode = v.CivilCode
-	c.Address = v.Address
-	c.Parental = v.Parental
-	c.SafetyWay = v.SafetyWay
-	c.RegisterWay = v.RegisterWay
-	c.Secrecy = v.Secrecy
-	c.Status = v.Status
-	c.Status = v.Status
-	c.ChannelEx = v.ChannelEx
-}
 
-func (c *Channel) CreateRequst(Method sip.RequestMethod) (req sip.Request) {
+func (channel *Channel) CreateRequst(Method sip.RequestMethod) (req sip.Request) {
-	d := c.device
+	d := channel.Device
-	d.sn++
+	d.SN++
 
 	callId := sip.CallID(utils.RandNumString(10))
 	userAgent := sip.UserAgentHeader("Monibuca")
+	maxForwards := sip.MaxForwards(70) //增加max-forwards为默认值 70
 	cseq := sip.CSeq{
-		SeqNo:      uint32(d.sn),
+		SeqNo:      uint32(d.SN),
 		MethodName: Method,
 	}
 	port := sip.Port(conf.SipPort)
@@ -89,14 +192,26 @@ func (c *Channel) CreateRequst(Method sip.RequestMethod) (req sip.Request) {
 		//DisplayName: sip.String{Str: d.serverConfig.Serial},
 		Uri: &sip.SipUri{
 			FUser: sip.String{Str: conf.Serial},
-			FHost: d.sipIP,
+			FHost: d.SipIP,
 			FPort: &port,
 		},
 		Params: sip.NewParams().Add("tag", sip.String{Str: utils.RandNumString(9)}),
 	}
+	//非同一域的目标地址需要使用@host
+	host := conf.Realm
+	if channel.DeviceID[0:10] != host {
+		if channel.Port != 0 {
+			deviceIp := d.NetAddr
+			deviceIp = deviceIp[0:strings.LastIndex(deviceIp, ":")]
+			host = fmt.Sprintf("%s:%d", deviceIp, channel.Port)
+		} else {
+			host = d.NetAddr
+		}
+	}
+
 	channelAddr := sip.Address{
 		//DisplayName: sip.String{Str: d.serverConfig.Serial},
-		Uri: &sip.SipUri{FUser: sip.String{Str: c.DeviceID}, FHost: conf.Realm},
+		Uri: &sip.SipUri{FUser: sip.String{Str: channel.DeviceID}, FHost: host},
 	}
 	req = sip.NewRequest(
 		"",
@@ -109,6 +224,7 @@ func (c *Channel) CreateRequst(Method sip.RequestMethod) (req sip.Request) {
 			&callId,
 			&userAgent,
 			&cseq,
+			&maxForwards,
 			serverAddr.AsContactHeader(),
 		},
 		"",
@@ -119,35 +235,78 @@ func (c *Channel) CreateRequst(Method sip.RequestMethod) (req sip.Request) {
 	req.SetDestination(d.NetAddr)
 	return req
 }
-func (channel *Channel) QueryRecord(startTime, endTime string) int {
+
-	d := channel.device
+func (channel *Channel) QueryRecord(startTime, endTime string) ([]*Record, error) {
-	channel.RecordStartTime = startTime
+	d := channel.Device
-	channel.RecordEndTime = endTime
-	channel.recordStartTime, _ = time.Parse(TIME_LAYOUT, startTime)
-	channel.recordEndTime, _ = time.Parse(TIME_LAYOUT, endTime)
-	channel.Records = nil
 	request := d.CreateRequest(sip.MESSAGE)
 	contentType := sip.ContentType("Application/MANSCDP+xml")
 	request.AppendHeader(&contentType)
-	body := fmt.Sprintf(`<?xml version="1.0"?>
+	// body := fmt.Sprintf(`<?xml version="1.0"?>
-		<Query>
+	// 	<Query>
-		<CmdType>RecordInfo</CmdType>
+	// 	<CmdType>RecordInfo</CmdType>
-		<SN>%d</SN>
+	// 	<SN>%d</SN>
-		<DeviceID>%s</DeviceID>
+	// 	<DeviceID>%s</DeviceID>
-		<StartTime>%s</StartTime>
+	// 	<StartTime>%s</StartTime>
-		<EndTime>%s</EndTime>
+	// 	<EndTime>%s</EndTime>
-		<Secrecy>0</Secrecy>
+	// 	<Secrecy>0</Secrecy>
-		<Type>all</Type>
+	// 	<Type>all</Type>
-		</Query>`, d.sn, channel.DeviceID, startTime, endTime)
+	// 	</Query>`, d.sn, channel.DeviceID, startTime, endTime)
+	start, _ := strconv.ParseInt(startTime, 10, 0)
+	end, _ := strconv.ParseInt(endTime, 10, 0)
+	body := BuildRecordInfoXML(d.SN, channel.DeviceID, start, end)
 	request.SetBody(body, true)
+
+	resultCh := RecordQueryLink.WaitResult(d.ID, channel.DeviceID, d.SN, QUERY_RECORD_TIMEOUT)
 	resp, err := d.SipRequestForResponse(request)
 	if err != nil {
-		return http.StatusRequestTimeout
+		return nil, fmt.Errorf("query error: %s", err)
 	}
-	return int(resp.StatusCode())
+	if resp.StatusCode() != http.StatusOK {
+		return nil, fmt.Errorf("query error, status=%d", resp.StatusCode())
+	}
+	// RecordQueryLink 中加了超时机制，该结果一定会返回
+	// 所以此处不用再增加超时等保护机制
+	r := <-resultCh
+	return r.list, r.err
 }
+
+func (channel *Channel) QueryPresetList() (sip.Response, error) {
+	d := channel.Device
+	request := d.CreateRequest(sip.MESSAGE)
+	contentType := sip.ContentType("Application/MANSCDP+xml")
+	request.AppendHeader(&contentType)
+
+	body := BuildPresetListXML(100, channel.DeviceID)
+	request.SetBody(body, true)
+
+	resp, err := d.SipRequestForResponse(request)
+	if err != nil {
+		return nil, fmt.Errorf("query error: %s", err)
+	}
+	if resp.StatusCode() != http.StatusOK {
+		return nil, fmt.Errorf("query error, status=%d", resp.StatusCode())
+	}
+	return resp, nil
+}
+
+func (channel *Channel) PresetControl(ptzCode int, point byte) int {
+	cmd := byte(PresetSet)
+	switch ptzCode {
+	case PresetAddPoint:
+		cmd = PresetSet
+	case PresetDelPoint:
+		cmd = PresetDel
+	case PresetCallPoint:
+		cmd = PresetCall
+	default:
+
+	}
+	PTZCmd := Pack(cmd, point)
+	return channel.Control(PTZCmd)
+}
+
 func (channel *Channel) Control(PTZCmd string) int {
-	d := channel.device
+	d := channel.Device
 	request := d.CreateRequest(sip.MESSAGE)
 	contentType := sip.ContentType("Application/MANSCDP+xml")
 	request.AppendHeader(&contentType)
@@ -157,7 +316,7 @@ func (channel *Channel) Control(PTZCmd string) int {
 		<SN>%d</SN>
 		<DeviceID>%s</DeviceID>
 		<PTZCmd>%s</PTZCmd>
-		</Control>`, d.sn, channel.DeviceID, PTZCmd)
+		</Control>`, d.SN, channel.DeviceID, PTZCmd)
 	request.SetBody(body, true)
 	resp, err := d.SipRequestForResponse(request)
 	if err != nil {
@@ -166,64 +325,9 @@ func (channel *Channel) Control(PTZCmd string) int {
 	return int(resp.StatusCode())
 }
 
-type InviteOptions struct {
+// Invite 发送Invite报文 invites a channel to play
-	Start     int
+// 注意里面的锁保证不同时发送invite报文，该锁由channel持有
-	End       int
+/***
-	dump      string
-	ssrc      string
-	SSRC      uint32
-	MediaPort uint16
-}
-
-func (o InviteOptions) IsLive() bool {
-	return o.Start == 0 || o.End == 0
-}
-
-func (o InviteOptions) Record() bool {
-	return !o.IsLive()
-}
-
-func (o *InviteOptions) Validate(start, end string) error {
-	if start != "" {
-		sint, err1 := strconv.ParseInt(start, 10, 0)
-		if err1 != nil {
-			return err1
-		}
-		o.Start = int(sint)
-	}
-	if end != "" {
-		eint, err2 := strconv.ParseInt(end, 10, 0)
-		if err2 != nil {
-			return err2
-		}
-		o.End = int(eint)
-	}
-	if o.Start >= o.End {
-		return errors.New("start < end")
-	}
-	return nil
-}
-
-func (o InviteOptions) String() string {
-	return fmt.Sprintf("t=%d %d", o.Start, o.End)
-}
-
-func (o *InviteOptions) CreateSSRC() {
-	ssrc := make([]byte, 10)
-	if o.IsLive() {
-		ssrc[0] = '0'
-	} else {
-		ssrc[0] = '1'
-	}
-	copy(ssrc[1:6], conf.Serial[3:8])
-	randNum := 1000 + rand.Intn(8999)
-	copy(ssrc[6:], strconv.Itoa(randNum))
-	o.ssrc = string(ssrc)
-	_ssrc, _ := strconv.ParseInt(o.ssrc, 10, 0)
-	o.SSRC = uint32(_ssrc)
-}
-
-/*
 f字段： f = v/编码格式/分辨率/帧率/码率类型/码率大小a/编码格式/码率大小/采样率
 各项具体含义：
     v：后续参数为视频的参数；各参数间以 “/”分割；
@@ -267,19 +371,29 @@ f = v/a/编码格式/码率大小/采样率
 f字段中视、音频参数段之间不需空格分割。
 可使用f字段中的分辨率参数标识同一设备不同分辨率的码流。
 */
-func (channel *Channel) Invite(opt InviteOptions) (code int, err error) {
+
+func (channel *Channel) Invite(opt *InviteOptions) (code int, err error) {
 	if opt.IsLive() {
-		if !channel.liveInviteLock.TryLock() {
+		if !channel.State.CompareAndSwap(0, 1) {
 			return 304, nil
 		}
 		defer func() {
-			if code != 200 {
+			if err != nil {
-				channel.liveInviteLock.Unlock()
+				GB28181Plugin.Error("InviteRetryInit", zap.Error(err))
+				channel.State.Store(0)
+				if conf.InviteMode == 1 {
+					// 5秒后重试
+					time.AfterFunc(time.Second*5, func() {
+						channel.Invite(opt)
+					})
+				}
+			} else {
+				channel.State.Store(2)
 			}
 		}()
 	}
-	channel.Bye(opt.IsLive())
+
-	d := channel.device
+	d := channel.Device
 	streamPath := fmt.Sprintf("%s/%s", d.ID, channel.DeviceID)
 	s := "Play"
 	opt.CreateSSRC()
@@ -287,123 +401,235 @@ func (channel *Channel) Invite(opt InviteOptions) (code int, err error) {
 		s = "Playback"
 		streamPath = fmt.Sprintf("%s/%s/%d-%d", d.ID, channel.DeviceID, opt.Start, opt.End)
 	}
+	if opt.StreamPath != "" {
+		streamPath = opt.StreamPath
+	} else if channel.DeviceID == "" {
+		streamPath = "gb28181/" + d.ID
+	} else {
+		opt.StreamPath = streamPath
+	}
 	if opt.dump == "" {
 		opt.dump = conf.DumpPath
 	}
-	// size := 1
-	// fps := 15
-	// bitrate := 200
-	// fmt.Sprintf("f=v/2/%d/%d/1/%da///", size, fps, bitrate)
-	publisher := &GBPublisher{
-		InviteOptions: opt,
-		channel:       channel,
-	}
 	protocol := ""
+	networkType := "udp"
+
+	// 根据配置文件判断是否多路复用
+	reusePort := conf.Port.Fdm
+
 	if conf.IsMediaNetworkTCP() {
+		networkType = "tcp"
 		protocol = "TCP/"
 		if conf.tcpPorts.Valid {
-			opt.MediaPort, err = publisher.ListenTCP()
+			opt.MediaPort, err = conf.tcpPorts.GetPort()
-			if err != nil {
+			opt.recyclePort = conf.tcpPorts.Recycle
-				return 500, err
-			}
-		} else if opt.MediaPort == 0 {
-			opt.MediaPort = conf.MediaPort
 		}
 	} else {
 		if conf.udpPorts.Valid {
-			opt.MediaPort, err = publisher.ListenUDP()
+			opt.MediaPort, err = conf.udpPorts.GetPort()
-			if err != nil {
+			opt.recyclePort = conf.udpPorts.Recycle
-				code = 500
-				return
-			}
-		} else if opt.MediaPort == 0 {
-			opt.MediaPort = conf.MediaPort
 		}
 	}
-	// if opt.MediaPort == 0 {
+	if err != nil {
-	// 	opt.MediaPort = conf.MediaPort
+		return http.StatusInternalServerError, err
-	// 	if conf.IsMediaNetworkTCP() {
+	}
-	// 		protocol = "TCP/"
+	if opt.MediaPort == 0 {
-	// 		opt.MediaPort = conf.MediaPort + channel.tcpPortIndex
+		opt.MediaPort = conf.MediaPort
-	// 		if channel.tcpPortIndex++; channel.tcpPortIndex >= conf.MediaPortMax {
+		// 单端口默认多路复用
-	// 			channel.tcpPortIndex = 0
+		reusePort = true
-	// 		}
+	}
-	// 	}
+
-	// }
 	sdpInfo := []string{
 		"v=0",
-		fmt.Sprintf("o=%s 0 0 IN IP4 %s", channel.DeviceID, d.mediaIP),
+		fmt.Sprintf("o=%s 0 0 IN IP4 %s", channel.DeviceID, d.MediaIP),
 		"s=" + s,
 		"u=" + channel.DeviceID + ":0",
-		"c=IN IP4 " + d.mediaIP,
+		"c=IN IP4 " + d.MediaIP,
 		opt.String(),
 		fmt.Sprintf("m=video %d %sRTP/AVP 96", opt.MediaPort, protocol),
 		"a=recvonly",
 		"a=rtpmap:96 PS/90000",
-		"y=" + opt.ssrc,
-		"",
 	}
 	if conf.IsMediaNetworkTCP() {
 		sdpInfo = append(sdpInfo, "a=setup:passive", "a=connection:new")
 	}
+	sdpInfo = append(sdpInfo, "y="+opt.ssrc)
 	invite := channel.CreateRequst(sip.INVITE)
 	contentType := sip.ContentType("application/sdp")
 	invite.AppendHeader(&contentType)
 
-	invite.SetBody(strings.Join(sdpInfo, "\r\n"), true)
+	invite.SetBody(strings.Join(sdpInfo, "\r\n")+"\r\n", true)
 
 	subject := sip.GenericHeader{
 		HeaderName: "Subject", Contents: fmt.Sprintf("%s:%s,%s:0", channel.DeviceID, opt.ssrc, conf.Serial),
 	}
 	invite.AppendHeader(&subject)
-	publisher.inviteRes, err = d.SipRequestForResponse(invite)
+	inviteRes, err := d.SipRequestForResponse(invite)
 	if err != nil {
-		return http.StatusRequestTimeout, err
+		if opt.recyclePort != nil {
+			opt.recyclePort(opt.MediaPort)
+		}
+		channel.Error("inviteRequestError", zap.Error(err), zap.String("msg", invite.String()))
+		return http.StatusInternalServerError, err
 	}
-	code = int(publisher.inviteRes.StatusCode())
+	code = int(inviteRes.StatusCode())
-	plugin.Info(fmt.Sprintf("Channel :%s invite response status code: %d", channel.DeviceID, code))
+	channel.Info("invite response", zap.Int("status code", code))
-	if code == 200 {
+
-		ds := strings.Split(publisher.inviteRes.Body(), "\r\n")
+	if code == http.StatusOK {
+		ds := strings.Split(inviteRes.Body(), "\r\n")
 		for _, l := range ds {
 			if ls := strings.Split(l, "="); len(ls) > 1 {
 				if ls[0] == "y" && len(ls[1]) > 0 {
 					if _ssrc, err := strconv.ParseInt(ls[1], 10, 0); err == nil {
 						opt.SSRC = uint32(_ssrc)
 					} else {
-						plugin.Error("read invite response y ", zap.Error(err))
+						channel.Error("read invite response y ", zap.Error(err))
+					}
+					//	break
+				}
+				if ls[0] == "m" && len(ls[1]) > 0 {
+					netinfo := strings.Split(ls[1], " ")
+					if strings.ToUpper(netinfo[2]) == "TCP/RTP/AVP" {
+						channel.Debug("Device support tcp")
+					} else {
+						channel.Debug("Device not support tcp")
+						networkType = "udp"
 					}
-					break
 				}
 			}
 		}
-		if conf.UdpCacheSize > 0 && !conf.IsMediaNetworkTCP() {
+		var psPuber ps.PSPublisher
-			publisher.udpCache = utils.NewPqRtp()
+		err = psPuber.Receive(streamPath, opt.dump, fmt.Sprintf("%s:%d", networkType, opt.MediaPort), opt.SSRC, reusePort)
+		if err != nil {
+			if opt.recyclePort != nil {
+				opt.recyclePort(opt.MediaPort)
+			}
+			channel.Error("inviteTcpCreateError", zap.Error(err))
+			return http.StatusInternalServerError, err
 		}
-		if err = plugin.Publish(streamPath, publisher); err != nil {
+
-			code = 403
+		if !opt.IsLive() {
-			return
+			// 10秒无数据关闭
+			if psPuber.Stream.DelayCloseTimeout == 0 {
+				psPuber.Stream.DelayCloseTimeout = time.Second * 10
+			}
+			if psPuber.Stream.IdleTimeout == 0 {
+				psPuber.Stream.IdleTimeout = time.Second * 10
+			}
 		}
-		ack := sip.NewAckRequest("", invite, publisher.inviteRes, "", nil)
+		PullStreams.Store(streamPath, &PullStream{
-		srv.Send(ack)
+			opt:       opt,
-	} else if opt.IsLive() && conf.AutoInvite {
+			channel:   channel,
-		time.AfterFunc(time.Second*5, func() {
+			inviteRes: inviteRes,
-			channel.Invite(InviteOptions{})
 		})
+		err = srv.Send(sip.NewAckRequest("", invite, inviteRes, "", nil))
+	} else {
+		if opt.recyclePort != nil {
+			opt.recyclePort(opt.MediaPort)
+		}
 	}
 	return
 }
 
-func (channel *Channel) Bye(live bool) int {
+func (channel *Channel) Bye(streamPath string) int {
-	d := channel.device
+	d := channel.Device
-	streamPath := fmt.Sprintf("%s/%s", d.ID, channel.DeviceID)
+	if streamPath == "" {
-	if s := Streams.Get(streamPath); s != nil {
+		streamPath = fmt.Sprintf("%s/%s", d.ID, channel.DeviceID)
-		s.Close()
 	}
-	if live && channel.LivePublisher != nil {
+	if s, loaded := PullStreams.LoadAndDelete(streamPath); loaded {
-		return channel.LivePublisher.Bye()
+		s.(*PullStream).Bye()
+		if s := Streams.Get(streamPath); s != nil {
+			s.Close()
+		}
+		return http.StatusOK
+	}
+	return http.StatusNotFound
+}
+
+func (channel *Channel) Pause(streamPath string) int {
+	if s, loaded := PullStreams.Load(streamPath); loaded {
+		r := s.(*PullStream).Pause()
+		if s := Streams.Get(streamPath); s != nil {
+			s.Pause()
+		}
+		return r
+	}
+	return http.StatusNotFound
+}
+
+func (channel *Channel) Resume(streamPath string) int {
+	if s, loaded := PullStreams.Load(streamPath); loaded {
+		r := s.(*PullStream).Resume()
+		if s := Streams.Get(streamPath); s != nil {
+			s.Resume()
+		}
+		return r
+	}
+	return http.StatusNotFound
+}
+
+func (channel *Channel) PlayAt(streamPath string, second uint) int {
+	if s, loaded := PullStreams.Load(streamPath); loaded {
+		r := s.(*PullStream).PlayAt(second)
+		if s := Streams.Get(streamPath); s != nil {
+			s.Resume()
+		}
+		return r
+	}
+	return http.StatusNotFound
+}
+
+func (channel *Channel) PlayForward(streamPath string, speed float32) int {
+	if s, loaded := PullStreams.Load(streamPath); loaded {
+		return s.(*PullStream).PlayForward(speed)
+	}
+	if s := Streams.Get(streamPath); s != nil {
+		s.Resume()
+	}
+	return http.StatusNotFound
+}
+
+func (channel *Channel) TryAutoInvite(opt *InviteOptions) {
+	condition := !opt.IsLive() || channel.CanInvite()
+	channel.Debug("TryAutoInvite", zap.Any("opt", opt), zap.Bool("condition", condition))
+	if condition {
+		go channel.Invite(opt)
+	}
+}
+
+func (channel *Channel) CanInvite() bool {
+	if channel.State.Load() != 0 || len(channel.DeviceID) != 20 || channel.Status == ChannelOffStatus {
+		return false
+	}
+
+	if conf.InviteIDs == "" {
+		return true
+	}
+
+	// 11～13位是设备类型编码
+	typeID := channel.DeviceID[10:13]
+
+	// format: start-end,type1,type2
+	tokens := strings.Split(conf.InviteIDs, ",")
+	for _, tok := range tokens {
+		if first, second, ok := strings.Cut(tok, "-"); ok {
+			if typeID >= first && typeID <= second {
+				return true
+			}
+		} else {
+			if typeID == first {
+				return true
+			}
+		}
+	}
+
+	return false
+}
+
+func getSipRespErrorCode(err error) int {
+	if re, ok := err.(*sip.RequestError); ok {
+		return int(re.Code)
+	} else {
+		return http.StatusInternalServerError
 	}
-	if !live && channel.RecordPublisher != nil {
-		return channel.RecordPublisher.Bye()
-	}
-	return 404
 }

const.go

@@ -0,0 +1,66 @@
+package gb28181
+
+var reasons = map[int]string{
+	100: "Trying",
+	180: "Ringing",
+	181: "Call Is Being Forwarded",
+	182: "Queued",
+	183: "Session Progress",
+	200: "OK",
+	202: "Accepted",
+	300: "Multiple Choices",
+	301: "Moved Permanently",
+	302: "Moved Temporarily",
+	305: "Use Proxy",
+	380: "Alternative Service",
+	400: "Bad Request",
+	401: "Unauthorized",
+	402: "Payment Required",
+	403: "Forbidden",
+	404: "Not Found",
+	405: "Method Not Allowed",
+	406: "Not Acceptable",
+	407: "Proxy Authentication Required",
+	408: "Request Timeout",
+	410: "Gone",
+	413: "Request Entity Too Large",
+	414: "Request-URI Too Long",
+	415: "Unsupported Media Type",
+	416: "Unsupported URI Scheme",
+	420: "Bad Extension",
+	421: "Extension Required",
+	423: "Interval Too Brief",
+	480: "Temporarily Unavailable",
+	481: "Call transaction Does Not Exist",
+	482: "Loop Detected",
+	483: "Too Many Hops",
+	484: "Address Incomplete",
+	485: "Ambiguous",
+	486: "Busy Here",
+	487: "Request Terminated",
+	488: "Not Acceptable Here",
+	489: "Bad Event",
+	491: "Request Pending",
+	493: "Undecipherable",
+	500: "Server Internal Error",
+	501: "Not Implemented",
+	502: "Bad Gateway",
+	503: "Service Unavailable",
+	504: "Server Tim",
+	505: "Version Not Supported",
+	513: "message Too Large",
+	600: "Busy Everywhere",
+	603: "Decline",
+	604: "Does Not Exist Anywhere",
+	606: "SESSION NOT ACCEPTABLE",
+}
+
+func Explain(statusCode int) string {
+	return reasons[statusCode]
+}
+
+const (
+	INVIDE_MODE_MANUAL = iota
+	INVIDE_MODE_AUTO
+	INVIDE_MODE_ONSUBSCRIBE
+)

device.go

@@ -12,9 +12,9 @@ import (
 
 	"go.uber.org/zap"
 	"m7s.live/engine/v4"
+	"m7s.live/engine/v4/log"
 	"m7s.live/plugin/gb28181/v4/utils"
 
-	// . "github.com/logrusorgru/aurora"
 	"github.com/ghettovoice/gosip/sip"
 	myip "github.com/husanpao/ip"
 )
@@ -23,7 +23,6 @@ const TIME_LAYOUT = "2006-01-02T15:04:05"
 
 // Record 录像
 type Record struct {
-	//channel   *Channel
 	DeviceID  string
 	Name      string
 	FilePath  string
@@ -44,8 +43,17 @@ var (
 	DeviceRegisterCount sync.Map //设备注册次数
 )
 
+type DeviceStatus string
+
+const (
+	DeviceRegisterStatus = "REGISTER"
+	DeviceRecoverStatus  = "RECOVER"
+	DeviceOnlineStatus   = "ONLINE"
+	DeviceOfflineStatus  = "OFFLINE"
+	DeviceAlarmedStatus  = "ALARMED"
+)
+
 type Device struct {
-	//*transaction.Core `json:"-"`
 	ID              string
 	Name            string
 	Manufacturer    string
@@ -54,31 +62,48 @@ type Device struct {
 	RegisterTime    time.Time
 	UpdateTime      time.Time
 	LastKeepaliveAt time.Time
-	Status          string
+	Status          DeviceStatus
-	Channels        []*Channel
+	SN              int
-	sn              int
+	Addr            sip.Address `json:"-" yaml:"-"`
-	addr            sip.Address
+	SipIP           string      //设备对应网卡的服务器ip
-	sipIP           string //设备对应网卡的服务器ip
+	MediaIP         string      //设备对应网卡的服务器ip
-	mediaIP         string //设备对应网卡的服务器ip
 	NetAddr         string
-	channelMap      map[string]*Channel
+	channelMap      sync.Map
-	channelMutex    sync.RWMutex
 	subscriber      struct {
 		CallID  string
 		Timeout time.Time
 	}
+	lastSyncTime time.Time
+	GpsTime      time.Time //gps时间
+	Longitude    string    //经度
+	Latitude     string    //纬度
+	*log.Logger  `json:"-" yaml:"-"`
 }
 
-func (config *GB28181Config) RecoverDevice(d *Device, req sip.Request) {
+func (d *Device) MarshalJSON() ([]byte, error) {
+	type Alias Device
+	data := &struct {
+		Channels []*Channel
+		*Alias
+	}{
+		Alias: (*Alias)(d),
+	}
+	d.channelMap.Range(func(key, value interface{}) bool {
+		data.Channels = append(data.Channels, value.(*Channel))
+		return true
+	})
+	return json.Marshal(data)
+}
+func (c *GB28181Config) RecoverDevice(d *Device, req sip.Request) {
 	from, _ := req.From()
-	d.addr = sip.Address{
+	d.Addr = sip.Address{
 		DisplayName: from.DisplayName,
 		Uri:         from.Address,
 	}
 	deviceIp := req.Source()
 	servIp := req.Recipient().Host()
 	//根据网卡ip获取对应的公网ip
-	sipIP := config.routes[servIp]
+	sipIP := c.routes[servIp]
 	//如果相等，则服务器是内网通道.海康摄像头不支持...自动获取
 	if strings.LastIndex(deviceIp, ".") != -1 && strings.LastIndex(servIp, ".") != -1 {
 		if servIp[0:strings.LastIndex(servIp, ".")] == deviceIp[0:strings.LastIndex(deviceIp, ".")] || sipIP == "" {
@@ -86,26 +111,24 @@ func (config *GB28181Config) RecoverDevice(d *Device, req sip.Request) {
 		}
 	}
 	//如果用户配置过则使用配置的
-	if config.SipIP != "" {
+	if c.SipIP != "" {
-		sipIP = config.SipIP
+		sipIP = c.SipIP
 	} else if sipIP == "" {
 		sipIP = myip.InternalIPv4()
 	}
 	mediaIp := sipIP
-	if config.MediaIP != "" {
+	if c.MediaIP != "" {
-		mediaIp = config.MediaIP
+		mediaIp = c.MediaIP
 	}
-	plugin.Info("RecoverDevice", zap.String("id", d.ID), zap.String("deviceIp", deviceIp), zap.String("servIp", servIp), zap.String("sipIP", sipIP), zap.String("mediaIp", mediaIp))
+	d.Info("RecoverDevice", zap.String("deviceIp", deviceIp), zap.String("servIp", servIp), zap.String("sipIP", sipIP), zap.String("mediaIp", mediaIp))
-	d.Status = string(sip.REGISTER)
+	d.Status = DeviceRegisterStatus
-	d.sipIP = sipIP
+	d.SipIP = sipIP
-	d.mediaIP = mediaIp
+	d.MediaIP = mediaIp
 	d.NetAddr = deviceIp
 	d.UpdateTime = time.Now()
-	d.channelMap = make(map[string]*Channel)
-	go d.Catalog()
 }
-func (config *GB28181Config) StoreDevice(id string, req sip.Request) {
+
-	var d *Device
+func (c *GB28181Config) StoreDevice(id string, req sip.Request) (d *Device) {
 	from, _ := req.From()
 	deviceAddr := sip.Address{
 		DisplayName: from.DisplayName,
@@ -116,12 +139,12 @@ func (config *GB28181Config) StoreDevice(id string, req sip.Request) {
 		d = _d.(*Device)
 		d.UpdateTime = time.Now()
 		d.NetAddr = deviceIp
-		d.addr = deviceAddr
+		d.Addr = deviceAddr
-		plugin.Debug("UpdateDevice", zap.String("id", id), zap.String("netaddr", d.NetAddr))
+		d.Debug("UpdateDevice", zap.String("netaddr", d.NetAddr))
 	} else {
 		servIp := req.Recipient().Host()
 		//根据网卡ip获取对应的公网ip
-		sipIP := config.routes[servIp]
+		sipIP := c.routes[servIp]
 		//如果相等，则服务器是内网通道.海康摄像头不支持...自动获取
 		if strings.LastIndex(deviceIp, ".") != -1 && strings.LastIndex(servIp, ".") != -1 {
 			if servIp[0:strings.LastIndex(servIp, ".")] == deviceIp[0:strings.LastIndex(deviceIp, ".")] || sipIP == "" {
@@ -129,47 +152,48 @@ func (config *GB28181Config) StoreDevice(id string, req sip.Request) {
 			}
 		}
 		//如果用户配置过则使用配置的
-		if config.SipIP != "" {
+		if c.SipIP != "" {
-			sipIP = config.SipIP
+			sipIP = c.SipIP
 		} else if sipIP == "" {
 			sipIP = myip.InternalIPv4()
 		}
 		mediaIp := sipIP
-		if config.MediaIP != "" {
+		if c.MediaIP != "" {
-			mediaIp = config.MediaIP
+			mediaIp = c.MediaIP
 		}
-		plugin.Info("StoreDevice", zap.String("id", id), zap.String("deviceIp", deviceIp), zap.String("servIp", servIp), zap.String("sipIP", sipIP), zap.String("mediaIp", mediaIp))
 		d = &Device{
 			ID:           id,
 			RegisterTime: time.Now(),
 			UpdateTime:   time.Now(),
-			Status:       string(sip.REGISTER),
+			Status:       DeviceRegisterStatus,
-			addr:         deviceAddr,
+			Addr:         deviceAddr,
-			sipIP:        sipIP,
+			SipIP:        sipIP,
-			mediaIP:      mediaIp,
+			MediaIP:      mediaIp,
 			NetAddr:      deviceIp,
-			channelMap:   make(map[string]*Channel),
+			Logger:       GB28181Plugin.With(zap.String("id", id)),
 		}
+		d.Info("StoreDevice", zap.String("deviceIp", deviceIp), zap.String("servIp", servIp), zap.String("sipIP", sipIP), zap.String("mediaIp", mediaIp))
 		Devices.Store(id, d)
-		SaveDevices()
+		c.SaveDevices()
-		go d.Catalog()
 	}
+	return
 }
-func ReadDevices() {
+func (c *GB28181Config) ReadDevices() {
 	if f, err := os.OpenFile("devices.json", os.O_RDONLY, 0644); err == nil {
 		defer f.Close()
 		var items []*Device
 		if err = json.NewDecoder(f).Decode(&items); err == nil {
 			for _, item := range items {
-				if time.Since(item.UpdateTime) < time.Duration(conf.RegisterValidity)*time.Second {
+				if time.Since(item.UpdateTime) < conf.RegisterValidity {
 					item.Status = "RECOVER"
+					item.Logger = GB28181Plugin.With(zap.String("id", item.ID))
 					Devices.Store(item.ID, item)
 				}
 			}
 		}
 	}
 }
-func SaveDevices() {
+func (c *GB28181Config) SaveDevices() {
 	var item []any
 	Devices.Range(func(key, value any) bool {
 		item = append(item, value)
@@ -183,89 +207,74 @@ func SaveDevices() {
 	}
 }
 
-func (d *Device) addChannel(channel *Channel) {
+func (d *Device) addOrUpdateChannel(info ChannelInfo) (c *Channel) {
-	for _, c := range d.Channels {
+	if old, ok := d.channelMap.Load(info.DeviceID); ok {
-		if c.DeviceID == channel.DeviceID {
+		c = old.(*Channel)
-			return
+		c.ChannelInfo = info
+	} else {
+		c = &Channel{
+			Device:      d,
+			ChannelInfo: info,
+			Logger:      d.Logger.With(zap.String("channel", info.DeviceID)),
 		}
-	}
+		if s := engine.Streams.Get(fmt.Sprintf("%s/%s/rtsp", c.Device.ID, c.DeviceID)); s != nil {
-	d.Channels = append(d.Channels, channel)
-}
-
-func (d *Device) CheckSubStream() {
-	d.channelMutex.Lock()
-	defer d.channelMutex.Unlock()
-	for _, c := range d.Channels {
-		if s := engine.Streams.Get("sub/" + c.DeviceID); s != nil {
 			c.LiveSubSP = s.Path
 		} else {
 			c.LiveSubSP = ""
 		}
+		d.channelMap.Store(info.DeviceID, c)
 	}
+	return
 }
-func (d *Device) UpdateChannels(list []*Channel) {
+
-	d.channelMutex.Lock()
+func (d *Device) deleteChannel(DeviceID string) {
-	defer d.channelMutex.Unlock()
+	d.channelMap.Delete(DeviceID)
+}
+
+func (d *Device) UpdateChannels(list ...ChannelInfo) {
 	for _, c := range list {
-		if _, ok := conf.Ignores[c.DeviceID]; ok {
+		if _, ok := conf.ignores[c.DeviceID]; ok {
 			continue
 		}
+		//当父设备非空且存在时、父设备节点增加通道
 		if c.ParentID != "" {
 			path := strings.Split(c.ParentID, "/")
 			parentId := path[len(path)-1]
-			if parent, ok := d.channelMap[parentId]; ok {
+			//如果父ID并非本身所属设备，一般情况下这是因为下级设备上传了目录信息，该信息通常不需要处理。
-				if c.DeviceID != parentId {
+			// 暂时不考虑级联目录的实现
-					parent.Children = append(parent.Children, c)
+			if d.ID != parentId {
-				}
+				if v, ok := Devices.Load(parentId); ok {
-			} else {
+					parent := v.(*Device)
-				d.addChannel(c)
+					parent.addOrUpdateChannel(c)
-			}
+					continue
-		} else {
+				} else {
-			d.addChannel(c)
+					c.Model = "Directory " + c.Model
-		}
+					c.Status = "NoParent"
-		if old, ok := d.channelMap[c.DeviceID]; ok {
-			c.ChannelEx = old.ChannelEx
-			if conf.PreFetchRecord {
-				n := time.Now()
-				n = time.Date(n.Year(), n.Month(), n.Day(), 0, 0, 0, 0, time.Local)
-				if len(c.Records) == 0 || (n.Format(TIME_LAYOUT) == c.RecordStartTime &&
-					n.Add(time.Hour*24-time.Second).Format(TIME_LAYOUT) == c.RecordEndTime) {
-					go c.QueryRecord(n.Format(TIME_LAYOUT), n.Add(time.Hour*24-time.Second).Format(TIME_LAYOUT))
 				}
 			}
-			old.Copy(c)
-			c = old
-		} else {
-			c.ChannelEx = &ChannelEx{
-				device: d,
-			}
-			d.channelMap[c.DeviceID] = c
 		}
-		if conf.AutoInvite && (c.LivePublisher == nil) {
+		//本设备增加通道
-			go c.Invite(InviteOptions{})
+		channel := d.addOrUpdateChannel(c)
+
+		if conf.InviteMode == INVIDE_MODE_AUTO {
+			channel.TryAutoInvite(&InviteOptions{})
 		}
 		if s := engine.Streams.Get("sub/" + c.DeviceID); s != nil {
-			c.LiveSubSP = s.Path
+			channel.LiveSubSP = s.Path
 		} else {
-			c.LiveSubSP = ""
+			channel.LiveSubSP = ""
 		}
 	}
 }
-func (d *Device) UpdateRecord(channelId string, list []*Record) {
-	d.channelMutex.RLock()
-	if c, ok := d.channelMap[channelId]; ok {
-		c.Records = append(c.Records, list...)
-	}
-	d.channelMutex.RUnlock()
-}
 
 func (d *Device) CreateRequest(Method sip.RequestMethod) (req sip.Request) {
-	d.sn++
+	d.SN++
 
 	callId := sip.CallID(utils.RandNumString(10))
 	userAgent := sip.UserAgentHeader("Monibuca")
+	maxForwards := sip.MaxForwards(70) //增加max-forwards为默认值 70
 	cseq := sip.CSeq{
-		SeqNo:      uint32(d.sn),
+		SeqNo:      uint32(d.SN),
 		MethodName: Method,
 	}
 	port := sip.Port(conf.SipPort)
@@ -273,7 +282,7 @@ func (d *Device) CreateRequest(Method sip.RequestMethod) (req sip.Request) {
 		//DisplayName: sip.String{Str: d.config.Serial},
 		Uri: &sip.SipUri{
 			FUser: sip.String{Str: conf.Serial},
-			FHost: d.sipIP,
+			FHost: d.SipIP,
 			FPort: &port,
 		},
 		Params: sip.NewParams().Add("tag", sip.String{Str: utils.RandNumString(9)}),
@@ -281,14 +290,15 @@ func (d *Device) CreateRequest(Method sip.RequestMethod) (req sip.Request) {
 	req = sip.NewRequest(
 		"",
 		Method,
-		d.addr.Uri,
+		d.Addr.Uri,
 		"SIP/2.0",
 		[]sip.Header{
 			serverAddr.AsFromHeader(),
-			d.addr.AsToHeader(),
+			d.Addr.AsToHeader(),
 			&callId,
 			&userAgent,
 			&cseq,
+			&maxForwards,
 			serverAddr.AsContactHeader(),
 		},
 		"",
@@ -335,11 +345,11 @@ func (d *Device) Subscribe() int {
 	request.AppendHeader(&contentType)
 	request.AppendHeader(&expires)
 
-	request.SetBody(BuildCatalogXML(d.sn, d.ID), true)
+	request.SetBody(BuildCatalogXML(d.SN, d.ID), true)
 
 	response, err := d.SipRequestForResponse(request)
 	if err == nil && response != nil {
-		if response.StatusCode() == 200 {
+		if response.StatusCode() == http.StatusOK {
 			callId, _ := request.CallID()
 			d.subscriber.CallID = string(*callId)
 		} else {
@@ -351,6 +361,7 @@ func (d *Device) Subscribe() int {
 }
 
 func (d *Device) Catalog() int {
+	//os.Stdout.Write(debug.Stack())
 	request := d.CreateRequest(sip.MESSAGE)
 	expires := sip.Expires(3600)
 	d.subscriber.Timeout = time.Now().Add(time.Second * time.Duration(expires))
@@ -358,25 +369,27 @@ func (d *Device) Catalog() int {
 
 	request.AppendHeader(&contentType)
 	request.AppendHeader(&expires)
-	request.SetBody(BuildCatalogXML(d.sn, d.ID), true)
+	request.SetBody(BuildCatalogXML(d.SN, d.ID), true)
 	// 输出Sip请求设备通道信息信令
-	plugin.Sugar().Debugf("SIP->Catalog:%s", request)
+	GB28181Plugin.Sugar().Debugf("SIP->Catalog:%s", request)
 	resp, err := d.SipRequestForResponse(request)
 	if err == nil && resp != nil {
+		GB28181Plugin.Sugar().Debugf("SIP<-Catalog Response: %s", resp.String())
 		return int(resp.StatusCode())
+	} else if err != nil {
+		GB28181Plugin.Error("SIP<-Catalog error:", zap.Error(err))
 	}
 	return http.StatusRequestTimeout
 }
 
-func (d *Device) QueryDeviceInfo(req *sip.Request) {
+func (d *Device) QueryDeviceInfo() {
 	for i := time.Duration(5); i < 100; i++ {
 
-		plugin.Info(fmt.Sprintf("QueryDeviceInfo:%s ipaddr:%s", d.ID, d.NetAddr))
 		time.Sleep(time.Second * i)
 		request := d.CreateRequest(sip.MESSAGE)
 		contentType := sip.ContentType("Application/MANSCDP+xml")
 		request.AppendHeader(&contentType)
-		request.SetBody(BuildDeviceInfoXML(d.sn, d.ID), true)
+		request.SetBody(BuildDeviceInfoXML(d.SN, d.ID), true)
 
 		response, _ := d.SipRequestForResponse(request)
 		if response != nil {
@@ -386,10 +399,8 @@ func (d *Device) QueryDeviceInfo(req *sip.Request) {
 			// 	received, _ := via.Params.Get("received")
 			// 	d.SipIP = received.String()
 			// }
-			if response.StatusCode() != 200 {
+			d.Info("QueryDeviceInfo", zap.Uint16("status code", uint16(response.StatusCode())))
-				plugin.Sugar().Errorf("device %s send Catalog : %d\n", d.ID, response.StatusCode())
+			if response.StatusCode() == http.StatusOK {
-			} else {
-				d.Subscribe()
 				break
 			}
 		}
@@ -401,23 +412,23 @@ func (d *Device) SipRequestForResponse(request sip.Request) (sip.Response, error
 }
 
 // MobilePositionSubscribe 移动位置订阅
-func (d *Device) MobilePositionSubscribe(id string, expires int, interval int) (code int) {
+func (d *Device) MobilePositionSubscribe(id string, expires time.Duration, interval time.Duration) (code int) {
 	mobilePosition := d.CreateRequest(sip.SUBSCRIBE)
 	if d.subscriber.CallID != "" {
 		callId := sip.CallID(utils.RandNumString(10))
 		mobilePosition.ReplaceHeaders(callId.Name(), []sip.Header{&callId})
 	}
-	expiresHeader := sip.Expires(expires)
+	expiresHeader := sip.Expires(expires / time.Second)
-	d.subscriber.Timeout = time.Now().Add(time.Second * time.Duration(expires))
+	d.subscriber.Timeout = time.Now().Add(expires)
 	contentType := sip.ContentType("Application/MANSCDP+xml")
 	mobilePosition.AppendHeader(&contentType)
 	mobilePosition.AppendHeader(&expiresHeader)
 
-	mobilePosition.SetBody(BuildDevicePositionXML(d.sn, id, interval), true)
+	mobilePosition.SetBody(BuildDevicePositionXML(d.SN, id, int(interval/time.Second)), true)
 
 	response, err := d.SipRequestForResponse(mobilePosition)
 	if err == nil && response != nil {
-		if response.StatusCode() == 200 {
+		if response.StatusCode() == http.StatusOK {
 			callId, _ := mobilePosition.CallID()
 			d.subscriber.CallID = callId.String()
 		} else {
@@ -430,13 +441,18 @@ func (d *Device) MobilePositionSubscribe(id string, expires int, interval int) (
 
 // UpdateChannelPosition 更新通道GPS坐标
 func (d *Device) UpdateChannelPosition(channelId string, gpsTime string, lng string, lat string) {
-	if c, ok := d.channelMap[channelId]; ok {
+	if v, ok := d.channelMap.Load(channelId); ok {
-		c.ChannelEx.GpsTime, _ = time.ParseInLocation("2006-01-02 15:04:05", gpsTime, time.Local)
+		c := v.(*Channel)
-		c.ChannelEx.Longitude = lng
+		c.GpsTime = time.Now() //时间取系统收到的时间，避免设备时间和格式问题
-		c.ChannelEx.Latitude = lat
+		c.Longitude = lng
-		plugin.Sugar().Debugf("更新通道[%s]坐标成功\n", c.Name)
+		c.Latitude = lat
+		c.Debug("update channel position success")
 	} else {
-		plugin.Sugar().Debugf("更新失败，未找到通道[%s]\n", channelId)
+		//如果未找到通道，则更新到设备上
+		d.GpsTime = time.Now() //时间取系统收到的时间，避免设备时间和格式问题
+		d.Longitude = lng
+		d.Latitude = lat
+		d.Debug("update device position success", zap.String("channelId", channelId))
 	}
 }
 
@@ -445,20 +461,20 @@ func (d *Device) UpdateChannelStatus(deviceList []*notifyMessage) {
 	for _, v := range deviceList {
 		switch v.Event {
 		case "ON":
-			plugin.Debug("收到通道上线通知")
+			d.Debug("receive channel online notify")
 			d.channelOnline(v.DeviceID)
 		case "OFF":
-			plugin.Debug("收到通道离线通知")
+			d.Debug("receive channel offline notify")
 			d.channelOffline(v.DeviceID)
 		case "VLOST":
-			plugin.Debug("收到通道视频丢失通知")
+			d.Debug("receive channel video lost notify")
 			d.channelOffline(v.DeviceID)
 		case "DEFECT":
-			plugin.Debug("收到通道故障通知")
+			d.Debug("receive channel video defect notify")
 			d.channelOffline(v.DeviceID)
 		case "ADD":
-			plugin.Debug("收到通道新增通知")
+			d.Debug("receive channel add notify")
-			channel := &Channel{
+			channel := ChannelInfo{
 				DeviceID:     v.DeviceID,
 				ParentID:     v.ParentID,
 				Name:         v.Name,
@@ -467,22 +483,22 @@ func (d *Device) UpdateChannelStatus(deviceList []*notifyMessage) {
 				Owner:        v.Owner,
 				CivilCode:    v.CivilCode,
 				Address:      v.Address,
+				Port:         v.Port,
 				Parental:     v.Parental,
 				SafetyWay:    v.SafetyWay,
 				RegisterWay:  v.RegisterWay,
 				Secrecy:      v.Secrecy,
-				Status:       v.Status,
+				Status:       ChannelStatus(v.Status),
 			}
-			channels := []*Channel{channel}
+			d.addOrUpdateChannel(channel)
-			d.UpdateChannels(channels)
 		case "DEL":
 			//删除
-			plugin.Debug("收到通道删除通知")
+			d.Debug("receive channel delete notify")
-			d.channelOffline(v.DeviceID)
+			d.deleteChannel(v.DeviceID)
 		case "UPDATE":
-			plugin.Debug("收到通道更新通知")
+			d.Debug("receive channel update notify")
 			// 更新通道
-			channel := &Channel{
+			channel := ChannelInfo{
 				DeviceID:     v.DeviceID,
 				ParentID:     v.ParentID,
 				Name:         v.Name,
@@ -491,32 +507,34 @@ func (d *Device) UpdateChannelStatus(deviceList []*notifyMessage) {
 				Owner:        v.Owner,
 				CivilCode:    v.CivilCode,
 				Address:      v.Address,
+				Port:         v.Port,
 				Parental:     v.Parental,
 				SafetyWay:    v.SafetyWay,
 				RegisterWay:  v.RegisterWay,
 				Secrecy:      v.Secrecy,
-				Status:       v.Status,
+				Status:       ChannelStatus(v.Status),
 			}
-			channels := []*Channel{channel}
+			d.UpdateChannels(channel)
-			d.UpdateChannels(channels)
 		}
 	}
 }
 
 func (d *Device) channelOnline(DeviceID string) {
-	if c, ok := d.channelMap[DeviceID]; ok {
+	if v, ok := d.channelMap.Load(DeviceID); ok {
-		c.Status = "ON"
+		c := v.(*Channel)
-		plugin.Sugar().Debugf("通道[%s]在线\n", c.Name)
+		c.Status = ChannelOnStatus
+		c.Debug("channel online", zap.String("channelId", DeviceID))
 	} else {
-		plugin.Sugar().Debugf("更新通道[%s]状态失败，未找到\n", DeviceID)
+		d.Debug("update channel status failed, not found", zap.String("channelId", DeviceID))
 	}
 }
 
 func (d *Device) channelOffline(DeviceID string) {
-	if c, ok := d.channelMap[DeviceID]; ok {
+	if v, ok := d.channelMap.Load(DeviceID); ok {
-		c.Status = "OFF"
+		c := v.(*Channel)
-		plugin.Sugar().Debugf("通道[%s]离线\n", c.Name)
+		c.Status = ChannelOffStatus
+		c.Debug("channel offline", zap.String("channelId", DeviceID))
 	} else {
-		plugin.Sugar().Debugf("更新通道[%s]状态失败，未找到\n", DeviceID)
+		d.Debug("update channel status failed, not found", zap.String("channelId", DeviceID))
 	}
 }

go.mod

@@ -1,52 +1,66 @@
 module m7s.live/plugin/gb28181/v4
 
-go 1.18
+go 1.19
 
 require (
-	github.com/ghettovoice/gosip v0.0.0-20220420085539-cf932c28a8fe
+	github.com/ghettovoice/gosip v0.0.0-20231227123312-6b80e2d3e6f7
-	github.com/husanpao/ip v0.0.0-20220711072141-f1e1174bc11b
+	github.com/goccy/go-json v0.10.2
-	github.com/logrusorgru/aurora v2.0.3+incompatible
+	github.com/husanpao/ip v0.0.0-20220711082147-73160bb611a8
-	github.com/pion/rtp/v2 v2.0.0-20220302185659-b3d10fc096b0
+	github.com/logrusorgru/aurora/v4 v4.0.0
-	go.uber.org/zap v1.21.0
+	github.com/pion/rtp v1.8.3
-	golang.org/x/net v0.0.0-20220607020251-c690dde0001d
+	go.uber.org/zap v1.26.0
-	golang.org/x/text v0.3.7
+	golang.org/x/net v0.19.0
-	m7s.live/engine/v4 v4.5.0
+	golang.org/x/text v0.14.0
+	m7s.live/engine/v4 v4.15.2
+	m7s.live/plugin/ps/v4 v4.1.3
 )
 
 require (
-	github.com/cnotch/ipchub v1.1.0 // indirect
+	github.com/bluenviron/gortsplib/v4 v4.6.2 // indirect
+	github.com/bluenviron/mediacommon v1.5.1 // indirect
+	github.com/deepch/vdk v0.0.27 // indirect
+	github.com/denisbrodbeck/machineid v1.0.1 // indirect
 	github.com/discoviking/fsm v0.0.0-20150126104936-f4a273feecca // indirect
-	github.com/fsnotify/fsnotify v1.5.4 // indirect
+	github.com/fsnotify/fsnotify v1.6.0 // indirect
-	github.com/go-ole/go-ole v1.2.6 // indirect
+	github.com/go-ole/go-ole v1.3.0 // indirect
+	github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 // indirect
 	github.com/gobwas/httphead v0.1.0 // indirect
 	github.com/gobwas/pool v0.2.1 // indirect
-	github.com/gobwas/ws v1.1.0 // indirect
+	github.com/gobwas/ws v1.3.1 // indirect
-	github.com/google/uuid v1.3.0 // indirect
+	github.com/golang/mock v1.6.0 // indirect
-	github.com/kr/text v0.2.0 // indirect
+	github.com/google/pprof v0.0.0-20230912144702-c363fe2c2ed8 // indirect
-	github.com/lufia/plan9stats v0.0.0-20220517141722-cf486979b281 // indirect
+	github.com/google/uuid v1.4.0 // indirect
-	github.com/mattn/go-colorable v0.1.12 // indirect
+	github.com/lufia/plan9stats v0.0.0-20230326075908-cb1d2100619a // indirect
-	github.com/mattn/go-isatty v0.0.14 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
+	github.com/mattn/go-isatty v0.0.19 // indirect
+	github.com/mcuadros/go-defaults v1.2.0 // indirect
 	github.com/mgutz/ansi v0.0.0-20200706080929-d51e80ef957d // indirect
-	github.com/onsi/ginkgo v1.16.5 // indirect
+	github.com/onsi/ginkgo/v2 v2.12.1 // indirect
-	github.com/onsi/gomega v1.19.0 // indirect
 	github.com/pion/randutil v0.1.0 // indirect
-	github.com/pion/rtp v1.7.13 // indirect
+	github.com/pion/webrtc/v3 v3.2.20 // indirect
-	github.com/power-devops/perfstat v0.0.0-20220216144756-c35f1ee13d7c // indirect
+	github.com/pkg/errors v0.9.1 // indirect
-	github.com/q191201771/naza v0.30.2 // indirect
+	github.com/power-devops/perfstat v0.0.0-20221212215047-62379fc7944b // indirect
+	github.com/q191201771/naza v0.30.48 // indirect
+	github.com/quic-go/qtls-go1-20 v0.3.3 // indirect
+	github.com/quic-go/quic-go v0.38.1 // indirect
 	github.com/satori/go.uuid v1.2.1-0.20181028125025-b2ce2384e17b // indirect
-	github.com/shirou/gopsutil/v3 v3.22.5 // indirect
+	github.com/shirou/gopsutil/v3 v3.23.8 // indirect
-	github.com/sirupsen/logrus v1.8.1 // indirect
+	github.com/shoenig/go-m1cpu v0.1.6 // indirect
+	github.com/sirupsen/logrus v1.9.3 // indirect
 	github.com/tevino/abool v1.2.0 // indirect
-	github.com/tklauser/go-sysconf v0.3.10 // indirect
+	github.com/tklauser/go-sysconf v0.3.12 // indirect
-	github.com/tklauser/numcpus v0.5.0 // indirect
+	github.com/tklauser/numcpus v0.6.1 // indirect
 	github.com/x-cray/logrus-prefixed-formatter v0.5.2 // indirect
-	github.com/yusufpapurcu/wmi v1.2.2 // indirect
+	github.com/yapingcat/gomedia v0.0.0-20230905155010-55b9713fcec1 // indirect
-	go.uber.org/atomic v1.9.0 // indirect
+	github.com/yusufpapurcu/wmi v1.2.3 // indirect
-	go.uber.org/multierr v1.8.0 // indirect
+	go.uber.org/multierr v1.11.0 // indirect
-	golang.org/x/crypto v0.0.0-20220525230936-793ad666bf5e // indirect
+	golang.org/x/crypto v0.16.0 // indirect
-	golang.org/x/sync v0.0.0-20220601150217-0de741cfad7f // indirect
+	golang.org/x/exp v0.0.0-20230905200255-921286631fa9 // indirect
-	golang.org/x/sys v0.0.0-20220615213510-4f61da869c0c // indirect
+	golang.org/x/mod v0.12.0 // indirect
-	golang.org/x/term v0.0.0-20220526004731-065cf7ba2467 // indirect
+	golang.org/x/sync v0.3.0 // indirect
+	golang.org/x/sys v0.15.0 // indirect
+	golang.org/x/term v0.15.0 // indirect
+	golang.org/x/tools v0.13.0 // indirect
+	google.golang.org/protobuf v1.31.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
-
 )

go.sum

@@ -1,36 +1,40 @@
-github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/bluenviron/gortsplib/v4 v4.6.2 h1:CGIsxpnUFvSlIxnSFS0oFSSfwsHMmBCmYcrGAtIcwXc=
-github.com/benbjohnson/clock v1.1.0 h1:Q92kusRqC1XV2MjkWETPvjJVqKetz1OzxZB7mHJLju8=
+github.com/bluenviron/gortsplib/v4 v4.6.2/go.mod h1:dN1YjyPNMfy/NwC17Ga6MiIMiUoQfg5GL7LGsVHa0Jo=
-github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA=
+github.com/bluenviron/mediacommon v1.5.1 h1:yYVF+ebqZOJh8yH+EeuPcAtTmWR66BqbJGmStxkScoI=
-github.com/cnotch/apirouter v0.0.0-20200731232942-89e243a791f3/go.mod h1:5deJPLON/x/s2dLOQfuKS0lenhOIT4xX0pvtN/OEIuY=
+github.com/bluenviron/mediacommon v1.5.1/go.mod h1:Ij/kE1LEucSjryNBVTyPL/gBI0d6/Css3f5PyrM957w=
-github.com/cnotch/ipchub v1.1.0 h1:hH0lh2mU3AZXPiqMwA0pdtqrwo7PFIMRGush9OobMUs=
-github.com/cnotch/ipchub v1.1.0/go.mod h1:2PbeBs2q2VxxTVCn1eYCDwpAWuVXbq1+N0FU7GimOH4=
-github.com/cnotch/loader v0.0.0-20200405015128-d9d964d09439/go.mod h1:oWpDagHB6p+Kqqq7RoRZKyC4XAXft50hR8pbTxdbYYs=
-github.com/cnotch/queue v0.0.0-20200326024423-6e88bdbf2ad4/go.mod h1:zOssjAlNusOxvtaqT+EMA+Iyi8rrtKr4/XfzN1Fgoeg=
-github.com/cnotch/queue v0.0.0-20201224060551-4191569ce8f6/go.mod h1:zOssjAlNusOxvtaqT+EMA+Iyi8rrtKr4/XfzN1Fgoeg=
-github.com/cnotch/scheduler v0.0.0-20200522024700-1d2da93eefc5/go.mod h1:F4GE3SZkJZ8an1Y0ZCqvSM3jeozNuKzoC67erG1PhIo=
-github.com/cnotch/xlog v0.0.0-20201208005456-cfda439cd3a0/go.mod h1:RW9oHsR79ffl3sR3yMGgxYupMn2btzdtJUwoxFPUE5E=
-github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/deepch/vdk v0.0.27 h1:j/SHaTiZhA47wRpaue8NRp7P9xwOOO/lunxrDJBwcao=
+github.com/deepch/vdk v0.0.27/go.mod h1:JlgGyR2ld6+xOIHa7XAxJh+stSDBAkdNvIPkUIdIywk=
+github.com/denisbrodbeck/machineid v1.0.1 h1:geKr9qtkB876mXguW2X6TU4ZynleN6ezuMSRhl4D7AQ=
+github.com/denisbrodbeck/machineid v1.0.1/go.mod h1:dJUwb7PTidGDeYyUBmXZ2GphQBbjJCrnectwCyxcUSI=
 github.com/discoviking/fsm v0.0.0-20150126104936-f4a273feecca h1:cTTdXpkQ1aVbOOmHwdwtYuwUZcQtcMrleD1UXLWhAq8=
 github.com/discoviking/fsm v0.0.0-20150126104936-f4a273feecca/go.mod h1:W+3LQaEkN8qAwwcw0KC546sUEnX86GIT8CcMLZC4mG0=
-github.com/emitter-io/address v1.0.0/go.mod h1:GfZb5+S/o8694B1GMGK2imUYQyn2skszMvGNA5D84Ug=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
 github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
-github.com/fsnotify/fsnotify v1.5.4 h1:jRbGcIw6P2Meqdwuo0H1p6JVLbL5DHKAKlYndzMwVZI=
+github.com/fsnotify/fsnotify v1.6.0 h1:n+5WquG0fcWoWp6xPWfHdbskMCQaFnG6PfBrh1Ky4HY=
-github.com/ghettovoice/gosip v0.0.0-20220420085539-cf932c28a8fe h1:turrF/P/KarJUx9aUnRNZMQtUu2hsNFNa+iNog+e/fc=
+github.com/fsnotify/fsnotify v1.6.0/go.mod h1:sl3t1tCWJFWoRz9R8WJCbQihKKwmorjAbSClcnxKAGw=
-github.com/ghettovoice/gosip v0.0.0-20220420085539-cf932c28a8fe/go.mod h1:yTr3BEYSFe9As6XM7ldyrVgqsPwlnw8Ahc4N28VFM2g=
+github.com/ghettovoice/gosip v0.0.0-20231227123312-6b80e2d3e6f7 h1:2ENInMa9XHho+1mUM8RZMZomAnfz+qR5v6AS0+TrM8w=
-github.com/go-ole/go-ole v1.2.6 h1:/Fpf6oFPoeFik9ty7siob0G6Ke8QvQEuVcuChpwXzpY=
+github.com/ghettovoice/gosip v0.0.0-20231227123312-6b80e2d3e6f7/go.mod h1:rlD1yLOErWYohWTryG/2bTTpmzB79p52ntLA/uIFXeI=
+github.com/go-logr/logr v1.2.4 h1:g01GSCwiDw2xSZfjJ2/T9M+S6pFdcNtFYsp+Y43HYDQ=
 github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
+github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE=
+github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78=
 github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE=
+github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 h1:tfuBGBXKqDEevZMzYi5KSi8KkcZtzBcTgAUUtapy0OI=
+github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572/go.mod h1:9Pwr4B2jHnOSGXyyzV8ROjYa2ojvAY6HCGYYfMoC3Ls=
 github.com/gobwas/httphead v0.1.0 h1:exrUm0f4YX0L7EBwZHuCF4GDp8aJfVeBrlLQrs6NqWU=
 github.com/gobwas/httphead v0.1.0/go.mod h1:O/RXo79gxV8G+RqlR/otEwx4Q36zl9rqC5u12GKvMCM=
 github.com/gobwas/pool v0.2.1 h1:xfeeEhW7pwmX8nuLVlqbzVc7udMDrwetjEv+TZIz1og=
 github.com/gobwas/pool v0.2.1/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
 github.com/gobwas/ws v1.1.0-rc.1/go.mod h1:nzvNcVha5eUziGrbxFCo6qFIojQHjJV5cLYIbezhfL0=
-github.com/gobwas/ws v1.1.0 h1:7RFti/xnNkMJnrK7D1yQ/iCIB5OrrY/54/H930kIbHA=
+github.com/gobwas/ws v1.3.1 h1:Qi34dfLMWJbiKaNbDVzM9x27nZBjmkaW6i4+Ku+pGVU=
-github.com/gobwas/ws v1.1.0/go.mod h1:nzvNcVha5eUziGrbxFCo6qFIojQHjJV5cLYIbezhfL0=
+github.com/gobwas/ws v1.3.1/go.mod h1:hRKAFb8wOxFROYNsT1bqfWnhX+b5MFeJM9r2ZSwg/KY=
+github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
+github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
+github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc=
+github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
 github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
@@ -38,120 +42,195 @@ github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrU
 github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
 github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
 github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
+github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
+github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
 github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.8 h1:e6P7q2lk1O+qJJb4BtCQXlK8vWEO8V1ZeuEdJNOqZyg=
+github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
-github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
+github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
-github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/google/pprof v0.0.0-20230912144702-c363fe2c2ed8 h1:gpptm606MZYGaMHMsB4Srmb6EbW/IVHnt04rcMXnkBQ=
-github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/google/pprof v0.0.0-20230912144702-c363fe2c2ed8/go.mod h1:czg5+yv1E0ZGTi6S6vVK1mke0fV+FaUhNGcd6VRS9Ik=
+github.com/google/uuid v1.3.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/google/uuid v1.4.0 h1:MtMxsa51/r9yyhkyLsVeVt0B+BGQZzpQiTQ4eHZ8bc4=
+github.com/google/uuid v1.4.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
-github.com/kelindar/process v0.0.0-20170730150328-69a29e249ec3/go.mod h1:+lTCLnZFXOkqwD8sLPl6u4erAc0cP8wFegQHfipz7KE=
+github.com/husanpao/ip v0.0.0-20220711082147-73160bb611a8 h1:4Jk58quTZmzJcTrLlbB5L1Q6qXu49EIjCReWxcBFWKo=
-github.com/kelindar/rate v1.0.0/go.mod h1:AjT4G+hTItNwt30lucEGZIz8y7Uk5zPho6vurIZ+1Es=
+github.com/husanpao/ip v0.0.0-20220711082147-73160bb611a8/go.mod h1:medl9/CfYoQlqAXtAARmMW5dAX2UOdwwkhaszYPk0AM=
-github.com/kelindar/tcp v1.0.0/go.mod h1:JB5hj1cshLU60XrLij2BBxW3JQ4hOye8vqbyvuKb52k=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/konsorten/go-windows-terminal-sequences v1.0.2/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
-github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
-github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/logrusorgru/aurora/v4 v4.0.0 h1:sRjfPpun/63iADiSvGGjgA1cAYegEWMPCJdUpJYn9JA=
-github.com/logrusorgru/aurora v2.0.3+incompatible h1:tOpm7WcpBTn4fjmVfgpQq0EfczGlG91VSDkswnjF5A8=
+github.com/logrusorgru/aurora/v4 v4.0.0/go.mod h1:lP0iIa2nrnT/qoFXcOZSrZQpJ1o6n2CUf/hyHi2Q4ZQ=
-github.com/logrusorgru/aurora v2.0.3+incompatible/go.mod h1:7rIyQOR62GCctdiQpZ/zOJlFyk6y+94wXzv6RNZgaR4=
 github.com/lufia/plan9stats v0.0.0-20211012122336-39d0f177ccd0/go.mod h1:zJYVVT2jmtg6P3p1VtQj7WsuWi/y4VnjVBn7F8KPB3I=
-github.com/lufia/plan9stats v0.0.0-20220517141722-cf486979b281 h1:aczX6NMOtt6L4YT0fQvKkDK6LZEtdOso9sUH89V1+P0=
+github.com/lufia/plan9stats v0.0.0-20230326075908-cb1d2100619a h1:N9zuLhTvBSRt0gWSiJswwQ2HqDmtX/ZCDJURnKUt1Ik=
+github.com/lufia/plan9stats v0.0.0-20230326075908-cb1d2100619a/go.mod h1:JKx41uQRwqlTZabZc+kILPrO/3jlKnQ2Z8b7YiVw5cE=
 github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
-github.com/mattn/go-colorable v0.1.12 h1:jF+Du6AlPIjs2BiUiQlKOX0rt3SujHxPnksPKZbaA40=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
 github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
-github.com/mattn/go-isatty v0.0.14 h1:yVuAays6BHfxijgZPzw+3Zlu5yQgKGP2/hcQbHb7S9Y=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
+github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA=
+github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mcuadros/go-defaults v1.2.0 h1:FODb8WSf0uGaY8elWJAkoLL0Ri6AlZ1bFlenk56oZtc=
+github.com/mcuadros/go-defaults v1.2.0/go.mod h1:WEZtHEVIGYVDqkKSWBdWKUVdRyKlMfulPaGDWIVeCWY=
 github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b/go.mod h1:01TrycV0kFyexm33Z7vhZRXopbI8J3TDReVlkTgMUxE=
 github.com/mgutz/ansi v0.0.0-20200706080929-d51e80ef957d h1:5PJl274Y63IEHC+7izoQE9x6ikvDFZS2mDVS3drnohI=
+github.com/mgutz/ansi v0.0.0-20200706080929-d51e80ef957d/go.mod h1:01TrycV0kFyexm33Z7vhZRXopbI8J3TDReVlkTgMUxE=
+github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e h1:fD57ERR4JtEqsWbfPhv4DMiApHyliiK5xCTNVSPiaAs=
+github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
 github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
 github.com/nxadm/tail v1.4.5/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
 github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE=
 github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU=
 github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk=
 github.com/onsi/ginkgo v1.14.2/go.mod h1:iSB4RoI2tjJc9BBv4NKIKWKya62Rps+oPG/Lv9klQyY=
+github.com/onsi/ginkgo v1.16.4/go.mod h1:dX+/inL/fNMqNlz0e9LfyB9TswhZpCVdJM/Z6Vvnwo0=
 github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE=
 github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042wbpU=
-github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
+github.com/onsi/ginkgo/v2 v2.12.1 h1:uHNEO1RP2SpuZApSkel9nEh1/Mu+hmQe7Q+Pepg5OYA=
+github.com/onsi/ginkgo/v2 v2.12.1/go.mod h1:TE309ZR8s5FsKKpuB1YAQYBzCaAfUgatB/xlT/ETL/o=
 github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
 github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
 github.com/onsi/gomega v1.10.4/go.mod h1:g/HbgYopi++010VEqkFgJHKC09uJiW9UkXvMUuKHUCQ=
-github.com/onsi/gomega v1.19.0 h1:4ieX6qQjPP/BfC3mpsAtIGGlxTWPeA3Inl/7DtXw1tw=
+github.com/onsi/gomega v1.17.0/go.mod h1:HnhC7FXeEQY45zxNK3PPoIUhzk/80Xly9PcubAlGdZY=
+github.com/onsi/gomega v1.27.10 h1:naR28SdDFlqrG6kScpT8VWpu1xWY5nJRCF3XaYyBjhI=
+github.com/pion/datachannel v1.5.5/go.mod h1:iMz+lECmfdCMqFRhXhcA/219B0SQlbpoR2V118yimL0=
+github.com/pion/dtls/v2 v2.2.7/go.mod h1:8WiMkebSHFD0T+dIU+UeBaoV7kDhOW5oDCzZ7WZ/F9s=
+github.com/pion/ice/v2 v2.3.11/go.mod h1:hPcLC3kxMa+JGRzMHqQzjoSj3xtE9F+eoncmXLlCL4E=
+github.com/pion/interceptor v0.1.18/go.mod h1:tpvvF4cPM6NGxFA1DUMbhabzQBxdWMATDGEUYOR9x6I=
+github.com/pion/logging v0.2.2/go.mod h1:k0/tDVsRCX2Mb2ZEmTqNa7CWsQPc+YYCB7Q+5pahoms=
+github.com/pion/mdns v0.0.8/go.mod h1:hYE72WX8WDveIhg7fmXgMKivD3Puklk0Ymzog0lSyaI=
 github.com/pion/randutil v0.1.0 h1:CFG1UdESneORglEsnimhUjf33Rwjubwj6xfiOXBa3mA=
 github.com/pion/randutil v0.1.0/go.mod h1:XcJrSMMbbMRhASFVOlj/5hQial/Y8oH/HVo7TBZq+j8=
-github.com/pion/rtp v1.6.2/go.mod h1:bDb5n+BFZxXx0Ea7E5qe+klMuqiBrP+w8XSjiWtCUko=
+github.com/pion/rtcp v1.2.10/go.mod h1:ztfEwXZNLGyF1oQDttz/ZKIBaeeg/oWbRYqzBM9TL1I=
-github.com/pion/rtp v1.7.13 h1:qcHwlmtiI50t1XivvoawdCGTP4Uiypzfrsap+bijcoA=
+github.com/pion/rtp v1.8.1/go.mod h1:pBGHaFt/yW7bf1jjWAoUjpSNoDnw98KTMg+jWWvziqU=
-github.com/pion/rtp/v2 v2.0.0-20220302185659-b3d10fc096b0 h1:zyOGxHutZ6IhksQSMtwf3OFXB29W5R18yFQWOQJYWjU=
+github.com/pion/rtp v1.8.3 h1:VEHxqzSVQxCkKDSHro5/4IUUG1ea+MFdqR2R3xSpNU8=
-github.com/pion/rtp/v2 v2.0.0-20220302185659-b3d10fc096b0/go.mod h1:Vj+rrFbJCT3yxqE/VSwaOo9DQ2pMKGPxuE7hplGOlOs=
+github.com/pion/rtp v1.8.3/go.mod h1:pBGHaFt/yW7bf1jjWAoUjpSNoDnw98KTMg+jWWvziqU=
-github.com/pixelbender/go-sdp v1.1.0/go.mod h1:6IBlz9+BrUHoFTea7gcp4S54khtOhjCW/nVDLhmZBAs=
+github.com/pion/sctp v1.8.5/go.mod h1:SUFFfDpViyKejTAdwD1d/HQsCu+V/40cCs2nZIvC3s0=
-github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
+github.com/pion/sctp v1.8.8/go.mod h1:igF9nZBrjh5AtmKc7U30jXltsFHicFCXSmWA2GWRaWs=
-github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pion/sdp/v3 v3.0.6/go.mod h1:iiFWFpQO8Fy3S5ldclBkpXqmWy02ns78NOKoLLL0YQw=
+github.com/pion/srtp/v2 v2.0.17/go.mod h1:y5WSHcJY4YfNB/5r7ca5YjHeIr1H3LM1rKArGGs8jMc=
+github.com/pion/stun v0.6.1/go.mod h1:/hO7APkX4hZKu/D0f2lHzNyvdkTGtIy3NDmLR7kSz/8=
+github.com/pion/transport v0.14.1/go.mod h1:4tGmbk00NeYA3rUa9+n+dzCCoKkcy3YlYb99Jn2fNnI=
+github.com/pion/transport/v2 v2.2.1/go.mod h1:cXXWavvCnFF6McHTft3DWS9iic2Mftcz1Aq29pGcU5g=
+github.com/pion/transport/v2 v2.2.2/go.mod h1:OJg3ojoBJopjEeECq2yJdXH9YVrUJ1uQ++NjXLOUorc=
+github.com/pion/transport/v2 v2.2.3/go.mod h1:q2U/tf9FEfnSBGSW6w5Qp5PFWRLRj3NjLhCCgpRK4p0=
+github.com/pion/turn/v2 v2.1.3/go.mod h1:huEpByKKHix2/b9kmTAM3YoX6MKP+/D//0ClgUYR2fY=
+github.com/pion/webrtc/v3 v3.2.20 h1:BQJiXQsJq9LgLp3op7rLy1y8d2WD+LtiS9cpY0uQ22A=
+github.com/pion/webrtc/v3 v3.2.20/go.mod h1:vVURQTBOG5BpWKOJz3nlr23NfTDeyKVmubRNqzQp+Tg=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE=
-github.com/power-devops/perfstat v0.0.0-20220216144756-c35f1ee13d7c h1:NRoLoZvkBTKvR5gQLgA3e0hqjkY9u1wm+iOL45VN/qI=
+github.com/power-devops/perfstat v0.0.0-20221212215047-62379fc7944b h1:0LFwY6Q3gMACTjAbMZBjXAqTOzOwFaj2Ld6cjeQ7Rig=
-github.com/q191201771/naza v0.30.2 h1:9ZC4T5AdSgGlW9cuFGp6H0mOOXQ156HxOzkYPqrvc14=
+github.com/power-devops/perfstat v0.0.0-20221212215047-62379fc7944b/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE=
-github.com/rogpeppe/go-internal v1.8.1 h1:geMPLpDpQOgVyCg5z5GoRwLHepNdb71NXb67XFkP+Eg=
+github.com/q191201771/naza v0.30.48 h1:lbYUaa7A15kJKYwOiU4AbFS1Zo8oQwppl2tLEbJTqnw=
+github.com/q191201771/naza v0.30.48/go.mod h1:n+dpJjQSh90PxBwxBNuifOwQttywvSIN5TkWSSYCeBk=
+github.com/quic-go/qtls-go1-20 v0.3.3 h1:17/glZSLI9P9fDAeyCHBFSWSqJcwx1byhLwP5eUIDCM=
+github.com/quic-go/qtls-go1-20 v0.3.3/go.mod h1:X9Nh97ZL80Z+bX/gUXMbipO6OxdiDi58b/fMC9mAL+k=
+github.com/quic-go/quic-go v0.38.1 h1:M36YWA5dEhEeT+slOu/SwMEucbYd0YFidxG3KlGPZaE=
+github.com/quic-go/quic-go v0.38.1/go.mod h1:ijnZM7JsFIkp4cRyjxJNIzdSfCLmUMg9wdyhGmg+SN4=
 github.com/satori/go.uuid v1.2.1-0.20181028125025-b2ce2384e17b h1:gQZ0qzfKHQIybLANtM3mBXNUtOfsCFXeTsnBqCsx1KM=
 github.com/satori/go.uuid v1.2.1-0.20181028125025-b2ce2384e17b/go.mod h1:dA0hQrYB0VpLJoorglMZABFdXlWrHn1NEOzdhQKdks0=
-github.com/shirou/gopsutil/v3 v3.22.5 h1:atX36I/IXgFiB81687vSiBI5zrMsxcIBkP9cQMJQoJA=
+github.com/sclevine/agouti v3.0.0+incompatible/go.mod h1:b4WX9W9L1sfQKXeJf1mUTLZKJ48R1S7H23Ji7oFO5Bw=
+github.com/shirou/gopsutil/v3 v3.23.8 h1:xnATPiybo6GgdRoC4YoGnxXZFRc3dqQTGi73oLvvBrE=
+github.com/shirou/gopsutil/v3 v3.23.8/go.mod h1:7hmCaBn+2ZwaZOr6jmPBZDfawwMGuo1id3C6aM8EDqQ=
+github.com/shoenig/go-m1cpu v0.1.6 h1:nxdKQNcEB6vzgA2E2bvzKIYRuNj7XNJ4S/aRSwKzFtM=
+github.com/shoenig/go-m1cpu v0.1.6/go.mod h1:1JJMcUBvfNwpq05QDQVAnx3gUHr9IYF7GNg9SUEw2VQ=
+github.com/shoenig/test v0.6.4 h1:kVTaSd7WLz5WZ2IaoM0RSzRsUD+m8wRR+5qvntpn4LU=
+github.com/shoenig/test v0.6.4/go.mod h1:byHiCGXqrVaflBLAMq/srcZIHynQPQgeyvkvXnjqq0k=
 github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
-github.com/sirupsen/logrus v1.8.1 h1:dJKuHgqk1NNQlqoA6BTlM1Wf9DOH3NBjQyu0h9+AZZE=
+github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
-github.com/sqs/goreturns v0.0.0-20181028201513-538ac6014518/go.mod h1:CKI4AZ4XmGV240rTHfO0hfE83S6/a3/Q1siZJ/vXf7A=
+github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
-github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
 github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.7.1 h1:5TQK59W5E3v0r2duFAb7P95B6hEeOyEnHRa8MjYSMTY=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
 github.com/tevino/abool v0.0.0-20170917061928-9b9efcf221b5/go.mod h1:f1SCnEOt6sc3fOJfPQDRDzHOtSXuTtnz0ImG9kPRDV0=
 github.com/tevino/abool v1.2.0 h1:heAkClL8H6w+mK5md9dzsuohKeXHUpY7Vw0ZCKW+huA=
-github.com/tklauser/go-sysconf v0.3.10 h1:IJ1AZGZRWbY8T5Vfk04D9WOA5WSejdflXxP03OUqALw=
+github.com/tevino/abool v1.2.0/go.mod h1:qc66Pna1RiIsPa7O4Egxxs9OqkuxDX55zznh9K07Tzg=
-github.com/tklauser/numcpus v0.5.0 h1:ooe7gN0fg6myJ0EKoTAf5hebTZrH52px3New/D9iJ+A=
+github.com/tklauser/go-sysconf v0.3.12 h1:0QaGUFOdQaIVdPgfITYzaTegZvdCjmYO52cSFAEVmqU=
+github.com/tklauser/go-sysconf v0.3.12/go.mod h1:Ho14jnntGE1fpdOqQEEaiKRpvIavV0hSfmBq8nJbHYI=
+github.com/tklauser/numcpus v0.6.1 h1:ng9scYS7az0Bk4OZLvrNXNSAO2Pxr1XXRAPyjhIx+Fk=
+github.com/tklauser/numcpus v0.6.1/go.mod h1:1XfjsgE2zo8GVw7POkMbHENHzVg3GzmoZ9fESEdAacY=
 github.com/x-cray/logrus-prefixed-formatter v0.5.2 h1:00txxvfBM9muc0jiLIEAkAcIMJzfthRT6usrui8uGmg=
 github.com/x-cray/logrus-prefixed-formatter v0.5.2/go.mod h1:2duySbKsL6M18s5GU7VPsoEPHyzalCE06qoARUCeBBE=
+github.com/yapingcat/gomedia v0.0.0-20230905155010-55b9713fcec1 h1:ilNIuDBR+UKA3qefiyWRoFufIFn3E4tgEXbBM4ILH28=
+github.com/yapingcat/gomedia v0.0.0-20230905155010-55b9713fcec1/go.mod h1:WSZ59bidJOO40JSJmLqlkBJrjZCtjbKKkygEMfzY/kc=
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
-github.com/yusufpapurcu/wmi v1.2.2 h1:KBNDSne4vP5mbSWnJbO+51IMOXJB67QiYCSBrubbPRg=
+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
-github.com/yusufpapurcu/wmi v1.2.2/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
+github.com/yusufpapurcu/wmi v1.2.3 h1:E1ctvB7uKFMOJw3fdOW32DwGE9I7t++CRUEMKvFoFiw=
-go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
+github.com/yusufpapurcu/wmi v1.2.3/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
-go.uber.org/atomic v1.9.0 h1:ECmE8Bn/WFTYwEW/bpKD3M8VtR/zQVbavAoalC1PYyE=
+go.uber.org/goleak v1.2.0 h1:xqgm/S+aQvhWFTtR0XK3Jvg7z8kGV8P4X14IzwN3Eqk=
-go.uber.org/goleak v1.1.11 h1:wy28qYRKZgnJTxGxvye5/wgWr1EKjmUDGYox5mGlRlI=
+go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
-go.uber.org/goleak v1.1.11/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ=
+go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
-go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU=
+go.uber.org/zap v1.26.0 h1:sI7k6L95XOKS281NhVKOFCUNIvv9e0w4BF8N3u+tCRo=
-go.uber.org/multierr v1.8.0 h1:dg6GjLku4EH+249NNmoIciG9N/jURbDG+pFlTkhzIC8=
+go.uber.org/zap v1.26.0/go.mod h1:dtElttAiwGvoJ/vj4IwHBS/gXsEu/pZ50mUIRWuG0so=
-go.uber.org/zap v1.21.0 h1:WefMeulhovoZ2sYXz7st6K0sLj7bBhpiFaud4r4zST8=
-go.uber.org/zap v1.21.0/go.mod h1:wjWOCqI0f2ZZrJF/UufIOkiC8ii6tm1iqIsLo76RfJw=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/crypto v0.0.0-20220525230936-793ad666bf5e h1:T8NU3HyQ8ClP4SEE+KbFlg6n0NhuTsN4MyznaarGsZM=
+golang.org/x/crypto v0.8.0/go.mod h1:mRqEX+O9/h5TFCrQhkgjo2yKi0yYA+9ecGkdQoHrywE=
-golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/crypto v0.10.0/go.mod h1:o4eNf7Ede1fv+hwOwZsTHl9EsPFO6q6ZvYR8vYfY45I=
+golang.org/x/crypto v0.11.0/go.mod h1:xgJhtzW8F9jGdVFWZESrid1U1bjeNy4zgy5cRr/CIio=
+golang.org/x/crypto v0.12.0/go.mod h1:NF0Gs7EO5K4qLn+Ylc+fih8BSTeIjAP05siRnAh98yw=
+golang.org/x/crypto v0.16.0 h1:mMMrFzRSCF0GvB7Ne27XVtVAaXLrPmgPC7/v0tkwHaY=
+golang.org/x/crypto v0.16.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4=
+golang.org/x/exp v0.0.0-20230905200255-921286631fa9 h1:GoHiUyI/Tp2nVkLI2mCxVkOjsbSXD66ic0XW0js0R9g=
+golang.org/x/exp v0.0.0-20230905200255-921286631fa9/go.mod h1:S2oDrQGGwySpoQPVqRShND87VCbxmc6bL1Yd2oYrm6k=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
+golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/mod v0.12.0 h1:rmsUpXtvNzj340zd98LZ4KntptpfRHwpFOHG188oHXc=
+golang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
 golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
 golang.org/x/net v0.0.0-20201202161906-c7110b5ffcbb/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
-golang.org/x/net v0.0.0-20220607020251-c690dde0001d h1:4SFsTMi4UahlKoloni7L4eYzhFRifURQLw+yv0QDCx8=
+golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk=
+golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.1.0/go.mod h1:Cx3nUiGt4eDBEyega/BKRp+/AlGL8hYe7U9odMt2Cco=
+golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
+golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns=
+golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
+golang.org/x/net v0.11.0/go.mod h1:2L/ixqYpgIVXmeoSA/4Lu7BzTG4KIyPIryS4IsOd1oQ=
+golang.org/x/net v0.13.0/go.mod h1:zEVYFnQC7m/vmpQFELhcD1EWkZlX69l4oqgmer6hfKA=
+golang.org/x/net v0.14.0/go.mod h1:PpSgVXXLK0OxS0F31C1/tv6XNguvCrnXIDrFMspZIUI=
+golang.org/x/net v0.19.0 h1:zTwKpTd2XuCqf8huc7Fo2iSy+4RHPd10s4KzeTnVr1c=
+golang.org/x/net v0.19.0/go.mod h1:CfAk/cbD4CthTvqiEl8NpboMuiuOYsAr/7NOjZJtv1U=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20220601150217-0de741cfad7f h1:Ax0t5p6N38Ga0dThY21weqDEyz2oklo4IvDkpigvkD8=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.3.0 h1:ftCYgMx6zT/asHUrPw8BLLscYtGznsLAnjq5RH9P66E=
+golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
 golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
@@ -160,7 +239,6 @@ golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200519105757-fe76b779f299/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -168,24 +246,59 @@ golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201204225414-ed752295db88/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201207223542-d4d67f95c62d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201214095126-aec9a390925b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220615213510-4f61da869c0c h1:aFV+BgZ4svzjfabn8ERpuB4JI4N6/rdy1iusx77G3oU=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.9.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.10.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.15.0 h1:h48lPFYpsTvQJZF4EKyI4aLHaev3CxivZmv7yZig9pc=
+golang.org/x/sys v0.15.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-golang.org/x/term v0.0.0-20220526004731-065cf7ba2467 h1:CBpWXWQpIRjzmkkA+M7q9Fqnwd2mZr3AFqexg8YTfoM=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.1.0/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
+golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY=
+golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
+golang.org/x/term v0.9.0/go.mod h1:M6DEAAIenWoTxdKrOltXcmDY3rSplQUkrvaDU5FcQyo=
+golang.org/x/term v0.10.0/go.mod h1:lpqdcUyK/oCiQxvxVrppt5ggO2KCZ5QblwqPnfZ6d5o=
+golang.org/x/term v0.11.0/go.mod h1:zC9APTIj3jG3FdV/Ons+XE1riIZXG4aZ4GTHiPZJPIU=
+golang.org/x/term v0.15.0 h1:y/Oo/a/q3IXu26lQgl04j/gjuBDOBlx7X6Om1j2CPW4=
+golang.org/x/term v0.15.0/go.mod h1:BDl952bC7+uMoWR75FIrCDx79TPU9oHkTZ9yRbYOrX0=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk=
+golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
+golang.org/x/text v0.10.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
+golang.org/x/text v0.11.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
+golang.org/x/text v0.12.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
+golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
+golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20201224043029-2b0845dc783e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
+golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
+golang.org/x/tools v0.13.0 h1:Iey4qkscZuv0VvIt8E0neZjtPVQFSc870HQ448QgEmQ=
+golang.org/x/tools v0.13.0/go.mod h1:HvlwmtVNQAhOuCjW7xxvovg8wbNq7LwfXh/k7wXUl58=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
@@ -196,21 +309,25 @@ google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQ
 google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
 google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
 google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
+google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
+google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8=
+google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
+gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f h1:BLraFXnmrev5lT+xlilqcH8XK9/i0At2xKjWk4p6zsU=
+gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
-gopkg.in/natefinch/lumberjack.v2 v2.0.0/go.mod h1:l0ndWWf7gzL7RNwBG7wST/UCcT4T24xpD6X8LsfU/+k=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
-gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
+gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-m7s.live/engine/v4 v4.5.0 h1:8UP1Yg0ryiwvKlYtwf4g+RX6EZPDEnpNWzrWcnsxU3U=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-m7s.live/engine/v4 v4.5.0/go.mod h1:uzpGiVnIcuoXehpvqOj9iTVxnyf7RZQZ/Ikiwyjs01E=
+m7s.live/engine/v4 v4.15.2 h1:Uws658Ict2B8JojBG7fNmd2G2i63MlomsQ4npgNzF3g=
+m7s.live/engine/v4 v4.15.2/go.mod h1:uKxjmsjU1WARUNowEkP83BSrJMUjGwkJrX5nPi6DGmE=
+m7s.live/plugin/ps/v4 v4.1.3 h1:Lbvu3ZlX/s3w9lcOwF0SCOCvxtxongPexCIn6x4yukw=
+m7s.live/plugin/ps/v4 v4.1.3/go.mod h1:RAb507iNmPG43I5kUA6ewF1fTRHDRsKbIVkIdLdKeeI=

handle.go

@@ -5,12 +5,12 @@ import (
 	"crypto/md5"
 	"encoding/xml"
 	"fmt"
-
+	"strconv"
-	"github.com/logrusorgru/aurora"
-	"go.uber.org/zap"
-	"m7s.live/plugin/gb28181/v4/utils"
 
 	"github.com/ghettovoice/gosip/sip"
+	"go.uber.org/zap"
+	. "m7s.live/engine/v4"
+	"m7s.live/plugin/gb28181/v4/utils"
 
 	"net/http"
 	"time"
@@ -32,7 +32,7 @@ func (a *Authorization) Verify(username, passwd, realm, nonce string) bool {
 	r2 := a.getDigest(s2)
 
 	if r1 == "" || r2 == "" {
-		fmt.Println("Authorization algorithm wrong")
+		GB28181Plugin.Error("Authorization algorithm wrong")
 		return false
 	}
 	//3、将密文 1，nonce 和密文 2 依次组合获取 1 个字符串，并对这个字符串使用算法加密，获得密文 r3，即Response
@@ -52,15 +52,53 @@ func (a *Authorization) getDigest(raw string) string {
 	}
 }
 
-func (config *GB28181Config) OnRegister(req sip.Request, tx sip.ServerTransaction) {
+func (c *GB28181Config) OnRegister(req sip.Request, tx sip.ServerTransaction) {
-	from, _ := req.From()
+	from, ok := req.From()
-
+	if !ok || from.Address == nil || from.Address.User() == nil {
+		GB28181Plugin.Error("OnRegister", zap.String("error", "no id"))
+		return
+	}
 	id := from.Address.User().String()
-	plugin.Debug(id)
 
+	GB28181Plugin.Debug("SIP<-OnMessage", zap.String("id", id), zap.String("source", req.Source()), zap.String("req", req.String()))
+
+	isUnregister := false
+	if exps := req.GetHeaders("Expires"); len(exps) > 0 {
+		exp := exps[0]
+		expSec, err := strconv.ParseInt(exp.Value(), 10, 32)
+		if err != nil {
+			GB28181Plugin.Info("OnRegister",
+				zap.String("error", fmt.Sprintf("wrong expire header value %q", exp)),
+				zap.String("id", id),
+				zap.String("source", req.Source()),
+				zap.String("destination", req.Destination()))
+			return
+		}
+		if expSec == 0 {
+			isUnregister = true
+		}
+	} else {
+		GB28181Plugin.Info("OnRegister",
+			zap.String("error", "has no expire header"),
+			zap.String("id", id),
+			zap.String("source", req.Source()),
+			zap.String("destination", req.Destination()))
+		return
+	}
+
+	GB28181Plugin.Info("OnRegister",
+		zap.Bool("isUnregister", isUnregister),
+		zap.String("id", id),
+		zap.String("source", req.Source()),
+		zap.String("destination", req.Destination()))
+
+	if len(id) != 20 {
+		GB28181Plugin.Info("Wrong GB-28181", zap.String("id", id))
+		return
+	}
 	passAuth := false
 	// 不需要密码情况
-	if config.Username == "" && config.Password == "" {
+	if c.Username == "" && c.Password == "" {
 		passAuth = true
 	} else {
 		// 需要密码情况 设备第一次上报，返回401和加密算法
@@ -73,7 +111,7 @@ func (config *GB28181Config) OnRegister(req sip.Request, tx sip.ServerTransactio
 			if auth.Username() == id {
 				username = id
 			} else {
-				username = config.Username
+				username = c.Username
 			}
 
 			if dc, ok := DeviceRegisterCount.LoadOrStore(id, 1); ok && dc.(int) > MaxRegisterCount {
@@ -83,7 +121,7 @@ func (config *GB28181Config) OnRegister(req sip.Request, tx sip.ServerTransactio
 			} else {
 				// 设备第二次上报，校验
 				_nonce, loaded := DeviceNonce.Load(id)
-				if loaded && auth.Verify(username, config.Password, config.Realm, _nonce.(string)) {
+				if loaded && auth.Verify(username, c.Password, c.Realm, _nonce.(string)) {
 					passAuth = true
 				} else {
 					DeviceRegisterCount.Store(id, dc.(int)+1)
@@ -92,7 +130,23 @@ func (config *GB28181Config) OnRegister(req sip.Request, tx sip.ServerTransactio
 		}
 	}
 	if passAuth {
-		config.StoreDevice(id, req)
+		var d *Device
+		if isUnregister {
+			tmpd, ok := Devices.LoadAndDelete(id)
+			if ok {
+				GB28181Plugin.Info("Unregister Device", zap.String("id", id))
+				d = tmpd.(*Device)
+			} else {
+				return
+			}
+		} else {
+			if v, ok := Devices.Load(id); ok {
+				d = v.(*Device)
+				c.RecoverDevice(d, req)
+			} else {
+				d = c.StoreDevice(id, req)
+			}
+		}
 		DeviceNonce.Delete(id)
 		DeviceRegisterCount.Delete(id)
 		resp := sip.NewResponseFromRequest("", req, http.StatusOK, "OK", "")
@@ -106,12 +160,19 @@ func (config *GB28181Config) OnRegister(req sip.Request, tx sip.ServerTransactio
 			Contents:   time.Now().Format(TIME_LAYOUT),
 		})
 		_ = tx.Respond(resp)
+
+		if !isUnregister {
+			//订阅设备更新
+			go d.syncChannels()
+		}
 	} else {
+		GB28181Plugin.Info("OnRegister unauthorized", zap.String("id", id), zap.String("source", req.Source()),
+			zap.String("destination", req.Destination()))
 		response := sip.NewResponseFromRequest("", req, http.StatusUnauthorized, "Unauthorized", "")
 		_nonce, _ := DeviceNonce.LoadOrStore(id, utils.RandNumString(32))
 		auth := fmt.Sprintf(
 			`Digest realm="%s",algorithm=%s,nonce="%s"`,
-			config.Realm,
+			c.Realm,
 			"MD5",
 			_nonce.(string),
 		)
@@ -122,30 +183,53 @@ func (config *GB28181Config) OnRegister(req sip.Request, tx sip.ServerTransactio
 		_ = tx.Respond(response)
 	}
 }
-func (config *GB28181Config) OnMessage(req sip.Request, tx sip.ServerTransaction) {
+
-	from, _ := req.From()
+// syncChannels
+// 同步设备信息、下属通道信息，包括主动查询通道信息，订阅通道变化情况
+func (d *Device) syncChannels() {
+	if time.Since(d.lastSyncTime) > 2*conf.HeartbeatInterval {
+		d.lastSyncTime = time.Now()
+		d.Catalog()
+		d.Subscribe()
+		d.QueryDeviceInfo()
+	}
+}
+
+type MessageEvent struct {
+	Type   string
+	Device *Device
+}
+
+func (c *GB28181Config) OnMessage(req sip.Request, tx sip.ServerTransaction) {
+	from, ok := req.From()
+	if !ok || from.Address == nil || from.Address.User() == nil {
+		GB28181Plugin.Error("OnMessage", zap.String("error", "no id"))
+		return
+	}
 	id := from.Address.User().String()
+	GB28181Plugin.Debug("SIP<-OnMessage", zap.String("id", id), zap.String("source", req.Source()), zap.String("req", req.String()))
 	if v, ok := Devices.Load(id); ok {
 		d := v.(*Device)
 		switch d.Status {
-		case "RECOVER":
+		case DeviceOfflineStatus, DeviceRecoverStatus:
-			config.RecoverDevice(d, req)
+			c.RecoverDevice(d, req)
-			return
+			go d.syncChannels()
-		case string(sip.REGISTER):
+		case DeviceRegisterStatus:
-			d.Status = "ONLINE"
+			d.Status = DeviceOnlineStatus
-			//go d.QueryDeviceInfo(req)
 		}
 		d.UpdateTime = time.Now()
 		temp := &struct {
 			XMLName      xml.Name
 			CmdType      string
+			SN           int // 请求序列号，一般用于对应 request 和 response
 			DeviceID     string
 			DeviceName   string
 			Manufacturer string
 			Model        string
 			Channel      string
-			DeviceList   []*Channel `xml:"DeviceList>Item"`
+			DeviceList   []ChannelInfo `xml:"DeviceList>Item"`
-			RecordList   []*Record  `xml:"RecordList>Item"`
+			RecordList   []*Record     `xml:"RecordList>Item"`
+			SumNum       int           // 录像结果的总数 SumNum，录像结果会按照多条消息返回，可用于判断是否全部返回
 		}{}
 		decoder := xml.NewDecoder(bytes.NewReader([]byte(req.Body())))
 		decoder.CharsetReader = charset.NewReaderLabel
@@ -153,7 +237,7 @@ func (config *GB28181Config) OnMessage(req sip.Request, tx sip.ServerTransaction
 		if err != nil {
 			err = utils.DecodeGbk(temp, []byte(req.Body()))
 			if err != nil {
-				plugin.Error("decode catelog err", zap.Error(err))
+				GB28181Plugin.Error("decode catelog err", zap.Error(err))
 			}
 		}
 		var body string
@@ -161,51 +245,65 @@ func (config *GB28181Config) OnMessage(req sip.Request, tx sip.ServerTransaction
 		case "Keepalive":
 			d.LastKeepaliveAt = time.Now()
 			//callID !="" 说明是订阅的事件类型信息
-			if d.Channels == nil {
+			if d.lastSyncTime.IsZero() {
-				go d.Catalog()
+				go d.syncChannels()
 			} else {
-				if d.subscriber.CallID != "" && d.LastKeepaliveAt.After(d.subscriber.Timeout) {
+				d.channelMap.Range(func(key, value interface{}) bool {
-					go d.Catalog()
+					if conf.InviteMode == INVIDE_MODE_AUTO {
-				} else {
+						value.(*Channel).TryAutoInvite(&InviteOptions{})
-					for _, c := range d.Channels {
-						if config.AutoInvite &&
-							(c.LivePublisher == nil) {
-							c.Invite(InviteOptions{})
-						}
 					}
-				}
+					return true
-
+				})
+			}
+			//在KeepLive 进行位置订阅的处理，如果开启了自动订阅位置，则去订阅位置
+			if c.Position.AutosubPosition && time.Since(d.GpsTime) > c.Position.Interval*2 {
+				d.MobilePositionSubscribe(d.ID, c.Position.Expires, c.Position.Interval)
+				GB28181Plugin.Debug("Mobile Position Subscribe", zap.String("deviceID", d.ID))
 			}
-			d.CheckSubStream()
 		case "Catalog":
-			d.UpdateChannels(temp.DeviceList)
+			d.UpdateChannels(temp.DeviceList...)
 		case "RecordInfo":
-			d.UpdateRecord(temp.DeviceID, temp.RecordList)
+			RecordQueryLink.Put(d.ID, temp.DeviceID, temp.SN, temp.SumNum, temp.RecordList)
 		case "DeviceInfo":
 			// 主设备信息
 			d.Name = temp.DeviceName
 			d.Manufacturer = temp.Manufacturer
 			d.Model = temp.Model
 		case "Alarm":
-			d.Status = "Alarmed"
+			d.Status = DeviceAlarmedStatus
 			body = BuildAlarmResponseXML(d.ID)
+		case "Broadcast":
+			GB28181Plugin.Info("broadcast message", zap.String("body", req.Body()))
+		case "PresetQuery":
+			GB28181Plugin.Info("PresetQuery message", zap.String("body", req.Body()))
 		default:
-			plugin.Sugar().Warnf("DeviceID:", aurora.Red(d.ID), " Not supported CmdType : "+temp.CmdType+" body:\n", req.Body)
+			d.Warn("Not supported CmdType", zap.String("CmdType", temp.CmdType), zap.String("body", req.Body()))
 			response := sip.NewResponseFromRequest("", req, http.StatusBadRequest, "", "")
 			tx.Respond(response)
 			return
 		}
-
+		EmitEvent(MessageEvent{
+			Type:   temp.CmdType,
+			Device: d,
+		})
 		tx.Respond(sip.NewResponseFromRequest("", req, http.StatusOK, "OK", body))
+	} else {
+		GB28181Plugin.Debug("Unauthorized message, device not found", zap.String("id", id))
 	}
 }
-func (config *GB28181Config) onBye(req sip.Request, tx sip.ServerTransaction) {
+func (c *GB28181Config) OnBye(req sip.Request, tx sip.ServerTransaction) {
 	tx.Respond(sip.NewResponseFromRequest("", req, http.StatusOK, "OK", ""))
 }
 
+type NotifyEvent MessageEvent
+
 // OnNotify 订阅通知处理
-func (config *GB28181Config) OnNotify(req sip.Request, tx sip.ServerTransaction) {
+func (c *GB28181Config) OnNotify(req sip.Request, tx sip.ServerTransaction) {
-	from, _ := req.From()
+	from, ok := req.From()
+	if !ok || from.Address == nil || from.Address.User() == nil {
+		GB28181Plugin.Error("OnMessage", zap.String("error", "no id"))
+		return
+	}
 	id := from.Address.User().String()
 	if v, ok := Devices.Load(id); ok {
 		d := v.(*Device)
@@ -228,7 +326,7 @@ func (config *GB28181Config) OnNotify(req sip.Request, tx sip.ServerTransaction)
 		if err != nil {
 			err = utils.DecodeGbk(temp, []byte(req.Body()))
 			if err != nil {
-				plugin.Error("decode catelog err", zap.Error(err))
+				GB28181Plugin.Error("decode catelog err", zap.Error(err))
 			}
 		}
 		var body string
@@ -239,15 +337,17 @@ func (config *GB28181Config) OnNotify(req sip.Request, tx sip.ServerTransaction)
 		case "MobilePosition":
 			//更新channel的坐标
 			d.UpdateChannelPosition(temp.DeviceID, temp.Time, temp.Longitude, temp.Latitude)
-		// case "Alarm":
+		case "Alarm":
-		// 	//报警事件通知 TODO
+			d.Status = DeviceAlarmedStatus
 		default:
-			plugin.Sugar().Warnf("DeviceID:", aurora.Red(d.ID), " Not supported CmdType : "+temp.CmdType+" body:", req.Body)
+			d.Warn("Not supported CmdType", zap.String("CmdType", temp.CmdType), zap.String("body", req.Body()))
 			response := sip.NewResponseFromRequest("", req, http.StatusBadRequest, "", "")
 			tx.Respond(response)
 			return
 		}
-
+		EmitEvent(NotifyEvent{
+			Type:   temp.CmdType,
+			Device: d})
 		tx.Respond(sip.NewResponseFromRequest("", req, http.StatusOK, "OK", body))
 	}
 }
@@ -261,6 +361,7 @@ type notifyMessage struct {
 	Owner        string
 	CivilCode    string
 	Address      string
+	Port         int
 	Parental     int
 	SafetyWay    int
 	RegisterWay  int

inviteoption.go

@@ -0,0 +1,67 @@
+package gb28181
+
+import (
+	"errors"
+	"fmt"
+	"math/rand"
+	"strconv"
+)
+
+type InviteOptions struct {
+	Start       int
+	End         int
+	dump        string
+	ssrc        string
+	SSRC        uint32
+	MediaPort   uint16
+	StreamPath  string
+	recyclePort func(p uint16) (err error)
+}
+
+func (o InviteOptions) IsLive() bool {
+	return o.Start == 0 || o.End == 0
+}
+
+func (o InviteOptions) Record() bool {
+	return !o.IsLive()
+}
+
+func (o *InviteOptions) Validate(start, end string) error {
+	if start != "" {
+		sint, err1 := strconv.ParseInt(start, 10, 0)
+		if err1 != nil {
+			return err1
+		}
+		o.Start = int(sint)
+	}
+	if end != "" {
+		eint, err2 := strconv.ParseInt(end, 10, 0)
+		if err2 != nil {
+			return err2
+		}
+		o.End = int(eint)
+	}
+	if o.Start >= o.End {
+		return errors.New("start < end")
+	}
+	return nil
+}
+
+func (o InviteOptions) String() string {
+	return fmt.Sprintf("t=%d %d", o.Start, o.End)
+}
+
+func (o *InviteOptions) CreateSSRC() {
+	ssrc := make([]byte, 10)
+	if o.IsLive() {
+		ssrc[0] = '0'
+	} else {
+		ssrc[0] = '1'
+	}
+	copy(ssrc[1:6], conf.Serial[3:8])
+	randNum := 1000 + rand.Intn(8999)
+	copy(ssrc[6:], strconv.Itoa(randNum))
+	o.ssrc = string(ssrc)
+	_ssrc, _ := strconv.ParseInt(o.ssrc, 10, 0)
+	o.SSRC = uint32(_ssrc)
+}

link.go

@@ -0,0 +1,119 @@
+package gb28181
+
+import (
+	"fmt"
+	"sync"
+	"time"
+
+	"go.uber.org/zap"
+)
+
+// 对于录像查询，通过 queryKey (即 deviceId + channelId + sn) 唯一区分一次请求和响应
+// 并将其关联起来，以实现异步响应的目的
+// 提供单例实例供调用
+var RecordQueryLink = NewRecordQueryLink(time.Second * 60)
+
+type recordQueryLink struct {
+	pendingResult map[string]recordQueryResult // queryKey 查询结果缓存
+	pendingResp   map[string]recordQueryResp   // queryKey 待回复的查询请求
+	timeout       time.Duration                // 查询结果的过期时间
+	sync.RWMutex
+}
+
+type recordQueryResult struct {
+	time     time.Time
+	err      error
+	sum      int
+	finished bool
+	list     []*Record
+}
+type recordQueryResp struct {
+	respChan  chan<- recordQueryResult
+	timeout   time.Duration
+	startTime time.Time
+}
+
+func NewRecordQueryLink(resultTimeout time.Duration) *recordQueryLink {
+	c := &recordQueryLink{
+		timeout:       resultTimeout,
+		pendingResult: make(map[string]recordQueryResult),
+		pendingResp:   make(map[string]recordQueryResp),
+	}
+	return c
+}
+
+// 唯一区分一次录像查询
+func recordQueryKey(deviceId, channelId string, sn int) string {
+	return fmt.Sprintf("%s-%s-%d", deviceId, channelId, sn)
+}
+
+// 定期清理过期的查询结果和请求
+func (c *recordQueryLink) cleanTimeout() {
+	for k, s := range c.pendingResp {
+		if time.Since(s.startTime) > s.timeout {
+			if r, ok := c.pendingResult[k]; ok {
+				c.notify(k, r)
+			} else {
+				c.notify(k, recordQueryResult{err: fmt.Errorf("query time out")})
+			}
+		}
+	}
+	for k, r := range c.pendingResult {
+		if time.Since(r.time) > c.timeout {
+			delete(c.pendingResult, k)
+		}
+	}
+}
+
+func (c *recordQueryLink) Put(deviceId, channelId string, sn int, sum int, record []*Record) {
+	key, r := c.doPut(deviceId, channelId, sn, sum, record)
+	if r.finished {
+		c.notify(key, r)
+	}
+}
+
+func (c *recordQueryLink) doPut(deviceId, channelId string, sn, sum int, record []*Record) (key string, r recordQueryResult) {
+	c.Lock()
+	defer c.Unlock()
+	key = recordQueryKey(deviceId, channelId, sn)
+	if v, ok := c.pendingResult[key]; ok {
+		r = v
+	} else {
+		r = recordQueryResult{time: time.Now(), sum: sum, list: make([]*Record, 0)}
+	}
+
+	r.list = append(r.list, record...)
+	if len(r.list) == sum {
+		r.finished = true
+	}
+	c.pendingResult[key] = r
+	GB28181Plugin.Logger.Debug("put record",
+		zap.String("key", key),
+		zap.Int("sum", sum),
+		zap.Int("count", len(r.list)))
+	return
+}
+
+func (c *recordQueryLink) WaitResult(
+	deviceId, channelId string, sn int,
+	timeout time.Duration) (resultCh <-chan recordQueryResult) {
+
+	key := recordQueryKey(deviceId, channelId, sn)
+	c.Lock()
+	defer c.Unlock()
+	respCh := make(chan recordQueryResult, 1)
+	resultCh = respCh
+	c.pendingResp[key] = recordQueryResp{startTime: time.Now(), timeout: timeout, respChan: respCh}
+	return
+}
+
+func (c *recordQueryLink) notify(key string, r recordQueryResult) {
+	if s, ok := c.pendingResp[key]; ok {
+		s.respChan <- r
+	}
+	c.Lock()
+	defer c.Unlock()
+	delete(c.pendingResp, key)
+	delete(c.pendingResult, key)
+	GB28181Plugin.Logger.Debug("record notify", zap.String("key", key))
+}

main.go

@@ -1,52 +1,65 @@
 package gb28181
 
 import (
-	"fmt"
+	"os"
 	"strings"
+	"sync"
+	"time"
 
+	"github.com/ghettovoice/gosip/sip"
 	myip "github.com/husanpao/ip"
+	"go.uber.org/zap"
 	. "m7s.live/engine/v4"
-	"m7s.live/engine/v4/config"
+	"m7s.live/engine/v4/util"
 )
 
+type GB28181PositionConfig struct {
+	AutosubPosition bool          `desc:"是否自动订阅定位"`             //是否自动订阅定位
+	Expires         time.Duration `default:"3600s" desc:"订阅周期"` //订阅周期
+	Interval        time.Duration `default:"6s" desc:"订阅间隔"`    //订阅间隔
+}
+
 type GB28181Config struct {
-	AutoInvite     bool
+	InviteMode int    `default:"1" desc:"拉流模式" enum:"0:手动拉流,1:预拉流,2:按需拉流"`      //邀请模式，0:手动拉流，1:预拉流，2:按需拉流
-	PreFetchRecord bool
+	InviteIDs  string `default:"131,132" desc:"允许邀请的设备类型（ 11～13位是设备类型编码）,逗号分割"` //按照国标gb28181协议允许邀请的设备类型:132 摄像机 NVR
-
+	ListenAddr string `default:"0.0.0.0" desc:"监听IP地址"`                         //监听地址
 	//sip服务器的配置
-	SipNetwork string //传输协议，默认UDP，可选TCP
+	SipNetwork string   `default:"udp"  desc:"废弃，请使用 Port"`               //传输协议，默认UDP，可选TCP
-	SipIP      string //sip 服务器公网IP
+	SipIP      string   `desc:"sip 服务IP地址"`                               //sip 服务器公网IP
-	SipPort    uint16 //sip 服务器端口，默认 5060
+	SipPort    sip.Port `default:"5060" desc:"废弃，请使用 Port"`               //sip 服务器端口，默认 5060
-	Serial     string //sip 服务器 id, 默认 34020000002000000001
+	Serial     string   `default:"34020000002000000001" desc:"sip 服务 id"` //sip 服务器 id, 默认 34020000002000000001
-	Realm      string //sip 服务器域，默认 3402000000
+	Realm      string   `default:"3402000000" desc:"sip 服务域"`             //sip 服务器域，默认 3402000000
-	Username   string //sip 服务器账号
+	Username   string   `desc:"sip 服务账号"`                                 //sip 服务器账号
-	Password   string //sip 服务器密码
+	Password   string   `desc:"sip 服务密码"`                                 //sip 服务器密码
-
+	Port       struct { // 新配置方式
-	AckTimeout        uint16 //sip 服务应答超时，单位秒
+		Sip   string `default:"udp:5060" desc:"sip服务端口号"`
-	RegisterValidity  int    //注册有效期，单位秒，默认 3600
+		Media string `default:"tcp:58200-59200" desc:"媒体服务端口号"`
-	RegisterInterval  int    //注册间隔，单位秒，默认 60
+		Fdm   bool   `default:"false" desc:"多路复用"`
-	HeartbeatInterval int    //心跳间隔，单位秒，默认 60
+	}
-	HeartbeatRetry    int    //心跳超时次数，默认 3
+	RegisterValidity  time.Duration `default:"3600s" desc:"注册有效期"` //注册有效期，单位秒，默认 3600
+	HeartbeatInterval time.Duration `default:"60s" desc:"心跳间隔"`    //心跳间隔，单位秒，默认 60
 
 	//媒体服务器配置
-	MediaIP          string //媒体服务器地址
+	MediaIP      string `desc:"媒体服务IP地址"`                    //媒体服务器地址
-	MediaPort        uint16 //媒体服务器端口
+	MediaPort    uint16 `default:"58200" desc:"废弃，请使用 Port"` //媒体服务器端口
-	MediaNetwork     string //媒体传输协议，默认UDP，可选TCP
+	MediaNetwork string `default:"tcp" desc:"废弃，请使用 Port"`   //媒体传输协议，默认UDP，可选TCP
-	MediaPortMin     uint16
+	MediaPortMin uint16 `default:"58200" desc:"废弃，请使用 Port"`
-	MediaPortMax     uint16
+	MediaPortMax uint16 `default:"59200" desc:"废弃，请使用 Port"`
-	MediaIdleTimeout uint16 //推流超时时间，超过则断开链接，让设备重连
 
-	// WaitKeyFrame      bool //是否等待关键帧，如果等待，则在收到第一个关键帧之前，忽略所有媒体流
+	RemoveBanInterval time.Duration `default:"600s"  desc:"移除禁止设备间隔"` //移除禁止设备间隔
-	RemoveBanInterval int //移除禁止设备间隔
+	routes            map[string]string
-	UdpCacheSize      int //udp缓存大小
+	DumpPath          string   `desc:"dump PS流本地文件路径"` //dump PS流本地文件路径
+	Ignores           []string `desc:"忽略的设备ID"`        //忽略的设备ID
+	ignores           map[string]struct{}
+	tcpPorts          PortManager
+	udpPorts          PortManager
+
+	Position GB28181PositionConfig //关于定位的配置参数
 
-	config.Publish
-	Server
-	LogLevel string //trace, debug, info, warn, error, fatal, panic
-	routes   map[string]string
-	DumpPath string //dump PS流本地文件路径
 }
 
+var SipUri *sip.SipUri
+
 func (c *GB28181Config) initRoutes() {
 	c.routes = make(map[string]string)
 	tempIps := myip.LocalAndInternalIPs()
@@ -56,14 +69,74 @@ func (c *GB28181Config) initRoutes() {
 			c.routes[k[0:lastdot]] = k
 		}
 	}
-	plugin.Info(fmt.Sprintf("LocalAndInternalIPs detail: %s", c.routes))
+	GB28181Plugin.Info("LocalAndInternalIPs", zap.Any("routes", c.routes))
 }
+
 func (c *GB28181Config) OnEvent(event any) {
-	switch event.(type) {
+	switch e := event.(type) {
 	case FirstConfig:
-		ReadDevices()
+		if c.Port.Sip != "udp:5060" {
+			protocol, ports := util.Conf2Listener(c.Port.Sip)
+			c.SipNetwork = protocol
+			c.SipPort = sip.Port(ports[0])
+		}
+		if c.Port.Media != "tcp:58200-59200" {
+			protocol, ports := util.Conf2Listener(c.Port.Media)
+			c.MediaNetwork = protocol
+			if len(ports) > 1 {
+				c.MediaPortMin = ports[0]
+				c.MediaPortMax = ports[1]
+			} else {
+				c.MediaPortMin = 0
+				c.MediaPortMax = 0
+				c.MediaPort = ports[0]
+			}
+		}
+		if len(c.Ignores) > 0 {
+			c.ignores = make(map[string]struct{})
+			for _, v := range c.Ignores {
+				c.ignores[v] = util.Null
+			}
+		}
+		os.MkdirAll(c.DumpPath, 0766)
+		c.ReadDevices()
+		SipUri = &sip.SipUri{
+			FUser: sip.String{Str: c.Serial},
+			FHost: c.SipIP,
+			FPort: &conf.SipPort,
+		}
 		go c.initRoutes()
 		c.startServer()
+	case InvitePublish:
+		if c.InviteMode == INVIDE_MODE_ONSUBSCRIBE {
+			//流可能是回放流，stream path是device/channel/start-end形式
+			streamNames := strings.Split(e.Target, "/")
+			if channel := FindChannel(streamNames[0], streamNames[1]); channel != nil {
+				opt := InviteOptions{}
+				if len(streamNames) > 2 {
+					last := len(streamNames) - 1
+					timestr := streamNames[last]
+					trange := strings.Split(timestr, "-")
+					if len(trange) == 2 {
+						startTime := trange[0]
+						endTime := trange[1]
+						opt.Validate(startTime, endTime)
+					}
+				}
+				channel.TryAutoInvite(&opt)
+			}
+		}
+	case SEpublish:
+		if channel := FindChannel(e.Target.AppName, strings.TrimSuffix(e.Target.StreamName, "/rtsp")); channel != nil {
+			channel.LiveSubSP = e.Target.Path
+		}
+	case SEclose:
+		if channel := FindChannel(e.Target.AppName, strings.TrimSuffix(e.Target.StreamName, "/rtsp")); channel != nil {
+			channel.LiveSubSP = ""
+		}
+		if v, ok := PullStreams.LoadAndDelete(e.Target.Path); ok {
+			go v.(*PullStream).Bye()
+		}
 	}
 }
 
@@ -71,32 +144,7 @@ func (c *GB28181Config) IsMediaNetworkTCP() bool {
 	return strings.ToLower(c.MediaNetwork) == "tcp"
 }
 
-var conf = &GB28181Config{
+var conf GB28181Config
-	AutoInvite:     true,
-	PreFetchRecord: false,
-	UdpCacheSize:   0,
-	SipNetwork:     "udp",
-	SipIP:          "",
-	SipPort:        5060,
-	Serial:         "34020000002000000001",
-	Realm:          "3402000000",
-	Username:       "",
-	Password:       "",
 
-	AckTimeout:        10,
+var GB28181Plugin = InstallPlugin(&conf)
-	RegisterValidity:  60,
+var PullStreams sync.Map //拉流
-	RegisterInterval:  60,
-	HeartbeatInterval: 60,
-	HeartbeatRetry:    3,
-
-	MediaIP:          "",
-	MediaPort:        58200,
-	MediaIdleTimeout: 30,
-	MediaNetwork:     "udp",
-
-	RemoveBanInterval: 600,
-	LogLevel:          "info",
-	// WaitKeyFrame:      true,
-}
-
-var plugin = InstallPlugin(conf)

manscdp.go

@@ -1,11 +1,23 @@
 package gb28181
 
 import (
+	"encoding/xml"
 	"fmt"
+	"strconv"
 	"time"
 )
 
 var (
+	// 获取预置位列表
+	PresentListXML = `
+<?xml version="1.0"?>
+<Query>
+	<CmdType>PresetQuery</CmdType>
+		<SN>%d</SN>
+	<DeviceID>%s</DeviceID>
+</Query>
+`
+
 	// CatalogXML 获取设备列表xml样式
 	CatalogXML = `<?xml version="1.0"?><Query>
 <CmdType>Catalog</CmdType>
@@ -43,6 +55,17 @@ var (
 </Query>`
 )
 
+func intTotime(t int64) time.Time {
+	tstr := strconv.FormatInt(t, 10)
+	if len(tstr) == 10 {
+		return time.Unix(t, 0)
+	}
+	if len(tstr) == 13 {
+		return time.UnixMilli(t)
+	}
+	return time.Now()
+}
+
 // BuildDeviceInfoXML 获取设备详情指令
 func BuildDeviceInfoXML(sn int, id string) string {
 	return fmt.Sprintf(DeviceInfoXML, sn, id)
@@ -53,9 +76,13 @@ func BuildCatalogXML(sn int, id string) string {
 	return fmt.Sprintf(CatalogXML, sn, id)
 }
 
+func BuildPresetListXML(sn int, id string) string {
+	return fmt.Sprintf(PresentListXML, sn, id)
+}
+
 // BuildRecordInfoXML 获取录像文件列表指令
 func BuildRecordInfoXML(sn int, id string, start, end int64) string {
-	return fmt.Sprintf(RecordInfoXML, sn, id, time.Unix(start, 0).Format("2006-01-02T15:04:05"), time.Unix(end, 0).Format("2006-01-02T15:04:05"))
+	return fmt.Sprintf(RecordInfoXML, sn, id, intTotime(start).Format("2006-01-02T15:04:05"), intTotime(end).Format("2006-01-02T15:04:05"))
 }
 
 // BuildDevicePositionXML 订阅设备位置
@@ -78,3 +105,13 @@ var (
 func BuildAlarmResponseXML(id string) string {
 	return fmt.Sprintf(AlarmResponseXML, id)
 }
+
+func XmlEncode(v interface{}) (string, error) {
+	xmlData, err := xml.MarshalIndent(v, "", " ")
+	if err != nil {
+		return "", err
+	}
+	xml := string(xmlData)
+	xml = `<?xml version="1.0" ?>` + "\n" + xml + "\n"
+	return xml, err
+}

portmanager.go

@@ -0,0 +1,58 @@
+package gb28181
+
+import (
+	"errors"
+)
+
+var ErrNoAvailablePorts = errors.New("no available ports")
+
+type PortManager struct {
+	recycle chan uint16
+	start   uint16
+	max     uint16
+	pos     uint16
+	Valid   bool
+}
+
+func (pm *PortManager) Init(start, end uint16) {
+	pm.start = start
+	pm.pos = start - 1
+	pm.max = end
+	if pm.pos > 0 && pm.max > pm.pos {
+		pm.Valid = true
+		pm.recycle = make(chan uint16, pm.Range())
+	}
+}
+
+func (pm *PortManager) Range() uint16 {
+	return pm.max - pm.pos
+}
+
+func (pm *PortManager) Recycle(p uint16) (err error) {
+	select {
+	case pm.recycle <- p:
+		return nil
+	default:
+		return ErrNoAvailablePorts
+	}
+}
+
+func (pm *PortManager) GetPort() (p uint16, err error) {
+	select {
+	case p = <-pm.recycle:
+		return
+	default:
+		if pm.Range() > 0 {
+			pm.pos++
+			p = pm.pos
+			return
+		} else {
+			if conf.Port.Fdm == false {
+				return 0, ErrNoAvailablePorts
+			}
+			pm.pos = pm.start - 1
+			p = pm.pos
+			return
+		}
+	}
+}

ptz.go

@@ -0,0 +1,107 @@
+package gb28181
+
+import (
+	"encoding/hex"
+	"encoding/xml"
+	"fmt"
+)
+
+var (
+	name2code = map[string]uint8{
+		"stop":      0,
+		"right":     1,
+		"left":      2,
+		"down":      4,
+		"downright": 5,
+		"downleft":  6,
+		"up":        8,
+		"upright":   9,
+		"upleft":    10,
+		"zoomin":    16,
+		"zoomout":   32,
+	}
+)
+
+type PresetCmd byte
+
+const (
+	PresetAddPoint  = 0
+	PresetDelPoint  = 1
+	PresetCallPoint = 2
+)
+
+const DeviceControl = "DeviceControl"
+const PTZFirstByte = 0xA5
+const (
+	PresetSet  = 0x81
+	PresetCall = 0x82
+	PresetDel  = 0x83
+)
+
+type MessagePtz struct {
+	XMLName  xml.Name `xml:"Control"`
+	CmdType  string   `xml:"CmdType"`
+	SN       int      `xml:"SN"`
+	DeviceID string   `xml:"DeviceID"`
+	PTZCmd   string   `xml:"PTZCmd"`
+}
+
+type Preset struct {
+	CMD   byte
+	Point byte
+}
+
+func toPtzStrByCmdName(cmdName string, horizontalSpeed, verticalSpeed, zoomSpeed uint8) (string, error) {
+	c, err := toPtzCode(cmdName)
+	if err != nil {
+		return "", err
+	}
+	return toPtzStr(c, horizontalSpeed, verticalSpeed, zoomSpeed), nil
+}
+
+func toPtzStr(cmdCode, horizontalSpeed, verticalSpeed, zoomSpeed uint8) string {
+	checkCode := uint16(0xA5+0x0F+0x01+cmdCode+horizontalSpeed+verticalSpeed+(zoomSpeed&0xF0)) % 0x100
+
+	return fmt.Sprintf("A50F01%02X%02X%02X%01X0%02X",
+		cmdCode,
+		horizontalSpeed,
+		verticalSpeed,
+		zoomSpeed>>4, // 根据 GB28181 协议，zoom 只取 4 bit
+		checkCode,
+	)
+}
+
+func toPtzCode(cmd string) (uint8, error) {
+	if code, ok := name2code[cmd]; ok {
+		return code, nil
+	} else {
+		return 0, fmt.Errorf("invalid ptz cmd %q", cmd)
+	}
+}
+
+func getVerificationCode(ptz []byte) {
+	sum := uint8(0)
+	for i := 0; i < len(ptz)-1; i++ {
+		sum += ptz[i]
+	}
+	ptz[len(ptz)-1] = sum
+}
+
+func getAssembleCode() uint8 {
+	return (PTZFirstByte>>4 + PTZFirstByte&0xF + 0) % 16
+}
+
+func Pack(cmd, point byte) string {
+	buf := make([]byte, 8)
+	buf[0] = PTZFirstByte
+	buf[1] = getAssembleCode()
+	buf[2] = 0
+
+	buf[3] = cmd
+
+	buf[4] = 0
+	buf[5] = point
+	buf[6] = 0
+	getVerificationCode(buf)
+	return hex.EncodeToString(buf)
+}

publisher.go

@@ -1,299 +0,0 @@
-package gb28181
-
-import (
-	"fmt"
-	"io"
-	"net"
-	"os"
-	"time"
-
-	"github.com/ghettovoice/gosip/sip"
-	"github.com/pion/rtp/v2"
-	"go.uber.org/zap"
-	. "m7s.live/engine/v4"
-	. "m7s.live/engine/v4/codec"
-	"m7s.live/engine/v4/codec/mpegts"
-	. "m7s.live/engine/v4/track"
-	"m7s.live/engine/v4/util"
-	"m7s.live/plugin/gb28181/v4/utils"
-)
-
-type GBPublisher struct {
-	Publisher
-	InviteOptions
-	channel     *Channel
-	inviteRes   sip.Response
-	parser      *utils.DecPSPackage
-	lastSeq     uint16
-	udpCache    *utils.PriorityQueueRtp
-	dumpFile    *os.File
-	dumpPrint   io.Writer
-	lastReceive time.Time
-	reorder     util.RTPReorder[*rtp.Packet]
-}
-
-func (p *GBPublisher) PrintDump(s string) {
-	if p.dumpPrint != nil {
-		p.dumpPrint.Write([]byte(s))
-	}
-}
-
-func (p *GBPublisher) OnEvent(event any) {
-	if p.channel == nil {
-		p.IO.OnEvent(event)
-		return
-	}
-	switch event.(type) {
-	case IPublisher:
-		if p.IsLive() {
-			p.Type = "GB28181 Live"
-			p.channel.LivePublisher = p
-		} else {
-			p.Type = "GB28181 Playback"
-			p.channel.RecordPublisher = p
-		}
-		conf.publishers.Add(p.SSRC, p)
-		if err := error(nil); p.dump != "" {
-			if p.dumpFile, err = os.OpenFile(p.dump, os.O_WRONLY|os.O_CREATE, 0644); err != nil {
-				p.Error("open dump file failed", zap.Error(err))
-			}
-		}
-	case SEwaitPublish:
-		//掉线自动重新拉流
-		if p.IsLive() {
-			if p.channel.LivePublisher != nil {
-				p.channel.LivePublisher = nil
-				p.channel.liveInviteLock.Unlock()
-			}
-			go p.channel.Invite(InviteOptions{})
-		}
-	case SEclose, SEKick:
-		if p.IsLive() {
-			if p.channel.LivePublisher != nil {
-				p.channel.LivePublisher = nil
-				p.channel.liveInviteLock.Unlock()
-			}
-		} else {
-			p.channel.RecordPublisher = nil
-		}
-		conf.publishers.Delete(p.SSRC)
-		if p.dumpFile != nil {
-			p.dumpFile.Close()
-		}
-		p.Bye()
-	}
-	p.Publisher.OnEvent(event)
-}
-
-func (p *GBPublisher) Bye() int {
-	res := p.inviteRes
-	if res == nil {
-		return 404
-	}
-	defer p.Stop()
-	p.inviteRes = nil
-	bye := p.channel.CreateRequst(sip.BYE)
-	from, _ := res.From()
-	to, _ := res.To()
-	callId, _ := res.CallID()
-	bye.ReplaceHeaders(from.Name(), []sip.Header{from})
-	bye.ReplaceHeaders(to.Name(), []sip.Header{to})
-	bye.ReplaceHeaders(callId.Name(), []sip.Header{callId})
-	resp, err := p.channel.device.SipRequestForResponse(bye)
-	if err != nil {
-		p.Error("Bye", zap.Error(err))
-		return 500
-	}
-	return int(resp.StatusCode())
-}
-
-func (p *GBPublisher) PushVideo(pts uint32, dts uint32, payload []byte) {
-	if p.VideoTrack == nil {
-		switch p.parser.VideoStreamType {
-		case mpegts.STREAM_TYPE_H264:
-			p.VideoTrack = NewH264(p.Publisher.Stream)
-		case mpegts.STREAM_TYPE_H265:
-			p.VideoTrack = NewH265(p.Publisher.Stream)
-		default:
-			//推测编码类型
-			var maybe264 H264NALUType
-			maybe264 = maybe264.Parse(payload[4])
-			switch maybe264 {
-			case NALU_Non_IDR_Picture,
-				NALU_IDR_Picture,
-				NALU_SEI,
-				NALU_SPS,
-				NALU_PPS,
-				NALU_Access_Unit_Delimiter:
-				p.VideoTrack = NewH264(p.Publisher.Stream)
-			default:
-				p.Info("maybe h265", zap.Uint8("type", maybe264.Byte()))
-				p.VideoTrack = NewH265(p.Publisher.Stream)
-			}
-		}
-	}
-	if len(payload) > 10 {
-		p.PrintDump(fmt.Sprintf("<td>pts:%d dts:%d data: % 2X</td>", pts, dts, payload[:10]))
-	} else {
-		p.PrintDump(fmt.Sprintf("<td>pts:%d dts:%d data: % 2X</td>", pts, dts, payload))
-	}
-	if dts == 0 {
-		dts = pts
-	}
-	p.VideoTrack.WriteAnnexB(pts, dts, payload)
-}
-func (p *GBPublisher) PushAudio(ts uint32, payload []byte) {
-	if p.AudioTrack == nil {
-		switch p.parser.AudioStreamType {
-		case mpegts.STREAM_TYPE_G711A:
-			at := NewG711(p.Publisher.Stream, true)
-			at.Audio.SampleRate = 8000
-			at.Audio.SampleSize = 16
-			at.Channels = 1
-			at.AVCCHead = []byte{(byte(at.CodecID) << 4) | (1 << 1)}
-			p.AudioTrack = at
-		case mpegts.STREAM_TYPE_G711U:
-			at := NewG711(p.Publisher.Stream, false)
-			at.Audio.SampleRate = 8000
-			at.Audio.SampleSize = 16
-			at.Channels = 1
-			at.AVCCHead = []byte{(byte(at.CodecID) << 4) | (1 << 1)}
-			p.AudioTrack = at
-		case mpegts.STREAM_TYPE_AAC:
-			p.AudioTrack = NewAAC(p.Publisher.Stream)
-			p.WriteADTS(payload[:7])
-		default:
-			p.Error("audio type not supported yet", zap.Uint32("type", p.parser.AudioStreamType))
-			return
-		}
-	} else {
-		p.AudioTrack.WriteRaw(ts, payload)
-	}
-}
-
-// 解析rtp封装 https://www.ietf.org/rfc/rfc2250.txt
-func (p *GBPublisher) PushPS(rtp *rtp.Packet) {
-	if p.parser == nil {
-		p.parser = utils.NewDecPSPackage(p)
-	}
-	if conf.IsMediaNetworkTCP() {
-		p.parser.Feed(rtp.Payload)
-		p.lastSeq = rtp.SequenceNumber
-	} else {
-		for rtp = p.reorder.Push(rtp.SequenceNumber, rtp); rtp != nil; rtp = p.reorder.Pop() {
-			if rtp.SequenceNumber != p.lastSeq+1 {
-				p.parser.Drop()
-			}
-			p.parser.Feed(rtp.Payload)
-			p.lastSeq = rtp.SequenceNumber
-		}
-	}
-}
-
-func (p *GBPublisher) Replay(f *os.File) (err error) {
-	var rtpPacket rtp.Packet
-	defer f.Close()
-	if p.dumpPrint != nil {
-		p.PrintDump(`<style  type="text/css">
-		.gray {
-			color: gray;
-		}
-		</style>
-		`)
-		p.PrintDump("<table>")
-		defer p.PrintDump("</table>")
-	}
-	var t uint16
-	for l := make([]byte, 6); !p.IsClosed(); time.Sleep(time.Millisecond * time.Duration(t)) {
-		_, err = f.Read(l)
-		if err != nil {
-			return
-		}
-		payload := make([]byte, util.ReadBE[int](l[:4]))
-		t = util.ReadBE[uint16](l[4:])
-		p.PrintDump(fmt.Sprintf("[<b>%d</b> %d]", t, len(payload)))
-		_, err = f.Read(payload)
-		if err != nil {
-			return
-		}
-		rtpPacket.Unmarshal(payload)
-		p.PushPS(&rtpPacket)
-	}
-	return
-}
-
-func (p *GBPublisher) ListenUDP() (port uint16, err error) {
-	var rtpPacket rtp.Packet
-	networkBuffer := 1048576
-	port, err = conf.udpPorts.GetPort()
-	if err != nil {
-		return
-	}
-	addr := fmt.Sprintf(":%d", port)
-	mediaAddr, _ := net.ResolveUDPAddr("udp", addr)
-	conn, err := net.ListenUDP("udp", mediaAddr)
-	if err != nil {
-		conf.udpPorts.Recycle(port)
-		plugin.Error("listen media server udp err", zap.String("addr", addr), zap.Error(err))
-		return 0, err
-	}
-	p.SetIO(conn)
-	go func() {
-		defer conn.Close()
-		bufUDP := make([]byte, networkBuffer)
-		plugin.Info("Media udp server start.", zap.Uint16("port", port))
-		defer plugin.Info("Media udp server stop", zap.Uint16("port", port))
-		defer conf.udpPorts.Recycle(port)
-		dumpLen := make([]byte, 6)
-		conn.SetReadDeadline(time.Now().Add(time.Second * 10))
-		for n, _, err := conn.ReadFromUDP(bufUDP); err == nil; n, _, err = conn.ReadFromUDP(bufUDP) {
-			ps := bufUDP[:n]
-			if err := rtpPacket.Unmarshal(ps); err != nil {
-				plugin.Error("Decode rtp error:", zap.Error(err))
-			}
-			if p.dumpFile != nil {
-				util.PutBE(dumpLen[:4], n)
-				if p.lastReceive.IsZero() {
-					util.PutBE(dumpLen[4:], 0)
-				} else {
-					util.PutBE(dumpLen[4:], uint16(time.Since(p.lastReceive).Milliseconds()))
-				}
-				p.lastReceive = time.Now()
-				p.dumpFile.Write(dumpLen)
-				p.dumpFile.Write(ps)
-			}
-			p.PushPS(&rtpPacket)
-			conn.SetReadDeadline(time.Now().Add(time.Second * 10))
-		}
-	}()
-	return
-}
-
-func (p *GBPublisher) ListenTCP() (port uint16, err error) {
-	port, err = conf.tcpPorts.GetPort()
-	if err != nil {
-		return
-	}
-	addr := fmt.Sprintf(":%d", port)
-	mediaAddr, _ := net.ResolveTCPAddr("tcp", addr)
-	listen, err := net.ListenTCP("tcp", mediaAddr)
-	if err != nil {
-		defer conf.tcpPorts.Recycle(port)
-		plugin.Error("listen media server tcp err", zap.String("addr", addr), zap.Error(err))
-		return 0, err
-	}
-	go func() {
-		plugin.Info("Media tcp server start.", zap.Uint16("port", port))
-		defer conf.tcpPorts.Recycle(port)
-		defer plugin.Info("Media tcp server stop", zap.Uint16("port", port))
-		conn, err := listen.Accept()
-		listen.Close()
-		p.SetIO(conn)
-		if err != nil {
-			plugin.Error("Accept err=", zap.Error(err))
-			return
-		}
-		processTcpMediaConn(conf, conn)
-	}()
-	return
-}

restful.go

@@ -1,8 +1,8 @@
 package gb28181
 
 import (
+	"fmt"
 	"net/http"
-	"os"
 	"strconv"
 	"strings"
 	"time"
@@ -10,111 +10,200 @@ import (
 	"m7s.live/engine/v4/util"
 )
 
-func (conf *GB28181Config) API_list(w http.ResponseWriter, r *http.Request) {
+var (
-	util.ReturnJson(func() (list []*Device) {
+	playScaleValues = map[float32]bool{0.25: true, 0.5: true, 1: true, 2: true, 4: true}
+)
+
+func (c *GB28181Config) API_list(w http.ResponseWriter, r *http.Request) {
+	query := r.URL.Query()
+	if query.Get("interval") == "" {
+		query.Set("interval", "5s")
+	}
+	util.ReturnFetchValue(func() (list []*Device) {
+		list = make([]*Device, 0)
 		Devices.Range(func(key, value interface{}) bool {
-			device := value.(*Device)
+			list = append(list, value.(*Device))
-			if time.Since(device.UpdateTime) > time.Duration(conf.RegisterValidity)*time.Second {
-				Devices.Delete(key)
-			} else {
-				list = append(list, device)
-			}
 			return true
 		})
 		return
-	}, time.Second*5, w, r)
+	}, w, r)
 }
 
-func (conf *GB28181Config) API_records(w http.ResponseWriter, r *http.Request) {
+func (c *GB28181Config) API_records(w http.ResponseWriter, r *http.Request) {
-	id := r.URL.Query().Get("id")
+	query := r.URL.Query()
-	channel := r.URL.Query().Get("channel")
+	id := query.Get("id")
-	startTime := r.URL.Query().Get("startTime")
+	channel := query.Get("channel")
-	endTime := r.URL.Query().Get("endTime")
+	startTime := query.Get("startTime")
+	endTime := query.Get("endTime")
+	trange := strings.Split(query.Get("range"), "-")
+	if len(trange) == 2 {
+		startTime = trange[0]
+		endTime = trange[1]
+	}
 	if c := FindChannel(id, channel); c != nil {
-		w.WriteHeader(c.QueryRecord(startTime, endTime))
+		res, err := c.QueryRecord(startTime, endTime)
+		if err == nil {
+			util.ReturnValue(res, w, r)
+		} else {
+			util.ReturnError(util.APIErrorInternal, err.Error(), w, r)
+		}
 	} else {
-		http.NotFound(w, r)
+		util.ReturnError(util.APIErrorNotFound, fmt.Sprintf("device %q channel %q not found", id, channel), w, r)
 	}
 }
 
-func (conf *GB28181Config) API_control(w http.ResponseWriter, r *http.Request) {
+func (c *GB28181Config) API_control(w http.ResponseWriter, r *http.Request) {
 	id := r.URL.Query().Get("id")
 	channel := r.URL.Query().Get("channel")
 	ptzcmd := r.URL.Query().Get("ptzcmd")
 	if c := FindChannel(id, channel); c != nil {
-		w.WriteHeader(c.Control(ptzcmd))
+		util.ReturnError(0, fmt.Sprintf("control code:%d", c.Control(ptzcmd)), w, r)
 	} else {
-		http.NotFound(w, r)
+		util.ReturnError(util.APIErrorNotFound, fmt.Sprintf("device %q channel %q not found", id, channel), w, r)
 	}
 }
 
-func (conf *GB28181Config) API_invite(w http.ResponseWriter, r *http.Request) {
+func (c *GB28181Config) API_ptz(w http.ResponseWriter, r *http.Request) {
+	q := r.URL.Query()
+	id := q.Get("id")
+	channel := q.Get("channel")
+	cmd := q.Get("cmd")   // 命令名称，见 ptz.go name2code 定义
+	hs := q.Get("hSpeed") // 水平速度
+	vs := q.Get("vSpeed") // 垂直速度
+	zs := q.Get("zSpeed") // 缩放速度
+
+	hsN, err := strconv.ParseUint(hs, 10, 8)
+	if err != nil {
+		util.ReturnError(util.APIErrorQueryParse, "hSpeed parameter is invalid", w, r)
+		return
+	}
+	vsN, err := strconv.ParseUint(vs, 10, 8)
+	if err != nil {
+		util.ReturnError(util.APIErrorQueryParse, "vSpeed parameter is invalid", w, r)
+		return
+	}
+	zsN, err := strconv.ParseUint(zs, 10, 8)
+	if err != nil {
+		util.ReturnError(util.APIErrorQueryParse, "zSpeed parameter is invalid", w, r)
+		return
+	}
+
+	ptzcmd, err := toPtzStrByCmdName(cmd, uint8(hsN), uint8(vsN), uint8(zsN))
+	if err != nil {
+		util.ReturnError(util.APIErrorQueryParse, err.Error(), w, r)
+		return
+	}
+	if c := FindChannel(id, channel); c != nil {
+		code := c.Control(ptzcmd)
+		util.ReturnError(code, "device received", w, r)
+	} else {
+		util.ReturnError(util.APIErrorNotFound, fmt.Sprintf("device %q channel %q not found", id, channel), w, r)
+	}
+}
+
+func (c *GB28181Config) API_invite(w http.ResponseWriter, r *http.Request) {
 	query := r.URL.Query()
 	id := query.Get("id")
 	channel := query.Get("channel")
+	streamPath := query.Get("streamPath")
 	port, _ := strconv.Atoi(query.Get("mediaPort"))
 	opt := InviteOptions{
-		dump:      query.Get("dump"),
+		dump:       query.Get("dump"),
-		MediaPort: uint16(port),
+		MediaPort:  uint16(port),
+		StreamPath: streamPath,
 	}
-	opt.Validate(query.Get("startTime"), query.Get("endTime"))
+	startTime := query.Get("startTime")
+	endTime := query.Get("endTime")
+	trange := strings.Split(query.Get("range"), "-")
+	if len(trange) == 2 {
+		startTime = trange[0]
+		endTime = trange[1]
+	}
+	opt.Validate(startTime, endTime)
 	if c := FindChannel(id, channel); c == nil {
-		http.NotFound(w, r)
+		util.ReturnError(util.APIErrorNotFound, fmt.Sprintf("device %q channel %q not found", id, channel), w, r)
-	} else if opt.IsLive() && c.LivePublisher != nil {
+	} else if opt.IsLive() && c.State.Load() > 0 {
-		w.WriteHeader(304) //直播流已存在
+		util.ReturnError(util.APIErrorQueryParse, "live stream already exists", w, r)
-	} else if code, err := c.Invite(opt); err == nil {
+	} else if code, err := c.Invite(&opt); err == nil {
-		w.WriteHeader(code)
+		if code == 200 {
+			util.ReturnOK(w, r)
+		} else {
+			util.ReturnError(util.APIErrorInternal, fmt.Sprintf("invite return code %d", code), w, r)
+		}
 	} else {
-		http.Error(w, err.Error(), code)
+		util.ReturnError(util.APIErrorInternal, err.Error(), w, r)
 	}
 }
 
-func (conf *GB28181Config) API_replay(w http.ResponseWriter, r *http.Request) {
+func (c *GB28181Config) API_bye(w http.ResponseWriter, r *http.Request) {
-	dump := r.URL.Query().Get("dump")
-	printOut := r.URL.Query().Get("print")
-	if dump == "" {
-		dump = conf.DumpPath
-	}
-	f, err := os.OpenFile(dump, os.O_RDONLY, 0644)
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-	} else {
-		streamPath := dump
-		if strings.HasPrefix(dump, "/") {
-			streamPath = "replay" + dump
-		} else {
-			streamPath = "replay/" + dump
-		}
-		var pub GBPublisher
-		pub.SetIO(f)
-		if err = plugin.Publish(streamPath, &pub); err == nil {
-			if printOut != "" {
-				pub.dumpPrint = w
-				pub.SetParentCtx(r.Context())
-				err = pub.Replay(f)
-			} else {
-				go pub.Replay(f)
-				w.Write([]byte("ok"))
-			}
-		} else {
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-		}
-	}
-}
-
-func (conf *GB28181Config) API_bye(w http.ResponseWriter, r *http.Request) {
-	// CORS(w, r)
 	id := r.URL.Query().Get("id")
 	channel := r.URL.Query().Get("channel")
-	live := r.URL.Query().Get("live")
+	streamPath := r.URL.Query().Get("streamPath")
 	if c := FindChannel(id, channel); c != nil {
-		w.WriteHeader(c.Bye(live != "false"))
+		util.ReturnError(0, fmt.Sprintf("bye code:%d", c.Bye(streamPath)), w, r)
 	} else {
-		http.NotFound(w, r)
+		util.ReturnError(util.APIErrorNotFound, fmt.Sprintf("device %q channel %q not found", id, channel), w, r)
 	}
 }
 
-func (conf *GB28181Config) API_position(w http.ResponseWriter, r *http.Request) {
+func (c *GB28181Config) API_play_pause(w http.ResponseWriter, r *http.Request) {
+	id := r.URL.Query().Get("id")
+	channel := r.URL.Query().Get("channel")
+	streamPath := r.URL.Query().Get("streamPath")
+	if c := FindChannel(id, channel); c != nil {
+		util.ReturnError(0, fmt.Sprintf("pause code:%d", c.Pause(streamPath)), w, r)
+	} else {
+		util.ReturnError(util.APIErrorNotFound, fmt.Sprintf("device %q channel %q not found", id, channel), w, r)
+	}
+}
+
+func (c *GB28181Config) API_play_resume(w http.ResponseWriter, r *http.Request) {
+	id := r.URL.Query().Get("id")
+	channel := r.URL.Query().Get("channel")
+	streamPath := r.URL.Query().Get("streamPath")
+	if c := FindChannel(id, channel); c != nil {
+		util.ReturnError(0, fmt.Sprintf("resume code:%d", c.Resume(streamPath)), w, r)
+	} else {
+		util.ReturnError(util.APIErrorNotFound, fmt.Sprintf("device %q channel %q not found", id, channel), w, r)
+	}
+}
+
+func (c *GB28181Config) API_play_seek(w http.ResponseWriter, r *http.Request) {
+	id := r.URL.Query().Get("id")
+	channel := r.URL.Query().Get("channel")
+	streamPath := r.URL.Query().Get("streamPath")
+	secStr := r.URL.Query().Get("second")
+	sec, err := strconv.ParseUint(secStr, 10, 32)
+	if err != nil {
+		util.ReturnError(util.APIErrorQueryParse, "second parameter is invalid: "+err.Error(), w, r)
+		return
+	}
+	if c := FindChannel(id, channel); c != nil {
+		util.ReturnError(0, fmt.Sprintf("play code:%d", c.PlayAt(streamPath, uint(sec))), w, r)
+	} else {
+		util.ReturnError(util.APIErrorNotFound, fmt.Sprintf("device %q channel %q not found", id, channel), w, r)
+	}
+}
+
+func (c *GB28181Config) API_play_forward(w http.ResponseWriter, r *http.Request) {
+	id := r.URL.Query().Get("id")
+	channel := r.URL.Query().Get("channel")
+	streamPath := r.URL.Query().Get("streamPath")
+	speedStr := r.URL.Query().Get("speed")
+	speed, err := strconv.ParseFloat(speedStr, 32)
+	secondErrMsg := "speed parameter is invalid, should be one of 0.25,0.5,1,2,4"
+	if err != nil || !playScaleValues[float32(speed)] {
+		util.ReturnError(util.APIErrorQueryParse, secondErrMsg, w, r)
+		return
+	}
+	if c := FindChannel(id, channel); c != nil {
+		util.ReturnError(0, fmt.Sprintf("playforward code:%d", c.PlayForward(streamPath, float32(speed))), w, r)
+	} else {
+		util.ReturnError(util.APIErrorNotFound, fmt.Sprintf("device %q channel %q not found", id, channel), w, r)
+	}
+}
+
+func (c *GB28181Config) API_position(w http.ResponseWriter, r *http.Request) {
 	//CORS(w, r)
 	query := r.URL.Query()
 	//设备id
@@ -124,13 +213,91 @@ func (conf *GB28181Config) API_position(w http.ResponseWriter, r *http.Request)
 	//订阅间隔（单位：秒）
 	interval := query.Get("interval")
 
-	expiresInt, _ := strconv.Atoi(expires)
+	expiresInt, err := time.ParseDuration(expires)
-	intervalInt, _ := strconv.Atoi(interval)
+	if expires == "" || err != nil {
+		expiresInt = c.Position.Expires
+	}
+	intervalInt, err := time.ParseDuration(interval)
+	if interval == "" || err != nil {
+		intervalInt = c.Position.Interval
+	}
 
 	if v, ok := Devices.Load(id); ok {
 		d := v.(*Device)
-		w.WriteHeader(d.MobilePositionSubscribe(id, expiresInt, intervalInt))
+		util.ReturnError(0, fmt.Sprintf("mobileposition code:%d", d.MobilePositionSubscribe(id, expiresInt, intervalInt)), w, r)
 	} else {
-		http.NotFound(w, r)
+		util.ReturnError(util.APIErrorNotFound, fmt.Sprintf("device %q  not found", id), w, r)
 	}
 }
+
+func (c *GB28181Config) API_preset_list(w http.ResponseWriter, r *http.Request) {
+	query := r.URL.Query()
+	//设备id
+	id := query.Get("id")
+	//获取通道
+	channel := query.Get("channel")
+	if c := FindChannel(id, channel); c != nil {
+		res, err := c.QueryPresetList()
+		if err == nil {
+			util.ReturnValue(res, w, r)
+		} else {
+			util.ReturnError(util.APIErrorInternal, err.Error(), w, r)
+		}
+	} else {
+		util.ReturnError(util.APIErrorNotFound, fmt.Sprintf("device %q channel %q not found", id, channel), w, r)
+	}
+
+}
+
+func (c *GB28181Config) API_preset_control(w http.ResponseWriter, r *http.Request) {
+	//CORS(w, r)
+	query := r.URL.Query()
+	//设备id
+	id := query.Get("id")
+	//获取通道
+	channel := query.Get("channel")
+	//获取cmd
+	ptzCmd := query.Get("cmd")
+	//获取点
+	point := query.Get("point")
+
+	if c := FindChannel(id, channel); c != nil {
+		_ptzCmd, _ := strconv.ParseInt(ptzCmd, 10, 16)
+		_point, _ := strconv.ParseInt(point, 10, 8)
+		code := c.PresetControl(int(_ptzCmd), byte(_point))
+		util.ReturnError(code, "device received", w, r)
+	} else {
+		util.ReturnError(util.APIErrorNotFound, fmt.Sprintf("device %q channel %q not found", id, channel), w, r)
+	}
+}
+
+type DevicePosition struct {
+	ID        string
+	GpsTime   time.Time //gps时间
+	Longitude string    //经度
+	Latitude  string    //纬度
+}
+
+func (c *GB28181Config) API_get_position(w http.ResponseWriter, r *http.Request) {
+	query := r.URL.Query()
+	//设备id
+	id := query.Get("id")
+	if query.Get("interval") == "" {
+		query.Set("interval", fmt.Sprintf("%ds", c.Position.Interval.Seconds()))
+	}
+	util.ReturnFetchValue(func() (list []*DevicePosition) {
+		if id == "" {
+			Devices.Range(func(key, value interface{}) bool {
+				d := value.(*Device)
+				if time.Since(d.GpsTime) <= c.Position.Interval {
+					list = append(list, &DevicePosition{ID: d.ID, GpsTime: d.GpsTime, Longitude: d.Longitude, Latitude: d.Latitude})
+				}
+				return true
+			})
+		} else if v, ok := Devices.Load(id); ok {
+			d := v.(*Device)
+			list = append(list, &DevicePosition{ID: d.ID, GpsTime: d.GpsTime, Longitude: d.Longitude, Latitude: d.Latitude})
+		}
+		return
+	}, w, r)
+}

server.go

@@ -1,87 +1,31 @@
 package gb28181
 
 import (
-	"bufio"
+	"context"
-	"encoding/binary"
 	"fmt"
-	"io"
-	"net"
 	"strconv"
 	"strings"
 	"time"
 
-	"github.com/logrusorgru/aurora"
-	"github.com/pion/rtp/v2"
-	"go.uber.org/zap"
-	"m7s.live/engine/v4/util"
-	"m7s.live/plugin/gb28181/v4/utils"
-
 	"github.com/ghettovoice/gosip"
 	"github.com/ghettovoice/gosip/log"
 	"github.com/ghettovoice/gosip/sip"
+	"github.com/logrusorgru/aurora/v4"
+	"go.uber.org/zap"
+	. "m7s.live/engine/v4"
+	"m7s.live/plugin/gb28181/v4/utils"
 )
 
 var srv gosip.Server
 
-type PortManager struct {
-	recycle chan uint16
-	max     uint16
-	pos     uint16
-	Valid   bool
-}
-
-func (pm *PortManager) Init(start, end uint16) {
-	pm.pos = start
-	pm.max = end
-	if pm.pos > 0 && pm.max > pm.pos {
-		pm.Valid = true
-		pm.recycle = make(chan uint16, pm.Range())
-	}
-}
-
-func (pm *PortManager) Range() uint16 {
-	return pm.max - pm.pos
-}
-
-func (pm *PortManager) Recycle(p uint16) (err error) {
-	select {
-	case pm.recycle <- p:
-		return nil
-	default:
-		return io.EOF //TODO: 换一个Error
-	}
-}
-
-func (pm *PortManager) GetPort() (p uint16, err error) {
-	select {
-	case p = <-pm.recycle:
-		return
-	default:
-		if pm.Range() > 0 {
-			pm.pos++
-			p = pm.pos
-			return
-		} else {
-			return 0, io.EOF //TODO: 换一个Error
-		}
-	}
-}
-
-type Server struct {
-	Ignores    map[string]struct{}
-	publishers util.Map[uint32, *GBPublisher]
-	tcpPorts   PortManager
-	udpPorts   PortManager
-}
-
 const MaxRegisterCount = 3
 
 func FindChannel(deviceId string, channelId string) (c *Channel) {
 	if v, ok := Devices.Load(deviceId); ok {
 		d := v.(*Device)
-		d.channelMutex.RLock()
+		if v, ok := d.channelMap.Load(channelId); ok {
-		c = d.channelMap[channelId]
+			return v.(*Channel)
-		d.channelMutex.RUnlock()
+		}
 	}
 	return
 }
@@ -96,130 +40,109 @@ var levelMap = map[string]log.Level{
 	"panic": log.PanicLevel,
 }
 
-func (config *GB28181Config) startServer() {
+func GetSipServer(transport string) gosip.Server {
-	config.publishers.Init()
+	return srv
-	addr := "0.0.0.0:" + strconv.Itoa(int(config.SipPort))
+}
 
-	logger := utils.NewZapLogger(plugin.Logger, "GB SIP Server", nil)
+var sn = 0
-	logger.SetLevel(levelMap[config.LogLevel])
+
+func CreateRequest(exposedId string, Method sip.RequestMethod, recipient *sip.Address, netAddr string) (req sip.Request) {
+
+	sn++
+
+	callId := sip.CallID(utils.RandNumString(10))
+	userAgent := sip.UserAgentHeader("Monibuca")
+	cseq := sip.CSeq{
+		SeqNo:      uint32(sn),
+		MethodName: Method,
+	}
+	port := sip.Port(conf.SipPort)
+	serverAddr := sip.Address{
+		//DisplayName: sip.String{Str: d.config.Serial},
+		Uri: &sip.SipUri{
+			FUser: sip.String{Str: exposedId},
+			FHost: conf.SipIP,
+			FPort: &port,
+		},
+		Params: sip.NewParams().Add("tag", sip.String{Str: utils.RandNumString(9)}),
+	}
+	req = sip.NewRequest(
+		"",
+		Method,
+		recipient.Uri,
+		"SIP/2.0",
+		[]sip.Header{
+			serverAddr.AsFromHeader(),
+			recipient.AsToHeader(),
+			&callId,
+			&userAgent,
+			&cseq,
+			serverAddr.AsContactHeader(),
+		},
+		"",
+		nil,
+	)
+
+	req.SetTransport(conf.SipNetwork)
+	req.SetDestination(netAddr)
+	//fmt.Printf("构建请求参数:%s", *&req)
+	// requestMsg.DestAdd, err2 = d.ResolveAddress(requestMsg)
+	// if err2 != nil {
+	// 	return nil
+	// }
+	//intranet ip , let's resolve it with public ip
+	// var deviceIp, deviceSourceIP net.IP
+	// switch addr := requestMsg.DestAdd.(type) {
+	// case *net.UDPAddr:
+	// 	deviceIp = addr.IP
+	// case *net.TCPAddr:
+	// 	deviceIp = addr.IP
+	// }
+
+	// switch addr2 := d.SourceAddr.(type) {
+	// case *net.UDPAddr:
+	// 	deviceSourceIP = addr2.IP
+	// case *net.TCPAddr:
+	// 	deviceSourceIP = addr2.IP
+	// }
+	// if deviceIp.IsPrivate() && !deviceSourceIP.IsPrivate() {
+	// 	requestMsg.DestAdd = d.SourceAddr
+	// }
+	return
+}
+func RequestForResponse(transport string, request sip.Request,
+	options ...gosip.RequestWithContextOption) (sip.Response, error) {
+	return (GetSipServer(transport)).RequestWithContext(context.Background(), request, options...)
+}
+
+func (c *GB28181Config) startServer() {
+	addr := c.ListenAddr + ":" + strconv.Itoa(int(c.SipPort))
+
+	logger := utils.NewZapLogger(GB28181Plugin.Logger, "GB SIP Server", nil)
+	logger.SetLevel(uint32(levelMap[EngineConfig.LogLevel]))
 	// logger := log.NewDefaultLogrusLogger().WithPrefix("GB SIP Server")
 	srvConf := gosip.ServerConfig{}
-	if config.SipIP != "" {
+	if c.SipIP != "" {
-		srvConf.Host = config.SipIP
+		srvConf.Host = c.SipIP
 	}
 	srv = gosip.NewServer(srvConf, nil, nil, logger)
-	srv.OnRequest(sip.REGISTER, config.OnRegister)
+	srv.OnRequest(sip.REGISTER, c.OnRegister)
-	srv.OnRequest(sip.MESSAGE, config.OnMessage)
+	srv.OnRequest(sip.MESSAGE, c.OnMessage)
-	srv.OnRequest(sip.NOTIFY, config.OnNotify)
+	srv.OnRequest(sip.NOTIFY, c.OnNotify)
-	srv.OnRequest(sip.BYE, config.onBye)
+	srv.OnRequest(sip.BYE, c.OnBye)
-	err := srv.Listen(strings.ToLower(config.SipNetwork), addr)
+	err := srv.Listen(strings.ToLower(c.SipNetwork), addr)
 	if err != nil {
-		plugin.Logger.Error("gb28181 server listen", zap.Error(err))
+		GB28181Plugin.Logger.Error("gb28181 server listen", zap.Error(err))
 	} else {
-		plugin.Info(fmt.Sprint(aurora.Green("Server gb28181 start at"), aurora.BrightBlue(addr)))
+		GB28181Plugin.Info(fmt.Sprint(aurora.Green("Server gb28181 start at"), aurora.BrightBlue(addr)))
 	}
 
-	go config.startMediaServer()
+	if c.MediaNetwork == "tcp" {
-
+		c.tcpPorts.Init(c.MediaPortMin, c.MediaPortMax)
-	if config.Username != "" || config.Password != "" {
-		go removeBanDevice(config)
-	}
-}
-
-func (config *GB28181Config) startMediaServer() {
-	if config.MediaNetwork == "tcp" {
-		config.tcpPorts.Init(config.MediaPortMin, config.MediaPortMax)
-		if !config.tcpPorts.Valid {
-			config.listenMediaTCP()
-		}
 	} else {
-		config.udpPorts.Init(config.MediaPortMin, config.MediaPortMax)
+		c.udpPorts.Init(c.MediaPortMin, c.MediaPortMax)
-		if !config.udpPorts.Valid {
-			config.listenMediaUDP()
-		}
-	}
-}
-
-func processTcpMediaConn(config *GB28181Config, conn net.Conn) {
-	var rtpPacket rtp.Packet
-	reader := bufio.NewReader(conn)
-	lenBuf := make([]byte, 2)
-	defer conn.Close()
-	var err error
-	for err == nil {
-		if _, err = io.ReadFull(reader, lenBuf); err != nil {
-			return
-		}
-		ps := make([]byte, binary.BigEndian.Uint16(lenBuf))
-		if _, err = io.ReadFull(reader, ps); err != nil {
-			return
-		}
-		if err := rtpPacket.Unmarshal(ps); err != nil {
-			plugin.Error("gb28181 decode rtp error:", zap.Error(err))
-		} else if publisher := config.publishers.Get(rtpPacket.SSRC); publisher != nil && publisher.Publisher.Err() == nil {
-			publisher.PushPS(&rtpPacket)
-		}
-	}
-}
-
-func (config *GB28181Config) listenMediaTCP() {
-	addr := ":" + strconv.Itoa(int(config.MediaPort))
-	mediaAddr, _ := net.ResolveTCPAddr("tcp", addr)
-	listen, err := net.ListenTCP("tcp", mediaAddr)
-
-	if err != nil {
-		plugin.Error("listen media server tcp err", zap.String("addr", addr), zap.Error(err))
-		return
-	}
-	plugin.Info("Media tcp server start.", zap.Uint16("port", config.MediaPort))
-	defer listen.Close()
-	defer plugin.Info("Media tcp server stop", zap.Uint16("port", config.MediaPort))
-
-	for {
-		conn, err := listen.Accept()
-		if err != nil {
-			plugin.Error("Accept err=", zap.Error(err))
-		}
-		go processTcpMediaConn(config, conn)
-	}
-}
-
-func (config *GB28181Config) listenMediaUDP() {
-	var rtpPacket rtp.Packet
-	networkBuffer := 1048576
-
-	addr := ":" + strconv.Itoa(int(config.MediaPort))
-	mediaAddr, _ := net.ResolveUDPAddr("udp", addr)
-	conn, err := net.ListenUDP("udp", mediaAddr)
-
-	if err != nil {
-		plugin.Error("listen media server udp err", zap.String("addr", addr), zap.Error(err))
-		return
-	}
-	bufUDP := make([]byte, networkBuffer)
-	plugin.Info("Media udp server start.", zap.Uint16("port", config.MediaPort))
-	defer plugin.Info("Media udp server stop", zap.Uint16("port", config.MediaPort))
-	dumpLen := make([]byte, 6)
-	for n, _, err := conn.ReadFromUDP(bufUDP); err == nil; n, _, err = conn.ReadFromUDP(bufUDP) {
-		ps := bufUDP[:n]
-		if err := rtpPacket.Unmarshal(ps); err != nil {
-			plugin.Error("Decode rtp error:", zap.Error(err))
-		}
-		if publisher := config.publishers.Get(rtpPacket.SSRC); publisher != nil && publisher.Publisher.Err() == nil {
-			if publisher.dumpFile != nil {
-				util.PutBE(dumpLen[:4], n)
-				if publisher.lastReceive.IsZero() {
-					util.PutBE(dumpLen[4:], 0)
-				} else {
-					util.PutBE(dumpLen[4:], uint16(time.Since(publisher.lastReceive).Milliseconds()))
-				}
-				publisher.lastReceive = time.Now()
-				publisher.dumpFile.Write(dumpLen)
-				publisher.dumpFile.Write(ps)
-			}
-			publisher.PushPS(&rtpPacket)
-		}
 	}
+	go c.startJob()
 }
 
 // func queryCatalog(config *transaction.Config) {
@@ -237,14 +160,58 @@ func (config *GB28181Config) listenMediaUDP() {
 // 	}
 // }
 
-func removeBanDevice(config *GB28181Config) {
+// 定时任务
-	t := time.NewTicker(time.Duration(config.RemoveBanInterval) * time.Second)
+func (c *GB28181Config) startJob() {
-	for range t.C {
+	statusTick := time.NewTicker(c.HeartbeatInterval / 2)
-		DeviceRegisterCount.Range(func(key, value interface{}) bool {
+	banTick := time.NewTicker(c.RemoveBanInterval)
-			if value.(int) > MaxRegisterCount {
+	linkTick := time.NewTicker(time.Millisecond * 100)
-				DeviceRegisterCount.Delete(key)
+	GB28181Plugin.Debug("start job")
+	for {
+		select {
+		case <-banTick.C:
+			if c.Username != "" || c.Password != "" {
+				c.removeBanDevice()
 			}
-			return true
+		case <-statusTick.C:
-		})
+			c.statusCheck()
+		case <-linkTick.C:
+			RecordQueryLink.cleanTimeout()
+		}
 	}
 }
+
+func (c *GB28181Config) removeBanDevice() {
+	DeviceRegisterCount.Range(func(key, value interface{}) bool {
+		if value.(int) > MaxRegisterCount {
+			DeviceRegisterCount.Delete(key)
+		}
+		return true
+	})
+}
+
+// statusCheck
+// -  当设备超过 3 倍心跳时间未发送过心跳（通过 UpdateTime 判断）, 视为离线
+// - 	当设备超过注册有效期内为发送过消息，则从设备列表中删除
+// UpdateTime 在设备发送心跳之外的消息也会被更新，相对于 LastKeepaliveAt 更能体现出设备最会一次活跃的时间
+func (c *GB28181Config) statusCheck() {
+	Devices.Range(func(key, value any) bool {
+		d := value.(*Device)
+		if time.Since(d.UpdateTime) > c.RegisterValidity {
+			Devices.Delete(key)
+			GB28181Plugin.Info("Device register timeout",
+				zap.String("id", d.ID),
+				zap.Time("registerTime", d.RegisterTime),
+				zap.Time("updateTime", d.UpdateTime),
+			)
+		} else if time.Since(d.UpdateTime) > c.HeartbeatInterval*3 {
+			d.Status = DeviceOfflineStatus
+			d.channelMap.Range(func(key, value any) bool {
+				ch := value.(*Channel)
+				ch.Status = ChannelOffStatus
+				return true
+			})
+			GB28181Plugin.Info("Device offline", zap.String("id", d.ID), zap.Time("updateTime", d.UpdateTime))
+		}
+		return true
+	})
+}

utils/buffer.go

@@ -47,6 +47,13 @@ func (b *IOBuffer) ReadN(length int) ([]byte, error) {
 	return nil, io.EOF
 }
 
+//func (b *IOBuffer) Read(buf []byte) (n int, err error) {
+//	var ret []byte
+//	ret, err = b.ReadN(len(buf))
+//	copy(buf, ret)
+//	return len(ret), err
+//}
+
 // empty reports whether the unread portion of the buffer is empty.
 func (b *IOBuffer) empty() bool { return b.Len() <= b.off }
 

utils/log.go

@@ -6,17 +6,18 @@ import (
 	"github.com/ghettovoice/gosip/log"
 	"go.uber.org/zap"
 	"go.uber.org/zap/zapcore"
+	m7slog "m7s.live/engine/v4/log"
 )
 
 type ZapLogger struct {
-	log     *zap.Logger
+	log     *m7slog.Logger
 	prefix  string
 	fields  log.Fields
 	sugared *zap.SugaredLogger
 	level   log.Level
 }
 
-func NewZapLogger(log *zap.Logger, prefix string, fields log.Fields) (z *ZapLogger) {
+func NewZapLogger(log *m7slog.Logger, prefix string, fields log.Fields) (z *ZapLogger) {
 	z = &ZapLogger{
 		log:    log,
 		prefix: prefix,
@@ -130,7 +131,7 @@ func (l *ZapLogger) Prefix() string {
 	return l.prefix
 }
 
-func (l *ZapLogger) WithFields(fields log.Fields) log.Logger {
+func (l *ZapLogger) WithFields(fields map[string]interface{}) log.Logger {
 	return NewZapLogger(l.log, l.Prefix(), l.Fields().WithFields(fields))
 }
 
@@ -153,6 +154,6 @@ func (l *ZapLogger) prepareEntry() *zap.SugaredLogger {
 	return newlog.Sugar()
 }
 
-func (l *ZapLogger) SetLevel(level log.Level) {
+func (l *ZapLogger) SetLevel(level uint32) {
-	l.level = level
+	l.level = log.Level(level)
 }

utils/ps.go

@@ -1,332 +0,0 @@
-package utils
-
-import (
-	"encoding/binary"
-	"errors"
-	"fmt"
-	"io"
-)
-
-const (
-	UDPTransfer        int = 0
-	TCPTransferActive  int = 1
-	TCPTransferPassive int = 2
-	LocalCache         int = 3
-
-	StartCodePS        = 0x000001ba
-	StartCodeSYS       = 0x000001bb
-	StartCodeMAP       = 0x000001bc
-	StartCodeVideo     = 0x000001e0
-	StartCodeAudio     = 0x000001c0
-	PrivateStreamCode  = 0x000001bd
-	MEPGProgramEndCode = 0x000001b9
-
-	RTPHeaderLength    int = 12
-	PSHeaderLength     int = 14
-	SystemHeaderLength int = 18
-	MAPHeaderLength    int = 24
-	PESHeaderLength    int = 19
-	RtpLoadLength      int = 1460
-	PESLoadLength      int = 0xFFFF
-	MAXFrameLen        int = 1024 * 1024 * 2
-)
-
-var (
-	ErrNotFoundStartCode = errors.New("not found the need start code flag")
-	ErrMarkerBit         = errors.New("marker bit value error")
-	ErrFormatPack        = errors.New("not package standard")
-	ErrParsePakcet       = errors.New("parse ps packet error")
-)
-
-type Pusher interface {
-	PushVideo(uint32, uint32, []byte)
-	PushAudio(uint32, []byte)
-	PrintDump(string)
-}
-
-/*
- This implement from VLC source code
- notes: https://github.com/videolan/vlc/blob/master/modules/mux/mpeg/bits.h
-*/
-
-//bitsBuffer bits buffer
-// type bitsBuffer struct {
-// 	iSize int
-// 	iData int
-// 	iMask uint8
-// 	pData []byte
-// }
-
-// func bitsInit(isize int, buffer []byte) *bitsBuffer {
-
-// 	bits := &bitsBuffer{
-// 		iSize: isize,
-// 		iData: 0,
-// 		iMask: 0x80,
-// 		pData: buffer,
-// 	}
-// 	if bits.pData == nil {
-// 		bits.pData = make([]byte, isize)
-// 	}
-// 	return bits
-// }
-
-// func bitsAlign(bits *bitsBuffer) {
-
-// 	if bits.iMask != 0x80 && bits.iData < bits.iSize {
-// 		bits.iMask = 0x80
-// 		bits.iData++
-// 		bits.pData[bits.iData] = 0x00
-// 	}
-// }
-// func bitsWrite(bits *bitsBuffer, count int, src uint64) *bitsBuffer {
-
-// 	for count > 0 {
-// 		count--
-// 		if ((src >> uint(count)) & 0x01) != 0 {
-// 			bits.pData[bits.iData] |= bits.iMask
-// 		} else {
-// 			bits.pData[bits.iData] &= ^bits.iMask
-// 		}
-// 		bits.iMask >>= 1
-// 		if bits.iMask == 0 {
-// 			bits.iData++
-// 			bits.iMask = 0x80
-// 		}
-// 	}
-
-// 	return bits
-// }
-
-/*
-https://github.com/videolan/vlc/blob/master/modules/demux/mpeg
-*/
-type DecPSPackage struct {
-	systemClockReferenceBase      uint64
-	systemClockReferenceExtension uint64
-	programMuxRate                uint32
-
-	VideoStreamType uint32
-	AudioStreamType uint32
-	IOBuffer
-	Payload     []byte
-	videoBuffer []byte
-	audioBuffer []byte
-	PTS         uint32
-	DTS         uint32
-	Pusher
-}
-
-func NewDecPSPackage(p Pusher) *DecPSPackage {
-	p.PrintDump("<tr><td>")
-	return &DecPSPackage{
-		Pusher: p,
-	}
-}
-func (dec *DecPSPackage) clean() {
-	dec.systemClockReferenceBase = 0
-	dec.systemClockReferenceExtension = 0
-	dec.programMuxRate = 0
-	dec.Payload = nil
-	dec.PTS = 0
-	dec.DTS = 0
-}
-
-func (dec *DecPSPackage) ReadPayload() (payload []byte, err error) {
-	payloadlen, err := dec.Uint16()
-	if err != nil {
-		return
-	}
-	return dec.ReadN(int(payloadlen))
-}
-
-// Drop 由于丢包引起的必须丢弃的数据
-func (dec *DecPSPackage) Drop() {
-	dec.Reset()
-	dec.videoBuffer = nil
-	dec.audioBuffer = nil
-	dec.Payload = nil
-}
-
-func (dec *DecPSPackage) Feed(ps []byte) (err error) {
-	if ps[0] == 0 && ps[1] == 0 && ps[2] == 1 {
-		defer dec.Write(ps)
-		if dec.Len() >= 4 {
-			//说明需要处理PS包，处理完后，清空缓存
-			defer dec.Reset()
-		} else {
-			return
-		}
-	} else {
-		// 说明是中间数据，直接写入缓存，否则数据不合法需要丢弃
-		if dec.Len() > 0 {
-			dec.Write(ps)
-		}
-		return nil
-	}
-	for dec.Len() >= 4 {
-		code, _ := dec.Uint32()
-		// println("code:", code)
-		switch code {
-		case StartCodePS:
-			dec.PrintDump("</td></tr><tr><td>")
-			if len(dec.audioBuffer) > 0 {
-				dec.PushAudio(dec.PTS, dec.audioBuffer)
-				dec.audioBuffer = nil
-			}
-			if len(dec.videoBuffer) > 0 {
-				dec.PushVideo(dec.PTS, dec.DTS, dec.videoBuffer)
-				dec.videoBuffer = nil
-			}
-			if err := dec.Skip(9); err != nil {
-				return err
-			}
-			psl, err := dec.ReadByte()
-			if err != nil {
-				return err
-			}
-			psl &= 0x07
-			if err = dec.Skip(int(psl)); err != nil {
-				return err
-			}
-		case StartCodeSYS:
-			dec.PrintDump("</td><td>[sys]")
-			dec.ReadPayload()
-		case StartCodeMAP:
-			dec.decProgramStreamMap()
-			dec.PrintDump("</td><td>[map]")
-		case StartCodeVideo:
-			if dec.videoBuffer == nil {
-				dec.PrintDump("</td><td>")
-			}
-			if err = dec.decPESPacket(); err == nil {
-				dec.videoBuffer = append(dec.videoBuffer, dec.Payload...)
-			} else {
-				fmt.Println("video", err)
-			}
-			dec.PrintDump("[video]")
-		case StartCodeAudio:
-			if dec.audioBuffer == nil {
-				dec.PrintDump("</td><td>")
-			}
-			if err = dec.decPESPacket(); err == nil {
-				dec.audioBuffer = append(dec.audioBuffer, dec.Payload...)
-				dec.PrintDump("[audio]")
-			} else {
-				fmt.Println("audio", err)
-			}
-		case PrivateStreamCode:
-			dec.ReadPayload()
-			dec.PrintDump("</td></tr><tr><td>[ac3]")
-		case MEPGProgramEndCode:
-			dec.PrintDump("</td></tr>")
-			return io.EOF
-		default:
-			fmt.Println("unknow code", code)
-			return ErrParsePakcet
-		}
-	}
-	return nil
-}
-
-/*
-	func (dec *DecPSPackage) decSystemHeader() error {
-		syslens, err := dec.Uint16()
-		if err != nil {
-			return err
-		}
-		// drop rate video audio bound and lock flag
-		syslens -= 6
-		if err = dec.Skip(6); err != nil {
-			return err
-		}
-
-		// ONE WAY: do not to parse the stream  and skip the buffer
-		//br.Skip(syslen * 8)
-
-		// TWO WAY: parse every stream info
-		for syslens > 0 {
-			if nextbits, err := dec.Uint8(); err != nil {
-				return err
-			} else if (nextbits&0x80)>>7 != 1 {
-				break
-			}
-			if err = dec.Skip(2); err != nil {
-				return err
-			}
-			syslens -= 3
-		}
-		return nil
-	}
-*/
-func (dec *DecPSPackage) decProgramStreamMap() error {
-	psm, err := dec.ReadPayload()
-	if err != nil {
-		return err
-	}
-	l := len(psm)
-	index := 2
-	programStreamInfoLen := binary.BigEndian.Uint16(psm[index:])
-	index += 2
-	index += int(programStreamInfoLen)
-	programStreamMapLen := binary.BigEndian.Uint16(psm[index:])
-	index += 2
-	for programStreamMapLen > 0 {
-		if l <= index+1 {
-			break
-		}
-		streamType := psm[index]
-		index++
-		elementaryStreamID := psm[index]
-		index++
-		if elementaryStreamID >= 0xe0 && elementaryStreamID <= 0xef {
-			dec.VideoStreamType = uint32(streamType)
-		} else if elementaryStreamID >= 0xc0 && elementaryStreamID <= 0xdf {
-			dec.AudioStreamType = uint32(streamType)
-		}
-		if l <= index+1 {
-			break
-		}
-		elementaryStreamInfoLength := binary.BigEndian.Uint16(psm[index:])
-		index += 2
-		index += int(elementaryStreamInfoLength)
-		programStreamMapLen -= 4 + elementaryStreamInfoLength
-	}
-	return nil
-}
-
-func (dec *DecPSPackage) decPESPacket() error {
-	payload, err := dec.ReadPayload()
-	if err != nil {
-		return err
-	}
-	if len(payload) < 4 {
-		return errors.New("not enough data")
-	}
-	//data_alignment_indicator := (payload[0]&0b0001_0000)>>4 == 1
-	flag := payload[1]
-	ptsFlag := flag>>7 == 1
-	dtsFlag := (flag&0b0100_0000)>>6 == 1
-	var pts, dts uint32
-	pesHeaderDataLen := payload[2]
-	payload = payload[3:]
-	extraData := payload[:pesHeaderDataLen]
-	if ptsFlag && len(extraData) > 4 {
-		pts = uint32(extraData[0]&0b0000_1110) << 29
-		pts += uint32(extraData[1]) << 22
-		pts += uint32(extraData[2]&0b1111_1110) << 14
-		pts += uint32(extraData[3]) << 7
-		pts += uint32(extraData[4]) >> 1
-		dec.PTS = pts
-		if dtsFlag && len(extraData) > 9 {
-			dts = uint32(extraData[5]&0b0000_1110) << 29
-			dts += uint32(extraData[6]) << 22
-			dts += uint32(extraData[7]&0b1111_1110) << 14
-			dts += uint32(extraData[8]) << 7
-			dts += uint32(extraData[9]) >> 1
-			dec.DTS = dts
-		}
-	}
-	dec.Payload = payload[pesHeaderDataLen:]
-	return err
-}

utils/rtp_sort.go

@@ -4,7 +4,7 @@ import (
 	"container/heap"
 	"errors"
 
-	"github.com/pion/rtp/v2"
+	"github.com/pion/rtp"
 )
 
 const MaxRtpDiff = 65000 //相邻两个包之间的最大差值