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

fix CIS pre-do bug, add jpeg-quality option

This commit is contained in:
gb 2023-05-08 18:04:54 +08:00
parent 423d54cce1
commit 6453b1aad4
14 changed files with 293 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
device/gxx-linux/imgproc/imageencode.cpp
View File

@ -40,7 +40,7 @@ JpegImageEncode::JpegImageEncode(bool bwimg, int dpi)
} }
m_bwimg = bwimg; m_bwimg = bwimg;
} }
JpegImageEncode::JpegImageEncode(const char* fmt, int dpi) : fmt_(fmt ? fmt : "") JpegImageEncode::JpegImageEncode(const char* fmt, int dpi_h, int dpi_v, int jpeg_quality) : fmt_(fmt ? fmt : "")
{ {
if(fmt_ == "PNG") if(fmt_ == "PNG")
{ {
@ -50,12 +50,12 @@ JpegImageEncode::JpegImageEncode(const char* fmt, int dpi) : fmt_(fmt ? fmt : ""
else else
{ {
compression_params.push_back(cv::IMWRITE_JPEG_QUALITY); compression_params.push_back(cv::IMWRITE_JPEG_QUALITY);
compression_params.push_back(100); compression_params.push_back(jpeg_quality);
compression_params.push_back(cv::IMWRITE_RESOLUTION_X); compression_params.push_back(cv::IMWRITE_RESOLUTION_X);
compression_params.push_back(dpi); compression_params.push_back(dpi_h);
compression_params.push_back(cv::IMWRITE_RESOLUTION_Y); compression_params.push_back(cv::IMWRITE_RESOLUTION_Y);
compression_params.push_back(dpi); compression_params.push_back(dpi_v);
} }
} }
JpegImageEncode::~JpegImageEncode() JpegImageEncode::~JpegImageEncode()

2
device/gxx-linux/imgproc/imageencode.h
View File

@ -25,7 +25,7 @@ class JpegImageEncode : public IImageEncode
public: public:
JpegImageEncode(bool bwimg, int dpi); JpegImageEncode(bool bwimg, int dpi);
JpegImageEncode(const char* fmt, int dpi); JpegImageEncode(const char* fmt, int dpi_h, int dpi_v, int jpeg_quality = 100);
virtual ~JpegImageEncode(); virtual ~JpegImageEncode();
virtual MemoryPtr encode(cv::Mat& image); virtual MemoryPtr encode(cv::Mat& image);

9
device/gxx-linux/scanner/imageusbhandler.cpp
View File

@ -36,7 +36,7 @@ ImageUsbHandler::~ImageUsbHandler()
static int num = 0; static int num = 0;
void ImageUsbHandler::add_image(void *data, int width, int height, int type, int scannnum,unsigned int fpgaversion) void ImageUsbHandler::add_image(void *data, int width, int height, int type, int scannnum,unsigned int fpgaversion)
{ {
printf("ImageUsbHandler::add_image(%d * %d), fpgaversion = %d\n", width, height, fpgaversion); printf("ImageUsbHandler::add_image(%d * %d), fpgaversion = %d, HRatio = %f, VRatio = %f\n", width, height, fpgaversion, H_ratio, V_ratio);
if(images->push_raw(data, width, height, type == CV_8UC1 ? COLOR_CHANNEL_GRAY : COLOR_CHANNEL_RGB, scannnum, fpgaversion, 0)) if(images->push_raw(data, width, height, type == CV_8UC1 ? COLOR_CHANNEL_GRAY : COLOR_CHANNEL_RGB, scannnum, fpgaversion, 0))
{ {
@ -45,11 +45,6 @@ void ImageUsbHandler::add_image(void *data, int width, int height, int type, int
images->push(nullptr, false); // notify ONE paper passed images->push(nullptr, false); // notify ONE paper passed
// img_one_paper *paper = new img_one_paper();
// paper->init_from(data, width, height, scannnum, PAPER_SIDE_LEFT, type == CV_8UC1 ? COLOR_CHANNEL_GRAY : COLOR_CHANNEL_RGB);
// imgproc_->push_image(paper);
// paper->release();
std::string ext = ".jpg"; std::string ext = ".jpg";
{ {
if (m_imgstatus.status != NO_error) if (m_imgstatus.status != NO_error)
@ -292,6 +287,8 @@ void ImageUsbHandler::Set_ratio(u32 h_ratio,u32 v_ratio)
{ {
H_ratio =*((float*)(&h_ratio)); H_ratio =*((float*)(&h_ratio));
V_ratio =*((float*)(&v_ratio)); V_ratio =*((float*)(&v_ratio));
images->set_ratio(H_ratio, V_ratio);
} }
bool ImageUsbHandler::done() bool ImageUsbHandler::done()

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

File diff suppressed because one or more lines are too long

2
device/gxx-linux/usb/src/async_model/hardware/hardware.h
View File

@ -12,7 +12,7 @@
class gb_json; class gb_json;
#define CAPTURED_IMG_RECEIVER_PROTO void(int data_type/*img_cb_type*/, void* data, size_t w, size_t h, int dpi_x, int dpi_y, size_t paper_ind, paper_side side, clr_channel clr, img_status, bool img_new, bool img_over) #define CAPTURED_IMG_RECEIVER_PROTO void(int data_type/*img_cb_type*/, void* data, size_t w, size_t h, int dpi_x, int dpi_y, size_t paper_ind, paper_side side, clr_channel clr, img_status, bool img_new, bool img_over, float ratio_H, float ratio_v)
// { // {

63
device/gxx-linux/usb/src/async_model/img_process/algs/img_algorithm.cpp
View File

@ -15,7 +15,7 @@ extern int32_t (*set_pixel_type)(int*);
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// class img_one_paper // class img_one_paper
img_one_paper::img_one_paper() img_one_paper::img_one_paper() : ratio_h_(1.0f), ratio_v_(1.0f)
{ {
} }
img_one_paper::~img_one_paper() img_one_paper::~img_one_paper()
@ -28,7 +28,7 @@ void img_one_paper::clear(void)
imgs_.clear(); imgs_.clear();
} }
int img_one_paper::init_from(void* data, size_t w, size_t h, int dpi_x, int dpi_y, size_t paper_ind, paper_side side, clr_channel cc, img_status status, bool img_new, bool img_over) int img_one_paper::init_from(void* data, size_t w, size_t h, int dpi_x, int dpi_y, size_t paper_ind, paper_side side, clr_channel cc, img_status status, bool img_new, bool img_over, float ratio_h, float ratio_v)
{ {
PACKIMAGE pk; PACKIMAGE pk;
@ -58,9 +58,9 @@ int img_one_paper::init_from(void* data, size_t w, size_t h, int dpi_x, int dpi_
} }
pk.height = h; pk.height = h;
return init_from(data, w, h, &pk); return init_from(data, w, h, &pk, ratio_h, ratio_v);
} }
int img_one_paper::init_from(void* data, size_t w, size_t h, LPPACKIMAGE pimg) int img_one_paper::init_from(void* data, size_t w, size_t h, LPPACKIMAGE pimg, float ratio_h, float ratio_v)
{ {
int ret = 0; int ret = 0;
PROCIMG img; PROCIMG img;
@ -69,6 +69,8 @@ int img_one_paper::init_from(void* data, size_t w, size_t h, LPPACKIMAGE pimg)
memcpy(&img.head, pimg, sizeof(img.head)); memcpy(&img.head, pimg, sizeof(img.head));
img.img = std::move(cv::Mat(h, w, CV_8UC1, data)); img.img = std::move(cv::Mat(h, w, CV_8UC1, data));
imgs_.push_back(std::move(img)); imgs_.push_back(std::move(img));
ratio_h_ = ratio_h;
ratio_v_ = ratio_v;
return ret; return ret;
} }
@ -76,6 +78,14 @@ std::vector<PROCIMG>& img_one_paper::images_queue(void)
{ {
return imgs_; return imgs_;
} }
float img_one_paper::get_cis_ratio_h(void)
{
return ratio_h_;
}
float img_one_paper::get_cis_ratio_v(void)
{
return ratio_v_;
}
@ -563,7 +573,7 @@ bool img_color_transfer::is_enabled(std::function<int32_t(const char*, void*, si
// "pos": 0, // "pos": 0,
// "type": "string", // "type": "string",
// "unit": "none", // "unit": "none",
// "affect": 0, // "affect": 2,
// "readonly": false, // "readonly": false,
// "visible": true, // "visible": true,
// "enabled": true, // "enabled": true,
@ -571,12 +581,36 @@ bool img_color_transfer::is_enabled(std::function<int32_t(const char*, void*, si
// "cur": "JPEG", // "cur": "JPEG",
// "default": "JPEG", // "default": "JPEG",
// "range": ["JPEG", "PNG", "TIFF"] // "range": ["JPEG", "PNG", "TIFF"]
// },
// "jpeg-quality": {
// "cat": "Common",
// "group": "output",
// "title": "JPEG质量",
// "desc": "设置JPEG压缩质量，质量越高，压缩率越低",
// "ver": 1,
// "pos": 0,
// "type": "int",
// "unit": "%",
// "affect": 4,
// "readonly": false,
// "visible": true,
// "enabled": true,
// "size": 4,
// "cur": 100,
// "default": 100,
// "range": {
// "min": 10,
// "max": 100,
// "step": 1
// },
// "depend_or": ["img-format==JPEG"]
// } // }
// } // }
static std::string fmt_json =
"{\"img-format\":{\"cat\":\"Common\",\"group\":\"output\",\"title\":\"\\u56fe\\u7247\\u683c\\u5f0f\",\"desc\":\"\\u8bbe\\u5907\\u8f93\\u51fa\\u7684\\u56fe\\u7247\\u6587\\u4ef6\\u683c\\u5f0f\",\"ver\":1,\"pos\":0,\"type\":\"string\",\"unit\":\"none\",\"affect\":0,\"readonly\":false,\"visible\":true,\"enabled\":true,\"size\":42,\"cur\":\"JPEG\",\"default\":\"JPEG\",\"range\":[\"JPEG\",\"PNG\",\"TIFF\"]}}";
img_encoder::img_encoder() : fmt_("JPEG") static std::string fmt_json =
"{\"img-format\":{\"cat\":\"Common\",\"group\":\"output\",\"title\":\"\\u56fe\\u7247\\u683c\\u5f0f\",\"desc\":\"\\u8bbe\\u5907\\u8f93\\u51fa\\u7684\\u56fe\\u7247\\u6587\\u4ef6\\u683c\\u5f0f\",\"ver\":1,\"pos\":0,\"type\":\"string\",\"unit\":\"none\",\"affect\":2,\"readonly\":false,\"visible\":true,\"enabled\":true,\"size\":42,\"cur\":\"JPEG\",\"default\":\"JPEG\",\"range\":[\"JPEG\",\"PNG\",\"TIFF\"]},\"jpeg-quality\":{\"cat\":\"Common\",\"group\":\"output\",\"title\":\"JPEG\\u8d28\\u91cf\",\"desc\":\"\\u8bbe\\u7f6eJPEG\\u538b\\u7f29\\u8d28\\u91cf\\uff0c\\u8d28\\u91cf\\u8d8a\\u9ad8\\uff0c\\u538b\\u7f29\\u7387\\u8d8a\\u4f4e\",\"ver\":1,\"pos\":0,\"type\":\"int\",\"unit\":\"%\",\"affect\":4,\"readonly\":false,\"visible\":true,\"enabled\":true,\"size\":4,\"cur\":100,\"default\":100,\"range\":{\"min\":10,\"max\":100,\"step\":1},\"depend_or\":[\"img-format==JPEG\"]}}";
img_encoder::img_encoder() : fmt_("JPEG"), jpeg_quality_(100)
{ {
cfg_ = new gb_json(); cfg_ = new gb_json();
if(cfg_->attach_text(&fmt_json[0])) if(cfg_->attach_text(&fmt_json[0]))
@ -639,12 +673,23 @@ int32_t img_encoder::set_config(const char* cfg_name, void* data, size_t* len, u
if(strcmp(cfg_name, "img-format") == 0) if(strcmp(cfg_name, "img-format") == 0)
fmt_ = std::string((char*)data, *len); fmt_ = std::string((char*)data, *len);
else if(strcmp(cfg_name, "jpeg-quality") == 0)
jpeg_quality_ = *(int*)data;
} }
return ret; return ret;
} }
bool img_encoder::update_enabled(const char* name, std::function<GET_SANE_OPT_PROTO> get_opt) bool img_encoder::update_enabled(const char* name, std::function<GET_SANE_OPT_PROTO> get_opt)
{ {
gb_json* child = cfg_->first_child();
while(child)
{
sane_cfg_provider::update_option_enable_status(child, get_opt);
child->release();
child = cfg_->next_child();
}
return false; return false;
} }
int32_t img_encoder::get_raw_value(const char* name, const char* key, std::string& val, uint32_t* type) int32_t img_encoder::get_raw_value(const char* name, const char* key, std::string& val, uint32_t* type)
@ -666,7 +711,7 @@ int32_t img_encoder::get_raw_value(const char* name, const char* key, std::strin
MemoryPtr img_encoder::encode(PROCIMG* img) MemoryPtr img_encoder::encode(PROCIMG* img)
{ {
JpegImageEncode encoder(fmt_.c_str(), img->head.resolution_x); JpegImageEncode encoder(fmt_.c_str(), img->head.resolution_x, img->head.resolution_y, jpeg_quality_);
if(fmt_ == "JPEG") if(fmt_ == "JPEG")
img->head.format = IMG_FMT_JPEG; img->head.format = IMG_FMT_JPEG;

9
device/gxx-linux/usb/src/async_model/img_process/algs/img_algorithm.h
View File

@ -43,6 +43,8 @@ class gb_json;
class img_one_paper : public refer class img_one_paper : public refer
{ {
std::vector<PROCIMG> imgs_; std::vector<PROCIMG> imgs_;
float ratio_h_; // CIS factor
float ratio_v_; // CIS factor
void clear(void); void clear(void);
@ -53,10 +55,12 @@ protected:
~img_one_paper(); ~img_one_paper();
public: public:
int init_from(void* data, size_t w, size_t h, int dpi_x, int dpi_y, size_t paper_ind, paper_side side = PAPER_SIDE_LEFT, clr_channel cc = COLOR_CHANNEL_RGB, img_status status = IMG_STATUS_OK, bool img_new = true, bool img_over = true); int init_from(void* data, size_t w, size_t h, int dpi_x, int dpi_y, size_t paper_ind, paper_side side = PAPER_SIDE_LEFT, clr_channel cc = COLOR_CHANNEL_RGB, img_status status = IMG_STATUS_OK, bool img_new = true, bool img_over = true, float ratio_h = 1.0f, float ratio_v = 1.0f);
int init_from(void* data, size_t w, size_t h, LPPACKIMAGE pimg); int init_from(void* data, size_t w, size_t h, LPPACKIMAGE pimg, float ratio_h = 1.0f, float ratio_v = 1.0f);
std::vector<PROCIMG>& images_queue(void); std::vector<PROCIMG>& images_queue(void);
float get_cis_ratio_h(void);
float get_cis_ratio_v(void);
}; };
enum img_alg_type enum img_alg_type
@ -187,6 +191,7 @@ class img_encoder : public sane_cfg_provider
{ {
std::string fmt_; std::string fmt_;
gb_json* cfg_; gb_json* cfg_;
int jpeg_quality_;
public: public:
img_encoder(); img_encoder();

113
device/gxx-linux/usb/src/async_model/img_process/cis_preproc.cpp
View File

@ -7,7 +7,7 @@
// configuration text // configuration text
// //
static std::string g_cis_cfg("{\"montage\":{\"cat\":\"cis\",\"group\":\"CIS\",\"title\":\"\\u56fe\\u50cf\\u62fc\\u63a5\",\"desc\":\"\\u5c06CIS\\u91c7\\u96c6\\u7684\\u539f\\u59cb\\u6570\\u636e\\u6062\\u590d\\u4e3a\\u6b63\\u5e38\\u7684\\u56fe\\u50cf\",\"ver\":1,\"pos\":10,\"type\":\"bool\",\"unit\":\"none\",\"affect\":0,\"readonly\":false,\"visible\":false,\"enabled\":true,\"size\":4,\"cur\":true,\"default\":true},\"fb-split\":{\"cat\":\"cis\",\"group\":\"CIS\",\"title\":\"\\u62c6\\u5206\\u6b63\\u53cd\\u9762\",\"desc\":\"\\u5c06\\u6b63\\u53cd\\u9762\\u5408\\u6210\\u7684\\u4e00\\u5f20\\u56fe\\u7247\\u62c6\\u5206\\u6210\\u6b63\\u9762\\u548c\\u53cd\\u9762\\u56fe\\u7247\",\"ver\":1,\"pos\":20,\"type\":\"bool\",\"unit\":\"none\",\"affect\":0,\"readonly\":false,\"visible\":false,\"enabled\":true,\"size\":4,\"cur\":true,\"default\":true}}"); static std::string g_cis_cfg("{\"montage\":{\"cat\":\"cis\",\"group\":\"CIS\",\"title\":\"\\u56fe\\u50cf\\u62fc\\u63a5\",\"desc\":\"\\u5c06CIS\\u91c7\\u96c6\\u7684\\u539f\\u59cb\\u6570\\u636e\\u6062\\u590d\\u4e3a\\u6b63\\u5e38\\u7684\\u56fe\\u50cf\",\"ver\":1,\"pos\":10,\"type\":\"bool\",\"unit\":\"none\",\"affect\":0,\"readonly\":false,\"visible\":false,\"enabled\":true,\"size\":4,\"cur\":true,\"default\":true},\"fb-split\":{\"cat\":\"CIS\",\"group\":\"CIS\",\"title\":\"\\u62c6\\u5206\\u6b63\\u53cd\\u9762\",\"desc\":\"\\u5c06\\u6b63\\u53cd\\u9762\\u5408\\u6210\\u7684\\u4e00\\u5f20\\u56fe\\u7247\\u62c6\\u5206\\u6210\\u6b63\\u9762\\u548c\\u53cd\\u9762\\u56fe\\u7247\",\"ver\":1,\"pos\":20,\"type\":\"bool\",\"unit\":\"none\",\"affect\":2,\"readonly\":false,\"visible\":false,\"enabled\":true,\"size\":4,\"cur\":true,\"default\":true},\"page\":{\"cat\":\"CIS\",\"group\":\"base\",\"title\":\"\\u9875\\u9762\",\"desc\":\"\\u83b7\\u53d6\\u7eb8\\u5f20\\u6307\\u5b9a\\u9762\\u7684\\u56fe\\u7247\",\"ver\":1,\"pos\":30,\"type\":\"string\",\"unit\":\"none\",\"affect\":2,\"readonly\":false,\"visible\":true,\"enabled\":true,\"size\":30,\"cur\":\"\\u53cc\\u9762\",\"default\":\"\\u53cc\\u9762\",\"range\":[\"\\u6b63\\u9762\",\"\\u80cc\\u9762\",\"\\u53cc\\u9762\"],\"depend_or\":[\"fb-split==true\"]}}");
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -20,7 +20,7 @@ img_one_paper* cis_montager(img_one_paper* in)
for(auto& v: in->images_queue()) for(auto& v: in->images_queue())
{ {
// 0x00090002 GetMergeMat(int dstwidth ,int dstheight,int type,cv::Mat& mat,unsigned int fpgaversion) // 0x00090002 GetMergeMat(int dstwidth ,int dstheight,int type,cv::Mat& mat,unsigned int fpgaversion)
v.img = GetMergeMat(v.head.width * v.head.channels, v.head.height, v.head.channels == 1 ? CV_8UC1 : CV_8UC3, v.img, 0x00090001); v.img = GetMergeMat(v.head.width, v.head.height, v.head.channels == 1 ? CV_8UC1 : CV_8UC3, v.img, 0x00090001);
v.head.width = v.img.cols; v.head.width = v.img.cols;
v.head.height = v.img.rows; v.head.height = v.img.rows;
} }
@ -34,14 +34,49 @@ img_one_paper* cis_spliter(img_one_paper* in)
for(auto& v: in->images_queue()) for(auto& v: in->images_queue())
{ {
if(v.head.pos.paper_side == PAPER_SIDE_LEFT) if(v.head.pos.paper_side == PAPER_SIDE_LEFT ||
v.head.pos.paper_side == PAPER_SIDE_RIGHT)
{ {
int actwidth = v.img.cols / 2; int actwidth = v.img.cols / 2;
int actheight = v.img.rows; int actheight = v.img.rows;
int off[] = {0, 1};
if(v.head.pos.paper_side == PAPER_SIDE_RIGHT)
{
off[0] = 1;
off[1] = 0;
}
for (int i = 0; i < 2; i++) for (int i = 0; i < 2; i++)
{ {
PROCIMG ii; PROCIMG ii;
ii.img = v.img(cv::Rect(i * actwidth, 0, actwidth, actheight)); ii.img = v.img(cv::Rect(off[i] * actwidth, 0, actwidth, actheight));
if (!ii.img.empty())
{
memcpy(&ii.head, &v.head, sizeof(ii.head));
ii.head.width = v.img.cols;
ii.head.height = v.img.rows;
ii.head.pos.paper_side = i == 0 ? PAPER_SIDE_FRONT : PAPER_SIDE_BACK;
result.push_back(ii);
}
}
}
else if(v.head.pos.paper_side == PAPER_SIDE_TOP ||
v.head.pos.paper_side == PAPER_SIDE_BOTTOM)
{
int actwidth = v.img.cols;
int actheight = v.img.rows / 2;
int off[] = {0, 1};
if(v.head.pos.paper_side == PAPER_SIDE_RIGHT)
{
off[0] = 1;
off[1] = 0;
}
for (int i = 0; i < 2; i++)
{
PROCIMG ii;
ii.img = v.img(cv::Rect(0, off[i] * actheight, actwidth, actheight));
if (!ii.img.empty()) if (!ii.img.empty())
{ {
memcpy(&ii.head, &v.head, sizeof(ii.head)); memcpy(&ii.head, &v.head, sizeof(ii.head));
@ -67,7 +102,7 @@ img_one_paper* cis_spliter(img_one_paper* in)
cis_pre_do::cis_pre_do(std::function<img_one_paper* (img_one_paper*)> montage cis_pre_do::cis_pre_do(std::function<img_one_paper* (img_one_paper*)> montage
, std::function< img_one_paper* (img_one_paper*)> split) , std::function< img_one_paper* (img_one_paper*)> split)
: montage_(montage), split_(split) : montage_(montage), split_(split)
, cfg_(g_cis_cfg), is_montage_(true), is_split_(true) , cfg_(g_cis_cfg), is_montage_(true), is_split_(true), page_(PAGE_DUPLEX), cis_dpi_(200)
{ {
if (!montage_) if (!montage_)
montage_ = cis_montager; montage_ = cis_montager;
@ -114,9 +149,41 @@ void cis_pre_do::init_value(void)
is_split_ = true; is_split_ = true;
child->release(); child->release();
} }
if (jsn->get_value("page", child) && child)
{
std::string val("");
if (child->get_value("cur", val))
{
if(val == "\xE6\xAD\xA3\xE9\x9D\xA2")
page_ = PAGE_FRONT;
else if(val == "\xE8\x83\x8c\xE9\x9D\xA2")
page_ = PAGE_BACK;
else
page_ = PAGE_DUPLEX;
}
printf("current page: %d(%s)\n", page_, val.c_str());
child->release();
}
jsn->release(); jsn->release();
} }
} }
void cis_pre_do::resize(cv::Mat& img, float ratio_h, float ratio_v)
{
if(cis_dpi_ == 200)
{
cv::resize(img, img, cv::Size(0, 0), 200.0 / 300.0 * ratio_h, ratio_v);
}
else if(cis_dpi_ == 300)
{
if(!IS_FLOAT_EQUAL(ratio_h, 1.0f) ||
!IS_FLOAT_EQUAL(ratio_v, 1.0f))
cv::resize(img, img, cv::Size(0, 0), ratio_h, ratio_v);
}
else
{
cv::resize(img, img, cv::Size(0, 0), ratio_h, 1.432323f * ratio_v);
}
}
int32_t cis_pre_do::get_config(void* buf, size_t* len, const char* cfg_name, std::string* strval) int32_t cis_pre_do::get_config(void* buf, size_t* len, const char* cfg_name, std::string* strval)
{ {
@ -161,10 +228,21 @@ int32_t cis_pre_do::set_config(const char* cfg_name, void* data, size_t* len, ui
bool cis_pre_do::update_enabled(const char* name, std::function<GET_SANE_OPT_PROTO> get_opt) bool cis_pre_do::update_enabled(const char* name, std::function<GET_SANE_OPT_PROTO> get_opt)
{ {
gb_json* root = new gb_json(); gb_json* root = new gb_json();
std::string val("");
if(get_opt("cis-dpi", "cur", val, nullptr) == 0)
cis_dpi_ = *(int*)val.c_str();
printf("cis-dpi = %d\n", cis_dpi_);
if(root->attach_text(&cfg_[0])) if(root->attach_text(&cfg_[0]))
{ {
sane_cfg_provider::update_option_enable_status(root, get_opt); gb_json* child = root->first_child();
while(child)
{
sane_cfg_provider::update_option_enable_status(child, get_opt);
child->release();
child = root->next_child();
}
cfg_ = std::move(root->to_string()); cfg_ = std::move(root->to_string());
} }
@ -197,17 +275,36 @@ img_one_paper* cis_pre_do::execute(img_one_paper* img)
if(is_montage_) if(is_montage_)
{ {
printf("montage ...\n");
img_one_paper* mont = montage_(img); img_one_paper* mont = montage_(img);
img->release(); img->release();
img = mont; img = mont;
} }
for(auto& v: img->images_queue())
{
resize(v.img, img->get_cis_ratio_h(), img->get_cis_ratio_v());
v.head.width = v.img.cols;
v.head.height = v.img.rows;
}
if(is_split_) if(is_split_)
{ {
printf("split ...\n");
img_one_paper* sp = split_(img); img_one_paper* sp = split_(img);
img->release(); img->release();
img = sp; img = sp;
if(page_ == PAGE_FRONT || page_ == PAGE_BACK)
{
int side = page_ == PAGE_FRONT ? PAPER_SIDE_FRONT : PAPER_SIDE_BACK;
for(int i = 0; i < img->images_queue().size(); ++i)
{
if(img->images_queue()[i].head.pos.paper_side != side)
{
img->images_queue().erase(img->images_queue().begin() + i);
i--;
}
}
}
} }
return img; return img;

32
device/gxx-linux/usb/src/async_model/img_process/cis_preproc.h
View File

@ -29,7 +29,7 @@ class gb_json;
// "default": true // "default": true
// }, // },
// "fb-split": { // "fb-split": {
// "cat": "cis", // "cat": "CIS",
// "group": "CIS", // "group": "CIS",
// "title": "拆分正反面", // "title": "拆分正反面",
// "desc": "将正反面合成的一张图片拆分成正面和反面图片", // "desc": "将正反面合成的一张图片拆分成正面和反面图片",
@ -37,13 +37,32 @@ class gb_json;
// "pos": 20, // "pos": 20,
// "type": "bool", // "type": "bool",
// "unit": "none", // "unit": "none",
// "affect": 0, // "affect": 2,
// "readonly": false, // "readonly": false,
// "visible": false, // "visible": false,
// "enabled": true, // "enabled": true,
// "size": 4, // "size": 4,
// "cur": true, // "cur": true,
// "default": true // "default": true
// },
// "page": {
// "cat": "CIS",
// "group": "base",
// "title": "页面",
// "desc": "获取纸张指定面的图片",
// "ver": 1,
// "pos": 30,
// "type": "string",
// "unit": "none",
// "affect": 2,
// "readonly": false,
// "visible": true,
// "enabled": true,
// "size": 30,
// "cur": "双面",
// "default": "双面",
// "range": ["正面", "背面", "双面"],
// "depend_or": ["fb-split==true"]
// } // }
// } // }
@ -52,12 +71,21 @@ class cis_pre_do : public sane_cfg_provider
std::string cfg_; std::string cfg_;
bool is_montage_; bool is_montage_;
bool is_split_; bool is_split_;
enum
{
PAGE_FRONT = 0,
PAGE_BACK,
PAGE_DUPLEX,
};
int page_;
int cis_dpi_;
std::function<img_one_paper* (img_one_paper*)> montage_; std::function<img_one_paper* (img_one_paper*)> montage_;
std::function<img_one_paper* (img_one_paper*)> split_; std::function<img_one_paper* (img_one_paper*)> split_;
gb_json* from_json_text(char* jsn_text = nullptr); gb_json* from_json_text(char* jsn_text = nullptr);
void init_value(void); void init_value(void);
void resize(cv::Mat& img, float ratio_h = 1.0f, float ratio_v = 1.0f);
public: public:
cis_pre_do(std::function<img_one_paper*(img_one_paper*)> montage = std::function<img_one_paper* (img_one_paper*)>() cis_pre_do(std::function<img_one_paper*(img_one_paper*)> montage = std::function<img_one_paper* (img_one_paper*)>()

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

@ -45,9 +45,10 @@ usb_gadget* usb_gadget_config::get_config(void)
static void print_mem_usage(const char* tips) static void print_mem_usage(const char* tips)
{ {
uint64_t size = sys_util::get_memory_usage("scan"); // uint64_t size = sys_util::get_memory_usage("scan");
printf("\n--Memory usage of %s: %s--\n", tips, sys_util::format_readable_bytes(size).c_str()); // printf("\n--Memory usage of %s: %s--\n", tips, sys_util::format_readable_bytes(size).c_str());
log_cls::log_memory_usage(tips, true);
} }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// async_usb_gadget // async_usb_gadget

12
device/gxx-linux/usb/src/async_model/scanner/async_scanner.cpp
View File

@ -25,12 +25,12 @@ extern int32_t (*scan_start)(void);
extern int32_t (*scan_stop)(void); extern int32_t (*scan_stop)(void);
extern int32_t (*set_dpi)(int*, int*); extern int32_t (*set_dpi)(int*, int*);
extern int32_t (*set_scan_num)(int); extern int32_t (*set_scan_num)(int);
extern int32_t (*set_image_receiver)(void(*rcv)(int data_type, void* data, size_t w, size_t h, int dpi_x, int dpi_y, size_t paper_ind, paper_side side, clr_channel clr, img_status status, bool img_new, bool img_over, void* param), void* param); extern int32_t (*set_image_receiver)(void(*rcv)(int data_type, void* data, size_t w, size_t h, int dpi_x, int dpi_y, 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);
static bool reg_img_cb = true; static bool reg_img_cb = true;
static void push_image(int data_type, void* data, size_t w, size_t h, int dpi_x, int dpi_y, size_t paper_ind, paper_side side, clr_channel clr, img_status status, bool img_new, bool img_over, void* param) static void push_image(int data_type, void* data, size_t w, size_t h, int dpi_x, int dpi_y, 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)
{ {
((async_scanner*)param)->push_image(data_type, data, w, h, dpi_x, dpi_y, paper_ind, side, clr, status, img_new, img_over); ((async_scanner*)param)->push_image(data_type, data, w, h, dpi_x, dpi_y, paper_ind, side, clr, status, img_new, img_over, ratio_h, ratio_v);
} }
#endif #endif
@ -121,7 +121,7 @@ async_scanner::~async_scanner()
cfg_mgr_->release(); cfg_mgr_->release();
} }
void async_scanner::push_image(int data_type, void* data, size_t w, size_t h, int dpi_x, int dpi_y, size_t paper_ind, paper_side side, clr_channel clr, img_status status, bool img_new, bool img_over) void async_scanner::push_image(int data_type, void* data, size_t w, size_t h, int dpi_x, int dpi_y, 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)
{ {
if(data_type == IMG_CB_STOPPED) if(data_type == IMG_CB_STOPPED)
{ {
@ -235,9 +235,9 @@ void async_scanner::init(void)
cfg_mgr_->reg_sane_provider(dynamic_cast<sane_cfg_provider*>(r)); cfg_mgr_->reg_sane_provider(dynamic_cast<sane_cfg_provider*>(r));
r->release(); r->release();
auto on_image_captured = [&](int data_type, void* data, size_t w, size_t h, int dpi_x, int dpi_y, size_t paper_ind, paper_side side, clr_channel clr, img_status status, bool img_new, bool img_over) -> void auto on_image_captured = [&](int data_type, void* data, size_t w, size_t h, int dpi_x, int dpi_y, 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
{ {
push_image(data_type, data, w, h, dpi_x, dpi_y, paper_ind, side, clr, status, img_new, img_over); push_image(data_type, data, w, h, dpi_x, dpi_y, paper_ind, side, clr, status, img_new, img_over, ratio_h, ratio_v);
}; };
capture_ = new image_capture(on_image_captured); capture_ = new image_capture(on_image_captured);
cfg_mgr_->reg_sane_provider(dynamic_cast<sane_cfg_provider*>(capture_)); cfg_mgr_->reg_sane_provider(dynamic_cast<sane_cfg_provider*>(capture_));

2
device/gxx-linux/usb/src/async_model/scanner/async_scanner.h
View File

@ -58,7 +58,7 @@ public:
// virtual int32_t set_config(const char* cfg_name, void* data, size_t* len, uint32_t* afterdo) override; // virtual int32_t set_config(const char* cfg_name, void* data, size_t* len, uint32_t* afterdo) override;
// virtual void update_enabled(std::function<GET_SANE_OPT_PROTO> get_opt) override; // virtual void update_enabled(std::function<GET_SANE_OPT_PROTO> get_opt) override;
// virtual int32_t get_value(const char* name, const char* key, std::string& val) override; // virtual int32_t get_value(const char* name, const char* key, std::string& val) override;
void push_image(int data_type, void* data, size_t w, size_t h, int dpi_x, int dpi_y, size_t paper_ind, paper_side side, clr_channel clr, img_status status, bool img_new, bool img_over); void push_image(int data_type, void* data, size_t w, size_t h, int dpi_x, int dpi_y, 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);
public: public:
uint32_t stop(void); uint32_t stop(void);

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

@ -25,9 +25,17 @@ int32_t (*set_scan_num)(int) = nullptr;
int32_t (*set_paper_type)(int) = nullptr; int32_t (*set_paper_type)(int) = nullptr;
int32_t (*set_pixel_type)(int*) = nullptr; int32_t (*set_pixel_type)(int*) = nullptr;
int32_t (*set_capturer_param)(int, int, 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, void* param), void* param) = 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;
#endif #endif
#else
#define LOG_LEVEL_ALL 0
namespace log_cls
{
template<typename ... Args>
void log(int level, const char* fmt, Args ... args)
{}
}
#endif #endif
#define CONFIG_VALUE 1 #define CONFIG_VALUE 1
@ -106,7 +114,7 @@ int32_t call_set_capturer_param(int type, int ind, int val)
{ {
return inst->set_capturer_parameter(type, ind, val); return inst->set_capturer_parameter(type, ind, val);
} }
int32_t call_set_image_receiver(void(*rcv)(int data_type, void* data, size_t w, size_t h, int dpi_x, int dpi_y, size_t paper_ind, paper_side side, clr_channel clr, img_status status, bool img_new, bool img_over, void* param), void* param) int32_t call_set_image_receiver(void(*rcv)(int data_type, void* data, size_t w, size_t h, int dpi_x, int dpi_y, 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)
{ {
return inst->set_img_receiver((void*)rcv, param); return inst->set_img_receiver((void*)rcv, param);
} }
@ -222,7 +230,9 @@ void UsbDevice::fill_if_descriptor(camtp_ctx * ctx, usb_gadget * usbctx, struct
desc->iInterface = STRINGID_INTERFACE; desc->iInterface = STRINGID_INTERFACE;
} }
#ifdef ASYNC_EP
log_cls::log(LOG_LEVEL_ALL, "fill_if_descriptor:\n"); log_cls::log(LOG_LEVEL_ALL, "fill_if_descriptor:\n");
#endif
PRINT_DEBUG_BUF(desc, sizeof(struct usb_interface_descriptor)); PRINT_DEBUG_BUF(desc, sizeof(struct usb_interface_descriptor));
return; return;
@ -271,8 +281,9 @@ void UsbDevice::fill_ep_descriptor(camtp_ctx * ctx, usb_gadget * usbctx,struct u
} }
} }
#endif #endif
#ifdef ASYNC_EP
log_cls::log(LOG_LEVEL_ALL, "fill_ep_descriptor:\n"); log_cls::log(LOG_LEVEL_ALL, "fill_ep_descriptor:\n");
#endif
PRINT_DEBUG_BUF(desc, sizeof(struct usb_endpoint_descriptor_no_audio)); PRINT_DEBUG_BUF(desc, sizeof(struct usb_endpoint_descriptor_no_audio));
return; return;
@ -331,7 +342,9 @@ void UsbDevice::fill_config_descriptor(camtp_ctx * ctx , usb_gadget * usbctx,str
desc->bmAttributes = USB_CONFIG_ATT_ONE; desc->bmAttributes = USB_CONFIG_ATT_ONE;
desc->bMaxPower = 1; desc->bMaxPower = 1;
#ifdef ASYNC_EP
log_cls::log(LOG_LEVEL_ALL, "fill_config_descriptor: (Total Len : %u + %d = %d)\n", (unsigned int) sizeof(struct usb_config_descriptor), total_size, desc->wTotalLength); log_cls::log(LOG_LEVEL_ALL, "fill_config_descriptor: (Total Len : %u + %d = %d)\n", (unsigned int) sizeof(struct usb_config_descriptor), total_size, desc->wTotalLength);
#endif
PRINT_DEBUG_BUF(desc, sizeof(struct usb_config_descriptor)); PRINT_DEBUG_BUF(desc, sizeof(struct usb_config_descriptor));
return; return;
@ -355,7 +368,9 @@ void UsbDevice::fill_dev_descriptor(camtp_ctx * ctx, usb_gadget * usbctx,struct
desc->iSerialNumber = STRINGID_SERIAL; desc->iSerialNumber = STRINGID_SERIAL;
desc->bNumConfigurations = 1; // Only one configuration desc->bNumConfigurations = 1; // Only one configuration
#ifdef ASYNC_EP
log_cls::log(LOG_LEVEL_ALL, "fill_dev_descriptor:\n"); log_cls::log(LOG_LEVEL_ALL, "fill_dev_descriptor:\n");
#endif
PRINT_DEBUG_BUF(desc, sizeof(struct usb_device_descriptor)); PRINT_DEBUG_BUF(desc, sizeof(struct usb_device_descriptor));
return; return;
@ -540,7 +555,9 @@ usb_gadget* UsbDevice::init_usb_camtp_gadget(camtp_ctx * ctx)
usbctx->ep_path[2] = ctx->usb_cfg.usb_endpoint_intin; usbctx->ep_path[2] = ctx->usb_cfg.usb_endpoint_intin;
usbctx->usb_device = open(ctx->usb_cfg.usb_device_path, O_RDWR|O_SYNC); usbctx->usb_device = open(ctx->usb_cfg.usb_device_path, O_RDWR|O_SYNC);
#ifdef ASYNC_EP
log_cls::log(LOG_LEVEL_ALL, "USB device: open(%s) = %d (%d)\n", ctx->usb_cfg.usb_device_path, usbctx->usb_device, usbctx->usb_device == -1 ? errno : 0); log_cls::log(LOG_LEVEL_ALL, "USB device: open(%s) = %d (%d)\n", ctx->usb_cfg.usb_device_path, usbctx->usb_device, usbctx->usb_device == -1 ? errno : 0);
#endif
// std::this_thread::sleep_for(std::chrono::milliseconds(15000)); // std::this_thread::sleep_for(std::chrono::milliseconds(15000));
// printf("USB device: go on ^_^\n"); // printf("USB device: go on ^_^\n");
@ -608,8 +625,9 @@ usb_gadget* UsbDevice::init_usb_camtp_gadget(camtp_ctx * ctx)
fill_ep_descriptor(ctx, usbctx, &usbctx->usb_ffs_config->ep_desc_ss.ep_desc_out,2, EP_BULK_MODE | EP_OUT_DIR | EP_SS_MODE); fill_ep_descriptor(ctx, usbctx, &usbctx->usb_ffs_config->ep_desc_ss.ep_desc_out,2, EP_BULK_MODE | EP_OUT_DIR | EP_SS_MODE);
fill_ep_descriptor(ctx, usbctx, &usbctx->usb_ffs_config->ep_desc_ss.ep_desc_int_in,3, EP_INT_MODE | EP_IN_DIR | EP_SS_MODE); fill_ep_descriptor(ctx, usbctx, &usbctx->usb_ffs_config->ep_desc_ss.ep_desc_int_in,3, EP_INT_MODE | EP_IN_DIR | EP_SS_MODE);
#endif #endif
#ifdef ASYNC_EP
log_cls::log(LOG_LEVEL_ALL, "init_usb_camtp_gadget :\n"); log_cls::log(LOG_LEVEL_ALL, "init_usb_camtp_gadget :\n");
#endif
PRINT_DEBUG_BUF(usbctx->usb_ffs_config, sizeof(usb_ffs_cfg)); PRINT_DEBUG_BUF(usbctx->usb_ffs_config, sizeof(usb_ffs_cfg));
ret = write(usbctx->usb_device, usbctx->usb_ffs_config, sizeof(usb_ffs_cfg)); ret = write(usbctx->usb_device, usbctx->usb_ffs_config, sizeof(usb_ffs_cfg));
@ -627,8 +645,9 @@ usb_gadget* UsbDevice::init_usb_camtp_gadget(camtp_ctx * ctx)
ffs_str.header.lang_count = htole32(1); ffs_str.header.lang_count = htole32(1);
ffs_str.code = htole16(0x0409); // en-us ffs_str.code = htole16(0x0409); // en-us
strcpy(ffs_str.string_data,ctx->usb_cfg.usb_string_interface); strcpy(ffs_str.string_data,ctx->usb_cfg.usb_string_interface);
#ifdef ASYNC_EP
log_cls::log(LOG_LEVEL_ALL, "write string :\n"); log_cls::log(LOG_LEVEL_ALL, "write string :\n");
#endif
PRINT_DEBUG_BUF(&ffs_str, sizeof(ffs_strings)); PRINT_DEBUG_BUF(&ffs_str, sizeof(ffs_strings));
ret = write(usbctx->usb_device, &ffs_str, ffs_str.header.length); ret = write(usbctx->usb_device, &ffs_str, ffs_str.header.length);
@ -674,8 +693,9 @@ usb_gadget* UsbDevice::init_usb_camtp_gadget(camtp_ctx * ctx)
#endif #endif
fill_dev_descriptor(ctx, usbctx,&usbctx->usb_config->dev_desc); fill_dev_descriptor(ctx, usbctx,&usbctx->usb_config->dev_desc);
#ifdef ASYNC_EP
log_cls::log(LOG_LEVEL_ALL, "init_usb_camtp_gadget :\n"); log_cls::log(LOG_LEVEL_ALL, "init_usb_camtp_gadget :\n");
#endif
PRINT_DEBUG_BUF(usbctx->usb_config, sizeof(usb_cfg)); PRINT_DEBUG_BUF(usbctx->usb_config, sizeof(usb_cfg));
ret = write(usbctx->usb_device, usbctx->usb_config, sizeof(usb_cfg)); ret = write(usbctx->usb_device, usbctx->usb_config, sizeof(usb_cfg));
@ -686,8 +706,9 @@ usb_gadget* UsbDevice::init_usb_camtp_gadget(camtp_ctx * ctx)
goto init_error; goto init_error;
} }
} }
#ifdef ASYNC_EP
log_cls::log(LOG_LEVEL_ALL, "init_usb_camtp_gadget : USB config done\n"); log_cls::log(LOG_LEVEL_ALL, "init_usb_camtp_gadget : USB config done\n");
#endif
printf("init usb ok!\n"); printf("init usb ok!\n");
return usbctx; return usbctx;
@ -704,9 +725,9 @@ init_error:
void UsbDevice::deinit_usb_camtp_gadget(usb_gadget * usbctx) void UsbDevice::deinit_usb_camtp_gadget(usb_gadget * usbctx)
{ {
int i; int i;
#ifdef ASYNC_EP
log_cls::log(LOG_LEVEL_ALL, "entering deinit_usb_camtp_gadget\n"); log_cls::log(LOG_LEVEL_ALL, "entering deinit_usb_camtp_gadget\n");
#endif
if( usbctx ) if( usbctx )
{ {
usbctx->stop = 1; usbctx->stop = 1;
@ -717,7 +738,9 @@ void UsbDevice::deinit_usb_camtp_gadget(usb_gadget * usbctx)
if( usbctx->ep_handles[i] >= 0 ) if( usbctx->ep_handles[i] >= 0 )
{ {
#ifdef ASYNC_EP
log_cls::log(LOG_LEVEL_ALL, "Closing End Point %d...\n",i); log_cls::log(LOG_LEVEL_ALL, "Closing End Point %d...\n",i);
#endif
close(usbctx->ep_handles[i] ); close(usbctx->ep_handles[i] );
} }
i++; i++;
@ -725,7 +748,9 @@ void UsbDevice::deinit_usb_camtp_gadget(usb_gadget * usbctx)
if (usbctx->usb_device >= 0) if (usbctx->usb_device >= 0)
{ {
#ifdef ASYNC_EP
log_cls::log(LOG_LEVEL_ALL, "Closing usb device...\n"); log_cls::log(LOG_LEVEL_ALL, "Closing usb device...\n");
#endif
printf("close USB device(%d)\n", usbctx->usb_device); printf("close USB device(%d)\n", usbctx->usb_device);
close(usbctx->usb_device); close(usbctx->usb_device);
usbctx->usb_device = - 1; usbctx->usb_device = - 1;
@ -733,7 +758,9 @@ void UsbDevice::deinit_usb_camtp_gadget(usb_gadget * usbctx)
if( !usbctx->thread_not_started ) if( !usbctx->thread_not_started )
{ {
#ifdef ASYNC_EP
log_cls::log(LOG_LEVEL_ALL, "Stopping USB Thread...\n"); log_cls::log(LOG_LEVEL_ALL, "Stopping USB Thread...\n");
#endif
pthread_cancel (usbctx->thread); pthread_cancel (usbctx->thread);
pthread_join(usbctx->thread, NULL); pthread_join(usbctx->thread, NULL);
usbctx->thread_not_started = 1; usbctx->thread_not_started = 1;
@ -769,8 +796,9 @@ void UsbDevice::deinit_usb_camtp_gadget(usb_gadget * usbctx)
free( usbctx ); free( usbctx );
} }
#ifdef ASYNC_EP
log_cls::log(LOG_LEVEL_ALL, "leaving deinit_usb_camtp_gadget\n"); log_cls::log(LOG_LEVEL_ALL, "leaving deinit_usb_camtp_gadget\n");
#endif
} }
void UsbDevice::usb_main() void UsbDevice::usb_main()
@ -793,12 +821,16 @@ void UsbDevice::usb_main()
printf("function mode: %d\n", camtp_context->usb_cfg.usb_functionfs_mode); printf("function mode: %d\n", camtp_context->usb_cfg.usb_functionfs_mode);
if (camtp_context->usb_cfg.usb_functionfs_mode) if (camtp_context->usb_cfg.usb_functionfs_mode)
{ {
#ifdef ASYNC_EP
log_cls::log(LOG_LEVEL_ALL, "CAMTP Responder : FunctionFS Mode - entering handle_ffs_ep0\n"); log_cls::log(LOG_LEVEL_ALL, "CAMTP Responder : FunctionFS Mode - entering handle_ffs_ep0\n");
#endif
handle_ffs_ep0(usb_ctx); handle_ffs_ep0(usb_ctx);
} }
else else
{ {
#ifdef ASYNC_EP
log_cls::log(LOG_LEVEL_ALL, "CAMTP Responder : GadgetFS Mode - entering handle_ep0\n"); log_cls::log(LOG_LEVEL_ALL, "CAMTP Responder : GadgetFS Mode - entering handle_ep0\n");
#endif
handle_ep0(usb_ctx); handle_ep0(usb_ctx);
} }
deinit_usb_camtp_gadget(usb_ctx); deinit_usb_camtp_gadget(usb_ctx);
@ -824,8 +856,9 @@ int UsbDevice::handle_ffs_ep0(usb_gadget * ctx)
fd_set read_set; fd_set read_set;
struct usb_functionfs_event event; struct usb_functionfs_event event;
int status; int status;
#ifdef ASYNC_EP
log_cls::log(LOG_LEVEL_ALL, "handle_ffs_ep0 : Entering...\n"); log_cls::log(LOG_LEVEL_ALL, "handle_ffs_ep0 : Entering...\n");
#endif
timeout.tv_sec = 40; timeout.tv_sec = 40;
timeout.tv_usec = 0; timeout.tv_usec = 0;
@ -842,7 +875,9 @@ int UsbDevice::handle_ffs_ep0(usb_gadget * ctx)
} }
else else
{ {
#ifdef ASYNC_EP
log_cls::log(LOG_LEVEL_ALL, "Select without timeout\n"); log_cls::log(LOG_LEVEL_ALL, "Select without timeout\n");
#endif
ret = select(ctx->usb_device+1, &read_set, NULL, NULL, NULL); ret = select(ctx->usb_device+1, &read_set, NULL, NULL, NULL);
} }
@ -862,16 +897,18 @@ int UsbDevice::handle_ffs_ep0(usb_gadget * ctx)
} }
nevents = ret / sizeof(event); nevents = ret / sizeof(event);
#ifdef ASYNC_EP
log_cls::log(LOG_LEVEL_ALL, "%d event(s)\n", nevents); log_cls::log(LOG_LEVEL_ALL, "%d event(s)\n", nevents);
#endif
printf("event type = %d\n", event.type); printf("event type = %d\n", event.type);
for (i=0; i<nevents; i++) for (i=0; i<nevents; i++)
{ {
switch (event.type) switch (event.type)
{ {
case FUNCTIONFS_ENABLE: case FUNCTIONFS_ENABLE:
#ifdef ASYNC_EP
log_cls::log(LOG_LEVEL_ALL, "EP0 FFS ENABLE\n"); log_cls::log(LOG_LEVEL_ALL, "EP0 FFS ENABLE\n");
#endif
//!< nick usb on //!< nick usb on
b_connected = true; b_connected = true;
if(connect_call) if(connect_call)
@ -886,7 +923,9 @@ int UsbDevice::handle_ffs_ep0(usb_gadget * ctx)
break; break;
case FUNCTIONFS_DISABLE: case FUNCTIONFS_DISABLE:
#ifdef ASYNC_EP
log_cls::log(LOG_LEVEL_ALL, "EP0 FFS DISABLE\n"); log_cls::log(LOG_LEVEL_ALL, "EP0 FFS DISABLE\n");
#endif
b_connected = false; b_connected = false;
//printf(" USB DISCONNECTED\n"); //printf(" USB DISCONNECTED\n");
if(connect_call) if(connect_call)
@ -927,20 +966,30 @@ int UsbDevice::handle_ffs_ep0(usb_gadget * ctx)
break; break;
case FUNCTIONFS_SETUP: case FUNCTIONFS_SETUP:
#ifdef ASYNC_EP
log_cls::log(LOG_LEVEL_ALL, "EP0 FFS SETUP\n"); log_cls::log(LOG_LEVEL_ALL, "EP0 FFS SETUP\n");
#endif
handle_setup_request(ctx, &event.u.setup); handle_setup_request(ctx, &event.u.setup);
break; break;
case FUNCTIONFS_BIND: case FUNCTIONFS_BIND:
#ifdef ASYNC_EP
log_cls::log(LOG_LEVEL_ALL, "EP0 FFS BIND\n"); log_cls::log(LOG_LEVEL_ALL, "EP0 FFS BIND\n");
#endif
break; break;
case FUNCTIONFS_UNBIND: case FUNCTIONFS_UNBIND:
#ifdef ASYNC_EP
log_cls::log(LOG_LEVEL_ALL, "EP0 FFS UNBIND\n"); log_cls::log(LOG_LEVEL_ALL, "EP0 FFS UNBIND\n");
#endif
break; break;
case FUNCTIONFS_SUSPEND: case FUNCTIONFS_SUSPEND:
#ifdef ASYNC_EP
log_cls::log(LOG_LEVEL_ALL, "EP0 FFS SUSPEND\n"); log_cls::log(LOG_LEVEL_ALL, "EP0 FFS SUSPEND\n");
#endif
break; break;
case FUNCTIONFS_RESUME: case FUNCTIONFS_RESUME:
#ifdef ASYNC_EP
log_cls::log(LOG_LEVEL_ALL, "EP0 FFS RESUME\n"); log_cls::log(LOG_LEVEL_ALL, "EP0 FFS RESUME\n");
#endif
break; break;
} }
} }
@ -949,7 +998,9 @@ int UsbDevice::handle_ffs_ep0(usb_gadget * ctx)
ctx->stop = 1; ctx->stop = 1;
end: end:
#ifdef ASYNC_EP
log_cls::log(LOG_LEVEL_ALL, "handle_ffs_ep0 : Leaving... (ctx->stop=%d)\n",ctx->stop); log_cls::log(LOG_LEVEL_ALL, "handle_ffs_ep0 : Leaving... (ctx->stop=%d)\n",ctx->stop);
#endif
return 1; return 1;
} }

19
device/gxx-linux/usb/usbimageprocqueue.h
View File

@ -18,6 +18,8 @@ class UsbImageProcQueue
int scan_status_; int scan_status_;
int dpi_x_; int dpi_x_;
int dpi_y_; int dpi_y_;
float ratio_h_;
float ratio_v_;
int sensor_status_2_scanner_status(int ss) int sensor_status_2_scanner_status(int ss)
{ {
@ -52,7 +54,7 @@ class UsbImageProcQueue
} }
public: public:
UsbImageProcQueue(NotifyPtr notify) : img_keeper_(nullptr), kp_param_(nullptr), scan_status_(0), dpi_x_(200), dpi_y_(200) UsbImageProcQueue(NotifyPtr notify) : img_keeper_(nullptr), kp_param_(nullptr), scan_status_(0), dpi_x_(200), dpi_y_(200), ratio_h_(1.0f), ratio_v_(1.0f)
{ {
this->notify = notify; this->notify = notify;
} }
@ -61,20 +63,20 @@ public:
{ {
if(!containsimg) if(!containsimg)
{ {
void (*push_image)(int data_type, void* data, size_t w, size_t h, int dpi_x, int dpi_y, size_t paper_ind, paper_side side, clr_channel clr, img_status status, bool img_new, bool img_over, void* param) = nullptr; void (*push_image)(int data_type, void* data, size_t w, size_t h, int dpi_x, int dpi_y, 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) = nullptr;
HGIntInfo* info = (HGIntInfo*)image->data(); HGIntInfo* info = (HGIntInfo*)image->data();
*(uint64_t*)&push_image = (uint64_t)img_keeper_; *(uint64_t*)&push_image = (uint64_t)img_keeper_;
if(info->From == HGType::STOPSCAN) if(info->From == HGType::STOPSCAN)
{ {
if(push_image) if(push_image)
push_image(IMG_CB_STOPPED, nullptr, sensor_status_2_scanner_status(info->Code), 0, dpi_x_, dpi_y_, 0, PAPER_SIDE_LEFT, (clr_channel)0, (img_status)0, true, true, kp_param_); push_image(IMG_CB_STOPPED, nullptr, sensor_status_2_scanner_status(info->Code), 0, dpi_x_, dpi_y_, 0, PAPER_SIDE_LEFT, (clr_channel)0, (img_status)0, true, true, ratio_h_, ratio_v_, kp_param_);
} }
else else
{ {
scan_status_ = sensor_status_2_scanner_status(info->Code); scan_status_ = sensor_status_2_scanner_status(info->Code);
if(push_image) if(push_image)
push_image(IMG_CB_STATUS, nullptr, sensor_status_2_scanner_status(info->Code), 0, dpi_x_, dpi_y_, 0, PAPER_SIDE_LEFT, (clr_channel)0, (img_status)0, true, true, kp_param_); push_image(IMG_CB_STATUS, nullptr, sensor_status_2_scanner_status(info->Code), 0, dpi_x_, dpi_y_, 0, PAPER_SIDE_LEFT, (clr_channel)0, (img_status)0, true, true, ratio_h_, ratio_v_, kp_param_);
} }
} }
return; return;
@ -107,12 +109,12 @@ public:
if(scannnum == 1) if(scannnum == 1)
scan_status_ = 0; scan_status_ = 0;
void (*push_image)(int data_type, void* data, size_t w, size_t h, int dpi_x, int dpi_y, size_t paper_ind, paper_side side, clr_channel clr, img_status status, bool img_new, bool img_over, void* param) = nullptr; void (*push_image)(int data_type, void* data, size_t w, size_t h, int dpi_x, int dpi_y, 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) = nullptr;
*(uint64_t*)&push_image = (uint64_t)img_keeper_; *(uint64_t*)&push_image = (uint64_t)img_keeper_;
if(push_image) if(push_image)
{ {
push_image(IMG_CB_IMAGE, data, width, height, dpi_x_, dpi_y_, scannnum, PAPER_SIDE_LEFT, (clr_channel)type, (img_status)status, true, true, kp_param_); push_image(IMG_CB_IMAGE, data, width, height, dpi_x_, dpi_y_, scannnum, PAPER_SIDE_LEFT, (clr_channel)type, (img_status)status, true, true, ratio_h_, ratio_v_, kp_param_);
return true; return true;
} }
@ -178,6 +180,11 @@ public:
//return (images.Size()>0) ? 0 : images.Front()->size(); //return (images.Size()>0) ? 0 : images.Front()->size();
} }
void set_ratio(float h, float v)
{
ratio_h_ = h;
ratio_v_ = v;
}
void clear() void clear()
{ {