#include "imageusbhandler.h"
#include "opencv2/opencv.hpp"
#include "imgproc.h"
#include "stringex.hpp"
#include "memoryex.h"
#include "usbimageprocqueue.h"
#include "applog.h"
#include "StopWatch.h"
#include "imageencode.h"
#include <iostream>
#include "ImageApplyAutoCrop.h"
#include "ImageApplyColorCastCorrect.h"
#include "hgutils.h"
#include "correct_ultis.h"
#include <fstream>
#include <RockchipRga.h>
#include <RockchipRgaMacro.h>

static const std::string loggername = "imageusbhandler";


class HG_RGA_
{
public:
    HG_RGA_()   {     m_rkrga.RkRgaInit();      }
    ~HG_RGA_()  {     m_rkrga.RkRgaDeInit();    }
    cv::Mat HG_RGA_Resize(cv::Mat& srcMat, cv::Size dsize, double fx = 0, double fy = 0,
                          int interpolation = cv::INTER_LINEAR)
    {

        if(srcMat.channels() == 3)
        {
            int ret = 0;
            int srcWidth, srcHeight, srcFormat;
            int dstWidth, dstHeight, dstFormat;
            bo_t bo_src, bo_dst;

            srcWidth = srcMat.cols;
            srcHeight = srcMat.rows;
            srcFormat = RK_FORMAT_RGB_888;
            if(dsize.empty())
            {
                dstWidth = srcMat.cols*fx;
                dstHeight = srcMat.rows*fy;
            }
            else
            {
                dstWidth = dsize.width;
                dstHeight = dsize.height;
            }
            if((srcMat.cols == dstWidth) && (srcMat.rows == dstHeight))
                return srcMat;
            if(srcMat.cols > 8192 || srcMat.rows > 8192 || dstHeight > 4096 || dstWidth > 4096)
            {
                cv::resize(srcMat,srcMat,dsize,fx,fy,interpolation);
                return srcMat;
            }
            StopWatch sw;
            dstFormat = RK_FORMAT_RGB_888;
            rga_info_t src;
            rga_info_t dst;
            memset(&src, 0, sizeof(rga_info_t));
            src.fd = -1;
            src.mmuFlag = -1;
            src.virAddr = srcMat.data;
            cv::Mat dstmat(dstHeight, dstWidth, CV_8UC3);
            memset(&dst, 0, sizeof(rga_info_t));
            dst.fd = -1;
            dst.mmuFlag = -1;
            dst.virAddr = dstmat.data;
            rga_set_rect(&src.rect, 0, 0, srcWidth, srcHeight, srcWidth /*stride*/, srcHeight, srcFormat);
            rga_set_rect(&dst.rect, 0, 0, dstWidth, dstHeight, dstWidth /*stride*/, dstHeight, dstFormat);
            src.rotation = HAL_TRANSFORM_ROT_180;
            src.scale_mode = bilinear;
            for(int i  = 0;i <1;i++)
            {
                ret = m_rkrga.RkRgaBlit(&src, &dst, NULL);
                if (ret)
                {
                    printf("rgaFillColor error : %s\n", strerror(errno));
                }
            }
            printf("!!!!! rga resize times: %f  w[%d]  h[%d]\n",sw.elapsed_ms(),dstWidth,dstHeight);
            return dstmat;
        }
        else
        {
            cv::resize(srcMat,srcMat,dsize,fx,fy,interpolation);
            return srcMat;
        }
        // int rows = srcMat.rows / 2;
        // cv::Mat dst(rows, srcMat.cols, srcMat.type());
        // int step = srcMat.step;
        // uchar* ptr1 = srcMat.data;
        // uchar* ptr2 = srcMat.data + step;
        // uchar* ptr = dst.data;
        // ushort pix;
        // for (size_t i = 0; i < rows; i++)
        // {
        //     for (size_t j = 0; j < step; j++)
        //     {
        //         pix = (ptr1[j] + ptr2[j]) >> 1; 
        //         ptr[j] = pix;
        //     }
        //     ptr1 += step + step;
        //     ptr2 += step + step;
        //     ptr += step;
        // }
        // return dst;
    }
private:
    RockchipRga m_rkrga;
};


ImageUsbHandler::ImageUsbHandler(std::shared_ptr<UsbImageProcQueue> images)
    : pool(1), encodepools(5),pushpool(1)
{
    LOG_INIT();
    this->images = images;
    m_dog.reset(new CImageApplyDogEarDetection(40,1.0,50));
    m_colorcast.reset(new CImageApplyColorCastCorrect(CImageApplyColorCastCorrect::PreScheme::G200_3399));// 2023-9-25 pm CImageApplyColorCastCorrect(1)
    m_sizedetect.reset(new CSizedetect(1));
    m_imgstatus.status = Error_Status::NO_error;
    m_imgstatus.scannum = 0;
    initLut();
    auto info= Get_static_jsonconfig().getscannerinfo();
    H_ratio =*((float*)(&info.H_ratio));
    V_ratio =*((float*)(&info.V_ratio));
    m_rga.reset(new HG_RGA_());
    cv::setNumThreads(1);
}
ImageUsbHandler::~ImageUsbHandler()
{
    
}


void ImageUsbHandler::free_frame_data(int type)
{
    if(type == 1)   m_frame_buf.reset();
    if(type == 2)   {encode_data.Clear(); m_frame_datas = std::queue<frame_data_info>(); }
}

