_沉思
_沉思

_沉思

0个粉丝

6

问答

0

专栏

0

资料

_沉思  发布于  2017-09-20 15:05:29
采纳率 0%
共6个问答
11389
  • 收藏
  • 点赞
  • 分享
  • 举报

关于hi3516a的错误：HI_MPI_VENC_SendFrame failed with 0xa0088003

海思
 
1.使用MPI函数HI_MPI_VPSS_GetChnFrame从vpss获取帧，然后将帧通过HI_MPI_VENC_SendFrame函数发给venc编码，出现错误：HI_MPI_VENC_SendFrame failed with 0xa0088003。"参数范围不合法",可是我查看了一下，都是合法的值呀，有没有前辈遇到类似的情况？
以下是源码：
[code]
#include
#include
#include
#include
#include
#include

#include "sample_comm.h"

#define PRE_WIDTH 1920
#define PRE_HEIGHT 1080
#define RES_WIDTH 3840
#define RES_HEIGHT 2160

VIDEO_NORM_E gs_enNorm = VIDEO_ENCODING_MODE_NTSC;
PIC_SIZE_E g_enPicSize = PIC_HD1080;

VIDEO_FRAME_INFO_S g_stFrame;

static HI_CHAR* pUserPageAddr[2] = {HI_NULL,HI_NULL};
static HI_U32 u32Size = 0;

VIDEO_FRAME_INFO_S* g_stDestFrame;
VIDEO_FRAME_INFO_S* g_stVpssFrame;


