#ifndef NETMODULE_H
#define NETMODULE_H

#ifdef WIN32

#ifdef NETMODULE_EXPORTS
#define H264_DVR_API  extern "C" __declspec(dllexport)
#else
#define H264_DVR_API  extern "C" __declspec(dllimport)   //VC 用
#endif

#ifndef CALL_METHOD
#define CALL_METHOD	__stdcall  //__cdecl
#endif
#define DEF_PARAM(x) = x
#define DEF_0_PARAM = 0
#else	//linux

#define Bool int
#define LOGD printf
#ifdef OS_IOS
#define H264_DVR_API
#define DEF_PARAM(x)
#define DEF_0_PARAM
#define TYPE_USER_DATA  unsigned long
#define TYPE_USER_DATA2  long
#else
#define H264_DVR_API	extern "C"
#define DEF_PARAM(x) = x
#define DEF_0_PARAM = 0
#endif
#define CALL_METHOD
#define CALLBACK
#define WORD	unsigned short
#define DWORD	unsigned long
#define LPDWORD	DWORD*
#define BOOL	int
#define TRUE	1
#define FALSE	0
#define BYTE	unsigned char
#define LONG	long
#define UINT	unsigned int
#define HDC		void*
#define HWND	void*
#define LPVOID	void*
//#define 0	0
#define LPCSTR  char*
#define LPCTSTR  const char*
#endif

enum SDK_RET_CODE
{
	H264_DVR_NOERROR				    = 0,				//没有错误
	H264_DVR_SUCCESS					= 1,				//返回成功
	H264_DVR_SDK_NOTVALID				= -10000,			//非法请求
	H264_DVR_NO_INIT					= -10001,			//SDK未经初始化
	H264_DVR_ILLEGAL_PARAM				= -10002,			//用户参数不合法
	H264_DVR_INVALID_HANDLE				= -10003,			//句柄无效
	H264_DVR_SDK_UNINIT_ERROR			= -10004,			//SDK清理出错
	H264_DVR_SDK_TIMEOUT				= -10005,			//等待超时
	H264_DVR_SDK_MEMORY_ERROR			= -10006,			//内存错误，创建内存失败
	H264_DVR_SDK_NET_ERROR				= -10007,			//网络错误
	H264_DVR_SDK_OPEN_FILE_ERROR		= -10008,			//打开文件失败
	H264_DVR_SDK_UNKNOWNERROR			= -10009,			//未知错误
	H264_DVR_DEV_VER_NOMATCH			= -11000,			//收到数据不正确，可能版本不匹配
	H264_DVR_SDK_NOTSUPPORT				= -11001,			//版本不支持

	H264_DVR_OPEN_CHANNEL_ERROR			= -11200,			//打开通道失败
	H264_DVR_CLOSE_CHANNEL_ERROR		= -11201,			//关闭通道失败
	H264_DVR_SUB_CONNECT_ERROR			= -11202,			//建立媒体子连接失败
	H264_DVR_SUB_CONNECT_SEND_ERROR		= -11203,			//媒体子连接通讯失败
	H264_DVR_NATCONNET_REACHED_MAX		= -11204,           //Nat视频链接达到最大，不允许新的Nat视频链接 

	/// 用户管理部分错误码
	H264_DVR_NOPOWER					= -11300,			//无权限
	H264_DVR_PASSWORD_NOT_VALID			= -11301,			// 账号密码不对
	H264_DVR_LOGIN_USER_NOEXIST			= -11302,			//用户不存在
	H264_DVR_USER_LOCKED				= -11303,			// 该用户被锁定
	H264_DVR_USER_IN_BLACKLIST			= -11304,			// 该用户不允许访问(在黑名单中)
	H264_DVR_USER_HAS_USED				= -11305,			// 该用户已登陆
	H264_DVR_USER_NOT_LOGIN				= -11306,			// 该用户没有登陆
	H264_DVR_CONNECT_DEVICE_ERROR		= -11307,			//可能设备不存在
	H264_DVR_ACCOUNT_INPUT_NOT_VALID	= -11308,			//用户管理输入不合法
	H264_DVR_ACCOUNT_OVERLAP			= -11309,			//索引重复
	H264_DVR_ACCOUNT_OBJECT_NONE		= -11310,			//不存在对象, 用于查询时
	H264_DVR_ACCOUNT_OBJECT_NOT_VALID	= -11311,			//不存在对象
	H264_DVR_ACCOUNT_OBJECT_IN_USE		= -11312,			//对象正在使用
	H264_DVR_ACCOUNT_SUBSET_OVERLAP		= -11313,			//子集超范围 (如组的权限超过权限表，用户权限超出组的权限范围等等)
	H264_DVR_ACCOUNT_PWD_NOT_VALID		= -11314,			//密码不正确
	H264_DVR_ACCOUNT_PWD_NOT_MATCH		= -11315,			//密码不匹配
	H264_DVR_ACCOUNT_RESERVED			= -11316,			//保留帐号


	/// 配置管理相关错误码
	H264_DVR_OPT_RESTART				= -11400,			// 保存配置后需要重启应用程序
	H264_DVR_OPT_REBOOT					= -11401,			// 需要重启系统
	H264_DVR_OPT_FILE_ERROR				= -11402,			// 写文件出错
	H264_DVR_OPT_CAPS_ERROR				= -11403,			// 配置特性不支持
	H264_DVR_OPT_VALIDATE_ERROR			= -11404,			// 配置校验失败
	H264_DVR_OPT_CONFIG_NOT_EXIST		= -11405,			// 请求或者设置的配置不存在
	
	//
	H264_DVR_CTRL_PAUSE_ERROR			= -11500,			//暂停失败
	H264_DVR_SDK_NOTFOUND				= -11501,			//查找失败，没有找到对应文件
	H264_DVR_CFG_NOT_ENABLE				= -11502,           //配置未启用

	H264_DVR_DECORD_FAIL				= -11503,           //解码失败

	//DNS协议解析返回错误码
	H264_DVR_SOCKET_ERROR				= -11600,			//创建套节字失败
	H264_DVR_SOCKET_CONNECT				= -11601,			//连接套节字失败
	H264_DVR_SOCKET_DOMAIN				= -11602,			//域名解析失败
	H264_DVR_SOCKET_SEND				= -11603,			//发送数据失败
	H264_DVR_ARSP_NO_DEVICE				= -11604,			//没有获取到设备信息，设备应该不在线
	H264_DVR_ARSP_BUSING				= -11605,			//ARSP服务繁忙
	H264_DVR_ARSP_BUSING_SELECT			= -11606,			//ARSP服务繁忙,select失败
	H264_DVR_ARSP_BUSING_RECVICE		= -11607,			//ARSP服务繁忙,recvice失败
	H264_DVR_CONNECTSERVER_ERROR		= -11608,			//连接服务器失败
    H264_DVR_CONNECT_AGNET     			= -11609,			//代理
    H264_DVR_CONNECT_NAT      			= -11610,			//穿透
    H264_DVR_CONNECT_FAILED				= -11611,			//连接失败
    H264_DVR_CONNECT_FULL				= -11612,			//服务器连接数已满
	H264_DVR_CLOUD_LOGIN_ERR			= -11613,	        //云登陆具体的错误码,说明:当登陆接口的error=-11613时，通过H264_DVR_DEVICEINFO成员sCloudErrCode获取错误码,底层增加错误码时上层不用增加代码
	H264_DVR_NO_CONNECT_FRONT			= -11614,			//前端设备未连接或者连接的前端设备分辨率未知
	H264_DVR_ARSP_USER_NOEXIST			= -11619,			//用户不存在 
	H264_DVR_ARSP_PASSWORD_ERROR		= -11620,			// 账号密码不对
	H264_DVR_ARSP_QUERY_ERROR			= -11621,			//	查询失败 
	//版权相关
	H264_DVR_PIRATESOFTWARE				= -11700,			//设备盗版
	H264_DVR_AUTH_TIMEOUT          		= -11800,			//鉴权超时
	H264_DVR_AUTH_FILE_FAILED			= -11801,			//鉴权文件失败
	H264_DVR_GAIN_LIST_TIMEOUT			= -11802,			//获取服务器列表超时
	H264_DVR_AUTH_CODE_ERR				= -11803,			//鉴权码错误
	//升级错误码
	H264_DVR_NOENOUGH_MEMORY			= -11804,			//内存不足
	H264_DVR_INVALID_FORMAT				= -11805,			//升级文件格式不对
	H264_DVR_UPDATE_PART_FAIL			= -11806,			//某个分区升级失败
	H264_DVR_INVALID_HARDWARE			= -11807,			//硬件型号不匹配
	H264_DVR_INVALID_VENDOR				= -11808,			//客户信息不匹配
	H264_DVR_INVALID_COMPALIBLE			= -11809,			//升级程序的兼容版本号比设备现有的小，不允许设备升级回老程序
	H264_DVR_INVALID_VERSION			= -11810,			//非法的版本
	H264_DVR_INVALID_WIFI_DRIVE			= -11811,			//升级程序里wifi驱动和设备当前在使用的wifi网卡不匹配
};


//云台操作类型
enum PTZ_ControlType
{
	TILT_UP = 0,			//上
	TILT_DOWN,				//下
	PAN_LEFT,				//左
	PAN_RIGHT,				//右
	PAN_LEFTTOP,			//左上
	PAN_LEFTDOWN,			//左下
	PAN_RIGTHTOP,			//右上
	PAN_RIGTHDOWN,			//右下
	ZOOM_OUT_1,				//变倍小//ZOOM_OUT/ZOOM_IN在VS2010与系统定义的冲突了
	ZOOM_IN_1,				//变倍大
	FOCUS_FAR,				//焦点后调
	FOCUS_NEAR,				//焦点前调
	IRIS_OPEN,				//光圈扩大
	IRIS_CLOSE,				//光圈缩小13

	EXTPTZ_OPERATION_ALARM,			//报警功能 
	EXTPTZ_LAMP_ON,					//灯光开
	EXTPTZ_LAMP_OFF,				//灯光关
	EXTPTZ_POINT_SET_CONTROL,		//设置预置点 
	EXTPTZ_POINT_DEL_CONTROL,		//清除预置点 
	EXTPTZ_POINT_MOVE_CONTROL,		//转预置点
	EXTPTZ_STARTPANCRUISE,			//开始水平旋转		20	
	EXTPTZ_STOPPANCRUISE,			//停止水平旋转	
	EXTPTZ_SETLEFTBORDER,			//设置左边界		
	EXTPTZ_SETRIGHTBORDER,			//设置右边界	
	EXTPTZ_STARTLINESCAN,			//自动扫描开始 
	EXTPTZ_CLOSELINESCAN,			//自动扫描开停止 
	EXTPTZ_ADDTOLOOP,				//加入预置点到巡航	p1巡航线路	p2预置点值	
	EXTPTZ_DELFROMLOOP,				//删除巡航中预置点	p1巡航线路	p2预置点值	
	EXTPTZ_POINT_LOOP_CONTROL,		//开始巡航 28
	EXTPTZ_POINT_STOP_LOOP_CONTROL,	//停止巡航
	EXTPTZ_CLOSELOOP,				//清除巡航	p1巡航线路		
	EXTPTZ_FASTGOTO,				//快速定位	
	EXTPTZ_AUXIOPEN,				//辅助开关，关闭在子命令中//param1 参见SDK_PtzAuxStatus，param2传入具体数值
	EXTPTZ_OPERATION_MENU,			//球机菜单操作，其中包括开，关，确定等等
	EXTPTZ_REVERSECOMM,				//镜头翻转
	EXTPTZ_OPERATION_RESET,			//云台复位

	EXTPTZ_TOTAL,
};
/// 云台辅助功能
enum SDK_PtzAuxStatus
{
	EXTPTZ_AUX_ON,	// 开
	EXTPTZ_AUX_OFF,	// 关
	EXTPTZ_AUX_NR,		
};

#define PAN_AUTO		29	/* 云台以SS的速度左右自动扫描 */
//#define EXTPTZ_FASTGOTO	30	//三维定位



#define NET_MAX_CHANNUM 			32			//最大通道个数
#define NET_DECORDR_CH              32          //最大解码通道个数
#define NET_MAX_USER_NUM			60			//最多用户数
#define NET_MAX_RIGTH_NUM			128			//最多权限数
#define NET_MAX_GROUP_NUM			50			//最多组数
#define NET_MAX_USER_LENGTH			32			//用户名密码最大长度
#define NET_MAX_COMBINE_NUM			2			//最大组合编码通道数
#define NET_MAX_DECORDR_CH          32          //最大解码通道个数	

#define NET_MAX_DDNS_TYPE			5			//支持的DDNS种类
#define NET_MAX_ARSP_TYPE			5
#define NET_MAX_ALARMSERVER_TYPE    5           //支持报警中心种类
#define NET_MAX_SYSFUNC				20			//最多系统功能个数
#define NET_MAX_PTZ_PROTOCOL_LENGTH 32			//云台协议名称最大长度
#define NET_N_WEEKS					7			//星期数
#define	NET_N_TSECT					6			//时间段数
#define NET_MD_REGION_ROW			32			//动态检测区域行数
#define NET_COVERNUM				8			 //覆盖区域数
#define NET_MAX_FILTERIP_NUM		64			//IP地址最大过滤数
#define NET_NAME_PASSWORD_LEN		64			//用户名密码最大长度
#define NET_MAX_PATH_LENGTH	        260			//路径长度
#define NET_N_MIN_TSECT				2
#define NET_MAX_RETURNED_LOGLIST	128			//最多日志条数
#define NET_MAX_MAC_LEN             32          //MAC地址字符最大长度
#define NET_IW_ENCODING_TOKEN_MAX   128
#define NET_MAX_AP_NUMBER           32          //SID最大数量，暂定10
#define NET_MAX_INFO_LEN		    128
#define NET_MAX_USERNAME_LENGTH		128
#define NET_MAX_SERIALNO_LENGTH		128         //最大解码通道个数
#define NET_CHANNEL_NAME_MAX_LEN   64			//通道名称最大长度
#define NET_MAX_LINE_PER_OSD_AREA   12			//编码中一个OSD区域最多可以显示的字符行数

//DDNS参数
#define DDNS_MAX_DDNS_NAMELEN 64  //主机名长度
#define DDNS_MAX_DDNS_PWDLEN 32   //密码长度
#define DDNS_MAX_DDNS_IPSIZE 64   //IP地址长度
#define DDNS_MAX_DDNS_IDSIZE 32   //设备标识长度
#define DDNS_MAX_SERIALINFO_SIZE 16 //序列号以及用户名长度



//摄象机参数
#define CAMERAPARA_MAXNUM  16    //曝光能力中目前最大长度
//短信最大数量
#define MAX_RECIVE_MSG_PHONE_COUNT 3	//最大发生短信数量

//VGA分辨率
#define VGA_MAXNUM     32       //分辨率 种类
#define VGA_NAME_LENGTH 10		//分辨率 长度	

//显示的设备列表(设备端搜索)
#define DEV_LIST_SHOW  256

//IP SIZE
#define IP_SIZE  16
//#define  MAX_HVR_CHNCAP       16
//DDNS服务器设备的信息

#define  NET_NAME_TOKEN_LEN 128

#define  NET_NAME_URL_LEN 128
#define  NET_NAME_ID_LEN 64

typedef struct _DDNS_INFO
{
	char ID[64];    //设备标识
	char Alias[DDNS_MAX_DDNS_NAMELEN];
	char IP[DDNS_MAX_DDNS_IPSIZE];   //外网IP
	char LanIP[DDNS_MAX_DDNS_IPSIZE];//内网IP
	int WebPort; //Web端口,默认为80
	int MediaPort; //媒体端口,默认为34567
	int MobilePort;  //手机监控端口，默认为34599
	int UPNPWebPort;  //UPNP启动下Web端口,UPNP不开启为0
	int UPNPMediaPort; //UPNP启动下媒体端口,UPNP不开启为0
	int UPNPMobilePort; //UPNP启动下手机监控端口,UPNP不开启为0
	int ChannelNum; //通道数
	int Status; //状态
	char Username[DDNS_MAX_DDNS_NAMELEN]; //用户名
	char Password[DDNS_MAX_DDNS_PWDLEN]; //密码
}DDNS_INFO,*pDDNS_INFO;

//DDNS信息查询模式
typedef struct _SearchMode
{
	int  nType;        //查询类型，见SearchModeType
	char szSerIP[DDNS_MAX_DDNS_IPSIZE];//服务器地址
	int nSerPort;           //服务器端口号
	char szSerialInfo[DDNS_MAX_SERIALINFO_SIZE];  //如果是按序列号，则为序列号，如果是用户名，则为用户名
	char szPassWord[DDNS_MAX_DDNS_PWDLEN]; //按用户名登陆时候的密码

}SearchMode;

//DDNS信息查询类型
enum SearchModeType
{
	DDNS_SERIAL = 0,//按序列号
	DDNS_USERNAME,  //按用户名
};
//实时预览扩展接口增加的参数：预览类型
typedef enum _H264_DVR_RealPlayType
{
	NET_RType_Realplay = 0,	//实时预览
	NET_RType_Main_Realplay2,	//实时监视-主码流，等同于NET_RType_Realplay
	NET_RType_Main_Realplay3,
	NET_RType_Sub_Realplay_1,	//实时监视-从码流1
	NET_RType_Sub_Realplay_2,	//实时监视-从码流2
	NET_RType_Sub_Realplay_3,	//实时监视-从码流3

	NET_RType_Multiplay_1,	//多画面预览－1画面
	NET_RType_Multiplay_4,	//多画面预览－4画面
	NET_RType_Multiplay_6,	//多画面预览－6画面
	NET_RType_Multiplay_8,	//多画面预览－8画面
	NET_RType_Multiplay_9,	//多画面预览－9画面
	NET_RType_Multiplay_12,	//多画面预览－12画面
	NET_RType_Multiplay_16,	//多画面预览－16画面
} NET_RealPlayType;

/// 组合编码模式
enum NetCombinType
{
	NET_COMBIN_NONE,
	NET_COMBIN_1,
	NET_COMBIN_2,
	NET_COMBIN_3,
	NET_COMBIN_4,
	NET_COMBIN_5,
	NET_COMBIN_6,
	NET_COMBIN_7,
	NET_COMBIN_8,
	NET_COMBIN_9,
	NET_COMBIN_10,
	NET_COMBIN_11,
	NET_COMBIN_12,
	NET_COMBIN_13,
	NET_COMBIN_14,
	NET_COMBIN_15,
	NET_COMBIN_16,
	NET_COMBIN_1_4,
	NET_COMBIN_5_8,
	NET_COMBIN_9_12,
	NET_COMBIN_13_16,
	NET_COMBIN_1_8,
	NET_COMBIN_9_16,
	NET_COMBIN_1_9,
	NET_COMBIN_8_16,
	NET_COMBIN_1_16
};

//这些结构体和枚举是提供给外部使用，所有可能会和设备那边定义了2次,所以都在前面加了SDK_
enum SDK_CAPTURE_SIZE_t {
	SDK_CAPTURE_SIZE_D1,		///< 720*576(PAL)	720*480(NTSC)
	SDK_CAPTURE_SIZE_HD1,		///< 352*576(PAL)	352*480(NTSC)
	SDK_CAPTURE_SIZE_BCIF,		///< 720*288(PAL)	720*240(NTSC)
	SDK_CAPTURE_SIZE_CIF,		///< 352*288(PAL)	352*240(NTSC)
	SDK_CAPTURE_SIZE_QCIF,		///< 176*144(PAL)	176*120(NTSC)
	SDK_CAPTURE_SIZE_VGA,		///< 640*480(PAL)	640*480(NTSC)
	SDK_CAPTURE_SIZE_QVGA,		///< 320*240(PAL)	320*240(NTSC)
	SDK_CAPTURE_SIZE_SVCD,		///< 480*480(PAL)	480*480(NTSC)
	SDK_CAPTURE_SIZE_QQVGA,		///< 160*128(PAL)	160*128(NTSC)
	SDK_CAPTURE_SIZE_ND1 = 9,     ///< 240*192
	SDK_CAPTURE_SIZE_650TVL,      ///< 926*576
	SDK_CAPTURE_SIZE_720P,        ///< 1280*720
	SDK_CAPTURE_SIZE_1_3M,        ///< 1280*960
	SDK_CAPTURE_SIZE_UXGA ,       ///< 1600*1200
	SDK_CAPTURE_SIZE_1080P,       ///< 1920*1080
	SDK_CAPTURE_SIZE_WUXGA,       ///< 1920*1200
	SDK_CAPTURE_SIZE_2_5M,        ///< 1872*1408
	SDK_CAPTURE_SIZE_3M,          ///< 2048*1536
	SDK_CAPTURE_SIZE_5M,          ///< 3744*1408
	SDK_CAPTURE_SIZE_NR =19,
	SDK_CAPTURE_SIZE_1080N = 19,     ///< 960*1080
	SDK_CAPTURE_SIZE_4M,        ///< 2592*1520
	SDK_CAPTURE_SIZE_6M,		///< 3072×2048
	SDK_CAPTURE_SIZE_8M,		///< 3264×2448
	SDK_CAPTURE_SIZE_12M,		///< 4000*3000
	SDK_CAPTURE_SIZE_4K,		///< 4096 * 2160通用/3840*2160海思
	SDK_CAPTURE_SIZE_EXT_V2_NR =25,
	SDK_CAPTURE_SIZE_720N = 25,  		//  640*720
	SDK_CAPTURE_SIZE_RES1,       		// 0*0 冗余
	SDK_CAPTURE_SIZE_RES2,      		// 0*0
	SDK_CAPTURE_SIZE_RES3,      		// 0*0
	SDK_CAPTURE_SIZE_RES4,      		// 0*0
	SDK_CAPTURE_SIZE_RES5,      		// 0*0
	SDK_CAPTURE_SIZE_RES6,      		// 0*0
	SDK_CAPTURE_SIZE_EXT_V3_NR,
};

/// 捕获码流控制模式类型
enum SDK_capture_brc_t {
	SDK_CAPTURE_BRC_CBR,			///< 固定码流。
	SDK_CAPTURE_BRC_VBR,			///< 可变码流。
	SDK_CAPTURE_BRC_MBR,			///< 混合码流。
	SDK_CAPTURE_BRC_NR				///< 枚举的码流控制模式数目。
};

/// 捕获压缩格式类型
enum SDK_CAPTURE_COMP_t {
	SDK_CAPTURE_COMP_DIVX_MPEG4,	///< DIVX MPEG4。
	SDK_CAPTURE_COMP_MS_MPEG4,		///< MS MPEG4。
	SDK_CAPTURE_COMP_MPEG2,			///< MPEG2。
	SDK_CAPTURE_COMP_MPEG1,			///< MPEG1。
	SDK_CAPTURE_COMP_H263,			///< H.263
	SDK_CAPTURE_COMP_MJPG,			///< MJPG
	SDK_CAPTURE_COMP_FCC_MPEG4,		///< FCC MPEG4
	SDK_CAPTURE_COMP_H264,			///< H.264
	SDK_CAPTURE_COMP_NR				///< 枚举的压缩标准数目。
};

/// 捕获通道类型
enum SDK_CAPTURE_CHANNEL_t {
	SDK_CHL_MAIN_T = 0,		///< 主通道	－	主码流1 
	SDK_CHL_2END_T = 1,		///< 辅通道	－	出辅码流2 
	SDK_CHL_3IRD_T = 2,		///< 辅通道	－	出辅码流3 
	SDK_CHL_4RTH_T = 3,		///< 辅通道	－	出辅码流4 
	SDK_CHL_JPEG_T = 4,		///< 辅通道	－	出JPEG抓图 
	SDK_CHL_FUNCTION_NUM
};
/// 音频编码类型
enum SDK_AudioEncodeTypes
{
	SDK_AUDIO_ENCODE_NONE = 0,
	SDK_AUDIO_ENCODE_G729_8KBIT,
	SDK_AUDIO_ENCODE_G726_16KBIT,
	SDK_AUDIO_ENCODE_G726_24KBIT,
	SDK_AUDIO_ENCODE_G726_32KBIT,
	SDK_AUDIO_ENCODE_G726_40KBIT,
	SDK_AUDIO_ENCODE_PCM_8TO16BIT,
	SDK_AUDIO_ENCODE_PCM_ALAW,
	SDK_AUDIO_ENCODE_PCM_ULAW,
	SDK_AUDIO_ENCODE_ADPCM8K16BIT,
	SDK_AUDIO_ENCODE_ADPCM16K16BIT,
	SDK_AUDIO_ENCODE_G711_ALAW,
	SDK_AUDIO_ENCODE_MPEG2_LAYER1,
	SDK_AUDIO_ENCODE_AMR8K16BIT,
	SDK_AUDIO_ENCODE_G711_ULAW,
	SDK_AUDIO_ENCODE_IMA_ADPCM_8K16BIT,
	SDK_AUDIO_ENCODE_TYPES_NR,
};


