2022-05-03 03:56:07 +00:00
# include " hg_scanner.h "
2022-05-30 03:04:26 +00:00
# include "../wrapper/hg_log.h"
2022-05-09 08:59:22 +00:00
# include "sane/sane_option_definitions.h"
2022-05-03 03:56:07 +00:00
# ifdef WIN32
# include "scanner_manager.h"
2022-05-10 00:27:31 +00:00
# include <direct.h>
2022-05-03 03:56:07 +00:00
# endif
static int ui_default_callback ( scanner_handle , int , void * , unsigned int * , void * )
{
return 0 ;
}
2022-05-30 06:46:37 +00:00
static std : : string bmp_821 ( unsigned char * bits /*bits data*/ , int w , int h , int * lbytes , bool line_align_4 )
{
static unsigned int g_bmp8_pallete [ ] = {
0x00000000 , 0x00800000 , 0x00008000 , 0x00808000 , 0x00000080 , 0x00800080 , 0x00008080 , 0x00c0c0c0 , 0x00c0dcc0 , 0x00a6caf0 , 0x00402000 , 0x00602000 , 0x00802000 , 0x00a02000 , 0x00c02000 , 0x00e02000
, 0x00004000 , 0x00204000 , 0x00404000 , 0x00604000 , 0x00804000 , 0x00a04000 , 0x00c04000 , 0x00e04000 , 0x00006000 , 0x00206000 , 0x00406000 , 0x00606000 , 0x00806000 , 0x00a06000 , 0x00c06000 , 0x00e06000
, 0x00008000 , 0x00208000 , 0x00408000 , 0x00608000 , 0x00808000 , 0x00a08000 , 0x00c08000 , 0x00e08000 , 0x0000a000 , 0x0020a000 , 0x0040a000 , 0x0060a000 , 0x0080a000 , 0x00a0a000 , 0x00c0a000 , 0x00e0a000
, 0x0000c000 , 0x0020c000 , 0x0040c000 , 0x0060c000 , 0x0080c000 , 0x00a0c000 , 0x00c0c000 , 0x00e0c000 , 0x0000e000 , 0x0020e000 , 0x0040e000 , 0x0060e000 , 0x0080e000 , 0x00a0e000 , 0x00c0e000 , 0x00e0e000
, 0x00000040 , 0x00200040 , 0x00400040 , 0x00600040 , 0x00800040 , 0x00a00040 , 0x00c00040 , 0x00e00040 , 0x00002040 , 0x00202040 , 0x00402040 , 0x00602040 , 0x00802040 , 0x00a02040 , 0x00c02040 , 0x00e02040
, 0x00004040 , 0x00204040 , 0x00404040 , 0x00604040 , 0x00804040 , 0x00a04040 , 0x00c04040 , 0x00e04040 , 0x00006040 , 0x00206040 , 0x00406040 , 0x00606040 , 0x00806040 , 0x00a06040 , 0x00c06040 , 0x00e06040
, 0x00008040 , 0x00208040 , 0x00408040 , 0x00608040 , 0x00808040 , 0x00a08040 , 0x00c08040 , 0x00e08040 , 0x0000a040 , 0x0020a040 , 0x0040a040 , 0x0060a040 , 0x0080a040 , 0x00a0a040 , 0x00c0a040 , 0x00e0a040
, 0x0000c040 , 0x0020c040 , 0x0040c040 , 0x0060c040 , 0x0080c040 , 0x00a0c040 , 0x00c0c040 , 0x00e0c040 , 0x0000e040 , 0x0020e040 , 0x0040e040 , 0x0060e040 , 0x0080e040 , 0x00a0e040 , 0x00c0e040 , 0x00e0e040
, 0x00000080 , 0x00200080 , 0x00400080 , 0x00600080 , 0x00800080 , 0x00a00080 , 0x00c00080 , 0x00e00080 , 0x00002080 , 0x00202080 , 0x00402080 , 0x00602080 , 0x00802080 , 0x00a02080 , 0x00c02080 , 0x00e02080
, 0x00004080 , 0x00204080 , 0x00404080 , 0x00604080 , 0x00804080 , 0x00a04080 , 0x00c04080 , 0x00e04080 , 0x00006080 , 0x00206080 , 0x00406080 , 0x00606080 , 0x00806080 , 0x00a06080 , 0x00c06080 , 0x00e06080
, 0x00008080 , 0x00208080 , 0x00408080 , 0x00608080 , 0x00808080 , 0x00a08080 , 0x00c08080 , 0x00e08080 , 0x0000a080 , 0x0020a080 , 0x0040a080 , 0x0060a080 , 0x0080a080 , 0x00a0a080 , 0x00c0a080 , 0x00e0a080
, 0x0000c080 , 0x0020c080 , 0x0040c080 , 0x0060c080 , 0x0080c080 , 0x00a0c080 , 0x00c0c080 , 0x00e0c080 , 0x0000e080 , 0x0020e080 , 0x0040e080 , 0x0060e080 , 0x0080e080 , 0x00a0e080 , 0x00c0e080 , 0x00e0e080
, 0x000000c0 , 0x002000c0 , 0x004000c0 , 0x006000c0 , 0x008000c0 , 0x00a000c0 , 0x00c000c0 , 0x00e000c0 , 0x000020c0 , 0x002020c0 , 0x004020c0 , 0x006020c0 , 0x008020c0 , 0x00a020c0 , 0x00c020c0 , 0x00e020c0
, 0x000040c0 , 0x002040c0 , 0x004040c0 , 0x006040c0 , 0x008040c0 , 0x00a040c0 , 0x00c040c0 , 0x00e040c0 , 0x000060c0 , 0x002060c0 , 0x004060c0 , 0x006060c0 , 0x008060c0 , 0x00a060c0 , 0x00c060c0 , 0x00e060c0
, 0x000080c0 , 0x002080c0 , 0x004080c0 , 0x006080c0 , 0x008080c0 , 0x00a080c0 , 0x00c080c0 , 0x00e080c0 , 0x0000a0c0 , 0x0020a0c0 , 0x0040a0c0 , 0x0060a0c0 , 0x0080a0c0 , 0x00a0a0c0 , 0x00c0a0c0 , 0x00e0a0c0
, 0x0000c0c0 , 0x0020c0c0 , 0x0040c0c0 , 0x0060c0c0 , 0x0080c0c0 , 0x00a0c0c0 , 0x00fffbf0 , 0x00a0a0a4 , 0x00808080 , 0x00ff0000 , 0x0000ff00 , 0x00ffff00 , 0x000000ff , 0x00ff00ff , 0x0000ffff , 0x00ffffff
} ;
int l = ( w + 31 ) / 32 * 4 ,
size = l * h ,
line_bytes = ( w + 3 ) / 4 * 4 ;
std : : string f ( " " ) ;
unsigned char * data = nullptr ;
unsigned int * pallete = g_bmp8_pallete ;
if ( ! line_align_4 )
{
l = ( w + 7 ) / 8 ;
size = l * h ;
}
if ( lbytes & & * lbytes )
line_bytes = * lbytes ;
f . resize ( size ) ;
data = ( unsigned char * ) & f [ 0 ] ;
for ( int i = 0 ; i < h ; + + i )
{
unsigned char v = 0 ,
* dst = data ;
for ( int j = 0 ; j < w ; + + j )
{
v < < = 1 ;
unsigned char pixel = ( ( pallete [ bits [ j ] ] & 0x0ff ) + ( ( pallete [ bits [ j ] ] > > 8 ) & 0x0ff ) + ( ( pallete [ bits [ j ] ] > > 16 ) & 0x0ff ) ) / 3 ;
if ( pixel > = 128 )
v | = 1 ;
if ( ( j + 1 ) % 8 = = 0 )
{
* dst + + = v ;
v = 0 ;
}
}
if ( v )
{
v < < = 8 - ( w % 8 ) ;
* dst + + = v ;
}
data + = l ;
bits + = line_bytes ;
}
if ( lbytes )
* lbytes = l ;
return f ;
}
2022-05-03 03:56:07 +00:00
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// hg_scanner
hg_scanner : : hg_scanner ( ScannerSerial serial
, const char * dev_name , usb_io * io )
2022-05-17 07:04:55 +00:00
: name_ ( dev_name ? dev_name : " " ) , io_ ( io ) , status_ ( SCANNER_ERR_NOT_START )
2022-05-03 03:56:07 +00:00
, scan_count_ ( - 1 ) , run_ ( true ) , paper_size_ ( TwSS : : A4 ) , erase_bkg_range_ ( 10 )
, noise_range_ ( 30 ) , omit_empty_level_ ( 50 ) , resolution_ ( 200 ) , rid_hole_range_ ( .1f )
, bright_ ( 128 ) , contrast_ ( 4 ) , gamma_ ( 1.0f ) , threshold_ ( 40 ) , anti_noise_ ( 8 ) , margin_ ( 5 )
, fractate_level_ ( 50 ) , ui_ev_cb_ ( ui_default_callback ) , scan_life_ ( NULL )
, notify_setting_result_ ( false ) , user_cancel_ ( false ) , cb_mem_ ( true ) , test_1_paper_ ( false )
2022-06-02 03:47:44 +00:00
, setting_count_ ( 0 ) , img_type_ ( " " ) , online_ ( false ) , is_quality_ ( - 1 ) , is_color_fill ( false ) , is_multiout ( false ) , save_multiout ( OPTION_VALUE_DLSC_CS_HD_HB )
2022-06-08 08:31:41 +00:00
, final_img_index_ ( 0 ) , custom_area_ ( false )
2022-05-03 03:56:07 +00:00
{
2022-05-30 09:36:42 +00:00
final_path_ = hg_log : : ini_get ( " paths " , " final_img " ) ;
if ( final_path_ . empty ( ) )
2022-06-06 04:03:24 +00:00
final_path_ = hg_log : : local_data_path ( ) + PATH_SEPARATOR + " imgs " ;
2022-05-30 09:36:42 +00:00
if ( hg_log : : create_folder ( final_path_ . c_str ( ) ) )
2022-06-06 04:03:24 +00:00
{
VLOG_MINI_1 ( LOG_LEVEL_WARNING , " temporary image folder: %s \n " , final_path_ . c_str ( ) ) ;
2022-06-01 03:04:10 +00:00
final_path_ + = PATH_SEPARATOR ;
2022-06-06 04:03:24 +00:00
}
2022-05-30 09:36:42 +00:00
else
2022-06-06 04:03:24 +00:00
{
VLOG_MINI_1 ( LOG_LEVEL_WARNING , " create temporary image folder failed: %s \n " , final_path_ . c_str ( ) ) ;
2022-05-30 09:36:42 +00:00
final_path_ = " " ;
2022-06-06 04:03:24 +00:00
}
2022-05-30 09:36:42 +00:00
2022-05-06 08:39:00 +00:00
custom_gamma_val_ = new SANE_Gamma ;
memset ( custom_gamma_val_ , 0 , sizeof ( SANE_Gamma ) ) ;
2022-05-09 08:59:22 +00:00
# ifdef MAPPING_FUNCTION_IN_BASE
init_setting_map ( setting_map_ , ARRAY_SIZE ( setting_map_ ) ) ;
# endif
2022-05-06 08:39:00 +00:00
2022-05-06 05:37:14 +00:00
paper_size_mm_ . cx = 210 ;
paper_size_mm_ . cy = 297 ;
2022-05-06 08:39:00 +00:00
custom_gamma_val_ - > pt_count_r = custom_gamma_val_ - > pt_count_g = custom_gamma_val_ - > pt_count_b = 0 ;
for ( int i = 0 ; i < ARRAY_SIZE ( custom_gamma_val_ - > table ) ; + + i )
custom_gamma_val_ - > table [ i ] = i & 0x0ff ;
2022-05-06 05:37:14 +00:00
2022-05-30 03:04:26 +00:00
VLOG_MINI_2 ( LOG_LEVEL_DEBUG_INFO , " %s(%s) constructed \n " , name_ . c_str ( ) , hg_log : : format_ptr ( this ) . c_str ( ) ) ;
2022-05-03 03:56:07 +00:00
image_prc_param_ . value = 0 ;
if ( io_ )
{
io_ - > add_ref ( ) ;
status_ = io_ - > last_error ( ) ;
2022-05-17 07:04:55 +00:00
online_ = status_ = = SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
}
wait_usb_ . set_debug_info ( " USB " ) ;
wait_img_ . set_debug_info ( " Image " ) ;
2022-05-23 03:52:53 +00:00
wait_usb_result_ . set_debug_info ( " start " ) ;
2022-05-03 03:56:07 +00:00
thread_usb_read_ . reset ( new std : : thread ( & hg_scanner : : thread_handle_usb , this ) ) ;
thread_img_handle_ . reset ( new std : : thread ( & hg_scanner : : thread_image_handle , this ) ) ;
}
hg_scanner : : ~ hg_scanner ( )
{
close ( true ) ;
if ( thread_usb_read_ . get ( ) & & thread_usb_read_ - > joinable ( ) )
thread_usb_read_ - > join ( ) ;
if ( thread_img_handle_ . get ( ) & & thread_img_handle_ - > joinable ( ) )
thread_img_handle_ - > join ( ) ;
2022-05-06 08:39:00 +00:00
delete custom_gamma_val_ ;
2022-05-03 03:56:07 +00:00
name_ . insert ( 0 , " \350 \256 \276 \345 \244 \207 “ " ) ;
name_ + = " ” \345 \267 \262 \347 \273 \217 \345 \205 \263 \351 \227 \255 \343 \200 \202 " ;
notify_ui_working_status ( name_ . c_str ( ) , SANE_EVENT_SCANNER_CLOSED ) ;
2022-05-30 03:04:26 +00:00
VLOG_MINI_2 ( LOG_LEVEL_DEBUG_INFO , " %s(%s) destroyed. \n " , name_ . c_str ( ) , hg_log : : format_ptr ( this ) . c_str ( ) ) ;
2022-05-17 07:04:55 +00:00
}
2022-05-03 03:56:07 +00:00
std : : string hg_scanner : : temporary_file ( char * tail , char * head )
{
2022-05-10 00:27:31 +00:00
std : : string path ( " /tmp/ " ) ;
char buf [ 128 ] ;
FILE * src = NULL ;
unsigned int ind = 1 ;
2022-05-03 03:56:07 +00:00
if ( ! head | | * head = = 0 )
head = ( char * ) " scan " ;
if ( ! tail )
tail = ( char * ) " " ;
2022-05-10 00:27:31 +00:00
# ifdef WIN32
char me [ MAX_PATH ] = { 0 } , * n = NULL ;
GetModuleFileNameA ( NULL , me , _countof ( me ) - 1 ) ;
n = strrchr ( me , ' \\ ' ) ;
if ( n + + = = NULL )
n = me ;
* n = 0 ;
path = me ;
path + = " img_tmp \\ " ;
mkdir ( path . c_str ( ) ) ;
# endif
2022-05-03 03:56:07 +00:00
srand ( time ( NULL ) ) ;
2022-05-10 00:27:31 +00:00
sprintf ( buf , " %s%s " , head , tail ) ;
while ( ( src = fopen ( ( path + buf ) . c_str ( ) , " rb " ) ) )
2022-05-03 03:56:07 +00:00
{
fclose ( src ) ;
2022-05-10 00:27:31 +00:00
sprintf ( buf , " %s(%u)%s " , head , ind + + , tail ) ;
2022-05-03 03:56:07 +00:00
}
2022-05-10 00:27:31 +00:00
return path + buf ;
2022-05-03 03:56:07 +00:00
}
2022-05-10 00:27:31 +00:00
int hg_scanner : : save_2_tempory_file ( std : : shared_ptr < std : : vector < char > > data , std : : string * path_file , unsigned int index )
2022-05-03 03:56:07 +00:00
{
2022-05-10 00:27:31 +00:00
char head [ 40 ] = { 0 } ;
std : : string file ( " " ) ;
FILE * dst = nullptr ;
2022-05-17 07:04:55 +00:00
int ret = SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
2022-06-01 03:04:10 +00:00
sprintf ( head , " usb_%05u " , index ) ;
if ( ! path_file | | path_file - > empty ( ) )
file = hg_scanner : : temporary_file ( ( char * ) " .jpg " , ( char * ) head ) ;
dst = fopen ( file . c_str ( ) , " wb " ) ;
2022-05-03 03:56:07 +00:00
if ( dst )
{
size_t wrote = fwrite ( data - > data ( ) , 1 , data - > size ( ) , dst ) ;
if ( wrote = = data - > size ( ) )
{
if ( path_file )
* path_file = file ;
2022-05-30 03:04:26 +00:00
VLOG_MINI_2 ( LOG_LEVEL_DEBUG_INFO , " --->Wrote %u bytes to file '%s' \n " , wrote , file . c_str ( ) ) ;
2022-05-03 03:56:07 +00:00
}
else
{
2022-05-17 07:04:55 +00:00
ret = SCANNER_ERR_WRITE_FILE_FAILED ;
2022-05-30 03:04:26 +00:00
VLOG_MINI_3 ( LOG_LEVEL_FATAL , " Failed in writting file(%u/%u) '%s' \n " , wrote , data - > size ( ) , file . c_str ( ) ) ;
2022-05-03 03:56:07 +00:00
}
fclose ( dst ) ;
}
else
{
2022-05-17 07:04:55 +00:00
ret = SCANNER_ERR_CREATE_FILE_FAILED ;
2022-05-30 03:04:26 +00:00
VLOG_MINI_1 ( LOG_LEVEL_FATAL , " Failed in creating file '%s' \n " , file . c_str ( ) ) ;
2022-05-03 03:56:07 +00:00
}
return ret ;
}
void hg_scanner : : init_setting_map ( int * setting_map , int count )
{
for ( int i = 0 ; i < count ; + + i )
setting_map [ i ] = - 1 ;
}
2022-05-09 08:59:22 +00:00
void hg_scanner : : set_setting_map ( int sn , const char * title )
{
std : : string val ( title ) ;
int empty = 0 ;
while ( empty < val . length ( ) & & val [ empty ] = = ' ' )
empty + + ;
val . erase ( 0 , empty ) ;
2022-05-30 03:04:26 +00:00
//VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "title: '%s', val: '%s'\n", title, val.c_str());
2022-05-09 08:59:22 +00:00
if ( val = = OPTION_TITLE_HFMRSZ )
setting_map_ [ HG_BASE_SETTING_INDEX_RESTORE_DEFAULT_SETTINGS ] = sn ;
else if ( val = = OPTION_TITLE_BZ )
setting_map_ [ HG_BASE_SETTING_INDEX_HELP ] = sn ;
else if ( val = = OPTION_TITLE_YSMS )
setting_map_ [ HG_BASE_SETTING_INDEX_COLOR_MODE ] = sn ;
else if ( val = = OPTION_TITLE_DLSC )
setting_map_ [ HG_BASE_SETTING_INDEX_MULTI_OUT ] = sn ;
2022-05-21 08:56:14 +00:00
else if ( val = = OPTION_TITLE_DLSCLX )
setting_map_ [ HG_BASE_SETTING_INDEX_MULTI_OUT_TYPE ] = sn ;
2022-05-09 08:59:22 +00:00
else if ( val = = OPTION_TITLE_HDHHBTX_CS )
setting_map_ [ HG_BASE_SETTING_INDEX_ERASE_COLOR ] = sn ;
else if ( val = = OPTION_TITLE_24WCSTX_DLSCCH )
setting_map_ [ HG_BASE_SETTING_INDEX_ERASE_MULTI_OUT_RED ] = sn ;
else if ( val = = OPTION_TITLE_24WCSTX_DTKCH )
setting_map_ [ HG_BASE_SETTING_INDEX_ERASE_ANSWER_RED ] = sn ;
else if ( val = = OPTION_TITLE_BJYC )
setting_map_ [ HG_BASE_SETTING_INDEX_ERASE_BACKGROUND ] = sn ;
else if ( val = = OPTION_TITLE_BJSCFDFW )
setting_map_ [ HG_BASE_SETTING_INDEX_ERASE_BACKGROUND_RANGE ] = sn ;
else if ( val = = OPTION_TITLE_HBTXZDYH )
setting_map_ [ HG_BASE_SETTING_INDEX_NOISE_OPTIMIZE ] = sn ;
else if ( val = = OPTION_TITLE_ZDYHCC )
setting_map_ [ HG_BASE_SETTING_INDEX_NOISE_OPTIMIZE_SIZE ] = sn ;
else if ( val = = OPTION_TITLE_ZZCC )
setting_map_ [ HG_BASE_SETTING_INDEX_PAPER ] = sn ;
else if ( val = = OPTION_TITLE_CCJC )
setting_map_ [ HG_BASE_SETTING_INDEX_PAPER_SIZE_CHECK ] = sn ;
else if ( val = = OPTION_TITLE_ZDYSMQY )
setting_map_ [ HG_BASE_SETTING_INDEX_IS_CUSTOM_AREA ] = sn ;
else if ( val = = OPTION_TITLE_SMQYZCmm )
setting_map_ [ HG_BASE_SETTING_INDEX_CUSTOM_AREA_LEFT ] = sn ;
else if ( val = = OPTION_TITLE_SMQYYCmm )
setting_map_ [ HG_BASE_SETTING_INDEX_CUSTOM_AREA_RIGHT ] = sn ;
else if ( val = = OPTION_TITLE_SMQYSCmm )
setting_map_ [ HG_BASE_SETTING_INDEX_CUSTOM_AREA_TOP ] = sn ;
else if ( val = = OPTION_TITLE_SMQYXCmm )
setting_map_ [ HG_BASE_SETTING_INDEX_CUSTOM_AREA_BOTTOM ] = sn ;
else if ( val = = OPTION_TITLE_SMYM )
setting_map_ [ HG_BASE_SETTING_INDEX_PAGE ] = sn ;
else if ( val = = OPTION_TITLE_TGKBYLMD )
setting_map_ [ HG_BASE_SETTING_INDEX_PAGE_OMIT_EMPTY_LEVEL ] = sn ;
else if ( val = = OPTION_TITLE_FBL )
setting_map_ [ HG_BASE_SETTING_INDEX_RESOLUTION ] = sn ;
2022-05-13 08:39:21 +00:00
else if ( val = = OPTION_TITLE_HZ )
2022-05-09 08:59:22 +00:00
setting_map_ [ HG_BASE_SETTING_INDEX_IMG_QUALITY ] = sn ;
else if ( val = = OPTION_TITLE_JHZFM )
setting_map_ [ HG_BASE_SETTING_INDEX_EXCHANGE ] = sn ;
else if ( val = = OPTION_TITLE_TXCF )
setting_map_ [ HG_BASE_SETTING_INDEX_SPLIT ] = sn ;
else if ( val = = OPTION_TITLE_ZDJP )
setting_map_ [ HG_BASE_SETTING_INDEX_AUTO_CORRECT ] = sn ;
else if ( val = = OPTION_TITLE_CKYC )
setting_map_ [ HG_BASE_SETTING_INDEX_RID_HOLE ] = sn ;
else if ( val = = OPTION_TITLE_CKSSFWZFMBL )
setting_map_ [ HG_BASE_SETTING_INDEX_RID_HOLE_RANGE ] = sn ;
else if ( val = = OPTION_TITLE_QYSDQX )
setting_map_ [ HG_BASE_SETTING_INDEX_IS_CUSTOM_GAMMA ] = sn ;
else if ( val = = OPTION_TITLE_LDZ )
setting_map_ [ HG_BASE_SETTING_INDEX_BRIGHT ] = sn ;
else if ( val = = OPTION_TITLE_DBD )
setting_map_ [ HG_BASE_SETTING_INDEX_CONTRAST ] = sn ;
else if ( val = = OPTION_TITLE_GMZ )
setting_map_ [ HG_BASE_SETTING_INDEX_GAMMA ] = sn ;
else if ( val = = OPTION_TITLE_RHYMH )
setting_map_ [ HG_BASE_SETTING_INDEX_SHARPEN ] = sn ;
else if ( val = = OPTION_TITLE_SSYZ )
setting_map_ [ HG_BASE_SETTING_INDEX_DARK_SAMPLE ] = sn ;
else if ( val = = OPTION_TITLE_XCHK )
setting_map_ [ HG_BASE_SETTING_INDEX_ERASE_BLACK_FRAME ] = sn ;
else if ( val = = OPTION_TITLE_YZ )
setting_map_ [ HG_BASE_SETTING_INDEX_THRESHOLD ] = sn ;
else if ( val = = OPTION_TITLE_BJKZDJ )
setting_map_ [ HG_BASE_SETTING_INDEX_ANTI_NOISE_LEVEL ] = sn ;
else if ( val = = OPTION_TITLE_BYSJ )
setting_map_ [ HG_BASE_SETTING_INDEX_MARGIN ] = sn ;
else if ( val = = OPTION_TITLE_BJTCFS )
setting_map_ [ HG_BASE_SETTING_INDEX_FILL_BACKGROUND ] = sn ;
else if ( val = = OPTION_TITLE_FZST )
setting_map_ [ HG_BASE_SETTING_INDEX_PERMEATE ] = sn ;
else if ( val = = OPTION_TITLE_FZSTDJ )
setting_map_ [ HG_BASE_SETTING_INDEX_PERMEATE_LV ] = sn ;
else if ( val = = OPTION_TITLE_QCMW )
setting_map_ [ HG_BASE_SETTING_INDEX_REMOVE_MORR ] = sn ;
else if ( val = = OPTION_TITLE_CWKS )
setting_map_ [ HG_BASE_SETTING_INDEX_ERROR_EXTENTION ] = sn ;
else if ( val = = OPTION_TITLE_CWW )
setting_map_ [ HG_BASE_SETTING_INDEX_REMOVE_TXTTURE ] = sn ;
else if ( val = = OPTION_TITLE_CSBJC )
setting_map_ [ HG_BASE_SETTING_INDEX_ULTRASONIC_CHECK ] = sn ;
else if ( val = = OPTION_TITLE_ZDJC )
setting_map_ [ HG_BASE_SETTING_INDEX_STAPLE_CHECK ] = sn ;
else if ( val = = OPTION_TITLE_SMZS )
setting_map_ [ HG_BASE_SETTING_INDEX_SCAN_MODE ] = sn ;
else if ( val = = OPTION_TITLE_SMSL )
setting_map_ [ HG_BASE_SETTING_INDEX_SCAN_COUNT ] = sn ;
else if ( val = = OPTION_TITLE_WGFX )
setting_map_ [ HG_BASE_SETTING_INDEX_TEXT_DIRECTION ] = sn ;
else if ( val = = OPTION_TITLE_BMXZ180 )
setting_map_ [ HG_BASE_SETTING_INDEX_ROTATE_BKG_180 ] = sn ;
else if ( val = = OPTION_TITLE_ZJJC )
setting_map_ [ HG_BASE_SETTING_INDEX_FRACTATE_CHECK ] = sn ;
2022-05-13 08:39:21 +00:00
else if ( val = = OPTION_TITLE_ZJDX )
2022-05-09 08:59:22 +00:00
setting_map_ [ HG_BASE_SETTING_INDEX_FRACTATE_CHECK_LEVEL ] = sn ;
else if ( val = = OPTION_TITLE_WXJC )
setting_map_ [ HG_BASE_SETTING_INDEX_SKEW_CHECK ] = sn ;
2022-05-13 08:39:21 +00:00
else if ( val = = OPTION_TITLE_WXRRD )
2022-05-09 08:59:22 +00:00
setting_map_ [ HG_BASE_SETTING_INDEX_SKEW_CHECK_LEVEL ] = sn ;
2022-05-20 07:53:40 +00:00
else if ( val = = OPTION_TITLE_SCTC )
setting_map_ [ HG_BASE_SETTING_INDEX_COLOR_FILL ] = sn ;
2022-05-09 08:59:22 +00:00
}
2022-05-03 03:56:07 +00:00
void hg_scanner : : thread_handle_usb ( void )
{
while ( run_ )
{
wait_usb_ . wait ( ) ;
if ( ! run_ )
break ;
if ( scan_life_ )
{
std : : this_thread : : sleep_for ( std : : chrono : : milliseconds ( 3000 ) ) ;
if ( scan_life_ )
{
2022-05-30 03:04:26 +00:00
LOG_INFO ( LOG_LEVEL_FATAL , " image process is still running! \n " ) ;
2022-05-03 03:56:07 +00:00
continue ;
}
}
scan_life_ = new do_when_born_and_dead < hg_scanner > ( this , & hg_scanner : : working_begin , & hg_scanner : : working_done , NULL ) ;
2022-05-10 00:27:31 +00:00
usb_img_index_ = 0 ;
2022-05-03 03:56:07 +00:00
thread_handle_usb_read ( ) ;
if ( scan_life_ - > release ( ) = = 0 )
scan_life_ = NULL ;
}
}
void hg_scanner : : thread_image_handle ( void )
{
while ( run_ )
{
wait_img_ . wait ( ) ;
if ( ! run_ )
break ;
scan_life_ - > add_ref ( ) ;
thread_handle_image_process ( ) ;
if ( scan_life_ - > release ( ) = = 0 )
scan_life_ = NULL ;
}
}
void hg_scanner : : get_range ( int setting_no , std : : vector < std : : string > & range , std : : string & def_val , bool & is_range /*range or list*/ )
{
char sn [ 20 ] ;
std : : string type ( " " ) ;
sprintf ( sn , " %d " , setting_no ) ;
range . clear ( ) ;
if ( setting_jsn_ . at ( sn ) . contains ( " range " ) )
{
setting_jsn_ . at ( sn ) . at ( " type " ) . get_to ( type ) ;
is_range = ! setting_jsn_ . at ( sn ) . at ( " range " ) . is_array ( ) ;
if ( is_range )
{
if ( type = = " int " )
{
int l = 0 , u = 0 ;
setting_jsn_ . at ( sn ) . at ( " range " ) . at ( " min " ) . get_to ( l ) ;
setting_jsn_ . at ( sn ) . at ( " range " ) . at ( " max " ) . get_to ( u ) ;
char str [ 20 ] ;
sprintf ( str , " %d " , l ) ;
range . push_back ( str ) ;
sprintf ( str , " %d " , u ) ;
range . push_back ( str ) ;
}
else
{
double l = .0f , u = .0f ;
setting_jsn_ . at ( sn ) . at ( " range " ) . at ( " min " ) . get_to ( l ) ;
setting_jsn_ . at ( sn ) . at ( " range " ) . at ( " max " ) . get_to ( u ) ;
char str [ 40 ] ;
sprintf ( str , " %f " , l ) ;
range . push_back ( str ) ;
sprintf ( str , " %f " , u ) ;
range . push_back ( str ) ;
}
}
else
{
char str [ 40 ] ;
for ( int i = 0 ; i < setting_jsn_ . at ( sn ) . at ( " range " ) . size ( ) ; + + i )
{
if ( type = = " int " )
{
int v = 0 ;
setting_jsn_ . at ( sn ) . at ( " range " ) . at ( i ) . get_to ( v ) ;
sprintf ( str , " %d " , v ) ;
range . push_back ( str ) ;
}
else if ( type = = " float " )
{
double v = 0 ;
setting_jsn_ . at ( sn ) . at ( " range " ) . at ( i ) . get_to ( v ) ;
sprintf ( str , " %f " , v ) ;
range . push_back ( str ) ;
}
else
{
std : : string v ( " " ) ;
setting_jsn_ . at ( sn ) . at ( " range " ) . at ( i ) . get_to ( v ) ;
range . push_back ( v ) ;
}
}
}
}
if ( type = = " int " )
{
int v = 0 ;
setting_jsn_ . at ( sn ) . at ( " default " ) . get_to ( v ) ;
sprintf ( sn , " %d " , v ) ;
def_val = sn ;
}
else if ( type = = " float " )
{
double v = 0 ;
setting_jsn_ . at ( sn ) . at ( " default " ) . get_to ( v ) ;
sprintf ( sn , " %f " , v ) ;
def_val = sn ;
}
else if ( type = = " string " )
setting_jsn_ . at ( sn ) . at ( " default " ) . get_to ( def_val ) ;
2022-05-30 03:04:26 +00:00
VLOG_MINI_3 ( LOG_LEVEL_DEBUG_INFO , " setting %d has %d range(s) and default value is '%s' \n " , setting_no , range . size ( ) , def_val . c_str ( ) ) ;
2022-05-03 03:56:07 +00:00
}
bool hg_scanner : : check_range ( int setting_no , bool & val )
{
std : : vector < std : : string > range ;
std : : string init ( " " ) , in ( val ? " true " : " false " ) ;
bool is_range = false ; ;
get_range ( setting_no , range , init , is_range ) ;
if ( range . size ( ) = = 0 )
return true ;
for ( int i = 0 ; i < range . size ( ) ; + + i )
{
if ( in = = range [ i ] )
return true ;
}
val = init = = " true " ? true : false ;
return false ;
}
bool hg_scanner : : check_range ( int setting_no , int & val )
{
std : : vector < std : : string > range ;
std : : string init ( " " ) ;
bool is_range = false ; ;
get_range ( setting_no , range , init , is_range ) ;
if ( range . size ( ) = = 0 )
return true ;
if ( is_range & & range . size ( ) = = 2 )
{
if ( val > = atoi ( range [ 0 ] . c_str ( ) ) & & val < = atoi ( range [ 1 ] . c_str ( ) ) )
return true ;
if ( val < atoi ( range [ 0 ] . c_str ( ) ) )
val = atoi ( range [ 0 ] . c_str ( ) ) ;
else
val = atoi ( range [ 1 ] . c_str ( ) ) ;
return false ;
}
else if ( ! is_range )
{
for ( int i = 0 ; i < range . size ( ) ; + + i )
{
if ( atoi ( range [ i ] . c_str ( ) ) = = val )
return true ;
}
}
val = atoi ( init . c_str ( ) ) ;
return false ;
}
bool hg_scanner : : check_range ( int setting_no , double & val )
{
std : : vector < std : : string > range ;
std : : string init ( " " ) ;
bool is_range = false ; ;
get_range ( setting_no , range , init , is_range ) ;
if ( range . size ( ) = = 0 )
return true ;
if ( is_range & & range . size ( ) = = 2 )
{
if ( val > = atof ( range [ 0 ] . c_str ( ) ) & & val < = atof ( range [ 1 ] . c_str ( ) ) )
return true ;
if ( val < atof ( range [ 0 ] . c_str ( ) ) )
val = atof ( range [ 0 ] . c_str ( ) ) ;
else
val = atof ( range [ 1 ] . c_str ( ) ) ;
return false ;
}
else if ( ! is_range )
{
for ( int i = 0 ; i < range . size ( ) ; + + i )
{
if ( fabs ( atof ( range [ i ] . c_str ( ) ) - val ) < .000001 )
return true ;
}
}
val = atof ( init . c_str ( ) ) ;
return false ;
}
bool hg_scanner : : check_range ( int setting_no , std : : string & val )
{
std : : vector < std : : string > range ;
std : : string init ( " " ) , in ( val ) ;
bool is_range = false ; ;
get_range ( setting_no , range , init , is_range ) ;
if ( range . size ( ) = = 0 )
return true ;
for ( int i = 0 ; i < range . size ( ) ; + + i )
{
if ( in = = range [ i ] )
return true ;
}
val = init ;
return false ;
}
int hg_scanner : : restore ( int setting_no )
{
char key [ 20 ] ;
int sn = setting_no ;
std : : string val ( " " ) ;
sprintf ( key , " %d " , setting_no ) ;
setting_jsn_ . at ( key ) . at ( " type " ) . get_to ( val ) ;
if ( val = = " string " )
{
val = " " ;
setting_jsn_ . at ( key ) . at ( " default " ) . get_to ( val ) ;
char * buf = NULL ;
int size = 0 ;
setting_jsn_ . at ( key ) . at ( " size " ) . get_to ( size ) ;
buf = ( char * ) malloc ( size + 4 ) ;
bzero ( buf , size + 4 ) ;
strcpy ( buf , val . c_str ( ) ) ;
sn = set_setting ( sn , buf , val . length ( ) ) ;
free ( buf ) ;
}
else if ( val = = " int " )
{
int v = 0 ;
setting_jsn_ . at ( key ) . at ( " default " ) . get_to ( v ) ;
sn = set_setting ( sn , ( char * ) & v , sizeof ( v ) ) ;
}
else if ( val = = " float " )
{
double v = .0f ;
setting_jsn_ . at ( key ) . at ( " default " ) . get_to ( v ) ;
sn = set_setting ( sn , ( char * ) & v , sizeof ( v ) ) ;
}
else if ( val = = " bool " )
{
bool v = false ;
setting_jsn_ . at ( key ) . at ( " default " ) . get_to ( v ) ;
sn = set_setting ( sn , ( char * ) & v , sizeof ( v ) ) ;
}
else
2022-05-17 07:04:55 +00:00
sn = SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
return sn ;
}
bool hg_scanner : : get_default_value ( void * buf , json * jsn )
{
std : : string type ( " " ) ;
jsn - > at ( " type " ) . get_to ( type ) ;
if ( type = = " bool " )
{
bool v = false ;
jsn - > at ( " default " ) . get_to ( v ) ;
* ( ( SANE_Bool * ) buf ) = v ;
}
else if ( type = = " int " )
{
int v = 0 ;
jsn - > at ( " default " ) . get_to ( v ) ;
* ( ( SANE_Int * ) buf ) = v ;
}
else if ( type = = " float " )
{
double v = 0 ;
jsn - > at ( " default " ) . get_to ( v ) ;
* ( ( SANE_Fixed * ) buf ) = SANE_FIX ( v ) ;
}
else if ( type = = " string " )
{
type = " " ;
jsn - > at ( " default " ) . get_to ( type ) ;
strcpy ( ( char * ) buf , type . c_str ( ) ) ;
}
else
return false ;
return true ;
}
bool hg_scanner : : is_to_file ( void )
{
return resolution_ > 200
| | paper_size_ = = TwSS : : USStatement
| | paper_size_ = = TwSS : : MaxSize
| | paper_size_ = = TwSS : : Trigeminy ;
}
void hg_scanner : : thread_handle_image_process ( void )
{
while ( run_ & & ! user_cancel_ )
{
2022-06-01 03:04:10 +00:00
std : : shared_ptr < tiny_buffer > tiny_buffer ;
if ( imgs_ . Size ( ) = = 0 )
2022-05-03 03:56:07 +00:00
{
if ( wait_usb_ . is_waiting ( ) )
break ;
this_thread : : sleep_for ( chrono : : milliseconds ( 30 ) ) ;
continue ;
}
2022-06-01 03:04:10 +00:00
tiny_buffer = imgs_ . Take ( ) ;
if ( tiny_buffer - > swap ( ) )
image_process ( tiny_buffer ) ;
2022-05-03 03:56:07 +00:00
else
{
2022-06-01 03:04:10 +00:00
VLOG_MINI_1 ( LOG_LEVEL_FATAL , " Reload USB data '%s' failed! \n " , tiny_buffer - > file ( ) . c_str ( ) ) ;
2022-05-03 03:56:07 +00:00
}
}
}
void hg_scanner : : working_begin ( void * )
{
final_img_index_ = 0 ;
2022-05-17 07:04:55 +00:00
notify_ui_working_status ( STATU_DESC_SCAN_WORKING , SANE_EVENT_WORKING , SCANNER_ERR_OK ) ;
2022-06-01 03:04:10 +00:00
VLOG_MINI_1 ( LOG_LEVEL_DEBUG_INFO , " [%s] scanning ... \n " , hg_log : : current_time ( ) . c_str ( ) ) ;
2022-05-03 03:56:07 +00:00
}
void hg_scanner : : working_done ( void * )
{
imgs_ . Clear ( ) ;
2022-06-07 10:06:28 +00:00
if ( user_cancel_ )
final_imgs_ . clear ( ) ;
2022-05-03 03:56:07 +00:00
switch ( status_ )
{
2022-05-17 07:04:55 +00:00
case SCANNER_ERR_OK :
2022-05-03 03:56:07 +00:00
notify_ui_working_status ( STATU_DESC_SCAN_STOPPED , SANE_EVENT_SCAN_FINISHED , status_ ) ;
break ;
2022-05-17 07:04:55 +00:00
case SCANNER_ERR_DEVICE_BUSY :
notify_ui_working_status ( STATU_DESC_SCANNER_ERR_DEVICE_PC_BUSY , SANE_EVENT_SCAN_FINISHED , status_ ) ;
2022-05-03 03:56:07 +00:00
break ;
2022-05-17 07:04:55 +00:00
case SCANNER_ERR_DEVICE_STOPPED :
2022-05-03 03:56:07 +00:00
notify_ui_working_status ( STATU_DESC_SCAN_STOPPED , SANE_EVENT_SCAN_FINISHED , status_ ) ;
break ;
2022-05-17 07:04:55 +00:00
case SCANNER_ERR_DEVICE_COVER_OPENNED :
notify_ui_working_status ( STATU_DESC_SCANNER_ERR_DEVICE_COVER_OPENNED , SANE_EVENT_SCAN_FINISHED , status_ ) ;
2022-05-03 03:56:07 +00:00
break ;
2022-05-17 07:04:55 +00:00
case SCANNER_ERR_DEVICE_NO_PAPER :
notify_ui_working_status ( STATU_DESC_SCANNER_ERR_DEVICE_NO_PAPER , SANE_EVENT_SCAN_FINISHED , status_ ) ;
2022-05-03 03:56:07 +00:00
break ;
2022-05-17 07:04:55 +00:00
case SCANNER_ERR_DEVICE_FEEDING_PAPER :
notify_ui_working_status ( STATU_DESC_SCANNER_ERR_DEVICE_FEEDING_PAPER , SANE_EVENT_SCAN_FINISHED , status_ ) ;
2022-05-03 03:56:07 +00:00
break ;
2022-05-17 07:04:55 +00:00
case SCANNER_ERR_DEVICE_NOT_FOUND :
notify_ui_working_status ( STATU_DESC_SCANNER_ERR_DEVICE_NOT_FOUND , SANE_EVENT_SCAN_FINISHED , status_ ) ;
2022-05-03 03:56:07 +00:00
break ;
2022-05-17 07:04:55 +00:00
case SCANNER_ERR_DEVICE_SLEEPING :
notify_ui_working_status ( STATU_DESC_SCANNER_ERR_DEVICE_SLEEPING , SANE_EVENT_SCAN_FINISHED , status_ ) ;
2022-05-03 03:56:07 +00:00
break ;
2022-05-17 07:04:55 +00:00
case SCANNER_ERR_DEVICE_COUNT_MODE :
notify_ui_working_status ( STATU_DESC_SCANNER_ERR_DEVICE_COUNT_MODE , SANE_EVENT_SCAN_FINISHED , status_ ) ;
2022-05-03 03:56:07 +00:00
break ;
2022-05-17 07:04:55 +00:00
case SCANNER_ERR_DEVICE_DOUBLE_FEEDING :
notify_ui_working_status ( STATU_DESC_SCANNER_ERR_DEVICE_DOUBLE_FEEDING , SANE_EVENT_SCAN_FINISHED , status_ ) ;
2022-05-03 03:56:07 +00:00
break ;
2022-05-17 07:04:55 +00:00
case SCANNER_ERR_DEVICE_PAPER_JAMMED :
notify_ui_working_status ( STATU_DESC_SCANNER_ERR_DEVICE_PAPER_JAMMED , SANE_EVENT_SCAN_FINISHED , status_ ) ;
2022-05-03 03:56:07 +00:00
break ;
2022-05-17 07:04:55 +00:00
case SCANNER_ERR_DEVICE_STAPLE_ON :
notify_ui_working_status ( STATU_DESC_SCANNER_ERR_DEVICE_STAPLE_ON , SANE_EVENT_SCAN_FINISHED , status_ ) ;
2022-05-03 03:56:07 +00:00
break ;
2022-05-17 07:04:55 +00:00
case SCANNER_ERR_DEVICE_PAPER_SKEW :
notify_ui_working_status ( STATU_DESC_SCANNER_ERR_DEVICE_PAPER_SKEW , SANE_EVENT_SCAN_FINISHED , status_ ) ;
2022-05-03 03:56:07 +00:00
break ;
2022-05-17 07:04:55 +00:00
case SCANNER_ERR_DEVICE_SIZE_CHECK :
notify_ui_working_status ( STATU_DESC_SCANNER_ERR_DEVICE_SIZE_CHECK , SANE_EVENT_SCAN_FINISHED , status_ ) ;
2022-05-03 03:56:07 +00:00
break ;
2022-05-17 07:04:55 +00:00
case SCANNER_ERR_DEVICE_DOGEAR :
notify_ui_working_status ( STATU_DESC_SCANNER_ERR_DEVICE_DOGEAR , SANE_EVENT_SCAN_FINISHED , status_ ) ;
2022-05-03 03:56:07 +00:00
break ;
2022-05-17 07:04:55 +00:00
case SCANNER_ERR_DEVICE_NO_IMAGE :
notify_ui_working_status ( STATU_DESC_SCANNER_ERR_DEVICE_NO_IMAGE , SANE_EVENT_SCAN_FINISHED , status_ ) ;
2022-05-03 03:56:07 +00:00
break ;
2022-05-17 07:04:55 +00:00
case SCANNER_ERR_DEVICE_SCANN_ERROR :
notify_ui_working_status ( STATU_DESC_SCANNER_ERR_DEVICE_SCANN_ERROR , SANE_EVENT_SCAN_FINISHED , status_ ) ;
2022-05-03 03:56:07 +00:00
break ;
2022-05-17 07:04:55 +00:00
case SCANNER_ERR_DEVICE_PC_BUSY :
notify_ui_working_status ( STATU_DESC_SCANNER_ERR_DEVICE_PC_BUSY , SANE_EVENT_SCAN_FINISHED , status_ ) ;
2022-05-03 03:56:07 +00:00
break ;
2022-05-23 06:10:18 +00:00
case SCANNER_ERR_INSUFFICIENT_MEMORY :
notify_ui_working_status ( STATU_DESC_SCANNER_ERR_INSUFFICIENT_MEMORY , SANE_EVENT_SCAN_FINISHED , status_ ) ;
break ;
2022-05-23 06:40:52 +00:00
case SCANNER_ERR_TIMEOUT :
notify_ui_working_status ( STATU_DESC_SCANNER_ERR_TIMEOUT , SANE_EVENT_SCAN_FINISHED , status_ ) ;
break ;
2022-05-03 03:56:07 +00:00
default :
notify_ui_working_status ( user_cancel_ ? STATU_DESC_SCAN_CANCELED : STATU_DESC_SCAN_STOPPED , SANE_EVENT_SCAN_FINISHED , status_ ) ;
break ;
}
if ( test_1_paper_ )
{
2022-05-30 03:04:26 +00:00
LOG_INFO ( LOG_LEVEL_DEBUG_INFO , " scanning mode: finished testing ONE paper, restore to normal scanning. \n " ) ;
2022-05-03 03:56:07 +00:00
}
else
{
2022-06-01 03:04:10 +00:00
VLOG_MINI_3 ( LOG_LEVEL_DEBUG_INFO , " [%s] scanned %d picture(s) and finished with error %s. \n " , hg_log : : current_time ( ) . c_str ( ) , final_img_index_ , hg_scanner_err_name ( status_ ) ) ;
2022-05-03 03:56:07 +00:00
}
test_1_paper_ = false ;
}
2022-05-06 05:37:14 +00:00
void hg_scanner : : reset_custom_area_range ( int paper )
{
if ( paper = = PAPER_A3 )
{
paper_size_mm_ . cx = 297 ;
paper_size_mm_ . cy = 420 ;
}
else if ( paper = = PAPER_A4 )
{
paper_size_mm_ . cx = 210 ;
paper_size_mm_ . cy = 297 ;
}
else if ( paper = = PAPER_A4_LATERAL )
{
paper_size_mm_ . cx = 297 ;
paper_size_mm_ . cy = 210 ;
}
else if ( paper = = PAPER_A5 )
{
paper_size_mm_ . cx = 148 ;
paper_size_mm_ . cy = 210 ;
}
else if ( paper = = PAPER_A5_LATERAL )
{
paper_size_mm_ . cx = 210 ;
paper_size_mm_ . cy = 148 ;
}
else if ( paper = = PAPER_A6 )
{
paper_size_mm_ . cx = 105 ;
paper_size_mm_ . cy = 148 ;
}
else if ( paper = = PAPER_A6_LATERAL )
{
paper_size_mm_ . cx = 148 ;
paper_size_mm_ . cy = 105 ;
}
else if ( paper = = PAPER_B4 )
{
paper_size_mm_ . cx = 250 ;
paper_size_mm_ . cy = 353 ;
}
else if ( paper = = PAPER_B5 )
{
paper_size_mm_ . cx = 176 ;
paper_size_mm_ . cy = 250 ;
}
else if ( paper = = PAPER_B6 )
{
paper_size_mm_ . cx = 125 ;
paper_size_mm_ . cy = 176 ;
}
else if ( paper = = PAPER_B5_LATERAL )
{
paper_size_mm_ . cx = 250 ;
paper_size_mm_ . cy = 176 ;
}
else if ( paper = = PAPER_B6_LATERAL )
{
paper_size_mm_ . cx = 176 ;
paper_size_mm_ . cy = 125 ;
}
else
{
2022-05-06 10:02:06 +00:00
paper_size_mm_ . cx = 210 ;
paper_size_mm_ . cy = 297 ;
2022-05-06 05:37:14 +00:00
}
}
2022-05-03 03:56:07 +00:00
int hg_scanner : : setting_restore ( void * data )
{
// restore ...
int count = 0 ;
setting_jsn_ . at ( " option_count " ) . get_to ( count ) ;
notify_setting_result_ = false ;
for ( int i = 1 ; i < count ; + + i )
restore ( i ) ;
notify_setting_result_ = true ;
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_CONFIGURATION_CHANGED ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : setting_help ( void * data )
{
2022-05-17 07:04:55 +00:00
int ret = SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
std : : string helpfile = helpfile_ ;
std : : string com = " xdg-open " ; //注意空格保留
2022-05-20 07:53:40 +00:00
printf ( " helpfile = %s \r \n " , helpfile . c_str ( ) ) ;
2022-05-03 03:56:07 +00:00
# ifdef WIN32
2022-05-27 01:24:28 +00:00
com = " " ;
2022-06-01 03:04:10 +00:00
helpfile . insert ( 0 , hg_log : : get_scanner_path ( ) ) ;
2022-05-03 03:56:07 +00:00
FILE * src = fopen ( helpfile . c_str ( ) , " rb " ) ;
if ( src )
fclose ( src ) ;
else
# else
if ( access ( helpfile . c_str ( ) , F_OK ) = = - 1 )
# endif
{
2022-05-30 03:04:26 +00:00
VLOG_MINI_1 ( LOG_LEVEL_DEBUG_INFO , " App_Help_pdf path is:%s system is:%d \r \n " , helpfile . c_str ( ) ) ;
2022-05-17 07:04:55 +00:00
ret = SCANNER_ERR_OPEN_FILE_FAILED ;
2022-05-03 03:56:07 +00:00
return ret ;
}
com + = helpfile ;
system ( com . c_str ( ) ) ;
2022-05-30 03:04:26 +00:00
VLOG_MINI_1 ( LOG_LEVEL_DEBUG_INFO , " App_Help_pdf path is:%s system is:%d \r \n " , helpfile . c_str ( ) ) ;
2022-05-03 03:56:07 +00:00
return ret ;
}
int hg_scanner : : setting_color_mode ( void * data )
{
std : : string str ( ( char * ) data ) ;
int old = image_prc_param_ . bits . color_mode ,
2022-05-17 07:04:55 +00:00
sub = SCANNER_ERR_OK ,
2022-05-03 03:56:07 +00:00
val = 0 ,
2022-05-17 07:04:55 +00:00
ret = SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
bool exact = check_range ( setting_map_ [ HG_BASE_SETTING_INDEX_COLOR_MODE ] , str ) ;
val = image_prc_param_ . bits . color_mode = match_best_color_mode ( str , NULL ) ;
sub = on_color_mode_changed ( val ) ;
image_prc_param_ . bits . color_mode = val ;
2022-05-17 07:04:55 +00:00
if ( sub = = SCANNER_ERR_NOT_EXACT )
2022-05-03 03:56:07 +00:00
{
image_prc_param_ . bits . color_mode = old ;
str = color_mode_string ( image_prc_param_ . bits . color_mode ) ;
2022-05-17 07:04:55 +00:00
ret = SCANNER_ERR_NOT_EXACT ;
2022-05-03 03:56:07 +00:00
}
else if ( sub )
{
ret = sub ;
image_prc_param_ . bits . color_mode = old ;
}
else if ( ! exact )
{
2022-05-17 07:04:55 +00:00
ret = SCANNER_ERR_NOT_EXACT ;
2022-05-03 03:56:07 +00:00
}
is_auto_matic_color = image_prc_param_ . bits . color_mode = = COLOR_MODE_AUTO_MATCH ? true : false ; // 等于COLOR_MODE_AUTO_MATCH 的时候颜色模式需要变为2 彩色模式图像参数和硬件参数都如此
2022-05-30 03:42:16 +00:00
VLOG_MINI_4 ( LOG_LEVEL_DEBUG_INFO , " Change color mode from %s to %s = %s color is =%s \n " , color_mode_string ( old ) . c_str ( ) , ( char * ) data , hg_scanner_err_name ( ret ) , str . c_str ( ) ) ;
2022-05-17 07:04:55 +00:00
if ( ret = = SCANNER_ERR_NOT_EXACT )
2022-05-03 03:56:07 +00:00
strcpy ( ( char * ) data , str . c_str ( ) ) ;
return ret ;
}
int hg_scanner : : setting_multi_out ( void * data )
2022-05-21 08:56:14 +00:00
{
is_multiout = * ( ( bool * ) data ) ;
2022-06-02 03:47:44 +00:00
int val = image_prc_param_ . bits . color_mode ;
VLOG_MINI_1 ( LOG_LEVEL_DEBUG_INFO , " image_prc_param_.bits.multi_out %d " , image_prc_param_ . bits . multi_out ) ;
if ( ! is_multiout )
on_color_mode_changed ( val ) ;
2022-05-21 08:56:14 +00:00
return SCANNER_ERR_OK ;
}
int hg_scanner : : setting_multi_out_type ( void * data )
2022-05-03 03:56:07 +00:00
{
2022-05-17 07:04:55 +00:00
int ret = SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
2022-06-02 03:47:44 +00:00
std : : string str ( ( char * ) data ) ;
2022-06-06 04:03:24 +00:00
2022-05-09 08:59:22 +00:00
bool exact = check_range ( setting_map_ [ HG_BASE_SETTING_INDEX_MULTI_OUT ] , str ) ;
2022-05-16 09:56:07 +00:00
int color ;
2022-05-03 03:56:07 +00:00
image_prc_param_ . bits . multi_out = match_best_multi_out ( str , NULL ) ;
2022-06-02 03:47:44 +00:00
save_multiout = str ;
2022-05-30 03:42:16 +00:00
VLOG_MINI_3 ( LOG_LEVEL_DEBUG_INFO , " set multi_out type from %s to %s = %s \n " , multi_out_string ( image_prc_param_ . bits . multi_out ) . c_str ( ) , ( char * ) data , hg_scanner_err_name ( ret ) ) ;
2022-05-17 01:46:26 +00:00
2022-05-16 09:56:07 +00:00
if ( image_prc_param_ . bits . multi_out = = MULTI_GRAY_AND_BW )
color = COLOR_MODE_256_GRAY ;
else
color = COLOR_MODE_24_BITS ;
2022-06-06 04:03:24 +00:00
2022-05-16 09:56:07 +00:00
on_color_mode_changed ( color ) ;
2022-05-03 03:56:07 +00:00
return ret ;
}
int hg_scanner : : setting_rid_color ( void * data )
{
std : : string str ( ( char * ) data ) ;
2022-05-17 07:04:55 +00:00
int ret = SCANNER_ERR_OK ,
2022-05-03 03:56:07 +00:00
color = - 1 ,
old = image_prc_param_ . bits . rid_color ;
bool exact = check_range ( setting_map_ [ HG_BASE_SETTING_INDEX_ERASE_COLOR ] , str ) ;
image_prc_param_ . bits . rid_color = match_best_rid_color ( str , NULL ) ;
on_color_mode_changed ( color ) ;
if ( ! exact )
{
2022-05-17 07:04:55 +00:00
ret = SCANNER_ERR_NOT_EXACT ;
2022-05-03 03:56:07 +00:00
strcpy ( ( char * ) data , str . c_str ( ) ) ;
}
return ret ;
}
int hg_scanner : : setting_rid_multi_red ( void * data )
{
image_prc_param_ . bits . rid_red = * ( ( bool * ) data ) ;
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : setting_rid_answer_red ( void * data )
{
image_prc_param_ . bits . rid_answer_red = * ( ( bool * ) data ) ;
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : setting_erase_background ( void * data )
{
image_prc_param_ . bits . erase_bakground = * ( ( bool * ) data ) ;
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : setting_erase_background_range ( void * data )
{
2022-05-17 07:04:55 +00:00
int ret = SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
erase_bkg_range_ = * ( ( int * ) data ) ;
if ( ! check_range ( setting_map_ [ HG_BASE_SETTING_INDEX_ERASE_BACKGROUND_RANGE ] , erase_bkg_range_ ) )
{
2022-05-17 07:04:55 +00:00
ret = SCANNER_ERR_NOT_EXACT ;
2022-05-03 03:56:07 +00:00
* ( ( int * ) data ) = erase_bkg_range_ ;
}
return ret ;
}
int hg_scanner : : setting_noise_optimize ( void * data )
{
image_prc_param_ . bits . noise_optimize = * ( ( bool * ) data ) ;
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : setting_noise_optimize_range ( void * data )
{
2022-05-17 07:04:55 +00:00
int ret = SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
noise_range_ = * ( ( int * ) data ) ;
if ( ! check_range ( setting_map_ [ HG_BASE_SETTING_INDEX_NOISE_OPTIMIZE_SIZE ] , noise_range_ ) )
{
2022-05-17 07:04:55 +00:00
ret = SCANNER_ERR_NOT_EXACT ;
2022-05-03 03:56:07 +00:00
* ( ( int * ) data ) = noise_range_ ;
}
return ret ;
}
int hg_scanner : : setting_paper ( void * data )
{
std : : string paper ( ( char * ) data ) ;
bool exact = check_range ( setting_map_ [ HG_BASE_SETTING_INDEX_PAPER ] , paper ) ;
2022-05-17 07:04:55 +00:00
int ret = SCANNER_ERR_OK , sub = SCANNER_ERR_OK ,
2022-05-03 03:56:07 +00:00
val = 0 ,
old = image_prc_param_ . bits . paper ;
val = image_prc_param_ . bits . paper = match_best_paper ( paper , NULL ) ;
sub = on_paper_changed ( val ) ;
image_prc_param_ . bits . paper = val ;
2022-05-17 07:04:55 +00:00
if ( sub = = SCANNER_ERR_NOT_EXACT )
2022-05-03 03:56:07 +00:00
{
ret = sub ;
paper = paper_string ( image_prc_param_ . bits . paper ) ;
}
else if ( sub )
{
ret = sub ;
image_prc_param_ . bits . paper = old ;
}
else if ( ! exact )
2022-05-17 07:04:55 +00:00
ret = SCANNER_ERR_NOT_EXACT ;
2022-05-03 03:56:07 +00:00
2022-05-30 03:42:16 +00:00
VLOG_MINI_3 ( LOG_LEVEL_DEBUG_INFO , " Change paper from %s to %s = %s \n " , paper_string ( old ) . c_str ( ) , ( char * ) data , hg_scanner_err_name ( ret ) ) ;
2022-05-03 03:56:07 +00:00
2022-05-17 07:04:55 +00:00
if ( ret = = SCANNER_ERR_NOT_EXACT )
2022-05-06 05:37:14 +00:00
strcpy ( ( char * ) data , paper . c_str ( ) ) ;
if ( old ! = image_prc_param_ . bits . paper )
reset_custom_area_range ( image_prc_param_ . bits . paper ) ;
2022-05-03 03:56:07 +00:00
return ret ;
}
int hg_scanner : : setting_paper_check ( void * data )
{
bool use = * ( ( bool * ) data ) ;
int ret = on_paper_check_changed ( use ) ;
2022-05-30 03:42:16 +00:00
VLOG_MINI_2 ( LOG_LEVEL_DEBUG_INFO , " Change paper size-checking %s = %s \n " , * ( ( bool * ) data ) ? " enabled " : " disabled " , hg_scanner_err_name ( ret ) ) ;
2022-05-03 03:56:07 +00:00
* ( ( bool * ) data ) = use ;
return ret ;
}
int hg_scanner : : setting_page ( void * data )
{
std : : string val ( ( char * ) data ) ;
bool exact = check_range ( setting_map_ [ HG_BASE_SETTING_INDEX_PAGE ] , val ) ;
2022-05-17 07:04:55 +00:00
int ret = exact ? SCANNER_ERR_OK : SCANNER_ERR_NOT_EXACT ;
2022-05-03 03:56:07 +00:00
2022-05-30 03:42:16 +00:00
VLOG_MINI_3 ( LOG_LEVEL_DEBUG_INFO , " Change page from %s to %s = %s \n " , page_string ( image_prc_param_ . bits . page ) . c_str ( ) , ( char * ) data , hg_scanner_err_name ( ret ) ) ;
2022-05-03 03:56:07 +00:00
image_prc_param_ . bits . page = match_best_page ( val , NULL ) ;
if ( ! exact )
strcpy ( ( char * ) data , val . c_str ( ) ) ;
return ret ;
}
int hg_scanner : : setting_page_omit_empty ( void * data )
{
2022-05-17 07:04:55 +00:00
int ret = SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
omit_empty_level_ = * ( ( int * ) data ) ;
if ( ! check_range ( setting_map_ [ HG_BASE_SETTING_INDEX_PAGE_OMIT_EMPTY_LEVEL ] , omit_empty_level_ ) )
{
2022-05-17 07:04:55 +00:00
ret = SCANNER_ERR_NOT_EXACT ;
2022-05-03 03:56:07 +00:00
* ( ( int * ) data ) = omit_empty_level_ ;
}
return ret ;
}
int hg_scanner : : setting_resolution ( void * data )
{
2022-05-17 07:04:55 +00:00
int ret = SCANNER_ERR_OK ,
2022-05-03 03:56:07 +00:00
old = resolution_ ,
2022-05-17 07:04:55 +00:00
sub = SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
resolution_ = * ( ( int * ) data ) ;
if ( ! check_range ( setting_map_ [ HG_BASE_SETTING_INDEX_RESOLUTION ] , resolution_ ) )
2022-05-17 07:04:55 +00:00
ret = SCANNER_ERR_NOT_EXACT ;
2022-05-03 03:56:07 +00:00
sub = on_resolution_changed ( resolution_ ) ;
2022-05-17 07:04:55 +00:00
if ( sub = = SCANNER_ERR_NOT_EXACT )
2022-05-03 03:56:07 +00:00
ret = sub ;
else if ( sub )
ret = sub ;
2022-05-30 03:42:16 +00:00
VLOG_MINI_3 ( LOG_LEVEL_DEBUG_INFO , " Change resolution from %d to %d = %s \n " , old , * ( ( int * ) data ) , hg_scanner_err_name ( ret ) ) ;
2022-05-03 03:56:07 +00:00
* ( ( int * ) data ) = resolution_ ;
return ret ;
}
int hg_scanner : : setting_exchagnge ( void * data )
{
image_prc_param_ . bits . exchange = * ( ( bool * ) data ) ;
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : setting_split_image ( void * data )
{
image_prc_param_ . bits . split = * ( ( bool * ) data ) ;
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : setting_automatic_skew ( void * data )
{
// automatic_skew_detection_ = *((bool*)data);
image_prc_param_ . bits . automatic_skew = * ( ( bool * ) data ) ;
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : setting_rid_hole ( void * data )
{
image_prc_param_ . bits . rid_hole = * ( ( bool * ) data ) ;
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : setting_rid_hoe_range ( void * data )
{
2022-05-17 07:04:55 +00:00
int ret = SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
rid_hole_range_ = * ( ( double * ) data ) ;
if ( ! check_range ( setting_map_ [ HG_BASE_SETTING_INDEX_RID_HOLE_RANGE ] , rid_hole_range_ ) )
{
2022-05-17 07:04:55 +00:00
ret = SCANNER_ERR_NOT_EXACT ;
2022-05-03 03:56:07 +00:00
* ( ( int * ) data ) = rid_hole_range_ ;
}
rid_hole_range_ * = 100 ;
2022-05-30 03:04:26 +00:00
VLOG_MINI_1 ( LOG_LEVEL_WARNING , " rid_hole_range_ = %f \r \n " , rid_hole_range_ ) ;
2022-05-03 03:56:07 +00:00
return ret ;
}
int hg_scanner : : setting_bright ( void * data )
{
2022-05-17 07:04:55 +00:00
int ret = SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
bright_ = * ( ( int * ) data ) ;
if ( ! check_range ( setting_map_ [ HG_BASE_SETTING_INDEX_BRIGHT ] , bright_ ) )
{
2022-05-17 07:04:55 +00:00
ret = SCANNER_ERR_NOT_EXACT ;
2022-05-03 03:56:07 +00:00
* ( ( int * ) data ) = bright_ ;
}
return ret ;
}
int hg_scanner : : setting_contrast ( void * data )
{
2022-05-17 07:04:55 +00:00
int ret = SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
contrast_ = * ( ( int * ) data ) ;
if ( ! check_range ( setting_map_ [ HG_BASE_SETTING_INDEX_CONTRAST ] , contrast_ ) )
{
2022-05-17 07:04:55 +00:00
ret = SCANNER_ERR_NOT_EXACT ;
2022-05-03 03:56:07 +00:00
* ( ( int * ) data ) = contrast_ ;
}
return ret ;
}
int hg_scanner : : setting_gamma ( void * data )
{
2022-05-17 07:04:55 +00:00
int ret = SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
gamma_ = * ( ( double * ) data ) ;
if ( ! check_range ( setting_map_ [ HG_BASE_SETTING_INDEX_GAMMA ] , gamma_ ) )
{
2022-05-17 07:04:55 +00:00
ret = SCANNER_ERR_NOT_EXACT ;
2022-05-03 03:56:07 +00:00
* ( ( double * ) data ) = gamma_ ;
}
return ret ;
}
int hg_scanner : : setting_sharpen ( void * data )
{
std : : string str ( ( char * ) data ) ;
2022-05-17 07:04:55 +00:00
int ret = SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
bool exact = check_range ( setting_map_ [ HG_BASE_SETTING_INDEX_SHARPEN ] , str ) ;
2022-05-30 03:04:26 +00:00
VLOG_MINI_2 ( LOG_LEVEL_DEBUG_INFO , " Change sharpen from %s to %s = " , sharpen_string ( image_prc_param_ . bits . sharpen ) . c_str ( ) , ( char * ) data ) ;
2022-05-03 03:56:07 +00:00
image_prc_param_ . bits . sharpen = match_best_sharpen ( str , NULL ) ;
if ( ! exact )
{
strcpy ( ( char * ) data , str . c_str ( ) ) ;
2022-05-17 07:04:55 +00:00
ret = SCANNER_ERR_NOT_EXACT ;
2022-05-03 03:56:07 +00:00
}
2022-05-30 03:04:26 +00:00
VLOG_MINI_1 ( LOG_LEVEL_DEBUG_INFO , " %d \n " , ret ) ;
2022-05-03 03:56:07 +00:00
return ret ;
}
int hg_scanner : : setting_dark_sample ( void * data )
{
image_prc_param_ . bits . dark_sample = * ( ( bool * ) data ) ;
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : setting_erase_black_frame ( void * data )
{
image_prc_param_ . bits . erase_black_frame = * ( ( bool * ) data ) ;
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : setting_threshold ( void * data )
{
2022-05-17 07:04:55 +00:00
int ret = SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
threshold_ = * ( ( int * ) data ) ;
if ( ! check_range ( setting_map_ [ HG_BASE_SETTING_INDEX_THRESHOLD ] , threshold_ ) )
{
2022-05-17 07:04:55 +00:00
ret = SCANNER_ERR_NOT_EXACT ;
2022-05-03 03:56:07 +00:00
* ( ( int * ) data ) = threshold_ ;
}
return ret ;
}
int hg_scanner : : setting_anti_noise ( void * data )
{
2022-05-17 07:04:55 +00:00
int ret = SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
anti_noise_ = * ( ( int * ) data ) ;
if ( ! check_range ( setting_map_ [ HG_BASE_SETTING_INDEX_ANTI_NOISE_LEVEL ] , anti_noise_ ) )
{
2022-05-17 07:04:55 +00:00
ret = SCANNER_ERR_NOT_EXACT ;
2022-05-03 03:56:07 +00:00
* ( ( int * ) data ) = anti_noise_ ;
}
return ret ;
}
int hg_scanner : : setting_margin ( void * data )
{
2022-05-17 07:04:55 +00:00
int ret = SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
margin_ = * ( ( int * ) data ) ;
if ( ! check_range ( setting_map_ [ HG_BASE_SETTING_INDEX_MARGIN ] , margin_ ) )
{
2022-05-17 07:04:55 +00:00
ret = SCANNER_ERR_NOT_EXACT ;
2022-05-03 03:56:07 +00:00
* ( ( int * ) data ) = margin_ ;
}
return ret ;
}
int hg_scanner : : setting_filling_background ( void * data )
{
std : : string str ( ( char * ) data ) ;
bool exact = check_range ( setting_map_ [ HG_BASE_SETTING_INDEX_FILL_BACKGROUND ] , str ) ;
2022-05-17 07:04:55 +00:00
int ret = exact ? SCANNER_ERR_OK : SCANNER_ERR_NOT_EXACT ;
2022-05-03 03:56:07 +00:00
image_prc_param_ . bits . fill_background = match_best_fill_background ( str , NULL ) ;
if ( ! exact )
{
strcpy ( ( char * ) data , str . c_str ( ) ) ;
2022-05-17 07:04:55 +00:00
ret = SCANNER_ERR_NOT_EXACT ;
2022-05-03 03:56:07 +00:00
}
return ret ;
}
int hg_scanner : : setting_is_permeate ( void * data )
{
image_prc_param_ . bits . is_permeate = * ( ( bool * ) data ) ;
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : setting_is_permeate_lv ( void * data )
{
2022-05-17 07:04:55 +00:00
int ret = SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
std : : string str ( ( char * ) data ) ;
bool exact = check_range ( setting_map_ [ HG_BASE_SETTING_INDEX_PERMEATE_LV ] , str ) ;
2022-05-30 03:04:26 +00:00
VLOG_MINI_2 ( LOG_LEVEL_DEBUG_INFO , " Change is_permeate_lv from %s to %s = " , is_permaeate_string ( image_prc_param_ . bits . is_permeate_lv_ ) . c_str ( ) , ( char * ) data ) ;
2022-05-03 03:56:07 +00:00
image_prc_param_ . bits . is_permeate_lv_ = match_best_permaeate_lv ( str , NULL ) ;
if ( ! exact )
{
strcpy ( ( char * ) data , str . c_str ( ) ) ;
2022-05-17 07:04:55 +00:00
ret = SCANNER_ERR_NOT_EXACT ;
2022-05-03 03:56:07 +00:00
}
2022-05-30 03:04:26 +00:00
VLOG_MINI_1 ( LOG_LEVEL_DEBUG_INFO , " %d \n " , ret ) ;
2022-05-03 03:56:07 +00:00
return ret ;
}
int hg_scanner : : setting_remove_morr ( void * data )
{
image_prc_param_ . bits . remove_morr = * ( ( bool * ) data ) ;
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : setting_error_extention ( void * data )
{
image_prc_param_ . bits . error_extention = * ( ( bool * ) data ) ;
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : setting_remove_texture ( void * data )
{
image_prc_param_ . bits . remove_txtture = * ( ( bool * ) data ) ;
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : setting_ultrasonic_check ( void * data )
{
bool use = * ( ( bool * ) data ) ;
int ret = on_ultrasonic_check_changed ( use ) ;
if ( ret )
* ( ( bool * ) data ) = use ;
return ret ;
}
int hg_scanner : : setting_staple_check ( void * data )
{
bool use = * ( ( bool * ) data ) ;
int ret = on_staple_check_changed ( use ) ;
if ( ret )
* ( ( bool * ) data ) = use ;
return ret ;
}
int hg_scanner : : setting_scan_mode ( void * data )
{
std : : string str ( ( char * ) data ) ;
bool exact = check_range ( setting_map_ [ HG_BASE_SETTING_INDEX_SCAN_MODE ] , str ) ;
2022-05-17 07:04:55 +00:00
int ret = exact ? SCANNER_ERR_OK : SCANNER_ERR_NOT_EXACT ;
2022-05-03 03:56:07 +00:00
2022-05-13 08:39:21 +00:00
if ( strcmp ( str . c_str ( ) , OPTION_VALUE_SMZS_LXSM ) = = 0 )
2022-05-03 03:56:07 +00:00
{
scan_count_ = - 1 ;
}
else
{
char key [ 20 ] ;
sprintf ( key , " %d " , setting_map_ [ HG_BASE_SETTING_INDEX_SCAN_COUNT ] ) ;
setting_jsn_ . at ( key ) . at ( " cur " ) . get_to ( scan_count_ ) ;
}
2022-05-30 03:04:26 +00:00
VLOG_MINI_1 ( LOG_LEVEL_DEBUG_INFO , " set scanning pages to %d \n " , scan_count_ ) ;
2022-05-03 03:56:07 +00:00
return ret ;
}
int hg_scanner : : setting_scan_count ( void * data )
{
2022-05-17 07:04:55 +00:00
int ret = SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
char key [ 20 ] ;
std : : string val ( " " ) ;
sprintf ( key , " %d " , setting_map_ [ HG_BASE_SETTING_INDEX_SCAN_MODE ] ) ;
setting_jsn_ . at ( key ) . at ( " cur " ) . get_to ( val ) ;
2022-05-13 08:39:21 +00:00
if ( val = = OPTION_VALUE_SMZS_LXSM )
2022-05-03 03:56:07 +00:00
{
scan_count_ = - 1 ;
}
else
{
scan_count_ = * ( ( int * ) data ) ;
}
2022-05-30 03:04:26 +00:00
VLOG_MINI_1 ( LOG_LEVEL_DEBUG_INFO , " set scanning pages to %d \n " , scan_count_ ) ;
2022-05-03 03:56:07 +00:00
return ret ;
}
int hg_scanner : : setting_text_direction ( void * data )
{
std : : string str ( ( char * ) data ) ;
bool exact = check_range ( setting_map_ [ HG_BASE_SETTING_INDEX_TEXT_DIRECTION ] , str ) ;
2022-05-17 07:04:55 +00:00
int ret = exact ? SCANNER_ERR_OK : SCANNER_ERR_NOT_EXACT ;
2022-05-03 03:56:07 +00:00
2022-05-30 03:04:26 +00:00
VLOG_MINI_3 ( LOG_LEVEL_DEBUG_INFO , " Change text direction from '%s' to '%s' = %s \n " , text_direction_string ( image_prc_param_ . bits . text_direction ) . c_str ( )
2022-05-30 03:42:16 +00:00
, ( char * ) data , hg_scanner_err_name ( ret ) ) ;
2022-05-03 03:56:07 +00:00
image_prc_param_ . bits . text_direction = match_best_text_direction ( str , NULL ) ;
if ( ! exact )
strcpy ( ( char * ) data , str . c_str ( ) ) ;
return ret ;
}
int hg_scanner : : setting_rotate_bkg_180 ( void * data )
{
image_prc_param_ . bits . rotate_back_180 = * ( ( bool * ) data ) ;
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : setting_fractate_check ( void * data )
{
image_prc_param_ . bits . fractate_check = * ( ( bool * ) data ) ;
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : setting_fractate_check_level ( void * data )
{
2022-05-17 07:04:55 +00:00
int ret = SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
fractate_level_ = * ( ( int * ) data ) ;
if ( ! check_range ( setting_map_ [ HG_BASE_SETTING_INDEX_FRACTATE_CHECK_LEVEL ] , fractate_level_ ) )
{
2022-05-17 07:04:55 +00:00
ret = SCANNER_ERR_NOT_EXACT ;
2022-05-03 03:56:07 +00:00
* ( ( int * ) data ) = fractate_level_ ;
}
return ret ;
}
int hg_scanner : : setting_skew_check ( void * data )
{
bool use = * ( ( bool * ) data ) ;
int ret = on_skew_check_changed ( use ) ;
if ( ret )
* ( ( bool * ) data ) = use ;
return ret ;
}
int hg_scanner : : setting_skew_check_level ( void * data )
{
int level = * ( ( int * ) data ) ;
bool exact = check_range ( setting_map_ [ HG_BASE_SETTING_INDEX_SKEW_CHECK_LEVEL ] , level ) ;
2022-05-17 07:04:55 +00:00
int ret = exact ? SCANNER_ERR_OK : SCANNER_ERR_NOT_EXACT ,
2022-05-03 03:56:07 +00:00
sub = on_skew_check_level_changed ( level ) ;
if ( sub )
{
ret = sub ;
}
if ( ret )
* ( ( int * ) data ) = level ;
return ret ;
}
2022-05-06 05:37:14 +00:00
int hg_scanner : : setting_is_custom_gamma ( void * data )
{
SANE_Bool * v = ( SANE_Bool * ) data ;
custom_gamma_ = * v = = SANE_TRUE ;
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-06 05:37:14 +00:00
}
int hg_scanner : : setting_custom_gamma_data ( void * data )
{
2022-05-06 06:37:52 +00:00
SANE_Gamma * gamma = ( SANE_Gamma * ) data ;
2022-05-06 05:37:14 +00:00
2022-05-06 08:39:00 +00:00
memcpy ( custom_gamma_val_ , gamma , sizeof ( * custom_gamma_val_ ) ) ;
2022-05-06 05:37:14 +00:00
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-06 05:37:14 +00:00
}
int hg_scanner : : setting_is_custom_area ( void * data )
{
SANE_Bool * v = ( SANE_Bool * ) data ;
custom_area_ = * v = = SANE_TRUE ;
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-06 05:37:14 +00:00
}
int hg_scanner : : setting_custom_area_left ( void * data )
{
SANE_Fixed * v = ( SANE_Fixed * ) data ;
2022-05-06 09:34:17 +00:00
custom_area_lt_x_ = * ( ( double * ) data ) ;
2022-05-06 05:37:14 +00:00
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-06 05:37:14 +00:00
}
int hg_scanner : : setting_custom_area_top ( void * data )
{
SANE_Fixed * v = ( SANE_Fixed * ) data ;
2022-05-06 09:34:17 +00:00
custom_area_lt_y_ = * ( ( double * ) data ) ;
2022-05-06 05:37:14 +00:00
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-06 05:37:14 +00:00
}
int hg_scanner : : setting_custom_area_right ( void * data )
{
SANE_Fixed * v = ( SANE_Fixed * ) data ;
2022-05-06 09:34:17 +00:00
custom_area_br_x_ = * ( ( double * ) data ) ;
2022-05-06 05:37:14 +00:00
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-06 05:37:14 +00:00
}
int hg_scanner : : setting_custom_area_bottom ( void * data )
{
SANE_Fixed * v = ( SANE_Fixed * ) data ;
2022-05-06 09:34:17 +00:00
custom_area_br_y_ = * ( ( double * ) data ) ;
2022-05-06 05:37:14 +00:00
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-06 05:37:14 +00:00
}
2022-05-03 03:56:07 +00:00
2022-05-09 07:02:00 +00:00
int hg_scanner : : setting_img_quality ( void * data )
{
std : : string str ( ( char * ) data ) ;
bool exact = check_range ( setting_map_ [ HG_BASE_SETTING_INDEX_IMG_QUALITY ] , str ) ;
2022-05-17 07:04:55 +00:00
int ret = exact ? SCANNER_ERR_OK : SCANNER_ERR_NOT_EXACT ;
2022-05-30 03:04:26 +00:00
VLOG_MINI_3 ( LOG_LEVEL_DEBUG_INFO , " Change quality from '%s' to '%s' = %s \n " , is_img_quality ( is_quality_ ) . c_str ( )
2022-05-30 03:42:16 +00:00
, ( char * ) data , hg_scanner_err_name ( ret ) ) ;
2022-05-09 07:02:00 +00:00
is_quality_ = match_best_img_quality ( str , NULL ) ;
2022-05-10 00:27:31 +00:00
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-09 07:02:00 +00:00
}
2022-05-20 07:53:40 +00:00
int hg_scanner : : setting_color_fill ( void * data )
{
is_color_fill = * ( ( bool * ) data ) ;
return SCANNER_ERR_OK ;
}
2022-05-03 03:56:07 +00:00
int hg_scanner : : on_color_mode_changed ( int & color_mode )
{
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : on_paper_changed ( int & paper )
{
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : on_paper_check_changed ( bool & check )
{
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : on_resolution_changed ( int & dpi )
{
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : on_ultrasonic_check_changed ( bool & check )
{
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : on_staple_check_changed ( bool & check )
{
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : on_skew_check_changed ( bool & check )
{
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : on_skew_check_level_changed ( int & check )
{
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
}
void hg_scanner : : on_device_reconnected ( void )
{
std : : lock_guard < std : : mutex > lock ( io_lock_ ) ;
2022-05-30 03:04:26 +00:00
VLOG_MINI_2 ( LOG_LEVEL_DEBUG_INFO , " %04x:%04x reconnected. \n " , io_ - > get_vid ( ) , io_ - > get_pid ( ) ) ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : set_setting_value ( int setting_no , void * data , int len )
{
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : on_scanner_closing ( bool force )
{
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
}
void hg_scanner : : thread_handle_usb_read ( void )
{
}
void hg_scanner : : init_settings ( const char * json_setting_text )
{
setting_jsn_ = jsonconfig : : load_json_from_text ( json_setting_text ) ;
int count = 0 ;
notify_setting_result_ = false ;
setting_jsn_ . at ( " option_count " ) . get_to ( count ) ;
for ( int sn = 1 ; sn < count ; + + sn )
{
char key [ 20 ] ;
std : : string val ( " " ) ;
sprintf ( key , " %d " , sn ) ;
2022-05-09 08:59:22 +00:00
# ifdef MAPPING_FUNCTION_IN_BASE
setting_jsn_ . at ( key ) . at ( " title " ) . get_to ( val ) ;
set_setting_map ( sn , val . c_str ( ) ) ;
# endif
2022-05-03 03:56:07 +00:00
setting_jsn_ . at ( key ) . at ( " type " ) . get_to ( val ) ;
if ( val = = " string " )
{
val = " " ;
setting_jsn_ . at ( key ) . at ( " default " ) . get_to ( val ) ;
char * buf = NULL ;
int size = 0 ;
setting_jsn_ . at ( key ) . at ( " size " ) . get_to ( size ) ;
buf = ( char * ) malloc ( size + 4 ) ;
bzero ( buf , size + 4 ) ;
strcpy ( buf , val . c_str ( ) ) ;
set_setting ( sn , buf , val . length ( ) ) ;
free ( buf ) ;
}
else if ( val = = " int " )
{
int v = 0 ;
setting_jsn_ . at ( key ) . at ( " default " ) . get_to ( v ) ;
set_setting ( sn , ( char * ) & v , sizeof ( v ) ) ;
}
else if ( val = = " float " )
{
double v = .0f ;
setting_jsn_ . at ( key ) . at ( " default " ) . get_to ( v ) ;
set_setting ( sn , ( char * ) & v , sizeof ( v ) ) ;
}
else if ( val = = " bool " )
{
bool v = false ;
setting_jsn_ . at ( key ) . at ( " default " ) . get_to ( v ) ;
set_setting ( sn , ( char * ) & v , sizeof ( v ) ) ;
}
}
setting_count_ = count ;
notify_setting_result_ = true ;
}
int hg_scanner : : on_scann_error ( int err )
{
status_ = err ;
2022-05-30 03:04:26 +00:00
VLOG_MINI_1 ( LOG_LEVEL_FATAL , " [xxx]Device status: 0x%x \n " , err ) ;
2022-05-03 03:56:07 +00:00
unsigned int e = err ;
2022-05-30 03:42:16 +00:00
return ui_ev_cb_ ( ( scanner_handle ) this , SANE_EVENT_ERROR , ( void * ) hg_scanner_err_name ( err ) , & e , NULL ) ;
2022-05-03 03:56:07 +00:00
}
2022-05-20 09:11:50 +00:00
int hg_scanner : : try_third_app_handle_start ( bool & handled )
{
int ret = SCANNER_ERR_OK ;
handled = ! async_io_ ;
if ( handled )
{
2022-05-23 03:52:53 +00:00
while ( wait_usb_result_ . try_wait ( ) )
std : : this_thread : : sleep_for ( std : : chrono : : milliseconds ( 3 ) ) ;
2022-06-01 03:04:10 +00:00
if ( ! wait_img_ . is_waiting ( ) | | ! wait_usb_ . is_waiting ( ) | | final_imgs_ . size ( ) )
2022-06-06 10:29:09 +00:00
{
while ( final_imgs_ . size ( ) = = 0 )
{
if ( wait_img_ . is_waiting ( ) & & wait_usb_ . is_waiting ( ) )
break ;
std : : this_thread : : sleep_for ( std : : chrono : : milliseconds ( 3 ) ) ;
}
if ( final_imgs_ . size ( ) = = 0 )
{
final_img_index_ = 0 ;
if ( user_cancel_ )
handled = false ;
else
ret = SCANNER_ERR_DEVICE_NO_PAPER ;
}
}
2022-05-20 09:11:50 +00:00
else if ( final_img_index_ )
{
final_img_index_ = 0 ;
2022-06-01 04:00:00 +00:00
if ( user_cancel_ )
handled = false ;
else
ret = SCANNER_ERR_DEVICE_NO_PAPER ;
2022-05-20 09:11:50 +00:00
}
else
handled = false ;
}
return ret ;
}
2022-05-23 03:52:53 +00:00
int hg_scanner : : try_third_app_after_start ( int err )
{
if ( ! async_io_ )
{
2022-06-01 09:16:09 +00:00
while ( wait_img_ . is_waiting ( ) & & ! wait_usb_ . is_waiting ( ) )
std : : this_thread : : sleep_for ( std : : chrono : : milliseconds ( 10 ) ) ;
if ( wait_img_ . is_waiting ( ) & & wait_usb_ . is_waiting ( ) )
err = status_ ;
2022-05-23 03:52:53 +00:00
}
return err ;
}
2022-06-01 03:04:10 +00:00
std : : shared_ptr < tiny_buffer > hg_scanner : : aquire_memory ( int size , bool from_usb )
2022-05-23 06:10:18 +00:00
{
2022-06-01 03:04:10 +00:00
std : : string lead ( from_usb ? " usb " : " imgp " ) , ext ( from_usb ? " jpg " : " dat " ) ;
unsigned int ind = from_usb ? usb_img_index_ : final_img_index_ ;
std : : shared_ptr < tiny_buffer > mem ( new tiny_buffer ( size , final_path_ . c_str ( ) , lead . c_str ( ) , ext . c_str ( ) , ind ) ) ;
2022-05-23 06:10:18 +00:00
2022-06-06 04:03:24 +00:00
if ( ! mem - > data ( 0 , ( unsigned int * ) & size ) )
2022-05-23 06:10:18 +00:00
{
mem . reset ( ) ;
2022-06-01 03:04:10 +00:00
LOG_INFO ( LOG_LEVEL_FATAL , " Can't aquire enough memory, working must be stopped! \n " ) ;
notify_ui_working_status ( STATU_DESC_SCANNER_ERR_INSUFFICIENT_MEMORY , SANE_EVENT_ERROR , SCANNER_ERR_INSUFFICIENT_MEMORY ) ;
stop ( ) ;
2022-05-23 06:10:18 +00:00
}
return mem ;
}
2022-05-03 03:56:07 +00:00
int hg_scanner : : notify_ui_working_status ( const char * msg , int ev , int status )
{
unsigned int s = status ;
return ui_ev_cb_ ( ( scanner_handle ) this , ev , ( void * ) msg , & s , NULL ) ;
}
bool hg_scanner : : waiting_for_memory_enough ( unsigned need_bytes )
{
return true ; // disable the memory control - added on 2022-03-22
bool ret = true ;
if ( cb_mem_ )
{
int ret = ui_ev_cb_ ( ( scanner_handle ) this , SANE_EVENT_IS_MEMORY_ENOUGH , NULL , & need_bytes , NULL ) ;
2022-05-17 07:04:55 +00:00
if ( ret = = SCANNER_ERR_INSUFFICIENT_MEMORY )
2022-05-03 03:56:07 +00:00
{
user_cancel_ = true ;
2022-05-17 07:04:55 +00:00
status_ = SCANNER_ERR_INSUFFICIENT_MEMORY ;
2022-05-03 03:56:07 +00:00
ret = false ;
}
2022-05-17 07:04:55 +00:00
else if ( ret = = SCANNER_ERR_NOT_ANY_MORE )
2022-05-03 03:56:07 +00:00
cb_mem_ = false ;
}
else
{
need_bytes * = 4 ;
void * buf = malloc ( need_bytes ) ;
bool first = true ;
while ( ! buf & & ! user_cancel_ )
{
if ( first )
{
2022-05-30 03:04:26 +00:00
VLOG_MINI_1 ( LOG_LEVEL_DEBUG_INFO , " Memory is too small for aquiring image(%u bytes), wait for ENOUGH ... \n " , need_bytes ) ;
2022-05-03 03:56:07 +00:00
notify_ui_working_status ( STATU_DESC_WAIT_FOR_MEM ) ;
first = false ;
}
std : : this_thread : : sleep_for ( std : : chrono : : milliseconds ( 30 ) ) ;
buf = malloc ( need_bytes ) ;
}
if ( ! first )
{
if ( buf )
{
2022-05-30 03:04:26 +00:00
VLOG_MINI_1 ( LOG_LEVEL_DEBUG_INFO , " waited for memory need(%u) \n " , need_bytes ) ;
2022-05-03 03:56:07 +00:00
}
else
{
2022-05-30 03:04:26 +00:00
VLOG_MINI_1 ( LOG_LEVEL_DEBUG_INFO , " canceled by user while waiting for memory need(%u) \n " , need_bytes ) ;
2022-05-03 03:56:07 +00:00
}
}
ret = ( ! user_cancel_ ) & & ( buf ! = NULL ) ;
if ( buf )
free ( buf ) ;
}
return ret ;
}
2022-05-30 06:46:37 +00:00
void hg_scanner : : copy_to_sane_image_header ( SANE_Parameters * header , int w , int h , int line_bytes , int channels , int bits )
2022-05-03 03:56:07 +00:00
{
if ( channels = = 3 )
header - > format = SANE_FRAME_RGB ;
else
header - > format = SANE_FRAME_GRAY ;
2022-05-30 06:46:37 +00:00
header - > depth = bits > = 8 ? 8 : bits ; // 此处指每一个颜色分量的位深, 我们的扫描仪固定为“8”
header - > last_frame = SANE_TRUE ; // 一幅图片如果各个分量相互分离, 则最后一个分量的时候设置为true。彩色图像RGB时也只有一“帧”, 所以也为true
2022-05-03 03:56:07 +00:00
header - > pixels_per_line = w ;
header - > lines = h ;
header - > bytes_per_line = line_bytes ;
}
2022-06-01 03:04:10 +00:00
int hg_scanner : : save_usb_data ( std : : shared_ptr < tiny_buffer > data )
2022-05-03 03:56:07 +00:00
{
2022-05-17 07:04:55 +00:00
int ret = SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
2022-05-10 00:27:31 +00:00
usb_img_index_ + + ;
2022-05-30 03:04:26 +00:00
VLOG_MINI_1 ( LOG_LEVEL_DEBUG_INFO , " USB read one picture with %u bytes \n " , data - > size ( ) ) ;
2022-06-01 03:04:10 +00:00
if ( ! data - > swap ( ) )
2022-05-03 03:56:07 +00:00
{
2022-06-01 03:04:10 +00:00
ret = SCANNER_ERR_OPEN_FILE_FAILED ;
2022-05-03 03:56:07 +00:00
}
else
{
imgs_ . Put ( data ) ;
2022-06-01 03:04:10 +00:00
if ( wait_img_ . is_waiting ( ) )
wait_img_ . notify ( ) ;
2022-05-03 03:56:07 +00:00
}
return ret ;
}
int hg_scanner : : save_final_image ( hg_imgproc : : LPIMGHEAD head , void * buf )
{
2022-05-30 06:46:37 +00:00
std : : string bw ( " " ) ;
2022-05-03 03:56:07 +00:00
final_img_index_ + + ;
2022-06-02 03:47:44 +00:00
bool is_1bit = false ;
if ( image_prc_param_ . bits . multi_out = = MULTI_OUT_ALL & & is_multiout )
{
if ( final_img_index_ % 3 = = 0 )
is_1bit = true ;
}
else if ( ( image_prc_param_ . bits . multi_out = = MULTI_GRAY_AND_BW | | image_prc_param_ . bits . multi_out = = MULTI_COLOR_AND_BW ) & & is_multiout )
{
if ( final_img_index_ % 2 = = 0 )
is_1bit = true ;
}
if ( img_conf_ . pixtype = = 0 | | ( is_1bit & & is_multiout ) )
2022-05-30 06:46:37 +00:00
{
int old = head - > line_bytes ;
bw = bmp_821 ( ( unsigned char * ) buf , head - > width , head - > height , & head - > line_bytes , async_io_ ) ;
buf = & bw [ 0 ] ;
head - > channels = head - > bits = 1 ;
head - > total_bytes = head - > line_bytes * head - > height ;
VLOG_MINI_4 ( LOG_LEVEL_DEBUG_INFO , " convert to 1-bit bmp(%d * %d), total = %u, len = %u \n " , head - > width , head - > height , head - > total_bytes , bw . length ( ) ) ;
}
2022-05-03 03:56:07 +00:00
if ( async_io_ )
{
SANE_Image img ;
2022-05-30 06:46:37 +00:00
copy_to_sane_image_header ( & img . header , head - > width , head - > height , head - > line_bytes , head - > channels , head - > bits ) ;
2022-05-03 03:56:07 +00:00
img . data = ( unsigned char * ) buf ;
img . bytes = head - > total_bytes ;
return ui_ev_cb_ ( ( scanner_handle ) this , SANE_EVENT_IMAGE_OK , & img , & final_img_index_ , NULL ) ;
}
2022-06-01 03:04:10 +00:00
if ( final_imgs_ . put ( head - > width , head - > height , head - > bits , head - > channels , head - > line_bytes , buf , head - > total_bytes
, final_path_ . c_str ( ) , " final " , " dat " , final_img_index_ ) )
2022-05-30 09:36:42 +00:00
return SCANNER_ERR_OK ;
else
2022-06-01 03:04:10 +00:00
return SCANNER_ERR_INSUFFICIENT_MEMORY ;
2022-05-03 03:56:07 +00:00
}
2022-05-17 01:46:26 +00:00
int hg_scanner : : is_running ( void )
{
if ( ! scan_life_ )
return THREAD_RUNNING_IDLE ;
int run = THREAD_RUNNING_IDLE ;
if ( ! wait_usb_ . is_waiting ( ) )
run | = THREAD_RUNNING_USB ;
if ( ! wait_img_ . is_waiting ( ) )
run | = THREAD_RUNNING_IMAGE ;
return run ;
}
2022-05-03 03:56:07 +00:00
int hg_scanner : : reset_io ( usb_io * io )
{
online_ = false ;
if ( ! io )
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_INVALID_PARAMETER ;
2022-05-03 03:56:07 +00:00
{
std : : lock_guard < std : : mutex > lock ( io_lock_ ) ;
usb_io * old = io_ ;
io - > add_ref ( ) ;
io_ = io ;
status_ = io_ - > last_error ( ) ;
2022-05-17 07:04:55 +00:00
online_ = status_ = = SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
if ( old )
old - > release ( ) ;
}
on_device_reconnected ( ) ;
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : io_disconnected ( void )
{
std : : lock_guard < std : : mutex > lock ( io_lock_ ) ;
online_ = false ;
io_ - > on_disconnected ( ) ;
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
}
void hg_scanner : : set_ui_callback ( sane_callback cb , bool enable_async_io )
{
ui_ev_cb_ = cb ? cb : ui_default_callback ;
async_io_ = enable_async_io ;
}
int hg_scanner : : get_pid ( void )
{
std : : lock_guard < std : : mutex > lock ( io_lock_ ) ;
return io_ - > get_pid ( ) ;
}
int hg_scanner : : get_vid ( void )
{
std : : lock_guard < std : : mutex > lock ( io_lock_ ) ;
return io_ - > get_vid ( ) ;
}
int hg_scanner : : close ( bool force )
{
int ret = on_scanner_closing ( force ) ;
online_ = false ;
2022-05-17 07:04:55 +00:00
if ( ret = = SCANNER_ERR_OK )
2022-05-03 03:56:07 +00:00
{
run_ = false ;
wait_usb_ . notify ( ) ;
wait_img_ . notify ( ) ;
if ( ! scan_life_ )
{
std : : lock_guard < std : : mutex > lock ( io_lock_ ) ;
if ( io_ )
{
io_ - > close ( ) ;
io_ - > release ( ) ;
io_ = NULL ;
}
}
else if ( io_ )
{
2022-05-30 03:04:26 +00:00
LOG_INFO ( LOG_LEVEL_WARNING , " close scanner: USB thread or Image thread is still running. \n " ) ;
2022-05-03 03:56:07 +00:00
io_ - > close ( ) ;
io_ - > release ( ) ;
io_ = NULL ;
}
2022-05-17 07:04:55 +00:00
status_ = SCANNER_ERR_NOT_OPEN ;
2022-05-03 03:56:07 +00:00
}
return ret ;
}
int hg_scanner : : set_setting ( int setting_no , void * data , int len )
{
// NOTE: the array of 'func' must be ONE to ONE of the HG_BASE_SETTING_INDEX_xxx
int ( hg_scanner : : * func [ ] ) ( void * ) = { & hg_scanner : : setting_restore
, & hg_scanner : : setting_help
, & hg_scanner : : setting_multi_out
2022-05-21 08:56:14 +00:00
, & hg_scanner : : setting_multi_out_type
, & hg_scanner : : setting_color_mode
2022-05-03 03:56:07 +00:00
, & hg_scanner : : setting_rid_color
, & hg_scanner : : setting_rid_multi_red
, & hg_scanner : : setting_rid_answer_red
, & hg_scanner : : setting_erase_background
, & hg_scanner : : setting_erase_background_range
, & hg_scanner : : setting_noise_optimize
, & hg_scanner : : setting_noise_optimize_range
, & hg_scanner : : setting_paper
, & hg_scanner : : setting_paper_check
2022-05-06 05:37:14 +00:00
, & hg_scanner : : setting_is_custom_area
, & hg_scanner : : setting_custom_area_left
, & hg_scanner : : setting_custom_area_right
, & hg_scanner : : setting_custom_area_top
, & hg_scanner : : setting_custom_area_bottom
2022-05-03 03:56:07 +00:00
, & hg_scanner : : setting_page
, & hg_scanner : : setting_page_omit_empty
, & hg_scanner : : setting_resolution
2022-05-09 07:02:00 +00:00
, & hg_scanner : : setting_img_quality
2022-05-03 03:56:07 +00:00
, & hg_scanner : : setting_exchagnge
, & hg_scanner : : setting_split_image
, & hg_scanner : : setting_automatic_skew
, & hg_scanner : : setting_rid_hole
, & hg_scanner : : setting_rid_hoe_range
2022-05-06 05:37:14 +00:00
, & hg_scanner : : setting_is_custom_gamma // 2022-05-05
2022-05-03 03:56:07 +00:00
, & hg_scanner : : setting_bright
, & hg_scanner : : setting_contrast
, & hg_scanner : : setting_gamma
2022-05-06 05:37:14 +00:00
, & hg_scanner : : setting_custom_gamma_data
2022-05-03 03:56:07 +00:00
, & hg_scanner : : setting_sharpen
, & hg_scanner : : setting_dark_sample
, & hg_scanner : : setting_erase_black_frame
, & hg_scanner : : setting_threshold
, & hg_scanner : : setting_anti_noise
, & hg_scanner : : setting_margin
, & hg_scanner : : setting_filling_background
, & hg_scanner : : setting_is_permeate
, & hg_scanner : : setting_is_permeate_lv
2022-05-20 07:53:40 +00:00
, & hg_scanner : : setting_color_fill
2022-05-03 03:56:07 +00:00
, & hg_scanner : : setting_remove_morr
, & hg_scanner : : setting_error_extention
, & hg_scanner : : setting_remove_texture
, & hg_scanner : : setting_ultrasonic_check
, & hg_scanner : : setting_staple_check
, & hg_scanner : : setting_scan_mode
, & hg_scanner : : setting_scan_count
, & hg_scanner : : setting_text_direction
, & hg_scanner : : setting_rotate_bkg_180
, & hg_scanner : : setting_fractate_check
, & hg_scanner : : setting_fractate_check_level
, & hg_scanner : : setting_skew_check
2022-05-20 07:53:40 +00:00
, & hg_scanner : : setting_skew_check_level
2022-05-03 03:56:07 +00:00
} ;
bool hit = false ;
2022-05-17 07:04:55 +00:00
int ret = SCANNER_ERR_OUT_OF_RANGE ;
2022-05-03 03:56:07 +00:00
char sn [ 20 ] ;
sprintf ( sn , " %d " , setting_no ) ;
for ( size_t i = 0 ; i < ARRAY_SIZE ( func ) ; + + i )
{
if ( setting_map_ [ i ] = = setting_no )
{
ret = ( this - > * func [ i ] ) ( data ) ;
hit = true ;
break ;
}
}
if ( ! hit )
{
2022-05-30 03:04:26 +00:00
VLOG_MINI_1 ( LOG_LEVEL_WARNING , " Setting %d is not found in base setting functions. \n " , setting_no ) ;
2022-05-03 03:56:07 +00:00
ret = set_setting_value ( setting_no , data , len ) ;
}
2022-05-17 07:04:55 +00:00
if ( ret = = SCANNER_ERR_OK | | ret = = SCANNER_ERR_NOT_EXACT | | ret = = SCANNER_ERR_CONFIGURATION_CHANGED )
2022-05-03 03:56:07 +00:00
{
std : : string type ( " " ) , name ( " " ) ;
setting_jsn_ . at ( sn ) . at ( " type " ) . get_to ( type ) ;
setting_jsn_ . at ( sn ) . at ( " title " ) . get_to ( name ) ;
if ( type = = " string " )
{
setting_jsn_ . at ( sn ) . at ( " cur " ) = ( char * ) data ;
type = ( char * ) data ;
}
else if ( type = = " int " )
{
setting_jsn_ . at ( sn ) . at ( " cur " ) = * ( ( int * ) data ) ;
sprintf ( sn , " %d " , * ( ( int * ) data ) ) ;
type = sn ;
}
else if ( type = = " float " )
{
setting_jsn_ . at ( sn ) . at ( " cur " ) = * ( ( double * ) data ) ;
sprintf ( sn , " %f " , * ( ( double * ) data ) ) ;
type = sn ;
}
else if ( type = = " bool " )
{
setting_jsn_ . at ( sn ) . at ( " cur " ) = * ( ( bool * ) data ) ;
type = * ( ( bool * ) data ) ? " true " : " false " ;
}
if ( notify_setting_result_ )
{
2022-05-20 07:18:49 +00:00
name . insert ( 0 , " \350 \256 \276 \347 \275 \256 \" " ) ;
name + = " \" \345 \200 \274 \344 \270 \272 \" " ;
name + = type + " \" \346 \210 \220 \345 \212 \237 \343 \200 \202 " ;
2022-05-03 03:56:07 +00:00
notify_ui_working_status ( name . c_str ( ) ) ;
}
}
else if ( notify_setting_result_ )
{
std : : string name ( " " ) ;
if ( setting_jsn_ . contains ( sn ) )
{
setting_jsn_ . at ( sn ) . at ( " title " ) . get_to ( name ) ;
}
else
2022-05-20 07:18:49 +00:00
name = std : : string ( " \350 \256 \276 \347 \275 \256 \351 \241 \271 " ) + sn ;
name . insert ( 0 , " \350 \256 \276 \347 \275 \256 \" " ) ;
2022-05-30 03:42:16 +00:00
name + = std : : string ( " \" \345 \200 \274 \345 \244 \261 \350 \264 \245 : " ) + hg_scanner_err_name ( ret ) ;
2022-05-03 03:56:07 +00:00
notify_ui_working_status ( name . c_str ( ) ) ;
}
return ret ;
}
int hg_scanner : : get_setting ( int setting_no , char * json_txt_buf , int * len )
{
if ( ! len )
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_INVALID_PARAMETER ;
2022-05-03 03:56:07 +00:00
if ( setting_no = = 0 )
{
int count = 0 ;
setting_jsn_ . at ( " option_count " ) . get_to ( count ) ;
* len = count ;
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
}
if ( setting_count_ < = setting_no | | setting_no < 0 )
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OUT_OF_RANGE ;
2022-05-03 03:56:07 +00:00
char sn [ 20 ] ;
2022-05-06 05:37:14 +00:00
std : : string text ( " " ) , name ( " " ) , tag ( " " ) ;
int add = 0 ;
bool is_gamma = false , is_area_x = false , is_area_y = false ;
2022-05-03 03:56:07 +00:00
sprintf ( sn , " %d " , setting_no ) ;
if ( ! setting_jsn_ . contains ( sn ) )
2022-05-30 03:04:26 +00:00
VLOG_MINI_2 ( LOG_LEVEL_FATAL , " !!!option(%d - %s) is not found. \n " , setting_no , sn ) ;
2022-05-03 03:56:07 +00:00
text = setting_jsn_ . at ( sn ) . dump ( ) ;
2022-05-06 05:37:14 +00:00
setting_jsn_ . at ( sn ) . at ( " name " ) . get_to ( name ) ;
2022-05-23 03:52:53 +00:00
if ( name = = SANE_STD_OPT_NAME_CUSTOM_AREA_LEFT | | name = = SANE_STD_OPT_NAME_CUSTOM_AREA_RIGHT )
2022-05-06 05:37:14 +00:00
{
is_area_x = true ;
add = 20 ;
}
2022-05-23 03:52:53 +00:00
else if ( name = = SANE_STD_OPT_NAME_CUSTOM_AREA_TOP | | name = = SANE_STD_OPT_NAME_CUSTOM_AREA_BOTTOM )
2022-05-06 05:37:14 +00:00
{
is_area_y = true ;
add = 20 ;
}
if ( * len < = text . length ( ) + add )
2022-05-03 03:56:07 +00:00
{
2022-05-06 05:37:14 +00:00
* len = text . length ( ) + 8 + add ;
2022-05-03 03:56:07 +00:00
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_INSUFFICIENT_MEMORY ;
2022-05-03 03:56:07 +00:00
}
2022-05-06 05:37:14 +00:00
if ( is_gamma )
{
name = " " ;
2022-05-06 06:37:52 +00:00
add = 3 * 256 ;
2022-05-06 08:39:00 +00:00
sprintf ( sn , " [%u " , custom_gamma_val_ - > table [ 0 ] ) ;
2022-05-06 05:37:14 +00:00
name + = sn ;
for ( int i = 1 ; i < add ; + + i )
{
2022-05-06 08:39:00 +00:00
sprintf ( sn , " ,%u " , custom_gamma_val_ - > table [ i ] ) ;
2022-05-06 05:37:14 +00:00
name + = sn ;
}
name + = " ] " ;
tag = " \" cur \" : " ;
}
else if ( is_area_x )
{
sprintf ( sn , " %u.0 " , paper_size_mm_ . cx ) ;
name = sn ;
tag = " \" max \" : " ;
}
else if ( is_area_y )
{
sprintf ( sn , " %u.0 " , paper_size_mm_ . cy ) ;
name = sn ;
tag = " \" max \" : " ;
}
if ( ! tag . empty ( ) )
{
size_t pos = text . find ( tag ) , end = pos ;
if ( pos ! = std : : string : : npos )
{
pos + = tag . length ( ) ;
end = pos ;
while ( end < text . length ( ) )
{
if ( text [ end ] = = ' , ' | | text [ end ] = = ' } ' | | text [ end ] = = ' ] ' | | text [ end ] = = ' \r ' | | text [ end ] = = ' \n ' )
break ;
end + + ;
}
if ( end > pos )
text . replace ( pos , end - pos , name ) ;
else
text . insert ( end , name ) ;
}
}
2022-05-03 03:56:07 +00:00
strcpy ( json_txt_buf , text . c_str ( ) ) ;
* len = text . length ( ) ;
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
}
std : : string hg_scanner : : name ( void )
{
return name_ ;
}
int hg_scanner : : status ( void )
{
2022-06-01 09:16:09 +00:00
if ( ! wait_usb_ . is_waiting ( ) | | ! wait_img_ . is_waiting ( ) )
return SCANNER_ERR_DEVICE_BUSY ;
else
return status_ ;
2022-05-03 03:56:07 +00:00
}
bool hg_scanner : : is_online ( void )
{
return online_ ;
}
int hg_scanner : : start ( void )
{
user_cancel_ = false ;
return status_ ;
}
int hg_scanner : : get_image_info ( SANE_Parameters * ii )
{
2022-05-17 07:04:55 +00:00
int ret = SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
IMH imh ;
bzero ( & imh , sizeof ( imh ) ) ;
2022-05-20 06:46:25 +00:00
bzero ( ii , sizeof ( * ii ) ) ;
2022-06-01 03:04:10 +00:00
while ( ( ! wait_img_ . is_waiting ( ) | | ! wait_usb_ . is_waiting ( ) ) & & final_imgs_ . size ( ) < = 0 )
2022-05-03 03:56:07 +00:00
this_thread : : sleep_for ( chrono : : milliseconds ( 10 ) ) ;
2022-06-01 03:04:10 +00:00
if ( final_imgs_ . size ( ) < = 0 )
2022-05-17 07:04:55 +00:00
ret = SCANNER_ERR_NO_DATA ;
2022-05-03 03:56:07 +00:00
else
{
if ( ! final_imgs_ . front ( & imh ) )
2022-05-17 07:04:55 +00:00
ret = SCANNER_ERR_NO_DATA ;
2022-05-03 03:56:07 +00:00
else
2022-05-30 06:46:37 +00:00
copy_to_sane_image_header ( ii , imh . width , imh . height , imh . line_bytes , imh . channels , imh . bits ) ;
2022-05-03 03:56:07 +00:00
}
2022-05-20 06:46:25 +00:00
2022-05-20 09:11:50 +00:00
if ( ret = = SCANNER_ERR_NO_DATA /*&& final_img_index_ == 0*/ )
2022-05-20 06:46:25 +00:00
{
2022-05-23 03:52:53 +00:00
if ( status_ ! = SCANNER_ERR_OK & & status_ ! = SCANNER_ERR_DEVICE_BUSY )
ret = SCANNER_ERR_NO_DATA ;
2022-05-20 06:46:25 +00:00
else
{
2022-05-30 06:46:37 +00:00
ii - > depth = image_prc_param_ . bits . color_mode = = COLOR_MODE_BLACK_WHITE ? 1 : 8 ;
2022-05-20 06:46:25 +00:00
ii - > last_frame = SANE_TRUE ;
ii - > format = image_prc_param_ . bits . color_mode = = COLOR_MODE_24_BITS | | image_prc_param_ . bits . color_mode = = COLOR_MODE_AUTO_MATCH ?
SANE_FRAME_RGB : SANE_FRAME_GRAY ;
SIZE paper = paper_size ( image_prc_param_ . bits . paper ) ;
ii - > pixels_per_line = paper . cx * 1.0f / 25.4 * resolution_ + .5f ;
ii - > lines = paper . cy * 1.0f / 25.4 * resolution_ + .5f ;
ii - > bytes_per_line = ii - > format = = SANE_FRAME_RGB ? ii - > pixels_per_line * 3 : ii - > pixels_per_line ;
if ( ii - > bytes_per_line > ii - > pixels_per_line )
imh . bits = 24 ;
else
imh . bits = 8 ;
ret = SCANNER_ERR_OK ;
}
}
2022-05-30 03:42:16 +00:00
VLOG_MINI_4 ( LOG_LEVEL_DEBUG_INFO , " Get image info(%d * %d * %d) = %s \n " , ii - > pixels_per_line , ii - > lines , imh . bits , hg_scanner_err_name ( ret ) ) ;
2022-05-03 03:56:07 +00:00
return ret ;
}
int hg_scanner : : read_image_data ( unsigned char * buf , int * len )
{
if ( ! len )
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_INVALID_PARAMETER ;
2022-05-03 03:56:07 +00:00
if ( ! buf )
{
IMH imh ;
final_imgs_ . front ( & imh ) ;
* len = imh . bytes ;
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_INSUFFICIENT_MEMORY ;
2022-05-03 03:56:07 +00:00
}
2022-06-01 03:04:10 +00:00
if ( final_imgs_ . size ( ) > 0 )
2022-05-03 03:56:07 +00:00
{
int fetch = * len ;
bool over = false ;
final_imgs_ . fetch_front ( buf , len , & over ) ;
2022-05-17 07:04:55 +00:00
return over ? SCANNER_ERR_NO_DATA : SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
}
else
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_NO_DATA ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : stop ( void )
{
user_cancel_ = true ;
return status_ ;
}
int hg_scanner : : reset ( void )
{
return status_ ;
}
int hg_scanner : : device_io_control ( unsigned long code , void * data , unsigned * len )
{
if ( code = = IO_CTRL_CODE_RESTORE_SETTINGS )
{
setting_restore ( data ) ;
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_CONFIGURATION_CHANGED ;
2022-05-03 03:56:07 +00:00
}
else if ( code = = IO_CTRL_CODE_GET_DEFAULT_VALUE )
{
char * jsn_txt = NULL ;
int size = 0 ;
json jsn ;
int ret = get_setting ( * len , jsn_txt , & size ) ;
2022-05-17 07:04:55 +00:00
if ( ret = = SCANNER_ERR_INSUFFICIENT_MEMORY )
2022-05-03 03:56:07 +00:00
{
jsn_txt = ( char * ) malloc ( size + 4 ) ;
bzero ( jsn_txt , size + 4 ) ;
get_setting ( * len , jsn_txt , & size ) ;
jsn = jsonconfig : : load_json_from_text ( jsn_txt ) ;
free ( jsn_txt ) ;
if ( get_default_value ( data , & jsn ) )
2022-05-17 07:04:55 +00:00
ret = SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
else
2022-05-17 07:04:55 +00:00
ret = SCANNER_ERR_DATA_DAMAGED ;
2022-05-03 03:56:07 +00:00
}
return ret ;
}
else if ( code = = IO_CTRL_CODE_CLEAR_ROLLER_COUNT )
{
int count = get_roller_num ( ) ;
if ( len )
* len = count ;
return clear_roller_num ( ) ;
}
else if ( code = = IO_CTRL_CODE_SET_FINAL_IMAGE_FORMAT )
{
SANE_FinalImgFormat * fmt = ( SANE_FinalImgFormat * ) data ;
return set_final_image_format ( fmt ) ;
}
else if ( code = = IO_CTRL_CODE_TEST_SINGLE )
{
return set_leaflet_scan ( ) ;
}
else if ( code = = IO_CTRL_CODE_SET_AUTO_COLOR_TYPE )
{
return set_auto_color_type ( ) ;
}
else if ( code = = IO_CTRL_CODE_GET_HARDWARE_VERSION )
{
std : : string fw = get_firmware_version ( ) ;
if ( * len < fw . size ( ) )
{
* len = fw . size ( ) ;
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_INSUFFICIENT_MEMORY ;
2022-05-03 03:56:07 +00:00
}
char * buf = strcpy ( ( char * ) data , fw . c_str ( ) ) ;
if ( buf )
{
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
}
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_DATA_DAMAGED ;
2022-05-03 03:56:07 +00:00
}
else if ( code = = IO_CTRL_CODE_GET_SERIAL )
{
std : : string ser = get_serial_num ( ) ;
if ( * len < ser . size ( ) )
{
* len = ser . size ( ) ;
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_INSUFFICIENT_MEMORY ;
2022-05-03 03:56:07 +00:00
}
char * buf = strcpy ( ( char * ) data , ser . c_str ( ) ) ;
if ( buf )
{
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
}
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_DATA_DAMAGED ;
2022-05-03 03:56:07 +00:00
}
else if ( code = = IO_CTRL_CODE_GET_HARDWARE_VERSION )
{
std : : string ip = get_ip ( ) ;
if ( * len < ip . size ( ) )
{
* len = ip . size ( ) ;
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_INSUFFICIENT_MEMORY ;
2022-05-03 03:56:07 +00:00
}
char * buf = strcpy ( ( char * ) data , ip . c_str ( ) ) ;
if ( buf )
{
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
}
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_DATA_DAMAGED ;
2022-05-03 03:56:07 +00:00
}
else if ( code = = IO_CTRL_CODE_GET_PAPER_ON )
{
return get_scanner_paperon ( ( SANE_Bool * ) data ) ;
}
else if ( code = = IO_CTRL_CODE_GET_POWER_LEVEL )
{
int val = 0 ,
2022-05-17 07:04:55 +00:00
ret = SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
if ( * len < sizeof ( int * ) )
{
* len = sizeof ( int * ) ;
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_INSUFFICIENT_MEMORY ;
2022-05-03 03:56:07 +00:00
}
ret = get_sleep_time ( val ) ;
2022-05-17 07:04:55 +00:00
if ( ret = = SCANNER_ERR_OK )
2022-05-03 03:56:07 +00:00
{
* ( ( int * ) data ) = val ;
}
return ret ;
}
else if ( code = = IO_CTRL_CODE_SET_POWER_LEVEL )
{
int val = * ( ( int * ) data ) ;
int sleeptime = 0 ;
switch ( val )
{
case SANE_POWER_NONE :
sleeptime = 0 ;
break ;
case SANE_POWER_MINUTES_5 :
sleeptime = 300 ;
break ;
case SANE_POWER_MINUTES_10 :
sleeptime = 600 ;
break ;
case SANE_POWER_MINUTES_20 :
sleeptime = 1200 ;
break ;
case SANE_POWER_MINUTES_30 :
sleeptime = 1800 ;
break ;
case SANE_POWER_MINUTES_60 :
sleeptime = 3600 ;
break ;
case SANE_POWER_MINUTES_120 :
sleeptime = 7200 ;
break ;
case SANE_POWER_MINUTES_240 :
sleeptime = 14400 ;
break ;
default :
sleeptime = 0 ;
break ;
}
return set_sleep_time ( sleeptime ) ;
}
2022-05-06 05:37:14 +00:00
else if ( code = = IO_CTRL_CODE_GET_CUSTOM_GAMMA )
{
2022-05-06 06:37:52 +00:00
SANE_Gamma * v = ( SANE_Gamma * ) data ;
2022-05-06 08:39:00 +00:00
memcpy ( v , custom_gamma_val_ , sizeof ( * custom_gamma_val_ ) ) ;
2022-05-06 05:37:14 +00:00
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-06 05:37:14 +00:00
}
2022-05-06 06:37:52 +00:00
else if ( code = = IO_CTRL_CODE_SET_CUSTOM_GAMMA )
2022-05-06 05:37:14 +00:00
{
2022-05-06 06:37:52 +00:00
SANE_Gamma * v = ( SANE_Gamma * ) data ;
2022-05-06 08:39:00 +00:00
memcpy ( custom_gamma_val_ , v , sizeof ( * custom_gamma_val_ ) ) ;
2022-05-06 05:37:14 +00:00
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-06 05:37:14 +00:00
}
2022-05-19 10:15:14 +00:00
else if ( code = = IO_CTRL_CODE_DISPLAY_APP_HELP )
{
2022-05-21 01:35:08 +00:00
//setting_help(data);
2022-05-19 10:15:14 +00:00
return SCANNER_ERR_OK ;
}
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_DEVICE_NOT_SUPPORT ;
2022-05-03 03:56:07 +00:00
}
std : : string hg_scanner : : get_firmware_version ( void )
{
2022-05-11 01:36:23 +00:00
return BRAND_DEVICE_NOT_SUPPORT ;
2022-05-03 03:56:07 +00:00
}
std : : string hg_scanner : : get_serial_num ( void )
{
2022-05-11 01:36:23 +00:00
return BRAND_DEVICE_NOT_SUPPORT ;
2022-05-03 03:56:07 +00:00
}
std : : string hg_scanner : : get_ip ( void )
{
2022-05-11 01:36:23 +00:00
return BRAND_DEVICE_NOT_SUPPORT ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : get_roller_num ( void )
{
2022-05-13 08:39:21 +00:00
return - 2 ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : clear_roller_num ( void )
{
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_DEVICE_NOT_SUPPORT ;
2022-05-03 03:56:07 +00:00
}
2022-05-13 08:39:21 +00:00
int hg_scanner : : get_history_count ( void )
{
return - 2 ;
}
2022-05-03 03:56:07 +00:00
//////////////////////////////////////////////////////////////////////////////////////////////////////
int hg_scanner : : set_leaflet_scan ( void )
{
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_NO_DATA ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : get_abuot_info ( void )
{
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_NO_DATA ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : restore_default_setting ( void )
{
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_NO_DATA ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : set_final_image_format ( SANE_FinalImgFormat * fmt )
{
switch ( fmt - > img_format )
{
case SANE_IMAGE_TYPE_BMP :
img_type_ = " .bmp " ;
break ;
case SANE_IMAGE_TYPE_PNG :
img_type_ = " .png " ;
break ;
case SANE_IMAGE_TYPE_JPG :
img_type_ = " .jpg " ;
break ;
case SANE_IMAGE_TYPE_TIFF :
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_INVALID_PARAMETER ;
2022-05-03 03:56:07 +00:00
case SANE_IMAGE_TYPE_WEBP :
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_INVALID_PARAMETER ;
2022-05-03 03:56:07 +00:00
case SANE_IMAGE_TYPE_PDF :
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_INVALID_PARAMETER ;
2022-05-03 03:56:07 +00:00
case SANE_IMAGE_TYPE_GIF :
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_INVALID_PARAMETER ;
2022-05-03 03:56:07 +00:00
case SANE_IMAGE_TYPE_SVG :
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_INVALID_PARAMETER ;
2022-05-03 03:56:07 +00:00
default :
img_type_ = " " ;
break ;
}
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : get_compression_format ( void )
{
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_DEVICE_NOT_SUPPORT ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : set_compression_format ( void )
{
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_DEVICE_NOT_SUPPORT ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : set_auto_color_type ( void )
{
is_auto_matic_color = true ;
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_OK ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : get_device_code ( void )
{
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_DEVICE_NOT_SUPPORT ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : get_sleep_time ( int & getsleepime )
{
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_DEVICE_NOT_SUPPORT ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : set_sleep_time ( int sleeptime )
{
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_DEVICE_NOT_SUPPORT ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : get_dogear_distance ( void )
{
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_DEVICE_NOT_SUPPORT ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : set_dogear_distance ( void )
{
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_DEVICE_NOT_SUPPORT ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : get_scanner_paperon ( SANE_Bool * paperon )
{
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_DEVICE_NOT_SUPPORT ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : set_scan_when_paper_on ( void )
{
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_DEVICE_NOT_SUPPORT ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : get_scan_when_paper_on ( void )
{
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_DEVICE_NOT_SUPPORT ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : get_scan_with_hole ( void )
{
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_DEVICE_NOT_SUPPORT ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : set_scan_with_hole ( void )
{
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_DEVICE_NOT_SUPPORT ;
2022-05-03 03:56:07 +00:00
}
int hg_scanner : : get_scan_is_sleep ( void )
{
2022-05-17 07:04:55 +00:00
return SCANNER_ERR_DEVICE_NOT_SUPPORT ;
2022-05-03 03:56:07 +00:00
}