newtx/hardware/hardware.cpp

#include "hardware.h"

#include "./cis/FpgaComm.h"
#include "./cis/gvideoisp1.h"
#include "./motor/motorboard.h"
#include <huagao/hgscanner_error.h>
#include <sane/sane_ex.h>
#include <json/gb_json.h>
#include <base/paper.h>

/////////////////////////////////////////////////////////////////////////////////////////////////////////
// scanner_hw
static std::string device_opt_json[] = {
	"{\"mode\":{\"cat\":\"none\",\"group\":\"CIS\",\"title\":\"\\u989c\\u8272\\u6a21\\u5f0f\",\"desc\":\"\\u9009\\u62e9\\u955c\\u5934\\u8272\\u5f69\\u5de5\\u4f5c\\u6a21\\u5f0f\",\"type\":\"string\",\"fix-id\":34819,\"ui-pos\":10,\"auth\":0,\"size\":12,\"cur\":\"\\u5f69\\u8272\",\"default\":\"\\u5f69\\u8272\",\"range\":[\"\\u5f69\\u8272\",\"\\u7070\\u5ea6\"]},\"resolution\":{\"cat\":\"none\",\"group\":\"CIS\",\"title\":\"\\u5206\\u8fa8\\u7387\",\"desc\":\"\\u8bbe\\u7f6e\\u955c\\u5934\\u5de5\\u4f5c\\u7684\\u5206\\u8fa8\\u7387\",\"type\":\"int\",\"fix-id\":34840,\"ui-pos\":11,\"auth\":0,\"size\":4,\"cur\":200,\"default\":200,\"range\":[200,300,600]},\"paper\":{\"cat\":\"base\",\"group\":\"base\",\"title\":\"\\u7eb8\\u5f20\\u5c3a\\u5bf8\",\"desc\":\"\\u8bbe\\u7f6e\\u51fa\\u56fe\\u5927\\u5c0f\",\"type\":\"string\",\"fix-id\":34831,\"ui-pos\":10,\"auth\":0,\"size\":44,\"cur\":\"\\u5339\\u914d\\u539f\\u59cb\\u5c3a\\u5bf8\",\"default\":\"\\u5339\\u914d\\u539f\\u59cb\\u5c3a\\u5bf8\",\"range\":[\"A3\",\"8\\u5f00\",\"A4\",\"16\\u5f00\",\"A5\",\"A6\",\"B4\",\"B5\",\"B6\",\"Letter\",\"Double Letter\",\"LEGAL\",\"\\u5339\\u914d\\u539f\\u59cb\\u5c3a\\u5bf8\",{\"resolution<500\":\"\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\\u81ea\\u52a8\\u88c1\\u5207\"},{\"resolution<500\":\"\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\"},{\"resolution<500\":\"\\u4e09\\u8054\\u8bd5\\u5377\"}]},\"lateral\":{\"cat\":\"base\",\"group\":\"base\",\"title\":\"\\u6a2a\\u5411\",\"desc\":\"\\u6a2a\\u5411\\u653e\\u7f6e\\u7eb8\\u5f20\",\"type\":\"bool\",\"fix-id\":34924,\"ui-pos\":12,\"auth\":0,\"affect\":6,\"visible\":0,\"size\":4,\"cur\":false,\"default\":false,\"depend\":\"paper==A4 || paper==16\\u5f00 || paper==A5 || paper==A6 || paper==B5 || paper==B6 || paper==Letter\"},\"paper-w\":{\"cat\":\"base\",\"group\":\"base\",\"title\":\"\\u7eb8\\u5f20\\u5bbd\\u5ea6\",\"desc\":\"\\u4ee5\\u6beb\\u7c73\\u4e3a\\u5355\\u4f4d\\u7684\\u7eb8\\u5f20\\u5bbd\",\"type\":\"float\",\"fix-id\":34922,\"ui-pos\":13,\"auth\":0,\"unit\":\"mm\",\"readonly\":true,\"visible\":0,\"size\":8,\"auto\":false,\"ownread\":true,\"cur\":210.000000,\"default\":210.000000},\"paper-h\":{\"cat\":\"base\",\"group\":\"base\",\"title\":\"\\u7eb8\\u5f20\\u9ad8\\u5ea6\",\"desc\":\"\\u4ee5\\u6beb\\u7c73\\u4e3a\\u5355\\u4f4d\\u7684\\u7eb8\\u5f20\\u9ad8\",\"type\":\"float\",\"fix-id\":34923,\"ui-pos\":14,\"auth\":0,\"unit\":\"mm\",\"readonly\":true,\"visible\":0,\"size\":8,\"auto\":false,\"ownread\":true,\"cur\":297.000000,\"default\":297.000000},\"is-wait-scan\":{\"cat\":\"base\",\"group\":\"feeder\",\"title\":\"\\u5f85\\u7eb8\\u626b\\u63cf\",\"desc\":\"\\u542f\\u7528\\u540e\\uff0c\\u6587\\u7a3f\\u653e\\u5165\\u626b\\u63cf\\u4eea\\u65f6\\u5c06\\u81ea\\u52a8\\u542f\\u52a8\\u626b\\u63cf\",\"type\":\"bool\",\"fix-id\":34873,\"ui-pos\":12,\"auth\":0,\"size\":4,\"cur\":false,\"default\":false},\"wait-scan-exit\":{\"cat\":\"base\",\"group\":\"feeder\",\"title\":\"\\u5f85\\u7eb8\\u626b\\u63cf\\u9000\\u51fa\\u65f6\\u95f4\",\"desc\":\"\\u8bbe\\u7f6e\\u7ed3\\u675f\\u5f85\\u7eb8\\u626b\\u63cf\\u7684\\u65f6\\u95f4\",\"type\":\"string\",\"fix-id\":34920,\"ui-pos\":13,\"auth\":0,\"size\":16,\"cur\":\"60s\",\"default\":\"60s\",\"range\":[\"15s\",\"30s\",\"60s\",\"2min\",\"4min\",\"8min\"],\"depend\":\"is-wait-scan==true\"},\"scan-mode\":{\"cat\":\"base\",\"group\":\"feeder\",\"title\":\"\\u626b\\u63cf\\u5f20\\u6570\",\"desc\":\"\\u9009\\u62e9\\u6307\\u5b9a\\u6570\\u91cf\\u626b\\u63cf\\u6216\\u8fde\\u7eed\\u626b\\u63cf\",\"type\":\"string\",\"fix-id\":34862,\"ui-pos\":15,\"auth\":0,\"size\":24,\"cur\":\"\\u8fde\\u7eed\\u626b\\u63cf\",\"default\":\"\\u8fde\\u7eed\\u626b\\u63cf\",\"range\":[\"\\u8fde\\u7eed\\u626b\\u63cf\",\"\\u626b\\u63cf\\u6307\\u5b9a\\u5f20\\u6570\"],\"depend\":\"is-wait-scan==false\"},\"scan-count\":{\"cat\":\"base\",\"group\":\"feeder\",\"title\":\" \\u626b\\u63cf\\u6570\\u91cf\",\"desc\":\"\\u626b\\u63cf\\u6307\\u5b9a\\u6570\\u91cf\",\"type\":\"int\",\"fix-id\":34863,\"ui-pos\":16,\"auth\":0,\"size\":4,\"cur\":-1,\"default\":-1,\"depend\":\"scan-mode.enabled&&scan-mode==\\u626b\\u63cf\\u6307\\u5b9a\\u5f20
	"x\":100,\"step\":1}},\"paper-on\":{\"cat\":\"none\",\"group\":\"feeder\",\"title\":\"\\u7eb8\\u5f20\\u5c31\\u7eea\",\"desc\":\"\\u7eb8\\u5f20\\u5df2\\u7ecf\\u5728\\u8fdb\\u7eb8\\u53f0\\u4e0a\\u653e\\u7f6e\\u597d\",\"type\":\"bool\",\"fix-id\":34912,\"ui-pos\":10,\"auth\":0,\"readonly\":true,\"size\":4,\"auto\":false,\"ownread\":true,\"cur\":false,\"default\":false},\"double-chk\":{\"cat\":\"none\",\"group\":\"feeder\",\"title\":\"\\u53cc\\u5f20\\u68c0\\u6d4b\",\"desc\":\"\\u68c0\\u6d4b\\u662f\\u5426\\u6709\\u4e24\\u5f20\\u6216\\u8005\\u591a\\u5f20\\u7eb8\\u540c\\u65f6\\u6413\\u8fdb\",\"type\":\"string\",\"ui-pos\":18,\"auth\":0,\"size\":16,\"cur\":\"\\u8d85\\u58f0\\u6ce2\",\"default\":\"\\u8d85\\u58f0\\u6ce2\",\"range\":[\"\\u8d85\\u58f0\\u6ce2\",\"\\u7981\\u7528\"]},\"is-staple\":{\"cat\":\"none\",\"group\":\"feeder\",\"title\":\"\\u88c5\\u8ba2\\u68c0\\u6d4b\",\"desc\":\"\\u68c0\\u6d4b\\u662f\\u5426\\u6709\\u8ba2\\u4e66\\u9489\\u5b58\\u5728\",\"type\":\"bool\",\"fix-id\":34861,\"ui-pos\":20,\"auth\":0,\"size\":4,\"cur\":true,\"default\":true},\"motor-speed\":{\"cat\":\"none\",\"group\":\"feeder\",\"title\":\"\\u8d70\\u7eb8\\u901f\\u5ea6\",\"desc\":\"\\u8bbe\\u7f6e\\u8d70\\u7eb8\\u7535\\u673a\\u7684\\u901f\\u5ea6\\uff0c\\u5f20\\/\\u5206\\uff08PPM\\uff09\",\"type\":\"int\",\"ui-pos\":25,\"auth\":0,\"size\":4,\"cur\":100,\"default\":100,\"range\":[{\"dev-model!=G200\":70},{\"dev-model!=G200\":80},{\"dev-model!=G200\":90},100,{\"dev-model==G200\":110},{\"dev-model==G200\":120},{\"dev-model==G200\":130}]},\"is-check-askew\":{\"cat\":\"none\",\"group\":\"feeder\",\"title\":\"\\u6b6a\\u659c\\u68c0\\u6d4b\",\"desc\":\"\\u68c0\\u6d4b\\u8fdb\\u7eb8\\u662f\\u5426\\u6b6a\\u659c\",\"type\":\"bool\",\"fix-id\":34868,\"ui-pos\":22,\"auth\":0,\"size\":4,\"cur\":true,\"default\":true},\"askew-range\":{\"cat\":\"none\",\"group\":\"feeder\",\"title\":\"\\u6b6a\\u659c\\u5bb9\\u5fcd\\u5ea6\",\"desc\":\"\\u503c\\u8d8a\\u5c0f\\uff0c\\u80fd\\u5bb9\\u5fcd\\u5f97\\u9001\\u5165\\u6587\\u7a3f\\u6b6a\\u659c\\u89d2\\u5ea6\\u8d8a\\u5c0f\",\"type\":\"int\",\"fix-id\":34869,\"ui-pos\":23,\"auth\":0,\"size\":4,\"cur\":3,\"default\":3,\"range\":{\"min\":1,\"max\":7,\"step\":1},\"depend\":\"is-check-askew==true\"},\"cis-len\":{\"cat\":\"base\",\"group\":\"\\u5173\\u4e8e\",\"title\":\"\\u955c\\u5934\\u957f\",\"desc\":\"\\u56fe\\u50cf\\u91c7\\u96c6\\u955c\\u5934\\u7684\\u957f\\u5ea6\\uff0c\\u5355\\u4f4d\\u4e3a\\u6beb\\u7c73\\uff08mm\\uff09\",\"type\":\"int\",\"ui-pos\":30,\"auth\":0,\"unit\":\"mm\",\"readonly\":true,\"size\":4,\"auto\":false,\"cur\":3888,\"default\":3888},\"motor-ver\":{\"cat\":\"none\",\"group\":\"\\u5173\\u4e8e\",\"title\":\"\\u7535\\u673a\\u9a71\\u52a8\\u7248\\u672c\",\"desc\":\"\\u7535\\u673a\\u677f\\u9a71\\u52a8\\u7a0b\\u5e8f\\u7248\\u672c\\u53f7\",\"type\":\"string\",\"fix-id\":34909,\"ui-pos\":16,\"auth\":0,\"readonly\":true,\"size\":24,\"auto\":false,\"cur\":\"\",\"default\":\"\"},\"fpga-ver\":{\"cat\":\"none\",\"group\":\"\\u5173\\u4e8e\",\"title\":\"CIS\\u63a7\\u5236\\u5668\\u7248\\u672c\",\"desc\":\"\\u955c\\u5934\\u53c2\\u6570\\u63a7\\u5236\\u9a71\\u52a8\\u7a0b\\u5e8f\\u7248\\u672c\\u53f7\",\"type\":\"string\",\"ui-pos\":17,\"auth\":0,\"readonly\":true,\"size\":24,\"auto\":false,\"cur\":\"\",\"default\":\"\"}}"
};


