lmh188
/
code_device
mirror of http://192.168.10.5:8099/sane/code_device.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

添加关于信息中单个子条目的属性操作；支持部分固有属性不配置在JSON中也能正常操作（测试需要注意对所有属性操作进行验证）

This commit is contained in:
gb 2023-05-13 16:26:43 +08:00
parent 3dd6e38cf7
commit cf2673f2b1
9 changed files with 483 additions and 29 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
hgdriver/hgdev/char_const.h
View File

@ -10,6 +10,9 @@
// 公司名称 & 信息
#ifdef OEM_HANWANG
#define ADMIN_NAME "hvcuser"
#define ADMIN_PWD "hvc2023"
// #define COMPANY_NAME "汉王科技股份有限公司"
#define COMPANY_NAME "\346\261\211\347\216\213\347\247\221\346\212\200\350\202\241\344\273\275\346\234\211\351\231\220\345\205\254\345\217\270"
// #define BRAND_APP_NAME "汉王扫描应用程序"
@ -39,6 +42,9 @@
#define BRAND_URL_GPS "https://j.map.baidu.com/68/idCJ"
#elif defined(OEM_LISICHENG)
#define ADMIN_NAME "lscuser"
#define ADMIN_PWD "lsc2023"
// #define COMPANY_NAME "北京立思辰计算机技术有限公司"
#define COMPANY_NAME "\345\214\227\344\272\254\347\253\213\346\200\235\350\276\260\350\256\241\347\256\227\346\234\272\346\212\200\346\234\257\346\234\211\351\231\220\345\205\254\345\217\270"
// #define BRAND_APP_NAME "立思辰扫描应用程序"
@ -67,6 +73,9 @@
#define BRAND_COMPANY_GPS "\347\231\276\345\272\246\345\234\260\345\233\276\350\256\277\351\227\256"
#define BRAND_URL_GPS "https://j.map.baidu.com/5f/Xzh"
#elif defined(OEM_CANGTIAN)
#define ADMIN_NAME "ctuser"
#define ADMIN_PWD "ct2023"
// #define COMPANY_NAME "沧田智能信息技术有限公司"
#define COMPANY_NAME "\346\262\247\347\224\260\346\231\272\350\203\275\344\277\241\346\201\257\346\212\200\346\234\257\346\234\211\351\231\220\345\205\254\345\217\270"
// #define BRAND_APP_NAME "沧田扫描应用程序"
@ -95,6 +104,9 @@
#define BRAND_COMPANY_GPS "\347\231\276\345\272\246\345\234\260\345\233\276\350\256\277\351\227\256"
#define BRAND_URL_GPS "https://j.map.baidu.com/27/KGSu"
#elif defined(OEM_ZHONGJING)
#define ADMIN_NAME "zjuser"
#define ADMIN_PWD "zj2023"
// #define COMPANY_NAME "上海中晶科技有限公司"
#define COMPANY_NAME "\344\270\212\346\265\267\344\270\255\346\231\266\347\247\221\346\212\200\346\234\211\351\231\220\345\205\254\345\217\270"
// #define BRAND_APP_NAME "中晶扫描应用程序"
@ -123,6 +135,9 @@
#define BRAND_COMPANY_GPS "\347\231\276\345\272\246\345\234\260\345\233\276\350\256\277\351\227\256"
#define BRAND_URL_GPS "https://j.map.baidu.com/67/BWSu"
#elif defined(OEM_ZIGUANG)
#define ADMIN_NAME "zguser"
#define ADMIN_PWD "zg2023"
// #define COMPANY_NAME "紫光股份有限公司"
#define COMPANY_NAME "\347\264\253\345\205\211\350\202\241\344\273\275\346\234\211\351\231\220\345\205\254\345\217\270"
// #define BRAND_APP_NAME "紫光扫描应用程序"
@ -151,6 +166,9 @@
#define BRAND_COMPANY_GPS "\347\231\276\345\272\246\345\234\260\345\233\276\350\256\277\351\227\256"
#define BRAND_URL_GPS "https://j.map.baidu.com/dd/eNIJ"
#else
#define ADMIN_NAME "hguser"
#define ADMIN_PWD "hg2016"
// #define COMPANY_NAME "宁波华高信息科技有限公司"
#define COMPANY_NAME "\345\256\201\346\263\242\345\215\216\351\253\230\344\277\241\346\201\257\347\247\221\346\212\200\346\234\211\351\231\220\345\205\254\345\217\270"
// #define BRAND_APP_NAME "华高扫描应用程序"

