海思hi3798mv300和310的区别_海思3516

大家好，又见面了，我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE使用 1年只要46元 售后保障 童叟无欺

在网上搜寻海思HI3519或者hi3516实时识别除了官方给的SDK 中有Rfcn的实时识别例子之外，其它都是读图片例子。官方例子中给了如下网络参考：Rfcn、Segnet、FasterRcnn、Cnn、Ssd、Yolov1、Yolov2、Yolov3、Lstm、Pvanet

在SDK中文件夹路径为/rp-hi3516dv300-busybox/smp/a7_linux/mpp/sample/svp/nnie其中有一个sample_nnie_main.c文件，官方例子如下：

/******************************************************************************
* function : show usage
******************************************************************************/
void SAMPLE_SVP_Usage(char* pchPrgName)
{
    printf("Usage : %s <index> \n", pchPrgName);
    printf("index:\n");
    printf("\t 0) RFCN(VI->VPSS->NNIE->VGS->VO).\n");
    printf("\t 1) Segnet(Read File).\n");
    printf("\t 2) FasterRcnnAlexnet(Read File).\n");
    printf("\t 3) FasterRcnnDoubleRoiPooling(Read File).\n");
    printf("\t 4) Cnn(Read File).\n");
    printf("\t 5) SSD(Read File).\n");
    printf("\t 6) Yolov1(Read File).\n");
    printf("\t 7) Yolov2(Read File).\n");
    printf("\t 8) Yolov3(Read File).\n");
    printf("\t 9) LSTM(Read File).\n");
    printf("\t a) Pvanet(Read File).\n");
    printf("\t b) Rfcn(Read File).\n");
}

如果尝试跑过SVP例程的朋友知道

# 运行Rfcn 实时监测，即 RFCN(VI->VPSS->NNIE->VGS->VO)
./sample_nnie_main 0  

在/rp-hi3516dv300-busybox/smp/a7_linux/mpp/sample/svp/nnie/sample中的sample_nnie.c文件

代码相关分析

Rfcn相关函数如下：

/******************************************************************************
* function : Rfcn software deinit
******************************************************************************/
static HI_S32 SAMPLE_SVP_NNIE_Rfcn_SoftwareDeinit(SAMPLE_SVP_NNIE_RFCN_SOFTWARE_PARAM_S* pstSoftWareParam)

/******************************************************************************
* function : Rfcn Deinit
******************************************************************************/
static HI_S32 SAMPLE_SVP_NNIE_Rfcn_Deinit(SAMPLE_SVP_NNIE_PARAM_S *pstNnieParam,
    SAMPLE_SVP_NNIE_RFCN_SOFTWARE_PARAM_S* pstSoftWareParam,SAMPLE_SVP_NNIE_MODEL_S *pstNnieModel)

/******************************************************************************
* function : Rfcn software para init
******************************************************************************/
static HI_S32 SAMPLE_SVP_NNIE_Rfcn_SoftwareInit(SAMPLE_SVP_NNIE_CFG_S* pstCfg,
    SAMPLE_SVP_NNIE_PARAM_S *pstNnieParam, SAMPLE_SVP_NNIE_RFCN_SOFTWARE_PARAM_S* pstSoftWareParam)

/******************************************************************************
* function : Rfcn init
******************************************************************************/
static HI_S32 SAMPLE_SVP_NNIE_Rfcn_ParamInit(SAMPLE_SVP_NNIE_CFG_S* pstCfg,
    SAMPLE_SVP_NNIE_PARAM_S *pstNnieParam, SAMPLE_SVP_NNIE_RFCN_SOFTWARE_PARAM_S* pstSoftWareParam)

/******************************************************************************
* function : roi to rect
******************************************************************************/
HI_S32 SAMPLE_SVP_NNIE_RoiToRect(SVP_BLOB_S *pstDstScore,
    SVP_BLOB_S *pstDstRoi, SVP_BLOB_S *pstClassRoiNum, HI_FLOAT *paf32ScoreThr,
    HI_BOOL bRmBg,SAMPLE_SVP_NNIE_RECT_ARRAY_S *pstRect,
    HI_U32 u32SrcWidth, HI_U32 u32SrcHeight,HI_U32 u32DstWidth,HI_U32 u32DstHeight)

/******************************************************************************
* function : Rfcn Proc
******************************************************************************/
static HI_S32 SAMPLE_SVP_NNIE_Rfcn_Proc(SAMPLE_SVP_NNIE_PARAM_S *pstParam,
    SAMPLE_SVP_NNIE_RFCN_SOFTWARE_PARAM_S *pstSwParam)