frame_data_info ImageUsbHandler::init_frame_data_info(uint32_t size)
{
    printf("\n init_frame_data size :%d\n",size);
    m_frame_buf.reset(new std::uint8_t[size],[](std::uint8_t*p){delete [] p;});
    frame_data_info p{0};
    p.total = size;
    p.pdata = (void*)m_frame_buf.get();
    return p;
}

frame_data_info ImageUsbHandler::init_frame_data_info(cv::Size size)
{
    StopWatch sw;
    cv::Mat mat = cv::Mat::zeros(size.height,size.width,CV_8UC1);
    printf("\ncv::Mat::zeros times :%f\n",sw.elapsed_ms());
    encode_data.Put(mat);
    frame_data_info p{0};
    p.total = size.width*size.height;
    p.pdata = (void*)mat.data;
    m_frame_datas.push(p);
    return p;
}

static int num = 0;
void ImageUsbHandler::add_image(void *data, int width, int height, int type, int scannnum,unsigned int fpgaversion,bool slow_moire,uint32_t error_code)
{
    std::string ext = ".jpg";
    {
        if (m_imgstatus.status != NO_error)
            return;
        cv::Mat mat;
        if(m_scanconfig.g200params.dpi == 3) 
            mat = cv::Mat(height, width, CV_8UC1, data);
        else
            mat =  cv::Mat(height, width, CV_8UC1, data).clone();                         
        capture_data.Put(mat);
        StopWatch checktime;
        if (m_hgimgconfig.is_dogeardetection || m_hgimgconfig.en_sizecheck)
        {
            cv::Mat tmp = cv::Mat(height, width, CV_8UC1, data);
            if (tmp.empty())
                return;
            m_imgstatus.status = Img_Detecting;
            auto mergemat = GetMergeMat(type == CV_8UC1 ? width : width / 3, height, type, tmp,fpgaversion);
            if(m_scanconfig.g200params.dpi==1)
            {
                #ifdef G100
                if(slow_moire)   cv::resize(mergemat, mergemat, cv::Size(0, 0), 200.0 / 300.0, 0.482);
                #else
                if(slow_moire)   cv::resize(mergemat, mergemat, cv::Size(0, 0), 200.0 / 300.0, 0.4842);
                #endif
                else    cv::resize(mergemat, mergemat, cv::Size(0, 0), 200.0 / 300.0, 1.0);
            }
            else if(m_scanconfig.g200params.dpi == 2)
            {
                #ifdef G100
                if(slow_moire) cv::resize(mergemat, mergemat, cv::Size(0, 0), 200.0 / 300.0, 200.0 / 300.0*0.7241); 
                #else
                if(slow_moire) cv::resize(mergemat, mergemat, cv::Size(0, 0), 200.0 / 300.0, 200.0 / 300.0*0.7256); 
                #endif
                else cv::resize(mergemat, mergemat, cv::Size(0, 0), 200.0 / 300.0, 200.0 / 300.0);
            }
            else
            {
#ifdef G200
                cv::resize(mergemat,mergemat,cv::Size(0,0),200.0 / 600.0,1.43434/3);
#else
                cv::resize(mergemat,mergemat,cv::Size(0,0),200.0 / 600.0,1.432323/3);
#endif
            }
               
            if (m_hgimgconfig.is_dogeardetection)
            {
                printf("\n is_dogeardetection");
                if(!m_scanconfig.g200params.pc_correct)
                     correctColor(mergemat, false);
                auto dogmat=mergemat(cv::Rect(mergemat.cols/2, 0, mergemat.cols/2, mergemat.rows));
                m_dog->apply(dogmat,0);
                if(m_dog->getResult())
                {
                    m_imgstatus.status=Dog_error;
                    m_imgstatus.scannum=scannnum;
                    add_scanevent({.From=IMG,.Code=m_imgstatus.status,.Img_Index=m_imgstatus.scannum,.Img_Status = img_status::IMG_STATUS_DOGEAR});
                    return;
                }
            }   
            if(m_hgimgconfig.en_sizecheck)
            {
                auto sizemat=mergemat(cv::Rect(mergemat.cols/2, 0, mergemat.cols/2, mergemat.rows));
                printf("\n en_sizecheck %d",m_scanconfig.g200params.paper);
                m_sizedetect->SetPapertype(m_scanconfig.g200params.paper);
                if(m_sizedetect->preprocess(sizemat,NULL))
                {
                    m_imgstatus.status=Size_error;  
                    m_imgstatus.scannum=scannnum;
                    add_scanevent({.From=IMG,.Code=m_imgstatus.status,.Img_Index=m_imgstatus.scannum,.Img_Status = img_status::IMG_STATUS_DOGEAR});
                    return;
                }                                  
            }
            m_imgstatus.status = NO_error;
        }
        //tmp.release();

        //std::lock_guard<std::mutex> guard(mtx);
        results.emplace(pool.enqueue([this, width, height, type, ext, scannnum, data ,fpgaversion,slow_moire,error_code]
                         {
                             printf("enqueue image index %d \n",scannnum);
                             StopWatch sw;
                             cv::Mat mat = capture_data.Take();

                            //  int dstwidth = type==CV_8UC1?width:width/3;
                            //  static int it=0;
                            //  StopWatch sss;                            
                            //  cv::Mat saveMat =GetMergeMat(dstwidth, height, type,mat,fpgaversion);
                            //  printf("\n Merge time  %f  fpgaversion %d \n",sss.elapsed_ms(),fpgaversion);
                            //  //cv::imwrite("/home/"+to_string(it++)+".bmp",saveMat);
                            //  //int dpi = saveMat.cols==7344?2:3;
                            //  if(!m_scanconfig.g200params.pc_correct)
                            //     correctColor(saveMat,m_scanconfig.g200params.dpi,saveMat.channels()==3?1:0,!m_scanconfig.g200params.is_textcorrect);
                            //  printf("\n correctColor time  %f \n",sw.elapsed_ms());

                            //  if((H_ratio != 1.0f) || (V_ratio != 1.0f))
                            //     cv::resize(saveMat,saveMat,cv::Size(),H_ratio,V_ratio); 
                            // encode_data.Put(saveMat);
                             
                             encodeimgs.push(encodepools.enqueue([this,width,height,type,slow_moire,scannnum,fpgaversion,error_code](cv::Mat mat) -> std::vector<MemoryPtr>
                                                             {
                                                                //auto saveMat = encode_data.Take(); 

                                                                int dstwidth = type==CV_8UC1?width:width/3;
                                                                StopWatch sss;                            
                                                                cv::Mat saveMat =GetMergeMat(dstwidth, height, type,mat,fpgaversion);
                                                                printf("\n Merge time  %f  fpgaversion %d \n",sss.elapsed_ms(),fpgaversion);
                                                                if(!m_scanconfig.g200params.pc_correct)
                                                                    correctColor(saveMat,m_scanconfig.g200params.dpi,saveMat.channels()==3?1:0,!m_scanconfig.g200params.is_textcorrect);

                                                                if (!m_scanconfig.g200params.iscorrect_mode){
                                                                    if(H_ratio>1.2f ||H_ratio<0.8f)
                                                                        H_ratio=1.0f;
                                                                    if(V_ratio>1.2f || V_ratio <0.8f)
                                                                        V_ratio=1.0f;
                                                                    if(m_scanconfig.g200params.dpi==1)
                                                                    {
                                                                        #ifdef G100
                                                                        if(slow_moire)   cv::resize(saveMat,saveMat,cv::Size(0,0),200.0/300.0*H_ratio,V_ratio*0.482,cv::InterpolationFlags::INTER_AREA);
                                                                        #else
                                                                        if(slow_moire)   cv::resize(saveMat,saveMat,cv::Size(0,0),200.0/300.0*H_ratio,V_ratio*0.4842,cv::InterpolationFlags::INTER_AREA);
                                                                        #endif
                                                                        else   cv::resize(saveMat,saveMat,cv::Size(0,0),200.0/300.0*H_ratio,1.0*V_ratio,(saveMat.channels() == 1) ? cv::InterpolationFlags::INTER_AREA :cv::InterpolationFlags::INTER_LINEAR);
                                                                    }
                                                                    if(m_scanconfig.g200params.dpi == 2)
                                                                    {
                                                                        #ifdef G100
                                                                        if(slow_moire) cv::resize(saveMat,saveMat,cv::Size(0,0),H_ratio,V_ratio*0.7241); 
                                                                        #else
                                                                        if(slow_moire) cv::resize(saveMat,saveMat,cv::Size(0,0),H_ratio,V_ratio*0.7256); 
                                                                        #endif
                                                                        else if((H_ratio != 1.0f) || (V_ratio != 1.0f))
                                                                            cv::resize(saveMat,saveMat,cv::Size(0,0),H_ratio,V_ratio); 
                                                                    }
                                                                    if(m_scanconfig.g200params.dpi == 3)
                                                                    #ifdef G200
                                                                        cv::resize(saveMat,saveMat,cv::Size(0,0),1.0*H_ratio,1.43434*V_ratio);  // 600 dpi ��������ʵ600�ɼ� 
                                                                    #else
                                                                        cv::resize(saveMat,saveMat,cv::Size(0,0),1.0*H_ratio,1.432323*V_ratio);
                                                                    #endif           
                                                                }                   
                                                                //cv::imwrite("/home/"+to_string(scannnum)+".bmp",saveMat);                              
                                                                cv::Mat imageMat;
                                                                std::vector<cv::Mat> imgs;
                                                                int actwidth = saveMat.cols / 2;
                                                                int actheight = saveMat.rows;
                                                                for (int i = 0; i < 2; i++)
                                                                {
                                                                    imageMat = saveMat(cv::Rect(i * actwidth, 0, actwidth, actheight));
                                                                    if (!imageMat.empty())
                                                                    {                                     
                                                                        imgs.push_back(imageMat);
                                                                    }
                                                                }
                                                                 std::shared_ptr<IImageEncode> imageencode; //(new BmpImageEncode());
                                                                 std::vector<MemoryPtr> encodedata;
                                                                 if (!m_scanconfig.g200params.iscorrect_mode)
                                                                 {
                                                                     if (m_hgimgconfig.is_switchfrontback && (imgs.size() > 1))
                                                                         std::swap(imgs[0], imgs[1]);
                                                                     
		                                                             if (!m_hgimgconfig.fillhole.is_fillhole){
                                                                        if(m_hgimgconfig.imageRotateDegree != 0.0 && m_hgimgconfig.imageRotateDegree != 180.0 && (imgs.size() > 1))
                                                                        {
                                                                            cv::flip(imgs[1], imgs[1], 0);
                                                                            cv::flip(imgs[1], imgs[1], 1);
                                                                        }
                                                                    }
                                                                     for (auto &ialsnode : m_ials)
                                                                     {
                                                                        if((error_code == 0x20)&&(m_hgimgconfig.is_autodiscradblank_normal || m_hgimgconfig.is_autodiscradblank_vince))
                                                                        {
                                                                            printf(" !!!! error_code == 0x20 \n");
                                                                            CImageApply * imgptr = ialsnode.get();
                                                                            if(typeid(*imgptr) == typeid(CImageApplyDiscardBlank))
                                                                                continue;
                                                                        }
                                                                         ialsnode->apply(imgs, bool(m_hgimgconfig.is_duplex));
                                                                     }
                                                                     if ((!m_hgimgconfig.is_duplex) && (imgs.size() > 1))
                                                                         imgs.pop_back();

                                                                 }
                                                                 
                                                                 for (auto &img : imgs)
                                                                 {
                                                                     cv::Mat enMat = img;
                                                                     if (!(enMat.empty() && (m_hgimgconfig.is_autodiscradblank_normal || m_hgimgconfig.is_autodiscradblank_vince)))
                                                                     {
                                                                        if(m_hgimgconfig.fadeback!=0)
                                                                        {
                                                                            if(enMat.channels()==3&&m_hgimgconfig.pixtype==1)
                                                                                cv::cvtColor(enMat,enMat,cv::COLOR_BGR2GRAY);
                                                                        }
                                                                        if(m_scanconfig.g200params.iscorrect_mode)
                                                                            imageencode.reset(new JpegImageEncode(false));
                                                                        else
                                                                            imageencode.reset(new JpegImageEncode(m_hgimgconfig.pixtype == 0));
                                                                            encodedata.push_back(imageencode->encode(enMat));
                                                                    }
                                                                 }
                                                                 return encodedata;
                                                             },mat));
                             pushpool.enqueue([this,error_code,scannnum]{
                                auto mem = encodeimgs.front().get();
                                encodeimgs.pop();
                                if (!mem.empty())
                                {
                                    for (int i=0;i<mem.size();i++)
                                    {
                                        if (mem[i].get())
                                            //images->push(mem[i], true,scannnum, (i == (mem.size()-1)) ? error_code : 0);
                                            images->push(mem[i], true,scannnum,error_code);
                                        else
                                            add_scanevent({.From = V4L2, .Code = 1});
                                    }
                                }
                             });
                             printf("imgproce time = %f \n", sw.elapsed_ms());
                             LOG_TRACE(string_format("imgproce time = %f\n", sw.elapsed_ms())); }));
    }
}