65
hgdriver/hgdev/hg_scanner.cpp
View File

@ -141,7 +141,7 @@ static bool is_firstopen_ = true; //第二次打开设备就不在去获取
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// hg_scanner
hg_scanner::hg_scanner(ScannerSerial serial, const char* dev_name, usb_io* io, int pid)
: name_(dev_name ? dev_name : ""), io_(io), status_(SCANNER_ERR_NOT_START), serial_(serial)
: name_(dev_name ? dev_name : ""), family_(""), io_(io), status_(SCANNER_ERR_NOT_START), serial_(serial)
, scan_count_(-1), run_(true), paper_size_(TwSS::A4), erase_bkg_range_(10), read_over_with_no_data_(false)
, noise_range_(30), omit_empty_level_(50), resolution_(200), rid_hole_range_(10.0f)
, bright_(128), contrast_(4), gamma_(1.0f), threshold_(40), anti_noise_(8), margin_(5)
@ -634,6 +634,10 @@ void hg_scanner::init_setting_func_map(void)
setting_map_[SANE_STD_OPT_NAME_COLOR_CORRECTION] = &hg_scanner::setting_color_correction;
setting_map_[SANE_STD_OPT_NAME_WAIT_SCAN_EXIT] = &hg_scanner::setting_auto_paper_scan_exit_time;
setting_map_[SANE_STD_OPT_NAME_DEVICE_VID] = &hg_scanner::setting_get_dev_vid;
setting_map_[SANE_STD_OPT_NAME_DEVICE_PID] = &hg_scanner::setting_get_dev_pid;
setting_map_[SANE_STD_OPT_NAME_DEVICE_MODEL] = &hg_scanner::setting_get_dev_family;
setting_map_[SANE_STD_OPT_NAME_DEVICE_NAME] = &hg_scanner::setting_get_dev_name;
setting_map_[SANE_STD_OPT_NAME_DEVICE_SERIAL_NO] = &hg_scanner::setting_get_dev_sn;
setting_map_[SANE_STD_OPT_NAME_FIRMWARE_VERSION] = &hg_scanner::setting_get_dev_fmver;
setting_map_[SANE_STD_OPT_NAME_DEVICE_IP_ADDR] = &hg_scanner::setting_get_dev_ip;
@ -648,6 +652,25 @@ std::string hg_scanner::setting_name_from(const char* n_or_id, int* id)
if (id)
*id = (long long)n_or_id;
#define RETURN_FIXED_NAME(id) \
if((unsigned long)n_or_id == SANE_OPT_ID_##id) \
return SANE_STD_OPT_NAME_##id;
RETURN_FIXED_NAME(DRIVER_VERSION);
RETURN_FIXED_NAME(MANUFACTURER);
RETURN_FIXED_NAME(COPYRIGHT);
RETURN_FIXED_NAME(CO_URL);
RETURN_FIXED_NAME(CO_TEL);
RETURN_FIXED_NAME(CO_ADDR);
RETURN_FIXED_NAME(CO_GPS);
RETURN_FIXED_NAME(HELP);
RETURN_FIXED_NAME(LOGIN);
RETURN_FIXED_NAME(LOGOUT);
RETURN_FIXED_NAME(ROLLER_COUNT);
RETURN_FIXED_NAME(DRIVER_LOG);
if ((unsigned long)n_or_id == SANE_OPT_ID_DRIVER_LOG)
return SANE_STD_OPT_NAME_GET_DEVS_L0G;
if ((unsigned long)n_or_id < jsn_children_.size())
return jsn_children_[(unsigned long)n_or_id];
else
@ -2317,6 +2340,40 @@ int hg_scanner::setting_auto_paper_scan_exit_time(void* data)
//VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "set paper_scan_exit_time from (%d)min to (%s)min = %d\n", is_auto_paper_scan_exit_time, (char*)data);
return 0;
}
int hg_scanner::setting_get_dev_vid(void* data)
{
if (io_)
{
*(int*)data = io_->get_vid();
return SCANNER_ERR_OK;
}
return SCANNER_ERR_NOT_OPEN;
}
int hg_scanner::setting_get_dev_pid(void* data)
{
if (io_)
{
*(int*)data = io_->get_pid();
return SCANNER_ERR_OK;
}
return SCANNER_ERR_NOT_OPEN;
}
int hg_scanner::setting_get_dev_family(void* data)
{
strcpy((char*)data, family_.c_str());
return SCANNER_ERR_OK;
}
int hg_scanner::setting_get_dev_name(void* data)
{
strcpy((char*)data, name_.c_str());
return SCANNER_ERR_OK;
}
int hg_scanner::setting_get_dev_sn(void* data)
{
if (!data)
@ -3006,6 +3063,10 @@ void hg_scanner::set_ui_callback(sane_callback cb, bool enable_async_io)
async_io_ = enable_async_io;
is_white_0_ = !async_io_;
}
void hg_scanner::set_dev_family(const char* family)
{
family_ = family ? family : "";
}
void hg_scanner::set_read_over_with_no_data(bool no_data)
{
read_over_with_no_data_ = no_data;
@ -3073,6 +3134,8 @@ int hg_scanner::set_setting(const char* name, void* data, int len)
if (hit)
{
ret = (this->*setting_map_[real_n])(data);
if (!setting_jsn_.contains(real_n)) // non-json value, return immediately
return ret;
}
else
{

6
hgdriver/hgdev/hg_scanner.h
View File

@ -129,6 +129,7 @@ class hg_scanner
bool notify_setting_result_;
std::string name_;
std::string family_;
std::string save_multiout; //保存多留输出类型
bool save_sizecheck;
bool read_over_with_no_data_; // 针对第三方调用，在最后一段数据时是否返回“SCANNER_ERR_NO_DATA”
@ -266,6 +267,10 @@ protected:
int setting_fold_type(void* data);
int setting_color_correction(void* data);
int setting_auto_paper_scan_exit_time(void* data);
int setting_get_dev_vid(void* data);
int setting_get_dev_pid(void* data);
int setting_get_dev_family(void* data);
int setting_get_dev_name(void* data);
int setting_get_dev_sn(void* data);
int setting_get_dev_fmver(void* data);
int setting_get_dev_ip(void* data);
@ -459,6 +464,7 @@ protected:
public:
void set_ui_callback(sane_callback cb, bool enable_async_io);
void set_dev_family(const char* family);
void set_read_over_with_no_data(bool no_data);
int reset_io(usb_io* io);
int io_disconnected(void);

183
hgdriver/hgdev/scanner_manager.cpp
View File

@ -127,7 +127,7 @@ bool hg_scanner_mgr::read_over_with_eof_ = true;
uint32_t hg_scanner_mgr::unique_img_id_ = 0;;
std::mutex hg_scanner_mgr::mutex_img_id;
hg_scanner_mgr::hg_scanner_mgr() : same_ind_(1)
hg_scanner_mgr::hg_scanner_mgr() : same_ind_(1), user_(""), pwd_("")
{
usb_manager::instance()->register_hotplug(&hg_scanner_mgr::usb_event_handle, this);
}
@ -714,6 +714,7 @@ scanner_err hg_scanner_mgr::hg_scanner_open(scanner_handle* h, const char* name,
if (scanner)
{
scanner->set_ui_callback(&hg_scanner_mgr::ui_default_callback, hg_scanner_mgr::async_io_enabled_);
scanner->set_dev_family(g_supporting_devices[it->ind].type.c_str());
scanner->set_read_over_with_no_data(hg_scanner_mgr::read_over_with_eof_);
}
@ -755,6 +756,119 @@ scanner_err hg_scanner_mgr::hg_scanner_get_parameter(scanner_handle h, const cha
if (!len)
return SCANNER_ERR_INVALID_PARAMETER;
// global options ...
if (!IS_PTR_NUMBER(name))
{
if (strcmp(name, SANE_STD_OPT_NAME_DRIVER_VERSION) == 0)
{
char buf[40] = { 0 };
sprintf(buf, "%d.%d.%d.%d", hg_scanner_mgr::ver_major_, hg_scanner_mgr::ver_minor_, hg_scanner_mgr::ver_build_, hg_scanner_mgr::ver_patch_);
if (*len <= strlen(buf))
{
*len = strlen(buf) + 1;
return SCANNER_ERR_INSUFFICIENT_MEMORY;
}
strcpy(data, buf);
*len = strlen(buf);
return SCANNER_ERR_OK;
}
#define TRY_STR_OPT(n, optn) \
if (strcmp(name, SANE_STD_OPT_NAME_##n) == 0) \
{ \
std::string n(GET_LANG(optn, nullptr)); \
if (*len <= n.length()) \
{ \
*len = n.length() + 1; \
\
return SCANNER_ERR_INSUFFICIENT_MEMORY; \
} \
\
strcpy(data, n.c_str()); \
*len = n.length(); \
\
return SCANNER_ERR_OK; \
}
TRY_STR_OPT(MANUFACTURER, COMPANY_NAME);
TRY_STR_OPT(COPYRIGHT, BRAND_COPYRIGHT);
TRY_STR_OPT(CO_URL, BRAND_URL_COMPANY_URL);
TRY_STR_OPT(CO_TEL, BRAND_COMPANY_TEL);
TRY_STR_OPT(CO_ADDR, BRAND_COMPANY_ADDRESS);
TRY_STR_OPT(CO_GPS, BRAND_URL_GPS);
// following options getting operation is implemented in 'set' ...
{
if (strcmp(SANE_STD_OPT_NAME_DEVICE_VID, name) == 0 ||
strcmp(SANE_STD_OPT_NAME_DEVICE_PID, name) == 0 ||
strcmp(SANE_STD_OPT_NAME_DEVICE_NAME, name) == 0 ||
strcmp(SANE_STD_OPT_NAME_DEVICE_MODEL, name) == 0 ||
strcmp(SANE_STD_OPT_NAME_DEVICE_SERIAL_NO, name) == 0 ||
strcmp(SANE_STD_OPT_NAME_FIRMWARE_VERSION, name) == 0 ||
strcmp(SANE_STD_OPT_NAME_DEVICE_IP_ADDR, name) == 0 ||
strcmp(SANE_STD_OPT_NAME_ROLLER_COUNT, name) == 0 ||
strcmp(SANE_STD_OPT_NAME_TOTAL_COUNT, name) == 0 ||
strcmp(SANE_STD_OPT_NAME_GET_DEVS_L0G, name) == 0)
return (scanner_err)SCAN_PTR(h)->set_setting(name, data, *len);
}
if (strcmp(SANE_STD_OPT_NAME_DRIVER_LOG, name) == 0)
{
if (!data)
return SCANNER_ERR_INVALID_PARAMETER;
if (user_ == ADMIN_NAME && pwd_ == ADMIN_PWD)
{
std::string f(hg_log::log_file_path());
if (f.empty())
return SCANNER_ERR_NO_DATA;
{
std::ifstream in(f.c_str(), ios::in | ios::binary);
std::ofstream out(data, ios::out | ios::binary);
out << in.rdbuf();
}
remove(f.c_str());
return SCANNER_ERR_OK;
}
else
return SCANNER_ERR_ACCESS_DENIED;
}
else if (strcmp(SANE_STD_OPT_NAME_GET_DEVS_L0G, name) == 0)
{
if (!data)
return SCANNER_ERR_INVALID_PARAMETER;
if (user_ == ADMIN_NAME && pwd_ == ADMIN_PWD)
{
char path[300] = { 0 };
int l = LOG_FILE_DEVICE,
ret = hg_scanner_control(h, IO_CTRL_CODE_GET_LOG_FILE, path, (unsigned*)&l);
if (ret == SCANNER_ERR_OK)
{
{
std::ifstream in(path, ios::in | ios::binary);
std::ofstream out(data, ios::out | ios::binary);
out << in.rdbuf();
}
remove(path);
}
return (scanner_err)ret;
}
else
return SCANNER_ERR_ACCESS_DENIED;
}
if (strcmp(SANE_STD_OPT_NAME_LOGIN, name) == 0 ||
strcmp(SANE_STD_OPT_NAME_LOGOUT, name) == 0)
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int l = *len,
err = SCAN_PTR(h)->get_setting(name, data, &l, id);
@ -764,6 +878,73 @@ scanner_err hg_scanner_mgr::hg_scanner_get_parameter(scanner_handle h, const cha
}
scanner_err hg_scanner_mgr::hg_scanner_set_parameter(scanner_handle h, const char* name, void* data, long len)
{
if (!IS_PTR_NUMBER(name))
{
if (strcmp(SANE_STD_OPT_NAME_CO_GPS, name) == 0 ||
strcmp(SANE_STD_OPT_NAME_CO_ADDR, name) == 0 ||
strcmp(SANE_STD_OPT_NAME_CO_TEL, name) == 0 ||
strcmp(SANE_STD_OPT_NAME_CO_URL, name) == 0 ||
strcmp(SANE_STD_OPT_NAME_COPYRIGHT, name) == 0 ||
strcmp(SANE_STD_OPT_NAME_MANUFACTURER, name) == 0 ||
strcmp(SANE_STD_OPT_NAME_DRIVER_VERSION, name) == 0)
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
if (strcmp(SANE_STD_OPT_NAME_LOGIN, name) == 0)
{
// str32 + 32
char* n = (char*)data,
* p = n + 32;
user_ = n;
pwd_ = p;
return SCANNER_ERR_OK; SCANNER_ERR_ACCESS_DENIED;
}
else if (strcmp(SANE_STD_OPT_NAME_LOGOUT, name) == 0)
{
// str32 + 32
char* n = (char*)data,
* p = n + 32;
if (user_ == n && pwd_ == p)
{
user_ = "";
pwd_ = "";
return SCANNER_ERR_OK;
}
return SCANNER_ERR_ACCESS_DENIED;
}
else if (strcmp(SANE_STD_OPT_NAME_DRIVER_LOG, name) == 0)
{
if (user_ == ADMIN_NAME && pwd_ == ADMIN_PWD)
{
hg_log::clear_log();
return SCANNER_ERR_OK;
}
return SCANNER_ERR_ACCESS_DENIED;
}
else if (strcmp(SANE_STD_OPT_NAME_GET_DEVS_L0G, name) == 0)
{
if (user_ == ADMIN_NAME && pwd_ == ADMIN_PWD)
{
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
return SCANNER_ERR_ACCESS_DENIED;
}
else if (strcmp(SANE_STD_OPT_NAME_ROLLER_COUNT, name) == 0)
{
if (user_ == ADMIN_NAME && pwd_ == ADMIN_PWD)
{
return (scanner_err)SCAN_PTR(h)->device_io_control(IO_CTRL_CODE_SET_CLEAR_ROLLER_COUNT, data, (unsigned*)&len);
}
return SCANNER_ERR_ACCESS_DENIED;
}
}
return (scanner_err)SCAN_PTR(h)->set_setting(name, data, len);
}
scanner_err hg_scanner_mgr::hg_scanner_start(scanner_handle h, void* async_event, int num)

3
hgdriver/hgdev/scanner_manager.h
View File

@ -64,6 +64,9 @@ class hg_scanner_mgr
std::mutex mutex_dev_;
unsigned int same_ind_;
std::string user_;
std::string pwd_;
static sane_callback event_callback_;
static bool async_io_enabled_;

15
hgdriver/wrapper/hg_log.cpp
View File

@ -208,6 +208,17 @@ public:
return file;
}
void clear_log(void)
{
if (log_ == &log_cls::log_file && file_)
{
std::lock_guard<std::mutex> lock(lock_);
fclose(file_);
remove(path_file_.c_str());
file_ = create_log_file(path_file_.c_str(), true);
}
}
};
log_cls* log_cls::inst_ = NULL;
std::string log_cls::g_time_tag = "=====";
@ -364,6 +375,10 @@ extern "C"
return str.substr(str.size()-7);
#endif
}
void clear_log(void)
{
log_cls::instance()->clear_log();
}
//static std::string get_scanimage_ver()
//{
// FILE* fp = popen("scanimage -V","r");

1
hgdriver/wrapper/hg_log.h
View File

@ -56,6 +56,7 @@ extern "C"
std::string temporary_path(void);
std::string log_file_path(void);
std::string get_scanimage_ver();
void clear_log(void);
float GetMemoryUsage(int pid);
float GetAppMemoryUsage();
const char* lang_load(uint32_t id);

217
hgsane/sane_hg_mdw.cpp
View File

@ -175,7 +175,7 @@ namespace local_utility
return str > bgn;
}
// 暂不支持科学计数<EFBFBD>?1.2e+10
// æš‚ä¸<EFBFBD>支æŒ<EFBFBD>科学计数ï¿?1.2e+10
bool get_number(const char*& str, double& val)
{
const char* bgn = str;
@ -256,6 +256,130 @@ namespace local_utility
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// fixed id map
static void init_fixed_id(const char* name, int id, std::map<sane_option_id, int>& mapid)
{
#define TRY_MATCH(n, m) \
if(strcmp(SANE_STD_OPT_NAME_##n, name) == 0) \
{ \
mapid[SANE_OPT_ID_##n] = id; \
return; \
}
TRY_MATCH(IS_MULTI_OUT);
TRY_MATCH(MULTI_OUT_TYPE);
TRY_MATCH(COLOR_MODE);
TRY_MATCH(FILTER);
TRY_MATCH(RID_MULTIOUT_RED);
TRY_MATCH(RID_ANSWER_SHEET_RED);
TRY_MATCH(ERASE_BACKGROUND);
TRY_MATCH(BKG_COLOR_RANGE);
TRY_MATCH(SHARPEN);
TRY_MATCH(RID_MORR);
TRY_MATCH(RID_GRID);
TRY_MATCH(ERROR_EXTENSION);
TRY_MATCH(NOISE_OPTIMIZE);
TRY_MATCH(NOISE_SIZE);
TRY_MATCH(PAPER);
TRY_MATCH(CUSTOM_AREA);
TRY_MATCH(CUSTOM_AREA_LEFT);
TRY_MATCH(CUSTOM_AREA_RIGHT);
TRY_MATCH(CUSTOM_AREA_TOP);
TRY_MATCH(CUSTOM_AREA_BOTTOM);
TRY_MATCH(SIZE_CHECK);
TRY_MATCH(PAGE);
TRY_MATCH(DISCARD_BLANK_SENS);
TRY_MATCH(RESOLUTION);
TRY_MATCH(IMAGE_QUALITY);
TRY_MATCH(EXCHANGE);
TRY_MATCH(SPLIT);
TRY_MATCH(ANTI_SKEW);
TRY_MATCH(IS_CUSTOM_GAMMA);
TRY_MATCH(BRIGHTNESS);
TRY_MATCH(CONTRAST);
TRY_MATCH(GAMMA);
TRY_MATCH(ERASE_BLACK_FRAME);
TRY_MATCH(DARK_SAMPLE);
TRY_MATCH(THRESHOLD);
TRY_MATCH(ANTI_NOISE_LEVEL);
TRY_MATCH(MARGIN);
TRY_MATCH(FILL_BKG_MODE);
TRY_MATCH(IS_ANTI_PERMEATE);
TRY_MATCH(ANTI_PERMEATE_LEVEL);
TRY_MATCH(RID_HOLE);
TRY_MATCH(SEARCH_HOLE_RANGE);
TRY_MATCH(IS_FILL_COLOR);
TRY_MATCH(IS_ULTROSONIC_CHECK);
TRY_MATCH(IS_CHECK_STAPLE);
TRY_MATCH(SCAN_MODE);
TRY_MATCH(SCAN_COUNT);
TRY_MATCH(TEXT_DIRECTION);
TRY_MATCH(IS_ROTATE_BKG_180);
TRY_MATCH(IS_CHECK_DOG_EAR);
TRY_MATCH(DOG_EAR_SIZE);
TRY_MATCH(IS_CHECK_ASKEW);
TRY_MATCH(ASKEW_RANGE);
TRY_MATCH(BINARY_THRESHOLD);
TRY_MATCH(IS_PHOTO_MODE);
TRY_MATCH(DOUBLE_FEED_HANDLE);
TRY_MATCH(WAIT_TO_SCAN);
TRY_MATCH(FEED_STRENGTH);
TRY_MATCH(TIME_TO_SLEEP);
TRY_MATCH(IS_AUTO_FEED_STRENGTH);
TRY_MATCH(FEED_STRENGTH_VALUE);
TRY_MATCH(REVERSE_01);
TRY_MATCH(RID_HOLE_L);
TRY_MATCH(SEARCH_HOLE_RANGE_L);
TRY_MATCH(RID_HOLE_R);
TRY_MATCH(SEARCH_HOLE_RANGE_R);
TRY_MATCH(RID_HOLE_T);
TRY_MATCH(SEARCH_HOLE_RANGE_T);
TRY_MATCH(RID_HOLE_B);
TRY_MATCH(SEARCH_HOLE_RANGE_B);
TRY_MATCH(FOLD_TYPE);
TRY_MATCH(COLOR_CORRECTION);
//TRY_MATCH(HISTORY_COUNT);
//TRY_MATCH(DRIVER_VERSION);
//TRY_MATCH(MANUFACTURER);
//TRY_MATCH(COPYRIGHT);
//TRY_MATCH(CO_URL);
//TRY_MATCH(CO_TEL);
//TRY_MATCH(CO_ADDR);
//TRY_MATCH(CO_GPS);
//TRY_MATCH(HELP);
//TRY_MATCH(VID);
//TRY_MATCH(PID);
//TRY_MATCH(DEV_NAME);
//TRY_MATCH(DEV_FAMILY);
//TRY_MATCH(LOGIN);
//TRY_MATCH(LOGOUT);
//TRY_MATCH(ROLLER_COUNT);
//TRY_MATCH(DRIVER_LOG);
//TRY_MATCH(DEVICE_LOG);
}
static std::string un_json_option_name(int id)
{
#define FIX_ID_TO_NAME(fid) \
if(id == SANE_OPT_ID_##fid) \
return SANE_STD_OPT_NAME_##fid;
FIX_ID_TO_NAME(HISTORY_COUNT);
FIX_ID_TO_NAME(DRIVER_VERSION);
FIX_ID_TO_NAME(MANUFACTURER);
FIX_ID_TO_NAME(COPYRIGHT);
FIX_ID_TO_NAME(CO_URL);
FIX_ID_TO_NAME(CO_TEL);
FIX_ID_TO_NAME(CO_ADDR);
FIX_ID_TO_NAME(CO_GPS);
FIX_ID_TO_NAME(VID);
FIX_ID_TO_NAME(PID);
FIX_ID_TO_NAME(DEV_NAME);
FIX_ID_TO_NAME(DEV_FAMILY);
FIX_ID_TO_NAME(ROLLER_COUNT);
FIX_ID_TO_NAME(HELP);
return "";
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static sane_callback cb_ui_ = NULL;
@ -640,7 +764,7 @@ SANE_Option_Descriptor* hg_sane_middleware::number_option_to_SANE_descriptor(con
sod->unit = SANE_UNIT_NONE;
sod->size = sizeof(SANE_Word);
sod->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT
/*| SANE_CAP_AUTOMATIC*/;
| SANE_CAP_AUTOMATIC;
if (lower || upper)
{
sod->size = sizeof(SANE_Range);
@ -708,7 +832,7 @@ SANE_Option_Descriptor* hg_sane_middleware::number_option_to_SANE_descriptor(con
sod->unit = SANE_UNIT_NONE;
sod->size = sizeof(SANE_Word);
sod->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT // 软件可设置选项
/*| SANE_CAP_AUTOMATIC*/; // 硬件可设置默认<E9BB98>?
| SANE_CAP_AUTOMATIC; // 硬件å<C2B6>¯è®¾ç½®é»˜è®¤ï¿½?
if (values.size())
{
@ -758,7 +882,7 @@ SANE_Option_Descriptor* hg_sane_middleware::number_option_to_SANE_descriptor(con
sod->unit = SANE_UNIT_NONE;
sod->size = sizeof(SANE_Word);
sod->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT // 软件可设置选项
/*| SANE_CAP_AUTOMATIC*/; // 硬件可设置默认<E9BB98>?
| SANE_CAP_AUTOMATIC; // 硬件å<C2B6>¯è®¾ç½®é»˜è®¤ï¿½?
if (values.size())
{
@ -995,11 +1119,16 @@ SANE_Option_Descriptor* hg_sane_middleware::from_json(scanner_handle h, const st
if (ret)
{
int bytes = 0;
bool bv = false;
jsn->get_value("size", bytes);
ret->size = bytes;
if (jsn->get_value("readonly", bv) && bv)
SET_CAP_READONLY(ret->cap)
val = "";
jsn->get_value("category", val);
jsn->get_value("cat", val);
if (val == "advanced")
{
ret->cap |= SANE_CAP_ADVANCED;
@ -1019,7 +1148,7 @@ SANE_Option_Descriptor* hg_sane_middleware::from_json(scanner_handle h, const st
//if (jsn->get_value("enable", enabled) && !enabled)
// ret->cap |= SANE_CAP_INACTIVE;
// 关联<EFBFBD>?
// å…³è<EFBFBD>”ï¿?
json* depend = NULL;
SLAVEOP so;
if (jsn->get_value("depend_or", depend))
@ -1204,6 +1333,26 @@ void hg_sane_middleware::reload_current_value(scanner_handle handle, std::vector
}
bool hg_sane_middleware::get_current_value(scanner_handle handle, const void* option, void(*setv)(void*, size_t, void*), void* value, SANE_Value_Type* type)
{
if (IS_PTR_NUMBER(option))
{
int id = (int)(uint64_t)option;
std::string name(local_utility::un_json_option_name(id));
if(!name.empty())
{
char buf[256] = { 0 };
long len = sizeof(buf) - 1;
if (hg_scanner_get_parameter(handle, name.c_str(), buf, &len) == SCANNER_ERR_OK)
{
setv(buf, len, value);
return true;
}
return false;
}
}
std::string name(""),
val(get_option_json(handle, (void *)option, &name));
json* jsn = new json();
@ -1375,7 +1524,7 @@ SANE_Status hg_sane_middleware::get_devices(const SANE_Device*** device_list, SA
if (hgerr == SCANNER_ERR_INSUFFICIENT_MEMORY)
{
count += 4; // 为两次hg_scanner_enum间隙可能新增的设备预留空<EFBFBD>?
count += 4; // 为两次hg_scanner_enumé—´éš™å<EFBFBD>¯èƒ½æ–°å¢žçš„设备预留空ï¿?
dev = (ScannerInfo*)local_utility::acquire_memory(sizeof(ScannerInfo) * count, "hg_sane_middleware::get_devices");
hgerr = hg_scanner_enum(dev, &count, local_only);
if (hgerr != SCANNER_ERR_OK)
@ -1521,23 +1670,21 @@ SANE_Option_Descriptor* hg_sane_middleware::get_option_descriptor(SANE_Handle h,
DEVOPT devopt;
devopt.option_no = id;
devopt.desc = ret;
local_utility::init_fixed_id(key.c_str(), id, (*it)->fixed_id);
devopt.opt_name = std::move(key);
(*it)->opts.push_back(std::move(devopt));
if ((*it)->std_opt)
(*it)->std_opt->init_known_opt(id, ret);
refresh_current_value(*it, ret->name, jsn);
}
}
delete jsn;
}
}
if (ret)
{
if ((*it)->std_opt)
(*it)->std_opt->init_known_opt(id, ret);
}
else if ((*it)->std_opt)
if(!ret && (*it)->std_opt)
ret = (*it)->std_opt->get_option(id);
}
return ret;
}
@ -1588,6 +1735,16 @@ SANE_Status hg_sane_middleware::set_option(SANE_Handle h, const void* option, SA
SANE_Status status = SANE_STATUS_GOOD;
std::string prev(""), v("");
if (action == SANE_ACTION_SET_AUTO && desc && desc->type != SANE_TYPE_BUTTON && desc->type != SANE_TYPE_GROUP) // we assume the driver can set the option properbly, and no work to do
{
VLOG_MINI_2(LOG_LEVEL_WARNING, "Option %d(%s) call SANE_ACTION_SET_AUTO, we set default value.\n", option, desc->title);
value = get_default_value(handle, option);
if (!value)
return SANE_STATUS_UNSUPPORTED;
release_value = true;
}
if (dev->std_opt && dev->std_opt->is_known_option(id, &desc))
{
SANE_Option_Descriptor* known = dev->std_opt->get_option(id);
@ -1601,21 +1758,29 @@ SANE_Status hg_sane_middleware::set_option(SANE_Handle h, const void* option, SA
{
if (!desc)
{
if (IS_PTR_NUMBER(option))
{
int id = (int)(uint64_t)option;
std::string name(local_utility::un_json_option_name(id));
if (!name.empty())
return local_utility::scanner_err_2_sane_statu(hg_scanner_set_parameter(handle, name.c_str(), value, 0));
}
VLOG_MINI_1(LOG_LEVEL_FATAL, "Option descriptor %d not found.\n", option);
return SANE_STATUS_UNSUPPORTED;
}
else if (!value && desc->type != SANE_TYPE_BUTTON)
{
if (action == SANE_ACTION_SET_AUTO) // we assume the driver can set the option properbly, and no work to do
{
VLOG_MINI_2(LOG_LEVEL_WARNING, "Option %d(%s) call SANE_ACTION_SET_AUTO, we set default value.\n", option, desc->title);
value = get_default_value(handle, option);
if (!value)
return SANE_STATUS_GOOD;
release_value = true;
}
else
//if (action == SANE_ACTION_SET_AUTO) // we assume the driver can set the option properbly, and no work to do
//{
// VLOG_MINI_2(LOG_LEVEL_WARNING, "Option %d(%s) call SANE_ACTION_SET_AUTO, we set default value.\n", option, desc->title);
//
// value = get_default_value(handle, option);
// if (!value)
// return SANE_STATUS_GOOD;
// release_value = true;
//}
//else
{
VLOG_MINI_2(LOG_LEVEL_WARNING, "Option descriptor %d(%s) need a value!.\n", option, desc->title);
@ -1764,7 +1929,7 @@ bool hg_sane_middleware::is_ready(void)
}
/// <summary>
/// 关联项处<EFBFBD>?
/// å…³è<EFBFBD>”项处ï¿?
bool hg_sane_middleware::compare_val_equal(const char* cur_val, const char* limit_l, const char* limit_r)
{
return strcmp(cur_val, limit_l) == 0;

2
hgsane/sane_hg_mdw.h
View File

@ -6,6 +6,7 @@
#include <vector>
#include <algorithm>
#include <string>
#include <map>
#include <stdio.h>
#if defined(WIN32) || defined(_WIN64)
#define bzero(b, s) memset(b, 0, s)
@ -79,6 +80,7 @@ typedef struct _dev_inst
std::vector<CURVAL> cur_vals;
std::vector<SLAVEOP> slaves;
std::vector<std::string> masters;
std::map<sane_option_id, int> fixed_id;
bool operator==(const char* n)
{