typedef enum _SDK_CONFIG_TYPE
{
	E_SDK_CONFIG_NOTHING = 0,
	E_SDK_CONFIG_USER,					//用户信息，包含了权限列表，用户列表和组列表   对应结构体USER_MANAGE_INFO
	E_SDK_CONFIG_ADD_USER,				//增加用户---对应结构体USER_INFO
	E_SDK_CONFIG_MODIFY_USER,			//修改用户---对应结构体CONF_MODIFYUSER
	E_SDK_CONFIG_DELETE_USER,			//对应结构体USER_INFO
	E_SDK_CONFIG_ADD_GROUP,				//增加组---对应结构体USER_GROUP_INFO
	E_SDK_CONFIG_MODIFY_GROUP,			//修改组---对应结构体CONF_MODIFYGROUP
	E_SDK_COFIG_DELETE_GROUP,			//对应结构体---USER_GROUP_INFO
	E_SDK_CONFIG_MODIFY_PSW,			//修改密码---对应结构体_CONF_MODIFY_PSW
	E_SDK_CONFIG_ABILITY_SYSFUNC = 9,	//支持的网络功能---对应结构体SDK_SystemFunction
	E_SDK_CONFIG_ABILTY_ENCODE = 10,	//首先获得编码能力---对应结构体CONFIG_EncodeAbility
	E_SDK_CONFIG_ABILITY_PTZPRO,		//云台协议---对应结构体SDK_PTZPROTOCOLFUNC
	E_SDK_COMFIG_ABILITY_COMMPRO,		//串口协议---对应结构体SDK_COMMFUNC
	E_SDK_CONFIG_ABILITY_MOTION_FUNC,	//动态检测块---对应结构体SDK_MotionDetectFunction
	E_SDK_CONFIG_ABILITY_BLIND_FUNC,	//视频遮挡块---对应结构体SDK_BlindDetectFunction
	E_SDK_CONFIG_ABILITY_DDNS_SERVER,	//DDNS服务支持类型---对应结构体SDK_DDNSServiceFunction
	E_SDK_CONFIG_ABILITY_TALK,			//对讲编码类型---对应结构体SDK_DDNSServiceFunction
	E_SDK_CONFIG_SYSINFO = 17,			//系统信息---对应结构体H264_DVR_DEVICEINFO
	E_SDK_CONFIG_SYSNORMAL,				//普通配置---对应结构体SDK_CONFIG_NORMAL
	E_SDK_CONFIG_SYSENCODE,				//编码配置---对应结构体SDK_EncodeConfigAll
	E_SDK_CONFIG_SYSNET = 20,			//网络设置---对应结构体SDK_CONFIG_NET_COMMON
	E_SDK_CONFIG_PTZ,					//云台页面---对应结构体SDK_STR_PTZCONFIG_ALL
	E_SDK_CONFIG_COMM,					//串口页面---对应结构体SDK_CommConfigAll
	E_SDK_CONFIG_RECORD,				//录像设置界面---对应结构体SDK_RECORDCONFIG
	E_SDK_CONFIG_MOTION,				//动态检测页面---对应结构体SDK_MOTIONCONFIG
	E_SDK_CONFIG_SHELTER,				//视频遮挡---对应结构体SDK_BLINDDETECTCONFIG
	E_SDK_CONFIG_VIDEO_LOSS,  			//视频丢失---对应结构体SDK_VIDEOLOSSCONFIG
	E_SDK_CONFIG_ALARM_IN,				//报警输入---对应结构体SDK_ALARM_INPUTCONFIG
	E_SDK_CONFIG_ALARM_OUT,				//报警输出---对应结构体SDK_AlarmOutConfigAll
	E_SDK_CONFIG_DISK_MANAGER,			//硬盘管理界面---对应结构体SDK_StorageDeviceControl
	E_SDK_CONFIG_OUT_MODE = 30,			//输出模式界面---对应结构体SDK_VideoWidgetConfigAll
	E_SDK_CONFIG_CHANNEL_NAME,			//通道名称---对应结构体SDK_ChannelNameConfigAll
	E_SDK_CONFIG_AUTO,					//自动维护界面配置---对应结构体SDK_AutoMaintainConfig
	E_SDK_CONFIG_DEFAULT,     			//恢复默认界面配置---对应结构体SDK_SetDefaultConfigTypes
	E_SDK_CONFIG_DISK_INFO,				//硬盘信息---对应结构体SDK_StorageDeviceInformationAll
	E_SDK_CONFIG_LOG_INFO,				//查询日志---对应结构体SDK_LogList
	E_SDK_CONFIG_NET_IPFILTER,			//黑名单配置---对应结构体SDK_NetIPFilterConfig
	E_SDK_CONFIG_NET_DHCP,				//DHCP配置---对应结构体SDK_NetDHCPConfigAll
	E_SDK_CONFIG_NET_DDNS,				//DDNS信息---对应结构体SDK_NetDDNSConfigALL
	E_SDK_CONFIG_NET_EMAIL,				//EMAIL---对应结构体SDK_NetEmailConfig
	E_SDK_CONFIG_NET_MULTICAST = 40,	//组播---对应结构体SDK_NetMultiCastConfig
	E_SDK_CONFIG_NET_NTP,				//NTP---对应结构体SDK_NetNTPConfig
	E_SDK_CONFIG_NET_PPPOE,				//PPPOE---对应结构体SDK_NetPPPoEConfig
	E_SDK_CONFIG_NET_DNS,				//DNS---对应结构体SDK_NetDNSConfig
	E_SDK_CONFIG_NET_FTPSERVER,			//FTP---对应结构体SDK_FtpServerConfig
	E_SDK_CONFIG_SYS_TIME,				//系统时间---对应结构体SDK_SYSTEM_TIME(接口H264_DVR_SetSystemDateTime也可以实现)
	E_SDK_CONFIG_CLEAR_LOG,				//清除日志(接口H264_DVR_ControlDVR)											
	E_SDK_REBOOT_DEV,					//重启启动设备(接口H264_DVR_ControlDVR)												
	E_SDK_CONFIG_ABILITY_LANG,			//支持语言---对应结构体SDK_MultiLangFunction
	E_SDK_CONFIG_VIDEO_FORMAT,																	
	E_SDK_CONFIG_COMBINEENCODE = 50,	//组合编码---对应结构体SDK_CombineEncodeConfigAll
	E_SDK_CONFIG_EXPORT,				//配置导出														
	E_SDK_CONFIG_IMPORT,				//配置导入
	E_SDK_LOG_EXPORT,					//日志导出														
	E_SDK_CONFIG_COMBINEENCODEMODE, 	//组合编码模式---对应结构体SDK_CombEncodeModeAll
	E_SDK_WORK_STATE,					//运行状态---SDK_DVR_WORKSTATE(接口H264_DVR_GetDVRWorkState也可以获取)															
	E_SDK_ABILITY_LANGLIST, 			//实际支持的语言集---对应结构体SDK_MultiLangFunction									
	E_SDK_CONFIG_NET_ARSP,				//ARSP---对应结构体SDK_NetARSPConfigAll
	E_SDK_CONFIG_SNAP_STORAGE,			//抓图设置---对应结构体SDK_SnapshotConfig
	E_SDK_CONFIG_NET_3G, 				//3G拨号---对应结构体SDK_Net3GConfig
	E_SDK_CONFIG_NET_MOBILE = 60, 		//手机监控---对应结构体SDK_NetMoblieConfig
	E_SDK_CONFIG_UPGRADEINFO, 			//获取升级信息/参数/文件名---对应结构体SDK_UpgradeInfo
	E_SDK_CONFIG_NET_DECODER,			//解码器地址设置V1(弃用)---对应结构体SDK_NetDecoderConfigAll
	E_SDK_ABILITY_VSTD, 				//实际支持的视频制式---对应结构体SDK_MultiVstd
	E_SDK_CONFIG_ABILITY_VSTD,			//支持视频制式---对应结构体SDK_MultiVstd
	E_SDK_CONFIG_NET_UPNP, 				//UPUN设置---对应结构体SDK_NetUPNPConfig
	E_SDK_CONFIG_NET_WIFI,				//WIFI---对应结构体SDK_NetWifiConfig
	E_SDK_CONFIG_NET_WIFI_AP_LIST,		//搜索到的wifi列表---对应结构体SDK_NetWifiDeviceAll
	E_SDK_CONFIG_SYSENCODE_SIMPLIIFY, 	//简化的编码配置---对应结构SDK_EncodeConfigAll_SIMPLIIFY
	E_SDK_CONFIG_ALARM_CENTER,  		//告警中心---对应结构体SDK_NetAlarmServerConfigAll
	E_SDK_CONFIG_NET_ALARM = 70,		//网络告警---对应结构体SDK_NETALARMCONFIG_ALL																		
	E_SDK_CONFIG_NET_MEGA,     			//互信互通---对应结构体SDK_CONFIG_NET_MEGA
	E_SDK_CONFIG_NET_XINGWANG, 			//星望---对应结构体SDK_CONFIG_NET_XINGWANG
	E_SDK_CONFIG_NET_SHISOU,   			//视搜---对应结构体SDK_CONFIG_NET_SHISOU
	E_SDK_CONFIG_NET_VVEYE,    			//VVEYE---对应结构体SDK_CONFIG_NET_VVEYE
	E_SDK_CONFIG_NET_PHONEMSG,  		//短信---对应结构体SDK_NetShortMsgCfg
	E_SDK_CONFIG_NET_PHONEMEDIAMSG,  	//彩信---对应结构体SDK_NetMultimediaMsgCfg
	E_SDK_VIDEO_PREVIEW,				//
	E_SDK_CONFIG_NET_DECODER_V2,		//解码器地址设置V2(弃用)---对应结构体SDK_NetDecorderConfigAll_V2
	E_SDK_CONFIG_NET_DECODER_V3,		//解码器地址设置V3---对应结构体SDK_NetDecorderConfigAll_V3
	E_SDK_CONFIG_ABILITY_SERIALNO = 80,	//序列号---对应结构体SDK_AbilitySerialNo(经测试不是设备序列号(暂弃用),序列号可以从登陆接口获取到)
	E_SDK_CONFIG_NET_RTSP,    			//RTSP---对应结构体SDK_NetRTSPConfig
	E_SDK_GUISET,              			//本地GUI输出设置---对应结构体SDK_GUISetConfig
	E_SDK_CATCHPIC,               		//抓图												
	E_SDK_VIDEOCOLOR,             		//视频颜色设置---对应结构体SDK_VideoColorConfigAll
	E_SDK_CONFIG_COMM485,				//串口485协议配置---对应结构体SDK_STR_RS485CONFIG_ALL
	E_SDK_COMFIG_ABILITY_COMMPRO485, 	//串口485协议---对应结构体SDK_COMMFUNC
	E_SDK_CONFIG_SYS_TIME_NORTC,		//设置系统时间noRtc---对应结构体SDK_SYSTEM_TIME
	E_SDK_CONFIG_REMOTECHANNEL,   		//远程通道---弃用
	E_SDK_CONFIG_OPENTRANSCOMCHANNEL , 	//打开透明串口---对应结构体TransComChannel
	E_SDK_CONFIG_CLOSETRANSCOMCHANNEL = 90,//关闭透明串口
	E_SDK_CONFIG_SERIALWIRTE,  			//写入透明串口信息
	E_SDK_CONFIG_SERIALREAD,   			//读取透明串口信息
	E_SDK_CONFIG_CHANNELTILE_DOT,		//点阵信息-修改IPC通道名需要点阵信息
	E_SDK_CONFIG_CAMERA,           		//摄象机参数---对应结构体SDK_CameraParam
	E_SDK_CONFIG_ABILITY_CAMERA,    	//曝光能力级---对应结构体SDK_CameraAbility
	E_SDK_CONFIG_BUGINFO,    			//命令调试													
	E_SDK_CONFIG_STORAGENOTEXIST,		//硬盘不存在---对应结构体SDK_VIDEOLOSSCONFIG
	E_SDK_CONFIG_STORAGELOWSPACE, 		//硬盘容量不足---对应结构体SDK_StorageLowSpaceConfig
	E_SDK_CONFIG_STORAGEFAILURE, 		//硬盘出错---对应结构体SDK_VIDEOLOSSCONFIG
	E_SDK_CFG_NETIPCONFLICT = 100,   	//IP冲突---对应结构体SDK_VIDEOLOSSCONFIG
	E_SDK_CFG_NETABORT,  				//网络异常---对应结构体SDK_VIDEOLOSSCONFIG
	E_SDK_CONFIG_CHNSTATUS, 			//通道状态---对应结构体SDK_NetDecorderChnStatusAll
	E_SDK_CONFIG_CHNMODE,  				//通道模式---对应结构体SDK_NetDecorderChnModeConfig
	E_SDK_CONFIG_NET_DAS,    			//主动注册---对应结构体SDK_DASSerInfo
	E_SDK_CONFIG_CAR_INPUT_EXCHANGE,    //外部信息输入与车辆状态的对应关系---对应结构体SDK_CarStatusExchangeAll			
	E_SDK_CONFIG_DELAY_TIME,       		//车载系统延时配置---对应结构体SDK_CarDelayTimeConfig
	E_SDK_CONFIG_NET_ORDER,             //网络优先级---对应结构体SDK_NetOrderConfig
	E_SDK_CONFIG_ABILITY_NETORDER , 	//网络优先级设置能力---对应结构体SDK_NetOrderFunction
	E_SDK_CONFIG_CARPLATE,				//车牌号配置---对应结构体SDK_CarPlates
	E_SDK_CONFIG_LOCALSDK_NET_PLATFORM = 110, //网络平台信息设置---对应结构体SDK_LocalSdkNetPlatformConfig
	E_SDK_CONFIG_GPS_TIMING,            //GPS校时相关配置---对应结构体SDK_GPSTimingConfig
	E_SDK_CONFIG_VIDEO_ANALYZE, 		//视频分析(智能DVR)---对应结构体SDK_ANALYSECONFIG
	E_SDK_CONFIG_GODEYE_ALARM,			//神眼接警中心系统---对应结构体SDK_GodEyeConfig
	E_SDK_CONFIG_NAT_STATUS_INFO,   	//nat状态信息---对应结构体SDK_NatStatusInfo	
	E_SDK_CONFIG_BUGINFOSAVE,     		//命令调试(保存)									 
	E_SDK_CONFIG_MEDIA_WATERMARK,		//水印设置---对应结构体SDK_WaterMarkConfigAll
	E_SDK_CONFIG_ENCODE_STATICPARAM,	//编码器静态参数---对应结构体SDK_EncodeStaticParamAll
	E_SDK_CONFIG_LOSS_SHOW_STR,		    //视频丢失显示字符串
	E_SDK_CONFIG_DIGMANAGER_SHOW,	    //通道管理显示配置---对应结构体SDK_DigManagerShowStatus
	E_SDK_CONFIG_ABILITY_ANALYZEABILITY = 120,//智能分析能力---对应结构体SDK_ANALYZEABILITY
	E_SDK_CONFIG_VIDEOOUT_PRIORITY,   //显示HDMI VGA优先级别配置
	E_SDK_CONFIG_NAT,		  		  //NAT功能，MTU值配置---对应结构体SDK_NatConfig
	E_SDK_CONFIG_CPCINFO,		      //智能CPC计数数据信息---对应结构体SDK_CPCDataAll
	E_SDK_CONFIG_STORAGE_POSITION,    // 录像存储设备类型---对应结构体SDK_RecordStorageType
	E_SDK_CONFIG_ABILITY_CARSTATUSNUM,//车辆状态数---对应结构体SDK_CarStatusNum
	E_SDK_CFG_VPN,					//VPN---对应结构体SDK_VPNConfig
	E_SDK_CFG_VIDEOOUT,				//VGA视频分辨率---对应结构体SDK_VGAresolution
	E_SDK_CFG_ABILITY_VGARESOLUTION,//支持的VGA分辨率列表---对应结构体SDK_VGAResolutionAbility
	E_SDK_CFG_NET_LOCALSEARCH,      //搜索设备，设备端的局域网设备---对应结构体SDK_NetDevList
	E_SDK_CFG_NETPLAT_KAINENG = 130,//客户配置---对应结构体SDK_CONFIG_KAINENG_INFO
	E_SDK_CFG_ENCODE_STATICPARAM_V2,//DVR编码器静态参数---对应结构体SDK_EncodeStaticParamV2
	E_SDK_ABILITY_ENC_STATICPARAM,	//静态编码能力集---对应结构体SDK_EncStaticParamAbility (掩码)
	E_SDK_CFG_C7_PLATFORM,          //C7平台配置---对应结构体SDK_C7PlatformConfig
	E_SDK_CFG_MAIL_TEST,            //邮件测试---对应结构体SDK_NetEmailConfig
	E_SDK_CFG_NET_KEYBOARD,         //网络键盘服务---对应结构体SDK_NetKeyboardConfig
	E_SDK_ABILITY_NET_KEYBOARD,		//网络键盘协议---对应结构体SDK_NetKeyboardAbility  
	E_SDK_CFG_SPVMN_PLATFORM,       //28181协议配置---对应结构体SDK_ASB_NET_VSP_CONFIG	
	E_SDK_CFG_PMS,				    //手机服务---对应结构体SDK_PMSConfig
	E_SDK_CFG_OSD_INFO,             //屏幕提示信息---对应结构体SDK_OSDInfoConfigAll
	E_SDK_CFG_KAICONG = 140,        //客户配置---对应结构体SDK_KaiCongAlarmConfig
	E_SDK_CFG_DIGITAL_REAL,			//真正支持的通道模式---对应结构体SDK_VideoChannelManage
	E_SDK_ABILITY_PTZCONTROL,		//PTZ控制能力集---对应结构体SDK_PTZControlAbility
	E_SDK_CFG_XMHEARTBEAT,			//对应结构体SDK_XMHeartbeatConfig
	E_SDK_CFG_MONITOR_PLATFORM,		//平台配置---对应结构体SDK_MonitorPlatformConfig
	E_SDK_CFG_PARAM_EX,				//摄像头扩展参数---对应结构体SDK_CameraParamEx
	E_SDK_CFG_NETPLAT_ANJU_P2P,		//安巨P2P---对应结构体SDK_NetPlatformCommonCfg  
	E_SDK_GPS_STATUS,				//GPS连接信息---对应结构体SDK_GPSStatusInfo 
	E_SDK_WIFI_STATUS,				//Wifi连接信息---对应结构体SDK_WifiStatusInfo
	E_SDK_3G_STATUS,  				//3G连接信息---对应结构体SDK_WirelessStatusInfo
	E_SDK_DAS_STATUS = 150, 		//主动注册状态---对应结构体SDK_DASStatusInfo 
	E_SDK_ABILITY_DECODE_DELEY,		//解码策略能力---对应结构体SDK_DecodeDeleyTimePrame
	E_SDK_CFG_DECODE_PARAM,     	//解码最大延时---对应结构体SDK_DecodeParam
	E_SDK_CFG_VIDEOCOLOR_CUSTOM,    //SDK_VIDEOCOLOR_PARAM_CUSTOM
	E_SDK_ABILITY_ONVIF_SUB_PROTOCOL,//onvif子协议---对应结构体SDK_AbilityMask   
	E_SDK_CONFIG_EXPORT_V2,      	//导出设备默认配置，即出厂的配置
	E_SDK_CFG_CAR_BOOT_TYPE,      	//车载开关机模式---对应结构体SDK_CarBootTypeConfig
	E_SDK_CFG_IPC_ALARM,			//IPC网络报警---对应结构体SDK_IPCAlarmConfigAll
	E_SDK_CFG_NETPLAT_TUTK_IOTC,	//TUTK IOTC平台配置---对应结构体SDK_NetPlatformCommonCfg
	E_SDK_CFG_BAIDU_CLOUD,     		//百度云---对应结构体SDK_BaiduCloudCfg
	E_SDK_CFG_PMS_MSGNUM = 160,		//手机订阅数---对应结构体SDK_PhoneInfoNum
	E_SDK_CFG_IPC_IP,           	//控制DVR去修改设备IP---对应结构体SDK_IPSetCfg
	E_SDK_ABILITY_DIMEN_CODE,       //二维码点阵---对应结构体SDK_DimenCodeAll
	E_SDK_CFG_MOBILE_WATCH, 	 	//中国电信手机看店平台配置---对应结构体SDK_MobileWatchCfg	
	E_SDK_CFG_BROWSER_LANGUAGE,   	//使用浏览器时使用的语言---对应结构体SDK_BrowserLanguageType
	E_SDK_CFG_TIME_ZONE,			//时区配置---对应结构体SDK_TimeZone
	E_SDK_CFG_NETBJTHY,       		//客户配置---对应结构体SDK_MonitorPlatformConfig
	E_SDK_ABILITY_MAX_PRE_RECORD,   //最大可设置预录时间1~30---对应结构体SDK_AbilityMask
	E_SDK_CFG_DIG_TIME_SYN,			//数字通道时间同步配置(决定前端同步方式)---对应结构体SDK_TimeSynParam
	E_SDK_CONFIG_OSDINFO_DOT,		//3行OSD
	E_CFG_NET_POS = 170,			//POS机配置---对应结构体SDK_NetPosConfigAll
	E_SDK_CFG_CUSTOMIZE_OEMINFO,	//定制OEM客户版本信息---对应结构体SDK_CustomizeOEMInfo
	E_SDK_CFG_DIGITAL_ENCODE, 		//数字通道精简版编码配置---对应结构体SDK_EncodeConfigAll_SIMPLIIFY
	E_SDK_CFG_DIGITAL_ABILITY, 		//数字通道的编码能力---对应结构体SDK_DigitDevInfo
	E_SDK_CFG_ENCODECH_DISPLAY,		//IE端编码配置显示的前端通道号---对应结构体SDK_EncodeChDisplay
	E_SDK_CFG_RESUME_PTZ_STATE,		//开机云台状态---对应结构体SDK_ResumePtzState
	E_SDK_CFG_LAST_SPLIT_STATE,   	//最近一次的画面分割模式，用于重启后恢复之前的分割模式
	E_SDK_CFG_SYSTEM_TIMING_WORK,   //设备定时开关机时间配置。隐藏在自动维护页面里，要用超级密码登陆才能看到界面
	E_SDK_CFG_GBEYESENV,			//宝威环境监测平台配置---对应结构体SDK_NetPlatformCommonCfg
	E_SDK_ABILITY_AHD_ENCODE_L, 	//AHDL能力集---对应结构体SDK_AHDEncodeLMask
	E_SDK_CFG_SPEEDALARM = 180,		//速度报警---对应结构体SDK_SpeedAlarmConfigAll
	E_SDK_CFG_CORRESPONDENT_INFO,	//用户自定义配置---对应结构体SDK_CorrespondentOwnInfo
	E_SDK_SET_OSDINFO,				//OSD信息设置---对应结构体SDK_OSDInfo
	E_SDK_SET_OSDINFO_V2,			//OSD信息叠加，不保存配置---对应结构体SDK_OSDInfoConfigAll
	E_SDK_ABILITY_SUPPORT_EXTSTREAM,//支持辅码流录像---对应结构体SDK_AbilityMask
	E_SDK_CFG_EXT_RECORD,			//辅码流配置---对应结构体SDK_RECORDCONFIG_ALL/SDK_RECORDCONFIG
	E_SDK_CFG_APP_DOWN_LINK,		//用于用户定制下载链接---对应结构体SDK_AppDownloadLink
	E_SDK_CFG_EX_USER_MAP,			//用于保存明文数据---对应结构体SDK_UserMap
	E_SDK_CFG_TRANS_COMM_DATA, 		//串口数据主动上传到UDP或TCP服务器，其中TCP服务器可以支持双向通信---对应结构体SDK_NetTransCommData
	E_SDK_EXPORT_LANGUAGE,			//语言导出
	E_SDK_IMPORT_LANGUAGE = 190,	//语言导入
	E_SDK_DELETE_LANGUAGE,			//语言删除
	E_SDK_CFG_UPGRADE_VERSION_LIST,	//云升级文件列表---对应结构体SDK_CloudUpgradeList
	E_SDK_CFG_GSENSORALARM,			//GSENSOR报警
	E_SDK_CFG_USE_PROGRAM,			//启动客户小程序---对应结构体SDK_NetUseProgram
	E_SDK_CFG_FTP_TEST,             //FTP测试---对应结构体SDK_FtpServerConfig
	E_SDK_CFG_FbExtraStateCtrl,  	//消费类产品的录像灯的状态---对应结构体SDK_FbExtraStateCtrl
	E_SDK_CFG_PHONE,				//手机用
	E_SDK_PicInBuffer,				//手机抓图,弃用 
	E_SDK_GUARD,					//布警 弃用
	E_SDK_UNGUARD = 200,			//撤警，弃用
	E_SDK_CFG_START_UPGRADE,		//开始升级，弃用
	E_SDK_CFG_AUTO_SWITCH,			//插座定时开关---获取配置都用H264_DVR_GetDevConfig_Json,配置使用H264_DVR_SetDevConfig_Json(配置时的格式见智能插座用到的命令.doc)(两个接口简称Json接口,下面用简称) "Name":"PowerSocket.AutoSwitch"
	E_SDK_CFG_POWER_SOCKET_SET,		//控制插座开关---Json接口 "Name":"OPPowerSocketGet"
	E_SDK_CFG_AUTO_ARM,				//插座的定时布撤防---Json接口 "Name":"PowerSocket.AutoArm"
	E_SDK_CFG_WIFI_MODE,			//Wifi模式配置，用于行车记录仪切换AP模式---对应结构体SDK_NetWifiMode
	E_SDK_CFG_CIENT_INFO,			//传递手机客户端信息---Json接口 "Name":"PowerSocket.ClientInfo"
	E_SDK_CFG_ATHORITY,				//SDK_Authority---Json接口 "Name":"PowerSocket.Authority"
	E_SDK_CFG_ARM ,					//SDK_Arm---Json接口 "Name":"PowerSocket.Arm"
	E_SDK_CFG_AUTOLIGHT,			//设置夜灯的定时开关功能 --Json接口 "Name" : "PowerSocket.AutoLight",
	E_SDK_CFG_LIGHT = 210,			//使能和禁止夜灯的动检响应功能---Json接口 "Name" : "PowerSocket.Light",
	E_SDK_CFG_WORKRECORD,			//进行电量统计---Json接口 "Name" : "PowerSocket.WorkRecord",
	E_SDK_CFG_SYSTEMTIME,			//设置时间的命令 ,当局域网连接的时候,连接的时候,发送对时命令 --Json接口 "Name":"System.Time"
	E_SDK_CFG_USB,					//usb接口控制功能---Json接口 "Name":"PowerSocket.Usb"
	E_SDK_CFG_NETPLAT_BJHONGTAIHENG,//北京鸿泰恒平台---对应结构体SDK_CONFIG_NET_BJHONGTAIHENG
	E_SDK_CFG_CLOUD_STORAGE,		//云存储相关配置---对应结构体SDK_CloudRecordConfigAll
	E_SDK_CFG_IDLE_PTZ_STATE,       //云台空闲动作相关配置---对应结构体SDK_PtzIdleStateAll
	E_SDK_CFG_CAMERA_CLEAR_FOG,	    //去雾功能配置---对应结构体SDK_CameraClearFogAll
	E_SDK_CFG_WECHATACCOUNT,		//---对应json "Name":"PowerSocket.WechatAccount"
	E_SDK_CFG_WECHATRENEW,			//---对应json "Name":"PowerSocket.WechatRenew" 
	E_SDK_CFG_POWERSOCKET_WIFI = 220,//---对应json "Name":"PowerSocket.WiFi"
	E_SDK_CFG_CAMERA_MOTOR_CONTROL, //机器人马达控制---对应结构体SDK_CameraMotorCtrl
	E_SDK_CFG_ENCODE_ADD_BEEP,		//设置编码加入每隔30秒beep声---对应结构体SDK_EncodeAddBeep
	E_SDK_CFG_DATALINK,			    //datalink客户在网络服务中的执行程序使能配置---对应结构体 SDK_DataLinkConfig
	E_SDK_CFG_FISH_EYE_PARAM,	    //鱼眼功能参数配置---对应结构体SDK_FishEyeParam
	E_SDK_OPERATION_SET_LOGO,	    //视频上叠加雄迈等厂家的LOGO---对应结构体SDK_SetLogo
	E_SDK_CFG_SPARSH_HEARTBEAT,		//Sparsh客户的心跳功能配置---对应结构体 SDK_SparshHeartbeat
	E_SDK_CFG_LOGIN_FAILED,			//登录失败时发送邮件，使用结构体:基本事件结构---对应结构体 SDK_VIDEOLOSSCONFIG
}SDK_CONFIG_TYPE;



/// 报警事件码
enum SDK_EventCodeTypes
{
	SDK_EVENT_CODE_INIT = 0,
	SDK_EVENT_CODE_LOCAL_ALARM = 1,	//本地报警(外部报警)
	SDK_EVENT_CODE_NET_ALARM,		//网络报警
	SDK_EVENT_CODE_MANUAL_ALARM,	//手动报警
	SDK_EVENT_CODE_VIDEO_MOTION,	//动态检测
	SDK_EVENT_CODE_VIDEO_LOSS,		//视频丢失
	SDK_EVENT_CODE_VIDEO_BLIND,		//视频遮挡
	SDK_EVENT_CODE_VIDEO_TITLE,		
	SDK_EVENT_CODE_VIDEO_SPLIT,
	SDK_EVENT_CODE_VIDEO_TOUR,
	SDK_EVENT_CODE_STORAGE_NOT_EXIST,//存储设备不存在
	SDK_EVENT_CODE_STORAGE_FAILURE,//存储设备访问失败
	SDK_EVENT_CODE_LOW_SPACE,		//存储设备容量过低
	SDK_EVENT_CODE_NET_ABORT,
	SDK_EVENT_CODE_COMM,
	SDK_EVENT_CODE_STORAGE_READ_ERROR,//存储设备读错误
	SDK_EVENT_CODE_STORAGE_WRITE_ERROR,//存储设备写错误
	SDK_EVENT_CODE_NET_IPCONFLICT,	//ip冲突
	SDK_EVENT_CODE_ALARM_EMERGENCY,
	SDK_EVENT_CODE_DEC_CONNECT,	
	SDK_EVENT_CODE_UPGRADE,
	SDK_EVENT_CODE_BACK_UP,
	SDK_EVENT_CODE_SHUT_DOWN,
	SDK_EVENT_CODE_REBOOT,
	SDK_EVENT_CODE_NEWFILE,
	SDK_EVENT_CODE_VideoAnalyze,
	SDK_EVENT_CODE_IPC_ALARM,
	SDK_EVENT_CODE_SPEED_ALARM,
	SDK_EVENT_CODE_GSENSOR_AlARM,
	SDK_EVENT_CODE_LOGIN_FAILED,//登录失败
	SDK_EVENT_CODE_NR,
};
//! 编码配置的类型
enum SDK_ENCODE_TYPE_BY_RECORD
{
	SDK_ENCODE_TYPE_TIM = 0,
	SDK_ENCODE_TYPE_MTD = 1,
	SDK_ENCODE_TYPE_ALM = 2,
	SDK_ENCODE_TYPE_NUM = 3,
	SDK_ENCODE_TYPE_SNAP_TIMER = 0,
	SDK_ENCODE_TYPE_SNAP_TRIGGER = 1,
};
#define SDK_EXTRATYPES 3 //辅码流类型

//网络传输策略
enum SDK_TransferPolicy
{
	SDK_TRANSFER_POLICY_AUTO,		///< 自适应
	SDK_TRANSFER_POLICY_QUALITY,	///< 质量优先
	SDK_TRANSFER_POLICY_FLUENCY,	///< 流量优先
	SDK_TRANSFER_POLICY_TRANSMISSION,//< 网传优先
	SDK_TRANSFER_POLICY_NR,
};



typedef struct {
	int left;
	int top;
	int right;
	int bottom;
}sdkRect;

/// 音频输入格式，语音对讲用
typedef struct SDK_AudioInFormatConfig
{
	int iBitRate;	   ///< 码流大小，kbps为单位，比如192kbps，128kbps
	int iSampleRate;   ///< 采样率，Hz为单位，比如44100Hz
	int iSampleBit;    ///< 采样的位深
	int iEncodeType;   ///< 编码方式，参照AudioEncodeTypes定义
}SDK_AudioInFormatConfig;

//语音对讲格式
typedef enum __TALK_CODING_TYPE
{
	TALK_DEFAULT = 0,
	TALK_PCM = 1,					//PCM
	TALK_G711a,						//G711a
	TALK_AMR,						//AMR
	TALK_G711u,						//G711u
	TALK_G726,						//G726
}TALK_CODING_TYPE;
//语音对讲
typedef struct H264_DVR_TALKDECODE_INFO
{
	TALK_CODING_TYPE		encodeType;		//编码类型
	int						nAudioBit;		//用实际的值表示，如8位 则填值为8
	unsigned int			dwSampleRate;	//采样率，如16k 则填值为16000
	char					reserved[64];
}H264_DVR_TALKDECODE_INFO;


/// 系统时间结构
typedef struct SDK_SYSTEM_TIME{
	int  year;///< 年。   
	int  month;///< 月，January = 1, February = 2, and so on.   
	int  day;///< 日。   
	int  wday;///< 星期，Sunday = 0, Monday = 1, and so on   
	int  hour;///< 时。   
	int  minute;///< 分。   
	int  second;///< 秒。   
	int  isdst;///< 夏令时标识。   
}SDK_SYSTEM_TIME;

//录像设置相关结构体
typedef struct tagSDK_TIMESECTION
{
	//!使能
	int enable;
	//!开始时间:小时
	int startHour;
	//!开始时间:分钟
	int	startMinute;
	//!开始时间:秒钟
	int	startSecond;
	//!结束时间:小时
	int	endHour;
	//!结束时间:分钟
	int	endMinute;
	//!结束时间:秒钟
	int	endSecond;
}SDK_TIMESECTION;

typedef struct{
	int dwYear;		//年
	int dwMonth;	//月
	int dwDay;		//日
	int dwHour;		//时
	int dwMinute;	//分
    int dwSecond;	//秒
}H264_DVR_TIME,*LPH264_DVR_TIME;

//时间结构
typedef struct _NEW_NET_TIME
{
	unsigned int second			:6;					//	秒	1-60		
	unsigned int minute			:6;					//	分	1-60		
	unsigned int hour			:5;					//	时	1-24		
	unsigned int day			:5;					//	日	1-31		
	unsigned int month			:4;					//	月	1-12		
	unsigned int year			:6;					//	年	2000-2063	
}NEW_NET_TIME, *LPNET_TIME;
///< 夏令时结构
typedef struct DSTPoint
{
	int	iYear;
	int	iMonth;
	int	iWeek;		///<周1:first  to2 3 4 -1:last one   0:表示使用按日计算的方法[-1,4]
	int	iWeekDay;	///<weekday from sunday=0	[0, 6]
	int Hour;
	int Minute;
}DSTPoint;

typedef struct SDK_VIDEO_FORMAT
{
	int		iCompression;			//  压缩模式 	
	int		iResolution;			//  分辨率 参照枚举SDK_CAPTURE_SIZE_t
	int		iBitRateControl;		//  码流控制 参照枚举SDK_capture_brc_t
	int		iQuality;				//  码流的画质 档次1-6		
	int		nFPS;					//  帧率值，NTSC/PAL不区分,负数表示多秒一帧		
	int		nBitRate;				//  0-4096k,该列表主要由客户端保存，设备只接收实际的码流值而不是下标。
	int		iGOP;					//  描述两个I帧之间的间隔时间，2-12 
} SDK_VIDEO_FORMAT;
typedef struct  SDK_AUDIO_FORMAT
{
	int		nBitRate;				//  码流kbps	
	int		nFrequency;				//  采样频率	
	int		nMaxVolume;				//  最大音量阈值
}SDK_AUDIO_FORMAT;
// 媒体格式
typedef struct SDK_MEDIA_FORMAT
{
	SDK_VIDEO_FORMAT vfFormat;			//  视频格式定义 			
	SDK_AUDIO_FORMAT afFormat;			//  音频格式定义 
	bool	bVideoEnable;				//  开启视频编码 
	bool	bAudioEnable;				//  开启音频编码 	
} SDK_MEDIA_FORMAT;

