debug

zhangmeng

2020-01-13 51f95d190fb7950638a2896cdd1fef7c6ed2b08f

 run.go

@@ -12,15 +12,75 @@
   "basic.com/valib/gogpu.git"
)

type channel struct {
   index int
   msgs  *sdkhelper.LockList
}

//////////////////////////////////////////////////////////////////
const (
   trackChnTimeout = time.Duration(10)
)

func (f *face) channelAvailable() int {
   f.mapChanLock.Lock()
   defer f.mapChanLock.Unlock()

   for i := 0; i < f.maxChannel; i++ {
      found := false
      for _, v := range f.mapChan {
         if v.index == i {
            found = true
            break
         }
      }
      if !found {
         return i
      }
   }
   return -1
}

func (f *face) channelRelease(id string) {
   f.mapChanLock.Lock()
   defer f.mapChanLock.Unlock()

   delete(f.mapChan, id)
}

func (f *face) channelExist(id string) (*channel, bool) {
   f.mapChanLock.Lock()
   defer f.mapChanLock.Unlock()

   c, ok := f.mapChan[id]
   return c, ok
}

func (f *face) channelNew(id string) *channel {

   index := f.channelAvailable()
   if index < 0 {
      return nil
   }

   f.mapChanLock.Lock()
   c := &channel{
      index: index,
      msgs:  sdkhelper.NewLockList(3),
   }
   f.mapChan[id] = c
   f.mapChanLock.Unlock()

   return c
}

