lmh188
/
tx-gxx-linux
mirror of http://192.168.1.51:8099/scanner/tx-gxx-linux.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

增加通讯缓冲区动态调整功能

This commit is contained in:
gb 2023-09-14 16:05:44 +08:00
parent eec4604ee3
commit 0436eb8eb8
19 changed files with 525 additions and 142 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
device/gxx-linux/usb/src/async_model/common/packet.h
View File

@ -48,6 +48,7 @@ enum ep0_req
USB_REQ_EP0_RESET_BULK, // 关闭并重新打开BULK端点, return error number (uint32_t). req = me, ind = 0, val = 0, len = sizeof(uint32_t)
USB_REQ_EP0_CANCEL_CMD, // 取消当前指令的继续执行（一般用于中止大数据的传输）. req = me, ind = 0, val = 0, len = sizeof(uint32_t) * 2 [(uint32_t)cmd + (uint32_t)pack-id]
USB_REQ_EP0_SET_ENCRYPT, // 设置加密方式， req = me, ind = 0, val = 0, len = sizeof(PACK_BASE)
USB_REQ_EP0_SET_BULK_BUFFER, // 设置bulk缓冲区大小系数， req = me, ind = coef, val = 0, len = 0
};
enum bulk_status
{

1
device/gxx-linux/usb/src/async_model/hardware/hardware.cpp
View File

@ -22,6 +22,7 @@ extern int32_t (*set_scan_num)(int);
extern int32_t (*set_paper_type)(int);
extern int32_t (*set_pixel_type)(int*);
extern int32_t (*set_capturer_param)(int, int, int);
extern int32_t (*int_opt_value)(int, int*, bool);
#endif
image_capture::image_capture(std::function<CAPTURED_IMG_RECEIVER_PROTO> receiver)

13
device/gxx-linux/usb/src/async_model/io/usb_io.cpp
View File

@ -332,6 +332,15 @@ dyn_mem_ptr async_usb_gadget::handle_ctrl_setup(dyn_mem_ptr data)
log_cls::log(LOG_LEVEL_DEBUG, "Set encrypting method: command - %d; payload - %d\n", enc_head_, enc_payload_);
}
break;
case USB_REQ_EP0_SET_BULK_BUFFER:
// if(pev->u.setup.wLength == sizeof(short))
{
uint16_t pre = buf_coef_;
buf_coef_ = pev->u.setup.wIndex;
log_cls::log(LOG_LEVEL_DEBUG, "Set bulk buffer size coefficient from %d to %d\n", pre, buf_coef_);
}
break;
default:
handled = false;
}
@ -350,7 +359,7 @@ dyn_mem_ptr async_usb_gadget::handle_ctrl_setup(dyn_mem_ptr data)
int async_usb_gadget::inner_write_bulk(data_source_ptr data, int* err)
{
unsigned char* ptr = data->ptr();
size_t bulk_size = gadget_->ep_config[EP_DESCRIPTOR_IN]->ep_desc[0].ep_desc.wMaxPacketSize,
size_t bulk_size = gadget_->ep_config[EP_DESCRIPTOR_IN]->ep_desc[0].ep_desc.wMaxPacketSize * buf_coef_,
total = data->get_rest(), off = 0, size = total > bulk_size ? bulk_size : total;
int w = 0;
@ -558,7 +567,7 @@ void async_usb_gadget::thread_read_ep0(void)
void async_usb_gadget::thread_read_bulk(void)
{
log_cls::log(LOG_LEVEL_ALL, "thread_read_bulk(%p of id %lx) started ...\n", &async_usb_gadget::thread_read_bulk, sys_util::thread_id(std::this_thread::get_id()));
size_t bulk_size = gadget_->ep_config[EP_DESCRIPTOR_OUT]->ep_desc[0].ep_desc.wMaxPacketSize;
size_t bulk_size = gadget_->ep_config[EP_DESCRIPTOR_OUT]->ep_desc[0].ep_desc.wMaxPacketSize * buf_coef_;
uint32_t cnt_0 = 0;
while(run_)

1
device/gxx-linux/usb/src/async_model/io/usb_io.h
View File

@ -72,6 +72,7 @@ class async_usb_gadget : public refer
thread_pool<async_usb_gadget>* threads_ = nullptr;
volatile bool run_ = true;
volatile bool reset_bulk_ = false;
volatile uint16_t buf_coef_ = 1;
usb_gadget *gadget_ = nullptr;
uint64_t thread_ep0_id_ = -1;
uint64_t thread_bulk_in_id_ = -1;

1
device/gxx-linux/usb/src/usbdevice.cpp
View File

@ -27,6 +27,7 @@ int32_t (*set_pixel_type)(int*) = nullptr;
int32_t (*set_capturer_param)(int, int, int) = nullptr;
int32_t (*set_image_receiver)(void(*rcv)(int data_type, void* data, size_t w, size_t h, int, int, size_t paper_ind, paper_side side, clr_channel clr, img_status status, bool img_new, bool img_over, float ratio_h, float ratio_v, void* param), void* param) = nullptr;
int32_t (*set_image_process_over)(bool) = nullptr;
int32_t (*int_opt_value)(int, int*, bool) = nullptr;
#endif
#else
#define LOG_LEVEL_ALL 0

30
pc/code_twain/sln/usb_tools/DlgScanner.cpp
View File

@ -752,8 +752,9 @@ CDlgScanner::~CDlgScanner()
void CDlgScanner::DoDataExchange(CDataExchange* pDX)
{
CDialogEx::DoDataExchange(pDX);
// DDX_Control(pDX, IDC_TAB_OPT, tab_opt_);
// DDX_Control(pDX, IDC_TAB_OPT, tab_opt_);
DDX_Control(pDX, IDC_TAB_OPER, tab_oper_);
DDX_Control(pDX, IDC_COMBO_BUF_SIZE, buf_);
}
typedef struct _prog_data
@ -899,6 +900,8 @@ void CDlgScanner::set_device(usb::LPUSBPNP pnp)
};
max_cmd_ = max_sent_ = 0;
buf_.SetCurSel(0);
buf_.EnableWindow(pnp != NULL);
if (pnp)
{
int err = 0;
@ -912,6 +915,7 @@ void CDlgScanner::set_device(usb::LPUSBPNP pnp)
scanner_ = NULL;
msg_box(m_hWnd, MB_OK, L"Error", L"Open %04X:%04X failed with error %d.", pnp->vid, pnp->pid, err);
enable_buttons(false);
buf_.EnableWindow(FALSE);
OnDeviceStatus(0, (LPARAM)SCANNER_STATUS_NOT_OPEN);
}
else
@ -935,6 +939,7 @@ void CDlgScanner::set_device(usb::LPUSBPNP pnp)
scanner_ = NULL;
}
enable_buttons(false);
buf_.EnableWindow(FALSE);
OnDeviceStatus(0, (LPARAM)SCANNER_STATUS_NOT_OPEN);
}
else
@ -1182,6 +1187,7 @@ BEGIN_MESSAGE_MAP(CDlgScanner, CDialogEx)
ON_MESSAGE(WM_SET_BUTTON_CHECK, &CDlgScanner::OnSetButtonChecked)
ON_MESSAGE(WM_ENABLE_CTRLS, &CDlgScanner::OnEnableCtrls)
ON_MESSAGE(WM_DEVICE_STATTUS, &CDlgScanner::OnDeviceStatus)
ON_CBN_SELCHANGE(IDC_COMBO_BUF_SIZE, &CDlgScanner::OnCbnSelchangeComboBufSize)
END_MESSAGE_MAP()
@ -1241,6 +1247,7 @@ BOOL CDlgScanner::OnInitDialog()
if(img_root_[img_root_.length() - 1] != L'\\')
img_root_ += L"\\";
::SetDlgItemTextW(m_hWnd, IDC_EDIT_IMG_PATH, img_root_.c_str());
buf_.SetCurSel(0);
return FALSE; // 除非将焦点设置到控件，否则返回 TRUE
}
@ -1517,3 +1524,24 @@ LRESULT CDlgScanner::OnDeviceStatus(WPARAM wp, LPARAM lp)
return 0;
}
void CDlgScanner::OnCbnSelchangeComboBufSize()
{
// TODO: 在此添加控件通知处理程序代码
int sel = buf_.GetCurSel();
sel = 1 << sel;
if (scanner_->set_io_buffer_size(sel))
{
int cur = 0;
sel = scanner_->get_io_buffer_size() >> 1;
while (sel)
{
cur++;
sel >>= 1;
}
buf_.SetCurSel(cur);
}
}

