2022-10-24 14:49:36 +00:00
|
|
|
#include "../../sdk/hginclude/huagaoxxx_warraper_ex.h"
|
2023-07-11 09:13:28 +00:00
|
|
|
|
|
|
|
#include "../../../sdk/include/huagao/brand.h"
|
|
|
|
#include "../../sdk/hginclude/utils.h"
|
2022-05-03 03:56:07 +00:00
|
|
|
#include "../hgdev/scanner_manager.h"
|
|
|
|
#include <iostream>
|
|
|
|
|
2023-01-19 07:43:59 +00:00
|
|
|
#include <lang/app_language.h>
|
|
|
|
#include "../hgdev/common_setting.h"
|
|
|
|
|
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"
|
|
|
|
{
|
2023-01-29 07:01:38 +00:00
|
|
|
static void language_changed(int cp, void* param)
|
|
|
|
{
|
|
|
|
reload_setting_string_from_pak(cp, nullptr);
|
|
|
|
hg_scanner_mgr::instance()->on_language_changed();
|
|
|
|
}
|
|
|
|
|
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(""),
|
2023-07-11 09:13:28 +00:00
|
|
|
pe(utils::get_module_full_path()),
|
2022-06-01 08:11:51 +00:00
|
|
|
path(PATH_SEPARATOR),
|
2022-06-01 03:04:10 +00:00
|
|
|
scanner(g_scanner_path),
|
2023-07-11 09:13:28 +00:00
|
|
|
sane(utils::get_module_full_path((g_sane_name + "." + DLL_EXTESION).c_str()));
|
|
|
|
size_t pos = pe.rfind(path[0]);
|
|
|
|
|
|
|
|
if(pos++ == std::string::npos)
|
|
|
|
pos = 0;
|
|
|
|
name = pe.substr(pos);
|
|
|
|
pe.erase(pos);
|
|
|
|
|
|
|
|
#if !defined(WIN32) && !defined(_WIN64)
|
2023-10-20 07:21:17 +00:00
|
|
|
g_scanner_path = utils::get_module_full_path(MODULE_NAME_SCANNER);
|
2022-06-01 03:04:10 +00:00
|
|
|
scanner = g_scanner_path;
|
2023-07-11 09:13:28 +00:00
|
|
|
#endif
|
|
|
|
pos = g_scanner_path.rfind(path[0]);
|
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);
|
2023-07-11 09:13:28 +00:00
|
|
|
|
|
|
|
utils::init_log(LOG_TYPE_FILE);
|
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "Module device: [%u.%u.%u.%u] - %s\n", VERSION_MAJOR, VERSION_MINOR, VERSION_YEAR, GET_BUILD_VER, scanner.c_str());
|
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "Module sane : [%s] - %s\n", g_sane_ver.c_str(), sane.c_str());
|
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "Module exe : %s\n", (pe + name).c_str());
|
2023-07-14 03:35:50 +00:00
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "Current Path : %s\n", utils::get_command_result("pwd").c_str());
|
2022-05-03 03:56:07 +00:00
|
|
|
|
2023-08-10 02:26:29 +00:00
|
|
|
//if (lang_initialize() == -1)
|
|
|
|
//{
|
|
|
|
// utils::to_log(LOG_LEVEL_FATAL, "No language package found!\n");
|
|
|
|
// return SCANNER_ERR_LANG_PAK_LOST;
|
|
|
|
//}
|
|
|
|
//else
|
|
|
|
//{
|
|
|
|
// std::string lang(utils::get_ini_value("language", "code-page", nullptr));
|
|
|
|
// if(!lang.empty())
|
|
|
|
// {
|
|
|
|
// lang_set_code_page(atoi(lang.c_str()));
|
|
|
|
// utils::to_log(LOG_LEVEL_DEBUG, "Found the language specified by user: %s, code-page after set = %d\n", lang.c_str(), lang_get_cur_code_page());
|
|
|
|
// }
|
|
|
|
//}
|
2023-01-19 07:43:59 +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);
|
|
|
|
|
2023-08-10 02:26:29 +00:00
|
|
|
register_language_changed_notify(language_changed, true);
|
|
|
|
std::string lang(utils::get_ini_value("language", "code-page", nullptr));
|
2023-08-10 03:09:16 +00:00
|
|
|
if (lang.empty() && STRICMP(name.c_str(), "qtsane") == 0)
|
|
|
|
{
|
2023-08-10 03:14:53 +00:00
|
|
|
lang = "20127"; // qtsane can not support chinese !!! we change language to English :(
|
2023-08-10 03:09:16 +00:00
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "Change the default language to English while qtsane does not support Chinese!\n");
|
|
|
|
}
|
2023-08-10 02:26:29 +00:00
|
|
|
if(!lang.empty())
|
|
|
|
{
|
|
|
|
lang_set_code_page(atoi(lang.c_str()));
|
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "Found the language specified by user: %s, code-page after set = %d\n", lang.c_str(), lang_get_cur_code_page());
|
|
|
|
}
|
|
|
|
|
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)
|
|
|
|
{
|
2023-01-29 07:01:38 +00:00
|
|
|
register_language_changed_notify(language_changed, false);
|
2022-05-03 03:56:07 +00:00
|
|
|
hg_scanner_mgr::clear();
|
2023-07-11 09:13:28 +00:00
|
|
|
utils::uninit();
|
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-09-09 10:09:20 +00:00
|
|
|
scanner_err hg_scanner_get_option(scanner_handle h, const char* name, char* data, long* len, int type)
|
2022-05-03 03:56:07 +00:00
|
|
|
{
|
2023-09-09 10:09:20 +00:00
|
|
|
return hg_scanner_mgr::instance()->hg_scanner_get_parameter(h, name, data, len, type);
|
2022-05-03 03:56:07 +00:00
|
|
|
}
|
|
|
|
|
2023-09-09 10:09:20 +00:00
|
|
|
scanner_err hg_scanner_set_option(scanner_handle h, const char* name, void* data, bool to_default)
|
2022-05-03 03:56:07 +00:00
|
|
|
{
|
2023-09-09 10:09:20 +00:00
|
|
|
return hg_scanner_mgr::instance()->hg_scanner_set_parameter(h, name, data, to_default);
|
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);
|
2023-02-18 02:26:38 +00:00
|
|
|
RETURN_IF(err, SCANNER_ERR_RELOAD_IMAGE_PARAM);
|
|
|
|
RETURN_IF(err, SCANNER_ERR_RELOAD_OPT_PARAM);
|
2022-05-30 03:04:26 +00:00
|
|
|
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);
|
2023-02-21 09:52:18 +00:00
|
|
|
RETURN_IF(err, SCANNER_ERR_DEVICE_MAYBE_IS_HOLE);
|
2023-04-14 08:32:01 +00:00
|
|
|
RETURN_IF(err, SCANNER_ERR_DEVICE_DEVS_BOOTING);
|
2023-06-02 03:36:32 +00:00
|
|
|
RETURN_IF(err, SCANNER_ERR_DEVICE_UNKNOWN_STATUS);
|
2022-05-30 03:04:26 +00:00
|
|
|
|
2023-01-19 07:43:59 +00:00
|
|
|
if (err == SCANNER_ERR_LANG_PAK_LOST)
|
|
|
|
return "SCANNER_ERR_LANG_PAK_LOST";
|
|
|
|
|
2022-05-30 03:04:26 +00:00
|
|
|
// NOTE: multi-thread unsafe here
|
|
|
|
static char g_unk_err[80] = { 0 };
|
2023-01-19 07:43:59 +00:00
|
|
|
sprintf(g_unk_err, "Unknown error: 0x%X", err);
|
2022-05-30 03:04:26 +00:00
|
|
|
|
|
|
|
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);
|
|
|
|
|
2023-07-02 06:13:55 +00:00
|
|
|
if (err == SCANNER_ERR_OPENED_BY_OTHER_PROCESS && *hg_scanner_mgr::instance()->last_open_message())
|
|
|
|
return hg_scanner_mgr::instance()->last_open_message();
|
|
|
|
|
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);
|
2023-02-18 02:26:38 +00:00
|
|
|
RETURN_DESC_IF(err, SCANNER_ERR_RELOAD_IMAGE_PARAM);
|
|
|
|
RETURN_DESC_IF(err, SCANNER_ERR_RELOAD_OPT_PARAM);
|
2022-05-30 03:04:26 +00:00
|
|
|
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);
|
2023-02-21 09:52:18 +00:00
|
|
|
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_MAYBE_IS_HOLE);
|
2023-04-14 08:32:01 +00:00
|
|
|
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_DEVS_BOOTING);
|
2023-06-02 03:36:32 +00:00
|
|
|
RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_UNKNOWN_STATUS);
|
2023-01-19 07:43:59 +00:00
|
|
|
if (err == SCANNER_ERR_LANG_PAK_LOST)
|
|
|
|
return "SCANNER_ERR_LANG_PAK_LOST";
|
|
|
|
|
2022-05-30 03:04:26 +00:00
|
|
|
// NOTE: multi-thread unsafe here
|
|
|
|
static char g_unk_err[80] = { 0 };
|
2023-07-11 09:13:28 +00:00
|
|
|
strcpy(g_unk_err, from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_UNKNOWN_ERROR));
|
2023-01-18 02:35:40 +00:00
|
|
|
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)
|
|
|
|
{
|
2023-07-11 09:13:28 +00:00
|
|
|
return level >= utils::get_log_level() && utils::get_log_type() != LOG_TYPE_NONE;
|
2022-05-30 03:04:26 +00:00
|
|
|
}
|
2023-07-11 09:44:33 +00:00
|
|
|
void hg_scanner_log(const char* info, int level)
|
2022-05-30 03:04:26 +00:00
|
|
|
{
|
2023-07-11 09:44:33 +00:00
|
|
|
utils::log_info(info, level);
|
2022-06-01 03:04:10 +00:00
|
|
|
}
|
2022-07-23 05:42:34 +00:00
|
|
|
|
|
|
|
const char* hg_scanner_image_statu_name(int img_statu)
|
|
|
|
{
|
2023-10-31 06:51:14 +00:00
|
|
|
RETURN_IF(img_statu, IMG_STATUS_OK);
|
|
|
|
RETURN_IF(img_statu, IMG_STATUS_BLANK);
|
|
|
|
RETURN_IF(img_statu, IMG_STATUS_DOUBLE);
|
|
|
|
RETURN_IF(img_statu, IMG_STATUS_JAM);
|
|
|
|
RETURN_IF(img_statu, IMG_STATUS_STAPLE);
|
|
|
|
RETURN_IF(img_statu, IMG_STATUS_SIZE_ERR);
|
|
|
|
RETURN_IF(img_statu, IMG_STATUS_DOGEAR);
|
|
|
|
RETURN_IF(img_statu, IMG_STATUS_DOGEAR_PARTIAL);
|
2022-07-23 05:42:34 +00:00
|
|
|
|
|
|
|
// 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
|
|
|
|
2023-07-11 09:44:33 +00:00
|
|
|
int hg_get_full_path_of_module(char* buf, size_t* size, const char* part_name)
|
|
|
|
{
|
|
|
|
if(!size)
|
|
|
|
return EINVAL;
|
|
|
|
|
|
|
|
std::string fullp(utils::get_module_full_path(part_name));
|
|
|
|
if(fullp.empty())
|
|
|
|
return ENOENT;
|
|
|
|
|
|
|
|
if(*size <= fullp.length())
|
|
|
|
{
|
|
|
|
*size = fullp.length() + 4;
|
|
|
|
|
|
|
|
return ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
strcpy(buf, fullp.c_str());
|
|
|
|
*size = fullp.length();
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
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
|