/******************************************************************************
* function : Rfcn Proc
******************************************************************************/
static HI_S32 SAMPLE_SVP_NNIE_Rfcn_Proc_ViToVo(SAMPLE_SVP_NNIE_PARAM_S *pstParam,
    SAMPLE_SVP_NNIE_RFCN_SOFTWARE_PARAM_S *pstSwParam, VIDEO_FRAME_INFO_S* pstExtFrmInfo,
    HI_U32 u32BaseWidth,HI_U32 u32BaseHeight)

/******************************************************************************
* function : Rfcn vi to vo thread entry
******************************************************************************/
static HI_VOID* SAMPLE_SVP_NNIE_Rfcn_ViToVo(HI_VOID* pArgs)

/******************************************************************************
* function : Rfcn Vi->VO
******************************************************************************/
void SAMPLE_SVP_NNIE_Rfcn(void)

/******************************************************************************
* function : rfcn sample signal handle
******************************************************************************/
void SAMPLE_SVP_NNIE_Rfcn_HandleSig(void)

/******************************************************************************
* function : rfcn sample signal handle
******************************************************************************/
void SAMPLE_SVP_NNIE_Rfcn_HandleSig_File(void)

/******************************************************************************
* function : Rfcn Read file        
******************************************************************************/
void SAMPLE_SVP_NNIE_Rfcn_File(void)

YOLOv3 相关函数代码如下：

/******************************************************************************
* function : Yolov3 software deinit
******************************************************************************/
static HI_S32 SAMPLE_SVP_NNIE_Yolov3_SoftwareDeinit(SAMPLE_SVP_NNIE_YOLOV3_SOFTWARE_PARAM_S* pstSoftWareParam)

/******************************************************************************
* function : Yolov3 Deinit
******************************************************************************/
static HI_S32 SAMPLE_SVP_NNIE_Yolov3_Deinit(SAMPLE_SVP_NNIE_PARAM_S *pstNnieParam,
    SAMPLE_SVP_NNIE_YOLOV3_SOFTWARE_PARAM_S* pstSoftWareParam,SAMPLE_SVP_NNIE_MODEL_S *pstNnieModel)

/******************************************************************************
* function : Yolov3 software para init
******************************************************************************/
static HI_S32 SAMPLE_SVP_NNIE_Yolov3_SoftwareInit(SAMPLE_SVP_NNIE_CFG_S* pstCfg,
    SAMPLE_SVP_NNIE_PARAM_S *pstNnieParam, SAMPLE_SVP_NNIE_YOLOV3_SOFTWARE_PARAM_S* pstSoftWareParam)

/******************************************************************************
* function : Yolov3 init
******************************************************************************/
static HI_S32 SAMPLE_SVP_NNIE_Yolov3_ParamInit(SAMPLE_SVP_NNIE_CFG_S* pstCfg,
    SAMPLE_SVP_NNIE_PARAM_S *pstNnieParam, SAMPLE_SVP_NNIE_YOLOV3_SOFTWARE_PARAM_S* pstSoftWareParam)

/******************************************************************************
* function : show YOLOV3 sample(image 416x416 U8_C3)
******************************************************************************/
void SAMPLE_SVP_NNIE_Yolov3(void)

/******************************************************************************
* function : Yolov3 sample signal handle
******************************************************************************/
void SAMPLE_SVP_NNIE_Yolov3_HandleSig(void)

通过Rfcn 和 YOLOv3对比发现，Rfcn的如下函数完成了视频的读取与处理

/******************************************************************************
* function : roi to rect   该函数实现了对监测目标对象的框计算
******************************************************************************/
HI_S32 SAMPLE_SVP_NNIE_RoiToRect(SVP_BLOB_S *pstDstScore,
    SVP_BLOB_S *pstDstRoi, SVP_BLOB_S *pstClassRoiNum, HI_FLOAT *paf32ScoreThr,
    HI_BOOL bRmBg,SAMPLE_SVP_NNIE_RECT_ARRAY_S *pstRect,
    HI_U32 u32SrcWidth, HI_U32 u32SrcHeight,HI_U32 u32DstWidth,HI_U32 u32DstHeight)

/******************************************************************************
* function : Rfcn Proc     该函数实现了物体识别这个功能
******************************************************************************/
static HI_S32 SAMPLE_SVP_NNIE_Rfcn_Proc(SAMPLE_SVP_NNIE_PARAM_S *pstParam,
    SAMPLE_SVP_NNIE_RFCN_SOFTWARE_PARAM_S *pstSwParam)

