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

1444 lines
40 KiB
C
Raw Blame History

/******************************************************************************
Copyright (C), 2011-2021, Hisilicon Tech. Co., Ltd.
******************************************************************************
File Name : sample_hifb.c
Version : Initial Draft
Author : Hisilicon multimedia software group
Created : 2013/7/1
Description :
History :
1.Date : 2013/7/1
Author :
Modification: Created file
******************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <sys/poll.h>
#include <sys/time.h>
#include <fcntl.h>
#include <errno.h>
#include <pthread.h>
#include <math.h>
#include <unistd.h>
#include <signal.h>
#include <sys/mman.h>
#include "sample_comm.h"
#include <linux/fb.h>
#include "hifb.h"
#include "loadbmp.h"
#include "hi_tde_api.h"
#include "hi_tde_type.h"
#include "hi_tde_errcode.h"
static VO_DEV VoDev = SAMPLE_VO_DEV_DSD0;
static HI_CHAR gs_cExitFlag = 0;
VO_INTF_TYPE_E g_enVoIntfType = VO_INTF_BT656;
static struct fb_bitfield s_r16 = {10, 5, 0};
static struct fb_bitfield s_g16 = {5, 5, 0};
static struct fb_bitfield s_b16 = {0, 5, 0};
static struct fb_bitfield s_a16 = {15, 1, 0};
#define WIDTH_720 720
#define HEIGHT_576 576
#define SAMPLE_IMAGE_WIDTH 300
#define SAMPLE_IMAGE_HEIGHT 150
#define SAMPLE_IMAGE_NUM 20
#define HIFB_RED_1555 0xFC00
#define GRAPHICS_LAYER_G0 0
#define SAMPLE_IMAGE1_PATH "./res/%d.bmp"
typedef struct hiPTHREAD_HIFB_SAMPLE
{
HI_S32 fd;
HI_S32 layer;
HI_S32 ctrlkey;
} PTHREAD_HIFB_SAMPLE_INFO;
HI_S32 SAMPLE_HIFB_LoadBmp(const char* filename, HI_U8* pAddr)
{
OSD_SURFACE_S Surface;
OSD_BITMAPFILEHEADER bmpFileHeader;
OSD_BITMAPINFO bmpInfo;
if (GetBmpInfo(filename, &bmpFileHeader, &bmpInfo) < 0)
{
SAMPLE_PRT("GetBmpInfo err!\n");
return HI_FAILURE;
}
Surface.enColorFmt = OSD_COLOR_FMT_RGB1555;
CreateSurfaceByBitMap(filename, &Surface, pAddr);
return HI_SUCCESS;
}
HI_VOID* SAMPLE_HIFB_PANDISPLAY(void* pData)
{
HI_S32 i, x, y, s32Ret;
TDE_HANDLE s32Handle;
struct fb_fix_screeninfo fix;
struct fb_var_screeninfo var;
HI_U32 u32FixScreenStride = 0;
HI_U8* pShowScreen;
HI_U8* pHideScreen;
HI_U32 u32HideScreenPhy = 0;
HI_U16* pShowLine;
HI_U16* ptemp = NULL;
HIFB_ALPHA_S stAlpha;
HIFB_POINT_S stPoint = {0, 0};
HI_CHAR file[12] = "/dev/fb0";
HI_CHAR image_name[128];
HI_U8* pDst = NULL;
HI_BOOL bShow;
PTHREAD_HIFB_SAMPLE_INFO* pstInfo;
HIFB_COLORKEY_S stColorKey;
TDE2_RECT_S stSrcRect, stDstRect;
TDE2_SURFACE_S stSrc, stDst;
HI_U32 Phyaddr;
HI_VOID* Viraddr;
HI_U32 u32Width;
HI_U32 u32Height;
if (VO_INTF_BT656 == g_enVoIntfType)
{
u32Width = WIDTH_720;
u32Height = HEIGHT_576;
}
else
{
u32Width = WIDTH_LCD;
u32Height = HEIGHT_LCD;
}
if (HI_NULL == pData)
{
return HI_NULL;
}
pstInfo = (PTHREAD_HIFB_SAMPLE_INFO*)pData;
switch (pstInfo->layer)
{
case GRAPHICS_LAYER_G0 :
strcpy(file, "/dev/fb0");
break;
default:
strcpy(file, "/dev/fb0");
break;
}
/* 1. open framebuffer device overlay 0 */
pstInfo->fd = open(file, O_RDWR, 0);
if (pstInfo->fd < 0)
{
SAMPLE_PRT("open %s failed!\n", file);
return HI_NULL;
}
bShow = HI_FALSE;
if (ioctl(pstInfo->fd, FBIOPUT_SHOW_HIFB, &bShow) < 0)
{
SAMPLE_PRT("FBIOPUT_SHOW_HIFB failed!\n");
return HI_NULL;
}
/* 2. set the screen original position */
switch (pstInfo->layer)
{
case GRAPHICS_LAYER_G0:
{
stPoint.s32XPos = 0;
stPoint.s32YPos = 0;
}
break;
default:
break;
}
if (ioctl(pstInfo->fd, FBIOPUT_SCREEN_ORIGIN_HIFB, &stPoint) < 0)
{
SAMPLE_PRT("set screen original show position failed!\n");
close(pstInfo->fd);
return HI_NULL;
}
/* 3. get the variable screen info */
if (ioctl(pstInfo->fd, FBIOGET_VSCREENINFO, &var) < 0)
{
SAMPLE_PRT("Get variable screen info failed!\n");
close(pstInfo->fd);
return HI_NULL;
}
/* 4. modify the variable screen info
the screen size: IMAGE_WIDTH*IMAGE_HEIGHT
the virtual screen size: VIR_SCREEN_WIDTH*VIR_SCREEN_HEIGHT
(which equals to VIR_SCREEN_WIDTH*(IMAGE_HEIGHT*2))
the pixel format: ARGB1555
*/
usleep(4 * 1000 * 1000);
switch (pstInfo->layer)
{
case GRAPHICS_LAYER_G0:
{
var.xres_virtual = u32Width;
var.yres_virtual = u32Height * 2;
var.xres = u32Width;
var.yres = u32Height;
}
break;
default:
break;
}
var.transp = s_a16;
var.red = s_r16;
var.green = s_g16;
var.blue = s_b16;
var.bits_per_pixel = 16;
var.activate = FB_ACTIVATE_NOW;
/* 5. set the variable screeninfo */
if (ioctl(pstInfo->fd, FBIOPUT_VSCREENINFO, &var) < 0)
{
SAMPLE_PRT("Put variable screen info failed!\n");
close(pstInfo->fd);
return HI_NULL;
}
/* 6. get the fix screen info */
if (ioctl(pstInfo->fd, FBIOGET_FSCREENINFO, &fix) < 0)
{
SAMPLE_PRT("Get fix screen info failed!\n");
close(pstInfo->fd);
return HI_NULL;
}
u32FixScreenStride = fix.line_length; /*fix screen stride*/
/* 7. map the physical video memory for user use */
pShowScreen = mmap(HI_NULL, fix.smem_len, PROT_READ | PROT_WRITE, MAP_SHARED, pstInfo->fd, 0);
if (MAP_FAILED == pShowScreen)
{
SAMPLE_PRT("mmap framebuffer failed!\n");
close(pstInfo->fd);
return HI_NULL;
}
memset(pShowScreen, 0x00, fix.smem_len);
/* time to play*/
bShow = HI_TRUE;
if (ioctl(pstInfo->fd, FBIOPUT_SHOW_HIFB, &bShow) < 0)
{
SAMPLE_PRT("FBIOPUT_SHOW_HIFB failed!\n");
munmap(pShowScreen, fix.smem_len);
close(pstInfo->fd);
return HI_NULL;
}
if (GRAPHICS_LAYER_G0 == pstInfo->layer)
{
for (i = 0; i < 1; i++)
{
if (i % 2)
{
var.yoffset = var.yres;
}
else
{
var.yoffset = 0;
}
ptemp = (HI_U16*)(pShowScreen + var.yres * u32FixScreenStride * (i % 2));
for (y = 10; y < 200; y++)
{
for (x = 10; x < 200; x++)
{
*(ptemp + y * var.xres + x) = HIFB_RED_1555;
}
}
SAMPLE_PRT("expected: the red box will appear!\n");
sleep(2);
stAlpha.bAlphaEnable = HI_TRUE;
stAlpha.u8Alpha0 = 0x0;
stAlpha.u8Alpha1 = 0x0;
if (ioctl(pstInfo->fd, FBIOPUT_ALPHA_HIFB, &stAlpha) < 0)
{
SAMPLE_PRT("Set alpha failed!\n");
close(pstInfo->fd);
return HI_NULL;
}
SAMPLE_PRT("expected: after set alpha = 0, the red box will disappear!\n");
sleep(2);
stAlpha.u8Alpha0 = 0;
stAlpha.u8Alpha1 = 0xFF;
if (ioctl(pstInfo->fd, FBIOPUT_ALPHA_HIFB, &stAlpha) < 0)
{
SAMPLE_PRT("Set alpha failed!\n");
close(pstInfo->fd);
return HI_NULL;
}
SAMPLE_PRT("expected:after set set alpha = 0xFF, the red box will appear again!\n");
sleep(2);
SAMPLE_PRT("expected: the red box will erased by colorkey!\n");
stColorKey.bKeyEnable = HI_TRUE;
stColorKey.u32Key = HIFB_RED_1555;
s32Ret = ioctl(pstInfo->fd, FBIOPUT_COLORKEY_HIFB, &stColorKey);
if (s32Ret < 0)
{
SAMPLE_PRT("FBIOPUT_COLORKEY_HIFB failed!\n");
close(pstInfo->fd);
return HI_NULL;
}
sleep(2);
SAMPLE_PRT("expected: the red box will appear again!\n");
stColorKey.bKeyEnable = HI_FALSE;
s32Ret = ioctl(pstInfo->fd, FBIOPUT_COLORKEY_HIFB, &stColorKey);
if (s32Ret < 0)
{
SAMPLE_PRT("FBIOPUT_COLORKEY_HIFB failed!\n");
close(pstInfo->fd);
return HI_NULL;
}
sleep(2);
}
}
/* show bitmap */
switch (pstInfo->ctrlkey)
{
case 2:
{
/*change bmp*/
if (HI_FAILURE == HI_MPI_SYS_MmzAlloc(&Phyaddr, ((void**)&Viraddr),
NULL, NULL, SAMPLE_IMAGE_WIDTH * SAMPLE_IMAGE_HEIGHT * 2))
{
SAMPLE_PRT("allocate memory (maxW*maxH*2 bytes) failed\n");
close(pstInfo->fd);
return HI_NULL;
}
s32Ret = HI_TDE2_Open();
if (s32Ret < 0)
{
SAMPLE_PRT("HI_TDE2_Open failed :%d!\n", s32Ret);
HI_MPI_SYS_MmzFree(Phyaddr, Viraddr);
close(pstInfo->fd);
return HI_NULL;
}
SAMPLE_PRT("expected:two red line!\n");
for (i = 0; i < SAMPLE_IMAGE_NUM; i++)
{
if ('q' == gs_cExitFlag)
{
printf("process exit...\n");
break;
}
/* step1: draw two red line*/
if (i % 2)
{
var.yoffset = var.yres;
}
else
{
var.yoffset = 0;
}
pHideScreen = pShowScreen + (u32FixScreenStride * var.yres) * (i % 2);
memset(pHideScreen, 0x00, u32FixScreenStride * var.yres);
u32HideScreenPhy = fix.smem_start + (i % 2) * u32FixScreenStride * var.yres;
pShowLine = (HI_U16*)pHideScreen;
for (y = (u32Height / 2 - 2); y < (u32Height / 2 + 2); y++)
{
for (x = 0; x < u32Width; x++)
{
*(pShowLine + y * var.xres + x) = HIFB_RED_1555;
}
}
for (y = 0; y < u32Height; y++)
{
for (x = (u32Width / 2 - 2); x < (u32Width / 2 + 2); x++)
{
*(pShowLine + y * var.xres + x) = HIFB_RED_1555;
}
}
if (ioctl(pstInfo->fd, FBIOPAN_DISPLAY, &var) < 0)
{
SAMPLE_PRT("FBIOPAN_DISPLAY failed!\n");
HI_MPI_SYS_MmzFree(Phyaddr, Viraddr);
close(pstInfo->fd);
return HI_NULL;
}
/* step2: draw gui picture*/
sprintf(image_name, SAMPLE_IMAGE1_PATH, i % 2);
pDst = (HI_U8*)Viraddr;
SAMPLE_HIFB_LoadBmp(image_name, pDst);
/* 0. open tde */
stSrcRect.s32Xpos = 0;
stSrcRect.s32Ypos = 0;
stSrcRect.u32Height = SAMPLE_IMAGE_HEIGHT;
stSrcRect.u32Width = SAMPLE_IMAGE_WIDTH;
stDstRect.s32Xpos = 0;
stDstRect.s32Ypos = 0;
stDstRect.u32Height = stSrcRect.u32Height;
stDstRect.u32Width = stSrcRect.u32Width;
stDst.enColorFmt = TDE2_COLOR_FMT_ARGB1555;
stDst.u32Width = u32Width;
stDst.u32Height = u32Height;
stDst.u32Stride = u32FixScreenStride;
stDst.u32PhyAddr = u32HideScreenPhy;
stSrc.enColorFmt = TDE2_COLOR_FMT_ARGB1555;
stSrc.u32Width = SAMPLE_IMAGE_WIDTH;
stSrc.u32Height = SAMPLE_IMAGE_HEIGHT;
stSrc.u32Stride = 2 * SAMPLE_IMAGE_WIDTH;
stSrc.u32PhyAddr = Phyaddr;
stSrc.bAlphaExt1555 = HI_TRUE;
stSrc.bAlphaMax255 = HI_TRUE;
stSrc.u8Alpha0 = 0XFF;
stSrc.u8Alpha1 = 0XFF;
/* 1. start job */
s32Handle = HI_TDE2_BeginJob();
if (HI_ERR_TDE_INVALID_HANDLE == s32Handle)
{
SAMPLE_PRT("start job failed!\n");
HI_MPI_SYS_MmzFree(Phyaddr, Viraddr);
close(pstInfo->fd);
return HI_NULL;
}
s32Ret = HI_TDE2_QuickCopy(s32Handle, &stSrc, &stSrcRect, &stDst, &stDstRect);
if (s32Ret < 0)
{
SAMPLE_PRT("HI_TDE2_QuickCopy:%d failed,ret=0x%x!\n", __LINE__, s32Ret);
HI_TDE2_CancelJob(s32Handle);
HI_MPI_SYS_MmzFree(Phyaddr, Viraddr);
close(pstInfo->fd);
return HI_NULL;
}
/* 3. submit job */
s32Ret = HI_TDE2_EndJob(s32Handle, HI_FALSE, HI_TRUE, 10);
if (s32Ret < 0)
{
SAMPLE_PRT("Line:%d,HI_TDE2_EndJob failed,ret=0x%x!\n", __LINE__, s32Ret);
HI_TDE2_CancelJob(s32Handle);
HI_MPI_SYS_MmzFree(Phyaddr, Viraddr);
close(pstInfo->fd);
return HI_NULL;
}
if (ioctl(pstInfo->fd, FBIOPAN_DISPLAY, &var) < 0)
{
SAMPLE_PRT("FBIOPAN_DISPLAY failed!\n");
HI_MPI_SYS_MmzFree(Phyaddr, Viraddr);
close(pstInfo->fd);
return HI_NULL;
}
sleep(1);
}
HI_TDE2_Close();
HI_MPI_SYS_MmzFree(Phyaddr, Viraddr);
}
break;
default:
{
}
}
/* unmap the physical memory */
munmap(pShowScreen, fix.smem_len);
bShow = HI_FALSE;
if (ioctl(pstInfo->fd, FBIOPUT_SHOW_HIFB, &bShow) < 0)
{
SAMPLE_PRT("FBIOPUT_SHOW_HIFB failed!\n");
close(pstInfo->fd);
return HI_NULL;
}
close(pstInfo->fd);
return HI_NULL;
}
HI_VOID* SAMPLE_HIFB_REFRESH(void* pData)
{
HI_S32 s32Ret = HI_SUCCESS;
HIFB_LAYER_INFO_S stLayerInfo = {0};
HIFB_BUFFER_S stCanvasBuf;
HI_U16* pBuf;
HI_U8* pDst = NULL;
HI_U32 x;
HI_U32 y;
HI_U32 i;
HI_CHAR image_name[128];
HI_BOOL bShow;
HIFB_POINT_S stPoint = {0};
struct fb_var_screeninfo stVarInfo;
HI_CHAR file[12] = "/dev/fb0";
HI_U32 maxW;
HI_U32 maxH;
PTHREAD_HIFB_SAMPLE_INFO* pstInfo;
HIFB_COLORKEY_S stColorKey;
TDE2_RECT_S stSrcRect, stDstRect;
TDE2_SURFACE_S stSrc, stDst;
HI_U32 Phyaddr;
HI_VOID* Viraddr;
TDE_HANDLE s32Handle;
if (HI_NULL == pData)
{
return HI_NULL;
}
pstInfo = (PTHREAD_HIFB_SAMPLE_INFO*)pData;
switch (pstInfo->layer)
{
case GRAPHICS_LAYER_G0:
strcpy(file, "/dev/fb0");
break;
default:
strcpy(file, "/dev/fb0");
break;
}
/* 1. open framebuffer device overlay 0 */
pstInfo->fd = open(file, O_RDWR, 0);
if (pstInfo->fd < 0)
{
SAMPLE_PRT("open %s failed!\n", file);
return HI_NULL;
}
/*all layer surport colorkey*/
stColorKey.bKeyEnable = HI_TRUE;
stColorKey.u32Key = 0x0;
if (ioctl(pstInfo->fd, FBIOPUT_COLORKEY_HIFB, &stColorKey) < 0)
{
SAMPLE_PRT("FBIOPUT_COLORKEY_HIFB!\n");
close(pstInfo->fd);
return HI_NULL;
}
s32Ret = ioctl(pstInfo->fd, FBIOGET_VSCREENINFO, &stVarInfo);
if (s32Ret < 0)
{
SAMPLE_PRT("GET_VSCREENINFO failed!\n");
close(pstInfo->fd);
return HI_NULL;
}
if (ioctl(pstInfo->fd, FBIOPUT_SCREEN_ORIGIN_HIFB, &stPoint) < 0)
{
SAMPLE_PRT("set screen original show position failed!\n");
close(pstInfo->fd);
return HI_NULL;
}
if (VO_INTF_BT656== g_enVoIntfType)
{
maxW = WIDTH_720;
maxH = HEIGHT_576;
}
else
{
maxW = WIDTH_LCD;
maxH = HEIGHT_LCD;
}
stVarInfo.transp = s_a16;
stVarInfo.red = s_r16;
stVarInfo.green = s_g16;
stVarInfo.blue = s_b16;
stVarInfo.bits_per_pixel = 16;
stVarInfo.activate = FB_ACTIVATE_NOW;
stVarInfo.xres = stVarInfo.xres_virtual = maxW;
stVarInfo.yres = stVarInfo.yres_virtual = maxH;
s32Ret = ioctl(pstInfo->fd, FBIOPUT_VSCREENINFO, &stVarInfo);
if (s32Ret < 0)
{
SAMPLE_PRT("PUT_VSCREENINFO failed!\n");
close(pstInfo->fd);
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)
{
SAMPLE_PRT("PUT_LAYER_INFO failed!\n");
close(pstInfo->fd);
return HI_NULL;
}
bShow = HI_TRUE;
if (ioctl(pstInfo->fd, FBIOPUT_SHOW_HIFB, &bShow) < 0)
{
SAMPLE_PRT("FBIOPUT_SHOW_HIFB failed!\n");
close(pstInfo->fd);
return HI_NULL;
}
if (HI_FAILURE == HI_MPI_SYS_MmzAlloc(&(stCanvasBuf.stCanvas.u32PhyAddr), ((void**)&pBuf),
NULL, NULL, maxW * maxH * 2))
{
SAMPLE_PRT("allocate memory (maxW*maxH*2 bytes) failed\n");
close(pstInfo->fd);
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);
/*change bmp*/
if (HI_FAILURE == HI_MPI_SYS_MmzAlloc(&Phyaddr, ((void**)&Viraddr),
NULL, NULL, SAMPLE_IMAGE_WIDTH * SAMPLE_IMAGE_HEIGHT * 2))
{
SAMPLE_PRT("allocate memory failed\n");
HI_MPI_SYS_MmzFree(stCanvasBuf.stCanvas.u32PhyAddr, pBuf);
close(pstInfo->fd);
return HI_NULL;
}
s32Ret = HI_TDE2_Open();
if (s32Ret < 0)
{
SAMPLE_PRT("HI_TDE2_Open failed :%d!\n", s32Ret);
HI_MPI_SYS_MmzFree(Phyaddr, Viraddr);
HI_MPI_SYS_MmzFree(stCanvasBuf.stCanvas.u32PhyAddr, pBuf);
close(pstInfo->fd);
return HI_NULL;
}
SAMPLE_PRT("expected:two red line!\n");
/*time to play*/
for (i = 0; i < SAMPLE_IMAGE_NUM; i++)
{
if ('q' == gs_cExitFlag)
{
printf("process exit...\n");
break;
}
for (y = (maxH / 2 - 2); y < (maxH / 2 + 2); y++)
{
for (x = 0; x < maxW; x++)
{
*(pBuf + y * maxW + x) = HIFB_RED_1555;
}
}
for (y = 0; y < maxH; y++)
{
for (x = (maxW / 2 - 2); x < (maxW / 2 + 2); x++)
{
*(pBuf + y * maxW + x) = HIFB_RED_1555;
}
}
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)
{
SAMPLE_PRT("REFRESH failed!\n");
HI_MPI_SYS_MmzFree(Phyaddr, Viraddr);
HI_MPI_SYS_MmzFree(stCanvasBuf.stCanvas.u32PhyAddr, pBuf);
close(pstInfo->fd);
return HI_NULL;
}
sleep(2);
sprintf(image_name, SAMPLE_IMAGE1_PATH, i % 2);
pDst = (HI_U8*)Viraddr;
SAMPLE_HIFB_LoadBmp(image_name, pDst);
/* 0. open tde */
stSrcRect.s32Xpos = 0;
stSrcRect.s32Ypos = 0;
stSrcRect.u32Height = SAMPLE_IMAGE_HEIGHT;
stSrcRect.u32Width = SAMPLE_IMAGE_WIDTH;
stDstRect.s32Xpos = 0;
stDstRect.s32Ypos = 0;
stDstRect.u32Height = stSrcRect.u32Width;
stDstRect.u32Width = stSrcRect.u32Width;
stDst.enColorFmt = TDE2_COLOR_FMT_ARGB1555;
stDst.u32Width = maxW;
stDst.u32Height = maxH;
stDst.u32Stride = maxW * 2;
stDst.u32PhyAddr = stCanvasBuf.stCanvas.u32PhyAddr;
stSrc.enColorFmt = TDE2_COLOR_FMT_ARGB1555;
stSrc.u32Width = SAMPLE_IMAGE_WIDTH;
stSrc.u32Height = SAMPLE_IMAGE_HEIGHT;
stSrc.u32Stride = 2 * SAMPLE_IMAGE_WIDTH;
stSrc.u32PhyAddr = Phyaddr;
stSrc.bAlphaExt1555 = HI_TRUE;
stSrc.bAlphaMax255 = HI_TRUE;
stSrc.u8Alpha0 = 0XFF;
stSrc.u8Alpha1 = 0XFF;
/* 1. start job */
s32Handle = HI_TDE2_BeginJob();
if (HI_ERR_TDE_INVALID_HANDLE == s32Handle)
{
SAMPLE_PRT("start job failed!\n");
HI_MPI_SYS_MmzFree(Phyaddr, Viraddr);
HI_MPI_SYS_MmzFree(stCanvasBuf.stCanvas.u32PhyAddr, pBuf);
close(pstInfo->fd);
return HI_NULL;
}
s32Ret = HI_TDE2_QuickCopy(s32Handle, &stSrc, &stSrcRect, &stDst, &stDstRect);
if (s32Ret < 0)
{
SAMPLE_PRT("HI_TDE2_QuickCopy:%d failed,ret=0x%x!\n", __LINE__, s32Ret);
HI_TDE2_CancelJob(s32Handle);
HI_MPI_SYS_MmzFree(Phyaddr, Viraddr);
HI_MPI_SYS_MmzFree(stCanvasBuf.stCanvas.u32PhyAddr, pBuf);
close(pstInfo->fd);
return HI_NULL;
}
/* 3. submit job */
s32Ret = HI_TDE2_EndJob(s32Handle, HI_FALSE, HI_TRUE, 10);
if (s32Ret < 0)
{
SAMPLE_PRT("Line:%d,HI_TDE2_EndJob failed,ret=0x%x!\n", __LINE__, s32Ret);
HI_TDE2_CancelJob(s32Handle);
HI_MPI_SYS_MmzFree(Phyaddr, Viraddr);
HI_MPI_SYS_MmzFree(stCanvasBuf.stCanvas.u32PhyAddr, pBuf);
close(pstInfo->fd);
return HI_NULL;
}
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)
{
SAMPLE_PRT("REFRESH failed!\n");
HI_MPI_SYS_MmzFree(Phyaddr, Viraddr);
HI_MPI_SYS_MmzFree(stCanvasBuf.stCanvas.u32PhyAddr, pBuf);
close(pstInfo->fd);
return HI_NULL;
}
sleep(2);
}
HI_MPI_SYS_MmzFree(Phyaddr, Viraddr);
HI_MPI_SYS_MmzFree(stCanvasBuf.stCanvas.u32PhyAddr, pBuf);
close(pstInfo->fd);
return HI_NULL;
}
HI_VOID SAMPLE_HIFB_HandleSig(HI_S32 signo)
{
if (SIGINT == signo || SIGTSTP == signo)
{
SAMPLE_COMM_SYS_Exit();
printf("\033[0;31mprogram exit abnormally!\033[0;39m\n");
}
exit(0);
}
HI_VOID SAMPLE_HIFB_Usage1(HI_CHAR* sPrgNm)
{
printf("Usage : %s <intf>\n", sPrgNm);
printf("intf:\n");
printf("\t 0) vo BT656 output, default.\n");
printf("\t 1) vo LCD output.\n");
return;
}
HI_VOID SAMPLE_HIFB_Usage2(HI_VOID)
{
printf("\n\n/************************************/\n");
printf("please choose the case which you want to run:\n");
printf("\t0: ARGB1555 standard mode\n");
printf("\t1: ARGB1555 BUF_DOUBLE mode\n");
printf("\t2: ARGB1555 BUF_ONE mode\n");
printf("\t3: ARGB1555 BUF_NONE mode\n");
printf("\tq: quit the whole sample\n");
printf("sample command:");
return;
}
HI_S32 SAMPLE_HIFB_StandardMode(HI_VOID)
{
HI_S32 s32Ret = HI_SUCCESS;
pthread_t phifb0 = -1;
PTHREAD_HIFB_SAMPLE_INFO stInfo0;
HI_U32 u32PicWidth;
HI_U32 u32PicHeight;
SIZE_S stSize;
VO_LAYER VoLayer = 0;
VO_PUB_ATTR_S stPubAttr;
VO_VIDEO_LAYER_ATTR_S stLayerAttr;
HI_U32 u32VoFrmRate;
VB_CONF_S stVbConf;
HI_U32 u32BlkSize;
/******************************************
step 1: init variable
******************************************/
memset(&stVbConf, 0, sizeof(VB_CONF_S));
if (VO_INTF_BT656 == g_enVoIntfType)
{
u32PicWidth = WIDTH_720;
u32PicHeight = HEIGHT_576;
}
else
{
u32PicWidth = WIDTH_LCD;
u32PicHeight = HEIGHT_LCD;
}
u32BlkSize = CEILING_2_POWER(u32PicWidth, SAMPLE_SYS_ALIGN_WIDTH)\
* CEILING_2_POWER(u32PicHeight, SAMPLE_SYS_ALIGN_WIDTH) * 2;
stVbConf.u32MaxPoolCnt = 128;
stVbConf.astCommPool[0].u32BlkSize = u32BlkSize;
stVbConf.astCommPool[0].u32BlkCnt = 6;
/******************************************
step 2: mpp system init.
******************************************/
s32Ret = SAMPLE_COMM_SYS_Init(&stVbConf);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("system init failed with %d!\n", s32Ret);
goto SAMPLE_HIFB_NoneBufMode_0;
}
/******************************************
step 3: start vo dev.
*****************************************/
if (VO_INTF_BT656 == g_enVoIntfType)
{
stPubAttr.enIntfSync = VO_OUTPUT_PAL;
stPubAttr.enIntfType = g_enVoIntfType;
stPubAttr.u32BgColor = 0x0000FF;
}
else
{
stPubAttr.enIntfSync = SYNC_LCD;
stPubAttr.enIntfType = g_enVoIntfType;
stPubAttr.u32BgColor = 0x0000FF;
}
stLayerAttr.bClusterMode = HI_FALSE;
stLayerAttr.bDoubleFrame = HI_FALSE;
stLayerAttr.enPixFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420;
s32Ret = SAMPLE_COMM_VO_GetWH(stPubAttr.enIntfSync, &stSize.u32Width, \
&stSize.u32Height, &u32VoFrmRate);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("get vo wh failed with %d!\n", s32Ret);
goto SAMPLE_HIFB_NoneBufMode_0;
}
memcpy(&stLayerAttr.stImageSize, &stSize, sizeof(stSize));
stLayerAttr.u32DispFrmRt = 30 ;
stLayerAttr.stDispRect.s32X = 0;
stLayerAttr.stDispRect.s32Y = 0;
stLayerAttr.stDispRect.u32Width = stSize.u32Width;
stLayerAttr.stDispRect.u32Height = stSize.u32Height;
s32Ret = SAMPLE_COMM_VO_StartDev(VoDev, &stPubAttr);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("start vo dev failed with %d!\n", s32Ret);
goto SAMPLE_HIFB_NoneBufMode_0;
}
s32Ret = SAMPLE_COMM_VO_StartLayer(VoLayer, &stLayerAttr, HI_TRUE);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("start vo layer failed with %d!\n", s32Ret);
goto SAMPLE_HIFB_NoneBufMode_1;
}
/******************************************
step 4: start hifb.
*****************************************/
stInfo0.layer = 0;
stInfo0.fd = -1;
stInfo0.ctrlkey = 2;
pthread_create(&phifb0, 0, SAMPLE_HIFB_PANDISPLAY, (void*)(&stInfo0));
while (1)
{
HI_CHAR ch;
printf("press 'q' to exit this sample.\n");
ch = (char)getchar();
getchar();
if ('q' == ch)
{
gs_cExitFlag = ch;
break;
}
else
{
printf("input invaild! please try again.\n");
}
}
if (-1 != phifb0)
{
pthread_join(phifb0, 0);
}
SAMPLE_COMM_VO_StopLayer(VoLayer);
SAMPLE_HIFB_NoneBufMode_1:
SAMPLE_COMM_VO_StopDev(VoDev);
SAMPLE_HIFB_NoneBufMode_0:
SAMPLE_COMM_SYS_Exit();
return s32Ret;
}
HI_S32 SAMPLE_HIFB_DoubleBufMode(HI_VOID)
{
HI_S32 s32Ret = HI_SUCCESS;
pthread_t phifb0 = -1;
PTHREAD_HIFB_SAMPLE_INFO stInfo0;
HI_U32 u32PicWidth;
HI_U32 u32PicHeight;
SIZE_S stSize;
VO_LAYER VoLayer = 0;
VO_PUB_ATTR_S stPubAttr;
VO_VIDEO_LAYER_ATTR_S stLayerAttr;
HI_U32 u32VoFrmRate;
VB_CONF_S stVbConf;
HI_U32 u32BlkSize;
/******************************************
step 1: init variable
******************************************/
memset(&stVbConf, 0, sizeof(VB_CONF_S));
if (VO_INTF_BT656 == g_enVoIntfType)
{
u32PicWidth = WIDTH_720;
u32PicHeight = HEIGHT_576;
}
else
{
u32PicWidth = WIDTH_LCD;
u32PicHeight = HEIGHT_LCD;
}
u32BlkSize = CEILING_2_POWER(u32PicWidth, SAMPLE_SYS_ALIGN_WIDTH)\
* CEILING_2_POWER(u32PicHeight, SAMPLE_SYS_ALIGN_WIDTH) * 2;
stVbConf.u32MaxPoolCnt = 128;
stVbConf.astCommPool[0].u32BlkSize = u32BlkSize;
stVbConf.astCommPool[0].u32BlkCnt = 6;
/******************************************
step 2: mpp system init.
******************************************/
s32Ret = SAMPLE_COMM_SYS_Init(&stVbConf);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("system init failed with %d!\n", s32Ret);
goto SAMPLE_HIFB_DoubleBufMode_0;
}
/******************************************
step 3: start vo dev.
*****************************************/
if (VO_INTF_BT656 == g_enVoIntfType)
{
stPubAttr.enIntfSync = VO_OUTPUT_PAL;
stPubAttr.enIntfType = g_enVoIntfType;
stPubAttr.u32BgColor = 0x0000FF;
}
else
{
stPubAttr.enIntfSync = SYNC_LCD;
stPubAttr.enIntfType = g_enVoIntfType;
stPubAttr.u32BgColor = 0x0000FF;
}
stLayerAttr.bClusterMode = HI_FALSE;
stLayerAttr.bDoubleFrame = HI_FALSE;
stLayerAttr.enPixFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420;
s32Ret = SAMPLE_COMM_VO_GetWH(stPubAttr.enIntfSync, &stSize.u32Width, \
&stSize.u32Height, &u32VoFrmRate);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("get vo wh failed with %d!\n", s32Ret);
goto SAMPLE_HIFB_DoubleBufMode_0;
}
memcpy(&stLayerAttr.stImageSize, &stSize, sizeof(stSize));
stLayerAttr.u32DispFrmRt = 30 ;
stLayerAttr.stDispRect.s32X = 0;
stLayerAttr.stDispRect.s32Y = 0;
stLayerAttr.stDispRect.u32Width = stSize.u32Width;
stLayerAttr.stDispRect.u32Height = stSize.u32Height;
s32Ret = SAMPLE_COMM_VO_StartDev(VoDev, &stPubAttr);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("start vo dev failed with %d!\n", s32Ret);
goto SAMPLE_HIFB_DoubleBufMode_0;
}
s32Ret = SAMPLE_COMM_VO_StartLayer(VoLayer, &stLayerAttr, HI_TRUE);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("start vo layer failed with %d!\n", s32Ret);
goto SAMPLE_HIFB_DoubleBufMode_1;
}
/******************************************
step 4: start hifb.
*****************************************/
stInfo0.layer = 0;
stInfo0.fd = -1;
stInfo0.ctrlkey = 1;
pthread_create(&phifb0, 0, SAMPLE_HIFB_REFRESH, (void*)(&stInfo0));
while (1)
{
HI_CHAR ch;
printf("press 'q' to exit this sample.\n");
ch = (char)getchar();
getchar();
if ('q' == ch)
{
gs_cExitFlag = ch;
break;
}
else
{
printf("input invaild! please try again.\n");
}
}
if (-1 != phifb0)
{
pthread_join(phifb0, 0);
}
SAMPLE_COMM_VO_StopLayer(VoLayer);
SAMPLE_HIFB_DoubleBufMode_1:
HI_MPI_VO_Disable(VoDev);
SAMPLE_HIFB_DoubleBufMode_0:
SAMPLE_COMM_SYS_Exit();
return s32Ret;
}
HI_S32 SAMPLE_HIFB_OneBufMode(HI_VOID)
{
HI_S32 s32Ret = HI_SUCCESS;
pthread_t phifb0 = -1;
PTHREAD_HIFB_SAMPLE_INFO stInfo0;
HI_U32 u32PicWidth;
HI_U32 u32PicHeight;
SIZE_S stSize;
VO_LAYER VoLayer = 0;
VO_PUB_ATTR_S stPubAttr;
VO_VIDEO_LAYER_ATTR_S stLayerAttr;
HI_U32 u32VoFrmRate;
VB_CONF_S stVbConf;
HI_U32 u32BlkSize;
/******************************************
step 1: init variable
******************************************/
memset(&stVbConf, 0, sizeof(VB_CONF_S));
if (VO_INTF_BT656 == g_enVoIntfType)
{
u32PicWidth = WIDTH_720;
u32PicHeight = HEIGHT_576;
}
else
{
u32PicWidth = WIDTH_LCD;
u32PicHeight = HEIGHT_LCD;
}
u32BlkSize = CEILING_2_POWER(u32PicWidth, SAMPLE_SYS_ALIGN_WIDTH)\
* CEILING_2_POWER(u32PicHeight, SAMPLE_SYS_ALIGN_WIDTH) * 2;
stVbConf.u32MaxPoolCnt = 128;
stVbConf.astCommPool[0].u32BlkSize = u32BlkSize;
stVbConf.astCommPool[0].u32BlkCnt = 6;
/******************************************
step 2: mpp system init.
******************************************/
s32Ret = SAMPLE_COMM_SYS_Init(&stVbConf);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("system init failed with %d!\n", s32Ret);
goto SAMPLE_HIFB_OneBufMode_0;
}
/******************************************
step 3: start vo dev.
*****************************************/
if (VO_INTF_BT656 == g_enVoIntfType)
{
stPubAttr.enIntfSync = VO_OUTPUT_PAL;
stPubAttr.enIntfType = g_enVoIntfType;
stPubAttr.u32BgColor = 0x0000FF;
}
else
{
stPubAttr.enIntfSync = SYNC_LCD;
stPubAttr.enIntfType = g_enVoIntfType;
stPubAttr.u32BgColor = 0x0000FF;
}
stLayerAttr.bClusterMode = HI_FALSE;
stLayerAttr.bDoubleFrame = HI_FALSE;
stLayerAttr.enPixFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420;
s32Ret = SAMPLE_COMM_VO_GetWH(stPubAttr.enIntfSync, &stSize.u32Width, \
&stSize.u32Height, &u32VoFrmRate);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("get vo wh failed with %d!\n", s32Ret);
goto SAMPLE_HIFB_OneBufMode_0;
}
memcpy(&stLayerAttr.stImageSize, &stSize, sizeof(stSize));
stLayerAttr.u32DispFrmRt = 30 ;
stLayerAttr.stDispRect.s32X = 0;
stLayerAttr.stDispRect.s32Y = 0;
stLayerAttr.stDispRect.u32Width = stSize.u32Width;
stLayerAttr.stDispRect.u32Height = stSize.u32Height;
s32Ret = SAMPLE_COMM_VO_StartDev(VoDev, &stPubAttr);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("start vo dev failed with %d!\n", s32Ret);
goto SAMPLE_HIFB_OneBufMode_0;
}
s32Ret = SAMPLE_COMM_VO_StartLayer(VoLayer, &stLayerAttr, HI_TRUE);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("start vo layer failed with %d!\n", s32Ret);
goto SAMPLE_HIFB_OneBufMode_1;
}
/******************************************
step 4: start hifb.
*****************************************/
stInfo0.layer = 0;
stInfo0.fd = -1;
stInfo0.ctrlkey = 0;
pthread_create(&phifb0, 0, SAMPLE_HIFB_REFRESH, (void*)(&stInfo0));
while (1)
{
HI_CHAR ch;
printf("press 'q' to exit this sample.\n");
ch = (char)getchar();
getchar();
if ('q' == ch)
{
gs_cExitFlag = ch;
break;
}
else
{
printf("input invaild! please try again.\n");
}
}
if (-1 != phifb0)
{
pthread_join(phifb0, 0);
}
SAMPLE_COMM_VO_StopLayer(VoLayer);
SAMPLE_HIFB_OneBufMode_1:
HI_MPI_VO_Disable(VoDev);
SAMPLE_HIFB_OneBufMode_0:
SAMPLE_COMM_SYS_Exit();
return s32Ret;
}
HI_S32 SAMPLE_HIFB_NoneBufMode(HI_VOID)
{
HI_S32 s32Ret = HI_SUCCESS;
pthread_t phifb0 = -1;
PTHREAD_HIFB_SAMPLE_INFO stInfo0;
HI_U32 u32PicWidth;
HI_U32 u32PicHeight;
SIZE_S stSize;
VO_LAYER VoLayer = 0;
VO_PUB_ATTR_S stPubAttr;
VO_VIDEO_LAYER_ATTR_S stLayerAttr;
HI_U32 u32VoFrmRate;
VB_CONF_S stVbConf;
HI_U32 u32BlkSize;
/******************************************
step 1: init variable
******************************************/
memset(&stVbConf, 0, sizeof(VB_CONF_S));
if (VO_INTF_BT656 == g_enVoIntfType)
{
u32PicWidth = WIDTH_720;
u32PicHeight = HEIGHT_576;
}
else
{
u32PicWidth = WIDTH_LCD;
u32PicHeight = HEIGHT_LCD;
}
u32BlkSize = CEILING_2_POWER(u32PicWidth, SAMPLE_SYS_ALIGN_WIDTH)\
* CEILING_2_POWER(u32PicHeight, SAMPLE_SYS_ALIGN_WIDTH) * 2;
stVbConf.u32MaxPoolCnt = 128;
stVbConf.astCommPool[0].u32BlkSize = u32BlkSize;
stVbConf.astCommPool[0].u32BlkCnt = 6;
/******************************************
step 2: mpp system init.
******************************************/
s32Ret = SAMPLE_COMM_SYS_Init(&stVbConf);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("system init failed with %d!\n", s32Ret);
goto SAMPLE_HIFB_NoneBufMode_0;
}
/******************************************
step 3: start vo dev.
*****************************************/
if (VO_INTF_BT656 == g_enVoIntfType)
{
stPubAttr.enIntfSync = VO_OUTPUT_PAL;
stPubAttr.enIntfType = g_enVoIntfType;
stPubAttr.u32BgColor = 0x0000FF;
}
else
{
stPubAttr.enIntfSync = SYNC_LCD;
stPubAttr.enIntfType = g_enVoIntfType;
stPubAttr.u32BgColor = 0x0000FF;
}
stLayerAttr.bClusterMode = HI_FALSE;
stLayerAttr.bDoubleFrame = HI_FALSE;
stLayerAttr.enPixFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420;
s32Ret = SAMPLE_COMM_VO_GetWH(stPubAttr.enIntfSync, &stSize.u32Width, \
&stSize.u32Height, &u32VoFrmRate);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("get vo wh failed with %d!\n", s32Ret);
goto SAMPLE_HIFB_NoneBufMode_0;
}
memcpy(&stLayerAttr.stImageSize, &stSize, sizeof(stSize));
stLayerAttr.u32DispFrmRt = 30 ;
stLayerAttr.stDispRect.s32X = 0;
stLayerAttr.stDispRect.s32Y = 0;
stLayerAttr.stDispRect.u32Width = stSize.u32Width;
stLayerAttr.stDispRect.u32Height = stSize.u32Height;
s32Ret = SAMPLE_COMM_VO_StartDev(VoDev, &stPubAttr);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("start vo dev failed with %d!\n", s32Ret);
goto SAMPLE_HIFB_NoneBufMode_0;
}
s32Ret = SAMPLE_COMM_VO_StartLayer(VoLayer, &stLayerAttr, HI_TRUE);
if (HI_SUCCESS != s32Ret)
{
SAMPLE_PRT("start vo layer failed with %d!\n", s32Ret);
goto SAMPLE_HIFB_NoneBufMode_1;
}
/******************************************
step 4: start hifb.
*****************************************/
stInfo0.layer = 0;
stInfo0.fd = -1;
stInfo0.ctrlkey = 3;
pthread_create(&phifb0, 0, SAMPLE_HIFB_REFRESH, (void*)(&stInfo0));
while (1)
{
HI_CHAR ch;
printf("press 'q' to exit this sample.\n");
ch = (char)getchar();
getchar();
if ('q' == ch)
{
gs_cExitFlag = ch;
break;
}
else
{
printf("input invaild! please try again.\n");
}
}
if (-1 != phifb0)
{
pthread_join(phifb0, 0);
}
SAMPLE_COMM_VO_StopLayer(VoLayer);
SAMPLE_HIFB_NoneBufMode_1:
HI_MPI_VO_Disable(VoDev);
SAMPLE_HIFB_NoneBufMode_0:
SAMPLE_COMM_SYS_Exit();
return s32Ret;
}
int main(int argc, char* argv[])
{
HI_S32 s32Ret = HI_SUCCESS;
HI_CHAR ch;
HI_BOOL bExit = HI_FALSE;
if ( (argc < 2) || (1 != strlen(argv[1])))
{
SAMPLE_HIFB_Usage1(argv[0]);
return HI_FAILURE;
}
signal(SIGINT, SAMPLE_HIFB_HandleSig);
signal(SIGTERM, SAMPLE_HIFB_HandleSig);
if ((argc > 1) && *argv[1] == '1') /* '0': VO_INTF_CVBS, else: BT1120 */
{
g_enVoIntfType = INTF_LCD;
}
/******************************************
1 choose the case
******************************************/
while (1)
{
SAMPLE_HIFB_Usage2();
gs_cExitFlag = 0;
ch = (char)getchar();
getchar();
switch (ch)
{
case '0':
{
SAMPLE_HIFB_StandardMode();
break;
}
case '1':
{
SAMPLE_HIFB_DoubleBufMode();
break;
}
case '2':
{
SAMPLE_HIFB_OneBufMode();
break;
}
case '3':
{
SAMPLE_HIFB_NoneBufMode();
break;
}
case 'q':
case 'Q':
{
bExit = HI_TRUE;
break;
}
default :
{
printf("input invaild! please try again.\n");
break;
}
}
if (bExit)
{
break;
}
}
return s32Ret;
}
Reference in New Issue View Git Blame Copy Permalink