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

根据产品名称，更改对应的标识符

This commit is contained in:
gb 2022-05-17 15:04:55 +08:00
parent 335ebea58b
commit 3984528192
24 changed files with 1710 additions and 1615 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
build.sh
View File

@ -4,26 +4,19 @@ sys=${sys%% *}
echo "${1}" echo "${1}"
if [ "${1}" == "hw" ]; then if [ "${1}" == "hw" ]; then
sed -i "s/-DOEM_HUAGAO/-DOEM_HANWANG/g" hgsane/CMakeLists.txt sed -ibkp "s/-DOEM_HUAGAO/-DOEM_HANWANG/g" hgsane/CMakeLists.txt
sed -i "s/-DOEM_HUAGAO/-DOEM_HANWANG/g" hgdriver/wrapper/CMakeLists.txt sed -i "s/hgsane/hwsane/g" hgsane/CMakeLists.txt
sed -i "s/-DOEM_HUAGAO/-DOEM_HANWANG/g" hgdriver/hgdev/CMakeLists.txt sed -i "s/hgdriver/hwdriver/g" hgsane/CMakeLists.txt
sed -i "s/-DOEM_LISICHENG/-DOEM_HANWANG/g" hgsane/CMakeLists.txt sed -ibkp "s/-DOEM_HUAGAO/-DOEM_HANWANG/g" hgdriver/hgdev/CMakeLists.txt
sed -i "s/-DOEM_LISICHENG/-DOEM_HANWANG/g" hgdriver/wrapper/CMakeLists.txt sed -ibkp "s/-DOEM_HUAGAO/-DOEM_HANWANG/g" hgdriver/wrapper/CMakeLists.txt
sed -i "s/-DOEM_LISICHENG/-DOEM_HANWANG/g" hgdriver/hgdev/CMakeLists.txt sed -i "s/hgdriver/hwdriver/g" hgdriver/wrapper/CMakeLists.txt
elif [ "${1}" == "lsc" ]; then elif [ "${1}" == "lsc" ]; then
sed -i "s/-DOEM_HUAGAO/-DOEM_LISICHENG/g" hgsane/CMakeLists.txt sed -ibkp "s/-DOEM_HUAGAO/-DOEM_LISICHENG/g" hgsane/CMakeLists.txt
sed -i "s/-DOEM_HUAGAO/-DOEM_LISICHENG/g" hgdriver/wrapper/CMakeLists.txt sed -i "s/hgsane/lscsane/g" hgsane/CMakeLists.txt
sed -i "s/-DOEM_HUAGAO/-DOEM_LISICHENG/g" hgdriver/hgdev/CMakeLists.txt sed -i "s/hgdriver/lscdriver/g" hgsane/CMakeLists.txt
sed -i "s/-DOEM_HANWANG/-DOEM_LISICHENG/g" hgsane/CMakeLists.txt sed -ibkp "s/-DOEM_HUAGAO/-DOEM_LISICHENG/g" hgdriver/hgdev/CMakeLists.txt
sed -i "s/-DOEM_HANWANG/-DOEM_LISICHENG/g" hgdriver/wrapper/CMakeLists.txt sed -ibkp "s/-DOEM_HUAGAO/-DOEM_LISICHENG/g" hgdriver/wrapper/CMakeLists.txt
sed -i "s/-DOEM_HANWANG/-DOEM_LISICHENG/g" hgdriver/hgdev/CMakeLists.txt sed -i "s/hgdriver/lscdriver/g" hgdriver/wrapper/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
fi fi
echo "------------------------------change cmake path:$1--------------------" echo "------------------------------change cmake path:$1--------------------"
@ -47,3 +40,6 @@ fi
make 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

26
hgdriver/hgdev/hg_ipc.cpp
View File