/******************************************************************************
* function : Rfcn Proc    该函数整讲以上两个函数进行整合，实现的识别流程
******************************************************************************/
static HI_S32 SAMPLE_SVP_NNIE_Rfcn_Proc_ViToVo(SAMPLE_SVP_NNIE_PARAM_S *pstParam,
    SAMPLE_SVP_NNIE_RFCN_SOFTWARE_PARAM_S *pstSwParam, VIDEO_FRAME_INFO_S* pstExtFrmInfo,
    HI_U32 u32BaseWidth,HI_U32 u32BaseHeight)

/******************************************************************************
* function : Rfcn vi to vo thread entry 该函数调用上面的SAMPLE_SVP_NNIE_Rfcn_Proc_ViToVo函数然后用SAMPLE_COMM_SVP_NNIE_FillRect函数画线，实现了对目标的标记
******************************************************************************/
static HI_VOID* SAMPLE_SVP_NNIE_Rfcn_ViToVo(HI_VOID* pArgs)

/******************************************************************************
* function : Rfcn Vi->VO          该函数为主函数实现了模型的初始化、从图像输入，然后识别，最后输出结果的过程  
******************************************************************************/
void SAMPLE_SVP_NNIE_Rfcn(void)

接下来就是如何改代码

第一步 在sample_nnie_mian.c尾端添加如下代码：

