【已解决】关于Hi3516A做OSD的问题

希望大家多多帮助，不胜感激:hug:

第一个问题可以利用overlay的alpha来处理,当然BMP图像要处理成有alpha的
第二个问题就是把几个BMP合成一个BMP而已

[quote][url=forum.php?mod=redirect&goto=findpost&pid=26508&ptid=10385]zhuangweiye 发表于 2016-3-14 17:25[/url]
第一个问题可以利用overlay的alpha来处理,当然BMP图像要处理成有alpha的
第二个问题就是把几个BMP合成一个 ...[/quote]

非常感谢您的回答，想再请问一下
1，我目前设置的Overlay的fgAlpha值，但是整个字符和背景均变透明了，无法实现去除背景颜色的效果。
2，合成几个BMP图片需要如何实现呢，这个SDL库能够实现吗

当Alpha 位为1时，芯片使用u32FgAlpha 进行透明度叠加；
当Alpha 位为0时，芯片使用u32BgAlpha 进行透明度叠加。
 0 表示全透明；128表示不透明。

而你的BMP的每个象素都是一种alpha的当然就只能一起变了,把要透明的像素的alpha和不要透明的像素的alpha设成不一样的
注意:这里讨论的实BMP图,而不是RGN的设定
举例:
比如你的BMP有两个像素(假设是16bits, RGN设为ARGB1555格式) ,假设BMP的buffer为[0x0000, 0x0123], 可以看出前一个点为黑色,后一个点为有色点,如果要黑点透明,那么要把黑点的值改为
0x8000, 同时u32FgAlpha=0, u32BgAlpha=128
这样一来有色点就留下了,黑点就透明了被下面的视频代替了


关于BMP合并,如果格式相同,就是简单的内存搬移了,很简单

可以分配一个大的内存,用SDL生成两个BMP内存,然后搬到大的内存就好了,只要注意下起始地址,高,宽和stride就可以了
然后把大的内存做为osd送给海思就能显示多行了

[quote][url=forum.php?mod=redirect&goto=findpost&pid=26513&ptid=10385]zhuangweiye 发表于 2016-3-14 18:15[/url]
当Alpha 位为1时，芯片使用u32FgAlpha 进行透明度叠加；
当Alpha 位为0时，芯片使用u32BgAlpha 进行透明度 ...[/quote]

非常感谢您的耐心回答， 我这边马上按照您的思路去做一下:loveliness:

楼主，你这是获取系统时间的吧，那你实现了时间戳功能了吗？字体使用哪个文件库的？

[quote][url=forum.php?mod=redirect&goto=findpost&pid=26513&ptid=10385]zhuangweiye 发表于 2016-3-14 18:15[/url]
当Alpha 位为1时，芯片使用u32FgAlpha 进行透明度叠加；
当Alpha 位为0时，芯片使用u32BgAlpha 进行透明度 ...[/quote]

前辈，我在网上查了很多资料，但是由于对BMP图像和SDL的不熟悉，还是很难实现您说的那几个步骤，请问下，能不能再指点一下，具体的实现步骤呢

你已经做了99%的工作了

还差1%

把你的HI_MPI_RGN_Create()/HI_MPI_RGN_AttachToChn()/HI_MPI_RGN_SetBitMap()的设置部分代码贴一下

本帖最后由 domenor 于 2017-3-9 09:24 编辑

[quote][url=forum.php?mod=redirect&goto=findpost&pid=26569&ptid=10385]zhuangweiye 发表于 2016-3-15 15:21[/url]
你已经做了99%的工作了

还差1%
[/quote]

[code]

#include "SDL/SDL.h"  
#include "SDL_ttf/SDL_ttf.h"  
#include "loadbmp.h"

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

typedef struct hiRGN_OSD_REVERSE_INFO_S
{
    RGN_HANDLE Handle;
    HI_U8 u8PerPixelLumaThrd;

    VPSS_GRP VpssGrp;
    VPSS_CHN VpssChn;
    VPSS_REGION_INFO_S stLumaRgnInfo; //定义VPSS 区域信息，用于获取区域亮度总和。

} RGN_OSD_REVERSE_INFO_S;