typedef union {	//IP addr
	unsigned char	c[4];
	unsigned short	s[2];
	unsigned int 	l;
}CONFIG_IPAddress;








///////////////////用户帐号管理相关结构体/////////////////////////////////
typedef struct _OPR_RIGHT
{
	char name[NET_MAX_USER_LENGTH];
}OPR_RIGHT;

typedef struct _USER_INFO
{
	int			rigthNum;
	char		rights[NET_MAX_RIGTH_NUM][NET_MAX_USER_LENGTH];
	char		Groupname[NET_MAX_USER_LENGTH];
	char		memo[NET_MAX_USER_LENGTH];
	char		name[NET_MAX_USER_LENGTH];
	char		passWord[NET_MAX_USER_LENGTH];
	bool		reserved;		//是否保留
	bool		shareable;		//本用户是否允许复用 1-复用，0-不复用
}USER_INFO;

typedef struct _USER_GROUP_INFO
{
	int			rigthNum;
	char		memo[NET_MAX_USER_LENGTH]; 
	char		name[NET_MAX_USER_LENGTH];
	char		rights[NET_MAX_RIGTH_NUM][NET_MAX_USER_LENGTH];	//权限列表
}USER_GROUP_INFO;

//用户信息配置结构
typedef struct _USER_MANAGE_INFO
{
	int					rigthNum;
	OPR_RIGHT			rightList[NET_MAX_RIGTH_NUM];
	int					groupNum;
	USER_GROUP_INFO		groupList[NET_MAX_GROUP_NUM];
	int					userNum;
	USER_INFO			userList[NET_MAX_USER_NUM];
}USER_MANAGE_INFO;

//修改用户
typedef struct _CONF_MODIFYUSER
{
	char UserName[NET_MAX_USER_LENGTH];
	USER_INFO User;
}CONF_MODIFYUSER;

//修改组
typedef struct _CONF_MODIFYGROUP
{
	char GroupName[NET_MAX_USER_LENGTH];
	USER_GROUP_INFO Group;
}CONF_MODIFYGROUP;


/// 修改用户密码请求
struct _CONF_MODIFY_PSW
{
	char sUserName[NET_MAX_USER_LENGTH];
	char Password[NET_MAX_USER_LENGTH];
    char NewPassword[NET_MAX_USER_LENGTH];
};

//普通配置页结构体
typedef struct _SDK_CONFIG_NORMAL
{
	SDK_SYSTEM_TIME sysTime;		//系统时间

	int iLocalNo;			/*!< 本机编号:[0, 998] */
	int iOverWrite;			/*!< 硬盘满时处理 "OverWrite（iOverWrite=1）", "StopRecord（iOverWrite=0）" */		
	char cIranCalendarEnable;			///<伊朗日历 
	char sMachineName[64];	///< 机器名
	int iVideoStartOutPut;	/*!< 输出模式 */
	int iAutoLogout;			///< 本地菜单自动注销(分钟)	[0, 120]

	int iVideoFormat;		/*!< 视频制式:“PAL”, “NTSC”, “SECAM” */
	int iLanguage;			/*!< 语言选择:“English”, “SimpChinese”, “TradChinese”, “Italian”, “Spanish”, “Japanese”, “Russian”, “French”, “German” */	
	int iDateFormat;		/*!< 日期格式:“YYMMDD”, “MMDDYY”, “DDMMYY” */
	int iDateSeparator;		/*!< 日期分割符:“.”, “-”, “/” */
	int iTimeFormat;		/*!< 时间格式:“12”, “24” */
	int iDSTRule;			///< 夏令时规则 
	int iWorkDay;			///< 工作日
	DSTPoint dDSTStart;
	DSTPoint dDSTEnd;
}SDK_CONFIG_NORMAL;


//以下编码配置相关
// 编码设置
typedef struct SDK_CONFIG_ENCODE
{
	SDK_MEDIA_FORMAT dstMainFmt[SDK_ENCODE_TYPE_NUM];		//  主码流格式 	
	SDK_MEDIA_FORMAT dstExtraFmt[SDK_EXTRATYPES];	//  辅码流格式 
	SDK_MEDIA_FORMAT dstSnapFmt[SDK_ENCODE_TYPE_NUM];		//  抓图格式 
}SDK_CONFIG_ENCODE;
typedef struct  SDK_EncodeConfigAll
{
	SDK_CONFIG_ENCODE vEncodeConfigAll[NET_MAX_CHANNUM];
}SDK_EncodeConfigAll;


// 简化版本编码配置
/// 媒体格式
typedef struct SDK_MEDIA_FORMAT_SIMPLIIFY
{
	SDK_VIDEO_FORMAT vfFormat;			//  视频格式定义 			
	bool	bVideoEnable;			//  开启视频编码 
	bool	bAudioEnable;			//  开启音频编码 	
}SDK_MEDIA_FORMAT_SIMPLIIFY;

/// 编码设置
typedef struct SDK_CONFIG_ENCODE_SIMPLIIFY
{
	SDK_MEDIA_FORMAT dstMainFmt;		//  主码流格式 	
	SDK_MEDIA_FORMAT dstExtraFmt;	//  辅码流格式 
}SDK_CONFIG_ENCODE_SIMPLIIFY;

/// 全通道编码配置
typedef struct SDK_EncodeConfigAll_SIMPLIIFY
{
	SDK_CONFIG_ENCODE_SIMPLIIFY vEncodeConfigAll[NET_MAX_CHANNUM];
}SDK_EncodeConfigAll_SIMPLIIFY;


typedef struct  SDK_CombineEncodeConfigAll
{
	SDK_CONFIG_ENCODE vEncodeConfigAll[NET_MAX_COMBINE_NUM];
}SDK_CombineEncodeConfigAll;

/// 组合编码模式
typedef struct SDK_CombEncodeParam
{
	int iEncodeMode;	 //见CombineEncodeMode
}SDK_CombEncodeParam;

typedef struct SDK_CombEncodeModeAll
{
	SDK_CombEncodeParam vEncodeParam[NET_MAX_COMBINE_NUM];
}SDK_CombEncodeModeAll;

//!视频物件结构
typedef struct  SDK_VIDEO_WIDGET
{
	unsigned int rgbaFrontground;		///< 物件的前景MakeRGB，和透明度	
	unsigned int rgbaBackground;		///< 物件的后景MakeRGB，和透明度	
	sdkRect	rcRelativePos;			///< 物件边距与整长的比例*8191
	bool	bPreviewBlend;			///< 预览叠加	
	bool	bEncodeBlend;			///< 编码叠加
}SDK_VIDEO_WIDGET;

//!视频物件设置
typedef struct SDK_CONFIG_VIDEOWIDGET
{
	SDK_VIDEO_WIDGET	dstCovers[NET_COVERNUM];
	SDK_VIDEO_WIDGET	ChannelTitle;
	SDK_VIDEO_WIDGET	TimeTitle;
	struct 
	{
		char strName[NET_NAME_PASSWORD_LEN];
#ifdef WIN32
 		__int64 iSerialNo;	
#else
		long long iSerialNo;	
#endif
	}ChannelName;					/// 通道名称
	int				iCoverNum;		/*!< 当前该通道有几个叠加的区域 */
}SDK_CONFIG_VIDEOWIDGET;

/// 视频物件(输出模式对话框)
typedef struct SDK_VideoWidgetConfigAll
{
	SDK_CONFIG_VIDEOWIDGET vVideoWidegetConfigAll[NET_MAX_CHANNUM];
}SDK_VideoWidgetConfigAll;

//视频颜色
typedef struct SDK_VIDEOCOLOR_PARAM
{
	int	nBrightness;		///< 亮度	0-100
	int	nContrast;			///< 对比度	0-100
	int	nSaturation;		///< 饱和度	0-100
	int	nHue;				///< 色度	0-100
	int	mGain;				///< 增益	0-100 第７位置1表示自动增益		
	int	mWhitebalance;		///< 自动白电平控制，bit7置位表示开启自动控制.0x0,0x1,0x2分别代表低,中,高等级
	int nAcutance;          ///< 锐度   0-15
}SDK_VIDEOCOLOR_PARAM;
///< 视频颜色设置
typedef struct SDK_VIDEOCOLOR
{
	SDK_TIMESECTION			tsTimeSection;		/// 时间段
	SDK_VIDEOCOLOR_PARAM	dstColor;			/// 颜色定义
	int					iEnable;
}SDK_VIDEOCOLOR;

typedef struct SDK_CONFIG_VIDEOCOLOR
{
	SDK_VIDEOCOLOR dstVideoColor[NET_N_MIN_TSECT];
}SDK_CONFIG_VIDEOCOLOR;

typedef struct SDK_VideoColorConfigAll
{
	SDK_CONFIG_VIDEOCOLOR vVideoColorAll[NET_MAX_CHANNUM];
}SDK_VideoColorConfigAll;


/// 所有通道名称标题
typedef struct SDK_ChannelNameConfigAll
{
	char channelTitle[NET_MAX_CHANNUM][NET_NAME_PASSWORD_LEN];
}SDK_ChannelNameConfigAll;

//输出模式
typedef struct SDK_GUISetConfig
{
	int iWindowAlpha;			///< 窗口透明度	[128, 255]
	bool bTimeTitleEn;			///< 时间标题显示使能
	bool bChannelTitleEn;		///< 通道标题显示使能	
	bool bAlarmStatus;			///<  报警状态
	bool bRecordStatus;			///<  录像状态显示使能
	bool bChanStateRecEn;		///< 录像标志显示使能
	bool bChanStateVlsEn;		///< 视频丢失标志显示使能
	bool bChanStateLckEn;		///< 通道锁定标志显示使能	
	bool bChanStateMtdEn;		///< 动态检测标志显示使能
	bool bBitRateEn;			///< 码流显示使能
	bool bRemoteEnable;			///< 遥控器使能
	bool bDeflick;				///< 抗抖动
}SDK_GUISetConfig;


////!普通网络设置
typedef struct SDK_CONFIG_NET_COMMON
{
	//!主机名
	char HostName[NET_NAME_PASSWORD_LEN];
	//!主机IP
	CONFIG_IPAddress HostIP;
	//!子网掩码
	CONFIG_IPAddress Submask;
	//!网关IP
	CONFIG_IPAddress Gateway;
	//!HTTP服务端口
	int HttpPort;
	//!TCP侦听端口
	int TCPPort;	
	//!SSL侦听端口
	int SSLPort;
	//!UDP侦听端口
	int UDPPort;
	//!最大连接数
	int MaxConn;
	//!监视协议 {"TCP","UDP","MCAST",…}
	int MonMode;
	//!限定码流值
	int MaxBps;
	//!传输策略
	//char TransferPlan[NET_NAME_PASSWORD_LEN];
	int TransferPlan;

	//!是否启用高速录像下载测率
	bool bUseHSDownLoad;

	//!MAC地址
	char sMac[NET_MAX_MAC_LEN];
}SDK_CONFIG_NET_COMMON;

////!普通网络设置 --
typedef struct SDK_CONFIG_NET_COMMON_V2
{
	//!主机名
	char HostName[NET_NAME_PASSWORD_LEN];
	//!主机IP
	CONFIG_IPAddress HostIP;
	//!子网掩码
	CONFIG_IPAddress Submask;
	//!网关IP
	CONFIG_IPAddress Gateway;
	//!HTTP服务端口
	int HttpPort;
	//!TCP侦听端口
	int TCPPort;	
	//!SSL侦听端口
	int SSLPort;
	//!UDP侦听端口
	int UDPPort;
	//!最大连接数
	int MaxConn;
	//!监视协议 {"TCP","UDP","MCAST",…}
	int MonMode;
	//!限定码流值
	int MaxBps;
	//!传输策略
	//char TransferPlan[NET_NAME_PASSWORD_LEN];
	int TransferPlan;

	//!是否启用高速录像下载测率
	bool bUseHSDownLoad;

	//!MAC地址
	char sMac[NET_MAX_MAC_LEN];

	char sSn[NET_MAX_MAC_LEN]; 	///序列号
#ifndef WIN32
	int DeviceType;   //设备类型
#endif
	char Resume[64];	///保留
}SDK_CONFIG_NET_COMMON_V2;

////!跨网段设置IP需 --
typedef struct SDK_CONFIG_NET_COMMON_V3
{
    //!主机名
    char HostName[NET_NAME_PASSWORD_LEN];
    //!主机IP
    CONFIG_IPAddress HostIP;
    //!子网掩码
    CONFIG_IPAddress Submask;
    //!网关IP
    CONFIG_IPAddress Gateway;
    //!HTTP服务端口
    int HttpPort;
    //!TCP侦听端口
    int TCPPort;
    //!SSL侦听端口
    int SSLPort;
    //!UDP侦听端口
    int UDPPort;
    //!最大连接数
    int MaxConn;
    //!监视协议 {"TCP","UDP","MCAST",?}
    int MonMode;
    //!限定码流值
    int MaxBps;
    //!传输策略
    //char TransferPlan[NET_NAME_PASSWORD_LEN];
    int TransferPlan;
    
    //!是否启用高速录像下载测率
    bool bUseHSDownLoad;
    
    //!MAC地址
    char sMac[NET_MAX_MAC_LEN];
    char UserName[NET_NAME_PASSWORD_LEN];
    char Password[NET_NAME_PASSWORD_LEN];
    char LocalMac[NET_MAX_MAC_LEN];
    int nPasswordType;
}SDK_CONFIG_NET_COMMON_V3;

//DHCP
#define SDK_MAX_ETH_NUM 4
typedef struct SDK_NetDHCPConfig
{
    bool bEnable;
    char ifName[32];
}SDK_NetDHCPConfig;
/// 所有网卡的DHCP配置
typedef struct SDK_NetDHCPConfigAll
{
    SDK_NetDHCPConfig vNetDHCPConfig[SDK_MAX_ETH_NUM];
}SDK_NetDHCPConfigAll;

///< DNS设置
typedef struct SDK_NetDNSConfig
{
    CONFIG_IPAddress		PrimaryDNS;
    CONFIG_IPAddress		SecondaryDNS;
}SDK_NetDNSConfig;
///< 服务器结构定义
typedef struct SDK_RemoteServerConfig
{
    char ServerName[NET_NAME_PASSWORD_LEN];	///< 服务名
    CONFIG_IPAddress ip;						///< IP地址
    int Port;							///< 端口号
    char UserName[NET_NAME_PASSWORD_LEN];		///< 用户名
    char Password[NET_NAME_PASSWORD_LEN];		///< 密码
    bool Anonymity;							///< 是否匿名登录
}SDK_RemoteServerConfig;
///< IP权限设置
typedef struct SDK_NetIPFilterConfig
{
    bool Enable;		///< 是否开启
    CONFIG_IPAddress BannedList[NET_MAX_FILTERIP_NUM];		///< 黑名单列表
    CONFIG_IPAddress TrustList[NET_MAX_FILTERIP_NUM];		///< 白名单列表
}SDK_NetIPFilterConfig;

///< 组播设置
typedef struct SDK_NetMultiCastConfig
{
    bool Enable;		///< 是否开启
    SDK_RemoteServerConfig Server;		///< 组播服务器
}SDK_NetMultiCastConfig;

///< pppoe设置
typedef struct SDK_NetPPPoEConfig
{
    bool Enable;	///< 是否开启
    SDK_RemoteServerConfig Server;		///< PPPOE服务器
    CONFIG_IPAddress addr;		///< 拨号后获得的IP地址
}SDK_NetPPPoEConfig;

///< DDNS设置
typedef struct SDK_NetDDNSConfig
{
    bool Enable;	///< 是否开启
    bool Online;		///< 是否在线
    char DDNSKey[NET_NAME_PASSWORD_LEN];	///< DDNS类型名称, 目前有: JUFENG
    char HostName[NET_NAME_PASSWORD_LEN];	///< 主机名
    SDK_RemoteServerConfig Server;			///< DDNS服务器
    
}SDK_NetDDNSConfig;

///< DDNS设置
typedef struct SDK_NetDDNSConfigALL
{
    SDK_NetDDNSConfig ddnsConfig[NET_MAX_DDNS_TYPE];
}SDK_NetDDNSConfigALL;

///< FTP设置
typedef struct SDK_FtpServerConfig{
    bool bEnable;        ///< 服务器使能
    SDK_RemoteServerConfig Server;	///< FTP服务器
    char cRemoteDir[NET_MAX_PATH_LENGTH];	///< 远程目录
    int iMaxFileLen;	///< 文件最大长度
}SDK_FtpServerConfig;

///< NTP设置
typedef struct SDK_NetNTPConfig
{
    ///< 是否开启
    bool Enable;
    ///< PPPOE服务器
    SDK_RemoteServerConfig Server;
    ///< 更新周期
    int UpdatePeriod;
    ///< 时区
    int TimeZone;
}SDK_NetNTPConfig;
#define  NET_MAX_EMAIL_TITLE_LEN 64
#define  NET_MAX_EMAIL_RECIEVERS  5
#define  NET_EMAIL_ADDR_LEN  32

///< EMAIL设置
typedef struct SDK_NetEmailConfig
{
    ///< 是否开启
    bool Enable;
    ///< smtp 服务器地址使用字符串形式填充
    ///< 可以填ip,也可以填域名
    SDK_RemoteServerConfig Server;
    bool bUseSSL;
    ///< 发送地址
    char SendAddr[NET_EMAIL_ADDR_LEN];
    ///< 接收人地址
    char Recievers[NET_MAX_EMAIL_RECIEVERS][NET_EMAIL_ADDR_LEN];
    ///< 邮件主题
    char Title[NET_MAX_EMAIL_TITLE_LEN];
    ///< email有效时间
    SDK_TIMESECTION Schedule[NET_N_MIN_TSECT];
}SDK_NetEmailConfig;

///< ARSP(主动注册服务器)设置
typedef struct SDK_NetARSPConfig
{
    bool bEnable;	///< 是否开启
    char sARSPKey[NET_NAME_PASSWORD_LEN];	///< DNS类型名称
    int iInterval;	///< 保活间隔时间
    char sURL[NET_NAME_PASSWORD_LEN];    ///< 本机域名
    SDK_RemoteServerConfig Server;		///< DDNS服务器
    int nHttpPort;                  ///< 服务器HTTP端口
}SDK_NetARSPConfig;

typedef struct SDK_NetARSPConfigAll
{
    SDK_NetARSPConfig vNetARSPConfigAll[NET_MAX_ARSP_TYPE];
}SDK_NetARSPConfigAll;

///< 解码器地址设置
typedef struct SDK_NetDecoderConfig
{
    bool Enable;						///< 是否开启
    char UserName[NET_NAME_PASSWORD_LEN];	///< DDNS类型名称, 目前有: JUFENG
    char PassWord[NET_NAME_PASSWORD_LEN];	///< 主机名
    char Address[NET_NAME_PASSWORD_LEN];
    int Protocol;
    int Port;							///< 解码器连接端口
    int Channel;						///< 解码器连接通道号
    int Interval;                       ///< 轮巡的间隔时间(s)
}SDK_NetDecoderConfig;

/// 所有通道的解码器地址设置
typedef struct SDK_NetDecoderConfigAll
{
    SDK_NetDecoderConfig vNetDecoderConfig[NET_MAX_DECORDR_CH];
}SDK_NetDecoderConfigAll;


/// 解码器地址设置V2版本
typedef struct SDK_NetDecoderConfig_V2
{
    int nTotalNum;            //有效的数组个数，最大为NET_MAX_CHANNUM
    SDK_NetDecoderConfig vNetDecoderConfig[NET_MAX_CHANNUM];
}SDK_NetDecoderConfig_V2;

/// 所有通道的解码器地址设置V2版本
typedef struct SDK_NetDecoderConfigAll_V2
{
    SDK_NetDecoderConfig_V2 vNetDecoderArray[NET_MAX_DECORDR_CH];
}SDK_NetDecoderConfigAll_V2;


///< 解码器地址设置
typedef struct SDK_NetDecorderConfigV3
{
    bool Enable;						///< 是否开启
    char UserName[NET_NAME_PASSWORD_LEN];	///< DDNS类型名称, 目前有: JUFENG
    char PassWord[NET_NAME_PASSWORD_LEN];	///< 主机名
    char Address[NET_NAME_PASSWORD_LEN];
    int Protocol;
    int Port;							///< 解码器连接端口
    int Channel;						///< 解码器连接通道号
    int Interval;                       ///< 轮巡的间隔时间(s),0:表示永久
    char ConfName[NET_NAME_PASSWORD_LEN];	///<配置名称
    int DevType;						///<设备类型
    int StreamType;						///<连接的码流类型CaptureChannelTypes
}SDK_NetDecorderConfigV3;

/*解码器连接类型*/
enum SDK_DecorderConnType
{
    SDK_CONN_SINGLE = 0, 	/*单连接*/
    SDK_CONN_MULTI = 1,		/*多连接轮巡*/
    SDK_CONN_TYPE_NR,
};

/*数字通道的配置*/
typedef struct SDK_NetDigitChnConfig
{
    bool Enable;		/*数字通道是否开启*/
    int ConnType;		/*连接类型，取DecoderConnectType的值*/
    int TourIntv;		/*多连接时轮巡间隔*/
    unsigned int SingleConnId;	/*单连接时的连接配置ID, 从1开始，0表示无效*/
    bool EnCheckTime;	/*开启对时*/
    SDK_NetDecorderConfigV3 NetDecorderConf[32]; /*网络设备通道配置表*/
    int nNetDeorde; // 有多少个
}SDK_NetDigitChnConfig;

/*所有数字通道的配置*/
typedef struct SDK_NetDecorderConfigAll_V3
{
    SDK_NetDigitChnConfig DigitChnConf[NET_MAX_DECORDR_CH];
}SDK_NetDecorderConfigAll_V3;

//通道模式
#define MAX_HVR_CHNCAP_CHN		32
typedef struct SDK_HVR_CHNCAP
{
    int nD1Chn;		// 支持的D1路数
    int n960HChn;	// 支持的960H路数
    int n720PChn;	// 支持的720P路数
    int n1080PChn;	// 支持的1080P路数
    int nCIFChn;	//支持的CIF通道数
    int nHD1Chn;	//支持的HD1通道数
    unsigned char nPlayChn; //支持回放路数
    unsigned char nDigiTalChn; //支持最大数字通道路数
    unsigned char n960PChn; //支持的960P通道数
    unsigned char n3MChn; //支持的3M通道数
    unsigned char n5MChn; //支持的5M通道数
    unsigned char nWUXGAChn; //支持的WUXGA通道数
    unsigned char n1080NChn;//支持1080N通道数
    unsigned char n4MChn;//支持4M通道数
    //unsigned char nResChar[2]; //冗余
}SDK_HVR_CHNCAP, *SDK_PHVR_CHNCAP;

typedef struct SDK_HVR_CHNCAPV2
{
    unsigned char nD1Chn;		// 支持的D1路数
    unsigned char n960HChn;	// 支持的960H路数
    unsigned char n720PChn;	// 支持的720P路数
    unsigned char n1080PChn;	// 支持的1080P路数
    unsigned char nCIFChn;	//支持的CIF通道数
    unsigned char nHD1Chn;	//支持的HD1通道数
    unsigned char nPlayChn; //支持回放路数
    unsigned char nDigiTalChn; //支持最大数字通道路数
    unsigned char n960PChn; //支持的960P通道数
    unsigned char n3MChn; //支持的3M通道数
    unsigned char n5MChn; //支持的5M通道数
    unsigned char nWUXGAChn; //支持的WUXGA通道数
    unsigned char n1080NChn;//支持1080N通道数
    unsigned char n4MChn;//支持4M通道数
    unsigned char n720NChn;//支持720N通道数
    unsigned char nRes[17];
}SDK_HVR_CHNCAPV2, *SDK_PHVR_CHNCAPV2;

typedef struct SDK_CAPTURE_HVRCAP  //改用CAPTURE_HVRCAPV2，为了兼容老的保留
{
    SDK_HVR_CHNCAP DigitalCap;		// 支持的数字通道信息
    SDK_HVR_CHNCAP AnalogCap;		// 支持的模拟通道信息
}SDK_CAPTURE_HVRCAP, *SDK_PCAPTURE_HVRCAP;

typedef struct SDK_CAPTURE_HVRCAPV2
{
    SDK_HVR_CHNCAPV2 DigitalCap;		// 支持的数字通道信息
    SDK_HVR_CHNCAPV2 AnalogCap;		// 支持的模拟通道信息
}SDK_CAPTURE_HVRCAPV2, *SDK_PCAPTURE_HVRCAPV2;

typedef struct SDK_CAPTURE_TOTAL_HVRCAP //改用CAPTURE_TOTAL_HVRCAPV2，为了兼容老的保留
{
    int		nHVRCap;			// 实际支持的模式
    SDK_CAPTURE_HVRCAP	HVRCap[MAX_HVR_CHNCAP_CHN];		// 所有模式的汇总
}SDK_CAPTURE_TOTAL_HVRCAP, *SDK_PCAPTURE_TOTAL_HVRCAP;

typedef struct SDK_CAPTURE_TOTAL_HVRCAPV2
{
    int		nHVRCap;			// 实际支持的模式
    SDK_CAPTURE_HVRCAPV2	HVRCap[MAX_HVR_CHNCAP_CHN];		// 所有模式的汇总
}SDK_CAPTURE_TOTAL_HVRCAPV2, *SDK_PCAPTURE_TOTAL_HVRCAPV2;

//通道模式配置
typedef struct SDK_NetDecorderChnModeConfig
{
    SDK_CAPTURE_TOTAL_HVRCAPV2 	HVRTotalCap;
    int HVRCurCapMode;
}SDK_NetDecorderChnModeConfig;


/*数字通道状态*/
typedef struct SDK_NetDecorderChnStatus
{
    char ChnName[NET_NAME_PASSWORD_LEN];
    char pMaxResName[50];
    char	pCurResName[50];
    char pStatus[50];
}SDK_NetDecorderChnStatus;

/*所有数字通道状态*/
typedef struct SDK_NetDecorderChnStatusAll
{
    SDK_NetDecorderChnStatus ChnStatusAll[MAX_HVR_CHNCAP_CHN];
}SDK_NetDecorderChnStatusAll;

//Pos设备类型
enum SDK_PosDevType
{
    SDK_POS_TYPE_MANY_LINES, //计算完总金额后才把商品信息一起发送过来
    SDK_POS_TYPE_ONE_LINE,   //每统计一件商品就把该商品的信息发送过来
    SDK_POS_NR
};

//文字编码格式
enum SDK_WordEncode
{
    SDK_WORD_ENCODE_GB2312,  //汉字编码GB2312
    SDK_WORD_ENCODE_UNICODE, //万国码 Unicode
    SDK_WORD_ENCODE_UTF8,    //UTF-8
};

#define SDK_MAX_POS_FUNC_KEYWORDS 4
// pos相关配置
typedef struct SDK_NetPosConfig
{
    bool Enable;		/*pos机通道使能*/
    int Devtype;		//pos机类型
    int Protocol;		//通信协议
    int Port;		//协议端口号
    bool SnapEnable;       //抓拍使能
    int  StartLine;        //对收到的信息从多少行开始显示
    int  WordEncodeType;   //文字编码格式，如枚举值 WordEncodeType 所示
    bool KeyWordEnable;    //关键字写日志功能使能
    char SearchWrod[SDK_MAX_POS_FUNC_KEYWORDS][16]; //需要添加到日志里的单词
    int  HideTime;         //隐藏通道显示的pos信息的时间,单位是秒，0表示不自动隐藏
    int res;		//保留
}SDK_NetPosConfig;
//所有pos机相关配置
typedef struct SDK_NetPosConfigAll
{
    SDK_NetPosConfig PosConfig[MAX_HVR_CHNCAP_CHN];
}SDK_NetPosConfigAll;


///< 3G拨号设置
typedef struct SDK_Net3GConfig
{
    bool bEnable;			  ///< 无线模块使能标志
    int iNetType;			  ///< 无线网络类型
    char sAPN[NET_NAME_PASSWORD_LEN];		///< 接入点名称
    char sDialNum[NET_NAME_PASSWORD_LEN];   ///< 拨号号码
    char sUserName[NET_NAME_PASSWORD_LEN];  ///< 拨号用户名
    char sPassword[NET_NAME_PASSWORD_LEN];  ///< 拨号密码
    CONFIG_IPAddress addr;			  ///< 拨号后获得的IP地址
}SDK_Net3GConfig;

///< 手机监控设置包括
typedef struct SDK_NetMoblieConfig
{
    bool bEnable;	///< 是否开启
    SDK_RemoteServerConfig Server;		///< 服务器
}SDK_NetMoblieConfig;

//RTSP
typedef struct SDK_NetRTSPConfig
{
    bool bServer;
    bool bClient;
    SDK_RemoteServerConfig Server;		///< 服务器模式
    SDK_RemoteServerConfig Client;		///< 客户端模式
}SDK_NetRTSPConfig;

///< UPNP设置
typedef struct SDK_NetUPNPConfig
{
    bool bEnable;			  ///< 使能标志
    bool bState;              ///< 状态, 1: OK 0: NOK
    int iHTTPPort;			  ///< HTTP连接映射后的端口
    int iMediaPort;			  ///< 媒体连接映射后的端口
    int iMobliePort;		  ///< 手机监控映射后的端口
}SDK_NetUPNPConfig;

///< WIFI设置
typedef struct SDK_NetWifiConfig
{
    bool bEnable;
    char sSSID[36];            //SSID Number
    int nChannel;                   //channel
    char sNetType[32];         //Infra, Adhoc
    char sEncrypType[32];      //NONE, WEP, TKIP, AES
    char sAuth[32];            //OPEN, SHARED, WEPAUTO, WPAPSK, WPA2PSK, WPANONE, WPA, WPA2
    int  nKeyType;                  //0:Hex 1:ASCII
    char sKeys[NET_IW_ENCODING_TOKEN_MAX];
    CONFIG_IPAddress HostIP;		///< host ip
    CONFIG_IPAddress Submask;		///< netmask
    CONFIG_IPAddress Gateway;		///< gateway
}SDK_NetWifiConfig;

enum SDK_RSSI_SINGNAL
{
    SDK_RSSI_NO_SIGNAL,   //<= -90db
    SDK_RSSI_VERY_LOW,     //<= -81db
    SDK_RSSI_LOW,          //<= -71db
    SDK_RSSI_GOOD,         //<= -67db
    SDK_RSSI_VERY_GOOD,    //<= -57db
    SDK_RSSI_EXCELLENT     //>-57db
};

