code_device/hgdriver/hgdev/hg_scanner.h

#pragma once

// hg_scanner is the base class of kinds of scanners
//
// created on 2022-01-30
//
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <mutex>
#include <thread>
//#include <vld.h>
#include "usb_manager.h"
#include "../../sdk/hginclude/huagaoxxx_warraper_ex.h"
#include "jsonconfig.h"
#include "../3rdparty/nick/StopWatch.h"
#include "hg_ipc.h"
#include "common_setting.h"
#include "image_process.h"
#include "StopWatch.h"
#include "PaperSize.h"
#include "version/HGVersion.h"
#if defined(WIN32) || defined(_WIN64)
#include <cryptoPP/md5.h> //暂时linux 屏蔽
#include <cryptoPP/files.h>
#include <cryptoPP/aes.h>
#include <cryptoPP/modes.h>
#include <cryptopp/hex.h>
#else
#include <unistd.h>
#include <dlfcn.h>
#endif
#include "../../../sdk/include/huagao/brand.h"


#ifndef WIN32 
#define __stdcall
#endif

#define MAPPING_FUNCTION_IN_BASE                            // 定义该标志，各子类不必再初始化setting_map_数组
    
#define SAFE_DELETE(p){ \
if (NULL != (p)) {delete((p)); \
		(p) = nullptr; \
}\
}
//#ifdef OEM_HANWANG
//#define hg_scanner      hw_scanner
//#elif defined(OEM_LISICHENG)
//#define hg_scanner      lsc_scanner
//#elif defined(OEM_CANGTIAN)
//#define hg_scanner      cts_scanner
//#endif


#define USB_REQ_GET_FPGA_REGS        0x40
#define USB_REQ_SET_FPGA_REGS		 0x41
#define USB_REQ_GET_MOTOR_REGS       0x42
#define USB_REQ_SET_MOTOR_REGS       0x43

#define USB_REQ_GET_DEV_STATUS        0x60
#define USB_REQ_GET_DEV_CONFIGURATION 0x61
#define USB_REQ_SET_DEV_CONFIGURATION 0x62
#define USB_REQ_GET_DEV_REGS          0x63
#define USB_REQ_SET_DEV_REGS          0x64

typedef HGResult(__stdcall* SDKHGVersion_Init_)(HGVersionMgr* mgr);
typedef HGResult(__stdcall* SDKHGVersion_Islock_)(HGVersionMgr mgr, const HGChar* devSN, HGBool* inList);
typedef HGResult(__stdcall* SDKHGVersion_Postlog_)(HGVersionMgr mgr, const HGChar* devName, const HGChar* devSN,
    const HGChar* devType, const HGChar* devFW, HGBool isLock);
typedef HGResult(__stdcall* SDKHGVersion_Free_)(HGVersionMgr mgr);

class hg_scanner
{
    HGVersionMgr            HGVersion_mgr_;
    SDKHGVersion_Init_		HGVersion_Init_;
    SDKHGVersion_Islock_	HGVersion_Islock_;
    SDKHGVersion_Postlog_	HGVersion_Postlog_;
    SDKHGVersion_Free_		HGVersion_Free_;
#ifndef WIN32
    void* Dynamicopen_HGVersion_pHandle_;;
#else
    HINSTANCE Dynamicopen_HGVersion_pHandle_;
#endif

    bool                notify_setting_result_;
	std::string	        name_;
    std::string         family_;
    std::string         save_multiout; //保存多留输出类型
    bool                save_sizecheck;
    bool                read_over_with_no_data_;    // 针对第三方调用，在最后一段数据时是否返回“SCANNER_ERR_NO_DATA”
    int                 is_color_type_;//保存最后下发到设备的颜色类型
    bool                have_max_size; //条目是否存在最大尺寸


    sane_callback       ui_ev_cb_;
    do_when_born_and_dead<hg_scanner>* scan_life_;

    std::unique_ptr<std::thread> thread_usb_read_;
    void thread_handle_usb(void);

