lmh188
/
code_device
mirror of http://192.168.10.5:8099/sane/code_device.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

添加BMP文件头函数；restore不判断auto属性

This commit is contained in:
gb 2024-01-05 17:39:16 +08:00
parent b30660fc49
commit 1d76b40512
11 changed files with 182 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

89
hgdriver/hgdev/scanner/scanner_handler.cpp
View File

@ -2,7 +2,7 @@
#include "async_usb_host.h" #include "async_usb_host.h"
#include <huagao/hgscanner_error.h>
@ -132,7 +132,7 @@ int cmd_result::clean(void)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// scanner_handler // scanner_handler
scanner_handler::scanner_handler(void) : usb_(nullptr), status_(SCANNER_STATUS_NOT_OPEN) scanner_handler::scanner_handler(void) : usb_(nullptr), status_(SCANNER_ERR_NOT_OPEN)
, img_receiver_(std::function<data_holder_ptr(LPPACKIMAGE, uint64_t)>()) , img_receiver_(std::function<data_holder_ptr(LPPACKIMAGE, uint64_t)>())
, status_notify_(std::function<void(uint32_t)>()) , status_notify_(std::function<void(uint32_t)>())
{ {
@ -149,20 +149,20 @@ scanner_handler::scanner_handler(void) : usb_(nullptr), status_(SCANNER_STATUS_N
ret = cmd->roger(reply, used, more); ret = cmd->roger(reply, used, more);
if (cmd->is_over()) if (cmd->is_over())
cmd->release(); cmd->release();
else if (status_ != SCANNER_STATUS_RESET_BULK) else // if (status_ != SCANNER_STATUS_RESET_BULK)
{ {
SIMPLE_LOCK(lock_reply_); SIMPLE_LOCK(lock_reply_);
reply_.push_back(cmd); reply_.push_back(cmd);
} }
} }
else if (status_ == SCANNER_STATUS_RESET_BULK) //else if (status_ == SCANNER_STATUS_RESET_BULK)
{ //{
if (pack->size == sizeof(PACK_BASE) && // if (pack->size == sizeof(PACK_BASE) &&
pack->cmd == PACK_CMD_SYNC_ROGER && // pack->cmd == PACK_CMD_SYNC_ROGER &&
pack->payload_len == 0) // pack->payload_len == 0)
status_ = SCANNER_STATUS_READY; // status_ = SCANNER_STATUS_READY;
} //}
else if (pack->size == sizeof(PACK_BASE)) else if (pack->size == sizeof(PACK_BASE))
{ {
if (pack->cmd == PACK_CMD_SCAN_IMG_ROGER) if (pack->cmd == PACK_CMD_SCAN_IMG_ROGER)
@ -489,7 +489,7 @@ int scanner_handler::scan_start(void)
*used = sizeof(PACK_BASE); *used = sizeof(PACK_BASE);
*more = nullptr; *more = nullptr;
status_ = pack->data == 0 ? SCANNER_STATUS_START_SCANNING : SCANNER_STATUS_READY; status_ = pack->data == 0 ? SCANNER_ERR_DEVICE_BUSY : SCANNER_ERR_OK;
cmd->trigger(); cmd->trigger();
return nullptr; return nullptr;
@ -590,7 +590,7 @@ int scanner_handler::file_transfer(const char* local_path, const char* remote_pa
else else
{ {
*more = dynamic_cast<packet_data_base_ptr>(freader); *more = dynamic_cast<packet_data_base_ptr>(freader);
status_ = SCANNER_STATUS_BUSY; status_ = SCANNER_ERR_DEVICE_BUSY;
} }
} }
} }
@ -651,7 +651,7 @@ int scanner_handler::file_transfer(const char* local_path, const char* remote_pa
fsaver->set_progress_notify(progress); fsaver->set_progress_notify(progress);
*more = dynamic_cast<packet_data_base_ptr>(fsaver); *more = dynamic_cast<packet_data_base_ptr>(fsaver);
(*(LPPACK_BASE)reply->ptr()).data = 0; (*(LPPACK_BASE)reply->ptr()).data = 0;
status_ = SCANNER_STATUS_BUSY; status_ = SCANNER_ERR_DEVICE_BUSY;
} }
} }
} }
@ -781,7 +781,7 @@ int scanner_handler::open_usb_scanner(libusb_device* dev)
{ {
ret = usb_->start(dev); ret = usb_->start(dev);
if(ret == 0) if(ret == 0)
status_ = SCANNER_STATUS_READY; status_ = SCANNER_ERR_OK;
//usb_->set_gadget_encrypting_method(ENCRYPT_CMD_XOR_PID); //usb_->set_gadget_encrypting_method(ENCRYPT_CMD_XOR_PID);
} }
@ -798,7 +798,7 @@ int scanner_handler::close(void)
reply_.clear(); reply_.clear();
} }
if(ret == 0) if(ret == 0)
status_ = SCANNER_STATUS_NOT_OPEN; status_ = SCANNER_ERR_NOT_OPEN;
return ret; return ret;
} }
@ -806,37 +806,36 @@ int scanner_handler::reset_message_que(void)
{ {
return 0; return 0;
int err = usb_->cancel_write(); //int err = usb_->cancel_write();
//
status_ = SCANNER_STATUS_RESET_BULK; //status_ = SCANNER_STATUS_RESET_BULK;
utils::to_log(LOG_LEVEL_DEBUG, "reset_message_que - send reset command ...\r\n"); //utils::to_log(LOG_LEVEL_DEBUG, "reset_message_que - send reset command ...\r\n");
err = usb_->reset_peer(); //err = usb_->reset_peer();
utils::to_log(LOG_LEVEL_DEBUG, "reset_message_que - send reset command = %d\r\n", err); //utils::to_log(LOG_LEVEL_DEBUG, "reset_message_que - send reset command = %d\r\n", err);
if (err == 0) //if (err == 0)
{ //{
EP0REPLYSTATUS s; // EP0REPLYSTATUS s;
dyn_mem_ptr raw(dyn_mem::memory(sizeof(PACK_BASE))); // dyn_mem_ptr raw(dyn_mem::memory(sizeof(PACK_BASE)));
LPPACK_BASE pack = (LPPACK_BASE)raw->ptr(); // LPPACK_BASE pack = (LPPACK_BASE)raw->ptr();
//
BASE_PACKET_REPLY(*pack, PACK_CMD_SYNC, 0, 0); // BASE_PACKET_REPLY(*pack, PACK_CMD_SYNC, 0, 0);
raw->set_len(sizeof(PACK_BASE)); // raw->set_len(sizeof(PACK_BASE));
utils::to_log(LOG_LEVEL_DEBUG, "reset_message_que - wait 100ms ...\r\n"); // utils::to_log(LOG_LEVEL_DEBUG, "reset_message_que - wait 100ms ...\r\n");
std::this_thread::sleep_for(std::chrono::milliseconds(100)); // std::this_thread::sleep_for(std::chrono::milliseconds(100));
utils::to_log(LOG_LEVEL_DEBUG, "reset_message_que - send SYNC packet ...\r\n"); // utils::to_log(LOG_LEVEL_DEBUG, "reset_message_que - send SYNC packet ...\r\n");
usb_->send_bulk_raw_data(raw); // usb_->send_bulk_raw_data(raw);
raw->release(); // raw->release();
//
std::this_thread::sleep_for(std::chrono::milliseconds(50)); // std::this_thread::sleep_for(std::chrono::milliseconds(50));
if (status_ == SCANNER_STATUS_RESET_BULK) // if (status_ == SCANNER_STATUS_RESET_BULK)
err = EFAULT; // err = EFAULT;
utils::to_log(LOG_LEVEL_DEBUG, "reset_message_que - final status = %d\r\n", status_); // utils::to_log(LOG_LEVEL_DEBUG, "reset_message_que - final status = %d\r\n", status_);
} //}
//
return err; //return err;
} }
bool scanner_handler::is_scanner_available(void) bool scanner_handler::is_scanner_available(void)
{ {
return status_ != SCANNER_STATUS_NOT_OPEN return status_ == SCANNER_ERR_OK ||
&& status_ != SCANNER_STATUS_LOST_CONNECT status_ == SCANNER_ERR_DEVICE_BUSY;
&& status_ != SCANNER_STATUS_RESET_BULK;
} }