static int VENC_SnapProcess(VENC_CHN VencChn)
{
        struct timeval TimeoutVal;
    fd_set read_fds;
    HI_S32 s32VencFd;
    VENC_STREAM_S stStream;
    VENC_CHN_STAT_S stStat;
        HI_S32 s32Ret;
    VENC_RECV_PIC_PARAM_S stRecvParam;

        printf("press any key to snap one pic\n");
    getchar();
        stRecvParam.s32RecvPicNum = 1;
    s32Ret = HI_MPI_VENC_StartRecvPicEx(VencChn,&stRecvParam);
    if (HI_SUCCESS != s32Ret)
    {
        SAMPLE_PRT("HI_MPI_VENC_StartRecvPic faild with %#x!\n", s32Ret);
        return HI_FAILURE;
    }
#if 0
        printf("g_stDestFrame->stVFrame.u32Width = %d\n",g_stDestFrame->stVFrame.u32Width);
        printf("g_stDestFrame->stVFrame.u32Height = %d\n",g_stDestFrame->stVFrame.u32Height);
        printf("g_stDestFrame->stVFrame.u32PhyAddr[0] = %#x\n",g_stDestFrame->stVFrame.u32PhyAddr[0]);
        printf("g_stDestFrame->stVFrame.u32PhyAddr[1] = %#x\n",g_stDestFrame->stVFrame.u32PhyAddr[1]);
        printf("g_stDestFrame->stVFrame.pVirAddr[0] = %#x\n",g_stDestFrame->stVFrame.pVirAddr[0]);
        printf("g_stDestFrame->stVFrame.pVirAddr[1] = %#x\n",g_stDestFrame->stVFrame.pVirAddr[1]);
        printf("g_stDestFrame->stVFrame.u32Stride[0] = %d\n",g_stDestFrame->stVFrame.u32Stride[0]);
        printf("g_stDestFrame->stVFrame.u32Stride[1] = %d\n",g_stDestFrame->stVFrame.u32Stride[1]);
        printf("g_stDestFrame->stVFrame.enPixelFormat = %d\n",g_stDestFrame->stVFrame.enPixelFormat);
        printf("g_stDestFrame->stVFrame.u64pts     = %d\n",g_stDestFrame->stVFrame.u64pts);
    printf("g_stDestFrame->stVFrame.u32TimeRef = %d\n",g_stDestFrame->stVFrame.u32TimeRef);
#endif
        printf("VencChn = %d\n",VencChn);
        s32Ret = HI_MPI_VENC_SendFrame(VencChn,g_stVpssFrame,-1);
        if(s32Ret != 0)
        {
                printf("HI_MPI_VENC_SendFrame failed with %#x!\n",s32Ret);
                return -1;
        }

        s32VencFd = HI_MPI_VENC_GetFd(VencChn);
        if (s32VencFd < 0)
        {
                SAMPLE_PRT("HI_MPI_VENC_GetFd faild with%#x!\n", s32VencFd);
                return HI_FAILURE;
        }

        FD_ZERO(&read_fds);
    FD_SET(s32VencFd, &read_fds);
        TimeoutVal.tv_sec  = 2;
    TimeoutVal.tv_usec = 0;
    s32Ret = select(s32VencFd + 1, &read_fds, NULL, NULL, &TimeoutVal);
    if (s32Ret < 0)
    {
        SAMPLE_PRT("snap select failed!\n");
        return HI_FAILURE;
    }
    else if (0 == s32Ret)
    {
        SAMPLE_PRT("snap time out!\n");
        return HI_FAILURE;
    }
        else
    {
        if (FD_ISSET(s32VencFd, &read_fds))
        {
            s32Ret = HI_MPI_VENC_Query(VencChn, &stStat);
            if (s32Ret != HI_SUCCESS)
            {
                SAMPLE_PRT("HI_MPI_VENC_Query failed with %#x!\n", s32Ret);
                return HI_FAILURE;
            }
                        if(0 == stStat.u32CurPacks)
                        {
                                SAMPLE_PRT("NOTE: Current  frame is NULL!\n");
                                return HI_SUCCESS;
                        }
                        stStream.pstPack = (VENC_PACK_S*)malloc(sizeof(VENC_PACK_S) * stStat.u32CurPacks);
            if (NULL == stStream.pstPack)
            {
                SAMPLE_PRT("malloc memory failed!\n");
                return HI_FAILURE;
            }

            stStream.u32PackCount = stStat.u32CurPacks;
            s32Ret = HI_MPI_VENC_GetStream(VencChn, &stStream, -1);
            if (HI_SUCCESS != s32Ret)
            {
                SAMPLE_PRT("HI_MPI_VENC_GetStream failed with %#x!\n", s32Ret);
                free(stStream.pstPack);
                stStream.pstPack = NULL;
                return HI_FAILURE;
            }

                        s32Ret = SAMPLE_COMM_VENC_SaveSnap(&stStream);
            if (HI_SUCCESS != s32Ret)
            {
                SAMPLE_PRT("HI_MPI_VENC_GetStream failed with %#x!\n", s32Ret);
                free(stStream.pstPack);
                stStream.pstPack = NULL;
                return HI_FAILURE;
            }

            s32Ret = HI_MPI_VENC_ReleaseStream(VencChn, &stStream);
            if (s32Ret)
            {
                SAMPLE_PRT("HI_MPI_VENC_ReleaseStream failed with %#x!\n", s32Ret);
                free(stStream.pstPack);
                stStream.pstPack = NULL;
                return HI_FAILURE;
            }

            free(stStream.pstPack);
            stStream.pstPack = NULL;
              }
        }
        s32Ret = HI_MPI_VENC_StopRecvPic(VencChn);
    if (s32Ret != HI_SUCCESS)
    {
        SAMPLE_PRT("HI_MPI_VENC_StopRecvPic failed with %#x!\n",  s32Ret);
        return HI_FAILURE;
    }
        return HI_SUCCESS;
}

static int VENC_SnapStart(VENC_CHN VencChn,SIZE_S* pstSize,int Width,int Height)
{
        HI_S32 s32Ret;
    VENC_CHN_ATTR_S stVencChnAttr;
    VENC_ATTR_JPEG_S stJpegAttr;
    stVencChnAttr.stVeAttr.enType = PT_JPEG;

    stJpegAttr.u32MaxPicWidth  = 3840;
    stJpegAttr.u32MaxPicHeight = 2160;
    stJpegAttr.u32PicWidth  = 3840/*pstSize->u32Width*/;
    stJpegAttr.u32PicHeight = 2160/*pstSize->u32Height*/;
    stJpegAttr.u32BufSize = 3840*2160*2/*pstSize->u32Width * pstSize->u32Height * 2*/;
    stJpegAttr.bByFrame = HI_TRUE;/*get stream mode is field mode  or frame mode*/
    stJpegAttr.bSupportDCF = HI_FALSE;
    memcpy(&stVencChnAttr.stVeAttr.stAttrJpeg, &stJpegAttr, sizeof(VENC_ATTR_JPEG_S));

        printf("VencChn = %d\n",VencChn);
    s32Ret = HI_MPI_VENC_CreateChn(VencChn, &stVencChnAttr);
    if (HI_SUCCESS != s32Ret)
    {
        SAMPLE_PRT("HI_MPI_VENC_CreateChn [%d] faild with %#x!\n", \
                   VencChn, s32Ret);
        return s32Ret;
    }
        return HI_SUCCESS;
       
}

