arvin_fresh

0个粉丝

问答

专栏

资料

arvin_fresh 发布于 2017-04-15 15:40:34

采纳率 0%

5801

收藏
点赞
分享

微信扫码分享

QQ好友
举报

HI3531A解码B帧的问题

海思

各位好，目前在开发3531A的解码，想咨询各位大侠3531A（非3531）支持解码B帧吗？
我在测试解码B帧时，一旦设置解码通道参数stVdecVideoAttr.bTemporalMvpEnable为1，HI_MPI_VDEC_CreateChn就会出错，出错返回0xa0058003！

若可以解码B帧，请问怎么设置？希望大侠们给个建议，先谢谢了！！！！！！！！！

我来回答

回答9个

时间排序

认可量排序

arvin_fresh

0个粉丝

问答

专栏

资料

arvin_fresh 2017-04-17 09:45:25

认可0 回复引用举报

论坛积极性好低 ... 就没人做过吗

zhuangweiye

8个粉丝

问答

专栏

资料

zhuangweiye 2017-04-17 10:17:41

认可0 回复引用举报

本帖最后由 zhuangweiye 于 2017-4-17 10:22 编辑

支持B frame

vdec 是什么模式? privateVB/moduleVB/userVB ?

arvin_fresh

0个粉丝

问答

专栏

资料

arvin_fresh 2017-04-17 12:09:24

认可0 回复引用举报

[quote][url=forum.php?mod=redirect&goto=findpost&pid=48360&ptid=14873]zhuangweiye 发表于 2017-4-17 10:17[/url]
支持B frame

vdec 是什么模式? privateVB/moduleVB/userVB ?[/quote]

ModuleVB，目前就是使用海思自己提供的demo；
支持B帧，内存分配方式有要求？
冒昧一句，能否有相关设置支持的demo供参考一下，谢谢。

arvin_fresh

0个粉丝

问答

专栏

资料

arvin_fresh 2017-04-17 12:10:48

认可0 回复引用举报

zhuangweiye

8个粉丝

问答

专栏

资料

zhuangweiye 2017-04-17 14:18:13

认可0 回复引用举报

[quote][url=forum.php?mod=redirect&goto=findpost&pid=48381&ptid=14873]arvin_fresh 发表于 2017-4-17 12:10[/url]
你是指HI3531还是HI3531A啊？[/quote]

31A

如果是moduleVB, 那么要支持B frame, vdec专用的VB要开两组VB, 楼主的VB是如何开的

arvin_fresh

0个粉丝

问答

专栏

资料

arvin_fresh 2017-04-17 14:39:15

认可0 回复引用举报

[quote][url=forum.php?mod=redirect&goto=findpost&pid=48388&ptid=14873]zhuangweiye 发表于 2017-4-17 14:18[/url]
31A

如果是moduleVB, 那么要支持B frame, vdec专用的VB要开两组VB, 楼主的VB是如何开的[/quote]