typedef struct hiRGN_ATTR_INFO_S
{
    RGN_HANDLE Handle;
    HI_U32 u32RgnNum;
} RGN_ATTR_INFO_S;

char tmp[25];
TTF_Font *font;  
SDL_Surface *text, *temp;  
SDL_Rect bounds;
BITMAP_S stBitmap;

BITMAP_S SDL_OSDtoBMP(char *tmp_sys_time)  
{  
        static unsigned char Count=0;
        if (TTF_Init() < 0 )
        {  
                fprintf(stderr, "Couldn't initialize TTF: %s\n",SDL_GetError());  
                SDL_Quit();
        }  
       
        font = TTF_OpenFont("./simhei.ttf", 48);
        if ( font == NULL )
        {  
                fprintf(stderr, "Couldn't load %d pt font from %s: %s\n",  
                "ptsize", 18, SDL_GetError());  
        }  
        SDL_Color forecol=   { 0xff, 0xff, 0xff, 0xff };  
        text = TTF_RenderUTF8_Solid(font, tmp_sys_time, forecol);
       
        SDL_PixelFormat *fmt;
        fmt = (SDL_PixelFormat*)malloc(sizeof(SDL_PixelFormat));
        memset(fmt,0,sizeof(SDL_PixelFormat));
        fmt->BitsPerPixel = 16;
        fmt->BytesPerPixel = 2;
       

        //fmt->Rmask = 0xff000000;//0xff000000;//0xff000000;//0x00FF0000
//        fmt->Gmask = 0x0000ff00;//0x0000ff00;//0x0000ff00;//0x0000FF00
        //fmt->Bmask = 0x000000ff;//0x000000ff;//0x000000ff;//0x000000FF
//        fmt->Amask = 0x000000ff;//0x0000ff00;//0x0000ff00;
        fmt->colorkey = 0xffffffff;
        fmt->alpha = 0xff;

        SDL_Surface *temp = SDL_ConvertSurface(text,fmt,0);
        SDL_SaveBMP(temp, "sys_time.bmp");
       
        stBitmap.u32Width = temp->pitch/2;                //do not use temp->w
        stBitmap.u32Height = temp->h;
        stBitmap.pData= temp->pixels;

        stBitmap.enPixelFormat= PIXEL_FORMAT_RGB_1555;
       
        SDL_FreeSurface(text);  
        SDL_FreeSurface(temp);
        TTF_CloseFont(font);  
        TTF_Quit();  
        return stBitmap;
}

