rk3399_arm_lvds/packages/common.pkg/include/commondef.h

#pragma once
#include <functional>
#include <map>
#include <queue>

#define FWVersionEN

#define G200

#ifdef G200
#define FWVersion "G2393D0318"
#define SERIALNUM "G2396021071101"
#else
#define FWVersion "G1393D0318"
#define SERIALNUM "G1396021071101"
#endif

//#ifdef FWVersionEN
//#pragma warnning("WARNNING! current fareware version is :" FWVersion)
//#endif
typedef unsigned int 	u32;
typedef unsigned char 	u8;
typedef unsigned char 	byte;
typedef unsigned short 	u16;

typedef struct Size
{
	long x;
	long y;
};

typedef enum Error_Status : uint32_t
{
	NO_error 		= 0,
	Dog_error 		= 1,
	Size_error 		= 2,
	Img_Detecting 	= 0xffff,
};

typedef struct ImgStatus
{
	Error_Status status;
	uint32_t scannum;
};

typedef union HG_ScanConfig
{
	unsigned int value;
	struct
	{
		unsigned int paper : 5;
		unsigned int color : 1;
		unsigned int dpi : 2;
		unsigned int double_feed_enbale : 1;
		unsigned int stable_enbale : 1;
		unsigned int screw_detect_enable : 1;
		unsigned int screw_detect_level : 3; //第十四位
		unsigned int iscorrect_mode : 1;
		unsigned int is_autopaper : 1;
		unsigned int is_textcorrect : 1;
		unsigned int is_fixedpaper : 1;
		unsigned int en_anlogic_key : 1;
		unsigned int en_autosize : 1;
		unsigned int pc_correct : 1;
		//unsigned int enable_sizecheck : 1;
		unsigned int double_out_en : 1;
		unsigned int enabledsp_cache : 1;
		unsigned int sizeerror_errorratio : 9;
	} g200params;
	struct
	{
		unsigned int pageSize : 5;
		unsigned int isColor : 1;
		unsigned int dpi : 2;
		unsigned int doubleFeeded : 1;
		unsigned int enableStable : 1;
		unsigned int enableLed : 1;
		unsigned int reversed1 : 6;
		unsigned int isCorrect : 1;
		unsigned int dstHeight : 8;
		unsigned int reversed2 : 6;
	} g400params;
} HGScanConfig;

typedef enum SCAN_STATUS
{
	SCAN_NORMAL,
	SCAN_SCANNING,
	SCAN_COVEROPEN,
	SCAN_FEEDERROR,
	SCAN_PAPERJAM,
	SCAN_DOUBLEFEED,
	SCAN_AQUIREIMGTIMEOUT,
	SCAN_AQUIREIMGSIZEERROR,
	SCAN_DETECTSKREW,
	SCAN_DETECTSTABLE,
	SCAN_COUNTMODE,
	SCAN_NOFEED,
	SCAN_AUTOCORRECT_DONE,
	SCAN_STOPED
} SCAN_STATUS;

enum img_status : uint32_t
{
	IMG_STATUS_OK = 0,					// normal
	IMG_STATUS_DOUBLE 	= 1 << 0,		// double-feeded paper
	IMG_STATUS_JAM 		= 1 << 1,		// jammed paper
	IMG_STATUS_STAPLE	= 1 << 2,		// staples on the paper
	IMG_STATUS_SIZE_ERR = 1 << 3,		// size check failed
	IMG_STATUS_DOGEAR 	= 1 << 4,		// paper has dogear - common
	IMG_STATUS_DOGEAR_PARTIAL = 1 << 5,	// dogear - scanned partial
	IMG_STATUS_BLANK	= 1 << 6,		// blank image
};

struct MotorBoardGlue
{
	MotorBoardGlue(const std::function<void(unsigned int)> error_call,
				   const std::function<void()> scan_done_call,
				   const std::function<void(unsigned int)> os_mode_call,
				   const std::function<void(unsigned int)> set_sleepmode_call,
				   const std::function<void(unsigned int)> mltop_call,
				   std::function<void(unsigned int)> auto_paper,
				   const std::function<void(bool)> coveropen)
		: m_error_call(error_call),
		  m_scan_done_call(scan_done_call),
		  m_os_mode_call(os_mode_call),
		  m_set_sleepmode_call(set_sleepmode_call),
		  m_mltop_call(mltop_call),
		  m_auto_paper(auto_paper),
		  m_coveropen_call(coveropen)
	{
	}