2
pc/code_twain/sln/usb_tools/DlgScanner.h
View File

@ -117,4 +117,6 @@ public:
afx_msg LRESULT OnSetButtonChecked(WPARAM wp, LPARAM lp);
afx_msg LRESULT OnEnableCtrls(WPARAM wp, LPARAM lp);
afx_msg LRESULT OnDeviceStatus(WPARAM wp, LPARAM lp);
afx_msg void OnCbnSelchangeComboBufSize();
CComboBox buf_;
};

7
pc/code_twain/sln/usb_tools/resource.h
View File

@ -72,7 +72,6 @@
#define IDC_STATIC_CMD 1043
#define IDC_STATIC_PARAM 1044
#define IDC_STATIC_COUNT 1045
#define IDC_EDIT_PROTOCOL_VER2 1046
#define IDC_EDIT_STATUS 1046
#define IDC_EDIT_CMD_QUE 1047
#define IDC_EDIT_SENT_QUE 1048
@ -92,15 +91,17 @@
#define IDC_STATIC_OPTS 1063
#define IDC_CHECK_AUTO_OPEN_IMG 1064
#define IDC_EDIT_LOG_FILE 1065
#define IDC_COMBO1 1066
#define IDC_COMBO_BUF_SIZE 1066
#define ID_TRAY_EXIT 32771
// Next default values for new objects
//
#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_NEXT_RESOURCE_VALUE 137
#define _APS_NEXT_RESOURCE_VALUE 138
#define _APS_NEXT_COMMAND_VALUE 32772
#define _APS_NEXT_CONTROL_VALUE 1066
#define _APS_NEXT_CONTROL_VALUE 1067
#define _APS_NEXT_SYMED_VALUE 101
#endif
#endif

216
pc/code_twain/sln/usb_tools/scanner/opt_ui/DlgGamma.cpp
View File