@ -78,7 +78,7 @@ platform_event::platform_event() : waiting_(false), dbg_info_("")
if (err == -1) if (err == -1)
{ {
err = errno; 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() platform_event::~platform_event()
@ -94,7 +94,7 @@ bool platform_event::wait(unsigned timeout)
{ {
bool waited = true; 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; waiting_ = true;
if (timeout == USB_TIMEOUT_INFINITE) if (timeout == USB_TIMEOUT_INFINITE)
sem_wait(&sem_); sem_wait(&sem_);
@ -105,7 +105,7 @@ bool platform_event::wait(unsigned timeout)
to.tv_nsec = (long)((timeout % 1000) * 1000 * 1000); to.tv_nsec = (long)((timeout % 1000) * 1000 * 1000);
waited = sem_timedwait(&sem_, &to) == 0; 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; waiting_ = false;
return waited; 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) 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_; 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(); init();
} }
@ -163,11 +163,11 @@ void shared_memory::init(void)
obj = shmget(key_, bytes_, 0600); obj = shmget(key_, bytes_, 0600);
if(obj == -1) if(obj == -1)
obj = shmget(key_, bytes_, 0); 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; obj_ = (void*)obj;
std::string prev(read()), proc(""); 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()) if(prev.length())
{ {
proc = prev; proc = prev;
@ -192,17 +192,17 @@ void shared_memory::init(void)
first_ = true; first_ = true;
clear(); clear();
obj = shmget(key_, bytes_, IPC_EXCL | IPC_CREAT | 0600); 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 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; return;
} }
} }
obj_ = (void*)obj; 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 #endif
if(first_) if(first_)
@ -248,7 +248,7 @@ char* shared_memory::get_buf(void)
#else #else
int* h = (int*)&obj_; int* h = (int*)&obj_;
char* buf = (char*)shmat(*h, 0, 0); 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 #endif
return buf; return buf;
@ -287,11 +287,11 @@ std::string shared_memory::get_proc_name_by_pid(pid_t pid)
} }
if (sizeof(pid) > 4 && v[1]) 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 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; return ret;
@ -328,7 +328,7 @@ std::string shared_memory::read(void)
int shared_memory::write(const char* data, size_t len) int shared_memory::write(const char* data, size_t len)
{ {
if (len > bytes_) if (len > bytes_)
return HG_ERR_INSUFFICIENT_MEMORY; return SCANNER_ERR_INSUFFICIENT_MEMORY;
char* buf = get_buf(); char* buf = get_buf();
int off = sizeof(len); int off = sizeof(len);

628
hgdriver/hgdev/hg_scanner.cpp
View File

File diff suppressed because it is too large Load Diff

11
hgdriver/hgdev/hg_scanner.h
View File

@ -88,6 +88,11 @@ enum
}; };
#define MAPPING_FUNCTION_IN_BASE // 定义该标志，各子类不必再初始化setting_map_数组 #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 class hg_scanner
{ {
@ -249,7 +254,7 @@ protected:
int on_scann_error(int err); // 返回“0”忽略错误继续执行，其它值则停止后续工作 int on_scann_error(int err); // 返回“0”忽略错误继续执行，其它值则停止后续工作
// callback to ui ... // 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); 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); 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); hg_scanner(ScannerSerial serial, const char* dev_name, usb_io* io);
virtual ~hg_scanner(); virtual ~hg_scanner();
static std::string strerr(hg_err err); static std::string strerr(scanner_err err);
static std::string error_description(hg_err err); static std::string error_description(scanner_err err);
static std::string temporary_file(char* tail = NULL, char* head = NULL); static std::string temporary_file(char* tail = NULL, char* head = NULL);
static int save_2_tempory_file(std::shared_ptr<std::vector<char>> data, std::string* path_file, unsigned int index = 0); static int save_2_tempory_file(std::shared_ptr<std::vector<char>> data, std::string* path_file, unsigned int index = 0);

366
hgdriver/hgdev/hg_scanner_200.cpp
View File

File diff suppressed because one or more lines are too long

6
hgdriver/hgdev/hg_scanner_200.h
View File

@ -12,6 +12,12 @@
#include "hg_scanner.h" #include "hg_scanner.h"
#include "../../sdk/hginclude/hg_log.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 class hg_scanner_200 : public hg_scanner
{ {

460
hgdriver/hgdev/hg_scanner_239.cpp
View File

File diff suppressed because it is too large Load Diff

7
hgdriver/hgdev/hg_scanner_239.h
View File

@ -12,6 +12,13 @@
#include "hg_scanner.h" #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 class hg_scanner_239 : public hg_scanner
{ {
//BlockingQueue<std::shared_ptr<std::vector<unsigned char>>> final_imgs_; // JPG ... //BlockingQueue<std::shared_ptr<std::vector<unsigned char>>> final_imgs_; // JPG ...

356
hgdriver/hgdev/hg_scanner_300.cpp
View File

File diff suppressed because one or more lines are too long

6
hgdriver/hgdev/hg_scanner_300.h
View File

@ -13,6 +13,12 @@
#include "../../sdk/hginclude/hg_log.h" #include "../../sdk/hginclude/hg_log.h"
#include "PaperSize.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 class hg_scanner_300 : public hg_scanner
{ {

388
hgdriver/hgdev/hg_scanner_400.cpp
View File

File diff suppressed because one or more lines are too long

5
hgdriver/hgdev/hg_scanner_400.h
View File

@ -14,6 +14,11 @@
#include "PaperSize.h" #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 class hg_scanner_400 : public hg_scanner
{ {

106
hgdriver/hgdev/image_process.cpp
View File

@ -16,16 +16,16 @@
#include "../ImageProcess/ImageApplyHeaders.h" #include "../ImageProcess/ImageApplyHeaders.h"
#include "ImageMultiOutput.h" #include "ImageMultiOutput.h"
#include "PaperSize.h" #include "PaperSize.h"
//不加上“extern "C"”会导致ARM平台链接不上库
#ifdef WIN32
#include "scanner_manager.h"
#include "ocr/hanwangOCRdetect.h"
#else
#include <dlfcn.h>
extern "C" extern "C"
{ {
#include "ocr/hanwangOCRdetect.h" #include "ocr/hanwangOCRdetect.h"
} }
#ifdef WIN32
#include "scanner_manager.h"
#else
#include <dlfcn.h>
#endif #endif
using namespace std; using namespace std;
@ -88,7 +88,7 @@ namespace hg_imgproc
{ {
buffer_.reset(new std::vector<char >(*buff)); buffer_.reset(new std::vector<char >(*buff));
mats_.clear(); mats_.clear();
return HG_ERR_OK; return SCANNER_ERR_OK;
} }
int load_file(const char* path_file) int load_file(const char* path_file)
{ {
@ -96,7 +96,7 @@ namespace hg_imgproc
FILE* src = fopen(path_file, "rb"); FILE* src = fopen(path_file, "rb");
if (!src) if (!src)
return HG_ERR_OPEN_FILE_FAILED; return SCANNER_ERR_OPEN_FILE_FAILED;
long len = 0; long len = 0;
fseek(src, 0, SEEK_END); fseek(src, 0, SEEK_END);
@ -106,7 +106,7 @@ namespace hg_imgproc
{ {
fclose(src); fclose(src);
return HG_ERR_INSUFFICIENT_MEMORY; return SCANNER_ERR_INSUFFICIENT_MEMORY;
} }
raw_data_.reset(new std::string()); raw_data_.reset(new std::string());
@ -114,7 +114,7 @@ namespace hg_imgproc
fread(&(*raw_data_)[0], 1, len, src); fread(&(*raw_data_)[0], 1, len, src);
fclose(src); fclose(src);
return HG_ERR_OK; return SCANNER_ERR_OK;
} }
// image-processing // image-processing
@ -122,7 +122,7 @@ namespace hg_imgproc
int decode(int pid) int decode(int pid)
{ {
if (!buffer_) if (!buffer_)
return HG_ERR_NO_DATA; return SCANNER_ERR_NO_DATA;
size_t origin = buffer_->size(); size_t origin = buffer_->size();
std::vector<std::shared_ptr<std::vector<char>>> buffs; std::vector<std::shared_ptr<std::vector<char>>> buffs;
@ -164,7 +164,7 @@ namespace hg_imgproc
//("/home/huagao/Desktop/1.jpg",mat); //("/home/huagao/Desktop/1.jpg",mat);
if (mat.empty()) 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; continue;
} }
if(pid == 0x100 || pid == 0x200 || pid == 0x139 || pid == 0x239) if(pid == 0x100 || pid == 0x200 || pid == 0x139 || pid == 0x239)
@ -195,16 +195,16 @@ namespace hg_imgproc
} }
catch (const std::exception& e) catch (const std::exception& e)
{ {
HG_LOG(HG_LOG_LEVEL_FATAL, e.what()); HG_LOG(LOG_LEVEL_FATAL, e.what());
} }
} }
buffs.clear(); 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) if(mats_.size() == 0)
{ {
return HG_ERR_NO_DATA; return SCANNER_ERR_NO_DATA;
} }
return HG_ERR_OK; return SCANNER_ERR_OK;
} }
public: public:
int correct_text(void) int correct_text(void)
@ -214,7 +214,7 @@ namespace hg_imgproc
rot.apply(mats_, img_conf_.is_duplex); 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()) if(!matex.mat.empty())
mats_.push_back(matex.mat); mats_.push_back(matex.mat);
} }
return HG_ERR_OK; return SCANNER_ERR_OK;
} }
int fadeback(int range,bool is_duplex) 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) 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) int multi_out(int out_type)
@ -328,7 +328,7 @@ namespace hg_imgproc
// cv::imwrite(filename,mat[j]); // cv::imwrite(filename,mat[j]);
} }
} }
return HG_ERR_OK; return SCANNER_ERR_OK;
} }
int multi_out_red() int multi_out_red()
{ {
@ -351,11 +351,11 @@ namespace hg_imgproc
// cv::imwrite(filename,mats_[i]); // cv::imwrite(filename,mats_[i]);
// printf("fadeback.size :%d ,filename is =%s\r\n",mats_.size(),filename.c_str()); // 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 auto_matic_color(int color_type)
{ {
int ret = HG_ERR_OK; int ret = SCANNER_ERR_OK;
std::vector<cv::Mat> mats(mats_); std::vector<cv::Mat> mats(mats_);
mats_.clear(); mats_.clear();
for(size_t i = 0;i < mats.size();i++) for(size_t i = 0;i < mats.size();i++)
@ -373,7 +373,7 @@ namespace hg_imgproc
/*pixtype 0 colcor; 1 gray; 2 bw*/ /*pixtype 0 colcor; 1 gray; 2 bw*/
int auto_crop() int auto_crop()
{ {
int ret = HG_ERR_OK; int ret = SCANNER_ERR_OK;
std::vector<cv::Mat> mats(mats_); std::vector<cv::Mat> mats(mats_);
mats_.clear(); mats_.clear();
@ -390,7 +390,7 @@ namespace hg_imgproc
} }
int fillhole() int fillhole()
{ {
int ret = HG_ERR_OK; int ret = SCANNER_ERR_OK;
std::vector<cv::Mat> mats(mats_); std::vector<cv::Mat> mats(mats_);
mats_.clear(); mats_.clear();
@ -404,7 +404,7 @@ namespace hg_imgproc
} }
int resolution_change() int resolution_change()
{ {
int ret = HG_ERR_OK; int ret = SCANNER_ERR_OK;
std::vector<cv::Mat> mats(mats_); std::vector<cv::Mat> mats(mats_);
mats_.clear(); mats_.clear();
@ -429,7 +429,7 @@ namespace hg_imgproc
} }
int croprect() int croprect()
{ {
int ret = HG_ERR_OK; int ret = SCANNER_ERR_OK;
std::vector<cv::Mat> mats(mats_); std::vector<cv::Mat> mats(mats_);
mats_.clear(); mats_.clear();
@ -444,7 +444,7 @@ namespace hg_imgproc
} }
int channel() int channel()
{ {
int ret = HG_ERR_OK; int ret = SCANNER_ERR_OK;
std::vector<cv::Mat> mats(mats_); std::vector<cv::Mat> mats(mats_);
mats_.clear(); mats_.clear();
@ -460,7 +460,7 @@ namespace hg_imgproc
} }
int customgamma(bool is_customgamma,unsigned char* table,int tableLength) int customgamma(bool is_customgamma,unsigned char* table,int tableLength)
{ {
int ret = HG_ERR_OK; int ret = SCANNER_ERR_OK;
std::vector<cv::Mat> mats(mats_); std::vector<cv::Mat> mats(mats_);
mats_.clear(); mats_.clear();
@ -489,7 +489,7 @@ namespace hg_imgproc
//防止渗<E6ADA2>? //防止渗<E6ADA2>?
int antiInflow(int permeate_lv) int antiInflow(int permeate_lv)
{ {
int ret = HG_ERR_OK; int ret = SCANNER_ERR_OK;
std::vector<cv::Mat> mats(mats_); std::vector<cv::Mat> mats(mats_);
mats_.clear(); mats_.clear();
@ -505,7 +505,7 @@ namespace hg_imgproc
//色彩校正 //色彩校正
int colorCorrection() int colorCorrection()
{ {
int ret = HG_ERR_OK; int ret = SCANNER_ERR_OK;
std::vector<cv::Mat> mats(mats_); std::vector<cv::Mat> mats(mats_);
mats_.clear(); mats_.clear();
@ -518,7 +518,7 @@ namespace hg_imgproc
//图像旋转 //图像旋转
int orentation() int orentation()
{ {
int ret = HG_ERR_OK; int ret = SCANNER_ERR_OK;
std::vector<cv::Mat> mats(mats_); std::vector<cv::Mat> mats(mats_);
mats_.clear(); mats_.clear();
mats_.resize(mats.size()); mats_.resize(mats.size());
@ -556,10 +556,10 @@ namespace hg_imgproc
#endif #endif
return ret; return ret;
} }
//除网<EFBFBD>? //除网ï¿?
int textureRemove() int textureRemove()
{ {
int ret = HG_ERR_OK; int ret = SCANNER_ERR_OK;
std::vector<cv::Mat> mats(mats_); std::vector<cv::Mat> mats(mats_);
mats_.clear(); mats_.clear();
@ -573,7 +573,7 @@ namespace hg_imgproc
//锐化 //锐化
int sharpenType() int sharpenType()
{ {
int ret = HG_ERR_OK; int ret = SCANNER_ERR_OK;
std::vector<cv::Mat> mats(mats_); std::vector<cv::Mat> mats(mats_);
mats_.clear(); mats_.clear();
@ -589,7 +589,7 @@ namespace hg_imgproc
//黑白降噪 //黑白降噪
int nosieDetach() int nosieDetach()
{ {
int ret = HG_ERR_OK; int ret = SCANNER_ERR_OK;
std::vector<cv::Mat> mats(mats_); std::vector<cv::Mat> mats(mats_);
mats_.clear(); mats_.clear();
@ -605,7 +605,7 @@ namespace hg_imgproc
//错误扩散 //错误扩散
int errorextention() int errorextention()
{ {
int ret = HG_ERR_OK; int ret = SCANNER_ERR_OK;
std::vector<cv::Mat> mats(mats_); std::vector<cv::Mat> mats(mats_);
mats_.clear(); mats_.clear();
@ -626,11 +626,11 @@ namespace hg_imgproc
int discardBlank() int discardBlank()
{ {
int ret = HG_ERR_OK; int ret = SCANNER_ERR_OK;
std::vector<cv::Mat> mats(mats_); std::vector<cv::Mat> mats(mats_);
mats_.clear(); mats_.clear();
double threshold = 40; //默认<EFBFBD>? double threshold = 40; //默认ï¿?
int edge = 150; int edge = 150;
CImageApplyDiscardBlank(threshold,edge,img_conf_.discardblank_percent); CImageApplyDiscardBlank(threshold,edge,img_conf_.discardblank_percent);
@ -646,10 +646,10 @@ namespace hg_imgproc
} }
return ret; return ret;
} }
//答题卡出<EFBFBD>? //答题å<EFBFBD>¡å‡ºï¿?
int answerSheetFilterRed() int answerSheetFilterRed()
{ {
int ret = HG_ERR_OK; int ret = SCANNER_ERR_OK;
std::vector<cv::Mat> mats(mats_); std::vector<cv::Mat> mats(mats_);
mats_.clear(); mats_.clear();
@ -664,7 +664,7 @@ namespace hg_imgproc
//对折 //对折
int fold() int fold()
{ {
int ret = HG_ERR_OK; int ret = SCANNER_ERR_OK;
std::vector<cv::Mat> mats(mats_); std::vector<cv::Mat> mats(mats_);
mats_.clear(); mats_.clear();
@ -678,7 +678,7 @@ namespace hg_imgproc
//画质 //画质
int quality(int dpi_dst) int quality(int dpi_dst)
{ {
int ret = HG_ERR_OK; int ret = SCANNER_ERR_OK;
std::vector<cv::Mat> mats(mats_); std::vector<cv::Mat> mats(mats_);
mats_.clear(); mats_.clear();
//mats_.resize(mats.size()); //mats_.resize(mats.size());
@ -690,14 +690,14 @@ namespace hg_imgproc
cv::resize(mats[i],out, cv::Size(),xy,xy); cv::resize(mats[i],out, cv::Size(),xy,xy);
mats_.push_back(out); mats_.push_back(out);
} }
return HG_ERR_OK; return SCANNER_ERR_OK;
} }
int ocr_auto_txtdirect() int ocr_auto_txtdirect()
{ {
int pDirect = -1; int pDirect = -1;
int ret = HG_ERR_OK; int ret = SCANNER_ERR_OK;
void *pHanld = NULL; void *pHanld = NULL;
#ifndef x86_64 //linux x86_64 暂时没有OCR三方 #ifndef x86_64 //linux x86_64 暂时没有OCR三方
std::vector<cv::Mat> mats(mats_); std::vector<cv::Mat> mats(mats_);
@ -710,7 +710,7 @@ namespace hg_imgproc
ret = HWOCR_GetFileDirectImage(const_cast<uchar*>(mats[i].data),mats[i].cols,mats[i].rows,mats[i].channels()== 1 ? TColorType::EGray256:TColorType::EColor16M,pHanld,&pDirect); ret = HWOCR_GetFileDirectImage(const_cast<uchar*>(mats[i].data),mats[i].cols,mats[i].rows,mats[i].channels()== 1 ? TColorType::EGray256:TColorType::EColor16M,pHanld,&pDirect);
if(ret != 0) if(ret != 0)
{ {
return HG_ERR_NO_DATA; return SCANNER_ERR_NO_DATA;
} }
if(pDirect == 1) if(pDirect == 1)
@ -748,12 +748,12 @@ namespace hg_imgproc
//cv::imwrite(std::to_string(i++)+"_final.jpg",out.mat); //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) int get_final_data(LPIMGHEAD pimh, void** buf, int index)
{ {
if ((index < 0 || index >= mats_.size())) if ((index < 0 || index >= mats_.size()))
return HG_ERR_NO_DATA; return SCANNER_ERR_NO_DATA;
pimh->width = mats_[index].cols; pimh->width = mats_[index].cols;
pimh->height = mats_[index].rows; pimh->height = mats_[index].rows;
@ -765,13 +765,13 @@ namespace hg_imgproc
*buf = mats_[index].data; *buf = mats_[index].data;
//printf("pimh->channels = %d \r\n",pimh->channels); //printf("pimh->channels = %d \r\n",pimh->channels);
return HG_ERR_OK; return SCANNER_ERR_OK;
} }
int get_final_data(LPIMGHEAD pimh, std::vector<unsigned char>* buf, int index) int get_final_data(LPIMGHEAD pimh, std::vector<unsigned char>* buf, int index)
{ {
if ((index < 0 || index >= mats_.size())) if ((index < 0 || index >= mats_.size()))
return HG_ERR_NO_DATA; return SCANNER_ERR_NO_DATA;
pimh->width = mats_[index].cols; pimh->width = mats_[index].cols;
pimh->height = mats_[index].rows; pimh->height = mats_[index].rows;
@ -804,15 +804,15 @@ namespace hg_imgproc
} }
//printf("pimh->channels_01 = %d \r\n",pimh->channels); //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<unsigned char> &bmpdata) int imgtypechange(std::string img_type_,void *buf,std::vector<unsigned char> &bmpdata)
{ {
int ret = HG_ERR_OK; int ret = SCANNER_ERR_OK;
if(!buf) if(!buf)
{ {
return HG_ERR_NO_DATA; return SCANNER_ERR_NO_DATA;
} }
cv::imencode(img_type_,*((cv::Mat*)buf),bmpdata); cv::imencode(img_type_,*((cv::Mat*)buf),bmpdata);
return ret; return ret;

8
hgdriver/hgdev/image_process.h
View File

@ -132,7 +132,7 @@ namespace hg_imgproc
// //
// 5 - call final to got outputing data // 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 // 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' // 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 // 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, void** buf, int index = 0);
int get_final_data(HIMGPRC himg, LPIMGHEAD pimh, std::vector<unsigned char>* buf, int index); int get_final_data(HIMGPRC himg, LPIMGHEAD pimh, std::vector<unsigned char>* buf, int index);
void release(HIMGPRC himg); void release(HIMGPRC himg);

115
hgdriver/hgdev/scanner_manager.cpp
View File

@ -23,7 +23,22 @@ static struct
std::string type; // product type std::string type; // product type
std::string rsc; // USB resource, version-addr. e.g. "USB2.0-1" 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, 0x200, SCANNER_NAME_HG_G200, "GScanO200", ""}
, {0x3072, 0x300, SCANNER_NAME_HG_G300, "GScanO400", ""} , {0x3072, 0x300, SCANNER_NAME_HG_G300, "GScanO400", ""}
, {0x3072, 0x400, SCANNER_NAME_HG_G400, "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, 0x339, SCANNER_NAME_HG_G339, "GScanO1003399", ""}
, {0x3072, 0x439, SCANNER_NAME_HG_G439, "GScanO1003399", ""} , {0x3072, 0x439, SCANNER_NAME_HG_G439, "GScanO1003399", ""}
, {0x064B, 0x7823, SCANNER_NAME_HG_G200, "GScanO200", ""} , {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; 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; // struct sysinfo si;
// if(sysinfo(&si) == 0) // 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_) if (hg_scanner_mgr::event_callback_)
return hg_scanner_mgr::event_callback_(h, ev, data, len, param); 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) 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) if (cb)
hg_scanner_mgr::async_io_enabled_ = cb(NULL, SANE_EVENT_SUPPORT_ASYNC_IO, NULL, NULL, NULL) == 0; 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_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_; 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) 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; index = i;
ev_ui = SANE_EVENT_DEVICE_ARRIVED; ev_ui = SANE_EVENT_DEVICE_ARRIVED;
de.name = g_supporting_devices[i].name.c_str(); 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) if (pid == 0x300 || pid == 0x400)
std::this_thread::sleep_for(std::chrono::milliseconds(1000)); std::this_thread::sleep_for(std::chrono::milliseconds(1000));
len = usb_manager::instance()->open(device, &io); 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); online_devices_[i].scanner->reset_io(io);
de.openned = SANE_TRUE; 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; name = it->display_name;
type = g_supporting_devices[it->ind].type; type = g_supporting_devices[it->ind].type;
h = it->scanner; 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) if (it->scanner)
it->scanner->io_disconnected(); it->scanner->io_disconnected();
else else
@ -277,7 +280,7 @@ void hg_scanner_mgr::set_appendix_info_for_about(SANE_About* about, char*& ptr,
count++; 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; hg_scanner* scanner = (hg_scanner*)h;
unsigned bytes = sizeof(SANE_About) + 40; 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; *len = bytes;
return HG_ERR_INSUFFICIENT_MEMORY; return SCANNER_ERR_INSUFFICIENT_MEMORY;
} }
// filling info to flat buffer ... // 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].content = NULL;
about->appendix[count].url = 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<OLSCANNER> devusbuf; std::vector<OLSCANNER> devusbuf;
long size = *count; long size = *count;
hg_err ret = HG_ERR_OK; scanner_err ret = SCANNER_ERR_OK;
get_online_devices(devusbuf); get_online_devices(devusbuf);
*count = devusbuf.size(); *count = devusbuf.size();
if (*count > size) if (*count > size)
{ {
ret = HG_ERR_INSUFFICIENT_MEMORY; ret = SCANNER_ERR_INSUFFICIENT_MEMORY;
} }
else else
{ {
@ -422,12 +425,12 @@ hg_err hg_scanner_mgr::hg_scanner_enum(HGScannerInfo* scanner_list, long* count,
return ret; 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<OLSCANNER> devs; std::vector<OLSCANNER> devs;
std::vector<OLSCANNER>::iterator it; std::vector<OLSCANNER>::iterator it;
usb_io* io = NULL; usb_io* io = NULL;
hg_err ret = HG_ERR_DEVICE_NOT_FOUND; scanner_err ret = SCANNER_ERR_DEVICE_NOT_FOUND;
*h = NULL; *h = NULL;
get_online_devices(devs); 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()) if (it != devs.end())
{ {
std::string msg(""); std::string msg("");
ret = (hg_err)usb_manager::instance()->open(it->dev, &io, &msg); ret = (scanner_err)usb_manager::instance()->open(it->dev, &io, &msg);
if (ret == HG_ERR_OK) if (ret == SCANNER_ERR_OK)
{ {
hg_scanner* scanner = NULL; hg_scanner* scanner = NULL;
if (g_supporting_devices[it->ind].pid == 0x100 || g_supporting_devices[it->ind].pid == 0x200) 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(); 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<std::mutex> lock(mutex_dev_); std::lock_guard<std::mutex> 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); SCAN_PTR(h)->close(force);
delete SCAN_PTR(h); 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) if (!len)
return HG_ERR_INVALID_PARAMETER; return SCANNER_ERR_INVALID_PARAMETER;
int l = *len, int l = *len,
err = SCAN_PTR(h)->get_setting(param_no, data, &l); err = SCAN_PTR(h)->get_setting(param_no, data, &l);
*len = 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) if (!len)
return HG_ERR_INVALID_PARAMETER; return SCANNER_ERR_INVALID_PARAMETER;
int l = *len, int l = *len,
err = SCAN_PTR(h)->read_image_data(data, &l); err = SCAN_PTR(h)->read_image_data(data, &l);
*len = 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) //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) if (code == IO_CTRL_CODE_ABOUT_INFO)
return get_about_info(h, data, len); return get_about_info(h, data, len);
else if (!h) else if (!h)
return HG_ERR_INVALID_PARAMETER; return SCANNER_ERR_INVALID_PARAMETER;
else 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);
} }

33
hgdriver/hgdev/scanner_manager.h
View File

@ -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;
class hg_scanner_mgr class hg_scanner_mgr
@ -69,7 +76,7 @@ class hg_scanner_mgr
void get_online_devices(std::vector<OLSCANNER>& devs); void get_online_devices(std::vector<OLSCANNER>& devs);
void set_appendix_info_for_about(SANE_About* about, char*& ptr, int& count, const char* key, const char* info, const char* url); 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: protected:
hg_scanner_mgr(); hg_scanner_mgr();
@ -82,17 +89,17 @@ public:
static void set_version(int hh, int hl, int lh, int ll); static void set_version(int hh, int hl, int lh, int ll);
public: public:
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);
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);
hg_err hg_scanner_close(scanner_handle h, bool force); scanner_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); scanner_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); scanner_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); scanner_err hg_scanner_start(scanner_handle h, void* async_event, int num);
hg_err hg_scanner_stop(scanner_handle h); scanner_err hg_scanner_stop(scanner_handle 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);
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);
hg_err hg_scanner_get_status(scanner_handle h, int setstutas); scanner_err hg_scanner_get_status(scanner_handle h, int setstutas);
hg_err hg_scanner_reset(scanner_handle h); scanner_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_control(scanner_handle h, unsigned long code, void* data, unsigned* len);
}; };

210
hgdriver/hgdev/usb_manager.cpp
View File

@ -27,15 +27,15 @@ uint8_t usb_manager::uninit_uint8 = 0x0ff;
usb_manager::usb_manager() : run_(true) usb_manager::usb_manager() : run_(true)
, usb_cb_handle_(NULL) , usb_cb_handle_(NULL)
, usb_cb_(&usb_manager::usb_event_handle), usb_cb_param_(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()) , born_(std::chrono::system_clock::now())
{ {
int ret = libusb_init(&context_); int ret = libusb_init(&context_);
// libusb_set_log_cb(context_, &usb_manager::usb_log_callback, LIBUSB_LOG_CB_CONTEXT); // LIBUSB_API_VERSION >= 0x01000107 // 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) if (ret)
status_ = HG_ERR_USB_INIT_FAILED; status_ = SCANNER_ERR_USB_INIT_FAILED;
wait_pnp_.set_debug_info("Waiting PNP"); wait_pnp_.set_debug_info("Waiting PNP");
if (!usb_notify_thread_.get()) if (!usb_notify_thread_.get())
@ -66,7 +66,7 @@ usb_manager::~usb_manager()
usb_notify_thread_.reset(); usb_notify_thread_.reset();
} }
libusb_exit(context_); 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) 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 // used when LIBUSB_API_VERSION >= 0x01000107
if (level == LIBUSB_LOG_LEVEL_NONE || LIBUSB_LOG_LEVEL_INFO || LIBUSB_LOG_LEVEL_DEBUG) 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 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) 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; usb_cb_handle_ = NULL;
status_ = HG_ERR_USB_REGISTER_PNP_FAILED; status_ = SCANNER_ERR_USB_REGISTER_PNP_FAILED;
} }
else else
status_ = HG_ERR_OK; status_ = SCANNER_ERR_OK;
return ret; return ret;
} }
@ -230,7 +230,7 @@ void usb_manager::notify_usb_event(PNPDEV& pd, bool* retry)
sprintf(buf, "0x%x", pd.event); sprintf(buf, "0x%x", pd.event);
evstr = buf; 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()); , HIBYTE(ud.ver), LOBYTE(ud.ver) / 0x10, ud.pid, ud.vid, evstr.c_str());
if (ev != USB_EVENT_NULL) if (ev != USB_EVENT_NULL)
{ {
@ -265,7 +265,7 @@ void usb_manager::thread_trigger_usb_event()
{ {
// ^_^ // ^_^
devices.clear(); 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; break;
} }
} }
@ -277,7 +277,7 @@ void usb_manager::thread_trigger_usb_event()
timeval tm={1,0}; timeval tm={1,0};
int ret=libusb_handle_events_timeout(context_, &tm); int ret=libusb_handle_events_timeout(context_, &tm);
if(ret < 0) 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)); 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) int usb_manager::usb_error_2_hg_err(int usb_err)
{ {
if (usb_err == LIBUSB_ERROR_TIMEOUT) if (usb_err == LIBUSB_ERROR_TIMEOUT)
return HG_ERR_TIMEOUT; return SCANNER_ERR_TIMEOUT;
else if (usb_err == LIBUSB_ERROR_PIPE) else if (usb_err == LIBUSB_ERROR_PIPE)
return HG_ERR_IO; return SCANNER_ERR_IO;
else if (usb_err == LIBUSB_ERROR_NO_DEVICE) 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) 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) 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) 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) 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) else if (usb_err == LIBUSB_ERROR_ACCESS)
return HG_ERR_ACCESS_DENIED; return SCANNER_ERR_ACCESS_DENIED;
else if (usb_err < 0) else if (usb_err < 0)
return (hg_err)usb_err; return (scanner_err)usb_err;
else else
return HG_ERR_OK; return SCANNER_ERR_OK;
} }
void usb_manager::init_endpoint(USBENDP* uep) void usb_manager::init_endpoint(USBENDP* uep)
@ -422,7 +422,7 @@ void usb_manager::enum_endpoints(libusb_device* device, USBTRANSENDP* endp)
if (ret != 0) 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; return;
} }
@ -436,26 +436,26 @@ void usb_manager::enum_endpoints(libusb_device* device, USBTRANSENDP* endp)
usb_manager::init_endpoint(&endp->isochronous); usb_manager::init_endpoint(&endp->isochronous);
} }
else 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) for (int i = 0; i < (int)desc.bNumConfigurations; ++i)
{ {
ret = libusb_get_config_descriptor(device, i, &conf); ret = libusb_get_config_descriptor(device, i, &conf);
if (ret != 0) if (ret != 0)
{ {
if (!endp) 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; continue;
} }
if (!endp) 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) for (int j = 0; j < conf->bNumInterfaces; ++j)
{ {
if (!endp) 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) for (int k = 0; k < conf->interface[j].num_altsetting; ++k)
{ {
if (!endp) 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() , usb_manager::device_class((libusb_class_code)conf->interface[j].altsetting[k].bInterfaceClass).c_str()
, conf->interface[j].altsetting[k].bNumEndpoints); , conf->interface[j].altsetting[k].bNumEndpoints);
for (int l = 0; l < conf->interface[j].altsetting[k].bNumEndpoints; ++l) 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) 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; ep = &endp->control;
} }
else if (conf->interface[j].altsetting[k].endpoint[l].bmAttributes == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS) 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; ep = &endp->isochronous;
} }
if (conf->interface[j].altsetting[k].endpoint[l].bmAttributes == LIBUSB_TRANSFER_TYPE_BULK) 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; ep = &endp->bulk;
} }
if (conf->interface[j].altsetting[k].endpoint[l].bmAttributes == LIBUSB_TRANSFER_TYPE_INTERRUPT) 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; ep = &endp->interrupt;
} }
if (conf->interface[j].altsetting[k].endpoint[l].bmAttributes == LIBUSB_TRANSFER_TYPE_BULK_STREAM) 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; ep = &endp->bulk_stream;
} }
if (ep) if (ep)
@ -505,14 +505,14 @@ void usb_manager::enum_endpoints(libusb_device* device, USBTRANSENDP* endp)
s->iface = j; s->iface = j;
s->claimed = 0; s->claimed = 0;
s->max_packet = conf->interface[j].altsetting[k].endpoint[l].wMaxPacketSize; 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); , s->max_packet);
} }
found_ep = true; found_ep = true;
} }
} }
else 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() , 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].bEndpointAddress
, conf->interface[j].altsetting[k].endpoint[l].wMaxPacketSize); , 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) 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) 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(); init_notify_thread();
return HG_ERR_OK; return SCANNER_ERR_OK;
} }
int usb_manager::open(libusb_device* device, usb_io** usbio, std::string* msg) int usb_manager::open(libusb_device* device, usb_io** usbio, std::string* msg)
{ {
if (!usbio) if (!usbio)
return HG_ERR_INVALID_PARAMETER; return SCANNER_ERR_INVALID_PARAMETER;
usb_dev dev; usb_dev dev;
usb_io* usb = NULL; usb_io* usb = NULL;
if (!get_device_info(device, &dev)) if (!get_device_info(device, &dev))
return HG_ERR_DEVICE_NOT_FOUND; return SCANNER_ERR_DEVICE_NOT_FOUND;
dev.contex = context_; dev.contex = context_;
usb = new usb_io(dev); usb = new usb_io(dev);
@ -562,14 +562,14 @@ int usb_manager::open(libusb_device* device, usb_io** usbio, std::string* msg)
if (msg) if (msg)
*msg = usb->init_error_msg(); *msg = usb->init_error_msg();
usb->release(); 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; return err;
} }
*usbio = dynamic_cast<usb_io*>(usb); *usbio = dynamic_cast<usb_io*>(usb);
return HG_ERR_OK; return SCANNER_ERR_OK;
} }
int usb_manager::last_status(void) int usb_manager::last_status(void)
{ {
@ -586,7 +586,7 @@ int usb_manager::last_status(void)
std::shared_ptr<IUsb> usb_; std::shared_ptr<IUsb> usb_;
#endif #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) , singleton_(nullptr)
{ {
#ifdef USE_OLD_USB #ifdef USE_OLD_USB
@ -630,7 +630,7 @@ bool usb_io::make_singleton(void)
singleton_->release(); singleton_->release();
singleton_ = nullptr; 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.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"; str += "' \345\215\240\347\224\250";
init_err_msg_ = str; init_err_msg_ = str;
@ -654,34 +654,34 @@ bool usb_io::claim_interterface(usb_manager::USBSIMPLEX* spl)
return true; 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); ret = libusb_kernel_driver_active(handle_, spl->iface);
if (ret == 1) if (ret == 1)
{ {
ret = libusb_detach_kernel_driver(handle_, spl->iface); 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) else if (ret == LIBUSB_ERROR_NO_DEVICE)
{ {
last_err_ = HG_ERR_DEVICE_NOT_FOUND; last_err_ = SCANNER_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()); 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; 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); 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); 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); libusb_set_configuration(handle_, spl->iconf);
//ret = libusb_reset_device(handle_); //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) //if (ret == LIBUSB_ERROR_NOT_FOUND)
//{ //{
// last_err_ = usb_manager::usb_error_2_hg_err(ret); // 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; // return false;
//} //}
@ -694,8 +694,8 @@ bool usb_io::claim_interterface(usb_manager::USBSIMPLEX* spl)
return true; return true;
} }
HG_VLOG_MINI_2(HG_LOG_LEVEL_FATAL, "second try libusb_claim_interface(%d) = %s\n", spl->iface, libusb_error_name(ret)); HG_VLOG_MINI_2(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; last_err_ = SCANNER_ERR_USB_CLAIM_INTERFACE_FAILED;
return false; return false;
} }
@ -715,7 +715,7 @@ int usb_io::claim_interfaces(bool claim)
break; break;
claimed.push_back(eps[i]->in.iface); 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 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()) && 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)) if (!claim_interterface(&eps[i]->out))
break; break;
claimed.push_back(eps[i]->out.iface); 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) if (eps[i]->out.claimed)
libusb_release_interface(handle_, eps[i]->out.iface); libusb_release_interface(handle_, eps[i]->out.iface);
} }
last_err_ = HG_ERR_OK; last_err_ = SCANNER_ERR_OK;
} }
return last_err_; return last_err_;
} }
void usb_io::init_after_open(void) 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); libusb_set_auto_detach_kernel_driver(handle_, 1);
usb_manager::enum_endpoints(dev_info_.device, &endpoints_); 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_; int err = last_err_;
@ -764,7 +764,7 @@ void usb_io::open(void)
ref_device_ = libusb_ref_device(dev_info_.device); ref_device_ = libusb_ref_device(dev_info_.device);
int ret = libusb_open(dev_info_.device, &handle_); 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)); , hg_log::format_ptr(handle_).c_str(), libusb_error_name(ret));
if (ret == LIBUSB_SUCCESS) if (ret == LIBUSB_SUCCESS)
{ {
@ -780,19 +780,19 @@ void usb_io::open(void)
return; return;
} }
last_err_ = usb_manager::usb_error_2_hg_err(ret); 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; 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; return true;
if (err == HG_ERR_TIMEOUT) if (err == SCANNER_ERR_TIMEOUT)
{ {
//因为在发送img参数出现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); // libusb_clear_halt(handle_, endp->port);
// return libusb_reset_device(handle_) == LIBUSB_SUCCESS; // 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_; return last_err_;
//if (endpoints_.control.in == usb_manager::uninit_uint8) //if (endpoints_.control.in == usb_manager::uninit_uint8)
// return HG_ERR_DEVICE_NOT_SUPPORT; // return SCANNER_ERR_DEVICE_NOT_SUPPORT;
if (!len) 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_); 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; *len = ret;
last_err_ = HG_ERR_OK; last_err_ = SCANNER_ERR_OK;
} }
else 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_); ret = libusb_control_transfer(handle_, type, req, val, ind, (unsigned char*)buf, *len, to_);
if (ret > 0) if (ret > 0)
{ {
*len = ret; *len = ret;
last_err_ = HG_ERR_OK; last_err_ = SCANNER_ERR_OK;
return last_err_; 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); 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 #ifdef USE_OLD_USB
*len = usb_->read_bulk(buf, *len); *len = usb_->read_bulk(buf, *len);
return HG_ERR_OK; return SCANNER_ERR_OK;
#endif #endif
if (!handle_) if (!handle_)
return last_err_; return last_err_;
if(endpoints_.bulk.in.port == usb_manager::uninit_uint8) if(endpoints_.bulk.in.port == usb_manager::uninit_uint8)
return HG_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
if (!len) if (!len)
return HG_ERR_INVALID_PARAMETER; return SCANNER_ERR_INVALID_PARAMETER;
//if (*len < endpoints_.bulk.in.max_packet) // avoid transferring overflows ... //if (*len < endpoints_.bulk.in.max_packet) // avoid transferring overflows ...
//{ //{
// *len = endpoints_.bulk.in.max_packet; // *len = endpoints_.bulk.in.max_packet;
// //
// return HG_ERR_INSUFFICIENT_MEMORY; // return SCANNER_ERR_INSUFFICIENT_MEMORY;
//} //}
// libusb_clear_halt(handle_,endpoints_.bulk.in.port); // libusb_clear_halt(handle_,endpoints_.bulk.in.port);
int total = 0, int total = 0,
@ -891,7 +891,7 @@ int usb_io::read_bulk(void* buf, int* len)
if (err) 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_; return last_err_;
@ -900,16 +900,16 @@ int usb_io::write_bulk(void* buf, int* len)
{ {
#ifdef USE_OLD_USB #ifdef USE_OLD_USB
* len = usb_->write_bulk(buf, *len); * len = usb_->write_bulk(buf, *len);
return HG_ERR_OK; return SCANNER_ERR_OK;
#endif #endif
if (!handle_) if (!handle_)
return last_err_; return last_err_;
if (endpoints_.bulk.out.port == usb_manager::uninit_uint8) if (endpoints_.bulk.out.port == usb_manager::uninit_uint8)
return HG_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
if (!len) if (!len)
return HG_ERR_INVALID_PARAMETER; return SCANNER_ERR_INVALID_PARAMETER;
unsigned char* data = (unsigned char*)buf; unsigned char* data = (unsigned char*)buf;
int total = 0, t = 0, 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_)); 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); //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((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((scanner_err)err).c_str(), to_, endpoints_.bulk.out.max_packet);
if (!on_io_error((hg_err)err, &endpoints_.bulk.out)) if (!on_io_error((scanner_err)err, &endpoints_.bulk.out))
{ {
*len = t; *len = t;
@ -927,7 +927,7 @@ int usb_io::write_bulk(void* buf, int* len)
} }
total += t; 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) if (!t)
break; 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_)); err = usb_manager::usb_error_2_hg_err(libusb_bulk_transfer(handle_, endpoints_.bulk.out.port, data, *len - total, &t, to_));
total += t; 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; *len = total;
last_err_ = err; last_err_ = err;
@ -946,22 +946,22 @@ int usb_io::read_interrupt(void* buf, int* len)
{ {
#ifdef USE_OLD_USB #ifdef USE_OLD_USB
* len = usb_->read_int(buf, *len); * len = usb_->read_int(buf, *len);
return HG_ERR_OK; return SCANNER_ERR_OK;
#endif #endif
if (!handle_) if (!handle_)
return last_err_; return last_err_;
if (endpoints_.interrupt.in.port == usb_manager::uninit_uint8) if (endpoints_.interrupt.in.port == usb_manager::uninit_uint8)
return HG_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
if (!len) if (!len)
return HG_ERR_INVALID_PARAMETER; return SCANNER_ERR_INVALID_PARAMETER;
if (*len < endpoints_.interrupt.in.max_packet) // avoid transferring overflows ... if (*len < endpoints_.interrupt.in.max_packet) // avoid transferring overflows ...
{ {
*len = endpoints_.interrupt.in.max_packet; *len = endpoints_.interrupt.in.max_packet;
return HG_ERR_INSUFFICIENT_MEMORY; return SCANNER_ERR_INSUFFICIENT_MEMORY;
} }
int io = 0; int io = 0;
@ -977,17 +977,17 @@ int usb_io::write_interrupt(void* buf, int* len)
return last_err_; return last_err_;
if (endpoints_.interrupt.out.port == usb_manager::uninit_uint8) if (endpoints_.interrupt.out.port == usb_manager::uninit_uint8)
return HG_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
if (!len) if (!len)
return HG_ERR_INVALID_PARAMETER; return SCANNER_ERR_INVALID_PARAMETER;
unsigned char* data = (unsigned char*)buf; unsigned char* data = (unsigned char*)buf;
int total = 0, t = 0, 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_)); err = usb_manager::usb_error_2_hg_err(libusb_bulk_transfer(handle_, endpoints_.interrupt.out.port, data, *len, &t, to_));
total += t; 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; data += t;
t = 0; t = 0;
@ -1004,33 +1004,33 @@ int usb_io::read_isochronous(void* buf, int* len)
if (!handle_) if (!handle_)
return last_err_; return last_err_;
return HG_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int usb_io::write_isochronous(void* buf, int* len) int usb_io::write_isochronous(void* buf, int* len)
{ {
if (!handle_) if (!handle_)
return last_err_; 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) int usb_io::read_bulk_stream(void* buf, int* len)
{ {
if (!handle_) if (!handle_)
return last_err_; 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) int usb_io::write_bulk_stream(void* buf, int* len)
{ {
if (!handle_) if (!handle_)
return last_err_; return last_err_;
return HG_ERR_DEVICE_NOT_SUPPORT; return SCANNER_ERR_DEVICE_NOT_SUPPORT;
} }
int usb_io::reset(void) int usb_io::reset(void)
{ {
if (!handle_) if (!handle_)
return HG_ERR_NOT_OPEN; return SCANNER_ERR_NOT_OPEN;
return usb_manager::usb_error_2_hg_err(libusb_reset_device(handle_)); 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 #ifdef USE_OLD_USB
usb_.reset(); usb_.reset();
return HG_ERR_OK; return SCANNER_ERR_OK;
#endif #endif
if (singleton_) if (singleton_)
singleton_->release(); singleton_->release();
@ -1065,7 +1065,7 @@ int usb_io::close(void)
ref_device_ = nullptr; ref_device_ = nullptr;
} }
return HG_ERR_OK; return SCANNER_ERR_OK;
} }
libusb_device* usb_io::get_usb_device(void) libusb_device* usb_io::get_usb_device(void)
@ -1084,7 +1084,7 @@ int usb_io::get_pid(void)
void usb_io::on_disconnected(void) void usb_io::on_disconnected(void)
{ {
close(); close();
last_err_ = HG_ERR_DEVICE_NOT_FOUND; last_err_ = SCANNER_ERR_DEVICE_NOT_FOUND;
} }
std::string usb_io::init_error_msg(void) 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) int usb_io::get_bulk_packet_size(int* bytes)
{ {
if (!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) 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; *bytes = endpoints_.bulk.in.max_packet;
return HG_ERR_OK; return SCANNER_ERR_OK;
} }
int usb_io::get_interrupt_packet_size(int* bytes) int usb_io::get_interrupt_packet_size(int* bytes)
{ {
if (!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) 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; *bytes = endpoints_.interrupt.in.max_packet;
return HG_ERR_OK; return SCANNER_ERR_OK;
} }
unsigned int usb_io::set_timeout(unsigned int to) unsigned int usb_io::set_timeout(unsigned int to)
{ {

6
hgdriver/hgdev/usb_manager.h
View File

@ -163,7 +163,7 @@ class usb_io
void init_after_open(void); void init_after_open(void);
void 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: protected:
virtual ~usb_io(); virtual ~usb_io();
@ -174,9 +174,9 @@ public:
int add_ref(void); // 拥有者在第一次获取时调用一次 int add_ref(void); // 拥有者在第一次获取时调用一次
int release(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 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 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 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 int write_interrupt(void* buf, int* len); // 写入数据, len : [in] - content bytes in buf, [out] - real wrote bytes

48
hgdriver/wrapper/hg_log.cpp
View File

@ -22,7 +22,7 @@
#endif #endif
class hglog class log_cls
{ {
typedef void(*log_to)(const char*, void*); typedef void(*log_to)(const char*, void*);
@ -32,7 +32,7 @@ class hglog
int level_; int level_;
log_callback lcb_; log_callback lcb_;
static hglog* inst_; static log_cls* inst_;
static void log_none(const char* info, void* param) static void log_none(const char* info, void* param)
{} {}
@ -51,9 +51,9 @@ class hglog
} }
protected: 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_) if (file_)
{ {
@ -63,12 +63,12 @@ protected:
} }
public: public:
static hglog* instance(void) static log_cls* instance(void)
{ {
if (!hglog::inst_) if (!log_cls::inst_)
hglog::inst_ = new hglog(); log_cls::inst_ = new log_cls();
return hglog::inst_; return log_cls::inst_;
} }
int set_log_type(int type, void* param) int set_log_type(int type, void* param)
@ -83,13 +83,13 @@ public:
lcb_ = NULL; lcb_ = NULL;
log_ = NULL; log_ = NULL;
if (type == HG_LOG_TYPE_NONE) if (type == LOG_TYPE_NONE)
log_ = &hglog::log_none; log_ = &log_cls::log_none;
else if(type == HG_LOG_TYPE_CONSOLE) else if(type == LOG_TYPE_CONSOLE)
log_ = &hglog::log_consonle; log_ = &log_cls::log_consonle;
else if (type == HG_LOG_TYPE_FILE) else if (type == LOG_TYPE_FILE)
{ {
log_ = &hglog::log_file; log_ = &log_cls::log_file;
ret = -1; ret = -1;
if (param) if (param)
@ -104,13 +104,13 @@ public:
} }
} }
} }
else if (type == HG_LOG_TYPE_CALLBACK) else if (type == LOG_TYPE_CALLBACK)
{ {
lcb_ = (log_callback)param; lcb_ = (log_callback)param;
} }
if(ret != 0) if(ret != 0)
log_ = &hglog::log_none; log_ = &log_cls::log_none;
return ret; return ret;
} }
@ -128,7 +128,7 @@ public:
log_(info, (void*)file_); log_(info, (void*)file_);
} }
}; };
hglog* hglog::inst_ = NULL; log_cls* log_cls::inst_ = NULL;
#ifdef EXPORT_AS_C #ifdef EXPORT_AS_C
extern "C" extern "C"
@ -163,13 +163,13 @@ extern "C"
} }
int init(hg_log_type type, hg_log_level level, char* log_file) 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; lcb_ = (log_callback)log_file;
else else
lcb_ = NULL; 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) std::string current_time(void)
{ {
@ -290,8 +290,8 @@ extern "C"
{ {
if (lcb_) if (lcb_)
lcb_(level, info); lcb_(level, info);
else if (hglog::instance()->is_log_level_enabled(level)) else if (log_cls::instance()->is_log_level_enabled(level))
hglog::instance()->log(info); log_cls::instance()->log(info);
} }
void vlog(hg_log_level level, const char* fmt, ...) void vlog(hg_log_level level, const char* fmt, ...)
{ {
@ -308,7 +308,7 @@ extern "C"
lcb_(level, buf); lcb_(level, buf);
free(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; va_list args;
char* buf = (char*)malloc(1024); char* buf = (char*)malloc(1024);
@ -318,7 +318,7 @@ extern "C"
sprintf(buf, fmt, args); sprintf(buf, fmt, args);
va_end(args); va_end(args);
hglog::instance()->log(buf); log_cls::instance()->log(buf);
free(buf); free(buf);
} }
} }

30
hgdriver/wrapper/huagaoxxx_warraper_ex.cpp
View File

@ -19,14 +19,14 @@
extern "C" 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::set_version(VERSION_MAJOR, VERSION_MINOR, VERSION_YEAR, VERSION_BUILD - 10000);
hg_scanner_mgr::instance(callback); hg_scanner_mgr::instance(callback);
return HG_ERR_OK; return SCANNER_ERR_OK;
} }
void hg_scanner_uninitialize(void) void hg_scanner_uninitialize(void)
{ {
@ -38,63 +38,63 @@ extern "C"
return MAKE_VERSION(VERSION_MAJOR, VERSION_MINOR, VERSION_YEAR, VERSION_BUILD - 10000); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); return hg_scanner_mgr::instance()->hg_scanner_control(h, code, data, len);
} }

370
hgsane/sane_hg_mdw.cpp
View File

@ -42,33 +42,33 @@ namespace local_utility
{ {
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static char g_unk_err[80] = { 0 }; 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) \ #define RETURN_MATCH_ERROR(hg, sane) \
if(hgerr == hg) \ if(hgerr == hg) \
return sane; return sane;
RETURN_MATCH_ERROR(HG_ERR_OK, SANE_STATUS_GOOD); RETURN_MATCH_ERROR(SCANNER_ERR_OK, SANE_STATUS_GOOD);
RETURN_MATCH_ERROR(HG_ERR_INVALID_PARAMETER, SANE_STATUS_INVAL); RETURN_MATCH_ERROR(SCANNER_ERR_INVALID_PARAMETER, SANE_STATUS_INVAL);
RETURN_MATCH_ERROR(HG_ERR_INSUFFICIENT_MEMORY, SANE_STATUS_NO_MEM); RETURN_MATCH_ERROR(SCANNER_ERR_INSUFFICIENT_MEMORY, SANE_STATUS_NO_MEM);
RETURN_MATCH_ERROR(HG_ERR_ACCESS_DENIED, SANE_STATUS_ACCESS_DENIED); RETURN_MATCH_ERROR(SCANNER_ERR_ACCESS_DENIED, SANE_STATUS_ACCESS_DENIED);
RETURN_MATCH_ERROR(HG_ERR_IO_PENDING, SANE_STATUS_GOOD); RETURN_MATCH_ERROR(SCANNER_ERR_IO_PENDING, SANE_STATUS_GOOD);
RETURN_MATCH_ERROR(HG_ERR_NOT_EXACT, SANE_STATUS_GOOD); RETURN_MATCH_ERROR(SCANNER_ERR_NOT_EXACT, SANE_STATUS_GOOD);
RETURN_MATCH_ERROR(HG_ERR_CONFIGURATION_CHANGED, SANE_STATUS_GOOD); RETURN_MATCH_ERROR(SCANNER_ERR_CONFIGURATION_CHANGED, SANE_STATUS_GOOD);
RETURN_MATCH_ERROR(HG_ERR_NOT_OPEN, SANE_STATUS_NO_DOCS); RETURN_MATCH_ERROR(SCANNER_ERR_NOT_OPEN, SANE_STATUS_NO_DOCS);
RETURN_MATCH_ERROR(HG_ERR_NOT_START, SANE_STATUS_NO_DOCS); RETURN_MATCH_ERROR(SCANNER_ERR_NOT_START, SANE_STATUS_NO_DOCS);
RETURN_MATCH_ERROR(HG_ERR_NO_DATA, SANE_STATUS_EOF); RETURN_MATCH_ERROR(SCANNER_ERR_NO_DATA, SANE_STATUS_EOF);
RETURN_MATCH_ERROR(HG_ERR_HAS_DATA_YET, SANE_STATUS_IO_ERROR); RETURN_MATCH_ERROR(SCANNER_ERR_HAS_DATA_YET, SANE_STATUS_IO_ERROR);
RETURN_MATCH_ERROR(HG_ERR_OUT_OF_RANGE, SANE_STATUS_NO_MEM); RETURN_MATCH_ERROR(SCANNER_ERR_OUT_OF_RANGE, SANE_STATUS_NO_MEM);
RETURN_MATCH_ERROR(HG_ERR_IO, SANE_STATUS_IO_ERROR); RETURN_MATCH_ERROR(SCANNER_ERR_IO, SANE_STATUS_IO_ERROR);
RETURN_MATCH_ERROR(HG_ERR_TIMEOUT, 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(SCANNER_ERR_DEVICE_NOT_FOUND, SANE_STATUS_NO_DOCS);
RETURN_MATCH_ERROR(HG_ERR_DEVICE_NOT_SUPPORT, SANE_STATUS_UNSUPPORTED); RETURN_MATCH_ERROR(SCANNER_ERR_DEVICE_NOT_SUPPORT, SANE_STATUS_UNSUPPORTED);
RETURN_MATCH_ERROR(HG_ERR_DEVICE_BUSY, SANE_STATUS_DEVICE_BUSY); RETURN_MATCH_ERROR(SCANNER_ERR_DEVICE_BUSY, SANE_STATUS_DEVICE_BUSY);
RETURN_MATCH_ERROR(HG_ERR_DEVICE_COVER_OPENNED, SANE_STATUS_COVER_OPEN); RETURN_MATCH_ERROR(SCANNER_ERR_DEVICE_COVER_OPENNED, SANE_STATUS_COVER_OPEN);
RETURN_MATCH_ERROR(HG_ERR_DEVICE_NO_PAPER, SANE_STATUS_NO_DOCS); RETURN_MATCH_ERROR(SCANNER_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_PAPER_JAMMED, SANE_STATUS_JAMMED);
return (SANE_Status)hgerr; return (SANE_Status)hgerr;
} }
@ -86,46 +86,46 @@ namespace local_utility
RETURN_IF(statu, SANE_STATUS_IO_ERROR); RETURN_IF(statu, SANE_STATUS_IO_ERROR);
RETURN_IF(statu, SANE_STATUS_NO_MEM); RETURN_IF(statu, SANE_STATUS_NO_MEM);
RETURN_IF(statu, SANE_STATUS_ACCESS_DENIED); RETURN_IF(statu, SANE_STATUS_ACCESS_DENIED);
RETURN_IF(statu, HG_ERR_INVALID_PARAMETER); RETURN_IF(statu, SCANNER_ERR_INVALID_PARAMETER);
RETURN_IF(statu, HG_ERR_USER_CANCELED); RETURN_IF(statu, SCANNER_ERR_USER_CANCELED);
RETURN_IF(statu, HG_ERR_INSUFFICIENT_MEMORY); RETURN_IF(statu, SCANNER_ERR_INSUFFICIENT_MEMORY);
RETURN_IF(statu, HG_ERR_ACCESS_DENIED); RETURN_IF(statu, SCANNER_ERR_ACCESS_DENIED);
RETURN_IF(statu, HG_ERR_IO_PENDING); RETURN_IF(statu, SCANNER_ERR_IO_PENDING);
RETURN_IF(statu, HG_ERR_NOT_EXACT); RETURN_IF(statu, SCANNER_ERR_NOT_EXACT);
RETURN_IF(statu, HG_ERR_CONFIGURATION_CHANGED); RETURN_IF(statu, SCANNER_ERR_CONFIGURATION_CHANGED);
RETURN_IF(statu, HG_ERR_NOT_OPEN); RETURN_IF(statu, SCANNER_ERR_NOT_OPEN);
RETURN_IF(statu, HG_ERR_NOT_START); RETURN_IF(statu, SCANNER_ERR_NOT_START);
RETURN_IF(statu, HG_ERR_NOT_ANY_MORE); RETURN_IF(statu, SCANNER_ERR_NOT_ANY_MORE);
RETURN_IF(statu, HG_ERR_NO_DATA); RETURN_IF(statu, SCANNER_ERR_NO_DATA);
RETURN_IF(statu, HG_ERR_HAS_DATA_YET); RETURN_IF(statu, SCANNER_ERR_HAS_DATA_YET);
RETURN_IF(statu, HG_ERR_OUT_OF_RANGE); RETURN_IF(statu, SCANNER_ERR_OUT_OF_RANGE);
RETURN_IF(statu, HG_ERR_IO); RETURN_IF(statu, SCANNER_ERR_IO);
RETURN_IF(statu, HG_ERR_TIMEOUT); RETURN_IF(statu, SCANNER_ERR_TIMEOUT);
RETURN_IF(statu, HG_ERR_OPEN_FILE_FAILED); RETURN_IF(statu, SCANNER_ERR_OPEN_FILE_FAILED);
RETURN_IF(statu, HG_ERR_CREATE_FILE_FAILED); RETURN_IF(statu, SCANNER_ERR_CREATE_FILE_FAILED);
RETURN_IF(statu, HG_ERR_WRITE_FILE_FAILED); RETURN_IF(statu, SCANNER_ERR_WRITE_FILE_FAILED);
RETURN_IF(statu, HG_ERR_DATA_DAMAGED); RETURN_IF(statu, SCANNER_ERR_DATA_DAMAGED);
RETURN_IF(statu, HG_ERR_USB_INIT_FAILED); RETURN_IF(statu, SCANNER_ERR_USB_INIT_FAILED);
RETURN_IF(statu, HG_ERR_USB_REGISTER_PNP_FAILED); RETURN_IF(statu, SCANNER_ERR_USB_REGISTER_PNP_FAILED);
RETURN_IF(statu, HG_ERR_USB_CLAIM_INTERFACE_FAILED); RETURN_IF(statu, SCANNER_ERR_USB_CLAIM_INTERFACE_FAILED);
RETURN_IF(statu, HG_ERR_DEVICE_NOT_FOUND); RETURN_IF(statu, SCANNER_ERR_DEVICE_NOT_FOUND);
RETURN_IF(statu, HG_ERR_DEVICE_NOT_SUPPORT); RETURN_IF(statu, SCANNER_ERR_DEVICE_NOT_SUPPORT);
RETURN_IF(statu, HG_ERR_DEVICE_BUSY); RETURN_IF(statu, SCANNER_ERR_DEVICE_BUSY);
RETURN_IF(statu, HG_ERR_DEVICE_SLEEPING); RETURN_IF(statu, SCANNER_ERR_DEVICE_SLEEPING);
RETURN_IF(statu, HG_ERR_DEVICE_COUNT_MODE); RETURN_IF(statu, SCANNER_ERR_DEVICE_COUNT_MODE);
RETURN_IF(statu, HG_ERR_DEVICE_STOPPED); RETURN_IF(statu, SCANNER_ERR_DEVICE_STOPPED);
RETURN_IF(statu, HG_ERR_DEVICE_COVER_OPENNED); RETURN_IF(statu, SCANNER_ERR_DEVICE_COVER_OPENNED);
RETURN_IF(statu, HG_ERR_DEVICE_NO_PAPER); RETURN_IF(statu, SCANNER_ERR_DEVICE_NO_PAPER);
RETURN_IF(statu, HG_ERR_DEVICE_FEEDING_PAPER); RETURN_IF(statu, SCANNER_ERR_DEVICE_FEEDING_PAPER);
RETURN_IF(statu, HG_ERR_DEVICE_DOUBLE_FEEDING); RETURN_IF(statu, SCANNER_ERR_DEVICE_DOUBLE_FEEDING);
RETURN_IF(statu, HG_ERR_DEVICE_PAPER_JAMMED); RETURN_IF(statu, SCANNER_ERR_DEVICE_PAPER_JAMMED);
RETURN_IF(statu, HG_ERR_DEVICE_STAPLE_ON); RETURN_IF(statu, SCANNER_ERR_DEVICE_STAPLE_ON);
RETURN_IF(statu, HG_ERR_DEVICE_PAPER_SKEW); RETURN_IF(statu, SCANNER_ERR_DEVICE_PAPER_SKEW);
RETURN_IF(statu, HG_ERR_DEVICE_SIZE_CHECK); RETURN_IF(statu, SCANNER_ERR_DEVICE_SIZE_CHECK);
RETURN_IF(statu, HG_ERR_DEVICE_DOGEAR); RETURN_IF(statu, SCANNER_ERR_DEVICE_DOGEAR);
RETURN_IF(statu, HG_ERR_DEVICE_NO_IMAGE); RETURN_IF(statu, SCANNER_ERR_DEVICE_NO_IMAGE);
RETURN_IF(statu, HG_ERR_DEVICE_SCANN_ERROR); RETURN_IF(statu, SCANNER_ERR_DEVICE_SCANN_ERROR);
RETURN_IF(statu, HG_ERR_DEVICE_PC_BUSY); 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); 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); free(buf);
} }
if (found) 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 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 #endif
#ifndef WIN32 #ifndef WIN32
@ -422,11 +422,11 @@ namespace local_utility
val(""); val("");
simple_ini ini; simple_ini ini;
bool given_path = false; bool given_path = false;
hg_log_type logt = HG_LOG_TYPE_FILE; hg_log_type logt = LOG_TYPE_FILE;
hg_log_level logl = HG_LOG_LEVEL_ALL; hg_log_level logl = LOG_LEVEL_ALL;
hg_log::init(HG_LOG_TYPE_CONSOLE, HG_LOG_LEVEL_DEBUG_INFO); hg_log::init(LOG_TYPE_CONSOLE, LOG_LEVEL_DEBUG_INFO);
HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "current path: '%s'\n", path.c_str()); HG_VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "current path: '%s'\n", path.c_str());
if (path.empty()) if (path.empty())
path = simple_ini::temporary_path(); path = simple_ini::temporary_path();
@ -440,10 +440,10 @@ namespace local_utility
{ {
val = ini.get("log", "type"); val = ini.get("log", "type");
if (stricmp(val.c_str(), "console") == 0) if (stricmp(val.c_str(), "console") == 0)
logt = HG_LOG_TYPE_CONSOLE; logt = LOG_TYPE_CONSOLE;
else if (stricmp(val.c_str(), "none") == 0) else if (stricmp(val.c_str(), "none") == 0)
logt = HG_LOG_TYPE_NONE; logt = LOG_TYPE_NONE;
if (logt == HG_LOG_TYPE_FILE) if (logt == LOG_TYPE_FILE)
{ {
val = ini.get("log", "file"); val = ini.get("log", "file");
if (!val.empty()) if (!val.empty())
@ -454,13 +454,13 @@ namespace local_utility
} }
val = ini.get("log", "level"); val = ini.get("log", "level");
if (stricmp(val.c_str(), "debug") == 0) 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) 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) 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"); std::string child("/scanner_log");
path += child; path += child;
@ -470,22 +470,28 @@ namespace local_utility
} }
else 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; path = simple_ini::temporary_path() + child;
if (MKDIR(path.c_str(), S_IREAD | S_IWRITE | S_IEXEC) == 0 || errno == EEXIST) if (MKDIR(path.c_str(), S_IREAD | S_IWRITE | S_IEXEC) == 0 || errno == EEXIST)
path += "/log.txt"; path += "/log.txt";
else else
{ {
HG_VLOG_MINI_2(HG_LOG_LEVEL_DEBUG_INFO, "create temporary directory '%s' failed(%d), log to console\n", path.c_str(), errno); HG_VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "create temporary directory '%s' failed(%d), log to console\n", path.c_str(), errno);
logt = HG_LOG_TYPE_CONSOLE; logt = LOG_TYPE_CONSOLE;
logl = HG_LOG_LEVEL_WARNING; logl = LOG_LEVEL_WARNING;
} }
} }
} }
hg_log::init(logt, logl, &path[0]); 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"; 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<std::mutex> lck(cb_lock_); std::lock_guard<std::mutex> lck(cb_lock_);
if (SANE_EVENT_SUPPORT_ASYNC_IO == code) 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) 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); 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_) if (cb_ui_)
{ {
@ -556,7 +562,13 @@ namespace local_utility
long v = hg_scanner_get_version(); long v = hg_scanner_get_version();
unsigned char* byt = (unsigned char*)&v; 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) void stop_work(void)
{ {
@ -580,7 +592,7 @@ static sane_callback g_cb = NULL;
void* g_param = NULL; void* g_param = NULL;
static unsigned int scan_count = -1; static unsigned int scan_count = -1;
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 #ifdef TEST_DEV
hg_scanner_mgr::instance(); hg_scanner_mgr::instance();
@ -590,7 +602,7 @@ hg_err hg_scanner_initialize(sane_callback callback, void* param)
g_cb = callback; g_cb = callback;
g_param = param; g_param = param;
return HG_ERR_OK; return SCANNER_ERR_OK;
} }
void hg_scanner_uninitialize(void) void hg_scanner_uninitialize(void)
{ {
@ -600,20 +612,20 @@ long hg_scanner_get_version(void)
return SANE_VERSION_CODE(1, 0, 311); return SANE_VERSION_CODE(1, 0, 311);
} }
static const char* scanner_name = "华高扫描仪(模拟)"; 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 #ifdef TEST_DEV
return hg_scanner_mgr::instance()->hg_scanner_enum(scanner_list, count, local_only); return hg_scanner_mgr::instance()->hg_scanner_enum(scanner_list, count, local_only);
#endif #endif
if (!count) if (!count)
return HG_ERR_INVALID_PARAMETER; return SCANNER_ERR_INVALID_PARAMETER;
if (*count < 1) if (*count < 1)
{ {
*count = 1; *count = 1;
return HG_ERR_INSUFFICIENT_MEMORY; return SCANNER_ERR_INSUFFICIENT_MEMORY;
} }
*count = 1; *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]); jsn_inst = new json(&v[0]);
} }
return HG_ERR_OK; return SCANNER_ERR_OK;
} }
static volatile bool run_ = true; static volatile bool run_ = true;
void* thread_pnp(void*) void* thread_pnp(void*)
{ {
HGScannerInfo devs[4]; ScannerInfo devs[4];
long count = sizeof(devs) / sizeof(devs[0]); long count = sizeof(devs) / sizeof(devs[0]);
int ev = SANE_EVENT_DEVICE_ARRIVED; int ev = SANE_EVENT_DEVICE_ARRIVED;
@ -657,31 +669,31 @@ void* thread_pnp(void*)
return 0; 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) if (!h || !name)
return HG_ERR_INVALID_PARAMETER; return SCANNER_ERR_INVALID_PARAMETER;
if (strcmp(name, scanner_name)) if (strcmp(name, scanner_name))
return HG_ERR_DEVICE_NOT_FOUND; return SCANNER_ERR_DEVICE_NOT_FOUND;
*h = (scanner_handle)0x7e57; *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(""); std::string v("");
json* child = NULL; json* child = NULL;
char key[20]; char key[20];
hg_err err = HG_ERR_OUT_OF_RANGE; scanner_err err = SCANNER_ERR_OUT_OF_RANGE;
if (!len || !jsn_inst) if (!len || !jsn_inst)
err = HG_ERR_INVALID_PARAMETER; err = SCANNER_ERR_INVALID_PARAMETER;
else else
{ {
if (param_no == 0) 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; int count = 0;
jsn_inst->get_value("option_count", count); jsn_inst->get_value("option_count", count);
*len = count; *len = count;
err = HG_ERR_OK; err = SCANNER_ERR_OK;
} }
else else
{ {
@ -703,14 +715,14 @@ hg_err hg_scanner_get_parameter(scanner_handle h, unsigned param_no, char* json_
if (*len <= v.length()) if (*len <= v.length())
{ {
err = HG_ERR_INSUFFICIENT_MEMORY; err = SCANNER_ERR_INSUFFICIENT_MEMORY;
*len = v.length() + 4; *len = v.length() + 4;
} }
else else
{ {
strcpy(json_data, v.c_str()); strcpy(json_data, v.c_str());
*len = v.length(); *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; 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) //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; // *(SANE_Int*)data = regular;
// //
// ret = HG_ERR_NOT_EXACT; // ret = SCANNER_ERR_NOT_EXACT;
// } // }
//} //}
@ -836,19 +848,19 @@ void* fake_thread(void* hs)
} }
else else
{ {
unsigned int err = HG_ERR_OPEN_FILE_FAILED; unsigned int err = SCANNER_ERR_OPEN_FILE_FAILED;
path += file; path += file;
local_utility::ui_cb(h, SANE_EVENT_ERROR, &path[0], &err, NULL); 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; break;
} }
} }
else else
{ {
unsigned int err = HG_ERR_OPEN_FILE_FAILED; unsigned int err = SCANNER_ERR_OPEN_FILE_FAILED;
path += file; path += file;
local_utility::ui_cb(h, SANE_EVENT_ERROR, &path[0], &err, NULL); 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; break;
} }
if (pic_ind >= count) if (pic_ind >= count)
@ -866,12 +878,12 @@ void* fake_thread(void* hs)
return 0; 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 (local_utility::cb_ui_)
//{ //{
// if (thread_img_handle.get() && !finished) // if (thread_img_handle.get() && !finished)
// return HG_ERR_DEVICE_BUSY; // return SCANNER_ERR_DEVICE_BUSY;
//} //}
finished = false; 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); 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; cancel = true;
//if (local_utility::cb_ui_) //if (local_utility::cb_ui_)
@ -900,9 +912,9 @@ hg_err hg_scanner_stop(scanner_handle h)
// thread_img_handle.reset(); // 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()); std::string path(local_utility::get_self_path());
char file[128]; 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; 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) // if (*len <= 0 || fake_read >= fake_total)
// return HG_ERR_NO_DATA; // return SCANNER_ERR_NO_DATA;
if (cancel) if (cancel)
return (hg_err)SANE_STATUS_CANCELLED; return (scanner_err)SANE_STATUS_CANCELLED;
std::string path(local_utility::get_self_path()); std::string path(local_utility::get_self_path());
char file[128]; char file[128];
@ -972,19 +984,19 @@ hg_err hg_scanner_read_img_data(scanner_handle h, unsigned char* data, long* len
offset += bytes; 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 #endif
@ -1012,7 +1024,7 @@ hg_sane_middleware::~hg_sane_middleware()
hg_scanner_uninitialize(); 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; 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); 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; 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) 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) 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; return sod;
} }
@ -1259,7 +1271,7 @@ SANE_Option_Descriptor* hg_sane_middleware::number_option_to_SANE_descriptor(con
str = (char*)((SANE_Range*)str + 1); 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; return sod;
} }
@ -1309,7 +1321,7 @@ SANE_Option_Descriptor* hg_sane_middleware::number_option_to_SANE_descriptor(con
str = (char*)(val + values.size()); 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; return sod;
} }
@ -1359,7 +1371,7 @@ SANE_Option_Descriptor* hg_sane_middleware::number_option_to_SANE_descriptor(con
str = (char*)(val + values.size()); 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; 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) 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; scanner_handle h = NULL;
hg_err err = HG_ERR_OK; scanner_err err = SCANNER_ERR_OK;
if (handle == NULL) if (handle == NULL)
return SANE_STATUS_INVAL; return SANE_STATUS_INVAL;
err = hg_scanner_open(&h, devicename, false, NULL, NULL, NULL, rsc); err = hg_scanner_open(&h, devicename, false, NULL, NULL, NULL, rsc);
if (err == HG_ERR_OK) if (err == SCANNER_ERR_OK)
{ {
OPENDEV od; OPENDEV od;
@ -1385,7 +1397,7 @@ SANE_Status hg_sane_middleware::open(SANE_String_Const devicename, SANE_Handle*
return SANE_STATUS_GOOD; return SANE_STATUS_GOOD;
} }
else if (err == HG_ERR_ACCESS_DENIED) else if (err == SCANNER_ERR_ACCESS_DENIED)
{ {
return SANE_STATUS_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) 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; ret->unit = SANE_UNIT_DPI;
} }
else if (strcmp(ret->name, KNOWN_OPT_NAME_CUSTOM_AREA_LEFT) == 0 || 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; char* json_txt = NULL;
long length = 0; 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(""); 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"); json_txt = (char*)local_utility::acquire_memory(ALIGN_INT(length + 4), "hg_sane_middleware::get_option_json");
bzero(json_txt, length + 4); bzero(json_txt, length + 4);
err = hg_scanner_get_parameter(handle, opt_no, json_txt, &length); err = hg_scanner_get_parameter(handle, opt_no, json_txt, &length);
if (err == HG_ERR_OK) if (err == SCANNER_ERR_OK)
{ {
ret = json_txt; 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); 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; delete jsn;
@ -1738,31 +1750,31 @@ SANE_Status hg_sane_middleware::get_devices(const SANE_Device*** device_list, SA
if (!device_list) if (!device_list)
return SANE_STATUS_INVAL; return SANE_STATUS_INVAL;
HGScannerInfo* dev = NULL; ScannerInfo * dev = NULL;
long count = 0; 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; SANE_Status ret = SANE_STATUS_GOOD;
if (hgerr == HG_ERR_INSUFFICIENT_MEMORY) if (hgerr == SCANNER_ERR_INSUFFICIENT_MEMORY)
{ {
count += 4; // 为两次hg_scanner_enum间隙可能新增的设备预留空间 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); hgerr = hg_scanner_enum(dev, &count, local_only);
if (hgerr != HG_ERR_OK) if (hgerr != SCANNER_ERR_OK)
{ {
free(dev); free(dev);
dev = NULL; dev = NULL;
} }
} }
if (hgerr == HG_ERR_OK) if (hgerr == SCANNER_ERR_OK)
{ {
*device_list = hg_sane_middleware::to_sane_device(dev, count); *device_list = hg_sane_middleware::to_sane_device(dev, count);
if (dev) if (dev)
free(dev); free(dev);
} }
else 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_) if (hg_sane_middleware::dev_list_)
free(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; SANE_Status err = SANE_STATUS_GOOD;
if (hs) 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; return err;
} }
SANE_Status hg_sane_middleware::get_image_parameters(SANE_Handle handle, SANE_Parameters* params) SANE_Status hg_sane_middleware::get_image_parameters(SANE_Handle handle, SANE_Parameters* params)
{ {
scanner_handle h = find_openning_device(handle); scanner_handle h = find_openning_device(handle);
hg_err err = HG_ERR_NOT_START; scanner_err err = SCANNER_ERR_NOT_START;
if (!params) if (!params)
return SANE_STATUS_INVAL; return SANE_STATUS_INVAL;
err = hg_scanner_get_img_info(h, params, sizeof(*params)); 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) SANE_Status hg_sane_middleware::start(SANE_Handle h, void* async_event)
{ {
OPENDEV dev; OPENDEV dev;
scanner_handle hs = find_openning_device(h, false, &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) if(hs)
err = hg_scanner_start(hs, async_event, dev.scan_count); 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) SANE_Status hg_sane_middleware::read(SANE_Handle h, void* buf, int* bytes)
{ {
scanner_handle hs = find_openning_device(h); 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; long r = bytes ? *bytes : 0;
if (bytes && hs) if (bytes && hs)
@ -1837,7 +1849,7 @@ SANE_Status hg_sane_middleware::read(SANE_Handle h, void* buf, int* bytes)
*bytes = r; *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) 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) 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; return SANE_STATUS_UNSUPPORTED;
} }
else if (!value && desc->type != SANE_TYPE_BUTTON) 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; 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; double dv = .0f;
bool bv = false; bool bv = false;
int size = desc->size; int size = desc->size;
hg_err err = HG_ERR_OK; scanner_err err = SCANNER_ERR_OK;
if (desc->type == SANE_TYPE_BOOL) 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); v = hg_sane_middleware::option_value_2_string(desc->type, value);
if (prev == v) 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 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); HG_VLOG_MINI_1(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()); on_SCANNER_ERR_CONFIGURATION_CHANGED(handle, dev.dev_name.c_str());
err = (hg_err)SANE_INFO_RELOAD_OPTIONS; 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; status = SANE_STATUS_ACCESS_DENIED;
else else
status = SANE_STATUS_INVAL; 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; // return SANE_STATUS_INVAL;
int ret = hg_scanner_control(handle, code, data, len); int ret = hg_scanner_control(handle, code, data, len);
if (ret == HG_ERR_CONFIGURATION_CHANGED) if (ret == SCANNER_ERR_CONFIGURATION_CHANGED)
{ {
int nc = code; int nc = code;
HG_VLOG_MINI_1(HG_LOG_LEVEL_DEBUG_INFO, "the setting '0x%08x' affects other options value, RELOAD ...\n", nc); HG_VLOG_MINI_1(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()); 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);
} }
/// <summary> /// <summary>
@ -2065,7 +2077,7 @@ bool hg_sane_middleware::is_enable_and(const std::vector<MASTEROP>& master, std:
std::vector<CURVAL>::iterator it = std::find(curvals.begin(), curvals.end(), master[i].option_no); std::vector<CURVAL>::iterator it = std::find(curvals.begin(), curvals.end(), master[i].option_no);
if (it == curvals.end()) 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; continue;
} }
enabled &= master[i].compare_val(it->val.c_str(), master[i].limit_l.c_str(), master[i].limit_r.c_str()); 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<MASTEROP>& master, std::
std::vector<CURVAL>::iterator it = std::find(curvals.begin(), curvals.end(), master[i].option_no); std::vector<CURVAL>::iterator it = std::find(curvals.begin(), curvals.end(), master[i].option_no);
if (it == curvals.end()) 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; continue;
} }
@ -2390,7 +2402,7 @@ void hg_sane_middleware::free_control_enable_data(OPTEN* opt)
free(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<int> changed; std::vector<int> changed;
reload_current_value(handle, &changed); reload_current_value(handle, &changed);
@ -2428,7 +2440,7 @@ extern "C" { // avoid compiler exporting name in C++ style !!!
local_utility::stop_work(); local_utility::stop_work();
hg_sane_middleware::clear(); 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) 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) 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); 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) 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) if (!length)
length = &max_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) 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; return non_blocking ? SANE_STATUS_UNSUPPORTED : SANE_STATUS_GOOD;
} }

