1601 lines
46 KiB
C
Executable File
1601 lines
46 KiB
C
Executable File
////////////////////////////////////////////////////////////////////////////////
|
|
#include "PrjInc.h"
|
|
#include "System/SysCommon.h"
|
|
#include "WiFiIpc/nvtwifi.h"
|
|
#include "UIWnd/UIFlow.h"
|
|
//#include "UIWnd/SPORTCAM/UIInfo/UIInfo.h"
|
|
//#include "UIWnd/SPORTCAM/UIInfo/UIPhotoInfo.h"
|
|
//#include "DateTimeInfo.h"
|
|
#include "UIDateImprint.h"
|
|
#include "UIDateImprintID.h"
|
|
//#include "UIWnd/SPORTCAM/Resource/UIResource.h"
|
|
//#include "Utility.h"
|
|
|
|
#include "FontConv/FontConv.h"
|
|
|
|
#include "Mode/UIMode.h"
|
|
#include "gximage/gximage.h"
|
|
//#include "UIWnd/SPORTCAM/UIInfo/UIPhotoMapping.h"
|
|
//#include "nvtmpp.h"
|
|
#include "UIAppPhoto.h"
|
|
#include "GxVideoFile.h"
|
|
#include <kflow_common/nvtmpp.h>
|
|
#include "kwrap/type.h"
|
|
#include "UIApp/MovieStamp/MovieStamp.h"
|
|
//#include "UIWnd/SPORTCAM/UIInfo/DateTimeInfo.h"
|
|
#include "vf_gfx.h"
|
|
|
|
#if HUNTING_CAMERA_MCU == ENABLE
|
|
#include <sf_common.h>
|
|
#endif
|
|
#define THIS_DBGLVL 2 // 0=FATAL, 1=ERR, 2=WRN, 3=UNIT, 4=FUNC, 5=IND, 6=MSG, 7=VALUE, 8=USER
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
#define __MODULE__ UIDateImprint
|
|
#define __DBGLVL__ ((THIS_DBGLVL>=PRJ_DBG_LVL)?THIS_DBGLVL:PRJ_DBG_LVL)
|
|
#define __DBGFLT__ "*" //*=All, [mark]=CustomClass
|
|
#include <kwrap/debug.h>
|
|
|
|
#include "UIInfo/UIInfo.h"
|
|
#include "sf_battery.h"
|
|
|
|
#define USE_DBG_STAMP DISABLE
|
|
|
|
/****************************************************
|
|
* IMPORTANT!!
|
|
*
|
|
* LVGL UI style only accept RGB color
|
|
*
|
|
****************************************************/
|
|
#if defined(_UI_STYLE_LVGL_)
|
|
|
|
#include "UIApp/lv_user_font_conv/lv_user_font_conv.h"
|
|
|
|
#define DATE_COLOR_TRANSPARENT lv_color_to32(LV_COLOR_OLIVE) /* it will be converted into yuv as color key */
|
|
#define DATE_COLOR_WHITE lv_color_to32(LV_COLOR_WHITE)
|
|
#define DATE_COLOR_BLACK lv_color_to32(LV_COLOR_BLACK)
|
|
#define DATE_COLOR_ORANGED lv_color_to32(LV_COLOR_ORANGE)
|
|
#define DATE_COLOR_RED lv_color_to32(LV_COLOR_RED)
|
|
|
|
#define LV_USER_FONT_CONV_ALIGN_W 8
|
|
#define LV_USER_FONT_CONV_ALIGN_H 2
|
|
|
|
lv_user_font_conv_draw_cfg draw_cfg = {0};
|
|
|
|
static void _movie_stamp_lv_cfg_init(lv_user_font_conv_draw_cfg *draw_cfg)
|
|
{
|
|
lv_user_font_conv_draw_cfg_init(draw_cfg);
|
|
|
|
|
|
draw_cfg->radius = LV_USER_CFG_STAMP_RADIUS;
|
|
draw_cfg->string.align = LV_USER_CFG_STAMP_TEXT_ALIGN;
|
|
draw_cfg->string.letter_space = LV_USER_CFG_STAMP_LETTER_SPACE;
|
|
draw_cfg->ext_w = LV_USER_CFG_STAMP_EXT_WIDTH;
|
|
draw_cfg->ext_h = LV_USER_CFG_STAMP_EXT_HEIGHT;
|
|
draw_cfg->border.width = LV_USER_CFG_STAMP_BORDER_WIDTH;
|
|
|
|
}
|
|
|
|
static UINT32 UIDateImprint_GetStampMemSize_LVGL(const lv_font_t *pFont, char* text)
|
|
{
|
|
//lv_user_font_conv_draw_cfg draw_cfg = {0};
|
|
lv_user_font_conv_calc_buffer_size_result result = {0};
|
|
|
|
_movie_stamp_lv_cfg_init(&draw_cfg);
|
|
|
|
draw_cfg.string.font = (lv_font_t *)pFont;
|
|
draw_cfg.string.text = text;
|
|
|
|
DBG_IND("[%s:%d]draw_cfg.string.text=%s\n", __FUNCTION__, __LINE__, draw_cfg.string.text);
|
|
|
|
draw_cfg.align_w = LV_USER_FONT_CONV_ALIGN_W;
|
|
draw_cfg.align_h = LV_USER_FONT_CONV_ALIGN_H;
|
|
|
|
if(PhotoExe_GetCapYUV420En()){
|
|
draw_cfg.fmt = HD_VIDEO_PXLFMT_YUV420;//GX_IMAGE_PIXEL_FMT_YUV420_PACKED;
|
|
}else{
|
|
draw_cfg.fmt = HD_VIDEO_PXLFMT_YUV422;//GX_IMAGE_PIXEL_FMT_YUV422_PACKED;
|
|
}
|
|
|
|
lv_user_font_conv_calc_buffer_size(&draw_cfg, &result);
|
|
|
|
DBG_IND("[%s:%d]result.output_buffer_size=%d\n", __FUNCTION__, __LINE__, result.output_buffer_size);
|
|
|
|
return result.output_buffer_size;
|
|
}
|
|
|
|
static ER FontConv_LVGL(FONT_CONV_IN *pIn, FONT_CONV_OUT *pOut)
|
|
{
|
|
HD_RESULT r;
|
|
//lv_user_font_conv_draw_cfg draw_cfg = {0};
|
|
lv_user_font_conv_mem_cfg mem_cfg = {0};
|
|
lv_user_font_conv_calc_buffer_size_result result = {0};
|
|
lv_color32_t color32;
|
|
|
|
_movie_stamp_lv_cfg_init(&draw_cfg);
|
|
|
|
draw_cfg.fmt = pIn->Format;
|
|
draw_cfg.string.font = (lv_font_t *) pIn->pFont;
|
|
draw_cfg.string.text = pIn->pStr;
|
|
draw_cfg.string.align = LV_USER_CFG_STAMP_TEXT_ALIGN;
|
|
draw_cfg.align_w = LV_USER_FONT_CONV_ALIGN_W;
|
|
draw_cfg.align_h = LV_USER_FONT_CONV_ALIGN_H;
|
|
|
|
/* text color */
|
|
color32.full = pIn->ciSolid;
|
|
draw_cfg.string.color = LV_COLOR_MAKE(color32.ch.red, color32.ch.green, color32.ch.blue);
|
|
draw_cfg.string.opa = LV_COLOR_GET_A32(color32);
|
|
|
|
/* bg color */
|
|
color32.full = pIn->ciTransparet;
|
|
draw_cfg.bg.color = LV_COLOR_MAKE(color32.ch.red, color32.ch.green, color32.ch.blue);
|
|
draw_cfg.bg.opa = LV_COLOR_GET_A32(color32);
|
|
|
|
/* border color */
|
|
color32.full = pIn->ciFrame;
|
|
draw_cfg.border.color = LV_COLOR_MAKE(color32.ch.red, color32.ch.green, color32.ch.blue);
|
|
draw_cfg.border.opa = LV_COLOR_GET_A32(color32);
|
|
draw_cfg.border.width = LV_USER_CFG_STAMP_BORDER_WIDTH;
|
|
|
|
/****************************************************************************
|
|
* IMPORTANT!!
|
|
*
|
|
* do not set color key to zero because engine may ignore zero value.
|
|
****************************************************************************/
|
|
draw_cfg.key_y = 255;
|
|
draw_cfg.key_u = 255;
|
|
draw_cfg.key_v = 255;
|
|
|
|
mem_cfg.output_buffer = (void*)pIn->MemAddr;
|
|
mem_cfg.output_buffer_size = pIn->MemSize;
|
|
|
|
DBG_IND("[%s:%d]mem_cfg.output_buffer_size=%d\n", __FUNCTION__, __LINE__, mem_cfg.output_buffer_size);
|
|
|
|
lv_user_font_conv_calc_buffer_size(&draw_cfg, &result);
|
|
lv_user_font_conv(&draw_cfg, &mem_cfg);
|
|
|
|
UINT32 LineOffs[2];
|
|
UINT32 PxlAddrs[2];
|
|
|
|
HD_COMMON_MEM_VIRT_INFO vir_meminfo = {0};
|
|
|
|
vir_meminfo.va = (void *)(mem_cfg.output_buffer);
|
|
if ( hd_common_mem_get(HD_COMMON_MEM_PARAM_VIRT_INFO, &vir_meminfo) != HD_OK) {
|
|
DBG_ERR("convert output_buffer to pa failed!\n");
|
|
return -1;
|
|
}
|
|
|
|
LineOffs[0] = (float)result.width * (float)(result.bpp / 8);
|
|
LineOffs[1] = LineOffs[0];
|
|
PxlAddrs[0] = (UINT32) vir_meminfo.pa;
|
|
PxlAddrs[1] = PxlAddrs[0] + (result.width * result.height); /* y plane is w * h for yuv420 & 422 */
|
|
|
|
r = vf_init_ex(&pOut->GenImg, result.width, result.height, pIn->Format, LineOffs, PxlAddrs);
|
|
if (r != HD_OK) {
|
|
DBG_ERR("vf_init_ex failed %d\r\n",r);
|
|
}
|
|
|
|
pOut->ColorKeyY = draw_cfg.key_y;
|
|
pOut->ColorKeyCb = draw_cfg.key_u;
|
|
pOut->ColorKeyCr = draw_cfg.key_v;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
#else
|
|
|
|
#include "UIApp/MovieStamp/DateStampFontTbl56x96.h"
|
|
#include "UIApp/MovieStamp/DateStampFontTbl42x72.h"
|
|
#include "UIApp/MovieStamp/DateStampFontTbl36x60.h"
|
|
#include "UIApp/MovieStamp/DateStampFontTbl26x44.h"
|
|
#include "UIApp/MovieStamp/DateStampFontTbl20x44.h"
|
|
#include "UIApp/MovieStamp/DateStampFontTbl18x30.h"
|
|
#include "UIApp/MovieStamp/DateStampFontTbl12x20.h"
|
|
#include "UIApp/MovieStamp/DateStampFontTbl10x16.h"
|
|
|
|
/****************************************************
|
|
* YUV
|
|
****************************************************/
|
|
#define DATE_COLOR_TRANSPARENT 0x00808000
|
|
#define DATE_COLOR_WHITE 0x008080FF
|
|
#define DATE_COLOR_BLACK 0x00818101
|
|
#define DATE_COLOR_ORANGED 0x00D4328A
|
|
#define DATE_COLOR_RED 0x00FF554E
|
|
|
|
#endif
|
|
|
|
#define FONT_BUF_RATIO (450)
|
|
|
|
typedef enum {
|
|
DATE_IMPRINT_EVENT_QV = 0, ///<quick view event
|
|
DATE_IMPRINT_EVENT_SCR, ///<screennail event
|
|
DATE_IMPRINT_EVENT_PRI, ///<primary image event
|
|
DATE_IMPRINT_EVENT_MAX, ///<Maximun value
|
|
} DATE_IMPRINT_EVENT;
|
|
|
|
|
|
typedef struct{
|
|
UINT32 PosX;
|
|
UINT32 PosY;
|
|
//IMG_BUF Img;
|
|
HD_VIDEO_FRAME Img;
|
|
UINT32 ColorKey; ///< format 0x00YYUUVV
|
|
UINT32 StampWeight; ///< 0 ~ 255
|
|
} DS_STAMP_INFOR;
|
|
|
|
|
|
typedef struct {
|
|
IMG_CAP_DATASTAMP_INFO *pCapInfo;
|
|
UINT32 MemAddr;
|
|
UINT32 MemSize;
|
|
FONT_CONV_IN tYuvDesc;
|
|
FONT_CONV_OUT tYuvInfo;
|
|
DS_STAMP_INFOR StampInfo;
|
|
//GX_IMAGE_CP_ENG copyEngine;
|
|
GXIMG_CP_ENG copyEngine;
|
|
UINT32 lockptn;
|
|
BOOL isStrDirty;
|
|
CHAR StrBuf[64];
|
|
UINT32 pic_cnt;
|
|
} DATE_IMPRINT_INFO;
|
|
|
|
|
|
typedef struct {
|
|
DATE_IMPRINT_INFO info[DATE_IMPRINT_EVENT_MAX];
|
|
|
|
} DATE_IMPRINT_CTRL;
|
|
|
|
DATE_IMPRINT_CTRL gDateImprintCtrl = {0};
|
|
DATE_IMPRINT_CTRL *pCtrl = &gDateImprintCtrl;
|
|
//static char gUiDateImprint_StrBuf[64] = {0};
|
|
//static NVTMPP_VB_POOL g_DateImprintPool[DATE_IMPRINT_EVENT_MAX]={NVTMPP_VB_INVALID_POOL, NVTMPP_VB_INVALID_POOL, NVTMPP_VB_INVALID_POOL};
|
|
static STAMP_ADDR_INFO g_DateImprintPool[DATE_IMPRINT_EVENT_MAX]={0};
|
|
void UiDateImprint_GetStampFont(UINT32 uiImageWidth, char **font);
|
|
char *UiDateImprint_InitStrBuf(void);
|
|
|
|
void UiDateImprint_Lock(UINT32 ptn)
|
|
{
|
|
FLGPTN uiFlag = 0;
|
|
wai_flg(&uiFlag, UI_DATEIMPRINT_FLG_ID, ptn, TWF_CLR);
|
|
}
|
|
|
|
void UiDateImprint_UnLock(UINT32 ptn)
|
|
{
|
|
set_flg(UI_DATEIMPRINT_FLG_ID, ptn);
|
|
}
|
|
|
|
|
|
void UiDateImprint_InitBuff(void)
|
|
{
|
|
|
|
DATE_IMPRINT_INFO *pInfo;
|
|
UINT32 i,genMaxw, genMaxh;
|
|
//NVTMPP_VB_BLK blk;
|
|
void *va;
|
|
UINT32 pa;
|
|
ER ret;
|
|
HD_COMMON_MEM_DDR_ID ddr_id = DDR_ID0;
|
|
CHAR pool_name[20] ={0};
|
|
ISIZE szStamp;
|
|
UINT32 FontWidth = 0;
|
|
UINT32 FontHight = 0;
|
|
FONT *pFont;
|
|
|
|
#if defined(_UI_STYLE_LVGL_)
|
|
LV_UNUSED(FontWidth);
|
|
LV_UNUSED(FontHight);
|
|
LV_UNUSED(szStamp);
|
|
#endif
|
|
|
|
|
|
DBG_IND("\r\n");
|
|
if (!UI_DATEIMPRINT_FLG_ID) {
|
|
DBG_ERR("ID is not installed\r\n");
|
|
return;
|
|
}
|
|
|
|
for (i=0;i<DATE_IMPRINT_EVENT_MAX;i++) {
|
|
pInfo = &pCtrl->info[i];
|
|
if ( i == DATE_IMPRINT_EVENT_QV && g_DateImprintPool[i].pool_va == 0) {
|
|
ISIZE size = GxVideo_GetDeviceSize(DOUT1);
|
|
|
|
UiDateImprint_GetStampFont(size.w,(char**)&pFont);
|
|
|
|
#if defined(_UI_STYLE_LVGL_)
|
|
pInfo->MemSize = UIDateImprint_GetStampMemSize_LVGL((const lv_font_t *)pFont, UiDateImprint_InitStrBuf());
|
|
pInfo->MemSize = pInfo->MemSize/4*5;
|
|
#else
|
|
GxGfx_SetTextStroke((const FONT *)pFont, FONTSTYLE_NORMAL, SCALE_1X);
|
|
GxGfx_Text(0, 0, 0, UiDateImprint_InitStrBuf()); //not really draw
|
|
szStamp = GxGfx_GetTextLastSize(); //just get text size
|
|
|
|
FontWidth=ALIGN_CEIL(szStamp.w ,8);
|
|
FontHight=ALIGN_CEIL(szStamp.h, 2);
|
|
pInfo->MemSize = (FontWidth*FontHight*FONT_BUF_RATIO)/100;//0x5000;//0x80000;
|
|
#endif
|
|
|
|
DBG_IND("QV w=%d, %d, MemSize=0x%x\r\n", FontWidth,FontHight,pInfo->MemSize);
|
|
|
|
sprintf(pool_name,"DateImprint_QV");
|
|
|
|
ret = hd_common_mem_alloc(pool_name, &pa, (void **)&va, pInfo->MemSize, ddr_id);
|
|
|
|
if (ret != HD_OK) {
|
|
DBG_ERR("QV alloc fail size 0x%x, ddr %d\r\n", pInfo->MemSize, ddr_id);
|
|
return;
|
|
}
|
|
DBG_IND("pa = 0x%x, va = 0x%x\r\n", (unsigned int)(pa), (unsigned int)(va));
|
|
g_DateImprintPool[i].pool_va=(UINT32)va;
|
|
g_DateImprintPool[i].pool_pa=(UINT32)pa;
|
|
memset(va, 0, pInfo->MemSize);
|
|
|
|
pInfo->MemAddr = g_DateImprintPool[i].pool_va;
|
|
pInfo->copyEngine = GXIMG_CP_ENG1;
|
|
pInfo->lockptn = FLGPTN_BIT(i); //i
|
|
}
|
|
else if ( i == DATE_IMPRINT_EVENT_SCR && g_DateImprintPool[i].pool_va == 0) {
|
|
pInfo->MemSize = 0x80000;
|
|
#if HUNTING_CAMERA_MCU == ENABLE
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
UiDateImprint_GetStampFont(sf_get_screen_nail_width(puiPara->SendPicSize),(char**)&pFont);
|
|
#else
|
|
UiDateImprint_GetStampFont(CFG_SCREENNAIL_W,(char**)&pFont);
|
|
#endif
|
|
|
|
#if defined(_UI_STYLE_LVGL_)
|
|
pInfo->MemSize = UIDateImprint_GetStampMemSize_LVGL((const lv_font_t *)pFont, UiDateImprint_InitStrBuf());
|
|
pInfo->MemSize = pInfo->MemSize/4*5;
|
|
#else
|
|
GxGfx_SetTextStroke((const FONT *)pFont, FONTSTYLE_NORMAL, SCALE_1X);
|
|
GxGfx_Text(0, 0, 0, UiDateImprint_InitStrBuf()); //not really draw
|
|
szStamp = GxGfx_GetTextLastSize(); //just get text size
|
|
|
|
FontWidth=ALIGN_CEIL(szStamp.w ,8);
|
|
FontHight=ALIGN_CEIL(szStamp.h, 2);
|
|
pInfo->MemSize = (FontWidth*FontHight*FONT_BUF_RATIO)/100;//0x5000;//0x80000;
|
|
#endif
|
|
|
|
|
|
DBG_IND("SRC w=%d, %d, MemSize=0x%x\r\n", FontWidth,FontHight,pInfo->MemSize);
|
|
|
|
sprintf(pool_name,"DateImprint_SCR");
|
|
|
|
ret = hd_common_mem_alloc(pool_name, &pa, (void **)&va, pInfo->MemSize, ddr_id);
|
|
|
|
if (ret != HD_OK) {
|
|
DBG_ERR("QV alloc fail size 0x%x, ddr %d\r\n", pInfo->MemSize, ddr_id);
|
|
return;
|
|
}
|
|
DBG_IND("pa = 0x%x, va = 0x%x\r\n", (unsigned int)(pa), (unsigned int)(va));
|
|
g_DateImprintPool[i].pool_va=(UINT32)va;
|
|
g_DateImprintPool[i].pool_pa=(UINT32)pa;
|
|
memset(va, 0, pInfo->MemSize);
|
|
|
|
pInfo->MemAddr = g_DateImprintPool[i].pool_va;
|
|
pInfo->copyEngine = GXIMG_CP_ENG2;
|
|
pInfo->lockptn = FLGPTN_BIT(i); //i
|
|
}
|
|
else if ( i == DATE_IMPRINT_EVENT_PRI && g_DateImprintPool[i].pool_va == 0) {
|
|
pInfo->MemSize = 0x80000;
|
|
UiDateImprint_GetStampFont(GetPhotoSizeWidth(PHOTO_MAX_CAP_SIZE),(char**)&pFont);
|
|
|
|
#if defined(_UI_STYLE_LVGL_)
|
|
pInfo->MemSize = UIDateImprint_GetStampMemSize_LVGL((const lv_font_t *)pFont, UiDateImprint_InitStrBuf());
|
|
pInfo->MemSize = pInfo->MemSize/4*5;
|
|
#else
|
|
GxGfx_SetTextStroke((const FONT *)pFont, FONTSTYLE_NORMAL, SCALE_1X);
|
|
GxGfx_Text(0, 0, 0, UiDateImprint_InitStrBuf()); //not really draw
|
|
szStamp = GxGfx_GetTextLastSize(); //just get text size
|
|
|
|
FontWidth=ALIGN_CEIL(szStamp.w ,8);
|
|
FontHight=ALIGN_CEIL(szStamp.h, 2);
|
|
pInfo->MemSize = (FontWidth*FontHight*FONT_BUF_RATIO)/100;//0x80000;
|
|
#endif
|
|
|
|
DBG_IND("PRI w=%d, %d, MemSize=0x%x\r\n", FontWidth,FontHight,pInfo->MemSize);
|
|
|
|
|
|
sprintf(pool_name,"DateImprint_PRI");
|
|
|
|
ret = hd_common_mem_alloc(pool_name, &pa, (void **)&va, pInfo->MemSize, ddr_id);
|
|
|
|
if (ret != HD_OK) {
|
|
DBG_ERR("QV alloc fail size 0x%x, ddr %d\r\n", pInfo->MemSize, ddr_id);
|
|
return;
|
|
}
|
|
DBG_IND("pa = 0x%x, va = 0x%x\r\n", (unsigned int)(pa), (unsigned int)(va));
|
|
g_DateImprintPool[i].pool_va=(UINT32)va;
|
|
g_DateImprintPool[i].pool_pa=(UINT32)pa;
|
|
memset(va, 0, pInfo->MemSize);
|
|
|
|
pInfo->MemAddr = g_DateImprintPool[i].pool_va;
|
|
pInfo->copyEngine = GXIMG_CP_ENG2;
|
|
pInfo->lockptn =FLGPTN_BIT(i); //i
|
|
}
|
|
pInfo->isStrDirty = TRUE;
|
|
pInfo->StrBuf[0] = 0;
|
|
pInfo->pic_cnt = 0;
|
|
genMaxw = GetPhotoSizeWidth(0) / 2;
|
|
genMaxh = GetPhotoSizeHeight(0) * 0.04;
|
|
pInfo->StampInfo.Img.loff[0] = genMaxw;
|
|
pInfo->StampInfo.Img.loff[1] = genMaxw;
|
|
pInfo->StampInfo.Img.pw[0] = genMaxw;
|
|
pInfo->StampInfo.Img.ph[0] = genMaxh;
|
|
if(PhotoExe_GetCapYUV420En()){
|
|
pInfo->StampInfo.Img.pxlfmt = HD_VIDEO_PXLFMT_YUV420;//GX_IMAGE_PIXEL_FMT_YUV420_PACKED;
|
|
}else{
|
|
pInfo->StampInfo.Img.pxlfmt = HD_VIDEO_PXLFMT_YUV422;//GX_IMAGE_PIXEL_FMT_YUV422_PACKED;
|
|
}
|
|
}
|
|
set_flg(UI_DATEIMPRINT_FLG_ID, FLGPTN_BIT_ALL);
|
|
|
|
}
|
|
void UiDateImprint_DestroyBuff(void)
|
|
{
|
|
UINT32 i, ret;
|
|
for (i=0;i<DATE_IMPRINT_EVENT_MAX;i++) {
|
|
|
|
if (g_DateImprintPool[i].pool_va != 0) {
|
|
ret = hd_common_mem_free((UINT32)g_DateImprintPool[i].pool_pa, (void *)g_DateImprintPool[i].pool_va);
|
|
if (ret != HD_OK) {
|
|
DBG_ERR("FileIn release blk failed! (%d)\r\n", ret);
|
|
break;
|
|
}
|
|
g_DateImprintPool[i].pool_va = 0;
|
|
g_DateImprintPool[i].pool_pa = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
char StampStr[64] = {0};
|
|
|
|
extern BOOL UiDateImprint_UpdateDate(char *StrBuf, UINT32 buff_len);
|
|
char * UiDateImprint_InitStrBuf(void)
|
|
{
|
|
char *dateStr = NULL;
|
|
INT16 cTemper = 0;
|
|
INT16 fTemper = 0;
|
|
UINT8 temperStr[32] = {0};
|
|
|
|
DateTime_Load();
|
|
|
|
#if PHOTO_ISP_STAMP == ENABLE
|
|
|
|
str = DateTime_MakeYMD();
|
|
UiDateImprint_get_isp_status(0, str, DateTime_StrBuf_Size());
|
|
|
|
#else
|
|
|
|
switch (UI_GetData(FL_DATE_STAMP))
|
|
{
|
|
case DATEIMPRINT_DATE:
|
|
dateStr = DateTime_MakeYMD();
|
|
break;
|
|
|
|
case DATEIMPRINT_DATE_TIME:
|
|
dateStr = DateTime_MakeYMDHMS();
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
#endif
|
|
|
|
sf_stamp_temperature_get(&fTemper, &cTemper);
|
|
snprintf((char *)temperStr, sizeof(temperStr), "%d%c%cF %d%c%cC", fTemper, 0xC2, 0xB0, cTemper, 0xC2, 0xB0);
|
|
//printf("[%s:%d]temperStr=%s\n", __FUNCTION__, __LINE__, temperStr);
|
|
|
|
snprintf((char *)StampStr, sizeof(StampStr), "%s %s", temperStr, dateStr);
|
|
DBG_IND("[%s:%d]StampStr=%s\n", __FUNCTION__, __LINE__, StampStr);
|
|
|
|
return StampStr;
|
|
}
|
|
|
|
UINT32 UiDateImprint_GetMaxWorkBufSize(DS_STAMP_INFOR *stampInfo)
|
|
{
|
|
return 0;//gximg_calc_require_size(stampInfo->Img.pw[0],stampInfo->Img.pw[0],stampInfo->Img.pxlfmt,stampInfo->Img.loff[0]);
|
|
}
|
|
|
|
void UiDateImprint_SelStampFont(UINT32 uiImageWidth, char **font, UINT32 *ScaleFactor)
|
|
{
|
|
#if defined(_UI_STYLE_LVGL_)
|
|
*ScaleFactor = 65536;
|
|
|
|
lv_plugin_res_id red_id;
|
|
|
|
if(uiImageWidth >= 5632)
|
|
{
|
|
red_id = LV_USER_CFG_STAMP_FONT_ID_24M;
|
|
}
|
|
else if(uiImageWidth >= 4608)
|
|
{
|
|
red_id = LV_USER_CFG_STAMP_FONT_ID_16M;
|
|
}
|
|
else if(uiImageWidth >= 4032)
|
|
{
|
|
red_id = LV_USER_CFG_STAMP_FONT_ID_12M;
|
|
}
|
|
else if(uiImageWidth >= 3264)
|
|
{
|
|
red_id = LV_USER_CFG_STAMP_FONT_ID_8M;
|
|
}
|
|
else if(uiImageWidth >= 1920)
|
|
{
|
|
red_id = LV_USER_CFG_STAMP_FONT_ID_LARGE;
|
|
}
|
|
else if(uiImageWidth >= 1080)
|
|
{
|
|
red_id = LV_USER_CFG_STAMP_FONT_ID_MEDIUM;
|
|
}
|
|
else if(uiImageWidth >= 1024)
|
|
{
|
|
red_id = LV_USER_CFG_STAMP_FONT_ID_SMALL_PIC;
|
|
}
|
|
else if(uiImageWidth >= 640)
|
|
{
|
|
red_id = LV_USER_CFG_STAMP_FONT_ID_SMALL;
|
|
}
|
|
else
|
|
{
|
|
red_id = LV_USER_CFG_STAMP_FONT_ID_XS;
|
|
}
|
|
|
|
DBG_IND("[%s:%d]uiImageWidth=%d,stamp font id=%d\n", __FUNCTION__, __LINE__, uiImageWidth, red_id);
|
|
|
|
*font = (char *) lv_plugin_get_font(red_id)->font;
|
|
|
|
#else
|
|
if (uiImageWidth >= 3840) {
|
|
*font = (char *)gDateStampFontTbl56x96;
|
|
*ScaleFactor = 65536;
|
|
}
|
|
else if(uiImageWidth >=3600) {
|
|
*font = (char *)&gDateStampFontTbl56x96;
|
|
*ScaleFactor = 65536*95/100;
|
|
}
|
|
else if(uiImageWidth >=3200) {
|
|
*font = (char *)&gDateStampFontTbl56x96;
|
|
*ScaleFactor = 65536*90/100;
|
|
}
|
|
else if(uiImageWidth >=2880) {
|
|
*font = (char *)&gDateStampFontTbl42x72;
|
|
*ScaleFactor = 65536;
|
|
}
|
|
else if(uiImageWidth >=1920) {
|
|
*font = (char *)&gDateStampFontTbl36x60;
|
|
*ScaleFactor = 65536;
|
|
}
|
|
else if(uiImageWidth >=1080) {
|
|
*font = (char *)&gDateStampFontTbl26x44;
|
|
*ScaleFactor = 65536;
|
|
}
|
|
else if(uiImageWidth >=640) {
|
|
*font = (char *)&gDateStampFontTbl12x20;
|
|
*ScaleFactor = 65536;
|
|
}
|
|
else if(uiImageWidth >=320) {
|
|
*font = (char *)&gDateStampFontTbl10x16;
|
|
*ScaleFactor = 65536;
|
|
}
|
|
else {
|
|
*font = (char *)&gDateStampFontTbl10x16;
|
|
*ScaleFactor = 65536/3;
|
|
}
|
|
#endif
|
|
|
|
|
|
}
|
|
void UiDateImprint_GetStampFont(UINT32 uiImageWidth, char **font)
|
|
{
|
|
#if defined(_UI_STYLE_LVGL_)
|
|
|
|
lv_plugin_res_id red_id;
|
|
|
|
|
|
if(uiImageWidth >= 5632)
|
|
{
|
|
red_id = LV_USER_CFG_STAMP_FONT_ID_24M;
|
|
}
|
|
else if(uiImageWidth >= 4608)
|
|
{
|
|
red_id = LV_USER_CFG_STAMP_FONT_ID_16M;
|
|
}
|
|
else if(uiImageWidth >= 4032)
|
|
{
|
|
red_id = LV_USER_CFG_STAMP_FONT_ID_12M;
|
|
}
|
|
else if(uiImageWidth >= 3264)
|
|
{
|
|
red_id = LV_USER_CFG_STAMP_FONT_ID_8M;
|
|
}
|
|
else if(uiImageWidth >= 1920)
|
|
{
|
|
red_id = LV_USER_CFG_STAMP_FONT_ID_LARGE;
|
|
}
|
|
else if(uiImageWidth >= 1080)
|
|
{
|
|
red_id = LV_USER_CFG_STAMP_FONT_ID_MEDIUM;
|
|
}
|
|
else if(uiImageWidth >= 1024)
|
|
{
|
|
red_id = LV_USER_CFG_STAMP_FONT_ID_SMALL_PIC;
|
|
}
|
|
else if(uiImageWidth >= 640)
|
|
{
|
|
red_id = LV_USER_CFG_STAMP_FONT_ID_SMALL;
|
|
}
|
|
else
|
|
{
|
|
red_id = LV_USER_CFG_STAMP_FONT_ID_XS;
|
|
}
|
|
|
|
DBG_IND("[%s:%d]uiImageWidth=%d,stamp font id=%d\n", __FUNCTION__, __LINE__, uiImageWidth, red_id);
|
|
|
|
*font = (char *) lv_plugin_get_font(red_id)->font;
|
|
|
|
#else
|
|
if (uiImageWidth >= 3840) {
|
|
*font = (char *)&gDateStampFontTbl56x96;
|
|
}
|
|
else if(uiImageWidth >=3600) {
|
|
*font = (char *)&gDateStampFontTbl56x96;
|
|
}
|
|
else if(uiImageWidth >=3200) {
|
|
*font = (char *)&gDateStampFontTbl56x96;
|
|
}
|
|
else if(uiImageWidth >=2880) {
|
|
*font = (char *)&gDateStampFontTbl42x72;
|
|
}
|
|
else if(uiImageWidth >=1920) {
|
|
*font = (char *)&gDateStampFontTbl36x60;
|
|
}
|
|
else if(uiImageWidth >=1080) {
|
|
*font = (char *)&gDateStampFontTbl26x44;
|
|
}
|
|
else if(uiImageWidth >=640) {
|
|
*font = (char *)&gDateStampFontTbl12x20;
|
|
}
|
|
else if(uiImageWidth >=320) {
|
|
*font = (char *)&gDateStampFontTbl10x16;
|
|
}
|
|
else {
|
|
*font = (char *)&gDateStampFontTbl10x16;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
DATE_IMPRINT_INFO *UiDateImprint_Event2Info(IMG_CAP_DATASTAMP_EVENT event)
|
|
{
|
|
DATE_IMPRINT_INFO *pInfo;
|
|
if (event == CAP_DS_EVENT_QV)
|
|
pInfo = &pCtrl->info[DATE_IMPRINT_EVENT_QV];
|
|
else if (event == CAP_DS_EVENT_SCR)
|
|
pInfo = &pCtrl->info[DATE_IMPRINT_EVENT_SCR];
|
|
else if (event == CAP_DS_EVENT_PRI)
|
|
pInfo = &pCtrl->info[DATE_IMPRINT_EVENT_PRI];
|
|
else
|
|
pInfo = NULL;
|
|
return pInfo;
|
|
}
|
|
|
|
|
|
INT32 UiDateImprint_GenYuvData(DATE_IMPRINT_INFO *pInfo)
|
|
{
|
|
#if 1
|
|
FONT_CONV_IN *pIn = &pInfo->tYuvDesc;
|
|
FONT_CONV_OUT *pOut = &pInfo->tYuvInfo;
|
|
UINT32 photo_w = pInfo->pCapInfo->ImgInfo.ch[0].width;
|
|
// UINT32 photo_h = pInfo->pCapInfo->ImgInfo.ch[0].height;
|
|
|
|
DBG_IND("\r\n");
|
|
pIn->MemAddr = pInfo->MemAddr;
|
|
pIn->MemSize = pInfo->MemSize;
|
|
pIn->pStr = pInfo->StrBuf;
|
|
|
|
#if defined(_UI_STYLE_LVGL_)
|
|
pIn->ciSolid = LV_USER_CFG_STAMP_COLOR_TEXT;
|
|
pIn->ciFrame = LV_USER_CFG_STAMP_COLOR_FRAME;
|
|
pIn->ciTransparet = LV_USER_CFG_STAMP_COLOR_BACKGROUND;
|
|
#else
|
|
pIn->ciSolid = DATE_COLOR_RED;
|
|
pIn->ciFrame = DATE_COLOR_TRANSPARENT;
|
|
pIn->ciTransparet = DATE_COLOR_TRANSPARENT;
|
|
#endif
|
|
if(PhotoExe_GetCapYUV420En()){
|
|
pIn->Format = HD_VIDEO_PXLFMT_YUV420;//GX_IMAGE_PIXEL_FMT_YUV420_PACKED;
|
|
}else{
|
|
pIn->Format = HD_VIDEO_PXLFMT_YUV422;//GX_IMAGE_PIXEL_FMT_YUV422_PACKED;
|
|
}
|
|
pIn->bEnableSmooth = FALSE;
|
|
//ImgSize = photo_w*photo_h;
|
|
#if 0
|
|
if (photo_w * photo_h <= 160 * 120) {
|
|
//thumbnail Size
|
|
pIn->pFont = (FONT *)gDemo_SmallFont;
|
|
pIn->ScaleFactor = 65536 / 3; //0.33x
|
|
}
|
|
else if (photo_w * photo_h <= 640 * 480) {
|
|
//VGA Size
|
|
pIn->pFont = (FONT *)gDemo_SmallFont;
|
|
pIn->ScaleFactor = 65536; //1.0x
|
|
} else {
|
|
UINT32 font_h, stamp_ratio;
|
|
pIn->pFont = (FONT *)gDemo_BigFont;
|
|
|
|
font_h = 190;
|
|
stamp_ratio = 0x00000A00; //0.04x
|
|
pIn->ScaleFactor = photo_h * stamp_ratio / font_h;
|
|
}
|
|
#else
|
|
DBG_IND("photo_w=%d\r\n",photo_w);
|
|
UiDateImprint_SelStampFont(photo_w, (char**)&pIn->pFont, &pIn->ScaleFactor);
|
|
#endif
|
|
|
|
#if defined(_UI_STYLE_LVGL_)
|
|
if (FontConv_LVGL(pIn, pOut) != E_OK) {
|
|
DBG_ERR("FontConv err\r\n");
|
|
return -1;
|
|
}
|
|
#else
|
|
if (FontConv(pIn, pOut) != E_OK) {
|
|
DBG_ERR("FontConv err\r\n");
|
|
return -1;
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
INT32 UiDateImprint_CalcPosition(DATE_IMPRINT_INFO *pInfo, UPOINT *pos)
|
|
{
|
|
#if 1
|
|
IMG_CAP_DATASTAMP_INFO *pCapInfo = pInfo->pCapInfo;
|
|
FONT_CONV_OUT *pYuvInfo = &pInfo->tYuvInfo;
|
|
UINT32 ofs = 0;
|
|
|
|
|
|
UINT32 photo_w = pCapInfo->ImgInfo.ch[0].width;
|
|
UINT32 photo_h = pCapInfo->ImgInfo.ch[0].height;
|
|
|
|
DBG_IND("photo_w =%d, photo_h=%d, gen w=%d, h=%d\r\n",photo_w,photo_h,(pYuvInfo->GenImg.pw[0]),pYuvInfo->GenImg.ph[0]);
|
|
|
|
if ((pYuvInfo->GenImg.pw[0]) > photo_w)
|
|
{
|
|
DBG_ERR("event=%d, GenImg w %d> photo_w %d\r\n",pCapInfo->event,(pYuvInfo->GenImg.pw[0]),photo_w);
|
|
return -1;
|
|
}
|
|
|
|
if (pYuvInfo->GenImg.ph[0] > photo_h)
|
|
{
|
|
DBG_ERR("GenImg h %d> photo_h %d\r\n",pYuvInfo->GenImg.ph[0],photo_h);
|
|
return -1;
|
|
}
|
|
|
|
//Leave blank to the right of the date watermark
|
|
ofs = pYuvInfo->GenImg.ph[0]/2;
|
|
|
|
if(photo_w >= (pYuvInfo->GenImg.pw[0] + ofs)){
|
|
pos->x = ALIGN_ROUND_4(photo_w - pYuvInfo->GenImg.pw[0] - ofs);
|
|
}
|
|
else if(photo_w >= pYuvInfo->GenImg.pw[0]){
|
|
pos->x = ALIGN_ROUND_4(photo_w - pYuvInfo->GenImg.pw[0]);
|
|
}
|
|
else{
|
|
DBG_ERR("stamp width overflow!\n");
|
|
}
|
|
|
|
if(photo_w >= pYuvInfo->GenImg.pw[0]){
|
|
pos->y = ALIGN_ROUND_4(photo_h - pYuvInfo->GenImg.ph[0]);
|
|
}
|
|
else{
|
|
DBG_ERR("stamp height overflow!\n");
|
|
}
|
|
|
|
DBG_IND("pos->x =%d, pos->y=%d\r\n",pos->x, pos->y);
|
|
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
ER UiDateImprint_UpdateData(DATE_IMPRINT_INFO *pInfo)
|
|
{
|
|
#if 1
|
|
DS_STAMP_INFOR *pStampInfo = &pInfo->StampInfo;
|
|
FONT_CONV_OUT *pYuvInfo = &pInfo->tYuvInfo;
|
|
UPOINT pos = {0};
|
|
|
|
if (UiDateImprint_GenYuvData(pInfo)< 0){
|
|
DBG_ERR("GenYuvData fail\r\n");
|
|
return E_SYS;
|
|
}
|
|
|
|
if (UiDateImprint_CalcPosition(pInfo,&pos) < 0){
|
|
DBG_ERR("CalcPosition fail\r\n");
|
|
return E_SYS;
|
|
}
|
|
pStampInfo->PosX = pos.x;
|
|
pStampInfo->PosY = pos.y;
|
|
DBG_IND("[%s:%d]pStampInfo->PosX=%d,pStampInfo->PosY=%d\n", __FUNCTION__, __LINE__, pStampInfo->PosX, pStampInfo->PosY);
|
|
pStampInfo->Img = pYuvInfo->GenImg;
|
|
|
|
//memcpy(&pStampInfo->Img, &pYuvInfo->GenImg, sizeof(VDO_FRAME));
|
|
|
|
pStampInfo->ColorKey = COLOR_MAKE_YUVD(pYuvInfo->ColorKeyY, pYuvInfo->ColorKeyCb, pYuvInfo->ColorKeyCr);
|
|
pStampInfo->StampWeight = 255;
|
|
DBG_IND("MemMax Use = %d bytes, MemMin Use=%d bytes\r\n", pYuvInfo->UsedMaxMemSize, pYuvInfo->UsedMemSize);
|
|
#endif
|
|
return E_OK;
|
|
}
|
|
|
|
void UiDateImprint_ChkUpdateData(DATE_IMPRINT_INFO *pInfo)
|
|
{
|
|
#if 1
|
|
UINT32 uiImageSize, ScreenNailSize;
|
|
UINT32 bScreenNailEn=0;
|
|
UINT32 bGenEn=0;
|
|
|
|
ScreenNailSize = CFG_SCREENNAIL_SIZE;
|
|
uiImageSize = UI_GetData(FL_PHOTO_SIZE);
|
|
if (uiImageSize < ScreenNailSize) {
|
|
bScreenNailEn=1;
|
|
}
|
|
|
|
if(pInfo->pCapInfo->event == CAP_DS_EVENT_SCR && bScreenNailEn){
|
|
bGenEn=1;
|
|
}else if(pInfo->pCapInfo->event == CAP_DS_EVENT_PRI && bScreenNailEn==0){
|
|
bGenEn=1;
|
|
}
|
|
|
|
DBG_IND("event=%d, bScreenNailEn=%d, bGenEn=%d\r\n",pInfo->pCapInfo->event,bScreenNailEn,bGenEn);
|
|
|
|
//if (pInfo->pCapInfo->event == CAP_DS_EVENT_QV || pInfo->pCapInfo->event == CAP_DS_EVENT_SCR) {
|
|
if (pInfo->pCapInfo->event == CAP_DS_EVENT_PRI) {
|
|
#if HUNTING_CAMERA_MCU == ENABLE
|
|
pInfo->isStrDirty = UiDateImprint_UpdateDate(pInfo->StrBuf,sizeof(pInfo->StrBuf));
|
|
#else
|
|
if ((UI_GetData(FL_CONTINUE_SHOT) == CONTINUE_SHOT_BURST_3)) {
|
|
if (pInfo->pic_cnt == 0)
|
|
pInfo->isStrDirty = UiDateImprint_UpdateDate(pInfo->StrBuf,sizeof(pInfo->StrBuf));
|
|
else
|
|
pInfo->isStrDirty = FALSE;
|
|
}
|
|
else {
|
|
pInfo->isStrDirty = UiDateImprint_UpdateDate(pInfo->StrBuf,sizeof(pInfo->StrBuf));
|
|
}
|
|
#endif
|
|
}
|
|
#if 0
|
|
// need to update primary info to screenail
|
|
if (pInfo->pCapInfo->event == CAP_DS_EVENT_PRI)
|
|
{
|
|
DATE_IMPRINT_INFO *pScrInfo;
|
|
|
|
pScrInfo= UiDateImprint_Event2Info(CAP_DS_EVENT_SCR);
|
|
pScrInfo->isStrDirty = pInfo->isStrDirty;
|
|
if (pInfo->isStrDirty == TRUE){
|
|
strncpy(pScrInfo->StrBuf,pInfo->StrBuf,sizeof(pScrInfo->StrBuf));
|
|
}
|
|
}
|
|
#else
|
|
// need to update primary info to screenail
|
|
//if (pInfo->pCapInfo->event == CAP_DS_EVENT_SCR)
|
|
if (bGenEn && pInfo->pCapInfo->event == CAP_DS_EVENT_SCR)
|
|
{
|
|
DATE_IMPRINT_INFO *pScrInfo;
|
|
pScrInfo= UiDateImprint_Event2Info(CAP_DS_EVENT_PRI);
|
|
|
|
pScrInfo->isStrDirty = pInfo->isStrDirty;
|
|
if (pInfo->isStrDirty == TRUE){
|
|
strncpy(pScrInfo->StrBuf,pInfo->StrBuf,sizeof(pScrInfo->StrBuf));
|
|
}
|
|
}
|
|
#endif
|
|
pInfo->pic_cnt++;
|
|
#endif
|
|
}
|
|
|
|
void UiDateImprint_DrawBG(DS_STAMP_INFOR *stampInfo, HD_VIDEO_FRAME* Img)
|
|
{
|
|
HD_GFX_DRAW_RECT param = {0};
|
|
|
|
param.dst_img.dim = Img->dim;
|
|
param.dst_img.ddr_id = Img->ddr_id;
|
|
param.dst_img.format = Img->pxlfmt;
|
|
param.dst_img.lineoffset[0] = Img->loff[0];
|
|
param.dst_img.lineoffset[1] = Img->loff[1];
|
|
param.dst_img.p_phy_addr[0] = Img->phy_addr[0];
|
|
param.dst_img.p_phy_addr[1] = Img->phy_addr[1];
|
|
param.color = LV_USER_CFG_STAMP_COLOR_BACKGROUND; /* ARGB format */
|
|
param.thickness = 10;
|
|
param.rect.w = Img->dim.w;
|
|
param.rect.h = stampInfo->Img.dim.h*11/10; /*add heigt*/
|
|
param.rect.x = 0;
|
|
//param.rect.y = stampInfo->PosY;
|
|
param.rect.y = Img->dim.h - param.rect.h;
|
|
param.type = HD_GFX_RECT_SOLID;
|
|
DBG_IND("[%s:%d]Img->dim.h=%d,param.rect.h=%d,stampInfo->PosY=%d\n", __FUNCTION__, __LINE__, Img->dim.h, param.rect.h, stampInfo->PosY);
|
|
|
|
hd_gfx_draw_rect(¶m);
|
|
}
|
|
|
|
void UiDateImprint_AttachString(DS_STAMP_INFOR *stampInfo, HD_VIDEO_FRAME* Img, UINT8* name, bool enable_ckey, UINT32 padding, UINT32* x_curr_ofs)
|
|
{
|
|
//lv_user_font_conv_draw_cfg draw_cfg = {0};
|
|
lv_user_font_conv_calc_buffer_size_result buff_size = {0};
|
|
lv_user_font_conv_mem_cfg mem_cfg = {0};
|
|
VF_GFX_SCALE param_img = {0};
|
|
HD_VIDEO_FRAME src_img;
|
|
void *va;
|
|
UINT32 pa;
|
|
HD_RESULT ret;
|
|
HD_COMMON_MEM_DDR_ID ddr_id = DDR_ID0;
|
|
|
|
//_movie_stamp_lv_cfg_init(&draw_cfg);
|
|
|
|
draw_cfg.string.text = (char*)name;
|
|
/*draw_cfg.string.align = LV_USER_CFG_STAMP_TEXT_ALIGN;
|
|
draw_cfg.align_w = LV_USER_FONT_CONV_ALIGN_W;
|
|
draw_cfg.align_h = LV_USER_FONT_CONV_ALIGN_H;
|
|
draw_cfg.mode = LV_USER_FONT_CONV_DRAW_TEXT;
|
|
if(PhotoExe_GetCapYUV420En())
|
|
{
|
|
draw_cfg.fmt = HD_VIDEO_PXLFMT_YUV420;
|
|
}else
|
|
{
|
|
draw_cfg.fmt = HD_VIDEO_PXLFMT_YUV422;
|
|
}
|
|
UiDateImprint_GetStampFont(src_img.dim.w, (char**)&draw_cfg.string.font);*/
|
|
|
|
lv_user_font_conv_calc_buffer_size(&draw_cfg, &buff_size);
|
|
|
|
ret = hd_common_mem_alloc("stamp_font", &pa, (void **)&va, buff_size.output_buffer_size, ddr_id);
|
|
if (ret != HD_OK) {
|
|
DBG_ERR("custom_stamp_buffer allocate failed\n\r");
|
|
}
|
|
else {
|
|
mem_cfg.output_buffer = va;
|
|
mem_cfg.output_buffer_size = buff_size.output_buffer_size;
|
|
}
|
|
|
|
lv_user_font_conv(&draw_cfg, &mem_cfg);
|
|
lv_user_font_conv_cfg_to_hd_frame(
|
|
&draw_cfg,
|
|
&mem_cfg,
|
|
buff_size.width,
|
|
buff_size.height,
|
|
&src_img
|
|
);
|
|
|
|
memset(¶m_img, 0, sizeof(param_img));
|
|
param_img.quality = HD_GFX_SCALE_QUALITY_NULL;
|
|
param_img.src_img = src_img;
|
|
param_img.src_region.x = 0;
|
|
param_img.src_region.y = 0;
|
|
param_img.src_region.w = src_img.dim.w;
|
|
param_img.src_region.h = src_img.dim.h;
|
|
param_img.engine = 0;
|
|
param_img.dst_img = *Img;
|
|
param_img.dst_region.w = (src_img.dim.w / src_img.dim.h) * stampInfo->Img.ph[0];
|
|
param_img.dst_region.h = stampInfo->Img.ph[0];
|
|
param_img.dst_region.x = (*x_curr_ofs - padding - param_img.dst_region.w);
|
|
param_img.dst_region.y = param_img.dst_img.dim.h - param_img.dst_region.h;
|
|
|
|
vf_gfx_scale(¶m_img, 1);
|
|
hd_common_mem_free(pa, va);
|
|
*x_curr_ofs = param_img.dst_region.x;
|
|
}
|
|
|
|
#define LV_USER_FONT_CONV_ALIGN_W 8
|
|
#define LV_USER_FONT_CONV_ALIGN_H 2
|
|
|
|
/* YUV color key */
|
|
#define CKEY_Y 0x0
|
|
#define CKEY_U 0x80
|
|
#define CKEY_V 0x80
|
|
|
|
void UiDateImprint_AttachICON(DS_STAMP_INFOR *stampInfo, HD_VIDEO_FRAME* Img, lv_plugin_res_id res_id, bool enable_ckey, UINT32 padding, UINT32* x_curr_ofs)
|
|
{
|
|
HD_VIDEO_PXLFMT out_fmt = HD_VIDEO_PXLFMT_YUV420;
|
|
HD_VIDEO_FRAME src_img;
|
|
void *va;
|
|
UINT32 pa;
|
|
HD_RESULT ret;
|
|
HD_COMMON_MEM_DDR_ID ddr_id = DDR_ID0;
|
|
|
|
/******************************************************************************
|
|
* Stamp image
|
|
******************************************************************************/
|
|
|
|
lv_user_font_conv_draw_cfg draw_cfg = {0};
|
|
lv_user_font_conv_calc_buffer_size_result buff_size = {0};
|
|
lv_user_font_conv_mem_cfg mem_cfg = {0};
|
|
|
|
lv_user_font_conv_draw_cfg_init(&draw_cfg);
|
|
|
|
draw_cfg.align_w = LV_USER_FONT_CONV_ALIGN_W;
|
|
draw_cfg.align_h = LV_USER_FONT_CONV_ALIGN_H;
|
|
draw_cfg.fmt = out_fmt;
|
|
draw_cfg.mode = LV_USER_FONT_CONV_DRAW_IMG;
|
|
#if LV_COLOR_DEPTH == 8
|
|
extern uint32_t palette_define[];
|
|
draw_cfg.img.palette = palette_define;
|
|
#else
|
|
draw_cfg.img.palette = NULL;
|
|
#endif
|
|
draw_cfg.img.id = res_id;
|
|
|
|
draw_cfg.enable_ckey = enable_ckey;
|
|
draw_cfg.key_y = CKEY_Y;
|
|
draw_cfg.key_u = CKEY_U;
|
|
draw_cfg.key_v = CKEY_V;
|
|
|
|
lv_user_font_conv_calc_buffer_size(&draw_cfg, &buff_size);
|
|
|
|
|
|
ret = hd_common_mem_alloc("stamp_icon", &pa, (void **)&va, buff_size.output_buffer_size, ddr_id);
|
|
if (ret != HD_OK) {
|
|
DBG_ERR("custom_stamp_buffer allocate failed\n\r");
|
|
}
|
|
else {
|
|
mem_cfg.output_buffer = va;
|
|
mem_cfg.output_buffer_size = buff_size.output_buffer_size;
|
|
}
|
|
|
|
/***********************************************************
|
|
* draw image
|
|
**********************************************************/
|
|
|
|
VF_GFX_SCALE param_img = {0};
|
|
|
|
lv_user_font_conv(&draw_cfg, &mem_cfg);
|
|
|
|
lv_user_font_conv_cfg_to_hd_frame(
|
|
&draw_cfg,
|
|
&mem_cfg,
|
|
buff_size.width,
|
|
buff_size.height,
|
|
&src_img
|
|
);
|
|
|
|
memset(¶m_img, 0, sizeof(param_img));
|
|
param_img.quality = HD_GFX_SCALE_QUALITY_NULL;
|
|
param_img.src_img = src_img;
|
|
param_img.src_region.x = 0;
|
|
param_img.src_region.y = 0;
|
|
param_img.src_region.w = src_img.dim.w;
|
|
param_img.src_region.h = src_img.dim.h;
|
|
param_img.engine = 0;
|
|
param_img.dst_img = *Img;
|
|
param_img.dst_region.w = (src_img.dim.w / src_img.dim.h) * stampInfo->Img.ph[0];
|
|
param_img.dst_region.h = stampInfo->Img.ph[0];
|
|
DBG_IND("[%s:%d]padding=%d,param_img.dst_region.w=%d,stampInfo->PosY=%d\n", __FUNCTION__, __LINE__, padding, param_img.dst_region.w, stampInfo->PosY);
|
|
// if(res_id == LV_PLUGIN_IMG_ID_ICON_10234_GPS)
|
|
// {
|
|
// param_img.dst_region.x = ALIGN_FLOOR_8(*x_curr_ofs - param_img.dst_region.w);
|
|
// }
|
|
// else
|
|
{
|
|
param_img.dst_region.x = (*x_curr_ofs - padding - param_img.dst_region.w);
|
|
}
|
|
param_img.dst_region.y = stampInfo->PosY;
|
|
|
|
vf_gfx_scale(¶m_img, 1);
|
|
|
|
hd_common_mem_free(pa, va);
|
|
|
|
*x_curr_ofs = param_img.dst_region.x;
|
|
}
|
|
|
|
void UiDateImprint_AttachLogo(DS_STAMP_INFOR *stampInfo, HD_VIDEO_FRAME* Img)
|
|
{
|
|
extern const WATERLOGO_BUFFER g_WaterLogo_yuv420_486;
|
|
|
|
HD_RESULT ret;
|
|
VF_GFX_SCALE param = {0};
|
|
UINT32 pa;
|
|
void* va;
|
|
UINT32 blk_size = 0;
|
|
UINT8 ddr_id = DDR_ID0;
|
|
HD_VIDEO_FRAME logo = {0};
|
|
UINT32 lineoff[HD_VIDEO_MAX_PLANE] = {0};
|
|
UINT32 addr[HD_VIDEO_MAX_PLANE] = {0};
|
|
|
|
blk_size = (g_WaterLogo_yuv420_486.uiWidth * g_WaterLogo_yuv420_486.uiHeight * 3) / 2;
|
|
ret = hd_common_mem_alloc("jack", &pa, (void **)&va, blk_size, ddr_id);
|
|
if (ret != HD_OK) {
|
|
DBG_ERR("alloc fail size 0x%x, ddr %d\r\n", blk_size, ddr_id);
|
|
return;
|
|
}
|
|
|
|
memcpy(va,(void*) g_WaterLogo_yuv420_486.uiWaterLogoAddr, blk_size);
|
|
|
|
lineoff[0] = g_WaterLogo_yuv420_486.uiWidth;
|
|
lineoff[1] = g_WaterLogo_yuv420_486.uiWidth;
|
|
addr[0] = pa;
|
|
addr[1] = addr[0] + (lineoff[0] * g_WaterLogo_yuv420_486.uiHeight);
|
|
vf_init_ex(&logo, g_WaterLogo_yuv420_486.uiWidth, g_WaterLogo_yuv420_486.uiHeight, Img->pxlfmt, lineoff, addr);
|
|
|
|
DBG_IND("[%s:%d]Img->dim.w=%d, Img->dim.h=%d\n", __FUNCTION__, __LINE__, Img->dim.w, Img->dim.h);
|
|
|
|
param.quality = HD_GFX_SCALE_QUALITY_NULL;
|
|
param.src_img = logo;
|
|
param.src_region.x = 0;
|
|
param.src_region.y = 0;
|
|
param.src_region.w = g_WaterLogo_yuv420_486.uiWidth;
|
|
param.src_region.h = g_WaterLogo_yuv420_486.uiHeight;
|
|
param.engine = 0;
|
|
param.dst_img = *Img;
|
|
param.dst_region.x = 0;
|
|
param.dst_region.y = Img->dim.h - stampInfo->Img.ph[0];
|
|
param.dst_region.w = (g_WaterLogo_yuv420_486.uiWidth / g_WaterLogo_yuv420_486.uiHeight) * stampInfo->Img.ph[0];
|
|
param.dst_region.h = stampInfo->Img.ph[0];
|
|
|
|
DBG_IND("[%s:%d]param.dst_region:%d %d %d %d\n", __FUNCTION__, __LINE__, param.dst_region.x, param.dst_region.y, param.dst_region.w, param.dst_region.h);
|
|
vf_gfx_scale(¶m, 1);
|
|
|
|
hd_common_mem_free(pa, va);
|
|
}
|
|
|
|
#if HUNTING_CAMERA_MCU == ENABLE
|
|
|
|
unsigned long DayCode[12]= {0,31,59,90,120,151,181,212,243,273,304,334};
|
|
unsigned long DayCode_Leap[12]= {0,31,60,91,121,152,182,213,244,274,305,335};
|
|
|
|
UINT8 sf_solar_to_Lunar(UINT16 Year,UINT8 Month, UINT8 Day)
|
|
{
|
|
float temp = 0,Tempnum = 0;
|
|
UINT32 tempn = 0,tempQ = 0,tempR = 0,LunarDay = 0;
|
|
UINT32 LunarDaytemp = 0;
|
|
|
|
if(Year>=2000)
|
|
Year=Year-2000;
|
|
|
|
if (Year<21)
|
|
{
|
|
UINT16 wMonthAdd[12] = {0,31,59,90,120,151,181,212,243,273,304,334};
|
|
|
|
UINT32 wNongliData[100] =
|
|
{
|
|
2635,333387,1701,1748,267701,694,2391,133423,1175,396438
|
|
,3402,3749,331177,1453,694,201326,2350,465197,3221,3402
|
|
,400202,2901,1386,267611,605,2349,137515,2709,464533,1738
|
|
,2901,330421,1242,2651,199255,1323,529706,3733,1706,398762
|
|
,2741,1206,267438,2647,1318,204070,3477,461653,1386,2413
|
|
,330077,1197,2637,268877,3365,531109,2900,2922,398042,2395
|
|
,1179,267415,2635,661067,1701,1748,398772,2742,2391,330031
|
|
,1175,1611,200010,3749,527717,1452,2742,332397,2350,3222
|
|
,268949,3402,3493,133973,1386,464219,605,2349,334123,2709
|
|
,2890,267946,2773,592565,1210,2651,395863,1323,2707,265877
|
|
};
|
|
|
|
UINT16 wCurYear;
|
|
UINT8 wCurMonth,wCurDay;
|
|
int nIsEnd,m,k,n,i;
|
|
UINT16 nTheDate,nBit;
|
|
//static int wCurYear,wCurMonth,wCurDay;
|
|
//static int nTheDate,nIsEnd,m,k,n,i,nBit;
|
|
|
|
wCurYear = Year+2000;
|
|
wCurMonth = Month;
|
|
wCurDay = Day;
|
|
|
|
nTheDate = (wCurYear - 1921) * 365 + (wCurYear - 1921) / 4 + wCurDay +
|
|
wMonthAdd[wCurMonth - 1] - 38;
|
|
|
|
if((!(wCurYear % 4)) && (wCurMonth > 2))
|
|
nTheDate = nTheDate + 1;
|
|
|
|
nIsEnd = 0;
|
|
m = 0;
|
|
while(nIsEnd != 1)
|
|
{
|
|
if(wNongliData[m] < 4095)
|
|
k = 11;
|
|
else
|
|
k = 12;
|
|
n = k;
|
|
while(n>=0)
|
|
{
|
|
nBit = wNongliData[m];
|
|
|
|
for(i=1; i<n+1; i++) //
|
|
nBit = nBit/2;
|
|
|
|
nBit = nBit % 2;
|
|
|
|
if (nTheDate <= (29 + nBit))
|
|
{
|
|
nIsEnd = 1;
|
|
break;
|
|
}
|
|
|
|
nTheDate = nTheDate - 29 - nBit;
|
|
n = n - 1;
|
|
}
|
|
|
|
if(nIsEnd)
|
|
break;
|
|
|
|
m = m + 1;
|
|
}
|
|
|
|
wCurYear = 1921 + m;
|
|
wCurMonth = k - n + 1;
|
|
wCurDay = nTheDate;
|
|
|
|
LunarDay=wCurDay ;
|
|
}// new code
|
|
else
|
|
{
|
|
|
|
if(Year<=100)
|
|
Year=Year+2000;
|
|
|
|
if (((Year% 400) == 0) || ((Year% 4) != 0))
|
|
{
|
|
temp=DayCode[Month-1]+Day;
|
|
|
|
}
|
|
else
|
|
{
|
|
temp=DayCode_Leap[Month-1]+Day;
|
|
|
|
}
|
|
// UI_PrintOSDNumber(temp, 2, 0, 4);
|
|
// UI_PrintOSDNumber(Year, 10, 0, 4);
|
|
tempQ=(Year-1977)/4;
|
|
tempR=(Year-1977)%4;
|
|
// UI_PrintOSDNumber(tempQ, 2, 2, 4);
|
|
// UI_PrintOSDNumber(tempR, 2, 3, 4);
|
|
Tempnum=14*tempQ+10.6*(tempR+1)+temp;
|
|
// UI_PrintOSDNumber(temp, 2, 4, 4);
|
|
tempn=Tempnum/29.5;
|
|
// UI_PrintOSDNumber(Tempnum, 2, 5, 4);
|
|
LunarDaytemp=(Tempnum-tempn*29.5)*10;
|
|
if(LunarDaytemp%10>=5)
|
|
LunarDay=(Tempnum-tempn*29.5)+1;
|
|
else if (LunarDaytemp%1000<10)
|
|
LunarDay=30;
|
|
else if (LunarDaytemp%1000>300)
|
|
LunarDay=1;
|
|
else
|
|
LunarDay=Tempnum-tempn*29.5;
|
|
// UI_PrintOSDNumber(LunarDay, 2, 6, 4);
|
|
}
|
|
|
|
return LunarDay;
|
|
}
|
|
|
|
void sf_get_gps_info_str(UINT8 *str, UINT8 type)
|
|
{
|
|
UINT32 i = 0;
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
|
|
DBG_IND("[%s:%d]puiPara->GpsSwitch=%d,puiPara->Latitude:%s,puiPara->Longitude:%s\n",
|
|
__FUNCTION__, __LINE__, puiPara->GpsSwitch, puiPara->Latitude, puiPara->Longitude);
|
|
if(puiPara->GpsSwitch == SF_ON)
|
|
{
|
|
if((puiPara->Latitude[0] == '\0') || (puiPara->Longitude[0] == '\0'))
|
|
{
|
|
str[0] = '\0';
|
|
}
|
|
else if(type == 1)
|
|
{
|
|
str[i++] = puiPara->Latitude[9];
|
|
str[i++] = puiPara->Latitude[0];
|
|
str[i++] = puiPara->Latitude[1];
|
|
str[i++] = 0xC2;
|
|
str[i++] = 0xB0;
|
|
str[i++] = puiPara->Latitude[2];
|
|
str[i++] = puiPara->Latitude[3];
|
|
str[i++] = 0x27; // '
|
|
str[i++] = puiPara->Latitude[5];
|
|
str[i++] = puiPara->Latitude[6];
|
|
str[i++] = 0x22; // "
|
|
str[i++] = ' ';
|
|
str[i++] = puiPara->Longitude[10];
|
|
str[i++] = puiPara->Longitude[0];
|
|
str[i++] = puiPara->Longitude[1];
|
|
str[i++] = puiPara->Longitude[2];
|
|
str[i++] = 0xC2;
|
|
str[i++] = 0xB0;
|
|
str[i++] = puiPara->Longitude[3];
|
|
str[i++] = puiPara->Longitude[4];
|
|
str[i++] = 0x27; // '
|
|
str[i++] = puiPara->Longitude[6];
|
|
str[i++] = puiPara->Longitude[7];
|
|
str[i++] = 0x22; // "
|
|
str[i++] = '\0';
|
|
}
|
|
else if(type == 2)
|
|
{
|
|
str[i++] = puiPara->Latitude[9];
|
|
str[i++] = puiPara->Latitude[0];
|
|
str[i++] = puiPara->Latitude[1];
|
|
str[i++] = 0x2A;
|
|
str[i++] = puiPara->Latitude[2];
|
|
str[i++] = puiPara->Latitude[3];
|
|
str[i++] = 0x27; // '
|
|
str[i++] = puiPara->Latitude[5];
|
|
str[i++] = puiPara->Latitude[6];
|
|
str[i++] = 0x22; // "
|
|
str[i++] = ' ';
|
|
str[i++] = puiPara->Longitude[10];
|
|
str[i++] = puiPara->Longitude[0];
|
|
str[i++] = puiPara->Longitude[1];
|
|
str[i++] = puiPara->Longitude[2];
|
|
str[i++] = 0x2A;
|
|
str[i++] = puiPara->Longitude[3];
|
|
str[i++] = puiPara->Longitude[4];
|
|
str[i++] = 0x27; // '
|
|
str[i++] = puiPara->Longitude[6];
|
|
str[i++] = puiPara->Longitude[7];
|
|
str[i++] = 0x22; // "
|
|
str[i++] = '\0';
|
|
}
|
|
else if(type == 3)
|
|
{
|
|
str[i++] = puiPara->Latitude[9];
|
|
str[i++] = puiPara->Latitude[0];
|
|
str[i++] = puiPara->Latitude[1];
|
|
str[i++] = '.';
|
|
str[i++] = puiPara->Latitude[2];
|
|
str[i++] = puiPara->Latitude[3];
|
|
str[i++] = '.';
|
|
str[i++] = puiPara->Latitude[5];
|
|
str[i++] = puiPara->Latitude[6];
|
|
str[i++] = '-';
|
|
|
|
str[i++] = puiPara->Longitude[10];
|
|
str[i++] = puiPara->Longitude[0];
|
|
str[i++] = puiPara->Longitude[1];
|
|
str[i++] = puiPara->Longitude[2];
|
|
str[i++] = '.';
|
|
str[i++] = puiPara->Longitude[3];
|
|
str[i++] = puiPara->Longitude[4];
|
|
str[i++] = '.';
|
|
str[i++] = puiPara->Longitude[6];
|
|
str[i++] = puiPara->Longitude[7];
|
|
str[i++] = '\0';
|
|
}
|
|
}
|
|
else
|
|
{
|
|
str[0] = '\0';
|
|
}
|
|
|
|
DBG_IND("[%s:%d]str:%s\n", __FUNCTION__, __LINE__, str);
|
|
return;
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
ER UiDateImprint_CopyData(DS_STAMP_INFOR *stampInfo,HD_VIDEO_FRAME* Img, UINT32 copyEngine)
|
|
{
|
|
ER ret =E_OK;
|
|
VF_GFX_COPY param ={0};
|
|
UINT8 customString[32] = {0};
|
|
INT32 year = 0, month = 0, day = 0;
|
|
UINT8 moonday = 0;
|
|
UINT8 batValue = 0;
|
|
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
|
|
if (stampInfo->StampWeight == 255)
|
|
{
|
|
|
|
VOS_TICK t1, t2;
|
|
UINT32 padding = stampInfo->Img.ph[0];
|
|
UINT32 x_curr_ofs = stampInfo->PosX; /* start from date stamp */
|
|
|
|
DBG_IND("[%s:%d]padding=%d\n", __FUNCTION__, __LINE__, padding);
|
|
|
|
vos_perf_mark(&t1);
|
|
|
|
//draw stamp background.
|
|
UiDateImprint_DrawBG(stampInfo, Img);
|
|
|
|
|
|
//moon stamp
|
|
year = DateTime_Get(DATETIME_YEAR);
|
|
month = DateTime_Get(DATETIME_MONTH);
|
|
day = DateTime_Get(DATETIME_DAY);
|
|
DBG_IND("[%s:%d]get date time:%04d %02d %02d\n", __FUNCTION__, __LINE__, year, month, day);
|
|
moonday = (sf_solar_to_Lunar(year, month, day)) - 1;
|
|
UiDateImprint_AttachICON(stampInfo, Img, (LV_PLUGIN_IMG_ID_ICON_10200_MOON + moonday), true, padding, &x_curr_ofs);
|
|
|
|
//battery stamp
|
|
batValue = sf_cardv_battery_level_get();
|
|
if(batValue < SF_BATT_LEVEL_1)
|
|
{
|
|
batValue = 1;
|
|
}
|
|
batValue -= 1;
|
|
UiDateImprint_AttachICON(stampInfo, Img, (LV_PLUGIN_IMG_ID_ICON_10230_BATTERT + batValue), true, padding, &x_curr_ofs);
|
|
|
|
DBG_IND("[%s:%d]moon id=%d,battery id=%d\n", __FUNCTION__, __LINE__,
|
|
(LV_PLUGIN_IMG_ID_ICON_10200_MOON + moonday), (LV_PLUGIN_IMG_ID_ICON_10230_BATTERT + batValue));
|
|
|
|
//camid stamp
|
|
if((puiPara->CamNameSwitch == SF_CAMID_ON) && (puiPara->CamNameStr[0] != '\0'))
|
|
{
|
|
snprintf((char *)customString, sizeof(customString), "%s", puiPara->CamNameStr);
|
|
DBG_IND("[%s:%d]customString=%s\n", __FUNCTION__, __LINE__, customString);
|
|
UiDateImprint_AttachString(stampInfo, Img, customString, true, padding, &x_curr_ofs);
|
|
}
|
|
|
|
//gps stamp
|
|
//sprintf((char *)puiPara->Latitude, "3458.3100N");
|
|
//sprintf((char *)puiPara->Longitude, "12294.4200E");
|
|
sf_get_gps_info_str(customString, 1);
|
|
if(0/*(puiPara->GpsSwitch == SF_ON) && (customString[0] != '\0')*/)
|
|
{
|
|
if(customString[0] != '\0')
|
|
{
|
|
//snprintf((char *)customString, sizeof(customString), "N22%c%c34'57\" E113%c%c55'19\"", 0xC2, 0xB0, 0xC2, 0xB0);
|
|
DBG_IND("[%s:%d]customString=%s\n", __FUNCTION__, __LINE__, customString);
|
|
UiDateImprint_AttachString(stampInfo, Img, customString, true, padding, &x_curr_ofs);
|
|
}
|
|
|
|
// UiDateImprint_AttachICON(stampInfo, Img, LV_PLUGIN_IMG_ID_ICON_10234_GPS, true, padding, &x_curr_ofs);
|
|
}
|
|
|
|
//logo stamp
|
|
UiDateImprint_AttachLogo(stampInfo, Img);
|
|
|
|
vos_perf_mark(&t2);
|
|
|
|
DBG_DUMP("*** dur = %lu ms ***\n", vos_perf_duration(t1, t2));
|
|
|
|
param.src_img = stampInfo->Img;
|
|
param.src_region.x = 0;
|
|
param.src_region.y = 0;
|
|
param.src_region.w = stampInfo->Img.loff[0];
|
|
param.src_region.h = stampInfo->Img.ph[0];
|
|
param.dst_img = *Img;
|
|
param.dst_pos.x=stampInfo->PosX;
|
|
param.dst_pos.y=stampInfo->PosY;
|
|
param.colorkey=stampInfo->ColorKey;
|
|
param.engine=copyEngine;
|
|
param.alpha = 255;
|
|
|
|
ret = vf_gfx_copy(¶m);
|
|
}
|
|
else
|
|
{
|
|
DBG_ERR("Not support StampWeight = %d\r\n",stampInfo->StampWeight);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
BOOL UiDateImprint_GenData(IMG_CAP_DATASTAMP_INFO *pCapInfo)
|
|
{
|
|
DATE_IMPRINT_INFO *pInfo;
|
|
//IMG_BUF Img = {0};
|
|
HD_VIDEO_FRAME Img = {0};
|
|
UINT32 LineOff[MAX_PLANE_NUM];
|
|
UINT32 PxlAddr[MAX_PLANE_NUM];
|
|
#if USE_DBG_STAMP
|
|
UINT32 time_start,time_end;
|
|
#endif
|
|
HD_RESULT hd_ret;
|
|
|
|
DBG_IND("event %d, width =%d, height =%d, line_ofs[0]=%d, line_ofs[1]=%d\r\n",pCapInfo->event,pCapInfo->ImgInfo.ch[0].width,pCapInfo->ImgInfo.ch[0].height,pCapInfo->ImgInfo.ch[0].line_ofs,pCapInfo->ImgInfo.ch[1].line_ofs);
|
|
|
|
pInfo = UiDateImprint_Event2Info(pCapInfo->event);
|
|
if (pInfo == NULL){
|
|
DBG_ERR("Unknown event %d\r\n",pCapInfo->event);
|
|
return FALSE;
|
|
}
|
|
UiDateImprint_Lock(pInfo->lockptn);
|
|
pInfo->pCapInfo = pCapInfo;
|
|
UiDateImprint_ChkUpdateData(pInfo);
|
|
DBG_IND("isStrDirty %d\r\n",pInfo->isStrDirty);
|
|
#if USE_DBG_STAMP
|
|
time_start = Perf_GetCurrent();
|
|
#endif
|
|
if (pInfo->isStrDirty) {
|
|
if (UiDateImprint_UpdateData(pInfo)!=E_OK){
|
|
return FALSE;
|
|
}
|
|
}
|
|
#if 0
|
|
GxImg_DumpBuf(&pYuvInfo->GenImg, TRUE);
|
|
#endif
|
|
PxlAddr[0] = pCapInfo->ImgInfo.pixel_addr[0];
|
|
PxlAddr[1] = pCapInfo->ImgInfo.pixel_addr[1];
|
|
LineOff[0] = pCapInfo->ImgInfo.ch[0].line_ofs;
|
|
LineOff[1] = pCapInfo->ImgInfo.ch[1].line_ofs;
|
|
|
|
if(PhotoExe_GetCapYUV420En()){
|
|
//gximg_init_buf_ex(&Img, pCapInfo->ImgInfo.ch[0].width, pCapInfo->ImgInfo.ch[0].height, GX_IMAGE_PIXEL_FMT_YUV420_PACKED, LineOff, PxlAddr);
|
|
if ((hd_ret = vf_init_ex(&Img, pCapInfo->ImgInfo.ch[0].width, pCapInfo->ImgInfo.ch[0].height, HD_VIDEO_PXLFMT_YUV420, LineOff, PxlAddr)) != HD_OK) {
|
|
DBG_ERR("vf_init_ex 420 failed(%d)\r\n", hd_ret);
|
|
}
|
|
}else{
|
|
//gximg_init_buf_ex(&Img, pCapInfo->ImgInfo.ch[0].width, pCapInfo->ImgInfo.ch[0].height, GX_IMAGE_PIXEL_FMT_YUV422_PACKED, LineOff, PxlAddr);
|
|
if ((hd_ret = vf_init_ex(&Img, pCapInfo->ImgInfo.ch[0].width, pCapInfo->ImgInfo.ch[0].height, HD_VIDEO_PXLFMT_YUV422, LineOff, PxlAddr)) != HD_OK) {
|
|
DBG_ERR("vf_init_ex 422 failed(%d)\r\n", hd_ret);
|
|
}
|
|
}
|
|
//DBG_ERR("Img.phy_addr=0x%x,0x%x,0x%x\r\n",Img.phy_addr[0],Img.phy_addr[1],Img.phy_addr[2]);
|
|
|
|
#if 1
|
|
UiDateImprint_CopyData(&pInfo->StampInfo,&Img,pInfo->copyEngine);
|
|
#else
|
|
IRECT srcRegion;
|
|
srcRegion.x = pInfo->StampInfo.PosX;
|
|
srcRegion.y = pInfo->StampInfo.PosY;
|
|
srcRegion.w = pInfo->StampInfo.Img.loff[0];
|
|
srcRegion.h = pInfo->StampInfo.Img.ph[0];
|
|
VF_GFX_COPY param ={0};
|
|
#if 0
|
|
param.src_img=Img;
|
|
param.src_region.x=srcRegion.x;
|
|
param.src_region.y=srcRegion.y;
|
|
param.src_region.w=srcRegion.w;
|
|
param.src_region.h=srcRegion.h;
|
|
param.dst_img=pInfo->StampInfo.Img;
|
|
|
|
param.dst_pos.x=0;
|
|
param.dst_pos.y=0;
|
|
#else
|
|
param.src_img=pInfo->StampInfo.Img;
|
|
param.src_region.x=0;
|
|
param.src_region.y=0;
|
|
param.src_region.w=srcRegion.w;
|
|
param.src_region.h=srcRegion.h;
|
|
|
|
param.dst_img=Img;
|
|
param.dst_pos.x=pInfo->StampInfo.PosX;
|
|
param.dst_pos.y=pInfo->StampInfo.PosY;
|
|
#endif
|
|
param.colorkey=pInfo->StampInfo.ColorKey;
|
|
param.engine=pInfo->copyEngine;
|
|
|
|
//DBG_ERR("param.src_img.phy_addr=0x%x,0x%x,0x%x\r\n",param.src_img.phy_addr[0],param.src_img.phy_addr[1],param.src_img.phy_addr[2]);
|
|
|
|
#if 0
|
|
{
|
|
FST_FILE hFile = NULL;
|
|
UINT32 filesize;
|
|
char filenamey[32]={0};
|
|
static UINT32 count=0;
|
|
sprintf(filenamey,"A:\\test_STASY_%d.RAW",count);
|
|
count++;
|
|
DBG_DUMP("wxh=%dx%d,loff=%d, %s...\r\n", param.dst_img.pw[0], param.dst_img.ph[0],param.dst_img.loff[0],filenamey);
|
|
filesize = param.dst_img.loff[0]*param.dst_img.ph[0];
|
|
hFile = FileSys_OpenFile(filenamey, FST_CREATE_ALWAYS | FST_OPEN_WRITE);
|
|
FileSys_WriteFile(hFile, (UINT8 *)param.dst_img.phy_addr[0], &filesize, 0, NULL);
|
|
FileSys_CloseFile(hFile);
|
|
}
|
|
#endif
|
|
//IRECT dst_region={388,440,240,20};
|
|
//gximg_fill_data((VDO_FRAME *)&(Img), GXIMG_REGION_MATCH_IMG, COLOR_YUV_RED);
|
|
//gximg_fill_data((VDO_FRAME *)&(param.dst_img), GXIMG_REGION_MATCH_IMG, COLOR_YUV_RED);
|
|
|
|
//ret = GxImg_CopyColorkeyData(Img,&srcRegion,&stampInfo->Img,REGION_MATCH_IMG,stampInfo->ColorKey,FALSE, copyEngine);
|
|
//ret = gximg_copy_color_key_data(Img,&srcRegion,&stampInfo->Img,GXIMG_REGION_MATCH_IMG,stampInfo->ColorKey,FALSE, copyEngine);
|
|
//vf_gfx_copy(¶m);
|
|
vf_gfx_I8_colorkey(¶m);
|
|
#endif
|
|
|
|
|
|
#if USE_DBG_STAMP
|
|
time_end = Perf_GetCurrent();
|
|
DBG_DUMP("Time Use = %d ms\r\n", (time_end-time_start) / 1000);
|
|
#endif
|
|
UiDateImprint_UnLock(pInfo->lockptn);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
|