debug

zhangmeng

2020-01-11 f78156db5df835c8230793e899ae661efef2a9d2

debug

 run.go

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

type channel struct {
    index int
    msg   chan protomsg.SdkMessage
}

//////////////////////////////////////////////////////////////////
const (
    cacheFrameNum   = 3
    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 {
    f.mapChanLock.Lock()
    defer f.mapChanLock.Unlock()

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

    c := &channel{
        index: index,
        msg:   make(chan protomsg.SdkMessage, cacheFrameNum),
    }

    f.mapChan[id] = c
    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 +164,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 +195,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.msg <- 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,23 +213,25 @@
            }
            // 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(c, out)
            c.msg <- msg
        }
    }
}

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

    dtchn := c.index
    f.fnLogger("DETECTTRACKONECHN DTCHN: ", dtchn)
    var curCid string

    for {
        select {
        case rMsg := <-in:
        case rMsg := <-c.msg:

            if !sdkhelper.ValidRemoteMessage(rMsg, f.typ, f.fnLogger) {
                sdkhelper.EjectResult(nil, rMsg, out)
@@ -218,43 +277,9 @@
        case <-time.After(trackChnTimeout * time.Second):
            f.fnLogger("Timeout to get image, curCid:", curCid)
            if curCid != "" {
                delete(f.ftrackChans, curCid)
                f.releaseChn(dtchn)
                f.channelRelease(curCid)
            }
            return
        }
    }
}

//////////////////////////////////////////////////////////////////
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()
}