/******************************************************************************
* function : roi to rect
******************************************************************************/
HI_S32 SAMPLE_SVP_NNIE_RoiToRect_Yolov3(SVP_BLOB_S *pstDstScore,
SVP_BLOB_S *pstDstRoi, SVP_BLOB_S *pstClassRoiNum, HI_FLOAT *paf32ScoreThr,
HI_BOOL bRmBg,SAMPLE_SVP_NNIE_RECT_ARRAY_S *pstRect,
HI_U32 u32SrcWidth, HI_U32 u32SrcHeight,HI_U32 u32DstWidth,HI_U32 u32DstHeight)
{
HI_U32 i = 0, j = 0;
HI_U32 u32RoiNumBias = 0;
HI_U32 u32ScoreBias = 0;
HI_U32 u32BboxBias = 0;
HI_FLOAT f32Score = 0.0f;
HI_S32* ps32Score = SAMPLE_SVP_NNIE_CONVERT_64BIT_ADDR(HI_S32,pstDstScore->u64VirAddr);
HI_S32* ps32Roi = SAMPLE_SVP_NNIE_CONVERT_64BIT_ADDR(HI_S32,pstDstRoi->u64VirAddr);
HI_S32* ps32ClassRoiNum = SAMPLE_SVP_NNIE_CONVERT_64BIT_ADDR(HI_S32,pstClassRoiNum->u64VirAddr);
HI_U32 u32ClassNum = pstClassRoiNum->unShape.stWhc.u32Width;
HI_U32 u32RoiNumTmp = 0;
SAMPLE_SVP_CHECK_EXPR_RET(u32ClassNum > 82 ,HI_ERR_SVP_NNIE_ILLEGAL_PARAM,SAMPLE_SVP_ERR_LEVEL_ERROR,
"Error(%#x),u32ClassNum(%u) must be less than or equal %u to!\n",HI_ERR_SVP_NNIE_ILLEGAL_PARAM,u32ClassNum, 82);
pstRect->u32TotalNum = 0;
pstRect->u32ClsNum = u32ClassNum;
if (bRmBg)
{
pstRect->au32RoiNum[0] = 0;
u32RoiNumBias += ps32ClassRoiNum[0];
for (i = 1; i < u32ClassNum; i++)
{
u32ScoreBias = u32RoiNumBias;
u32BboxBias = u32RoiNumBias * SAMPLE_SVP_NNIE_COORDI_NUM;
u32RoiNumTmp = 0;
/*if the confidence score greater than result thresh, the result will be drawed*/
if(((HI_FLOAT)ps32Score[u32ScoreBias] / SAMPLE_SVP_NNIE_QUANT_BASE >=
paf32ScoreThr[i])  &&  (ps32ClassRoiNum[i] != 0))
{ 
for (j = 0; j < (HI_U32)ps32ClassRoiNum[i]; j++)
{
/*Score is descend order*/
f32Score = (HI_FLOAT)ps32Score[u32ScoreBias + j] / SAMPLE_SVP_NNIE_QUANT_BASE;
if ((f32Score < paf32ScoreThr[i]) || (u32RoiNumTmp >= SAMPLE_SVP_NNIE_MAX_ROI_NUM_OF_CLASS))
{
break;
}
pstRect->astRect[i][u32RoiNumTmp].astPoint[0].s32X = (HI_U32)((HI_FLOAT)ps32Roi[u32BboxBias + j*SAMPLE_SVP_NNIE_COORDI_NUM] / (HI_FLOAT)u32SrcWidth * (HI_FLOAT)u32DstWidth) & (~1) ;
pstRect->astRect[i][u32RoiNumTmp].astPoint[0].s32Y = (HI_U32)((HI_FLOAT)ps32Roi[u32BboxBias + j*SAMPLE_SVP_NNIE_COORDI_NUM + 1] / (HI_FLOAT)u32SrcHeight * (HI_FLOAT)u32DstHeight) & (~1);
pstRect->astRect[i][u32RoiNumTmp].astPoint[1].s32X = (HI_U32)((HI_FLOAT)ps32Roi[u32BboxBias + j*SAMPLE_SVP_NNIE_COORDI_NUM + 2]/ (HI_FLOAT)u32SrcWidth * (HI_FLOAT)u32DstWidth) & (~1);
pstRect->astRect[i][u32RoiNumTmp].astPoint[1].s32Y = pstRect->astRect[i][u32RoiNumTmp].astPoint[0].s32Y;
pstRect->astRect[i][u32RoiNumTmp].astPoint[2].s32X = pstRect->astRect[i][u32RoiNumTmp].astPoint[1].s32X;
pstRect->astRect[i][u32RoiNumTmp].astPoint[2].s32Y = (HI_U32)((HI_FLOAT)ps32Roi[u32BboxBias + j*SAMPLE_SVP_NNIE_COORDI_NUM + 3] / (HI_FLOAT)u32SrcHeight * (HI_FLOAT)u32DstHeight) & (~1);
pstRect->astRect[i][u32RoiNumTmp].astPoint[3].s32X =  pstRect->astRect[i][u32RoiNumTmp].astPoint[0].s32X;
pstRect->astRect[i][u32RoiNumTmp].astPoint[3].s32Y =  pstRect->astRect[i][u32RoiNumTmp].astPoint[2].s32Y;
u32RoiNumTmp++;
}
}
pstRect->au32RoiNum[i] = u32RoiNumTmp;
pstRect->u32TotalNum += u32RoiNumTmp;
u32RoiNumBias += ps32ClassRoiNum[i];
}
}
return HI_SUCCESS;
}
/******************************************************************************
* function : Yolov3 Procession ViToVo
******************************************************************************/
static HI_S32 SAMPLE_SVP_NNIE_Yolov3_Proc_ViToVo(SAMPLE_SVP_NNIE_PARAM_S *pstParam,
SAMPLE_SVP_NNIE_YOLOV3_SOFTWARE_PARAM_S *pstSwParam, VIDEO_FRAME_INFO_S* pstExtFrmInfo,
HI_U32 u32BaseWidth,HI_U32 u32BaseHeight)
{
HI_S32 s32Ret = HI_FAILURE;
SAMPLE_SVP_NNIE_INPUT_DATA_INDEX_S stInputDataIdx = {0};
SAMPLE_SVP_NNIE_PROCESS_SEG_INDEX_S stProcSegIdx = {0};
stInputDataIdx.u32SegIdx = 0;
stInputDataIdx.u32NodeIdx = 0;
HI_FLOAT f32PrintResultThresh = 0.8f;
/*SP420*/
pstParam->astSegData[stInputDataIdx.u32SegIdx].astSrc[stInputDataIdx.u32NodeIdx].u64VirAddr = pstExtFrmInfo->stVFrame.u64VirAddr[0];
pstParam->astSegData[stInputDataIdx.u32SegIdx].astSrc[stInputDataIdx.u32NodeIdx].u64PhyAddr = pstExtFrmInfo->stVFrame.u64PhyAddr[0];
pstParam->astSegData[stInputDataIdx.u32SegIdx].astSrc[stInputDataIdx.u32NodeIdx].u32Stride  = pstExtFrmInfo->stVFrame.u32Stride[0];
// 与Rfcn不同YOLOv3是调用 SAMPLE_SVP_NNIE_Forward 进行解析
s32Ret = SAMPLE_SVP_NNIE_Forward(&s_stYolov3NnieParam,&stInputDataIdx,&stProcSegIdx,HI_TRUE);
SAMPLE_SVP_CHECK_EXPR_RET(HI_SUCCESS != s32Ret,s32Ret,SAMPLE_SVP_ERR_LEVEL_ERROR,
"Error,SAMPLE_SVP_NNIE_Yolov3_Proc failed!\n");
/*draw result, this sample has 21 classes:
class 0:background     class 1:plane           class 2:bicycle
class 3:bird           class 4:boat            class 5:bottle
class 6:bus            class 7:car             class 8:cat
class 9:chair          class10:cow             class11:diningtable
class 12:dog           class13:horse           class14:motorbike
class 15:person        class16:pottedplant     class17:sheep
class 18:sofa          class19:train           class20:tvmonitor*/
/*Software process*/
/*if user has changed net struct, please make sure SAMPLE_SVP_NNIE_Yolov3_GetResult
function input datas are correct*/
s32Ret = SAMPLE_SVP_NNIE_Yolov3_GetResult(&s_stYolov3NnieParam,&s_stYolov3SoftwareParam);
//  (void)SAMPLE_SVP_NNIE_Detection_PrintResult(&(pstSwParam->stDstScore), &(pstSwParam->stDstRoi), &(pstSwParam->stClassRoiNum),f32PrintResultThresh);
//  SAMPLE_SVP_TRACE_INFO("Yolov3 result:\n");
//    (void)SAMPLE_SVP_NNIE_Detection_PrintResult(&s_stYolov3SoftwareParam.stDstScore,
//       &s_stYolov3SoftwareParam.stDstRoi, &s_stYolov3SoftwareParam.stClassRoiNum,f32PrintResultThresh);
s32Ret = SAMPLE_SVP_NNIE_RoiToRect_Yolov3(&(pstSwParam->stDstScore),
&(pstSwParam->stDstRoi), &(pstSwParam->stClassRoiNum), pstSwParam->af32ScoreThr,HI_TRUE,&(pstSwParam->stRect),
pstExtFrmInfo->stVFrame.u32Width, pstExtFrmInfo->stVFrame.u32Height,u32BaseWidth,u32BaseHeight);
SAMPLE_SVP_CHECK_EXPR_RET(HI_SUCCESS != s32Ret,s32Ret,SAMPLE_SVP_ERR_LEVEL_ERROR,
"Error(%#x),SAMPLE_SVP_NNIE_RoiToRect failed!\n",s32Ret); 
return s32Ret;
}
/******************************************************************************
* function : Yolov3 vi to vo thread entry
******************************************************************************/
static HI_VOID* SAMPLE_SVP_NNIE_Yolov3_ViToVo_thread(HI_VOID* pArgs)
{
HI_S32 s32Ret;
SAMPLE_SVP_NNIE_PARAM_S *pstParam;
SAMPLE_SVP_NNIE_YOLOV3_SOFTWARE_PARAM_S *pstSwParam;
VIDEO_FRAME_INFO_S stBaseFrmInfo;
VIDEO_FRAME_INFO_S stExtFrmInfo;
HI_S32 s32MilliSec = 20000;
VO_LAYER voLayer = 0;
VO_CHN voChn = 0;
HI_S32 s32VpssGrp = 0;
HI_S32 as32VpssChn[] = {VPSS_CHN0, VPSS_CHN1};
pstParam = &s_stYolov3NnieParam;
pstSwParam = &s_stYolov3SoftwareParam;
while (HI_FALSE == s_bNnieStopSignal)
{
s32Ret = HI_MPI_VPSS_GetChnFrame(s32VpssGrp, as32VpssChn[1], &stExtFrmInfo, s32MilliSec);
if(HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Error(%#x),HI_MPI_VPSS_GetChnFrame failed, VPSS_GRP(%d), VPSS_CHN(%d)!\n",
s32Ret,s32VpssGrp, as32VpssChn[1]);
continue;
}
s32Ret = HI_MPI_VPSS_GetChnFrame(s32VpssGrp, as32VpssChn[0], &stBaseFrmInfo, s32MilliSec);
SAMPLE_CHECK_EXPR_GOTO(HI_SUCCESS!=s32Ret, EXT_RELEASE,
"Error(%#x),HI_MPI_VPSS_GetChnFrame failed, VPSS_GRP(%d), VPSS_CHN(%d)!\n",
s32Ret,s32VpssGrp, as32VpssChn[0]);
// 存在疑问 stBaseFrmInfo.stVFrame.u32Height
s32Ret = SAMPLE_SVP_NNIE_Yolov3_Proc_ViToVo(pstParam,pstSwParam, &stExtFrmInfo,
stBaseFrmInfo.stVFrame.u32Width,stBaseFrmInfo.stVFrame.u32Height);
SAMPLE_CHECK_EXPR_GOTO(HI_SUCCESS!=s32Ret, BASE_RELEASE,
"Error(%#x),SAMPLE_SVP_NNIE_YOLOV3_Proc failed!\n", s32Ret);
// SAMPLE_SVP_TRACE_INFO("The Width is %d\n", stExtFrmInfo.stVFrame.u32Width);
// SAMPLE_SVP_TRACE_INFO("The Height is %d\n", stExtFrmInfo.stVFrame.u32Height);
//Draw rect
s32Ret = SAMPLE_COMM_SVP_NNIE_FillRect(&stBaseFrmInfo, &(pstSwParam->stRect), 0x0000FF00);
SAMPLE_CHECK_EXPR_GOTO(HI_SUCCESS!=s32Ret, BASE_RELEASE,
"SAMPLE_COMM_SVP_NNIE_FillRect failed, Error(%#x)!\n", s32Ret);
s32Ret = HI_MPI_VO_SendFrame(voLayer, voChn, &stBaseFrmInfo, s32MilliSec);
SAMPLE_CHECK_EXPR_GOTO(HI_SUCCESS!=s32Ret, BASE_RELEASE,
"HI_MPI_VO_SendFrame failed, Error(%#x)!\n", s32Ret);
BASE_RELEASE:
s32Ret = HI_MPI_VPSS_ReleaseChnFrame(s32VpssGrp,as32VpssChn[0], &stBaseFrmInfo);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Error(%#x),HI_MPI_VPSS_ReleaseChnFrame failed,Grp(%d) chn(%d)!\n",
s32Ret,s32VpssGrp,as32VpssChn[0]);
}
EXT_RELEASE:
s32Ret = HI_MPI_VPSS_ReleaseChnFrame(s32VpssGrp,as32VpssChn[1], &stExtFrmInfo);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("Error(%#x),HI_MPI_VPSS_ReleaseChnFrame failed,Grp(%d) chn(%d)!\n",
s32Ret,s32VpssGrp,as32VpssChn[1]);
}
}
return HI_NULL;
}
/******************************************************************************
* function : Yolov3 vi to vo real time detection
******************************************************************************/
void SAMPLE_SVP_NNIE_Yolov3_Vivo(void)
{
//   HI_CHAR *pcSrcFile = "./data/nnie_image/rgb_planar/dog_bike_car_416x416.bgr";
HI_CHAR *pcModelName = "./data/nnie_model/detection/inst_yolov3_cycle.wk";
SAMPLE_SVP_NNIE_CFG_S   stNnieCfg = {0};
SIZE_S stSize;
PIC_SIZE_E enSize = PIC_CIF;
HI_S32 s32Ret = HI_SUCCESS;
HI_CHAR acThreadName[16] = {0};
/*Sys init*/
SAMPLE_COMM_SVP_CheckSysInit();
/******************************************
step 1: start vi vpss vo
******************************************/
s_stYolov3Switch.bVenc = HI_FALSE;
s_stYolov3Switch.bVo   = HI_TRUE;
s32Ret = SAMPLE_COMM_IVE_StartViVpssVencVo_Yolov3(&s_stViConfig,&s_stYolov3Switch,&enSize);
SAMPLE_CHECK_EXPR_GOTO(HI_SUCCESS != s32Ret, YOLOV3_FAIL_1,
"Error(%#x),SAMPLE_COMM_IVE_StartViVpssVencVo failed!\n", s32Ret);
s32Ret = SAMPLE_COMM_SYS_GetPicSize(enSize, &stSize);
SAMPLE_CHECK_EXPR_GOTO(HI_SUCCESS != s32Ret, YOLOV3_FAIL_1,
"Error(%#x),SAMPLE_COMM_SYS_GetPicSize failed!\n", s32Ret);
stSize.u32Width = 416;
stSize.u32Height = 416;
/******************************************
step 2: init NNIE param
******************************************/
stNnieCfg.pszPic= NULL;
stNnieCfg.u32MaxInputNum = 1;
stNnieCfg.u32MaxRoiNum = 0;
stNnieCfg.aenNnieCoreId[0] = SVP_NNIE_ID_0;//set NNIE core
/*Yolov3 Load model*/
SAMPLE_SVP_TRACE_INFO("Yolov3 Load model!\n");
s32Ret = SAMPLE_COMM_SVP_NNIE_LoadModel(pcModelName,&s_stYolov3Model);
SAMPLE_SVP_CHECK_EXPR_GOTO(HI_SUCCESS != s32Ret,YOLOV3_FAIL_0,SAMPLE_SVP_ERR_LEVEL_ERROR,
"Error,SAMPLE_COMM_SVP_NNIE_LoadModel failed!\n");
/*Yolov3 parameter initialization*/
/*Yolov3 software parameters are set in SAMPLE_SVP_NNIE_Yolov3_SoftwareInit,
if user has changed net struct, please make sure the parameter settings in
SAMPLE_SVP_NNIE_Yolov3_SoftwareInit function are correct*/
SAMPLE_SVP_TRACE_INFO("Yolov3 parameter initialization!\n");
s_stYolov3NnieParam.pstModel = &s_stYolov3Model.stModel;
s32Ret = SAMPLE_SVP_NNIE_Yolov3_ParamInit(&stNnieCfg,&s_stYolov3NnieParam,&s_stYolov3SoftwareParam);
SAMPLE_SVP_CHECK_EXPR_GOTO(HI_SUCCESS != s32Ret,YOLOV3_FAIL_0,SAMPLE_SVP_ERR_LEVEL_ERROR,
"Error,SAMPLE_SVP_NNIE_Yolov3_ParamInit failed!\n");
/*Fill src data*/
SAMPLE_SVP_TRACE_INFO("Yolov3 start!\n");
s_bNnieStopSignal = HI_FALSE;
/******************************************
step 3: Create work thread
******************************************/
snprintf(acThreadName, 16, "NNIE_ViToVo");
prctl(PR_SET_NAME, (unsigned long)acThreadName, 0,0,0);
pthread_create(&s_hNnieThread, 0, SAMPLE_SVP_NNIE_Yolov3_ViToVo_thread, NULL);
SAMPLE_PAUSE();
s_bNnieStopSignal = HI_TRUE;
pthread_join(s_hNnieThread, HI_NULL);
s_hNnieThread = 0;
YOLOV3_FAIL_1:
SAMPLE_SVP_NNIE_Yolov3_Deinit(&s_stYolov3NnieParam,&s_stYolov3SoftwareParam,&s_stYolov3Model);
YOLOV3_FAIL_0:
SAMPLE_COMM_IVE_StopViVpssVencVo_Yolov3(&s_stViConfig,&s_stYolov3Switch);
}
void SAMPLE_SVP_NNIE_Yolov3_Vivo_HandleSig(void)
{
s_bNnieStopSignal = HI_TRUE;
if (0 != s_hNnieThread)
{
pthread_join(s_hNnieThread, HI_NULL);
s_hNnieThread = 0;
}
SAMPLE_SVP_NNIE_Yolov3_Deinit(&s_stYolov3NnieParam,&s_stYolov3SoftwareParam,&s_stYolov3Model);
memset(&s_stYolov3NnieParam,0,sizeof(SAMPLE_SVP_NNIE_PARAM_S));
memset(&s_stYolov3SoftwareParam,0,sizeof(SAMPLE_SVP_NNIE_YOLOV3_SOFTWARE_PARAM_S));
memset(&s_stYolov3Model,0,sizeof(SAMPLE_SVP_NNIE_MODEL_S));
SAMPLE_COMM_IVE_StopViVpssVencVo_Yolov3(&s_stViConfig,&s_stYolov3Switch);
}

