resistancemonitor/Cpp/DataServices/hjdatadefine.h

#ifndef __HJDATADEFINE__
#define __HJDATADEFINE__
#include "WinDef.h"
#include <stdint.h>
#include <map>
#include <set>
#include <vector>
#include <string>

#define DATA_HEADTAIL	0xAA
#define DATA_HEAD		0xAA
#define DATA_TAIL		0xAA
#define DATA_CONVER		0xAB
//数据中心和数据总中心的交互指令  
#define UP_MSG_LOGIN				0x01	//登录包或者订阅包
#define UP_MSG_LIST					0x03    //请求任务列表
#define UP_MSG_TASKSTATUS			0x05	//请求任务状态
#define UP_MSG_ALARMHANDLE			0x08    //上传报警处理
#define UP_MSG_PLATEINFO		    0x0A
#define UP_MSG_LASTALARM			0x0B	//请求最后报警
#define UP_MSG_LASTRTINFO			0x0C	//请求最后状态信息
#define UP_MSG_HISTORYALARM			0x0D	//请求历史报警
#define UP_MSG_HISTORYRTINFO		0x0E	//请求历史状态信息
#define UP_MSG_ERROR				0x11    //上传误报警
#define UP_MSG_VIDEO_START			0x13	//请求开始实时视频
#define UP_MSG_VIDEO_STOP			0x15	//请求停止实时视频
#define MSG_REALTIMEANALYSIS		0x18    //下发定时分析图片 //用于分析是否车道是否偏移等功能
#define UP_MSG_DELETEALARM			0x19    //上传删除报警
#define UP_MSG_CONFIRMALARM			0x21	//上传报警确认
#define UP_MSG_VIDEOFINISH			0x23	//上传录像通知
#define UP_MSG_MARKERROR			0x25	//上传误报警入库
#define UP_MSG_PTZCMD               0x27    //上传云台控制
#define UP_MSG_KEEP					0x32	//心跳
#define UP_MSG_IDTRACK_INFO         0x2C    //上传目标id跟踪信息

#define DOWN_MSG_RESP				0x02	//通用应答包
#define DOWN_MSG_LIST				0x04	//下发任务列表
#define DOWN_MSG_TASKSTATUS			0x06	//下发任务状态
#define DOWN_MSG_ALARM				0x07    //下发报警
#define DOWN_MSG_RTINFO				0x09	//下发状态信息
#define DOWN_MSG_LICENSE			0x0A	//下发车牌信息
#define DOWN_MSG_VIDEO_DATA			0x14    //下发视频数据
#define DOWN_MSG_DELETEALARM		0x20	//下发删除报警
#define DOWN_MSG_CONFIRMALARM		0x22	//下发报警确认
#define DOWN_MSG_MARKERROR			0x24	//下发错误标记
#define DOWN_MSG_KEEP				0x26    //心跳
#define DOWN_MSG_REALTIMEANALYSIS	0x28	//下发实时分析图片(类似报警)  //崇左定制   2023年10月18日起 使用 MSG_REALTIMEANALYSIS
#define DOWN_MSG_ALARM_DATA			0x2A	//下发报警数据图片 暂时只用于图片
#define DWON_MSG_IDTRACK_INFO       0x2D    //下发目标id跟踪信息
#define DWON_MSG_IDTRACK_INFOTOSERVER  0x2E  //下发目标id跟踪信息到dataserver
#define DOWN_MSG_LIST_NEW			0x1A	//下发新的任务列表
#define DOWN_MSG_REFLECTIVECONE_INFO  0x1D   //下发反光锥桶信息
#define DOWN_MSG_CONSTRUCTION_INFO    0x1E   //下发施工信息

#define MSG_CONTROL					0x1B	//下发控制命令    此命令同协议号回包
#define MSG_VIDEO_SRC               0x1C    //下发视频源配置
#define MSG_TASK_LIST				0x29    //请求和下发任务列表  用于下发给VA关联通道用
#define MSG_TASK_CONF				0x2B    //请求和下发任务配置
#define MSG_CONFIRM_RECV_ALARM_0x2F	0x2F	//确认收到报警.  报警补传用,  数据内容为36 bit guid + 预留156bit

#define MSG_LOG						0x33		//系统日志
#define UP_MSG_TIME					0x34		//时间同步
#define NOTICE_MSG_FEEDBACK			0x3A		//雨雾报警反馈
#define UP_MSG_ALARM_ERROR			0x40		//非车辆行人误报警反馈
#define MSG_CAMERA_STATUS			0x35        //摄像机状态  设备ID 13bit + 状态 1bit + 摄像机ip 16bit 预留 34bit  状态： 0.离线 1.在线
#define DOWN_MSG_IMAGE_DATA			0x36	    //下发图像数据
#define MSG_CONFIG_JSON_DATA		0x37		//配置数据获取和设置 1bit OR_DATA_INFO + 64bit taskname + json data
#define MSG_CONGESTION_INFO			0x39        //收费站拥堵长度
#define MSG_TRAINWORK_INFO          0x42        //隧道行车信息

#define UP_WATCH_LIST		0x61  //请求监控列表
#define DOWN_WATCH_LIST		0x62  //下发监控列表
#define UP_WATCH_CONTROL    0x63  //请求控制监控操作   启动.停止.暂停.继续.隐藏.显示.重启.添加.删除等
#define UP_WATCH_ALLCTL		0x65  //请求对所有监控操作 启动.停止.暂停.继续.隐藏.显示.重启.添加.删除等
#define UP_SERVER_STATUS	0x66	//请求服务器状态
#define DOWN_SERVER_STATUS  0x67	//响应\或主动通知服务器状态

//广播协议
#define MSG_GROUP_MOD_ADDR	0xFE   //修改地址协命令
#define MSG_DISCOVER_DEVICE 0xFF   //路由发现协议

//任务来源定义
#define TASK_SOURCE_UNDEFINE	0x00
#define TASK_SOURCE_JIESHANG	0x01
#define TASK_SOURCE_HUIJING		0x02
#define TASK_SOURCE_XIANDL		0x03

//车辆类型 specialvalue 第一字节低四位
//#define CAR_TYPE_INVALID      0x00  //无效
//#define CAR_TYPE_TRUNK        0x01  
//#define CAR_TYPE_BUS	      0x02
//#define CAR_TYPE_CAR	      0x03  //小车
//#define CAR_TYPE_YELLOW	      0x04 //维护车辆

//位置信息 specialvalue 第一字节高四位
#define ALARM_LOCA_INVALID    0x00
#define ALARM_LOCA_HARD		  0x01  //硬路肩 
#define ALARM_LOCA_PARK       0x02  //停车带
#define ALARM_LOCA_LANE       0x03  //主车道
#define ALARM_LOCA_GUIDE      0x04  //导流带
#define ALARM_LOCA_ISOLA      0x05  //隔离带
#define ALARM_LOCA_RAMP       0x06  //匝道

#define ALARM_DIRECTION_INVALID 0x00    //位置方向
#define ALARM_DIRECTION_NEGA	0x01
#define ALARM_DIRECTION_POSI	0x02

//报警车辆类型
#define ALARM_CARTYPE_TRUCK		0x01  //货车
#define ALARM_CARTYPE_BUS		0x02  //客车
#define ALARM_CARTYPE_CAR		0x03  //小车
#define ALARM_CARTYPE_TANKER	0x04  //油罐车
#define ALARM_CARTYPE_YELLOWCAR	0x05  //施工车
#define ALARM_CARTYPE_CONTRAINERTRUCK 0x06   //厢式货车
#define ALARM_CARTYPE_POLICECAR 0x07   //警车

#define SPECIAL_POSI(x) (x & 0xFFFF3FFF | 0x008000)
#define SPECIAL_NEGA(x) (x & 0xFFFF3FFF | 0x004000)
#define SPECIAL_LOCA(x) ((x & 0x0000C000) >> 14)
#define SPECIAL_EVENTLOCA(x) ((x & 0x000000F0) >> 4)
#define SPECIAL_TYPE(x) (x & 0x0000000F)
#define SPECIAL_LANE(x) ((x & 0x00000F00) >> 8)

//MSG_CONTROL 
enum class VA_CONTROL_TYPE : uint16_t
{
	VBT_SNAP = 0x01,	//抓拍      
	VBT_MODIFY_IP = 0x02, //修改视频源IP
	VBT_MODIFY_ID = 0x03, //修改taskid      64bit taskname + 13bit old taskid + 13bit new taskid
	VBT_MODIFY_NAME = 0x04, //修改taskname    64bit taskname + 64bit old taskname
	VBT_MODIFY_INTERVAL = 0x05, //修改流量统计间隔    4bit  统计时长
	VBT_CHECK_BOX = 0x06, // 复选框勾选      1bit 0 read or 1 set + 2bit checkbox type + 64bit taskname + 1bit value + 1bit result
	VBT_SAMPLE = 0x07,   //截取样本类型下发  2bit WORK_TARGET_TYPE  16bit reser
};

enum class VA_CONFIG_CHECKBOX_TYPE : uint16_t
{
	VCIT_PRESET_CONFIG = 0x01,      //预置位配置
};

//分析服务器类型
enum class VASERVICE_TYPE
{
	VST_INVALD = 0,
	VST_IVU = 1,
	VST_VA = 2,
	VST_XADL = 3,
	VST_DATA = 4,
};
enum class ALARM_LEVEL
{
	Fatal = 1,
	Error = 2,
	Warn = 3,
	Info = 4,
};

//分析场景类型
enum class ANALYSISSCENARIO_TYPE : uint8_t
{
	AS_UNKOWN = 0,
	AS_TUNNEL = 2,     //隧道
	AS_ROAD = 1,    //路面
	AS_TUNNELOPENING = 5,   //洞口
	AS_TUNNELN = 4,         //汽通洞
	AS_SWITCHHOUSE = 15,     //配电房
	AS_SERVERAREA = 11,     //服务区
	AS_TOLLSTATION = 6,     //收费站
	AS_NATIONALROAD = 19,    //国道
	AS_PARKINGSTRIP = 3,    //停车带
	AS_RADAR = 17, //雷达
	AS_FISHEYE = 18,        //鱼眼
};