HI_S32 SAMPLE_RGN_CreateOverlayExForVpss(RGN_HANDLE Handle, HI_U32 u32Num)
{
    HI_S32 i;
    HI_S32 s32Ret;
    MPP_CHN_S stChn; //定义模块设备通道结构体。
    HI_U32 u32layer = 0;
    RGN_ATTR_S stRgnAttrSet; //定义区域属性结构体。
    RGN_CHN_ATTR_S stChnAttr;  //定义区域通道显示属性结构体。
   
    stChn.enModId  = HI_ID_VPSS;  //模块号7。
    stChn.s32DevId = 0;                    //设备号0。
    stChn.s32ChnId = 0;  //通道号2。

    for (i = Handle; i < (Handle + u32Num); i++)
    {
        stRgnAttrSet.enType = OVERLAYEX_RGN;  //区域类型:编码通道视频叠加区
                         
        stRgnAttrSet.unAttr.stOverlayEx.enPixelFmt       = PIXEL_FORMAT_RGB_1555; //区域属性:扩展叠加区域属性。像素格式。
        stRgnAttrSet.unAttr.stOverlayEx.stSize.u32Width  = 1728;  //区域的高宽。
        stRgnAttrSet.unAttr.stOverlayEx.stSize.u32Height = 972;
        stRgnAttrSet.unAttr.stOverlayEx.u32BgColor       = 0x007c00*(i%2) + ((i+1)%2)*0x1f;
        
                        if (1 == i % u32Num)
        {
            stRgnAttrSet.unAttr.stOverlayEx.stSize.u32Width  = 180;
            stRgnAttrSet.unAttr.stOverlayEx.stSize.u32Height = 120;
            stRgnAttrSet.unAttr.stOverlayEx.u32BgColor       = 0x0000001f;
        }
       else if (2 == i % u32Num)
        {
            stRgnAttrSet.unAttr.stOverlayEx.stSize.u32Width  = 160;
            stRgnAttrSet.unAttr.stOverlayEx.stSize.u32Height = 120;
            stRgnAttrSet.unAttr.stOverlayEx.u32BgColor       = 0x00007c00;
        }
       else if (3 == i % u32Num)
        {
            stRgnAttrSet.unAttr.stOverlayEx.stSize.u32Width  = 100;
            stRgnAttrSet.unAttr.stOverlayEx.stSize.u32Height = 150;
            stRgnAttrSet.unAttr.stOverlayEx.u32BgColor       = 0x000007ff;
        }
        
                         s32Ret = HI_MPI_RGN_Create(i, &stRgnAttrSet); //创建区域。
        if (s32Ret != HI_SUCCESS)
        {
            printf("HI_MPI_RGN_Create failed! s32Ret: 0x%x.\n", s32Ret);
            return s32Ret;
        }

        stChnAttr.bShow  = HI_TRUE;  //区域是否显示
        stChnAttr.enType = OVERLAYEX_RGN;  //区域类型:扩展视频叠加区域
        stChnAttr.unChnAttr.stOverlayExChn.stPoint.s32X = 192;          //VENC 通道叠加区域通道显示属性:区域位置。
        stChnAttr.unChnAttr.stOverlayExChn.stPoint.s32Y = 108;
        stChnAttr.unChnAttr.stOverlayExChn.u32BgAlpha   = 0;          //Alpha 位为0 的像素点的透明度。取值越小，越透明。
        stChnAttr.unChnAttr.stOverlayExChn.u32FgAlpha   = 255;  //Alpha 位为1 的像素点的透明度. 取值越小，越透明。
        stChnAttr.unChnAttr.stOverlayExChn.u32Layer     = u32layer;
        u32layer++;
        if (1 == i % 4)
        {
            stChnAttr.unChnAttr.stOverlayExChn.stPoint.s32X = 130;
            stChnAttr.unChnAttr.stOverlayExChn.stPoint.s32Y = 330;
        }

                        else if (2 == i % 4)
        {
            stChnAttr.unChnAttr.stOverlayExChn.stPoint.s32X = 270;
            stChnAttr.unChnAttr.stOverlayExChn.stPoint.s32Y = 300;
        }
        else if (3 == i % 4)
        {
            stChnAttr.unChnAttr.stOverlayExChn.stPoint.s32X = 180;
            stChnAttr.unChnAttr.stOverlayExChn.stPoint.s32Y = 400;
        }

        s32Ret = HI_MPI_RGN_AttachToChn(i, &stChn, &stChnAttr); //将区域叠加到通道上。
        if (s32Ret != HI_SUCCESS)
        {
            printf("HI_MPI_RGN_AttachToChn failed! s32Ret: 0x%x.\n", s32Ret);
            return s32Ret;
        }
    }

    return HI_SUCCESS;

}

/******************************************************************************
* funciton : load bmp from file
******************************************************************************/
HI_S32 SAMPLE_RGN_LoadBmp(const HI_CHAR *filename, BITMAP_S *pstBitmap)
{
    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;
   
    pstBitmap->pData = malloc(2*(bmpInfo.bmiHeader.biWidth)*(bmpInfo.bmiHeader.biHeight));
       
    if(NULL == pstBitmap->pData)
    {
        SAMPLE_PRT("malloc osd memroy err!\n");        
        return HI_FAILURE;
    }

    CreateSurfaceByBitMap(filename,&Surface,(HI_U8*)(pstBitmap->pData));
       
    pstBitmap->u32Width = Surface.u16Width;
    pstBitmap->u32Height = Surface.u16Height;
    pstBitmap->enPixelFormat = PIXEL_FORMAT_RGB_1555;                 
    return HI_SUCCESS;
}