    std::unique_ptr<std::thread> thread_img_handle_;
    void thread_image_handle(void);

    std::unique_ptr<std::thread> thread_devslock_handle_;
    void thread_devslock_handle(void);

    std::unique_ptr<std::thread> thread_read_int_;
    void thread_read_int(void);

    void(hg_scanner::* dump_img_)(hg_imgproc::HIMGPRC himg, const char* desc);
    void dump_image_empty(hg_imgproc::HIMGPRC himg, const char* desc);
    void dump_image_real(hg_imgproc::HIMGPRC himg, const char* desc);

    void init_setting_func_map(void);
    std::string setting_name_from(const char* n_or_id, int* id = nullptr);
    void get_range(const char* name, std::vector<std::string>& range, std::string& def_val, bool& is_range/*range or list*/);
    bool check_range(const char* name, bool& val);
    bool check_range(const char* name, int& val);
    bool check_range(const char* name, double& val);
    bool check_range(const char* name, std::string& val);
    bool check_paper_and_resolution(int res, int paper);
    bool check_resolution_and_quality(int res, const char* quality);
    int  restore(const char* name);
    bool get_default_value(void* buf, json* jsn);
    bool is_to_file(void);
    void thread_handle_image_process(void);

    void working_begin(void*);
    void working_done(void*);

    void image_process(std::shared_ptr<tiny_buffer>& buffer, uint32_t id);
    void reset_custom_area_range(int paper);
    float reset_custom_area_jsn_value(const char* name, double& var, float range_l, float range_u, float value_l, float value_u);    // return cur value
    int  set_color_change(void);
    bool jsn_reorganize(); //  固件版本不同 初始化json要做出相对应的删除
public:


    // 设置接口
protected:

    // 配置序号映射数组，各子类必须重载“init_setting_map”方法以初始化该数组 --> 2022-05-09：基类中以title自动匹配功能序号，子类不必再处理并屏蔽此项工作
    // 比如：  某型设备的“颜色模式”功能号为1，则 setting_map_[HG_BASE_SETTING_INDEX_COLOR_MODE] = 1
    //         如果设备的“颜色模式”配置逻辑与基类预定义的不同，
    //          则 setting_map_[HG_BASE_SETTING_INDEX_COLOR_MODE] = -1，在子类重载的set_setting_value方法中处理
    // 
    // 2022-06-28: 属性处理函数改用map结构存储，只须处理set_setting_map函数即可
    //  int             setting_map_[HG_BASE_SETTING_INDEX_MAX];
    //virtual void init_setting_map(int* setting_map, int count);
    std::map<std::string, int (hg_scanner::*)(void*, long*)>    setting_map_;
    int invoke_setting_xxx(int(hg_scanner::* func)(void*, long*), void* data, long* len);

