HI_MPI_VO_SendFrame 提示无效的视频帧

在VPSS获取视频数据后，进行dma拷贝，并完成vgs缩放，然后将数据发生vo，会提示无效的视频帧
通过log信息打印为 ：undefined

typedef struct crop_frame
{
VPSS_CHN VpssChn;
SAMPLE_VO_CONFIG_S stVoConfig;
VPSS_GRP        VpssGrpVenc;
VO_CHN             VoChn;
}CropFrame;
IVE_SRC_DATA_S g_stSrcData;
IVE_DST_DATA_S g_stDstData;

单独的函数，启动线程处理裁剪

{
    CropFrame* pFrame = (CropFrame*)malloc(sizeof(CropFrame));
    pFrame->stVoConfig = stVoConfig;
    pFrame->VpssChn = VpssChn;
    pFrame->VoChn = VoChn;
    pFrame->VpssGrpVenc = VpssGrpVenc;
    pFrame->rect_h = stGlobalParam->stCamCfg.rect_height;
    pFrame->rect_w = stGlobalParam->stCamCfg.rect_width;
    pFrame->rect_x = stGlobalParam->stCamCfg.rect_x;
    pFrame->rect_y = stGlobalParam->stCamCfg.rect_y;
    SAMPLE_PRT("rect_h : %d , rect_w : %d , rect_x : %d, rect_y : %d\n", pFrame->rect_h, pFrame->rect_w, pFrame->rect_x, pFrame->rect_y);
    g_stSrcData.u32Width = 3840;
    g_stSrcData.u32Height = 2160;
    g_stSrcData.u32Stride = 3840;

    s32Ret = HI_MPI_SYS_MmzAlloc_Cached(&g_stSrcData.u64PhyAddr, &g_stSrcData.u64VirAddr, "User", HI_NULL, g_stSrcData.u32Height*g_stSrcData.u32Stride*3/2);
    if(HI_SUCCESS!=s32Ret)
    {
        HI_MPI_SYS_MmzFree(g_stSrcData.u64PhyAddr, g_stSrcData.u64VirAddr);
        printf("000 HI_MPI_SYS_MmzAlloc_Cached failed with error code: %#x\n", s32Ret);
        return;
    }
    g_stDstData.u32Width = 1920;
    g_stDstData.u32Height = 1080;
    g_stDstData.u32Stride = 1920;   
    s32Ret = HI_MPI_SYS_MmzAlloc_Cached(&g_stDstData.u64PhyAddr, &g_stDstData.u64VirAddr, "User", HI_NULL, g_stDstData.u32Height* g_stDstData.u32Stride*3/2);
    if(HI_SUCCESS!=s32Ret)
    {
        printf("111 HI_MPI_SYS_MmzAlloc_Cached failed with error code: %#x\n", s32Ret);
        HI_MPI_SYS_MmzFree(g_stDstData.u64PhyAddr, g_stDstData.u64VirAddr);
        return;
    }
    // HI_MPI_VO_Enable
    s32Ret = SAMPLE_COMM_VO_StopVO(&pFrame->stVoConfig);
    if (s32Ret != HI_SUCCESS) {
        printf("SAMPLE_COMM_VO_StopVO failed. s32Ret: 0x%x ! \n", s32Ret);
    }
    /*start vo*/
    s32Ret = SAMPLE_COMM_VO_StartVO(&pFrame->stVoConfig);
    if (HI_SUCCESS != s32Ret) {
        SAMPLE_PRT("start vo failed. s32Ret: 0x%x !\n", s32Ret);
    }
    pthread_t pth_vio;
    pthread_create(&pth_vio, NULL, Crop_Video_Frame, pFrame);
}

