/******************************************************************************
* 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;
}
HI_VOID *sw_HIFB_REFRESH(void *pData)
{
HI_S32 s32Ret = HI_SUCCESS;
HIFB_LAYER_INFO_S stLayerInfo = {0};
HIFB_BUFFER_S stCanvasBuf;
HI_U16 *pBuf;
HI_U32 x, y;
HI_BOOL Show;
HI_BOOL bCompress = HI_TRUE;
HIFB_POINT_S stPoint = {0};
struct fb_var_screeninfo stVarInfo;
char file[12] = "/dev/fb0";
HI_U32 maxW,maxH;
PTHREAD_HIFB_sw_INFO *pstInfo;
pstInfo = (PTHREAD_HIFB_sw_INFO *)pData;
HIFB_COLORKEY_S stColorKey;
switch (pstInfo->layer)
{
case 0 :
strcpy(file, "/dev/fb0");
break;
case 1 :
strcpy(file, "/dev/fb1");
break;
case 2 :
strcpy(file, "/dev/fb2");
break;
case 3 :
strcpy(file, "/dev/fb3");
break;
case 4 :
strcpy(file, "/dev/fb4");
break;
default:
strcpy(file, "/dev/fb0");
break;
}
pstInfo->fd = open(file, O_RDWR, 0);
if (pstInfo->fd < 0)
{
printf("open %s failed!\n",file);
return HI_NULL;
}
if (pstInfo->layer == HIFB_LAYER_0 )
{
if (ioctl(pstInfo->fd, FBIOPUT_COMPRESSION_HIFB, &bCompress) < 0)
{
printf("FBIOPUT_COMPRESSION_HIFB failed!\n");
close(pstInfo->fd);
return HI_NULL;
}
}
stColorKey.bKeyEnable = HI_TRUE;
stColorKey.u32Key = 0x0;
if (ioctl(pstInfo->fd, FBIOPUT_COLORKEY_HIFB, &stColorKey) < 0)
{
printf("FBIOPUT_COLORKEY_HIFB!\n");
close(pstInfo->fd);
return HI_NULL;
}
s32Ret = ioctl(pstInfo->fd, FBIOGET_VSCREENINFO, &stVarInfo);
if (s32Ret < 0)
{
printf("GET_VSCREENINFO failed!\n");
return HI_NULL;
}
if (ioctl(pstInfo->fd, FBIOPUT_SCREEN_ORIGIN_HIFB, &stPoint) < 0)
{
printf("set screen original show position failed!\n");
return HI_NULL;
}
maxW = 1280;
maxH = 720;
stVarInfo.xres = stVarInfo.xres_virtual = maxW;
stVarInfo.yres = stVarInfo.yres_virtual = maxH;
setRelolution(maxW,maxH);
s32Ret = ioctl(pstInfo->fd, FBIOPUT_VSCREENINFO, &stVarInfo);
if (s32Ret < 0)
{
printf("PUT_VSCREENINFO failed!\n");
return HI_NULL;
}
switch (pstInfo->ctrlkey)
{
case 0 :
{
stLayerInfo.BufMode = HIFB_LAYER_BUF_ONE;
stLayerInfo.u32Mask = HIFB_LAYERMASK_BUFMODE;
break;
}
case 1 :
{
stLayerInfo.BufMode = HIFB_LAYER_BUF_DOUBLE;
stLayerInfo.u32Mask = HIFB_LAYERMASK_BUFMODE;
break;
}
default:
{
stLayerInfo.BufMode = HIFB_LAYER_BUF_NONE;
stLayerInfo.u32Mask = HIFB_LAYERMASK_BUFMODE;
}
}
s32Ret = ioctl(pstInfo->fd, FBIOPUT_LAYER_INFO, &stLayerInfo);
if (s32Ret < 0)
{
printf("PUT_LAYER_INFO failed!\n");
return HI_NULL;
}
Show = HI_TRUE;
if (ioctl(pstInfo->fd, FBIOPUT_SHOW_HIFB, &Show) < 0)
{
printf("FBIOPUT_SHOW_HIFB failed!\n");
return HI_NULL;
}
if (HI_FAILURE == HI_MPI_SYS_MmzAlloc(&(stCanvasBuf.stCanvas.u32PhyAddr), ((void**)&pBuf),
NULL, NULL, maxW*maxH*2))
{
printf("allocate memory (maxW*maxH*2 bytes) failed\n");
return HI_NULL;
}
stCanvasBuf.stCanvas.u32Height = maxH;
stCanvasBuf.stCanvas.u32Width = maxW;
stCanvasBuf.stCanvas.u32Pitch = maxW*2;
stCanvasBuf.stCanvas.enFmt = HIFB_FMT_ARGB1555;
memset(pBuf, 0x00, stCanvasBuf.stCanvas.u32Pitch*stCanvasBuf.stCanvas.u32Height);
gdc.tcClear=0x00;
gdc.pWinFb->hFB=pstInfo->fd;
gdc.pWinFb->pMappedAddr=pBuf;
gdc.pWinFb->pPhyAddr=stCanvasBuf.stCanvas.u32PhyAddr;
gdc.pSzWin.nW=maxW;
gdc.pSzWin.nH=maxH;
windowInit();
CreateMsgQueue(&gdc.nMsgid,20);
while(1)
{
pWINDOW_S pOsd=getOSDWnd();
MSG msg={WIN_FLASH_ALL,0};
SendMsg(gdc.nMsgid,msg);
while(1)
{
RecvMsg(gdc.nMsgid,&msg,TRUE);
switch(msg.message)
{
case WIN_FLASH_ALL:
windowFlush();
stCanvasBuf.UpdateRect.x = 0;
stCanvasBuf.UpdateRect.y = 0;
stCanvasBuf.UpdateRect.w = maxW;
stCanvasBuf.UpdateRect.h = maxH;
s32Ret = ioctl(pstInfo->fd, FBIO_REFRESH, &stCanvasBuf);
if (s32Ret < 0)
{
printf("REFRESH failed!\n");
}
break;
case WIN_WIN_FLASH:
case WIN_FLASH_AREA:
case WIN_CTRL_FLASH:
break;
}
}
}
return HI_NULL;
}
HI_S32 TDE_DrawGraphicSample()
{
HI_U32 u32Size;
HI_S32 s32Fd;
HI_U32 u32Times;
HI_U8* pu8Screen;
HI_U8* pu8BackGroundVir;
HI_U32 u32PhyAddr;
HI_S32 s32Ret = -1;
HI_U32 i = 0;
HI_BOOL bShow;
HIFB_ALPHA_S stAlpha = {0};
struct fb_fix_screeninfo stFixInfo;
struct fb_var_screeninfo stVarInfo;
struct fb_bitfield stR32 = {10, 5, 0};
struct fb_bitfield stG32 = {5, 5, 0};
struct fb_bitfield stB32 = {0, 5, 0};
struct fb_bitfield stA32 = {15, 1, 0};
/* 1. open tde device */
HI_TDE2_Open();
/* 2. framebuffer operation */
s32Fd = open("/dev/fb0", O_RDWR);
if (s32Fd == -1)
{
printf("open frame buffer device error\n");
goto FB_OPEN_ERROR;
}
stAlpha.bAlphaChannel = HI_FALSE;
stAlpha.bAlphaEnable = HI_FALSE;
if (ioctl(s32Fd, FBIOPUT_ALPHA_HIFB, &stAlpha) < 0)
{
printf("Put alpha info failed!\n");
goto FB_PROCESS_ERROR0;
}
/* get the variable screen info */
if (ioctl(s32Fd, FBIOGET_VSCREENINFO, &stVarInfo) < 0)
{
printf("Get variable screen info failed!\n");
goto FB_PROCESS_ERROR0;
}
stVarInfo.xres_virtual = SCREEN_WIDTH;
stVarInfo.yres_virtual = SCREEN_HEIGHT*2;
stVarInfo.xres = SCREEN_WIDTH;
stVarInfo.yres = SCREEN_HEIGHT;
stVarInfo.activate = FB_ACTIVATE_NOW;
stVarInfo.bits_per_pixel = 16;
stVarInfo.xoffset = 0;
stVarInfo.yoffset = 0;
stVarInfo.red = stR32;
stVarInfo.green = stG32;
stVarInfo.blue = stB32;
stVarInfo.transp = stA32;
if (ioctl(s32Fd, FBIOPUT_VSCREENINFO, &stVarInfo) < 0)
{
printf("process frame buffer device error\n");
goto FB_PROCESS_ERROR0;
}
if (ioctl(s32Fd, FBIOGET_FSCREENINFO, &stFixInfo) < 0)
{
printf("process frame buffer device error\n");
goto FB_PROCESS_ERROR0;
}
u32Size = stFixInfo.smem_len;
u32PhyAddr = stFixInfo.smem_start;
pu8Screen = mmap(NULL, u32Size, PROT_READ|PROT_WRITE, MAP_SHARED, s32Fd, 0);
if (NULL == pu8Screen)
{
printf("mmap fb0 failed!\n");
goto FB_PROCESS_ERROR0;
}
memset(pu8Screen, 0x00, stFixInfo.smem_len);
/* 3. create surface */
g_stScreen[0].enColorFmt = PIXFMT;
g_stScreen[0].u32PhyAddr = u32PhyAddr;
g_stScreen[0].u32Width = SCREEN_WIDTH;
g_stScreen[0].u32Height = SCREEN_HEIGHT;
g_stScreen[0].u32Stride = stFixInfo.line_length;
g_stScreen[0].bAlphaMax255 = HI_TRUE;
g_stScreen[1] = g_stScreen[0];
g_stScreen[1].u32PhyAddr = g_stScreen[0].u32PhyAddr + g_stScreen[0].u32Stride * g_stScreen[0].u32Height;
/* allocate memory (720*576*2*N_IMAGES bytes) to save Images' infornation */
if (HI_FAILURE == HI_MPI_SYS_MmzAlloc(&(g_stBackGround.u32PhyAddr), ((void**)&pu8BackGroundVir),
NULL, NULL, 720*576*2*N_IMAGES))
{
TDE_PRINT("allocate memory (720*576*2*N_IMAGES bytes) failed\n");
goto FB_PROCESS_ERROR1;
}
TDE_CreateSurfaceByFile(BACKGROUND_NAME, &g_stBackGround, pu8BackGroundVir);
g_stImgSur[0].u32PhyAddr = g_stBackGround.u32PhyAddr + g_stBackGround.u32Stride * g_stBackGround.u32Height;
for(i = 0; i < N_IMAGES - 1; i++)
{
TDE_CreateSurfaceByFile(pszImageNames[i], &g_stImgSur[i],
pu8BackGroundVir + ((HI_U32)g_stImgSur[i].u32PhyAddr - g_stBackGround.u32PhyAddr));
g_stImgSur[i+1].u32PhyAddr = g_stImgSur[i].u32PhyAddr + g_stImgSur[i].u32Stride * g_stImgSur[i].u32Height;
}
TDE_CreateSurfaceByFile(pszImageNames[i], &g_stImgSur[i],
pu8BackGroundVir + ((HI_U32)g_stImgSur[i].u32PhyAddr - g_stBackGround.u32PhyAddr));
bShow = HI_TRUE;
if (ioctl(s32Fd, FBIOPUT_SHOW_HIFB, &bShow) < 0)
{
fprintf (stderr, "Couldn't show fb\n");
goto FB_PROCESS_ERROR2;
}
g_s32FrameNum = 0;
/* 3. use tde and framebuffer to realize rotational effect */
for (u32Times = 0; u32Times < 20; u32Times++)
{
circumrotate(u32Times%2);
stVarInfo.yoffset = (u32Times%2)?0:576;
/*set frame buffer start position*/
if (ioctl(s32Fd, FBIOPAN_DISPLAY, &stVarInfo) < 0)
{
TDE_PRINT("process frame buffer device error\n");
goto FB_PROCESS_ERROR2;
}
sleep(1);
}
s32Ret = 0;
FB_PROCESS_ERROR2:
HI_MPI_SYS_MmzFree(g_stBackGround.u32PhyAddr, pu8BackGroundVir);
FB_PROCESS_ERROR1:
munmap(pu8Screen, u32Size);
FB_PROCESS_ERROR0:
close(s32Fd);
FB_OPEN_ERROR:
HI_TDE2_Close();
return s32Ret;
}
/******************************************************************************
* 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;
}
