增加图像扩展信息接口;增加SANE接口;调整语言包转换方式
This commit is contained in:
parent
e3b51facd9
commit
6e968c93f4
|
@ -23,8 +23,9 @@ private:
|
|||
std::condition_variable _condvar;
|
||||
typedef struct _dq
|
||||
{
|
||||
size_t bytes;
|
||||
T t;
|
||||
size_t bytes;
|
||||
uint32_t id;
|
||||
T t;
|
||||
}DQ;
|
||||
deque<DQ> _queue;
|
||||
size_t bytes_;
|
||||
|
@ -67,13 +68,13 @@ public:
|
|||
return isShutDown;
|
||||
}
|
||||
|
||||
void Put(const T task, size_t bytes)
|
||||
void Put(const T task, size_t bytes, uint32_t id = -1)
|
||||
{
|
||||
lock_guard<mutex> lock(_mutex);
|
||||
if (!isShutDown)
|
||||
{
|
||||
{
|
||||
DQ dq = { bytes, task };
|
||||
DQ dq = { bytes, id, task };
|
||||
_queue.push_back(dq);
|
||||
bytes_ += bytes;
|
||||
}
|
||||
|
@ -82,7 +83,7 @@ public:
|
|||
|
||||
}
|
||||
|
||||
T Take()
|
||||
T Take(uint32_t* id = nullptr)
|
||||
{
|
||||
unique_lock<mutex> lock(_mutex);
|
||||
if (_queue.size() <= 0)
|
||||
|
@ -96,11 +97,13 @@ public:
|
|||
DQ front(_queue.front());
|
||||
_queue.pop_front();
|
||||
bytes_ -= front.bytes;
|
||||
if (id)
|
||||
*id = front.id;
|
||||
|
||||
return front.t;
|
||||
}
|
||||
|
||||
T Front()
|
||||
T Front(uint32_t* id = nullptr)
|
||||
{
|
||||
unique_lock<mutex> lock(_mutex);
|
||||
if (_queue.size() <= 0)
|
||||
|
|
|
@ -786,7 +786,7 @@ void final_img_queue::clear(void)
|
|||
queue_.clear();
|
||||
}
|
||||
bool final_img_queue::put(int w, int h, int bpp, int channels, int line_bytes, void* data, unsigned bytes
|
||||
, const char* tmp_path, const char* name_leading, const char* ext, int ind)
|
||||
, const char* tmp_path, const char* name_leading, const char* ext, int ind, uint32_t id)
|
||||
{
|
||||
IMGDT imgd;
|
||||
bool ret = false;
|
||||
|
@ -798,6 +798,7 @@ bool final_img_queue::put(int w, int h, int bpp, int channels, int line_bytes, v
|
|||
imgd.header.height = h;
|
||||
imgd.header.line_bytes = line_bytes;
|
||||
imgd.header.width = w;
|
||||
imgd.header.src_id = id;
|
||||
imgd.offset = 0;
|
||||
imgd.data.reset(new tiny_buffer(bytes, tmp_path, name_leading, ext, ind));
|
||||
|
||||
|
|
|
@ -214,6 +214,7 @@ typedef struct _img_header
|
|||
int channels;
|
||||
int line_bytes;
|
||||
unsigned bytes;
|
||||
uint32_t src_id;
|
||||
}IMH;
|
||||
typedef struct _img
|
||||
{
|
||||
|
@ -236,7 +237,7 @@ public:
|
|||
size_t size(void);
|
||||
void clear(void);
|
||||
bool put(int w, int h, int bpp, int channels, int line_bytes, void* data, unsigned bytes
|
||||
, const char* tmp_path, const char* name_leading, const char* ext, int ind);
|
||||
, const char* tmp_path, const char* name_leading, const char* ext, int ind, uint32_t id);
|
||||
bool front(IMH* header);
|
||||
void fetch_front(void* buf, int* len, bool* over);
|
||||
};
|
|
@ -156,7 +156,7 @@ hg_scanner::hg_scanner(ScannerSerial serial, const char* dev_name, usb_io* io,in
|
|||
, is_kernelsnap_221027_(false), memory_size_(2000/*USB+JPEG压缩及图像处理图队列,总共1GB*/), isx86_Advan_(true), stop_fatal_(SCANNER_ERR_OK), is_auto_paper_scan(false)
|
||||
, size_check(false), save_sleeptime_type_(false), is_kernelsnap_devsislock(false), is_checksum_strat_scan(false), is_cis_image(false)
|
||||
, is_dpi_color_check(false),save_dpi_color_check_val(0.0f), is_auto_falt(false),HGVersion_mgr_(NULL), HGVersion_Init_(NULL)
|
||||
, HGVersion_Islock_(NULL), HGVersion_Postlog_(NULL), HGVersion_Free_(NULL), Dynamicopen_HGVersion_pHandle_(NULL),pid_(pid)
|
||||
, HGVersion_Islock_(NULL), HGVersion_Postlog_(NULL), HGVersion_Free_(NULL), Dynamicopen_HGVersion_pHandle_(NULL),pid_(pid), fetching_id_(-1)
|
||||
{
|
||||
#if !defined(_WIN32) && !defined(_WIN64) &&defined(x86_64)
|
||||
isx86_Advan_ = false;
|
||||
|
@ -677,7 +677,14 @@ void hg_scanner::get_range(const char* name, std::vector<std::string>& range, st
|
|||
else
|
||||
{
|
||||
std::string v("");
|
||||
setting_jsn_.at(name).at("range").at(i).get_to(v);
|
||||
if (setting_jsn_.at(name).at("range").at(i).is_number())
|
||||
{
|
||||
int id = 0;
|
||||
setting_jsn_.at(name).at("range").at(i).get_to(id);
|
||||
v = hg_log::lang_load(id);
|
||||
}
|
||||
else
|
||||
setting_jsn_.at(name).at("range").at(i).get_to(v);
|
||||
range.push_back(v);
|
||||
}
|
||||
}
|
||||
|
@ -700,8 +707,10 @@ void hg_scanner::get_range(const char* name, std::vector<std::string>& range, st
|
|||
sprintf(sn, "%f", v);
|
||||
def_val = sn;
|
||||
}
|
||||
else if(type == "string")
|
||||
setting_jsn_.at(name).at("default").get_to(def_val);
|
||||
else if (type == "string")
|
||||
{
|
||||
def_val = get_setting_item_string(name, "default");
|
||||
}
|
||||
//VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "setting %d has %d range(s) and default value is '%s'\n", setting_no, range.size(), def_val.c_str());
|
||||
}
|
||||
bool hg_scanner::check_range(const char* name, bool& val)
|
||||
|
@ -848,8 +857,7 @@ int hg_scanner::restore(const char* name)
|
|||
setting_jsn_.at(name).at("type").get_to(val);
|
||||
if (val == "string")
|
||||
{
|
||||
val = "";
|
||||
setting_jsn_.at(name).at("default").get_to(val);
|
||||
val = get_setting_item_string(name, "default");
|
||||
|
||||
char* buf = NULL;
|
||||
int size = 0;
|
||||
|
@ -913,7 +921,14 @@ bool hg_scanner::get_default_value(void* buf, json* jsn)
|
|||
else if (type == "string")
|
||||
{
|
||||
type = "";
|
||||
jsn->at("default").get_to(type);
|
||||
if (jsn->at("default").is_number())
|
||||
{
|
||||
int n = 0;
|
||||
jsn->at("default").get_to(n);
|
||||
type = hg_log::lang_load(n);
|
||||
}
|
||||
else
|
||||
jsn->at("default").get_to(type);
|
||||
strcpy((char*)buf, type.c_str());
|
||||
}
|
||||
else
|
||||
|
@ -943,7 +958,8 @@ void hg_scanner::thread_handle_image_process(void)
|
|||
continue;
|
||||
}
|
||||
|
||||
tiny_buffer = imgs_.Take();
|
||||
uint32_t id = -1;
|
||||
tiny_buffer = imgs_.Take(&id);
|
||||
if (tiny_buffer->swap())
|
||||
{
|
||||
try
|
||||
|
@ -956,7 +972,7 @@ void hg_scanner::thread_handle_image_process(void)
|
|||
stop();
|
||||
break;
|
||||
}
|
||||
image_process(tiny_buffer);
|
||||
image_process(tiny_buffer, id);
|
||||
}
|
||||
catch (const std::exception& e)
|
||||
{
|
||||
|
@ -968,7 +984,7 @@ void hg_scanner::thread_handle_image_process(void)
|
|||
else
|
||||
stop_fatal_ = SCANNER_ERR_INSUFFICIENT_MEMORY;
|
||||
VLOG_MINI_1(LOG_LEVEL_ALL, "is opencv Fatal: %s\n", e.what());
|
||||
//stop();
|
||||
stop();
|
||||
break;
|
||||
|
||||
}
|
||||
|
@ -1513,8 +1529,8 @@ int hg_scanner::setting_paper(void* data)
|
|||
|
||||
VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "Change paper from %s to %s = %s\n", paper_string(old).c_str(), (char*)data, hg_scanner_err_name(ret));
|
||||
|
||||
//if(ret == SCANNER_ERR_NOT_EXACT)
|
||||
// strcpy((char*)data, paper.c_str());
|
||||
if(ret == SCANNER_ERR_NOT_EXACT)
|
||||
strcpy((char*)data, paper.c_str());
|
||||
if(old != image_prc_param_.bits.paper)
|
||||
reset_custom_area_range(image_prc_param_.bits.paper);
|
||||
|
||||
|
@ -1566,7 +1582,10 @@ int hg_scanner::setting_resolution(void* data)
|
|||
|
||||
resolution_ = *((int*)data);
|
||||
if (!check_range(SANE_STD_OPT_NAME_RESOLUTION, resolution_))
|
||||
{
|
||||
*(int*)data = resolution_;
|
||||
ret = SCANNER_ERR_NOT_EXACT;
|
||||
}
|
||||
|
||||
// check paper ...
|
||||
if (!check_paper_and_resolution(resolution_, image_prc_param_.bits.paper))
|
||||
|
@ -1874,9 +1893,8 @@ int hg_scanner::setting_scan_mode(void* data)
|
|||
int hg_scanner::setting_scan_count(void* data)
|
||||
{
|
||||
int ret = SCANNER_ERR_OK;
|
||||
std::string val("");
|
||||
std::string val(get_setting_item_string(SANE_STD_OPT_NAME_SCAN_MODE, "cur"));
|
||||
|
||||
setting_jsn_.at(SANE_STD_OPT_NAME_SCAN_MODE).at("cur").get_to(val);
|
||||
if (val == hg_log::lang_load(ID_OPTION_VALUE_SMZS_LXSM))
|
||||
{
|
||||
scan_count_ = -1;
|
||||
|
@ -2365,12 +2383,33 @@ void hg_scanner::init_settings(const char* json_setting_text)
|
|||
continue;
|
||||
|
||||
std::string val("");
|
||||
|
||||
change_string_2_lang_id(v.c_str(), "title");
|
||||
change_string_2_lang_id(v.c_str(), "desc");
|
||||
|
||||
setting_jsn_.at(v.c_str()).at("type").get_to(val);
|
||||
if (val == "string")
|
||||
{
|
||||
val = "";
|
||||
setting_jsn_.at(v.c_str()).at("default").get_to(val);
|
||||
change_string_2_lang_id(v.c_str(), "cur");
|
||||
change_string_2_lang_id(v.c_str(), "default");
|
||||
if (setting_jsn_.at(v.c_str()).contains("range"))
|
||||
{
|
||||
for (int i = 0; i < setting_jsn_.at(v.c_str()).at("range").size(); ++i)
|
||||
{
|
||||
int id = -1;
|
||||
|
||||
setting_jsn_.at(v.c_str()).at("range").at(i).get_to(val);
|
||||
id = lang_get_string_id(val.c_str(), true);
|
||||
if (id == -1)
|
||||
{
|
||||
VLOG_MINI_1(LOG_LEVEL_WARNING, "LANGUAGE-ERR: lost item ID of '%s'\n", val.c_str());
|
||||
}
|
||||
else
|
||||
setting_jsn_.at(v.c_str()).at("range")[i] = id;
|
||||
}
|
||||
}
|
||||
|
||||
val = get_setting_item_string(v.c_str(), "default");
|
||||
|
||||
char* buf = NULL;
|
||||
int size = 0;
|
||||
|
@ -2421,6 +2460,40 @@ int hg_scanner::init_settings(int pid)
|
|||
|
||||
return SCANNER_ERR_OK;
|
||||
}
|
||||
void hg_scanner::change_string_2_lang_id(const char* name, const char* key)
|
||||
{
|
||||
std::string val("");
|
||||
int id = -1;
|
||||
|
||||
if (setting_jsn_.at(name).contains(key))
|
||||
{
|
||||
setting_jsn_.at(name).at(key).get_to(val);
|
||||
id = lang_get_string_id(val.c_str(), true);
|
||||
if (id == -1)
|
||||
{
|
||||
VLOG_MINI_1(LOG_LEVEL_WARNING, "LANGUAGE-ERR: lost item ID of '%s'\n", val.c_str());
|
||||
}
|
||||
else
|
||||
setting_jsn_.at(name).at(key) = id;
|
||||
}
|
||||
}
|
||||
std::string hg_scanner::get_setting_item_string(const char* name, const char* key)
|
||||
{
|
||||
std::string ret("");
|
||||
|
||||
if (setting_jsn_.at(name).at(key).is_number())
|
||||
{
|
||||
int n = -1;
|
||||
setting_jsn_.at(name).at(key).get_to(n);
|
||||
ret = hg_log::lang_load(n);
|
||||
}
|
||||
else
|
||||
{
|
||||
setting_jsn_.at(name).at(key).get_to(ret);
|
||||
}
|
||||
|
||||
return std::move(ret);
|
||||
}
|
||||
int hg_scanner::on_scann_error(int err)
|
||||
{
|
||||
status_ = err;
|
||||
|
@ -2636,7 +2709,7 @@ int hg_scanner::save_usb_data(std::shared_ptr<tiny_buffer> data)
|
|||
{
|
||||
VLOG_MINI_1(LOG_LEVEL_WARNING, "Warning: memory usage(%.2fMB) maybe leading exception!\r\n", Memoryusae);
|
||||
}
|
||||
imgs_.Put(data, data->size());
|
||||
imgs_.Put(data, data->size(), hg_scanner_mgr::unique_id());
|
||||
if (wait_img_.is_waiting())
|
||||
wait_img_.notify();
|
||||
}
|
||||
|
@ -2646,7 +2719,7 @@ int hg_scanner::save_usb_data(std::shared_ptr<tiny_buffer> data)
|
|||
|
||||
return ret;
|
||||
}
|
||||
int hg_scanner::save_final_image(hg_imgproc::LPIMGHEAD head, void* buf)
|
||||
int hg_scanner::save_final_image(hg_imgproc::LPIMGHEAD head, void* buf, uint32_t id)
|
||||
{
|
||||
std::string bw("");
|
||||
|
||||
|
@ -2687,6 +2760,7 @@ int hg_scanner::save_final_image(hg_imgproc::LPIMGHEAD head, void* buf)
|
|||
img.bytes = head->total_bytes;
|
||||
img.flag.statu = head->statu;
|
||||
img.flag.dpi = resolution_;
|
||||
img.src_id = id;
|
||||
|
||||
if (img.flag.statu)
|
||||
{
|
||||
|
@ -2697,7 +2771,7 @@ int hg_scanner::save_final_image(hg_imgproc::LPIMGHEAD head, void* buf)
|
|||
}
|
||||
|
||||
if (final_imgs_.put(head->width, head->height, head->bits, head->channels, head->line_bytes, buf, head->total_bytes
|
||||
, final_path_.c_str(), "final", "dat", final_img_index_))
|
||||
, final_path_.c_str(), "final", "dat", final_img_index_, id))
|
||||
return SCANNER_ERR_OK;
|
||||
else
|
||||
return SCANNER_ERR_INSUFFICIENT_MEMORY;
|
||||
|
@ -2850,10 +2924,10 @@ int hg_scanner::set_setting(const char* name, void* data, int len)
|
|||
|
||||
if (ret == SCANNER_ERR_OK || ret == SCANNER_ERR_NOT_EXACT || ret == SCANNER_ERR_CONFIGURATION_CHANGED)
|
||||
{
|
||||
std::string type(""), name("");
|
||||
std::string type(""), name(get_setting_item_string(real_n.c_str(), "title"));
|
||||
|
||||
setting_jsn_.at(real_n).at("type").get_to(type);
|
||||
setting_jsn_.at(real_n).at("title").get_to(name);
|
||||
// setting_jsn_.at(real_n).at("title").get_to(name);
|
||||
if (type == "string")
|
||||
{
|
||||
setting_jsn_.at(real_n).at("cur") = (char*)data;
|
||||
|
@ -2927,18 +3001,18 @@ int hg_scanner::get_setting(const char* name, char* json_txt_buf, int* len, int*
|
|||
else
|
||||
{
|
||||
//json_name.find(real_n)
|
||||
auto it = json_name.find(real_n);
|
||||
if (it != json_name.end())
|
||||
{
|
||||
int i = it->second;
|
||||
|
||||
const char* load = hg_log::lang_load(i);
|
||||
if (load)
|
||||
{
|
||||
setting_jsn_.at(real_n).at("title") = load;
|
||||
}
|
||||
|
||||
}
|
||||
//auto it = json_name.find(real_n);
|
||||
//if (it != json_name.end())
|
||||
//{
|
||||
// int i = it->second;
|
||||
//
|
||||
// const char* load = hg_log::lang_load(i);
|
||||
// if (*load)
|
||||
// {
|
||||
// setting_jsn_.at(real_n).at("title") = load;
|
||||
// }
|
||||
//
|
||||
//}
|
||||
std::string text(setting_jsn_.at(real_n).dump());
|
||||
|
||||
text.insert(0, "\"" + real_n + "\":");
|
||||
|
@ -2983,6 +3057,7 @@ int hg_scanner::get_image_info(SANE_Parameters* ii)
|
|||
int ret = SCANNER_ERR_OK;
|
||||
IMH imh;
|
||||
|
||||
fetching_id_ = -1;
|
||||
bzero(&imh, sizeof(imh));
|
||||
bzero(ii, sizeof(*ii));
|
||||
while ((!wait_img_.is_waiting() || !wait_usb_.is_waiting()) && final_imgs_.size() <= 0)
|
||||
|
@ -2995,7 +3070,10 @@ int hg_scanner::get_image_info(SANE_Parameters* ii)
|
|||
if (!final_imgs_.front(&imh))
|
||||
ret = SCANNER_ERR_NO_DATA;
|
||||
else
|
||||
{
|
||||
copy_to_sane_image_header(ii, imh.width, imh.height, imh.line_bytes, imh.channels, imh.bits);
|
||||
fetching_id_ = imh.src_id;
|
||||
}
|
||||
}
|
||||
|
||||
if (ret == SCANNER_ERR_NO_DATA /*&& final_img_index_ == 0*/)
|
||||
|
@ -3696,7 +3774,7 @@ int hg_scanner::get_scan_is_sleep(SANE_Bool& data)
|
|||
{
|
||||
return SCANNER_ERR_DEVICE_NOT_SUPPORT;
|
||||
}
|
||||
void hg_scanner::image_process(std::shared_ptr<tiny_buffer>& buffer)
|
||||
void hg_scanner::image_process(std::shared_ptr<tiny_buffer>& buffer, uint32_t id)
|
||||
{
|
||||
if (!buffer.get() || !ImagePrc_pHandle_)
|
||||
{
|
||||
|
@ -3919,7 +3997,10 @@ void hg_scanner::image_process(std::shared_ptr<tiny_buffer>& buffer)
|
|||
VLOG_MINI_6(LOG_LEVEL_DEBUG_INFO, "Set img type is:%s Final picture %d (%d * %d * %d) with %u bytes!\n", img_type_.c_str(), index
|
||||
, ih.width, ih.height, ih.bits * ih.channels, ih.total_bytes);
|
||||
}
|
||||
save_final_image(&ih, buf);
|
||||
if (id == -1)
|
||||
id = hg_scanner_mgr::unique_id();
|
||||
save_final_image(&ih, buf, id);
|
||||
id = -1;
|
||||
}
|
||||
}
|
||||
int hg_scanner::image_configuration(SCANCONF& ic)
|
||||
|
|
|
@ -146,7 +146,7 @@ class hg_scanner
|
|||
void working_begin(void*);
|
||||
void working_done(void*);
|
||||
|
||||
void image_process(std::shared_ptr<tiny_buffer>& buff);
|
||||
void image_process(std::shared_ptr<tiny_buffer>& buffer, uint32_t id);
|
||||
void reset_custom_area_range(int paper);
|
||||
float reset_custom_area_jsn_value(const char* name, double& var, float range_l, float range_u, float value_l, float value_u); // return cur value
|
||||
int set_color_change(void);
|
||||
|
@ -362,8 +362,12 @@ protected:
|
|||
int stop_fatal_;
|
||||
BlockingQueue<std::shared_ptr<tiny_buffer>> imgs_;
|
||||
|
||||
uint32_t fetching_id_; // for sane read image ext info. added on 2023-01-13
|
||||
|
||||
void init_settings(const char* json_setting_text);
|
||||
int init_settings(int pid);
|
||||
void change_string_2_lang_id(const char* name, const char* key);
|
||||
std::string get_setting_item_string(const char* name, const char* key);
|
||||
int on_scann_error(int err); // 返回“0”忽略错误继续执行,其它值则停止后续工作
|
||||
int try_third_app_handle_start(bool& handled);
|
||||
int try_third_app_after_start(int err);
|
||||
|
@ -375,7 +379,7 @@ protected:
|
|||
|
||||
void copy_to_sane_image_header(SANE_Parameters* header, int w, int h, int line_bytes, int channels, int bits);
|
||||
int save_usb_data(std::shared_ptr<tiny_buffer> data);
|
||||
int save_final_image(hg_imgproc::LPIMGHEAD head, void* buf);
|
||||
int save_final_image(hg_imgproc::LPIMGHEAD head, void* buf, uint32_t id = -1);
|
||||
|
||||
void adjust_filling_hole(LPSCANCONF conf);
|
||||
|
||||
|
|
|
@ -92,6 +92,9 @@ std::string hg_scanner_mgr::pe_path_("");
|
|||
std::string hg_scanner_mgr::pe_name_("");
|
||||
bool hg_scanner_mgr::read_over_with_eof_ = true;
|
||||
|
||||
uint32_t hg_scanner_mgr::unique_img_id_ = 0;;
|
||||
std::mutex hg_scanner_mgr::mutex_img_id;
|
||||
|
||||
hg_scanner_mgr::hg_scanner_mgr() : same_ind_(1)
|
||||
{
|
||||
usb_manager::instance()->register_hotplug(&hg_scanner_mgr::usb_event_handle, this);
|
||||
|
@ -125,6 +128,7 @@ hg_scanner_mgr* hg_scanner_mgr::instance(sane_callback cb)
|
|||
hg_scanner_mgr::event_callback_ = cb;
|
||||
if (cb)
|
||||
hg_scanner_mgr::async_io_enabled_ = cb(NULL, SANE_EVENT_SUPPORT_ASYNC_IO, NULL, NULL, NULL) == 0;
|
||||
hg_scanner_mgr::unique_img_id_ = (uint32_t)INT_MAX + 1;
|
||||
hg_scanner_mgr::inst_ = new hg_scanner_mgr();
|
||||
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "async image transferring is %s\n", hg_scanner_mgr::async_io_enabled_ ? "enabled" : "disabled");
|
||||
}
|
||||
|
@ -190,6 +194,17 @@ std::string hg_scanner_mgr::get_pe_name(std::string* path)
|
|||
|
||||
return hg_scanner_mgr::pe_name_;
|
||||
}
|
||||
uint32_t hg_scanner_mgr::unique_id(int type)
|
||||
{
|
||||
if (type == UNIQUE_ID_IMG)
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(hg_scanner_mgr::mutex_img_id);
|
||||
|
||||
return hg_scanner_mgr::unique_img_id_++;
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
hg_scanner* hg_scanner_mgr::create_scanner_empty(const char* name, usb_io* io, scanner_handle* h)
|
||||
{
|
||||
|
|
|
@ -76,6 +76,9 @@ class hg_scanner_mgr
|
|||
static int ver_build_;
|
||||
static int ver_patch_;
|
||||
|
||||
static uint32_t unique_img_id_;
|
||||
static std::mutex mutex_img_id;
|
||||
|
||||
static hg_scanner_mgr* inst_;
|
||||
static void usb_event_handle(usb_event ev, libusb_device* device, int vid, int pid, int usb_ver_h, int usb_ver_l, bool* retry, void* user); // usb_ver_h.usb_ver_l
|
||||
|
||||
|
@ -96,6 +99,11 @@ public:
|
|||
static void set_version(int hh, int hl, int lh, int ll);
|
||||
static void set_exe_name(const char* path, const char* name);
|
||||
static std::string get_pe_name(std::string* path = nullptr);
|
||||
enum
|
||||
{
|
||||
UNIQUE_ID_IMG = 0,
|
||||
};
|
||||
static uint32_t unique_id(int type = UNIQUE_ID_IMG);
|
||||
|
||||
static hg_scanner* create_scanner_empty(const char* name, usb_io* io, scanner_handle* h);
|
||||
static hg_scanner* create_scanner_g100(const char* name, usb_io* io, scanner_handle* h);
|
||||
|
|
|
@ -11,8 +11,8 @@ extern void inner_sane_exit(void);
|
|||
extern SANE_Status inner_sane_get_devices(const SANE_Device*** device_list, SANE_Bool local_only);
|
||||
extern SANE_Status inner_sane_open(SANE_String_Const devicename, SANE_Handle* handle);
|
||||
extern void inner_sane_close(SANE_Handle handle);
|
||||
extern const SANE_Option_Descriptor* inner_sane_get_option_descriptor(SANE_Handle handle, SANE_Int option);
|
||||
extern SANE_Status inner_sane_control_option(SANE_Handle handle, SANE_Int option, SANE_Action action, void* value, SANE_Int* info);
|
||||
extern const SANE_Option_Descriptor* inner_sane_get_option_descriptor(SANE_Handle handle, const void* option);
|
||||
extern SANE_Status inner_sane_control_option(SANE_Handle handle, const void* option, SANE_Action action, void* value, SANE_Int* info);
|
||||
extern SANE_Status inner_sane_get_parameters(SANE_Handle handle, SANE_Parameters* params);
|
||||
extern SANE_Status inner_sane_start(SANE_Handle handle);
|
||||
extern SANE_Status inner_sane_read(SANE_Handle handle, SANE_Byte* data, SANE_Int max_length, SANE_Int* length);
|
||||
|
@ -24,6 +24,7 @@ extern SANE_String_Const inner_sane_strstatus(SANE_Status status);
|
|||
extern SANE_Status inner_sane_init_ex(SANE_Int* version_code, sane_callback cb, void* param);
|
||||
extern SANE_Status inner_sane_io_control(SANE_Handle h, unsigned long code, void* data, unsigned* len);
|
||||
extern const char* inner_sane_err_desc(SANE_Status err);
|
||||
extern SANE_Status inner_sane_read_ext(SANE_Img_Ext_Info* ext_info, SANE_Int* len);
|
||||
|
||||
/// <summary>
|
||||
/// 导出接口
|
||||
|
@ -51,11 +52,11 @@ void sane_close(SANE_Handle handle)
|
|||
const SANE_Option_Descriptor*
|
||||
sane_get_option_descriptor(SANE_Handle handle, SANE_Int option)
|
||||
{
|
||||
return inner_sane_get_option_descriptor(handle, option);
|
||||
return inner_sane_get_option_descriptor(handle, (const void*)option);
|
||||
}
|
||||
SANE_Status sane_control_option(SANE_Handle handle, SANE_Int option, SANE_Action action, void* value, SANE_Int* info)
|
||||
{
|
||||
return inner_sane_control_option(handle, option, action, value, info);
|
||||
return inner_sane_control_option(handle, (const void*)option, action, value, info);
|
||||
}
|
||||
SANE_Status sane_get_parameters(SANE_Handle handle, SANE_Parameters* params)
|
||||
{
|
||||
|
@ -100,3 +101,16 @@ const char* sane_err_desc(SANE_Status err)
|
|||
{
|
||||
return inner_sane_err_desc(err);
|
||||
}
|
||||
const SANE_Option_Descriptor*
|
||||
sane_get_option_descriptor_ex(SANE_Handle handle, const char* option)
|
||||
{
|
||||
return inner_sane_get_option_descriptor(handle, (const void*)option);
|
||||
}
|
||||
SANE_Status sane_control_option_ex(SANE_Handle handle, const char* option, SANE_Action action, void* value, SANE_Int* info)
|
||||
{
|
||||
return inner_sane_control_option(handle, (const void*)option, action, value, info);
|
||||
}
|
||||
SANE_Status sane_read_ext_info(SANE_Img_Ext_Info* ext_info, SANE_Int* len)
|
||||
{
|
||||
return inner_sane_read_ext(ext_info, len);
|
||||
}
|
||||
|
|
|
@ -339,7 +339,7 @@ namespace local_utility
|
|||
hg_sane_middleware* hg_sane_middleware::inst_ = NULL;
|
||||
const SANE_Device** hg_sane_middleware::dev_list_ = NULL;
|
||||
|
||||
hg_sane_middleware::hg_sane_middleware(void) : opt_0_(nullptr), std_opt_(nullptr), init_ok_(false)
|
||||
hg_sane_middleware::hg_sane_middleware(void) : opt_0_(nullptr), init_ok_(false)
|
||||
{
|
||||
if (lang_initialize() == -1)
|
||||
{
|
||||
|
@ -369,17 +369,14 @@ hg_sane_middleware::hg_sane_middleware(void) : opt_0_(nullptr), std_opt_(nullptr
|
|||
hg_sane_middleware::~hg_sane_middleware()
|
||||
{
|
||||
register_language_changed_notify(&hg_sane_middleware::language_changed, false);
|
||||
for (size_t i = 0; i < opts_.size(); ++i)
|
||||
{
|
||||
local_utility::free_memory(opts_[i].desc);
|
||||
}
|
||||
for (size_t i = 0; i < openning_.size(); ++i)
|
||||
hg_scanner_close(openning_[i].handle, true);
|
||||
{
|
||||
hg_scanner_close(openning_[i]->dev, true);
|
||||
hg_sane_middleware::free_device_inst(openning_[i]);
|
||||
}
|
||||
hg_scanner_uninitialize();
|
||||
if (opt_0_)
|
||||
local_utility::free_memory(opt_0_);
|
||||
if (std_opt_)
|
||||
delete std_opt_;
|
||||
}
|
||||
|
||||
void hg_sane_middleware::language_changed(int cp, void* param)
|
||||
|
@ -453,6 +450,18 @@ double hg_sane_middleware::sane_fixed_2_double(SANE_Fixed v)
|
|||
{
|
||||
return SANE_UNFIX(v);
|
||||
}
|
||||
void hg_sane_middleware::set_value_to_var(void* val, size_t bytes, void* param)
|
||||
{
|
||||
memcpy(param, val, bytes);
|
||||
}
|
||||
void hg_sane_middleware::set_value_to_new(void* val, size_t bytes, void* param)
|
||||
{
|
||||
void** addr = (void**)param;
|
||||
|
||||
*addr = local_utility::acquire_memory(bytes, "set_value_to_new");
|
||||
memcpy(*addr, val, bytes);
|
||||
}
|
||||
|
||||
std::string hg_sane_middleware::option_value_2_string(SANE_Value_Type type, void* val)
|
||||
{
|
||||
std::string ret("unknown");
|
||||
|
@ -486,35 +495,13 @@ std::string hg_sane_middleware::option_value_2_string(SANE_Value_Type type, void
|
|||
|
||||
return ret;
|
||||
}
|
||||
|
||||
std::string hg_sane_middleware::sane_path(void)
|
||||
{
|
||||
return g_sane_path;
|
||||
}
|
||||
hg_sane_middleware* hg_sane_middleware::instance(void)
|
||||
{
|
||||
if (!hg_sane_middleware::inst_)
|
||||
hg_sane_middleware::inst_ = new hg_sane_middleware();
|
||||
|
||||
return hg_sane_middleware::inst_;
|
||||
}
|
||||
void hg_sane_middleware::set_callback(sane_callback cb, void* param)
|
||||
{
|
||||
local_utility::set_callback(cb, param);
|
||||
}
|
||||
void hg_sane_middleware::clear(void)
|
||||
{
|
||||
local_utility::stop_work();
|
||||
if (hg_sane_middleware::inst_)
|
||||
{
|
||||
delete hg_sane_middleware::inst_;
|
||||
hg_sane_middleware::inst_ = NULL;
|
||||
}
|
||||
}
|
||||
scanner_handle hg_sane_middleware::sane_handle_to_scanner(SANE_Handle h)
|
||||
{
|
||||
if (!h)
|
||||
return nullptr;
|
||||
|
||||
int bits = sizeof(h) / 2 * 8;
|
||||
unsigned long long v = (unsigned long long)h;
|
||||
uint64_t v = (uint64_t)h;
|
||||
|
||||
v ^= v >> bits;
|
||||
|
||||
|
@ -522,8 +509,11 @@ scanner_handle hg_sane_middleware::sane_handle_to_scanner(SANE_Handle h)
|
|||
}
|
||||
SANE_Handle hg_sane_middleware::scanner_handle_to_sane(scanner_handle h)
|
||||
{
|
||||
if (!h)
|
||||
return nullptr;
|
||||
|
||||
int bits = sizeof(h) / 2 * 8;
|
||||
unsigned long long v = (unsigned long long)h;
|
||||
uint64_t v = (uint64_t)h;
|
||||
|
||||
v ^= v >> bits;
|
||||
|
||||
|
@ -753,30 +743,46 @@ SANE_Option_Descriptor* hg_sane_middleware::number_option_to_SANE_descriptor(con
|
|||
|
||||
return sod;
|
||||
}
|
||||
|
||||
void hg_sane_middleware::on_device_closed(scanner_handle h)
|
||||
std::string hg_sane_middleware::get_string_in_json(json* jsn, const char* key)
|
||||
{
|
||||
// 由于目å‰<C3A5>对多设备的支æŒ<C3A6>还ä¸<C3A4>是刚需,故代ç <C3A7>å<EFBFBD>ªè€ƒè™‘å<E28098>•è®¾å¤‡æƒ…况,设备关é—å<C2AD>Žï¼Œæ¸…除所有å<E280B0>˜é‡?
|
||||
for (size_t i = 0; i < opts_.size(); ++i)
|
||||
std::string str("");
|
||||
int id = -1;
|
||||
|
||||
if (jsn->get_value(key, id) && id != -1)
|
||||
{
|
||||
local_utility::free_memory(opts_[i].desc);
|
||||
str = lang_load_string(id, &id);
|
||||
}
|
||||
opts_.clear();
|
||||
for (size_t i = 0; i < openning_.size(); ++i)
|
||||
{
|
||||
if (openning_[i].handle == h)
|
||||
{
|
||||
openning_.erase(openning_.begin() + i);
|
||||
i--;
|
||||
}
|
||||
}
|
||||
cur_vals_.clear();
|
||||
slave_options_.clear();
|
||||
master_options_.clear();
|
||||
if (std_opt_)
|
||||
delete std_opt_;
|
||||
std_opt_ = nullptr;
|
||||
else
|
||||
jsn->get_value(key, str);
|
||||
|
||||
return std::move(str);
|
||||
}
|
||||
|
||||
std::string hg_sane_middleware::sane_path(void)
|
||||
{
|
||||
return g_sane_path;
|
||||
}
|
||||
hg_sane_middleware* hg_sane_middleware::instance(void)
|
||||
{
|
||||
if (!hg_sane_middleware::inst_)
|
||||
hg_sane_middleware::inst_ = new hg_sane_middleware();
|
||||
|
||||
return hg_sane_middleware::inst_;
|
||||
}
|
||||
void hg_sane_middleware::set_callback(sane_callback cb, void* param)
|
||||
{
|
||||
local_utility::set_callback(cb, param);
|
||||
}
|
||||
void hg_sane_middleware::clear(void)
|
||||
{
|
||||
local_utility::stop_work();
|
||||
if (hg_sane_middleware::inst_)
|
||||
{
|
||||
delete hg_sane_middleware::inst_;
|
||||
hg_sane_middleware::inst_ = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
|
@ -788,19 +794,18 @@ SANE_Status hg_sane_middleware::open(SANE_String_Const devicename, SANE_Handle*
|
|||
err = hg_scanner_open(&h, devicename, false, NULL, NULL, NULL, rsc);
|
||||
if (err == SCANNER_ERR_OK)
|
||||
{
|
||||
OPENDEV od;
|
||||
LPDEVINST inst = new DEVINST;
|
||||
|
||||
od.dev_name = devicename;
|
||||
od.handle = h;
|
||||
od.scan_count = -1;
|
||||
openning_.push_back(od);
|
||||
inst->name = devicename;
|
||||
inst->dev = h;
|
||||
openning_.push_back(inst);
|
||||
*handle = hg_sane_middleware::scanner_handle_to_sane(h);
|
||||
|
||||
if (!local_utility::cb_ui_)
|
||||
{
|
||||
long count = 0;
|
||||
hg_scanner_get_parameter(h, 0, NULL, &count);
|
||||
std_opt_ = new sane_std_opts(count);
|
||||
inst->std_opt = new sane_std_opts(count);
|
||||
}
|
||||
|
||||
return SANE_STATUS_GOOD;
|
||||
|
@ -812,16 +817,15 @@ SANE_Status hg_sane_middleware::open(SANE_String_Const devicename, SANE_Handle*
|
|||
else
|
||||
return (SANE_Status)err; // SANE_STATUS_UNSUPPORTED;
|
||||
}
|
||||
SANE_Option_Descriptor* hg_sane_middleware::from_json(scanner_handle h, const std::string& name, json* jsn, int opt_no)
|
||||
SANE_Option_Descriptor* hg_sane_middleware::from_json(scanner_handle h, const std::string& name, json* jsn)
|
||||
{
|
||||
std::string title(""), desc(""), val("");
|
||||
std::string title(hg_sane_middleware::get_string_in_json(jsn, "title")),
|
||||
desc(hg_sane_middleware::get_string_in_json(jsn, "desc")),
|
||||
val("");
|
||||
std::vector<std::string> constraints;
|
||||
double lower = .0f, upper = .0f, step = .0f;
|
||||
bool db_val = false;
|
||||
|
||||
jsn->get_value("title", title);
|
||||
jsn->get_value("desc", desc);
|
||||
|
||||
if (!jsn->get_value("type", val))
|
||||
return NULL;
|
||||
|
||||
|
@ -836,10 +840,42 @@ SANE_Option_Descriptor* hg_sane_middleware::from_json(scanner_handle h, const st
|
|||
{
|
||||
if (range->first_child(val))
|
||||
{
|
||||
constraints.push_back(val);
|
||||
size_t pos = val.find(".");
|
||||
if (pos != std::string::npos)
|
||||
{
|
||||
for (size_t i = val.length() - 1; i > pos; --i)
|
||||
{
|
||||
if (val[i] != '0')
|
||||
{
|
||||
pos = i + 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
val.erase(pos);
|
||||
}
|
||||
if (std::to_string(atoi(val.c_str())) == val)
|
||||
constraints.push_back(lang_load_string(atoi(val.c_str()), (int*)&lower));
|
||||
else
|
||||
constraints.push_back(val);
|
||||
while (range->next_child(val))
|
||||
{
|
||||
constraints.push_back(val);
|
||||
pos = val.find(".");
|
||||
if (pos != std::string::npos)
|
||||
{
|
||||
for (size_t i = val.length() - 1; i > pos; --i)
|
||||
{
|
||||
if (val[i] != '0')
|
||||
{
|
||||
pos = i + 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
val.erase(pos);
|
||||
}
|
||||
if (std::to_string(atoi(val.c_str())) == val)
|
||||
constraints.push_back(lang_load_string(atoi(val.c_str()), (int*)&lower));
|
||||
else
|
||||
constraints.push_back(val);
|
||||
}
|
||||
}
|
||||
delete range;
|
||||
|
@ -866,6 +902,7 @@ SANE_Option_Descriptor* hg_sane_middleware::from_json(scanner_handle h, const st
|
|||
lower = l;
|
||||
upper = u;
|
||||
step = s;
|
||||
VLOG_MINI_4(LOG_LEVEL_DEBUG_INFO, "%s range: [%d, +%d, %d]\n", name.c_str(), l, s, u);
|
||||
ret = hg_sane_middleware::number_option_to_SANE_descriptor(name.c_str(), title.c_str(), desc.c_str()
|
||||
, false, &lower, &upper, &step);
|
||||
}
|
||||
|
@ -891,6 +928,7 @@ SANE_Option_Descriptor* hg_sane_middleware::from_json(scanner_handle h, const st
|
|||
range->get_value("max", upper);
|
||||
step = (upper - lower) / 10.0f;
|
||||
range->get_value("step", step);
|
||||
VLOG_MINI_4(LOG_LEVEL_DEBUG_INFO, "%s range: (%f, +%f, %f)\n", name.c_str(), lower, step, upper);
|
||||
ret = hg_sane_middleware::number_option_to_SANE_descriptor(name.c_str(), title.c_str(), desc.c_str()
|
||||
, true, &lower, &upper, &step);
|
||||
}
|
||||
|
@ -977,7 +1015,8 @@ SANE_Option_Descriptor* hg_sane_middleware::from_json(scanner_handle h, const st
|
|||
}
|
||||
if (depend)
|
||||
{
|
||||
if (parse_depends(depend, so))
|
||||
std::vector<LPDEVINST>::iterator it = find_openning_device_in_que(h);
|
||||
if (it != openning_.end() && parse_depends(depend, so, (*it)->masters))
|
||||
{
|
||||
so.enable_now = (ret->cap & SANE_CAP_INACTIVE) != SANE_CAP_INACTIVE;
|
||||
so.name = name;
|
||||
|
@ -996,13 +1035,13 @@ SANE_Option_Descriptor* hg_sane_middleware::from_json(scanner_handle h, const st
|
|||
integer = master == "int";
|
||||
master = "";
|
||||
m->get_value_as_string("cur", master, integer);
|
||||
so.enable_now = so.is_enable(so.master, cur_vals_);
|
||||
so.enable_now = so.is_enable(so.master, (*it)->cur_vals);
|
||||
if (!so.enable_now)
|
||||
ret->cap |= SANE_CAP_INACTIVE;
|
||||
}
|
||||
delete m;
|
||||
}
|
||||
slave_options_.push_back(so);
|
||||
(*it)->slaves.push_back(so);
|
||||
}
|
||||
delete depend;
|
||||
}
|
||||
|
@ -1010,10 +1049,19 @@ SANE_Option_Descriptor* hg_sane_middleware::from_json(scanner_handle h, const st
|
|||
|
||||
return ret;
|
||||
}
|
||||
scanner_handle hg_sane_middleware::find_openning_device(SANE_Handle h, bool rmv, OPENDEV* dev)
|
||||
void hg_sane_middleware::free_device_inst(LPDEVINST dev)
|
||||
{
|
||||
if (dev->std_opt)
|
||||
delete dev->std_opt;
|
||||
for (auto& v : dev->opts)
|
||||
local_utility::free_memory(v.desc);
|
||||
|
||||
delete dev;
|
||||
}
|
||||
scanner_handle hg_sane_middleware::find_openning_device(SANE_Handle h, bool rmv, LPDEVINST* dev)
|
||||
{
|
||||
scanner_handle handle = hg_sane_middleware::sane_handle_to_scanner(h);
|
||||
std::vector<OPENDEV>::iterator it = std::find(openning_.begin(), openning_.end(), handle);
|
||||
std::vector<LPDEVINST>::iterator it = find_openning_device_in_que(handle);
|
||||
|
||||
if (it == openning_.end())
|
||||
handle = NULL;
|
||||
|
@ -1022,12 +1070,16 @@ scanner_handle hg_sane_middleware::find_openning_device(SANE_Handle h, bool rmv,
|
|||
if (dev)
|
||||
*dev = *it;
|
||||
if (rmv)
|
||||
{
|
||||
if (!dev)
|
||||
hg_sane_middleware::free_device_inst(*it);
|
||||
openning_.erase(it);
|
||||
}
|
||||
}
|
||||
|
||||
return handle;
|
||||
}
|
||||
std::string hg_sane_middleware::get_option_json(scanner_handle handle, void *opt, std::string* key)
|
||||
std::string hg_sane_middleware::get_option_json(scanner_handle handle, void *opt, std::string* key, SANE_Int* id)
|
||||
{
|
||||
char* json_txt = NULL;
|
||||
long length = 0;
|
||||
|
@ -1038,7 +1090,7 @@ std::string hg_sane_middleware::get_option_json(scanner_handle handle, void *opt
|
|||
{
|
||||
json_txt = (char*)local_utility::acquire_memory(ALIGN_INT(length + 4), "hg_sane_middleware::get_option_json");
|
||||
bzero(json_txt, length + 4);
|
||||
err = hg_scanner_get_parameter(handle, (const char*)opt, json_txt, &length);
|
||||
err = hg_scanner_get_parameter(handle, (const char*)opt, json_txt, &length, id);
|
||||
if (err == SCANNER_ERR_OK)
|
||||
{
|
||||
const char* head = json_txt;
|
||||
|
@ -1068,42 +1120,43 @@ std::string hg_sane_middleware::get_option_json(scanner_handle handle, void *opt
|
|||
|
||||
return ret;
|
||||
}
|
||||
SANE_Option_Descriptor* hg_sane_middleware::find_stored_descriptor(const char* name, unsigned long long option)
|
||||
SANE_Option_Descriptor* hg_sane_middleware::find_stored_descriptor(scanner_handle handle, const void* option, SANE_Int* id)
|
||||
{
|
||||
|
||||
if (IS_PTR_NUMBER(option))
|
||||
std::vector<LPDEVINST>::iterator it = find_openning_device_in_que(handle);
|
||||
|
||||
if (it != openning_.end())
|
||||
{
|
||||
for (const auto& v : opts_)
|
||||
if (IS_PTR_NUMBER(option))
|
||||
{
|
||||
if (v.dev_name == name && v.option_no == option)
|
||||
return v.desc;
|
||||
if (id)
|
||||
*id = (int)option;
|
||||
for (const auto& v : (*it)->opts)
|
||||
{
|
||||
if (v.option_no == (int)option)
|
||||
return v.desc;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for (const auto& v : opts_)
|
||||
else
|
||||
{
|
||||
if (v.dev_name == name && v.opt_name == (const char*)option)
|
||||
return v.desc;
|
||||
for (const auto& v : (*it)->opts)
|
||||
{
|
||||
if (v.opt_name == (const char*)option)
|
||||
{
|
||||
if (id)
|
||||
*id = v.option_no;
|
||||
return v.desc;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
SANE_Option_Descriptor* hg_sane_middleware::find_stored_descriptor(SANE_Handle handle, unsigned long long option)
|
||||
{
|
||||
OPENDEV dev;
|
||||
scanner_handle h = find_openning_device(handle, false, &dev);
|
||||
|
||||
if (!h)
|
||||
return NULL;
|
||||
else
|
||||
return find_stored_descriptor(dev.dev_name.c_str(), option);
|
||||
}
|
||||
|
||||
void hg_sane_middleware::reload_current_value(scanner_handle handle, std::vector<std::string>* changed)
|
||||
{
|
||||
long count = 0;
|
||||
std::vector<LPDEVINST>::iterator it = find_openning_device_in_que(handle);
|
||||
|
||||
if (changed)
|
||||
changed->clear();
|
||||
|
@ -1116,13 +1169,13 @@ void hg_sane_middleware::reload_current_value(scanner_handle handle, std::vector
|
|||
if (jsn->attach_text(&val[0]) &&
|
||||
jsn->get_value("type", val))
|
||||
{
|
||||
if (refresh_current_value(key.c_str(), jsn))
|
||||
if (refresh_current_value(*it, key.c_str(), jsn))
|
||||
changed->push_back(key);
|
||||
}
|
||||
delete jsn;
|
||||
}
|
||||
}
|
||||
bool hg_sane_middleware::get_current_value(scanner_handle handle, int option, void* value, SANE_Value_Type* type)
|
||||
bool hg_sane_middleware::get_current_value(scanner_handle handle, const void* option, void(*setv)(void*, size_t, void*), void* value, SANE_Value_Type* type)
|
||||
{
|
||||
std::string name(""),
|
||||
val(get_option_json(handle, (void *)option, &name));
|
||||
|
@ -1140,37 +1193,50 @@ bool hg_sane_middleware::get_current_value(scanner_handle handle, int option, vo
|
|||
{
|
||||
int v = 0;
|
||||
jsn->get_value("cur", v);
|
||||
*((SANE_Int*)value) = v;
|
||||
// *((SANE_Int*)value) = v;
|
||||
setv(&v, sizeof(v), value);
|
||||
t = SANE_TYPE_INT;
|
||||
}
|
||||
else if (val == "bool")
|
||||
{
|
||||
bool yesorno = false;
|
||||
jsn->get_value("cur", yesorno);
|
||||
*(SANE_Bool*)value = yesorno;
|
||||
bool bv = false;
|
||||
SANE_Bool v = SANE_FALSE;
|
||||
jsn->get_value("cur", bv);
|
||||
// *(SANE_Bool*)value = v;
|
||||
v = bv;
|
||||
setv(&v, sizeof(v), value);
|
||||
t = SANE_TYPE_BOOL;
|
||||
}
|
||||
else if (val == "float")
|
||||
{
|
||||
double v = .0f;
|
||||
jsn->get_value("cur", v);
|
||||
*((SANE_Fixed*)value) = hg_sane_middleware::double_2_sane_fixed(v);
|
||||
double dv = .0f;
|
||||
SANE_Fixed v = 0;
|
||||
jsn->get_value("cur", dv);
|
||||
v = hg_sane_middleware::double_2_sane_fixed(dv);
|
||||
setv(&v, sizeof(v), value);
|
||||
t = SANE_TYPE_FIXED;
|
||||
}
|
||||
else
|
||||
{
|
||||
val = "";
|
||||
jsn->get_value("cur", val);
|
||||
strcpy((char*)value, val.c_str());
|
||||
int size = 0;
|
||||
jsn->get_value("size", size);
|
||||
val = hg_sane_middleware::get_string_in_json(jsn, "cur");
|
||||
if (size <= val.length())
|
||||
size = val.length() + 1;
|
||||
//strcpy((char*)value, val.c_str());
|
||||
setv(&val[0], size, value);
|
||||
estimate += val.length();
|
||||
}
|
||||
if (type)
|
||||
*type = t;
|
||||
|
||||
refresh_current_value(name.c_str(), jsn);
|
||||
std::vector<LPDEVINST>::iterator it = find_openning_device_in_que(handle);
|
||||
refresh_current_value(*it, name.c_str(), jsn);
|
||||
|
||||
jsn->get_value("title", val);
|
||||
|
||||
if (setv == &hg_sane_middleware::set_value_to_new)
|
||||
value = *(void**)value;
|
||||
VLOG_MINI_3(LOG_LEVEL_ALL, "<--Get option(%d - %s) value: %s\n", option, val.c_str(), hg_sane_middleware::option_value_2_string(t, value).c_str());
|
||||
}
|
||||
|
||||
|
@ -1178,7 +1244,7 @@ bool hg_sane_middleware::get_current_value(scanner_handle handle, int option, vo
|
|||
|
||||
return ret;
|
||||
}
|
||||
void* hg_sane_middleware::get_default_value(scanner_handle handle, int option, int* bytes, bool log)
|
||||
void* hg_sane_middleware::get_default_value(scanner_handle handle, const void* option, int* bytes, bool log)
|
||||
{
|
||||
std::string val(get_option_json(handle, (void *)option));
|
||||
void* data = nullptr;
|
||||
|
@ -1238,8 +1304,7 @@ void* hg_sane_middleware::get_default_value(scanner_handle handle, int option, i
|
|||
int size = 0;
|
||||
|
||||
jsn->get_value("size", size);
|
||||
val = "";
|
||||
jsn->get_value("default", val);
|
||||
val = hg_sane_middleware::get_string_in_json(jsn, "default");
|
||||
|
||||
if (size < (int)val.length())
|
||||
size = val.length();
|
||||
|
@ -1259,9 +1324,15 @@ void* hg_sane_middleware::get_default_value(scanner_handle handle, int option, i
|
|||
}
|
||||
delete jsn;
|
||||
|
||||
if (!data && std_opt_)
|
||||
if (!data)
|
||||
{
|
||||
data = std_opt_->get_default_value(handle, option);
|
||||
std::vector<LPDEVINST>::iterator it = find_openning_device_in_que(handle);
|
||||
if (it != openning_.end() && (*it)->std_opt)
|
||||
{
|
||||
SANE_Int id = -1;
|
||||
find_stored_descriptor(handle, option, &id);
|
||||
data = (*it)->std_opt->get_default_value(handle, id);
|
||||
}
|
||||
}
|
||||
|
||||
return data;
|
||||
|
@ -1332,8 +1403,6 @@ SANE_Status hg_sane_middleware::close_device(SANE_Handle h)
|
|||
|
||||
if (hs)
|
||||
err = local_utility::scanner_err_2_sane_statu(hg_scanner_close(hs, true));
|
||||
if (err == SANE_STATUS_GOOD)
|
||||
on_device_closed(hs);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
@ -1351,12 +1420,12 @@ SANE_Status hg_sane_middleware::get_image_parameters(SANE_Handle handle, SANE_Pa
|
|||
}
|
||||
SANE_Status hg_sane_middleware::start(SANE_Handle h, void* async_event)
|
||||
{
|
||||
OPENDEV dev;
|
||||
scanner_handle hs = find_openning_device(h, false, &dev);
|
||||
scanner_err err = SCANNER_ERR_INVALID_PARAMETER;
|
||||
LPDEVINST dev;
|
||||
scanner_handle hs = find_openning_device(h);
|
||||
scanner_err err = SCANNER_ERR_INVALID_PARAMETER;
|
||||
|
||||
if(hs)
|
||||
err = hg_scanner_start(hs, async_event, dev.scan_count);
|
||||
err = hg_scanner_start(hs, async_event, -1);
|
||||
|
||||
return local_utility::scanner_err_2_sane_statu(err);
|
||||
}
|
||||
|
@ -1383,16 +1452,16 @@ SANE_Status hg_sane_middleware::stop(SANE_Handle h)
|
|||
|
||||
return SANE_STATUS_GOOD;
|
||||
}
|
||||
SANE_Option_Descriptor* hg_sane_middleware::get_option_descriptor(SANE_Handle h, SANE_Int option)
|
||||
SANE_Option_Descriptor* hg_sane_middleware::get_option_descriptor(SANE_Handle h, const void* option)
|
||||
{
|
||||
OPENDEV dev;
|
||||
scanner_handle handle = find_openning_device(h, false, &dev);
|
||||
SANE_Option_Descriptor* ret = NULL;
|
||||
SANE_Option_Descriptor* ret = nullptr;
|
||||
scanner_handle handle = hg_sane_middleware::sane_handle_to_scanner(h);
|
||||
std::vector<LPDEVINST>::iterator it = find_openning_device_in_que(handle);
|
||||
SANE_Int id = -1;
|
||||
|
||||
if (!handle)
|
||||
return NULL;
|
||||
|
||||
if (option == 0)
|
||||
if (!handle || it == openning_.end())
|
||||
return nullptr;
|
||||
else if (option == 0)
|
||||
{
|
||||
if (!opt_0_)
|
||||
{
|
||||
|
@ -1408,29 +1477,28 @@ SANE_Option_Descriptor* hg_sane_middleware::get_option_descriptor(SANE_Handle h,
|
|||
return opt_0_;
|
||||
}
|
||||
|
||||
ret = find_stored_descriptor(dev.dev_name.c_str(),option);
|
||||
ret = find_stored_descriptor(handle, option, &id);
|
||||
if (!ret)
|
||||
{
|
||||
std::string key(""),
|
||||
json_txt(get_option_json(handle, (SANE_Int*)option, &key));
|
||||
json_txt(get_option_json(handle, (void*)option, &key, &id));
|
||||
|
||||
if (json_txt.length())
|
||||
{
|
||||
json* jsn = new json();
|
||||
if (jsn->attach_text(&json_txt[0]))
|
||||
{
|
||||
ret = from_json(handle, key, jsn, option);
|
||||
ret = from_json(handle, key, jsn);
|
||||
|
||||
if (ret)
|
||||
{
|
||||
DEVOPT devopt;
|
||||
devopt.dev_name = dev.dev_name;
|
||||
devopt.option_no = option;
|
||||
devopt.option_no = id;
|
||||
devopt.desc = ret;
|
||||
devopt.opt_name = key;
|
||||
opts_.push_back(devopt);
|
||||
devopt.opt_name = std::move(key);
|
||||
(*it)->opts.push_back(std::move(devopt));
|
||||
|
||||
refresh_current_value(devopt.opt_name.c_str(), jsn);
|
||||
refresh_current_value(*it, ret->name, jsn);
|
||||
}
|
||||
}
|
||||
delete jsn;
|
||||
|
@ -1439,17 +1507,17 @@ SANE_Option_Descriptor* hg_sane_middleware::get_option_descriptor(SANE_Handle h,
|
|||
|
||||
if (ret)
|
||||
{
|
||||
if (std_opt_)
|
||||
std_opt_->init_known_opt(option, ret);
|
||||
if ((*it)->std_opt)
|
||||
(*it)->std_opt->init_known_opt(id, ret);
|
||||
}
|
||||
else if (std_opt_)
|
||||
ret = std_opt_->get_option(option);
|
||||
else if ((*it)->std_opt)
|
||||
ret = (*it)->std_opt->get_option(id);
|
||||
|
||||
return ret;
|
||||
}
|
||||
SANE_Status hg_sane_middleware::set_option(SANE_Handle h, SANE_Int option, SANE_Action action, void* value, SANE_Int* after_do)
|
||||
SANE_Status hg_sane_middleware::set_option(SANE_Handle h, const void* option, SANE_Action action, void* value, SANE_Int* after_do)
|
||||
{
|
||||
OPENDEV dev;
|
||||
LPDEVINST dev = nullptr;
|
||||
scanner_handle handle = find_openning_device(h, false, &dev);
|
||||
|
||||
if (!handle || (action == SANE_ACTION_GET_VALUE && !value))
|
||||
|
@ -1472,12 +1540,14 @@ SANE_Status hg_sane_middleware::set_option(SANE_Handle h, SANE_Int option, SANE_
|
|||
}
|
||||
else
|
||||
{
|
||||
if (std_opt_ && std_opt_->is_known_option(option))
|
||||
SANE_Int id = -1;
|
||||
find_stored_descriptor(handle, option, &id);
|
||||
if (dev->std_opt && dev->std_opt->is_known_option(id))
|
||||
{
|
||||
std_opt_->get_value(h, option, value);
|
||||
dev->std_opt->get_value(h, id, value);
|
||||
ret = SANE_STATUS_GOOD;
|
||||
}
|
||||
else if(get_current_value(handle, option, value))
|
||||
else if(get_current_value(handle, option, &hg_sane_middleware::set_value_to_var, value))
|
||||
ret = SANE_STATUS_GOOD;
|
||||
}
|
||||
|
||||
|
@ -1485,19 +1555,20 @@ SANE_Status hg_sane_middleware::set_option(SANE_Handle h, SANE_Int option, SANE_
|
|||
}
|
||||
else
|
||||
{
|
||||
SANE_Option_Descriptor* desc = find_stored_descriptor(dev.dev_name.c_str(), option);
|
||||
SANE_Int id = -1;
|
||||
SANE_Option_Descriptor* desc = find_stored_descriptor(handle, option, &id);
|
||||
bool release_value = false;
|
||||
scanner_err err = SCANNER_ERR_OK;
|
||||
SANE_Status status = SANE_STATUS_GOOD;
|
||||
std::string prev(""), v("");
|
||||
|
||||
if (std_opt_ && std_opt_->is_known_option(option, &desc))
|
||||
if (dev->std_opt && dev->std_opt->is_known_option(id, &desc))
|
||||
{
|
||||
SANE_Option_Descriptor* known = std_opt_->get_option(option);
|
||||
SANE_Option_Descriptor* known = dev->std_opt->get_option(id);
|
||||
unsigned char* cont = (unsigned char*)value;
|
||||
prev = hg_sane_middleware::option_value_2_string(known->type, value);
|
||||
VLOG_MINI_5(LOG_LEVEL_DEBUG_INFO, "$First 4-bytes of origin value for option %d is: %02X%02X%02X%02X\n", option, cont[0], cont[1], cont[2], cont[3]);
|
||||
err = std_opt_->set_value(handle, option, value);
|
||||
err = dev->std_opt->set_value(handle, id, value);
|
||||
v = hg_sane_middleware::option_value_2_string(known->type, value);
|
||||
}
|
||||
else
|
||||
|
@ -1569,16 +1640,16 @@ SANE_Status hg_sane_middleware::set_option(SANE_Handle h, SANE_Int option, SANE_
|
|||
|
||||
if (err == SCANNER_ERR_OK)
|
||||
{
|
||||
err = (scanner_err)something_after_do(handle, dev.dev_name.c_str(), desc->name, v.c_str());
|
||||
err = (scanner_err)something_after_do(dev, desc->name, v.c_str());
|
||||
}
|
||||
else if (err == SCANNER_ERR_NOT_EXACT)
|
||||
{
|
||||
err = (scanner_err)(something_after_do(handle, dev.dev_name.c_str(), desc->name, v.c_str()) | SANE_INFO_INEXACT);
|
||||
err = (scanner_err)(something_after_do(dev, desc->name, v.c_str()) | SANE_INFO_INEXACT);
|
||||
}
|
||||
else if (err == SCANNER_ERR_CONFIGURATION_CHANGED)
|
||||
{
|
||||
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "the setting '%s' affects other options value, RELOAD ...\n", desc->title);
|
||||
on_SCANNER_ERR_CONFIGURATION_CHANGED(handle, dev.dev_name.c_str());
|
||||
on_SCANNER_ERR_CONFIGURATION_CHANGED(dev);
|
||||
err = (scanner_err)SANE_INFO_RELOAD_OPTIONS;
|
||||
}
|
||||
else if (err == SCANNER_ERR_ACCESS_DENIED)
|
||||
|
@ -1600,16 +1671,28 @@ SANE_Status hg_sane_middleware::set_option(SANE_Handle h, SANE_Int option, SANE_
|
|||
return status;
|
||||
}
|
||||
}
|
||||
bool hg_sane_middleware::get_cur_value(SANE_Handle handle, int option, void* value, SANE_Value_Type* type)
|
||||
bool hg_sane_middleware::get_cur_value(SANE_Handle handle, void* option, void* value, SANE_Value_Type* type)
|
||||
{
|
||||
scanner_handle h = find_openning_device(handle);
|
||||
|
||||
if (!h)
|
||||
return false;
|
||||
|
||||
return get_current_value(h, option, value, type);
|
||||
return get_current_value(h, option, &hg_sane_middleware::set_value_to_var, value, type);
|
||||
}
|
||||
void* hg_sane_middleware::get_def_value(SANE_Handle handle, int option, int* bytes, bool log)
|
||||
void* hg_sane_middleware::get_cur_value(SANE_Handle handle, void* option, SANE_Value_Type* type)
|
||||
{
|
||||
scanner_handle h = find_openning_device(handle);
|
||||
void* buf = nullptr;
|
||||
|
||||
if (!h)
|
||||
return NULL;
|
||||
|
||||
get_current_value(h, option, &hg_sane_middleware::set_value_to_new, &buf, type);
|
||||
|
||||
return buf;
|
||||
}
|
||||
void* hg_sane_middleware::get_def_value(SANE_Handle handle, void* option, int* bytes, bool log)
|
||||
{
|
||||
scanner_handle h = find_openning_device(handle);
|
||||
|
||||
|
@ -1620,8 +1703,8 @@ void* hg_sane_middleware::get_def_value(SANE_Handle handle, int option, int* byt
|
|||
}
|
||||
SANE_Status hg_sane_middleware::io_control(SANE_Handle h, unsigned long code, void* data, unsigned* len)
|
||||
{
|
||||
OPENDEV od;
|
||||
scanner_handle handle = find_openning_device(h, false, &od);
|
||||
LPDEVINST dev;
|
||||
scanner_handle handle = find_openning_device(h, false, &dev);
|
||||
int ret = SANE_STATUS_GOOD;
|
||||
|
||||
// commented at 2022-03-23 for getting app about info before open any device
|
||||
|
@ -1633,7 +1716,7 @@ SANE_Status hg_sane_middleware::io_control(SANE_Handle h, unsigned long code, vo
|
|||
{
|
||||
int nc = code;
|
||||
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "the setting '0x%08x' affects other options value, RELOAD ...\n", nc);
|
||||
on_SCANNER_ERR_CONFIGURATION_CHANGED(handle, od.dev_name.c_str());
|
||||
on_SCANNER_ERR_CONFIGURATION_CHANGED(dev);
|
||||
}
|
||||
|
||||
return local_utility::scanner_err_2_sane_statu(ret);
|
||||
|
@ -1813,7 +1896,7 @@ bool hg_sane_middleware::parse_master_option(const char* depend_str, MASTEROP& m
|
|||
|
||||
return ret;
|
||||
}
|
||||
bool hg_sane_middleware::parse_depends(json* jsn, SLAVEOP& so)
|
||||
bool hg_sane_middleware::parse_depends(json* jsn, SLAVEOP& so, std::vector<std::string>& master)
|
||||
{
|
||||
std::string val(""), mn("");
|
||||
bool ret = jsn->first_child(val);
|
||||
|
@ -1831,10 +1914,10 @@ bool hg_sane_middleware::parse_depends(json* jsn, SLAVEOP& so)
|
|||
else
|
||||
mn = mo.name;
|
||||
so.master.push_back(mo);
|
||||
if (std::find(master_options_.begin(), master_options_.end(), mo.name) == master_options_.end())
|
||||
if (std::find(master.begin(), master.end(), mo.name) == master.end())
|
||||
{
|
||||
master_options_.push_back(mo.name);
|
||||
std::sort(master_options_.begin(), master_options_.end());
|
||||
master.push_back(mo.name);
|
||||
std::sort(master.begin(), master.end());
|
||||
}
|
||||
ret = jsn->next_child(val);
|
||||
}
|
||||
|
@ -1857,9 +1940,9 @@ bool hg_sane_middleware::is_associatived(const SLAVEOP& slave, const char* maste
|
|||
|
||||
return result;
|
||||
}
|
||||
bool hg_sane_middleware::set_stored_option_enabled(const char* dev_name, unsigned long long option, bool enable, int* size)
|
||||
bool hg_sane_middleware::set_stored_option_enabled(scanner_handle h, const void* option, bool enable, int* size)
|
||||
{
|
||||
SANE_Option_Descriptor* opt = find_stored_descriptor(dev_name, option);
|
||||
SANE_Option_Descriptor* opt = find_stored_descriptor(h, option);
|
||||
bool ret = false;
|
||||
|
||||
if (opt)
|
||||
|
@ -1875,14 +1958,14 @@ bool hg_sane_middleware::set_stored_option_enabled(const char* dev_name, unsigne
|
|||
|
||||
return ret;
|
||||
}
|
||||
int hg_sane_middleware::something_after_do(scanner_handle h, const char* dev_name, const char* master_name, const char* cur_val)
|
||||
int hg_sane_middleware::something_after_do(LPDEVINST dev, const char* master_name, const char* cur_val)
|
||||
{
|
||||
int after = 0;
|
||||
OPTENABLE oe;
|
||||
std::vector<OPTENABLE> changed_options;
|
||||
|
||||
refresh_current_value(master_name, cur_val);
|
||||
if (std::find(master_options_.begin(), master_options_.end(), master_name) == master_options_.end())
|
||||
refresh_current_value(dev, master_name, cur_val);
|
||||
if (std::find(dev->masters.begin(), dev->masters.end(), master_name) == dev->masters.end())
|
||||
{
|
||||
return after;
|
||||
}
|
||||
|
@ -1892,32 +1975,32 @@ int hg_sane_middleware::something_after_do(scanner_handle h, const char* dev_nam
|
|||
changed_options.push_back(oe);
|
||||
for (size_t i = 0; i < changed_options.size(); ++i)
|
||||
{
|
||||
for (size_t slave = 0; slave < slave_options_.size(); ++slave)
|
||||
for (size_t slave = 0; slave < dev->slaves.size(); ++slave)
|
||||
{
|
||||
if (slave_options_[slave].name == changed_options[i].name ||
|
||||
!is_associatived(slave_options_[slave], changed_options[i].name.c_str()))
|
||||
if (dev->slaves[slave].name == changed_options[i].name ||
|
||||
!is_associatived(dev->slaves[slave], changed_options[i].name.c_str()))
|
||||
continue;
|
||||
|
||||
bool enable = changed_options[i].enable;
|
||||
int bytes = 0;
|
||||
// if (enable)
|
||||
enable = slave_options_[slave].is_enable(slave_options_[slave].master, cur_vals_);
|
||||
if (enable == slave_options_[slave].enable_now)
|
||||
enable = dev->slaves[slave].is_enable(dev->slaves[slave].master, dev->cur_vals);
|
||||
if (enable == dev->slaves[slave].enable_now)
|
||||
continue;
|
||||
|
||||
slave_options_[slave].enable_now = enable;
|
||||
if (!set_stored_option_enabled(dev_name, (unsigned long long )slave_options_[slave].name.c_str(), enable, &bytes))
|
||||
dev->slaves[slave].enable_now = enable;
|
||||
if (!set_stored_option_enabled(dev->dev, dev->slaves[slave].name.c_str(), enable, &bytes))
|
||||
continue;
|
||||
|
||||
OPTEN* op = get_control_enalbe_data(slave_options_[slave]);
|
||||
hg_scanner_control(h, HG_CONTROL_CODE_OPTION_ENABLE, op, NULL);
|
||||
OPTEN* op = get_control_enalbe_data(dev, dev->slaves[slave]);
|
||||
hg_scanner_control(dev->dev, HG_CONTROL_CODE_OPTION_ENABLE, op, NULL);
|
||||
free_control_enable_data(op);
|
||||
|
||||
if (std::find(changed_options.begin(), changed_options.end(), slave_options_[slave].name) != changed_options.end())
|
||||
if (std::find(changed_options.begin(), changed_options.end(), dev->slaves[slave].name) != changed_options.end())
|
||||
continue;
|
||||
|
||||
oe.name = slave_options_[slave].name;
|
||||
oe.enable = slave_options_[slave].enable_now;
|
||||
oe.name = dev->slaves[slave].name;
|
||||
oe.enable = dev->slaves[slave].enable_now;
|
||||
changed_options.push_back(oe);
|
||||
}
|
||||
}
|
||||
|
@ -1927,16 +2010,16 @@ int hg_sane_middleware::something_after_do(scanner_handle h, const char* dev_nam
|
|||
|
||||
return after;
|
||||
}
|
||||
bool hg_sane_middleware::refresh_current_value(const char* name, json* jsn)
|
||||
bool hg_sane_middleware::refresh_current_value(LPDEVINST dev, const char* name, json* jsn)
|
||||
{
|
||||
std::vector<CURVAL>::iterator it = std::find(cur_vals_.begin(), cur_vals_.end(), name);
|
||||
if (it == cur_vals_.end())
|
||||
std::vector<CURVAL>::iterator it = std::find(dev->cur_vals.begin(), dev->cur_vals.end(), name);
|
||||
if (it == dev->cur_vals.end())
|
||||
{
|
||||
CURVAL cv;
|
||||
jsn->get_value("type", cv.type);
|
||||
cv.name = name;
|
||||
jsn->get_value_as_string("cur", cv.val, cv.type == "int");
|
||||
cur_vals_.push_back(cv);
|
||||
dev->cur_vals.push_back(cv);
|
||||
|
||||
return false;
|
||||
}
|
||||
|
@ -1948,10 +2031,10 @@ bool hg_sane_middleware::refresh_current_value(const char* name, json* jsn)
|
|||
return old != it->val;
|
||||
}
|
||||
}
|
||||
bool hg_sane_middleware::refresh_current_value(const char* name, const char* val)
|
||||
bool hg_sane_middleware::refresh_current_value(LPDEVINST dev, const char* name, const char* val)
|
||||
{
|
||||
std::vector<CURVAL>::iterator it = std::find(cur_vals_.begin(), cur_vals_.end(), name);
|
||||
if (it != cur_vals_.end())
|
||||
std::vector<CURVAL>::iterator it = std::find(dev->cur_vals.begin(), dev->cur_vals.end(), name);
|
||||
if (it != dev->cur_vals.end())
|
||||
{
|
||||
bool ret = strcmp(it->val.c_str(), val) == 0;
|
||||
|
||||
|
@ -1962,7 +2045,7 @@ bool hg_sane_middleware::refresh_current_value(const char* name, const char* val
|
|||
|
||||
return false;
|
||||
}
|
||||
OPTEN* hg_sane_middleware::get_control_enalbe_data(const SLAVEOP& slave)
|
||||
OPTEN* hg_sane_middleware::get_control_enalbe_data(LPDEVINST dev, const SLAVEOP& slave)
|
||||
{
|
||||
std::vector<std::string> master;
|
||||
OPTEN* opt = NULL;
|
||||
|
@ -1982,8 +2065,8 @@ OPTEN* hg_sane_middleware::get_control_enalbe_data(const SLAVEOP& slave)
|
|||
opt->master_count = 0;
|
||||
for (size_t i = 0; i < master.size(); ++i)
|
||||
{
|
||||
std::vector<CURVAL>::iterator m = std::find(cur_vals_.begin(), cur_vals_.end(), master[i]);
|
||||
if (m == cur_vals_.end())
|
||||
std::vector<CURVAL>::iterator m = std::find(dev->cur_vals.begin(), dev->cur_vals.end(), master[i]);
|
||||
if (m == dev->cur_vals.end())
|
||||
continue;
|
||||
|
||||
opt->master[opt->master_count].name = master[i];
|
||||
|
@ -2020,20 +2103,40 @@ void hg_sane_middleware::free_control_enable_data(OPTEN* opt)
|
|||
free(opt);
|
||||
}
|
||||
}
|
||||
void hg_sane_middleware::on_SCANNER_ERR_CONFIGURATION_CHANGED(scanner_handle handle, const char* dev_name)
|
||||
void hg_sane_middleware::on_SCANNER_ERR_CONFIGURATION_CHANGED(LPDEVINST dev)
|
||||
{
|
||||
std::vector<std::string> changed;
|
||||
reload_current_value(handle, &changed);
|
||||
reload_current_value(dev->dev, &changed);
|
||||
if (changed.size())
|
||||
{
|
||||
for (size_t i = 0; i < changed.size(); ++i)
|
||||
{
|
||||
std::vector<CURVAL>::iterator it = std::find(cur_vals_.begin(), cur_vals_.end(), changed[i]);
|
||||
if (it != cur_vals_.end())
|
||||
something_after_do(handle, dev_name, it->name.c_str(), it->val.c_str());
|
||||
std::vector<CURVAL>::iterator it = std::find(dev->cur_vals.begin(), dev->cur_vals.end(), changed[i]);
|
||||
if (it != dev->cur_vals.end())
|
||||
something_after_do(dev, it->name.c_str(), it->val.c_str());
|
||||
}
|
||||
}
|
||||
}
|
||||
std::vector<LPDEVINST>::iterator hg_sane_middleware::find_openning_device_in_que(scanner_handle h)
|
||||
{
|
||||
for (size_t i = 0; i < openning_.size(); ++i)
|
||||
{
|
||||
if (openning_[i]->dev == h)
|
||||
return openning_.begin() + i;
|
||||
}
|
||||
|
||||
return openning_.end();
|
||||
}
|
||||
std::vector<LPDEVINST>::iterator hg_sane_middleware::find_openning_device_in_que(const char* name)
|
||||
{
|
||||
for (size_t i = 0; i < openning_.size(); ++i)
|
||||
{
|
||||
if (openning_[i]->name == name)
|
||||
return openning_.begin() + i;
|
||||
}
|
||||
|
||||
return openning_.end();
|
||||
}
|
||||
/// </summary>
|
||||
|
||||
/// <summary>
|
||||
|
@ -2069,11 +2172,11 @@ extern "C" { // avoid compiler exporting name in C++ style !!!
|
|||
hg_sane_middleware::instance()->close_device(handle);
|
||||
}
|
||||
const SANE_Option_Descriptor*
|
||||
inner_sane_get_option_descriptor(SANE_Handle handle, SANE_Int option)
|
||||
inner_sane_get_option_descriptor(SANE_Handle handle, const void* option)
|
||||
{
|
||||
return hg_sane_middleware::instance()->get_option_descriptor(handle, option);
|
||||
}
|
||||
SANE_Status inner_sane_control_option(SANE_Handle handle, SANE_Int option, SANE_Action action, void* value, SANE_Int* info)
|
||||
SANE_Status inner_sane_control_option(SANE_Handle handle, const void* option, SANE_Action action, void* value, SANE_Int* info)
|
||||
{
|
||||
return hg_sane_middleware::instance()->set_option(handle, option, action, value, info);
|
||||
}
|
||||
|
@ -2135,6 +2238,10 @@ extern "C" { // avoid compiler exporting name in C++ style !!!
|
|||
{
|
||||
return hg_scanner_err_description(local_utility::sane_statu_2_scanner_err(err));
|
||||
}
|
||||
SANE_Status inner_sane_read_ext(SANE_Img_Ext_Info* ext_info, SANE_Int* len)
|
||||
{
|
||||
return SANE_STATUS_UNSUPPORTED;
|
||||
}
|
||||
|
||||
void sanei_debug_msg(int level, int max_level, const char* be, const char* fmt, va_list ap)
|
||||
{
|
||||
|
|
|
@ -26,43 +26,105 @@
|
|||
|
||||
class json;
|
||||
class sane_std_opts;
|
||||
typedef struct _device_option
|
||||
{
|
||||
// std::string dev_name;
|
||||
int option_no;
|
||||
std::string opt_name;
|
||||
SANE_Option_Descriptor* desc;
|
||||
}DEVOPT;
|
||||
typedef struct _cur_val
|
||||
{
|
||||
std::string name;
|
||||
std::string type;
|
||||
std::string val; /*参数全部字符串化*/
|
||||
|
||||
bool operator==(const std::string& n)
|
||||
{
|
||||
return name == n;
|
||||
}
|
||||
}CURVAL;
|
||||
typedef struct _master_option
|
||||
{
|
||||
std::string name;
|
||||
SANE_Value_Type type;
|
||||
std::string limit_l;
|
||||
std::string limit_r;
|
||||
bool(*compare_val)(const char* cur_val, const char* limit_l, const char* limit_r); // ==, !=, >, >=, <, <=, [l, r], ![l, r]
|
||||
}MASTEROP;
|
||||
typedef struct _slave_option
|
||||
{
|
||||
std::string name;
|
||||
bool enable_now;
|
||||
std::vector<MASTEROP> master;
|
||||
bool (*is_enable)(const std::vector<MASTEROP>& master
|
||||
, std::vector<CURVAL>& curvals/*参数全部字符串化*/); // logic 'and', 'or' opertions
|
||||
}SLAVEOP;
|
||||
typedef struct _opt_status
|
||||
{
|
||||
std::string name;
|
||||
bool enable;
|
||||
|
||||
bool operator==(const std::string& opt)
|
||||
{
|
||||
return name == opt;
|
||||
}
|
||||
}OPTENABLE;
|
||||
typedef struct _dev_inst
|
||||
{
|
||||
scanner_handle dev;
|
||||
std::string name;
|
||||
sane_std_opts* std_opt;
|
||||
std::vector<DEVOPT> opts;
|
||||
std::vector<CURVAL> cur_vals;
|
||||
std::vector<SLAVEOP> slaves;
|
||||
std::vector<std::string> masters;
|
||||
|
||||
bool operator==(const char* n)
|
||||
{
|
||||
return strcmp(name.c_str(), n) == 0;
|
||||
}
|
||||
bool operator==(scanner_handle h)
|
||||
{
|
||||
return dev == h;
|
||||
}
|
||||
|
||||
struct _dev_inst()
|
||||
{
|
||||
dev = nullptr;
|
||||
name = "";
|
||||
std_opt = nullptr;
|
||||
}
|
||||
}DEVINST, * LPDEVINST;
|
||||
class hg_sane_middleware
|
||||
{
|
||||
typedef struct _device_option
|
||||
{
|
||||
std::string dev_name;
|
||||
int option_no;
|
||||
std::string opt_name;
|
||||
SANE_Option_Descriptor* desc;
|
||||
}DEVOPT;
|
||||
std::vector<DEVOPT> opts_;
|
||||
// std::vector<DEVOPT> opts_;
|
||||
SANE_Option_Descriptor* opt_0_;
|
||||
sane_std_opts* std_opt_;
|
||||
bool init_ok_;
|
||||
|
||||
typedef struct _openning_scanner_option
|
||||
{
|
||||
std::string dev_name;
|
||||
scanner_handle handle;
|
||||
int scan_count;
|
||||
|
||||
//struct _openning_scanner_option()
|
||||
//{
|
||||
// dev_name = "";
|
||||
// handle = NULL;
|
||||
// option_no = 0;
|
||||
// desc = NULL;
|
||||
//}
|
||||
bool operator==(const char* name)
|
||||
{
|
||||
return strcmp(dev_name.c_str(), name) == 0;
|
||||
}
|
||||
bool operator==(scanner_handle h)
|
||||
{
|
||||
return handle == h;
|
||||
}
|
||||
}OPENDEV;
|
||||
std::vector<OPENDEV> openning_;
|
||||
//typedef struct _openning_scanner_option
|
||||
//{
|
||||
// std::string dev_name;
|
||||
// scanner_handle handle;
|
||||
// int scan_count;
|
||||
//
|
||||
// //struct _openning_scanner_option()
|
||||
// //{
|
||||
// // dev_name = "";
|
||||
// // handle = NULL;
|
||||
// // option_no = 0;
|
||||
// // desc = NULL;
|
||||
// //}
|
||||
// bool operator==(const char* name)
|
||||
// {
|
||||
// return strcmp(dev_name.c_str(), name) == 0;
|
||||
// }
|
||||
// bool operator==(scanner_handle h)
|
||||
// {
|
||||
// return handle == h;
|
||||
// }
|
||||
//}OPENDEV;
|
||||
//std::vector<OPENDEV> openning_;
|
||||
|
||||
static hg_sane_middleware *inst_;
|
||||
static const SANE_Device** dev_list_;
|
||||
|
@ -73,37 +135,25 @@ class hg_sane_middleware
|
|||
static void device_pnp(int sig); // 热插拔事件监控
|
||||
static SANE_Fixed double_2_sane_fixed(double v);
|
||||
static double sane_fixed_2_double(SANE_Fixed v);
|
||||
static void set_value_to_var(void* val, size_t bytes, void* param);
|
||||
static void set_value_to_new(void* val, size_t bytes, void* param);
|
||||
|
||||
void on_device_closed(scanner_handle h);
|
||||
SANE_Status open(SANE_String_Const devicename, SANE_Handle* handle, const char* name, const char* pwd, const char* method, char* rsc);
|
||||
SANE_Option_Descriptor* from_json(scanner_handle h, const std::string& name, json* jsn, int opt_no);
|
||||
scanner_handle find_openning_device(SANE_Handle h, bool rmv = false, OPENDEV* dev = NULL);
|
||||
std::string get_option_json(scanner_handle handle, void* opt, std::string* key = nullptr);
|
||||
SANE_Option_Descriptor* find_stored_descriptor(const char* name, unsigned long long option);
|
||||
SANE_Option_Descriptor* find_stored_descriptor(SANE_Handle handle, unsigned long long option);
|
||||
SANE_Option_Descriptor* from_json(scanner_handle h, const std::string& name, json* jsn);
|
||||
std::string get_option_json(scanner_handle handle, void* opt, std::string* key = nullptr, SANE_Int* id = nullptr);
|
||||
SANE_Option_Descriptor* find_stored_descriptor(scanner_handle handle, const void* option, SANE_Int* id = nullptr);
|
||||
|
||||
void reload_current_value(scanner_handle handle, std::vector<std::string>* changed = NULL);
|
||||
bool get_current_value(scanner_handle handle, int option, void* value, SANE_Value_Type* type = NULL);
|
||||
void* get_default_value(scanner_handle handle, int option, int* bytes = nullptr, bool log = false); // caller should call local_utility::free_memory to free the returned value
|
||||
bool get_current_value(scanner_handle handle, const void* option, void(*setv)(void*, size_t, void*), void* value, SANE_Value_Type* type = NULL);
|
||||
void* get_default_value(scanner_handle handle, const void* option, int* bytes = nullptr, bool log = false); // caller should call local_utility::free_memory to free the returned value
|
||||
|
||||
/// <summary>
|
||||
/// 关联项处理
|
||||
|
||||
// 添加对多依赖项的支持 - 2022-03-10
|
||||
typedef struct _cur_val
|
||||
{
|
||||
std::string name;
|
||||
std::string type;
|
||||
std::string val; /*参数全部字符串化*/
|
||||
|
||||
bool operator==(const std::string& n)
|
||||
{
|
||||
return name == n;
|
||||
}
|
||||
}CURVAL;
|
||||
std::vector<CURVAL> cur_vals_;
|
||||
bool refresh_current_value(const char* name, json* jsn); // return whether changed old value
|
||||
bool refresh_current_value(const char* name, const char* val);
|
||||
//std::vector<CURVAL> cur_vals_;
|
||||
bool refresh_current_value(LPDEVINST dev, const char* name, json* jsn); // return whether changed old value
|
||||
bool refresh_current_value(LPDEVINST dev, const char* name, const char* val);
|
||||
|
||||
static bool compare_val_equal(const char* cur_val, const char* limit_l, const char* limit_r);
|
||||
static bool compare_val_not_equal(const char* cur_val, const char* limit_l, const char* limit_r);
|
||||
|
@ -113,49 +163,30 @@ class hg_sane_middleware
|
|||
static bool compare_val_not_great(const char* cur_val, const char* limit_l, const char* limit_r);
|
||||
static bool compare_val_between(const char* cur_val, const char* limit_l, const char* limit_r);
|
||||
static bool compare_val_not_between(const char* cur_val, const char* limit_l, const char* limit_r);
|
||||
typedef struct _master_option
|
||||
{
|
||||
std::string name;
|
||||
SANE_Value_Type type;
|
||||
std::string limit_l;
|
||||
std::string limit_r;
|
||||
bool(*compare_val)(const char* cur_val, const char* limit_l, const char* limit_r); // ==, !=, >, >=, <, <=, [l, r], ![l, r]
|
||||
}MASTEROP;
|
||||
|
||||
static bool is_enable_and(const std::vector<MASTEROP>& master, std::vector<CURVAL>& curvals);
|
||||
static bool is_enable_or(const std::vector<MASTEROP>& master, std::vector<CURVAL>& curvals);
|
||||
typedef struct _slave_option
|
||||
{
|
||||
std::string name;
|
||||
bool enable_now;
|
||||
std::vector<MASTEROP> master;
|
||||
bool (*is_enable)(const std::vector<MASTEROP>& master
|
||||
, std::vector<CURVAL>& curvals/*参数全部字符串化*/); // logic 'and', 'or' opertions
|
||||
}SLAVEOP;
|
||||
std::vector<SLAVEOP> slave_options_;
|
||||
std::vector<std::string> master_options_;
|
||||
//std::vector<SLAVEOP> slave_options_;
|
||||
//std::vector<std::string> master_options_;
|
||||
|
||||
|
||||
bool parse_master_option(const char* depend_str, MASTEROP& mo);
|
||||
bool parse_depends(json* jsn, SLAVEOP& so);
|
||||
bool parse_depends(json* jsn, SLAVEOP& so, std::vector<std::string>& master);
|
||||
|
||||
typedef struct _opt_enabled
|
||||
{
|
||||
std::string name;
|
||||
bool enable;
|
||||
|
||||
bool operator==(const std::string& opt)
|
||||
{
|
||||
return name == opt;
|
||||
}
|
||||
}OPTENABLE;
|
||||
bool is_associatived(const SLAVEOP& slave, const char* master_name);
|
||||
bool set_stored_option_enabled(const char* dev_name, unsigned long long option, bool enable, int* size = NULL);
|
||||
int something_after_do(scanner_handle h, const char* dev_name, const char* master_name, const char* cur_val);
|
||||
OPTEN* get_control_enalbe_data(const SLAVEOP& slave);
|
||||
bool set_stored_option_enabled(scanner_handle h, const void* option, bool enable, int* size = NULL);
|
||||
int something_after_do(LPDEVINST dev, const char* master_name, const char* cur_val);
|
||||
OPTEN* get_control_enalbe_data(LPDEVINST dev, const SLAVEOP& slave);
|
||||
void free_control_enable_data(OPTEN* opt);
|
||||
void on_SCANNER_ERR_CONFIGURATION_CHANGED(scanner_handle handle, const char* dev_name);
|
||||
/// 关联项处理结束
|
||||
void on_SCANNER_ERR_CONFIGURATION_CHANGED(LPDEVINST dev);
|
||||
|
||||
std::vector<LPDEVINST> openning_;
|
||||
std::vector<LPDEVINST>::iterator find_openning_device_in_que(scanner_handle h);
|
||||
std::vector<LPDEVINST>::iterator find_openning_device_in_que(const char* name);
|
||||
/// 关联项处理结束
|
||||
|
||||
static void free_device_inst(LPDEVINST dev);
|
||||
scanner_handle find_openning_device(SANE_Handle h, bool rmv = false, LPDEVINST* dev = NULL);
|
||||
|
||||
protected:
|
||||
hg_sane_middleware(void);
|
||||
|
@ -177,6 +208,7 @@ public:
|
|||
, const std::vector<int>& values); // NO constraint if values was empty
|
||||
static SANE_Option_Descriptor* number_option_to_SANE_descriptor(const char* name, const char* title, const char* desc
|
||||
, const std::vector<double>& values); // NO constraint if values was empty
|
||||
static std::string get_string_in_json(json* jsn, const char* key);
|
||||
|
||||
// methods ...
|
||||
public:
|
||||
|
@ -188,10 +220,11 @@ public:
|
|||
SANE_Status read(SANE_Handle h, void* buf, int* bytes);
|
||||
SANE_Status stop(SANE_Handle h);
|
||||
|
||||
SANE_Option_Descriptor* get_option_descriptor(SANE_Handle h, SANE_Int option);
|
||||
SANE_Status set_option(SANE_Handle h, SANE_Int option, SANE_Action action, void* value, SANE_Int* after_do);
|
||||
bool get_cur_value(SANE_Handle handle, int option, void* value, SANE_Value_Type* type = NULL); // SANE_type
|
||||
void* get_def_value(SANE_Handle handle, int option, int* bytes = nullptr, bool log = false); // caller should call local_utility::free_memory to free the returned value, SANE_type
|
||||
SANE_Option_Descriptor* get_option_descriptor(SANE_Handle h, const void* option);
|
||||
SANE_Status set_option(SANE_Handle h, const void* option, SANE_Action action, void* value, SANE_Int* after_do);
|
||||
bool get_cur_value(SANE_Handle handle, void* option, void* value, SANE_Value_Type* type = nullptr); // SANE_type
|
||||
void* get_cur_value(SANE_Handle handle, void* option, SANE_Value_Type* type = nullptr); // caller should call local_utility::free_memory to free the returned value, SANE_type
|
||||
void* get_def_value(SANE_Handle handle, void* option, int* bytes = nullptr, bool log = false); // caller should call local_utility::free_memory to free the returned value, SANE_type
|
||||
|
||||
// extension ...
|
||||
SANE_Status io_control(SANE_Handle h, unsigned long code, void* data, unsigned* len);
|
||||
|
|
Loading…
Reference in New Issue