void ImageUsbHandler::add_image(void *data, int width, int height, int type, int scannnum,int frame_data_type,uint32_t adc_type,unsigned int fpgaversion,bool slow_moire,std::uint32_t error_code)
{
    std::string ext = ".jpg";
    {
        if (m_imgstatus.status != NO_error)
            return;
        cv::Mat src;
        if(frame_data_type == 2){
            src = encode_data.Take();
            // auto tmp = encode_data.Take();
            // src = cv::Mat(tmp.rows*3,tmp.cols/3,CV_8UC1,tmp.data).clone();
        }
        else
        {
            src = cv::Mat(height, width, CV_8UC1, data).clone();   
            // src = cv::Mat(height*3, width/3, CV_8UC1, data).clone();   
        }
        if(Image_Detection(src,type,slow_moire,fpgaversion,scannnum) != Error_Status::NO_error)
            return; 
        capture_data.Put(src);
        //std::lock_guard<std::mutex> guard(mtx);
        results.emplace(pool.enqueue([this, width, height, type, ext, scannnum, data ,fpgaversion,slow_moire,error_code,adc_type]
                         {
                             printf("enqueue image index %d \n",scannnum);                             
                             encodeimgs.push(encodepools.enqueue([this,width,height,type,slow_moire,fpgaversion,error_code,adc_type]() -> std::vector<MemoryPtr>
                                        {
                                        auto saveMat = capture_data.Take();
                                        // cv::imwrite("src.bmp",saveMat);
                                        if(adc_type == 19908458)
                                            saveMat = merge_color_8458(saveMat);
                                        else
                                            saveMat = merge_8478(saveMat,type==CV_8UC3,fpgaversion);
                                        if(!m_scanconfig.g200params.pc_correct)
                                            correctColor(saveMat,m_scanconfig.g200params.dpi,saveMat.channels()==3?1:0,!m_scanconfig.g200params.is_textcorrect,1);
                                        if(H_ratio>1.2f ||H_ratio<0.8f)
                                            H_ratio=1.0f;
                                        if(V_ratio>1.2f || V_ratio <0.8f)
                                            V_ratio=1.0f;

                                        if(m_scanconfig.g200params.dpi==1)
                                        {
                                            #ifdef G100
                                            if(slow_moire)   cv::resize(saveMat,saveMat,cv::Size(0,0),H_ratio,V_ratio*0.482,cv::InterpolationFlags::INTER_AREA);
                                            #else
                                            if(slow_moire)   cv::resize(saveMat,saveMat,cv::Size(0,0),H_ratio,V_ratio*0.517,cv::InterpolationFlags::INTER_AREA);
                                            #endif
                                            else   cv::resize(saveMat,saveMat,cv::Size(0,0),H_ratio,V_ratio); 
                                        }
                                        if(m_scanconfig.g200params.dpi == 2)
                                        {
                                            #ifdef G100
                                            if(slow_moire) cv::resize(saveMat,saveMat,cv::Size(0,0),H_ratio,V_ratio*0.7241); 
                                            #else
                                            if(slow_moire) cv::resize(saveMat,saveMat,cv::Size(0,0),H_ratio,V_ratio*0.7699); 
                                            #endif
                                            else if((H_ratio != 1.0f) || (V_ratio != 1.0f))
                                                cv::resize(saveMat,saveMat,cv::Size(0,0),H_ratio,V_ratio); 
                                        }
                                        if(m_scanconfig.g200params.dpi == 3)
                                            cv::resize(saveMat,saveMat,cv::Size(0,0),H_ratio,V_ratio);  // 600 dpi ��������ʵ600�ɼ� 

                                        // if(m_scanconfig.g200params.dpi==1)
                                        // {
                                        //     #ifdef G100
                                        //     if(slow_moire)   saveMat = m_rga->HG_RGA_Resize(saveMat,cv::Size(0,0),H_ratio,V_ratio*0.482,cv::InterpolationFlags::INTER_AREA);
                                        //     #else
                                        //     if(slow_moire)   saveMat = m_rga->HG_RGA_Resize(saveMat,cv::Size(0,0),H_ratio,V_ratio*0.517,cv::InterpolationFlags::INTER_AREA);
                                        //     #endif
                                        //     else   saveMat = m_rga->HG_RGA_Resize(saveMat,cv::Size(0,0),H_ratio,V_ratio);
                                        // }
                                        // if(m_scanconfig.g200params.dpi == 2)
                                        // {
                                        //     #ifdef G100
                                        //     if(slow_moire) saveMat = m_rga->HG_RGA_Resize(saveMat,cv::Size(0,0),H_ratio,V_ratio*0.7241); 
                                        //     #else
                                        //     if(slow_moire) saveMat = m_rga->HG_RGA_Resize(saveMat,cv::Size(0,0),H_ratio,V_ratio*0.7699); 
                                        //     #endif
                                        //     else if((H_ratio != 1.0f) || (V_ratio != 1.0f))
                                        //         saveMat = m_rga->HG_RGA_Resize(saveMat,cv::Size(0,0),H_ratio,V_ratio); 
                                        // }
                                        // if(m_scanconfig.g200params.dpi == 3)
                                        //     saveMat = m_rga->HG_RGA_Resize(saveMat,cv::Size(0,0),H_ratio,V_ratio);  // 600 dpi ��������ʵ600�ɼ�    
                                        
                                        cv::Mat imageMat;
                                        std::vector<cv::Mat> imgs;
                                        int actwidth = saveMat.cols / 2;
                                        int actheight = saveMat.rows;
                                        for (int i = 0; i < 2; i++)
                                        {
                                            imageMat = saveMat(cv::Rect(i * actwidth, 0, actwidth, actheight));
                                            // imageMat = saveMat(cv::Rect(i * actwidth, 0, actwidth, actheight)).clone();  
                                            // cv::imwrite("/root/img/"+std::to_string(num++)+".jpg",imageMat);
                                            // if(m_scanconfig.g200params.dpi == 3)    imageMat = interpolation_600dpi(imageMat,false);  
                                            
                                            // if(m_scanconfig.g200params.dpi==1)
                                            // {
                                            //     #ifdef G100
                                            //     if(slow_moire)   imageMat = m_rga->HG_RGA_Resize(imageMat,cv::Size(0,0),H_ratio,V_ratio*0.482,cv::InterpolationFlags::INTER_AREA);
                                            //     #else
                                            //     if(slow_moire)   imageMat = m_rga->HG_RGA_Resize(imageMat,cv::Size(0,0),H_ratio,V_ratio*0.517,cv::InterpolationFlags::INTER_AREA);
                                            //     #endif
                                            //     else   imageMat = m_rga->HG_RGA_Resize(imageMat,cv::Size(0,0),H_ratio,V_ratio);
                                            // }
                                            // if(m_scanconfig.g200params.dpi == 2)
                                            // {
                                            //     #ifdef G100
                                            //     if(slow_moire) imageMat = m_rga->HG_RGA_Resize(imageMat,cv::Size(0,0),H_ratio,V_ratio*0.7241); 
                                            //     #else
                                            //     if(slow_moire) imageMat = m_rga->HG_RGA_Resize(imageMat,cv::Size(0,0),H_ratio,V_ratio*0.7699); 
                                            //     #endif
                                            //     else if((H_ratio != 1.0f) || (V_ratio != 1.0f))
                                            //         imageMat = m_rga->HG_RGA_Resize(imageMat,cv::Size(0,0),H_ratio,V_ratio); 
                                            // }
                                            // if(m_scanconfig.g200params.dpi == 3)
                                            //     imageMat = m_rga->HG_RGA_Resize(imageMat,cv::Size(0,0),H_ratio,V_ratio);  // 600 dpi ��������ʵ600�ɼ�    
                                           
                                            // imageMat = this->m_rga->HG_RGA_Resize(imageMat,cv::Size(0,0),H_ratio,V_ratio);
                                            //cv::imwrite("/root/img/__"+std::to_string(num++)+".jpg",imageMat);
                                            imgs.push_back(imageMat);
                                        }
                                        std::shared_ptr<IImageEncode> imageencode; //(new BmpImageEncode());
                                        std::vector<MemoryPtr> encodedata;
                                        if (!m_scanconfig.g200params.iscorrect_mode)
                                        {
                                            if (m_hgimgconfig.is_switchfrontback && (imgs.size() > 1))
                                                std::swap(imgs[0], imgs[1]);
                                            printf(" \n!!!!m_hgimgconfig.papertype: %d  rows : %d \n",m_hgimgconfig.papertype,imgs[0].rows );
                                            if(!((m_hgimgconfig.papertype == 52 || m_hgimgconfig.papertype == 54) && (imgs[0].rows > 10800)))
                                            {                                           
                                                if (!m_hgimgconfig.fillhole.is_fillhole){
                                                    if(m_hgimgconfig.imageRotateDegree != 0.0 && m_hgimgconfig.imageRotateDegree != 180.0 && (imgs.size() > 1))
                                                    {
                                                        cv::flip(imgs[1], imgs[1], 0);
                                                        cv::flip(imgs[1], imgs[1], 1);
                                                    }
                                                }
                                                for (auto &ialsnode : m_ials)
                                                {
                                                    if((error_code == 0x20)&&(m_hgimgconfig.is_autodiscradblank_normal || m_hgimgconfig.is_autodiscradblank_vince))
                                                    {
                                                        printf(" !!!! error_code == 0x20 \n");
                                                        CImageApply * imgptr = ialsnode.get();
                                                        if(typeid(*imgptr) == typeid(CImageApplyDiscardBlank))
                                                            continue;
                                                    }
                                                    ialsnode->apply(imgs, bool(m_hgimgconfig.is_duplex));
                                                }
                                            }
                                            else
                                            {
                                                for (auto &img : imgs)
                                                {
                                                    if(!img.empty()) myFloodFill(img,true);
                                                }
                                            }
                                            if ((!m_hgimgconfig.is_duplex) && (imgs.size() > 1))
                                                imgs.pop_back();
                                        }

                                        for (auto &img : imgs)
                                        {
                                            cv::Mat enMat = img;
                                            if (!(enMat.empty() && (m_hgimgconfig.is_autodiscradblank_normal || m_hgimgconfig.is_autodiscradblank_vince)))
                                            {
                                                if(m_hgimgconfig.fadeback!=0)
                                                {
                                                    if(enMat.channels()==3&&m_hgimgconfig.pixtype==1)
                                                        cv::cvtColor(enMat,enMat,cv::COLOR_BGR2GRAY);
                                                }
                                                if(m_scanconfig.g200params.iscorrect_mode)
                                                    imageencode.reset(new JpegImageEncode(false));
                                                else
                                                    imageencode.reset(new JpegImageEncode(m_hgimgconfig.pixtype == 0));
                                                    //  imageencode.reset(new JpegImageEncode(true));
                                                // imageencode.reset(new BmpImageEncode());
                                                encodedata.push_back(imageencode->encode(enMat));
                                            }
                                        }
                                        return encodedata;
                                    }));
                             pushpool.enqueue([this,scannnum,error_code]{
                                auto mem = encodeimgs.front().get();
                                encodeimgs.pop();
                                if (!mem.empty())
                                {
                                    for (int i=0;i<mem.size();i++)
                                    {
                                        if (mem[i].get())
                                            images->push(mem[i], true,scannnum,error_code);
                                        else
                                            add_scanevent({.From = V4L2, .Code = 1});
                                    }
                                }
                             });
                        }));
    }
}

