zcy
/
multimedia
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
multimedia/device/mpp/sample/common/sample_comm_ive.c

1406 lines
38 KiB
C
Raw Normal View History

添加3518 开发板 例子代码 用于二次开发
2019-09-09 17:17:53 +00:00
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>
#include "hi_common.h"
#include "hi_comm_video.h"
#include "hi_comm_sys.h"
#include "hi_comm_ive.h"
#include "hi_comm_vgs.h"
#include "hi_comm_vi.h"
#include "hi_comm_vo.h"
#include "mpi_vb.h"
#include "mpi_sys.h"
#include "mpi_vi.h"
#include "mpi_vo.h"
#include "mpi_ive.h"
#include "mpi_vgs.h"
#include "sample_comm_ive.h"
static HI_BOOL bMpiInit = HI_FALSE;
HI_U16 SAMPLE_COMM_IVE_CalcStride(HI_U16 u16Width, HI_U8 u8Align)
{
return (u16Width + (u8Align - u16Width%u8Align)%u8Align);
}
static HI_S32 SAMPLE_IVE_MPI_Init(HI_VOID)
{
HI_S32 s32Ret;
VB_CONF_S struVbConf;
MPP_SYS_CONF_S struSysConf;
HI_MPI_SYS_Exit();
HI_MPI_VB_Exit();
memset(&struVbConf,0,sizeof(VB_CONF_S));
struVbConf.u32MaxPoolCnt = 128;
struVbConf.astCommPool[0].u32BlkSize = 1920*1080*3/2;
struVbConf.astCommPool[0].u32BlkCnt = 4;
s32Ret = HI_MPI_VB_SetConf(&struVbConf);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VB_SetConf fail,Error(%#x)\n",s32Ret);
return s32Ret;
}
s32Ret = HI_MPI_VB_Init();
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VB_Init fail,Error(%#x)\n",s32Ret);
return s32Ret;
}
struSysConf.u32AlignWidth = 64;
s32Ret = HI_MPI_SYS_SetConf(&struSysConf);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_SYS_SetConf fail,Error(%#x)\n",s32Ret);
(HI_VOID)HI_MPI_VB_Exit();
return s32Ret;
}
s32Ret = HI_MPI_SYS_Init();
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_SYS_Init fail,Error(%#x)\n",s32Ret);
(HI_VOID)HI_MPI_VB_Exit();
return s32Ret;
}
return HI_SUCCESS;
}
HI_VOID SAMPLE_COMM_IVE_CheckIveMpiInit(HI_VOID)
{
if(HI_FALSE == bMpiInit)
{
if (SAMPLE_IVE_MPI_Init())
{
SAMPLE_PRT("Ive mpi init failed!\n");
exit(-1);
}
bMpiInit = HI_TRUE;
}
}
HI_S32 SAMPLE_COMM_IVE_IveMpiExit(HI_VOID)
{
bMpiInit = HI_FALSE;
if (HI_MPI_SYS_Exit())
{
SAMPLE_PRT("Sys exit failed!\n");
return HI_FAILURE;
}
if (HI_MPI_VB_Exit())
{
SAMPLE_PRT("Vb exit failed!\n");
return HI_FAILURE;
}
return HI_SUCCESS;
}
HI_S32 SAMPLE_COMM_VGS_AddDrawRectJob(VGS_HANDLE VgsHandle, IVE_IMAGE_S *pstSrc, IVE_IMAGE_S *pstDst,
RECT_S *pstRect, HI_U16 u16RectNum)
{
HI_S32 s32Ret = HI_SUCCESS;
VGS_TASK_ATTR_S stVgsTask;
VGS_ADD_COVER_S stVgsCover;
HI_U16 i;
memset(&stVgsTask, 0, sizeof(VGS_TASK_ATTR_S));
stVgsTask.stImgIn.stVFrame.enPixelFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420;
stVgsTask.stImgIn.stVFrame.enCompressMode = COMPRESS_MODE_NONE;
stVgsTask.stImgIn.stVFrame.enVideoFormat = VIDEO_FORMAT_LINEAR;
stVgsTask.stImgIn.stVFrame.u32Field = VIDEO_FIELD_FRAME;
stVgsTask.stImgIn.stVFrame.u32Width = pstSrc->u16Width;
stVgsTask.stImgIn.stVFrame.u32Height = pstSrc->u16Height;
stVgsTask.stImgIn.stVFrame.u32PhyAddr[0] = pstSrc->u32PhyAddr[0];
stVgsTask.stImgIn.stVFrame.u32PhyAddr[1] = pstSrc->u32PhyAddr[1];
stVgsTask.stImgIn.stVFrame.pVirAddr[0] = pstSrc->pu8VirAddr[0];
stVgsTask.stImgIn.stVFrame.pVirAddr[1] = pstSrc->pu8VirAddr[1];
stVgsTask.stImgIn.stVFrame.u32Stride[0] = pstSrc->u16Stride[0];
stVgsTask.stImgIn.stVFrame.u32Stride[1] = pstSrc->u16Stride[1];
stVgsTask.stImgIn.stVFrame.u64pts = 12;
stVgsTask.stImgIn.stVFrame.u32TimeRef = 24;
stVgsTask.stImgOut.stVFrame.enPixelFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420;
stVgsTask.stImgOut.stVFrame.enCompressMode = COMPRESS_MODE_NONE;
stVgsTask.stImgOut.stVFrame.enVideoFormat = VIDEO_FORMAT_LINEAR;
stVgsTask.stImgOut.stVFrame.u32Field = VIDEO_FIELD_FRAME;
stVgsTask.stImgOut.stVFrame.u32Width = pstDst->u16Width;
stVgsTask.stImgOut.stVFrame.u32Height = pstDst->u16Height;
stVgsTask.stImgOut.stVFrame.u32PhyAddr[0] = pstDst->u32PhyAddr[0];
stVgsTask.stImgOut.stVFrame.u32PhyAddr[1] = pstDst->u32PhyAddr[1];
stVgsTask.stImgOut.stVFrame.pVirAddr[0] = pstDst->pu8VirAddr[0];
stVgsTask.stImgOut.stVFrame.pVirAddr[1] = pstDst->pu8VirAddr[1];
stVgsTask.stImgOut.stVFrame.u32Stride[0] = pstDst->u16Stride[0];
stVgsTask.stImgOut.stVFrame.u32Stride[1] = pstDst->u16Stride[1];
stVgsTask.stImgOut.stVFrame.u64pts = 12;
stVgsTask.stImgOut.stVFrame.u32TimeRef = 24;
stVgsCover.enCoverType = COVER_RECT;
for(i = 0; i < u16RectNum;i++)
{
stVgsCover.stDstRect.s32X = (pstRect[i].s32X / 2) * 2;
stVgsCover.stDstRect.s32Y = (pstRect[i].s32Y / 2) * 2;
stVgsCover.stDstRect.u32Width = (pstRect[i].u32Width / 2) * 2;
stVgsCover.stDstRect.u32Height = (pstRect[i].u32Height / 2) * 2;
stVgsCover.u32Color = 0x0000FF00;
if(stVgsCover.stDstRect.s32X + stVgsCover.stDstRect.u32Width < stVgsTask.stImgOut.stVFrame.u32Width
&& stVgsCover.stDstRect.s32Y + stVgsCover.stDstRect.u32Height < stVgsTask.stImgOut.stVFrame.u32Height)
{
s32Ret = HI_MPI_VGS_AddCoverTask(VgsHandle,&stVgsTask,&stVgsCover);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("HI_MPI_VGS_AddCoverTask fail,Error(%#x)\n",s32Ret);
HI_MPI_VGS_CancelJob(VgsHandle);
return s32Ret;
}
}
}
return s32Ret;
}
HI_S32 SAMPLE_COMM_VGS_FillRect(VIDEO_FRAME_INFO_S *pstFrmInfo, SAMPLE_RECT_ARRAY_S *pstRect,HI_U32 u32Color)
{
VGS_HANDLE VgsHandle;
HI_S32 s32Ret = HI_SUCCESS;
HI_U16 i;
VGS_TASK_ATTR_S stVgsTask;
VGS_ADD_COVER_S stVgsAddCover;
if(0 == pstRect->u16Num)
{
return s32Ret;
}
s32Ret = HI_MPI_VGS_BeginJob(&VgsHandle);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("Vgs begin job fail,Error(%#x)\n",s32Ret);
return s32Ret;
}
memcpy(&stVgsTask.stImgIn,pstFrmInfo,sizeof(VIDEO_FRAME_INFO_S));
memcpy(&stVgsTask.stImgOut,pstFrmInfo,sizeof(VIDEO_FRAME_INFO_S));
stVgsAddCover.enCoverType = COVER_QUAD_RANGLE;
stVgsAddCover.u32Color = u32Color;
for(i = 0;i < pstRect->u16Num;i++)
{
stVgsAddCover.stQuadRangle.bSolid = HI_FALSE;
stVgsAddCover.stQuadRangle.u32Thick = 2;
memcpy(stVgsAddCover.stQuadRangle.stPoint,pstRect->astRect[i].astPoint,sizeof(pstRect->astRect[i].astPoint));
s32Ret = HI_MPI_VGS_AddCoverTask(VgsHandle, &stVgsTask, &stVgsAddCover);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("HI_MPI_VGS_AddCoverTask fail,Error(%#x)\n",s32Ret);
HI_MPI_VGS_CancelJob(VgsHandle);
return s32Ret;
}
}
s32Ret = HI_MPI_VGS_EndJob(VgsHandle);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("HI_MPI_VGS_EndJob fail,Error(%#x)\n",s32Ret);
HI_MPI_VGS_CancelJob(VgsHandle);
return s32Ret;
}
return s32Ret;
}
HI_S32 SAMPLE_COMM_IVE_ReadFile(IVE_IMAGE_S *pstImg, FILE *pFp)
{
HI_U16 y;
HI_U8 *pU8;
HI_U16 height;
HI_U16 width;
HI_U16 loop;
(HI_VOID)fgetc(pFp);
if (feof(pFp))
{
SAMPLE_PRT("end of file!\n");
fseek(pFp, 0 , SEEK_SET);
}
else
{
fseek(pFp, -1 , SEEK_CUR);
}
height = pstImg->u16Height;
width = pstImg->u16Width;
switch(pstImg->enType)
{
case IVE_IMAGE_TYPE_U8C1:
{
pU8 = pstImg->pu8VirAddr[0];
for (y = 0; y < height; y++)
{
if ( 1 != fread(pU8,width,1,pFp))
{
SAMPLE_PRT("Read file fail\n");
return HI_FAILURE;
}
pU8 += pstImg->u16Stride[0];
}
}
break;
case IVE_IMAGE_TYPE_YUV420SP:
{
pU8 = pstImg->pu8VirAddr[0];
for (y = 0; y < height; y++)
{
if ( 1 != fread(pU8,width,1,pFp))
{
SAMPLE_PRT("Read file fail\n");
return HI_FAILURE;
}
pU8 += pstImg->u16Stride[0];
}
pU8 = pstImg->pu8VirAddr[1];
for (y = 0; y < height/2; y++)
{
if ( 1 != fread(pU8,width,1,pFp))
{
SAMPLE_PRT("Read file fail\n");
return HI_FAILURE;
}
pU8 += pstImg->u16Stride[1];
}
}
break;
case IVE_IMAGE_TYPE_YUV422SP:
{
pU8 = pstImg->pu8VirAddr[0];
for (y = 0; y < height; y++)
{
if ( 1 != fread(pU8,width,1,pFp))
{
SAMPLE_PRT("Read file fail\n");
return HI_FAILURE;
}
pU8 += pstImg->u16Stride[0];
}
pU8 = pstImg->pu8VirAddr[1];
for (y = 0; y < height; y++)
{
if ( 1 != fread(pU8,width,1,pFp))
{
SAMPLE_PRT("Read file fail\n");
return HI_FAILURE;
}
pU8 += pstImg->u16Stride[1];
}
}
break;
case IVE_IMAGE_TYPE_U8C3_PACKAGE:
{
pU8 = pstImg->pu8VirAddr[0];
for (y = 0; y < height; y++)
{
if ( 1 != fread(pU8,width * 3,1,pFp))
{
SAMPLE_PRT("Read file fail\n");
return HI_FAILURE;
}
pU8 += pstImg->u16Stride[0] * 3;
}
}
break;
case IVE_IMAGE_TYPE_U8C3_PLANAR:
{
for (loop = 0; loop < 3; loop++)
{
pU8 = pstImg->pu8VirAddr[loop];
for (y = 0; y < height; y++)
{
if ( 1 != fread(pU8,width,1,pFp))
{
SAMPLE_PRT("Read file fail\n");
return HI_FAILURE;
}
pU8 += pstImg->u16Stride[loop];
}
}
}
break;
case IVE_IMAGE_TYPE_S16C1:
case IVE_IMAGE_TYPE_U16C1:
{
pU8 = pstImg->pu8VirAddr[0];
for( y = 0; y < height; y++ )
{
if( sizeof(HI_U16) != fread(pU8, width, sizeof(HI_U16), pFp) )
{
SAMPLE_PRT("Read file fail\n");
return HI_FAILURE;
}
pU8 += pstImg->u16Stride[0] * 2;
}
}
break;
default:
break;
}
return HI_SUCCESS;
}
HI_S32 SAMPLE_COMM_IVE_WriteFile(IVE_IMAGE_S *pstImg, FILE *pFp)
{
HI_U16 y;
HI_U8 *pU8;
HI_U16 height;
HI_U16 width;
height = pstImg->u16Height;
width = pstImg->u16Width;
switch(pstImg->enType)
{
case IVE_IMAGE_TYPE_U8C1:
case IVE_IMAGE_TYPE_S8C1:
{
pU8 = pstImg->pu8VirAddr[0];
for (y = 0; y < height; y++)
{
if ( 1 != fwrite(pU8,width,1,pFp))
{
SAMPLE_PRT("Write file fail\n");
return HI_FAILURE;
}
pU8 += pstImg->u16Stride[0];
}
}
break;
case IVE_IMAGE_TYPE_YUV420SP:
{
pU8 = pstImg->pu8VirAddr[0];
for (y = 0; y < height; y++)
{
if ( width != fwrite(pU8,1,width,pFp))
{
SAMPLE_PRT("Write file fail\n");
return HI_FAILURE;
}
pU8 += pstImg->u16Stride[0];
}
pU8 = pstImg->pu8VirAddr[1];
for (y = 0; y < height/2; y++)
{
if ( width != fwrite(pU8,1,width,pFp))
{
SAMPLE_PRT("Write file fail\n");
return HI_FAILURE;
}
pU8 += pstImg->u16Stride[1];
}
}
break;
case IVE_IMAGE_TYPE_YUV422SP:
{
pU8 = pstImg->pu8VirAddr[0];
for (y = 0; y < height; y++)
{
if ( width != fwrite(pU8,1,width,pFp))
{
SAMPLE_PRT("Write file fail\n");
return HI_FAILURE;
}
pU8 += pstImg->u16Stride[0];
}
pU8 = pstImg->pu8VirAddr[1];
for (y = 0; y < height; y++)
{
if ( width != fwrite(pU8,1,width,pFp))
{
SAMPLE_PRT("Write file fail\n");
return HI_FAILURE;
}
pU8 += pstImg->u16Stride[1];
}
}
break;
#if 0
case IVE_IMAGE_TYPE_U8C3_PACKAGE:
{
pU8 = image->pu8VirAddr[0];
for (y = 0; y < height; y++)
{
if ( 1 != fread(pU8,width * 3,1,fp))
{
printf("read file error,line:%d\n",__LINE__);
return HI_FAILURE;
}
pU8 += image->u16Stride[0] * 3;
}
}
break;
case IVE_IMAGE_TYPE_U8C3_PLANAR:
{
for (HI_U16 loop = 0; loop < 3; loop++)
{
pU8 = image->pu8VirAddr[loop];
for (y = 0; y < height; y++)
{
if ( 1 != fread(pU8,width,1,fp))
{
printf("read file error,line:%d\n",__LINE__);
return HI_FAILURE;
}
pU8 += image->u16Stride[loop];
}
}
}
break;
#endif
case IVE_IMAGE_TYPE_S16C1:
case IVE_IMAGE_TYPE_U16C1:
{
pU8 = pstImg->pu8VirAddr[0];
for( y = 0; y < height; y++ )
{
if( sizeof(HI_U16) != fwrite(pU8, width, sizeof(HI_U16), pFp) )
{
SAMPLE_PRT("Write file fail\n");
return HI_FAILURE;
}
pU8 += pstImg->u16Stride[0] * 2;
}
}
break;
case IVE_IMAGE_TYPE_U32C1:
{
pU8 = pstImg->pu8VirAddr[0];
for( y = 0; y < height; y++ )
{
if( width != fwrite(pU8, sizeof(HI_U32), width, pFp) )
{
SAMPLE_PRT("Write file fail\n");
return HI_FAILURE;
}
pU8 += pstImg->u16Stride[0] * 4;
}
break;
}
default:
break;
}
return HI_SUCCESS;
}
HI_VOID SAMPLE_COMM_IVE_BlobToRect(IVE_CCBLOB_S *pstBlob, SAMPLE_RECT_ARRAY_S *pstRect,
HI_U16 u16RectMaxNum,HI_U16 u16AreaThrStep,
HI_U16 u16SrcWidth, HI_U16 u16SrcHeight,
HI_U16 u16DstWidth,HI_U16 u16DstHeight)
{
HI_U16 u16Num;
HI_U16 i,j,k;
HI_U16 u16Thr= 0;
HI_BOOL bValid;
if(pstBlob->u8RegionNum > u16RectMaxNum)
{
u16Thr = pstBlob->u16CurAreaThr;
do
{
u16Num = 0;
u16Thr += u16AreaThrStep;
for(i = 0;i < 254;i++)
{
if(pstBlob->astRegion[i].u32Area > u16Thr)
{
u16Num++;
}
}
}while(u16Num > u16RectMaxNum);
}
u16Num = 0;
for(i = 0;i < 254;i++)
{
if(pstBlob->astRegion[i].u32Area > u16Thr)
{
pstRect->astRect[u16Num].astPoint[0].s32X = (HI_U16)((HI_FLOAT)pstBlob->astRegion[i].u16Left / (HI_FLOAT)u16SrcWidth * (HI_FLOAT)u16DstWidth) & (~1) ;
pstRect->astRect[u16Num].astPoint[0].s32Y = (HI_U16)((HI_FLOAT)pstBlob->astRegion[i].u16Top / (HI_FLOAT)u16SrcHeight * (HI_FLOAT)u16DstHeight) & (~1);
pstRect->astRect[u16Num].astPoint[1].s32X = (HI_U16)((HI_FLOAT)pstBlob->astRegion[i].u16Right/ (HI_FLOAT)u16SrcWidth * (HI_FLOAT)u16DstWidth) & (~1);
pstRect->astRect[u16Num].astPoint[1].s32Y = (HI_U16)((HI_FLOAT)pstBlob->astRegion[i].u16Top / (HI_FLOAT)u16SrcHeight * (HI_FLOAT)u16DstHeight) & (~1);
pstRect->astRect[u16Num].astPoint[2].s32X = (HI_U16)((HI_FLOAT)pstBlob->astRegion[i].u16Right / (HI_FLOAT)u16SrcWidth * (HI_FLOAT)u16DstWidth) & (~1);
pstRect->astRect[u16Num].astPoint[2].s32Y = (HI_U16)((HI_FLOAT)pstBlob->astRegion[i].u16Bottom / (HI_FLOAT)u16SrcHeight * (HI_FLOAT)u16DstHeight) & (~1);
pstRect->astRect[u16Num].astPoint[3].s32X = (HI_U16)((HI_FLOAT)pstBlob->astRegion[i].u16Left / (HI_FLOAT)u16SrcWidth * (HI_FLOAT)u16DstWidth) & (~1);
pstRect->astRect[u16Num].astPoint[3].s32Y = (HI_U16)((HI_FLOAT)pstBlob->astRegion[i].u16Bottom / (HI_FLOAT)u16SrcHeight * (HI_FLOAT)u16DstHeight) & (~1);
bValid = HI_TRUE;
for(j = 0; j < 3;j++)
{
for (k = j + 1; k < 4;k++)
{
if ((pstRect->astRect[u16Num].astPoint[j].s32X == pstRect->astRect[u16Num].astPoint[k].s32X)
&&(pstRect->astRect[u16Num].astPoint[j].s32Y == pstRect->astRect[u16Num].astPoint[k].s32Y))
{
bValid = HI_FALSE;
break;
}
}
}
if (HI_TRUE == bValid)
{
u16Num++;
}
}
}
pstRect->u16Num = u16Num;
}
/*****************************************************************************
* function : set vpss group attribute.
*****************************************************************************/
static HI_VOID SAMPLE_COMM_IVE_VpssGrpAttr(HI_U32 u32VpssGrpCnt, VPSS_GRP_ATTR_S *pstVpssGrpAttr, SIZE_S *pstSize)
{
HI_U32 i;
memset(pstVpssGrpAttr, 0, sizeof(VPSS_GRP_ATTR_S));
for(i=0; i<u32VpssGrpCnt; i++)
{
pstVpssGrpAttr->enDieMode = VPSS_DIE_MODE_NODIE;
pstVpssGrpAttr->bIeEn = HI_FALSE;
pstVpssGrpAttr->bDciEn = HI_FALSE;
pstVpssGrpAttr->bNrEn = HI_TRUE;
//pstVpssGrpAttr->bEsEn = HI_FALSE;
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);
}
}
/*****************************************************************************
* function : start vpss. VPSS chn with frame
*****************************************************************************/
static HI_S32 SAMPLE_COMM_IVE_VpssStart(HI_S32 s32VpssGrpCnt, SIZE_S astSize[],
VPSS_CHN aVpssChn[], HI_S32 s32VpssChnCnt, VPSS_GRP_ATTR_S *pstVpssGrpAttr)
{
VPSS_GRP VpssGrp;
VPSS_CHN VpssChn;
VPSS_GRP_ATTR_S stGrpAttr = {0};
//VPSS_CHN_ATTR_S stChnAttr = {0};
VPSS_GRP_PARAM_S stVpssParam = {0};
VPSS_CHN_MODE_S stVpssChnMode = {0};
VPSS_FRAME_RATE_S stVpssFrmRate = {30, 30};
HI_S32 s32Ret = HI_SUCCESS;
HI_S32 i, j;
HI_U32 u32Depth = 3;
HI_ASSERT(s32VpssGrpCnt>0);
HI_ASSERT(s32VpssChnCnt>0);
/*** Set Vpss Grp Attr ***/
if(NULL == pstVpssGrpAttr)
{
stGrpAttr.u32MaxW = astSize[0].u32Width;
stGrpAttr.u32MaxH = astSize[0].u32Height;
stGrpAttr.bIeEn = HI_FALSE;
stGrpAttr.bNrEn = HI_TRUE;
stGrpAttr.bHistEn = HI_FALSE;
stGrpAttr.enDieMode = VPSS_DIE_MODE_NODIE;
stGrpAttr.enPixFmt = SAMPLE_PIXEL_FORMAT;
}
else
{
memcpy(&stGrpAttr,pstVpssGrpAttr,sizeof(VPSS_GRP_ATTR_S));
}
for(i=0; i<s32VpssGrpCnt; i++)
{
VpssGrp = i;
/*** create vpss group ***/
s32Ret = HI_MPI_VPSS_CreateGrp(VpssGrp, &stGrpAttr);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VPSS_CreateGrp failed with errno: %#x!\n", s32Ret);
return HI_FAILURE;
}
/*** set vpss param ***/
s32Ret = HI_MPI_VPSS_GetGrpParam(VpssGrp, &stVpssParam);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VPSS_GetGrpParam failed with errno: %#x!\n", s32Ret);
return HI_FAILURE;
}
//stVpssParam.u32IeStrength = 0;
s32Ret = HI_MPI_VPSS_SetGrpParam(VpssGrp, &stVpssParam);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VPSS_SetGrpParam failed with errno: %#x!\n", s32Ret);
return HI_FAILURE;
}
s32Ret = HI_MPI_VPSS_SetGrpFrameRate(VpssGrp, &stVpssFrmRate);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VPSS_SetGrpFrameRate failed with errno: %#x!\n", s32Ret);
return HI_FAILURE;
}
/*** enable vpss chn, with frame ***/
for(j=0; j<s32VpssChnCnt; j++)
{
VpssChn = aVpssChn[j];
stVpssChnMode.enChnMode = VPSS_CHN_MODE_USER;
stVpssChnMode.u32Width = astSize[j].u32Width;
stVpssChnMode.u32Height = astSize[j].u32Height;
stVpssChnMode.enPixelFormat = SAMPLE_PIXEL_FORMAT;
stVpssChnMode.enCompressMode = COMPRESS_MODE_NONE;
s32Ret = HI_MPI_VPSS_SetChnMode(VpssGrp, VpssChn, &stVpssChnMode);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VPSS_SetChnMode failed with errno: %#x\n", s32Ret);
return HI_FAILURE;
}
s32Ret = HI_MPI_VPSS_SetDepth(VpssGrp, VpssChn, u32Depth);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VPSS_SetDepth failed with errno: %#x\n", s32Ret);
return HI_FAILURE;
}
s32Ret = HI_MPI_VPSS_EnableChn(VpssGrp, VpssChn);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VPSS_EnableChn failed with errno: %#x\n", s32Ret);
return HI_FAILURE;
}
}
/*** start vpss group ***/
s32Ret = HI_MPI_VPSS_StartGrp(VpssGrp);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VPSS_StartGrp failed with %#x\n", s32Ret);
return HI_FAILURE;
}
}
return HI_SUCCESS;
}
/*****************************************************************************
* function : stop vpss
*****************************************************************************/
static HI_S32 SAMPLE_COMM_IVE_StopVpss(HI_S32 s32VpssGrpCnt, HI_S32 s32VpssChnCnt)
{
HI_S32 i, j;
HI_S32 s32Ret = HI_SUCCESS;
VPSS_GRP VpssGrp;
VPSS_CHN VpssChn;
for(i=0; i<s32VpssGrpCnt; i++)
{
VpssGrp = i;
s32Ret = HI_MPI_VPSS_StopGrp(VpssGrp);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("HI_MPI_VPSS_StopGrp failed with errno: %#x!\n", s32Ret);
return HI_FAILURE;
}
for(j=0; j<s32VpssChnCnt; j++)
{
VpssChn = j;
s32Ret = HI_MPI_VPSS_DisableChn(VpssGrp, VpssChn);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("HI_MPI_VPSS_DisableChn failed with errno: %#x!\n", s32Ret);
return HI_FAILURE;
}
}
s32Ret = HI_MPI_VPSS_DestroyGrp(VpssGrp);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("HI_MPI_VPSS_DestroyGrp failed with errno: %#x!\n", s32Ret);
return HI_FAILURE;
}
}
return HI_SUCCESS;
}
/******************************************************************************
* function : Start BT1120 720P vi/vo/venc
******************************************************************************/
HI_S32 SAMPLE_COMM_IVE_BT1120_720P_PreView(SAMPLE_IVE_VI_VO_CONFIG_S *pstViVoConfig,
HI_BOOL bOpenVi,HI_BOOL bOpenViExt,HI_BOOL bOpenVo,HI_BOOL bOpenVenc,HI_BOOL bOpenVpss,HI_U32 u32VpssChnNum)
{
HI_U32 u32ViChnCnt = 1;
VB_CONF_S stVbConf;
VO_DEV VoDev = SAMPLE_VO_DEV_DSD0;
VI_CHN ViChn = 0;
VI_CHN ViExtChn = 1;
VO_PUB_ATTR_S stVoPubAttr;
SAMPLE_VO_MODE_E enVoMode = VO_MODE_1MUX;
PIC_SIZE_E enPicSize = pstViVoConfig->enPicSize;
VI_EXT_CHN_ATTR_S stExtChnAttr;
HI_S32 s32Ret = HI_SUCCESS;
HI_U32 u32BlkSize;
SIZE_S stSize;
VO_LAYER VoLayer = 0;
VO_VIDEO_LAYER_ATTR_S stLayerAttr;
SAMPLE_VI_CONFIG_S *pstViConfig = &(pstViVoConfig->stViConfig);
VENC_CHN VencChn = 0;
HI_U32 u32ViDepth = 4;
VI_CHN_ATTR_S stChnAttr;
HI_U32 u32VpssGrpCnt = 1;
VPSS_CHN aVpssChn[2] = {VPSS_CHN0, VPSS_CHN3};
VPSS_GRP_ATTR_S stVpssGrpAttr;
SIZE_S astSize[2];
memset(&stVbConf,0,sizeof(VB_CONF_S));
u32BlkSize = SAMPLE_COMM_SYS_CalcPicVbBlkSize(pstViVoConfig->enNorm, enPicSize,
SAMPLE_PIXEL_FORMAT, SAMPLE_SYS_ALIGN_WIDTH);
stVbConf.u32MaxPoolCnt = 128;
/*ddr0 video buffer*/
stVbConf.astCommPool[0].u32BlkSize = u32BlkSize;
stVbConf.astCommPool[0].u32BlkCnt = u32ViChnCnt * 3;
if (HI_TRUE == bOpenViExt)
{
u32BlkSize = SAMPLE_COMM_SYS_CalcPicVbBlkSize(pstViVoConfig->enNorm,PIC_CIF, SAMPLE_PIXEL_FORMAT, SAMPLE_SYS_ALIGN_WIDTH);
stVbConf.astCommPool[1].u32BlkSize = u32BlkSize;
stVbConf.astCommPool[1].u32BlkCnt = 3;
}
// mpp system init.
s32Ret = SAMPLE_COMM_SYS_Init(&stVbConf);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("SAMPLE_COMM_SYS_Init fail,Error(%#x)\n", s32Ret);
goto END_720P_0;
}
if (HI_TRUE == bOpenVi)
{
s32Ret = SAMPLE_COMM_VI_StartVi(pstViConfig);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("SAMPLE_COMM_VI_StartVi fail,Error(%#x)\n",s32Ret);
goto END_720P_0;
}
s32Ret = HI_MPI_VI_SetFrameDepth(ViChn,u32ViDepth);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VI_SetFrameDepth fail,ViChn(%d),Error(%#x)\n",ViChn,s32Ret);
goto END_720P_1;
}
s32Ret = HI_MPI_VI_GetChnAttr(ViChn,&stChnAttr);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VI_GetChnAttr fail,ViChn(%d),Error(%#x)\n",ViChn,s32Ret);
goto END_720P_1;
}
//Set Vi frame rate,because vi from BT1120 is 720P@30
stChnAttr.s32SrcFrameRate = 3;
stChnAttr.s32DstFrameRate = 1;
s32Ret = HI_MPI_VI_SetChnAttr(ViChn,&stChnAttr);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VI_SetChnAttr,ViChn(%d),Error(%#x)\n",ViChn,s32Ret);
goto END_720P_1;
}
}
//Open vi ext chn
if (HI_TRUE == bOpenViExt)
{
stExtChnAttr.enPixFormat = SAMPLE_PIXEL_FORMAT;
stExtChnAttr.s32BindChn = ViChn;
stExtChnAttr.stDestSize.u32Width = 352;
stExtChnAttr.stDestSize.u32Height = 288;
stExtChnAttr.s32DstFrameRate = -1;
stExtChnAttr.s32SrcFrameRate = -1;
stExtChnAttr.enCompressMode = COMPRESS_MODE_NONE;
s32Ret = HI_MPI_VI_SetExtChnAttr(ViExtChn, &stExtChnAttr);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VI_SetExtChnAttr fail,ViChn(%d),Error(%#x)\n",ViExtChn,s32Ret);
goto END_720P_1;
}
s32Ret = HI_MPI_VI_EnableChn(ViExtChn);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VI_EnableChn fail,ViChn(%d),Error(%#x)\n",ViExtChn,s32Ret);
goto END_720P_1;
}
s32Ret = HI_MPI_VI_SetFrameDepth(ViExtChn,u32ViDepth);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_VI_SetFrameDepth fail,ViChn(%d),Error(%#x)\n",ViExtChn,s32Ret);
goto END_720P_1;
}
}
//Open vo
if (HI_TRUE == bOpenVo)
{
s32Ret = SAMPLE_COMM_SYS_GetPicSize(pstViVoConfig->enNorm, enPicSize, &stSize);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("SAMPLE_COMM_SYS_GetPicSize fail,Error(%#x)\n",s32Ret);
goto END_720P_2;
}
stVoPubAttr.enIntfType = pstViVoConfig->enVoIntfType;
//hi3518e Vo only suppurt pal
//if(VO_INTF_BT1120 == pstViVoConfig->enVoIntfType)
//{
// stVoPubAttr.enIntfSync = /*VO_OUTPUT_720P60*/VO_OUTPUT_1080P30;
//}
// if(SAMPLE_VI_MODE_BT1120_1080P == pstViVoConfig->stViConfig.enViMode)
// {
// stVoPubAttr.enIntfSync = VO_OUTPUT_1080P30;
// }
//else if(SAMPLE_VI_MODE_BT1120_720P == pstViVoConfig->stViConfig.enViMode)
// {
// stVoPubAttr.enIntfSync = VO_OUTPUT_720P60;
// }
// else
{
stVoPubAttr.enIntfSync = VO_OUTPUT_PAL;
}
stVoPubAttr.u32BgColor = 0x000000ff;
/* In HD, this item should be set to HI_FALSE */
s32Ret = SAMPLE_COMM_VO_StartDev(VoDev, &stVoPubAttr);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("SAMPLE_COMM_VO_StartDevLayer fail,VoDev(%d),Error(%#x)!\n",VoDev,s32Ret);
goto END_720P_2;
}
stLayerAttr.bClusterMode = HI_FALSE;
stLayerAttr.bDoubleFrame = HI_FALSE;
stLayerAttr.enPixFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420;
memcpy(&stLayerAttr.stImageSize,&stSize,sizeof(stSize));
stLayerAttr.u32DispFrmRt = 60 ;
stLayerAttr.stDispRect.s32X = 0;
stLayerAttr.stDispRect.s32Y = 0;
if((stVoPubAttr.enIntfSync == VO_OUTPUT_720P60) || (stVoPubAttr.enIntfSync == VO_OUTPUT_1080P30))
{
stLayerAttr.stDispRect.u32Width = stSize.u32Width;
stLayerAttr.stDispRect.u32Height = stSize.u32Height;
}
else if(stVoPubAttr.enIntfSync == VO_OUTPUT_PAL)
{
stLayerAttr.stDispRect.u32Width = 720;
stLayerAttr.stDispRect.u32Height = 576;
}
s32Ret = SAMPLE_COMM_VO_StartLayer(VoLayer, &stLayerAttr, HI_TRUE);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("SAMPLE_COMM_VO_StartLayer fail,VoLayer(%d),Error(%#x)\n",VoLayer,s32Ret);
goto END_720P_3;
}
s32Ret = SAMPLE_COMM_VO_StartChn(VoDev, enVoMode);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("SAMPLE_COMM_VO_StartChn fail,VoDev(%d),Error(%#x)\n",VoDev,s32Ret);
goto END_720P_4;
}
}
if (HI_TRUE == bOpenVenc)
{
s32Ret = SAMPLE_COMM_VENC_Start(VencChn, PT_H264, pstViVoConfig->enNorm, enPicSize, SAMPLE_RC_CBR,0);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("SAMPLE_COMM_VENC_Start fail,VencChn(%d),Error(%#x)\n",VencChn,s32Ret);
goto END_720P_5;
}
s32Ret = SAMPLE_COMM_VENC_StartGetStream(1);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("SAMPLE_COMM_VENC_StartGetStream fail,Error(%#x)\n",s32Ret);
goto END_720P_6;
}
}
if (HI_TRUE == bOpenVpss)
{
s32Ret = SAMPLE_COMM_SYS_GetPicSize(pstViVoConfig->enNorm, enPicSize, &astSize[0]);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("SAMPLE_COMM_SYS_GetPicSize fail,Error(%#x)\n",s32Ret);
goto END_720P_6;
}
astSize[1].u32Width = 352;
astSize[1].u32Height = 288;
SAMPLE_COMM_IVE_VpssGrpAttr(u32VpssGrpCnt, &stVpssGrpAttr, &stSize);
s32Ret = SAMPLE_COMM_IVE_VpssStart(u32VpssGrpCnt, astSize, aVpssChn, u32VpssChnNum, &stVpssGrpAttr);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("SAMPLE_COMM_IVE_VpssStart fail,Error(%#x)\n",s32Ret);
goto END_720P_6;
}
}
return s32Ret;
//END_720P_7:
//if (HI_TRUE == bOpenVpss)
//{
// SAMPLE_COMM_IVE_StopVpss(u32VpssGrpCnt,u32VpssChnNum);
//}
END_720P_6:
if (HI_TRUE == bOpenVenc)
{
SAMPLE_COMM_VENC_Stop(VencChn);
}
END_720P_5:
if (HI_TRUE == bOpenVo)
{
SAMPLE_COMM_VO_StopChn(VoDev, enVoMode);
}
END_720P_4:
if (HI_TRUE == bOpenVo)
{
SAMPLE_COMM_VO_StopLayer(VoLayer);
}
END_720P_3:
if (HI_TRUE == bOpenVo)
{
SAMPLE_COMM_VO_StopDev(VoDev);
}
END_720P_2:
if(HI_TRUE == bOpenViExt)
{
(HI_VOID)HI_MPI_VI_DisableChn(ViExtChn);
}
END_720P_1:
if (HI_TRUE == bOpenVi)
{
SAMPLE_COMM_VI_StopVi(pstViConfig);
}
END_720P_0:
SAMPLE_COMM_SYS_Exit();
return s32Ret;
}
/******************************************************************************
* function : Stop BT1120 720P vi/vo/venc
******************************************************************************/
HI_VOID SAMPLE_COMM_IVE_BT1120_720P_Stop(SAMPLE_IVE_VI_VO_CONFIG_S *pstViVoConfig,
HI_BOOL bOpenVi,HI_BOOL bOpenViExt,HI_BOOL bOpenVo,HI_BOOL bOpenVenc,HI_BOOL bOpenVpss,HI_U32 u32VpssChnNum)
{
VO_DEV VoDev = SAMPLE_VO_DEV_DSD0;
VO_LAYER VoLayer = 0;
SAMPLE_VO_MODE_E enVoMode = VO_MODE_1MUX;
VI_CHN ViExtChn = 1;
VENC_CHN VencChn = 0;
HI_U32 u32VpssGrpCnt = 1;
if (HI_TRUE == bOpenVpss)
{
SAMPLE_COMM_IVE_StopVpss(u32VpssGrpCnt,u32VpssChnNum);
}
if (HI_TRUE == bOpenVenc)
{
SAMPLE_COMM_VENC_StopGetStream();
SAMPLE_COMM_VENC_Stop(VencChn);
}
//Close vo
if (HI_TRUE == bOpenVo )
{
SAMPLE_COMM_VO_StopChn(VoDev, enVoMode);
SAMPLE_COMM_VO_StopLayer(VoLayer);
SAMPLE_COMM_VO_StopDev(VoDev);
}
//Close vi ext chn
if(HI_TRUE == bOpenViExt)
{
(HI_VOID)HI_MPI_VI_DisableChn(ViExtChn);
}
//Close vi
if (HI_TRUE == bOpenVi)
{
SAMPLE_COMM_VI_StopVi(&(pstViVoConfig->stViConfig));
}
//Close sys
SAMPLE_COMM_SYS_Exit();
}
/******************************************************************************
* function : Create ive image
******************************************************************************/
HI_S32 SAMPLE_COMM_IVE_CreateImage(IVE_IMAGE_S *pstImg,IVE_IMAGE_TYPE_E enType,HI_U16 u16Width,HI_U16 u16Height)
{
HI_U32 u32Size = 0;
HI_S32 s32Ret;
if (NULL == pstImg)
{
SAMPLE_PRT("pstImg is null\n");
return HI_FAILURE;
}
pstImg->enType = enType;
pstImg->u16Width = u16Width;
pstImg->u16Height = u16Height;
pstImg->u16Stride[0] = SAMPLE_COMM_IVE_CalcStride(pstImg->u16Width,IVE_ALIGN);
switch(enType)
{
case IVE_IMAGE_TYPE_U8C1:
case IVE_IMAGE_TYPE_S8C1:
{
u32Size = pstImg->u16Stride[0] * pstImg->u16Height;
s32Ret = HI_MPI_SYS_MmzAlloc(&pstImg->u32PhyAddr[0], (void**)&pstImg->pu8VirAddr[0], NULL, HI_NULL, u32Size);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("Mmz Alloc fail,Error(%#x)\n",s32Ret);
return s32Ret;
}
}
break;
case IVE_IMAGE_TYPE_YUV420SP:
{
u32Size = pstImg->u16Stride[0] * pstImg->u16Height * 3 / 2;
s32Ret = HI_MPI_SYS_MmzAlloc(&pstImg->u32PhyAddr[0], (void**)&pstImg->pu8VirAddr[0], NULL, HI_NULL, u32Size);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("Mmz Alloc fail,Error(%#x)\n",s32Ret);
return s32Ret;
}
pstImg->u16Stride[1] = pstImg->u16Stride[0];
pstImg->u32PhyAddr[1] = pstImg->u32PhyAddr[0] + pstImg->u16Stride[0] * pstImg->u16Height;
pstImg->pu8VirAddr[1] = pstImg->pu8VirAddr[0] + pstImg->u16Stride[0] * pstImg->u16Height;
}
break;
case IVE_IMAGE_TYPE_YUV422SP:
{
u32Size = pstImg->u16Stride[0] * pstImg->u16Height * 2;
s32Ret = HI_MPI_SYS_MmzAlloc(&pstImg->u32PhyAddr[0], (void**)&pstImg->pu8VirAddr[0], NULL, HI_NULL, u32Size);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("Mmz Alloc fail,Error(%#x)\n",s32Ret);
return s32Ret;
}
pstImg->u16Stride[1] = pstImg->u16Stride[0];
pstImg->u32PhyAddr[1] = pstImg->u32PhyAddr[0] + pstImg->u16Stride[0] * pstImg->u16Height;
pstImg->pu8VirAddr[1] = pstImg->pu8VirAddr[0] + pstImg->u16Stride[0] * pstImg->u16Height;
}
break;
case IVE_IMAGE_TYPE_YUV420P:
break;
case IVE_IMAGE_TYPE_YUV422P:
break;
case IVE_IMAGE_TYPE_S8C2_PACKAGE:
break;
case IVE_IMAGE_TYPE_S8C2_PLANAR:
break;
case IVE_IMAGE_TYPE_S16C1:
case IVE_IMAGE_TYPE_U16C1:
{
u32Size = pstImg->u16Stride[0] * pstImg->u16Height * sizeof(HI_U16);
s32Ret = HI_MPI_SYS_MmzAlloc(&pstImg->u32PhyAddr[0], (void**)&pstImg->pu8VirAddr[0], NULL, HI_NULL, u32Size);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("Mmz Alloc fail,Error(%#x)\n",s32Ret);
return s32Ret;
}
}
break;
case IVE_IMAGE_TYPE_U8C3_PACKAGE:
{
u32Size = pstImg->u16Stride[0] * pstImg->u16Height * 3;
s32Ret = HI_MPI_SYS_MmzAlloc(&pstImg->u32PhyAddr[0], (void**)&pstImg->pu8VirAddr[0], NULL, HI_NULL, u32Size);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("Mmz Alloc fail,Error(%#x)\n",s32Ret);
return s32Ret;
}
pstImg->pu8VirAddr[1] = pstImg->pu8VirAddr[0] +1;
pstImg->pu8VirAddr[2] = pstImg->pu8VirAddr[1] + 1;
pstImg->u32PhyAddr[1] = pstImg->u32PhyAddr[0] + 1;
pstImg->u32PhyAddr[2] = pstImg->u32PhyAddr[1] + 1;
pstImg->u16Stride[1] = pstImg->u16Stride[0];
pstImg->u16Stride[2] = pstImg->u16Stride[0];
}
break;
case IVE_IMAGE_TYPE_U8C3_PLANAR:
break;
case IVE_IMAGE_TYPE_S32C1:
case IVE_IMAGE_TYPE_U32C1:
{
u32Size = pstImg->u16Stride[0] * pstImg->u16Height * sizeof(HI_U32);
s32Ret = HI_MPI_SYS_MmzAlloc(&pstImg->u32PhyAddr[0], (void**)&pstImg->pu8VirAddr[0], NULL, HI_NULL, u32Size);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("Mmz Alloc fail,Error(%#x)\n",s32Ret);
return s32Ret;
}
}
break;
case IVE_IMAGE_TYPE_S64C1:
case IVE_IMAGE_TYPE_U64C1:
{
u32Size = pstImg->u16Stride[0] * pstImg->u16Height * sizeof(HI_U64);
s32Ret = HI_MPI_SYS_MmzAlloc(&pstImg->u32PhyAddr[0], (void**)&pstImg->pu8VirAddr[0], NULL, HI_NULL, u32Size);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("Mmz Alloc fail,Error(%#x)\n",s32Ret);
return s32Ret;
}
}
break;
default:
break;
}
return HI_SUCCESS;
}
/******************************************************************************
* function : Create memory info
******************************************************************************/
HI_S32 SAMPLE_COMM_IVE_CreateMemInfo(IVE_MEM_INFO_S*pstMemInfo,HI_U32 u32Size)
{
HI_S32 s32Ret;
if (NULL == pstMemInfo)
{
SAMPLE_PRT("pstMemInfo is null\n");
return HI_FAILURE;
}
pstMemInfo->u32Size = u32Size;
s32Ret = HI_MPI_SYS_MmzAlloc(&pstMemInfo->u32PhyAddr, (void**)&pstMemInfo->pu8VirAddr, NULL, HI_NULL, u32Size);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("Mmz Alloc fail,Error(%#x)\n",s32Ret);
return HI_FAILURE;
}
return HI_SUCCESS;
}
/******************************************************************************
* function : Create ive image by cached
******************************************************************************/
HI_S32 SAMPLE_COMM_IVE_CreateImageByCached(IVE_IMAGE_S *pstImg,
IVE_IMAGE_TYPE_E enType,HI_U16 u16Width,HI_U16 u16Height)
{
HI_U32 u32Size = 0;
HI_S32 s32Ret;
if (NULL == pstImg)
{
SAMPLE_PRT("pstImg is null\n");
return HI_FAILURE;
}
pstImg->enType = enType;
pstImg->u16Width = u16Width;
pstImg->u16Height = u16Height;
pstImg->u16Stride[0] = SAMPLE_COMM_IVE_CalcStride(pstImg->u16Width,IVE_ALIGN);
switch(enType)
{
case IVE_IMAGE_TYPE_U8C1:
case IVE_IMAGE_TYPE_S8C1:
{
u32Size = pstImg->u16Stride[0] * pstImg->u16Height;
s32Ret = HI_MPI_SYS_MmzAlloc_Cached(&pstImg->u32PhyAddr[0], (void**)&pstImg->pu8VirAddr[0], NULL, HI_NULL, u32Size);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("Mmz Alloc fail,Error(%#x)\n",s32Ret);
return s32Ret;
}
}
break;
case IVE_IMAGE_TYPE_YUV420SP:
break;
case IVE_IMAGE_TYPE_YUV422SP:
break;
case IVE_IMAGE_TYPE_YUV420P:
break;
case IVE_IMAGE_TYPE_YUV422P:
break;
case IVE_IMAGE_TYPE_S8C2_PACKAGE:
break;
case IVE_IMAGE_TYPE_S8C2_PLANAR:
break;
case IVE_IMAGE_TYPE_S16C1:
case IVE_IMAGE_TYPE_U16C1:
{
u32Size = pstImg->u16Stride[0] * pstImg->u16Height * sizeof(HI_U16);
s32Ret = HI_MPI_SYS_MmzAlloc_Cached(&pstImg->u32PhyAddr[0], (void**)&pstImg->pu8VirAddr[0], NULL, HI_NULL, u32Size);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("Mmz Alloc fail,Error(%#x)\n",s32Ret);
return s32Ret;
}
}
break;
case IVE_IMAGE_TYPE_U8C3_PACKAGE:
break;
case IVE_IMAGE_TYPE_U8C3_PLANAR:
break;
case IVE_IMAGE_TYPE_S32C1:
case IVE_IMAGE_TYPE_U32C1:
{
u32Size = pstImg->u16Stride[0] * pstImg->u16Height * sizeof(HI_U32);
s32Ret = HI_MPI_SYS_MmzAlloc_Cached(&pstImg->u32PhyAddr[0], (void**)&pstImg->pu8VirAddr[0], NULL, HI_NULL, u32Size);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("Mmz Alloc fail,Error(%#x)\n",s32Ret);
return s32Ret;
}
}
break;
case IVE_IMAGE_TYPE_S64C1:
case IVE_IMAGE_TYPE_U64C1:
{
u32Size = pstImg->u16Stride[0] * pstImg->u16Height * sizeof(HI_U64);
s32Ret = HI_MPI_SYS_MmzAlloc_Cached(&pstImg->u32PhyAddr[0], (void**)&pstImg->pu8VirAddr[0], NULL, HI_NULL, u32Size);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("Mmz Alloc fail,Error(%#x)\n",s32Ret);
return s32Ret;
}
}
break;
default:
break;
}
return HI_SUCCESS;
}
/******************************************************************************
* function : Dma frame info to ive image
******************************************************************************/
HI_S32 SAMPLE_COMM_DmaImage(VIDEO_FRAME_INFO_S *pstFrameInfo,IVE_DST_IMAGE_S *pstDst,HI_BOOL bInstant)
{
HI_S32 s32Ret;
IVE_HANDLE hIveHandle;
IVE_SRC_DATA_S stSrcData;
IVE_DST_DATA_S stDstData;
IVE_DMA_CTRL_S stCtrl = {IVE_DMA_MODE_DIRECT_COPY,0};
HI_BOOL bFinish = HI_FALSE;
HI_BOOL bBlock = HI_TRUE;
//fill src
stSrcData.pu8VirAddr = (HI_U8*)pstFrameInfo->stVFrame.pVirAddr[0];
stSrcData.u32PhyAddr = pstFrameInfo->stVFrame.u32PhyAddr[0];
stSrcData.u16Width = (HI_U16)pstFrameInfo->stVFrame.u32Width;
stSrcData.u16Height = (HI_U16)pstFrameInfo->stVFrame.u32Height;
stSrcData.u16Stride = (HI_U16)pstFrameInfo->stVFrame.u32Stride[0];
//fill dst
stDstData.pu8VirAddr = pstDst->pu8VirAddr[0];
stDstData.u32PhyAddr = pstDst->u32PhyAddr[0];
stDstData.u16Width = pstDst->u16Width;
stDstData.u16Height = pstDst->u16Height;
stDstData.u16Stride = pstDst->u16Stride[0];
s32Ret = HI_MPI_IVE_DMA(&hIveHandle,&stSrcData,&stDstData,&stCtrl,bInstant);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_IVE_DMA fail,Error(%#x)\n",s32Ret);
return s32Ret;
}
if (HI_TRUE == bInstant)
{
s32Ret = HI_MPI_IVE_Query(hIveHandle,&bFinish,bBlock);
while(HI_ERR_IVE_QUERY_TIMEOUT == s32Ret)
{
usleep(100);
s32Ret = HI_MPI_IVE_Query(hIveHandle,&bFinish,bBlock);
}
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("HI_MPI_IVE_Query fail,Error(%#x)\n",s32Ret);
return s32Ret;
}
}
return HI_SUCCESS;
}