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

更换sane/scanner/lang三个模块名称，避免与第三方APP模块名称冲突

This commit is contained in:
gb 2023-10-20 15:21:17 +08:00
parent 99a7b6dd92
commit 64d05ae35c
20 changed files with 176 additions and 264 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
hgdriver/hgdev/hg_ipc.h
View File

@ -24,6 +24,8 @@
#include <memory> #include <memory>
#include <hginclude/utils.h>
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// memory management ... // memory management ...
void* allocate_memory(size_t bytes, const char* log_msg = ""); void* allocate_memory(size_t bytes, const char* log_msg = "");
@ -50,40 +52,6 @@ public:
void set_debug_info(const char* info); void set_debug_info(const char* info);
}; };
class refer
{
volatile int ref_;
std::mutex mutex_;
protected:
refer() : ref_(1)
{}
virtual ~refer()
{}
public:
int add_ref(void)
{
std::lock_guard<std::mutex> lock(mutex_);
return ++ref_;
}
int release(void)
{
int ref = 0;
{
std::lock_guard<std::mutex> lock(mutex_);
ref = --ref_;
}
if (ref == 0)
delete this;
return ref;
}
};
template<class T> template<class T>
class do_when_born_and_dead : public refer class do_when_born_and_dead : public refer
{ {

36
hgdriver/hgdev/hg_scanner.cpp
View File

@ -167,6 +167,7 @@ hg_scanner::hg_scanner(ScannerSerial serial, const char* dev_name, usb_io* io, i
, firmware_sup_double_img(false),firmware_sup_devs_lock_(false),firmware_sup_dpi_300(false),firmware_sup_dpi_600(false),firmware_sup_auto_speed_(false),firmware_sup_morr_(false) , firmware_sup_double_img(false),firmware_sup_devs_lock_(false),firmware_sup_dpi_300(false),firmware_sup_dpi_600(false),firmware_sup_auto_speed_(false),firmware_sup_morr_(false)
, firmware_sup_color_fill_(false),firmware_sup_history_cnt(false), is_discardblank(false) , firmware_sup_color_fill_(false),firmware_sup_history_cnt(false), is_discardblank(false)
, setting_jsn_(new device_option()) , setting_jsn_(new device_option())
, auto_scan_restore_(false), auto_scan_prev_(is_auto_paper_scan)
{ {
#if !defined(_WIN32) && !defined(_WIN64) &&defined(x86_64) #if !defined(_WIN32) && !defined(_WIN64) &&defined(x86_64)
isx86_Advan_ = false; isx86_Advan_ = false;
@ -465,7 +466,7 @@ void hg_scanner::thread_image_handle(void)
int hg_scanner::hg_version_init_handle() int hg_scanner::hg_version_init_handle()
{ {
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
string scanner_path = utils::get_module_full_path(SCANNER_DRIVER_PART_NAME); string scanner_path = utils::get_module_full_path(MODULE_NAME_SCANNER);
if (scanner_path.empty()) if (scanner_path.empty())
{ {
return SCANNER_ERR_OUT_OF_RANGE; return SCANNER_ERR_OUT_OF_RANGE;
@ -496,8 +497,8 @@ int hg_scanner::hg_version_init_handle()
HGVersion_Free_ = (SDKHGVersion_Free_)dlsym(Dynamicopen_HGVersion_pHandle_, "HGVersion_DestroyMgr"); HGVersion_Free_ = (SDKHGVersion_Free_)dlsym(Dynamicopen_HGVersion_pHandle_, "HGVersion_DestroyMgr");
#else #else
//string scanner_path = utils::get_module_full_path(LIBNAME); //string scanner_path = utils::get_module_full_path(MODULE_NAME_SCANNER);
//scanner_path = scanner_path.substr(0, scanner_path.size() - strlen(LIBNAME)); //scanner_path = scanner_path.substr(0, scanner_path.size() - strlen(MODULE_NAME_SCANNER));
string HGVersionlib_path = scanner_path + HGVERSION_LIBNANE; string HGVersionlib_path = scanner_path + HGVERSION_LIBNANE;
wchar_t* Prclibbuffer = new wchar_t[HGVersionlib_path.length() + 1]; wchar_t* Prclibbuffer = new wchar_t[HGVersionlib_path.length() + 1];
@ -1533,10 +1534,34 @@ int hg_scanner::setting_scan_mode(void* data, long* len)
if (strcmp(str.c_str(), from_default_language(OPTION_VALUE_SMZS_LXSM)) == 0) if (strcmp(str.c_str(), from_default_language(OPTION_VALUE_SMZS_LXSM)) == 0)
{ {
scan_count_ = -1; scan_count_ = -1;
// restore AutoScan ?
if (auto_scan_restore_)
{
long len = sizeof(auto_scan_prev_);
setting_auto_paper_scan(&auto_scan_prev_, &len);
utils::to_log(LOG_LEVEL_DEBUG, "Restore 'AutoScan' to '%s' for user changes scan mode to '%s'\n"
, auto_scan_prev_ ? "true" : "false", str.c_str());
}
} }
else else
{ {
scan_count_ = *(int*)setting_jsn_->get_option_value(SANE_STD_OPT_NAME_SCAN_COUNT, OPT_VAL_CURRENT).c_str(); scan_count_ = *(int*)setting_jsn_->get_option_value(SANE_STD_OPT_NAME_SCAN_COUNT, OPT_VAL_CURRENT).c_str();
// 智学网设置该参数时，程序取消待纸扫描
if (!auto_scan_restore_) // 连续调用时，保留最初状态
{
auto_scan_restore_ = auto_scan_prev_ = is_auto_paper_scan;
if (auto_scan_restore_)
{
bool v = false;
long len = sizeof(v);
setting_auto_paper_scan(&v, &len);
auto_scan_restore_ = true;
utils::to_log(LOG_LEVEL_DEBUG, "Disable 'AutoScan' for user changes scan mode to '%s'\n", str.c_str());
}
}
} }
utils::to_log(LOG_LEVEL_DEBUG, "set scanning pages to %d\n", scan_count_); utils::to_log(LOG_LEVEL_DEBUG, "set scanning pages to %d\n", scan_count_);
@ -1803,6 +1828,9 @@ int hg_scanner::setting_auto_pick_paper_threshold(void* data, long* len)
} }
int hg_scanner::setting_auto_paper_scan(void* data, long* len) int hg_scanner::setting_auto_paper_scan(void* data, long* len)
{ {
utils::to_log(LOG_LEVEL_DEBUG, "No 'AutoScan' restroing for setting_auto_paper_scan invoked.\n");
auto_scan_restore_ = false;
is_auto_paper_scan = *((bool *)data); is_auto_paper_scan = *((bool *)data);
if (!firmware_sup_wait_paper_ && is_auto_paper_scan) if (!firmware_sup_wait_paper_ && is_auto_paper_scan)
{ {
@ -2259,7 +2287,7 @@ void hg_scanner::init_settings(const char* json_setting_text)
int hg_scanner::init_settings(int pid) int hg_scanner::init_settings(int pid)
{ {
char rel_path[80] = { 0 }; char rel_path[80] = { 0 };
std::string root(utils::get_module_full_path(SCANNER_DRIVER_PART_NAME)), jsn(""); std::string root(utils::get_module_full_path(MODULE_NAME_SCANNER)), jsn("");
int ret = root.rfind(PATH_SEPARATOR[0]); int ret = root.rfind(PATH_SEPARATOR[0]);
if((size_t)ret++ == std::string::npos) if((size_t)ret++ == std::string::npos)

18
hgdriver/hgdev/hg_scanner.h
View File

@ -309,6 +309,8 @@ protected:
int feedmode_; // 分纸强度 int feedmode_; // 分纸强度
int sleeptime_; // 睡眠时间 int sleeptime_; // 睡眠时间
bool is_auto_paper_scan; // 待纸扫描 bool is_auto_paper_scan; // 待纸扫描
bool auto_scan_prev_; // 保留待纸扫描程序改变状态之前的值 - 2023-10-16: 智学网根据扫描张数来打开或关闭待纸扫描
bool auto_scan_restore_; // 是否需要恢复待纸扫描状态 - 2023-10-16: 智学网根据扫描张数来打开或关闭待纸扫描
bool size_check; // 尺寸检测 bool size_check; // 尺寸检测
bool save_feedmode_type_; //保存分支强度狀態 bool save_feedmode_type_; //保存分支强度狀態
@ -407,14 +409,6 @@ protected:
void adjust_filling_hole(LPSCANCONF conf); void adjust_filling_hole(LPSCANCONF conf);
enum thread_running
{
THREAD_RUNNING_IDLE = 0,
THREAD_RUNNING_USB = 1 << 0,
THREAD_RUNNING_IMAGE = 1 << 1,
};
int is_running(void); // return thread_running
//////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////
// 新增自定义伽玛曲线及扫描区域属性 - 2022-05-05 // 新增自定义伽玛曲线及扫描区域属性 - 2022-05-05
bool custom_gamma_; // 为true时，应用custom_gamma_val_阵列调整图像色彩；为false时，保持原来的处理方式 bool custom_gamma_; // 为true时，应用custom_gamma_val_阵列调整图像色彩；为false时，保持原来的处理方式
@ -453,6 +447,14 @@ public:
bool is_online(void); bool is_online(void);
void on_language_changed(void); void on_language_changed(void);
enum thread_running
{
THREAD_RUNNING_IDLE = 0,
THREAD_RUNNING_USB = 1 << 0,
THREAD_RUNNING_IMAGE = 1 << 1,
};
int is_running(void); // return thread_running
public: public:
virtual int start(void); virtual int start(void);
virtual int get_image_info(SANE_Parameters* ii); virtual int get_image_info(SANE_Parameters* ii);

8
hgdriver/hgdev/hg_scanner_239.cpp
View File

File diff suppressed because one or more lines are too long

4
hgdriver/hgdev/hg_scanner_300.cpp
View File

@ -834,7 +834,7 @@ int hg_scanner_300::initdevice()
{ {
if (fw.substr(4, 6) == "230303") if (fw.substr(4, 6) == "230303")
{ {
string scanner_path(utils::get_module_full_path(SCANNER_DRIVER_PART_NAME)); string scanner_path(utils::get_module_full_path(MODULE_NAME_SCANNER));
size_t pos = scanner_path.rfind(PATH_SEPARATOR[0]); size_t pos = scanner_path.rfind(PATH_SEPARATOR[0]);
if(pos++ == std::string::npos) if(pos++ == std::string::npos)
pos = 0; pos = 0;
@ -1337,7 +1337,7 @@ int hg_scanner_300::set_updata0303(void)
{ {
if (fw.substr(4, 6) == "230303") if (fw.substr(4, 6) == "230303")
{ {
string scanner_path = utils::get_module_full_path(SCANNER_DRIVER_PART_NAME); string scanner_path = utils::get_module_full_path(MODULE_NAME_SCANNER);
size_t pos = scanner_path.rfind(PATH_SEPARATOR[0]); size_t pos = scanner_path.rfind(PATH_SEPARATOR[0]);
if(pos++ == std::string::npos) if(pos++ == std::string::npos)
pos = 0; pos = 0;

4
hgdriver/hgdev/image_process.cpp
View File

@ -306,7 +306,7 @@ namespace hg_imgproc
int init_auto_txt_hanld() int init_auto_txt_hanld()
{ {
int ret = 0; int ret = 0;
string scanner_path = utils::get_module_full_path(SCANNER_DRIVER_PART_NAME); string scanner_path = utils::get_module_full_path(MODULE_NAME_SCANNER);
size_t pos = scanner_path.rfind(PATH_SEPARATOR[0]); size_t pos = scanner_path.rfind(PATH_SEPARATOR[0]);
if (scanner_path.empty()) if (scanner_path.empty())
@ -1160,7 +1160,7 @@ namespace hg_imgproc
SDKExit ocrexit = NULL; SDKExit ocrexit = NULL;
#ifndef WIN32 #ifndef WIN32
string scanner_path = utils::get_module_full_path(SCANNER_DRIVER_PART_NAME); string scanner_path = utils::get_module_full_path(MODULE_NAME_SCANNER);
if(scanner_path.empty()) if(scanner_path.empty())
{ {

8
hgdriver/hgdev/scanner_manager.cpp
View File

@ -1017,7 +1017,13 @@ scanner_err hg_scanner_mgr::hg_scanner_start(scanner_handle h, void* async_event
} }
scanner_err hg_scanner_mgr::hg_scanner_stop(scanner_handle h) scanner_err hg_scanner_mgr::hg_scanner_stop(scanner_handle h)
{ {
return (scanner_err)SCAN_PTR(h)->stop(); scanner_err err = (scanner_err)SCAN_PTR(h)->stop();
// call from APP, block when all working-threads stopped - added on 2023-10-18 when handled double-feeding in SANE
while (SCAN_PTR(h)->is_running() != hg_scanner::THREAD_RUNNING_IDLE)
std::this_thread::sleep_for(std::chrono::milliseconds(3));
return err;
} }
scanner_err hg_scanner_mgr::hg_scanner_get_img_info(scanner_handle h, SANE_Parameters* bmi, long len) scanner_err hg_scanner_mgr::hg_scanner_get_img_info(scanner_handle h, SANE_Parameters* bmi, long len)
{ {

6
hgdriver/wrapper/CMakeLists.txt
View File

@ -39,7 +39,7 @@ endif()
target_link_libraries(${PROJECT_NAME} PRIVATE target_link_libraries(${PROJECT_NAME} PRIVATE
${PROJECT_SOURCE_DIR}/../../../build/libgdev.a ${PROJECT_SOURCE_DIR}/../../../build/libgdev.a
${PROJECT_SOURCE_DIR}/../../../build/libgimgproc.a ${PROJECT_SOURCE_DIR}/../../../build/libgimgproc.a
${PROJECT_SOURCE_DIR}/../../../release/uos/${CMAKE_SYSTEM_PROCESSOR}/liblang.so ${PROJECT_SOURCE_DIR}/../../../release/uos/${CMAKE_SYSTEM_PROCESSOR}/libyuyanbao.so
${PROJECT_SOURCE_DIR}/../3rdparty/opencv/lib/uos/${CMAKE_SYSTEM_PROCESSOR}/libopencv_imgproc.a ${PROJECT_SOURCE_DIR}/../3rdparty/opencv/lib/uos/${CMAKE_SYSTEM_PROCESSOR}/libopencv_imgproc.a
${PROJECT_SOURCE_DIR}/../3rdparty/opencv/lib/uos/${CMAKE_SYSTEM_PROCESSOR}/libopencv_imgcodecs.a ${PROJECT_SOURCE_DIR}/../3rdparty/opencv/lib/uos/${CMAKE_SYSTEM_PROCESSOR}/libopencv_imgcodecs.a
${PROJECT_SOURCE_DIR}/../3rdparty/opencv/lib/uos/${CMAKE_SYSTEM_PROCESSOR}/libopencv_highgui.a ${PROJECT_SOURCE_DIR}/../3rdparty/opencv/lib/uos/${CMAKE_SYSTEM_PROCESSOR}/libopencv_highgui.a
@ -54,7 +54,7 @@ target_link_libraries(${PROJECT_NAME} PRIVATE
${PROJECT_SOURCE_DIR}/../3rdparty/opencv/lib/uos/${CMAKE_SYSTEM_PROCESSOR}/libzlib.a ${PROJECT_SOURCE_DIR}/../3rdparty/opencv/lib/uos/${CMAKE_SYSTEM_PROCESSOR}/libzlib.a
${PROJECT_SOURCE_DIR}/../3rdparty/opencv/lib/uos/${CMAKE_SYSTEM_PROCESSOR}/liblibwebp.a ${PROJECT_SOURCE_DIR}/../3rdparty/opencv/lib/uos/${CMAKE_SYSTEM_PROCESSOR}/liblibwebp.a
${PROJECT_SOURCE_DIR}/../../../sdk/lib/uos/${CMAKE_SYSTEM_PROCESSOR}/libusb-1.0.a #uos下放的先后顺序不对可能会导致库链接不上 ${PROJECT_SOURCE_DIR}/../../../sdk/lib/uos/${CMAKE_SYSTEM_PROCESSOR}/libusb-1.0.a #uos下放的ĺ…<EFBFBD>ĺ<EFBFBD>ŽéˇşĺşŹä¸ŤĺŻąĺŹŻč<EFBFBD>˝äĽšĺŻĽč‡´ĺş“链接不ä¸?
udev pthread dl m) udev pthread dl m)
#勿修改下面预留行 #勿修改下面预留行
@ -70,7 +70,7 @@ message("cpu is x86_64")
elseif(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "aarch64") elseif(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "aarch64")
target_link_libraries(${PROJECT_NAME} PRIVATE target_link_libraries(${PROJECT_NAME} PRIVATE
${PROJECT_SOURCE_DIR}/../3rdparty/opencv/lib/uos/${CMAKE_SYSTEM_PROCESSOR}/libittnotify.a ${PROJECT_SOURCE_DIR}/../3rdparty/opencv/lib/uos/${CMAKE_SYSTEM_PROCESSOR}/libittnotify.a
${PROJECT_SOURCE_DIR}/../3rdparty/opencv/lib/uos/${CMAKE_SYSTEM_PROCESSOR}/libtegra_hal.a #uos 不需要 kylin需要 ${PROJECT_SOURCE_DIR}/../3rdparty/opencv/lib/uos/${CMAKE_SYSTEM_PROCESSOR}/libtegra_hal.a #uos 不需č¦?kylin需č¦?
#message("静态库预留03") #message("静态库预留03")
#message("静态库预留04") #message("静态库预留04")

2
hgdriver/wrapper/huagaoxxx_warraper_ex.cpp
View File

@ -92,7 +92,7 @@ extern "C"
pe.erase(pos); pe.erase(pos);
#if !defined(WIN32) && !defined(_WIN64) #if !defined(WIN32) && !defined(_WIN64)
g_scanner_path = utils::get_module_full_path((std::string(SCANNER_DRIVER_PART_NAME) + "." + DLL_EXTESION).c_str()); g_scanner_path = utils::get_module_full_path(MODULE_NAME_SCANNER);
scanner = g_scanner_path; scanner = g_scanner_path;
#endif #endif
pos = g_scanner_path.rfind(path[0]); pos = g_scanner_path.rfind(path[0]);

2
hgsane/CMakeLists.txt
View File

@ -20,7 +20,7 @@ link_directories(${PROJECT_NAME} PRIVATE
${PROJECT_SOURCE_DIR}/../../release/uos/${CMAKE_SYSTEM_PROCESSOR} ${PROJECT_SOURCE_DIR}/../../release/uos/${CMAKE_SYSTEM_PROCESSOR}
) )
target_link_libraries(${PROJECT_NAME} PRIVATE hgdriver target_link_libraries(${PROJECT_NAME} PRIVATE hgdriver
${PROJECT_SOURCE_DIR}/../../release/uos/${CMAKE_SYSTEM_PROCESSOR}/liblang.so ${PROJECT_SOURCE_DIR}/../../release/uos/${CMAKE_SYSTEM_PROCESSOR}/libyuyanbao.so
${PROJECT_SOURCE_DIR}/../../release/uos/${CMAKE_SYSTEM_PROCESSOR}/libhgdriver.so ${PROJECT_SOURCE_DIR}/../../release/uos/${CMAKE_SYSTEM_PROCESSOR}/libhgdriver.so
) )

4
sdk/hginclude/huagaoxxx_warraper_ex.h
View File

@ -28,10 +28,10 @@
#include "sane/sane_ex.h" #include "sane/sane_ex.h"
#include <string> #include <string>
#if defined(WIN32) || defined(_WIN64) #if defined(WIN32) || defined(_WIN64)
#include "../../../sdk/include/huagao/brand.h"
#ifndef HGSCANNER_EXPORT #ifndef HGSCANNER_EXPORT
#pragma comment(lib, "scanner.lib") #pragma comment(lib, "scannerqd.lib")
#endif #endif
#define VERSION_MAJOR VERSION_MAIN #define VERSION_MAJOR VERSION_MAIN
#define VERSION_MINOR VERSION_SUB #define VERSION_MINOR VERSION_SUB

37
sdk/hginclude/utils.cpp
View File

@ -1128,6 +1128,43 @@ namespace utils
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// refer
refer::refer() : ref_(1)
{
on_born();
}
refer::~refer()
{
on_dead();
}
void refer::on_born(void)
{}
void refer::on_dead(void)
{}
int32_t refer::add_ref(void)
{
SIMPLE_LOCK(mutex_);
return ++ref_;
}
int32_t refer::release(void)
{
int32_t ref = 0;
{
SIMPLE_LOCK(mutex_);
ref = --ref_;
}
if (ref == 0)
delete this;
return ref;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// util // util
chronograph::chronograph() chronograph::chronograph()

27
sdk/hginclude/utils.h
View File

@ -8,6 +8,7 @@
#include <sane/sane_ex.h> #include <sane/sane_ex.h>
#include <string> #include <string>
#include <memory> #include <memory>
#include <mutex>
enum log_type enum log_type
{ {
@ -108,6 +109,32 @@ int gettimeofday(TIMEV* tv, struct timezone* tz);
typedef struct timeval TIMEV; typedef struct timeval TIMEV;
#endif #endif
// object life referer
//
// derived from 'refer' if your class used in multi-threads
//
#define MUTEX std::mutex
#define LOCK_WITH_NAME(n, v) std::lock_guard<MUTEX> n(v)
#define SIMPLE_LOCK(v) LOCK_WITH_NAME(locker, v)
class refer
{
volatile int32_t ref_;
MUTEX mutex_;
protected:
refer();
virtual ~refer();
virtual void on_born(void);
virtual void on_dead(void);
public:
virtual int32_t add_ref(void);
virtual int32_t release(void);
};
// time utility
class chronograph class chronograph
{ {
TIMEV bgn_; TIMEV bgn_;

44
twain/ds/huagaods.cpp
View File

@ -1608,10 +1608,7 @@ Twpp::Result huagao_ds::imageFileXferGet(const Twpp::Identity& origin)
//} //}
{ {
std::string info(m_fileXfer.filePath().string()); utils::to_log(LOG_LEVEL_DEBUG, "FileTransfer '%s' = %d(%d)\r\n", m_fileXfer.filePath().string().c_str(), (CC)ret.status(), cv_e);
char r[80] = { 0 };
sprintf(r, ": status = %d(Fail: 0x%x)\r\n", (int)ret.status(), cv_e);
utils::log_info((info + r).c_str(), 1);
} }
} }
@ -2374,13 +2371,13 @@ void huagao_ds::init_support_caps(int err)
log_attr_access((int)type, (int)msg); log_attr_access((int)type, (int)msg);
if (Msg::Set == msg) { if (Msg::Set == msg) {
auto res = data.currentItem<Fix32>(); auto res = data.currentItem<Fix32>();
float angle = res.toFloat(); double angle = res.toFloat();
std::string val(s2t::rotation_to_sane(angle)); std::string val(s2t::rotation_to_sane(angle));
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
SET_SANE_OPT(ret, scanner_, TEXT_DIRECTION, &val[0]); SET_SANE_OPT(ret, scanner_, TEXT_DIRECTION, &val[0]);
return ret == SCANNER_ERR_OK ? success() : badValue(); return ret == SCANNER_ERR_OK ? success() : badValue();
} }
std::vector<float> values; std::vector<double> values;
std::vector<std::string> svalues; std::vector<std::string> svalues;
GET_SANE_OPT(std::string, scanner_, TEXT_DIRECTION, NULL, &svalues); GET_SANE_OPT(std::string, scanner_, TEXT_DIRECTION, NULL, &svalues);
@ -2390,10 +2387,10 @@ void huagao_ds::init_support_caps(int err)
Fix32 Init = Fix32(values[sane_opts::RANGE_POS_DEFAULT]), Now = Fix32(values[sane_opts::RANGE_POS_CURRENT]); Fix32 Init = Fix32(values[sane_opts::RANGE_POS_DEFAULT]), Now = Fix32(values[sane_opts::RANGE_POS_CURRENT]);
std::list<Fix32> vls; std::list<Fix32> vls;
UInt32 i = distance<float>(values, values[sane_opts::RANGE_POS_DEFAULT]), UInt32 i = distance<double>(values, values[sane_opts::RANGE_POS_DEFAULT]),
n = distance<float>(values, values[sane_opts::RANGE_POS_CURRENT]); n = distance<double>(values, values[sane_opts::RANGE_POS_CURRENT]);
for (size_t i = sane_opts::RANGE_POS_ENUM_BEGIN; i < values.size(); ++i) for (size_t ind = sane_opts::RANGE_POS_ENUM_BEGIN; ind < values.size(); ++ind)
vls.push_back(Fix32(values[i])); vls.push_back(Fix32(values[ind]));
return cap_get_enum_values<Fix32, CapType::IRotation>(msg, data, vls, Now, Init, n, i); return cap_get_enum_values<Fix32, CapType::IRotation>(msg, data, vls, Now, Init, n, i);
}; };
@ -2616,16 +2613,17 @@ void huagao_ds::init_support_caps(int err)
log_attr_access((int)type, (int)msg); log_attr_access((int)type, (int)msg);
if (Msg::Set == msg) { if (Msg::Set == msg) {
auto autodetectborder = data.currentItem<CapType::IAutomaticBorderDetection>(); auto autodetectborder = data.currentItem<CapType::IAutomaticBorderDetection>();
std::string val(s2t::auto_size_to_sane(autodetectborder));
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
SET_SANE_OPT(ret, scanner_, SIZE_CHECK, (bool*)&autodetectborder); SET_SANE_OPT(ret, scanner_, PAPER, (bool*)&autodetectborder);
return ret == SCANNER_ERR_OK ? success() : badValue(); return ret == SCANNER_ERR_OK ? success() : badValue();
} }
Bool init = false, Bool init = false,
erase = false; erase = false;
std::vector<bool> all; std::vector<std::string> sall;
GET_SANE_OPT(bool, scanner_, SIZE_CHECK, NULL, &all); GET_SANE_OPT(std::string, scanner_, PAPER, NULL, &sall);
init = (bool)all[sane_opts::RANGE_POS_DEFAULT]; init = s2t::auto_size_from_sane(sall[sane_opts::RANGE_POS_DEFAULT].c_str());
erase = (bool)all[sane_opts::RANGE_POS_CURRENT]; erase = s2t::auto_size_from_sane(sall[sane_opts::RANGE_POS_CURRENT].c_str());
return CapSupGetAllReset<Bool, Bool, CapType::IAutomaticBorderDetection>(msg, data, { false,true }, erase, init, erase ? 1 : 0, 0); return CapSupGetAllReset<Bool, Bool, CapType::IAutomaticBorderDetection>(msg, data, { false,true }, erase, init, erase ? 1 : 0, 0);
}; };
@ -3432,10 +3430,10 @@ void huagao_ds::init_caps_from_sane_directly(const std::vector<uint32_t>& ids)
{ {
m_query[(CapType)v] = msgSupportGetAll; m_query[(CapType)v] = msgSupportGetAll;
m_caps[(CapType)v] = [this](Twpp::CapType type, Msg msg, Capability& data) -> Result { m_caps[(CapType)v] = [this](Twpp::CapType type, Msg msg, Capability& data) -> Result {
std::vector<float> all; std::vector<double> all;
Fix32 val; Fix32 val;
sane_opts::get_opts<float> op(NULL, &all); sane_opts::get_opts<double> op(NULL, &all);
scanner_->get_value((int)type, sane_opts::set_opt_value<float>, &op); scanner_->get_value((int)type, sane_opts::set_opt_value<double>, &op);
op.re_order(); op.re_order();
copy_type(val, all[sane_opts::RANGE_POS_CURRENT]); copy_type(val, all[sane_opts::RANGE_POS_CURRENT]);
type = data.type(); type = data.type();
@ -3447,10 +3445,10 @@ void huagao_ds::init_caps_from_sane_directly(const std::vector<uint32_t>& ids)
{ {
m_query[(CapType)v] = msgSupportGetAllSetReset; m_query[(CapType)v] = msgSupportGetAllSetReset;
m_caps[(CapType)v] = [this](Twpp::CapType type, Msg msg, Capability& data) -> Result { m_caps[(CapType)v] = [this](Twpp::CapType type, Msg msg, Capability& data) -> Result {
std::vector<float> all; std::vector<double> all;
value_limit lmt; value_limit lmt;
sane_opts::get_opts<float> op(&lmt, &all); sane_opts::get_opts<double> op(&lmt, &all);
scanner_->get_value((int)type, sane_opts::set_opt_value<float>, &op); scanner_->get_value((int)type, sane_opts::set_opt_value<double>, &op);
op.re_order(); op.re_order();
if (msg == Msg::Set || msg == Msg::Reset) if (msg == Msg::Set || msg == Msg::Reset)
{ {
@ -3487,8 +3485,8 @@ void huagao_ds::init_caps_from_sane_directly(const std::vector<uint32_t>& ids)
if (lmt == VAL_LIMIT_ENUM) if (lmt == VAL_LIMIT_ENUM)
{ {
std::list<Fix32> vals; std::list<Fix32> vals;
UInt32 ni = distance<float>(all, all[sane_opts::RANGE_POS_CURRENT]), UInt32 ni = distance<double>(all, all[sane_opts::RANGE_POS_CURRENT]),
ii = distance<float>(all, all[sane_opts::RANGE_POS_DEFAULT]); ii = distance<double>(all, all[sane_opts::RANGE_POS_DEFAULT]);
for (size_t i = sane_opts::RANGE_POS_ENUM_BEGIN; i < all.size(); ++i) for (size_t i = sane_opts::RANGE_POS_ENUM_BEGIN; i < all.size(); ++i)
{ {
Fix32 t; Fix32 t;

4
twain/ds/s2t_api.h
View File

@ -133,8 +133,8 @@ typedef bool(*set_opt_value)(void* val, value_role role, value_limit limit, void
class IRef class IRef
{ {
public: public:
COM_API_DECLARE(long, add_ref(void)); COM_API_DECLARE(int32_t, add_ref(void));
COM_API_DECLARE(long, release(void)); COM_API_DECLARE(int32_t, release(void));
}; };
class IScanImg : public IRef // 为兼容TWAIN传输方式，位图全部转换为完整的位图文件内容，TWAIN协议层在获取数据时，根据不同传输方式跳过对应的文件头即可 - 2023-07-03 class IScanImg : public IRef // 为兼容TWAIN传输方式，位图全部转换为完整的位图文件内容，TWAIN协议层在获取数据时，根据不同传输方式跳过对应的文件头即可 - 2023-07-03
{ {

12
twain/ds/sane_helper.cpp
View File

@ -103,20 +103,16 @@ bool sane_helper::load_sane(const char* vendor) // libsane_hgsane.so.1, and vend
clear(); clear();
#if OS_WIN dll_handle_ = utils::load_dll((dll_root_ + MODULE_NAME_SANE).c_str(), LOAD_WITH_ALTERED_SEARCH_PATH);
std::string file(dll_root_ + "sane.dll"), func("sane_");
#else
std::string file(dll_root_ + "libsane-" + vendor + ".so.1"), func("sane_");
#endif
dll_handle_ = utils::load_dll(file.c_str(), LOAD_WITH_ALTERED_SEARCH_PATH);
if(!dll_handle_) if(!dll_handle_)
{ {
utils::to_log(7, "load sane library(%s) = %s\n", file.c_str(), strerror(errno)); utils::to_log(7, "load sane library(%s) = %s\n", MODULE_NAME_SANE, strerror(errno));
return false; return false;
} }
std::string func("sane_");
func += vendor; func += vendor;
func += "_"; func += "sane_";
#define GET_PROC_ADDR(api) \ #define GET_PROC_ADDR(api) \
*(void**)&invoke_sane_##api = GetProcAddress(dll_handle_, (func + #api).c_str()); \ *(void**)&invoke_sane_##api = GetProcAddress(dll_handle_, (func + #api).c_str()); \

31
twain/ds/scanned_img.cpp
View File

@ -68,33 +68,6 @@ namespace local_trans
} }
} }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// class refer
refer::refer() : ref_(1)
{}
refer::~refer()
{}
COM_API_IMPLEMENT(refer, long, add_ref(void))
{
std::lock_guard<std::mutex> locker(lock_);
return ++ref_;
}
COM_API_IMPLEMENT(refer, long, release(void))
{
long ref = 0;
{
std::lock_guard<std::mutex> locker(lock_);
ref = --ref_;
}
if (ref == 0)
delete this;
return ref;
}
@ -455,11 +428,11 @@ void scanned_img::swap_rgb(void)
} }
// IRef // IRef
COM_API_IMPLEMENT(scanned_img, long, add_ref(void)) COM_API_IMPLEMENT(scanned_img, int32_t, add_ref(void))
{ {
return refer::add_ref(); return refer::add_ref();
} }
COM_API_IMPLEMENT(scanned_img, long, release(void)) COM_API_IMPLEMENT(scanned_img, int32_t, release(void))
{ {
return refer::release(); return refer::release();
} }

18
twain/ds/scanned_img.h
View File

@ -3,20 +3,8 @@
#include <vector> #include <vector>
#include <mutex> #include <mutex>
class refer : public IRef #include "../../sdk/hginclude/utils.h"
{
std::mutex lock_;
volatile long ref_;
protected:
refer();
virtual ~refer();
// IRef
public:
COM_API_OVERRIDE(long, add_ref(void));
COM_API_OVERRIDE(long, release(void));
};
class image_buf class image_buf
{ {
@ -74,8 +62,8 @@ protected:
// IRef // IRef
public: public:
COM_API_OVERRIDE(long, add_ref(void)); COM_API_OVERRIDE(int32_t, add_ref(void));
COM_API_OVERRIDE(long, release(void)); COM_API_OVERRIDE(int32_t, release(void));
// IScanImg // IScanImg
public: public:

135
twain/ds/scanner.cpp
View File

@ -97,116 +97,6 @@ namespace callback
g_scanner_instances.erase(it); g_scanner_instances.erase(it);
} }
struct
{
const char* name;
const char* title;
}g_opts[] = { {SANE_STD_OPT_NAME_RESTORE , OPTION_TITLE_HFMRSZ}
, {SANE_STD_OPT_NAME_HELP , OPTION_TITLE_BZ}
, {SANE_STD_OPT_NAME_IS_MULTI_OUT , OPTION_TITLE_DLSC}
, {SANE_STD_OPT_NAME_MULTI_OUT_TYPE , OPTION_TITLE_DLSCLX}
, {SANE_STD_OPT_NAME_COLOR_MODE , OPTION_TITLE_YSMS}
, {SANE_STD_OPT_NAME_BINARY_THRESHOLD , OPTION_TITLE_HBTXYZ}
, {SANE_STD_OPT_NAME_REVERSE_01 , OPTION_TITLE_HBTXFSSC}
, {SANE_STD_OPT_NAME_FILTER , OPTION_TITLE_HDHHBTX_CSYZQ}
, {SANE_STD_OPT_NAME_RID_MULTIOUT_RED , OPTION_TITLE_24WCSTX_DLSCCH}
, {SANE_STD_OPT_NAME_RID_ANSWER_SHEET_RED , OPTION_TITLE_24WCSTX_DTKCH}
, {SANE_STD_OPT_NAME_ERASE_BACKGROUND , OPTION_TITLE_BJYC}
, {SANE_STD_OPT_NAME_BKG_COLOR_RANGE , OPTION_TITLE_BJSCFDFW}
, {SANE_STD_OPT_NAME_SHARPEN , OPTION_TITLE_RHYMH}
, {SANE_STD_OPT_NAME_RID_MORR , OPTION_TITLE_QCMW}
, {SANE_STD_OPT_NAME_RID_GRID , OPTION_TITLE_CWW}
, {SANE_STD_OPT_NAME_ERROR_EXTENSION , OPTION_TITLE_CWKS}
, {SANE_STD_OPT_NAME_NOISE_OPTIMIZE , OPTION_TITLE_HBTXZDYH}
, {SANE_STD_OPT_NAME_NOISE_SIZE , OPTION_TITLE_ZDYHCC}
, {SANE_STD_OPT_NAME_PAPER , OPTION_TITLE_ZZCC}
, {SANE_STD_OPT_NAME_CUSTOM_AREA , OPTION_TITLE_ZDYSMQY}
, {SANE_STD_OPT_NAME_CUSTOM_AREA_LEFT , OPTION_TITLE_SMQYZCmm}
, {SANE_STD_OPT_NAME_CUSTOM_AREA_RIGHT , OPTION_TITLE_SMQYYCmm}
, {SANE_STD_OPT_NAME_CUSTOM_AREA_TOP , OPTION_TITLE_SMQYSCmm}
, {SANE_STD_OPT_NAME_CUSTOM_AREA_BOTTOM , OPTION_TITLE_SMQYXCmm}
, {SANE_STD_OPT_NAME_SIZE_CHECK , OPTION_TITLE_CCJC}
, {SANE_STD_OPT_NAME_PAGE , OPTION_TITLE_SMYM}
, {SANE_STD_OPT_NAME_DISCARD_BLANK_SENS , OPTION_TITLE_TGKBYLMD}
, {SANE_STD_OPT_NAME_RESOLUTION , OPTION_TITLE_FBL}
, {SANE_STD_OPT_NAME_TIME_TO_SLEEP , OPTION_TITLE_XMSJ}
, {SANE_STD_OPT_NAME_IMAGE_QUALITY , OPTION_TITLE_HZ}
, {SANE_STD_OPT_NAME_EXCHANGE ,OPTION_TITLE_JHZFM}
, {SANE_STD_OPT_NAME_SPLIT ,OPTION_TITLE_TXCF }
, {SANE_STD_OPT_NAME_ANTI_SKEW , OPTION_TITLE_ZDJP}
, {SANE_STD_OPT_NAME_IS_CUSTOM_GAMMA , OPTION_TITLE_QYSDQX}
, {SANE_STD_OPT_NAME_GAMMA , OPTION_TITLE_JMZ}
, {SANE_STD_OPT_NAME_BRIGHTNESS , OPTION_TITLE_LDZ}
, {SANE_STD_OPT_NAME_CONTRAST , OPTION_TITLE_DBD}
, {SANE_STD_OPT_NAME_IS_PHOTO_MODE , OPTION_TITLE_ZPMS}
, {SANE_STD_OPT_NAME_ERASE_BLACK_FRAME , OPTION_TITLE_XCHK}
, {SANE_STD_OPT_NAME_DARK_SAMPLE , OPTION_TITLE_SSYZ}
, {SANE_STD_OPT_NAME_THRESHOLD , OPTION_TITLE_YZ}
, {SANE_STD_OPT_NAME_ANTI_NOISE_LEVEL , OPTION_TITLE_BJKZDJ}
, {SANE_STD_OPT_NAME_MARGIN , OPTION_TITLE_BYSJ}
, {SANE_STD_OPT_NAME_FILL_BKG_MODE , OPTION_TITLE_BJTCFS}
, {SANE_STD_OPT_NAME_IS_ANTI_PERMEATE , OPTION_TITLE_FZST}
, {SANE_STD_OPT_NAME_ANTI_PERMEATE_LEVEL , OPTION_TITLE_FZSTDJ}
, {SANE_STD_OPT_NAME_RID_HOLE_L , OPTION_TITLE_CKYCZC}
, {SANE_STD_OPT_NAME_SEARCH_HOLE_RANGE_L , OPTION_TITLE_ZCCKSSFWZFMBL}
, {SANE_STD_OPT_NAME_RID_HOLE_R , OPTION_TITLE_CKYCYC}
, {SANE_STD_OPT_NAME_SEARCH_HOLE_RANGE_R , OPTION_TITLE_YCCKSSFWZFMBL}
, {SANE_STD_OPT_NAME_RID_HOLE_T , OPTION_TITLE_CKYCSC}
, {SANE_STD_OPT_NAME_SEARCH_HOLE_RANGE_T , OPTION_TITLE_SCCKSSFWZFMBL}
, {SANE_STD_OPT_NAME_RID_HOLE_B , OPTION_TITLE_CKYCXC}
, {SANE_STD_OPT_NAME_SEARCH_HOLE_RANGE_B , OPTION_TITLE_XCCKSSFWZFMBL}
, {SANE_STD_OPT_NAME_IS_FILL_COLOR , OPTION_TITLE_SCTC}
, {SANE_STD_OPT_NAME_IS_ULTROSONIC_CHECK , OPTION_TITLE_CSBJC}
, {SANE_STD_OPT_NAME_DOUBLE_FEED_HANDLE , OPTION_TITLE_SZTPCL}
, {SANE_STD_OPT_NAME_IS_CHECK_STAPLE , OPTION_TITLE_ZDJC}
, {SANE_STD_OPT_NAME_SCAN_MODE , OPTION_TITLE_SMZS}
, {SANE_STD_OPT_NAME_SCAN_COUNT , OPTION_TITLE_SMSL}
, {SANE_STD_OPT_NAME_TEXT_DIRECTION , OPTION_TITLE_WGFX}
, {SANE_STD_OPT_NAME_IS_ROTATE_BKG_180 , OPTION_TITLE_BMXZ180}
, {SANE_STD_OPT_NAME_IS_CHECK_DOG_EAR , OPTION_TITLE_ZJJC}
, {SANE_STD_OPT_NAME_DOG_EAR_SIZE , OPTION_TITLE_ZJDX}
, {SANE_STD_OPT_NAME_IS_CHECK_ASKEW , OPTION_TITLE_WXJC}
, {SANE_STD_OPT_NAME_ASKEW_RANGE , OPTION_TITLE_WXRRD}
, {SANE_STD_OPT_NAME_FEED_STRENGTH , OPTION_TITLE_FZQD}
, {SANE_STD_OPT_NAME_IS_AUTO_FEED_STRENGTH , OPTION_TITLE_ZDFZQD}
, {SANE_STD_OPT_NAME_FEED_STRENGTH_VALUE , OPTION_TITLE_JZSBL}
, {SANE_STD_OPT_NAME_WAIT_TO_SCAN , OPTION_TITLE_DZSM}
, {SANE_STD_OPT_NAME_FOLD_TYPE , OPTION_TITLE_DZMS}
, {SANE_STD_OPT_NAME_COLOR_CORRECTION , OPTION_TITLE_SPJZ}
},
g_discard[] = { {SANE_STD_OPT_NAME_REVERSE_01 , "\351\273\221\347\231\275\345\233\276\345\203\217\345\217\215\350\211\262\350\276\223\345\207\272\357\274\210\346\255\243\345\270\270\351\242\234\350\211\262\344\270\272\357\274\2320-\351\273\221\350\211\262\357\274\2331-\347\231\275\350\211\262\357\274\211"} // 黑白图像反色输出（正常颜色为：0-黑色；1-白色）
, {SANE_STD_OPT_NAME_FILTER , "\347\201\260\345\272\246\346\210\226\351\273\221\347\231\275\345\233\276\345\203\217 - \351\231\244\350\211\262"} // 灰度或黑白图像 - 除色
, {SANE_STD_OPT_NAME_IS_AUTO_FEED_STRENGTH , "\350\207\252\345\212\250\346\220\223\347\272\270\345\274\272\345\272\246"} // 自动搓纸强度
, {SANE_STD_OPT_NAME_FEED_STRENGTH_VALUE , "\346\220\223\347\272\270\351\230\210\345\200\274"} // " 搓纸阈值"
};
const char* option_title_2_name(const char* title)
{
while (*title == ' ')
title++;
for (size_t i = 0; i < _countof(g_discard); ++i)
{
if (strcmp(title, g_discard[i].title) == 0)
return g_discard[i].name;
}
for (size_t i = 0; i < _countof(g_opts); ++i)
{
if (strcmp(title, g_opts[i].title) == 0)
return g_opts[i].name;
}
return "";
}
const char* option_name_2_title(const char* name)
{
for (size_t i = 0; i < _countof(g_opts); ++i)
{
if (strcmp(name, g_opts[i].name) == 0)
return g_opts[i].title;
}
return "";
}
static HWND find_main_wnd(void) static HWND find_main_wnd(void)
{ {
@ -251,7 +141,7 @@ namespace callback
static void init_ui(void) static void init_ui(void)
{ {
std::string root(utils::get_module_full_path(SCANNER_DRIVER_PART_NAME)); std::string root(utils::get_module_full_path(MODULE_NAME_SCANNER));
size_t pos = root.rfind(PATH_SEPARATOR[0]); size_t pos = root.rfind(PATH_SEPARATOR[0]);
if(pos != std::string::npos) if(pos != std::string::npos)
@ -449,12 +339,12 @@ int scanner::transfer_id(int id)
} }
void scanner::apply_config(void) void scanner::apply_config(void)
{ {
//if (callback::apply_current_config) if (callback::apply_current_config)
//{ {
// char* cfg = callback::apply_current_config(scanner_name_.c_str(), handle_, &sane_api_); char* cfg = callback::apply_current_config(scanner_name_.c_str(), handle_, &sane_api_);
// if (cfg && callback::twain_ui_free) if (cfg && callback::twain_ui_free)
// callback::twain_ui_free(cfg); callback::twain_ui_free(cfg);
//} }
} }
void scanner::on_ui_event(int uev, void* sender) void scanner::on_ui_event(int uev, void* sender)
{ {
@ -582,7 +472,6 @@ int scanner::open(void)
{ {
size_t pid = -1; size_t pid = -1;
// transport_config_file();
callback::reg_callback(handle_, this); callback::reg_callback(handle_, this);
scanner_name_ = name; scanner_name_ = name;
pid = scanner_name_.find(" - "); pid = scanner_name_.find(" - ");
@ -924,11 +813,11 @@ int scanner::thread_start(void)
// IRef // IRef
COM_API_IMPLEMENT(scanner, long, add_ref(void)) COM_API_IMPLEMENT(scanner, int32_t, add_ref(void))
{ {
return refer::add_ref(); return refer::add_ref();
} }
COM_API_IMPLEMENT(scanner, long, release(void)) COM_API_IMPLEMENT(scanner, int32_t, release(void))
{ {
return refer::release(); return refer::release();
} }
@ -1543,7 +1432,7 @@ extern "C"
utils::init_log(LOG_TYPE_FILE, LOG_LEVEL_ALL, "_twain"); utils::init_log(LOG_TYPE_FILE, LOG_LEVEL_ALL, "_twain");
sane_helper_ = new sane_helper(); sane_helper_ = new sane_helper();
if(!sane_helper_->load_sane((std::string(OEM_SHORT_NAME_E) + "sane").c_str())) if(!sane_helper_->load_sane(OEM_SHORT_NAME_E))
{ {
delete sane_helper_; delete sane_helper_;
sane_helper_ = nullptr; sane_helper_ = nullptr;
@ -1554,12 +1443,12 @@ extern "C"
if (sane_helper_->invoke_sane_init_ex(&ver, callback::sane_event_callback, nullptr) == SANE_STATUS_GOOD) if (sane_helper_->invoke_sane_init_ex(&ver, callback::sane_event_callback, nullptr) == SANE_STATUS_GOOD)
{ {
std::string lang(utils::get_module_full_path(SCANNER_DRIVER_PART_NAME)); std::string lang(utils::get_module_full_path(MODULE_NAME_SCANNER));
size_t pos = lang.rfind(PATH_SEPARATOR[0]); size_t pos = lang.rfind(PATH_SEPARATOR[0]);
if(pos++ == std::string::npos) if(pos++ == std::string::npos)
pos = 0; pos = 0;
lang.erase(pos); lang.erase(pos);
lang += LANG_DLL_NAME; lang += MODULE_NAME_LANG;
pos = local_trans::load_lang_pak(lang.c_str()); pos = local_trans::load_lang_pak(lang.c_str());
utils::to_log(LOG_LEVEL_WARNING, "load language component (%s) = %s\n", lang.c_str(), strerror(pos)); utils::to_log(LOG_LEVEL_WARNING, "load language component (%s) = %s\n", lang.c_str(), strerror(pos));

4
twain/ds/scanner.h
View File

@ -132,8 +132,8 @@ public:
// IRef // IRef
public: public:
COM_API_OVERRIDE(long, add_ref(void)); COM_API_OVERRIDE(int32_t, add_ref(void));
COM_API_OVERRIDE(long, release(void)); COM_API_OVERRIDE(int32_t, release(void));
// ISaneInvoker // ISaneInvoker
public: public: