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
code_device/hgdriver/wrapper/huagaoxxx_warraper_ex.cpp

284 lines
9.4 KiB
C++
Raw Blame History

#include "../../sdk/hginclude/huagaoxxx_warraper_ex.h"
#include "../wrapper/hg_log.h"
#include "../hgdev/scanner_manager.h"
#include <iostream>
#ifndef VERSION_MAJOR
#define VERSION_MAJOR 1
#define VERSION_MINOR 0
#define VERSION_YEAR 2022
#define VERSION_BUILD 105181
#endif
#define MAKE_VERSION(a, b, c, d) \
((((unsigned long long)(a) & 0x0ffff) << 48) \
| (((unsigned long long)(b) & 0x0ffff) << 32) \
| (((unsigned long long)(c) & 0x0ffff) << 16) \
| (((unsigned long long)(d) & 0x0ffff) << 0))
std::string g_module_path = "";
static std::string g_sane_name = "";
static std::string g_sane_ver = "";
extern "C"
{
scanner_err hg_scanner_initialize(sane_callback callback, void* reserve)
{
#ifndef WIN32
size_t pos = 0;
g_module_path = hg_log::get_module_full_path((std::string(GET_BACKEND_NAME) + ".so").c_str());
pos = g_module_path.rfind('/');
if (pos++ != std::string::npos)
g_module_path.erase(pos);
#endif
hg_log::init();
hg_scanner_mgr::set_version(VERSION_MAJOR, VERSION_MINOR, VERSION_YEAR, VERSION_BUILD - 100000);
hg_scanner_mgr::instance(callback);
return SCANNER_ERR_OK;
}
void hg_scanner_uninitialize(void)
{
hg_scanner_mgr::clear();
}
unsigned long long hg_scanner_get_version(void)
{
return MAKE_VERSION(VERSION_MAJOR, VERSION_MINOR, VERSION_YEAR, VERSION_BUILD - 100000);
}
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);
}
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);
}
scanner_err hg_scanner_close(scanner_handle h, bool force)
{
return hg_scanner_mgr::instance()->hg_scanner_close(h, force);
}
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);
}
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);
}
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);
}
scanner_err hg_scanner_stop(scanner_handle h)
{
return hg_scanner_mgr::instance()->hg_scanner_stop(h);
}
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);
}
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);
}
scanner_err hg_scanner_get_status(scanner_handle h, int setstutas)
{
return hg_scanner_mgr::instance()->hg_scanner_get_status(h, setstutas);
}
scanner_err hg_scanner_reset(scanner_handle h)
{
return hg_scanner_mgr::instance()->hg_scanner_reset(h);
}
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);
}
void hg_scanner_set_sane_info(const char* name, const char* ver)
{
g_sane_name = name;
g_sane_ver = ver;
}
const char* hg_scanner_err_name(int err)
{
RETURN_IF(err, SANE_STATUS_GOOD);
RETURN_IF(err, SANE_STATUS_UNSUPPORTED);
RETURN_IF(err, SANE_STATUS_CANCELLED);
RETURN_IF(err, SANE_STATUS_DEVICE_BUSY);
RETURN_IF(err, SANE_STATUS_INVAL);
RETURN_IF(err, SANE_STATUS_EOF);
RETURN_IF(err, SANE_STATUS_JAMMED);
RETURN_IF(err, SANE_STATUS_NO_DOCS);
RETURN_IF(err, SANE_STATUS_COVER_OPEN);
RETURN_IF(err, SANE_STATUS_IO_ERROR);
RETURN_IF(err, SANE_STATUS_NO_MEM);
RETURN_IF(err, SANE_STATUS_ACCESS_DENIED);
RETURN_IF(err, SCANNER_ERR_INVALID_PARAMETER);
RETURN_IF(err, SCANNER_ERR_USER_CANCELED);
RETURN_IF(err, SCANNER_ERR_INSUFFICIENT_MEMORY);
RETURN_IF(err, SCANNER_ERR_ACCESS_DENIED);
RETURN_IF(err, SCANNER_ERR_IO_PENDING);
RETURN_IF(err, SCANNER_ERR_NOT_EXACT);
RETURN_IF(err, SCANNER_ERR_CONFIGURATION_CHANGED);
RETURN_IF(err, SCANNER_ERR_NOT_OPEN);
RETURN_IF(err, SCANNER_ERR_NOT_START);
RETURN_IF(err, SCANNER_ERR_NOT_ANY_MORE);
RETURN_IF(err, SCANNER_ERR_NO_DATA);
RETURN_IF(err, SCANNER_ERR_HAS_DATA_YET);
RETURN_IF(err, SCANNER_ERR_OUT_OF_RANGE);
RETURN_IF(err, SCANNER_ERR_IO);
RETURN_IF(err, SCANNER_ERR_TIMEOUT);
RETURN_IF(err, SCANNER_ERR_OPEN_FILE_FAILED);
RETURN_IF(err, SCANNER_ERR_CREATE_FILE_FAILED);
RETURN_IF(err, SCANNER_ERR_WRITE_FILE_FAILED);
RETURN_IF(err, SCANNER_ERR_DATA_DAMAGED);
RETURN_IF(err, SCANNER_ERR_USB_INIT_FAILED);
RETURN_IF(err, SCANNER_ERR_USB_REGISTER_PNP_FAILED);
RETURN_IF(err, SCANNER_ERR_USB_CLAIM_INTERFACE_FAILED);
RETURN_IF(err, SCANNER_ERR_DEVICE_NOT_FOUND);
RETURN_IF(err, SCANNER_ERR_DEVICE_NOT_SUPPORT);
RETURN_IF(err, SCANNER_ERR_DEVICE_BUSY);
RETURN_IF(err, SCANNER_ERR_DEVICE_SLEEPING);
RETURN_IF(err, SCANNER_ERR_DEVICE_COUNT_MODE);
RETURN_IF(err, SCANNER_ERR_DEVICE_STOPPED);
RETURN_IF(err, SCANNER_ERR_DEVICE_COVER_OPENNED);
RETURN_IF(err, SCANNER_ERR_DEVICE_NO_PAPER);
RETURN_IF(err, SCANNER_ERR_DEVICE_FEEDING_PAPER);
RETURN_IF(err, SCANNER_ERR_DEVICE_DOUBLE_FEEDING);
RETURN_IF(err, SCANNER_ERR_DEVICE_PAPER_JAMMED);
RETURN_IF(err, SCANNER_ERR_DEVICE_STAPLE_ON);
RETURN_IF(err, SCANNER_ERR_DEVICE_PAPER_SKEW);
RETURN_IF(err, SCANNER_ERR_DEVICE_SIZE_CHECK);
RETURN_IF(err, SCANNER_ERR_DEVICE_DOGEAR);
RETURN_IF(err, SCANNER_ERR_DEVICE_NO_IMAGE);
RETURN_IF(err, SCANNER_ERR_DEVICE_SCANN_ERROR);
RETURN_IF(err, SCANNER_ERR_DEVICE_PC_BUSY);
// NOTE: multi-thread unsafe here
static char g_unk_err[80] = { 0 };
sprintf(g_unk_err, "\346\234\252\347\237\245\351\224\231\350\257\257\357\274\2320x%X", err);
return g_unk_err;
}
const char* hg_scanner_err_description(int err)
{
RETURN_DESC_IF(err, SCANNER_ERR_OK);
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_NOT_SUPPORT);
RETURN_DESC_IF(err, SCANNER_ERR_USER_CANCELED);
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_BUSY);
RETURN_DESC_IF(err, SCANNER_ERR_INVALID_PARAMETER);
RETURN_DESC_IF(err, SCANNER_ERR_NO_DATA);
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_PAPER_JAMMED);
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_NO_PAPER);
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_COVER_OPENNED);
RETURN_DESC_IF(err, SCANNER_ERR_IO);
RETURN_DESC_IF(err, SCANNER_ERR_INSUFFICIENT_MEMORY);
RETURN_DESC_IF(err, SCANNER_ERR_ACCESS_DENIED);
RETURN_DESC_IF(err, SCANNER_ERR_INSUFFICIENT_MEMORY);
RETURN_DESC_IF(err, SCANNER_ERR_ACCESS_DENIED);
RETURN_DESC_IF(err, SCANNER_ERR_IO_PENDING);
RETURN_DESC_IF(err, SCANNER_ERR_NOT_EXACT);
RETURN_DESC_IF(err, SCANNER_ERR_CONFIGURATION_CHANGED);
RETURN_DESC_IF(err, SCANNER_ERR_NOT_OPEN);
RETURN_DESC_IF(err, SCANNER_ERR_NOT_START);
RETURN_DESC_IF(err, SCANNER_ERR_NOT_ANY_MORE);
RETURN_DESC_IF(err, SCANNER_ERR_NO_DATA);
RETURN_DESC_IF(err, SCANNER_ERR_HAS_DATA_YET);
RETURN_DESC_IF(err, SCANNER_ERR_OUT_OF_RANGE);
RETURN_DESC_IF(err, SCANNER_ERR_IO);
RETURN_DESC_IF(err, SCANNER_ERR_TIMEOUT);
RETURN_DESC_IF(err, SCANNER_ERR_OPEN_FILE_FAILED);
RETURN_DESC_IF(err, SCANNER_ERR_CREATE_FILE_FAILED);
RETURN_DESC_IF(err, SCANNER_ERR_WRITE_FILE_FAILED);
RETURN_DESC_IF(err, SCANNER_ERR_DATA_DAMAGED);
RETURN_DESC_IF(err, SCANNER_ERR_USB_INIT_FAILED);
RETURN_DESC_IF(err, SCANNER_ERR_USB_REGISTER_PNP_FAILED);
RETURN_DESC_IF(err, SCANNER_ERR_USB_CLAIM_INTERFACE_FAILED);
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_NOT_FOUND);
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_NOT_SUPPORT);
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_BUSY);
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_SLEEPING);
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_COUNT_MODE);
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_STOPPED);
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_COVER_OPENNED);
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_NO_PAPER);
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_FEEDING_PAPER);
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_DOUBLE_FEEDING);
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_PAPER_JAMMED);
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_STAPLE_ON);
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_PAPER_SKEW);
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_SIZE_CHECK);
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_DOGEAR);
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_NO_IMAGE);
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_SCANN_ERROR);
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_PC_BUSY);
// NOTE: multi-thread unsafe here
static char g_unk_err[80] = { 0 };
sprintf(g_unk_err, "\346\234\252\347\237\245\351\224\231\350\257\257\357\274\2320x%X", err);
return g_unk_err;
}
bool hg_scanner_log_is_enable(int level)
{
return hg_log::is_log_level_enabled(level);
}
void hg_scanner_log(const char* info)
{
hg_log::log(info);
}
char* get_file_path(const char* name, char* buf)
{
std::string fp(hg_log::get_module_full_path(name));
if (fp.empty())
*buf = 0;
else
strcpy(buf, fp.c_str());
return buf;
}
}
#ifdef WIN32
BOOL WINAPI DllMain(HINSTANCE inst, DWORD reason, LPVOID reserved)
{
if (reason == DLL_PROCESS_ATTACH)
{
if (g_module_path.empty())
{
char path[MAX_PATH] = { 0 };
GetModuleFileNameA(inst, path, _countof(path) - 1);
if (strrchr(path, '\\'))
{
strrchr(path, '\\')[1] = 0;
g_module_path = path;
}
}
}
return TRUE;
}
#endif
Reference in New Issue View Git Blame Copy Permalink