add skd structures

zhangmeng

2019-05-20 d3817713b726cade529a0c3c287a05a97ae3a924

add skd structures

 protomsg.pb.go

@@ -4,6 +4,7 @@
package protomsg

import (
    encoding_binary "encoding/binary"
    fmt "fmt"
    proto "github.com/gogo/protobuf/proto"
    io "io"
@@ -202,31 +203,594 @@
    return nil
}

// struct for sdk
type Point struct {
    X int32 `protobuf:"varint,1,opt,name=x,proto3" json:"x,omitempty"`
    Y int32 `protobuf:"varint,2,opt,name=y,proto3" json:"y,omitempty"`
}

func (m *Point) Reset()         { *m = Point{} }
func (m *Point) String() string { return proto.CompactTextString(m) }
func (*Point) ProtoMessage()    {}
func (*Point) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{3}
}
func (m *Point) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
}
func (m *Point) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    if deterministic {
        return xxx_messageInfo_Point.Marshal(b, m, deterministic)
    } else {
        b = b[:cap(b)]
        n, err := m.MarshalTo(b)
        if err != nil {
            return nil, err
        }
        return b[:n], nil
    }
}
func (m *Point) XXX_Merge(src proto.Message) {
    xxx_messageInfo_Point.Merge(m, src)
}
func (m *Point) XXX_Size() int {
    return m.Size()
}
func (m *Point) XXX_DiscardUnknown() {
    xxx_messageInfo_Point.DiscardUnknown(m)
}

var xxx_messageInfo_Point proto.InternalMessageInfo

func (m *Point) GetX() int32 {
    if m != nil {
        return m.X
    }
    return 0
}

func (m *Point) GetY() int32 {
    if m != nil {
        return m.Y
    }
    return 0
}

type Rect struct {
    Left   int32 `protobuf:"varint,1,opt,name=left,proto3" json:"left,omitempty"`
    Top    int32 `protobuf:"varint,2,opt,name=top,proto3" json:"top,omitempty"`
    Right  int32 `protobuf:"varint,3,opt,name=right,proto3" json:"right,omitempty"`
    Bottom int32 `protobuf:"varint,4,opt,name=bottom,proto3" json:"bottom,omitempty"`
}

func (m *Rect) Reset()         { *m = Rect{} }
func (m *Rect) String() string { return proto.CompactTextString(m) }
func (*Rect) ProtoMessage()    {}
func (*Rect) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{4}
}
func (m *Rect) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
}
func (m *Rect) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    if deterministic {
        return xxx_messageInfo_Rect.Marshal(b, m, deterministic)
    } else {
        b = b[:cap(b)]
        n, err := m.MarshalTo(b)
        if err != nil {
            return nil, err
        }
        return b[:n], nil
    }
}
func (m *Rect) XXX_Merge(src proto.Message) {
    xxx_messageInfo_Rect.Merge(m, src)
}
func (m *Rect) XXX_Size() int {
    return m.Size()
}
func (m *Rect) XXX_DiscardUnknown() {
    xxx_messageInfo_Rect.DiscardUnknown(m)
}

var xxx_messageInfo_Rect proto.InternalMessageInfo

func (m *Rect) GetLeft() int32 {
    if m != nil {
        return m.Left
    }
    return 0
}

func (m *Rect) GetTop() int32 {
    if m != nil {
        return m.Top
    }
    return 0
}

func (m *Rect) GetRight() int32 {
    if m != nil {
        return m.Right
    }
    return 0
}

func (m *Rect) GetBottom() int32 {
    if m != nil {
        return m.Bottom
    }
    return 0
}

type FaceAngle struct {
    Yaw        int32   `protobuf:"varint,1,opt,name=yaw,proto3" json:"yaw,omitempty"`
    Pitch      int32   `protobuf:"varint,2,opt,name=pitch,proto3" json:"pitch,omitempty"`
    Roll       int32   `protobuf:"varint,3,opt,name=roll,proto3" json:"roll,omitempty"`
    Confidence float32 `protobuf:"fixed32,4,opt,name=confidence,proto3" json:"confidence,omitempty"`
}

func (m *FaceAngle) Reset()         { *m = FaceAngle{} }
func (m *FaceAngle) String() string { return proto.CompactTextString(m) }
func (*FaceAngle) ProtoMessage()    {}
func (*FaceAngle) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{5}
}
func (m *FaceAngle) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
}
func (m *FaceAngle) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    if deterministic {
        return xxx_messageInfo_FaceAngle.Marshal(b, m, deterministic)
    } else {
        b = b[:cap(b)]
        n, err := m.MarshalTo(b)
        if err != nil {
            return nil, err
        }
        return b[:n], nil
    }
}
func (m *FaceAngle) XXX_Merge(src proto.Message) {
    xxx_messageInfo_FaceAngle.Merge(m, src)
}
func (m *FaceAngle) XXX_Size() int {
    return m.Size()
}
func (m *FaceAngle) XXX_DiscardUnknown() {
    xxx_messageInfo_FaceAngle.DiscardUnknown(m)
}

var xxx_messageInfo_FaceAngle proto.InternalMessageInfo

func (m *FaceAngle) GetYaw() int32 {
    if m != nil {
        return m.Yaw
    }
    return 0
}

func (m *FaceAngle) GetPitch() int32 {
    if m != nil {
        return m.Pitch
    }
    return 0
}

func (m *FaceAngle) GetRoll() int32 {
    if m != nil {
        return m.Roll
    }
    return 0
}

func (m *FaceAngle) GetConfidence() float32 {
    if m != nil {
        return m.Confidence
    }
    return 0
}

type ThftResult struct {
    Gender int32 `protobuf:"varint,1,opt,name=gender,proto3" json:"gender,omitempty"`
    Age    int32 `protobuf:"varint,2,opt,name=age,proto3" json:"age,omitempty"`
    Race   int32 `protobuf:"varint,3,opt,name=race,proto3" json:"race,omitempty"`
    Beauty int32 `protobuf:"varint,4,opt,name=beauty,proto3" json:"beauty,omitempty"`
    Smile  int32 `protobuf:"varint,5,opt,name=smile,proto3" json:"smile,omitempty"`
}

func (m *ThftResult) Reset()         { *m = ThftResult{} }
func (m *ThftResult) String() string { return proto.CompactTextString(m) }
func (*ThftResult) ProtoMessage()    {}
func (*ThftResult) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{6}
}
func (m *ThftResult) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
}
func (m *ThftResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    if deterministic {
        return xxx_messageInfo_ThftResult.Marshal(b, m, deterministic)
    } else {
        b = b[:cap(b)]
        n, err := m.MarshalTo(b)
        if err != nil {
            return nil, err
        }
        return b[:n], nil
    }
}
func (m *ThftResult) XXX_Merge(src proto.Message) {
    xxx_messageInfo_ThftResult.Merge(m, src)
}
func (m *ThftResult) XXX_Size() int {
    return m.Size()
}
func (m *ThftResult) XXX_DiscardUnknown() {
    xxx_messageInfo_ThftResult.DiscardUnknown(m)
}

