package shmparser
|
|
/*
|
#cgo LDFLAGS: -ldl
|
#include <stdlib.h>
|
#include "shmparser.h"
|
*/
|
import "C"
|
import (
|
"unsafe"
|
)
|
|
func str2byte(s string) []byte {
|
x := (*[2]uintptr)(unsafe.Pointer(&s))
|
h := [3]uintptr{x[0], x[1], x[1]}
|
return *(*[]byte)(unsafe.Pointer(&h))
|
}
|
|
func byte2str(d []byte) string {
|
return *(*string)(unsafe.Pointer(&d))
|
}
|
|
// Image2Shm fill image to shm
|
func Image2Shm(shm []byte, cid, cname, timestamp string, data []byte, w, h int, fid int64) {
|
|
dataptr := (*C.uchar)(unsafe.Pointer(&data[0]))
|
cidbyte := str2byte(cid)
|
cidptr := (*C.char)(unsafe.Pointer(&cidbyte[0]))
|
cnamebyte := str2byte(cname)
|
cnameptr := (*C.char)(unsafe.Pointer(&cnamebyte[0]))
|
|
tsbyte := str2byte(timestamp)
|
tsptr := (*C.char)(unsafe.Pointer(&tsbyte[0]))
|
|
cimg := C.make_image_ref(C.ulong(fid),
|
dataptr, C.uint(len(data)), C.uint(w), C.uint(h),
|
tsptr, C.uint(len(timestamp)),
|
cidptr, C.uint(len(cid)),
|
cnameptr, C.uint(len(cname)),
|
)
|
|
shmptr := unsafe.Pointer(&shm[0])
|
C.goImage2Shm(shmptr, unsafe.Pointer(cimg))
|
C.free_stimg(cimg)
|
}
|
|
// ImageShm Image struct in Shm
|
type ImageShm struct {
|
Data []byte
|
Width int
|
Height int
|
Timestamp string
|
Id uint64
|
Cid string
|
Cname string
|
}
|
|
func uintptr2byte(p unsafe.Pointer, size uint64) []byte {
|
if (^uint(0) >> 63) == 0 {
|
const maxLen = 0x7fffffff
|
return (*(*[maxLen]byte)(p))[:size:size]
|
} else {
|
const maxLen = 0xffffffffffff
|
return (*(*[maxLen]byte)(p))[:size:size]
|
}
|
}
|
|
func Shm2Image(shm []byte) ImageShm {
|
cimg := C.shm2image(unsafe.Pointer(&shm[0]))
|
|
var goimg ImageShm
|
|
var data, ts, cid, cname unsafe.Pointer
|
var sd, id C.ulong
|
var sts, scid, scname, w, h C.uint
|
|
p := unsafe.Pointer(cimg)
|
|
C.goImageGet(p, &data, &sd, &ts, &sts, &cid, &scid, &cname, &scname, &id, &w, &h)
|
goimg.Data = uintptr2byte(data, uint64(sd))
|
|
tmp := uintptr2byte(ts, uint64(sts))
|
goimg.Timestamp = byte2str(tmp)
|
|
tmp = uintptr2byte(cid, uint64(scid))
|
goimg.Cid = byte2str(tmp)
|
|
tmp = uintptr2byte(cname, uint64(scname))
|
goimg.Cname = byte2str(tmp)
|
|
goimg.Width = int(w)
|
goimg.Height = int(h)
|
goimg.Id = uint64(id)
|
|
C.free_stimg(cimg)
|
|
return goimg
|
}
|
|
// Rect struct
|
type Rect struct {
|
Left int
|
Top int
|
Right int
|
Bottom int
|
}
|
|
// Target analysis Target
|
type Target struct {
|
Id uint64
|
Type string
|
Confidence int
|
Rc Rect
|
Feat []byte
|
Attr []byte
|
}
|
|
// Resdk result of sdk
|
type Resdk struct {
|
Type string
|
Id string
|
Name string
|
Timestamp string
|
Targets []Target
|
}
|
|
// Strule struct of rule message
|
type Strule struct {
|
Handletrack string
|
Datatype string
|
Sdks []Resdk
|
}
|
|
// Rule2Shm rule message init to shm
|
func Rule2Shm(shm []byte, handletrack string) {
|
shmptr := unsafe.Pointer(&shm[0])
|
ht := str2byte(handletrack)
|
htptr := (*C.char)(unsafe.Pointer(&ht[0]))
|
|
C.rule2shm(shmptr, htptr, C.uint(len(handletrack)))
|
}
|
|
// AddResSdk2RuleInShm add sdk message to rule in shm
|
func AddResSdk2RuleInShm(shm []byte, sdk Resdk) {
|
|
ctgts := C.goTargetsNew(C.uint(len(sdk.Targets)))
|
for k, v := range sdk.Targets {
|
tpbyte := str2byte(v.Type)
|
tptr := (*C.char)(unsafe.Pointer(&tpbyte[0]))
|
featptr := (*C.uchar)(unsafe.Pointer(&v.Feat[0]))
|
attrptr := (*C.uchar)(unsafe.Pointer(&v.Attr[0]))
|
|
C.goTargetAdd(ctgts, C.int(k), C.ulong(v.Id), tptr, C.uint(len(v.Type)),
|
C.int(v.Confidence),
|
C.int(v.Rc.Left), C.int(v.Rc.Top), C.int(v.Rc.Right), C.int(v.Rc.Bottom),
|
featptr, C.uint(len(v.Feat)), attrptr, C.uint(len(v.Attr)))
|
}
|
|
shmptr := unsafe.Pointer(&shm[0])
|
ts := str2byte(sdk.Timestamp)
|
tsptr := (*C.char)(unsafe.Pointer(&ts[0]))
|
|
tp := str2byte(sdk.Type)
|
tpstr := (*C.char)(unsafe.Pointer(&tp[0]))
|
|
C.goSdkPut(shmptr, ctgts, C.uint(len(sdk.Targets)),
|
tpstr, C.uint(len(sdk.Type)),
|
tsptr, C.uint(len(sdk.Timestamp)))
|
|
C.goTargetsDel(ctgts)
|
}
|
|
// Shm2Rule get Rule from shm
|
func Shm2Rule(shm []byte) Strule {
|
|
var rule Strule
|
|
crule := C.shm2rule(unsafe.Pointer(&shm[0]))
|
|
var ht unsafe.Pointer
|
var sht C.uint
|
|
p := unsafe.Pointer(crule)
|
C.goHandletrackGet(p, &ht, &sht)
|
tmp := uintptr2byte(ht, uint64(sht))
|
rule.Handletrack = byte2str(tmp)
|
|
var dt unsafe.Pointer
|
var sdt C.uint
|
C.goDatatypeGet(p, &dt, &sdt)
|
tmp = uintptr2byte(dt, uint64(sdt))
|
rule.Datatype = byte2str(tmp)
|
|
////////////////////////////////////////////////
|
|
var csdk unsafe.Pointer
|
var s32 C.uint
|
C.goSdkArrayGet(p, &csdk, &s32)
|
|
for i := 0; i < int(s32); i++ {
|
var ctype, cid, cname, cts, ctgt unsafe.Pointer
|
var st, si, sn, sts, stgt C.uint
|
var sdk Resdk
|
|
C.goSdkGet(csdk, C.int(i), &ctype, &st, &cid, &si,
|
&cname, &sn, &cts, &sts, &ctgt, &stgt)
|
tmp = uintptr2byte(ctype, uint64(st))
|
sdk.Type = byte2str(tmp)
|
|
tmp = uintptr2byte(cid, uint64(si))
|
sdk.Id = byte2str(tmp)
|
|
tmp = uintptr2byte(cname, uint64(sn))
|
sdk.Name = byte2str(tmp)
|
tmp = uintptr2byte(cts, uint64(sts))
|
sdk.Timestamp = byte2str(tmp)
|
|
for j := 0; j < int(stgt); j++ {
|
var tid C.ulong
|
var tc, tl, tt, tr, tb C.int
|
var tp, tfeat, tattr unsafe.Pointer
|
var stp, stf, sta C.uint
|
|
var tgt Target
|
|
C.goTargetGet(ctgt, C.int(j), &tid, &tc, &tl, &tt, &tr, &tb,
|
&tp, &stp, &tfeat, &stf, &tattr, &sta)
|
|
tgt.Id = uint64(tid)
|
tgt.Confidence = int(tc)
|
tgt.Rc.Left = int(tl)
|
tgt.Rc.Top = int(tt)
|
tgt.Rc.Right = int(tr)
|
tgt.Rc.Bottom = int(tb)
|
|
tmp = uintptr2byte(tp, uint64(stp))
|
tgt.Type = byte2str(tmp)
|
|
tmp = uintptr2byte(tfeat, uint64(stf))
|
tgt.Feat = tmp
|
|
tmp = uintptr2byte(tattr, uint64(sta))
|
tgt.Attr = tmp
|
|
sdk.Targets = append(sdk.Targets, tgt)
|
}
|
|
rule.Sdks = append(rule.Sdks, sdk)
|
}
|
|
C.free_strule(crule)
|
|
return rule
|
}
|