typedef struct SDK_NetWifiDevice
{
    char sSSID[36];            //SSID Number
    int nRSSI;                 //SEE SDK_RSSI_SINGNAL
    int nChannel;
    char sNetType[32];         //Infra, Adhoc
    char sEncrypType[32];      //NONE, WEP, TKIP, AES
    char sAuth[32];            //OPEN, SHARED, WEPAUTO, WPAPSK, WPA2PSK, WPANONE, WPA, WPA2
}SDK_NetWifiDevice;

typedef struct SDK_NetWifiDeviceAll
{
    int nDevNumber;
    SDK_NetWifiDevice vNetWifiDeviceAll[NET_MAX_AP_NUMBER];
}SDK_NetWifiDeviceAll;

///< 报警中心设置
typedef struct SDK_NetAlarmCenterConfig
{
    bool bEnable;		///< 是否开启
    char sAlarmServerKey[NET_NAME_PASSWORD_LEN];	///< 报警中心协议类型名称,
    ///< 报警中心服务器
    SDK_RemoteServerConfig Server;
    bool bAlarm;
    bool bLog;
}SDK_NetAlarmCenterConfig;

typedef struct SDK_NetAlarmServerConfigAll
{
    SDK_NetAlarmCenterConfig vAlarmServerConfigAll[NET_MAX_ALARMSERVER_TYPE];
}SDK_NetAlarmServerConfigAll;


//互信互通
typedef struct SDK_CONFIG_NET_MEGA
{
    bool bEnable;
    bool bNetManEnable;
    CONFIG_IPAddress ServerIP;
    int iServerPort;
    char sDeviceId[32];
    char sUserName[24];
    char sPasswd[32];
    int iMaxCon;
    int iVideoPort;
    int iAudioPort;
    int iMsgPort;
    int iUpdatePort;
}SDK_CONFIG_NET_MEGA;

// 新望平台
typedef struct SDK_CONFIG_NET_XINGWANG
{
    bool bEnable;
    bool bSyncTime;
    bool bSubStream;
    CONFIG_IPAddress ServerIP;
    int iServerPort;
    int iDownLoadPort;
    char sPasswd[32];
    char szSID[32];
}SDK_CONFIG_NET_XINGWANG;

// 视搜平台
typedef struct SDK_CONFIG_NET_SHISOU
{
    bool bEnable;
    SDK_RemoteServerConfig Server;
    char szSID[NET_MAX_USERNAME_LENGTH];
}SDK_CONFIG_NET_SHISOU;

// VVEYE平台
typedef struct SDK_CONFIG_NET_VVEYE
{
    bool bEnable;
    bool bCorpEnable;            //只有在使用企业服务器时才需要设置Server
    SDK_RemoteServerConfig Server;
    char szDeviceName[NET_MAX_USERNAME_LENGTH];
}SDK_CONFIG_NET_VVEYE;

// 报警中心消息类型
enum SDK_AlarmCenterMsgType
{
    SDK_ALARMCENTER_ALARM,
    SDK_ALARMCENTER_LOG,
};

// 报警中心消息类型
enum SDK_AlarmCenterStatus
{
    SDK_AC_START,
    SDK_AC_STOP,
};

// 告警中心消息内容
typedef struct SDK_NetAlarmCenterMsg
{
    CONFIG_IPAddress HostIP;		///< 设备IP
    int nChannel;                   ///< 通道
    int nType;                      ///< 类型 见AlarmCenterMsgType
    int nStatus;                    ///< 状态 见AlarmCenterStatus
    SDK_SYSTEM_TIME Time;           ///< 发生时间
    char sEvent[NET_MAX_INFO_LEN];  ///< 事件
    char sSerialID[NET_MAX_MAC_LEN]; ///< 设备序列号
    char sDescrip[NET_MAX_INFO_LEN];  ///< 描述
}SDK_NetAlarmCenterMsg;

/// 编码信息
typedef struct SDK_EncodeInfo
{
    bool bEnable;			///< 使能项
    bool bHaveAudio;		///< 是否支持音频
    int iStreamType;		///< 码流类型，capture_channel_t
    unsigned int uiCompression;		///< capture_comp_t的掩码
    unsigned int uiResolution;		///< SDK_CAPTURE_SIZE_t的掩码
}SDK_EncodeInfo;

/// 编码能力
typedef struct CONFIG_EncodeAbility
{
    unsigned int iMaxEncodePower;		///< 支持的最大编码能力
    int iChannelMaxSetSync;		///< 每个通道分辨率是否需要同步 0-不同步, 1 -同步
    unsigned int nMaxPowerPerChannel[NET_MAX_CHANNUM];		///< 每个通道支持的最高编码能力
    unsigned int ImageSizePerChannel[NET_MAX_CHANNUM];		///< 每个通道支持的图像分辨率
    unsigned int ExImageSizePerChannel[NET_MAX_CHANNUM];		///< 每个通道支持的辅码流图像分辨率
    SDK_EncodeInfo vEncodeInfo[SDK_CHL_FUNCTION_NUM];	///< 编码信息,暂时最大就4中码流
    SDK_EncodeInfo vCombEncInfo[SDK_CHL_FUNCTION_NUM];	///< 组合编码信息,暂时最大就4中码流
    int	iMaxBps;				///< 最高码流Kbps
    unsigned int ExImageSizePerChannelEx[NET_MAX_CHANNUM][SDK_CAPTURE_SIZE_EXT_V3_NR];	///< 每个通道支持的辅码流图像分辨率
}CONFIG_EncodeAbility;

// 串口协议
enum SDK_CommProtocol
{
    SDK_CONSOLE = 0,
    SDK_KEYBOARD,
    SDK_COM_TYPES,
};
/// 串口协议
typedef struct SDK_COMMFUNC
{
    //每个协议最多由64个字符组成
    int nProNum;
    char vCommProtocol[100][32];
}SDK_COMMFUNC;

/// 云台协议
typedef struct SDK_PTZPROTOCOLFUNC
{
    //每个协议最多由64个字符组成
    int nProNum;
    char vPTZProtocol[100][NET_MAX_PTZ_PROTOCOL_LENGTH];
}SDK_PTZPROTOCOLFUNC;

/// 区域遮挡能力集
typedef struct SDK_BlindDetectFunction
{
    int iBlindConverNum;	///< 区域遮挡块数
}SDK_BlindDetectFunction;

/// 动检区域能力集
typedef struct SDK_MotionDetectFunction
{
    int iGridRow;
    int iGridColumn;
}SDK_MotionDetectFunction;

/// 支持的DDNS类型
typedef struct SDK_DDNSServiceFunction
{
    int  nTypeNum;
    char vDDNSType[NET_MAX_DDNS_TYPE][64];
}SDK_DDNSServiceFunction;

/// 支持语言
typedef struct SDK_MultiLangFunction
{
    //每个协议最多由64个字符组成
    int nLangNum;
    char vLanguageName[128][64];
}SDK_MultiLangFunction;

/// 支持的视频制式
typedef struct SDK_MultiVstd
{
    //每个协议最多由3个字符组成
    int nVstdNum;
    char vVstdName[3][64];
}SDK_MultiVstd;

/// 编码功能
enum SDK_EncodeFunctionTypes
{
    SDK_ENCODE_FUNCTION_TYPE_DOUBLE_STREAM,		///< 双码流功能
    SDK_ENCODE_FUNCTION_TYPE_COMBINE_STREAM,	///< 组合编码功能
    SDK_ENCODE_FUNCTION_TYPE_SNAP_STREAM,		///< 抓图功能
    SDK_ENCODE_FUNCTION_TYPE_WATER_MARK,		///< 水印功能
    SDK_ENCODE_FUNCTION_TYPE_IFRAME_RANGE,		///< I帧间隔
    SDK_ENCODE_FUNCTION_TYPE_LOW_BITRATE,   // 低码流
    SDK_ENCODE_FUNCTION_TYPE_NR,
};

/// 报警功能
enum SDK_AlarmFucntionTypes
{
    SDK_ALARM_FUNCTION_TYPE_MOTION_DETECT,	///< 动态检测
    SDK_ALARM_FUNCTION_TYPE_BLIND_DETECT,	///< 视屏遮挡
    SDK_ALARM_FUNCTION_TYPE_LOSS_DETECT,	///< 视屏丢失
    SDK_ALARM_FUNCTION_TYPE_LOCAL_ALARM,	///< 本地报警
    SDK_ALARM_FUNCTION_TYPE_NET_ALARM,		///< 网络报警
    SDK_ALARM_FUNCTION_TYPE_IP_CONFLICT,	///< IP地址冲突
    SDK_ALARM_FUNCTION_TYPE_NET_ABORT,		///< 网络异常
    SDK_ALARM_FUNCTION_TYPE_STORAGE_NOTEXIST,	///< 存储设备不存在
    SDK_ALARM_FUNCTION_TYPE_STORAGE_LOWSPACE,	///< 存储设备容量不足
    SDK_ALARM_FUNCTION_TYPE_STORAGE_FAILURE,	///< 存储设备访问失败
    SDK_ALARM_FUNCTION_TYPE_VIDEOANALYSE,///<视频分析
    SDK_ALARM_FUNCTION_TYPE_NET_ABORT_EXTEND,	//网络异常扩展
    SDK_ALARM_FUNCTION_TYPE_IPC_ALARM,			//IPC报警
    SDK_ALARM_FUNCTION_TYPE_NR
};

/// 网络服务功能
enum SDK_NetServerTypes
{
    SDK_NET_SERVER_TYPES_IPFILTER,		///< 白黑名单
    SDK_NET_SERVER_TYPES_DHCP,			///< DHCP功能
    SDK_NET_SERVER_TYPES_DDNS,			///< DDNS功能
    SDK_NET_SERVER_TYPES_EMAIL,			///< Email功能
    SDK_NET_SERVER_TYPES_MULTICAST,		///< 多播功能
    SDK_NET_SERVER_TYPES_NTP,			///< NTP功能
    SDK_NET_SERVER_TYPES_PPPOE,
    SDK_NET_SERVER_TYPES_DNS,
    SDK_NET_SERVER_TYPES_ARSP,			///< 主动注册服务
    SDK_NET_SERVER_TYPES_3G,            ///< 3G拨号
    SDK_NET_SERVER_TYPES_MOBILE=10,        ///< 手机监控
    SDK_NET_SERVER_TYPES_UPNP,			    ///< UPNP
    SDK_NET_SERVER_TYPES_FTP,			    ///< FTP
    SDK_NET_SERVER_TYPES_WIFI,          ///<WIFI
    SDK_NET_SERVER_TYPES_ALARM_CENTER,  ///< 告警中心
    SDK_NET_SERVER_TYPES_NETPLAT_MEGA,  ///< 互信互通
    SDK_NET_SERVER_TYPES_NETPLAT_XINWANG,  ///< 星望
    SDK_NET_SERVER_TYPES_NETPLAT_SHISOU,  ///< 视搜
    SDK_NET_SERVER_TYPES_NETPLAT_VVEYE,  ///< 威威眼
    SDK_NET_SERVER_TYPES_RTSP,     //RTSP
    SDK_NET_SERVER_TYPES_PHONEMSG=20,     //手机信息发送配置
    SDK_NET_SERVER_TYPES_PHONEMULTIMEDIAMSG,     //手机信息发送配置
    SDK_NET_SERVER_TYPES_DAS,          //主动注册
    SDK_NET_SERVER_TYPES_LOCALSDK_PLATFORM,          //网络平台信息设置
    SDK_NET_SERVER_TYPES_GOD_EYE,///<神眼接警中心系统
    SDK_NET_SERVER_TYPES_NAT,		///NAT穿透，MTU配置
    SDK_NET_SERVER_TYPES_VPN,     ///VPN
    SDK_NET_SERVER_TYPES_NET_KEYBOARD,	///网络键盘配置
    SDK_NET_SERVER_TYPES_SPVMN,		///28181协议配置
    SDK_NET_SERVER_TYPES_PMS,      //手机服务
    SDK_NET_SERVER_TYPE_KAICONG,		///凯聪配置
    SDK_NET_SERVER_TYPE_PROTOCOL_MAC,///支持MAC协议
    SDK_NET_SERVER_TYPE_XMHEARTBEAT, //雄迈心跳
    SDK_NET_SERVER_TYPES_MONITOR_PLATFORM, //神州数码监控平台
    SDK_NET_SERVER_TYPES_ANJUP2P,			//
    SDK_NET_SERVER_TYPES_TUTKIOTC,		//TUTK IOTC平台
    SDK_NET_SERVER_TYPES_BAIDUCLOUD, //百度云
    SDK_NET_SERVER_TYPES_MOBILWATCH,		//手机看店
    SDK_NET_NET_SERVER_TYPES_BJLTHY,				//北京龙腾
    SDK_NET_SERVER_TYPES_OPENVPN,			//openvpn配置
    SDK_NET_SERVER_TYPES_PROTOCOL_NAT,		//支持NAT协议
    SDK_NET_SERVER_TYPES_PLATFORM_GBEYES,	//支持环保数据叠加
    SDK_NET_SERVER_TYPES_DATALINK,			//DataLink客户网络服务中执行程序使能配置
    SDK_NET_SERVER_TYPES_WIFI_MODE,			//是否支持wifi模式相关配置
    SDK_NET_SERVER_TYPES_NR,
};

/// 预览功能
enum SDK_PreviewTypes
{
    SDK_PREVIEW_TYPES_TOUR,		///< 轮巡
    SDK_PREVIEW_TYPES_TALK,		///< GUI界面配置
    SDK_PREVIEW_TYPES_NR
};

///串口类型
enum SDK_CommTypes
{
    SDK_COMM_TYPES_RS485,			///<485串口
    SDK_COMM_TYPES_RS232,			///<232串口
    SDK_COMM_TYPES_NR
};

//输入法限制
enum SDK_InPutMethod
{
    SDK_NO_SUPPORT_CHINESE,		//不支持中文输入
    SDK_NO_SUPPORT_NR
};

//报警中标签显示
enum SDK_TipShow
{
    SDK_NO_BEEP_TIP_SHOW,  //蜂鸣提示
    SDK_NO_FTP_TIP_SHOW,  //FTP提示
    SDK_NO_EMAIL_TIP_SHOW,  //EMAIL提示
    SDK_NO_TIP_SHOW_NR
};
///车载功能
enum SDK_MobileCar
{
    SDK_MOBILEDVR_STATUS_EXCHANGE,
    SDK_MOBILEDVR_DELAY_SET,
    SDK_MOBILEDVR_CARPLATE_SET,
    SDK_MOBILEDVR_GPS_TIMING,
    SDK_MOBILEDVR_DVR_BOOT_TYPE_SET,
    SDK_MOBILEDVR_NR
};

///其他功能
enum SDK_OtherFunction
{
    SDK_OTHER_DOWNLOADPAUSE,		//录像下载暂停功能
    SDK_OTHER_USB_SUPPORT_RECORD,	//USB支持录像功能
    SDK_OTHER_SD_SUPPORT_RECORD,		//SD支持录像功能
    SDK_OTHER_ONVIF_CLIENT_SUPPORT,	//是否支持ONVIF客户端
    SDK_OTHER_NET_LOCALSEARCH_SUPPORT,	//是否支持远程搜索
    SDK_OTHER_MAXPLAYBACK_SUPPORT, //是否支持最大回放通道数显示
    SDK_OTHER_NVR_SUPPORT, //是否是专业NVR
    SDK_OTHER_C7_PLATFORM_SUPPORT,//支持C7平台
    SDK_OTHER_MAIL_TEST_SUPPORT,		//支持邮件测试
    SDK_OTHER_SHOW_OSD_INFO,            //支持显示3行OSD信息
    SDK_OTHER_HIDE_DIGITAL, //通道模式屏蔽功能
    SDK_OTHER_ACUTANCE_HORIZONTAL,	//锐度
    SDK_OTHER_ACUTANCE_VERTIAL,
    SDK_OTHER_BROAD_TRENDS,		//宽动态功能
    SDK_OTHER_NO_TALK,		//对讲能力
    SDK_OTHER_ALTER_DIGITAL_NAME,	//修改数字通道名称
    SDK_OTHER_SHOW_CONNECT_STATUS,      //支持显示wifi 3G 主动注册等的连接状态
    SDK_OTHER_SUPPORT_ECACT_SEEK,	//支持回放精准定位
    SDK_OTHER_UPLOAD_TITLEANDSTATE,		//通道标题和数字通道状态上传能力集
    SDK_OTHER_NO_HDD_RECORD,		//无硬盘录像
    SDK_OTHER_MUSICFILE_PLAY,		//播放音频文件
    SDK_OTHER_SUPPORT_SET_DIG_IP,//设置前端ip能力
    SDK_OTHER_VERSION_PRODUCT_TYPE,//支持在版本信息里显示设备型号
    SDK_OTHER_SUPPORT_CAMERA_IMG_STYLE,//支持摄像机图像风格
    SDK_OTHER_SUPPORT_TITLE_ABILITY,//支持修改onvif标题
    SDK_OTHER_SUPPORT_DIMEN_CODE,//支持二维码
    SDK_OTHER_SHOWFALSE_CHECKTIME,//屏蔽解码器时间同步功能
    SDK_OTHER_SUPPORT_TIME_ZONE, //时区配置
    SDK_OTHER_SHOW_ALARM_LEVEL_REGION,//显示数字通道报警功能的灵敏度和区域设置
    SDK_OTHER_SUPPORT_POS,//支持POS
    SDK_OTHER_HDD_LOWSPACE_USE_MB,//硬盘空间不足报警下限用MB
    SDK_OTHER_SUPPORT_CUSTOMIZE_OEMINFO,//定制OEM客户版本信息
    SDK_OTHER_DIGITAL_ENCODE,//数字通道编码配置
    SDK_OTHER_RESUME_PTZ_STATE,//开机恢复云台状态
    SDK_OTHER_SUPPORT_SNAP_CFG,//支持抓图配置
    SDK_OTHER_ABNORMITY_SEND_EMAIL,//存储设备存在及存储异常及存储空间不足发邮件
    SDK_OTHER_SUPPORT_DIGITAL_PRE,//支持数字通道预录
    SDK_OTHER_SUPPORT_WRITE_LOG, //报警页面添加是否写日志勾选框
    SDK_OTHER_SUPPORT_CHANGE_ONVIF_PORT,//支持修改onvif端口
    SDK_OTHER_SUPPORT_COMM_DATA_UPLOAD,  //支持串口数据上传到指定服务器
    SDK_OTHER_SUPPORT_TEXT_PASSWORD,//记录明文密码
    SDK_OTHER_SUPPORT_CLOUD_UPGRADE,	// 支持云升级
    SDK_OTHER_SUPPORT_USE_PROGRAM,//支持启动客户小程序
    SDK_OTHER_SUPPORT_MODIFY_FRONT_CFG,//支持修改前端配置
    SDK_OTHER_SUPPORT_FTP_TEST,    //新程序支持FTP支持FTP测试，老程序不支持。
    SDK_OTHER_SUPPORT_PTZ_IDLE_STATE, //云台空闲时执行何种操作的配置
	SDK_OTHER_SUPPORT_IMP_RCD,//web端是否提供关键录像搜索的选项	
	SDK_OTHER_SUPPORT_CAMERA_MOTOR_CTRL, //支持机器人马达控制
	SDK_OTHER_SUPPORT_ENCODE_ADD_BEEP,// 视频编码每隔30秒加入beep声
	SDK_OTHER_SUPPORT_FISH_EYE,	        //鱼眼功能能力集
	SDK_OTHER_SUPPORT_SPVMN_NAS_SERVER,	//安徽超清客户的nas服务器配置
	SDK_OTHER_NR
};

///支持的系统功能
typedef struct SDK_SystemFunction
{
    bool vEncodeFunction[SDK_ENCODE_FUNCTION_TYPE_NR];	///< 编码功能SDK_EncodeFunctionTypes
    bool vAlarmFunction[SDK_ALARM_FUNCTION_TYPE_NR];		///< 报警功能AlarmFucntionTypes
    bool vNetServerFunction[SDK_NET_SERVER_TYPES_NR];	///< 网络服务功能NetServerTypes
    bool vPreviewFunction[SDK_PREVIEW_TYPES_NR];		///< 预览功能PreviewTypes
    bool vCommFunction[SDK_COMM_TYPES_NR];			///<串口类型SDK_CommTypes
    bool vInputMethodFunction[SDK_NO_SUPPORT_NR];  //<输入法限制SDK_InPutMethod>
    bool vTipShowFunction[SDK_NO_TIP_SHOW_NR];               //报警标签显示SDK_TipShow>
    bool vMobileCarFunction[SDK_MOBILEDVR_NR];//车载功能
    bool vOtherFunction[SDK_OTHER_NR];				//其他功能OtherFunction
}SDK_SystemFunction;

typedef struct SDK_COMMATTRI
{
    int	iDataBits;	// 数据位取值为5,6,7,8
    int	iStopBits;	// 停止位
    int	iParity;	// 校验位
    int	iBaudRate;	// 实际波特率
}SDK_COMMATTRI;

// 串口配置
typedef struct SDK_CONFIG_COMM_X
{
    char iProtocolName[32];	// 串口协议:“Console”
    int iPortNo;		// 端口号
    SDK_COMMATTRI aCommAttri;		// 串口属性
}SDK_CONFIG_COMM_X;

typedef struct SDK_CommConfigAll
{
    SDK_CONFIG_COMM_X vCommConfig[SDK_COM_TYPES];
}SDK_CommConfigAll;


// 云台设置
typedef struct SDK_STR_CONFIG_PTZ
{
    char sProtocolName[NET_MAX_PTZ_PROTOCOL_LENGTH];	// 协议名称
    int	ideviceNo;				// 云台设备地址编号
    int	iNumberInMatrixs;		// 在矩阵中的统一编号
    int iPortNo;				// 串口端口号	[1, 4]
    SDK_COMMATTRI dstComm;			// 串口属性
}SDK_STR_CONFIG_PTZ;

//所有通道云台协议
typedef struct SDK_STR_PTZCONFIG_ALL
{
    SDK_STR_CONFIG_PTZ ptzAll[NET_MAX_CHANNUM];
}SDK_STR_PTZCONFIG_ALL;

//RS485
typedef struct SDK_STR_RS485CONFIG_ALL
{
    SDK_STR_CONFIG_PTZ ptzAll[NET_MAX_CHANNUM];
}SDK_STR_RS485CONFIG_ALL;


typedef struct SDK_CONFIG_WORKSHEET
{
    SDK_TIMESECTION	tsSchedule[NET_N_WEEKS][NET_N_TSECT];	/*!< 时间段 */
}SDK_CONFIG_WORKSHEET;

/// 录像模式种类
enum SDK_RecordModeTypes
{
    SDK_RECORD_MODE_CLOSED,		///< 关闭录像
    SDK_RECORD_MODE_MANUAL,		///< 手动录像
    SDK_RECORD_MODE_CONFIG,		///< 按配置录像
    SDK_RECORD_MODE_NR,
};

///< 录像设置
typedef struct SDK_RECORDCONFIG
{
    int iPreRecord;			///< 预录时间，为零时表示关闭
    bool bRedundancy;		///< 冗余开关
    bool bSnapShot;			///< 快照开关
    int iPacketLength;		///< 录像打包长度（分钟）[1, 255]
    int iRecordMode;		///< 录像模式，0 关闭，1 禁止 2 配置
    SDK_CONFIG_WORKSHEET wcWorkSheet;			///< 录像时间段
    unsigned int typeMask[NET_N_WEEKS][NET_N_TSECT];		///< 录像类型掩码
}SDK_RECORDCONFIG;

//录像设置结构体
typedef struct SDK_RECORDCONFIG_ALL
{
    SDK_RECORDCONFIG vRecordConfigAll[NET_MAX_CHANNUM+NET_MAX_CHANNUM];
}SDK_RECORDCONFIG_ALL;

///< 图片设置
typedef struct SDK_SnapshotConfig
{
    int iPreSnap;			///< 预抓图片数
    bool bRedundancy;		///< 冗余开关
    int iSnapMode;		///< 录像模式，见RecordModeTypes
    SDK_CONFIG_WORKSHEET wcWorkSheet;				///< 录像时间段
    unsigned int typeMask[NET_N_WEEKS][NET_N_TSECT];	///< 录像类型掩码，见enum RecordTypes
}SDK_SnapshotConfig;

typedef struct SDK_SnapshotConfigAll
{
    SDK_SnapshotConfig vSnapshotConfigAll[NET_MAX_CHANNUM];
}SDK_SnapshotConfigAll;


//报警相关结构体
//  云台联动结构
typedef struct SDK_PtzLinkConfig
{
    int iType;		// 联动的类型
    int iValue;		// 联动的类型对应的值
}SDK_PtzLinkConfig;

#define CHANNELNAME_MAX_LEN 64  //通道名称最大长度

typedef struct SDK_EventHandler
{
    unsigned int	dwRecord;				// 录象掩码
    int		iRecordLatch;			// 录像延时：10?300 sec
    unsigned int	dwTour;					// 轮巡掩码
    unsigned int	dwSnapShot;				// 抓图掩码
    unsigned int	dwAlarmOut;				// 报警输出通道掩码
    unsigned int	dwMatrix;				// 矩阵掩码
    int		iEventLatch;			// 联动开始延时时间，s为单位
    int		iAOLatch;				// 报警输出延时：10?300 sec
    SDK_PtzLinkConfig PtzLink[NET_MAX_CHANNUM];		// 云台联动项
    SDK_CONFIG_WORKSHEET schedule;		// 录像时间段
    
    bool	bRecordEn;				// 录像使能
    bool	bTourEn;				// 轮巡使能
    bool	bSnapEn;				// 抓图使能
    bool	bAlarmOutEn;			// 报警使能
    bool	bPtzEn;
    
    // 云台联动使能
    bool	bTip;					// 屏幕提示使能
    bool	bMail;					// 发送邮件
    bool	bMessage;				// 发送消息到报警中心
    bool	bBeep;					// 蜂鸣
    bool	bVoice;					// 语音提示
    bool	bFTP;					// 启动FTP传输
    bool	bMatrixEn;				// 矩阵使能
    bool	bLog;					// 日志使能
    bool	bMessagetoNet;			// 消息上传给网络使能
    
    bool    bShowInfo;              // 是否在GUI上和编码里显示报警信息
    unsigned int    dwShowInfoMask;         // 要联动显示报警信息的通道掩码
    char    pAlarmInfo[CHANNELNAME_MAX_LEN];//要显示的报警信息
    
    bool    bShortMsg;              //发送短信
    bool    bMultimediaMsg;         //发送彩信
}SDK_EventHandler;

enum SDK_ANALYSE_MODE
{
    SDK_ANALYSE_TRIPWIRE = 0, //单绊线
    SDK_ANALYSE_PERIMETER     //周界检测
};
/** 周界检测模式 */
enum SDK_URP_PERIMETER_MODE_E
{
    SDK_URP_PMODE_INTRUSION = 0,			/**< 入侵 */
    SDK_URP_PMODE_ENTER,				/**< 进入 */
    SDK_URP_PMODE_EXIT				/**< 离开 */
};

/** 最大边界点数 */
#define SDK_MAX_BOUNDARY_POINT_NUM 8
#define SDK_MAX_POINT_NUM 4
#define SDK_NAME_BUF_SIZE 16

/** 坐标点 */
typedef struct URP_SDK_POINT_S
{
    short X;					/**< x */
    short Y;					/**< y */
}URP_SDK_POINT_S;

/** 线结构 */
typedef struct SDK_URP_LINE_S
{
    URP_SDK_POINT_S stStartPt;			/**< 线段起点 */
    URP_SDK_POINT_S stEndPt;			/**< 线段终点 */
}SDK_URP_LINE_S;

typedef struct SDK_URP_POLYGON_REGION_S
{
    int iValid;
    int iPointNum;
    URP_SDK_POINT_S astPoint[SDK_MAX_BOUNDARY_POINT_NUM];
}SDK_URP_POLYGON_REGION_S;

/** URP周界检测边界点 */
typedef struct SDK_URP_PERIMETER_LIMIT_BOUNDARY_S
{
    int      iBoundaryPtNum;					/**< 边界点数目 */
    URP_SDK_POINT_S   astBoundaryPts[SDK_MAX_BOUNDARY_POINT_NUM];	/**< 边界点集合 */
}SDK_URP_PERIMETER_LIMIT_BOUNDARY_S;

/** URP周界检测限制参数 */
typedef struct SDK_URP_PERIMETER_LIMIT_PARA_S
{
    int iMinDist;						/**< 最小像素距离 */
    int iMinTime;						/**< 最短时间 */
    int	iDirectionLimit;					/**< 是否做方向限制 */
    int iForbiddenDirection;					/**< 禁止方向角度(单位: 角度) */
    SDK_URP_PERIMETER_LIMIT_BOUNDARY_S stBoundary;			/**< 周界边界区域 */
}SDK_URP_PERIMETER_LIMIT_PARA_S;

/** URP周界检测规则参数 */
typedef struct SDK_URP_PERIMETER_RULE_PARA_S
{
    int iTypeLimit;						/**< 目标类型限制 */
    int iTypeHuman;						/**< 目标类别：人(限定类型时使用) */
    int iTypeVehicle;						/**< 目标类别：车 */
    int iMode;						/**< 周界模式 */
    SDK_URP_PERIMETER_LIMIT_PARA_S stLimitPara;				/**< 周界限制参数 */
}SDK_URP_PERIMETER_RULE_PARA_S;

// ----------------------------------------------------------------------
//  绊线数据结构
/** URP单绊线最多条数 */
#define SDK_URP_MAX_TRIPWIRE_CNT 8

/** URP单绊线结构 */
typedef struct SDK_URP_TRIPWIRE_S
{
    int     iValid;						/**< 是否有效 */
    int    iIsDoubleDirection;				/**< 表示该绊线是否为双向绊线(0: 否, 1: 是) */
    int     iForbiddenDirection;				/**< 单绊线禁止方向*/
    SDK_URP_LINE_S	stLine;						/**< 单绊线位置 */
}SDK_URP_TRIPWIRE_S;

/** URP单绊线限制参数 */
typedef struct SDK_URP_TRIPWIRE_LIMIT_PARA_S
{
    int iMinDist;						/**< 最小像素距离 */
    int iMinTime;						/**< 最短时间 */
}SDK_URP_TRIPWIRE_LIMIT_PARA_S;