/******************************************************************************
  Some simple Hisilicon Hi3531 system functions.

  Copyright (C), 2010-2011, Hisilicon Tech. Co., Ltd.
******************************************************************************
Modification:  2011-2 Created
******************************************************************************/
#ifdef __cplusplus
#if __cplusplus
extern "C"{
#endif
#endif /* End of #ifdef __cplusplus */

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "sample_comm.h"

#ifdef OPEN_RTP
/****************************start********************/
#include
#include
#include
#include "./rtp2es.h"
#include "./es2rtp.h"
#include "./sps.h"
/****************************end********************/
#endif

/* g_s32VBSource: 0 to module common vb, 1 to private vb, 2 to user vb
And don't forget to set the value of VBSource file "load3535" */
HI_S32 g_s32VBSource = 0;
VB_POOL g_ahVbPool[VB_MAX_POOLS] = {[0 ... (VB_MAX_POOLS-1)] = VB_INVALID_POOLID};

#define PRINTF_VDEC_CHN_STATE(Chn, stChnStat) \
do{\
         printf(" chn:%2d,  bStart:%2d, DecodeFrames:%4d,  LeftPics:%3d,  LeftBytes:%10d,  LeftFrames:%4d, RecvFrames:%6d, DecErr:%4d\n",\
            Chn,\
            stChnStat.bStartRecvStream,\
            stChnStat.u32DecodeStreamFrames,\
            stChnStat.u32LeftPics,\
            stChnStat.u32LeftStreamBytes,\
            stChnStat.u32LeftStreamFrames,\
            stChnStat.u32RecvStreamFrames,\
            stChnStat.stVdecDecErr);\
      }while(0)

HI_VOID SAMPLE_COMM_VDEC_Sysconf(VB_CONF_S *pstVbConf, SIZE_S *pstSize)
{
memset(pstVbConf, 0, sizeof(VB_CONF_S));
pstVbConf->u32MaxPoolCnt = 2;
pstVbConf->astCommPool[0].u32BlkSize = (pstSize->u32Width * pstSize->u32Height * 3) >> 1;
pstVbConf->astCommPool[0].u32BlkCnt    = 20 + 10;

#ifndef HI_FPGA
printf("[Dbg] %s %d user astCommPool[1]\n", __FUNCTION__, __LINE__);
pstVbConf->astCommPool[1].u32BlkSize = 3840*2160;
pstVbConf->astCommPool[1].u32BlkCnt    = 5 + 10;
#endif
}

HI_VOID SAMPLE_COMM_VDEC_ModCommPoolConf(VB_CONF_S *pstModVbConf,
PAYLOAD_TYPE_E enType, SIZE_S *pstSize, HI_S32 s32ChnNum)
{
HI_S32 PicSize, PmvSize;

memset(pstModVbConf, 0, sizeof(VB_CONF_S));
pstModVbConf->u32MaxPoolCnt = 2;

VB_PIC_BLK_SIZE(pstSize->u32Width, pstSize->u32Height, enType, PicSize);
pstModVbConf->astCommPool[0].u32BlkSize = PicSize;
pstModVbConf->astCommPool[0].u32BlkCnt  = 4*s32ChnNum;

/* NOTICE:
1. if the VDEC channel is H264 channel and support to decode B frame, then you should allocate PmvBuffer
2. if the VDEC channel is MPEG4 channel, then you should allocate PmvBuffer.
*/
if(PT_H265 == enType)
{
      VB_PMV_BLK_SIZE(pstSize->u32Width, pstSize->u32Height, enType, PmvSize);
      pstModVbConf->astCommPool[1].u32BlkSize = PmvSize;
      pstModVbConf->astCommPool[1].u32BlkCnt  = 4*s32ChnNum;
}
         /****  modify ****s***/
#ifdef USER_B_FRAME
      VB_PMV_BLK_SIZE(pstSize->u32Width, pstSize->u32Height, enType, PmvSize);
      pstModVbConf->astCommPool[1].u32BlkSize = PmvSize;
      pstModVbConf->astCommPool[1].u32BlkCnt  = 4*s32ChnNum;
printf("[Dbg] %s %d vdec pmv vb, u32BlkSize %d, u32BlkCnt %d\n", __FUNCTION__, __LINE__
      , pstModVbConf->astCommPool[1].u32BlkSize
      , pstModVbConf->astCommPool[1].u32BlkCnt);
#endif
         /****  modify ****e***/
}

HI_VOID SAMPLE_COMM_VDEC_ChnAttr(HI_S32 s32ChnNum,
VDEC_CHN_ATTR_S *pstVdecChnAttr, PAYLOAD_TYPE_E enType, SIZE_S *pstSize)
{
HI_S32 i;

for(i=0; i {
      pstVdecChnAttr.enType    = enType;
      pstVdecChnAttr.u32BufSize = 3 * pstSize->u32Width * pstSize->u32Height;
      pstVdecChnAttr.u32Priority  = 5;
      pstVdecChnAttr.u32PicWidth  = pstSize->u32Width;
      pstVdecChnAttr.u32PicHeight = pstSize->u32Height;
printf("pstVdecChnAttr[%d].enType=%d\n", i, pstVdecChnAttr.enType);
printf("pstVdecChnAttr[%d].u32BufSize=%d\n", i, pstVdecChnAttr.u32BufSize);
printf("pstVdecChnAttr[%d].u32Priority=%d\n", i, pstVdecChnAttr.u32Priority);
printf("pstVdecChnAttr[%d].u32PicWidth=%d\n", i, pstVdecChnAttr.u32PicWidth);
printf("pstVdecChnAttr[%d].u32PicHeight=%d\n", i, pstVdecChnAttr.u32PicHeight);
      if (PT_H264 == enType || PT_MP4VIDEO == enType)
      {
         pstVdecChnAttr.stVdecVideoAttr.enMode=VIDEO_MODE_FRAME;
         pstVdecChnAttr.stVdecVideoAttr.u32RefFrameNum = 1;
         pstVdecChnAttr.stVdecVideoAttr.bTemporalMvpEnable = 0;
         /****  modify ****s***/
#ifdef USER_B_FRAME
         pstVdecChnAttr.stVdecVideoAttr.u32RefFrameNum = 5;
         //pstVdecChnAttr.stVdecVideoAttr.bTemporalMvpEnable = 1;
#endif
         /****  modify ****e***/
printf("pstVdecChnAttr[%d].stVdecVideoAttr.enMode=%d\n", i, pstVdecChnAttr.stVdecVideoAttr.enMode);
printf("pstVdecChnAttr[%d].stVdecVideoAttr.u32RefFrameNum=%d\n", i, pstVdecChnAttr.stVdecVideoAttr.u32RefFrameNum);
printf("pstVdecChnAttr[%d].stVdecVideoAttr.bTemporalMvpEnable=%d\n", i, pstVdecChnAttr.stVdecVideoAttr.bTemporalMvpEnable);

      }
      else if (PT_JPEG == enType || PT_MJPEG == enType)
      {
         pstVdecChnAttr.stVdecJpegAttr.enMode = VIDEO_MODE_FRAME;
         pstVdecChnAttr.stVdecJpegAttr.enJpegFormat = JPG_COLOR_FMT_YCBCR420;
      }
      else if(PT_H265 == enType)
      {
         pstVdecChnAttr.stVdecVideoAttr.enMode=VIDEO_MODE_STREAM;
         pstVdecChnAttr.stVdecVideoAttr.u32RefFrameNum = 4;
         pstVdecChnAttr.stVdecVideoAttr.bTemporalMvpEnable = 1;
      }
}

}

HI_VOID SAMPLE_COMM_VDEC_VpssGrpAttr(HI_S32 s32ChnNum, VPSS_GRP_ATTR_S *pstVpssGrpAttr, SIZE_S *pstSize)
{
HI_S32 i;

for(i=0; i {
      pstVpssGrpAttr->enDieMode = VPSS_DIE_MODE_NODIE;
      pstVpssGrpAttr->bIeEn    = HI_FALSE;
      pstVpssGrpAttr->bDciEn = HI_TRUE;
      pstVpssGrpAttr->bNrEn    = HI_TRUE;
      pstVpssGrpAttr->bHistEn = HI_FALSE;
      pstVpssGrpAttr->enPixFmt  = PIXEL_FORMAT_YUV_SEMIPLANAR_420;
      pstVpssGrpAttr->u32MaxW = ALIGN_UP(pstSize->u32Width,  16);
      pstVpssGrpAttr->u32MaxH = ALIGN_UP(pstSize->u32Height, 16);
}
}

HI_VOID SAMPLE_COMM_VDEC_VoAttr(HI_S32 s32ChnNum, VO_DEV VoDev ,VO_PUB_ATTR_S *pstVoPubAttr, VO_VIDEO_LAYER_ATTR_S *pstVoLayerAttr)
{
HI_S32 u32Width, u32Height;

/*********** set the pub attr of VO ****************/
if (0 == VoDev)
{
      pstVoPubAttr->enIntfSync = VO_OUTPUT_720P50;
      pstVoPubAttr->enIntfType = VO_INTF_BT1120 | VO_INTF_VGA;
}
else if (1 == VoDev)
{
      pstVoPubAttr->enIntfSync = VO_OUTPUT_720P50;
      pstVoPubAttr->enIntfType = VO_INTF_VGA;
}
else if (VoDev>=2 && VoDev <=3)
{
      pstVoPubAttr->enIntfSync = VO_OUTPUT_PAL;
      pstVoPubAttr->enIntfType = VO_INTF_CVBS;
}
pstVoPubAttr->u32BgColor = VO_BKGRD_BLUE;

/***************** set the layer attr of VO  *******************/
if(pstVoPubAttr->enIntfSync == VO_OUTPUT_720P50)
{
      u32Width  = 1280;
      u32Height = 720;
}
else if (pstVoPubAttr->enIntfSync == VO_OUTPUT_PAL)
{
      u32Width  = 720;
      u32Height = 576;
}
pstVoLayerAttr->stDispRect.s32X    = 0;
pstVoLayerAttr->stDispRect.s32Y    = 0;
pstVoLayerAttr->stDispRect.u32Width    = u32Width;
pstVoLayerAttr->stDispRect.u32Height  = u32Height;
pstVoLayerAttr->stImageSize.u32Width  = u32Width;
pstVoLayerAttr->stImageSize.u32Height = u32Height;
pstVoLayerAttr->bDoubleFrame    = HI_FALSE;
pstVoLayerAttr->bClusterMode       = HI_FALSE;
pstVoLayerAttr->u32DispFrmRt    = 30;
pstVoLayerAttr->enPixFormat    = PIXEL_FORMAT_YUV_SEMIPLANAR_420;
}

HI_VOID SAMPLE_COMM_VDEC_ThreadParam(HI_S32 s32ChnNum, VdecThreadParam *pstVdecSend,
                                                         VDEC_CHN_ATTR_S *pstVdecChnAttr, char *pStreamFileName)
{
int i;

for(i=0; i {
      sprintf(pstVdecSend.cFileName, pStreamFileName, i);
      pstVdecSend.s32MilliSec    = 0;
      pstVdecSend.s32ChnId       = i;
      pstVdecSend.s32IntervalTime = 1;
      pstVdecSend.u64PtsInit    = 0;
      pstVdecSend.u64PtsIncrease  = 0;
      pstVdecSend.eCtrlSinal    = VDEC_CTRL_START;
      pstVdecSend.bLoopSend    = HI_TRUE;
      pstVdecSend.bManuSend    = HI_FALSE;
      pstVdecSend.enType       = pstVdecChnAttr.enType;
      pstVdecSend.s32MinBufSize = (pstVdecChnAttr.u32PicWidth * pstVdecChnAttr.u32PicHeight * 3)>>1;
      if (PT_H264 == pstVdecChnAttr.enType  || PT_MP4VIDEO == pstVdecChnAttr.enType)
      {
         pstVdecSend.s32StreamMode  = pstVdecChnAttr.stVdecVideoAttr.enMode;
      }
      else
      {
         pstVdecSend.s32StreamMode = VIDEO_MODE_FRAME;
      }
}
}

HI_VOID Sample_COMM_SetCrop(HI_S32 VpssGrp)
{
VPSS_CROP_INFO_S stCropInfo;
memset(&stCropInfo, 0, sizeof(VPSS_CROP_INFO_S));
stCropInfo.bEnable = HI_TRUE;
stCropInfo.enCropCoordinate = VPSS_CROP_ABS_COOR;
stCropInfo.stCropRect.s32X = 160;
stCropInfo.stCropRect.s32Y= 160;
stCropInfo.stCropRect.u32Width = 480;
stCropInfo.stCropRect.u32Height= 240;
HI_MPI_VPSS_SetGrpCrop(VpssGrp, &stCropInfo);
}

HI_S32 Sample_COMM_VPSS_StartCover(HI_S32 VpssGrp)
{
HI_S32 s32ChnCnt = 4;
HI_S32 j;
RGN_HANDLE hRgn;
RGN_ATTR_S stRgnAttr;
MPP_CHN_S stMppChn;
RGN_CHN_ATTR_S stRgnChnAttr;

stRgnAttr.enType = COVER_RGN;
hRgn = VpssGrp + 1;
CHECK_RET(HI_MPI_RGN_Create(hRgn, &stRgnAttr), "HI_MPI_RGN_Create");

stMppChn.enModId = HI_ID_VPSS;
stMppChn.s32DevId = VpssGrp;

stRgnChnAttr.bShow = HI_TRUE;
stRgnChnAttr.enType = stRgnAttr.enType;

stRgnChnAttr.unChnAttr.stCoverExChn.u32Layer = 0;
stRgnChnAttr.unChnAttr.stCoverExChn.stRect.s32X = 160;
stRgnChnAttr.unChnAttr.stCoverExChn.stRect.s32Y = 160;
stRgnChnAttr.unChnAttr.stCoverExChn.stRect.u32Width = 480;
stRgnChnAttr.unChnAttr.stCoverExChn.stRect.u32Height = 240;
stRgnChnAttr.unChnAttr.stCoverExChn.u32Color = 0xff;
stRgnChnAttr.unChnAttr.stCoverExChn.enCoverType = AREA_RECT;

for (j = 0; j < s32ChnCnt; j++)
{
      if(j==1)/*chn12--§3-cover*/
{
         continue;
      }
      stRgnChnAttr.unChnAttr.stCoverExChn.u32Layer = 1;
      //stRgnChnAttr.unChnAttr.stCoverExChn.u32Color = 0xadcde + j * 100000;
      stMppChn.s32ChnId = j;
      CHECK_RET(HI_MPI_RGN_AttachToChn(hRgn, &stMppChn, &stRgnChnAttr), "HI_MPI_RGN_AttachToChn");
}

return HI_SUCCESS;
}

HI_VOID Sample_MST_GetDefVoAttr(VO_DEV VoDev,
      VO_PUB_ATTR_S *pstPubAttr, VO_VIDEO_LAYER_ATTR_S *pstLayerAttr,
      HI_S32 s32SquareSort, VO_CHN_ATTR_S *astChnAttr)
{
HI_U32 u32Frmt, u32Width, u32Height, j;

u32Width = 720;
u32Height = 576;
u32Frmt = 25;
HI_MPI_VO_GetPubAttr(VoDev, pstPubAttr);
if (NULL != pstPubAttr)
{
      pstPubAttr->enIntfSync = VO_OUTPUT_PAL;
      pstPubAttr->enIntfType = VO_INTF_VGA;
}

HI_MPI_VO_GetVideoLayerAttr(VoDev, pstLayerAttr);
//HI_MPI_VO_GetVideoLayerPartitionMode(VoDev, VO_PART_MODE_MULTI);
if (NULL != pstLayerAttr)
{
      pstLayerAttr->stDispRect.s32X    = 0;
      pstLayerAttr->stDispRect.s32Y    = 0;
      pstLayerAttr->stDispRect.u32Width = u32Width;
      pstLayerAttr->stDispRect.u32Height  = u32Height;
      pstLayerAttr->stImageSize.u32Width  = u32Width;
      pstLayerAttr->stImageSize.u32Height = u32Height;
      pstLayerAttr->u32DispFrmRt       = u32Frmt;
      //pstLayerAttr->u32DispFrmRt       = 30;
      pstLayerAttr->enPixFormat          = PIXEL_FORMAT_YUV_SEMIPLANAR_420;
      pstLayerAttr->bDoubleFrame       = HI_FALSE;
      pstLayerAttr->bClusterMode       = HI_FALSE;
}

if (NULL != astChnAttr)
{
      for (j=0; j<(s32SquareSort * s32SquareSort); j++)
      {
         astChnAttr[j].stRect.s32X    = ALIGN_BACK((u32Width/s32SquareSort) * (j%s32SquareSort), 2);
         astChnAttr[j].stRect.s32Y    = ALIGN_BACK((u32Height/s32SquareSort) * (j/s32SquareSort), 2);
         astChnAttr[j].stRect.u32Width = ALIGN_BACK(u32Width/s32SquareSort, 2);
         astChnAttr[j].stRect.u32Height  = ALIGN_BACK(u32Height/s32SquareSort, 2);
         astChnAttr[j].u32Priority    = 0;
         astChnAttr[j].bDeflicker       = HI_TRUE;
      }
}

return ;
}

HI_VOID Sample_MST_StartPIPVideoLayer(VO_DEV VoDev, VO_VIDEO_LAYER_ATTR_S *pstLayerAttr,
VO_CHN_ATTR_S *astChnAttr, HI_S32 s32ChnNum)
{
HI_U32 i;

//enVoPartitionMode = VO_PART_MODE_MULTI;
HI_MPI_VO_SetVideoLayerPartitionMode(VO_LAYER_PIP, VO_PART_MODE_MULTI);
if (VO_DEV_HD_END == VoDev)
{
      HI_MPI_VO_UnBindVideoLayer(VO_LAYER_PIP, 0);
}
HI_MPI_VO_BindVideoLayer(VO_LAYER_PIP, VoDev);
HI_MPI_VO_SetVideoLayerAttr(VO_LAYER_PIP, pstLayerAttr);
HI_MPI_VO_EnableVideoLayer(VO_LAYER_PIP);

for (i = 0; i < s32ChnNum; i++)
{
      HI_MPI_VO_SetChnAttr(VO_LAYER_PIP, i, &astChnAttr);
      HI_MPI_VO_EnableChn(VO_LAYER_PIP, i);
}
}

HI_S32 SAMPLE_COMM_VDEC_InitModCommVb(VB_CONF_S *pstModVbConf)
{
HI_S32 i;
HI_S32 s32Ret;

HI_MPI_VB_ExitModCommPool(VB_UID_VDEC);

if(0 == g_s32VBSource)
{
      CHECK_RET(HI_MPI_VB_SetModPoolConf(VB_UID_VDEC, pstModVbConf), "HI_MPI_VB_SetModPoolConf");
      CHECK_RET(HI_MPI_VB_InitModCommPool(VB_UID_VDEC), "HI_MPI_VB_InitModCommPool");
}
else if (2 == g_s32VBSource)
{
      if (pstModVbConf->u32MaxPoolCnt > VB_MAX_POOLS)
      {
         printf("vb pool num(%d) is larger than VB_MAX_POOLS. \n", pstModVbConf->u32MaxPoolCnt);
         return HI_FAILURE;
      }
      for (i = 0; i < pstModVbConf->u32MaxPoolCnt; i++)
      {
         if (pstModVbConf->astCommPool.u32BlkSize && pstModVbConf->astCommPool.u32BlkCnt)
         {
            g_ahVbPool = HI_MPI_VB_CreatePool(pstModVbConf->astCommPool.u32BlkSize,
                  pstModVbConf->astCommPool.u32BlkCnt, NULL);
            if (VB_INVALID_POOLID == g_ahVbPool)
                  goto fail;
         }
      }
      return HI_SUCCESS;

fail:
      for (;i>=0;i--)
      {
         if (VB_INVALID_POOLID != g_ahVbPool)
         {
            s32Ret = HI_MPI_VB_DestroyPool(g_ahVbPool);
            HI_ASSERT(HI_SUCCESS == s32Ret);
            g_ahVbPool = VB_INVALID_POOLID;
         }
      }
      return HI_FAILURE;
}

return HI_SUCCESS;
}

HI_VOID * SAMPLE_COMM_VDEC_SendStream(HI_VOID *pArgs)
{
VdecThreadParam *pstVdecThreadParam =(VdecThreadParam *)pArgs;
FILE *fpStrm=NULL;
HI_U8 *pu8Buf = NULL;
VDEC_STREAM_S stStream;
HI_BOOL bFindStart, bFindEnd;
HI_S32 s32Ret,  i,  start = 0;
HI_S32 s32UsedBytes = 0, s32ReadLen = 0;
HI_U64 u64pts = 0;
HI_S32 len;
HI_BOOL sHasReadStream = HI_FALSE;

if(pstVdecThreadParam->cFileName != 0)
{
      fpStrm = fopen(pstVdecThreadParam->cFileName, "rb");
      if(fpStrm == NULL)
      {
         printf("SAMPLE_TEST:can't open file %s in send stream thread:%d\n",pstVdecThreadParam->cFileName, pstVdecThreadParam->s32ChnId);
         return (HI_VOID *)(HI_FAILURE);
      }
}
//printf("SAMPLE_TEST:chn %d, stream file:%s, bufsize: %d\n",
//pstVdecThreadParam->s32ChnId, pstVdecThreadParam->cFileName, pstVdecThreadParam->s32MinBufSize);

pu8Buf = malloc(pstVdecThreadParam->s32MinBufSize);
if(pu8Buf == NULL)
{
      printf("SAMPLE_TEST:can't alloc %d in send stream thread:%d\n", pstVdecThreadParam->s32MinBufSize, pstVdecThreadParam->s32ChnId);
      fclose(fpStrm);
      return (HI_VOID *)(HI_FAILURE);
}
fflush(stdout);

u64pts = pstVdecThreadParam->u64PtsInit;
while (1)
{
      if (pstVdecThreadParam->eCtrlSinal == VDEC_CTRL_STOP)
      {
         break;
      }
      else if (pstVdecThreadParam->eCtrlSinal == VDEC_CTRL_PAUSE)
      {
         sleep(MIN2(pstVdecThreadParam->s32IntervalTime,1000));
         continue;
      }

      if ( (pstVdecThreadParam->s32StreamMode==VIDEO_MODE_FRAME) && (pstVdecThreadParam->enType == PT_MP4VIDEO) )
      {
         bFindStart = HI_FALSE;
         bFindEnd = HI_FALSE;
         fseek(fpStrm, s32UsedBytes, SEEK_SET);
         s32ReadLen = fread(pu8Buf, 1, pstVdecThreadParam->s32MinBufSize, fpStrm);
         if (s32ReadLen == 0)
         {
            if (pstVdecThreadParam->bLoopSend)
            {
                  s32UsedBytes = 0;
                  fseek(fpStrm, 0, SEEK_SET);
                  s32ReadLen = fread(pu8Buf, 1, pstVdecThreadParam->s32MinBufSize, fpStrm);
            }
            else
            {
                  break;
            }
         }

         for (i=0; i          {
            if (pu8Buf == 0 && pu8Buf[i+1] == 0 && pu8Buf[i+2] == 1 && pu8Buf[i+3] == 0xB6)
            {
                  bFindStart = HI_TRUE;
                  i += 4;
                  break;
            }
         }

         for (; i          {
            if (pu8Buf[i  ] == 0 && pu8Buf[i+1] == 0 && pu8Buf[i+2] == 1 && pu8Buf[i+3] == 0xB6)
            {
                  bFindEnd = HI_TRUE;
                  break;
            }
         }

         s32ReadLen = i;
         if (bFindStart == HI_FALSE)
         {
            printf("SAMPLE_TEST: chn %d can not find start code! s32ReadLen %d, s32UsedBytes %d. \n",
                        pstVdecThreadParam->s32ChnId, s32ReadLen, s32UsedBytes);
         }
         else if (bFindEnd == HI_FALSE)
         {
            s32ReadLen = i+4;
         }

      }
      else if ( (pstVdecThreadParam->s32StreamMode==VIDEO_MODE_FRAME) && (pstVdecThreadParam->enType == PT_H264) )
      {
         bFindStart = HI_FALSE;
         bFindEnd = HI_FALSE;
         fseek(fpStrm, s32UsedBytes, SEEK_SET);
         s32ReadLen = fread(pu8Buf, 1, pstVdecThreadParam->s32MinBufSize, fpStrm);
         if (s32ReadLen == 0)
         {
            if (pstVdecThreadParam->bLoopSend)
            {
                  s32UsedBytes = 0;
                  fseek(fpStrm, 0, SEEK_SET);
                  s32ReadLen = fread(pu8Buf, 1, pstVdecThreadParam->s32MinBufSize, fpStrm);
            }
            else
            {
                  break;
            }
         }

         for (i=0; i          {
            if (  pu8Buf[i  ] == 0 && pu8Buf[i+1] == 0 && pu8Buf[i+2] == 1 &&
                  ( (pu8Buf[i+3]&0x1F) == 0x5 || (pu8Buf[i+3]&0x1F) == 0x1 ) &&
                  ( (pu8Buf[i+4]&0x80) == 0x80)
               )
            {
                  bFindStart = HI_TRUE;
                  i += 4;
                  break;
            }
         }

         for (; i          {
            if (  pu8Buf[i  ] == 0 && pu8Buf[i+1] == 0 && pu8Buf[i+2] == 1 &&
( ((pu8Buf[i+3]&0x1F) == 0x7) || ((pu8Buf[i+3]&0x1F) == 0x8) || ((pu8Buf[i+3]&0x1F) == 0x6)
                  || (((pu8Buf[i+3]&0x1F) == 0x5 || (pu8Buf[i+3]&0x1F) == 0x1) &&((pu8Buf[i+4]&0x80) == 0x80))
                  )
               )
            {
                  bFindEnd = HI_TRUE;
                  break;
            }
         }

         if(i > 0) s32ReadLen = i;
         if (bFindStart == HI_FALSE)
         {
            printf("SAMPLE_TEST: chn %d can not find start code!s32ReadLen %d, s32UsedBytes %d. \n",
                        pstVdecThreadParam->s32ChnId, s32ReadLen, s32UsedBytes);
         }
         else if (bFindEnd == HI_FALSE)
         {
            s32ReadLen = i+5;
         }

      }
      else if ((pstVdecThreadParam->enType == PT_MJPEG) )
      {
         bFindStart = HI_FALSE;
         bFindEnd = HI_FALSE;
         fseek(fpStrm, s32UsedBytes, SEEK_SET);
         s32ReadLen = fread(pu8Buf, 1, pstVdecThreadParam->s32MinBufSize, fpStrm);
         if (s32ReadLen == 0)
         {
            if (pstVdecThreadParam->bLoopSend)
            {
                  s32UsedBytes = 0;
                  fseek(fpStrm, 0, SEEK_SET);
                  s32ReadLen = fread(pu8Buf, 1, pstVdecThreadParam->s32MinBufSize, fpStrm);
            }
            else
            {
                  break;
            }
         }


         for (i=0; i          {
            if (pu8Buf == 0xFF && pu8Buf[i+1] == 0xD8)
            {
                  start = i;
                  bFindStart = HI_TRUE;
                  i = i + 2;
                  break;
            }
         }

         for (; i          {
            if ( (pu8Buf == 0xFF) && (pu8Buf[i+1]& 0xF0) == 0xE0 )
            {
                  len = (pu8Buf[i+2]<<8) + pu8Buf[i+3];
                  i += 1 + len;
            }
            else
            {
                  break;
            }
         }

         for (; i          {
            if (pu8Buf == 0xFF && pu8Buf[i+1] == 0xD8)
            {
                  bFindEnd = HI_TRUE;
                  break;
            }
         }
         s32ReadLen = i;
         if (bFindStart == HI_FALSE)
         {
            printf("SAMPLE_TEST: chn %d can not find start code! s32ReadLen %d, s32UsedBytes %d. \n",
                        pstVdecThreadParam->s32ChnId, s32ReadLen, s32UsedBytes);
         }
         else if (bFindEnd == HI_FALSE)
         {
            s32ReadLen = i+2;
         }
      }
      else if ((pstVdecThreadParam->enType == PT_JPEG) )
      {
         if (HI_TRUE != sHasReadStream)
         {

            bFindStart = HI_FALSE;
            bFindEnd = HI_FALSE;

            fseek(fpStrm, s32UsedBytes, SEEK_SET);
            s32ReadLen = fread(pu8Buf, 1, pstVdecThreadParam->s32MinBufSize, fpStrm);
            if (s32ReadLen == 0)
            {
                  if (pstVdecThreadParam->bLoopSend)
                  {
                     s32UsedBytes = 0;
                     fseek(fpStrm, 0, SEEK_SET);
                     s32ReadLen = fread(pu8Buf, 1, pstVdecThreadParam->s32MinBufSize, fpStrm);
                  }
                  else
                  {
                     break;
                  }
            }


            for (i=0; i             {
                  if (pu8Buf == 0xFF && pu8Buf[i+1] == 0xD8)
                  {
                     start = i;
                     bFindStart = HI_TRUE;
                     i = i + 2;
                     break;
                  }
            }

            for (; i             {
                  if ( (pu8Buf == 0xFF) && (pu8Buf[i+1]& 0xF0) == 0xE0 )
                  {
                     len = (pu8Buf[i+2]<<8) + pu8Buf[i+3];
                     i += 1 + len;
                  }
                  else
                  {
                     break;
                  }
            }

            for (; i             {
                  if (pu8Buf == 0xFF && pu8Buf[i+1] == 0xD8)
                  {
                     bFindEnd = HI_TRUE;
                     break;
                  }
            }
            s32ReadLen = i;
            if (bFindStart == HI_FALSE)
            {
                  printf("SAMPLE_TEST: chn %d can not find start code! s32ReadLen %d, s32UsedBytes %d. \n",
                        pstVdecThreadParam->s32ChnId, s32ReadLen, s32UsedBytes);
            }
            else if (bFindEnd == HI_FALSE)
            {
                  s32ReadLen = i+2;
            }
               sHasReadStream = HI_TRUE;
         }
      }
      else
      {
         fseek(fpStrm, s32UsedBytes, SEEK_SET);
         s32ReadLen = fread(pu8Buf, 1, pstVdecThreadParam->s32MinBufSize, fpStrm);
         if (s32ReadLen == 0)
         {
            if (pstVdecThreadParam->bLoopSend)
            {
                  s32UsedBytes = 0;
                  fseek(fpStrm, 0, SEEK_SET);
                  s32ReadLen = fread(pu8Buf, 1, pstVdecThreadParam->s32MinBufSize, fpStrm);
            }
            else
            {
                  break;
            }
         }
      }

      stStream.u64PTS  = u64pts;
      stStream.pu8Addr = pu8Buf + start;
      stStream.u32Len  = s32ReadLen;
      stStream.bEndOfFrame  = (pstVdecThreadParam->s32StreamMode==VIDEO_MODE_FRAME)? HI_TRUE: HI_FALSE;
      stStream.bEndOfStream = HI_FALSE;


      //printf("Send One Frame");
      //fflush(stdout);

      s32Ret=HI_MPI_VDEC_SendStream(pstVdecThreadParam->s32ChnId, &stStream, pstVdecThreadParam->s32MilliSec);
      pstVdecThreadParam->cUserCmd = 0;
      if (HI_SUCCESS != s32Ret)
      {
         usleep(100);
      }
      else
      {
         s32UsedBytes = s32UsedBytes +s32ReadLen + start;
         u64pts += pstVdecThreadParam->u64PtsIncrease;
      }
   usleep(1000);
}

/* send the flag of stream end */
memset(&stStream, 0, sizeof(VDEC_STREAM_S) );
stStream.bEndOfStream = HI_TRUE;
HI_MPI_VDEC_SendStream(pstVdecThreadParam->s32ChnId, &stStream, -1);

//printf("SAMPLE_TEST:send steam thread %d return ...\n", pstVdecThreadParam->s32ChnId);
fflush(stdout);
if (pu8Buf != HI_NULL)
{
      free(pu8Buf);
}
fclose(fpStrm);

return (HI_VOID *)HI_SUCCESS;
}

HI_VOID * SAMPLE_COMM_VDEC_GetChnLuma(HI_VOID *pArgs)
{
VDEC_CHN_LUM_S stLumaPix;
VdecThreadParam *pstVdecThreadParam =(VdecThreadParam *)pArgs;
HI_BOOL bRunFlag = HI_TRUE;
HI_S32 s32Ret;
FILE *fpLuma = HI_NULL;
HI_CHAR FileName[128];
HI_CHAR acString[128];

snprintf(FileName, 128, "LumaPixChn%d.txt", pstVdecThreadParam->s32ChnId);
fpLuma=fopen(FileName, "w+");
if(fpLuma == NULL)
{
      printf("SAMPLE_TEST:can't open file %s in get luma thread:%d\n", pstVdecThreadParam->cFileName, pstVdecThreadParam->s32ChnId);
      return (HI_VOID *)(HI_FAILURE);
}

while(1)
{
      switch(pstVdecThreadParam->eCtrlSinal)
      {
         case VDEC_CTRL_START:
            s32Ret = HI_MPI_VDEC_GetChnLuma(pstVdecThreadParam->s32ChnId, &stLumaPix);
            if (HI_SUCCESS == s32Ret)
            {
                  memset(acString, 0, 128);
                  sprintf(acString, "chn %d,  Pts = %lld,  LumPixSum = %lld,  LumPixAverage=%d!    \n",
                  pstVdecThreadParam->s32ChnId, stLumaPix.u64Pts, stLumaPix.u64LumPixSum,stLumaPix.u32LumPixAverage);
                  fprintf(fpLuma, "%s\n", acString);
            }
            break;

         case VDEC_CTRL_PAUSE:
            sleep(MIN2(pstVdecThreadParam->s32IntervalTime,1000));
            break;

         case VDEC_CTRL_STOP:
            bRunFlag=HI_FALSE;
            break;

         default:
            printf("SAMPLE_TEST:unknow command in get luma thread %d\n", pstVdecThreadParam->s32ChnId);
            bRunFlag=HI_FALSE;
            break;
      }
      usleep(40000);
      if(bRunFlag==HI_FALSE)
      {
         break;
      }
}
printf("SAMPLE_TEST:get LumaPix thread %d return ...\n", pstVdecThreadParam->s32ChnId);
fclose(fpLuma);

return (HI_VOID *)HI_SUCCESS;
}

HI_VOID SAMPLE_COMM_VDEC_CmdCtrl(HI_S32 s32ChnNum,VdecThreadParam *pstVdecSend)
{
HI_S32 i;
HI_S32 s32FrameRate = 0;
HI_BOOL /*bIsPause = HI_FALSE, */bVoPause = HI_FALSE;
VDEC_CHN_STAT_S stStat;
char c=0;
      for (i=0; i       pstVdecSend.cUserCmd = 0;
while(1)
{
      printf("\nSAMPLE_TEST:press 'e' to exit; 'p' to pause/resume; 'q' to query!;'s' to step!;'a' to add!;'d' to sub!;\n");

      c = getchar();
      if(10 == c)
      {
         continue;
      }
      getchar();
      if (c == 'e')
      {
         for (i=0; i          pstVdecSend.cUserCmd = 0;
         break;
      }
//       else if (c == 'r')
//       {
//          if (bIsPause)
//          {
//             for (i=0; i //             pstVdecSend.eCtrlSinal = VDEC_CTRL_PAUSE;
//          }
//          else
//          {
//             for (i=0; i //             pstVdecSend.eCtrlSinal = VDEC_CTRL_START;
//          }
//          bIsPause = !bIsPause;
//
//       }
      else if (c == 'p')
      {
         if (bVoPause)
         {
            HI_MPI_VO_ResumeChn(0, 0);
            HI_MPI_VO_ResumeChn(1, 0);
            printf("VO Resume.");
         }
         else
         {
            HI_MPI_VO_PauseChn(0, 0);
            HI_MPI_VO_PauseChn(1, 0);
            printf("VO Pause.");
         }
         bVoPause = !bVoPause;
      }
      else if (c == 'a')
      {
         for(i = 0; i < 2; i++)
         {
            HI_MPI_VO_GetChnFrameRate(i, 0, &s32FrameRate);
            if (s32FrameRate >= 120)
            {
                  printf("VO layer %d is larger than 120.", i);
                  continue;
            }
            s32FrameRate += 10;
            HI_MPI_VO_SetChnFrameRate(i, 0, s32FrameRate);
            printf("VO layer %d is set to %d.", i, s32FrameRate);
         }
      }
      else if (c == 'd')
      {
         for(i = 0; i < 2; i++)
         {
            HI_MPI_VO_GetChnFrameRate(i, 0, &s32FrameRate);
            if (s32FrameRate < 10)
            {
                  printf("VO layer %d is less than 10.", i);
                  continue;
            }
            s32FrameRate -= 10;
            HI_MPI_VO_SetChnFrameRate(i, 0, s32FrameRate);
            printf("VO layer %d is set to %d.", i, s32FrameRate);
         }
      }
      else if (c == 's')
      {
         if (bVoPause == HI_FALSE)
         {
            printf("Firstly press 'p' to pause,then step.");
            continue;
         }
         HI_MPI_VO_StepChn(0, 0);
         HI_MPI_VO_StepChn(1, 0);
         printf("VO Step.");
      }
      else if (c == 'q')
      {
         for (i=0; i          {
            HI_MPI_VDEC_Query(pstVdecSend.s32ChnId, &stStat);
            PRINTF_VDEC_CHN_STATE(pstVdecSend.s32ChnId, stStat);
         }
      }
      fflush(stdout);
}
}

HI_VOID SAMPLE_COMM_VDEC_StartSendStream(HI_S32 s32ChnNum, VdecThreadParam *pstVdecSend, pthread_t *pVdecThread)
{
HI_S32  i;

for(i=0; i {
      pthread_create(&pVdecThread, 0, SAMPLE_COMM_VDEC_SendStream, (HI_VOID *)&pstVdecSend);
}
}

HI_VOID SAMPLE_COMM_VDEC_StopSendStream(HI_S32 s32ChnNum, VdecThreadParam *pstVdecSend, pthread_t *pVdecThread)
{
HI_S32  i;

for(i=0; i {
      HI_MPI_VDEC_StopRecvStream(i);
      pstVdecSend.eCtrlSinal=VDEC_CTRL_STOP;
      pthread_join(pVdecThread, HI_NULL);
}
}

HI_VOID SAMPLE_COMM_VDEC_StartGetLuma(HI_S32 s32ChnNum, VdecThreadParam *pstVdecSend, pthread_t *pVdecThread)
{
HI_S32  i;

for(i=0; i {
      pthread_create(&pVdecThread[i+VDEC_MAX_CHN_NUM], 0, SAMPLE_COMM_VDEC_GetChnLuma, (HI_VOID *)&pstVdecSend);
}
}

HI_VOID SAMPLE_COMM_VDEC_StopGetLuma(HI_S32 s32ChnNum, VdecThreadParam *pstVdecSend, pthread_t *pVdecThread)
{
HI_S32  i;

for(i=0; i {
      pstVdecSend.eCtrlSinal = VDEC_CTRL_STOP;
      pthread_join(pVdecThread[i+VDEC_MAX_CHN_NUM], HI_NULL);
}
}

HI_S32 SAMPLE_COMM_VDEC_Start(HI_S32 s32ChnNum, VDEC_CHN_ATTR_S *pstAttr)
{
HI_S32  i;
HI_U32 u32BlkCnt = 10;
VDEC_CHN_POOL_S stPool;

for(i=0; i {
      if(1 == g_s32VBSource)
      {
         CHECK_CHN_RET(HI_MPI_VDEC_SetChnVBCnt(i, u32BlkCnt), i, "HI_MPI_VDEC_SetChnVBCnt");
      }
      CHECK_CHN_RET(HI_MPI_VDEC_CreateChn(i, &pstAttr), i, "HI_MPI_VDEC_CreateChn");
      /**  modify ****s*/
#ifdef USER_B_FRAME
      VDEC_CHN_PARAM_S decChnPrm;
      HI_S32 tmpRet = HI_MPI_VDEC_GetChnParam(i, &decChnPrm);
      if (tmpRet != 0)
      {
         printf("[Err] HI_MPI_VDEC_GetChnParam return 0x%x\n", tmpRet);
      } else{

         printf("=======>[before]dec chn %d s32DecMode %d\n", i, decChnPrm.s32DecMode);
         decChnPrm.s32DecMode = 0;// i p b frame
         //decChnPrm.s32DecMode = 1;// i p frame
         CHECK_CHN_RET(HI_MPI_VDEC_SetChnParam(i, &decChnPrm), i, "HI_MPI_VDEC_SetChnParam");
      }
#endif
      int tmpDispMode = 0;
      CHECK_CHN_RET(HI_MPI_VDEC_GetDisplayMode(i, &tmpDispMode), i, "HI_MPI_VDEC_GetDisplayMode");
      printf("============>before get vdec display mode %d\n", tmpDispMode);

      //CHECK_CHN_RET(HI_MPI_VDEC_SetDisplayMode(i, VIDEO_DISPLAY_MODE_PREVIEW), i, "HI_MPI_VDEC_SetDisplayMode");
      CHECK_CHN_RET(HI_MPI_VDEC_SetDisplayMode(i, VIDEO_DISPLAY_MODE_PLAYBACK), i, "HI_MPI_VDEC_SetDisplayMode");
      CHECK_CHN_RET(HI_MPI_VDEC_GetDisplayMode(i, &tmpDispMode), i, "HI_MPI_VDEC_GetDisplayMode");
      printf("============>after get vdec display mode %d\n", tmpDispMode);

      /**  modify ****e*/
      if (2 == g_s32VBSource)
      {
         stPool.hPicVbPool = g_ahVbPool[0];
         stPool.hPmvVbPool = -1;
         CHECK_CHN_RET(HI_MPI_VDEC_AttachVbPool(i, &stPool), i, "HI_MPI_VDEC_AttachVbPool");
      }
      CHECK_CHN_RET(HI_MPI_VDEC_StartRecvStream(i), i, "HI_MPI_VDEC_StartRecvStream");
      //CHECK_CHN_RET(HI_MPI_VDEC_SetDisplayMode(i, VIDEO_DISPLAY_MODE_PREVIEW), i, "HI_MPI_VDEC_SetDisplayMode");
}

return HI_SUCCESS;
}

HI_S32 SAMPLE_COMM_VDEC_Stop(HI_S32 s32ChnNum)
{
HI_S32 i;

for(i=0; i {
      CHECK_CHN_RET(HI_MPI_VDEC_StopRecvStream(i), i, "HI_MPI_VDEC_StopRecvStream");
      CHECK_CHN_RET(HI_MPI_VDEC_DestroyChn(i), i, "HI_MPI_VDEC_DestroyChn");
}

return HI_SUCCESS;
}

HI_S32 SAMPLE_COMM_VDEC_BindVpss(VDEC_CHN VdChn, VPSS_GRP VpssGrp)
{
MPP_CHN_S stSrcChn;
MPP_CHN_S stDestChn;

stSrcChn.enModId = HI_ID_VDEC;
stSrcChn.s32DevId = 0;
stSrcChn.s32ChnId = VdChn;

stDestChn.enModId = HI_ID_VPSS;
stDestChn.s32DevId = VpssGrp;
stDestChn.s32ChnId = 0;

CHECK_RET(HI_MPI_SYS_Bind(&stSrcChn, &stDestChn), "HI_MPI_SYS_Bind");

return HI_SUCCESS;
}

HI_S32 SAMPLE_COMM_VDEC_BindVo(VDEC_CHN VdChn, VO_LAYER VoLayer, VO_CHN VoChn)
{
MPP_CHN_S stSrcChn;
MPP_CHN_S stDestChn;

stSrcChn.enModId = HI_ID_VDEC;
stSrcChn.s32DevId = 0;
stSrcChn.s32ChnId = VdChn;

stDestChn.enModId = HI_ID_VOU;
stDestChn.s32DevId = VoLayer;
stDestChn.s32ChnId = VoChn;

CHECK_RET(HI_MPI_SYS_Bind(&stSrcChn, &stDestChn), "HI_MPI_SYS_Bind");

return HI_SUCCESS;
}

HI_S32 SAMPLE_COMM_VDEC_UnBindVpss(VDEC_CHN VdChn, VPSS_GRP VpssGrp)
{
MPP_CHN_S stSrcChn;
MPP_CHN_S stDestChn;

stSrcChn.enModId = HI_ID_VDEC;
stSrcChn.s32DevId = 0;
stSrcChn.s32ChnId = VdChn;

stDestChn.enModId = HI_ID_VPSS;
stDestChn.s32DevId = VpssGrp;
stDestChn.s32ChnId = 0;

CHECK_RET(HI_MPI_SYS_UnBind(&stSrcChn, &stDestChn), "HI_MPI_SYS_UnBind");

return HI_SUCCESS;
}

HI_S32 SAMPLE_COMM_VDEC_UnBindVo(VDEC_CHN VdChn, VO_LAYER VoLayer, VO_CHN VoChn)
{
MPP_CHN_S stSrcChn;
MPP_CHN_S stDestChn;

stSrcChn.enModId = HI_ID_VDEC;
stSrcChn.s32DevId = 0;
stSrcChn.s32ChnId = VdChn;

stDestChn.enModId = HI_ID_VOU;
stDestChn.s32DevId = VoLayer;
stDestChn.s32ChnId = VoChn;

CHECK_RET(HI_MPI_SYS_UnBind(&stSrcChn, &stDestChn), "HI_MPI_SYS_UnBind");

return HI_SUCCESS;
}

/******************************************************************************
* function : Set system memory location
******************************************************************************/
HI_S32 SAMPLE_COMM_VDEC_MemConfig(HI_VOID)
{
HI_S32 i = 0;
HI_S32 s32Ret = HI_SUCCESS;

HI_CHAR * pcMmzName;
MPP_CHN_S stMppChnVDEC;

/* VDEC chn max is 80*/
for(i=0; i<80; i++)
{
      stMppChnVDEC.enModId = HI_ID_VDEC;
      stMppChnVDEC.s32DevId = 0;
      stMppChnVDEC.s32ChnId = i;

      if(0 == (i%2))
      {
         pcMmzName = NULL;
      }
      else
      {
         pcMmzName = "ddr1";
      }

      s32Ret = HI_MPI_SYS_SetMemConf(&stMppChnVDEC,pcMmzName);
      if (s32Ret)
      {
         SAMPLE_PRT("HI_MPI_SYS_SetMemConf ERR !\n");
         return HI_FAILURE;
      }
}

return HI_SUCCESS;
}

#ifdef __cplusplus
#if __cplusplus
}
#endif
#endif /* End of #ifdef __cplusplus */

arvin_fresh

0个粉丝

5

问答

0

专栏

1

资料

arvin_fresh 2017-04-17 14:42:36

认可0 回复引用举报

[quote][url=forum.php?mod=redirect&goto=findpost&pid=48388&ptid=14873]zhuangweiye 发表于 2017-4-17 14:18[/url]
31A

如果是moduleVB, 那么要支持B frame, vdec专用的VB要开两组VB, 楼主的VB是如何开的[/quote]

自己主要修改了以下两个函数，修改部分为黑色粗体（USER_B_FRAME在编译里已定义）

HI_VOID       SAMPLE_COMM_VDEC_ModCommPoolConf(VB_CONF_S *pstModVbConf,
PAYLOAD_TYPE_E enType, SIZE_S *pstSize, HI_S32 s32ChnNum)
{
HI_S32 PicSize, PmvSize;

memset(pstModVbConf, 0, sizeof(VB_CONF_S));
pstModVbConf->u32MaxPoolCnt = 2;

VB_PIC_BLK_SIZE(pstSize->u32Width, pstSize->u32Height, enType, PicSize);
pstModVbConf->astCommPool[0].u32BlkSize = PicSize;
pstModVbConf->astCommPool[0].u32BlkCnt  = 4*s32ChnNum;

/* NOTICE:
1. if the VDEC channel is H264 channel and support to decode B frame, then you should allocate PmvBuffer
2. if the VDEC channel is MPEG4 channel, then you should allocate PmvBuffer.
*/
if(PT_H265 == enType)
{
      VB_PMV_BLK_SIZE(pstSize->u32Width, pstSize->u32Height, enType, PmvSize);
      pstModVbConf->astCommPool[1].u32BlkSize = PmvSize;
      pstModVbConf->astCommPool[1].u32BlkCnt  = 4*s32ChnNum;
}
         /****  modify ****s***/
#ifdef USER_B_FRAME
   VB_PMV_BLK_SIZE(pstSize->u32Width, pstSize->u32Height, enType, PmvSize);
      pstModVbConf->astCommPool[1].u32BlkSize = PmvSize;
      pstModVbConf->astCommPool[1].u32BlkCnt  = 4*s32ChnNum;
printf("[Dbg] %s %d vdec pmv vb, u32BlkSize %d, u32BlkCnt %d\n", __FUNCTION__, __LINE__
      , pstModVbConf->astCommPool[1].u32BlkSize
      , pstModVbConf->astCommPool[1].u32BlkCnt);
#endif
         /****  modify ****e***/
}

HI_S32 SAMPLE_COMM_VDEC_Start(HI_S32 s32ChnNum, VDEC_CHN_ATTR_S *pstAttr)
{
HI_S32  i;
HI_U32 u32BlkCnt = 10;
VDEC_CHN_POOL_S stPool;

for(i=0; i {
      if(1 == g_s32VBSource)
      {
         CHECK_CHN_RET(HI_MPI_VDEC_SetChnVBCnt(i, u32BlkCnt), i, "HI_MPI_VDEC_SetChnVBCnt");
      }
      CHECK_CHN_RET(HI_MPI_VDEC_CreateChn(i, &pstAttr), i, "HI_MPI_VDEC_CreateChn");
      /**  modify ****s*/
#ifdef USER_B_FRAME
      VDEC_CHN_PARAM_S decChnPrm;
      HI_S32 tmpRet = HI_MPI_VDEC_GetChnParam(i, &decChnPrm);
      if (tmpRet != 0)
      {
         printf("[Err] HI_MPI_VDEC_GetChnParam return 0x%x\n", tmpRet);
      } else{

         printf("=======>[before]dec chn %d s32DecMode %d\n", i, decChnPrm.s32DecMode);
         decChnPrm.s32DecMode = 0;// i p b frame
         //decChnPrm.s32DecMode = 1;// i p frame
         CHECK_CHN_RET(HI_MPI_VDEC_SetChnParam(i, &decChnPrm), i, "HI_MPI_VDEC_SetChnParam");
      }
#endif
      int tmpDispMode = 0;
      CHECK_CHN_RET(HI_MPI_VDEC_GetDisplayMode(i, &tmpDispMode), i, "HI_MPI_VDEC_GetDisplayMode");
      printf("============>before get vdec display mode %d\n", tmpDispMode);

      //CHECK_CHN_RET(HI_MPI_VDEC_SetDisplayMode(i, VIDEO_DISPLAY_MODE_PREVIEW), i, "HI_MPI_VDEC_SetDisplayMode");
      CHECK_CHN_RET(HI_MPI_VDEC_SetDisplayMode(i, VIDEO_DISPLAY_MODE_PLAYBACK), i, "HI_MPI_VDEC_SetDisplayMode");
      CHECK_CHN_RET(HI_MPI_VDEC_GetDisplayMode(i, &tmpDispMode), i, "HI_MPI_VDEC_GetDisplayMode");
      printf("============>after get vdec display mode %d\n", tmpDispMode);

      /**  modify ****e*/
      if (2 == g_s32VBSource)
      {
         stPool.hPicVbPool = g_ahVbPool[0];
         stPool.hPmvVbPool = -1;
         CHECK_CHN_RET(HI_MPI_VDEC_AttachVbPool(i, &stPool), i, "HI_MPI_VDEC_AttachVbPool");
      }
      CHECK_CHN_RET(HI_MPI_VDEC_StartRecvStream(i), i, "HI_MPI_VDEC_StartRecvStream");
      //CHECK_CHN_RET(HI_MPI_VDEC_SetDisplayMode(i, VIDEO_DISPLAY_MODE_PREVIEW), i, "HI_MPI_VDEC_SetDisplayMode");
}

return HI_SUCCESS;
}

qn1530842054

0个粉丝

1

问答

0

专栏

0

资料

qn1530842054 2018-07-07 20:49:43

认可0 回复引用举报

这个问题解决了吗？

arvin_fresh

0个粉丝

5

问答

0

专栏

1

资料

arvin_fresh 2017-04-15 17:21:04

认可0 回复引用举报

:'(:'(:'(:'(:'(:'(:'(:'(

添加附件添加网盘链接

或将文件直接拖到这里

悬赏：

E币

网盘

* 网盘链接：

* 提取码：

悬赏：

E币

Markdown 语法

加粗**内容**

斜体*内容*

删除线~~内容~~

引用> 引用内容

代码`代码`

代码块```编程语言↵代码```

链接[链接标题](url)

无序列表- 内容

有序列表1. 内容

缩进内容

图片![alt](url)

+ 添加网盘链接/附件

Markdown 语法

加粗**内容**

斜体*内容*

删除线~~内容~~

引用> 引用内容

代码`代码`

代码块```编程语言↵代码```

链接[链接标题](url)

无序列表- 内容

有序列表1. 内容

缩进内容

图片![alt](url)

相关问答

hi3531a支持h264的B帧解码吗

7

2018-02-05 15:00:12

hi3531a 不支持H264 B帧解码？

0

2018-03-23 17:37:55

hi3531a解码问题

1

2019-06-24 17:40:37

Hi3531A解码4K@30帧率上不去的问题

1

2022-01-20 13:55:08

请教hi3531a 4k解码问题

3

2019-11-21 16:39:34

Hi3531A 解码4K@30延时的问题

5

2021-10-15 11:02:59

3531解B帧的效率不行吗？

3

2014-11-17 17:30:27

HI3531D编码GOP支持B帧吗？

1

2019-04-16 14:37:00

Hi3531A编码问题

4

2016-08-30 15:17:42

hi3531a GVS 问题

0

2017-04-07 13:27:30

hi3531a音频问题

4

2017-11-30 09:33:31

hi3531A 音频问题

4

2018-03-30 16:22:08

hi3531a TDE 问题

0

2017-04-07 13:43:32

hi3531a编码码率大，解码断解码显示就花屏

3

2018-10-12 14:49:34

HI3531解码50/60帧率卡顿问题

7

2016-12-06 10:00:55

hi3531a 增大音量问题

7

2018-03-02 16:31:32

Hi3531A技术问题

7

2016-07-29 11:54:40

3531能编解B帧吗？求破解

1

2014-11-13 16:45:04

hi3531A vdec模块解码1024*1024图像丢帧严重

6

2017-01-06 08:51:41

无更多相似问答去提问

点击登录

-- 积分

-- E币

提问

—

收益

—

被采纳

—

我要提问

切换马甲

上一页

下一页

社区问答

关于社区发帖新规则

关于社区回答问题能得到什么奖励？

如何写出高质量有效的提问及回答？

欢迎对社区的功能提出建议？

悬赏问答

10
海思IVP928

5
22AP10支持F35SQA001G spi nand flash

20
如何将自有训练的RAW降噪模型应用于AIBNR？

10
RV1106的低功耗和休眠唤醒功能

10
海思平台（Hi3516DV500），设置完ldc参数后工作异常

5
rv1126-dc-201 安装hi3881.ko wifi驱动成功后启动connmand服务，系统就崩了

10
ss928编码的h264帧流，用RTSP传输到电脑，VLC播放不了是什么情况？

10
我运行rv1126的开发环境后，编译demo提示没有opencv，自行编译安装后没有解决，请问这个怎么处理呢？板子是easy eai nano

50
CPS-1848 link不上FPGA。

10
想问一下各位大佬们，关于VI配置成8Lan LVDS模式的相关问题

举报反馈

举报类型

内容涉黄/赌/毒

内容侵权/抄袭

政治相关

涉嫌广告

侮辱谩骂

其他

详细说明

提醒

你的问题还没有最佳答案，是否结题，结题后将扣除20%的悬赏金

取消

确认

提醒

你的问题还没有最佳答案，是否结题，结题后将根据回答情况扣除相应悬赏金（1回答=1E币）

取消

确认

关注公众号

联系我们
社区问题咨询：Ebaina-CN
定制需求咨询：xxqk158820

回顶部