var xxx_messageInfo_ThftResult proto.InternalMessageInfo

func (m *ThftResult) GetGender() int32 {
    if m != nil {
        return m.Gender
    }
    return 0
}

func (m *ThftResult) GetAge() int32 {
    if m != nil {
        return m.Age
    }
    return 0
}

func (m *ThftResult) GetRace() int32 {
    if m != nil {
        return m.Race
    }
    return 0
}

func (m *ThftResult) GetBeauty() int32 {
    if m != nil {
        return m.Beauty
    }
    return 0
}

func (m *ThftResult) GetSmile() int32 {
    if m != nil {
        return m.Smile
    }
    return 0
}

type FacePos struct {
    RcFace     *Rect      `protobuf:"bytes,1,opt,name=rcFace,proto3" json:"rcFace,omitempty"`
    PtLeftEye  *Point     `protobuf:"bytes,2,opt,name=ptLeftEye,proto3" json:"ptLeftEye,omitempty"`
    PtRightEye *Point     `protobuf:"bytes,3,opt,name=ptRightEye,proto3" json:"ptRightEye,omitempty"`
    PtMouth    *Point     `protobuf:"bytes,4,opt,name=ptMouth,proto3" json:"ptMouth,omitempty"`
    PtNose     *Point     `protobuf:"bytes,5,opt,name=ptNose,proto3" json:"ptNose,omitempty"`
    FAngle     *FaceAngle `protobuf:"bytes,6,opt,name=fAngle,proto3" json:"fAngle,omitempty"`
    Quality    int32      `protobuf:"varint,7,opt,name=quality,proto3" json:"quality,omitempty"`
    FacialData []byte     `protobuf:"bytes,8,opt,name=facialData,proto3" json:"facialData,omitempty"`
}

func (m *FacePos) Reset()         { *m = FacePos{} }
func (m *FacePos) String() string { return proto.CompactTextString(m) }
func (*FacePos) ProtoMessage()    {}
func (*FacePos) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{7}
}
func (m *FacePos) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
}
func (m *FacePos) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    if deterministic {
        return xxx_messageInfo_FacePos.Marshal(b, m, deterministic)
    } else {
        b = b[:cap(b)]
        n, err := m.MarshalTo(b)
        if err != nil {
            return nil, err
        }
        return b[:n], nil
    }
}
func (m *FacePos) XXX_Merge(src proto.Message) {
    xxx_messageInfo_FacePos.Merge(m, src)
}
func (m *FacePos) XXX_Size() int {
    return m.Size()
}
func (m *FacePos) XXX_DiscardUnknown() {
    xxx_messageInfo_FacePos.DiscardUnknown(m)
}

var xxx_messageInfo_FacePos proto.InternalMessageInfo

func (m *FacePos) GetRcFace() *Rect {
    if m != nil {
        return m.RcFace
    }
    return nil
}

func (m *FacePos) GetPtLeftEye() *Point {
    if m != nil {
        return m.PtLeftEye
    }
    return nil
}

func (m *FacePos) GetPtRightEye() *Point {
    if m != nil {
        return m.PtRightEye
    }
    return nil
}

func (m *FacePos) GetPtMouth() *Point {
    if m != nil {
        return m.PtMouth
    }
    return nil
}

func (m *FacePos) GetPtNose() *Point {
    if m != nil {
        return m.PtNose
    }
    return nil
}

func (m *FacePos) GetFAngle() *FaceAngle {
    if m != nil {
        return m.FAngle
    }
    return nil
}

func (m *FacePos) GetQuality() int32 {
    if m != nil {
        return m.Quality
    }
    return 0
}

func (m *FacePos) GetFacialData() []byte {
    if m != nil {
        return m.FacialData
    }
    return nil
}

type FaceInfo struct {
    RcFace     *Rect      `protobuf:"bytes,1,opt,name=rcFace,proto3" json:"rcFace,omitempty"`
    PtLeftEye  *Point     `protobuf:"bytes,2,opt,name=ptLeftEye,proto3" json:"ptLeftEye,omitempty"`
    PtRightEye *Point     `protobuf:"bytes,3,opt,name=ptRightEye,proto3" json:"ptRightEye,omitempty"`
    PtMouth    *Point     `protobuf:"bytes,4,opt,name=ptMouth,proto3" json:"ptMouth,omitempty"`
    PtNose     *Point     `protobuf:"bytes,5,opt,name=ptNose,proto3" json:"ptNose,omitempty"`
    FAngle     *FaceAngle `protobuf:"bytes,6,opt,name=fAngle,proto3" json:"fAngle,omitempty"`
    Quality    int32      `protobuf:"varint,7,opt,name=quality,proto3" json:"quality,omitempty"`
    FacialData []byte     `protobuf:"bytes,8,opt,name=facialData,proto3" json:"facialData,omitempty"`
    FaceID     int64      `protobuf:"varint,9,opt,name=faceID,proto3" json:"faceID,omitempty"`
}

func (m *FaceInfo) Reset()         { *m = FaceInfo{} }
func (m *FaceInfo) String() string { return proto.CompactTextString(m) }
func (*FaceInfo) ProtoMessage()    {}
func (*FaceInfo) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{8}
}
func (m *FaceInfo) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
}
func (m *FaceInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    if deterministic {
        return xxx_messageInfo_FaceInfo.Marshal(b, m, deterministic)
    } else {
        b = b[:cap(b)]
        n, err := m.MarshalTo(b)
        if err != nil {
            return nil, err
        }
        return b[:n], nil
    }
}
func (m *FaceInfo) XXX_Merge(src proto.Message) {
    xxx_messageInfo_FaceInfo.Merge(m, src)
}
func (m *FaceInfo) XXX_Size() int {
    return m.Size()
}
func (m *FaceInfo) XXX_DiscardUnknown() {
    xxx_messageInfo_FaceInfo.DiscardUnknown(m)
}

var xxx_messageInfo_FaceInfo proto.InternalMessageInfo

func (m *FaceInfo) GetRcFace() *Rect {
    if m != nil {
        return m.RcFace
    }
    return nil
}

func (m *FaceInfo) GetPtLeftEye() *Point {
    if m != nil {
        return m.PtLeftEye
    }
    return nil
}

func (m *FaceInfo) GetPtRightEye() *Point {
    if m != nil {
        return m.PtRightEye
    }
    return nil
}

func (m *FaceInfo) GetPtMouth() *Point {
    if m != nil {
        return m.PtMouth
    }
    return nil
}

func (m *FaceInfo) GetPtNose() *Point {
    if m != nil {
        return m.PtNose
    }
    return nil
}

func (m *FaceInfo) GetFAngle() *FaceAngle {
    if m != nil {
        return m.FAngle
    }
    return nil
}

func (m *FaceInfo) GetQuality() int32 {
    if m != nil {
        return m.Quality
    }
    return 0
}

func (m *FaceInfo) GetFacialData() []byte {
    if m != nil {
        return m.FacialData
    }
    return nil
}