/////////////////////////////////////////////////////////////////////////////////////////////////////////
// scanner_hw
scanner_hw::scanner_hw() : mb_events_("motorboard-event")
{
    set_where("hardware");
    mb_events_.enable_wait_log(false);

    init();
}
scanner_hw::~scanner_hw()
{
    close();
}

void scanner_hw::init(void)
{
    std::string text("");

    for(auto& v: device_opt_json)
        text += v;
    init_version(text);
    set_opt_json_text(&text[0]);

#define OPT_HANDLER(name)       \
    auto name = [this](void* value) -> void

    auto a = [this](void* value) -> void
    {
        auto_scan_ = *(bool*)value;
    };
    auto e = [this](void* value) -> void
    {
        if(strcmp((char*)value, "15s") == 0)
            time_to_exit_auto_scan_ = 15;
        else if(strcmp((char*)value, "30s") == 0)
            time_to_exit_auto_scan_ = 30;
        else if(strcmp((char*)value, "2min") == 0)
            time_to_exit_auto_scan_ = 120;
        else if(strcmp((char*)value, "4min") == 0)
            time_to_exit_auto_scan_ = 240;
        else if(strcmp((char*)value, "8min") == 0)
            time_to_exit_auto_scan_ = 480;
        else
            time_to_exit_auto_scan_ = 60;
    };

    auto m = [this](void* value) -> void
    {
        if(strcmp((char*)value, "\347\201\260\345\272\246") == 0)
            mode_ = (char*)value;
        else
            mode_ = "\345\275\251\350\211\262";
    };
    auto r = [this](void* value) -> void
    {
        if(*(int*)value <= 200)
            dpi_ = 200;
        else
            dpi_ = 300;
    };
    auto b = [this](void* value) -> void
    {
        baud_ = *(int*)value;
    };
    auto d = [this](void* value) -> void
    {
        delay_ = *(int*)value;
    };
    auto f = [this](void* value) -> void
    {
        frame_h_ = *(int*)value;
    };
    auto s = [this](void* value) -> void
    {
        sample_ = *(int*)value;
    };

    auto efb = [this](void* value) -> void
    {
        exposure_[SIDE_FRONT][COLOR_IND_BLUE] = *(int*)value;
    };
    auto efg = [this](void* value) -> void
    {
        exposure_[SIDE_FRONT][COLOR_IND_GREEN] = *(int*)value;
    };
    auto efr = [this](void* value) -> void
    {
        exposure_[SIDE_FRONT][COLOR_IND_RED] = *(int*)value;
    };
    auto ebb = [this](void* value) -> void
    {
        exposure_[SIDE_BACK][COLOR_IND_BLUE] = *(int*)value;
    };
    auto ebg = [this](void* value) -> void
    {
        exposure_[SIDE_BACK][COLOR_IND_GREEN] = *(int*)value;
    };
    auto ebr = [this](void* value) -> void
    {
        exposure_[SIDE_BACK][COLOR_IND_RED] = *(int*)value;
    };

    auto gf = [this](void* value) -> void
    {
        gain_[SIDE_FRONT] = *(int*)value;
    };
    auto gb = [this](void* value) -> void
    {
        gain_[SIDE_BACK] = *(int*)value;
    };

    auto of = [this](void* value) -> void
    {
        off_[SIDE_FRONT] = *(int*)value;
    };
    auto ob = [this](void* value) -> void
    {
        off_[SIDE_BACK] = *(int*)value;
    };

    CLEAN_ARRAY(exposure_);
    CLEAN_ARRAY(gain_);
    CLEAN_ARRAY(off_);

    opt_handler_[SANE_FULL_NAME(WAIT_TO_SCAN)] = a;
    opt_handler_[SANE_FULL_NAME(WAIT_SCAN_EXIT)] = e;

    opt_handler_[SANE_FULL_NAME(COLOR_MODE)] = m;
    opt_handler_[SANE_FULL_NAME(RESOLUTION)] = r;
    opt_handler_[SANE_FULL_NAME(CIS_BAUD)] = b;
    opt_handler_[SANE_FULL_NAME(CIS_DELAY)] = d;
    opt_handler_[SANE_FULL_NAME(CIS_FRAME_H)] = f;
    opt_handler_[SANE_FULL_NAME(CIS_SAMPLE)] = s;

    opt_handler_[SANE_FULL_NAME(CIS_EXPO_FB)] = efb;
    opt_handler_[SANE_FULL_NAME(CIS_EXPO_FG)] = efg;
    opt_handler_[SANE_FULL_NAME(CIS_EXPO_FR)] = efr;
    opt_handler_[SANE_FULL_NAME(CIS_EXPO_BB)] = ebb;
    opt_handler_[SANE_FULL_NAME(CIS_EXPO_BG)] = ebg;
    opt_handler_[SANE_FULL_NAME(CIS_EXPO_BR)] = ebr;

    opt_handler_[SANE_FULL_NAME(CIS_GAIN_FRONT)] = gf;
    opt_handler_[SANE_FULL_NAME(CIS_GAIN_BACK)] = gb;

    opt_handler_[SANE_FULL_NAME(CIS_OFFSET_FRONT)] = of;
    opt_handler_[SANE_FULL_NAME(CIS_OFFSET_BACK)] = ob;


    auto p = [this](void* value) -> void
    {
        paper_ = (char*)value;
    };
    auto l = [this](void* value) -> void
    {
        lateral_ = *(bool*)value;
    };

    opt_handler_[SANE_FULL_NAME(PAPER)] = p;
    opt_handler_[SANE_FULL_NAME(LATERAL)] = l;

    auto staple = [this](void* value) -> void
    {
        staple_chk_ = *(bool*)value;
    };
    auto screw = [this](void* value) -> void
    {
        screw_chk_ = *(bool*)value;
    };
    auto screwl = [this](void* value) -> void
    {
        screw_chk_level_ = *(int*)value;
    };
    auto dbchk = [this](void* value) -> void
    {
        double_chk_ = strcmp((char*)value, "\347\246\201\347\224\250") != 0;
    };
    auto motsp = [this](void* value) -> void
    {
        int speed = *(int*)value;
        if(family_ == "G200")
        {
            speed -= 100;       // 100 110 120 130
        }
        else
        {
            speed -= 70;        // 70 80 90 100
        }
        switch(speed)
        {
        case 10:
            motor_speed_ = SPEED_PPM_BASE_10;
            break;
        case 20:
            motor_speed_ = SPEED_PPM_BASE_20;
            break;
        case 30:
            motor_speed_ = SPEED_PPM_BASE_30;
            break;
        default:
            motor_speed_ = SPEED_PPM_BASE;
            break;
        }
    };
    auto fm = [this](void* value) -> void
    {
        family_ = (char*)value;
        utils::to_log(LOG_LEVEL_DEBUG, "Device family set as: %s\n", family_.c_str());
    };
    OPT_HANDLER(cntm)
    {
        
    };
    OPT_HANDLER(cnt)
    {
        scan_count_ = *(int*)value;
    };
    OPT_HANDLER(afs)
    {

    };
    OPT_HANDLER(ff)
    {

    };
    OPT_HANDLER(fs)
    {

    };
    OPT_HANDLER(slp)
    {

    };

    opt_handler_[SANE_FULL_NAME(IS_CHECK_STAPLE)] = staple;
    opt_handler_[SANE_FULL_NAME(IS_CHECK_ASKEW)] = screw;
    opt_handler_[SANE_FULL_NAME(ASKEW_RANGE)] = screwl;
    opt_handler_[SANE_FULL_NAME(DOUBLE_CHECK)] = dbchk;
    opt_handler_[SANE_FULL_NAME(MOTOR_SPEED)] = motsp;
    opt_handler_[SANE_FULL_NAME(DEVICE_MODEL)] = fm;
    opt_handler_[SANE_FULL_NAME(SCAN_MODE)] = cntm;
    opt_handler_[SANE_FULL_NAME(SCAN_COUNT)] = cnt;
    opt_handler_[SANE_FULL_NAME(IS_AUTO_FEED_STRENGTH)] = afs;
    opt_handler_[SANE_FULL_NAME(FEED_STRENGTH_VALUE)] = ff;
    opt_handler_[SANE_FULL_NAME(FEED_STRENGTH)] = fs;
    opt_handler_[SANE_FULL_NAME(TIME_TO_SLEEP)] = slp;
}
void scanner_hw::init_version(std::string& text)
{
    gb_json *jsn = new gb_json();

    if(jsn->attach_text(&text[0]))
    {
        gb_json *child = nullptr;
        jsn->get_value(SANE_FULL_NAME(MOTOR_VER), child);
        if(child)
        {
            unsigned int val = 0;
            char    buf[20] = {0};

            motor_.reset(new MotorBoard(nullptr));
            motor_->read(MB_PORT_VERSION, val);
            motor_.reset();

            sprintf(buf, "%u", val);
            child->set_value("cur", buf);
            child->set_value("default", buf);
            child->release();
        }

        jsn->get_value(SANE_FULL_NAME(FPGA_VER), child);
        if(child)
        {
            unsigned int val = 0;
            char    buf[20] = {0};

            img_controller_.reset(new FpgaComm(baud_, true));
            img_controller_->read(MAX_REGS - 1, val);
            img_controller_.reset();

            sprintf(buf, "0x%08x", val);
            child->set_value("cur", buf);
            child->set_value("default", buf);
            child->release();
        }
        
        jsn->get_value(SANE_FULL_NAME(CIS_LENGTH), child);
        if(child)
        {
            child->get_value("default", cis_length_);
            child->release();
        }
        
        text = jsn->to_string();
    }
    jsn->release();
}
void scanner_hw::thread_image_capture(void)
{
    PACKIMAGE       img;
    safe_fifo<int>  avail_mem("v4l2-mem");
    int             used_v4l2_mem = 0, times = 0;
    std::pair<int, int> mbev;

    auto put_v4l2_mem = [&](BEFORE_DESTROY_PARAM) -> BEFORE_DESTROY_RET
    {
        int ind = (int)(long)param;

        mem->detach(nullptr);
        avail_mem.save(ind);
    };

    utils::to_log(LOG_LEVEL_DEBUG, "scanning thread working ...\n");
    memset(&img, 0, sizeof(img));
    img.bpp = 8;
    img.channels = 3;
    img.resolution_x = 200;
    img.resolution_y = 200;
    img.width = cis_length_;
    img.height = 16380;
    motor_->clear_error();
    motor_->start();
    if(mb_events_.take(mbev, true))
        utils::to_log(LOG_LEVEL_DEBUG, "take first motorboard event: %d - 0x%08x\n", mbev.first, mbev.second);
    else
        utils::to_log(LOG_LEVEL_FATAL, "Wait Lifter event before scanning failed.\n");
    while(scanning_ && mbev.first == MOTOR_BORD_EVENT_LIFTER_READY)    // auto scan cycle ...
    {
        motor_->pick_paper();

        // scanning ONE turn ...
        while(scanning_ && motor_->wait_paper_out(3000))
        {
            size_t  size = 0;
            int     ind = -1;
            void*   frame = camera_->read_frame(5 * 1000, size, ind);
            dyn_mem_shared_ptr mem = nullptr;

            if(!frame)
            {
                break;
            }
            mem = new dyn_mem_shared(frame, size, put_v4l2_mem, (void*)ind);
            used_v4l2_mem++;
            img.pos.paper_ind++;
            img.pos.status = IMG_STATUS_OK;
            img_handler_(mem, true, &img);

            if(img.pos.paper_ind == scan_count_ || is_scan_fatal())
                break;

            // retrieve V4L2 memory ...
            retrieve_v4l2_mem(&avail_mem, &used_v4l2_mem);
            if(used_v4l2_mem >= camera_->get_mem_count())
            {
                stop_scan();
                utils::to_log(LOG_LEVEL_FATAL, "Scanning stopped for that V4L2 is out of memory!\n");
                break;
            }

            motor_->pick_paper();
        }

        // retrieve v4l2-mem ...
        int ind = -1;
        while(avail_mem.take(ind, false))
        {
            used_v4l2_mem--;
            camera_->add_v4l2_memory(ind);
        }

        if(!auto_scan_ || !scanning_)
            break;

        // wait paper ...
    }

    stop_scan();
    while(used_v4l2_mem)
    {
        if(times++ == 0)
            utils::to_log(LOG_LEVEL_DEBUG, "Wait to retrieve %d V4L2 memory(s) ...\n", used_v4l2_mem);
        else if(times >= 1000)
        {
            utils::to_log(LOG_LEVEL_FATAL, "Wait %d times, but %d V4L2 memory(s) has not returned yet!\n", times, used_v4l2_mem);
            break;
        }
        retrieve_v4l2_mem(&avail_mem, &used_v4l2_mem);
        std::this_thread::sleep_for(std::chrono::milliseconds(5));
    }
    utils::to_log(LOG_LEVEL_DEBUG, "scanning thread exited.\n");

    scanning_ = false;
}
bool scanner_hw::is_scan_fatal(void)
{
    return false;
}
void scanner_hw::retrieve_v4l2_mem(safe_fifo<int>* mem, int* used)
{
    int u = *used,
        ind = 0;

    while(u >= camera_->get_mem_count())
    {
        if(mem->size())
        {
            if(ind)
                utils::to_log(LOG_LEVEL_WARNING, "V4L2 memory returned.\n");
            break;
        }
        if(ind == 0)
            utils::to_log(LOG_LEVEL_WARNING, "V4L2 is out of memory, wait image processor return ...\n");

        if(ind++ > 1000)    // 3 seconds ...
            break;
        std::this_thread::sleep_for(std::chrono::milliseconds(3));
    }
    while(mem->take(ind, false))
    {
        u--;
        camera_->add_v4l2_memory(ind);
    }
    *used = u;
}

