add go test,complete

zhangmeng

2023-02-03 35a85de7b7495878ae4dcb73449f18c28131496c

 shmparser/shmparser.go

@@ -22,8 +22,8 @@
   return *(*string)(unsafe.Pointer(&d))
}

// Image2shm fill image to shm
func Image2shm(shm []byte, cid, cname string, data []byte, w, h int, fid int64) {
// Image2Shm fill image to shm
func Image2Shm(shm []byte, cid, cname string, data []byte, w, h int, fid int64) {
   timestamp := strings.Replace(time.Now().Format("2006-01-02 15:04:05.000"), ".", ":", -1)

   dataptr := (*C.uchar)(unsafe.Pointer(&data[0]))
@@ -43,7 +43,8 @@
   )

   shmptr := unsafe.Pointer(&shm[0])
   C.goimage2shm(shmptr, unsafe.Pointer(&cimg))
   C.goImage2Shm(shmptr, unsafe.Pointer(cimg))
   C.free_stimg(cimg)
}

// ImageShm Image struct in Shm
@@ -57,11 +58,20 @@
   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
   const maxLen = 0xffffffffffff

   var data, ts, cid, cname unsafe.Pointer
   var sd, id C.ulong
@@ -69,16 +79,16 @@

   p := unsafe.Pointer(cimg)

   C.goimageinfo(p, &data, &sd, &ts, &sts, &cid, &scid, &cname, &scname, &id, &w, &h)
   goimg.Data = (*[maxLen]byte)(data)[:uint64(sd):uint64(sd)]
   C.goImageGet(p, &data, &sd, &ts, &sts, &cid, &scid, &cname, &scname, &id, &w, &h)
   goimg.Data = uintptr2byte(data, uint64(sd))

   tmp := (*[maxLen]byte)(ts)[:int(sts):int(sts)]
   tmp := uintptr2byte(ts, uint64(sts))
   goimg.Timestamp = byte2str(tmp)

   tmp = (*[maxLen]byte)(cid)[:int(scid):int(scid)]
   tmp = uintptr2byte(cid, uint64(scid))
   goimg.Cid = byte2str(tmp)

   tmp = (*[maxLen]byte)(cname)[:int(scname):int(scname)]
   tmp = uintptr2byte(cname, uint64(scname))
   goimg.Cname = byte2str(tmp)

   goimg.Width = int(w)
@@ -136,14 +146,14 @@
// AddResSdk2RuleInShm add sdk message to rule in shm
func AddResSdk2RuleInShm(shm []byte, sdk Resdk) {

   ctgts := C.gotargetsnew(C.uint(len(sdk.Targets)))
   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.gotargetsadd(ctgts, C.int(k), C.ulong(v.Id), tptr, C.uint(len(v.Type)),
      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)))
@@ -156,11 +166,11 @@
   tp := str2byte(sdk.Type)
   tpstr := (*C.char)(unsafe.Pointer(&tp[0]))

   C.goruleaddsdk(shmptr, ctgts, C.uint(len(sdk.Targets)),
   C.goSdkPut(shmptr, ctgts, C.uint(len(sdk.Targets)),
      tpstr, C.uint(len(sdk.Type)),
      tsptr, C.uint(len(sdk.Timestamp)))

   C.gotargetsdel(ctgts)
   C.goTargetsDel(ctgts)
}

// Shm2Rule get Rule from shm
@@ -170,22 +180,77 @@

   crule := C.shm2rule(unsafe.Pointer(&shm[0]))

   const maxLen = 0xffffffffffff

   var data unsafe.Pointer
   var s32 C.uint
   var ht unsafe.Pointer
   var sht C.uint

   p := unsafe.Pointer(crule)
   C.gorulehandletrack(p, &data, &s32)
   tmp := (*[maxLen]byte)(data)[:int(s32):int(s32)]
   C.goHandletrackGet(p, &ht, &sht)
   tmp := uintptr2byte(ht, uint64(sht))
   rule.Handletrack = byte2str(tmp)

   C.goruledatatype(p, &data, &s32)
   tmp = (*[maxLen]byte)(data)[:int(s32):int(s32)]
   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