	std::function<void(unsigned int)> 	m_error_call;
	std::function<void()> 				m_scan_done_call;
	std::function<void(unsigned int)> 	m_os_mode_call;
	std::function<void(unsigned int)> 	m_set_sleepmode_call;
	std::function<void(unsigned int)> 	m_mltop_call;
	std::function<void(unsigned int)> 	m_auto_paper;
	std::function<void(bool)> 			m_coveropen_call;
}; 


struct ScannerNativeParam
{
	u32 TotalScanned;	   //扫描总计<E680BB>?
	u32 RollerNum;		   //滚轴计数
	u32 H_ratio;		   //横向修正系数
	u32 V_ratio;		   //纵向修正系数
	u32 JamTimes;		   //卡纸次数
	u32 FeedErrorTimes;	   //搓纸失败次数
	u32 DoubleFeedTimes;   //双张次数
	u32 ScanSessionsCount; //总计扫描次数
	u16 gray_sp;		   //灰度sp<73>?
	u16 color_sp;		   //彩色sp<73>?
	int sleeptime;		   //休眠模式时间 -1 不休<E4B88D>?
	std::string SerialNum; //序列<E5BA8F>?
	std::string Token;	   //识别<E8AF86>?
	u32 clr_maxbright;	   //彩色平场校正最大亮<E5A4A7>?
	u32 gray_maxbright;	   //灰度平场校正最大亮<E5A4A7>?
	u32 speedmode;		   //速度模式 G100 0->70 1->80 2->90 3->100 G200 0->100 1->110 2->120 3->130
	u16 Vid;			   //USB vid 
	u16 Pid;			   //USB Pid
	std::uint32_t chu_motor_speed_200; // G100 G200 出纸电机速度
	std::uint32_t chu_motor_speed_300; // G100 G200 出纸电机速度
	std::uint32_t chu_motor_speed_600; // G100 G200 出纸电机速度
};

enum TwSS : unsigned short
{
	None 		= 0,
	A4Letter 	= 1,
	A4 			= 1,
	B5Letter 	= 2,
	JISB5 		= 2,
	B5 			= 2,
	USLetter 	= 3,
	USLegal 	= 4,
	A5 			= 5,
	B4 			= 6,
	ISOB4 		= 6,
	B6 			= 7,
	ISOB6 		= 7,
	USLedger 	= 9,
	USExecutive = 10,
	A3 			= 11,
	B3 			= 12,
	ISOB3 		= 12,
	A6 			= 13,
	C4 			= 14,
	C5 			= 15,
	C6 			= 16,
	_4A0 		= 17,
	_2A0 		= 18,
	A0 			= 19,
	A1 			= 20,
	A2 			= 21,
	A7 			= 22,
	A8 			= 23,
	A9 			= 24,
	A10 		= 25,
	ISOB0 		= 26,
	ISOB1 		= 27,
	ISOB2 		= 28,
	ISOB5 		= 29,
	ISOB7 		= 30,
	ISOB8 		= 31,
	ISOB9 		= 32,
	ISOB10 		= 33,
	JISB0 		= 34,
	JISB1 		= 35,
	JISB2 		= 36,
	JISB3 		= 37,
	JISB4 		= 38,
	JISB6 		= 39,
	JISB7 		= 40,
	JISB8 		= 41,
	JISB9 		= 42,
	JISB10 		= 43,
	C0 			= 44,
	C1 			= 45,
	C2 			= 46,
	C3 			= 47,
	C7 			= 48,
	C8 			= 49,
	C9 			= 50,
	C10 		= 51,
	USStatement = 52,
	BusinessCard = 53,
	MaxSize 	= 54,
	K8 			= 0x81,
	K16 		= 0x82,
	Trigeminy 	= 0x83,
};

enum class PaperSize
{
	G400_A3 = 0,
	G400_A4,
	G400_A4R,
	G400_A5,
	G400_A5R,
	G400_A6,
	G400_A6R,
	G400_B4,
	G400_B5,
	G400_B5R,
	G400_B6,
	G400_B6R,
	G400_DOUBLELETTER,
	G400_LEGAL,
	G400_LETTER,
	G400_LETTERR,
	G400_LONGLETTER 	= 16,
	G400_MAXSIZE 		= 17,
	G400_AUTO 			= 16,
	G400_MAXAUTO 		= 18
};

struct HGSize
{
	unsigned int width;
	unsigned int height;

	bool operator<(HGSize const &right) const
	{
		if (width < right.width && height < right.height)
			return true;
		return false;
	}
};

//usb int 端点 返回消息的生产<E7949F>?
enum HGType
{
	MtBoard = 1,
	FPGA,
	V4L2,
	IMG,
	AutoCorrect,
	STOPSCAN,
	CMD_OUT,
};

//usb int 端点通信结构<E7BB93>?
struct HGIntInfo
{
	HGType 			From;
	unsigned int 	Code;
	unsigned int 	Img_Index;
	img_status 		Img_Status;
};

enum SpeedMode
{
	PPM70 	= 70,
	PPM80 	= 80,
	PPM90 	= 90,
	PPM100 	= 100,
	PPM110 	= 110,
	PPM120 	= 120,
	PPM130 	= 130
};

typedef struct frame_data_info
{
	unsigned int offset;
	unsigned int total;
	unsigned int frame_count;
	unsigned int img_w;
	unsigned int img_h;
	void* pdata;
	bool empty()
	{
		return (offset *total*frame_count*img_w*img_h== 0) || (pdata == nullptr);
	}
	std::string to_str()
	{
		return "offset = " + std::to_string(offset)+ " total = "+ std::to_string(total) + " frame_count = "+ std::to_string(frame_count) +
		" img_w = "+ std::to_string(img_w) + " img_h = "+ std::to_string(img_h);
	}
}; 

typedef struct
{
	u32 colorSp_200;
	u32 graySp_200;
	u32 colorSp_300;
	u32 graySp_300;
	u32 colorSp_600;
	u32 graySp_600;
	u32 motorSpeed;
} DunNanCisSp;

typedef struct
{
	u32 colorSp;
	u32 graySp;
	u32 motorSpeed;
} CisSp;


static std::map<SpeedMode, DunNanCisSp> cameraparmSp = {
#ifdef G100
	{PPM70, {.colorSp_200 = 1150 , .graySp_200= 3450,.colorSp_300 = 1207 ,.graySp_300 = 3621,.colorSp_600 = 1822 ,.graySp_600 = 5466 , 1}},
	{PPM80, {.colorSp_200 = 1150 , .graySp_200= 3450,.colorSp_300 = 1207 ,.graySp_300 = 3621,.colorSp_600 = 1822 ,.graySp_600 = 5466 , 2}},
	{PPM90, {.colorSp_200 = 944 , .graySp_200= 2834,.colorSp_300 = 1019 ,.graySp_300 = 3059,.colorSp_600 = 1822 ,.graySp_600 = 5466 , 0}},
	{PPM100, {.colorSp_200 = 847 , .graySp_200= 2541,.colorSp_300 = 875 ,.graySp_300 = 2626,.colorSp_600 = 1822 ,.graySp_600 = 5466 , 4}},//G100 3399 暂无100 ppm
	{PPM110, {.colorSp_200 = 847 , .graySp_200= 2541,.colorSp_300 = 875 ,.graySp_300 = 2626,.colorSp_600 = 1822 ,.graySp_600 = 5466 , 3}},
#else
	{PPM90, {.colorSp_200 = 816 , .graySp_200= 2450,.colorSp_300 = 878 ,.graySp_300 = 2637,.colorSp_600 = 1531 ,.graySp_600 = 4595 , 4}},
	{PPM100, {.colorSp_200 = 816 , .graySp_200= 2450,.colorSp_300 = 878 ,.graySp_300 = 2637,.colorSp_600 = 1531 ,.graySp_600 = 4595 , 0}},
	{PPM110, {.colorSp_200 = 816 , .graySp_200= 2450,.colorSp_300 = 878 ,.graySp_300 = 2637,.colorSp_600 = 1531 ,.graySp_600 = 4595 , 1}},
	{PPM120, {.colorSp_200 = 816 , .graySp_200= 2450,.colorSp_300 = 878 ,.graySp_300 = 2637,.colorSp_600 = 1531 ,.graySp_600 = 4595 , 3}},
	{PPM130, {.colorSp_200 = 816 , .graySp_200= 2450,.colorSp_300 = 878 ,.graySp_300 = 2637,.colorSp_600 = 1531 ,.graySp_600 = 4595 , 2}} //默认 140
#endif
};

