modularization/src/tool/RemoteCtrl_Stream/ivpicsave.cpp

#include "ivpicsave.h"

#include <QDateTime>

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

#ifdef NVIDIA_AGX
#include <opencv2/imgcodecs/legacy/constants_c.h>    //OpenCV4 use this line
#include <opencv2/imgproc/types_c.h>   //OpenCV4 use this line
#endif

ivpicsave::ivpicsave(QString strdir,QString strsuffix,std::string strvin)
{
    mstrdir = strdir;
    mstrsuffix = strsuffix;
    mstrvin = strvin;
    mnWriteIndex = 0;
}

void ivpicsave::SetPic(iv::vision::rawpic pic)
{
    if((mbGetPicSize == true ) && (mbSave == false))
    {
        return;
    }
    mMutex.lock();
    mrawpic.CopyFrom(pic);
    mnWriteIndex++;
    mMutex.unlock();
}

void ivpicsave::run()
{
    int nReadIndex = 0;
    std::vector<iv::vision::rawpic> xvectorpic;
    bool bgetfps = false;
    double ffps = 30;
    while(!QThread::isInterruptionRequested())
    {
        if((mbSave == false)&&(bgetfps))
        {
            msleep(100);
            continue;
        }
        bool bNew = false;
        iv::vision::rawpic pic;
        if(mnWriteIndex != nReadIndex)
        {

            mMutex.lock();
            pic.CopyFrom(mrawpic);
            mMutex.unlock();
            if(bgetfps == false)
            {
                xvectorpic.push_back(pic);
                if(xvectorpic.size()>=10)
                {
                    std::vector<qint64> xtimediff;
                    int j;
                    for(j=1;j<xvectorpic.size();j++)
                    {
                        qint64 diff = xvectorpic[j].time() - xvectorpic[j-1].time();
                        xtimediff.push_back(diff);
                    }
                    qint64 totaldiff = 0;
                    for(j=0;j<xtimediff.size();j++)
                    {
                        totaldiff = totaldiff + xtimediff[j];
                    }
                    qint64 avgdiff = totaldiff/xtimediff.size();
                    ffps = avgdiff;
                    if(ffps<1.0)ffps =1.0;
                    if(ffps>1000.0)ffps = 1000.0;
                    ffps = 1000.0/ffps;
                    mMutexSave.lock();
                    mfps = ffps;
                    mnpicheight = xvectorpic[0].height();
                    mnpicwidth = xvectorpic[0].width();
                    mMutexSave.unlock();
                    mbGetPicSize = true;
                    bgetfps = true;
                    xvectorpic.clear();
                    xtimediff.clear();
                }
            }
            nReadIndex++;
            bNew = true;
        }

        if(mbSave == false)
        {
            msleep(1);
            continue;
        }
        if(bNew)
        {
            cv::Mat mat(pic.height(),pic.width(),pic.mattype());

            if(mbSave)
            {
                if(pic.type() == 1)
                    memcpy(mat.data,pic.picdata().data(),mat.rows*mat.cols*mat.elemSize());
                else
                {
                    std::vector<unsigned char> buff(pic.picdata().data(),pic.picdata().data()+pic.picdata().size());
                    mat = cv::imdecode(buff,CV_LOAD_IMAGE_COLOR);
                }
                int font = cv::FONT_HERSHEY_DUPLEX;
                QDateTime xrecvtime = QDateTime::fromMSecsSinceEpoch(pic.time());
         //       char strtext[256];
          //      snprintf(strtext,"%s",xrecvtime.toString("yyyy-MM-dd hh:mm:ss:zzz").toLatin1().data());
                std::string strtext = xrecvtime.toString("yyyy-MM-dd hh:mm:ss:zzz").toStdString();
                double fratio = pic.width()/640;
                int fontsize = 0.5*fratio;
                if(fontsize<1)fontsize = 1;
                cv::putText(mat,strtext,cv::Point(pic.width() - 230*fratio,30*fratio),font,0.5*fratio,cv::Scalar(0,255,0),fontsize);
                cv::putText(mat,mstrvin,cv::Point(10,30*fratio),font,0.5*fratio,cv::Scalar(0,255,0),fontsize);
            }


            mMutexSave.lock();
            if(mbSave)
            {
                mWriter<<mat;
            }
            mMutexSave.unlock();
        }
        msleep(10);
    }
}

void ivpicsave::startsave()
{
    std::string strfilename;
    strfilename = mstrdir.toStdString() + QDateTime::currentDateTime().toString("yyyy-MM-dd-hh-mm-ss-zzz").toStdString() +"-" + mstrsuffix.toStdString() +".avi";
    mMutexSave.lock();
    mWriter.open(strfilename,cv::VideoWriter::fourcc('M','P','4','2'),10.0,cv::Size(mnpicwidth,mnpicheight),1);
    if(mWriter.isOpened())
    {
        mbSave = true;
    }
    mMutexSave.unlock();
}

void ivpicsave::stopsave()
{
    if(mbSave)
    {
        mMutexSave.lock();
        mbSave = false;
        mWriter.release();
        mMutexSave.unlock();
    }
}