    int setting_restore(void* data, long* len);
    int setting_help(void* data, long* len);
    int setting_color_mode(void* data, long* len);
    int setting_multi_out(void* data, long* len);
    int setting_multi_out_type(void* data, long* len);
    int setting_rid_color(void* data, long* len);
    int setting_rid_multi_red(void* data, long* len);
    int setting_rid_answer_red(void* data, long* len);
    int setting_erase_background(void* data, long* len);
    int setting_erase_background_range(void* data, long* len);
    int setting_noise_optimize(void* data, long* len);
    int setting_noise_optimize_range(void* data, long* len);
    int setting_paper(void* data, long* len);
    int setting_paper_check(void* data, long* len);
    int setting_page(void* data, long* len);
    int setting_page_omit_empty(void* data, long* len);
    int setting_resolution(void* data, long* len);
    int setting_exchagnge(void* data, long* len);
    int setting_split_image(void* data, long* len);
    int setting_automatic_skew(void* data, long* len);
    int setting_rid_hole(void* data, long* len);
    int setting_rid_hoe_range(void* data, long* len);
    int setting_bright(void* data, long* len);
    int setting_contrast(void* data, long* len);
    int setting_gamma(void* data, long* len);
    int setting_sharpen(void* data, long* len);
    int setting_dark_sample(void* data, long* len);
    int setting_erase_black_frame(void* data, long* len);
    int setting_threshold(void* data, long* len);
    int setting_anti_noise(void* data, long* len);
    int setting_margin(void* data, long* len);
    int setting_filling_background(void* data, long* len);
    int setting_is_permeate(void* data, long* len);
    int setting_is_permeate_lv(void* data, long* len);
    int setting_remove_morr(void* data, long* len);
    int setting_error_extention(void* data, long* len);
    int setting_remove_texture(void* data, long* len);
    int setting_ultrasonic_check(void* data, long* len);
    int setting_go_on_when_double_checked(void* data, long* len);
    int setting_staple_check(void* data, long* len);
    int setting_scan_mode(void* data, long* len);
    int setting_scan_count(void* data, long* len);
    int setting_text_direction(void* data, long* len);
    int setting_rotate_bkg_180(void* data, long* len);
    int setting_fractate_check(void* data, long* len);
    int setting_fractate_check_level(void* data, long* len);
    int setting_skew_check(void* data, long* len);
    int setting_skew_check_level(void* data, long* len);
    int setting_is_custom_gamma(void* data, long* len);
    int setting_custom_gamma_data(void* data, long* len);
    int setting_is_custom_area(void* data, long* len);
    int setting_custom_area_left(void* data, long* len);
    int setting_custom_area_top(void* data, long* len);
    int setting_custom_area_right(void* data, long* len);
    int setting_custom_area_bottom(void* data, long* len);
    int setting_img_quality(void* data, long* len);
    int setting_color_fill(void* data, long* len);
    int setting_keep_watermark(void* data, long* len);
    int setting_black_white_threshold(void* data, long* len);
    int setting_white_pixel_0(void* data, long* len);
    int setting_feedmode(void* data, long* len);
    int setting_sleeptime(void* data, long* len);
    int setting_auto_pick_paper(void* data, long* len);
    int setting_auto_pick_paper_threshold(void* data, long* len);
    int setting_auto_paper_scan(void* data, long* len);
    int setting_isremove_left_hole(void* data, long* len);
    int setting_isremove_right_hole(void* data, long* len);
    int setting_isremove_top_hole(void* data, long* len);
    int setting_isremove_low_hole(void* data, long* len);
    int setting_isremove_left_hole_threshold(void* data, long* len);
    int setting_isremove_right_hole_threshold(void* data, long* len);
    int setting_isremove_top_hole_threshold(void* data, long* len);
    int setting_isremove_low_hole_threshold(void* data, long* len);
    int setting_fold_type(void* data, long* len);
    int setting_color_correction(void* data, long* len);
    int setting_auto_paper_scan_exit_time(void* data, long* len);
    int setting_get_dev_vid(void* data, long* len);
    int setting_get_dev_pid(void* data, long* len);
    int setting_get_dev_family(void* data, long* len);
    int setting_get_dev_name(void* data, long* len);
    int setting_get_dev_sn(void* data, long* len);
    int setting_get_dev_fmver(void* data, long* len);
    int setting_get_dev_ip(void* data, long* len);
    int setting_get_roller_count(void* data, long* len);
    int setting_get_history_count(void* data, long* len);
    int setting_get_devs_log(void* data, long* len);
    int setting_set_language(void* data, long* len);
    int setting_get_motor_ver(void* data, long* len);
    int setting_get_initial_boot_time(void* data, long* len);
    int setting_set_discardblank(void* data, long* len);
    int setting_detect_lens_dirty(void* data, long* len);
    int setting_set_period(void* data, long* len);

    virtual void on_device_reconnected(void);
    virtual int on_scanner_closing(bool force);