//目标类型
enum class WORK_TARGET_TYPE : uint16_t
{
	WTT_UNKOWN = -1,
	WTT_CAR = 0x00,			//小车
	WTT_PERSON = 0x01,		//行人
	WTT_OTHER = 0x02,		//其他
	WTT_SPILL = 0x03,		//抛撒物
	WTT_BICYCLE = 0x04,		//自行车
	WTT_MOTORBIKE = 0x05,	//摩托车
	WTT_BUS = 0x06,			//大巴
	WTT_TRUCK = 0x07,		//货车
	WTT_YELLOWCAR = 0x08,  //工程车
	WTT_REFLECTIVECONE = 0x09, //反光锥
	WTT_YELLOWPERSON, //维护人员
	WTT_TANKER,			//危化品
	WTT_MULTI_CAR,		//多辆车(拥堵)
	WTT_FIRE,			//火焰
	WTT_PTZ,			//字符
	WTT_CAT,           //猫
	WTT_DOG,			//狗
	WTT_SMOG,			//烟雾
	WTT_SHEEP,		//羊
	WTT_COW,		//牛
	WTT_BRANCH,      //树枝
	WTT_REFLECTIVEEVSTS,     //反光背心
	WTT_BARRIERARM,         //抬杆
	WTT_TOOL,               //工具
	WTT_HEAD,               //头
	WTT_HAT,                //帽子
	WTT_CLOTHES,           //衣服
	WTT_TRAILER,			//挂车
	WTT_WOVENBAG,           // 编织袋
	WTT_RUBBISH,            // 垃圾堆
};

enum TaskStateType
{
	STATUS_ALL = -1,
	STATUS_STOP = 0,        /*停止*/
	STATUS_GETSTREAMING = 1, /*正在获取视频流*/
	STATUS_GETSTREAMFAILED = 2, /*正在获取视频流*/
	STATUS_ALGINITERROR = 3,     /*算法错误 可能视频尺寸 加密狗 规则设置等问题*/
	STATUS_ALGSETCONFIGERROR = 4,     /*算法错误 可能视频尺寸 加密狗 规则设置等问题*/
	STATUS_ANALYZING = 5, /*正常分析中*/
	STATUS_STOPBYTIME = 6,     /*处于暂停时间中*/
	STATUS_STOPBYUSAGE = 7, /*性能占用过高，暂停任务*/
	STATUS_FILESERIALIZING = 8, /*文件解析中*/
	STATUS_FILESERIALIZEFAILED = 9, /*文件解析中*/
};

enum class eTimeSlot : uint8_t
{
	TS_UNKNOW = 0,
	TS_DAYTIME,
	TS_NIGHTTIME,
	TS_ALTERNATING,
	TS_SKY, //天窗
};

enum DA_AlarmType
{
	ALARM_0 = 0x00,		//0x00:	抓拍
	ALARM_1 = 0x01,		//0x01:	"移动物体";
	ALARM_2 = 0x02,		//0x02:	"小场景打架"; //移动人体改成打架  2009/12/03 ;打架改成小场景打架;
	ALARM_3 = 0x03,		//0x03:	"环境突变";
	ALARM_4 = 0x04,		//0x04:	"区域滞留";
	ALARM_5 = 0x05,		//0x05:	"区域内消失";
	ALARM_6 = 0x06,		//0x06:	"进入区域";
	ALARM_7 = 0x07,		//0x07:	"离开区域";
	ALARM_8 = 0x08,		//0x08:	"左穿越拌线";
	ALARM_9 = 0x09,		//0x09:	"右穿越拌线";
	ALARM_0A = 0x0A,	//0x0A:	"踩线";
	ALARM_0B = 0x0B,	//0x0B:	"突然出现";
	ALARM_0C = 0x0C,	//0x0C:	常规图片 //物品盗移前图片  
	ALARM_0D = 0x0D,	//0x0D:	"清晰人脸抓拍";
	ALARM_0E = 0x0E,	//0x0E:	"物品盗移";
	ALARM_0F = 0x0F,	//0x0F:	"物品位移";
	ALARM_10 = 0x10,	//0x10:	"物品遮挡";
	ALARM_11 = 0x11,	//0x11:	"多于1张人脸抓拍";
	ALARM_12 = 0x12,	//0x12:	"物体滞留";
	ALARM_13 = 0x13,	//0x13:	"跌倒";
	ALARM_14 = 0x14,	//0x14:	"加速";
	ALARM_15 = 0x15,	//0x15:	"徘徊";
	ALARM_16 = 0x16,	//0x16:	"超高";
	ALARM_17 = 0x17,	//0x17:	清晰人脸抓拍灰度图，灰度图不再是JPEG图片
	ALARM_18 = 0x18,	//0x18:	多于1张人脸抓拍灰度图
	ALARM_19 = 0x19,	//0x19:	报警前图片
	ALARM_1A = 0x1A,	//0x1a:	报警后图片
	ALARM_1B = 0x1B,	//0x1b:	人头计数查询图片
	ALARM_1C = 0x1C,	//0x1c:	人脸图片
	ALARM_1D = 0x1D,	//0x1d:	目标信息	people_cnt1为目标数，无图片，只有tagObjectInfo结构体
	ALARM_1E = 0x1E,	//0x1e:	球机跟踪信息	无图片，只有tagPtzCtrlInfo结构体
	ALARM_1F = 0x1F,	//0x1f:	球机跟踪结束	无图片，无内容

	ALARM_20 = 0x20,    // 大场景打架  
	ALARM_21 = 0x21,    // 人员接近     

	//广州中科院需求报警类型
	ALARM_22 = 0x22,    // 区域内有目标（专用）
	ALARM_23 = 0x23,    // 区域内无目标（专用）

	// 周界新增报警类型	
	ALARM_24 = 0x24,    // 逆行
	ALARM_25 = 0x25,    // 聚众 (周界3.0聚众)

	ALARM_26 = 0x26,    // 车牌识别 people_cnt1为车牌数，buf部分为people_cnt1个tagPlateInfo结构体+图片

	ALARM_27 = 0x27,    // 安全帽

	// ATM滞留相关报警类型（74-0x3D为滞留用户自定义报警）
	ALARM_30 = 0x30,    // 人员滞留超时	
	ALARM_31 = 0x31,    // 人员进入	
	ALARM_32 = 0x32,    // 人员离开
	ALARM_33 = 0x33,    // 物体滞留前	
	ALARM_34 = 0x34,    // 键盘	
	ALARM_35 = 0x35,    // 读卡器
	ALARM_36 = 0x36,    // 防护罩	

	// AB相关报警类型
	ALARM_40 = 0x40,    // 打砸
	ALARM_41 = 0x41,    // 人员进入（AB）
	ALARM_42 = 0x42,    // 人员滞留
	ALARM_43 = 0x43,    // 人员聚集 (异常行为)

	ALARM_ROLLOVER_0x45 = 0x45,  //疑似事故(侧翻)
	ALARM_CRASH_GUARD_0x46 = 0x46, //疑似事故(撞护栏)
	ALARM_REAR_END_0x47 = 0x47, //疑似事故(追尾)
	ALARM_BREAK_DOWN_0x48 = 0x48, //疑似事故(抛锚)
	ALARM_SELF_BURNING_0x49 = 0x49, //疑似事故(自然)

	ALARM_ANA_FRAME = 0x4E,  //定时抓拍
	ALARM_4F = 0x4F,    //观察,只存不发送

	ALARM_50 = 0x50, 	//0x50:	停驶
	ALARM_51 = 0x51, 	//0x51:	超速
	ALARM_52 = 0x52, 	//0x52:	事故
	ALARM_53 = 0x53, 	//0x53:	拥堵
	ALARM_PERSON = 84,
	ALARM_54 = 0x54, 	//0x54:	行人
	ALARM_55 = 0x55, 	//0x55:	逆行
	ALARM_FIRE = 0x56,
	ALARM_56 = 0x56, 	//0x56:	火焰
	ALARM_SPILL = 0x57,
	ALARM_57 = 0x57, 	//0x57:	抛洒物
	ALARM_58 = 0x58, 	//0x58:	排队超限
	ALARM_59 = 0x59, 	//0x59:	交通状态信息		无图片，只有tagDriveWayInfo结构体
	ALARM_5a = 0x5a, 	//0x5a:	抓拍(近景,会附加上车牌)
	ALARM_5b = 0x5b, 	//0x5b:	抓拍(中景)		2018年8月31日 10:03:04
	ALARM_5c = 0x5c,    //0x5c; 光线异常		2017年12月8日 11:29:46 scz 
	ALARM_SMOG = 0x5d,
	ALARM_5d = 0x5d,    //0x5d; 烟雾			2017年12月8日 11:29:50 scz
	ALARM_5e = 0x5e,	//0x5e; 摄像头转动		2018年1月4日 10:15:28 scz
	ALARM_5f = 0x5f,    //0x5f; 低速			2018年3月29日 10:22:08 scz

	ALARM_MOTORBIKE_0X60 = 96,
	ALARM_60 = 0x60,    //0x60: 非法车辆		2019年4月17日13:14:21 scz
	ALARM_61 = 0x61,    //0x61; 施工车辆        2019年4月18日09:19:42 scz
	ALARM_62 = 0x62,    //0x62; 施工维护人员    2019年4月18日09:20:19 scz
	ALARM_63 = 0x63,    //0x63: 施工			2019年4月17日13:14:30 scz
	ALARM_64 = 0x64,    //0x64; 违章变道		2019年8月14日11:02:43 scz
	ALARM_65 = 0x65,    //0x65; 高温预警		2019年11月12日09:15:32 scz
	ALARM_66 = 0x66,    //0x66; 高温报警		2019年11月12日13:50:14 scz
	ALARM_67 = 0x67,	//0x67;	低温预警		2019年11月12日09:16:01 scz
	ALARM_68 = 0x68,	//0x68;	低温报警		2019年11月12日09:16:01 scz
	ALARM_69 = 0x69,	//0x69; 火点报警		2019年11月14日11:03:54 scz
	ALARM_6a = 0x6a,	//0x6a; 压线报警		2020年5月22日11:26:41 scz
	ALARM_6b = 0x6b,    //0x6b  行驶车辆异常    107
	ALARM_6c = 0x6c,    //0x6c  能见度报警      108
	ALARM_6e = 0x6e,	//0x6e;	摄像机异常		2019年8月21日09:22:15 scz
	ALARM_6f = 0x6f,	//0x6f; 昼夜交替        2018年11月1日 16:10:51 scz