9
hgsane/sane_hg_mdw.h
View File

@ -18,6 +18,11 @@
#define ENABLE_SLAVE_OPTION_CONTROL #define ENABLE_SLAVE_OPTION_CONTROL
#define ALIGN_INT(n) ((((n) + sizeof(int) - 1) / sizeof(int)) * sizeof(int)) #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 json;
class hg_sane_middleware class hg_sane_middleware
@ -57,7 +62,7 @@ class hg_sane_middleware
static hg_sane_middleware *inst_; static hg_sane_middleware *inst_;
static const SANE_Device** dev_list_; 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 free_sane_device(SANE_Device** dev); // 释放由to_sane_device返回的指针
static void device_pnp(int sig); // 热插拔事件监控 static void device_pnp(int sig); // 热插拔事件监控
static SANE_Fixed double_2_sane_fixed(double v); 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); 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); OPTEN* get_control_enalbe_data(const SLAVEOP& slave);
void free_control_enable_data(OPTEN* opt); 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: protected:

32
sdk/hginclude/hg_log.h
View File

@ -11,19 +11,29 @@
#define bzero(a, l) memset(a, 0, l) #define bzero(a, l) memset(a, 0, l)
#endif #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 enum hg_log_type
{ {
HG_LOG_TYPE_NONE = 0, // no logging LOG_TYPE_NONE = 0, // no logging
HG_LOG_TYPE_CONSOLE, // print to console LOG_TYPE_CONSOLE, // print to console
HG_LOG_TYPE_FILE, // write log into file LOG_TYPE_FILE, // write log into file
HG_LOG_TYPE_CALLBACK, // invoke callback log_callback LOG_TYPE_CALLBACK, // invoke callback log_callback
}; };
enum hg_log_level enum hg_log_level
{ {
HG_LOG_LEVEL_ALL = 0, LOG_LEVEL_ALL = 0,
HG_LOG_LEVEL_DEBUG_INFO, LOG_LEVEL_DEBUG_INFO,
HG_LOG_LEVEL_WARNING, LOG_LEVEL_WARNING,
HG_LOG_LEVEL_FATAL, LOG_LEVEL_FATAL,
}; };
typedef void (*log_callback)(hg_log_level, const char* info); 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 // 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 // Return: 0 - success, or -1 in 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); 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); void log(hg_log_level level, const char* info);