    virtual int on_color_mode_changed(int& color_mode) = 0; // COLOR_MODE_xxx
    virtual int on_paper_changed(int& paper) = 0;           // PAPER_xxx
    virtual int on_paper_check_changed(bool& check)=0;
    virtual int on_resolution_changed(int& dpi)=0;
    virtual int on_ultrasonic_check_changed(bool& check)=0;
    virtual int on_staple_check_changed(bool& check) = 0;
    virtual int on_skew_check_changed(bool& check) = 0;
    virtual int on_skew_check_level_changed(int& check) = 0;
    virtual int on_get_feedmode(int& feedmode) = 0;             //获取分纸强度
    virtual int on_set_feedmode(int feedmode) = 0;              //设置分纸强度
    virtual int on_pic_type(bool& pic) = 0;                     //照片模式或者文本模式
    virtual int on_pick_paper(bool autostrength) = 0;           //设置搓纸使能
    virtual int on_pick_paper_threshold(double threshold) = 0;  //设置搓纸阈值
    virtual int on_is_auto_paper(bool isautopaper) = 0;         //待纸扫描
    virtual int on_cis_get_image(bool type) = 0;
    virtual int on_process_double_paper(bool type) = 0;         //双张图像校验
    virtual int on_detect_lens_dirty(bool type);                //检测镜头脏污
    virtual int on_set_period(int val);                         //PWM占空比
protected:

	virtual int set_setting_value(const char* name, void* data, long* len);
	
    virtual void thread_handle_usb_read(void) = 0;
    virtual void thread_handle_islock_read();
    int hg_version_init_handle();
    int set_server_blacklist_lock(); // 0:不锁定 1:锁定  
    void hg_version_free_handle();
    // adjust color or apply custom gamma 
    void adjust_color(hg_imgproc::HIMGPRC handle);
    hg_imgproc::IMGPRCPARAM get_image_process_object(int model);
    SANE_Image_Statu last_usb_image_statu(int err);
    hg_imgproc::HIMGPRC		ImagePrc_pHandle_;
protected:
    ScannerSerial   serial_;
    volatile bool   is_checksum_strat_scan;  //设备锁定时，通过校验码来进行扫描
    volatile bool   run_;
    volatile bool   is_read_int;
    volatile bool   user_cancel_;
    platform_event  wait_usb_;
    platform_event  wait_img_;
    platform_event  wait_usb_result_;
    platform_event  wait_devsislock_;
    platform_event  wait_read_int;
    usb_io*         io_;
    std::mutex      io_lock_;
    std::string     firmware_ver_;
    bool            online_;
    int			    status_;
    bool            async_io_;
    bool            cb_mem_;
    bool            test_1_paper_;      // 是否为单张扫描模式
    std::vector<std::string>    jsn_children_;
    std::vector<string> erase_depend_;  //需要删除父依赖项
    json	        setting_jsn_;

    IMGPRCFIXPARAM  image_prc_param_;
    int             erase_bkg_range_;   // 背景移除像素范围
    int             noise_range_;       // 噪点优化尺寸
    TwSS            paper_size_;
    int             omit_empty_level_;  // 跳过空白页灵敏度
    int             resolution_;        // 分辨率
    double          rid_hole_range_;    // 穿孔移除范围
    int             bright_;            // 亮度
    int             contrast_;          // 对比度
    double          gamma_;             // 伽玛
    int             threshold_;         // 阈值
    int             anti_noise_;        // 背景搞噪等级
    int             margin_;            // 边缘缩进
    int             fractate_level_;    // 折角检测复杂度
    int             scan_count_;        // 扫描张数，各实例化类在重载set_setting_value中，如果发现该设置项对该参数有影响时，需要对此值作更改
    bool            is_auto_matic_color;// 自动颜色识别
    int             is_quality_;                    // 画质设置 0 - 速度优先；1 - 画质优先
    bool            is_color_fill;                  // 色彩填充
    bool            is_multiout;                    // 多流输出
   