	ALARM_70 = 0x70,    //112; 驶离
	ALARM_71 = 0x71,    //113; 非法闯入
	ALARM_72 = 0x72,    //114 树枝侵入
	ALARM_73 = 0x73,    //115 工具遗漏
	ALARM_74 = 0x74,    //116 抬杆
	ALARM_75 = 0x75,    //117 可燃物
	ALARM_76 = 0x76,	//118 滞留
	ALARM_77 = 0x77,    //119 拥堵解除
	ALARM_78 = 0x78,    //120 施工解除
	ALARM_79 = 0x79,    //121 穿越导流带报警
	ALARM_7a = 0x7a,    //122 挂车报警
	ALARM_LENS_OFFSET_7b = 0x7b,         //123 镜头偏移
	ALARM_7c = 0x7c,                     //车辆超限

	ALARM_81 = 0x81,	//0x81:	"外接报警1";
	ALARM_82 = 0x82, 	//0x82:	"外接报警2";
	ALARM_83 = 0x83, 	//0x83:	"外接报警3";
	ALARM_84 = 0x84, 	//0x84:	"外接报警4";

	// 视频丢失和视频遮挡相关报警类型
	ALARM_90 = 0x90,    //144 视频丢失
	ALARM_91 = 0x91,    //145 视频遮挡
	ALARM_92 = 0x92,    //146 视频模糊(视频质量下降) 2021年7月15日08:47:00

	// 设备相关报警类型（新）
	ALARM_93 = 0x93,    // 紧急报警
	ALARM_94 = 0x94,    // 无硬盘
	ALARM_DISK_OVER_95 = 149,
	ALARM_95 = 0x95,    // 硬盘满
	ALARM_96 = 0x96,    // 硬盘错误
	ALARM_97 = 0x97,    // 登录失败
	ALARM_98 = 0x98,    // 设备网络中断  2021年7月15日08:50:22
	ALARM_99 = 0x99,    // 网络冲突
	ALARM_9A = 0x9A,    // 算法重置
	ALARM_9B = 0x9B,    // 网络通信故障
	ALARM_9C = 0x9C,    // 无GPU
	ALARM_GPU_MEM_9D = 0x9D, //显存异常
	ALARM_GPU_USE_9E = 0x9E,  //GPU异常

	ALARM_9F = 0x9F,     //判断设备类型用

	// 人脸遮挡算法相关报警类型

	ALARM_A0 = 0xA0,    /* 口罩遮挡（v3.0版本新增） */
	ALARM_A1 = 0xA1,	/* 墨镜遮挡（v3.0版本新增） */
	ALARM_A2 = 0xA2,	/* 其他遮挡（v3.0版本新增） */

	// 帽子检测算法报警类型
	ALARM_A6 = 0xA6,   /* 没有佩戴安全帽 */
	ALARM_A7 = 0xA7,   //未穿反光衣或其它穿带异常

	//桥下报警  0xB0~0xB8
	ALARM_PERSON_STAY_0XB0 = 176, //人员滞留
	ALARM_CAR_STAY_0XB1 = 177,    //车辆滞留
	ALARM_RUBBISH_0XB2 = 178,     //堆放物料
	ALARM_ILLEGAL_OPT_0XB3 = 179, //违规操作/违规经营
	ALARM_DUMP_RUBBISH_0xB4 = 180, //疑似倾倒垃圾

	ALARM_E0 = 0xE0, 	//0xe0:	人头计数报警格式，尾部增加img_alarm_report_t结构体
	ALARM_E1 = 0xE1, 	//0xe1:	聚众报警的图片
	ALARM_E2 = 0xE2,    // 双目垂直人头计数
	ALARM_EE = 0xEE, 	//0xee:	mjpeg视频流
	ALARM_F0 = 0xF0,	//0xF0:	"设备重启";
	ALARM_F1 = 0xF1,	//0xF1:	"上电抓拍";

	ALARM_TEST = 0xFF,
};

enum class WATCH_CONTROL_ACTION
{
	WCA_UNKNOW = 0,
	WCA_START,
	WCA_STOP,
	WCA_PAUSE,
	WCA_CONTINUE,
	WCA_HIDE,
	WCA_SHOW,
	WCA_REBOOT,
	WCA_APPEND,
	WCA_DELETE,
	WCA_CLEAR
};

enum class VA_CAMERA_BRAND
{
	VCB_UNKOWN = 0x00,
	VCB_HIK,
	VCB_DAHUA,
	VCB_UNIVIEW,
	VCB_SANTICHI,
	VCB_AXIS,
	VCB_OBTELECOM,
	VCB_SUNCTI,
	VCB_SIGNALWAY,
	VCB_PELCO,
	VCB_HUAWEI,
};

//数据包类型
enum class VA_PACK_TYPE
{
	VPT_UNKOWN = 0,
	VPT_ALARM_EVENT,	//报警事件
	VPT_TRAFFIC_FLOW,	//车流量
	VPT_PLATE_DETECT,	//车牌检测
	VPT_REAL_MONITOR,
	VPT_RCF_EVENT,		//反光锥事件
	VPT_CONGEST_INFO,   //拥堵信息
};

enum class VA_ALARM_DATA_TYPE : uint8_t
{
	VADT_PIC_JPG = 0x00,   //JPG数据
	VADT_VIDEO_MP4 = 0x01,   //MP4数据
	VADT_VIDEO_H264 = 0x02,  //H264数据
};

enum class VA_DATA_CATA : uint8_t
{
	VDC_PIC = 0x00,    //pic
	VDC_IMG = 0x01,	   //img
	VDC_LOG = 0x02,	   //log
	VDC_PLATE = 0x03,  //plate
	VDC_VIDEO = 0x04,  //video
	VDC_ANA = 0x05,	   //ana
};

#pragma pack(push, 1)

//头部
typedef struct tagHjDataHead {
	BYTE head;		//头部标识
	BYTE len[2];	//数据内容的长度
	BYTE ver;		//协议版本
	BYTE protocol;	//数据包的协议代码
	BYTE subno;		//下级的编号	如果是数据中心发往数据服务,则为0
	BYTE subpacknum;	//分包总数,0和1表示不分包
	bool subpackend : 1;  //分包结束标记
	BYTE subpackno : 7;  //分包编号
	DWORD	packno;		//数据包编号
}HJDATAHEAD, * LPHJDATAHEAD;

//21
typedef struct tagHjDataHead2 {
	DWORD64 head;		//头部标识
	DWORD len;			//数据内容的长度,等于包长度 – 21 – 2,后面数据长度为9 + len + 2
	BYTE ver;		//协议版本
	BYTE protocol;	//数据包的协议代码
	BYTE subno;		//下级的编号	如果是数据中心发往数据服务,则为0
	BYTE subpacknum;	//分包总数,0和1表示不分包
	bool subpackend : 1;  //分包结束标记
	BYTE subpackno : 7;  //分包编号
	DWORD	packno;		//数据包编号
}HJDATAHEAD2, * LPHJDATAHEAD2;

typedef struct tagOrDataInfo
{
	uint8_t readORset : 1;      //0 read 1 set
	uint8_t requestORresponse : 1;     //0  request  1 response
	uint8_t failORsucc : 1;    // 0  fail   1 succ    response 时使用
	uint8_t source : 2;       // 0 web   1  vaservice  2  dataservice  3 super
	uint8_t reser : 3;
}OR_DATA_INFO, * LPOR_DATA_INFO;

typedef struct tagVAConfigData
{
	OR_DATA_INFO or_info;
	char taskname[64] = { 0 };
	char jsondata[0];
}VACONFIG_DATA, * LPVACONFIG_DATA;

typedef struct dATALOGIN {
	char	name[50];
	WORD	areano;
	char	addr[32];
	char	user[32];
	char	pswd[32];
}DATALOGIN, * LPDATALOGIN;

typedef struct dATANOTICE {
	char	addr[32];
	WORD	port;
	byte    bnotice;
}DATANOTICE, * LPDATANOTICE;

typedef struct dATALIST {
	char	ivuaddr[32] = { 0 };//192.168.2.73:21011
	uint8_t	tasknum = 0;//共有多少个任务. 
	uint8_t task_size = 0; //每个任务结构体多少长度
	//WORD tasknum;
}DATALIST, * LPDATALIST;

typedef struct {
	DWORD   packno;
	BYTE	protocol;
	BYTE    result;
	char	mark[32];
}DATARESP, * LPDATARESP;

typedef struct tagDDateTime
{
	WORD wYear;
	WORD wMonth;
	WORD wDayOfWeek;
	WORD wDay;
	WORD wHour;
	WORD wMinute;
	WORD wSecond;
	WORD wMilliseconds;

	void operator=(tagDDateTime dataTime)
	{
		wYear = dataTime.wYear;
		wMonth = dataTime.wMonth;
		wDay = dataTime.wDay;
		wHour = dataTime.wHour;
		wMinute = dataTime.wMinute;
		wSecond = dataTime.wSecond;
		wMilliseconds = dataTime.wMilliseconds;
	}
	void operator=(uint64_t t)
	{
		CTime time(t / 1000);
		SYSTEMTIME st;
		time.GetAsSystemTime(st);
		wYear = st.wYear;
		wMonth = st.wMonth;
		wDay = st.wDay;
		wHour = st.wHour;
		wMinute = st.wMinute;
		wSecond = st.wSecond;
		wMilliseconds = t % 1000;
	}

	bool operator>(tagDDateTime dataTime) const
	{
		int iSecond = wHour * 3600 + wMinute * 60 + wSecond;
		int iOtherSecond = dataTime.wHour * 3600 + dataTime.wMinute * 60 + dataTime.wSecond;
		if (iSecond > iOtherSecond)
		{
			return true;
		}
		else
		{
			return false;
		}
	}

	bool operator<(tagDDateTime dataTime) const
	{
		int iSecond = wHour * 3600 + wMinute * 60 + wSecond;
		int iOtherSecond = dataTime.wHour * 3600 + dataTime.wMinute * 60 + dataTime.wSecond;
		if (iSecond < iOtherSecond)
		{
			return true;
		}
		else
		{
			return false;
		}
	}

	bool operator==(tagDDateTime dataTime) const
	{
		return (dataTime.wYear == wYear && dataTime.wMonth == wMonth && dataTime.wDay == wDay &&
			dataTime.wHour == wHour && dataTime.wMinute == wMinute && dataTime.wSecond == wSecond);
	}

	bool operator!=(tagDDateTime dataTime) const
	{
		return (dataTime.wHour != wHour || dataTime.wMinute != wMinute || dataTime.wSecond != wSecond);
	}

	void Parse(const char* chTime)
	{
		sscanf_s(chTime, "%04hd-%02hd-%02hdT%02hd:%02hd:%02hd", &wYear, &wMonth, &wDay, &wHour, &wMinute, &wSecond);
	}

	void ParseFromANSI(const char* chTime)
	{
		sscanf_s(chTime, "%04hd-%02hd-%02hd %02hd:%02hd:%02hd", &wYear, &wMonth, &wDay, &wHour, &wMinute, &wSecond);
	}
	operator CString()
	{
		CString strTime;
		strTime.Format("%04hd-%02hd-%02hd %02hd:%02hd:%02hd", wYear, wMonth, wDay, wHour, wMinute, wSecond);

		return strTime;
	}

	operator uint64_t() const
	{
		uint64_t nTimer = 0;
		tm temptm = { wSecond,
			wMinute,
			wHour,
			wDay,
			wMonth - 1,
			wYear - 1900
		};
		nTimer = mktime(&temptm) * 1000 + wMilliseconds;
		return nTimer;
	}
}DDATE_TIME;

