2022-10-24 14:49:36 +00:00
|
|
|
#include "../../sdk/hginclude/huagaoxxx_warraper_ex.h"
|
2022-05-30 03:04:26 +00:00
|
|
|
#include "../wrapper/hg_log.h"
|
2022-05-03 03:56:07 +00:00
|
|
|
#include "../hgdev/scanner_manager.h"
|
|
|
|
#include <iostream>
|
|
|
|
|
2022-07-18 08:56:03 +00:00
|
|
|
#if defined(WIN32) || defined(_WIN64)
|
2022-06-01 03:04:10 +00:00
|
|
|
#include <fileapi.h>
|
|
|
|
#else
|
|
|
|
#include <sys/vfs.h>
|
|
|
|
#include <string.h>
|
|
|
|
#endif
|
2022-10-24 14:49:36 +00:00
|
|
|
#include <math.h>
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
|
|
#define MAKE_VERSION(a, b, c, d) \
|
2022-05-17 07:57:09 +00:00
|
|
|
((((unsigned long long)(a) & 0x0ffff) << 48) \
|
|
|
|
| (((unsigned long long)(b) & 0x0ffff) << 32) \
|
|
|
|
| (((unsigned long long)(c) & 0x0ffff) << 16) \
|
|
|
|
| (((unsigned long long)(d) & 0x0ffff) << 0))
|
2022-05-03 03:56:07 +00:00
|
|
|
|
2022-06-01 03:04:10 +00:00
|
|
|
std::string g_scanner_path = "";
|
2022-05-30 09:36:42 +00:00
|
|
|
static std::string g_sane_name = "";
|
|
|
|
static std::string g_sane_ver = "";
|
|
|
|
|
2022-07-21 09:54:58 +00:00
|
|
|
namespace err_map
|
|
|
|
{
|
|
|
|
struct
|
|
|
|
{
|
|
|
|
int sane;
|
|
|
|
int scanner;
|
|
|
|
}g_err_map[] =
|
|
|
|
{ {SANE_STATUS_GOOD, SCANNER_ERR_OK}
|
|
|
|
, {SANE_STATUS_UNSUPPORTED, SCANNER_ERR_DEVICE_NOT_SUPPORT}
|
|
|
|
, {SANE_STATUS_CANCELLED, SCANNER_ERR_USER_CANCELED}
|
|
|
|
, {SANE_STATUS_DEVICE_BUSY, SCANNER_ERR_DEVICE_BUSY}
|
|
|
|
, {SANE_STATUS_INVAL, SCANNER_ERR_INVALID_PARAMETER}
|
|
|
|
, {SANE_STATUS_EOF, SCANNER_ERR_NO_DATA}
|
|
|
|
, {SANE_STATUS_JAMMED, SCANNER_ERR_DEVICE_PAPER_JAMMED}
|
|
|
|
, {SANE_STATUS_NO_DOCS, SCANNER_ERR_DEVICE_NO_PAPER}
|
|
|
|
, {SANE_STATUS_COVER_OPEN, SCANNER_ERR_DEVICE_COVER_OPENNED}
|
|
|
|
, {SANE_STATUS_IO_ERROR, SCANNER_ERR_IO}
|
|
|
|
, {SANE_STATUS_NO_MEM, SCANNER_ERR_INSUFFICIENT_MEMORY}
|
|
|
|
, {SANE_STATUS_ACCESS_DENIED, SCANNER_ERR_ACCESS_DENIED}
|
|
|
|
};
|
|
|
|
|
|
|
|
static int sane_2_scanner(int sane)
|
|
|
|
{
|
|
|
|
for (size_t i = 0; i < _countof(g_err_map); ++i)
|
|
|
|
{
|
|
|
|
if (g_err_map[i].sane == sane)
|
|
|
|
return g_err_map[i].scanner;
|
|
|
|
}
|
|
|
|
|
|
|
|
return sane;
|
|
|
|
}
|
|
|
|
static int scanner_2_sane(int scanner)
|
|
|
|
{
|
|
|
|
for (size_t i = 0; i < _countof(g_err_map); ++i)
|
|
|
|
{
|
|
|
|
if (g_err_map[i].scanner == scanner)
|
|
|
|
return g_err_map[i].sane;
|
|
|
|
}
|
|
|
|
|
|
|
|
return scanner;
|
|
|
|
}
|
|
|
|
}
|
2022-05-03 03:56:07 +00:00
|
|
|
extern "C"
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
scanner_err hg_scanner_initialize(sane_callback callback, void* reserve)
|
2022-05-03 03:56:07 +00:00
|
|
|
{
|
2022-06-01 03:04:10 +00:00
|
|
|
std::string name(""),
|
|
|
|
pe(hg_log::pe_path(&name)),
|
2022-06-01 08:11:51 +00:00
|
|
|
path(PATH_SEPARATOR),
|
2022-06-01 03:04:10 +00:00
|
|
|
scanner(g_scanner_path),
|
2022-06-01 08:11:51 +00:00
|
|
|
sane(hg_log::get_module_full_path((g_sane_name + DLL_EXTESION).c_str()));
|
2022-07-18 08:56:03 +00:00
|
|
|
#if defined(WIN32) || defined(_WIN64)
|
2022-06-01 03:04:10 +00:00
|
|
|
size_t pos = g_scanner_path.rfind('\\');
|
|
|
|
if (pos++ != std::string::npos)
|
|
|
|
g_scanner_path.erase(pos);
|
|
|
|
#else
|
2022-05-30 09:36:42 +00:00
|
|
|
size_t pos = 0;
|
2022-06-01 03:04:10 +00:00
|
|
|
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('/');
|
2022-05-30 09:36:42 +00:00
|
|
|
if (pos++ != std::string::npos)
|
2022-06-01 03:04:10 +00:00
|
|
|
g_scanner_path.erase(pos);
|
2022-05-30 09:36:42 +00:00
|
|
|
#endif
|
2022-05-30 03:04:26 +00:00
|
|
|
hg_log::init();
|
2022-06-01 03:04:10 +00:00
|
|
|
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());
|
2022-05-03 03:56:07 +00:00
|
|
|
|
2022-06-01 03:04:10 +00:00
|
|
|
hg_scanner_mgr::set_version(VERSION_MAJOR, VERSION_MINOR, VERSION_YEAR, GET_BUILD_VER);
|
2022-09-23 02:26:04 +00:00
|
|
|
hg_scanner_mgr::set_exe_name(pe.c_str(), name.c_str());
|
2022-05-03 03:56:07 +00:00
|
|
|
hg_scanner_mgr::instance(callback);
|
|
|
|
|
2022-05-17 07:04:55 +00:00
|
|
|
return SCANNER_ERR_OK;
|
2022-05-03 03:56:07 +00:00
|
|
|
}
|
|
|
|
void hg_scanner_uninitialize(void)
|
|
|
|
{
|
|
|
|
hg_scanner_mgr::clear();
|
2022-06-01 03:04:10 +00:00
|
|
|
hg_log::unint();
|
2022-05-03 03:56:07 +00:00
|
|
|
}
|
|
|
|
|
2022-05-17 07:57:09 +00:00
|
|
|
unsigned long long hg_scanner_get_version(void)
|
2022-05-03 03:56:07 +00:00
|
|
|
{
|
2022-06-01 03:04:10 +00:00
|
|
|
return MAKE_VERSION(VERSION_MAJOR, VERSION_MINOR, VERSION_YEAR, GET_BUILD_VER);
|
2022-05-03 03:56:07 +00:00
|
|
|
}
|
|
|
|
|
2022-05-17 07:04:55 +00:00
|
|
|
scanner_err hg_scanner_enum(ScannerInfo* scanner_list, long* count, bool local_only)
|
2022-05-03 03:56:07 +00:00
|
|
|
{
|
|
|
|
return hg_scanner_mgr::instance()->hg_scanner_enum(scanner_list, count, local_only);
|
|
|
|
}
|
|
|
|
|
2022-05-17 07:04:55 +00:00
|
|
|
scanner_err hg_scanner_open(scanner_handle* h, const char* name, bool shared, const char* user, const char* pwd, const char* check, char* rsc)
|
2022-05-03 03:56:07 +00:00
|
|
|
{
|
|
|
|
return hg_scanner_mgr::instance()->hg_scanner_open(h, name, shared, user, pwd, check, rsc);
|
|
|
|
}
|
|
|
|
|
2022-05-17 07:04:55 +00:00
|
|
|
scanner_err hg_scanner_close(scanner_handle h, bool force)
|
2022-05-03 03:56:07 +00:00
|
|
|
{
|
|
|
|
return hg_scanner_mgr::instance()->hg_scanner_close(h, force);
|
|
|
|
}
|
|
|
|
|
2023-01-10 06:21:39 +00:00
|
|
|
scanner_err hg_scanner_get_parameter(scanner_handle h, const char* name, char* data, long* len, SANE_Int* id)
|
2022-05-03 03:56:07 +00:00
|
|
|
{
|
2023-01-10 06:21:39 +00:00
|
|
|
return hg_scanner_mgr::instance()->hg_scanner_get_parameter(h, name, data, len, id);
|
2022-05-03 03:56:07 +00:00
|
|
|
}
|
|
|
|
|
2022-11-10 02:02:52 +00:00
|
|
|
scanner_err hg_scanner_set_parameter(scanner_handle h, const char* name, void* data, long len)
|
2022-05-03 03:56:07 +00:00
|
|
|
{
|
2022-11-10 02:02:52 +00:00
|
|
|
return hg_scanner_mgr::instance()->hg_scanner_set_parameter(h, name, data, len);
|
2022-05-03 03:56:07 +00:00
|
|
|
}
|
|
|
|
|
2022-05-17 07:04:55 +00:00
|
|
|
scanner_err hg_scanner_start(scanner_handle h, void* async_event, int num)
|
2022-05-03 03:56:07 +00:00
|
|
|
{
|
|
|
|
return hg_scanner_mgr::instance()->hg_scanner_start(h, async_event, num);
|
|
|
|
}
|
|
|
|
|
2022-05-17 07:04:55 +00:00
|
|
|
scanner_err hg_scanner_stop(scanner_handle h)
|
2022-05-03 03:56:07 +00:00
|
|
|
{
|
|
|
|
return hg_scanner_mgr::instance()->hg_scanner_stop(h);
|
|
|
|
}
|
|
|
|
|
2022-05-17 07:04:55 +00:00
|
|
|
scanner_err hg_scanner_get_img_info(scanner_handle h, SANE_Parameters* bmi, long len)
|
2022-05-03 03:56:07 +00:00
|
|
|
{
|
|
|
|
return hg_scanner_mgr::instance()->hg_scanner_get_img_info(h, bmi, len);
|
|
|
|
}
|
|
|
|
|
2022-05-17 07:04:55 +00:00
|
|
|
scanner_err hg_scanner_read_img_data(scanner_handle h, unsigned char* data, long* len)
|
2022-05-03 03:56:07 +00:00
|
|
|
{
|
|
|
|
return hg_scanner_mgr::instance()->hg_scanner_read_img_data(h, data, len);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2022-05-17 07:04:55 +00:00
|
|
|
scanner_err hg_scanner_get_status(scanner_handle h, int setstutas)
|
2022-05-03 03:56:07 +00:00
|
|
|
{
|
|
|
|
return hg_scanner_mgr::instance()->hg_scanner_get_status(h, setstutas);
|
|
|
|
}
|
|
|
|
|
2022-05-17 07:04:55 +00:00
|
|
|
scanner_err hg_scanner_reset(scanner_handle h)
|
2022-05-03 03:56:07 +00:00
|
|
|
{
|
|
|
|
return hg_scanner_mgr::instance()->hg_scanner_reset(h);
|
|
|
|
}
|
|
|
|
|
2022-05-17 07:04:55 +00:00
|
|
|
scanner_err hg_scanner_control(scanner_handle h, unsigned long code, void* data, unsigned* len)
|
2022-05-03 03:56:07 +00:00
|
|
|
{
|
|
|
|
return hg_scanner_mgr::instance()->hg_scanner_control(h, code, data, len);
|
|
|
|
}
|
2022-05-30 03:04:26 +00:00
|
|
|
|
|
|
|
void hg_scanner_set_sane_info(const char* name, const char* ver)
|
|
|
|
{
|
2022-05-30 09:36:42 +00:00
|
|
|
g_sane_name = name;
|
|
|
|
g_sane_ver = ver;
|
2022-05-30 03:04:26 +00:00
|
|
|
}
|
|
|
|
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);
|
2022-06-08 01:31:35 +00:00
|
|
|
RETURN_IF(err, SCANNER_ERR_OPENED_BY_OTHER_PROCESS);
|
2022-05-30 03:04:26 +00:00
|
|
|
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);
|
2022-10-28 03:01:01 +00:00
|
|
|
RETURN_IF(err, SCANNER_ERR_DEVICE_ISLOCK);
|
2022-05-30 03:04:26 +00:00
|
|
|
|
|
|
|
// 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)
|
|
|
|
{
|
2022-07-21 09:54:58 +00:00
|
|
|
if (err < 0x100)
|
|
|
|
err = err_map::sane_2_scanner(err);
|
|
|
|
|
2022-05-30 03:04:26 +00:00
|
|
|
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);
|
2022-06-08 01:31:35 +00:00
|
|
|
RETURN_DESC_IF(err, SCANNER_ERR_OPENED_BY_OTHER_PROCESS);
|
2022-05-30 03:04:26 +00:00
|
|
|
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);
|
2022-11-24 16:25:54 +00:00
|
|
|
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_ISLOCK);
|
2022-05-30 03:04:26 +00:00
|
|
|
|
|
|
|
// NOTE: multi-thread unsafe here
|
|
|
|
static char g_unk_err[80] = { 0 };
|
2023-01-18 02:35:40 +00:00
|
|
|
strcpy(g_unk_err, STATU_DESC_SCANNER_ERR_DEVICE_UNKNOWN_ERROR);
|
|
|
|
sprintf(g_unk_err + strlen(g_unk_err), ":0x%x", err);
|
2022-05-30 03:04:26 +00:00
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
2022-05-30 09:36:42 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
2022-06-01 03:04:10 +00:00
|
|
|
|
|
|
|
int get_disk_space(const char* path, unsigned long long* total, unsigned long long* avail, unsigned long long* block)
|
|
|
|
{
|
|
|
|
int ret = SCANNER_ERR_OK;
|
|
|
|
|
2022-07-18 08:56:03 +00:00
|
|
|
#if defined(WIN32) || defined(_WIN64)
|
2022-06-01 03:04:10 +00:00
|
|
|
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;
|
|
|
|
}
|
2022-07-23 05:42:34 +00:00
|
|
|
|
|
|
|
const char* hg_scanner_image_statu_name(int img_statu)
|
|
|
|
{
|
|
|
|
RETURN_IF(img_statu, SANE_Image_Statu_OK);
|
|
|
|
RETURN_IF(img_statu, SANE_Image_Statu_Blank);
|
|
|
|
RETURN_IF(img_statu, SANE_Image_Statu_Double);
|
|
|
|
RETURN_IF(img_statu, SANE_Image_Statu_Jammed);
|
|
|
|
|
|
|
|
// NOTE: multi-thread unsafe here
|
|
|
|
static char g_unk_statu[80] = { 0 };
|
|
|
|
sprintf(g_unk_statu, "Unknowned image statu: 0x%X", img_statu);
|
|
|
|
|
|
|
|
return g_unk_statu;
|
|
|
|
}
|
2022-11-08 03:21:50 +00:00
|
|
|
|
|
|
|
void get_current_time(char* tmbuf, struct tm* t)
|
|
|
|
{
|
|
|
|
#if defined(WIN32) || defined(_WIN64)
|
|
|
|
static long bias = -1;
|
|
|
|
static bool as_start = true;
|
|
|
|
|
|
|
|
if (bias == -1)
|
|
|
|
{
|
|
|
|
_get_timezone(&bias);
|
|
|
|
as_start = hg_log::ini_get("time", "adjust") != "no";
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
time_t now = time(nullptr);
|
|
|
|
struct tm* l = localtime(&now);
|
|
|
|
|
|
|
|
#if defined(WIN32) || defined(_WIN64)
|
|
|
|
long after = 0;
|
|
|
|
if (as_start && _get_timezone(&after) == 0 &&
|
2022-11-10 02:02:52 +00:00
|
|
|
(after != bias && after != -bias))
|
2022-11-08 03:21:50 +00:00
|
|
|
{
|
|
|
|
now += bias;
|
|
|
|
l = localtime(&now);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (t)
|
|
|
|
*t = *l;
|
|
|
|
if (tmbuf)
|
|
|
|
sprintf(tmbuf, "%04d-%02d-%02d %02d:%02d:%02d", l->tm_year + 1900, l->tm_mon + 1, l->tm_mday, l->tm_hour, l->tm_min, l->tm_sec);
|
|
|
|
}
|
|
|
|
void get_current_time_w(wchar_t* tmbuf, struct tm* t)
|
|
|
|
{
|
|
|
|
struct tm tmp = { 0 }, * l = &tmp;
|
|
|
|
|
|
|
|
get_current_time(nullptr, l);
|
|
|
|
if (t)
|
|
|
|
*t = *l;
|
|
|
|
if (tmbuf)
|
2022-11-10 02:02:52 +00:00
|
|
|
swprintf(tmbuf, 40, L"%04d-%02d-%02d %02d:%02d:%02d", l->tm_year + 1900, l->tm_mon + 1, l->tm_mday, l->tm_hour, l->tm_min, l->tm_sec);
|
2022-11-08 03:21:50 +00:00
|
|
|
}
|
2022-05-27 01:24:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2022-07-18 08:56:03 +00:00
|
|
|
#if defined(WIN32) || defined(_WIN64)
|
2022-05-27 01:24:28 +00:00
|
|
|
|
|
|
|
BOOL WINAPI DllMain(HINSTANCE inst, DWORD reason, LPVOID reserved)
|
|
|
|
{
|
|
|
|
if (reason == DLL_PROCESS_ATTACH)
|
|
|
|
{
|
2022-06-01 03:04:10 +00:00
|
|
|
if (g_scanner_path.empty())
|
2022-05-27 01:24:28 +00:00
|
|
|
{
|
|
|
|
char path[MAX_PATH] = { 0 };
|
|
|
|
|
|
|
|
GetModuleFileNameA(inst, path, _countof(path) - 1);
|
2022-06-01 03:04:10 +00:00
|
|
|
// if (strrchr(path, '\\'))
|
2022-05-27 01:24:28 +00:00
|
|
|
{
|
2022-06-01 03:04:10 +00:00
|
|
|
// strrchr(path, '\\')[1] = 0;
|
|
|
|
g_scanner_path = path;
|
2022-05-27 01:24:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
#endif
|