// sane_opt_provider
char* scanner_hw::get_value(const char* name, void* value, size_t* size, int* err)
{
    char    *ret = nullptr;

    if(err)
        *err = SCANNER_ERR_OK;

    if(strcmp(name, SANE_FULL_NAME(PAPER_ON)) == 0)
    {
        ret = (char*)malloc(sizeof(int));
        *(int*)ret = 0;
        *(bool*)ret = paper_on_;
        if(size)
            *size = sizeof(bool);
    }
    else if(strcmp(name, SANE_FULL_NAME(PAPER_W)) == 0)
    {
        SIZE sz = paper::size(paper_.c_str());
        double  mm = lateral_ && lateral_en_ ? sz.cy : sz.cx;

        ret = (char*)malloc(sizeof(double));
        *(double*)ret = mm;
        if(size)
            *size = sizeof(double);
    }
    else if(strcmp(name, SANE_FULL_NAME(PAPER_H)) == 0)
    {
        SIZE sz = paper::size(paper_.c_str());
        double  mm = lateral_ && lateral_en_ ? sz.cx : sz.cy;

        ret = (char*)malloc(sizeof(double));
        *(double*)ret = mm;
        if(size)
            *size = sizeof(double);
    }
    else if(err)
        *err = SCANNER_ERR_DEVICE_NOT_FOUND;

    return ret;
}
int scanner_hw::set_value(const char* name, void* val)
{
    if(scanning_)   // working, no set
    {
        return SCANNER_ERR_DEVICE_BUSY;
    }

    if(opt_handler_.count(name))
    {
        opt_handler_[name](val);

        return 0;
    }
    else
    {
        return SCANNER_ERR_DEVICE_NOT_SUPPORT;
    }
}
void scanner_hw::enable(const char* name, bool able)
{
    if(strcmp(name, SANE_FULL_NAME(LATERAL)) == 0)
        lateral_en_ = able;
}