typedef struct {
	char	guid[37];
	char	name[20];
	DDATE_TIME	time;
	BYTE	result;
	char	mark[200];
}DATAALARMHANDLE, * LPDATAALARMHANDLE;

typedef struct tagHistoryReq
{
	char taskid[12];
	char taskname[64];
	DDATE_TIME starttime;
	DDATE_TIME endtime;
	BYTE reserve[16];
	tagHistoryReq()
	{
		memset(this, 0, sizeof(tagHistoryReq));
	}
}DATA_HISTORYREQ, * LPDATA_HISTORYREQ;

typedef struct tagDataTaskItem
{
	char	       task_id[12];		// 任务唯一ID
	char	       task_name[64];	// 任务名称(界面显示用)
	char		   roadno[6];
	unsigned char  task_type;		// 0-实时视频 1-录像视频 2-本地文件
	DWORD          scenestype : 8;		//1字节   场景类型   0 未知  3 普清路面  4 普清隧道  5 高清路面  7 高清隧道  8走廊过道  9 匝道 10 热成像匝道  10
	DWORD		   stationnum : 24;     //3字节   桩号   
	char		   sourcetype;		//来源类型, 0. 无效 1. ONVIF 2. GB28181 3. DAXUN 4. WEICHUAN 5. HIK 2017年9月27日 10:01:05 scz 
	char		   sourceip[16];	//视频源IP
	unsigned short sourceport;		//视频源端口
	int			   taskState;
}DATA_TASK_ITEM, * LPDATA_TASK_ITEM;

typedef struct tagDataTaskItemEx : tagDataTaskItem
{
	uint32_t		lng = 0;  //经度  10的六次方
	uint32_t		lat = 0;  // 纬度  10的六次方
	char			version[20] = { 0 };
	uint32_t		rever[6] = { 0 };  //预留
}DATA_TASK_ITEMEX, * LPDATA_TASK_ITEMEX;

typedef struct tagDataTaskItemEx1
{
	char	       task_id[12];		// 任务唯一ID
	char	       task_name[64];	// 任务名称(界面显示用)
	char		   roadno[6];
	unsigned char  task_type;		// 0-实时视频 1-录像视频 2-本地文件
	DWORD          scenestype : 8;		//1字节   场景类型   0 未知  3 普清路面  4 普清隧道  5 高清路面  7 高清隧道  8走廊过道  9 匝道 10 热成像匝道  10
	DWORD		   stationnum : 24;     //3字节   桩号   
	//int			   task_channel;	// 分析通道，从0开始
	/*
	unsigned char  task_sysType;	// 0-iCVS 1-RTSP 2-SDK

	//iCV_AnalyRuleType
	unsigned char  alg_type;		// 算法类型ALG_TYPE
	unsigned int   alg_len;			// 算法规则长度, 此结构体后跟随alg_len个字节,表示算法规则
	unsigned char  throw_type;		// 丢帧方式 0-全帧 1-两帧丢一帧 2-三帧丢一帧 3-四帧丢一帧...

	//analyTimeSpan
	DDATE_TIME     begin_time;		// 开始时间
	DDATE_TIME     end_time;		// 结束时间

	//iCV_MediaSrcType
	char		   dev_Id[128];		//rtsp时为媒体url
	char		   nodePath[32];
	char		   nodeType[32];
	char		   biz_Id[128];
	int			   dataType;		//0-RAW 1-YV12 2-RGB32 3-MPEG4 4-H264
	*/
	//LocalExInfo
	char		   sourcetype;		//来源类型, 0. 无效 1. ONVIF 2. GB28181 3. DAXUN 4. WEICHUAN 5. HIK 2017年9月27日 10:01:05 scz 
	char		   sourceip[16];	//视频源IP
	unsigned short sourceport;		//视频源端口
	/*
	char		   username[64];	//视频源登录用户名
	char		   password[256];	//视频源登录密码
	char		   vd_domain[64];	//视频源登录域名
	char		   vd_guid[256];	//平台厂家提供的视频通道唯一标识符
	unsigned char  chn_id;			//通道号
	unsigned char  stream_type;		//0-主码流 1-子码流
	unsigned char  video_source;	//视频源类型 对应厂家视频类型 VDEV_TYPE
	int			   presetNo;		//分析任务启动时相机预置位，非启用此功能置0

	char		   vd_ipaddr[16];
	unsigned short vd_port;			// 视频端口
	char		   file_name[256];	// 录像文件的完整路径,在实时模式下,用做onvif设备认证类型
	*/
	int			   taskState;
}DATA_TASK_ITEMEX1, * LPDATA_TASK_ITEMEX1;

typedef struct {
	char			taskname[64];
	TaskStateType	status;
}DATA_TASKSTATUS, * LPDATA_TASKSTATUS;

//106
typedef struct tagAlarmBase
{
	char taskid[12];  //由48字节减少到12字节 2018年6月5日 12:50:08   //vaservice 不用管理, 由数据服务管理 2023.11.27
	char taskname[64];  //通道名称
	char roadno[6];  //公路编号  例如:G60
	//int channelid;  //视频流的通道索引
	int	stat_num;	//桩号
	DDATE_TIME alarmtime;//报警时间
	DA_AlarmType alarmtype;

	tagAlarmBase()
	{
		memset(this, 0, sizeof(tagAlarmBase));
	}
}D_ALARMBASE, * LPD_ALARMBASE;

//16
typedef struct tagAlarmAdditional
{
	BYTE remindlevel;		//报警提醒等级  0. 无效(默认为3)  1. 低  2. 中  3. 高  4. 特高
	char licenseplate[11];  //抓拍识别的车牌号
	eTimeSlot timeslot;			//时段 0. 无效   1. 昼  2. 夜  3. 昼夜交替 4 天窗
	BYTE platecolor;		//抓拍识别的车牌颜色
	BYTE reserve[2];
}D_ALARM_ADDIINFO, * LPD_ALARM_ADDIINFO;

typedef struct tagAnalysisImageInfo
{
	char imagetype_path[89];
	char directname[11] = { 0 };    //车道方向名称
}D_IMAGE_INFO, * LPD_PIMAGE_INFO;

typedef struct tagiAlarmIVUPoint
{
	tagiAlarmIVUPoint() {};
	tagiAlarmIVUPoint(unsigned short x, unsigned short y)
	{
		point_x = x;
		point_y = y;
	}
	unsigned short point_x;
	unsigned short point_y;
}D_ALARM_POINT, * LPD_ALARM_POINT;

typedef struct tagiAlarmIVULine
{
	D_ALARM_POINT its_point1;
	D_ALARM_POINT its_point2;
	DWORD ivu_line_length;
}D_ALARM_LINE, * LPD_ALARM_LINE;

typedef struct tagiAlarmIVUBox
{
	D_ALARM_POINT its_point1;
	D_ALARM_POINT its_point2;
}D_ALARM_BOX, * LPD_ALARM_BOX;

enum  class ALARM_FILTER_ID
{
	AFI_EVE_LIGHT = 20,
};

enum class E_FILTER : uint8_t
{
	FILTER_NO = 0x00,  //没有过滤
	FILTER_SPILL = 0x01, // 小抛洒物过滤
	FILTER_NETWORK = 0x02,  //网络卡顿过滤
	FILTER_TESTALARM = 0x03, //测试报警过滤
	FILTER_NO_PUSH,    //主动不推送
	FILTER_WB,			//误报过滤
	FILTER_SHIGONG_RONGHE,    //施工融合
	FILTER_CAR_SMALL,   //车辆过小
	FILTER_HOLIDAY,		//节假日
	FILTER_AUTO,		//自动处理
	FILTER_SHIGONG,    //施工过滤
	FILTER_PLAN,		//施工计划
	FILTER_REPEAT,		//重复报警
	FILTER_MALFUNCTION, //事故过滤
	FILTER_STREAM,      //码流卡顿
	FILTER_AREAOUT,     //区域外报警
	FILTER_WHRATE = 0x10,     //车辆长宽比例不对
	FILTER_GREEN,		//绿化带树枝  58001
	FILTER_MOVE,		//车道偏移 58007 58012
	FILTER_BRAND,		//护栏立杆标牌 58002
	FILTER_WHITE,		//标线白印修补 58003
	FILTER_DIRECT,		//方向标错 58009
	FILTER_LIGHT,		//光线阴影 58004
	FILTER_STAT,		//桩号标错 58010
	FILTER_KADUN,		//卡顿引起 58011
	FILTER_OUT_ROAD,	//非高速路段内 
	FILTER_HUANXING,    //缓行拥堵 58013, 58015
	FILTER_WORK,		//施工施救作业 58014
	FILTER_BIRDS,		//鸟类误报 58098
	FILTER_SHIELD,		//主动屏蔽
	FILTER_ZGY,			//浙高运过滤
	FILTER_CLASSIFY,    //图像分类
};