10
hgdriver/hgdev/user-opt/user.h
View File

@ -7,6 +7,16 @@
#include <string> #include <string>
// name password time-limit
//
// developer calc(dev-sn + login-times) 6min
//
// owner calc(dev-sn + login-times) 30min
//
// admin dev-sn 1hour
//
// user none, default level always
//
class hguser class hguser
{ {
std::string name_; std::string name_;

22
sdk/base/data.cpp
View File

@ -10,28 +10,6 @@
#include <sys/mman.h> #include <sys/mman.h>
#endif #endif
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// sys_info
uint32_t sys_info::page_size = 0;
uint32_t sys_info::page_map_size = 0;
uint32_t sys_info::cluster_size = 0;
sys_info::sys_info()
{
sys_info::page_size = utils::get_page_size(&sys_info::page_map_size);
std::string path(utils::get_local_data_path());
unsigned long long cluster = 0;
utils::get_disk_space(path.c_str(), nullptr, nullptr, &cluster);
sys_info::cluster_size = cluster;
printf("Page size: %u\nMap size: %u\nCluster : %u\n", sys_info::page_size, sys_info::page_map_size, sys_info::cluster_size);
}
sys_info::~sys_info()
{}
static sys_info g_si;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// //

11
sdk/base/data.h
View File

@ -76,17 +76,6 @@ public:
uint8_t* buffer(void); uint8_t* buffer(void);
}; };
class sys_info
{
public:
sys_info();
~sys_info();
public:
static uint32_t page_size;
static uint32_t page_map_size;
static uint32_t cluster_size;
};
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// //