func (m *FaceInfo) GetFaceID() int64 {
    if m != nil {
        return m.FaceID
    }
    return 0
}

type ObjInfo struct {
    RcObj *Rect   `protobuf:"bytes,1,opt,name=rcObj,proto3" json:"rcObj,omitempty"`
    Typ   int32   `protobuf:"varint,2,opt,name=typ,proto3" json:"typ,omitempty"`
    Prob  float32 `protobuf:"fixed32,3,opt,name=prob,proto3" json:"prob,omitempty"`
}

func (m *ObjInfo) Reset()         { *m = ObjInfo{} }
func (m *ObjInfo) String() string { return proto.CompactTextString(m) }
func (*ObjInfo) ProtoMessage()    {}
func (*ObjInfo) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{9}
}
func (m *ObjInfo) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
}
func (m *ObjInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    if deterministic {
        return xxx_messageInfo_ObjInfo.Marshal(b, m, deterministic)
    } else {
        b = b[:cap(b)]
        n, err := m.MarshalTo(b)
        if err != nil {
            return nil, err
        }
        return b[:n], nil
    }
}
func (m *ObjInfo) XXX_Merge(src proto.Message) {
    xxx_messageInfo_ObjInfo.Merge(m, src)
}
func (m *ObjInfo) XXX_Size() int {
    return m.Size()
}
func (m *ObjInfo) XXX_DiscardUnknown() {
    xxx_messageInfo_ObjInfo.DiscardUnknown(m)
}

var xxx_messageInfo_ObjInfo proto.InternalMessageInfo

func (m *ObjInfo) GetRcObj() *Rect {
    if m != nil {
        return m.RcObj
    }
    return nil
}

func (m *ObjInfo) GetTyp() int32 {
    if m != nil {
        return m.Typ
    }
    return 0
}

func (m *ObjInfo) GetProb() float32 {
    if m != nil {
        return m.Prob
    }
    return 0
}

func init() {
    proto.RegisterType((*TaskLabel)(nil), "protomsg.TaskLabel")
    proto.RegisterType((*SdkMessage)(nil), "protomsg.SdkMessage")
    proto.RegisterType((*Image)(nil), "protomsg.Image")
    proto.RegisterType((*Point)(nil), "protomsg.Point")
    proto.RegisterType((*Rect)(nil), "protomsg.Rect")
    proto.RegisterType((*FaceAngle)(nil), "protomsg.FaceAngle")
    proto.RegisterType((*ThftResult)(nil), "protomsg.ThftResult")
    proto.RegisterType((*FacePos)(nil), "protomsg.FacePos")
    proto.RegisterType((*FaceInfo)(nil), "protomsg.FaceInfo")
    proto.RegisterType((*ObjInfo)(nil), "protomsg.ObjInfo")
}

func init() { proto.RegisterFile("protomsg.proto", fileDescriptor_32de24555f916688) }