enum class E_SCENE_TYPE : uint8_t
{
	SCENE_UNKOWN = 0x00,
	SCENE_ROAD = 0x01,  //主线
	SCENE_SD,			//隧道
	SCENE_STOPPARK,           //紧停
	SCENE_CARPASS,           //汽通
	SCENE_HOLE_OUT,           //洞外
	SCENE_COLLECT,           //收费
	SCENE_YANGHU,           //养护
	SCENE_IN,           //进口
	SCENE_OUT,           //出口
	SCENE_BRIDGE_DOWN,           //	桥下
	SCENE_SERVICE,           //	服务
	SCENE_CONSTRUCTION,           //	工地
	SCENE_WATCH_BOX,           //	岗亭
	SCENE_CAR,           //	车载
	SCENE_POWER,           //	配电
	SCENE_RAMP,           //	匝道
	SCENE_RADAR,           //	雷达
	SCENE_YUYAN,         //鱼眼
	SCENE_NATIONAL,     //国道
};

//12 == sizeof(tagiAlarmObjectInfo)
typedef struct tagiAlarmObjectInfo
{
	uint8_t laneindex : 1; //车道方向，0.下行(桩号有大变小) 1.上行(桩号有小变大) 2018年6月5日 12:51:46 更改定义
	uint8_t r1 : 7;
	uint8_t r[3];
	DWORD laneno;	 //方向编号(见相关定义)
	union
	{
		DWORD special_value;
		//事件
		struct
		{
			uint8_t car_type : 4;  //80车辆类型  83拥堵等级
			uint8_t event_loca : 4;  //事件位置  

			uint8_t lane_label_e : 4;	 //车道编号1, 2, 3, 4, 5
			uint8_t startoversign : 2;  //报警开始结束标记  0.未知  1.开始  2.结束  例如拥堵开始拥堵结束, 施工开始,施工结束 摄像机断开开始,结束
			uint8_t posinega : 2;   //0. 无效  1. 反向  2. 正向

			uint8_t snapback : 1;   //0. 不归位  1. 归位到1倍焦距
			uint8_t cong_level : 3; //83拥堵等级 0 无效 1. 畅通  2. 基本畅通  3. 轻度拥堵 4. 中度拥堵  5. 严重拥堵
			uint8_t result : 2;		//处理结果, 包含人工和系统, 0. 未处理  1. 已处理  2. 误报  3. 其他
			uint8_t rever : 2;

			E_FILTER filter : 7;  //报警过滤结果  用于过滤结果的统计,只发送到数据端,而不推送到客户端
			uint8_t make_up_e : 1;  //补传位
		};
		//流量
		struct
		{
			uint8_t rever1 : 4;
			eTimeSlot time_solt : 4;      //时间段1昼2夜3昼夜交替4天窗   注意事件不能使用此字段
			uint16_t lane_label : 4;	//车道编号1, 2, 3, 4, 5(新的已经不使用)
			uint16_t time_span : 12;   //时间跨度
			uint8_t rever2 : 7;
			uint8_t make_up : 1;  //补传位
		};
		//抓拍
		struct
		{
			uint8_t  targetType; //WORK_TARGET_TYPE
			uint8_t  version;    //YOLO_VERSION_ALGO
			uint8_t  sr;
			uint8_t  sr2;
		};
	};
}D_ALARM_OBJ_INFO, * LPD_ALARM_OBJ_INFO;
/*
如果报警是ALARM_50 或者 ALARM_55 等车辆事件时,
special_value 定义更改为:
低四位标识车辆类型:
0.	无效
1.	事件车辆为货车
2.	事件车辆为客车
3.	事件车辆为小车
4.  事件车辆为危化品车
5.  事件车辆为施工车
高四位表示事件发生的位置:
0.	无效
1.	硬路肩
2.	停车带
3.	行驶车道
4.	导流带
5.	隔离带
6.	匝道
如果报警是 ALARM_53 事件时:
special_value 定义更改为:
0.	无效
1.	基本畅通
2.	轻度拥堵
3.	中度拥堵
4.	严重拥堵
(可只取0, 2, 4值)
针对所有报警和车流量数据包:(新增)
SPECIALVALUE的最高位(即下标从0开始的第31位)
0.	实时数据包
1.	补传数据包
针对车流量数据包;
第一字节低四位的值标识车流量统计时间单位:
0. 1分钟
1. 5分钟
2. 1小时
3. 1天
(目前只取0值, 后续会考虑归档,归档后值为2)

*/

//2019年2月27日14:11:10
//sizeof(tagAlarmExtraInfo) == 12
typedef struct tagAlarmExtraInfo
{
	union
	{
		struct
		{
			unsigned short uwFlux;				//当前预估的分钟车流量	单位(辆 / 分)
			unsigned short uwSpeed;			//当前平均车速   km/h
			unsigned short uwSpace;			//车间距
			unsigned short uwDensity;           //车辆密度，N/L, 单位：辆/km
			unsigned short uwOccupancy;         //当前车道占有率，扩大1000倍
			unsigned short uwLowSpace;
		} congestion;
	};
}D_ALARM_EXTRAINFO, * LPD_ALARM_EXTRAINFO;

//sizeof(D_ALARM_ITS_ANALYSIS) == 254
typedef struct tagAlarmIVUITSAnalysis : public D_ALARMBASE
{
	D_ALARM_OBJ_INFO its_info;
	//D_ALARM_LINE its_line;
	D_ALARM_EXTRAINFO its_extra;
	D_ALARM_BOX its_box;
	D_ALARM_ADDIINFO its_addition;
	D_IMAGE_INFO its_image;
}D_ALARM_ITS_ANALYSIS, * LPD_ALARM_ITS_ANALYSIS;

//44
typedef struct
{
	uint16_t uwQueue;				//排队超限，非零则超限
	uint16_t uwJam;				//交通状态 0 无效 1 畅通 2 基本畅通 3 轻度拥堵 4 中度拥堵 5 严重拥堵
	//unsigned int udwFlux;				//车流量数  单位 辆/每分钟
	uint16_t udwFlux;				//车流量数  单位 辆/每分钟
	uint16_t r1;
	int16_t udwSpeed;				//平均车速   km/h
	uint16_t r2;
	int16_t udwSpace;				//车间距
	uint16_t r3;
	int16_t uwDensity;           //车辆密度，N/L, 单位：辆/km
	int16_t uwOccupancy;         //车道占有率，扩大1000倍
	uint16_t udwLowSpace;			//
	uint16_t laneno = 0;              //车道级 方向编号   scz 2024年4月24日 不能大于65535
	uint8_t     lane_label;                //车道编号0,1,2,3,4
	uint16_t    carNum;                   //小型车数目
	uint16_t    truckNum;                 //中型车数目
	uint16_t    tankerNum;               //大车数目
	uint8_t		valid : 1;               //是否有该车道 0无1有
	uint8_t		busNum : 7;             //客车数目
	uint8_t     reserve[12];
	//unsigned int udwStyleFlux[5];		//车流量	单位时间 分钟
}DDRIVEWAY_INFO, * LPDRIVEWAYINFO;		//车道报警类型

//sizeof(D_ALARM_ITS_RTINFO) == 382
typedef struct tagiAlarmIVUITSRealTimeInfo : public D_ALARMBASE
{
	D_ALARM_OBJ_INFO its_info;
	DDRIVEWAY_INFO its_statcinfo[6];
}D_ALARM_ITS_RTINFO, * LPD_ALARM_ITS_RTINFO;

typedef struct {
	DWORD packno;
	BYTE protocol;
	BYTE result;
}DATA_RESP, * LPDATA_RESP;

typedef struct {
	char playguid[36];
	char ivuname[32];
	char taskname[64];
}DATA_STARTVIDEO, * LPDATA_STARTVIDEO;


//报警结构体
typedef struct tagAlarmIVUITSAnalysisEx : public tagAlarmIVUITSAnalysis
{
	char guid[37];
	char rel_guid[37];
	uint32_t lng; //经度
	uint32_t lat; //维度
	byte     byNetworkStatus;  //0表示网络好 1表示最近有丢包 2表示最近I帧间隔有变化 3表示既有丢包又有I帧变化
	DA_AlarmType rel_alarm_type = ALARM_0;
	uint32_t rel_alarm_time = 0;
	E_SCENE_TYPE scene_type = E_SCENE_TYPE::SCENE_UNKOWN;
	byte    reserver[2] = { 0 };
	char   mark[35] = { 0 };
}D_ALARM_ITS_ANALYSISEX, * LPD_ALARM_ITS_ANALYSISEX;

//车流量结构体 
typedef struct tagiAlarmIVUITSRealTimeInfoex : public tagiAlarmIVUITSRealTimeInfo
{
	char guid[37];
	uint32_t lng; //经度
	uint32_t lat; //维度
	byte    reserver[12];
}D_ALARM_ITS_RTINFOEX, * LPD_ALARM_ITS_RTINFOEX;;

typedef tagAlarmIVUITSAnalysisEx VA_Alarm;
typedef D_ALARM_ITS_ANALYSISEX D_ALARM_ITS_ANALYSISEXEX;
typedef LPD_ALARM_ITS_ANALYSISEX LPD_ALARM_ITS_ANALYSISEXEX;
typedef	tagiAlarmIVUITSRealTimeInfoex VA_TrafficFlow;

typedef struct VAPlateInfo
{
	DDATE_TIME  time;
	char license[16];	// 车牌字符串
	BYTE platecolor;   //车牌颜色
	BYTE confidence;   //可信度
	char imagepath[100];
	WORD platewidth;  //车牌宽度
	BYTE lanelabel;   //车道标号  0代表所有-不分车道, 1,2,3,4 从里往外  5应急车道
	char reserve[5];

}VA_PlateInfo;

//sizeof(VA_TASK_LIST) = 128
typedef struct tagTaskList
{
	char taskname[64];  //名称
	char ip[16];     //ip
	uint16_t port;   //端口
	uint32_t stat_num; //桩号
	char reserve[42];
}VA_TASK_LIST, * LPVA_TASK_LIST;

