install go2rtc on bob
This commit is contained in:
@@ -0,0 +1,381 @@
|
||||
package tutk
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/binary"
|
||||
"io"
|
||||
"net"
|
||||
"time"
|
||||
)
|
||||
|
||||
type Session interface {
|
||||
Close() error
|
||||
|
||||
ClientStart(i byte, username, password string) []byte
|
||||
|
||||
SendIOCtrl(ctrlType uint32, ctrlData []byte) []byte
|
||||
SendFrameData(frameInfo, frameData []byte) []byte
|
||||
|
||||
RecvIOCtrl() (ctrlType uint32, ctrlData []byte, err error)
|
||||
RecvFrameData() (frameInfo, frameData []byte, err error)
|
||||
|
||||
SessionRead(chID byte, buf []byte) int
|
||||
SessionWrite(chID byte, buf []byte) error
|
||||
}
|
||||
|
||||
func NewSession16(conn net.Conn, sid8 []byte) *Session16 {
|
||||
sid16 := make([]byte, 16)
|
||||
copy(sid16[8:], sid8)
|
||||
copy(sid16, sid8[:2])
|
||||
sid16[4] = 0x0c
|
||||
|
||||
return &Session16{
|
||||
conn: conn,
|
||||
sid16: sid16,
|
||||
rawCmd: make(chan []byte, 10),
|
||||
rawPkt: make(chan [2][]byte, 100),
|
||||
}
|
||||
}
|
||||
|
||||
type Session16 struct {
|
||||
conn net.Conn
|
||||
sid16 []byte
|
||||
|
||||
rawCmd chan []byte
|
||||
rawPkt chan [2][]byte
|
||||
|
||||
seqSendCh0 uint16
|
||||
seqSendCh1 uint16
|
||||
|
||||
seqSendCmd1 uint16
|
||||
seqSendAud uint16
|
||||
|
||||
waitFSeq uint16
|
||||
waitCSeq uint16
|
||||
waitSize int
|
||||
waitData []byte
|
||||
}
|
||||
|
||||
func (s *Session16) Close() error {
|
||||
close(s.rawCmd)
|
||||
close(s.rawPkt)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *Session16) Msg(size uint16) []byte {
|
||||
b := make([]byte, size)
|
||||
copy(b, magic)
|
||||
b[3] = 0x0a // connected stage
|
||||
binary.LittleEndian.PutUint16(b[4:], size-16)
|
||||
copy(b[8:], "\x07\x04\x21") // client request
|
||||
copy(b[12:], s.sid16)
|
||||
return b
|
||||
}
|
||||
|
||||
const (
|
||||
msgHhrSize = 28
|
||||
cmdHdrSize = 24
|
||||
)
|
||||
|
||||
func (s *Session16) ClientStart(i byte, username, password string) []byte {
|
||||
const size = 566 + 32
|
||||
msg := s.Msg(size)
|
||||
|
||||
// 0 00000b0000000000000000000000000022020000fcfc7284
|
||||
// 24 4d69737300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
|
||||
// 281 636c69656e740000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
|
||||
// 538 0100000004000000fb071f000000000000000000000003000000000001000000
|
||||
cmd := msg[msgHhrSize:]
|
||||
copy(cmd, "\x00\x00\x0b\x00")
|
||||
binary.LittleEndian.PutUint16(cmd[16:], size-52)
|
||||
if i == 0 {
|
||||
cmd[18] = 1
|
||||
} else {
|
||||
cmd[1] = 0x20
|
||||
}
|
||||
binary.LittleEndian.PutUint32(cmd[20:], uint32(time.Now().UnixMilli()))
|
||||
|
||||
// important values for some cameras (not for df3)
|
||||
data := cmd[cmdHdrSize:]
|
||||
copy(data, username)
|
||||
copy(data[257:], password)
|
||||
|
||||
// 0100000004000000fb071f000000000000000000000003000000000001000000
|
||||
cfg := data[257+257:]
|
||||
//cfg[0] = 1 // 0 - simple proto, 1 - complex proto with "0Cxx" commands
|
||||
cfg[4] = 4
|
||||
copy(cfg[8:], "\xfb\x07\x1f\x00")
|
||||
cfg[22] = 3
|
||||
//cfg[28] = 1 // unknown
|
||||
return msg
|
||||
}
|
||||
|
||||
func (s *Session16) SendIOCtrl(ctrlType uint32, ctrlData []byte) []byte {
|
||||
dataSize := 4 + uint16(len(ctrlData))
|
||||
msg := s.Msg(msgHhrSize + cmdHdrSize + dataSize)
|
||||
|
||||
cmd := msg[msgHhrSize:]
|
||||
copy(cmd, "\x00\x70\x0b\x00")
|
||||
|
||||
s.seqSendCmd1++ // start from 1, important!
|
||||
binary.LittleEndian.PutUint16(cmd[4:], s.seqSendCmd1)
|
||||
|
||||
binary.LittleEndian.PutUint16(cmd[16:], dataSize)
|
||||
binary.LittleEndian.PutUint32(cmd[20:], uint32(time.Now().UnixMilli()))
|
||||
|
||||
data := cmd[cmdHdrSize:]
|
||||
binary.LittleEndian.PutUint32(data, ctrlType)
|
||||
copy(data[4:], ctrlData)
|
||||
return msg
|
||||
}
|
||||
|
||||
func (s *Session16) SendFrameData(frameInfo, frameData []byte) []byte {
|
||||
// -> 01030b001d0000008802000000002800b0020bf501000000 ... 4f4455412000000088020000030400001d000000000000000bf51f7a9b0100000000000000000000
|
||||
|
||||
n := uint16(len(frameData))
|
||||
dataSize := n + 8 + 32
|
||||
msg := s.Msg(msgHhrSize + cmdHdrSize + dataSize)
|
||||
|
||||
// 0 01030b00 command + version
|
||||
// 4 1d000000 seq
|
||||
// 8 8802 media size (648)
|
||||
// 10 00000000
|
||||
// 14 2800 tail (pkt header) size?
|
||||
// 16 b002 size (648 + 8 + 32)
|
||||
// 18 0bf5 random msg id (unixms)
|
||||
// 20 01000000 fixed
|
||||
cmd := msg[msgHhrSize:]
|
||||
copy(cmd, "\x01\x03\x0b\x00")
|
||||
binary.LittleEndian.PutUint16(cmd[4:], s.seqSendAud)
|
||||
s.seqSendAud++
|
||||
binary.LittleEndian.PutUint16(cmd[8:], n)
|
||||
cmd[14] = 0x28 // important!
|
||||
binary.LittleEndian.PutUint16(cmd[16:], dataSize)
|
||||
binary.LittleEndian.PutUint16(cmd[18:], uint16(time.Now().UnixMilli()))
|
||||
cmd[20] = 1
|
||||
|
||||
data := cmd[cmdHdrSize:]
|
||||
copy(data, frameData)
|
||||
copy(data[n:], "ODUA\x20\x00\x00\x00")
|
||||
copy(data[n+8:], frameInfo)
|
||||
|
||||
return msg
|
||||
}
|
||||
|
||||
func (s *Session16) RecvIOCtrl() (ctrlType uint32, ctrlData []byte, err error) {
|
||||
buf, ok := <-s.rawCmd
|
||||
if !ok {
|
||||
return 0, nil, io.EOF
|
||||
}
|
||||
return binary.LittleEndian.Uint32(buf), buf[4:], nil
|
||||
}
|
||||
|
||||
func (s *Session16) RecvFrameData() (frameInfo, frameData []byte, err error) {
|
||||
buf, ok := <-s.rawPkt
|
||||
if !ok {
|
||||
return nil, nil, io.EOF
|
||||
}
|
||||
return buf[0], buf[1], nil
|
||||
}
|
||||
|
||||
func (s *Session16) SessionRead(chID byte, cmd []byte) int {
|
||||
if chID != 0 {
|
||||
return s.handleCh1(cmd)
|
||||
}
|
||||
|
||||
// 0 01030800 command + version
|
||||
// 4 00000000 frame seq
|
||||
// 8 ac880100 total size
|
||||
// 12 6200 chunk seq
|
||||
// 14 2000 tail (pkt header) size
|
||||
// 16 cc00 size
|
||||
// 18 0000
|
||||
// 20 01000000 fixed
|
||||
|
||||
switch cmd[0] {
|
||||
case 0x01:
|
||||
var packetData [2][]byte
|
||||
|
||||
switch cmd[1] {
|
||||
case 0x03:
|
||||
frameSeq := binary.LittleEndian.Uint16(cmd[4:])
|
||||
chunkSeq := binary.LittleEndian.Uint16(cmd[12:])
|
||||
if chunkSeq == 0 {
|
||||
s.waitFSeq = frameSeq
|
||||
s.waitCSeq = 0
|
||||
s.waitData = s.waitData[:0]
|
||||
payloadSize := binary.LittleEndian.Uint32(cmd[8:])
|
||||
hdrSize := binary.LittleEndian.Uint16(cmd[14:])
|
||||
s.waitSize = int(hdrSize) + int(payloadSize)
|
||||
} else if frameSeq != s.waitFSeq || chunkSeq != s.waitCSeq {
|
||||
s.waitCSeq = 0
|
||||
return msgMediaLost
|
||||
}
|
||||
|
||||
s.waitData = append(s.waitData, cmd[24:]...)
|
||||
if n := len(s.waitData); n < s.waitSize {
|
||||
s.waitCSeq++
|
||||
return msgMediaChunk
|
||||
}
|
||||
|
||||
s.waitCSeq = 0
|
||||
|
||||
payloadSize := binary.LittleEndian.Uint32(cmd[8:])
|
||||
packetData[0] = bytes.Clone(s.waitData[payloadSize:])
|
||||
packetData[1] = bytes.Clone(s.waitData[:payloadSize])
|
||||
|
||||
case 0x04:
|
||||
data := cmd[24:]
|
||||
hdrSize := binary.LittleEndian.Uint16(cmd[14:])
|
||||
packetData[0] = bytes.Clone(data[:hdrSize])
|
||||
packetData[1] = bytes.Clone(data[hdrSize:])
|
||||
|
||||
default:
|
||||
return msgUnknown
|
||||
}
|
||||
|
||||
select {
|
||||
case s.rawPkt <- packetData:
|
||||
default:
|
||||
return msgError
|
||||
}
|
||||
return msgMediaFrame
|
||||
|
||||
case 0x00:
|
||||
switch cmd[1] {
|
||||
case 0x70:
|
||||
_ = s.SessionWrite(0, s.msgAck0070(cmd))
|
||||
select {
|
||||
case s.rawCmd <- append([]byte{}, cmd[24:]...):
|
||||
default:
|
||||
}
|
||||
|
||||
return msgCommand
|
||||
case 0x12:
|
||||
_ = s.SessionWrite(0, s.msgAck0012(cmd))
|
||||
return msgDafang0012
|
||||
case 0x71:
|
||||
return msgCommandAck
|
||||
}
|
||||
}
|
||||
|
||||
return msgUnknown
|
||||
}
|
||||
|
||||
func (s *Session16) msgAck0070(msg28 []byte) []byte {
|
||||
// <- 00700800010000000000000000000000340000007625a02f ...
|
||||
// -> 00710800010000000000000000000000000000007625a02f
|
||||
msg := s.Msg(msgHhrSize + cmdHdrSize)
|
||||
|
||||
cmd := msg[msgHhrSize:]
|
||||
copy(cmd, "\x00\x71")
|
||||
copy(cmd[2:], msg28[2:6]) // same version and seq
|
||||
copy(cmd[20:], msg28[20:24]) // same msg random
|
||||
|
||||
return msg
|
||||
}
|
||||
|
||||
func (s *Session16) msgAck0012(msg28 []byte) []byte {
|
||||
// <- 001208000000000000000000000000000c00000000000000 020000000100000001000000
|
||||
// -> 00130b000000000000000000000000001400000000000000 0200000001000000010000000000000000000000
|
||||
const dataSize = 20
|
||||
msg := s.Msg(msgHhrSize + cmdHdrSize + dataSize)
|
||||
|
||||
cmd := msg[msgHhrSize:]
|
||||
copy(cmd, "\x00\x13\x0b\x00")
|
||||
cmd[16] = dataSize
|
||||
|
||||
data := cmd[cmdHdrSize:]
|
||||
copy(data, msg28[cmdHdrSize:])
|
||||
|
||||
return msg
|
||||
}
|
||||
|
||||
func (s *Session16) handleCh1(cmd []byte) int {
|
||||
// Channel 1 used for two-way audio. It's important:
|
||||
// - answer on 0000 command with exact config response (can't set simple proto)
|
||||
// - send 0012 command at start
|
||||
// - respond on every 0008 command for smooth playback
|
||||
switch cid := string(cmd[:2]); cid {
|
||||
case "\x00\x00": // client start
|
||||
_ = s.SessionWrite(1, s.msgAck0000(cmd))
|
||||
_ = s.SessionWrite(1, s.msg0012())
|
||||
return msgClientStart
|
||||
case "\x00\x07": // time sync without data
|
||||
_ = s.SessionWrite(1, s.msgAck0007(cmd))
|
||||
return msgUnknown0007
|
||||
case "\x00\x08": // time sync with data
|
||||
_ = s.SessionWrite(1, s.msgAck0008(cmd))
|
||||
return msgUnknown0008
|
||||
case "\x00\x13": // ack for 0012
|
||||
return msgUnknown0013
|
||||
}
|
||||
return msgUnknown
|
||||
}
|
||||
|
||||
func (s *Session16) msgAck0000(msg28 []byte) []byte {
|
||||
// <- 000008000000000000000000000000001a0200004f47c714 ... 00000000000000000100000004000000fb071f00000000000000000000000300
|
||||
// -> 00140b00000000000000000000000000200000004f47c714 00000000000000000100000004000000fb071f00000000000000000000000300
|
||||
const cmdDataSize = 32
|
||||
msg := s.Msg(msgHhrSize + cmdHdrSize + cmdDataSize)
|
||||
|
||||
cmd := msg[msgHhrSize:]
|
||||
copy(cmd, "\x00\x14\x0b\x00")
|
||||
cmd[16] = cmdDataSize
|
||||
copy(cmd[20:], msg28[20:24]) // request id (random)
|
||||
|
||||
// Important to answer with same data.
|
||||
data := cmd[cmdHdrSize:]
|
||||
copy(data, msg28[len(msg28)-32:])
|
||||
return msg
|
||||
}
|
||||
|
||||
func (s *Session16) msg0012() []byte {
|
||||
// -> 00120b000000000000000000000000000c00000000000000020000000100000001000000
|
||||
const dataSize = 12
|
||||
msg := s.Msg(msgHhrSize + cmdHdrSize + dataSize)
|
||||
cmd := msg[msgHhrSize:]
|
||||
|
||||
copy(cmd, "\x00\x12\x0b\x00")
|
||||
cmd[16] = dataSize
|
||||
data := cmd[cmdHdrSize:]
|
||||
|
||||
data[0] = 2
|
||||
data[4] = 1
|
||||
data[9] = 1
|
||||
return msg
|
||||
}
|
||||
|
||||
func (s *Session16) msgAck0007(msg28 []byte) []byte {
|
||||
// <- 000708000000000000000000000000000c00000001000000000000001c551f7a00000000
|
||||
// -> 010a0b00000000000000000000000000000000000100000000000000
|
||||
msg := s.Msg(msgHhrSize + 28)
|
||||
cmd := msg[msgHhrSize:]
|
||||
copy(cmd, "\x01\x0a\x0b\x00")
|
||||
cmd[20] = 1
|
||||
return msg
|
||||
}
|
||||
|
||||
func (s *Session16) msgAck0008(msg28 []byte) []byte {
|
||||
// <- 000808000000000000000000000000000000f9f0010000000200000050f31f7a
|
||||
// -> 01090b0000000000000000000000000000000000010000000200000050f31f7a
|
||||
msg := s.Msg(msgHhrSize + 28)
|
||||
cmd := msg[msgHhrSize:]
|
||||
copy(cmd, "\x01\x09\x0b\x00")
|
||||
copy(cmd[20:], msg28[20:])
|
||||
return msg
|
||||
}
|
||||
|
||||
func (s *Session16) SessionWrite(chID byte, buf []byte) error {
|
||||
switch chID {
|
||||
case 0:
|
||||
binary.LittleEndian.PutUint16(buf[6:], s.seqSendCh0)
|
||||
s.seqSendCh0++
|
||||
case 1:
|
||||
binary.LittleEndian.PutUint16(buf[6:], s.seqSendCh1)
|
||||
s.seqSendCh1++
|
||||
buf[14] = 1 // channel
|
||||
}
|
||||
_, err := s.conn.Write(buf)
|
||||
return err
|
||||
}
|
||||
Reference in New Issue
Block a user