debug

zhangmeng

2020-01-15 0ffd95f2278e860736e46f8b73f357470f5a3d91

 run.go

@@ -5,12 +5,13 @@
   "os"
   "sync"
   "time"
   "unsafe"

   "basic.com/libgowrapper/sdkhelper.git"
   "face/common"

   "basic.com/libgowrapper/sdkstruct.git"
   "basic.com/pubsub/protomsg.git"
   "basic.com/valib/gogpu.git"
   "github.com/gogo/protobuf/proto"
)

const maxTryBeforeReboot = 10
@@ -19,7 +20,7 @@
   handle *SDKFace

   maxChannel      int
   ftrackChans     map[string]chan protomsg.SdkMessage
   ftrackChans     map[string]chan common.MsgRS
   ftrackChannels  map[string]int
   ftrackChanStats []bool
   chnLock         sync.Mutex
@@ -76,7 +77,7 @@
      fn("Face SDK Create Error When New SDK")
      return nil
   }
   cfg, err := sdkhelper.ReadConfig(config)
   cfg, err := common.ReadConfig(config)
   if err != nil {
      fn("Face SDK Create Error When Read Config: ", err)
      return nil
@@ -104,9 +105,9 @@
   }

   w, h, detThrd, detNum, detAngle, propThrd, extThrd, trckInterval, trckSmpl, maxChan, gpuM :=
      1280, 720, sdkhelper.Atoi(cfg.Param[dt]), sdkhelper.Atoi(cfg.Param[dn]), sdkhelper.Atoi(cfg.Param[da]),
      sdkhelper.Atoi(cfg.Param[pt]), sdkhelper.Atoi(cfg.Param[et]), sdkhelper.Atoi(cfg.Param[ti]), sdkhelper.Atoi(cfg.Param[ts]),
      sdkhelper.Atoi(cfg.Param[mc]), sdkhelper.Atoi(cfg.Param[gm])
      1280, 720, common.Atoi(cfg.Param[dt]), common.Atoi(cfg.Param[dn]), common.Atoi(cfg.Param[da]),
      common.Atoi(cfg.Param[pt]), common.Atoi(cfg.Param[et]), common.Atoi(cfg.Param[ti]), common.Atoi(cfg.Param[ts]),
      common.Atoi(cfg.Param[mc]), common.Atoi(cfg.Param[gm])

   if detAngle > 0 {
   }
@@ -139,7 +140,7 @@
      handle: handle,

      maxChannel:      maxChan,
      ftrackChans:     make(map[string]chan protomsg.SdkMessage, maxChan),
      ftrackChans:     make(map[string]chan common.MsgRS, maxChan),
      ftrackChannels:  make(map[string]int, maxChan),
      ftrackChanStats: make([]bool, maxChan, maxChan),

@@ -171,14 +172,14 @@
      postPull = `_1`
      postPush = `_2`
   )
   ipcRcv := sdkhelper.GetIpcAddress(s.shm, s.id+postPull)
   ipcSnd := sdkhelper.GetIpcAddress(s.shm, s.id+postPush)
   chRcv := make(chan []byte, s.maxChannel)
   chSnd := make(chan sdkstruct.MsgSDK, s.maxChannel)
   ipcRcv := common.GetIpcAddress(s.shm, s.id+postPull)
   ipcSnd := common.GetIpcAddress(s.shm, s.id+postPush)
   chRcv := make(chan common.MsgRS, s.maxChannel)
   chSnd := make(chan common.MsgRS, s.maxChannel)

   rcver := sdkhelper.NewReciever(ipcRcv, chRcv, s.shm, s.fnLogger)
   snder := sdkhelper.NewSender(ipcSnd, chSnd, s.shm, s.fnLogger)
   torule := sdkhelper.NewToRule(s.ipc2Rule, s.ruleMsgMaxCacheSize, s.fnLogger)
   rcver := common.NewReciever(ipcRcv, chRcv, s.shm, s.fnLogger)
   snder := common.NewSender(ipcSnd, chSnd, s.shm, s.fnLogger)
   torule := common.NewToRule(s.ipc2Rule, s.ruleMsgMaxCacheSize, s.fnLogger)

   snder.ApplyCallbackFunc(torule.Push)