typedef struct tagObjIDTrcakInfoList
{
	uint64_t global_id;				//全局ID
	uint64_t vehicle_id;				//本地ID
	//RECT     rcObj;				//目标框
	uint16_t x;
	uint16_t y;
	uint16_t w;
	uint16_t h;
	WORK_TARGET_TYPE     objType;		//目标类型
	uint8_t lane_index;				//上下行
	uint32_t lane_no;			//方向编号
	int16_t speed;				//车速  km/h
	uint64_t time;				//时间戳
	uint8_t   lane_label;				//车道号
	uint32_t lng;			//经度		*1000000
	uint32_t lat;			//维度		*1000000
	uint8_t     time_slot;         //时间段1昼2夜3昼夜交替4天窗
	byte	 data_type;				//数据类型  0:数据记录  1:跟踪画线接力 2:跟踪消失接力 3 车牌信息
	char licenseplate[11];  //抓拍识别的车牌号
	uint8_t license_color;  //车牌颜色 0 未知 1 蓝色 2 黄色 3 白色 4 黑色 5 绿色 6黄绿色-大型新能源车牌颜色
	uint32_t vehicle_statnum;  //车辆桩号
	uint32_t global_index;  //全局ID索引
	uint8_t		posi;		//正反向 0:无效 1：正向 2:反向
	//int         image_channels;    //CV_8UC1  CV_8UC2
	//uint8_t     image_data[192 * 192 * 3];
	uint8_t     reserver[15];     //识别为车牌数据时reserver[0]表示车辆颜色 0 白色 1 灰色 2 黄 3 粉 4 红 5 绿 6 蓝 7 棕 8 黑
	tagObjIDTrcakInfoList()
	{
		memset(this, 0, sizeof(tagObjIDTrcakInfoList));
	}

}VA_IDTRCAK_INFOLIST, * LPVA_IDTRCAK_INFOLIST;

struct tagObjIDTrcakInfoListEx
{
	tagObjIDTrcakInfoList info;
	uint32_t			stat_num;	     //镜头桩号
};

struct TrcakItem
{
	std::vector<tagObjIDTrcakInfoListEx> item;
	size_t			objindex;		     //最近桩号索引
	uint8_t			lane_label;			 //最后使用车道号
	size_t			changeLane;			 //变道次数
	TrcakItem()
	{
		lane_label = -1;
		objindex = -1;
		changeLane = 0;
	}
};

typedef std::map<uint64_t, TrcakItem>	MapTraceList;


typedef struct tagObjIDTrcakInfoToServer
{
	char taskid[16];
	char taskname[64];   //通道名称
	uint32_t	stat_num;	     //桩号
	uint64_t	time;	     //时间戳
	uint8_t		g_lane_index;				//总上下行
	uint8_t     num;        //目标个数
	VA_IDTRCAK_INFOLIST idtrcakInfo[];
	tagObjIDTrcakInfoToServer()
	{
		memset(this, 0, sizeof(tagObjIDTrcakInfoToServer));
	}
}VA_IDTRCAK_INFOLIST_TOSERVER, * LPVA_IDTRCAK_INFOLIST_TOSERVER;

#pragma warning(disable : 4200)
typedef struct VALicense
{
	char taskid[12];
	char taskname[64];
	char roadno[6];
	DWORD laneno;
	DWORD ip;
	BYTE  bSrc;    //0车牌图，1 全图
	BYTE  reserve[9];
	BYTE licensenum;
	//后面紧跟 VA_PlateInfo 结构体
	VA_PlateInfo plateInfo[];
}VA_License, * LP_VA_License;

typedef	struct tagVAAlarmEx
	: public VA_Alarm
{
	char ivuaddr[32];
	int result;
	byte isdelete;
	int filterresult;
	int level;
}VA_AlarmEx, * LPVA_AlarmEx;

typedef struct tagVAAlarmEx2
	: public VA_Alarm
{
	char handlename[20];
	DDATE_TIME handletime;
	byte result;   //0. 未处理 1. 正确报警  2. 误报警 3. 其他
	char mark[200];
}VA_AlarmEx2, * LPA_AlarmEx2;

//摄像机信息 scz 新增
typedef struct tagCameraInfo
{
	char ip[32];	//ip
	char user[32];	//用户名
	char pwd[32];	//密码
	VA_CAMERA_BRAND brand; //品牌
	char model[32];  //型号
	WORD httpport;
	WORD rtspport;
	WORD httpsport;
	WORD serverport;
	WORD onvifport;

	tagCameraInfo()
	{
		memset(this, 0, sizeof(tagCameraInfo));
		httpport = 80;
		rtspport = 554;
		httpsport = 443;
		onvifport = 80;
	}
}VA_CAMERA_INFO, * LPVA_CAMERA_INFO;

//锥桶上传信息
typedef struct tagReflectiveConeInfo
{
	uint16_t x;
	uint16_t y;
	uint16_t w;
	uint16_t h;
	uint8_t   lanelabel;				//车道号
	uint32_t  statnum;                 //锥桶桩号
	BYTE reserve[20];
}VA_REFLECTIVECONE_INFO, * LPVA_REFLECTIVECONE_INFO;

typedef struct tagReflectiveConeInfoToServer
{
	char taskid[16];
	char taskname[64];   //通道名称
	char road_no[6];
	uint32_t	stat_num;	     //杆子桩号
	uint64_t	time;	     //时间戳
	uint8_t		lane_index;				//上下行
	BYTE		reserve[20];		//服务器临时需要使用8个字节
	uint8_t     num;        //目标个数
	VA_REFLECTIVECONE_INFO reflectiveConeInfo[];
	tagReflectiveConeInfoToServer()
	{
		memset(this, 0, sizeof(tagReflectiveConeInfoToServer));
	}
}VA_REFLECTIVECONE_INFO_TOSERVER, * LPVA_REFLECTIVECONE_INFO_TOSERVER;

//数据包
typedef struct tagVAPack
{
	uint8_t* data;   //数据地址   //注意前面是否有LWS_PRE个字节预留
	uint32_t len;	 //数据长度   //data的数据长度
	VA_PACK_TYPE type;   //数据类型
	time_t	time;		//时间
	bool bin;			//是否二进制
	bool json;			//是否json
	uint16_t count;		//数据总数
	uint32_t rever;
	tagVAPack()
	{
		memset(this, 0, sizeof(tagVAPack));
	};
}VA_PACK, * LPVA_PACK;

//0x2A 下发报警数据
typedef struct tagHjAlarmData {
	DDATE_TIME time;   //报警时间
	DA_AlarmType alarmtype;  //报警类型
	char	guid[37];	//报警记录ID
	VA_ALARM_DATA_TYPE datatype; //数据类型
	VA_DATA_CATA datacata;   //数据存放目录
	eTimeSlot timeslot;
	uint8_t  targetType;  //WORK_TARGET_TYPE
	uint8_t  version;	 //YOLO_VERSION_ALGO
	uint8_t reser[12];	//预留
	uint32_t len;		//数据长度
	uint8_t data[];    //数据
	tagHjAlarmData() {
		memset(this, 0, sizeof(tagHjAlarmData));
	}
}HJALARMDATA, * LPHJALARMDATA;

//0x18 下发报警数据,定时发的实时图像
typedef struct tagHjAlarmDataEx {
	char    taskname[64];  //通道名称
	SYSTEMTIME time;   //报警时间
	DA_AlarmType alarmtype;  //报警类型
	char	guid[37];	//报警记录ID
	VA_ALARM_DATA_TYPE datatype; //数据类型
	VA_DATA_CATA datacata;   //数据存放目录
	eTimeSlot timeslot;
	uint8_t  targetType;  //WORK_TARGET_TYPE
	uint8_t  version;	 //YOLO_VERSION_ALGO
	uint8_t reser[12];	//预留
	uint32_t len;		//数据长度
	uint8_t data[];    //数据
	tagHjAlarmDataEx() {
		memset(this, 0, sizeof(tagHjAlarmDataEx));
	}
}HJALARMDATAEX, * LPHJALARMDATAEX;

//下发图像数据
typedef struct tagHjImageData
{
	char      taskid[16];
	char      road_no[6];
	uint64_t  objid;				//目标ID
	char	  licenseplate[11];  //车牌号
	uint8_t      ncolor;            //车牌颜色 0 未知 1 蓝色 2 黄色 3 白色 4 黑色 5 绿色 6黄绿色-大型新能源车牌颜色
	byte      send_type;         // 1 va发送  2 车牌算法发送 3 post给浙高运的图像数据
	uint64_t  time;               //时间戳
	VA_ALARM_DATA_TYPE datatype; //图像数据类型
	uint8_t reser[128];	//预留  //识别为车牌数据时reser[0]表示车辆颜色 0 白色 1 灰色 2 黄 3 粉 4 红 5 绿 6 蓝 7 棕 8 黑
	uint32_t len;		//数据长度
	uint8_t data[];    //图像数据
	tagHjImageData()
	{
		memset(this, 0, sizeof(tagHjImageData));
	}

}HJIMAGEDATA, * LPIMAGEDATA;

//收费站拥堵信息
typedef struct tagCongestionInfo
{
	char      taskname[64];  //通道名称    命名以XXX收费站开头
	uint64_t  t;               //时间戳
	uint16_t  congest_length;  //拥堵长度
	uint16_t  ramp_length;  //总长度
	char	  roadno[10];		//公路编号
	uint8_t   lane_label : 3;   //车道0代表全部 取值[0,5]   必填
	uint8_t   jam_level : 3;    //0.未知 1.畅通 2.基本畅通 3.轻度拥堵 4.中度拥堵  5.严重拥堵
	uint8_t   posinega : 2;    // 0.反向   1.正向   必填
	uint8_t   lane_index : 2;  //0. 无效  1. 下行  2. 上行  跟原有的定义不同
	int       laneno;          //方向编号
	uint8_t   r : 6;
	uint32_t  lng;
	uint32_t  lat;
	char      direct[11];  //方向名称   入口方向/出口方向
	VA_ALARM_DATA_TYPE datatype; //图像数据类型
	uint8_t   congest_state;   //拥堵状态 0 未拥堵 1 拥堵开始 2 拥堵中 3 拥堵结束
	uint8_t   reser[15]; //预留
	uint32_t  len;   //图像数据长度
	uint8_t   data[0];  //图像数据
	tagCongestionInfo()
	{
		//roadno, direct, lane_index, lng, lat 以页面数据为准
		memset(this, 0, sizeof(tagCongestionInfo));
	}
}CONGESTIONINFO, * LPCONGESTIONINFO;

//隧道行车信息
typedef struct tagTrainWorkInfo
{
	char    taskid[16];
	char    roadno[10];		//公路编号
	char    guid[37];       //id
	uint64_t   time;               //时间戳 毫秒
	uint8_t    lane_label;    // 车道
	uint8_t    lane_index;    // 上下行 0 下行 1 上行
	char	   licenseplate[11];  //车牌号
	uint8_t    speed;             //车速
	uint8_t    ncolor;            //车身颜色
	uint8_t    car_length;        //车长度
	uint8_t    car_type;          // 车型 0 未知 1 行人 2 非机动车 3 小型车 4 中型车 5 大型
	uint8_t    reser[32];

	tagTrainWorkInfo()
	{
		memset(this, 0, sizeof(tagTrainWorkInfo));
	}
}TRAINWORKINFO, * LPTRAINWORKINFO;