var fileDescriptor_32de24555f916688 = []byte{
    // 238 bytes of a gzipped FileDescriptorProto
    0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x8e, 0xbd, 0x4e, 0xc3, 0x30,
    0x14, 0x85, 0xe3, 0x06, 0x17, 0x7a, 0x41, 0x08, 0x99, 0x0a, 0x79, 0xb2, 0xac, 0x4c, 0x59, 0xe8,
    0x00, 0x6f, 0xc0, 0x56, 0x09, 0x06, 0x0c, 0x2f, 0x70, 0x83, 0xad, 0xc4, 0x72, 0x4b, 0x11, 0xb6,
    0x04, 0x8f, 0xc1, 0x63, 0x31, 0x66, 0x64, 0x44, 0xc9, 0x8b, 0x20, 0x3b, 0x3f, 0x13, 0xdb, 0xf9,
    0xae, 0xae, 0xbe, 0x73, 0xe0, 0xfc, 0xed, 0xfd, 0x10, 0x0e, 0x7b, 0x5f, 0x6f, 0x52, 0x60, 0x27,
    0x13, 0x17, 0x8f, 0xb0, 0x7a, 0x46, 0xef, 0xee, 0xb1, 0x32, 0x3b, 0x76, 0x05, 0xcb, 0x80, 0xde,
    0x59, 0xcd, 0x89, 0x24, 0xe5, 0x4a, 0x8d, 0x14, 0xef, 0x5e, 0x3b, 0xab, 0x3d, 0x5f, 0xc8, 0x3c,
    0xde, 0x07, 0x62, 0x6b, 0xa0, 0xf6, 0x55, 0x9b, 0x4f, 0x9e, 0x4b, 0x52, 0x52, 0x35, 0x40, 0x81,
    0x00, 0x4f, 0xda, 0x3d, 0x18, 0xef, 0xb1, 0x36, 0xec, 0x02, 0xf2, 0x97, 0x59, 0x18, 0x23, 0xbb,
    0x86, 0xe3, 0xe8, 0xdd, 0x61, 0xc5, 0x17, 0x92, 0x94, 0xa7, 0x37, 0x97, 0x9b, 0x79, 0xde, 0xbc,
    0x45, 0x4d, 0x3f, 0x8c, 0xc1, 0x91, 0xc6, 0x80, 0xa9, 0xe3, 0x4c, 0xa5, 0x5c, 0x6c, 0x81, 0x6e,
    0xf7, 0xd1, 0xbe, 0x06, 0xfa, 0x61, 0x75, 0x68, 0x92, 0x9f, 0xaa, 0x01, 0xe2, 0xde, 0xc6, 0xd8,
    0xba, 0x09, 0xa9, 0x80, 0xaa, 0x91, 0xfe, 0x53, 0xdd, 0xf1, 0xef, 0x4e, 0x90, 0xb6, 0x13, 0xe4,
    0xb7, 0x13, 0xe4, 0xab, 0x17, 0x59, 0xdb, 0x8b, 0xec, 0xa7, 0x17, 0x59, 0xb5, 0x4c, 0xab, 0x6e,
    0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0x88, 0x81, 0x6c, 0xa1, 0x3d, 0x01, 0x00, 0x00,
    // 607 bytes of a gzipped FileDescriptorProto
    0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x54, 0x4f, 0x6f, 0xd3, 0x4e,
    0x10, 0xad, 0x93, 0xda, 0x6e, 0xa6, 0x55, 0x7f, 0x3f, 0x2d, 0x15, 0xf2, 0xc9, 0x8a, 0x0c, 0x82,
    0x20, 0xd4, 0x22, 0x95, 0x4f, 0x00, 0x2a, 0x48, 0x95, 0x5a, 0x5a, 0x96, 0x72, 0xe1, 0xb6, 0xb6,
    0xd7, 0x7f, 0x1a, 0xc7, 0x6b, 0xec, 0x8d, 0x1a, 0x7f, 0x0b, 0x3e, 0x16, 0x07, 0x0e, 0x3d, 0x72,
    0x44, 0xad, 0xf8, 0x1e, 0x68, 0xc6, 0x1b, 0x27, 0x42, 0xe1, 0xc4, 0x95, 0xdb, 0xbc, 0xdd, 0x97,
    0x37, 0x6f, 0xde, 0x4e, 0x0c, 0xfb, 0x55, 0xad, 0xb4, 0x9a, 0x35, 0xe9, 0x11, 0x15, 0x6c, 0x67,
    0x89, 0x83, 0xf7, 0x30, 0xba, 0x12, 0xcd, 0xf4, 0x4c, 0x84, 0xb2, 0x60, 0x0f, 0xc1, 0xd1, 0xa2,
    0x99, 0xe6, 0xb1, 0x67, 0x8d, 0xad, 0xc9, 0x88, 0x1b, 0x84, 0xe7, 0x4d, 0x3c, 0xcd, 0xe3, 0xc6,
    0x1b, 0x8c, 0x87, 0x78, 0xde, 0x21, 0x76, 0x00, 0x76, 0x5e, 0xc6, 0x72, 0xe1, 0x0d, 0xc7, 0xd6,
    0xc4, 0xe6, 0x1d, 0x08, 0x04, 0xc0, 0x87, 0x78, 0x7a, 0x2e, 0x9b, 0x46, 0xa4, 0x92, 0xfd, 0x0f,
    0xc3, 0xa8, 0x17, 0xc4, 0x92, 0x1d, 0x82, 0x8b, 0xba, 0x85, 0x08, 0xbd, 0xc1, 0xd8, 0x9a, 0xec,
    0x1e, 0x3f, 0x38, 0xea, 0xed, 0xf5, 0x5e, 0xf8, 0x92, 0xc3, 0x18, 0x6c, 0xc7, 0x42, 0x0b, 0xea,
    0xb1, 0xc7, 0xa9, 0x0e, 0x4e, 0xc1, 0x3e, 0x9d, 0xa1, 0xfa, 0x01, 0xd8, 0x37, 0x79, 0xac, 0x33,
    0xd2, 0xb7, 0x79, 0x07, 0xd0, 0x6f, 0x26, 0xf3, 0x34, 0xd3, 0xd4, 0xc0, 0xe6, 0x06, 0x6d, 0x94,
    0x7a, 0x04, 0xf6, 0xa5, 0xca, 0x4b, 0xcd, 0xf6, 0xc0, 0x5a, 0x18, 0x19, 0x6b, 0x81, 0xa8, 0x35,
    0xbf, 0xb6, 0xda, 0xe0, 0x13, 0x6c, 0x73, 0x19, 0x91, 0x40, 0x21, 0x13, 0x6d, 0x68, 0x54, 0xe3,
    0x80, 0x5a, 0x55, 0x86, 0x8b, 0x25, 0x9a, 0xaa, 0xa9, 0xbb, 0x89, 0x85, 0x00, 0x9a, 0x0a, 0x95,
    0xd6, 0x6a, 0xe6, 0x6d, 0x77, 0xa6, 0x3a, 0x14, 0xa4, 0x30, 0x7a, 0x2b, 0x22, 0xf9, 0xaa, 0x4c,
    0x0b, 0x4a, 0xab, 0x15, 0x37, 0x46, 0x1f, 0x4b, 0x14, 0xab, 0x72, 0x1d, 0x65, 0xa6, 0x41, 0x07,
    0xd0, 0x48, 0xad, 0x8a, 0xc2, 0x74, 0xa0, 0x9a, 0xf9, 0x00, 0x91, 0x2a, 0x93, 0x3c, 0x96, 0x65,
    0x24, 0xa9, 0xc9, 0x80, 0xaf, 0x9d, 0x04, 0x0b, 0x80, 0xab, 0x2c, 0xd1, 0x5c, 0x36, 0xf3, 0x82,
    0xec, 0xa4, 0xb2, 0x8c, 0x65, 0x6d, 0x9a, 0x19, 0x84, 0x0e, 0x44, 0x2a, 0x97, 0xe3, 0x60, 0xc6,
    0xd8, 0x4b, 0x44, 0xb2, 0xef, 0x25, 0x22, 0x49, 0xc3, 0x48, 0x31, 0xd7, 0x6d, 0x3f, 0x0c, 0x21,
    0x74, 0xdb, 0xcc, 0xf2, 0x42, 0x7a, 0x76, 0xe7, 0x96, 0x40, 0xf0, 0x6d, 0x00, 0x2e, 0xce, 0x78,
    0xa9, 0x1a, 0xf6, 0x04, 0x9c, 0x3a, 0x42, 0x40, 0x7d, 0x77, 0x8f, 0xf7, 0x57, 0x8f, 0x8f, 0x11,
    0x73, 0x73, 0xcb, 0x0e, 0x61, 0x54, 0xe9, 0x33, 0x99, 0xe8, 0x37, 0xad, 0x34, 0x7b, 0xf2, 0xdf,
    0x8a, 0x4a, 0x4f, 0xc6, 0x57, 0x0c, 0xf6, 0x02, 0xa0, 0xd2, 0x1c, 0x83, 0x46, 0xfe, 0x70, 0x33,
    0x7f, 0x8d, 0xc2, 0x9e, 0x81, 0x5b, 0xe9, 0x73, 0x35, 0xd7, 0x19, 0x8d, 0xb0, 0x81, 0xbd, 0xbc,
    0x67, 0x4f, 0xc1, 0xa9, 0xf4, 0x3b, 0xd5, 0x74, 0x53, 0x6d, 0x60, 0x9a, 0x6b, 0xf6, 0x1c, 0x9c,
    0x84, 0xde, 0xd1, 0x73, 0x7e, 0x5f, 0xec, 0xfe, 0x89, 0xb9, 0xa1, 0x30, 0x0f, 0xdc, 0xcf, 0x73,
    0x51, 0xe4, 0xba, 0xf5, 0x5c, 0x0a, 0x6b, 0x09, 0xf1, 0x21, 0x13, 0x11, 0xe5, 0xa2, 0x38, 0xc1,
    0x65, 0xdd, 0xa1, 0x65, 0x5d, 0x3b, 0x09, 0x7e, 0x0e, 0x60, 0x07, 0xf5, 0x4e, 0xcb, 0x44, 0xfd,
    0xcb, 0xf3, 0xaf, 0xf3, 0xc4, 0x65, 0x4e, 0x30, 0xce, 0x13, 0x6f, 0x34, 0xb6, 0x26, 0x43, 0x6e,
    0x50, 0xf0, 0x11, 0xdc, 0x8b, 0xf0, 0x9a, 0x52, 0x7e, 0x0c, 0x76, 0x1d, 0x5d, 0x84, 0xd7, 0x7f,
    0x08, 0xb9, 0xbb, 0xa4, 0x4f, 0x41, 0xbb, 0xfa, 0x14, 0xb4, 0x15, 0xfe, 0x77, 0xaa, 0x5a, 0x85,
    0x14, 0xe0, 0x80, 0x53, 0xfd, 0xda, 0xfb, 0x7a, 0xe7, 0x5b, 0xb7, 0x77, 0xbe, 0xf5, 0xe3, 0xce,
    0xb7, 0xbe, 0xdc, 0xfb, 0x5b, 0xb7, 0xf7, 0xfe, 0xd6, 0xf7, 0x7b, 0x7f, 0x2b, 0x74, 0x48, 0xf5,
    0xe5, 0xaf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x91, 0x04, 0x9a, 0x58, 0xaf, 0x05, 0x00, 0x00,
}

