diff --git a/hgdriver/hgdev/CMakeLists.txt b/hgdriver/hgdev/CMakeLists.txt index e0f3cba..e7a96df 100644 --- a/hgdriver/hgdev/CMakeLists.txt +++ b/hgdriver/hgdev/CMakeLists.txt @@ -5,7 +5,7 @@ add_definitions(-DUOS) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC -O2") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC -O2") aux_source_directory(${PROJECT_SOURCE_DIR} DIR_SRCS) -file(GLOB DIR_HEADS "${PROJECT_SOURCE_DIR}/*.h" "${PROJECT_SOURCE_DIR}/*.hpp") +file(GLOB DIR_HEADS "${PROJECT_SOURCE_DIR}/*.h" "${PROJECT_SOURCE_DIR}/*.hpp" "${PROJECT_SOURCE_DIR}/../../sdk/hginclude/*.h" "${PROJECT_SOURCE_DIR}/../../sdk/hginclude/*.cpp") set(DIR_SRCS ${DIR_SRCS} ${DIR_HEADS}) add_library(${PROJECT_NAME} STATIC ${DIR_SRCS}) @@ -53,7 +53,7 @@ target_include_directories(${PROJECT_NAME} PRIVATE ${PROJECT_SOURCE_DIR} ${PROJECT_SOURCE_DIR}/../3rdparty/opencv/include ${PROJECT_SOURCE_DIR}/../3rdparty/tiff/include ${PROJECT_SOURCE_DIR}/../../../sdk/include - ${PROJECT_SOURCE_DIR}/../wrapper + ${PROJECT_SOURCE_DIR}/../../sdk/hginclude ) set(LIBRARY_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/../../../build) diff --git a/hgdriver/hgdev/common_setting.cpp b/hgdriver/hgdev/common_setting.cpp index 4dbbe3f..592ff5a 100644 --- a/hgdriver/hgdev/common_setting.cpp +++ b/hgdriver/hgdev/common_setting.cpp @@ -1,8 +1,8 @@ #include "common_setting.h" #include "sane/sane_option_definitions.h" -#include "hg_log.h" +#include -#define MAKE_ID_AND_STR(id) id, hg_log::lang_load(id) +#define MAKE_ID_AND_STR(id) id, lang_load_string(id, nullptr) static struct _fixed_option { int str_id; @@ -251,7 +251,7 @@ static std::string get_str(struct _fixed_option* arr, int num, int enm, int defa static void reload_string(struct _fixed_option* arr, int num) { for (int i = 0; i < num; ++i) - arr[i].str = hg_log::lang_load(arr[i].str_id); + arr[i].str = lang_load_string(arr[i].str_id, nullptr); } #define RELOAD_STRING(arr) reload_string(arr, ARRAY_SIZE(arr)) @@ -504,16 +504,16 @@ int double_paper_flag_from_option_value(std::string& opt_val, bool* exact) if (exact) *exact = true; - if (opt_val == hg_log::lang_load(ID_OPTION_VALUE_SZTPCL_SCTXBJXSM)) + if (opt_val == lang_load_string(ID_OPTION_VALUE_SZTPCL_SCTXBJXSM, nullptr)) return DOUBLE_PAPER_CONTINUE | DOUBLE_PAPER_SAVE_IMG; - else if (opt_val == hg_log::lang_load(ID_OPTION_VALUE_SZTPCL_SCTXBTZSM)) + else if (opt_val == lang_load_string(ID_OPTION_VALUE_SZTPCL_SCTXBTZSM, nullptr)) return DOUBLE_PAPER_SAVE_IMG; - else if (opt_val == hg_log::lang_load(ID_OPTION_VALUE_SZTPCL_DQTXBJXSM)) + else if (opt_val == lang_load_string(ID_OPTION_VALUE_SZTPCL_DQTXBJXSM, nullptr)) return DOUBLE_PAPER_CONTINUE; else { if (exact) - *exact = opt_val == hg_log::lang_load(ID_OPTION_VALUE_SZTPCL_DQTXBTZSM); + *exact = opt_val == lang_load_string(ID_OPTION_VALUE_SZTPCL_DQTXBTZSM, nullptr); } return 0; } @@ -523,14 +523,14 @@ std::string double_paper_flag_to_option_value(int flag) if (is_continue_when_double_paper(flag)) { if (is_save_img_when_double_paper(flag)) - return hg_log::lang_load(ID_OPTION_VALUE_SZTPCL_SCTXBJXSM); + return lang_load_string(ID_OPTION_VALUE_SZTPCL_SCTXBJXSM, nullptr); else - return hg_log::lang_load(ID_OPTION_VALUE_SZTPCL_DQTXBJXSM); + return lang_load_string(ID_OPTION_VALUE_SZTPCL_DQTXBJXSM, nullptr); } else if (is_save_img_when_double_paper(flag)) - return hg_log::lang_load(ID_OPTION_VALUE_SZTPCL_SCTXBTZSM); + return lang_load_string(ID_OPTION_VALUE_SZTPCL_SCTXBTZSM, nullptr); else - return hg_log::lang_load(ID_OPTION_VALUE_SZTPCL_DQTXBTZSM); + return lang_load_string(ID_OPTION_VALUE_SZTPCL_DQTXBTZSM, nullptr); } bool is_continue_when_double_paper(int flag) { diff --git a/hgdriver/hgdev/hg_ipc.cpp b/hgdriver/hgdev/hg_ipc.cpp index f5122c2..3eab170 100644 --- a/hgdriver/hgdev/hg_ipc.cpp +++ b/hgdriver/hgdev/hg_ipc.cpp @@ -1,6 +1,7 @@ #include "hg_ipc.h" -#include "../wrapper/hg_log.h" + #include "huagao/hgscanner_error.h" +#include "../../sdk/hginclude/utils.h" #if defined(WIN32) || defined(_WIN64) //#include "scanner_manager.h" @@ -98,7 +99,7 @@ platform_event::platform_event() : waiting_(false), dbg_info_("") if (err == -1) { err = errno; - VLOG_MINI_2(LOG_LEVEL_FATAL, "(%s)sem_init failed: %d\n", hg_log::format_ptr(this).c_str(), err); + utils::to_log(LOG_LEVEL_FATAL, "(%p)sem_init failed: %d\n", this, err); } } platform_event::~platform_event() @@ -114,7 +115,7 @@ bool platform_event::wait(unsigned timeout) { bool waited = true; - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "platform_event(%s - %s) --> waiting...\n", hg_log::format_ptr(this).c_str(), dbg_info_.c_str()); + utils::to_log(LOG_LEVEL_DEBUG, "platform_event(%p - %s) --> waiting...\n", this, dbg_info_.c_str()); waiting_ = true; if (timeout == USB_TIMEOUT_INFINITE) sem_wait(&sem_); @@ -125,7 +126,7 @@ bool platform_event::wait(unsigned timeout) to.tv_nsec = (long)((timeout % 1000) * 1000 * 1000); waited = sem_timedwait(&sem_, &to) == 0; } - VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "platform_event(%s - %s) --> %s.\n", hg_log::format_ptr(this).c_str(), dbg_info_.c_str(), waited ? "waited" : "wait timeout"); + utils::to_log(LOG_LEVEL_DEBUG, "platform_event(%p - %s) --> %s.\n", this, dbg_info_.c_str(), waited ? "waited" : "wait timeout"); waiting_ = false; return waited; @@ -149,7 +150,7 @@ void platform_event::set_debug_info(const char* info) shared_memory::shared_memory(unsigned long long key, size_t size) : key_(key), obj_((void*)-1), first_(true), bytes_(size), len_(0) { unsigned int* ptr = (unsigned int*)&key_; - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "shared memory key = 0x%x%08x\n", ptr[1], ptr[0]); + utils::to_log(LOG_LEVEL_DEBUG, "shared memory key = 0x%x%08x\n", ptr[1], ptr[0]); init(); } @@ -183,11 +184,11 @@ void shared_memory::init(void) obj = shmget(key_, bytes_, 0600); if(obj == -1) obj = shmget(key_, bytes_, 0); - VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "open existing: shmget(0x%x%08x) = %d\n", v[1], v[0], obj); + utils::to_log(LOG_LEVEL_DEBUG, "open existing: shmget(0x%x%08x) = %d\n", v[1], v[0], obj); obj_ = (void*)obj; std::string prev(read()), proc(""); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "shared memory content: %s\n", prev.c_str()); + utils::to_log(LOG_LEVEL_DEBUG, "shared memory content: %s\n", prev.c_str()); if(prev.length()) { proc = prev; @@ -212,23 +213,23 @@ void shared_memory::init(void) first_ = true; clear(); obj = shmget(key_, bytes_, IPC_EXCL | IPC_CREAT | 0600); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "%s is not existing and reopen it\n", prev.c_str()); + utils::to_log(LOG_LEVEL_DEBUG, "%s is not existing and reopen it\n", prev.c_str()); } } else { - VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "shmget(0x%x%08x) = %d\n", v[1], v[0], errno); + utils::to_log(LOG_LEVEL_DEBUG, "shmget(0x%x%08x) = %d\n", v[1], v[0], errno); return; } } obj_ = (void*)obj; - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "shared memory id = %d[%s], \n", obj, first_ ? "created" : "opened"); + utils::to_log(LOG_LEVEL_DEBUG, "shared memory id = %d[%s], \n", obj, first_ ? "created" : "opened"); #endif if(first_) { pid_t pid = getpid(); - std::string me(""); + std::string me(utils::get_module_full_path()); char buf[40] = { 0 }; unsigned int* pn = (unsigned int*)&pid; @@ -236,7 +237,10 @@ void shared_memory::init(void) sprintf(buf, "(pid: 0x%x%08x)", pn[1], pn[0]); else sprintf(buf, "(pid: %u)", pn[0]); - hg_log::pe_path(&me); + + size_t pos = me.rfind(PATH_SEPARATOR[0]); + if(pos++ != std::string::npos) + me.erase(0, pos); me += buf; write(me.c_str(), me.length()); } @@ -268,7 +272,7 @@ char* shared_memory::get_buf(void) #else int* h = (int*)&obj_; char* buf = (char*)shmat(*h, 0, 0); - VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "shared memory %d buffer = %s, error = %d\n", *h, hg_log::format_ptr(buf).c_str(), errno); + utils::to_log(LOG_LEVEL_DEBUG, "shared memory %d buffer = %p, error = %d\n", *h, buf, errno); #endif return buf; @@ -307,11 +311,11 @@ std::string shared_memory::get_proc_name_by_pid(pid_t pid) } if (sizeof(pid) > 4 && v[1]) { - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "PID(%lld) name is: %s\n", pid, ret.c_str()); + utils::to_log(LOG_LEVEL_DEBUG, "PID(%lld) name is: %s\n", pid, ret.c_str()); } else { - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "PID(%u) name is: %s\n", pid, ret.c_str()); + utils::to_log(LOG_LEVEL_DEBUG, "PID(%u) name is: %s\n", pid, ret.c_str()); } return ret; @@ -367,9 +371,9 @@ int shared_memory::write(const char* data, size_t len) ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // tiny_file_map ... tiny_file_map::tiny_file_map() : size_(0), map_(INVALID_HANDLE_NAME), buf_(nullptr), file_(""), keep_f_(false) - , map_off_(0), map_bytes_(0), page_size_(hg_log::get_page_size()) + , map_off_(0), map_bytes_(0), page_size_(utils::get_page_size()) { - hg_log::get_page_size(&page_size_); + utils::get_page_size(&page_size_); } tiny_file_map::~tiny_file_map() { @@ -414,14 +418,14 @@ HANDLE_NAME tiny_file_map::open_file_for_mapping(const char* file, unsigned* byt { if (lseek(ret, *bytes - 1, SEEK_SET) < 0) { - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "set file size to %u - 1 bytes failed: %d\n", *bytes, errno); + utils::to_log(LOG_LEVEL_DEBUG, "set file size to %u - 1 bytes failed: %d\n", *bytes, errno); ::close(ret); remove(file); ret = INVALID_HANDLE_NAME; } if (write(ret, "0", 1) < 0) { - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "set file size to %u bytes failed: %d\n", *bytes, errno); + utils::to_log(LOG_LEVEL_DEBUG, "set file size to %u bytes failed: %d\n", *bytes, errno); ::close(ret); remove(file); ret = INVALID_HANDLE_NAME; @@ -543,7 +547,7 @@ int tiny_file_map::open(const char* file, bool existing, unsigned int size) size_ = size; } - VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "map([%s]%s) = %d\n", existing ? "existing" : "new", file, ret); + utils::to_log(LOG_LEVEL_DEBUG, "map([%s]%s) = %d\n", existing ? "existing" : "new", file, ret); if (ret == SCANNER_ERR_OK) file_ = file; @@ -857,7 +861,7 @@ void final_img_queue::fetch_front(void* buf, int* len, bool* over) { if (!imgd.data->swap()) { - VLOG_MINI_1(LOG_LEVEL_FATAL, "Reload final image '%s' failed!\n", imgd.data->file().c_str()); + utils::to_log(LOG_LEVEL_FATAL, "Reload final image '%s' failed!\n", imgd.data->file().c_str()); } } @@ -871,7 +875,7 @@ void final_img_queue::fetch_front(void* buf, int* len, bool* over) } else { - VLOG_MINI_2(LOG_LEVEL_FATAL, "Remap final image '%s + 0x%08x' failed!\n", imgd.data->file().c_str(), imgd.offset); + utils::to_log(LOG_LEVEL_FATAL, "Remap final image '%s + 0x%08x' failed!\n", imgd.data->file().c_str(), imgd.offset); } imgd.offset += *len; if (imgd.offset >= imgd.header.bytes) diff --git a/hgdriver/hgdev/hg_scanner.cpp b/hgdriver/hgdev/hg_scanner.cpp index f70db64..b2e0498 100644 --- a/hgdriver/hgdev/hg_scanner.cpp +++ b/hgdriver/hgdev/hg_scanner.cpp @@ -1,5 +1,7 @@ #include "hg_scanner.h" -#include "../wrapper/hg_log.h" + +#include "../../sdk/hginclude/utils.h" +#include #include "sane/sane_option_definitions.h" #include "scanner_setting.h" #include "scanner_manager.h" @@ -148,7 +150,7 @@ hg_scanner::hg_scanner(ScannerSerial serial, const char* dev_name, usb_io* io, i , bright_(128), contrast_(4), gamma_(1.0f), threshold_(40), anti_noise_(8), margin_(5) , fractate_level_(50), ui_ev_cb_(ui_default_callback), scan_life_(NULL) , notify_setting_result_(false), user_cancel_(false), cb_mem_(true), test_1_paper_(false) - , img_type_(""), online_(false), is_quality_(-1), is_color_fill(false), is_multiout(false), save_multiout(hg_log::lang_load(ID_OPTION_VALUE_DLSCLX_CS_HD_HB)) + , img_type_(""), online_(false), is_quality_(-1), is_color_fill(false), is_multiout(false), save_multiout(lang_load_string(ID_OPTION_VALUE_DLSCLX_CS_HD_HB, nullptr)) , final_img_index_(0), custom_area_(false), save_sizecheck(false), bw_threshold_(128), custom_gamma_(false) , double_paper_handle_(0), keep_watermark_(false), save_feedmode_type_(false), feedmode_(1), sleeptime_(-1), split3399_(0) , async_io_(false), is_white_0_(true), isremove_left_hole(false), isremove_right_hole(false), isremove_top_hole(false), isremove_low_hole(false) @@ -166,40 +168,52 @@ hg_scanner::hg_scanner(ScannerSerial serial, const char* dev_name, usb_io* io, i #if !defined(_WIN32) && !defined(_WIN64) &&defined(x86_64) isx86_Advan_ = false; #endif + std::string config_file(utils::get_local_data_path() + PATH_SEPARATOR + "config" + PATH_SEPARATOR + "debug.cfg"); + char strbuf[260] = {0}; + int getl = GetPrivateProfileStringA("path", "final_img", "", strbuf, sizeof(strbuf) - 1, config_file.c_str()); + init_setting_func_map(); - final_path_ = hg_log::ini_get("path", "final_img"); + strbuf[getl] = 0; + final_path_ = strbuf; if(final_path_.empty()) - final_path_ = hg_log::local_data_path() + PATH_SEPARATOR + "imgs"; - if (hg_log::ini_get("dump", "dumpusb") == "1") + final_path_ = utils::get_local_data_path() + PATH_SEPARATOR + "imgs"; + if (GetPrivateProfileIntA("dump", "dumpusb", 0, config_file.c_str()) == 1) { - dump_usb_path_ = hg_log::ini_get("dump", "usb_path"); + getl = GetPrivateProfileStringA("dump", "usb_path", "", strbuf, sizeof(strbuf) - 1, config_file.c_str()); + strbuf[getl] = 0; + dump_usb_path_ = strbuf; if (dump_usb_path_.empty()) dump_usb_path_ = final_path_; if (!dump_usb_path_.empty()) dump_img_ = &hg_scanner::dump_image_real; } - std::string mem = hg_log::ini_get("mem", "max_img"); + getl = GetPrivateProfileStringA("mem", "max_img", "", strbuf, sizeof(strbuf) - 1, config_file.c_str()); + strbuf[getl] = 0; + + std::string mem(strbuf); if (!mem.empty()) { memory_size_ = std::stoi(mem); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Get the config file --->memory_size_ set is :%lld", memory_size_); + utils::to_log(LOG_LEVEL_DEBUG, "Get the config file --->memory_size_ set is :%lld", memory_size_); } - std::string adv = hg_log::ini_get("cpu", "advanced"); + getl = GetPrivateProfileStringA("cpu", "advanced", "", strbuf, sizeof(strbuf) - 1, config_file.c_str()); + strbuf[getl] = 0; + std::string adv(strbuf); if (!adv.empty()) { isx86_Advan_ = adv == "0" ? false : true; - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Get the config file --->isx86_Advan_ set is :%d", isx86_Advan_); + utils::to_log(LOG_LEVEL_DEBUG, "Get the config file --->isx86_Advan_ set is :%d", isx86_Advan_); } - if (hg_log::create_folder(final_path_.c_str())) + if (utils::create_folder(final_path_.c_str())) { - VLOG_MINI_1(LOG_LEVEL_WARNING, "temporary image folder: %s\n", final_path_.c_str()); + utils::to_log(LOG_LEVEL_WARNING, "temporary image folder: %s\n", final_path_.c_str()); final_path_ += PATH_SEPARATOR; } else { - VLOG_MINI_1(LOG_LEVEL_WARNING, "create temporary image folder failed: %s\n", final_path_.c_str()); + utils::to_log(LOG_LEVEL_WARNING, "create temporary image folder failed: %s\n", final_path_.c_str()); final_path_ = ""; } @@ -212,7 +226,7 @@ hg_scanner::hg_scanner(ScannerSerial serial, const char* dev_name, usb_io* io, i for (int i = 0; i < ARRAY_SIZE(custom_gamma_val_->table); ++i) custom_gamma_val_->table[i] = i & 0x0ff; - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "%s(%s) constructed\n", name_.c_str(), hg_log::format_ptr(this).c_str()); + utils::to_log(LOG_LEVEL_DEBUG, "%s(%p) constructed\n", name_.c_str(), this); image_prc_param_.value = 0; if (io_) @@ -257,10 +271,10 @@ hg_scanner::~hg_scanner() delete custom_gamma_val_; hg_imgproc::release(ImagePrc_pHandle_); - name_.insert(0, hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_DEVS)); - name_ += hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_IS_CLOSE); + name_.insert(0, lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_DEVS, nullptr)); + name_ += lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_IS_CLOSE, nullptr); notify_ui_working_status(name_.c_str(), SANE_EVENT_SCANNER_CLOSED); - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "%s(%s) destroyed.\n", name_.c_str(), hg_log::format_ptr(this).c_str()); + utils::to_log(LOG_LEVEL_DEBUG, "%s(%p) destroyed.\n", name_.c_str(), this); } std::string hg_scanner::temporary_file(char* tail, char* head) @@ -316,19 +330,19 @@ int hg_scanner::save_2_tempory_file(std::shared_ptr> data, std { if (path_file) *path_file = file; - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "--->Wrote %u bytes to file '%s'\n", wrote, file.c_str()); + utils::to_log(LOG_LEVEL_DEBUG, "--->Wrote %u bytes to file '%s'\n", wrote, file.c_str()); } else { ret = SCANNER_ERR_WRITE_FILE_FAILED; - VLOG_MINI_3(LOG_LEVEL_FATAL, "Failed in writting file(%u/%u) '%s'\n", wrote, data->size(), file.c_str()); + utils::to_log(LOG_LEVEL_FATAL, "Failed in writting file(%u/%u) '%s'\n", wrote, data->size(), file.c_str()); } fclose(dst); } else { ret = SCANNER_ERR_CREATE_FILE_FAILED; - VLOG_MINI_1(LOG_LEVEL_FATAL, "Failed in creating file '%s'\n", file.c_str()); + utils::to_log(LOG_LEVEL_FATAL, "Failed in creating file '%s'\n", file.c_str()); } return ret; @@ -398,13 +412,13 @@ void hg_scanner::thread_read_int(void) void hg_scanner::thread_handle_usb(void) { int cnt = 0; - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "[thread_handle_usb 'START' !!!]:[%d]\n", cnt); + utils::to_log(LOG_LEVEL_DEBUG, "[thread_handle_usb 'START' !!!]:[%d]\n", cnt); while (run_) { cnt++; - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "[thread_handle_usb 'WAIT' !!!]:[%d]\n", cnt); + utils::to_log(LOG_LEVEL_DEBUG, "[thread_handle_usb 'WAIT' !!!]:[%d]\n", cnt); wait_usb_.wait(); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "[thread_handle_usb 'NOTIFY' !!!]:[%d]\n", cnt); + utils::to_log(LOG_LEVEL_DEBUG, "[thread_handle_usb 'NOTIFY' !!!]:[%d]\n", cnt); if (!run_) break; @@ -413,7 +427,7 @@ void hg_scanner::thread_handle_usb(void) std::this_thread::sleep_for(std::chrono::milliseconds(3000)); if (scan_life_) { - VLOG_MINI_1(LOG_LEVEL_FATAL, "[thread_handle_usb image process is still running!]:[%d]\n", cnt); + utils::to_log(LOG_LEVEL_FATAL, "[thread_handle_usb image process is still running!]:[%d]\n", cnt); continue; } } @@ -424,9 +438,9 @@ void hg_scanner::thread_handle_usb(void) if (scan_life_->release() == 0) scan_life_ = NULL; - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "[thread_handle_usb_read 'GET IMAGE END'!!!]:[%d]\n", cnt); + utils::to_log(LOG_LEVEL_DEBUG, "[thread_handle_usb_read 'GET IMAGE END'!!!]:[%d]\n", cnt); } - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "[thread_handle_usb EXIT !!!]:[%d]\n", cnt); + utils::to_log(LOG_LEVEL_DEBUG, "[thread_handle_usb EXIT !!!]:[%d]\n", cnt); } void hg_scanner::thread_image_handle(void) { @@ -447,12 +461,15 @@ int hg_scanner::hg_version_init_handle() { int ret = SCANNER_ERR_OK; #ifndef WIN32 - string scanner_path = hg_log::get_module_full_path(LIBNAME); + string scanner_path = utils::get_module_full_path(SCANNER_DRIVER_PART_NAME); if (scanner_path.empty()) { return SCANNER_ERR_OUT_OF_RANGE; } - scanner_path = scanner_path.substr(0, scanner_path.size() - strlen(LIBNAME)); + size_t pos = scanner_path.rfind(PATH_SEPARATOR[0]); + if(pos++ == std::string::npos) + pos = 0; + scanner_path.erase(pos); string HGVersionlib_path = scanner_path + HGVERSION_LIBNANE; if (access(HGVersionlib_path.c_str(), F_OK) != 0) @@ -464,7 +481,7 @@ int hg_scanner::hg_version_init_handle() if (!Dynamicopen_HGVersion_pHandle_ ) { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "HGVersionlib_path open dll is error: %s\n", hg_scanner_err_name(SCANNER_ERR_INSUFFICIENT_MEMORY)); + utils::to_log(LOG_LEVEL_DEBUG, "HGVersionlib_path open dll is error: %s\n", hg_scanner_err_name(SCANNER_ERR_INSUFFICIENT_MEMORY)); return SCANNER_ERR_INSUFFICIENT_MEMORY; } HGVersion_Init_ = (SDKHGVersion_Init_)dlsym(Dynamicopen_HGVersion_pHandle_, "HGVersion_CreateMgr"); @@ -492,7 +509,7 @@ int hg_scanner::hg_version_init_handle() //int l = GetLastError(); if (!Dynamicopen_HGVersion_pHandle_ ) { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Dynamicopen_HGVersion_pHandle_ open dll is error: %s\n", hg_scanner_err_name(SCANNER_ERR_INSUFFICIENT_MEMORY)); + utils::to_log(LOG_LEVEL_DEBUG, "Dynamicopen_HGVersion_pHandle_ open dll is error: %s\n", hg_scanner_err_name(SCANNER_ERR_INSUFFICIENT_MEMORY)); return SCANNER_ERR_INSUFFICIENT_MEMORY; } HGVersion_Init_ = (SDKHGVersion_Init_) GetProcAddress(Dynamicopen_HGVersion_pHandle_, "HGVersion_CreateMgr"); @@ -537,21 +554,21 @@ int hg_scanner::set_server_blacklist_lock() { ret = get_dev_islock_file(islock_file); is_checksum_strat_scan = islock_file <= 0 ? true : false; //使用校验码来进行扫描，以后只会使用这种方法进行扫描 - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "net is 404 , devs list is:%d\n", islock_file); + utils::to_log(LOG_LEVEL_DEBUG, "net is 404 , devs list is:%d\n", islock_file); } else if (!islock) { ret = HGVersion_Postlog_(HGVersion_mgr_, pidbuffer, snbuffer, fv.substr(0, 4).c_str(), fvbuffer, islock); //发送日志到服务,第三个参数随意字符串但不能为NULL is_checksum_strat_scan = true; set_dev_islock_file(0); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "use checksum start scan:%d\n", islock); + utils::to_log(LOG_LEVEL_DEBUG, "use checksum start scan:%d\n", islock); } else { ret = HGVersion_Postlog_(HGVersion_mgr_, pidbuffer, snbuffer, fv.substr(0, 4).c_str(), fvbuffer, islock); //发送日志到服务,第三个参数随意字符串但不能为NULL is_checksum_strat_scan = false; set_dev_islock_file(1); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "devs is lock:%d\n", islock); + utils::to_log(LOG_LEVEL_DEBUG, "devs is lock:%d\n", islock); } return 0 ; } @@ -774,7 +791,7 @@ void hg_scanner::get_range(const char* name, std::vector& range, st { int id = 0; setting_jsn_.at(name).at("range").at(i).get_to(id); - v = hg_log::lang_load(id); + v = lang_load_string(id, nullptr); } else setting_jsn_.at(name).at("range").at(i).get_to(v); @@ -804,7 +821,7 @@ void hg_scanner::get_range(const char* name, std::vector& range, st { def_val = get_setting_item_string(name, "default"); } - //VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "setting %d has %d range(s) and default value is '%s'\n", setting_no, range.size(), def_val.c_str()); + //utils::to_log(LOG_LEVEL_DEBUG, "setting %d has %d range(s) and default value is '%s'\n", setting_no, range.size(), def_val.c_str()); } bool hg_scanner::check_range(const char* name, bool& val) { @@ -924,7 +941,7 @@ bool hg_scanner::check_paper_and_resolution(int res, int paper) paper == PAPER_MAX_SIZE_CLIP || paper == PAPER_TRIGEMINY) { - VLOG_MINI_2(LOG_LEVEL_WARNING, "resolution '%d' is in-compatible with paper '%s'\n", res, paper_string(paper).c_str()); + utils::to_log(LOG_LEVEL_WARNING, "resolution '%d' is in-compatible with paper '%s'\n", res, paper_string(paper).c_str()); return false; } } @@ -933,9 +950,9 @@ bool hg_scanner::check_paper_and_resolution(int res, int paper) } bool hg_scanner::check_resolution_and_quality(int res, const char* quality) { - if (res == 600 && strcmp(quality, hg_log::lang_load(ID_OPTION_VALUE_HZ_SDYX)) == 0) + if (res == 600 && strcmp(quality, lang_load_string(ID_OPTION_VALUE_HZ_SDYX, nullptr)) == 0) { - VLOG_MINI_2(LOG_LEVEL_WARNING, "resolution '%d' is in-compatible with quality '%s'\n", res, quality); + utils::to_log(LOG_LEVEL_WARNING, "resolution '%d' is in-compatible with quality '%s'\n", res, quality); return false; } @@ -1021,7 +1038,7 @@ bool hg_scanner::get_default_value(void* buf, json* jsn) { int n = 0; jsn->at("default").get_to(n); - type = hg_log::lang_load(n); + type = lang_load_string(n, nullptr); } else jsn->at("default").get_to(type); @@ -1052,7 +1069,7 @@ void hg_scanner::thread_handle_image_process(void) { if (wait_usb_.is_waiting()) { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "[thread_handle_image_process 'break thread!!!'] Total pic %d.\n", cnt); + utils::to_log(LOG_LEVEL_DEBUG, "[thread_handle_image_process 'break thread!!!'] Total pic %d.\n", cnt); cnt = 0; break; } @@ -1062,8 +1079,8 @@ void hg_scanner::thread_handle_image_process(void) uint32_t id = -1; cnt++; - LOG_INFO(LOG_LEVEL_DEBUG_INFO, "\r\n"); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "[thread_handle_image_process] Total from the queue:[%d].\n", cnt); + utils::log_info("\r\n", LOG_LEVEL_DEBUG); + utils::to_log(LOG_LEVEL_DEBUG, "[thread_handle_image_process] Total from the queue:[%d].\n", cnt); tiny_buffer = imgs_.Take(&id); if (tiny_buffer->swap()) { @@ -1072,7 +1089,7 @@ void hg_scanner::thread_handle_image_process(void) if (!ImagePrc_pHandle_) { - VLOG_MINI_1(LOG_LEVEL_FATAL, "[thread_handle_image_process]:Get Image Process is NULL pid is %d.\n",pid_); + utils::to_log(LOG_LEVEL_FATAL, "[thread_handle_image_process]:Get Image Process is NULL pid is %d.\n",pid_); stop_fatal_ = SCANNER_ERR_INSUFFICIENT_MEMORY; stop(); break; @@ -1088,24 +1105,24 @@ void hg_scanner::thread_handle_image_process(void) } else stop_fatal_ = SCANNER_ERR_INSUFFICIENT_MEMORY; - VLOG_MINI_1(LOG_LEVEL_FATAL, "[thread_handle_image_process]:is opencv Fatal and stop scanner: %s\n", e.what()); + utils::to_log(LOG_LEVEL_FATAL, "[thread_handle_image_process]:is opencv Fatal and stop scanner: %s\n", e.what()); stop(); break; } catch (...) { - VLOG_MINI_1(LOG_LEVEL_FATAL, "[thread_handle_image_process]:stop scanner!!! Insufficient memory when proecss image with %d bytes.\n", tiny_buffer->size()); + utils::to_log(LOG_LEVEL_FATAL, "[thread_handle_image_process]:stop scanner!!! Insufficient memory when proecss image with %d bytes.\n", tiny_buffer->size()); stop_fatal_ = SCANNER_ERR_INSUFFICIENT_MEMORY; stop(); } } else { - VLOG_MINI_1(LOG_LEVEL_FATAL, "[thread_handle_image_process]:Reload USB data '%s' failed!\n", tiny_buffer->file().c_str()); + utils::to_log(LOG_LEVEL_FATAL, "[thread_handle_image_process]:Reload USB data '%s' failed!\n", tiny_buffer->file().c_str()); } } - LOG_INFO(LOG_LEVEL_DEBUG_INFO, "[thread_handle_image_process 'EXIT !!!']\n"); + utils::log_info("[thread_handle_image_process 'EXIT !!!']\n", LOG_LEVEL_DEBUG); //VLDGlobalDisable(); } void hg_scanner::working_begin(void*) @@ -1113,8 +1130,8 @@ void hg_scanner::working_begin(void*) stop_fatal_ = SCANNER_ERR_OK; final_img_index_ = 0; status_ = SCANNER_ERR_OK; - notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCAN_WORKING), SANE_EVENT_WORKING, SCANNER_ERR_OK); - LOG_INFO(LOG_LEVEL_DEBUG_INFO, "scanning ...\n"); + notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCAN_WORKING, nullptr), SANE_EVENT_WORKING, SCANNER_ERR_OK); + utils::log_info("scanning ...\n", LOG_LEVEL_DEBUG); } void hg_scanner::working_done(void*) { @@ -1128,94 +1145,94 @@ void hg_scanner::working_done(void*) switch (status_) { case SCANNER_ERR_OK: - notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCAN_STOPPED), SANE_EVENT_SCAN_FINISHED, status_); + notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCAN_STOPPED, nullptr), SANE_EVENT_SCAN_FINISHED, status_); break; case SCANNER_ERR_DEVICE_BUSY: - notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_PC_BUSY), SANE_EVENT_SCAN_FINISHED, status_); + notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_PC_BUSY, nullptr), SANE_EVENT_SCAN_FINISHED, status_); break; case SCANNER_ERR_DEVICE_STOPPED: - notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCAN_STOPPED), SANE_EVENT_SCAN_FINISHED, status_); + notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCAN_STOPPED, nullptr), SANE_EVENT_SCAN_FINISHED, status_); break; case SCANNER_ERR_DEVICE_COVER_OPENNED: - notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_COVER_OPENNED), SANE_EVENT_SCAN_FINISHED, status_); + notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_COVER_OPENNED, nullptr), SANE_EVENT_SCAN_FINISHED, status_); break; case SCANNER_ERR_DEVICE_NO_PAPER: - notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER), SANE_EVENT_SCAN_FINISHED, status_); + notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER, nullptr), SANE_EVENT_SCAN_FINISHED, status_); break; case SCANNER_ERR_DEVICE_FEEDING_PAPER: - notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_FEEDING_PAPER), SANE_EVENT_SCAN_FINISHED, status_); + notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_FEEDING_PAPER, nullptr), SANE_EVENT_SCAN_FINISHED, status_); break; case SCANNER_ERR_DEVICE_NOT_FOUND: - notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_NOT_FOUND), SANE_EVENT_SCAN_FINISHED, status_); + notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_NOT_FOUND, nullptr), SANE_EVENT_SCAN_FINISHED, status_); break; case SCANNER_ERR_DEVICE_SLEEPING: - notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING), SANE_EVENT_SCAN_FINISHED, status_); + notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING, nullptr), SANE_EVENT_SCAN_FINISHED, status_); break; case SCANNER_ERR_DEVICE_COUNT_MODE: - notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_COUNT_MODE), SANE_EVENT_SCAN_FINISHED, status_); + notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_COUNT_MODE, nullptr), SANE_EVENT_SCAN_FINISHED, status_); break; case SCANNER_ERR_DEVICE_DOUBLE_FEEDING: - notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_DOUBLE_FEEDING), SANE_EVENT_SCAN_FINISHED, status_); + notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_DOUBLE_FEEDING, nullptr), SANE_EVENT_SCAN_FINISHED, status_); break; case SCANNER_ERR_DEVICE_PAPER_JAMMED: - notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_PAPER_JAMMED), SANE_EVENT_SCAN_FINISHED, status_); + notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_PAPER_JAMMED, nullptr), SANE_EVENT_SCAN_FINISHED, status_); break; case SCANNER_ERR_DEVICE_STAPLE_ON: - notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_STAPLE_ON), SANE_EVENT_SCAN_FINISHED, status_); + notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_STAPLE_ON, nullptr), SANE_EVENT_SCAN_FINISHED, status_); break; case SCANNER_ERR_DEVICE_PAPER_SKEW: - notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_PAPER_SKEW), SANE_EVENT_SCAN_FINISHED, status_); + notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_PAPER_SKEW, nullptr), SANE_EVENT_SCAN_FINISHED, status_); break; case SCANNER_ERR_DEVICE_SIZE_CHECK: - notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_SIZE_CHECK), SANE_EVENT_SCAN_FINISHED, status_); + notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_SIZE_CHECK, nullptr), SANE_EVENT_SCAN_FINISHED, status_); break; case SCANNER_ERR_DEVICE_DOGEAR: - notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_DOGEAR), SANE_EVENT_SCAN_FINISHED, status_); + notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_DOGEAR, nullptr), SANE_EVENT_SCAN_FINISHED, status_); break; case SCANNER_ERR_DEVICE_NO_IMAGE: - notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_NO_IMAGE), SANE_EVENT_SCAN_FINISHED, status_); + notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_NO_IMAGE, nullptr), SANE_EVENT_SCAN_FINISHED, status_); break; case SCANNER_ERR_DEVICE_SCANN_ERROR: - notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_SCANN_ERROR), SANE_EVENT_SCAN_FINISHED, status_); + notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_SCANN_ERROR, nullptr), SANE_EVENT_SCAN_FINISHED, status_); break; case SCANNER_ERR_DEVICE_PC_BUSY: - notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_PC_BUSY), SANE_EVENT_SCAN_FINISHED, status_); + notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_PC_BUSY, nullptr), SANE_EVENT_SCAN_FINISHED, status_); break; case SCANNER_ERR_INSUFFICIENT_MEMORY: - notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_INSUFFICIENT_MEMORY), SANE_EVENT_SCAN_FINISHED, status_); + notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_INSUFFICIENT_MEMORY, nullptr), SANE_EVENT_SCAN_FINISHED, status_); break; case SCANNER_ERR_TIMEOUT: - notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_TIMEOUT), SANE_EVENT_SCAN_FINISHED, status_); + notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_TIMEOUT, nullptr), SANE_EVENT_SCAN_FINISHED, status_); break; case SCANNER_ERR_DEVICE_ISLOCK: - notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_ISLOCK), SANE_EVENT_SCAN_FINISHED, status_); + notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_ISLOCK, nullptr), SANE_EVENT_SCAN_FINISHED, status_); break; case SCANNER_ERR_DEVICE_AUTO_FAIL_OVER: - notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_AUTO_FAIL_OVER), SANE_EVENT_SCAN_FINISHED, status_); + notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_AUTO_FAIL_OVER, nullptr), SANE_EVENT_SCAN_FINISHED, status_); break; case SCANNER_ERR_DEVICE_DISTORTION: - notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_DISTORTION), SANE_EVENT_SCAN_FINISHED, status_); + notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_DISTORTION, nullptr), SANE_EVENT_SCAN_FINISHED, status_); break; case SCANNER_ERR_DEVICE_MAYBE_IS_HOLE: - notify_ui_working_status(from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_MAYBE_IS_HOLE), SANE_EVENT_SCAN_FINISHED, status_); + notify_ui_working_status(from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_MAYBE_IS_HOLE, nullptr), SANE_EVENT_SCAN_FINISHED, status_); break; case SCANNER_ERR_DEVICE_DEVS_BOOTING: - notify_ui_working_status(from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_DEVS_BOOTING), SANE_EVENT_SCAN_FINISHED, status_); + notify_ui_working_status(from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_DEVS_BOOTING, nullptr), SANE_EVENT_SCAN_FINISHED, status_); break; default: - notify_ui_working_status(user_cancel_ ? hg_log::lang_load(ID_STATU_DESC_SCAN_CANCELED) : hg_log::lang_load(ID_STATU_DESC_SCAN_STOPPED), SANE_EVENT_SCAN_FINISHED, status_); + notify_ui_working_status(user_cancel_ ? lang_load_string(ID_STATU_DESC_SCAN_CANCELED, nullptr) : lang_load_string(ID_STATU_DESC_SCAN_STOPPED, nullptr), SANE_EVENT_SCAN_FINISHED, status_); break; } if (test_1_paper_) { - LOG_INFO(LOG_LEVEL_DEBUG_INFO, "scanning mode: finished testing ONE paper, restore to normal scanning.\n"); + utils::log_info("scanning mode: finished testing ONE paper, restore to normal scanning.\n", LOG_LEVEL_DEBUG); } else { - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "EXIT All Thread--->Total picture: [%d] and scanner status [%s].\n", final_img_index_, hg_scanner_err_description(status_)); + utils::to_log(LOG_LEVEL_DEBUG, "EXIT All Thread--->Total picture: [%d] and scanner status [%s].\n", final_img_index_, hg_scanner_err_description(status_)); } - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "----------Main End scan status----------%s:\n", hg_scanner_err_description(status_)); + utils::to_log(LOG_LEVEL_DEBUG, "----------Main End scan status----------%s:\n", hg_scanner_err_description(status_)); test_1_paper_ = false; } @@ -1484,8 +1501,14 @@ int hg_scanner::setting_help(void* data, long* len) } #if defined(WIN32) || defined(_WIN64) + std::string root(utils::get_module_full_path(SCANNER_DRIVER_PART_NAME)); + size_t pos = root.rfind(PATH_SEPARATOR[0]); + + if(pos++ == std::string::npos) + pos = 0; + root.erase(pos); com = ""; - helpfile.insert(0, hg_log::get_scanner_path()); + helpfile.insert(0, root); FILE* src = fopen(helpfile.c_str(), "rb"); if (src) fclose(src); @@ -1494,7 +1517,7 @@ int hg_scanner::setting_help(void* data, long* len) if (access(helpfile.c_str(),F_OK) == -1) #endif { - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO,"open help file fail,not find file :%d code page :%d\r\n",helpfile.c_str(), code_page); + utils::to_log(LOG_LEVEL_DEBUG,"open help file fail,not find file :%d code page :%d\r\n",helpfile.c_str(), code_page); ret = SCANNER_ERR_OPEN_FILE_FAILED; return ret ; } @@ -1505,7 +1528,7 @@ int hg_scanner::setting_help(void* data, long* len) #else system(com.c_str()); #endif - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO,"App_Help_pdf Path is:%s Code Page is:%d\n",helpfile.c_str(), code_page); + utils::to_log(LOG_LEVEL_DEBUG,"App_Help_pdf Path is:%s Code Page is:%d\n",helpfile.c_str(), code_page); return ret; } int hg_scanner::setting_color_mode(void* data, long* len) @@ -1541,7 +1564,7 @@ int hg_scanner::setting_color_mode(void* data, long* len) is_auto_matic_color = image_prc_param_.bits.color_mode == COLOR_MODE_AUTO_MATCH ? true :false; // 等于COLOR_MODE_AUTO_MATCH 的时候颜色模式需要变为2 彩色模式图像参数和硬件参数都如此 - VLOG_MINI_4(LOG_LEVEL_DEBUG_INFO, "Change color mode from %s to %s = %s color is =%s\n", color_mode_string(old).c_str(), (char*)data, hg_scanner_err_name(ret),str.c_str()); + utils::to_log(LOG_LEVEL_DEBUG, "Change color mode from %s to %s = %s color is =%s\n", color_mode_string(old).c_str(), (char*)data, hg_scanner_err_name(ret),str.c_str()); if(ret == SCANNER_ERR_NOT_EXACT) strcpy((char*)data, str.c_str()); @@ -1551,7 +1574,7 @@ int hg_scanner::setting_multi_out(void* data, long* len) { is_multiout = *((bool*)data); int val = image_prc_param_.bits.color_mode; - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "image_prc_param_.bits.multi_out %d\n", image_prc_param_.bits.multi_out); + utils::to_log(LOG_LEVEL_DEBUG, "image_prc_param_.bits.multi_out %d\n", image_prc_param_.bits.multi_out); //if (is_multiout) //{ @@ -1575,7 +1598,7 @@ int hg_scanner::setting_multi_out_type(void* data, long* len) image_prc_param_.bits.multi_out = match_best_multi_out(str,NULL); save_multiout = str; - VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "set multi_out type from %s to %s = %s\n", multi_out_string(image_prc_param_.bits.multi_out).c_str(), (char*)data, hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "set multi_out type from %s to %s = %s\n", multi_out_string(image_prc_param_.bits.multi_out).c_str(), (char*)data, hg_scanner_err_name(ret)); /*if (image_prc_param_.bits.multi_out == MULTI_GRAY_AND_BW) color = COLOR_MODE_256_GRAY; @@ -1695,7 +1718,7 @@ int hg_scanner::setting_paper(void* data, long* len) invoke_setting_xxx(&hg_scanner::setting_paper_check, &save_sizecheck, &l); } - VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "Change paper from %s to %s = %s\n", paper_string(old).c_str(), (char*)data, hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "Change paper from %s to %s = %s\n", paper_string(old).c_str(), (char*)data, hg_scanner_err_name(ret)); if(ret == SCANNER_ERR_NOT_EXACT) strcpy((char*)data, paper.c_str()); @@ -1726,7 +1749,7 @@ int hg_scanner::setting_paper_check(void* data, long* len) int ret = on_paper_check_changed(use); - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "Change paper size-checking %s = %s\n", *((bool*)data) ? "enabled" : "disabled", hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "Change paper size-checking %s = %s\n", *((bool*)data) ? "enabled" : "disabled", hg_scanner_err_name(ret)); if (ret == SCANNER_ERR_DEVICE_NOT_SUPPORT) { *((bool*)data) = use; @@ -1742,7 +1765,7 @@ int hg_scanner::setting_page(void* data, long* len) bool exact = check_range(SANE_STD_OPT_NAME_PAGE, val); int ret = exact ? SCANNER_ERR_OK : SCANNER_ERR_NOT_EXACT; - VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "Change page from %s to %s = %s\n", page_string(image_prc_param_.bits.page).c_str(), (char*)data, hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "Change page from %s to %s = %s\n", page_string(image_prc_param_.bits.page).c_str(), (char*)data, hg_scanner_err_name(ret)); image_prc_param_.bits.page = match_best_page(val, NULL); if (!exact) strcpy((char*)data, val.c_str()); @@ -1809,7 +1832,7 @@ int hg_scanner::setting_resolution(void* data, long* len) else if (sub) ret = sub; - VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "Change resolution from %d to %d = %s\n", old, *((int*)data), hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "Change resolution from %d to %d = %s\n", old, *((int*)data), hg_scanner_err_name(ret)); //*((int*)data) = resolution_; if (!have_max_size) { @@ -1910,7 +1933,7 @@ int hg_scanner::setting_rid_hoe_range(void* data, long* len) *((int*)data) = rid_hole_range_; } rid_hole_range_*=100; - VLOG_MINI_1(LOG_LEVEL_WARNING, "set rid_hole_range_ = %f\r\n", rid_hole_range_); + utils::to_log(LOG_LEVEL_WARNING, "set rid_hole_range_ = %f\r\n", rid_hole_range_); return ret; } @@ -1924,7 +1947,7 @@ int hg_scanner::setting_bright(void* data, long* len) ret = SCANNER_ERR_NOT_EXACT; *((int*)data) = bright_; } - VLOG_MINI_1(LOG_LEVEL_WARNING, "set bright_ = %d\r\n", bright_); + utils::to_log(LOG_LEVEL_WARNING, "set bright_ = %d\r\n", bright_); return ret; } int hg_scanner::setting_contrast(void* data, long* len) @@ -1937,7 +1960,7 @@ int hg_scanner::setting_contrast(void* data, long* len) ret = SCANNER_ERR_NOT_EXACT; *((int*)data) = contrast_; } - VLOG_MINI_1(LOG_LEVEL_WARNING, "set contrast_ = %d\r\n", contrast_); + utils::to_log(LOG_LEVEL_WARNING, "set contrast_ = %d\r\n", contrast_); return ret; } int hg_scanner::setting_gamma(void* data, long* len) @@ -1959,7 +1982,7 @@ int hg_scanner::setting_sharpen(void* data, long* len) int ret = SCANNER_ERR_OK; bool exact = check_range(SANE_STD_OPT_NAME_SHARPEN, str); - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "Change sharpen from %s to %s = ", sharpen_string(image_prc_param_.bits.sharpen).c_str(), (char*)data); + utils::to_log(LOG_LEVEL_DEBUG, "Change sharpen from %s to %s = ", sharpen_string(image_prc_param_.bits.sharpen).c_str(), (char*)data); image_prc_param_.bits.sharpen = match_best_sharpen(str, NULL); if (!exact) @@ -1967,7 +1990,7 @@ int hg_scanner::setting_sharpen(void* data, long* len) strcpy((char*)data, str.c_str()); ret = SCANNER_ERR_NOT_EXACT; } - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "%d\n", ret); + utils::to_log(LOG_LEVEL_DEBUG, "%d\n", ret); return ret; } @@ -2048,7 +2071,7 @@ int hg_scanner::setting_is_permeate_lv(void* data, long* len) std::string str((char*)data); bool exact = check_range(SANE_STD_OPT_NAME_ANTI_PERMEATE_LEVEL, str); - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "Change is_permeate_lv from %s to %s = ", is_permaeate_string(image_prc_param_.bits.is_permeate_lv_).c_str(), (char*)data); + utils::to_log(LOG_LEVEL_DEBUG, "Change is_permeate_lv from %s to %s = ", is_permaeate_string(image_prc_param_.bits.is_permeate_lv_).c_str(), (char*)data); image_prc_param_.bits.is_permeate_lv_ = match_best_permaeate_lv(str, NULL); if (!exact) @@ -2056,7 +2079,7 @@ int hg_scanner::setting_is_permeate_lv(void* data, long* len) strcpy((char*)data, str.c_str()); ret = SCANNER_ERR_NOT_EXACT; } - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "%d\n", ret); + utils::to_log(LOG_LEVEL_DEBUG, "%d\n", ret); return ret; @@ -2104,9 +2127,9 @@ int hg_scanner::setting_go_on_when_double_checked(void* data, long* len) bool ok = true; std::string val((char*)data); - if (!firmware_sup_double_img && val.compare(hg_log::lang_load(ID_OPTION_VALUE_SZTPCL_DQTXBTZSM))) + if (!firmware_sup_double_img && val.compare(lang_load_string(ID_OPTION_VALUE_SZTPCL_DQTXBTZSM, nullptr))) { - strcpy((char*)data, hg_log::lang_load(ID_OPTION_VALUE_SZTPCL_SCTXBTZSM)); + strcpy((char*)data, lang_load_string(ID_OPTION_VALUE_SZTPCL_SCTXBTZSM, nullptr)); return SCANNER_ERR_DEVICE_NOT_SUPPORT; } @@ -2141,7 +2164,7 @@ int hg_scanner::setting_scan_mode(void* data, long* len) bool exact = check_range(SANE_STD_OPT_NAME_SCAN_MODE, str); int ret = exact ? SCANNER_ERR_OK : SCANNER_ERR_NOT_EXACT; - if (strcmp(str.c_str(), hg_log::lang_load(ID_OPTION_VALUE_SMZS_LXSM)) == 0) + if (strcmp(str.c_str(), lang_load_string(ID_OPTION_VALUE_SMZS_LXSM, nullptr)) == 0) { scan_count_ = -1; } @@ -2150,7 +2173,7 @@ int hg_scanner::setting_scan_mode(void* data, long* len) setting_jsn_.at(SANE_STD_OPT_NAME_SCAN_COUNT).at("cur").get_to(scan_count_); } - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "set scanning pages to %d\n", scan_count_); + utils::to_log(LOG_LEVEL_DEBUG, "set scanning pages to %d\n", scan_count_); return ret; } @@ -2159,7 +2182,7 @@ int hg_scanner::setting_scan_count(void* data, long* len) int ret = SCANNER_ERR_OK; std::string val(get_setting_item_string(SANE_STD_OPT_NAME_SCAN_MODE, "cur")); - if (val == hg_log::lang_load(ID_OPTION_VALUE_SMZS_LXSM)) + if (val == lang_load_string(ID_OPTION_VALUE_SMZS_LXSM, nullptr)) { scan_count_ = -1; } @@ -2167,7 +2190,7 @@ int hg_scanner::setting_scan_count(void* data, long* len) { scan_count_ = *((int*)data); } - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "set scanning pages to %d\n", scan_count_); + utils::to_log(LOG_LEVEL_DEBUG, "set scanning pages to %d\n", scan_count_); return ret; } @@ -2177,7 +2200,7 @@ int hg_scanner::setting_text_direction(void* data, long* len) bool exact = check_range(SANE_STD_OPT_NAME_TEXT_DIRECTION, str); int ret = exact ? SCANNER_ERR_OK : SCANNER_ERR_NOT_EXACT; - VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "Change text direction from '%s' to '%s' = %s\n", text_direction_string(image_prc_param_.bits.text_direction).c_str() + utils::to_log(LOG_LEVEL_DEBUG, "Change text direction from '%s' to '%s' = %s\n", text_direction_string(image_prc_param_.bits.text_direction).c_str() , (char*)data, hg_scanner_err_name(ret)); image_prc_param_.bits.text_direction = match_best_text_direction(str, NULL); @@ -2303,7 +2326,7 @@ int hg_scanner::setting_img_quality(void* data, long* len) bool exact = check_range(SANE_STD_OPT_NAME_IMAGE_QUALITY, str); int ret = exact ? SCANNER_ERR_OK : SCANNER_ERR_NOT_EXACT; int old = is_quality_; - VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "Change quality from '%s' to '%s' = %s\n", is_img_quality(is_quality_).c_str() + utils::to_log(LOG_LEVEL_DEBUG, "Change quality from '%s' to '%s' = %s\n", is_img_quality(is_quality_).c_str() , (char*)data, hg_scanner_err_name(ret)); is_quality_ = match_best_img_quality(str,NULL); @@ -2355,7 +2378,7 @@ int hg_scanner::setting_feedmode(void* data, long* len) if (ret == SCANNER_ERR_OK) feedmode_ = val; - VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "setfeedmode from '%s' to '%s' = %s\n", is_paper_strength(feedmode_).c_str() + utils::to_log(LOG_LEVEL_DEBUG, "setfeedmode from '%s' to '%s' = %s\n", is_paper_strength(feedmode_).c_str() , (char*)data, hg_scanner_err_name(ret)); return ret; } @@ -2402,7 +2425,7 @@ int hg_scanner::setting_sleeptime(void* data, long* len) if (ret == SCANNER_ERR_OK) sleeptime_ = val; - VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "set sleeptime from (%s)min to (%s)min = %s\n", is_sleep_time(sleeptime_).c_str() + utils::to_log(LOG_LEVEL_DEBUG, "set sleeptime from (%s)min to (%s)min = %s\n", is_sleep_time(sleeptime_).c_str() , (char*)data, hg_scanner_err_name(ret)); return ret; } @@ -2517,7 +2540,7 @@ int hg_scanner::setting_auto_paper_scan_exit_time(void* data, long* len) else is_auto_paper_scan_exit_time = 60; //is_auto_paper_scan_exit_time = *((int*)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); + //utils::to_log(LOG_LEVEL_DEBUG, "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, long* len) @@ -2729,7 +2752,7 @@ void hg_scanner::on_device_reconnected(void) { std::lock_guard lock(io_lock_); - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "%04x:%04x reconnected.\n", io_->get_vid(), io_->get_pid()); + utils::to_log(LOG_LEVEL_DEBUG, "%04x:%04x reconnected.\n", io_->get_vid(), io_->get_pid()); } int hg_scanner::set_setting_value(const char* name, void* data, long* len) { @@ -2884,7 +2907,7 @@ void hg_scanner::change_setting_language(bool init) id = lang_get_string_id(val.c_str(), true); if (id == -1) { - VLOG_MINI_1(LOG_LEVEL_WARNING, "LANGUAGE-ERR: lost item ID of '%s'\n", val.c_str()); + utils::to_log(LOG_LEVEL_WARNING, "LANGUAGE-ERR: lost item ID of '%s'\n", val.c_str()); } else setting_jsn_.at(v.c_str()).at("range")[i] = id; @@ -2969,10 +2992,10 @@ void hg_scanner::init_settings(const char* json_setting_text) jsn_reorganize(); - VLOG_MINI_1(LOG_LEVEL_ALL, "Initialize %d settings ...\n", jsn_children_.size() - 1); + utils::to_log(LOG_LEVEL_ALL, "Initialize %d settings ...\n", jsn_children_.size() - 1); notify_setting_result_ = false; change_setting_language(true); - VLOG_MINI_1(LOG_LEVEL_ALL, "Initialize %d settings ... OK\n", jsn_children_.size() - 1); + utils::to_log(LOG_LEVEL_ALL, "Initialize %d settings ... OK\n", jsn_children_.size() - 1); if (lang_get_cur_code_page() != DEFAULT_CODE_PAGE) on_language_changed(); notify_setting_result_ = true; @@ -2985,13 +3008,16 @@ void hg_scanner::init_settings(const char* json_setting_text) int hg_scanner::init_settings(int pid) { char rel_path[80] = { 0 }; - std::string root(hg_log::get_scanner_path()), jsn(""); - int ret = 0; + std::string root(utils::get_module_full_path(SCANNER_DRIVER_PART_NAME)), jsn(""); + int ret = root.rfind(PATH_SEPARATOR[0]); + if((size_t)ret++ == std::string::npos) + ret = 0; + root.erase(ret); sprintf(rel_path, "%ssettings%s%04x.hsc", PATH_SEPARATOR, PATH_SEPARATOR, pid); root += rel_path; ret = load_scanner_setting(root.c_str(), jsn); - VLOG_MINI_2(LOG_LEVEL_WARNING, "Apply '%s' setting: %d\n", root.c_str(), ret); + utils::to_log(LOG_LEVEL_WARNING, "Apply '%s' setting: %d\n", root.c_str(), ret); if (ret) return SCANNER_ERR_DATA_DAMAGED; @@ -3010,7 +3036,7 @@ void hg_scanner::change_string_2_lang_id(const char* name, const char* key) id = lang_get_string_id(val.c_str(), true); if (id == -1) { - VLOG_MINI_1(LOG_LEVEL_WARNING, "LANGUAGE-ERR: lost item ID of '%s'\n", val.c_str()); + utils::to_log(LOG_LEVEL_WARNING, "LANGUAGE-ERR: lost item ID of '%s'\n", val.c_str()); } else setting_jsn_.at(name).at(key) = id; @@ -3024,7 +3050,7 @@ std::string hg_scanner::get_setting_item_string(const char* name, const char* ke { int n = -1; setting_jsn_.at(name).at(key).get_to(n); - ret = hg_log::lang_load(n); + ret = lang_load_string(n, nullptr); } else { @@ -3037,7 +3063,7 @@ int hg_scanner::on_scann_error(int err) { status_ = err; - VLOG_MINI_1(LOG_LEVEL_FATAL, "[xxx]Device status: 0x%x\n", err); + utils::to_log(LOG_LEVEL_FATAL, "[xxx]Device status: 0x%x\n", err); unsigned int e = err; @@ -3108,8 +3134,8 @@ std::shared_ptr hg_scanner::aquire_memory(int size, bool from_usb) if (!mem->data(0, (unsigned int*)&size)) { mem.reset(); - LOG_INFO(LOG_LEVEL_FATAL, "Can't aquire enough memory, working must be stopped!\n"); - notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_INSUFFICIENT_MEMORY), SANE_EVENT_ERROR, SCANNER_ERR_INSUFFICIENT_MEMORY); + utils::log_info("Can't aquire enough memory, working must be stopped!\n", LOG_LEVEL_FATAL); + notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_INSUFFICIENT_MEMORY, nullptr), SANE_EVENT_ERROR, SCANNER_ERR_INSUFFICIENT_MEMORY); stop(); } @@ -3150,8 +3176,8 @@ bool hg_scanner::waiting_for_memory_enough(unsigned need_bytes) { if (first) { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Memory is too small for aquiring image(%u bytes), wait for ENOUGH ...\n", need_bytes); - notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_WAIT_FOR_MEM)); + utils::to_log(LOG_LEVEL_DEBUG, "Memory is too small for aquiring image(%u bytes), wait for ENOUGH ...\n", need_bytes); + notify_ui_working_status(lang_load_string(ID_STATU_DESC_WAIT_FOR_MEM, nullptr)); first = false; } std::this_thread::sleep_for(std::chrono::milliseconds(30)); @@ -3161,11 +3187,11 @@ bool hg_scanner::waiting_for_memory_enough(unsigned need_bytes) { if (buf) { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "waited for memory need(%u)\n", need_bytes); + utils::to_log(LOG_LEVEL_DEBUG, "waited for memory need(%u)\n", need_bytes); } else { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "canceled by user while waiting for memory need(%u)\n", need_bytes); + utils::to_log(LOG_LEVEL_DEBUG, "canceled by user while waiting for memory need(%u)\n", need_bytes); } } ret = (!user_cancel_) && (buf != NULL); @@ -3193,7 +3219,7 @@ int hg_scanner::save_usb_data(std::shared_ptr data) unsigned int bytes = data->size(); usb_img_index_++; - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "USB read one picture with %u bytes\n", data->size()); + utils::to_log(LOG_LEVEL_DEBUG, "USB read one picture with %u bytes\n", data->size()); if (dump_usb_path_.length()) //这两台设备不是jpg的图 所以不能直接处理 { char name[80] = { 0 }; @@ -3242,11 +3268,11 @@ int hg_scanner::save_usb_data(std::shared_ptr data) else Memoryusae += final_imgs_.mem_usage() / 1024.0f / 1024.0f; if(num++ == 0) - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Memory Usage is Too big:%f ,Please wait -_- ...\r\n", Memoryusae); + utils::to_log(LOG_LEVEL_DEBUG, "Memory Usage is Too big:%f ,Please wait -_- ...\r\n", Memoryusae); } if (num && Memoryusae >= memory_size_ && !user_cancel_) { - VLOG_MINI_1(LOG_LEVEL_WARNING, "Warning: memory usage(%.2fMB) maybe leading exception!\r\n", Memoryusae); + utils::to_log(LOG_LEVEL_WARNING, "Warning: memory usage(%.2fMB) maybe leading exception!\r\n", Memoryusae); } imgs_.Put(data, data->size(), hg_scanner_mgr::unique_id()); if (wait_img_.is_waiting()) @@ -3286,7 +3312,7 @@ int hg_scanner::save_final_image(hg_imgproc::LPIMGHEAD head, void* buf, uint32_t buf = &bw[0]; head->channels = head->bits = 1; head->total_bytes = head->line_bytes * head->height; - VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "convert to 1-bit bmp(%d * %d), total = %u, len = %u , black_white_image_threshold_ =%d\n", head->width, head->height, head->total_bytes, bw.length(), bw_threshold_); + utils::to_log(LOG_LEVEL_DEBUG, "convert to 1-bit bmp(%d * %d), total = %u, len = %u , black_white_image_threshold_ =%d\n", head->width, head->height, head->total_bytes, bw.length(), bw_threshold_); } if (async_io_) @@ -3303,7 +3329,7 @@ int hg_scanner::save_final_image(hg_imgproc::LPIMGHEAD head, void* buf, uint32_t if (img.flag.statu) { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "some error with final image: %s\n", hg_scanner_image_statu_name(img.flag.statu)); + utils::to_log(LOG_LEVEL_DEBUG, "some error with final image: %s\n", hg_scanner_image_statu_name(img.flag.statu)); } return ui_ev_cb_((scanner_handle)this, SANE_EVENT_IMAGE_OK, &img, &final_img_index_, NULL); @@ -3435,7 +3461,7 @@ int hg_scanner::close(bool force) } else if (io_) { - LOG_INFO(LOG_LEVEL_WARNING, "close scanner: USB thread or Image thread is still running.\n"); + utils::log_info("close scanner: USB thread or Image thread is still running.\n", LOG_LEVEL_WARNING); io_->close(); while (scan_life_) std::this_thread::sleep_for(std::chrono::milliseconds(5)); @@ -3466,7 +3492,7 @@ int hg_scanner::set_setting(const char* name, void* data, long* len) } else { - VLOG_MINI_1(LOG_LEVEL_WARNING, "Setting '%s' is not found in base setting functions.\n", real_n.c_str()); + utils::to_log(LOG_LEVEL_WARNING, "Setting '%s' is not found in base setting functions.\n", real_n.c_str()); ret = set_setting_value(real_n.c_str(), data, len); } @@ -3548,7 +3574,7 @@ int hg_scanner::get_setting(const char* name, char* json_txt_buf, int* len, int* } else if (!setting_jsn_.contains(real_n)) { - VLOG_MINI_1(LOG_LEVEL_FATAL, "!!!option(%s) is not found.\n", real_n.c_str()); + utils::to_log(LOG_LEVEL_FATAL, "!!!option(%s) is not found.\n", real_n.c_str()); return SCANNER_ERR_OUT_OF_RANGE; } else @@ -3559,7 +3585,7 @@ int hg_scanner::get_setting(const char* name, char* json_txt_buf, int* len, int* //{ // int i = it->second; // - // const char* load = hg_log::lang_load(i); + // const char* load = lang_load_string(i); // if (*load) // { // setting_jsn_.at(real_n).at("title") = load; @@ -3628,7 +3654,7 @@ void hg_scanner::on_language_changed(void) if (setting_jsn_.at(v.c_str()).at("range").at(i).is_number()) { setting_jsn_.at(v.c_str()).at("range").at(i).get_to(id); - val = hg_log::lang_load(id); + val = lang_load_string(id, nullptr); } else setting_jsn_.at(v.c_str()).at("range").at(i).get_to(val); @@ -3641,7 +3667,7 @@ void hg_scanner::on_language_changed(void) if (now > old) { setting_jsn_.at(v.c_str()).at("size") = now; - VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "Change size of '%s' from %d to %d\n", v.c_str(), old, now); + utils::to_log(LOG_LEVEL_DEBUG, "Change size of '%s' from %d to %d\n", v.c_str(), old, now); } } } @@ -3699,7 +3725,7 @@ int hg_scanner::get_image_info(SANE_Parameters* ii) ret = SCANNER_ERR_OK; } } - VLOG_MINI_4(LOG_LEVEL_DEBUG_INFO, "Get image info(%d * %d * %d) = %s\n", ii->pixels_per_line, ii->lines, imh.bits, hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "Get image info(%d * %d * %d) = %s\n", ii->pixels_per_line, ii->lines, imh.bits, hg_scanner_err_name(ret)); return ret; } @@ -4032,7 +4058,7 @@ int hg_scanner::device_io_control(unsigned long code, void* data, unsigned* len) { string str; int ret = get_device_log(str); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "str = %d\n", str.length()); + utils::to_log(LOG_LEVEL_DEBUG, "str = %d\n", str.length()); *(char*)data = 0; if (ret != SCANNER_ERR_OK) @@ -4060,7 +4086,7 @@ int hg_scanner::device_io_control(unsigned long code, void* data, unsigned* len) SANE_Bool islock = *((SANE_Bool*)data); int ret = get_scan_islock(islock); *((SANE_Bool*)data) = islock; - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "io ctrl islock:%d\r\n", *((SANE_Bool*)data)); + utils::to_log(LOG_LEVEL_DEBUG, "io ctrl islock:%d\r\n", *((SANE_Bool*)data)); return ret; } else if (code == IO_CTRL_CODE_SET_FIRMWARE_UPGRADE) @@ -4508,7 +4534,7 @@ void hg_scanner::image_process(std::shared_ptr& buffer, uint32_t id save_dpi_color_check_val = distortion_val.scaleXY = res.scaleXY; is_dpi_color_check = false; - VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "Set distortion val is:h:%f w:%f distortion val is:%f\n", distortion_val.h, distortion_val.w, distortion_val.scaleXY); + utils::to_log(LOG_LEVEL_DEBUG, "Set distortion val is:h:%f w:%f distortion val is:%f\n", distortion_val.h, distortion_val.w, distortion_val.scaleXY); } else if (param.cis_image || ((img_conf_.papertype == TwSS::MaxSize || img_conf_.papertype == TwSS::USStatement) @@ -4535,7 +4561,7 @@ void hg_scanner::image_process(std::shared_ptr& buffer, uint32_t id //ret = hg_imgproc::fillhole(ImagePrc_pHandle_, top, low, left, right); //(this->*dump_img_)(ImagePrc_pHandle_, "fillhole"); - //VLOG_MINI_1(LOG_LEVEL_WARNING, "Image proc fillhole is:%d\n", ret); + //utils::to_log(LOG_LEVEL_WARNING, "Image proc fillhole is:%d\n", ret); } if (pid_ != 0x239 && pid_ != 0x439) @@ -4697,7 +4723,7 @@ void hg_scanner::image_process(std::shared_ptr& buffer, uint32_t id if (is_quality_ == IMG_SPEED && resolution_ >= 300)//239 { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "set resolution_ is :%d\n", resolution_) + utils::to_log(LOG_LEVEL_DEBUG, "set resolution_ is :%d\n", resolution_); err = hg_imgproc::quality(ImagePrc_pHandle_, resolution_); (this->*dump_img_)(ImagePrc_pHandle_, "quality"); @@ -4715,7 +4741,7 @@ void hg_scanner::image_process(std::shared_ptr& buffer, uint32_t id (this->*dump_img_)(ImagePrc_pHandle_, "final"); while (hg_imgproc::get_final_data(ImagePrc_pHandle_, &ih, &buf, index++) == SCANNER_ERR_OK) { - VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "Final picture %d (%d * %d * %d) with %u bytes!\n", index + utils::to_log(LOG_LEVEL_DEBUG, "Final picture %d (%d * %d * %d) with %u bytes!\n", index , ih.width, ih.height, ih.bits * ih.channels, ih.total_bytes); if (!img_type_.empty()) @@ -4731,7 +4757,7 @@ void hg_scanner::image_process(std::shared_ptr& buffer, uint32_t id buf = bmpdata.data(); ih.total_bytes = bmpdata.size(); - 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 + utils::to_log(LOG_LEVEL_DEBUG, "Set img type is:%s Final picture %d (%d * %d * %d) with %u bytes!\n", img_type_.c_str(), index , ih.width, ih.height, ih.bits * ih.channels, ih.total_bytes); } if (id == -1) @@ -4822,7 +4848,7 @@ int hg_scanner::image_configuration(SCANCONF& ic) //子类处理 //if (test_1_paper_) //{ - // LOG_INFO(LOG_LEVEL_DEBUG_INFO, "scanning mode: testing ONE paper ...\n"); + // LOG_INFO(LOG_LEVEL_DEBUG, "scanning mode: testing ONE paper ...\n"); // ic.scannum = ic.is_duplex ? 2 : 1; //} //else @@ -4966,62 +4992,62 @@ int hg_scanner::image_configuration(SCANCONF& ic) ic.cropRect.enable = false; } img_conf_ = ic; - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.pixtype=%d\r\n", ic.pixtype); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.papertype=%d\r\n", ic.papertype); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.AutoCrop_threshold=%d\r\n", ic.AutoCrop_threshold); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.autodescrew=%d\r\n", ic.autodescrew); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.automaticcolor=%d\r\n", ic.automaticcolor); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.brightness=%f\r\n", ic.brightness); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.contrast=%f\r\n", ic.contrast); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.en_fold=%d\r\n", ic.en_fold); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.en_sizecheck=%d\r\n", ic.en_sizecheck); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.enhance_color=%d\r\n", ic.enhance_color); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.fillbackground=%d\r\n", ic.fillbackground); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.filter=%d\r\n", ic.filter); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.gamma=%f\r\n", ic.gamma); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.hardwarecaps.capturepixtype=%d\r\n", ic.hardwarecaps.capturepixtype); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.hardwarecaps.en_doublefeed=%d\r\n", ic.hardwarecaps.en_doublefeed); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.hsvcorrect=%d", ic.hsvcorrect); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.imageRotateDegree=%f\r\n", ic.imageRotateDegree); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.indent=%d\r\n", 5); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.is_autocontrast=%d\r\n", ic.is_autocontrast); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.is_autocrop=%d\r\n", ic.is_autocrop); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.is_autodiscradblank_normal=%d\r\n", ic.is_autodiscradblank_normal); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.is_autodiscradblank_vince=%d\r\n", ic.is_autodiscradblank_vince); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.isfillcolor=%d\r\n", ic.isfillcolor); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.is_autotext=%d\r\n", ic.is_autotext); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.is_backrotate180=%d\r\n", ic.is_backrotate180); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.is_convex=%d\r\n", ic.is_convex); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.is_duplex=%d\r\n", ic.is_duplex); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.is_switchfrontback=%d\r\n", ic.is_switchfrontback); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.is_dogeardetection=%d\r\n", ic.is_dogeardetection); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.fillhole.multi_output_red=%d\r\n", ic.multi_output_red); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.noise=%d\r\n", ic.noise); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.pixtype=%d\r\n", ic.pixtype); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.resolution_dst=%f\r\n", ic.resolution_dst); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.resolution_native=%f\r\n", ic.resolution_native); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.scannum=%d\r\n", ic.scannum); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.sharpen=%d\r\n", ic.sharpen); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.discardblank_percent=%d\r\n", ic.discardblank_percent); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.detachnoise.is_detachnoise=%d\r\n", ic.detachnoise.is_detachnoise); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.detachnoise.detachnoise=%d\r\n", ic.detachnoise.detachnoise); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.detachnoise.refuseInflow=%d\r\n", ic.refuseInflow); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.detachnoise.refuseInflow=%d\r\n", ic.refuseInflow); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.removeMorr=%d\r\n", ic.removeMorr); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.errorExtention=%d\r\n", ic.errorExtention); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.textureRemove=%d\r\n", ic.refuseInflow); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.fillhole.is_fillhole=%d\r\n", ic.fillhole.is_fillhole); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.ic.fillhole.fillholeratio=%d\r\n ", ic.fillhole.fillholeratio); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.fadeback=%d\r\n", ic.fadeback); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.cropRect.enable=%d\r\n", ic.cropRect.enable); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.cropRect.width=%d\r\n", ic.cropRect.width); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.cropRect.height=%d\r\n", ic.cropRect.height); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.cropRect.x=%d\r\n", ic.cropRect.x); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.cropRect.y=%d\r\n", ic.cropRect.y); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.dogeardistabce=%d\r\n", ic.dogeardistabce); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.fold_concatmode=%d\r\n", ic.fold_concatmode); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.HsvFilterType=%d\r\n", ic.HsvFilterType); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.is_colorcast =%d\r\n", ic.is_colorcast); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "ic.isuoloadexceptionimage=%d\r\n", ic.isuoloadexceptionimage); + utils::to_log(LOG_LEVEL_DEBUG, "ic.pixtype=%d\r\n", ic.pixtype); + utils::to_log(LOG_LEVEL_DEBUG, "ic.papertype=%d\r\n", ic.papertype); + utils::to_log(LOG_LEVEL_DEBUG, "ic.AutoCrop_threshold=%d\r\n", ic.AutoCrop_threshold); + utils::to_log(LOG_LEVEL_DEBUG, "ic.autodescrew=%d\r\n", ic.autodescrew); + utils::to_log(LOG_LEVEL_DEBUG, "ic.automaticcolor=%d\r\n", ic.automaticcolor); + utils::to_log(LOG_LEVEL_DEBUG, "ic.brightness=%f\r\n", ic.brightness); + utils::to_log(LOG_LEVEL_DEBUG, "ic.contrast=%f\r\n", ic.contrast); + utils::to_log(LOG_LEVEL_DEBUG, "ic.en_fold=%d\r\n", ic.en_fold); + utils::to_log(LOG_LEVEL_DEBUG, "ic.en_sizecheck=%d\r\n", ic.en_sizecheck); + utils::to_log(LOG_LEVEL_DEBUG, "ic.enhance_color=%d\r\n", ic.enhance_color); + utils::to_log(LOG_LEVEL_DEBUG, "ic.fillbackground=%d\r\n", ic.fillbackground); + utils::to_log(LOG_LEVEL_DEBUG, "ic.filter=%d\r\n", ic.filter); + utils::to_log(LOG_LEVEL_DEBUG, "ic.gamma=%f\r\n", ic.gamma); + utils::to_log(LOG_LEVEL_DEBUG, "ic.hardwarecaps.capturepixtype=%d\r\n", ic.hardwarecaps.capturepixtype); + utils::to_log(LOG_LEVEL_DEBUG, "ic.hardwarecaps.en_doublefeed=%d\r\n", ic.hardwarecaps.en_doublefeed); + utils::to_log(LOG_LEVEL_DEBUG, "ic.hsvcorrect=%d", ic.hsvcorrect); + utils::to_log(LOG_LEVEL_DEBUG, "ic.imageRotateDegree=%f\r\n", ic.imageRotateDegree); + utils::to_log(LOG_LEVEL_DEBUG, "ic.indent=%d\r\n", 5); + utils::to_log(LOG_LEVEL_DEBUG, "ic.is_autocontrast=%d\r\n", ic.is_autocontrast); + utils::to_log(LOG_LEVEL_DEBUG, "ic.is_autocrop=%d\r\n", ic.is_autocrop); + utils::to_log(LOG_LEVEL_DEBUG, "ic.is_autodiscradblank_normal=%d\r\n", ic.is_autodiscradblank_normal); + utils::to_log(LOG_LEVEL_DEBUG, "ic.is_autodiscradblank_vince=%d\r\n", ic.is_autodiscradblank_vince); + utils::to_log(LOG_LEVEL_DEBUG, "ic.isfillcolor=%d\r\n", ic.isfillcolor); + utils::to_log(LOG_LEVEL_DEBUG, "ic.is_autotext=%d\r\n", ic.is_autotext); + utils::to_log(LOG_LEVEL_DEBUG, "ic.is_backrotate180=%d\r\n", ic.is_backrotate180); + utils::to_log(LOG_LEVEL_DEBUG, "ic.is_convex=%d\r\n", ic.is_convex); + utils::to_log(LOG_LEVEL_DEBUG, "ic.is_duplex=%d\r\n", ic.is_duplex); + utils::to_log(LOG_LEVEL_DEBUG, "ic.is_switchfrontback=%d\r\n", ic.is_switchfrontback); + utils::to_log(LOG_LEVEL_DEBUG, "ic.is_dogeardetection=%d\r\n", ic.is_dogeardetection); + utils::to_log(LOG_LEVEL_DEBUG, "ic.fillhole.multi_output_red=%d\r\n", ic.multi_output_red); + utils::to_log(LOG_LEVEL_DEBUG, "ic.noise=%d\r\n", ic.noise); + utils::to_log(LOG_LEVEL_DEBUG, "ic.pixtype=%d\r\n", ic.pixtype); + utils::to_log(LOG_LEVEL_DEBUG, "ic.resolution_dst=%f\r\n", ic.resolution_dst); + utils::to_log(LOG_LEVEL_DEBUG, "ic.resolution_native=%f\r\n", ic.resolution_native); + utils::to_log(LOG_LEVEL_DEBUG, "ic.scannum=%d\r\n", ic.scannum); + utils::to_log(LOG_LEVEL_DEBUG, "ic.sharpen=%d\r\n", ic.sharpen); + utils::to_log(LOG_LEVEL_DEBUG, "ic.discardblank_percent=%d\r\n", ic.discardblank_percent); + utils::to_log(LOG_LEVEL_DEBUG, "ic.detachnoise.is_detachnoise=%d\r\n", ic.detachnoise.is_detachnoise); + utils::to_log(LOG_LEVEL_DEBUG, "ic.detachnoise.detachnoise=%d\r\n", ic.detachnoise.detachnoise); + utils::to_log(LOG_LEVEL_DEBUG, "ic.detachnoise.refuseInflow=%d\r\n", ic.refuseInflow); + utils::to_log(LOG_LEVEL_DEBUG, "ic.detachnoise.refuseInflow=%d\r\n", ic.refuseInflow); + utils::to_log(LOG_LEVEL_DEBUG, "ic.removeMorr=%d\r\n", ic.removeMorr); + utils::to_log(LOG_LEVEL_DEBUG, "ic.errorExtention=%d\r\n", ic.errorExtention); + utils::to_log(LOG_LEVEL_DEBUG, "ic.textureRemove=%d\r\n", ic.refuseInflow); + utils::to_log(LOG_LEVEL_DEBUG, "ic.fillhole.is_fillhole=%d\r\n", ic.fillhole.is_fillhole); + utils::to_log(LOG_LEVEL_DEBUG, "ic.ic.fillhole.fillholeratio=%d\r\n ", ic.fillhole.fillholeratio); + utils::to_log(LOG_LEVEL_DEBUG, "ic.fadeback=%d\r\n", ic.fadeback); + utils::to_log(LOG_LEVEL_DEBUG, "ic.cropRect.enable=%d\r\n", ic.cropRect.enable); + utils::to_log(LOG_LEVEL_DEBUG, "ic.cropRect.width=%d\r\n", ic.cropRect.width); + utils::to_log(LOG_LEVEL_DEBUG, "ic.cropRect.height=%d\r\n", ic.cropRect.height); + utils::to_log(LOG_LEVEL_DEBUG, "ic.cropRect.x=%d\r\n", ic.cropRect.x); + utils::to_log(LOG_LEVEL_DEBUG, "ic.cropRect.y=%d\r\n", ic.cropRect.y); + utils::to_log(LOG_LEVEL_DEBUG, "ic.dogeardistabce=%d\r\n", ic.dogeardistabce); + utils::to_log(LOG_LEVEL_DEBUG, "ic.fold_concatmode=%d\r\n", ic.fold_concatmode); + utils::to_log(LOG_LEVEL_DEBUG, "ic.HsvFilterType=%d\r\n", ic.HsvFilterType); + utils::to_log(LOG_LEVEL_DEBUG, "ic.is_colorcast =%d\r\n", ic.is_colorcast); + utils::to_log(LOG_LEVEL_DEBUG, "ic.isuoloadexceptionimage=%d\r\n", ic.isuoloadexceptionimage); return ret; } \ No newline at end of file diff --git a/hgdriver/hgdev/hg_scanner_200.cpp b/hgdriver/hgdev/hg_scanner_200.cpp index 9d0bc0c..9562706 100644 --- a/hgdriver/hgdev/hg_scanner_200.cpp +++ b/hgdriver/hgdev/hg_scanner_200.cpp @@ -1,5 +1,7 @@ #include "hg_scanner_200.h" -#include "../wrapper/hg_log.h" + +#include "../../sdk/hginclude/utils.h" +#include #if defined(WIN32) || defined(_WIN64) #include "scanner_manager.h" @@ -120,7 +122,7 @@ void hg_scanner_200::discard_prev(void) ret = get_scanner_status(usb); } if (imgs || packets) - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "discard prev-scanning %d packets and %d images.\n", packets, imgs); + utils::to_log(LOG_LEVEL_DEBUG, "discard prev-scanning %d packets and %d images.\n", packets, imgs); } int hg_scanner_200::on_scanner_closing(bool force) { @@ -263,7 +265,7 @@ void hg_scanner_200::thread_handle_usb_read(void) } this_thread::sleep_for(chrono::milliseconds(2)); } - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "USB thread exit with code: %s, status = %s\n", hg_scanner_err_name(ret), hg_scanner_err_description(status_)); + utils::to_log(LOG_LEVEL_DEBUG, "USB thread exit with code: %s, status = %s\n", hg_scanner_err_name(ret), hg_scanner_err_description(status_)); } int hg_scanner_200::start(void) { @@ -292,7 +294,7 @@ int hg_scanner_200::start(void) { status_ = ret = SCANNER_ERR_DEVICE_NO_PAPER; //notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER, SANE_EVENT_ERROR, status_); - VLOG_MINI_1(LOG_LEVEL_WARNING, "device start status is(%s)\n", hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER)); + utils::to_log(LOG_LEVEL_WARNING, "device start status is(%s)\n", lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER, nullptr)); return ret; } @@ -302,7 +304,7 @@ int hg_scanner_200::start(void) ret = writeusb(usb); io_->set_timeout(500); } - VLOG_MINI_1(LOG_LEVEL_WARNING, "write start command = %s\n", hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_WARNING, "write start command = %s\n", hg_scanner_err_name(ret)); if(ret == SCANNER_ERR_OK) { @@ -312,7 +314,7 @@ int hg_scanner_200::start(void) } else status_ = ret; - VLOG_MINI_1(LOG_LEVEL_WARNING, "start result: %s\n", hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_WARNING, "start result: %s\n", hg_scanner_err_name(ret)); return ret; } @@ -328,7 +330,7 @@ int hg_scanner_200::stop(void) user_cancel_ = true; if (ret == SCANNER_ERR_DEVICE_BUSY) { - LOG_INFO(LOG_LEVEL_DEBUG_INFO,"stop status is busy\r\n"); + utils::log_info("stop status is busy\r\n", LOG_LEVEL_DEBUG); std::this_thread::sleep_for(std::chrono::milliseconds(2000)); } else if (ret == SCANNER_ERR_OK) @@ -433,7 +435,7 @@ int hg_scanner_200::get_img_data(unsigned int bytes, SANE_Image_Statu statu) void* buf = imagedata->data(index, &size); if (!buf) { - VLOG_MINI_3(LOG_LEVEL_FATAL, "memory(0x%08x + %u) fatal when read USB image %d !!!\n", index, block, usb_img_index_); + utils::to_log(LOG_LEVEL_FATAL, "memory(0x%08x + %u) fatal when read USB image %d !!!\n", index, block, usb_img_index_); ret = SCANNER_ERR_INSUFFICIENT_MEMORY; break; } @@ -483,7 +485,7 @@ int hg_scanner_200::writedown_device_configuration(bool type,setting_hardware::H ret = io_->write_bulk(&usbcb, &len); } - VLOG_MINI_1(LOG_LEVEL_WARNING, "writedown_device_configuration is .(%s)\n", hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_WARNING, "writedown_device_configuration is .(%s)\n", hg_scanner_err_name(ret)); return ret; } @@ -693,7 +695,7 @@ void hg_scanner_200::writedown_image_configuration(void) ic.imageRotateDegree = 0; if (test_1_paper_) { - LOG_INFO(LOG_LEVEL_DEBUG_INFO, "scanning mode: testing ONE paper ...\n"); + utils::log_info("scanning mode: testing ONE paper ...\n", LOG_LEVEL_DEBUG); ic.scannum = 1; } else @@ -716,18 +718,18 @@ void hg_scanner_200::printf_devconfig(setting_hardware::HGSCANCONF_DSP *d) if (!d) d = &dsp_config_; - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\r\ndsp_config.params_dsp.color:%d\r\n",d->params_dsp.color); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config_.params_dsp.double_feed_enbale:%d\r\n",d->params_dsp.double_feed_enbale); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config_.params_dsp.dpi:%d\r\n",d->params_dsp.dpi); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config_.params_dsp.enable_sizecheck:%d\r\n",d->params_dsp.enable_sizecheck); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config_.params_dsp.paper:%d\r\n",d->params_dsp.paper); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config_.params_dsp.pc_correct:%d\r\n",d->params_dsp.pc_correct); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config_.params_dsp.screw_detect_enable:%d\r\n",d->params_dsp.screw_detect_enable); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config_.params_dsp.screw_detect_level:%d\r\n",d->params_dsp.screw_detect_level); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config_.params_dsp.stable_enbale:%d\r\n",d->params_dsp.stable_enbale); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config_.params_dsp.unused_one:%d\r\n",d->params_dsp.unused_one); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config_.params_dsp.unused_two:%d\r\n",d->params_dsp.unused_two); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config_.params_dsp.value:%d\r\n",d->value); + utils::to_log(LOG_LEVEL_DEBUG,"\r\ndsp_config.params_dsp.color:%d\r\n",d->params_dsp.color); + utils::to_log(LOG_LEVEL_DEBUG,"dsp_config_.params_dsp.double_feed_enbale:%d\r\n",d->params_dsp.double_feed_enbale); + utils::to_log(LOG_LEVEL_DEBUG,"dsp_config_.params_dsp.dpi:%d\r\n",d->params_dsp.dpi); + utils::to_log(LOG_LEVEL_DEBUG,"dsp_config_.params_dsp.enable_sizecheck:%d\r\n",d->params_dsp.enable_sizecheck); + utils::to_log(LOG_LEVEL_DEBUG,"dsp_config_.params_dsp.paper:%d\r\n",d->params_dsp.paper); + utils::to_log(LOG_LEVEL_DEBUG,"dsp_config_.params_dsp.pc_correct:%d\r\n",d->params_dsp.pc_correct); + utils::to_log(LOG_LEVEL_DEBUG,"dsp_config_.params_dsp.screw_detect_enable:%d\r\n",d->params_dsp.screw_detect_enable); + utils::to_log(LOG_LEVEL_DEBUG,"dsp_config_.params_dsp.screw_detect_level:%d\r\n",d->params_dsp.screw_detect_level); + utils::to_log(LOG_LEVEL_DEBUG,"dsp_config_.params_dsp.stable_enbale:%d\r\n",d->params_dsp.stable_enbale); + utils::to_log(LOG_LEVEL_DEBUG,"dsp_config_.params_dsp.unused_one:%d\r\n",d->params_dsp.unused_one); + utils::to_log(LOG_LEVEL_DEBUG,"dsp_config_.params_dsp.unused_two:%d\r\n",d->params_dsp.unused_two); + utils::to_log(LOG_LEVEL_DEBUG,"dsp_config_.params_dsp.value:%d\r\n",d->value); } std::string hg_scanner_200::get_firmware_version() { @@ -1001,7 +1003,7 @@ int hg_scanner_200::set_auto_flat(int data) } else status_ = ret; - VLOG_MINI_1(LOG_LEVEL_WARNING, "set_auto_flat ret: %s\n", hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_WARNING, "set_auto_flat ret: %s\n", hg_scanner_err_name(ret)); return ret; } diff --git a/hgdriver/hgdev/hg_scanner_200.h b/hgdriver/hgdev/hg_scanner_200.h index b115ea4..84dabfc 100644 --- a/hgdriver/hgdev/hg_scanner_200.h +++ b/hgdriver/hgdev/hg_scanner_200.h @@ -10,7 +10,6 @@ #include #include "hg_scanner.h" -#include "../wrapper/hg_log.h" //#ifdef OEM_HANWANG //#define hg_scanner_200 hw_scanner_200 diff --git a/hgdriver/hgdev/hg_scanner_239.cpp b/hgdriver/hgdev/hg_scanner_239.cpp index f718bf7..ba41a2c 100644 --- a/hgdriver/hgdev/hg_scanner_239.cpp +++ b/hgdriver/hgdev/hg_scanner_239.cpp @@ -1,5 +1,7 @@ #include "hg_scanner_239.h" -#include "../wrapper/hg_log.h" + +#include "../../sdk/hginclude/utils.h" +#include #include "filetools.h" #if defined(WIN32) || defined(_WIN64) @@ -159,7 +161,7 @@ hg_scanner_239::hg_scanner_239(const char* dev_name, int pid,usb_io* io) : hg_sc { init_version(); //pid_ = pid; - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "hg_scanner_239(%s) constructing ...\n", hg_log::format_ptr(this).c_str()); + utils::to_log(LOG_LEVEL_DEBUG, "hg_scanner_239(%p) constructing ...\n", this); dev_conf_.value = 0; #ifndef MAPPING_FUNCTION_IN_BASE init_setting_map(setting_map_, ARRAY_SIZE(setting_map_)); @@ -181,7 +183,7 @@ hg_scanner_239::hg_scanner_239(const char* dev_name, int pid,usb_io* io) : hg_sc } hg_scanner_239::~hg_scanner_239() { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "hg_scanner_239(%s) destroyed.\n", hg_log::format_ptr(this).c_str()); + utils::to_log(LOG_LEVEL_DEBUG, "hg_scanner_239(%p) destroyed.\n", this); } int hg_scanner_239::read_register(int addr, int* val) { @@ -222,12 +224,12 @@ std::string hg_scanner_239::control_fetch(int addr, int val, int size) ret = io_->read_bulk(&data[0], &l); if (ret || l == 0) { - VLOG_MINI_4(LOG_LEVEL_DEBUG_INFO, "control_fetch(%d, %d) - read_bulk %d byte(s) = %s\n", addr, val, l, hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "control_fetch(%d, %d) - read_bulk %d byte(s) = %s\n", addr, val, l, hg_scanner_err_name(ret)); data.clear(); } } else - VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "control_fetch(%d, %d) = %s\n", addr, val, hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "control_fetch(%d, %d) = %s\n", addr, val, hg_scanner_err_name(ret)); return data; } @@ -255,7 +257,7 @@ int hg_scanner_239::get_scan_mode(bool &type) ret = read_register(setting3399::SR_OS, &val); //val == 1计数模式 type =val == 1 ? false : true; - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "get_scan_mode: %s\n", type ? hg_scanner_err_description(SCANNER_ERR_DEVICE_COUNT_MODE) : hg_scanner_err_description(SCANNER_ERR_OK)); + utils::to_log(LOG_LEVEL_DEBUG, "get_scan_mode: %s\n", type ? hg_scanner_err_description(SCANNER_ERR_DEVICE_COUNT_MODE) : hg_scanner_err_description(SCANNER_ERR_OK)); return ret; } @@ -342,7 +344,7 @@ int hg_scanner_239::set_auto_flat(int data) std::this_thread::sleep_for(std::chrono::milliseconds(300)); ret = try_third_app_after_start(ret); } - VLOG_MINI_1(LOG_LEVEL_WARNING, "set_auto_flat ret: %s\n", hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_WARNING, "set_auto_flat ret: %s\n", hg_scanner_err_name(ret)); return ret; } int hg_scanner_239::get_motor_board_ver(string &ver) @@ -363,7 +365,7 @@ int hg_scanner_239::get_status(void) if (ret) { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "get status error: %s\n", hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "get status error: %s\n", hg_scanner_err_name(ret)); status_ = ret; return -1; @@ -380,7 +382,7 @@ bool hg_scanner_239::is_dev_image_process_done(void) if (ret) { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "is_dev_image_process_done() error: %s\n", hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "is_dev_image_process_done() error: %s\n", hg_scanner_err_name(ret)); status_ = ret; return true; @@ -397,7 +399,7 @@ bool hg_scanner_239::is_dev_image_keep_last_paper(void) if (ret) { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "is_dev_image_keep_last_paper() error: %s\n", hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "is_dev_image_keep_last_paper() error: %s\n", hg_scanner_err_name(ret)); status_ = ret; return true; @@ -412,7 +414,7 @@ int hg_scanner_239::get_image_count(void) int val = 0, ret = read_register(setting3399::SR_IM_COUNT, &val); - //VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Gets The image queue in the 'DEVICE':[%d]\n", val); + //utils::to_log(LOG_LEVEL_DEBUG, "Gets The image queue in the 'DEVICE':[%d]\n", val); if (ret == SCANNER_ERR_OK) return val; @@ -430,7 +432,7 @@ int hg_scanner_239::get_front_data_size(void) return val; else { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "get_front_data_size = %s\n", hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "get_front_data_size = %s\n", hg_scanner_err_name(ret)); return -1; } } @@ -516,18 +518,18 @@ void hg_scanner_239::init_version(void) firmware_sup_color_fill_ = year >= "3C" ? true : false; } - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Firmware_sup_wait_paper_:%s\r\n", firmware_sup_wait_paper_ ? "enable" : "close"); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Firmware_sup_log_export_:%s\r\n", firmware_sup_log_export_ ? "enable" : "close"); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Firmware_sup_pick_strength_:%s\r\n", firmware_sup_pick_strength_ ? "enable" : "close"); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Firmware_sup_color_corr_:%s\r\n", firmware_sup_color_corr_ ? "enable" : "close"); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Firmware_sup_double_img:%s\r\n", firmware_sup_double_img ? "enable" : "close"); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Firmware_sup_devs_lock_:%s\r\n", firmware_sup_devs_lock_ ? "enable" : "close"); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Firmware_sup_dpi_300:%s\r\n", firmware_sup_dpi_300 ? "enable" : "close"); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Firmware_sup_dpi_600:%s\r\n", firmware_sup_dpi_600 ? "enable" : "close"); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Firmware_sup_auto_speed_:%s\r\n", firmware_sup_auto_speed_ ? "enable" : "close"); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Firmware_sup_morr_:%s\r\n", firmware_sup_morr_ ? "enable" : "close"); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Firmware_sup_color_fill_:%s\r\n", firmware_sup_color_fill_ ? "enable" : "close"); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Firmware version: %s\n", fv.c_str()); + utils::to_log(LOG_LEVEL_DEBUG, "Firmware_sup_wait_paper_:%s\r\n", firmware_sup_wait_paper_ ? "enable" : "close"); + utils::to_log(LOG_LEVEL_DEBUG, "Firmware_sup_log_export_:%s\r\n", firmware_sup_log_export_ ? "enable" : "close"); + utils::to_log(LOG_LEVEL_DEBUG, "Firmware_sup_pick_strength_:%s\r\n", firmware_sup_pick_strength_ ? "enable" : "close"); + utils::to_log(LOG_LEVEL_DEBUG, "Firmware_sup_color_corr_:%s\r\n", firmware_sup_color_corr_ ? "enable" : "close"); + utils::to_log(LOG_LEVEL_DEBUG, "Firmware_sup_double_img:%s\r\n", firmware_sup_double_img ? "enable" : "close"); + utils::to_log(LOG_LEVEL_DEBUG, "Firmware_sup_devs_lock_:%s\r\n", firmware_sup_devs_lock_ ? "enable" : "close"); + utils::to_log(LOG_LEVEL_DEBUG, "Firmware_sup_dpi_300:%s\r\n", firmware_sup_dpi_300 ? "enable" : "close"); + utils::to_log(LOG_LEVEL_DEBUG, "Firmware_sup_dpi_600:%s\r\n", firmware_sup_dpi_600 ? "enable" : "close"); + utils::to_log(LOG_LEVEL_DEBUG, "Firmware_sup_auto_speed_:%s\r\n", firmware_sup_auto_speed_ ? "enable" : "close"); + utils::to_log(LOG_LEVEL_DEBUG, "Firmware_sup_morr_:%s\r\n", firmware_sup_morr_ ? "enable" : "close"); + utils::to_log(LOG_LEVEL_DEBUG, "Firmware_sup_color_fill_:%s\r\n", firmware_sup_color_fill_ ? "enable" : "close"); + utils::to_log(LOG_LEVEL_DEBUG, "Firmware version: %s\n", fv.c_str()); //is_kernelsnap_239_220429_ = date >= "B0429" ? true : false; //is_kernelsnap_239_220430_ = date >= "B0430" ? true : false; @@ -598,7 +600,7 @@ int hg_scanner_239::writedown_device_configuration(bool type, setting_hardware: ret = write_register(setting3399::SR_CONFIG_SCAN_PARAM, dev_conf->value); - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "Writedown scanner configuration(0x%x) = %s\n", dev_conf->value, hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "Writedown scanner configuration(0x%x) = %s\n", dev_conf->value, hg_scanner_err_name(ret)); return ret; } int hg_scanner_239::writedown_image_configuration(void) @@ -625,7 +627,7 @@ int hg_scanner_239::writedown_image_configuration(void) ic.hardwarecaps.skrewdetectlevel = dev_conf_.params_3399.screw_detect_level; if (test_1_paper_) { - LOG_INFO(LOG_LEVEL_DEBUG_INFO, "scanning mode: testing ONE paper ...\n"); + utils::log_info("scanning mode: testing ONE paper ...\n", LOG_LEVEL_DEBUG); ic.scannum = ic.is_duplex ? 2 : 1; } else @@ -656,7 +658,7 @@ int hg_scanner_239::pop_first_image(void) int ret = write_register(setting3399::SR_IM_POP, 1); if (ret) { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "popup first image = %s\n", hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "popup first image = %s\n", hg_scanner_err_name(ret)); } return ret; } @@ -701,7 +703,7 @@ int hg_scanner_239::read_one_image_from_usb(SANE_Image_Statu statu) int block = 0; if (!buff) { - VLOG_MINI_3(LOG_LEVEL_FATAL, "memory(0x%08x + %u) fatal when read USB image %d !!!\n", off, r, usb_img_index_); + utils::to_log(LOG_LEVEL_FATAL, "memory(0x%08x + %u) fatal when read USB image %d !!!\n", off, r, usb_img_index_); ret = SCANNER_ERR_INSUFFICIENT_MEMORY; } else @@ -718,7 +720,7 @@ int hg_scanner_239::read_one_image_from_usb(SANE_Image_Statu statu) void* buff = buf->data(off, &size); if (!buf) { - //VLOG_MINI_3(LOG_LEVEL_FATAL, "memory(0x%08x + %u) fatal when read USB image %d !!!\n", index, block, usb_img_index_); + //utils::to_log(LOG_LEVEL_FATAL, "memory(0x%08x + %u) fatal when read USB image %d !!!\n", index, block, usb_img_index_); ret = SCANNER_ERR_INSUFFICIENT_MEMORY; break; } @@ -727,7 +729,7 @@ int hg_scanner_239::read_one_image_from_usb(SANE_Image_Statu statu) if (ret != SCANNER_ERR_OK) { - VLOG_MINI_3(LOG_LEVEL_FATAL, "read_one_image_from_usb read_data:%s!!! read data[%d/:%d]\n", hg_scanner_err_name(ret),size, block); + utils::to_log(LOG_LEVEL_FATAL, "read_one_image_from_usb read_data:%s!!! read data[%d/:%d]\n", hg_scanner_err_name(ret),size, block); break; } @@ -738,7 +740,7 @@ int hg_scanner_239::read_one_image_from_usb(SANE_Image_Statu statu) } if (r > 0) { - VLOG_MINI_2(LOG_LEVEL_FATAL, "read_one_image_from_usb 'total' is %d, 'left' total len is:%d!!!\n", total, r); + utils::to_log(LOG_LEVEL_FATAL, "read_one_image_from_usb 'total' is %d, 'left' total len is:%d!!!\n", total, r); } if (ret == SCANNER_ERR_OK) @@ -751,7 +753,7 @@ int hg_scanner_239::read_one_image_from_usb(SANE_Image_Statu statu) } else { - VLOG_MINI_1(LOG_LEVEL_FATAL, "Read image data from USB err: %s\n", hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_FATAL, "Read image data from USB err: %s\n", hg_scanner_err_name(ret)); } } } @@ -804,7 +806,7 @@ int hg_scanner_239::discard_all_images(void) //} if (pre_int) - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "prev-connection has left %d interrupt packet(s) && %d image(s).\n", pre_int, pre_img); + utils::to_log(LOG_LEVEL_DEBUG, "prev-connection has left %d interrupt packet(s) && %d image(s).\n", pre_int, pre_img); return 0; } int hg_scanner_239::get_roller_life(void) @@ -1106,8 +1108,8 @@ void hg_scanner_239::thread_correction(void) if (sw.elapsed_s() > 10) { status_ = SCANNER_ERR_DEVICE_AUTO_FAIL_OVER; - //notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_FAIL_OUTTIME), SANE_EVENT_ERROR, ret); // 通信超时 - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "设备校正超时 '%s'\n", hg_scanner_err_name(status_)); + //notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_FAIL_OUTTIME), SANE_EVENT_ERROR, ret); // 通信超时 + utils::to_log(LOG_LEVEL_DEBUG, "设备校正超时 '%s'\n", hg_scanner_err_name(status_)); break; } std::this_thread::sleep_for(std::chrono::milliseconds(500)); @@ -1171,7 +1173,7 @@ void hg_scanner_239::thread_get_dves_image(void) { status_ = ret; notify_ui_working_status(from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_GET_IMAGE_OUTTIME), SANE_EVENT_ERROR, ret); // 取图通信超时 - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "get image time out:%s\n", hg_scanner_err_name(status_)); + utils::to_log(LOG_LEVEL_DEBUG, "get image time out:%s\n", hg_scanner_err_name(status_)); break; } @@ -1179,7 +1181,7 @@ void hg_scanner_239::thread_get_dves_image(void) { stop(); notify_ui_working_status(from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_EXIT_WAIT_SCAN), SANE_EVENT_ERROR, status_); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "auto paper scan exit :%s\n", from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_EXIT_WAIT_SCAN)); + utils::to_log(LOG_LEVEL_DEBUG, "auto paper scan exit :%s\n", from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_EXIT_WAIT_SCAN)); } if ((get_status() & 0x03) == 0) @@ -1193,7 +1195,7 @@ void hg_scanner_239::thread_get_dves_image(void) size = sizeof(buf); memset(buf, 0, size); info->From = setting3399::STOPSCAN; - LOG_INFO(LOG_LEVEL_DEBUG_INFO, "User cancelled (checked when read INT timeout), we faked a 'STOP' messag to enter exiting process ...\n"); + utils::log_info("User cancelled (checked when read INT timeout), we faked a 'STOP' messag to enter exiting process ...\n", LOG_LEVEL_DEBUG); } else continue; @@ -1211,7 +1213,7 @@ void hg_scanner_239::thread_get_dves_image(void) status_ = settings::device_status_to_hg_err(info); if (status_) { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "status from interrupt point is '%s'\n", hg_scanner_err_description(status_)); + utils::to_log(LOG_LEVEL_DEBUG, "status from interrupt point is '%s'\n", hg_scanner_err_description(status_)); } if (status_ != SCANNER_ERR_OK && status_ != SCANNER_ERR_TIMEOUT @@ -1280,7 +1282,7 @@ void hg_scanner_239::thread_get_dves_image(void) } } //else - // VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "status(0x%x) is not accept in usb thread\n", status); + // utils::to_log(LOG_LEVEL_DEBUG, "status(0x%x) is not accept in usb thread\n", status); } else if (info->From == setting3399::STOPSCAN)//固件版本:3B0326获取无纸时，下面中断信息会先发无纸在停止扫描,然后在发无纸 { //此时int端点还要信息没有读取完，而且退出点击继续扫描，下面设备还未结束扫描 @@ -1288,7 +1290,7 @@ void hg_scanner_239::thread_get_dves_image(void) { status_ = svdevs_err_.front(); } - LOG_INFO(LOG_LEVEL_DEBUG_INFO, "received 'STOPSCAN' message in usb thread, check remaining image and finish scanning ...\n"); + utils::log_info("received 'STOPSCAN' message in usb thread, check remaining image and finish scanning ...\n", LOG_LEVEL_DEBUG); // fetch all buffered images and exit ... //while(!is_dev_image_process_done()) @@ -1313,7 +1315,7 @@ void hg_scanner_239::thread_get_dves_image(void) else status_ = ret = SCANNER_ERR_USER_CANCELED; - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "%s\n", hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_GET_USER_CANCEL_SCAN)); + utils::to_log(LOG_LEVEL_DEBUG, "%s\n", lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_GET_USER_CANCEL_SCAN, nullptr)); auoto_paper_indx = 0; break; } @@ -1321,7 +1323,7 @@ void hg_scanner_239::thread_get_dves_image(void) { //std::lock_guard lock(io_lock_); - //LOG_INFO(LOG_LEVEL_DEBUG_INFO, "First message received from USB is 'STOPSCAN'\n"); + //utils::log_info(LOG_LEVEL_DEBUG, "First message received from USB is 'STOPSCAN'\n"); // notify_ui_working_status(STATU_DESC_DEVICE_RESET); // reset_ = true; // ret = io_->reset(); @@ -1334,9 +1336,9 @@ void hg_scanner_239::thread_get_dves_image(void) if (count == 0 || (s & 3) == 0) { - LOG_INFO(LOG_LEVEL_DEBUG_INFO, "Really stopped ^_^\n"); + utils::log_info("Really stopped ^_^\n", LOG_LEVEL_DEBUG); - string str = hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_ROUND_SACN_OVER); + string str = lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_ROUND_SACN_OVER, nullptr); str += ":" + to_string(++auoto_paper_indx); if (!user_cancel_ && is_auto_paper_scan && svdevs_err_.empty()) @@ -1347,7 +1349,7 @@ void hg_scanner_239::thread_get_dves_image(void) } else if (info->From == setting3399::V4L2) { - VLOG_MINI_2(LOG_LEVEL_WARNING, "V4L2 message received, code = %d, index = %d\n", info->Code, info->Img_Index); + utils::to_log(LOG_LEVEL_WARNING, "V4L2 message received, code = %d, index = %d\n", info->Code, info->Img_Index); // stop(); break; } @@ -1367,14 +1369,14 @@ void hg_scanner_239::thread_get_dves_image(void) else { // error handling ... - 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_description(status_)); + utils::to_log(LOG_LEVEL_DEBUG, "Read HGEIntInfo: From = %d, Code = %d, Img_Index = %d, status = %s\n", info->From, info->Code, info->Img_Index, hg_scanner_err_description(status_)); } } this_thread::sleep_for(chrono::milliseconds(10)); } // stop 通过int端点返回 如果不反回则是固件问题，软件不做处理 - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "USB thread exit with code: %s, status = %s\n", hg_scanner_err_name(ret), hg_scanner_err_description(status_)); + utils::to_log(LOG_LEVEL_DEBUG, "USB thread exit with code: %s, status = %s\n", hg_scanner_err_name(ret), hg_scanner_err_description(status_)); } void hg_scanner_239::thread_handle_usb_read(void) { @@ -1399,7 +1401,7 @@ int hg_scanner_239::start(void) split3399_ = 0; cb_mem_ = true; - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "scanner status: 0x%x\n", get_status()); + utils::to_log(LOG_LEVEL_DEBUG, "scanner status: 0x%x\n", get_status()); reset(); @@ -1408,7 +1410,7 @@ int hg_scanner_239::start(void) if (!val && ret == SCANNER_ERR_OK) { status_ = SCANNER_ERR_DEVICE_SLEEPING; - VLOG_MINI_1(LOG_LEVEL_WARNING, "device start status is(%s)\n", hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING)); + utils::to_log(LOG_LEVEL_WARNING, "device start status is(%s)\n", lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING, nullptr)); set_notify_sleep(); @@ -1437,12 +1439,12 @@ int hg_scanner_239::start(void) if (ret) { - 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)); + utils::to_log(LOG_LEVEL_WARNING, "Write down image process parameters fail is(%s), the result will be unpredictable.\n", hg_scanner_err_name(ret)); } if (ret != SCANNER_ERR_OK) { - VLOG_MINI_1(LOG_LEVEL_WARNING, "start status01 is(%s), the result will be unpredictable.\n", hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_WARNING, "start status01 is(%s), the result will be unpredictable.\n", hg_scanner_err_name(ret)); return ret; } @@ -1466,9 +1468,9 @@ int hg_scanner_239::start(void) else { status_ = ret; - 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)); + utils::to_log(LOG_LEVEL_WARNING, "(Thread 0x%x)Send start command = %s\n", GetCurrentProcessId(), hg_scanner_err_name(ret)); } - VLOG_MINI_1(LOG_LEVEL_WARNING, "----------Main start scan status : %s----------\n", hg_scanner_err_description(ret)); + utils::to_log(LOG_LEVEL_WARNING, "----------Main start scan status : %s----------\n", hg_scanner_err_description(ret)); return ret; } @@ -1675,7 +1677,7 @@ int hg_scanner_239::get_sleep_time(int& data) data = val; } - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "get_sleep_time = %d with %s\n", data,hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "get_sleep_time = %d with %s\n", data,hg_scanner_err_name(ret)); return ret; } int hg_scanner_239::set_sleep_time(int setsleepime) @@ -1684,7 +1686,7 @@ int hg_scanner_239::set_sleep_time(int setsleepime) int ret = write_register(setting3399::SR_SET_SLEEPTIME, setsleepime); - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "set sleep time to %d = %s\n", setsleepime, hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "set sleep time to %d = %s\n", setsleepime, hg_scanner_err_name(ret)); return ret; } @@ -1700,7 +1702,7 @@ int hg_scanner_239::get_scanner_paperon(SANE_Bool& type) { type = val == 0 ? false : true; } - VLOG_MINI_1(LOG_LEVEL_WARNING, "get_scanner_paperon is(%s)\n", !type ? hg_scanner_err_description(SCANNER_ERR_DEVICE_NO_PAPER) : hg_scanner_err_description(SCANNER_ERR_OK)); + utils::to_log(LOG_LEVEL_WARNING, "get_scanner_paperon is(%s)\n", !type ? hg_scanner_err_description(SCANNER_ERR_DEVICE_NO_PAPER) : hg_scanner_err_description(SCANNER_ERR_OK)); return ret; } @@ -1715,7 +1717,7 @@ int hg_scanner_239::get_scan_is_sleep(SANE_Bool& type) { type = val == 1 ? true : false; } - VLOG_MINI_1(LOG_LEVEL_WARNING, "get_scanner_paperon is(%s)\n", !type ? hg_scanner_err_description(SCANNER_ERR_DEVICE_SLEEPING) : hg_scanner_err_description(SCANNER_ERR_OK)); + utils::to_log(LOG_LEVEL_WARNING, "get_scanner_paperon is(%s)\n", !type ? hg_scanner_err_description(SCANNER_ERR_DEVICE_SLEEPING) : hg_scanner_err_description(SCANNER_ERR_OK)); return ret; } @@ -1745,7 +1747,7 @@ int hg_scanner_239::get_device_log(string &logpath) } std::lock_guard lock(io_lock_); - string save_path = hg_log::temporary_path() + PATH_SEPARATOR + "device.log"; + string save_path = utils::temporary_path() + PATH_SEPARATOR + "device.log"; string device_log_path = "/var/log/syslog"; string str ; @@ -1801,7 +1803,7 @@ int hg_scanner_239::get_device_log(string &logpath) f << str << endl; f.close(); logpath = save_path; - VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "log path:%s ret:%s buffersize: %d\n", logpath.c_str(),hg_scanner_err_name(ret),buffersize); + utils::to_log(LOG_LEVEL_DEBUG, "log path:%s ret:%s buffersize: %d\n", logpath.c_str(),hg_scanner_err_name(ret),buffersize); return ret; } int hg_scanner_239::set_devreboot(int data) @@ -1826,19 +1828,19 @@ int hg_scanner_239::set_scan_islock(SANE_Bool set_islock) if (!firmware_sup_devs_lock_) { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "devs lock:%s \n", hg_scanner_err_description(SCANNER_ERR_DEVICE_NOT_SUPPORT)); + utils::to_log(LOG_LEVEL_DEBUG, "devs lock:%s \n", hg_scanner_err_description(SCANNER_ERR_DEVICE_NOT_SUPPORT)); return SCANNER_ERR_DEVICE_NOT_SUPPORT; } if (set_islock != 0 && set_islock != 1) { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "devs lock:%s \n", hg_scanner_err_description(SCANNER_ERR_INVALID_PARAMETER)); + utils::to_log(LOG_LEVEL_DEBUG, "devs lock:%s \n", hg_scanner_err_description(SCANNER_ERR_INVALID_PARAMETER)); return SCANNER_ERR_INVALID_PARAMETER; } int val = 0, ret = write_register(setting3399::SR_SET_LOCK_STATES, set_islock); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Set scanner is lock:%d\r\n", set_islock); + utils::to_log(LOG_LEVEL_DEBUG, "Set scanner is lock:%d\r\n", set_islock); return ret; } @@ -1848,7 +1850,7 @@ int hg_scanner_239::get_scan_islock(SANE_Bool& islock) if (!firmware_sup_devs_lock_) { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "devs lock:%s \n", hg_scanner_err_description(SCANNER_ERR_DEVICE_NOT_SUPPORT)); + utils::to_log(LOG_LEVEL_DEBUG, "devs lock:%s \n", hg_scanner_err_description(SCANNER_ERR_DEVICE_NOT_SUPPORT)); return SCANNER_ERR_DEVICE_NOT_SUPPORT; } @@ -1861,14 +1863,14 @@ int hg_scanner_239::get_scan_islock(SANE_Bool& islock) islock = val; ret = islock ? SCANNER_ERR_DEVICE_ISLOCK : SCANNER_ERR_OK; - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Get scanner is lock:%d\r\n", ret); + utils::to_log(LOG_LEVEL_DEBUG, "Get scanner is lock:%d\r\n", ret); return ret; } int hg_scanner_239::set_scan_lock_check_val(string check_str) { if (!firmware_sup_devs_lock_) { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "devs lock:%s \n", hg_scanner_err_description(SCANNER_ERR_DEVICE_NOT_SUPPORT)); + utils::to_log(LOG_LEVEL_DEBUG, "devs lock:%s \n", hg_scanner_err_description(SCANNER_ERR_DEVICE_NOT_SUPPORT)); return SCANNER_ERR_DEVICE_NOT_SUPPORT; } @@ -2022,7 +2024,7 @@ int hg_scanner_239::get_dev_islock_file(int& islockfile) if (!firmware_sup_devs_lock_) { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "devs lock:%s \n", hg_scanner_err_description(SCANNER_ERR_DEVICE_NOT_SUPPORT)); + utils::to_log(LOG_LEVEL_DEBUG, "devs lock:%s \n", hg_scanner_err_description(SCANNER_ERR_DEVICE_NOT_SUPPORT)); return SCANNER_ERR_DEVICE_NOT_SUPPORT; } @@ -2054,7 +2056,7 @@ int hg_scanner_239::get_dev_islock_file(int& islockfile) else islockfile = -1; - VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "get list file is:%s ret:%s buffersize: %d\n", device_log_path.c_str(), hg_scanner_err_description(ret), buffersize); + utils::to_log(LOG_LEVEL_DEBUG, "get list file is:%s ret:%s buffersize: %d\n", device_log_path.c_str(), hg_scanner_err_description(ret), buffersize); return ret; } int hg_scanner_239::set_dev_islock_file(int islockfile) @@ -2063,7 +2065,7 @@ int hg_scanner_239::set_dev_islock_file(int islockfile) if (!firmware_sup_devs_lock_) { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "devs lock:%s \n", hg_scanner_err_description(SCANNER_ERR_DEVICE_NOT_SUPPORT)); + utils::to_log(LOG_LEVEL_DEBUG, "devs lock:%s \n", hg_scanner_err_description(SCANNER_ERR_DEVICE_NOT_SUPPORT)); return SCANNER_ERR_DEVICE_NOT_SUPPORT; } if (islockfile != 0 && islockfile != 1) @@ -2095,7 +2097,7 @@ int hg_scanner_239::set_dev_islock_file(int islockfile) if (ret != SCANNER_ERR_OK) return ret; - //VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "log path:%s ret:%s buffersize: %d\n", logpath.c_str(), hg_scanner_err_name(ret), buffersize); + //utils::to_log(LOG_LEVEL_DEBUG, "log path:%s ret:%s buffersize: %d\n", logpath.c_str(), hg_scanner_err_name(ret), buffersize); //return ret; return SCANNER_ERR_OK; } diff --git a/hgdriver/hgdev/hg_scanner_300.cpp b/hgdriver/hgdev/hg_scanner_300.cpp index 3d1767a..86ddcca 100644 --- a/hgdriver/hgdev/hg_scanner_300.cpp +++ b/hgdriver/hgdev/hg_scanner_300.cpp @@ -1,5 +1,7 @@ #include "hg_scanner_300.h" -#include "../wrapper/hg_log.h" + +#include "../../sdk/hginclude/utils.h" +#include #if defined(WIN32) || defined(_WIN64) #include "scanner_manager.h" @@ -117,7 +119,7 @@ void hg_scanner_300::thread_handle_usb_read(void) ret = get_scanner_status(usb); if (ret && ret != SCANNER_ERR_NO_DATA) { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "status from bulk point is '%s'\n", hg_scanner_err_description(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "status from bulk point is '%s'\n", hg_scanner_err_description(ret)); } //printf("usb.u32_Data = %d ret = %d\r\n",usb.u32_Data,ret); @@ -133,9 +135,9 @@ void hg_scanner_300::thread_handle_usb_read(void) ret = status_; else status_ = ret = SCANNER_ERR_USER_CANCELED; - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "%s\n", hg_scanner_err_description(status_)); + utils::to_log(LOG_LEVEL_DEBUG, "%s\n", hg_scanner_err_description(status_)); } - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "'STOPSCAN' message in usb thread:%s\n" , hg_scanner_err_description(status_)); + utils::to_log(LOG_LEVEL_DEBUG, "'STOPSCAN' message in usb thread:%s\n" , hg_scanner_err_description(status_)); break; } @@ -199,14 +201,14 @@ void hg_scanner_300::thread_handle_usb_read(void) else if (ret == SCANNER_ERR_IO) { status_ = ret; - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "%s\n", hg_scanner_err_description(status_)); + utils::to_log(LOG_LEVEL_DEBUG, "%s\n", hg_scanner_err_description(status_)); break; } if (sw.elapsed_ms() > 30000 && img_conf_.resolution_dst != 600)//防止状态信息一直取不上来导致卡死 { if ((img_conf_.papertype == TwSS::MaxSize || img_conf_.papertype == TwSS::USStatement) && pid_ == 0x0300 && firmware_sup_dpi_600) { - hg_log::log(LOG_LEVEL_WARNING, "while 30S\n"); + utils::log_info("while 30S\n", LOG_LEVEL_WARNING); } else { @@ -215,8 +217,8 @@ void hg_scanner_300::thread_handle_usb_read(void) status_ = savestatus_[0]; } savestatus_.clear(); - hg_log::log(LOG_LEVEL_WARNING, "Get Status TimeOut,get image out 30S\n"); - notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_GET_IMAGE_OUTTIME), SANE_EVENT_ERROR, status_); // 取图通信超时 + utils::log_info("Get Status TimeOut,get image out 30S\n", LOG_LEVEL_WARNING); + notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_GET_IMAGE_OUTTIME, nullptr), SANE_EVENT_ERROR, status_); // 取图通信超时 break; } } @@ -227,14 +229,14 @@ void hg_scanner_300::thread_handle_usb_read(void) status_ = savestatus_[0]; } savestatus_.clear(); - hg_log::log(LOG_LEVEL_WARNING, "MaxSize TimeOut,Get Image 130s\n"); - notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_GET_IMAGE_OUTTIME), SANE_EVENT_ERROR, status_); // 取图通信超时 + utils::log_info("MaxSize TimeOut,Get Image 130s\n", LOG_LEVEL_WARNING); + notify_ui_working_status(lang_load_string(ID_STATU_DESC_SCANNER_ERR_DEVICE_GET_IMAGE_OUTTIME, nullptr), SANE_EVENT_ERROR, status_); // 取图通信超时 break; } if (ret == SCANNER_ERR_OK && usb.u32_Count > 0) { int totalNum = usb.u32_Count & 0x3fffffff; // 2022-08-04: 兼容Android，默认图片大小均在1GB以内 - VLOG_MINI_2(LOG_LEVEL_WARNING, "Get Scaner Image Size:%d bytes,Image Num[%d]\n", totalNum,img_num); + utils::to_log(LOG_LEVEL_WARNING, "Get Scaner Image Size:%d bytes,Image Num[%d]\n", totalNum,img_num); img_num++; if (totalNum) { @@ -269,7 +271,7 @@ void hg_scanner_300::thread_handle_usb_read(void) } this_thread::sleep_for(chrono::milliseconds(10)); } - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "USB thread exit with code: %s, status = %s\n", hg_scanner_err_name(ret), hg_scanner_err_description(status_)); + utils::to_log(LOG_LEVEL_DEBUG, "USB thread exit with code: %s, status = %s\n", hg_scanner_err_name(ret), hg_scanner_err_description(status_)); } int hg_scanner_300::discard_all_images(void) { @@ -322,7 +324,7 @@ int hg_scanner_300::start(void) //if (is_read_int) //{ - // VLOG_MINI_1(LOG_LEVEL_WARNING, "device status is(%s)\n", STATU_DESC_SCANNER_ERR_DEVICE_DEVS_BOOTING); + // utils::to_log(LOG_LEVEL_WARNING, "device status is(%s)\n", STATU_DESC_SCANNER_ERR_DEVICE_DEVS_BOOTING); // return SCANNER_ERR_DEVICE_DEVS_BOOTING; //} ret = get_scan_is_sleep(val); @@ -375,7 +377,7 @@ int hg_scanner_300::start(void) } else status_ = ret; - VLOG_MINI_1(LOG_LEVEL_WARNING, "----------Main start scan status : %s----------\n", hg_scanner_err_description(ret)); + utils::to_log(LOG_LEVEL_WARNING, "----------Main start scan status : %s----------\n", hg_scanner_err_description(ret)); return ret; } int hg_scanner_300::stop(void) @@ -390,7 +392,7 @@ int hg_scanner_300::stop(void) if (status_ == SCANNER_ERR_DEVICE_BUSY) { - LOG_INFO(LOG_LEVEL_DEBUG_INFO,"stop status is busy\r\n"); + utils::log_info("stop status is busy\r\n", LOG_LEVEL_DEBUG); std::this_thread::sleep_for(std::chrono::milliseconds(2000)); } user_cancel_ = true; @@ -450,14 +452,14 @@ int hg_scanner_300::get_scanner_status(USBCB &usb) ret = writeusb(usb); if (ret != SCANNER_ERR_OK) { - VLOG_MINI_1(LOG_LEVEL_WARNING, "get_scanner_status write usb: %s\n", hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_WARNING, "get_scanner_status write usb: %s\n", hg_scanner_err_name(ret)); return ret; } ret = readusb(usb); if (ret != SCANNER_ERR_OK) { - VLOG_MINI_1(LOG_LEVEL_WARNING, "get_scanner_status read usb: %s\n", hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_WARNING, "get_scanner_status read usb: %s\n", hg_scanner_err_name(ret)); status_ = ret; return ret; } @@ -477,11 +479,11 @@ int hg_scanner_300::get_img_data(std::shared_ptr &imagedata) ret = writeusb(usb); if (ret != SCANNER_ERR_OK) { - VLOG_MINI_1(LOG_LEVEL_WARNING, "get_img_data setting3288dsp::GET_IMAGE write usb: %s\n", hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_WARNING, "get_img_data setting3288dsp::GET_IMAGE write usb: %s\n", hg_scanner_err_name(ret)); } else { - VLOG_MINI_1(LOG_LEVEL_FATAL, "get_img_data get data total len is:%d\n", total); + utils::to_log(LOG_LEVEL_FATAL, "get_img_data get data total len is:%d\n", total); while (total > 0) { block = 512 * 1024; @@ -493,7 +495,7 @@ int hg_scanner_300::get_img_data(std::shared_ptr &imagedata) void* buf = imagedata->data(index, &size); if (!buf) { - VLOG_MINI_3(LOG_LEVEL_FATAL, "memory(0x%08x + %u) fatal when read USB image %d !!!\n", index, block, usb_img_index_); + utils::to_log(LOG_LEVEL_FATAL, "memory(0x%08x + %u) fatal when read USB image %d !!!\n", index, block, usb_img_index_); ret = SCANNER_ERR_INSUFFICIENT_MEMORY; break; } @@ -502,12 +504,12 @@ int hg_scanner_300::get_img_data(std::shared_ptr &imagedata) if (ret != SCANNER_ERR_OK && ret != SCANNER_ERR_TIMEOUT) { - VLOG_MINI_1(LOG_LEVEL_FATAL, "get_img_data read_data:%s!!! \n", hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_FATAL, "get_img_data read_data:%s!!! \n", hg_scanner_err_name(ret)); break; } else if (ret == SCANNER_ERR_TIMEOUT && io_->get_timeout() > 3000) { - VLOG_MINI_2(LOG_LEVEL_FATAL, "get_img_data read_data:%s!!! ,get_timeout is %d\n", hg_scanner_err_name(ret), io_->get_timeout()); + utils::to_log(LOG_LEVEL_FATAL, "get_img_data read_data:%s!!! ,get_timeout is %d\n", hg_scanner_err_name(ret), io_->get_timeout()); break; } @@ -522,7 +524,7 @@ int hg_scanner_300::get_img_data(std::shared_ptr &imagedata) } else { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Read image data from USB err: %s\n", hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "Read image data from USB err: %s\n", hg_scanner_err_name(ret)); stop(); string str = STATU_DESC_SCANNER_ERR_DEVICE_GET_IMAGE_ERR; str = str + '-' + STATU_DESC_SCANNER_ERR_DEVICE_STOPPED; @@ -562,7 +564,7 @@ int hg_scanner_300::writedown_device_configuration(bool type,setting_hardware::H if ((is_quality_ == IMG_SPEED) && (resolution_ >= 300)) { - VLOG_MINI_1(LOG_LEVEL_WARNING, "writedown_device_configuration is_quality_ is .(%d)\n", is_quality_) + utils::to_log(LOG_LEVEL_WARNING, "writedown_device_configuration is_quality_ is .(%d)\n", is_quality_); d->params_3288.dpi = 1; } if (image_prc_param_.bits.paper == PAPER_AUTO_MATCH @@ -589,7 +591,7 @@ int hg_scanner_300::writedown_device_configuration(bool type,setting_hardware::H { printf_devconfig(d); } - VLOG_MINI_1(LOG_LEVEL_WARNING, "writedown_device_configuration is .(%s)\n", hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_WARNING, "writedown_device_configuration is .(%s)\n", hg_scanner_err_name(ret)); return ret; } @@ -660,7 +662,7 @@ int hg_scanner_300::on_resolution_changed(int& dpi) else dsp_config.params_3288.dpi = 1; - VLOG_MINI_3(LOG_LEVEL_WARNING, "on_resolution_changed is dpi:%d .set device dpi(%d),firmware_sup_dpi_300 is :%d\n", dpi, dsp_config.params_3288.dpi, firmware_sup_dpi_300); + utils::to_log(LOG_LEVEL_WARNING, "on_resolution_changed is dpi:%d .set device dpi(%d),firmware_sup_dpi_300 is :%d\n", dpi, dsp_config.params_3288.dpi, firmware_sup_dpi_300); ret = writedown_device_configuration(); return ret; @@ -704,7 +706,7 @@ int hg_scanner_300::set_kernelsnap_ver() ret = SCANNER_ERR_NO_DATA; } - VLOG_MINI_2(LOG_LEVEL_WARNING, "hg_scanner_300 firmware_sup_dpi_300 :%d ,firmware_sup_dpi_600:%d\n", firmware_sup_dpi_300, firmware_sup_dpi_600); + utils::to_log(LOG_LEVEL_WARNING, "hg_scanner_300 firmware_sup_dpi_300 :%d ,firmware_sup_dpi_600:%d\n", firmware_sup_dpi_300, firmware_sup_dpi_600); return SCANNER_ERR_OK; } int hg_scanner_300::agreement(TwSS tw,int align) @@ -737,8 +739,11 @@ int hg_scanner_300::initdevice() { if (fw.substr(4, 6) == "230303") { - string scanner_path = hg_log::get_module_full_path(LIBNAME); - scanner_path = scanner_path.substr(0, scanner_path.size() - strlen(LIBNAME)); + string scanner_path(utils::get_module_full_path(SCANNER_DRIVER_PART_NAME)); + size_t pos = scanner_path.rfind(PATH_SEPARATOR[0]); + if(pos++ == std::string::npos) + pos = 0; + scanner_path.erase(pos); scanner_path += "update.zip"; set_firmware_upgrade(scanner_path); return SCANNER_ERR_OK; @@ -767,7 +772,7 @@ void hg_scanner_300::writedown_image_configuration(void) ic.imageRotateDegree = 0; if (test_1_paper_) { - LOG_INFO(LOG_LEVEL_DEBUG_INFO, "scanning mode: testing ONE paper ...\n"); + utils::log_info("scanning mode: testing ONE paper ...\n", LOG_LEVEL_DEBUG); ic.scannum = 1; } else @@ -788,18 +793,18 @@ void hg_scanner_300::printf_devconfig(setting_hardware::HGSCANCONF_3288 *d) if (!d) d = &dsp_config; - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params_3288.doubleFeeded:%d\r\n",d->params_3288.doubleFeeded); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params_3288.dpi:%d\r\n",d->params_3288.dpi); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params_3288.dstHeight:%d\r\n",d->params_3288.dstHeight); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params_3288.enableLed:%d\r\n",d->params_3288.enableLed); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params_3288.enableStable:%d\r\n",d->params_3288.enableStable); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params_3288.isColor:%d\r\n",d->params_3288.isColor); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params_3288.isCorrect:%d\r\n",d->params_3288.isCorrect); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params_3288.pageSize:%d\r\n",d->params_3288.pageSize); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params_3288.reversed1:%d\r\n",d->params_3288.reversed1); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params_3288.reversed2:%d\r\n",d->params_3288.reversed2); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params_3288.enableSizeDetect:%d\r\n",d->params_3288.enableSizeDetect); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params_3288.value:%d\r\n",d->value); + utils::to_log(LOG_LEVEL_DEBUG,"dsp_config.params_3288.doubleFeeded:%d\r\n",d->params_3288.doubleFeeded); + utils::to_log(LOG_LEVEL_DEBUG,"dsp_config.params_3288.dpi:%d\r\n",d->params_3288.dpi); + utils::to_log(LOG_LEVEL_DEBUG,"dsp_config.params_3288.dstHeight:%d\r\n",d->params_3288.dstHeight); + utils::to_log(LOG_LEVEL_DEBUG,"dsp_config.params_3288.enableLed:%d\r\n",d->params_3288.enableLed); + utils::to_log(LOG_LEVEL_DEBUG,"dsp_config.params_3288.enableStable:%d\r\n",d->params_3288.enableStable); + utils::to_log(LOG_LEVEL_DEBUG,"dsp_config.params_3288.isColor:%d\r\n",d->params_3288.isColor); + utils::to_log(LOG_LEVEL_DEBUG,"dsp_config.params_3288.isCorrect:%d\r\n",d->params_3288.isCorrect); + utils::to_log(LOG_LEVEL_DEBUG,"dsp_config.params_3288.pageSize:%d\r\n",d->params_3288.pageSize); + utils::to_log(LOG_LEVEL_DEBUG,"dsp_config.params_3288.reversed1:%d\r\n",d->params_3288.reversed1); + utils::to_log(LOG_LEVEL_DEBUG,"dsp_config.params_3288.reversed2:%d\r\n",d->params_3288.reversed2); + utils::to_log(LOG_LEVEL_DEBUG,"dsp_config.params_3288.enableSizeDetect:%d\r\n",d->params_3288.enableSizeDetect); + utils::to_log(LOG_LEVEL_DEBUG,"dsp_config.params_3288.value:%d\r\n",d->value); } std::string hg_scanner_300::get_firmware_version() { @@ -815,7 +820,7 @@ std::string hg_scanner_300::get_firmware_version() ret = io_->read_bulk(buf, &len); } string fw = buf; - VLOG_MINI_1(LOG_LEVEL_WARNING, "get_firmware_version:%s\n", !fw.empty() ? fw.c_str() : "not find devs firmware_version"); + utils::to_log(LOG_LEVEL_WARNING, "get_firmware_version:%s\n", !fw.empty() ? fw.c_str() : "not find devs firmware_version"); return buf; } @@ -834,7 +839,7 @@ std::string hg_scanner_300::get_firmware_version() ret = io_->read_bulk(&SerialNum[0], &len); } - VLOG_MINI_1(LOG_LEVEL_WARNING, "get_serial_num:%s\n", !SerialNum.empty() ? SerialNum.c_str() : "not find devs get_serial_num"); + utils::to_log(LOG_LEVEL_WARNING, "get_serial_num:%s\n", !SerialNum.empty() ? SerialNum.c_str() : "not find devs get_serial_num"); return SerialNum; } std::string hg_scanner_300::get_ip(void) @@ -891,7 +896,7 @@ int hg_scanner_300::get_sleep_time(int &data) { data = (SANE_Power)usbcb.u32_Data; } - VLOG_MINI_1(LOG_LEVEL_WARNING, "get_sleep_time:%d\n", data); + utils::to_log(LOG_LEVEL_WARNING, "get_sleep_time:%d\n", data); return ret; } int hg_scanner_300::set_sleep_time(int data) @@ -924,7 +929,7 @@ int hg_scanner_300::get_scanner_paperon(SANE_Bool& type) // ret = SCANNER_ERR_DEVICE_NO_PAPER; //else // ret = SCANNER_ERR_OK; - VLOG_MINI_1(LOG_LEVEL_WARNING, "get_scanner_paperon is(%s)\n", !type ? hg_scanner_err_description(SCANNER_ERR_DEVICE_NO_PAPER) : hg_scanner_err_description(SCANNER_ERR_OK)); + utils::to_log(LOG_LEVEL_WARNING, "get_scanner_paperon is(%s)\n", !type ? hg_scanner_err_description(SCANNER_ERR_DEVICE_NO_PAPER) : hg_scanner_err_description(SCANNER_ERR_OK)); return ret; } @@ -953,7 +958,7 @@ int hg_scanner_300::get_scan_is_sleep(SANE_Bool& type) type = false; //return SCANNER_ERR_DEVICE_SLEEPING; } - VLOG_MINI_1(LOG_LEVEL_WARNING, "get_scan_is_sleep is(%s)\n", !type ? hg_scanner_err_description(SCANNER_ERR_DEVICE_SLEEPING) : hg_scanner_err_description(SCANNER_ERR_OK)); + utils::to_log(LOG_LEVEL_WARNING, "get_scan_is_sleep is(%s)\n", !type ? hg_scanner_err_description(SCANNER_ERR_DEVICE_SLEEPING) : hg_scanner_err_description(SCANNER_ERR_OK)); return ret; } ///此款设备无此功能 @@ -1101,12 +1106,12 @@ int hg_scanner_300::set_firmware_upgrade(std::string str) if (ret != SCANNER_ERR_OK) { - VLOG_MINI_1(LOG_LEVEL_WARNING, "updata result read_bulk:%s\n", hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_WARNING, "updata result read_bulk:%s\n", hg_scanner_err_name(ret)); //return ret; } if (result.u32_Data == 2 || result.u32_Data == 3) { - VLOG_MINI_1(LOG_LEVEL_WARNING, "updata result:%d\n", result.u32_Data); + utils::to_log(LOG_LEVEL_WARNING, "updata result:%d\n", result.u32_Data); break; } } @@ -1163,7 +1168,7 @@ int hg_scanner_300::set_devs_distortion_check_val(float data) USBCB usbcb = { setting3288dsp::SET_JUST_COF_V ,val,protocol_dpi }; len = sizeof(usbcb); float f = *(float*)&(val); - VLOG_MINI_3(LOG_LEVEL_WARNING, "set_devs_distortion_check_val dpi is:%d,config dpi = %d,distortion_check_val(%f)\n", resolution_, protocol_dpi,f); + utils::to_log(LOG_LEVEL_WARNING, "set_devs_distortion_check_val dpi is:%d,config dpi = %d,distortion_check_val(%f)\n", resolution_, protocol_dpi,f); io_->set_timeout(5000); { std::lock_guard lock(io_lock_); @@ -1200,7 +1205,7 @@ int hg_scanner_300::get_devs_distortion_check_val(float& data) val = usbcb.u32_Data; data = *(float *) &val; - VLOG_MINI_3(LOG_LEVEL_WARNING, "get_distortion_check_val dpi is:%d,protocol_dpi = %d get_distortion_check_val(%f)\n", resolution_, protocol_dpi, data); + utils::to_log(LOG_LEVEL_WARNING, "get_distortion_check_val dpi is:%d,protocol_dpi = %d get_distortion_check_val(%f)\n", resolution_, protocol_dpi, data); return ret; } int hg_scanner_300::set_auto_flat(int data) @@ -1227,7 +1232,7 @@ int hg_scanner_300::set_auto_flat(int data) } else status_ = ret; - VLOG_MINI_1(LOG_LEVEL_WARNING, "set_auto_flat ret: %s\n", hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_WARNING, "set_auto_flat ret: %s\n", hg_scanner_err_name(ret)); return ret; } int hg_scanner_300::set_updata0303(void) @@ -1237,8 +1242,11 @@ int hg_scanner_300::set_updata0303(void) { if (fw.substr(4, 6) == "230303") { - string scanner_path = hg_log::get_module_full_path(LIBNAME); - scanner_path = scanner_path.substr(0, scanner_path.size() - strlen(LIBNAME)); + string scanner_path = utils::get_module_full_path(SCANNER_DRIVER_PART_NAME); + size_t pos = scanner_path.rfind(PATH_SEPARATOR[0]); + if(pos++ == std::string::npos) + pos = 0; + scanner_path.erase(pos); scanner_path += "update.zip"; set_firmware_upgrade(scanner_path); } diff --git a/hgdriver/hgdev/hg_scanner_300.h b/hgdriver/hgdev/hg_scanner_300.h index 446b071..9bd4d40 100644 --- a/hgdriver/hgdev/hg_scanner_300.h +++ b/hgdriver/hgdev/hg_scanner_300.h @@ -10,7 +10,6 @@ #include #include "hg_scanner.h" -#include "../wrapper/hg_log.h" #include "PaperSize.h" //#ifdef OEM_HANWANG diff --git a/hgdriver/hgdev/hg_scanner_302.cpp b/hgdriver/hgdev/hg_scanner_302.cpp index 6253055..342ba85 100644 --- a/hgdriver/hgdev/hg_scanner_302.cpp +++ b/hgdriver/hgdev/hg_scanner_302.cpp @@ -1,5 +1,7 @@ #include "hg_scanner_302.h" -#include "../wrapper/hg_log.h" + +#include "../../sdk/hginclude/utils.h" +#include #include "filetools.h" #if defined(WIN32) || defined(_WIN64) @@ -163,7 +165,7 @@ namespace settings302 // *r = true; // else // *r = false; - // VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "Paper '%s' index = %d, device value = %d\n", paper_string(paper).c_str(), ind, paper_map_3399[ind].dev_value); + // utils::to_log(LOG_LEVEL_DEBUG, "Paper '%s' index = %d, device value = %d\n", paper_string(paper).c_str(), ind, paper_map_3399[ind].dev_value); // paper = paper_map_3399[ind].paper; // if (type) // *type = paper_map_3399[ind].type; @@ -178,7 +180,7 @@ hg_scanner_302::hg_scanner_302(const char* dev_name, int pid, usb_io* io) : hg_s , rewrite_conf_(false), reset_(false) { //pid_ = pid; - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "hg_scanner_302(%s) constructing ...\n", hg_log::format_ptr(this).c_str()); + utils::to_log(LOG_LEVEL_DEBUG, "hg_scanner_302(%p) constructing ...\n", this); dev_conf_.value = 0; #ifndef MAPPING_FUNCTION_IN_BASE init_setting_map(setting_map_, ARRAY_SIZE(setting_map_)); @@ -195,7 +197,7 @@ hg_scanner_302::hg_scanner_302(const char* dev_name, int pid, usb_io* io) : hg_s } hg_scanner_302::~hg_scanner_302() { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "hg_scanner_302(%s) destroyed.\n", hg_log::format_ptr(this).c_str()); + utils::to_log(LOG_LEVEL_DEBUG, "hg_scanner_302(%p) destroyed.\n", this); } int hg_scanner_302::read_register(int addr, int* val) { @@ -238,16 +240,16 @@ std::string hg_scanner_302::control_fetch(int addr, int val, int size) ret = io_->read_bulk(&data[0], &l); if (ret == SCANNER_ERR_OK) { - VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "control_fetch(%d, %d) - read_bulk %d bytes\n", addr, val, l); + utils::to_log(LOG_LEVEL_DEBUG, "control_fetch(%d, %d) - read_bulk %d bytes\n", addr, val, l); } else { - VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "control_fetch(%d, %d) - read_bulk = %s\n", addr, val, hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "control_fetch(%d, %d) - read_bulk = %s\n", addr, val, hg_scanner_err_name(ret)); data.clear(); } } else - VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "control_fetch(%d, %d) = %s\n", addr, val, hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "control_fetch(%d, %d) = %s\n", addr, val, hg_scanner_err_name(ret)); return data; } @@ -278,7 +280,7 @@ int hg_scanner_302::clr_roller_num(void) return val; else { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "clr_roller_num = %s\n", hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "clr_roller_num = %s\n", hg_scanner_err_name(ret)); return -1; } } @@ -292,7 +294,7 @@ int hg_scanner_302::get_sleep_time(void) return val; else { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "get_sleep_time = %s\n", hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "get_sleep_time = %s\n", hg_scanner_err_name(ret)); return -1; } } @@ -304,7 +306,7 @@ int hg_scanner_302::get_scan_mode(void) if (ret) { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "get scan mode error: %s\n", hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "get scan mode error: %s\n", hg_scanner_err_name(ret)); status_ = ret; return -1; @@ -320,7 +322,7 @@ int hg_scanner_302::get_status(void) if (ret) { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "get status error: %s\n", hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "get status error: %s\n", hg_scanner_err_name(ret)); status_ = ret; return -1; @@ -336,7 +338,7 @@ bool hg_scanner_302::is_dev_tx(void) if (ret) { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "is_dev_tx() error: %s\n", hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "is_dev_tx() error: %s\n", hg_scanner_err_name(ret)); status_ = ret; return false; @@ -352,7 +354,7 @@ bool hg_scanner_302::is_dev_image_process_done(void) if (ret) { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "is_dev_image_process_done() error: %s\n", hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "is_dev_image_process_done() error: %s\n", hg_scanner_err_name(ret)); status_ = ret; return true; @@ -369,7 +371,7 @@ bool hg_scanner_302::is_dev_image_keep_last_paper(void) if (ret) { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "is_dev_image_keep_last_paper() error: %s\n", hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "is_dev_image_keep_last_paper() error: %s\n", hg_scanner_err_name(ret)); status_ = ret; return true; @@ -387,7 +389,7 @@ int hg_scanner_302::get_scanned_count(void) return val; else { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "get_scanned_count = %s\n", hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "get_scanned_count = %s\n", hg_scanner_err_name(ret)); return -1; } } @@ -397,7 +399,7 @@ int hg_scanner_302::get_image_count(void) int val = 0, ret = read_register(setting3399::SR_IM_COUNT, &val); - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "get_image_count() = %d, error: %s\n", val, hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "get_image_count() = %d, error: %s\n", val, hg_scanner_err_name(ret)); if (ret == SCANNER_ERR_OK) return val; @@ -414,7 +416,7 @@ int hg_scanner_302::get_front_data_size(void) return val; else { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "get_front_data_size = %s\n", hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "get_front_data_size = %s\n", hg_scanner_err_name(ret)); return -1; } } @@ -424,9 +426,9 @@ void hg_scanner_302::init_version(void) sn(get_serial_num()); if (fv.empty() || sn.empty()) return; - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Firmware version: %s\n", fv.c_str()); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Serial number: %s\n", sn.c_str()); - //VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, " HG3399 IP: %s\n", get_ip().c_str()); + utils::to_log(LOG_LEVEL_DEBUG, "Firmware version: %s\n", fv.c_str()); + utils::to_log(LOG_LEVEL_DEBUG, "Serial number: %s\n", sn.c_str()); + //utils::to_log(LOG_LEVEL_DEBUG, " HG3399 IP: %s\n", get_ip().c_str()); //if (fv.length() >= 10 && (fv[5] > 'A' || atoi(fv.substr(6, 4).c_str()) >= 1209)) //{ @@ -485,7 +487,7 @@ int hg_scanner_302::writedown_device_configuration(bool type,setting_hardware::H ret = write_register(setting3399::SR_CONFIG_SCAN_PARAM, dev_conf->value); } - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "Writedown scanner configuration(0x%x) = %s\n", dev_conf->value, hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "Writedown scanner configuration(0x%x) = %s\n", dev_conf->value, hg_scanner_err_name(ret)); return ret; } int hg_scanner_302::writedown_image_configuration(void) @@ -507,7 +509,7 @@ int hg_scanner_302::writedown_image_configuration(void) ic.hardwarecaps.skrewdetectlevel = dev_conf_.params_3399.screw_detect_level; if (test_1_paper_) { - LOG_INFO(LOG_LEVEL_DEBUG_INFO, "scanning mode: testing ONE paper ...\n"); + utils::log_info("scanning mode: testing ONE paper ...\n", LOG_LEVEL_DEBUG); ic.scannum = /*ic.is_duplex ? 2 :*/ 1; } else @@ -536,7 +538,7 @@ int hg_scanner_302::pop_first_image(void) std::lock_guard lock(io_lock_); int ret = write_register(setting3399::SR_IM_POP, 1); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "popup first image = %s\n", hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "popup first image = %s\n", hg_scanner_err_name(ret)); return ret; } @@ -548,7 +550,7 @@ int hg_scanner_302::read_one_image_from_usb(SANE_Image_Statu statu) ret = SCANNER_ERR_OK; bool popimg = false; - VLOG_MINI_1(LOG_LEVEL_ALL, "New image size: %u\n", total); + utils::to_log(LOG_LEVEL_ALL, "New image size: %u\n", total); if (!waiting_for_memory_enough(total)) { status_ = SCANNER_ERR_INSUFFICIENT_MEMORY; @@ -593,7 +595,7 @@ int hg_scanner_302::read_one_image_from_usb(SANE_Image_Statu statu) buff = buf->data(off, (unsigned int*)&r); } } - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Read image from USB = %s\n", hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "Read image from USB = %s\n", hg_scanner_err_name(ret)); if (ret == SCANNER_ERR_OK) { //{ @@ -608,17 +610,17 @@ int hg_scanner_302::read_one_image_from_usb(SANE_Image_Statu statu) } else { - VLOG_MINI_1(LOG_LEVEL_FATAL, "save usb data failed: %s\n", hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_FATAL, "save usb data failed: %s\n", hg_scanner_err_name(ret)); } } else { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Read image data from USB err: %s\n", hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "Read image data from USB err: %s\n", hg_scanner_err_name(ret)); } } else { - VLOG_MINI_1(LOG_LEVEL_FATAL, "write command SR_IM_TX failed: %s\n", hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_FATAL, "write command SR_IM_TX failed: %s\n", hg_scanner_err_name(ret)); } } if(popimg) @@ -665,7 +667,7 @@ int hg_scanner_302::discard_all_images(void) io_->set_timeout(oto); } if (pre_int) - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "prev-connection has left %d interrupt packet(s) && %d image(s).\n", pre_int, pre_img); + utils::to_log(LOG_LEVEL_DEBUG, "prev-connection has left %d interrupt packet(s) && %d image(s).\n", pre_int, pre_img); return 0; } int hg_scanner_302::get_roller_life(void) @@ -924,7 +926,7 @@ void hg_scanner_302::thread_handle_usb_read(void) } if (ret != SCANNER_ERR_OK && ret != SCANNER_ERR_TIMEOUT) { - VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "read-INT = %s: From(%d), Code(%d), Index(%d), size = %d\n", hg_scanner_err_name(ret), + utils::to_log(LOG_LEVEL_DEBUG, "read-INT = %s: From(%d), Code(%d), Index(%d), size = %d\n", hg_scanner_err_name(ret), info->From, info->Code, info->Img_Index, size); } @@ -938,7 +940,7 @@ void hg_scanner_302::thread_handle_usb_read(void) //int statu = get_status(); //if ((statu & 0x03) == 0) //{ - // VLOG_MINI_1(LOG_LEVEL_FATAL, "USB thread over with status: 0x%x\n", statu); + // utils::to_log(LOG_LEVEL_FATAL, "USB thread over with status: 0x%x\n", statu); // status_ = SCANNER_ERR_OK; // break; //} @@ -953,7 +955,7 @@ void hg_scanner_302::thread_handle_usb_read(void) if (size == sizeof(buf)) { ret = settings302::device_status_to_hg_err(info); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "status from interrupt point is '%s'\n", hg_scanner_err_name(status_)); + utils::to_log(LOG_LEVEL_DEBUG, "status from interrupt point is '%s'\n", hg_scanner_err_name(status_)); if (ret != SCANNER_ERR_OK && ret != SCANNER_ERR_TIMEOUT && ret != SCANNER_ERR_DEVICE_STOPPED) { @@ -983,7 +985,7 @@ void hg_scanner_302::thread_handle_usb_read(void) status_ = st; } - VLOG_MINI_1(LOG_LEVEL_WARNING, "\346\211\253\346\217\217\345\244\261\350\264\245, read interrupt\350\277\224\345\233\236\347\212\266\346\200\201\344\270\272\357\274\232%s\n", hg_scanner_err_description(status_)); + utils::to_log(LOG_LEVEL_WARNING, "\346\211\253\346\217\217\345\244\261\350\264\245, read interrupt\350\277\224\345\233\236\347\212\266\346\200\201\344\270\272\357\274\232%s\n", hg_scanner_err_description(status_)); break; } @@ -996,11 +998,11 @@ void hg_scanner_302::thread_handle_usb_read(void) } else { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "receive IMG event but no image count(%d)!", get_image_count()); + utils::to_log(LOG_LEVEL_DEBUG, "receive IMG event but no image count(%d)!", get_image_count()); } break; case setting3399::V4L2: - VLOG_MINI_1(LOG_LEVEL_FATAL, "V4L2 error: %d\n", info->Code); + utils::to_log(LOG_LEVEL_FATAL, "V4L2 error: %d\n", info->Code); { bool cancel = user_cancel_; stop(); @@ -1010,7 +1012,7 @@ void hg_scanner_302::thread_handle_usb_read(void) break; case setting3399::STOPSCAN: go = false; - LOG_INFO(LOG_LEVEL_ALL, "Received STOPSCAN event ...\n"); + utils::log_info("Received STOPSCAN event ...\n", LOG_LEVEL_ALL); std::this_thread::sleep_for(std::chrono::milliseconds(500)); while (get_image_count() > 0) // lost IMG message, check image count to receive rest images (BUG-228)... { @@ -1029,11 +1031,11 @@ void hg_scanner_302::thread_handle_usb_read(void) break; } else - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "read %d bytes, sizeof(buf) = %d\n", size, sizeof(buf)); + utils::to_log(LOG_LEVEL_DEBUG, "read %d bytes, sizeof(buf) = %d\n", size, sizeof(buf)); this_thread::sleep_for(chrono::milliseconds(10)); } - 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_)); + utils::to_log(LOG_LEVEL_DEBUG, "USB thread exit with code: %s, status = %s\n", hg_scanner_err_name(ret), hg_scanner_err_name(status_)); } int hg_scanner_302::start(void) { @@ -1048,7 +1050,7 @@ int hg_scanner_302::start(void) user_cancel_ = false; split3399_ = 0; cb_mem_ = true; - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "scanner status: 0x%x\n", get_status()); + utils::to_log(LOG_LEVEL_DEBUG, "scanner status: 0x%x\n", get_status()); reset(); @@ -1079,11 +1081,11 @@ int hg_scanner_302::start(void) else { ret = status_ = SCANNER_ERR_DEVICE_UNKNOWN_STATUS; - VLOG_MINI_2(LOG_LEVEL_WARNING, "The device is abnormal(%d) and can not be scanned : %s\n", val, hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_WARNING, "The device is abnormal(%d) and can not be scanned : %s\n", val, hg_scanner_err_name(ret)); //break; } - VLOG_MINI_2(LOG_LEVEL_WARNING, "failed on SR_GET_ANDROID_STATE(%d) result: %s\n", val, hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_WARNING, "failed on SR_GET_ANDROID_STATE(%d) result: %s\n", val, hg_scanner_err_name(ret)); return ret; } @@ -1096,7 +1098,7 @@ int hg_scanner_302::start(void) write_register(0x1000, count); ret = write_command(setting3399::SC_START); } - VLOG_MINI_1(LOG_LEVEL_WARNING, "start result: %s\n", hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_WARNING, "start result: %s\n", hg_scanner_err_name(ret)); if (ret == SCANNER_ERR_OK) { @@ -1107,7 +1109,7 @@ int hg_scanner_302::start(void) else { status_ = ret; - 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)); + utils::to_log(LOG_LEVEL_WARNING, "(Thread 0x%x)Send start command = %s\n", GetCurrentThreadId(), hg_scanner_err_name(ret)); } return ret; @@ -1236,7 +1238,7 @@ int hg_scanner_302::get_sleep_time(int& data) data = val; } - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "get_sleep_time = %d with %s\n", data, hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "get_sleep_time = %d with %s\n", data, hg_scanner_err_name(ret)); return ret; } int hg_scanner_302::set_sleep_time(int setsleepime) @@ -1244,7 +1246,7 @@ int hg_scanner_302::set_sleep_time(int setsleepime) std::lock_guard lock(io_lock_); int ret = write_register(setting3399::SR_SET_SLEEPTIME, setsleepime); - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "set sleep time to %d = %s\n", setsleepime, hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "set sleep time to %d = %s\n", setsleepime, hg_scanner_err_name(ret)); return ret; } @@ -1283,7 +1285,7 @@ int hg_scanner_302::get_device_log(string &log) if (ret == SCANNER_ERR_OK) ret = io_->write_bulk(&log[0],&len); - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "log path:%s ret:%s\n", log.c_str(),hg_scanner_err_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "log path:%s ret:%s\n", log.c_str(),hg_scanner_err_name(ret)); return ret; } int hg_scanner_302::set_devreboot(int data) diff --git a/hgdriver/hgdev/image_process.cpp b/hgdriver/hgdev/image_process.cpp index 21f8c4c..9c915e9 100644 --- a/hgdriver/hgdev/image_process.cpp +++ b/hgdriver/hgdev/image_process.cpp @@ -1,5 +1,9 @@ #include "image_process.h" -#include "../wrapper/hg_log.h" + +#include "../../sdk/hginclude/utils.h" +#include "../../sdk/hginclude/huagaoxxx_warraper_ex.h" +#include + #include #include #if !defined(WIN32) && !defined(_WIN64) @@ -218,14 +222,19 @@ namespace hg_imgproc public: imgproc(int pid, bool isx86_Advan) : pid_(pid),papersize_(pid_) , img_statu_(SANE_Image_Statu_OK) - , my_path_(hg_log::pe_path()) + , my_path_(utils::get_module_full_path()) ,ocrinit_(NULL),ocrgetdirectimage_(NULL) ,ocrexit_(NULL),HGBase_CreatImg(NULL) ,HGBase_FreeImg(NULL),Auto_Txt_pHanld(NULL) ,Dynamicopen_HGBase_pHandle_(NULL) ,Dynamicopen_HGImageprc_pHandle_(NULL),isx86_Advan_(isx86_Advan) { - cv::setUseOptimized(isx86_Advan_); //开关cpu高级指令? + size_t pos = my_path_.rfind(PATH_SEPARATOR[0]); + if(pos++ == std::string::npos) + pos = 0; + my_path_.erase(pos); + + cv::setUseOptimized(isx86_Advan_); //开关cpu高级指令�? } ~imgproc() { @@ -294,29 +303,18 @@ namespace hg_imgproc int init_auto_txt_hanld() { int ret = 0; -#ifndef WIN32 -#ifdef OEM_HANWANG - string libname = "libhwdriver.so"; -#elif defined(OEM_LISICHENG) - string libname = "liblscdriver.so"; -#elif defined(OEM_CANGTIAN) - string libname = "libctsdriver.so"; -#elif defined(OEM_ZHONGJING) - string libname = "libzjdriver.so"; -#elif defined(OEM_ZIGUANG) - string libname = "libzgdriver.so"; -#else - string libname = "libhgdriver.so"; -#endif - - string scanner_path = hg_log::get_module_full_path(libname.c_str()); + string scanner_path = utils::get_module_full_path(SCANNER_DRIVER_PART_NAME); + size_t pos = scanner_path.rfind(PATH_SEPARATOR[0]); if (scanner_path.empty()) { return SCANNER_ERR_OUT_OF_RANGE; } - scanner_path = scanner_path.substr(0, scanner_path.size() - libname.size()); + if(pos++ == std::string::npos) + pos = 0; + scanner_path.erase(pos); +#ifndef WIN32 string HGImagePrclib_path = scanner_path + IMGPRC_LIBNANE; string HGBaselib_path = scanner_path + HGBASE_LIBNAME; @@ -326,14 +324,14 @@ namespace hg_imgproc { return SCANNER_ERR_OUT_OF_RANGE; } - printf("HGBaselib_path?s HGImagePrclib_path:%s\r\n",HGBaselib_path.c_str(),HGImagePrclib_path.c_str()); + printf("HGBaselib_path�?s HGImagePrclib_path:%s\r\n",HGBaselib_path.c_str(),HGImagePrclib_path.c_str()); Dynamicopen_HGImageprc_pHandle_ = dlopen(HGImagePrclib_path.c_str(), RTLD_LAZY); Dynamicopen_HGBase_pHandle_ = dlopen(HGBaselib_path.c_str(), RTLD_LAZY); if (!Dynamicopen_HGBase_pHandle_ || !Dynamicopen_HGImageprc_pHandle_) { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "auto txt open dll is error: %s\n", hg_scanner_err_name(SCANNER_ERR_INSUFFICIENT_MEMORY)); + utils::to_log(LOG_LEVEL_DEBUG, "auto txt open dll is error: %s\n", hg_scanner_err_name(SCANNER_ERR_INSUFFICIENT_MEMORY)); return SCANNER_ERR_INSUFFICIENT_MEMORY; } @@ -345,9 +343,6 @@ namespace hg_imgproc HGBase_FreeImg = (SDKHGBase_FreeImage_)dlsym(Dynamicopen_HGBase_pHandle_,"HGBase_DestroyImage"); #else - string scanner_path = hg_log::get_module_full_path("scanner.dll"); - scanner_path = scanner_path.substr(0, scanner_path.size() - strlen("scanner.dll")); - string HGImagePrclib_path = scanner_path + IMGPRC_LIBNANE; string HGBaselib_path = scanner_path + HGBASE_LIBNAME; @@ -371,7 +366,7 @@ namespace hg_imgproc if (!Dynamicopen_HGBase_pHandle_ || !Dynamicopen_HGImageprc_pHandle_) { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "auto txt open dll is error: %s\n", hg_scanner_err_name(SCANNER_ERR_INSUFFICIENT_MEMORY)); + utils::to_log(LOG_LEVEL_DEBUG, "auto txt open dll is error: %s\n", hg_scanner_err_name(SCANNER_ERR_INSUFFICIENT_MEMORY)); return SCANNER_ERR_INSUFFICIENT_MEMORY; } ocrinit_ = (SDKHGImgProc_InitOCR_)GetProcAddress(Dynamicopen_HGImageprc_pHandle_, "HGImgProc_CreateOCRMgr"); @@ -488,7 +483,7 @@ namespace hg_imgproc if (mat.empty()) { - LOG_INFO(LOG_LEVEL_FATAL, "decode image data error\n"); + utils::log_info("decode image data error\n", LOG_LEVEL_FATAL); continue; } if (param_.cis_image) @@ -510,8 +505,8 @@ namespace hg_imgproc } catch (const std::exception& e) { - LOG_INFO(LOG_LEVEL_FATAL, e.what()); - throw(e); // 继续抛到上层处理? + utils::log_info(e.what(), LOG_LEVEL_FATAL); + throw(e); // 继续抛到上层处理�? } } @@ -523,7 +518,7 @@ namespace hg_imgproc if (pid_ == 0x100 || pid_ == 0x200 || pid_ == 0x300 || pid_ == 0x400 || pid == 0x402 || pid == 0x302) { - //////除穿孔算法移至解压图像之? + //////除穿孔算法移至解压图像之�? double left = img_conf_.fillholeratio_left / 100.0; double right = img_conf_.fillholeratio_right / 100.0; double top = img_conf_.fillholeratio_up / 100.0; @@ -531,7 +526,7 @@ namespace hg_imgproc if (left > 0 || right > 0 || top > 0 || low > 0) fillhole1(Temp_mat, top, low, left, right); - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "Remove hole is '%s',Hole image buffer size is:%d\n", !Temp_mat.empty() ? "enable" : "close", Temp_mat.size()); + utils::to_log(LOG_LEVEL_DEBUG, "Remove hole is '%s',Hole image buffer size is:%d\n", !Temp_mat.empty() ? "enable" : "close", Temp_mat.size()); if (param_.cis_image) { mats_ = Temp_mat; @@ -563,7 +558,7 @@ namespace hg_imgproc Temp_mat.clear(); - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "Decode %u bytes to %u picture(s)\n", origin, mats_.size()); + utils::to_log(LOG_LEVEL_DEBUG, "Decode %u bytes to %u picture(s)\n", origin, mats_.size()); if (mats_.empty()) { return SCANNER_ERR_NO_DATA; @@ -853,7 +848,7 @@ namespace hg_imgproc std::vector mats(mats_); mats_.clear(); - //VLOG_MINI_4(LOG_LEVEL_DEBUG_INFO, "adjust_color: table len = %d, brightness = %f, contrast = %f, gamma = %f\n", tableLength + //utils::to_log(LOG_LEVEL_DEBUG, "adjust_color: table len = %d, brightness = %f, contrast = %f, gamma = %f\n", tableLength // , img_conf_.brightness, img_conf_.contrast, img_conf_.gamma); if (gamma_table && tableLength) { @@ -1166,13 +1161,16 @@ namespace hg_imgproc string libname = "libhgdriver.so"; #endif - string scanner_path = hg_log::get_module_full_path(libname.c_str()); + string scanner_path = utils::get_module_full_path(SCANNER_DRIVER_PART_NAME); if(scanner_path.empty()) { return SCANNER_ERR_OUT_OF_RANGE; } - scanner_path = scanner_path.substr(0,scanner_path.size() - libname.size()); + size_t pos = scanner_path.rfind(PATH_SEPARATOR[0]); + if(pos++ == std::string::npos) + pos = 0; + scanner_path.erase(pos); scanner_path+="libhwocrdetect.so"; printf("hwlib path:%s\r\n",scanner_path.c_str()); @@ -1343,7 +1341,7 @@ namespace hg_imgproc info.width = mats.cols; info.origin = HGBASE_IMGORIGIN_TOP; int bits = mats.channels() == 1 ? 8 : 24; - info.widthStep = mats.step; //opencv原始? + info.widthStep = mats.step; //opencv原始�? info.type = mats.channels() == 1 ? HGBASE_IMGTYPE_GRAY : HGBASE_IMGTYPE_BGR; int ret = HGBase_CreatImg(const_cast(mats.data), &info, &image); @@ -1355,11 +1353,11 @@ namespace hg_imgproc /// - /// 8位图?位图 + /// 8位图�?位图 /// - /// 8bit?/param> + /// 8bit�?/param> /// 阈值，建议默认127 - /// true为反色，即黑0?；反之亦?/param> + /// true为反色，即黑0�?；反之亦�?/param> /// true为四字节对齐 /// 1位图 /// @@ -1519,7 +1517,7 @@ namespace hg_imgproc } else { - LOG_INFO(LOG_LEVEL_ALL, "No image output in image_process!\n"); + utils::log_info("No image output in image_process!\n", LOG_LEVEL_ALL); } } }; @@ -1876,7 +1874,7 @@ namespace hg_imgproc } else { - std::string tmpf(hg_log::temporary_path() + PATH_SEPARATOR + "imgtrans.jpg"); + std::string tmpf(utils::temporary_path() + PATH_SEPARATOR + "imgtrans.jpg"); cv::imwrite(tmpf.c_str(), imsg, cpr); size_t bytes = 0; conv->dst.data = (SANE_String_Const)G4Tiff::load_mini_file(tmpf.c_str(), &bytes, allocate_memory); diff --git a/hgdriver/hgdev/scanner_manager.cpp b/hgdriver/hgdev/scanner_manager.cpp index 6fd909d..05971d5 100644 --- a/hgdriver/hgdev/scanner_manager.cpp +++ b/hgdriver/hgdev/scanner_manager.cpp @@ -1,5 +1,7 @@ #include "scanner_manager.h" -#include "../wrapper/hg_log.h" + +#include "../../sdk/hginclude/utils.h" +#include #include #include #include "raw_src.h" @@ -142,7 +144,12 @@ std::mutex hg_scanner_mgr::mutex_img_id; hg_scanner_mgr::hg_scanner_mgr() : same_ind_(1), user_(""), pwd_(""), cf_name("") { - cf_name = hg_log::ini_get("devs_name", "name"); + std::string cfgf(utils::get_local_data_path() + PATH_SEPARATOR + "config" + PATH_SEPARATOR + "debug.cfg"); + char buf[260] = {0}; + int l = GetPrivateProfileStringA("devs_name", "name", "", buf, _countof(buf) - 1, cfgf.c_str()); + + buf[l] = 0; + cf_name = buf; usb_manager::instance()->register_hotplug(&hg_scanner_mgr::usb_event_handle, this); int code_page = lang_get_cur_code_page(); url_en = BRAND_COMPANY_URL; @@ -184,7 +191,7 @@ hg_scanner_mgr* hg_scanner_mgr::instance(sane_callback cb) hg_scanner_mgr::async_io_enabled_ = cb(NULL, SANE_EVENT_SUPPORT_ASYNC_IO, NULL, NULL, NULL) == 0; hg_scanner_mgr::unique_img_id_ = (uint32_t)INT_MAX + 1; hg_scanner_mgr::inst_ = new hg_scanner_mgr(); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "async image transferring is %s\n", hg_scanner_mgr::async_io_enabled_ ? "enabled" : "disabled"); + utils::to_log(LOG_LEVEL_DEBUG, "async image transferring is %s\n", hg_scanner_mgr::async_io_enabled_ ? "enabled" : "disabled"); } return hg_scanner_mgr::inst_; @@ -210,17 +217,21 @@ void hg_scanner_mgr::set_version(int hh, int hl, int lh, int ll) } void hg_scanner_mgr::set_exe_name(const char* path, const char* name) { + std::string cfgf(utils::get_local_data_path() + PATH_SEPARATOR + "config" + PATH_SEPARATOR + "debug.cfg"); + char buf[260] = {0}; + int l = 0; + hg_scanner_mgr::pe_path_ = path ? path : ""; hg_scanner_mgr::pe_name_ = name ? name : ""; - std::string str = hg_log::get_scanimage_ver(); + std::string str(utils::get_command_result("scanimage -V")); bool is_scanimg =false; is_scanimg = str >= "1.0.29" ? true : false; - VLOG_MINI_2(LOG_LEVEL_ALL, "imgascan ver is: %s is_scanimg is:%d\n", str.c_str(),is_scanimg); + utils::to_log(LOG_LEVEL_ALL, "imgascan ver is: %s is_scanimg is:%d\n", str.c_str(),is_scanimg); if (name && *name) { // int ret = system("scanimage -V"); - std::string eof(hg_log::ini_get("read_eof", name)); - if (eof.empty()) + l = GetPrivateProfileStringA("read_eof", name, "", buf, _countof(buf) - 1, cfgf.c_str()); + if (l == 0) { if(is_scanimg) hg_scanner_mgr::read_over_with_eof_ = STRICMP(name, "simple-scan") != 0; @@ -228,18 +239,18 @@ void hg_scanner_mgr::set_exe_name(const char* path, const char* name) hg_scanner_mgr::read_over_with_eof_ = STRICMP(name, "simple-scan") != 0 && (!is_scanimg? (STRICMP(name, "scanimage") != 0) : 1); } else - hg_scanner_mgr::read_over_with_eof_ = eof != "0"; + hg_scanner_mgr::read_over_with_eof_ = strcmp(buf, "0") != 0; } else { - std::string eof(hg_log::ini_get("read_eof", "first")); - if (eof.empty()) + l = GetPrivateProfileStringA("read_eof", "first", "", buf, _countof(buf) - 1, cfgf.c_str()); + if (l == 0) hg_scanner_mgr::read_over_with_eof_ = true; else - hg_scanner_mgr::read_over_with_eof_ = eof != "0"; + hg_scanner_mgr::read_over_with_eof_ = strcmp(buf, "0") != 0; } - VLOG_MINI_1(LOG_LEVEL_ALL, "read image data end with EOF: %s\n", hg_scanner_mgr::read_over_with_eof_ ? "true" : "false"); + utils::to_log(LOG_LEVEL_ALL, "read image data end with EOF: %s\n", hg_scanner_mgr::read_over_with_eof_ ? "true" : "false"); } std::string hg_scanner_mgr::get_pe_name(std::string* path) { @@ -429,7 +440,7 @@ void hg_scanner_mgr::on_hgscanner_pnp(usb_event ev, libusb_device* device, int v libusb_ref_device(ols.dev); // ref to the device of queue online_devices_ online_devices_.push_back(ols); name = ols.display_name; - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "%s connected.\n", name.c_str()); + utils::to_log(LOG_LEVEL_DEBUG, "%s connected.\n", name.c_str()); type = g_supporting_devices[ols.ind].type; } else if (online_devices_[i].scanner && !online_devices_[i].scanner->is_online()) @@ -446,7 +457,7 @@ void hg_scanner_mgr::on_hgscanner_pnp(usb_event ev, libusb_device* device, int v if (pid == 0x300 || pid == 0x400) std::this_thread::sleep_for(std::chrono::milliseconds(1000)); len = usb_manager::instance()->open(device, &io); - VLOG_MINI_3(LOG_LEVEL_WARNING, "[%04x:%04x]%s re-connected.\n", pid, vid, online_devices_[i].display_name.c_str()); + utils::to_log(LOG_LEVEL_WARNING, "[%04x:%04x]%s re-connected.\n", pid, vid, online_devices_[i].display_name.c_str()); if (len == SCANNER_ERR_OK) { online_devices_[i].scanner->reset_io(io); @@ -467,7 +478,7 @@ void hg_scanner_mgr::on_hgscanner_pnp(usb_event ev, libusb_device* device, int v name = it->display_name; type = g_supporting_devices[it->ind].type; h = it->scanner; - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "%s Dis-connected.\n", name.c_str()); + utils::to_log(LOG_LEVEL_DEBUG, "%s Dis-connected.\n", name.c_str()); if (it->scanner) it->scanner->io_disconnected(); else @@ -864,18 +875,7 @@ scanner_err hg_scanner_mgr::hg_scanner_get_parameter(scanner_handle h, const cha 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; + return (scanner_err)utils::copy_log_file_to(data); } else return SCANNER_ERR_ACCESS_DENIED; @@ -978,9 +978,7 @@ scanner_err hg_scanner_mgr::hg_scanner_set_parameter(scanner_handle h, const cha { if (user_ == ADMIN_NAME && pwd_ == ADMIN_PWD) { - hg_log::clear_log(); - - return SCANNER_ERR_OK; + return (scanner_err)utils::clear_log_file(); } return SCANNER_ERR_ACCESS_DENIED; @@ -1067,14 +1065,15 @@ scanner_err hg_scanner_mgr::hg_scanner_control(scanner_handle h, unsigned long c if (!data) return SCANNER_ERR_INVALID_PARAMETER; - std::string f(hg_log::log_file_path()); + std::string f(utils::temporary_path() + PATH_SEPARATOR + "scanner-tmplog.txt"); - if (f.empty()) + int ret = utils::copy_log_file_to(f.c_str()); + if (ret) *((char*)data) = 0; else strcpy((char*)data, f.c_str()); - return SCANNER_ERR_OK; + return (scanner_err)ret; } else if (!h) return SCANNER_ERR_INVALID_PARAMETER; diff --git a/hgdriver/hgdev/usb_manager.cpp b/hgdriver/hgdev/usb_manager.cpp index e8a67ef..caea087 100644 --- a/hgdriver/hgdev/usb_manager.cpp +++ b/hgdriver/hgdev/usb_manager.cpp @@ -1,5 +1,8 @@ #include "usb_manager.h" -#include "../wrapper/hg_log.h" + +#include "../../sdk/hginclude/utils.h" +#include "../../sdk/hginclude/huagaoxxx_warraper_ex.h" +#include #include #define IF_CLASS(code, cls) \ @@ -29,7 +32,7 @@ usb_manager::usb_manager() : run_(true) int ret = libusb_init(&context_); // libusb_set_log_cb(context_, &usb_manager::usb_log_callback, LIBUSB_LOG_CB_CONTEXT); // LIBUSB_API_VERSION >= 0x01000107 - VLOG_MINI_4(LOG_LEVEL_DEBUG_INFO, "usb_manager(%s) libusb_init(%s) = %s, context = %s\n", hg_log::format_ptr(this).c_str(), hg_log::format_ptr(&context_).c_str(), libusb_error_name(ret), hg_log::format_ptr(context_).c_str()); + utils::to_log(LOG_LEVEL_DEBUG, "usb_manager(%p) libusb_init(%p) = %s, context = %p\n", this, &context_, libusb_error_name(ret), context_); if (ret) status_ = SCANNER_ERR_USB_INIT_FAILED; @@ -62,7 +65,7 @@ usb_manager::~usb_manager() usb_notify_thread_.reset(); } libusb_exit(context_); - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "usb_manager(%s) destroying and free context(%s)\n", hg_log::format_ptr(this).c_str(), hg_log::format_ptr(context_).c_str()); + utils::to_log(LOG_LEVEL_DEBUG, "usb_manager(%p) destroying and free context(%p)\n", this, context_); } int LIBUSB_CALL usb_manager::usb_pnp_callback(libusb_context* ctx, libusb_device* device, libusb_hotplug_event event, void* monitor) @@ -85,11 +88,11 @@ void usb_manager::usb_log_callback(libusb_context* ctx, libusb_log_level level, // used when LIBUSB_API_VERSION >= 0x01000107 if (level == LIBUSB_LOG_LEVEL_NONE || LIBUSB_LOG_LEVEL_INFO || LIBUSB_LOG_LEVEL_DEBUG) { - LOG_INFO(LOG_LEVEL_DEBUG_INFO, str); + utils::log_info(str, LOG_LEVEL_DEBUG); } else { - LOG_INFO(LOG_LEVEL_FATAL, str); + utils::log_info(str, LOG_LEVEL_FATAL); } } @@ -110,7 +113,7 @@ int usb_manager::register_usb_pnp(void) if (ret != LIBUSB_SUCCESS) { - LOG_INFO(LOG_LEVEL_FATAL, (std::string("regist usbhotplug callback error msg: ") + libusb_error_name(ret) + "\n").c_str()); + utils::to_log(LOG_LEVEL_FATAL, "regist usbhotplug callback error msg: %s\n", libusb_error_name(ret)); usb_cb_handle_ = NULL; status_ = SCANNER_ERR_USB_REGISTER_PNP_FAILED; } @@ -227,7 +230,7 @@ void usb_manager::notify_usb_event(PNPDEV& pd, bool* retry) sprintf(buf, "0x%x", pd.event); evstr = buf; } - VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "USB%u.%x of pid:vid(%x:%x) event(%s) received.\n" + utils::to_log(LOG_LEVEL_DEBUG, "USB%u.%x of pid:vid(%x:%x) event(%s) received.\n" , HIBYTE(ud.ver), LOBYTE(ud.ver) / 0x10, ud.pid, ud.vid, evstr.c_str()); if (ev != USB_EVENT_NULL) { @@ -261,7 +264,7 @@ void usb_manager::thread_trigger_usb_event() { // ^_^ devices.clear(); - LOG_INFO(LOG_LEVEL_DEBUG_INFO, "register_usb_pnp success ^_^\n"); + utils::log_info("register_usb_pnp success ^_^\n", LOG_LEVEL_DEBUG); break; } } @@ -273,7 +276,7 @@ void usb_manager::thread_trigger_usb_event() timeval tm={1,0}; int ret=libusb_handle_events_timeout(context_, &tm); if(ret < 0) - LOG_INFO(LOG_LEVEL_FATAL, (std::string("libusb_handle_events_timeout error ") + libusb_error_name(ret) + "\n").c_str()); + utils::to_log(LOG_LEVEL_FATAL, "libusb_handle_events_timeout error %s\n", libusb_error_name(ret)); std::this_thread::sleep_for(std::chrono::milliseconds(10)); } @@ -412,13 +415,12 @@ void usb_manager::enum_endpoints(libusb_device* device, USBTRANSENDP* endp) { libusb_device_descriptor desc; libusb_config_descriptor *conf = NULL; - std::string dev(hg_log::format_ptr(device)); int ret = libusb_get_device_descriptor(device, &desc); bool found_ep = false; if (ret != 0) { - LOG_INFO(LOG_LEVEL_WARNING, (std::string("Get device descriptor of device(") + dev + ") failed.\n").c_str()); + utils::to_log(LOG_LEVEL_WARNING, "Get device descriptor of device(%p) failed.\n", device); return; } @@ -432,26 +434,26 @@ void usb_manager::enum_endpoints(libusb_device* device, USBTRANSENDP* endp) usb_manager::init_endpoint(&endp->isochronous); } else - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, " +Device(%s) has %u configurations ...\n", dev.c_str(), desc.bNumConfigurations); + utils::to_log(LOG_LEVEL_DEBUG, " +Device(%p) has %u configurations ...\n", device, desc.bNumConfigurations); for (int i = 0; i < (int)desc.bNumConfigurations; ++i) { ret = libusb_get_config_descriptor(device, i, &conf); if (ret != 0) { if (!endp) - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, " Get %d configuration failed.\n", i + 1); + utils::to_log(LOG_LEVEL_DEBUG, " Get %d configuration failed.\n", i + 1); continue; } if (!endp) - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, " Configuration %d has %d interfaces\n", i + 1, conf->bNumInterfaces); + utils::to_log(LOG_LEVEL_DEBUG, " Configuration %d has %d interfaces\n", i + 1, conf->bNumInterfaces); for (int j = 0; j < conf->bNumInterfaces; ++j) { if (!endp) - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, " Interface %d has %d alt-settings\n", j + 1, conf->interface[j].num_altsetting); + utils::to_log(LOG_LEVEL_DEBUG, " Interface %d has %d alt-settings\n", j + 1, conf->interface[j].num_altsetting); for (int k = 0; k < conf->interface[j].num_altsetting; ++k) { if (!endp) - VLOG_MINI_4(LOG_LEVEL_DEBUG_INFO, " Setting %d: %d - %s has %d endpoints\n", k + 1, conf->interface[j].altsetting[k].bInterfaceNumber + utils::to_log(LOG_LEVEL_DEBUG, " Setting %d: %d - %s has %d endpoints\n", k + 1, conf->interface[j].altsetting[k].bInterfaceNumber , usb_manager::device_class((libusb_class_code)conf->interface[j].altsetting[k].bInterfaceClass).c_str() , conf->interface[j].altsetting[k].bNumEndpoints); for (int l = 0; l < conf->interface[j].altsetting[k].bNumEndpoints; ++l) @@ -462,27 +464,27 @@ void usb_manager::enum_endpoints(libusb_device* device, USBTRANSENDP* endp) if (conf->interface[j].altsetting[k].endpoint[l].bmAttributes == LIBUSB_TRANSFER_TYPE_CONTROL) { - VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "Found endpoint(%x) for device(VID: %x, PID: %x) of control\n", conf->interface[j].altsetting[k].endpoint[l].bEndpointAddress, desc.idVendor, desc.idProduct); + utils::to_log(LOG_LEVEL_DEBUG, "Found endpoint(%x) for device(VID: %x, PID: %x) of control\n", conf->interface[j].altsetting[k].endpoint[l].bEndpointAddress, desc.idVendor, desc.idProduct); ep = &endp->control; } else if (conf->interface[j].altsetting[k].endpoint[l].bmAttributes == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS) { - VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "Found endpoint(%x) for device(VID: %x, PID: %x) of isochronous\n", conf->interface[j].altsetting[k].endpoint[l].bEndpointAddress, desc.idVendor, desc.idProduct); + utils::to_log(LOG_LEVEL_DEBUG, "Found endpoint(%x) for device(VID: %x, PID: %x) of isochronous\n", conf->interface[j].altsetting[k].endpoint[l].bEndpointAddress, desc.idVendor, desc.idProduct); ep = &endp->isochronous; } if (conf->interface[j].altsetting[k].endpoint[l].bmAttributes == LIBUSB_TRANSFER_TYPE_BULK) { - VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "Found endpoint(%x) for device(VID: %x, PID: %x) of bulk\n", conf->interface[j].altsetting[k].endpoint[l].bEndpointAddress, desc.idVendor, desc.idProduct); + utils::to_log(LOG_LEVEL_DEBUG, "Found endpoint(%x) for device(VID: %x, PID: %x) of bulk\n", conf->interface[j].altsetting[k].endpoint[l].bEndpointAddress, desc.idVendor, desc.idProduct); ep = &endp->bulk; } if (conf->interface[j].altsetting[k].endpoint[l].bmAttributes == LIBUSB_TRANSFER_TYPE_INTERRUPT) { - VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "Found endpoint(%x) for device(VID: %x, PID: %x) of interrupt\n", conf->interface[j].altsetting[k].endpoint[l].bEndpointAddress, desc.idVendor, desc.idProduct); + utils::to_log(LOG_LEVEL_DEBUG, "Found endpoint(%x) for device(VID: %x, PID: %x) of interrupt\n", conf->interface[j].altsetting[k].endpoint[l].bEndpointAddress, desc.idVendor, desc.idProduct); ep = &endp->interrupt; } if (conf->interface[j].altsetting[k].endpoint[l].bmAttributes == LIBUSB_TRANSFER_TYPE_BULK_STREAM) { - VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "Found endpoint(%x) for device(VID: %x, PID: %x) of bulk-stream\n", conf->interface[j].altsetting[k].endpoint[l].bEndpointAddress, desc.idVendor, desc.idProduct); + utils::to_log(LOG_LEVEL_DEBUG, "Found endpoint(%x) for device(VID: %x, PID: %x) of bulk-stream\n", conf->interface[j].altsetting[k].endpoint[l].bEndpointAddress, desc.idVendor, desc.idProduct); ep = &endp->bulk_stream; } if (ep) @@ -493,7 +495,7 @@ void usb_manager::enum_endpoints(libusb_device* device, USBTRANSENDP* endp) else s = &ep->out; // = (conf->interface[j].altsetting[k].endpoint[l].bEndpointAddress & 3) | LIBUSB_ENDPOINT_OUT; - // NOTE: 这里应该尽量将输入输出端口统一到同一个接口上来，目前未做，只取第一? + // NOTE: 这里应该尽量将输入输出端口统一到同一个接口上来，目前未做，只取第一�? if (s->port == usb_manager::uninit_uint8) { s->port = conf->interface[j].altsetting[k].endpoint[l].bEndpointAddress & (LIBUSB_ENDPOINT_IN | LIBUSB_ENDPOINT_OUT | 3); @@ -501,14 +503,14 @@ void usb_manager::enum_endpoints(libusb_device* device, USBTRANSENDP* endp) s->iface = j; s->claimed = 0; s->max_packet = conf->interface[j].altsetting[k].endpoint[l].wMaxPacketSize; - VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, " Endpoint address = 0x%02x, origin = 0x%02x, max packet: 0x%x\n", s->port, conf->interface[j].altsetting[k].endpoint[l].bEndpointAddress + utils::to_log(LOG_LEVEL_DEBUG, " Endpoint address = 0x%02x, origin = 0x%02x, max packet: 0x%x\n", s->port, conf->interface[j].altsetting[k].endpoint[l].bEndpointAddress , s->max_packet); } found_ep = true; } } else - VLOG_MINI_4(LOG_LEVEL_DEBUG_INFO, " Endpoint %d(%s) address: %x, Max packet: 0x%x bytes\n", l + 1 + utils::to_log(LOG_LEVEL_DEBUG, " Endpoint %d(%s) address: %x, Max packet: 0x%x bytes\n", l + 1 , usb_manager::endpoint_type((libusb_transfer_type)conf->interface[j].altsetting[k].endpoint[l].bmAttributes).c_str() , conf->interface[j].altsetting[k].endpoint[l].bEndpointAddress , conf->interface[j].altsetting[k].endpoint[l].wMaxPacketSize); @@ -519,7 +521,7 @@ void usb_manager::enum_endpoints(libusb_device* device, USBTRANSENDP* endp) } if (endp && !found_ep) - VLOG_MINI_2(LOG_LEVEL_FATAL, "No endpoint has been found on device (VID: %x, PID: %x)\n", desc.idVendor, desc.idProduct); + utils::to_log(LOG_LEVEL_FATAL, "No endpoint has been found on device (VID: %x, PID: %x)\n", desc.idVendor, desc.idProduct); } int usb_manager::register_hotplug(usb_event_handler cb, void* user) @@ -558,7 +560,7 @@ int usb_manager::open(libusb_device* device, usb_io** usbio, std::string* msg) if (msg) *msg = usb->init_error_msg(); usb->release(); - VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "Open %04x:%04x failed: %s\n", dev.vid, dev.pid, hg_scanner_err_name(err)); + utils::to_log(LOG_LEVEL_DEBUG, "Open %04x:%04x failed: %s\n", dev.vid, dev.pid, hg_scanner_err_name(err)); return err; } @@ -630,7 +632,7 @@ bool usb_io::make_singleton(void) str.insert(0, "\350\256\276\345\244\207\345\267\262\347\273\217\350\242\253\350\277\233\347\250\213 '"); str += "' \345\215\240\347\224\250"; init_err_msg_ = str; - VLOG_MINI_1(LOG_LEVEL_FATAL, "Open failed: %s\n", str.c_str()); + utils::to_log(LOG_LEVEL_FATAL, "Open failed: %s\n", str.c_str()); return false; } @@ -651,38 +653,38 @@ bool usb_io::claim_interterface(usb_manager::USBSIMPLEX* spl) return true; } - VLOG_MINI_2(LOG_LEVEL_FATAL, "libusb_claim_interface(%d) = %s, now try some actions ...\n", spl->iface, libusb_error_name(ret)); + utils::to_log(LOG_LEVEL_FATAL, "libusb_claim_interface(%d) = %s, now try some actions ...\n", spl->iface, libusb_error_name(ret)); ret = libusb_kernel_driver_active(handle_, spl->iface); if (ret == 1) { ret = libusb_detach_kernel_driver(handle_, spl->iface); - VLOG_MINI_2(LOG_LEVEL_FATAL, " libusb_detach_kernel_driver(%d) = %s\n", spl->iface, libusb_error_name(ret)); + utils::to_log(LOG_LEVEL_FATAL, " libusb_detach_kernel_driver(%d) = %s\n", spl->iface, libusb_error_name(ret)); } else if (ret == LIBUSB_ERROR_NO_DEVICE) { last_err_ = SCANNER_ERR_DEVICE_NOT_FOUND; - VLOG_MINI_1(LOG_LEVEL_FATAL, " device(%s) maybe left when libusb_kernel_driver_active.\n", hg_log::format_ptr(dev_info_.device).c_str()); + utils::to_log(LOG_LEVEL_FATAL, " device(%p) maybe left when libusb_kernel_driver_active.\n", dev_info_.device); return false; } else { - VLOG_MINI_2(LOG_LEVEL_FATAL, " libusb_kernel_driver_active(%d) = %d\n", spl->iface, ret); + utils::to_log(LOG_LEVEL_FATAL, " libusb_kernel_driver_active(%d) = %d\n", spl->iface, ret); } ret = libusb_clear_halt(handle_, spl->port); - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, " libusb_clear_halt(%x) = %s\n", spl->port, libusb_error_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, " libusb_clear_halt(%x) = %s\n", spl->port, libusb_error_name(ret)); ret = libusb_release_interface(handle_, spl->iface); - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, " libusb_release_interface(%u) = %s\n", spl->iface, libusb_error_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, " libusb_release_interface(%u) = %s\n", spl->iface, libusb_error_name(ret)); ret = libusb_set_configuration(handle_, spl->iconf); - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, " libusb_set_configuration(%u) = %s\n", spl->iconf, libusb_error_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, " libusb_set_configuration(%u) = %s\n", spl->iconf, libusb_error_name(ret)); //ret = libusb_reset_device(handle_); - //VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, " libusb_reset_device = %s\n", libusb_error_name(ret)); + //utils::to_log(LOG_LEVEL_DEBUG, " libusb_reset_device = %s\n", libusb_error_name(ret)); //if (ret == LIBUSB_ERROR_NOT_FOUND) //{ // last_err_ = usb_manager::usb_error_2_hg_err(ret); - // VLOG_MINI_1(LOG_LEVEL_FATAL, "device(%s) maybe left when libusb_reset_device.\n", hg_log::format_ptr(dev_info_.device).c_str()); + // utils::to_log(LOG_LEVEL_FATAL, "device(%s) maybe left when libusb_reset_device.\n", hg_log::format_ptr(dev_info_.device).c_str()); // // return false; //} @@ -692,11 +694,11 @@ bool usb_io::claim_interterface(usb_manager::USBSIMPLEX* spl) if (ret == LIBUSB_SUCCESS) { spl->claimed = true; - VLOG_MINI_2(LOG_LEVEL_FATAL, "second libusb_claim_interface(%d) = %s\n", spl->iface, libusb_error_name(ret)); + utils::to_log(LOG_LEVEL_FATAL, "second libusb_claim_interface(%d) = %s\n", spl->iface, libusb_error_name(ret)); return true; } - VLOG_MINI_2(LOG_LEVEL_FATAL, "second try libusb_claim_interface(%d) = %s\n", spl->iface, libusb_error_name(ret)); + utils::to_log(LOG_LEVEL_FATAL, "second try libusb_claim_interface(%d) = %s\n", spl->iface, libusb_error_name(ret)); last_err_ = SCANNER_ERR_USB_CLAIM_INTERFACE_FAILED; return false; @@ -717,7 +719,7 @@ int usb_io::claim_interfaces(bool claim) break; claimed.push_back(eps[i]->in.iface); - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "claimed %s interface %d\n", usb_manager::endpoint_type((libusb_transfer_type)i).c_str(), eps[i]->in.iface); + utils::to_log(LOG_LEVEL_DEBUG, "claimed %s interface %d\n", usb_manager::endpoint_type((libusb_transfer_type)i).c_str(), eps[i]->in.iface); } if (eps[i]->out.port != usb_manager::uninit_uint8 && eps[i]->out.iface != eps[i]->in.iface && std::find(claimed.begin(), claimed.end(), eps[i]->out.iface) == claimed.end()) @@ -725,7 +727,7 @@ int usb_io::claim_interfaces(bool claim) if (!claim_interterface(&eps[i]->out)) break; claimed.push_back(eps[i]->out.iface); - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "claimed %s interface %d\n", usb_manager::endpoint_type((libusb_transfer_type)i).c_str(), eps[i]->out.iface); + utils::to_log(LOG_LEVEL_DEBUG, "claimed %s interface %d\n", usb_manager::endpoint_type((libusb_transfer_type)i).c_str(), eps[i]->out.iface); } } } @@ -766,8 +768,7 @@ void usb_io::open(void) ref_device_ = libusb_ref_device(dev_info_.device); int ret = libusb_open(dev_info_.device, &handle_); - VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "call libusb_open(%s, %s) = %s\n", hg_log::format_ptr(dev_info_.device).c_str() - , hg_log::format_ptr(handle_).c_str(), libusb_error_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "call libusb_open(%p, %p) = %s\n", dev_info_.device, handle_, libusb_error_name(ret)); if (ret == LIBUSB_SUCCESS) { init_after_open(); @@ -782,7 +783,7 @@ void usb_io::open(void) return; } last_err_ = usb_manager::usb_error_2_hg_err(ret); - VLOG_MINI_4(LOG_LEVEL_FATAL, "Open USB%u.%u-%s failed: %s\n", HIBYTE(dev_info_.ver), LOBYTE(dev_info_.ver) / 0x10, hg_log::format_ptr(dev_info_.device).c_str(), libusb_error_name(ret)); + utils::to_log(LOG_LEVEL_FATAL, "Open USB%u.%u-%p failed: %s\n", HIBYTE(dev_info_.ver), LOBYTE(dev_info_.ver) / 0x10, dev_info_.device, libusb_error_name(ret)); init_err_msg_ = hg_scanner_err_description(last_err_); handle_ = NULL; } @@ -794,8 +795,8 @@ bool usb_io::on_io_error(scanner_err err, usb_manager::USBSIMPLEX* endp) if (err == SCANNER_ERR_TIMEOUT) { - //因为在发送img参数出现timeout，暂时禁? - // //LOG_INFO(LOG_LEVEL_DEBUG_INFO, "Operation timeout\n"); + //因为在发送img参数出现timeout，暂时禁�? + // //utils::log_info(LOG_LEVEL_DEBUG, "Operation timeout\n"); // libusb_clear_halt(handle_, endp->port); // return libusb_reset_device(handle_) == LIBUSB_SUCCESS; @@ -861,7 +862,7 @@ int usb_io::control_io(uint8_t type, uint8_t req, uint16_t val, uint16_t ind, vo //} //else *len = 0; - VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "libusb_control_transfer(%x, %x, %d, %d) = %s\n", type, req, val, ind, libusb_error_name(ret)); + utils::to_log(LOG_LEVEL_DEBUG, "libusb_control_transfer(%x, %x, %d, %d) = %s\n", type, req, val, ind, libusb_error_name(ret)); last_err_ = usb_manager::usb_error_2_hg_err(ret); } @@ -894,14 +895,14 @@ int usb_io::read_bulk(void* buf, int* len) if (err) { - VLOG_MINI_4(LOG_LEVEL_DEBUG_INFO, "read_bulk(%x, %d/%d) = %s\n", endpoints_.bulk.in.port, total, *len, libusb_error_name(err)); + utils::to_log(LOG_LEVEL_DEBUG, "read_bulk(%x, %d/%d) = %s\n", endpoints_.bulk.in.port, total, *len, libusb_error_name(err)); if (err == LIBUSB_ERROR_TIMEOUT && *len == total) { int old = to_; if(to_ < 10 * 1000) to_ *= 1.5f; //err = LIBUSB_SUCCESS; - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, " Read full length, we consider it as success, and increament timeout from %d to %d\n", old, to_); + utils::to_log(LOG_LEVEL_DEBUG, " Read full length, we consider it as success, and increament timeout from %d to %d\n", old, to_); } } *len = total; @@ -930,7 +931,7 @@ int usb_io::write_bulk(void* buf, int* len) err = usb_manager::usb_error_2_hg_err(libusb_bulk_transfer(handle_, endpoints_.bulk.out.port, data, *len, &t, to_)); - //VLOG_MINI_6(LOG_LEVEL_DEBUG_INFO, "First write port %x bulk %d/%d = %s(timeout = %d, packet size = %x)\n", endpoints_.bulk.out.port, t, *len, hg_scanner_err_name((scanner_err)err).c_str(), to_, endpoints_.bulk.out.max_packet); + //VLOG_MINI_6(LOG_LEVEL_DEBUG, "First write port %x bulk %d/%d = %s(timeout = %d, packet size = %x)\n", endpoints_.bulk.out.port, t, *len, hg_scanner_err_name((scanner_err)err).c_str(), to_, endpoints_.bulk.out.max_packet); // printf("First write port %x bulk %d/%d = %s(timeout = %d, packet size = %x)\n", endpoints_.bulk.out.port, t, *len, hg_scanner_err_name((scanner_err)err).c_str(), to_, endpoints_.bulk.out.max_packet); if (!on_io_error((scanner_err)err, &endpoints_.bulk.out)) { @@ -949,7 +950,7 @@ int usb_io::write_bulk(void* buf, int* len) err = usb_manager::usb_error_2_hg_err(libusb_bulk_transfer(handle_, endpoints_.bulk.out.port, data, *len - total, &t, to_)); total += t; } - //VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "Last write bulk %d/%d = %s\n", total, *len, hg_scanner_err_name((scanner_err)err).c_str()); + //utils::to_log(LOG_LEVEL_DEBUG, "Last write bulk %d/%d = %s\n", total, *len, hg_scanner_err_name((scanner_err)err).c_str()); *len = total; last_err_ = err; diff --git a/hgdriver/wrapper/CMakeLists.txt b/hgdriver/wrapper/CMakeLists.txt index 7b399e2..c875ea6 100644 --- a/hgdriver/wrapper/CMakeLists.txt +++ b/hgdriver/wrapper/CMakeLists.txt @@ -13,7 +13,7 @@ add_compile_options(-std=c++11) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC -O2") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC -O2") aux_source_directory(${PROJECT_SOURCE_DIR} DIR_SRCS) -file(GLOB DIR_HEADS "${PROJECT_SOURCE_DIR}/*.h" "${PROJECT_SOURCE_DIR}/*.hpp") +file(GLOB DIR_HEADS "${PROJECT_SOURCE_DIR}/*.h" "${PROJECT_SOURCE_DIR}/*.hpp" "${PROJECT_SOURCE_DIR}/../../sdk/hginclude/*.h" "${PROJECT_SOURCE_DIR}/../../sdk/hginclude/*.cpp") set(DIR_SRCS ${DIR_SRCS} ${DIR_HEADS}) if(COMMAND cmake_policy) cmake_policy(SET CMP0003 NEW) @@ -97,7 +97,8 @@ target_include_directories(${PROJECT_NAME} PRIVATE ${PROJECT_SOURCE_DIR} ${PROJECT_SOURCE_DIR}/../3rdparty/tiff/include ${PROJECT_SOURCE_DIR}/../ImageProcess ${PROJECT_SOURCE_DIR}/../hgdev - ${PROJECT_SOURCE_DIR}/../wrapper + ${PROJECT_SOURCE_DIR}/../wrapper + ${PROJECT_SOURCE_DIR}/../sdk/hginclude ${PROJECT_SOURCE_DIR}/../../../sdk/include ) set(LIBRARY_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/../../../release/uos/${CMAKE_SYSTEM_PROCESSOR}) diff --git a/hgdriver/wrapper/hg_log.cpp b/hgdriver/wrapper/hg_log.cpp deleted file mode 100644 index 10f770d..0000000 --- a/hgdriver/wrapper/hg_log.cpp +++ /dev/null @@ -1,889 +0,0 @@ -#include -#include -#include -#include -#include -#include -#include - -#if defined(WIN32) || defined(_WIN64) -#include -#include -#include -#include -#include -#define MKDIR(a, b) mkdir(a) -#pragma comment(lib, "imagehlp.lib") -#pragma comment(lib, "Psapi.lib") -#pragma comment(lib, "shlwapi.lib") -#else -#define MKDIR(a, b) mkdir(a, b) -#include -#include -#include -#include -#include -#include -#endif -#include -#include "../wrapper/hg_log.h" -#include -#include -#include "ini_file.h" -#define VMRSS_LINE 21 //ʵڴʹ -#define MAX_LOG_FILE_SIZE 10 * 1024 * 1024 -#ifdef _INTSIZEOF -#undef _INTSIZEOF -#define _INTSIZEOF(n) ((sizeof(n) + sizeof(long) - 1) & ~(sizeof(long) - 1)) -#endif - - -extern std::string g_scanner_path; // Ending with '\\' -static std::string log_divider("=========================================================================\n"); - -class log_cls -{ - typedef void(*log_to)(const char*, void*, void*); - - std::string path_file_; - FILE* file_; - log_to log_; - int level_; - log_callback lcb_; - std::mutex lock_; - - static log_cls* inst_; - - static FILE* create_log_file(const char* path_file, bool truncate) - { - FILE* file_ = fopen(path_file, "a+b"); - - if (file_) - { - fseek(file_, 0, SEEK_END); - if (ftell(file_) == 0) - { - unsigned char bom[] = { 0x0ef, 0x0bb, 0x0bf }; - fwrite(bom, sizeof(bom), 1, file_); - } - - std::string now(g_time_tag + hg_log::current_time() + g_time_tag); - now += truncate ? " trcated.\n" : " started.\n"; - now.insert(0, log_divider); - fwrite(now.c_str(), 1, now.length(), file_); - } - - return file_; - } - static void log_none(const char* info, void* param, void* param2) - {} - static void log_consonle(const char* info, void* param, void* param2) - { - printf(info); - } - static void log_file(const char* info, void* param, void* param2) - { - FILE** file = (FILE**)param; - - if(*file == nullptr) - *file = create_log_file(((std::string*)param2)->c_str(), false); - - if (*file) - { - fwrite(info, 1, strlen(info), *file); - fflush(*file); - if (ftell(*file) >= MAX_LOG_FILE_SIZE) - { - fclose(*file); - remove(((std::string*)param2)->c_str()); - *file = create_log_file(((std::string*)param2)->c_str(), true); - } - } - } - - -protected: - log_cls() : path_file_(""), file_(0), log_(&log_cls::log_consonle), level_(LOG_LEVEL_ALL), lcb_(NULL) - {} - ~log_cls() - { - if (file_) - { - fclose(file_); - file_ = 0; - } - } - -public: - static std::string g_time_tag; - static log_cls* instance(void) - { - if (!log_cls::inst_) - log_cls::inst_ = new log_cls(); - - return log_cls::inst_; - } - - int set_log_type(int type, void* param) - { - int ret = 0; - - if (file_) - { - fclose(file_); - file_ = 0; - } - lcb_ = NULL; - log_ = NULL; - - if (type == LOG_TYPE_NONE) - log_ = &log_cls::log_none; - else if(type == LOG_TYPE_CONSOLE) - log_ = &log_cls::log_consonle; - else if (type == LOG_TYPE_FILE) - { - log_ = &log_cls::log_file; - - ret = -1; - if (param) - { - path_file_ = (char*)param; - file_ = create_log_file(path_file_.c_str(), false); - if (file_) - ret = 0; - } - } - else if (type == LOG_TYPE_CALLBACK) - { - lcb_ = (log_callback)param; - } - - if(ret != 0) - log_ = &log_cls::log_none; - - return ret; - } - void set_log_level(int level) - { - level_ = level; - } - bool is_log_level_enabled(int level) - { - return level >= level_; - } - - void log(const char* info) - { - std::lock_guard lock(lock_); - - log_(info, &file_, &path_file_); - } - std::string get_log_file_path(bool copy) - { - std::string file(""); - - if (log_ == &log_cls::log_file && file_) - { - file = path_file_; - - if (copy) - { - file += ".txt"; - - FILE* dst = fopen(file.c_str(), "wb"); - - if (!dst) - file = ""; - else - { - std::lock_guard lock(lock_); - char buf[1024] = { 0 }; - size_t l = 0; - - fseek(file_, 0, SEEK_SET); - while ((l = fread(buf, 1, sizeof(buf), file_))) - fwrite(buf, 1, l, dst); - fclose(dst); - } - } - } - - return file; - } - void clear_log(void) - { - if (log_ == &log_cls::log_file && file_) - { - std::lock_guard 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 = "====="; - -#ifdef EXPORT_AS_C -extern "C" -{ -#endif - namespace hg_log - { - static simple_ini ini_; - static log_callback lcb_ = NULL; - - typedef struct _find_file - { - std::string pattern; - std::string found; - }FINDFILE, * LPFF; - static bool on_found(const char* file, void* param) - { - LPFF lpff = (LPFF)param; - char pth = PATH_SEPARATOR[0]; - const char* name = strrchr(file, pth); - - if (name++ == nullptr) - name = file; - - std::string lc(name); - str_tolower(lc); - if (lc.find(lpff->pattern) != std::string::npos) - { - lpff->found = file; - return false; - } - - return true; - } -#if defined(WIN32) || defined(_WIN64) - static std::string u2a(const wchar_t* u, UINT cp = CP_ACP) - { - std::string a(""); - - if (u) - { - char stack[256] = { 0 }, * ansi = NULL; - int len = 0; - - len = WideCharToMultiByte(cp, 0, u, lstrlenW(u), NULL, 0, NULL, NULL); - ansi = new char[len + 2]; - len = WideCharToMultiByte(cp, 0, u, lstrlenW(u), ansi, len, NULL, NULL); - ansi[len--] = 0; - a = ansi; - delete[] ansi; - } - - return a; - } - static int enum_files(const char* dir, bool recursive, bool(*found_file)(const char* path_file, void* param), void* param) - { - int ret = 0; - HANDLE h = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, GetCurrentProcessId()); - MODULEENTRY32W pei = { 0 }; - - if (h == INVALID_HANDLE_VALUE) - ret = GetLastError(); - else - { - pei.dwSize = sizeof(pei); - if (Module32FirstW(h, &pei)) - { - do - { - std::string ansi(u2a(pei.szExePath)); - if (!found_file(ansi.c_str(), param)) - break; - pei.dwSize = sizeof(pei); - } while (Module32NextW(h, &pei)); - } - CloseHandle(h); - } - - return ret; - } -#else - static std::string link_file(const char* lnk) - { - char path[256] = { 0 }; - int len = readlink(lnk, path, sizeof(path) - 1); - - return len > 0 ? path : lnk; - } - static int enum_files(const char* dir, bool recursive, bool(*found_file)(const char* path_file, void* param), void* param) - { - int ret = 0; - DIR* pdir = nullptr; - struct dirent* ent = nullptr; - - pdir = opendir(dir); - if (!pdir) - return errno; - - while ((ent = readdir(pdir))) - { - if (ent->d_type & DT_DIR) - { - if (recursive) - { - if (strcmp(ent->d_name, ".") && strcmp(ent->d_name, "..")) - { - std::string sub(dir); - sub += "/"; - sub += ent->d_name; - ret = enum_files(sub.c_str(), recursive, found_file, param); - if (ret == 0x5e17) - break; - } - } - } - else - { - std::string file(dir); - - file += "/"; - file += ent->d_name; - if (!found_file(link_file(file.c_str()).c_str(), param)) - { - ret = 0x5e17; - break; - } - } - } - - return ret; - } - -#endif - std::string get_scanimage_ver() - { - #if defined(WIN32) || defined(_WIN64) - return ""; - #else - FILE* fp = NULL; - char buf[128] = { 0 }; - fp = popen("scanimage -V", "r"); - if (!fp) - return ""; - - int ret = fread(buf, 1, sizeof(buf) - 1, fp); - if(ret<1) - return ""; - - pclose(fp); - std::string str = buf; - 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"); - // if (!fp) - // { - // return ""; - // } - // long len = 0; - // fseek(fp, 0, SEEK_END); - // len = ftell(fp); - // fseek(fp, 0, SEEK_SET); - // char* buf = new char[len]; - // if (!buf) - // { - // return ""; - // } - // int ret = fread(buf, 1, sizeof(buf) - 1, fp); - // pclose(); - //} - std::string format_ptr(void* ptr) - { - char buf[40]; - - if (sizeof(ptr) == sizeof(int)) - { - sprintf(buf, "0x%08x", ptr); - } - else - { - unsigned int* n = (unsigned int*)&ptr; - sprintf(buf, "0x%x%08x", n[1], n[0]); - } - - return buf; - } - std::string format_current_thread_id(void) - { -#if defined(WIN32) || defined(_WIN64) - return format_ptr((void*)GetCurrentThreadId()); -#else - return format_ptr((void*)pthread_self()); -#endif - } - std::string current_time(void) - { - char buf[40] = { 0 }; - - hg_get_current_time(buf); - - return buf; - } - std::string format_size(unsigned long size) - { - char buf[40]; - - if (size > 1024 * 1024 * 1024) - { - double d = size; - - d /= 1024 * 1024 * 1024; - sprintf(buf, "%.2fGB", d); - } - else if (size > 1024 * 1024) - { - double d = size; - - d /= 1024 * 1024; - sprintf(buf, "%.2fMB", d); - } - else if (size > 1024) - { - double d = size; - - d /= 1024; - sprintf(buf, "%.1fKB", d); - } - else - { - sprintf(buf, "%u bytes", (unsigned int)size); - } - - return buf; - } - std::string u2utf8(const wchar_t* u) - { - std::string utf8(""); - -#if defined(WIN32) || defined(_WIN64) - utf8 = u2a(u, CP_UTF8); -#else -#endif - return utf8; - } - std::string pe_path(std::string* name) - { -#if defined(WIN32) || defined(_WIN64) - wchar_t path[MAX_PATH] = { 0 }, * last = NULL; - - GetModuleFileNameW(NULL, path, _countof(path) - 1); - last = wcsrchr(path, L'\\'); - if (last) - { - if (name) - *name = u2utf8(last + 1); - *last = 0; - } - - return u2utf8(path); -#else - char path[256] = { 0 }; - int len = readlink("/proc/self/exe", path, sizeof(path) - 1); - - if (len > 0 && len < sizeof(path)) - { - for (--len; len > 0; --len) - { - if (path[len] == '/') - { - path[len] = 0; - if (name) - *name = path + len + 1; - break; - } - } - } - - return path; -#endif - } - unsigned long long available_memory(void) - { -#if defined(WIN32) || defined(_WIN64) - MEMORYSTATUSEX ms; - - if (GlobalMemoryStatusEx(&ms)) - return ms.ullAvailPhys; - else - return -1; -#else - struct sysinfo si; - if (sysinfo(&si) == 0) - return si.freeram * si.mem_unit; -#endif - } - void str_tolower(std::string& str) - { - std::transform(str.begin(), str.end(), str.begin(), tolower); - } - bool create_folder(const char* fodler) - { - return MKDIR(fodler, S_IREAD | S_IWRITE | S_IEXEC) == 0 || errno == EEXIST; - } - std::string ini_get(const char* app, const char* key) - { - return ini_.get(app, key); - } - void ini_set(const char* app, const char* key, const char* val) - { - ini_.set(app, key, val); - } - - std::string get_module_full_path(const char* module_part_name) - { - char path[128] = { 0 }; - FINDFILE ff; - - ff.pattern = module_part_name; - str_tolower(ff.pattern); -#if defined(WIN32) || defined(_WIN64) -#else - sprintf(path, "/proc/%u/map_files/", getpid()); -#endif - enum_files(path, false, on_found, &ff); - - return ff.found; - } - std::string get_scanner_path(void) - { - return g_scanner_path; - } - unsigned int get_page_size(unsigned int* map_unit) - { - unsigned int ps = 1024; -#if defined(WIN32) || defined(_WIN64) - SYSTEM_INFO si = { 0 }; - - GetSystemInfo(&si); - ps = si.dwPageSize; - if (map_unit) - *map_unit = si.dwAllocationGranularity; -#else - ps = sysconf(_SC_PAGESIZE); - if(ps < 1024 || (ps & 0x0fe0000ff)) // nKB && < 16MB - ps = getpagesize(); - if (map_unit) - *map_unit = ps; -#endif - if (ps < 1024 || (ps & 0x0fe0000ff)) // nKB && < 16MB - ps = 1024; - - return ps; - } - static int get_log_config(const std::string& root, hg_log_type* type, std::string* path) - { - std::string me(root + PATH_SEPARATOR + "config" + PATH_SEPARATOR + "debug.cfg"); - int lv = LOG_LEVEL_ALL; - hg_log_type tp = LOG_TYPE_FILE; - - if (!type) - type = &tp; - *type = LOG_TYPE_FILE; - if (ini_.load(me.c_str()) == 0) - { - std::string val(ini_.get("log", "type")); - if (val == "console") - *type = LOG_TYPE_CONSOLE; - else if (val == "none") - *type = LOG_TYPE_NONE; - else - *type = LOG_TYPE_FILE; - - if (*type == LOG_TYPE_FILE && path) - { - *path = ini_.get("log", "path"); - } - - val = ini_.get("log", "level"); - if (val == "debug") - lv = LOG_LEVEL_DEBUG_INFO; - else if (val == "warning") - lv = LOG_LEVEL_WARNING; - else if (val == "fatal") - lv = LOG_LEVEL_FATAL; - } - else - create_folder((root + PATH_SEPARATOR + "config").c_str()); - - return lv; - } - std::string get_command_result(const char* cmd, int len) - { - std::string result(""); - - #if OS_WIN - #else - FILE* src = popen(cmd, "r"); - - if (src) - { - char buf[128] = { 0 }; - int rv = fread(buf, 1, sizeof(buf) - 1, src); - - while (rv > 0) - { - buf[rv] = 0; - result += buf; - if (len != -1 && result.length() >= len) - { - result.erase(len); - break; - } - rv = fread(buf, 1, sizeof(buf) - 1, src); - } - pclose(src); - } - #endif - - return std::move(result); - } - const char* trim(std::string& str, const char* sp = " \r\n\t") - { - int pos = 0; - char ch[2] = { 0 }; - - for (; pos < str.length(); ++pos) - { - ch[0] = str[pos]; - if (!strstr(sp, ch)) - break; - } - if (pos) - str.erase(0, pos); - - pos = str.length() - 1; - for (; pos >= 0; --pos) - { - ch[0] = str[pos]; - if (!strstr(sp, ch)) - break; - } - if (++pos < str.length()) - str.erase(pos); - - return str.c_str(); - } - std::string get_local_data_path(void) - { - static std::string ldp(""); - - if (ldp.empty()) - { - #if OS_WIN - const char* path(getenv("LOCALAPPDATA")); - - if (path) - { - ldp = path; - ldp += PATH_SEPARATOR; - } - #else - const char* path(getenv("HOME")); - - if (path) - { - if (strstr(path, "/root")) - { - std::string usr(get_command_result("logname", -1)); - ldp = std::string("/home/") + trim(usr); - if (!opendir(ldp.c_str())) - { - printf("opendir(%s) failed: %s\n", ldp.c_str(), strerror(errno)); - ldp = path; - } - } - else - { - ldp = path; - } - ldp += std::string(PATH_SEPARATOR) + "."; - } - #endif - - ldp += PRODUCT_VENDOR; - ldp += "Scan"; - create_folder(ldp.c_str()); - - printf("# local data path: %s\n", ldp.c_str()); - } - - return ldp; - } - std::string local_data_path(void) - { - static std::string local_data_path(""); - static bool load_first = true; - - if (load_first) - { - simple_ini first; - - load_first = false; - if (first.load((get_scanner_path() + "first.cfg").c_str()) == 0) - { - std::string env = first.get("constraints", "local_data_path"); - if (env.length()) - local_data_path = env; - } - } - - std::string home(local_data_path); - - if (home.empty()) - { - local_data_path = home = get_local_data_path(); - } - - return std::move(home); - } - std::string temporary_path(void) - { - return simple_ini::temporary_path(); - } - std::string log_file_path(void) - { - return log_cls::instance()->get_log_file_path(true); - } - - int init(void) - { - char* file = nullptr; - std::string path(""); - hg_log_type type = LOG_TYPE_FILE; - int level = get_log_config(local_data_path(), &type, &path); - - if (type == LOG_TYPE_FILE) - { - std::string name(""), - paths[] = { local_data_path(), pe_path(&name), get_scanner_path(), temporary_path()}; - int ind = 0; - - if (!path.empty() && create_folder(path.c_str())) - ind = sizeof(paths) / sizeof(paths[0]) + 2; - - for (; ind < sizeof(paths) / sizeof(paths[0]); ++ind) - { - path = paths[ind] + PATH_SEPARATOR + "Log"; - if (create_folder(path.c_str())) - break; - } - if(ind == sizeof(paths) / sizeof(paths[0])) - { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "# Try PE, scanner and temporary path failed(%d), log to console\n", errno); - type = LOG_TYPE_CONSOLE; - } - - if (type == LOG_TYPE_FILE) - { - if (name.empty()) - path += std::string(PATH_SEPARATOR) + "scanner.log"; - else - path += PATH_SEPARATOR + name + ".log"; - file = &path[0]; - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "# Log to file: '%s'\n", path.c_str()); - } - } - log_cls::instance()->set_log_level(level); - - return log_cls::instance()->set_log_type(type, file); - } - void unint(void) - { - std::string now(log_cls::g_time_tag + hg_log::current_time() + log_cls::g_time_tag + " exited.\n"); - log(now.c_str()); - log((log_divider + "\n\n\n\n").c_str()); - } - void log(int level, const char* info) - { - if (lcb_) - lcb_(level, info); - else if (log_cls::instance()->is_log_level_enabled(level)) - log_cls::instance()->log(info); - } - bool is_log_level_enabled(int level) - { - return log_cls::instance()->is_log_level_enabled(level); - } - void log(const char* info) - { - log_cls::instance()->log(info); - } - float GetMemoryUsage(int pid) - { -#ifdef WIN32 - uint64_t mem = 0, vmem = 0; - PROCESS_MEMORY_COUNTERS pmc; - - HANDLE process = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid); - if (GetProcessMemoryInfo(process, &pmc, sizeof(pmc))) - { - mem = pmc.WorkingSetSize; - vmem = pmc.PagefileUsage; - } - CloseHandle(process); - - return mem / 1024.0 / 1024.0;//byte TO MB - -#else - char file_name[64] = { 0 }; - FILE* fd; - char line_buff[512] = { 0 }; - sprintf(file_name, "/proc/%d/status", pid); - - fd = fopen(file_name, "r"); - if (nullptr == fd) - return 0; - - char name[64]; - int vmrss = 0; - for (int i = 0; i < VMRSS_LINE - 1; i++) - fgets(line_buff, sizeof(line_buff), fd); - - fgets(line_buff, sizeof(line_buff), fd); - sscanf(line_buff, "%s %d", name, &vmrss); - fclose(fd); - return vmrss / 1024.0;//KB TO MB -#endif -} - float GetAppMemoryUsage() - { - return GetMemoryUsage(getpid()); - } - - const char* lang_load(uint32_t id) - { - int err = 0; - const char *lang = lang_load_string(id, &err); - if (err != 0) - { - return ""; - } - return lang; - } - - - } -#ifdef EXPORT_AS_C -} -#endif - -#if defined(WIN32) || defined(_WIN64) -void hg_debug_log(int level, const char* info) -{ - hg_log::log(level, info); -} -#endif - diff --git a/hgdriver/wrapper/hg_log.h b/hgdriver/wrapper/hg_log.h deleted file mode 100644 index 3813b15..0000000 --- a/hgdriver/wrapper/hg_log.h +++ /dev/null @@ -1,84 +0,0 @@ -// this file is include huagao logging tools -// -// created: 2022-02-09 -// - -#pragma once - -#include -#include "../../sdk/hginclude/huagaoxxx_warraper_ex.h" -#include "lang/app_language.h" -#if defined(WIN32) || defined(_WIN64) -#define bzero(a, l) memset(a, 0, l) -#define PATH_SEPARATOR "\\" -#define DLL_EXTESION ".dll" -#define STRICMP stricmp -#else -#include -#define PATH_SEPARATOR "/" -#define DLL_EXTESION ".so" -#define STRICMP strcasecmp -#endif - -//#ifdef OEM_HANWANG -//#define hg_log hw_log -//#define hg_log_type hw_log_type -//#elif defined(OEM_LISICHENG) -//#define hg_log lsc_log -//#define hg_log_type lsc_log_type -//#endif - -enum hg_log_type -{ - LOG_TYPE_NONE = 0, // no logging - LOG_TYPE_CONSOLE, // print to console - LOG_TYPE_FILE, // write log into file - LOG_TYPE_CALLBACK, // invoke callback log_callback -}; - -typedef void (*log_callback)(int, const char* info); - -#ifdef EXPORT_AS_C -extern "C" -{ -#endif - namespace hg_log - { - std::string format_ptr(void* ptr); - std::string format_current_thread_id(void); - std::string current_time(void); - std::string format_size(unsigned long size); - std::string u2utf8(const wchar_t* u); - std::string pe_path(std::string* name = nullptr); - std::string get_module_full_path(const char* module_part_name); - std::string get_scanner_path(void); - std::string local_data_path(void); - 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); - unsigned int get_page_size(unsigned int* map_unit = nullptr); - unsigned long long available_memory(void); - void str_tolower(std::string& str); - bool create_folder(const char* fodler); - - std::string ini_get(const char* app, const char* key); - void ini_set(const char* app, const char* key, const char* val); - - // Function: initialize the logging type and level - // - // Return: 0 - success, or -1 in LOG_TYPE_FILE and log_file cannot be created - int init(void); - void unint(void); - - void log(int level, const char* info); - bool is_log_level_enabled(int level); - void log(const char* info); - } -#ifdef EXPORT_AS_C -} -#endif - diff --git a/hgdriver/wrapper/huagaoxxx_warraper_ex.cpp b/hgdriver/wrapper/huagaoxxx_warraper_ex.cpp index 52a2f05..b170b38 100644 --- a/hgdriver/wrapper/huagaoxxx_warraper_ex.cpp +++ b/hgdriver/wrapper/huagaoxxx_warraper_ex.cpp @@ -1,5 +1,7 @@ #include "../../sdk/hginclude/huagaoxxx_warraper_ex.h" -#include "../wrapper/hg_log.h" + +#include "../../../sdk/include/huagao/brand.h" +#include "../../sdk/hginclude/utils.h" #include "../hgdev/scanner_manager.h" #include @@ -78,30 +80,33 @@ extern "C" scanner_err hg_scanner_initialize(sane_callback callback, void* reserve) { std::string name(""), - pe(hg_log::pe_path(&name)), + pe(utils::get_module_full_path()), path(PATH_SEPARATOR), scanner(g_scanner_path), - sane(hg_log::get_module_full_path((g_sane_name + DLL_EXTESION).c_str())); -#if defined(WIN32) || defined(_WIN64) - size_t pos = g_scanner_path.rfind('\\'); - if (pos++ != std::string::npos) - g_scanner_path.erase(pos); -#else - size_t pos = 0; - g_scanner_path = hg_log::get_module_full_path((std::string(GET_BACKEND_NAME) + ".so").c_str()); + sane(utils::get_module_full_path((g_sane_name + "." + DLL_EXTESION).c_str())); + size_t pos = pe.rfind(path[0]); + + if(pos++ == std::string::npos) + pos = 0; + name = pe.substr(pos); + pe.erase(pos); + +#if !defined(WIN32) && !defined(_WIN64) + g_scanner_path = utils::get_module_full_path((std::string(SCANNER_DRIVER_PART_NAME) + "." + DLL_EXTESION).c_str()); scanner = g_scanner_path; - pos = g_scanner_path.rfind('/'); +#endif + pos = g_scanner_path.rfind(path[0]); if (pos++ != std::string::npos) g_scanner_path.erase(pos); -#endif - hg_log::init(); - VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "Module device: [%u.%u.%u.%u] - %s\n", VERSION_MAJOR, VERSION_MINOR, VERSION_YEAR, GET_BUILD_VER, scanner.c_str()); - VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "Module sane : [%s] - %s\n", g_sane_ver.c_str(), sane.c_str()); - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Module exe : %s\n", (pe + path + name).c_str()); + + utils::init_log(LOG_TYPE_FILE); + utils::to_log(LOG_LEVEL_DEBUG, "Module device: [%u.%u.%u.%u] - %s\n", VERSION_MAJOR, VERSION_MINOR, VERSION_YEAR, GET_BUILD_VER, scanner.c_str()); + utils::to_log(LOG_LEVEL_DEBUG, "Module sane : [%s] - %s\n", g_sane_ver.c_str(), sane.c_str()); + utils::to_log(LOG_LEVEL_DEBUG, "Module exe : %s\n", (pe + name).c_str()); if (lang_initialize() == -1) { - VLOG_MINI_1(LOG_LEVEL_FATAL, "No language package found(%d)!\n", -1); + utils::to_log(LOG_LEVEL_FATAL, "No language package found!\n"); return SCANNER_ERR_LANG_PAK_LOST; } register_language_changed_notify(language_changed, true); @@ -116,7 +121,7 @@ extern "C" { register_language_changed_notify(language_changed, false); hg_scanner_mgr::clear(); - hg_log::unint(); + utils::uninit(); } unsigned long long hg_scanner_get_version(void) @@ -332,78 +337,18 @@ extern "C" // NOTE: multi-thread unsafe here static char g_unk_err[80] = { 0 }; - strcpy(g_unk_err, hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_UNKNOWN_ERROR)); + strcpy(g_unk_err, from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_UNKNOWN_ERROR)); sprintf(g_unk_err + strlen(g_unk_err), ":0x%x", err); return g_unk_err; } bool hg_scanner_log_is_enable(int level) { - return hg_log::is_log_level_enabled(level); + return level >= utils::get_log_level() && utils::get_log_type() != LOG_TYPE_NONE; } void hg_scanner_log(const char* info) { - hg_log::log(info); - } - - char* get_file_path(const char* name, char* buf) - { - std::string fp(hg_log::get_module_full_path(name)); - - if (fp.empty()) - *buf = 0; - else - strcpy(buf, fp.c_str()); - - return buf; - } - - int get_disk_space(const char* path, unsigned long long* total, unsigned long long* avail, unsigned long long* block) - { - int ret = SCANNER_ERR_OK; - -#if defined(WIN32) || defined(_WIN64) - ULARGE_INTEGER av = { 0 }, - all = { 0 }; - if (GetDiskFreeSpaceExA(path, &av, &all, NULL)) - { - if (total) - *total = all.QuadPart; - if (avail) - *avail = av.QuadPart; - if (block) - { - DWORD sec = 0, - clu = 0; - std::string root(path); - size_t pos = root.find(":\\"); - if (pos != std::string::npos) - root.erase(pos + 2); - if (GetDiskFreeSpaceA(root.c_str(), &clu, &sec, NULL, NULL)) - { - *block = clu * sec; - } - } - } - else - ret = GetLastError(); -#else - struct statfs fs = { 0 }; - - ret = statfs(path, &fs); - if (ret == 0) - { - VLOG_MINI_4(LOG_LEVEL_DEBUG_INFO, " Total: %lld, Free: %lld, Avail: %lld, block size: %lld\n", - fs.f_blocks, fs.f_bfree, fs.f_bavail, fs.f_bsize); - if (total) - *total = fs.f_blocks * fs.f_bsize; - if (avail) - *avail = fs.f_bavail * fs.f_bsize; - if (block) - *block = fs.f_bsize; - } -#endif - return ret; + utils::log_info(info, LOG_LEVEL_DEBUG); } const char* hg_scanner_image_statu_name(int img_statu) @@ -420,47 +365,6 @@ extern "C" return g_unk_statu; } - void hg_get_current_time(char* tmbuf, struct tm* t) - { -#if defined(WIN32) || defined(_WIN64) - static long bias = -1; - static bool as_start = true; - - if (bias == -1) - { - _get_timezone(&bias); - as_start = hg_log::ini_get("time", "adjust") != "no"; - } -#endif - - time_t now = time(nullptr); - struct tm* l = localtime(&now); - -#if defined(WIN32) || defined(_WIN64) - long after = 0; - if (as_start && _get_timezone(&after) == 0 && - (after != bias && after != -bias)) - { - now += bias; - l = localtime(&now); - } -#endif - - if (t) - *t = *l; - if (tmbuf) - sprintf(tmbuf, "%04d-%02d-%02d %02d:%02d:%02d--->", l->tm_year + 1900, l->tm_mon + 1, l->tm_mday, l->tm_hour, l->tm_min, l->tm_sec); - } - void hg_get_current_time_w(wchar_t* tmbuf, struct tm* t) - { - struct tm tmp = { 0 }, * l = &tmp; - - hg_get_current_time(nullptr, l); - if (t) - *t = *l; - if (tmbuf) - swprintf(tmbuf, 40, L"%04d-%02d-%02d %02d:%02d:%02d--->", l->tm_year + 1900, l->tm_mon + 1, l->tm_mday, l->tm_hour, l->tm_min, l->tm_sec); - } } diff --git a/hgsane/sane_hg_mdw.cpp b/hgsane/sane_hg_mdw.cpp index 272fde2..a5bdcf7 100644 --- a/hgsane/sane_hg_mdw.cpp +++ b/hgsane/sane_hg_mdw.cpp @@ -1,4 +1,5 @@ #include "sane_hg_mdw.h" + #include "json.h" #include #include @@ -20,6 +21,7 @@ #include "../../sdk/include/sane/sane_option_definitions.h" #include "sane_option.h" #include +#include "../sdk/hginclude/utils.h" #ifndef SIGUSR1 #define SIGUSR1 10 @@ -175,7 +177,7 @@ namespace local_utility return str > bgn; } - // 暂不支持科学计数?1.2e+10 + // 暂不支持科学计数�?1.2e+10 bool get_number(const char*& str, double& val) { const char* bgn = str; @@ -452,7 +454,7 @@ namespace local_utility SANE_Handle h = hg_sane_middleware::scanner_handle_to_sane(dev); - // VLOG_MINI_1(LOG_LEVEL_ALL, "sane callback invoked of event %s\n", sane_event((SANE_Event)code).c_str()); + // utils::to_log(LOG_LEVEL_ALL, "sane callback invoked of event %s\n", sane_event((SANE_Event)code).c_str()); if (cb_ui) { @@ -540,7 +542,7 @@ hg_sane_middleware::hg_sane_middleware(void) : opt_0_(nullptr), init_ok_(false) char path[512] = { 0 }; size_t pos = 0; - g_sane_path = get_file_path((std::string(GET_BACKEND_NAME) + ".so").c_str(), path); + g_sane_path = utils::get_module_full_path((std::string(GET_BACKEND_NAME) + ".so").c_str()); pos = g_sane_path.rfind('/'); if (pos++ != std::string::npos) g_sane_path.erase(pos); @@ -614,7 +616,7 @@ const SANE_Device** hg_sane_middleware::to_sane_device(ScannerInfo* hgscanner, i COPY_DEVICE_MEMBER(type); } - //VLOG_MINI_2(LOG_LEVEL_ALL, "Memory usage: %u / %u\n", val - (char*)ret, total); + //utils::to_log(LOG_LEVEL_ALL, "Memory usage: %u / %u\n", val - (char*)ret, total); return (const SANE_Device**)ret; } @@ -629,7 +631,7 @@ void hg_sane_middleware::free_sane_device(SANE_Device** dev) } void hg_sane_middleware::device_pnp(int sig) { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Device list changed (%d)...", sig); + utils::to_log(LOG_LEVEL_DEBUG, "Device list changed (%d)...", sig); } SANE_Fixed hg_sane_middleware::double_2_sane_fixed(double v) { @@ -846,7 +848,7 @@ SANE_Option_Descriptor* hg_sane_middleware::number_option_to_SANE_descriptor(con for (size_t i = 0; i < values.size(); ++i) val[i] = values[i]; } - //VLOG_MINI_2(LOG_LEVEL_ALL, "Memory usage: %u/%u\n", str - (char*)sod, bytes); + //utils::to_log(LOG_LEVEL_ALL, "Memory usage: %u/%u\n", str - (char*)sod, bytes); return sod; } @@ -1078,7 +1080,7 @@ SANE_Option_Descriptor* hg_sane_middleware::from_json(scanner_handle h, const st lower = l; upper = u; step = s; - VLOG_MINI_4(LOG_LEVEL_DEBUG_INFO, "%s range: [%d, +%d, %d]\n", name.c_str(), l, s, u); + utils::to_log(LOG_LEVEL_DEBUG, "%s range: [%d, +%d, %d]\n", name.c_str(), l, s, u); ret = hg_sane_middleware::number_option_to_SANE_descriptor(name.c_str(), title.c_str(), desc.c_str() , false, &lower, &upper, &step); } @@ -1104,7 +1106,7 @@ SANE_Option_Descriptor* hg_sane_middleware::from_json(scanner_handle h, const st range->get_value("max", upper); step = (upper - lower) / 10.0f; range->get_value("step", step); - VLOG_MINI_4(LOG_LEVEL_DEBUG_INFO, "%s range: (%f, +%f, %f)\n", name.c_str(), lower, step, upper); + utils::to_log(LOG_LEVEL_DEBUG, "%s range: (%f, +%f, %f)\n", name.c_str(), lower, step, upper); ret = hg_sane_middleware::number_option_to_SANE_descriptor(name.c_str(), title.c_str(), desc.c_str() , true, &lower, &upper, &step); } @@ -1183,7 +1185,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; - // 关联? + // 关联�? json* depend = NULL; SLAVEOP so; if (jsn->get_value("depend_or", depend)) @@ -1481,7 +1483,7 @@ bool hg_sane_middleware::get_current_value(scanner_handle handle, const void* op if (setv == &hg_sane_middleware::set_value_to_new) value = *(void**)value; - VLOG_MINI_3(LOG_LEVEL_ALL, "<--Get option(%d - %s) value: %s\n", option, val.c_str(), hg_sane_middleware::option_value_2_string(t, value).c_str()); + utils::to_log(LOG_LEVEL_ALL, "<--Get option(%d - %s) value: %s\n", option, val.c_str(), hg_sane_middleware::option_value_2_string(t, value).c_str()); } delete jsn; @@ -1509,7 +1511,7 @@ void* hg_sane_middleware::get_default_value(scanner_handle handle, const void* o *bytes = sizeof(SANE_Bool); if (log) { - VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "option %d(%s) default value is: %s\n", option, title.c_str(), v ? "true" : "false"); + utils::to_log(LOG_LEVEL_DEBUG, "option %d(%s) default value is: %s\n", option, title.c_str(), v ? "true" : "false"); } } else if (val == "int") @@ -1523,7 +1525,7 @@ void* hg_sane_middleware::get_default_value(scanner_handle handle, const void* o *bytes = sizeof(v); if (log) { - VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "option %d(%s) default value is: %d\n", option, title.c_str(), v); + utils::to_log(LOG_LEVEL_DEBUG, "option %d(%s) default value is: %d\n", option, title.c_str(), v); } } else if (val == "float") @@ -1539,7 +1541,7 @@ void* hg_sane_middleware::get_default_value(scanner_handle handle, const void* o memcpy(data, &sd, sizeof(sd)); if (log) { - VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "option %d(%s) default value is: %f\n", option, title.c_str(), v); + utils::to_log(LOG_LEVEL_DEBUG, "option %d(%s) default value is: %f\n", option, title.c_str(), v); } } else if (val == "string") @@ -1557,12 +1559,12 @@ void* hg_sane_middleware::get_default_value(scanner_handle handle, const void* o *bytes = val.length() + 1; if (log) { - VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "option %d(%s) default value is: %s\n", option, title.c_str(), (char*)data); + utils::to_log(LOG_LEVEL_DEBUG, "option %d(%s) default value is: %s\n", option, title.c_str(), (char*)data); } } else { - VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "option %d(%s) is '%s' and no value action.\n", option, title.c_str(), val.c_str()); + utils::to_log(LOG_LEVEL_DEBUG, "option %d(%s) is '%s' and no value action.\n", option, title.c_str(), val.c_str()); } } delete jsn; @@ -1592,7 +1594,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间隙可能新增的设备预留空? + count += 4; // 为两次hg_scanner_enum间隙可能新增的设备预留空�? 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) @@ -1722,7 +1724,7 @@ SANE_Option_Descriptor* hg_sane_middleware::get_option_descriptor(SANE_Handle h, opt_0_->type = SANE_TYPE_INT; opt_0_->size = sizeof(SANE_TYPE_INT); } - LOG_INFO(LOG_LEVEL_DEBUG_INFO, "get_option_descriptor(0)\n"); + utils::log_info("get_option_descriptor(0)\n", LOG_LEVEL_DEBUG); return opt_0_; } @@ -1789,7 +1791,7 @@ SANE_Status hg_sane_middleware::set_option(SANE_Handle h, const void* option, SA hg_scanner_get_parameter(handle, (const char*)option, NULL, &count); *((SANE_Int*)value) = count; ret = SANE_STATUS_GOOD; - VLOG_MINI_1(LOG_LEVEL_WARNING, "get option count = %d.\n", count); + utils::to_log(LOG_LEVEL_WARNING, "get option count = %d.\n", count); } else { @@ -1859,7 +1861,7 @@ SANE_Status hg_sane_middleware::set_option(SANE_Handle h, const void* option, SA 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); + utils::to_log(LOG_LEVEL_WARNING, "Option %d(%s) call SANE_ACTION_SET_AUTO, we set default value.\n", option, desc->title); int len = 0; void* val = get_default_value(handle, option, &len); @@ -1884,7 +1886,7 @@ SANE_Status hg_sane_middleware::set_option(SANE_Handle h, const void* option, SA SANE_Option_Descriptor* known = dev->std_opt->get_option(id); unsigned char* cont = (unsigned char*)value; prev = hg_sane_middleware::option_value_2_string(known->type, value); - VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "$First 4-bytes of origin value for option %d is: %02X%02X%02X%02X\n", option, cont[0], cont[1], cont[2], cont[3]); + utils::to_log(LOG_LEVEL_DEBUG, "$First 4-bytes of origin value for option %d is: %02X%02X%02X%02X\n", option, cont[0], cont[1], cont[2], cont[3]); err = dev->std_opt->set_value(handle, id, value); v = hg_sane_middleware::option_value_2_string(known->type, value); } @@ -1901,14 +1903,14 @@ SANE_Status hg_sane_middleware::set_option(SANE_Handle h, const void* option, SA 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); + utils::to_log(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); + // utils::to_log(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) @@ -1917,7 +1919,7 @@ SANE_Status hg_sane_middleware::set_option(SANE_Handle h, const void* option, SA //} //else { - VLOG_MINI_2(LOG_LEVEL_WARNING, "Option descriptor %d(%s) need a value!.\n", option, desc->title); + utils::to_log(LOG_LEVEL_WARNING, "Option descriptor %d(%s) need a value!.\n", option, desc->title); return SANE_STATUS_INVAL; } @@ -1957,11 +1959,11 @@ SANE_Status hg_sane_middleware::set_option(SANE_Handle h, const void* option, SA if (prev == v) { - VLOG_MINI_3(LOG_LEVEL_ALL, "-->Set option(%d - %s) value: %s\n", option, desc_title.c_str(), v.c_str()); + utils::to_log(LOG_LEVEL_ALL, "-->Set option(%d - %s) value: %s\n", option, desc_title.c_str(), v.c_str()); } else { - VLOG_4(LOG_LEVEL_ALL, 512, "-->Set option(%d - %s) value: %s(Applied: %s)\n", option, desc_title.c_str(), prev.c_str(), v.c_str()); + utils::to_log(LOG_LEVEL_ALL, "-->Set option(%d - %s) value: %s(Applied: %s)\n", option, desc_title.c_str(), prev.c_str(), v.c_str()); } if (err == SCANNER_ERR_OK) @@ -1974,7 +1976,7 @@ SANE_Status hg_sane_middleware::set_option(SANE_Handle h, const void* option, SA } else if (err == SCANNER_ERR_CONFIGURATION_CHANGED) { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "the setting '%s' affects other options value, RELOAD ...\n", desc_title.c_str()); + utils::to_log(LOG_LEVEL_DEBUG, "the setting '%s' affects other options value, RELOAD ...\n", desc_title.c_str()); //on_SCANNER_ERR_CONFIGURATION_CHANGED(dev); if(dev->fixed_id.count(SANE_OPT_ID_LANGUAGE) == 0 || dev->fixed_id[SANE_OPT_ID_LANGUAGE] != id) // language reload by callback already reload_options(handle); @@ -1982,12 +1984,12 @@ SANE_Status hg_sane_middleware::set_option(SANE_Handle h, const void* option, SA } else if(err == SCANNER_ERR_RELOAD_IMAGE_PARAM) { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "the setting '%s' affects image parameter, APP should re-get ...\n", desc_title.c_str()); + utils::to_log(LOG_LEVEL_DEBUG, "the setting '%s' affects image parameter, APP should re-get ...\n", desc_title.c_str()); err = (scanner_err)SANE_INFO_RELOAD_PARAMS; } else if(err == SCANNER_ERR_RELOAD_OPT_PARAM) { - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "the setting '%s' affects image parameter and options, APP should re-get image info and reload options...\n", desc_title.c_str()); + utils::to_log(LOG_LEVEL_DEBUG, "the setting '%s' affects image parameter and options, APP should re-get image info and reload options...\n", desc_title.c_str()); //on_SCANNER_ERR_CONFIGURATION_CHANGED(dev); if (dev->fixed_id.count(SANE_OPT_ID_LANGUAGE) == 0 || dev->fixed_id[SANE_OPT_ID_LANGUAGE] != id) // language reload by callback already reload_options(handle); @@ -2058,7 +2060,7 @@ SANE_Status hg_sane_middleware::io_control(SANE_Handle h, unsigned long code, vo if (ret == SCANNER_ERR_CONFIGURATION_CHANGED) { int nc = code; - VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "the setting '0x%08x' affects other options value, RELOAD ...\n", nc); + utils::to_log(LOG_LEVEL_DEBUG, "the setting '0x%08x' affects other options value, RELOAD ...\n", nc); on_SCANNER_ERR_CONFIGURATION_CHANGED(dev); } @@ -2070,7 +2072,7 @@ bool hg_sane_middleware::is_ready(void) } /// -/// 关联项处? +/// 关联项处�? 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; @@ -2114,7 +2116,7 @@ bool hg_sane_middleware::is_enable_and(scanner_handle hdev, const std::vector::iterator it = std::find(curvals.begin(), curvals.end(), master[i].name); if (it == curvals.end()) { - VLOG_MINI_1(LOG_LEVEL_WARNING, "option %s's current value is not found, other options depend it maybe in wrong status.\n", master[i].name.c_str()); + utils::to_log(LOG_LEVEL_WARNING, "option %s's current value is not found, other options depend it maybe in wrong status.\n", master[i].name.c_str()); continue; } @@ -2136,7 +2138,7 @@ bool hg_sane_middleware::is_enable_or(scanner_handle hdev, const std::vector::iterator it = std::find(curvals.begin(), curvals.end(), master[i].name); if (it == curvals.end()) { - VLOG_MINI_1(LOG_LEVEL_WARNING, "option %s's current value is not found, other options depend it maybe in wrong status.\n", master[i].name.c_str()); + utils::to_log(LOG_LEVEL_WARNING, "option %s's current value is not found, other options depend it maybe in wrong status.\n", master[i].name.c_str()); continue; } @@ -2551,7 +2553,7 @@ extern "C" { // avoid compiler exporting name in C++ style !!! } SANE_Status inner_sane_start(SANE_Handle handle) { - LOG_INFO(LOG_LEVEL_ALL, "sane_start\n"); + utils::log_info("sane_start\n", LOG_LEVEL_ALL); return hg_sane_middleware::instance()->start(handle, NULL); } @@ -2566,13 +2568,13 @@ extern "C" { // avoid compiler exporting name in C++ style !!! } void inner_sane_cancel(SANE_Handle handle) { - LOG_INFO(LOG_LEVEL_ALL, "sane_cancel\n"); + utils::log_info("sane_cancel\n", LOG_LEVEL_ALL); hg_sane_middleware::instance()->stop(handle); } SANE_Status inner_sane_set_io_mode(SANE_Handle handle, SANE_Bool non_blocking) { - LOG_INFO(LOG_LEVEL_ALL, "sane_set_io_mode\n"); + utils::log_info("sane_set_io_mode\n", LOG_LEVEL_ALL); return non_blocking ? SANE_STATUS_UNSUPPORTED : SANE_STATUS_GOOD; } diff --git a/hgsane/sane_option.cpp b/hgsane/sane_option.cpp index 63fa251..12e3f26 100644 --- a/hgsane/sane_option.cpp +++ b/hgsane/sane_option.cpp @@ -1,6 +1,8 @@ #include "sane_option.h" + #include #include "../sdk/hginclude/huagaoxxx_warraper_ex.h" +#include "../sdk/hginclude/utils.h" #include "../../sdk/include/lang/app_language.h" @@ -50,7 +52,7 @@ static void match_paper(char* buf, int cx, int cy) else strcpy(buf, from_default_language(g_paper[index].title, NULL)); - VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "match paper(%u * %u) to '%s'\n", cx, cy, (char*)buf); + utils::to_log(LOG_LEVEL_DEBUG, "match paper(%u * %u) to '%s'\n", cx, cy, (char*)buf); } @@ -395,7 +397,7 @@ scanner_err sane_std_opts::set_value(scanner_handle h, int opt, void* buf) long len = 0; void* data = from_known_opt_value(op, buf, &len); - VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "%d->%d: %s\n", opt, op->user.opt, (char*)data); + utils::to_log(LOG_LEVEL_DEBUG, "%d->%d: %s\n", opt, op->user.opt, (char*)data); statu = hg_scanner_set_parameter(h, (const char*)op->user.opt, data, &len); if (statu == SCANNER_ERR_NOT_EXACT) diff --git a/sdk/hginclude/huagaoxxx_warraper_ex.h b/sdk/hginclude/huagaoxxx_warraper_ex.h index f76b00b..131582c 100644 --- a/sdk/hginclude/huagaoxxx_warraper_ex.h +++ b/sdk/hginclude/huagaoxxx_warraper_ex.h @@ -28,8 +28,8 @@ #include "sane/sane_ex.h" #include + #if defined(WIN32) || defined(_WIN64) -#include "../../../sdk/include/huagao/brand.h" #ifndef HGSCANNER_EXPORT #pragma comment(lib, "scanner.lib") #endif @@ -440,51 +440,12 @@ extern "C"{ const char* hg_scanner_err_name(int err); const char* hg_scanner_err_description(int err); - enum log_level - { - LOG_LEVEL_ALL = 0, - LOG_LEVEL_DEBUG_INFO, - LOG_LEVEL_WARNING, - LOG_LEVEL_FATAL, - }; bool hg_scanner_log_is_enable(int level); void hg_scanner_log(const char* info); - // Function: 获取模块全路径名称 - // - // Parameters: name - 模块名称（模块名称的一部分即可，不支持通配符） - // - // buf - 返回的全路径空间，必须保证足够大小 - // - // Return: 返回buf - char* get_file_path(const char* name, char* buf); - - // Function: 获取磁盘空间 - // - // Parameters: path - 全路径 - // - // total - 总空间大小（字节） - // - // avail - 可用空间大小（字节） - // - // block - 磁盘单元（块/簇）大小（字节） - // - // Return: 0 - 成功；其它为失败代码 - int get_disk_space(const char* path, unsigned long long* total, unsigned long long* avail, unsigned long long* block); - // Function: 图像状态名称 const char* hg_scanner_image_statu_name(int img_statu); - // Function: 获取当前时间字符串 - // - // Parameters: tmbuf - 用于接收时间字符串，不小于40个字符长度 - // - // t - 用于接收原始的时间结构 - // - // Return: void - void hg_get_current_time(char* tmbuf, struct tm* t = nullptr); - void hg_get_current_time_w(wchar_t* tmbuf, struct tm* t = nullptr); - #ifdef __cplusplus } #endif @@ -494,113 +455,6 @@ if (NULL != (p)) {free((p)); \ }\ } -///////////////////////////////////////////////////////////////////////////////////// -// log ... -#define VLOG_MINI_BYTES 512 - -#define LOG_INFO(level, info) \ - if(hg_scanner_log_is_enable(level)) \ - {\ - char* msgbuf = (char*)malloc(VLOG_MINI_BYTES); \ - if (msgbuf != NULL) \ - { \ - hg_get_current_time(msgbuf);\ - strcpy(msgbuf+strlen(msgbuf),info); \ - hg_scanner_log(msgbuf); \ - SAFE_FREE(msgbuf); \ - } \ - } \ - - -#define VLOG_1(level, bytes, fmt, arg1) \ - if(hg_scanner_log_is_enable(level)) \ - { \ - char* msgbuf = (char*)malloc(bytes); \ - if (msgbuf != NULL) \ - { \ - hg_get_current_time(msgbuf);\ - sprintf(msgbuf +strlen(msgbuf), fmt, arg1); \ - } \ - hg_scanner_log(msgbuf); \ - SAFE_FREE(msgbuf); \ - } -#define VLOG_MINI_1(level, fmt, arg1) VLOG_1(level, VLOG_MINI_BYTES, fmt, arg1) - -#define VLOG_2(level, bytes, fmt, arg1, arg2) \ - if(hg_scanner_log_is_enable(level)) \ - { \ - char* msgbuf = (char*)malloc(bytes); \ - if (msgbuf != NULL) \ - { \ - hg_get_current_time(msgbuf);\ - sprintf(msgbuf+strlen(msgbuf), fmt, arg1, arg2); \ - } \ - hg_scanner_log(msgbuf); \ - SAFE_FREE(msgbuf); \ - } -#define VLOG_MINI_2(level, fmt, arg1, arg2) VLOG_2(level, VLOG_MINI_BYTES, fmt, arg1, arg2) - -#define VLOG_3(level, bytes, fmt, arg1, arg2, arg3) \ - if(hg_scanner_log_is_enable(level)) \ - { \ - char* msgbuf = (char*)malloc(bytes); \ - if (msgbuf != NULL) \ - { \ - hg_get_current_time(msgbuf);\ - sprintf(msgbuf +strlen(msgbuf), fmt, arg1, arg2, arg3); \ - }\ - hg_scanner_log(msgbuf); \ - SAFE_FREE(msgbuf); \ - } -#define VLOG_MINI_3(level, fmt, arg1, arg2, arg3) VLOG_3(level, VLOG_MINI_BYTES, fmt, arg1, arg2, arg3) - -#define VLOG_4(level, bytes, fmt, arg1, arg2, arg3, arg4) \ - if(hg_scanner_log_is_enable(level)) \ - { \ - char* msgbuf = (char*)malloc(bytes); \ - if (msgbuf != NULL) \ - { \ - hg_get_current_time(msgbuf);\ - sprintf(msgbuf+strlen(msgbuf), fmt, arg1, arg2, arg3, arg4); \ -}\ - hg_scanner_log(msgbuf); \ - SAFE_FREE(msgbuf); \ - } -#define VLOG_MINI_4(level, fmt, arg1, arg2, arg3, arg4) \ - VLOG_4(level, VLOG_MINI_BYTES, fmt, arg1, arg2, arg3, arg4) - -#define VLOG_5(level, bytes, fmt, arg1, arg2, arg3, arg4, arg5) \ - if(hg_scanner_log_is_enable(level)) \ - { \ - char* msgbuf = (char*)malloc(bytes); \ - if(msgbuf) \ - { \ -hg_get_current_time(msgbuf);\ - sprintf(msgbuf+strlen(msgbuf), fmt, arg1, arg2, arg3, arg4, arg5); \ - }\ - hg_scanner_log(msgbuf); \ - SAFE_FREE(msgbuf); \ - } -#define VLOG_MINI_5(level, fmt, arg1, arg2, arg3, arg4, arg5) \ - VLOG_5(level, VLOG_MINI_BYTES, fmt, arg1, arg2, arg3, arg4, arg5) - -#define VLOG_6(level, bytes, fmt, arg1, arg2, arg3, arg4, arg5, arg6) \ - if(hg_scanner_log_is_enable(level)) \ - { \ - char* msgbuf = (char*)malloc(bytes); \ - if (msgbuf != NULL) \ - { \ - hg_get_current_time(msgbuf);\ - sprintf(msgbuf+strlen(msgbuf), fmt, arg1, arg2, arg3, arg4, arg5, arg6); \ - }\ - hg_scanner_log(msgbuf); \ - SAFE_FREE(msgbuf); \ - } - -#define VLOG_MINI_6(level, fmt, arg1, arg2, arg3, arg4, arg5, arg6) \ - VLOG_6(level, VLOG_MINI_BYTES, fmt, arg1, arg2, arg3, arg4, arg5, arg6) - - #endif // WRRPER_SANE_SCANNER_H_EX diff --git a/hgdriver/wrapper/ini_file.cpp b/sdk/hginclude/ini_file.cpp similarity index 100% rename from hgdriver/wrapper/ini_file.cpp rename to sdk/hginclude/ini_file.cpp diff --git a/hgdriver/wrapper/ini_file.h b/sdk/hginclude/ini_file.h similarity index 100% rename from hgdriver/wrapper/ini_file.h rename to sdk/hginclude/ini_file.h diff --git a/twain/utils.cpp b/sdk/hginclude/utils.cpp similarity index 86% rename from twain/utils.cpp rename to sdk/hginclude/utils.cpp index a530ab0..c86d9f7 100644 --- a/twain/utils.cpp +++ b/sdk/hginclude/utils.cpp @@ -1,4 +1,5 @@ #include "utils.h" + #include "huagao/brand.h" @@ -63,6 +64,7 @@ int gettimeofday(TIMEV* tv, struct timezone* tz) #include #include #include +#include static std::mutex ini_lock_; static std::map ini_files_; @@ -269,6 +271,14 @@ public: return log_cls::inst_; } + static void clear(void) + { + if(log_cls::inst_) + { + delete log_cls::inst_; + log_cls::inst_ = nullptr; + } + } int set_log_type(int type, void* param) { @@ -326,7 +336,7 @@ public: log_(info, &file_, &path_file_); } - std::string get_log_file_path(bool copy) + std::string get_log_file_path(const char* dst = nullptr) { std::string file(""); @@ -334,9 +344,9 @@ public: { file = path_file_; - if (copy) + if (dst) { - file += ".txt"; + file = dst; FILE* dst = fopen(file.c_str(), "wb"); @@ -580,6 +590,10 @@ namespace utils return ldp; } + std::string temporary_path(void) + { + return std::move(simple_ini::temporary_path()); + } std::string format_current_time(void) { return std::move(chronograph::now()); @@ -780,6 +794,76 @@ namespace utils return rename(from, to); } + int get_disk_space(const char* path, unsigned long long* total, unsigned long long* avail, unsigned long long* block) + { + int ret = 0; + +#if defined(WIN32) || defined(_WIN64) + ULARGE_INTEGER av = { 0 }, + all = { 0 }; + if (GetDiskFreeSpaceExA(path, &av, &all, NULL)) + { + if (total) + *total = all.QuadPart; + if (avail) + *avail = av.QuadPart; + if (block) + { + DWORD sec = 0, + clu = 0; + std::string root(path); + size_t pos = root.find(":\\"); + if (pos != std::string::npos) + root.erase(pos + 2); + if (GetDiskFreeSpaceA(root.c_str(), &clu, &sec, NULL, NULL)) + { + *block = clu * sec; + } + } + } + else + ret = GetLastError(); +#else + struct statfs fs = { 0 }; + + ret = statfs(path, &fs); + if (ret == 0) + { + utils::to_log(LOG_LEVEL_DEBUG, " Total: %lld, Free: %lld, Avail: %lld, block size: %lld\n", + fs.f_blocks, fs.f_bfree, fs.f_bavail, fs.f_bsize); + if (total) + *total = fs.f_blocks * fs.f_bsize; + if (avail) + *avail = fs.f_bavail * fs.f_bsize; + if (block) + *block = fs.f_bsize; + } +#endif + return ret; + } + unsigned int get_page_size(unsigned int* map_unit) + { + unsigned int ps = 1024; +#if defined(WIN32) || defined(_WIN64) + SYSTEM_INFO si = { 0 }; + + GetSystemInfo(&si); + ps = si.dwPageSize; + if (map_unit) + *map_unit = si.dwAllocationGranularity; +#else + ps = sysconf(_SC_PAGESIZE); + if(ps < 1024 || (ps & 0x0fe0000ff)) // nKB && < 16MB + ps = getpagesize(); + if (map_unit) + *map_unit = ps; +#endif + if (ps < 1024 || (ps & 0x0fe0000ff)) // nKB && < 16MB + ps = 1024; + + return ps; + } + void init_log(log_type type, log_level level, const char* fn_appendix) { std::string file(""); @@ -803,6 +887,10 @@ namespace utils log_cls::instance()->set_log_type(type, &file[0]); log_cls::instance()->set_log_level(level); } + void uninit(void) + { + log_cls::clear(); + } void log_info(const char* info, int level) { if (get_log_type() != LOG_TYPE_NONE && get_log_level() <= level) @@ -810,6 +898,33 @@ namespace utils log_cls::instance()->log(("[" + format_current_time() + "]: " + info).c_str()); } } + void log_mem_info(const char* desc, const void* data, size_t bytes, int level) + { + if (get_log_type() == LOG_TYPE_NONE || get_log_level() > level) + return; + + std::string line(desc); + char buf[40] = {0}; + + utils::log_info((line + "\n").c_str(), level); + line = ""; + for(size_t i = 0; i < bytes; ++i) + { + if((i % 16) == 0) + { + if(line.length()) + utils::log_info((line + "\n").c_str(), level); + sprintf(buf, "%p ", (const char*)data + i); + line = buf; + } + else if((i % 8) == 0) + line += " "; + sprintf(buf, "%02x ", ((const unsigned char*)data)[i]); + line += buf; + } + if(line.length()) + utils::log_info((line + "\n").c_str(), level); + } int get_log_type(void) { return log_cls::instance()->type(); @@ -818,6 +933,19 @@ namespace utils { return log_cls::instance()->level(); } + + int copy_log_file_to(const char* dst) + { + log_cls::instance()->get_log_file_path(dst); + + return 0; + } + int clear_log_file(void) + { + log_cls::instance()->clear_log(); + + return 0; + } }; diff --git a/twain/utils.h b/sdk/hginclude/utils.h similarity index 86% rename from twain/utils.h rename to sdk/hginclude/utils.h index 6545174..46a3caf 100644 --- a/twain/utils.h +++ b/sdk/hginclude/utils.h @@ -30,6 +30,7 @@ namespace utils std::string get_command_result(const char* cmd, int len = -1); std::string get_local_data_path(void); + std::string temporary_path(void); std::string format_current_time(void); std::string get_module_full_path(const char* part_name = nullptr/*nullptr to get main-pe/first module's full path*/); std::string target_file_from_link(const char* lnk_file); @@ -43,10 +44,17 @@ namespace utils int enum_file(const char* folder, bool recursive, bool/*return false to stop enumeration*/(STDCALL* found)(const char* path_name, bool dir, void* param), void* param); int move_file(const char* from, const char* to); + int get_disk_space(const char* path, unsigned long long* total, unsigned long long* avail, unsigned long long* block); + unsigned int get_page_size(unsigned int* map_unit = nullptr); + void init_log(log_type type, log_level level = LOG_LEVEL_ALL, const char* fn_appendix = nullptr/*appendix to default log-file-name*/); + void uninit(void); void log_info(const char* info, int level = LOG_LEVEL_ALL); + void log_mem_info(const char* desc, const void* data, size_t bytes, int level = LOG_LEVEL_ALL); // log as 0x12345678 00 01 02 ... int get_log_type(void); int get_log_level(void); + int copy_log_file_to(const char* dst); + int clear_log_file(void); template void to_log(int level, const char* fmt, Args ... args) diff --git a/twain/CMakeLists.txt b/twain/CMakeLists.txt index 955cb94..755fc9f 100644 --- a/twain/CMakeLists.txt +++ b/twain/CMakeLists.txt @@ -8,8 +8,9 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC -fvisibility=hidden") aux_source_directory(${PROJECT_SOURCE_DIR} DIR_SRCS) # add_subdirectory(twain) file(GLOB DIR_HEADS "${PROJECT_SOURCE_DIR}/*.h" "${PROJECT_SOURCE_DIR}/*.hpp" "${PROJECT_SOURCE_DIR}/*.cpp" - "${PROJECT_SOURCE_DIR}/../hgdriver/wrapper/ini_file.h" - "${PROJECT_SOURCE_DIR}/../hgdriver/wrapper/ini_file.cpp") + "${PROJECT_SOURCE_DIR}/../sdk/hginclude/*.h" + "${PROJECT_SOURCE_DIR}/../sdk/hginclude/*.cpp" + ) set(DIR_SRCS ${DIR_SRCS} ${DIR_HEADS}) add_library(${PROJECT_NAME} SHARED ${DIR_SRCS}) @@ -21,11 +22,11 @@ link_libraries(dl) # ) target_include_directories(${PROJECT_NAME} PRIVATE ${PROJECT_SOURCE_DIR} + ${PROJECT_SOURCE_DIR}/../sdk/hginclude ${PROJECT_SOURCE_DIR}/../../sdk/include ${PROJECT_SOURCE_DIR}/../../sdk/include/huagao ${PROJECT_SOURCE_DIR}/../../sdk/include/twain ${PROJECT_SOURCE_DIR}/../../sdk/include/twain/twpp - ${PROJECT_SOURCE_DIR}/../hgdriver/wrapper ) target_link_directories(${PROJECT_NAME} PRIVATE ${PROJECT_SOURCE_DIR} diff --git a/twain/huagaods.cpp b/twain/huagaods.cpp index 049a02c..bc756cd 100644 --- a/twain/huagaods.cpp +++ b/twain/huagaods.cpp @@ -1020,7 +1020,7 @@ Result huagao_ds::identityOpenDs(const Identity& id) m_fileXfer.setFormat(ImageFileFormat::Bmp); scanner_status_ = SCANNER_STATUS_READY; - log_mem_info("srcIdent:", srcIdent, sizeof(*srcIdent)); + utils::log_mem_info("srcIdent:", srcIdent, sizeof(*srcIdent)); return success(); } @@ -2145,11 +2145,11 @@ void huagao_ds::init_support_caps(void) return badValue(); } } - log_mem_info("IXferMech data before:", &data, sizeof(data)); + utils::log_mem_info("IXferMech data before:", &data, sizeof(data)); Result r = CapSupGetAllReset(msg, data, { XferMech::Native, XferMech::File, XferMech::Memory }, m_capXferMech, XferMech::Native, (int)m_capXferMech, 0); - log_mem_info("IXferMech data after:", &data, sizeof(data)); + utils::log_mem_info("IXferMech data after:", &data, sizeof(data)); return r; }; diff --git a/twain/s2t_api.h b/twain/s2t_api.h index b54e20e..d331c4f 100644 --- a/twain/s2t_api.h +++ b/twain/s2t_api.h @@ -437,8 +437,6 @@ extern "C" int open_scanner(SCANNERID scanner_id, ISaneInvoker** invoker, bool last_try); bool is_scanner_online(SCANNERID scanner_id); int uninitialize_sane(void* reserve); - void log_debug_info(const char* info, int level); - void log_mem_info(const char* desc, const void* data, size_t bytes); ISaneInvoker* sane_wapper_open_scanner(SCANNERID scanner_id, int* err, bool last_try); } diff --git a/twain/scanner.cpp b/twain/scanner.cpp index 95206fe..9ebae36 100644 --- a/twain/scanner.cpp +++ b/twain/scanner.cpp @@ -79,7 +79,7 @@ namespace callback { char msg[218] = { 0 }; sprintf_s(msg, _countof(msg) - 1, "Lost device(0x%08X) when event(%u) occurs!\r\n", hdev, code); - log_debug_info(msg, 1); + utils::log_info(msg, (log_level)1); return 0; } @@ -285,7 +285,7 @@ namespace callback info += "' failed: " + std::string(strerror(GetLastError())) + "\r\n"; - log_debug_info(info.c_str(), 1); + utils::log_info(info.c_str(), LOG_LEVEL_DEBUG); } else { @@ -1024,7 +1024,7 @@ void scanner::extension_page(int id) ex_opts_.push_back(ea); { sprintf_s(msg, _countof(msg) - 1, "handle_ex_duplex of id: %d\r\n", ea.ind); - log_debug_info(msg, 0); + utils::log_info(msg, (log_level)0); } ea.ind = ex_discard_blank_page_id_ = ex_id_++; @@ -1033,7 +1033,7 @@ void scanner::extension_page(int id) ex_opts_.push_back(ea); { sprintf_s(msg, _countof(msg) - 1, "handle_ex_discard_blank_page of id: %d\r\n", ea.ind); - log_debug_info(msg, 0); + utils::log_info(msg, (log_level)0); } ea.ind = ex_discard_blank_receipt_id_ = ex_id_++; @@ -1042,7 +1042,7 @@ void scanner::extension_page(int id) ex_opts_.push_back(ea); { sprintf_s(msg, _countof(msg) - 1, "handle_ex_discard_blank_receipt of id: %d\r\n", ea.ind); - log_debug_info(msg, 0); + utils::log_info(msg, (log_level)0); } ea.ind = ex_is_page_fold_id_ = ex_id_++; @@ -1051,7 +1051,7 @@ void scanner::extension_page(int id) ex_opts_.push_back(ea); { sprintf_s(msg, _countof(msg) - 1, "handle_ex_page_fold of id: %d\r\n", ea.ind); - log_debug_info(msg, 0); + utils::log_info(msg, (log_level)0); } } void scanner::extension_erase_color(int id) @@ -2368,7 +2368,7 @@ COM_API_IMPLEMENT(scanner, int, get_scanned_images(DWORD milliseconds)) { char msg[128] = { 0 }; sprintf_s(msg, _countof(msg) - 1, "Wait image count = %d\r\n", count); - log_debug_info(msg, 1); + utils::log_info(msg, (log_level)1); } return count; @@ -2718,7 +2718,7 @@ COM_API_IMPLEMENT(scanner, int, set_value(int sn, void* val)) desc = sane_helper_->invoke_sane_get_option_descriptor(handle_, ex->base_ind); sprintf_s(msg, _countof(msg) - 1, "set_value of %s(0x%x) of ID %d, base id = %d)\r\n", desc->name, *(unsigned*)val, sn, ex->base_ind); } - log_debug_info(msg, 0); + utils::log_info(msg, (log_level)0); } twain_set_ = true; @@ -2969,6 +2969,7 @@ COM_API_IMPLEMENT(scanner, bool, ui_show_setting(HWND parent, bool with_scan, bo COM_API_IMPLEMENT(scanner, bool, ui_show_progress(HWND parent, bool bIndicator)) { + bIndicator = false; is_bIndicator = bIndicator; ui_notify = std::function(); auto ui_process = [this](ui_result res) @@ -3026,7 +3027,7 @@ int scanner::handle_device_event(int ev_code, void* data, unsigned int* len) if (callback::show_progress_ui && is_bIndicator) ui_notify(ev_code, data, *len); on_ui_event(ev_code, (void*)ev_code); - log_debug_info("Scanning ...\r\n", 1); + utils::log_info("Scanning ...\r\n", LOG_LEVEL_DEBUG); } else if (ev_code == SANE_EVENT_IMAGE_OK) { @@ -3050,7 +3051,7 @@ int scanner::handle_device_event(int ev_code, void* data, unsigned int* len) images_.count(&bytes); bytes /= 1024 * 1024; if (times == 1) - log_debug_info("Memory usage upto limit! wait up to 100 ms ...\r\n", 1); + utils::log_info("Memory usage upto limit! wait up to 100 ms ...\r\n", LOG_LEVEL_DEBUG); } images_.save(img, img->bytes()); } @@ -3065,7 +3066,7 @@ int scanner::handle_device_event(int ev_code, void* data, unsigned int* len) { char msg[128] = { 0 }; sprintf_s(msg, _countof(msg) - 1, "New image(%u) received with %u bytes\r\n", img_ind_, simg->bytes); - log_debug_info(msg, 1); + utils::log_info(msg, (log_level)1); } } else if (ev_code == SANE_EVENT_USB_DATA_RECEIVED) @@ -3096,7 +3097,7 @@ int scanner::handle_device_event(int ev_code, void* data, unsigned int* len) { char msg[128] = { 0 }; sprintf_s(msg, _countof(msg) - 1, "Scan finished with error: %u\r\n", *len); - log_debug_info(msg, 1); + utils::log_info(msg, (log_level)1); } } //else if (ev_code == SANE_EVENT_ERROR) // 屏蔽，在停止扫描时展示信息 - 2023-05-30 @@ -3233,35 +3234,6 @@ extern "C" return 0; } - void log_debug_info(const char* info, int level) - { - utils::log_info(info, (log_level)level); - } - - void log_mem_info(const char* desc, const void* data, size_t bytes) - { - std::string line(desc); - char buf[40] = {0}; - - utils::log_info((line + "\n").c_str()); - line = ""; - for(size_t i = 0; i < bytes; ++i) - { - if((i % 16) == 0) - { - if(line.length()) - utils::log_info((line + "\n").c_str()); - sprintf(buf, "%p ", (const char*)data + i); - line = buf; - } - else if((i % 8) == 0) - line += " "; - sprintf(buf, "%02x ", ((const unsigned char*)data)[i]); - line += buf; - } - if(line.length()) - utils::log_info((line + "\n").c_str()); - } ISaneInvoker* sane_wapper_open_scanner(SCANNERID scanner_id, int* err, bool last_try) {