//.colorSp_200 = 2606 , .graySp_200= 7818,.colorSp_300 = 2804 ,.graySp_300 = 8412,.colorSp_600 = 3405 ,.graySp_600 = 10215
static std::map<SpeedMode, DunNanCisSp> cameraparmSp_8478 = {
#ifdef G100
	{PPM70,  {.colorSp_200 = 1150 , .graySp_200= 3450,.colorSp_300 = 1207 ,.graySp_300 = 3621,.colorSp_600 = 1822 ,.graySp_600 = 5466 , 1}},
	{PPM80,  {.colorSp_200 = 1150 , .graySp_200= 3450,.colorSp_300 = 1207 ,.graySp_300 = 3621,.colorSp_600 = 1822 ,.graySp_600 = 5466 , 2}},
	{PPM90,  {.colorSp_200 = 944 ,  .graySp_200= 2834,.colorSp_300 = 1019 ,.graySp_300 = 3059,.colorSp_600 = 1822 ,.graySp_600 = 5466 , 0}},
	{PPM100, {.colorSp_200 = 847 ,  .graySp_200= 2541,.colorSp_300 = 875 , .graySp_300 = 2626,.colorSp_600 = 1822 ,.graySp_600 = 5466 , 4}},//G100 3399 暂无100 ppm
	{PPM110, {.colorSp_200 = 847 ,  .graySp_200= 2541,.colorSp_300 = 875 , .graySp_300 = 2626,.colorSp_600 = 1822 ,.graySp_600 = 5466 , 3}},
#else
	{PPM90,  {.colorSp_200 = 7818 , .graySp_200= 7818,.colorSp_300 = 8412 ,.graySp_300 = 8412,.colorSp_600 = 10215 ,.graySp_600 = 10215 , 4}},
	{PPM100, {.colorSp_200 = 7818 , .graySp_200= 7818,.colorSp_300 = 8412 ,.graySp_300 = 8412,.colorSp_600 = 10215 ,.graySp_600 = 10215 , 0}},
	{PPM110, {.colorSp_200 = 7818 , .graySp_200= 7818,.colorSp_300 = 8412 ,.graySp_300 = 8412,.colorSp_600 = 10215 ,.graySp_600 = 10215 , 1}},
	{PPM120, {.colorSp_200 = 7818 , .graySp_200= 7818,.colorSp_300 = 8412 ,.graySp_300 = 8412,.colorSp_600 = 10215 ,.graySp_600 = 10215 , 3}},
	{PPM130, {.colorSp_200 = 7818 , .graySp_200= 7818,.colorSp_300 = 8412 ,.graySp_300 = 8412,.colorSp_600 = 10215 ,.graySp_600 = 10215 , 2}} //默认 140
#endif
};


static std::map<SpeedMode,int> anlogic_freq = {
#ifdef G100
	{PPM70,  1},
	{PPM80,  2},
	{PPM90,  3},
	{PPM110, 4},
#else
	{PPM100, 1},
	{PPM110, 2},
	{PPM120, 3},
	{PPM130, 4} 
#endif
};

static std::map<SpeedMode, CisSp> scannerSp = {
#ifdef G100
	{PPM70,  {0x42d, 0xc88, 1}},
	{PPM80,  {0x37f, 0xa7f, 2}},
	{PPM90,  {0x2B6, 0x822, 0}},
	{PPM100, {0x27C, 0x775, 4}},//G100 3399 暂无100 ppm
	{PPM110, {0x24e, 0x706, 3}},
#else
	{PPM90,  {0x27C, 0x775, 4}},
	{PPM100, {0x27C, 0x775, 0}},
	{PPM110, {0x27C, 0x775, 1}},
	{PPM120, {0x27C, 0x775, 3}},
	{PPM130, {0x27C, 0x775, 2}} //默认 140
#endif
};

static std::map<PaperSize, HGSize> papersMap = {
	{PaperSize::G400_A3, 			{1632, 10800}},
	{PaperSize::G400_A4, 			{1632, 8100}},
	{PaperSize::G400_A4R, 			{1632, 6000}},
	{PaperSize::G400_A5, 			{1632, 6000}},
	{PaperSize::G400_A5R,			{1632, 6000}},
	{PaperSize::G400_A6, 			{1632, 6000}},
	{PaperSize::G400_A6R, 			{1632, 6000}},
	{PaperSize::G400_B4, 			{1632, 10800}},
	{PaperSize::G400_B5, 			{1632, 8100}},
	{PaperSize::G400_B5R, 			{1632, 6000}},
	{PaperSize::G400_B6, 			{1632, 6000}},
	{PaperSize::G400_DOUBLELETTER, 	{1632, 10800}},
	{PaperSize::G400_B6R, 			{1632, 6000}},
	{PaperSize::G400_LEGAL, 		{1632, 10800}},
	{PaperSize::G400_LETTER, 		{1632, 8100}},
	{PaperSize::G400_LETTERR, 		{1632, 10800}},
	{PaperSize::G400_MAXSIZE, 		{1632, 16002}},
	{PaperSize::G400_AUTO, 			{1632, 10800}},
	{PaperSize::G400_MAXAUTO, 		{1632, 16002}},
};