type face struct {
   handle *SDKFace
   list   *sdkhelper.LockList

   maxChannel      int
   ftrackChans     map[string]chan protomsg.SdkMessage
   ftrackChannels  map[string]int
   ftrackChanStats []bool
   chnLock         sync.Mutex
   maxChannel  int
   mapChan     map[string]*channel
   mapChanLock sync.Mutex

   fnLogger func(...interface{})

@@ -103,10 +163,8 @@
      handle: handle,
      list:   sdkhelper.NewLockList(maxChan + maxChan/2),

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

      fnLogger: fn,

@@ -136,18 +194,16 @@
func (f *face) run(msgs []protomsg.SdkMessage, out chan<- sdkstruct.MsgSDK, typ string) {

   for _, msg := range msgs {
      if _, ok := f.ftrackChans[msg.Cid]; ok {
         f.ftrackChans[msg.Cid] <- msg
      if c, ok := f.channelExist(msg.Cid); ok {
         c.msgs.Push(msg)
      } else {

         f.ftrackChans[msg.Cid] = make(chan protomsg.SdkMessage, cacheFrameNum)
         chn := f.getAvailableChn()
         if chn < 0 {
         nc := f.channelNew(msg.Cid)
         if nc == nil {
            f.fnLogger("TOO MUCH CHANNEL")
            sdkhelper.EjectResult(nil, msg, out)
            continue
         }
         f.ftrackChannels[msg.Cid] = chn

         i := sdkhelper.UnpackImage(msg, f.typ, f.fnLogger)
         if i == nil {
@@ -156,105 +212,68 @@
         }
         // conv to bgr24 and resize
         imgW, imgH := int(i.Width), int(i.Height)
         ret := f.handle.TrackerResize(imgW, imgH, chn)
         f.fnLogger("ResizeFaceTracker: cid: ", msg.Cid, " chan: ", chn, " wXh: ", imgW, "x", imgH, " result:", ret)
         go f.detectTrackOneChn(f.ftrackChans[msg.Cid], out, chn)
         f.ftrackChans[msg.Cid] <- msg
         ret := f.handle.TrackerResize(imgW, imgH, nc.index)
         f.fnLogger("ResizeFaceTracker: cid: ", msg.Cid, " chan: ", nc.index, " wXh: ", imgW, "x", imgH, " result:", ret)
         go f.detectTrackOneChn(nc, out)
         nc.msgs.Push(msg)
      }
   }
}

func (f *face) detectTrackOneChn(in <-chan protomsg.SdkMessage, out chan<- sdkstruct.MsgSDK, dtchn int) {
   tm := time.Now()
   sc := 0
   f.fnLogger("DETECTTRACKONECHN DTCHN: ", dtchn)
func (f *face) detectTrackOneChn(c *channel, out chan<- sdkstruct.MsgSDK) {

   dtchn := c.index
   var curCid string

   for {
      select {
      case rMsg := <-in:

         if !sdkhelper.ValidRemoteMessage(rMsg, f.typ, f.fnLogger) {
            sdkhelper.EjectResult(nil, rMsg, out)
            f.fnLogger("Face!!!!!!SkdMessage Invalid")

            continue
         }

         i := sdkhelper.UnpackImage(rMsg, f.typ, f.fnLogger)
         if i == nil || i.Data == nil || i.Width <= 0 || i.Height <= 0 {
            sdkhelper.EjectResult(nil, rMsg, out)
            f.fnLogger("Face!!!!!!Unpack Image From SkdMessage Failed")

            continue
         }

         curCid = i.Cid

         // conv to bgr24 and resize
         imgW, imgH := int(i.Width), int(i.Height)

         count, data, _ := f.handle.Run(i.Data, imgW, imgH, 3, dtchn)

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

         sc++
         if sc == 25 {
            f.fnLogger("CHAN:%d, FACE RUN 25 FRAME USE TIME: ", dtchn, time.Since(tm))
            sc = 0
            tm = time.Now()
         }

         if time.Since(tm) > time.Second {
            f.fnLogger("CHAN: ", dtchn, " FACE RUN ", sc, " FRAME USE TIME: ", time.Since(tm))
            sc = 0
            tm = time.Now()
         }
      case <-time.After(trackChnTimeout * time.Second):
         f.fnLogger("Timeout to get image, curCid:", curCid)
         f.fnLogger("######Timeout to get image, curCid:", curCid, " Chan:", dtchn)
         if curCid != "" {
            delete(f.ftrackChans, curCid)
            f.releaseChn(dtchn)
            f.channelRelease(curCid)
         }
         return
      default:
         // f.fnLogger("DETECTTRACKONECHN DTCHN: ", dtchn)

         elems := c.msgs.Drain()
         var msgs []protomsg.SdkMessage
         for _, v := range elems {
            msgs = append(msgs, v.(protomsg.SdkMessage))
         }
         for _, rMsg := range msgs {

            if !sdkhelper.ValidRemoteMessage(rMsg, f.typ, f.fnLogger) {
               sdkhelper.EjectResult(nil, rMsg, out)
               f.fnLogger("Face!!!!!!SkdMessage Invalid: ", dtchn)

               continue
            }

            i := sdkhelper.UnpackImage(rMsg, f.typ, f.fnLogger)
            if i == nil || i.Data == nil || i.Width <= 0 || i.Height <= 0 {
               sdkhelper.EjectResult(nil, rMsg, out)
               f.fnLogger("Face!!!!!!Unpack Image From SkdMessage Failed: ", dtchn)

               continue
            }

            curCid = i.Cid

            // conv to bgr24 and resize
            imgW, imgH := int(i.Width), int(i.Height)

            count, data, _ := f.handle.Run(i.Data, imgW, imgH, 3, dtchn)

            sdkhelper.EjectResult(data, rMsg, out)

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

//////////////////////////////////////////////////////////////////
const (
   cacheFrameNum   = 3
   trackChnTimeout = time.Duration(10)
)

func (f *face) cleanChnStat() {
   f.chnLock.Lock()
   for i := 0; i < f.maxChannel; i++ {
      f.ftrackChanStats[i] = false
   }
   f.chnLock.Unlock()
}

func (f *face) getAvailableChn() int {
   f.chnLock.Lock()
   defer f.chnLock.Unlock()

   for i := 0; i < f.maxChannel; i++ {
      if f.ftrackChanStats[i] == false {
         f.ftrackChanStats[i] = true
         return i
      }
   }
   return -1
}

func (f *face) releaseChn(chn int) {
   f.chnLock.Lock()
   f.ftrackChanStats[chn] = false
   f.chnLock.Unlock()
}