void System_OnStrgInit_INMEM(void)
{
static BOOL bStrg_init_INMEM = FALSE;
UINT32 i=0;
if(bStrg_init_INMEM)
return;
//check partition overlap
//part 0(FW area) must match loader reserved size,and next area can not overlap previos area
for(i=0;i<NAND_PARTITION_NUM;i++)
{
if(i==0)
{
if(NandPartition[i].uiPhySize<gBinInfo.ld.FWResvSize)
{
DBG_ERR("part0 %x < FWResvSize %x,cannot init\r\n",NandPartition[i].uiPhySize,gBinInfo.ld.FWResvSize);
return;
}
}
else
{
if(NandPartition[i].uiPhyAddr<NandPartition[i-1].uiPhyAddr+NandPartition[i-1].uiPhySize)
{
DBG_ERR("part%d start %x overlap part%d end %x,cannot init\r\n",i,NandPartition[i].uiPhyAddr,i-1,NandPartition[i-1].uiPhyAddr+NandPartition[i-1].uiPhySize);
return;
}
}
}
for(i=0;i<NAND_PARTITION_NUM;i++)
{
DX_HANDLE DxNandDev = Dx_GetObject(NandPartition[i].uiDxClassType);
//#NT#2014/07/16#Calvin Chang#Support DRAM Tiny Mode -begin
#if (_INTERSTORAGE_ == _INTERSTORAGE_SPI_)
UserNandInit.buf.Addr = OS_GetMempoolAddr(POOL_ID_STORAGE_RAMDISK);
UserNandInit.buf.Size = OS_GetMempoolSize(POOL_ID_STORAGE_RAMDISK);
#else
UserNandInit.buf.Addr = OS_GetMempoolAddr(POOL_ID_STORAGE_NAND);
UserNandInit.buf.Size = OS_GetMempoolSize(POOL_ID_STORAGE_NAND);
#endif
UserNandInit.prt.uiDxClassType = NandPartition[i].uiDxClassType;
UserNandInit.prt.uiPhyAddr = NandPartition[i].uiPhyAddr;
UserNandInit.prt.uiPhySize = NandPartition[i].uiPhySize;
if(i==0)
UserNandInit.prt.uiResvSize = gBinInfo.ld.LdBlockCount; //FWS use loader block count as reserved blcok
else
UserNandInit.prt.uiResvSize = NandPartition[i].uiResvSize;
Dx_Init(DxNandDev,&UserNandInit,0,STORAGE_VER);
}
bStrg_init_INMEM = TRUE;
}
void UI_GfxInit(void)
{
UINT32 uiPoolAddr;
//Initial all states, all buffers
DBG_FUNC_BEGIN("\r\n");
uiPoolAddr = OS_GetMempoolAddr(POOL_ID_GFX_TEMP);
////////////////////////////////////////////////////////////////
GxGfx_Config(CFG_STRING_BUF_SIZE,256);
//Init Gfx
GxGfx_Init((UINT32*)uiPoolAddr,POOL_SIZE_GFX_TEMP); //initial Graphics
//set default shape, text, image state for GxGfx
GxGfx_SetAllDefault();
//set custom image state for GxGfx
GxGfx_SetImageStroke(ROP_KEY,IMAGEPARAM_DEFAULT);
GxGfx_SetImageColor(IMAGEPALETTE_DEFAULT,IMAGEPARAM_DEFAULT);
#if (UI_STYLE==UI_STYLE_DRIVER)
GxGfx_SetImageTable((const IMAGE_TABLE*)gDemoKit_Image);
#else
GxGfx_SetImageTable((const IMAGE_TABLE*)gDemo_Image);
#endif
//set custom text state for GxGfx
GxGfx_SetTextColor(TEXTFORECOLOR1_DEFAULT, TEXTFORECOLOR2_DEFAULT, TEXTFORECOLOR3_DEFAULT);
#if (UI_STYLE==UI_STYLE_DRIVER)
GxGfx_SetTextStroke((const FONT*)gDemoKit_Font, FONTSTYLE_NORMAL, SCALE_1X);
#else
GxGfx_SetTextStroke((const FONT*)gDemo_Font, FONTSTYLE_NORMAL, SCALE_1X);
#endif
GxGfx_SetStringTable((const STRING_TABLE*)Get_LanguageTable());
}
BOOL Cmd_user_dump_pool(CHAR* strCmd)
{
UINT32 i;
DBG_DUMP("dump pool status\r\n");
debug_msg("POOL_ID_STORAGE_NAND:%d- start addr:0x%08lX, size:0x%08lX\r\n", POOL_ID_STORAGE_NAND, OS_GetMempoolAddr(POOL_ID_STORAGE_NAND), OS_GetMempoolSize(POOL_ID_STORAGE_NAND));
debug_msg("POOL_ID_APP:%d- start addr:0x%08lX, size:0x%08lX\r\n", POOL_ID_APP, OS_GetMempoolAddr(POOL_ID_APP), OS_GetMempoolSize(POOL_ID_APP));
debug_msg("------------------------------------------------\r\n");
for(i = 1; i <= POOL_ID_APP; i++)
{
debug_msg("POOL_ID_%d- start addr:0x%08lX, size:0x%08lX\r\n", i, OS_GetMempoolAddr(i), OS_GetMempoolSize(i));
}
return TRUE;
}
BOOL UIDisplay_GetCleanBuf(UINT32* pAddr, UINT32* pSize)
{
//if all OSD buffers are continuous memory block, fill current addr & size
//UINT32* pAddr = (UINT32*)param1;
//UINT32* pSize = (UINT32*)param2;
UINT32 uiBufAddr;
uiBufAddr = OS_GetMempoolAddr(POOL_ID_DISP_OSD1);
*pAddr = uiBufAddr;
*pSize = POOL_SIZE_DISP_OSD1*4;
return TRUE;
}
UINT32 User_GetTempBuffer(UINT32 uiSize)
{
void *pBuf = 0;
if(uiSize <= POOL_SIZE_APP)
{
pBuf = (void*)OS_GetMempoolAddr(POOL_ID_APP);
}
if(pBuf == NULL)
{
DBG_ERR("get buffer fail\r\n");
}
return (UINT32)pBuf;
}
void UI_ShowJPG(UINT8 LayerID, UINT32 uiJPGData, UINT32 uiJPGSize, UINT32 uiTempBuf)
{
UINT16 w=0,h=0,fmt=0;
UINT32 uiOutAddrY, uiOutAddrCb, uiOutAddrCr;
ISIZE DeviceSize;
DeviceSize = GxVideo_GetDeviceSize(DOUT1);
#if(VDO_USE_ROTATE_BUFFER == ENABLE)
GX_IMAGE_PIXEL_FMT GxImgFMT = GX_IMAGE_PIXEL_FMT_YUV420_PACKED;
IMG_BUF DispImg = {0};
IMG_BUF DispOutImg = {0};
UINT32 uiPoolAddr,uiPoolSize;
uiPoolAddr = OS_GetMempoolAddr(POOL_ID_DISP_VDO2TEMP);
uiPoolSize = OS_GetMempoolSize(POOL_ID_DISP_VDO2TEMP);
#endif
#if 1
Jpeg_DecodeInfo((const UINT8*)uiJPGData, uiJPGSize, &w, &h, &fmt);
DBG_IND("Splash data=%08x, size=%08x, w=%d, h=%d, fmt=%x\r\n", uiJPGData, uiJPGSize, w, h, fmt);
Jpeg_GetImageAddr(w, h, fmt, (UINT8*)uiTempBuf, &uiOutAddrY, &uiOutAddrCb, &uiOutAddrCr);
DBG_IND("output dataY=%08x, dataY=%08x, dataY=%08x\r\n", uiOutAddrY, uiOutAddrCb, uiOutAddrCr);
Jpeg_DecodeImage((UINT8*)uiJPGData, uiJPGSize, (UINT8*)uiTempBuf, w*h*2);
if(LayerID == LAYER_VDO1) //VDO1
{
#if(VDO_USE_ROTATE_BUFFER == ENABLE)
if (fmt == PXLFMT_YUV422_PK)
GxImg_InitBuf(&DispImg,w,h,GX_IMAGE_PIXEL_FMT_YUV422, GXIMAGE_LINEOFFSET_ALIGN(16),uiTempBuf,w*h*2);
else
GxImg_InitBuf(&DispImg,w,h,GX_IMAGE_PIXEL_FMT_YUV420, GXIMAGE_LINEOFFSET_ALIGN(16),uiTempBuf,w*h*2);
GxImg_RotateData(&DispImg,uiPoolAddr,uiPoolSize,GX_IMAGE_ROTATE_90,&DispOutImg);
Display_SetBuffer(LAYER_VDO1, h, w, h, PXLFMT_YUV420_PK, DispOutImg.PxlAddr[0], DispOutImg.PxlAddr[1], DispOutImg.PxlAddr[2]);
Display_SetWindow(LAYER_VDO1, 0, 0, DeviceSize.h, DeviceSize.w);
#else
Display_SetBuffer(LAYER_VDO1, w, h, w, fmt, uiOutAddrY, uiOutAddrCb, uiOutAddrCr);
Display_SetWindow(LAYER_VDO1, 0, 0, DeviceSize.w, DeviceSize.h);
#endif
Display_SetEnable(LAYER_VDO1, TRUE);
Display_SetEnable(LAYER_VDO2, FALSE);
}
if(LayerID == LAYER_VDO2) //VDO2
{
Display_SetBuffer(LAYER_VDO2, w, h, w, fmt, uiOutAddrY, uiOutAddrCb, uiOutAddrCr);
Display_SetWindow(LAYER_VDO2, 0, 0, DeviceSize.w, DeviceSize.h);
Display_SetEnable(LAYER_VDO1, FALSE);
Display_SetEnable(LAYER_VDO2, TRUE);
}
#endif
}
void System_OnStrgInit_EXMEM(void)
{
static BOOL bStrg_init_EXMEM = FALSE;
if(bStrg_init_EXMEM)
return;
{
DX_HANDLE DxCardDev1 = Dx_GetObject(DX_CLASS_STORAGE_EXT|DX_TYPE_CARD1);
UserSdioInit.buf.Addr = OS_GetMempoolAddr(POOL_ID_STORAGE_SDIO);
UserSdioInit.buf.Size = OS_GetMempoolSize(POOL_ID_STORAGE_SDIO);
Dx_Init(DxCardDev1,&UserSdioInit,0,STORAGE_VER);
}
#if(COPYCARD2CARD_FUNCTION == ENABLE)
// for card 2
{
DX_HANDLE DxCardDev2 = Dx_GetObject(DX_CLASS_STORAGE_EXT|DX_TYPE_CARD2);
UserSdio2Init.buf.Addr = OS_GetMempoolAddr(POOL_ID_STORAGE_SDIO2);
UserSdio2Init.buf.Size = OS_GetMempoolSize(POOL_ID_STORAGE_SDIO2);
Dx_Init(DxCardDev2,&UserSdio2Init,0,STORAGE_VER);
}
#endif
bStrg_init_EXMEM = TRUE;
}
/**
Initialize application for USB SIDC mode
Initialize application for USB SIDC mode.
@param void
@return void
*/
void AppInit_ModeUSBSIDC(void)
{
//#Bus-Power or Self-Power is decided by project.Bus-Powered is default.
USB_SIDC_INFO SIDCInfo={0};
char* pDxName=NULL;
UINT32 uiPoolAddr, uiSidcBuff;
DX_HANDLE pStrgDev = GxStrg_GetDevice(0);
uiPoolAddr = OS_GetMempoolAddr(POOL_ID_DISP_VDO1);
Sidc_SetSendObjBufAddrSize((UINT32)uiPoolAddr, MIN_BUFFER_SIZE_FOR_SENDOBJ);
uiSidcBuff = uiPoolAddr + MIN_BUFFER_SIZE_FOR_SENDOBJ;
SIDCInfo.uiSidcBufAddr = uiSidcBuff;
SIDCInfo.uiSidcBufSize = SIDC_WORKING_BUFFER;
USBMakerInit_USIDC(&SIDCInfo);
if(Dx_GetInfo(pStrgDev, DX_INFO_NAME,&pDxName)!=DX_OK)
{
pDxName = NULL;
}
// Check card lock status, only storage card has this status, where NAND flash does not
if (pDxName==NULL || strcmp(pDxName, "Storage_Nand1")==0)
{
SIDCInfo.uiStrgCardLock = FALSE;
}
else if (strcmp(pDxName,"Storage_Card1")==0)
{
//#NT#2010/07/20#Jeah Yen -begin
SIDCInfo.uiStrgCardLock = GxStrg_GetDeviceCtrl(0, CARD_READONLY);
//#NT#2010/07/20#Jeah Yen -end
}
//#Bus-Power or Self-Power is decided by project.Bus-Powered is default.
#if (USB_CHARGE_FUNCTION == DISABLE)
SIDCInfo.isSelfPwred = TRUE;
#endif
if (Sidc_Open(&SIDCInfo) != E_OK)
{
debug_err(("Error open USB SIDC task\r\n"));
}
}
void Display_ShowSplash(SPLASH_ID splash_id)
{
UINT32 uiPoolAddr;
//TM_Begin(DISP_SHOWLOGO);
//get temp buffer
uiPoolAddr = OS_GetMempoolAddr(POOL_ID_DISP_VDO2);
if (uiPoolAddr == 0)
{
return;
}
#if 1
//load default logo
#if (UI_STYLE==UI_STYLE_DRIVER)
if (splash_id == SPLASH_POWERON)
{
p_gLogoJPG = (UINT32)g_ucBGOpening;
p_gLogoSize = Logo_getBGOpening_size();
} else {
p_gLogoJPG = (UINT32)g_ucBGGoodbye;
p_gLogoSize = Logo_getBGGoodbye_size();
}
#else
if (splash_id == SPLASH_POWERON)
{
p_gLogoJPG = (UINT32)gDemo_Logo;
p_gLogoSize = DEMO_LOGO_SIZE;
}
else
{
p_gLogoJPG = (UINT32)gDemoPwroff_Logo;
p_gLogoSize = DEMO_PWROFFLOGO_SIZE;
}
#endif
//show logo
DBG_IND("Show Logo\r\n");
UI_ShowJPG(LOGO_DISP_LAYER, (UINT32)p_gLogoJPG, p_gLogoSize, uiPoolAddr);
#endif
//TM_End(DISP_SHOWLOGO);
}
void PipView_FlipImage(PIMG_BUF pSrc, IRECT* pRcSrc, PIMG_BUF pDst, IRECT* pRcDst)
{
UINT32 uiPoolAddr, uiPoolSize, uiBufSize;
UINT32 uiLineOffset[2] = {0};
UINT32 uiPxlAddr[2] = {0};
IRECT DstRegion;
IPOINT Location;
IMG_BUF DstImg;
uiPoolAddr = OS_GetMempoolAddr(POOL_ID_PIP_FLIP);
uiPoolSize = OS_GetMempoolSize(POOL_ID_PIP_FLIP);
DstRegion.x = 0;
DstRegion.y = 0;
DstRegion.w = ALIGN_CEIL_16(pRcDst->w);
DstRegion.h = ALIGN_CEIL_8(pRcDst->h);
uiLineOffset[0] = DstRegion.w;
uiLineOffset[1] = DstRegion.w;
uiPxlAddr[0] = uiPoolAddr;
uiPxlAddr[1] = uiPoolAddr + DstRegion.w * DstRegion.h;
// scale
GxImg_InitBufEx(&DstImg,
DstRegion.w,
DstRegion.h,
pDst->PxlFmt,
uiLineOffset,
uiPxlAddr);
GxImg_ScaleData(pSrc, pRcSrc, &DstImg, &DstRegion);
// horizontal flip
uiBufSize = (DstRegion.w * DstRegion.h * 3) / 2;
GxImg_SelfRotate(&DstImg, uiPoolAddr + uiBufSize, uiPoolSize - uiBufSize, GX_IMAGE_ROTATE_HRZ);
// copy
Location.x = pRcDst->x;
Location.y = pRcDst->y;
GxImg_CopyData(&DstImg, &DstRegion, pDst, &Location);
}
void System_OnStrgInit_PS(void)
{
//PHASE-2 : Init & Open Lib or LibExt
#if PST_FUNC
// Open PStore
PSFMT gFmtStruct = {MAX_BLK_PER_SEC,MAX_SEC_NUM};
PSTORE_INIT_PARAM gPStoreParam;
UINT32 result=0;
UINT8 *pBuf;
DX_HANDLE pStrgDev = 0;
//UINT32 hStrg = 0;
pStrgDev = Dx_GetObject(DX_CLASS_STORAGE_EXT|DX_TYPE_NAND3);
//PStore_InstallCmd();
pBuf = (UINT8 *)OS_GetMempoolAddr(POOL_ID_PS_BUFFER);
gPStoreParam.pBuf = pBuf;
gPStoreParam.uiBufSize = POOL_SIZE_PS_BUFFER;
result = PStore_Open(pStrgDev,&gPStoreParam);
if(result!=E_PS_OK)
{
DBG_ERR("PStore Open fail %d format \r\n",result);
result = PStore_Format(&gFmtStruct);
}
//#NT#2013/05/28#Lincy Lin -begin
//#NT#
// read calibration data
#if (UI_STYLE!=UI_STYLE_DRIVER)
Cal_ReadSysData();
Cal_ApplyData(CAL_SYS_DATA);
#endif
//#NT#2013/05/28#Lincy Lin -end
#endif
}
void System_OnStrgInit_FWS(void)
{
BOOL bLZC = FALSE;
ER er;
UINT32 m_LdLoadedOffest;
DX_HANDLE pStrgDev = 0;
DBG_MSG("Init!\r\n");
DBG_IND("^M LD_BLOCK=%d\r\n", gBinInfo.ld.LdBlockCount);
DBG_IND("^M FW_MAX_SIZE=%08X\r\n", gBinInfo.ld.FWResvSize);
DBG_IND("^MFW_validate-update:");
//ValidateUpdateFW
{
UINT32 bUpdate = ((gBinInfo.ld.LdCtrl2 & LDCF_UPDATE_FW)!=0);
UINT32 uiUpdateResult = ((gBinInfo.ld.LdCtrl2 & LDCF_UPDATE_FW_DONE)!=0);
if(bUpdate)
{
DBG_IND("\r\n^MFW is just updated.\r\n");
if(!uiUpdateResult)
{
DBG_FATAL("\r\nFW updated: fail!\r\n");
}
}
}
DBG_IND("^M ok\r\n");
pStrgDev = Dx_GetObject(DX_CLASS_STORAGE_EXT|DX_TYPE_NAND0);
#if (_INTERSTORAGE_==_INTERSTORAGE_SPI_)
bLZC = TRUE;
#else
bLZC = FALSE;
#endif
if(bLZC)
{
gPL_Init.PlInit.DataType = PARTLOAD_DATA_TYPE_COMPRESS_LZ;
gPL_BufAddr = OS_GetMempoolAddr(POOL_ID_APP);
gPL_BufSize = POOL_SIZE_APP;
}
else
{
gPL_Init.PlInit.DataType = PARTLOAD_DATA_TYPE_UNCOMPRESS;
gPL_BufAddr = OS_GetMempoolAddr(POOL_ID_FWS_BUFFER);
gPL_BufSize = POOL_SIZE_FWS_BUFFER;
}
m_LdLoadedOffest = gBinInfo.ld.LdLoadSize; //Get Ld loaded size
gPL_Init.uiApiVer = FWSRV_API_VERSION;
gPL_Init.TaskID = 0;
gPL_Init.SemID = 0;
gPL_Init.FlagID = 0;
gPL_Init.PlInit.uiApiVer = PARTLOAD_API_VERSION;
gPL_Init.PlInit.hStrg = pStrgDev;
gPL_Init.PlInit.uiAddrBegin = OS_GetMemAddr(MEM_CODE)+m_LdLoadedOffest; //Must be block boundary align
gPL_Init.PlInit.uiWorkingAddr = gPL_BufAddr;
gPL_Init.PlInit.uiWorkingSize = gPL_BufSize;
er = FwSrv_Init(&gPL_Init);
if(er != FWSRV_ER_OK)
{
DBG_ERR("Init failed!\r\n");
}
er = FwSrv_Open();
if(er != FWSRV_ER_OK)
{
DBG_ERR("Open failed!\r\n");
}
}
void UIDisplay_Init(UINT8 iDD, BOOL bClear, ISIZE* pDeviceSize)
{
RESULT r;
LAYER_INIT LayerInit;
UINT32 uiBufAddr;
//fixed buffer size
UINT32 osd_w = OSD_W;
UINT32 osd_h = OSD_H;
//fixed buffer size
UINT32 vdo_w = OSD_W;
UINT32 vdo_h = OSD_H;
//ISIZE DeviceSize;
LAYER_INIT* pLayerInit = (LAYER_INIT*)&LayerInit; //layer init parameter
//DeviceSize = GxVideo_GetDeviceSize(DOUT1);
ISIZE DeviceSize = pDeviceSize[0];
DBG_MSG("DOUT=%d\n\r",iDD>>4);
switch(iDD & 0x0f) //check layer
{
case LAYER_OSD1:
uiBufAddr = OS_GetMempoolAddr(POOL_ID_DISP_OSD1);
pLayerInit->uiType = TYPE_FB;
pLayerInit->uiPxlfmt = DISPLAY_OSD_FMT;
pLayerInit->uiWidth = osd_w;
pLayerInit->uiHeight = osd_h;
#if (OSD_USE_DOUBLE_BUFFER == ENABLE)
pLayerInit->uiBufCount = 1;
pLayerInit->uiSwapEffect = SWAPEFFECT_COPY;
#else
pLayerInit->uiBufCount = 0;
pLayerInit->uiSwapEffect = SWAPEFFECT_DISCARD;
#endif
switch(pLayerInit->uiPxlfmt)
{
case PXLFMT_INDEX1: pLayerInit->uiBufSize = (osd_w*osd_h)>>3;break;
case PXLFMT_INDEX2: pLayerInit->uiBufSize = (osd_w*osd_h)>>2;break;
case PXLFMT_INDEX4: pLayerInit->uiBufSize = (osd_w*osd_h)>>1;break;
case PXLFMT_INDEX8: pLayerInit->uiBufSize = (osd_w*osd_h)>>0;break;
}
pLayerInit->pBufAddr[0] = uiBufAddr;
#if (OSD_USE_DOUBLE_BUFFER == ENABLE)
pLayerInit->pBufAddr[1] = uiBufAddr + pLayerInit->uiBufSize;
#else
pLayerInit->pBufAddr[1] = 0;
#endif
pLayerInit->pBufAddr[2] = 0;
//dynamic window size
pLayerInit->win.x= 0;
pLayerInit->win.y = 0;
pLayerInit->win.w = DeviceSize.w;
pLayerInit->win.h = DeviceSize.h;
pLayerInit->uiWinAttr = 0;
#if (OSD_USE_ROTATE_BUFFER == ENABLE)
if(gbOsdRotate == 1)
{
DBG_MSG("^YEnable Rotate\r\n");
//prepare show DC
UINT32 buf_w = pLayerInit->uiWidth;
UINT32 buf_h = pLayerInit->uiHeight;
UINT32 win_w = pLayerInit->win.w;
UINT32 win_h = pLayerInit->win.h;
pLayerInit->uiWidth = buf_h;
pLayerInit->uiHeight = buf_w;
pLayerInit->uiBufCount = 0;
pLayerInit->uiSwapEffect = SWAPEFFECT_DISCARD;
pLayerInit->pBufAddr[0] = uiBufAddr;
pLayerInit->pBufAddr[1] = 0;
pLayerInit->pBufAddr[2] = 0;
pLayerInit->win.w = win_h;
pLayerInit->win.h = win_w;
//prepare paint DC
memset(pPaintDC, 0, sizeof(DC));
GxGfx_AttachDC(pPaintDC, TYPE_FB,
pLayerInit->uiPxlfmt, buf_w, buf_h, buf_w,
(UINT8*)(uiBufAddr + pLayerInit->uiBufSize), 0, 0);
}
else
{
DBG_MSG("^YDisable Rotate\r\n");
}
#endif
r = GxDisplay_InitLayer(iDD, &LayerInit, bClear);
UI_DirtyDisplaySource(iDD); //must force flush to update new swap-buffer and new swap-effect
DBG_MSG("OSD1 buf=%08x, size=%08x\n\r",LayerInit.pBufAddr[0], LayerInit.uiBufSize);
DBG_MSG("OSD1 buf.w=%d, buf.h=%d;\n\r",LayerInit.uiWidth, LayerInit.uiHeight);
DBG_MSG("OSD1 win.w=%d, win.h=%d;\n\r",LayerInit.win.w, LayerInit.win.h);
break;
case LAYER_OSD2:
uiBufAddr = OS_GetMempoolAddr(POOL_ID_DISP_OSD2);
pLayerInit->uiType = TYPE_FB;
pLayerInit->uiPxlfmt = DISPLAY_OSD_FMT;
pLayerInit->uiWidth = osd_w;
pLayerInit->uiHeight = osd_h;
#if (OSD2_USE_DOUBLE_BUFFER == ENABLE)
pLayerInit->uiBufCount = 1;
pLayerInit->uiSwapEffect = SWAPEFFECT_COPY;
#else
pLayerInit->uiBufCount = 0;
pLayerInit->uiSwapEffect = SWAPEFFECT_DISCARD;
#endif
switch(pLayerInit->uiPxlfmt)
{
case PXLFMT_INDEX1: pLayerInit->uiBufSize = (osd_w*osd_h)>>3;break;
case PXLFMT_INDEX2: pLayerInit->uiBufSize = (osd_w*osd_h)>>2;break;
case PXLFMT_INDEX4: pLayerInit->uiBufSize = (osd_w*osd_h)>>1;break;
case PXLFMT_INDEX8: pLayerInit->uiBufSize = (osd_w*osd_h)>>0;break;
}
pLayerInit->pBufAddr[0] = uiBufAddr;
#if (OSD2_USE_DOUBLE_BUFFER == ENABLE)
pLayerInit->pBufAddr[1] = uiBufAddr + pLayerInit->uiBufSize;
#else
pLayerInit->pBufAddr[1] = 0;
#endif
pLayerInit->pBufAddr[2] = 0;
//dynamic window size
pLayerInit->win.x= 0;
pLayerInit->win.y = 0;
pLayerInit->win.w = DeviceSize.w;
pLayerInit->win.h = DeviceSize.h;
pLayerInit->uiWinAttr = 0;
r = GxDisplay_InitLayer(iDD, &LayerInit, bClear);
DBG_MSG("OSD2 buf=%08x, size=%08x\n\r",LayerInit.pBufAddr[0], LayerInit.uiBufSize);
DBG_MSG("OSD2 buf.w=%d, buf.h=%d;\n\r",LayerInit.uiWidth, LayerInit.uiHeight);
DBG_MSG("OSD2 win.w=%d, win.h=%d;\n\r",LayerInit.win.w, LayerInit.win.h);
break;
case LAYER_VDO1:
uiBufAddr = OS_GetMempoolAddr(POOL_ID_DISP_VDO1);
pLayerInit->uiType = TYPE_FB;
pLayerInit->uiPxlfmt = DISPLAY_VDO_FMT;
pLayerInit->uiWidth = vdo_w;
pLayerInit->uiHeight = vdo_h;
#if (VDO_USE_DOUBLE_BUFFER == ENABLE)
pLayerInit->uiBufCount = 1;
pLayerInit->uiSwapEffect = SWAPEFFECT_COPY;
#else
pLayerInit->uiBufCount = 0;
pLayerInit->uiSwapEffect = SWAPEFFECT_DISCARD;
#endif
switch(pLayerInit->uiPxlfmt)
{
case PXLFMT_YUV422:
case PXLFMT_YUV422_PK:
pLayerInit->uiBufSize = (vdo_w*vdo_h)*2 + 64;break;
break;
default: DBG_ERR("Pxlfmt %d",pLayerInit->uiPxlfmt);
}
pLayerInit->pBufAddr[0] = uiBufAddr;
#if (VDO_USE_DOUBLE_BUFFER == ENABLE)
pLayerInit->pBufAddr[1] = uiBufAddr + pLayerInit->uiBufSize;
#else
pLayerInit->pBufAddr[1] = 0;
#endif
pLayerInit->pBufAddr[2] = 0;
//dynamic window size
pLayerInit->win.x= 0;
pLayerInit->win.y = 0;
pLayerInit->win.w = DeviceSize.w;
pLayerInit->win.h = DeviceSize.h;
pLayerInit->uiWinAttr = 0;
r = GxDisplay_InitLayer(iDD, &LayerInit, bClear);
DBG_MSG("VDO1 buf=%08x, size=%08x\n\r",LayerInit.pBufAddr[0], LayerInit.uiBufSize);
DBG_MSG("VDO1 buf.w=%d, buf.h=%d;\n\r",LayerInit.uiWidth, LayerInit.uiHeight);
DBG_MSG("VDO1 win.w=%d, win.h=%d;\n\r",LayerInit.win.w, LayerInit.win.h);
break;
case LAYER_VDO2:
uiBufAddr = OS_GetMempoolAddr(POOL_ID_DISP_VDO2);
pLayerInit->uiType = TYPE_FB;
pLayerInit->uiPxlfmt = DISPLAY_VDO_FMT;
pLayerInit->uiWidth = vdo_w;
pLayerInit->uiHeight = vdo_h;
#if (VDO2_USE_DOUBLE_BUFFER == ENABLE)
pLayerInit->uiBufCount = 1;
pLayerInit->uiSwapEffect = SWAPEFFECT_COPY;
#else
pLayerInit->uiBufCount = 0;
pLayerInit->uiSwapEffect = SWAPEFFECT_DISCARD;
#endif
switch(pLayerInit->uiPxlfmt)
{
case PXLFMT_YUV422:
case PXLFMT_YUV422_PK: pLayerInit->uiBufSize = (vdo_w*vdo_h)*2 + 64;
break;
default: DBG_ERR("Pxlfmt %d",pLayerInit->uiPxlfmt);
}
pLayerInit->pBufAddr[0] = uiBufAddr;
#if (VDO2_USE_DOUBLE_BUFFER == ENABLE)
pLayerInit->pBufAddr[1] = uiBufAddr + pLayerInit->uiBufSize;
#else
pLayerInit->pBufAddr[1] = 0;
#endif
pLayerInit->pBufAddr[2] = 0;
pLayerInit->win.x = 0;
pLayerInit->win.y = 0;
pLayerInit->win.w = DeviceSize.w;
pLayerInit->win.h = DeviceSize.h;
pLayerInit->uiWinAttr = 0;
r = GxDisplay_InitLayer(iDD, &LayerInit, bClear);
DBG_MSG("VDO2 buf1=%08x, size=%08x\n\r",LayerInit.pBufAddr[0], LayerInit.uiBufSize);
DBG_MSG("VDO2 buf2=%08x, size=%08x\n\r",LayerInit.pBufAddr[1], LayerInit.uiBufSize);
DBG_MSG("VDO2 buf.w=%d, buf.h=%d;\n\r",LayerInit.uiWidth, LayerInit.uiHeight);
DBG_MSG("VDO2 win.w=%d, win.h=%d;\n\r",LayerInit.win.w, LayerInit.win.h);
break;
}
}
static BOOL UI_WriteLogoFileName(UINT32 logoId)
{
FST_FILE pFile;
UINT32 uiFileSize;
UINT8 *BgBuf;
char *fileName;
URECT Rect = {0, 0, 320, 240};
ER erReturn = E_OK;
PSTORE_SECTION_HANDLE* pSecHdl; // to save the handle of PStore section
char *psecnameId;
if (logoId == UI_LOGO_POWERON)
{
fileName = "A:\\logo.jpg";
psecnameId = PS_POWERON_LOGO;
}
else //if (logoId == UI_LOGO_POWEROFF)
{
fileName = "A:\\logo2.jpg";
psecnameId = PS_POWEROFF_LOGO;
}
FileSys_WaitFinish();
pFile = FileSys_OpenFile(fileName, FST_OPEN_READ);
if (pFile == NULL)
{
debug_err(("open file error\r\n"));
return FALSE;
}
uiFileSize = FileSys_GetFileLen(fileName); // for small page nand
USE_MSG(("file size = %d\r\n",uiFileSize));
if ((uiFileSize < 1024) || (uiFileSize > LOGO_MAX_FILESIZE))
{
Cal_FillRect(&Rect, _OSD_INDEX_BLACK);
Cal_ShowStringByColor("jpg size is too big or too small\n", &Rect, _OSD_INDEX_YELLOW, _OSD_INDEX_BLACK);
Delay_DelayMs(2000);
Cal_FillRect(&Rect, _OSD_INDEX_BLACK);
debug_err(("Write logo error\n\r"));
return FALSE;
}
BgBuf = (UINT8 *)OS_GetMempoolAddr(POOL_ID_APP);
if (FileSys_ReadFile(pFile,(UINT8 *)(BgBuf+4),&uiFileSize,FST_FLAG_NONE,NULL)!=FST_STA_OK)
{
USE_MSG(("file read failed\r\n"));
return FALSE;
}
FileSys_CloseFile(pFile);
*BgBuf = LO_BYTE(LO_WORD(uiFileSize));
*(BgBuf+1) = HI_BYTE(LO_WORD(uiFileSize));
*(BgBuf+2) = LO_BYTE(HI_WORD(uiFileSize));
*(BgBuf+3) = HI_BYTE(HI_WORD(uiFileSize));
pSecHdl = PStore_OpenSection(psecnameId, PS_RDWR | PS_CREATE);
if (pSecHdl == E_PS_SECHDLER)
{
debug_err(("Section open fail\r\n"));
goto err_ret;
}
erReturn = PStore_WriteSection(BgBuf, 0, SYSPARAM_LOGO_LEN, pSecHdl);
if (erReturn != E_PS_OK)
{
debug_err(("PStore program error\r\n"));
goto err_ret;
}
//#PIC#2010/07/23#Creator -begin
PStore_CloseSection(pSecHdl);
//#PIC#2010/07/23#Creator -end
return TRUE;
err_ret:
PStore_CloseSection(pSecHdl);
//PStore_DisablePS();
return FALSE;
}
BOOL UI_ShowLogoFile(UINT32 logoId,UINT32 *uiJpgAddr,UINT32 *uiJpgSize)
{
UINT32 uiFileSize;
UINT8 *BgBuf;
ER erReturn;
PSTORE_SECTION_HANDLE* pSecHdl; // to save the handle of PStore section
char *psecnameId;
if (logoId == UI_LOGO_POWERON)
{
psecnameId = PS_POWERON_LOGO;
}
else //if (logoId == UI_LOGO_POWEROFF)
{
psecnameId = PS_POWEROFF_LOGO;
}
//get_blk((void *)&BgBuf, POOL_ID_SICD);
//rel_blk(POOL_ID_SICD, BgBuf);
BgBuf = (UINT8 *)OS_GetMempoolAddr(POOL_ID_APP);
//PStore_EnablePS();
//pSecHdl = PStore_OpenSection(PS_BG_LOGO, PS_RDONLY);
pSecHdl = PStore_OpenSection(psecnameId, PS_RDONLY);
if (pSecHdl == E_PS_SECHDLER)
{
debug_err(("Section PS_BG_LOGO open fail\r\n"));
PStore_CloseSection(pSecHdl);
//PStore_DisablePS();
return FALSE;
}
erReturn = PStore_ReadSection(BgBuf, 0, 4, pSecHdl);
if (erReturn != E_PS_OK)
{
debug_err(("PStore read error\r\n"));
}
uiFileSize = MAKE_LONG(MAKE_WORD(BgBuf[0],BgBuf[1]),MAKE_WORD(BgBuf[2],BgBuf[3]));
USE_MSG(("UserPS_ShowLogoFile: logo uiFileSize %d\r\n",uiFileSize));
//check file size logo size: 1k---20k
if ((uiFileSize < 1024) || (uiFileSize > LOGO_MAX_FILESIZE))
{
USE_MSG(("Show logo error\n\r"));
PStore_CloseSection(pSecHdl);
//PStore_DisablePS();
return FALSE;
}
erReturn = PStore_ReadSection(BgBuf, 0, (uiFileSize+4), pSecHdl);
if (erReturn != E_PS_OK)
{
debug_err(("PStore read error\r\n"));
PStore_CloseSection(pSecHdl);
return FALSE;
}
PStore_CloseSection(pSecHdl);
*uiJpgAddr = (UINT32)(BgBuf+4);
*uiJpgSize = (UINT32)uiFileSize;
return TRUE;
}
void UI_UpdateCfgFile(void)
{
#if 0
UINT32 uiKeyAct, uiKeyCode;
FLGPTN uiFlag;
#endif
char* str;
FST_FILE pFile;
UINT32 uiFileSize;
UINT8 *BgBuf;
char *fileName;
URECT Rect = {0, 0, 320, 240};
BOOL Ret =TRUE ;
ER erReturn;
PSTORE_SECTION_HANDLE* pSecHdl; // to save the handle of PStore section
fileName = "A:\\NTCONFIG.bin";
FileSys_WaitFinish();
pFile = FileSys_OpenFile(fileName, FST_OPEN_READ);
if (pFile == NULL)
{
debug_err(("open file error\r\n"));
Ret =FALSE;
}
uiFileSize = FileSys_GetFileLen(fileName); // for small page nand
USE_MSG(("file size = %d\r\n",uiFileSize));
//if file is null
if (uiFileSize == 0)
{
USE_MSG(("file size is 0\r\n"));
Ret =FALSE;
}
if (uiFileSize > CFG_MAX_FILESIZE)
{
USE_MSG(("file size is bigger = %d\r\n",uiFileSize));
Ret =FALSE;
}
//get_blk((void *)&BgBuf, POOL_ID_SICD);
//rel_blk(POOL_ID_SICD, BgBuf);
//SysGetSICDAddr((UINT32*)&BgBuf);
BgBuf = (UINT8 *)OS_GetMempoolAddr(POOL_ID_APP);
if (FileSys_ReadFile(pFile,BgBuf,&uiFileSize,FST_FLAG_NONE,NULL)!=FST_STA_OK)
{
USE_MSG(("file read failed\r\n"));
Ret =FALSE;
}
FileSys_CloseFile(pFile);
*BgBuf = LO_BYTE(LO_WORD(uiFileSize));
*(BgBuf+1) = HI_BYTE(LO_WORD(uiFileSize));
*(BgBuf+2) = LO_BYTE(HI_WORD(uiFileSize));
*(BgBuf+3) = HI_BYTE(HI_WORD(uiFileSize));
//PStore_EnablePS();
pSecHdl = PStore_OpenSection(PS_BG_CFG, PS_RDWR | PS_CREATE);
if (pSecHdl == E_PS_SECHDLER)
{
debug_err(("Section open fail\r\n"));
PStore_CloseSection(pSecHdl);
//PStore_DisablePS();
Ret =FALSE;
}
erReturn = PStore_WriteSection(BgBuf, 0, SYSPARAM_SYSFLAG_LEN, pSecHdl);
PStore_CloseSection(pSecHdl);
if (erReturn != E_PS_OK)
{
debug_err(("PStore program error\r\n"));
Ret =FALSE;
}
Cal_FillRect(&Rect, _OSD_INDEX_BLACK);
Rect.x = 56;
Rect.y = 108;
Rect.w = 212;
Rect.h = 24;
if (Ret == FALSE)
{
str = "Update Cfg file error";
Cal_ShowStringByColor(str, &Rect, _OSD_INDEX_YELLOW, _OSD_INDEX_BLACK);
}else
{
str = "Update Cfg file ok";
Cal_ShowStringByColor(str, &Rect, _OSD_INDEX_YELLOW, _OSD_INDEX_BLACK);
}
Delay_DelayMs(1000);
if (Ret)
{
System_PowerOff(SYS_POWEROFF_NORMAL);
}
#if 0
clr_flg(FLG_ID_CALIBRATION, 0xffffffff);
while (1)
{
wai_flg(&uiFlag, FLG_ID_CALIBRATION, 0xffffffff, TWF_ORW | TWF_CLR);
debug_msg("^GuiFlag:%x\r\n",uiFlag);
if (uiFlag)
break;
}
#else
Delay_DelayMs(1500);
#endif
}
BOOL UI_LoadCfgFile(void)
{
ER erReturn;
UINT32 i;
char *SysParam_Sector;
UINT32 uiFileSize;
UINT8 *BgBuf;
PSTORE_SECTION_HANDLE* pSecHdl;
strcpy(gUIConfigInfo.strMakerString, (CHAR *)GetMakerString());
strcpy(gUIConfigInfo.strModelString,(CHAR *)GetModelString());
strcpy(gUIConfigInfo.strSoftwareVer,(CHAR *)GetVersionString());
gUIConfigInfo.uiSizeDefaultIndex = DEFAULT_PHOTO_SIZE;
gUIConfigInfo.uiMovieSizeDefaultIndex = DEFAULT_MOVIE_SIZE;
gUIConfigInfo.uiLanguageDefaultIndex = DEFAULT_LANGUAGE;
gUIConfigInfo.uiFreqDefaultIndex = DEFAULT_FREQUENCY;
gUIConfigInfo.uiTVModeDefaultIndex = DEFAULT_TV_MODE;
gUIConfigInfo.uiDateImprintDefaultIndex = DEFAULT_MOVIE_DATEIMPRINT;
gUIConfigInfo.uiBeepDefaultIndex = DEFAULT_BEEP;
gUIConfigInfo.uiVideoAudioDefaultIndex = DEFAULT_MOVIE_AUDIO;
BgBuf = (UINT8 *)OS_GetMempoolAddr(POOL_ID_APP);
//PStore_EnablePS();
pSecHdl = PStore_OpenSection(PS_BG_CFG, PS_RDONLY);
if (pSecHdl == E_PS_SECHDLER)
{
debug_err(("UserPS_ReadCfgFile: Section open fail\r\n"));
goto err_ret;
}
erReturn = PStore_ReadSection(BgBuf, 0, 4, pSecHdl);
if (erReturn != E_PS_OK)
{
debug_err(("UserPS_ReadCfgFile: PStore read error\r\n"));
goto err_ret;
}
uiFileSize = MAKE_LONG(MAKE_WORD(BgBuf[0],BgBuf[1]),MAKE_WORD(BgBuf[2],BgBuf[3]));
USE_MSG(("UserPS_ReadCfgFile: cfg filesize=%d\r\n", uiFileSize));
if (uiFileSize > CFG_MAX_FILESIZE)
{
debug_err(("UserPS_ReadCfgFile: file size error\n\r"));
goto err_ret;
}
erReturn = PStore_ReadSection(BgBuf, 0, (uiFileSize+4), pSecHdl);
if (erReturn != E_PS_OK)
{
debug_err(("UserPS_ReadCfgFile: PStore read error\r\n"));
goto err_ret;
}
PStore_CloseSection(pSecHdl);
//PStore_DisablePS();
SysParam_Sector = (char *)(BgBuf + ((uiFileSize+4+4-1)/4)*4);
memset((UINT8 *)SysParam_Sector,0,SYSPARAM_SYSFLAG_LEN);
if (!get_key_value((char *)&BgBuf[4],(char*)SysParam_Sector))
{
debug_err(("UserPS_ReadCfgFile: Read cfg file error\r\n"));
return FALSE;//goto err_ret;
}
i = 0;
while(TRUE)
{
if (SysParam_Sector[0] == '\0')
{
debug_err(("sysflag is null\r\n"));
break;
}
if (i*KEY_VALUE_LEN >= SYSPARAM_SYSFLAG_LEN)
{
break;
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN, "beep"))
{
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "yes"))
{
USE_MSG(("beep yes\r\n"));
UI_SetBeepDefaultIndex(BEEP_ON);
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "no"))
{
USE_MSG(("beep no\r\n"));
UI_SetBeepDefaultIndex(BEEP_OFF);
}
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN, "videoaudio"))
{
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "yes"))
{
USE_MSG(("videoaudio yes\r\n"));
UI_SetVideoAudioDefaultIndex(MOVIE_AUDIO_ON);
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "no"))
{
USE_MSG(("videoaudio no\r\n"));
UI_SetVideoAudioDefaultIndex(MOVIE_AUDIO_OFF);
}
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN, "hz"))
{
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "50hz"))
{
USE_MSG(("50hz\r\n"));
UI_SetFreqDefaultIndex(FREQUENCY_50HZ);
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "60hz"))
{
USE_MSG(("60hz\r\n"));
UI_SetFreqDefaultIndex(FREQUENCY_60HZ);
}
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN, "tvmode"))
{
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "pal"))
{
USE_MSG(("tvmode pal\r\n"));
UI_SetTVModeDefaultIndex(TV_MODE_PAL);
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "ntsc"))
{
USE_MSG(("tvmode ntsc\r\n"));
UI_SetTVModeDefaultIndex(TV_MODE_NTSC);
}
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN, "date"))
{
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "yes"))
{
USE_MSG(("date_time on\r\n"));
UI_SetDateImprintDefaultIndex(DATE_TIME_ON);
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "no"))
{
USE_MSG(("date_time off\r\n"));
UI_SetDateImprintDefaultIndex(DATE_TIME_OFF);
}
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN, "moviesize"))
{
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "1080p"))
{
USE_MSG(("moviesize-1080p\r\n"));
gTM_OPTIONS_MOVIE_SIZE[MOVIE_SIZE_1080P].TextId = IDS_MOVIE_SIZE_1080FHD;
gTM_OPTIONS_MOVIE_SIZE[MOVIE_SIZE_1080P].IconId = IDI_MOVIE_SIZE_1080FHD;
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "720p"))
{
USE_MSG(("moviesize-720p\r\n"));
gTM_OPTIONS_MOVIE_SIZE[MOVIE_SIZE_720P].TextId = IDS_MOVIE_SIZE_720P;
gTM_OPTIONS_MOVIE_SIZE[MOVIE_SIZE_720P].IconId = IDI_MOVIE_SIZE_720P;
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "wvga"))
{
USE_MSG(("moviesize-wvga\r\n"));
gTM_OPTIONS_MOVIE_SIZE[MOVIE_SIZE_WVGA].TextId = IDS_MOVIE_SIZE_WVGA;
gTM_OPTIONS_MOVIE_SIZE[MOVIE_SIZE_WVGA].IconId = IDI_MOVIE_SIZE_WVGA;
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "vga"))
{
USE_MSG(("moviesize-vga\r\n"));
gTM_OPTIONS_MOVIE_SIZE[MOVIE_SIZE_VGA].TextId = IDS_MOVIE_SIZE_VGA;
gTM_OPTIONS_MOVIE_SIZE[MOVIE_SIZE_VGA].IconId = IDI_MOVIE_SIZE_VGA;
}
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN, "photosize"))
{
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "12m"))
{
USE_MSG(("photosize-12m\r\n"));
gTM_OPTIONS_PHOTO_SIZE[PHOTO_SIZE_12M].TextId = IDS_PHOTO_SIZE_12M;
gTM_OPTIONS_PHOTO_SIZE[PHOTO_SIZE_12M].IconId = IDI_PHOTO_SIZE_12M;
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "10m"))
{
USE_MSG(("photosize-10m\r\n"));
gTM_OPTIONS_PHOTO_SIZE[PHOTO_SIZE_10M].TextId = IDS_PHOTO_SIZE_10M;
gTM_OPTIONS_PHOTO_SIZE[PHOTO_SIZE_10M].IconId = IDI_PHOTO_SIZE_10M;
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "8m"))
{
USE_MSG(("photosize-8m\r\n"));
gTM_OPTIONS_PHOTO_SIZE[PHOTO_SIZE_8M].TextId = IDS_PHOTO_SIZE_8M;
gTM_OPTIONS_PHOTO_SIZE[PHOTO_SIZE_8M].IconId = IDI_PHOTO_SIZE_8M;
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "5m"))
{
USE_MSG(("photosize-5m\r\n"));
gTM_OPTIONS_PHOTO_SIZE[PHOTO_SIZE_5M].TextId = IDS_PHOTO_SIZE_5M;
gTM_OPTIONS_PHOTO_SIZE[PHOTO_SIZE_5M].IconId = IDI_PHOTO_SIZE_5M;
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "3m"))
{
USE_MSG(("photosize-3m\r\n"));
gTM_OPTIONS_PHOTO_SIZE[PHOTO_SIZE_3M].TextId = IDS_PHOTO_SIZE_3M;
gTM_OPTIONS_PHOTO_SIZE[PHOTO_SIZE_3M].IconId = IDI_PHOTO_SIZE_3M;
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "2m169"))
{
USE_MSG(("photosize-2m9\r\n"));
gTM_OPTIONS_PHOTO_SIZE[PHOTO_SIZE_2MHD].TextId = IDS_PHOTO_SIZE_2MHD;
gTM_OPTIONS_PHOTO_SIZE[PHOTO_SIZE_2MHD].IconId = IDI_PHOTO_SIZE_2MHD;
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "vga"))
{
USE_MSG(("photosize-vgam\r\n"));
gTM_OPTIONS_PHOTO_SIZE[PHOTO_SIZE_VGA].TextId = IDS_PHOTO_SIZE_VGA;
gTM_OPTIONS_PHOTO_SIZE[PHOTO_SIZE_VGA].IconId = IDI_PHOTO_SIZE_VGA;
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "1m"))
{
USE_MSG(("photosize-1m\r\n"));
gTM_OPTIONS_PHOTO_SIZE[PHOTO_SIZE_1M].TextId = IDS_PHOTO_SIZE_1M;
gTM_OPTIONS_PHOTO_SIZE[PHOTO_SIZE_1M].IconId = IDI_PHOTO_SIZE_1M;
}
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN, "defaultmoviesize"))
{
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "1080p"))
{
USE_MSG(("defaultmoviesize-1080p\r\n"));
UI_SetMovieSizeDefaultIndex(MOVIE_SIZE_1080P);
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "720p"))
{
USE_MSG(("defaultmoviesize-720p\r\n"));
UI_SetMovieSizeDefaultIndex(MOVIE_SIZE_720P);
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "wvga"))
{
USE_MSG(("defaultmoviesize-wvga\r\n"));
UI_SetMovieSizeDefaultIndex(MOVIE_SIZE_WVGA);
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "vga"))
{
USE_MSG(("defaultmoviesize-vga\r\n"));
UI_SetMovieSizeDefaultIndex(MOVIE_SIZE_VGA);
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "qvga"))
{
USE_MSG(("defaultmoviesize-qvga\r\n"));
UI_SetMovieSizeDefaultIndex(MOVIE_SIZE_QVGA);
}
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN, "defaultphotosize"))
{
#if (UPDATE_CFG == UPDATE_CFG_YES)
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "vga"))
{
USE_MSG(("defaultphotosize-vga\r\n"));
UI_SetSizeDefaultIndex(PHOTO_SIZE_VGA);
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "2m169"))
{
USE_MSG(("defaultphotosize-2m169\r\n"));
UI_SetSizeDefaultIndex(PHOTO_SIZE_2MHD);
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "2m"))
{
USE_MSG(("defaultphotosize-2m\r\n"));
UI_SetSizeDefaultIndex(PHOTO_SIZE_2M);
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "3m"))
{
USE_MSG(("defaultphotosize-3m\r\n"));
UI_SetSizeDefaultIndex(PHOTO_SIZE_3M);
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "5m"))
{
USE_MSG(("defaultphotosize-5m\r\n"));
UI_SetSizeDefaultIndex(PHOTO_SIZE_5M);
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "8m"))
{
USE_MSG(("defaultphotosize-8m\r\n"));
UI_SetSizeDefaultIndex(PHOTO_SIZE_8M);
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "9m"))
{
USE_MSG(("defaultphotosize-9m\r\n"));
//UI_SetSizeDefaultIndex(PHOTO_SIZE_10M);
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "10m"))
{
USE_MSG(("defaultphotosize-10m\r\n"));
UI_SetSizeDefaultIndex(PHOTO_SIZE_10M);
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "12m"))
{
USE_MSG(("defaultphotosize-12m\r\n"));
UI_SetSizeDefaultIndex(PHOTO_SIZE_12M);
}
#endif
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN, "language"))
{
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "en"))
{
USE_MSG(("language-en\r\n"));
gTM_OPTIONS_LANGUAGE[LANG_EN].TextId = IDS_LANG_EN;
gTM_OPTIONS_LANGUAGE[LANG_EN].IconId = IDI_LANG_EN;
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "de"))
{
USE_MSG(("language-de\r\n"));
gTM_OPTIONS_LANGUAGE[LANG_DE].TextId = IDS_LANG_DE;
gTM_OPTIONS_LANGUAGE[LANG_DE].IconId = IDI_LANG_DE;
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "es"))
{
USE_MSG(("language-es\r\n"));
gTM_OPTIONS_LANGUAGE[LANG_ES].TextId = IDS_LANG_ES;
gTM_OPTIONS_LANGUAGE[LANG_ES].IconId = IDI_LANG_ES;
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "it"))
{
USE_MSG(("language-it\r\n"));
gTM_OPTIONS_LANGUAGE[LANG_IT].TextId = IDS_LANG_IT;
gTM_OPTIONS_LANGUAGE[LANG_IT].IconId = IDI_LANG_IT;
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "ru"))
{
USE_MSG(("language-ru\r\n"));
gTM_OPTIONS_LANGUAGE[LANG_RU].TextId = IDS_LANG_RU;
gTM_OPTIONS_LANGUAGE[LANG_RU].IconId = IDI_LANG_RU;
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "fr"))
{
USE_MSG(("language-fr\r\n"));
gTM_OPTIONS_LANGUAGE[LANG_FR].TextId = IDS_LANG_FR;
gTM_OPTIONS_LANGUAGE[LANG_FR].IconId = IDI_LANG_FR;
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "sc"))
{
USE_MSG(("language-sc\r\n"));
gTM_OPTIONS_LANGUAGE[LANG_SC].TextId = IDS_LANG_SC;
gTM_OPTIONS_LANGUAGE[LANG_SC].IconId = IDI_LANG_SC;
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "tc"))
{
USE_MSG(("language-tc\r\n"));
gTM_OPTIONS_LANGUAGE[LANG_TC].TextId = IDS_LANG_TC;
gTM_OPTIONS_LANGUAGE[LANG_TC].IconId = IDI_LANG_TC;
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "jp"))
{
USE_MSG(("language-jp\r\n"));
gTM_OPTIONS_LANGUAGE[LANG_JP].TextId = IDS_LANG_JP;
gTM_OPTIONS_LANGUAGE[LANG_JP].IconId = IDI_LANG_JP;
}
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN, "defaultlanguage"))
{
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "en"))
{
USE_MSG(("defaultlanguage-en\r\n"));
UI_SetLanguageDefaultIndex(LANG_EN);
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "fr"))
{
USE_MSG(("defaultlanguage-fr\r\n"));
UI_SetLanguageDefaultIndex(LANG_FR);
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "de"))
{
USE_MSG(("defaultlanguage-de\r\n"));
UI_SetLanguageDefaultIndex(LANG_DE);
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "es"))
{
USE_MSG(("defaultlanguage-es\r\n"));\
UI_SetLanguageDefaultIndex(LANG_ES);
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "ru"))
{
USE_MSG(("defaultlanguage-ru\r\n"));
UI_SetLanguageDefaultIndex(LANG_RU);
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "it"))
{
USE_MSG(("defaultlanguage-it\r\n"));
UI_SetLanguageDefaultIndex(LANG_IT);
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "sc"))
{
USE_MSG(("defaultlanguage-sc\r\n"));
UI_SetLanguageDefaultIndex(LANG_SC);
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "tc"))
{
USE_MSG(("defaultlanguage-tc\r\n"));
UI_SetLanguageDefaultIndex(LANG_TC);
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN, "jp"))
{
USE_MSG(("defaultlanguage-jp\r\n"));
UI_SetLanguageDefaultIndex(LANG_JP);
}
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN, "maker"))
{
USE_MSG(("maker:%s\r\n",SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN));
strcpy(gUIConfigInfo.strMakerString,SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN);
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN, "model"))
{
USE_MSG(("model:%s\r\n",SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN));
strcpy(gUIConfigInfo.strModelString,SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN);
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN, "version"))
{
USE_MSG(("verion:%s\r\n",SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN));
strcpy(gUIConfigInfo.strSoftwareVer,SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN);
}
if (!strcmp(SysParam_Sector+i*KEY_VALUE_LEN, "ImageDescription"))
{
USE_MSG(("sImageDescription:%s\r\n",SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN));
strcpy(gUIConfigInfo.strImageDescription,SysParam_Sector+i*KEY_VALUE_LEN+KEY_LEN);
}
i++;
}
return TRUE;
err_ret:
PStore_CloseSection(pSecHdl);
//PStore_DisablePS();
return FALSE;
}
void System_OnStrgInit_FS(void)
{
//#NT#2015/01/21#KS Hung -begin
//#NT#Fast boot recording.
#if (_FAST_BOOT_REC_FUNC_)
DX_HANDLE pStrgDev = Dx_GetObject(DX_CLASS_STORAGE_EXT|DX_TYPE_CARD1);
UINT32 paramArray[0];
#endif
//#NT#2015/01/21#KS Hung -end
{
MEM_RANGE Pool;
Pool.Addr = OS_GetMempoolAddr(POOL_ID_FS_BUFFER);
//#NT#2015/01/21#KS Hung -begin
//#NT#Fast boot recording.
#if (_FAST_BOOT_REC_FUNC_)
Pool.Addr = dma_getCacheAddr(Pool.Addr);
#endif
//#NT#2015/01/21#KS Hung -end
Pool.Size = OS_GetMempoolSize(POOL_ID_FS_BUFFER);
#if USE_FILEDB
GxStrg_SetConfig(FILE_CFG_SUPPORT_EXFAT, FALSE); // cannot support exFAT if using FileDB
#endif
GxStrg_SetConfig(FILE_CFG_BUF, (UINT32)&Pool);
//FileSys_InstallCmd();
}
{
MEM_RANGE WorkBuf;
WorkBuf.Addr = OS_GetMempoolAddr(POOL_ID_EXIF);
WorkBuf.Size = POOL_SIZE_EXIF;
Exif_Init(&WorkBuf, ExifCB);
#if (_SENSORLIB2_ != _SENSORLIB2_DUMMY_)
WorkBuf.Addr += POOL_SIZE_EXIF;
EXIF_Init(EXIF_HDL_ID_2, &WorkBuf, ExifCB);
#endif
}
GxStrg_RegCB(Strg_CB); //Register CB function of GxStorage (NANR or CARD)
{
//FileSys:
//1.設定init值
//#NT#2012/11/14#Philex Lin - begin
// init DCF FolderID/FileID with RTC data
#if (UI_STYLE==UI_STYLE_DRIVER)
System_OnStrgInitDCFFolder();
#else
// Initialize DCF name.ext
//DCF dir-name
DCF_SetDirFreeChars( DCF_SUBPATH );
//DCF file-name
DCF_SetFileFreeChars( DCF_FILE_TYPE_ANYFORMAT, DCF_IMAGE_NAME );
#endif
//#NT#2012/11/14#Philex Lin - end
//DCF file-ext
#if (MOVIE_FORMAT == MOVIE_FORMAT_AVI)
DCF_SetParm(DCF_PRMID_SET_VALID_FILE_FMT, DCF_FILE_TYPE_JPG|DCF_FILE_TYPE_AVI);
#else
DCF_SetParm(DCF_PRMID_SET_VALID_FILE_FMT, DCF_FILE_TYPE_JPG|DCF_FILE_TYPE_AVI|DCF_FILE_TYPE_MOV|DCF_FILE_TYPE_MP4);
#endif
DCF_SetParm(DCF_PRMID_SET_DEP_FILE_FMT, DCF_FILE_TYPE_JPG|DCF_FILE_TYPE_WAV|DCF_FILE_TYPE_MPO);
//TODO: [DCF] How to add an new format & its ext?
//2.設定CB值,
//3.註冊SxJob服務 ---------> System Job
//4.註冊SxTimer服務 ---------> Detect Job
#if (SDINSERT_FUNCTION == ENABLE)
SX_TIMER_DET_STRG_ID = SxTimer_AddItem(&Timer_Card_DetInsert);
#endif
SX_TIMER_DET_SYSTEM_BUSY_ID = SxTimer_AddItem(&Timer_System_DetBusy);
//5.註冊SxCmd服務 ---------> Cmd Function
//System_AddSxCmd(Storage_OnCommand); //GxStorage
#if (_DUAL_CARD_FUNC_ == ENABLE)
SysSetFlag(FL_DualCardMain, MAIN_CARD_NONE);
#endif
//#NT#2014/12/08#KS Hung -begin
//#NT#Fast boot recording.
#if (_FAST_BOOT_REC_FUNC_)
paramArray[0] = (UINT32)pStrgDev;
if ( (GxStrg_GetDeviceCtrl((UINT32)pStrgDev, CARD_INSERT)) || (GxStrg_GetDeviceCtrl((UINT32)pStrgDev, CARD_READONLY)) )
{
GxStrg_ForceDetect(CARD_FORCE_DET_INSERT);
System_OnStrgInsert(&SystemObjCtrl, 1, paramArray);
}
else
{
System_OnStrgRemove(&SystemObjCtrl, 1, paramArray);
}
#endif
//#NT#2014/12/08#KS Hung -end
//start scan
SxTimer_SetFuncActive(SX_TIMER_DET_STRG_ID, TRUE);
SxTimer_SetFuncActive(SX_TIMER_DET_SYSTEM_BUSY_ID, TRUE);
/*
#if (SDINSERT_FUNCTION == ENABLE)
{
//提早detect storage可以得到兩個好處:
//1.知道storage的type是哪一種
//2.立刻"啟動File System"
// 如果沒這樣, 就要等到SXOPEN之後, SX_TIMER_DET_STRG_ID開始跑才會"啟動File System",
// 與其他task的競爭結果, 容易造成"啟動File System"的timing不固定
GxDet_Storage();
GxDet_Storage();
Delay_DelayMs(30);
}
#endif
*/
}
}
INT32 JPG2MOV_MakeMovie(JPG2MOV_OBJ *pObj)
{
#define BS_SIZE_MAX (10*1024*1024) // 10MB
#define YUV_SIZE_MAX (12*1024*1024) // 12MB
#define MEDIAREC_BUF_SIZE (60*1024*1024) // 60MB
UINT32 uiPoolAddr, uiPoolSize, uiBSAddr, uiFileSize;
UINT32 i, j, uiTimeCount, uiMediaRecAddr;
JPG2YUV_INFO Jpg2Yuv;
FST_FILE pFile;
ER err = E_OK;
MEDIAREC_OBJ MediaRecObj = {0};
UINT32 FileNumber;
FILEDB_HANDLE fileDbHandle, fileDbbufSize=0x200000, fileDbbufAddr;
PFILEDB_FILE_ATTR pFileAttr;
uiPoolAddr = OS_GetMempoolAddr(POOL_ID_APP);
uiPoolSize = OS_GetMempoolSize(POOL_ID_APP);
uiBSAddr = uiPoolAddr + uiPoolSize - BS_SIZE_MAX;
uiMediaRecAddr = uiPoolAddr + YUV_SIZE_MAX;
fileDbbufAddr = uiBSAddr - fileDbbufSize;
// ----------------------------------- <--- APP buffer starting address
// | JPEG decode YUV buffer | (original image format)
// -----------------------------------
// | YUV buffer 1 for media recorder | (image format transform: to YUV420 UV-pack, ...)
// -----------------------------------
// | YUV buffer 2 for media recorder |
// -----------------------------------
// | YUV buffer 3 for media recorder |
// -----------------------------------
// | ... |
// -----------------------------------
// | JPEG bitstream buffer |
// ----------------------------------- <--- IQ buffer end address
//
// Note: Be sure the buffer is enough for storing the necessary YUV patterns!
Perf_Open();
uiTimeCount = Perf_GetCurrent();
MediaRecObj.CallBackFunc = JPG2MOV_RecCB;
if (MediaRec_Open(&MediaRecObj) != E_OK)
{
DBG_ERR("MediaRec_Open() failed!\r\n");
return E_SYS;
}
// reset video encode ready flag to TRUE
g_bVidEncReady = TRUE;
//MediaRec_OpenCutMsg(1);
MediaRec_SetGiveYUVBuf(uiMediaRecAddr, MEDIAREC_BUF_SIZE);
JPG2MOV_SetRecParam();
//MediaRec_ChangeParameter(MEDIAREC_RECPARAM_PRE_ENCODE, FALSE, 0, 0);
//MediaRec_ChangeParameter(MEDIAREC_RECPARAM_MERGEYUV, 1, 0, 0);
MediaRec_Record();
// create fileDB for copy
{
FILEDB_INIT_OBJ FilDBInitObj={0};
CHAR rootPath[20]=FILEDB_TMLPS_ROOT;//"A:\\TMLPS\\";
FilDBInitObj.rootPath = rootPath;
FilDBInitObj.bIsRecursive = TRUE;
FilDBInitObj.bIsCyclic = TRUE;
FilDBInitObj.bIsMoveToLastFile = TRUE;
FilDBInitObj.bIsSupportLongName = TRUE;
FilDBInitObj.bIsDCFFileOnly = FALSE;
FilDBInitObj.bIsChkHasFile = FALSE;
FilDBInitObj.u32MaxFilePathLen = 60;
FilDBInitObj.u32MaxFileNum = 20000;
FilDBInitObj.fileFilter = FILEDB_FMT_JPG;
FilDBInitObj.u32MemAddr = dma_getCacheAddr(fileDbbufAddr);
FilDBInitObj.u32MemSize = fileDbbufSize;
fileDbHandle = FileDB_Create(&FilDBInitObj);
}
// merge JPEG file one by one
FileNumber = FileDB_GetTotalFileNum(fileDbHandle);
for (i = 0; i < FileNumber; i++)
{
DBG_MSG("Handle photo no. %d\r\n", i);
// 1. Read JPG data from file
pFileAttr = FileDB_SearhFile(fileDbHandle, i);
//sprintf(sFileName, "A:\\TMLPS\\PHOTO\\2000_0509_043848_001.JPG", (i+1));
uiFileSize = BS_SIZE_MAX;
pFile = FileSys_OpenFile(pFileAttr->filePath, FST_OPEN_READ);
if (pFile)
{
FileSys_ReadFile(pFile, (UINT8 *)uiBSAddr, &uiFileSize, 0, NULL);
FileSys_CloseFile(pFile);
DBG_MSG("File %s, size %d\r\n", sFileName, uiFileSize);
if (uiFileSize == BS_SIZE_MAX)
{
DBG_ERR("Read buffer is not enough!\r\n");
MediaRec_Stop(MEDIAREC_WAIT_END);
MediaRec_Close();
return E_SYS;
}
}
else
{
DBG_ERR("Open %s for reading failed!\r\n", sFileName);
MediaRec_Stop(MEDIAREC_WAIT_END);
MediaRec_Close();
return E_SYS;
}
// 2. Decode JPEG, do format transform and image scaling
Jpg2Yuv.uiJpgAddr = uiBSAddr;
Jpg2Yuv.uiJpgSize = uiFileSize;
Jpg2Yuv.uiYAddr = uiPoolAddr;
err = JPG2YUV_DecodeAndScale(&Jpg2Yuv);
// 3. Wait for video encode ready last time
j = 0;
while (j < 40)
{
if (g_bVidEncReady) // check video encode ready
{
break;
}
Delay_DelayMs(1); // delay 1 ms
j++;
}
// 4. Trigger writing file every second
if (i && ((i % 30) == 0))
{
MediaRec_TriggerWriteFile();
}
// 5. Do H.264 encode
if (err == E_OK)
{
MEDIAREC_READYBUF_INFO readyInfo;
readyInfo.y = Jpg2Yuv.uiYAddr;
readyInfo.cb = Jpg2Yuv.uiUAddr;
readyInfo.cr = Jpg2Yuv.uiVAddr;
readyInfo.y_lot = Jpg2Yuv.uiYLineOffset;
readyInfo.uv_lot = Jpg2Yuv.uiUVLineOffset;
g_bVidEncReady = FALSE;
MediaRec_GiveYUV(&readyInfo);
}
// 6. Update progress test
if (pObj->fpProgressCB)
pObj->fpProgressCB(((i+1)*100)/FileNumber);
}
FileDB_Release(fileDbHandle);
MediaRec_Stop(MEDIAREC_WAIT_END);
MediaRec_Close();
uiTimeCount = Perf_GetCurrent() - uiTimeCount;
DBG_DUMP("^YTotal merge time %d ms\r\n", uiTimeCount/1000);
return E_OK;
}
void System_OnStrgInit_FS(void)
{
{
MEM_RANGE Pool;
Pool.Addr = OS_GetMempoolAddr(POOL_ID_FS_BUFFER);
Pool.Size = OS_GetMempoolSize(POOL_ID_FS_BUFFER);
GxStrg_SetConfig(FILE_CFG_BUF, (UINT32)&Pool);
//FileSys_InstallCmd();
}
{
MEM_RANGE WorkBuf;
WorkBuf.Addr = OS_GetMempoolAddr(POOL_ID_EXIF);
WorkBuf.Size = POOL_SIZE_EXIF*POOL_CNT_EXIF;
Exif_Init(&WorkBuf, ExifCB);
}
GxStrg_RegCB(Strg_CB); //Register CB function of GxStorage (NANR or CARD)
{
//FileSys:
//1.設定init值
//#NT#2012/11/14#Philex Lin - begin
// init DCF FolderID/FileID with RTC data
#if (UI_STYLE==UI_STYLE_DRIVER)
System_OnStrgInitDCFFolder();
#else
// Initialize DCF name.ext
//DCF dir-name
DCF_SetDirFreeChars( DCF_SUBPATH );
//DCF file-name
DCF_SetFileFreeChars( DCF_FILE_TYPE_ANYFORMAT, DCF_IMAGE_NAME );
#endif
//#NT#2012/11/14#Philex Lin - end
//DCF file-ext
#if (MOVIE_FORMAT == MOVIE_FORMAT_AVI)
DCF_SetParm(DCF_PRMID_SET_VALID_FILE_FMT, DCF_FILE_TYPE_JPG|DCF_FILE_TYPE_AVI);
#else
DCF_SetParm(DCF_PRMID_SET_VALID_FILE_FMT, DCF_FILE_TYPE_JPG|DCF_FILE_TYPE_AVI|DCF_FILE_TYPE_MOV|DCF_FILE_TYPE_MP4);
#endif
DCF_SetParm(DCF_PRMID_SET_DEP_FILE_FMT, DCF_FILE_TYPE_JPG|DCF_FILE_TYPE_WAV|DCF_FILE_TYPE_MPO);
//TODO: [DCF] How to add an new format & its ext?
//2.設定CB值,
//3.註冊SxJob服務 ---------> System Job
//4.註冊SxTimer服務 ---------> Detect Job
#if (SDINSERT_FUNCTION == ENABLE)
SX_TIMER_DET_STRG_ID = SxTimer_AddItem(&Timer_Card_DetInsert);
#endif
SX_TIMER_DET_SYSTEM_BUSY_ID = SxTimer_AddItem(&Timer_System_DetBusy);
//5.註冊SxCmd服務 ---------> Cmd Function
//System_AddSxCmd(Storage_OnCommand); //GxStorage
//start scan
SxTimer_SetFuncActive(SX_TIMER_DET_STRG_ID, TRUE);
SxTimer_SetFuncActive(SX_TIMER_DET_SYSTEM_BUSY_ID, TRUE);
/*
#if (SDINSERT_FUNCTION == ENABLE)
{
//提早detect storage可以得到兩個好處:
//1.知道storage的type是哪一種
//2.立刻"啟動File System"
// 如果沒這樣, 就要等到SXOPEN之後, SX_TIMER_DET_STRG_ID開始跑才會"啟動File System",
// 與其他task的競爭結果, 容易造成"啟動File System"的timing不固定
GxDet_Storage();
GxDet_Storage();
Delay_DelayMs(30);
}
#endif
*/
}
}
void MsdcNvtCb_Open(MSDCNVTCB_OPEN* pOpen)
{
UINT8* pMemPool = NULL;
UINT32 MemSize = 0;
MSDCNVT_INIT MsdcNvtInit = {0};
USB_MSDC_INFO MSDCInfo = {0};
MSDCNVT_LUN* pLun = MsdcNvt_GetNullLun();
//Due to PC Limit Max Packet Size is 64k Bytes, so MsdcVendor work need to cache buffer with 0x24000 bytes
#if(CFG_CACHE_USE==CACHE_USE_LOCAL)
pMemPool = m_MsdcNvtCache;
MemSize = sizeof(m_MsdcNvtCache);
#elif(CFG_CACHE_USE==CACHE_USE_MEM_POOL)
pMemPool = (UINT8*)OS_GetMempoolAddr(POOL_ID_CACHE);
pMemPool += POOL_CACHE_OFFSET_MSDC_DBGSYS;
MemSize = POOL_SIZE_CACHE_MSDC_DBGSYS;
#else
#error "You have to select a cache source!"
#endif
MsdcNvtInit.uiApiVer = MSDCNVT_API_VERSION;
MsdcNvtInit.pMemCache = (UINT8*)pMemPool;
MsdcNvtInit.uiSizeCache = MemSize;
MsdcNvtInit.bHookDbgMsg = TRUE;
MsdcNvtInit.uiUartIdx = 0;
if(!MsdcNvt_Init(&MsdcNvtInit))
{
debug_err(("MsdcNvt_Init() Failed!\r\n"));
return;
}
//Register Bi - Direction Functions
#if(CFG_MSDC_NVT_CB_PHOTO==ENABLE)
MsdcNvtRegBi_Photo();
#endif
#if(CFG_MSDC_NVT_CB_DISP==ENABLE)
MsdcNvtRegBi_Disp();
#endif
#if(CFG_MSDC_NVT_CB_FILE==ENABLE)
{
MSDCNVTCBFILE_INIT Init={0};
Init.uiWorkingAddr = OS_GetMempoolAddr(POOL_ID_APP);
Init.uiWorkingSize = POOL_SIZE_APP;
MsdcNvtCbFile_Init(&Init);
MsdcNvtRegBi_File();
}
#endif
#if(CFG_MSDC_NVT_CB_ADJ==ENABLE)
MsdcNvtRegBi_Adj();
#endif
#if(CFG_MSDC_NVT_CB_UPDFW==ENABLE)
MsdcNvtRegBi_UpdFw();
#endif
//Register Single Direction Functions
#if(CFG_SI_MODULE==SI_MODULE_CUSTOM_SI)
MsdcNvtRegSi_CustomSi();
#elif (CFG_SI_MODULE==SI_MODULE_IQSIM)
MsdcNvtRegSi_IQSim();
#elif (CFG_SI_MODULE==SI_MODULE_AE)
AEAlg2_MsdcCB();
#endif
MSDCInfo.uiMsdcBufAddr = (UINT32)pMemPool;
MSDCInfo.uiMsdcBufSize = (UINT32)MemSize;
pOpen->fpUSBMakerInit(&MSDCInfo);
//The callback functions for the MSDC Vendor command.
//If project doesn't need the MSDC Vendor command, set this callback function as NULL.
MSDCInfo.msdc_check_cb = MsdcNvt_Verify_Cb;
MSDCInfo.msdc_vendor_cb = MsdcNvt_Vendor_Cb;
//Assign a Null Lun
MSDCInfo.pStrgHandle[0] = pLun->hStrg;
MSDCInfo.msdc_type[0] = pLun->Type;
MSDCInfo.msdc_storage_detCB[0] = pLun->fpStrgDetCb;
MSDCInfo.msdc_strgLock_detCB[0] = pLun->fpStrgLockCb;
MSDCInfo.LUNs = pLun->uiLUNs;
// Open MSDC task
if (Msdc_Open(&MSDCInfo) != E_OK)
{
debug_err(("Error open USB MSDC task\r\n"));
}
}
void System_OnVideoInit(void)
{
DX_HANDLE cDispDev = 0;
PDISP_OBJ pDispObj=disp_getDisplayObject(DISP_1);
DISPDEV_PARAM DispDev;
//PHASE-1 : Init & Open Drv or DrvExt
{
GxVideo_RegCB(Video_CB); //Register CB function of GxVideo
gDevLCDObj = Dx_GetObject(DX_CLASS_DISPLAY_EXT|DX_TYPE_LCD);
DBG_MSG("LCD = %08x\r\n", gDevLCDObj);
gDevTVObj = Dx_GetObject(DX_CLASS_DISPLAY_EXT|DX_TYPE_TVOUT);
DBG_MSG("TV = %08x\r\n", gDevTVObj);
gDevHDMIObj = Dx_GetObject(DX_CLASS_DISPLAY_EXT|DX_TYPE_HDMIOUT);
DBG_MSG("HDMI = %08x\r\n", gDevHDMIObj);
GxVideo_InitDevice(DOUT1);
GxVideo_InitDevice(DOUT2);
cDispDev = gDevLCDObj;
if(cDispDev)
{
//Dx_Init(cDispDev, 0, Display_CB, DISPLAY_VER);
Dx_Init(cDispDev, 0, 0, DISPLAY_VER);
}
cDispDev = gDevTVObj;
if(cDispDev)
{
//Dx_Init(cDispDev, 0, Display_CB, DISPLAY_VER);
Dx_Init(cDispDev, 0, 0, DISPLAY_VER);
}
cDispDev = gDevHDMIObj;
if(cDispDev)
{
//Dx_Init(cDispDev, 0, Display_CB, DISPLAY_VER);
Dx_Init(cDispDev, 0, 0, DISPLAY_VER);
}
//5.註冊SxCmd服務 ---------> Cmd Function
//SxCmd_AddTabel(Cmd_lcd);
//SxCmd_AddTabel(Cmd_tv);
//SxCmd_AddTabel(Cmd_hdmi);
//GxVideo_InstallCmd();
}
//PHASE-2 : Init & Open Lib or LibExt
{
//Config SxJob,SxTimer,SxCmd
//3.註冊SxJob服務 ---------> System Job
//SX_JOB_DISPLAY = System_AddSxJob(Display_Change_Job);
//SX_JOB_DISPMODE = System_AddSxJob(Display_ChangeMode_Job);
//4.註冊SxTimer服務 ---------> Detect Job
#if (TVINSERT_FUNCTION == ENABLE)
SX_TIMER_DET_TV_ID = SxTimer_AddItem(&Timer_Display_DetTV);
#endif
#if (DET_LCD_REG_FUNCTION == ENABLE)
SX_TIMER_DET_LCDREG_ID = SxTimer_AddItem(&Timer_Display_DetStatus);
#endif
#if (DET_LCDDIR_FUNCTION == ENABLE)
SX_TIMER_DET_LCDDIR_ID = SxTimer_AddItem(&Timer_Display_DetLCDDir);
#endif
//5.註冊SxCmd服務 ---------> Cmd Function
//config video Output
cDispDev = gDevLCDObj;
GxVideo_OpenDevice(DOUT1, (UINT32)cDispDev, DISP_LASTMODE);//open LCD first
GxVideo_DumpInfo();
#if (DET_LCDDIR_FUNCTION == ENABLE)
//config video Direct
Display_DetLCDDir();
#endif
DispDev.SEL.SET_ROTATE.Rot = DISPDEV_LCD_ROTATE_180;
pDispObj->devCtrl(DISPDEV_SET_ROTATE, &DispDev);
Ux_PostEvent(NVTEVT_VIDEO_ATTACH, 1, 1); // attach
#if (TVINSERT_FUNCTION == ENABLE)
SxTimer_SetFuncActive(SX_TIMER_DET_TV_ID, TRUE);
#endif
#if (DET_LCDDIR_FUNCTION == ENABLE)
SxTimer_SetFuncActive(SX_TIMER_DET_LCDDIR_ID, TRUE);
#endif
//DispSrv_InstallCmd();
AppView_Init();
{
#if(VDO_USE_ROTATE_BUFFER == ENABLE)
UINT32 uiPoolAddr = OS_GetMempoolAddr(POOL_ID_DISP_VDO1);
UINT32 uiPoolSize = OS_GetMempoolSize(POOL_ID_DISP_VDO1)+OS_GetMempoolSize(POOL_ID_DISP_VDO1TEMP)+OS_GetMempoolSize(POOL_ID_DISP_VDO1TEMP2);
AppView_ConfigWorkingBuffer(uiPoolAddr, uiPoolSize);
if((DX_HANDLE)GxVideo_GetDevice(DOUT1) == gDevLCDObj)
{
AppView_ConfigAttr(0, 0, DISPSRV_ROTATE_90); //enable rotate 90
}
#else
UINT32 uiPoolAddr = OS_GetMempoolAddr(POOL_ID_DISP_VDO1);
UINT32 uiPoolSize = OS_GetMempoolSize(POOL_ID_DISP_VDO1)+OS_GetMempoolSize(POOL_ID_DISP_VDO1TEMP);
AppView_ConfigWorkingBuffer(uiPoolAddr, uiPoolSize);
#endif
}
{
#if(OSD_USE_ROTATE_BUFFER == ENABLE)
if((DX_HANDLE)GxVideo_GetDevice(DOUT1) == gDevLCDObj)
{
View_Window_ConfigAttr(0, 1); //enable rotate 90
}
#endif
}
}
////////////////////////////////////////////////////////////////
{
ISIZE DeviceSize;
//Init Display
DeviceSize = GxVideo_GetDeviceSize(DOUT1); //Get LCD size
GxDisplay_Init(DOUT1, DeviceSize.w, DeviceSize.h);
DeviceSize = GxVideo_GetDeviceSize(DOUT2); //Get LCD size
GxDisplay_Init(DOUT2, DeviceSize.w, DeviceSize.h);
}
}
void FlowMode_OnUsbUnplug(void)
{
UINT32 filesize ;
char * uiBuffer ;
//ER status ;
UIDebug_usb(("^BFlowMode_OnUsbUnplug begin\r\n"));
//#NT#2010/03/16#Lincy Lin -begin
//#NT# For Calibration
#if 1
if(IS_USB_VENDOR())
{
FST_FILE filehdl = NULL;
INT32 ret = FST_STA_ERROR;
#if _DEMO_TODO
GxFile_GetStorageObj(PRIMARY_STGTYPE_CARD)->Close();
//GxFile_ChangeStorage(PRIMARY_STGTYPE_CARD);
GxFile_ChangeStorage(PRIMARY_STGTYPE_CARD);
#endif
uiBuffer = (char *)OS_GetMempoolAddr(POOL_ID_GFX_IMAGE);
debug_err(("\n[IMG] Pool size read %d \r\n", OS_GetMempoolSize(POOL_ID_GFX_IMAGE)));
// Update English Language begin
filesize = 0x4;
// Disable IDE video1/video2 output
//UI_Show(UI_SHOW_INFO, TRUE); //OSD2
//UI_Show(UI_SHOW_WINDOW, TRUE); //OSD1
//UI_Show(UI_SHOW_BACKGND, TRUE); //VDO2
//UI_Show(UI_SHOW_PREVIEW, TRUE); //VDO1
GxVideo_SetDeviceCtrl(DOUT1, DISPLAY_DEVCTRL_BRIGHTLVL, 5);
filehdl = FileSys_OpenFile("A:\\FO.txt",FST_OPEN_READ);
ret = FileSys_ReadFile(filehdl,(UINT8*)uiBuffer,&filesize, 0, 0);
FileSys_CloseFile(filehdl);
if(ret==FST_STA_OK)
{
Ux_SendEvent(0, NVTEVT_SYSTEM_MODE, 1, PRIMARY_MODE_PHOTO);
#if (_CALIBRATION_MODE_ == ENABLE)
//g_IsautoMTF = TRUE;
g_bCalbirationOpened = FALSE;
#endif
SwTimer_DelayMs(1500);
Ux_PostEvent(NVTEVT_STORAGE_INIT, 0, 0);
//FocusOffsetAdjust();
//debug_err(("^R status = 0x%x 0x%x \r\n" , status , *(UINT32 *)uiBuffer));
}
else
{
UIDebug_usb(("^B USB PlugOff,PwrOff 1\r\n"));
System_PowerOff(SYS_POWEROFF_NORMAL);
}
}
else
{
UIDebug_usb(("^B USB PlugOff,PwrOff 2\r\n"));
System_PowerOff(SYS_POWEROFF_NORMAL);
}
#else
#if (MODEKEY_FUNCTION == ENABLE)
Ux_SendEvent(0, NVTEVT_SYSTEM_MODE, 1, System_GetState(SYS_STATE_PREVMODE));
//#NT#2009/12/24#Lily Kao - begin
debug_msg("USB_CB:PlugOff,PrevMode=%d\r\n",System_GetState(SYS_STATE_PREVMODE));
//System_PowerOff();
//#NT#2010/01/14#Lincy Lin -begin
//#NT#2010/02/03#Brad Chen -begin
//#NT# add USB unplug then change to photo mode
{
UINT32 uiDscMode;
//#NT#2010/01/20#JeahYen -begin
uiDscMode = Input_Key2Mode(GxKey_GetData(GXKEY_STS_KEY1));
//#NT#2010/01/20#JeahYen -end
UI_SetData(FL_ModeIndex,uiDscMode);
UI_Switch_DscMode(uiDscMode,DSCMODE_SWITCH_FORCE,DSCMODE_SWITCHDIR_DONT_CARE);
}
//#NT#2010/02/03#Brad Chen -end
#else
{
UINT32 uiDscMode;
//#NT#2010/01/20#JeahYen -begin
uiDscMode = Input_Key2Mode(GxKey_GetData(GXKEY_STS_KEY1));
//#NT#2010/01/20#JeahYen -end
UI_SetData(FL_ModeIndex,uiDscMode);
UI_Switch_DscMode(uiDscMode,DSCMODE_SWITCH_FORCE,DSCMODE_SWITCHDIR_DONT_CARE);
}
#endif
#endif
//#NT#2010/03/16#Lincy Lin -end
UIDebug_usb(("^BFlowMode_OnUsbUnplug end\r\n"));
}
INT32 SetupExe_OnFileSysInit(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
{
#if _DEMO_TODO
//#NT#2010/11/27Steven feng-begin
UINT32 uiPoolAddr;
UINT32 uiBufSize = 0 ,status;
//#NT#2011/02/16#Steven feng -begin
#if SLIDESHOW_MUSIC_OPTION
UINT32 i;
#endif
//#NT#2011/02/16#Steven feng -end
//#NT#2010/11/27Steven feng-end
//debug_msg("[SetupObj] FileSysInit\r\n");
//#NT#2010/09/28#Lincy Lin -begin
//#NT#Add check if write Photo frame Pstore when update FW
if(FlowMode_IsPowerOnUpdateFW())
{
FST_FILE filehdl = NULL;
INT32 ret = FST_STA_ERROR;
//#NT#2011/01/07#Janice Huang -begin
//#NT#add warn wind,for Production line ,unplug bettery
Ux_OpenWindow(&DialogWarnCtrl, 2, WRN_FW_UPDATING, WARN_ALWAYS);
//#NT#2010/11/04#Lincy Lin -begin
// delay for AE stable
SwTimer_DelayMs(100);
//#NT#2010/11/04#Lincy Lin -end
UIRes_ChkWritePHFE();
//#NT#2011/02/14Steven feng-begin
#if SLIDESHOW_MUSIC_OPTION
UIRes_ChkWriteSSWAV();
#endif
//#NT#2011/02/14Steven feng-end
//#NT#2010/11/27Steven feng-begin
uiPoolAddr = OS_GetMempoolAddr(POOL_ID_APP);
filehdl = FileSys_OpenFile(CAL_CLEAR_FOLDER,FST_OPEN_READ);
ret = FileSys_ReadFile(filehdl,(UINT8*)uiPoolAddr,&uiBufSize, 0, 0);
FileSys_CloseFile(filehdl);
if(ret == FST_STA_OK)
{
debug_err(("^G Clear Cal Data & status\r\n"));
Cal_ItemClearStatus();
}
else
debug_err(("^G Reserve Cal Data & status\r\n"));
//#NT#2010/11/27Steven feng-end
//#NT#2011/01/28#Brad Chen -begin
//#NT# add burn ISO
if(_MSDC_MODE_==_MSDC_ALL_NAND2_|| _MSDC_MODE_ == _MSDC_SINGLE_NAND2_)
{
ER result = E_OK;
char *fileName = "A:\\GEISO.ISO";
FST_FILE *pFile;
UINT32 value = 0X30444301;
result = copy_iso();
pFile = FileSys_OpenFile((char *)fileName,FST_OPEN_READ);
if (pFile != NULL)
{
FormatNand();
}
else
{
debug_err(("open file error\r\n"));
}
result = check_iso(0x8000,value,4);
if (result == E_OK)
{
debug_msg(" set AutoRunISOWriteSts OK\r\n");
UI_SetData(FL_AutoRunISOWriteSts,TRUE);
}
else
debug_msg(" set AutoRunISOWriteSts Fail\r\n");
}
//#NT#2011/01/28#Brad Chen -end
Ux_CloseWindow(&DialogWarnCtrl,0);
UIRes_InitReadPHFE();
//#NT#2011/02/16#Steven feng -begin
#if SLIDESHOW_MUSIC_OPTION
for(i = 0 ; i<4 ; i++)
UIRes_InitReadSSWAV(i);
#endif
//#NT#2011/02/16#Steven feng -end
Ux_OpenWindow(&DialogWarnCtrl, 2, WRN_FW_CHECK, WARN_ALWAYS);
//post event again,because open wind ,miss the event
Ux_PostEvent(NVTEVT_STORAGE_INIT, 0, 0);
//#NT#2011/01/07#Janice Huang -end
//#NT#2011/03/01#Lincy Lin -begin
//#NT#Fix remove battery the info not save bug
Save_MenuInfo();
//#NT#2011/03/01#Lincy Lin -end
}
else
{
//#NT#2010/09/28#Lincy Lin -end
//#NT#2010/11/01#Lincy Lin -begin
UIRes_InitReadPHFE();
//#NT#2010/11/01#Lincy Lin -end
}
#if _PWRON_WAIT_FILESYSTEM_
if (UIStorageCheck(STORAGE_CHECK_DCIM_READONLY, NULL) == TRUE)
{
UI_SetData(FL_IsDCIMReadOnly,TRUE);
}
#endif
//#NT#2011/03/24#Lincy Lin -begin
//#NT#
BackupPhotoParamsInfo();
//#NT#2011/03/24#Lincy Lin -end
#endif
return NVTEVT_CONSUME;
}
INT32 UIFlowWndPlay_OnKeyEnter(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
{
//#NT#2012/08/31#Calvin Chang#Porting Media Flow -begin
//UINT32 uiCurindex;
UINT32 uiPoolAddr;
char pFilePath[FULL_FILE_PATH_LEN];
UINT32 fileType = DCF_FILE_TYPE_JPG;
UINT32 uiPBFileFmt;
switch(g_PlbData.State)
{
case PLB_ST_PLAY_MOV:
case PLB_ST_FWD_MOV:
case PLB_ST_BWD_MOV:
Ux_SendEvent(&UIMoviePlayObjCtrl, NVTEVT_PAUSE_PLAY_MOVIE, 0);
FlowPB_IconDrawMovPlay(TRUE);
g_PlbData.State = PLB_ST_PAUSE_MOV;
//#NT#2012/10/23#Philex Lin - begin
// enable auto power off/USB detect timer
// enable sound key tone flag
KeyScan_EnableMisc(TRUE);
//#NT#2012/10/23#Philex Lin - end
break;
case PLB_ST_PAUSE_MOV:
//#NT#2012/10/23#Philex Lin - begin
// disable auto power off/USB detect timer
// disable key tone flag
KeyScan_EnableMisc(FALSE);
//#NT#2012/10/23#Philex Lin - end
// Start to Play
Ux_SendEvent(&UIMoviePlayObjCtrl,
NVTEVT_PLAY_PLAY_MOVIE,
2,
g_uiUIFlowWndPlayCurrenSpeed,
g_uiUIFlowWndPlayCurrenDirection);
FlowPB_IconDrawMovPlay(TRUE);
g_PlbData.State = PLB_ST_PLAY_MOV;
break;
default:
case PLB_ST_FULL:
uiPBFileFmt = AppPlay_GetData(PLAY_FILEFMT);
if (uiPBFileFmt & PBFMT_AVI ||
uiPBFileFmt & PBFMT_MOVMJPG ||
uiPBFileFmt & PBFMT_MP4)
{
// Open Video File
if (gphUIFlowMovPlay_Filehdl)
{
FileSys_CloseFile(gphUIFlowMovPlay_Filehdl);
gphUIFlowMovPlay_Filehdl = NULL;
}
if (uiPBFileFmt & PBFMT_AVI)
fileType = DCF_FILE_TYPE_AVI;
else if (uiPBFileFmt & PBFMT_MOVMJPG)
fileType = DCF_FILE_TYPE_MOV;
else if (uiPBFileFmt & PBFMT_MP4)
fileType = DCF_FILE_TYPE_MOV;
else
{
debug_msg("Wrong video file format!! \r\n");
break;
}
// Get Current index
PB_GetParam(PBPRMID_CURR_FILEPATH, (UINT32 *)pFilePath);
#if 0
uiCurindex = DCF_GetCurIndex();
DCF_GetObjPath(uiCurindex,fileType,pFilePath);
#endif
// Open Test Media File
gphUIFlowMovPlay_Filehdl = FileSys_OpenFile(pFilePath, FST_OPEN_READ);
if (!gphUIFlowMovPlay_Filehdl)
{
debug_msg("UIFlowWndPlay_OnKeyEnter: Can't open Video file!\r\n");
break;
}
//#NT#2012/10/23#Philex Lin - begin
// disable auto power off/USB detect timer
// disable key tone flag
KeyScan_EnableMisc(FALSE);
//#NT#2012/10/23#Philex Lin - end
// Buffer Allocation
get_blf((VP*)&(uiPoolAddr), POOL_ID_APP);
rel_blf(POOL_ID_APP, (VP)uiPoolAddr);
g_UIPlayMediaObj.hActMediafilehdl = gphUIFlowMovPlay_Filehdl;
g_UIPlayMediaObj.CallBackFunc = Play_MovieCB;
// g_UIPlayMediaObj.uiMemAddr = uiPoolAddr;
g_UIPlayMediaObj.uiMemAddr = (UINT32)OS_GetMempoolAddr(POOL_ID_APP);
g_UIPlayMediaObj.uiMemSize = POOL_SIZE_APP;
//g_UIPlayMediaObj.iAudioType = AUDIO_OUTPUT_HP;
g_UIPlayMediaObj.bDisableAudio = FALSE;
UIFlowMoviePlay_SetSpeed(g_PlbData.VideoPBSpeed);
g_uiUIFlowWndPlayCurrenDirection = MEDIAPLAY_DIR_FORWARD;
//flush event first
Ux_FlushEventByRange(NVTEVT_KEY_EVT_START,NVTEVT_KEY_EVT_END);
//stop scan
//SxTimer_SetFuncActive(SX_TIMER_DET_STRG_ID, FALSE);
SxTimer_SetFuncActive(SX_TIMER_DET_SYSTEM_BUSY_ID, FALSE);
Ux_SendEvent(&UIMoviePlayObjCtrl, NVTEVT_INIT_PLAY_MOVIE, 1, &g_UIPlayMediaObj);
// Start to Play
Ux_SendEvent(&UIMoviePlayObjCtrl,
NVTEVT_PLAY_PLAY_MOVIE,
2,
g_uiUIFlowWndPlayCurrenSpeed,
g_uiUIFlowWndPlayCurrenDirection);
if (KeyScan_GetPlugDev()!=PLUG_HDMI)
{
//FlowPB_IconDrawMovPlayVolumn(g_uiUIFlowWndPlayCurrentVolume);
}
FlowPB_IconDrawMovPlay(TRUE);
g_PlbData.State = PLB_ST_PLAY_MOV;
}
break;
}
//#NT#2012/08/31#Calvin Chang -end
return NVTEVT_CONSUME;
}