typedef struct tagAllDISKSTATUS
{
	char	diskName;				//磁盘数量
	int		total;					//所有磁盘总容量MB
	int		ofFree;				    //所有磁盘剩余容量MB
}AllDISKSTATUS, * LPAllDISKSTATUS;

#define HJ_MAX_GPU_NUM     4					// 监控的GPU个数（NVIDIA定义的最多GPU个数是64，这里最多只监控4个
typedef struct tagGpuInfo
{
	char	name[20];
	WORD    utilizationRate;   //千分制 GPU使用率
	WORD    memusage;   //千分制 GPU显存使用率
	WORD	temperature;	//0.1度  GPU温度
	BYTE	decUtilization;		//解码使用率
	BYTE    encUtilization;		//编码使用率
	uint8_t    reser[4];			//预留
}GPUINFO;

#define HJ_MAX_DISK_NUM    10
typedef struct SERVER_STATUS
{
	DWORD64 osRunTime;
	DWORD backTime;
	WORD cpuUsage;   //千分制
	GPUINFO gpuUsage[HJ_MAX_GPU_NUM];
	WORD memUsage; // 千分制
	AllDISKSTATUS diskUsage[HJ_MAX_DISK_NUM];
	WORD cputemp;  //CPU温度  摄氏度
	char ipAddr[16] = { 0 };
}SERVERSTATUS, * HJSERVERSTATUS;

typedef struct SERVER_STATUS_EX : public SERVER_STATUS
{
	time_t recvTime = 0;
	time_t lastOffDetect = 0;
	time_t lastDiskDetect = 0;
	uint32_t r[8] = { 0 };
}SERVERSTATUSEX, * HJSERVERSTATUSEX;

enum class eDEVICE_TYPE : uint8_t
{
	DT_ALL = 0x00,
	DT_GT_EDGE = 0x01, //高瞳盒子
	DT_HJ_DOG = 0x02,  //慧景软件狗
	DT_HJ_VA = 0x03,  //慧景VA
};

typedef struct tagDeviceDiscover
{
	eDEVICE_TYPE type = eDEVICE_TYPE::DT_ALL;
	uint8_t r[31] = { 0 };
};

//设置地址 128
typedef struct tagAddressIPv4
{
	uint8_t bVersion = 4;   // 取值4为ipv4, 6为ipv6
	uint8_t bDHCP = 0;      // 是否启用DHCP,  如果启动, 后面配置无效
	char srcip[16] = { 0 };    // 原IP
	char ip[16] = { 0 };
	char mask[16] = { 0 };
	char gateway[16] = { 0 };
	char dns[16] = { 0 };
	char dns_back[16] = { 0 };
	uint8_t r[30] = { 0 };
}IPv4_ADDRESS;

// 468
typedef struct tagDeviceInfo2
{
	uint8_t no = 1;								//序号, 设备层, 无用
	uint8_t channel_num = 4;					//通道数, 设备最大配置路数
	uint16_t port = 8000;
	uint16_t http_port = 80;
	uint8_t activate = false;
	uint8_t r = 0;
	char type[20] = { "" };
	char version[12] = { "1.0.0" };				//版本
	char ip[32] = { 0 };						//设备地址
	char gateway[32] = { "192.168.1.1" };		//设备网关
	char sn[32] = { "DWW74T3" };				//设备序号
	char subnet_mask[32] = { "255.255.255.0" };   //设备子网掩码
	char mac_address[32] = { "CC-96-E5-00-A6-6B" };   //mac地址
	char device_name[64] = { "" };
	eDEVICE_TYPE device_type = eDEVICE_TYPE::DT_ALL;
	time_t time = 0;  //时间戳
	uint8_t bDHCP = 0;  //是否启用DHCP,  如果启动, 后面配置无效
	char device_no[12] = { "GT-001" };                 // 设备编号
	char dns[32] = { "0.0.0.0" };                // 首选DNS
	char dns_pack[32] = { "0.0.0.0" };               // 备选DNS
	uint8_t rr[118] = { 0 };
}DEVICE_INFO, * LPDEVICE_INFO;

//用于系统日志
#define LOG_LEVEL_1		1
#define LOG_LEVEL_2		2
#define LOG_LEVEL_3		3
#define LOG_LEVEL_4		4
typedef struct tagVA_LOG_DATA
{
	char ip[16];		//分析地址
	uint8_t no;  //序号  端口 - 20010
	uint8_t level;  //等级    1严重  2重要  3警告  4提示
	uint16_t r;
	uint64_t time;   //时间
	char taskname[64];  //通道名称
	char mark[280];    //详细信息
	tagVA_LOG_DATA()
	{
		memset(this, 0, sizeof(tagVA_LOG_DATA));
	}
}VA_LOG_DATA;


//施工区域(通信使用)
typedef struct tagConstructionAreaMsg
{
	char		guid[37];								//施工ID
	char		roadno[6];								//公路编号  例如:G60

	//人工确认信息
	uint32_t	start_stat_num;							//开始桩号
	uint32_t	end_stat_num;							//结束桩号
	uint64_t	start_time;								//开始时间		毫秒
	uint64_t	end_time;								//结束时间		同上
	uint64_t    real_end_time;							//实际结束时间	同上
	uint8_t		lane_index;								//上下行  0. 下行 1. 上行 
	//uint8_t     lane_label;							//车道编号0,1,2,3,4  //TODO 需要改成数组lane_label[7]
	int			 lane_label;							//车道编号 位表示
	uint8_t		lane_label_max;							//最大车道数量
	char		add_name[50];							//添加人员

	//计算和人工确认综合后的数据
	uint32_t	com_start_stat_num;						//开始桩号
	uint32_t	com_end_stat_num;						//结束桩号
	uint64_t    com_end_time;							//结束时间	同上
	int			set_lane_label;							//车道编号 位表示
};

//施工区域（结构体不能使用memset操作）
typedef struct tagConstructionArea
{
	char		guid[37];								//施工ID
	char		roadno[6];								//公路编号  例如:G60

	//人工确认信息
	uint32_t	start_stat_num;							//开始桩号
	uint32_t	end_stat_num;							//结束桩号
	uint64_t	start_time;								//开始时间		毫秒
	uint64_t	end_time;								//结束时间		同上
	uint64_t    real_end_time;							//实际结束时间	同上
	uint8_t		lane_index;								//上下行  0. 下行 1. 上行 
	//uint8_t     lane_label;							//车道编号0,1,2,3,4  //TODO 需要改成数组lane_label[7]
	std::set<uint8_t> set_lane_label;
	uint8_t		lane_label_max;							//最大车道数量
	char		add_name[50];							//添加人员

	//计算和人工确认综合后的数据
	uint32_t	com_start_stat_num;						//开始桩号
	uint32_t	com_end_stat_num;						//结束桩号
	uint64_t    com_end_time;							//结束时间	同上
	std::set<uint8_t>com_set_lane_label;						//车道编号

	//
	int			end_count;								//结束统计
	bool		time_init;								//开始结束时间为手动设置
	tagConstructionArea()
	{
		ZeroMemory(guid, sizeof(guid));
		ZeroMemory(add_name, sizeof(add_name));
		ZeroMemory(roadno, sizeof(roadno));
		start_stat_num = 0;
		end_stat_num = 0;
		start_time = 0;
		end_time = 0;
		real_end_time = 0;
		lane_index = 0;
		lane_label_max = 0;
		com_start_stat_num = 0;
		com_end_stat_num = 0;
		com_end_time = 0;
		end_count = 0;
		time_init = false;
		set_lane_label.clear();
		com_set_lane_label.clear();
	}
	tagConstructionArea(const tagConstructionArea& s)
		:set_lane_label(s.set_lane_label),
		com_set_lane_label(s.com_set_lane_label)
	{
		CopyMemory(this->guid, s.guid, sizeof(this->guid));
		CopyMemory(this->add_name, s.add_name, sizeof(this->add_name));
		CopyMemory(this->roadno, s.roadno, sizeof(this->roadno));
		//人工确认信息
		this->start_stat_num = s.start_stat_num;							//开始桩号
		this->end_stat_num = s.end_stat_num;							//结束桩号	
		this->start_time = s.start_time;								//开始时间		毫秒
		this->end_time = s.end_time;								//结束时间		同上	
		this->real_end_time = s.real_end_time;							//实际结束时间	同上
		this->lane_index = s.lane_index;								//上下行  0. 下行 1. 上行 
		this->lane_label_max = s.lane_label_max;							//最大车道数量
		this->end_count = s.end_count;							//最大车道数量
		this->time_init = s.time_init;

		//计算和人工确认综合后的数据
		this->com_start_stat_num = s.com_start_stat_num;						//开始桩号
		this->com_end_stat_num = s.com_end_stat_num;						//结束桩号
		this->com_end_time = s.com_end_time;							//结束时间	同上
	}
	tagConstructionArea& operator=(const tagConstructionArea& s)
	{
		if (this != &s)
		{
			CopyMemory(this->guid, s.guid, sizeof(this->guid));
			CopyMemory(this->add_name, s.add_name, sizeof(this->add_name));
			CopyMemory(this->roadno, s.roadno, sizeof(this->roadno));
			//人工确认信息
			this->start_stat_num = s.start_stat_num;							//开始桩号
			this->end_stat_num = s.end_stat_num;							//结束桩号	
			this->start_time = s.start_time;								//开始时间		毫秒
			this->end_time = s.end_time;								//结束时间		同上	
			this->real_end_time = s.real_end_time;							//实际结束时间	同上
			this->lane_index = s.lane_index;								//上下行  0. 下行 1. 上行 
			this->lane_label_max = s.lane_label_max;							//最大车道数量
			this->set_lane_label = s.set_lane_label;
			this->end_count = s.end_count;							//最大车道数量
			this->time_init = s.time_init;

			//计算和人工确认综合后的数据
			this->com_start_stat_num = s.com_start_stat_num;						//开始桩号
			this->com_end_stat_num = s.com_end_stat_num;						//结束桩号
			this->com_end_time = s.com_end_time;							//结束时间	同上
			this->com_set_lane_label = s.com_set_lane_label;
		}
		return *this;
	}
	//车道转换为string '，'分割
	std::string LaneLabelToString(bool com) const
	{
		std::string str;
		if (com)
		{
			for (auto& it : com_set_lane_label)
			{
				str += std::to_string(it) + ",";
			}
		}
		else
		{
			for (auto& it : set_lane_label)
			{
				str += std::to_string(it) + ",";
			}
		}

		return str;
	}
	//车道转换为二进制数
	int LaneLabelToInt(bool com) const
	{
		int nValue = 0;
		if (com)
		{
			for (auto& it : com_set_lane_label)
			{
				if (it == 0)
				{
					nValue = 0;
					break;
				}
				nValue |= (int)pow(2, it);
			}
		}
		else
		{
			for (auto& it : set_lane_label)
			{
				if (it == 0)
				{
					nValue = 0;
					break;
				}
				nValue |= (int)pow(2, it);
			}
		}

		return nValue;
	}

	//二进制数转换为车道
	void IntToLaneLabel(bool com, int nValue)
	{
		if (nValue == 0xFF)
		{
			return;
		}
		if (com)
		{
			com_set_lane_label.clear();
			if (nValue == 0)
			{
				com_set_lane_label.insert(0);
			}
			else
			{
				for (int i = 1; i < 10; i++)
				{
					auto k = (int)pow(2, i);
					if ((nValue & k) > 0)
					{
						com_set_lane_label.insert(i);
					}
				}
			}
		}
		else
		{
			set_lane_label.clear();
			if (nValue == 0)
			{
				set_lane_label.insert(0);
			}
			else
			{
				for (int i = 1; i < 10; i++)
				{
					auto k = (int)pow(2, i);
					if ((nValue & k) > 0)
					{
						set_lane_label.insert(i);
					}
				}
			}
		}
	}
}VA_CONSTRUCTION_AREA;

