153 lines
3.3 KiB
Go
153 lines
3.3 KiB
Go
package qlab
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"fmt"
|
|
"math"
|
|
)
|
|
|
|
func oscPad(n int) int {
|
|
return (4 - n%4) % 4
|
|
}
|
|
|
|
func buildOSC(addr string, args ...any) []byte {
|
|
var buf []byte
|
|
|
|
buf = append(buf, []byte(addr)...)
|
|
buf = append(buf, 0)
|
|
for range oscPad(len(addr) + 1) {
|
|
buf = append(buf, 0)
|
|
}
|
|
|
|
typetag := ","
|
|
for _, arg := range args {
|
|
switch arg.(type) {
|
|
case int32:
|
|
typetag += "i"
|
|
case float32:
|
|
typetag += "f"
|
|
case string:
|
|
typetag += "s"
|
|
case []byte:
|
|
typetag += "b"
|
|
case int64:
|
|
typetag += "h"
|
|
case float64:
|
|
typetag += "d"
|
|
}
|
|
}
|
|
buf = append(buf, []byte(typetag)...)
|
|
buf = append(buf, 0)
|
|
for range oscPad(len(typetag) + 1) {
|
|
buf = append(buf, 0)
|
|
}
|
|
|
|
for _, arg := range args {
|
|
switch v := arg.(type) {
|
|
case int32:
|
|
buf = binary.BigEndian.AppendUint32(buf, uint32(v))
|
|
case float32:
|
|
buf = binary.BigEndian.AppendUint32(buf, math.Float32bits(v))
|
|
case string:
|
|
buf = append(buf, []byte(v)...)
|
|
buf = append(buf, 0)
|
|
for range oscPad(len(v) + 1) {
|
|
buf = append(buf, 0)
|
|
}
|
|
case []byte:
|
|
buf = binary.BigEndian.AppendUint32(buf, uint32(len(v)))
|
|
buf = append(buf, v...)
|
|
for range oscPad(len(v)) {
|
|
buf = append(buf, 0)
|
|
}
|
|
case int64:
|
|
buf = binary.BigEndian.AppendUint64(buf, uint64(v))
|
|
case float64:
|
|
buf = binary.BigEndian.AppendUint64(buf, math.Float64bits(v))
|
|
}
|
|
}
|
|
|
|
return buf
|
|
}
|
|
|
|
func parseOSC(data []byte) (addr string, args []any, err error) {
|
|
if len(data) < 4 {
|
|
return "", nil, fmt.Errorf("osc: message too short")
|
|
}
|
|
|
|
end := 0
|
|
for end < len(data) && data[end] != 0 {
|
|
end++
|
|
}
|
|
addr = string(data[:end])
|
|
pos := end + 1 + oscPad(end+1)
|
|
|
|
if pos >= len(data) || data[pos] != ',' {
|
|
return addr, nil, nil
|
|
}
|
|
|
|
ttEnd := pos
|
|
for ttEnd < len(data) && data[ttEnd] != 0 {
|
|
ttEnd++
|
|
}
|
|
typetag := string(data[pos+1 : ttEnd])
|
|
pos = ttEnd + 1 + oscPad(ttEnd-pos+1)
|
|
|
|
for _, t := range typetag {
|
|
switch t {
|
|
case 'i':
|
|
if pos+4 > len(data) {
|
|
return addr, args, fmt.Errorf("osc: truncated int32")
|
|
}
|
|
args = append(args, int32(binary.BigEndian.Uint32(data[pos:])))
|
|
pos += 4
|
|
case 'f':
|
|
if pos+4 > len(data) {
|
|
return addr, args, fmt.Errorf("osc: truncated float32")
|
|
}
|
|
args = append(args, math.Float32frombits(binary.BigEndian.Uint32(data[pos:])))
|
|
pos += 4
|
|
case 's':
|
|
end := pos
|
|
for end < len(data) && data[end] != 0 {
|
|
end++
|
|
}
|
|
args = append(args, string(data[pos:end]))
|
|
pos = end + 1 + oscPad(end-pos+1)
|
|
case 'b':
|
|
if pos+4 > len(data) {
|
|
return addr, args, fmt.Errorf("osc: truncated blob size")
|
|
}
|
|
size := int(binary.BigEndian.Uint32(data[pos:]))
|
|
pos += 4
|
|
if pos+size > len(data) {
|
|
return addr, args, fmt.Errorf("osc: truncated blob")
|
|
}
|
|
b := make([]byte, size)
|
|
copy(b, data[pos:pos+size])
|
|
args = append(args, b)
|
|
pos += size + oscPad(size)
|
|
case 'h':
|
|
if pos+8 > len(data) {
|
|
return addr, args, fmt.Errorf("osc: truncated int64")
|
|
}
|
|
args = append(args, int64(binary.BigEndian.Uint64(data[pos:])))
|
|
pos += 8
|
|
case 'd':
|
|
if pos+8 > len(data) {
|
|
return addr, args, fmt.Errorf("osc: truncated float64")
|
|
}
|
|
args = append(args, math.Float64frombits(binary.BigEndian.Uint64(data[pos:])))
|
|
pos += 8
|
|
case 'T':
|
|
args = append(args, true)
|
|
case 'F':
|
|
args = append(args, false)
|
|
case 'N':
|
|
args = append(args, nil)
|
|
}
|
|
}
|
|
|
|
return addr, args, nil
|
|
}
|