// pair<papertype,height> unit:mm
static std::map<PaperSize,int> paperHeight={
	{PaperSize::G400_A3, 			 475},
	{PaperSize::G400_A4, 			 337},
	{PaperSize::G400_A4R, 			 240},
	{PaperSize::G400_A5, 			 247},
	{PaperSize::G400_A5R, 			 178},
	{PaperSize::G400_A6, 			 178},
	{PaperSize::G400_A6R, 			 135},
	{PaperSize::G400_B4,  			 383},
	{PaperSize::G400_B5,  			 300},
	{PaperSize::G400_B5R,  			 226},
	{PaperSize::G400_B6,  			 226},
	{PaperSize::G400_DOUBLELETTER, 	 500},
	{PaperSize::G400_B6R,  			 175},
	{PaperSize::G400_LEGAL,  		 386},
	{PaperSize::G400_LETTER,  		 339},
	{PaperSize::G400_LETTERR,  		 276},
	{PaperSize::G400_MAXSIZE,  		1040},//300 dpi  max heigth 690
	{PaperSize::G400_AUTO,  		1040},//300 dpi  max heigth
	{PaperSize::G400_MAXAUTO,  		1040}//300 dpi  max heigth 
};

enum Scanner_Reg_Defs
{
	SR_CMD,
	SR_STATUS,
	SR_SCAN_COUNT,
	SR_OS,
	SR_SENSORS,
	SR_MOTOR,
	SR_IM_TYPE,
	SR_IM_COUNT,
	SR_IM_TX,
	SR_IM_FRONT_SIZE,
	SR_IM_CLEAR,
	SR_IM_TXING,
	SR_IM_POP,
	SR_IM_ABORT,
	SR_COUNT,
	SR_CONFIG_SCAN_PARAM,
	SR_GET_FWVERSION,
	SR_SET_FWERSION,
	SR_GET_SERIALNUM,
	SR_SET_SERIALNUM,
	SR_CONFIF_IMGPROCPARAM,
	SC_AUTOCORRECT,
	SC_GET_CORRECT_PARAM,
	SC_SET_CORRECT_PARAM,
	SR_GET_H_RATIO,
	SR_SET_H_RATIO,
	SR_GET_V_RATIO,
	SR_SET_V_RATIO,
	SR_GET_SERIAL_LEN,
	SR_GET_GRAY_SP,
	SR_GET_COLOR_SP,
	SR_SET_GRAY_SP,
	SR_SET_COLOR_SP,
	SR_SET_SLEEPTIME,
	SR_GET_SLEEPTIME,
	SR_GET_SLEEP_STAUTUS,
	SR_GET_IMAGEPROCESSDONE,
	SR_GET_KEEP_LAST_PAPER,
	SR_GET_PAPERON,
	SR_SET_SPEEDMODE,
	SR_GET_SPEEDMODE,
	SR_GET_JOSN_SIZE,
	SR_GET_JSON,
	SR_SET_JSON_PATH,
	SR_SET_JSON,
	SR_GET_FILE_POS,
	SR_SET_FILE_POS,
	SR_NOTIFY_SLEEP,
	SR_GET_FEEDMODE,
	SR_SET_FEEDMODE,
	SR_GET_AUTOMATICCONTROLFEEDMODE_ENABLE,
	SR_SET_AUTOMATICCONTROLFEEDMODE_ENABLE,
	SR_GET_AUTOMATICCONTROLFEEDMODE_THRESHOLD,
	SR_SET_AUTOMATICCONTROLFEEDMODE_THRESHOLD,
	SR_GET_TRAYPOSITION,
	SR_SET_TRAYPOSITION,
	SR_GET_LOCK_STATES,
	SR_SET_LOCK_STATES,
	SR_GET_TOKEN,
	SR_SET_TOKEN,
	SR_GET_TOKEN_LENGHT,
	SR_DECODE_TOKEN,
	SR_CLEAN_PAPER_ROAD,
	SR_EXECUTE_CMD,
	SR_EXECUTE_CMD_OUT_LENGHT,
	SR_GET_EXECUTE_CMD_OUT,
	SR_SET_Corrective_Restoration,
	SR_BACKUP_RESTORES_HUAGODIR,
	SR_SINGLE_CORRECT_MODE,
	SR_GET_DAIL_CODE,
	SR_GET_COMB_Coefficients_Lenght,
	SR_GET_COMB_Coefficients,
	SR_SET_COMB_Coefficients,
	SR_GET_CUO_ERROR = 0x50,
	SR_GET_DOU_ERROR,
	SR_GET_JAM_ERROR,
	SR_GET_SCANN_NUM,
	SR_CLR_ROLLER_NUM,
	SR_GET_ROLLER_NUM,
	SR_CLR_SCANN_NUM,
	SR_GET_H_200_RATIO,  //非敦南cis需返回false
	SR_SET_H_200_RATIO,
	SR_GET_V_200_RATIO,
	SR_SET_V_200_RATIO,
	SR_GET_H_300_RATIO,
	SR_SET_H_300_RATIO,
	SR_GET_V_300_RATIO,
	SR_SET_V_300_RATIO,
	SR_GET_H_600_RATIO,
	SR_SET_H_600_RATIO,
	SR_GET_V_600_RATIO,
	SR_SET_V_600_RATIO,
	SR_SET_GRAYCORRECT_MODE,
	SR_GET_GRAYCORRECT_MODE,
	SR_GET_ARM_DATETIME,
	SR_GET_ARM_DATETIME_LENGHT,
	SR_SET_ARM_DATETIME,
	SR_SET_SENSOR_CONFIG,
	SR_GET_SENSOR_CONFIG,
	SR_SET_LCD_LANGUAGE,
	SR_GET_LCD_LANGUAGE,
	SR_GET_SENSOR_CONFIG_LENGHT,
	SR_GET_ULTRASONIC_VERSION,
	SR_UPDATA_START = 0x100,
	SR_UPDATA_STAUTUS = 0x101,
	SR_UPDATA_MD5_RELUST = 0x102,
	SR_UPDATA_RECOVERY = 0x103,
	SR_UPDATA_REBOOT = 0x104,
	SR_POWEROFF = 0x105,
	SR_REBOOT = 0x106,
	SR_FLAT_CLR_MAX_BRIGHT,
	SR_FLAT_GRAY_MAX_BRIGHT,
	SR_KERNEL_VERSION_INFO_LENGTH,
	SR_GET_KERNEL_VERSION,
	SR_GET_MBSTATUS,
	SR_GET_IPADDR_LENGHT = 0x200,
	SR_GET_MACADDR,
	SR_GET_IPADDR,
	SR_GET_MBVERSION_LENGHT,
	SR_GET_MBVERSION,
	SR_GET_USBVIDPID,
	SR_SET_USBVIDPID,
	SR_SET_STARTBACKUP,//开始备份
	SR_GET_BACKUPSTATUS//备份状态
};