bool ImageUsbHandler::is_limit(uint32_t type){
    if((type > 0) && (m_hgimgconfig.papertype == 52 || m_hgimgconfig.papertype == 54))
    {
        while (results.size())
        {
            results.front().get();
            results.pop();
        }
        if (encodeimgs.size() >= 1)
            return true;
    }

    if (m_hgimgconfig.resolution_dst > 200.0 || m_hgimgconfig.papertype == 52 || m_hgimgconfig.papertype == 54 ||
        m_hgimgconfig.papertype == 131)
    {
        while (results.size() >= (m_scanconfig.g200params.dpi == 3 ? 1 : 3))
        {
            results.front().get();
            results.pop();
        }
        if (encodeimgs.size() >= (m_scanconfig.g200params.dpi == 3 ? 1 : 3))
            return true;
    }
    else
    {
        while (results.size() >= 15)
        {
            results.front().get();
            results.pop();
        }
        if (encodeimgs.size() >= 15)
            return true;
    }
    return false;
}

void ImageUsbHandler::add_scanevent(HGIntInfo status)
{
    VectorMemroyPtr mem = VectorMemroyPtr(new VectorMemroy());
    HGIntInfo info = status;
    mem->resize(sizeof(info));
    memcpy(&mem->buf()[0], &info, sizeof(info));
    images->push(mem, false);
}