    int             bw_threshold_;                  // 黑白图像阈值 （added on 2022-06-28）
    int             feedmode_;                      // 分纸强度
    int             sleeptime_;                     // 睡眠时间
    bool            is_auto_paper_scan;             // 待纸扫描
    bool            auto_scan_prev_;                // 保留待纸扫描程序改变状态之前的值 - 2023-10-16: 智学网根据扫描张数来打开或关闭待纸扫描
    bool            auto_scan_restore_;             // 是否需要恢复待纸扫描状态         - 2023-10-16: 智学网根据扫描张数来打开或关闭待纸扫描
    bool            size_check;                     // 尺寸检测

    bool            save_feedmode_type_;            //保存分支强度狀態
    bool            save_sleeptime_type_;           //保存休眠時間

    bool            isremove_left_hole;             //设置左边除穿孔
    bool            isremove_right_hole;            //设置右边除穿孔
    bool            isremove_top_hole;              //设置上边除穿孔
    bool            isremove_low_hole;              //设置下边除穿孔
    double          isremove_left_hole_threshold;   //设置左边除穿孔阈值
    double          isremove_right_hole_threshold;  //设置右边除穿孔阈值
    double          isremove_top_hole_threshold;    //设置上边除穿孔阈值
    double          isremove_low_hole_threshold;    //设置下边除穿孔阈值
    int             fold_type_;                     //对折类型
    bool            is_cis_image;                   //设置cis获取原图
    bool            is_dpi_color_check;             //纵向DPI、色差检测  ,畸变自动计算
    float           save_dpi_color_check_val;       //保存纵向DPI、色差检测  ,畸变自动计算 的值
    bool            is_auto_falt;                   //是否进行平场校正
    bool            color_correction_;              //是否色彩校正
    int             is_auto_paper_scan_exit_time;   //待纸扫描退出时间
    bool            is_auto_feedmode_;              //是否启用自动分纸强度
    bool            is_discardblank;                //是否启动跳过空白页
    bool            is_lens_dirty;                  //是否检测镜头脏污

    SANE_DISTORTION_VAL distortion_val;             //畸变修正结构体保存



    int             split3399_; //3399设备正面和反面图像是相对的，所以对折时反面需要进行特殊处理
    int             pid_;     

    /////////不同的固件号版本支持
    //bool            is_kernelsnap_239_220830_;      //此版本支持，手动睡眠唤醒，分纸强度
    //bool		    is_kernelsnap_239_211209_;      //获取固件版本号是否是新旧版本
    //bool		    is_kernelsnap_239_221027_;      //此版本一下不支持拆分模式 pc实现

    //bool            is_kernelsnap3288_221106_;      //G300 3288 在221106版本支持真实300dpi 
    //bool            is_kernelsnap3288_230210_;      //G300 3288 在230210版本支持真实600dpi 

    //bool            is_kernelsnap3288_230303_;      //G300 3288 支持清除历史扫描张数
   
    //bool            is_kernelsnap_devsislock;       //支持设备锁的版本
    //bool            is_kernelsnap_239_3C_;          //支持偏色校正的版本，自适应配置
    //bool            is_kernelsnap_439_3C0606;       //支持偏色校正的版本
    //bool            is_kernelsnap_239_220500_;      //支持双张保留的版本

    //bool            is_kernelsnap_239_220429_;      //第一个安陆版本，支持设备日志导出
    //bool            is_kernelsnap_239_220430_;      //待纸扫描
   // bool            is_kernelsnap_211227_;          //此版本以下，不支持真实dpi ，只设置1下去