如图所示：

第二步 在文件的上端添加

/*yolov3 para*/
static SAMPLE_IVE_SWITCH_S s_stYolov3Switch = {HI_FALSE,HI_FALSE};

第三步在文件svp\common\sample_comm_nnie.h 

更改第273行   hiSAMPLE_SVP_NNIE_YOLOV3_SOFTWARE_PARAM_S 结构体，代码如下：

typedef struct hiSAMPLE_SVP_NNIE_YOLOV3_SOFTWARE_PARAM_S
{
HI_U32 u32OriImHeight;
HI_U32 u32OriImWidth;
HI_U32 u32BboxNumEachGrid;
HI_U32 u32ClassNum;
HI_U32 au32GridNumHeight[3];
HI_U32 au32GridNumWidth[3];
HI_U32 u32NmsThresh;
HI_U32 u32ConfThresh;
HI_U32 u32MaxRoiNum;
HI_FLOAT af32Bias[3][6];
SVP_MEM_INFO_S stGetResultTmpBuf;
SVP_DST_BLOB_S stClassRoiNum;
SVP_DST_BLOB_S stDstRoi;
SVP_DST_BLOB_S stDstScore;
HI_FLOAT af32ScoreThr[SAMPLE_SVP_NNIE_MAX_CLASS_NUM];
SAMPLE_SVP_NNIE_RECT_ARRAY_S stRect;
}SAMPLE_SVP_NNIE_YOLOV3_SOFTWARE_PARAM_S;