/** URP单绊线规则参数 */
typedef struct SDK_URP_TRIPWIRE_RULE_PARA_S
{
    int iTypeLimit;						/**< 目标类型限制 */
    int iTypeHuman;						/**< 目标类别：人(限定类型时使用) */
    int iTypeVehicle;						/**< 目标类别：车 */
    SDK_URP_TRIPWIRE_S astLines[SDK_URP_MAX_TRIPWIRE_CNT];		/**< 单绊线 */
    SDK_URP_TRIPWIRE_LIMIT_PARA_S stLimitPara;				/**< 单绊线限制参数 */
}SDK_URP_TRIPWIRE_RULE_PARA_S;


/** URP目标输出灵敏度级别 */
enum SDK_SENSITIVITY_LEVEL_E
{
    SDK_HIGH_LEVEL_SENSITIVITY,         /**< 高灵敏度 */
    SDK_MIDDLE_LEVEL_SENSITIVITY,		/**< 中灵敏度 */
    SDK_LOW_LEVEL_SENSITIVITY			/**< 低灵敏度 */
};

/** 算法模块 */

enum SDK_MODULE_TYPE
{
    SDK_MODULE_TYPE_PEA = 0,
    SDK_MODULE_TYPE_OSC,
    SDK_MODULE_TYPE_AVD,
    SDK_MODULE_TYPE_ALL
};

// ----------------------------------------------------------------------
// 下面开始是自定义结构

typedef struct SDK_PEA_RULE_S
{
    int iShowTrack;						/// 是否显示轨迹
    int iShowRule;						/// 是否显示规则
    int iLevel;						/// 警戒级别（灵敏度）0：高级（默认值）；1：中级；2：低级；
    int iPerimeterEnable;					/// 周界规则使能
    SDK_URP_PERIMETER_RULE_PARA_S	stPerimeterRulePara;	/**< 周界检测 */
    int iTripWireEnable;					/// 单绊线规则使能
    SDK_URP_TRIPWIRE_RULE_PARA_S	stTripwireRulePara;	/**< 单绊线检测 */
}SDK_PEA_RULE_S;

/// 算法能力结构
typedef struct SDK_CAPS					/// 置1表示该通道支持对应的智能算法，置0表示不支持。
{
    int dwPEA;
    int dwAVD;
    int dwVFD;
    int dwAAI;
    int dwOSC;
    int iResv[3];
}SDK_CAPS;

typedef struct SDK_PEA_STATUS_S
{
    int dwPerimeter;					/// 入侵检测状态，包括了伴线和周界,，uint值是各个报警输入通道报警状态的掩码。
    /// 低通道在低位，高通道在高位。报警置1，无报警置0，不存在的通道置0。
    int iResv[4];
    int avdStatue;
}SDK_PEA_STATUS_S;


//物品遗留-begin
#define NET_MAX_OSC_NUM 4
#define NET_MAX_POINT_NUM 4
#define NET_NAME_BUF_SIZE 16

typedef struct SDK_URP_OSC_SPECL_REGIONS_S
{
    int nValid; //是否有效
    char chName[NET_NAME_BUF_SIZE]; //区域名称
    SDK_URP_POLYGON_REGION_S stOscRg; //要检测区域定义
    SDK_URP_POLYGON_REGION_S astSubRgA; //检测区域中的无效子区域
    SDK_URP_POLYGON_REGION_S astSubRgB; //检测区域中的无效子区域
    SDK_URP_POLYGON_REGION_S astSubRgC; //检测区域中的无效子区域
}SDK_URP_OSC_SPECL_REGIONS_S;

typedef struct SDK_URP_OSC_LMT_PARA_S
{
    int nTimeMin; //时间约束
    int nSizeMin; //最小尺寸
    int nSizeMax; //最大尺寸
}SDK_URP_OSC_LMT_PARA_S;

typedef struct SDK_URP_OSC_RULE_PARA_S
{
    int nSceneType; //场景类型
    int nCameraType; //相机类型
    SDK_URP_OSC_SPECL_REGIONS_S astSpclRgs[NET_MAX_OSC_NUM]; //要处理的区域个数
    SDK_URP_OSC_LMT_PARA_S stOscPara; //一些约束
}SDK_URP_OSC_RULE_PARA_S;

typedef struct SDK_OSC_RULE_S
{
    int iShowTrack;				/// 是否显示轨迹
    int iShowRule;						     /// 是否显示规则
    int iLevel;						     /// 警戒级别0：非警报（默认值）；1：低级；2：中级；3: 高级
    int iAbandumEnable;		   	/// 物品遗留使能
    SDK_URP_OSC_RULE_PARA_S stObjAbandumRulePara; /// 物品遗留参数
    int iStolenEnable;			  	 /// 物品被盗使能
    SDK_URP_OSC_RULE_PARA_S stObjStolenRulePara;   /// 物品被盗参数
    int iNoParkingEnable;		 	  	 /// 非法停车使能
    SDK_URP_OSC_RULE_PARA_S stNoParkingRulePara;   /// 非法停车参数
}SDK_OSC_RULE_S;


typedef struct SDK_AVD_RULE_S
{
    int iLevel;						     /// 灵敏度档位，1-5档，数值越大越灵敏越易报警
    int itBrightAbnmlEnable;				///< 亮度异常使能
    int iClarityEnable;					///< 清晰度检测使能
    int iNoiseEnable;					///< 噪声检测使能
    int iColorEnable;					///< 偏色检测使能
    int iFreezeEnable;					///< 画面冻结检测使能
    int iNosignalEnable;					///< 信号缺失检测使能
    int iChangeEnable;					///< 场景变换检测使能
    int iInterfereEnable;					///< 人为干扰检测使能
    int iPtzLoseCtlEnable;					///< PTZ失控检测使能
}SDK_AVD_RULE_S;

/** 坐标点 */
typedef struct SDK_URP_IMP_POINT_S
{
    short s16X;					/**< x */
    short s16Y;					/**< y */
}SDK_URP_IMP_POINT_S;

typedef struct SDK_CPC_RULE_S
{
    SDK_URP_IMP_POINT_S stRulePoint[4];	///检测规则，需要画满4个点
    int s32Sizemin;			///最小像距(0,height/2)
    int s32Sizemax;			///最大像距(sizemin, height/2)
    int s32Countmax;			///最大目标数[1~15],
    int s32Sensitivity;		/// 灵敏度档位，1-5档，数值越大越灵敏越易报警
    unsigned int u32Flag;				///标志位，用来判断进出，默认设0
    int s32EnterDirection;	///进入的方向
}SDK_CPC_RULE_S;

//各种算法的规则配置集合
typedef struct SDK_RULECONFIG
{
    SDK_PEA_RULE_S stRulePea;   //周界检测与绊线配置
    SDK_OSC_RULE_S stRuleOSC; //物品盗移、滞留，非法停车配置
    SDK_AVD_RULE_S stRuleAVD;//异常视频信号诊断配置
    SDK_CPC_RULE_S stRuleCPC; //人头计数算法配置
}SDK_RULECONFIG;


//一个通道的智能分析配置
typedef struct SDK_ANALYSECONFIG
{
    bool         bEnable;      //是否启用视频分析功能
    int          moduleType;   //使用的那种算法模块
    SDK_EventHandler hEvent;  //联动事件
    SDK_RULECONFIG   stRuleConfig; //各种算法的规则配置
}SDK_ANALYSECONFIG;

//所有通道的智能分析配置
typedef struct SDK_ANALYSECONFIG_ALL
{
    SDK_ANALYSECONFIG vAnalyzeAll[NET_MAX_CHANNUM];
}SDK_ANALYSECONFIG_ALL;

//智能分析能力
typedef struct SDK_ANALYZEABILITY
{
    UINT uIntelPEA; //智能PEA支持，位对应通道
    UINT uAlgorithmPEA;//PEA支持的算法类型，例如拌线
    UINT uIntelOSC; //智能OSC支持，位对应通道
    UINT uAlgorithmOSC;//OSC支持的算法类型
    UINT uIntelAVD; //智能AVD支持，位对应通道
    UINT uAlgorithmAVD;//AVD支持的算法类型
    UINT uIntelCPC; //人流量记数支持，位对应通道
    UINT uAlgorithmCPC;//CPC支持的算法类型
}SDK_ANALYZEABILITY;



///< 动态检测设置
typedef struct SDK_MOTIONCONFIG
{
    bool bEnable;							// 动态检测开启
    int iLevel;								// 灵敏度
    unsigned int mRegion[NET_MD_REGION_ROW];			// 区域，每一行使用一个二进制串
    SDK_EventHandler hEvent;					// 动态检测联动
}SDK_MOTIONCONFIG;

/// 全通道动态检测配置
typedef struct SDK_MOTIONCONFIG_ALL
{
    SDK_MOTIONCONFIG vMotionDetectAll[NET_MAX_CHANNUM];
}SDK_MOTIONCONFIG_ALL;

///< 遮挡检测配置
typedef struct SDK_BLINDDETECTCONFIG
{
    bool	bEnable;		///< 遮挡检测开启
    int		iLevel;			///< 灵敏度：1?6
    SDK_EventHandler hEvent;	///< 遮挡检测联动
}SDK_BLINDDETECTCONFIG;

/// 全通道遮挡检测配置
typedef struct SDK_BLINDDETECTCONFIG_ALL
{
    SDK_BLINDDETECTCONFIG vBlindDetectAll[NET_MAX_CHANNUM];
}SDK_BLINDDETECTCONFIG_ALL;

///< 基本事件结构
typedef struct SDK_VIDEOLOSSCONFIG
{
    bool bEnable;			///< 使能
    SDK_EventHandler hEvent;	///< 处理参数
}SDK_VIDEOLOSSCONFIG;

/// 所有通道的基本时间结构
typedef struct SDK_VIDEOLOSSCONFIG_ALL
{
    SDK_VIDEOLOSSCONFIG vGenericEventConfig[NET_MAX_CHANNUM];
}SDK_VIDEOLOSSCONFIG_ALL;

///< 报警输入配置
typedef struct SDK_ALARM_INPUTCONFIG
{
    bool	bEnable;		///< 报警输入开关
    int		iSensorType;	///< 传感器类型常开 or 常闭
    SDK_EventHandler hEvent;	///< 报警联动
}SDK_ALARM_INPUTCONFIG;

///< 所有通道的报警输入配置
typedef struct SDK_ALARM_INPUTCONFIG_ALL
{
    SDK_ALARM_INPUTCONFIG vAlarmConfigAll[NET_MAX_CHANNUM];
}SDK_ALARM_INPUTCONFIG_ALL;

///< 网路报警
typedef struct SDK_NETALARMCONFIG
{
    bool bEnable;			///< 使能
    SDK_EventHandler hEvent;	///< 处理参数
}SDK_NETALARMCONFIG;

/// 所有通道的网路报警结构
typedef struct SDK_NETALARMCONFIG_ALL
{
    SDK_NETALARMCONFIG vNetAlarmConfig[NET_MAX_CHANNUM];
}SDK_NETALARMCONFIG_ALL;

///< 本地报警输出配置
typedef struct SDK_AlarmOutConfig
{
    int nAlarmOutType;		///< 报警输出类型: 配置,手动,关闭
    int nAlarmOutStatus;    ///< 报警状态: 0:打开 1;闭合
}SDK_AlarmOutConfig;

//< 硬盘容量不足事件剩余容量类型
enum SDK_StorageLowSpaceType
{
    SDK_PERSENT = 0,
    SDK_MB,
    SDK_GB,
};

///< 硬盘容量不足事件结构
typedef struct SDK_StorageLowSpaceConfig
{
    bool bEnable;
    int iLowerLimit;		///< 硬盘剩余容量下限, 百分数
    SDK_EventHandler hEvent;	///< 处理参数
    bool bRecordTimeEnable;
    int iRecordTime;		///<录像天数
    int iLowerLimitSpace;		///< 硬盘剩余容量MB或者GB为单位
    int EnableType;		///< 0为用百分比，1为用MB，见枚举StorageLowSpaceType
}SDK_StorageLowSpaceConfig;

///< 所有通道的报警输出配置
typedef struct SDK_AlarmOutConfigAll
{
    SDK_AlarmOutConfig vAlarmOutConfigAll[NET_MAX_CHANNUM];
}SDK_AlarmOutConfigAll;

/// 所有通道的解码器地址设置V2版本
typedef struct SDK_AbilitySerialNo
{
    char serialNo[NET_MAX_SERIALNO_LENGTH];
    char productType[NET_MAX_SERIALNO_LENGTH];
}SDK_AbilitySerialNo;

///< 驱动器信息结构
typedef struct SDK_DriverInformation
{
    int		iDriverType;		///< 驱动器类型
    bool	bIsCurrent;			///< 是否为当前工作盘
    unsigned int	uiTotalSpace;		///< 总容量，MB为单位
    unsigned int	uiRemainSpace;		///< 剩余容量，MB为单位
    int		iStatus;			///< 错误标志，文件系统初始化时被设置
    int		iLogicSerialNo;				///< 逻辑序号
    SDK_SYSTEM_TIME  tmStartTimeNew;		///< 新录像时间段的开始时间
    SDK_SYSTEM_TIME	 tmEndTimeNew;			///< 新录像时间段的结束时间
    SDK_SYSTEM_TIME	 tmStartTimeOld;		///< 老录像时间段的开始时间
    SDK_SYSTEM_TIME	 tmEndTimeOld;			///< 老录像时间段的结束时间
}SDK_DriverInformation;
enum
{
    SDK_MAX_DRIVER_PER_DISK = 2,	///< 每个磁盘最多的分区数
    SDK_MAX_DISK_PER_MACHINE = 8,	///< 最多支持8块硬盘
};
//硬盘管理
typedef struct SDK_STORAGEDISK
{
    int		iPhysicalNo;
    int		iPartNumber;		// 分区数
    SDK_DriverInformation diPartitions[SDK_MAX_DRIVER_PER_DISK];
}SDK_STORAGEDISK;

typedef struct SDK_StorageDeviceInformationAll
{
    int iDiskNumber;
    SDK_STORAGEDISK vStorageDeviceInfoAll[SDK_MAX_DISK_PER_MACHINE];
}SDK_StorageDeviceInformationAll;

/// 存储设备控制类型
enum SDK_StorageDeviceControlTypes
{
    SDK_STORAGE_DEVICE_CONTROL_SETTYPE,		///< 设置类型
    SDK_STORAGE_DEVICE_CONTROL_RECOVER,		///< 恢复错误
    SDK_STORAGE_DEVICE_CONTROL_PARTITIONS,	///< 分区操作
    SDK_STORAGE_DEVICE_CONTROL_CLEAR,		///< 清除操作
    SDK_STORAGE_DEVICE_CONTROL_NR,
};

/// 清除磁盘数据类型
enum SDK_StorageDeviceClearTypes
{
    SDK_STORAGE_DEVICE_CLEAR_DATA,			///< 清除录像数据
    SDK_STORAGE_DEVICE_CLEAR_PARTITIONS,	///< 清除分区
    SDK_STORAGE_DEVICE_CLEAR_NR,
};

/// 驱动器类型
enum SDK_FileSystemDriverTypes
{
	SDK_DRIVER_READ_WRITE	= 0,	///< 读写驱动器
	SDK_DRIVER_READ_ONLY	= 1,	///< 只读驱动器
	SDK_DRIVER_EVENTS		= 2,	///< 事件驱动器
	SDK_DRIVER_REDUNDANT	= 3,	///< 冗余驱动器
	SDK_DRIVER_SNAPSHOT		= 4,	///< 快照驱动器
	SDK_DRIVER_TYPE_NR		= 5,	///< 驱动器类型个数
	SDK_DRIVER_UNUSED		= 0xff,	///< 没有使用的驱动器结构
};

/// 存储设备控制
typedef struct SDK_StorageDeviceControl
{
    int iAction;	///< 见enum SDK_StorageDeviceControlTypes
    int iSerialNo;	///< 磁盘序列号
    int iPartNo;    ///< 分区号
    int iType;		///< enum SDK_StorageDeviceClearTypes或者SDK_FileSystemDriverTypes
    int iPartSize[2/*MAX_DRIVER_PER_DISK*/];	///< 各个分区的大小
}SDK_StorageDeviceControl;

/// 设备类型
typedef enum SDK_DeviceType
{
    SDK_DEVICE_TYPE_DVR,	///< 普通DVR设备
    SDK_DEVICE_TYPE_NVS,	///< NVS设备
    SDK_DEVICE_TYPE_IPC,	///< IPC设备
    SDK_DEVICE_TYPE_HVR,	///<混合dvr
    SDK_DEVICE_TYPE_IVR,	///<智能dvr
    SDK_DEVICE_TYPE_MVR,	///<车载dvr
    SDK_DEVICE_TYPE_NR
}SDK_DeviceType;

/// 设备信息
typedef struct _H264_DVR_DEVICEINFO
{
    char sSoftWareVersion[64];	///< 软件版本信息
    char sHardWareVersion[64];	///< 硬件版本信息
    char sEncryptVersion[64];	///< 加密版本信息
    SDK_SYSTEM_TIME tmBuildTime;///< 软件创建时间
    char sSerialNumber[64];			///< 设备序列号
    int byChanNum;				///< 视频输入通道数
    int iVideoOutChannel;		///< 视频输出通道数
    int byAlarmInPortNum;		///< 报警输入通道数
    int byAlarmOutPortNum;		///< 报警输出通道数
    int iTalkInChannel;			///< 对讲输入通道数
    int iTalkOutChannel;		///< 对讲输出通道数
    int iExtraChannel;			///< 扩展通道数
    int iAudioInChannel;		///< 音频输入通道数
    int iCombineSwitch;			///< 组合编码通道分割模式是否支持切换
    int iDigChannel;		///<数字通道数
    unsigned int uiDeviceRunTime;	///<系统运行时间
    SDK_DeviceType deviceTye;	///设备类型
    char sHardWare[64];		///<设备型号
    char uUpdataTime[20];	///<更新日期 例如 2013-09-03 14:15:13
    unsigned int uUpdataType;	///<更新内容
    int nLanguage;//国家的语言ID,0:英文/ 1:中文
    char sCloudErrCode[NET_MAX_PATH_LENGTH];//云登陆具体错误内容
	int status[32];
	//判断新过来的连接是不是通过代理转发的，如果是那么按照服务器
	//返回的限制条件来限制。
	//status[0] 路数限制:0代表不限制， n代表限制n路
	//status[1]码流限制。0 :不限制。1限制不能观看主码流。
	//status[2]限制时间。0:不限制。n:限制n分钟。
	//status[3]限制码率，目前分为四档。0:不限制。1:限制为CIF 6帧 100K ，后续待定
	//status[4]保留位，后续扩充。
	//其中status[0]和status[1]在此处体现。
	//status[2]和status[3]在传输码流的过程中体现
}H264_DVR_DEVICEINFO,*LPH264_DVR_DEVICEINFO;

//主动服务回调数据
typedef struct H264_DVR_ACTIVEREG_INFO
{
    char deviceSarialID[64];//设备序列号，如果大于64位则赋值0
    H264_DVR_DEVICEINFO deviceInfo;//设备信息
    char IP[IP_SIZE];   //外网IP
}H264_DVR_ACTIVEREG_INFO;
///< 自动维护设置
typedef struct SDK_AutoMaintainConfig
{
    int iAutoRebootDay;				///< 自动重启设置日期
    int iAutoRebootHour;			///< 重启整点时间	[0, 23]
    int iAutoDeleteFilesDays;		///< 自动删除文件时间[0, 30]
}SDK_AutoMaintainConfig;

/// 默认配置种类
enum SDK_DefaultConfigKinds
{
    SDK_DEFAULT_CFG_GENERAL,			// 普通配置
    SDK_DEFAULT_CFG_ENCODE,				// 编码配置
    SDK_DEFAULT_CFG_RECORD,				// 录像配置
    SDK_DEFAULT_CFG_NET_SERVICE,		// 网络服务
    SDK_DEFAULT_CFG_NET_COMMON,			// 通用网络
    SDK_DEFAULT_CFG_ALARM,				// 报警
    SDK_DEFAULT_CFG_PTZCOMM,			// 云台，串口
    SDK_DEFAULT_CFG_USERMANAGER,		// 用户管理
    SDK_DEFAULT_CFG_PREVIEW,			// 预览配置
    SDK_DEFAULT_CFG_CAMERA_PARAM,            // 网络摄像头配置
    SDK_DEFAULT_CFG_END,
};

/// 恢复的默认配置种类
typedef struct SDK_SetDefaultConfigTypes
{
    bool vSetDefaultKinds[SDK_DEFAULT_CFG_END];
}SDK_SetDefaultConfigTypes;


typedef struct H264_DVR_CLIENTINFO{
    int nChannel;	//通道号
    int nStream;	//0表示主码流，为1表示子码流
    int nMode;		//0：TCP方式,1：UDP方式,2：多播方式,3 - RTP方式，4-音视频分开(TCP)
    int nComType;	//只对组合编码通道有效, 组合编码通道的拼图模式
    void* hWnd;
    
#ifndef OS_IOS
    H264_DVR_CLIENTINFO()
    {
        hWnd=0;
    }
#endif
    
}*LPH264_DVR_CLIENTINFO;


enum SDK_File_Type
{
    SDK_RECORD_ALL = 0,
    SDK_RECORD_ALARM = 1, //外部报警录像
    SDK_RECORD_DETECT,	  //视频侦测录像
    SDK_RECORD_REGULAR,	  //普通录像
    SDK_RECORD_MANUAL,	  //手动录像
    SDK_PIC_ALL = 10,
    SDK_PIC_ALARM,		  //外部报警录像
    SDK_PIC_DETECT,		  //视频侦测录像
    SDK_PIC_REGULAR,      //普通录像
    SDK_PIC_MANUAL,       //手动录像
    SDK_PIC_IDXIMG,		  //索引图片
    SDK_PIC_KEY,		//关键录像
    SDK_TYPE_NUM
};

//查询录像条件
typedef struct H264_DVR_FINDINFO
{
    int nChannelN0;			//通道号
    int nFileType;			//文件类型, 见SDK_File_Type
    H264_DVR_TIME startTime;	//开始时间
    H264_DVR_TIME endTime;	//结束时间
    char szFileName[32];		//文件名，为空的话，系统处理，有值，系统采用
    void *hWnd;
    int  StreamType;
#ifndef OS_IOS
    H264_DVR_FINDINFO()
    {
        hWnd=0;
        StreamType =0;
    }
#endif
}H264_DVR_FINDINFO;

//录像文件返回结构体
typedef struct H264_DVR_FILE_DATA
{
    int ch;						//通道号
    int size;					//文件大小
    char sFileName[108];		///< 文件名
    SDK_SYSTEM_TIME stBeginTime;	///< 文件开始时间
    SDK_SYSTEM_TIME stEndTime;		///< 文件结束时间
    void *hWnd;
    int StreamType;	//码流类型是回放主码流还是辅助码流
#ifndef OS_IOS
    H264_DVR_FILE_DATA()
    {
        hWnd=0;
        StreamType =0;
    };
#endif
}H264_DVR_FILE_DATA;

//回放动作
enum SDK_PlayBackAction
{
    SDK_PLAY_BACK_PAUSE,		/*<! 暂停回放 */
    SDK_PLAY_BACK_CONTINUE,		/*<! 继续回放 */
    SDK_PLAY_BACK_SEEK,			/*<! 回放定位，时间s为单位 */
    SDK_PLAY_BACK_FAST,	        /*<! 加速回放 */
    SDK_PLAY_BACK_SLOW,	        /*<! 减速回放 */
    SDK_PLAY_BACK_SEEK_PERCENT, /*<! 回放定位百分比 */
};

//按时间段查询
typedef struct SDK_SearchByTime
{
    int nHighChannel;			///< 33~64录像通道号掩码
    int nLowChannel;			///< 1~32录像通道号掩码
    int nFileType;              ///< 文件类型, 见SDK_File_Type
    SDK_SYSTEM_TIME stBeginTime;	    ///< 查询开始时间
    SDK_SYSTEM_TIME stEndTime;		///< 查询结束时间
    int    iSync;               ///< 是否需要同步
    unsigned int	nHighStreamType;///< 33~64录像的码流类型
    unsigned int nLowStreamType;///< 1~32录像的码流类型
}SDK_SearchByTime;

//每个通道的录像信息
typedef struct SDK_SearchByTimeInfo
{
    int iChannel;			    ///< 录像通道号
    ///< 录像记录用720个字节的5760位来表示一天中的1440分钟
    ///< 0000:无录像 0001:F_COMMON 0002:F_ALERT 0003:F_DYNAMIC 0004:F_CARD 0005:F_HAND
    unsigned char cRecordBitMap[720];
}SDK_SearchByTimeInfo;

typedef struct SDK_SearchByTimeResult
{
    int nInfoNum;										 ///< 通道的录像记录信息个数
    SDK_SearchByTimeInfo ByTimeInfo[NET_MAX_CHANNUM];    ///< 通道的录像记录信息
}SDK_SearchByTimeResult;

//报警信息
typedef struct SDK_ALARM_INFO
{
    int nChannel;
    int iEvent; //报警事件码:见枚举SDK_EventCodeTypes
    int iStatus;//0:报警开始，1:报警结束
    SDK_SYSTEM_TIME SysTime;
}SDK_AlarmInfo;

/// 日志查询条件
typedef struct SDK_LogSearchCondition
{
    int nType;						///< 日志类型
    int iLogPosition;				///< 从上次查询的结束时的日志指针
    SDK_SYSTEM_TIME stBeginTime;	///< 查询日志开始时间
    SDK_SYSTEM_TIME stEndTime;		///< 查询日志结束时间
}SDK_LogSearchCondition;


typedef struct SDK_LogItem
{
    char sType[24];	///< 日志类型
    char sUser[32];	///< 日志用户
    char sData[68];	///< 日志数据
    SDK_SYSTEM_TIME stLogTime;	///< 日志时间
    int iLogPosition;			///< 从上次查询的结束时的日志指针
}SDK_LogItem;

//日志返回信息
typedef struct SDK_LogList
{
    int iNumLog;
    SDK_LogItem Logs[NET_MAX_RETURNED_LOGLIST];
}SDK_LogList;

/// 语音对讲格式
typedef struct SDK_AudioInFormatConfigAll
{
    SDK_AudioInFormatConfig vAudioInFormatConfig[SDK_AUDIO_ENCODE_TYPES_NR];
}SDK_AudioInFormatConfigAll;

/// 告警状态
typedef struct SDK_DVR_ALARMSTATE
{
    int iVideoMotion; ///< 移动侦测状态,用掩码表示通道号,bit0代表通道一,以此类推 1: 有告警 0: 无告警
    int iVideoBlind; ///< 视频遮挡状态,用掩码表示通道号,bit0代表通道一,以此类推 1: 有告警 0: 无告警
    int iVideoLoss;	///< 视频丢失状态,用掩码表示通道号,bit0代表通道一,以此类推 1: 有告警 0: 无告警
    int iAlarmIn;	///< 告警输入状态,用掩码表示通道号,bit0代表通道一,以此类推 1: 有告警 0: 无告警
    int iAlarmOut;	///< 告警输出状态,用掩码表示通道号,bit0代表通道一,以此类推 1: 有告警 0: 无告警
}SDK_DVR_ALARMSTATE;

// 通道状态
typedef struct SDK_DVR_CHANNELSTATE
{
    bool bRecord; ///< 是否正在录像
    int iBitrate;	///< 当前码率
}SDK_DVR_CHANNELSTATE;

// DVR工作状态
typedef struct SDK_DVR_WORKSTATE
{
    SDK_DVR_CHANNELSTATE vChnState[NET_MAX_CHANNUM];
    SDK_DVR_ALARMSTATE vAlarmState;
}SDK_DVR_WORKSTATE;


/// 按键值, 不能随便更改
enum SDK_NetKeyBoardValue
{
    SDK_NET_KEY_0, SDK_NET_KEY_1, SDK_NET_KEY_2, SDK_NET_KEY_3, SDK_NET_KEY_4, SDK_NET_KEY_5, SDK_NET_KEY_6, SDK_NET_KEY_7, SDK_NET_KEY_8, SDK_NET_KEY_9,
    SDK_NET_KEY_10, SDK_NET_KEY_11, SDK_NET_KEY_12, SDK_NET_KEY_13, SDK_NET_KEY_14, SDK_NET_KEY_15, SDK_NET_KEY_16, SDK_NET_KEY_10PLUS,SDK_NET_KEY_DIGIT,
    SDK_NET_KEY_UP = 20,     // 上或者云台向上
    SDK_NET_KEY_DOWN,        // 下或者云台向下
    SDK_NET_KEY_LEFT,        // 左或者云台向左
    SDK_NET_KEY_RIGHT,       // 右或者云台向右
    SDK_NET_KEY_SHIFT,
    SDK_NET_KEY_PGUP,        // 上一页
    SDK_NET_KEY_PGDN,        // 下一页
    SDK_NET_KEY_RET,         // 确认
    SDK_NET_KEY_ESC,         // 取消或退出
    SDK_NET_KEY_FUNC,        // 切换输入法
    SDK_NET_KEY_PLAY,        // 播放/暂停
    SDK_NET_KEY_BACK,        // 倒放
    SDK_NET_KEY_STOP,        // 停止
    SDK_NET_KEY_FAST,        // 快放
    SDK_NET_KEY_SLOW,        // 慢放
    SDK_NET_KEY_NEXT,        // 下一个文件
    SDK_NET_KEY_PREV,        // 上一个文件
	SDK_NET_KEY_PAUSE,		 // 暂停
	SDK_NET_KEY_FUNC_A,		 // 功能键A
	SDK_NET_KEY_FUNC_B,	     // 功能键B(在消费类产品上，A和B的功能会根据设备的不同而有不同的表现)
    SDK_NET_KEY_REC = 40,    // 录像设置
    SDK_NET_KEY_SEARCH,      // 录像查询
    SDK_NET_KEY_INFO,        // 系统信息
    SDK_NET_KEY_ALARM,       // 告警输出
    SDK_NET_KEY_ADDR,        // 遥控器地址设置
    SDK_NET_KEY_BACKUP,      // 备份
    SDK_NET_KEY_SPLIT,       // 画面分割模式切换，每按一次切换到下一个风格模式
    SDK_NET_KEY_SPLIT1,      // 单画面
    SDK_NET_KEY_SPLIT4,      // 四画面
    SDK_NET_KEY_SPLIT8,      // 八画面
    SDK_NET_KEY_SPLIT9,      // 九画面
    SDK_NET_KEY_SPLIT16,     // 16画面
    SDK_NET_KEY_SHUT,        // 关机
    SDK_NET_KEY_MENU,        // 菜单
    SDK_NET_KEY_SPLIT25,	// 25画面
    SDK_NET_KEY_SPLIT36,     // 36画面
    SDK_NET_KEY_PTZ = 60,    // 进入云台控制模式
    SDK_NET_KEY_TELE,        // 变倍减
    SDK_NET_KEY_WIDE,        // 变倍加
    SDK_NET_KEY_IRIS_SMALL,  // 光圈增
    SDK_NET_KEY_IRIS_LARGE,  // 光圈减
    SDK_NET_KEY_FOCUS_NEAR,  // 聚焦远
    SDK_NET_KEY_FOCUS_FAR,   // 聚焦近
    SDK_NET_KEY_BRUSH,       // 雨刷
    SDK_NET_KEY_LIGHT,       // 灯光
    SDK_NET_KEY_SPRESET,     // 设置预置点
    SDK_NET_KEY_GPRESET,     // 转至预置点
    SDK_NET_KEY_DPRESET,     // 清除预置点
    SDK_NET_KEY_PATTERN,     // 模式
    SDK_NET_KEY_AUTOSCAN,    // 自动扫描开始结束
    SDK_NET_KEY_AUTOTOUR,    // 自动巡航
    SDK_NET_KEY_AUTOPAN,     // 线扫开始/结束
};

/// 按键状态
enum SDK_NetKeyBoardState
{
    SDK_NET_KEYBOARD_KEYDOWN,	// 按键按下
    SDK_NET_KEYBOARD_KEYUP,		// 按键松开
};

typedef struct SDK_NetKeyBoardData
{
    int iValue; //枚举SDK_NetKeyBoardValue
    int iState; //枚举SDK_NetKeyBoardState
}SDK_NetKeyBoardData;

// 升级信息获取
typedef struct SDK_UpgradeInfo
{
    char szSerial[64];
    char szHardware[64];
    char szVendor[64];
    unsigned int uiLogoArea[2];
}SDK_UpgradeInfo;

/// 网络报警
typedef struct SDK_NetAlarmInfo
{
    int iEvent;  //目前未使用
    int iState;   //每bit表示一个通道,bit0:第一通道,0-无报警 1-有报警, 依次类推
}SDK_NetAlarmInfo;

typedef enum SERIAL_TYPE
{
    RS232 = 0,
    RS485 = 1,
}SERIAL_TYPE;


enum MEDIA_PACK_TYPE
{
    FILE_HEAD =	0,	    		// 文件头
    VIDEO_I_FRAME = 1,			// 视频I帧
    VIDEO_B_FRAME =	2,			// 视频B帧
    VIDEO_P_FRAME = 3,			// 视频P帧
    VIDEO_BP_FRAME = 4,			// 视频BP帧
    VIDEO_BBP_FRAME	= 5,		// 视频B帧B帧P帧
    VIDEO_J_FRAME = 6,			// 图片帧
    AUDIO_PACKET = 10,			// 音频包
};

typedef struct
{
    int		nPacketType;				// 包类型,见MEDIA_PACK_TYPE
    char*	pPacketBuffer;				// 缓存区地址
    unsigned int	dwPacketSize;				// 包的大小
    
    // 绝对时标
    int		nYear;						// 时标:年
    int		nMonth;						// 时标:月
    int		nDay;						// 时标:日
    int		nHour;						// 时标:时
    int		nMinute;					// 时标:分
    int		nSecond;					// 时标:秒
    unsigned int 	dwTimeStamp;					// 相对时标低位，单位为毫秒
    unsigned int	dwTimeStampHigh;        //相对时标高位，单位为毫秒
    unsigned int   dwFrameNum;             //帧序号
    unsigned int   dwFrameRate;            //帧率
    unsigned short uWidth;              //图像宽度
    unsigned short uHeight;             //图像高度
    unsigned int       Reserved[6];            //保留
} PACKET_INFO_EX;


typedef struct SDK_OEMInfo
{
    int nOEMID;                     //OEM ID
    char sCompanyName[NET_MAX_USERNAME_LENGTH]; //公司名
    char sTel[NET_MAX_USERNAME_LENGTH];         //电话
    char sAddr[NET_MAX_USERNAME_LENGTH];        //地址
}SDK_OEMInfo;
typedef struct __TransComChannel//透明窗口
{
    SERIAL_TYPE TransComType;//SERIAL_TYPE
    unsigned int baudrate;
    unsigned int databits;
    unsigned int stopbits;
    unsigned int parity;
} TransComChannel;
typedef enum SDK_State_Type
{
    DEV_STATE_DDNS=0,
}SDK_State_Type;

//摄象机参数.....

//曝光配置
typedef struct SDK_ExposureCfg
{
    int  level;    //曝光等级
    unsigned int leastTime;//自动曝光时间下限或手动曝光时间，单位微秒
    unsigned int mostTime; //自动曝光时间上限，单位微秒
}SDK_ExposureCfg;

//增益配置
typedef struct SDK_GainCfg
{
    int gain;    //自动增益上限(自动增益启用)或固定增益值
    int autoGain;//自动增益是否启用，0:不开启  1:开启
}SDK_GainCfg;

//网络摄像机配置
typedef struct SDK_CameraParam
{
    unsigned int whiteBalance;         //白平衡
    unsigned int dayNightColor;        //日夜模式，取值有彩色、自动切换和黑白
    int elecLevel;             //参考电平值
    unsigned int apertureMode;          //自动光圈模式
    unsigned int BLCMode;               //背光补偿模式
    SDK_ExposureCfg exposureConfig;//曝光配置
    SDK_GainCfg     gainConfig;    //增益配置
    
    unsigned int PictureFlip;		//图片上下翻转
    unsigned int PictureMirror;	//图片左右翻转(镜像)
    unsigned int RejectFlicker;	//日光灯防闪功能
    unsigned int EsShutter;		//电子慢快门功能
    
    int ircut_mode;		//IR-CUT切换 0 = 红外灯同步切换 1 = 自动切换
    
    int dnc_thr;			//日夜转换阈值
    int ae_sensitivity;	//ae灵敏度配置
    
    int Day_nfLevel;		//noise filter 等级，0-5,0不滤波，1-5 值越大滤波效果越明显
    int Night_nfLevel;
    int Ircut_swap;		//ircut 正常序= 0        反序= 1
}SDK_CameraParam;

//所有摄象机配置
typedef struct SDK_AllCameraParam
{
    SDK_CameraParam vCameraParamAll[NET_MAX_CHANNUM];   //所有的通道
}SDK_AllCameraParam;

//曝光能力级
typedef struct SDK_CameraAbility
{
    int  count;      //支持曝光速度数量
    unsigned int speeds[CAMERAPARA_MAXNUM]; //曝光速度
    int  status;     //工作状态  >= 0 正常    < 0 异常
    int  elecLevel;  //参考电平值
    int  luminance;  //平均亮度
    char pVersion[64];//xm 2a版本
    char reserve[32];//保留
}SDK_CameraAbility;

//本地播放控制
enum SDK_LoalPlayAction
{
    SDK_Local_PLAY_PAUSE,		/*<! 暂停播放 */
    SDK_Local_PLAY_CONTINUE,		/*<! 继续正常播放 */
    SDK_Local_PLAY_FAST,	        /*<! 加速播放 */
    SDK_Local_PLAY_SLOW,	        /*<! 减速播放 */
    
};

//短信配置
typedef struct SDK_NetShortMsgCfg
{
    bool bEnable;       //发送手机短信的功能是否启用
    char pDesPhoneNum[MAX_RECIVE_MSG_PHONE_COUNT][16];
    int  sendTimes;     //需要向每个手机发送多少次短信
}SDK_NetShortMsgCfg;
//手机彩信配置
typedef struct SDK_NetMultimediaMsgCfg
{
    bool bEnable;				// 发送手机彩信的功能是否启用
    char pDesPhoneNum[MAX_RECIVE_MSG_PHONE_COUNT][16]; //接收彩信的手机号，现支持3个手机号
    char pGateWayDomain[40];	// 网关地址，域名或IP
    int  gateWayPort;			// 网关端口
    char pMmscDomain[40];		// 彩信服务器地址，IP或域名
    int  mmscPort;				// 彩信服务器端口号
}SDK_NetMultimediaMsgCfg;

typedef struct SDK_DASSerInfo
{
    bool enable;
    char serAddr[NET_NAME_PASSWORD_LEN];
    int  port;
    char userName[NET_NAME_PASSWORD_LEN];
    char passwd[NET_NAME_PASSWORD_LEN];
    char devID[NET_NAME_PASSWORD_LEN];
}SDK_DASSerInfo;
typedef enum UploadDataType  //上传数据类型
{
    VEHICLE=0,//车载信息
    SDK_RECORD_STATE,//录像状态
    SDK_DIGITCHN_STATE,	//数字通道连接状态
    SDK_TITLE_INFO,		//通道标题
}UploadDataType;
//车载相关************************************************************************
//车辆状态
enum SDK_CAR_STATUS_TYPE
{
    SDK_CAR_WORKING,             //是否在运行
    SDK_CAR_LIGHT_LEFT_TURN,     //左转灯是否点亮
    SDK_CAR_LIGHT_RIGHT_TURN,    //右转灯是否点亮
    SDK_CAR_DOOR_LEFT_FRONT,     //左前门是否打开
    SDK_CAR_DOOR_RIGHT_FRONT,    //右前门是否打开
    SDK_CAR_DOOR_LEFT_BACK,      //左后门是否打开
    SDK_CAR_DOOR_RIGHT_BACK,     //右后门是否打开
    SDK_CAR_DOOR_BACK,           //后门是否打开
    SDK_CAR_BRAKE,               //是否踩刹车
    SDK_CAR_URGENCY_ALARM,       //紧急报警
    SDK_CAR_STATUS_NR, //状态种类数目
};

//外部输入类型
enum SDK_IO_INPUT_TYPE
{
    SDK_LOCAL_ALARM_INPUT,//本地报警输入
    SDK_RS232_INPUT,      //通过232串口输入
    SDK_RS485_INPUT,      //通过485串口输入
};

//外部信息输入与车辆状态的对应关系
typedef struct SDK_CarStatusExchange
{
    int  statusType; //哪一种车辆状态，比如左转灯
    bool bExist;     //是否有该种状态的信息输入，根据车辆的实际情况进行设置
    bool bEnable;    //是否检测该种状态
    int  inputType;  //该种状态对应的信息输入类型，从IO_INPUT_TYPE枚举的值中取
    int  addr;       //地址，比如是本地报警输入口一对应0，输入口二对应1
    int  sensorType; //常开(NO)或常闭(NC)，当inputType是本地报警输入时有效
}SDK_CarStatusExchange;

typedef struct SDK_CarStatusExchangeAll
{
    SDK_CarStatusExchange exchangeAll[16];
}SDK_CarStatusExchangeAll;

typedef struct SDK_CarStatusNum
{
    int iCarStatusNum;
}SDK_CarStatusNum;

typedef struct SDK_CarDelayTimeConfig
{
    bool bStartDelay;
    bool bCloseDelay;
    
    int timeStartDelay;		//单位:分钟
    int timeCloseDelay;		//单位:分钟
}SDK_CarDelayTimeConfig;
enum SDK_network_media {
    SDK_NM_WIRED = 0,  //有线网卡
    SDK_NM_WLAN,       //Wifi
    SDK_NM_3G,         //3G网卡
    SDK_NM_NR,    //种类数
};
//网络连接优先级
typedef struct SDK_tagNetLinkOrder
{
    int netType;  //取值是network_media类型的
    int netOrder; //数字越小，优先级越高,0是最高优先级
}SDK_NetLinkOrder;
//网络优先级
typedef struct SDK_NetOrderConfig
{
    bool         bEnable;        //是否设置网络优先级
    int          netCount;       //网络类型数目
    SDK_NetLinkOrder pNetOrder[SDK_NM_NR];//网络优先级
    SDK_NetLinkOrder pReserve[7-SDK_NM_NR];//给新的网络类型预留
}SDK_NetOrderConfig;
///网络优先级能力
typedef struct SDK_NetOrderFunction
{
    bool bNetOrder;
}SDK_NetOrderFunction;
#define  MAX_CAR_INFOR 24
/// 车载牌号
struct  SDK_CarPlates
{
    char sPlateName[MAX_CAR_INFOR];
};
enum NET_ISP
{
    ISP_AUTO, //自动选择
    ISP_TELCOM, //电信
    ISP_UNIONCOM, //联通
    ISP_CNC,//网通
    ISP_MOBILE,//移动，铁通
    ISP_USER,//自定义
};
//网络平台信息设置
typedef struct SDK_LocalSdkNetPlatformConfig
{
    int Enable;
    int nISP;                          ///参见NET_ISP
    char sServerName[32];
    char ID[32];
    char sUserName[32];
    char sPassword[32];
    CONFIG_IPAddress HostIP;		///< host ip
    int port;
}SDK_LOCALSDK_NET_PLATFORM_CONFIG;

//GPS校时配置
typedef struct SDK_GPSTimingConfig
{
    bool bEnable;      // 是否启用
    int  timeChange;   // 相对于UTC时间需要改变多少，单位:秒
    int  updatePeriod; // 更新周期  单位:分钟
}SDK_GPSTimingConfig;
//神眼接警中心系统
typedef struct	SDK_GodEyeConfig
{
    bool	bEnable;
    char MainSeverName[NET_NAME_PASSWORD_LEN]; //主域名
    int MainPort;	//主端口
    char ExSeverName[NET_NAME_PASSWORD_LEN]; //备用域名
    int ExPort;	//备用端口
}SDK_GodEyeConfig;
enum  SDK_DigManagerShowStatus
{
    SDK_DM_SHOW_NONE,
    SDK_DM_SHOW_ALL,
};


//数字通道显示状态
typedef struct SDK_DigitalManagerShow
{
    int  nDigitalManagerShowSta;
}SDK_DigitalManagerShow;

//NAT传输，MTU值
typedef struct SDK_NatConfig
{
    bool bEnable;
#if 0
    bool CloudpushEnable;
#endif
    int nMTU;             // 范围 (100,1400)
    char serverAddr[64];  //云服务的域名或者IP地址。
    int  serverPort;      //云服务的端口;
    CONFIG_IPAddress dnsSvr1;//云服务的DNS服务器地址
    CONFIG_IPAddress dnsSvr2;
#if 0
    char pResv[16];      //保留
#endif
}SDK_NatConfig;

typedef enum SubConnType
{
    conn_realTimePlay=1,
    conn_talk,
    conn_playback
}SubConnType;
//*** */向设备注册
enum SocketStyle
{
	TCPSOCKET=0,
	UDPSOCKET,	
	PLUGLANSOCKET=4,			//插座局域网登陆
	PLUGOUTERSOCKET,		//插座外网登陆
    SOCKETNR
};


enum SDK_NatStatusType
{
    SDK_NAT_STATUS_DISENABLE,//未开启
    SDK_NAT_STATUS_PROBING,  //正在探测DNS
    SDK_NAT_STATUS_CONNECTING,//正在连接服务器
    SDK_NAT_STATUS_CONNECTED,//连接成功
};
//nat状态信息
typedef struct SDK_NatStatusInfo
{
	int	iNatStatus;
	char NatInfoCode[256];//增加内容，加大
}SDK_NatStatusInfo;

/// 数字水印配置
typedef struct SDK_WaterMarkConfig
{
    bool	bEnable;		//  开启水印
    char  sKey[8];
    char sUserData[16];
}SDK_WaterMarkConfig;

typedef struct SDK_WaterMarkConfigAll
{
    SDK_WaterMarkConfig vWaterMarkConfigAll[NET_MAX_CHANNUM];
}SDK_WaterMarkConfigAll;

///编码器静态参数
typedef struct SDK_EncodeStaticParam
{
    int profile;
    int level;
    int reserved1[4];
}SDK_EncodeStaticParam;


typedef struct SDK_EncodeStaticParamAll
{
    SDK_EncodeStaticParam	EncodeStaticParamAll[NET_MAX_CHANNUM];
}SDK_EncodeStaticParamAll;

enum
{
    sdk_maxCPCDataItem = 2048,
    sdk_maxCPCDataReturn = 512,
    sdk_itemtotalLength = 96,	//2位通道号，20位开始时间，20位结束时间，和两个13位的数据,加冗余
    sdk_maxpack=4,// sdk_maxCPCDataItem/sdk_maxCPCDataReturn
};

typedef struct SDK_CPCDataItem		//人数统计项结构体
{
    int channel;			//对应的通道号
    SDK_SYSTEM_TIME startTime;	//开始时间
    SDK_SYSTEM_TIME endTime;	//结束时间
    int inNum;			//进入人数
    int outNum;			//离开人数
}SDK_CPCDataItem;

typedef struct SDK_CPCData
{
    int nItemNum;
    SDK_CPCDataItem CPCData[sdk_maxCPCDataReturn];
}SDK_CPCData;

typedef struct SDK_CPCDataAll
{
    int nCount;
    SDK_CPCData nCpcData[sdk_maxpack] ;
}SDK_CPCDataAll;

/// 录像存储设备类型，以下类型的一种或者多种
typedef struct SDK_RecordStorageType
{
    bool SATA_as;
    bool USB_as;
    bool SD_as;
    bool DVD_as;
}SDK_RecordStorageType;

//VPN结构体
typedef struct SDK_VPNConfig
{
    bool Enable;		///< 是否开启
    CONFIG_IPAddress ServiceIp;						///< 服务器IP地址
    char UserName[NET_NAME_PASSWORD_LEN];		///< 用户名
    char Password[NET_NAME_PASSWORD_LEN];		///< 密码
    CONFIG_IPAddress addr;		///< 拨号后获得的IP地址
    char ServerName[NET_NAME_PASSWORD_LEN];		///< openvpn服务器地址
    int port;
}SDK_VPNConfig;
//当前VGA分辨率
typedef struct SDK_VGAresolution
{
    int nHeight;
    int nWidth;
}SDK_VGAresolution;
//支持VGA分辨率列表
typedef struct SDK_VGAResolutionAbility
{
    int vVGANum;
    char vVGAList[VGA_MAXNUM][VGA_NAME_LENGTH];
}SDK_VGAResolutionAbility;

//设备列表(设备搜索的)
typedef struct SDK_NetDevList
{
    int vNetDevNum;
    SDK_CONFIG_NET_COMMON_V2 vNetDevList[DEV_LIST_SHOW];
}SDK_NetDevList;

//温州凯能平台
/***用户信息***/

typedef struct SDK_CONFIG_KAINENG_USERINFO
{
    char szUserName[16];           //用户姓名：5个汉字或十个字母;
    char szUserAddr[128];           //用户地址：30个汉字或60个字母;
    char szUserAttr[16];           //用户性质：5个汉字或十个字母；
    
    char szBelongUnit[64];         //归管单位：15个汉字或30个字母;
    char szBelongUnitPhone[16];    //归管单位电话：14位数字；分机用"-" 隔离符;
    
    char szPoliceUnit[64];         //出警单位：15个汉字或30个字母;
    char szPoliceUnitAddr[128];     //出警单位地址：30个汉字或60个字母;
    char szPoliceUnitPhone[16];    //出警单位电话：14位数字；分机用"-"隔离符;
    
    char szPolicePhone[4][16];
    char szPolOrCenPhone[2][16];   //警联/中心电话1、2：14位数字；分机用"-" 隔离符;
    
    char szFTP[64];                //FTP：50个字符；
    char szEMail[64];              //E-Mail: 50个字符；
    CONFIG_IPAddress PoliceIP;            //接警中心IP地址
    int nHttpPort;                 //接警中心IP端口
}SDK_CONFIG_KAINENG_USERINFO;

/***设备信息***/
//闲置布防类型枚举
typedef enum SDK_GuardType
{
    SDK_FORBID = 0,      //禁止
    SDK_TEN_MIN,         //十分钟
    SDK_THIRTY_MIN,      //三十分钟
    SDK_SIXTY_MIN,       //六十分钟
    SDK_MAX,
}SDK_GUARDTYEP;


typedef struct SDK_CONFIG_KAINENG_DEVINFO
{
    char ProbeNum1;                //条件布防：两个下拉框，每个下拉框从 1号到10号探测器选择 ；默认两个为 <1号探测器>
    char ProbeNum2;                //条件布防：两个下拉框，每个下拉框从 1号到10号探测器选择 ；默认两个为 <1号探测器>
    char nProbeType;			   //条件：下拉框 可选择3种为 <禁止>  <AND>  <OR>  默认为 <禁止>
    char nGuardType;               //闲置布防, 参照GUARDTYEP
    
    int AlarmTime;                //警笛开启时间：三位数字从000-999  默认为：180
    int nGuardArea;               //有线防区类型：八位数字，每位最小0最大3，即00000000 到33333333;  默认：00000000；
    
    char szRemConAddr[4][4];       //遥控器1-4号地址 ：八位16进制字符允许空（即0-9  A-F），默认为空；
    char szLinDevAddr[6][4];       //联运设备地1-6地址：八位16进制字符允许空（即0-9  A-F），默认为空；
    char szProbeAddr[10][4];       //探测器1-10号地址：八位16进制字符允许空（即0-9  A-F），默认为空；
    
    //定时布撤防
    char szGuardTime[3][9];        //定时布撤防,每组都为char [8] 类型 即00 00 00 00，表达由开始时分到结束时分，不需要年月日期
}SDK_CONFIG_KAINENG_DEVINFO;

/***联动设置***/
//联动动作枚举
typedef enum SDK_KNAlarmLink
{
    SDK_LINK_EMPTY = 0,
    SDK_LINK_SWITH,
    SDK_LINK_10S,
    SDK_LINK_30S,
    SDK_LINK_60S,
    SDK_LINK_200S,
    SDK_LINK_600S,
    SDK_LINK_METHOD_1,
    SDK_LINK_METHOD_2,
    SDK_LINK_MAX,
}SDK_KNALARMLINK;

typedef struct SDK_CONFIG_KAINENG_LINKINFO
{
    char eLink[10][7];        //联动设置,取值为联动动作枚举
}SDK_CONFIG_KAINENG_LINKINFO;

//凯能定制，3个界面信息全在这里。
typedef struct SDK_CONFIG_KAINENG_INFO
{
    SDK_CONFIG_KAINENG_USERINFO UserInfo;
    SDK_CONFIG_KAINENG_DEVINFO DevInfo;
    SDK_CONFIG_KAINENG_LINKINFO LinkInfo;
}SDK_CONFIG_KAINENG_INFO;

//搜索设备协议
typedef enum SDK_TransferProtocol_V2
{
    SDK_TRANSFER_PROTOCOL_NETIP,
    SDK_TRANSFER_PROTOCOL_ONVIF,
    SDK_TRANSFER_TRANSFER_PROTOCOL_MAC,
    SDK_TRANSFER_PROTOCOL_NR_V2=5,
    SDK_TRANSFER_PROTOCOL_ONVIF_DEFAULT = 128,
    SDK_TRANSFER_PROTOCOL_ONVIF_NR_V2
}SDK_TransferProtocol_V2;

typedef struct SDK_EncodeStaticParamV2
{
    int profile; //当前静态编码
    int reserved1[4]; //保留字段
}SDK_EncodeStaticParamV2;

/*
 ==	DVR静态编码能力集，现在3种
 ==	0 不支持 1 支持baseline 2 支持main profile 4 支持high profile
 ==  掩码操作
 */
typedef struct SDK_EncStaticParamAbility
{
    unsigned int encStaticParam;
}SDK_EncStaticParamAbility;

//安徽创世C7平台配置
typedef struct SDK_C7PlatformConfig
{
    char pServerAddr[64];//平台地址，IP地址或域名
    int  servPort;       //平台端口
    char pPUID[32];      //PUID
    char pPassword[32];  //密码
    char pStatus[64];    //接入状态，在LocalSDK中是可读可写的，其它地方是只读
    char pResv[60];      //保留
}SDK_C7PlatformConfig;

///网络键盘
typedef struct SDK_NetKeyboardConfig
{
    bool Enable;		///< 是否开启
    char sTransProtocol[4];	//传输协议
    int ListenPort;		//监听端口
    char sParserProtocol[32];
    int deviceaddr;	//设备地址
}SDK_NetKeyboardConfig;
////// 网络键盘协议
typedef struct SDK_NetKeyboardAbility
{
    //每个协议最多由64个字符组成
    int nTransPNum;
    char vTransProtocol[32][NET_MAX_PTZ_PROTOCOL_LENGTH];
    int nParserNum;
    char vParserProtocol[32][NET_MAX_PTZ_PROTOCOL_LENGTH];
}SDK_NetKeyboardAbility;

//28181协议配置
typedef struct SDK_ASB_NET_VSP_CONFIG
{
    bool		bCsEnable;				//使能标记
    char		szCsIP[64];				//服务器地址
    short	sCsPort;					//服务器端口
    short	sUdpPort;				//本地绑定udp端口
    char		szServerNo[64];			//服务器序列号
    char 	szServerDn[64];			//服务器所在的域名称
    char		szDeviceNO[64];			//设备序列号
    char 	szConnPass[64];			//设备接入密码
    int		iHsIntervalTime;			//心跳间隔时间,单位是秒
    int		iRsAgedTime;			//重新发送注册时间间隔，单位为秒
    char		Camreaid[NET_MAX_CHANNUM][64];	//设备中摄像头ID
    int		CamreaLevel[NET_MAX_CHANNUM];	//报警等级
    char		Alarmid[NET_MAX_CHANNUM][64];	//设备中摄像头ID
    int		AlarmLevel[NET_MAX_CHANNUM];	//报警等级
    unsigned int		uiAlarmStateGpinEnable;	//外部报警使能
    unsigned int		uiAlarmStateLoseEnable;	//视频丢失告警使能
    unsigned int		uiAlarmStateMotionEnable;//视频动态侦测告警使能
    unsigned int		uiAlarmStateBlindEnable;	//屏幕遮挡告警使能
    unsigned int		uiAlarmStatePerformanceEnable;	//系统异常告警使能
    unsigned int		uiAlarmStateConnectEnable;	//用户连接告警使能
}SDK_ASB_NET_VSP_CONFIG;

//手机服务配置
typedef struct SDK_PMSConfig
{
    bool Enable;		///< 是否开启
    char servname[64];
    int port;
    char boxid[128];
    char resume[24]; //保留
}SDK_PMSConfig;

//屏幕提示信息
typedef struct  SDK_OSDInfoConfig
{
    SDK_VIDEO_WIDGET OSDInfoWidget;
    char ppInfo[NET_MAX_LINE_PER_OSD_AREA][NET_CHANNEL_NAME_MAX_LEN];
}SDK_OSDInfoConfig ;

enum SDK_wordEncType
{
    SDK_wordEnc_GB2312,
    SDK_wordEnc_Unicode,
    SDK_wordEnc_UTF8,
    SDK_wordEnc_NR,
};

//所有通道的屏幕提示信息
typedef struct  SDK_OSDInfoConfigAll
{
    SDK_OSDInfoConfig   vOSDInfoAll[NET_MAX_CHANNUM];
    int strEnc;//编码格式,默认为UTF-8,不做任何处理；主要用于客户特殊需求，枚举参见wordEncType
}SDK_OSDInfoConfigAll;
//
typedef struct SDK_KaiCongAlarmConfig
{
    bool Enable;		///< 是否开启
    char ServerName[NET_NAME_PASSWORD_LEN];	///< 服务名
    int Port;							///< 端口号
    char UserName[NET_NAME_PASSWORD_LEN];		///< 用户名
    char Password[NET_NAME_PASSWORD_LEN];		///< 密码
}SDK_KaiCongAlarmConfig;
//
typedef struct SDK_VideoChannelManage
{
    int		nHVRCap;
    int		curMode;
    bool bhide[MAX_HVR_CHNCAP_CHN];
    SDK_CAPTURE_HVRCAPV2	HVRCap[MAX_HVR_CHNCAP_CHN];
}SDK_VideoChannelManage ;

//PTZ控制能力集
typedef struct SDK_PTZControlAbility
{
    unsigned int nPTZPosition;
}SDK_PTZControlAbility;

typedef struct SDK_PositionPoint
{
    int iPointStart_x;
    int iPointStart_y;
    int iPointEnd_x;
    int iPointEnd_y;
}SDK_PositionPoint;

typedef struct SDK_XMHeartbeatConfig
{
    bool bEnable;							///< 是否开启
    int iInterval;							///< 保活间隔时间
    char ServerName[NET_NAME_PASSWORD_LEN];	///< 服务名
    int Port;								///< 端口号
    char UserName[NET_NAME_PASSWORD_LEN];		///< 用户名
    char Password[NET_NAME_PASSWORD_LEN];		///< 密码
    char resume[24];
}SDK_XMHeartbeatConfig;

typedef struct SDK_MonitorPlatformConfig
{
    int Enable;		///< 是否开启
    char servname[NET_NAME_PASSWORD_LEN];
    int port;
    char resume[24];
    char agentid[128];	//客户端id，深广平台使用(以SSJC开头)
    char type[128];		//
}SDK_MonitorPlatformConfig;
enum SDK_IMG_TYPE
{
    SDK_IMG_TYPE_DEFAULT,
    SDK_IMG_TYPE_1,
    SDK_IMG_TYPE_2,
    SDK_IMG_TYPE_NR,
};
//网络摄像头扩展参数
typedef struct SDK_CameraParamEx
{
    SDK_GainCfg broadTrends;	//宽动态
    int style;	//enum SDK_IMG_TYPE
    unsigned int exposureTime;//实际生效的曝光时间
    int res[62];	//冗余
}SDK_CameraParamEx;

// 摄像头所有扩展参数
typedef struct SDK_CameraParamExAll
{
    SDK_CameraParamEx vCameraParamExAll[NET_MAX_CHANNUM];
}SDK_CameraParamExAll;

//网络服务定制平台通用配置，以后定制都用这个
typedef struct SDK_NetPlatformCommonCfg
{
    int	Enable;
    int Port;									///< 端口号
    char ServerName[NET_NAME_PASSWORD_LEN];		///< 服务名
    char ID[NET_NAME_PASSWORD_LEN];
    char UserName[NET_NAME_PASSWORD_LEN];		///< 用户名
    char Password[NET_NAME_PASSWORD_LEN];		///< 密码
    char resume[128];		///预留
}SDK_NetPlatformCommonCfg;