27
sdk/base/packet.h
View File

@ -126,33 +126,6 @@ enum img_cb_type
IMG_CB_STOPPED, IMG_CB_STOPPED,
}; };
enum scanner_status
{
SCANNER_STATUS_READY = 0x10000, // status beginning, avoiding conficts with standards/system error code
SCANNER_STATUS_NOT_OPEN,
SCANNER_STATUS_LOST_CONNECT,
SCANNER_STATUS_RESET_BULK,
SCANNER_STATUS_START_SCANNING, // start ok, but scanning-thread not working
SCANNER_STATUS_SCANNING, // start ok, and scanning-thread is working
SCANNER_STATUS_SCAN_FINISHED, // not a persistance status
SCANNER_STATUS_BUSY, // doing task exclude scanning
SCANNER_STATUS_COVER_OPENNED,
SCANNER_STATUS_COVER_CLOSED,
SCANNER_STATUS_SLEEPING,
SCANNER_STATUS_WAKED_UP,
SCANNER_STATUS_COUNT_MODE,
SCANNER_STATUS_DOUBLE_FEEDED,
SCANNER_STATUS_PAPER_JAMMED,
SCANNER_STATUS_PAPER_ASKEW,
SCANNER_STATUS_FEED_FAILED,
SCANNER_STATUS_NO_PAPER,
SCANNER_STATUS_PAPER_ON,
SCANNER_STATUS_STAPLE_ON,
SCANNER_STATUS_SIZE_ERR,
SCANNER_STATUS_DOGEAR,
SCANNER_STATUS_CFG_CHANGED, // PACK_BASE::payload - LPCFGVAL
};
// option affection if value changed, see SANE_INFO_xxx // option affection if value changed, see SANE_INFO_xxx
enum opt_affect enum opt_affect
{ {

1
sdk/base/plat_types.h
View File

@ -17,6 +17,7 @@
#define ALIGN_TO(v, align) (((v) + (align) - 1) / (align) * (align)) #define ALIGN_TO(v, align) (((v) + (align) - 1) / (align) * (align))
#define ALIGN_INT(v) ALIGN_TO(v, sizeof(int)) #define ALIGN_INT(v) ALIGN_TO(v, sizeof(int))
#define CLEAN_ARRAY(a) memset(a, 0, sizeof(a)) #define CLEAN_ARRAY(a) memset(a, 0, sizeof(a))
#define BMP_LINE_BYTES(bits) (((bits) + 31) / 32 * 4)
#define RETURN_ENUM_STR(v, e) \ #define RETURN_ENUM_STR(v, e) \
if(v == e) \ if(v == e) \

85
sdk/base/utils.cpp
View File

@ -605,8 +605,12 @@ namespace utils
ldp = path; ldp = path;
ldp += PATH_SEPARATOR; ldp += PATH_SEPARATOR;
} }
#else
#ifdef BUILD_AS_DEVICE
const char* path = "/var/log";
#else #else
const char* path(getenv("HOME")); const char* path(getenv("HOME"));
#endif
if (path) if (path)
{ {
@ -926,11 +930,11 @@ namespace utils
HMODULE load_dll(const char* path_file, int flag) HMODULE load_dll(const char* path_file, int flag)
{ {
#if OS_WIN #if OS_WIN
HMODULE h = LoadLibraryA(path_file); HMODULE h = NULL; // LoadLibraryA(path_file);
int ret = GetLastError(); int ret = 0; // GetLastError();
utils::to_log(1, "[TWAIN]Load: LoadLibraryA(%s) = %d\r\n", path_file, ret); // utils::to_log(1, "[TWAIN]Load: LoadLibraryA(%s) = %d\r\n", path_file, ret);
if (!h && (ret == ERROR_MOD_NOT_FOUND || ret == ERROR_BAD_EXE_FORMAT)) // if (!h && (ret == ERROR_MOD_NOT_FOUND || ret == ERROR_BAD_EXE_FORMAT))
{ {
std::string dir(path_file); std::string dir(path_file);
size_t pos = dir.rfind('\\'); size_t pos = dir.rfind('\\');
@ -1239,6 +1243,53 @@ namespace utils
return 0; return 0;
} }
std::string bitmap_info_header(int pixel_w, int pixel_h, int bpp, int dpix, int dpiy)
{
BITMAPINFODEADER bih = {0};
std::string stream("");
if(dpiy == 0)
dpiy = dpix;
bih.biSize = sizeof(bih);
bih.biWidth = pixel_w;
bih.biHeight = pixel_h;
bih.biBitCount = bpp;
bih.biSizeImage = BMP_LINE_BYTES(pixel_w * bpp) * pixel_h;
bih.biPlanes = 1;
bih.biCompression = BI_RGB;
bih.biXPelsPerMeter = (LONG)(dpix * 39.37f + .5f);
bih.biYPelsPerMeter = (LONG)(dpiy * 39.37f + .5f);
stream = std::string((char*)&bih, sizeof(bih));
if(bpp == 1)
{
int pal[] = { 0, 0x0ffffff };
stream += std::string((char*)pal, sizeof(pal));
bih.biClrUsed = _countof(pal);
}
else if(bpp == 8)
{
stream += std::string((char*)global_info::gray_pallete, sizeof(global_info::gray_pallete));
bih.biClrUsed = _countof(global_info::gray_pallete);
}
return std::move(stream);
}
std::string bitmap_file_header(BITMAPINFOHEADER *lpbi) // return BITMAPFILEHEADER
{
BITMAPFILEHEADER bfh = {0};
int pal_size = 0;
bfh.bfType = MAKEWORD('B', 'M');
if(lpbi->biBitCount == 1)
pal_size = 2 * sizeof(int);
else if(lpbi->biBitCount == 8)
pal_size = 256 * sizeof(int);
bfh.bfOffBits = sizeof(bfh) + sizeof(BITMAPINFOHEADER) + pal_size;
bfh.bfSize = bfh.bfOffBits + lpbi->biSizeImage;
return std::move(std::string((char*)&bfh, sizeof(bfh)));
}
#if OS_WIN #if OS_WIN
bool run_get_message(HWND hwnd, UINT filter_min, UINT filter_max, std::function<bool(MSG*, bool*)> msghandler) bool run_get_message(HWND hwnd, UINT filter_min, UINT filter_max, std::function<bool(MSG*, bool*)> msghandler)
{ {
@ -1598,6 +1649,32 @@ void chronograph::reset()
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// global_info
uint32_t global_info::page_size = 0;
uint32_t global_info::page_map_size = 0;
uint32_t global_info::cluster_size = 0;
uint32_t global_info::gray_pallete[] = {0};
global_info::global_info()
{
global_info::page_size = utils::get_page_size(&global_info::page_map_size);
std::string path(utils::get_local_data_path());
unsigned long long cluster = 0;
utils::get_disk_space(path.c_str(), nullptr, nullptr, &cluster);
global_info::cluster_size = cluster;
for(int i = 0; i < _countof(global_info::gray_pallete); ++i)
global_info::gray_pallete[i] = MAKELONG(MAKEWORD(i, i), MAKEWORD(i, 0));
printf("Page size: %u\nMap size: %u\nCluster : %u\n", global_info::page_size, global_info::page_map_size, global_info::cluster_size);
}
global_info::~global_info()
{}
static global_info g_si;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

18
sdk/base/utils.h
View File

@ -77,6 +77,10 @@ namespace utils
int copy_log_file_to(const char* dst); int copy_log_file_to(const char* dst);
int clear_log_file(void); int clear_log_file(void);
// bitmap header ...
std::string bitmap_info_header(int pixel_w, int pixel_h, int bpp, int dpix, int dpiy = 0); // return BITMPINFOHEADER + pallete if need. dpiy same as dpix if was ZERO
std::string bitmap_file_header(BITMAPINFOHEADER *lpbi); // return BITMAPFILEHEADER
#if OS_WIN #if OS_WIN
// Function: pump message recycle (GetMessageW) // Function: pump message recycle (GetMessageW)
// //
@ -232,6 +236,20 @@ public:
void reset(void); void reset(void);
}; };
// global info
class global_info
{
public:
global_info();
~global_info();
public:
static uint32_t page_size;
static uint32_t page_map_size;
static uint32_t cluster_size;
static uint32_t gray_pallete[256];
};
// event // event
class platform_event : public refer class platform_event : public refer
{ {

17
sdk/sane_opt_json/device_opt.cpp
View File

@ -1785,6 +1785,20 @@ int device_option::update_data(const char* name, void* value, bool reorder_if_ne
|| (child->get_value("auth", err) && user_ && !user_(err))) || (child->get_value("auth", err) && user_ && !user_(err)))
{ {
err = SCANNER_ERR_ACCESS_DENIED; err = SCANNER_ERR_ACCESS_DENIED;
// following ...
if (src_.count(name))
{
sane_opt_provider* opt = src_[name]->get_following(name);
while(opt)
{
opt->set_value(name, value);
sane_opt_provider* next = opt->get_following(name);
opt->release();
opt = next;
}
}
} }
else else
{ {
@ -1921,7 +1935,8 @@ int device_option::restore(sane_opt_provider* holder)
while (child) while (child)
{ {
if ((!holder || src_.count(child->key()) && src_[child->key()] == holder) if ((!holder || src_.count(child->key()) && src_[child->key()] == holder)
&& is_auto_restore_default(child)) // && is_auto_restore_default(child)
)
{ {
std::string val(device_option::option_value(child, true)); std::string val(device_option::option_value(child, true));
update_data(child->key().c_str(), &val[0], false); update_data(child->key().c_str(), &val[0], false);

22
sdk/sane_opt_json/device_opt.h
View File

@ -375,8 +375,8 @@ public:
// "resolution": { // "resolution": {
// "cat": "base", // "cat": "base",
// "group" : "base", // "group" : "base",
// "title" : "分辨率", // "title" : "<EFBFBD>ֱ<EFBFBD><EFBFBD><EFBFBD>",
// "desc" : "设置扫描图像的分辨率", // "desc" : "<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ɨ<EFBFBD><EFBFBD>ͼ<EFBFBD><EFBFBD>ķֱ<EFBFBD><EFBFBD><EFBFBD>",
// "type" : "int", // "type" : "int",
// "fix-id" : 34840, // "fix-id" : 34840,
// "size" : 4, // "size" : 4,
@ -386,7 +386,7 @@ public:
// "min": 100, // "min": 100,
// "max" : { // "max" : {
// "default": 600, // "default": 600,
// "paper==最大扫描尺寸自动裁切 || paper==最大扫描尺寸 || paper==三联试卷" : 500 // "paper==<EFBFBD><EFBFBD><EFBFBD>ɨ<EFBFBD><EFBFBD>ߴ<EFBFBD><EFBFBD>Զ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> || paper==<3D><><EFBFBD>ɨ<EFBFBD><C9A8>ߴ<EFBFBD> || paper==<3D><><EFBFBD><EFBFBD><EFBFBD>Ծ<EFBFBD>" : 500
// }, // },
// "step" : 1 // "step" : 1
// } // }
@ -395,19 +395,19 @@ public:
// "paper": { // "paper": {
// "cat": "base", // "cat": "base",
// "group" : "base", // "group" : "base",
// "title" : "纸张尺寸", // "title" : "ֽ<EFBFBD>ųߴ<EFBFBD>",
// "desc" : "设置出图大小", // "desc" : "<EFBFBD><EFBFBD><EFBFBD>ó<EFBFBD>ͼ<EFBFBD><EFBFBD>С",
// "type" : "string", // "type" : "string",
// "fix-id" : 34831, // "fix-id" : 34831,
// "size" : 44, // "size" : 44,
// "cur" : "匹配原始尺寸", // "cur" : "ƥ<EFBFBD><EFBFBD>ԭʼ<EFBFBD>ߴ<EFBFBD>",
// "default" : "匹配原始尺寸", // "default" : "ƥ<EFBFBD><EFBFBD>ԭʼ<EFBFBD>ߴ<EFBFBD>",
// "range" : ["A3", "8开", "A4", "16开", "A5", "A6", "B4", "B5", "B6", "Letter", "Double Letter", "LEGAL", "匹配原始尺寸", { // "range" : ["A3", "8<EFBFBD><EFBFBD>", "A4", "16<31><36>", "A5", "A6", "B4", "B5", "B6", "Letter", "Double Letter", "LEGAL", "ƥ<EFBFBD><EFBFBD>ԭʼ<EFBFBD>ߴ<EFBFBD>", {
// "resolution<500": "最大扫描尺寸自动裁切" // "resolution<500": "<EFBFBD><EFBFBD><EFBFBD>ɨ<EFBFBD><EFBFBD>ߴ<EFBFBD><EFBFBD>Զ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>"
// }, { // }, {
// "resolution<500": "最大扫描尺寸" // "resolution<500": "<EFBFBD><EFBFBD><EFBFBD>ɨ<EFBFBD><EFBFBD>ߴ<EFBFBD>"
// }, { // }, {
// "resolution<500": "三联试卷" // "resolution<500": "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ծ<EFBFBD>"
// }] // }]
// } // }
//} //}

1
twain/ds/scanned_img.cpp
View File

@ -275,6 +275,7 @@ std::string scanned_img::file_header(SANE_ImageType type, float resolution)
pal_size = 2 * sizeof(int); pal_size = 2 * sizeof(int);
else if (bih.biBitCount == 8) else if (bih.biBitCount == 8)
pal_size = 256 * sizeof(int); pal_size = 256 * sizeof(int);
bih.biClrUsed = pal_size / sizeof(int); // some APP (PJScanner.exe 光大……) use this field to calculate pallete
{ {
BITMAPFILEHEADER fh = { 0 }; BITMAPFILEHEADER fh = { 0 };