diff --git a/build.sh b/build.sh index 1166f8e..ea2e799 100755 --- a/build.sh +++ b/build.sh @@ -4,26 +4,19 @@ sys=${sys%% *} echo "${1}" if [ "${1}" == "hw" ]; then - sed -i "s/-DOEM_HUAGAO/-DOEM_HANWANG/g" hgsane/CMakeLists.txt - sed -i "s/-DOEM_HUAGAO/-DOEM_HANWANG/g" hgdriver/wrapper/CMakeLists.txt - sed -i "s/-DOEM_HUAGAO/-DOEM_HANWANG/g" hgdriver/hgdev/CMakeLists.txt - sed -i "s/-DOEM_LISICHENG/-DOEM_HANWANG/g" hgsane/CMakeLists.txt - sed -i "s/-DOEM_LISICHENG/-DOEM_HANWANG/g" hgdriver/wrapper/CMakeLists.txt - sed -i "s/-DOEM_LISICHENG/-DOEM_HANWANG/g" hgdriver/hgdev/CMakeLists.txt + sed -ibkp "s/-DOEM_HUAGAO/-DOEM_HANWANG/g" hgsane/CMakeLists.txt + sed -i "s/hgsane/hwsane/g" hgsane/CMakeLists.txt + sed -i "s/hgdriver/hwdriver/g" hgsane/CMakeLists.txt + sed -ibkp "s/-DOEM_HUAGAO/-DOEM_HANWANG/g" hgdriver/hgdev/CMakeLists.txt + sed -ibkp "s/-DOEM_HUAGAO/-DOEM_HANWANG/g" hgdriver/wrapper/CMakeLists.txt + sed -i "s/hgdriver/hwdriver/g" hgdriver/wrapper/CMakeLists.txt elif [ "${1}" == "lsc" ]; then - sed -i "s/-DOEM_HUAGAO/-DOEM_LISICHENG/g" hgsane/CMakeLists.txt - sed -i "s/-DOEM_HUAGAO/-DOEM_LISICHENG/g" hgdriver/wrapper/CMakeLists.txt - sed -i "s/-DOEM_HUAGAO/-DOEM_LISICHENG/g" hgdriver/hgdev/CMakeLists.txt - sed -i "s/-DOEM_HANWANG/-DOEM_LISICHENG/g" hgsane/CMakeLists.txt - sed -i "s/-DOEM_HANWANG/-DOEM_LISICHENG/g" hgdriver/wrapper/CMakeLists.txt - sed -i "s/-DOEM_HANWANG/-DOEM_LISICHENG/g" hgdriver/hgdev/CMakeLists.txt -else - sed -i "s/-DOEM_LISICHENG/-DOEM_HUAGAO/g" hgsane/CMakeLists.txt - sed -i "s/-DOEM_LISICHENG/-DOEM_HUAGAO/g" hgdriver/wrapper/CMakeLists.txt - sed -i "s/-DOEM_LISICHENG/-DOEM_HUAGAO/g" hgdriver/hgdev/CMakeLists.txt - sed -i "s/-DOEM_HANWANG/-DOEM_HUAGAO/g" hgsane/CMakeLists.txt - sed -i "s/-DOEM_HANWANG/-DOEM_HUAGAO/g" hgdriver/wrapper/CMakeLists.txt - sed -i "s/-DOEM_HANWANG/-DOEM_HUAGAO/g" hgdriver/hgdev/CMakeLists.txt + sed -ibkp "s/-DOEM_HUAGAO/-DOEM_LISICHENG/g" hgsane/CMakeLists.txt + sed -i "s/hgsane/lscsane/g" hgsane/CMakeLists.txt + sed -i "s/hgdriver/lscdriver/g" hgsane/CMakeLists.txt + sed -ibkp "s/-DOEM_HUAGAO/-DOEM_LISICHENG/g" hgdriver/hgdev/CMakeLists.txt + sed -ibkp "s/-DOEM_HUAGAO/-DOEM_LISICHENG/g" hgdriver/wrapper/CMakeLists.txt + sed -i "s/hgdriver/lscdriver/g" hgdriver/wrapper/CMakeLists.txt fi echo "------------------------------change cmake path:$1--------------------" @@ -47,3 +40,6 @@ fi make +mv ../code_device/hgsane/CMakeLists.txtbkp ../code_device/hgsane/CMakeLists.txt +mv ../code_device/hgdriver/hgdev/CMakeLists.txtbkp ../code_device/hgdriver/hgdev/CMakeLists.txt +mv ../code_device/hgdriver/wrapper/CMakeLists.txtbkp ../code_device/hgdriver/wrapper/CMakeLists.txt \ No newline at end of file diff --git a/hgdriver/hgdev/hg_ipc.cpp b/hgdriver/hgdev/hg_ipc.cpp index 246cf1a..c13d057 100644 --- a/hgdriver/hgdev/hg_ipc.cpp +++ b/hgdriver/hgdev/hg_ipc.cpp @@ -78,7 +78,7 @@ platform_event::platform_event() : waiting_(false), dbg_info_("") if (err == -1) { err = errno; - HG_VLOG_MINI_2(HG_LOG_LEVEL_FATAL, "(%s)sem_init failed: %d\n", hg_log::format_ptr(this).c_str(), err); + HG_VLOG_MINI_2(LOG_LEVEL_FATAL, "(%s)sem_init failed: %d\n", hg_log::format_ptr(this).c_str(), err); } } platform_event::~platform_event() @@ -94,7 +94,7 @@ bool platform_event::wait(unsigned timeout) { bool waited = true; - HG_VLOG_MINI_2(HG_LOG_LEVEL_DEBUG_INFO, "platform_event(%s - %s) --> waiting...\n", hg_log::format_ptr(this).c_str(), dbg_info_.c_str()); + HG_VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "platform_event(%s - %s) --> waiting...\n", hg_log::format_ptr(this).c_str(), dbg_info_.c_str()); waiting_ = true; if (timeout == USB_TIMEOUT_INFINITE) sem_wait(&sem_); @@ -105,7 +105,7 @@ bool platform_event::wait(unsigned timeout) to.tv_nsec = (long)((timeout % 1000) * 1000 * 1000); waited = sem_timedwait(&sem_, &to) == 0; } - HG_VLOG_MINI_3(HG_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"); + HG_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"); waiting_ = false; return waited; @@ -129,7 +129,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_; - HG_VLOG_MINI_2(HG_LOG_LEVEL_DEBUG_INFO, "shared memory key = 0x%x%08x\n", ptr[1], ptr[0]); + HG_VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "shared memory key = 0x%x%08x\n", ptr[1], ptr[0]); init(); } @@ -163,11 +163,11 @@ void shared_memory::init(void) obj = shmget(key_, bytes_, 0600); if(obj == -1) obj = shmget(key_, bytes_, 0); - HG_VLOG_MINI_3(HG_LOG_LEVEL_DEBUG_INFO, "open existing: shmget(0x%x%08x) = %d\n", v[1], v[0], obj); + HG_VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "open existing: shmget(0x%x%08x) = %d\n", v[1], v[0], obj); obj_ = (void*)obj; std::string prev(read()), proc(""); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "shared memory content: %s\n", prev.c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "shared memory content: %s\n", prev.c_str()); if(prev.length()) { proc = prev; @@ -192,17 +192,17 @@ void shared_memory::init(void) first_ = true; clear(); obj = shmget(key_, bytes_, IPC_EXCL | IPC_CREAT | 0600); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "%s is not existing and reopen it\n", prev.c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "%s is not existing and reopen it\n", prev.c_str()); } } else { - HG_VLOG_MINI_3(HG_LOG_LEVEL_DEBUG_INFO, "shmget(0x%x%08x) = %d\n", v[1], v[0], errno); + HG_VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "shmget(0x%x%08x) = %d\n", v[1], v[0], errno); return; } } obj_ = (void*)obj; - HG_VLOG_MINI_2(HG_LOG_LEVEL_DEBUG_INFO, "shared memory id = %d[%s], \n", obj, first_ ? "created" : "opened"); + HG_VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "shared memory id = %d[%s], \n", obj, first_ ? "created" : "opened"); #endif if(first_) @@ -248,7 +248,7 @@ char* shared_memory::get_buf(void) #else int* h = (int*)&obj_; char* buf = (char*)shmat(*h, 0, 0); - HG_VLOG_MINI_3(HG_LOG_LEVEL_DEBUG_INFO, "shared memory %d buffer = %s, error = %d\n", *h, hg_log::format_ptr(buf).c_str(), errno); + HG_VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "shared memory %d buffer = %s, error = %d\n", *h, hg_log::format_ptr(buf).c_str(), errno); #endif return buf; @@ -287,11 +287,11 @@ std::string shared_memory::get_proc_name_by_pid(pid_t pid) } if (sizeof(pid) > 4 && v[1]) { - HG_VLOG_MINI_2(HG_LOG_LEVEL_DEBUG_INFO, "PID(%lld) name is: %s\n", pid, ret.c_str()); + HG_VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "PID(%lld) name is: %s\n", pid, ret.c_str()); } else { - HG_VLOG_MINI_2(HG_LOG_LEVEL_DEBUG_INFO, "PID(%u) name is: %s\n", pid, ret.c_str()); + HG_VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "PID(%u) name is: %s\n", pid, ret.c_str()); } return ret; @@ -328,7 +328,7 @@ std::string shared_memory::read(void) int shared_memory::write(const char* data, size_t len) { if (len > bytes_) - return HG_ERR_INSUFFICIENT_MEMORY; + return SCANNER_ERR_INSUFFICIENT_MEMORY; char* buf = get_buf(); int off = sizeof(len); diff --git a/hgdriver/hgdev/hg_scanner.cpp b/hgdriver/hgdev/hg_scanner.cpp index 961cc05..9cf5b8c 100644 --- a/hgdriver/hgdev/hg_scanner.cpp +++ b/hgdriver/hgdev/hg_scanner.cpp @@ -18,7 +18,7 @@ static int ui_default_callback(scanner_handle, int, void*, unsigned int*, void*) // hg_scanner hg_scanner::hg_scanner(ScannerSerial serial , const char* dev_name, usb_io* io) - : name_(dev_name ? dev_name : ""), io_(io), status_(HG_ERR_NOT_START) + : name_(dev_name ? dev_name : ""), io_(io), status_(SCANNER_ERR_NOT_START) , scan_count_(-1), run_(true), paper_size_(TwSS::A4), erase_bkg_range_(10) , noise_range_(30), omit_empty_level_(50), resolution_(200), rid_hole_range_(.1f) , bright_(128), contrast_(4), gamma_(1.0f), threshold_(40), anti_noise_(8), margin_(5) @@ -38,14 +38,14 @@ hg_scanner::hg_scanner(ScannerSerial serial for (int i = 0; i < ARRAY_SIZE(custom_gamma_val_->table); ++i) custom_gamma_val_->table[i] = i & 0x0ff; - HG_VLOG_MINI_2(HG_LOG_LEVEL_DEBUG_INFO, "%s(%s) constructed\n", name_.c_str(), hg_log::format_ptr(this).c_str()); + HG_VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "%s(%s) constructed\n", name_.c_str(), hg_log::format_ptr(this).c_str()); image_prc_param_.value = 0; if (io_) { io_->add_ref(); status_ = io_->last_error(); - online_ = status_ == HG_ERR_OK; + online_ = status_ == SCANNER_ERR_OK; } wait_usb_.set_debug_info("USB"); @@ -66,97 +66,97 @@ hg_scanner::~hg_scanner() name_.insert(0, "\350\256\276\345\244\207 “"); name_ += "”\345\267\262\347\273\217\345\205\263\351\227\255\343\200\202"; notify_ui_working_status(name_.c_str(), SANE_EVENT_SCANNER_CLOSED); - HG_VLOG_MINI_2(HG_LOG_LEVEL_DEBUG_INFO, "%s(%s) destroyed.\n", name_.c_str(), hg_log::format_ptr(this).c_str()); + HG_VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "%s(%s) destroyed.\n", name_.c_str(), hg_log::format_ptr(this).c_str()); } -std::string hg_scanner::strerr(hg_err err) +std::string hg_scanner::strerr(scanner_err err) { - RETURN_IF(err, HG_ERR_OK); - RETURN_IF(err, HG_ERR_INVALID_PARAMETER); - RETURN_IF(err, HG_ERR_INSUFFICIENT_MEMORY); - RETURN_IF(err, HG_ERR_ACCESS_DENIED); - RETURN_IF(err, HG_ERR_IO_PENDING); - RETURN_IF(err, HG_ERR_NOT_EXACT); - RETURN_IF(err, HG_ERR_CONFIGURATION_CHANGED); - RETURN_IF(err, HG_ERR_NOT_OPEN); - RETURN_IF(err, HG_ERR_NOT_START); - RETURN_IF(err, HG_ERR_NO_DATA); - RETURN_IF(err, HG_ERR_HAS_DATA_YET); - RETURN_IF(err, HG_ERR_OUT_OF_RANGE); - RETURN_IF(err, HG_ERR_IO); - RETURN_IF(err, HG_ERR_TIMEOUT); - RETURN_IF(err, HG_ERR_CREATE_FILE_FAILED); - RETURN_IF(err, HG_ERR_WRITE_FILE_FAILED); - RETURN_IF(err, HG_ERR_OPENED_BY_OTHER_PROCESS); + RETURN_IF(err, SCANNER_ERR_OK); + RETURN_IF(err, SCANNER_ERR_INVALID_PARAMETER); + RETURN_IF(err, SCANNER_ERR_INSUFFICIENT_MEMORY); + RETURN_IF(err, SCANNER_ERR_ACCESS_DENIED); + RETURN_IF(err, SCANNER_ERR_IO_PENDING); + RETURN_IF(err, SCANNER_ERR_NOT_EXACT); + RETURN_IF(err, SCANNER_ERR_CONFIGURATION_CHANGED); + RETURN_IF(err, SCANNER_ERR_NOT_OPEN); + RETURN_IF(err, SCANNER_ERR_NOT_START); + RETURN_IF(err, SCANNER_ERR_NO_DATA); + RETURN_IF(err, SCANNER_ERR_HAS_DATA_YET); + RETURN_IF(err, SCANNER_ERR_OUT_OF_RANGE); + RETURN_IF(err, SCANNER_ERR_IO); + RETURN_IF(err, SCANNER_ERR_TIMEOUT); + RETURN_IF(err, SCANNER_ERR_CREATE_FILE_FAILED); + RETURN_IF(err, SCANNER_ERR_WRITE_FILE_FAILED); + RETURN_IF(err, SCANNER_ERR_OPENED_BY_OTHER_PROCESS); // 2：USB错误 - RETURN_IF(err, HG_ERR_USB_INIT_FAILED); - RETURN_IF(err, HG_ERR_USB_REGISTER_PNP_FAILED); - RETURN_IF(err, HG_ERR_USB_CLAIM_INTERFACE_FAILED); + RETURN_IF(err, SCANNER_ERR_USB_INIT_FAILED); + RETURN_IF(err, SCANNER_ERR_USB_REGISTER_PNP_FAILED); + RETURN_IF(err, SCANNER_ERR_USB_CLAIM_INTERFACE_FAILED); // 3：硬件错误 - RETURN_IF(err, HG_ERR_DEVICE_NOT_FOUND); - RETURN_IF(err, HG_ERR_DEVICE_NOT_SUPPORT); - RETURN_IF(err, HG_ERR_DEVICE_BUSY); - RETURN_IF(err, HG_ERR_DEVICE_STOPPED); - RETURN_IF(err, HG_ERR_DEVICE_COVER_OPENNED); - RETURN_IF(err, HG_ERR_DEVICE_NO_PAPER); - RETURN_IF(err, HG_ERR_DEVICE_FEEDING_PAPER); - RETURN_IF(err, HG_ERR_DEVICE_DOUBLE_FEEDING); - RETURN_IF(err, HG_ERR_DEVICE_PAPER_JAMMED); - RETURN_IF(err, HG_ERR_DEVICE_STAPLE_ON); - RETURN_IF(err, HG_ERR_DEVICE_PAPER_SKEW); - RETURN_IF(err, HG_ERR_DEVICE_SIZE_CHECK); - RETURN_IF(err, HG_ERR_DEVICE_DOGEAR); - RETURN_IF(err, HG_ERR_DEVICE_NO_IMAGE); - RETURN_IF(err, HG_ERR_DEVICE_SCANN_ERROR); + RETURN_IF(err, SCANNER_ERR_DEVICE_NOT_FOUND); + RETURN_IF(err, SCANNER_ERR_DEVICE_NOT_SUPPORT); + RETURN_IF(err, SCANNER_ERR_DEVICE_BUSY); + RETURN_IF(err, SCANNER_ERR_DEVICE_STOPPED); + RETURN_IF(err, SCANNER_ERR_DEVICE_COVER_OPENNED); + RETURN_IF(err, SCANNER_ERR_DEVICE_NO_PAPER); + RETURN_IF(err, SCANNER_ERR_DEVICE_FEEDING_PAPER); + RETURN_IF(err, SCANNER_ERR_DEVICE_DOUBLE_FEEDING); + RETURN_IF(err, SCANNER_ERR_DEVICE_PAPER_JAMMED); + RETURN_IF(err, SCANNER_ERR_DEVICE_STAPLE_ON); + RETURN_IF(err, SCANNER_ERR_DEVICE_PAPER_SKEW); + RETURN_IF(err, SCANNER_ERR_DEVICE_SIZE_CHECK); + RETURN_IF(err, SCANNER_ERR_DEVICE_DOGEAR); + RETURN_IF(err, SCANNER_ERR_DEVICE_NO_IMAGE); + RETURN_IF(err, SCANNER_ERR_DEVICE_SCANN_ERROR); char unk[80]; sprintf(unk, "\346\234\252\347\237\245\351\224\231\350\257\257\357\274\2320x%x", err); return unk; } -std::string hg_scanner::error_description(hg_err err) +std::string hg_scanner::error_description(scanner_err err) { - RETURN_DESC_IF(err, HG_ERR_OK); - RETURN_DESC_IF(err, HG_ERR_INVALID_PARAMETER); - RETURN_DESC_IF(err, HG_ERR_INSUFFICIENT_MEMORY); - RETURN_DESC_IF(err, HG_ERR_ACCESS_DENIED); - RETURN_DESC_IF(err, HG_ERR_IO_PENDING); - RETURN_DESC_IF(err, HG_ERR_NOT_EXACT); - RETURN_DESC_IF(err, HG_ERR_CONFIGURATION_CHANGED); - RETURN_DESC_IF(err, HG_ERR_NOT_OPEN); - RETURN_DESC_IF(err, HG_ERR_NOT_START); - RETURN_DESC_IF(err, HG_ERR_NO_DATA); - RETURN_DESC_IF(err, HG_ERR_HAS_DATA_YET); - RETURN_DESC_IF(err, HG_ERR_OUT_OF_RANGE); - RETURN_DESC_IF(err, HG_ERR_IO); - RETURN_DESC_IF(err, HG_ERR_TIMEOUT); - RETURN_DESC_IF(err, HG_ERR_CREATE_FILE_FAILED); - RETURN_DESC_IF(err, HG_ERR_WRITE_FILE_FAILED); - RETURN_DESC_IF(err, HG_ERR_OPENED_BY_OTHER_PROCESS); + RETURN_DESC_IF(err, SCANNER_ERR_OK); + RETURN_DESC_IF(err, SCANNER_ERR_INVALID_PARAMETER); + RETURN_DESC_IF(err, SCANNER_ERR_INSUFFICIENT_MEMORY); + RETURN_DESC_IF(err, SCANNER_ERR_ACCESS_DENIED); + RETURN_DESC_IF(err, SCANNER_ERR_IO_PENDING); + RETURN_DESC_IF(err, SCANNER_ERR_NOT_EXACT); + RETURN_DESC_IF(err, SCANNER_ERR_CONFIGURATION_CHANGED); + RETURN_DESC_IF(err, SCANNER_ERR_NOT_OPEN); + RETURN_DESC_IF(err, SCANNER_ERR_NOT_START); + RETURN_DESC_IF(err, SCANNER_ERR_NO_DATA); + RETURN_DESC_IF(err, SCANNER_ERR_HAS_DATA_YET); + RETURN_DESC_IF(err, SCANNER_ERR_OUT_OF_RANGE); + RETURN_DESC_IF(err, SCANNER_ERR_IO); + RETURN_DESC_IF(err, SCANNER_ERR_TIMEOUT); + RETURN_DESC_IF(err, SCANNER_ERR_CREATE_FILE_FAILED); + RETURN_DESC_IF(err, SCANNER_ERR_WRITE_FILE_FAILED); + RETURN_DESC_IF(err, SCANNER_ERR_OPENED_BY_OTHER_PROCESS); // 2：USB错误 - RETURN_DESC_IF(err, HG_ERR_USB_INIT_FAILED); - RETURN_DESC_IF(err, HG_ERR_USB_REGISTER_PNP_FAILED); - RETURN_DESC_IF(err, HG_ERR_USB_CLAIM_INTERFACE_FAILED); + RETURN_DESC_IF(err, SCANNER_ERR_USB_INIT_FAILED); + RETURN_DESC_IF(err, SCANNER_ERR_USB_REGISTER_PNP_FAILED); + RETURN_DESC_IF(err, SCANNER_ERR_USB_CLAIM_INTERFACE_FAILED); // 3：硬件错误 - RETURN_DESC_IF(err, HG_ERR_DEVICE_NOT_FOUND); - RETURN_DESC_IF(err, HG_ERR_DEVICE_NOT_SUPPORT); - RETURN_DESC_IF(err, HG_ERR_DEVICE_BUSY); - RETURN_DESC_IF(err, HG_ERR_DEVICE_STOPPED); - RETURN_DESC_IF(err, HG_ERR_DEVICE_COVER_OPENNED); - RETURN_DESC_IF(err, HG_ERR_DEVICE_NO_PAPER); - RETURN_DESC_IF(err, HG_ERR_DEVICE_FEEDING_PAPER); - RETURN_DESC_IF(err, HG_ERR_DEVICE_DOUBLE_FEEDING); - RETURN_DESC_IF(err, HG_ERR_DEVICE_PAPER_JAMMED); - RETURN_DESC_IF(err, HG_ERR_DEVICE_STAPLE_ON); - RETURN_DESC_IF(err, HG_ERR_DEVICE_PAPER_SKEW); - RETURN_DESC_IF(err, HG_ERR_DEVICE_SIZE_CHECK); - RETURN_DESC_IF(err, HG_ERR_DEVICE_DOGEAR); - RETURN_DESC_IF(err, HG_ERR_DEVICE_NO_IMAGE); - RETURN_DESC_IF(err, HG_ERR_DEVICE_SCANN_ERROR); + RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_NOT_FOUND); + RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_NOT_SUPPORT); + RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_BUSY); + RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_STOPPED); + RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_COVER_OPENNED); + RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_NO_PAPER); + RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_FEEDING_PAPER); + RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_DOUBLE_FEEDING); + RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_PAPER_JAMMED); + RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_STAPLE_ON); + RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_PAPER_SKEW); + RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_SIZE_CHECK); + RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_DOGEAR); + RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_NO_IMAGE); + RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_SCANN_ERROR); char unk[80]; sprintf(unk, "\346\234\252\347\237\245\351\224\231\350\257\257\357\274\2320x%x", err); @@ -203,7 +203,7 @@ int hg_scanner::save_2_tempory_file(std::shared_ptr> data, std char head[40] = { 0 }; std::string file(""); FILE* dst = nullptr; - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; sprintf(head, "scan_%06u", index); file = hg_scanner::temporary_file((char*)".jpg", (char*)head); @@ -216,19 +216,19 @@ int hg_scanner::save_2_tempory_file(std::shared_ptr> data, std { if (path_file) *path_file = file; - HG_VLOG_MINI_2(HG_LOG_LEVEL_DEBUG_INFO, "--->Wrote %u bytes to file '%s'\n", wrote, file.c_str()); + HG_VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "--->Wrote %u bytes to file '%s'\n", wrote, file.c_str()); } else { - ret = HG_ERR_WRITE_FILE_FAILED; - HG_VLOG_MINI_3(HG_LOG_LEVEL_FATAL, "Failed in writting file(%u/%u) '%s'\n", wrote, data->size(), file.c_str()); + ret = SCANNER_ERR_WRITE_FILE_FAILED; + HG_VLOG_MINI_3(LOG_LEVEL_FATAL, "Failed in writting file(%u/%u) '%s'\n", wrote, data->size(), file.c_str()); } fclose(dst); } else { - ret = HG_ERR_CREATE_FILE_FAILED; - HG_VLOG_MINI_1(HG_LOG_LEVEL_FATAL, "Failed in creating file '%s'\n", file.c_str()); + ret = SCANNER_ERR_CREATE_FILE_FAILED; + HG_VLOG_MINI_1(LOG_LEVEL_FATAL, "Failed in creating file '%s'\n", file.c_str()); } return ret; @@ -248,7 +248,7 @@ void hg_scanner::set_setting_map(int sn, const char* title) empty++; val.erase(0, empty); - //HG_VLOG_MINI_2(HG_LOG_LEVEL_DEBUG_INFO, "title: '%s', val: '%s'\n", title, val.c_str()); + //HG_VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "title: '%s', val: '%s'\n", title, val.c_str()); if (val == OPTION_TITLE_HFMRSZ) setting_map_[HG_BASE_SETTING_INDEX_RESTORE_DEFAULT_SETTINGS] = sn; @@ -370,7 +370,7 @@ void hg_scanner::thread_handle_usb(void) std::this_thread::sleep_for(std::chrono::milliseconds(3000)); if (scan_life_) { - HG_LOG(HG_LOG_LEVEL_FATAL, "image process is still running!\n"); + HG_LOG(LOG_LEVEL_FATAL, "image process is still running!\n"); continue; } } @@ -480,7 +480,7 @@ void hg_scanner::get_range(int setting_no, std::vector& range, std: else if(type == "string") setting_jsn_.at(sn).at("default").get_to(def_val); - HG_VLOG_MINI_3(HG_LOG_LEVEL_DEBUG_INFO, "setting %d has %d range(s) and default value is '%s'\n", setting_no, range.size(), def_val.c_str()); + HG_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()); } bool hg_scanner::check_range(int setting_no, bool& val) { @@ -606,7 +606,7 @@ int hg_scanner::restore(int setting_no) for (int i = 0; i < ARRAY_SIZE(custom_gamma_val_->table); ++i) custom_gamma_val_->table[i] = i & 0x0ff; - return HG_ERR_OK; + return SCANNER_ERR_OK; } setting_jsn_.at(key).at("type").get_to(val); @@ -644,7 +644,7 @@ int hg_scanner::restore(int setting_no) sn = set_setting(sn, (char*)&v, sizeof(v)); } else - sn = HG_ERR_OK; + sn = SCANNER_ERR_OK; return sn; } @@ -732,7 +732,7 @@ void hg_scanner::thread_handle_image_process(void) } else { - HG_VLOG_MINI_1(HG_LOG_LEVEL_FATAL, "FATAL: open tempory image file '%s' failed.\n", file.c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_FATAL, "FATAL: open tempory image file '%s' failed.\n", file.c_str()); } } else @@ -747,7 +747,7 @@ void hg_scanner::thread_handle_image_process(void) void hg_scanner::working_begin(void*) { final_img_index_ = 0; - notify_ui_working_status(STATU_DESC_SCAN_WORKING, SANE_EVENT_WORKING, HG_ERR_OK); + notify_ui_working_status(STATU_DESC_SCAN_WORKING, SANE_EVENT_WORKING, SCANNER_ERR_OK); } void hg_scanner::working_done(void*) { @@ -759,59 +759,59 @@ void hg_scanner::working_done(void*) switch (status_) { - case HG_ERR_OK: + case SCANNER_ERR_OK: notify_ui_working_status(STATU_DESC_SCAN_STOPPED, SANE_EVENT_SCAN_FINISHED, status_); break; - case HG_ERR_DEVICE_BUSY: - notify_ui_working_status(STATU_DESC_HG_ERR_DEVICE_PC_BUSY, SANE_EVENT_SCAN_FINISHED, status_); + case SCANNER_ERR_DEVICE_BUSY: + notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_PC_BUSY, SANE_EVENT_SCAN_FINISHED, status_); break; - case HG_ERR_DEVICE_STOPPED: + case SCANNER_ERR_DEVICE_STOPPED: notify_ui_working_status(STATU_DESC_SCAN_STOPPED, SANE_EVENT_SCAN_FINISHED, status_); break; - case HG_ERR_DEVICE_COVER_OPENNED: - notify_ui_working_status(STATU_DESC_HG_ERR_DEVICE_COVER_OPENNED, SANE_EVENT_SCAN_FINISHED, status_); + case SCANNER_ERR_DEVICE_COVER_OPENNED: + notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_COVER_OPENNED, SANE_EVENT_SCAN_FINISHED, status_); break; - case HG_ERR_DEVICE_NO_PAPER: - notify_ui_working_status(STATU_DESC_HG_ERR_DEVICE_NO_PAPER, SANE_EVENT_SCAN_FINISHED, status_); + case SCANNER_ERR_DEVICE_NO_PAPER: + notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER, SANE_EVENT_SCAN_FINISHED, status_); break; - case HG_ERR_DEVICE_FEEDING_PAPER: - notify_ui_working_status(STATU_DESC_HG_ERR_DEVICE_FEEDING_PAPER, SANE_EVENT_SCAN_FINISHED, status_); + case SCANNER_ERR_DEVICE_FEEDING_PAPER: + notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_FEEDING_PAPER, SANE_EVENT_SCAN_FINISHED, status_); break; - case HG_ERR_DEVICE_NOT_FOUND: - notify_ui_working_status(STATU_DESC_HG_ERR_DEVICE_NOT_FOUND, SANE_EVENT_SCAN_FINISHED, status_); + case SCANNER_ERR_DEVICE_NOT_FOUND: + notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_NOT_FOUND, SANE_EVENT_SCAN_FINISHED, status_); break; - case HG_ERR_DEVICE_SLEEPING: - notify_ui_working_status(STATU_DESC_HG_ERR_DEVICE_SLEEPING, SANE_EVENT_SCAN_FINISHED, status_); + case SCANNER_ERR_DEVICE_SLEEPING: + notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING, SANE_EVENT_SCAN_FINISHED, status_); break; - case HG_ERR_DEVICE_COUNT_MODE: - notify_ui_working_status(STATU_DESC_HG_ERR_DEVICE_COUNT_MODE, SANE_EVENT_SCAN_FINISHED, status_); + case SCANNER_ERR_DEVICE_COUNT_MODE: + notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_COUNT_MODE, SANE_EVENT_SCAN_FINISHED, status_); break; - case HG_ERR_DEVICE_DOUBLE_FEEDING: - notify_ui_working_status(STATU_DESC_HG_ERR_DEVICE_DOUBLE_FEEDING, SANE_EVENT_SCAN_FINISHED, status_); + case SCANNER_ERR_DEVICE_DOUBLE_FEEDING: + notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_DOUBLE_FEEDING, SANE_EVENT_SCAN_FINISHED, status_); break; - case HG_ERR_DEVICE_PAPER_JAMMED: - notify_ui_working_status(STATU_DESC_HG_ERR_DEVICE_PAPER_JAMMED, SANE_EVENT_SCAN_FINISHED, status_); + case SCANNER_ERR_DEVICE_PAPER_JAMMED: + notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_PAPER_JAMMED, SANE_EVENT_SCAN_FINISHED, status_); break; - case HG_ERR_DEVICE_STAPLE_ON: - notify_ui_working_status(STATU_DESC_HG_ERR_DEVICE_STAPLE_ON, SANE_EVENT_SCAN_FINISHED, status_); + case SCANNER_ERR_DEVICE_STAPLE_ON: + notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_STAPLE_ON, SANE_EVENT_SCAN_FINISHED, status_); break; - case HG_ERR_DEVICE_PAPER_SKEW: - notify_ui_working_status(STATU_DESC_HG_ERR_DEVICE_PAPER_SKEW, SANE_EVENT_SCAN_FINISHED, status_); + case SCANNER_ERR_DEVICE_PAPER_SKEW: + notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_PAPER_SKEW, SANE_EVENT_SCAN_FINISHED, status_); break; - case HG_ERR_DEVICE_SIZE_CHECK: - notify_ui_working_status(STATU_DESC_HG_ERR_DEVICE_SIZE_CHECK, SANE_EVENT_SCAN_FINISHED, status_); + case SCANNER_ERR_DEVICE_SIZE_CHECK: + notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_SIZE_CHECK, SANE_EVENT_SCAN_FINISHED, status_); break; - case HG_ERR_DEVICE_DOGEAR: - notify_ui_working_status(STATU_DESC_HG_ERR_DEVICE_DOGEAR, SANE_EVENT_SCAN_FINISHED, status_); + case SCANNER_ERR_DEVICE_DOGEAR: + notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_DOGEAR, SANE_EVENT_SCAN_FINISHED, status_); break; - case HG_ERR_DEVICE_NO_IMAGE: - notify_ui_working_status(STATU_DESC_HG_ERR_DEVICE_NO_IMAGE, SANE_EVENT_SCAN_FINISHED, status_); + case SCANNER_ERR_DEVICE_NO_IMAGE: + notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_NO_IMAGE, SANE_EVENT_SCAN_FINISHED, status_); break; - case HG_ERR_DEVICE_SCANN_ERROR: - notify_ui_working_status(STATU_DESC_HG_ERR_DEVICE_SCANN_ERROR, SANE_EVENT_SCAN_FINISHED, status_); + case SCANNER_ERR_DEVICE_SCANN_ERROR: + notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_SCANN_ERROR, SANE_EVENT_SCAN_FINISHED, status_); break; - case HG_ERR_DEVICE_PC_BUSY: - notify_ui_working_status(STATU_DESC_HG_ERR_DEVICE_PC_BUSY, SANE_EVENT_SCAN_FINISHED, status_); + case SCANNER_ERR_DEVICE_PC_BUSY: + notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_PC_BUSY, SANE_EVENT_SCAN_FINISHED, status_); break; default: notify_ui_working_status(user_cancel_ ? STATU_DESC_SCAN_CANCELED : STATU_DESC_SCAN_STOPPED, SANE_EVENT_SCAN_FINISHED, status_); @@ -822,11 +822,11 @@ void hg_scanner::working_done(void*) if (test_1_paper_) { - HG_LOG(HG_LOG_LEVEL_DEBUG_INFO, "scanning mode: finished testing ONE paper, restore to normal scanning.\n"); + HG_LOG(LOG_LEVEL_DEBUG_INFO, "scanning mode: finished testing ONE paper, restore to normal scanning.\n"); } else { - HG_VLOG_MINI_2(HG_LOG_LEVEL_DEBUG_INFO, "scanned %d picture(s) and finished with error %s.\n", final_img_index_, hg_scanner::strerr((hg_err)status_).c_str()); + HG_VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "scanned %d picture(s) and finished with error %s.\n", final_img_index_, hg_scanner::strerr((scanner_err)status_).c_str()); } test_1_paper_ = false; @@ -912,11 +912,11 @@ int hg_scanner::setting_restore(void* data) restore(i); notify_setting_result_ = true; - return HG_ERR_CONFIGURATION_CHANGED; + return SCANNER_ERR_CONFIGURATION_CHANGED; } int hg_scanner::setting_help(void* data) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; if (name_ == "华高扫描仪—G100") //保留 { @@ -935,23 +935,23 @@ int hg_scanner::setting_help(void* data) if (access(helpfile.c_str(),F_OK) == -1) #endif { - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"App_Help_pdf path is:%s\r\n",hg_scanner::strerr((hg_err)ret).c_str()); - ret = HG_ERR_OPEN_FILE_FAILED; + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"App_Help_pdf path is:%s\r\n",hg_scanner::strerr((scanner_err)ret).c_str()); + ret = SCANNER_ERR_OPEN_FILE_FAILED; return ret ; } com += helpfile; system(com.c_str()); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"App_Help_pdf path is:%s system is:%d\r\n",helpfile.c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"App_Help_pdf path is:%s system is:%d\r\n",helpfile.c_str()); return ret; } int hg_scanner::setting_color_mode(void* data) { std::string str((char*)data); int old = image_prc_param_.bits.color_mode, - sub = HG_ERR_OK, + sub = SCANNER_ERR_OK, val = 0, - ret = HG_ERR_OK; + ret = SCANNER_ERR_OK; bool exact = check_range(setting_map_[HG_BASE_SETTING_INDEX_COLOR_MODE], str); val = image_prc_param_.bits.color_mode = match_best_color_mode(str, NULL); @@ -959,11 +959,11 @@ int hg_scanner::setting_color_mode(void* data) sub = on_color_mode_changed(val); image_prc_param_.bits.color_mode = val; - if (sub == HG_ERR_NOT_EXACT) + if (sub == SCANNER_ERR_NOT_EXACT) { image_prc_param_.bits.color_mode = old; str = color_mode_string(image_prc_param_.bits.color_mode); - ret = HG_ERR_NOT_EXACT; + ret = SCANNER_ERR_NOT_EXACT; } else if (sub) { @@ -972,24 +972,24 @@ int hg_scanner::setting_color_mode(void* data) } else if (!exact) { - ret = HG_ERR_NOT_EXACT; + ret = SCANNER_ERR_NOT_EXACT; } is_auto_matic_color = image_prc_param_.bits.color_mode == COLOR_MODE_AUTO_MATCH ? true :false; // 等于COLOR_MODE_AUTO_MATCH 的时候颜色模式需要变为2 彩色模式图像参数和硬件参数都如此 - HG_VLOG_MINI_4(HG_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::strerr((hg_err)ret).c_str(),str.c_str()); - if(ret == HG_ERR_NOT_EXACT) + HG_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::strerr((scanner_err)ret).c_str(),str.c_str()); + if(ret == SCANNER_ERR_NOT_EXACT) strcpy((char*)data, str.c_str()); return ret; } int hg_scanner::setting_multi_out(void *data) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; if(image_prc_param_.bits.color_mode != 2) { - ret = HG_ERR_INVALID_PARAMETER; + ret = SCANNER_ERR_INVALID_PARAMETER; return ret; } std::string str((char*)data); @@ -997,7 +997,7 @@ int hg_scanner::setting_multi_out(void *data) bool exact = check_range(setting_map_[HG_BASE_SETTING_INDEX_MULTI_OUT], str); int color; image_prc_param_.bits.multi_out = match_best_multi_out(str,NULL); - HG_VLOG_MINI_3(HG_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::strerr((hg_err)ret).c_str()); + HG_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::strerr((scanner_err)ret).c_str()); if (image_prc_param_.bits.multi_out == MULTI_GRAY_AND_BW) color = COLOR_MODE_256_GRAY; @@ -1011,7 +1011,7 @@ int hg_scanner::setting_multi_out(void *data) int hg_scanner::setting_rid_color(void* data) { std::string str((char*)data); - int ret = HG_ERR_OK, + int ret = SCANNER_ERR_OK, color = -1, old = image_prc_param_.bits.rid_color; bool exact = check_range(setting_map_[HG_BASE_SETTING_INDEX_ERASE_COLOR], str); @@ -1023,7 +1023,7 @@ int hg_scanner::setting_rid_color(void* data) if (!exact) { - ret = HG_ERR_NOT_EXACT; + ret = SCANNER_ERR_NOT_EXACT; strcpy((char*)data, str.c_str()); } @@ -1033,28 +1033,28 @@ int hg_scanner::setting_rid_multi_red(void* data) { image_prc_param_.bits.rid_red = *((bool*)data); - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner::setting_rid_answer_red(void* data) { image_prc_param_.bits.rid_answer_red = *((bool*)data); - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner::setting_erase_background(void* data) { image_prc_param_.bits.erase_bakground = *((bool*)data); - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner::setting_erase_background_range(void* data) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; erase_bkg_range_ = *((int*)data); if (!check_range(setting_map_[HG_BASE_SETTING_INDEX_ERASE_BACKGROUND_RANGE], erase_bkg_range_)) { - ret = HG_ERR_NOT_EXACT; + ret = SCANNER_ERR_NOT_EXACT; *((int*)data) = erase_bkg_range_; } @@ -1064,16 +1064,16 @@ int hg_scanner::setting_noise_optimize(void* data) { image_prc_param_.bits.noise_optimize = *((bool*)data); - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner::setting_noise_optimize_range(void* data) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; noise_range_ = *((int*)data); if (!check_range(setting_map_[HG_BASE_SETTING_INDEX_NOISE_OPTIMIZE_SIZE], noise_range_)) { - ret = HG_ERR_NOT_EXACT; + ret = SCANNER_ERR_NOT_EXACT; *((int*)data) = noise_range_; } @@ -1083,14 +1083,14 @@ int hg_scanner::setting_paper(void* data) { std::string paper((char*)data); bool exact = check_range(setting_map_[HG_BASE_SETTING_INDEX_PAPER], paper); - int ret = HG_ERR_OK, sub = HG_ERR_OK, + int ret = SCANNER_ERR_OK, sub = SCANNER_ERR_OK, val = 0, old = image_prc_param_.bits.paper; val = image_prc_param_.bits.paper = match_best_paper(paper, NULL); sub = on_paper_changed(val); image_prc_param_.bits.paper = val; - if (sub == HG_ERR_NOT_EXACT) + if (sub == SCANNER_ERR_NOT_EXACT) { ret = sub; paper = paper_string(image_prc_param_.bits.paper); @@ -1101,11 +1101,11 @@ int hg_scanner::setting_paper(void* data) image_prc_param_.bits.paper = old; } else if (!exact) - ret = HG_ERR_NOT_EXACT; + ret = SCANNER_ERR_NOT_EXACT; - HG_VLOG_MINI_3(HG_LOG_LEVEL_DEBUG_INFO, "Change paper from %s to %s = %s\n", paper_string(old).c_str(), (char*)data, hg_scanner::strerr((hg_err)ret).c_str()); + HG_VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "Change paper from %s to %s = %s\n", paper_string(old).c_str(), (char*)data, hg_scanner::strerr((scanner_err)ret).c_str()); - if(ret == HG_ERR_NOT_EXACT) + if(ret == SCANNER_ERR_NOT_EXACT) strcpy((char*)data, paper.c_str()); if(old != image_prc_param_.bits.paper) reset_custom_area_range(image_prc_param_.bits.paper); @@ -1117,7 +1117,7 @@ int hg_scanner::setting_paper_check(void* data) bool use = *((bool*)data); int ret = on_paper_check_changed(use); - HG_VLOG_MINI_2(HG_LOG_LEVEL_DEBUG_INFO, "Change paper size-checking %s = %s\n", *((bool*)data) ? "enabled" : "disabled", hg_scanner::strerr((hg_err)ret).c_str()); + HG_VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "Change paper size-checking %s = %s\n", *((bool*)data) ? "enabled" : "disabled", hg_scanner::strerr((scanner_err)ret).c_str()); *((bool*)data) = use; return ret; @@ -1126,9 +1126,9 @@ int hg_scanner::setting_page(void* data) { std::string val((char*)data); bool exact = check_range(setting_map_[HG_BASE_SETTING_INDEX_PAGE], val); - int ret = exact ? HG_ERR_OK : HG_ERR_NOT_EXACT; + int ret = exact ? SCANNER_ERR_OK : SCANNER_ERR_NOT_EXACT; - HG_VLOG_MINI_3(HG_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::strerr((hg_err)ret).c_str()); + HG_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::strerr((scanner_err)ret).c_str()); image_prc_param_.bits.page = match_best_page(val, NULL); if (!exact) strcpy((char*)data, val.c_str()); @@ -1137,12 +1137,12 @@ int hg_scanner::setting_page(void* data) } int hg_scanner::setting_page_omit_empty(void* data) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; omit_empty_level_ = *((int*)data); if (!check_range(setting_map_[HG_BASE_SETTING_INDEX_PAGE_OMIT_EMPTY_LEVEL], omit_empty_level_)) { - ret = HG_ERR_NOT_EXACT; + ret = SCANNER_ERR_NOT_EXACT; *((int*)data) = omit_empty_level_; } @@ -1150,20 +1150,20 @@ int hg_scanner::setting_page_omit_empty(void* data) } int hg_scanner::setting_resolution(void* data) { - int ret = HG_ERR_OK, + int ret = SCANNER_ERR_OK, old = resolution_, - sub = HG_ERR_OK; + sub = SCANNER_ERR_OK; resolution_ = *((int*)data); if (!check_range(setting_map_[HG_BASE_SETTING_INDEX_RESOLUTION], resolution_)) - ret = HG_ERR_NOT_EXACT; + ret = SCANNER_ERR_NOT_EXACT; sub = on_resolution_changed(resolution_); - if (sub == HG_ERR_NOT_EXACT) + if (sub == SCANNER_ERR_NOT_EXACT) ret = sub; else if (sub) ret = sub; - HG_VLOG_MINI_3(HG_LOG_LEVEL_DEBUG_INFO, "Change resolution from %d to %d = %s\n", old, *((int*)data), hg_scanner::strerr((hg_err)ret).c_str()); + HG_VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "Change resolution from %d to %d = %s\n", old, *((int*)data), hg_scanner::strerr((scanner_err)ret).c_str()); *((int*)data) = resolution_; return ret; @@ -1172,50 +1172,50 @@ int hg_scanner::setting_exchagnge(void* data) { image_prc_param_.bits.exchange = *((bool*)data); - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner::setting_split_image(void* data) { image_prc_param_.bits.split = *((bool*)data); - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner::setting_automatic_skew(void* data) { // automatic_skew_detection_ = *((bool*)data); image_prc_param_.bits.automatic_skew = *((bool*)data); - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner::setting_rid_hole(void* data) { image_prc_param_.bits.rid_hole = *((bool*)data); - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner::setting_rid_hoe_range(void* data) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; rid_hole_range_ = *((double*)data); if (!check_range(setting_map_[HG_BASE_SETTING_INDEX_RID_HOLE_RANGE], rid_hole_range_)) { - ret = HG_ERR_NOT_EXACT; + ret = SCANNER_ERR_NOT_EXACT; *((int*)data) = rid_hole_range_; } rid_hole_range_*=100; - HG_VLOG_MINI_1(HG_LOG_LEVEL_WARNING, "rid_hole_range_ = %f\r\n", rid_hole_range_); + HG_VLOG_MINI_1(LOG_LEVEL_WARNING, "rid_hole_range_ = %f\r\n", rid_hole_range_); return ret; } int hg_scanner::setting_bright(void* data) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; bright_ = *((int*)data); if (!check_range(setting_map_[HG_BASE_SETTING_INDEX_BRIGHT], bright_)) { - ret = HG_ERR_NOT_EXACT; + ret = SCANNER_ERR_NOT_EXACT; *((int*)data) = bright_; } @@ -1223,12 +1223,12 @@ int hg_scanner::setting_bright(void* data) } int hg_scanner::setting_contrast(void* data) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; contrast_ = *((int*)data); if (!check_range(setting_map_[HG_BASE_SETTING_INDEX_CONTRAST], contrast_)) { - ret = HG_ERR_NOT_EXACT; + ret = SCANNER_ERR_NOT_EXACT; *((int*)data) = contrast_; } @@ -1236,12 +1236,12 @@ int hg_scanner::setting_contrast(void* data) } int hg_scanner::setting_gamma(void* data) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; gamma_ = *((double*)data); if (!check_range(setting_map_[HG_BASE_SETTING_INDEX_GAMMA], gamma_)) { - ret = HG_ERR_NOT_EXACT; + ret = SCANNER_ERR_NOT_EXACT; *((double*)data) = gamma_; } @@ -1250,18 +1250,18 @@ int hg_scanner::setting_gamma(void* data) int hg_scanner::setting_sharpen(void* data) { std::string str((char*)data); - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; bool exact = check_range(setting_map_[HG_BASE_SETTING_INDEX_SHARPEN], str); - HG_VLOG_MINI_2(HG_LOG_LEVEL_DEBUG_INFO, "Change sharpen from %s to %s = ", sharpen_string(image_prc_param_.bits.sharpen).c_str(), (char*)data); + HG_VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "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) { strcpy((char*)data, str.c_str()); - ret = HG_ERR_NOT_EXACT; + ret = SCANNER_ERR_NOT_EXACT; } - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "%d\n", ret); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "%d\n", ret); return ret; } @@ -1269,22 +1269,22 @@ int hg_scanner::setting_dark_sample(void* data) { image_prc_param_.bits.dark_sample = *((bool*)data); - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner::setting_erase_black_frame(void* data) { image_prc_param_.bits.erase_black_frame = *((bool*)data); - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner::setting_threshold(void* data) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; threshold_ = *((int*)data); if (!check_range(setting_map_[HG_BASE_SETTING_INDEX_THRESHOLD], threshold_)) { - ret = HG_ERR_NOT_EXACT; + ret = SCANNER_ERR_NOT_EXACT; *((int*)data) = threshold_; } @@ -1292,12 +1292,12 @@ int hg_scanner::setting_threshold(void* data) } int hg_scanner::setting_anti_noise(void* data) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; anti_noise_ = *((int*)data); if (!check_range(setting_map_[HG_BASE_SETTING_INDEX_ANTI_NOISE_LEVEL], anti_noise_)) { - ret = HG_ERR_NOT_EXACT; + ret = SCANNER_ERR_NOT_EXACT; *((int*)data) = anti_noise_; } @@ -1305,12 +1305,12 @@ int hg_scanner::setting_anti_noise(void* data) } int hg_scanner::setting_margin(void* data) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; margin_ = *((int*)data); if (!check_range(setting_map_[HG_BASE_SETTING_INDEX_MARGIN], margin_)) { - ret = HG_ERR_NOT_EXACT; + ret = SCANNER_ERR_NOT_EXACT; *((int*)data) = margin_; } @@ -1320,13 +1320,13 @@ int hg_scanner::setting_filling_background(void* data) { std::string str((char*)data); bool exact = check_range(setting_map_[HG_BASE_SETTING_INDEX_FILL_BACKGROUND], str); - int ret = exact ? HG_ERR_OK : HG_ERR_NOT_EXACT; + int ret = exact ? SCANNER_ERR_OK : SCANNER_ERR_NOT_EXACT; image_prc_param_.bits.fill_background = match_best_fill_background(str, NULL); if (!exact) { strcpy((char*)data, str.c_str()); - ret = HG_ERR_NOT_EXACT; + ret = SCANNER_ERR_NOT_EXACT; } return ret; @@ -1334,23 +1334,23 @@ int hg_scanner::setting_filling_background(void* data) int hg_scanner::setting_is_permeate(void* data) { image_prc_param_.bits.is_permeate = *((bool*)data); - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner::setting_is_permeate_lv(void* data) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; std::string str((char*)data); bool exact = check_range(setting_map_[HG_BASE_SETTING_INDEX_PERMEATE_LV], str); - HG_VLOG_MINI_2(HG_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); + HG_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); image_prc_param_.bits.is_permeate_lv_ = match_best_permaeate_lv(str, NULL); if (!exact) { strcpy((char*)data, str.c_str()); - ret = HG_ERR_NOT_EXACT; + ret = SCANNER_ERR_NOT_EXACT; } - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "%d\n", ret); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "%d\n", ret); return ret; @@ -1359,19 +1359,19 @@ int hg_scanner::setting_remove_morr(void* data) { image_prc_param_.bits.remove_morr = *((bool*)data); - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner::setting_error_extention(void* data) { image_prc_param_.bits.error_extention = *((bool*)data); - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner::setting_remove_texture(void* data) { image_prc_param_.bits.remove_txtture = *((bool*)data); - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner::setting_ultrasonic_check(void* data) { @@ -1397,7 +1397,7 @@ int hg_scanner::setting_scan_mode(void* data) { std::string str((char*)data); bool exact = check_range(setting_map_[HG_BASE_SETTING_INDEX_SCAN_MODE], str); - int ret = exact ? HG_ERR_OK : HG_ERR_NOT_EXACT; + int ret = exact ? SCANNER_ERR_OK : SCANNER_ERR_NOT_EXACT; if (strcmp(str.c_str(), OPTION_VALUE_SMZS_LXSM) == 0) { @@ -1410,13 +1410,13 @@ int hg_scanner::setting_scan_mode(void* data) setting_jsn_.at(key).at("cur").get_to(scan_count_); } - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "set scanning pages to %d\n", scan_count_); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "set scanning pages to %d\n", scan_count_); return ret; } int hg_scanner::setting_scan_count(void* data) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; char key[20]; std::string val(""); @@ -1431,7 +1431,7 @@ int hg_scanner::setting_scan_count(void* data) scan_count_ = *((int*)data); } - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "set scanning pages to %d\n", scan_count_); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "set scanning pages to %d\n", scan_count_); return ret; } @@ -1439,10 +1439,10 @@ int hg_scanner::setting_text_direction(void* data) { std::string str((char*)data); bool exact = check_range(setting_map_[HG_BASE_SETTING_INDEX_TEXT_DIRECTION], str); - int ret = exact ? HG_ERR_OK : HG_ERR_NOT_EXACT; + int ret = exact ? SCANNER_ERR_OK : SCANNER_ERR_NOT_EXACT; - HG_VLOG_MINI_3(HG_LOG_LEVEL_DEBUG_INFO, "Change text direction from '%s' to '%s' = %s\n", text_direction_string(image_prc_param_.bits.text_direction).c_str() - , (char*)data, hg_scanner::strerr((hg_err)ret).c_str()); + HG_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() + , (char*)data, hg_scanner::strerr((scanner_err)ret).c_str()); image_prc_param_.bits.text_direction = match_best_text_direction(str, NULL); if (!exact) strcpy((char*)data, str.c_str()); @@ -1453,22 +1453,22 @@ int hg_scanner::setting_rotate_bkg_180(void* data) { image_prc_param_.bits.rotate_back_180 = *((bool*)data); - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner::setting_fractate_check(void* data) { image_prc_param_.bits.fractate_check = *((bool*)data); - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner::setting_fractate_check_level(void* data) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; fractate_level_ = *((int*)data); if (!check_range(setting_map_[HG_BASE_SETTING_INDEX_FRACTATE_CHECK_LEVEL], fractate_level_)) { - ret = HG_ERR_NOT_EXACT; + ret = SCANNER_ERR_NOT_EXACT; *((int*)data) = fractate_level_; } @@ -1488,7 +1488,7 @@ int hg_scanner::setting_skew_check_level(void* data) { int level = *((int*)data); bool exact = check_range(setting_map_[HG_BASE_SETTING_INDEX_SKEW_CHECK_LEVEL], level); - int ret = exact ? HG_ERR_OK : HG_ERR_NOT_EXACT, + int ret = exact ? SCANNER_ERR_OK : SCANNER_ERR_NOT_EXACT, sub = on_skew_check_level_changed(level); if (sub) @@ -1506,7 +1506,7 @@ int hg_scanner::setting_is_custom_gamma(void* data) custom_gamma_ = *v == SANE_TRUE; - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner::setting_custom_gamma_data(void* data) { @@ -1514,7 +1514,7 @@ int hg_scanner::setting_custom_gamma_data(void* data) memcpy(custom_gamma_val_, gamma, sizeof(*custom_gamma_val_)); - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner::setting_is_custom_area(void* data) { @@ -1522,7 +1522,7 @@ int hg_scanner::setting_is_custom_area(void* data) custom_area_ = *v == SANE_TRUE; - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner::setting_custom_area_left(void* data) { @@ -1530,7 +1530,7 @@ int hg_scanner::setting_custom_area_left(void* data) custom_area_lt_x_ = *((double*)data); - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner::setting_custom_area_top(void* data) { @@ -1538,7 +1538,7 @@ int hg_scanner::setting_custom_area_top(void* data) custom_area_lt_y_ = *((double*)data); - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner::setting_custom_area_right(void* data) { @@ -1546,7 +1546,7 @@ int hg_scanner::setting_custom_area_right(void* data) custom_area_br_x_ = *((double*)data); - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner::setting_custom_area_bottom(void* data) { @@ -1555,68 +1555,68 @@ int hg_scanner::setting_custom_area_bottom(void* data) custom_area_br_y_ = *((double*)data); - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner::setting_img_quality(void *data) { std::string str((char*)data); bool exact = check_range(setting_map_[HG_BASE_SETTING_INDEX_IMG_QUALITY], str); - int ret = exact ? HG_ERR_OK : HG_ERR_NOT_EXACT; + int ret = exact ? SCANNER_ERR_OK : SCANNER_ERR_NOT_EXACT; - HG_VLOG_MINI_3(HG_LOG_LEVEL_DEBUG_INFO, "Change quality from '%s' to '%s' = %s\n", is_img_quality(is_quality_).c_str() - , (char*)data, hg_scanner::strerr((hg_err)ret).c_str()); + HG_VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "Change quality from '%s' to '%s' = %s\n", is_img_quality(is_quality_).c_str() + , (char*)data, hg_scanner::strerr((scanner_err)ret).c_str()); is_quality_ = match_best_img_quality(str,NULL); - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner::on_color_mode_changed(int& color_mode) { - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner::on_paper_changed(int& paper) { - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner::on_paper_check_changed(bool& check) { - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner::on_resolution_changed(int& dpi) { - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner::on_ultrasonic_check_changed(bool& check) { - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner::on_staple_check_changed(bool& check) { - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner::on_skew_check_changed(bool& check) { - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner::on_skew_check_level_changed(int& check) { - return HG_ERR_OK; + return SCANNER_ERR_OK; } void hg_scanner::on_device_reconnected(void) { std::lock_guard lock(io_lock_); - HG_VLOG_MINI_2(HG_LOG_LEVEL_DEBUG_INFO, "%04x:%04x reconnected.\n", io_->get_vid(), io_->get_pid()); + HG_VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "%04x:%04x reconnected.\n", io_->get_vid(), io_->get_pid()); } int hg_scanner::set_setting_value(int setting_no, void* data, int len) { - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner::on_scanner_closing(bool force) { - return HG_ERR_OK; + return SCANNER_ERR_OK; } void hg_scanner::thread_handle_usb_read(void) { @@ -1687,11 +1687,11 @@ int hg_scanner::on_scann_error(int err) { status_ = err; - HG_VLOG_MINI_1(HG_LOG_LEVEL_FATAL, "[xxx]Device status: 0x%x\n", err); + HG_VLOG_MINI_1(LOG_LEVEL_FATAL, "[xxx]Device status: 0x%x\n", err); unsigned int e = err; - return ui_ev_cb_((scanner_handle)this, SANE_EVENT_ERROR, (void*)hg_scanner::strerr((hg_err)err).c_str(), &e, NULL); + return ui_ev_cb_((scanner_handle)this, SANE_EVENT_ERROR, (void*)hg_scanner::strerr((scanner_err)err).c_str(), &e, NULL); } int hg_scanner::notify_ui_working_status(const char* msg, int ev, int status) { @@ -1709,13 +1709,13 @@ bool hg_scanner::waiting_for_memory_enough(unsigned need_bytes) { int ret = ui_ev_cb_((scanner_handle)this, SANE_EVENT_IS_MEMORY_ENOUGH, NULL, &need_bytes, NULL); - if (ret == HG_ERR_INSUFFICIENT_MEMORY) + if (ret == SCANNER_ERR_INSUFFICIENT_MEMORY) { user_cancel_ = true; - status_ = HG_ERR_INSUFFICIENT_MEMORY; + status_ = SCANNER_ERR_INSUFFICIENT_MEMORY; ret = false; } - else if (ret == HG_ERR_NOT_ANY_MORE) + else if (ret == SCANNER_ERR_NOT_ANY_MORE) cb_mem_ = false; } else @@ -1728,7 +1728,7 @@ bool hg_scanner::waiting_for_memory_enough(unsigned need_bytes) { if (first) { - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "Memory is too small for aquiring image(%u bytes), wait for ENOUGH ...\n", need_bytes); + HG_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(STATU_DESC_WAIT_FOR_MEM); first = false; } @@ -1739,11 +1739,11 @@ bool hg_scanner::waiting_for_memory_enough(unsigned need_bytes) { if (buf) { - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "waited for memory need(%u)\n", need_bytes); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "waited for memory need(%u)\n", need_bytes); } else { - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "canceled by user while waiting for memory need(%u)\n", need_bytes); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "canceled by user while waiting for memory need(%u)\n", need_bytes); } } ret = (!user_cancel_) && (buf != NULL); @@ -1768,16 +1768,16 @@ void hg_scanner::copy_to_sane_image_header(SANE_Parameters* header, int w, int h } int hg_scanner::save_usb_data(std::shared_ptr> data) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; usb_img_index_++; - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "USB read one picture with %u bytes\n", data->size()); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "USB read one picture with %u bytes\n", data->size()); if (is_to_file()) { std::string file(""); ret = hg_scanner::save_2_tempory_file(data, &file, usb_img_index_); - if (ret == HG_ERR_OK) + if (ret == SCANNER_ERR_OK) paths_.Put(file); } else @@ -1808,7 +1808,7 @@ int hg_scanner::save_final_image(hg_imgproc::LPIMGHEAD head, void* buf) final_imgs_.put(head->width, head->height, head->bits, head->channels, head->line_bytes, buf, head->total_bytes); - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner::is_running(void) { @@ -1828,7 +1828,7 @@ int hg_scanner::reset_io(usb_io* io) { online_ = false; if (!io) - return HG_ERR_INVALID_PARAMETER; + return SCANNER_ERR_INVALID_PARAMETER; { std::lock_guard lock(io_lock_); @@ -1838,13 +1838,13 @@ int hg_scanner::reset_io(usb_io* io) io->add_ref(); io_ = io; status_ = io_->last_error(); - online_ = status_ == HG_ERR_OK; + online_ = status_ == SCANNER_ERR_OK; if (old) old->release(); } on_device_reconnected(); - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner::io_disconnected(void) { @@ -1853,7 +1853,7 @@ int hg_scanner::io_disconnected(void) online_ = false; io_->on_disconnected(); - return HG_ERR_OK; + return SCANNER_ERR_OK; } void hg_scanner::set_ui_callback(sane_callback cb, bool enable_async_io) { @@ -1877,7 +1877,7 @@ int hg_scanner::close(bool force) int ret = on_scanner_closing(force); online_ = false; - if (ret == HG_ERR_OK) + if (ret == SCANNER_ERR_OK) { run_ = false; wait_usb_.notify(); @@ -1895,13 +1895,13 @@ int hg_scanner::close(bool force) } else if (io_) { - HG_LOG(HG_LOG_LEVEL_WARNING, "close scanner: USB thread or Image thread is still running.\n"); + HG_LOG(LOG_LEVEL_WARNING, "close scanner: USB thread or Image thread is still running.\n"); io_->close(); io_->release(); io_ = NULL; } - status_ = HG_ERR_NOT_OPEN; + status_ = SCANNER_ERR_NOT_OPEN; } return ret; @@ -1966,7 +1966,7 @@ int hg_scanner::set_setting(int setting_no, void* data, int len) }; bool hit = false; - int ret = HG_ERR_OUT_OF_RANGE; + int ret = SCANNER_ERR_OUT_OF_RANGE; char sn[20]; sprintf(sn, "%d", setting_no); @@ -1981,11 +1981,11 @@ int hg_scanner::set_setting(int setting_no, void* data, int len) } if (!hit) { - HG_VLOG_MINI_1(HG_LOG_LEVEL_WARNING, "Setting %d is not found in base setting functions.\n", setting_no); + HG_VLOG_MINI_1(LOG_LEVEL_WARNING, "Setting %d is not found in base setting functions.\n", setting_no); ret = set_setting_value(setting_no, data, len); } - if (ret == HG_ERR_OK || ret == HG_ERR_NOT_EXACT || ret == HG_ERR_CONFIGURATION_CHANGED) + if (ret == SCANNER_ERR_OK || ret == SCANNER_ERR_NOT_EXACT || ret == SCANNER_ERR_CONFIGURATION_CHANGED) { std::string type(""), name(""); @@ -2032,7 +2032,7 @@ int hg_scanner::set_setting(int setting_no, void* data, int len) else name = std::string("设置项") + sn; name.insert(0, "设置 “"); - name += "” 值失败: " + hg_scanner::strerr((hg_err)ret); + name += "” 值失败: " + hg_scanner::strerr((scanner_err)ret); notify_ui_working_status(name.c_str()); } @@ -2041,7 +2041,7 @@ int hg_scanner::set_setting(int setting_no, void* data, int len) int hg_scanner::get_setting(int setting_no, char* json_txt_buf, int* len) { if (!len) - return HG_ERR_INVALID_PARAMETER; + return SCANNER_ERR_INVALID_PARAMETER; if (setting_no == 0) { @@ -2049,10 +2049,10 @@ int hg_scanner::get_setting(int setting_no, char* json_txt_buf, int* len) setting_jsn_.at("option_count").get_to(count); *len = count; - return HG_ERR_OK; + return SCANNER_ERR_OK; } if (setting_count_ <= setting_no || setting_no < 0) - return HG_ERR_OUT_OF_RANGE; + return SCANNER_ERR_OUT_OF_RANGE; char sn[20]; std::string text(""), name(""), tag(""); @@ -2061,7 +2061,7 @@ int hg_scanner::get_setting(int setting_no, char* json_txt_buf, int* len) sprintf(sn, "%d", setting_no); if (!setting_jsn_.contains(sn)) - HG_VLOG_MINI_2(HG_LOG_LEVEL_FATAL, "!!!option(%d - %s) is not found.\n", setting_no, sn); + HG_VLOG_MINI_2(LOG_LEVEL_FATAL, "!!!option(%d - %s) is not found.\n", setting_no, sn); text = setting_jsn_.at(sn).dump(); setting_jsn_.at(sn).at("name").get_to(name); if (name == KNOWN_OPT_NAME_CUSTOM_GAMMA) @@ -2083,7 +2083,7 @@ int hg_scanner::get_setting(int setting_no, char* json_txt_buf, int* len) { *len = text.length() + 8 + add; - return HG_ERR_INSUFFICIENT_MEMORY; + return SCANNER_ERR_INSUFFICIENT_MEMORY; } if (is_gamma) @@ -2135,7 +2135,7 @@ int hg_scanner::get_setting(int setting_no, char* json_txt_buf, int* len) strcpy(json_txt_buf, text.c_str()); *len = text.length(); - return HG_ERR_OK; + return SCANNER_ERR_OK; } std::string hg_scanner::name(void) { @@ -2158,7 +2158,7 @@ int hg_scanner::start(void) } int hg_scanner::get_image_info(SANE_Parameters* ii) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; IMH imh; bzero(&imh, sizeof(imh)); @@ -2166,22 +2166,22 @@ int hg_scanner::get_image_info(SANE_Parameters* ii) this_thread::sleep_for(chrono::milliseconds(10)); if (final_imgs_.Size() <= 0) - ret = HG_ERR_NO_DATA; + ret = SCANNER_ERR_NO_DATA; else { if (!final_imgs_.front(&imh)) - ret = HG_ERR_NO_DATA; + ret = SCANNER_ERR_NO_DATA; else copy_to_sane_image_header(ii, imh.width, imh.height, imh.line_bytes, imh.channels); } - HG_VLOG_MINI_4(HG_LOG_LEVEL_DEBUG_INFO, "Get image info(%d * %d * %d) = %s\n", ii->pixels_per_line, ii->lines, imh.bits, hg_scanner::strerr((hg_err)ret).c_str()); + HG_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::strerr((scanner_err)ret).c_str()); return ret; } int hg_scanner::read_image_data(unsigned char* buf, int* len) { if (!len) - return HG_ERR_INVALID_PARAMETER; + return SCANNER_ERR_INVALID_PARAMETER; if (!buf) { @@ -2189,7 +2189,7 @@ int hg_scanner::read_image_data(unsigned char* buf, int* len) final_imgs_.front(&imh); *len = imh.bytes; - return HG_ERR_INSUFFICIENT_MEMORY; + return SCANNER_ERR_INSUFFICIENT_MEMORY; } if (final_imgs_.Size() > 0) @@ -2199,10 +2199,10 @@ int hg_scanner::read_image_data(unsigned char* buf, int* len) final_imgs_.fetch_front(buf, len, &over); - return over ? HG_ERR_NO_DATA : HG_ERR_OK; + return over ? SCANNER_ERR_NO_DATA : SCANNER_ERR_OK; } else - return HG_ERR_NO_DATA; + return SCANNER_ERR_NO_DATA; } int hg_scanner::stop(void) { @@ -2220,7 +2220,7 @@ int hg_scanner::device_io_control(unsigned long code, void* data, unsigned* len) { setting_restore(data); - return HG_ERR_CONFIGURATION_CHANGED; + return SCANNER_ERR_CONFIGURATION_CHANGED; } else if (code == IO_CTRL_CODE_GET_DEFAULT_VALUE) { @@ -2229,7 +2229,7 @@ int hg_scanner::device_io_control(unsigned long code, void* data, unsigned* len) json jsn; int ret = get_setting(*len, jsn_txt, &size); - if (ret == HG_ERR_INSUFFICIENT_MEMORY) + if (ret == SCANNER_ERR_INSUFFICIENT_MEMORY) { jsn_txt = (char*)malloc(size + 4); bzero(jsn_txt, size + 4); @@ -2237,9 +2237,9 @@ int hg_scanner::device_io_control(unsigned long code, void* data, unsigned* len) jsn = jsonconfig::load_json_from_text(jsn_txt); free(jsn_txt); if (get_default_value(data, &jsn)) - ret = HG_ERR_OK; + ret = SCANNER_ERR_OK; else - ret = HG_ERR_DATA_DAMAGED; + ret = SCANNER_ERR_DATA_DAMAGED; } return ret; @@ -2274,16 +2274,16 @@ int hg_scanner::device_io_control(unsigned long code, void* data, unsigned* len) if (*len < fw.size()) { *len = fw.size(); - return HG_ERR_INSUFFICIENT_MEMORY; + return SCANNER_ERR_INSUFFICIENT_MEMORY; } char* buf = strcpy((char*)data, fw.c_str()); if (buf) { - return HG_ERR_OK; + return SCANNER_ERR_OK; } - return HG_ERR_DATA_DAMAGED; + return SCANNER_ERR_DATA_DAMAGED; } else if(code == IO_CTRL_CODE_GET_SERIAL) { @@ -2291,14 +2291,14 @@ int hg_scanner::device_io_control(unsigned long code, void* data, unsigned* len) if (*len < ser.size()) { *len = ser.size(); - return HG_ERR_INSUFFICIENT_MEMORY; + return SCANNER_ERR_INSUFFICIENT_MEMORY; } char* buf = strcpy((char*)data, ser.c_str()); if (buf) { - return HG_ERR_OK; + return SCANNER_ERR_OK; } - return HG_ERR_DATA_DAMAGED; + return SCANNER_ERR_DATA_DAMAGED; } else if (code == IO_CTRL_CODE_GET_HARDWARE_VERSION) { @@ -2306,15 +2306,15 @@ int hg_scanner::device_io_control(unsigned long code, void* data, unsigned* len) if (*len < ip.size()) { *len = ip.size(); - return HG_ERR_INSUFFICIENT_MEMORY; + return SCANNER_ERR_INSUFFICIENT_MEMORY; } char* buf = strcpy((char*)data, ip.c_str()); if (buf) { - return HG_ERR_OK; + return SCANNER_ERR_OK; } - return HG_ERR_DATA_DAMAGED; + return SCANNER_ERR_DATA_DAMAGED; } else if (code == IO_CTRL_CODE_GET_PAPER_ON) { @@ -2323,16 +2323,16 @@ int hg_scanner::device_io_control(unsigned long code, void* data, unsigned* len) else if(code == IO_CTRL_CODE_GET_POWER_LEVEL) { int val = 0, - ret = HG_ERR_OK; + ret = SCANNER_ERR_OK; if (*len < sizeof(int *)) { *len = sizeof(int *); - return HG_ERR_INSUFFICIENT_MEMORY; + return SCANNER_ERR_INSUFFICIENT_MEMORY; } ret = get_sleep_time(val); - if (ret == HG_ERR_OK) + if (ret == SCANNER_ERR_OK) { *((int *)data) = val; } @@ -2381,7 +2381,7 @@ int hg_scanner::device_io_control(unsigned long code, void* data, unsigned* len) memcpy(v, custom_gamma_val_, sizeof(*custom_gamma_val_)); - return HG_ERR_OK; + return SCANNER_ERR_OK; } else if (code == IO_CTRL_CODE_SET_CUSTOM_GAMMA) { @@ -2389,10 +2389,10 @@ int hg_scanner::device_io_control(unsigned long code, void* data, unsigned* len) memcpy(custom_gamma_val_, v, sizeof(*custom_gamma_val_)); - return HG_ERR_OK; + return SCANNER_ERR_OK; } - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } std::string hg_scanner::get_firmware_version(void) { @@ -2412,7 +2412,7 @@ int hg_scanner::get_roller_num(void) } int hg_scanner::clear_roller_num(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner::get_history_count(void) { @@ -2422,16 +2422,16 @@ int hg_scanner::get_history_count(void) ////////////////////////////////////////////////////////////////////////////////////////////////////// int hg_scanner::set_leaflet_scan(void) { - return HG_ERR_NO_DATA; + return SCANNER_ERR_NO_DATA; } int hg_scanner::get_abuot_info(void) { - return HG_ERR_NO_DATA; + return SCANNER_ERR_NO_DATA; } int hg_scanner::restore_default_setting(void) { - return HG_ERR_NO_DATA; + return SCANNER_ERR_NO_DATA; } int hg_scanner::set_final_image_format(SANE_FinalImgFormat* fmt) { @@ -2447,78 +2447,78 @@ int hg_scanner::set_final_image_format(SANE_FinalImgFormat* fmt) img_type_ = ".jpg"; break; case SANE_IMAGE_TYPE_TIFF: - return HG_ERR_INVALID_PARAMETER; + return SCANNER_ERR_INVALID_PARAMETER; case SANE_IMAGE_TYPE_WEBP: - return HG_ERR_INVALID_PARAMETER; + return SCANNER_ERR_INVALID_PARAMETER; case SANE_IMAGE_TYPE_PDF: - return HG_ERR_INVALID_PARAMETER; + return SCANNER_ERR_INVALID_PARAMETER; case SANE_IMAGE_TYPE_GIF: - return HG_ERR_INVALID_PARAMETER; + return SCANNER_ERR_INVALID_PARAMETER; case SANE_IMAGE_TYPE_SVG: - return HG_ERR_INVALID_PARAMETER; + return SCANNER_ERR_INVALID_PARAMETER; default: img_type_ = ""; break; } - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner::get_compression_format(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner::set_compression_format(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner::set_auto_color_type(void) { is_auto_matic_color = true; - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner::get_device_code(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner::get_sleep_time(int& getsleepime) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner::set_sleep_time(int sleeptime) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner::get_dogear_distance(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner::set_dogear_distance(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner::get_scanner_paperon(SANE_Bool* paperon) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner::set_scan_when_paper_on(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner::get_scan_when_paper_on(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner::get_scan_with_hole(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner::set_scan_with_hole(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner::get_scan_is_sleep(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } \ No newline at end of file diff --git a/hgdriver/hgdev/hg_scanner.h b/hgdriver/hgdev/hg_scanner.h index d6235f1..adb8364 100644 --- a/hgdriver/hgdev/hg_scanner.h +++ b/hgdriver/hgdev/hg_scanner.h @@ -88,6 +88,11 @@ enum }; #define MAPPING_FUNCTION_IN_BASE // 定义该标志，各子类不必再初始化setting_map_数组 +#ifdef OEM_HANWANG +#define hg_scanner hw_scanner +#elif defined(OEM_LISICHENG) +#define hg_scanner lsc_scanner +#endif class hg_scanner { @@ -249,7 +254,7 @@ protected: int on_scann_error(int err); // 返回“0”忽略错误继续执行，其它值则停止后续工作 // callback to ui ... - int notify_ui_working_status(const char* msg, int ev = SANE_EVENT_STATUS, int status = HG_ERR_OK); + int notify_ui_working_status(const char* msg, int ev = SANE_EVENT_STATUS, int status = SCANNER_ERR_OK); bool waiting_for_memory_enough(unsigned need_bytes); void copy_to_sane_image_header(SANE_Parameters* header, int w, int h, int line_bytes, int channels); @@ -303,8 +308,8 @@ public: hg_scanner(ScannerSerial serial, const char* dev_name, usb_io* io); virtual ~hg_scanner(); - static std::string strerr(hg_err err); - static std::string error_description(hg_err err); + static std::string strerr(scanner_err err); + static std::string error_description(scanner_err err); static std::string temporary_file(char* tail = NULL, char* head = NULL); static int save_2_tempory_file(std::shared_ptr> data, std::string* path_file, unsigned int index = 0); diff --git a/hgdriver/hgdev/hg_scanner_200.cpp b/hgdriver/hgdev/hg_scanner_200.cpp index 68cce16..0d92dba 100644 --- a/hgdriver/hgdev/hg_scanner_200.cpp +++ b/hgdriver/hgdev/hg_scanner_200.cpp @@ -9,16 +9,16 @@ static std::string jsontext("{\"device_type\":\"G100\",\"option_count\":54,\"1\":{\"category\":\"base\",\"name\":\"cfg-1\",\"title\":\"\\u6062\\u590d\\u9ed8\\u8ba4\\u8bbe\\u7f6e\",\"desc\":\"\\u6062\\u590d\\u9ed8\\u8ba4\\u8bbe\\u7f6e\",\"type\":\"button\",\"cur\":\"button\",\"default\":\"button\",\"size\":0},\"2\":{\"category\":\"advanced\",\"name\":\"cfg-2\",\"title\":\"\\u5e2e\\u52a9\",\"desc\":\"\\u663e\\u793a\\u8f6f\\u4ef6\\u5e2e\\u52a9\\u6587\\u6863\",\"type\":\"button\",\"cur\":\"true\",\"default\":\"true\",\"size\":4},\"3\":{\"category\":\"base\",\"name\":\"grp-1\",\"title\":\"\\u57fa\\u672c\\u8bbe\\u7f6e\",\"type\":\"group\"},\"4\":{\"category\":\"base\",\"name\":\"cfg-4\",\"title\":\"\\u989c\\u8272\\u6a21\\u5f0f\",\"desc\":\"\\u8bbe\\u7f6e\\u989c\\u8272\\u4f4d\\u6df1\",\"type\":\"string\",\"cur\":\"24\\u4f4d\\u5f69\\u8272\",\"default\":\"24\\u4f4d\\u5f69\\u8272\",\"size\":32,\"range\":[\"24\\u4f4d\\u5f69\\u8272\",\"256\\u7ea7\\u7070\\u5ea6\",\"\\u9ed1\\u767d\",\"\\u989c\\u8272\\u81ea\\u52a8\\u8bc6\\u522b\"]},\"5\":{\"category\":\"base\",\"name\":\"cfg-5\",\"title\":\"\\u7070\\u5ea6\\u6216\\u9ed1\\u767d\\u56fe\\u50cf - \\u9664\\u8272\",\"desc\":\"\\u9664\\u53bb\\u56fe\\u50cf\\u5f69\\u8272\",\"type\":\"string\",\"cur\":\"\\u4e0d\\u9664\\u8272\",\"default\":\"\\u4e0d\\u9664\\u8272\",\"size\":24,\"range\":[\"\\u4e0d\\u9664\\u8272\",\"\\u9664\\u7ea2\\u8272\",\"\\u9664\\u7eff\\u8272\",\"\\u9664\\u84dd\\u8272\",\"\\u7ea2\\u8272\\u589e\\u5f3a\",\"\\u7eff\\u8272\\u589e\\u5f3a\",\"\\u84dd\\u8272\\u589e\\u5f3a\"],\"depend_or\":[\"4==256\\u7ea7\\u7070\\u5ea6\",\"4==\\u9ed1\\u767d\"]},\"6\":{\"category\":\"base\",\"name\":\"cfg-6\",\"title\":\"\\u591a\\u6d41\\u8f93\\u51fa\",\"desc\":\"\",\"type\":\"string\",\"cur\":\"\\u65e0\",\"default\":\"\\u65e0\",\"size\":32,\"range\":[\"\\u65e0\",\"\\u5f69\\u8272+\\u7070\\u5ea6+\\u9ed1\\u767d\",\"\\u5f69\\u8272+\\u7070\\u5ea6\",\"\\u5f69\\u8272+\\u9ed1\\u767d\",\"\\u7070\\u5ea6+\\u9ed1\\u767d\"],\"depend_or\":[\"4==24\\u4f4d\\u5f69\\u8272\"]},\"7\":{\"category\":\"base\",\"name\":\"cfg-7\",\"title\":\"24\\u4f4d\\u5f69\\u8272\\u56fe\\u50cf - \\u591a\\u6d41\\u8f93\\u51fa\\u9664\\u7ea2\",\"desc\":\"\\u591a\\u901a\\u9053\\u8f93\\u51fa\\u4e2d\\uff0c\\u53bb\\u9664\\u7ea2\\u8272\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_or\":[\"4==24\\u4f4d\\u5f69\\u8272\"]},\"8\":{\"category\":\"base\",\"name\":\"cfg-8\",\"title\":\"24\\u4f4d\\u5f69\\u8272\\u56fe\\u50cf - \\u7b54\\u9898\\u5361\\u9664\\u7ea2\",\"desc\":\"\\u7b54\\u9898\\u5361\\u626b\\u63cf\\u4e2d\\u53bb\\u9664\\u7ea2\\u8272\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_or\":[\"4==24\\u4f4d\\u5f69\\u8272\"]},\"9\":{\"category\":\"base\",\"name\":\"cfg-9\",\"title\":\"\\u80cc\\u666f\\u79fb\\u9664\",\"desc\":\"\\u79fb\\u9664\\u5f69\\u8272\\u56fe\\u50cf\\u80cc\\u666f\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_or\":[\"4==24\\u4f4d\\u5f69\\u8272\"]},\"10\":{\"category\":\"base\",\"name\":\"cfg-10\",\"title\":\" \\u80cc\\u666f\\u8272\\u5f69\\u6d6e\\u52a8\\u8303\\u56f4\",\"desc\":\"\\u8bbe\\u5b9a\\u80cc\\u666f\\u8272\\u5f69\\u7684\\u6d6e\\u52a8\\u8303\\u56f4\\uff0c\\u5728\\u8be5\\u8303\\u56f4\\u5185\\u7684\\u90fd\\u5f53\\u4f5c\\u80cc\\u666f\\u79fb\\u9664\",\"type\":\"int\",\"cur\":20,\"default\":20,\"size\":4,\"range\":{\"min\":1,\"max\":128},\"depend_or\":[\"9==true\"]},\"11\":{\"category\":\"base\",\"name\":\"cfg-11\",\"title\":\"\\u9510\\u5316\\u4e0e\\u6a21\\u7cca\",\"desc\":\"\\u9510\\u5316\\u4e0e\\u6a21\\u7cca\",\"type\":\"string\",\"cur\":\"\\u65e0\",\"default\":\"\\u65e0\",\"size\":24,\"range\":[\"\\u65e0\",\"\\u9510\\u5316\",\"\\u8fdb\\u4e00\\u6b65\\u9510\\u5316\",\"\\u6a21\\u7cca\",\"\\u8fdb\\u4e00\\u6b65\\u6a21\\u7cca\"],\"depend_and\":[\"4!=\\u9ed1\\u767d\",\"4!=\\u989c\\u8272\\u81ea\\u52a8\\u8bc6\\u522b\"]},\"12\":{\"category\":\"base\",\"name\":\"cfg-12\",\"title\":\"\\u53bb\\u9664\\u6469\\u5c14\\u7eb9\",\"desc\":\"\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_and\":[\"4!=\\u9ed1\\u767d\",\"4!=\\u989c\\u8272\\u81ea\\u52a8\\u8bc6\\u522b\"]},\"13\":{\"category\":\"base\",\"name\":\"cfg-13\",\"title\":\"\\u9664\\u7f51\\u7eb9\",\"desc\":\"\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_and\":[\"4!=\\u9ed1\\u767d\",\"4!=\\u989c\\u8272\\u81ea\\u52a8\\u8bc6\\u522b\"]},\"14\":{\"category\":\"base\",\"name\":\"cfg-14\",\"title\":\"\\u9519\\u8bef\\u6269\\u6563\",\"desc\":\"\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_or\":[\"4==\\u9ed1\\u767d\"]},\"15\":{\"category\":\"base\",\"name\":\"cfg-15\",\"title\":\"\\u9ed1\\u767d\\u56fe\\u50cf\\u566a\\u70b9\\u4f18\\u5316\",\"desc\":\"\\u566a\\u70b9\\u4f18\\u5316\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_or\":[\"4==\\u9ed1\\u767d\"]},\"16\":{\"category\":\"base\",\"name\":\"cfg-16\",\"title\":\" \\u566a\\u70b9\\u4f18\\u5316\\u5c3a\\u5bf8\",\"desc\":\"\\u566a\\u70b9\\u4f18\\u5316\\u5c3a\\u5bf8\",\"type\":\"int\",\"cur\":30,\"default\":30,\"size\":4,\"range\":{\"min\":10,\"max\":50},\"depend_or\":[\"15==true\"]},\"17\":{\"category\":\"base\",\"name\":\"cfg-17\",\"title\":\"\\u7eb8\\u5f20\\u5c3a\\u5bf8\",\"desc\":\"\\u8bbe\\u7f6e\\u7eb8\\u5f20\\u5927\\u5c0f\",\"type\":\"string\",\"cur\":\"\\u5339\\u914d\\u539f\\u59cb\\u5c3a\\u5bf8\",\"default\":\"\\u5339\\u914d\\u539f\\u59cb\\u5c3a\\u5bf8\",\"size\":48,\"range\":[\"A3\",\"8\\u5f00\",\"A4\",\"A4\\u6a2a\\u5411\",\"16\\u5f00\",\"16\\u5f00\\u6a2a\\u5411\",\"A5\",\"A5\\u6a2a\\u5411\",\"A6\",\"A6\\u6a2a\\u5411\",\"B4\",\"B5\",\"B5\\u6a2a\\u5411\",\"B6\",\"B6\\u6a2a\\u5411\",\"Letter\",\"Letter\\u6a2a\\u5411\",\"Double Letter\",\"LEGAL\",\"\\u5339\\u914d\\u539f\\u59cb\\u5c3a\\u5bf8\",\"\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\\u81ea\\u52a8\\u88c1\\u5207\",\"\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\",\"\\u4e09\\u8054\\u8bd5\\u5377\"]},\"18\":{\"category\":\"base\",\"name\":\"cfg-18\",\"title\":\"\\u81ea\\u5b9a\\u4e49\\u626b\\u63cf\\u533a\\u57df\",\"desc\":\"\\u81ea\\u5b9a\\u4e49\\u626b\\u63cf\\u533a\\u57df\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_and\":[\"17!=\\u5339\\u914d\\u539f\\u59cb\\u5c3a\\u5bf8\",\"17!=\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\",\"17!=\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\\u81ea\\u52a8\\u88c1\\u5207\"]},\"19\":{\"category\":\"base\",\"name\":\"tl-x\",\"title\":\"\\u626b\\u63cf\\u533a\\u57df\\u5de6\\u4fa7\\uff08mm\\uff09\",\"desc\":\"\\u81ea\\u5b9a\\u4e49\\u626b\\u63cf\\u533a\\u57df\\u5de6\\u4e0a\\u89d2x\\u5750\\u6807\",\"type\":\"float\",\"cur\":0.000000,\"default\":0.000000,\"size\":4,\"range\":{\"min\":0.000000,\"max\":210.000000},\"depend_and\":[\"18==true\"]},\"20\":{\"category\":\"base\",\"name\":\"br-x\",\"title\":\"\\u626b\\u63cf\\u533a\\u57df\\u53f3\\u4fa7\\uff08mm\\uff09\",\"desc\":\"\\u81ea\\u5b9a\\u4e49\\u626b\\u63cf\\u533a\\u57df\\u53f3\\u4e0b\\u89d2x\\u5750\\u6807\",\"type\":\"float\",\"cur\":210.000000,\"default\":210.000000,\"size\":4,\"range\":{\"min\":0.000000,\"max\":210.000000},\"depend_and\":[\"18==true\"]},\"21\":{\"category\":\"base\",\"name\":\"tl-y\",\"title\":\"\\u626b\\u63cf\\u533a\\u57df\\u4e0a\\u4fa7\\uff08mm\\uff09\",\"desc\":\"\\u81ea\\u5b9a\\u4e49\\u626b\\u63cf\\u533a\\u57df\\u5de6\\u4e0a\\u89d2y\\u5750\\u6807\",\"type\":\"float\",\"cur\":0.000000,\"default\":0.000000,\"size\":4,\"range\":{\"min\":0.000000,\"max\":297.000000},\"depend_and\":[\"18==true\"]},\"22\":{\"category\":\"base\",\"name\":\"br-y\",\"title\":\"\\u626b\\u63cf\\u533a\\u57df\\u4e0b\\u4fa7\\uff08mm\\uff09\",\"desc\":\"\\u81ea\\u5b9a\\u4e49\\u626b\\u63cf\\u533a\\u57df\\u53f3\\u4e0b\\u89d2y\\u5750\\u6807\",\"type\":\"float\",\"cur\":297.000000,\"default\":297.000000,\"size\":4,\"range\":{\"min\":0.000000,\"max\":297.000000},\"depend_and\":[\"18==true\"]},\"23\":{\"category\":\"base\",\"name\":\"cfg-23\",\"title\":\"\\u626b\\u63cf\\u9875\\u9762\",\"desc\":\"\\u8bbe\\u7f6e\\u9875\\u9762\\u626b\\u63cf\\u65b9\\u5f0f\",\"type\":\"string\",\"cur\":\"\\u53cc\\u9762\",\"default\":\"\\u53cc\\u9762\",\"size\":40,\"range\":[\"\\u5355\\u9762\",\"\\u53cc\\u9762\",\"\\u8df3\\u8fc7\\u7a7a\\u767d\\u9875\\uff08\\u901a\\u7528\\uff09\",\"\\u8df3\\u8fc7\\u7a7a\\u767d\\u9875\\uff08\\u53d1\\u7968\\u7eb8\\uff09\",\"\\u5bf9\\u6298\"]},\"24\":{\"category\":\"base\",\"name\":\"cfg-24\",\"title\":\" \\u8df3\\u8fc7\\u7a7a\\u767d\\u9875\\u7075\\u654f\\u5ea6\",\"desc\":\"\\u7075\\u654f\\u5ea6\\u8d8a\\u9ad8\\uff0c\\u5219\\u8d8a\\u5bb9\\u6613\\u8df3\\u8fc7\",\"type\":\"int\",\"cur\":50,\"default\":50,\"size\":4,\"range\":{\"min\":1,\"max\":100},\"depend_or\":[\"23==\\u8df3\\u8fc7\\u7a7a\\u767d\\u9875\\uff08\\u901a\\u7528\\uff09\",\"23==\\u8df3\\u8fc7\\u7a7a\\u767d\\u9875\\uff08\\u53d1\\u7968\\u7eb8\\uff09\"]},\"25\":{\"category\":\"base\",\"name\":\"cfg-25\",\"title\":\"\\u5206\\u8fa8\\u7387\",\"desc\":\"\\u626b\\u63cf\\u4eea\\u5206\\u8fa8\\u7387\",\"type\":\"int\",\"cur\":200,\"default\":200,\"size\":4,\"range\":[100,150,200,240,300]},\"26\":{\"category\":\"base\",\"name\":\"cfg-26\",\"title\":\"\\u4ea4\\u6362\\u6b63\\u53cd\\u9762\",\"desc\":\"\\u4ea4\\u6362\\u6b63\\u53cd\\u9762\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_and\":[\"23!=\\u5355\\u9762\"]},\"27\":{\"category\":\"base\",\"name\":\"cfg-27\",\"title\":\"\\u56fe\\u50cf\\u62c6\\u5206\",\"desc\":\"\\u81ea\\u52a8\\u62c6\\u5206\\u56fe\\u50cf\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_or\":[\"23!=\\u5bf9\\u6298\"]},\"28\":{\"category\":\"base\",\"name\":\"cfg-28\",\"title\":\"\\u81ea\\u52a8\\u7ea0\\u504f\",\"desc\":\"\\u81ea\\u52a8\\u7ea0\\u504f\",\"type\":\"bool\",\"cur\":true,\"default\":true,\"size\":4,\"depend_or\":[\"23!=\\u5bf9\\u6298\"]},\"29\":{\"category\":\"base\",\"name\":\"grp-2\",\"title\":\"\\u4eae\\u5ea6\",\"type\":\"group\"},\"30\":{\"category\":\"base\",\"name\":\"cfg-30\",\"title\":\"\\u542f\\u7528\\u8272\\u8c03\\u66f2\\u7ebf\",\"desc\":\"\\u901a\\u8fc7\\u8272\\u8c03\\u66f2\\u7ebf\\u6765\\u8bbe\\u7f6e\\u56fe\\u50cf\\u4f3d\\u9a6c\\u503c\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4},\"31\":{\"category\":\"base\",\"name\":\"cfg-31\",\"title\":\"\\u4eae\\u5ea6\\u503c\",\"desc\":\"\\u8c03\\u6574\\u56fe\\u7247\\u4eae\\u5ea6\",\"type\":\"int\",\"cur\":128,\"default\":128,\"size\":4,\"range\":{\"min\":1,\"max\":255},\"depend_and\":[\"30==false\"]},\"32\":{\"category\":\"base\",\"name\":\"cfg-32\",\"title\":\"\\u5bf9\\u6bd4\\u5ea6\",\"desc\":\"\\u8c03\\u6574\\u56fe\\u7247\\u5bf9\\u6bd4\\u5ea6\",\"type\":\"int\",\"cur\":4,\"default\":4,\"size\":4,\"range\":{\"min\":1,\"max\":7},\"depend_and\":[\"30==false\"]},\"33\":{\"category\":\"base\",\"name\":\"cfg-33\",\"title\":\"\\u4f3d\\u9a6c\\u503c\",\"desc\":\"\\u8c03\\u6574\\u56fe\\u7247\\u4f3d\\u9a6c\\u503c\",\"type\":\"float\",\"cur\":1.000000,\"default\":1.000000,\"size\":4,\"range\":{\"min\":0.010000,\"max\":5.000000},\"depend_and\":[\"30==false\"]},\"34\":{\"category\":\"base\",\"name\":\"grp-3\",\"title\":\"\\u56fe\\u50cf\\u5904\\u7406\",\"type\":\"group\"},\"35\":{\"category\":\"base\",\"name\":\"cfg-35\",\"title\":\"\\u6d88\\u9664\\u9ed1\\u6846\",\"desc\":\"\\u6d88\\u9664\\u9ed1\\u6846\",\"type\":\"bool\",\"cur\":true,\"default\":true,\"size\":4},\"36\":{\"category\":\"base\",\"name\":\"cfg-36\",\"title\":\"\\u6df1\\u8272\\u6837\\u5f20\",\"desc\":\"\\u6df1\\u8272\\u6837\\u5f20\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_and\":[\"23!=\\u5bf9\\u6298\",\"35!=true\",\"17!=\\u5339\\u914d\\u539f\\u59cb\\u5c3a\\u5bf8\",\"17!=\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\",\"17!=\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\\u81ea\\u52a8\\u88c1\\u5207\",\"28!=true\"]},\"37\":{\"category\":\"advanced\",\"name\":\"cfg-37\",\"title\":\"\\u9608\\u503c\",\"desc\":\"\\u9608\\u503c\",\"type\":\"int\",\"cur\":40,\"default\":40,\"size\":4,\"range\":{\"min\":30,\"max\":50},\"depend_or\":[\"35==true\",\"17==\\u5339\\u914d\\u539f\\u59cb\\u5c3a\\u5bf8\",\"17==\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\",\"17==\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\\u81ea\\u52a8\\u88c1\\u5207\",\"28==true\"]},\"38\":{\"category\":\"advanced\",\"name\":\"cfg-38\",\"title\":\"\\u80cc\\u666f\\u6297\\u566a\\u7b49\\u7ea7\",\"desc\":\"\\u80cc\\u666f\\u6297\\u566a\\u7b49\\u7ea7\",\"type\":\"int\",\"cur\":8,\"default\":8,\"size\":4,\"range\":{\"min\":1,\"max\":20},\"depend_or\":[\"35==true\",\"17==\\u5339\\u914d\\u539f\\u59cb\\u5c3a\\u5bf8\",\"17==\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\",\"17==\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\\u81ea\\u52a8\\u88c1\\u5207\",\"28==true\"]},\"39\":{\"category\":\"advanced\",\"name\":\"cfg-39\",\"title\":\"\\u8fb9\\u7f18\\u7f29\\u8fdb\",\"desc\":\"\\u8fb9\\u7f18\\u7f29\\u8fdb\",\"type\":\"int\",\"cur\":5,\"default\":5,\"size\":4,\"range\":{\"min\":5,\"max\":30},\"depend_or\":[\"35==true\",\"17==\\u5339\\u914d\\u539f\\u59cb\\u5c3a\\u5bf8\",\"17==\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\\u81ea\\u52a8\\u88c1\\u5207\",\"28==true\",\"17==\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\"]},\"40\":{\"category\":\"advanced\",\"name\":\"cfg-40\",\"title\":\"\\u80cc\\u666f\\u586b\\u5145\\u65b9\\u5f0f\",\"desc\":\"\\u80cc\\u666f\\u586b\\u5145\\u65b9\\u5f0f\",\"type\":\"string\",\"cur\":\"\\u51f8\\u591a\\u8fb9\\u5f62\",\"default\":\"\\u51f8\\u591a\\u8fb9\\u5f62\",\"size\":40,\"range\":[\"\\u51f8\\u591a\\u8fb9\\u5f62\",\"\\u51f9\\u591a\\u8fb9\\u5f62\"],\"depend_or\":[\"35==true\"]},\"41\":{\"category\":\"base\",\"name\":\"cfg-41\",\"title\":\"\\u9632\\u6b62\\u6e17\\u900f\",\"desc\":\"\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4},\"42\":{\"category\":\"base\",\"name\":\"cfg-42\",\"title\":\" \\u9632\\u6b62\\u6e17\\u900f\\u7b49\\u7ea7\",\"desc\":\"\",\"type\":\"string\",\"cur\":\"\\u8f83\\u5f31\",\"default\":\"\\u8f83\\u5f31\",\"size\":16,\"range\":[\"\\u8f83\\u5f31\",\"\\u5f31\",\"\\u4e00\\u822c\",\"\\u5f3a\",\"\\u8f83\\u5f3a\"],\"depend_or\":[\"41==true\"]},\"43\":{\"category\":\"base\",\"name\":\"cfg-43\",\"title\":\"\\u7a7f\\u5b54\\u79fb\\u9664\",\"desc\":\"\\u79fb\\u9664\\u7eb8\\u5f20\\u4e2d\\u7684\\u7a7f\\u5b54\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4},\"44\":{\"category\":\"base\",\"name\":\"cfg-44\",\"title\":\" \\u7a7f\\u5b54\\u641c\\u7d22\\u8303\\u56f4\\u5360\\u5e45\\u9762\\u6bd4\\u4f8b\",\"desc\":\"\\u7a7f\\u5b54\\u641c\\u7d22\\u8303\\u56f4\\u5360\\u5e45\\u9762\\u6bd4\\u4f8b\",\"type\":\"float\",\"cur\":0.100000,\"default\":0.100000,\"size\":4,\"range\":{\"min\":0.010000,\"max\":0.500000},\"depend_or\":[\"43==true\"]},\"45\":{\"category\":\"base\",\"name\":\"grp-4\",\"title\":\"\\u9001\\u7eb8\\u65b9\\u5f0f\\u8bbe\\u7f6e\",\"type\":\"group\"},\"46\":{\"category\":\"base\",\"name\":\"cfg-46\",\"title\":\"\\u8d85\\u58f0\\u6ce2\\u68c0\\u6d4b\",\"desc\":\"\\u8d85\\u58f0\\u6ce2\\u68c0\\u6d4b\\u9001\\u7eb8\\u72b6\\u6001\",\"type\":\"bool\",\"cur\":true,\"default\":true,\"size\":4},\"47\":{\"category\":\"base\",\"name\":\"cfg-47\",\"title\":\"\\u88c5\\u8ba2\\u68c0\\u6d4b\",\"desc\":\"\\u68c0\\u6d4b\\u7eb8\\u5f20\\u4e0a\\u662f\\u5426\\u6709\\u9489\\u4e66\\u9489\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4},\"48\":{\"category\":\"base\",\"name\":\"cfg-48\",\"title\":\"\\u626b\\u63cf\\u5f20\\u6570\",\"desc\":\"\\u626b\\u63cf\\u7eb8\\u5f20\\u6570\\u91cf\",\"type\":\"string\",\"cur\":\"\\u8fde\\u7eed\\u626b\\u63cf\",\"default\":\"\\u8fde\\u7eed\\u626b\\u63cf\",\"size\":32,\"range\":[\"\\u8fde\\u7eed\\u626b\\u63cf\",\"\\u626b\\u63cf\\u6307\\u5b9a\\u5f20\\u6570\"]},\"49\":{\"category\":\"base\",\"name\":\"cfg-49\",\"title\":\" \\u626b\\u63cf\\u6570\\u91cf\",\"desc\":\"\\u626b\\u63cf\\u6307\\u5b9a\\u6570\\u91cf\",\"type\":\"int\",\"cur\":1,\"default\":1,\"size\":4,\"depend_or\":[\"48==\\u626b\\u63cf\\u6307\\u5b9a\\u5f20\\u6570\"]},\"50\":{\"category\":\"base\",\"name\":\"cfg-50\",\"title\":\"\\u6587\\u7a3f\\u65b9\\u5411\",\"desc\":\"\\u6587\\u7a3f\\u65b9\\u5411\",\"type\":\"string\",\"cur\":\"0\\u00b0\",\"default\":\"0\\u00b0\",\"size\":40,\"range\":[\"0\\u00b0\",\"90\\u00b0\",\"180\\u00b0\",\"-90\\u00b0\",\"\\u81ea\\u52a8\\u6587\\u672c\\u65b9\\u5411\\u8bc6\\u522b\\u00b0\"]},\"51\":{\"category\":\"base\",\"name\":\"cfg-51\",\"title\":\"\\u80cc\\u9762\\u65cb\\u8f6c180\\u00b0\",\"desc\":\"\\u80cc\\u9762\\u626b\\u63cf\\u7684\\u56fe\\u50cf\\u65cb\\u8f6c180\\u00b0\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_and\":[\"23!=\\u5355\\u9762\",\"23!=\\u5bf9\\u6298\",\"50!=\\u81ea\\u52a8\\u6587\\u672c\\u65b9\\u5411\\u8bc6\\u522b\\u00b0\"]},\"52\":{\"category\":\"base\",\"name\":\"cfg-52\",\"title\":\"\\u6b6a\\u659c\\u68c0\\u6d4b\",\"desc\":\"\\u7eb8\\u5f20\\u6b6a\\u659c\\u68c0\\u6d4b\",\"type\":\"bool\",\"cur\":true,\"default\":true,\"size\":4},\"53\":{\"category\":\"base\",\"name\":\"cfg-53\",\"title\":\" \\u6b6a\\u659c\\u5bb9\\u5fcd\\u5ea6\",\"desc\":\"\\u503c\\u8d8a\\u5c0f\\uff0c\\u4ee3\\u8868\\u80fd\\u68c0\\u6d4b\\u5230\\u7eb8\\u5f20\\u7684\\u6b6a\\u659c\\u89d2\\u5ea6\\u8d8a\\u5c0f\",\"type\":\"int\",\"cur\":3,\"default\":3,\"size\":4,\"range\":{\"min\":1,\"max\":5},\"depend_or\":[\"52==true\"]}}"); namespace settingsdsp_200 { - hg_err device_status_to_hg_err(int usbdata, bool *fatal) + scanner_err device_status_to_hg_err(int usbdata, bool *fatal) { - hg_err code = HG_ERR_OK; + scanner_err code = SCANNER_ERR_OK; if (fatal) *fatal = true; switch (usbdata) { case HAVE_IMAGE: - code = HG_ERR_OK; + code = SCANNER_ERR_OK; if (fatal) *fatal = false; break; @@ -27,40 +27,40 @@ namespace settingsdsp_200 case USER_STOP: if (fatal) *fatal = false; - code = HG_ERR_DEVICE_STOPPED; + code = SCANNER_ERR_DEVICE_STOPPED; break; case COUNT_MODE: - code = HG_ERR_DEVICE_COUNT_MODE; + code = SCANNER_ERR_DEVICE_COUNT_MODE; break; case NO_FEED: - code = HG_ERR_DEVICE_NO_PAPER; + code = SCANNER_ERR_DEVICE_NO_PAPER; break; case OPEN_COVER: - code = HG_ERR_DEVICE_COVER_OPENNED; + code = SCANNER_ERR_DEVICE_COVER_OPENNED; break; case FEED_IN_ERROR: - code = HG_ERR_DEVICE_FEEDING_PAPER; + code = SCANNER_ERR_DEVICE_FEEDING_PAPER; break; case PAPER_JAM: - code = HG_ERR_DEVICE_PAPER_JAMMED; + code = SCANNER_ERR_DEVICE_PAPER_JAMMED; break; case DETECT_DOUBLE_FEED: - code = HG_ERR_DEVICE_DOUBLE_FEEDING; + code = SCANNER_ERR_DEVICE_DOUBLE_FEEDING; break; case DETECT_STAPLE: - code = HG_ERR_DEVICE_STAPLE_ON; + code = SCANNER_ERR_DEVICE_STAPLE_ON; break; case PAPER_SKEW: - code = HG_ERR_DEVICE_PAPER_SKEW; + code = SCANNER_ERR_DEVICE_PAPER_SKEW; break; case HARDWARE_ERROR: - code = HG_ERR_DEVICE_NOT_SUPPORT; + code = SCANNER_ERR_DEVICE_NOT_SUPPORT; break; case PC_SCAN_BUSY_or_ERROR: - code = HG_ERR_DEVICE_PC_BUSY; + code = SCANNER_ERR_DEVICE_PC_BUSY; break; case SIZE_ERROR: - code = HG_ERR_DEVICE_SIZE_CHECK; + code = SCANNER_ERR_DEVICE_SIZE_CHECK; break; default: if (fatal) @@ -120,7 +120,7 @@ namespace settingsdsp_200 *r = true; else *r = false; - HG_VLOG_MINI_3(HG_LOG_LEVEL_DEBUG_INFO, "Paper '%s' index = %d, device value = %d\n", paper_string(paper).c_str(), ind, paper_map[ind].dev_value); + HG_VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "Paper '%s' index = %d, device value = %d\n", paper_string(paper).c_str(), ind, paper_map[ind].dev_value); paper = paper_map[ind].paper; if (type) *type = paper_map[ind].type; @@ -209,7 +209,7 @@ enum hg_239_setting_item hg_scanner_200::hg_scanner_200(const char* dev_name,int pid, usb_io* io) : hg_scanner(G100Serial, dev_name, io), pid_(pid) { string fw = get_firmware_version(); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "get_firmware_version is: %s\n",fw.c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "get_firmware_version is: %s\n",fw.c_str()); initdevice(); dsp_config_.value = 0; @@ -231,7 +231,7 @@ void hg_scanner_200::discard_prev(void) packets = 0, normal = 0; - while (ret == HG_ERR_OK) + while (ret == SCANNER_ERR_OK) { if (usb.u32_Data == HAVE_IMAGE) { @@ -250,7 +250,7 @@ void hg_scanner_200::discard_prev(void) ret = get_scanner_status(usb); } if (imgs || packets) - HG_VLOG_MINI_2(HG_LOG_LEVEL_DEBUG_INFO, "discard prev-scanning %d packets and %d images.\n", packets, imgs); + HG_VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "discard prev-scanning %d packets and %d images.\n", packets, imgs); } void hg_scanner_200::init_setting_map(int* setting_map, int count) @@ -318,12 +318,12 @@ void hg_scanner_200::init_setting_map(int* setting_map, int count) int hg_scanner_200::on_scanner_closing(bool force) { - return HG_ERR_OK; + return SCANNER_ERR_OK; } void hg_scanner_200::thread_handle_usb_read(void) { - int ret = HG_ERR_OK, - prev_err = HG_ERR_OK; + int ret = SCANNER_ERR_OK, + prev_err = SCANNER_ERR_OK; StopWatch sw; bool first = true; @@ -334,14 +334,14 @@ void hg_scanner_200::thread_handle_usb_read(void) if (sw.elapsed_s() > 30) { // no any data in 30 seconds, we giveup the work ... - status_ = prev_err != HG_ERR_OK ? prev_err : HG_ERR_TIMEOUT; + status_ = prev_err != SCANNER_ERR_OK ? prev_err : SCANNER_ERR_TIMEOUT; break; } USBCB usb = {0}; ret = get_scanner_status(usb); - if (ret == HG_ERR_DEVICE_NOT_FOUND) + if (ret == SCANNER_ERR_DEVICE_NOT_FOUND) { // device left, the work is no meanning ... status_ = ret; @@ -355,14 +355,14 @@ void hg_scanner_200::thread_handle_usb_read(void) sw.reset(); first = false; } - else if (ret == HG_ERR_DEVICE_STOPPED) + else if (ret == SCANNER_ERR_DEVICE_STOPPED) { status_ = prev_err; break; } - else if(ret != HG_ERR_OK) + else if(ret != SCANNER_ERR_OK) { - if (prev_err == HG_ERR_OK) + if (prev_err == SCANNER_ERR_OK) { if (first) { @@ -385,7 +385,7 @@ void hg_scanner_200::thread_handle_usb_read(void) } } else - notify_ui_working_status(hg_scanner::error_description((hg_err)prev_err).c_str(), SANE_EVENT_ERROR, prev_err); + notify_ui_working_status(hg_scanner::error_description((scanner_err)prev_err).c_str(), SANE_EVENT_ERROR, prev_err); prev_err = ret; } this_thread::sleep_for(chrono::milliseconds(2)); @@ -394,13 +394,13 @@ void hg_scanner_200::thread_handle_usb_read(void) int hg_scanner_200::start(void) { - int ret = HG_ERR_OK, + int ret = SCANNER_ERR_OK, count = -1; //discard_prev(); user_cancel_ = false; //ret = writedown_device_configuration(true); - if (ret == HG_ERR_OK) + if (ret == SCANNER_ERR_OK) writedown_image_configuration(); else { @@ -411,19 +411,19 @@ int hg_scanner_200::start(void) //writedown_device_configuration(true); // ret = get_scan_is_sleep(); - // if (ret == HG_ERR_DEVICE_SLEEPING) + // if (ret == SCANNER_ERR_DEVICE_SLEEPING) // { // status_ = ret; - // notify_ui_working_status(STATU_DESC_HG_ERR_DEVICE_SLEEPING, SANE_EVENT_SCAN_FINISHED, status_); - // HG_VLOG_MINI_1(HG_LOG_LEVEL_WARNING, "device start status is(%s)\n", STATU_DESC_HG_ERR_DEVICE_SLEEPING); + // notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING, SANE_EVENT_SCAN_FINISHED, status_); + // HG_VLOG_MINI_1(LOG_LEVEL_WARNING, "device start status is(%s)\n", STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING); // return ret; // } ret = get_scanner_paperon(); - if (ret == HG_ERR_DEVICE_NO_PAPER) + if (ret == SCANNER_ERR_DEVICE_NO_PAPER) { status_ = ret; - notify_ui_working_status(STATU_DESC_HG_ERR_DEVICE_NO_PAPER, SANE_EVENT_ERROR, status_); - HG_VLOG_MINI_1(HG_LOG_LEVEL_WARNING, "device start status is(%s)\n", STATU_DESC_HG_ERR_DEVICE_NO_PAPER); + notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER, SANE_EVENT_ERROR, status_); + HG_VLOG_MINI_1(LOG_LEVEL_WARNING, "device start status is(%s)\n", STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER); return ret; } @@ -432,11 +432,11 @@ int hg_scanner_200::start(void) ret = writeusb(usb); io_->set_timeout(500); - HG_VLOG_MINI_1(HG_LOG_LEVEL_WARNING, "device start is.(%s)\n", hg_scanner::strerr((hg_err)ret).c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_WARNING, "device start is.(%s)\n", hg_scanner::strerr((scanner_err)ret).c_str()); - if(ret == HG_ERR_OK) + if(ret == SCANNER_ERR_OK) { - status_ = HG_ERR_DEVICE_BUSY; + status_ = SCANNER_ERR_DEVICE_BUSY; wait_usb_.notify(); std::this_thread::sleep_for(std::chrono::milliseconds(300)); } @@ -447,20 +447,20 @@ int hg_scanner_200::start(void) } int hg_scanner_200::stop(void) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; USBCB usbcb = {STOP, 0, 0}; ret = writeusb(usbcb); user_cancel_ = true; - if (ret == HG_ERR_DEVICE_BUSY) + if (ret == SCANNER_ERR_DEVICE_BUSY) { - HG_LOG(HG_LOG_LEVEL_DEBUG_INFO,"stop status is busy\r\n"); + HG_LOG(LOG_LEVEL_DEBUG_INFO,"stop status is busy\r\n"); std::this_thread::sleep_for(std::chrono::milliseconds(2000)); } - else if (ret == HG_ERR_OK) + else if (ret == SCANNER_ERR_OK) { - status_ = HG_ERR_DEVICE_STOPPED; + status_ = SCANNER_ERR_DEVICE_STOPPED; } return status_; @@ -469,7 +469,7 @@ int hg_scanner_200::writeusb(USBCB &usb) { std::lock_guard lock(io_lock_); - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; int len = sizeof(usb); ret = io_->write_bulk(&usb,&len); @@ -484,7 +484,7 @@ int hg_scanner_200::readusb(USBCB &usb) { std::lock_guard lock(io_lock_); - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; int len = sizeof(USBCB); ret = io_->read_bulk(&usb,&len); @@ -497,7 +497,7 @@ int hg_scanner_200::readusb(USBCB &usb) } int hg_scanner_200::pop_image() { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; USBCB usbcb = {POP_IMAGE, 0, 0}; ret = writeusb(usbcb); @@ -506,18 +506,18 @@ int hg_scanner_200::pop_image() } int hg_scanner_200::get_scanner_status(USBCB &usb) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; usb = {GET_DSP_STATUS, 0, 0}; ret = writeusb(usb); - if (ret != HG_ERR_OK) + if (ret != SCANNER_ERR_OK) return ret; io_->set_timeout(500); ret = readusb(usb); - if (ret != HG_ERR_OK) + if (ret != SCANNER_ERR_OK) { status_ = ret; return ret; @@ -528,14 +528,14 @@ int hg_scanner_200::get_scanner_status(USBCB &usb) int hg_scanner_200::get_img_data(unsigned int bytes) { int total = bytes, - ret = HG_ERR_OK, + ret = SCANNER_ERR_OK, index = 0, block = total; std::shared_ptr> imagedata(new std::vector(total)); USBCB usb{GET_IMAGE, 0, total}; ret = writeusb(usb); - if (ret != HG_ERR_OK) + if (ret != SCANNER_ERR_OK) { status_ = ret; return ret; @@ -551,13 +551,13 @@ int hg_scanner_200::get_img_data(unsigned int bytes) ret = io_->read_bulk(imagedata->data() + index,&block); io_->set_timeout(500); //不能删除可能会导致IO超时 - if (ret != HG_ERR_OK) + if (ret != SCANNER_ERR_OK) break; index += block; total -= block; } - if (ret == HG_ERR_OK) + if (ret == SCANNER_ERR_OK) { ret = save_usb_data(imagedata); } @@ -567,11 +567,11 @@ int hg_scanner_200::get_img_data(unsigned int bytes) void hg_scanner_200::image_process(std::shared_ptr>& buffer) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; hg_imgproc::IMGPRCPARAM param; hg_imgproc::HIMGPRC handle = NULL; hg_imgproc::IMGHEAD ih; - int err = HG_ERR_OK, + int err = SCANNER_ERR_OK, index = 0; void* buf = NULL; @@ -582,11 +582,11 @@ void hg_scanner_200::image_process(std::shared_ptr>& buffer) param.double_side = img_conf_.is_duplex; param.dpi = img_conf_.resolution_dst; - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"param.black_white :%d\r\n",param.black_white); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"param.channels :%d\r\n",param.channels); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"param.color_mode :%d\r\n",param.color_mode); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"param.double_side :%d\r\n",param.double_side); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"param.dpi :%d\r\n",param.dpi); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"param.black_white :%d\r\n",param.black_white); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"param.channels :%d\r\n",param.channels); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"param.color_mode :%d\r\n",param.color_mode); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"param.double_side :%d\r\n",param.double_side); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"param.dpi :%d\r\n",param.dpi); handle = hg_imgproc::init(&img_conf_,¶m,pid_); @@ -746,7 +746,7 @@ void hg_scanner_200::image_process(std::shared_ptr>& buffer) colormode=img_conf_.pixtype; err = hg_imgproc::split(handle,img_conf_.multiOutput,img_conf_.splitImage,img_conf_.multi_output_red,colormode,img_conf_.is_duplex); - HG_VLOG_MINI_5(HG_LOG_LEVEL_DEBUG_INFO, "img split-> multiOutput is:%d splitImage is:%d multi_output_red is:%d pixtype is:%d is_duplex:%d\r\n" + HG_VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "img split-> multiOutput is:%d splitImage is:%d multi_output_red is:%d pixtype is:%d is_duplex:%d\r\n" ,img_conf_.multiOutput ,img_conf_.splitImage ,img_conf_.multi_output_red @@ -771,9 +771,9 @@ void hg_scanner_200::image_process(std::shared_ptr>& buffer) } hg_imgproc::final(handle); - while (hg_imgproc::get_final_data(handle, &ih, &buf, index++) == HG_ERR_OK && !user_cancel_) + while (hg_imgproc::get_final_data(handle, &ih, &buf, index++) == SCANNER_ERR_OK && !user_cancel_) { - HG_VLOG_MINI_5(HG_LOG_LEVEL_DEBUG_INFO, "Final picture %d (%d * %d * %d) with %u bytes!\n", index + HG_VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "Final picture %d (%d * %d * %d) with %u bytes!\n", index , ih.width, ih.height, ih.bits * ih.channels, ih.total_bytes); std::vectorbmpdata; @@ -783,13 +783,13 @@ void hg_scanner_200::image_process(std::shared_ptr>& buffer) //cv::imencode(img_type_,*((cv::Mat*)buf),bmpdata); if(bmpdata.empty()) { - status_ = HG_ERR_NO_DATA; + status_ = SCANNER_ERR_NO_DATA; return ; } buf = bmpdata.data(); ih.total_bytes = bmpdata.size(); - HG_VLOG_MINI_6(HG_LOG_LEVEL_DEBUG_INFO, "Set img type is:%s Final picture %d (%d * %d * %d) with %u bytes!\n",img_type_.c_str() ,index + HG_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 , ih.width, ih.height, ih.bits * ih.channels, ih.total_bytes); } @@ -802,9 +802,9 @@ void hg_scanner_200::image_process(std::shared_ptr>& buffer) int hg_scanner_200::writedown_device_configuration(bool type,HGSCANCONF_DSP *d) { if (!type) - return HG_ERR_OK; + return SCANNER_ERR_OK; - int ret = HG_ERR_OK, + int ret = SCANNER_ERR_OK, len = 0; if (!d) @@ -814,14 +814,14 @@ int hg_scanner_200::writedown_device_configuration(bool type,HGSCANCONF_DSP *d) len = sizeof(USBCB); ret = io_->write_bulk(&usbcb,&len); - HG_VLOG_MINI_1(HG_LOG_LEVEL_WARNING, "writedown_device_configuration is .(%s)\n", hg_scanner::strerr((hg_err)ret).c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_WARNING, "writedown_device_configuration is .(%s)\n", hg_scanner::strerr((scanner_err)ret).c_str()); return ret; } int hg_scanner_200::on_color_mode_changed(int& color_mode) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; if (color_mode == COLOR_MODE_BLACK_WHITE || color_mode == COLOR_MODE_256_GRAY) { @@ -838,7 +838,7 @@ int hg_scanner_200::on_paper_changed(int& paper) { bool exact = true; int ind = settingsdsp_200::match_best_paper(paper, &exact, &paper_size_), - ret = exact ? HG_ERR_OK : HG_ERR_NOT_EXACT; + ret = exact ? SCANNER_ERR_OK : SCANNER_ERR_NOT_EXACT; if (dsp_config_.params.paper != settingsdsp_200::paper_map[ind].dev_value) { @@ -859,13 +859,13 @@ int hg_scanner_200::on_paper_changed(int& paper) } } else if (!exact) - ret = HG_ERR_NOT_EXACT; + ret = SCANNER_ERR_NOT_EXACT; } return ret; } int hg_scanner_200::on_paper_check_changed(bool& check) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; if(dsp_config_.params.enable_sizecheck ^ check) { dsp_config_.params.enable_sizecheck = check; @@ -881,7 +881,7 @@ int hg_scanner_200::on_paper_check_changed(bool& check) int hg_scanner_200::on_resolution_changed(int& dpi) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; dsp_config_.params.dpi = 1; ret = writedown_device_configuration(); return ret; @@ -889,7 +889,7 @@ int hg_scanner_200::on_resolution_changed(int& dpi) int hg_scanner_200::on_ultrasonic_check_changed(bool& check) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; if (dsp_config_.params.double_feed_enbale ^ check) { @@ -907,7 +907,7 @@ int hg_scanner_200::on_ultrasonic_check_changed(bool& check) int hg_scanner_200::on_staple_check_changed(bool& check) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; if (dsp_config_.params.stable_enbale ^ check) { @@ -924,7 +924,7 @@ int hg_scanner_200::on_staple_check_changed(bool& check) } int hg_scanner_200::on_skew_check_changed(bool& check) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; if (dsp_config_.params.screw_detect_enable ^ check) { @@ -941,7 +941,7 @@ int hg_scanner_200::on_skew_check_changed(bool& check) } int hg_scanner_200::on_skew_check_level_changed(int& check) { - int ret = HG_ERR_OK, + int ret = SCANNER_ERR_OK, val = check, old = dsp_config_.params.screw_detect_level; HGSCANCONF_DSP cf; @@ -951,12 +951,12 @@ int hg_scanner_200::on_skew_check_level_changed(int& check) if (val < 0) { val = 0; - ret = HG_ERR_NOT_EXACT; + ret = SCANNER_ERR_NOT_EXACT; } else if (val > cf.params.screw_detect_level) { val = cf.params.screw_detect_level; - ret = HG_ERR_NOT_EXACT; + ret = SCANNER_ERR_NOT_EXACT; } if (val != dsp_config_.params.screw_detect_level) { @@ -965,10 +965,10 @@ int hg_scanner_200::on_skew_check_level_changed(int& check) if (ret) check = dsp_config_.params.screw_detect_level = old; } - if (ret == HG_ERR_OK && val != check) + if (ret == SCANNER_ERR_OK && val != check) { check = val; - ret = HG_ERR_NOT_EXACT; + ret = SCANNER_ERR_NOT_EXACT; } return ret; @@ -990,7 +990,7 @@ int hg_scanner_200::initdevice() writedown_device_configuration(true,&ds); printf_devconfig(&ds); - return HG_ERR_OK; + return SCANNER_ERR_OK; } void hg_scanner_200::writedown_image_configuration(void) { @@ -1048,7 +1048,7 @@ else if (test_1_paper_) { - HG_LOG(HG_LOG_LEVEL_DEBUG_INFO, "scanning mode: testing ONE paper ...\n"); + HG_LOG(LOG_LEVEL_DEBUG_INFO, "scanning mode: testing ONE paper ...\n"); ic.scannum = 1; } else @@ -1124,56 +1124,56 @@ else //printf ("ic.resolution_native =%f ic.resolution_dst = %f img_conf_.resolution_dst = %f \r\n",ic.resolution_native,ic.resolution_dst,img_conf_.resolution_dst); agreement(); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.pixtype=%d", ic.pixtype); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.papertype=%d", ic.papertype); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.AutoCrop_threshold=%d", ic.AutoCrop_threshold); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.autodescrew=%d", ic.autodescrew); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.automaticcolor=%d", ic.automaticcolor); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.brightness=%f", ic.brightness); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.contrast=%f", ic.contrast); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.en_fold=%d", ic.en_fold); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.en_sizecheck=%d", ic.en_sizecheck); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.enhance_color=%d", ic.enhance_color); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.fillbackground=%d", ic.fillbackground); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.filter=%d", ic.filter); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.gamma=%f", ic.gamma); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.hardwarecaps.capturepixtype=%d", ic.hardwarecaps.capturepixtype); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.hardwarecaps.en_doublefeed=%d", ic.hardwarecaps.en_doublefeed); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.hsvcorrect=%d", ic.hsvcorrect); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.imageRotateDegree=%f", ic.imageRotateDegree); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.indent=%d", 5); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_autocontrast=%d", ic.is_autocontrast); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_autocrop=%d", ic.is_autocrop); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_autodiscradblank_normal=%d", ic.is_autodiscradblank_normal); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_autodiscradblank_vince=%d", ic.is_autodiscradblank_vince); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_autotext=%d", ic.is_autotext); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_backrotate180=%d", ic.is_backrotate180); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_convex=%d", ic.is_convex); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_duplex=%d", ic.is_duplex); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_switchfrontback=%d", ic.is_switchfrontback); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_dogeardetection=%d", ic.is_dogeardetection); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.fillhole.multi_output_red=%d", ic.multi_output_red); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.noise=%d", 8); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.resolution_dst=%f", ic.resolution_dst); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.resolution_native=%f", ic.resolution_native); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.scannum=%d", ic.scannum); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.sharpen=%d", ic.sharpen); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.discardblank_percent=%d", ic.discardblank_percent); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.is_detachnoise=%d", ic.detachnoise.is_detachnoise); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.detachnoise=%d\r ", ic.detachnoise.detachnoise); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.refuseInflow=%d\r ", ic.refuseInflow); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.refuseInflow=%d\r ", ic.refuseInflow); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.removeMorr=%d\r ", ic.removeMorr); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.errorExtention=%d\r ", ic.errorExtention); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.textureRemove=%d\r\n ", ic.textureRemove); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.fillhole.is_fillhole=%d\r\n ", ic.fillhole.is_fillhole); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.ic.fillhole.fillholeratio=%f\r\n ", ic.fillhole.fillholeratio); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.fadeback=%d\r\n ",ic.fadeback); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.enable=%d\r\n ",ic.cropRect.enable); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.height=%d\r\n ",ic.cropRect.height); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.width=%d\r\n ",ic.cropRect.width); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.x=%d\r\n ",ic.cropRect.x); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.y=%d\r\n ",ic.cropRect.y); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.pixtype=%d", ic.pixtype); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.papertype=%d", ic.papertype); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.AutoCrop_threshold=%d", ic.AutoCrop_threshold); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.autodescrew=%d", ic.autodescrew); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.automaticcolor=%d", ic.automaticcolor); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.brightness=%f", ic.brightness); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.contrast=%f", ic.contrast); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.en_fold=%d", ic.en_fold); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.en_sizecheck=%d", ic.en_sizecheck); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.enhance_color=%d", ic.enhance_color); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.fillbackground=%d", ic.fillbackground); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.filter=%d", ic.filter); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.gamma=%f", ic.gamma); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.hardwarecaps.capturepixtype=%d", ic.hardwarecaps.capturepixtype); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.hardwarecaps.en_doublefeed=%d", ic.hardwarecaps.en_doublefeed); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.hsvcorrect=%d", ic.hsvcorrect); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.imageRotateDegree=%f", ic.imageRotateDegree); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.indent=%d", 5); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autocontrast=%d", ic.is_autocontrast); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autocrop=%d", ic.is_autocrop); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autodiscradblank_normal=%d", ic.is_autodiscradblank_normal); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autodiscradblank_vince=%d", ic.is_autodiscradblank_vince); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autotext=%d", ic.is_autotext); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_backrotate180=%d", ic.is_backrotate180); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_convex=%d", ic.is_convex); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_duplex=%d", ic.is_duplex); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_switchfrontback=%d", ic.is_switchfrontback); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_dogeardetection=%d", ic.is_dogeardetection); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.fillhole.multi_output_red=%d", ic.multi_output_red); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.noise=%d", 8); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.resolution_dst=%f", ic.resolution_dst); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.resolution_native=%f", ic.resolution_native); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.scannum=%d", ic.scannum); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.sharpen=%d", ic.sharpen); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.discardblank_percent=%d", ic.discardblank_percent); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.is_detachnoise=%d", ic.detachnoise.is_detachnoise); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.detachnoise=%d\r ", ic.detachnoise.detachnoise); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.refuseInflow=%d\r ", ic.refuseInflow); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.refuseInflow=%d\r ", ic.refuseInflow); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.removeMorr=%d\r ", ic.removeMorr); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.errorExtention=%d\r ", ic.errorExtention); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.textureRemove=%d\r\n ", ic.textureRemove); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.fillhole.is_fillhole=%d\r\n ", ic.fillhole.is_fillhole); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.ic.fillhole.fillholeratio=%f\r\n ", ic.fillhole.fillholeratio); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.fadeback=%d\r\n ",ic.fadeback); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.enable=%d\r\n ",ic.cropRect.enable); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.height=%d\r\n ",ic.cropRect.height); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.width=%d\r\n ",ic.cropRect.width); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.x=%d\r\n ",ic.cropRect.x); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.y=%d\r\n ",ic.cropRect.y); } void hg_scanner_200::printf_devconfig(HGSCANCONF_DSP *d) @@ -1182,28 +1182,28 @@ void hg_scanner_200::printf_devconfig(HGSCANCONF_DSP *d) if (!d) d = &dsp_config_; - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\r\ndsp_config.params.color:%d\r\n",d->params.color); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"dsp_config_.params.double_feed_enbale:%d\r\n",d->params.double_feed_enbale); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"dsp_config_.params.dpi:%d\r\n",d->params.dpi); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"dsp_config_.params.enable_sizecheck:%d\r\n",d->params.enable_sizecheck); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"dsp_config_.params.paper:%d\r\n",d->params.paper); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"dsp_config_.params.pc_correct:%d\r\n",d->params.pc_correct); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"dsp_config_.params.screw_detect_enable:%d\r\n",d->params.screw_detect_enable); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"dsp_config_.params.screw_detect_level:%d\r\n",d->params.screw_detect_level); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"dsp_config_.params.stable_enbale:%d\r\n",d->params.stable_enbale); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"dsp_config_.params.unused_one:%d\r\n",d->params.unused_one); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"dsp_config_.params.unused_two:%d\r\n",d->params.unused_two); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"dsp_config_.params.value:%d\r\n",d->value); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\r\ndsp_config.params.color:%d\r\n",d->params.color); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config_.params.double_feed_enbale:%d\r\n",d->params.double_feed_enbale); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config_.params.dpi:%d\r\n",d->params.dpi); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config_.params.enable_sizecheck:%d\r\n",d->params.enable_sizecheck); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config_.params.paper:%d\r\n",d->params.paper); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config_.params.pc_correct:%d\r\n",d->params.pc_correct); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config_.params.screw_detect_enable:%d\r\n",d->params.screw_detect_enable); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config_.params.screw_detect_level:%d\r\n",d->params.screw_detect_level); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config_.params.stable_enbale:%d\r\n",d->params.stable_enbale); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config_.params.unused_one:%d\r\n",d->params.unused_one); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config_.params.unused_two:%d\r\n",d->params.unused_two); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config_.params.value:%d\r\n",d->value); } std::string hg_scanner_200::get_firmware_version() { char buf[20] = { 0 }; - int ret = HG_ERR_OK, + int ret = SCANNER_ERR_OK, len = 8; //协议定义长度为8 300 400 =10 USBCB cmd = {GET_FW_VERSION, len, 0,}; ret = writeusb(cmd); - if(ret == HG_ERR_OK) + if(ret == SCANNER_ERR_OK) { std::lock_guard lock(io_lock_); ret = io_->read_bulk(buf, &len); @@ -1215,12 +1215,12 @@ std::string hg_scanner_200::get_firmware_version() std::string hg_scanner_200::get_serial_num() { char buf[20] = { 0 }; - int ret = HG_ERR_OK, + int ret = SCANNER_ERR_OK, len = 12; //协议定义长度为8 300 400 =10 USBCB cmd = {GET_SERIAL, len, 0,}; ret = writeusb(cmd); - if (ret == HG_ERR_OK) + if (ret == SCANNER_ERR_OK) { std::lock_guard lock(io_lock_); ret = io_->read_bulk(buf, &len); @@ -1232,7 +1232,7 @@ std::string hg_scanner_200::get_firmware_version() int hg_scanner_200::agreement() { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; if (image_prc_param_.bits.rid_color != RID_COLOR_NONE) @@ -1255,7 +1255,7 @@ int hg_scanner_200::agreement() int hg_scanner_200::set_leaflet_scan(void) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; test_1_paper_ = true; ret = start(); @@ -1263,49 +1263,49 @@ int hg_scanner_200::set_leaflet_scan(void) } int hg_scanner_200::get_abuot_info(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_200::restore_default_setting(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_200::set_img_format(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_200::get_compression_format(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_200::set_compression_format(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_200::set_auto_color_type(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_200::get_device_code(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_200::get_sleep_time(SANE_Power* getime) { - int ret = HG_ERR_OK, + int ret = SCANNER_ERR_OK, len = 0; USBCB usbcb = {GET_SLEEP_TIME, 0, 0}; ret = writeusb(usbcb); - if (ret != HG_ERR_OK) + if (ret != SCANNER_ERR_OK) { return ret; } len = sizeof(usbcb); ret = io_->read_bulk(&usbcb,&len); printf("usbcb.u32_Data = %d\r\n",usbcb.u32_Data); - if (ret == HG_ERR_OK) + if (ret == SCANNER_ERR_OK) { if (getime) { @@ -1313,7 +1313,7 @@ int hg_scanner_200::get_sleep_time(SANE_Power* getime) } if (usbcb.u32_Data) { - return HG_ERR_DEVICE_SLEEPING; + return SCANNER_ERR_DEVICE_SLEEPING; } } return ret; @@ -1322,10 +1322,10 @@ int hg_scanner_200::set_sleep_time(SANE_Power* setime) { if (!setime) { - return HG_ERR_NO_DATA; + return SCANNER_ERR_NO_DATA; } - int ret = HG_ERR_OK, + int ret = SCANNER_ERR_OK, time = *setime; USBCB usbcb = {SET_SLEEP_TIME,time, 0}; @@ -1336,15 +1336,15 @@ int hg_scanner_200::set_sleep_time(SANE_Power* setime) int hg_scanner_200::get_dogear_distance(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_200::set_dogear_distance(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_200::get_scanner_paperon(SANE_Bool* paperon) { - int ret = HG_ERR_OK, + int ret = SCANNER_ERR_OK, len = 0; USBCB usbcb = {GET_PAPER_STATUS, 0, 0}; @@ -1352,19 +1352,19 @@ int hg_scanner_200::get_scanner_paperon(SANE_Bool* paperon) ret = writeusb(usbcb); io_->set_timeout(500); - if (ret == HG_ERR_OK) + if (ret == SCANNER_ERR_OK) { std::lock_guard lock(io_lock_); ret = io_->read_bulk(&usbcb,&len); } - if (ret != HG_ERR_OK) + if (ret != SCANNER_ERR_OK) { return ret; } if (usbcb.u32_Data == 0) - ret = HG_ERR_DEVICE_NO_PAPER; + ret = SCANNER_ERR_DEVICE_NO_PAPER; else - ret = HG_ERR_OK; + ret = SCANNER_ERR_OK; if (paperon) { *paperon = usbcb.u32_Data; @@ -1373,23 +1373,23 @@ int hg_scanner_200::get_scanner_paperon(SANE_Bool* paperon) } int hg_scanner_200::set_scan_when_paper_on(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_200::get_scan_when_paper_on(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_200::get_scan_with_hole(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_200::set_scan_with_hole(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_200::get_scan_is_sleep() { - int ret = HG_ERR_OK, + int ret = SCANNER_ERR_OK, len = 0; USBCB usbcb = { CHECK_IS_SLEEP, 0, 0}; @@ -1398,22 +1398,22 @@ int hg_scanner_200::get_scan_is_sleep() io_->set_timeout(200); - if (ret == HG_ERR_OK) + if (ret == SCANNER_ERR_OK) { std::lock_guard lock(io_lock_); ret = io_->read_bulk(&usbcb,&len); } - if (ret != HG_ERR_OK) + if (ret != SCANNER_ERR_OK) { return ret; } if (usbcb.u32_Data == 0x10) { - return HG_ERR_OK; + return SCANNER_ERR_OK; } else if (usbcb.u32_Data == 0x100) { - return HG_ERR_DEVICE_SLEEPING; + return SCANNER_ERR_DEVICE_SLEEPING; } } @@ -1429,10 +1429,10 @@ int hg_scanner_200::get_scan_is_sleep() // // { // std::lock_guard lock(io_lock_); -// if (io_->write_bulk(&usbcb, &len) == HG_ERR_OK) +// if (io_->write_bulk(&usbcb, &len) == SCANNER_ERR_OK) // { // len = sizeof(usbcb); -// if (io_->read_bulk(&usbcb, &len) != HG_ERR_OK) +// if (io_->read_bulk(&usbcb, &len) != SCANNER_ERR_OK) // usbcb.u32_Count = -1; // } // else diff --git a/hgdriver/hgdev/hg_scanner_200.h b/hgdriver/hgdev/hg_scanner_200.h index 388f549..d02e900 100644 --- a/hgdriver/hgdev/hg_scanner_200.h +++ b/hgdriver/hgdev/hg_scanner_200.h @@ -12,6 +12,12 @@ #include "hg_scanner.h" #include "../../sdk/hginclude/hg_log.h" +#ifdef OEM_HANWANG +#define hg_scanner_200 hw_scanner_200 +#elif defined(OEM_LISICHENG) +#define hg_scanner_200 lsc_scanner_200 +#endif + class hg_scanner_200 : public hg_scanner { diff --git a/hgdriver/hgdev/hg_scanner_239.cpp b/hgdriver/hgdev/hg_scanner_239.cpp index 160d9a1..d9b7431 100644 --- a/hgdriver/hgdev/hg_scanner_239.cpp +++ b/hgdriver/hgdev/hg_scanner_239.cpp @@ -192,44 +192,44 @@ struct HGEIntInfo }; namespace settings { - // device status to hg_err - hg_err device_status_to_hg_err(HGEIntInfo* ds) + // device status to scanner_err + scanner_err device_status_to_hg_err(HGEIntInfo* ds) { - hg_err code = HG_ERR_OK; + scanner_err code = SCANNER_ERR_OK; if (ds->From == HGType::FPGA) - code = HG_ERR_OK; + code = SCANNER_ERR_OK; else if (ds->From == HGType::MtBoard) { switch (ds->Code) { case 0x00002: - code = HG_ERR_DEVICE_NO_PAPER; + code = SCANNER_ERR_DEVICE_NO_PAPER; break; case 0x00004: - code = HG_ERR_DEVICE_COVER_OPENNED; + code = SCANNER_ERR_DEVICE_COVER_OPENNED; break; case 0x00008: - code = HG_ERR_DEVICE_FEEDING_PAPER; + code = SCANNER_ERR_DEVICE_FEEDING_PAPER; break; case 0x00010: - code = HG_ERR_DEVICE_PAPER_JAMMED; + code = SCANNER_ERR_DEVICE_PAPER_JAMMED; break; case 0x00020: - code = HG_ERR_DEVICE_DOUBLE_FEEDING; + code = SCANNER_ERR_DEVICE_DOUBLE_FEEDING; break; case 0x00040: - code = HG_ERR_DEVICE_STAPLE_ON; + code = SCANNER_ERR_DEVICE_STAPLE_ON; break; case 0x00080: - code = HG_ERR_DEVICE_PAPER_SKEW; + code = SCANNER_ERR_DEVICE_PAPER_SKEW; break; case 0x10000: case 0x80000: - code = HG_ERR_TIMEOUT; + code = SCANNER_ERR_TIMEOUT; break; case 0x20000: - code = HG_ERR_DEVICE_SIZE_CHECK; + code = SCANNER_ERR_DEVICE_SIZE_CHECK; break; default: break; @@ -238,19 +238,19 @@ namespace settings else if (ds->From == HGType::IMG) { if (ds->Code == 1) - code = HG_ERR_DEVICE_DOGEAR; + code = SCANNER_ERR_DEVICE_DOGEAR; else if (ds->Code == 2) - code = HG_ERR_DEVICE_SIZE_CHECK; + code = SCANNER_ERR_DEVICE_SIZE_CHECK; } else if (ds->From == HGType::V4L2) { if (ds->Code == 0) - code = HG_ERR_DEVICE_SCANN_ERROR; + code = SCANNER_ERR_DEVICE_SCANN_ERROR; else if (ds->Code == 1) - code = HG_ERR_DEVICE_NO_IMAGE; + code = SCANNER_ERR_DEVICE_NO_IMAGE; } else if (ds->From == HGType::STOPSCAN) - code = HG_ERR_DEVICE_STOPPED; + code = SCANNER_ERR_DEVICE_STOPPED; return code; } @@ -365,7 +365,7 @@ namespace settings *r = true; else *r = false; - HG_VLOG_MINI_3(HG_LOG_LEVEL_DEBUG_INFO, "Paper '%s' index = %d, device value = %d\n", paper_string(paper).c_str(), ind, paper_map[ind].dev_value); + HG_VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "Paper '%s' index = %d, device value = %d\n", paper_string(paper).c_str(), ind, paper_map[ind].dev_value); paper = paper_map[ind].paper; if (type) *type = paper_map[ind].type; @@ -379,7 +379,7 @@ namespace settings hg_scanner_239::hg_scanner_239(const char* dev_name, int pid,usb_io* io) : hg_scanner(G20039Serial, dev_name, io) , rewrite_conf_(false), reset_(false),pid_(pid) { - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "hg_scanner_239(%s) constructing ...\n", hg_log::format_ptr(this).c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "hg_scanner_239(%s) constructing ...\n", hg_log::format_ptr(this).c_str()); dev_conf_.value = 0; #ifndef MAPPING_FUNCTION_IN_BASE init_setting_map(setting_map_, ARRAY_SIZE(setting_map_)); @@ -390,7 +390,7 @@ hg_scanner_239::hg_scanner_239(const char* dev_name, int pid,usb_io* io) : hg_sc } hg_scanner_239::~hg_scanner_239() { - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "hg_scanner_239(%s) destroyed.\n", hg_log::format_ptr(this).c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "hg_scanner_239(%s) destroyed.\n", hg_log::format_ptr(this).c_str()); } int hg_scanner_239::read_register(int addr, int* val) @@ -428,7 +428,7 @@ std::string hg_scanner_239::control_fetch(int addr, int val, int size) std::string data(""); ret = write_register(addr, val); - if (ret == HG_ERR_OK) + if (ret == SCANNER_ERR_OK) { std::lock_guard lock(io_lock_); @@ -438,12 +438,12 @@ std::string hg_scanner_239::control_fetch(int addr, int val, int size) ret = io_->read_bulk(&data[0], &l); if (ret) { - HG_VLOG_MINI_3(HG_LOG_LEVEL_DEBUG_INFO, "control_fetch(%d, %d) - read_bulk = %s\n", addr, val, hg_scanner::strerr((hg_err)ret).c_str()); + HG_VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "control_fetch(%d, %d) - read_bulk = %s\n", addr, val, hg_scanner::strerr((scanner_err)ret).c_str()); data.clear(); } } else - HG_VLOG_MINI_3(HG_LOG_LEVEL_DEBUG_INFO, "control_fetch(%d, %d) = %s\n", addr, val, hg_scanner::strerr((hg_err)ret).c_str()); + HG_VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "control_fetch(%d, %d) = %s\n", addr, val, hg_scanner::strerr((scanner_err)ret).c_str()); return data; } @@ -454,7 +454,7 @@ std::string hg_scanner_239::get_fpga(void) ret = read_register(SR_GET_MBVERSION_LENGHT, &val); std::string fpga(""); - if (ret == HG_ERR_OK) + if (ret == SCANNER_ERR_OK) { fpga.resize(val + 2); bzero(&fpga[0], val + 2); @@ -469,11 +469,11 @@ int hg_scanner_239::clr_roller_num(void) int val = 0, ret = read_register(SR_CLR_ROLLER_NUM, &val); - if (ret == HG_ERR_OK) + if (ret == SCANNER_ERR_OK) return val; else { - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "clr_roller_num = %s\n", hg_scanner::strerr((hg_err)ret).c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "clr_roller_num = %s\n", hg_scanner::strerr((scanner_err)ret).c_str()); return -1; } } @@ -482,11 +482,11 @@ int hg_scanner_239::get_sleep_time(void) int val = 0, ret = read_register(SR_GET_SLEEPTIME, &val); - if (ret == HG_ERR_OK) + if (ret == SCANNER_ERR_OK) return val; else { - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "get_sleep_time = %s\n", hg_scanner::strerr((hg_err)ret).c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "get_sleep_time = %s\n", hg_scanner::strerr((scanner_err)ret).c_str()); return -1; } } @@ -497,7 +497,7 @@ int hg_scanner_239::get_scan_mode(void) if (ret) { - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "get scan mode error: %s\n", hg_scanner::strerr((hg_err)ret).c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "get scan mode error: %s\n", hg_scanner::strerr((scanner_err)ret).c_str()); status_ = ret; return -1; @@ -512,7 +512,7 @@ int hg_scanner_239::get_status(void) if (ret) { - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "get status error: %s\n", hg_scanner::strerr((hg_err)ret).c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "get status error: %s\n", hg_scanner::strerr((scanner_err)ret).c_str()); status_ = ret; return -1; @@ -527,7 +527,7 @@ bool hg_scanner_239::is_dev_tx(void) if (ret) { - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "is_dev_tx() error: %s\n", hg_scanner::strerr((hg_err)ret).c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "is_dev_tx() error: %s\n", hg_scanner::strerr((scanner_err)ret).c_str()); status_ = ret; return false; @@ -542,7 +542,7 @@ bool hg_scanner_239::is_dev_image_process_done(void) if (ret) { - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "is_dev_image_process_done() error: %s\n", hg_scanner::strerr((hg_err)ret).c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "is_dev_image_process_done() error: %s\n", hg_scanner::strerr((scanner_err)ret).c_str()); status_ = ret; return true; @@ -558,7 +558,7 @@ bool hg_scanner_239::is_dev_image_keep_last_paper(void) if (ret) { - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "is_dev_image_keep_last_paper() error: %s\n", hg_scanner::strerr((hg_err)ret).c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "is_dev_image_keep_last_paper() error: %s\n", hg_scanner::strerr((scanner_err)ret).c_str()); status_ = ret; return true; @@ -571,11 +571,11 @@ int hg_scanner_239::get_scanned_count(void) int val = 0, ret = read_register(SR_GET_SCANN_NUM, &val); - if (ret == HG_ERR_OK) + if (ret == SCANNER_ERR_OK) return val; else { - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "get_scanned_count = %s\n", hg_scanner::strerr((hg_err)ret).c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "get_scanned_count = %s\n", hg_scanner::strerr((scanner_err)ret).c_str()); return -1; } } @@ -584,9 +584,9 @@ int hg_scanner_239::get_image_count(void) int val = 0, ret = read_register(SR_IM_COUNT, &val); - HG_VLOG_MINI_2(HG_LOG_LEVEL_DEBUG_INFO, "get_image_count() = %d, error: %s\n", val, hg_scanner::strerr((hg_err)ret).c_str()); + HG_VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "get_image_count() = %d, error: %s\n", val, hg_scanner::strerr((scanner_err)ret).c_str()); - if (ret == HG_ERR_OK) + if (ret == SCANNER_ERR_OK) return val; else return -1; @@ -596,11 +596,11 @@ int hg_scanner_239::get_front_data_size(void) int val = 0, ret = read_register(SR_IM_FRONT_SIZE, &val); - if (ret == HG_ERR_OK) + if (ret == SCANNER_ERR_OK) return val; else { - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "get_front_data_size = %s\n", hg_scanner::strerr((hg_err)ret).c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "get_front_data_size = %s\n", hg_scanner::strerr((scanner_err)ret).c_str()); return -1; } } @@ -609,9 +609,9 @@ void hg_scanner_239::init_version(void) std::string fv(get_firmware_version()), sn(get_serial_num()); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, " HG3399 firmware version: %s\n", fv.c_str()); - //HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, " HG3399 serial number: %s\n", sn.c_str()); - //HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, " HG3399 IP: %s\n", get_ip().c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, " HG3399 firmware version: %s\n", fv.c_str()); + //HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, " HG3399 serial number: %s\n", sn.c_str()); + //HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, " HG3399 IP: %s\n", get_ip().c_str()); if (fv.length() >= 10 && (fv[5] > 'A' || atoi(fv.substr(6, 4).c_str()) >= 1209)) { @@ -622,12 +622,12 @@ void hg_scanner_239::init_version(void) } void hg_scanner_239::image_process(std::shared_ptr>& buff) { - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "Process image with %u bytes content ...\n", buff->size()); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Process image with %u bytes content ...\n", buff->size()); hg_imgproc::IMGPRCPARAM param; hg_imgproc::HIMGPRC handle = NULL; hg_imgproc::IMGHEAD ih; - int err = HG_ERR_OK, + int err = SCANNER_ERR_OK, index = 0; void* buf = NULL; @@ -674,7 +674,7 @@ void hg_scanner_239::image_process(std::shared_ptr>& buff) colormode=img_conf_.pixtype; err = hg_imgproc::split(handle,img_conf_.multiOutput,img_conf_.splitImage,img_conf_.multi_output_red,colormode,img_conf_.is_duplex); - HG_VLOG_MINI_5(HG_LOG_LEVEL_DEBUG_INFO, "img split-> multiOutput is:%d splitImage is:%d multi_output_red is:%d pixtype is:%d is_duplex:%d\r\n" + HG_VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "img split-> multiOutput is:%d splitImage is:%d multi_output_red is:%d pixtype is:%d is_duplex:%d\r\n" ,img_conf_.multiOutput ,img_conf_.splitImage ,img_conf_.multi_output_red @@ -700,9 +700,9 @@ void hg_scanner_239::image_process(std::shared_ptr>& buff) } hg_imgproc::final(handle); - while (hg_imgproc::get_final_data(handle, &ih, &buf, index++) == HG_ERR_OK && !user_cancel_) + while (hg_imgproc::get_final_data(handle, &ih, &buf, index++) == SCANNER_ERR_OK && !user_cancel_) { - HG_VLOG_MINI_5(HG_LOG_LEVEL_DEBUG_INFO, "Final picture %d (%d * %d * %d) with %u bytes!\n", index + HG_VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "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()) @@ -713,13 +713,13 @@ void hg_scanner_239::image_process(std::shared_ptr>& buff) //cv::imencode(img_type_,*((cv::Mat*)buf),bmpdata); if(bmpdata.empty()) { - status_ = HG_ERR_NO_DATA; + status_ = SCANNER_ERR_NO_DATA; return ; } buf = bmpdata.data(); ih.total_bytes = bmpdata.size(); - HG_VLOG_MINI_6(HG_LOG_LEVEL_DEBUG_INFO, "Set img type is:%s Final picture %d (%d * %d * %d) with %u bytes!\n",img_type_.c_str() ,index + HG_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 , ih.width, ih.height, ih.bits * ih.channels, ih.total_bytes); } save_final_image(&ih, buf); @@ -741,32 +741,32 @@ int hg_scanner_239::get_device_paperon_stautus(void) } // int hg_scanner_239::writedown_device_configuration() // { -// int ret = HG_ERR_OK; +// int ret = SCANNER_ERR_OK; // ret = write_register(SR_CONFIG_SCAN_PARAM, dev_conf_.value); -// HG_VLOG_MINI_2(HG_LOG_LEVEL_DEBUG_INFO, "Writedown scanner configuration(0x%x) = %s\n", dev_conf_.value, hg_scanner::strerr((hg_err)ret).c_str()); +// HG_VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "Writedown scanner configuration(0x%x) = %s\n", dev_conf_.value, hg_scanner::strerr((scanner_err)ret).c_str()); // return ret; // } int hg_scanner_239::writedown_device_configuration(HGSCANCONF *dev_conf) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; if(!dev_conf) dev_conf = &dev_conf_; ret = write_register(SR_CONFIG_SCAN_PARAM, dev_conf->value); - HG_VLOG_MINI_2(HG_LOG_LEVEL_DEBUG_INFO, "Writedown scanner configuration(0x%x) = %s\n", dev_conf->value, hg_scanner::strerr((hg_err)ret).c_str()); + HG_VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "Writedown scanner configuration(0x%x) = %s\n", dev_conf->value, hg_scanner::strerr((scanner_err)ret).c_str()); return ret; } int hg_scanner_239::writedown_image_configuration(void) { int ret = write_register(SR_CONFIF_IMGPROCPARAM, sizeof(SCANCONF)); - if (ret != HG_ERR_OK) + if (ret != SCANNER_ERR_OK) return ret; SCANCONF ic; @@ -840,7 +840,7 @@ else ic.AutoCrop_threshold = threshold_; if (test_1_paper_) { - HG_LOG(HG_LOG_LEVEL_DEBUG_INFO, "scanning mode: testing ONE paper ...\n"); + HG_LOG(LOG_LEVEL_DEBUG_INFO, "scanning mode: testing ONE paper ...\n"); ic.scannum = ic.is_duplex ? 2 : 1; } else @@ -916,60 +916,60 @@ else this_thread::sleep_for(chrono::milliseconds(500)); io_->set_timeout(2000);//必要延时 } - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "Write-down 0x%x bytes image process parameters\n", len); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Write-down 0x%x bytes image process parameters\n", len); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.pixtype=%d", ic.pixtype); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.papertype=%d", ic.papertype); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.AutoCrop_threshold=%d", ic.AutoCrop_threshold); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.autodescrew=%d", ic.autodescrew); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.automaticcolor=%d", ic.automaticcolor); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.brightness=%f", ic.brightness); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.contrast=%f", ic.contrast); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.en_fold=%d", ic.en_fold); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.en_sizecheck=%d", ic.en_sizecheck); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.enhance_color=%d", ic.enhance_color); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.fillbackground=%d", ic.fillbackground); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.filter=%d", ic.filter); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.gamma=%f", ic.gamma); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.hardwarecaps.capturepixtype=%d", ic.hardwarecaps.capturepixtype); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.hardwarecaps.en_doublefeed=%d", ic.hardwarecaps.en_doublefeed); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.hsvcorrect=%d", ic.hsvcorrect); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.imageRotateDegree=%f", ic.imageRotateDegree); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.indent=%d", 5); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_autocontrast=%d", ic.is_autocontrast); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_autocrop=%d", ic.is_autocrop); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_autodiscradblank_normal=%d", ic.is_autodiscradblank_normal); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_autodiscradblank_vince=%d", ic.is_autodiscradblank_vince); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_autotext=%d", ic.is_autotext); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_backrotate180=%d", ic.is_backrotate180); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_convex=%d", ic.is_convex); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_duplex=%d", ic.is_duplex); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_switchfrontback=%d", ic.is_switchfrontback); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_dogeardetection=%d", ic.is_dogeardetection); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.fillhole.multi_output_red=%d", ic.multi_output_red); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.noise=%d", 8); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.pixtype=%d", ic.pixtype); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.resolution_dst=%f", ic.resolution_dst); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.resolution_native=%f", ic.resolution_native); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.scannum=%d", ic.scannum); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.sharpen=%d", ic.sharpen); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.discardblank_percent=%d", ic.discardblank_percent); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.is_detachnoise=%d", ic.detachnoise.is_detachnoise); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.detachnoise=%d\r ", ic.detachnoise.detachnoise); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.refuseInflow=%d\r ", ic.refuseInflow); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.refuseInflow=%d\r ", ic.refuseInflow); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.removeMorr=%d\r ", ic.removeMorr); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.errorExtention=%d\r ", ic.errorExtention); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.textureRemove=%d\r\n ", ic.refuseInflow); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.fillhole.is_fillhole=%d\r\n ", ic.fillhole.is_fillhole); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.ic.fillhole.fillholeratio=%d\r\n ", ic.fillhole.fillholeratio); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.fadeback=%d\r\n ",ic.fadeback); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.pixtype=%d", ic.pixtype); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.papertype=%d", ic.papertype); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.AutoCrop_threshold=%d", ic.AutoCrop_threshold); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.autodescrew=%d", ic.autodescrew); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.automaticcolor=%d", ic.automaticcolor); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.brightness=%f", ic.brightness); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.contrast=%f", ic.contrast); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.en_fold=%d", ic.en_fold); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.en_sizecheck=%d", ic.en_sizecheck); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.enhance_color=%d", ic.enhance_color); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.fillbackground=%d", ic.fillbackground); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.filter=%d", ic.filter); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.gamma=%f", ic.gamma); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.hardwarecaps.capturepixtype=%d", ic.hardwarecaps.capturepixtype); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.hardwarecaps.en_doublefeed=%d", ic.hardwarecaps.en_doublefeed); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.hsvcorrect=%d", ic.hsvcorrect); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.imageRotateDegree=%f", ic.imageRotateDegree); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.indent=%d", 5); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autocontrast=%d", ic.is_autocontrast); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autocrop=%d", ic.is_autocrop); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autodiscradblank_normal=%d", ic.is_autodiscradblank_normal); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autodiscradblank_vince=%d", ic.is_autodiscradblank_vince); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autotext=%d", ic.is_autotext); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_backrotate180=%d", ic.is_backrotate180); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_convex=%d", ic.is_convex); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_duplex=%d", ic.is_duplex); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_switchfrontback=%d", ic.is_switchfrontback); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_dogeardetection=%d", ic.is_dogeardetection); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.fillhole.multi_output_red=%d", ic.multi_output_red); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.noise=%d", 8); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.pixtype=%d", ic.pixtype); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.resolution_dst=%f", ic.resolution_dst); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.resolution_native=%f", ic.resolution_native); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.scannum=%d", ic.scannum); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.sharpen=%d", ic.sharpen); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.discardblank_percent=%d", ic.discardblank_percent); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.is_detachnoise=%d", ic.detachnoise.is_detachnoise); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.detachnoise=%d\r ", ic.detachnoise.detachnoise); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.refuseInflow=%d\r ", ic.refuseInflow); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.refuseInflow=%d\r ", ic.refuseInflow); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.removeMorr=%d\r ", ic.removeMorr); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.errorExtention=%d\r ", ic.errorExtention); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.textureRemove=%d\r\n ", ic.refuseInflow); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.fillhole.is_fillhole=%d\r\n ", ic.fillhole.is_fillhole); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.ic.fillhole.fillholeratio=%d\r\n ", ic.fillhole.fillholeratio); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.fadeback=%d\r\n ",ic.fadeback); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.enable=%d\r ", ic.cropRect.enable); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.width=%d\r\n ", ic.cropRect.width); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.height=%d\r\n ", ic.cropRect.height); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.x=%f\r\n ", ic.cropRect.x); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.y=%d\r\n ",ic.cropRect.y); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.enable=%d\r ", ic.cropRect.enable); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.width=%d\r\n ", ic.cropRect.width); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.height=%d\r\n ", ic.cropRect.height); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.x=%f\r\n ", ic.cropRect.x); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.y=%d\r\n ",ic.cropRect.y); img_conf_ = ic; return ret; @@ -979,7 +979,7 @@ int hg_scanner_239::pop_first_image(void) { int ret = write_register(SR_IM_POP, 1); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "popup first image = %s\n", hg_scanner::strerr((hg_err)ret).c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "popup first image = %s\n", hg_scanner::strerr((scanner_err)ret).c_str()); return ret; } @@ -987,29 +987,29 @@ int hg_scanner_239::pop_first_image(void) int hg_scanner_239::read_one_image_from_usb(void) { //if (is_dev_tx()) - // return HG_ERR_OK; + // return SCANNER_ERR_OK; //if (!is_kernelsnap_211209_) //{ // if (image_prc_param_.bits.page == PAGE_DOUBLE && !image_prc_param_.bits.fractate_check) // if (get_image_count() < 3) - // return HG_ERR_DEVICE_NO_IMAGE; + // return SCANNER_ERR_DEVICE_NO_IMAGE; // if (get_image_count() < 2) - // return HG_ERR_DEVICE_NO_IMAGE; + // return SCANNER_ERR_DEVICE_NO_IMAGE; //} int r = 0, total = get_front_data_size(), off = 0, - ret = HG_ERR_OK; + ret = SCANNER_ERR_OK; if (!waiting_for_memory_enough(total)) { - status_ = HG_ERR_INSUFFICIENT_MEMORY; + status_ = SCANNER_ERR_INSUFFICIENT_MEMORY; return status_; } if (user_cancel_) - return HG_ERR_USER_CANCELED; + return SCANNER_ERR_USER_CANCELED; if (total == -1) ret = status_; @@ -1020,7 +1020,7 @@ int hg_scanner_239::read_one_image_from_usb(void) // write reading command ret = write_register(SR_IM_TX, 1); - if (ret == HG_ERR_OK) + if (ret == SCANNER_ERR_OK) { std::this_thread::sleep_for(std::chrono::milliseconds(10)); r = total; @@ -1029,7 +1029,7 @@ int hg_scanner_239::read_one_image_from_usb(void) ret = io_->read_bulk(buf->data(), &r); - while (ret == HG_ERR_OK) + while (ret == SCANNER_ERR_OK) { off += r; if (off >= total) @@ -1039,11 +1039,11 @@ int hg_scanner_239::read_one_image_from_usb(void) ret = io_->read_bulk(buf->data() + off, &r); } } - if (ret == HG_ERR_OK) + if (ret == SCANNER_ERR_OK) { - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "Read image from USB = %s\n", hg_scanner::strerr((hg_err)ret).c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Read image from USB = %s\n", hg_scanner::strerr((scanner_err)ret).c_str()); ret = save_usb_data(buf); - if (ret == HG_ERR_OK) + if (ret == SCANNER_ERR_OK) { pop_first_image(); //if(image_prc_param_.bits.page == PAGE_SINGLE) @@ -1053,10 +1053,10 @@ int hg_scanner_239::read_one_image_from_usb(void) else { char msg[128]; - sprintf(msg, "Read image data from USB err: %s\n", hg_scanner::strerr((hg_err)ret).c_str()); - HG_LOG(HG_LOG_LEVEL_DEBUG_INFO, msg); + sprintf(msg, "Read image data from USB err: %s\n", hg_scanner::strerr((scanner_err)ret).c_str()); + HG_LOG(LOG_LEVEL_DEBUG_INFO, msg); notify_ui_working_status(msg); - notify_ui_working_status(STATU_DESC_HG_ERR_TIMEOUT, SANE_EVENT_ERROR); + notify_ui_working_status(STATU_DESC_SCANNER_ERR_TIMEOUT, SANE_EVENT_ERROR); } } } @@ -1071,7 +1071,7 @@ void hg_scanner_239::discard_all_images(void) oto = 0, pre_img = 0, pre_int = 0, - ret = HG_ERR_OK; + ret = SCANNER_ERR_OK; { std::lock_guard lock(io_lock_); @@ -1079,7 +1079,7 @@ void hg_scanner_239::discard_all_images(void) io_->set_timeout(100); ret = io_->read_interrupt(buf, &size); } - while (ret == HG_ERR_OK) + while (ret == SCANNER_ERR_OK) { pre_int++; if (info->From == IMG) @@ -1102,7 +1102,7 @@ void hg_scanner_239::discard_all_images(void) io_->set_timeout(oto); } if (pre_int) - HG_VLOG_MINI_2(HG_LOG_LEVEL_DEBUG_INFO, "prev-connection has left %d interrupt packet(s) && %d image(s).\n", pre_int, pre_img); + HG_VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "prev-connection has left %d interrupt packet(s) && %d image(s).\n", pre_int, pre_img); } void hg_scanner_239::init_setting_map(int* setting_map, int count) @@ -1172,7 +1172,7 @@ void hg_scanner_239::init_setting_map(int* setting_map, int count) //color_mode =-1 除色选项 int hg_scanner_239::on_color_mode_changed(int& color_mode) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; if ((((color_mode == COLOR_MODE_24_BITS || color_mode == COLOR_MODE_AUTO_MATCH) && !dev_conf_.g200params.color) || ((color_mode != COLOR_MODE_24_BITS && color_mode != COLOR_MODE_AUTO_MATCH) && dev_conf_.g200params.color)) && color_mode != -1) @@ -1218,7 +1218,7 @@ int hg_scanner_239::on_paper_changed(int& paper) { bool exact = true; int ind = settings::match_best_paper(paper, &exact, &paper_size_), - ret = exact ? HG_ERR_OK : HG_ERR_NOT_EXACT; + ret = exact ? SCANNER_ERR_OK : SCANNER_ERR_NOT_EXACT; if (dev_conf_.g200params.paper != settings::paper_map[ind].dev_value) { @@ -1239,14 +1239,14 @@ int hg_scanner_239::on_paper_changed(int& paper) } } else if (!exact) - ret = HG_ERR_NOT_EXACT; + ret = SCANNER_ERR_NOT_EXACT; } return ret; } int hg_scanner_239::on_paper_check_changed(bool& check) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; if (dev_conf_.g200params.enable_sizecheck ^ check) { @@ -1265,7 +1265,7 @@ int hg_scanner_239::on_resolution_changed(int& dpi) { bool exact = true; int ind = settings::match_best_resolution(dpi, &exact), - ret = exact ? HG_ERR_OK : HG_ERR_NOT_EXACT; + ret = exact ? SCANNER_ERR_OK : SCANNER_ERR_NOT_EXACT; if (dev_conf_.g200params.dpi != settings::resolution_map[ind].dev_value) { @@ -1278,10 +1278,10 @@ int hg_scanner_239::on_resolution_changed(int& dpi) dev_conf_.g200params.dpi = old; } else if (!exact) - ret = HG_ERR_NOT_EXACT; + ret = SCANNER_ERR_NOT_EXACT; } - if (ret == HG_ERR_NOT_EXACT) + if (ret == SCANNER_ERR_NOT_EXACT) dpi = settings::resolution_map[ind].resolution; @@ -1291,7 +1291,7 @@ int hg_scanner_239::on_resolution_changed(int& dpi) int hg_scanner_239::on_ultrasonic_check_changed(bool& check) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; if (dev_conf_.g200params.ultrasonic_enable ^ check) { @@ -1308,7 +1308,7 @@ int hg_scanner_239::on_ultrasonic_check_changed(bool& check) } int hg_scanner_239::on_staple_check_changed(bool& check) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; if (dev_conf_.g200params.staple_enbale ^ check) { @@ -1325,7 +1325,7 @@ int hg_scanner_239::on_staple_check_changed(bool& check) } int hg_scanner_239::on_skew_check_changed(bool& check) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; if (dev_conf_.g200params.screw_detect_enable ^ check) { @@ -1342,7 +1342,7 @@ int hg_scanner_239::on_skew_check_changed(bool& check) } int hg_scanner_239::on_skew_check_level_changed(int& check) { - int ret = HG_ERR_OK, + int ret = SCANNER_ERR_OK, val = check, old = dev_conf_.g200params.screw_detect_level; HGSCANCONF cf; @@ -1352,12 +1352,12 @@ int hg_scanner_239::on_skew_check_level_changed(int& check) if (val < 0) { val = 0; - ret = HG_ERR_NOT_EXACT; + ret = SCANNER_ERR_NOT_EXACT; } else if (val > cf.g200params.screw_detect_level) { val = cf.g200params.screw_detect_level; - ret = HG_ERR_NOT_EXACT; + ret = SCANNER_ERR_NOT_EXACT; } if (val != dev_conf_.g200params.screw_detect_level) { @@ -1366,10 +1366,10 @@ int hg_scanner_239::on_skew_check_level_changed(int& check) if (ret) check = dev_conf_.g200params.screw_detect_level = old; } - if (ret == HG_ERR_OK && val != check) + if (ret == SCANNER_ERR_OK && val != check) { check = val; - ret = HG_ERR_NOT_EXACT; + ret = SCANNER_ERR_NOT_EXACT; } return ret; @@ -1380,7 +1380,7 @@ void hg_scanner_239::on_device_reconnected(void) int ret = writedown_device_configuration(); init_version(); - rewrite_conf_ = ret != HG_ERR_OK; + rewrite_conf_ = ret != SCANNER_ERR_OK; if (reset_) { reset_ = false; @@ -1389,7 +1389,7 @@ void hg_scanner_239::on_device_reconnected(void) } int hg_scanner_239::on_scanner_closing(bool force) { - return HG_ERR_OK; + return SCANNER_ERR_OK; } void hg_scanner_239::thread_handle_usb_read(void) @@ -1397,11 +1397,11 @@ void hg_scanner_239::thread_handle_usb_read(void) char buf[64]; HGEIntInfo* info = (HGEIntInfo*)buf; int size = sizeof(buf), - ret = HG_ERR_OK, + ret = SCANNER_ERR_OK, to_cnt = 0, count = 0; - status_ = HG_ERR_DEVICE_BUSY; + status_ = SCANNER_ERR_DEVICE_BUSY; while (run_ )//&& !user_cancel_ { if (user_cancel_) @@ -1415,7 +1415,7 @@ void hg_scanner_239::thread_handle_usb_read(void) ret = io_->read_interrupt(buf, &size); io_->set_timeout(1000); } - if (ret == HG_ERR_TIMEOUT) + if (ret == SCANNER_ERR_TIMEOUT) { if (++to_cnt > 10) { @@ -1427,12 +1427,12 @@ void hg_scanner_239::thread_handle_usb_read(void) std::this_thread::sleep_for(std::chrono::milliseconds(500)); if ((get_status() & 0x03) == 0) { - status_ = HG_ERR_OK; + status_ = SCANNER_ERR_OK; break; } continue; } - else if (ret != HG_ERR_OK) + else if (ret != SCANNER_ERR_OK) { status_ = ret; break; @@ -1442,9 +1442,9 @@ void hg_scanner_239::thread_handle_usb_read(void) if (size == sizeof(buf)) { status_ = settings::device_status_to_hg_err(info); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "status from interrupt point is '%s'\n", hg_scanner::strerr((hg_err)status_).c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "status from interrupt point is '%s'\n", hg_scanner::strerr((scanner_err)status_).c_str()); - if (status_ != HG_ERR_OK && status_ != HG_ERR_TIMEOUT && status_ != HG_ERR_DEVICE_STOPPED) + if (status_ != SCANNER_ERR_OK && status_ != SCANNER_ERR_TIMEOUT && status_ != SCANNER_ERR_DEVICE_STOPPED) { if (!is_dev_image_process_done()) { @@ -1456,15 +1456,15 @@ void hg_scanner_239::thread_handle_usb_read(void) { ret = read_one_image_from_usb(); count++; - if (ret != HG_ERR_OK - && ret != HG_ERR_CREATE_FILE_FAILED - && ret != HG_ERR_WRITE_FILE_FAILED) + if (ret != SCANNER_ERR_OK + && ret != SCANNER_ERR_CREATE_FILE_FAILED + && ret != SCANNER_ERR_WRITE_FILE_FAILED) break; } status_ = st; } - HG_VLOG_MINI_1(HG_LOG_LEVEL_WARNING, "扫描失败, read interrupt返回状态为：%s\n", hg_scanner::error_description((hg_err)status_).c_str()); - //notify_ui_working_status(("扫描失败 " + hg_scanner::error_description((hg_err)status_)).c_str(), SANE_EVENT_ERROR, status_); + HG_VLOG_MINI_1(LOG_LEVEL_WARNING, "扫描失败, read interrupt返回状态为：%s\n", hg_scanner::error_description((scanner_err)status_).c_str()); + //notify_ui_working_status(("扫描失败 " + hg_scanner::error_description((scanner_err)status_)).c_str(), SANE_EVENT_ERROR, status_); break; } @@ -1477,26 +1477,26 @@ void hg_scanner_239::thread_handle_usb_read(void) { count++; ret = read_one_image_from_usb(); - if (ret != HG_ERR_OK - && ret != HG_ERR_CREATE_FILE_FAILED - && ret != HG_ERR_WRITE_FILE_FAILED) + if (ret != SCANNER_ERR_OK + && ret != SCANNER_ERR_CREATE_FILE_FAILED + && ret != SCANNER_ERR_WRITE_FILE_FAILED) break; } if (user_cancel_) { - if (ret == HG_ERR_INSUFFICIENT_MEMORY) + if (ret == SCANNER_ERR_INSUFFICIENT_MEMORY) stop(); - status_ = ret = HG_ERR_USER_CANCELED; - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "用户取消操作 '%s'\n", hg_scanner::strerr((hg_err)status_).c_str()); + status_ = ret = SCANNER_ERR_USER_CANCELED; + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "用户取消操作 '%s'\n", hg_scanner::strerr((scanner_err)status_).c_str()); break; } } //else - // HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "status(0x%x) is not accept in usb thread\n", status); + // HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "status(0x%x) is not accept in usb thread\n", status); } else if (info->From == STOPSCAN) { - HG_LOG(HG_LOG_LEVEL_DEBUG_INFO, "received 'STOPSCAN' message in usb thread, check remaining image and finish scanning ...\n"); + HG_LOG(LOG_LEVEL_DEBUG_INFO, "received 'STOPSCAN' message in usb thread, check remaining image and finish scanning ...\n"); // fetch all buffered images and exit ... while(!is_dev_image_process_done()) @@ -1506,60 +1506,60 @@ void hg_scanner_239::thread_handle_usb_read(void) { ret = read_one_image_from_usb(); count++; - if (ret != HG_ERR_OK - && ret != HG_ERR_CREATE_FILE_FAILED - && ret != HG_ERR_WRITE_FILE_FAILED) + if (ret != SCANNER_ERR_OK + && ret != SCANNER_ERR_CREATE_FILE_FAILED + && ret != SCANNER_ERR_WRITE_FILE_FAILED) break; } if (count == 0) { std::lock_guard lock(io_lock_); - HG_LOG(HG_LOG_LEVEL_DEBUG_INFO, "First message received from USB is 'STOPSCAN'\n"); + HG_LOG(LOG_LEVEL_DEBUG_INFO, "First message received from USB is 'STOPSCAN'\n"); // notify_ui_working_status(STATU_DESC_DEVICE_RESET); // reset_ = true; // ret = io_->reset(); - // status_ = HG_ERR_IO; + // status_ = SCANNER_ERR_IO; } - else if (status_ == HG_ERR_TIMEOUT || status_ == HG_ERR_IO || status_ == HG_ERR_DEVICE_STOPPED) - status_ = HG_ERR_OK; + else if (status_ == SCANNER_ERR_TIMEOUT || status_ == SCANNER_ERR_IO || status_ == SCANNER_ERR_DEVICE_STOPPED) + status_ = SCANNER_ERR_OK; int s = get_status(); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "status after received 'STOPSCAN': 0x%x\n", s); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "status after received 'STOPSCAN': 0x%x\n", s); if (count || (s & 3) == 0) { - HG_LOG(HG_LOG_LEVEL_DEBUG_INFO, "Really stopped ^_^\n"); + HG_LOG(LOG_LEVEL_DEBUG_INFO, "Really stopped ^_^\n"); break; } } else if (info->From == V4L2) { - HG_VLOG_MINI_2(HG_LOG_LEVEL_WARNING, "V4L2 message received, code = %d, index = %d\n", info->Code, info->Img_Index); + HG_VLOG_MINI_2(LOG_LEVEL_WARNING, "V4L2 message received, code = %d, index = %d\n", info->Code, info->Img_Index); // stop(); break; } else { // error handling ... - HG_VLOG_MINI_4(HG_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::strerr((hg_err)status_).c_str()); + HG_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::strerr((scanner_err)status_).c_str()); } } else - HG_VLOG_MINI_2(HG_LOG_LEVEL_DEBUG_INFO, "read %d bytes, sizeof(buf) = %d\n", size, sizeof(buf)); + HG_VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "read %d bytes, sizeof(buf) = %d\n", size, sizeof(buf)); this_thread::sleep_for(chrono::milliseconds(10)); } - HG_VLOG_MINI_2(HG_LOG_LEVEL_DEBUG_INFO, "USB thread exit with code: %s, status = %s\n", hg_scanner::strerr((hg_err)ret).c_str(), hg_scanner::strerr((hg_err)status_).c_str()); + HG_VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "USB thread exit with code: %s, status = %s\n", hg_scanner::strerr((scanner_err)ret).c_str(), hg_scanner::strerr((scanner_err)status_).c_str()); } int hg_scanner_239::start(void) { - int ret = HG_ERR_OK, + int ret = SCANNER_ERR_OK, val = 0; user_cancel_ = false; cb_mem_ = true; - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "scanner status: 0x%x\n", get_status()); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "scanner status: 0x%x\n", get_status()); notify_ui_working_status(STATU_DESC_PREPARE_START); reset(); @@ -1567,20 +1567,20 @@ int hg_scanner_239::start(void) val = get_sleep_time(); //if (val != 1) //{ - // status_ = HG_ERR_DEVICE_SLEEPING; - // HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "scanner's status(0x%x) is considerring as sleepping.\n", val); + // status_ = SCANNER_ERR_DEVICE_SLEEPING; + // HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "scanner's status(0x%x) is considerring as sleepping.\n", val); // return status_; //} val = get_scan_mode(); - if (status_ == HG_ERR_DEVICE_NOT_FOUND) + if (status_ == SCANNER_ERR_DEVICE_NOT_FOUND) return status_; if (val == -1) return status_; if (val & 1) { - status_ = HG_ERR_DEVICE_COUNT_MODE; + status_ = SCANNER_ERR_DEVICE_COUNT_MODE; return status_; } @@ -1592,58 +1592,58 @@ int hg_scanner_239::start(void) //ret = writedown_device_configuration(); } - if(ret == HG_ERR_OK) + if(ret == SCANNER_ERR_OK) { ret = writedown_image_configuration(); } if (ret) { - HG_VLOG_MINI_1(HG_LOG_LEVEL_WARNING, "Write down image process parameters fail is(%s), the result will be unpredictable.\n", hg_scanner::strerr((hg_err)ret).c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_WARNING, "Write down image process parameters fail is(%s), the result will be unpredictable.\n", hg_scanner::strerr((scanner_err)ret).c_str()); std::string info(STATU_DESC_REWRITE_CONFIGURATION); - info += "失败：" + hg_scanner::strerr((hg_err)ret); + info += "失败：" + hg_scanner::strerr((scanner_err)ret); notify_ui_working_status(info.c_str(), SANE_EVENT_ERROR, ret); } - if (ret != HG_ERR_OK) + if (ret != SCANNER_ERR_OK) { - HG_VLOG_MINI_1(HG_LOG_LEVEL_WARNING, "start status01 is(%s), the result will be unpredictable.\n", hg_scanner::strerr((hg_err)ret).c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_WARNING, "start status01 is(%s), the result will be unpredictable.\n", hg_scanner::strerr((scanner_err)ret).c_str()); return ret; } ret = get_scanner_paperon(); - if (ret == HG_ERR_DEVICE_NO_PAPER) + if (ret == SCANNER_ERR_DEVICE_NO_PAPER) { status_ = ret; - notify_ui_working_status(STATU_DESC_HG_ERR_DEVICE_NO_PAPER, SANE_EVENT_ERROR, status_); - HG_VLOG_MINI_1(HG_LOG_LEVEL_WARNING, "device start status is(%s)\n", STATU_DESC_HG_ERR_DEVICE_NO_PAPER); + notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER, SANE_EVENT_ERROR, status_); + HG_VLOG_MINI_1(LOG_LEVEL_WARNING, "device start status is(%s)\n", STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER); return ret; } ret = write_command(SC_START); - HG_VLOG_MINI_1(HG_LOG_LEVEL_WARNING, "start status02 is(%s), the result will be unpredictable.\n", hg_scanner::strerr((hg_err)ret).c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_WARNING, "start status02 is(%s), the result will be unpredictable.\n", hg_scanner::strerr((scanner_err)ret).c_str()); io_->set_timeout(1000); - if (ret == HG_ERR_OK) + if (ret == SCANNER_ERR_OK) { - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "Write SC_START command success, and now scanner stauts is %x\n", get_status()); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Write SC_START command success, and now scanner stauts is %x\n", get_status()); - //status_ = HG_ERR_DEVICE_BUSY; + //status_ = SCANNER_ERR_DEVICE_BUSY; wait_usb_.notify(); this_thread::sleep_for(chrono::milliseconds(100)); } else { status_ = ret; - HG_VLOG_MINI_3(HG_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::strerr((hg_err)ret).c_str()); + HG_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::strerr((scanner_err)ret).c_str()); } return ret; } //int hg_scanner_239::get_image_info(IMG_PARAM* ii) //{ -// int ret = HG_ERR_OK; +// int ret = SCANNER_ERR_OK; // IMH imh; // // bzero(&imh, sizeof(imh)); @@ -1655,7 +1655,7 @@ int hg_scanner_239::start(void) // else // { // if (!final_imgs_.front(&imh)) -// ret = HG_ERR_NO_DATA; +// ret = SCANNER_ERR_NO_DATA; // else // { // if (image_prc_param_.bits.color_mode == COLOR_MODE_24_BITS) @@ -1669,14 +1669,14 @@ int hg_scanner_239::start(void) // ii->lines = imh.height; // } // } -// HG_VLOG_MINI_4(HG_LOG_LEVEL_DEBUG_INFO, "Get image info(%d * %d * %d) = %s\n", ii->pixels_per_line, ii->lines, imh.bits, hg_scanner::strerr((hg_err)ret).c_str()); +// HG_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::strerr((scanner_err)ret).c_str()); // // return ret; //} //int hg_scanner_239::read_image_data(unsigned char* buf, int* len) //{ // if (!len) -// return HG_ERR_INVALID_PARAMETER; +// return SCANNER_ERR_INVALID_PARAMETER; // // if (!buf) // { @@ -1684,7 +1684,7 @@ int hg_scanner_239::start(void) // final_imgs_.front(&imh); // *len = imh.bytes; // -// return HG_ERR_INSUFFICIENT_MEMORY; +// return SCANNER_ERR_INSUFFICIENT_MEMORY; // } // // if (final_imgs_.Size() > 0) @@ -1692,17 +1692,17 @@ int hg_scanner_239::start(void) // int fetch = *len; // // final_imgs_.fetch_front(buf, len); -// HG_VLOG_MINI_4(HG_LOG_LEVEL_DEBUG_INFO, "[%s]UI fetch image 0x%x/0x%x to buf %s...\n", hg_log::format_current_thread_id().c_str(), *len, fetch +// HG_VLOG_MINI_4(LOG_LEVEL_DEBUG_INFO, "[%s]UI fetch image 0x%x/0x%x to buf %s...\n", hg_log::format_current_thread_id().c_str(), *len, fetch // , hg_log::format_ptr(buf).c_str()); // -// return HG_ERR_OK; +// return SCANNER_ERR_OK; // } // else -// return HG_ERR_NO_DATA; +// return SCANNER_ERR_NO_DATA; //} int hg_scanner_239::stop(void) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; user_cancel_ = true; ret = write_command(SC_STOP); @@ -1723,13 +1723,13 @@ int hg_scanner_239::reset(void) } int hg_scanner_239::device_io_control(unsigned long code, void* data, unsigned* len) { - int ret = HG_ERR_OUT_OF_RANGE; + int ret = SCANNER_ERR_OUT_OF_RANGE; if (HG_CONTROL_CODE_OPTION_ENABLE == code) { OPTEN* opten = (OPTEN*)data; - ret = HG_ERR_OK; + ret = SCANNER_ERR_OK; if (opten->opt_num == HG_239_SETTING_CORRECT && !opten->enabled) // for BUG-20 modified by Gongbing on 2022-03-12 { bool enable = true; @@ -1763,11 +1763,11 @@ int hg_scanner_239::get_roller_num(void) int val = 0, ret = read_register(SR_GET_ROLLER_NUM, &val); - if (ret == HG_ERR_OK) + if (ret == SCANNER_ERR_OK) return val; else { - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "get_roller_num = %s\n", hg_scanner::strerr((hg_err)ret).c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "get_roller_num = %s\n", hg_scanner::strerr((scanner_err)ret).c_str()); return -1; } } @@ -1785,7 +1785,7 @@ int hg_scanner_239::clear_roller_num(void) int hg_scanner_239::set_leaflet_scan(void) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; test_1_paper_ = true; ret = start(); @@ -1794,44 +1794,44 @@ int hg_scanner_239::set_leaflet_scan(void) int hg_scanner_239::get_abuot_info(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_239::restore_default_setting(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_239::set_final_image_format(SANE_FinalImgFormat* fmt) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_239::get_compression_format(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_239::set_compression_format(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_239::set_auto_color_type(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_239::get_device_code(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_239::get_sleep_time(SANE_Power* getime) { int val = 0, ret = read_register(SR_GET_SLEEPTIME, &val); - if (ret == HG_ERR_OK) + if (ret == SCANNER_ERR_OK) *getime = (SANE_Power)val; else { - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "get_sleep_time = %s\n", hg_scanner::strerr((hg_err)ret).c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "get_sleep_time = %s\n", hg_scanner::strerr((scanner_err)ret).c_str()); return -1; } } @@ -1840,28 +1840,28 @@ int hg_scanner_239::set_sleep_time(int setsleepime) { int ret = write_register(SR_SET_SLEEPTIME, setsleepime); - HG_VLOG_MINI_2(HG_LOG_LEVEL_DEBUG_INFO, "set sleep time to %d = %s\n", setsleepime, hg_scanner::strerr((hg_err)ret).c_str()); + HG_VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "set sleep time to %d = %s\n", setsleepime, hg_scanner::strerr((scanner_err)ret).c_str()); return ret; } int hg_scanner_239::get_dogear_distance(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_239::set_dogear_distance(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_239::get_scanner_paperon(SANE_Bool* paperon) { int val = 0, ret = read_register(SR_GET_PAPERON, &val); - if (ret == HG_ERR_OK) + if (ret == SCANNER_ERR_OK) { if (!val) { - ret = HG_ERR_DEVICE_NO_PAPER; + ret = SCANNER_ERR_DEVICE_NO_PAPER; if (paperon) { *paperon = true; @@ -1869,7 +1869,7 @@ int hg_scanner_239::get_scanner_paperon(SANE_Bool* paperon) } else { - ret = HG_ERR_OK; + ret = SCANNER_ERR_OK; if (paperon) { *paperon = false; @@ -1878,28 +1878,28 @@ int hg_scanner_239::get_scanner_paperon(SANE_Bool* paperon) } else { - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "get_scanner_paperon = %s\n", hg_scanner::strerr((hg_err)ret).c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "get_scanner_paperon = %s\n", hg_scanner::strerr((scanner_err)ret).c_str()); return -1; } return ret; } int hg_scanner_239::set_scan_when_paper_on(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_239::get_scan_when_paper_on(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_239::get_scan_with_hole(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_239::set_scan_with_hole(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_239::get_scan_is_sleep() { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } diff --git a/hgdriver/hgdev/hg_scanner_239.h b/hgdriver/hgdev/hg_scanner_239.h index c49219b..c9bca91 100644 --- a/hgdriver/hgdev/hg_scanner_239.h +++ b/hgdriver/hgdev/hg_scanner_239.h @@ -12,6 +12,13 @@ #include "hg_scanner.h" +#ifdef OEM_HANWANG +#define hg_scanner_239 hw_scanner_239 +#elif defined(OEM_LISICHENG) +#define hg_scanner_239 lsc_scanner_239 +#endif + + class hg_scanner_239 : public hg_scanner { //BlockingQueue>> final_imgs_; // JPG ... diff --git a/hgdriver/hgdev/hg_scanner_300.cpp b/hgdriver/hgdev/hg_scanner_300.cpp index 324d08b..1cb4bbe 100644 --- a/hgdriver/hgdev/hg_scanner_300.cpp +++ b/hgdriver/hgdev/hg_scanner_300.cpp @@ -9,52 +9,52 @@ static std::string jsontext("{\"device_type\":\"G300\",\"option_count\":51,\"1\":{\"category\":\"base\",\"name\":\"cfg-1\",\"title\":\"\\u6062\\u590d\\u9ed8\\u8ba4\\u8bbe\\u7f6e\",\"desc\":\"\\u6062\\u590d\\u9ed8\\u8ba4\\u8bbe\\u7f6e\",\"type\":\"button\",\"cur\":\"button\",\"default\":\"button\",\"size\":0},\"2\":{\"category\":\"advanced\",\"name\":\"cfg-2\",\"title\":\"\\u5e2e\\u52a9\",\"desc\":\"\\u663e\\u793a\\u8f6f\\u4ef6\\u5e2e\\u52a9\\u6587\\u6863\",\"type\":\"button\",\"cur\":\"true\",\"default\":\"true\",\"size\":4},\"3\":{\"category\":\"base\",\"name\":\"grp-1\",\"title\":\"\\u57fa\\u672c\\u8bbe\\u7f6e\",\"type\":\"group\"},\"4\":{\"category\":\"base\",\"name\":\"cfg-4\",\"title\":\"\\u989c\\u8272\\u6a21\\u5f0f\",\"desc\":\"\\u8bbe\\u7f6e\\u989c\\u8272\\u4f4d\\u6df1\",\"type\":\"string\",\"cur\":\"24\\u4f4d\\u5f69\\u8272\",\"default\":\"24\\u4f4d\\u5f69\\u8272\",\"size\":32,\"range\":[\"24\\u4f4d\\u5f69\\u8272\",\"256\\u7ea7\\u7070\\u5ea6\",\"\\u9ed1\\u767d\",\"\\u989c\\u8272\\u81ea\\u52a8\\u8bc6\\u522b\"]},\"5\":{\"category\":\"base\",\"name\":\"cfg-5\",\"title\":\"\\u7070\\u5ea6\\u6216\\u9ed1\\u767d\\u56fe\\u50cf - \\u9664\\u8272\",\"desc\":\"\\u9664\\u53bb\\u56fe\\u50cf\\u5f69\\u8272\",\"type\":\"string\",\"cur\":\"\\u4e0d\\u9664\\u8272\",\"default\":\"\\u4e0d\\u9664\\u8272\",\"size\":24,\"range\":[\"\\u4e0d\\u9664\\u8272\",\"\\u9664\\u7ea2\\u8272\",\"\\u9664\\u7eff\\u8272\",\"\\u9664\\u84dd\\u8272\",\"\\u7ea2\\u8272\\u589e\\u5f3a\",\"\\u7eff\\u8272\\u589e\\u5f3a\",\"\\u84dd\\u8272\\u589e\\u5f3a\"],\"depend_or\":[\"4==256\\u7ea7\\u7070\\u5ea6\",\"4==\\u9ed1\\u767d\"]},\"6\":{\"category\":\"base\",\"name\":\"cfg-6\",\"title\":\"\\u591a\\u6d41\\u8f93\\u51fa\",\"desc\":\"\",\"type\":\"string\",\"cur\":\"\\u65e0\",\"default\":\"\\u65e0\",\"size\":32,\"range\":[\"\\u65e0\",\"\\u5f69\\u8272+\\u7070\\u5ea6+\\u9ed1\\u767d\",\"\\u5f69\\u8272+\\u7070\\u5ea6\",\"\\u5f69\\u8272+\\u9ed1\\u767d\",\"\\u7070\\u5ea6+\\u9ed1\\u767d\"],\"depend_or\":[\"4==24\\u4f4d\\u5f69\\u8272\"]},\"7\":{\"category\":\"base\",\"name\":\"cfg-7\",\"title\":\"24\\u4f4d\\u5f69\\u8272\\u56fe\\u50cf - \\u591a\\u6d41\\u8f93\\u51fa\\u9664\\u7ea2\",\"desc\":\"\\u591a\\u901a\\u9053\\u8f93\\u51fa\\u4e2d\\uff0c\\u53bb\\u9664\\u7ea2\\u8272\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_or\":[\"4==24\\u4f4d\\u5f69\\u8272\"]},\"8\":{\"category\":\"base\",\"name\":\"cfg-8\",\"title\":\"24\\u4f4d\\u5f69\\u8272\\u56fe\\u50cf - \\u7b54\\u9898\\u5361\\u9664\\u7ea2\",\"desc\":\"\\u7b54\\u9898\\u5361\\u626b\\u63cf\\u4e2d\\u53bb\\u9664\\u7ea2\\u8272\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_or\":[\"4==24\\u4f4d\\u5f69\\u8272\"]},\"9\":{\"category\":\"base\",\"name\":\"cfg-9\",\"title\":\"\\u80cc\\u666f\\u79fb\\u9664\",\"desc\":\"\\u79fb\\u9664\\u5f69\\u8272\\u56fe\\u50cf\\u80cc\\u666f\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_or\":[\"4==24\\u4f4d\\u5f69\\u8272\"]},\"10\":{\"category\":\"base\",\"name\":\"cfg-10\",\"title\":\" \\u80cc\\u666f\\u8272\\u5f69\\u6d6e\\u52a8\\u8303\\u56f4\",\"desc\":\"\\u8bbe\\u5b9a\\u80cc\\u666f\\u8272\\u5f69\\u7684\\u6d6e\\u52a8\\u8303\\u56f4\\uff0c\\u5728\\u8be5\\u8303\\u56f4\\u5185\\u7684\\u90fd\\u5f53\\u4f5c\\u80cc\\u666f\\u79fb\\u9664\",\"type\":\"int\",\"cur\":20,\"default\":20,\"size\":4,\"range\":{\"min\":1,\"max\":128},\"depend_or\":[\"9==true\"]},\"11\":{\"category\":\"base\",\"name\":\"cfg-11\",\"title\":\"\\u9510\\u5316\\u4e0e\\u6a21\\u7cca\",\"desc\":\"\\u9510\\u5316\\u4e0e\\u6a21\\u7cca\",\"type\":\"string\",\"cur\":\"\\u65e0\",\"default\":\"\\u65e0\",\"size\":24,\"range\":[\"\\u65e0\",\"\\u9510\\u5316\",\"\\u8fdb\\u4e00\\u6b65\\u9510\\u5316\",\"\\u6a21\\u7cca\",\"\\u8fdb\\u4e00\\u6b65\\u6a21\\u7cca\"],\"depend_and\":[\"4!=\\u9ed1\\u767d\",\"4!=\\u989c\\u8272\\u81ea\\u52a8\\u8bc6\\u522b\"]},\"12\":{\"category\":\"base\",\"name\":\"cfg-12\",\"title\":\"\\u53bb\\u9664\\u6469\\u5c14\\u7eb9\",\"desc\":\"\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_and\":[\"4!=\\u9ed1\\u767d\",\"4!=\\u989c\\u8272\\u81ea\\u52a8\\u8bc6\\u522b\"]},\"13\":{\"category\":\"base\",\"name\":\"cfg-13\",\"title\":\"\\u9519\\u8bef\\u6269\\u6563\",\"desc\":\"\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_or\":[\"4==\\u9ed1\\u767d\"]},\"14\":{\"category\":\"base\",\"name\":\"cfg-14\",\"title\":\"\\u9664\\u7f51\\u7eb9\",\"desc\":\"\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_and\":[\"4!=\\u9ed1\\u767d\",\"4!=\\u989c\\u8272\\u81ea\\u52a8\\u8bc6\\u522b\"]},\"15\":{\"category\":\"base\",\"name\":\"cfg-15\",\"title\":\"\\u9ed1\\u767d\\u56fe\\u50cf\\u566a\\u70b9\\u4f18\\u5316\",\"desc\":\"\\u566a\\u70b9\\u4f18\\u5316\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_or\":[\"4==\\u9ed1\\u767d\"]},\"16\":{\"category\":\"base\",\"name\":\"cfg-16\",\"title\":\" \\u566a\\u70b9\\u4f18\\u5316\\u5c3a\\u5bf8\",\"desc\":\"\\u566a\\u70b9\\u4f18\\u5316\\u5c3a\\u5bf8\",\"type\":\"int\",\"cur\":30,\"default\":30,\"size\":4,\"range\":{\"min\":10,\"max\":50},\"depend_or\":[\"15==true\"]},\"17\":{\"category\":\"base\",\"name\":\"cfg-17\",\"title\":\"\\u7eb8\\u5f20\\u5c3a\\u5bf8\",\"desc\":\"\\u8bbe\\u7f6e\\u7eb8\\u5f20\\u5927\\u5c0f\",\"type\":\"string\",\"cur\":\"\\u5339\\u914d\\u539f\\u59cb\\u5c3a\\u5bf8\",\"default\":\"\\u5339\\u914d\\u539f\\u59cb\\u5c3a\\u5bf8\",\"size\":40,\"range\":[\"A4\",\"A5\",\"A5\\u6a2a\\u5411\",\"A6\",\"A6\\u6a2a\\u5411\",\"B5\",\"B5\\u6a2a\\u5411\",\"B6\",\"B6\\u6a2a\\u5411\",\"\\u5339\\u914d\\u539f\\u59cb\\u5c3a\\u5bf8\",\"\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\\u81ea\\u52a8\\u88c1\\u5207\",\"\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\"]},\"18\":{\"category\":\"base\",\"name\":\"cfg-18\",\"title\":\"\\u81ea\\u5b9a\\u4e49\\u626b\\u63cf\\u533a\\u57df\",\"desc\":\"\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_and\":[\"17!=\\u5339\\u914d\\u539f\\u59cb\\u5c3a\\u5bf8\",\"17!=\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\",\"17!=\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\\u81ea\\u52a8\\u88c1\\u5207\"]},\"19\":{\"category\":\"base\",\"name\":\"tl-x\",\"title\":\"\\u626b\\u63cf\\u533a\\u57df\\u5de6\\u4fa7\\uff08mm\\uff09\",\"desc\":\"\",\"type\":\"float\",\"cur\":0.000000,\"default\":0.000000,\"size\":4,\"range\":{\"min\":0.000000,\"max\":210.000000},\"depend_and\":[\"18==true\"]},\"20\":{\"category\":\"base\",\"name\":\"br-x\",\"title\":\"\\u626b\\u63cf\\u533a\\u57df\\u53f3\\u4fa7\\uff08mm\\uff09\",\"desc\":\"\",\"type\":\"float\",\"cur\":210.000000,\"default\":210.000000,\"size\":4,\"range\":{\"min\":0.000000,\"max\":210.000000},\"depend_and\":[\"18==true\"]},\"21\":{\"category\":\"base\",\"name\":\"tl-y\",\"title\":\"\\u626b\\u63cf\\u533a\\u57df\\u4e0a\\u4fa7\\uff08mm\\uff09\",\"desc\":\"\",\"type\":\"float\",\"cur\":0.000000,\"default\":0.000000,\"size\":4,\"range\":{\"min\":0.000000,\"max\":297.000000},\"depend_and\":[\"18==true\"]},\"22\":{\"category\":\"base\",\"name\":\"br-y\",\"title\":\"\\u626b\\u63cf\\u533a\\u57df\\u4e0b\\u4fa7\\uff08mm\\uff09\",\"desc\":\"\",\"type\":\"float\",\"cur\":297.000000,\"default\":297.000000,\"size\":4,\"range\":{\"min\":0.000000,\"max\":297.000000},\"depend_and\":[\"18==true\"]},\"23\":{\"category\":\"base\",\"name\":\"cfg-23\",\"title\":\"\\u626b\\u63cf\\u9875\\u9762\",\"desc\":\"\\u8bbe\\u7f6e\\u9875\\u9762\\u626b\\u63cf\\u65b9\\u5f0f\",\"type\":\"string\",\"cur\":\"\\u53cc\\u9762\",\"default\":\"\\u53cc\\u9762\",\"size\":50,\"range\":[\"\\u5355\\u9762\",\"\\u53cc\\u9762\",\"\\u8df3\\u8fc7\\u7a7a\\u767d\\u9875\\uff08\\u901a\\u7528\\uff09\",\"\\u8df3\\u8fc7\\u7a7a\\u767d\\u9875\\uff08\\u53d1\\u7968\\u7eb8\\uff09\",\"\\u5bf9\\u6298\"]},\"24\":{\"category\":\"base\",\"name\":\"cfg-24\",\"title\":\" \\u8df3\\u8fc7\\u7a7a\\u767d\\u9875\\u7075\\u654f\\u5ea6\",\"desc\":\"\\u7075\\u654f\\u5ea6\\u8d8a\\u9ad8\\uff0c\\u5219\\u8d8a\\u5bb9\\u6613\\u8df3\\u8fc7\",\"type\":\"int\",\"cur\":50,\"default\":50,\"size\":4,\"range\":{\"min\":1,\"max\":100},\"depend_or\":[\"23==\\u8df3\\u8fc7\\u7a7a\\u767d\\u9875\\uff08\\u901a\\u7528\\uff09\",\"23==\\u8df3\\u8fc7\\u7a7a\\u767d\\u9875\\uff08\\u53d1\\u7968\\u7eb8\\uff09\"]},\"25\":{\"category\":\"base\",\"name\":\"cfg-25\",\"title\":\"\\u5206\\u8fa8\\u7387\",\"desc\":\"\\u626b\\u63cf\\u4eea\\u5206\\u8fa8\\u7387\",\"type\":\"int\",\"cur\":200,\"default\":200,\"size\":4,\"range\":[100,150,200,240,300,600]},\"26\":{\"category\":\"base\",\"name\":\"cfg-26\",\"title\":\"\\u4ea4\\u6362\\u6b63\\u53cd\\u9762\",\"desc\":\"\\u4ea4\\u6362\\u6b63\\u53cd\\u9762\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_and\":[\"23!=\\u5355\\u9762\"]},\"27\":{\"category\":\"base\",\"name\":\"cfg-27\",\"title\":\"\\u56fe\\u50cf\\u62c6\\u5206\",\"desc\":\"\\u81ea\\u52a8\\u62c6\\u5206\\u56fe\\u50cf\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_or\":[\"23!=\\u5bf9\\u6298\"]},\"28\":{\"category\":\"base\",\"name\":\"cfg-28\",\"title\":\"\\u81ea\\u52a8\\u7ea0\\u504f\",\"desc\":\"\\u81ea\\u52a8\\u7ea0\\u504f\",\"type\":\"bool\",\"cur\":true,\"default\":true,\"size\":4,\"depend_or\":[\"23!=\\u5bf9\\u6298\"]},\"29\":{\"category\":\"base\",\"name\":\"grp-2\",\"title\":\"\\u4eae\\u5ea6\",\"type\":\"group\"},\"30\":{\"category\":\"base\",\"name\":\"cfg-30\",\"title\":\"\\u542f\\u7528\\u8272\\u8c03\\u66f2\\u7ebf\",\"desc\":\"\\u901a\\u8fc7\\u8272\\u8c03\\u66f2\\u7ebf\\u6765\\u8bbe\\u7f6e\\u56fe\\u50cf\\u4f3d\\u9a6c\\u503c\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4},\"31\":{\"category\":\"base\",\"name\":\"cfg-31\",\"title\":\"\\u4eae\\u5ea6\\u503c\",\"desc\":\"\\u8c03\\u6574\\u56fe\\u7247\\u4eae\\u5ea6\",\"type\":\"int\",\"cur\":128,\"default\":128,\"size\":4,\"range\":{\"min\":1,\"max\":255},\"depend_and\":[\"30==false\"]},\"32\":{\"category\":\"base\",\"name\":\"cfg-32\",\"title\":\"\\u5bf9\\u6bd4\\u5ea6\",\"desc\":\"\\u8c03\\u6574\\u56fe\\u7247\\u5bf9\\u6bd4\\u5ea6\",\"type\":\"int\",\"cur\":4,\"default\":4,\"size\":4,\"range\":{\"min\":1,\"max\":7},\"depend_and\":[\"30==false\"]},\"33\":{\"category\":\"base\",\"name\":\"cfg-33\",\"title\":\"\\u4f3d\\u9a6c\\u503c\",\"desc\":\"\\u8c03\\u6574\\u56fe\\u7247\\u4f3d\\u9a6c\\u503c\",\"type\":\"float\",\"cur\":1.000000,\"default\":1.000000,\"size\":4,\"range\":{\"min\":1.000000,\"max\":5.000000},\"depend_and\":[\"30==false\"]},\"34\":{\"category\":\"base\",\"name\":\"grp-3\",\"title\":\"\\u56fe\\u50cf\\u5904\\u7406\",\"type\":\"group\"},\"35\":{\"category\":\"base\",\"name\":\"cfg-35\",\"title\":\"\\u6d88\\u9664\\u9ed1\\u6846\",\"desc\":\"\\u6d88\\u9664\\u9ed1\\u6846\",\"type\":\"bool\",\"cur\":true,\"default\":true,\"size\":4},\"36\":{\"category\":\"base\",\"name\":\"cfg-36\",\"title\":\"\\u6df1\\u8272\\u6837\\u5f20\",\"desc\":\"\\u6df1\\u8272\\u6837\\u5f20\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_and\":[\"23!=\\u5bf9\\u6298\",\"35!=true\",\"17!=\\u5339\\u914d\\u539f\\u59cb\\u5c3a\\u5bf8\",\"17!=\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\",\"17!=\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\\u81ea\\u52a8\\u88c1\\u5207\",\"28!=true\"]},\"37\":{\"category\":\"advanced\",\"name\":\"cfg-37\",\"title\":\"\\u9608\\u503c\",\"desc\":\"\\u9608\\u503c\",\"type\":\"int\",\"cur\":40,\"default\":40,\"size\":4,\"range\":{\"min\":30,\"max\":50},\"depend_or\":[\"35==true\",\"17==\\u5339\\u914d\\u539f\\u59cb\\u5c3a\\u5bf8\",\"17==\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\",\"17==\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\\u81ea\\u52a8\\u88c1\\u5207\",\"28==true\"]},\"38\":{\"category\":\"advanced\",\"name\":\"cfg-38\",\"title\":\"\\u80cc\\u666f\\u6297\\u566a\\u7b49\\u7ea7\",\"desc\":\"\\u80cc\\u666f\\u6297\\u566a\\u7b49\\u7ea7\",\"type\":\"int\",\"cur\":8,\"default\":8,\"size\":4,\"range\":{\"min\":1,\"max\":20},\"depend_or\":[\"35==true\",\"17==\\u5339\\u914d\\u539f\\u59cb\\u5c3a\\u5bf8\",\"17==\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\",\"17==\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\\u81ea\\u52a8\\u88c1\\u5207\",\"28==true\"]},\"39\":{\"category\":\"advanced\",\"name\":\"cfg-39\",\"title\":\"\\u8fb9\\u7f18\\u7f29\\u8fdb\",\"desc\":\"\\u8fb9\\u7f18\\u7f29\\u8fdb\",\"type\":\"int\",\"cur\":5,\"default\":5,\"size\":4,\"range\":{\"min\":5,\"max\":30},\"depend_or\":[\"35==true\",\"17==\\u5339\\u914d\\u539f\\u59cb\\u5c3a\\u5bf8\",\"17==\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\\u81ea\\u52a8\\u88c1\\u5207\",\"28==true\",\"17==\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\"]},\"40\":{\"category\":\"advanced\",\"name\":\"cfg-40\",\"title\":\"\\u80cc\\u666f\\u586b\\u5145\\u65b9\\u5f0f\",\"desc\":\"\\u80cc\\u666f\\u586b\\u5145\\u65b9\\u5f0f\",\"type\":\"string\",\"cur\":\"\\u51f8\\u591a\\u8fb9\\u5f62\",\"default\":\"\\u51f8\\u591a\\u8fb9\\u5f62\",\"size\":40,\"range\":[\"\\u51f8\\u591a\\u8fb9\\u5f62\",\"\\u51f9\\u591a\\u8fb9\\u5f62\"],\"depend_or\":[\"35==true\"]},\"41\":{\"category\":\"base\",\"name\":\"cfg-41\",\"title\":\"\\u9632\\u6b62\\u6e17\\u900f\",\"desc\":\"\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4},\"42\":{\"category\":\"base\",\"name\":\"cfg-42\",\"title\":\" \\u9632\\u6b62\\u6e17\\u900f\\u7b49\\u7ea7\",\"desc\":\"\",\"type\":\"string\",\"cur\":\"\\u8f83\\u5f31\",\"default\":\"\\u8f83\\u5f31\",\"size\":16,\"range\":[\"\\u8f83\\u5f31\",\"\\u5f31\",\"\\u4e00\\u822c\",\"\\u5f3a\",\"\\u8f83\\u5f3a\"],\"depend_or\":[\"41==true\"]},\"43\":{\"category\":\"base\",\"name\":\"cfg-43\",\"title\":\"\\u7a7f\\u5b54\\u79fb\\u9664\",\"desc\":\"\\u79fb\\u9664\\u7eb8\\u5f20\\u4e2d\\u7684\\u7a7f\\u5b54\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4},\"44\":{\"category\":\"base\",\"name\":\"cfg-44\",\"title\":\" \\u7a7f\\u5b54\\u641c\\u7d22\\u8303\\u56f4\\u5360\\u5e45\\u9762\\u6bd4\\u4f8b\",\"desc\":\"\\u7a7f\\u5b54\\u641c\\u7d22\\u8303\\u56f4\\u5360\\u5e45\\u9762\\u6bd4\\u4f8b\",\"type\":\"float\",\"cur\":0.100000,\"default\":0.100000,\"size\":4,\"range\":{\"min\":0.010000,\"max\":0.500000},\"depend_or\":[\"43==true\"]},\"45\":{\"category\":\"base\",\"name\":\"grp-4\",\"title\":\"\\u9001\\u7eb8\\u65b9\\u5f0f\\u8bbe\\u7f6e\",\"type\":\"group\"},\"46\":{\"category\":\"base\",\"name\":\"cfg-46\",\"title\":\"\\u8d85\\u58f0\\u6ce2\\u68c0\\u6d4b\",\"desc\":\"\\u8d85\\u58f0\\u6ce2\\u68c0\\u6d4b\\u9001\\u7eb8\\u72b6\\u6001\",\"type\":\"bool\",\"cur\":true,\"default\":true,\"size\":4},\"47\":{\"category\":\"base\",\"name\":\"cfg-47\",\"title\":\"\\u626b\\u63cf\\u5f20\\u6570\",\"desc\":\"\\u626b\\u63cf\\u7eb8\\u5f20\\u6570\\u91cf\",\"type\":\"string\",\"cur\":\"\\u8fde\\u7eed\\u626b\\u63cf\",\"default\":\"\\u8fde\\u7eed\\u626b\\u63cf\",\"size\":32,\"range\":[\"\\u8fde\\u7eed\\u626b\\u63cf\",\"\\u626b\\u63cf\\u6307\\u5b9a\\u5f20\\u6570\"]},\"48\":{\"category\":\"base\",\"name\":\"cfg-48\",\"title\":\" \\u626b\\u63cf\\u6570\\u91cf\",\"desc\":\"\\u626b\\u63cf\\u6307\\u5b9a\\u6570\\u91cf\",\"type\":\"int\",\"cur\":1,\"default\":1,\"size\":4,\"depend_or\":[\"47==\\u626b\\u63cf\\u6307\\u5b9a\\u5f20\\u6570\"]},\"49\":{\"category\":\"base\",\"name\":\"cfg-49\",\"title\":\"\\u6587\\u7a3f\\u65b9\\u5411\",\"desc\":\"\\u6587\\u7a3f\\u65b9\\u5411\",\"type\":\"string\",\"cur\":\"0\\u00b0\",\"default\":\"0\\u00b0\",\"size\":40,\"range\":[\"0\\u00b0\",\"90\\u00b0\",\"180\\u00b0\",\"-90\\u00b0\",\"\\u81ea\\u52a8\\u6587\\u672c\\u65b9\\u5411\\u8bc6\\u522b\\u00b0\"]},\"50\":{\"category\":\"base\",\"name\":\"cfg-50\",\"title\":\"\\u80cc\\u9762\\u65cb\\u8f6c180\\u00b0\",\"desc\":\"\\u80cc\\u9762\\u626b\\u63cf\\u7684\\u56fe\\u50cf\\u65cb\\u8f6c180\\u00b0\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_and\":[\"23!=\\u5355\\u9762\",\"23!=\\u5bf9\\u6298\",\"49!=\\u81ea\\u52a8\\u6587\\u672c\\u65b9\\u5411\\u8bc6\\u522b\\u00b0\"]}}"); namespace settingsdsp_300 { - hg_err device_status_to_hg_err(int usbdata) + scanner_err device_status_to_hg_err(int usbdata) { - hg_err code = HG_ERR_NO_DATA; + scanner_err code = SCANNER_ERR_NO_DATA; switch (usbdata) { case HAVE_IMAGE: - code = HG_ERR_OK; + code = SCANNER_ERR_OK; break; case STOP_SCAN: - code = HG_ERR_DEVICE_STOPPED; + code = SCANNER_ERR_DEVICE_STOPPED; break; case COUNT_MODE: - code = HG_ERR_DEVICE_COUNT_MODE; + code = SCANNER_ERR_DEVICE_COUNT_MODE; break; case NO_FEED: - code = HG_ERR_DEVICE_NO_PAPER; + code = SCANNER_ERR_DEVICE_NO_PAPER; break; case OPEN_COVER: - code = HG_ERR_DEVICE_COVER_OPENNED; + code = SCANNER_ERR_DEVICE_COVER_OPENNED; break; case FEED_IN_ERROR: - code = HG_ERR_DEVICE_FEEDING_PAPER; + code = SCANNER_ERR_DEVICE_FEEDING_PAPER; break; case PAPER_JAM: - code = HG_ERR_DEVICE_PAPER_JAMMED; + code = SCANNER_ERR_DEVICE_PAPER_JAMMED; break; case DETECT_DOUBLE_FEED: - code = HG_ERR_DEVICE_DOUBLE_FEEDING; + code = SCANNER_ERR_DEVICE_DOUBLE_FEEDING; break; case DETECT_STAPLE: - code = HG_ERR_DEVICE_STAPLE_ON; + code = SCANNER_ERR_DEVICE_STAPLE_ON; break; case PAPER_SKEW: - code = HG_ERR_DEVICE_PAPER_SKEW; + code = SCANNER_ERR_DEVICE_PAPER_SKEW; break; case HARDWARE_ERROR: - code = HG_ERR_DEVICE_NOT_SUPPORT; + code = SCANNER_ERR_DEVICE_NOT_SUPPORT; break; case PC_SCAN_BUSY_or_ERROR: - code = HG_ERR_DEVICE_PC_BUSY; + code = SCANNER_ERR_DEVICE_PC_BUSY; break; case SIZE_ERROR: - code = HG_ERR_DEVICE_SIZE_CHECK; + code = SCANNER_ERR_DEVICE_SIZE_CHECK; break; default: - code = HG_ERR_NO_DATA; + code = SCANNER_ERR_NO_DATA; break; } @@ -105,7 +105,7 @@ namespace settingsdsp_300 *r = true; else *r = false; - HG_VLOG_MINI_3(HG_LOG_LEVEL_DEBUG_INFO, "Paper '%s' index = %d, device value = %d\n", paper_string(paper).c_str(), ind, paper_map[ind].dev_value); + HG_VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "Paper '%s' index = %d, device value = %d\n", paper_string(paper).c_str(), ind, paper_map[ind].dev_value); paper = paper_map[ind].paper; if (type) *type = paper_map[ind].type; @@ -266,12 +266,12 @@ void hg_scanner_300::init_setting_map(int* setting_map, int count) int hg_scanner_300::on_scanner_closing(bool force) { - return HG_ERR_OK; + return SCANNER_ERR_OK; } void hg_scanner_300::thread_handle_usb_read(void) { - int ret = HG_ERR_OK, - status = HG_ERR_OK; + int ret = SCANNER_ERR_OK, + status = SCANNER_ERR_OK; StopWatch sw; savestatus_.clear(); @@ -286,7 +286,7 @@ void hg_scanner_300::thread_handle_usb_read(void) ////如果设备出现卡纸 或者双张等设备信息问题，需要等到设备进行发送stop才能停止。 所以始终以 "停止" 消息为结束信号 ////如果有图的情况下，并且卡纸或双张等，设备会先发送卡纸双张信息。所以接受到错误信息之后，仍需要把图像取出来。 - if (ret == HG_ERR_DEVICE_STOPPED) + if (ret == SCANNER_ERR_DEVICE_STOPPED) { if (!savestatus_.empty()) { @@ -294,12 +294,12 @@ void hg_scanner_300::thread_handle_usb_read(void) } else { - status_ = HG_ERR_OK; + status_ = SCANNER_ERR_OK; } savestatus_.clear(); break; } - if (ret != HG_ERR_OK && ret != HG_ERR_DEVICE_STOPPED && ret != HG_ERR_NO_DATA) + if (ret != SCANNER_ERR_OK && ret != SCANNER_ERR_DEVICE_STOPPED && ret != SCANNER_ERR_NO_DATA) { savestatus_.push_back(ret); } @@ -312,14 +312,14 @@ void hg_scanner_300::thread_handle_usb_read(void) } else { - status_ = HG_ERR_TIMEOUT; + status_ = SCANNER_ERR_TIMEOUT; } savestatus_.clear(); - hg_log::log(HG_LOG_LEVEL_WARNING, "get status timeout,get image out\n"); + hg_log::log(LOG_LEVEL_WARNING, "get status timeout,get image out\n"); break; } - if (ret == HG_ERR_OK && usb.u32_Count > 0) + if (ret == SCANNER_ERR_OK && usb.u32_Count > 0) { int totalNum = usb.u32_Count; std::shared_ptr> imagedata(new std::vector (totalNum)); @@ -327,11 +327,11 @@ void hg_scanner_300::thread_handle_usb_read(void) ret = get_img_data(imagedata); io_->set_timeout(200); - if (ret == HG_ERR_OK) + if (ret == SCANNER_ERR_OK) { ret = pop_image(); sw.reset(); - if (ret != HG_ERR_OK) + if (ret != SCANNER_ERR_OK) { status_ = ret; break; @@ -349,12 +349,12 @@ void hg_scanner_300::thread_handle_usb_read(void) int hg_scanner_300::start(void) { - int ret = HG_ERR_OK, + int ret = SCANNER_ERR_OK, count = -1; user_cancel_ = false; ret = writedown_device_configuration(true); - if (ret == HG_ERR_OK) + if (ret == SCANNER_ERR_OK) writedown_image_configuration(); else { @@ -364,30 +364,30 @@ void hg_scanner_300::thread_handle_usb_read(void) printf_devconfig(); ret = get_scan_is_sleep(); - if (ret == HG_ERR_DEVICE_SLEEPING) + if (ret == SCANNER_ERR_DEVICE_SLEEPING) { status_ = ret; - notify_ui_working_status(STATU_DESC_HG_ERR_DEVICE_SLEEPING, SANE_EVENT_ERROR, status_); - HG_VLOG_MINI_1(HG_LOG_LEVEL_WARNING, "device start status is(%s)\n", STATU_DESC_HG_ERR_DEVICE_SLEEPING); + notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING, SANE_EVENT_ERROR, status_); + HG_VLOG_MINI_1(LOG_LEVEL_WARNING, "device start status is(%s)\n", STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING); return ret; } ret = get_scanner_paperon(); - if (ret == HG_ERR_DEVICE_NO_PAPER) + if (ret == SCANNER_ERR_DEVICE_NO_PAPER) { status_ = ret; - notify_ui_working_status(STATU_DESC_HG_ERR_DEVICE_NO_PAPER, SANE_EVENT_ERROR, status_); - HG_VLOG_MINI_1(HG_LOG_LEVEL_WARNING, "device start status is(%s)\n", STATU_DESC_HG_ERR_DEVICE_NO_PAPER); + notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER, SANE_EVENT_ERROR, status_); + HG_VLOG_MINI_1(LOG_LEVEL_WARNING, "device start status is(%s)\n", STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER); return ret; } USBCB usb = {START_COMMAND, img_conf_.scannum, 0}; ret = writeusb(usb); io_->set_timeout(500); - HG_VLOG_MINI_1(HG_LOG_LEVEL_WARNING, "device start is.(%s)\n", hg_scanner::strerr((hg_err)ret).c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_WARNING, "device start is.(%s)\n", hg_scanner::strerr((scanner_err)ret).c_str()); - if(ret == HG_ERR_OK) + if(ret == SCANNER_ERR_OK) { - status_ = HG_ERR_DEVICE_BUSY; + status_ = SCANNER_ERR_DEVICE_BUSY; wait_usb_.notify(); std::this_thread::sleep_for(std::chrono::milliseconds(300)); } @@ -398,20 +398,20 @@ void hg_scanner_300::thread_handle_usb_read(void) } int hg_scanner_300::stop(void) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; USBCB usbcb = {STOP, 0, 0}; ret = writeusb(usbcb); - if (status_ == HG_ERR_DEVICE_BUSY) + if (status_ == SCANNER_ERR_DEVICE_BUSY) { - HG_LOG(HG_LOG_LEVEL_DEBUG_INFO,"stop status is busy\r\n"); + HG_LOG(LOG_LEVEL_DEBUG_INFO,"stop status is busy\r\n"); std::this_thread::sleep_for(std::chrono::milliseconds(2000)); } //user_cancel_ = true; - if (ret == HG_ERR_OK) + if (ret == SCANNER_ERR_OK) { - status_ = HG_ERR_DEVICE_STOPPED; + status_ = SCANNER_ERR_DEVICE_STOPPED; } return status_; @@ -420,7 +420,7 @@ int hg_scanner_300::writeusb(USBCB &usb) { std::lock_guard lock(io_lock_); - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; int len = sizeof(usb); ret = io_->write_bulk(&usb,&len); @@ -435,7 +435,7 @@ int hg_scanner_300::readusb(USBCB &usb) { std::lock_guard lock(io_lock_); - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; int len = sizeof(USBCB); ret = io_->read_bulk(&usb,&len); @@ -448,7 +448,7 @@ int hg_scanner_300::readusb(USBCB &usb) } int hg_scanner_300::pop_image() { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; USBCB usbcb = {POP_IMAGE, 0, 0}; ret = writeusb(usbcb); @@ -458,36 +458,36 @@ int hg_scanner_300::pop_image() int hg_scanner_300::get_scanner_status(USBCB &usb) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; usb = {GET_DSP_STATUS, 0, 0}; ret = writeusb(usb); - if (ret != HG_ERR_OK) + if (ret != SCANNER_ERR_OK) return ret; io_->set_timeout(200); //必要延时，且不能小于这个数值 ret = readusb(usb); - if (ret != HG_ERR_OK) + if (ret != SCANNER_ERR_OK) { status_ = ret; return ret; } - hg_err code = settingsdsp_300::device_status_to_hg_err(usb.u32_Data); + scanner_err code = settingsdsp_300::device_status_to_hg_err(usb.u32_Data); return code ; } int hg_scanner_300::get_img_data(std::shared_ptr> &imagedata) { int total = imagedata->size(), - ret = HG_ERR_OK, + ret = SCANNER_ERR_OK, index = 0, block = total; USBCB usb{GET_IMAGE, 0, total}; ret = writeusb(usb); - if (ret != HG_ERR_OK) + if (ret != SCANNER_ERR_OK) { status_ = ret; return ret; @@ -505,7 +505,7 @@ int hg_scanner_300::get_img_data(std::shared_ptr> &imagedata) ret = io_->read_bulk(imagedata->data() + index,&block); - if (ret != HG_ERR_OK) + if (ret != SCANNER_ERR_OK) { status_ = ret; return ret; @@ -513,7 +513,7 @@ int hg_scanner_300::get_img_data(std::shared_ptr> &imagedata) index += block; total -= block; } - if (ret == HG_ERR_OK) + if (ret == SCANNER_ERR_OK) { ret = save_usb_data(imagedata); } @@ -524,11 +524,11 @@ int hg_scanner_300::get_img_data(std::shared_ptr> &imagedata) void hg_scanner_300::image_process(std::shared_ptr>& buffer) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; hg_imgproc::IMGPRCPARAM param; hg_imgproc::HIMGPRC handle = NULL; hg_imgproc::IMGHEAD ih; - int err = HG_ERR_OK, + int err = SCANNER_ERR_OK, index = 0; void* buf = NULL; @@ -539,10 +539,10 @@ void hg_scanner_300::image_process(std::shared_ptr>& buffer) param.double_side = img_conf_.is_duplex; param.dpi = img_conf_.resolution_dst; - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"param.black_white :%d\r\n",param.black_white); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"param.channels :%d\r\n",param.channels); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"param.color_mode :%d\r\n",param.color_mode); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"param.double_side :%d\r\n",param.double_side); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"param.black_white :%d\r\n",param.black_white); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"param.channels :%d\r\n",param.channels); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"param.color_mode :%d\r\n",param.color_mode); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"param.double_side :%d\r\n",param.double_side); @@ -705,7 +705,7 @@ void hg_scanner_300::image_process(std::shared_ptr>& buffer) colormode=img_conf_.pixtype; err = hg_imgproc::split(handle,img_conf_.multiOutput,img_conf_.splitImage,img_conf_.multi_output_red,colormode,img_conf_.is_duplex); - HG_VLOG_MINI_5(HG_LOG_LEVEL_DEBUG_INFO, "img split-> multiOutput is:%d splitImage is:%d multi_output_red is:%d pixtype is:%d is_duplex:%d\r\n" + HG_VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "img split-> multiOutput is:%d splitImage is:%d multi_output_red is:%d pixtype is:%d is_duplex:%d\r\n" ,img_conf_.multiOutput ,img_conf_.splitImage ,img_conf_.multi_output_red @@ -729,9 +729,9 @@ void hg_scanner_300::image_process(std::shared_ptr>& buffer) hg_imgproc::ocr_auto_txtdirect(handle); } hg_imgproc::final(handle); - while (hg_imgproc::get_final_data(handle, &ih, &buf, index++) == HG_ERR_OK && !user_cancel_) + while (hg_imgproc::get_final_data(handle, &ih, &buf, index++) == SCANNER_ERR_OK && !user_cancel_) { - HG_VLOG_MINI_5(HG_LOG_LEVEL_DEBUG_INFO, "Final picture %d (%d * %d * %d) with %u bytes!\n", index + HG_VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "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()) @@ -741,13 +741,13 @@ void hg_scanner_300::image_process(std::shared_ptr>& buffer) hg_imgproc::imgtypechange(handle,img_type_,buf,bmpdata); if(bmpdata.empty()) { - status_ = HG_ERR_NO_DATA; + status_ = SCANNER_ERR_NO_DATA; return ; } buf = bmpdata.data(); ih.total_bytes = bmpdata.size(); - HG_VLOG_MINI_6(HG_LOG_LEVEL_DEBUG_INFO, "Set img type is:%s Final picture %d (%d * %d * %d) with %u bytes!\n",img_type_.c_str() ,index + HG_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 , ih.width, ih.height, ih.bits * ih.channels, ih.total_bytes); } save_final_image(&ih, buf); @@ -759,9 +759,9 @@ void hg_scanner_300::image_process(std::shared_ptr>& buffer) int hg_scanner_300::writedown_device_configuration(bool type,HGSCANCONF_G400 *d) { if (!type) - return HG_ERR_OK; + return SCANNER_ERR_OK; - int ret = HG_ERR_OK, + int ret = SCANNER_ERR_OK, len = 0; if (!d) @@ -771,14 +771,14 @@ int hg_scanner_300::writedown_device_configuration(bool type,HGSCANCONF_G400 *d) len = sizeof(USBCB); ret = io_->write_bulk(&usbcb,&len); - HG_VLOG_MINI_1(HG_LOG_LEVEL_WARNING, "writedown_device_configuration is .(%s)\n", hg_scanner::strerr((hg_err)ret).c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_WARNING, "writedown_device_configuration is .(%s)\n", hg_scanner::strerr((scanner_err)ret).c_str()); return ret; } int hg_scanner_300::on_color_mode_changed(int& color_mode) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; // if ((((color_mode == COLOR_MODE_24_BITS || color_mode == COLOR_MODE_AUTO_MATCH) && !dsp_config.params.color) || // ((color_mode != COLOR_MODE_24_BITS && color_mode != COLOR_MODE_AUTO_MATCH) && dsp_config.params.color)) && color_mode != -1) // { @@ -819,7 +819,7 @@ int hg_scanner_300::on_paper_changed(int& paper) { bool exact = true; int ind = settingsdsp_300::match_best_paper(paper, &exact, &paper_size_), - ret = exact ? HG_ERR_OK : HG_ERR_NOT_EXACT; + ret = exact ? SCANNER_ERR_OK : SCANNER_ERR_NOT_EXACT; if (dsp_config.params.pageSize != settingsdsp_300::paper_map[ind].dev_value) { @@ -840,13 +840,13 @@ int hg_scanner_300::on_paper_changed(int& paper) } } else if (!exact) - ret = HG_ERR_NOT_EXACT; + ret = SCANNER_ERR_NOT_EXACT; } return ret; } int hg_scanner_300::on_paper_check_changed(bool& check) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; if(dsp_config.params.sizedetece ^ check) { dsp_config.params.sizedetece = check; @@ -862,7 +862,7 @@ int hg_scanner_300::on_paper_check_changed(bool& check) int hg_scanner_300::on_resolution_changed(int& dpi) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; dsp_config.params.dpi = 1; ret = writedown_device_configuration(); return ret; @@ -870,7 +870,7 @@ int hg_scanner_300::on_resolution_changed(int& dpi) int hg_scanner_300::on_ultrasonic_check_changed(bool& check) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; if (dsp_config.params.doubleFeeded ^ check) { @@ -887,7 +887,7 @@ int hg_scanner_300::on_ultrasonic_check_changed(bool& check) } int hg_scanner_300::agreement(TwSS tw,int align) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; SIZE size; HGSCANCONF_G400 d = dsp_config; size = papersize.GetPaperSize(TwSS::A4,200,align); @@ -918,7 +918,7 @@ int hg_scanner_300::initdevice() writedown_device_configuration(true); printf_devconfig(); - return HG_ERR_OK; + return SCANNER_ERR_OK; } void hg_scanner_300::writedown_image_configuration(void) @@ -978,7 +978,7 @@ else ic.AutoCrop_threshold = threshold_; if (test_1_paper_) { - HG_LOG(HG_LOG_LEVEL_DEBUG_INFO, "scanning mode: testing ONE paper ...\n"); + HG_LOG(LOG_LEVEL_DEBUG_INFO, "scanning mode: testing ONE paper ...\n"); ic.scannum = 1; } else @@ -1051,7 +1051,7 @@ else img_conf_ = ic; int ret = agreement((TwSS)img_conf_.papertype,img_conf_.paperAlign); - if (ret != HG_ERR_OK) + if (ret != SCANNER_ERR_OK) { status_ = ret; return ; @@ -1059,56 +1059,56 @@ else printf ("ic.resolution_native =%f ic.resolution_dst = %f img_conf_.resolution_dst = %f \r\n",ic.resolution_native,ic.resolution_dst,img_conf_.resolution_dst); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.pixtype=%d", ic.pixtype); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.papertype=%d", ic.papertype); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.AutoCrop_threshold=%d", ic.AutoCrop_threshold); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.autodescrew=%d", ic.autodescrew); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.automaticcolor=%d", ic.automaticcolor); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.brightness=%f", ic.brightness); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.contrast=%f", ic.contrast); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.en_fold=%d", ic.en_fold); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.en_sizecheck=%d", ic.en_sizecheck); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.enhance_color=%d", ic.enhance_color); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.fillbackground=%d", ic.fillbackground); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.filter=%d", ic.filter); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.gamma=%f", ic.gamma); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.hardwarecaps.capturepixtype=%d", ic.hardwarecaps.capturepixtype); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.hardwarecaps.en_doublefeed=%d", ic.hardwarecaps.en_doublefeed); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.hsvcorrect=%d", ic.hsvcorrect); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.imageRotateDegree=%f", ic.imageRotateDegree); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.indent=%d", 5); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_autocontrast=%d", ic.is_autocontrast); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_autocrop=%d", ic.is_autocrop); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_autodiscradblank_normal=%d", ic.is_autodiscradblank_normal); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_autodiscradblank_vince=%d", ic.is_autodiscradblank_vince); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_autotext=%d", ic.is_autotext); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_backrotate180=%d", ic.is_backrotate180); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_convex=%d", ic.is_convex); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_duplex=%d", ic.is_duplex); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_switchfrontback=%d", ic.is_switchfrontback); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_dogeardetection=%d", ic.is_dogeardetection); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.multi_output_red=%d", ic.multi_output_red); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.noise=%d", 8); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.resolution_dst=%f", ic.resolution_dst); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.resolution_native=%f", ic.resolution_native); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.scannum=%d", ic.scannum); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.sharpen=%d", ic.sharpen); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.discardblank_percent=%d", ic.discardblank_percent); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.is_detachnoise=%d", ic.detachnoise.is_detachnoise); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.detachnoise=%d\r ", ic.detachnoise.detachnoise); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.refuseInflow=%d\r ", ic.refuseInflow); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.refuseInflow=%d\r ", ic.refuseInflow); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.removeMorr=%d\r ", ic.removeMorr); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.errorExtention=%d\r ", ic.errorExtention); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.textureRemove=%d\r\n ", ic.textureRemove); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.fillhole.is_fillhole=%d\r\n ", ic.fillhole.is_fillhole); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.ic.fillhole.fillholeratio=%f\r\n ", ic.fillhole.fillholeratio); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.fadeback=%d\r\n ",ic.fadeback); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.enable=%d\r\n ",ic.cropRect.enable); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.height=%d\r\n ",ic.cropRect.height); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.width=%d\r\n ",ic.cropRect.width); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.x=%d\r\n ",ic.cropRect.x); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.y=%d\r\n ",ic.cropRect.y); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.pixtype=%d", ic.pixtype); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.papertype=%d", ic.papertype); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.AutoCrop_threshold=%d", ic.AutoCrop_threshold); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.autodescrew=%d", ic.autodescrew); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.automaticcolor=%d", ic.automaticcolor); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.brightness=%f", ic.brightness); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.contrast=%f", ic.contrast); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.en_fold=%d", ic.en_fold); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.en_sizecheck=%d", ic.en_sizecheck); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.enhance_color=%d", ic.enhance_color); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.fillbackground=%d", ic.fillbackground); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.filter=%d", ic.filter); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.gamma=%f", ic.gamma); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.hardwarecaps.capturepixtype=%d", ic.hardwarecaps.capturepixtype); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.hardwarecaps.en_doublefeed=%d", ic.hardwarecaps.en_doublefeed); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.hsvcorrect=%d", ic.hsvcorrect); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.imageRotateDegree=%f", ic.imageRotateDegree); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.indent=%d", 5); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autocontrast=%d", ic.is_autocontrast); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autocrop=%d", ic.is_autocrop); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autodiscradblank_normal=%d", ic.is_autodiscradblank_normal); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autodiscradblank_vince=%d", ic.is_autodiscradblank_vince); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autotext=%d", ic.is_autotext); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_backrotate180=%d", ic.is_backrotate180); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_convex=%d", ic.is_convex); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_duplex=%d", ic.is_duplex); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_switchfrontback=%d", ic.is_switchfrontback); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_dogeardetection=%d", ic.is_dogeardetection); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.multi_output_red=%d", ic.multi_output_red); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.noise=%d", 8); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.resolution_dst=%f", ic.resolution_dst); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.resolution_native=%f", ic.resolution_native); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.scannum=%d", ic.scannum); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.sharpen=%d", ic.sharpen); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.discardblank_percent=%d", ic.discardblank_percent); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.is_detachnoise=%d", ic.detachnoise.is_detachnoise); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.detachnoise=%d\r ", ic.detachnoise.detachnoise); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.refuseInflow=%d\r ", ic.refuseInflow); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.refuseInflow=%d\r ", ic.refuseInflow); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.removeMorr=%d\r ", ic.removeMorr); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.errorExtention=%d\r ", ic.errorExtention); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.textureRemove=%d\r\n ", ic.textureRemove); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.fillhole.is_fillhole=%d\r\n ", ic.fillhole.is_fillhole); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.ic.fillhole.fillholeratio=%f\r\n ", ic.fillhole.fillholeratio); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.fadeback=%d\r\n ",ic.fadeback); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.enable=%d\r\n ",ic.cropRect.enable); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.height=%d\r\n ",ic.cropRect.height); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.width=%d\r\n ",ic.cropRect.width); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.x=%d\r\n ",ic.cropRect.x); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.y=%d\r\n ",ic.cropRect.y); } void hg_scanner_300::printf_devconfig(HGSCANCONF_G400 *d) @@ -1117,24 +1117,24 @@ void hg_scanner_300::printf_devconfig(HGSCANCONF_G400 *d) if (!d) d = &dsp_config; - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\r\ndsp_config.params.doubleFeeded:%d\r\n",d->params.doubleFeeded); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"dsp_config.params.dpi:%d\r\n",d->params.dpi); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"dsp_config.params.dstHeight:%d\r\n",d->params.dstHeight); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"dsp_config.params.enableLed:%d\r\n",d->params.enableLed); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"dsp_config.params.enableUV:%d\r\n",d->params.enableUV); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"dsp_config.params.isColor:%d\r\n",d->params.isColor); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"dsp_config.params.isCorrect:%d\r\n",d->params.isCorrect); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"dsp_config.params.pageSize:%d\r\n",d->params.pageSize); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"dsp_config.params.reversed1:%d\r\n",d->params.reversed1); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"dsp_config.params.reversed2:%d\r\n",d->params.reversed2); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"dsp_config.params.sizedetece:%d\r\n",d->params.sizedetece); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"dsp_config.params.value:%d\r\n",d->value); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\r\ndsp_config.params.doubleFeeded:%d\r\n",d->params.doubleFeeded); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params.dpi:%d\r\n",d->params.dpi); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params.dstHeight:%d\r\n",d->params.dstHeight); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params.enableLed:%d\r\n",d->params.enableLed); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params.enableUV:%d\r\n",d->params.enableUV); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params.isColor:%d\r\n",d->params.isColor); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params.isCorrect:%d\r\n",d->params.isCorrect); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params.pageSize:%d\r\n",d->params.pageSize); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params.reversed1:%d\r\n",d->params.reversed1); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params.reversed2:%d\r\n",d->params.reversed2); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params.sizedetece:%d\r\n",d->params.sizedetece); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params.value:%d\r\n",d->value); } std::string hg_scanner_300::get_firmware_version() { char buf[20] = { 0 }; - int ret = HG_ERR_OK, + int ret = SCANNER_ERR_OK, len = 10; //协议定义长度为10 100 200 =8 USBCB cmd = {GET_FW_VERSION,len,0,}; @@ -1147,7 +1147,7 @@ std::string hg_scanner_300::get_firmware_version() std::string hg_scanner_300::get_serial_num() { string SerialNum = ""; - int ret = HG_ERR_OK, + int ret = SCANNER_ERR_OK, len = 14; SerialNum.resize(len); @@ -1156,7 +1156,7 @@ std::string hg_scanner_300::get_firmware_version() std::lock_guard lock(io_lock_); ret = io_->read_bulk(&SerialNum[0],&len); - if (ret != HG_ERR_OK) + if (ret != SCANNER_ERR_OK) { return "0000000000000000000"; } @@ -1170,7 +1170,7 @@ std::string hg_scanner_300::get_firmware_version() int hg_scanner_300::set_leaflet_scan(void) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; test_1_paper_ = true; ret = start(); @@ -1179,49 +1179,49 @@ int hg_scanner_300::set_leaflet_scan(void) int hg_scanner_300::get_abuot_info(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_300::restore_default_setting(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_300::set_final_image_format(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_300::get_compression_format(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_300::set_compression_format(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_300::set_auto_color_type(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_300::get_device_code(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_300::get_sleep_time(SANE_Power* getime) { - int ret = HG_ERR_OK, + int ret = SCANNER_ERR_OK, len = 0; USBCB usbcb = {GET_SLEEP_TIME, 0, 0}; ret = writeusb(usbcb); - if (ret != HG_ERR_OK) + if (ret != SCANNER_ERR_OK) { return ret; } len = sizeof(usbcb); ret = io_->read_bulk(&usbcb,&len); printf("usbcb.u32_Data = %d\r\n",usbcb.u32_Data); - if (ret == HG_ERR_OK) + if (ret == SCANNER_ERR_OK) { if (getime) { @@ -1229,7 +1229,7 @@ int hg_scanner_300::get_sleep_time(SANE_Power* getime) } if (usbcb.u32_Data) { - return HG_ERR_DEVICE_SLEEPING; + return SCANNER_ERR_DEVICE_SLEEPING; } } return ret; @@ -1238,10 +1238,10 @@ int hg_scanner_300::set_sleep_time(SANE_Power* setime) { if (!setime) { - return HG_ERR_NO_DATA; + return SCANNER_ERR_NO_DATA; } - int ret = HG_ERR_OK, + int ret = SCANNER_ERR_OK, time = *setime; USBCB usbcb = {SET_SLEEP_TIME,time, 0}; @@ -1252,15 +1252,15 @@ int hg_scanner_300::set_sleep_time(SANE_Power* setime) int hg_scanner_300::get_dogear_distance(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_300::set_dogear_distance(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_300::get_scanner_paperon(SANE_Bool* paperon) { - int ret = HG_ERR_OK, + int ret = SCANNER_ERR_OK, len = 0; USBCB usbcb = {GET_PAPER_STATUS, 0, 0}; @@ -1268,18 +1268,18 @@ int hg_scanner_300::get_scanner_paperon(SANE_Bool* paperon) ret = writeusb(usbcb); io_->set_timeout(500); - if (ret == HG_ERR_OK) + if (ret == SCANNER_ERR_OK) { ret = io_->read_bulk(&usbcb,&len); } - if (ret != HG_ERR_OK) + if (ret != SCANNER_ERR_OK) { return ret; } if (usbcb.u32_Data == 0) - ret = HG_ERR_DEVICE_NO_PAPER; + ret = SCANNER_ERR_DEVICE_NO_PAPER; else - ret = HG_ERR_OK; + ret = SCANNER_ERR_OK; if (paperon) { *paperon = usbcb.u32_Data; @@ -1288,23 +1288,23 @@ int hg_scanner_300::get_scanner_paperon(SANE_Bool* paperon) } int hg_scanner_300::set_scan_when_paper_on(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_300::get_scan_when_paper_on(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_300::get_scan_with_hole(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_300::set_scan_with_hole(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_300::get_scan_is_sleep() { - int ret = HG_ERR_OK, + int ret = SCANNER_ERR_OK, len = 0; USBCB usbcb = {0x100, 0, 0}; @@ -1313,21 +1313,21 @@ int hg_scanner_300::get_scan_is_sleep() io_->set_timeout(200); - if (ret == HG_ERR_OK) + if (ret == SCANNER_ERR_OK) { ret = io_->read_bulk(&usbcb,&len); } - if (ret != HG_ERR_OK) + if (ret != SCANNER_ERR_OK) { return ret; } if (usbcb.u32_Data == 0x10) { - return HG_ERR_OK; + return SCANNER_ERR_OK; } else if (usbcb.u32_Data == 0x100) { - return HG_ERR_DEVICE_SLEEPING; + return SCANNER_ERR_DEVICE_SLEEPING; } } @@ -1339,20 +1339,20 @@ int hg_scanner_300::get_scan_is_sleep() ///此款设备无此功能 int hg_scanner_300::on_staple_check_changed(bool& check) { - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner_300::on_skew_check_changed(bool& check) { - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner_300::on_skew_check_level_changed(int& check) { - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner_300::agreement() { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; if (image_prc_param_.bits.rid_color != RID_COLOR_NONE) { diff --git a/hgdriver/hgdev/hg_scanner_300.h b/hgdriver/hgdev/hg_scanner_300.h index 1a07e1b..00f454c 100644 --- a/hgdriver/hgdev/hg_scanner_300.h +++ b/hgdriver/hgdev/hg_scanner_300.h @@ -13,6 +13,12 @@ #include "../../sdk/hginclude/hg_log.h" #include "PaperSize.h" +#ifdef OEM_HANWANG +#define hg_scanner_300 hw_scanner_300 +#elif defined(OEM_LISICHENG) +#define hg_scanner_300 lsc_scanner_300 +#endif + class hg_scanner_300 : public hg_scanner { diff --git a/hgdriver/hgdev/hg_scanner_400.cpp b/hgdriver/hgdev/hg_scanner_400.cpp index af82c39..f8729b6 100644 --- a/hgdriver/hgdev/hg_scanner_400.cpp +++ b/hgdriver/hgdev/hg_scanner_400.cpp @@ -9,52 +9,52 @@ static std::string jsontext("{\"device_type\":\"G400\",\"option_count\":51,\"1\":{\"category\":\"base\",\"name\":\"cfg-1\",\"title\":\"\\u6062\\u590d\\u9ed8\\u8ba4\\u8bbe\\u7f6e\",\"desc\":\"\\u6062\\u590d\\u9ed8\\u8ba4\\u8bbe\\u7f6e\",\"type\":\"button\",\"cur\":\"button\",\"default\":\"button\",\"size\":0},\"2\":{\"category\":\"advanced\",\"name\":\"cfg-2\",\"title\":\"\\u5e2e\\u52a9\",\"desc\":\"\\u663e\\u793a\\u8f6f\\u4ef6\\u5e2e\\u52a9\\u6587\\u6863\",\"type\":\"button\",\"cur\":\"true\",\"default\":\"true\",\"size\":4},\"3\":{\"category\":\"base\",\"name\":\"grp-1\",\"title\":\"\\u57fa\\u672c\\u8bbe\\u7f6e\",\"type\":\"group\"},\"4\":{\"category\":\"base\",\"name\":\"cfg-4\",\"title\":\"\\u989c\\u8272\\u6a21\\u5f0f\",\"desc\":\"\\u8bbe\\u7f6e\\u989c\\u8272\\u4f4d\\u6df1\",\"type\":\"string\",\"cur\":\"24\\u4f4d\\u5f69\\u8272\",\"default\":\"24\\u4f4d\\u5f69\\u8272\",\"size\":32,\"range\":[\"24\\u4f4d\\u5f69\\u8272\",\"256\\u7ea7\\u7070\\u5ea6\",\"\\u9ed1\\u767d\",\"\\u989c\\u8272\\u81ea\\u52a8\\u8bc6\\u522b\"]},\"5\":{\"category\":\"base\",\"name\":\"cfg-5\",\"title\":\"\\u7070\\u5ea6\\u6216\\u9ed1\\u767d\\u56fe\\u50cf - \\u9664\\u8272\",\"desc\":\"\\u9664\\u53bb\\u56fe\\u50cf\\u5f69\\u8272\",\"type\":\"string\",\"cur\":\"\\u4e0d\\u9664\\u8272\",\"default\":\"\\u4e0d\\u9664\\u8272\",\"size\":24,\"range\":[\"\\u4e0d\\u9664\\u8272\",\"\\u9664\\u7ea2\\u8272\",\"\\u9664\\u7eff\\u8272\",\"\\u9664\\u84dd\\u8272\",\"\\u7ea2\\u8272\\u589e\\u5f3a\",\"\\u7eff\\u8272\\u589e\\u5f3a\",\"\\u84dd\\u8272\\u589e\\u5f3a\"],\"depend_or\":[\"4==256\\u7ea7\\u7070\\u5ea6\",\"4==\\u9ed1\\u767d\"]},\"6\":{\"category\":\"base\",\"name\":\"cfg-6\",\"title\":\"\\u591a\\u6d41\\u8f93\\u51fa\",\"desc\":\"\",\"type\":\"string\",\"cur\":\"\\u65e0\",\"default\":\"\\u65e0\",\"size\":32,\"range\":[\"\\u65e0\",\"\\u5f69\\u8272+\\u7070\\u5ea6+\\u9ed1\\u767d\",\"\\u5f69\\u8272+\\u7070\\u5ea6\",\"\\u5f69\\u8272+\\u9ed1\\u767d\",\"\\u7070\\u5ea6+\\u9ed1\\u767d\"],\"depend_or\":[\"4==24\\u4f4d\\u5f69\\u8272\"]},\"7\":{\"category\":\"base\",\"name\":\"cfg-7\",\"title\":\"24\\u4f4d\\u5f69\\u8272\\u56fe\\u50cf - \\u591a\\u6d41\\u8f93\\u51fa\\u9664\\u7ea2\",\"desc\":\"\\u591a\\u901a\\u9053\\u8f93\\u51fa\\u4e2d\\uff0c\\u53bb\\u9664\\u7ea2\\u8272\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_or\":[\"4==24\\u4f4d\\u5f69\\u8272\"]},\"8\":{\"category\":\"base\",\"name\":\"cfg-8\",\"title\":\"24\\u4f4d\\u5f69\\u8272\\u56fe\\u50cf - \\u7b54\\u9898\\u5361\\u9664\\u7ea2\",\"desc\":\"\\u7b54\\u9898\\u5361\\u626b\\u63cf\\u4e2d\\u53bb\\u9664\\u7ea2\\u8272\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_or\":[\"4==24\\u4f4d\\u5f69\\u8272\"]},\"9\":{\"category\":\"base\",\"name\":\"cfg-9\",\"title\":\"\\u80cc\\u666f\\u79fb\\u9664\",\"desc\":\"\\u79fb\\u9664\\u5f69\\u8272\\u56fe\\u50cf\\u80cc\\u666f\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_or\":[\"4==24\\u4f4d\\u5f69\\u8272\"]},\"10\":{\"category\":\"base\",\"name\":\"cfg-10\",\"title\":\" \\u80cc\\u666f\\u8272\\u5f69\\u6d6e\\u52a8\\u8303\\u56f4\",\"desc\":\"\\u8bbe\\u5b9a\\u80cc\\u666f\\u8272\\u5f69\\u7684\\u6d6e\\u52a8\\u8303\\u56f4\\uff0c\\u5728\\u8be5\\u8303\\u56f4\\u5185\\u7684\\u90fd\\u5f53\\u4f5c\\u80cc\\u666f\\u79fb\\u9664\",\"type\":\"int\",\"cur\":20,\"default\":20,\"size\":4,\"range\":{\"min\":1,\"max\":128},\"depend_or\":[\"9==true\"]},\"11\":{\"category\":\"base\",\"name\":\"cfg-11\",\"title\":\"\\u9510\\u5316\\u4e0e\\u6a21\\u7cca\",\"desc\":\"\\u9510\\u5316\\u4e0e\\u6a21\\u7cca\",\"type\":\"string\",\"cur\":\"\\u65e0\",\"default\":\"\\u65e0\",\"size\":24,\"range\":[\"\\u65e0\",\"\\u9510\\u5316\",\"\\u8fdb\\u4e00\\u6b65\\u9510\\u5316\",\"\\u6a21\\u7cca\",\"\\u8fdb\\u4e00\\u6b65\\u6a21\\u7cca\"],\"depend_and\":[\"4!=\\u9ed1\\u767d\",\"4!=\\u989c\\u8272\\u81ea\\u52a8\\u8bc6\\u522b\"]},\"12\":{\"category\":\"base\",\"name\":\"cfg-12\",\"title\":\"\\u53bb\\u9664\\u6469\\u5c14\\u7eb9\",\"desc\":\"\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_and\":[\"4!=\\u9ed1\\u767d\",\"4!=\\u989c\\u8272\\u81ea\\u52a8\\u8bc6\\u522b\"]},\"13\":{\"category\":\"base\",\"name\":\"cfg-13\",\"title\":\"\\u9664\\u7f51\\u7eb9\",\"desc\":\"\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_and\":[\"4!=\\u9ed1\\u767d\",\"4!=\\u989c\\u8272\\u81ea\\u52a8\\u8bc6\\u522b\"]},\"14\":{\"category\":\"base\",\"name\":\"cfg-14\",\"title\":\"\\u9519\\u8bef\\u6269\\u6563\",\"desc\":\"\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_or\":[\"4==\\u9ed1\\u767d\"]},\"15\":{\"category\":\"base\",\"name\":\"cfg-15\",\"title\":\"\\u9ed1\\u767d\\u56fe\\u50cf\\u566a\\u70b9\\u4f18\\u5316\",\"desc\":\"\\u566a\\u70b9\\u4f18\\u5316\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_or\":[\"4==\\u9ed1\\u767d\"]},\"16\":{\"category\":\"base\",\"name\":\"cfg-16\",\"title\":\" \\u566a\\u70b9\\u4f18\\u5316\\u5c3a\\u5bf8\",\"desc\":\"\\u566a\\u70b9\\u4f18\\u5316\\u5c3a\\u5bf8\",\"type\":\"int\",\"cur\":30,\"default\":30,\"size\":4,\"range\":{\"min\":10,\"max\":50},\"depend_or\":[\"15==true\"]},\"17\":{\"category\":\"base\",\"name\":\"cfg-17\",\"title\":\"\\u7eb8\\u5f20\\u5c3a\\u5bf8\",\"desc\":\"\\u8bbe\\u7f6e\\u7eb8\\u5f20\\u5927\\u5c0f\",\"type\":\"string\",\"cur\":\"\\u5339\\u914d\\u539f\\u59cb\\u5c3a\\u5bf8\",\"default\":\"\\u5339\\u914d\\u539f\\u59cb\\u5c3a\\u5bf8\",\"size\":48,\"range\":[\"A3\",\"A4\",\"A4\\u6a2a\\u5411\",\"A5\",\"A5\\u6a2a\\u5411\",\"A6\",\"A6\\u6a2a\\u5411\",\"B4\",\"B5\",\"B5\\u6a2a\\u5411\",\"B6\",\"B6\\u6a2a\\u5411\",\"Letter\",\"Letter\\u6a2a\\u5411\",\"Double Letter\",\"LEGAL\",\"\\u5339\\u914d\\u539f\\u59cb\\u5c3a\\u5bf8\",\"\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\\u81ea\\u52a8\\u88c1\\u5207\",\"\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\"]},\"18\":{\"category\":\"base\",\"name\":\"cfg-18\",\"title\":\"\\u81ea\\u5b9a\\u4e49\\u626b\\u63cf\\u533a\\u57df\",\"desc\":\"\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_and\":[\"17!=\\u5339\\u914d\\u539f\\u59cb\\u5c3a\\u5bf8\",\"17!=\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\",\"17!=\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\\u81ea\\u52a8\\u88c1\\u5207\"]},\"19\":{\"category\":\"base\",\"name\":\"tl-x\",\"title\":\"\\u626b\\u63cf\\u533a\\u57df\\u5de6\\u4fa7\\uff08mm\\uff09\",\"desc\":\"\\u81ea\\u5b9a\\u4e49\\u626b\\u63cf\\u533a\\u57df\\u5de6\\u4e0a\\u89d2x\\u5750\\u6807\",\"type\":\"float\",\"cur\":0.000000,\"default\":0.000000,\"size\":4,\"range\":{\"min\":0.000000,\"max\":210.000000},\"depend_and\":[\"18==true\"]},\"20\":{\"category\":\"base\",\"name\":\"br-x\",\"title\":\"\\u626b\\u63cf\\u533a\\u57df\\u53f3\\u4fa7\\uff08mm\\uff09\",\"desc\":\"\",\"type\":\"float\",\"cur\":0.000000,\"default\":0.000000,\"size\":4,\"range\":{\"min\":0.000000,\"max\":210.000000},\"depend_and\":[\"18==true\"]},\"21\":{\"category\":\"base\",\"name\":\"tl-y\",\"title\":\"\\u626b\\u63cf\\u533a\\u57df\\u4e0a\\u4fa7\\uff08mm\\uff09\",\"desc\":\"\\u81ea\\u5b9a\\u4e49\\u626b\\u63cf\\u533a\\u57df\\u5de6\\u4e0a\\u89d2y\\u5750\\u6807\",\"type\":\"float\",\"cur\":0.000000,\"default\":0.000000,\"size\":4,\"range\":{\"min\":0.000000,\"max\":297.000000},\"depend_and\":[\"18==true\"]},\"22\":{\"category\":\"base\",\"name\":\"br-y\",\"title\":\"\\u626b\\u63cf\\u533a\\u57df\\u4e0b\\u4fa7\\uff08mm\\uff09\",\"desc\":\"\\u81ea\\u5b9a\\u4e49\\u626b\\u63cf\\u533a\\u57df\\u53f3\\u4e0b\\u89d2y\\u5750\\u6807\",\"type\":\"float\",\"cur\":297.000000,\"default\":297.000000,\"size\":4,\"range\":{\"min\":0.000000,\"max\":297.000000},\"depend_and\":[\"18==true\"]},\"23\":{\"category\":\"base\",\"name\":\"cfg-23\",\"title\":\"\\u626b\\u63cf\\u9875\\u9762\",\"desc\":\"\\u8bbe\\u7f6e\\u9875\\u9762\\u626b\\u63cf\\u65b9\\u5f0f\",\"type\":\"string\",\"cur\":\"\\u53cc\\u9762\",\"default\":\"\\u53cc\\u9762\",\"size\":50,\"range\":[\"\\u5355\\u9762\",\"\\u53cc\\u9762\",\"\\u8df3\\u8fc7\\u7a7a\\u767d\\u9875\\uff08\\u901a\\u7528\\uff09\",\"\\u8df3\\u8fc7\\u7a7a\\u767d\\u9875\\uff08\\u53d1\\u7968\\u7eb8\\uff09\",\"\\u5bf9\\u6298\"]},\"24\":{\"category\":\"base\",\"name\":\"cfg-24\",\"title\":\" \\u8df3\\u8fc7\\u7a7a\\u767d\\u9875\\u7075\\u654f\\u5ea6\",\"desc\":\"\\u7075\\u654f\\u5ea6\\u8d8a\\u9ad8\\uff0c\\u5219\\u8d8a\\u5bb9\\u6613\\u8df3\\u8fc7\",\"type\":\"int\",\"cur\":50,\"default\":50,\"size\":4,\"range\":{\"min\":1,\"max\":100},\"depend_or\":[\"23==\\u8df3\\u8fc7\\u7a7a\\u767d\\u9875\\uff08\\u53d1\\u7968\\u7eb8\\uff09\",\"23==\\u8df3\\u8fc7\\u7a7a\\u767d\\u9875\\uff08\\u901a\\u7528\\uff09\"]},\"25\":{\"category\":\"base\",\"name\":\"cfg-25\",\"title\":\"\\u5206\\u8fa8\\u7387\",\"desc\":\"\\u626b\\u63cf\\u4eea\\u5206\\u8fa8\\u7387\",\"type\":\"int\",\"cur\":200,\"default\":200,\"size\":4,\"range\":[100,150,200,240,300,600]},\"26\":{\"category\":\"base\",\"name\":\"cfg-26\",\"title\":\"\\u4ea4\\u6362\\u6b63\\u53cd\\u9762\",\"desc\":\"\\u4ea4\\u6362\\u6b63\\u53cd\\u9762\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_and\":[\"23!=\\u5355\\u9762\"]},\"27\":{\"category\":\"base\",\"name\":\"cfg-27\",\"title\":\"\\u56fe\\u50cf\\u62c6\\u5206\",\"desc\":\"\\u81ea\\u52a8\\u62c6\\u5206\\u56fe\\u50cf\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_or\":[\"23!=\\u5bf9\\u6298\"]},\"28\":{\"category\":\"base\",\"name\":\"cfg-28\",\"title\":\"\\u81ea\\u52a8\\u7ea0\\u504f\",\"desc\":\"\\u81ea\\u52a8\\u7ea0\\u504f\",\"type\":\"bool\",\"cur\":true,\"default\":true,\"size\":4,\"depend_or\":[\"23!=\\u5bf9\\u6298\"]},\"29\":{\"category\":\"base\",\"name\":\"grp-2\",\"title\":\"\\u4eae\\u5ea6\",\"type\":\"group\"},\"30\":{\"category\":\"base\",\"name\":\"cfg-30\",\"title\":\"\\u542f\\u7528\\u8272\\u8c03\\u66f2\\u7ebf\",\"desc\":\"\\u901a\\u8fc7\\u8272\\u8c03\\u66f2\\u7ebf\\u6765\\u8bbe\\u7f6e\\u56fe\\u50cf\\u4f3d\\u739b\\u503c\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4},\"31\":{\"category\":\"base\",\"name\":\"cfg-31\",\"title\":\"\\u4eae\\u5ea6\\u503c\",\"desc\":\"\\u8c03\\u6574\\u56fe\\u7247\\u4eae\\u5ea6\",\"type\":\"int\",\"cur\":128,\"default\":128,\"size\":4,\"range\":{\"min\":1,\"max\":255}},\"32\":{\"category\":\"base\",\"name\":\"cfg-32\",\"title\":\"\\u5bf9\\u6bd4\\u5ea6\",\"desc\":\"\\u8c03\\u6574\\u56fe\\u7247\\u5bf9\\u6bd4\\u5ea6\",\"type\":\"int\",\"cur\":4,\"default\":4,\"size\":4,\"range\":{\"min\":1,\"max\":7}},\"33\":{\"category\":\"base\",\"name\":\"cfg-33\",\"title\":\"\\u4f3d\\u9a6c\\u503c\",\"desc\":\"\\u8c03\\u6574\\u56fe\\u7247\\u4f3d\\u739b\\u503c\",\"type\":\"float\",\"cur\":1.000000,\"default\":1.000000,\"size\":4,\"range\":{\"min\":1.000000,\"max\":5.000000}},\"34\":{\"category\":\"base\",\"name\":\"grp-3\",\"title\":\"\\u56fe\\u50cf\\u5904\\u7406\",\"type\":\"group\"},\"35\":{\"category\":\"base\",\"name\":\"cfg-35\",\"title\":\"\\u6d88\\u9664\\u9ed1\\u6846\",\"desc\":\"\\u6d88\\u9664\\u9ed1\\u6846\",\"type\":\"bool\",\"cur\":true,\"default\":true,\"size\":4},\"36\":{\"category\":\"base\",\"name\":\"cfg-36\",\"title\":\"\\u6df1\\u8272\\u6837\\u5f20\",\"desc\":\"\\u6df1\\u8272\\u6837\\u5f20\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_and\":[\"23!=\\u5bf9\\u6298\",\"35!=true\",\"17!=\\u5339\\u914d\\u539f\\u59cb\\u5c3a\\u5bf8\",\"17!=\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\",\"17!=\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\\u81ea\\u52a8\\u88c1\\u5207\",\"28!=true\"]},\"37\":{\"category\":\"advanced\",\"name\":\"cfg-37\",\"title\":\"\\u9608\\u503c\",\"desc\":\"\\u9608\\u503c\",\"type\":\"int\",\"cur\":40,\"default\":40,\"size\":4,\"range\":{\"min\":30,\"max\":50},\"depend_or\":[\"35==true\",\"17==\\u5339\\u914d\\u539f\\u59cb\\u5c3a\\u5bf8\",\"17==\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\",\"17==\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\\u81ea\\u52a8\\u88c1\\u5207\",\"28==true\"]},\"38\":{\"category\":\"advanced\",\"name\":\"cfg-38\",\"title\":\"\\u80cc\\u666f\\u6297\\u566a\\u7b49\\u7ea7\",\"desc\":\"\\u80cc\\u666f\\u6297\\u566a\\u7b49\\u7ea7\",\"type\":\"int\",\"cur\":8,\"default\":8,\"size\":4,\"range\":{\"min\":1,\"max\":20},\"depend_or\":[\"35==true\",\"17==\\u5339\\u914d\\u539f\\u59cb\\u5c3a\\u5bf8\",\"17==\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\",\"17==\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\\u81ea\\u52a8\\u88c1\\u5207\",\"28==true\"]},\"39\":{\"category\":\"advanced\",\"name\":\"cfg-39\",\"title\":\"\\u8fb9\\u7f18\\u7f29\\u8fdb\",\"desc\":\"\\u8fb9\\u7f18\\u7f29\\u8fdb\",\"type\":\"int\",\"cur\":5,\"default\":5,\"size\":4,\"range\":{\"min\":5,\"max\":30},\"depend_or\":[\"35==true\",\"17==\\u5339\\u914d\\u539f\\u59cb\\u5c3a\\u5bf8\",\"17==\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\\u81ea\\u52a8\\u88c1\\u5207\",\"28==true\",\"17==\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\"]},\"40\":{\"category\":\"advanced\",\"name\":\"cfg-40\",\"title\":\"\\u80cc\\u666f\\u586b\\u5145\\u65b9\\u5f0f\",\"desc\":\"\\u80cc\\u666f\\u586b\\u5145\\u65b9\\u5f0f\",\"type\":\"string\",\"cur\":\"\\u51f8\\u591a\\u8fb9\\u5f62\",\"default\":\"\\u51f8\\u591a\\u8fb9\\u5f62\",\"size\":40,\"range\":[\"\\u51f8\\u591a\\u8fb9\\u5f62\",\"\\u51f9\\u591a\\u8fb9\\u5f62\"],\"depend_or\":[\"35==true\"]},\"41\":{\"category\":\"base\",\"name\":\"cfg-41\",\"title\":\"\\u9632\\u6b62\\u6e17\\u900f\",\"desc\":\"\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4},\"42\":{\"category\":\"base\",\"name\":\"cfg-42\",\"title\":\" \\u9632\\u6b62\\u6e17\\u900f\\u7b49\\u7ea7\",\"desc\":\"\",\"type\":\"string\",\"cur\":\"\\u8f83\\u5f31\",\"default\":\"\\u8f83\\u5f31\",\"size\":16,\"range\":[\"\\u8f83\\u5f31\",\"\\u5f31\",\"\\u4e00\\u822c\",\"\\u5f3a\",\"\\u8f83\\u5f3a\"],\"depend_or\":[\"41==true\"]},\"43\":{\"category\":\"base\",\"name\":\"cfg-43\",\"title\":\"\\u7a7f\\u5b54\\u79fb\\u9664\",\"desc\":\"\\u79fb\\u9664\\u7eb8\\u5f20\\u4e2d\\u7684\\u7a7f\\u5b54\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4},\"44\":{\"category\":\"base\",\"name\":\"cfg-44\",\"title\":\" \\u7a7f\\u5b54\\u641c\\u7d22\\u8303\\u56f4\\u5360\\u5e45\\u9762\\u6bd4\\u4f8b\",\"desc\":\"\\u7a7f\\u5b54\\u641c\\u7d22\\u8303\\u56f4\\u5360\\u5e45\\u9762\\u6bd4\\u4f8b\",\"type\":\"float\",\"cur\":0.100000,\"default\":0.100000,\"size\":4,\"range\":{\"min\":0.010000,\"max\":0.500000},\"depend_or\":[\"43==true\"]},\"45\":{\"category\":\"base\",\"name\":\"grp-4\",\"title\":\"\\u9001\\u7eb8\\u65b9\\u5f0f\\u8bbe\\u7f6e\",\"type\":\"group\"},\"46\":{\"category\":\"base\",\"name\":\"cfg-46\",\"title\":\"\\u8d85\\u58f0\\u6ce2\\u68c0\\u6d4b\",\"desc\":\"\\u8d85\\u58f0\\u6ce2\\u68c0\\u6d4b\\u9001\\u7eb8\\u72b6\\u6001\",\"type\":\"bool\",\"cur\":true,\"default\":true,\"size\":4},\"47\":{\"category\":\"base\",\"name\":\"cfg-47\",\"title\":\"\\u626b\\u63cf\\u5f20\\u6570\",\"desc\":\"\\u626b\\u63cf\\u7eb8\\u5f20\\u6570\\u91cf\",\"type\":\"string\",\"cur\":\"\\u8fde\\u7eed\\u626b\\u63cf\",\"default\":\"\\u8fde\\u7eed\\u626b\\u63cf\",\"size\":32,\"range\":[\"\\u8fde\\u7eed\\u626b\\u63cf\",\"\\u626b\\u63cf\\u6307\\u5b9a\\u5f20\\u6570\"]},\"48\":{\"category\":\"base\",\"name\":\"cfg-48\",\"title\":\" \\u626b\\u63cf\\u6570\\u91cf\",\"desc\":\"\\u626b\\u63cf\\u6307\\u5b9a\\u6570\\u91cf\",\"type\":\"int\",\"cur\":1,\"default\":1,\"size\":4,\"depend_or\":[\"47==\\u626b\\u63cf\\u6307\\u5b9a\\u5f20\\u6570\"]},\"49\":{\"category\":\"base\",\"name\":\"cfg-49\",\"title\":\"\\u6587\\u7a3f\\u65b9\\u5411\",\"desc\":\"\\u6587\\u7a3f\\u65b9\\u5411\",\"type\":\"string\",\"cur\":\"0\\u00b0\",\"default\":\"0\\u00b0\",\"size\":40,\"range\":[\"0\\u00b0\",\"90\\u00b0\",\"180\\u00b0\",\"-90\\u00b0\",\"\\u81ea\\u52a8\\u6587\\u672c\\u65b9\\u5411\\u8bc6\\u522b\\u00b0\"]},\"50\":{\"category\":\"base\",\"name\":\"cfg-50\",\"title\":\"\\u80cc\\u9762\\u65cb\\u8f6c180\\u00b0\",\"desc\":\"\\u80cc\\u9762\\u626b\\u63cf\\u7684\\u56fe\\u50cf\\u65cb\\u8f6c180\\u00b0\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_and\":[\"23!=\\u5355\\u9762\",\"23!=\\u5bf9\\u6298\",\"49!=\\u81ea\\u52a8\\u6587\\u672c\\u65b9\\u5411\\u8bc6\\u522b\\u00b0\"]}}"); namespace settingsdsp_400 { - hg_err device_status_to_hg_err(int usbdata) + scanner_err device_status_to_hg_err(int usbdata) { - hg_err code = HG_ERR_NO_DATA; + scanner_err code = SCANNER_ERR_NO_DATA; switch (usbdata) { case HAVE_IMAGE: - code = HG_ERR_OK; + code = SCANNER_ERR_OK; break; case STOP_SCAN: - code = HG_ERR_DEVICE_STOPPED; + code = SCANNER_ERR_DEVICE_STOPPED; break; case COUNT_MODE: - code = HG_ERR_DEVICE_COUNT_MODE; + code = SCANNER_ERR_DEVICE_COUNT_MODE; break; case NO_FEED: - code = HG_ERR_DEVICE_NO_PAPER; + code = SCANNER_ERR_DEVICE_NO_PAPER; break; case OPEN_COVER: - code = HG_ERR_DEVICE_COVER_OPENNED; + code = SCANNER_ERR_DEVICE_COVER_OPENNED; break; case FEED_IN_ERROR: - code = HG_ERR_DEVICE_FEEDING_PAPER; + code = SCANNER_ERR_DEVICE_FEEDING_PAPER; break; case PAPER_JAM: - code = HG_ERR_DEVICE_PAPER_JAMMED; + code = SCANNER_ERR_DEVICE_PAPER_JAMMED; break; case DETECT_DOUBLE_FEED: - code = HG_ERR_DEVICE_DOUBLE_FEEDING; + code = SCANNER_ERR_DEVICE_DOUBLE_FEEDING; break; case DETECT_STAPLE: - code = HG_ERR_DEVICE_STAPLE_ON; + code = SCANNER_ERR_DEVICE_STAPLE_ON; break; case PAPER_SKEW: - code = HG_ERR_DEVICE_PAPER_SKEW; + code = SCANNER_ERR_DEVICE_PAPER_SKEW; break; case HARDWARE_ERROR: - code = HG_ERR_DEVICE_NOT_SUPPORT; + code = SCANNER_ERR_DEVICE_NOT_SUPPORT; break; case PC_SCAN_BUSY_or_ERROR: - code = HG_ERR_DEVICE_PC_BUSY; + code = SCANNER_ERR_DEVICE_PC_BUSY; break; case SIZE_ERROR: - code = HG_ERR_DEVICE_SIZE_CHECK; + code = SCANNER_ERR_DEVICE_SIZE_CHECK; break; default: - code = HG_ERR_NO_DATA; + code = SCANNER_ERR_NO_DATA; break; } @@ -106,7 +106,7 @@ namespace settingsdsp_400 *r = true; else *r = false; - HG_VLOG_MINI_3(HG_LOG_LEVEL_DEBUG_INFO, "Paper '%s' index = %d, device value = %d\n", paper_string(paper).c_str(), ind, paper_map[ind].dev_value); + HG_VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "Paper '%s' index = %d, device value = %d\n", paper_string(paper).c_str(), ind, paper_map[ind].dev_value); paper = paper_map[ind].paper; if (type) *type = paper_map[ind].type; @@ -264,12 +264,12 @@ void hg_scanner_400::init_setting_map(int* setting_map, int count) int hg_scanner_400::on_scanner_closing(bool force) { - return HG_ERR_OK; + return SCANNER_ERR_OK; } void hg_scanner_400::thread_handle_usb_read(void) { - int ret = HG_ERR_OK, - status = HG_ERR_OK; + int ret = SCANNER_ERR_OK, + status = SCANNER_ERR_OK; StopWatch sw; std::vector savestatus_; @@ -284,7 +284,7 @@ void hg_scanner_400::thread_handle_usb_read(void) ////如果设备出现卡纸 或者双张等设备信息问题，需要等到设备进行发送stop才能停止。 所以始终以 "停止" 消息为结束信号 ////如果有图的情况下，并且卡纸或双张等，设备会先发送卡纸双张信息。所以接受到错误信息之后，仍需要把图像取出来。 - if (ret == HG_ERR_DEVICE_STOPPED) + if (ret == SCANNER_ERR_DEVICE_STOPPED) { if (!savestatus_.empty()) { @@ -292,12 +292,12 @@ void hg_scanner_400::thread_handle_usb_read(void) } else { - status_ = HG_ERR_OK; + status_ = SCANNER_ERR_OK; } savestatus_.clear(); break; } - if (ret != HG_ERR_OK && ret != HG_ERR_DEVICE_STOPPED && ret != HG_ERR_NO_DATA) + if (ret != SCANNER_ERR_OK && ret != SCANNER_ERR_DEVICE_STOPPED && ret != SCANNER_ERR_NO_DATA) { savestatus_.push_back(ret); } @@ -309,14 +309,14 @@ void hg_scanner_400::thread_handle_usb_read(void) } else { - status_ = HG_ERR_TIMEOUT; + status_ = SCANNER_ERR_TIMEOUT; } savestatus_.clear(); - hg_log::log(HG_LOG_LEVEL_WARNING, "get status timeout,get image out\n"); + hg_log::log(LOG_LEVEL_WARNING, "get status timeout,get image out\n"); break; } - if (ret == HG_ERR_OK && usb.u32_Count > 0) + if (ret == SCANNER_ERR_OK && usb.u32_Count > 0) { int totalNum = usb.u32_Count; std::shared_ptr> imagedata(new std::vector (totalNum)); @@ -324,11 +324,11 @@ void hg_scanner_400::thread_handle_usb_read(void) ret = get_img_data(imagedata); io_->set_timeout(200); - if (ret == HG_ERR_OK) + if (ret == SCANNER_ERR_OK) { ret = pop_image(); sw.reset(); - if (ret != HG_ERR_OK) + if (ret != SCANNER_ERR_OK) { status_ = ret; break; @@ -346,12 +346,12 @@ void hg_scanner_400::thread_handle_usb_read(void) int hg_scanner_400::start(void) { - int ret = HG_ERR_OK, + int ret = SCANNER_ERR_OK, count = -1; user_cancel_ = false; ret = writedown_device_configuration(true); - if (ret == HG_ERR_OK) + if (ret == SCANNER_ERR_OK) writedown_image_configuration(); else { @@ -361,30 +361,30 @@ int hg_scanner_400::start(void) printf_devconfig(); ret = get_scan_is_sleep(); - if (ret == HG_ERR_DEVICE_SLEEPING) + if (ret == SCANNER_ERR_DEVICE_SLEEPING) { status_ = ret; - notify_ui_working_status(STATU_DESC_HG_ERR_DEVICE_SLEEPING, SANE_EVENT_ERROR, status_); - HG_VLOG_MINI_1(HG_LOG_LEVEL_WARNING, "device start status is(%s)\n", STATU_DESC_HG_ERR_DEVICE_SLEEPING); + notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING, SANE_EVENT_ERROR, status_); + HG_VLOG_MINI_1(LOG_LEVEL_WARNING, "device start status is(%s)\n", STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING); return ret; } ret = get_scanner_paperon(); - if (ret == HG_ERR_DEVICE_NO_PAPER) + if (ret == SCANNER_ERR_DEVICE_NO_PAPER) { status_ = ret; - notify_ui_working_status(STATU_DESC_HG_ERR_DEVICE_NO_PAPER, SANE_EVENT_ERROR, status_); - HG_VLOG_MINI_1(HG_LOG_LEVEL_WARNING, "device start status is(%s)\n", STATU_DESC_HG_ERR_DEVICE_NO_PAPER); + notify_ui_working_status(STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER, SANE_EVENT_ERROR, status_); + HG_VLOG_MINI_1(LOG_LEVEL_WARNING, "device start status is(%s)\n", STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER); return ret; } USBCB usb = {START_COMMAND, img_conf_.scannum, 0}; ret = writeusb(usb); io_->set_timeout(1000); - HG_VLOG_MINI_1(HG_LOG_LEVEL_WARNING, "device start is.(%s)\n", hg_scanner::strerr((hg_err)ret).c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_WARNING, "device start is.(%s)\n", hg_scanner::strerr((scanner_err)ret).c_str()); - if(ret == HG_ERR_OK) + if(ret == SCANNER_ERR_OK) { - status_ = HG_ERR_DEVICE_BUSY; + status_ = SCANNER_ERR_DEVICE_BUSY; wait_usb_.notify(); std::this_thread::sleep_for(std::chrono::milliseconds(300)); } @@ -395,21 +395,21 @@ int hg_scanner_400::start(void) } int hg_scanner_400::stop(void) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; USBCB usbcb = {STOP, 0, 0}; ret = writeusb(usbcb); - if (status_ == HG_ERR_DEVICE_BUSY) + if (status_ == SCANNER_ERR_DEVICE_BUSY) { - HG_VLOG_MINI_1(HG_LOG_LEVEL_WARNING, "stop !but device is busy ,so sleep 2s(%s)\n", hg_scanner::strerr((hg_err)status_).c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_WARNING, "stop !but device is busy ,so sleep 2s(%s)\n", hg_scanner::strerr((scanner_err)status_).c_str()); std::this_thread::sleep_for(std::chrono::milliseconds(2000)); } //user_cancel_ = true; - if (ret == HG_ERR_OK) + if (ret == SCANNER_ERR_OK) { - status_ = HG_ERR_DEVICE_STOPPED; - HG_VLOG_MINI_1(HG_LOG_LEVEL_WARNING, "stop device:(%s)\n", hg_scanner::strerr((hg_err)status_).c_str()); + status_ = SCANNER_ERR_DEVICE_STOPPED; + HG_VLOG_MINI_1(LOG_LEVEL_WARNING, "stop device:(%s)\n", hg_scanner::strerr((scanner_err)status_).c_str()); } notify_ui_working_status("取消扫描", SANE_EVENT_STATUS, status_); @@ -419,7 +419,7 @@ int hg_scanner_400::writeusb(USBCB &usb) { std::lock_guard lock(io_lock_); - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; int len = sizeof(usb); ret = io_->write_bulk(&usb,&len); @@ -434,7 +434,7 @@ int hg_scanner_400::readusb(USBCB &usb) { std::lock_guard lock(io_lock_); - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; int len = sizeof(USBCB); ret = io_->read_bulk(&usb,&len); @@ -447,7 +447,7 @@ int hg_scanner_400::readusb(USBCB &usb) } int hg_scanner_400::pop_image() { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; USBCB usbcb = {POP_IMAGE, 0, 0}; ret = writeusb(usbcb); @@ -457,35 +457,35 @@ int hg_scanner_400::pop_image() int hg_scanner_400::get_scanner_status(USBCB &usb) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; usb = {GET_DSP_STATUS, 0, 0}; ret = writeusb(usb); - if (ret != HG_ERR_OK) + if (ret != SCANNER_ERR_OK) return ret; io_->set_timeout(500); ret = readusb(usb); - if (ret != HG_ERR_OK) + if (ret != SCANNER_ERR_OK) { status_ = ret; return ret; } - hg_err code = settingsdsp_400::device_status_to_hg_err(usb.u32_Data); + scanner_err code = settingsdsp_400::device_status_to_hg_err(usb.u32_Data); return code ; } int hg_scanner_400::get_img_data(std::shared_ptr> &imagedata) { int total = imagedata->size(), - ret = HG_ERR_OK, + ret = SCANNER_ERR_OK, index = 0, block = total; USBCB usb{GET_IMAGE, 0, total}; ret = writeusb(usb); - if (ret != HG_ERR_OK) + if (ret != SCANNER_ERR_OK) { status_ = ret; return ret; @@ -503,7 +503,7 @@ int hg_scanner_400::get_img_data(std::shared_ptr> &imagedata) ret = io_->read_bulk(imagedata->data() + index,&block); - if (ret != HG_ERR_OK) + if (ret != SCANNER_ERR_OK) { status_ = ret; return ret; @@ -511,7 +511,7 @@ int hg_scanner_400::get_img_data(std::shared_ptr> &imagedata) index += block; total -= block; } - if (ret == HG_ERR_OK) + if (ret == SCANNER_ERR_OK) { ret = save_usb_data(imagedata); } @@ -522,11 +522,11 @@ int hg_scanner_400::get_img_data(std::shared_ptr> &imagedata) void hg_scanner_400::image_process(std::shared_ptr>& buffer) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; hg_imgproc::IMGPRCPARAM param; hg_imgproc::HIMGPRC handle = NULL; hg_imgproc::IMGHEAD ih; - int err = HG_ERR_OK, + int err = SCANNER_ERR_OK, index = 0; void* buf = NULL; @@ -537,11 +537,11 @@ void hg_scanner_400::image_process(std::shared_ptr>& buffer) param.double_side = img_conf_.is_duplex; param.dpi = img_conf_.resolution_dst; - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"param.black_white :%d\r\n",param.black_white); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"param.channels :%d\r\n",param.channels); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"param.color_mode :%d\r\n",param.color_mode); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"param.double_side :%d\r\n",param.double_side); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"param.dpi :%d\r\n",param.dpi); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"param.black_white :%d\r\n",param.black_white); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"param.channels :%d\r\n",param.channels); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"param.color_mode :%d\r\n",param.color_mode); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"param.double_side :%d\r\n",param.double_side); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"param.dpi :%d\r\n",param.dpi); handle = hg_imgproc::init(&img_conf_,¶m,pid_); @@ -552,7 +552,7 @@ void hg_scanner_400::image_process(std::shared_ptr>& buffer) { ret = hg_imgproc::fillhole(handle); //printf("填穿孔开启\r\n"); - //HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "填穿孔开启:%s\n",hg_scanner::strerr((hg_err)ret).c_str()); + //HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "填穿孔开启:%s\n",hg_scanner::strerr((scanner_err)ret).c_str()); } /////////////////////////////////////111111111111111111111111111////////////////////////////////// @@ -562,32 +562,32 @@ void hg_scanner_400::image_process(std::shared_ptr>& buffer) { ret = hg_imgproc::discardBlank(handle); printf("丢弃空白页开启\r\n"); - //HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "丢弃空白页开启:%s\n",hg_scanner::strerr((hg_err)ret).c_str()); + //HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "丢弃空白页开启:%s\n",hg_scanner::strerr((scanner_err)ret).c_str()); } if(img_conf_.fadeback) { hg_imgproc::fadeback(handle,img_conf_.fadebackrange,param.double_side); //printf("背景除色开启\r\n"); - //HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "背景除色开启:%s\n",hg_scanner::strerr((hg_err)ret).c_str()); + //HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "背景除色开启:%s\n",hg_scanner::strerr((scanner_err)ret).c_str()); } if (img_conf_.resolution_dst != img_conf_.resolution_native) { hg_imgproc::resolution_change(handle); //printf("dpi改变开启\r\n"); - //HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "dpi改变开启:%s\n",hg_scanner::strerr((hg_err)ret).c_str()); + //HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "dpi改变开启:%s\n",hg_scanner::strerr((scanner_err)ret).c_str()); } if (img_conf_.cropRect.enable && !img_conf_.is_autocrop) { hg_imgproc::croprect(handle); //printf("手动裁图开启\r\n"); - //HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "手动裁图开启:%s\n",hg_scanner::strerr((hg_err)ret).c_str()); + //HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "手动裁图开启:%s\n",hg_scanner::strerr((scanner_err)ret).c_str()); } if (img_conf_.filter != ColorFilter::FILTER_NONE && (img_conf_.pixtype == COLOR_MODE_BLACK_WHITE || img_conf_.pixtype == COLOR_MODE_256_GRAY)) { printf("除色开启\r\n"); hg_imgproc::channel(handle); - //HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "除色开启:%s\n",hg_scanner::strerr((hg_err)ret).c_str()); + //HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "除色开启:%s\n",hg_scanner::strerr((scanner_err)ret).c_str()); } /////////////////////////////////////2222222222222222222222222222222222222////////////////////////////////// int tableLength ;//= sizeof(custom_gamma_val_->table)/sizeof(custom_gamma_val_->table[0]); @@ -631,7 +631,7 @@ void hg_scanner_400::image_process(std::shared_ptr>& buffer) { hg_imgproc::answerSheetFilterRed(handle); //printf("答题卡出红开启\r\n"); - //HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "答题卡出红开启:%s\n",hg_scanner::strerr((hg_err)ret).c_str()); + //HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "答题卡出红开启:%s\n",hg_scanner::strerr((scanner_err)ret).c_str()); } if (img_conf_.refuseInflow) { @@ -654,7 +654,7 @@ void hg_scanner_400::image_process(std::shared_ptr>& buffer) { hg_imgproc::colorCorrection(handle); //printf("颜色校正开启\r\n"); - //HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "颜色校正开启:%s\n",hg_scanner::strerr((hg_err)ret).c_str()); + //HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "颜色校正开启:%s\n",hg_scanner::strerr((scanner_err)ret).c_str()); } if ((img_conf_.imageRotateDegree != TEXT_DIRECTION_0 || img_conf_.is_backrotate180) && (!img_conf_.is_autotext)) { @@ -665,25 +665,25 @@ void hg_scanner_400::image_process(std::shared_ptr>& buffer) { hg_imgproc::textureRemove(handle); //printf("除摩尔纹开启\r\n"); - //HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "除摩尔纹开启:%s\n",hg_scanner::strerr((hg_err)ret).c_str()); + //HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "除摩尔纹开启:%s\n",hg_scanner::strerr((scanner_err)ret).c_str()); } if (img_conf_.detachnoise.is_detachnoise) { hg_imgproc::nosieDetach(handle); //printf("噪点优化开启\r\n"); - //HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "噪点优化开启:%s\n",hg_scanner::strerr((hg_err)ret).c_str()); + //HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "噪点优化开启:%s\n",hg_scanner::strerr((scanner_err)ret).c_str()); } if (img_conf_.pixtype == COLOR_MODE_BLACK_WHITE) { hg_imgproc::errorextention(handle); //printf("黑白图处理开启\r\n"); - //HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "黑白图处理开启:%s\n",hg_scanner::strerr((hg_err)ret).c_str()); + //HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "黑白图处理开启:%s\n",hg_scanner::strerr((scanner_err)ret).c_str()); } if (img_conf_.en_fold) { hg_imgproc::fold(handle); //printf("对折开启\r\n"); - //HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "对折开启:%s\n",hg_scanner::strerr((hg_err)ret).c_str()); + //HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "对折开启:%s\n",hg_scanner::strerr((scanner_err)ret).c_str()); } /////////////////////////////////// @@ -692,7 +692,7 @@ void hg_scanner_400::image_process(std::shared_ptr>& buffer) { err = hg_imgproc::multi_out_red(handle); //printf("多流出红开启\r\n"); - //HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "多流出红开启:%s\n",hg_scanner::strerr((hg_err)ret).c_str()); + //HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "多流出红开启:%s\n",hg_scanner::strerr((scanner_err)ret).c_str()); } @@ -716,7 +716,7 @@ void hg_scanner_400::image_process(std::shared_ptr>& buffer) colormode=img_conf_.pixtype; err = hg_imgproc::split(handle,img_conf_.multiOutput,img_conf_.splitImage,img_conf_.multi_output_red,colormode,img_conf_.is_duplex); - HG_VLOG_MINI_5(HG_LOG_LEVEL_DEBUG_INFO, "img split-> multiOutput is:%d splitImage is:%d multi_output_red is:%d pixtype is:%d is_duplex:%d\r\n" + HG_VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "img split-> multiOutput is:%d splitImage is:%d multi_output_red is:%d pixtype is:%d is_duplex:%d\r\n" ,img_conf_.multiOutput ,img_conf_.splitImage ,img_conf_.multi_output_red @@ -724,7 +724,7 @@ void hg_scanner_400::image_process(std::shared_ptr>& buffer) ,img_conf_.is_duplex); - //HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "图像拆分开启:%s\n",hg_scanner::strerr((hg_err)ret).c_str()); + //HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "图像拆分开启:%s\n",hg_scanner::strerr((scanner_err)ret).c_str()); } if (!image_prc_param_.bits.split || !image_prc_param_.bits.rid_red || !image_prc_param_.bits.multi_out) @@ -732,7 +732,7 @@ void hg_scanner_400::image_process(std::shared_ptr>& buffer) if(img_conf_.automaticcolor) { ret = hg_imgproc::auto_matic_color(handle,img_conf_.automaticcolortype); - //HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "颜色自动识别模式开启:%s\n",hg_scanner::strerr((hg_err)ret).c_str()); + //HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "颜色自动识别模式开启:%s\n",hg_scanner::strerr((scanner_err)ret).c_str()); } } if (img_conf_.is_autotext) @@ -742,9 +742,9 @@ void hg_scanner_400::image_process(std::shared_ptr>& buffer) } hg_imgproc::final(handle); - while (hg_imgproc::get_final_data(handle, &ih, &buf, index++) == HG_ERR_OK) + while (hg_imgproc::get_final_data(handle, &ih, &buf, index++) == SCANNER_ERR_OK) { - HG_VLOG_MINI_5(HG_LOG_LEVEL_DEBUG_INFO, "Final picture %d (%d * %d * %d) with %u bytes!\n", index + HG_VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "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()) @@ -755,13 +755,13 @@ void hg_scanner_400::image_process(std::shared_ptr>& buffer) //cv::imencode(img_type_,*((cv::Mat*)buf),bmpdata); if(bmpdata.empty()) { - status_ = HG_ERR_NO_DATA; + status_ = SCANNER_ERR_NO_DATA; return ; } buf = bmpdata.data(); ih.total_bytes = bmpdata.size(); - HG_VLOG_MINI_6(HG_LOG_LEVEL_DEBUG_INFO, "Set img type is:%s Final picture %d (%d * %d * %d) with %u bytes!\n",img_type_.c_str() ,index + HG_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 , ih.width, ih.height, ih.bits * ih.channels, ih.total_bytes); } @@ -774,9 +774,9 @@ void hg_scanner_400::image_process(std::shared_ptr>& buffer) int hg_scanner_400::writedown_device_configuration(bool type,HGSCANCONF_G400 *d) { if (!type) - return HG_ERR_OK; + return SCANNER_ERR_OK; - int ret = HG_ERR_OK, + int ret = SCANNER_ERR_OK, len = 0; if (!d) @@ -786,14 +786,14 @@ int hg_scanner_400::writedown_device_configuration(bool type,HGSCANCONF_G400 *d) len = sizeof(USBCB); ret = io_->write_bulk(&usbcb,&len); - HG_VLOG_MINI_1(HG_LOG_LEVEL_WARNING, "writedown_device_configuration is .(%s)\n", hg_scanner::strerr((hg_err)ret).c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_WARNING, "writedown_device_configuration is .(%s)\n", hg_scanner::strerr((scanner_err)ret).c_str()); return ret; } int hg_scanner_400::on_color_mode_changed(int& color_mode) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; //printf("color_mode =%d\r\n",color_mode); // if ((((color_mode == COLOR_MODE_24_BITS || color_mode == COLOR_MODE_AUTO_MATCH) && !dsp_config.params.color) || // ((color_mode != COLOR_MODE_24_BITS && color_mode != COLOR_MODE_AUTO_MATCH) && dsp_config.params.color)) && color_mode != -1) @@ -835,7 +835,7 @@ int hg_scanner_400::on_paper_changed(int& paper) { bool exact = true; int ind = settingsdsp_400::match_best_paper(paper, &exact, &paper_size_), - ret = exact ? HG_ERR_OK : HG_ERR_NOT_EXACT; + ret = exact ? SCANNER_ERR_OK : SCANNER_ERR_NOT_EXACT; if (dsp_config.params.pageSize != settingsdsp_400::paper_map[ind].dev_value) { @@ -857,13 +857,13 @@ int hg_scanner_400::on_paper_changed(int& paper) } } else if (!exact) - ret = HG_ERR_NOT_EXACT; + ret = SCANNER_ERR_NOT_EXACT; } return ret; } int hg_scanner_400::on_paper_check_changed(bool& check) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; if(dsp_config.params.sizedetece ^ check) { dsp_config.params.sizedetece = check; @@ -879,7 +879,7 @@ int hg_scanner_400::on_paper_check_changed(bool& check) int hg_scanner_400::on_resolution_changed(int& dpi) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; dsp_config.params.dpi = 1; ret = writedown_device_configuration(); return ret; @@ -887,7 +887,7 @@ int hg_scanner_400::on_resolution_changed(int& dpi) int hg_scanner_400::on_ultrasonic_check_changed(bool& check) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; if (dsp_config.params.doubleFeeded ^ check) { @@ -904,7 +904,7 @@ int hg_scanner_400::on_ultrasonic_check_changed(bool& check) } int hg_scanner_400::agreement(TwSS tw,int align) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; SIZE size; HGSCANCONF_G400 d; d = dsp_config; @@ -935,7 +935,7 @@ int hg_scanner_400::initdevice() writedown_device_configuration(true); printf_devconfig(); - return HG_ERR_OK; + return SCANNER_ERR_OK; } @@ -995,7 +995,7 @@ void hg_scanner_400::writedown_image_configuration(void) ic.AutoCrop_threshold = threshold_; if (test_1_paper_) { - HG_LOG(HG_LOG_LEVEL_DEBUG_INFO, "scanning mode: testing ONE paper ...\n"); + HG_LOG(LOG_LEVEL_DEBUG_INFO, "scanning mode: testing ONE paper ...\n"); ic.scannum = 1; } else @@ -1066,64 +1066,64 @@ void hg_scanner_400::writedown_image_configuration(void) img_conf_ = ic; int ret = agreement((TwSS)img_conf_.papertype,img_conf_.paperAlign); - if (ret != HG_ERR_OK) + if (ret != SCANNER_ERR_OK) { status_ = ret; return ; } - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.pixtype=%d", ic.pixtype); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.papertype=%d", ic.papertype); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.AutoCrop_threshold=%d", ic.AutoCrop_threshold); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.autodescrew=%d", ic.autodescrew); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.automaticcolor=%d", ic.automaticcolor); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.brightness=%f", ic.brightness); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.contrast=%f", ic.contrast); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.en_fold=%d", ic.en_fold); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.en_sizecheck=%d", ic.en_sizecheck); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.enhance_color=%d", ic.enhance_color); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.fillbackground=%d", ic.fillbackground); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.filter=%d", ic.filter); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.gamma=%f", ic.gamma); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.hardwarecaps.capturepixtype=%d", ic.hardwarecaps.capturepixtype); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.hardwarecaps.en_doublefeed=%d", ic.hardwarecaps.en_doublefeed); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.hsvcorrect=%d", ic.hsvcorrect); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.imageRotateDegree=%f", ic.imageRotateDegree); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.indent=%d", 5); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_autocontrast=%d", ic.is_autocontrast); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_autocrop=%d", ic.is_autocrop); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_autodiscradblank_normal=%d", ic.is_autodiscradblank_normal); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_autodiscradblank_vince=%d", ic.is_autodiscradblank_vince); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_autotext=%d", ic.is_autotext); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_backrotate180=%d", ic.is_backrotate180); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_convex=%d", ic.is_convex); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_duplex=%d", ic.is_duplex); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_switchfrontback=%d", ic.is_switchfrontback); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.is_dogeardetection=%d", ic.is_dogeardetection); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.fillhole.multi_output_red=%d", ic.multi_output_red); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.noise=%d", 8); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.resolution_dst=%f", ic.resolution_dst); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.resolution_native=%f", ic.resolution_native); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.scannum=%d", ic.scannum); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.sharpen=%d", ic.sharpen); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.discardblank_percent=%d", ic.discardblank_percent); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.is_detachnoise=%d", ic.detachnoise.is_detachnoise); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.detachnoise=%d\r ", ic.detachnoise.detachnoise); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.refuseInflow=%d\r ", ic.refuseInflow); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.refuseInflow=%d\r ", ic.refuseInflow); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.removeMorr=%d\r ", ic.removeMorr); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.errorExtention=%d\r ", ic.errorExtention); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.textureRemove=%d\r\n ", ic.textureRemove); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.fillhole.is_fillhole=%d\r\n ", ic.fillhole.is_fillhole); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.ic.fillhole.fillholeratio=%f\r\n ", ic.fillhole.fillholeratio); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.fadeback=%d\r\n ",ic.fadeback); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.pixtype=%d", ic.pixtype); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.papertype=%d", ic.papertype); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.AutoCrop_threshold=%d", ic.AutoCrop_threshold); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.autodescrew=%d", ic.autodescrew); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.automaticcolor=%d", ic.automaticcolor); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.brightness=%f", ic.brightness); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.contrast=%f", ic.contrast); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.en_fold=%d", ic.en_fold); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.en_sizecheck=%d", ic.en_sizecheck); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.enhance_color=%d", ic.enhance_color); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.fillbackground=%d", ic.fillbackground); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.filter=%d", ic.filter); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.gamma=%f", ic.gamma); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.hardwarecaps.capturepixtype=%d", ic.hardwarecaps.capturepixtype); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.hardwarecaps.en_doublefeed=%d", ic.hardwarecaps.en_doublefeed); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.hsvcorrect=%d", ic.hsvcorrect); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.imageRotateDegree=%f", ic.imageRotateDegree); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.indent=%d", 5); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autocontrast=%d", ic.is_autocontrast); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autocrop=%d", ic.is_autocrop); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autodiscradblank_normal=%d", ic.is_autodiscradblank_normal); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autodiscradblank_vince=%d", ic.is_autodiscradblank_vince); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_autotext=%d", ic.is_autotext); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_backrotate180=%d", ic.is_backrotate180); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_convex=%d", ic.is_convex); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_duplex=%d", ic.is_duplex); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_switchfrontback=%d", ic.is_switchfrontback); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.is_dogeardetection=%d", ic.is_dogeardetection); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.fillhole.multi_output_red=%d", ic.multi_output_red); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.noise=%d", 8); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.resolution_dst=%f", ic.resolution_dst); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.resolution_native=%f", ic.resolution_native); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.scannum=%d", ic.scannum); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.sharpen=%d", ic.sharpen); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.discardblank_percent=%d", ic.discardblank_percent); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.is_detachnoise=%d", ic.detachnoise.is_detachnoise); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.detachnoise=%d\r ", ic.detachnoise.detachnoise); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.detachnoise.refuseInflow=%d\r ", ic.refuseInflow); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.refuseInflow=%d\r ", ic.refuseInflow); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.removeMorr=%d\r ", ic.removeMorr); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.errorExtention=%d\r ", ic.errorExtention); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.textureRemove=%d\r\n ", ic.textureRemove); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.fillhole.is_fillhole=%d\r\n ", ic.fillhole.is_fillhole); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.ic.fillhole.fillholeratio=%f\r\n ", ic.fillhole.fillholeratio); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.fadeback=%d\r\n ",ic.fadeback); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.enable=%d\r ", ic.cropRect.enable); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.width=%d\r\n ", ic.cropRect.width); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.height=%d\r\n ", ic.cropRect.height); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.x=%f\r\n ", ic.cropRect.x); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.y=%d\r\n ",ic.cropRect.y); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.enable=%d\r ", ic.cropRect.enable); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.width=%d\r\n ", ic.cropRect.width); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.height=%d\r\n ", ic.cropRect.height); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.x=%f\r\n ", ic.cropRect.x); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\n ic.cropRect.y=%d\r\n ",ic.cropRect.y); } @@ -1132,29 +1132,29 @@ void hg_scanner_400::printf_devconfig(HGSCANCONF_G400 *d) if (!d) d = &dsp_config; - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"\r\ndsp_config.params.doubleFeeded:%d\r\n",d->params.doubleFeeded); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"dsp_config.params.dpi:%d\r\n",d->params.dpi); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"dsp_config.params.dstHeight:%d\r\n",d->params.dstHeight); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"dsp_config.params.enableLed:%d\r\n",d->params.enableLed); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"dsp_config.params.enableUV:%d\r\n",d->params.enableUV); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"dsp_config.params.isColor:%d\r\n",d->params.isColor); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"dsp_config.params.isCorrect:%d\r\n",d->params.isCorrect); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"dsp_config.params.pageSize:%d\r\n",d->params.pageSize); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"dsp_config.params.reversed1:%d\r\n",d->params.reversed1); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"dsp_config.params.reversed2:%d\r\n",d->params.reversed2); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"dsp_config.params.sizedetece:%d\r\n",d->params.sizedetece); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO,"dsp_config.params.value:%d\r\n",d->value); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"\r\ndsp_config.params.doubleFeeded:%d\r\n",d->params.doubleFeeded); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params.dpi:%d\r\n",d->params.dpi); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params.dstHeight:%d\r\n",d->params.dstHeight); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params.enableLed:%d\r\n",d->params.enableLed); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params.enableUV:%d\r\n",d->params.enableUV); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params.isColor:%d\r\n",d->params.isColor); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params.isCorrect:%d\r\n",d->params.isCorrect); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params.pageSize:%d\r\n",d->params.pageSize); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params.reversed1:%d\r\n",d->params.reversed1); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params.reversed2:%d\r\n",d->params.reversed2); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params.sizedetece:%d\r\n",d->params.sizedetece); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params.value:%d\r\n",d->value); } std::string hg_scanner_400::get_firmware_version() { char buf[20] = { 0 }; - int ret = HG_ERR_OK, + int ret = SCANNER_ERR_OK, len = 10; //协议定义长度为10 100 200 =10 USBCB cmd = {GET_FW_VERSION, len, 0,}; ret = writeusb(cmd); - if(ret == HG_ERR_OK) + if(ret == SCANNER_ERR_OK) ret = io_->read_bulk(buf, &len); return buf; @@ -1163,17 +1163,17 @@ std::string hg_scanner_400::get_firmware_version() std::string hg_scanner_400::get_serial_num() { char buf[20] = { 0 }; - int ret = HG_ERR_OK, + int ret = SCANNER_ERR_OK, len = 14; USBCB cmd = {GET_SERIAL, len, 0,}; ret = writeusb(cmd); - if (ret == HG_ERR_OK) + if (ret == SCANNER_ERR_OK) { std::lock_guard lock(io_lock_); ret = io_->read_bulk(buf, &len); } - HG_VLOG_MINI_2(HG_LOG_LEVEL_DEBUG_INFO, "get serial num = %s, serial num = %s\n", hg_scanner::strerr((hg_err)ret).c_str(), buf); + HG_VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "get serial num = %s, serial num = %s\n", hg_scanner::strerr((scanner_err)ret).c_str(), buf); return buf; } @@ -1182,7 +1182,7 @@ std::string hg_scanner_400::get_firmware_version() int hg_scanner_400::set_leaflet_scan(void) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; test_1_paper_ = true; ret = start(); @@ -1191,49 +1191,49 @@ int hg_scanner_400::set_leaflet_scan(void) int hg_scanner_400::get_abuot_info(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_400::restore_default_setting(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_400::set_final_image_format(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_400::get_compression_format(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_400::set_compression_format(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_400::set_auto_color_type(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_400::get_device_code(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_400::get_sleep_time(int &getsleepime) { - int ret = HG_ERR_OK, + int ret = SCANNER_ERR_OK, len = 0; USBCB usbcb = {GET_SLEEP_TIME, 0, 0}; ret = writeusb(usbcb); - if (ret != HG_ERR_OK) + if (ret != SCANNER_ERR_OK) { return ret; } len = sizeof(usbcb); ret = io_->read_bulk(&usbcb,&len); printf("usbcb.u32_Data = %d\r\n",usbcb.u32_Data); - if (ret == HG_ERR_OK) + if (ret == SCANNER_ERR_OK) { getsleepime = usbcb.u32_Data; } @@ -1242,7 +1242,7 @@ int hg_scanner_400::get_sleep_time(int &getsleepime) int hg_scanner_400::set_sleep_time(int setsleepime) { - int ret = HG_ERR_OK, + int ret = SCANNER_ERR_OK, time = setsleepime; USBCB usbcb = {SET_SLEEP_TIME,time, 0}; @@ -1253,15 +1253,15 @@ int hg_scanner_400::set_sleep_time(int setsleepime) int hg_scanner_400::get_dogear_distance(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_400::set_dogear_distance(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_400::get_scanner_paperon(SANE_Bool* paperon) { - int ret = HG_ERR_OK, + int ret = SCANNER_ERR_OK, len = 0; USBCB usbcb = {GET_PAPER_STATUS, 0, 0}; @@ -1269,18 +1269,18 @@ int hg_scanner_400::get_scanner_paperon(SANE_Bool* paperon) ret = writeusb(usbcb); io_->set_timeout(500); - if (ret == HG_ERR_OK) + if (ret == SCANNER_ERR_OK) { ret = io_->read_bulk(&usbcb,&len); } - if (ret != HG_ERR_OK) + if (ret != SCANNER_ERR_OK) { return ret; } if (usbcb.u32_Data == 0) - ret = HG_ERR_DEVICE_NO_PAPER; + ret = SCANNER_ERR_DEVICE_NO_PAPER; else - ret = HG_ERR_OK; + ret = SCANNER_ERR_OK; if (paperon) { *paperon = usbcb.u32_Data; @@ -1289,23 +1289,23 @@ int hg_scanner_400::get_scanner_paperon(SANE_Bool* paperon) } int hg_scanner_400::set_scan_when_paper_on(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_400::get_scan_when_paper_on(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_400::get_scan_with_hole(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_400::set_scan_with_hole(void) { - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int hg_scanner_400::get_scan_is_sleep() { - int ret = HG_ERR_OK, + int ret = SCANNER_ERR_OK, len = 0; USBCB usbcb = {0x100, 0, 0}; @@ -1314,21 +1314,21 @@ int hg_scanner_400::get_scan_is_sleep() io_->set_timeout(200); - if (ret == HG_ERR_OK) + if (ret == SCANNER_ERR_OK) { ret = io_->read_bulk(&usbcb,&len); } - if (ret != HG_ERR_OK) + if (ret != SCANNER_ERR_OK) { return ret; } if (usbcb.u32_Data == 0x10) { - return HG_ERR_OK; + return SCANNER_ERR_OK; } else if (usbcb.u32_Data == 0x100) { - return HG_ERR_DEVICE_SLEEPING; + return SCANNER_ERR_DEVICE_SLEEPING; } } @@ -1338,14 +1338,14 @@ int hg_scanner_400::get_scan_is_sleep() ///此款设备无此功能暂时预留 int hg_scanner_400::on_staple_check_changed(bool& check) { - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner_400::on_skew_check_changed(bool& check) { - return HG_ERR_OK; + return SCANNER_ERR_OK; } int hg_scanner_400::on_skew_check_level_changed(int& check) { - return HG_ERR_OK; + return SCANNER_ERR_OK; } /////////////////////////////////////over/////////////////////////// \ No newline at end of file diff --git a/hgdriver/hgdev/hg_scanner_400.h b/hgdriver/hgdev/hg_scanner_400.h index e4b21b5..a24b53c 100644 --- a/hgdriver/hgdev/hg_scanner_400.h +++ b/hgdriver/hgdev/hg_scanner_400.h @@ -14,6 +14,11 @@ #include "PaperSize.h" +#ifdef OEM_HANWANG +#define hg_scanner_400 hw_scanner_400 +#elif defined(OEM_LISICHENG) +#define hg_scanner_400 lsc_scanner_400 +#endif class hg_scanner_400 : public hg_scanner { diff --git a/hgdriver/hgdev/image_process.cpp b/hgdriver/hgdev/image_process.cpp index bc5778c..a2c8f84 100644 --- a/hgdriver/hgdev/image_process.cpp +++ b/hgdriver/hgdev/image_process.cpp @@ -16,16 +16,16 @@ #include "../ImageProcess/ImageApplyHeaders.h" #include "ImageMultiOutput.h" #include "PaperSize.h" -//不加上“extern "C"”会导致ARM平台链接不上库 + +#ifdef WIN32 +#include "scanner_manager.h" +#include "ocr/hanwangOCRdetect.h" +#else +#include extern "C" { #include "ocr/hanwangOCRdetect.h" } - -#ifdef WIN32 -#include "scanner_manager.h" -#else -#include #endif using namespace std; @@ -88,7 +88,7 @@ namespace hg_imgproc { buffer_.reset(new std::vector(*buff)); mats_.clear(); - return HG_ERR_OK; + return SCANNER_ERR_OK; } int load_file(const char* path_file) { @@ -96,7 +96,7 @@ namespace hg_imgproc FILE* src = fopen(path_file, "rb"); if (!src) - return HG_ERR_OPEN_FILE_FAILED; + return SCANNER_ERR_OPEN_FILE_FAILED; long len = 0; fseek(src, 0, SEEK_END); @@ -106,7 +106,7 @@ namespace hg_imgproc { fclose(src); - return HG_ERR_INSUFFICIENT_MEMORY; + return SCANNER_ERR_INSUFFICIENT_MEMORY; } raw_data_.reset(new std::string()); @@ -114,7 +114,7 @@ namespace hg_imgproc fread(&(*raw_data_)[0], 1, len, src); fclose(src); - return HG_ERR_OK; + return SCANNER_ERR_OK; } // image-processing @@ -122,7 +122,7 @@ namespace hg_imgproc int decode(int pid) { if (!buffer_) - return HG_ERR_NO_DATA; + return SCANNER_ERR_NO_DATA; size_t origin = buffer_->size(); std::vector>> buffs; @@ -164,7 +164,7 @@ namespace hg_imgproc //("/home/huagao/Desktop/1.jpg",mat); if (mat.empty()) { - HG_LOG(HG_LOG_LEVEL_FATAL, "decode image data error\n"); + HG_LOG(LOG_LEVEL_FATAL, "decode image data error\n"); continue; } if(pid == 0x100 || pid == 0x200 || pid == 0x139 || pid == 0x239) @@ -195,16 +195,16 @@ namespace hg_imgproc } catch (const std::exception& e) { - HG_LOG(HG_LOG_LEVEL_FATAL, e.what()); + HG_LOG(LOG_LEVEL_FATAL, e.what()); } } buffs.clear(); - HG_VLOG_MINI_2(HG_LOG_LEVEL_DEBUG_INFO, "Decode %u bytes to %u picture(s)\n", origin, mats_.size()); + HG_VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "Decode %u bytes to %u picture(s)\n", origin, mats_.size()); if(mats_.size() == 0) { - return HG_ERR_NO_DATA; + return SCANNER_ERR_NO_DATA; } - return HG_ERR_OK; + return SCANNER_ERR_OK; } public: int correct_text(void) @@ -214,7 +214,7 @@ namespace hg_imgproc rot.apply(mats_, img_conf_.is_duplex); - return HG_ERR_OK; + return SCANNER_ERR_OK; } @@ -235,7 +235,7 @@ namespace hg_imgproc if(!matex.mat.empty()) mats_.push_back(matex.mat); } - return HG_ERR_OK; + return SCANNER_ERR_OK; } int fadeback(int range,bool is_duplex) { @@ -256,7 +256,7 @@ namespace hg_imgproc } - return HG_ERR_OK; + return SCANNER_ERR_OK; } int multi_out(void) { @@ -307,7 +307,7 @@ namespace hg_imgproc } } - return HG_ERR_OK; + return SCANNER_ERR_OK; } int multi_out(int out_type) @@ -328,7 +328,7 @@ namespace hg_imgproc // cv::imwrite(filename,mat[j]); } } - return HG_ERR_OK; + return SCANNER_ERR_OK; } int multi_out_red() { @@ -351,11 +351,11 @@ namespace hg_imgproc // cv::imwrite(filename,mats_[i]); // printf("fadeback.size :%d ,filename is =%s\r\n",mats_.size(),filename.c_str()); } - return HG_ERR_OK; + return SCANNER_ERR_OK; } int auto_matic_color(int color_type) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; std::vector mats(mats_); mats_.clear(); for(size_t i = 0;i < mats.size();i++) @@ -373,7 +373,7 @@ namespace hg_imgproc /*pixtype 0 colcor; 1 gray; 2 bw*/ int auto_crop() { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; std::vector mats(mats_); mats_.clear(); @@ -390,7 +390,7 @@ namespace hg_imgproc } int fillhole() { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; std::vector mats(mats_); mats_.clear(); @@ -404,7 +404,7 @@ namespace hg_imgproc } int resolution_change() { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; std::vector mats(mats_); mats_.clear(); @@ -429,7 +429,7 @@ namespace hg_imgproc } int croprect() { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; std::vector mats(mats_); mats_.clear(); @@ -444,7 +444,7 @@ namespace hg_imgproc } int channel() { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; std::vector mats(mats_); mats_.clear(); @@ -460,7 +460,7 @@ namespace hg_imgproc } int customgamma(bool is_customgamma,unsigned char* table,int tableLength) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; std::vector mats(mats_); mats_.clear(); @@ -489,7 +489,7 @@ namespace hg_imgproc //防止渗�? int antiInflow(int permeate_lv) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; std::vector mats(mats_); mats_.clear(); @@ -505,7 +505,7 @@ namespace hg_imgproc //色彩校正 int colorCorrection() { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; std::vector mats(mats_); mats_.clear(); @@ -518,7 +518,7 @@ namespace hg_imgproc //图像旋转 int orentation() { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; std::vector mats(mats_); mats_.clear(); mats_.resize(mats.size()); @@ -556,10 +556,10 @@ namespace hg_imgproc #endif return ret; } - //除网�? + //除网? int textureRemove() { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; std::vector mats(mats_); mats_.clear(); @@ -573,7 +573,7 @@ namespace hg_imgproc //锐化 int sharpenType() { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; std::vector mats(mats_); mats_.clear(); @@ -589,7 +589,7 @@ namespace hg_imgproc //黑白降噪 int nosieDetach() { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; std::vector mats(mats_); mats_.clear(); @@ -605,7 +605,7 @@ namespace hg_imgproc //错误扩散 int errorextention() { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; std::vector mats(mats_); mats_.clear(); @@ -626,11 +626,11 @@ namespace hg_imgproc int discardBlank() { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; std::vector mats(mats_); mats_.clear(); - double threshold = 40; //默认�? + double threshold = 40; //默认? int edge = 150; CImageApplyDiscardBlank(threshold,edge,img_conf_.discardblank_percent); @@ -646,10 +646,10 @@ namespace hg_imgproc } return ret; } - //答题卡出�? + //答题卡出? int answerSheetFilterRed() { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; std::vector mats(mats_); mats_.clear(); @@ -664,7 +664,7 @@ namespace hg_imgproc //对折 int fold() { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; std::vector mats(mats_); mats_.clear(); @@ -678,7 +678,7 @@ namespace hg_imgproc //画质 int quality(int dpi_dst) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; std::vector mats(mats_); mats_.clear(); //mats_.resize(mats.size()); @@ -690,14 +690,14 @@ namespace hg_imgproc cv::resize(mats[i],out, cv::Size(),xy,xy); mats_.push_back(out); } - return HG_ERR_OK; + return SCANNER_ERR_OK; } int ocr_auto_txtdirect() { int pDirect = -1; - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; void *pHanld = NULL; #ifndef x86_64 //linux x86_64 暂时没有OCR三方 std::vector mats(mats_); @@ -710,7 +710,7 @@ namespace hg_imgproc ret = HWOCR_GetFileDirectImage(const_cast(mats[i].data),mats[i].cols,mats[i].rows,mats[i].channels()== 1 ? TColorType::EGray256:TColorType::EColor16M,pHanld,&pDirect); if(ret != 0) { - return HG_ERR_NO_DATA; + return SCANNER_ERR_NO_DATA; } if(pDirect == 1) @@ -748,12 +748,12 @@ namespace hg_imgproc //cv::imwrite(std::to_string(i++)+"_final.jpg",out.mat); } - return HG_ERR_OK; + return SCANNER_ERR_OK; } int get_final_data(LPIMGHEAD pimh, void** buf, int index) { if ((index < 0 || index >= mats_.size())) - return HG_ERR_NO_DATA; + return SCANNER_ERR_NO_DATA; pimh->width = mats_[index].cols; pimh->height = mats_[index].rows; @@ -765,13 +765,13 @@ namespace hg_imgproc *buf = mats_[index].data; //printf("pimh->channels = %d \r\n",pimh->channels); - return HG_ERR_OK; + return SCANNER_ERR_OK; } int get_final_data(LPIMGHEAD pimh, std::vector* buf, int index) { if ((index < 0 || index >= mats_.size())) - return HG_ERR_NO_DATA; + return SCANNER_ERR_NO_DATA; pimh->width = mats_[index].cols; pimh->height = mats_[index].rows; @@ -804,15 +804,15 @@ namespace hg_imgproc } //printf("pimh->channels_01 = %d \r\n",pimh->channels); - return HG_ERR_OK; + return SCANNER_ERR_OK; } int imgtypechange(std::string img_type_,void *buf,std::vector &bmpdata) { - int ret = HG_ERR_OK; + int ret = SCANNER_ERR_OK; if(!buf) { - return HG_ERR_NO_DATA; + return SCANNER_ERR_NO_DATA; } cv::imencode(img_type_,*((cv::Mat*)buf),bmpdata); return ret; diff --git a/hgdriver/hgdev/image_process.h b/hgdriver/hgdev/image_process.h index a385c8e..675b113 100644 --- a/hgdriver/hgdev/image_process.h +++ b/hgdriver/hgdev/image_process.h @@ -132,7 +132,7 @@ namespace hg_imgproc // // 5 - call final to got outputing data // - // 6 - call get_final_data to get outputing data, while return HG_ERR_NO_DATA + // 6 - call get_final_data to get outputing data, while return SCANNER_ERR_NO_DATA // // 7 - call release to free the HIMGPRC handle // @@ -198,12 +198,12 @@ namespace hg_imgproc // pimh must not to be NULL, and pimh->total_bytes indicates the length of 'buf' // - // if 'buf' was NULL, then return HG_ERR_INSUFFICIENT_MEMORY + // if 'buf' was NULL, then return SCANNER_ERR_INSUFFICIENT_MEMORY // // index is ZERO-base, if index is valid, fill the 'pimh' first, and copy data to buf if it was not NULL - // return HG_ERR_NO_DATA if it was out of range + // return SCANNER_ERR_NO_DATA if it was out of range // - // return HG_ERR_OK if index has valid image data and buf is large enough + // return SCANNER_ERR_OK if index has valid image data and buf is large enough int get_final_data(HIMGPRC himg, LPIMGHEAD pimh, void** buf, int index = 0); int get_final_data(HIMGPRC himg, LPIMGHEAD pimh, std::vector* buf, int index); void release(HIMGPRC himg); diff --git a/hgdriver/hgdev/scanner_manager.cpp b/hgdriver/hgdev/scanner_manager.cpp index 58e47ca..39370eb 100644 --- a/hgdriver/hgdev/scanner_manager.cpp +++ b/hgdriver/hgdev/scanner_manager.cpp @@ -23,7 +23,22 @@ static struct std::string type; // product type std::string rsc; // USB resource, version-addr. e.g. "USB2.0-1" } -g_supporting_devices[] = { {0x3072, 0x100, SCANNER_NAME_HG_G100, "GScanO200", ""} +g_supporting_devices[] = { +#ifdef OEM_LISICHENG + {0x31c9, 0x8420, SCANNER_NAME_LSC_G42S, "G426xF", ""} + , {0x31c9, 0x8520, SCANNER_NAME_LSC_G52S, "G52x0F", ""} + , {0x31c9, 0x8620, SCANNER_NAME_LSC_G62S, "G6290U", ""} + , {0x31c9, 0x8629, SCANNER_NAME_LSC_G62S, "G6290U", ""} + , {0x31c9, 0x8730, SCANNER_NAME_LSC_G73S, "G73x0U", ""} + , {0x31c9, 0x8739, SCANNER_NAME_LSC_G73S, "G73x0U", ""}, +#endif +#ifdef OEM_HANWANG + {0x2903, 0x7000, SCANNER_NAME_HW_7000, "HW-74x0WA", ""} + , {0x2903, 0x1000, SCANNER_NAME_HW_9110F, "HW-9110F", ""} + , {0x2903, 0x8000, SCANNER_NAME_HW_8190F, "HW-8190F", ""} + , {0x2903, 0x9000, SCANNER_NAME_HW_9110F, "HW-9110F", ""}, +#endif + {0x3072, 0x100, SCANNER_NAME_HG_G100, "GScanO200", ""} , {0x3072, 0x200, SCANNER_NAME_HG_G200, "GScanO200", ""} , {0x3072, 0x300, SCANNER_NAME_HG_G300, "GScanO400", ""} , {0x3072, 0x400, SCANNER_NAME_HG_G400, "GScanO400", ""} @@ -32,18 +47,6 @@ g_supporting_devices[] = { {0x3072, 0x100, SCANNER_NAME_HG_G100, "GScanO200", "" , {0x3072, 0x339, SCANNER_NAME_HG_G339, "GScanO1003399", ""} , {0x3072, 0x439, SCANNER_NAME_HG_G439, "GScanO1003399", ""} , {0x064B, 0x7823, SCANNER_NAME_HG_G200, "GScanO200", ""} - - , {0x31c9, 0x8420, SCANNER_NAME_LSC_G42S, "G426xF", ""} - , {0x31c9, 0x8520, SCANNER_NAME_LSC_G52S, "G52x0F", ""} - , {0x31c9, 0x8620, SCANNER_NAME_LSC_G62S, "G6290U", ""} - , {0x31c9, 0x8629, SCANNER_NAME_LSC_G62S, "G6290U", ""} - , {0x31c9, 0x8730, SCANNER_NAME_LSC_G73S, "G73x0U", ""} - , {0x31c9, 0x8739, SCANNER_NAME_LSC_G73S, "G73x0U", ""} - - , {0x2903, 0x7000, SCANNER_NAME_HW_7000, "HW-74x0WA", ""} - , {0x2903, 0x1000, SCANNER_NAME_HW_9110F, "HW-9110F", ""} - , {0x2903, 0x8000, SCANNER_NAME_HW_8190F, "HW-8190F", ""} - , {0x2903, 0x9000, SCANNER_NAME_HW_9110F, "HW-9110F", ""} }; static std::string g_vendor = COMPANY_NAME; @@ -77,15 +80,15 @@ int hg_scanner_mgr::ui_default_callback(scanner_handle h, int ev, void* data, un // { // struct sysinfo si; // if(sysinfo(&si) == 0) - // return si.freeram * si.mem_unit > *len + 200 * 1024 * 1024 ? HG_ERR_OK : HG_ERR_INSUFFICIENT_MEMORY; + // return si.freeram * si.mem_unit > *len + 200 * 1024 * 1024 ? SCANNER_ERR_OK : SCANNER_ERR_INSUFFICIENT_MEMORY; - // return HG_ERR_OK; + // return SCANNER_ERR_OK; // } if (hg_scanner_mgr::event_callback_) return hg_scanner_mgr::event_callback_(h, ev, data, len, param); - return HG_ERR_OK; + return SCANNER_ERR_OK; } hg_scanner_mgr* hg_scanner_mgr::instance(sane_callback cb) { @@ -95,7 +98,7 @@ hg_scanner_mgr* hg_scanner_mgr::instance(sane_callback cb) if (cb) hg_scanner_mgr::async_io_enabled_ = cb(NULL, SANE_EVENT_SUPPORT_ASYNC_IO, NULL, NULL, NULL) == 0; hg_scanner_mgr::inst_ = new hg_scanner_mgr(); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "async image transferring is %s\n", hg_scanner_mgr::async_io_enabled_ ? "enabled" : "disabled"); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "async image transferring is %s\n", hg_scanner_mgr::async_io_enabled_ ? "enabled" : "disabled"); } return hg_scanner_mgr::inst_; @@ -153,7 +156,7 @@ void hg_scanner_mgr::on_hgscanner_pnp(usb_event ev, libusb_device* device, int v { if (g_supporting_devices[i].vid == vid && g_supporting_devices[i].pid == pid) { - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "%s connected.\n", g_supporting_devices[i].name.c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "%s connected.\n", g_supporting_devices[i].name.c_str()); index = i; ev_ui = SANE_EVENT_DEVICE_ARRIVED; de.name = g_supporting_devices[i].name.c_str(); @@ -185,9 +188,9 @@ 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); - if (len == HG_ERR_OK) + if (len == SCANNER_ERR_OK) { - HG_VLOG_MINI_3(HG_LOG_LEVEL_WARNING, "[%04x:%04x]%s re-connected.\n", pid, vid, online_devices_[i].display_name.c_str()); + HG_VLOG_MINI_3(LOG_LEVEL_WARNING, "[%04x:%04x]%s re-connected.\n", pid, vid, online_devices_[i].display_name.c_str()); online_devices_[i].scanner->reset_io(io); de.openned = SANE_TRUE; } @@ -228,7 +231,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; - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "%s Dis-connected.\n", name.c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "%s Dis-connected.\n", name.c_str()); if (it->scanner) it->scanner->io_disconnected(); else @@ -277,7 +280,7 @@ void hg_scanner_mgr::set_appendix_info_for_about(SANE_About* about, char*& ptr, count++; } } -hg_err hg_scanner_mgr::get_about_info(scanner_handle h, void* data, unsigned* len) +scanner_err hg_scanner_mgr::get_about_info(scanner_handle h, void* data, unsigned* len) { hg_scanner* scanner = (hg_scanner*)h; unsigned bytes = sizeof(SANE_About) + 40; @@ -317,7 +320,7 @@ hg_err hg_scanner_mgr::get_about_info(scanner_handle h, void* data, unsigned* le { *len = bytes; - return HG_ERR_INSUFFICIENT_MEMORY; + return SCANNER_ERR_INSUFFICIENT_MEMORY; } // filling info to flat buffer ... @@ -393,20 +396,20 @@ hg_err hg_scanner_mgr::get_about_info(scanner_handle h, void* data, unsigned* le about->appendix[count].content = NULL; about->appendix[count].url = NULL; - return HG_ERR_OK; + return SCANNER_ERR_OK; } -hg_err hg_scanner_mgr::hg_scanner_enum(HGScannerInfo* scanner_list, long* count, bool local_only) +scanner_err hg_scanner_mgr::hg_scanner_enum(ScannerInfo* scanner_list, long* count, bool local_only) { std::vector devusbuf; long size = *count; - hg_err ret = HG_ERR_OK; + scanner_err ret = SCANNER_ERR_OK; get_online_devices(devusbuf); *count = devusbuf.size(); if (*count > size) { - ret = HG_ERR_INSUFFICIENT_MEMORY; + ret = SCANNER_ERR_INSUFFICIENT_MEMORY; } else { @@ -422,12 +425,12 @@ hg_err hg_scanner_mgr::hg_scanner_enum(HGScannerInfo* scanner_list, long* count, return ret; } -hg_err hg_scanner_mgr::hg_scanner_open(scanner_handle* h, const char* name, bool shared, const char* user, const char* pwd, const char* check, char* rsc) +scanner_err hg_scanner_mgr::hg_scanner_open(scanner_handle* h, const char* name, bool shared, const char* user, const char* pwd, const char* check, char* rsc) { std::vector devs; std::vector::iterator it; usb_io* io = NULL; - hg_err ret = HG_ERR_DEVICE_NOT_FOUND; + scanner_err ret = SCANNER_ERR_DEVICE_NOT_FOUND; *h = NULL; get_online_devices(devs); @@ -435,8 +438,8 @@ hg_err hg_scanner_mgr::hg_scanner_open(scanner_handle* h, const char* name, bool if (it != devs.end()) { std::string msg(""); - ret = (hg_err)usb_manager::instance()->open(it->dev, &io, &msg); - if (ret == HG_ERR_OK) + ret = (scanner_err)usb_manager::instance()->open(it->dev, &io, &msg); + if (ret == SCANNER_ERR_OK) { hg_scanner* scanner = NULL; if (g_supporting_devices[it->ind].pid == 0x100 || g_supporting_devices[it->ind].pid == 0x200) @@ -483,9 +486,9 @@ hg_err hg_scanner_mgr::hg_scanner_open(scanner_handle* h, const char* name, bool io->release(); } - return *h ? ret : HG_ERR_DEVICE_NOT_SUPPORT; + return *h ? ret : SCANNER_ERR_DEVICE_NOT_SUPPORT; } -hg_err hg_scanner_mgr::hg_scanner_close(scanner_handle h, bool force) +scanner_err hg_scanner_mgr::hg_scanner_close(scanner_handle h, bool force) { { std::lock_guard lock(mutex_dev_); @@ -502,65 +505,65 @@ hg_err hg_scanner_mgr::hg_scanner_close(scanner_handle h, bool force) SCAN_PTR(h)->close(force); delete SCAN_PTR(h); - return HG_ERR_OK; + return SCANNER_ERR_OK; } -hg_err hg_scanner_mgr::hg_scanner_get_parameter(scanner_handle h, unsigned param_no, char* data, long* len) +scanner_err hg_scanner_mgr::hg_scanner_get_parameter(scanner_handle h, unsigned param_no, char* data, long* len) { if (!len) - return HG_ERR_INVALID_PARAMETER; + return SCANNER_ERR_INVALID_PARAMETER; int l = *len, err = SCAN_PTR(h)->get_setting(param_no, data, &l); *len = l; - return (hg_err)err; + return (scanner_err)err; } -hg_err hg_scanner_mgr::hg_scanner_set_parameter(scanner_handle h, unsigned param_no, void* data, long len) +scanner_err hg_scanner_mgr::hg_scanner_set_parameter(scanner_handle h, unsigned param_no, void* data, long len) { - return (hg_err)SCAN_PTR(h)->set_setting(param_no, data, len); + return (scanner_err)SCAN_PTR(h)->set_setting(param_no, data, len); } -hg_err hg_scanner_mgr::hg_scanner_start(scanner_handle h, void* async_event, int num) +scanner_err hg_scanner_mgr::hg_scanner_start(scanner_handle h, void* async_event, int num) { - return (hg_err)SCAN_PTR(h)->start(); + return (scanner_err)SCAN_PTR(h)->start(); } -hg_err hg_scanner_mgr::hg_scanner_stop(scanner_handle h) +scanner_err hg_scanner_mgr::hg_scanner_stop(scanner_handle h) { - return (hg_err)SCAN_PTR(h)->stop(); + return (scanner_err)SCAN_PTR(h)->stop(); } -hg_err hg_scanner_mgr::hg_scanner_get_img_info(scanner_handle h, SANE_Parameters* bmi, long len) +scanner_err hg_scanner_mgr::hg_scanner_get_img_info(scanner_handle h, SANE_Parameters* bmi, long len) { - return (hg_err)SCAN_PTR(h)->get_image_info(bmi); + return (scanner_err)SCAN_PTR(h)->get_image_info(bmi); } -hg_err hg_scanner_mgr::hg_scanner_read_img_data(scanner_handle h, unsigned char* data, long* len) +scanner_err hg_scanner_mgr::hg_scanner_read_img_data(scanner_handle h, unsigned char* data, long* len) { if (!len) - return HG_ERR_INVALID_PARAMETER; + return SCANNER_ERR_INVALID_PARAMETER; int l = *len, err = SCAN_PTR(h)->read_image_data(data, &l); *len = l; - return (hg_err)err; + return (scanner_err)err; } -hg_err hg_scanner_mgr::hg_scanner_get_status(scanner_handle h, int setstutas) +scanner_err hg_scanner_mgr::hg_scanner_get_status(scanner_handle h, int setstutas) { - return (hg_err)SCAN_PTR(h)->status(); + return (scanner_err)SCAN_PTR(h)->status(); } -hg_err hg_scanner_mgr::hg_scanner_reset(scanner_handle h) +scanner_err hg_scanner_mgr::hg_scanner_reset(scanner_handle h) { - return (hg_err)SCAN_PTR(h)->reset(); + return (scanner_err)SCAN_PTR(h)->reset(); } -hg_err hg_scanner_mgr::hg_scanner_control(scanner_handle h, unsigned long code, void* data, unsigned* len) +scanner_err hg_scanner_mgr::hg_scanner_control(scanner_handle h, unsigned long code, void* data, unsigned* len) { //if (!len && code != IO_CTRL_CODE_TEST_SINGLE) - // return HG_ERR_INVALID_PARAMETER; + // return SCANNER_ERR_INVALID_PARAMETER; if (code == IO_CTRL_CODE_ABOUT_INFO) return get_about_info(h, data, len); else if (!h) - return HG_ERR_INVALID_PARAMETER; + return SCANNER_ERR_INVALID_PARAMETER; else - return (hg_err)SCAN_PTR(h)->device_io_control(code, data, len); + return (scanner_err)SCAN_PTR(h)->device_io_control(code, data, len); } diff --git a/hgdriver/hgdev/scanner_manager.h b/hgdriver/hgdev/scanner_manager.h index c680500..6b53253 100644 --- a/hgdriver/hgdev/scanner_manager.h +++ b/hgdriver/hgdev/scanner_manager.h @@ -26,6 +26,13 @@ // //////////////////////////////////////////////////////////////////////////////////////// +#ifdef OEM_HANWANG +#define hg_scanner hw_scanner +#define hg_scanner_mgr hw_scanner_mgr +#elif defined(OEM_LISICHENG) +#define hg_scanner lsc_scanner +#define hg_scanner_mgr lsc_scanner_mgr +#endif class hg_scanner; class hg_scanner_mgr @@ -69,7 +76,7 @@ class hg_scanner_mgr void get_online_devices(std::vector& devs); void set_appendix_info_for_about(SANE_About* about, char*& ptr, int& count, const char* key, const char* info, const char* url); - hg_err get_about_info(scanner_handle h, void* data, unsigned* len); + scanner_err get_about_info(scanner_handle h, void* data, unsigned* len); protected: hg_scanner_mgr(); @@ -82,17 +89,17 @@ public: static void set_version(int hh, int hl, int lh, int ll); public: - hg_err hg_scanner_enum(HGScannerInfo* scanner_list, long* count, bool local_only); - hg_err hg_scanner_open(scanner_handle* h, const char* name, bool shared, const char* user, const char* pwd, const char* check, char* rsc); - hg_err hg_scanner_close(scanner_handle h, bool force); - hg_err hg_scanner_get_parameter(scanner_handle h, unsigned param_no, char* data, long* len); - hg_err hg_scanner_set_parameter(scanner_handle h, unsigned param_no, void* data, long len); - hg_err hg_scanner_start(scanner_handle h, void* async_event, int num); - hg_err hg_scanner_stop(scanner_handle h); - hg_err hg_scanner_get_img_info(scanner_handle h, SANE_Parameters* bmi, long len); - hg_err hg_scanner_read_img_data(scanner_handle h, unsigned char* data, long* len); - hg_err hg_scanner_get_status(scanner_handle h, int setstutas); - hg_err hg_scanner_reset(scanner_handle h); - hg_err hg_scanner_control(scanner_handle h, unsigned long code, void* data, unsigned* len); + scanner_err hg_scanner_enum(ScannerInfo* scanner_list, long* count, bool local_only); + scanner_err hg_scanner_open(scanner_handle* h, const char* name, bool shared, const char* user, const char* pwd, const char* check, char* rsc); + scanner_err hg_scanner_close(scanner_handle h, bool force); + scanner_err hg_scanner_get_parameter(scanner_handle h, unsigned param_no, char* data, long* len); + scanner_err hg_scanner_set_parameter(scanner_handle h, unsigned param_no, void* data, long len); + scanner_err hg_scanner_start(scanner_handle h, void* async_event, int num); + scanner_err hg_scanner_stop(scanner_handle h); + scanner_err hg_scanner_get_img_info(scanner_handle h, SANE_Parameters* bmi, long len); + scanner_err hg_scanner_read_img_data(scanner_handle h, unsigned char* data, long* len); + scanner_err hg_scanner_get_status(scanner_handle h, int setstutas); + scanner_err hg_scanner_reset(scanner_handle h); + scanner_err hg_scanner_control(scanner_handle h, unsigned long code, void* data, unsigned* len); }; diff --git a/hgdriver/hgdev/usb_manager.cpp b/hgdriver/hgdev/usb_manager.cpp index 212ecc7..3b6820f 100644 --- a/hgdriver/hgdev/usb_manager.cpp +++ b/hgdriver/hgdev/usb_manager.cpp @@ -27,15 +27,15 @@ uint8_t usb_manager::uninit_uint8 = 0x0ff; usb_manager::usb_manager() : run_(true) , usb_cb_handle_(NULL) , usb_cb_(&usb_manager::usb_event_handle), usb_cb_param_(NULL) - , context_(NULL), status_(HG_ERR_OK) + , context_(NULL), status_(SCANNER_ERR_OK) , born_(std::chrono::system_clock::now()) { int ret = libusb_init(&context_); // libusb_set_log_cb(context_, &usb_manager::usb_log_callback, LIBUSB_LOG_CB_CONTEXT); // LIBUSB_API_VERSION >= 0x01000107 - HG_VLOG_MINI_4(HG_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()); + HG_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()); if (ret) - status_ = HG_ERR_USB_INIT_FAILED; + status_ = SCANNER_ERR_USB_INIT_FAILED; wait_pnp_.set_debug_info("Waiting PNP"); if (!usb_notify_thread_.get()) @@ -66,7 +66,7 @@ usb_manager::~usb_manager() usb_notify_thread_.reset(); } libusb_exit(context_); - HG_VLOG_MINI_2(HG_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()); + HG_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()); } int LIBUSB_CALL usb_manager::usb_pnp_callback(libusb_context* ctx, libusb_device* device, libusb_hotplug_event event, void* monitor) @@ -89,11 +89,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) { - HG_LOG(HG_LOG_LEVEL_DEBUG_INFO, str); + HG_LOG(LOG_LEVEL_DEBUG_INFO, str); } else { - HG_LOG(HG_LOG_LEVEL_FATAL, str); + HG_LOG(LOG_LEVEL_FATAL, str); } } @@ -114,12 +114,12 @@ int usb_manager::register_usb_pnp(void) if (ret != LIBUSB_SUCCESS) { - HG_LOG(HG_LOG_LEVEL_FATAL, (std::string("regist usbhotplug callback error msg: ") + libusb_error_name(ret) + "\n").c_str()); + HG_LOG(LOG_LEVEL_FATAL, (std::string("regist usbhotplug callback error msg: ") + libusb_error_name(ret) + "\n").c_str()); usb_cb_handle_ = NULL; - status_ = HG_ERR_USB_REGISTER_PNP_FAILED; + status_ = SCANNER_ERR_USB_REGISTER_PNP_FAILED; } else - status_ = HG_ERR_OK; + status_ = SCANNER_ERR_OK; return ret; } @@ -230,7 +230,7 @@ void usb_manager::notify_usb_event(PNPDEV& pd, bool* retry) sprintf(buf, "0x%x", pd.event); evstr = buf; } - HG_VLOG_MINI_5(HG_LOG_LEVEL_DEBUG_INFO, "USB%u.%x of pid:vid(%x:%x) event(%s) received.\n" + HG_VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "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) { @@ -265,7 +265,7 @@ void usb_manager::thread_trigger_usb_event() { // ^_^ devices.clear(); - HG_LOG(HG_LOG_LEVEL_DEBUG_INFO, "register_usb_pnp success ^_^\n"); + HG_LOG(LOG_LEVEL_DEBUG_INFO, "register_usb_pnp success ^_^\n"); break; } } @@ -277,7 +277,7 @@ void usb_manager::thread_trigger_usb_event() timeval tm={1,0}; int ret=libusb_handle_events_timeout(context_, &tm); if(ret < 0) - HG_LOG(HG_LOG_LEVEL_FATAL, (std::string("libusb_handle_events_timeout error ") + libusb_error_name(ret) + "\n").c_str()); + HG_LOG(LOG_LEVEL_FATAL, (std::string("libusb_handle_events_timeout error ") + libusb_error_name(ret) + "\n").c_str()); std::this_thread::sleep_for(std::chrono::milliseconds(10)); } @@ -325,25 +325,25 @@ void usb_manager::clear(void) int usb_manager::usb_error_2_hg_err(int usb_err) { if (usb_err == LIBUSB_ERROR_TIMEOUT) - return HG_ERR_TIMEOUT; + return SCANNER_ERR_TIMEOUT; else if (usb_err == LIBUSB_ERROR_PIPE) - return HG_ERR_IO; + return SCANNER_ERR_IO; else if (usb_err == LIBUSB_ERROR_NO_DEVICE) - return HG_ERR_DEVICE_NOT_FOUND; + return SCANNER_ERR_DEVICE_NOT_FOUND; else if (usb_err == LIBUSB_ERROR_BUSY) - return HG_ERR_DEVICE_BUSY; + return SCANNER_ERR_DEVICE_BUSY; else if (usb_err == LIBUSB_ERROR_INVALID_PARAM) - return HG_ERR_INVALID_PARAMETER; + return SCANNER_ERR_INVALID_PARAMETER; else if (usb_err == LIBUSB_ERROR_OVERFLOW) - return HG_ERR_OUT_OF_RANGE; + return SCANNER_ERR_OUT_OF_RANGE; else if (usb_err == LIBUSB_ERROR_NO_MEM) - return HG_ERR_INSUFFICIENT_MEMORY; + return SCANNER_ERR_INSUFFICIENT_MEMORY; else if (usb_err == LIBUSB_ERROR_ACCESS) - return HG_ERR_ACCESS_DENIED; + return SCANNER_ERR_ACCESS_DENIED; else if (usb_err < 0) - return (hg_err)usb_err; + return (scanner_err)usb_err; else - return HG_ERR_OK; + return SCANNER_ERR_OK; } void usb_manager::init_endpoint(USBENDP* uep) @@ -422,7 +422,7 @@ void usb_manager::enum_endpoints(libusb_device* device, USBTRANSENDP* endp) if (ret != 0) { - HG_LOG(HG_LOG_LEVEL_WARNING, (std::string("Get device descriptor of device(") + dev + ") failed.\n").c_str()); + HG_LOG(LOG_LEVEL_WARNING, (std::string("Get device descriptor of device(") + dev + ") failed.\n").c_str()); return; } @@ -436,26 +436,26 @@ void usb_manager::enum_endpoints(libusb_device* device, USBTRANSENDP* endp) usb_manager::init_endpoint(&endp->isochronous); } else - hg_log::vlog(HG_LOG_LEVEL_DEBUG_INFO, " +Device(%s) has %u configurations ...\n", dev.c_str(), desc.bNumConfigurations); + hg_log::vlog(LOG_LEVEL_DEBUG_INFO, " +Device(%s) has %u configurations ...\n", dev.c_str(), desc.bNumConfigurations); for (int i = 0; i < (int)desc.bNumConfigurations; ++i) { ret = libusb_get_config_descriptor(device, i, &conf); if (ret != 0) { if (!endp) - hg_log::vlog(HG_LOG_LEVEL_DEBUG_INFO, " Get %d configuration failed.\n", i + 1); + hg_log::vlog(LOG_LEVEL_DEBUG_INFO, " Get %d configuration failed.\n", i + 1); continue; } if (!endp) - hg_log::vlog(HG_LOG_LEVEL_DEBUG_INFO, " Configuration %d has %d interfaces\n", i + 1, conf->bNumInterfaces); + hg_log::vlog(LOG_LEVEL_DEBUG_INFO, " Configuration %d has %d interfaces\n", i + 1, conf->bNumInterfaces); for (int j = 0; j < conf->bNumInterfaces; ++j) { if (!endp) - hg_log::vlog(HG_LOG_LEVEL_DEBUG_INFO, " Interface %d has %d alt-settings\n", j + 1, conf->interface[j].num_altsetting); + hg_log::vlog(LOG_LEVEL_DEBUG_INFO, " 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) - hg_log::vlog(HG_LOG_LEVEL_DEBUG_INFO, " Setting %d: %d - %s has %d endpoints\n", k + 1, conf->interface[j].altsetting[k].bInterfaceNumber + hg_log::vlog(LOG_LEVEL_DEBUG_INFO, " 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) @@ -466,27 +466,27 @@ void usb_manager::enum_endpoints(libusb_device* device, USBTRANSENDP* endp) if (conf->interface[j].altsetting[k].endpoint[l].bmAttributes == LIBUSB_TRANSFER_TYPE_CONTROL) { - HG_VLOG_MINI_3(HG_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); + HG_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); ep = &endp->control; } else if (conf->interface[j].altsetting[k].endpoint[l].bmAttributes == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS) { - HG_VLOG_MINI_3(HG_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); + HG_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); ep = &endp->isochronous; } if (conf->interface[j].altsetting[k].endpoint[l].bmAttributes == LIBUSB_TRANSFER_TYPE_BULK) { - HG_VLOG_MINI_3(HG_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); + HG_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); ep = &endp->bulk; } if (conf->interface[j].altsetting[k].endpoint[l].bmAttributes == LIBUSB_TRANSFER_TYPE_INTERRUPT) { - HG_VLOG_MINI_3(HG_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); + HG_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); ep = &endp->interrupt; } if (conf->interface[j].altsetting[k].endpoint[l].bmAttributes == LIBUSB_TRANSFER_TYPE_BULK_STREAM) { - HG_VLOG_MINI_3(HG_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); + HG_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); ep = &endp->bulk_stream; } if (ep) @@ -505,14 +505,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; - HG_VLOG_MINI_3(HG_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 + HG_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 , s->max_packet); } found_ep = true; } } else - HG_VLOG_MINI_4(HG_LOG_LEVEL_DEBUG_INFO, " Endpoint %d(%s) address: %x, Max packet: 0x%x bytes\n", l + 1 + HG_VLOG_MINI_4(LOG_LEVEL_DEBUG_INFO, " 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); @@ -523,7 +523,7 @@ void usb_manager::enum_endpoints(libusb_device* device, USBTRANSENDP* endp) } if (endp && !found_ep) - HG_VLOG_MINI_2(HG_LOG_LEVEL_FATAL, "No endpoint has been found on device (VID: %x, PID: %x)\n", desc.idVendor, desc.idProduct); + HG_VLOG_MINI_2(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) @@ -541,17 +541,17 @@ int usb_manager::register_hotplug(usb_event_handler cb, void* user) } init_notify_thread(); - return HG_ERR_OK; + return SCANNER_ERR_OK; } int usb_manager::open(libusb_device* device, usb_io** usbio, std::string* msg) { if (!usbio) - return HG_ERR_INVALID_PARAMETER; + return SCANNER_ERR_INVALID_PARAMETER; usb_dev dev; usb_io* usb = NULL; if (!get_device_info(device, &dev)) - return HG_ERR_DEVICE_NOT_FOUND; + return SCANNER_ERR_DEVICE_NOT_FOUND; dev.contex = context_; usb = new usb_io(dev); @@ -562,14 +562,14 @@ int usb_manager::open(libusb_device* device, usb_io** usbio, std::string* msg) if (msg) *msg = usb->init_error_msg(); usb->release(); - HG_VLOG_MINI_3(HG_LOG_LEVEL_DEBUG_INFO, "Open %04x:%04x failed: %s\n", dev.vid, dev.pid, hg_scanner::strerr((hg_err)err).c_str()); + HG_VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "Open %04x:%04x failed: %s\n", dev.vid, dev.pid, hg_scanner::strerr((scanner_err)err).c_str()); return err; } *usbio = dynamic_cast(usb); - return HG_ERR_OK; + return SCANNER_ERR_OK; } int usb_manager::last_status(void) { @@ -586,7 +586,7 @@ int usb_manager::last_status(void) std::shared_ptr usb_; #endif -usb_io::usb_io(const usb_dev& dev) : ref_(1), handle_(NULL), dev_info_(dev), to_(1000), last_err_(HG_ERR_NOT_START), ref_device_(nullptr) +usb_io::usb_io(const usb_dev& dev) : ref_(1), handle_(NULL), dev_info_(dev), to_(1000), last_err_(SCANNER_ERR_NOT_START), ref_device_(nullptr) , singleton_(nullptr) { #ifdef USE_OLD_USB @@ -630,7 +630,7 @@ bool usb_io::make_singleton(void) singleton_->release(); singleton_ = nullptr; - last_err_ = HG_ERR_OPENED_BY_OTHER_PROCESS; + last_err_ = SCANNER_ERR_OPENED_BY_OTHER_PROCESS; 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; @@ -654,34 +654,34 @@ bool usb_io::claim_interterface(usb_manager::USBSIMPLEX* spl) return true; } - HG_VLOG_MINI_2(HG_LOG_LEVEL_FATAL, " first libusb_claim_interface(%d) = %s\n", spl->iface, libusb_error_name(ret)); + HG_VLOG_MINI_2(LOG_LEVEL_FATAL, " first libusb_claim_interface(%d) = %s\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); - HG_VLOG_MINI_2(HG_LOG_LEVEL_FATAL, " libusb_detach_kernel_driver(%d) = %s\n", spl->iface, libusb_error_name(ret)); + HG_VLOG_MINI_2(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_ = HG_ERR_DEVICE_NOT_FOUND; - HG_VLOG_MINI_1(HG_LOG_LEVEL_FATAL, "device(%s) maybe left when libusb_kernel_driver_active.\n", hg_log::format_ptr(dev_info_.device).c_str()); + last_err_ = SCANNER_ERR_DEVICE_NOT_FOUND; + HG_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()); return false; } - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, " libusb_clear_halt(%x) ...\n", spl->port); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, " libusb_clear_halt(%x) ...\n", spl->port); libusb_clear_halt(handle_, spl->port); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, " libusb_release_interface(%u) ...\n", spl->iface); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, " libusb_release_interface(%u) ...\n", spl->iface); libusb_release_interface(handle_, spl->iface); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, " libusb_set_configuration(%u) ...\n", spl->iconf); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, " libusb_set_configuration(%u) ...\n", spl->iconf); libusb_set_configuration(handle_, spl->iconf); //ret = libusb_reset_device(handle_); - //HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, " libusb_reset_device = %s\n", libusb_error_name(ret)); + //HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, " 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); - // HG_VLOG_MINI_1(HG_LOG_LEVEL_FATAL, "device(%s) maybe left when libusb_reset_device.\n", hg_log::format_ptr(dev_info_.device).c_str()); + // HG_VLOG_MINI_1(LOG_LEVEL_FATAL, "device(%s) maybe left when libusb_reset_device.\n", hg_log::format_ptr(dev_info_.device).c_str()); // // return false; //} @@ -694,8 +694,8 @@ bool usb_io::claim_interterface(usb_manager::USBSIMPLEX* spl) return true; } - HG_VLOG_MINI_2(HG_LOG_LEVEL_FATAL, "second try libusb_claim_interface(%d) = %s\n", spl->iface, libusb_error_name(ret)); - last_err_ = HG_ERR_USB_CLAIM_INTERFACE_FAILED; + HG_VLOG_MINI_2(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; } @@ -715,7 +715,7 @@ int usb_io::claim_interfaces(bool claim) break; claimed.push_back(eps[i]->in.iface); - HG_VLOG_MINI_2(HG_LOG_LEVEL_DEBUG_INFO, "claimed %s interface %d\n", usb_manager::endpoint_type((libusb_transfer_type)i).c_str(), eps[i]->in.iface); + HG_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); } 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()) @@ -723,7 +723,7 @@ int usb_io::claim_interfaces(bool claim) if (!claim_interterface(&eps[i]->out)) break; claimed.push_back(eps[i]->out.iface); - HG_VLOG_MINI_2(HG_LOG_LEVEL_DEBUG_INFO, "claimed %s interface %d\n", usb_manager::endpoint_type((libusb_transfer_type)i).c_str(), eps[i]->out.iface); + HG_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); } } } @@ -736,17 +736,17 @@ int usb_io::claim_interfaces(bool claim) if (eps[i]->out.claimed) libusb_release_interface(handle_, eps[i]->out.iface); } - last_err_ = HG_ERR_OK; + last_err_ = SCANNER_ERR_OK; } return last_err_; } void usb_io::init_after_open(void) { - last_err_ = HG_ERR_OK; + last_err_ = SCANNER_ERR_OK; libusb_set_auto_detach_kernel_driver(handle_, 1); usb_manager::enum_endpoints(dev_info_.device, &endpoints_); - if (claim_interfaces(true) != HG_ERR_OK) + if (claim_interfaces(true) != SCANNER_ERR_OK) { int err = last_err_; @@ -764,7 +764,7 @@ void usb_io::open(void) ref_device_ = libusb_ref_device(dev_info_.device); int ret = libusb_open(dev_info_.device, &handle_); - HG_VLOG_MINI_3(HG_LOG_LEVEL_DEBUG_INFO, "call libusb_open(%s, %s) = %s\n", hg_log::format_ptr(dev_info_.device).c_str() + HG_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)); if (ret == LIBUSB_SUCCESS) { @@ -780,19 +780,19 @@ void usb_io::open(void) return; } last_err_ = usb_manager::usb_error_2_hg_err(ret); - HG_VLOG_MINI_4(HG_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)); + HG_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)); handle_ = NULL; } } -bool usb_io::on_io_error(hg_err err, usb_manager::USBSIMPLEX* endp) +bool usb_io::on_io_error(scanner_err err, usb_manager::USBSIMPLEX* endp) { - if (err == HG_ERR_OK) + if (err == SCANNER_ERR_OK) return true; - if (err == HG_ERR_TIMEOUT) + if (err == SCANNER_ERR_TIMEOUT) { //因为在发送img参数出现timeout，暂时禁用 - // //HG_LOG(HG_LOG_LEVEL_DEBUG_INFO, "Operation timeout\n"); + // //HG_LOG(LOG_LEVEL_DEBUG_INFO, "Operation timeout\n"); // libusb_clear_halt(handle_, endp->port); // return libusb_reset_device(handle_) == LIBUSB_SUCCESS; @@ -827,10 +827,10 @@ int usb_io::control_io(uint8_t type, uint8_t req, uint16_t val, uint16_t ind, vo return last_err_; //if (endpoints_.control.in == usb_manager::uninit_uint8) - // return HG_ERR_DEVICE_NOT_SUPPORT; + // return SCANNER_ERR_DEVICE_NOT_SUPPORT; if (!len) - return HG_ERR_INVALID_PARAMETER; + return SCANNER_ERR_INVALID_PARAMETER; int ret = libusb_control_transfer(handle_, type, req, val, ind, (unsigned char*)buf, *len, to_); @@ -839,23 +839,23 @@ int usb_io::control_io(uint8_t type, uint8_t req, uint16_t val, uint16_t ind, vo { *len = ret; - last_err_ = HG_ERR_OK; + last_err_ = SCANNER_ERR_OK; } else { - if (on_io_error((hg_err)usb_manager::usb_error_2_hg_err(ret), &endpoints_.control.in)) + if (on_io_error((scanner_err)usb_manager::usb_error_2_hg_err(ret), &endpoints_.control.in)) { ret = libusb_control_transfer(handle_, type, req, val, ind, (unsigned char*)buf, *len, to_); if (ret > 0) { *len = ret; - last_err_ = HG_ERR_OK; + last_err_ = SCANNER_ERR_OK; return last_err_; } } - HG_VLOG_MINI_5(HG_LOG_LEVEL_DEBUG_INFO, "libusb_control_transfer(%x, %x, %d, %d) = %s\n", type, req, val, ind, libusb_error_name(ret)); + HG_VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "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); } @@ -865,22 +865,22 @@ int usb_io::read_bulk(void* buf, int* len) { #ifdef USE_OLD_USB *len = usb_->read_bulk(buf, *len); - return HG_ERR_OK; + return SCANNER_ERR_OK; #endif if (!handle_) return last_err_; if(endpoints_.bulk.in.port == usb_manager::uninit_uint8) - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; if (!len) - return HG_ERR_INVALID_PARAMETER; + return SCANNER_ERR_INVALID_PARAMETER; //if (*len < endpoints_.bulk.in.max_packet) // avoid transferring overflows ... //{ // *len = endpoints_.bulk.in.max_packet; // - // return HG_ERR_INSUFFICIENT_MEMORY; + // return SCANNER_ERR_INSUFFICIENT_MEMORY; //} // libusb_clear_halt(handle_,endpoints_.bulk.in.port); int total = 0, @@ -891,7 +891,7 @@ int usb_io::read_bulk(void* buf, int* len) if (err) { - HG_VLOG_MINI_4(HG_LOG_LEVEL_DEBUG_INFO, "libusb_bulk_transfer(%x, %d/%d) = %s\n", endpoints_.bulk.in.port, *len, total, libusb_error_name(err)); + HG_VLOG_MINI_4(LOG_LEVEL_DEBUG_INFO, "libusb_bulk_transfer(%x, %d/%d) = %s\n", endpoints_.bulk.in.port, *len, total, libusb_error_name(err)); } return last_err_; @@ -900,16 +900,16 @@ int usb_io::write_bulk(void* buf, int* len) { #ifdef USE_OLD_USB * len = usb_->write_bulk(buf, *len); - return HG_ERR_OK; + return SCANNER_ERR_OK; #endif if (!handle_) return last_err_; if (endpoints_.bulk.out.port == usb_manager::uninit_uint8) - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; if (!len) - return HG_ERR_INVALID_PARAMETER; + return SCANNER_ERR_INVALID_PARAMETER; unsigned char* data = (unsigned char*)buf; int total = 0, t = 0, @@ -917,9 +917,9 @@ 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_)); - //HG_VLOG_MINI_6(HG_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::strerr((hg_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::strerr((hg_err)err).c_str(), to_, endpoints_.bulk.out.max_packet); - if (!on_io_error((hg_err)err, &endpoints_.bulk.out)) + //HG_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::strerr((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::strerr((scanner_err)err).c_str(), to_, endpoints_.bulk.out.max_packet); + if (!on_io_error((scanner_err)err, &endpoints_.bulk.out)) { *len = t; @@ -927,7 +927,7 @@ int usb_io::write_bulk(void* buf, int* len) } total += t; - while (total < *len && (err == HG_ERR_TIMEOUT || err == HG_ERR_DEVICE_BUSY)) + while (total < *len && (err == SCANNER_ERR_TIMEOUT || err == SCANNER_ERR_DEVICE_BUSY)) { if (!t) break; @@ -936,7 +936,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; } - //HG_VLOG_MINI_3(HG_LOG_LEVEL_DEBUG_INFO, "Last write bulk %d/%d = %s\n", total, *len, hg_scanner::strerr((hg_err)err).c_str()); + //HG_VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "Last write bulk %d/%d = %s\n", total, *len, hg_scanner::strerr((scanner_err)err).c_str()); *len = total; last_err_ = err; @@ -946,22 +946,22 @@ int usb_io::read_interrupt(void* buf, int* len) { #ifdef USE_OLD_USB * len = usb_->read_int(buf, *len); - return HG_ERR_OK; + return SCANNER_ERR_OK; #endif if (!handle_) return last_err_; if (endpoints_.interrupt.in.port == usb_manager::uninit_uint8) - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; if (!len) - return HG_ERR_INVALID_PARAMETER; + return SCANNER_ERR_INVALID_PARAMETER; if (*len < endpoints_.interrupt.in.max_packet) // avoid transferring overflows ... { *len = endpoints_.interrupt.in.max_packet; - return HG_ERR_INSUFFICIENT_MEMORY; + return SCANNER_ERR_INSUFFICIENT_MEMORY; } int io = 0; @@ -977,17 +977,17 @@ int usb_io::write_interrupt(void* buf, int* len) return last_err_; if (endpoints_.interrupt.out.port == usb_manager::uninit_uint8) - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; if (!len) - return HG_ERR_INVALID_PARAMETER; + return SCANNER_ERR_INVALID_PARAMETER; unsigned char* data = (unsigned char*)buf; int total = 0, t = 0, err = usb_manager::usb_error_2_hg_err(libusb_bulk_transfer(handle_, endpoints_.interrupt.out.port, data, *len, &t, to_)); total += t; - while (total < *len && (err == HG_ERR_TIMEOUT || err == HG_ERR_DEVICE_BUSY)) + while (total < *len && (err == SCANNER_ERR_TIMEOUT || err == SCANNER_ERR_DEVICE_BUSY)) { data += t; t = 0; @@ -1004,33 +1004,33 @@ int usb_io::read_isochronous(void* buf, int* len) if (!handle_) return last_err_; - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int usb_io::write_isochronous(void* buf, int* len) { if (!handle_) return last_err_; - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int usb_io::read_bulk_stream(void* buf, int* len) { if (!handle_) return last_err_; - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int usb_io::write_bulk_stream(void* buf, int* len) { if (!handle_) return last_err_; - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; } int usb_io::reset(void) { if (!handle_) - return HG_ERR_NOT_OPEN; + return SCANNER_ERR_NOT_OPEN; return usb_manager::usb_error_2_hg_err(libusb_reset_device(handle_)); } @@ -1045,7 +1045,7 @@ int usb_io::close(void) { #ifdef USE_OLD_USB usb_.reset(); - return HG_ERR_OK; + return SCANNER_ERR_OK; #endif if (singleton_) singleton_->release(); @@ -1065,7 +1065,7 @@ int usb_io::close(void) ref_device_ = nullptr; } - return HG_ERR_OK; + return SCANNER_ERR_OK; } libusb_device* usb_io::get_usb_device(void) @@ -1084,7 +1084,7 @@ int usb_io::get_pid(void) void usb_io::on_disconnected(void) { close(); - last_err_ = HG_ERR_DEVICE_NOT_FOUND; + last_err_ = SCANNER_ERR_DEVICE_NOT_FOUND; } std::string usb_io::init_error_msg(void) { @@ -1102,26 +1102,26 @@ int usb_io::last_error(void) int usb_io::get_bulk_packet_size(int* bytes) { if (!bytes) - return HG_ERR_INVALID_PARAMETER; + return SCANNER_ERR_INVALID_PARAMETER; if (endpoints_.bulk.in.port == usb_manager::uninit_uint8 && endpoints_.bulk.out.port == usb_manager::uninit_uint8) - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; *bytes = endpoints_.bulk.in.max_packet; - return HG_ERR_OK; + return SCANNER_ERR_OK; } int usb_io::get_interrupt_packet_size(int* bytes) { if (!bytes) - return HG_ERR_INVALID_PARAMETER; + return SCANNER_ERR_INVALID_PARAMETER; if (endpoints_.interrupt.in.port == usb_manager::uninit_uint8 && endpoints_.interrupt.out.port == usb_manager::uninit_uint8) - return HG_ERR_DEVICE_NOT_SUPPORT; + return SCANNER_ERR_DEVICE_NOT_SUPPORT; *bytes = endpoints_.interrupt.in.max_packet; - return HG_ERR_OK; + return SCANNER_ERR_OK; } unsigned int usb_io::set_timeout(unsigned int to) { diff --git a/hgdriver/hgdev/usb_manager.h b/hgdriver/hgdev/usb_manager.h index 83e1c78..24e724b 100644 --- a/hgdriver/hgdev/usb_manager.h +++ b/hgdriver/hgdev/usb_manager.h @@ -163,7 +163,7 @@ class usb_io void init_after_open(void); void open(void); - bool on_io_error(hg_err err, usb_manager::USBSIMPLEX* endp); + bool on_io_error(scanner_err err, usb_manager::USBSIMPLEX* endp); protected: virtual ~usb_io(); @@ -174,9 +174,9 @@ public: int add_ref(void); // 拥有者在第一次获取时调用一次 int release(void); // 拥有者不再使用时调用 - // IO操作返回值全部为错误代码 (hg_err) + // IO操作返回值全部为错误代码 (scanner_err) int control_io(uint8_t type, uint8_t req, uint16_t val, uint16_t ind, void* buf, int* len); // 读取数据, len: [in] - buf size, [out] - real read bytes in buf - int read_bulk(void* buf, int* len); // 读取数据, len: [in] - buf size, [out] - real read bytes in buf. 如果缓冲区太小，则返回HG_ERR_INSUFFICIENT_MEMORY的错误，并在该值中保存建议的最小缓冲区大小 + int read_bulk(void* buf, int* len); // 读取数据, len: [in] - buf size, [out] - real read bytes in buf. 如果缓冲区太小，则返回SCANNER_ERR_INSUFFICIENT_MEMORY的错误，并在该值中保存建议的最小缓冲区大小 int write_bulk(void* buf, int* len); // 写入数据, len : [in] - content bytes in buf, [out] - real wrote bytes int read_interrupt(void* buf, int* len); // 读取数据, len: [in] - buf size, [out] - real read bytes in buf int write_interrupt(void* buf, int* len); // 写入数据, len : [in] - content bytes in buf, [out] - real wrote bytes diff --git a/hgdriver/wrapper/hg_log.cpp b/hgdriver/wrapper/hg_log.cpp index 6cc0532..2d14100 100644 --- a/hgdriver/wrapper/hg_log.cpp +++ b/hgdriver/wrapper/hg_log.cpp @@ -22,7 +22,7 @@ #endif -class hglog +class log_cls { typedef void(*log_to)(const char*, void*); @@ -32,7 +32,7 @@ class hglog int level_; log_callback lcb_; - static hglog* inst_; + static log_cls* inst_; static void log_none(const char* info, void* param) {} @@ -51,9 +51,9 @@ class hglog } protected: - hglog() : path_file_(""), file_(0), log_(&hglog::log_consonle), level_(HG_LOG_LEVEL_ALL), lcb_(NULL) + log_cls() : path_file_(""), file_(0), log_(&log_cls::log_consonle), level_(LOG_LEVEL_ALL), lcb_(NULL) {} - ~hglog() + ~log_cls() { if (file_) { @@ -63,12 +63,12 @@ protected: } public: - static hglog* instance(void) + static log_cls* instance(void) { - if (!hglog::inst_) - hglog::inst_ = new hglog(); + if (!log_cls::inst_) + log_cls::inst_ = new log_cls(); - return hglog::inst_; + return log_cls::inst_; } int set_log_type(int type, void* param) @@ -83,13 +83,13 @@ public: lcb_ = NULL; log_ = NULL; - if (type == HG_LOG_TYPE_NONE) - log_ = &hglog::log_none; - else if(type == HG_LOG_TYPE_CONSOLE) - log_ = &hglog::log_consonle; - else if (type == HG_LOG_TYPE_FILE) + 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_ = &hglog::log_file; + log_ = &log_cls::log_file; ret = -1; if (param) @@ -104,13 +104,13 @@ public: } } } - else if (type == HG_LOG_TYPE_CALLBACK) + else if (type == LOG_TYPE_CALLBACK) { lcb_ = (log_callback)param; } if(ret != 0) - log_ = &hglog::log_none; + log_ = &log_cls::log_none; return ret; } @@ -128,7 +128,7 @@ public: log_(info, (void*)file_); } }; -hglog* hglog::inst_ = NULL; +log_cls* log_cls::inst_ = NULL; #ifdef EXPORT_AS_C extern "C" @@ -163,13 +163,13 @@ extern "C" } int init(hg_log_type type, hg_log_level level, char* log_file) { - if (type == HG_LOG_TYPE_CALLBACK) + if (type == LOG_TYPE_CALLBACK) lcb_ = (log_callback)log_file; else lcb_ = NULL; - hglog::instance()->set_log_level(level); + log_cls::instance()->set_log_level(level); - return hglog::instance()->set_log_type(type, log_file); + return log_cls::instance()->set_log_type(type, log_file); } std::string current_time(void) { @@ -290,8 +290,8 @@ extern "C" { if (lcb_) lcb_(level, info); - else if (hglog::instance()->is_log_level_enabled(level)) - hglog::instance()->log(info); + else if (log_cls::instance()->is_log_level_enabled(level)) + log_cls::instance()->log(info); } void vlog(hg_log_level level, const char* fmt, ...) { @@ -308,7 +308,7 @@ extern "C" lcb_(level, buf); free(buf); } - else if (hglog::instance()->is_log_level_enabled(level)) + else if (log_cls::instance()->is_log_level_enabled(level)) { va_list args; char* buf = (char*)malloc(1024); @@ -318,7 +318,7 @@ extern "C" sprintf(buf, fmt, args); va_end(args); - hglog::instance()->log(buf); + log_cls::instance()->log(buf); free(buf); } } diff --git a/hgdriver/wrapper/huagaoxxx_warraper_ex.cpp b/hgdriver/wrapper/huagaoxxx_warraper_ex.cpp index 29add60..6586a45 100644 --- a/hgdriver/wrapper/huagaoxxx_warraper_ex.cpp +++ b/hgdriver/wrapper/huagaoxxx_warraper_ex.cpp @@ -19,14 +19,14 @@ extern "C" { - hg_err hg_scanner_initialize(sane_callback callback, void* reserve) + scanner_err hg_scanner_initialize(sane_callback callback, void* reserve) { - // hg_log::init(HG_LOG_TYPE_CONSOLE); + // hg_log::init(LOG_TYPE_CONSOLE); hg_scanner_mgr::set_version(VERSION_MAJOR, VERSION_MINOR, VERSION_YEAR, VERSION_BUILD - 10000); hg_scanner_mgr::instance(callback); - return HG_ERR_OK; + return SCANNER_ERR_OK; } void hg_scanner_uninitialize(void) { @@ -38,63 +38,63 @@ extern "C" return MAKE_VERSION(VERSION_MAJOR, VERSION_MINOR, VERSION_YEAR, VERSION_BUILD - 10000); } - hg_err hg_scanner_enum(HGScannerInfo* scanner_list, long* count, bool local_only) + scanner_err hg_scanner_enum(ScannerInfo* scanner_list, long* count, bool local_only) { return hg_scanner_mgr::instance()->hg_scanner_enum(scanner_list, count, local_only); } - hg_err hg_scanner_open(scanner_handle* h, const char* name, bool shared, const char* user, const char* pwd, const char* check, char* rsc) + scanner_err hg_scanner_open(scanner_handle* h, const char* name, bool shared, const char* user, const char* pwd, const char* check, char* rsc) { return hg_scanner_mgr::instance()->hg_scanner_open(h, name, shared, user, pwd, check, rsc); } - hg_err hg_scanner_close(scanner_handle h, bool force) + scanner_err hg_scanner_close(scanner_handle h, bool force) { return hg_scanner_mgr::instance()->hg_scanner_close(h, force); } - hg_err hg_scanner_get_parameter(scanner_handle h, unsigned param_no, char* data, long* len) + scanner_err hg_scanner_get_parameter(scanner_handle h, unsigned param_no, char* data, long* len) { return hg_scanner_mgr::instance()->hg_scanner_get_parameter(h, param_no, data, len); } - hg_err hg_scanner_set_parameter(scanner_handle h, unsigned param_no, void* data, long len) + scanner_err hg_scanner_set_parameter(scanner_handle h, unsigned param_no, void* data, long len) { return hg_scanner_mgr::instance()->hg_scanner_set_parameter(h, param_no, data, len); } - hg_err hg_scanner_start(scanner_handle h, void* async_event, int num) + scanner_err hg_scanner_start(scanner_handle h, void* async_event, int num) { return hg_scanner_mgr::instance()->hg_scanner_start(h, async_event, num); } - hg_err hg_scanner_stop(scanner_handle h) + scanner_err hg_scanner_stop(scanner_handle h) { return hg_scanner_mgr::instance()->hg_scanner_stop(h); } - hg_err hg_scanner_get_img_info(scanner_handle h, SANE_Parameters* bmi, long len) + scanner_err hg_scanner_get_img_info(scanner_handle h, SANE_Parameters* bmi, long len) { return hg_scanner_mgr::instance()->hg_scanner_get_img_info(h, bmi, len); } - hg_err hg_scanner_read_img_data(scanner_handle h, unsigned char* data, long* len) + scanner_err hg_scanner_read_img_data(scanner_handle h, unsigned char* data, long* len) { return hg_scanner_mgr::instance()->hg_scanner_read_img_data(h, data, len); } - hg_err hg_scanner_get_status(scanner_handle h, int setstutas) + scanner_err hg_scanner_get_status(scanner_handle h, int setstutas) { return hg_scanner_mgr::instance()->hg_scanner_get_status(h, setstutas); } - hg_err hg_scanner_reset(scanner_handle h) + scanner_err hg_scanner_reset(scanner_handle h) { return hg_scanner_mgr::instance()->hg_scanner_reset(h); } - hg_err hg_scanner_control(scanner_handle h, unsigned long code, void* data, unsigned* len) + scanner_err hg_scanner_control(scanner_handle h, unsigned long code, void* data, unsigned* len) { return hg_scanner_mgr::instance()->hg_scanner_control(h, code, data, len); } diff --git a/hgsane/sane_hg_mdw.cpp b/hgsane/sane_hg_mdw.cpp index 1588672..1feba4c 100644 --- a/hgsane/sane_hg_mdw.cpp +++ b/hgsane/sane_hg_mdw.cpp @@ -42,33 +42,33 @@ namespace local_utility { ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static char g_unk_err[80] = { 0 }; - SANE_Status hg_err_2_sane_statu(int hgerr) + SANE_Status scanner_err_2_sane_statu(int hgerr) { #define RETURN_MATCH_ERROR(hg, sane) \ if(hgerr == hg) \ return sane; - RETURN_MATCH_ERROR(HG_ERR_OK, SANE_STATUS_GOOD); - RETURN_MATCH_ERROR(HG_ERR_INVALID_PARAMETER, SANE_STATUS_INVAL); - RETURN_MATCH_ERROR(HG_ERR_INSUFFICIENT_MEMORY, SANE_STATUS_NO_MEM); - RETURN_MATCH_ERROR(HG_ERR_ACCESS_DENIED, SANE_STATUS_ACCESS_DENIED); - RETURN_MATCH_ERROR(HG_ERR_IO_PENDING, SANE_STATUS_GOOD); - RETURN_MATCH_ERROR(HG_ERR_NOT_EXACT, SANE_STATUS_GOOD); - RETURN_MATCH_ERROR(HG_ERR_CONFIGURATION_CHANGED, SANE_STATUS_GOOD); - RETURN_MATCH_ERROR(HG_ERR_NOT_OPEN, SANE_STATUS_NO_DOCS); - RETURN_MATCH_ERROR(HG_ERR_NOT_START, SANE_STATUS_NO_DOCS); - RETURN_MATCH_ERROR(HG_ERR_NO_DATA, SANE_STATUS_EOF); - RETURN_MATCH_ERROR(HG_ERR_HAS_DATA_YET, SANE_STATUS_IO_ERROR); - RETURN_MATCH_ERROR(HG_ERR_OUT_OF_RANGE, SANE_STATUS_NO_MEM); - RETURN_MATCH_ERROR(HG_ERR_IO, SANE_STATUS_IO_ERROR); - RETURN_MATCH_ERROR(HG_ERR_TIMEOUT, SANE_STATUS_IO_ERROR); + RETURN_MATCH_ERROR(SCANNER_ERR_OK, SANE_STATUS_GOOD); + RETURN_MATCH_ERROR(SCANNER_ERR_INVALID_PARAMETER, SANE_STATUS_INVAL); + RETURN_MATCH_ERROR(SCANNER_ERR_INSUFFICIENT_MEMORY, SANE_STATUS_NO_MEM); + RETURN_MATCH_ERROR(SCANNER_ERR_ACCESS_DENIED, SANE_STATUS_ACCESS_DENIED); + RETURN_MATCH_ERROR(SCANNER_ERR_IO_PENDING, SANE_STATUS_GOOD); + RETURN_MATCH_ERROR(SCANNER_ERR_NOT_EXACT, SANE_STATUS_GOOD); + RETURN_MATCH_ERROR(SCANNER_ERR_CONFIGURATION_CHANGED, SANE_STATUS_GOOD); + RETURN_MATCH_ERROR(SCANNER_ERR_NOT_OPEN, SANE_STATUS_NO_DOCS); + RETURN_MATCH_ERROR(SCANNER_ERR_NOT_START, SANE_STATUS_NO_DOCS); + RETURN_MATCH_ERROR(SCANNER_ERR_NO_DATA, SANE_STATUS_EOF); + RETURN_MATCH_ERROR(SCANNER_ERR_HAS_DATA_YET, SANE_STATUS_IO_ERROR); + RETURN_MATCH_ERROR(SCANNER_ERR_OUT_OF_RANGE, SANE_STATUS_NO_MEM); + RETURN_MATCH_ERROR(SCANNER_ERR_IO, SANE_STATUS_IO_ERROR); + RETURN_MATCH_ERROR(SCANNER_ERR_TIMEOUT, SANE_STATUS_IO_ERROR); - RETURN_MATCH_ERROR(HG_ERR_DEVICE_NOT_FOUND, SANE_STATUS_NO_DOCS); - RETURN_MATCH_ERROR(HG_ERR_DEVICE_NOT_SUPPORT, SANE_STATUS_UNSUPPORTED); - RETURN_MATCH_ERROR(HG_ERR_DEVICE_BUSY, SANE_STATUS_DEVICE_BUSY); - RETURN_MATCH_ERROR(HG_ERR_DEVICE_COVER_OPENNED, SANE_STATUS_COVER_OPEN); - RETURN_MATCH_ERROR(HG_ERR_DEVICE_NO_PAPER, SANE_STATUS_NO_DOCS); - RETURN_MATCH_ERROR(HG_ERR_DEVICE_PAPER_JAMMED, SANE_STATUS_JAMMED); + RETURN_MATCH_ERROR(SCANNER_ERR_DEVICE_NOT_FOUND, SANE_STATUS_NO_DOCS); + RETURN_MATCH_ERROR(SCANNER_ERR_DEVICE_NOT_SUPPORT, SANE_STATUS_UNSUPPORTED); + RETURN_MATCH_ERROR(SCANNER_ERR_DEVICE_BUSY, SANE_STATUS_DEVICE_BUSY); + RETURN_MATCH_ERROR(SCANNER_ERR_DEVICE_COVER_OPENNED, SANE_STATUS_COVER_OPEN); + RETURN_MATCH_ERROR(SCANNER_ERR_DEVICE_NO_PAPER, SANE_STATUS_NO_DOCS); + RETURN_MATCH_ERROR(SCANNER_ERR_DEVICE_PAPER_JAMMED, SANE_STATUS_JAMMED); return (SANE_Status)hgerr; } @@ -86,46 +86,46 @@ namespace local_utility RETURN_IF(statu, SANE_STATUS_IO_ERROR); RETURN_IF(statu, SANE_STATUS_NO_MEM); RETURN_IF(statu, SANE_STATUS_ACCESS_DENIED); - RETURN_IF(statu, HG_ERR_INVALID_PARAMETER); - RETURN_IF(statu, HG_ERR_USER_CANCELED); - RETURN_IF(statu, HG_ERR_INSUFFICIENT_MEMORY); - RETURN_IF(statu, HG_ERR_ACCESS_DENIED); - RETURN_IF(statu, HG_ERR_IO_PENDING); - RETURN_IF(statu, HG_ERR_NOT_EXACT); - RETURN_IF(statu, HG_ERR_CONFIGURATION_CHANGED); - RETURN_IF(statu, HG_ERR_NOT_OPEN); - RETURN_IF(statu, HG_ERR_NOT_START); - RETURN_IF(statu, HG_ERR_NOT_ANY_MORE); - RETURN_IF(statu, HG_ERR_NO_DATA); - RETURN_IF(statu, HG_ERR_HAS_DATA_YET); - RETURN_IF(statu, HG_ERR_OUT_OF_RANGE); - RETURN_IF(statu, HG_ERR_IO); - RETURN_IF(statu, HG_ERR_TIMEOUT); - RETURN_IF(statu, HG_ERR_OPEN_FILE_FAILED); - RETURN_IF(statu, HG_ERR_CREATE_FILE_FAILED); - RETURN_IF(statu, HG_ERR_WRITE_FILE_FAILED); - RETURN_IF(statu, HG_ERR_DATA_DAMAGED); - RETURN_IF(statu, HG_ERR_USB_INIT_FAILED); - RETURN_IF(statu, HG_ERR_USB_REGISTER_PNP_FAILED); - RETURN_IF(statu, HG_ERR_USB_CLAIM_INTERFACE_FAILED); - RETURN_IF(statu, HG_ERR_DEVICE_NOT_FOUND); - RETURN_IF(statu, HG_ERR_DEVICE_NOT_SUPPORT); - RETURN_IF(statu, HG_ERR_DEVICE_BUSY); - RETURN_IF(statu, HG_ERR_DEVICE_SLEEPING); - RETURN_IF(statu, HG_ERR_DEVICE_COUNT_MODE); - RETURN_IF(statu, HG_ERR_DEVICE_STOPPED); - RETURN_IF(statu, HG_ERR_DEVICE_COVER_OPENNED); - RETURN_IF(statu, HG_ERR_DEVICE_NO_PAPER); - RETURN_IF(statu, HG_ERR_DEVICE_FEEDING_PAPER); - RETURN_IF(statu, HG_ERR_DEVICE_DOUBLE_FEEDING); - RETURN_IF(statu, HG_ERR_DEVICE_PAPER_JAMMED); - RETURN_IF(statu, HG_ERR_DEVICE_STAPLE_ON); - RETURN_IF(statu, HG_ERR_DEVICE_PAPER_SKEW); - RETURN_IF(statu, HG_ERR_DEVICE_SIZE_CHECK); - RETURN_IF(statu, HG_ERR_DEVICE_DOGEAR); - RETURN_IF(statu, HG_ERR_DEVICE_NO_IMAGE); - RETURN_IF(statu, HG_ERR_DEVICE_SCANN_ERROR); - RETURN_IF(statu, HG_ERR_DEVICE_PC_BUSY); + RETURN_IF(statu, SCANNER_ERR_INVALID_PARAMETER); + RETURN_IF(statu, SCANNER_ERR_USER_CANCELED); + RETURN_IF(statu, SCANNER_ERR_INSUFFICIENT_MEMORY); + RETURN_IF(statu, SCANNER_ERR_ACCESS_DENIED); + RETURN_IF(statu, SCANNER_ERR_IO_PENDING); + RETURN_IF(statu, SCANNER_ERR_NOT_EXACT); + RETURN_IF(statu, SCANNER_ERR_CONFIGURATION_CHANGED); + RETURN_IF(statu, SCANNER_ERR_NOT_OPEN); + RETURN_IF(statu, SCANNER_ERR_NOT_START); + RETURN_IF(statu, SCANNER_ERR_NOT_ANY_MORE); + RETURN_IF(statu, SCANNER_ERR_NO_DATA); + RETURN_IF(statu, SCANNER_ERR_HAS_DATA_YET); + RETURN_IF(statu, SCANNER_ERR_OUT_OF_RANGE); + RETURN_IF(statu, SCANNER_ERR_IO); + RETURN_IF(statu, SCANNER_ERR_TIMEOUT); + RETURN_IF(statu, SCANNER_ERR_OPEN_FILE_FAILED); + RETURN_IF(statu, SCANNER_ERR_CREATE_FILE_FAILED); + RETURN_IF(statu, SCANNER_ERR_WRITE_FILE_FAILED); + RETURN_IF(statu, SCANNER_ERR_DATA_DAMAGED); + RETURN_IF(statu, SCANNER_ERR_USB_INIT_FAILED); + RETURN_IF(statu, SCANNER_ERR_USB_REGISTER_PNP_FAILED); + RETURN_IF(statu, SCANNER_ERR_USB_CLAIM_INTERFACE_FAILED); + RETURN_IF(statu, SCANNER_ERR_DEVICE_NOT_FOUND); + RETURN_IF(statu, SCANNER_ERR_DEVICE_NOT_SUPPORT); + RETURN_IF(statu, SCANNER_ERR_DEVICE_BUSY); + RETURN_IF(statu, SCANNER_ERR_DEVICE_SLEEPING); + RETURN_IF(statu, SCANNER_ERR_DEVICE_COUNT_MODE); + RETURN_IF(statu, SCANNER_ERR_DEVICE_STOPPED); + RETURN_IF(statu, SCANNER_ERR_DEVICE_COVER_OPENNED); + RETURN_IF(statu, SCANNER_ERR_DEVICE_NO_PAPER); + RETURN_IF(statu, SCANNER_ERR_DEVICE_FEEDING_PAPER); + RETURN_IF(statu, SCANNER_ERR_DEVICE_DOUBLE_FEEDING); + RETURN_IF(statu, SCANNER_ERR_DEVICE_PAPER_JAMMED); + RETURN_IF(statu, SCANNER_ERR_DEVICE_STAPLE_ON); + RETURN_IF(statu, SCANNER_ERR_DEVICE_PAPER_SKEW); + RETURN_IF(statu, SCANNER_ERR_DEVICE_SIZE_CHECK); + RETURN_IF(statu, SCANNER_ERR_DEVICE_DOGEAR); + RETURN_IF(statu, SCANNER_ERR_DEVICE_NO_IMAGE); + RETURN_IF(statu, SCANNER_ERR_DEVICE_SCANN_ERROR); + RETURN_IF(statu, SCANNER_ERR_DEVICE_PC_BUSY); sprintf(g_unk_err, "\346\234\252\347\237\245\351\224\231\350\257\257\357\274\232%X", statu); @@ -210,9 +210,9 @@ namespace local_utility free(buf); } if (found) - hg_log::log(HG_LOG_LEVEL_DEBUG_INFO, "Testing configuration loaded from /tmp/hg_g100.txt ^_^\n"); + hg_log::log(LOG_LEVEL_DEBUG_INFO, "Testing configuration loaded from /tmp/hg_g100.txt ^_^\n"); else - hg_log::log(HG_LOG_LEVEL_DEBUG_INFO, "'/tmp/hg_g100.txt' is not found or data damaged. :(\n"); + hg_log::log(LOG_LEVEL_DEBUG_INFO, "'/tmp/hg_g100.txt' is not found or data damaged. :(\n"); #endif #ifndef WIN32 @@ -422,11 +422,11 @@ namespace local_utility val(""); simple_ini ini; bool given_path = false; - hg_log_type logt = HG_LOG_TYPE_FILE; - hg_log_level logl = HG_LOG_LEVEL_ALL; + hg_log_type logt = LOG_TYPE_FILE; + hg_log_level logl = LOG_LEVEL_ALL; - hg_log::init(HG_LOG_TYPE_CONSOLE, HG_LOG_LEVEL_DEBUG_INFO); - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "current path: '%s'\n", path.c_str()); + hg_log::init(LOG_TYPE_CONSOLE, LOG_LEVEL_DEBUG_INFO); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "current path: '%s'\n", path.c_str()); if (path.empty()) path = simple_ini::temporary_path(); @@ -440,10 +440,10 @@ namespace local_utility { val = ini.get("log", "type"); if (stricmp(val.c_str(), "console") == 0) - logt = HG_LOG_TYPE_CONSOLE; + logt = LOG_TYPE_CONSOLE; else if (stricmp(val.c_str(), "none") == 0) - logt = HG_LOG_TYPE_NONE; - if (logt == HG_LOG_TYPE_FILE) + logt = LOG_TYPE_NONE; + if (logt == LOG_TYPE_FILE) { val = ini.get("log", "file"); if (!val.empty()) @@ -454,13 +454,13 @@ namespace local_utility } val = ini.get("log", "level"); if (stricmp(val.c_str(), "debug") == 0) - logl = HG_LOG_LEVEL_DEBUG_INFO; + logl = LOG_LEVEL_DEBUG_INFO; else if (stricmp(val.c_str(), "warning") == 0) - logl = HG_LOG_LEVEL_WARNING; + logl = LOG_LEVEL_WARNING; else if (stricmp(val.c_str(), "fatal") == 0) - logl = HG_LOG_LEVEL_FATAL; + logl = LOG_LEVEL_FATAL; } - if (logt == HG_LOG_TYPE_FILE && !given_path) + if (logt == LOG_TYPE_FILE && !given_path) { std::string child("/scanner_log"); path += child; @@ -470,22 +470,28 @@ namespace local_utility } else { - HG_VLOG_MINI_2(HG_LOG_LEVEL_DEBUG_INFO, "create folder '%s' failed(%d), now try temporary directory\n", path.c_str(), errno); + HG_VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "create folder '%s' failed(%d), now try temporary directory\n", path.c_str(), errno); path = simple_ini::temporary_path() + child; if (MKDIR(path.c_str(), S_IREAD | S_IWRITE | S_IEXEC) == 0 || errno == EEXIST) path += "/log.txt"; else { - HG_VLOG_MINI_2(HG_LOG_LEVEL_DEBUG_INFO, "create temporary directory '%s' failed(%d), log to console\n", path.c_str(), errno); - logt = HG_LOG_TYPE_CONSOLE; - logl = HG_LOG_LEVEL_WARNING; + HG_VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "create temporary directory '%s' failed(%d), log to console\n", path.c_str(), errno); + logt = LOG_TYPE_CONSOLE; + logl = LOG_LEVEL_WARNING; } } } hg_log::init(logt, logl, &path[0]); +#ifdef OEM_HANWANG + path = hg_log::current_time() + " hwsane is starting ...\n"; +#elif defined(OEM_LISICHENG) + path = hg_log::current_time() + " lscsane is starting ...\n"; +#else path = hg_log::current_time() + " hgsane is starting ...\n"; - hg_log::log(HG_LOG_LEVEL_FATAL, path.c_str()); +#endif + hg_log::log(LOG_LEVEL_FATAL, path.c_str()); } ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -521,7 +527,7 @@ namespace local_utility std::lock_guard lck(cb_lock_); if (SANE_EVENT_SUPPORT_ASYNC_IO == code) - return cb_ui_ ? HG_ERR_OK : HG_ERR_DEVICE_NOT_SUPPORT; + return cb_ui_ ? SCANNER_ERR_OK : SCANNER_ERR_DEVICE_NOT_SUPPORT; if (code == SANE_EVENT_WIN_DEBUG_INFO) { @@ -531,7 +537,7 @@ namespace local_utility SANE_Handle h = hg_sane_middleware::scanner_handle_to_sane(dev); - HG_VLOG_MINI_1(HG_LOG_LEVEL_ALL, "sane callback invoked of event %s\n", sane_event((SANE_Event)code).c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_ALL, "sane callback invoked of event %s\n", sane_event((SANE_Event)code).c_str()); if (cb_ui_) { @@ -556,7 +562,13 @@ namespace local_utility long v = hg_scanner_get_version(); unsigned char* byt = (unsigned char*)&v; - HG_VLOG_MINI_4(HG_LOG_LEVEL_DEBUG_INFO, "Huagao scanner driver version: %u.%u.%u.%u\n", byt[3], byt[2], byt[1], byt[0]); +#ifdef OEM_HANWANG + HG_VLOG_MINI_4(LOG_LEVEL_DEBUG_INFO, "HanWang scanner driver version: %u.%u.%u.%u\n", byt[3], byt[2], byt[1], byt[0]); +#elif defined(OEM_LISICHENG) + HG_VLOG_MINI_4(LOG_LEVEL_DEBUG_INFO, "Lisicheng scanner driver version: %u.%u.%u.%u\n", byt[3], byt[2], byt[1], byt[0]); +#else + HG_VLOG_MINI_4(LOG_LEVEL_DEBUG_INFO, "Huagao scanner driver version: %u.%u.%u.%u\n", byt[3], byt[2], byt[1], byt[0]); +#endif } void stop_work(void) { @@ -580,7 +592,7 @@ static sane_callback g_cb = NULL; void* g_param = NULL; static unsigned int scan_count = -1; static unsigned int scan_count_ = 1; -hg_err hg_scanner_initialize(sane_callback callback, void* param) +scanner_err hg_scanner_initialize(sane_callback callback, void* param) { #ifdef TEST_DEV hg_scanner_mgr::instance(); @@ -590,7 +602,7 @@ hg_err hg_scanner_initialize(sane_callback callback, void* param) g_cb = callback; g_param = param; - return HG_ERR_OK; + return SCANNER_ERR_OK; } void hg_scanner_uninitialize(void) { @@ -600,20 +612,20 @@ long hg_scanner_get_version(void) return SANE_VERSION_CODE(1, 0, 311); } static const char* scanner_name = "华高扫描仪(模拟)"; -hg_err hg_scanner_enum(HGScannerInfo* scanner_list, long* count, bool local_only) +scanner_err hg_scanner_enum(ScannerInfo* scanner_list, long* count, bool local_only) { #ifdef TEST_DEV return hg_scanner_mgr::instance()->hg_scanner_enum(scanner_list, count, local_only); #endif if (!count) - return HG_ERR_INVALID_PARAMETER; + return SCANNER_ERR_INVALID_PARAMETER; if (*count < 1) { *count = 1; - return HG_ERR_INSUFFICIENT_MEMORY; + return SCANNER_ERR_INSUFFICIENT_MEMORY; } *count = 1; @@ -627,12 +639,12 @@ hg_err hg_scanner_enum(HGScannerInfo* scanner_list, long* count, bool local_only jsn_inst = new json(&v[0]); } - return HG_ERR_OK; + return SCANNER_ERR_OK; } static volatile bool run_ = true; void* thread_pnp(void*) { - HGScannerInfo devs[4]; + ScannerInfo devs[4]; long count = sizeof(devs) / sizeof(devs[0]); int ev = SANE_EVENT_DEVICE_ARRIVED; @@ -657,31 +669,31 @@ void* thread_pnp(void*) return 0; } -hg_err hg_scanner_open(scanner_handle* h, const char* name, bool shared, const char* user, const char* pwd, const char* check, char* rsc/*rsc[80]*/) +scanner_err hg_scanner_open(scanner_handle* h, const char* name, bool shared, const char* user, const char* pwd, const char* check, char* rsc/*rsc[80]*/) { if (!h || !name) - return HG_ERR_INVALID_PARAMETER; + return SCANNER_ERR_INVALID_PARAMETER; if (strcmp(name, scanner_name)) - return HG_ERR_DEVICE_NOT_FOUND; + return SCANNER_ERR_DEVICE_NOT_FOUND; *h = (scanner_handle)0x7e57; - return HG_ERR_OK; + return SCANNER_ERR_OK; } -hg_err hg_scanner_close(scanner_handle h, bool force) +scanner_err hg_scanner_close(scanner_handle h, bool force) { - return HG_ERR_OK; + return SCANNER_ERR_OK; } -hg_err hg_scanner_get_parameter(scanner_handle h, unsigned param_no, char* json_data, long* len) +scanner_err hg_scanner_get_parameter(scanner_handle h, unsigned param_no, char* json_data, long* len) { std::string v(""); json* child = NULL; char key[20]; - hg_err err = HG_ERR_OUT_OF_RANGE; + scanner_err err = SCANNER_ERR_OUT_OF_RANGE; if (!len || !jsn_inst) - err = HG_ERR_INVALID_PARAMETER; + err = SCANNER_ERR_INVALID_PARAMETER; else { if (param_no == 0) @@ -689,7 +701,7 @@ hg_err hg_scanner_get_parameter(scanner_handle h, unsigned param_no, char* json_ int count = 0; jsn_inst->get_value("option_count", count); *len = count; - err = HG_ERR_OK; + err = SCANNER_ERR_OK; } else { @@ -703,14 +715,14 @@ hg_err hg_scanner_get_parameter(scanner_handle h, unsigned param_no, char* json_ if (*len <= v.length()) { - err = HG_ERR_INSUFFICIENT_MEMORY; + err = SCANNER_ERR_INSUFFICIENT_MEMORY; *len = v.length() + 4; } else { strcpy(json_data, v.c_str()); *len = v.length(); - err = HG_ERR_OK; + err = SCANNER_ERR_OK; } } } @@ -718,9 +730,9 @@ hg_err hg_scanner_get_parameter(scanner_handle h, unsigned param_no, char* json_ return err; } -hg_err hg_scanner_set_parameter(scanner_handle h, unsigned param_no, void* data, long len) +scanner_err hg_scanner_set_parameter(scanner_handle h, unsigned param_no, void* data, long len) { - hg_err ret = HG_ERR_OK; + scanner_err ret = SCANNER_ERR_OK; //if (param_no == 15) //{ @@ -730,7 +742,7 @@ hg_err hg_scanner_set_parameter(scanner_handle h, unsigned param_no, void* data, // { // *(SANE_Int*)data = regular; // - // ret = HG_ERR_NOT_EXACT; + // ret = SCANNER_ERR_NOT_EXACT; // } //} @@ -836,19 +848,19 @@ void* fake_thread(void* hs) } else { - unsigned int err = HG_ERR_OPEN_FILE_FAILED; + unsigned int err = SCANNER_ERR_OPEN_FILE_FAILED; path += file; local_utility::ui_cb(h, SANE_EVENT_ERROR, &path[0], &err, NULL); - HG_VLOG_2(HG_LOG_LEVEL_DEBUG_INFO, 512, "Open file failed(%d): %s\n", errno, path.c_str()); + HG_VLOG_2(LOG_LEVEL_DEBUG_INFO, 512, "Open file failed(%d): %s\n", errno, path.c_str()); break; } } else { - unsigned int err = HG_ERR_OPEN_FILE_FAILED; + unsigned int err = SCANNER_ERR_OPEN_FILE_FAILED; path += file; local_utility::ui_cb(h, SANE_EVENT_ERROR, &path[0], &err, NULL); - HG_VLOG_2(HG_LOG_LEVEL_DEBUG_INFO, 512, "Open file failed(%d): %s\n", errno, path.c_str()); + HG_VLOG_2(LOG_LEVEL_DEBUG_INFO, 512, "Open file failed(%d): %s\n", errno, path.c_str()); break; } if (pic_ind >= count) @@ -866,12 +878,12 @@ void* fake_thread(void* hs) return 0; } -hg_err hg_scanner_start(scanner_handle h, void* async_event, int num) +scanner_err hg_scanner_start(scanner_handle h, void* async_event, int num) { //if (local_utility::cb_ui_) //{ // if (thread_img_handle.get() && !finished) - // return HG_ERR_DEVICE_BUSY; + // return SCANNER_ERR_DEVICE_BUSY; //} finished = false; @@ -888,9 +900,9 @@ hg_err hg_scanner_start(scanner_handle h, void* async_event, int num) pthread_create(&id, NULL, fake_thread, (void*)h); } - return HG_ERR_OK; + return SCANNER_ERR_OK; } -hg_err hg_scanner_stop(scanner_handle h) +scanner_err hg_scanner_stop(scanner_handle h) { cancel = true; //if (local_utility::cb_ui_) @@ -900,9 +912,9 @@ hg_err hg_scanner_stop(scanner_handle h) // thread_img_handle.reset(); //} - return HG_ERR_OK; + return SCANNER_ERR_OK; } -hg_err hg_scanner_get_img_info(scanner_handle h, SANE_Parameters* bmi, long len) +scanner_err hg_scanner_get_img_info(scanner_handle h, SANE_Parameters* bmi, long len) { std::string path(local_utility::get_self_path()); char file[128]; @@ -932,14 +944,14 @@ hg_err hg_scanner_get_img_info(scanner_handle h, SANE_Parameters* bmi, long len) bmi->pixels_per_line = 1920; } - return HG_ERR_OK; + return SCANNER_ERR_OK; } -hg_err hg_scanner_read_img_data(scanner_handle h, unsigned char* data, long* len) +scanner_err hg_scanner_read_img_data(scanner_handle h, unsigned char* data, long* len) { // if (*len <= 0 || fake_read >= fake_total) -// return HG_ERR_NO_DATA; +// return SCANNER_ERR_NO_DATA; if (cancel) - return (hg_err)SANE_STATUS_CANCELLED; + return (scanner_err)SANE_STATUS_CANCELLED; std::string path(local_utility::get_self_path()); char file[128]; @@ -972,19 +984,19 @@ hg_err hg_scanner_read_img_data(scanner_handle h, unsigned char* data, long* len offset += bytes; } - return HG_ERR_OK; + return SCANNER_ERR_OK; } -hg_err hg_scanner_get_status(scanner_handle h, int setstutas) +scanner_err hg_scanner_get_status(scanner_handle h, int setstutas) { - return HG_ERR_OK; + return SCANNER_ERR_OK; } -hg_err hg_scanner_reset(scanner_handle h) +scanner_err hg_scanner_reset(scanner_handle h) { - return HG_ERR_OK; + return SCANNER_ERR_OK; } -hg_err hg_scanner_control(scanner_handle h, unsigned long code, void* data, unsigned* len) +scanner_err hg_scanner_control(scanner_handle h, unsigned long code, void* data, unsigned* len) { - return HG_ERR_OK; + return SCANNER_ERR_OK; } #endif @@ -1012,7 +1024,7 @@ hg_sane_middleware::~hg_sane_middleware() hg_scanner_uninitialize(); } -const SANE_Device** hg_sane_middleware::to_sane_device(HGScannerInfo* hgscanner, int count) +const SANE_Device** hg_sane_middleware::to_sane_device(ScannerInfo* hgscanner, int count) { // 将多级指针安排在一个连续的内存空间存放 SANE_Device** ret = NULL, * dev = NULL; @@ -1054,7 +1066,7 @@ const SANE_Device** hg_sane_middleware::to_sane_device(HGScannerInfo* hgscanner, COPY_DEVICE_MEMBER(type); } - //HG_VLOG_MINI_2(HG_LOG_LEVEL_ALL, "Memory usage: %u / %u\n", val - (char*)ret, total); + //HG_VLOG_MINI_2(LOG_LEVEL_ALL, "Memory usage: %u / %u\n", val - (char*)ret, total); return (const SANE_Device**)ret; } @@ -1069,7 +1081,7 @@ void hg_sane_middleware::free_sane_device(SANE_Device** dev) } void hg_sane_middleware::device_pnp(int sig) { - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "Device list changed (%d)...", sig); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Device list changed (%d)...", sig); } SANE_Fixed hg_sane_middleware::double_2_sane_fixed(double v) { @@ -1198,7 +1210,7 @@ SANE_Option_Descriptor* hg_sane_middleware::string_option_to_SANE_descriptor(con } } - //HG_VLOG_MINI_2(HG_LOG_LEVEL_ALL, "Memory usage: %u/%u\n", str - (char*)sod, bytes); + //HG_VLOG_MINI_2(LOG_LEVEL_ALL, "Memory usage: %u/%u\n", str - (char*)sod, bytes); return sod; } @@ -1259,7 +1271,7 @@ SANE_Option_Descriptor* hg_sane_middleware::number_option_to_SANE_descriptor(con str = (char*)((SANE_Range*)str + 1); } - //HG_VLOG_MINI_2(HG_LOG_LEVEL_ALL, "Memory usage: %u/%u\n", str - (char*)sod, bytes); + //HG_VLOG_MINI_2(LOG_LEVEL_ALL, "Memory usage: %u/%u\n", str - (char*)sod, bytes); return sod; } @@ -1309,7 +1321,7 @@ SANE_Option_Descriptor* hg_sane_middleware::number_option_to_SANE_descriptor(con str = (char*)(val + values.size()); } - //HG_VLOG_MINI_2(HG_LOG_LEVEL_ALL, "Memory usage: %u/%u\n", str - (char*)sod, bytes); + //HG_VLOG_MINI_2(LOG_LEVEL_ALL, "Memory usage: %u/%u\n", str - (char*)sod, bytes); return sod; } @@ -1359,7 +1371,7 @@ SANE_Option_Descriptor* hg_sane_middleware::number_option_to_SANE_descriptor(con str = (char*)(val + values.size()); } - //HG_VLOG_MINI_2(HG_LOG_LEVEL_ALL, "Memory usage: %u/%u\n", str - (char*)sod, bytes); + //HG_VLOG_MINI_2(LOG_LEVEL_ALL, "Memory usage: %u/%u\n", str - (char*)sod, bytes); return sod; } @@ -1367,13 +1379,13 @@ SANE_Option_Descriptor* hg_sane_middleware::number_option_to_SANE_descriptor(con SANE_Status hg_sane_middleware::open(SANE_String_Const devicename, SANE_Handle* handle, const char* name, const char* pwd, const char* method, char* rsc) { scanner_handle h = NULL; - hg_err err = HG_ERR_OK; + scanner_err err = SCANNER_ERR_OK; if (handle == NULL) return SANE_STATUS_INVAL; err = hg_scanner_open(&h, devicename, false, NULL, NULL, NULL, rsc); - if (err == HG_ERR_OK) + if (err == SCANNER_ERR_OK) { OPENDEV od; @@ -1385,7 +1397,7 @@ SANE_Status hg_sane_middleware::open(SANE_String_Const devicename, SANE_Handle* return SANE_STATUS_GOOD; } - else if (err == HG_ERR_ACCESS_DENIED) + else if (err == SCANNER_ERR_ACCESS_DENIED) { return SANE_STATUS_ACCESS_DENIED; } @@ -1529,7 +1541,7 @@ SANE_Option_Descriptor* hg_sane_middleware::from_json(scanner_handle h, json* js if (strcmp(ret->title, "\345\210\206\350\276\250\347\216\207") == 0) { - hg_log::log(HG_LOG_LEVEL_DEBUG_INFO, "set \345\210\206\350\276\250\347\216\207 unit to DPI\n"); + hg_log::log(LOG_LEVEL_DEBUG_INFO, "set \345\210\206\350\276\250\347\216\207 unit to DPI\n"); ret->unit = SANE_UNIT_DPI; } else if (strcmp(ret->name, KNOWN_OPT_NAME_CUSTOM_AREA_LEFT) == 0 || @@ -1609,15 +1621,15 @@ std::string hg_sane_middleware::get_option_json(scanner_handle handle, int opt_n { char* json_txt = NULL; long length = 0; - hg_err err = hg_scanner_get_parameter(handle, opt_no, json_txt, &length); + scanner_err err = hg_scanner_get_parameter(handle, opt_no, json_txt, &length); std::string ret(""); - if (err == HG_ERR_INSUFFICIENT_MEMORY) + if (err == SCANNER_ERR_INSUFFICIENT_MEMORY) { json_txt = (char*)local_utility::acquire_memory(ALIGN_INT(length + 4), "hg_sane_middleware::get_option_json"); bzero(json_txt, length + 4); err = hg_scanner_get_parameter(handle, opt_no, json_txt, &length); - if (err == HG_ERR_OK) + if (err == SCANNER_ERR_OK) { ret = json_txt; } @@ -1706,7 +1718,7 @@ bool hg_sane_middleware::get_current_value(scanner_handle handle, int option, vo jsn->get_value("title", val); - HG_VLOG_MINI_3(HG_LOG_LEVEL_DEBUG_INFO, "<--Get option(%d - %s) value: %s\n", option, val.c_str(), hg_sane_middleware::option_value_2_string(t, value).c_str()); + HG_VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "<--Get option(%d - %s) value: %s\n", option, val.c_str(), hg_sane_middleware::option_value_2_string(t, value).c_str()); } delete jsn; @@ -1738,31 +1750,31 @@ SANE_Status hg_sane_middleware::get_devices(const SANE_Device*** device_list, SA if (!device_list) return SANE_STATUS_INVAL; - HGScannerInfo* dev = NULL; + ScannerInfo * dev = NULL; long count = 0; - hg_err hgerr = hg_scanner_enum(dev, &count, local_only); + scanner_err hgerr = hg_scanner_enum(dev, &count, local_only); SANE_Status ret = SANE_STATUS_GOOD; - if (hgerr == HG_ERR_INSUFFICIENT_MEMORY) + if (hgerr == SCANNER_ERR_INSUFFICIENT_MEMORY) { count += 4; // 为两次hg_scanner_enum间隙可能新增的设备预留空间 - dev = (HGScannerInfo*)local_utility::acquire_memory(sizeof(HGScannerInfo) * count, "hg_sane_middleware::get_devices"); + dev = (ScannerInfo*)local_utility::acquire_memory(sizeof(ScannerInfo) * count, "hg_sane_middleware::get_devices"); hgerr = hg_scanner_enum(dev, &count, local_only); - if (hgerr != HG_ERR_OK) + if (hgerr != SCANNER_ERR_OK) { free(dev); dev = NULL; } } - if (hgerr == HG_ERR_OK) + if (hgerr == SCANNER_ERR_OK) { *device_list = hg_sane_middleware::to_sane_device(dev, count); if (dev) free(dev); } else - ret = local_utility::hg_err_2_sane_statu(hgerr); + ret = local_utility::scanner_err_2_sane_statu(hgerr); if (hg_sane_middleware::dev_list_) free(hg_sane_middleware::dev_list_); @@ -1798,37 +1810,37 @@ SANE_Status hg_sane_middleware::close_device(SANE_Handle h) SANE_Status err = SANE_STATUS_GOOD; if (hs) - err = local_utility::hg_err_2_sane_statu(hg_scanner_close(hs, true)); + err = local_utility::scanner_err_2_sane_statu(hg_scanner_close(hs, true)); return err; } SANE_Status hg_sane_middleware::get_image_parameters(SANE_Handle handle, SANE_Parameters* params) { scanner_handle h = find_openning_device(handle); - hg_err err = HG_ERR_NOT_START; + scanner_err err = SCANNER_ERR_NOT_START; if (!params) return SANE_STATUS_INVAL; err = hg_scanner_get_img_info(h, params, sizeof(*params)); - return local_utility::hg_err_2_sane_statu(err); + return local_utility::scanner_err_2_sane_statu(err); } SANE_Status hg_sane_middleware::start(SANE_Handle h, void* async_event) { OPENDEV dev; scanner_handle hs = find_openning_device(h, false, &dev); - hg_err err = HG_ERR_INVALID_PARAMETER; + scanner_err err = SCANNER_ERR_INVALID_PARAMETER; if(hs) err = hg_scanner_start(hs, async_event, dev.scan_count); - return local_utility::hg_err_2_sane_statu(err); + return local_utility::scanner_err_2_sane_statu(err); } SANE_Status hg_sane_middleware::read(SANE_Handle h, void* buf, int* bytes) { scanner_handle hs = find_openning_device(h); - hg_err err = HG_ERR_INVALID_PARAMETER; + scanner_err err = SCANNER_ERR_INVALID_PARAMETER; long r = bytes ? *bytes : 0; if (bytes && hs) @@ -1837,7 +1849,7 @@ SANE_Status hg_sane_middleware::read(SANE_Handle h, void* buf, int* bytes) *bytes = r; } - return local_utility::hg_err_2_sane_statu(err); + return local_utility::scanner_err_2_sane_statu(err); } SANE_Status hg_sane_middleware::stop(SANE_Handle h) { @@ -1922,12 +1934,12 @@ SANE_Status hg_sane_middleware::set_option(SANE_Handle h, SANE_Int option, SANE_ if (!desc) { - HG_VLOG_MINI_1(HG_LOG_LEVEL_WARNING, "Option descriptor %d not found.\n", option); + HG_VLOG_MINI_1(LOG_LEVEL_WARNING, "Option descriptor %d not found.\n", option); return SANE_STATUS_UNSUPPORTED; } else if (!value && desc->type != SANE_TYPE_BUTTON) { - HG_VLOG_MINI_2(HG_LOG_LEVEL_WARNING, "Option descriptor %d(%s) need a value!.\n", option, desc->title); + HG_VLOG_MINI_2(LOG_LEVEL_WARNING, "Option descriptor %d(%s) need a value!.\n", option, desc->title); return SANE_STATUS_INVAL; } @@ -1938,7 +1950,7 @@ SANE_Status hg_sane_middleware::set_option(SANE_Handle h, SANE_Int option, SANE_ double dv = .0f; bool bv = false; int size = desc->size; - hg_err err = HG_ERR_OK; + scanner_err err = SCANNER_ERR_OK; if (desc->type == SANE_TYPE_BOOL) { @@ -1968,28 +1980,28 @@ SANE_Status hg_sane_middleware::set_option(SANE_Handle h, SANE_Int option, SANE_ v = hg_sane_middleware::option_value_2_string(desc->type, value); if (prev == v) { - HG_VLOG_MINI_3(HG_LOG_LEVEL_DEBUG_INFO, "-->Set option(%d - %s) value: %s\n", option, desc->title, v.c_str()); + HG_VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "-->Set option(%d - %s) value: %s\n", option, desc->title, v.c_str()); } else { - HG_VLOG_4(HG_LOG_LEVEL_DEBUG_INFO, 512, "-->Set option(%d - %s) value: %s(Applied: %s)\n", option, desc->title, prev.c_str(), v.c_str()); + HG_VLOG_4(LOG_LEVEL_DEBUG_INFO, 512, "-->Set option(%d - %s) value: %s(Applied: %s)\n", option, desc->title, prev.c_str(), v.c_str()); } - if (err == HG_ERR_OK) + if (err == SCANNER_ERR_OK) { - err = (hg_err)something_after_do(handle, dev.dev_name.c_str(), option, v.c_str()); + err = (scanner_err)something_after_do(handle, dev.dev_name.c_str(), option, v.c_str()); } - else if (err == HG_ERR_NOT_EXACT) + else if (err == SCANNER_ERR_NOT_EXACT) { - err = (hg_err)(something_after_do(handle, dev.dev_name.c_str(), option, v.c_str()) | SANE_INFO_INEXACT); + err = (scanner_err)(something_after_do(handle, dev.dev_name.c_str(), option, v.c_str()) | SANE_INFO_INEXACT); } - else if (err == HG_ERR_CONFIGURATION_CHANGED) + else if (err == SCANNER_ERR_CONFIGURATION_CHANGED) { - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "the setting '%s' affects other options value, RELOAD ...\n", desc->title); - on_HG_ERR_CONFIGURATION_CHANGED(handle, dev.dev_name.c_str()); - err = (hg_err)SANE_INFO_RELOAD_OPTIONS; + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "the setting '%s' affects other options value, RELOAD ...\n", desc->title); + on_SCANNER_ERR_CONFIGURATION_CHANGED(handle, dev.dev_name.c_str()); + err = (scanner_err)SANE_INFO_RELOAD_OPTIONS; } - else if (err == HG_ERR_ACCESS_DENIED) + else if (err == SCANNER_ERR_ACCESS_DENIED) status = SANE_STATUS_ACCESS_DENIED; else status = SANE_STATUS_INVAL; @@ -2010,14 +2022,14 @@ SANE_Status hg_sane_middleware::io_control(SANE_Handle h, unsigned long code, vo // return SANE_STATUS_INVAL; int ret = hg_scanner_control(handle, code, data, len); - if (ret == HG_ERR_CONFIGURATION_CHANGED) + if (ret == SCANNER_ERR_CONFIGURATION_CHANGED) { int nc = code; - HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "the setting '0x%08x' affects other options value, RELOAD ...\n", nc); - on_HG_ERR_CONFIGURATION_CHANGED(handle, od.dev_name.c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "the setting '0x%08x' affects other options value, RELOAD ...\n", nc); + on_SCANNER_ERR_CONFIGURATION_CHANGED(handle, od.dev_name.c_str()); } - return local_utility::hg_err_2_sane_statu(ret); + return local_utility::scanner_err_2_sane_statu(ret); } /// @@ -2065,7 +2077,7 @@ bool hg_sane_middleware::is_enable_and(const std::vector& master, std: std::vector::iterator it = std::find(curvals.begin(), curvals.end(), master[i].option_no); if (it == curvals.end()) { - HG_VLOG_MINI_1(HG_LOG_LEVEL_WARNING, "option %d's current value is not found, other options depend it maybe in wrong status.\n", master[i].option_no); + HG_VLOG_MINI_1(LOG_LEVEL_WARNING, "option %d's current value is not found, other options depend it maybe in wrong status.\n", master[i].option_no); continue; } enabled &= master[i].compare_val(it->val.c_str(), master[i].limit_l.c_str(), master[i].limit_r.c_str()); @@ -2082,7 +2094,7 @@ bool hg_sane_middleware::is_enable_or(const std::vector& master, std:: std::vector::iterator it = std::find(curvals.begin(), curvals.end(), master[i].option_no); if (it == curvals.end()) { - HG_VLOG_MINI_1(HG_LOG_LEVEL_WARNING, "option %d's current value is not found, other options depend it maybe in wrong status.\n", master[i].option_no); + HG_VLOG_MINI_1(LOG_LEVEL_WARNING, "option %d's current value is not found, other options depend it maybe in wrong status.\n", master[i].option_no); continue; } @@ -2390,7 +2402,7 @@ void hg_sane_middleware::free_control_enable_data(OPTEN* opt) free(opt); } } -void hg_sane_middleware::on_HG_ERR_CONFIGURATION_CHANGED(scanner_handle handle, const char* dev_name) +void hg_sane_middleware::on_SCANNER_ERR_CONFIGURATION_CHANGED(scanner_handle handle, const char* dev_name) { std::vector changed; reload_current_value(handle, &changed); @@ -2428,7 +2440,7 @@ extern "C" { // avoid compiler exporting name in C++ style !!! local_utility::stop_work(); hg_sane_middleware::clear(); - hg_log::log(HG_LOG_LEVEL_FATAL, (hg_log::current_time() + " hgsane exited.\n").c_str()); + hg_log::log(LOG_LEVEL_FATAL, (hg_log::current_time() + " hgsane exited.\n").c_str()); } SANE_Status inner_sane_get_devices(const SANE_Device*** device_list, SANE_Bool local_only) { @@ -2459,13 +2471,13 @@ extern "C" { // avoid compiler exporting name in C++ style !!! } SANE_Status inner_sane_start(SANE_Handle handle) { - HG_VLOG_MINI_1(HG_LOG_LEVEL_ALL, "[%s] - sane_start\n", hg_log::format_current_thread_id().c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_ALL, "[%s] - sane_start\n", hg_log::format_current_thread_id().c_str()); return hg_sane_middleware::instance()->start(handle, NULL); } SANE_Status inner_sane_read(SANE_Handle handle, SANE_Byte* data, SANE_Int max_length, SANE_Int* length) { - // HG_VLOG_MINI_1(HG_LOG_LEVEL_ALL, "[%s] - sane_read\n", hg_log::format_current_thread_id().c_str()); + // HG_VLOG_MINI_1(LOG_LEVEL_ALL, "[%s] - sane_read\n", hg_log::format_current_thread_id().c_str()); if (!length) length = &max_length; @@ -2480,7 +2492,7 @@ extern "C" { // avoid compiler exporting name in C++ style !!! } SANE_Status inner_sane_set_io_mode(SANE_Handle handle, SANE_Bool non_blocking) { - HG_VLOG_MINI_1(HG_LOG_LEVEL_ALL, "[%s] - sane_set_io_mode\n", hg_log::format_current_thread_id().c_str()); + HG_VLOG_MINI_1(LOG_LEVEL_ALL, "[%s] - sane_set_io_mode\n", hg_log::format_current_thread_id().c_str()); return non_blocking ? SANE_STATUS_UNSUPPORTED : SANE_STATUS_GOOD; } diff --git a/hgsane/sane_hg_mdw.h b/hgsane/sane_hg_mdw.h index ed1b1e4..35eeedf 100644 --- a/hgsane/sane_hg_mdw.h +++ b/hgsane/sane_hg_mdw.h @@ -18,6 +18,11 @@ #define ENABLE_SLAVE_OPTION_CONTROL #define ALIGN_INT(n) ((((n) + sizeof(int) - 1) / sizeof(int)) * sizeof(int)) +#ifdef OEM_HANWANG +#define hg_sane_middleware hw_sane_middleware +#elif defined(OEM_LISICHENG) +#define hg_sane_middleware lsc_sane_middleware +#endif class json; class hg_sane_middleware @@ -57,7 +62,7 @@ class hg_sane_middleware static hg_sane_middleware *inst_; static const SANE_Device** dev_list_; - static const SANE_Device** to_sane_device(HGScannerInfo* hgscanner, int count); // 将驱动层传回的设备列表数据，转换为标准SANE协议的设备列表 + static const SANE_Device** to_sane_device(ScannerInfo* hgscanner, int count); // 将驱动层传回的设备列表数据，转换为标准SANE协议的设备列表 static void free_sane_device(SANE_Device** dev); // 释放由to_sane_device返回的指针 static void device_pnp(int sig); // 热插拔事件监控 static SANE_Fixed double_2_sane_fixed(double v); @@ -142,7 +147,7 @@ class hg_sane_middleware int something_after_do(scanner_handle h, const char* dev_name, int option_no, const char* cur_val); OPTEN* get_control_enalbe_data(const SLAVEOP& slave); void free_control_enable_data(OPTEN* opt); - void on_HG_ERR_CONFIGURATION_CHANGED(scanner_handle handle, const char* dev_name); + void on_SCANNER_ERR_CONFIGURATION_CHANGED(scanner_handle handle, const char* dev_name); /// 关联项处理结束 protected: diff --git a/sdk/hginclude/hg_log.h b/sdk/hginclude/hg_log.h index c117f42..92888e1 100644 --- a/sdk/hginclude/hg_log.h +++ b/sdk/hginclude/hg_log.h @@ -11,19 +11,29 @@ #define bzero(a, l) memset(a, 0, l) #endif +#ifdef OEM_HANWANG +#define hg_log hw_log +#define hg_log_type hw_log_type +#define hg_log_level hw_log_level +#elif defined(OEM_LISICHENG) +#define hg_log lsc_log +#define hg_log_type lsc_log_type +#define hg_log_level lsc_log_level +#endif + enum hg_log_type { - HG_LOG_TYPE_NONE = 0, // no logging - HG_LOG_TYPE_CONSOLE, // print to console - HG_LOG_TYPE_FILE, // write log into file - HG_LOG_TYPE_CALLBACK, // invoke callback log_callback + 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 }; enum hg_log_level { - HG_LOG_LEVEL_ALL = 0, - HG_LOG_LEVEL_DEBUG_INFO, - HG_LOG_LEVEL_WARNING, - HG_LOG_LEVEL_FATAL, + LOG_LEVEL_ALL = 0, + LOG_LEVEL_DEBUG_INFO, + LOG_LEVEL_WARNING, + LOG_LEVEL_FATAL, }; typedef void (*log_callback)(hg_log_level, const char* info); @@ -48,10 +58,10 @@ extern "C" // // level - log level. only the information can be logged if it's level was not less than this level // - // log_file - when type was 'HG_LOG_TYPE_FILE', specify the logging file path. default is "/tmp/hgscanner.log" + // log_file - when type was 'LOG_TYPE_FILE', specify the logging file path. default is "/tmp/hgscanner.log" // - // Return: 0 - success, or -1 in HG_LOG_TYPE_FILE and log_file cannot be created - int init(hg_log_type type = HG_LOG_TYPE_NONE, hg_log_level level = HG_LOG_LEVEL_DEBUG_INFO, char* log_file = 0); + // Return: 0 - success, or -1 in LOG_TYPE_FILE and log_file cannot be created + int init(hg_log_type type = LOG_TYPE_NONE, hg_log_level level = LOG_LEVEL_DEBUG_INFO, char* log_file = 0); void log(hg_log_level level, const char* info); diff --git a/sdk/hginclude/huagaoxxx_warraper_ex.h b/sdk/hginclude/huagaoxxx_warraper_ex.h index 525ec1f..ff15200 100644 --- a/sdk/hginclude/huagaoxxx_warraper_ex.h +++ b/sdk/hginclude/huagaoxxx_warraper_ex.h @@ -83,9 +83,42 @@ /// /// 错误代码 #define MAX_NAME_LEN 256 +#ifdef OEM_HANWANG +#define hg_scanner_initialize hw_scanner_initialize +#define hg_scanner_uninitialize hw_scanner_uninitialize +#define hg_scanner_get_version hw_scanner_get_version +#define hg_scanner_enum hw_scanner_enum +#define hg_scanner_open hw_scanner_open +#define hg_scanner_close hw_scanner_close +#define hg_scanner_get_parameter hw_scanner_get_parameter +#define hg_scanner_set_parameter hw_scanner_set_parameter +#define hg_scanner_start hw_scanner_start +#define hg_scanner_stop hw_scanner_stop +#define hg_scanner_get_img_info hw_scanner_get_img_info +#define hg_scanner_read_img_data hw_scanner_read_img_data +#define hg_scanner_get_status hw_scanner_get_status +#define hg_scanner_reset hw_scanner_reset +#define hg_scanner_control hw_scanner_control +#elif defined(OEM_LISICHENG) +#define hg_scanner_initialize lsc_scanner_initialize +#define hg_scanner_uninitialize lsc_scanner_uninitialize +#define hg_scanner_get_version lsc_scanner_get_version +#define hg_scanner_enum lsc_scanner_enum +#define hg_scanner_open lsc_scanner_open +#define hg_scanner_close lsc_scanner_close +#define hg_scanner_get_parameter lsc_scanner_get_parameter +#define hg_scanner_set_parameter lsc_scanner_set_parameter +#define hg_scanner_start lsc_scanner_start +#define hg_scanner_stop lsc_scanner_stop +#define hg_scanner_get_img_info lsc_scanner_get_img_info +#define hg_scanner_read_img_data lsc_scanner_read_img_data +#define hg_scanner_get_status lsc_scanner_get_status +#define hg_scanner_reset lsc_scanner_reset +#define hg_scanner_control lsc_scanner_control +#endif -typedef struct _hg_device +typedef struct _device { char name[MAX_NAME_LEN]; // 设备ANSI名称，驱动需要保证该名称唯一， // 即使在有几台同类设备同时连接上时，也能通过该名称访问指定的设备 @@ -93,7 +126,7 @@ typedef struct _hg_device char vendor[MAX_NAME_LEN]; // 设备制造商 char model[MAX_NAME_LEN]; // model name char type[MAX_NAME_LEN]; // device type -}HGScannerInfo; +}ScannerInfo; // hg_scanner_control 控制码及参数 // @@ -173,7 +206,7 @@ extern "C"{ // reserve - 保留 // // Return: 状态码 - hg_err hg_scanner_initialize(sane_callback callback, void* reserve); + scanner_err hg_scanner_initialize(sane_callback callback, void* reserve); // Function: 退出进程前启动驱动清理工作 // @@ -198,7 +231,7 @@ extern "C"{ // // Parameter: scanner_list - 用户分配的空间 // - // count - [in]：'scanner_list' 的以HGScannerInfo为单位的空间大小； [out]：scanner_list 中返回的设备个数 + // count - [in]：'scanner_list' 的以ScannerInfo为单位的空间大小； [out]：scanner_list 中返回的设备个数 // 当'scanner_list'为NULL或者空间小于所需最小长度时，返回所需要的HGScannerInfo元素数 // 该参数必须非空，如果为NULL，则会返回 EPARAMETERINVAL 的错误 // @@ -207,7 +240,7 @@ extern "C"{ // Return: 错误代码, E_OK or E_INSUFFICIENTMEM or E_PARAMETERINVAL // // NOTE: 'name'空间由用户分配，如果空间太小(包含传入NULL)，会在len中返回所需要的最小空间字节数，并返回 EINSUFFICIENTMEM - hg_err hg_scanner_enum(HGScannerInfo* scanner_list, long* count, bool local_only); + scanner_err hg_scanner_enum(ScannerInfo* scanner_list, long* count, bool local_only); // Function: 打开指定的设备 // @@ -228,7 +261,7 @@ extern "C"{ // 通常用于在需要第三方资源身份验证的时候返回，如果不需要或者已经成功打开，则可忽略该返回内容 // // Return: 错误代码，E_OK or E_ACCESSDENIED or E_DEVICENOTFOUND or E_NOTSUPPORT - hg_err hg_scanner_open(scanner_handle* h, const char* name, bool shared, const char* user, const char* pwd, const char* check, char* rsc/*rsc[80]*/); + scanner_err hg_scanner_open(scanner_handle* h, const char* name, bool shared, const char* user, const char* pwd, const char* check, char* rsc/*rsc[80]*/); // Function: 关闭打开的设备 // @@ -238,7 +271,7 @@ extern "C"{ // 为true时，则立即关闭设备并返回成功） // // Return: 错误代码，E_OK or E_HASDATAYET - hg_err hg_scanner_close(scanner_handle h, bool force); + scanner_err hg_scanner_close(scanner_handle h, bool force); // Function: 获取设备的配置参数说明及当前的设置值 // @@ -257,7 +290,7 @@ extern "C"{ // Return: 错误代码，E_OK or E_INSUFFICIENTMEM or E_PARAMETERINVAL or E_DEVICENOTFOUND or E_OUTOFRANGE // // NOTE: 'data'空间由用户分配，如果空间太小(包含传入NULL)，会在len中返回所需要的最小空间字节数，并返回 EINSUFFICIENTMEM - hg_err hg_scanner_get_parameter(scanner_handle h, unsigned param_no, char* json_data, long* len); + scanner_err hg_scanner_get_parameter(scanner_handle h, unsigned param_no, char* json_data, long* len); // Function: 设置设备的配置参数 // @@ -278,7 +311,7 @@ extern "C"{ // // NOTE: 如果传入的参数不精确，则由驱动选择合适的参数设置并写入到data中，返回 E_NOTEXACT 的错误码。用户需要根据该参数更新UI // 以共享方式打开的设备，没有设置权限，会返回 E_ACCESSDENIED 错误。 - hg_err hg_scanner_set_parameter(scanner_handle h, unsigned param_no, void* data, long len); + scanner_err hg_scanner_set_parameter(scanner_handle h, unsigned param_no, void* data, long len); // Function: 启动设备工作 // @@ -289,7 +322,7 @@ extern "C"{ // Return: 错误代码，E_OK or E_NOTSUPPORT or E_DEVICENOTFOUND(句柄非法), E_COVER_OPEN, E_PAPER_JAMMED, E_DEVICEBUSY // // NOTE: 支持异步IO时，事件需要有[新图片开始(带新图片头信息），新图片数据，出现错误……] 几种基本类型 - hg_err hg_scanner_start(scanner_handle h, void* async_event,int num); + scanner_err hg_scanner_start(scanner_handle h, void* async_event,int num); // Function: 扫描过程中停止设备工作 // @@ -298,7 +331,7 @@ extern "C"{ // num - 设置扫描页数，-1全部扫描 // // Return: 错误代码，E_OK or E_DEVICENOTFOUND(句柄非法) - hg_err hg_scanner_stop(scanner_handle h); + scanner_err hg_scanner_stop(scanner_handle h); // Function: 读取图片信息 // @@ -309,7 +342,7 @@ extern "C"{ // len - 'bmi' 大小 // // Return: 错误代码，E_OK or E_NOTSTART - hg_err hg_scanner_get_img_info(scanner_handle h, SANE_Parameters* bmi, long len); + scanner_err hg_scanner_get_img_info(scanner_handle h, SANE_Parameters* bmi, long len); // Function: 读取图片数据 // @@ -320,7 +353,7 @@ extern "C"{ // len - [in]：'data' 大小；[out]：'data'中返回的数据字节数 // // Return: 错误代码。如果为异步IO，没有数据时会立即返回，并返回代码 E_IOPENDING - hg_err hg_scanner_read_img_data(scanner_handle h, unsigned char* data, long* len); + scanner_err hg_scanner_read_img_data(scanner_handle h, unsigned char* data, long* len); // Function: 获取设备状态 // @@ -329,7 +362,7 @@ extern "C"{ // setstutas -设置需要获取状态的条件 // // Return: 状态码 - hg_err hg_scanner_get_status(scanner_handle h, int setstutas); + scanner_err hg_scanner_get_status(scanner_handle h, int setstutas); // Function: 复位设备 // @@ -338,7 +371,7 @@ extern "C"{ // Return: 错误码 // // NOTE: 从错误中恢复到正常状态 - hg_err hg_scanner_reset(scanner_handle h); + scanner_err hg_scanner_reset(scanner_handle h); // Function: 直接访问控制 // @@ -351,7 +384,7 @@ extern "C"{ // len - data中数据长度。如果是获取操作时，长度小于所需要的长度，则返回需要的长度且返回 E_INSUFFICIENTMEM 的错误 // // Return: 错误码 - hg_err hg_scanner_control(scanner_handle h, unsigned long code, void* data, unsigned *len); + scanner_err hg_scanner_control(scanner_handle h, unsigned long code, void* data, unsigned *len); #ifdef __cplusplus }