enum SDK_INFO_NET_LINK_STATUS
{
    SDK_INFO_NET_LINK_OK         = 0,
    SDK_INFO_NET_LINK_FAILED     = 1,
    SDK_INFO_NET_LINK_NO_DEVICE  = 2,
    SDK_INFO_NET_LINK_INVALID    = 9,
};
enum SDK_POSITIONING_DIRECTION
{
    SDK_POS_DIRECTION_EAST  = 'E',
    SDK_POS_DIRECTION_WEST  = 'W',
    SDK_POS_DIRECTION_SOUTH = 'S',
    SDK_POS_DIRECTION_NORTH = 'N'
};
typedef struct SDK_POSITIONING_POS//经纬度
{
    int  degree;     //以(度/1000)为单位
    char direction;  //方位 取值如枚举值POSITIONING_DIRECTION所示
    char res[3];
}SDK_POSITIONING_POS;
//GPS状态
typedef struct SDK_GPSStatusInfo
{
    int             positioningStatus; //定位状态，取值如枚举SDK_INFO_NET_LINK_STATUS所述
    SDK_POSITIONING_POS longitudePos;      //经度
    SDK_POSITIONING_POS latitudePos;       //纬度
    char            rev[12];
}SDK_GPSStatusInfo;

//wifi状态
typedef struct SDK_WifiStatusInfo
{
    int  connectStatus;  //wifi连接状态  如枚举SDK_INFO_NET_LINK_STATUS所述
    int  strength;       //信号强度
    char rev[24];
}SDK_WifiStatusInfo;

//3G状态
typedef struct SDK_WirelessStatusInfo
{
    int  connectStatus;  //3G连接状态  如枚举SDK_INFO_NET_LINK_STATUS所述
    int  strength;       //信号强度
    char rev[24];
}SDK_WirelessStatusInfo;

//主动注册状态
typedef struct SDK_DASStatusInfo
{
    int  connectStatus;  //DAS连接状态  如枚举SDK_INFO_NET_LINK_STATUS所述
    char rev[28];
}SDK_DASStatusInfo;

typedef struct SDK_RecordStorageInfo
{
    unsigned int bStart;//是否录像标志位
    SDK_SYSTEM_TIME beginTime;//录像开始时间
    SDK_SYSTEM_TIME endTime;//录像结束时间
    unsigned int  storageCapacity;//硬盘总容量
    unsigned int  useCapacity;//使用容量
    int res[16];//冗余
}SDK_RecordStorageInfo;
/// 解码延时等级
enum SDK_DecodeDeleyTypes
{
    SDK_DecodeDeley_0 = 0,
    SDK_DecodeDeley_1,
    SDK_DecodeDeley_2,
    SDK_DecodeDeley_3,
    SDK_DecodeDeley_4,
    SDK_DecodeDeley_5,
    SDK_DecodeDeley_6,
    SDK_DecodeDeley_TYPE_NR,
};

typedef struct SDK_DecodeDeleyTimePrame
{
    unsigned int  DecodeDeleyTime[SDK_DecodeDeley_TYPE_NR];
}SDK_DecodeDeleyTimePrame;

// 数字通道
typedef struct SDK_DecodeParam
{
    int iMaxDeleyTime[NET_MAX_CHANNUM];	// 最大的解码延时
}SDK_DecodeParam;

typedef struct SDK_RecordStateInfo
{
    int nchannel;
    int RecordState;
}SDK_RecordStateInfo;

//定制视频颜色结构
typedef struct SDK_VIDEOCOLOR_PARAM_EX
{
    int		BrightnessRef;		///< 亮度ref1，取值0-100。
    int		ContrastRef;		///< 对比度ref1，取值0-100。
    int  		ContrastThRef;		///< 对比度阀值ref1，取值0-100。
    int		ContrastSlopeRef;		///< 对比度斜率ref1，取值0-100。
    int 		DarkBlfRef;
    int		DarkNfRef;
    int		DarkEcPthRef;
    int		DarkEcMthRef;
    int		DarkDcRef;
    int		CbGain;	//high low middle
    int		CrGain;	//higg low middle
    int		reserved;	//保留
}SDK_VIDEOCOLOR_PARAM_EX;

typedef struct SDK_VIDEOCOLOR_PARAM_CUSTOM
{
    SDK_VIDEOCOLOR_PARAM_EX	VideoColor[3];
    int		Saturation;		///< 饱和度，取值0-100。
    int		Gain;			///< 增益，取值0-100。bit7置位表示自动增益，其他位被忽略。
    int		Acutance;		///< 锐度，取值0-100
    int		AeWight;		//背光补偿
}SDK_VIDEOCOLOR_PARAM_CUSTOM;

enum SDK_FileControlType
{
    SDK_FILE_DEL,			//删除文件
    SDK_FILE_DIR_DEL,		//删除文件夹
    SDK_FILE_DIR_CLEAR,		//清空文件夹
    SDK_FILE_NR,
};

typedef struct SDK_NetFileControl
{
    int iAction;			//enum FileControlType
    char strfile[256];
}SDK_NetFileControl;

enum SDK_DecChnStateType
{
    SDK_DEC_STA_NONE, 			//无用
    SDK_DEC_STA_NOCONFIG,		//未配置
    SDK_DEC_STA_NOLOGIN,		//未登陆
    SDK_DEC_STA_NOCONNECT,	//未连接
    SDK_DEC_STA_CONNECTED,	//已连接
    SDK_DEC_STA_LOGIN_FAILED,	//登录失败
};

typedef struct SDK_DigitStateInfo
{
    int nchannel;
    int DigitState; //SDK_DecChnStateType
}SDK_DigitStateInfo;

typedef struct SDK_TitleNameInfo
{
    int nchannel;
    char titleName[256];
}SDK_TitleNameInfo;
/*
	==SDK_TransferProtocol_V2
	==第一位代表SDK_TRANSFER_PROTOCOL_ONVIF_DEFAULT = 128，以此内推
 */
typedef struct SDK_AbilityMask
{
    unsigned int AbilityPram;
}SDK_AbilityMask;

enum SDK_Music_Play_Action
{
    SDK_MUSIC_ACTION_PLAY,
    SDK_MUSIC_ACTION_STOP,
    SDK_MUSIC_ACTION_PAUSE,
    SDK_MUSIC_ACTION_CONTINUE
};

typedef struct SDK_LocalMusicControl
{
    int iAction;            //参考SDK_Music_Play_Action
    char sFileName[20];
}SDK_LocalMusicControl;

/// 音频文件列表信息
typedef struct SDK_MusicFileList
{
    int iNumFiles;		///< 文件数量
    char sFileName[8][20];
}SDK_MusicFileList;

enum SDK_CAR_BOOT_TYPE
{
    SDK_CAR_BOOT_TYPE_SPARK,  //点火熄火开关机
    SDK_CAR_BOOT_TYPE_TIMING, //定时开关机
    SDK_CAR_BOOT_TYPE_NR,
};


//点火开关机延时配置
typedef struct SDK_CarSparkWork
{
    int bootDelayMinute;  //开机延时分钟数
    int shutDelayMinute;  //关机延时分钟数
    char resv[24];        //保留
}SDK_CarSparkWork;

//车载定时开关机配置
typedef struct SDK_CarTimingWork
{
    SDK_TIMESECTION workSection1; //工作时间段1
    SDK_TIMESECTION workSection2; //工作时间段2
    char resv[32]; //保留
}SDK_CarTimingWork;

typedef struct SDK_CarBootTypeConfig
{
    int           bootType;         //如枚举 SDK_CAR_BOOT_TYPE 所述
    SDK_CarSparkWork  sparkWorkConfig;  //点火开关机配置
    SDK_CarTimingWork timingWorkConfig; //定时开关机时间段1
    char          resv[48];
}SDK_CarBootTypeConfig;

//单个IPC
typedef struct SDK_ALARM_IPCCONFIG
{
    bool	bEnable;		///< 报警输入开关
    int		iSensorType;	///< 传感器类型常开 or 常闭
    SDK_EventHandler hEvent;	///< 报警联动
}SDK_ALARM_IPCCONFIG;
///< 所有数字通道的报警配置
typedef struct SDK_IPCAlarmConfigAll
{
    SDK_ALARM_IPCCONFIG vAlarmConfigAll[NET_DECORDR_CH];
}SDK_IPCAlarmConfigAll;

//百度云
typedef struct SDK_BaiduCloudCfg
{
    bool	enable;
    char APIKey[NET_NAME_TOKEN_LEN];				//应用API密钥
    char SecretKey[NET_NAME_TOKEN_LEN];			//应用密钥
    char AuthorizationCode[NET_NAME_TOKEN_LEN];	//授权码
    char accessToken[NET_NAME_TOKEN_LEN];		//访问权限码
    char refreshToken[NET_NAME_TOKEN_LEN];		//刷新权限码
    char deviceID[NET_NAME_TOKEN_LEN];			//设备ID
    char userCode[NET_NAME_TOKEN_LEN];			//用户授权码
    char qrcodeUrl[NET_NAME_TOKEN_LEN];			//二维码
    char streamID[NET_NAME_TOKEN_LEN];			//流ID
    char describe[NET_NAME_TOKEN_LEN];			//设备名称
    int state;								//状态
    SDK_SYSTEM_TIME	refreshTime;					//上次刷新Token时间
    int channelMain[NET_MAX_CHANNUM];				//是否开启标记
    int channelExtra[NET_MAX_CHANNUM];				//是否开启标记
    int	recordFileMode;						//配置录像模式
    int	recordFileSize;						//录像文件大小
    int	recordFileTime;						//录像最长时间
    char resume[128];							///预留
}SDK_BaiduCloudCfg;

//手机订阅数
typedef struct SDK_PhoneInfoNum
{
    int nNum;
}SDK_PhoneInfoNum;

typedef struct SDK_LOGIN_CFG//修改前端ip登录用
{
    char sUserName[NET_MAX_USER_LENGTH];		///< 登陆名字
    char sPassword[NET_MAX_USER_LENGTH];		///< 登陆密码
    int iEncryptType;			///< 密码加密方式 固定值 1
}SDK_LOGIN_CFG;

typedef struct
{
    int ch;
    int devtype;
    SDK_CONFIG_NET_COMMON netcfg;
    SDK_LOGIN_CFG loginPram;
}SDK_IPSetCfg;

//二维
typedef struct SDK_DimenCode
{
    int size;
    unsigned char code[3920];// 177*177/32*4=3920，局部变量
}SDK_DimenCode;

typedef struct SDK_DimenCodeAll
{
    SDK_DimenCode sn;
    SDK_DimenCode appIOS;
    SDK_DimenCode appAndroid;
    SDK_DimenCode otherInfo;  //客户自定义信息
}SDK_DimenCodeAll;

//中国电信手机看店平台
typedef struct SDK_MobileWatchCfg
{
    int	Enable;
    char DevID[NET_NAME_ID_LEN];				// 设备编码
    char DevKey[NET_NAME_ID_LEN];			// 设备验证码
    char ManufacturerNo[NET_NAME_ID_LEN];	// 厂商编号
    char Mode[NET_NAME_ID_LEN];				// 设备型号
    char GroupAddr[NET_NAME_URL_LEN];		// 集团平台地址
    char ProvinceAddr[NET_NAME_URL_LEN];		// 省平台地址
    char NatIP[NET_NAME_ID_LEN];				// 设备主服务器接入地址
    int	NatPort;							// 设备主服务器接入端口
    char BackupNatIP[NET_NAME_ID_LEN];		// 设备备用服务器接入地址
    int	BackupNatPort;					// 设备备用服务器接入端口
    
    char TurnIP[NET_NAME_ID_LEN];				// TurnServer服务器地址
    int	TurnPort;						// TurnServer服务器端口
    char BackupTurnIP[NET_NAME_ID_LEN];		// TurnServer备份服务器地址
    int	BackupTurnPort;					// TurnServer备份服务器端口
    char FtpIP[NET_NAME_ID_LEN];				// 图片上传FTP服务器地址
    int	FtpPort;							// 图片上传FTP服务器端口
    char FtpAccount[NET_NAME_ID_LEN];			// 图片上传FTP服务器帐号
    char FtpPassword[NET_NAME_ID_LEN];		// 图片上传FTP服务器密码
    char resume[NET_NAME_URL_LEN];			// 预留
}SDK_MobileWatchCfg;

typedef struct SDK_BrowserLanguageType
{
    int type;
}SDK_BrowserLanguageType;

typedef struct SDK_TimeZone
{
    int minuteswest; //跟UTC时间的差值，单位分钟，可以为负
    int FistFlag;		//用于保证第一次使用的时候时间不变
}SDK_TimeZone;


enum SDK_TimeSynTypes
{
    SDK_TST_OFF = 0,
    SDK_TST_TIME_UTC,
    SDK_TST_TIME_LOCAL,
    SDK_TST_TIME_ALL,
    SDK_TST_NR,
};

// 数字通道时间同步
typedef struct SDK_TimeSynParam
{
    int iTimeModel[NET_MAX_CHANNUM]; //参考SDK_TimeSynTypes
}SDK_TimeSynParam;

typedef struct SDK_CustomizeOEMInfo
{
    unsigned int typeMask;//类型: BITMSK(BURN_OEM_ID),BITMSK(BURN_OEM_PRODUCT),BITMSK(BURN_OEM_SERIAL)
    unsigned int oemID;
    unsigned int oemProduct;
    unsigned int oemSerial;
}SDK_CustomizeOEMInfo;

typedef struct SDK_DigitDevInfo
{
    bool enable; //配置是否可用，本地设备使用
    int nCapture;//模拟通道数
    int nAudio;//音频通道数
    int videoFormat;//视频制式
    CONFIG_EncodeAbility ability;//编码能力
}SDK_DigitDevInfo;

typedef struct SDK_EncodeChDisplay
{
    unsigned int displayChanelMask;	//IE显示的编码配置通道号掩码
}SDK_EncodeChDisplay;

//点间巡航
typedef struct SDK_TourState
{
    bool bRunning;
    int  lineID;   //点间巡航线路编号
}SDK_TourState;

//巡迹
typedef struct SDK_PatternState
{
    bool bRunning;
    int  lineID;  //巡迹线路编号 (未使用)
}SDK_PatternState;

//线扫
typedef struct SDK_ScanState
{
    bool bRunning;
    int  lineID;  //线扫线路编号 (未使用)
}SDK_ScanState;

//水平旋转
typedef struct SDK_PanonState
{
    bool bRunning;
    int  lineID;  //水平旋转线路编号 (未使用)
}SDK_PanonState;

//开机转到指定预置点
typedef struct SDK_PresetState
{
    bool bEnable;
    int  iPresetID;
}SDK_PresetState;

//断电前位置
typedef struct SDK_PoweroffState
{
    bool bEnable;
    int  iPresetID;
}SDK_PoweroffState;

//一个通道的云台操作状态
typedef struct SDK_PtzState
{
    SDK_TourState    tourState;
    SDK_PatternState patternState;
    SDK_ScanState    scanState;
    SDK_PanonState   panonState;
    SDK_PresetState  presetState;
    SDK_PoweroffState poweroffState;
}SDK_PtzState;

//重启后恢复之前的云台操作状态
typedef struct SDK_ResumePtzState
{
    bool     bEnable;                    //是否启用设备重启后恢复云台状态功能
    SDK_PtzState ptzStateAll[NET_MAX_CHANNUM];
}SDK_ResumePtzState;

typedef struct SDK_AHDEncodeLMask
{
    unsigned int AHDLMask;
}SDK_AHDEncodeLMask;

/// 速度报警类型
enum SDK_SpeedAlarmTypes
{
    SDK_SPEED_ALARM_HIGH,		// 高速报警
    SDK_SPEED_ALARM_LOW,		// 低速报警
    SDK_SPEED_ALARM_NR
};

///< 速度报警配置
typedef struct SDK_SpeedAlarmConfig
{
    bool	bEnable;		///< 速度报警开启
    int		iSpeed;			///< 速度
    SDK_EventHandler hEvent;	///< 速度报警联动参数
}SDK_SpeedAlarmConfig;

/// 全部类型的速度报警配置
typedef struct SDK_SpeedAlarmConfigAll
{
    SDK_SpeedAlarmConfig vSpeedAlarmAll[SDK_SPEED_ALARM_NR];
}SDK_SpeedAlarmConfigAll;

typedef struct SDK_CorrespondentOwnInfo
{
    char brand[64];
    char pModel[32];
    char pFirmwareVersion[32];
    char pHardwareId[32];
    int port;
}SDK_CorrespondentOwnInfo;

typedef struct SDK_OSDInfo
{
    int index;//设置通道标题和时间标题之外的区域，取值0和1
    int nX;//范围0-1000
    int nY;//范围0-1000
    int nChannel;//要设置的通道
    char pOSDStr[128];//要叠加的字符串
}SDK_OSDInfo;

typedef struct SDK_AppDownloadLink
{
    bool IOSEnable;    //是否显示iphone客户端二维码
    bool AndroidEnable;//是否显示安卓客户端二维码
    bool SNEnable;     //是否显示序列号对应的二维码
    bool OtherEnable;  //是否显示客户自定义二维码
    char inkIOS[128];
    char linkAndroid[128];
    char nameOther[128];  //客户自定义二维码名称
    char linkOther[128];  //客户自定义二维码
}SDK_AppDownloadLink;

typedef struct SDK_UserMap
{
    int size;
    USER_INFO UserCfg[64];
}SDK_UserMap;

//上传串口数据到指定服务器
typedef struct SDK_NetTransCommData
{
    bool bEnable;		///< 是否开启
    int SerialType;  //串口类型，0表示RS232，1表示RS485
    int ServerType;	///协议类型名称,0表示TCP，1表示UDP
    char ServerAddr[NET_NAME_PASSWORD_LEN];  //域名或者IP地址。
    int  ServerPort;	//端口;
	int  ReportTime;	//状态消息发送间隔时间，单位分钟
}SDK_NetTransCommData;

typedef struct SDK_PhoneInfo
{
    char command[NET_NAME_PASSWORD_LEN];
    char type[12];
    char asid[128];
    char username[NET_NAME_PASSWORD_LEN];
    char password[NET_NAME_PASSWORD_LEN];
    char acme[NET_NAME_PASSWORD_LEN];
    char resume[24];
}SDK_PhoneInfo;

enum
{
    SDK_MAX_VERSION_NUM = 20,
};

typedef struct SDK_CloudUpgradeVersion
{
    char name[128];// 版本名
    char date[12];//版本日期，格式:"2014-08-26"
    unsigned int length;	// 升级文件长度
}SDK_CloudUpgradeVersion;

typedef struct SDK_CloudUpgradeList
{
    int num;
    SDK_CloudUpgradeVersion versions[SDK_MAX_VERSION_NUM];
}SDK_CloudUpgradeList;

//启动客户demo
typedef struct SDK_NetUseProgram
{
    bool bEnable;   //是否开启
    char UserName[NET_NAME_PASSWORD_LEN];		///< 用户名
    char Password[NET_NAME_PASSWORD_LEN];		///< 密码
    int Port;	///< 端口号
    char ServerAddr[NET_NAME_PASSWORD_LEN];  //域名或者IP地址。
    char Describe[NET_MAX_RIGTH_NUM];			//设备名称
}SDK_NetUseProgram;

typedef struct I_VERSION_INFO_T
{
    char name[128];// 版本名
    char date[12];//版本日期，格式:"2014-08-26"
    unsigned int length;	// 升级文件长度
}I_VERSION_INFO_T;


//wifi模式相关配置，用于行车记录仪自动切换AP模式
typedef struct SDK_NetWifiMode
{
    int autoSwitchAPMode; //取值  1:自动切换成AP模式(家用模式)  0:不自动切换
    int reserve[7];
}SDK_NetWifiMode;

//消费类产品的录像灯的状态
typedef struct SDK_FbExtraStateCtrl
{
    int ison;
}SDK_FbExtraStateCtrl;

typedef struct SDK_AutoSwitch
{
    int  nStartTime;
    int  nStopTime;
    int  nStartDay;
    int  nStopDay;
    bool bEnable;
}SDK_AutoSwitch;

typedef struct SDK_AutoSwitchAll
{
    SDK_AutoSwitch Aswitch[10];
}SDK_AutoSwitchAll;



typedef struct SDK_PowerSocketSet
{
    int nSwitch;
    int nLight;
}SDK_PowerSocketSet;

typedef struct SDK_ClientInfo
{
    char Description[NET_NAME_PASSWORD_LEN];
    char Uuid[NET_NAME_PASSWORD_LEN];
    char Phone[NET_NAME_PASSWORD_LEN];
    char LoginTime[NET_NAME_PASSWORD_LEN];
    char Number[NET_NAME_PASSWORD_LEN];
    int  Permission;
    bool DeleThisClient;
    
}SDK_ClientInfo;

typedef struct SDK_ClientInfoAll
{
    SDK_ClientInfo info[10];
}SDK_ClientInfoAll;



typedef struct SDK_Authority
{
    int Level;
	int Ability;
}SDK_Authority;

typedef struct SDK_Arm
{
    int Guard;
}SDK_Arm;

typedef struct SDK_AlarmInfo_V2
{
    char Descrip[64];
    char SerialID[64];
    char Type[32];
    char iEvent[20];
    char iStatus[20];
    SDK_SYSTEM_TIME SysTime;
}SDK_AlarmInfo_V2;

/// 用户登陆方式
enum SDK_LoginType
{
    H264_DVR_LOGIN_TYPE_WEB,		///< WEB登陆(默认)
    H264_DVR_LOGIN_TYPE_LOCALUPGRADE,	///< 升级工具(局域网升级)登陆
    H264_DVR_LOGIN_TYPE_CLOUDUPGRADE,	///< 云升级登陆
    H264_DVR_LOGIN_TYPE_PCCLIENT,	///< PC客户端登陆
    H264_DVR_LOGIN_TYPE_MOBILE,		///< 移动终端（IPhone）登陆
    H264_DVR_LOGIN_TYPE_NR,			///< 登陆类型
};

typedef struct SDK_Xpms_Search_AlarmInfo_Req
{
    char Uuid[100];
    char authCode[100];
    SDK_SYSTEM_TIME StarTime;	//报警信息查询起始时间
    SDK_SYSTEM_TIME EndTime;	//报警信息查询结束时间，全0表示当前时间
    int Channel;			//Channel < 0 表示全部查询，通道号是从0开始的
    int AlarmType;		//报警类型(暂时无用)
    int Number;			//请求要查的报警条数 ，Number <= 0 表示查全部
    int Index;				//需要从查询的结果中哪一条开始取
    char Res[32];
}SDK_XPMS_SEARCH_ALARMINFO_REQ;


typedef struct SDK_Xpms_Search_AlarmPic_Req
{
    char Uuid[100];
    char authCode[100];
#ifdef WIN32
    __int64 ID;
#else
    long long ID;		//报警信息ID号
#endif
    char Res[32];
}SDK_XPMS_SEARCH_ALARMPIC_REQ;

// 北京鸿泰恒平台
typedef struct SDK_CONFIG_NET_BJHONGTAIHENG
{
    bool bEnable;
    char ServerUrl[64]; //服务器地址
    char DevID[16];     //设备id
    char Password[16];  //设备验证码
    char DevModel[16];     //设备型号
    char SerialNo[20]; //设备序列号
}SDK_CONFIG_NET_BJHONGTAIHENG;

typedef enum
{
    SDK_LocalAlarm = (int)0x00001,
    SDK_MotionDetect = (int)0x00002,
}SDK_AlarmRecType;

//云存储配置相关结构体
typedef struct SDK_CloudRecordConfig
{
    int EnableMsk;			//0全不存，1是定时存，2报警存，3定时&& 报警
    int StreamType;			//码流类型
    int AlarmRecTypeMsk;	//需要上传录像的报警类型，AlarmRecType类型掩码
    SDK_CONFIG_WORKSHEET wcWorkSheet;	//普通录像需存储的时间段
}SDK_CloudRecordConfig;

typedef struct SDK_CloudRecordConfigAll
{
    SDK_CloudRecordConfig vRecordConfigAll[NET_MAX_CHANNUM];
}SDK_CloudRecordConfigAll;

// 空闲动作
typedef struct SDK_PtzIdleState
{
    bool bEnable;					// 空闲动作使能位
    int iTime;						// 空闲时间 单位: 秒
    int iIdleState;		// 空闲动作类型
    int iId;				// 相应空闲动作类型的动作编号
}SDK_PtzIdleState;
typedef struct SDK_PtzIdleStateAll
{
    SDK_PtzIdleState pPtzIdleStateAll[NET_MAX_CHANNUM];
}SDK_PtzIdleStateAll;

typedef struct SDK_CameraClearFog
{
    bool enable; //0 打开，1 不打开
    int  level ; // 强度等级[0,100]
    char rev[4];
}SDK_CameraClearFog;
typedef struct SDK_CameraClearFogAll
{
    SDK_CameraClearFog vCameraClearFogAll[NET_MAX_CHANNUM];
}SDK_CameraClearFogAll;
//机器人马达控制
typedef struct SDK_CameraMotorCtrl
{
	bool UDDireOverturn;   //上下方向翻转
	bool LRDireOverturn;   //左右方向翻转
	bool UDRestOverturn;   //上下限位翻转
	bool LRRestOverturn;   //左右限位翻转
	int  rev[8];
}SDK_CameraMotorCtrl;

typedef struct SDK_EncodeAddBeep
{
	int Enable;       //置1 视频编码每隔30秒beep声，置0没有此功能 
	char res[4];
}SDK_EncodeAddBeep;

typedef struct SDK_DataLinkConfig
{
	int DoProgramEnable;
	int NIP2Enable;
}SDK_DataLinkConfig;
//安装位置
typedef enum{
	SDK_FISHEYE_APP_CEIL = 0, //天花板
	SDK_FISHEYE_APP_TABL = 1, //桌上
	SDK_FISHEYE_APP_WALL = 2, //墙上
}SDK_FISHEYE_APP_TYPE_E;

//鱼眼模式
typedef enum{
	SDK_FISHEYE_SECENE_ORIG	= 0,
	SDK_FISHEYE_SECENE_R = 1,
	SDK_FISHEYE_SECENE_P180_ALL = 2,
	SDK_FISHEYE_SECENE_P180_ONE = 3,
	SDK_FISHEYE_SECENE_P180_TWO = 4,
	SDK_FISHEYE_SECENE_P360_FULL = 5,
	SDK_FISHEYE_SECENE_P360_SEPE = 6,
	SDK_FISHEYE_SECENE_P360_HALF = 7,
	SDK_FISHEYE_SECENE_ROP_R = 8,
	SDK_FISHEYE_SECENE_RORR_R = 9,
	SDK_FISHEYE_SECENE_RRRR_R = 10,
	SDK_FISHEYE_SECENE_RRP_R = 11
}SDK_FISHEYE_SECENE_E;


typedef struct SDK_FishEyeParam
{
	int appType;	//如枚举FISHEYE_APP_TYPE_E
	int secene;		//如枚举FISHEYE_SECENE_E
	unsigned int reserv[8];
}SDK_FishEyeParam;

//是否叠加OSD logo
typedef struct SDK_SetLogo
{
	int Enable;
	int	reserve[8];
}SDK_SetLogo;

typedef struct SDK_SparshHeartbeat
{
	bool bEnable;	///是否启用
	int  IntevalTime; 	///间隔上报时间
	char AlarmType[NET_NAME_PASSWORD_LEN];	///名称
}SDK_SparshHeartbeat;
typedef struct SDK_SDevicesState
{
    int 	num;
    char uuid[32][32];
    int state[32];
}SDK_SDevicesState;

typedef enum SDK_EncMode
{
	WIFI_ENC_OPEN = 0,
	WIFI_ENC_AES = 1,
	WIFI_ENC_TKIP = 2,
	WIFI_ENC_WEP =3
}SDK_EncMode;

typedef struct SDK_SWifiInfo
{
	char wifiSsid[64];
	char wifiPassword[64];
	char wifiMac[64];       // 以:分隔的十六进制字符串
	char wifiGateWay[64];   // 网关
	char wifiSubmark[64];   // 子网掩码
	char wifiDNS1[64];      // DNS1
	char wifiDNS2[64];      // DNS2
	int  wifiEncMode;       // 加密方式--EncMode
	char mobileIp[32];
	char mobileMac[32];
}SDK_SWifiInfo;

// 数据上传通道回调函数原型
typedef void (CALL_METHOD *fUploadDataCallBack) (long lLoginID, long UploadType, char *pBuffer, unsigned long dwBufSize, unsigned long dwUser);

// 透明串口回调函数原形
typedef void (CALL_METHOD *fTransComCallBack) (long lLoginID, long lTransComType, char *pBuffer, unsigned long dwBufSize, unsigned long dwUser);
//服务器断开回调原形
typedef void (CALL_METHOD *fDisConnect)(long lLoginID, char *pchDVRIP, long nDVRPort, unsigned long dwUser);

//原始数据回调原形
typedef int(CALL_METHOD *fRealDataCallBack) (long lRealHandle, long dwDataType, unsigned char *pBuffer,long lbufsize,long dwUser);
typedef int(CALL_METHOD *fRealDataCallBack_V2) (long lRealHandle, const PACKET_INFO_EX *pFrame, unsigned int dwUser);

// 回放录像进度回调原形
typedef void(CALL_METHOD *fDownLoadPosCallBack) (long lPlayHandle, long lTotalSize, long lDownLoadSize, long dwUser);

//消息（报警,主动注册）回调原形
/*
	1.报警,pBuf说明,
	SDK_AlarmInfo alarmInfo;
	memcpy ( &alarmInfo, pBuf, dwBufLen );
	2.主动注册,pBuf说明,
	H264_DVR_ACTIVEREG_INFO activeInfo;
	memcpy ( &alarmInfo, pBuf, dwBufLen );
*/
typedef bool (CALL_METHOD *fMessCallBack)(long lLoginID, char *pBuf,
                                          unsigned long dwBufLen, long dwUser);

//升级设备程序回调原形
/*
	nSendSize = -1 说明升级完成  
	nSendSize = -2 说明升级出错
	nTotalSize = -1时, nSendSize:1-99返回升级进度 
	nTotalSize =0时,nSendSize = H264_DVR_NOENOUGH_MEMORY-H264_DVR_INVALID_WIFI_DRIVE 升级错误具体码
	其他就是发送进度
	云升级增加了这一步:nTotalSize=-2时，nSendSize:0 - 100=下载进度,没有发送进度
*/
typedef void(CALL_METHOD *fUpgradeCallBack) (long lLoginID, long lUpgradechannel,
                                             int nTotalSize, int nSendSize, long dwUser);


