下面是返回结果，用的就是https://gitee.com/ascend/EdgeAndRobotics/tree/master/Samples/YOLOV5USBCamera这个样例，C++代码，CANN是昇腾社区的
root@davinci-mini:~# bash get_env.sh 
davinci_device list in the current environment is 
crw-rw---- 1 HwHiAiUser HwHiAiUser 246, 0 Jun 18 08:53 /dev/davinci0
crw-rw---- 1 HwHiAiUser HwHiAiUser 247, 0 Jun 18 08:53 /dev/davinci_manager
crw------- 1 root       root       243, 0 Jun 18 08:53 /dev/davinci_mdio
Your current CANN version is 7.0.RC1,installation location is /usr/local/Ascend/ascend-toolkit/latest
All folders in the current CANN directory have 
total 120
drwxr-xr-x  5 root root  4096 Jun 17 08:21 .
drwxr-xr-x  4 root root  4096 Jun 17 08:21 ..
dr-xr-xr-x 14 root root  4096 Jun 17 08:21 aarch64-linux
lrwxrwxrwx  1 root root    18 Jun 17 08:07 acllib -> ../7.0.RC1/runtime
lrwxrwxrwx  1 root root    13 Jun 17 08:21 arm64-linux -> aarch64-linux
lrwxrwxrwx  1 root root    14 Jun 17 08:10 atc -> ../7.0.RC1/atc
lrwxrwxrwx  1 root root    17 Jun 17 08:20 bin -> aarch64-linux/bin
lrwxrwxrwx  1 root root    19 Jun 17 08:10 compiler -> ../7.0.RC1/compiler
lrwxrwxrwx  1 root root    18 Jun 17 08:20 conf -> aarch64-linux/conf
lrwxrwxrwx  1 root root    20 Jun 17 08:10 fwkacllib -> ../7.0.RC1/fwkacllib
lrwxrwxrwx  1 root root    21 Jun 17 08:20 include -> aarch64-linux/include
lrwxrwxrwx  1 root root    21 Jun 17 08:21 lib64 -> ./aarch64-linux/lib64
lrwxrwxrwx  1 root root    29 Jun 17 08:20 mindstudio-toolkit -> ../7.0.RC1/mindstudio-toolkit
lrwxrwxrwx  1 root root    14 Jun 17 08:17 opp -> ../7.0.RC1/opp
lrwxrwxrwx  1 root root    14 Jun 17 08:17 ops -> ../7.0.RC1/opp
-rw-rw-r--  1 root root    16 Jun 17 05:17 platform.ini
lrwxrwxrwx  1 root root    16 Jun 17 08:20 pyACL -> ../7.0.RC1/pyACL
drwxr-xr-x  3 root root  4096 Jun 17 08:10 python
-r-xr-x---  1 root root 87837 Jun 17 05:03 remove_latest_softlink.sh
lrwxrwxrwx  1 root root    18 Jun 17 08:07 runtime -> ../7.0.RC1/runtime
lrwxrwxrwx  1 root root    23 Jun 17 08:21 test-ops -> ../7.0.RC1/opp/test-ops
lrwxrwxrwx  1 root root    18 Jun 17 08:20 toolkit -> ../7.0.RC1/toolkit
drwxr-xr-x  2 root root  4096 Jun 17 08:20 tools
-rw-r--r--  1 root root   822 Jun 17 08:21 version.cfg
CANN version:
CANN_root_version:7.0.RC1
CANN_user_version:
CANN_current_version:7.0.RC1
driver_version:22.0.3
soc_version:310
firmware_version:1.83.10.1.248
-----------------------------------------------------------------
Generic settings environment variables:
LD_LIBRARY_PATH:/usr/local/Ascend/ascend-toolkit/latest/lib64:/usr/local/Ascend/ascend-toolkit/latest/lib64/plugin/opskernel:/usr/local/Ascend/ascend-toolkit/latest/lib64/plugin/nnengine:/usr/local/Ascend/ascend-toolkit/latest/opp/built-in/op_impl/ai_core/tbe/op_tiling:/var/davinci/driver/lib64:/var/davinci/driver/lib64/common:/var/davinci/driver/lib64/driver:/usr/local/python3.7.5/lib:/usr/lib64:/usr/local/Ascend/toolbox/latest/Ascend-DMI/lib64:/usr/local/Ascend/nnrt/latest/arm64-linux/acllib/lib64/:/opt/mini/driver:
PATH:/usr/local/Ascend/ascend-toolkit/latest/bin:/usr/local/Ascend/ascend-toolkit/latest/compiler/ccec_compiler/bin:/usr/local/Ascend/toolbox/latest/Ascend-DMI/bin:/usr/local/python3.7.5/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/snap/bin
ASCEND_TOOLKIT_HOME:/usr/local/Ascend/ascend-toolkit/latest
PYTHONPATH:/usr/local/Ascend/ascend-toolkit/latest/python/site-packages:/usr/local/Ascend/ascend-toolkit/latest/opp/built-in/op_impl/ai_core/tbe:
ASCEND_AICPU_PATH:/usr/local/Ascend/ascend-toolkit/latest
ASCEND_OPP_PATH:/usr/local/Ascend/ascend-toolkit/latest/opp
TOOLCHAIN_HOME:/usr/local/Ascend/ascend-toolkit/latest/toolkit
ASCEND_HOME_PATH:/usr/local/Ascend/ascend-toolkit/latest
----------------------------------------------------------------
Samples environment variables:
CPU_ARCH:
THIRDPART_PATH:
INSTALL_DIR:
DDK_PATH:/usr/local/Ascend/ascend-toolkit/latest
NPU_HOST_LIB:/usr/local/Ascend/ascend-toolkit/latest/runtime/lib64/stub
----------------------------------------------------------------
python and pip version
python3:Python 3.7.5
pip3:pip 24.0 from /usr/local/python3.7.5/lib/python3.7/site-packages/pip (python 3.7)
----------------------------------------------------------------
pip dependencis
numpy                    1.21.6
decorator                5.1.1
sympy                    1.10.1
cffi                     1.15.1
protobuf                 4.24.4
attrs                    23.2.0
PyYAML                   6.0.1
pathlib2                 2.3.7.post1
scipy                    1.7.3
requests                 2.31.0
psutil                   5.9.8
absl-py                  2.1.0
----------------------------------------------------------------
System environment and dependencies
System:Linux davinci-mini 5.10.0+ #2 SMP Mon Mar 20 15:02:18 CST 2023 aarch64 aarch64 aarch64 GNU/Linux
gcc:gcc (Ubuntu/Linaro 7.5.0-3ubuntu1~18.04) 7.5.0
g++:g++ (Ubuntu/Linaro 7.5.0-3ubuntu1~18.04) 7.5.0
make:GNU Make 4.1
cmake:cmake version 3.10.2
zlib1g:ii  zlib1g:arm64   1:1.2.11.dfsg-0ubuntu2.2 arm64        compression library - runtime
zlib1g-dev:ii  zlib1g-dev:arm64 1:1.2.11.dfsg-0ubuntu2.2 arm64        compression library - development
libsqlite3-dev:ii  libsqlite3-dev:arm64 3.22.0-1ubuntu0.7 arm64        SQLite 3 development files
openssl:ii  openssl        1.1.1-1ubuntu2.1~18.04.23 arm64        Secure Sockets Layer toolkit - cryptographic utility
libssl-dev:ii  libssl-dev:arm64 1.1.1-1ubuntu2.1~18.04.23 arm64        Secure Sockets Layer toolkit - development files
libffi-dev:ii  libffi-dev:arm64 3.2.1-8      arm64        Foreign Function Interface library (development files)
unzip:ii  unzip          6.0-21ubuntu1.2 arm64        De-archiver for .zip files
pciutils:ii  pciutils       1:3.5.2-1ubuntu1.1 arm64        Linux PCI Utilities
net-tools:ii  net-tools      1.60+git20161116.90da8a0-1ubuntu1 arm64        NET-3 networking toolkit
libblas-dev:ii  libblas-dev:arm64 3.7.1-4ubuntu1 arm64        Basic Linear Algebra Subroutines 3, static library
gfortran:ii  gfortran       4:7.4.0-1ubuntu2.3 arm64        GNU Fortran 95 compiler
libblas3:ii  libblas3:arm64 3.7.1-4ubuntu1 arm64        Basic Linear Algebra Reference implementations, shared library
----------------------------------------------------------------
samples dependencies
opencv:3.2.0
x264:not installed
ffmpeg:4.2.9
aclliteCPP:not installed
Cython                   not installed
av                       not installed
Pillow                   not installed