HI_VOID *Crop_Video_Frame(void* arg){
CropFrame* pFrame = (CropFrame*)arg;
HI_S32 s32Ret;
VIDEO_FRAME_INFO_S pstVideoFrame;
s32Ret = HI_MPI_VPSS_GetGrpFrame(pFrame->VpssChn, 0, &pstVideoFrame);
if (HI_SUCCESS != s32Ret) {
    SAMPLE_PRT("HI_MPI_VPSS_GetGrpFrame failed. s32Ret: 0x%x !\n", s32Ret);
}
SAMPLE_PRT("pstVideoFrame enPixelFormat : %d , poolID : %d, enModId :%d, stVFrame.enVideoFormat : %d\n", pstVideoFrame.stVFrame.enPixelFormat, pstVideoFrame.u32PoolId, pstVideoFrame.enModId, pstVideoFrame.stVFrame.enVideoFormat);
SAMPLE_PRT("pstVideoFrame width : %d, height : %d, stride:%d\n", pstVideoFrame.stVFrame.u32Width, pstVideoFrame.stVFrame.u32Height, pstVideoFrame.stVFrame.u32Stride[0]);

IVE_HANDLE hIve;
IVE_SRC_DATA_S stSrcData;
IVE_DST_DATA_S stDstData;
IVE_SRC_DATA_S stSrcData1;
 IVE_DST_DATA_S stDstData1;
IVE_DMA_CTRL_S stDmaCtrl = { IVE_DMA_MODE_DIRECT_COPY, 0 };
VGS_TASK_ATTR_S stTask;
memset(&stTask, 0, sizeof(stTask));
//pstVideoFrame to stSrcData
stSrcData.u64PhyAddr = pstVideoFrame.stVFrame.u64PhyAddr[0] ;
stSrcData.u64VirAddr = pstVideoFrame.stVFrame.u64VirAddr[0] ;
stSrcData.u32Width = pstVideoFrame.stVFrame.u32Width/2;
stSrcData.u32Height = pstVideoFrame.stVFrame.u32Height/2;
stSrcData.u32Stride = pstVideoFrame.stVFrame.u32Stride[0]/2;

stDstData.u64PhyAddr = g_stDstData.u64PhyAddr;
stDstData.u64VirAddr = g_stDstData.u64VirAddr;
stDstData.u32Width = g_stDstData.u32Width;
stDstData.u32Height = g_stDstData.u32Height;
stDstData.u32Stride = g_stDstData.u32Stride;
SAMPLE_PRT("stDstData u32Stride : %d , width :%d , height : %d\n", stDstData.u32Stride, stDstData.u32Width, stDstData.u32Height);

HI_BOOL bInstant = HI_FALSE;
s32Ret = HI_MPI_IVE_DMA(&hIve, &stSrcData, &stDstData, &stDmaCtrl, bInstant);
if (s32Ret != HI_SUCCESS) {
    SAMPLE_PRT("000 HI_MPI_IVE_DMA failed with error code: %#x , bInstant : %d\n", s32Ret, bInstant);
}
stSrcData.u64PhyAddr = pstVideoFrame.stVFrame.u64PhyAddr[1] ;
stSrcData.u64VirAddr = pstVideoFrame.stVFrame.u64VirAddr[1] ;
stSrcData.u32Width = pstVideoFrame.stVFrame.u32Width/2;
stSrcData.u32Height = pstVideoFrame.stVFrame.u32Height/4;
stSrcData.u32Stride = pstVideoFrame.stVFrame.u32Stride[1]/2;

stDstData.u64PhyAddr = g_stDstData.u64PhyAddr+ 1920 * 1080;
stDstData.u64VirAddr = g_stDstData.u64VirAddr+ 1920 * 1080;
stDstData.u32Width = g_stDstData.u32Width;
stDstData.u32Height = g_stDstData.u32Height/2;
stDstData.u32Stride = g_stDstData.u32Stride;
SAMPLE_PRT("stDstData u32Stride : %d , width :%d , height : %d\n", stDstData.u32Stride, stDstData.u32Width, stDstData.u32Height);
s32Ret = HI_MPI_IVE_DMA(&hIve, &stSrcData, &stDstData, &stDmaCtrl, bInstant);
if (s32Ret != HI_SUCCESS) {
    SAMPLE_PRT("111 HI_MPI_IVE_DMA failed with error code: %#x , bInstant : %d\n", s32Ret, bInstant);
}

s32Ret = HI_MPI_VPSS_ReleaseGrpFrame(pFrame->VpssGrpVenc, 0, &pstVideoFrame);
if (s32Ret != HI_SUCCESS) {
    SAMPLE_PRT("HI_MPI_VPSS_ReleaseGrpFrame failed with error code: %#x\n", s32Ret);
}

stTask.stImgIn.stVFrame.u32Width = g_stDstData.u32Width;
stTask.stImgIn.stVFrame.u32Height = g_stDstData.u32Height;
stTask.stImgIn.stVFrame.u32Stride[0] = g_stDstData.u32Stride;
stTask.stImgIn.stVFrame.u64PhyAddr[0] = g_stDstData.u64PhyAddr;
stTask.stImgIn.stVFrame.u64VirAddr[0] = g_stDstData.u64VirAddr;
stTask.stImgIn.stVFrame.u64PhyAddr[1] = g_stDstData.u64PhyAddr + 1920 * 1080;
stTask.stImgIn.stVFrame.u64VirAddr[1] = g_stDstData.u64VirAddr + 1920 * 1080;
stTask.stImgIn.stVFrame.u32Stride[1] = g_stDstData.u32Stride;
stTask.stImgIn.stVFrame.enPixelFormat = PIXEL_FORMAT_YVU_SEMIPLANAR_420;

//creat vb 
VB_POOL ourpool;
VB_POOL poolId;
VB_BLK ourblock;
VB_POOL_CONFIG_S ourVBconfig;
HI_U64* ourPhyAddr;
HI_U8 *ourVirAddr;

(hi_void)memset_s(&ourVBconfig, sizeof(VB_POOL_CONFIG_S), 0, sizeof(VB_POOL_CONFIG_S));
ourVBconfig.u32BlkCnt = 1;
ourVBconfig.u64BlkSize = 3840 * 2160 * 3 / 2;
ourVBconfig.enRemapMode = VB_REMAP_MODE_NONE;
ourpool = HI_MPI_VB_CreatePool(&ourVBconfig);
if (ourpool == VB_INVALID_POOLID) {
    SAMPLE_PRT("HI_MPI_VB_CreatePool failed!\n");
    printf("Create pool error\n");
}
ourblock = HI_MPI_VB_GetBlock(ourpool, 3840 * 2160 * 3 / 2, "ourspace");
ourPhyAddr = HI_MPI_VB_Handle2PhysAddr(ourblock);
ourVirAddr = (HI_U8 *)HI_MPI_SYS_Mmap(ourPhyAddr, 3840 * 2160 * 3 / 2);

stTask.stImgOut.stVFrame.u32Width = g_stSrcData.u32Width;
stTask.stImgOut.stVFrame.u32Height = g_stSrcData.u32Height;
stTask.stImgOut.stVFrame.u32Stride[0] = g_stSrcData.u32Stride;
stTask.stImgOut.stVFrame.u64PhyAddr[0] = ourPhyAddr;
stTask.stImgOut.stVFrame.u64VirAddr[0] = (HI_U64)(HI_UINTPTR_T)ourVirAddr;
stTask.stImgOut.stVFrame.u64PhyAddr[1] = ourPhyAddr +3840*2160;
stTask.stImgOut.stVFrame.u64VirAddr[1] =stTask.stImgOut.stVFrame.u64VirAddr[0] +3840*2160;
stTask.stImgOut.stVFrame.u32Stride[1] = g_stSrcData.u32Stride;
stTask.stImgOut.stVFrame.enPixelFormat = PIXEL_FORMAT_YVU_SEMIPLANAR_420;
stTask.stImgOut.stVFrame.enVideoFormat = VIDEO_FORMAT_LINEAR;
stTask.stImgOut.u32PoolId = ourpool;
SAMPLE_PRT("stTask.stImgOut.u32PoolId : %d, ourpool : %d\n", stTask.stImgOut.u32PoolId, ourpool);

VGS_HANDLE hHandle;
s32Ret = HI_MPI_VGS_BeginJob(&hHandle);
if (s32Ret != HI_SUCCESS) {
    SAMPLE_PRT("HI_MPI_VGS_BeginJob failed with error code: %#x\n", s32Ret);
}

s32Ret = HI_MPI_VGS_AddScaleTask(hHandle,&stTask,VGS_SCLCOEF_NORMAL);
if (s32Ret != HI_SUCCESS) {
    HI_MPI_VGS_CancelJob(hHandle); 
    SAMPLE_PRT("HI_MPI_VGS_AddScaleTask failed with error code: %#x\n", s32Ret);
}

s32Ret = HI_MPI_VGS_EndJob(hHandle); 
if (s32Ret != HI_SUCCESS) {
    HI_MPI_VGS_CancelJob(hHandle); 
    SAMPLE_PRT("HI_MPI_VGS_EndJob failed with error code: %#x\n", s32Ret);
}
SAMPLE_PRT("stTask out width : %d , hight : %d, stride : %d , stride[1] : %d\n", stTask.stImgOut.stVFrame.u32Width, stTask.stImgOut.stVFrame.u32Height, stTask.stImgOut.stVFrame.u32Stride[0], stTask.stImgOut.stVFrame.u32Stride[1]);

VO_LAYER VoLayer = pFrame->stVoConfig.VoDev; // VO层号
s32Ret = HI_MPI_VO_SendFrame(VoLayer, pFrame->VoChn, &stTask.stImgOut, -1);
if (s32Ret != HI_SUCCESS) {
    SAMPLE_PRT("HI_MPI_VO_SendFrame failed with error code: %#x\n", s32Ret);
}
s32Ret = HI_MPI_SYS_Munmap(ourVirAddr, 3840 * 2160 * 3 / 2);
if (s32Ret != HI_SUCCESS) {
    SAMPLE_PRT("HI_MPI_SYS_Munmap failed with error code: %#x\n", s32Ret);
}
s32Ret = HI_MPI_VB_ReleaseBlock(ourblock);
if (s32Ret != HI_SUCCESS) {
    SAMPLE_PRT("HI_MPI_VB_ReleaseBlock failed with error code: %#x\n", s32Ret);
}
}