// 语音对讲的音频数据回调函数原形
typedef void (CALL_METHOD *pfAudioDataCallBack)(long lVoiceHandle, char *pDataBuf,
                                                long dwBufSize, char byAudioFlag, long dwUser);


//本地播放结束回调原形
typedef void (CALL_METHOD * fLocalPlayFileCallBack)(long lPlayHand, long nUser);

//信息帧回调设置
typedef void (CALL_METHOD  *InfoFramCallBack)(long lPlayHand, long nType, LPCSTR pBuf,long nSize, long nUser);



//子连接断线回调
typedef void (CALL_METHOD *fSubDisConnectCallBack)(long lLoginID, SubConnType type, long nChannel, long dwUser);

#ifdef WIN32
//RigisterDraw回调原形
typedef void (CALL_METHOD * fPlayDrawCallBack)(long lPlayHand,HDC hDc,long nUser);
#else//linux没用到这个回调
typedef void (CALL_METHOD * fPlayDrawCallBack)(long lPlayHand,void* hDc,long nUser);
#endif // WIN32

//*** */SDK初始化
H264_DVR_API long CALL_METHOD H264_DVR_Init(fDisConnect cbDisConnect, unsigned long dwUser);

//*** */SDK退出清理
H264_DVR_API bool CALL_METHOD H264_DVR_Cleanup();

//获取错误信息
H264_DVR_API long CALL_METHOD H264_DVR_GetLastError();

// 设置连接设备超时时间和尝试次数
/*
	nWaitTime:单位ms不设置时默认5000ms,
	nTryTimes:次数,不设置时默认3次
*/
H264_DVR_API bool CALL_METHOD H264_DVR_SetConnectTime(long nWaitTime, long nTryTimes);

//登陆设备
/*
	socketType 参考类型 SocketStyle，默认是0 
*/
H264_DVR_API long CALL_METHOD H264_DVR_Login(char *sDVRIP, unsigned short wDVRPort, char *sUserName, char *sPassword,
                                             LPH264_DVR_DEVICEINFO lpDeviceInfo, int *error,int socketType DEF_PARAM(0));

//向设备注册扩展接口
/*
	增加登陆类型 0==web 1 ==升级工具 2 == 搜索工具  102 == 外部加密，内部就不用加密了
*/
H264_DVR_API long CALL_METHOD H264_DVR_LoginEx(char *sDVRIP, unsigned short wDVRPort, char *sUserName, char *sPassword,
							   LPH264_DVR_DEVICEINFO lpDeviceInfo, int nType, int *error);

//客户云登陆接口
H264_DVR_API long CALL_METHOD H264_DVR_Login_Cloud(char *sDVRIP, unsigned short wDVRPort, char *sUserName, char *sPassword,
												   LPH264_DVR_DEVICEINFO lpDeviceInfo, int *error,char* uuid);
//向设备注销
H264_DVR_API long CALL_METHOD H264_DVR_Logout(long lLoginID);

//设置接收DVR信息回调, 例如报警信息,以ID号区分
H264_DVR_API bool CALL_METHOD H264_DVR_SetDVRMessCallBack(fMessCallBack cbAlarmcallback, unsigned long lUser);

//建立报警上传通道
H264_DVR_API long CALL_METHOD H264_DVR_SetupAlarmChan(long lLoginID);
//关闭报警上报
H264_DVR_API bool CALL_METHOD H264_DVR_CloseAlarmChan(long lLoginID);


//远程配置设备接口 配置类型见SDK_CONFIG_TYPE
H264_DVR_API long  CALL_METHOD H264_DVR_GetDevConfig(long lLoginID, unsigned long dwCommand, int nChannelNO, char * lpOutBuffer, unsigned long dwOutBufferSize, unsigned long* lpBytesReturned,int waittime DEF_PARAM(1000));
H264_DVR_API long  CALL_METHOD H264_DVR_SetDevConfig(long lLoginID, unsigned long dwCommand, int nChannelNO, char * lpInBuffer, unsigned long dwInBufferSize, int waittime DEF_PARAM(1000));

//跨网段设置设备配置，目前只支持对网络配置进行设置    SDK_CONFIG_NET_COMMON_V3,nChannelNO:1临时保存,其他为永久保存
H264_DVR_API long CALL_METHOD H264_DVR_SetConfigOverNet(unsigned long dwCommand, int nChannelNO, char * lpInBuffer, unsigned long dwInBufferSize, int waittime DEF_PARAM(1000));

//日志查询
H264_DVR_API bool CALL_METHOD H264_DVR_FindDVRLog(long lLoginID, SDK_LogSearchCondition *pFindParam, SDK_LogList *pRetBuffer, long lBufSize, int waittime DEF_PARAM(2000));

//打开实时预览
H264_DVR_API long CALL_METHOD H264_DVR_RealPlay(long lLoginID, LPH264_DVR_CLIENTINFO lpClientInfo);
H264_DVR_API bool CALL_METHOD H264_DVR_StopRealPlay(long lRealHandle,void*hWnd DEF_PARAM(0));
H264_DVR_API long CALL_METHOD H264_DVR_PauseRealPlay(long lRealHandle, bool bPause);

//设置回调函数，用户自己处理客户端收到的数据
H264_DVR_API bool CALL_METHOD H264_DVR_SetRealDataCallBack(long lRealHandle,fRealDataCallBack cbRealData, long dwUser);
/*
	数据经过码流分析过，带有帧的具体信息
*/
H264_DVR_API bool CALL_METHOD H264_DVR_SetRealDataCallBack_V2(long lRealHandle,fRealDataCallBack_V2 cbRealData, long dwUser);

//清除回调函数,该函数需要在H264_DVR_StopRealPlay前调用
H264_DVR_API bool CALL_METHOD H264_DVR_DelRealDataCallBack(long lRealHandle,fRealDataCallBack cbRealData, long dwUser);
H264_DVR_API bool CALL_METHOD H264_DVR_DelRealDataCallBack_V2(long lRealHandle,fRealDataCallBack_V2 cbRealData, long dwUser);

//录像查询
/*
	lLoginID	登陆句柄
	lpFindInfo	查询条件
	lpFileData	查找到的录像数据，外部开内存
	lMaxCount	最大录像数目
	findcount	查找到的录像数目
	waittime	查询超时时间
*/
H264_DVR_API long CALL_METHOD H264_DVR_FindFile(long lLoginID, H264_DVR_FINDINFO* lpFindInfo, H264_DVR_FILE_DATA *lpFileData, int lMaxCount, int *findcount, int waittime DEF_PARAM(5000));

//录像查询
/*
	lLoginID		登陆句柄
	lpFindInfo	查询条件
	lpFileData	查找到的录像数据，外部开内存
	waittime		查询超时时间
*/
H264_DVR_API long CALL_METHOD H264_DVR_FindFileByTime(long lLoginID, SDK_SearchByTime* lpFindInfo, SDK_SearchByTimeResult *lpFileData, int waittime DEF_PARAM(10000));

//录像回放
/*
	lLoginID		登陆句柄
	sPlayBackFileName	回放的录像名称
	cbDownLoadPos 进度回调，用户通知用户设备是否已经将数据发送完毕，回调中的lDownLoadSize=-1代表数据发送完毕
	客户如果想实时显示进度，应该从码流里面获取时间来计算
	网络部分不分析码流，如果以当前接收数据大小/总大小来计算进度的话不是很准，应该以当前时间，根据开始时间和结束时间来计算进度
	fDownLoadDataCallBack 数据回调
	dwDataUser	回调参数
*/
H264_DVR_API long CALL_METHOD H264_DVR_PlayBackByName(long lLoginID, H264_DVR_FILE_DATA *sPlayBackFile, fDownLoadPosCallBack cbDownLoadPos, fRealDataCallBack fDownLoadDataCallBack, long dwDataUser);
H264_DVR_API long CALL_METHOD H264_DVR_PlayBackByName_V2(long lLoginID, H264_DVR_FILE_DATA *sPlayBackFile, fDownLoadPosCallBack cbDownLoadPos, fRealDataCallBack_V2 fDownLoadDataCallBack, long dwDataUser);

//按时间进行录像回放
/*
	1、进度回调和数据回调用的同一个回调参数
	2、fDownLoadDataCallBack数据回调出来的数据的没有经过码流分析
*/
H264_DVR_API long CALL_METHOD H264_DVR_PlayBackByTime(long lLoginID, H264_DVR_FINDINFO* lpFindInfo, fDownLoadPosCallBack cbDownLoadPos, fRealDataCallBack fDownLoadDataCallBack, long dwDataUser);

/*
	1、进度回调和数据回调用不同的回调参数
	2、fDownLoadDataCallBack数据回调出来的数据的没有经过码流分析
*/
H264_DVR_API long CALL_METHOD H264_DVR_PlayBackByTimeEx(long lLoginID, H264_DVR_FINDINFO* lpFindInfo,fRealDataCallBack fDownLoadDataCallBack, long dwDataUser,
											fDownLoadPosCallBack cbDownLoadPos, long dwPosUser);
/*
	1、进度回调和数据回调用不同的回调参数
	2、fDownLoadDataCallBack数据回调出来的数据的码流分析过
*/
H264_DVR_API long CALL_METHOD H264_DVR_PlayBackByTime_V2(long lLoginID, H264_DVR_FINDINFO* lpFindInfo,fRealDataCallBack_V2 fDownLoadDataCallBack, long dwDataUser,
											fDownLoadPosCallBack cbDownLoadPos, long dwPosUser);

//停止回放
H264_DVR_API bool CALL_METHOD H264_DVR_StopPlayBack(long lPlayHandle);

//回放控制分暂停/继续/定位/快放/慢放等等 lControlCode: SDK_PlayBackAction
H264_DVR_API bool CALL_METHOD H264_DVR_PlayBackControl(long lPlayHandle, long lControlCode,long lCtrlValue);

//录像下载,用户可以不使用回调，自己通过H264_DVR_GetDownloadPos获取进度
H264_DVR_API long CALL_METHOD H264_DVR_GetFileByName(long lLoginID,H264_DVR_FILE_DATA *sPlayBackFile,char *sSavedFileName,
                                                     fDownLoadPosCallBack cbDownLoadPos DEF_0_PARAM, long dwDataUser DEF_0_PARAM,fRealDataCallBack fDownLoadDataCallBack DEF_0_PARAM);

//录像下载,用户可以不使用回调，自己通过H264_DVR_GetDownloadPos获取进度
H264_DVR_API long CALL_METHOD H264_DVR_GetFileByName_V2(long lLoginID,H264_DVR_FILE_DATA *sPlayBackFile,char *sSavedFileName,
													 fDownLoadPosCallBack cbDownLoadPos DEF_0_PARAM, long dwDataUser DEF_0_PARAM,fRealDataCallBack_V2 fDownLoadDataCallBack_V2 DEF_0_PARAM);

H264_DVR_API long CALL_METHOD H264_DVR_GetFileByTime(long lLoginID, H264_DVR_FINDINFO* lpFindInfo, char *sSavedFileDIR, bool bMerge DEF_PARAM(0),
                                                     fDownLoadPosCallBack cbDownLoadPos DEF_0_PARAM, long dwDataUser DEF_0_PARAM,fRealDataCallBack fDownLoadDataCallBack DEF_0_PARAM);

H264_DVR_API bool CALL_METHOD H264_DVR_StopGetFile(long lFileHandle);

//下载控制分,暂停,继续 lControlCode: SDK_PlayBackAction
H264_DVR_API bool CALL_METHOD H264_DVR_GetFileControl(long lPlayHandle, long lControlCode, bool bDown DEF_PARAM(1));
//获取下载进度
H264_DVR_API int CALL_METHOD H264_DVR_GetDownloadPos(long lFileHandle);

//升级
/*
	==UpgradeTypes
 */
H264_DVR_API long CALL_METHOD H264_DVR_Upgrade(long lLoginID, char *sFileName, int nType DEF_0_PARAM, fUpgradeCallBack cbUpgrade DEF_0_PARAM, long dwUser DEF_0_PARAM);

//升级状态 1 成功， 2 正在升级 3 失败
H264_DVR_API int CALL_METHOD H264_DVR_GetUpgradeState(long lUpgradeHandle);
H264_DVR_API long CALL_METHOD H264_DVR_CloseUpgradeHandle(long lUpgradeHandle);


//云台控制，默认是开启云台，速度4，用户也可以自行设置速度
/* 
	lPTZCommand:见PTZ_ControlType
*/
H264_DVR_API bool CALL_METHOD H264_DVR_PTZControl(long lLoginID,int nChannelNo, long lPTZCommand, bool bStop  DEF_PARAM(0), long lSpeed DEF_PARAM(4));

//扩展云台控制，包括预置点设置，巡航路线，快速定位等等
/*
	设置，删除，转到预置点时：lParam1为预置点值
	加入预置点到巡航，删除巡航中预置点时：lParam1为巡航线路值，
	lParam2为预置点值,lParam3为时间间隔
	开始巡航，停止巡航，清除巡航线路时：lParam1为巡航线路值
	云台方向设置时：lParam1为水平步长，lParam2为垂直步长
	lPTZCommand:PTZ_ControlType
 */
H264_DVR_API bool CALL_METHOD H264_DVR_PTZControlEx(long lLoginID,int nChannelNo, long lPTZCommand,
                                                    long lParam1, long lParam2, long lParam3, bool bStop DEF_0_PARAM);

//设备控制：返回值 true 成功， false 失败
/*
	type==0 重启设备，1 清除日志 2 关机 3.恢复记录日志 4.停止记录日志 5.手机对讲恢复关闭之前临时打开过的音频
*/
H264_DVR_API bool CALL_METHOD H264_DVR_ControlDVR(long lLoginID, int type, int waittime DEF_PARAM(2000));
	

//搜索局域网内的设备 SDK_CONFIG_NET_COMMON_V2
H264_DVR_API bool CALL_METHOD H264_DVR_SearchDevice(char* szBuf, int nBufLen, int* pRetLen, int nSearchTime);


//语音对讲，负责数据传发接口
H264_DVR_API long CALL_METHOD H264_DVR_StartVoiceCom_MR(long lLoginID, pfAudioDataCallBack pVcb, long dwDataUser);
H264_DVR_API bool CALL_METHOD H264_DVR_VoiceComSendData(long lVoiceHandle, char *pSendBuf, long lBufSize);
H264_DVR_API bool CALL_METHOD H264_DVR_StopVoiceCom(long lVoiceHandle);

//设置对讲音频编码方式，用户可以不设置，默认为G711A编码
H264_DVR_API bool CALL_METHOD H264_DVR_SetTalkMode(long lLoginID, SDK_AudioInFormatConfig* pTalkMode);

// lRecordType录像模式, 见SDK_RecordModeTypes
H264_DVR_API bool CALL_METHOD H264_DVR_StartDVRRecord(long lLoginID, int nChannelNo ,long lRecordType);
H264_DVR_API bool CALL_METHOD H264_DVR_StopDVRRecord(long lLoginID, int nChannelNo);

//设置设备系统时间
H264_DVR_API bool CALL_METHOD H264_DVR_SetSystemDateTime(long lLoginID, SDK_SYSTEM_TIME *pSysTime);
//得到设备的工作状态
H264_DVR_API bool CALL_METHOD H264_DVR_GetDVRWorkState(long lLoginID, SDK_DVR_WORKSTATE *pWorkState);

//网络键盘，具体使用方法见ClientDemo
H264_DVR_API bool CALL_METHOD H264_DVR_ClickKey(long lLoginID, SDK_NetKeyBoardData *pKeyBoardData);

// 磁盘管理
/*	
	对硬盘进行分区,格式化等等操作
*/
H264_DVR_API int CALL_METHOD H264_DVR_StorageManage(long lLoginID, SDK_StorageDeviceControl *pStorageCtl);

H264_DVR_API bool CALL_METHOD H264_DVR_SendNetAlarmMsg(long lLoginID, SDK_NetAlarmInfo *pAlarmInfo);

//设备端抓图,即抓设备端发过来的即时的一张图片sdk内部生成文件
/*
	说明:设备端抓图,即抓设备端发过来的即时的一张图片的内存buf
	1.需要设备配置里面有抓图配置选项该接口才有效
	2.如果满足1，默认抓出来的分辨率是D1，如果想抓跟视频分辨率一样的图片，就需要修改编码设置里的抓图分辨率，
	  如果编码设置没有抓图分辨率选项，则需要定制支持该项的程序
*/
H264_DVR_API bool CALL_METHOD H264_DVR_CatchPic(long lLoginID, int nChannel, char *sFileName);

//设备端抓图,即抓设备端发过来的即时的一张图片的内存buf，外部生成文件
/*
	说明:同H264_DVR_CatchPic
*/
H264_DVR_API bool CALL_METHOD H264_DVR_CatchPicInBuffer(long lLoginID, int nChannel, char *pBuffer, int nBufLen, int *pPicLen);

//启动报警中心监听(具体用法见AlarmCenter demo)
H264_DVR_API bool CALL_METHOD H264_DVR_StartAlarmCenterListen(int nPort, fMessCallBack cbAlarmCenter, unsigned long dwDataUser);
//关闭报警中心监听
H264_DVR_API bool CALL_METHOD H264_DVR_StopAlarmCenterListen();

//透明232,485
H264_DVR_API bool CALL_METHOD H264_DVR_SerialWrite(long lLoginID, SERIAL_TYPE nType, char *pBuffer, int nBufLen);
H264_DVR_API bool CALL_METHOD H264_DVR_SerialRead(long lLoginID, SERIAL_TYPE nType, char *pBuffer, int nBufLen, int *pReadLen);

//获取DDNS信息，具体用法见ClientDemo
H264_DVR_API int CALL_METHOD H264_DVR_GetDDNSInfo(SearchMode &searchmode, DDNS_INFO *pDevicInfo, int maxDeviceNum, int &nretNum);

//nStream: 0表示主码流，为1表示子码流
H264_DVR_API bool CALL_METHOD H264_DVR_MakeKeyFrame(long lLoginID, int nChannel, int nStream);

//nStream: 0表示主码流，为1表示子码流
H264_DVR_API bool CALL_METHOD H264_DVR_GetOEMInfo(long lLoginID, SDK_OEMInfo *pOEMInfo);
// 创建透明串口通道
H264_DVR_API bool CALL_METHOD H264_DVR_OpenTransComChannel(long lLoginID, TransComChannel *TransInfo, fTransComCallBack cbTransCom, unsigned long lUser);
//关闭透明串口通道
H264_DVR_API bool CALL_METHOD H264_DVR_CloseTransComChannel(long lLoginID, SERIAL_TYPE nType);

//获取ui图片:type 1:为全图片 2:活动区域图片
H264_DVR_API bool CALL_METHOD H264_DVR_CatchPicUI(long lLoginID,char *saveFileName,int type DEF_PARAM(1));

#ifdef WIN32

//打开通道音频 //预览，回放，本地播放 一个函数
H264_DVR_API bool CALL_METHOD H264_DVR_OpenSound(long lHandle);
//关闭通道音频 //预览，回放，本地播放 一个函数
H264_DVR_API bool CALL_METHOD H264_DVR_CloseSound(long lHandle);
//抓本地图片 //预览，回放，本地播放 一个函数
H264_DVR_API bool CALL_METHOD H264_DVR_LocalCatchPic(long lHandle,char*szSaveFileName);
//打开对讲
H264_DVR_API long CALL_METHOD H264_DVR_StartLocalVoiceCom(long lLoginID);
//开始本地录像
H264_DVR_API bool CALL_METHOD H264_DVR_StartLocalRecord(long lRealHandle,char*szSaveFileName,long type=0);
//关闭本地录像
H264_DVR_API bool CALL_METHOD H264_DVR_StopLocalRecord(long lRealHandle);

//播放本地文件
H264_DVR_API long CALL_METHOD H264_DVR_StartLocalPlay(char*pFileName,void* hWnd,fPlayDrawCallBack drawCallBack=0,long user=0);
//关闭本地播放
H264_DVR_API bool CALL_METHOD H264_DVR_StopLocalPlay(long lPlayHandle);
//获取播放位置用于回放，和本地播放
H264_DVR_API float CALL_METHOD H264_DVR_GetPlayPos(long lPlayHandle);
//设置播放位置（百分比）用于回放，和本地播放
H264_DVR_API bool CALL_METHOD H264_DVR_SetPlayPos(long lPlayHandle,float fRelativPos);
//播放控制（播放，停止，恢复，快发，慢放）
H264_DVR_API bool CALL_METHOD H264_DVR_LocalPlayCtrl(long lPlayHandle,SDK_LoalPlayAction action,long lCtrlValue);
//设置播放结束回调
H264_DVR_API bool CALL_METHOD H264_DVR_SetFileEndCallBack(long lPlayHandle,fLocalPlayFileCallBack callBack,long user);
//设置信息帧回调
H264_DVR_API bool CALL_METHOD H264_DVR_SetInfoFrameCallBack(long lPlayHandle,InfoFramCallBack callback,long user);

//本地颜色控制 //预览，回放，本地播放 一个函数
H264_DVR_API bool CALL_METHOD H264_DVR_LocalGetColor(long lHandle, DWORD nRegionNum, LONG *pBrightness, LONG *pContrast, LONG *pSaturation, LONG *pHue);
H264_DVR_API bool CALL_METHOD H264_DVR_LocalSetColor(long lHandle, DWORD nRegionNum, LONG nBrightness, LONG nContrast, LONG nSaturation, LONG nHue);
#endif
//设置本地ip
H264_DVR_API bool CALL_METHOD H264_DVR_SetLocalBindAddress(char*szIP);

//上报数据
H264_DVR_API bool CALL_METHOD H264_DVR_StartUploadData(long lLoginID,UploadDataType upLoadType,fUploadDataCallBack callBack,long lUser);

H264_DVR_API bool CALL_METHOD H264_DVR_StopUploadData(long lLoginID,UploadDataType upLoadType);

//主动注册
H264_DVR_API bool CALL_METHOD H264_DVR_StartActiveRigister(int nPort, fMessCallBack cbFunc, unsigned long dwDataUser);
H264_DVR_API bool CALL_METHOD H264_DVR_StopActiveRigister();

//子连接异常断开
H264_DVR_API long CALL_METHOD H264_DVR_SetSubDisconnectCallBack(fSubDisConnectCallBack callBack,DWORD userData);

//设置保活时间,perKeeplifeTime(心跳间隔):单位秒,detectDisconTime(断线检测时间):单位秒
H264_DVR_API long CALL_METHOD H264_DVR_SetKeepLifeTime(long lLoginID,unsigned int perKeeplifeTime,unsigned int detectDisconTime);

//MAC 得到加密
H264_DVR_API bool CALL_METHOD H264_DVR_CheckEncrypt(char *pMac);

//设备搜索到的设备，与设备在同一个局域网的设备
H264_DVR_API bool CALL_METHOD H264_DVR_SearchDeviceEX(long lLoginID,SDK_NetDevList *pDevlist,SDK_TransferProtocol_V2 transferProtocol DEF_PARAM(SDK_TRANSFER_PROTOCOL_NETIP),int waittime DEF_PARAM(15000));

//云台快速定位
//使用前 判断是否支持
H264_DVR_API bool CALL_METHOD H264_DVR_PTZPostion(long lLoginID,int nChannel,SDK_PositionPoint *pPositionPoint);

///< NVR和其连接的前端对讲
H264_DVR_API bool CALL_METHOD H264_DVR_StartDevTalk(long lLoginID,int nChannel,int waittime DEF_PARAM(2000));
H264_DVR_API bool CALL_METHOD H264_DVR_StopDevTalk(long lLoginID,int nChannel,int waittime DEF_PARAM(2000));
///<硬盘录像信息
//录像查询
//lLoginID		登陆句柄
//lpFindInfo	查询条件
//lpFileData	查找到的录像数据，外部开内存
//waittime		查询超时时间
H264_DVR_API long CALL_METHOD H264_DVR_RecordInfo(long lLoginID, SDK_SearchByTime* lpFindInfo, SDK_RecordStorageInfo *lpRecordData, int waittime DEF_PARAM(15000));

H264_DVR_API bool CALL_METHOD H264_DVR_ControlFile(long lLoginID,SDK_NetFileControl *lpFileControl,int waittime DEF_PARAM(15000));

//录像设备里面有多少音频文件，最大8个
//lLoginID		登陆句柄
//lpFindInfo	查询条件
//lpFileData	查找到的音频数据，外部开内存
//waittime		查询超时时间
H264_DVR_API bool CALL_METHOD H264_DVR_FindAudioFile(long lLoginID, SDK_MusicFileList* lpFileList, int waittime DEF_PARAM(5000));

/*
	==播放音频文件需要文件名，其他的不需要，ACTION一定要赋值
	== Action  参考 SDK_Music_Play_Action
 */
H264_DVR_API bool CALL_METHOD H264_DVR_ControlAudio(long lLoginID, SDK_LocalMusicControl *lpMusicControl, int waittime DEF_PARAM(2000));

H264_DVR_API bool CALL_METHOD H264_DVR_UserData(int ntype,char *pUserData, long nlen);
H264_DVR_API long CALL_METHOD H264_DVR_Upgrade_Cloud(long lLoginID, SDK_CloudUpgradeVersion *sUpgradeVer, int nType DEF_0_PARAM, fUpgradeCallBack cbUpgrade DEF_0_PARAM, long dwUser DEF_0_PARAM);
H264_DVR_API long CALL_METHOD H264_DVR_StopUpgrade_Cloud(long lHandle);
H264_DVR_API bool CALL_METHOD H264_DVR_Get_OutNet_IP(const char *uuid, char* ip);
#ifndef WIN32

typedef void (*IDownProcess)(int nProcess,int userData);
typedef void (*IDownData)(unsigned char* data, unsigned int length, int nUserData);

H264_DVR_API int  CALL_METHOD H264_DVR_SetServerAddr(const char *ip, int port);
////start********手机用**********/
H264_DVR_API int  CALL_METHOD H264_DVR_GetUpgradeFileList(const char *id, char *VersionList,int &num);
H264_DVR_API int CALL_METHOD H264_DVR_StartDownload(const char* strSaveFilePath, const char *id, const char *date,const char *name,unsigned int length,IDownProcess ProgressCallback,IDownData DataCallback,int userData);
H264_DVR_API int CALL_METHOD H264_DVR_CancelDownload();
////**************end/

H264_DVR_API bool CALL_METHOD H264_DVR_ControlFBExtraState(long lLoginID, bool bOn, int waittime);
//获取服务器ip(测试用)
H264_DVR_API bool CALL_METHOD H264_DVR_GetServerIp(char* _serverip);


H264_DVR_API int CALL_METHOD H264_DVR_AuthDevice_Init(char *uuid,char *ip,int port);
H264_DVR_API int CALL_METHOD H264_DVR_AuthDevice_Register();
H264_DVR_API int CALL_METHOD H264_DVR_AuthDevice_UnRegister();

H264_DVR_API int CALL_METHOD H264_DVR_AuthDevice_GetUpdateServer(char *ip,int size);


H264_DVR_API int CALL_METHOD H264_DVR_AlarmInit(char* uuid,char*ip,char* serIP);

typedef int (*MpsDevAuth)(char *buffer,int size);	//鉴权
typedef int (*MpsDevDataRecv)(char *buffer,int size,int clientID);	//数据由客户端发给设备

H264_DVR_API int CALL_METHOD H264_DVR_AlarmPush(char* buffer,int size);
H264_DVR_API int CALL_METHOD H264_DVR_AlarmStart(char* uuid,char* serIP,MpsDevAuth  AuthCb, MpsDevDataRecv DataRecvCb);

H264_DVR_API int CALL_METHOD H264_DVR_IMpsClient(char* uuid,SDK_CONFIG_TYPE configType,char* buffer,int size);

H264_DVR_API int CALL_METHOD H264_DVR_IMpsGetClient(char* uuid,SDK_CONFIG_TYPE configType,char* buffer,int size);
H264_DVR_API int CALL_METHOD H264_DVR_IMpsInbuffer(char* uuid,SDK_CONFIG_TYPE configType,char* buffer,int *size);
H264_DVR_API long CALL_METHOD H264_DVR_Upgrade_Cloud_V2(char* uuid, SDK_CloudUpgradeVersion *sUpgradeVer, int nType,fUpgradeCallBack cbUpgrade, long dwUser);

H264_DVR_API int H264_DVR_SearchAlarmInfo(char *ip, int port, SDK_XPMS_SEARCH_ALARMINFO_REQ &AlarmInfoReq);
H264_DVR_API int H264_DVR_SearchAlarmPic(char *ip, int port, SDK_XPMS_SEARCH_ALARMPIC_REQ &AlarmPicReq);
//获取穿透库的版本信息
H264_DVR_API void CALL_METHOD H264_VV_NAT_GetVersion(char *version, int size);
////增加强制走转发的接口；skipP2P=1  强制转发。skipP2P=0 按正常检测机制流程。
H264_DVR_API void CALL_METHOD H264_Direct_Proxy(int skipP2P);
//1雄迈精品  0普通的
H264_DVR_API int CALL_METHOD H264_XM_Unique();
H264_DVR_API void* get_MpsAlarmClient_Instance();
H264_DVR_API long CALL_METHOD H264_DVR_GetDevConfig_Json(long lLoginID, const char* dwCommand, int nChannelNO,char * lpOutBuffer,unsigned long dwOutBufferSize,unsigned long* lpBytesReturned,int waittime DEF_PARAM(1000));

H264_DVR_API long CALL_METHOD H264_DVR_SetDevConfig_Json(long lLoginID,const char* dwCommand, int nChannelNO, char * lpInBuffer,int waittime DEF_PARAM(1000));
typedef int (*OnFoundDevCB)(char * uuid,int state,int userData);
H264_DVR_API int CALL_METHOD H264_DVR_Check_Device_Exist(SDK_SDevicesState *pStates, int nTimeout,OnFoundDevCB decCb,int userData);
H264_DVR_API int CALL_METHOD H264_DVR_Check_Device_Exist_V2(SDK_SDevicesState *pStates, int nTimeout,OnFoundDevCB decCb,int userData);
typedef void (*PFunOnWifiConfigResult)(int nResult, SDK_CONFIG_NET_COMMON_V2 *pConfig);
H264_DVR_API int CALL_METHOD H264_DVR_StartWifiConfig(SDK_SWifiInfo *pInfo, PFunOnWifiConfigResult pOnResult);
H264_DVR_API void CALL_METHOD H264_DVR_StopWifiConfig();
H264_DVR_API int CALL_METHOD H264_DVR_SetAuthUserInfo(const char *userName, const char *password);
#endif
#endif