void ImageUsbHandler::clear()
{
    if (images.get())
        images->clear();
    while (results.size() > 0)
        results.pop();
    while (encodeimgs.size() > 0)
        encodeimgs.pop();
    capture_data.Clear();
    encode_data.Clear();
}

void ImageUsbHandler::Set_ratio(u32 h_ratio,u32 v_ratio)
{
    H_ratio =*((float*)(&h_ratio));
    V_ratio =*((float*)(&v_ratio));
}



bool ImageUsbHandler::done()
{
    std::lock_guard<std::mutex> guard(mtx);
    if(results.size() >= 1){
        auto &fu_run = results.back();
        if((fu_run.valid() && (fu_run.wait_for(std::chrono::seconds(0)) != std::future_status::ready)))
            return false;
    }
    if(encodeimgs.size()>=1)
    {
        auto &fu_encode = encodeimgs.back();
        if((!fu_encode.valid()) && encodeimgs.size() == 1)
            return true;
        else
            return false;
        return !(fu_encode.wait_for(std::chrono::seconds(0)) != std::future_status::ready);
        //return (!(fu_run.wait_for(std::chrono::seconds(0)) != std::future_status::ready))&&(!(fu_encode.wait_for(std::chrono::seconds(0)) != std::future_status::ready));
    }
    return true;
}

