testing

av/pktque/filters.go

@@ -36,7 +36,7 @@ type FilterDemuxer struct {
 	audioidx int
 }
 
-func (self FilterDemuxer) ReadPacket() (pkt av.Packet, err error) {
+func (self *FilterDemuxer) ReadPacket() (pkt av.Packet, err error) {
 	if self.streams == nil {
 		if self.streams, err = self.Demuxer.Streams(); err != nil {
 			return
@@ -170,6 +170,20 @@ func (self *AVSync) check(i int) (start time.Duration, end time.Duration, correc
 	return
 }
 
+type CalcDuration struct {
+	LastTime map[int8]time.Duration
+}
+
+func (self *CalcDuration) ModifyPacket(pkt *av.Packet, streams []av.CodecData, videoidx int, audioidx int) (drop bool, err error) {
+	if tmp, ok := self.LastTime[pkt.Idx]; ok && tmp != 0 {
+		pkt.Duration = pkt.Time - self.LastTime[pkt.Idx]
+	} else if pkt.Time < 100*time.Millisecond {
+		pkt.Duration = pkt.Time
+	}
+	self.LastTime[pkt.Idx] = pkt.Time
+	return
+}
+
 // Make packets reading speed as same as walltime, effect like ffmpeg -re option.
 type Walltime struct {
 	firsttime time.Time

codec/h264parser/parser.go

@@ -665,11 +665,19 @@ func (self CodecData) AVCDecoderConfRecordBytes() []byte {
 }
 
 func (self CodecData) SPS() []byte {
-	return self.RecordInfo.SPS[0]
+	if len(self.RecordInfo.SPS) > 0 {
+		return self.RecordInfo.SPS[0]
+	}
+
+	return []byte{0}
 }
 
 func (self CodecData) PPS() []byte {
-	return self.RecordInfo.PPS[0]
+	if len(self.RecordInfo.PPS) > 0 {
+		return self.RecordInfo.PPS[0]
+	}
+
+	return []byte{0}
 }
 
 func (self CodecData) Width() int {

example/test/main.go

@@ -0,0 +1,25 @@
+package main
+
+import (
+	"github.com/deepch/vdk/format/ts"
+	"log"
+	"os"
+)
+
+func main() {
+	f, _ := os.Open("edb9708f29b24ba9b175808d6b9df9c6541e25766d4a40209a8f903948b72f3f.ts")
+	m := ts.NewDemuxer(f)
+	var i int
+	for {
+		p, err := m.ReadPacket()
+		if err != nil {
+			return
+		}
+		if p.IsKeyFrame {
+			i = 0
+		}
+		log.Println(i, p.Time, p.Data[4:10], len(p.Data))
+		i++
+
+	}
+}

example/transcoder/main.go

@@ -0,0 +1,64 @@
+package main
+
+import (
+	"context"
+	"github.com/deepch/vdk/format/rtspv2"
+	"github.com/deepch/vdk/format/ts"
+	"log"
+	"os/exec"
+	"time"
+)
+
+func main() {
+	RTSPClient, err := rtspv2.Dial(rtspv2.RTSPClientOptions{URL: "rtsp://url", DisableAudio: true, DialTimeout: 3 * time.Second, ReadWriteTimeout: 5 * time.Second, Debug: true, OutgoingProxy: false})
+	if err != nil {
+		panic(err)
+	}
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	cmd := exec.CommandContext(ctx, "ffmpeg", "-flags", "low_delay", "-analyzeduration", "1", "-fflags", "-nobuffer", "-probesize", "1024k", "-f", "mpegts", "-i", "-", "-vcodec", "libx264", "-preset", "ultrafast", "-bf", "0", "-f", "mpegts", "-max_muxing_queue_size", "400", "-pes_payload_size", "0", "pipe:1")
+	inPipe, _ := cmd.StdinPipe()
+	outPipe, _ := cmd.StdoutPipe()
+	//cmd.Stderr = os.Stderr
+	mux := ts.NewMuxer(inPipe)
+	demuxer := ts.NewDemuxer(outPipe)
+	codec := RTSPClient.CodecData
+	mux.WriteHeader(codec)
+	go func() {
+		imNewCodec, err := demuxer.Streams()
+		log.Println("new codec data", imNewCodec, err)
+		for i, data := range imNewCodec {
+			log.Println(i, data)
+		}
+		for {
+			pkt, err := demuxer.ReadPacket()
+			if err != nil {
+				log.Panic(err)
+			}
+			log.Println("im new pkt ===>", pkt.Idx, pkt.Time)
+		}
+	}()
+	cmd.Start()
+	var start bool
+	for {
+		select {
+		case signals := <-RTSPClient.Signals:
+			switch signals {
+			case rtspv2.SignalCodecUpdate:
+				//?
+			case rtspv2.SignalStreamRTPStop:
+				return
+			}
+		case packetAV := <-RTSPClient.OutgoingPacketQueue:
+			if packetAV.IsKeyFrame {
+				start = true
+			}
+			if !start {
+				continue
+			}
+			if err = mux.WritePacket(*packetAV); err != nil {
+				return
+			}
+		}
+	}
+}

format/mp4/mp4io/mp4io.go

@@ -387,6 +387,10 @@ func ReadFileAtoms(r io.ReadSeeker) (atoms []Atom, err error) {
 			return
 		}
 		size := pio.U32BE(taghdr[0:])
+		if size > 5242880 {
+			err = parseErr("len", 5242880, err)
+			return 
+		}
 		tag := Tag(pio.U32BE(taghdr[4:]))
 
 		var atom Atom

format/mp4/muxer.go

@@ -3,23 +3,22 @@ package mp4
 import (
 	"bufio"
 	"fmt"
-	"io"
-	"time"
-
-	"github.com/deepch/vdk/codec/h265parser"
-
 	"github.com/deepch/vdk/av"
 	"github.com/deepch/vdk/codec/aacparser"
 	"github.com/deepch/vdk/codec/h264parser"
+	"github.com/deepch/vdk/codec/h265parser"
 	"github.com/deepch/vdk/format/mp4/mp4io"
 	"github.com/deepch/vdk/utils/bits/pio"
+	"io"
+	"time"
 )
 
 type Muxer struct {
-	w       io.WriteSeeker
-	bufw    *bufio.Writer
-	wpos    int64
-	streams []*Stream
+	w                  io.WriteSeeker
+	bufw               *bufio.Writer
+	wpos               int64
+	streams            []*Stream
+	NegativeTsMakeZero bool
 }
 
 func NewMuxer(w io.WriteSeeker) *Muxer {
@@ -206,8 +205,12 @@ func (self *Muxer) WritePacket(pkt av.Packet) (err error) {
 
 func (self *Stream) writePacket(pkt av.Packet, rawdur time.Duration) (err error) {
 	if rawdur < 0 {
-		err = fmt.Errorf("mp4: stream#%d time=%v < lasttime=%v", pkt.Idx, pkt.Time, self.lastpkt.Time)
-		return
+		if self.muxer.NegativeTsMakeZero {
+			rawdur = 0
+		} else {
+			err = fmt.Errorf("mp4: stream#%d time=%v < lasttime=%v", pkt.Idx, pkt.Time, self.lastpkt.Time)
+			return
+		}
 	}
 
 	if _, err = self.muxer.bufw.Write(pkt.Data); err != nil {

format/mp4f/muxer.go

@@ -3,6 +3,7 @@ package mp4f
 import (
 	"bufio"
 	"fmt"
+	"log"
 	"os"
 	"time"
 
@@ -238,14 +239,15 @@ func (self *Muxer) WriteTrailer() (err error) {
 	return
 }
 
-func (element *Muxer) WriteHeader(streams []av.CodecData) (err error) {
+func (element *Muxer) WriteHeader(streams []av.CodecData) error {
 	element.streams = []*Stream{}
 	for _, stream := range streams {
-		if err = element.newStream(stream); err != nil {
-			return
+		if err := element.newStream(stream); err != nil {
+			log.Println("WriteHeader", err)
 		}
 	}
-	return
+
+	return nil
 }
 
 func (element *Muxer) GetInit(streams []av.CodecData) (string, []byte) {
@@ -285,6 +287,9 @@ func (element *Muxer) GetInit(streams []av.CodecData) (string, []byte) {
 }
 
 func (element *Muxer) WritePacket(pkt av.Packet, GOP bool) (bool, []byte, error) {
+	if pkt.Idx+1 > int8(len(element.streams)) {
+		return false, nil, nil
+	}
 	stream := element.streams[pkt.Idx]
 	if GOP {
 		ts := time.Duration(0)

format/mp4m/mp4io/mp4io.go

@@ -387,6 +387,12 @@ func ReadFileAtoms(r io.ReadSeeker) (atoms []Atom, err error) {
 			return
 		}
 		size := pio.U32BE(taghdr[0:])
+
+		if size == 0 {
+			err = fmt.Errorf("bad hdr size")
+			return
+		}
+
 		tag := Tag(pio.U32BE(taghdr[4:]))
 
 		var atom Atom

format/mp4m/muxer.go

@@ -14,10 +14,11 @@ import (
 )
 
 type Muxer struct {
-	w       io.WriteSeeker
-	bufw    *bufio.Writer
-	wpos    int64
-	streams []*Stream
+	w                  io.WriteSeeker
+	bufw               *bufio.Writer
+	wpos               int64
+	streams            []*Stream
+	NegativeTsMakeZero bool
 }
 
 func NewMuxer(w io.WriteSeeker) *Muxer {
@@ -181,8 +182,12 @@ func (self *Muxer) WritePacket(pkt av.Packet) (err error) {
 
 func (self *Stream) writePacket(pkt av.Packet, rawdur time.Duration) (err error) {
 	if rawdur < 0 {
-		err = fmt.Errorf("mp4: stream#%d time=%v < lasttime=%v", pkt.Idx, pkt.Time, self.lastpkt.Time)
-		return
+		if self.muxer.NegativeTsMakeZero {
+			rawdur = 0
+		} else {
+			err = fmt.Errorf("mp4: stream#%d time=%v < lasttime=%v", pkt.Idx, pkt.Time, self.lastpkt.Time)
+			return
+		}
 	}
 
 	if _, err = self.muxer.bufw.Write(pkt.Data); err != nil {

format/mse/muxer.go

@@ -0,0 +1,77 @@
+package mse
+
+import (
+	"github.com/deepch/vdk/av"
+	"github.com/deepch/vdk/format/mp4f"
+	"github.com/gobwas/ws"
+	"github.com/gobwas/ws/wsutil"
+	"net"
+	"net/http"
+)
+
+var Debug bool
+
+type Muxer struct {
+	m    *mp4f.Muxer
+	r    *http.Request
+	w    http.ResponseWriter
+	conn net.Conn
+}
+
+func NewMuxer(r *http.Request, w http.ResponseWriter) (*Muxer, error) {
+	conn, _, _, err := ws.UpgradeHTTP(r, w)
+	if err != nil {
+		return nil, err
+	}
+	go func() {
+		defer func() {
+			conn.Close()
+		}()
+		for {
+			if _, _, err = wsutil.NextReader(conn, ws.StateServerSide); err != nil {
+				return
+			}
+		}
+	}()
+
+	return &Muxer{
+		conn: conn,
+		m:    mp4f.NewMuxer(nil),
+		r:    r,
+		w:    w,
+	}, nil
+}
+
+func (m *Muxer) WriteHeader(streams []av.CodecData) (err error) {
+	if err = m.m.WriteHeader(streams); err != nil {
+		return
+	}
+	meta, fist := m.m.GetInit(streams)
+	if err = wsutil.WriteServerText(m.conn, []byte(meta)); err != nil {
+		return
+	}
+	if err = wsutil.WriteServerBinary(m.conn, fist); err != nil {
+		return
+	}
+
+	return
+}
+
+func (m *Muxer) WritePacket(pkt av.Packet) (err error) {
+	gotFrame, buffer, err := m.m.WritePacket(pkt, false)
+	if err != nil {
+		return
+	}
+	if gotFrame {
+		if err = wsutil.WriteServerBinary(m.conn, buffer); err != nil {
+			return
+		}
+	}
+
+	return
+}
+
+func (m *Muxer) WriteTrailer() (err error) {
+
+	return m.conn.Close()
+}

format/nvr/muxer.go

@@ -1,59 +1,338 @@
 package nvr
 
 import (
-	"log"
-	"os"
-	"time"
-
+	"bytes"
+	"encoding/binary"
+	"encoding/gob"
+	"errors"
+	"fmt"
 	"github.com/deepch/vdk/av"
+	"github.com/deepch/vdk/codec/aacparser"
+	"github.com/deepch/vdk/codec/h264parser"
+	"github.com/deepch/vdk/format/mp4"
+	"github.com/google/uuid"
+	"github.com/moby/sys/mountinfo"
+	"github.com/shirou/gopsutil/v3/disk"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+var MIME = []byte{11, 22, 111, 222, 11, 22, 111, 222}
+var listTag = []string{"{server_id}", "{host_name}", "{host_name_short}", "{host_name_long}", "{stream_name}", "{channel_name}", "{stream_id}", "{channel_id}", "{start_year}", "{start_month}", "{start_day}", "{start_hour}", "{start_minute}", "{start_second}", "{start_millisecond}", "{start_unix_second}", "{start_unix_millisecond}", "{start_time}", "{start_pts}", "{end_year}", "{end_month}", "{end_day}", "{end_hour}", "{end_minute}", "{end_second}", "{end_millisecond}", "{start_unix_second}", "{start_unix_millisecond}", "{end_time}", "{end_pts}", "{duration_second}", "{duration_millisecond}"}
+
+const (
+	MP4 = "mp4"
+	NVR = "nvr"
 )
 
 type Muxer struct {
-	name      string
-	patch     string
-	started   bool
-	file      *os.File
-	codec     []av.CodecData
-	buffer    []*av.Packet
-	bufferDur time.Duration
-	seqDur    time.Duration
+	muxer                                                            *mp4.Muxer
+	format                                                           string
+	limit                                                            int
+	d                                                                *os.File
+	m                                                                *os.File
+	dur                                                              time.Duration
+	h                                                                int
+	gof                                                              *Gof
+	patch                                                            string
+	mpoint                                                           []string
+	start, end                                                       time.Time
+	pstart, pend                                                     time.Duration
+	started                                                          bool
+	serverID, streamName, channelName, streamID, channelID, hostname string
 }
 
-//NewMuxer func
-func NewMuxer(codec []av.CodecData, name, patch string, seqDur time.Duration) *Muxer {
-	return &Muxer{
-		codec:  codec,
-		name:   name,
-		patch:  patch,
-		seqDur: seqDur,
+type Gof struct {
+	Streams []av.CodecData
+	Packet  []av.Packet
+}
+
+type Data struct {
+	Time  int64
+	Start int64
+	Dur   int64
+}
+
+const (
+	B  = 1
+	KB = 1024 * B
+	MB = 1024 * KB
+	GB = 1024 * MB
+)
+
+func init() {
+	gob.RegisterName("nvr.Gof", Gof{})
+	gob.RegisterName("h264parser.CodecData", h264parser.CodecData{})
+	gob.RegisterName("aacparser.CodecData", aacparser.CodecData{})
+
+}
+
+func NewMuxer(serverID, streamName, channelName, streamID, channelID string, mpoint []string, patch, format string, limit int) (m *Muxer, err error) {
+	hostname, _ := os.Hostname()
+	m = &Muxer{
+		mpoint:      mpoint,
+		patch:       patch,
+		h:           -1,
+		gof:         &Gof{},
+		format:      format,
+		limit:       limit,
+		serverID:    serverID,
+		streamName:  streamName,
+		channelName: channelName,
+		streamID:    streamID,
+		channelID:   channelID,
+		hostname:    hostname,
 	}
-}
-
-//WritePacket func
-func (obj *Muxer) CodecUpdate(val []av.CodecData) {
-	obj.codec = val
-}
-
-//WritePacket func
-func (obj *Muxer) WritePacket(pkt *av.Packet) (err error) {
-	if !obj.started && pkt.IsKeyFrame {
-		obj.started = true
-	}
-	if obj.started {
-		if pkt.IsKeyFrame && obj.bufferDur >= obj.seqDur {
-			log.Println("write to drive", len(obj.buffer), obj.bufferDur)
-			obj.buffer = nil
-			obj.bufferDur = 0
-		}
-		obj.buffer = append(obj.buffer, pkt)
-		if pkt.Idx == 0 {
-			obj.bufferDur += pkt.Duration
-		}
-	}
-	return nil
-}
-
-//Close func
-func (obj *Muxer) Close() {
+	return
+}
+
+func (m *Muxer) WriteHeader(streams []av.CodecData) (err error) {
+	m.gof.Streams = streams
+	if m.format == MP4 {
+		return m.OpenMP4()
+	}
+
+	return
+}
+
+func (m *Muxer) WritePacket(pkt av.Packet) (err error) {
+	if len(m.gof.Streams) == 0 {
+		return
+	}
+	if !m.started && pkt.IsKeyFrame {
+		m.started = true
+	}
+	if m.started {
+		switch m.format {
+		case MP4:
+			return m.writePacketMP4(pkt)
+		case NVR:
+			return m.writePacketNVR(pkt)
+		}
+	}
+
+	return
+}
+
+func (m *Muxer) writePacketMP4(pkt av.Packet) (err error) {
+	if pkt.IsKeyFrame && m.dur > time.Duration(m.limit)*time.Second {
+		m.pstart = pkt.Time
+		if err = m.OpenMP4(); err != nil {
+			return
+		}
+		m.dur = 0
+
+	}
+	m.dur += pkt.Duration
+	m.pend = pkt.Time
+
+	return m.muxer.WritePacket(pkt)
+}
+
+func (m *Muxer) writePacketNVR(pkt av.Packet) (err error) {
+	if pkt.IsKeyFrame {
+		if len(m.gof.Packet) > 0 {
+			if err = m.writeGop(); err != nil {
+				return
+			}
+		}
+		m.gof.Packet, m.dur = nil, 0
+	}
+	if pkt.Idx == 0 {
+		m.dur += pkt.Duration
+	}
+	m.gof.Packet = append(m.gof.Packet, pkt)
+
+	return
+}
+
+func (m *Muxer) writeGop() (err error) {
+	t := time.Now().UTC()
+	if m.h != t.Hour() {
+		if err = m.OpenNVR(); err != nil {
+			return
+		}
+	}
+	f := Data{
+		Time: t.UnixNano(),
+		Dur:  m.dur.Milliseconds(),
+	}
+	if f.Start, err = m.d.Seek(0, 2); err != nil {
+		return
+	}
+	enc := gob.NewEncoder(m.d)
+	if err = enc.Encode(m.gof); err != nil {
+		return
+	}
+	buf := bytes.NewBuffer([]byte{})
+	if err = binary.Write(buf, binary.LittleEndian, f); err != nil {
+		return
+	}
+	if _, err = buf.Write(MIME); err != nil {
+		return
+	}
+	_, err = m.m.Write(buf.Bytes())
+
+	return
+}
+
+func (m *Muxer) OpenNVR() (err error) {
+	m.WriteTrailer()
+	t := time.Now().UTC()
+	if err = os.MkdirAll(fmt.Sprintf("%s/%s", m.patch, t.Format("2006/01/02")), 0755); err != nil {
+		return
+	}
+	if m.d, err = os.OpenFile(fmt.Sprintf("%s/%s/%d.d", m.patch, t.Format("2006/01/02"), t.Hour()), os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0660); err != nil {
+		return
+	}
+	if m.m, err = os.OpenFile(fmt.Sprintf("%s/%s/%d.m", m.patch, t.Format("2006/01/02"), t.Hour()), os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0660); err != nil {
+		return
+	}
+	m.h = t.Hour()
+
+	return
+}
+
+func (m *Muxer) OpenMP4() (err error) {
+	m.WriteTrailer()
+	m.start = time.Now().UTC()
+
+	d, err := m.filePatch()
+	if err != nil {
+		return
+	}
+	if err = os.MkdirAll(filepath.Dir(d), 0755); err != nil {
+		return
+	}
+	if m.d, err = os.Create(filepath.Join(filepath.Dir(d), fmt.Sprintf("tmp_%s_%d.mp4", uuid.New(), time.Now().Unix()))); err != nil {
+		return
+	}
+	m.muxer = mp4.NewMuxer(m.d)
+	m.muxer.NegativeTsMakeZero = true
+	if err = m.muxer.WriteHeader(m.gof.Streams); err != nil {
+		return
+	}
+
+	return
+}
+
+func (m *Muxer) filePatch() (string, error) {
+	var (
+		mu = float64(100)
+		ui = -1
+	)
+
+	for i, i2 := range m.mpoint {
+		if m, err := mountinfo.Mounted(i2); err == nil && m {
+			if d, err := disk.Usage(i2); err == nil {
+				if d.UsedPercent < mu {
+					ui = i
+					mu = d.UsedPercent
+				}
+			}
+		}
+	}
+
+	if ui == -1 {
+		return "", errors.New("not mount ready")
+	}
+
+	ts := filepath.Join(m.mpoint[ui], m.patch)
+	m.end = time.Now().UTC()
+
+	for _, s := range listTag {
+		switch s {
+		case "{server_id}":
+			ts = strings.Replace(ts, "{server_id}", m.serverID, -1)
+		case "{host_name}":
+			ts = strings.Replace(ts, "{host_name}", m.hostname, -1)
+		case "{host_name_short}":
+			ts = strings.Replace(ts, "{host_name_short}", m.hostname, -1)
+		case "{host_name_long}":
+			ts = strings.Replace(ts, "{host_name_long}", m.hostname, -1)
+		case "{stream_name}":
+			ts = strings.Replace(ts, "{stream_name}", m.streamName, -1)
+		case "{channel_name}":
+			ts = strings.Replace(ts, "{channel_name}", m.channelName, -1)
+		case "{stream_id}":
+			ts = strings.Replace(ts, "{stream_id}", m.streamID, -1)
+		case "{channel_id}":
+			ts = strings.Replace(ts, "{channel_id}", m.channelID, -1)
+		case "{start_year}":
+			ts = strings.Replace(ts, "{start_year}", fmt.Sprintf("%d", m.start.Year()), -1)
+		case "{start_month}":
+			ts = strings.Replace(ts, "{start_month}", fmt.Sprintf("%d", int(m.start.Month())), -1)
+		case "{start_day}":
+			ts = strings.Replace(ts, "{start_day}", fmt.Sprintf("%d", m.start.Day()), -1)
+		case "{start_hour}":
+			ts = strings.Replace(ts, "{start_hour}", fmt.Sprintf("%d", m.start.Hour()), -1)
+		case "{start_minute}":
+			ts = strings.Replace(ts, "{start_minute}", fmt.Sprintf("%d", m.start.Minute()), -1)
+		case "{start_second}":
+			ts = strings.Replace(ts, "{start_second}", fmt.Sprintf("%d", m.start.Second()), -1)
+		case "{start_millisecond}":
+			ts = strings.Replace(ts, "{start_millisecond}", fmt.Sprintf("%d", m.start.Nanosecond()/1000/1000), -1)
+		case "{start_unix_millisecond}":
+			ts = strings.Replace(ts, "{start_unix_millisecond}", fmt.Sprintf("%d", m.end.UnixMilli()), -1)
+		case "{start_unix_second}":
+			ts = strings.Replace(ts, "{start_unix_second}", fmt.Sprintf("%d", m.end.Unix()), -1)
+		case "{start_time}":
+			ts = strings.Replace(ts, "{start_time}", fmt.Sprintf("%s", m.start.Format("2006-01-02T15:04:05-0700")), -1)
+		case "{start_pts}":
+			ts = strings.Replace(ts, "{start_pts}", fmt.Sprintf("%d", m.pstart.Milliseconds()), -1)
+		case "{end_year}":
+			ts = strings.Replace(ts, "{end_year}", fmt.Sprintf("%d", m.end.Year()), -1)
+		case "{end_month}":
+			ts = strings.Replace(ts, "{end_month}", fmt.Sprintf("%d", int(m.end.Month())), -1)
+		case "{end_day}":
+			ts = strings.Replace(ts, "{end_day}", fmt.Sprintf("%d", m.end.Day()), -1)
+		case "{end_hour}":
+			ts = strings.Replace(ts, "{end_hour}", fmt.Sprintf("%d", m.end.Hour()), -1)
+		case "{end_minute}":
+			ts = strings.Replace(ts, "{end_minute}", fmt.Sprintf("%d", m.end.Minute()), -1)
+		case "{end_second}":
+			ts = strings.Replace(ts, "{end_second}", fmt.Sprintf("%d", m.end.Second()), -1)
+		case "{end_millisecond}":
+			ts = strings.Replace(ts, "{end_millisecond}", fmt.Sprintf("%d", m.start.Nanosecond()/1000/1000), -1)
+		case "{end_unix_millisecond}":
+			ts = strings.Replace(ts, "{end_unix_millisecond}", fmt.Sprintf("%d", m.end.UnixMilli()), -1)
+		case "{end_unix_second}":
+			ts = strings.Replace(ts, "{end_unix_second}", fmt.Sprintf("%d", m.end.Unix()), -1)
+		case "{end_time}":
+			ts = strings.Replace(ts, "{end_time}", fmt.Sprintf("%s", m.end.Format("2006-01-02T15:04:05-0700")), -1)
+		case "{end_pts}":
+			ts = strings.Replace(ts, "{end_pts}", fmt.Sprintf("%d", m.pend.Milliseconds()), -1)
+		case "{duration_second}":
+			ts = strings.Replace(ts, "{duration_second}", fmt.Sprintf("%f", m.dur.Seconds()), -1)
+		case "{duration_millisecond}":
+			ts = strings.Replace(ts, "{duration_millisecond}", fmt.Sprintf("%d", m.dur.Milliseconds()), -1)
+		}
+	}
+
+	return ts, nil
+}
+
+func (m *Muxer) WriteTrailer() (err error) {
+	if m.muxer != nil {
+		m.muxer.WriteTrailer()
+	}
+	if m.m != nil {
+		err = m.m.Close()
+	}
+	if m.d != nil {
+		if m.format == MP4 {
+			p, err := m.filePatch()
+			if err != nil {
+				return err
+			}
+			if err = os.Rename(m.d.Name(), filepath.Join(filepath.Dir(m.d.Name()), filepath.Base(p))); err != nil {
+				return err
+			}
+		}
+		err = m.d.Close()
+	}
+
 	return
 }

format/nvr/streams.go

@@ -0,0 +1,8 @@
+package nvr
+
+import "github.com/deepch/vdk/av"
+
+type Stream struct {
+	codec av.CodecData
+	idx   int
+}

format/rtmp/rtmp.go

@@ -258,7 +258,10 @@ func (self *Conn) RxBytes() uint64 {
 }
 
 func (self *Conn) Close() (err error) {
-	return self.netconn.Close()
+	if self.netconn != nil {
+		return self.netconn.Close()
+	}
+	return
 }
 
 func (self *Conn) pollCommand() (err error) {
@@ -1623,20 +1626,15 @@ func (self *Conn) handshakeServer() (err error) {
 	clitime := pio.U32BE(C1[0:4])
 	srvtime := clitime
 	srvver := uint32(0x0d0e0a0d)
-	cliver := pio.U32BE(C1[4:8])
 
-	if cliver != 0 {
-		var ok bool
-		var digest []byte
-		if ok, digest = hsParse1(C1, hsClientPartialKey, hsServerFullKey); !ok {
-			err = fmt.Errorf("rtmp: handshake server: C1 invalid")
-			return
-		}
+	var ok bool
+	var digest []byte
+	if ok, digest = hsParse1(C1, hsClientPartialKey, hsServerFullKey); ok {
 		hsCreate01(S0S1, srvtime, srvver, hsServerPartialKey)
 		hsCreate2(S2, digest)
 	} else {
-		copy(S1, C1)
-		copy(S2, C2)
+		copy(S1, C2)
+		copy(S2, C1)
 	}
 
 	if _, err = self.bufw.Write(S0S1S2); err != nil {

format/rtsp/client.go

@@ -9,7 +9,6 @@ import (
 	"encoding/hex"
 	"fmt"
 	"io"
-	//"log"
 	"net"
 	"net/textproto"
 	"net/url"
@@ -41,9 +40,10 @@ const (
 )
 
 type Client struct {
-	DebugRtsp bool
-	DebugRtp  bool
-	Headers   []string
+	DebugRtsp    bool
+	DebugRtp     bool
+	DisableAudio bool
+	Headers      []string
 
 	SkipErrRtpBlock bool
 
@@ -147,7 +147,12 @@ func (self *Client) probe() (err error) {
 }
 
 func (self *Client) prepare(stage int) (err error) {
+	var waitIdle int
 	for self.stage < stage {
+		waitIdle++
+		if waitIdle > 20 {
+			return fmt.Errorf("codec not ready")
+		}
 		switch self.stage {
 		case 0:
 			if err = self.Options(); err != nil {
@@ -695,7 +700,9 @@ func (self *Client) Describe() (streams []sdp.Media, err error) {
 	self.streams = []*Stream{}
 	for _, media := range medias {
 		stream := &Stream{Sdp: media, client: self}
-		stream.makeCodecData()
+		if err = stream.makeCodecData(); err != nil && DebugRtsp {
+			fmt.Println("rtsp: makeCodecData error", err)
+		}
 		self.streams = append(self.streams, stream)
 		streams = append(streams, media)
 	}
@@ -767,7 +774,7 @@ func (self *Stream) timeScale() int {
 
 func (self *Stream) makeCodecData() (err error) {
 	media := self.Sdp
-	if media.PayloadType >= 96 && media.PayloadType <= 127 {
+	if (media.PayloadType >= 96 && media.PayloadType <= 127) || media.Type == av.H264 || media.Type == av.AAC {
 		switch media.Type {
 		case av.H264:
 			for _, nalu := range media.SpropParameterSets {
@@ -1070,12 +1077,44 @@ func (self *Stream) handleRtpPacket(packet []byte) (err error) {
 		err = fmt.Errorf("rtp: packet too short")
 		return
 	}
-	payloadOffset := 12 + int(packet[0]&0xf)*4
+
+	timestamp := binary.BigEndian.Uint32(packet[4:8])
+
+	/*
+		Test offset
+	*/
+	Padding := (packet[0]>>5)&1 == 1
+	Extension := (packet[0]>>4)&1 == 1
+	CSRCCnt := int(packet[0] & 0x0f)
+
+	RTPHeaderSize := 12
+
+	payloadOffset := RTPHeaderSize
+	end := len(packet)
+	if end-payloadOffset >= 4*CSRCCnt {
+		payloadOffset += 4 * CSRCCnt
+	}
+
+	if Extension && end-payloadOffset >= 4 {
+		extLen := 4 * int(binary.BigEndian.Uint16(packet[payloadOffset+2:]))
+		payloadOffset += 4
+		if end-payloadOffset >= extLen {
+			payloadOffset += extLen
+		}
+	}
+
+	if Padding && end-payloadOffset > 0 {
+		paddingLen := int(packet[end-1])
+		if end-payloadOffset >= paddingLen {
+			end -= paddingLen
+		}
+	}
+
 	if payloadOffset > len(packet) {
 		err = fmt.Errorf("rtp: packet too short")
 		return
 	}
-	timestamp := binary.BigEndian.Uint32(packet[4:8])
+
 	payload := packet[payloadOffset:]
 
 	/*

format/rtsp/server.go

@@ -0,0 +1 @@
+package rtsp

format/rtspv2/client.go

@@ -150,9 +150,12 @@ func Dial(options RTSPClientOptions) (*RTSPClient, error) {
 	if err != nil {
 		return nil, err
 	}
-
 	for _, i2 := range client.mediaSDP {
 		if (i2.AVType != VIDEO && i2.AVType != AUDIO) || (client.options.DisableAudio && i2.AVType == AUDIO) {
+			//TODO check it
+			if strings.Contains(string(client.SDPRaw), "LaunchDigital") {
+				client.chTMP += 2
+			}
 			continue
 		}
 		err = client.request(SETUP, map[string]string{"Transport": "RTP/AVP/TCP;unicast;interleaved=" + strconv.Itoa(client.chTMP) + "-" + strconv.Itoa(client.chTMP+1)}, client.ControlTrack(i2.Control), false, false)
@@ -589,6 +592,9 @@ func (client *RTSPClient) RTPDemuxer(payloadRAW *[]byte) ([]*av.Packet, bool) {
 		}
 	}
 	offset += 4
+	if len(content) < end {
+		return nil, false
+	}
 	switch int(content[1]) {
 	case client.videoID:
 		if client.PreVideoTS == 0 {
@@ -747,7 +753,7 @@ func (client *RTSPClient) RTPDemuxer(payloadRAW *[]byte) ([]*av.Packet, bool) {
 						}
 					}
 				default:
-					client.Println("Unsupported NAL Type", naluType)
+					//client.Println("Unsupported NAL Type", naluType)
 				}
 			}
 		}
@@ -945,14 +951,14 @@ func (client *RTSPClient) CodecUpdateVPS(val []byte) {
 
 }
 
-//Println mini logging functions
+// Println mini logging functions
 func (client *RTSPClient) Println(v ...interface{}) {
 	if client.options.Debug {
 		log.Println(v)
 	}
 }
 
-//binSize
+// binSize
 func binSize(val int) []byte {
 	buf := make([]byte, 4)
 	binary.BigEndian.PutUint32(buf, uint32(val))

format/rtspv2/proxy.go

@@ -25,6 +25,7 @@ type ProxyConn struct {
 	cseq     int
 	session  string
 	protocol int
+	in       int
 }
 
 type Proxy struct {
@@ -40,7 +41,6 @@ func NewProxyConn(netconn net.Conn) *ProxyConn {
 	conn.writebuf = make([]byte, 4096)
 	conn.readbuf = make([]byte, 4096)
 	conn.session = uuid.New().String()
-	conn.cseq = 1
 	return conn
 }
 
@@ -156,6 +156,7 @@ func (self *ProxyConn) prepare() error {
 		return errors.New("no fist cmd")
 	}
 
+	cseq := strings.TrimSpace(stringInBetween(string(self.readbuf[:n]), "CSeq:", "\r\n"))
 	switch fistStringsSlice[0] {
 	case OPTIONS:
 
@@ -165,45 +166,46 @@ func (self *ProxyConn) prepare() error {
 		if self.URL, err = url.Parse(fistStringsSlice[1]); err != nil {
 			return err
 		}
-		_, err := self.netconn.Write([]byte("RTSP/1.0 200 OK\r\nPublic: OPTIONS, DESCRIBE, SETUP, PLAY\r\nSession: " + self.session + "\r\nCSeq: " + strconv.Itoa(self.cseq) + "\r\n\r\n"))
+		_, err := self.netconn.Write([]byte("RTSP/1.0 200 OK\r\nPublic: OPTIONS, DESCRIBE, SETUP, PLAY\r\nSession: " + self.session + "\r\nCSeq: " + cseq + "\r\n\r\n"))
 		if err != nil {
 			return err
 		}
 		self.options = true
 
 	case SETUP:
-
 		if strings.Contains(string(self.readbuf[:n]), "RTP/AVP/UDP") {
-			_, err := self.netconn.Write([]byte("RTSP/1.0 461 Unsupported transport\r\nCSeq: " + strconv.Itoa(self.cseq) + "\r\nSession: " + self.session + "\r\n\r\n"))
+			_, err := self.netconn.Write([]byte("RTSP/1.0 461 Unsupported transport\r\nCSeq: " + cseq + "\r\nSession: " + self.session + "\r\n\r\n"))
 			if err != nil {
 				return err
 			}
 			return nil
 		}
-		_, err := self.netconn.Write([]byte("RTSP/1.0 200 OK\r\nCSeq: " + strconv.Itoa(self.cseq) + "\r\nSession: " + self.session + "\r\nTransport: RTP/AVP/TCP;unicast;interleaved=0-1\r\n\r\n"))
+		_, err := self.netconn.Write([]byte("RTSP/1.0 200 OK\r\nCSeq: " + cseq + "\r\nSession: " + self.session + "\r\nTransport: RTP/AVP/TCP;unicast;interleaved=" + strconv.Itoa(self.in) + "-" + strconv.Itoa(self.in+1) + "\r\n\r\n"))
 		if err != nil {
 			return err
 		}
-
+		self.in = self.in + 2
 	case DESCRIBE:
 
-		buf := "RTSP/1.0 200 OK\r\nContent-Type: application/sdp\r\nSession: " + self.session + "\r\nContent-Length: " + strconv.Itoa(len(self.sdp)) + "\r\nCSeq: " + strconv.Itoa(self.cseq) + "\r\n\r\n"
+		buf := "RTSP/1.0 200 OK\r\nContent-Type: application/sdp\r\nSession: " + self.session + "\r\nContent-Length: " + strconv.Itoa(len(self.sdp)) + "\r\nCSeq: " + cseq + "\r\n\r\n"
 		_, err := self.netconn.Write([]byte(buf + string(self.sdp)))
 		if err != nil {
 			return err
 		}
 
 	case PLAY:
-
-		_, err := self.netconn.Write([]byte("RTSP/1.0 200 OK\r\nSession: " + self.session + ";timeout=60\r\nCSeq: " + strconv.Itoa(self.cseq) + "\r\n\r\n"))
+		_, err := self.netconn.Write([]byte("RTSP/1.0 200 OK\r\nSession: " + self.session + ";timeout=60\r\nCSeq: " + cseq + "\r\n\r\n"))
 		if err != nil {
 			return err
 		}
 		self.playing = true
+	case TEARDOWN:
+		self.netconn.Close()
+		return errors.New("exit")
 
 	default:
 
-		return errors.New("metod not found")
+		return errors.New("metod not found " + fistStringsSlice[0])
 
 	}
 	return nil

format/ts/demuxer.go

@@ -284,7 +284,11 @@ func (self *Stream) payloadEnd() (n int, err error) {
 						b := make([]byte, 4+len(nalu))
 						pio.PutU32BE(b[0:4], uint32(len(nalu)))
 						copy(b[4:], nalu)
-						self.addPacket(b, time.Duration(0), (1000*time.Millisecond)/time.Duration(self.fps))
+						fps := self.fps
+						if self.fps == 0 {
+							fps = 25
+						}
+						self.addPacket(b, time.Duration(0), (1000*time.Millisecond)/time.Duration(fps))
 						n++
 					}
 				}

format/ts/muxer.go

@@ -2,6 +2,7 @@ package ts
 
 import (
 	"fmt"
+	"github.com/deepch/vdk/codec/h265parser"
 	"io"
 	"time"
 
@@ -11,7 +12,7 @@ import (
 	"github.com/deepch/vdk/format/ts/tsio"
 )
 
-var CodecTypes = []av.CodecType{av.H264, av.AAC}
+var CodecTypes = []av.CodecType{av.H264, av.H265, av.AAC}
 
 type Muxer struct {
 	w       io.Writer
@@ -123,6 +124,11 @@ func (self *Muxer) WritePATPMT() (err error) {
 				StreamType:    tsio.ElementaryStreamTypeH264,
 				ElementaryPID: stream.pid,
 			})
+		case av.H265:
+			elemStreams = append(elemStreams, tsio.ElementaryStreamInfo{
+				StreamType:    tsio.ElementaryStreamTypeH265,
+				ElementaryPID: stream.pid,
+			})
 		}
 	}
 
@@ -210,6 +216,36 @@ func (self *Muxer) WritePacket(pkt av.Packet) (err error) {
 		n := tsio.FillPESHeader(self.peshdr, tsio.StreamIdH264, -1, pkt.Time+pkt.CompositionTime, pkt.Time)
 		datav[0] = self.peshdr[:n]
 
+		if err = stream.tsw.WritePackets(self.w, datav, pkt.Time, pkt.IsKeyFrame, false); err != nil {
+			return
+		}
+	case av.H265:
+		codec := stream.CodecData.(h265parser.CodecData)
+
+		nalus := self.nalus[:0]
+		if pkt.IsKeyFrame {
+			nalus = append(nalus, codec.SPS())
+			nalus = append(nalus, codec.PPS())
+			nalus = append(nalus, codec.VPS())
+		}
+		pktnalus, _ := h265parser.SplitNALUs(pkt.Data)
+		for _, nalu := range pktnalus {
+			nalus = append(nalus, nalu)
+		}
+
+		datav := self.datav[:1]
+		for i, nalu := range nalus {
+			if i == 0 {
+				datav = append(datav, h265parser.AUDBytes)
+			} else {
+				datav = append(datav, h265parser.StartCodeBytes)
+			}
+			datav = append(datav, nalu)
+		}
+
+		n := tsio.FillPESHeader(self.peshdr, tsio.StreamIdH264, -1, pkt.Time+pkt.CompositionTime, pkt.Time)
+		datav[0] = self.peshdr[:n]
+
 		if err = stream.tsw.WritePackets(self.w, datav, pkt.Time, pkt.IsKeyFrame, false); err != nil {
 			return
 		}

format/ts/tsio/tsio.go

@@ -36,6 +36,7 @@ const (
 	ElementaryStreamTypeH264                = 0x1B
 	ElementaryStreamTypeAdtsAAC             = 0x0F
 	ElementaryStreamTypeAlignmentDescriptor = 0x06
+	ElementaryStreamTypeH265                = 0x24
 )
 
 type PATEntry struct {
@@ -516,7 +517,7 @@ func NewTSWriter(pid uint16) *TSWriter {
 	return w
 }
 
-//TSHeader func
+// TSHeader func
 type TSHeader struct {
 	PID                    uint
 	PCR                    uint64
@@ -528,7 +529,7 @@ type TSHeader struct {
 	HeaderLength           uint
 }
 
-//WriteTSHeader func
+// WriteTSHeader func
 func WriteTSHeader(w io.Writer, element TSHeader, dataLength int) (written int, err error) {
 	var flags, extFlags uint
 
@@ -688,13 +689,13 @@ func makeRepeatValBytes(val byte, n int) []byte {
 	return b
 }
 
-//WriteRepeatVal func
+// WriteRepeatVal func
 func WriteRepeatVal(w io.Writer, val byte, n int) (err error) {
 	_, err = w.Write(makeRepeatValBytes(val, n))
 	return
 }
 
-//WriteUInt64 func
+// WriteUInt64 func
 func WriteUInt64(w io.Writer, val uint64, n int) (err error) {
 	var b [8]byte
 	for i := n - 1; i >= 0; i-- {
@@ -707,12 +708,12 @@ func WriteUInt64(w io.Writer, val uint64, n int) (err error) {
 	return
 }
 
-//WriteUInt func
+// WriteUInt func
 func WriteUInt(w io.Writer, val uint, n int) (err error) {
 	return WriteUInt64(w, uint64(val), n)
 }
 
-//PCRToUInt func
+// PCRToUInt func
 func PCRToUInt(pcr uint64) uint64 {
 	base := pcr / 300
 	ext := pcr % 300

go.mod

@@ -4,14 +4,18 @@ go 1.18
 
 require (
 	github.com/google/uuid v1.3.0
-	github.com/pion/interceptor v0.1.12
+	github.com/pion/interceptor v0.1.17
 	github.com/pion/webrtc/v2 v2.2.26
-	github.com/pion/webrtc/v3 v3.1.58
+	github.com/pion/webrtc/v3 v3.2.12
 )
 
 require (
 	github.com/cheekybits/genny v1.0.0 // indirect
+	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0 // indirect
+	github.com/gobwas/httphead v0.1.0 // indirect
+	github.com/gobwas/pool v0.2.1 // indirect
+	github.com/gobwas/ws v1.3.1 // indirect
 	github.com/golang/mock v1.6.0 // indirect
 	github.com/google/pprof v0.0.0-20230309165930-d61513b1440d // indirect
 	github.com/lucas-clemente/quic-go v0.31.1 // indirect
@@ -20,30 +24,34 @@ require (
 	github.com/marten-seemann/qtls-go1-19 v0.1.2 // indirect
 	github.com/onsi/ginkgo/v2 v2.9.0 // indirect
 	github.com/pion/datachannel v1.5.5 // indirect
-	github.com/pion/dtls/v2 v2.2.6 // indirect
+	github.com/pion/dtls/v2 v2.2.7 // indirect
 	github.com/pion/ice v0.7.18 // indirect
-	github.com/pion/ice/v2 v2.3.1 // indirect
+	github.com/pion/ice/v2 v2.3.9 // indirect
 	github.com/pion/logging v0.2.2 // indirect
 	github.com/pion/mdns v0.0.7 // indirect
 	github.com/pion/quic v0.1.4 // indirect
 	github.com/pion/randutil v0.1.0 // indirect
 	github.com/pion/rtcp v1.2.10 // indirect
 	github.com/pion/rtp v1.7.13 // indirect
-	github.com/pion/sctp v1.8.6 // indirect
+	github.com/pion/sctp v1.8.7 // indirect
 	github.com/pion/sdp/v2 v2.4.0 // indirect
 	github.com/pion/sdp/v3 v3.0.6 // indirect
 	github.com/pion/srtp v1.5.2 // indirect
-	github.com/pion/srtp/v2 v2.0.12 // indirect
-	github.com/pion/stun v0.4.0 // indirect
+	github.com/pion/srtp/v2 v2.0.15 // indirect
+	github.com/pion/stun v0.6.1 // indirect
 	github.com/pion/transport v0.14.1 // indirect
-	github.com/pion/transport/v2 v2.0.2 // indirect
-	github.com/pion/turn/v2 v2.1.0 // indirect
+	github.com/pion/transport/v2 v2.2.1 // indirect
+	github.com/pion/turn/v2 v2.1.2 // indirect
 	github.com/pion/udp v0.1.4 // indirect
 	github.com/pion/udp/v2 v2.0.1 // indirect
-	golang.org/x/crypto v0.7.0 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/stretchr/testify v1.8.4 // indirect
+	github.com/tejasmanohar/timerange-go v1.0.0 // indirect
+	golang.org/x/crypto v0.10.0 // indirect
 	golang.org/x/exp v0.0.0-20230310171629-522b1b587ee0 // indirect
 	golang.org/x/mod v0.9.0 // indirect
-	golang.org/x/net v0.8.0 // indirect
-	golang.org/x/sys v0.6.0 // indirect
+	golang.org/x/net v0.11.0 // indirect
+	golang.org/x/sys v0.9.0 // indirect
 	golang.org/x/tools v0.7.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -30,6 +30,12 @@ github.com/gliderlabs/ssh v0.1.1/go.mod h1:U7qILu1NlMHj9FlMhZLlkCdDnU1DBEAqr0aev
 github.com/go-errors/errors v1.0.1/go.mod h1:f4zRHt4oKfwPJE5k8C9vpYG+aDHdBFUsgrm6/TyX73Q=
 github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0 h1:p104kn46Q8WdvHunIJ9dAyjPVtrBPhSr3KT2yUst43I=
 github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE=
+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.3.1 h1:Qi34dfLMWJbiKaNbDVzM9x27nZBjmkaW6i4+Ku+pGVU=
+github.com/gobwas/ws v1.3.1/go.mod h1:hRKAFb8wOxFROYNsT1bqfWnhX+b5MFeJM9r2ZSwg/KY=
 github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
 github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
 github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
@@ -135,16 +141,22 @@ github.com/pion/dtls/v2 v2.1.5 h1:jlh2vtIyUBShchoTDqpCCqiYCyRFJ/lvf/gQ8TALs+c=
 github.com/pion/dtls/v2 v2.1.5/go.mod h1:BqCE7xPZbPSubGasRoDFJeTsyJtdD1FanJYL0JGheqY=
 github.com/pion/dtls/v2 v2.2.6 h1:yXMxKr0Skd+Ub6A8UqXTRLSywskx93ooMRHsQUtd+Z4=
 github.com/pion/dtls/v2 v2.2.6/go.mod h1:t8fWJCIquY5rlQZwA2yWxUS1+OCrAdXrhVKXB5oD/wY=
+github.com/pion/dtls/v2 v2.2.7 h1:cSUBsETxepsCSFSxC3mc/aDo14qQLMSL+O6IjG28yV8=
+github.com/pion/dtls/v2 v2.2.7/go.mod h1:8WiMkebSHFD0T+dIU+UeBaoV7kDhOW5oDCzZ7WZ/F9s=
 github.com/pion/ice v0.7.18 h1:KbAWlzWRUdX9SmehBh3gYpIFsirjhSQsCw6K2MjYMK0=
 github.com/pion/ice v0.7.18/go.mod h1:+Bvnm3nYC6Nnp7VV6glUkuOfToB/AtMRZpOU8ihuf4c=
 github.com/pion/ice/v2 v2.2.6 h1:R/vaLlI1J2gCx141L5PEwtuGAGcyS6e7E0hDeJFq5Ig=
 github.com/pion/ice/v2 v2.2.6/go.mod h1:SWuHiOGP17lGromHTFadUe1EuPgFh/oCU6FCMZHooVE=
 github.com/pion/ice/v2 v2.3.1 h1:FQCmUfZe2Jpe7LYStVBOP6z1DiSzbIateih3TztgTjc=
 github.com/pion/ice/v2 v2.3.1/go.mod h1:aq2kc6MtYNcn4XmMhobAv6hTNJiHzvD0yXRz80+bnP8=
+github.com/pion/ice/v2 v2.3.9 h1:7yZpHf3PhPxJGT4JkMj1Y8Rl5cQ6fB709iz99aeMd/U=
+github.com/pion/ice/v2 v2.3.9/go.mod h1:lT3kv5uUIlHfXHU/ZRD7uKD/ufM202+eTa3C/umgGf4=
 github.com/pion/interceptor v0.1.11 h1:00U6OlqxA3FFB50HSg25J/8cWi7P6FbSzw4eFn24Bvs=
 github.com/pion/interceptor v0.1.11/go.mod h1:tbtKjZY14awXd7Bq0mmWvgtHB5MDaRN7HV3OZ/uy7s8=
 github.com/pion/interceptor v0.1.12 h1:CslaNriCFUItiXS5o+hh5lpL0t0ytQkFnUcbbCs2Zq8=
 github.com/pion/interceptor v0.1.12/go.mod h1:bDtgAD9dRkBZpWHGKaoKb42FhDHTG2rX8Ii9LRALLVA=
+github.com/pion/interceptor v0.1.17 h1:prJtgwFh/gB8zMqGZoOgJPHivOwVAp61i2aG61Du/1w=
+github.com/pion/interceptor v0.1.17/go.mod h1:SY8kpmfVBvrbUzvj2bsXz7OJt5JvmVNZ+4Kjq7FcwrI=
 github.com/pion/logging v0.2.2 h1:M9+AIj/+pxNsDfAT64+MAVgJO0rsyLnoJKCqf//DoeY=
 github.com/pion/logging v0.2.2/go.mod h1:k0/tDVsRCX2Mb2ZEmTqNa7CWsQPc+YYCB7Q+5pahoms=
 github.com/pion/mdns v0.0.4/go.mod h1:R1sL0p50l42S5lJs91oNdUL58nm0QHrhxnSegr++qC0=
@@ -176,6 +188,8 @@ github.com/pion/sctp v1.8.2/go.mod h1:xFe9cLMZ5Vj6eOzpyiKjT9SwGM4KpK/8Jbw5//jc+0
 github.com/pion/sctp v1.8.5/go.mod h1:SUFFfDpViyKejTAdwD1d/HQsCu+V/40cCs2nZIvC3s0=
 github.com/pion/sctp v1.8.6 h1:CUex11Vkt9YS++VhLf8b55O3VqKrWL6W3SDwX4jAqsI=
 github.com/pion/sctp v1.8.6/go.mod h1:SUFFfDpViyKejTAdwD1d/HQsCu+V/40cCs2nZIvC3s0=
+github.com/pion/sctp v1.8.7 h1:JnABvFakZueGAn4KU/4PSKg+GWbF6QWbKTWZOSGJjXw=
+github.com/pion/sctp v1.8.7/go.mod h1:g1Ul+ARqZq5JEmoFy87Q/4CePtKnTJ1QCL9dBBdN6AU=
 github.com/pion/sdp/v2 v2.4.0 h1:luUtaETR5x2KNNpvEMv/r4Y+/kzImzbz4Lm1z8eQNQI=
 github.com/pion/sdp/v2 v2.4.0/go.mod h1:L2LxrOpSTJbAns244vfPChbciR/ReU1KWfG04OpkR7E=
 github.com/pion/sdp/v3 v3.0.5 h1:ouvI7IgGl+V4CrqskVtr3AaTrPvPisEOxwgpdktctkU=
@@ -190,10 +204,14 @@ github.com/pion/srtp/v2 v2.0.9 h1:JJq3jClmDFBPX/F5roEb0U19jSU7eUhyDqR/NZ34EKQ=
 github.com/pion/srtp/v2 v2.0.9/go.mod h1:5TtM9yw6lsH0ppNCehB/EjEUli7VkUgKSPJqWVqbhQ4=
 github.com/pion/srtp/v2 v2.0.12 h1:WrmiVCubGMOAObBU1vwWjG0H3VSyQHawKeer2PVA5rY=
 github.com/pion/srtp/v2 v2.0.12/go.mod h1:C3Ep44hlOo2qEYaq4ddsmK5dL63eLehXFbHaZ9F5V9Y=
+github.com/pion/srtp/v2 v2.0.15 h1:+tqRtXGsGwHC0G0IUIAzRmdkHvriF79IHVfZGfHrQoA=
+github.com/pion/srtp/v2 v2.0.15/go.mod h1:b/pQOlDrbB0HEH5EUAQXzSYxikFbNcNuKmF8tM0hCtw=
 github.com/pion/stun v0.3.5 h1:uLUCBCkQby4S1cf6CGuR9QrVOKcvUwFeemaC865QHDg=
 github.com/pion/stun v0.3.5/go.mod h1:gDMim+47EeEtfWogA37n6qXZS88L5V6LqFcf+DZA2UA=
 github.com/pion/stun v0.4.0 h1:vgRrbBE2htWHy7l3Zsxckk7rkjnjOsSM7PHZnBwo8rk=
 github.com/pion/stun v0.4.0/go.mod h1:QPsh1/SbXASntw3zkkrIk3ZJVKz4saBY2G7S10P3wCw=
+github.com/pion/stun v0.6.1 h1:8lp6YejULeHBF8NmV8e2787BogQhduZugh5PdhDyyN4=
+github.com/pion/stun v0.6.1/go.mod h1:/hO7APkX4hZKu/D0f2lHzNyvdkTGtIy3NDmLR7kSz/8=
 github.com/pion/transport v0.6.0/go.mod h1:iWZ07doqOosSLMhZ+FXUTq+TamDoXSllxpbGcfkCmbE=
 github.com/pion/transport v0.8.10/go.mod h1:tBmha/UCjpum5hqTWhfAEs3CO4/tHSg0MYRhSzR+CZ8=
 github.com/pion/transport v0.10.0/go.mod h1:BnHnUipd0rZQyTVB2SBGojFHT9CBt5C5TcsJSQGkvSE=
@@ -208,11 +226,17 @@ github.com/pion/transport v0.14.1/go.mod h1:4tGmbk00NeYA3rUa9+n+dzCCoKkcy3YlYb99
 github.com/pion/transport/v2 v2.0.0/go.mod h1:HS2MEBJTwD+1ZI2eSXSvHJx/HnzQqRy2/LXxt6eVMHc=
 github.com/pion/transport/v2 v2.0.2 h1:St+8o+1PEzPT51O9bv+tH/KYYLMNR5Vwm5Z3Qkjsywg=
 github.com/pion/transport/v2 v2.0.2/go.mod h1:vrz6bUbFr/cjdwbnxq8OdDDzHf7JJfGsIRkxfpZoTA0=
+github.com/pion/transport/v2 v2.1.0/go.mod h1:AdSw4YBZVDkZm8fpoz+fclXyQwANWmZAlDuQdctTThQ=
+github.com/pion/transport/v2 v2.2.0/go.mod h1:AdSw4YBZVDkZm8fpoz+fclXyQwANWmZAlDuQdctTThQ=
+github.com/pion/transport/v2 v2.2.1 h1:7qYnCBlpgSJNYMbLCKuSY9KbQdBFoETvPNETv0y4N7c=
+github.com/pion/transport/v2 v2.2.1/go.mod h1:cXXWavvCnFF6McHTft3DWS9iic2Mftcz1Aq29pGcU5g=
 github.com/pion/turn/v2 v2.0.4/go.mod h1:1812p4DcGVbYVBTiraUmP50XoKye++AMkbfp+N27mog=
 github.com/pion/turn/v2 v2.0.8 h1:KEstL92OUN3k5k8qxsXHpr7WWfrdp7iJZHx99ud8muw=
 github.com/pion/turn/v2 v2.0.8/go.mod h1:+y7xl719J8bAEVpSXBXvTxStjJv3hbz9YFflvkpcGPw=
 github.com/pion/turn/v2 v2.1.0 h1:5wGHSgGhJhP/RpabkUb/T9PdsAjkGLS6toYz5HNzoSI=
 github.com/pion/turn/v2 v2.1.0/go.mod h1:yrT5XbXSGX1VFSF31A3c1kCNB5bBZgk/uu5LET162qs=
+github.com/pion/turn/v2 v2.1.2 h1:wj0cAoGKltaZ790XEGW9HwoUewqjliwmhtxCuB2ApyM=
+github.com/pion/turn/v2 v2.1.2/go.mod h1:1kjnPkBcex3dhCU2Am+AAmxDcGhLX3WnMfmkNpvSTQU=
 github.com/pion/udp v0.1.0/go.mod h1:BPELIjbwE9PRbd/zxI/KYBnbo7B6+oA6YuEaNE8lths=
 github.com/pion/udp v0.1.1 h1:8UAPvyqmsxK8oOjloDk4wUt63TzFe9WEJkg5lChlj7o=
 github.com/pion/udp v0.1.1/go.mod h1:6AFo+CMdKQm7UiA0eUPA8/eVCTx8jBIITLZHc9DWX5M=
@@ -226,6 +250,8 @@ github.com/pion/webrtc/v3 v3.1.42 h1:wJEQFIXVanptnQcHOLTuIo4AtGB2+mG2x4OhIhnITOA
 github.com/pion/webrtc/v3 v3.1.42/go.mod h1:ffD9DulDrPxyWvDPUIPAOSAWx9GUlOExiJPf7cCcMLA=
 github.com/pion/webrtc/v3 v3.1.58 h1:husXqiKQuk6gbOqJlPHs185OskAyxUW6iAEgHghgCrc=
 github.com/pion/webrtc/v3 v3.1.58/go.mod h1:jJdqoqGBlZiE3y8Z1tg1fjSkyEDCZLL+foypUBn0Lhk=
+github.com/pion/webrtc/v3 v3.2.12 h1:pVqz5NdtTqyhKIhMcXR8bPp709kCf9blyAhDjoVRLvA=
+github.com/pion/webrtc/v3 v3.2.12/go.mod h1:/Oz6K95CGWaN+3No+Z0NYvgOPOr3aY8UyTlMm/dec3A=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
@@ -276,7 +302,12 @@ github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO
 github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
 github.com/stretchr/testify v1.8.2 h1:+h33VjcLVPDHtOdpUCuF+7gSuG3yGIftsP1YvFihtJ8=
 github.com/stretchr/testify v1.8.2/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/tarm/serial v0.0.0-20180830185346-98f6abe2eb07/go.mod h1:kDXzergiv9cbyO7IOYJZWg1U88JhDg3PB6klq9Hg2pA=
+github.com/tejasmanohar/timerange-go v1.0.0 h1:yCd/hWz0NRTU5Pu+f82rsFb0fwpVyJt0oKbAkqOi/ZI=
+github.com/tejasmanohar/timerange-go v1.0.0/go.mod h1:tic3Puc+uofo0D7502PvYBlu5sJMszF5nGbsYsu7FiI=
 github.com/viant/assertly v0.4.8/go.mod h1:aGifi++jvCrUaklKEKT0BU95igDNaqkvz+49uaYMPRU=
 github.com/viant/toolbox v0.24.0/go.mod h1:OxMCG57V0PXuIP2HNQrtJf2CjqdmbrOx5EkMILuUhzM=
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
@@ -304,6 +335,9 @@ golang.org/x/crypto v0.5.0/go.mod h1:NK/OQwhpMQP3MwtdjgLlYHnH9ebylxKWv3e0fK+mkQU
 golang.org/x/crypto v0.6.0/go.mod h1:OFC/31mSvZgRz0V1QTNCzfAI1aIRzbiufJtkMIlEp58=
 golang.org/x/crypto v0.7.0 h1:AvwMYaRytfdeVt3u6mLaxYtErKYjxA2OXjJ1HHq6t3A=
 golang.org/x/crypto v0.7.0/go.mod h1:pYwdfH91IfpZVANVyUOhSIPZaFoJGxTFbZhFTx+dXZU=
+golang.org/x/crypto v0.8.0/go.mod h1:mRqEX+O9/h5TFCrQhkgjo2yKi0yYA+9ecGkdQoHrywE=
+golang.org/x/crypto v0.10.0 h1:LKqV2xt9+kDzSTfOhx4FrkEBcMrAgHSYgzywV9zcGmM=
+golang.org/x/crypto v0.10.0/go.mod h1:o4eNf7Ede1fv+hwOwZsTHl9EsPFO6q6ZvYR8vYfY45I=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20230310171629-522b1b587ee0 h1:LGJsf5LRplCck6jUCH3dBL2dmycNruWNF5xugkSlfXw=
 golang.org/x/exp v0.0.0-20230310171629-522b1b587ee0/go.mod h1:CxIveKay+FTh1D0yPZemJVgC/95VzuuOLq5Qi4xnoYc=
@@ -314,6 +348,7 @@ golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHl
 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.9.0 h1:KENHtAZL2y3NLMYZeHY9DW8HW8V+kQyJsY/V9JlKvCs=
 golang.org/x/mod v0.9.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@@ -353,6 +388,10 @@ golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
 golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
 golang.org/x/net v0.8.0 h1:Zrh2ngAOFYneWTAIAPethzeaQLuHwhuBkuV6ZiRnUaQ=
 golang.org/x/net v0.8.0/go.mod h1:QVkue5JL9kW//ek3r6jTKnTFis1tRmNAW2P1shuFdJc=
+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 h1:Gi2tvZIJyBtO9SDr1q9h5hEQCp/4L2RQ+ar0qjx2oNU=
+golang.org/x/net v0.11.0/go.mod h1:2L/ixqYpgIVXmeoSA/4Lu7BzTG4KIyPIryS4IsOd1oQ=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20181017192945-9dcd33a902f4/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20181203162652-d668ce993890/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
@@ -367,6 +406,7 @@ golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJ
 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-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181029174526-d69651ed3497/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
@@ -400,11 +440,19 @@ golang.org/x/sys v0.4.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 h1:MVltZSvRTcU2ljQOhs94SXPftV6DCNnZViHeQps87pQ=
 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 h1:KS/R3tvhPqvJvwcKfnBHJwwthS11LRhmM5D59eEXa0s=
+golang.org/x/sys v0.9.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 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.4.0/go.mod h1:9P2UbLfCdcvo3p/nzKvsmas4TnlujnuoV9hGgYzW1lQ=
 golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
+golang.org/x/term v0.6.0/go.mod h1:m6U89DPEgQRMq3DNkDClhWw02AUbt2daBVO4cn4Hv9U=
+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/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
@@ -417,6 +465,10 @@ golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 golang.org/x/text v0.6.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.8.0 h1:57P1ETyNKtuIjB4SRd15iJxuhj8Gc416Y78H3qgMh68=
+golang.org/x/text v0.8.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
+golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
+golang.org/x/text v0.10.0 h1:UpjohKhiEgNc0CSauXmwYftY1+LlaC75SJwh0SgCX58=
+golang.org/x/text v0.10.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
 golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
@@ -430,6 +482,7 @@ golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtn
 golang.org/x/tools v0.0.0-20201224043029-2b0845dc783e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
 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.7.0 h1:W4OVu8VVOaIO0yzWMNdepAulS7YfoS3Zabrm8DOXXU4=
 golang.org/x/tools v0.7.0/go.mod h1:4pg6aUX35JBAogB10C9AtvVL+qowtN4pT3CGSQex14s=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
@@ -477,6 +530,7 @@ 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 h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 grpc.go4.org v0.0.0-20170609214715-11d0a25b4919/go.mod h1:77eQGdRu53HpSqPFJFmuJdjuHRquDANNeA4x7B8WQ9o=
 honnef.co/go/tools v0.0.0-20180728063816-88497007e858/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=