copy from bgr-2-analysis

zhangmeng

2020-01-15 d85f3edab0d8c495cecd7a81f31a9ead1eb001ac

 common/helper.go

@@ -1,20 +1,22 @@
package common

import (
   "context"
   "encoding/json"
   "fmt"
   "io/ioutil"
   "strconv"
   "time"

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

const mode = deliver.PushPull

// MsgRS msg recv and snd
type MsgRS struct {
   Msg protomsg.SdkMessage
}

// GetIpcAddress get ipc
func GetIpcAddress(shm bool, id string) string {
@@ -59,109 +61,56 @@
   return i
}

// UnserilizeProto un
func UnserilizeProto(ctx context.Context, data <-chan []byte, out chan<- protomsg.SdkMessage, fn func(...interface{})) {
   for {
      select {
      case <-ctx.Done():
         return
      case d := <-data:
         if len(d) < 100 {
            continue
         }
         msg := protomsg.SdkMessage{}
         if err := proto.Unmarshal(d, &msg); err != nil {
            fn(err, " msg 处理异常")
            continue
         }

         out <- msg

      default:
         time.Sleep(10 * time.Millisecond)
      }
   }
}

// Msg2MsgSDK msg->msgsdk
func Msg2MsgSDK(msg protomsg.SdkMessage) *sdkstruct.MsgSDK {

   d, err := proto.Marshal(&msg)
   if err != nil {
      return nil
   }

   index, count := int(msg.Tasklab.Index), len(msg.Tasklab.Sdkinfos)
   if index >= count {
      return &sdkstruct.MsgSDK{
         MsgData:    d,
         SdkCount:   count,
         SdkIndex:   index,
         SdkDataLen: 0,
      }
   }

   return &sdkstruct.MsgSDK{
      MsgData:    d,
      SdkCount:   count,
      SdkIndex:   index,
      SdkDataLen: len(d),
   }
}

// EjectResult eject
func EjectResult(res []byte, msg protomsg.SdkMessage, out chan<- sdkstruct.MsgSDK) {
func EjectResult(res []byte, msg MsgRS, out chan<- MsgRS) {

   if res == nil {
      s := Msg2MsgSDK(msg)
      if s == nil {
      out <- msg
         return
      }
      out <- *s
   index := int(msg.Msg.Tasklab.Index)

   if index >= len(msg.Msg.Tasklab.Sdkinfos) {
      return
   }

   msg.Tasklab.Sdkinfos[int(msg.Tasklab.Index)].Sdkdata = res
   msg.Msg.Tasklab.Sdkinfos[index].Sdkdata = res

   s := Msg2MsgSDK(msg)
   if s == nil {
      return
   }
   out <- *s
   out <- msg
}

/////////////////////////////////////////////////////////////

// ValidRemoteMessage valid or not
func ValidRemoteMessage(msg protomsg.SdkMessage, fnName string, fn func(...interface{})) bool {
   if msg.Tasklab == nil {
func ValidRemoteMessage(msg MsgRS, fnName string, fn func(...interface{})) bool {
   if msg.Msg.Tasklab == nil {
      fn(fnName, " recieve msg nil")
      return false
   }

   sdkLen := len(msg.Tasklab.Sdkinfos)
   sdkLen := len(msg.Msg.Tasklab.Sdkinfos)
   if sdkLen == 0 {
      fn(fnName, " has no sdk info")
      return false
   }

   curIndex := int(msg.Tasklab.Index)
   curIndex := int(msg.Msg.Tasklab.Index)
   if curIndex < 0 || curIndex >= sdkLen {
      fn(fnName, " tasklab index ", curIndex, " error")
      return false
   }
   if msg.Tasklab.Sdkinfos[curIndex].Sdktype != fnName {
      fn(fnName, " is different from ", msg.Tasklab.Sdkinfos[curIndex].Sdktype)
   if msg.Msg.Tasklab.Sdkinfos[curIndex].Sdktype != fnName {
      fn(fnName, " is different from ", msg.Msg.Tasklab.Sdkinfos[curIndex].Sdktype)
      return false
   }
   return true
}

// UnpackImage unpack
func UnpackImage(msg protomsg.SdkMessage, fnName string, fn func(...interface{})) *protomsg.Image {
func UnpackImage(msg MsgRS, fnName string, fn func(...interface{})) *protomsg.Image {
   // 反序列化数据得到sdk入参
   i := &protomsg.Image{}
   err := proto.Unmarshal(msg.Data, i)
   err := proto.Unmarshal(msg.Msg.Data, i)
   if err != nil {
      fn(fnName, " protobuf decode CameraImage error: ", err.Error())
      return nil