    bool            firmware_sup_wait_paper_;       //固件支持 待纸扫描         139 239-3B0431, 439-3B0629
    bool            firmware_sup_pick_strength_;    //固件支持 分纸强度         139 239-3B0830
    bool            firmware_sup_log_export_;       //固件支持 日志导出         139 239-3B0429
    bool            firmware_sup_color_corr_;       //固件支持 偏色校正         139 239 439-3C
    bool            firmware_sup_wake_device_;      //固件支持 唤醒设备         139 239-3B0830
    bool            firmware_sup_double_img;        //固件支持 双张保留         139 239-3C
    bool            firmware_sup_devs_lock_;        //固件支持 设备锁定         139 239-3b0500, 439-3C, 302_402-2023/3/15
    bool            firmware_sup_dpi_300;           //固件支持 真实DPI300       139 239-21227，此版本以下，不支持真实dpi，dpi设置1  //3288 G300 用到
    bool            firmware_sup_dpi_600;           //固件支持 真实DPI600       139 239-21227，此版本以下，不支持真实dpi，dpi设置1
    bool            firmware_sup_auto_speed_;       //固件支持 自适应速度       139 239 439 -3C
    bool            firmware_sup_morr_;             //固件支持 摩尔纹           139 239-3C0518
    bool            firmware_sup_color_fill_;       //固件支持 色彩填充         139 239 439 -3C
    bool            firmware_sup_history_cnt;       //固件支持 清除历史张数     3288 G300 220303
    bool            firmware_sup_double_check;      //固件支持 双张校验         231021
    bool            firmware_sup_dirty_check;       //固件支持 脏污检测         231021
    bool            firmware_sup_backup_restore;    //固件支持 备份还原         231021
    bool            firmware_sup_boardTime;         //固件支持 板级时间校验     231021
    bool            firmware_sup_device_7010;       //G300 设备但是7010 2023/9/21
    int mat_width;
    int mat_height;

    SCANCONF 	img_conf_;  //此参数外部不做任何改变，请在writedown_image_configuration做修改
    std::string img_type_;

    std::string     dump_usb_path_;      // 诊断模式，输出USB原始图像
    final_img_queue final_imgs_;	     // JPG ...
    unsigned int    usb_img_index_;
    unsigned int    final_img_index_;
    std::string     final_path_;
    unsigned long   memory_size_;       // MB
    unsigned long   wait_mem_seconds_;  // wait up to wait_mem_seconds_ if memory usage is great than memory_size_
    bool            isx86_Advan_;
    int             stop_fatal_;
    BlockingQueue<std::shared_ptr<tiny_buffer>> imgs_;

    std::map<int, setting3288dsp::FLAT_INFO_IMAGE>correction_image_map_;

    uint32_t        fetching_id_;   // for sane read image ext info. added on 2023-01-13

    void change_setting_language(bool init);
    void erase_option(const char* name);
    void init_settings(const char* json_setting_text);
    int init_settings(int pid);
    void change_string_2_lang_id(const char* name, const char* key);
    std::string get_setting_item_string(const char* name, const char* key);
    int on_scann_error(int err);        // 返回“0”忽略错误继续执行，其它值则停止后续工作
    int try_third_app_handle_start(bool& handled);
    int try_third_app_after_start(int err);
    std::shared_ptr<tiny_buffer> aquire_memory(int size, bool from_usb = true);

    // callback to ui ...
    int notify_ui_working_status(const char* msg, int ev = SANE_EVENT_STATUS, int status = SCANNER_ERR_OK);
    bool waiting_for_memory_enough(unsigned need_bytes);

    void copy_to_sane_image_header(SANE_Parameters* header, int w, int h, int line_bytes, int channels, int bits);
    int save_usb_data(std::shared_ptr<tiny_buffer> data);
    int save_final_image(hg_imgproc::LPIMGHEAD head, void* buf, uint32_t id = -1);

    void adjust_filling_hole(LPSCANCONF conf);
    int wait_one_image_from_start(bool& handled);

    ////////////////////////////////////////////////////////////////
    // 新增自定义伽玛曲线及扫描区域属性 - 2022-05-05
    bool    custom_gamma_;                  // 为true时，应用custom_gamma_val_阵列调整图像色彩；为false时，保持原来的处理方式
    SANE_Gamma *custom_gamma_val_;          // 当为RGB或者彩色时，为三组256字节的数据；当为黑白或灰度时，只有一组256字节
    bool    custom_area_;                   // 是否启用自定义区域，为true时才使用下列4个数据；为false时保持原来的处理方式
    double  custom_area_lt_x_;              // 自定义区域左上角x坐标
    double  custom_area_lt_y_;              // 自定义区域左上角y坐标
    double  custom_area_br_x_;              // 自定义区域右下角x坐标
    double  custom_area_br_y_;              // 自定义区域右下角y坐标
    SIZE    paper_size_mm_;                 // 当前纸张尺寸（mm）
    // 新增自定义伽玛曲线及扫描区域属性 - END
    ////////////////////////////////////////////////////////////////