int main(int argc,char *argv[])
{
    VB_CONF_S stVbConf;
       
        VB_BLK VbBlk = VB_INVALID_HANDLE;
        VB_POOL hPool  = VB_INVALID_POOLID;
    SAMPLE_VI_CONFIG_S stViConfig = {0};

        HI_U32 u32ViChnCnt = 2;       
    VPSS_GRP VpssGrp = 0;
    VPSS_CHN VpssChn = 0;
    VPSS_GRP_ATTR_S stVpssGrpAttr;
    VPSS_CHN_ATTR_S stVpssChnAttr;
    VPSS_CHN_MODE_S stVpssChnMode;
        VPSS_EXT_CHN_ATTR_S stVpssExtChnAttr;

    VENC_CHN VencChn;
    HI_U32 u32BlkSize;
    SIZE_S stSize;
        ROTATE_E enRotate = ROTATE_NONE;
    HI_S32 i = 0;

    HI_S32 s32Ret = HI_SUCCESS;
        char ch;
        HI_S32 u32Depth = 4;
        int width  = 3840;
        int height = 2160;

        u32Size = width*height*3/2;
       
        /* 1.初始化缓冲池 */
    memset(&stVbConf, 0, sizeof(VB_CONF_S));
        stVbConf.u32MaxPoolCnt = 128;
        /*video buffer*/
    u32BlkSize = SAMPLE_COMM_SYS_CalcPicVbBlkSize(gs_enNorm, \
                 g_enPicSize, SAMPLE_PIXEL_FORMAT, SAMPLE_SYS_ALIGN_WIDTH);

    stVbConf.astCommPool[0].u32BlkSize = u32BlkSize;//1920*1080*3/2
    stVbConf.astCommPool[0].u32BlkCnt = u32ViChnCnt * 8;
       
        /* 2.初始化mpp系统*/
    s32Ret = SAMPLE_COMM_SYS_Init(&stVbConf);
    if (HI_SUCCESS != s32Ret)
    {
        SAMPLE_PRT("system init failed with %d!\n", s32Ret);
        goto END_VENC_JPEG_0;
    }
        /* 3.设置vi和开启vi通道*/
    stViConfig.enViMode   = SENSOR_TYPE;
    stViConfig.enRotate   = ROTATE_NONE;/*旋转角度为0*/
    stViConfig.enNorm     = VIDEO_ENCODING_MODE_AUTO;/*两种格式:PAL/NTSC/AUTO*/
    stViConfig.enViChnSet = VI_CHN_SET_NORMAL;/*正常模式下/镜像*/
    s32Ret = SAMPLE_COMM_VI_StartVi(&stViConfig);
    if (HI_SUCCESS != s32Ret)
    {
        SAMPLE_PRT("start vi failed!\n");
        goto END_VENC_JPEG_1;
    }
        /* 4.开启vpss,vi绑定vpss*/
    s32Ret = SAMPLE_COMM_SYS_GetPicSize(gs_enNorm,g_enPicSize, &stSize);/*获取stSize*/
    if (HI_SUCCESS != s32Ret)
    {
        SAMPLE_PRT("SAMPLE_COMM_SYS_GetPicSize failed!\n");
        goto END_VENC_JPEG_1;
    }


    stVpssGrpAttr.u32MaxW = 1920;
    stVpssGrpAttr.u32MaxH = 1080;
    stVpssGrpAttr.bIeEn = HI_FALSE;   
    stVpssGrpAttr.bNrEn = HI_TRUE;
    stVpssGrpAttr.bHistEn = HI_FALSE;
    stVpssGrpAttr.enDieMode = VPSS_DIE_MODE_NODIE;
    stVpssGrpAttr.enPixFmt = SAMPLE_PIXEL_FORMAT;
    stVpssGrpAttr.bDciEn = HI_FALSE;
        s32Ret = HI_MPI_VPSS_CreateGrp(VpssGrp,&stVpssGrpAttr);
        if (s32Ret != HI_SUCCESS)
        {
                SAMPLE_PRT("HI_MPI_VPSS_CreateGrp failed with %#x!\n", s32Ret);
                return -1;
        }
        s32Ret = HI_MPI_VPSS_StartGrp(VpssGrp);
    if (s32Ret != HI_SUCCESS)
    {
        SAMPLE_PRT("HI_MPI_VPSS_StartGrp failed with %#x\n", s32Ret);
        return -1;
    }
#if 1
        memset(&stVpssChnAttr, 0, sizeof(stVpssChnAttr));
        stVpssChnAttr.bBorderEn = 0;
    stVpssChnAttr.bFlip = 0;
    stVpssChnAttr.bMirror = 0;
    stVpssChnAttr.bSpEn = 0;
    stVpssChnAttr.s32SrcFrameRate = -1;
    stVpssChnAttr.s32DstFrameRate = -1;
    stVpssChnMode.enChnMode     = VPSS_CHN_MODE_USER;
    stVpssChnMode.bDouble       = HI_FALSE;
    stVpssChnMode.enPixelFormat = SAMPLE_PIXEL_FORMAT;
    stVpssChnMode.u32Width      = 1920/*stSize.u32Width*/;
    stVpssChnMode.u32Height     = 1080/*stSize.u32Height*/;
    stVpssChnMode.enCompressMode = COMPRESS_MODE_NONE;

        VPSS_CROP_INFO_S stVpssCropInfo;

    stVpssCropInfo.bEnable = HI_TRUE;
    stVpssCropInfo.enCropCoordinate = VPSS_CROP_ABS_COOR;
    stVpssCropInfo.stCropRect.s32X = 0;
    stVpssCropInfo.stCropRect.s32Y = 0;
    stVpssCropInfo.stCropRect.u32Width  = 1920;
    stVpssCropInfo.stCropRect.u32Height = 1080;
        s32Ret = HI_MPI_VPSS_SetGrpCrop(i, &stVpssCropInfo);
       
        s32Ret =  HI_MPI_VPSS_SetDepth(VpssGrp, VpssChn,u32Depth);
    if (s32Ret != HI_SUCCESS)
    {
        SAMPLE_PRT("HI_MPI_VPSS_SetDepth failed with %#x!\n", s32Ret);
        return -1;
    }
    s32Ret = HI_MPI_VPSS_SetChnAttr(VpssGrp, VpssChn, &stVpssChnAttr);               
    if (s32Ret != HI_SUCCESS)
    {
        SAMPLE_PRT("HI_MPI_VPSS_SetChnAttr failed with %#x!\n", s32Ret);
        return -1;
    }
        s32Ret = HI_MPI_VPSS_SetChnMode(VpssGrp, VpssChn,&stVpssChnMode);
    if (s32Ret != HI_SUCCESS)
    {
            SAMPLE_PRT("%s failed with %#x\n", __FUNCTION__, s32Ret);
        return -1;
    }
        s32Ret =  HI_MPI_VPSS_EnableChn(VpssGrp,VpssChn);
    if (s32Ret != HI_SUCCESS)
    {
        SAMPLE_PRT("HI_MPI_VPSS_SetChnMode failed with %#x!\n", s32Ret);
        return -1;
    }
        VencChn = 0;
        s32Ret = VENC_SnapStart(VencChn,&stSize,4096,4096);
    if (HI_SUCCESS != s32Ret)
    {
               SAMPLE_PRT("Start snap failed!\n");
               goto END_VENC_JPEG_5;
    }
        SAMPLE_COMM_VI_BindVpss(stViConfig.enViMode);

        int count = 0;
        printf("press 'q' to exit sample!\nperess ENTER to capture one picture to file\n");
        while((ch = (char)getchar()) != 'q')
        {
                g_stVpssFrame = (VIDEO_FRAME_INFO_S*)malloc(sizeof(VIDEO_FRAME_INFO_S));
                g_stDestFrame = (VIDEO_FRAME_INFO_S*)malloc(sizeof(VIDEO_FRAME_INFO_S));
                memset(g_stVpssFrame,0,sizeof(g_stVpssFrame));
#if 0
                hPool = HI_MPI_VB_CreatePool(u32Size,1,NULL);
                if (hPool == VB_INVALID_POOLID)
                {
                        SAMPLE_PRT("HI_MPI_VB_CreatePool failed! \n");
                        return -1;
                }
#endif
            s32Ret = HI_MPI_VPSS_GetChnFrame(VpssGrp,VpssChn,g_stVpssFrame,-1);
            if (s32Ret == HI_SUCCESS)
            {
#if 1           
                printf("g_stVpssFrame->stVFrame.u32Width = %d\n",g_stVpssFrame->stVFrame.u32Width);
                printf("g_stVpssFrame->stVFrame.u32Height = %d\n",g_stVpssFrame->stVFrame.u32Height);
                printf("g_stVpssFrame->stVFrame.u32PhyAddr[0] = %#x\n",g_stVpssFrame->stVFrame.u32PhyAddr[0]);
                printf("g_stVpssFrame->stVFrame.u32PhyAddr[1] = %#x\n",g_stVpssFrame->stVFrame.u32PhyAddr[1]);
                printf("g_stVpssFrame->stVFrame.pVirAddr[0] = %#x\n",g_stVpssFrame->stVFrame.pVirAddr[0]);
                printf("g_stVpssFrame->stVFrame.pVirAddr[1] = %#x\n",g_stVpssFrame->stVFrame.pVirAddr[1]);
                printf("g_stVpssFrame->stVFrame.u32Stride[0] = %d\n",g_stVpssFrame->stVFrame.u32Stride[0]);
                printf("g_stVpssFrame->stVFrame.u32Stride[1] = %d\n",g_stVpssFrame->stVFrame.u32Stride[1]);
                printf("g_stVpssFrame->stVFrame.enPixelFormat = %d\n",g_stVpssFrame->stVFrame.enPixelFormat);
                printf("g_stVpssFrame->stVFrame.u64pts           = %d\n",g_stVpssFrame->stVFrame.u64pts);
                printf("g_stVpssFrame->stVFrame.u32TimeRef = %d\n",g_stVpssFrame->stVFrame.u32TimeRef);
#endif                   
                        memcpy(g_stDestFrame,g_stVpssFrame,sizeof(VIDEO_FRAME_INFO_S));
                    //reform_yuv(&g_stVpssFrame->stVFrame,g_stDestFrame,4);
                    HI_MPI_VPSS_ReleaseChnFrame(VpssGrp,VpssChn,g_stVpssFrame);
                    //vgs_main(&g_stVpssFrame->stVFrame,&g_stDestFrame->stVFrame,1920,1080);
            }
            else
            {
                    SAMPLE_PRT("HI_MPI_VPSS_GetChnFrame failed with %#x\n", s32Ret);
                return -1;
            }
                s32Ret = VENC_SnapProcess(VencChn);
                if (HI_SUCCESS != s32Ret)
                {
                        printf("%s: snap process failed!\n", __FUNCTION__);
                        continue;
                }
                //HI_MPI_VPSS_ReleaseChnFrame(VpssGrp,VpssChn,g_stVpssFrame);
                printf("snap %d success!\n",count);
                count++;
                free(g_stVpssFrame);
                free(g_stDestFrame);
        }
        printf("please press ENTER to exit this sample\n");
        getchar();
       
        SAMPLE_COMM_VENC_StopGetStream();
#endif
#if 0
                /******************************************
                 step 6: stream venc process -- get stream, then save it to file.
                ******************************************/
                i = 0;
                while ((ch = (char)getchar()) != 'q')
                {
                        s32Ret = SAMPLE_COMM_VENC_SnapProcess(VencChn);
                        if (HI_SUCCESS != s32Ret)
                        {
                                printf("%s: sanp process failed!\n", __FUNCTION__);
                                break;
                        }
                        printf("snap %d success!\n", i);
                        i++;
                }
       
                printf("please press ENTER to exit this sample\n");
                getchar();
                /******************************************
                 step 8: exit process
                ******************************************/
                SAMPLE_COMM_VENC_StopGetStream();
#endif
        END_VENC_JPEG_5:
                VpssGrp = 0;
                VpssChn = 0;
                VencChn = 0;
                SAMPLE_COMM_VENC_UnBindVpss(VencChn, VpssGrp, VpssChn);
                SAMPLE_COMM_VENC_Stop(VencChn);
        END_VENC_JPEG_4:          //vpss stop
                VpssGrp = 0;
                VpssChn = 0;
                SAMPLE_COMM_VPSS_DisableChn(VpssGrp, VpssChn);
        END_VENC_JPEG_3:          //vpss stop
                SAMPLE_COMM_VI_UnBindVpss(stViConfig.enViMode);
        END_VENC_JPEG_2:          //vpss stop
                SAMPLE_COMM_VPSS_StopGroup(VpssGrp);
        END_VENC_JPEG_1:          //vi stop
                SAMPLE_COMM_VI_StopVi(&stViConfig);
        END_VENC_JPEG_0:        //system exit
                SAMPLE_COMM_SYS_Exit();
                HI_MPI_VB_DestroyPool(hPool);
                hPool = VB_INVALID_POOLID;

       
        return 0;
}
[/code]
我来回答
回答8个
时间排序
认可量排序
zhuangweiye

