353 lines
11 KiB
C++
353 lines
11 KiB
C++
#include "../../sdk/hginclude/huagaoxxx_warraper_ex.h"
|
|
#include "../wrapper/hg_log.h"
|
|
#include "../hgdev/scanner_manager.h"
|
|
#include <iostream>
|
|
|
|
#ifdef WIN32
|
|
#include <fileapi.h>
|
|
#else
|
|
#include <sys/vfs.h>
|
|
#include <string.h>
|
|
#endif
|
|
|
|
#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))
|
|
#define GET_BUILD_VER VERSION_BUILD - 100000
|
|
|
|
std::string g_scanner_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)
|
|
{
|
|
std::string name(""),
|
|
pe(hg_log::pe_path(&name)),
|
|
path(PATH_SEPARATOR),
|
|
scanner(g_scanner_path),
|
|
sane(hg_log::get_module_full_path((g_sane_name + DLL_EXTESION).c_str()));
|
|
#ifdef WIN32
|
|
size_t pos = g_scanner_path.rfind('\\');
|
|
if (pos++ != std::string::npos)
|
|
g_scanner_path.erase(pos);
|
|
#else
|
|
size_t pos = 0;
|
|
g_scanner_path = hg_log::get_module_full_path((std::string(GET_BACKEND_NAME) + ".so").c_str());
|
|
scanner = g_scanner_path;
|
|
pos = g_scanner_path.rfind('/');
|
|
if (pos++ != std::string::npos)
|
|
g_scanner_path.erase(pos);
|
|
#endif
|
|
hg_log::init();
|
|
VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "Module device: [%u.%u.%u.%u] - %s\n", VERSION_MAJOR, VERSION_MINOR, VERSION_YEAR, GET_BUILD_VER, scanner.c_str());
|
|
VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "Module sane : [%s] - %s\n", g_sane_ver.c_str(), sane.c_str());
|
|
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Module exe : %s\n", (pe + path + name).c_str());
|
|
|
|
hg_scanner_mgr::set_version(VERSION_MAJOR, VERSION_MINOR, VERSION_YEAR, GET_BUILD_VER);
|
|
hg_scanner_mgr::instance(callback);
|
|
|
|
return SCANNER_ERR_OK;
|
|
}
|
|
void hg_scanner_uninitialize(void)
|
|
{
|
|
hg_scanner_mgr::clear();
|
|
hg_log::unint();
|
|
}
|
|
|
|
unsigned long long hg_scanner_get_version(void)
|
|
{
|
|
return MAKE_VERSION(VERSION_MAJOR, VERSION_MINOR, VERSION_YEAR, GET_BUILD_VER);
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
int get_disk_space(const char* path, unsigned long long* total, unsigned long long* avail, unsigned long long* block)
|
|
{
|
|
int ret = SCANNER_ERR_OK;
|
|
|
|
#ifdef WIN32
|
|
ULARGE_INTEGER av = { 0 },
|
|
all = { 0 };
|
|
if (GetDiskFreeSpaceExA(path, &av, &all, NULL))
|
|
{
|
|
if (total)
|
|
*total = all.QuadPart;
|
|
if (avail)
|
|
*avail = av.QuadPart;
|
|
if (block)
|
|
{
|
|
DWORD sec = 0,
|
|
clu = 0;
|
|
std::string root(path);
|
|
size_t pos = root.find(":\\");
|
|
if (pos != std::string::npos)
|
|
root.erase(pos + 2);
|
|
if (GetDiskFreeSpaceA(root.c_str(), &clu, &sec, NULL, NULL))
|
|
{
|
|
*block = clu * sec;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
ret = GetLastError();
|
|
#else
|
|
struct statfs fs = { 0 };
|
|
|
|
ret = statfs(path, &fs);
|
|
if (ret == 0)
|
|
{
|
|
VLOG_MINI_4(LOG_LEVEL_DEBUG_INFO, " Total: %lld, Free: %lld, Avail: %lld, block size: %lld\n",
|
|
fs.f_blocks, fs.f_bfree, fs.f_bavail, fs.f_bsize);
|
|
if (total)
|
|
*total = fs.f_blocks * fs.f_bsize;
|
|
if (avail)
|
|
*avail = fs.f_bavail * fs.f_bsize;
|
|
if (block)
|
|
*block = fs.f_bsize;
|
|
}
|
|
#endif
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
|
|
#ifdef WIN32
|
|
|
|
BOOL WINAPI DllMain(HINSTANCE inst, DWORD reason, LPVOID reserved)
|
|
{
|
|
if (reason == DLL_PROCESS_ATTACH)
|
|
{
|
|
if (g_scanner_path.empty())
|
|
{
|
|
char path[MAX_PATH] = { 0 };
|
|
|
|
GetModuleFileNameA(inst, path, _countof(path) - 1);
|
|
// if (strrchr(path, '\\'))
|
|
{
|
|
// strrchr(path, '\\')[1] = 0;
|
|
g_scanner_path = path;
|
|
}
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
#endif
|