2022-05-03 03:56:07 +00:00
|
|
|
|
#include "hg_scanner_239.h"
|
2022-05-30 03:04:26 +00:00
|
|
|
|
#include "../wrapper/hg_log.h"
|
2022-05-03 03:56:07 +00:00
|
|
|
|
#include "filetools.h"
|
|
|
|
|
|
|
|
|
|
#ifdef WIN32
|
|
|
|
|
#include "scanner_manager.h"
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#include <map>
|
|
|
|
|
|
|
|
|
|
//#define SAVE_TO_FILE
|
|
|
|
|
|
|
|
|
|
#define USB_REQ_GET_FPGA_REGS 0x40
|
|
|
|
|
#define USB_REQ_SET_FPGA_REGS 0x41
|
|
|
|
|
#define USB_REQ_GET_MOTOR_REGS 0x42
|
|
|
|
|
#define USB_REQ_SET_MOTOR_REGS 0x43
|
|
|
|
|
|
|
|
|
|
#define USB_REQ_GET_DEV_STATUS 0x60
|
|
|
|
|
#define USB_REQ_GET_DEV_CONFIGURATION 0x61
|
|
|
|
|
#define USB_REQ_SET_DEV_CONFIGURATION 0x62
|
|
|
|
|
#define USB_REQ_GET_DEV_REGS 0x63
|
|
|
|
|
#define USB_REQ_SET_DEV_REGS 0x64
|
|
|
|
|
|
|
|
|
|
|
2022-05-23 08:54:55 +00:00
|
|
|
|
static std::string jsontext("{\"device_type\":\"G239\",\"option_count\":60,\"1\":{\"category\":\"base\",\"name\":\"cfg-1\",\"title\":\"\\u6062\\u590d\\u9ed8\\u8ba4\\u8bbe\\u7f6e\",\"desc\":\"\\u6062\\u590d\\u9ed8\\u8ba4\\u8bbe\\u7f6e\",\"type\":\"button\",\"cur\":\"button\",\"default\":\"button\",\"size\":0},\"2\":{\"category\":\"advanced\",\"name\":\"cfg-2\",\"title\":\"\\u5e2e\\u52a9\",\"desc\":\"\\u663e\\u793a\\u8f6f\\u4ef6\\u5e2e\\u52a9\\u6587\\u6863\",\"type\":\"button\",\"cur\":\"true\",\"default\":\"true\",\"size\":4},\"3\":{\"category\":\"base\",\"name\":\"grp-1\",\"title\":\"\\u57fa\\u672c\\u8bbe\\u7f6e\",\"type\":\"group\"},\"4\":{\"category\":\"base\",\"name\":\"cfg-4\",\"title\":\"\\u591a\\u6d41\\u8f93\\u51fa\",\"desc\":\"\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4},\"5\":{\"category\":\"base\",\"name\":\"cfg-5\",\"title\":\"\\u591a\\u6d41\\u8f93\\u51fa\\u7c7b\\u578b\",\"desc\":\"\",\"type\":\"string\",\"cur\":\"\\u65e0\",\"default\":\"\\u65e0\",\"size\":32,\"range\":[\"\\u5f69\\u8272+\\u7070\\u5ea6+\\u9ed1\\u767d\",\"\\u5f69\\u8272+\\u7070\\u5ea6\",\"\\u5f69\\u8272+\\u9ed1\\u767d\",\"\\u7070\\u5ea6+\\u9ed1\\u767d\"],\"depend_or\":[\"4==true\"]},\"6\":{\"category\":\"base\",\"name\":\"cfg-6\",\"title\":\"\\u989c\\u8272\\u6a21\\u5f0f\",\"desc\":\"\\u8bbe\\u7f6e\\u989c\\u8272\\u4f4d\\u6df1\",\"type\":\"string\",\"cur\":\"24\\u4f4d\\u5f69\\u8272\",\"default\":\"24\\u4f4d\\u5f69\\u8272\",\"size\":32,\"range\":[\"24\\u4f4d\\u5f69\\u8272\",\"256\\u7ea7\\u7070\\u5ea6\",\"\\u9ed1\\u767d\",\"\\u989c\\u8272\\u81ea\\u52a8\\u8bc6\\u522b\"],\"depend_or\":[\"4!=true\"]},\"7\":{\"category\":\"base\",\"name\":\"cfg-7\",\"title\":\"\\u7070\\u5ea6\\u6216\\u9ed1\\u767d\\u56fe\\u50cf - \\u9664\\u8272\",\"desc\":\"\\u9664\\u53bb\\u56fe\\u50cf\\u5f69\\u8272\",\"type\":\"string\",\"cur\":\"\\u4e0d\\u9664\\u8272\",\"default\":\"\\u4e0d\\u9664\\u8272\",\"size\":24,\"range\":[\"\\u4e0d\\u9664\\u8272\",\"\\u9664\\u7ea2\\u8272\",\"\\u9664\\u7eff\\u8272\",\"\\u9664\\u84dd\\u8272\",\"\\u7ea2\\u8272\\u589e\\u5f3a\",\"\\u7eff\\u8272\\u589e\\u5f3a\",\"\\u84dd\\u8272\\u589e\\u5f3a\"],\"depend_and\":[\"4!=true\",\"6!=24\\u4f4d\\u5f69\\u8272\",\"6!=\\u989c\\u8272\\u81ea\\u52a8\\u8bc6\\u522b\"]},\"8\":{\"category\":\"base\",\"name\":\"cfg-8\",\"title\":\"24\\u4f4d\\u5f69\\u8272\\u56fe\\u50cf - \\u591a\\u6d41\\u8f93\\u51fa\\u9664\\u7ea2\",\"desc\":\"\\u591a\\u901a\\u9053\\u8f93\\u51fa\\u4e2d\\uff0c\\u53bb\\u9664\\u7ea2\\u8272\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_and\":[\"4!=true\",\"6!=256\\u7ea7\\u7070\\u5ea6\",\"6!=\\u9ed1\\u767d\",\"6!=\\u989c\\u8272\\u81ea\\u52a8\\u8bc6\\u522b\"]},\"9\":{\"category\":\"base\",\"name\":\"cfg-9\",\"title\":\"24\\u4f4d\\u5f69\\u8272\\u56fe\\u50cf - \\u7b54\\u9898\\u5361\\u9664\\u7ea2\",\"desc\":\"\\u7b54\\u9898\\u5361\\u626b\\u63cf\\u4e2d\\u53bb\\u9664\\u7ea2\\u8272\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_and\":[\"4!=true\",\"6!=256\\u7ea7\\u7070\\u5ea6\",\"6!=\\u9ed1\\u767d\",\"6!=\\u989c\\u8272\\u81ea\\u52a8\\u8bc6\\u522b\"]},\"10\":{\"category\":\"base\",\"name\":\"cfg-10\",\"title\":\"\\u80cc\\u666f\\u79fb\\u9664\",\"desc\":\"\\u79fb\\u9664\\u5f69\\u8272\\u56fe\\u50cf\\u80cc\\u666f\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_and\":[\"4!=true\",\"6!=256\\u7ea7\\u7070\\u5ea6\",\"6!=\\u9ed1\\u767d\",\"6!=\\u989c\\u8272\\u81ea\\u52a8\\u8bc6\\u522b\"]},\"11\":{\"category\":\"base\",\"name\":\"cfg-11\",\"title\":\" \\u80cc\\u666f\\u8272\\u5f69\\u6d6e\\u52a8\\u8303\\u56f4\",\"desc\":\"\\u8bbe\\u5b9a\\u80cc\\u666f\\u8272\\u5f69\\u7684\\u6d6e\\u52a8\\u8303\\u56f4\\uff0c\\u5728\\u8be5\\u8303\\u56f4\\u5185\\u7684\\u90fd\\u5f53\\u4f5c\\u80cc\\u666f\\u79fb\\u9664\",\"type\":\"int\",\"cur\":20,\"default\":20,\"size\":4,\"range\":{\"min\":1,\"max\":128},\"depend_or\":[\"10==true\"]},\"12\":{\"category\":\"base\",\"name\":\"cfg-12\",\"title\":\"\\u9510\\u5316\\u4e0e\\u6a21\\u7cca\",\"desc\":\"\\u9510\\u5316\\u4e0e\\u6a21\\u7cca\",\"type\":\"string\",\"cur\":\"\\u65e0\",\"default\":\"\\u65e0\",\"size\":24,\"
|
2022-05-03 03:56:07 +00:00
|
|
|
|
enum hg_239_setting_item
|
|
|
|
|
{
|
|
|
|
|
HG_239_SETTING_RESTORE = 1, // 恢复默认设置
|
|
|
|
|
HG_239_SETTING_HELP, // 帮助
|
|
|
|
|
|
|
|
|
|
HG__239_SETTING_GROUP_1,
|
|
|
|
|
|
|
|
|
|
HG_239_SETTING_COLOR_MODE, // 颜色模式
|
|
|
|
|
|
|
|
|
|
HG_239_SETTING_ERASE_COLOR, // 除色
|
|
|
|
|
HG_239_SETTING_ERASE_MULTI_RED, // 多流输出除红
|
|
|
|
|
HG_239_SETTING_ERASE_ANSWER_RED, // 答题卡除红
|
|
|
|
|
HG_239_SETTING_ERASE_BACKGROUND, // 移除背景
|
|
|
|
|
HG_239_SETTING_ERASE_BKG_RANGE, // 移除背景范围
|
|
|
|
|
HG_239_SETTING_NOISE, // 黑白图像噪点优化
|
|
|
|
|
HG_239_SETTING_NOISE_SIZE, // 噪点优化尺寸
|
|
|
|
|
HG_239_SETTING_PAPER_SIZE, // 纸张尺寸
|
2022-05-07 07:39:48 +00:00
|
|
|
|
|
|
|
|
|
HG_239_SETTING_CUSTOM_AREA, // 自定义扫描区域
|
|
|
|
|
HG_239_SETTING_CUSTOM_AREA_LEFT, // 扫描区域左侧(mm)
|
|
|
|
|
HG_239_SETTING_CUSTOM_AREA_RIGHT, // 扫描区域右侧(mm)
|
|
|
|
|
HG_239_SETTING_CUSTOM_AREA_TOP, // 扫描区域上侧(mm)
|
|
|
|
|
HG_239_SETTING_CUSTOM_AREA_BOTTOM, // 扫描区域下侧(mm)
|
|
|
|
|
|
2022-05-03 03:56:07 +00:00
|
|
|
|
HG_239_SETTING_PAPER_SIZE_CHECK, // 尺寸检测
|
|
|
|
|
HG_239_SETTING_PAGE, // 扫描页面
|
|
|
|
|
HG_239_SETTING_SKIP_NILL, // 跳过空白页灵敏度
|
|
|
|
|
HG_239_SETTING_RESOLUTION, // 分辨率
|
2022-05-09 07:02:00 +00:00
|
|
|
|
HG_239_SETTING_IMG_QUALITY, // 画质
|
2022-05-03 03:56:07 +00:00
|
|
|
|
HG_239_SETTING_REVERSE, // 交换正反面
|
|
|
|
|
HG_239_SETTING_SPLIT, // 图像拆分
|
|
|
|
|
HG_239_SETTING_CORRECT, // 自动纠偏
|
|
|
|
|
HG_239_SETTING_ERASE_HOLE, // 穿孔移除
|
|
|
|
|
HG_239_SETTING_HOLE_SEARCH, // 穿孔搜索范围
|
|
|
|
|
|
|
|
|
|
HG__239_SETTING_GROUP_2,
|
|
|
|
|
|
2022-05-07 07:39:48 +00:00
|
|
|
|
HG_239_SETTING_CUSTOM_GAMMA, // 启用色调曲线
|
2022-05-03 03:56:07 +00:00
|
|
|
|
HG_239_SETTING_LIGHT, // 亮度
|
|
|
|
|
HG_239_SETTING_CONTRAST, // 对比度
|
|
|
|
|
HG_239_SETTING_GAMMA, // 伽玛
|
|
|
|
|
|
|
|
|
|
HG__239_SETTING_GROUP_3,
|
|
|
|
|
|
|
|
|
|
HG_239_SETTING_SHARP, // 锐化与模糊
|
|
|
|
|
HG_239_SETTING_ERASE_BLACK_BORDER, // 消除黑框
|
|
|
|
|
HG_239_SETTING_SAMPLE, // 深色样张
|
|
|
|
|
HG_239_SETTING_THRESHOLD, // 阈值
|
|
|
|
|
HG_239_SETTING_ANTI_NOISE, // 背景抗噪等级
|
|
|
|
|
HG_239_SETTING_MARGIN, // 边缘缩进
|
|
|
|
|
HG_239_SETTING_FILLING, // 背景填充方式
|
|
|
|
|
HG_239_SETTING_PERMEATE, // 防止渗透
|
|
|
|
|
HG_239_SETTING_PERMEATE_lv, // 防止渗透等级
|
|
|
|
|
HG_239_SETTING_REMOVE_MORR, // 去除摩尔纹
|
|
|
|
|
HG_239_SETTING_ERROR_EXTENTION, // 错误扩散
|
|
|
|
|
HG_239_SETTING_REMOVE_TXTTURE, // 除网纹
|
|
|
|
|
|
|
|
|
|
HG__239_SETTING_GROUP_4,
|
|
|
|
|
|
|
|
|
|
HG_239_SETTING_ULTRASONIC, // 超声波检测
|
|
|
|
|
HG_239_SETTING_STAPLE, // 装订检测
|
|
|
|
|
HG_239_SETTING_SCAN_METHOD, // 连续扫描或扫描指定张数
|
|
|
|
|
HG_239_SETTING_SCAN_COUNT, // 扫描指定数量
|
|
|
|
|
HG_239_SETTING_DIRECTION, // 文稿方向 删除文稿自动识别
|
|
|
|
|
HG_239_SETTING_ROTATE, // 背面旋转180°
|
|
|
|
|
HG_239_SETTING_FRACTATE, // 折角检测
|
|
|
|
|
HG_239_SETTING_FRACTATE_COMPLEX, // 折角检测复杂度
|
|
|
|
|
HG_239_SETTING_SCREW, // 歪斜检测
|
|
|
|
|
HG_239_SETTING_SCREW_COMPLEX, // 歪斜检测复杂度
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
HG_239_SETTING_END,
|
|
|
|
|
|
|
|
|
|
//暂时屏蔽
|
|
|
|
|
HG_239_SETTING_MULTI_OUT = 500, // 多流输出
|
|
|
|
|
};
|
|
|
|
|
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_CUO_ERROR = 0x50,
|
|
|
|
|
SR_GET_DOU_ERROR,
|
|
|
|
|
SR_GET_JAM_ERROR,
|
|
|
|
|
SR_GET_SCANN_NUM,
|
|
|
|
|
SR_CLR_ROLLER_NUM,
|
|
|
|
|
SR_GET_ROLLER_NUM,
|
|
|
|
|
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
|
|
|
|
|
};
|
|
|
|
|
enum Scanner_Cmd_Defs
|
|
|
|
|
{
|
|
|
|
|
SC_START,
|
|
|
|
|
SC_STOP,
|
|
|
|
|
SC_CLEAR,
|
|
|
|
|
SC_COUNT
|
|
|
|
|
};
|
|
|
|
|
enum HGType
|
|
|
|
|
{
|
|
|
|
|
MtBoard = 1,
|
|
|
|
|
FPGA,
|
|
|
|
|
V4L2,
|
|
|
|
|
IMG,
|
|
|
|
|
AutoCorrect,
|
|
|
|
|
STOPSCAN,
|
|
|
|
|
};
|
|
|
|
|
struct HGEIntInfo
|
|
|
|
|
{
|
|
|
|
|
HGType From;
|
|
|
|
|
unsigned int Code;
|
|
|
|
|
unsigned int Img_Index;
|
|
|
|
|
};
|
|
|
|
|
namespace settings
|
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
// device status to scanner_err
|
|
|
|
|
scanner_err device_status_to_hg_err(HGEIntInfo* ds)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
scanner_err code = SCANNER_ERR_OK;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
if (ds->From == HGType::FPGA)
|
2022-05-17 07:04:55 +00:00
|
|
|
|
code = SCANNER_ERR_OK;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
else if (ds->From == HGType::MtBoard)
|
|
|
|
|
{
|
|
|
|
|
switch (ds->Code)
|
|
|
|
|
{
|
|
|
|
|
case 0x00002:
|
2022-05-17 07:04:55 +00:00
|
|
|
|
code = SCANNER_ERR_DEVICE_NO_PAPER;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
break;
|
|
|
|
|
case 0x00004:
|
2022-05-17 07:04:55 +00:00
|
|
|
|
code = SCANNER_ERR_DEVICE_COVER_OPENNED;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
break;
|
|
|
|
|
case 0x00008:
|
2022-05-17 07:04:55 +00:00
|
|
|
|
code = SCANNER_ERR_DEVICE_FEEDING_PAPER;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
break;
|
|
|
|
|
case 0x00010:
|
2022-05-17 07:04:55 +00:00
|
|
|
|
code = SCANNER_ERR_DEVICE_PAPER_JAMMED;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
break;
|
|
|
|
|
case 0x00020:
|
2022-05-17 07:04:55 +00:00
|
|
|
|
code = SCANNER_ERR_DEVICE_DOUBLE_FEEDING;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
break;
|
|
|
|
|
case 0x00040:
|
2022-05-17 07:04:55 +00:00
|
|
|
|
code = SCANNER_ERR_DEVICE_STAPLE_ON;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
break;
|
|
|
|
|
case 0x00080:
|
2022-05-17 07:04:55 +00:00
|
|
|
|
code = SCANNER_ERR_DEVICE_PAPER_SKEW;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
break;
|
|
|
|
|
case 0x10000:
|
|
|
|
|
case 0x80000:
|
2022-05-17 07:04:55 +00:00
|
|
|
|
code = SCANNER_ERR_TIMEOUT;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
break;
|
|
|
|
|
case 0x20000:
|
2022-05-17 07:04:55 +00:00
|
|
|
|
code = SCANNER_ERR_DEVICE_SIZE_CHECK;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if (ds->From == HGType::IMG)
|
|
|
|
|
{
|
|
|
|
|
if (ds->Code == 1)
|
2022-05-17 07:04:55 +00:00
|
|
|
|
code = SCANNER_ERR_DEVICE_DOGEAR;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
else if (ds->Code == 2)
|
2022-05-17 07:04:55 +00:00
|
|
|
|
code = SCANNER_ERR_DEVICE_SIZE_CHECK;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
else if (ds->From == HGType::V4L2)
|
|
|
|
|
{
|
|
|
|
|
if (ds->Code == 0)
|
2022-05-17 07:04:55 +00:00
|
|
|
|
code = SCANNER_ERR_DEVICE_SCANN_ERROR;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
else if (ds->Code == 1)
|
2022-05-17 07:04:55 +00:00
|
|
|
|
code = SCANNER_ERR_DEVICE_NO_IMAGE;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
else if (ds->From == HGType::STOPSCAN)
|
2022-05-17 07:04:55 +00:00
|
|
|
|
code = SCANNER_ERR_DEVICE_STOPPED;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
return code;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// resolution
|
|
|
|
|
static struct
|
|
|
|
|
{
|
|
|
|
|
float resolution;
|
|
|
|
|
int dev_value;
|
|
|
|
|
}resolution_map[] =
|
|
|
|
|
{
|
|
|
|
|
{100.0f, 1},
|
|
|
|
|
{150.0f, 1},
|
|
|
|
|
{200.0f, 1},
|
|
|
|
|
{240.0f, 1},
|
|
|
|
|
{300.0f, 0},
|
|
|
|
|
{600.0f, 1} //临时版本发1 原来发2
|
|
|
|
|
};
|
|
|
|
|
bool is_equal(float l, float r)
|
|
|
|
|
{
|
|
|
|
|
return fabs(l - r) < .000001f;
|
|
|
|
|
}
|
|
|
|
|
int match_best_resolution(int resolution, bool* exact)
|
|
|
|
|
{
|
|
|
|
|
int rsl = resolution,
|
|
|
|
|
ind = 0;
|
|
|
|
|
bool good = true, *r = exact ? exact : &good;
|
|
|
|
|
|
|
|
|
|
if (rsl <= resolution_map[0].resolution)
|
|
|
|
|
{
|
|
|
|
|
ind = 0;
|
|
|
|
|
}
|
|
|
|
|
else if (rsl >= resolution_map[ARRAY_SIZE(resolution_map) - 1].resolution)
|
|
|
|
|
{
|
|
|
|
|
ind = ARRAY_SIZE(resolution_map) - 1;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
for (int i = 1; i < ARRAY_SIZE(resolution_map); ++i)
|
|
|
|
|
{
|
|
|
|
|
if (is_equal(rsl, resolution_map[i].resolution))
|
|
|
|
|
{
|
|
|
|
|
ind = i;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
if (rsl < resolution_map[i].resolution)
|
|
|
|
|
{
|
|
|
|
|
float dif_l = rsl - resolution_map[i - 1].resolution,
|
|
|
|
|
dif_r = resolution_map[i].resolution - rsl;
|
|
|
|
|
|
|
|
|
|
if (dif_l > dif_r)
|
|
|
|
|
ind = i;
|
|
|
|
|
else
|
|
|
|
|
ind = i - 1;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
*r = is_equal(rsl, resolution_map[ind].resolution);
|
|
|
|
|
|
|
|
|
|
return ind;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// paper
|
|
|
|
|
static struct
|
|
|
|
|
{
|
|
|
|
|
int paper;
|
|
|
|
|
TwSS type;
|
|
|
|
|
int dev_value;
|
|
|
|
|
}paper_map[] =
|
|
|
|
|
{
|
|
|
|
|
{PAPER_A3, TwSS::A3, 0},
|
|
|
|
|
{PAPER_8K, TwSS::K8, 0},
|
|
|
|
|
{PAPER_A4, TwSS::A4, 1},
|
|
|
|
|
{PAPER_A4_LATERAL, TwSS::A4, 2},
|
|
|
|
|
{PAPER_16K, TwSS::K16, 0},
|
|
|
|
|
{PAPER_16K_LATERAL, TwSS::K16, 0},
|
|
|
|
|
{PAPER_A5, TwSS::A5, 2},
|
|
|
|
|
{PAPER_A5_LATERAL, TwSS::A5, 2},
|
|
|
|
|
{PAPER_A6, TwSS::A6, 2},
|
|
|
|
|
{PAPER_A6_LATERAL, TwSS::A6, 2},
|
|
|
|
|
{PAPER_B4, TwSS::B4, 0},
|
|
|
|
|
{PAPER_B5, TwSS::B5, 0},
|
|
|
|
|
{PAPER_B5_LATERAL, TwSS::B5, 1},
|
|
|
|
|
{PAPER_B6, TwSS::B6, 2},
|
|
|
|
|
{PAPER_B6_LATERAL, TwSS::B6, 2},
|
|
|
|
|
{PAPER_LETTER, TwSS::USLetter, 14},
|
|
|
|
|
{PAPER_LETTER_LATERAL, TwSS::USLetter, 1},
|
|
|
|
|
{PAPER_DOUBLE_LETTER, TwSS::USLedger, 2},
|
|
|
|
|
{PAPER_LEGAL, TwSS::USLegal, 0},
|
|
|
|
|
{PAPER_AUTO_MATCH, TwSS::None, 0},
|
|
|
|
|
{PAPER_MAX_SIZE_CLIP, TwSS::USStatement, 16},
|
|
|
|
|
{PAPER_MAX_SIZE, TwSS::MaxSize, 16},
|
|
|
|
|
{PAPER_TRIGEMINY, TwSS::Trigeminy, 16}
|
|
|
|
|
};
|
|
|
|
|
int match_best_paper(int& paper, bool* exact, TwSS* type)
|
|
|
|
|
{
|
|
|
|
|
int ind = 0;
|
|
|
|
|
bool good = true, * r = exact ? exact : &good;
|
|
|
|
|
|
|
|
|
|
for (int i = 0; i < ARRAY_SIZE(paper_map); ++i)
|
|
|
|
|
{
|
|
|
|
|
if (paper == paper_map[i].paper)
|
|
|
|
|
{
|
|
|
|
|
ind = i;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (paper == paper_map[ind].paper)
|
|
|
|
|
*r = true;
|
|
|
|
|
else
|
|
|
|
|
*r = false;
|
2022-05-30 03:04:26 +00:00
|
|
|
|
VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "Paper '%s' index = %d, device value = %d\n", paper_string(paper).c_str(), ind, paper_map[ind].dev_value);
|
2022-05-03 03:56:07 +00:00
|
|
|
|
paper = paper_map[ind].paper;
|
|
|
|
|
if (type)
|
|
|
|
|
*type = paper_map[ind].type;
|
|
|
|
|
|
|
|
|
|
return ind;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
// class ...
|
|
|
|
|
hg_scanner_239::hg_scanner_239(const char* dev_name, int pid,usb_io* io) : hg_scanner(G20039Serial, dev_name, io)
|
|
|
|
|
, rewrite_conf_(false), reset_(false),pid_(pid)
|
|
|
|
|
{
|
2022-05-30 03:04:26 +00:00
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "hg_scanner_239(%s) constructing ...\n", hg_log::format_ptr(this).c_str());
|
2022-05-03 03:56:07 +00:00
|
|
|
|
dev_conf_.value = 0;
|
2022-05-09 08:59:22 +00:00
|
|
|
|
#ifndef MAPPING_FUNCTION_IN_BASE
|
2022-05-03 03:56:07 +00:00
|
|
|
|
init_setting_map(setting_map_, ARRAY_SIZE(setting_map_));
|
2022-05-09 08:59:22 +00:00
|
|
|
|
#endif
|
2022-05-03 03:56:07 +00:00
|
|
|
|
init_settings(jsontext.c_str());
|
|
|
|
|
writedown_device_configuration(); // initialize the hardware settings
|
|
|
|
|
init_version();
|
|
|
|
|
}
|
|
|
|
|
hg_scanner_239::~hg_scanner_239()
|
|
|
|
|
{
|
2022-05-30 03:04:26 +00:00
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "hg_scanner_239(%s) destroyed.\n", hg_log::format_ptr(this).c_str());
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int hg_scanner_239::read_register(int addr, int* val)
|
|
|
|
|
{
|
|
|
|
|
std::lock_guard<std::mutex> lock(io_lock_);
|
|
|
|
|
|
|
|
|
|
int l = sizeof(*val),
|
|
|
|
|
ret = io_->control_io(0x0c0, USB_REQ_GET_DEV_REGS, addr, 0, val, &l);
|
|
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
|
status_ = ret;
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
int hg_scanner_239::write_register(int addr, int val)
|
|
|
|
|
{
|
|
|
|
|
std::lock_guard<std::mutex> lock(io_lock_);
|
|
|
|
|
|
|
|
|
|
int l = sizeof(val),
|
|
|
|
|
ret = io_->control_io(0x040, USB_REQ_SET_DEV_REGS, addr, 0, &val, &l);
|
|
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
|
status_ = ret;
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
int hg_scanner_239::write_command(int cmd)
|
|
|
|
|
{
|
|
|
|
|
return write_register(0, cmd);
|
|
|
|
|
}
|
|
|
|
|
std::string hg_scanner_239::control_fetch(int addr, int val, int size)
|
|
|
|
|
{
|
|
|
|
|
int l = sizeof(val),
|
|
|
|
|
ret = 0;
|
|
|
|
|
std::string data("");
|
|
|
|
|
|
|
|
|
|
ret = write_register(addr, val);
|
2022-05-17 07:04:55 +00:00
|
|
|
|
if (ret == SCANNER_ERR_OK)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
|
|
|
|
std::lock_guard<std::mutex> lock(io_lock_);
|
|
|
|
|
|
|
|
|
|
l = size + 1;
|
|
|
|
|
data.resize(size + 2);
|
|
|
|
|
bzero(&data[0], size + 2);
|
|
|
|
|
ret = io_->read_bulk(&data[0], &l);
|
|
|
|
|
if (ret)
|
|
|
|
|
{
|
2022-05-30 03:42:16 +00:00
|
|
|
|
VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "control_fetch(%d, %d) - read_bulk = %s\n", addr, val, hg_scanner_err_name(ret));
|
2022-05-03 03:56:07 +00:00
|
|
|
|
data.clear();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
2022-05-30 03:42:16 +00:00
|
|
|
|
VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "control_fetch(%d, %d) = %s\n", addr, val, hg_scanner_err_name(ret));
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
return data;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::string hg_scanner_239::get_fpga(void)
|
|
|
|
|
{
|
|
|
|
|
int val = 0,
|
|
|
|
|
ret = read_register(SR_GET_MBVERSION_LENGHT, &val);
|
|
|
|
|
std::string fpga("");
|
|
|
|
|
|
2022-05-17 07:04:55 +00:00
|
|
|
|
if (ret == SCANNER_ERR_OK)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
|
|
|
|
fpga.resize(val + 2);
|
|
|
|
|
bzero(&fpga[0], val + 2);
|
|
|
|
|
|
|
|
|
|
return control_fetch(SR_GET_MBVERSION, 0, val);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return fpga;
|
|
|
|
|
}
|
|
|
|
|
int hg_scanner_239::clr_roller_num(void)
|
|
|
|
|
{
|
|
|
|
|
int val = 0,
|
|
|
|
|
ret = read_register(SR_CLR_ROLLER_NUM, &val);
|
|
|
|
|
|
2022-05-17 07:04:55 +00:00
|
|
|
|
if (ret == SCANNER_ERR_OK)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
return val;
|
|
|
|
|
else
|
|
|
|
|
{
|
2022-05-30 03:42:16 +00:00
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "clr_roller_num = %s\n", hg_scanner_err_name(ret));
|
2022-05-03 03:56:07 +00:00
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
int hg_scanner_239::get_sleep_time(void)
|
|
|
|
|
{
|
|
|
|
|
int val = 0,
|
|
|
|
|
ret = read_register(SR_GET_SLEEPTIME, &val);
|
|
|
|
|
|
2022-05-17 07:04:55 +00:00
|
|
|
|
if (ret == SCANNER_ERR_OK)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
return val;
|
|
|
|
|
else
|
|
|
|
|
{
|
2022-05-30 03:42:16 +00:00
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "get_sleep_time = %s\n", hg_scanner_err_name(ret));
|
2022-05-03 03:56:07 +00:00
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
int hg_scanner_239::get_scan_mode(void)
|
|
|
|
|
{
|
|
|
|
|
int val = 0,
|
|
|
|
|
ret = read_register(SR_OS, &val);
|
|
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
|
{
|
2022-05-30 03:42:16 +00:00
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "get scan mode error: %s\n", hg_scanner_err_name(ret));
|
2022-05-03 03:56:07 +00:00
|
|
|
|
status_ = ret;
|
|
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
return val;
|
|
|
|
|
}
|
|
|
|
|
int hg_scanner_239::get_status(void)
|
|
|
|
|
{
|
|
|
|
|
int val = 0,
|
|
|
|
|
ret = read_register(SR_STATUS, &val);
|
|
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
|
{
|
2022-05-30 03:42:16 +00:00
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "get status error: %s\n", hg_scanner_err_name(ret));
|
2022-05-03 03:56:07 +00:00
|
|
|
|
status_ = ret;
|
|
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
return val;
|
|
|
|
|
}
|
|
|
|
|
bool hg_scanner_239::is_dev_tx(void)
|
|
|
|
|
{
|
|
|
|
|
int val = 0,
|
|
|
|
|
ret = read_register(SR_STATUS, &val);
|
|
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
|
{
|
2022-05-30 03:42:16 +00:00
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "is_dev_tx() error: %s\n", hg_scanner_err_name(ret));
|
2022-05-03 03:56:07 +00:00
|
|
|
|
status_ = ret;
|
|
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
return val;
|
|
|
|
|
}
|
|
|
|
|
bool hg_scanner_239::is_dev_image_process_done(void)
|
|
|
|
|
{
|
|
|
|
|
int val = 0,
|
|
|
|
|
ret = read_register(SR_GET_IMAGEPROCESSDONE, &val);
|
|
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
|
{
|
2022-05-30 03:42:16 +00:00
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "is_dev_image_process_done() error: %s\n", hg_scanner_err_name(ret));
|
2022-05-03 03:56:07 +00:00
|
|
|
|
status_ = ret;
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
return val;
|
|
|
|
|
}
|
|
|
|
|
bool hg_scanner_239::is_dev_image_keep_last_paper(void)
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
int val = 0,
|
|
|
|
|
ret = read_register(SR_GET_KEEP_LAST_PAPER, &val);
|
|
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
|
{
|
2022-05-30 03:42:16 +00:00
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "is_dev_image_keep_last_paper() error: %s\n", hg_scanner_err_name(ret));
|
2022-05-03 03:56:07 +00:00
|
|
|
|
status_ = ret;
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
return val;
|
|
|
|
|
}
|
|
|
|
|
int hg_scanner_239::get_scanned_count(void)
|
|
|
|
|
{
|
|
|
|
|
int val = 0,
|
|
|
|
|
ret = read_register(SR_GET_SCANN_NUM, &val);
|
|
|
|
|
|
2022-05-17 07:04:55 +00:00
|
|
|
|
if (ret == SCANNER_ERR_OK)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
return val;
|
|
|
|
|
else
|
|
|
|
|
{
|
2022-05-30 03:42:16 +00:00
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "get_scanned_count = %s\n", hg_scanner_err_name(ret));
|
2022-05-03 03:56:07 +00:00
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
int hg_scanner_239::get_image_count(void)
|
|
|
|
|
{
|
|
|
|
|
int val = 0,
|
|
|
|
|
ret = read_register(SR_IM_COUNT, &val);
|
|
|
|
|
|
2022-05-30 03:42:16 +00:00
|
|
|
|
VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "get_image_count() = %d, error: %s\n", val, hg_scanner_err_name(ret));
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
2022-05-17 07:04:55 +00:00
|
|
|
|
if (ret == SCANNER_ERR_OK)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
return val;
|
|
|
|
|
else
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
int hg_scanner_239::get_front_data_size(void)
|
|
|
|
|
{
|
|
|
|
|
int val = 0,
|
|
|
|
|
ret = read_register(SR_IM_FRONT_SIZE, &val);
|
|
|
|
|
|
2022-05-17 07:04:55 +00:00
|
|
|
|
if (ret == SCANNER_ERR_OK)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
return val;
|
|
|
|
|
else
|
|
|
|
|
{
|
2022-05-30 03:42:16 +00:00
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "get_front_data_size = %s\n", hg_scanner_err_name(ret));
|
2022-05-03 03:56:07 +00:00
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
void hg_scanner_239::init_version(void)
|
|
|
|
|
{
|
|
|
|
|
std::string fv(get_firmware_version()),
|
|
|
|
|
sn(get_serial_num());
|
|
|
|
|
|
2022-05-30 03:04:26 +00:00
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, " HG3399 firmware version: %s\n", fv.c_str());
|
|
|
|
|
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, " HG3399 serial number: %s\n", sn.c_str());
|
|
|
|
|
//VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, " HG3399 IP: %s\n", get_ip().c_str());
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
if (fv.length() >= 10 && (fv[5] > 'A' || atoi(fv.substr(6, 4).c_str()) >= 1209))
|
|
|
|
|
{
|
|
|
|
|
is_kernelsnap_211209_ = atoi(get_fpga().c_str()) >= 35211210;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
is_kernelsnap_211209_ = false;
|
|
|
|
|
}
|
2022-06-01 03:04:10 +00:00
|
|
|
|
void hg_scanner_239::image_process(std::shared_ptr<tiny_buffer>& buff)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
2022-05-30 03:04:26 +00:00
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Process image with %u bytes content ...\n", buff->size());
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
hg_imgproc::IMGPRCPARAM param;
|
|
|
|
|
hg_imgproc::HIMGPRC handle = NULL;
|
|
|
|
|
hg_imgproc::IMGHEAD ih;
|
2022-05-17 07:04:55 +00:00
|
|
|
|
int err = SCANNER_ERR_OK,
|
2022-05-03 03:56:07 +00:00
|
|
|
|
index = 0;
|
|
|
|
|
void* buf = NULL;
|
|
|
|
|
|
|
|
|
|
bzero(¶m, sizeof(param));
|
|
|
|
|
|
|
|
|
|
param.bits = 8;
|
|
|
|
|
param.black_white = img_conf_.pixtype == COLOR_MODE_BLACK_WHITE;
|
|
|
|
|
param.channels = img_conf_.pixtype == COLOR_MODE_24_BITS ? 3 : 1;
|
|
|
|
|
param.color_mode = img_conf_.pixtype;
|
|
|
|
|
param.double_side = img_conf_.is_duplex;
|
|
|
|
|
param.dpi = img_conf_.resolution_dst;
|
|
|
|
|
|
|
|
|
|
// printf("img_conf_ =%d\r\n",img_conf_.pixtype);
|
|
|
|
|
// printf("param.black_white :%d\r\n",param.black_white);
|
|
|
|
|
// printf("param.channels :%d\r\n",param.channels);
|
|
|
|
|
// printf("param.color_mode :%d\r\n",param.color_mode);
|
|
|
|
|
// printf("param.double_side :%d\r\n",param.double_side);
|
|
|
|
|
// printf("param.dpi :%d\r\n",param.dpi);
|
|
|
|
|
|
2022-05-04 08:57:05 +00:00
|
|
|
|
handle = hg_imgproc::init(&img_conf_,¶m,pid_);
|
2022-05-03 03:56:07 +00:00
|
|
|
|
err = hg_imgproc::load_buffer(handle, buff);
|
|
|
|
|
err = hg_imgproc::decode(handle,pid_);
|
|
|
|
|
|
|
|
|
|
if(image_prc_param_.bits.erase_bakground && !user_cancel_)
|
|
|
|
|
{
|
|
|
|
|
err = hg_imgproc::fadeback(handle,img_conf_.fadebackrange,img_conf_.is_duplex);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (image_prc_param_.bits.rid_red && img_conf_.pixtype == COLOR_MODE_24_BITS)
|
|
|
|
|
err = hg_imgproc::multi_out_red(handle);
|
|
|
|
|
|
|
|
|
|
if (image_prc_param_.bits.split && !user_cancel_)
|
|
|
|
|
{
|
|
|
|
|
int colormode=1;
|
|
|
|
|
if(img_conf_.filter == RID_COLOR_NONE)
|
|
|
|
|
colormode=img_conf_.pixtype;
|
|
|
|
|
|
|
|
|
|
err = hg_imgproc::split(handle,img_conf_.multiOutput,img_conf_.splitImage,img_conf_.multi_output_red,colormode,img_conf_.is_duplex);
|
2022-05-30 03:04:26 +00:00
|
|
|
|
VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "img split-> multiOutput is:%d splitImage is:%d multi_output_red is:%d pixtype is:%d is_duplex:%d\r\n"
|
2022-05-03 03:56:07 +00:00
|
|
|
|
,img_conf_.multiOutput
|
|
|
|
|
,img_conf_.splitImage
|
|
|
|
|
,img_conf_.multi_output_red
|
|
|
|
|
,img_conf_.pixtype
|
|
|
|
|
,img_conf_.is_duplex);
|
|
|
|
|
}
|
|
|
|
|
|
2022-06-02 03:47:44 +00:00
|
|
|
|
if (!image_prc_param_.bits.split || !image_prc_param_.bits.rid_red || !is_multiout)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
|
|
|
|
if(img_conf_.automaticcolor)
|
|
|
|
|
{
|
|
|
|
|
hg_imgproc::auto_matic_color(handle,img_conf_.automaticcolortype);
|
|
|
|
|
}
|
|
|
|
|
}
|
2022-05-11 03:27:11 +00:00
|
|
|
|
if (img_conf_.is_autotext)
|
|
|
|
|
{
|
|
|
|
|
printf("文本方向自动识别\r\n");
|
|
|
|
|
hg_imgproc::ocr_auto_txtdirect(handle);
|
|
|
|
|
}
|
|
|
|
|
if (is_quality_ == IMG_SPEED && resolution_ >= 300)
|
|
|
|
|
{
|
|
|
|
|
err = hg_imgproc::quality(handle,resolution_);
|
|
|
|
|
}
|
2022-05-21 08:56:14 +00:00
|
|
|
|
//多流输出最后处理
|
|
|
|
|
if (is_multiout)
|
|
|
|
|
{
|
2022-05-23 08:54:55 +00:00
|
|
|
|
int multi_out = image_prc_param_.bits.multi_out;
|
2022-05-21 08:56:14 +00:00
|
|
|
|
err = hg_imgproc::multi_out(handle,multi_out);
|
|
|
|
|
}
|
2022-05-03 03:56:07 +00:00
|
|
|
|
hg_imgproc::final(handle);
|
2022-05-09 11:27:10 +00:00
|
|
|
|
|
2022-05-17 07:04:55 +00:00
|
|
|
|
while (hg_imgproc::get_final_data(handle, &ih, &buf, index++) == SCANNER_ERR_OK && !user_cancel_)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
2022-05-30 03:04:26 +00:00
|
|
|
|
VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "Final picture %d (%d * %d * %d) with %u bytes!\n", index
|
2022-05-03 03:56:07 +00:00
|
|
|
|
, ih.width, ih.height, ih.bits * ih.channels, ih.total_bytes);
|
|
|
|
|
|
|
|
|
|
if(!img_type_.empty())
|
|
|
|
|
{
|
|
|
|
|
std::vector<unsigned char>bmpdata;
|
|
|
|
|
|
|
|
|
|
hg_imgproc::imgtypechange(handle,img_type_,buf,bmpdata);
|
|
|
|
|
//cv::imencode(img_type_,*((cv::Mat*)buf),bmpdata);
|
|
|
|
|
if(bmpdata.empty())
|
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
status_ = SCANNER_ERR_NO_DATA;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
return ;
|
|
|
|
|
}
|
|
|
|
|
buf = bmpdata.data();
|
|
|
|
|
ih.total_bytes = bmpdata.size();
|
|
|
|
|
|
2022-05-30 03:04:26 +00:00
|
|
|
|
VLOG_MINI_6(LOG_LEVEL_DEBUG_INFO, "Set img type is:%s Final picture %d (%d * %d * %d) with %u bytes!\n",img_type_.c_str() ,index
|
2022-05-03 03:56:07 +00:00
|
|
|
|
, ih.width, ih.height, ih.bits * ih.channels, ih.total_bytes);
|
|
|
|
|
}
|
|
|
|
|
save_final_image(&ih, buf);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
hg_imgproc::release(handle);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int hg_scanner_239::get_device_sleep_stautus(void)
|
|
|
|
|
{
|
|
|
|
|
int ret =read_register(SR_GET_SLEEP_STAUTUS,0);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int hg_scanner_239::get_device_paperon_stautus(void)
|
|
|
|
|
{
|
|
|
|
|
int ret =read_register(SR_GET_PAPERON,0);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
// int hg_scanner_239::writedown_device_configuration()
|
|
|
|
|
// {
|
2022-05-17 07:04:55 +00:00
|
|
|
|
// int ret = SCANNER_ERR_OK;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// ret = write_register(SR_CONFIG_SCAN_PARAM, dev_conf_.value);
|
2022-05-30 03:42:16 +00:00
|
|
|
|
// VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "Writedown scanner configuration(0x%x) = %s\n", dev_conf_.value, hg_scanner_err_name(ret));
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
// return ret;
|
|
|
|
|
// }
|
|
|
|
|
|
|
|
|
|
int hg_scanner_239::writedown_device_configuration(HGSCANCONF *dev_conf)
|
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
int ret = SCANNER_ERR_OK;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
if(!dev_conf)
|
|
|
|
|
dev_conf = &dev_conf_;
|
|
|
|
|
|
|
|
|
|
ret = write_register(SR_CONFIG_SCAN_PARAM, dev_conf->value);
|
|
|
|
|
|
2022-05-30 03:42:16 +00:00
|
|
|
|
VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "Writedown scanner configuration(0x%x) = %s\n", dev_conf->value, hg_scanner_err_name(ret));
|
2022-05-03 03:56:07 +00:00
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int hg_scanner_239::writedown_image_configuration(void)
|
|
|
|
|
{
|
|
|
|
|
int ret = write_register(SR_CONFIF_IMGPROCPARAM, sizeof(SCANCONF));
|
2022-05-17 07:04:55 +00:00
|
|
|
|
if (ret != SCANNER_ERR_OK)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
|
|
SCANCONF ic;
|
|
|
|
|
int len = sizeof(ic);
|
|
|
|
|
|
|
|
|
|
bzero(&ic, len);
|
|
|
|
|
|
|
|
|
|
ic.papertype = paper_size_;
|
|
|
|
|
|
2022-05-18 06:22:17 +00:00
|
|
|
|
if (is_lateral(image_prc_param_.bits.paper))
|
|
|
|
|
ic.paperAlign = Rot270;
|
|
|
|
|
else if (image_prc_param_.bits.text_direction == TEXT_DIRECTION_AUTO)
|
|
|
|
|
ic.paperAlign = AutoTextOrientation;
|
|
|
|
|
else
|
|
|
|
|
ic.paperAlign = Rot0;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
ic.en_sizecheck = dev_conf_.g200params.enable_sizecheck;
|
2022-05-11 03:27:11 +00:00
|
|
|
|
|
|
|
|
|
if (image_prc_param_.bits.text_direction != TEXT_DIRECTION_AUTO)
|
|
|
|
|
ic.imageRotateDegree = image_prc_param_.bits.text_direction;
|
|
|
|
|
else
|
|
|
|
|
ic.imageRotateDegree = 0;
|
|
|
|
|
|
2022-05-03 03:56:07 +00:00
|
|
|
|
ic.is_duplex = (image_prc_param_.bits.page == PAGE_DOUBLE || image_prc_param_.bits.page == PAGE_OMIT_EMPTY ||
|
|
|
|
|
image_prc_param_.bits.page == PAGE_OMIT_EMPTY_RECEIPT || image_prc_param_.bits.page ==PAGE_FOLIO);
|
|
|
|
|
ic.en_fold = (image_prc_param_.bits.page == PAGE_FOLIO);
|
|
|
|
|
ic.pixtype = image_prc_param_.bits.color_mode == COLOR_MODE_AUTO_MATCH ? 2 : image_prc_param_.bits.color_mode;
|
|
|
|
|
ic.automaticcolor = is_auto_matic_color;
|
|
|
|
|
|
|
|
|
|
ic.automaticcolortype = 1;// ic.pixtype; //存疑
|
2022-05-18 06:22:17 +00:00
|
|
|
|
if (resolution_ >= 300)
|
|
|
|
|
{
|
|
|
|
|
if(is_quality_ == IMG_SPEED)
|
2022-05-09 11:27:10 +00:00
|
|
|
|
{
|
2022-05-18 06:22:17 +00:00
|
|
|
|
ic.resolution_dst = 200;
|
2022-05-09 11:27:10 +00:00
|
|
|
|
}
|
2022-05-18 06:22:17 +00:00
|
|
|
|
else if(is_quality_ ==IMG_QUALITY)
|
2022-05-09 11:27:10 +00:00
|
|
|
|
{
|
|
|
|
|
ic.resolution_dst = resolution_;
|
|
|
|
|
}
|
2022-05-18 06:22:17 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
ic.resolution_dst = resolution_;
|
|
|
|
|
}
|
2022-05-09 11:27:10 +00:00
|
|
|
|
|
2022-05-03 03:56:07 +00:00
|
|
|
|
ic.resolution_native = 200.0f;
|
|
|
|
|
ic.gamma = (float)gamma_;
|
|
|
|
|
ic.contrast = (contrast_ - 4) * 333.0;
|
|
|
|
|
ic.brightness = (bright_ - 128) * (2000.0 / 254.0);
|
|
|
|
|
ic.threshold = threshold_;
|
|
|
|
|
ic.is_autocontrast = 0; //无参数
|
|
|
|
|
ic.is_autocrop = (ic.papertype == TwSS::None || ic.papertype ==TwSS::USStatement);
|
|
|
|
|
ic.is_autodiscradblank_normal = image_prc_param_.bits.page == PAGE_OMIT_EMPTY;
|
2022-05-17 02:23:03 +00:00
|
|
|
|
ic.discardblank_percent = omit_empty_level_ >= 60 ? 60 : omit_empty_level_; //默认20
|
2022-05-03 03:56:07 +00:00
|
|
|
|
ic.is_autodiscradblank_vince = image_prc_param_.bits.page == PAGE_OMIT_EMPTY_RECEIPT;
|
|
|
|
|
ic.is_switchfrontback = image_prc_param_.bits.exchange;
|
|
|
|
|
ic.autodescrew = image_prc_param_.bits.automatic_skew;
|
|
|
|
|
//ic.multi_output_red = image_prc_param_.bits.rid_red; //必须屏蔽,否则超时,未知错误不可描述。
|
|
|
|
|
ic.hsvcorrect = image_prc_param_.bits.rid_answer_red;
|
|
|
|
|
ic.sharpen = image_prc_param_.bits.sharpen;
|
|
|
|
|
ic.enhance_color = image_prc_param_.bits.rid_color;
|
|
|
|
|
ic.fillbackground = image_prc_param_.bits.erase_black_frame;
|
|
|
|
|
ic.is_convex = (image_prc_param_.bits.fill_background == FILL_BKG_CONVEX_POLYGON);
|
|
|
|
|
ic.noise = image_prc_param_.bits.noise_optimize;
|
|
|
|
|
ic.indent = margin_;
|
|
|
|
|
ic.AutoCrop_threshold = threshold_;
|
|
|
|
|
if (test_1_paper_)
|
|
|
|
|
{
|
2022-05-30 03:04:26 +00:00
|
|
|
|
LOG_INFO(LOG_LEVEL_DEBUG_INFO, "scanning mode: testing ONE paper ...\n");
|
2022-05-03 03:56:07 +00:00
|
|
|
|
ic.scannum = ic.is_duplex ? 2 : 1;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
ic.scannum = (ic.is_duplex ? scan_count_ * 2 : scan_count_);
|
|
|
|
|
}
|
|
|
|
|
ic.is_backrotate180 = image_prc_param_.bits.rotate_back_180;
|
|
|
|
|
ic.is_dogeardetection = image_prc_param_.bits.fractate_check;
|
|
|
|
|
ic.hardwarecaps.en_skrewdetect = dev_conf_.g200params.screw_detect_enable;
|
|
|
|
|
ic.hardwarecaps.en_doublefeed = dev_conf_.g200params.ultrasonic_enable;
|
|
|
|
|
ic.hardwarecaps.en_stapledetect = dev_conf_.g200params.staple_enbale;
|
|
|
|
|
ic.hardwarecaps.skrewdetectlevel = dev_conf_.g200params.screw_detect_level;
|
|
|
|
|
// ic.hardwarecaps.is_autopaper = dev_conf_.g200params.is_autopaper;
|
|
|
|
|
ic.hardwarecaps.capturepixtype = 0; //暂无参数 获取图像类型
|
|
|
|
|
ic.hardwarecaps.lowpowermode = LowPowerMode::Min_None; //暂无参数 设置休眠时间 两个参数3399未使用
|
|
|
|
|
ic.fillhole.is_fillhole = image_prc_param_.bits.rid_hole;
|
|
|
|
|
ic.fillhole.fillholeratio = rid_hole_range_;
|
|
|
|
|
ic.detachnoise.is_detachnoise = image_prc_param_.bits.noise_optimize;
|
|
|
|
|
ic.detachnoise.detachnoise = noise_range_;
|
2022-05-11 03:27:11 +00:00
|
|
|
|
ic.is_autotext = image_prc_param_.bits.text_direction == TEXT_DIRECTION_AUTO ? 1 :0;
|
2022-05-20 07:53:40 +00:00
|
|
|
|
ic.isfillcolor = is_color_fill;//暂无参数 未使用到
|
2022-05-03 03:56:07 +00:00
|
|
|
|
ic.refuseInflow = image_prc_param_.bits.is_permeate;
|
|
|
|
|
ic.colorCorrection = 0;
|
|
|
|
|
ic.removeMorr = image_prc_param_.bits.remove_morr;
|
|
|
|
|
ic.errorExtention = image_prc_param_.bits.error_extention ;//暂无参数
|
|
|
|
|
ic.textureRemove = image_prc_param_.bits.remove_txtture;//暂无参数
|
|
|
|
|
ic.splitImage = image_prc_param_.bits.split;
|
2022-05-16 09:56:07 +00:00
|
|
|
|
|
2022-05-18 06:22:17 +00:00
|
|
|
|
ic.cropRect.enable = custom_area_;
|
2022-05-16 09:56:07 +00:00
|
|
|
|
int height = (custom_area_br_y_ *ic.resolution_dst) /25.4 - (custom_area_lt_y_ *ic.resolution_dst /25.4);
|
|
|
|
|
int width = (custom_area_br_x_ *ic.resolution_dst) /25.4 - (custom_area_lt_x_ *ic.resolution_dst /25.4);
|
|
|
|
|
ic.cropRect.height = height;
|
|
|
|
|
ic.cropRect.width = width;
|
2022-05-07 07:39:48 +00:00
|
|
|
|
ic.cropRect.x = custom_area_lt_x_ *ic.resolution_dst /25.4;
|
|
|
|
|
ic.cropRect.y = custom_area_lt_y_ *ic.resolution_dst /25.4;
|
|
|
|
|
|
2022-05-16 09:56:07 +00:00
|
|
|
|
ic.multiOutput = (MultiOutput)image_prc_param_.bits.multi_out; //暂无参数
|
2022-05-03 03:56:07 +00:00
|
|
|
|
ic.normalCrop = image_prc_param_.bits.dark_sample;
|
|
|
|
|
ic.dogeardistabce = fractate_level_;
|
|
|
|
|
ic.fadeback = image_prc_param_.bits.erase_bakground;
|
|
|
|
|
ic.fadebackrange = erase_bkg_range_;
|
|
|
|
|
|
|
|
|
|
int filter_clr[] = { 3, 0, 1, 2, 5, 6, 7 };
|
|
|
|
|
if(image_prc_param_.bits.color_mode == COLOR_MODE_24_BITS || image_prc_param_.bits.color_mode == COLOR_MODE_AUTO_MATCH)
|
|
|
|
|
ic.filter = 3;
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
ic.filter = filter_clr[image_prc_param_.bits.rid_color];
|
|
|
|
|
// if(ic.filter != 3)
|
|
|
|
|
// ic.pixtype = 2;
|
|
|
|
|
|
|
|
|
|
ic.hsvcorrect = 0;
|
|
|
|
|
ic.multi_output_red = 0;
|
|
|
|
|
ic.multiOutput = MultiOutput::Unused;
|
|
|
|
|
ic.fadeback = false;
|
|
|
|
|
}
|
2022-06-02 03:47:44 +00:00
|
|
|
|
//多留输出的处理
|
|
|
|
|
if (image_prc_param_.bits.multi_out == MULTI_GRAY_AND_BW && is_multiout)
|
2022-05-16 09:56:07 +00:00
|
|
|
|
{
|
|
|
|
|
ic.pixtype = 1;
|
|
|
|
|
}
|
2022-06-02 03:47:44 +00:00
|
|
|
|
else if ((image_prc_param_.bits.multi_out == MULTI_OUT_ALL ||image_prc_param_.bits.multi_out == MULTI_COLOR_AND_GRAY||image_prc_param_.bits.multi_out == MULTI_COLOR_AND_BW) && is_multiout)
|
|
|
|
|
{
|
|
|
|
|
ic.pixtype = 2;
|
|
|
|
|
}
|
|
|
|
|
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
|
|
|
|
std::lock_guard<std::mutex> lock(io_lock_);
|
|
|
|
|
|
|
|
|
|
ret = io_->write_bulk(&ic, &len);
|
|
|
|
|
|
|
|
|
|
this_thread::sleep_for(chrono::milliseconds(500));
|
|
|
|
|
io_->set_timeout(2000);//必要延时
|
|
|
|
|
}
|
2022-05-30 03:04:26 +00:00
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Write-down 0x%x bytes image process parameters\n", len);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.pixtype=%d", ic.pixtype);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.papertype=%d", ic.papertype);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.AutoCrop_threshold=%d", ic.AutoCrop_threshold);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.autodescrew=%d", ic.autodescrew);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.automaticcolor=%d", ic.automaticcolor);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.brightness=%f", ic.brightness);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.contrast=%f", ic.contrast);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.en_fold=%d", ic.en_fold);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.en_sizecheck=%d", ic.en_sizecheck);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.enhance_color=%d", ic.enhance_color);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.fillbackground=%d", ic.fillbackground);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.filter=%d", ic.filter);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.gamma=%f", ic.gamma);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.hardwarecaps.capturepixtype=%d", ic.hardwarecaps.capturepixtype);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.hardwarecaps.en_doublefeed=%d", ic.hardwarecaps.en_doublefeed);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.hsvcorrect=%d", ic.hsvcorrect);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.imageRotateDegree=%f", ic.imageRotateDegree);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.indent=%d", 5);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autocontrast=%d", ic.is_autocontrast);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autocrop=%d", ic.is_autocrop);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autodiscradblank_normal=%d", ic.is_autodiscradblank_normal);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autodiscradblank_vince=%d", ic.is_autodiscradblank_vince);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autotext=%d", ic.is_autotext);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_backrotate180=%d", ic.is_backrotate180);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_convex=%d", ic.is_convex);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_duplex=%d", ic.is_duplex);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_switchfrontback=%d", ic.is_switchfrontback);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_dogeardetection=%d", ic.is_dogeardetection);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.fillhole.multi_output_red=%d", ic.multi_output_red);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.noise=%d", 8);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.pixtype=%d", ic.pixtype);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.resolution_dst=%f", ic.resolution_dst);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.resolution_native=%f", ic.resolution_native);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.scannum=%d", ic.scannum);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.sharpen=%d", ic.sharpen);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.discardblank_percent=%d", ic.discardblank_percent);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.is_detachnoise=%d", ic.detachnoise.is_detachnoise);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.detachnoise=%d\r ", ic.detachnoise.detachnoise);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.refuseInflow=%d\r ", ic.refuseInflow);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.refuseInflow=%d\r ", ic.refuseInflow);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.removeMorr=%d\r ", ic.removeMorr);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.errorExtention=%d\r ", ic.errorExtention);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.textureRemove=%d\r\n ", ic.refuseInflow);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.fillhole.is_fillhole=%d\r\n ", ic.fillhole.is_fillhole);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.ic.fillhole.fillholeratio=%d\r\n ", ic.fillhole.fillholeratio);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.fadeback=%d\r\n ",ic.fadeback);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.enable=%d\r ", ic.cropRect.enable);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.width=%d\r\n ", ic.cropRect.width);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.height=%d\r\n ", ic.cropRect.height);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.x=%f\r\n ", ic.cropRect.x);
|
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.y=%d\r\n ",ic.cropRect.y);
|
2022-05-11 07:39:38 +00:00
|
|
|
|
|
2022-05-03 03:56:07 +00:00
|
|
|
|
img_conf_ = ic;
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int hg_scanner_239::pop_first_image(void)
|
|
|
|
|
{
|
|
|
|
|
int ret = write_register(SR_IM_POP, 1);
|
|
|
|
|
|
2022-05-30 03:42:16 +00:00
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "popup first image = %s\n", hg_scanner_err_name(ret));
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int hg_scanner_239::read_one_image_from_usb(void)
|
|
|
|
|
{
|
|
|
|
|
//if (is_dev_tx())
|
2022-05-17 07:04:55 +00:00
|
|
|
|
// return SCANNER_ERR_OK;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
//if (!is_kernelsnap_211209_)
|
|
|
|
|
//{
|
|
|
|
|
// if (image_prc_param_.bits.page == PAGE_DOUBLE && !image_prc_param_.bits.fractate_check)
|
|
|
|
|
// if (get_image_count() < 3)
|
2022-05-17 07:04:55 +00:00
|
|
|
|
// return SCANNER_ERR_DEVICE_NO_IMAGE;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
// if (get_image_count() < 2)
|
2022-05-17 07:04:55 +00:00
|
|
|
|
// return SCANNER_ERR_DEVICE_NO_IMAGE;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
//}
|
|
|
|
|
int r = 0,
|
|
|
|
|
total = get_front_data_size(),
|
|
|
|
|
off = 0,
|
2022-05-17 07:04:55 +00:00
|
|
|
|
ret = SCANNER_ERR_OK;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
if (!waiting_for_memory_enough(total))
|
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
status_ = SCANNER_ERR_INSUFFICIENT_MEMORY;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
return status_;
|
|
|
|
|
}
|
|
|
|
|
if (user_cancel_)
|
2022-05-17 07:04:55 +00:00
|
|
|
|
return SCANNER_ERR_USER_CANCELED;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
if (total == -1)
|
|
|
|
|
ret = status_;
|
|
|
|
|
else
|
|
|
|
|
{
|
2022-06-01 03:04:10 +00:00
|
|
|
|
std::shared_ptr<tiny_buffer> buf(aquire_memory(total));
|
2022-05-23 06:10:18 +00:00
|
|
|
|
if (!buf.get())
|
|
|
|
|
return SCANNER_ERR_INSUFFICIENT_MEMORY;
|
|
|
|
|
|
2022-05-03 03:56:07 +00:00
|
|
|
|
// write reading command
|
|
|
|
|
ret = write_register(SR_IM_TX, 1);
|
|
|
|
|
|
2022-05-17 07:04:55 +00:00
|
|
|
|
if (ret == SCANNER_ERR_OK)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
|
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(10));
|
|
|
|
|
r = total;
|
|
|
|
|
{
|
|
|
|
|
std::lock_guard<std::mutex> lock(io_lock_);
|
|
|
|
|
|
|
|
|
|
ret = io_->read_bulk(buf->data(), &r);
|
|
|
|
|
|
2022-05-17 07:04:55 +00:00
|
|
|
|
while (ret == SCANNER_ERR_OK)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
|
|
|
|
off += r;
|
|
|
|
|
if (off >= total)
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
r = total - off;
|
|
|
|
|
ret = io_->read_bulk(buf->data() + off, &r);
|
|
|
|
|
}
|
|
|
|
|
}
|
2022-05-17 07:04:55 +00:00
|
|
|
|
if (ret == SCANNER_ERR_OK)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
2022-05-30 03:42:16 +00:00
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Read image from USB = %s\n", hg_scanner_err_name(ret));
|
2022-05-03 03:56:07 +00:00
|
|
|
|
ret = save_usb_data(buf);
|
2022-05-17 07:04:55 +00:00
|
|
|
|
if (ret == SCANNER_ERR_OK)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
|
|
|
|
pop_first_image();
|
|
|
|
|
//if(image_prc_param_.bits.page == PAGE_SINGLE)
|
|
|
|
|
// pop_first_image();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
char msg[128];
|
2022-05-30 03:42:16 +00:00
|
|
|
|
sprintf(msg, "Read image data from USB err: %s\n", hg_scanner_err_name(ret));
|
2022-05-30 03:04:26 +00:00
|
|
|
|
LOG_INFO(LOG_LEVEL_DEBUG_INFO, msg);
|
2022-05-03 03:56:07 +00:00
|
|
|
|
notify_ui_working_status(msg);
|
2022-05-17 07:04:55 +00:00
|
|
|
|
notify_ui_working_status(STATU_DESC_SCANNER_ERR_TIMEOUT, SANE_EVENT_ERROR);
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
void hg_scanner_239::discard_all_images(void)
|
|
|
|
|
{
|
|
|
|
|
char buf[64];
|
|
|
|
|
HGEIntInfo* info = (HGEIntInfo*)buf;
|
|
|
|
|
int size = sizeof(buf),
|
|
|
|
|
oto = 0,
|
|
|
|
|
pre_img = 0,
|
|
|
|
|
pre_int = 0,
|
2022-05-17 07:04:55 +00:00
|
|
|
|
ret = SCANNER_ERR_OK;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
{
|
|
|
|
|
std::lock_guard<std::mutex> lock(io_lock_);
|
|
|
|
|
oto = io_->get_timeout();
|
|
|
|
|
io_->set_timeout(100);
|
|
|
|
|
ret = io_->read_interrupt(buf, &size);
|
|
|
|
|
}
|
2022-05-17 07:04:55 +00:00
|
|
|
|
while (ret == SCANNER_ERR_OK)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
|
|
|
|
pre_int++;
|
|
|
|
|
if (info->From == IMG)
|
|
|
|
|
{
|
|
|
|
|
while (get_image_count() > 0)
|
|
|
|
|
{
|
|
|
|
|
pop_first_image();
|
|
|
|
|
pre_img++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
size = sizeof(buf);
|
|
|
|
|
{
|
|
|
|
|
std::lock_guard<std::mutex> lock(io_lock_);
|
|
|
|
|
ret = io_->read_interrupt(buf, &size);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
{
|
|
|
|
|
std::lock_guard<std::mutex> lock(io_lock_);
|
|
|
|
|
io_->set_timeout(oto);
|
|
|
|
|
}
|
|
|
|
|
if (pre_int)
|
2022-05-30 03:04:26 +00:00
|
|
|
|
VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "prev-connection has left %d interrupt packet(s) && %d image(s).\n", pre_int, pre_img);
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void hg_scanner_239::init_setting_map(int* setting_map, int count)
|
|
|
|
|
{
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_RESTORE_DEFAULT_SETTINGS] = HG_239_SETTING_RESTORE;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_HELP] = HG_239_SETTING_HELP;
|
|
|
|
|
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_COLOR_MODE] = HG_239_SETTING_COLOR_MODE;
|
2022-05-09 08:59:22 +00:00
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_MULTI_OUT] = HG_239_SETTING_MULTI_OUT;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_ERASE_COLOR] = HG_239_SETTING_ERASE_COLOR;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_ERASE_MULTI_OUT_RED] = HG_239_SETTING_ERASE_MULTI_RED;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_ERASE_ANSWER_RED] = HG_239_SETTING_ERASE_ANSWER_RED;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_ERASE_BACKGROUND] = HG_239_SETTING_ERASE_BACKGROUND;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_ERASE_BACKGROUND_RANGE] = HG_239_SETTING_ERASE_BKG_RANGE;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_NOISE_OPTIMIZE] = HG_239_SETTING_NOISE;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_NOISE_OPTIMIZE_SIZE] = HG_239_SETTING_NOISE_SIZE;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_PAPER] = HG_239_SETTING_PAPER_SIZE;
|
2022-05-07 07:39:48 +00:00
|
|
|
|
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_IS_CUSTOM_AREA] = HG_239_SETTING_CUSTOM_AREA;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_CUSTOM_AREA_LEFT] = HG_239_SETTING_CUSTOM_AREA_LEFT;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_CUSTOM_AREA_RIGHT] = HG_239_SETTING_CUSTOM_AREA_RIGHT;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_CUSTOM_AREA_TOP] = HG_239_SETTING_CUSTOM_AREA_TOP;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_CUSTOM_AREA_BOTTOM] = HG_239_SETTING_CUSTOM_AREA_BOTTOM;
|
|
|
|
|
|
2022-05-03 03:56:07 +00:00
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_PAPER_SIZE_CHECK] = HG_239_SETTING_PAPER_SIZE_CHECK;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_PAGE] = HG_239_SETTING_PAGE;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_PAGE_OMIT_EMPTY_LEVEL] = HG_239_SETTING_SKIP_NILL;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_RESOLUTION] = HG_239_SETTING_RESOLUTION;
|
2022-05-09 11:27:10 +00:00
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_IMG_QUALITY] = HG_239_SETTING_IMG_QUALITY;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_EXCHANGE] = HG_239_SETTING_REVERSE;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_SPLIT] = HG_239_SETTING_SPLIT;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_AUTO_CORRECT] = HG_239_SETTING_CORRECT;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_RID_HOLE] = HG_239_SETTING_ERASE_HOLE;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_RID_HOLE_RANGE] = HG_239_SETTING_HOLE_SEARCH;
|
|
|
|
|
|
2022-05-07 07:39:48 +00:00
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_IS_CUSTOM_GAMMA] = HG_239_SETTING_CUSTOM_GAMMA;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_BRIGHT] = HG_239_SETTING_LIGHT;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_CONTRAST] = HG_239_SETTING_CONTRAST;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_GAMMA] = HG_239_SETTING_GAMMA;
|
|
|
|
|
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_SHARPEN] = HG_239_SETTING_SHARP;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_DARK_SAMPLE] = HG_239_SETTING_SAMPLE;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_ERASE_BLACK_FRAME] = HG_239_SETTING_ERASE_BLACK_BORDER;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_THRESHOLD] = HG_239_SETTING_THRESHOLD;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_ANTI_NOISE_LEVEL] = HG_239_SETTING_ANTI_NOISE;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_MARGIN] = HG_239_SETTING_MARGIN;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_FILL_BACKGROUND] = HG_239_SETTING_FILLING;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_PERMEATE] = HG_239_SETTING_PERMEATE;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_PERMEATE_LV] = HG_239_SETTING_PERMEATE_lv;
|
2022-05-09 08:59:22 +00:00
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_REMOVE_MORR] = HG_239_SETTING_REMOVE_MORR;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_ERROR_EXTENTION] = HG_239_SETTING_ERROR_EXTENTION;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_REMOVE_TXTTURE] = HG_239_SETTING_REMOVE_TXTTURE;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_ULTRASONIC_CHECK] = HG_239_SETTING_ULTRASONIC;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_STAPLE_CHECK] = HG_239_SETTING_STAPLE;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_SCAN_MODE] = HG_239_SETTING_SCAN_METHOD;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_SCAN_COUNT] = HG_239_SETTING_SCAN_COUNT;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_TEXT_DIRECTION] = HG_239_SETTING_DIRECTION;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_ROTATE_BKG_180] = HG_239_SETTING_ROTATE;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_FRACTATE_CHECK] = HG_239_SETTING_FRACTATE;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_FRACTATE_CHECK_LEVEL] = HG_239_SETTING_FRACTATE_COMPLEX;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_SKEW_CHECK] = HG_239_SETTING_SCREW;
|
|
|
|
|
setting_map[HG_BASE_SETTING_INDEX_SKEW_CHECK_LEVEL] = HG_239_SETTING_SCREW_COMPLEX;
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//color_mode =-1 除色选项
|
|
|
|
|
int hg_scanner_239::on_color_mode_changed(int& color_mode)
|
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
int ret = SCANNER_ERR_OK;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
if ((((color_mode == COLOR_MODE_24_BITS || color_mode == COLOR_MODE_AUTO_MATCH) && !dev_conf_.g200params.color) ||
|
|
|
|
|
((color_mode != COLOR_MODE_24_BITS && color_mode != COLOR_MODE_AUTO_MATCH) && dev_conf_.g200params.color)) && color_mode != -1)
|
|
|
|
|
{
|
|
|
|
|
dev_conf_.g200params.color ^= 1;
|
|
|
|
|
ret = writedown_device_configuration();
|
|
|
|
|
if(ret)
|
|
|
|
|
dev_conf_.g200params.color ^= 1;
|
|
|
|
|
}
|
|
|
|
|
if(color_mode == COLOR_MODE_AUTO_MATCH)
|
|
|
|
|
{
|
|
|
|
|
dev_conf_.g200params.color = 1;
|
|
|
|
|
}
|
|
|
|
|
HGSCANCONF d = dev_conf_;
|
|
|
|
|
|
|
|
|
|
if (image_prc_param_.bits.rid_color != RID_COLOR_NONE
|
|
|
|
|
&&(image_prc_param_.bits.color_mode == COLOR_MODE_256_GRAY || image_prc_param_.bits.color_mode == COLOR_MODE_BLACK_WHITE)
|
|
|
|
|
)
|
|
|
|
|
{
|
|
|
|
|
d.g200params.color = 1;
|
|
|
|
|
ret = writedown_device_configuration(&d);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(image_prc_param_.bits.rid_color != RID_COLOR_NONE
|
|
|
|
|
&& (image_prc_param_.bits.color_mode == COLOR_MODE_256_GRAY || image_prc_param_.bits.color_mode == COLOR_MODE_BLACK_WHITE)
|
|
|
|
|
&& color_mode == -1)
|
|
|
|
|
{
|
|
|
|
|
d.g200params.color = 1;
|
|
|
|
|
}
|
|
|
|
|
else if (image_prc_param_.bits.rid_color == RID_COLOR_NONE
|
|
|
|
|
&& (image_prc_param_.bits.color_mode == COLOR_MODE_256_GRAY || image_prc_param_.bits.color_mode == COLOR_MODE_BLACK_WHITE)
|
|
|
|
|
&& color_mode == -1)
|
|
|
|
|
{
|
|
|
|
|
d.g200params.color = 0;
|
|
|
|
|
}
|
|
|
|
|
if(color_mode == -1)
|
|
|
|
|
ret = writedown_device_configuration(&d);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
int hg_scanner_239::on_paper_changed(int& paper)
|
|
|
|
|
{
|
|
|
|
|
bool exact = true;
|
|
|
|
|
int ind = settings::match_best_paper(paper, &exact, &paper_size_),
|
2022-05-17 07:04:55 +00:00
|
|
|
|
ret = exact ? SCANNER_ERR_OK : SCANNER_ERR_NOT_EXACT;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
if (dev_conf_.g200params.paper != settings::paper_map[ind].dev_value)
|
|
|
|
|
{
|
|
|
|
|
int old = dev_conf_.g200params.paper;
|
|
|
|
|
|
|
|
|
|
dev_conf_.g200params.paper = settings::paper_map[ind].dev_value;
|
|
|
|
|
ret = writedown_device_configuration();
|
|
|
|
|
if (ret)
|
|
|
|
|
{
|
|
|
|
|
dev_conf_.g200params.paper = old;
|
|
|
|
|
for (int i = 0; i < ARRAY_SIZE(settings::paper_map); ++i)
|
|
|
|
|
{
|
|
|
|
|
if (settings::paper_map[i].dev_value == old)
|
|
|
|
|
{
|
|
|
|
|
paper = settings::paper_map[i].paper;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if (!exact)
|
2022-05-17 07:04:55 +00:00
|
|
|
|
ret = SCANNER_ERR_NOT_EXACT;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
int hg_scanner_239::on_paper_check_changed(bool& check)
|
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
int ret = SCANNER_ERR_OK;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
if (dev_conf_.g200params.enable_sizecheck ^ check)
|
|
|
|
|
{
|
|
|
|
|
dev_conf_.g200params.enable_sizecheck = check;
|
|
|
|
|
ret = writedown_device_configuration();
|
|
|
|
|
if (ret)
|
|
|
|
|
{
|
|
|
|
|
dev_conf_.g200params.enable_sizecheck = !check;
|
|
|
|
|
check = dev_conf_.g200params.enable_sizecheck;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
int hg_scanner_239::on_resolution_changed(int& dpi)
|
|
|
|
|
{
|
|
|
|
|
bool exact = true;
|
|
|
|
|
int ind = settings::match_best_resolution(dpi, &exact),
|
2022-05-17 07:04:55 +00:00
|
|
|
|
ret = exact ? SCANNER_ERR_OK : SCANNER_ERR_NOT_EXACT;
|
2022-05-09 11:27:10 +00:00
|
|
|
|
|
2022-05-03 03:56:07 +00:00
|
|
|
|
if (dev_conf_.g200params.dpi != settings::resolution_map[ind].dev_value)
|
|
|
|
|
{
|
2022-05-09 11:27:10 +00:00
|
|
|
|
int old = dev_conf_.g200params.dpi;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
dev_conf_.g200params.dpi = settings::resolution_map[ind].dev_value;
|
2022-05-09 11:27:10 +00:00
|
|
|
|
dev_conf_.g200params.dpi = 1;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
ret = writedown_device_configuration();
|
|
|
|
|
if (ret)
|
|
|
|
|
{
|
|
|
|
|
dev_conf_.g200params.dpi = old;
|
|
|
|
|
}
|
|
|
|
|
else if (!exact)
|
2022-05-17 07:04:55 +00:00
|
|
|
|
ret = SCANNER_ERR_NOT_EXACT;
|
2022-05-09 11:27:10 +00:00
|
|
|
|
}
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
2022-05-17 07:04:55 +00:00
|
|
|
|
if (ret == SCANNER_ERR_NOT_EXACT)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
dpi = settings::resolution_map[ind].resolution;
|
2022-05-09 07:02:00 +00:00
|
|
|
|
|
2022-05-09 11:27:10 +00:00
|
|
|
|
|
|
|
|
|
|
2022-05-03 03:56:07 +00:00
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int hg_scanner_239::on_ultrasonic_check_changed(bool& check)
|
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
int ret = SCANNER_ERR_OK;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
if (dev_conf_.g200params.ultrasonic_enable ^ check)
|
|
|
|
|
{
|
|
|
|
|
dev_conf_.g200params.ultrasonic_enable = check;
|
|
|
|
|
ret = writedown_device_configuration();
|
|
|
|
|
if (ret)
|
|
|
|
|
{
|
|
|
|
|
dev_conf_.g200params.ultrasonic_enable = !check;
|
|
|
|
|
check = dev_conf_.g200params.ultrasonic_enable;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
int hg_scanner_239::on_staple_check_changed(bool& check)
|
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
int ret = SCANNER_ERR_OK;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
if (dev_conf_.g200params.staple_enbale ^ check)
|
|
|
|
|
{
|
|
|
|
|
dev_conf_.g200params.staple_enbale = check;
|
|
|
|
|
ret = writedown_device_configuration();
|
|
|
|
|
if (ret)
|
|
|
|
|
{
|
|
|
|
|
dev_conf_.g200params.staple_enbale = !check;
|
|
|
|
|
check = dev_conf_.g200params.staple_enbale;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
int hg_scanner_239::on_skew_check_changed(bool& check)
|
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
int ret = SCANNER_ERR_OK;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
if (dev_conf_.g200params.screw_detect_enable ^ check)
|
|
|
|
|
{
|
|
|
|
|
dev_conf_.g200params.screw_detect_enable = check;
|
|
|
|
|
ret = writedown_device_configuration();
|
|
|
|
|
if (ret)
|
|
|
|
|
{
|
|
|
|
|
dev_conf_.g200params.screw_detect_enable = !check;
|
|
|
|
|
check = dev_conf_.g200params.screw_detect_enable;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
int hg_scanner_239::on_skew_check_level_changed(int& check)
|
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
int ret = SCANNER_ERR_OK,
|
2022-05-03 03:56:07 +00:00
|
|
|
|
val = check,
|
|
|
|
|
old = dev_conf_.g200params.screw_detect_level;
|
|
|
|
|
HGSCANCONF cf;
|
|
|
|
|
|
|
|
|
|
cf.g200params.screw_detect_level = -1;
|
|
|
|
|
|
|
|
|
|
if (val < 0)
|
|
|
|
|
{
|
|
|
|
|
val = 0;
|
2022-05-17 07:04:55 +00:00
|
|
|
|
ret = SCANNER_ERR_NOT_EXACT;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
else if (val > cf.g200params.screw_detect_level)
|
|
|
|
|
{
|
|
|
|
|
val = cf.g200params.screw_detect_level;
|
2022-05-17 07:04:55 +00:00
|
|
|
|
ret = SCANNER_ERR_NOT_EXACT;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
if (val != dev_conf_.g200params.screw_detect_level)
|
|
|
|
|
{
|
|
|
|
|
dev_conf_.g200params.screw_detect_level = val;
|
|
|
|
|
ret = writedown_device_configuration();
|
|
|
|
|
if (ret)
|
|
|
|
|
check = dev_conf_.g200params.screw_detect_level = old;
|
|
|
|
|
}
|
2022-05-17 07:04:55 +00:00
|
|
|
|
if (ret == SCANNER_ERR_OK && val != check)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
|
|
|
|
check = val;
|
2022-05-17 07:04:55 +00:00
|
|
|
|
ret = SCANNER_ERR_NOT_EXACT;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void hg_scanner_239::on_device_reconnected(void)
|
|
|
|
|
{
|
|
|
|
|
int ret = writedown_device_configuration();
|
|
|
|
|
init_version();
|
|
|
|
|
|
2022-05-17 07:04:55 +00:00
|
|
|
|
rewrite_conf_ = ret != SCANNER_ERR_OK;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
if (reset_)
|
|
|
|
|
{
|
|
|
|
|
reset_ = false;
|
|
|
|
|
start();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
int hg_scanner_239::on_scanner_closing(bool force)
|
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
return SCANNER_ERR_OK;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void hg_scanner_239::thread_handle_usb_read(void)
|
|
|
|
|
{
|
|
|
|
|
char buf[64];
|
|
|
|
|
HGEIntInfo* info = (HGEIntInfo*)buf;
|
|
|
|
|
int size = sizeof(buf),
|
2022-05-17 07:04:55 +00:00
|
|
|
|
ret = SCANNER_ERR_OK,
|
2022-05-03 03:56:07 +00:00
|
|
|
|
to_cnt = 0,
|
|
|
|
|
count = 0;
|
|
|
|
|
|
2022-06-01 09:16:09 +00:00
|
|
|
|
//status_ = SCANNER_ERR_DEVICE_BUSY;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
while (run_ )//&& !user_cancel_
|
|
|
|
|
{
|
|
|
|
|
if (user_cancel_)
|
|
|
|
|
{
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
size = sizeof(buf);
|
|
|
|
|
{
|
|
|
|
|
std::lock_guard<std::mutex> lock(io_lock_);
|
|
|
|
|
|
|
|
|
|
ret = io_->read_interrupt(buf, &size);
|
|
|
|
|
io_->set_timeout(1000);
|
|
|
|
|
}
|
2022-05-17 07:04:55 +00:00
|
|
|
|
if (ret == SCANNER_ERR_TIMEOUT)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
|
|
|
|
if (++to_cnt > 10)
|
|
|
|
|
{
|
|
|
|
|
status_ = ret;
|
|
|
|
|
notify_ui_working_status("通信超时", SANE_EVENT_ERROR, ret);
|
2022-05-09 11:27:10 +00:00
|
|
|
|
//stop();
|
2022-05-03 03:56:07 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(500));
|
|
|
|
|
if ((get_status() & 0x03) == 0)
|
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
status_ = SCANNER_ERR_OK;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2022-05-17 07:04:55 +00:00
|
|
|
|
else if (ret != SCANNER_ERR_OK)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
|
|
|
|
status_ = ret;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
to_cnt = 0;
|
|
|
|
|
if (size == sizeof(buf))
|
|
|
|
|
{
|
|
|
|
|
status_ = settings::device_status_to_hg_err(info);
|
2022-05-30 03:42:16 +00:00
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "status from interrupt point is '%s'\n", hg_scanner_err_name(status_));
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
2022-05-17 07:04:55 +00:00
|
|
|
|
if (status_ != SCANNER_ERR_OK && status_ != SCANNER_ERR_TIMEOUT && status_ != SCANNER_ERR_DEVICE_STOPPED)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
|
|
|
|
if (!is_dev_image_process_done())
|
|
|
|
|
{
|
|
|
|
|
int st = status_;
|
|
|
|
|
while (!is_dev_image_process_done())
|
|
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(30));
|
|
|
|
|
|
|
|
|
|
while (get_image_count() > 0)
|
|
|
|
|
{
|
|
|
|
|
ret = read_one_image_from_usb();
|
|
|
|
|
count++;
|
2022-05-17 07:04:55 +00:00
|
|
|
|
if (ret != SCANNER_ERR_OK
|
|
|
|
|
&& ret != SCANNER_ERR_CREATE_FILE_FAILED
|
|
|
|
|
&& ret != SCANNER_ERR_WRITE_FILE_FAILED)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
status_ = st;
|
|
|
|
|
}
|
2022-05-30 03:42:16 +00:00
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_WARNING, "扫描失败, read interrupt返回状态为:%s\n", hg_scanner_err_description(status_));
|
2022-05-17 07:04:55 +00:00
|
|
|
|
//notify_ui_working_status(("扫描失败 " + hg_scanner::error_description((scanner_err)status_)).c_str(), SANE_EVENT_ERROR, status_);
|
2022-05-03 03:56:07 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (info->From == IMG)
|
|
|
|
|
{
|
|
|
|
|
int s = get_status();
|
|
|
|
|
// if (s > 0 && s < 4) // running ...
|
|
|
|
|
{
|
|
|
|
|
while (get_image_count() > 0)
|
|
|
|
|
{
|
|
|
|
|
count++;
|
|
|
|
|
ret = read_one_image_from_usb();
|
2022-05-17 07:04:55 +00:00
|
|
|
|
if (ret != SCANNER_ERR_OK
|
|
|
|
|
&& ret != SCANNER_ERR_CREATE_FILE_FAILED
|
|
|
|
|
&& ret != SCANNER_ERR_WRITE_FILE_FAILED)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
if (user_cancel_)
|
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
if (ret == SCANNER_ERR_INSUFFICIENT_MEMORY)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
stop();
|
2022-05-17 07:04:55 +00:00
|
|
|
|
status_ = ret = SCANNER_ERR_USER_CANCELED;
|
2022-05-30 03:42:16 +00:00
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "用户取消操作 '%s'\n", hg_scanner_err_name(status_));
|
2022-05-03 03:56:07 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
//else
|
2022-05-30 03:04:26 +00:00
|
|
|
|
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "status(0x%x) is not accept in usb thread\n", status);
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
else if (info->From == STOPSCAN)
|
|
|
|
|
{
|
2022-05-30 03:04:26 +00:00
|
|
|
|
LOG_INFO(LOG_LEVEL_DEBUG_INFO, "received 'STOPSCAN' message in usb thread, check remaining image and finish scanning ...\n");
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
// fetch all buffered images and exit ...
|
|
|
|
|
while(!is_dev_image_process_done())
|
|
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(30));
|
|
|
|
|
|
|
|
|
|
while (get_image_count() > 0)
|
|
|
|
|
{
|
|
|
|
|
ret = read_one_image_from_usb();
|
|
|
|
|
count++;
|
2022-05-17 07:04:55 +00:00
|
|
|
|
if (ret != SCANNER_ERR_OK
|
|
|
|
|
&& ret != SCANNER_ERR_CREATE_FILE_FAILED
|
|
|
|
|
&& ret != SCANNER_ERR_WRITE_FILE_FAILED)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
if (count == 0)
|
|
|
|
|
{
|
|
|
|
|
std::lock_guard<std::mutex> lock(io_lock_);
|
|
|
|
|
|
2022-05-30 03:04:26 +00:00
|
|
|
|
LOG_INFO(LOG_LEVEL_DEBUG_INFO, "First message received from USB is 'STOPSCAN'\n");
|
2022-05-03 03:56:07 +00:00
|
|
|
|
// notify_ui_working_status(STATU_DESC_DEVICE_RESET);
|
|
|
|
|
// reset_ = true;
|
|
|
|
|
// ret = io_->reset();
|
2022-05-17 07:04:55 +00:00
|
|
|
|
// status_ = SCANNER_ERR_IO;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
2022-05-17 07:04:55 +00:00
|
|
|
|
else if (status_ == SCANNER_ERR_TIMEOUT || status_ == SCANNER_ERR_IO || status_ == SCANNER_ERR_DEVICE_STOPPED)
|
|
|
|
|
status_ = SCANNER_ERR_OK;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
int s = get_status();
|
2022-05-30 03:04:26 +00:00
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "status after received 'STOPSCAN': 0x%x\n", s);
|
2022-05-03 03:56:07 +00:00
|
|
|
|
if (count || (s & 3) == 0)
|
|
|
|
|
{
|
2022-05-30 03:04:26 +00:00
|
|
|
|
LOG_INFO(LOG_LEVEL_DEBUG_INFO, "Really stopped ^_^\n");
|
2022-05-03 03:56:07 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if (info->From == V4L2)
|
|
|
|
|
{
|
2022-05-30 03:04:26 +00:00
|
|
|
|
VLOG_MINI_2(LOG_LEVEL_WARNING, "V4L2 message received, code = %d, index = %d\n", info->Code, info->Img_Index);
|
2022-05-03 03:56:07 +00:00
|
|
|
|
// stop();
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
// error handling ...
|
2022-05-30 03:42:16 +00:00
|
|
|
|
VLOG_MINI_4(LOG_LEVEL_DEBUG_INFO, "Read HGEIntInfo: From = %d, Code = %d, Img_Index = %d, status = %s\n", info->From, info->Code, info->Img_Index, hg_scanner_err_name(status_));
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
2022-05-30 03:04:26 +00:00
|
|
|
|
VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "read %d bytes, sizeof(buf) = %d\n", size, sizeof(buf));
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
this_thread::sleep_for(chrono::milliseconds(10));
|
|
|
|
|
}
|
2022-05-30 03:42:16 +00:00
|
|
|
|
VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "USB thread exit with code: %s, status = %s\n", hg_scanner_err_name(ret), hg_scanner_err_name(status_));
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int hg_scanner_239::start(void)
|
|
|
|
|
{
|
2022-05-20 09:11:50 +00:00
|
|
|
|
bool handled = false;
|
|
|
|
|
int ret = try_third_app_handle_start(handled),
|
2022-05-03 03:56:07 +00:00
|
|
|
|
val = 0;
|
|
|
|
|
|
2022-05-20 09:11:50 +00:00
|
|
|
|
user_cancel_ = false;
|
|
|
|
|
|
2022-05-20 06:46:25 +00:00
|
|
|
|
// for third-sane-app invoking, added on 2022-05-19
|
2022-05-20 09:11:50 +00:00
|
|
|
|
if (handled)
|
|
|
|
|
return ret;
|
2022-05-20 06:46:25 +00:00
|
|
|
|
|
2022-05-03 03:56:07 +00:00
|
|
|
|
user_cancel_ = false;
|
|
|
|
|
cb_mem_ = true;
|
2022-05-30 03:04:26 +00:00
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "scanner status: 0x%x\n", get_status());
|
2022-05-03 03:56:07 +00:00
|
|
|
|
notify_ui_working_status(STATU_DESC_PREPARE_START);
|
|
|
|
|
|
|
|
|
|
reset();
|
|
|
|
|
get_roller_num();
|
|
|
|
|
val = get_sleep_time();
|
|
|
|
|
//if (val != 1)
|
|
|
|
|
//{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
// status_ = SCANNER_ERR_DEVICE_SLEEPING;
|
2022-05-30 03:04:26 +00:00
|
|
|
|
// VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "scanner's status(0x%x) is considerring as sleepping.\n", val);
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
// return status_;
|
|
|
|
|
//}
|
|
|
|
|
val = get_scan_mode();
|
2022-05-17 07:04:55 +00:00
|
|
|
|
if (status_ == SCANNER_ERR_DEVICE_NOT_FOUND)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
return status_;
|
|
|
|
|
|
|
|
|
|
if (val == -1)
|
|
|
|
|
return status_;
|
|
|
|
|
if (val & 1)
|
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
status_ = SCANNER_ERR_DEVICE_COUNT_MODE;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
return status_;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
notify_ui_working_status(STATU_DESC_REWRITE_CONFIGURATION);
|
|
|
|
|
//if(rewrite_conf_)
|
|
|
|
|
{
|
|
|
|
|
//协议设置方式一定要注意 1:协议结构体做好,start一起发送 2:每次设置一次发送一次 注意事项:除色时颜色切换维彩色使用的是临时变量,下发一次被释放,如果start再次发就会导致协议层被覆盖
|
|
|
|
|
//ret = writedown_device_configuration();
|
|
|
|
|
}
|
|
|
|
|
|
2022-05-17 07:04:55 +00:00
|
|
|
|
if(ret == SCANNER_ERR_OK)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
|
|
|
|
ret = writedown_image_configuration();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
|
{
|
2022-05-30 03:42:16 +00:00
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_WARNING, "Write down image process parameters fail is(%s), the result will be unpredictable.\n", hg_scanner_err_name(ret));
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
std::string info(STATU_DESC_REWRITE_CONFIGURATION);
|
|
|
|
|
|
2022-05-30 03:42:16 +00:00
|
|
|
|
info += std::string("\345\244\261\350\264\245\357\274\232") + hg_scanner_err_name(ret);
|
2022-05-03 03:56:07 +00:00
|
|
|
|
notify_ui_working_status(info.c_str(), SANE_EVENT_ERROR, ret);
|
|
|
|
|
}
|
|
|
|
|
|
2022-05-17 07:04:55 +00:00
|
|
|
|
if (ret != SCANNER_ERR_OK)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
2022-05-30 03:42:16 +00:00
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_WARNING, "start status01 is(%s), the result will be unpredictable.\n", hg_scanner_err_name(ret));
|
2022-05-03 03:56:07 +00:00
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
ret = get_scanner_paperon();
|
2022-05-17 07:04:55 +00:00
|
|
|
|
if (ret == SCANNER_ERR_DEVICE_NO_PAPER)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
|
|
|
|
status_ = ret;
|
2022-05-17 07:04:55 +00:00
|
|
|
|
notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER, SANE_EVENT_ERROR, status_);
|
2022-05-30 03:04:26 +00:00
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_WARNING, "device start status is(%s)\n", STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER);
|
2022-05-04 03:07:55 +00:00
|
|
|
|
return ret;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ret = write_command(SC_START);
|
|
|
|
|
|
|
|
|
|
io_->set_timeout(1000);
|
2022-05-17 07:04:55 +00:00
|
|
|
|
if (ret == SCANNER_ERR_OK)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
//status_ = SCANNER_ERR_DEVICE_BUSY;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
wait_usb_.notify();
|
|
|
|
|
this_thread::sleep_for(chrono::milliseconds(100));
|
2022-06-01 09:16:09 +00:00
|
|
|
|
ret = try_third_app_after_start(ret);
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
status_ = ret;
|
2022-05-30 03:42:16 +00:00
|
|
|
|
VLOG_MINI_3(LOG_LEVEL_WARNING, "(%s)[Thread %s]Send start command = %s\n", hg_log::current_time().c_str(), hg_log::format_current_thread_id().c_str(), hg_scanner_err_name(ret));
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
2022-06-01 09:16:09 +00:00
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_WARNING, "start result: %s\n", hg_scanner_err_name(ret));
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
int hg_scanner_239::stop(void)
|
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
int ret = SCANNER_ERR_OK;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
user_cancel_ = true;
|
|
|
|
|
ret = write_command(SC_STOP);
|
|
|
|
|
io_->set_timeout(500);
|
2022-06-01 03:04:10 +00:00
|
|
|
|
final_imgs_.clear();
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
return status_;
|
|
|
|
|
}
|
|
|
|
|
int hg_scanner_239::reset(void)
|
|
|
|
|
{
|
2022-06-01 03:04:10 +00:00
|
|
|
|
final_imgs_.clear();
|
2022-05-03 03:56:07 +00:00
|
|
|
|
discard_all_images();
|
|
|
|
|
|
|
|
|
|
return status_;
|
|
|
|
|
}
|
|
|
|
|
int hg_scanner_239::device_io_control(unsigned long code, void* data, unsigned* len)
|
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
int ret = SCANNER_ERR_OUT_OF_RANGE;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
if (HG_CONTROL_CODE_OPTION_ENABLE == code)
|
|
|
|
|
{
|
|
|
|
|
OPTEN* opten = (OPTEN*)data;
|
|
|
|
|
|
2022-05-17 07:04:55 +00:00
|
|
|
|
ret = SCANNER_ERR_OK;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
if (opten->opt_num == HG_239_SETTING_CORRECT && !opten->enabled) // for BUG-20 modified by Gongbing on 2022-03-12
|
|
|
|
|
{
|
|
|
|
|
bool enable = true;
|
|
|
|
|
setting_automatic_skew(&enable);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if (IO_CTRL_CODE_TEST_SINGLE == code)
|
|
|
|
|
{
|
|
|
|
|
test_1_paper_ = true;
|
|
|
|
|
ret = start();
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
ret = hg_scanner::device_io_control(code, data, len);
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
std::string hg_scanner_239::get_firmware_version(void)
|
|
|
|
|
{
|
|
|
|
|
return control_fetch(SR_GET_FWVERSION, 0, 20);
|
|
|
|
|
}
|
|
|
|
|
std::string hg_scanner_239::get_serial_num(void)
|
|
|
|
|
{
|
|
|
|
|
return control_fetch(SR_GET_SERIALNUM, 0, 20);
|
|
|
|
|
}
|
|
|
|
|
std::string hg_scanner_239::get_ip(void)
|
|
|
|
|
{
|
|
|
|
|
return control_fetch(SR_GET_IPADDR, 0, 40);
|
|
|
|
|
}
|
|
|
|
|
int hg_scanner_239::get_roller_num(void)
|
|
|
|
|
{
|
|
|
|
|
int val = 0,
|
|
|
|
|
ret = read_register(SR_GET_ROLLER_NUM, &val);
|
|
|
|
|
|
2022-05-17 07:04:55 +00:00
|
|
|
|
if (ret == SCANNER_ERR_OK)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
return val;
|
|
|
|
|
else
|
|
|
|
|
{
|
2022-05-30 03:42:16 +00:00
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "get_roller_num = %s\n", hg_scanner_err_name(ret));
|
2022-05-03 03:56:07 +00:00
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
int hg_scanner_239::clear_roller_num(void)
|
|
|
|
|
{
|
|
|
|
|
int val = 0,
|
|
|
|
|
ret = read_register(SR_CLR_ROLLER_NUM, &val);
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
|
|
int hg_scanner_239::set_leaflet_scan(void)
|
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
int ret = SCANNER_ERR_OK;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
test_1_paper_ = true;
|
|
|
|
|
|
|
|
|
|
ret = start();
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
int hg_scanner_239::get_abuot_info(void)
|
|
|
|
|
{
|
|
|
|
|
|
2022-05-17 07:04:55 +00:00
|
|
|
|
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
int hg_scanner_239::restore_default_setting(void)
|
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
int hg_scanner_239::set_final_image_format(SANE_FinalImgFormat* fmt)
|
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int hg_scanner_239::get_compression_format(void)
|
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
int hg_scanner_239::set_compression_format(void)
|
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
int hg_scanner_239::set_auto_color_type(void)
|
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int hg_scanner_239::get_device_code(void)
|
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
int hg_scanner_239::get_sleep_time(SANE_Power* getime)
|
|
|
|
|
{
|
|
|
|
|
int val = 0,
|
|
|
|
|
ret = read_register(SR_GET_SLEEPTIME, &val);
|
|
|
|
|
|
2022-05-17 07:04:55 +00:00
|
|
|
|
if (ret == SCANNER_ERR_OK)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
*getime = (SANE_Power)val;
|
|
|
|
|
else
|
|
|
|
|
{
|
2022-05-30 03:42:16 +00:00
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "get_sleep_time = %s\n", hg_scanner_err_name(ret));
|
2022-05-03 03:56:07 +00:00
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int hg_scanner_239::set_sleep_time(int setsleepime)
|
|
|
|
|
{
|
|
|
|
|
int ret = write_register(SR_SET_SLEEPTIME, setsleepime);
|
|
|
|
|
|
2022-05-30 03:42:16 +00:00
|
|
|
|
VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "set sleep time to %d = %s\n", setsleepime, hg_scanner_err_name(ret));
|
2022-05-03 08:44:13 +00:00
|
|
|
|
|
|
|
|
|
return ret;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
int hg_scanner_239::get_dogear_distance(void)
|
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
int hg_scanner_239::set_dogear_distance(void)
|
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
int hg_scanner_239::get_scanner_paperon(SANE_Bool* paperon)
|
|
|
|
|
{
|
|
|
|
|
int val = 0,
|
|
|
|
|
ret = read_register(SR_GET_PAPERON, &val);
|
|
|
|
|
|
2022-05-17 07:04:55 +00:00
|
|
|
|
if (ret == SCANNER_ERR_OK)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
|
|
|
|
if (!val)
|
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
ret = SCANNER_ERR_DEVICE_NO_PAPER;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
if (paperon)
|
|
|
|
|
{
|
|
|
|
|
*paperon = true;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
ret = SCANNER_ERR_OK;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
if (paperon)
|
|
|
|
|
{
|
|
|
|
|
*paperon = false;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2022-05-30 03:42:16 +00:00
|
|
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "get_scanner_paperon = %s\n", hg_scanner_err_name(ret));
|
2022-05-03 03:56:07 +00:00
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
int hg_scanner_239::set_scan_when_paper_on(void)
|
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
int hg_scanner_239::get_scan_when_paper_on(void)
|
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
int hg_scanner_239::get_scan_with_hole(void)
|
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
int hg_scanner_239::set_scan_with_hole(void)
|
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
int hg_scanner_239::get_scan_is_sleep()
|
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|