zhuangweiye

8个粉丝

0

问答

0

专栏

0

资料

zhuangweiye 2017-09-20 15:17:09
认可0

memcpy(g_stDestFrame,g_stVpssFrame,sizeof(VIDEO_FRAME_INFO_S));
HI_MPI_VPSS_ReleaseChnFrame(VpssGrp,VpssChn,g_stVpssFrame);

楼主copy个描述符，就把VB给释放掉了

一般流程是
HI_MPI_VPSS_GetChnFrame（）；
HI_MPI_VENC_SendFrame（）；
HI_MPI_VPSS_ReleaseChnFrame（）；

无需copy VIDEO_FRAME_INFO_S
_沉思

_沉思

0个粉丝

6

问答

0

专栏

0

资料

_沉思 2017-09-20 15:25:10
认可0
[quote][url=forum.php?mod=redirect&goto=findpost&pid=64389&ptid=23582]zhuangweiye 发表于 2017-9-20 15:17[/url]
memcpy(g_stDestFrame,g_stVpssFrame,sizeof(VIDEO_FRAME_INFO_S));
HI_MPI_VPSS_ReleaseChnFrame(VpssG ...[/quote]

我按照前辈说的流程重新编译运行一边，还是出现原来的错误。memcpy那里已经注释掉了...
zhuangweiye

zhuangweiye

8个粉丝

0

问答

0

专栏

0

资料

zhuangweiye 2017-09-20 16:11:20
认可0
[quote][url=forum.php?mod=redirect&goto=findpost&pid=64391&ptid=23582]_沉思 发表于 2017-9-20 15:25[/url]
我按照前辈说的流程重新编译运行一边，还是出现原来的错误。memcpy那里已经注释掉了...[/quote]

是不是JPEG 编码器的高宽大于1920x1080的 ？
_沉思

_沉思

0个粉丝

6

问答

0

专栏

0

资料

_沉思 2017-09-20 16:32:03
认可0
[quote][url=forum.php?mod=redirect&goto=findpost&pid=64395&ptid=23582]zhuangweiye 发表于 2017-9-20 16:11[/url]
是不是JPEG 编码器的高宽大于1920x1080的 ？[/quote]

庄工，是这样子的。我用这个程序是用来将一张图片1080p拼接成2x2图片（3840*2160）的，刚刚没有改过来，现在改过来了，已经可以用了。现在我有还有一个问题，就是我那个memcpy(g_stDestFrame,g_stVpssFrame,sizeof(VIDEO_FRAME_INFO_S))，其中g_stDestFrame是处理过的结构体，然后把这个结构体通过HI_MPI_VENC_SendFrame函数发送给venc，然后就报错误：HI_MPI_VENC_SendFrame failed with 0xa0088003。这种情况下一般是我的拼接出现问题吗？还是我的结构体设置有问题？我觉得呢，如果拼接有问题，大不了yuv420sp数据错误，出来的图像是错误的，总不至于导致"参数范围不合法"这样的错误吧
_沉思

_沉思

0个粉丝

6

问答

0

专栏

0

资料

_沉思 2017-09-20 16:34:44
认可0
[quote][url=forum.php?mod=redirect&goto=findpost&pid=64395&ptid=23582]zhuangweiye 发表于 2017-9-20 16:11[/url]
是不是JPEG 编码器的高宽大于1920x1080的 ？[/quote]

以下是拼接后VIDEO_FRAME_INFO_S结构体的初始化：
zhuangweiye

zhuangweiye

8个粉丝

0

问答

0

专栏

0

资料

zhuangweiye 2017-09-20 16:39:32
认可0
[quote][url=forum.php?mod=redirect&goto=findpost&pid=64398&ptid=23582]_沉思 发表于 2017-9-20 16:32[/url]
庄工，是这样子的。我用这个程序是用来将一张图片1080p拼接成2x2图片（3840*2160）的，刚刚没有改过来， ...[/quote]

如果是拼接出来的图， 那么g_stDestFrame就必须自己填实际的值，而不是copy

实际上要测试的话很简单，create 4K的VB pool，然后从该VB pool中取VB， 然后根据这个VB填g_stDestFrame， 再send frame， 这样可以测试流程

对于实际工作时， 只是get到图后利用DMA把图像数据copy到VB的对应位置中而已
qn1549853439

qn1549853439

0个粉丝

1

问答

0

专栏

0

资料

qn1549853439 2019-08-15 12:04:56
认可0
[quote][url=forum.php?mod=redirect&goto=findpost&pid=64479&ptid=23582]_沉思 发表于 2017-9-22 01:50[/url]
解决了，多谢庄工。[/quote]

请问问题出在哪里？我也是拼图，还是这个错误号
_沉思

_沉思

0个粉丝

6

问答

0

专栏

0

资料

_沉思 2017-09-22 01:50:18
认可0
[quote]zhuangweiye 发表于 2017-9-20 16:39
如果是拼接出来的图， 那么g_stDestFrame就必须自己填实际的值，而不是copy

实际上要测试的话很简单， ...[/quote]

解决了，多谢庄工。
添加附件 添加网盘链接
或将文件直接拖到这里
悬赏：
E币
网盘
* 网盘链接：
* 提取码：
悬赏：
E币

Markdown 语法

  • 加粗**内容**
  • 斜体*内容*
  • 删除线~~内容~~
  • 引用> 引用内容
  • 代码`代码`
  • 代码块```编程语言↵代码```
  • 链接[链接标题](url)
  • 无序列表- 内容
  • 有序列表1. 内容
  • 缩进内容
  • 图片![alt](url)
+ 添加网盘链接/附件

Markdown 语法

  • 加粗**内容**
  • 斜体*内容*
  • 删除线~~内容~~
  • 引用> 引用内容
  • 代码`代码`
  • 代码块```编程语言↵代码```
  • 链接[链接标题](url)
  • 无序列表- 内容
  • 有序列表1. 内容
  • 缩进内容
  • 图片![alt](url)
相关问答
无更多相似问答 去提问
易百纳技术社区
点击登录
-- 积分
-- E币
提问
—
收益
—
被采纳
—
我要提问
社区问答
悬赏问答
举报反馈

举报类型

  • 内容涉黄/赌/毒
  • 内容侵权/抄袭
  • 政治相关
  • 涉嫌广告
  • 侮辱谩骂
  • 其他

详细说明

提醒
你的问题还没有最佳答案，是否结题，结题后将扣除20%的悬赏金
取消
确认
提醒
你的问题还没有最佳答案，是否结题，结题后将根据回答情况扣除相应悬赏金（1回答=1E币）
取消
确认
易百纳技术社区