typedef union Ctrol_Description{
	std::uint32_t value;
	struct{
		std::uint32_t direction : 1;
		std::uint32_t unused : 31;
	}Param;
}CtrolDescription; 

enum Updata_Stautus
{
	Start_updata,
	Download_file,
	Download_file_error,
	Download_file_finish,
	MD5_Reovery,
	MD5_Rboot,
	MD5_Error,
	Reboot
};

enum Scanner_Cmd_Defs
{
	SC_START,
	SC_STOP,
	SC_CLEAR,
	SC_COUNT
};

enum HGScanSide
{
	Duplex,
	Single,
	DisCardBlankNormal,
	DisCardBlacnkVince,
	Flod
};

enum class HGRotate
{
	Rot_0,
	Rot_90,
	Rot_180,
	Rot_270,
	Rot_auto
};

typedef union USBVIDPID
{
	struct{
		unsigned short VID;
		unsigned short PID;
	}param;
	unsigned int value;
};

typedef union HG_ImgProcParms
{
	unsigned int value;
	struct
	{
		u32 papertype : 5;
		u32 scanside : 3;
		u32 res : 10;
		u32 rotate : 2;
		u32 autodescrew : 1;
		u32 fillbackground : 1;
		u32 filter : 4;
		u32 enhancecolor : 2;
		u32 fillhole : 1;
		u32 reversed : 3;
	} imgprocparams;
} HGImgProcParms;

///用于CIS 自动校正参数保存
typedef struct
{
	u32 gainF[6];
	u32 gainB[6];
	u32 offsetsF[6];
	u32 offsetsB[6];
	u32 expF[3];
	u32 expB[3];
	u32 sp;
} HGCISConfig;

