关于海思osd菜单问题

本帖最后由 ngswfx 于 2016-6-16 18:53 编辑

[quote][url=forum.php?mod=redirect&goto=findpost&pid=31835&ptid=7681]love_lin 发表于 2016-6-16 16:29[/url]
谢谢指教，刚才看了下您发的链接，但是我没太看懂，我说说下我目前的状况：
1.我能实现单行的中文字位图， ...[/quote]

如果单行搞定了，多做几个bitmap，多次叠加到FBI的缓冲，就可以了。

别去折腾文件了，那是海斯给的例子而已，需要自己造缓冲。

我那个代码里面有2个关键的缓冲。

一个是OSDRGB，这个就是造文字叠加的缓冲。

还有一个是OSDBUf ,其实就是FBI的缓冲 ，是下面这个代码产生的缓冲。
if (HI_FAILURE == HI_MPI_SYS_MmzAlloc(&(stOsdCanvasBuf.stCanvas.u32PhyAddr), ((void**)&pOSDBuf),NULL, NULL, maxW*maxH*2)){
                close(fdOSD);fdOSD=0;
                return 0;
        }
///////////
你只要把OSDRGB，叠加好文字的缓冲生产好了，拷贝过去就好了。

例子中，只要寬高，1024 768。

/////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////实际绘制动作
        fdOSD=Check_InitOSD_ENV();  //代码允许多次执行
        if(!fdOSD){
                printf("IVHI_RefreshShowOsd_Text Check_InitOSD_ENV: pos3.9 error \n");
                return false;
        }
        memcpy(pOSDBuf,pOSDRGB,nW*nH*2); //将前面做好的带有文字的OSDRGB数据靠背给FBI缓冲pOSDBuf
        if(pOSDRGB)
                delete pOSDRGB;
        printf("IVHI_RefreshShowOsd_Text: pos4 _nWndWidth:%d _nWndHeight:%d \n",nW,nH);//就是屏幕寬高
        pOSDRGB=NULL;  //每次不同的文字内容，我这里都会重新分配OSDRGB，所以这里直接删除了
        ////////////////////////////////////////////////////////////////////
        stOsdCanvasBuf.UpdateRect.x = 0;
        stOsdCanvasBuf.UpdateRect.y = 0;
        stOsdCanvasBuf.UpdateRect.w = nW;
        stOsdCanvasBuf.UpdateRect.h = nH;  //由于OSDbuff和FBI是点对点的，所以坐标是0，0，寬，高
        if(fdOSD)
                s32Ret = ioctl(fdOSD, FBIO_REFRESH, &stOsdCanvasBuf);   //这里就会显示出来了

[quote][url=forum.php?mod=redirect&goto=findpost&pid=31855&ptid=7681]ngswfx 发表于 2016-6-16 18:43[/url]
如果单行搞定了，多做几个bitmap，多次叠加到FBI的缓冲，就可以了。

别去折腾文件了，那是海斯给的 ...[/quote]

首先谢谢您的帮助！！由于我第一次处理linux的图形层，所以还有很多不理解。
早上研究了您的思路，还是没成功，加入您的代码，很多定义我没理解，所以编译也没过。
1.MAX_SUPPORT_DEC_VIDEO_CHL=16 为何不是1，我们不是只要通过VO输出吗？
2.附件“HZ16Lib.c.tar.gz”里面变量值全是数字，不知道怎么和您的代码结合起来用？
3.“memcpy(pOSDBuf,pOSDRGB,nW*nH*2); //将前面做好的带有文字的OSDRGB数据靠背给FBI缓冲pOSDBuf”-->您的这句话是不是只要通过这个接口函数“void ShowSysWorkInfOSD()”把OSDRGB数据做好？但我看了接口代码的实现，怎么也理解它是怎么填充数据的。？
4.以下是我整理的海思的SAMPLE的例子，加载位图图像的，可实现的，但不知道怎么把您的代码整合进去。
望您能帮我看看！！
[code]/*
* =====================================================
*
*       Filename:  osd_menu.c
*
*    Description:  osd menu
*
*        Version:  
*        Created:  2016年06月03日 10时03分32秒
*       Revision:  none
*       Compiler:  arm-hisiv300-linux-gcc
*
*         Author:  CharLee
*   Organization:  Xiamen CloudTop Technology Co.,LTD
*
* =====================================================
*/

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