HI_S32 SAMPLE_RGN_UpdateCanvas(const char* filename, BITMAP_S* pstBitmap, HI_BOOL bFil,
                               HI_U32 u16FilColor, SIZE_S* pstSize, HI_U32 u32Stride, PIXEL_FORMAT_E enPixelFmt)
{
    OSD_SURFACE_S Surface;
    OSD_BITMAPFILEHEADER bmpFileHeader;
    OSD_BITMAPINFO bmpInfo;

    if (GetBmpInfo(filename, &bmpFileHeader, &bmpInfo) < 0)
    {
        printf("GetBmpInfo err!\n");
        return HI_FAILURE;
    }

    if (PIXEL_FORMAT_RGB_1555 == enPixelFmt)
    {
        Surface.enColorFmt = OSD_COLOR_FMT_RGB1555;
    }
    else if (PIXEL_FORMAT_RGB_4444 == enPixelFmt)
    {
        Surface.enColorFmt = OSD_COLOR_FMT_RGB4444;
    }
    else if (PIXEL_FORMAT_RGB_8888 == enPixelFmt)
    {
        Surface.enColorFmt = OSD_COLOR_FMT_RGB8888;
    }
    else
    {
        printf("Pixel format is not support!\n");
        return HI_FAILURE;
    }
        if (NULL == pstBitmap->pData)
    {
        printf("malloc osd memroy err!\n");
        return HI_FAILURE;
    }
    CreateSurfaceByCanvas(filename, &Surface, (HI_U8*)(pstBitmap->pData), pstSize->u32Width, pstSize->u32Height, u32Stride);

    pstBitmap->u32Width  = Surface.u16Width;
    pstBitmap->u32Height = Surface.u16Height;

    if (PIXEL_FORMAT_RGB_1555 == enPixelFmt)
    {
        pstBitmap->enPixelFormat = PIXEL_FORMAT_RGB_1555;
    }
    else if (PIXEL_FORMAT_RGB_4444 == enPixelFmt)
    {
        pstBitmap->enPixelFormat = PIXEL_FORMAT_RGB_4444;
    }
    else if (PIXEL_FORMAT_RGB_8888 == enPixelFmt)
    {
        pstBitmap->enPixelFormat = PIXEL_FORMAT_RGB_8888;
    }
    int i, j;
    HI_U16* pu16Temp;
    pu16Temp = (HI_U16*)pstBitmap->pData;

    if (bFil)
    {
        for (i = 0; i < pstBitmap->u32Height; i++)
        {
            for (j = 0; j < pstBitmap->u32Width; j++)
            {
                if (u16FilColor == *pu16Temp)
                {
                    *pu16Temp &= 0x7FFF;
                }

                pu16Temp++;
            }
        }

    }

    return HI_SUCCESS;
}

HI_S32 SAMPLE_RGN_DestroyRegion(RGN_HANDLE Handle, HI_U32 u32Num)
{
    HI_S32 i;
    HI_S32 s32Ret;   
        
    for (i=Handle; i<(Handle + u32Num); i++)
    {
        s32Ret = HI_MPI_RGN_Destroy(i);
        if (HI_SUCCESS != s32Ret)
        {
            printf("HI_MPI_RGN_Destroy failed! s32Ret: 0x%x.\n", s32Ret);
            return s32Ret;
        }
    }

    return HI_SUCCESS;
   
}

