云南调试

pans

2019-04-03 da184ac7eef8ca74e12bdc63abf205e2fd5f9917

 QiaoJiaSystem/GB28181DecoderModel/VideoCaptureElementWithRtp.cpp

@@ -35,8 +35,53 @@

bool BASICGB28181::VideoCaptureElementWithRtp::startRtpStream(int streamTransType) {

    if(!m_waitSignalrunning) {
        DBG("std::thread waitSignalAndEmit create New!!");
        //等待下层ffmpeg将rtp包解码成为图片后触发信号,然后触发当前类的submit
        std::thread waitSignalAndEmit([&](BASICGB28181::VideoCaptureElementWithRtp *p_this) {
            p_this->m_waitSignal = true;
            p_this->m_waitSignalrunning = true;
            //循环，由成员变量来维护这个线程的运行状态
            while (p_this->m_waitSignal) {
//#TODO wait test
#ifdef TestCode
                DBG("waitSignal(\"DecoderImageOK\") begin");
#endif
                //等待信号触发
                gSignalLock.waitSignal(p_this->m_chanPubID + "DecoderImageOK");
#ifdef TestCode
                DBG("waitSignal(\"DecoderImageOK\") after");
#endif
                /****录像模块代码*****/
                p_this->m_picCount++;
                //几张选一张放入Redis
                if (p_this->m_picCount % m_nPicsPickOne != 0) {
                    continue;
                } else {
                    p_this->m_picCount.store(0);
                }

//            从ffmpeg解码类中获取图片
                p_this->m_fFmpegDecoderJPG.getImage().copyTo(p_this->m_image);
                {
                    cv::Mat copyMat;
                    std::string imageName = p_this->m_fFmpegDecoderJPG.GetImageName();
                    p_this->m_image.copyTo(copyMat);
                    m_pManager->SaveImageToRedis(p_this->m_chanPubID, imageName, copyMat);
                }
                /*********/

                p_this->submit();
            }
            p_this->m_waitSignalrunning = false;
            INFO("waitSignalAndEmit is exit...");
        }, this);
        waitSignalAndEmit.detach();
    }

    TryCath(
    //--------------国标设备或则国标下级平台必须支持GB28181-2016----------------------------------------------
    //解码线程，发起点播请求，启动ffmpeg解码模块
        std::thread videoCaptureElementThd([&](VideoCaptureElementWithRtp *p_this, int streamType) {
            DBG("videoCaptureElementThd start...");
            StreamTransType_E etype;
@@ -61,23 +106,57 @@
            }
            DBG("C_RealVideoStart start... m_chanPubID is " << p_this->m_chanPubID << " etype is " << etype
                                                            << " m_userdata is " << m_userdata);
            //开始点播视频
            long lrealhandle = C_RealVideoStart(const_cast<char *>(p_this->m_chanPubID.c_str()), etype,
                                                p_this->streamcallback, m_userdata);

            if (lrealhandle != -1) {
                //点播成功
                DBG(p_this->m_chanPubID << "  C_RealVideoStart ok ... type is " << etype);
                p_this->m_running = true;
                //启动ffmpeg解码模块
                p_this->m_fFmpegDecoderJPG.startThd(p_this->m_chanPubID, p_this->m_fps, p_this->m_gpuIdx);
                usleep(1000000);
                //阻塞线程，等待外部触发关闭点播
                while (p_this->m_running) {
                    usleep(300000);
                    if(p_this->m_fFmpegDecoderJPG.getRunning()) {
                        usleep(300000);
                    } else {

                        // 根据reopenTime判断是否需要重启
                        if (reopenTime < 0) {
                            p_this->m_running = false;
                            stop();
                            INFO("grabFrame faild, element stopping");
                        } else {
                            //todo 业务死锁
                            usleep((6 - reopenTime--) * 1000000);
                            INFO("grabFrame faild, try reopen video: ");

                            //关闭ffmpeg解码模块
                            p_this->m_fFmpegDecoderJPG.stopThd();
                            //启动ffmpeg解码模块
                            p_this->m_fFmpegDecoderJPG.startThd(p_this->m_chanPubID, p_this->m_fps, p_this->m_gpuIdx);
                            continue;
                        }
                    }
                }
                DBG("videoCaptureElementThd stop ...");
                //停止点播
                C_RealVideoStop(lrealhandle);
                //将waitSignalAndEmit 线程退出
                p_this->m_waitSignal = false;
                DBG("videoCaptureElementThd stop ok...");
            } else {
                //点播失败
                p_this->m_waitSignal = false;
                p_this->m_running = false;

                //关闭ffmpeg解码模块
                p_this->m_fFmpegDecoderJPG.stopThd();
                ERR(p_this->m_chanPubID << " C_RealVideoStart is error lrealhandle is  " << lrealhandle);

                p_this->startRtpStream(p_this->m_streamTransType);
            }

        }, this, streamTransType);
@@ -118,48 +197,32 @@
//        fwrite(data, sizeof(char), datalen, fp11);
    }
#endif

    //将底层组好的rtp包，存入ffmpeg中的缓存队列
    CHKDBG(p_this->m_fFmpegDecoderJPG.pushInfo(data, datalen, p_this->m_chanPubID), true,
           "pushInfo is error !! handle is " << handle << " datatype is " << datatype << " frametype is " << frametype);
}

void BASICGB28181::VideoCaptureElementWithRtp::threadFunc() {

//    if ((!m_running) || (!m_waitSignal)) {
////        根据reopenTime判断是否需要重启
//        if (reopenTime < 0) {
//            stop();
//            INFO("grabFrame faild, element stopping");
//            return;
//        } else {
//            //todo 业务死锁
//            usleep(reopenTime * 1000);
//            INFO("grabFrame faild, try reopen video: ");
//            startRtpStream(m_streamTransType);
//            return;
//        }
//    }
    fireConnectors();
}

void BASICGB28181::VideoCaptureElementWithRtp::threadInitial() {

    std::thread waitSignalAndEmit([&](BASICGB28181::VideoCaptureElementWithRtp *p_this) {
        p_this->m_waitSignal = true;
        while (p_this->m_waitSignal) {
//#TODO wait test
#ifdef TestCode
            DBG("waitSignal(\"DecoderImageOK\") begin");
#endif
            gSignalLock.waitSignal(p_this->m_chanPubID + "DecoderImageOK");
#ifdef TestCode
            DBG("waitSignal(\"DecoderImageOK\") after");
#endif
            p_this->m_picCount++;
            //几张选一张放入Redis
            if (p_this->m_picCount % m_nPicsPickOne != 0) {
                continue;
            } else {
                p_this->m_picCount.store(0);
            }

            p_this->m_fFmpegDecoderJPG.getImage().copyTo(p_this->m_image);
            {
                cv::Mat copyMat;
                std::string imageName = p_this->m_fFmpegDecoderJPG.GetImageName();
                p_this->m_image.copyTo(copyMat);
                m_pManager->SaveImageToRedis(p_this->m_chanPubID, imageName, copyMat);
            }
            p_this->submit();
        }
        INFO("waitSignalAndEmit is exit...");
    }, this);
    waitSignalAndEmit.detach();
    startRtpStream(m_streamTransType);
}