Alex X
154 lines
3.6 KiB
Go
154 lines
3.6 KiB
Go
package tutk
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"fmt"
|
|
)
|
|
|
|
func (c *Conn) oldMsgCtrl(ctrlType uint16, ctrlData []byte) []byte {
|
|
size := msgHhrSize + cmdHdrSize + 4 + uint16(len(ctrlData))
|
|
msg := c.msg(size)
|
|
|
|
cmd := msg[msgHhrSize:]
|
|
copy(cmd, "\x00\x70\x0b\x00")
|
|
|
|
binary.LittleEndian.PutUint16(cmd[4:], c.seqSendCmd1)
|
|
c.seqSendCmd1++
|
|
|
|
binary.LittleEndian.PutUint16(cmd[16:], size-52)
|
|
//binary.LittleEndian.PutUint32(cmd[20:], uint32(time.Now().UnixMilli()))
|
|
|
|
data := cmd[cmdHdrSize:]
|
|
binary.LittleEndian.PutUint16(data, ctrlType)
|
|
copy(data[4:], ctrlData)
|
|
return msg
|
|
}
|
|
|
|
func (c *Conn) oldHandlerCh0() func([]byte) int8 {
|
|
var waitSeq uint16
|
|
var waitSize uint32
|
|
var waitData []byte
|
|
|
|
return func(cmd []byte) int8 {
|
|
// 0 01030800 command + version
|
|
// 4 00000000 fixed
|
|
// 8 ac880100 total size
|
|
// 12 6200 chunk seq
|
|
// 14 2000 ???
|
|
// 16 cc00 size
|
|
// 18 0000
|
|
// 20 01000000 fixed
|
|
|
|
switch cmd[0] {
|
|
case 0x01:
|
|
switch cmd[1] {
|
|
case 0x03:
|
|
seq := binary.LittleEndian.Uint16(cmd[12:])
|
|
if seq != waitSeq {
|
|
waitSeq = 0
|
|
return msgMediaLost
|
|
}
|
|
if seq == 0 {
|
|
waitData = waitData[:0]
|
|
waitSize = binary.LittleEndian.Uint32(cmd[8:]) + 32
|
|
}
|
|
|
|
waitData = append(waitData, cmd[24:]...)
|
|
if n := uint32(len(waitData)); n < waitSize {
|
|
waitSeq++
|
|
return msgMediaChunk
|
|
} else if n > waitSize {
|
|
waitSeq = 0
|
|
return msgMediaLost
|
|
}
|
|
|
|
// create a buffer for the header and collected data
|
|
packetData := make([]byte, waitSize)
|
|
// there's a header at the end - let's move it to the beginning
|
|
copy(packetData, waitData[waitSize-32:])
|
|
copy(packetData[32:], waitData)
|
|
|
|
select {
|
|
case c.rawPkt <- packetData:
|
|
default:
|
|
c.err = fmt.Errorf("%s: media queue is full", "tutk")
|
|
return -1
|
|
}
|
|
|
|
waitSeq = 0
|
|
return msgMediaFrame
|
|
|
|
case 0x04:
|
|
waitSize2 := binary.LittleEndian.Uint32(cmd[8:])
|
|
waitData2 := cmd[24:]
|
|
|
|
if uint32(len(waitData2)) != waitSize2 {
|
|
return -1 // shouldn't happened for audio
|
|
}
|
|
|
|
packetData := make([]byte, waitSize2)
|
|
copy(packetData, waitData2)
|
|
|
|
select {
|
|
case c.rawPkt <- packetData:
|
|
default:
|
|
c.err = fmt.Errorf("%s: media queue is full", "tutk")
|
|
return -1
|
|
}
|
|
return msgMediaFrame
|
|
}
|
|
|
|
case 0x00:
|
|
switch cmd[1] {
|
|
case 0x70:
|
|
_ = c.WriteCh0(c.msgAck0070(cmd))
|
|
select {
|
|
case c.rawCmd <- cmd[24:]:
|
|
default:
|
|
}
|
|
return msgCommand
|
|
case 0x12:
|
|
_ = c.WriteCh0(c.msgAck0012(cmd))
|
|
return msgDafang0012
|
|
case 0x71:
|
|
if c.cmdAck != nil {
|
|
c.cmdAck()
|
|
}
|
|
return msgDafang0071
|
|
}
|
|
}
|
|
|
|
return 0
|
|
}
|
|
}
|
|
|
|
func (c *Conn) msgAck0070(msg28 []byte) []byte {
|
|
// <- [104] 0402120a 58000300 08041200 e6e8 0000 0c000000e6e839da66b0dc14 00700800010000000000000000000000 3400 00007625a02f ...
|
|
// -> [ 52] 0402190a 24000400 07042100 e6e8 0000 0c000000e6e839da66b0dc14 00710800010000000000000000000000 0000 00007625a02f
|
|
msg := c.msg(52)
|
|
|
|
cmd := msg[msgHhrSize:]
|
|
copy(cmd, "\x00\x71\x0b\x00")
|
|
binary.LittleEndian.PutUint16(cmd[4:], c.seqSendCmd1)
|
|
c.seqSendCmd1++
|
|
copy(cmd[8:], msg28[8:10])
|
|
|
|
return msg
|
|
}
|
|
|
|
func (c *Conn) msgAck0012(msg28 []byte) []byte {
|
|
// <- [64] 0402120a 30000000 08041200 e6e800000c000000e6e839da66b0dc14 001208000000000000000000000000000c00000000000000 020000000100000001000000
|
|
// -> [72] 0402190a 38000300 07042100 e6e800000c000000e6e839da66b0dc14 00130b000000000000000000000000001400000000000000 0200000001000000010000000000000000000000
|
|
const size = 72
|
|
msg := c.msg(size)
|
|
|
|
cmd := msg[msgHhrSize:]
|
|
copy(cmd, "\x00\x13\x0b\x00")
|
|
cmd[16] = size - 52 // data size
|
|
|
|
data := cmd[cmdHdrSize:]
|
|
copy(data, msg28[cmdHdrSize:])
|
|
|
|
return msg
|
|
}
|