@ -703,121 +703,121 @@ void dlg_gamma::on_combo_sel_changed(int id, int sel)
void dlg_gamma::get_gamma(SANE_Gamma* gamma)
{
gamma->apply_to_back = SANE_FALSE;
//if (cur_ == &rgb_gray_)
{
cur_ = &rgb_gray_;
gamma->pt_count = (SANE_Byte)(cur_->points.size() - 2);
// gamma->pt_count_r = gamma->pt_count_g = gamma->pt_count_b = 0;
for (int i = 2; i < (int)cur_->points.size(); ++i)
{
gamma->keypoint[i - 2].x = (SANE_Byte)cur_->points[i].x;
gamma->keypoint[i - 2].y = (SANE_Byte)cur_->points[i].y;
}
//gamma->apply_to_back = SANE_FALSE;
////if (cur_ == &rgb_gray_)
//{
// cur_ = &rgb_gray_;
// gamma->pt_count = (SANE_Byte)(cur_->points.size() - 2);
//// gamma->pt_count_r = gamma->pt_count_g = gamma->pt_count_b = 0;
// for (int i = 2; i < (int)cur_->points.size(); ++i)
// {
// gamma->keypoint[i - 2].x = (SANE_Byte)cur_->points[i].x;
// gamma->keypoint[i - 2].y = (SANE_Byte)cur_->points[i].y;
// }
for (int i = 0; i < 256; ++i)
gamma->table[i] = calc_value(i);
}
//else
{
// gamma->pt_count = 0;
// for (int i = 0; i < 256; ++i)
// gamma->table[i] = calc_value(i);
//}
////else
//{
//// gamma->pt_count = 0;
cur_ = &red_;
gamma->pt_count_r = (SANE_Byte)(cur_->points.size() - 2);
for (int i = 2; i < (int)cur_->points.size(); ++i)
{
gamma->keypoint_r[i - 2].x = (SANE_Byte)cur_->points[i].x;
gamma->keypoint_r[i - 2].y = (SANE_Byte)cur_->points[i].y;
}
for (int i = 0; i < 256; ++i)
gamma->table[i] = calc_value(i);
// cur_ = &red_;
// gamma->pt_count_r = (SANE_Byte)(cur_->points.size() - 2);
// for (int i = 2; i < (int)cur_->points.size(); ++i)
// {
// gamma->keypoint_r[i - 2].x = (SANE_Byte)cur_->points[i].x;
// gamma->keypoint_r[i - 2].y = (SANE_Byte)cur_->points[i].y;
// }
// for (int i = 0; i < 256; ++i)
// gamma->table[i] = calc_value(i);
cur_ = &green_;
gamma->pt_count_g = (SANE_Byte)(cur_->points.size() - 2);
for (int i = 2; i < (int)cur_->points.size(); ++i)
{
gamma->keypoint_g[i - 2].x = (SANE_Byte)cur_->points[i].x;
gamma->keypoint_g[i - 2].y = (SANE_Byte)cur_->points[i].y;
}
for (int i = 0; i < 256; ++i)
gamma->table[256 + i] = calc_value(i);
// cur_ = &green_;
// gamma->pt_count_g = (SANE_Byte)(cur_->points.size() - 2);
// for (int i = 2; i < (int)cur_->points.size(); ++i)
// {
// gamma->keypoint_g[i - 2].x = (SANE_Byte)cur_->points[i].x;
// gamma->keypoint_g[i - 2].y = (SANE_Byte)cur_->points[i].y;
// }
// for (int i = 0; i < 256; ++i)
// gamma->table[256 + i] = calc_value(i);
cur_ = &blue_;
gamma->pt_count_b = (SANE_Byte)(cur_->points.size() - 2);
for (int i = 2; i < (int)cur_->points.size(); ++i)
{
gamma->keypoint_b[i - 2].x = (SANE_Byte)cur_->points[i].x;
gamma->keypoint_b[i - 2].y = (SANE_Byte)cur_->points[i].y;
}
for (int i = 0; i < 256; ++i)
gamma->table[512 + i] = calc_value(i);
}
// cur_ = &blue_;
// gamma->pt_count_b = (SANE_Byte)(cur_->points.size() - 2);
// for (int i = 2; i < (int)cur_->points.size(); ++i)
// {
// gamma->keypoint_b[i - 2].x = (SANE_Byte)cur_->points[i].x;
// gamma->keypoint_b[i - 2].y = (SANE_Byte)cur_->points[i].y;
// }
// for (int i = 0; i < 256; ++i)
// gamma->table[512 + i] = calc_value(i);
//}
}
void dlg_gamma::set_gamma(const SANE_Gamma* gamma, bool gray)
{
int sel = 0;
std::wstring text(L"");
SendMessage(get_item(IDC_CHANNEL), CB_RESETCONTENT, 0, 0);
is_color_ = !gray;
cur_ = &rgb_gray_;
init_curve(cur_);
for (int i = 0; i < gamma->pt_count; ++i)
{
POINT pt = { gamma->keypoint[i].x, gamma->keypoint[i].y };
cur_->points.push_back(pt);
}
cur_->coefs = calc::coefs_from_points(cur_->points);
if (is_color_)
{
SendMessageW(get_item(IDC_CHANNEL), CB_ADDSTRING, 0, (LPARAM)L"RGB");
}
else
{
text = local_trans::lang_trans_between_hz936(CONST_STRING_GRAY);
SendMessageW(get_item(IDC_CHANNEL), CB_ADDSTRING, 0, (LPARAM)&text[0]);
}
if(!gray)
{
is_color_ = true;
cur_ = &red_;
init_curve(cur_);
for (int i = 0; i < gamma->pt_count_r; ++i)
{
POINT pt = { gamma->keypoint_r[i].x, gamma->keypoint_r[i].y };
cur_->points.push_back(pt);
}
cur_->coefs = calc::coefs_from_points(cur_->points);
cur_ = &green_;
init_curve(cur_);
for (int i = 0; i < gamma->pt_count_g; ++i)
{
POINT pt = { gamma->keypoint_g[i].x, gamma->keypoint_g[i].y };
cur_->points.push_back(pt);
}
cur_->coefs = calc::coefs_from_points(cur_->points);
cur_ = &blue_;
init_curve(cur_);
for (int i = 0; i < gamma->pt_count_b; ++i)
{
POINT pt = { gamma->keypoint_b[i].x, gamma->keypoint_b[i].y };
cur_->points.push_back(pt);
}
cur_->coefs = calc::coefs_from_points(cur_->points);
//int sel = 0;
//std::wstring text(L"");
//SendMessage(get_item(IDC_CHANNEL), CB_RESETCONTENT, 0, 0);
//is_color_ = !gray;
//cur_ = &rgb_gray_;
//init_curve(cur_);
//for (int i = 0; i < gamma->pt_count; ++i)
//{
// POINT pt = { gamma->keypoint[i].x, gamma->keypoint[i].y };
// cur_->points.push_back(pt);
//}
//cur_->coefs = calc::coefs_from_points(cur_->points);
//if (is_color_)
//{
// SendMessageW(get_item(IDC_CHANNEL), CB_ADDSTRING, 0, (LPARAM)L"RGB");
text = local_trans::lang_trans_between_hz936(CONST_STRING_RED);
SendMessageW(get_item(IDC_CHANNEL), CB_ADDSTRING, 0, (LPARAM)&text[0]);
text = local_trans::lang_trans_between_hz936(CONST_STRING_GREEN);
SendMessageW(get_item(IDC_CHANNEL), CB_ADDSTRING, 0, (LPARAM)&text[0]);
text = local_trans::lang_trans_between_hz936(CONST_STRING_BLUE);
SendMessageW(get_item(IDC_CHANNEL), CB_ADDSTRING, 0, (LPARAM)&text[0]);
}
cur_ = &rgb_gray_;
sel = 0;
SendMessage(get_item(IDC_CHANNEL), CB_SETCURSEL, sel, 0);
SendMessage(get_item(IDC_SCHEME), CB_SETCURSEL, 0, 0);
//}
//else
//{
// text = local_trans::lang_trans_between_hz936(CONST_STRING_GRAY);
// SendMessageW(get_item(IDC_CHANNEL), CB_ADDSTRING, 0, (LPARAM)&text[0]);
//}
//if(!gray)
//{
// is_color_ = true;
// cur_ = &red_;
// init_curve(cur_);
// for (int i = 0; i < gamma->pt_count_r; ++i)
// {
// POINT pt = { gamma->keypoint_r[i].x, gamma->keypoint_r[i].y };
// cur_->points.push_back(pt);
// }
// cur_->coefs = calc::coefs_from_points(cur_->points);
// cur_ = &green_;
// init_curve(cur_);
// for (int i = 0; i < gamma->pt_count_g; ++i)
// {
// POINT pt = { gamma->keypoint_g[i].x, gamma->keypoint_g[i].y };
// cur_->points.push_back(pt);
// }
// cur_->coefs = calc::coefs_from_points(cur_->points);
// cur_ = &blue_;
// init_curve(cur_);
// for (int i = 0; i < gamma->pt_count_b; ++i)
// {
// POINT pt = { gamma->keypoint_b[i].x, gamma->keypoint_b[i].y };
// cur_->points.push_back(pt);
// }
// cur_->coefs = calc::coefs_from_points(cur_->points);
//// SendMessageW(get_item(IDC_CHANNEL), CB_ADDSTRING, 0, (LPARAM)L"RGB");
// text = local_trans::lang_trans_between_hz936(CONST_STRING_RED);
// SendMessageW(get_item(IDC_CHANNEL), CB_ADDSTRING, 0, (LPARAM)&text[0]);
// text = local_trans::lang_trans_between_hz936(CONST_STRING_GREEN);
// SendMessageW(get_item(IDC_CHANNEL), CB_ADDSTRING, 0, (LPARAM)&text[0]);
// text = local_trans::lang_trans_between_hz936(CONST_STRING_BLUE);
// SendMessageW(get_item(IDC_CHANNEL), CB_ADDSTRING, 0, (LPARAM)&text[0]);
//}
//cur_ = &rgb_gray_;
//sel = 0;
//SendMessage(get_item(IDC_CHANNEL), CB_SETCURSEL, sel, 0);
//SendMessage(get_item(IDC_SCHEME), CB_SETCURSEL, 0, 0);
}

13
pc/code_twain/sln/usb_tools/scanner/scanner_handler.cpp
View File

