copy from VAProcess

zhangmeng

2019-12-11 2f5f0c75f3257b4ea9c37df6d02e5598b975740f

 work/sdk/fdetect.go

@@ -4,22 +4,13 @@
   "analysis/logo"
   "analysis/work"
   "context"
   "plugin"
   "sync"

   "basic.com/libgowrapper/sdkstruct.git"

   "basic.com/valib/gogpu.git"
   "basic.com/valib/gosdk.git"
)

type faceInfo struct {
   pos  gosdk.CFacePos
   id   uint64
   life int
}

type fTrackInfo struct {
   lastTrackInfos []faceInfo
   lastTrackID    uint64
}

const MaxFaceDetectThreadNum = 32

@@ -29,32 +20,63 @@
   iGPU    int

   // track
   faceAngle   int
   dftfacenum  int
   dftinterval int
   sampleSize  int

   // external track
   tracker map[string]*fTrackInfo
   faceAngle  int
   faceNum    int
   interval   int
   sampleSize int

   ftrackChans     map[string]chan work.MsgRS
   ftrackChannels  map[string]int
   ftrackChanStats []bool
   chnLock         sync.Mutex

   handle          interface{}
   fnInit          func() interface{}
   fnFree          func(interface{})
   fnRun           func(interface{}, []byte, int, int, int, int) []sdkstruct.CFaceResult
   fnTrackerResize func(interface{}, int, int, int) bool
   fnExtractor     func(interface{}, int, int) bool
   fnPropertizer   func(interface{}, int) bool
   fnTracker       func(interface{}, int, int, int, int, int, int, int) bool
}

// NewEFDetectWithTrack with track
func NewEFDetectWithTrack(gi, thrds, faceNum, faceAngle, interval, samp int) *EFDetect {
   soFile := "libface.so"

   plug, err := plugin.Open(soFile)
   if err != nil {
      logo.Errorln("Open: ", soFile, " error: ", err)
      return nil
   }

   fnInit, _ := LoadFunc(plug, soFile, "NewSDK")
   fnFree, _ := LoadFunc(plug, soFile, "Free")
   fnRun, _ := LoadFunc(plug, soFile, "Run")
   fnTrackerResize, _ := LoadFunc(plug, soFile, "TrackerResize")
   fnExtractor, _ := LoadFunc(plug, soFile, "Extractor")
   fnPropertizer, _ := LoadFunc(plug, soFile, "Propertizer")
   fnTracker, _ := LoadFunc(plug, soFile, "Tracker")

   return &EFDetect{
      threads:         thrds,
      faceAngle:       faceAngle,
      ftrackChans:     make(map[string]chan work.MsgRS, MaxFaceDetectThreadNum),
      ftrackChannels:  make(map[string]int, MaxFaceDetectThreadNum),
      ftrackChanStats: make([]bool, MaxFaceDetectThreadNum, MaxFaceDetectThreadNum),
      dftfacenum:      faceNum,
      dftinterval:     interval,
      faceNum:         faceNum,
      interval:        interval,
      iGPU:            gi,
      sampleSize:      samp,

      handle:          nil,
      fnInit:          fnInit.(func() interface{}),
      fnFree:          fnFree.(func(interface{})),
      fnRun:           fnRun.(func(interface{}, []byte, int, int, int, int) []sdkstruct.CFaceResult),
      fnTrackerResize: fnTrackerResize.(func(interface{}, int, int, int) bool),
      fnExtractor:     fnExtractor.(func(interface{}, int, int) bool),
      fnPropertizer:   fnPropertizer.(func(interface{}, int) bool),
      fnTracker:       fnTracker.(func(interface{}, int, int, int, int, int, int, int) bool),
   }
}

@@ -75,12 +97,22 @@
      gpu = gogpu.ValidGPU(2048)
   }

   gosdk.InitFaceTracker(e.threads, gpu, 1280, 720, e.dftfacenum, e.dftinterval, e.sampleSize) // i not work
   logo.Infoln("ftrack use gpu: ", gpu)
   e.handle = e.fnInit()

   gosdk.InitFaceProperty(e.threads)
   gosdk.InitFaceExtractor(e.threads, gpu)
   logo.Infoln("fextract use gpu: ", gpu)
   if !e.fnTracker(e.handle, 1280, 720, e.faceNum, e.interval, e.sampleSize, e.threads, gpu) {
      logo.Errorln("FACE TRACKER CREATE ERROR")
   }
   logo.Infoln("Face Tracker Use GPU: ", gpu)

   if !e.fnPropertizer(e.handle, e.threads) {
      logo.Errorln("FACE PROPERTIZER CREATE ERROR")
   }

   if !e.fnExtractor(e.handle, e.threads, gpu) {
      logo.Errorln("FACE EXTRACTOR CREATE ERROR")
   }

   logo.Infoln("Face Extractor Use GPU: ", gpu)
}

// Run impl interface