嗯，但是这个代码下面有个 msgData.videoEnd = true;这个是判断是否结束帧的；我测试时发现这个还是false状态，而且在resize之前还是能输出img.cols不为0，说明不是空帧（我测了下，如果是25帧的视频，就是在第25帧时那个图片就报错，25帧图片是有数据的），下面时inputvideo和执行模型的两个线程，您看下就改了两个地方
```
void* GetInputVideo(void* arg) {
    bool ret = SetCurContext(context);
    CHECK_RET(ret, LOG_PRINT("[ERROR] set cur context for pthread  %ld failed.", pthread_self()); return NULL);
    int32_t deviceId = *(int32_t *)arg;
    string videoPath = "../data/test.mp4";
    VideoRead cap(videoPath, deviceId);
    CHECK_RET(cap.IsOpened(), LOG_PRINT("[ERROR] open %s failed.", videoPath.c_str()); return NULL);

// ImageProc imageProcess;
    ImageData frame;
    ImageSize modelSize(modelWidth, modelHeight);
    int isHost = GetRunMode();
    LOG_PRINT("[INFO] start to decode...");
    while(1) {
        ret = cap.Read(frame);
        if (ret) {

** //这个地方把resize去掉，将原始yuv帧放到队列中了** 
            // ImageData dst;
            // imageProcess.Resize(frame, dst, modelSize, RESIZE_PROPORTIONAL_UPPER_LEFT);
            MsgData msgData;
    
            msgData.framedata = frame;
            msgData.size = frame.size;
            msgData.videoEnd = false;
            cv::Mat yuyvImg(frame.height*1.5, frame.width, CV_8UC1);//RGB在高是YUV的1.5倍
            if (isHost) {
                    void* hostDataBuffer = CopyDataToHost(frame.data.get(), frame.size);
                    memcpy(yuyvImg.data, (unsigned char*)hostDataBuffer, frame.size);
                    FreeHostMem(hostDataBuffer);
                    hostDataBuffer = nullptr;
                } else {
                    memcpy(yuyvImg.data, (unsigned char*)frame.data.get(), frame.size);
                }
            cv::cvtColor(yuyvImg, msgData.srcImg, cv::COLOR_YUV2RGB_NV21);
            while (1) {
                if (msgDataQueue.Push(msgData)) {
                    break;
                }
                usleep(100);
            }
        } else {
            LOG_PRINT("[INFO] frame read end.");
            break;
        }
    }
    cap.Release();
    MsgData msgData;
    msgData.videoEnd = true;
    while (1) {
        if (msgDataQueue.Push(msgData)) {
            break;
        }
        usleep(100);
    }
    LOG_PRINT("[INFO] preprocess add end msgData. tid : %ld", pthread_self());
    return NULL;
}

void* ModelExecute(void* arg) {
    bool ret = SetCurContext(context);
    CHECK_RET(ret, LOG_PRINT("[ERROR] set cur context for pthread  %ld failed.", pthread_self()); return NULL);
    ModelProc modelProcess;
    string modelPath = "../model/yolov5s.om";
    ret = modelProcess.Load(modelPath);
    CHECK_RET(ret, LOG_PRINT("[ERROR] load model %s failed.", modelPath.c_str()); return NULL);
    ImageSize modelSize(modelWidth, modelHeight);

ImageProc imageProcess;
    while(1) {
        if(!msgDataQueue.Empty()) {
            MsgData msgData = msgDataQueue.Pop();
            if (msgData.videoEnd) {
                break;//这个地方是判断是否结束帧的了
            }
            else {

ImageData dst;
                ImageData framed = msgData.framedata;
//这个地方将队列中的原始帧拿出进行resize了，然后就最后一帧报错，我看了最后一帧不是空帧
                imageProcess.Resize(framed, dst, modelSize, RESIZE_PROPORTIONAL_UPPER_LEFT);
                ret = modelProcess.CreateInput(static_cast<void*>(dst.data.get()), dst.size);
                CHECK_RET(ret, LOG_PRINT("[ERROR] Create model input failed."); break);
                MsgOut msgOut;
                msgOut.srcImg = msgData.srcImg;
                msgOut.videoEnd = msgData.videoEnd;
                modelProcess.Execute(msgOut.inferOutputs);
                CHECK_RET(ret, LOG_PRINT("[ERROR] model execute failed."); break);
                while (1) {
                    if (msgOutQueue.Push(msgOut)) {
                        break;
                    }
                    usleep(100);
                }
            }
        }
    }
    modelProcess.DestroyResource();
    MsgOut msgOut;
    msgOut.videoEnd = true;
    while (1) {
        if (msgOutQueue.Push(msgOut)) {
            break;
        }
        usleep(100);
    }
    LOG_PRINT("[INFO] infer msg end. tid : %ld", pthread_self());
    return  NULL;
}
```