void ImageUsbHandler::config_procparams(HGImgProcParms params)
{
    LOG_TRACE("****ImageUsbHandler config_procparams****\n");
    LOG_TRACE(string_format("HGImgProcParms.value = %d \n", params.value));
    LOG_TRACE(string_format("HGImgProcParms.papertype = %d  HGImgProcParms.scanside = %d \n", params.imgprocparams.papertype, params.imgprocparams.scanside));
    LOG_TRACE(string_format("HGImgProcParms.res = %d  HGImgProcParms.rotate = %d \n", params.imgprocparams.res, params.imgprocparams.rotate));
    LOG_TRACE(string_format("HGImgProcParms.autodescrew = %d  HGImgProcParms.fillbackground = %d \n", params.imgprocparams.autodescrew, params.imgprocparams.fillbackground));
    LOG_TRACE(string_format("HGImgProcParms.filter = %d  HGImgProcParms.enhancecolor = %d \n", params.imgprocparams.filter, params.imgprocparams.enhancecolor));
    LOG_TRACE(string_format("HGImgProcParms.fillhole = %d \n", params.imgprocparams.fillhole));
    m_procparams = params;
}


Error_Status ImageUsbHandler::Image_Detection(cv::Mat src,int type,bool slow_moire,int fpgaversion,int scannum)
{
    m_imgstatus.status = Error_Status::Img_Detecting;
    if (m_hgimgconfig.is_dogeardetection || m_hgimgconfig.en_sizecheck)
    {
        auto mergemat = merge_8478( src,type == CV_8UC3,fpgaversion);
        if(H_ratio>1.2f ||H_ratio<0.8f)
            H_ratio=1.0f;
        if(V_ratio>1.2f || V_ratio <0.8f)
            V_ratio=1.0f;
        
        if(m_scanconfig.g200params.dpi==1)
        {
            #ifdef G100
            if(slow_moire)   cv::resize(mergemat,mergemat,cv::Size(0,0),H_ratio,V_ratio*0.482,cv::InterpolationFlags::INTER_NEAREST);
            #else
            if(slow_moire)   cv::resize(mergemat,mergemat,cv::Size(0,0),H_ratio,V_ratio*0.517,cv::InterpolationFlags::INTER_NEAREST);
            #endif
            else             cv::resize(mergemat,mergemat,cv::Size(0,0),H_ratio,V_ratio,cv::InterpolationFlags::INTER_NEAREST);
        }
        if(m_scanconfig.g200params.dpi == 2)
        {
            #ifdef G100
            if(slow_moire) cv::resize(mergemat,mergemat,cv::Size(0,0),H_ratio/1.5,V_ratio*0.7241/1.5,cv::InterpolationFlags::INTER_NEAREST); 
            #else
            if(slow_moire) cv::resize(mergemat,mergemat,cv::Size(0,0),H_ratio/1.5,V_ratio*0.7699/1.5,cv::InterpolationFlags::INTER_NEAREST); 
            #endif
            else           cv::resize(mergemat,mergemat,cv::Size(0,0),H_ratio/1.5,V_ratio/1.5,cv::InterpolationFlags::INTER_NEAREST); 
        }
        if(m_scanconfig.g200params.dpi == 3)
            cv::resize(mergemat,mergemat,cv::Size(0,0),H_ratio/3.0,V_ratio/3.0,cv::InterpolationFlags::INTER_NEAREST);
        if (m_hgimgconfig.is_dogeardetection)
        {
            printf("\n is_dogeardetection");
            if(!m_scanconfig.g200params.pc_correct)
                    correctColor(mergemat,m_scanconfig.g200params.dpi,mergemat.channels()==3?1:0,!m_scanconfig.g200params.is_textcorrect,1);
            auto dogmat=mergemat(cv::Rect(mergemat.cols/2, 0, mergemat.cols/2, mergemat.rows));
            m_dog->apply(dogmat,0);
            if(m_dog->getResult())
            {
                m_imgstatus.status=Error_Status::Dog_error;
                add_scanevent({.From=IMG,.Code=m_imgstatus.status,.Img_Index=m_imgstatus.scannum});
                return m_imgstatus.status;
            }
        }   
        if(m_hgimgconfig.en_sizecheck)
        {
            auto sizemat=mergemat(cv::Rect(mergemat.cols/2, 0, mergemat.cols/2, mergemat.rows));
            printf("\n en_sizecheck %d",m_scanconfig.g200params.paper);
            m_sizedetect->SetPapertype(m_scanconfig.g200params.paper);
            if(m_sizedetect->preprocess(sizemat,NULL))
            {
                m_imgstatus.status=Error_Status::Size_error;  
                add_scanevent({.From=IMG,.Code=m_imgstatus.status,.Img_Index=m_imgstatus.scannum});
                return m_imgstatus.status;
            }                                  
        }
    }
    m_imgstatus.status = Error_Status::NO_error;
    return m_imgstatus.status;
}

