modularization/src/driver/driver_piccompress/main.cpp

#include <QCoreApplication>

#include <thread>

#include <opencv2/opencv.hpp>
#include <opencv2/core.hpp>

#ifdef SYSTEM_AGX
#include "opencv2/imgcodecs/legacy/constants_c.h"
#include <opencv2/imgproc/types_c.h>

#endif

#ifdef Q_OS_WIN
#include "opencv2/imgcodecs/legacy/constants_c.h"
#include <opencv2/imgproc/types_c.h>
#endif




#include <QTime>

#include "modulecomm.h"
#include "rawpic.pb.h"
#include "xmlparam.h"
#include "ivversion.h"
#include "ivbacktrace.h"

int gnpicquuality = 60;
int gnwidth = 640;
int gnheight = 360;

std::string gstrmem_input;
std::string gstrmem_output;

void * gpainput;
void * gpaoutput;

void Listenpic(const char * strdata,const unsigned int nSize,const unsigned int index,const QDateTime * dt,const char * strmemname)
{
    if(nSize<1000)return;
    iv::vision::rawpic pic;
    if(false == pic.ParseFromArray(strdata,nSize))
    {
        std::cout<<"picview Listenpic fail."<<std::endl;
        return;
    }

    cv::Mat mat(pic.height(),pic.width(),pic.mattype());

    if(pic.type() == 1)
        memcpy(mat.data,pic.picdata().data(),mat.rows*mat.cols*mat.elemSize());
    else
    {

 //       qDebug("jpg");
        std::vector<unsigned char> buff(pic.picdata().data(),pic.picdata().data()+pic.picdata().size());
        mat = cv::imdecode(buff,CV_LOAD_IMAGE_COLOR);
    }

    std::vector<int> param = std::vector<int>(2);
    param[0] = CV_IMWRITE_JPEG_QUALITY;
    param[1] = gnpicquuality; // default(95) 0-100
    std::vector<unsigned char> buff;

    cv::Mat mat1;

    cv::resize(mat,mat1,cv::Size(gnwidth,gnheight));

    iv::vision::rawpic outpic;

    cv::imencode(".jpg", mat1, buff, param);
    outpic.set_picdata(buff.data(),buff.size());
    buff.clear();
    outpic.set_type(2);
    outpic.set_time(pic.time());
    outpic.set_index(pic.index());

    outpic.set_elemsize(mat1.elemSize());
    outpic.set_width(mat1.cols);
    outpic.set_height(mat1.rows);

    int ndatasize = outpic.ByteSize();
    std::cout<<outpic.index()<<":after compress . size is "<<ndatasize<<std::endl;
    char * strbuf = new char[ndatasize];
    if(outpic.SerializeToArray(strbuf,ndatasize))
    {
        iv::modulecomm::ModuleSendMsg(gpaoutput,strbuf,ndatasize);
    }
    delete strbuf;


}

int main(int argc, char *argv[])
{
    RegisterIVBackTrace();
    showversion("driver_piccompress");
    QCoreApplication a(argc, argv);

    char strxmlpath[256];
    if(argc<2)
    {
        snprintf(strxmlpath,255,"driver_piccompress.xml");
    }
    else
    {
        strncpy(strxmlpath,argv[1],255);
    }

    std::cout<<" xml path:"<<strxmlpath<<std::endl;

    iv::xmlparam::Xmlparam xp(strxmlpath);

    gstrmem_input = xp.GetParam("input","usbpic");
    gstrmem_output = xp.GetParam("output","compresspic");

    std::cout<<"input:"<<gstrmem_input<<std::endl;
    std::cout<<"output:"<<gstrmem_output<<std::endl;

    std::string strquality = xp.GetParam("quality","60");
    gnpicquuality = atoi(strquality.data());
    std::cout<<"picture quality:"<<gnpicquuality<<std::endl;

    std::string strwidth = xp.GetParam("width","640");
    gnwidth = atoi(strwidth.data());
    std::cout<<"width:"<<gnwidth<<std::endl;

    std::string strheight = xp.GetParam("height","360");
    gnheight = atoi(strheight.data());
    std::cout<<"height:"<<gnheight<<std::endl;

    gpainput = iv::modulecomm::RegisterRecv(gstrmem_input.data(),Listenpic);
    gpaoutput = iv::modulecomm::RegisterSend(gstrmem_output.data(),10000000,1);

    return a.exec();
}