func (m *TaskLabel) Marshal() (dAtA []byte, err error) {
@@ -347,6 +911,376 @@
    return i, nil
}

func (m *Point) Marshal() (dAtA []byte, err error) {
    size := m.Size()
    dAtA = make([]byte, size)
    n, err := m.MarshalTo(dAtA)
    if err != nil {
        return nil, err
    }
    return dAtA[:n], nil
}

func (m *Point) MarshalTo(dAtA []byte) (int, error) {
    var i int
    _ = i
    var l int
    _ = l
    if m.X != 0 {
        dAtA[i] = 0x8
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.X))
    }
    if m.Y != 0 {
        dAtA[i] = 0x10
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Y))
    }
    return i, nil
}

func (m *Rect) Marshal() (dAtA []byte, err error) {
    size := m.Size()
    dAtA = make([]byte, size)
    n, err := m.MarshalTo(dAtA)
    if err != nil {
        return nil, err
    }
    return dAtA[:n], nil
}

func (m *Rect) MarshalTo(dAtA []byte) (int, error) {
    var i int
    _ = i
    var l int
    _ = l
    if m.Left != 0 {
        dAtA[i] = 0x8
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Left))
    }
    if m.Top != 0 {
        dAtA[i] = 0x10
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Top))
    }
    if m.Right != 0 {
        dAtA[i] = 0x18
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Right))
    }
    if m.Bottom != 0 {
        dAtA[i] = 0x20
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Bottom))
    }
    return i, nil
}

func (m *FaceAngle) Marshal() (dAtA []byte, err error) {
    size := m.Size()
    dAtA = make([]byte, size)
    n, err := m.MarshalTo(dAtA)
    if err != nil {
        return nil, err
    }
    return dAtA[:n], nil
}

func (m *FaceAngle) MarshalTo(dAtA []byte) (int, error) {
    var i int
    _ = i
    var l int
    _ = l
    if m.Yaw != 0 {
        dAtA[i] = 0x8
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Yaw))
    }
    if m.Pitch != 0 {
        dAtA[i] = 0x10
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Pitch))
    }
    if m.Roll != 0 {
        dAtA[i] = 0x18
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Roll))
    }
    if m.Confidence != 0 {
        dAtA[i] = 0x25
        i++
        encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Confidence))))
        i += 4
    }
    return i, nil
}

func (m *ThftResult) Marshal() (dAtA []byte, err error) {
    size := m.Size()
    dAtA = make([]byte, size)
    n, err := m.MarshalTo(dAtA)
    if err != nil {
        return nil, err
    }
    return dAtA[:n], nil
}

func (m *ThftResult) MarshalTo(dAtA []byte) (int, error) {
    var i int
    _ = i
    var l int
    _ = l
    if m.Gender != 0 {
        dAtA[i] = 0x8
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Gender))
    }
    if m.Age != 0 {
        dAtA[i] = 0x10
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Age))
    }
    if m.Race != 0 {
        dAtA[i] = 0x18
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Race))
    }
    if m.Beauty != 0 {
        dAtA[i] = 0x20
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Beauty))
    }
    if m.Smile != 0 {
        dAtA[i] = 0x28
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Smile))
    }
    return i, nil
}

func (m *FacePos) Marshal() (dAtA []byte, err error) {
    size := m.Size()
    dAtA = make([]byte, size)
    n, err := m.MarshalTo(dAtA)
    if err != nil {
        return nil, err
    }
    return dAtA[:n], nil
}

func (m *FacePos) MarshalTo(dAtA []byte) (int, error) {
    var i int
    _ = i
    var l int
    _ = l
    if m.RcFace != nil {
        dAtA[i] = 0xa
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.RcFace.Size()))
        n2, err2 := m.RcFace.MarshalTo(dAtA[i:])
        if err2 != nil {
            return 0, err2
        }
        i += n2
    }
    if m.PtLeftEye != nil {
        dAtA[i] = 0x12
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.PtLeftEye.Size()))
        n3, err3 := m.PtLeftEye.MarshalTo(dAtA[i:])
        if err3 != nil {
            return 0, err3
        }
        i += n3
    }
    if m.PtRightEye != nil {
        dAtA[i] = 0x1a
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.PtRightEye.Size()))
        n4, err4 := m.PtRightEye.MarshalTo(dAtA[i:])
        if err4 != nil {
            return 0, err4
        }
        i += n4
    }
    if m.PtMouth != nil {
        dAtA[i] = 0x22
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.PtMouth.Size()))
        n5, err5 := m.PtMouth.MarshalTo(dAtA[i:])
        if err5 != nil {
            return 0, err5
        }
        i += n5
    }
    if m.PtNose != nil {
        dAtA[i] = 0x2a
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.PtNose.Size()))
        n6, err6 := m.PtNose.MarshalTo(dAtA[i:])
        if err6 != nil {
            return 0, err6
        }
        i += n6
    }
    if m.FAngle != nil {
        dAtA[i] = 0x32
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.FAngle.Size()))
        n7, err7 := m.FAngle.MarshalTo(dAtA[i:])
        if err7 != nil {
            return 0, err7
        }
        i += n7
    }
    if m.Quality != 0 {
        dAtA[i] = 0x38
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Quality))
    }
    if len(m.FacialData) > 0 {
        dAtA[i] = 0x42
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(len(m.FacialData)))
        i += copy(dAtA[i:], m.FacialData)
    }
    return i, nil
}

func (m *FaceInfo) Marshal() (dAtA []byte, err error) {
    size := m.Size()
    dAtA = make([]byte, size)
    n, err := m.MarshalTo(dAtA)
    if err != nil {
        return nil, err
    }
    return dAtA[:n], nil
}