// operation ...
int scanner_hw::open(std::function<IMAGE_HANDLER_PROTO> image_handler)
{
    this->close();
    int fh = 16380;

    if(!image_handler)
        return SCANNER_ERR_INVALID_PARAMETER;

    img_handler_ = image_handler;
    img_controller_.reset(new FpgaComm(baud_));
    if(!img_controller_->is_ok())
        return DEV_ERR(HD_001);

    img_controller_->setColorMode(mode_ == "\345\275\251\350\211\262" ? COLOR_MODE : GRAY_MODE);
    img_controller_->setDpi((dpi_ + 100) / 200);
    img_controller_->setDelayTime(delay_);
    img_controller_->setSample(sample_);
    // img_controller_->setSp(2520);

    void(FpgaComm::* exposure[])(int) = {&FpgaComm::setAExposureB, &FpgaComm::setAExposureG
        , &FpgaComm::setAExposureR, &FpgaComm::setBExposureB, &FpgaComm::setBExposureG, &FpgaComm::setBExposureR};
    for(int i = 0; i < SIDE_COUNT; ++i)
    {
        for(int j = 0; j < COLOR_IND_COUNT; ++j)
            (img_controller_.get()->*exposure[i * SIDE_COUNT + j])(exposure_[i][j]);
    }

    for(int i = 0; i < FpgaComm::CIS_SECTOR_COUNT; ++i)
        img_controller_->setAGain(i, gain_[SIDE_FRONT]);
    for(int i = 0; i < FpgaComm::CIS_SECTOR_COUNT; ++i)
        img_controller_->setBGain(i, gain_[SIDE_BACK]);

    for(int i = 0; i < FpgaComm::CIS_SECTOR_COUNT; ++i)
        img_controller_->setAOffset(i, off_[SIDE_FRONT]);
    for(int i = 0; i < FpgaComm::CIS_SECTOR_COUNT; ++i)
        img_controller_->setBOffset(i, off_[SIDE_BACK]);

    auto cb = [this](int ev, unsigned int data) -> void
    {
        mb_events_.save(std::make_pair(ev, data), true);
    };
    mb_events_.clear();
    motor_.reset(new MotorBoard(cb));
    motor_->set_double_inpect(double_chk_);
    motor_->set_staple_inpect(staple_chk_);
    motor_->set_screw_inpect(screw_chk_);
    motor_->set_screw_level(screw_chk_level_);
    motor_->set_speed_mode(motor_speed_);
    motor_->set_auto_paper(auto_scan_, true);

    unsigned int val = 0;
    if(motor_->read(MB_PORT_CONFIG, val))
        utils::to_log(LOG_LEVEL_DEBUG, "MotorBoard config : %p\n", val);
    else
        utils::to_log(LOG_LEVEL_FATAL, "Get motor-board config failed.\n");
    if(motor_->read(MB_PORT_STATUS, val))
        utils::to_log(LOG_LEVEL_DEBUG, "MotorBoard status : %p\n", val);
    else
        utils::to_log(LOG_LEVEL_FATAL, "Get motor-board status failed.\n");
    if(motor_->read(MB_PORT_MODE, val))
        utils::to_log(LOG_LEVEL_DEBUG, "MotorBoard mode   : %p\n", val);
    else
        utils::to_log(LOG_LEVEL_FATAL, "Get motor-board mode failed.\n");
    if(motor_->read(MB_PORT_VERSION, val))
        utils::to_log(LOG_LEVEL_DEBUG, "MotorBoard version: %p\n", val);
    else
        utils::to_log(LOG_LEVEL_FATAL, "Get motor-board version failed.\n");
    if(motor_->read(MB_PORT_CONFIG_EX, val))
        utils::to_log(LOG_LEVEL_DEBUG, "MotorBoard confige: %p\n", val);
    else
        utils::to_log(LOG_LEVEL_FATAL, "Get motor-board confige failed.\n");

    camera_.reset(new GVideoISP1());
    camera_->open(3888, fh);
    std::this_thread::sleep_for(std::chrono::milliseconds(20));

    img_controller_->setFrameHeight(frame_h_);
    img_controller_->capture();
    size_t size;
    int _int;
     auto data = camera_->read_frame(100,size,_int);
     if(data)
        camera_->add_v4l2_memory(_int);

    std::this_thread::sleep_for(std::chrono::milliseconds(20));
    img_controller_->setFrameHeight(fh / 2 * 3);
    if(1)
    {
        // debug ...
        unsigned int vals[] = {0x5ffa, 0x3300c9d, 0x1, 0xaa00aa, 0x340030aa, 0x1380193
                            , 0x1270131, 0x340030aa, 0x168000c, 0x168017b, 0, 0x0afa3f
                            , 0x3e8};
        for(int i = 0; i < _countof(vals); ++i)
            img_controller_->write(i, vals[i]);
        img_controller_->update();
    }
        
    return SCANNER_ERR_OK;
}
int scanner_hw::start_scan(void)
{
    unsigned int val = 0;

    if(!camera_.get() || !motor_.get() || !img_controller_.get())
        return DEV_ERR(NOT_READY);

    motor_->clear_error();
    if(!motor_->read(MB_PORT_STATUS, val))
        return DEV_ERR(GET_STATUS_FAILED);

    utils::to_log(LOG_LEVEL_DEBUG, "start scan: status = 0x%08x.\n", val);
    if (((SMBSTATUS*)&val)->open_machine)   // 0x700fe
        return DEV_ERR(COVER_OPENNED);

    if(!motor_->read(MB_PORT_MODE, val))
        return DEV_ERR(GET_STATUS_FAILED);

    utils::to_log(LOG_LEVEL_DEBUG, "start scan: mode-status = 0x%08x.\n", val);
    if(((SMBMODE*)&val)->paper_jammed_in ||
        ((SMBMODE*)&val)->paper_jammed_out)
        return DEV_ERR(PAPER_JAMMED);
        
    if(((SMBMODE*)&val)->feeding_paper_ready == 0 && !auto_scan_)
        return DEV_ERR(NO_PAPER);

    scanning_ = true;
    mb_events_.clear();
    scan_thread_.reset(new std::thread(&scanner_hw::thread_image_capture, this));

    return SCANNER_ERR_OK;
}
int scanner_hw::stop_scan(void)
{
    scanning_ = auto_scan_ = false;
    mb_events_.trigger();
    if(motor_.get())
    {
        motor_->set_auto_paper(false, false);
        motor_->stop();
    }

    if(camera_.get())
        camera_->stop();
    mb_events_.clear();

    return 0;
}
int scanner_hw::close(void)
{
    img_controller_.reset();
    if(motor_.get())
    {
        motor_->stop();
        motor_.reset();
    }
    if(camera_.get())
    {
        camera_->stop();
        camera_->close();
        camera_.reset();
    }
    if(scan_thread_.get() && scan_thread_->joinable())
        scan_thread_->join();
    scan_thread_.reset();

    return 0;
}
bool scanner_hw::is_scanning(void)
{
    return scanning_;
}