#include "sample_comm.h"

#include
#include "hifb.h"
#include "loadbmp.h"
#include "hi_tde_api.h"
#include "hi_tde_type.h"
#include "hi_tde_errcode.h"


static VO_LAYER VoLayer = 0;
static VO_DEV VoDev = SAMPLE_VO_DEV_DSD0;

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_1920             1920
#define HEIGHT_1080            1080
#define WIDTH_720              720
#define HEIGHT_576             576

#define SAMPLE_IMAGE_WIDTH     300
#define SAMPLE_IMAGE_HEIGHT    150
#define SAMPLE_IMAGE_SIZE      (300*150*2)
#define SAMPLE_IMAGE_NUM       20
#define HIFB_RED_1555   0xFC00

#define GRAPHICS_LAYER_G0  0

#define SAMPLE_IMAGE1_PATH                "./res/%d.bmp"

HI_S32 OSD_MENU_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_S32 OSD_MENU_HIFB_Refresh()
{
    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;
        int fd;
    HIFB_COLORKEY_S stColorKey;
    TDE2_RECT_S stSrcRect, stDstRect;
    TDE2_SURFACE_S stSrc, stDst;
    HI_U32 Phyaddr;
    HI_VOID* Viraddr;
    TDE_HANDLE s32Handle;

    fd = open("/dev/fb0", O_RDWR, 0);
    if (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(fd, FBIOPUT_COLORKEY_HIFB, &stColorKey) < 0)
    {
        SAMPLE_PRT("FBIOPUT_COLORKEY_HIFB!\n");
        close(fd);
        return HI_NULL;
    }
    s32Ret = ioctl(fd, FBIOGET_VSCREENINFO, &stVarInfo);
    if (s32Ret < 0)
    {
        SAMPLE_PRT("GET_VSCREENINFO failed!\n");
        close(fd);
        return HI_NULL;
    }

    if (ioctl(fd, FBIOPUT_SCREEN_ORIGIN_HIFB, &stPoint) < 0)
    {
        SAMPLE_PRT("set screen original show position failed!\n");
        close(fd);
        return HI_NULL;
    }

        maxW = WIDTH_720;
    maxH = HEIGHT_576;

    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(fd, FBIOPUT_VSCREENINFO, &stVarInfo);
    if (s32Ret < 0)
    {
        SAMPLE_PRT("PUT_VSCREENINFO failed!\n");
        close(fd);
        return HI_NULL;
    }
    stLayerInfo.BufMode = HIFB_LAYER_BUF_NONE;
    stLayerInfo.u32Mask = HIFB_LAYERMASK_BUFMODE;

    s32Ret = ioctl(fd, FBIOPUT_LAYER_INFO, &stLayerInfo);
    if (s32Ret < 0)
    {
        SAMPLE_PRT("PUT_LAYER_INFO failed!\n");
        close(fd);
        return HI_NULL;
    }
    bShow = HI_TRUE;
    if (ioctl(fd, FBIOPUT_SHOW_HIFB, &bShow) < 0)
    {
        SAMPLE_PRT("FBIOPUT_SHOW_HIFB failed!\n");
        close(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(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(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(fd);
        return HI_NULL;
    }

    /*time to play*/
        i = 0;
    for (;;)
    {
                snprintf(image_name, FILE_NAME_LEN, SAMPLE_IMAGE1_PATH, i % 2);
        pDst = (HI_U8*)Viraddr;
        OSD_MENU_LoadBmp(image_name, pDst);
                i++;

        /* 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(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(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(fd);
            return HI_NULL;
        }

        stCanvasBuf.UpdateRect.x = 180;
        stCanvasBuf.UpdateRect.y = 180;
        stCanvasBuf.UpdateRect.w = maxW;
        stCanvasBuf.UpdateRect.h = maxH;
        s32Ret = ioctl(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(fd);
            return HI_NULL;
        }
                sleep(2);

    }

    HI_MPI_SYS_MmzFree(Phyaddr, Viraddr);
    HI_MPI_SYS_MmzFree(stCanvasBuf.stCanvas.u32PhyAddr, pBuf);
    close(fd);

    return 0;;
}

/**********************************************
*
*  Name:        OSD_MENU_StartVoDev
*  Description:  start vo device
*  Param:       
*  Return:
*
*********************************************/
HI_S32 OSD_MENU_StartVoDev()
{
        HI_S32 s32Ret = HI_SUCCESS;

    HI_U32 u32PicWidth;
    HI_U32 u32PicHeight;
    SIZE_S  stSize;

    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));
    u32PicWidth = WIDTH_1920;
    u32PicHeight = HEIGHT_1080;

    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 OSD_MENU_START_VO_0;
    }

    /******************************************
     step 3:  start vo dev.
    *****************************************/
    stPubAttr.enIntfSync = VO_OUTPUT_1080P60;
    stPubAttr.enIntfType = VO_INTF_BT1120;
    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 OSD_MENU_START_VO_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 OSD_MENU_START_VO_1;
    }

    s32Ret = SAMPLE_COMM_VO_StartLayer(VoLayer, &stLayerAttr, HI_TRUE);
    if (HI_SUCCESS != s32Ret)
    {
        SAMPLE_PRT("start vo layer failed with %d!\n", s32Ret);
        goto OSD_MENU_START_VO_2;
    }
        return s32Ret;

OSD_MENU_START_VO_2:  
    SAMPLE_COMM_VO_StopLayer(VoLayer);
OSD_MENU_START_VO_1:
    SAMPLE_COMM_VO_StopDev(VoDev);
OSD_MENU_START_VO_0:
    SAMPLE_COMM_SYS_Exit();

    return s32Ret;
}

/**********************************************
*
*  Name:        OSD_MENU_HandleSig
*  Description:  ctrl + c / z
*  Param:       
*  Return:
*
*********************************************/
HI_VOID OSD_MENU_HandleSig(HI_S32 signo)
{
    if (SIGINT == signo || SIGTERM == signo)
    {
        /*        SAMPLE_COMM_VO_StopLayer(VoLayer);
                SAMPLE_COMM_VO_StopDev(VoDev);
        SAMPLE_COMM_SYS_Exit();*/
        printf("\033[0;31mprogram exit abnormally!\033[0;39m\n");
    }

    exit(0);
}
/**********************************************
*
*  Name:        main
*  Description:  Program execution entry
*  Param:        int argc, char *argv[]
*  Return: 0
*
*********************************************/
int main ( int argc, char *argv[] )
{
        char ch;
        HI_S32 s32Ret = HI_SUCCESS;

        signal(SIGINT,OSD_MENU_HandleSig);
        signal(SIGTERM,OSD_MENU_HandleSig);
/*       
        s32Ret = OSD_MENU_StartVoDev();
        if(HI_SUCCESS != s32Ret){
                printf("start vo device failed\n");
                return -1;
        }
*/
        OSD_MENU_HIFB_Refresh();
start:
        printf("Enter 'q' exit!\n");
        ch = (char)getchar();
        getchar();
        if(ch != 'q')
                goto start;

        return 0;
}/*End of Main*/
[/code]
我的理解是：只要用您的代码填充    /*change bmp*/
    (HI_FAILURE == HI_MPI_SYS_MmzAlloc(&Phyaddr, ((void**)&Viraddr),
                                          NULL, NULL, SAMPLE_IMAGE_WIDTH * SAMPLE_IMAGE_HEIGHT * 2))
    的BUFF？

//目前就是用海思接口，加载图片的！！

本帖最后由 ngswfx 于 2016-6-17 18:34 编辑

[quote][url=forum.php?mod=redirect&goto=findpost&pid=31880&ptid=7681]love_lin 发表于 2016-6-17 15:10[/url]
首先谢谢您的帮助！！由于我第一次处理linux的图形层，所以还有很多不理解。
早上研究了您的思路，还是 ...[/quote]

1、MAX_SUPPORT_DEC_VIDEO_CHL=16 这个你不用管他，自己一个值=1即可。源代码从我的项目里摘出来了，
里面是定义了一个芯片最大解码视频路数。
2、HZ16Lib.c.tar.gz解压后，是个.c文件，你直接强加到你的项目里，就行了，这个就是汉字的字库，有8000多个汉字。
3、填充汉字的过程，就在ShowOSD_DEC_BOX_MX里面，实际上在ShowOSD_MX，DrawOSD里面，它从字库文件中，根据汉字的区码，位码，每个汉字的每个点都取出来，叠加到pOSDRGB的指定位置。
4、HIFB，你应该已经弄OK了，所有的都加进去，ShowSysWorkInfOSD()替换OSD_MENU_HIFB_Refresh()就可以了。





////附件中是3520D的DEMO，里面叠加了3行，有汉字 数字。
debug目录下有个执行程序，在3520D上可以直接执行看效果。 uclibc版的。v100nptl交叉编译的

3520D 运行后，效果图

本帖最后由 love_lin 于 2016-6-17 18:12 编辑

[quote][url=forum.php?mod=redirect&goto=findpost&pid=31891&ptid=7681]ngswfx 发表于 2016-6-17 16:41[/url]
3520D 运行后，效果图[/quote]

谢谢您的帮忙！！
我已经把您的代码移植到我的，源码如下，但是显示出来有问题，效果图如下。
请帮忙看看哪里出了问题？
1.如果我把        maxW = WIDTH_720; maxH = HEIGHT_576;设置成1920和1080时，s32Ret = ioctl(fd, FBIOPUT_VSCREENINFO, &stVarInfo);会执行错误，不知道为何？
2.ShowOSD_DEC_BOX_MX((unsigned char *)pOSDRGB,videoChlOsd.strInf[j],videoChlOsd.nPosX[j],videoChlOsd.nPosY[j],nW,nH,videoChlOsd.nColor[j]);变量nW和nH的值是多少？
3.您提供的字库是.c文件，我把它改成.h了，不知道有没影响，.c我不知道怎么编译。
[code]/*
* =====================================================
*
*       Filename:  osd_menu.c
*
*    Description:  osd menu
*
*        Version:  
*        Created:  2016年06月03日 10时03分32秒
*       Revision:  none
*       Compiler:  arm-hisiv300-linux-gcc
*
*         Author:  CharLee
*   Organization:  Xiamen CloudTop Technology Co.,LTD
*
* =====================================================
*/

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

#include "sample_comm.h"

#include
#include "hifb.h"
#include "loadbmp.h"
#include "hi_tde_api.h"
#include "hi_tde_type.h"
#include "hi_tde_errcode.h"
#include "HZ16Lib.h"

#define WIDTH_1920             1920
#define HEIGHT_1080            1080
#define WIDTH_720              720
#define HEIGHT_576             576

#define SAMPLE_IMAGE_WIDTH     300
#define SAMPLE_IMAGE_HEIGHT    150
#define SAMPLE_IMAGE_SIZE      (300*150*2)
#define SAMPLE_IMAGE_NUM       20
#define HIFB_RED_1555   0xFC00

#define GRAPHICS_LAYER_G0  0

#define                                        HZLIB_ZISE                16
#define                                        UInt32        unsigned int
#define                                        UInt16        unsigned short
#define                                        UInt8        unsigned char
#define                                        Int8        char
#define                                        CLIP(a,b,c)    (((a)<(b))?(b):(((a)>(c))?(c):(a)))
#define                                        UCLIPI(a,b)    CLIP(a,0,b)
#define                                        HZLIB_ZISE                16
#define                                        MUX(a,b,c)     ((a)?(b):(c))
#define                                        INONZERO(a,b)     MUX(a,0,b)
#define                                        UBYTESEL(a, n)        ( (a>>(8*n)) && 0xff)
int                         g_real_HZ16_count;
unsigned short HZ16_Space[];
unsigned char         HZ16Lib[];

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 MAX_SUPPORT_DEC_VIDEO_CHL 1
#define MAX_SUPPORT_OSD_LINES                           4
#define MAX_SUPPORT_OSD_CHAR_NUM_ONE_LINE  32   //一行最大支持的字符数目
typedef struct IVHI_OSDEX
{
    bool bUse;//用于高速判断用
    int  nDisplay;//哪个显示器,第几个输出通道,对于3520等,只有一个,所以为0
    int  nChl;//这个指的是某个显示通道,例如某个屏幕上的某个画面
    int  nSupportLines;//支持的行数
    int  nPosX[MAX_SUPPORT_OSD_LINES];//坐标
    int  nPosY[MAX_SUPPORT_OSD_LINES];
    int  nColor[MAX_SUPPORT_OSD_LINES];//字符颜色
    char strInf[MAX_SUPPORT_OSD_LINES][MAX_SUPPORT_OSD_CHAR_NUM_ONE_LINE];
}IVHI_OSD;
IVHI_OSD      videoChlOsd[MAX_SUPPORT_DEC_VIDEO_CHL];
char * pOSDRGB = NULL;

void YtoRGB1555ToChar(unsigned char Y,unsigned char *rgb1555_0,unsigned char *rgb1555_1,int nColor)
{
    if(Y>0x01){
            Y=0xF0;
            switch(nColor){
            case 0://白色
                    *rgb1555_0=0xFF;
                    *rgb1555_1=0xFF;
            break;
            case 1://
                    *rgb1555_0=0x80;
                    *rgb1555_1=0x80;
                    break;
            case 2:
                    *rgb1555_0=0xFF;
                    *rgb1555_1=0x80;
                    break;
            case 3:
                    *rgb1555_0=0x14;
                    *rgb1555_1=0x14;
                    break;
            }
            return;
    }
}

void DrawOSD(unsigned char *buf, unsigned short *hzLib,int stride,int nColor)
{
    int i, font;
    int        lumi;
    bool lum=true;
    int *p1 = (int *)(buf+(stride<<4));
    float mult_f = (float)(lum?0.20:1);
    mult_f=0.5;
    float mult_b = 1 - mult_f;
    int avglum = (buf[0] + buf[1] + buf[2] + buf[3] + buf[4] +buf[5] + buf[6] + buf[7] + buf[8] + buf[9] + buf[10] +buf[11] + buf[12] + buf[13] + buf[14] + buf[15])/16;
    if(!lum&&(avglum>145))
            lumi = 0x1;
    else
            lumi = 0xff;
    //1字节个亮度信息转为2字节1555
    int nD=2;//翻倍
    unsigned short Y;
    int nPos=0;
    for (i=0; i<16; i++) {
            font = *hzLib ++;
            ///////////////  这里修改一下，如果开始的buf里面是背景数据的话，通过调整上面的几个参数可以实现取反，主要是avglum的作用，它先计算开始的数据情况，然后如果背景亮度大于145就变黑，我没搞到视频数据，所以暂时没实现，这里有点乱
    //        for (int j=0; j<32; j++) {
    //                buf[j]=BK_SCR_TRANS_COLOR_KEY;
    //        }
            nPos=0;//buf[0*nD]和buf[0*nD+1] 2个字节就是1555
            Y   = (unsigned char)MUX(font&0x0080, lumi*mult_f+buf[0*nD]*mult_b, buf[0*nD]); //这个就是一个Y 变成1555 2个字节
            YtoRGB1555ToChar(Y,buf+nPos*nD,buf+nPos*nD+1,nColor);
            nPos=1;
            Y   = (unsigned char)MUX(font&0x0040, lumi*mult_f+buf[1*nD]*mult_b, buf[1*nD]);
            YtoRGB1555ToChar(Y,buf+nPos*nD,buf+nPos*nD+1,nColor);
            nPos=2;
            Y   = (unsigned char)MUX(font&0x0020, lumi*mult_f+buf[2*nD]*mult_b, buf[2*nD]);
            YtoRGB1555ToChar(Y,buf+nPos*nD,buf+nPos*nD+1,nColor);
            nPos=3;
            Y   = (unsigned char)MUX(font&0x0010, lumi*mult_f+buf[3*nD]*mult_b, buf[3*nD]);
            YtoRGB1555ToChar(Y,buf+nPos*nD,buf+nPos*nD+1,nColor);
            nPos=4;
            Y   = (unsigned char)MUX(font&0x0008, lumi*mult_f+buf[4*nD]*mult_b, buf[4*nD]);
            YtoRGB1555ToChar(Y,buf+nPos*nD,buf+nPos*nD+1,nColor);
            nPos=5;
            Y   = (unsigned char)MUX(font&0x0004, lumi*mult_f+buf[5*nD]*mult_b,buf[5*nD]);
            YtoRGB1555ToChar(Y,buf+nPos*nD,buf+nPos*nD+1,nColor);
            nPos=6;
            Y   = (unsigned char)MUX(font&0x0002, lumi*mult_f+buf[6*nD]*mult_b,buf[6*nD]);
            YtoRGB1555ToChar(Y,buf+nPos*nD,buf+nPos*nD+1,nColor);
            nPos=7;
            Y   = (unsigned char)MUX(font&0x0001, lumi*mult_f+buf[7*nD]*mult_b,buf[7*nD]);
            YtoRGB1555ToChar(Y,buf+nPos*nD,buf+nPos*nD+1,nColor);
            nPos=8;
            Y   = (unsigned char)MUX(font&0x8000, lumi*mult_f+buf[8*nD]*mult_b,buf[8*nD]);
            YtoRGB1555ToChar(Y,buf+nPos*nD,buf+nPos*nD+1,nColor);
            nPos=9;
            Y   = (unsigned char)MUX(font&0x4000, lumi*mult_f+buf[9*nD]*mult_b,buf[9*nD]);
            YtoRGB1555ToChar(Y,buf+nPos*nD,buf+nPos*nD+1,nColor);
            nPos=10;
            Y = (unsigned char)MUX(font&0x2000, lumi*mult_f+buf[10*nD]*mult_b,  buf[10*nD]);
            YtoRGB1555ToChar(Y,buf+nPos*nD,buf+nPos*nD+1,nColor);
            nPos=11;
            Y = (unsigned char)MUX(font&0x1000, lumi*mult_f+buf[11*nD]*mult_b,  buf[11*nD]);
            YtoRGB1555ToChar(Y,buf+nPos*nD,buf+nPos*nD+1,nColor);
            nPos=12;
            Y = (unsigned char)MUX(font&0x0800, lumi*mult_f+buf[12*nD]*mult_b,  buf[12*nD]);
            YtoRGB1555ToChar(Y,buf+nPos*nD,buf+nPos*nD+1,nColor);
            nPos=13;
            Y = (unsigned char)MUX(font&0x0400, lumi*mult_f+buf[13*nD]*mult_b,  buf[13*nD]);
            YtoRGB1555ToChar(Y,buf+nPos*nD,buf+nPos*nD+1,nColor);
            nPos=14;
            Y = (unsigned char)MUX(font&0x0200, lumi*mult_f+buf[14*nD]*mult_b,  buf[14*nD]);
            YtoRGB1555ToChar(Y,buf+nPos*nD,buf+nPos*nD+1,nColor);
            nPos=15;
            Y = (unsigned char)MUX(font&0x0100, lumi*mult_f+buf[15*nD]*mult_b,  buf[15*nD]);
            YtoRGB1555ToChar(Y,buf+nPos*nD,buf+nPos*nD+1,nColor);
            /////////////////////////////////////////
            buf += stride*2;
    }

}
int  ShowOSD_DEC_BOX_MX(unsigned char *pBase, char *pStr, unsigned short x, unsigned short y,int width, int height,int nColor)
{
    if(!pBase||!pStr||width<1||height<1||x>width||y>=height)
            return 0;
    UInt32 nChar=0,wd=0,nOffset=0,nSize, l, r;

    Int8 q=3;
    Int8 w;
    Int8 *p=(char *)pStr;
    UInt8 *pHZLib=0;
    UInt8        *pp = (unsigned char *)p;
    pBase += width*2*y+x*2;
    while (*p) {
            pp = (unsigned char *)p;
            q = *p&0x80?(*p++)-161:2; // Get qu code
            w=((*p++)&0x7f)-33; // Get wei code
            if ((int)(nOffset = q*94+w) >= g_real_HZ16_count)
                    continue;
            pHZLib = (HZ16Lib+(nOffset<<5));
            if (q<10) {
                    l = UBYTESEL(HZ16_Space[nOffset],1);
                    r = UBYTESEL(HZ16_Space[nOffset],0);
                    nSize = HZLIB_ZISE-(l+r);
            }
            else {
                    nSize = HZLIB_ZISE;
                    l = r = 0;
            }
            if ((int)(x+wd+nSize)>width)
                    break;
            DrawOSD(pBase+(wd+nChar)*2,(unsigned short *)pHZLib,width,nColor);
            nChar++;
            wd += 14;//12 自体间距
    }

    return nChar;
}

static int OSD_MENU_Init()
{
        int i;
        int k = 0;
        int j;
        int nWndWidth = WIDTH_720;
        int nWndHeight = HEIGHT_576;
        for(i=0;i                 videoChlOsd.bUse=true;
                videoChlOsd.nDisplay=0;
                //videoChlOsd.nFlashShowSecond=0;
                //videoChlOsd.nLastFlashStartTimer=0;
                videoChlOsd.nChl=i;
                videoChlOsd.nSupportLines=4;
                j=0;
                sprintf(videoChlOsd.strInf[j],"CHL:%d",i);
                videoChlOsd.nPosX[j]=16;//坐标
                videoChlOsd.nPosY[j]=16;
                videoChlOsd.nColor[j]=0;//字符颜色
                j=1;
                sprintf(videoChlOsd.strInf[j],"温度-湿度");
                videoChlOsd.nPosX[j]=nWndWidth-400;//坐标  //1024为标准
                videoChlOsd.nPosY[j]=16;
                videoChlOsd.nColor[j]=1;//字符颜色
                j=2;
                sprintf(videoChlOsd.strInf[j],"OSD测试");
                videoChlOsd.nPosX[j]=16;//坐标
                videoChlOsd.nPosY[j]=nWndHeight-64;
                videoChlOsd.nColor[j]=2;//字符颜色
                j=3;
                sprintf(videoChlOsd.strInf[j],"IP:192.168.2.58");
                videoChlOsd.nPosX[j]=nWndWidth-400;//坐标
                videoChlOsd.nPosY[j]=nWndHeight-64;
                videoChlOsd.nColor[j]=3;//字符颜色
        }
        for(k = 0; k <= j;k++)
        {
                ShowOSD_DEC_BOX_MX((unsigned char *)pOSDRGB,videoChlOsd.strInf[k],videoChlOsd.nPosX[k],videoChlOsd.nPosY[k],nWndWidth,nWndHeight,videoChlOsd.nColor[k]);
        }
        return 0;
}

HI_S32 OSD_MENU_HIFB_Refresh()
{
    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;
        int fd;
    HIFB_COLORKEY_S stColorKey;
    TDE2_RECT_S stSrcRect, stDstRect;
    TDE2_SURFACE_S stSrc, stDst;
    HI_U32 Phyaddr;
    TDE_HANDLE s32Handle;

    fd = open("/dev/fb0", O_RDWR, 0);
    if (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(fd, FBIOPUT_COLORKEY_HIFB, &stColorKey) < 0)
    {
        SAMPLE_PRT("FBIOPUT_COLORKEY_HIFB!\n");
        close(fd);
        return HI_NULL;
    }
    s32Ret = ioctl(fd, FBIOGET_VSCREENINFO, &stVarInfo);
    if (s32Ret < 0)
    {
        SAMPLE_PRT("GET_VSCREENINFO failed!\n");
        close(fd);
        return HI_NULL;
    }

    if (ioctl(fd, FBIOPUT_SCREEN_ORIGIN_HIFB, &stPoint) < 0)
    {
        SAMPLE_PRT("set screen original show position failed!\n");
        close(fd);
        return HI_NULL;
    }

        maxW = WIDTH_720;
    maxH = HEIGHT_576;

    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(fd, FBIOPUT_VSCREENINFO, &stVarInfo);
    if (s32Ret < 0)
    {
        SAMPLE_PRT("PUT_VSCREENINFO failed!\n");
        close(fd);
        return HI_NULL;
    }
    stLayerInfo.BufMode = HIFB_LAYER_BUF_NONE;
    stLayerInfo.u32Mask = HIFB_LAYERMASK_BUFMODE;

    s32Ret = ioctl(fd, FBIOPUT_LAYER_INFO, &stLayerInfo);
    if (s32Ret < 0)
    {
        SAMPLE_PRT("PUT_LAYER_INFO failed!\n");
        close(fd);
        return HI_NULL;
    }
    bShow = HI_TRUE;
    if (ioctl(fd, FBIOPUT_SHOW_HIFB, &bShow) < 0)
    {
        SAMPLE_PRT("FBIOPUT_SHOW_HIFB failed!\n");
        close(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(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**)&pOSDRGB),
                                          NULL, NULL, SAMPLE_IMAGE_WIDTH * SAMPLE_IMAGE_HEIGHT * 2))
    {
        SAMPLE_PRT("allocate memory  failed\n");
        HI_MPI_SYS_MmzFree(stCanvasBuf.stCanvas.u32PhyAddr, pBuf);
        close(fd);
        return HI_NULL;
    }

    /*init osd menu*/
    OSD_MENU_Init();

        /*copy memeroy*/
        memcpy(pBuf,pOSDRGB,maxW*maxH*2);

        //stCanvasBuf.UpdateRect.x = 180;
        //stCanvasBuf.UpdateRect.y = 180;
        stCanvasBuf.UpdateRect.x = 0;
        stCanvasBuf.UpdateRect.y = 0;
        stCanvasBuf.UpdateRect.w = maxW;
        stCanvasBuf.UpdateRect.h = maxH;
        s32Ret = ioctl(fd, FBIO_REFRESH, &stCanvasBuf);
        if (s32Ret < 0)
        {
            SAMPLE_PRT("REFRESH failed!\n");
            HI_MPI_SYS_MmzFree(Phyaddr, pOSDRGB);
            HI_MPI_SYS_MmzFree(stCanvasBuf.stCanvas.u32PhyAddr, pBuf);
            close(fd);
            return HI_NULL;
        }


        sleep(15);
    HI_MPI_SYS_MmzFree(Phyaddr, pOSDRGB);
    HI_MPI_SYS_MmzFree(stCanvasBuf.stCanvas.u32PhyAddr, pBuf);
    close(fd);

    return 0;;
}

/**********************************************
*
*  Name:        OSD_MENU_HandleSig
*  Description:  ctrl + c / z
*  Param:       
*  Return:
*
*********************************************/
HI_VOID OSD_MENU_HandleSig(HI_S32 signo)
{
    if (SIGINT == signo || SIGTERM == signo)
    {
        printf("\033[0;31mprogram exit abnormally!\033[0;39m\n");
    }

    exit(0);
}
/**********************************************
*
*  Name:        main
*  Description:  Program execution entry
*  Param:        int argc, char *argv[]
*  Return: 0
*
*********************************************/
int main ( int argc, char *argv[] )
{
        char ch;
        HI_S32 s32Ret = HI_SUCCESS;

        signal(SIGINT,OSD_MENU_HandleSig);
        signal(SIGTERM,OSD_MENU_HandleSig);
/*       
        s32Ret = OSD_MENU_StartVoDev();
        if(HI_SUCCESS != s32Ret){
                printf("start vo device failed\n");
                return -1;
        }
*/
        OSD_MENU_HIFB_Refresh();
start:
        printf("Enter 'q' exit!\n");
        ch = (char)getchar();
        getchar();
        if(ch != 'q')
                goto start;

        return 0;
}/*End of Main*/
[/code]