    // 2022-07-23 新增双张之后留图继续扫描
    int     double_paper_handle_;           // 汉王要求出现双张的时候可保留
    bool    keep_watermark_;                // 汉王要求图像处理过程中保留水印 - 是否与背景移除、背景填充相关？？？

    // 2022-08-31 新增黑白图像是否反色输出（PNM黑白像素与BMP黑白像素相反）
    bool    is_white_0_;                    // 是否‘0’代表白色

public:
    int start(void);
    int stop(void);

    void set_ui_callback(sane_callback cb, bool enable_async_io);
    void set_dev_family(const char* family);
    void set_read_over_with_no_data(bool no_data);
    int reset_io(usb_io* io);
    int io_disconnected(void);
    int get_pid(void);
    int get_vid(void);
    int close(bool force);
	int set_setting(const char* name, void* data, long* len);
	int get_setting(const char* name, char* json_txt_buf, int* len, int* id);
    int hgpaper_to_devspaper(Paper_Map papermap[], int len, int& paper, bool* exact, TwSS* type);
    int image_configuration(SCANCONF &ic);
	std::string name(void);
	int status(void);
    bool is_online(void);
    void on_language_changed(void);

    enum thread_running
    {
        THREAD_RUNNING_IDLE = 0,
        THREAD_RUNNING_USB = 1 << 0,
        THREAD_RUNNING_IMAGE = 1 << 1,
    };
    int is_running(void);   // return thread_running

public:
    virtual int do_start(void) = 0;
    virtual int do_stop(void) = 0;
    virtual int get_image_info(SANE_Parameters* ii, int len);
    virtual int read_image_data(unsigned char* buf, int* len);
    virtual int reset(void);
    virtual int device_io_control(unsigned long code, void* data, unsigned* len);
    virtual int discard_all_images(void) = 0;
    virtual int get_roller_life(void);  // 获取滚轴最大寿命

public:
	hg_scanner(ScannerSerial serial, const char* dev_name, usb_io* io,int pid);
	virtual ~hg_scanner();

    static std::string temporary_file(char* tail = NULL, char* head = NULL);
    static int save_2_tempory_file(std::shared_ptr<std::vector<char>> data, std::string* path_file, unsigned int index = 0);
public:

    //////////////固定的硬件信息设置或获取//////////////
    virtual std::string get_firmware_version(void);
    virtual std::string get_serial_num(void);
    virtual std::string get_ip(void);
    virtual std::string get_device_model(void);

    virtual int set_device_model(string str);
    virtual int set_serial_num(string str) = 0;             //设置序列号
    virtual int set_vid_pid(int data) = 0;                  //设置vidpid
    virtual int get_vid_pid(int& data) = 0;                 //获取vidpid

    /////////////成功返回:SCANNER_ERR_OK /////////////
    /////////////失败返回:IO错误码       /////////////
    virtual int set_leaflet_scan(void) = 0;                 //单张扫描
    virtual int get_abuot_info(void);                   //获取软件关于信息 (基类实现) 
    virtual int restore_default_setting(void);              //恢复默认设置 (基类实现) 
    virtual int set_final_image_format(SANE_FinalImgFormat* fmt);//设置图像处理最终输出（final()）的图像数据格式  (基类实现) ***
    

    virtual int get_compression_format(void);               //获取支持的压缩格式                 不支持
    virtual int set_compression_format(void);               //设置图像数据最终输出的压缩格式     不支持

    virtual int set_auto_color_type(void);                  //设置自动匹配颜色模式  (基类实现) 
    virtual int set_clear_roller_num(void) = 0;             //清除滚轴计数
    virtual int set_clear_history_num(void) = 0;            //清除历史张数