func (m *FaceInfo) MarshalTo(dAtA []byte) (int, error) {
    var i int
    _ = i
    var l int
    _ = l
    if m.RcFace != nil {
        dAtA[i] = 0xa
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.RcFace.Size()))
        n8, err8 := m.RcFace.MarshalTo(dAtA[i:])
        if err8 != nil {
            return 0, err8
        }
        i += n8
    }
    if m.PtLeftEye != nil {
        dAtA[i] = 0x12
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.PtLeftEye.Size()))
        n9, err9 := m.PtLeftEye.MarshalTo(dAtA[i:])
        if err9 != nil {
            return 0, err9
        }
        i += n9
    }
    if m.PtRightEye != nil {
        dAtA[i] = 0x1a
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.PtRightEye.Size()))
        n10, err10 := m.PtRightEye.MarshalTo(dAtA[i:])
        if err10 != nil {
            return 0, err10
        }
        i += n10
    }
    if m.PtMouth != nil {
        dAtA[i] = 0x22
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.PtMouth.Size()))
        n11, err11 := m.PtMouth.MarshalTo(dAtA[i:])
        if err11 != nil {
            return 0, err11
        }
        i += n11
    }
    if m.PtNose != nil {
        dAtA[i] = 0x2a
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.PtNose.Size()))
        n12, err12 := m.PtNose.MarshalTo(dAtA[i:])
        if err12 != nil {
            return 0, err12
        }
        i += n12
    }
    if m.FAngle != nil {
        dAtA[i] = 0x32
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.FAngle.Size()))
        n13, err13 := m.FAngle.MarshalTo(dAtA[i:])
        if err13 != nil {
            return 0, err13
        }
        i += n13
    }
    if m.Quality != 0 {
        dAtA[i] = 0x38
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Quality))
    }
    if len(m.FacialData) > 0 {
        dAtA[i] = 0x42
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(len(m.FacialData)))
        i += copy(dAtA[i:], m.FacialData)
    }
    if m.FaceID != 0 {
        dAtA[i] = 0x48
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.FaceID))
    }
    return i, nil
}

func (m *ObjInfo) Marshal() (dAtA []byte, err error) {
    size := m.Size()
    dAtA = make([]byte, size)
    n, err := m.MarshalTo(dAtA)
    if err != nil {
        return nil, err
    }
    return dAtA[:n], nil
}

func (m *ObjInfo) MarshalTo(dAtA []byte) (int, error) {
    var i int
    _ = i
    var l int
    _ = l
    if m.RcObj != nil {
        dAtA[i] = 0xa
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.RcObj.Size()))
        n14, err14 := m.RcObj.MarshalTo(dAtA[i:])
        if err14 != nil {
            return 0, err14
        }
        i += n14
    }
    if m.Typ != 0 {
        dAtA[i] = 0x10
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Typ))
    }
    if m.Prob != 0 {
        dAtA[i] = 0x1d
        i++
        encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Prob))))
        i += 4
    }
    return i, nil
}

func encodeVarintProtomsg(dAtA []byte, offset int, v uint64) int {
    for v >= 1<<7 {
        dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -414,6 +1348,189 @@
    l = len(m.Data)
    if l > 0 {
        n += 1 + l + sovProtomsg(uint64(l))
    }
    return n
}

func (m *Point) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    if m.X != 0 {
        n += 1 + sovProtomsg(uint64(m.X))
    }
    if m.Y != 0 {
        n += 1 + sovProtomsg(uint64(m.Y))
    }
    return n
}

func (m *Rect) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    if m.Left != 0 {
        n += 1 + sovProtomsg(uint64(m.Left))
    }
    if m.Top != 0 {
        n += 1 + sovProtomsg(uint64(m.Top))
    }
    if m.Right != 0 {
        n += 1 + sovProtomsg(uint64(m.Right))
    }
    if m.Bottom != 0 {
        n += 1 + sovProtomsg(uint64(m.Bottom))
    }
    return n
}

func (m *FaceAngle) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    if m.Yaw != 0 {
        n += 1 + sovProtomsg(uint64(m.Yaw))
    }
    if m.Pitch != 0 {
        n += 1 + sovProtomsg(uint64(m.Pitch))
    }
    if m.Roll != 0 {
        n += 1 + sovProtomsg(uint64(m.Roll))
    }
    if m.Confidence != 0 {
        n += 5
    }
    return n
}

func (m *ThftResult) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    if m.Gender != 0 {
        n += 1 + sovProtomsg(uint64(m.Gender))
    }
    if m.Age != 0 {
        n += 1 + sovProtomsg(uint64(m.Age))
    }
    if m.Race != 0 {
        n += 1 + sovProtomsg(uint64(m.Race))
    }
    if m.Beauty != 0 {
        n += 1 + sovProtomsg(uint64(m.Beauty))
    }
    if m.Smile != 0 {
        n += 1 + sovProtomsg(uint64(m.Smile))
    }
    return n
}

func (m *FacePos) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    if m.RcFace != nil {
        l = m.RcFace.Size()
        n += 1 + l + sovProtomsg(uint64(l))
    }
    if m.PtLeftEye != nil {
        l = m.PtLeftEye.Size()
        n += 1 + l + sovProtomsg(uint64(l))
    }
    if m.PtRightEye != nil {
        l = m.PtRightEye.Size()
        n += 1 + l + sovProtomsg(uint64(l))
    }
    if m.PtMouth != nil {
        l = m.PtMouth.Size()
        n += 1 + l + sovProtomsg(uint64(l))
    }
    if m.PtNose != nil {
        l = m.PtNose.Size()
        n += 1 + l + sovProtomsg(uint64(l))
    }
    if m.FAngle != nil {
        l = m.FAngle.Size()
        n += 1 + l + sovProtomsg(uint64(l))
    }
    if m.Quality != 0 {
        n += 1 + sovProtomsg(uint64(m.Quality))
    }
    l = len(m.FacialData)
    if l > 0 {
        n += 1 + l + sovProtomsg(uint64(l))
    }
    return n
}

func (m *FaceInfo) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    if m.RcFace != nil {
        l = m.RcFace.Size()
        n += 1 + l + sovProtomsg(uint64(l))
    }
    if m.PtLeftEye != nil {
        l = m.PtLeftEye.Size()
        n += 1 + l + sovProtomsg(uint64(l))
    }
    if m.PtRightEye != nil {
        l = m.PtRightEye.Size()
        n += 1 + l + sovProtomsg(uint64(l))
    }
    if m.PtMouth != nil {
        l = m.PtMouth.Size()
        n += 1 + l + sovProtomsg(uint64(l))
    }
    if m.PtNose != nil {
        l = m.PtNose.Size()
        n += 1 + l + sovProtomsg(uint64(l))
    }
    if m.FAngle != nil {
        l = m.FAngle.Size()
        n += 1 + l + sovProtomsg(uint64(l))
    }
    if m.Quality != 0 {
        n += 1 + sovProtomsg(uint64(m.Quality))
    }
    l = len(m.FacialData)
    if l > 0 {
        n += 1 + l + sovProtomsg(uint64(l))
    }
    if m.FaceID != 0 {
        n += 1 + sovProtomsg(uint64(m.FaceID))
    }
    return n
}