这个时main函数里面的完整代码，替换https://gitee.com/ascend/EdgeAndRobotics/tree/master/Samples/YOLOV5USBCamera中src里面的mian.cpp就可以
```
#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
#include <queue>
#include <unordered_map>
#include <cmath>
#include <dirent.h>
#include <string.h>
#include "opencv2/opencv.hpp"
#include "opencv2/imgproc/types_c.h"
#include "opencv2/highgui/highgui.hpp"
#include "acllite_dvpp_lite/ImageProc.h"
#include "acllite_om_execute/ModelProc.h"
#include "acllite_media/CameraRead.h"
#include "acllite_dvpp_lite/VideoRead.h"
#include "acllite_common/Queue.h"
#include "label.h"

using namespace std;
using namespace acllite;
using namespace cv;

aclrtContext context = nullptr;
uint32_t cvWidth = 1920;
uint32_t cvHeight = 1080;
cv::Mat cvImg = cv::Mat(cvHeight, cvWidth, CV_8UC3, cv::Scalar(0, 0, 0));
uint32_t modelWidth = 640;
uint32_t modelHeight = 640;
bool exitFlag = false;
struct MsgData {
    std::shared_ptr<uint8_t> data = nullptr;
    uint32_t size = 0;
    bool videoEnd = false;
    cv::Mat srcImg;
    ImageData framedata;
};

struct MsgOut {
    cv::Mat srcImg;
    bool videoEnd = false;
    vector<InferenceOutput> inferOutputs;
};

Queue<MsgData> msgDataQueue(32);
Queue<MsgOut> msgOutQueue(32);
std::string displayMode = "";
typedef struct BoundBox {
        float x;
        float y;
        float width;
        float height;
        float score;
        size_t classIndex;
        size_t index;
    } BoundBox;

bool Initparam(int argc, char *argv[])
{
    DIR *dir;
    int outputDisplay = 1;
    if ((dir = opendir("./out")) == NULL)
        system("mkdir ./out");
    int paramNum = 2;
    if(argc != paramNum) {
        LOG_PRINT("[ERROR] please choose output display mode: [./main imshow] [./main stdout]");
        return false;
    }
    displayMode = argv[outputDisplay];
    return true;
}

bool sortScore(BoundBox box1, BoundBox box2)
{
    return box1.score > box2.score;
}

void GetResult(std::vector<InferenceOutput>& inferOutputs,
    cv::Mat& srcImage, uint32_t modelWidth, uint32_t modelHeight)
{
    uint32_t outputDataBufId = 0;
    float *classBuff = static_cast<float *>(inferOutputs[outputDataBufId].data.get());
    float confidenceThreshold = 0.25;
    size_t classNum = 80;
    size_t offset = 5;
    size_t totalNumber = classNum + offset;
    size_t modelOutputBoxNum = 25200;
    size_t startIndex = 5;
    int srcWidth = srcImage.cols;
    int srcHeight = srcImage.rows;

vector <BoundBox> boxes;
    size_t yIndex = 1;
    size_t widthIndex = 2;
    size_t heightIndex = 3;
    size_t classConfidenceIndex = 4;
    float widthScale = (float)(srcWidth) / modelWidth;
    float heightScale = (float)(srcHeight) / modelHeight;
    float finalScale = (widthScale > heightScale) ? widthScale : heightScale;
    for (size_t i = 0; i < modelOutputBoxNum; ++i) {
        float maxValue = 0;
        float maxIndex = 0;
        for (size_t j = startIndex; j < totalNumber; ++j) {
            float value = classBuff[i * totalNumber + j] * classBuff[i * totalNumber + classConfidenceIndex];
                if (value > maxValue) {
                maxIndex = j - startIndex;
                maxValue = value;
            }
        }
        float classConfidence = classBuff[i * totalNumber + classConfidenceIndex];
        if (classConfidence >= confidenceThreshold) {
            size_t index = i * totalNumber + maxIndex + startIndex;
            float finalConfidence =  classConfidence * classBuff[index];
            BoundBox box;
            box.x = classBuff[i * totalNumber] * finalScale;
            box.y = classBuff[i * totalNumber + yIndex] * finalScale;
            box.width = classBuff[i * totalNumber + widthIndex] * finalScale;
            box.height = classBuff[i * totalNumber + heightIndex] * finalScale;
            box.score = finalConfidence;
            box.classIndex = maxIndex;
            box.index = i;
            if (maxIndex < classNum) {
                boxes.push_back(box);
            }
        }
           }
    vector <BoundBox> result;
    result.clear();
    float NMSThreshold = 0.45;
    int32_t maxLength = modelWidth > modelHeight ? modelWidth : modelHeight;
    std::sort(boxes.begin(), boxes.end(), sortScore);
    BoundBox boxMax;
    BoundBox boxCompare;
    while (boxes.size() != 0) {
        size_t index = 1;
        result.push_back(boxes[0]);
        while (boxes.size() > index) {
            boxMax.score = boxes[0].score;
            boxMax.classIndex = boxes[0].classIndex;
            boxMax.index = boxes[0].index;
            boxMax.x = boxes[0].x + maxLength * boxes[0].classIndex;
            boxMax.y = boxes[0].y + maxLength * boxes[0].classIndex;
            boxMax.width = boxes[0].width;
            boxMax.height = boxes[0].height;

boxCompare.score = boxes[index].score;
            boxCompare.classIndex = boxes[index].classIndex;
            boxCompare.index = boxes[index].index;
            boxCompare.x = boxes[index].x + boxes[index].classIndex * maxLength;
            boxCompare.y = boxes[index].y + boxes[index].classIndex * maxLength;
            boxCompare.width = boxes[index].width;
            boxCompare.height = boxes[index].height;
            float xLeft = max(boxMax.x, boxCompare.x);
            float yTop = max(boxMax.y, boxCompare.y);
            float xRight = min(boxMax.x + boxMax.width, boxCompare.x + boxCompare.width);
            float yBottom = min(boxMax.y + boxMax.height, boxCompare.y + boxCompare.height);
            float width = max(0.0f, xRight - xLeft);
            float hight = max(0.0f, yBottom - yTop);
            float area = width * hight;
            float iou =  area / (boxMax.width * boxMax.height + boxCompare.width * boxCompare.height - area);
            if (iou > NMSThreshold) {
                boxes.erase(boxes.begin() + index);
                continue;
            }
            ++index;
        }
        boxes.erase(boxes.begin());
    }
    const double fountScale = 0.5;
    const uint32_t lineSolid = 2;
    const uint32_t labelOffset = 11;
    const cv::Scalar fountColor(0, 0, 255);
    const vector <cv::Scalar> colors{
        cv::Scalar(237, 149, 100), cv::Scalar(0, 215, 255),
        cv::Scalar(50, 205, 50), cv::Scalar(139, 85, 26)};

int half = 2;
    string textPrint = "[";
    for (size_t i = 0; i < result.size(); ++i) {
        if (result[i].score < 0.7) {
            continue;
        }
        cv::Point leftUpPoint, rightBottomPoint;
        leftUpPoint.x = result[i].x - result[i].width / half;
        leftUpPoint.y = result[i].y - result[i].height / half;
        rightBottomPoint.x = result[i].x + result[i].width / half;
        rightBottomPoint.y = result[i].y + result[i].height / half;
        cv::rectangle(srcImage, leftUpPoint, rightBottomPoint, colors[i % colors.size()], lineSolid);
        string className = label[result[i].classIndex];
        string markString = to_string(result[i].score) + ":" + className;
        textPrint += markString;
        cv::putText(srcImage, markString, cv::Point(leftUpPoint.x, leftUpPoint.y + labelOffset),
                    cv::FONT_HERSHEY_COMPLEX, fountScale, fountColor);
    }
    textPrint += "]";
    if (displayMode == "imshow") {
        cv::imshow("usb-show-demo", srcImage);
        cv::waitKey(1);
    } else if (displayMode == "stdout") {
        cout<<"Detect Result: "<< textPrint <<endl;
    } else {
        LOG_PRINT("[ERROR] output display mode not supported.");
    }
    return;
}

void* GetInputVideo(void* arg) {
    bool ret = SetCurContext(context);
    CHECK_RET(ret, LOG_PRINT("[ERROR] set cur context for pthread  %ld failed.", pthread_self()); return NULL);
    int32_t deviceId = *(int32_t *)arg;    
    string videoPath = "../data/test.mp4";
    VideoRead cap(videoPath, deviceId);
    CHECK_RET(cap.IsOpened(), LOG_PRINT("[ERROR] open %s failed.", videoPath.c_str()); return NULL);

// ImageProc imageProcess;
    ImageData frame;
    ImageSize modelSize(modelWidth, modelHeight);
    int isHost = GetRunMode();
    LOG_PRINT("[INFO] start to decode...");
    while(1) {
        ret = cap.Read(frame);
        if (ret) {
            // ImageData dst;
            // imageProcess.Resize(frame, dst, modelSize, RESIZE_PROPORTIONAL_UPPER_LEFT);
            MsgData msgData;
            msgData.framedata = frame;
            msgData.size = frame.size;
            msgData.videoEnd = false;
            cv::Mat yuyvImg(frame.height*1.5, frame.width, CV_8UC1);//RGB在高是YUV的1.5倍
            if (isHost) {
                    void* hostDataBuffer = CopyDataToHost(frame.data.get(), frame.size);
                    memcpy(yuyvImg.data, (unsigned char*)hostDataBuffer, frame.size);
                    FreeHostMem(hostDataBuffer);
                    hostDataBuffer = nullptr;
                } else {
                    memcpy(yuyvImg.data, (unsigned char*)frame.data.get(), frame.size);
                }
            cv::cvtColor(yuyvImg, msgData.srcImg, cv::COLOR_YUV2RGB_NV21);
            while (1) {
                if (msgDataQueue.Push(msgData)) {
                    break;
                }
                usleep(100);
            }
        } else {
            LOG_PRINT("[INFO] frame read end.");
            break;
        }
    }
    cap.Release();
    MsgData msgData;
    msgData.videoEnd = true;
    while (1) {
        if (msgDataQueue.Push(msgData)) {
            break;
        }
        usleep(100);
    }
    LOG_PRINT("[INFO] preprocess add end msgData. tid : %ld", pthread_self());
    return NULL;
}

void* GetInput(void* arg) {
    bool ret = SetCurContext(context);
    CHECK_RET(ret, LOG_PRINT("[ERROR] set cur context for pthread  %ld failed.", pthread_self()); return NULL);
    int32_t deviceId = *(int32_t *)arg;
    string devPath = "/dev/video0";
    CameraRead cap(devPath, deviceId);
    CHECK_RET(cap.IsOpened(), LOG_PRINT("[ERROR] open %s failed.", devPath.c_str()); return NULL);
    ImageProc imageProcess;
    ImageData frame;
    ImageSize modelSize(modelWidth, modelHeight);
    LOG_PRINT("[INFO] start to decode...");
    while(1) {
        ret = cap.Read(frame);
        if (ret) {
            ImageData dst;
            imageProcess.Resize(frame, dst, modelSize, RESIZE_PROPORTIONAL_UPPER_LEFT);
            MsgData msgData;
            msgData.data = dst.data;
            msgData.size = dst.size;
            msgData.videoEnd = false;
            cv::Mat yuyvImg(frame.height, frame.width, CV_8UC2);
            memcpy(yuyvImg.data, (unsigned char*)frame.data.get(), frame.size);
            cv::cvtColor(yuyvImg, msgData.srcImg, cv::COLOR_YUV2BGR_YUYV);
            while (1) {
                if (msgDataQueue.Push(msgData)) {
                    break;
                }
                usleep(100);
            }

} else {
            LOG_PRINT("[INFO] frame read end.");
            break;
        }
	break;
    }
    cap.Release();
    MsgData msgData;
    msgData.videoEnd = true;
    while (1) {
        if (msgDataQueue.Push(msgData)) {
            break;
        }
        usleep(100);
    }
    LOG_PRINT("[INFO] preprocess add end msgData. tid : %ld", pthread_self());
    return NULL;
}
 
void* ModelExecute(void* arg) {
    bool ret = SetCurContext(context);
    CHECK_RET(ret, LOG_PRINT("[ERROR] set cur context for pthread  %ld failed.", pthread_self()); return NULL);
    ModelProc modelProcess;
    string modelPath = "../model/yolov5s.om";
    ret = modelProcess.Load(modelPath);
    CHECK_RET(ret, LOG_PRINT("[ERROR] load model %s failed.", modelPath.c_str()); return NULL);
    ImageSize modelSize(modelWidth, modelHeight);

ImageProc imageProcess;
    while(1) {
        if(!msgDataQueue.Empty()) {
            MsgData msgData = msgDataQueue.Pop();
            if (msgData.videoEnd) {
                break;
            }
            else {
                
                ImageData dst;
		ImageData framed = msgData.framedata;
                imageProcess.Resize(framed, dst, modelSize, RESIZE_PROPORTIONAL_UPPER_LEFT);
                ret = modelProcess.CreateInput(static_cast<void*>(dst.data.get()), dst.size);
                CHECK_RET(ret, LOG_PRINT("[ERROR] Create model input failed."); break);
                MsgOut msgOut;
                msgOut.srcImg = msgData.srcImg;
                msgOut.videoEnd = msgData.videoEnd;
                modelProcess.Execute(msgOut.inferOutputs);
                CHECK_RET(ret, LOG_PRINT("[ERROR] model execute failed."); break);
                while (1) {
                    if (msgOutQueue.Push(msgOut)) {
                        break;
                    }
                    usleep(100);
                }
            }
        }
    }
    modelProcess.DestroyResource();
    MsgOut msgOut;
    msgOut.videoEnd = true;
    while (1) {
        if (msgOutQueue.Push(msgOut)) {
            break;
        }
        usleep(100);
    }
    LOG_PRINT("[INFO] infer msg end. tid : %ld", pthread_self());
    return  NULL;
}

void* PostProcess(void* arg) {
    while(1) {
        if(!msgOutQueue.Empty()) {
            MsgOut msgOut = msgOutQueue.Pop();
            usleep(100);
            if (msgOut.videoEnd) {
                break;
            }
            GetResult(msgOut.inferOutputs, msgOut.srcImg, modelWidth, modelHeight);
        }
    }
    LOG_PRINT("[INFO] *************** all get done ***************");
    exitFlag = true;
    return  NULL;
}

int main(int argc, char *argv[]) {
    int32_t deviceId = 0;
    AclLiteResource aclResource(deviceId);
    bool ret = aclResource.Init();
    CHECK_RET(ret, LOG_PRINT("[ERROR] InitACLResource failed."); return 1);
    context = aclResource.GetContext();
    ret = Initparam(argc, argv);
    CHECK_RET(ret, LOG_PRINT("[ERROR] Initparam failed."); return 1);
 
    pthread_t preTids, exeTids, posTids;
    // run usb camera:
    //pthread_create(&preTids, NULL, GetInput, (void*)&deviceId);
    // run mp4 video:
    pthread_create(&preTids, NULL, GetInputVideo, (void*)&deviceId);

pthread_create(&exeTids, NULL, ModelExecute, NULL);
    pthread_create(&posTids, NULL, PostProcess, NULL);

pthread_detach(preTids);
    pthread_detach(exeTids);
    pthread_detach(posTids);
 
    while(!exitFlag) {
        sleep(10);
    }
    aclResource.Release();
    return 0;
}

```