    virtual int get_device_code(void);                      //获取设备编码                       不支持

    virtual int get_scanner_paperon(SANE_Bool& type)=0;     //获取设备有无纸张      /*/ type : false无纸（不正常状态false）  true有纸 */

    virtual int get_scan_is_sleep(SANE_Bool& type) = 0;     //获取设备是否休眠当中  /*/ type : false休眠（不正常状态false）  true未休眠*/
    virtual int get_sleep_time(int& data) = 0;              //获取功耗模式（休眠）  /*/ data > 0*/
    virtual int set_sleep_time(int data) = 0;               //设置功耗模式（休眠）  /*/ data > 0*/
    virtual int get_history_scan_count(int &data) = 0;      //获取历史扫描张数      /*/ data > 0*/
    virtual int get_roller_num(int &data) = 0;              //获取滚轮张数          /*/ data > 0*/
    virtual int set_notify_sleep(void) = 0;                 //唤醒设备
    virtual int get_device_log(string &log) = 0;            //获取设备日志          /*/ log :储存路径*/
    virtual int set_devreboot(int data) = 0;                //设置设备重启          /*/ data:0 reboot data:1  1进入loader,0普通重启
    virtual int set_devshtudown() = 0;                      //设置设备关机
    virtual int set_scan_islock(SANE_Bool type) = 0;        //设置设备是否锁定      /*/ type:0解锁，1锁定*/
    virtual int get_scan_islock(SANE_Bool& type) = 0;       //获取设备是否锁定      /*/ type:0解锁，1锁定*/
    virtual int set_scan_lock_check_val(string str) = 0;    //获取设备是否锁定      /*/ str:校验码*/
    virtual int set_firmware_upgrade(std::string str) = 0;  //固件升级              /*/ str:文件名路径*/
    virtual int set_clean_paper_road() = 0;                 //清理纸道 
    virtual int get_dev_islock_file(int &data) = 0;         //获取设备文件          /*/ data:0 未上锁，1 上锁。-1 未发现黑名单列表 -2列表没有信息*/
    virtual int set_dev_islock_file(int data) = 0;          //设置设备文件          /*/ data:0 未上锁，1 上锁*/
    virtual int get_scan_mode(bool& type) ;                 //获取设备是否计数模式  /*/ type:false计数模式 true非计数模式
    virtual int set_speed_mode(int data) = 0;               //设置速度模式          /*/ 设备不同值不同，详情见子类注释
    virtual int get_speed_mode(int &data) = 0;              //获取速度模式          /*/ 设备不同值不同，详情见子类注释   

    virtual int set_distortion_image(bool type);            //设置畸变校正图	    /*/ 基类处理
    virtual int get_distortion_check_val(int &val);         //获取自动计算畸变校正值        /*/ 基类处理

    virtual int set_devs_distortion_check_val(float data) = 0;  //设置畸变矫正值	 float;
    virtual int get_devs_distortion_check_val(float& data) = 0; //获取设备畸变值	 float;  

    virtual int set_auto_flat(int data) = 0;                    //设置自动平场校正   
                                                                // data:0(ALL) 1(200dpi、gray) 2(200dpi、color) 3(300dpi、gray) 4(300dpi、color) 5(600dpi、gray) 6(600dpi、color)
    virtual int set_updata0303(void) ;
    virtual int get_motor_board_ver(string &ver);               //获取G239电机板的固件号 //3399设备支持

    virtual int set_devs_time(string times);                    //设置设备时间    //3399设备支持
    virtual int get_devs_time(string &times);                   //获取设备时间    //3399设备支持

    virtual int get_devs_cpu(string& cpu);									//获取设备内存大小
    virtual int get_devs_disk(string& disk);								//获取设备硬盘容量大小
    virtual int set_restore();					                //还原文件
    virtual int set_backup();					                //备份文件
};


    //TEST 测试GIT切换