void ImageUsbHandler::myFloodFill(cv::Mat &image, bool isTwoSide)
{
    int w = image.cols;
    int h = image.rows;
    cv::Vec3b lt, rt, lb, rb;
    const double threshold = 10;

    if (!isTwoSide)
    {
        lt = image.channels() == 3 ? image.at<cv::Vec3b>(0, 0) : image.at<uchar>(0, 0);
        if (lt[0] < threshold && lt[1] < threshold && lt[2] < threshold)
            cv::floodFill(image, cv::Point(0, 0), cv::Scalar::all(255), 0, cv::Scalar::all(5), cv::Scalar::all(40), cv::FLOODFILL_FIXED_RANGE);

        rt = image.channels() == 3 ? image.at<cv::Vec3b>(0, w - 1) : image.at<uchar>(0, w - 1);
        if (rt[0] < threshold)
            cv::floodFill(image, cv::Point(w - 1, 0), cv::Scalar::all(255), 0, cv::Scalar::all(5), cv::Scalar::all(40), cv::FLOODFILL_FIXED_RANGE);

        lb = image.channels() == 3 ? image.at<cv::Vec3b>(h - 1, 0) : image.at<uchar>(h - 1, 0);
        if (lb[0] < threshold)
            cv::floodFill(image, cv::Point(0, h - 1), cv::Scalar::all(255), 0, cv::Scalar::all(5), cv::Scalar::all(40), cv::FLOODFILL_FIXED_RANGE);

        rb = image.channels() == 3 ? image.at<cv::Vec3b>(h - 1, w - 1) : image.at<uchar>(h - 1, w - 1);
        if (rb[0] < threshold)
            cv::floodFill(image, cv::Point(w - 1, h - 1), cv::Scalar::all(255), 0, cv::Scalar::all(5), cv::Scalar::all(40), cv::FLOODFILL_FIXED_RANGE);
    }
    else
    {
        int w_ = w / 2;
        lt = image.channels() == 3 ? image.at<cv::Vec3b>(0, 0) : image.at<uchar>(0, 0);
        if (lt[0] < threshold && lt[1] < threshold && lt[2] < threshold)
            cv::floodFill(image, cv::Point(0, 0), cv::Scalar::all(255), 0, cv::Scalar::all(5), cv::Scalar::all(40), cv::FLOODFILL_FIXED_RANGE);

        rt = image.channels() == 3 ? image.at<cv::Vec3b>(0, w_ - 1) : image.at<uchar>(0, w_ - 1);
        if (rt[0] < threshold && rt[1] < threshold && rt[2] < threshold)
            cv::floodFill(image, cv::Point(w_ - 1, 0), cv::Scalar::all(255), 0, cv::Scalar::all(5), cv::Scalar::all(40), cv::FLOODFILL_FIXED_RANGE);

        lb = image.channels() == 3 ? image.at<cv::Vec3b>(h - 1, 0) : image.at<uchar>(h - 1, 0);
        if (lb[0] < threshold && lb[1] < threshold && lb[2] < threshold)
            cv::floodFill(image, cv::Point(0, h - 1), cv::Scalar::all(255), 0, cv::Scalar::all(5), cv::Scalar::all(40), cv::FLOODFILL_FIXED_RANGE);

        rb = image.channels() == 3 ? image.at<cv::Vec3b>(h - 1, w_ - 1) : image.at<uchar>(h - 1, w_ - 1);
        if (rb[0] < threshold && rb[1] < threshold && rb[2] < threshold)
            cv::floodFill(image, cv::Point(w_ - 1, h - 1), cv::Scalar::all(255), 0, cv::Scalar::all(5), cv::Scalar::all(40), cv::FLOODFILL_FIXED_RANGE);

        lt = image.channels() == 3 ? image.at<cv::Vec3b>(0, w_) : image.at<uchar>(0, w_);
        if (lt[0] < threshold && lt[1] < threshold && lt[2] < threshold)
            cv::floodFill(image, cv::Point(w_, 0), cv::Scalar::all(255), 0, cv::Scalar::all(5), cv::Scalar::all(40), cv::FLOODFILL_FIXED_RANGE);

        rt = image.channels() == 3 ? image.at<cv::Vec3b>(0, w - 1) : image.at<uchar>(0, w - 1);
        if (rt[0] < threshold && rt[1] < threshold && rt[2] < threshold)
            cv::floodFill(image, cv::Point(w - 1, 0), cv::Scalar::all(255), 0, cv::Scalar::all(5), cv::Scalar::all(40), cv::FLOODFILL_FIXED_RANGE);

        lb = image.channels() == 3 ? image.at<cv::Vec3b>(h - 1, w_) : image.at<uchar>(h - 1, w_);
        if (lb[0] < threshold && lb[1] < threshold && lb[2] < threshold)
            cv::floodFill(image, cv::Point(w_, h - 1), cv::Scalar::all(255), 0, cv::Scalar::all(5), cv::Scalar::all(40), cv::FLOODFILL_FIXED_RANGE);

        rb = image.channels() == 3 ? image.at<cv::Vec3b>(h - 1, w - 1) : image.at<uchar>(h - 1, w - 1);
        if (rb[0] < threshold && rb[1] < threshold && rb[2] < threshold)
            cv::floodFill(image, cv::Point(w - 1, h - 1), cv::Scalar::all(255), 0, cv::Scalar::all(5), cv::Scalar::all(40), cv::FLOODFILL_FIXED_RANGE);
    }
}