第四步在svp\common\sample_comm_ive.c

更改 第1172行函数HI_S32 SAMPLE_COMM_IVE_VbInit_Yolov3(PIC_SIZE_E *paenSize,SIZE_S *pastSize,HI_U32 u32VpssChnNum)

HI_S32 SAMPLE_COMM_IVE_VbInit_Yolov3(PIC_SIZE_E *paenSize,SIZE_S *pastSize,HI_U32 u32VpssChnNum)
{
HI_S32 s32Ret;
HI_U32 i;
HI_U64 u64BlkSize;
VB_CONFIG_S stVbConf;
memset(&stVbConf, 0, sizeof(VB_CONFIG_S));
stVbConf.u32MaxPoolCnt = 128;
for (i = 0; i < u32VpssChnNum; i++)
{
s32Ret = SAMPLE_COMM_SYS_GetPicSize(paenSize[i], &pastSize[i]);
pastSize[1].u32Width = 416;
pastSize[1].u32Height = 416;
SAMPLE_CHECK_EXPR_GOTO(HI_SUCCESS != s32Ret, VB_FAIL_0,
"SAMPLE_COMM_SYS_GetPicSize failed,Error(%#x)!\n",s32Ret);
u64BlkSize = COMMON_GetPicBufferSize(pastSize[i].u32Width, pastSize[i].u32Height,
SAMPLE_PIXEL_FORMAT, DATA_BITWIDTH_8, COMPRESS_MODE_NONE, DEFAULT_ALIGN);
/* comm video buffer */
stVbConf.astCommPool[i].u64BlkSize = u64BlkSize;
stVbConf.astCommPool[i].u32BlkCnt  = 16;
}
s32Ret = SAMPLE_COMM_SYS_Init(&stVbConf);
SAMPLE_CHECK_EXPR_GOTO(HI_SUCCESS != s32Ret, VB_FAIL_1,
"SAMPLE_COMM_SYS_Init failed,Error(%#x)!\n", s32Ret);
return s32Ret;
VB_FAIL_1:
SAMPLE_COMM_SYS_Exit();
VB_FAIL_0:
return s32Ret;
}