@ -444,7 +444,20 @@ int scanner_handler::restart_peer_bulk(uint32_t timeout)
return usb_->restart_peer_bulk(timeout);
}
int scanner_handler::set_io_buffer_size(unsigned short size)
{
if (!is_scanner_available())
return ENODEV;
return usb_->reset_io_buffer_size(size);
}
int scanner_handler::get_io_buffer_size(void)
{
if (!is_scanner_available())
return 1;
return usb_->get_io_buffer_size();
}
int scanner_handler::option_get_all(std::string& json_opts)
{

2
pc/code_twain/sln/usb_tools/scanner/scanner_handler.h
View File

@ -107,6 +107,8 @@ public:
int get_protocol_version(uint16_t* ver);
int get_scanner_status(LPEP0REPLYSTATUS status);
int restart_peer_bulk(uint32_t timeout = 1000/*ms*/);
int set_io_buffer_size(unsigned short size);
int get_io_buffer_size(void);
// following methods transferred by Bulk, blocked ...
int option_get_all(std::string& json_opts);

32
pc/code_twain/sln/usb_tools/scanner/usb/async_usb_host.cpp
View File

@ -10,7 +10,7 @@
// async_usb_host
async_usb_host::async_usb_host(std::function<FUNCTION_PROTO_COMMAND_HANDLE> cmd_handler)
: handler_(cmd_handler), usb_dev_(nullptr), usb_handle_(nullptr), run_(true), cancel_write_(false), writing_(false)
, head_enc_type_(ENCRYPT_CMD_NONE), payload_enc_type_(ENCRYPT_NONE), enc_data_(0)
, head_enc_type_(ENCRYPT_CMD_NONE), payload_enc_type_(ENCRYPT_NONE), enc_data_(0), buf_coef_(1)
{
memset(&bulk_in_, -1, sizeof(bulk_in_));
memset(&bulk_out_, -1, sizeof(bulk_out_));
@ -195,13 +195,14 @@ uint8_t& async_usb_host::encrypt_data(void)
void async_usb_host::thread_read_bulk(void)
{
dyn_mem_ptr mem = dyn_mem::memory(bulk_in_.max_packet);
size_t buf_size = buf_coef_ * bulk_in_.max_packet;
dyn_mem_ptr mem = dyn_mem::memory(buf_size);
log_cls::log(LOG_LEVEL_ALL, "thread_read_bulk working ...\r\n");
while (run_)
{
int r = 0,
err = libusb_bulk_transfer(usb_handle_, bulk_in_.port, mem->ptr(), bulk_in_.max_packet, &r, -1);
err = libusb_bulk_transfer(usb_handle_, bulk_in_.port, mem->ptr(), buf_size, &r, -1);
if (err)
{
@ -219,7 +220,8 @@ void async_usb_host::thread_read_bulk(void)
mem->set_len(r);
in_que_.save(mem, true);
mem = dyn_mem::memory(bulk_in_.max_packet);
buf_size = buf_coef_ * bulk_in_.max_packet;
mem = dyn_mem::memory(buf_size);
}
if (mem)
@ -358,7 +360,7 @@ void async_usb_host::thread_pump_task(void)
int async_usb_host::bulk_write_buf(uint8_t* buf, int* len)
{
int bulk_size = bulk_out_.max_packet,
int bulk_size = bulk_out_.max_packet * buf_coef_,
total = 0,
l = bulk_size <= *len ? bulk_size : *len,
s = 0,
@ -392,7 +394,7 @@ int async_usb_host::bulk_write_buf(uint8_t* buf, int* len)
int async_usb_host::inner_write_bulk(data_source_ptr data, int* err)
{
unsigned char* ptr = data->ptr();
size_t bulk_size = bulk_out_.max_packet,
size_t bulk_size = bulk_out_.max_packet * buf_coef_,
total = data->get_rest();
int e = 0, s = 0;
@ -526,6 +528,24 @@ int async_usb_host::restart_peer_bulk(uint32_t timeout)
return err ? err : ok;
}
int async_usb_host::reset_io_buffer_size(unsigned short size)
{
libusb_control_transfer(usb_handle_, LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_ENDPOINT_OUT
, USB_REQ_EP0_SET_BULK_BUFFER, 0, size
, nullptr, 0
, 1000);
{
buf_coef_ = size;
return 0;
}
return EFAULT;
}
int async_usb_host::get_io_buffer_size(void)
{
return buf_coef_;
}
int async_usb_host::set_gadget_encrypting_method(uint32_t cmd_enc, uint32_t payload_enc, uint8_t enc_data)
{
dyn_mem_ptr ptr(dyn_mem::memory(sizeof(PACK_BASE)));

3
pc/code_twain/sln/usb_tools/scanner/usb/async_usb_host.h
View File

@ -38,6 +38,7 @@ class async_usb_host : public refer
volatile bool run_;
volatile bool writing_;
volatile bool cancel_write_;
volatile int buf_coef_;
libusb_device_handle* usb_handle_;
libusb_device* usb_dev_;
USBEP bulk_in_;
@ -80,6 +81,8 @@ public:
int get_peer_protocol_version(uint16_t* ver);
int get_peer_status(LPEP0REPLYSTATUS status);
int restart_peer_bulk(uint32_t timeout = 1000/*ms*/);
int reset_io_buffer_size(unsigned short size);
int get_io_buffer_size(void);
int set_gadget_encrypting_method(uint32_t cmd_enc = ENCRYPT_CMD_NONE, uint32_t payload_enc = ENCRYPT_NONE, uint8_t enc_data = 0);
int send_heart_beat(uint32_t pack_id);

2
pc/code_twain/sln/usb_tools/usb_tools.vcxproj
View File

@ -77,7 +77,7 @@
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<LinkIncremental>true</LinkIncremental>
<IncludePath>$(ProjectDir)..\..\..\sdk\include\;$(ProjectDir)..\..\device\win_usb\;$(ProjectDir)..\sdk\include\;$(ProjectDir)..\..\..\..\device\gxx-linux\usb\src\async_model\;$(IncludePath)</IncludePath>
<LibraryPath>$(SolutionDir)sdk\lib\$(Configuration);$(ProjectDir)..\..\..\sdk\lib\win\$(PlatformTarget)\oem\huagao;$(LibraryPath)</LibraryPath>
<LibraryPath>$(SolutionDir)sdk\lib\;$(ProjectDir)..\..\..\sdk\lib\win\$(PlatformTarget)\oem\huagao;$(LibraryPath)</LibraryPath>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<LinkIncremental>true</LinkIncremental>

BIN
pc/code_twain/sln/usb_tools/usbtools.rc
View File

Binary file not shown.

26
pc/sdk/include/huagao/hgscanner_error.h
View File

@ -72,6 +72,8 @@ enum scanner_err
SCANNER_ERR_DEVICE_AUTO_FAIL_INFO, // 设备平场自动校正信息传输
SCANNER_ERR_DEVICE_DISTORTION, // 畸变修正失败
SCANNER_ERR_DEVICE_MAYBE_IS_HOLE, // 纸张有孔洞
SCANNER_ERR_DEVICE_DEVS_BOOTING, // 请稍等 - 设备正在准备
SCANNER_ERR_DEVICE_UNKNOWN_STATUS, // 设备处于未知状态
};
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -347,6 +349,30 @@ enum scanner_err
//#define STATU_DESC_SCANNER_ERR_DEVICE_EXIT_WAIT_SCAN "退出待纸扫描"
#define STATU_DESC_SCANNER_ERR_DEVICE_EXIT_WAIT_SCAN "\351\200\200\345\207\272\345\276\205\347\272\270\346\211\253\346\217\217"
//#define STATU_DESC_SCANNER_ERR_DEVICE_GET_IMAGE_ERR "获取图像异常"
#define STATU_DESC_SCANNER_ERR_DEVICE_GET_IMAGE_ERR "\350\216\267\345\217\226\345\233\276\345\203\217\345\274\202\345\270\270"
//#define STATU_DESC_SCANNER_ERR_DEVICE_DEVS_BOOTING "请稍等-设备正在准备中"
#define STATU_DESC_SCANNER_ERR_DEVICE_DEVS_BOOTING "\350\257\267\347\250\215\347\255\211-\350\256\276\345\244\207\346\255\243\345\234\250\345\207\206\345\244\207\344\270\255"
//#define STATU_DESC_SCANNER_ERR_DEVICE_DEVS_BOOTING "设备启动成功-可以开始扫描"
#define STATU_DESC_SCANNER_ERR_DEVICE_DEVS_START_SUCCES "\350\256\276\345\244\207\345\220\257\345\212\250\346\210\220\345\212\237-\345\217\257\344\273\245\345\274\200\345\247\213\346\211\253\346\217\217"
//#define STATU_DESC_SCANNER_ERR_LANG_PAK_LOST 语言包缺失词条
#define STATU_DESC_SCANNER_ERR_LANG_PAK_LOST "\350\257\255\350\250\200\345\214\205\347\274\272\345\244\261\350\257\215\346\235\241"
//#define STATU_DESC_SCANNER_ERR_DEVICE_UPGRADE_SUCCESSFUL 设备升级成功
#define STATU_DESC_SCANNER_ERR_DEVICE_UPGRADE_SUCCESSFUL "\350\256\276\345\244\207\345\215\207\347\272\247\346\210\220\345\212\237"
//#define STATU_DESC_SCANNER_ERR_DEVICE_UPGRADE_FAIL 设备升级失败
#define STATU_DESC_SCANNER_ERR_DEVICE_UPGRADE_FAIL "\350\256\276\345\244\207\345\215\207\347\272\247\345\244\261\350\264\245"
//#define STATU_DESC_SCANNER_ERR_DEVICE_AUTO_FAIL_INFO 自动平场校正信息
#define STATU_DESC_SCANNER_ERR_DEVICE_AUTO_FAIL_INFO "\350\207\252\345\212\250\345\271\263\345\234\272\346\240\241\346\255\243\344\277\241\346\201\257"
//#define STATU_DESC_SCANNER_ERR_DEVICE_UNKNOWN_STATUS 设备处于未知状态
#define STATU_DESC_SCANNER_ERR_DEVICE_UNKNOWN_STATUS "\350\256\276\345\244\207\345\244\204\344\272\216\346\234\252\347\237\245\347\212\266\346\200\201"
// 状态信息描述符 - OVER
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

308
pc/sdk/include/sane/sane_ex.h
View File

@ -17,6 +17,90 @@
#ifndef sane_ex_h
#define sane_ex_h
#if !defined(WIN32) && !defined(_WIN64) // migrate codes from windows to linux ...
#include <unistd.h>
#include <sys/types.h>
#include <dlfcn.h>
#pragma pack(push)
#pragma pack(1)
typedef struct BITMAPFILEHEADER
{
u_int16_t bfType;
u_int32_t bfSize;
u_int16_t bfReserved1;
u_int16_t bfReserved2;
u_int32_t bfOffBits;
}BITMAPFILEHEADER;
typedef struct BITMAPINFOHEADER
{
u_int32_t biSize;
u_int32_t biWidth;
u_int32_t biHeight;
u_int16_t biPlanes;
u_int16_t biBitCount;
u_int32_t biCompression;
u_int32_t biSizeImage;
u_int32_t biXPelsPerMeter;
u_int32_t biYPelsPerMeter;
u_int32_t biClrUsed;
u_int32_t biClrImportant;
}BITMAPINFODEADER;
#pragma pack(pop)
#define BI_RGB 0
#define MAKEWORD(a, b) (((a) & 0x0ff) | (((b) & 0x0ff) << 8))
#define MAKELONG(a, b) (((a) & 0x0ffff) | (((b) & 0x0ffff) << 16))
#define _countof(a) (sizeof(a) / sizeof((a)[0]))
typedef long LONG;
typedef void* HANDLE;
typedef void* HWND;
typedef void* HMODULE;
typedef void* LPVOID;
typedef void* FARPROC;
typedef unsigned int DWORD;
typedef unsigned short WORD;
typedef unsigned short UINT16;
typedef unsigned char BYTE;
typedef int BOOL;
typedef unsigned int SCANNERID;
#define TRUE 1
#define FALSE 0
#define MAX_PATH 256
#define huge
#define FAR
#define NEAR
#define LOWORD(v) ((v) & 0x0ffff)
#define HIWORD(v) (((v) >> 16) & 0x0ffff)
#define PASCAL __attribute__((stdcall))
#define LOAD_WITH_ALTERED_SEARCH_PATH RTLD_NOW
#define LoadLibraryExA(file, reserve, flag) dlopen(file, flag)
#define FreeLibrary dlclose
#define GetProcAddress dlsym
#define GetPrivateProfileIntW GetPrivateProfileIntA
#define lstrlenA strlen
#define lstrlenW strlen
#define DLL_EXT_NAME "so"
#define STRICMP strcasecmp
extern DWORD GetLastError(void);
extern DWORD GetPrivateProfileIntA(const char* app, const char* key, DWORD def, const char* file);
extern void Sleep(DWORD milliseconds);
extern int GetModuleFileNameA(void*, char* buf, size_t len);
extern int GetCurrentProcessId(void);
#else
#define DLL_EXT_NAME "dll"
#define STRICMP stricmp
#endif
#ifndef EXPORT_SANE_API
#ifdef OEM_HANWANG
#define ENTIRE_API(pre, tail) pre##_hwsane_##tail
@ -28,6 +112,10 @@
#define ENTIRE_API(pre, tail) pre##_zjsane_##tail
#elif defined(OEM_ZIGUANG)
#define ENTIRE_API(pre, tail) pre##_zgsane_##tail
#elif defined(OEM_DELI)
#define ENTIRE_API(pre, tail) pre##_dlsane_##tail
#elif defined(OEM_NEUTRAL)
#define ENTIRE_API(pre, tail) pre##_neusane_##tail
#else
#define ENTIRE_API(pre, tail) pre##_hgsane_##tail
#endif
@ -52,9 +140,15 @@
#define sane_get_option_descriptor_ex ENTIRE_API(get_option_descriptor_ex)
#define sane_control_option_ex ENTIRE_API(control_option_ex)
#define sane_read_ext_info ENTIRE_API(sane, read_ext_info)
int sane_ex_get_driver_version(int* hh, int* hl, int* lh, int* ll);
#endif
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#define SANE_OPT_NAME(name) SANE_STD_OPT_NAME_##name
#define SANE_OPT_FIXED_ID(id) SANE_OPT_ID_##id
#define MAX_OPT_NAME_LEN 64
// sane-standard-option-name defined by third-app
//
// PART I: 参数类型与华高一致，可直接通过改name字段为标准值实现
@ -93,6 +187,12 @@
#define SANE_STD_OPT_NAME_ANTI_SKEW "is-anti-skew" // OPTION_TITLE_ZDJP
#define SANE_STD_OPT_NAME_IS_CUSTOM_GAMMA "is-custom-gamma" // OPTION_TITLE_QYSDQX
#define SANE_STD_OPT_NAME_GAMMA "gamma" // OPTION_TITLE_JMZ
#define SANE_STD_OPT_NAME_CUSTOM_GAMMA "custom-gamma" // OPTION_TITLE_CUSTOM_JMZ; data - SANE_Gamma*
#define SANE_STD_OPT_NAME_GRAY_GAMMA "gray-gamma-table"
#define SANE_STD_OPT_NAME_COLOR_GAMMA "color-gamma-table"
#define SANE_STD_OPT_NAME_RED_GAMMA "red-gamma-table"
#define SANE_STD_OPT_NAME_GREEN_GAMMA "green-gamma-table"
#define SANE_STD_OPT_NAME_BLUE_GAMMA "blue-gamma-table"
#define SANE_STD_OPT_NAME_BRIGHTNESS "brightness" // OPTION_TITLE_LDZ
#define SANE_STD_OPT_NAME_CONTRAST "contrast" // OPTION_TITLE_DBD
#define SANE_STD_OPT_NAME_IS_PHOTO_MODE "is-photo-mode" // OPTION_TITLE_ZPMS
@ -133,15 +233,16 @@
#define SANE_STD_OPT_NAME_FOLD_TYPE "fold-type" // OPTION_TITLE_DZMS
#define SANE_STD_OPT_NAME_COLOR_CORRECTION "color-correction" // OPTION_TITLE_SPJZ
#define SANE_STD_OPT_NAME_WAIT_SCAN_EXIT "wait-scan-exit" // OPTION_TITLE_DZSMTCSJ
#define SANE_STD_OPT_NAME_DISCARDBLANK "discardblank" // OPTION_TITLE_TGKBY
//#define SANE_STD_OPT_NAME_COMPANY "company" // 公司名称
//#define SANE_STD_OPT_NAME_COMPANY_URL "co-url" // 公司网址
//#define SANE_STD_OPT_NAME_COMPANY_GPS "co-gps" // 公司导航地址
//#define SANE_STD_OPT_NAME_COMPANY_TELEPHONE "co-tel" // 公司电话
//#define SANE_STD_OPT_NAME_COMPANY_ADDRESS "co-addr" // 公司地址
#define SANE_STD_OPT_NAME_DEVICE_NAME "dev-name" // 设备名称
#define SANE_STD_OPT_NAME_DEVICE_VID "dev-vid" // 设备VID
#define SANE_STD_OPT_NAME_DEVICE_PID "dev-pid" // 设备PID
#define SANE_STD_OPT_NAME_DEVICE_MODEL "dev-model" // 设备系列
#define SANE_STD_OPT_NAME_DEV_NAME SANE_STD_OPT_NAME_DEVICE_NAME
#define SANE_STD_OPT_NAME_VID SANE_STD_OPT_NAME_DEVICE_VID
#define SANE_STD_OPT_NAME_PID SANE_STD_OPT_NAME_DEVICE_PID
#define SANE_STD_OPT_NAME_DEV_FAMILY SANE_STD_OPT_NAME_DEVICE_MODEL
#define SANE_STD_OPT_NAME_DEVICE_TYPE "dev-type" // 设备型号
#define SANE_STD_OPT_NAME_DEVICE_SERIAL_NO "dev-sn" // 设备序列号
#define SANE_STD_OPT_NAME_FIRMWARE_VERSION "fmw-ver" // 固件版本
@ -149,26 +250,172 @@
#define SANE_STD_OPT_NAME_DEVICE_MAC_ADDR "mac-addr" // 设备MAC地址
#define SANE_STD_OPT_NAME_ROLLER_COUNT "roll-cnt" // 滚轴张数
#define SANE_STD_OPT_NAME_TOTAL_COUNT "total-cnt" // 历史总张数
#define SANE_STD_OPT_NAME_GET_DEVS_L0G "get_devs_log" // 获取设备日志
#define SANE_STD_OPT_NAME_HISTORY_COUNT SANE_STD_OPT_NAME_TOTAL_COUNT
#define SANE_STD_OPT_NAME_GET_DEVS_L0G "devs-log" // 获取设备日志
#define SANE_STD_OPT_NAME_DRIVER_VERSION "drv-ver" // 设备VID
#define SANE_STD_OPT_NAME_MANUFACTURER "company" // 公司名称
#define SANE_STD_OPT_NAME_COPYRIGHT "copyright" // 版权
#define SANE_STD_OPT_NAME_CO_URL "co-url" // 公司网址
#define SANE_STD_OPT_NAME_CO_TEL "co-tel" // 公司电话
#define SANE_STD_OPT_NAME_CO_ADDR "co-addr" // 公司地址
#define SANE_STD_OPT_NAME_CO_GPS "co-gps" // 公司地图定位
#define SANE_STD_OPT_NAME_LOGIN "login" // 登录
#define SANE_STD_OPT_NAME_LOGOUT "logout" // 登出
#define SANE_STD_OPT_NAME_DRIVER_LOG "drv-log" // 驱动日志
#define SANE_STD_OPT_NAME_DEVICE_LOG SANE_STD_OPT_NAME_GET_DEVS_L0G
#define SANE_STD_OPT_NAME_ROLLER_LIFE "roller-life" // 滚轴最大寿命（过纸张数）
#define SANE_STD_OPT_NAME_LANGUAGE "language" // 语言
#define SANE_STD_OPT_NAME_MOTOR_VER "motor-ver" // 电机固件版本, data = char*
#define SANE_STD_OPT_NAME_TRANSFORM_IMAGE_FORMAT "trans-img-fmt" // 图像格式转换, data - SANE_ImageFormatConvert*, dst.data 调用SANE_STD_OPT_NAME_FREE_BUFFER释放
#define SANE_STD_OPT_NAME_FREE_BUFFER "free-buf" // 释放由驱动返回的内存, data - (void**)&buf
#define SANE_STD_OPT_NAME_PAPER_ON "paper-on" // check whether paper is on
#define SANE_STD_OPT_NAME_INITIAL_BOOT_TIME "initial-boot-time" // 设备的初始开机时间
// PART II: 参数类型与华高不一致，需要通过“hgsane”组件在中间转换
#define SANE_STD_OPT_NAME_PAPER_W "page-width" // OPTION_TITLE_ZZCC
#define SANE_STD_OPT_NAME_PAPER_H "page-height" // OPTION_TITLE_ZZCC
#define SANE_STD_OPT_NAME_DUPLEX "duplex" // OPTION_TITLE_SMYM
// END for sane-standard-option-name defined by third-app
//
//
//
// 借鉴TWAIN协议固定ID的做法，定义SANE属性的固定ID - 这里与TWAIN中的ID保持一致，以方便TWAIN的调用
enum sane_option_id
{
SANE_OPT_ID_BASE = 0x8800,
SANE_OPT_ID_IS_MULTI_OUT = 0x8801,
SANE_OPT_ID_MULTI_OUT_TYPE = 0x8802,
SANE_OPT_ID_COLOR_MODE = 0x8803,
SANE_OPT_ID_FILTER = 0x8804,
SANE_OPT_ID_RID_MULTIOUT_RED = 0x8805,
SANE_OPT_ID_RID_ANSWER_SHEET_RED = 0x8806,
SANE_OPT_ID_ERASE_BACKGROUND = 0x8807,
SANE_OPT_ID_BKG_COLOR_RANGE = 0x8808,
SANE_OPT_ID_SHARPEN = 0x8809,
SANE_OPT_ID_RID_MORR = 0x880A,
SANE_OPT_ID_RID_GRID = 0x880B,
SANE_OPT_ID_ERROR_EXTENSION = 0x880C,
SANE_OPT_ID_NOISE_OPTIMIZE = 0x880D,
SANE_OPT_ID_NOISE_SIZE = 0x880E,
SANE_OPT_ID_PAPER = 0x880F,
SANE_OPT_ID_CUSTOM_AREA = 0x8810,
SANE_OPT_ID_CUSTOM_AREA_LEFT = 0x8811,
SANE_OPT_ID_CUSTOM_AREA_RIGHT = 0x8812,
SANE_OPT_ID_CUSTOM_AREA_TOP = 0x8813,
SANE_OPT_ID_CUSTOM_AREA_BOTTOM = 0x8814,
SANE_OPT_ID_SIZE_CHECK = 0x8815,
SANE_OPT_ID_PAGE = 0x8816,
SANE_OPT_ID_DISCARD_BLANK_SENS = 0x8817,
SANE_OPT_ID_RESOLUTION = 0x8818,
SANE_OPT_ID_IMAGE_QUALITY = 0x8819,
SANE_OPT_ID_EXCHANGE = 0x881A,
SANE_OPT_ID_SPLIT = 0x881B,
SANE_OPT_ID_ANTI_SKEW = 0x881C,
SANE_OPT_ID_IS_CUSTOM_GAMMA = 0x881D,
SANE_OPT_ID_BRIGHTNESS = 0x881E,
SANE_OPT_ID_CONTRAST = 0x881F,
SANE_OPT_ID_GAMMA = 0x8820,
SANE_OPT_ID_ERASE_BLACK_FRAME = 0x8821,
SANE_OPT_ID_DARK_SAMPLE = 0x8822,
SANE_OPT_ID_THRESHOLD = 0x8823,
SANE_OPT_ID_ANTI_NOISE_LEVEL = 0x8824,
SANE_OPT_ID_MARGIN = 0x8825,
SANE_OPT_ID_FILL_BKG_MODE = 0x8826,
SANE_OPT_ID_IS_ANTI_PERMEATE = 0x8827,
SANE_OPT_ID_ANTI_PERMEATE_LEVEL = 0x8828,
SANE_OPT_ID_RID_HOLE = 0x8829,
SANE_OPT_ID_SEARCH_HOLE_RANGE = 0x882A,
SANE_OPT_ID_IS_FILL_COLOR = 0x882B,
SANE_OPT_ID_IS_ULTROSONIC_CHECK = 0x882C,
SANE_OPT_ID_IS_CHECK_STAPLE = 0x882D,
SANE_OPT_ID_SCAN_MODE = 0x882E,
SANE_OPT_ID_SCAN_COUNT = 0x882F,
SANE_OPT_ID_TEXT_DIRECTION = 0x8830,
SANE_OPT_ID_IS_ROTATE_BKG_180 = 0x8831,
SANE_OPT_ID_IS_CHECK_DOG_EAR = 0x8832,
SANE_OPT_ID_DOG_EAR_SIZE = 0x8833,
SANE_OPT_ID_IS_CHECK_ASKEW = 0x8834,
SANE_OPT_ID_ASKEW_RANGE = 0x8835,
SANE_OPT_ID_BINARY_THRESHOLD = 0x8836,
SANE_OPT_ID_IS_PHOTO_MODE = 0x8837,
SANE_OPT_ID_DOUBLE_FEED_HANDLE = 0x8838,
SANE_OPT_ID_WAIT_TO_SCAN = 0x8839,
SANE_OPT_ID_FEED_STRENGTH = 0x883A,
SANE_OPT_ID_TIME_TO_SLEEP = 0x883B,
SANE_OPT_ID_IS_AUTO_FEED_STRENGTH = 0x883C,
SANE_OPT_ID_FEED_STRENGTH_VALUE = 0x883D,
SANE_OPT_ID_REVERSE_01 = 0x883E,
SANE_OPT_ID_RID_HOLE_L = 0x883F,
SANE_OPT_ID_SEARCH_HOLE_RANGE_L = 0x8840,
SANE_OPT_ID_RID_HOLE_R = 0x8841,
SANE_OPT_ID_SEARCH_HOLE_RANGE_R = 0x8842,
SANE_OPT_ID_RID_HOLE_T = 0x8843,
SANE_OPT_ID_SEARCH_HOLE_RANGE_T = 0x8844,
SANE_OPT_ID_RID_HOLE_B = 0x8845,
SANE_OPT_ID_SEARCH_HOLE_RANGE_B = 0x8846,
SANE_OPT_ID_FOLD_TYPE = 0x8847,
SANE_OPT_ID_COLOR_CORRECTION = 0x8848,
SANE_OPT_ID_HISTORY_COUNT = 0x8849,
SANE_OPT_ID_DRIVER_VERSION = 0x884A,
SANE_OPT_ID_MANUFACTURER = 0x884B,
SANE_OPT_ID_COPYRIGHT = 0x884C,
SANE_OPT_ID_CO_URL = 0x884D,
SANE_OPT_ID_CO_TEL = 0x884E,
SANE_OPT_ID_CO_ADDR = 0x884F,
SANE_OPT_ID_CO_GPS = 0x8850,
SANE_OPT_ID_HELP = 0x8851,
SANE_OPT_ID_VID = 0x8852,
SANE_OPT_ID_PID = 0x8853,
SANE_OPT_ID_DEV_NAME = 0x8854,
SANE_OPT_ID_DEV_FAMILY = 0x8855,
SANE_OPT_ID_DEVICE_SERIAL_NO = 0x8856,
SANE_OPT_ID_FIRMWARE_VERSION = 0x8857,
SANE_OPT_ID_DEVICE_IP_ADDR = 0x8858,
SANE_OPT_ID_DEVICE_MAC_ADDR = 0x8859,
SANE_OPT_ID_CUSTOM_GAMMA = 0x885A, // data: SANE_Gamma*
SANE_OPT_ID_ROLLER_LIFE = 0x885B, // data: uint32_t*
SANE_OPT_ID_LANGUAGE = 0x885C, // data: char*
SANE_OPT_ID_MOTOR_VER = 0x885D, // 电机固件版本, data - char*
SANE_OPT_ID_TRANSFORM_IMAGE_FORMAT = 0x885E,// 图像格式转换, data - SANE_ImageFormatConvert*, dst.data 调用SANE_STD_OPT_NAME_FREE_BUFFER释放
SANE_OPT_ID_FREE_BUFFER = 0x885F, // 释放由驱动返回的内存, data - (void**)&buf
SANE_OPT_ID_PAPER_ON = 0x8860, // 是否有纸张, data - SANE_Bool*
SANE_OPT_ID_GRAY_GAMMA = 0x8861, // gray-gamma-table
SANE_OPT_ID_COLOR_GAMMA = 0x8862, // color-gamma-table
SANE_OPT_ID_RED_GAMMA = 0x8863, // red-gamma-table
SANE_OPT_ID_GREEN_GAMMA = 0x8864, // green-gamma-table
SANE_OPT_ID_BLUE_GAMMA = 0x8865, // blue-gamma-table
SANE_OPT_ID_INITIAL_BOOT_TIME = 0x8866,
SANE_OPT_ID_DISCARDBLANK = 0x8867,
SANE_OPT_ID_LOGIN = 0x9900,
SANE_OPT_ID_LOGOUT = 0x9901,
SANE_OPT_ID_ROLLER_COUNT = 0x9902,
SANE_OPT_ID_DRIVER_LOG = 0x9903,
SANE_OPT_ID_DEVICE_LOG = 0x9904,
};
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include "sane.h"
#define MAX_STRING_LEN 256
#define IS_DOUBLE_EQUAL(a, b) fabs((a) - (b)) < .000001
#define IS_PTR_NUMBER(ptr) (((unsigned long long)(ptr)) < 0x10000)
#define ALIGN_TO(v, align) (((v) + (align) - 1) / (align))
#define CAPABILITY_ORDINARY (SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT)
#define CAPABILITY_READONLY SANE_CAP_SOFT_DETECT
// 设置活动状态
#define SET_CAP_ACTIVE(cap, act) \
{ \
if(act) \
cap &= ~SANE_CAP_INACTIVE; \
else \
cap |= SANE_CAP_INACTIVE; \
}
// 设置为只读属性
#define SET_CAP_READONLY(cap) \
{ \
@ -201,6 +448,12 @@ extern "C" {
////////////////////////////////////////////////////////////////////////////////
// extension for standard SANE ...
enum SANE_Action_Ex // extension for SANE_Action
{
SANE_ACTION_GET_DEFAULT_VALUE = 100, // 获取设置项默认值，参数同SANE_ACTION_GET_VALUE
SANE_ACTION_GET_FIX_ID, // 获取属性的固定ID，void* = SANE_Int*
};
typedef struct _sane_stream
{
SANE_Int bytes;
@ -358,19 +611,37 @@ extern "C" {
SANE_Byte x;
SANE_Byte y;
}SANE_Gamma_Point;
enum gamma_index
{
GAMMA_INDEX_GRAY = 0,
GAMMA_INDEX_COLOR,
GAMMA_INDEX_RED,
GAMMA_INDEX_GREEN,
GAMMA_INDEX_BLUE,
};
typedef struct _user_gamma // NOTE: exceeds 4KB !!!
{
SANE_Bool apply_to_back; // SANE_TRUE: 应用到背面; SANE_FALSE: 应用到正面
SANE_Byte pt_count; // 关键点keypoint中有效数据个数，最多4个，0为不使用
SANE_Byte pt_count_r; // 关键点keypoint_r中有效数据个数，最多4个，0为不使用
SANE_Byte pt_count_g; // 关键点keypoint_g中有效数据个数，最多4个，0为不使用
SANE_Byte pt_count_b; // 关键点keypoint_b中有效数据个数，最多4个，0为不使用
SANE_Gamma_Point keypoint[4]; // gamma曲线方程式RGB/灰度/黑白模式控制点
SANE_Gamma_Point keypoint_r[4]; // gamma曲线方程式Red分量控制点
SANE_Gamma_Point keypoint_g[4]; // gamma曲线方程式Green分量控制点
SANE_Gamma_Point keypoint_b[4]; // gamma曲线方程式Blue分量控制点
SANE_Byte table[3 * 256]; // gamma变换阵列，多分量时，顺序为：R[256] + G[256] + B[256]
SANE_Int apply_to_back : 8; // SANE_TRUE: 应用到背面; SANE_FALSE: 应用到正面
SANE_Int app_data : 24; // APP 自定义数据
SANE_Byte count[8]; // 控制点个数，顺序为(gamma_index)： Gray + Color + Red + Green + Blue
SANE_Byte pt_gray[4]; // 灰度控制点 - 只记录横坐标，纵坐标请在table表中查得
SANE_Byte pt_color[4]; // 彩色控制点 - 只记录横坐标，纵坐标请在table表中查得
SANE_Byte pt_red[4]; // 红色控制点 - 只记录横坐标，纵坐标请在table表中查得
SANE_Byte pt_green[4]; // 绿色控制点 - 只记录横坐标，纵坐标请在table表中查得
SANE_Byte pt_blue[4]; // 蓝色控制点 - 只记录横坐标，纵坐标请在table表中查得
SANE_Byte table[5 * 256]; // gamma变换阵列，顺序为(gamma_index)：Gray[256] + Color[256] + R[256] + G[256] + B[256]
}SANE_Gamma;
typedef struct _user_gamma_ex // from draft-2.0
{
SANE_Int size : 16; // size of this structure
SANE_Int ver : 8; // version
SANE_Int count : 8; // 控制点(point数组中有效元素)个数
SANE_Int side : 4; // 0 - 应用到正反面；1 - 应用到正面；2 - 应用到反面
SANE_Int channel : 4; // 0 - 灰度曲线；1 - 彩色曲线；2 - Red通道曲线；3 - Green通道曲线；4 - Blue通道曲线
SANE_Int app_data : 24; // APP 自定义数据
SANE_Byte point[4]; // 控制点 - 只记录横坐标，纵坐标请在table表中查得
SANE_Byte table[256]; // 变换表
}SANE_Gamma_Ex;
typedef struct CISTestResult
{
double w; //圆横轴
@ -468,6 +739,7 @@ extern "C" {
SANE_EVENT_SCAN_FINISHED, // 扫描仪完成扫描, data - (char*)description, *len - error code
SANE_EVENT_ABOUT_INFORMATION, // APP关于信息, data - (SANE_About*), len - unused, be NULL
SANE_EVENT_SCANNER_CLOSED, // 扫描仪已经关闭，data & len 同 SANE_EVENT_STATUS
SANE_EVENT_IMG_UPLOADED, // APP取走一张图片, data - unused, len - count
// SANE_EVENT_WIN_DEBUG_INFO, // writedown debug info on windows platform ... data - (utf8*), *len - HG_LOG_LEVEL, param - NULL !!!
// ui event ...

3
pc/sdk/include/sane/sane_option_definitions.h
View File

@ -638,6 +638,8 @@
//#define OPTION_TITLE_DZSMTCSJ "待纸扫描退出时间"
#define OPTION_TITLE_DZSMTCSJ "\345\276\205\347\272\270\346\211\253\346\217\217\351\200\200\345\207\272\346\227\266\351\227\264"
//#define OPTION_TITLE_TGKBY "跳过空白页"
#define OPTION_TITLE_TGKBY "\350\267\263\350\277\207\347\251\272\347\231\275\351\241\265"
////////////////////////////////////////////////////////////////
@ -649,6 +651,7 @@
////////////////////////////////////////////////////////////////
// string compare ...
////////////////////////////////////////////////////////////////
#include <string.h>
#define IMPLEMENT_OPTION_STRING_COMPARE(func_name) \
bool func_name(const char* opt_define, const char* value) \
{ \

2
pc/sdk/include/sane/sanei_backend.h
View File

@ -70,6 +70,7 @@
without making handstands. */
# ifdef sigset_t
# undef sigset_t
# define sigset_t int
# endif
# ifdef sigemptyset
# undef sigemptyset
@ -96,7 +97,6 @@
# undef SIG_SETMASK
# endif
# define sigset_t int
# define sigemptyset(set) do { *(set) = 0; } while (0)
# define sigfillset(set) do { *(set) = ~0; } while (0)
# define sigaddset(set,signal) do { *(set) |= sigmask (signal); } while (0)