typedef struct
{
	HGCISConfig colorCorrect;
	HGCISConfig color;
	HGCISConfig grayCorrect;
	HGCISConfig gray;
} HGCorrectConfigs;

enum class CISVendor
{
	CIS_UNKNOWUN,
	HUALIN_CIS_V0,
	DUNNAN_CIS_V0
};

#define STR_CORRECTCOLOR CorrectColor
#define STR_COLOR Color
#define STR_CORRECTGRAY CorrectGray
#define STR_GRAY Gray

#define STR_GAINF GainF
#define STR_GAINB GainB
#define STR_EXPF ExpF
#define STR_EXPB ExpB
#define STR_OFFSETF OffsetF
#define STR_OFFSETB OffsetB
#define STR_SP Sp

#define STR(str) #str
#define STRCON(str1, str2) STR(str1) \
STR(str2)

#define LUT_COLOR_BLACK_PATH 			"/usr/local/huago/lut_0.bmp"
#define LUT_COLOR_WHITE_PATH 			"/usr/local/huago/lut_1.bmp"
#define LUT_GRAY_BLACK_PATH 			"/usr/local/huago/lut_2.bmp"
#define LUT_GRAY_WHITE_PATH 			"/usr/local/huago/lut_3.bmp"
#define LUT_COLOR_LUT_PATH 				"/usr/local/huago/color_lut.bmp"
#define LUT_GRAY_LUT_PATH 				"/usr/local/huago/gray_lut.bmp"

#define IMAGE_COLOR 1
#define IMAGE_GRAY 0

#define JSON_CORRECTFILE_PATH 			"/usr/local/huago/cisconfig.json"
#define JSON_CORRECTDIR_PATH 			"/usr/local/huago"
#define JSON_SCANNER_INFO_DIR 			"/usr/local/huago"
#define JSON_SCANNER_INFO_FILE 			"/usr/local/huago/scannerinfo.json"

#define S_INFO_TOTALSCANNED 			"TotalScanned"
#define S_INFO_ROLLERNUM 				"RollerNum"
#define S_INFO_HRATIO 					"HRatio"
#define S_INFO_VRATIO 					"VRatio"
#define S_GRAY_SP 						"GraySp"
#define S_COLOR_SP 						"ColorSp"
#define S_INFO_SLEEPTIME 				"Sleeptime"
#define S_INFO_JAMNUM 					"JamInNum"
#define S_INFO_FEEDERROR 				"FeedError"
#define S_INFO_DOUNUM 					"DoubleNum"
#define S_INFO_SCANSESSIONCOUNT 		"ScanTimes"
#define S_INFO_SERIALNUM 				"SerialNum"
#define S_INFO_TOKEN 					"ScannerToken"
#define S_INFO_CLR_MAXBRT 				"FlatClrMaxBrt"
#define S_INFO_GRAY_MAXBRT 				"FlatGrayMaxBrt"
#define S_INFO_SPEEDMODE 				"SpeedMode"
#define S_INFO_VID 						"VID"
#define S_INFO_PID 						"PID"
#define S_INFO_CHUZHI_MOTOR_SPEED_200 	"Chu_Motor_Speed_200"
#define S_INFO_CHUZHI_MOTOR_SPEED_300 	"Chu_Motor_Speed_300"
#define S_INFO_CHUZHI_MOTOR_SPEED_600 	"Chu_Motor_Speed_600"

#pragma pack(push)
#pragma pack(4)
typedef struct tagFillHole
{
	uint8_t 	is_fillhole;
	int 		fillholeratio;
} FillHole;

typedef struct tagDetachNoise
{
	uint8_t 	is_detachnoise;
	int			detachnoise;
} DetachNoise;

enum LowPowerMode : unsigned int
{
	Min_None = 0,
	Min_5,
	Min_10,
	Min_20,
	Min_30,
	Min_60,
	Min_120,
	Min_240
};

typedef struct tagHARDWAREPARAMS
{
	byte capturepixtype;
	byte en_doublefeed;
	byte en_stapledetect;
	byte en_skrewdetect;
	byte skrewdetectlevel;
	LowPowerMode lowpowermode;
#ifdef UV
	byte en_uv;
#endif
} HardwareCaps;

typedef struct Scan_Rect
{
	int width;
	int height;
	int x;
	int y;
} ScanRect;

enum PaperAlign : unsigned char
{
	Rot0 = 0,
	Rot270 = 3,
	AutoTextOrientation = 5
};