第五步更改主函数

在svp\nnie\sample_nnie_main.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include "sample_nnie_main.h"
static char **s_ppChCmdArgv = NULL;
/******************************************************************************
* function : to process abnormal case
******************************************************************************/
#ifndef __HuaweiLite__
void SAMPLE_SVP_HandleSig(int s32Signo)
{
signal(SIGINT,SIG_IGN);
signal(SIGTERM,SIG_IGN);
if (SIGINT == s32Signo || SIGTERM == s32Signo)
{
switch (*s_ppChCmdArgv[1])
{
case '0':
{
SAMPLE_SVP_NNIE_Rfcn_HandleSig();
}
break;
case '1':
{
SAMPLE_SVP_NNIE_Yolov3_HandleSig();
}
break;
case '2':
{
SAMPLE_SVP_NNIE_Yolov3_Vivo_HandleSig();
}
break;
default :
{
}
break;
}
printf("\033[0;31mprogram termination abnormally!\033[0;39m\n");
}
exit(-1);
}
#endif
/******************************************************************************
* function : show usage
******************************************************************************/
void SAMPLE_SVP_Usage(char* pchPrgName)
{
printf("Usage : %s <index> \n", pchPrgName);
printf("index:\n");
printf("\t 0) RFCN(VI->VPSS->NNIE->VGS->VO).\n");
printf("\t 1) Yolov3(Read File).\n");
printf("\t 2) Yolov3(VI->VPSS->NNIE->VGS->VO).\n");
}
/******************************************************************************
* function : nnie sample
******************************************************************************/
#ifdef __HuaweiLite__
int app_main(int argc, char *argv[])
#else
int main(int argc, char *argv[])
#endif
{
int s32Ret = HI_SUCCESS;
if (argc < 2 || argc > 2)
{
SAMPLE_SVP_Usage(argv[0]);
return HI_FAILURE;
}
if (!strncmp(argv[1], "-h", 2))
{
SAMPLE_SVP_Usage(argv[0]);
return HI_SUCCESS;
}
s_ppChCmdArgv = argv;
#ifndef __HuaweiLite__
signal(SIGINT, SAMPLE_SVP_HandleSig);
signal(SIGTERM, SAMPLE_SVP_HandleSig);
#endif
switch (*argv[1])
{
case '0':
{
SAMPLE_SVP_NNIE_Rfcn();
}
break;
case '1':
{
SAMPLE_SVP_NNIE_Yolov3();
}
break;
case '2':
{
SAMPLE_SVP_NNIE_Yolov3_Vivo();
}
break;
default :
{
SAMPLE_SVP_Usage(argv[0]);
}
break;
}
return s32Ret;
}

第六步更改头文件

在路径svp\nnie\sample\sample_nnie_main.h加入如下代码：

void  SAMPLE_SVP_NNIE_Yolov3_Vivo(void);
void SAMPLE_SVP_NNIE_Yolov3_Vivo_HandleSig(void);

最后保存所有

在执行make clean 以及make 指令

最后执行./sample_nnie_main 2

由于我的摄像头输入为1080p图像导致计算量很大，所以帧率只有2fps

关于源代码以及工程文件我已上传至CSDN,若果有需要的同学可自取。

纯自己摸索，也有借鉴学习。该方案无需安装openCV库！