func (m *ObjInfo) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    if m.RcObj != nil {
        l = m.RcObj.Size()
        n += 1 + l + sovProtomsg(uint64(l))
    }
    if m.Typ != 0 {
        n += 1 + sovProtomsg(uint64(m.Typ))
    }
    if m.Prob != 0 {
        n += 5
    }
    return n
}
@@ -847,6 +1964,1277 @@
    }
    return nil
}
func (m *Point) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx
        var wire uint64
        for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
                return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
                return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            wire |= uint64(b&0x7F) << shift
            if b < 0x80 {
                break
            }
        }
        fieldNum := int32(wire >> 3)
        wireType := int(wire & 0x7)
        if wireType == 4 {
            return fmt.Errorf("proto: Point: wiretype end group for non-group")
        }
        if fieldNum <= 0 {
            return fmt.Errorf("proto: Point: illegal tag %d (wire type %d)", fieldNum, wire)
        }
        switch fieldNum {
        case 1:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field X", wireType)
            }
            m.X = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.X |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        case 2:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field Y", wireType)
            }
            m.Y = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.Y |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        default:
            iNdEx = preIndex
            skippy, err := skipProtomsg(dAtA[iNdEx:])
            if err != nil {
                return err
            }
            if skippy < 0 {
                return ErrInvalidLengthProtomsg
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthProtomsg
            }
            if (iNdEx + skippy) > l {
                return io.ErrUnexpectedEOF
            }
            iNdEx += skippy
        }
    }

    if iNdEx > l {
        return io.ErrUnexpectedEOF
    }
    return nil
}
func (m *Rect) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx
        var wire uint64
        for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
                return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
                return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            wire |= uint64(b&0x7F) << shift
            if b < 0x80 {
                break
            }
        }
        fieldNum := int32(wire >> 3)
        wireType := int(wire & 0x7)
        if wireType == 4 {
            return fmt.Errorf("proto: Rect: wiretype end group for non-group")
        }
        if fieldNum <= 0 {
            return fmt.Errorf("proto: Rect: illegal tag %d (wire type %d)", fieldNum, wire)
        }
        switch fieldNum {
        case 1:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field Left", wireType)
            }
            m.Left = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.Left |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        case 2:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field Top", wireType)
            }
            m.Top = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.Top |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        case 3:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field Right", wireType)
            }
            m.Right = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.Right |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        case 4:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field Bottom", wireType)
            }
            m.Bottom = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.Bottom |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        default:
            iNdEx = preIndex
            skippy, err := skipProtomsg(dAtA[iNdEx:])
            if err != nil {
                return err
            }
            if skippy < 0 {
                return ErrInvalidLengthProtomsg
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthProtomsg
            }
            if (iNdEx + skippy) > l {
                return io.ErrUnexpectedEOF
            }
            iNdEx += skippy
        }
    }

    if iNdEx > l {
        return io.ErrUnexpectedEOF
    }
    return nil
}
func (m *FaceAngle) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx
        var wire uint64
        for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
                return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
                return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            wire |= uint64(b&0x7F) << shift
            if b < 0x80 {
                break
            }
        }
        fieldNum := int32(wire >> 3)
        wireType := int(wire & 0x7)
        if wireType == 4 {
            return fmt.Errorf("proto: FaceAngle: wiretype end group for non-group")
        }
        if fieldNum <= 0 {
            return fmt.Errorf("proto: FaceAngle: illegal tag %d (wire type %d)", fieldNum, wire)
        }
        switch fieldNum {
        case 1:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field Yaw", wireType)
            }
            m.Yaw = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.Yaw |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        case 2:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field Pitch", wireType)
            }
            m.Pitch = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.Pitch |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        case 3:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field Roll", wireType)
            }
            m.Roll = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.Roll |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        case 4:
            if wireType != 5 {
                return fmt.Errorf("proto: wrong wireType = %d for field Confidence", wireType)
            }
            var v uint32
            if (iNdEx + 4) > l {
                return io.ErrUnexpectedEOF
            }
            v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
            iNdEx += 4
            m.Confidence = float32(math.Float32frombits(v))
        default:
            iNdEx = preIndex
            skippy, err := skipProtomsg(dAtA[iNdEx:])
            if err != nil {
                return err
            }
            if skippy < 0 {
                return ErrInvalidLengthProtomsg
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthProtomsg
            }
            if (iNdEx + skippy) > l {
                return io.ErrUnexpectedEOF
            }
            iNdEx += skippy
        }
    }

    if iNdEx > l {
        return io.ErrUnexpectedEOF
    }
    return nil
}
func (m *ThftResult) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx
        var wire uint64
        for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
                return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
                return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            wire |= uint64(b&0x7F) << shift
            if b < 0x80 {
                break
            }
        }
        fieldNum := int32(wire >> 3)
        wireType := int(wire & 0x7)
        if wireType == 4 {
            return fmt.Errorf("proto: ThftResult: wiretype end group for non-group")
        }
        if fieldNum <= 0 {
            return fmt.Errorf("proto: ThftResult: illegal tag %d (wire type %d)", fieldNum, wire)
        }
        switch fieldNum {
        case 1:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field Gender", wireType)
            }
            m.Gender = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.Gender |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        case 2:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field Age", wireType)
            }
            m.Age = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.Age |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        case 3:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field Race", wireType)
            }
            m.Race = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.Race |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        case 4:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field Beauty", wireType)
            }
            m.Beauty = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.Beauty |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        case 5:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field Smile", wireType)
            }
            m.Smile = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.Smile |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        default:
            iNdEx = preIndex
            skippy, err := skipProtomsg(dAtA[iNdEx:])
            if err != nil {
                return err
            }
            if skippy < 0 {
                return ErrInvalidLengthProtomsg
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthProtomsg
            }
            if (iNdEx + skippy) > l {
                return io.ErrUnexpectedEOF
            }
            iNdEx += skippy
        }
    }

    if iNdEx > l {
        return io.ErrUnexpectedEOF
    }
    return nil
}
func (m *FacePos) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx
        var wire uint64
        for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
                return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
                return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            wire |= uint64(b&0x7F) << shift
            if b < 0x80 {
                break
            }
        }
        fieldNum := int32(wire >> 3)
        wireType := int(wire & 0x7)
        if wireType == 4 {
            return fmt.Errorf("proto: FacePos: wiretype end group for non-group")
        }
        if fieldNum <= 0 {
            return fmt.Errorf("proto: FacePos: illegal tag %d (wire type %d)", fieldNum, wire)
        }
        switch fieldNum {
        case 1:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field RcFace", wireType)
            }
            var msglen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            if m.RcFace == nil {
                m.RcFace = &Rect{}
            }
            if err := m.RcFace.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            iNdEx = postIndex
        case 2:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field PtLeftEye", wireType)
            }
            var msglen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            if m.PtLeftEye == nil {
                m.PtLeftEye = &Point{}
            }
            if err := m.PtLeftEye.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            iNdEx = postIndex
        case 3:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field PtRightEye", wireType)
            }
            var msglen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            if m.PtRightEye == nil {
                m.PtRightEye = &Point{}
            }
            if err := m.PtRightEye.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            iNdEx = postIndex
        case 4:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field PtMouth", wireType)
            }
            var msglen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            if m.PtMouth == nil {
                m.PtMouth = &Point{}
            }
            if err := m.PtMouth.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            iNdEx = postIndex
        case 5:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field PtNose", wireType)
            }
            var msglen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            if m.PtNose == nil {
                m.PtNose = &Point{}
            }
            if err := m.PtNose.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            iNdEx = postIndex
        case 6:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field FAngle", wireType)
            }
            var msglen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            if m.FAngle == nil {
                m.FAngle = &FaceAngle{}
            }
            if err := m.FAngle.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            iNdEx = postIndex
        case 7:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field Quality", wireType)
            }
            m.Quality = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.Quality |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        case 8:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field FacialData", wireType)
            }
            var byteLen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                byteLen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if byteLen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + byteLen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.FacialData = append(m.FacialData[:0], dAtA[iNdEx:postIndex]...)
            if m.FacialData == nil {
                m.FacialData = []byte{}
            }
            iNdEx = postIndex
        default:
            iNdEx = preIndex
            skippy, err := skipProtomsg(dAtA[iNdEx:])
            if err != nil {
                return err
            }
            if skippy < 0 {
                return ErrInvalidLengthProtomsg
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthProtomsg
            }
            if (iNdEx + skippy) > l {
                return io.ErrUnexpectedEOF
            }
            iNdEx += skippy
        }
    }

    if iNdEx > l {
        return io.ErrUnexpectedEOF
    }
    return nil
}
func (m *FaceInfo) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx
        var wire uint64
        for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
                return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
                return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            wire |= uint64(b&0x7F) << shift
            if b < 0x80 {
                break
            }
        }
        fieldNum := int32(wire >> 3)
        wireType := int(wire & 0x7)
        if wireType == 4 {
            return fmt.Errorf("proto: FaceInfo: wiretype end group for non-group")
        }
        if fieldNum <= 0 {
            return fmt.Errorf("proto: FaceInfo: illegal tag %d (wire type %d)", fieldNum, wire)
        }
        switch fieldNum {
        case 1:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field RcFace", wireType)
            }
            var msglen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            if m.RcFace == nil {
                m.RcFace = &Rect{}
            }
            if err := m.RcFace.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            iNdEx = postIndex
        case 2:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field PtLeftEye", wireType)
            }
            var msglen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            if m.PtLeftEye == nil {
                m.PtLeftEye = &Point{}
            }
            if err := m.PtLeftEye.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            iNdEx = postIndex
        case 3:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field PtRightEye", wireType)
            }
            var msglen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            if m.PtRightEye == nil {
                m.PtRightEye = &Point{}
            }
            if err := m.PtRightEye.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            iNdEx = postIndex
        case 4:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field PtMouth", wireType)
            }
            var msglen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            if m.PtMouth == nil {
                m.PtMouth = &Point{}
            }
            if err := m.PtMouth.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            iNdEx = postIndex
        case 5:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field PtNose", wireType)
            }
            var msglen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            if m.PtNose == nil {
                m.PtNose = &Point{}
            }
            if err := m.PtNose.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            iNdEx = postIndex
        case 6:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field FAngle", wireType)
            }
            var msglen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            if m.FAngle == nil {
                m.FAngle = &FaceAngle{}
            }
            if err := m.FAngle.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            iNdEx = postIndex
        case 7:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field Quality", wireType)
            }
            m.Quality = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.Quality |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        case 8:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field FacialData", wireType)
            }
            var byteLen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                byteLen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if byteLen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + byteLen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.FacialData = append(m.FacialData[:0], dAtA[iNdEx:postIndex]...)
            if m.FacialData == nil {
                m.FacialData = []byte{}
            }
            iNdEx = postIndex
        case 9:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field FaceID", wireType)
            }
            m.FaceID = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.FaceID |= int64(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        default:
            iNdEx = preIndex
            skippy, err := skipProtomsg(dAtA[iNdEx:])
            if err != nil {
                return err
            }
            if skippy < 0 {
                return ErrInvalidLengthProtomsg
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthProtomsg
            }
            if (iNdEx + skippy) > l {
                return io.ErrUnexpectedEOF
            }
            iNdEx += skippy
        }
    }

    if iNdEx > l {
        return io.ErrUnexpectedEOF
    }
    return nil
}
func (m *ObjInfo) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx
        var wire uint64
        for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
                return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
                return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            wire |= uint64(b&0x7F) << shift
            if b < 0x80 {
                break
            }
        }
        fieldNum := int32(wire >> 3)
        wireType := int(wire & 0x7)
        if wireType == 4 {
            return fmt.Errorf("proto: ObjInfo: wiretype end group for non-group")
        }
        if fieldNum <= 0 {
            return fmt.Errorf("proto: ObjInfo: illegal tag %d (wire type %d)", fieldNum, wire)
        }
        switch fieldNum {
        case 1:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field RcObj", wireType)
            }
            var msglen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            if m.RcObj == nil {
                m.RcObj = &Rect{}
            }
            if err := m.RcObj.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            iNdEx = postIndex
        case 2:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field Typ", wireType)
            }
            m.Typ = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.Typ |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        case 3:
            if wireType != 5 {
                return fmt.Errorf("proto: wrong wireType = %d for field Prob", wireType)
            }
            var v uint32
            if (iNdEx + 4) > l {
                return io.ErrUnexpectedEOF
            }
            v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
            iNdEx += 4
            m.Prob = float32(math.Float32frombits(v))
        default:
            iNdEx = preIndex
            skippy, err := skipProtomsg(dAtA[iNdEx:])
            if err != nil {
                return err
            }
            if skippy < 0 {
                return ErrInvalidLengthProtomsg
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthProtomsg
            }
            if (iNdEx + skippy) > l {
                return io.ErrUnexpectedEOF
            }
            iNdEx += skippy
        }
    }

    if iNdEx > l {
        return io.ErrUnexpectedEOF
    }
    return nil
}
func skipProtomsg(dAtA []byte) (n int, err error) {
    l := len(dAtA)
    iNdEx := 0

 protomsg.proto

@@ -19,3 +19,54 @@
    int32 height = 2;
    bytes data = 3;
}

// struct for sdk
message Point{
    int32 x = 1;
    int32 y = 2;
}
message Rect{
    int32 left = 1;
    int32 top = 2;
    int32 right = 3;
    int32 bottom = 4;
}
message FaceAngle{
    int32 yaw = 1;
    int32 pitch =2;
    int32 roll = 3;
    float confidence =4;
}
message ThftResult{
    int32 gender = 1;
    int32 age = 2;
    int32 race = 3;
    int32 beauty = 4;
    int32 smile = 5;
}
message FacePos{
    Rect rcFace = 1;
    Point ptLeftEye = 2;
    Point ptRightEye = 3;
    Point ptMouth = 4;
    Point ptNose = 5;
    FaceAngle fAngle = 6;
    int32 quality = 7;
    bytes facialData = 8;
}
message FaceInfo{
    Rect rcFace = 1;
    Point ptLeftEye = 2;
    Point ptRightEye = 3;
    Point ptMouth = 4;
    Point ptNose = 5;
    FaceAngle fAngle = 6;
    int32 quality = 7;
    bytes facialData = 8;
    int64 faceID = 9;
}
message ObjInfo{
    Rect rcObj = 1;
    int32 typ = 2;
    float prob = 3;
}