typedef enum Enchace_Color : short
{
	Enhance_None = 0,
	Enhance_Red,
	Enhance_Green,
	Enhance_Blue
} EnchaceColor;

typedef enum SharpenBlur : short
{
	Sharpen_None,
	Sharpen_Normal,
	Sharpen_More,
	Sharpen_Blur,
	Sharpen_Blur_More
} SharpenBlur;

typedef struct tagCrop_Rect
{
    int enable;
    int x;				/*****自定义裁切区域左上角x坐标*/
    int y;				/*****自定义裁切区域左上角y坐标*/
    int width;			/*****自定义裁切区域宽<E59F9F>?******/
    int height;			/*****自定义裁切区域高<E59F9F>?******/
}CropRect;

typedef enum tagMulti_Output {
    Unused = -1,
    All,
    ColorGray,
    ColorBw,
    GrayBw
}MultiOutput;

typedef struct tagSkew_Detection {
    int enable;
    int level;
}SkewDetection;

typedef struct tagHhardware_Params_3399
{
    int             capturepixtype;
    int             doubleFeedDetection;
    int             bindingDetection;
    int             sizeDetection;
    SkewDetection   skewDetection;
}HardwareCaps_3399;

struct GScanCap
{
	uint8_t 		papertype; 						
	PaperAlign 		paperAlign; 					
	uint8_t 		en_sizecheck; 					
	float 			imageRotateDegree;				
	uint8_t 		is_duplex;						
	uint8_t 		en_fold;						
	int 			pixtype;							
	int 			automaticcolor;						
	int 			automaticcolortype; 			
	//ScanRect         scanrect;
	float 			resolution_dst; 					
	float 			resolution_native;				
	float 			gamma;							
	float 			contrast;							
	float 			brightness;						
	float 			threshold;					
	uint8_t 		is_autocontrast;				
	uint8_t 		is_autocrop;				
	uint8_t 		is_autodiscradblank_normal; 	
	int 			discardblank_percent;			
	uint8_t			is_autodiscradblank_vince;		
	uint8_t 		is_switchfrontback;				
	uint8_t 		autodescrew;				
	uint8_t 		multi_output_red;				
	uint8_t 		hsvcorrect;						
	uint8_t 		filter;							
	uint8_t 		sharpen;						
	uint8_t 		enhance_color;					
	uint8_t 		fillbackground;				
	bool 			is_convex;						
	int 			noise;								
	int 			indent;								
	int 			AutoCrop_threshold;					
	unsigned short 	scannum;					
	uint8_t 		is_backrotate180;				
	uint8_t 		is_dogeardetection; 			
	HardwareCaps 	hardwarecaps;				
	FillHole 		fillhole;						
	DetachNoise 	detachnoise; 				
	uint8_t 		is_autotext;	 				
	bool 			isfillcolor;						
	int 			refuseInflow;						
	int 			colorCorrection;					
	int 			removeMorr;						
    int 			errorExtention;					
	int 			textureRemove;							
	int 			splitImage;									
	CropRect 		cropRect;						
	MultiOutput 	multiOutput;			
	bool 			normalCrop;						
	uint32_t 		dogeardistabce;				
	bool 			fadeback;							
	int 			fadebackrange;			
	bool 			isuploadexceptionimage;	
	int 			fillholeratio_up;
	int 			fillholeratio_down;		
	int 			fillholeratio_left;
	int 			fillholeratio_right;
	std::uint8_t 	fold_concatmode;					/*拼接模式*/
	int 			HsvFilterType;						/**< 答题卡留红除杂色功能类型 暂定0 为关闭；1为留红除杂色>*/
	bool 			is_colorcast;						/**< 色偏校正>*/
	int 			discare_edge;						/**< 跳过空白页边缘缩进>*/
	int 			discare_dilate;						/**< 调过空白页纸张杂点阈值>*/
	double 			discare_meanth;						/**< 调过空白页文稿底色阈值>*/
	bool 			en_contaminationdetection; 			/**< 脏污检测使能>*/
	bool 			detect_size_discard_blank;			/**< 基于压缩图像大小跳过空白页使能>*/
	uint32_t 		refuseInflow_level;					/**< 防止渗透等级>*/
	uint32_t 		maxszie_sanp_height;				/**< 最大幅面采集高度>*/
	uint32_t 		reserve[1024]; 						/**< 预留4096字节做协议扩展*/				
};
#pragma pack(pop)