// 复选框勾选
typedef struct tagCheckBox
{
	VA_CONTROL_TYPE control_type = VA_CONTROL_TYPE::VBT_CHECK_BOX;
	// 1bit 0 read or 1 set + 2bit checkbox type + 64bit taskname + 1bit value + 1bit result
	uint8_t bSet;                    // 0获取或 1 设置
	VA_CONFIG_CHECKBOX_TYPE checkbox_type;          // 复选框类型
	char taskName[64] = { 0 };       // 通道名
	uint8_t value;                   // 值:1 勾选 0 不勾选
	uint8_t result = 0;              // 处理结果  0: 失败  1:成功
	uint16_t r = 0;
}CHECK_BOX, * LPCHECK_BOX;

// 摄像机状态
typedef struct tagCamerAStatus
{
	char id[13];         // 13bit 设备ID 
	uint8_t status;      // 1bit  状态
	char ip[16];         // 16bit 摄像头IP
	uint8_t rr[32] = { 0 };
}CAMERA_STATUS, * LPCAMERA_STATUS;

// 报警确认信息 //505
typedef struct tagAlarmConfirm
{
	char taskName[64] = { 0 };   // 通道名
	char eventID[37] = { 0 };    // 事件编号
	SYSTEMTIME alarmTime = { 0 };        // 报警时间
	char strMark[200] = { 0 };
	int result = 0;                   //处理结果   1. 正确.  2 误报  3. 其他   ... 详情见文档
	int level = 0;                  // 报警等级      1. 严重  2. 重要   3. 警告   4. 提示
	char strServiceAddr[32] = { 0 };
	char strFullName[50] = { 0 };       //处理人姓名
	E_FILTER  filter_result = E_FILTER::FILTER_NO;    //误报原因
	char otherReason[20] = { 0 };  // 其他 58100
	uint8_t rr[29] = { 0 };
	//kafka 施工信息
	DWORD dwEventStatus = 0;
	int nDirection = 0;
	int nBeginMilestone = 0;
	int nEndMilestone = 0;
	char szJeeves[32] = { 0 };
	//end
}ALARM_CONFIRM, * LPALARM_CONFIRM;

#pragma  pack(pop)

enum class VA_PIC_LIST_TYPE : uint8_t
{
	VPLT_LIST = 0x00, //巡查列表
	VPLT_NORMAL = 0x01, //已巡查
	VPLT_GREEN = 0x02, //绿化修整列表
	VPLT_LENS = 0x03, //镜头问题列表
	VPLT_CONFIG = 0x04, //镜头偏移,需要重新配置
	VPLT_USERS = 99, //自定义
};

class CHjDataConver {
public:
	static int conver_sendpack(LPBYTE dest, LPBYTE src, WORD srclen, BYTE subno, DWORD packno, BYTE protocol, BYTE ver = 0x01)
	{
		HJDATAHEAD head;
		memset(&head, 0, sizeof(HJDATAHEAD));
		head.head = DATA_HEAD;
		head.subno = subno;
		*((WORD*)head.len) = htons(srclen);
		head.packno = htonl(packno);
		head.protocol = protocol;
		head.ver = ver;

		BYTE check = 0;
		int j = 0;
		// 		memcpy(dest, &head, sizeof(HJDATAHEAD2));
		// 		j += sizeof(HJDATAHEAD2);
		LPBYTE pHead = (LPBYTE)&head + 1;
		dest[j++] = DATA_HEAD;
		for (int i = 0; i < sizeof(head) - 1; i++) {
			check ^= pHead[i];
			if (pHead[i] == DATA_HEADTAIL || pHead[i] == DATA_CONVER) //转义
			{
				dest[j++] = DATA_CONVER;
				dest[j++] = pHead[i] ^ 0x20;
			}
			else
				dest[j++] = pHead[i];
		}
		for (int i = 0; i < srclen; i++)
		{
			check ^= src[i];
			if (src[i] == DATA_HEADTAIL || src[i] == DATA_CONVER) //转义
			{
				dest[j++] = DATA_CONVER;
				dest[j++] = src[i] ^ 0x20;
			}
			else
				dest[j++] = src[i];
		}
		//转义校验值
		if (check == DATA_HEADTAIL || check == DATA_CONVER)
		{
			dest[j++] = DATA_CONVER;
			dest[j++] = check ^ 0x20;
		}
		else
			dest[j++] = check;

		//加上尾
		dest[j++] = DATA_HEADTAIL;
		return j;
	}
	//新协议
	static int conver_sendpack2(LPBYTE dest, LPBYTE src, DWORD srclen, BYTE subno, DWORD packno, BYTE protocol, BYTE ver = 0x01)
	{
		static DWORD64 headid = 0xABAAAAAAAAAAAAAA;
		if (dest == nullptr) return (sizeof(HJDATAHEAD2) + srclen + 2);
		HJDATAHEAD2 head;
		memset(&head, 0, sizeof(HJDATAHEAD2));
		memcpy(&head.head, &headid, sizeof(DWORD64));
		head.subno = subno;
		head.len = htonl(srclen);
		head.packno = htonl(packno);
		head.protocol = protocol;
		head.ver = ver;

		int j = 0;
		memcpy(dest, &head, sizeof(HJDATAHEAD2));
		j += sizeof(HJDATAHEAD2);
		if (src) memcpy(dest + j, src, srclen);
		j += srclen;

		//check
		dest[j++] = 0x00;
		//end
		dest[j++] = 0xab;

		return j;
	}
	//calculate check,纯数据，有长度(已经包含校验位)无校验
	static int conver_sendpack_check(LPBYTE dest, LPBYTE src, int len)
	{
		BYTE check = 0;
		int j = 0;
		dest[j++] = DATA_HEADTAIL;
		for (int i = 0; i < len - 1; i++)
		{
			check ^= src[i];
			if (src[i] == DATA_HEADTAIL || src[i] == DATA_CONVER) //转义
			{
				dest[j++] = DATA_CONVER;
				dest[j++] = src[i] ^ 0x20;
			}
			else
				dest[j++] = src[i];
		}
		//转义校验值
		if (check == DATA_HEADTAIL || check == DATA_CONVER)
		{
			dest[j++] = DATA_CONVER;
			dest[j++] = check ^ 0x20;
		}
		else
			dest[j++] = check;

		//加上尾
		dest[j++] = DATA_HEADTAIL;
		return j;
	}
	//收到一个完整数据包后解析数据
	static bool conver_recvpack(LPBYTE pBuf, int& len)
	{
		if (pBuf == NULL) return false;
		BYTE* pb = (BYTE*)pBuf;
		if ((pb[0] != DATA_HEADTAIL) || (pb[len - 1] != DATA_HEADTAIL)) return false;

		BYTE check = 0;
		int i = 0;

		for (i = 1; i < len && pb[i] != DATA_HEADTAIL; i++)
		{

			if (pb[i] == DATA_CONVER)
			{
				pb[i] = pb[i + 1] ^ 0x20;
				memmove(&pb[i + 1], &pb[i + 2], len - i - 2);
			}

			check ^= pb[i];
		}

		len = i + 1;
		return check == 0;
	}

	//收到一个完整数据包后校验数据
	static bool conver_recvpack2(LPBYTE pBuf, int& len)
	{
		if (pBuf == NULL) return false;
		if (len < sizeof(HJDATAHEAD2)) return false;
		static DWORD64 headid = 0xABAAAAAAAAAAAAAA;
		if ((*(DWORD64*)pBuf) != headid) return false;
		if (pBuf[len - 1] != 0xab) return false;
		static BYTE check = 0x00;
		if (pBuf[len - 2] != check) return false;
		auto pHead = (HJDATAHEAD2*)pBuf;
		//pHead->len = htonl(pHead->len); 还原, 不对包做出改变.
		//pHead->packno = htonl(pHead->packno);
		return true;

		BYTE* pb = (BYTE*)pBuf;
		if ((pb[0] != DATA_HEADTAIL) || (pb[len - 1] != DATA_HEADTAIL)) return false;

		int i = 0;

		for (i = 1; i < len && pb[i] != DATA_HEADTAIL; i++)
		{
			//不转义
			/*
			if(pb[i]==DATA_CONVER)
			{
				pb[i] = pb[i+1]^0x20;
				memmove(&pb[i+1],&pb[i+2],len-i-2);
			}
			*/
			check ^= pb[i];
		}

		len = i + 1;
		return check == 0;
	}

};


#endif