65
sdk/hginclude/huagaoxxx_warraper_ex.h
View File

@ -83,9 +83,42 @@
/// <summary> /// <summary>
/// 错误代码 /// 错误代码
#define MAX_NAME_LEN 256 #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名称，驱动需要保证该名称唯一， char name[MAX_NAME_LEN]; // 设备ANSI名称，驱动需要保证该名称唯一，
// 即使在有几台同类设备同时连接上时，也能通过该名称访问指定的设备 // 即使在有几台同类设备同时连接上时，也能通过该名称访问指定的设备
@ -93,7 +126,7 @@ typedef struct _hg_device
char vendor[MAX_NAME_LEN]; // 设备制造商 char vendor[MAX_NAME_LEN]; // 设备制造商
char model[MAX_NAME_LEN]; // model name char model[MAX_NAME_LEN]; // model name
char type[MAX_NAME_LEN]; // device type char type[MAX_NAME_LEN]; // device type
}HGScannerInfo; }ScannerInfo;
// hg_scanner_control 控制码及参数 // hg_scanner_control 控制码及参数
// //
@ -173,7 +206,7 @@ extern "C"{
// reserve - 保留 // reserve - 保留
// //
// Return: 状态码 // Return: 状态码
hg_err hg_scanner_initialize(sane_callback callback, void* reserve); scanner_err hg_scanner_initialize(sane_callback callback, void* reserve);
// Function: 退出进程前启动驱动清理工作 // Function: 退出进程前启动驱动清理工作
// //
@ -198,7 +231,7 @@ extern "C"{
// //
// Parameter: scanner_list - 用户分配的空间 // Parameter: scanner_list - 用户分配的空间
// //
// count - [in]：'scanner_list' 的以HGScannerInfo为单位的空间大小； [out]：scanner_list 中返回的设备个数 // count - [in]：'scanner_list' 的以ScannerInfo为单位的空间大小； [out]：scanner_list 中返回的设备个数
// 当'scanner_list'为NULL或者空间小于所需最小长度时，返回所需要的HGScannerInfo元素数 // 当'scanner_list'为NULL或者空间小于所需最小长度时，返回所需要的HGScannerInfo元素数
// 该参数必须非空，如果为NULL，则会返回 EPARAMETERINVAL 的错误 // 该参数必须非空，如果为NULL，则会返回 EPARAMETERINVAL 的错误
// //
@ -207,7 +240,7 @@ extern "C"{
// Return: 错误代码, E_OK or E_INSUFFICIENTMEM or E_PARAMETERINVAL // Return: 错误代码, E_OK or E_INSUFFICIENTMEM or E_PARAMETERINVAL
// //
// NOTE: 'name'空间由用户分配，如果空间太小(包含传入NULL)，会在len中返回所需要的最小空间字节数，并返回 EINSUFFICIENTMEM // 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: 打开指定的设备 // Function: 打开指定的设备
// //
@ -228,7 +261,7 @@ extern "C"{
// 通常用于在需要第三方资源身份验证的时候返回，如果不需要或者已经成功打开，则可忽略该返回内容 // 通常用于在需要第三方资源身份验证的时候返回，如果不需要或者已经成功打开，则可忽略该返回内容
// //
// Return: 错误代码，E_OK or E_ACCESSDENIED or E_DEVICENOTFOUND or E_NOTSUPPORT // 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: 关闭打开的设备 // Function: 关闭打开的设备
// //
@ -238,7 +271,7 @@ extern "C"{
// 为true时，则立即关闭设备并返回成功） // 为true时，则立即关闭设备并返回成功）
// //
// Return: 错误代码，E_OK or E_HASDATAYET // 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: 获取设备的配置参数说明及当前的设置值 // Function: 获取设备的配置参数说明及当前的设置值
// //
@ -257,7 +290,7 @@ extern "C"{
// Return: 错误代码，E_OK or E_INSUFFICIENTMEM or E_PARAMETERINVAL or E_DEVICENOTFOUND or E_OUTOFRANGE // Return: 错误代码，E_OK or E_INSUFFICIENTMEM or E_PARAMETERINVAL or E_DEVICENOTFOUND or E_OUTOFRANGE
// //
// NOTE: 'data'空间由用户分配，如果空间太小(包含传入NULL)，会在len中返回所需要的最小空间字节数，并返回 EINSUFFICIENTMEM // 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: 设置设备的配置参数 // Function: 设置设备的配置参数
// //
@ -278,7 +311,7 @@ extern "C"{
// //
// NOTE: 如果传入的参数不精确，则由驱动选择合适的参数设置并写入到data中，返回 E_NOTEXACT 的错误码。用户需要根据该参数更新UI // NOTE: 如果传入的参数不精确，则由驱动选择合适的参数设置并写入到data中，返回 E_NOTEXACT 的错误码。用户需要根据该参数更新UI
// 以共享方式打开的设备，没有设置权限，会返回 E_ACCESSDENIED 错误。 // 以共享方式打开的设备，没有设置权限，会返回 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: 启动设备工作 // Function: 启动设备工作
// //
@ -289,7 +322,7 @@ extern "C"{
// Return: 错误代码，E_OK or E_NOTSUPPORT or E_DEVICENOTFOUND(句柄非法), E_COVER_OPEN, E_PAPER_JAMMED, E_DEVICEBUSY // Return: 错误代码，E_OK or E_NOTSUPPORT or E_DEVICENOTFOUND(句柄非法), E_COVER_OPEN, E_PAPER_JAMMED, E_DEVICEBUSY
// //
// NOTE: 支持异步IO时，事件需要有[新图片开始(带新图片头信息），新图片数据，出现错误……] 几种基本类型 // 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: 扫描过程中停止设备工作 // Function: 扫描过程中停止设备工作
// //
@ -298,7 +331,7 @@ extern "C"{
// num - 设置扫描页数，-1全部扫描 // num - 设置扫描页数，-1全部扫描
// //
// Return: 错误代码，E_OK or E_DEVICENOTFOUND(句柄非法) // Return: 错误代码，E_OK or E_DEVICENOTFOUND(句柄非法)
hg_err hg_scanner_stop(scanner_handle h); scanner_err hg_scanner_stop(scanner_handle h);
// Function: 读取图片信息 // Function: 读取图片信息
// //
@ -309,7 +342,7 @@ extern "C"{
// len - 'bmi' 大小 // len - 'bmi' 大小
// //
// Return: 错误代码，E_OK or E_NOTSTART // 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: 读取图片数据 // Function: 读取图片数据
// //
@ -320,7 +353,7 @@ extern "C"{
// len - [in]：'data' 大小；[out]：'data'中返回的数据字节数 // len - [in]：'data' 大小；[out]：'data'中返回的数据字节数
// //
// Return: 错误代码。如果为异步IO，没有数据时会立即返回，并返回代码 E_IOPENDING // 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: 获取设备状态 // Function: 获取设备状态
// //
@ -329,7 +362,7 @@ extern "C"{
// setstutas -设置需要获取状态的条件 // setstutas -设置需要获取状态的条件
// //
// Return: 状态码 // Return: 状态码
hg_err hg_scanner_get_status(scanner_handle h, int setstutas); scanner_err hg_scanner_get_status(scanner_handle h, int setstutas);
// Function: 复位设备 // Function: 复位设备
// //
@ -338,7 +371,7 @@ extern "C"{
// Return: 错误码 // Return: 错误码
// //
// NOTE: 从错误中恢复到正常状态 // NOTE: 从错误中恢复到正常状态
hg_err hg_scanner_reset(scanner_handle h); scanner_err hg_scanner_reset(scanner_handle h);
// Function: 直接访问控制 // Function: 直接访问控制
// //
@ -351,7 +384,7 @@ extern "C"{
// len - data中数据长度。如果是获取操作时，长度小于所需要的长度，则返回需要的长度且返回 E_INSUFFICIENTMEM 的错误 // len - data中数据长度。如果是获取操作时，长度小于所需要的长度，则返回需要的长度且返回 E_INSUFFICIENTMEM 的错误
// //
// Return: 错误码 // 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 #ifdef __cplusplus
} }