HI_S32 SAMPLE_RGN_AddOsdToVpss(HI_VOID)
{
    RGN_HANDLE Handle;  //定义区域句柄。
    HI_S32 u32RgnNum;
    HI_S32 s32Ret = HI_SUCCESS;
    RGN_ATTR_S stRgnAttrSet;  //定义区域属性结构体。
    RGN_CANVAS_INFO_S stCanvasInfo; //定义画布信息结构体。
    HI_S32 i;
    BITMAP_S stBitmap;  //定义位图图像信息结构。
    SIZE_S stSize;
   
   
        /*************************************************
      step 1: create region and attach to vpss group
     *************************************************/
    Handle    = 0;
    u32RgnNum = 1;
   
        char *wday[]={"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
        time_t timep;
        struct tm *p;
        char time_buf[18]="\0";
            
        while(1)
        {
                time(&timep);
                p=localtime(&timep);
                sprintf(time_buf, "%04d/%02d/%02d-%02d:%02d:%02d-%s", (1900+p->tm_year), (1+p->tm_mon), p->tm_mday,\
                                p->tm_hour, p->tm_min, p->tm_sec, wday[p->tm_wday]);
       
                printf("%s\n",time_buf);
                stBitmap = SDL_OSDtoBMP(time_buf);
               
                sleep(1);       
          
                        /*************************************************
          step 7: load bitmap to region
         *************************************************/
        s32Ret = HI_MPI_RGN_GetAttr(Handle, &stRgnAttrSet);  //获取区域属性。
        if (HI_SUCCESS != s32Ret)
        {
            printf("HI_MPI_RGN_GetAttr failed! s32Ret: 0x%x.\n", s32Ret);
            return s32Ret;
        }
       
        s32Ret = HI_MPI_RGN_GetCanvasInfo(Handle, &stCanvasInfo); //获取区域的显示画布信息。
        if (HI_SUCCESS != s32Ret)
        {
            printf("HI_MPI_RGN_GetCanvasInfo failed! s32Ret: 0x%x.\n", s32Ret);
            return s32Ret;
        }
       
        stBitmap.pData   = (HI_VOID*)stCanvasInfo.u32VirtAddr;  //位图数据。
        stSize.u32Width  = stCanvasInfo.stSize.u32Width;                          //位图宽度。
        stSize.u32Height = stCanvasInfo.stSize.u32Height;  
        s32Ret = SAMPLE_RGN_UpdateCanvas("sys_time.bmp", &stBitmap, HI_FALSE, 0, &stSize, stCanvasInfo.u32Stride,
                                         stRgnAttrSet.unAttr.stOverlayEx.enPixelFmt);
        if (HI_SUCCESS != s32Ret)
         {
            printf("SAMPLE_RGN_UpdateCanvas failed! s32Ret: 0x%x.\n", s32Ret);
            return s32Ret;
         }
         
         s32Ret = HI_MPI_RGN_UpdateCanvas(Handle);  //更新显示画布。
        if (HI_SUCCESS != s32Ret)
        {
            printf("HI_MPI_RGN_UpdateCanvas failed! s32Ret: 0x%x.\n", s32Ret);
            return s32Ret;
        }
       
        }
          
        //<<----------------------
        if(NULL != stBitmap.pData)
        {
                free(stBitmap.pData);
                stBitmap.pData = NULL;
        }
}

HI_S32 OsdInitial(HI_VOID)
{
        RGN_HANDLE Handle;  //定义区域句柄。
    HI_S32 u32RgnNum;
    HI_S32 s32Ret = HI_SUCCESS;
   
        Handle    = 0;
    u32RgnNum = 1;
   
           s32Ret = SAMPLE_RGN_DestroyRegion(Handle, u32RgnNum);
   
           s32Ret = SAMPLE_RGN_CreateOverlayExForVpss(Handle, u32RgnNum);  //创建区域并将区域叠加到通道上
    if (HI_SUCCESS != s32Ret)
    {
        printf("SAMPLE_RGN_CreateOverlayExForVpss failed! s32Ret: 0x%x.\n", s32Ret);
        return s32Ret;
    }
    return HI_SUCCESS;
}

#endif
[/code]

[quote][url=forum.php?mod=redirect&goto=findpost&pid=26569&ptid=10385]zhuangweiye 发表于 2016-3-15 15:21[/url]
你已经做了99%的工作了

还差1%
[/quote]

代码已经贴出，感谢！

s32Ret = SAMPLE_RGN_UpdateCanvas("sys_time.bmp", &stBitmap, HI_FALSE, 0, &stSize, stCanvasInfo.u32Stride, stRgnAttrSet.unAttr.stOverlayEx.enPixelFmt);

请注意第三第四个参数, 这两个可以控制透明, 第三个设为HI_TRUE, 第四个设为BMP中需要透明的背景像素的值(你可以用打印的方法得到)

也可以做个测试,第四个参数设为0x8000(从代码和贴出OSD的实际图猜的), 应该会看到osd中的字(黑色的部分, 希望值是0x8000,祈祷中...)透明了

[quote][url=forum.php?mod=redirect&goto=findpost&pid=26575&ptid=10385]zhuangweiye 发表于 2016-3-15 16:09[/url]
s32Ret = SAMPLE_RGN_UpdateCanvas("sys_time.bmp", &stBitmap, HI_FALSE, 0, &stSize, stCanvasInfo.u32St ...[/quote]

好的，我试一下

[quote][url=forum.php?mod=redirect&goto=findpost&pid=26575&ptid=10385]zhuangweiye 发表于 2016-3-15 16:09[/url]
s32Ret = SAMPLE_RGN_UpdateCanvas("sys_time.bmp", &stBitmap, HI_FALSE, 0, &stSize, stCanvasInfo.u32St ...[/quote]

[img]http://chuantu.biz/t2/31/1458029983x3738746571.bmp[/img]

实现了:victory:

恭喜

提几个问题:
1.用overlayEx的方法会引入附加的带宽
2. 应该可以不用SDL_SaveBMP(temp, "sys_time.bmp"), 看看这个temp里面是不是直接就能得到BMP的buffer, 写文件得方法毕竟不是好方法

[quote][url=forum.php?mod=redirect&goto=findpost&pid=26584&ptid=10385]zhuangweiye 发表于 2016-3-15 16:26[/url]
恭喜

提几个问题:
[/quote]

嗯，这两个确实是前期考虑不够周到，我这边会优化一下，多谢提醒:hug:

你好，我也在做OSD，但是调用I_MPI_RGN_AttachToChn()时总是报0xa0128003，就是参数超出合法范围
我用的是Ho3516C，这是设置的参数
stChnAttr.bShow = HI_TRUE;
  stChnAttr.enType = OVERLAY_RGN;
  stChnAttr.unChnAttr.stOverlayChn.stPoint.s32X = 16;
  stChnAttr.unChnAttr.stOverlayChn.stPoint.s32Y = 16;
  stChnAttr.unChnAttr.stOverlayExChn.u32BgAlpha   = 0;      
  stChnAttr.unChnAttr.stOverlayExChn.u32FgAlpha   = 128;     
  stChnAttr.unChnAttr.stOverlayChn.u32Layer = 0;
请问是我参数设置上的问题吗

就这点参数看不出来,估计是那些没贴出来的参数有问题

[quote][url=forum.php?mod=redirect&goto=findpost&pid=26584&ptid=10385]zhuangweiye 发表于 2016-3-15 16:26[/url]
恭喜

提几个问题:
[/quote]

前辈，关于你说的这两个问题
1、因为我要叠加字符到VPSS通道，3516A的话只能用OverLayEx来实现了
2、这边已经实现了不保存BMP图片直接用Buffer显示OSD了

然后，之前说到的想显示多行，我在进行BMP合并的时候遇到很多问题，能不能再指点一下，对bmp确实不是很熟悉。

1. 如果是不用预览,可以考虑在VENC上加OSD, 可以用overlay, 可以节约带宽, 可能子码流的OSD更好点
2. 关于合并的问题, 建议你用上面的代码改, 显示两行时间
   a. RGN的高是原来的两倍
   b. 开个new_buffer是SDL得到的buffer的两倍, 把SDL得到的buffer  copy到new_buffer的偏移位置0 和 sizeof(SDL buffer)的地方
   c. 然后把 new_buffer做为OSD的buffer交给海思
这样先试一下, 慢慢就理解了, 很容易的

你的OSD加到VPSS，如果出来两路流，一路分辨率大，另一路分辨率小。分辨率大的那个OSD看上去不是很小吗，这只是个人的一点理解哈。我认为加到ENC更好一些