@@ -223,48 +224,45 @@
   f.chnLock.Unlock()
}

func (f *face) run(ctx context.Context, in <-chan []byte, out chan<- sdkstruct.MsgSDK) {

   chMsg := make(chan protomsg.SdkMessage, f.maxChannel)
   go sdkhelper.UnserilizeProto(ctx, in, chMsg, f.fnLogger)
func (f *face) run(ctx context.Context, in <-chan common.MsgRS, out chan<- common.MsgRS) {

   for {
      select {
      case <-ctx.Done():
         f.handle.Free()
         return
      case rMsg := <-chMsg:
         if !sdkhelper.ValidRemoteMessage(rMsg, f.typ, f.fnLogger) {
      case rMsg := <-in:
         if !common.ValidRemoteMessage(rMsg, f.typ, f.fnLogger) {
            f.fnLogger("FACE TRACK VALIDREMOTEMESSAGE INVALID")
            sdkhelper.EjectResult(nil, rMsg, out)
            common.EjectResult(nil, rMsg, out)
            continue
         }

         if _, ok := f.ftrackChans[rMsg.Cid]; ok {
         if _, ok := f.ftrackChans[rMsg.Msg.Cid]; ok {
            f.fnLogger("Face Cache Size: ", len(f.ftrackChans))
            f.ftrackChans[rMsg.Cid] <- rMsg
            f.ftrackChans[rMsg.Msg.Cid] <- rMsg
         } else {

            f.ftrackChans[rMsg.Cid] = make(chan protomsg.SdkMessage, f.maxChannel)
            f.ftrackChans[rMsg.Msg.Cid] = make(chan common.MsgRS, f.maxChannel)
            chn := f.getAvailableChn()
            if chn < 0 {
               f.fnLogger("TOO MUCH CHANNEL")
               sdkhelper.EjectResult(nil, rMsg, out)
               common.EjectResult(nil, rMsg, out)
               continue
            }
            f.ftrackChannels[rMsg.Cid] = chn
            f.ftrackChannels[rMsg.Msg.Cid] = chn

            i := sdkhelper.UnpackImage(rMsg, f.typ, f.fnLogger)
            i := common.UnpackImage(rMsg, f.typ, f.fnLogger)
            if i == nil {
               sdkhelper.EjectResult(nil, rMsg, out)
               common.EjectResult(nil, rMsg, out)
               continue
            }
            // conv to bgr24 and resize
            imgW, imgH := int(i.Width), int(i.Height)
            ret := f.handle.TrackerResize(imgW, imgH, chn)
            f.fnLogger("ResizeFaceTracker: cid: ", rMsg.Cid, " chan: ", chn, " wXh: ", imgW, "x", imgH, " result:", ret)
            go f.detectTrackOneChn(ctx, f.ftrackChans[rMsg.Cid], out, chn)
            f.ftrackChans[rMsg.Cid] <- rMsg
            f.fnLogger("ResizeFaceTracker: cid: ", rMsg.Msg.Cid, " chan: ", chn, " wXh: ", imgW, "x", imgH, " result:", ret)
            go f.detectTrackOneChn(ctx, f.ftrackChans[rMsg.Msg.Cid], out, chn)
            f.ftrackChans[rMsg.Msg.Cid] <- rMsg
         }
      default:
         time.Sleep(time.Millisecond * 100)
@@ -272,7 +270,7 @@
   }
}

func (f *face) detectTrackOneChn(ctx context.Context, in <-chan protomsg.SdkMessage, out chan<- sdkstruct.MsgSDK, dtchn int) {
func (f *face) detectTrackOneChn(ctx context.Context, in <-chan common.MsgRS, out chan<- common.MsgRS, dtchn int) {
   tm := time.Now()
   sc := 0
   f.fnLogger("DETECTTRACKONECHN DTCHN: ", dtchn)
@@ -285,14 +283,14 @@

      case rMsg := <-in:

         if !sdkhelper.ValidRemoteMessage(rMsg, f.typ, f.fnLogger) {
            sdkhelper.EjectResult(nil, rMsg, out)
         if !common.ValidRemoteMessage(rMsg, f.typ, f.fnLogger) {
            common.EjectResult(nil, rMsg, out)
            continue
         }

         i := sdkhelper.UnpackImage(rMsg, f.typ, f.fnLogger)
         i := common.UnpackImage(rMsg, f.typ, f.fnLogger)
         if i == nil || i.Data == nil || i.Width <= 0 || i.Height <= 0 {
            sdkhelper.EjectResult(nil, rMsg, out)
            common.EjectResult(nil, rMsg, out)
            continue
         }

@@ -301,20 +299,69 @@
         // conv to bgr24 and resize
         imgW, imgH := int(i.Width), int(i.Height)

         f.fnLogger("Face Start Run:", dtchn, "CAMERAID: ", rMsg.Cid)
         // f.fnLogger("Face~~~Track", dtchn)
         detect := f.handle.Track(i.Data, imgW, imgH, 3, dtchn)
         // f.fnLogger("Face~~~Track Over", dtchn)

         count, data, _ := f.handle.Run(i.Data, imgW, imgH, 3, dtchn)
         var faces []*protomsg.ResultFaceDetect

         sdkhelper.EjectResult(data, rMsg, out)
         //将sdk返回值转换成protomsg类型
         for _, d := range detect {

            //运行sd
            // f.fnLogger("Face~~~FaceInfo2FacePos", dtchn)
            dec := FaceInfo2FacePos(d)
            // f.fnLogger("Face~~~FaceInfo2FacePos over", dtchn)

            // f.fnLogger("Face~~~Propertize", dtchn)
            prop := f.handle.Propertize(dec, i.Data, imgW, imgH, 3, dtchn)
            // f.fnLogger("Face~~~Propertize Over", dtchn)

            f.fnLogger("Face~~~Extract", dtchn)
            feat := f.handle.Extract(dec, i.Data, imgW, imgH, 3, dtchn)
            f.fnLogger("Face~~~Extract Over", dtchn)

            // f.fnLogger("Face~~~protomsg.ThftResult", dtchn)
            resP := (*protomsg.ThftResult)(unsafe.Pointer(&prop))
            // f.fnLogger("Face~~~protomsg.ThftResult Over", dtchn)

            // f.fnLogger("Face~~~tconvert2ProtoFacePos", dtchn)
            result := tconvert2ProtoFacePos(d)
            // f.fnLogger("Face~~~tconvert2ProtoFacePos Over", dtchn)

            //组成结果并序列化
            res := &protomsg.ResultFaceDetect{Pos: result, Result: resP, Feats: feat}
            faces = append(faces, res)

         }

         var err error
         var data []byte
         if len(faces) > 0 {

            // logo.Infoln("CID: ", rMsg.Msg.Cid, " TASK: ", rMsg.Msg.Tasklab.Taskid, " FACE TRACK OBJS: ", len(faces))

            facePos := protomsg.ParamFacePos{Faces: faces}
            data, err = proto.Marshal(&facePos)
            if err != nil {
               f.fnLogger("fdetect marshal proto face pos error", err)
               data = nil
            }
         }

         // f.fnLogger("Face~~~EjectResult", dtchn)
         common.EjectResult(data, rMsg, out)
         // f.fnLogger("Face~~~EjectResult Over", dtchn)
         f.mtxRunning.Lock()
         f.running = true
         f.mtxRunning.Unlock()

         var id, name string
         if rMsg.Tasklab != nil {
            id, name = rMsg.Tasklab.Taskid, rMsg.Tasklab.Taskname
         if rMsg.Msg.Tasklab != nil {
            id, name = rMsg.Msg.Tasklab.Taskid, rMsg.Msg.Tasklab.Taskname
         }
         f.fnLogger("Chan:", dtchn, "CAMERAID: ", rMsg.Cid, " TASKID: ", id, " TASKNAME: ", name, " DETECT ", f.typ, " COUNT: ", count)

         f.fnLogger("Chan:", dtchn, "CAMERAID: ", rMsg.Msg.Cid, " TASKID: ", id, " TASKNAME: ", name, " DETECT ", f.typ, " COUNT: ", len(faces))

         sc++
         if sc == 25 {