3893 lines
128 KiB
C
3893 lines
128 KiB
C
////////////////////////////////////////////////////////////////////////////////
|
|
#include "PrjInc.h"
|
|
#include "ImageApp/ImageApp_MovieMulti.h"
|
|
#include "avfile/movieinterface_def.h"
|
|
#include "sys_mempool.h"
|
|
//#include "sys_fdt.h"
|
|
#include "UIApp/MovieStamp/MovieStamp.h"
|
|
#include "NamingRule/NameRule_Custom.h"
|
|
|
|
#if USE_FILEDB
|
|
#include "FileDB.h"
|
|
#elif USE_DCF
|
|
#include "DCF.h"
|
|
#else
|
|
#error "must enable either DCF or FILEBD"
|
|
#endif
|
|
|
|
#include "SysSensor.h"
|
|
#include "GxTime.h"
|
|
#include "vendor_isp.h"
|
|
#include "UIApp/Network/UIAppWiFiCmd.h"
|
|
#include "UIApp/AppDisp_PipView.h"
|
|
#include <vf_gfx.h>
|
|
#include "vendor_videocapture.h"
|
|
#if (GPS_FUNCTION == ENABLE)
|
|
#include <GPS.h>
|
|
#endif
|
|
#include "UIApp/MovieStamp/MovieStampAPI.h"
|
|
|
|
#include "UIApp/Network/EthCamAppSocket.h"
|
|
#include "UIApp/Network/EthCamAppNetwork.h"
|
|
#include "UIApp/Network/EthCamAppCmd.h"
|
|
#include "UIApp/EthCamCmdParser/EthCamCmdParser.h"
|
|
|
|
#if (USE_EXIF == ENABLE)
|
|
#include "UIApp/ExifVendor.h"
|
|
#endif
|
|
#include "vendor_videoout.h"
|
|
#include "IOCfg.h"
|
|
|
|
#define THIS_DBGLVL 2 // 0=FATAL, 1=ERR, 2=WRN, 3=UNIT, 4=FUNC, 5=IND, 6=MSG, 7=VALUE, 8=USER
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
#define __MODULE__ UiAppMovie
|
|
#define __DBGLVL__ ((THIS_DBGLVL>=PRJ_DBG_LVL)?THIS_DBGLVL:PRJ_DBG_LVL)
|
|
#define __DBGFLT__ "*" //*=All, [mark]=CustomClass
|
|
#include <kwrap/debug.h>
|
|
#if HUNTING_CAMERA_MCU == ENABLE
|
|
#include <sf_inc.h>
|
|
#endif
|
|
#define VDO_YUV_BUFSIZE(w, h, pxlfmt) ALIGN_CEIL_4(((w) * (h) * HD_VIDEO_PXLFMT_BPP(pxlfmt)) / 8)
|
|
|
|
#define FILE_SN_MAX 999999
|
|
//#define MOVIE_ROOT_PATH "A:\\MOVIE\\"
|
|
#define MOVIE_ROOT_PATH "A:\\Novatek\\"
|
|
//#define MOVIE_THUMB_WIDTH 640
|
|
|
|
static UINT32 g_FileSerialNum = 0;
|
|
static BOOL g_bAllowRawEnc = TRUE;
|
|
static UINT32 raw_enc_path = 0;
|
|
|
|
/**********************************************************************************
|
|
* independent thumbnail
|
|
*********************************************************************************/
|
|
|
|
static char thumb_current_path_main[256] = {'\0'};
|
|
static char thumb_current_path_clone[256] = {'\0'};
|
|
|
|
|
|
#if (defined(_NVT_ETHREARCAM_RX_) ||defined(_NVT_ETHREARCAM_TX_))
|
|
extern int SX_TIMER_ETHCAM_DATARECVDET_ID;
|
|
extern int SX_TIMER_ETHCAM_ETHERNETLINKDET_LINKDET_ID;
|
|
#endif
|
|
#if(defined(_NVT_ETHREARCAM_RX_))
|
|
extern UINT32 EthCamHB1[ETHCAM_PATH_ID_MAX], EthCamHB2;
|
|
UINT32 g_uiEthcamEncBufSec[]= {3, 3};
|
|
extern int SX_TIMER_ETHCAM_DATARECVDET_ID;
|
|
#if (ETH_REARCAM_CAPS_COUNT>=2)
|
|
extern int SX_TIMER_ETHCAM_ETHHUB_LINKDET_ID;
|
|
#define ETHCAM_DISP_MAX_QUEUE 0
|
|
#else
|
|
#define ETHCAM_DISP_MAX_QUEUE 0
|
|
#if(ETHCAM_DISP_MAX_QUEUE>0)
|
|
static SEND_FRM_BSQ g_EthCamDispQ={0};
|
|
static UINT8 g_EthCamDispPoolAddr[ETHCAM_DISP_MAX_QUEUE*sizeof(ISF_DATA)]={0};
|
|
static TIMER_ID g_EthCamDisp_TimerID = 0;
|
|
#endif
|
|
#endif
|
|
#define ETH_WIDTH 1280
|
|
#define ETH_HEIGHT 720
|
|
#define ETH_CODEC HD_CODEC_TYPE_H265
|
|
UINT8 EthCamH265DescDefaultAddr[88]= {0, 0, 0, 1, 64, 1, 12, 1, 255, 255, 33, 96, 0, 0, 3, 0, 0, 3, 0, 0, 3, 0, 0, 3, 0, 150, 172, 9, 0, 0, 0, 1, 66, 1, 1, 33, 96, 0, 0, 3, 0, 0, 3, 0, 0, 3, 0, 0, 3, 0, 150, 160, 2, 128, 128, 45, 31, 230, 173, 59, 201, 174, 85, 115, 112, 16, 16, 16, 64, 3, 110, 232, 0, 102, 255, 48, 2, 0, 0, 0, 1, 68, 1, 192, 114, 240, 59, 36, };
|
|
#else
|
|
#define ETHCAM_DISP_MAX_QUEUE 0
|
|
#endif
|
|
#if (defined(_NVT_ETHREARCAM_TX_))
|
|
extern UINT32 EthCamTxHB;
|
|
static NVTMPP_VB_POOL g_EthCamRecId1_GetBsMapTblPool= NVTMPP_VB_INVALID_POOL;
|
|
static UINT32 g_EthCamRecId1_GetBsMapTblPoolAddr=0;
|
|
SEND_FRM_BSQ g_RecId1SendFrmBsQ={0};
|
|
#endif
|
|
static UINT32 gMovie_InitCommonMemFinish=0;
|
|
|
|
#if (MOVIE_UVAC_FUNC == ENABLE)
|
|
#include "UVAC.h"
|
|
|
|
static UVAC_VID_RESO gUIUvacVidReso[1] = {
|
|
{1920, 1080, 1, 30, 0, 0}, //16:9
|
|
};
|
|
|
|
static UINT32 gUIUvacAudSampleRate[1] = {
|
|
32000
|
|
};
|
|
|
|
_ALIGNED(64) static UINT16 m_UVACSerialStrDesc3[] = {
|
|
0x0320, // 20: size of String Descriptor = 32 bytes
|
|
// 03: String Descriptor type
|
|
'9', '6', '5', '6', '5', // 96565-00000-001 (default)
|
|
'0', '0', '0', '0', '0',
|
|
'0', '0', '1', '0', '0'
|
|
};
|
|
|
|
_ALIGNED(64) const static UINT8 m_UVACManuStrDesc[] = {
|
|
USB_VENDER_DESC_STRING_LEN * 2 + 2, // size of String Descriptor = 6 bytes
|
|
0x03, // 03: String Descriptor type
|
|
USB_VENDER_DESC_STRING
|
|
};
|
|
|
|
_ALIGNED(64) const static UINT8 m_UVACProdStrDesc[] = {
|
|
USB_PRODUCT_DESC_STRING_LEN * 2 + 2, // size of String Descriptor = 6 bytes
|
|
0x03, // 03: String Descriptor type
|
|
USB_PRODUCT_DESC_STRING
|
|
};
|
|
|
|
static UVAC_VEND_DEV_DESC gUIMovUvacDevDesc = {0};
|
|
|
|
static void xUSBMakerInit_UVAC(UVAC_VEND_DEV_DESC *pUVACDevDesc)
|
|
{
|
|
pUVACDevDesc->pManuStringDesc = (UVAC_STRING_DESC *)m_UVACManuStrDesc;
|
|
pUVACDevDesc->pProdStringDesc = (UVAC_STRING_DESC *)m_UVACProdStrDesc;
|
|
pUVACDevDesc->pSerialStringDesc = (UVAC_STRING_DESC *)m_UVACSerialStrDesc3;
|
|
pUVACDevDesc->VID = USB_VID;
|
|
pUVACDevDesc->PID = USB_PID_PCCAM;
|
|
}
|
|
#endif //#if (MOVIE_UVAC_FUNC == ENABLE)
|
|
|
|
extern void GOIO_Turn_Onoff_IRCUT(UINT8 onoff);
|
|
extern void GPIO_IRLed_Turn_Onoff(BOOL onoff);
|
|
|
|
INT32 Set_Cur_Day_Night_Status_cmd(BOOL OnOff)
|
|
{
|
|
AET_STATUS_INFO ae_status_info = {0};
|
|
IQT_NIGHT_MODE night_mode = {0};
|
|
AWBT_MANUAL awb_manual = {0};
|
|
HD_RESULT hd_ret;
|
|
if ((hd_ret = vendor_isp_init()) != HD_OK) {
|
|
DBG_ERR("vendor_isp_init() fail(%d)\r\n", hd_ret);
|
|
}
|
|
ae_status_info.id = 0;
|
|
night_mode.id = 0;
|
|
awb_manual.id = 0;
|
|
vendor_isp_get_ae(AET_ITEM_STATUS, &ae_status_info);
|
|
DBG_ERR(">> aet status lv %d lv_base %d\r\n",ae_status_info.status_info.lv,ae_status_info.status_info.lv_base);
|
|
//DBG_ERR(">> aet status ev %d ev_base %d\r\n",ae_status_info.status_info.ev,ae_status_info.status_info.ev_base);
|
|
if (((ae_status_info.status_info.lv / 1000000) < 7)&&(OnOff))
|
|
{
|
|
|
|
awb_manual.manual.en = 1;
|
|
awb_manual.manual.r_gain= 256;
|
|
awb_manual.manual.g_gain= 256;
|
|
awb_manual.manual.b_gain= 256;
|
|
|
|
night_mode.mode = 1;
|
|
GOIO_Turn_Onoff_IRCUT(0);
|
|
//GPIO_IRLed_Turn_Onoff(1);
|
|
//sf_ir_led_set(((2 == SysGetFlag(NightMode)) ? 2 : 1),SysGetFlag(FlashLed), SysGetFlag(NightMode), 0);
|
|
}
|
|
else
|
|
{
|
|
night_mode.mode = 0;
|
|
awb_manual.manual.en = 0;
|
|
GOIO_Turn_Onoff_IRCUT(1);
|
|
//GPIO_IRLed_Turn_Onoff(0);
|
|
//sf_ir_led_set(0, 0, 0, 0);
|
|
}
|
|
vendor_isp_set_awb(AWBT_ITEM_MANUAL, &awb_manual);
|
|
|
|
vendor_isp_set_iq(IQT_ITEM_NIGHT_MODE, &night_mode);
|
|
if (OnOff){
|
|
vos_util_delay_ms(500);
|
|
}
|
|
if ((hd_ret = vendor_isp_uninit()) != HD_OK) {
|
|
DBG_ERR("vendor_isp_uninit() fail(%d)\r\n", hd_ret);
|
|
}
|
|
vos_util_delay_ms(20);
|
|
return 0;
|
|
}
|
|
INT32 Set_Cur_Day_Night_Status(BOOL OnOff, UINT8 isSnapVideo)
|
|
{
|
|
static AET_STATUS_INFO ae_status_info = {0};
|
|
AET_MANUAL ae_manual = {0};
|
|
IQT_NIGHT_MODE night_mode = {0};
|
|
AWBT_MANUAL awb_manual = {0};
|
|
HD_RESULT hd_ret;
|
|
|
|
#if HUNTING_CAMERA_MCU == ENABLE
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
#endif
|
|
|
|
if ((hd_ret = vendor_isp_init()) != HD_OK) {
|
|
DBG_ERR("vendor_isp_init() fail(%d)\r\n", hd_ret);
|
|
}
|
|
ae_status_info.id = 0;
|
|
night_mode.id = 0;
|
|
awb_manual.id = 0;
|
|
vendor_isp_get_ae(AET_ITEM_STATUS, &ae_status_info);
|
|
//DBG_ERR(">> aet status lv %d lv_base %d\r\n",ae_status_info.status_info.lv,ae_status_info.status_info.lv_base);
|
|
//DBG_ERR(">> aet status ev %d ev_base %d\r\n",ae_status_info.status_info.ev,ae_status_info.status_info.ev_base);
|
|
ae_manual.id = 0;
|
|
vendor_isp_get_ae(AET_ITEM_MANUAL, &ae_manual);
|
|
if (((ae_status_info.status_info.lv / 1000000) < 7)&&(OnOff))
|
|
{
|
|
|
|
awb_manual.manual.en = 1;
|
|
awb_manual.manual.r_gain= 256;
|
|
awb_manual.manual.g_gain= 256;
|
|
awb_manual.manual.b_gain= 256;
|
|
|
|
night_mode.mode = 1;
|
|
GOIO_Turn_Onoff_IRCUT(0);
|
|
//GPIO_IRLed_Turn_Onoff(1);
|
|
#if HUNTING_CAMERA_MCU == ENABLE
|
|
sf_set_ae_night_mode(1);
|
|
sf_ir_led_set(((2 == puiPara->NightMode) ? 2 : 1),puiPara->FlashLed, puiPara->NightMode,isSnapVideo);
|
|
if (OnOff){
|
|
vos_util_delay_ms(330);
|
|
}
|
|
ae_manual.manual.mode = 1;
|
|
if (puiPara->NightMode == 0) {
|
|
ae_manual.manual.expotime = 125000;//ae_status.status_info.expotime[0];
|
|
ae_manual.manual.iso_gain = ae_status_info.status_info.iso_gain[0]*ae_status_info.status_info.expotime[0]/125000;
|
|
}
|
|
else if (puiPara->NightMode == 1) {
|
|
ae_manual.manual.expotime = 66666;//ae_status.status_info.expotime[0];
|
|
ae_manual.manual.iso_gain = ae_status_info.status_info.iso_gain[0]*ae_status_info.status_info.expotime[0]/66666;
|
|
}
|
|
else {
|
|
ae_manual.manual.expotime = ae_status_info.status_info.expotime[0];
|
|
ae_manual.manual.iso_gain = ae_status_info.status_info.iso_gain[0];
|
|
}
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
night_mode.mode = 0;
|
|
awb_manual.manual.en = 0;
|
|
ae_manual.manual.mode = 0;
|
|
GOIO_Turn_Onoff_IRCUT(1);
|
|
//GPIO_IRLed_Turn_Onoff(0);
|
|
#if HUNTING_CAMERA_MCU == ENABLE
|
|
sf_set_ae_night_mode(0);
|
|
sf_ir_led_set(0, 0, 0, 0);
|
|
#endif
|
|
}
|
|
vendor_isp_set_awb(AWBT_ITEM_MANUAL, &awb_manual);
|
|
|
|
vendor_isp_set_iq(IQT_ITEM_NIGHT_MODE, &night_mode);
|
|
vendor_isp_set_ae(AET_ITEM_MANUAL, &ae_manual);
|
|
|
|
if ((hd_ret = vendor_isp_uninit()) != HD_OK) {
|
|
DBG_ERR("vendor_isp_uninit() fail(%d)\r\n", hd_ret);
|
|
}
|
|
//vos_util_delay_ms(20);
|
|
return 0;
|
|
}
|
|
|
|
|
|
#if (MOVIE_IME_CROP == ENABLE)
|
|
MOVIEMULTI_IME_CROP_INFO IMECropInfo[SENSOR_CAPS_COUNT];
|
|
void MovieExe_SetIMECrop(UINT32 rec_id)
|
|
{
|
|
UINT32 i;
|
|
ISIZE disp_size = GxVideo_GetDeviceSize(DOUT1);
|
|
USIZE disp_aspect_ratio = GxVideo_GetDeviceAspect(DOUT1);
|
|
UINT32 pip_style = UI_GetData(FL_DUAL_CAM);
|
|
|
|
i = rec_id;
|
|
gMovie_Rec_Info[i].disp_ratio.w = disp_aspect_ratio.w;
|
|
gMovie_Rec_Info[i].disp_ratio.h = disp_aspect_ratio.h;
|
|
|
|
if ((gMovie_Rec_Info[i].ratio.w * gMovie_Rec_Info[i].disp_ratio.h) > (gMovie_Rec_Info[i].disp_ratio.w * gMovie_Rec_Info[i].ratio.h)) {
|
|
IMECropInfo[i].IMESize.h = disp_size.h;
|
|
IMECropInfo[i].IMESize.w = ALIGN_CEIL_16((IMECropInfo[i].IMESize.h * gMovie_Rec_Info[i].ratio.w) / gMovie_Rec_Info[i].ratio.h);
|
|
IMECropInfo[i].IMEWin.w = disp_size.w;
|
|
IMECropInfo[i].IMEWin.h = disp_size.h;
|
|
IMECropInfo[i].IMEWin.x = ALIGN_CEIL_4((IMECropInfo[i].IMESize.w - IMECropInfo[i].IMEWin.w) / 2);
|
|
IMECropInfo[i].IMEWin.y = 0;
|
|
} else {
|
|
if (pip_style == DUALCAM_LR_FULL) {
|
|
gMovie_Rec_Info[i].disp_ratio.w = disp_aspect_ratio.w;
|
|
gMovie_Rec_Info[i].disp_ratio.h = disp_aspect_ratio.h * 2;
|
|
|
|
if ((gMovie_Rec_Info[i].ratio.w * gMovie_Rec_Info[i].disp_ratio.h) > (gMovie_Rec_Info[i].disp_ratio.w * gMovie_Rec_Info[i].ratio.h)) {
|
|
IMECropInfo[i].IMESize.h = disp_size.h;
|
|
IMECropInfo[i].IMESize.w = ALIGN_CEIL_16((IMECropInfo[i].IMESize.h * gMovie_Rec_Info[i].ratio.w) / gMovie_Rec_Info[i].ratio.h);
|
|
IMECropInfo[i].IMEWin.w = disp_size.w / 2;
|
|
IMECropInfo[i].IMEWin.h = disp_size.h;
|
|
IMECropInfo[i].IMEWin.x = ALIGN_CEIL_4((IMECropInfo[i].IMESize.w - IMECropInfo[i].IMEWin.w) / 2);
|
|
IMECropInfo[i].IMEWin.y = 0;
|
|
} else {
|
|
IMECropInfo[i].IMESize.w = ALIGN_CEIL_16(disp_size.w / 2);
|
|
IMECropInfo[i].IMESize.h = ALIGN_CEIL_4((IMECropInfo[i].IMESize.w * gMovie_Rec_Info[i].ratio.h) / gMovie_Rec_Info[i].ratio.w);
|
|
IMECropInfo[i].IMEWin.w = disp_size.w / 2;
|
|
IMECropInfo[i].IMEWin.h = disp_size.h;
|
|
IMECropInfo[i].IMEWin.x = 0;
|
|
IMECropInfo[i].IMEWin.y = ALIGN_CEIL_4((IMECropInfo[i].IMESize.h - IMECropInfo[i].IMEWin.h) / 2);
|
|
}
|
|
} else if ((pip_style == DUALCAM_FRONT) || (pip_style == DUALCAM_BEHIND)) {
|
|
IMECropInfo[i].IMESize.h = disp_size.h;
|
|
IMECropInfo[i].IMESize.w = ALIGN_CEIL_16((IMECropInfo[i].IMESize.h * gMovie_Rec_Info[i].ratio.w) / gMovie_Rec_Info[i].ratio.h);
|
|
IMECropInfo[i].IMEWin.w = IMECropInfo[i].IMESize.w;
|
|
IMECropInfo[i].IMEWin.h = IMECropInfo[i].IMESize.h;
|
|
IMECropInfo[i].IMEWin.x = 0;
|
|
IMECropInfo[i].IMEWin.y = 0;
|
|
} else {
|
|
IMECropInfo[i].IMESize.w = ALIGN_CEIL_16(disp_size.w);
|
|
IMECropInfo[i].IMESize.h = ALIGN_CEIL_4((IMECropInfo[i].IMESize.w * gMovie_Rec_Info[i].ratio.h) / gMovie_Rec_Info[i].ratio.w);
|
|
IMECropInfo[i].IMEWin.w = disp_size.w;
|
|
IMECropInfo[i].IMEWin.h = disp_size.h;
|
|
IMECropInfo[i].IMEWin.x = 0;
|
|
IMECropInfo[i].IMEWin.y = ALIGN_CEIL_4((IMECropInfo[i].IMESize.h - IMECropInfo[i].IMEWin.h) / 2);
|
|
}
|
|
}
|
|
|
|
//DBG_DUMP("IMECropInfo[%d]: size w %d, h %d, Win x %d, y %d, w %d, h %d\r\n",
|
|
// i, IMECropInfo[i].IMESize.w, IMECropInfo[i].IMESize.h, IMECropInfo[i].IMEWin.x, IMECropInfo[i].IMEWin.y, IMECropInfo[i].IMEWin.w, IMECropInfo[i].IMEWin.h);
|
|
|
|
if (((IMECropInfo[i].IMEWin.x + IMECropInfo[i].IMEWin.w) > IMECropInfo[i].IMESize.w) || ((IMECropInfo[i].IMEWin.y + IMECropInfo[i].IMEWin.h) > IMECropInfo[i].IMESize.h)) {
|
|
DBG_ERR("Window out of range! %d+%d>%d or %d+%d>%d\r\n", IMECropInfo[i].IMEWin.x, IMECropInfo[i].IMEWin.w, IMECropInfo[i].IMESize.w, IMECropInfo[i].IMEWin.y, IMECropInfo[i].IMEWin.h, IMECropInfo[i].IMESize.h);
|
|
}
|
|
|
|
ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1 + i, MOVIEMULTI_PARAM_DISP_IME_CROP, (UINT32)&IMECropInfo[i]);
|
|
}
|
|
void MovieExe_SetDispWin(void)
|
|
{
|
|
ISIZE disp_size = GxVideo_GetDeviceSize(DOUT1);
|
|
URECT disp_win;
|
|
|
|
switch (UI_GetData(FL_DUAL_CAM)) {
|
|
case DUALCAM_FRONT:
|
|
// only consider panel width > height temporary
|
|
disp_win.x = ALIGN_CEIL_4((disp_size.w - IMECropInfo[0].IMEWin.w) / 2);
|
|
disp_win.y = 0;
|
|
disp_win.w = IMECropInfo[0].IMEWin.w;
|
|
disp_win.h = IMECropInfo[0].IMEWin.h;
|
|
break;
|
|
|
|
#if (SENSOR_CAPS_COUNT >= 2)
|
|
case DUALCAM_BEHIND:
|
|
// only consider panel width > height temporary
|
|
disp_win.x = ALIGN_CEIL_4((disp_size.w - IMECropInfo[1].IMEWin.w) / 2);
|
|
disp_win.y = 0;
|
|
disp_win.w = IMECropInfo[1].IMEWin.w;
|
|
disp_win.h = IMECropInfo[1].IMEWin.h;
|
|
break;
|
|
#endif
|
|
|
|
default:
|
|
disp_win.x = 0;
|
|
disp_win.y = 0;
|
|
disp_win.w = disp_size.w;
|
|
disp_win.h = disp_size.h;
|
|
break;
|
|
}
|
|
|
|
ImageApp_MovieMulti_SetParam(0, MOVIEMULTI_PARAM_DISP_WINDOW, (UINT32)&disp_win);
|
|
}
|
|
#endif
|
|
|
|
static UINT32 g_PipViewStyle = 0xffff;
|
|
UINT32 MovieExe_GetPipStyle(void)
|
|
{
|
|
return g_PipViewStyle;
|
|
}
|
|
static void MovieExe_DispCB(HD_VIDEO_FRAME *pEthcamSrc)
|
|
{
|
|
HD_VIDEO_FRAME src_img[SENSOR_CAPS_COUNT+ETH_REARCAM_CAPS_COUNT] = {0};
|
|
HD_VIDEO_FRAME dst_img;
|
|
BOOL bPullData[SENSOR_CAPS_COUNT+ETH_REARCAM_CAPS_COUNT] = {0};
|
|
HD_RESULT ret;
|
|
HD_COMMON_MEM_VB_BLK blk;
|
|
UINT32 i, mask, sensor_mask, sensor_count;
|
|
UINT32 blk_size, pa;
|
|
UINT32 addr[HD_VIDEO_MAX_PLANE] = {0};
|
|
UINT32 loff[HD_VIDEO_MAX_PLANE] = {0};
|
|
APPDISP_VIEW_DRAW pip_draw = {0};
|
|
#if (MOVIE_IME_CROP == ENABLE) || ((SENSOR_CAPS_COUNT & SENSOR_ON_MASK)==0 && ETH_REARCAM_CAPS_COUNT) || (ETH_REARCAM_CAPS_COUNT==1)
|
|
ISIZE DevSize = GxVideo_GetDeviceSize(DOUT1);
|
|
#endif
|
|
ISIZE disp_buf={0};
|
|
UINT32 pip_style = UI_GetData(FL_DUAL_CAM);
|
|
#if (DRAM_SIZE_64MB_DISP_OFF==ENABLE)
|
|
if (ImageApp_MovieMulti_IsStreamRunning(_CFG_STRM_ID_1) == FALSE) {
|
|
vos_util_delay_ms(200);
|
|
}
|
|
goto video_frame_release;
|
|
#endif
|
|
// If system in sleep mode, pull out the buffer and release directly due to we use vprc blocking mode to pause the task
|
|
// Otherwise the task will trap in busy loop
|
|
if(0 != System_GetState(SYS_STATE_SLEEPLEVEL)){
|
|
goto video_frame_release;
|
|
}
|
|
#if (MOVIE_IME_CROP == ENABLE)
|
|
static UINT32 skip_count = 0;
|
|
//static VOS_TICK t1, t2;
|
|
if (g_PipViewStyle != UI_GetData(FL_DUAL_CAM)) {
|
|
if (skip_count == 0) {
|
|
UINT32 i;
|
|
//vos_perf_mark(&t1);
|
|
for (i = 0; i < SENSOR_CAPS_COUNT; i++) {
|
|
MovieExe_SetIMECrop(i);
|
|
}
|
|
MovieExe_SetDispWin();
|
|
}
|
|
skip_count++;
|
|
if (skip_count > 3) {
|
|
skip_count = 0;
|
|
g_PipViewStyle = UI_GetData(FL_DUAL_CAM);
|
|
//vos_perf_mark(&t2);
|
|
//DBG_DUMP("skip time %d us\r\n", t2 - t1);
|
|
//MovieExe_SetDispWin();
|
|
} else {
|
|
vos_util_delay_ms(33); // delay 33ms
|
|
return;
|
|
}
|
|
}
|
|
#else
|
|
g_PipViewStyle = UI_GetData(FL_DUAL_CAM);
|
|
#endif
|
|
|
|
mask = 1;
|
|
sensor_count = 0;
|
|
sensor_mask = System_GetEnableSensor();
|
|
if ((pip_style == DUALCAM_FRONT) || (pip_style == DUALCAM_LR_FRONT_FULL)) {
|
|
if (sensor_mask & SENSOR_1) {
|
|
if ((ret = ImageApp_MovieMulti_DispPullOut(_CFG_REC_ID_1, &src_img[0], 150)) == HD_OK) {
|
|
pip_draw.p_src_img[0] = &src_img[0];
|
|
bPullData[0] = TRUE;
|
|
sensor_count++;
|
|
}
|
|
}
|
|
} else if ((pip_style == DUALCAM_BEHIND) || (pip_style == DUALCAM_LR_BEHIND_FULL)) {
|
|
if (sensor_mask & SENSOR_2) {
|
|
if ((ret = ImageApp_MovieMulti_DispPullOut(_CFG_REC_ID_2, &src_img[1], 150)) == HD_OK) {
|
|
pip_draw.p_src_img[1] = &src_img[1];
|
|
bPullData[1] = TRUE;
|
|
sensor_count++;
|
|
}
|
|
}
|
|
} else {
|
|
for (i = 0; i < (SENSOR_CAPS_COUNT & SENSOR_ON_MASK); i++) {
|
|
if (sensor_mask & mask) {
|
|
if ((ret = ImageApp_MovieMulti_DispPullOut(_CFG_REC_ID_1 + i, &src_img[i], 150)) == HD_OK) {
|
|
pip_draw.p_src_img[i] = &src_img[i];
|
|
bPullData[i] = TRUE;
|
|
sensor_count++;
|
|
}
|
|
}
|
|
mask <<= 1;
|
|
}
|
|
//DBG_DUMP("%d, src_img[0].dim.h=%d, %d,%d,%d\r\n",sensor_mask, src_img[0].dim.w,src_img[0].dim.h,src_img[1].dim.w,src_img[1].dim.h);
|
|
//if(SysVideo_GetDirbyID(DOUT1)!=HD_VIDEO_DIR_ROTATE_0){
|
|
// src_img[0].dim.h= ALIGN_CEIL_8(src_img[0].dim.h);
|
|
//}
|
|
}
|
|
#if defined(_NVT_ETHREARCAM_RX_)
|
|
UINT32 j;
|
|
for (i = _CFG_ETHCAM_ID_1; i < (_CFG_ETHCAM_ID_1+ETH_REARCAM_CAPS_COUNT); i++) {
|
|
#if(((SENSOR_CAPS_COUNT & SENSOR_ON_MASK) + ETH_REARCAM_CAPS_COUNT)==1)
|
|
j=i-_CFG_ETHCAM_ID_1+(SENSOR_CAPS_COUNT);
|
|
#else
|
|
j=i-_CFG_ETHCAM_ID_1+(SENSOR_CAPS_COUNT & SENSOR_ON_MASK);
|
|
#endif
|
|
|
|
if(ImageApp_MovieMulti_EthCamLinkForDispStatus(i)){
|
|
#if (ETH_REARCAM_CLONE_FOR_DISPLAY == ENABLE)
|
|
if (socketCliEthData2_IsRecv(i-_CFG_ETHCAM_ID_1))
|
|
#else
|
|
if (socketCliEthData1_IsRecv(i-_CFG_ETHCAM_ID_1))
|
|
#endif
|
|
{
|
|
if ((ret = ImageApp_MovieMulti_DispPullOut(i, &src_img[j], 150)) != HD_OK) {
|
|
//DBG_ERR("ethcam pull_out yuv error[%d]=%d\r\n", i-_CFG_ETHCAM_ID_1, ret);
|
|
if(ret==HD_ERR_BAD_DATA){
|
|
DBG_ERR("Dec err!,path_id=%d\r\n", i-_CFG_ETHCAM_ID_1);
|
|
if(ImageApp_MovieMulti_IsStreamRunning(i)){
|
|
Ux_PostEvent(NVTEVT_CB_MOVIE_SLOW, 0);
|
|
}
|
|
if((i-_CFG_ETHCAM_ID_1)>=ETHCAM_PATH_ID_1 && (i-_CFG_ETHCAM_ID_1)< ETHCAM_PATH_ID_MAX){
|
|
//ImageApp_MovieMulti_EthCamLinkForDisp((i-_CFG_ETHCAM_ID_1), DISABLE, TRUE);
|
|
|
|
EthCamCmd_GetFrameTimerEn(0);
|
|
EthCam_SendXMLCmd((i-_CFG_ETHCAM_ID_1), ETHCAM_PORT_DATA1 ,ETHCAM_CMD_TX_RESET_I, 0);
|
|
#if(ETH_REARCAM_CLONE_FOR_DISPLAY == ENABLE)
|
|
EthCam_SendXMLCmd((i-_CFG_ETHCAM_ID_1), ETHCAM_PORT_DATA2 ,ETHCAM_CMD_TX_RESET_I, 0);
|
|
#endif
|
|
EthCamCmd_GetFrameTimerEn(1);
|
|
pEthcamSrc[i-_CFG_ETHCAM_ID_1] = src_img[j];
|
|
//ImageApp_MovieMulti_EthCamLinkForDisp((i-_CFG_ETHCAM_ID_1), ENABLE, TRUE);
|
|
}
|
|
goto video_frame_release;
|
|
}
|
|
//continue;
|
|
}else{
|
|
pip_draw.p_src_img[j] = &src_img[j];
|
|
sensor_count++;
|
|
bPullData[j] = TRUE;
|
|
pEthcamSrc[i-_CFG_ETHCAM_ID_1] = src_img[j];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if (sensor_count == 0) { // cannot pull data!
|
|
vos_util_delay_ms(100);
|
|
return;
|
|
}
|
|
#if (MOVIE_IME_CROP == ENABLE)
|
|
disp_buf.w = DevSize.w;
|
|
disp_buf.h = DevSize.h;
|
|
#else
|
|
disp_buf.w = src_img[0].dim.w;
|
|
disp_buf.h = src_img[0].dim.h;
|
|
#endif
|
|
#if ( ETH_REARCAM_CAPS_COUNT == 1)
|
|
if (pip_style == DUALCAM_BEHIND || pip_style == DUALCAM_BOTH2) {
|
|
disp_buf.w = DevSize.w;
|
|
disp_buf.h = DevSize.h;
|
|
}
|
|
#endif
|
|
#if ((SENSOR_CAPS_COUNT & SENSOR_ON_MASK)==0 && ETH_REARCAM_CAPS_COUNT)
|
|
disp_buf.w = DevSize.w;
|
|
disp_buf.h = DevSize.h;
|
|
#endif
|
|
|
|
#if ( ETH_REARCAM_CAPS_COUNT >= 2)
|
|
if (!(SENSOR_CAPS_COUNT & SENSOR_ON_MASK)) {
|
|
if ((socketCliEthData1_IsRecv(ETHCAM_PATH_ID_1)) && (!socketCliEthData1_IsRecv(ETHCAM_PATH_ID_2))) {
|
|
UI_SetData(FL_DUAL_CAM, DUALCAM_FRONT);
|
|
UI_SetData(FL_DUAL_CAM_MENU, DUALCAM_FRONT);
|
|
} else if ((!socketCliEthData1_IsRecv(ETHCAM_PATH_ID_1)) && (socketCliEthData1_IsRecv(ETHCAM_PATH_ID_2))) {
|
|
UI_SetData(FL_DUAL_CAM, DUALCAM_BEHIND);
|
|
UI_SetData(FL_DUAL_CAM_MENU, DUALCAM_BEHIND);
|
|
}
|
|
pip_style = UI_GetData(FL_DUAL_CAM);
|
|
}
|
|
#endif
|
|
|
|
if ((pip_style == DUALCAM_FRONT) || (pip_style == DUALCAM_LR_FRONT_FULL)
|
|
#if defined(_NVT_ETHREARCAM_RX_)
|
|
|| (sensor_count == 1 && (SENSOR_CAPS_COUNT & SENSOR_ON_MASK))
|
|
#endif
|
|
) {
|
|
if(pip_draw.p_src_img[0]){ //IVOT_N12079_CO-116
|
|
|
|
#if MOVIE_AI_DEMO
|
|
{
|
|
MovieAlgFunc_AI2_Result result = MovieAlgFunc_AI2_GetResult();
|
|
|
|
if(result.obj_num){
|
|
|
|
HD_GFX_HANDLE handle;
|
|
HD_GFX_DRAW_RECT draw_rect_list[MOVIE_ALG_FUNC_AI2_MAX_OBJ_NUM] = {0};
|
|
|
|
hd_gfx_begin_job(&handle);
|
|
|
|
for(UINT32 i=0 ; i<result.obj_num && i<MOVIE_ALG_FUNC_AI2_MAX_OBJ_NUM ; i++)
|
|
{
|
|
HD_IRECT new_rect;
|
|
HD_GFX_DRAW_RECT *draw_rect = &draw_rect_list[i];
|
|
|
|
draw_rect->color = 0xFFFF0000;
|
|
draw_rect->dst_img.ddr_id = DDR_ID0;
|
|
draw_rect->dst_img.dim = pip_draw.p_src_img[0]->dim;
|
|
draw_rect->dst_img.format = pip_draw.p_src_img[0]->pxlfmt;
|
|
draw_rect->dst_img.p_phy_addr[0] = pip_draw.p_src_img[0]->phy_addr[0];
|
|
draw_rect->dst_img.p_phy_addr[1] = pip_draw.p_src_img[0]->phy_addr[1];
|
|
draw_rect->dst_img.lineoffset[0] = pip_draw.p_src_img[0]->loff[0];
|
|
draw_rect->dst_img.lineoffset[1] = pip_draw.p_src_img[0]->loff[1];
|
|
draw_rect->thickness = 4;
|
|
draw_rect->type = HD_GFX_RECT_HOLLOW;
|
|
|
|
new_rect.w = ALIGN_FLOOR((draw_rect->dst_img.dim.w * result.obj[i].rect.w) / result.dim.w, 4);
|
|
new_rect.h = (draw_rect->dst_img.dim.h * result.obj[i].rect.h) / result.dim.h;
|
|
new_rect.x = (draw_rect->dst_img.dim.w * result.obj[i].rect.x) / result.dim.w;
|
|
new_rect.y = (draw_rect->dst_img.dim.h * result.obj[i].rect.y) / result.dim.h;
|
|
|
|
draw_rect->rect = new_rect;
|
|
}
|
|
|
|
hd_gfx_add_draw_rect_list(handle, draw_rect_list, result.obj_num);
|
|
hd_gfx_end_job(handle);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if ((ret = ImageApp_MovieMulti_DispPushIn(_CFG_DISP_ID_1, &src_img[0], 150)) != HD_OK) {
|
|
#if defined(_NVT_ETHREARCAM_RX_)
|
|
if (ret != HD_ERR_OVERRUN){
|
|
DBG_ERR("disp push_in error(%d)\r\n", ret);
|
|
}
|
|
#else
|
|
DBG_ERR("disp push_in error(%d)\r\n", ret);
|
|
#endif
|
|
}
|
|
goto video_frame_release;
|
|
}
|
|
} else if ((pip_style == DUALCAM_BEHIND) || (pip_style == DUALCAM_LR_BEHIND_FULL)) {
|
|
#if (DUALCAM_PIP_BEHIND_FLIP == DISABLE)
|
|
if(pip_draw.p_src_img[1]){ //IVOT_N12079_CO-116
|
|
if ((ret = ImageApp_MovieMulti_DispPushIn(_CFG_DISP_ID_1, &src_img[1], 150)) != HD_OK) {
|
|
#if defined(_NVT_ETHREARCAM_RX_)
|
|
if (ret != HD_ERR_OVERRUN){
|
|
DBG_ERR("disp push_in error(%d)\r\n", ret);
|
|
}
|
|
#else
|
|
DBG_ERR("disp push_in error(%d)\r\n", ret);
|
|
#endif
|
|
}
|
|
goto video_frame_release;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
if(SysVideo_GetDirbyID(DOUT1) != HD_VIDEO_DIR_NONE){
|
|
blk_size = VDO_YUV_BUFSIZE(ALIGN_CEIL_16(disp_buf.w), ALIGN_CEIL_16(disp_buf.h), HD_VIDEO_PXLFMT_YUV420);
|
|
}else{
|
|
blk_size = VDO_YUV_BUFSIZE(disp_buf.w, disp_buf.h, HD_VIDEO_PXLFMT_YUV420);
|
|
}
|
|
|
|
|
|
if ((blk = hd_common_mem_get_block(HD_COMMON_MEM_COMMON_POOL, blk_size, DDR_ID0)) == HD_COMMON_MEM_VB_INVALID_BLK) {
|
|
DBG_ERR("hd_common_mem_get_block fail(%d)\r\n", blk);
|
|
goto video_frame_release;
|
|
}
|
|
|
|
if ((pa = hd_common_mem_blk2pa(blk)) == 0) {
|
|
DBG_ERR("hd_common_mem_blk2pa fail\r\n");
|
|
if ((ret = hd_common_mem_release_block(blk)) != HD_OK) {
|
|
DBG_ERR("hd_common_mem_release_block fail(%d)\r\n", ret);
|
|
}
|
|
goto video_frame_release;
|
|
}
|
|
|
|
// set dest buffer
|
|
pip_draw.p_dst_img = &dst_img;
|
|
addr[0] = pa;
|
|
loff[0] = ALIGN_CEIL_4(disp_buf.w);
|
|
addr[1] = pa + loff[0] * disp_buf.h;
|
|
loff[1] = ALIGN_CEIL_4(disp_buf.w);
|
|
if ((ret = vf_init_ex(pip_draw.p_dst_img, disp_buf.w, disp_buf.h, HD_VIDEO_PXLFMT_YUV420, loff, addr)) != HD_OK) {
|
|
DBG_ERR("vf_init_ex dst failed(%d)\r\n", ret);
|
|
}
|
|
|
|
PipView_OnDraw(&pip_draw);
|
|
|
|
#if (MOVIE_IME_CROP == ENABLE)
|
|
// fill black if rear sensor plugged out
|
|
if ((System_GetEnableSensor() & SENSOR_2) == 0) {
|
|
VF_GFX_DRAW_RECT draw_rect = {0};
|
|
memcpy((void *)&draw_rect.dst_img, (void *)pip_draw.p_dst_img, sizeof(HD_VIDEO_FRAME));
|
|
draw_rect.color = COLOR_RGB_BLACK;
|
|
draw_rect.rect.x = 0;
|
|
draw_rect.rect.y = 0;
|
|
draw_rect.rect.w = DevSize.w;
|
|
draw_rect.rect.h = DevSize.h;
|
|
draw_rect.type = HD_GFX_RECT_SOLID;
|
|
draw_rect.thickness = 0; //Don't care for HD_GFX_RECT_SOLID
|
|
draw_rect.engine = 0;
|
|
vf_gfx_draw_rect(&draw_rect);
|
|
}
|
|
#endif
|
|
|
|
pip_draw.p_dst_img->count = 0;
|
|
pip_draw.p_dst_img->timestamp = hd_gettime_us();
|
|
pip_draw.p_dst_img->blk = blk;
|
|
//DBG_DUMP("dst_im.dim.w=%d, %d\r\n", pip_draw.p_dst_img->dim.w,pip_draw.p_dst_img->dim.h);
|
|
|
|
if ((ret = ImageApp_MovieMulti_DispPushIn(_CFG_DISP_ID_1, pip_draw.p_dst_img, 150)) != HD_OK) {
|
|
#if defined(_NVT_ETHREARCAM_RX_)
|
|
if (ret != HD_ERR_OVERRUN){
|
|
DBG_ERR("disp push_in error(%d)\r\n", ret);
|
|
}
|
|
#else
|
|
DBG_ERR("disp push_in error(%d)\r\n", ret);
|
|
#endif
|
|
}
|
|
|
|
if ((ret = hd_common_mem_release_block(blk)) != HD_OK) {
|
|
DBG_ERR("hd_common_mem_release_block fail(%d)\r\n", ret);
|
|
}
|
|
|
|
video_frame_release:
|
|
for (i = 0; i < (SENSOR_CAPS_COUNT&SENSOR_ON_MASK); i++) {
|
|
//if (pip_draw.p_src_img[i]) {
|
|
if (bPullData[i]){
|
|
if ((ret = ImageApp_MovieMulti_DispReleaseOut(_CFG_REC_ID_1 + i, &src_img[i])) != HD_OK) {
|
|
DBG_ERR("disp release_out error(%d)\r\n", ret);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void MovieExe_WifiCB(HD_VIDEO_FRAME *pEthcamSrc)
|
|
{
|
|
HD_VIDEO_FRAME src_img[SENSOR_CAPS_COUNT+ETH_REARCAM_CAPS_COUNT] = {0};
|
|
HD_VIDEO_FRAME dst_img;
|
|
|
|
//HD_VIDEO_FRAME video_frame = {0};
|
|
HD_RESULT ret;
|
|
HD_COMMON_MEM_VB_BLK blk;
|
|
UINT32 i, mask, sensor_mask, sensor_count;
|
|
UINT32 blk_size, pa=0;
|
|
UINT32 addr[HD_VIDEO_MAX_PLANE] = {0};
|
|
UINT32 loff[HD_VIDEO_MAX_PLANE] = {0};
|
|
APPDISP_VIEW_DRAW pip_draw = {0};
|
|
|
|
//#if (MOVIE_UVAC_FUNC == DISABLE)
|
|
//if (System_GetState(SYS_STATE_CURRSUBMODE) != SYS_SUBMODE_WIFI) {
|
|
if (ImageApp_MovieMulti_IsStreamRunning(_CFG_STRM_ID_1) == FALSE) {
|
|
return;
|
|
}
|
|
//#endif
|
|
|
|
mask = 1;
|
|
sensor_count = 0;
|
|
sensor_mask = System_GetEnableSensor();
|
|
for (i = 0; i < (SENSOR_CAPS_COUNT & SENSOR_ON_MASK); i++) {
|
|
if (sensor_mask & mask) {
|
|
if ((ret = ImageApp_MovieMulti_WifiPullOut(_CFG_REC_ID_1 + i, &src_img[i], 150)) == HD_OK) {
|
|
pip_draw.p_src_img[i] = &src_img[i];
|
|
sensor_count++;
|
|
}
|
|
}
|
|
mask <<= 1;
|
|
}
|
|
|
|
#if defined(_NVT_ETHREARCAM_RX_)
|
|
UINT32 j;
|
|
for (i = _CFG_ETHCAM_ID_1; i < (_CFG_ETHCAM_ID_1+ETH_REARCAM_CAPS_COUNT); i++) {
|
|
j=i-_CFG_ETHCAM_ID_1+(SENSOR_CAPS_COUNT & SENSOR_ON_MASK);
|
|
|
|
if (pEthcamSrc[i-_CFG_ETHCAM_ID_1].pw[0]) {
|
|
pip_draw.p_src_img[j] = &pEthcamSrc[i-_CFG_ETHCAM_ID_1];
|
|
sensor_count++;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if (sensor_count == 0) { // cannot pull data!
|
|
vos_util_delay_ms(100);
|
|
return;
|
|
}
|
|
|
|
|
|
ISIZE DevSize = {0};
|
|
DevSize.w = gMovie_Strm_Info.size.w;
|
|
DevSize.h = gMovie_Strm_Info.size.h;
|
|
|
|
//if(pip_draw.p_src_img[1])
|
|
//DBG_DUMP("DevSize=%d, %d %d,%d,%d\r\n", DevSize.w,DevSize.h,pip_draw.p_src_img[1]->pw[0],pip_draw.p_src_img[1]->loff[0],pip_draw.p_src_img[1]->ph[0]);
|
|
|
|
if ((UI_GetData(FL_DUAL_CAM) == DUALCAM_FRONT) || (sensor_count == 1)) {
|
|
if( src_img[0].phy_addr[0]==0){
|
|
goto video_frame_release;
|
|
}
|
|
|
|
if ((ret = ImageApp_MovieMulti_WifiPushIn(_CFG_STRM_ID_1, &src_img[0], 150)) != HD_OK) {
|
|
DBG_ERR("wifi push_in error(%d)\r\n", ret);
|
|
}
|
|
goto video_frame_release;
|
|
}
|
|
#if !defined(_NVT_ETHREARCAM_RX_)
|
|
else if (UI_GetData(FL_DUAL_CAM) == DUALCAM_BEHIND) {
|
|
#if (DUALCAM_PIP_BEHIND_FLIP == DISABLE)
|
|
if(pip_draw.p_src_img[1] && ((UINT32)DevSize.w == pip_draw.p_src_img[1]->pw[0])){
|
|
if ((ret = ImageApp_MovieMulti_WifiPushIn(_CFG_STRM_ID_1, &src_img[1], 150)) != HD_OK) {
|
|
DBG_ERR("wifi push_in error(%d)\r\n", ret);
|
|
}
|
|
goto video_frame_release;
|
|
}
|
|
#endif
|
|
}
|
|
#endif
|
|
blk_size = VDO_YUV_BUFSIZE(DevSize.w, DevSize.h, HD_VIDEO_PXLFMT_YUV420);
|
|
if ((blk = hd_common_mem_get_block(HD_COMMON_MEM_COMMON_POOL, blk_size, DDR_ID0)) == HD_COMMON_MEM_VB_INVALID_BLK) {
|
|
DBG_ERR("hd_common_mem_get_block fail(%d)\r\n", blk);
|
|
goto video_frame_release;
|
|
}
|
|
|
|
if ((pa = hd_common_mem_blk2pa(blk)) == 0) {
|
|
DBG_ERR("hd_common_mem_blk2pa fail\r\n");
|
|
if ((ret = hd_common_mem_release_block(blk)) != HD_OK) {
|
|
DBG_ERR("hd_common_mem_release_block fail(%d)\r\n", ret);
|
|
}
|
|
goto video_frame_release;
|
|
}
|
|
|
|
// set dest buffer
|
|
pip_draw.p_dst_img = &dst_img;
|
|
addr[0] = pa;
|
|
loff[0] = ALIGN_CEIL_4(DevSize.w);
|
|
addr[1] = pa + loff[0] * DevSize.h;
|
|
loff[1] = ALIGN_CEIL_4(DevSize.w);
|
|
if ((ret = vf_init_ex(pip_draw.p_dst_img, DevSize.w, DevSize.h, HD_VIDEO_PXLFMT_YUV420, loff, addr)) != HD_OK) {
|
|
DBG_ERR("vf_init_ex dst failed(%d)\r\n", ret);
|
|
}
|
|
|
|
PipView_OnDraw(&pip_draw);
|
|
|
|
pip_draw.p_dst_img->count = 0;
|
|
pip_draw.p_dst_img->timestamp = hd_gettime_us();
|
|
pip_draw.p_dst_img->blk = blk;
|
|
if ((ret = ImageApp_MovieMulti_WifiPushIn(_CFG_STRM_ID_1, pip_draw.p_dst_img, 150)) != HD_OK) {
|
|
#if defined(_NVT_ETHREARCAM_RX_)
|
|
if (ret != HD_ERR_OVERRUN){
|
|
DBG_ERR("wifi push_in error(%d)\r\n", ret);
|
|
}
|
|
#else
|
|
DBG_ERR("wifi push_in error(%d)\r\n", ret);
|
|
#endif
|
|
}
|
|
|
|
if ((ret = hd_common_mem_release_block(blk)) != HD_OK) {
|
|
DBG_ERR("hd_common_mem_release_block fail(%d)\r\n", ret);
|
|
}
|
|
|
|
video_frame_release:
|
|
for (i = 0; i < (SENSOR_CAPS_COUNT&SENSOR_ON_MASK); i++) {
|
|
if (pip_draw.p_src_img[i]) {
|
|
if ((ret = ImageApp_MovieMulti_WifiReleaseOut(_CFG_REC_ID_1 + i, &src_img[i])) != HD_OK) {
|
|
DBG_ERR("wifi release_out error(%d)\r\n", ret);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void MovieExe_PipCB(void)
|
|
{
|
|
#if defined(_NVT_ETHREARCAM_RX_)
|
|
HD_VIDEO_FRAME ethcam_src_img[ETH_REARCAM_CAPS_COUNT] = {0};
|
|
#else
|
|
HD_VIDEO_FRAME ethcam_src_img[1] = {0};
|
|
#endif
|
|
MovieExe_DispCB(ethcam_src_img);
|
|
MovieExe_WifiCB(ethcam_src_img);
|
|
|
|
#if defined(_NVT_ETHREARCAM_RX_)
|
|
UINT32 i, j;
|
|
HD_RESULT ret;
|
|
for (i = _CFG_ETHCAM_ID_1; i < (_CFG_ETHCAM_ID_1+ETH_REARCAM_CAPS_COUNT); i++) {
|
|
j=i-_CFG_ETHCAM_ID_1;
|
|
if (ethcam_src_img[j].pw[0] || ethcam_src_img[j].phy_addr[0]) {
|
|
if ((ret = ImageApp_MovieMulti_DispReleaseOut(i, ðcam_src_img[j])) != HD_OK) {
|
|
DBG_ERR("pip release_out error\r\n", ret);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
// avoid busy loop if system in sleep mode and submode != wifi
|
|
if ((System_GetState(SYS_STATE_SLEEPLEVEL) != 0) && (System_GetState(SYS_STATE_CURRSUBMODE) != SYS_SUBMODE_WIFI)) {
|
|
vos_util_delay_ms(200);
|
|
}
|
|
}
|
|
|
|
void MovieExe_EthCam_ChgDispCB(UINT32 DualCam)
|
|
{
|
|
#if defined(_NVT_ETHREARCAM_RX_)
|
|
UINT32 DualCamChk=DUALCAM_BEHIND;//ETH_REARCAM_CAPS_COUNT==1, show behind sensor
|
|
#if((ETH_REARCAM_CAPS_COUNT+SENSOR_CAPS_COUNT) >2)
|
|
DualCamChk=DUALCAM_BOTH;//show four division
|
|
#endif
|
|
|
|
#if(ETH_REARCAM_CLONE_FOR_DISPLAY == ENABLE)
|
|
DBG_DUMP("MovieExe_EthCam_ChgDispCB IsSocketGetData=%d, %d\r\n",socketCliEthData2_IsRecv(ETHCAM_PATH_ID_1),DualCam);
|
|
if(socketCliEthData2_IsRecv(ETHCAM_PATH_ID_1)&& (DualCam==DualCamChk))
|
|
#else
|
|
DBG_DUMP("MovieExe_EthCam_ChgDispCB IsSocketGetData=%d, %d, %d\r\n",socketCliEthData1_IsRecv(ETHCAM_PATH_ID_1), socketCliEthData1_IsRecv(ETHCAM_PATH_ID_2),DualCam);
|
|
if((socketCliEthData1_IsRecv(ETHCAM_PATH_ID_1) || socketCliEthData1_IsRecv(ETHCAM_PATH_ID_2))&& (DualCam==DualCamChk))
|
|
#endif
|
|
{
|
|
#if(ETH_REARCAM_CLONE_FOR_DISPLAY == ENABLE)
|
|
if(socketCliEthData1_IsRecv(ETHCAM_PATH_ID_1)==0){
|
|
BKG_PostEvent(NVTEVT_BKW_ETHCAM_SYNC_TIME);
|
|
BKG_PostEvent(NVTEVT_BKW_ETHCAM_SOCKETCLI_REC_DATA_OPEN_START);
|
|
}
|
|
#endif
|
|
|
|
#if((ETH_REARCAM_CAPS_COUNT+SENSOR_CAPS_COUNT) == 2)
|
|
UI_SetData(FL_DUAL_CAM, DUALCAM_BEHIND);
|
|
UI_SetData(FL_DUAL_CAM_MENU, DUALCAM_BEHIND);
|
|
#else//#elif(ETH_REARCAM_CAPS_COUNT >= 2)
|
|
UI_SetData(FL_DUAL_CAM, DUALCAM_BOTH);
|
|
UI_SetData(FL_DUAL_CAM_MENU, DUALCAM_BOTH);
|
|
#endif
|
|
}else{
|
|
#if((ETH_REARCAM_CAPS_COUNT+SENSOR_CAPS_COUNT) == 2)//#if(ETH_REARCAM_CAPS_COUNT == 1)
|
|
UI_SetData(FL_DUAL_CAM, DUALCAM_FRONT);//default front sensor
|
|
UI_SetData(FL_DUAL_CAM_MENU, DUALCAM_FRONT);
|
|
#else//#elif(ETH_REARCAM_CAPS_COUNT >= 2)
|
|
UI_SetData(FL_DUAL_CAM, DUALCAM_BOTH);//default four division
|
|
UI_SetData(FL_DUAL_CAM_MENU, DUALCAM_BOTH);
|
|
#endif
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#if (USE_EXIF == ENABLE)
|
|
static UINT32 exifbuf_pa = 0, exifbuf_va = 0;
|
|
|
|
static ER MovieExe_InitExif(void)
|
|
{
|
|
ER ret = E_SYS;
|
|
HD_RESULT hd_ret;
|
|
UINT32 pa, blk_size;
|
|
void *va;
|
|
HD_COMMON_MEM_DDR_ID ddr_id = DDR_ID0;
|
|
MEM_RANGE buf;
|
|
|
|
EXIF_InstallID();
|
|
|
|
blk_size = 64 * 1024 * 1* SENSOR_CAPS_COUNT;
|
|
|
|
if(exifbuf_va == 0) {
|
|
if ((hd_ret = hd_common_mem_alloc("exifbuf", &pa, (void **)&va, blk_size, ddr_id)) != HD_OK) {
|
|
DBG_ERR("hd_common_mem_alloc failed(%d)\r\n", hd_ret);
|
|
return E_NOMEM;
|
|
}
|
|
exifbuf_va = (UINT32)va;
|
|
exifbuf_pa = (UINT32)pa;
|
|
|
|
buf.addr = exifbuf_va;
|
|
buf.size = 0x10000;
|
|
EXIF_Init(EXIF_HDL_ID_1, &buf, ExifCB);
|
|
#if !defined(_SENSOR2_CMOS_OFF_)
|
|
buf.addr = (exifbuf_va + buf.size);
|
|
buf.size = 0x10000;
|
|
EXIF_Init(EXIF_HDL_ID_2, &buf, ExifCB);
|
|
#endif
|
|
#if !defined(_SENSOR3_CMOS_OFF_)
|
|
buf.addr = (exifbuf_va + buf.size);
|
|
buf.size = 0x10000;
|
|
EXIF_Init(EXIF_HDL_ID_3, &buf, ExifCB);
|
|
#endif
|
|
ret = E_OK;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static ER MovieExe_UninitExif(void)
|
|
{
|
|
ER ret = E_OK;
|
|
HD_RESULT hd_ret;
|
|
|
|
if ((hd_ret = hd_common_mem_free(exifbuf_pa, (void *)exifbuf_va)) != HD_OK) {
|
|
DBG_ERR("hd_common_mem_free failed(%d)\r\n", hd_ret);
|
|
ret = E_SYS;
|
|
}
|
|
exifbuf_pa = 0;
|
|
exifbuf_va = 0;
|
|
|
|
EXIF_UninstallID();
|
|
|
|
return ret;
|
|
}
|
|
#endif
|
|
UINT32 MovieExe_GetTBR(MOVIE_CFG_REC_ID rec_id)
|
|
{
|
|
if(rec_id==_CFG_REC_ID_1){
|
|
return gMovie_Rec_Info[_CFG_REC_ID_1].target_bitrate;
|
|
}else{
|
|
return gMovie_Clone_Info[rec_id-_CFG_CLONE_ID_1].target_bitrate;
|
|
}
|
|
}
|
|
UINT32 MovieExe_GetWidth(MOVIE_CFG_REC_ID rec_id)
|
|
{
|
|
if(rec_id==_CFG_REC_ID_1){
|
|
return gMovie_Rec_Info[_CFG_REC_ID_1].size.w;
|
|
}else{
|
|
return gMovie_Clone_Info[rec_id-_CFG_CLONE_ID_1].size.w;
|
|
}
|
|
}
|
|
UINT32 MovieExe_GetHeight(MOVIE_CFG_REC_ID rec_id)
|
|
{
|
|
if(rec_id==_CFG_REC_ID_1){
|
|
return gMovie_Rec_Info[_CFG_REC_ID_1].size.h;
|
|
}else{
|
|
return gMovie_Clone_Info[rec_id-_CFG_CLONE_ID_1].size.h;
|
|
}
|
|
}
|
|
UINT32 MovieExe_GetFps(MOVIE_CFG_REC_ID rec_id)
|
|
{
|
|
if(rec_id==_CFG_REC_ID_1){
|
|
return gMovie_Rec_Info[_CFG_REC_ID_1].frame_rate;
|
|
}else{
|
|
return gMovie_Clone_Info[rec_id-_CFG_CLONE_ID_1].frame_rate;
|
|
}
|
|
}
|
|
UINT32 MovieExe_GetGOP(MOVIE_CFG_REC_ID rec_id)
|
|
{
|
|
if(rec_id==_CFG_REC_ID_1){
|
|
return gMovie_Rec_Info[_CFG_REC_ID_1].cbr_info.uiGOP;
|
|
}else{
|
|
return gMovie_Clone_Info[rec_id-_CFG_CLONE_ID_1].cbr_info.uiGOP;
|
|
}
|
|
}
|
|
UINT32 MovieExe_GetCodec(MOVIE_CFG_REC_ID rec_id)
|
|
{
|
|
if(rec_id==_CFG_REC_ID_1){
|
|
return gMovie_Rec_Info[_CFG_REC_ID_1].codec;
|
|
}else{
|
|
return gMovie_Clone_Info[rec_id-_CFG_CLONE_ID_1].codec;
|
|
}
|
|
}
|
|
MOVIE_RECODE_INFO MovieExe_GetRecInfo(MOVIE_CFG_REC_ID rec_id)
|
|
{
|
|
if(rec_id==_CFG_REC_ID_1){
|
|
return gMovie_Rec_Info[_CFG_REC_ID_1];
|
|
}else{
|
|
return gMovie_Clone_Info[rec_id-_CFG_CLONE_ID_1];
|
|
}
|
|
}
|
|
UINT32 MovieExe_GetEmrRollbackSec(void)
|
|
{
|
|
return gMovie_Rec_Option.emr_sec;
|
|
}
|
|
#if(defined(_NVT_ETHREARCAM_RX_))
|
|
UINT32 MovieExe_GetEthcamEncBufSec(ETHCAM_PATH_ID path_id)
|
|
{
|
|
return g_uiEthcamEncBufSec[path_id];
|
|
}
|
|
void MovieExe_SetEthcamEncBufSec(ETHCAM_PATH_ID path_id, UINT32 Sec)
|
|
{
|
|
g_uiEthcamEncBufSec[path_id]=Sec;
|
|
}
|
|
#endif
|
|
|
|
void MovieExe_AE_SetUIInfo(UINT32 index, UINT32 value)
|
|
{
|
|
AET_FREQUENCY_MODE FreMode ={0};
|
|
AET_EV_OFFSET EV_Offset={0};
|
|
HD_RESULT hd_ret;
|
|
|
|
DBG_FUNC_BEGIN("index=%d, value=%d\r\n",index,value);
|
|
if ((hd_ret = vendor_isp_init()) != HD_OK) {
|
|
DBG_ERR("vendor_isp_init() fail(%d)\r\n", hd_ret);
|
|
}
|
|
if (System_GetEnableSensor() & SENSOR_1) {
|
|
DBG_FUNC("sensor1 AE_UI_FREQUENCY value=%d\r\n", value);
|
|
if(index == AE_UI_FREQUENCY){
|
|
FreMode.id = AE_ID_1;
|
|
FreMode.mode = value;
|
|
if ((hd_ret = vendor_isp_set_ae(AET_ITEM_FREQUENCY, &FreMode)) != HD_OK) {
|
|
DBG_ERR("vendor_isp_set_ae() fail(%d)\r\n", hd_ret);
|
|
}
|
|
}else if (index == AE_UI_EV){
|
|
EV_Offset.id =AE_ID_1;
|
|
EV_Offset.offset=value;
|
|
if ((hd_ret = vendor_isp_set_ae(AET_ITEM_EV, &EV_Offset)) != HD_OK) {
|
|
DBG_ERR("vendor_isp_set_ae() fail(%d)\r\n", hd_ret);
|
|
}
|
|
}
|
|
}
|
|
if (System_GetEnableSensor() & SENSOR_2) {
|
|
DBG_FUNC("sensor2 AE_UI_FREQUENCY value=%d\r\n", value);
|
|
if(index == AE_UI_FREQUENCY){
|
|
FreMode.id = AE_ID_2;
|
|
FreMode.mode = value;
|
|
if ((hd_ret = vendor_isp_set_ae(AET_ITEM_FREQUENCY, &FreMode)) != HD_OK) {
|
|
DBG_ERR("vendor_isp_set_ae() fail(%d)\r\n", hd_ret);
|
|
}
|
|
}else if (index == AE_UI_EV){
|
|
EV_Offset.id =AE_ID_2;
|
|
EV_Offset.offset=value;
|
|
if ((hd_ret = vendor_isp_set_ae(AET_ITEM_EV, &EV_Offset)) != HD_OK) {
|
|
DBG_ERR("vendor_isp_set_ae() fail(%d)\r\n", hd_ret);
|
|
}
|
|
}
|
|
}
|
|
if ((hd_ret = vendor_isp_uninit()) != HD_OK) {
|
|
DBG_ERR("vendor_isp_uninit() fail(%d)\r\n", hd_ret);
|
|
}
|
|
DBG_FUNC_END("\r\n");
|
|
}
|
|
|
|
void MovieExe_ResetFileSN(void)
|
|
{
|
|
g_FileSerialNum = 0;
|
|
}
|
|
|
|
UINT32 MovieExe_GetFileSN(void)
|
|
{
|
|
return g_FileSerialNum;
|
|
}
|
|
|
|
BOOL MovieExe_CheckSNFull(void)
|
|
{
|
|
return (g_FileSerialNum >= FILE_SN_MAX);
|
|
}
|
|
|
|
static void MovieExe_FileNamingCB(MOVIE_CFG_REC_ID id, char *pFileName)
|
|
{
|
|
|
|
#if USE_FILEDB
|
|
static struct tm CurDateTime = {0};
|
|
|
|
g_FileSerialNum++;
|
|
|
|
if (g_FileSerialNum > FILE_SN_MAX) {
|
|
g_FileSerialNum = FILE_SN_MAX;
|
|
Ux_PostEvent(NVTEVT_CB_MOVIE_FULL, 0);
|
|
}
|
|
|
|
GxTime_GetTime(&CurDateTime);
|
|
#if(SENSOR_CAPS_COUNT>=2 || ((defined(_NVT_ETHREARCAM_RX_)) && (ETH_REARCAM_CAPS_COUNT >= 2)))
|
|
char NH_endChar='A';
|
|
if(id < _CFG_REC_ID_MAX){
|
|
NH_endChar+=id;
|
|
}else if(id <_CFG_CLONE_ID_MAX){
|
|
NH_endChar+=(id-_CFG_CLONE_ID_1);
|
|
}else if(id <_CFG_ETHCAM_ID_MAX){
|
|
NH_endChar+=(id-_CFG_ETHCAM_ID_1);
|
|
}
|
|
|
|
snprintf(pFileName, NMC_TOTALFILEPATH_MAX_LEN, "%04d%02d%02d%02d%02d%02d_%06d%c",
|
|
CurDateTime.tm_year, CurDateTime.tm_mon, CurDateTime.tm_mday,
|
|
CurDateTime.tm_hour, CurDateTime.tm_min, CurDateTime.tm_sec, g_FileSerialNum, NH_endChar);
|
|
#else
|
|
snprintf(pFileName, NMC_TOTALFILEPATH_MAX_LEN, "%04d%02d%02d%02d%02d%02d_%06d",
|
|
CurDateTime.tm_year, CurDateTime.tm_mon, CurDateTime.tm_mday,
|
|
CurDateTime.tm_hour, CurDateTime.tm_min, CurDateTime.tm_sec, g_FileSerialNum);
|
|
#endif
|
|
#elif USE_DCF
|
|
|
|
UINT32 nextFolderID = 0, nextFileID = 0;
|
|
|
|
if (DCF_GetDBInfo(DCF_INFO_IS_9999)) {
|
|
DBG_ERR("Exceed max dcf file!\r\n");
|
|
pFileName[0] = '\0';
|
|
} else {
|
|
DCF_GetNextID(&nextFolderID,&nextFileID);
|
|
DCF_MakeObjPath(nextFolderID, nextFileID, DCF_FILE_TYPE_MP4, pFileName);
|
|
DCF_AddDBfile(pFileName);
|
|
DBG_DUMP("%s added to DCF\r\n", pFileName);
|
|
#if HUNTING_CAMERA_MCU == ENABLE
|
|
char tmp[NMC_TOTALFILEPATH_MAX_LEN] = {'\0'};
|
|
sprintf(tmp, "S%03d%04d.JPG", nextFolderID, nextFileID);
|
|
if(id == _CFG_REC_ID_1){
|
|
snprintf(thumb_current_path_main, sizeof(thumb_current_path_main), "%s", tmp);
|
|
}
|
|
else if(id == _CFG_CLONE_ID_1){
|
|
snprintf(thumb_current_path_clone, sizeof(thumb_current_path_clone), "%s", tmp);
|
|
}
|
|
DBG_DUMP("last send file:%s\r\n", tmp);
|
|
#else
|
|
if(id == _CFG_REC_ID_1){
|
|
snprintf(thumb_current_path_main, sizeof(thumb_current_path_main), "%s", pFileName);
|
|
}
|
|
else if(id == _CFG_CLONE_ID_1){
|
|
snprintf(thumb_current_path_clone, sizeof(thumb_current_path_clone), "%s", pFileName);
|
|
}
|
|
#endif
|
|
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
}
|
|
|
|
static void MovieExe_RawEncodeFileNamingCB(MOVIE_CFG_REC_ID id, char *pFileName)
|
|
{
|
|
#if USE_FILEDB
|
|
|
|
static struct tm CurDateTime = {0};
|
|
|
|
g_FileSerialNum++;
|
|
|
|
if (g_FileSerialNum > FILE_SN_MAX) {
|
|
g_FileSerialNum = FILE_SN_MAX;
|
|
Ux_PostEvent(NVTEVT_CB_MOVIE_FULL, 0);
|
|
}
|
|
|
|
GxTime_GetTime(&CurDateTime);
|
|
#if(SENSOR_CAPS_COUNT>=2)
|
|
char NH_endChar='A';
|
|
if(id < _CFG_REC_ID_MAX){
|
|
NH_endChar+=id;
|
|
}else if(id <_CFG_CLONE_ID_MAX){
|
|
NH_endChar+=(id-_CFG_CLONE_ID_1);
|
|
}
|
|
|
|
snprintf(pFileName, NMC_TOTALFILEPATH_MAX_LEN, "%04d%02d%02d%02d%02d%02d_%06d%c",
|
|
CurDateTime.tm_year, CurDateTime.tm_mon, CurDateTime.tm_mday,
|
|
CurDateTime.tm_hour, CurDateTime.tm_min, CurDateTime.tm_sec, g_FileSerialNum, NH_endChar);
|
|
#else
|
|
snprintf(pFileName, NMC_TOTALFILEPATH_MAX_LEN, "%04d%02d%02d%02d%02d%02d_%06d",
|
|
CurDateTime.tm_year, CurDateTime.tm_mon, CurDateTime.tm_mday,
|
|
CurDateTime.tm_hour, CurDateTime.tm_min, CurDateTime.tm_sec, g_FileSerialNum);
|
|
#endif
|
|
#elif USE_DCF
|
|
|
|
UINT32 nextFolderID = 0, nextFileID = 0;
|
|
|
|
if (DCF_GetDBInfo(DCF_INFO_IS_9999)) {
|
|
DBG_ERR("Exceed max dcf file!\r\n");
|
|
pFileName[0] = '\0';
|
|
} else {
|
|
DCF_GetNextID(&nextFolderID,&nextFileID);
|
|
DCF_MakeObjPath(nextFolderID, nextFileID, DCF_FILE_TYPE_JPG, pFileName);
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
static void MovieExe_UserEventCb(UINT32 id, MOVIE_USER_CB_EVENT event_id, UINT32 value)
|
|
{
|
|
switch ((UINT32)event_id) {
|
|
case MOVIE_USER_CB_EVENT_STAMP_CB: {
|
|
}
|
|
break;
|
|
|
|
case MOVIE_USER_CB_EVENT_REC_ONE_SECOND: {
|
|
// add gps data here
|
|
#if (GPS_FUNCTION == ENABLE)
|
|
MEM_RANGE gps_data;
|
|
RMCINFO RMCInfo;
|
|
GPSRec_GetRMCDate(&RMCInfo);
|
|
|
|
gps_data.addr = (UINT32)&(RMCInfo);
|
|
gps_data.size = sizeof(RMCInfo);
|
|
ImageApp_MovieMulti_SetParam(_CFG_CTRL_ID, MOVIEMULTI_PARAM_FILE_GPS_DATA, (UINT32)&gps_data);
|
|
#endif
|
|
Ux_PostEvent(NVTEVT_CB_MOVIE_REC_ONE_SEC, 1, value);
|
|
}
|
|
break;
|
|
|
|
case MOVIE_USER_CB_EVENT_FILENAMING_MOV_CB:
|
|
case MOVIE_USER_CB_EVENT_FILENAMING_EMR_CB: {
|
|
CHAR *pFileName = (CHAR *) value;
|
|
|
|
// Make custome file name
|
|
MovieExe_FileNamingCB(id, pFileName);
|
|
|
|
}
|
|
break;
|
|
|
|
case MOVIE_USER_CB_EVENT_FILENAMING_SNAPSHOT_CB: {
|
|
CHAR *pFileName = (CHAR *) value;
|
|
|
|
// Make custome file name
|
|
MovieExe_RawEncodeFileNamingCB(id, pFileName);
|
|
|
|
}
|
|
break;
|
|
|
|
case MOVIE_USER_CB_ERROR_CARD_SLOW: {
|
|
DBG_ERR("Slow card!, id %d\r\n", value);
|
|
Ux_PostEvent(NVTEVT_CB_MOVIE_SLOW, 0);
|
|
}
|
|
break;
|
|
|
|
case MOVIE_USER_CB_ERROR_CARD_WR_ERR: {
|
|
DBG_ERR("EVENT %d: card write error!\r\n", event_id);
|
|
Ux_PostEvent(NVTEVT_CB_MOVIE_WR_ERROR, 0);
|
|
}
|
|
break;
|
|
|
|
case MOVIE_USER_CB_EVENT_SNAPSHOT_OK: {
|
|
Ux_PostEvent(NVTEVT_CB_RAWENC_OK, 0);
|
|
}
|
|
break;
|
|
|
|
case MOVIE_USER_CB_ERROR_SNAPSHOT_ERR: {
|
|
DBG_ERR("EVENT %d: snapshop err!\r\n", event_id);
|
|
g_bAllowRawEnc=TRUE;
|
|
Ux_PostEvent(NVTEVT_CB_RAWENC_ERR, 0);
|
|
}
|
|
break;
|
|
|
|
case MOVIE_USER_CB_EVENT_CUTFILE: {
|
|
// Cyclic record cut file callback
|
|
DBG_IND("EVENT 0x%08x: Cut file end!\r\n", event_id);
|
|
}
|
|
break;
|
|
|
|
case MOVIE_USER_CB_ERROR_SEAMLESS_REC_FULL: {
|
|
Ux_PostEvent(NVTEVT_CB_MOVIE_FULL, 0);
|
|
}
|
|
break;
|
|
|
|
case MOVIE_USER_CB_EVENT_OVERTIME: {
|
|
DBG_IND("EVENT 0x%08x: Overtime!\r\n", event_id);
|
|
Ux_PostEvent(NVTEVT_CB_MOVIE_OVERTIME, 0);
|
|
}
|
|
break;
|
|
|
|
case MOVIE_USER_CB_EVENT_EMR_FILE_COMPLETED: {
|
|
Ux_PostEvent(NVTEVT_CB_EMR_COMPLETED, 2, id, event_id);
|
|
}
|
|
break;
|
|
|
|
case MOVIE_USER_CB_EVENT_CARSH_FILE_COMPLETED: {
|
|
CHAR *pFileName = (CHAR *) value;
|
|
if (pFileName) {
|
|
DBG_IND("crash file %s completed\r\n", pFileName);
|
|
}
|
|
Ux_PostEvent(NVTEVT_CB_EMR_COMPLETED, 2, id, event_id);
|
|
}
|
|
break;
|
|
|
|
case MOVIE_USER_CB_EVENT_PREV_CARSH_FILE_COMPLETED: {
|
|
CHAR *pFileName = (CHAR *) value;
|
|
if (pFileName) {
|
|
DBG_IND("prev crash file %s completed\r\n", pFileName);
|
|
}
|
|
Ux_PostEvent(NVTEVT_CB_EMR_COMPLETED, 2, id, event_id);
|
|
}
|
|
break;
|
|
|
|
case MOVIE_USER_CB_EVENT_CLOSE_FILE_COMPLETED: {
|
|
#if USE_FILEDB
|
|
DBG_IND(" ===== MOVIE_USER_CB_EVENT_CLOSE_FILE_COMPLETED ===== \r\n");
|
|
CHAR *p_ext_name = (CHAR *) value;
|
|
if (strcmp(p_ext_name, "JPG") == 0 || strcmp(p_ext_name, "jpg") == 0){
|
|
DBG_DUMP("Rawenc Completed\r\n");
|
|
raw_enc_path &= ~(1 << id);
|
|
if (!raw_enc_path) {
|
|
g_bAllowRawEnc = TRUE;
|
|
}
|
|
}
|
|
|
|
#elif USE_DCF
|
|
// MOVIEMULTI_CLOSE_FILE_INFO *info = (MOVIEMULTI_CLOSE_FILE_INFO *)value;
|
|
// DCF_AddDBfile(info->path);
|
|
// DBG_DUMP("%s added to DCF\r\n", info->path);
|
|
#if HUNTING_CAMERA_MCU == ENABLE
|
|
DBG_IND(" ===== MOVIE_USER_CB_EVENT_CLOSE_FILE_COMPLETED ===== id:%d \r\n", id);
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
if((SF_CAM_MODE_PHOTO_VIDEO == puiPara->CamMode) && (id == _CFG_REC_ID_1))
|
|
{
|
|
if(SUCCESS == sf_share_mem_file_down(0, 0)){
|
|
sf_set_send_statu(TRUE);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#endif
|
|
}
|
|
Ux_PostEvent(NVTEVT_CB_MOVIE_REC_FINISH, 1, value);
|
|
break;
|
|
|
|
case MOVIE_USER_CB_EVENT_CLOSE_RESULT: {
|
|
if (value == MOVREC_EVENT_RESULT_NORMAL) {
|
|
// normal stop
|
|
DBG_IND("EVENT 0x%08x: REC_FILE_COMPLETED!\r\n", event_id);
|
|
#if (SENSOR_INSERT_MASK != 0 || defined(_NVT_ETHREARCAM_RX_))
|
|
UINT32 i;
|
|
for (i=0; i<SENSOR_CAPS_COUNT; i++){
|
|
if (ImageApp_MovieMulti_IsStreamRunning(gMovie_Rec_Info[i].rec_id)){
|
|
return;
|
|
}
|
|
}
|
|
#endif
|
|
#if(defined(_NVT_ETHREARCAM_RX_))
|
|
UINT32 j;
|
|
for (j=0; j<ETH_REARCAM_CAPS_COUNT; j++){
|
|
if (ImageApp_MovieMulti_IsStreamRunning(_CFG_ETHCAM_ID_1+j)){
|
|
return;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
Ux_PostEvent(NVTEVT_CB_MOVIE_REC_FINISH, 1, value);
|
|
} else if (value == MOVREC_EVENT_RESULT_WRITE_ERR) {
|
|
// write error
|
|
DBG_ERR("EVENT %d: HW error!\r\n", event_id);
|
|
Ux_PostEvent(NVTEVT_CB_MOVIE_WR_ERROR, 0);
|
|
} else if (value == MOVREC_EVENT_LOOPREC_FULL) {
|
|
// loop record full
|
|
DBG_ERR("EVENT 0x%08x: looprec full!\r\n", event_id);
|
|
} else if (value == MOVREC_EVENT_RESULT_SLOW) {
|
|
// slow
|
|
// do nothing due to restart flow in controlled by MOVIE_USER_CB_ERROR_CARD_SLOW callback messge.
|
|
DBG_ERR("EVENT 0x%08x: Slow card!\r\n", event_id);
|
|
} else if (value == MOVREC_EVENT_RESULT_FULL) {
|
|
DBG_IND("EVENT 0x%08x: REC_FILE_COMPLETED!\r\n", event_id);
|
|
// card full
|
|
DBG_ERR("EVENT %d: Full!\r\n", event_id);
|
|
Ux_PostEvent(NVTEVT_CB_MOVIE_FULL, 0);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case MOVIE_USER_CB_EVENT_RAWENC_PREPARED: {
|
|
#if (USE_EXIF == ENABLE)
|
|
EXIF_HANDLE_ID HandleID;
|
|
HandleID = value;
|
|
ExifVendor_Write0thIFD(HandleID);
|
|
ExifVendor_WriteExifIFD(HandleID);
|
|
ExifVendor_Write0thIntIFD(HandleID);
|
|
#endif
|
|
}
|
|
break;
|
|
|
|
case MOVIE_USER_CB_EVENT_CARD_FULL: {
|
|
CHAR *pFileName = (CHAR *) value;
|
|
DBG_ERR("card full, pFileName %s\r\n", pFileName);
|
|
Ux_PostEvent(NVTEVT_CB_MOVIE_FULL, 0);
|
|
}
|
|
break;
|
|
|
|
case MOVIE_USER_CB_EVENT_JENC_PREPARED: {
|
|
MOVIE_IMGCAP_INFO *ptr = (MOVIE_IMGCAP_INFO *)value;
|
|
//MovieStamp_EncodeStampEn(HD_GET_OUT(ImageApp_MovieMulti_GetRawEncPort(ptr->path_id)) - 1, STAMP_ALL, (ptr->type == MOVIE_IMGCAP_RAWENC) ? ENABLE : DISABLE);
|
|
MovieStamp_EncodeStampEn(ptr->path_id, STAMP_ALL, (ptr->type == MOVIE_IMGCAP_RAWENC) ? ENABLE : DISABLE);
|
|
//MovieStamp_EncodeStampEn(ptr->path_id, STAMP_ALL, (ptr->type+1) );
|
|
break;
|
|
}
|
|
|
|
case MOVIE_USER_CB_EVENT_JENC_DONE:{
|
|
|
|
MOVIE_JPEG_INFO *ptr = (MOVIE_JPEG_INFO*)value;
|
|
|
|
if(ptr->sign == MAKEFOURCC('T', 'H', 'U', 'M')){
|
|
|
|
char* thumb_current_path = NULL;
|
|
|
|
if(id == _CFG_REC_ID_1){
|
|
thumb_current_path = thumb_current_path_main;
|
|
}
|
|
else if(id == _CFG_CLONE_ID_1){
|
|
thumb_current_path = thumb_current_path_clone;
|
|
}
|
|
|
|
if(thumb_current_path){
|
|
|
|
UINT32 length = strlen(thumb_current_path);
|
|
|
|
if(length){
|
|
|
|
char tmp[256] = {'\0'};
|
|
|
|
|
|
#if HUNTING_CAMERA_MCU == ENABLE
|
|
snprintf(tmp, sizeof(tmp), "%s%s", MOVIE_THUMB_PATH, thumb_current_path); /* DCF 8.3 naming rule */
|
|
#else
|
|
snprintf(tmp, sizeof(tmp), "%s%s", MOVIE_THUMB_PATH, (thumb_current_path + (length - 12))); /* DCF 8.3 naming rule */
|
|
snprintf(tmp + strlen(tmp) - 3, sizeof(tmp), "%s", "JPG");
|
|
#endif
|
|
|
|
DBG_DUMP("%s:%d MOVIE_USER_CB_EVENT_JENC_DONE %s\n", __FUNCTION__, __LINE__, tmp);
|
|
|
|
FST_FILE fp = FileSys_OpenFile(tmp, FST_OPEN_ALWAYS | FST_OPEN_WRITE);
|
|
|
|
FileSys_WriteFile(fp, (UINT8*)ptr->addr_va, &ptr->size, 0, NULL);
|
|
FileSys_CloseFile(fp);
|
|
thumb_current_path[0] = '\0';
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
#if(defined(_NVT_ETHREARCAM_RX_))
|
|
case MOVIE_USRR_CB_EVENT_TRIGGER_ETHCAM_THUMB:{
|
|
UINT32 i;
|
|
for (i = 0; i < ETH_REARCAM_CAPS_COUNT; i++) {
|
|
if (EthCamNet_GetEthLinkStatus(i) == ETHCAM_LINK_UP) {
|
|
if (id == (_CFG_ETHCAM_ID_1 + i)) {
|
|
if (i == 0) {
|
|
AppBKW_SetData(BKW_ETHCAM_TRIGGER_THUMB_PATHID_P0, id);
|
|
} else {
|
|
AppBKW_SetData(BKW_ETHCAM_TRIGGER_THUMB_PATHID_P1, id);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//AppBKW_SetData(BKW_ETHCAM_TRIGGER_THUMB_PATHID, path_id);
|
|
BKG_PostEvent(NVTEVT_BKW_TRIGGER_THUMB);
|
|
}
|
|
break;
|
|
#endif
|
|
#if (MOVIE_UVAC_FUNC == ENABLE)
|
|
case MOVIE_USER_CB_EVENT_UVAC: {
|
|
if (value == ENABLE) {
|
|
#if (SENSOR_CAPS_COUNT == 3)
|
|
ImageApp_MovieMulti_ImgLinkForUVAC(_CFG_REC_ID_1, ENABLE, TRUE);
|
|
ImageApp_MovieMulti_ImgLinkForUVAC(_CFG_REC_ID_2, ENABLE, TRUE);
|
|
ImageApp_MovieMulti_ImgLinkForUVAC(_CFG_REC_ID_3, ENABLE, TRUE);
|
|
#elif (SENSOR_CAPS_COUNT == 2)
|
|
ImageApp_MovieMulti_ImgLinkForUVAC(_CFG_REC_ID_1, ENABLE, TRUE);
|
|
if (System_GetEnableSensor() == (SENSOR_1 | SENSOR_2)){
|
|
ImageApp_MovieMulti_ImgLinkForUVAC(_CFG_REC_ID_2, ENABLE, TRUE);
|
|
}else if (System_GetEnableSensor() == SENSOR_1 ){
|
|
ImageApp_MovieMulti_ImgLinkForUVAC(_CFG_REC_ID_2, DISABLE, TRUE);
|
|
}
|
|
#else
|
|
ImageApp_MovieMulti_ImgLinkForUVAC(_CFG_REC_ID_1, ENABLE, TRUE);
|
|
#endif
|
|
ImageApp_MovieMulti_UvacStart(_CFG_UVAC_ID_1);
|
|
} else {
|
|
ImageApp_MovieMulti_UvacStop(_CFG_UVAC_ID_1);
|
|
#if (SENSOR_CAPS_COUNT == 3)
|
|
ImageApp_MovieMulti_ImgLinkForUVAC(_CFG_REC_ID_1, DISABLE, TRUE);
|
|
ImageApp_MovieMulti_ImgLinkForUVAC(_CFG_REC_ID_2, DISABLE, TRUE);
|
|
ImageApp_MovieMulti_ImgLinkForUVAC(_CFG_REC_ID_3, DISABLE, TRUE);
|
|
#elif (SENSOR_CAPS_COUNT == 2)
|
|
ImageApp_MovieMulti_ImgLinkForUVAC(_CFG_REC_ID_1, DISABLE, TRUE);
|
|
if (System_GetEnableSensor() == (SENSOR_1 | SENSOR_2)){
|
|
ImageApp_MovieMulti_ImgLinkForUVAC(_CFG_REC_ID_2, DISABLE, TRUE);
|
|
}
|
|
#else
|
|
ImageApp_MovieMulti_ImgLinkForUVAC(_CFG_REC_ID_1, DISABLE, TRUE);
|
|
#endif
|
|
}
|
|
break;
|
|
}
|
|
#endif
|
|
|
|
#if _TODO
|
|
case MOVIE_USER_CB_EVENT_FILE_DELETED: {
|
|
CHAR *p_path = (CHAR *) value;
|
|
if (NULL != p_path) {
|
|
DBG_IND("^R %s deleted\r\n", p_path);
|
|
}
|
|
}
|
|
break;
|
|
#endif
|
|
}
|
|
}
|
|
void MovieExe_TriggerPIMResultManual(UINT32 value)
|
|
{
|
|
//NMI_IMGCAP_JPG jpg={0};
|
|
//jpg.thumb=FALSE;
|
|
//MovieExe_UserEventCb(0, MOVIE_USER_CB_EVENT_SNAPSHOT_OK, (UINT32)&jpg);
|
|
MovieExe_UserEventCb(0, MOVIE_USER_CB_EVENT_SNAPSHOT_OK, 0);
|
|
}
|
|
|
|
static void MovieExe_SetRecInfoByUISetting(void)
|
|
{
|
|
UINT32 movie_size_idx, size_idx = 0;
|
|
UINT32 movie_aspect_ratio_idx = 0;
|
|
UINT32 i, rec_type;
|
|
UINT32 mask, ipl_id = 0, setting_count = 0;
|
|
UINT32 movie_rec_mask;//, clone_rec_mask;
|
|
|
|
movie_size_idx = UI_GetData(FL_MOVIE_SIZE);
|
|
rec_type = MovieMapping_GetRecType(movie_size_idx);
|
|
|
|
movie_rec_mask = SENSOR_ALL; //All ImagePipe must be initialized first, but they isn't running state
|
|
//clone_rec_mask = SENSOR_ALL;
|
|
|
|
mask = 1;
|
|
for (i = 0; i < SENSOR_CAPS_COUNT; i++) {
|
|
|
|
if (rec_type == MOVIE_REC_TYPE_FRONT || rec_type == MOVIE_REC_TYPE_CLONE) { // single recording
|
|
if (movie_rec_mask & mask) { // active sensor, for movie recording
|
|
ipl_id = 0; // get data from the mapping table of single recording, so IPL ID = 0
|
|
size_idx = movie_size_idx;
|
|
}
|
|
} else if (rec_type == MOVIE_REC_TYPE_DUAL) { // dual recording
|
|
if ((movie_rec_mask & mask) && (setting_count < 2)) { // active sensor, for movie recording
|
|
#if (SENSOR_CAPS_COUNT >=2)//CID 129679
|
|
if (setting_count == 0) { // 1st active sensor
|
|
ipl_id = 0; // get data from the mapping table of dual recording, 1st IPL ID = 0
|
|
} else { // 2nd active sensor
|
|
ipl_id = 1; // get data from the mapping table of dual recording, 2nd IPL ID = 1
|
|
}
|
|
#else
|
|
ipl_id = 0; // get data from the mapping table of dual recording, 1st IPL ID = 0
|
|
#endif
|
|
size_idx = movie_size_idx;
|
|
setting_count++;
|
|
}
|
|
} else if (rec_type == MOVIE_REC_TYPE_TRI) { // tri recording
|
|
if ((movie_rec_mask & mask) && (setting_count < 3)) { // active sensor, for movie recording
|
|
if (setting_count == 0) { // 1st active sensor
|
|
ipl_id = 0; // get data from the mapping table of tri recording, 1st IPL ID = 0
|
|
} else if (setting_count == 1) { // 2nd active sensor
|
|
ipl_id = 1; // get data from the mapping table of tri recording, 2nd IPL ID = 1
|
|
} else { // 3rd active sensor
|
|
ipl_id = 2; // get data from the mapping table of tri recording, 3rd IPL ID = 2
|
|
}
|
|
size_idx = movie_size_idx;
|
|
setting_count++;
|
|
}
|
|
} else { // quad recording
|
|
ipl_id = i;
|
|
size_idx = movie_size_idx;
|
|
}
|
|
|
|
// set main movie
|
|
gMovie_Rec_Info[i].size.w = MovieMapping_GetWidth(size_idx, ipl_id);
|
|
gMovie_Rec_Info[i].size.h = MovieMapping_GetHeight(size_idx, ipl_id);
|
|
gMovie_Rec_Info[i].raw_enc_size.w = MovieMapping_GetWidth(size_idx, ipl_id);
|
|
gMovie_Rec_Info[i].raw_enc_size.h = MovieMapping_GetHeight(size_idx, ipl_id);
|
|
gMovie_Rec_Info[i].frame_rate = MovieMapping_GetFrameRate(size_idx, ipl_id);
|
|
gMovie_Rec_Info[i].target_bitrate = MovieMapping_GetTargetBitrate(size_idx, ipl_id);
|
|
gMovie_Rec_Info[i].dar = MovieMapping_GetDispAspectRatio(size_idx, ipl_id);
|
|
gMovie_Rec_Info[i].codec = (UI_GetData(FL_MOVIE_CODEC) == MOVIE_CODEC_H265)?_CFG_CODEC_H265:_CFG_CODEC_H264;
|
|
//#NT#2018/02/14#KCHong -begin
|
|
//#NT#support sensor rotate setting
|
|
gMovie_Rec_Info[i].sensor_rotate = (UI_GetData(FL_MOVIE_SENSOR_ROTATE) == SEN_ROTATE_ON) ? TRUE : FALSE;
|
|
//#NT#2018/02/14#KCHong -end
|
|
MovieMapping_GetAqInfo(size_idx, ipl_id, (UINT32)&gMovie_Rec_Info[i].aq_info);
|
|
MovieMapping_GetCbrInfo(size_idx, ipl_id, (UINT32)&gMovie_Rec_Info[i].cbr_info);
|
|
movie_aspect_ratio_idx = MovieMapping_GetImageRatio(size_idx, ipl_id);
|
|
|
|
switch (movie_aspect_ratio_idx) {
|
|
case IMAGERATIO_16_9:
|
|
gMovie_Rec_Info[i].ratio.w = 16;
|
|
gMovie_Rec_Info[i].ratio.h = 9;
|
|
gMovie_Rec_Info[i].disp_ratio.w = 16;
|
|
gMovie_Rec_Info[i].disp_ratio.h = 9;
|
|
break;
|
|
default:
|
|
gMovie_Rec_Info[i].ratio.w = 4;
|
|
gMovie_Rec_Info[i].ratio.h = 3;
|
|
gMovie_Rec_Info[i].disp_ratio.w = 4;
|
|
gMovie_Rec_Info[i].disp_ratio.h = 3;
|
|
break;
|
|
}
|
|
|
|
// set clone movie
|
|
if (rec_type == MOVIE_REC_TYPE_CLONE) {
|
|
gMovie_Clone_Info[i].size.w = MovieMapping_GetCloneWidth(size_idx, ipl_id);
|
|
gMovie_Clone_Info[i].size.h = MovieMapping_GetCloneHeight(size_idx, ipl_id);
|
|
gMovie_Clone_Info[i].raw_enc_size.w = MovieMapping_GetCloneWidth(size_idx, ipl_id);
|
|
gMovie_Clone_Info[i].raw_enc_size.h = MovieMapping_GetCloneHeight(size_idx, ipl_id);
|
|
gMovie_Clone_Info[i].frame_rate = MovieMapping_GetCloneFrameRate(size_idx, ipl_id);
|
|
gMovie_Clone_Info[i].target_bitrate = MovieMapping_GetCloneTargetBitrate(size_idx, ipl_id);
|
|
gMovie_Clone_Info[i].dar = MovieMapping_GetCloneDispAspectRatio(size_idx, ipl_id);
|
|
gMovie_Clone_Info[i].codec = (UI_GetData(FL_MOVIE_CODEC) == MOVIE_CODEC_H265) ? _CFG_CODEC_H265 : _CFG_CODEC_H264;
|
|
MovieMapping_GetCloneAqInfo(size_idx, ipl_id, (UINT32)&gMovie_Clone_Info[i].aq_info);
|
|
MovieMapping_GetCloneCbrInfo(size_idx, ipl_id, (UINT32)&gMovie_Clone_Info[i].cbr_info);
|
|
movie_aspect_ratio_idx = MovieMapping_GetCloneImageRatio(size_idx, ipl_id);
|
|
|
|
switch (movie_aspect_ratio_idx) {
|
|
case IMAGERATIO_16_9:
|
|
gMovie_Clone_Info[i].ratio.w = 16;
|
|
gMovie_Clone_Info[i].ratio.h = 9;
|
|
gMovie_Clone_Info[i].disp_ratio.w = 16;
|
|
gMovie_Clone_Info[i].disp_ratio.h = 9;
|
|
break;
|
|
default:
|
|
gMovie_Clone_Info[i].ratio.w = 4;
|
|
gMovie_Clone_Info[i].ratio.h = 3;
|
|
gMovie_Clone_Info[i].disp_ratio.w = 4;
|
|
gMovie_Clone_Info[i].disp_ratio.h = 3;
|
|
break;
|
|
}
|
|
}
|
|
|
|
mask <<= 1;
|
|
}
|
|
}
|
|
|
|
static void MovieExe_InitAlgFunc(void)
|
|
{
|
|
UINT32 i;
|
|
|
|
// start alg image path
|
|
for (i = 0; i < SENSOR_CAPS_COUNT; i++) {
|
|
if (gMovie_Alg_Info[_CFG_REC_ID_1 + i].path13.ImgSize.w && gMovie_Alg_Info[_CFG_REC_ID_1 + i].path13.ImgSize.h) {
|
|
ImageApp_MovieMulti_ImgLinkForAlg((_CFG_REC_ID_1 + i), _CFG_ALG_PATH3, ENABLE, TRUE);
|
|
}
|
|
if (gMovie_Alg_Info[_CFG_REC_ID_1 + i].path14.ImgSize.w && gMovie_Alg_Info[_CFG_REC_ID_1 + i].path14.ImgSize.h) {
|
|
ImageApp_MovieMulti_ImgLinkForAlg((_CFG_REC_ID_1 + i), _CFG_ALG_PATH4, ENABLE, TRUE);
|
|
}
|
|
}
|
|
|
|
#if (_BOARD_DRAM_SIZE_ > 0x04000000)
|
|
// install alg functions here
|
|
MovieAlgFunc_MD_InstallID();
|
|
|
|
#if MOVIE_AI_DEMO
|
|
MovieAlgFunc_AI2_InstallID();
|
|
#endif
|
|
|
|
#endif
|
|
}
|
|
|
|
static void MovieExe_UninitAlgFunc(void)
|
|
{
|
|
UINT32 i;
|
|
#if (_BOARD_DRAM_SIZE_ > 0x04000000)
|
|
// uninstall alg functions here
|
|
MovieAlgFunc_MD_UninstallID();
|
|
|
|
#if MOVIE_AI_DEMO
|
|
MovieAlgFunc_AI2_UninstallID();
|
|
#endif
|
|
|
|
#endif
|
|
|
|
// stop alg image path
|
|
for (i = 0; i < SENSOR_CAPS_COUNT; i++) {
|
|
if (gMovie_Alg_Info[_CFG_REC_ID_1 + i].path13.ImgSize.w && gMovie_Alg_Info[_CFG_REC_ID_1 + i].path13.ImgSize.h) {
|
|
ImageApp_MovieMulti_ImgLinkForAlg((_CFG_REC_ID_1 + i), _CFG_ALG_PATH3, DISABLE, TRUE);
|
|
}
|
|
if (gMovie_Alg_Info[_CFG_REC_ID_1 + i].path14.ImgSize.w && gMovie_Alg_Info[_CFG_REC_ID_1 + i].path14.ImgSize.h) {
|
|
ImageApp_MovieMulti_ImgLinkForAlg((_CFG_REC_ID_1 + i), _CFG_ALG_PATH4, DISABLE, TRUE);
|
|
}
|
|
}
|
|
}
|
|
|
|
#if (SENSOR_INSERT_FUNCTION == ENABLE)
|
|
HD_RESULT MovieExe_DetSensor(BOOL *plug)
|
|
{
|
|
HD_RESULT result;
|
|
HD_PATH_ID path_id = 0;
|
|
|
|
#if (SENSOR_INSERT_MASK == SENSOR_1)
|
|
path_id = ImageApp_MovieMulti_GetVcapCtrlPort(_CFG_REC_ID_1);
|
|
#elif (SENSOR_INSERT_MASK == SENSOR_2)
|
|
path_id = ImageApp_MovieMulti_GetVcapCtrlPort(_CFG_REC_ID_2);
|
|
#elif (SENSOR_INSERT_MASK == SENSOR_3)
|
|
path_id = ImageApp_MovieMulti_GetVcapCtrlPort(_CFG_REC_ID_3);
|
|
#endif
|
|
result = vendor_videocap_get(path_id, VENDOR_VIDEOCAP_PARAM_GET_PLUG, plug);
|
|
|
|
return result;
|
|
}
|
|
#endif
|
|
UINT32 MovieExe_GetCommonMemInitFinish(void)
|
|
{
|
|
return gMovie_InitCommonMemFinish;
|
|
}
|
|
|
|
#if(UVC_MULTIMEDIA_FUNC == ENABLE)
|
|
#include "USBCDC.h"
|
|
static BOOL CdcPstnReqCB(CDC_COM_ID ComID, UINT8 Code, UINT8 *pData, UINT32 *pDataLen)
|
|
{
|
|
BOOL bSupported = TRUE;
|
|
CDCLineCoding LineCoding;
|
|
|
|
switch (Code) {
|
|
case REQ_GET_LINE_CODING: {
|
|
//DBG_DUMP("Get Line Coding\r\n");
|
|
LineCoding.uiBaudRateBPS = 115200;
|
|
LineCoding.uiCharFormat = 0;//CDC_LINEENCODING_OneStopBit;
|
|
LineCoding.uiParityType = 0;//CDC_PARITY_None;
|
|
LineCoding.uiDataBits = 8;
|
|
*pDataLen = sizeof(LineCoding);
|
|
memcpy(pData, &LineCoding, *pDataLen);
|
|
break;
|
|
}
|
|
|
|
case REQ_SET_LINE_CODING: {
|
|
if (*pDataLen == sizeof(LineCoding)) {
|
|
memcpy(&LineCoding, pData, *pDataLen);
|
|
} else {
|
|
bSupported = FALSE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case REQ_SET_CONTROL_LINE_STATE: {
|
|
if (*(UINT16 *)pData == 0x3) { //console ready
|
|
}
|
|
break;
|
|
}
|
|
|
|
default: {
|
|
bSupported = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
return bSupported;
|
|
}
|
|
#endif
|
|
|
|
INT32 MovieExe_OnOpen(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
|
|
{
|
|
UINT32 i;
|
|
|
|
#if defined(_NVT_ETHREARCAM_RX_)
|
|
MOVIEMULTI_MAX_LINK_INFO MaxLinkInfo = {1, 1, 1, 1, ETH_REARCAM_CAPS_COUNT}; //Img, Disp, Wifi, AudCap, EthCam
|
|
#else
|
|
MOVIEMULTI_MAX_LINK_INFO MaxLinkInfo = {1, 1, 1, 1, 0}; //Img, Disp, Wifi, AudCap, EthCam
|
|
#endif
|
|
#if USE_FILEDB
|
|
MOVIE_CFG_FDB_INFO fdb_info = {0};
|
|
UINT32 drive = 'A';
|
|
#endif
|
|
MOVIE_SENSOR_INFO sen_cfg = {0};
|
|
|
|
DBG_FUNC("\r\n");
|
|
|
|
FileSys_MakeDir(MOVIE_THUMB_PATH);
|
|
GOIO_Turn_Onoff_IRCUT(1);
|
|
|
|
Movie_CommPoolInit();
|
|
gMovie_InitCommonMemFinish=1;
|
|
#if SF_IQ_TEST == ENABLE
|
|
if((0 == access("/mnt/sd/FW98565A.bin", F_OK))){
|
|
system("rm -rf /mnt/sd/LD96565A.bin");
|
|
system("rm -rf /mnt/sd/FW98565A.bin");
|
|
system("sync");
|
|
usleep(100*1000);
|
|
}
|
|
#endif
|
|
MovieExe_SetRecInfoByUISetting();
|
|
|
|
gMovie_Disp_Info.vout_ctrl = GxVideo_GetDeviceCtrl(DOUT1,DISPLAY_DEVCTRL_CTRLPATH);
|
|
gMovie_Disp_Info.vout_path = GxVideo_GetDeviceCtrl(DOUT1,DISPLAY_DEVCTRL_PATH);
|
|
gMovie_Disp_Info.ratio = GxVideo_GetDeviceAspect(0);
|
|
gMovie_Disp_Info.dir = SysVideo_GetDirbyID(0);
|
|
|
|
HD_VIDEOOUT_SYSCAPS syscap;
|
|
hd_videoout_get(gMovie_Disp_Info.vout_ctrl, HD_VIDEOOUT_PARAM_SYSCAPS, &syscap);
|
|
|
|
DBG_DUMP("output_dim = {%lu, %lu} input_dim = {%lu, %lu}\n",
|
|
syscap.output_dim.w, syscap.output_dim.h,
|
|
syscap.input_dim.w, syscap.input_dim.h
|
|
);
|
|
|
|
|
|
//MaxLinkInfo.MaxImgLink = Movie_GetImageRecCount();
|
|
MaxLinkInfo.MaxImgLink = SENSOR_CAPS_COUNT;
|
|
ImageApp_MovieMulti_Config(MOVIE_CONFIG_MAX_LINK_INFO, (UINT32) &MaxLinkInfo);
|
|
|
|
//MOVIE_AD_MAP Movie_AD_Sensor_Map[SENSOR_CAPS_COUNT] = {{_CFG_REC_ID_1, 0 ,HD_VIDEOCAP_0 }, { _CFG_REC_ID_2, 0, HD_VIDEOCAP_1}, {_CFG_REC_ID_3, ((1<<8)| 0), HD_VIDEOCAP_2}};
|
|
for (i = 0; i < SENSOR_CAPS_COUNT; i++) {
|
|
#if (SHDR_FUNC == ENABLE)
|
|
MOVIE_RECODE_INFO info_hdr;
|
|
memcpy((void *)&info_hdr, (void *)&gMovie_Rec_Info[i], sizeof(MOVIE_RECODE_INFO));
|
|
if (UI_GetData(FL_MOVIE_HDR) == MOVIE_HDR_OFF) {
|
|
info_hdr.vcap_func &= ~HD_VIDEOCAP_FUNC_SHDR;
|
|
info_hdr.vproc_func &= ~HD_VIDEOPROC_FUNC_SHDR;
|
|
}
|
|
ImageApp_MovieMulti_Config(MOVIE_CONFIG_RECORD_INFO, (UINT32)&info_hdr);
|
|
#else // (SHDR_FUNC == ENABLE)
|
|
ImageApp_MovieMulti_Config(MOVIE_CONFIG_RECORD_INFO, (UINT32)&gMovie_Rec_Info[i]);
|
|
#endif // (SHDR_FUNC == ENABLE)
|
|
ImageApp_MovieMulti_Config(MOVIE_CONFIG_RECORD_INFO, (UINT32)&gMovie_Clone_Info[i]);
|
|
ImageApp_MovieMulti_Config(MOVIE_CONFIG_ALG_INFO, (UINT32)&gMovie_Alg_Info[i]);
|
|
// get sensor info
|
|
sen_cfg.rec_id = _CFG_REC_ID_1 + i;
|
|
System_GetSensorInfo(i, SENSOR_DRV_CFG, &(sen_cfg.vcap_cfg));
|
|
System_GetSensorInfo(i, SENSOR_SENOUT_FMT, &(sen_cfg.senout_pxlfmt));
|
|
System_GetSensorInfo(i, SENSOR_CAPOUT_FMT, &(sen_cfg.capout_pxlfmt));
|
|
System_GetSensorInfo(i, SENSOR_DATA_LANE, &(sen_cfg.data_lane));
|
|
System_GetSensorInfo(i, SENSOR_AE_PATH, &(sen_cfg.ae_path));
|
|
System_GetSensorInfo(i, SENSOR_AWB_PATH, &(sen_cfg.awb_path));
|
|
System_GetSensorInfo(i, SENSOR_IQ_PATH, &(sen_cfg.iq_path));
|
|
System_GetSensorInfo(i, SENSOR_IQ_SHADING_PATH, &(sen_cfg.iq_shading_path));
|
|
System_GetSensorInfo(i, SENSOR_IQ_DPC_PATH, &(sen_cfg.iq_dpc_path));
|
|
System_GetSensorInfo(i, SENSOR_IQ_LDC_PATH, &(sen_cfg.iq_ldc_path));
|
|
#if (SHDR_FUNC == ENABLE)
|
|
if (UI_GetData(FL_MOVIE_HDR) == MOVIE_HDR_OFF) {
|
|
sen_cfg.vcap_cfg.sen_cfg.shdr_map = 0;
|
|
if ((HD_VIDEO_PXLFMT_CLASS(sen_cfg.capout_pxlfmt) == HD_VIDEO_PXLFMT_CLASS_RAW) && (HD_VIDEO_PXLFMT_PLANE(sen_cfg.capout_pxlfmt) != 1)) {
|
|
sen_cfg.capout_pxlfmt &= ~HD_VIDEO_PXLFMT_PLANE_MASK;
|
|
sen_cfg.capout_pxlfmt |= (1 << 24);
|
|
}
|
|
}
|
|
#endif // (SHDR_FUNC == ENABLE)
|
|
ImageApp_MovieMulti_Config(MOVIE_CONFIG_SENSOR_INFO, (UINT32)&sen_cfg);
|
|
|
|
//ImageApp_MovieMulti_Config(MOVIE_CONFIG_AD_MAP, (UINT32)&Movie_AD_Sensor_Map[i]);
|
|
|
|
#if (MOVIE_IME_CROP == ENABLE)
|
|
MovieExe_SetIMECrop(i);
|
|
#endif
|
|
}
|
|
|
|
MovieMapping_GetStreamInfo(UI_GetData(FL_MOVIE_SIZE), (UINT32) &gMovie_Strm_Info);
|
|
|
|
DBG_DUMP("****** gMovie_Strm_Info {%lu, %lu}", gMovie_Strm_Info.size.w, gMovie_Strm_Info.size.h);
|
|
|
|
ImageApp_MovieMulti_Config(MOVIE_CONFIG_STREAM_INFO, (UINT32)&gMovie_Strm_Info);
|
|
ImageApp_MovieMulti_Config(MOVIE_CONFIG_AUDIO_INFO, (UINT32)&gMovie_Audio_Info);
|
|
ImageApp_MovieMulti_Config(MOVIE_CONFIG_DISP_INFO, (UINT32)&gMovie_Disp_Info);
|
|
|
|
// File option
|
|
ImageApp_MovieMulti_FileOption((MOVIE_RECODE_FILE_OPTION *) &gMovie_Rec_Option);
|
|
|
|
// User Callback
|
|
ImageApp_MovieMulti_RegUserCB(MovieExe_UserEventCb);
|
|
|
|
ImageApp_MovieMulti_SetParam(_CFG_CTRL_ID, MOVIEMULTI_PARAM_FILE_UTC_AUTO_EN, TRUE);
|
|
|
|
//ImageApp_MovieMulti_SetParam(_CFG_DISP_ID_1, MOVIEMULTI_PARAM_DISP_REG_CB, (UINT32)MovieExe_DispCB);
|
|
ImageApp_MovieMulti_SetParam(_CFG_STRM_ID_1, MOVIEMULTI_PARAM_WIFI_REG_CB, (UINT32)MovieExe_WifiCB);
|
|
ImageApp_MovieMulti_SetParam(_CFG_DISP_ID_1, MOVIEMULTI_PARAM_DISP_REG_CB, (UINT32)MovieExe_PipCB);
|
|
|
|
#if (MOVIE_DIRECT_FUNC == ENABLE)
|
|
ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1, MOVIEMULTI_PARAM_VCAP_OUTFUNC, HD_VIDEOCAP_OUTFUNC_DIRECT);
|
|
#endif
|
|
|
|
#if (MOVIE_YUV_COMPRESS == ENABLE)
|
|
ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1, MOVIEMULTI_PARAM_YUV_COMPRESS, TRUE);
|
|
ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1, MOVIEMULTI_PARAM_IMGCAP_SOUT_BUF_TYPE, MOVIE_IMGCAP_SOUT_NONE);
|
|
ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1, MOVIEMULTI_PARAM_IMGCAP_YUVSRC, MOVIE_IMGCAP_YUVSRC_STRM);
|
|
#endif
|
|
#if (defined(_MODEL_565_CARDV_HS880C_))
|
|
#if (MOVIE_YUV_COMPRESS == ENABLE)
|
|
ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1, MOVIEMULTI_PARAM_YUV_COMPRESS, TRUE);
|
|
ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1, MOVIEMULTI_PARAM_IMGCAP_SOUT_BUF_TYPE, MOVIE_IMGCAP_SOUT_NONE);
|
|
ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1, MOVIEMULTI_PARAM_IMGCAP_YUVSRC, MOVIE_IMGCAP_YUVSRC_STRM);
|
|
#endif
|
|
ImageApp_MovieMulti_SetParam(_CFG_REC_ID_2, MOVIEMULTI_PARAM_YUV_COMPRESS, TRUE);
|
|
ImageApp_MovieMulti_SetParam(_CFG_REC_ID_2, MOVIEMULTI_PARAM_IMGCAP_SOUT_BUF_TYPE, MOVIE_IMGCAP_SOUT_NONE);
|
|
ImageApp_MovieMulti_SetParam(_CFG_REC_ID_2, MOVIEMULTI_PARAM_IMGCAP_YUVSRC, MOVIE_IMGCAP_YUVSRC_DISP);
|
|
#endif
|
|
ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1, MOVIEMULTI_PRARM_FILEDB_MAX_MUM, 5000);
|
|
// #if (MOVIE_DIRECT_FUNC == ENABLE)//defined (_sen_ad_tp9950_)
|
|
{
|
|
MOVIEMULTI_IPL_SIZE_INFO ipl_size={{2560,1440},30};
|
|
|
|
ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1 , MOVIEMULTI_PARAM_IPL_USER_IMG_SIZE, (UINT32)&ipl_size);
|
|
ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1 , MOVIEMULTI_PARAM_IPL_FORCED_IMG_SIZE, MOVIE_IPL_SIZE_USER);
|
|
}
|
|
// #endif
|
|
|
|
#if defined(_NVT_ETHREARCAM_RX_)
|
|
ImageApp_MovieMulti_SetParam(_CFG_ETHCAM_ID_1, MOVIEMULTI_RARAM_ETHCAM_RX_FUNC_EN, TRUE);
|
|
for (i = 0; i < ETH_REARCAM_CAPS_COUNT; i++) {
|
|
|
|
#if (ETH_REARCAM_CLONE_FOR_DISPLAY == ENABLE)
|
|
if(socketCliEthData2_IsConn(i)==0){
|
|
MOVIEMULTI_ETHCAM_DEC_INFO dec_info = {
|
|
.width = ETH_WIDTH, //max size for decode
|
|
.height = ETH_HEIGHT,
|
|
.codec = (UI_GetData(FL_MOVIE_CODEC) == MOVIE_CODEC_H265)?HD_CODEC_TYPE_H265:HD_CODEC_TYPE_H264,//UI_GetData(FL_MOVIE_CODEC),//HD_CODEC_TYPE_H265,
|
|
.header_size = sizeof(EthCamH265DescDefaultAddr),
|
|
.header = EthCamH265DescDefaultAddr,
|
|
};
|
|
ImageApp_MovieMulti_SetParam((_CFG_ETHCAM_ID_1 +i), MOVIEMULTI_PRARM_ETHCAM_DEC_INFO, (UINT32)&dec_info);
|
|
}
|
|
#else
|
|
if(socketCliEthData1_IsConn(i)==0){
|
|
MOVIEMULTI_ETHCAM_DEC_INFO dec_info = {
|
|
.width = 1920, //max size for decode
|
|
.height = 1080,
|
|
.codec = (UI_GetData(FL_MOVIE_CODEC) == MOVIE_CODEC_H265)?HD_CODEC_TYPE_H265:HD_CODEC_TYPE_H264,//UI_GetData(FL_MOVIE_CODEC),//HD_CODEC_TYPE_H265,
|
|
.header_size = sizeof(EthCamH265DescDefaultAddr),
|
|
.header = EthCamH265DescDefaultAddr,
|
|
};
|
|
ImageApp_MovieMulti_SetParam((_CFG_ETHCAM_ID_1 +i), MOVIEMULTI_PRARM_ETHCAM_DEC_INFO, (UINT32)&dec_info);
|
|
}
|
|
#endif
|
|
if(socketCliEthData1_IsConn(i)==0){
|
|
MOVIEMULTI_ETHCAM_REC_INFO rec_info = {
|
|
.width = ETH_WIDTH,
|
|
.height = ETH_HEIGHT,
|
|
.vfr = 30,
|
|
.tbr = 450 * 1024,
|
|
.ar = MEDIAREC_DAR_DEFAULT,
|
|
.gop = 15,
|
|
.codec = (UI_GetData(FL_MOVIE_CODEC) == MOVIE_CODEC_H265)?_CFG_CODEC_H265:_CFG_CODEC_H264,//_CFG_CODEC_H265,
|
|
.aud_codec = ETHCAM_AUDIO_FORMAT,//_CFG_AUD_CODEC_AAC,
|
|
.rec_mode = _CFG_REC_TYPE_AV,
|
|
.rec_format = ETHCAM_FILE_FORMAT,//_CFG_FILE_FORMAT_MP4,
|
|
.buf_pa = 0,
|
|
.buf_size = 0,
|
|
};
|
|
ImageApp_MovieMulti_SetParam((_CFG_ETHCAM_ID_1 +i), MOVIEMULTI_PRARM_ETHCAM_REC_INFO, (UINT32)&rec_info);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#if (SENSOR_SIEPATGEN == ENABLE)
|
|
for (i = 0; i < SENSOR_CAPS_COUNT; i++) {
|
|
ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1 + i, MOVIEMULTI_PARAM_VCAP_PAT_GEN, HD_VIDEOCAP_SEN_PAT_COLORBAR);
|
|
}
|
|
#endif
|
|
|
|
#if (MOVIE_UVAC_FUNC == ENABLE)
|
|
UVAC_VID_RESO_ARY uvacVidResoAry = {0};
|
|
UVAC_AUD_SAMPLERATE_ARY uvacAudSampleRateAry = {0};
|
|
|
|
ImageApp_MovieMulti_SetParam(_CFG_UVAC_ID_1, MOVIEMULTI_PRARM_UVAC_FUNC, ENABLE);
|
|
|
|
// UVC streaming size is the same as WiFi
|
|
gUIUvacVidReso[0].width = gMovie_Strm_Info.size.w;
|
|
gUIUvacVidReso[0].height = gMovie_Strm_Info.size.h;
|
|
uvacVidResoAry.aryCnt = 1;
|
|
uvacVidResoAry.pVidResAry = &gUIUvacVidReso[0];
|
|
ImageApp_MovieMulti_SetParam(_CFG_UVAC_ID_1, MOVIEMULTI_PARAM_UVAC_VID_RESO_ARY, (UINT32)&uvacVidResoAry);
|
|
|
|
gUIUvacAudSampleRate[0] = gMovie_Audio_Info.aud_rate;
|
|
uvacAudSampleRateAry.aryCnt = 1;
|
|
uvacAudSampleRateAry.pAudSampleRateAry = &gUIUvacAudSampleRate[0];
|
|
ImageApp_MovieMulti_SetParam(_CFG_UVAC_ID_1, MOVIEMULTI_PARAM_UVAC_AUD_SAMPLERATE_ARY, (UINT32)&uvacAudSampleRateAry);
|
|
|
|
xUSBMakerInit_UVAC(&gUIMovUvacDevDesc);
|
|
ImageApp_MovieMulti_SetParam(_CFG_UVAC_ID_1, MOVIEMULTI_PARAM_UVAC_VEND_DEV_DESC, (UINT32)&gUIMovUvacDevDesc);
|
|
|
|
ImageApp_MovieMulti_SetParam(_CFG_UVAC_ID_1, MOVIEMULTI_PARAM_UVAC_VID_FMT_TYPE, (gMovie_Strm_Info.codec == _CFG_CODEC_MJPG) ? UVAC_VIDEO_FORMAT_MJPEG_ONLY : UVAC_VIDEO_FORMAT_H264_ONLY);
|
|
|
|
#if(UVC_MULTIMEDIA_FUNC == ENABLE)
|
|
ImageApp_MovieMulti_SetParam(_CFG_UVAC_ID_1, MOVIEMULTI_PARAM_UVAC_CDC_EN, ENABLE);
|
|
ImageApp_MovieMulti_SetParam(_CFG_UVAC_ID_1, MOVIEMULTI_PARAM_UVAC_CDC2_EN, ENABLE);
|
|
ImageApp_MovieMulti_SetParam(_CFG_UVAC_ID_1, MOVIEMULTI_PARAM_UVAC_CDC_PSTN_REQ_CB, (UINT32)CdcPstnReqCB);
|
|
#endif
|
|
|
|
#endif //#if (MOVIE_UVAC_FUNC == ENABLE)
|
|
|
|
// set LviewNvt parameter here or will use default value
|
|
#if 0
|
|
ImageApp_Common_SetParam(0, IACOMMON_PARAM_LVIEWNVT_PORTNUM, 8192);
|
|
ImageApp_Common_SetParam(0, IACOMMON_PARAM_LVIEWNVT_THREADPRIORITY, 6);
|
|
ImageApp_Common_SetParam(0, IACOMMON_PARAM_LVIEWNVT_FRAMERATE, gMovie_Strm_Info.frame_rate);
|
|
ImageApp_Common_SetParam(0, IACOMMON_PARAM_LVIEWNVT_SOCKBUFSIZE, 102400);
|
|
ImageApp_Common_SetParam(0, IACOMMON_PARAM_LVIEWNVT_TIMEOUTCNT, 10);
|
|
ImageApp_Common_SetParam(0, IACOMMON_PARAM_LVIEWNVT_TOS, 0x0100);
|
|
#endif
|
|
|
|
#if USE_DCF
|
|
ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1, MOVIEMULTI_PARAM_FILE_USE_FILEDB, FALSE);
|
|
ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1, MOVIEMULTI_PARAM_FILE_CB_CLOSED_FILE_INFO, TRUE);
|
|
#endif
|
|
|
|
|
|
ImageApp_MovieMulti_Open();
|
|
#if 0
|
|
for (i = 0; i < SENSOR_CAPS_COUNT; i++) {
|
|
ImageApp_MovieMulti_ImgLinkForDisp(_CFG_REC_ID_1 + i, ENABLE, TRUE);
|
|
}
|
|
#else
|
|
#if (DRAM_SIZE_64MB_DISP_OFF==ENABLE)
|
|
// do nothing
|
|
#else
|
|
for (i = 0; i <(SENSOR_CAPS_COUNT& SENSOR_ON_MASK); i++) {
|
|
if (System_GetEnableSensor() & (SENSOR_1 << i)) {
|
|
ImageApp_MovieMulti_ImgLinkForDisp(_CFG_REC_ID_1 + i, ENABLE, TRUE);
|
|
} else {
|
|
ImageApp_MovieMulti_ImgLinkForDisp(_CFG_REC_ID_1 + i, DISABLE, TRUE);
|
|
}
|
|
}
|
|
#endif
|
|
#if (SENSOR_INSERT_FUNCTION == ENABLE)
|
|
System_EnableSensorDet();
|
|
#endif
|
|
#if 0
|
|
if (System_GetEnableSensor() == (SENSOR_1|SENSOR_2)) {
|
|
ImageApp_MovieMulti_ImgLinkForDisp(_CFG_REC_ID_1, ENABLE, TRUE);
|
|
ImageApp_MovieMulti_ImgLinkForDisp(_CFG_REC_ID_2, ENABLE, TRUE);
|
|
} else if (System_GetEnableSensor() == SENSOR_1) {
|
|
ImageApp_MovieMulti_ImgLinkForDisp(_CFG_REC_ID_1, ENABLE, TRUE);
|
|
ImageApp_MovieMulti_ImgLinkForDisp(_CFG_REC_ID_2, DISABLE, TRUE);
|
|
}
|
|
#endif
|
|
#endif
|
|
ImageApp_MovieMulti_DispStart(_CFG_DISP_ID_1);
|
|
// start acap function
|
|
//ImageApp_MovieMulti_AudCapStart(0);
|
|
|
|
Ux_SendEvent(&CustomMovieObjCtrl, NVTEVT_EXE_MOVIE_WDR, 1, SysGetFlag(FL_MOVIE_WDR));
|
|
//Ux_SendEvent(&CustomMovieObjCtrl, NVTEVT_EXE_SHDR, 1, UI_GetData(FL_MOVIE_HDR));
|
|
|
|
|
|
|
|
#if(defined(_NVT_ETHREARCAM_RX_))
|
|
EthCamNet_EthHubChkPortReady();
|
|
for (i=0; i<ETH_REARCAM_CAPS_COUNT; i++){
|
|
if(EthCamNet_GetEthLinkStatus(i)==ETHCAM_LINK_UP && socketCliEthCmd_IsConn(i)==0){
|
|
EthCamSocketCli_ReConnect(i, 0 ,0);
|
|
}
|
|
}
|
|
for (i=0; i<ETH_REARCAM_CAPS_COUNT; i++){
|
|
if(EthCamNet_GetEthLinkStatus(i)==ETHCAM_LINK_UP){
|
|
if(socketCliEthCmd_IsConn(i)==0){
|
|
BKG_PostEvent(NVTEVT_BKW_ETHCAM_SOCKETCLI_CMD_OPEN);
|
|
}
|
|
EthCamHB1[i] = 0;
|
|
EthCamHB2 = 0;
|
|
if(SxTimer_GetFuncActive(SX_TIMER_ETHCAM_DATARECVDET_ID)==0){
|
|
SxTimer_SetFuncActive(SX_TIMER_ETHCAM_DATARECVDET_ID, TRUE);
|
|
}
|
|
}
|
|
}
|
|
#if (ETH_REARCAM_CAPS_COUNT>=2)
|
|
if(SxTimer_GetFuncActive(SX_TIMER_ETHCAM_ETHHUB_LINKDET_ID)==0){
|
|
//DBG_DUMP("Active ETHHUB Timer\r\n");
|
|
SxTimer_SetFuncActive(SX_TIMER_ETHCAM_ETHHUB_LINKDET_ID, TRUE);
|
|
}
|
|
#endif
|
|
#endif
|
|
#if(WIFI_AP_FUNC==ENABLE)
|
|
// if (System_GetState(SYS_STATE_CURRSUBMODE) == SYS_SUBMODE_WIFI) {
|
|
// Ux_SendEvent(&CustomMovieObjCtrl, NVTEVT_EXE_MOVIE_STRM_START, 1,gMovie_Strm_Info.strm_id);
|
|
// Ux_PostEvent(NVTEVT_WIFI_EXE_MODE_DONE,1,E_OK);
|
|
// }
|
|
|
|
DBG_DUMP("****NVTEVT_EXE_MOVIE_STRM_START");
|
|
Ux_SendEvent(&CustomMovieObjCtrl, NVTEVT_EXE_MOVIE_STRM_START, 1,gMovie_Strm_Info.strm_id);
|
|
|
|
#endif
|
|
#if MOVIE_UVAC_FUNC
|
|
Ux_SendEvent(&CustomMovieObjCtrl, NVTEVT_EXE_MOVIE_UVAC_START, 0);
|
|
#endif
|
|
//#if (FS_FUNC == ENABLE)
|
|
// wait fs mount ready
|
|
// System_WaitFS();
|
|
//#endif
|
|
|
|
#if USE_FILEDB
|
|
// FileManage Config
|
|
fdb_info.drive = drive;
|
|
fdb_info.p_root_path = MOVIE_ROOT_PATH;
|
|
fdb_info.mem_range.addr = (int)mempool_filedb;
|
|
fdb_info.mem_range.size = POOL_SIZE_FILEDB;
|
|
if (0 != ImageApp_MovieMulti_FMConfig(&fdb_info)) {
|
|
DBG_ERR("FMConfig fail\r\n");
|
|
return -1;
|
|
}
|
|
ImageApp_MovieMulti_FMSetSortBySN("_", 1, 6);
|
|
|
|
for (i = 0; i < SENSOR_CAPS_COUNT; i++) {
|
|
ImageApp_MovieMulti_Root_Path(MOVIE_ROOT_PATH, gMovie_Folder_Naming[i].rec_id);
|
|
ImageApp_MovieMulti_Folder_Naming((MOVIEMULTI_RECODE_FOLDER_NAMING*)&gMovie_Folder_Naming[i]);
|
|
|
|
ImageApp_MovieMulti_Root_Path(MOVIE_ROOT_PATH, gMovie_Clone_Folder_Naming[i].rec_id);
|
|
ImageApp_MovieMulti_Folder_Naming((MOVIEMULTI_RECODE_FOLDER_NAMING*)&gMovie_Clone_Folder_Naming[i]);
|
|
}
|
|
#if defined(_NVT_ETHREARCAM_RX_)
|
|
for (i = 0; i < ETH_REARCAM_CAPS_COUNT; i++) {
|
|
ImageApp_MovieMulti_Root_Path(MOVIE_ROOT_PATH, gMovie_EthCam_Folder_Naming[i].rec_id);
|
|
ImageApp_MovieMulti_Folder_Naming((MOVIEMULTI_RECODE_FOLDER_NAMING*)&gMovie_EthCam_Folder_Naming[i]);
|
|
}
|
|
#endif
|
|
// FileManage Open
|
|
if (0 != ImageApp_MovieMulti_FMOpen(drive)) {
|
|
DBG_ERR("FMOpen fail\r\n");
|
|
return -1;
|
|
}
|
|
|
|
{
|
|
// sample code to get file serial number; assume the FileDB handle created by ImageApp is 0
|
|
PFILEDB_FILE_ATTR pFileAttr;
|
|
|
|
if (FileDB_GetTotalFileNum(0)) {
|
|
if ((pFileAttr = FileDB_CurrFile(0)) != NULL) {
|
|
g_FileSerialNum = FileDB_GetSNByName(0, pFileAttr->filename);
|
|
}
|
|
} else {
|
|
g_FileSerialNum = 0;
|
|
}
|
|
}
|
|
#endif
|
|
#if (USE_EXIF == ENABLE)
|
|
ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1, MOVIEMULTI_PARAM_IMGCAP_EXIF_EN, TRUE);
|
|
MovieExe_InitExif();
|
|
#endif
|
|
|
|
MovieExe_InitAlgFunc();
|
|
|
|
// TODO: isp test
|
|
#if 0
|
|
{
|
|
AET_DTSI_INFO ae_dtsi_info = {0};
|
|
AWBT_DTSI_INFO awb_dtsi_info = {0};
|
|
IQT_DTSI_INFO iq_dtsi_info = {0};
|
|
|
|
ae_dtsi_info.id = 0;
|
|
strncpy(ae_dtsi_info.node_path, "/isp/ae/imx290_ae_0", DTSI_NAME_LENGTH);
|
|
strncpy(ae_dtsi_info.file_path, "null", DTSI_NAME_LENGTH);
|
|
ae_dtsi_info.buf_addr = fdt_get_app();
|
|
vendor_isp_set_ae(AET_ITEM_RLD_DTSI, &ae_dtsi_info);
|
|
|
|
awb_dtsi_info.id = 0;
|
|
strncpy(awb_dtsi_info.node_path, "/isp/awb/imx290_awb_0", DTSI_NAME_LENGTH);
|
|
strncpy(awb_dtsi_info.file_path, "null", DTSI_NAME_LENGTH);
|
|
awb_dtsi_info.buf_addr = fdt_get_app();
|
|
vendor_isp_set_awb(AWBT_ITEM_RLD_DTSI, &awb_dtsi_info);
|
|
|
|
iq_dtsi_info.id = 0;
|
|
strncpy(iq_dtsi_info.node_path, "/isp/iq/imx290_iq_0", DTSI_NAME_LENGTH);
|
|
strncpy(iq_dtsi_info.file_path, "null", DTSI_NAME_LENGTH);
|
|
iq_dtsi_info.buf_addr = fdt_get_app();
|
|
vendor_isp_set_iq(IQT_ITEM_RLD_DTSI, &iq_dtsi_info);
|
|
}
|
|
#endif
|
|
//call default
|
|
Ux_DefaultEvent(pCtrl, NVTEVT_EXE_OPEN, paramNum, paramArray);
|
|
return NVTEVT_CONSUME;
|
|
}
|
|
|
|
INT32 MovieExe_OnClose(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
|
|
{
|
|
#if USE_FILEDB
|
|
UINT32 drive = 'A';
|
|
#endif
|
|
DBG_FUNC("\r\n");
|
|
#if (SENSOR_INSERT_FUNCTION == ENABLE)
|
|
System_DisableSensorDet();
|
|
#endif
|
|
#if defined(_NVT_ETHREARCAM_RX_)
|
|
UINT32 j;
|
|
#if (ETH_REARCAM_CAPS_COUNT==1 && ETHCAM_DISP_MAX_QUEUE)
|
|
if(g_EthCamDisp_TimerID){
|
|
timer_close(g_EthCamDisp_TimerID);
|
|
g_EthCamDisp_TimerID=0;
|
|
}
|
|
for (j=0; j<ETHCAM_DISP_MAX_QUEUE; j++){
|
|
if(g_EthCamDispQ.Queue[j].Desc[0]){
|
|
ImageUnit_ReleaseData(&g_EthCamDispQ.Queue[j]);
|
|
}
|
|
}
|
|
#endif
|
|
for (j=0; j<ETH_REARCAM_CAPS_COUNT; j++){
|
|
if(ImageApp_MovieMulti_IsStreamRunning(_CFG_ETHCAM_ID_1+ j)){
|
|
ImageApp_MovieMulti_RecStop(_CFG_ETHCAM_ID_1 + j);
|
|
}
|
|
|
|
if (System_GetState(SYS_STATE_NEXTSUBMODE) == SYS_SUBMODE_UPDFW
|
|
&& System_GetState(SYS_STATE_CURRSUBMODE) == SYS_SUBMODE_UPDFW) {
|
|
EthCamCmd_GetFrameTimerEn(0);
|
|
ImageApp_MovieMulti_EthCamLinkForDisp((_CFG_ETHCAM_ID_1 + j), DISABLE, TRUE);
|
|
EthCamSocketCli_ReConnect(j, 0, 0);
|
|
EthCamSocketCli_Close(j, ETHSOCKIPCCLI_ID_0);
|
|
EthCamSocketCli_Close(j, ETHSOCKIPCCLI_ID_1);
|
|
socketCliEthData_DestroyAllBuff(j);
|
|
break;
|
|
}else if(EthCamNet_GetEthLinkStatus(j)==ETHCAM_LINK_DOWN){
|
|
socketCliEthData_DestroyAllBuff(j);
|
|
continue;
|
|
}else{
|
|
EthCamCmd_GetFrameTimerEn(0);
|
|
#if (ETH_REARCAM_CLONE_FOR_DISPLAY == ENABLE)
|
|
socketCliEthData2_SetAllowPush(0, 0);
|
|
#endif
|
|
vos_util_delay_ms(200);//wait push in vdec
|
|
|
|
ImageApp_MovieMulti_EthCamLinkForDisp((_CFG_ETHCAM_ID_1 + j), DISABLE, TRUE);
|
|
if(socketCliEthData1_IsRecv(j)
|
|
#if (ETH_REARCAM_CLONE_FOR_DISPLAY == ENABLE)
|
|
&& socketCliEthData2_IsRecv(j)
|
|
#else
|
|
&& 0
|
|
#endif
|
|
){
|
|
EthCam_SendXMLCmd(j, ETHCAM_PORT_DEFAULT ,ETHCAM_CMD_TX_STREAM_STOP, 2);
|
|
}else{
|
|
if(socketCliEthData1_IsRecv(j)){
|
|
EthCam_SendXMLCmd(j, ETHCAM_PORT_DATA1 ,ETHCAM_CMD_TX_STREAM_STOP, 0);
|
|
}
|
|
#if (ETH_REARCAM_CLONE_FOR_DISPLAY == ENABLE)
|
|
if(socketCliEthData2_IsRecv(j)){
|
|
EthCam_SendXMLCmd(j, ETHCAM_PORT_DATA2 ,ETHCAM_CMD_TX_STREAM_STOP, 0);
|
|
}
|
|
#endif
|
|
}
|
|
if(socketCliEthCmd_IsConn(j)){
|
|
if(System_GetShutdownBegin()){
|
|
EthCam_SendXMLCmd(j, ETHCAM_PORT_DEFAULT ,ETHCAM_CMD_TX_POWEROFF, 0);
|
|
}else{
|
|
EthCam_SendXMLCmd(j, ETHCAM_PORT_DEFAULT ,ETHCAM_CMD_CHANGE_MODE, 0);
|
|
}
|
|
}
|
|
EthCamCmd_Done(j, 0xFFFFFFFF, ETHCAM_CMD_TERMINATE);
|
|
|
|
socketCliEthData1_SetRecv(j, 0);
|
|
socketCliEthData2_SetRecv(j, 0);
|
|
|
|
EthCamSocketCli_ReConnect(j, 0, 0);
|
|
EthCamSocketCli_Close(j, ETHSOCKIPCCLI_ID_0);
|
|
EthCamSocketCli_Close(j, ETHSOCKIPCCLI_ID_1);
|
|
EthCamSocketCli_Close(j, ETHSOCKIPCCLI_ID_2);
|
|
socketCliEthData_DestroyAllBuff(j);
|
|
//for next background Tsk link
|
|
EthCamNet_SetPrevEthLinkStatus(j, ETHCAM_LINK_DOWN);
|
|
}
|
|
EthCamHB1[j] = 0;
|
|
}
|
|
SxTimer_SetFuncActive(SX_TIMER_ETHCAM_DATARECVDET_ID, FALSE);
|
|
EthCamHB2 = 0;
|
|
#if (ETH_REARCAM_CAPS_COUNT>=2)
|
|
SxTimer_SetFuncActive(SX_TIMER_ETHCAM_ETHHUB_LINKDET_ID, FALSE);
|
|
#endif
|
|
#endif
|
|
// close movie recording if necessary
|
|
Ux_SendEvent(&CustomMovieObjCtrl, NVTEVT_EXE_MOVIE_REC_STOP, 0);
|
|
|
|
MovieExe_UninitAlgFunc();
|
|
MovieStamp_Disable();
|
|
MovieStamp_DestroyBuff();
|
|
ImageApp_MovieMulti_DispStop(_CFG_DISP_ID_1);
|
|
|
|
#if MOVIE_UVAC_FUNC
|
|
Ux_SendEvent(&CustomMovieObjCtrl, NVTEVT_EXE_MOVIE_UVAC_STOP, 0);
|
|
#endif
|
|
|
|
#if (0)//(SENSOR_CAPS_COUNT == 1)
|
|
ImageApp_MovieMulti_ImgLinkForDisp(_CFG_REC_ID_1, DISABLE, FALSE);
|
|
#else
|
|
UINT32 i;
|
|
for (i = 0; i < (SENSOR_CAPS_COUNT & SENSOR_ON_MASK); i++){
|
|
ImageApp_MovieMulti_ImgLinkForDisp(_CFG_REC_ID_1 + i, DISABLE, TRUE);
|
|
}
|
|
#endif
|
|
// stop acap function
|
|
//ImageApp_MovieMulti_AudCapStop(0);
|
|
|
|
#if (USE_EXIF == ENABLE)
|
|
MovieExe_UninitExif();
|
|
#endif
|
|
|
|
#if(WIFI_AP_FUNC==ENABLE)
|
|
// if (System_GetState(SYS_STATE_CURRSUBMODE) == SYS_SUBMODE_WIFI) {
|
|
Ux_SendEvent(&CustomMovieObjCtrl, NVTEVT_EXE_MOVIE_STRM_STOP, 1,gMovie_Strm_Info.strm_id);
|
|
// }
|
|
#endif
|
|
|
|
ImageApp_MovieMulti_Close();
|
|
raw_enc_path = 0;
|
|
gMovie_InitCommonMemFinish=0;
|
|
|
|
#if USE_FILEDB
|
|
// FileManage Close
|
|
if (0 != ImageApp_MovieMulti_FMClose(drive)) {
|
|
DBG_ERR("FMClose fail\r\n");
|
|
return -1;
|
|
}
|
|
#endif
|
|
//call default
|
|
Ux_DefaultEvent(pCtrl, NVTEVT_EXE_CLOSE, paramNum, paramArray);
|
|
return NVTEVT_CONSUME;
|
|
}
|
|
|
|
INT32 MovieExe_OnMovieSize(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
|
|
{
|
|
UINT32 uiSelect = 0;
|
|
|
|
if (paramNum > 0) {
|
|
uiSelect = paramArray[0];
|
|
}
|
|
|
|
DBG_DUMP("MovieExe_OnMovieSize uiSelect %d\r\n", uiSelect);
|
|
|
|
UI_SetData(FL_MOVIE_SIZE, uiSelect);
|
|
|
|
|
|
return NVTEVT_CONSUME;
|
|
}
|
|
|
|
INT32 MovieExe_OnMovieAudio(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
|
|
{
|
|
UINT32 uiSelect = 0;
|
|
|
|
if (paramNum) {
|
|
uiSelect = paramArray[0];
|
|
}
|
|
|
|
UI_SetData(FL_MOVIE_AUDIO, uiSelect);
|
|
|
|
if (uiSelect == MOVIE_AUDIO_OFF) {
|
|
// set audio mute
|
|
ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1, MOVIEMULTI_PARAM_AUD_MUTE_ENC, TRUE);
|
|
} else {
|
|
// restore audio volume
|
|
ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1, MOVIEMULTI_PARAM_AUD_MUTE_ENC, FALSE);
|
|
}
|
|
|
|
return NVTEVT_CONSUME;
|
|
}
|
|
|
|
INT32 MovieExe_OnDateImprint(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
|
|
{
|
|
UINT32 uiSelect = 0;
|
|
|
|
if (paramNum) {
|
|
uiSelect = paramArray[0];
|
|
}
|
|
|
|
UI_SetData(FL_MOVIE_DATEIMPRINT, uiSelect);
|
|
|
|
return NVTEVT_CONSUME;
|
|
}
|
|
|
|
INT32 MovieExe_OnCyclicRec(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
|
|
{
|
|
UINT32 uiSelect = 0;
|
|
UINT32 i, mask;
|
|
UINT32 movie_rec_mask, clone_rec_mask;
|
|
|
|
uiSelect = paramNum ? paramArray[0] : MOVIE_CYCLICREC_3MIN;
|
|
|
|
DBG_IND("uiSelect %d\r\n", uiSelect);
|
|
|
|
UI_SetData(FL_MOVIE_CYCLIC_REC, uiSelect);
|
|
|
|
/*switch (uiSelect) {
|
|
case MOVIE_CYCLICREC_1MIN:
|
|
gMovie_Rec_Option.seamless_sec = 60;
|
|
break;
|
|
|
|
case MOVIE_CYCLICREC_3MIN:
|
|
gMovie_Rec_Option.seamless_sec = 180;
|
|
break;
|
|
|
|
case MOVIE_CYCLICREC_5MIN:
|
|
gMovie_Rec_Option.seamless_sec = 300;
|
|
break;
|
|
|
|
case MOVIE_CYCLICREC_10MIN:
|
|
gMovie_Rec_Option.seamless_sec = 600;
|
|
break;
|
|
|
|
case MOVIE_CYCLICREC_OFF:
|
|
gMovie_Rec_Option.seamless_sec = 900;
|
|
break;
|
|
|
|
default:
|
|
gMovie_Rec_Option.seamless_sec = 300;
|
|
break;
|
|
}*/
|
|
|
|
/*Default 15s for manual shooting*/
|
|
gMovie_Rec_Option.seamless_sec = 15;
|
|
|
|
movie_rec_mask = Movie_GetMovieRecMask();
|
|
clone_rec_mask = Movie_GetCloneRecMask();
|
|
|
|
mask = 1;
|
|
for (i = 0; i < SENSOR_CAPS_COUNT; i++) {
|
|
if (movie_rec_mask & mask) {
|
|
ImageApp_MovieMulti_SetParam(gMovie_Rec_Info[i].rec_id, MOVIEMULTI_PARAM_FILE_SEAMLESSSEC, gMovie_Rec_Option.seamless_sec);
|
|
ImageApp_MovieMulti_SetParam(gMovie_Rec_Info[i].rec_id, MOVIEMULTI_PARAM_FILE_ENDTYPE, (uiSelect == MOVIE_CYCLICREC_OFF) ? MOVREC_ENDTYPE_CUT_TILLCARDFULL : MOVREC_ENDTYPE_CUTOVERLAP);
|
|
}
|
|
|
|
if (clone_rec_mask & mask) {
|
|
ImageApp_MovieMulti_SetParam(gMovie_Clone_Info[i].rec_id, MOVIEMULTI_PARAM_FILE_SEAMLESSSEC, (gMovie_Rec_Option.seamless_sec));
|
|
ImageApp_MovieMulti_SetParam(gMovie_Clone_Info[i].rec_id, MOVIEMULTI_PARAM_FILE_ENDTYPE, (uiSelect == MOVIE_CYCLICREC_OFF) ? MOVREC_ENDTYPE_CUT_TILLCARDFULL : MOVREC_ENDTYPE_CUTOVERLAP);
|
|
}
|
|
|
|
mask <<= 1;
|
|
}
|
|
|
|
#if(defined(_NVT_ETHREARCAM_RX_))
|
|
for (i = 0; i < ETH_REARCAM_CAPS_COUNT; i++) {
|
|
ImageApp_MovieMulti_SetParam((_CFG_ETHCAM_ID_1 + i), MOVIEMULTI_PARAM_FILE_SEAMLESSSEC, gMovie_Rec_Option.seamless_sec);
|
|
ImageApp_MovieMulti_SetParam((_CFG_ETHCAM_ID_1 + i), MOVIEMULTI_PARAM_FILE_ENDTYPE, (uiSelect == MOVIE_CYCLICREC_OFF)? MOVREC_ENDTYPE_CUT_TILLCARDFULL : MOVREC_ENDTYPE_CUTOVERLAP);
|
|
}
|
|
#endif
|
|
|
|
return NVTEVT_CONSUME;
|
|
}
|
|
|
|
static void MovieExe_SetRecParamByRecID(MOVIE_CFG_REC_ID rec_id)
|
|
{
|
|
// set record type (video only, video and audio, time-lapse, ...)
|
|
if (SysGetFlag(FL_MOVIE_TIMELAPSE_REC) == MOVIE_TIMELAPSEREC_OFF) {
|
|
if (SysGetFlag(FL_MovieAudioRec) == MOVIE_AUD_REC_OFF) {
|
|
ImageApp_MovieMulti_SetParam(rec_id, MOVIEMULTI_PARAM_REC_FORMAT, _CFG_REC_TYPE_VID);
|
|
} else {
|
|
ImageApp_MovieMulti_SetParam(rec_id, MOVIEMULTI_PARAM_REC_FORMAT, _CFG_REC_TYPE_AV);
|
|
}
|
|
ImageApp_MovieMulti_SetParam(rec_id, MOVIEMULTI_PARAM_TIMELAPSE_TIME, 0);
|
|
ImageApp_MovieMulti_SetParam(rec_id, MOVIEMULTI_PARAM_FILE_ENDTYPE, (SysGetFlag(FL_MOVIE_CYCLIC_REC) == MOVIE_CYCLICREC_OFF) ? MOVREC_ENDTYPE_CUT_TILLCARDFULL : MOVREC_ENDTYPE_CUTOVERLAP);
|
|
} else {
|
|
ImageApp_MovieMulti_SetParam(rec_id, MOVIEMULTI_PARAM_REC_FORMAT, _CFG_REC_TYPE_TIMELAPSE);
|
|
ImageApp_MovieMulti_SetParam(rec_id, MOVIEMULTI_PARAM_TIMELAPSE_TIME, Get_MovieTimeLapseValue(SysGetFlag(FL_MOVIE_TIMELAPSE_REC)));
|
|
////ImageApp_MovieMulti_SetParam(rec_id, MOVIEMULTI_PARAM_FILE_PLAYFRAMERATE, MOVIE_TIMELAPSE_PLAYFRAMERATE);
|
|
ImageApp_MovieMulti_SetParam(rec_id, MOVIEMULTI_PARAM_FILE_ENDTYPE, (SysGetFlag(FL_MOVIE_CYCLIC_REC) == MOVIE_CYCLICREC_OFF) ? MOVREC_ENDTYPE_CUT_TILLCARDFULL : MOVREC_ENDTYPE_CUTOVERLAP);
|
|
}
|
|
}
|
|
int MovieExe_GetWaterLogoSource(const UINT32 recWidth,WATERLOGO_BUFFER *waterSrc)
|
|
{
|
|
#if defined (WATERLOGO_FUNCTION) && (WATERLOGO_FUNCTION == ENABLE)
|
|
// if(recWidth >= 1080){
|
|
// memcpy(waterSrc,&g_WaterLogo_1440,sizeof(WATERLOGO_BUFFER));
|
|
// }else{
|
|
// memcpy(waterSrc,&g_WaterLogo_640,sizeof(WATERLOGO_BUFFER));
|
|
// }
|
|
|
|
memcpy(waterSrc,&g_WaterLogo_640,sizeof(WATERLOGO_BUFFER));
|
|
#endif
|
|
return E_OK;
|
|
}
|
|
static void MovieExe_RecMovieStamp(void)
|
|
{
|
|
#if(SENSOR_CAPS_COUNT & SENSOR_ON_MASK)
|
|
UINT32 Width, Height;
|
|
UINT32 uiStampAddr=0;
|
|
UINT32 uiStampMemSize;
|
|
WATERLOGO_BUFFER waterLogoSrc={0};
|
|
HD_PATH_ID uiVEncOutPortId = 0;
|
|
|
|
#if defined(_UI_STYLE_LVGL_)
|
|
lv_color32_t color = (lv_color32_t){.full = LV_USER_CFG_STAMP_COLOR_BACKGROUND};
|
|
uint8_t r = LV_COLOR_GET_R32(color);
|
|
uint8_t g = LV_COLOR_GET_G32(color);
|
|
uint8_t b = LV_COLOR_GET_B32(color);
|
|
STAMP_COLOR StampColorBg = {RGB_GET_Y(r, g, b), RGB_GET_U(r, g, b), RGB_GET_V(r, g, b)}; // date stamp foreground color
|
|
#else
|
|
STAMP_COLOR StampColorBg = {RGB_GET_Y( 16, 16, 16), RGB_GET_U( 16, 16, 16), RGB_GET_V( 16, 16, 16)}; // date stamp background color
|
|
#endif
|
|
|
|
#if defined(_UI_STYLE_LVGL_)
|
|
color = (lv_color32_t){.full = LV_USER_CFG_STAMP_COLOR_FRAME};
|
|
r = LV_COLOR_GET_R32(color);
|
|
g = LV_COLOR_GET_G32(color);
|
|
b = LV_COLOR_GET_B32(color);
|
|
STAMP_COLOR StampColorFr = {RGB_GET_Y(r, g, b), RGB_GET_U(r, g, b), RGB_GET_V(r, g, b)}; // date stamp foreground color
|
|
#else
|
|
STAMP_COLOR StampColorFr = {RGB_GET_Y( 16, 16, 16), RGB_GET_U( 16, 16, 16), RGB_GET_V( 16, 16, 16)}; // date stamp frame color
|
|
#endif
|
|
|
|
|
|
#if defined(_UI_STYLE_LVGL_)
|
|
color = (lv_color32_t){.full = LV_USER_CFG_STAMP_COLOR_TEXT};
|
|
r = LV_COLOR_GET_R32(color);
|
|
g = LV_COLOR_GET_G32(color);
|
|
b = LV_COLOR_GET_B32(color);
|
|
STAMP_COLOR StampColorFg = {RGB_GET_Y(r, g, b), RGB_GET_U(r, g, b), RGB_GET_V(r, g, b)}; // date stamp foreground color
|
|
#else
|
|
STAMP_COLOR StampColorFg = {RGB_GET_Y(224, 224, 192), RGB_GET_U(224, 224, 192), RGB_GET_V(224, 224, 192)}; // date stamp foreground color
|
|
#endif
|
|
|
|
UINT32 i, mask;
|
|
UINT32 movie_rec_mask, clone_rec_mask;
|
|
|
|
movie_rec_mask = Movie_GetMovieRecMask();
|
|
clone_rec_mask = Movie_GetCloneRecMask();
|
|
//DBG_DUMP("setup_rec_moviestamp sen_cnt=%d\r\n",sen_cnt);
|
|
mask = 1;
|
|
|
|
|
|
USIZE sz = {0};
|
|
UINT32 size_idx = UI_GetData(FL_MOVIE_SIZE);
|
|
UINT32 IsPathSizeDiff=0;
|
|
sz.w=MovieMapping_GetWidth(size_idx, 0);
|
|
sz.h=MovieMapping_GetHeight(size_idx, 0);
|
|
for (i = 0; i < SENSOR_CAPS_COUNT; i++) {
|
|
if (MovieMapping_GetWidth(size_idx, i)*MovieMapping_GetHeight(size_idx, i) != (sz.w*sz.h)) {
|
|
IsPathSizeDiff=1;
|
|
if (MovieMapping_GetWidth(size_idx, i)*MovieMapping_GetHeight(size_idx, i) > (sz.w*sz.h)) {
|
|
sz.w=MovieMapping_GetWidth(size_idx, i);
|
|
sz.h=MovieMapping_GetHeight(size_idx, i);
|
|
}
|
|
}
|
|
}
|
|
DBG_DUMP("RecMovieStamp ,size_idx=%d, IsPathSizeDiff=%d, sz=(%d, %d)\r\n",size_idx, IsPathSizeDiff,sz.w,sz.h);
|
|
|
|
for (i = 0; i < SENSOR_CAPS_COUNT; i ++) {
|
|
// set main path 1st movie stamp
|
|
if ((movie_rec_mask & mask) || (SENSOR_INSERT_MASK & mask)) {
|
|
Width = gMovie_Rec_Info[i].size.w;
|
|
Height =gMovie_Rec_Info[i].size.h;
|
|
memset(&waterLogoSrc,0,sizeof(WATERLOGO_BUFFER));
|
|
MovieExe_GetWaterLogoSource(Width,&waterLogoSrc);
|
|
uiVEncOutPortId = HD_GET_OUT(ImageApp_MovieMulti_GetVdoEncPort(_CFG_REC_ID_1+i)) - 1; // since out is start from 1, so uiVidEncId should minus 1
|
|
DBG_DUMP("main VEncOutPortId=%d, [%d, %d] i=%d\r\n",uiVEncOutPortId,Width,Height, i);
|
|
#if (_BOARD_DRAM_SIZE_ == 0x04000000)
|
|
uiStampMemSize = MovieStamp_CalcBufSize(Width/2, Height,&waterLogoSrc);
|
|
#else
|
|
uiStampMemSize = MovieStamp_CalcBufSize(Width, Height,&waterLogoSrc);
|
|
#endif
|
|
if(IsPathSizeDiff==0){//each path is the same size
|
|
//if(i==0){
|
|
uiStampAddr = MovieStamp_GetBufAddr(uiVEncOutPortId, uiStampMemSize); // stamp malloc vir addr
|
|
//}
|
|
}else{
|
|
uiStampAddr = MovieStamp_GetBufAddr(uiVEncOutPortId, uiStampMemSize); // stamp malloc vir addr
|
|
}
|
|
MovieStamp_SetBuffer(uiVEncOutPortId, uiStampAddr, uiStampMemSize, waterLogoSrc.uiWidth, waterLogoSrc.uiHeight);
|
|
|
|
MovieStamp_SetColor(uiVEncOutPortId, &StampColorBg, &StampColorFr, &StampColorFg);
|
|
|
|
MovieStamp_Setup(
|
|
uiVEncOutPortId,
|
|
STAMP_ON |
|
|
STAMP_AUTO |
|
|
STAMP_DATE_TIME |
|
|
STAMP_BOTTOM_LEFT |
|
|
STAMP_POS_NORMAL |
|
|
STAMP_YY_MM_DD,
|
|
Width,
|
|
Height,
|
|
#if defined (WATERLOGO_FUNCTION) && (WATERLOGO_FUNCTION == ENABLE)
|
|
(WATERLOGO_BUFFER *)&waterLogoSrc);
|
|
#else
|
|
NULL);
|
|
#endif
|
|
}
|
|
// set clone path 1st movie stamp
|
|
if ((clone_rec_mask & mask) || ((SENSOR_INSERT_MASK & mask) && (MovieMapping_GetWidth(size_idx, i) >= MovieMapping_GetCloneWidth(size_idx, i)))) {
|
|
Width = gMovie_Clone_Info[i].size.w;
|
|
Height = gMovie_Clone_Info[i].size.h;
|
|
memset(&waterLogoSrc,0,sizeof(WATERLOGO_BUFFER));
|
|
MovieExe_GetWaterLogoSource(Width,&waterLogoSrc);
|
|
uiVEncOutPortId = HD_GET_OUT(ImageApp_MovieMulti_GetVdoEncPort(_CFG_CLONE_ID_1+i)) - 1; // since out is start from 1, so uiVidEncId should minus 1
|
|
DBG_DUMP("clone VEncOutPortId=%d, GetVdoEncPort(_CFG_CLONE_ID_1+%d)=0x%x\r\n",uiVEncOutPortId,i,ImageApp_MovieMulti_GetVdoEncPort(_CFG_CLONE_ID_1+i));
|
|
#if (_BOARD_DRAM_SIZE_ == 0x04000000)
|
|
uiStampMemSize = MovieStamp_CalcBufSize(Width/2, Height,&waterLogoSrc);
|
|
#else
|
|
uiStampMemSize = MovieStamp_CalcBufSize(Width, Height,&waterLogoSrc);
|
|
#endif
|
|
uiStampAddr = MovieStamp_GetBufAddr(uiVEncOutPortId, uiStampMemSize);
|
|
MovieStamp_SetBuffer(uiVEncOutPortId, uiStampAddr, uiStampMemSize, waterLogoSrc.uiWidth, waterLogoSrc.uiHeight);
|
|
|
|
MovieStamp_SetColor(uiVEncOutPortId, &StampColorBg, &StampColorFr, &StampColorFg);
|
|
|
|
MovieStamp_Setup(
|
|
uiVEncOutPortId,
|
|
STAMP_ON |
|
|
STAMP_AUTO |
|
|
STAMP_DATE_TIME |
|
|
STAMP_BOTTOM_LEFT |
|
|
STAMP_POS_NORMAL |
|
|
STAMP_YY_MM_DD,
|
|
Width,
|
|
Height,
|
|
#if defined (WATERLOGO_FUNCTION) && (WATERLOGO_FUNCTION == ENABLE)
|
|
(WATERLOGO_BUFFER *)&waterLogoSrc);
|
|
#else
|
|
NULL);
|
|
#endif
|
|
}
|
|
#if 1
|
|
// set rawenc path 1st movie stamp
|
|
if ((movie_rec_mask & mask) || (SENSOR_INSERT_MASK & mask)) {
|
|
Width = gMovie_Rec_Info[i].size.w;
|
|
Height =gMovie_Rec_Info[i].size.h;
|
|
memset(&waterLogoSrc,0,sizeof(WATERLOGO_BUFFER));
|
|
MovieExe_GetWaterLogoSource(Width,&waterLogoSrc);
|
|
//uiVEncOutPortId = HD_GET_OUT(ImageApp_MovieMulti_GetRawEncPort(_CFG_REC_ID_1+i)) - 1;
|
|
//DBG_DUMP("main Rewenc VEncOutPortId=%d, GetVdoEncPort(_CFG_REC_ID_1+%d)=0x%x\r\n",uiVEncOutPortId,i,ImageApp_MovieMulti_GetRawEncPort(_CFG_REC_ID_1+i));
|
|
uiVEncOutPortId =MovieStamp_GetRawEncVirtualPort(i);
|
|
DBG_DUMP("main Rewenc VEncOutPortId=%d, i=%d, w=%d, %d\r\n",uiVEncOutPortId,i,Width,Height);
|
|
//for use max w, h, calc buffer
|
|
Width = sz.w;
|
|
Height = sz.h;
|
|
#if (_BOARD_DRAM_SIZE_ == 0x04000000)
|
|
uiStampMemSize = MovieStamp_CalcBufSize(Width/2, Height,&waterLogoSrc);
|
|
#else
|
|
uiStampMemSize = MovieStamp_CalcBufSize(Width, Height,&waterLogoSrc);
|
|
#endif
|
|
if(i==0){
|
|
uiStampAddr = MovieStamp_GetBufAddr(uiVEncOutPortId,uiStampMemSize);
|
|
}
|
|
MovieStamp_SetBuffer(uiVEncOutPortId, uiStampAddr, uiStampMemSize, waterLogoSrc.uiWidth, waterLogoSrc.uiHeight);
|
|
|
|
MovieStamp_SetColor(uiVEncOutPortId, &StampColorBg, &StampColorFr, &StampColorFg);
|
|
|
|
Width = gMovie_Rec_Info[i].size.w;
|
|
Height = gMovie_Rec_Info[i].size.h;
|
|
MovieStamp_Setup(
|
|
uiVEncOutPortId,
|
|
STAMP_ON |
|
|
STAMP_AUTO |
|
|
STAMP_DATE_TIME |
|
|
STAMP_BOTTOM_LEFT |
|
|
STAMP_POS_NORMAL |
|
|
STAMP_YY_MM_DD,
|
|
Width,
|
|
Height,
|
|
#if defined (WATERLOGO_FUNCTION) && (WATERLOGO_FUNCTION == ENABLE)
|
|
(WATERLOGO_BUFFER *)&waterLogoSrc);
|
|
#else
|
|
NULL);
|
|
#endif
|
|
}
|
|
#endif
|
|
mask <<= 1;
|
|
}
|
|
MovieStamp_Enable();
|
|
#endif
|
|
}
|
|
|
|
INT32 MovieExe_OnRecStart(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
|
|
{
|
|
UINT32 i, mask;
|
|
UINT32 movie_rec_mask, clone_rec_mask;
|
|
USIZE thmub_size;
|
|
UINT32 uifile_buffer_reserved_sec = 3;
|
|
#if (_BOARD_DRAM_SIZE_ == 0x04000000)
|
|
uifile_buffer_reserved_sec =5;
|
|
#elif ((((SENSOR_CAPS_COUNT & SENSOR_ON_MASK) + ETH_REARCAM_CAPS_COUNT)>= 2) && (_BOARD_DRAM_SIZE_ == 0x08000000))
|
|
uifile_buffer_reserved_sec =6;
|
|
#endif
|
|
Set_Cur_Day_Night_Status(1, 1);
|
|
|
|
//#NT# save rec status
|
|
UI_SetData(FL_MOVIE_REC, 1);
|
|
for (i = 0; i < SENSOR_CAPS_COUNT; i++) {
|
|
if(gMovie_Rec_Info[i].file_format ==_CFG_FILE_FORMAT_TS){
|
|
ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1 + i, MOVIEMULTI_PARAM_FILE_FRONT_MOOV, FALSE);
|
|
}
|
|
}
|
|
|
|
movie_rec_mask = Movie_GetMovieRecMask();
|
|
clone_rec_mask = Movie_GetCloneRecMask();
|
|
|
|
mask = 1;
|
|
for (i = 0; i < SENSOR_CAPS_COUNT; i++) {
|
|
if ((movie_rec_mask & mask) || (SENSOR_INSERT_MASK & mask)) {
|
|
|
|
// set thumbnail size
|
|
thmub_size.w = MOVIE_THUMB_WIDTH;
|
|
thmub_size.h = (thmub_size.w * gMovie_Rec_Info[i].size.h) / gMovie_Rec_Info[i].size.w;
|
|
ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1 + i, MOVIEMULTI_PARAM_IMGCAP_THUM_SIZE, (UINT32)&thmub_size);
|
|
|
|
MovieExe_SetRecParamByRecID(gMovie_Rec_Info[i].rec_id);
|
|
// Set UDTA data
|
|
Movie_SetUserData(gMovie_Rec_Info[i].rec_id);
|
|
}
|
|
|
|
if (clone_rec_mask & mask) {
|
|
|
|
// set thumbnail size
|
|
thmub_size.w = MOVIE_THUMB_WIDTH;
|
|
thmub_size.h = (thmub_size.w * gMovie_Clone_Info[i].size.h) / gMovie_Clone_Info[i].size.w;
|
|
ImageApp_MovieMulti_SetParam(_CFG_CLONE_ID_1 + i, MOVIEMULTI_PARAM_IMGCAP_THUM_SIZE, (UINT32)&thmub_size);
|
|
|
|
MovieExe_SetRecParamByRecID(gMovie_Clone_Info[i].rec_id);
|
|
// Set UDTA data
|
|
Movie_SetUserData(gMovie_Clone_Info[i].rec_id);
|
|
}
|
|
|
|
mask <<= 1;
|
|
}
|
|
|
|
if (UI_GetData(FL_MOVIE_DATEIMPRINT) == MOVIE_DATEIMPRINT_ON) {
|
|
MovieExe_RecMovieStamp();
|
|
}else{
|
|
MovieStamp_Disable();
|
|
}
|
|
// trigger record
|
|
mask = 1;
|
|
#if(defined(_NVT_ETHREARCAM_RX_))
|
|
for (i = 0; i < (SENSOR_CAPS_COUNT & SENSOR_ON_MASK); i++)
|
|
#else
|
|
for (i = 0; i < SENSOR_CAPS_COUNT; i++)
|
|
#endif
|
|
{
|
|
// start clone path first due to some functions (such as 2v1a need this procedure)
|
|
if (clone_rec_mask & mask) {
|
|
ImageApp_MovieMulti_SetParam(gMovie_Clone_Info[i].rec_id, MOVIEMULTI_PARAM_FILE_FLUSH_SEC, 10);
|
|
ImageApp_MovieMulti_SetParam(gMovie_Clone_Info[i].rec_id, MOVIEMULTI_PARAM_FILE_WRITE_BLKSIZE, 0x100000);
|
|
ImageApp_MovieMulti_SetParam(gMovie_Clone_Info[i].rec_id, MOVIEMULTI_PARAM_FILE_BUFRESSEC, uifile_buffer_reserved_sec);
|
|
ImageApp_MovieMulti_SetParam(gMovie_Clone_Info[i].rec_id, MOVIEMULTI_PARAM_FILE_BUFRESSEC_EMR, uifile_buffer_reserved_sec + gMovie_Rec_Option.clone_emr_sec);
|
|
//ImageApp_MovieMulti_RecStart(gMovie_Clone_Info[i].rec_id);
|
|
ImageApp_MovieMulti_TrigOnce(gMovie_Clone_Info[i].rec_id, 15);
|
|
}
|
|
|
|
if (movie_rec_mask & mask) {
|
|
ImageApp_MovieMulti_SetParam(gMovie_Rec_Info[i].rec_id, MOVIEMULTI_PARAM_FILE_FLUSH_SEC, 10);
|
|
ImageApp_MovieMulti_SetParam(gMovie_Rec_Info[i].rec_id, MOVIEMULTI_PARAM_FILE_WRITE_BLKSIZE, 0x100000);
|
|
ImageApp_MovieMulti_SetParam(gMovie_Rec_Info[i].rec_id, MOVIEMULTI_PARAM_FILE_BUFRESSEC, uifile_buffer_reserved_sec);
|
|
ImageApp_MovieMulti_SetParam(gMovie_Rec_Info[i].rec_id, MOVIEMULTI_PARAM_FILE_BUFRESSEC_EMR, uifile_buffer_reserved_sec + gMovie_Rec_Option.emr_sec);
|
|
//ImageApp_MovieMulti_RecStart(gMovie_Rec_Info[i].rec_id);
|
|
ImageApp_MovieMulti_TrigOnce(gMovie_Rec_Info[i].rec_id, 15);
|
|
}
|
|
|
|
mask <<= 1;
|
|
}
|
|
|
|
#if defined(_NVT_ETHREARCAM_RX_)
|
|
UINT32 j;
|
|
|
|
for (j = 0; j < ETH_REARCAM_CAPS_COUNT; j++) {
|
|
//DBG_DUMP("IsRecv[%d]=%d\r\n", i,socketCliEthData1_IsRecv(ETHCAM_PATH_ID_1 +i));
|
|
if(socketCliEthData1_IsRecv(ETHCAM_PATH_ID_1 +j)){
|
|
#if (ETH_REARCAM_CAPS_COUNT == 1)
|
|
EthCam_SendXMLCmd(j, ETHCAM_PORT_DATA1 ,ETHCAM_CMD_TX_STREAM_STOP, 0);
|
|
#endif
|
|
MovieExe_SetRecParamByRecID(_CFG_ETHCAM_ID_1 + j);
|
|
ImageApp_MovieMulti_SetParam((_CFG_ETHCAM_ID_1 + j), MOVIEMULTI_PARAM_FILE_FLUSH_SEC, 10);
|
|
ImageApp_MovieMulti_SetParam((_CFG_ETHCAM_ID_1 + j), MOVIEMULTI_PARAM_FILE_WRITE_BLKSIZE, 0x200000);
|
|
ImageApp_MovieMulti_SetParam((_CFG_ETHCAM_ID_1 + j), MOVIEMULTI_PARAM_FILE_BUFRESSEC, uifile_buffer_reserved_sec);
|
|
#if (ETH_REARCAM_CAPS_COUNT >= 2)
|
|
ImageApp_MovieMulti_SetParam((_CFG_ETHCAM_ID_1 + j), MOVIEMULTI_PARAM_FILE_MAX_POP_SIZE, (16*1024*1024));
|
|
#endif
|
|
ImageApp_MovieMulti_RecStart(_CFG_ETHCAM_ID_1 + j);
|
|
#if (ETH_REARCAM_CAPS_COUNT == 1)
|
|
socketCliEthData1_RecvResetParam(j);
|
|
EthCam_SendXMLCmd(j, ETHCAM_PORT_DATA1 ,ETHCAM_CMD_TX_STREAM_START, 0);
|
|
#endif
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// disable auto power off/USB detect timer
|
|
KeyScan_EnableMisc(FALSE);
|
|
|
|
return NVTEVT_CONSUME;
|
|
}
|
|
|
|
INT32 MovieExe_OnRecStop(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
|
|
{
|
|
UINT32 i, mask;
|
|
UINT32 movie_rec_mask, clone_rec_mask;
|
|
|
|
UI_SetData(FL_MOVIE_REC, 0);
|
|
|
|
movie_rec_mask = Movie_GetMovieRecMask();
|
|
clone_rec_mask = Movie_GetCloneRecMask();
|
|
Set_Cur_Day_Night_Status(0, 1);
|
|
|
|
mask = 1;
|
|
for (i = 0; i < SENSOR_CAPS_COUNT; i++) {
|
|
// stop clone path first due to some functions (such as 2v1a need this procedure)
|
|
if (clone_rec_mask & mask) {
|
|
ImageApp_MovieMulti_RecStop(gMovie_Clone_Info[i].rec_id);
|
|
}
|
|
|
|
if (movie_rec_mask & mask) {
|
|
ImageApp_MovieMulti_RecStop(gMovie_Rec_Info[i].rec_id);
|
|
}
|
|
|
|
mask <<= 1;
|
|
}
|
|
#if defined(_NVT_ETHREARCAM_RX_)
|
|
for (i = 0; i < ETH_REARCAM_CAPS_COUNT; i++) {
|
|
if(socketCliEthData1_IsRecv(ETHCAM_PATH_ID_1 +i)){
|
|
ImageApp_MovieMulti_RecStop(_CFG_ETHCAM_ID_1 + i);
|
|
}
|
|
}
|
|
#endif
|
|
if (UI_GetData(FL_MOVIE_DATEIMPRINT) == MOVIE_DATEIMPRINT_ON && ImageApp_MovieMulti_IsStreamRunning(_CFG_STRM_ID_1)==0) {
|
|
MovieStamp_Disable();
|
|
}
|
|
#if defined(_NVT_ETHREARCAM_RX_)
|
|
UINT32 j;
|
|
|
|
for (j = 0; j < ETH_REARCAM_CAPS_COUNT; j++) {
|
|
ImageApp_MovieMulti_RecStop(_CFG_ETHCAM_ID_1 + j);
|
|
}
|
|
#endif
|
|
|
|
// Enable auto power off/USB detect timer
|
|
KeyScan_EnableMisc(TRUE);
|
|
if( ImageApp_MovieMulti_IsStreamRunning(_CFG_STRM_ID_1)){
|
|
SxTimer_SetFuncActive(SX_TIMER_DET_AUTOPOWEROFF_ID, FALSE);
|
|
}
|
|
|
|
return NVTEVT_CONSUME;
|
|
}
|
|
static void MovieExe_WifiMovieStamp(void)
|
|
{
|
|
UINT32 Width, Height;
|
|
UINT32 uiStampMemSize;
|
|
UINT32 uiStampAddr;
|
|
WATERLOGO_BUFFER waterLogoSrc={0};
|
|
|
|
#if defined(_UI_STYLE_LVGL_)
|
|
lv_color32_t color = (lv_color32_t){.full = LV_USER_CFG_STAMP_COLOR_BACKGROUND};
|
|
uint8_t r = LV_COLOR_GET_R32(color);
|
|
uint8_t g = LV_COLOR_GET_G32(color);
|
|
uint8_t b = LV_COLOR_GET_B32(color);
|
|
STAMP_COLOR StampColorBg = {RGB_GET_Y(r, g, b), RGB_GET_U(r, g, b), RGB_GET_V(r, g, b)}; // date stamp foreground color
|
|
#else
|
|
STAMP_COLOR StampColorBg = {RGB_GET_Y( 16, 16, 16), RGB_GET_U( 16, 16, 16), RGB_GET_V( 16, 16, 16)}; // date stamp background color
|
|
#endif
|
|
|
|
#if defined(_UI_STYLE_LVGL_)
|
|
color = (lv_color32_t){.full = LV_USER_CFG_STAMP_COLOR_FRAME};
|
|
r = LV_COLOR_GET_R32(color);
|
|
g = LV_COLOR_GET_G32(color);
|
|
b = LV_COLOR_GET_B32(color);
|
|
STAMP_COLOR StampColorFr = {RGB_GET_Y(r, g, b), RGB_GET_U(r, g, b), RGB_GET_V(r, g, b)}; // date stamp foreground color
|
|
#else
|
|
STAMP_COLOR StampColorFr = {RGB_GET_Y( 16, 16, 16), RGB_GET_U( 16, 16, 16), RGB_GET_V( 16, 16, 16)}; // date stamp frame color
|
|
#endif
|
|
|
|
|
|
#if defined(_UI_STYLE_LVGL_)
|
|
color = (lv_color32_t){.full = LV_USER_CFG_STAMP_COLOR_TEXT};
|
|
r = LV_COLOR_GET_R32(color);
|
|
g = LV_COLOR_GET_G32(color);
|
|
b = LV_COLOR_GET_B32(color);
|
|
STAMP_COLOR StampColorFg = {RGB_GET_Y(r, g, b), RGB_GET_U(r, g, b), RGB_GET_V(r, g, b)}; // date stamp foreground color
|
|
#else
|
|
STAMP_COLOR StampColorFg = {RGB_GET_Y(224, 224, 192), RGB_GET_U(224, 224, 192), RGB_GET_V(224, 224, 192)}; // date stamp foreground color
|
|
#endif
|
|
|
|
HD_PATH_ID uiVEncOutPortId = HD_GET_OUT(ImageApp_MovieMulti_GetVdoEncPort(_CFG_STRM_ID_1)) - 1;
|
|
|
|
// set wifi path 1st movie stamp
|
|
{
|
|
Width = gMovie_Strm_Info.size.w;
|
|
Height = gMovie_Strm_Info.size.h;
|
|
memset(&waterLogoSrc,0,sizeof(WATERLOGO_BUFFER));
|
|
MovieExe_GetWaterLogoSource(Width,&waterLogoSrc);
|
|
#if (_BOARD_DRAM_SIZE_ == 0x04000000)
|
|
uiStampMemSize = MovieStamp_CalcBufSize(Width/2, Height,&waterLogoSrc);
|
|
#else
|
|
uiStampMemSize = MovieStamp_CalcBufSize(Width, Height,&waterLogoSrc);
|
|
#endif
|
|
uiStampAddr = MovieStamp_GetBufAddr(uiVEncOutPortId, uiStampMemSize);
|
|
MovieStamp_SetBuffer(uiVEncOutPortId, uiStampAddr, uiStampMemSize, waterLogoSrc.uiWidth, waterLogoSrc.uiHeight);
|
|
|
|
MovieStamp_SetColor(uiVEncOutPortId, &StampColorBg, &StampColorFr, &StampColorFg);
|
|
DBG_DUMP("wifi VEncOutPortId=%d, GetVdoEncPort(_CFG_STRM_ID_1)=0x%x\r\n",uiVEncOutPortId,ImageApp_MovieMulti_GetVdoEncPort(_CFG_STRM_ID_1));
|
|
|
|
MovieStamp_Setup(
|
|
uiVEncOutPortId,
|
|
STAMP_ON |
|
|
STAMP_AUTO |
|
|
STAMP_DATE_TIME |
|
|
STAMP_BOTTOM_LEFT |
|
|
STAMP_POS_NORMAL |
|
|
STAMP_YY_MM_DD,
|
|
Width,
|
|
Height,
|
|
#if defined (WATERLOGO_FUNCTION) && (WATERLOGO_FUNCTION == ENABLE)
|
|
(WATERLOGO_BUFFER *)&waterLogoSrc);
|
|
#else
|
|
NULL);
|
|
#endif
|
|
}
|
|
|
|
MovieStamp_Enable();
|
|
}
|
|
INT32 MovieExe_OnStrmStart(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
|
|
{
|
|
//#NT#2018/06/15#KCHong -begin
|
|
//#NT#multirec test
|
|
#if 0
|
|
UINT32 id = gMovie_Strm_Info.strm_id;
|
|
|
|
if (paramNum) {
|
|
id = paramArray[0];
|
|
}
|
|
ImageApp_Movie_Streaming_Start(id);
|
|
#else
|
|
#if (SENSOR_CAPS_COUNT == 3)
|
|
ImageApp_MovieMulti_ImgLinkForStreaming(_CFG_REC_ID_1, ENABLE, TRUE);
|
|
ImageApp_MovieMulti_ImgLinkForStreaming(_CFG_REC_ID_2, ENABLE, TRUE);
|
|
ImageApp_MovieMulti_ImgLinkForStreaming(_CFG_REC_ID_3, ENABLE, TRUE);
|
|
#elif (SENSOR_CAPS_COUNT == 2)
|
|
#if (SENSOR_CAPS_COUNT & SENSOR_ON_MASK)
|
|
ImageApp_MovieMulti_ImgLinkForStreaming(_CFG_REC_ID_1, ENABLE, TRUE);
|
|
if (System_GetEnableSensor() == (SENSOR_1 | SENSOR_2)){
|
|
ImageApp_MovieMulti_ImgLinkForStreaming(_CFG_REC_ID_2, ENABLE, TRUE);
|
|
}else if (System_GetEnableSensor() == SENSOR_1 ){
|
|
ImageApp_MovieMulti_ImgLinkForStreaming(_CFG_REC_ID_2, DISABLE, TRUE);
|
|
}
|
|
#endif
|
|
#else
|
|
#if (SENSOR_CAPS_COUNT & SENSOR_ON_MASK)
|
|
#if(defined(_NVT_ETHREARCAM_RX_))
|
|
ImageApp_MovieMulti_ImgLinkForStreaming(_CFG_REC_ID_1, ENABLE, TRUE);
|
|
#else
|
|
ImageApp_MovieMulti_ImgLinkForStreaming(_CFG_REC_ID_1, ENABLE, TRUE);
|
|
#endif
|
|
#endif
|
|
#endif
|
|
ImageApp_MovieMulti_StreamingStart(_CFG_STRM_ID_1);
|
|
#endif
|
|
|
|
#if (defined(_NVT_ETHREARCAM_RX_) && (SENSOR_CAPS_COUNT & SENSOR_ON_MASK)==0 && ETH_REARCAM_CAPS_COUNT >=2)
|
|
return NVTEVT_CONSUME;
|
|
#endif
|
|
|
|
|
|
//#NT#2018/06/15#KCHong -end
|
|
if (UI_GetData(FL_MOVIE_DATEIMPRINT) == MOVIE_DATEIMPRINT_ON) {
|
|
MovieExe_WifiMovieStamp();
|
|
}
|
|
return NVTEVT_CONSUME;
|
|
}
|
|
|
|
INT32 MovieExe_OnStrmStop(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
|
|
{
|
|
//#NT#2018/06/15#KCHong -begin
|
|
//#NT#multirec test
|
|
#if 0
|
|
UINT32 id = gMovie_Strm_Info.strm_id;
|
|
|
|
if (paramNum) {
|
|
id = paramArray[0];
|
|
}
|
|
ImageApp_Movie_Streaming_Stop(id);
|
|
#else
|
|
ImageApp_MovieMulti_StreamingStop(_CFG_STRM_ID_1);
|
|
|
|
#if (SENSOR_CAPS_COUNT == 3)
|
|
ImageApp_MovieMulti_ImgLinkForStreaming(_CFG_REC_ID_1, DISABLE, TRUE);
|
|
ImageApp_MovieMulti_ImgLinkForStreaming(_CFG_REC_ID_2, DISABLE, TRUE);
|
|
ImageApp_MovieMulti_ImgLinkForStreaming(_CFG_REC_ID_3, DISABLE, TRUE);
|
|
#elif (SENSOR_CAPS_COUNT == 2)
|
|
ImageApp_MovieMulti_ImgLinkForStreaming(_CFG_REC_ID_1, DISABLE, TRUE);
|
|
if (System_GetEnableSensor() == (SENSOR_1 | SENSOR_2)){
|
|
ImageApp_MovieMulti_ImgLinkForStreaming(_CFG_REC_ID_2, DISABLE, TRUE);
|
|
}
|
|
#else
|
|
#if (SENSOR_CAPS_COUNT & SENSOR_ON_MASK)
|
|
ImageApp_MovieMulti_ImgLinkForStreaming(_CFG_REC_ID_1, DISABLE, TRUE);
|
|
#endif
|
|
#endif
|
|
#endif
|
|
//#NT#2018/06/15#KCHong -end
|
|
return NVTEVT_CONSUME;
|
|
}
|
|
|
|
INT32 MovieExe_OnUvacStart(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
|
|
{
|
|
#if (SENSOR_CAPS_COUNT == 2)
|
|
ImageApp_MovieMulti_ImgLinkForStreaming(_CFG_REC_ID_1, ENABLE, TRUE);
|
|
if (System_GetEnableSensor() == (SENSOR_1 | SENSOR_2)) {
|
|
ImageApp_MovieMulti_ImgLinkForStreaming(_CFG_REC_ID_2, ENABLE, TRUE);
|
|
} else if (System_GetEnableSensor() == SENSOR_1) {
|
|
ImageApp_MovieMulti_ImgLinkForStreaming(_CFG_REC_ID_2, DISABLE, TRUE);
|
|
}
|
|
#else
|
|
#if defined(_NVT_ETHREARCAM_RX_)
|
|
ImageApp_MovieMulti_ImgLinkForStreaming(_CFG_REC_ID_1, ENABLE, TRUE);
|
|
#else
|
|
ImageApp_MovieMulti_ImgLinkForStreaming(_CFG_REC_ID_1, ENABLE, FALSE);
|
|
#endif
|
|
#endif
|
|
ImageApp_MovieMulti_UvacStart(_CFG_UVAC_ID_1);
|
|
|
|
#if 0 //MOVIE_UVAC_FUNC // if you want to enable data stamp on UVAC, please change to #if 1
|
|
if (UI_GetData(FL_MOVIE_DATEIMPRINT) == MOVIE_DATEIMPRINT_ON) {
|
|
UINT32 uiStampAddr;
|
|
|
|
#if defined(_UI_STYLE_LVGL_)
|
|
lv_color32_t color = (lv_color32_t){.full = LV_USER_CFG_STAMP_COLOR_BACKGROUND};
|
|
uint8_t r = LV_COLOR_GET_R32(color);
|
|
uint8_t g = LV_COLOR_GET_G32(color);
|
|
uint8_t b = LV_COLOR_GET_B32(color);
|
|
STAMP_COLOR StampColorBg = {RGB_GET_Y(r, g, b), RGB_GET_U(r, g, b), RGB_GET_V(r, g, b)}; // date stamp foreground color
|
|
#else
|
|
STAMP_COLOR StampColorBg = {RGB_GET_Y( 16, 16, 16), RGB_GET_U( 16, 16, 16), RGB_GET_V( 16, 16, 16)}; // date stamp background color
|
|
#endif
|
|
|
|
#if defined(_UI_STYLE_LVGL_)
|
|
color = (lv_color32_t){.full = LV_USER_CFG_STAMP_COLOR_FRAME};
|
|
r = LV_COLOR_GET_R32(color);
|
|
g = LV_COLOR_GET_G32(color);
|
|
b = LV_COLOR_GET_B32(color);
|
|
STAMP_COLOR StampColorFr = {RGB_GET_Y(r, g, b), RGB_GET_U(r, g, b), RGB_GET_V(r, g, b)}; // date stamp foreground color
|
|
#else
|
|
STAMP_COLOR StampColorFr = {RGB_GET_Y( 16, 16, 16), RGB_GET_U( 16, 16, 16), RGB_GET_V( 16, 16, 16)}; // date stamp frame color
|
|
#endif
|
|
|
|
|
|
#if defined(_UI_STYLE_LVGL_)
|
|
color = (lv_color32_t){.full = LV_USER_CFG_STAMP_COLOR_TEXT};
|
|
r = LV_COLOR_GET_R32(color);
|
|
g = LV_COLOR_GET_G32(color);
|
|
b = LV_COLOR_GET_B32(color);
|
|
STAMP_COLOR StampColorFg = {RGB_GET_Y(r, g, b), RGB_GET_U(r, g, b), RGB_GET_V(r, g, b)}; // date stamp foreground color
|
|
#else
|
|
STAMP_COLOR StampColorFg = {RGB_GET_Y(224, 224, 192), RGB_GET_U(224, 224, 192), RGB_GET_V(224, 224, 192)}; // date stamp foreground color
|
|
#endif
|
|
|
|
UINT32 path_id=ImageApp_MovieMulti_GetVdoEncPort(_CFG_UVAC_ID_1);
|
|
|
|
|
|
#if (STAMP_PRIVATE_POOL == DISABLE)
|
|
// use POOL_ID_DATEIMPRINT as movie data stamp buffer
|
|
uiStampAddr = OS_GetMempoolAddr(POOL_ID_DATEIMPRINT);
|
|
MovieStamp_SetBuffer(path_id, uiStampAddr+POOL_SIZE_DATEIMPRINT/2, POOL_SIZE_DATEIMPRINT/2);
|
|
#else
|
|
uiStampAddr=MovieStamp_GetBufAddr(path_id, MovieStamp_CalcBufSize(gUIUvacVidReso[0].width, gUIUvacVidReso[0].height));//POOL_SIZE_DATEIMPRINT/2);
|
|
MovieStamp_SetBuffer(path_id, uiStampAddr, MovieStamp_CalcBufSize(gUIUvacVidReso[0].width, gUIUvacVidReso[0].height));//POOL_SIZE_DATEIMPRINT/2);
|
|
#endif
|
|
|
|
MovieStamp_SetColor(path_id, &StampColorBg, &StampColorFr, &StampColorFg);
|
|
|
|
MovieStamp_Setup(
|
|
path_id,
|
|
STAMP_ON |
|
|
STAMP_AUTO |
|
|
STAMP_DATE_TIME |
|
|
STAMP_BOTTOM_RIGHT |
|
|
STAMP_POS_NORMAL |
|
|
STAMP_BG_TRANSPARENT |
|
|
STAMP_YY_MM_DD |
|
|
STAMP_IMG_420UV,
|
|
gUIUvacVidReso[0].width,
|
|
gUIUvacVidReso[0].height,
|
|
#if defined (WATERLOGO_FUNCTION) && (WATERLOGO_FUNCTION == ENABLE)
|
|
(WATERLOGO_BUFFER *)&g_WaterLogo);
|
|
#else
|
|
NULL);
|
|
#endif
|
|
|
|
MovieStamp_Enable();
|
|
}
|
|
#endif
|
|
return NVTEVT_CONSUME;
|
|
}
|
|
|
|
INT32 MovieExe_OnUvacStop(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
|
|
{
|
|
ImageApp_MovieMulti_UvacStop(_CFG_UVAC_ID_1);
|
|
#if (SENSOR_CAPS_COUNT == 2)
|
|
ImageApp_MovieMulti_ImgLinkForStreaming(_CFG_REC_ID_1, DISABLE, TRUE);
|
|
if (System_GetEnableSensor() == (SENSOR_1 | SENSOR_2)) {
|
|
ImageApp_MovieMulti_ImgLinkForStreaming(_CFG_REC_ID_2, DISABLE, TRUE);
|
|
}
|
|
#else
|
|
#if defined(_NVT_ETHREARCAM_RX_)
|
|
ImageApp_MovieMulti_ImgLinkForStreaming(_CFG_REC_ID_1, DISABLE, TRUE);
|
|
#else
|
|
ImageApp_MovieMulti_ImgLinkForStreaming(_CFG_REC_ID_1, DISABLE, FALSE);
|
|
#endif
|
|
#endif
|
|
|
|
return NVTEVT_CONSUME;
|
|
}
|
|
|
|
INT32 MovieExe_OnRecRawEnc(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
|
|
{
|
|
UINT32 i, mask, movie_rec_mask;
|
|
|
|
if (g_bAllowRawEnc == FALSE){
|
|
DBG_ERR("RawEnc Busy....\r\n");
|
|
return NVTEVT_CONSUME;
|
|
}
|
|
|
|
g_bAllowRawEnc = FALSE;
|
|
movie_rec_mask = Movie_GetMovieRecMask();
|
|
mask = 1;
|
|
for (i = 0; i < (SENSOR_CAPS_COUNT & SENSOR_ON_MASK); i++) {
|
|
if ((movie_rec_mask & mask) && ImageApp_MovieMulti_IsStreamRunning(i)) {
|
|
DBG_DUMP("trigger snap shot!\r\n");
|
|
//ImageApp_MovieMulti_TriggerSnapshot(gMovie_Rec_Info[i].rec_id);
|
|
if (ImageApp_MovieMulti_TriggerSnapshot(gMovie_Rec_Info[i].rec_id) != E_OK) {
|
|
// set g_bAllowRawEnc flag for next time trigger due to snapshot is failed this time
|
|
g_bAllowRawEnc = TRUE;
|
|
return NVTEVT_CONSUME;
|
|
}
|
|
raw_enc_path |= (1 << gMovie_Rec_Info[i].rec_id);
|
|
}
|
|
mask <<= 1;
|
|
}
|
|
#if(defined(_NVT_ETHREARCAM_RX_))
|
|
for(i=0;i<ETH_REARCAM_CAPS_COUNT;i++){
|
|
if(socketCliEthData1_IsRecv(ETHCAM_PATH_ID_1 +i)){
|
|
EthCam_SendXMLCmd(i, ETHCAM_PORT_DATA1 ,ETHCAM_CMD_GET_TX_MOVIE_RAW_ENCODE, 0);
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
return NVTEVT_CONSUME;
|
|
}
|
|
|
|
INT32 MovieExe_OnProtectAuto(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
|
|
{
|
|
UINT32 uiSelect = 0;
|
|
UINT32 i;
|
|
|
|
if (paramNum) {
|
|
uiSelect = paramArray[0];
|
|
}
|
|
UI_SetData(FL_MOVIE_URGENT_PROTECT_AUTO, uiSelect);
|
|
|
|
if (UI_GetData(FL_MOVIE_URGENT_PROTECT_AUTO) == MOVIE_URGENT_PROTECT_AUTO_ON ||
|
|
UI_GetData(FL_MOVIE_URGENT_PROTECT_MANUAL) == MOVIE_URGENT_PROTECT_MANUAL_ON) {
|
|
if (gMovie_Rec_Option.emr_on == _CFG_EMR_OFF) {
|
|
if (GetMovieRecType_2p(UI_GetData(FL_MOVIE_SIZE)) == MOVIE_REC_TYPE_FRONT) {
|
|
#if (_BOARD_DRAM_SIZE_ == 0x04000000)
|
|
gMovie_Rec_Option.emr_on = _CFG_EMR_SET_CRASH; // set crash
|
|
#else
|
|
gMovie_Rec_Option.emr_on = _CFG_MAIN_EMR_BOTH; // main + emr
|
|
#endif
|
|
#if(defined(_NVT_ETHREARCAM_RX_))
|
|
gMovie_Rec_Option.emr_on = _CFG_EMR_SET_CRASH;//_CFG_MAIN_EMR_PAUSE; // set crash
|
|
#endif
|
|
} else {
|
|
gMovie_Rec_Option.emr_on = _CFG_EMR_SET_CRASH; // set crash
|
|
}
|
|
for (i = 0; i < SENSOR_CAPS_COUNT; i++) {
|
|
ImageApp_MovieMulti_SetParam(gMovie_Rec_Info[i].rec_id, MOVIEMULTI_PARAM_FILE_ROLLBACKSEC, gMovie_Rec_Option.emr_sec);
|
|
ImageApp_MovieMulti_SetParam(gMovie_Rec_Info[i].rec_id, MOVIEMULTI_PARAM_FILE_KEEPSEC, gMovie_Rec_Option.keep_sec);
|
|
ImageApp_MovieMulti_SetParam(gMovie_Rec_Info[i].rec_id, MOVIEMULTI_PARAM_FILE_EMRON, gMovie_Rec_Option.emr_on);
|
|
}
|
|
#if(defined(_NVT_ETHREARCAM_RX_))
|
|
for (i = 0; i < ETH_REARCAM_CAPS_COUNT; i++) {
|
|
ImageApp_MovieMulti_SetParam((_CFG_ETHCAM_ID_1 + i), MOVIEMULTI_PARAM_FILE_ROLLBACKSEC, gMovie_Rec_Option.emr_sec);
|
|
ImageApp_MovieMulti_SetParam((_CFG_ETHCAM_ID_1 + i), MOVIEMULTI_PARAM_FILE_KEEPSEC, gMovie_Rec_Option.keep_sec);
|
|
ImageApp_MovieMulti_SetParam((_CFG_ETHCAM_ID_1 + i), MOVIEMULTI_PARAM_FILE_EMRON, gMovie_Rec_Option.emr_on);
|
|
}
|
|
#endif
|
|
|
|
}
|
|
} else {
|
|
if (gMovie_Rec_Option.emr_on != _CFG_EMR_OFF) {
|
|
gMovie_Rec_Option.emr_on = _CFG_EMR_OFF;
|
|
for (i = 0; i < SENSOR_CAPS_COUNT; i++) {
|
|
ImageApp_MovieMulti_SetParam(gMovie_Rec_Info[i].rec_id, MOVIEMULTI_PARAM_FILE_EMRON, gMovie_Rec_Option.emr_on);
|
|
}
|
|
#if(defined(_NVT_ETHREARCAM_RX_))
|
|
for (i = 0; i < ETH_REARCAM_CAPS_COUNT; i++) {
|
|
ImageApp_MovieMulti_SetParam((_CFG_ETHCAM_ID_1 + i), MOVIEMULTI_PARAM_FILE_EMRON, gMovie_Rec_Option.emr_on);
|
|
}
|
|
#endif
|
|
|
|
}
|
|
}
|
|
|
|
return NVTEVT_CONSUME;
|
|
}
|
|
|
|
INT32 MovieExe_OnProtectManual(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
|
|
{
|
|
UINT32 uiSelect = 0;
|
|
UINT32 i;
|
|
|
|
if (paramNum) {
|
|
uiSelect = paramArray[0];
|
|
}
|
|
UI_SetData(FL_MOVIE_URGENT_PROTECT_MANUAL, uiSelect);
|
|
|
|
if (UI_GetData(FL_MOVIE_URGENT_PROTECT_AUTO) == MOVIE_URGENT_PROTECT_AUTO_ON ||
|
|
UI_GetData(FL_MOVIE_URGENT_PROTECT_MANUAL) == MOVIE_URGENT_PROTECT_MANUAL_ON) {
|
|
if (gMovie_Rec_Option.emr_on == _CFG_EMR_OFF) {
|
|
if (GetMovieRecType_2p(UI_GetData(FL_MOVIE_SIZE)) == MOVIE_REC_TYPE_FRONT) {
|
|
#if (_BOARD_DRAM_SIZE_ == 0x04000000)
|
|
gMovie_Rec_Option.emr_on = _CFG_EMR_SET_CRASH; // set crash
|
|
#else
|
|
gMovie_Rec_Option.emr_on = _CFG_MAIN_EMR_BOTH; // main + emr
|
|
#endif
|
|
#if(defined(_NVT_ETHREARCAM_RX_))
|
|
gMovie_Rec_Option.emr_on = _CFG_EMR_SET_CRASH;//_CFG_MAIN_EMR_PAUSE; // set crash
|
|
#endif
|
|
|
|
} else {
|
|
gMovie_Rec_Option.emr_on = _CFG_EMR_SET_CRASH; // set crash
|
|
}
|
|
for (i = 0; i < SENSOR_CAPS_COUNT; i++) {
|
|
ImageApp_MovieMulti_SetParam(gMovie_Rec_Info[i].rec_id, MOVIEMULTI_PARAM_FILE_ROLLBACKSEC, gMovie_Rec_Option.emr_sec);
|
|
ImageApp_MovieMulti_SetParam(gMovie_Rec_Info[i].rec_id, MOVIEMULTI_PARAM_FILE_KEEPSEC, gMovie_Rec_Option.keep_sec);
|
|
ImageApp_MovieMulti_SetParam(gMovie_Rec_Info[i].rec_id, MOVIEMULTI_PARAM_FILE_EMRON, gMovie_Rec_Option.emr_on);
|
|
}
|
|
#if(defined(_NVT_ETHREARCAM_RX_))
|
|
for (i = 0; i < ETH_REARCAM_CAPS_COUNT; i++) {
|
|
ImageApp_MovieMulti_SetParam((_CFG_ETHCAM_ID_1 + i), MOVIEMULTI_PARAM_FILE_ROLLBACKSEC, gMovie_Rec_Option.emr_sec);
|
|
ImageApp_MovieMulti_SetParam((_CFG_ETHCAM_ID_1 + i), MOVIEMULTI_PARAM_FILE_KEEPSEC, gMovie_Rec_Option.keep_sec);
|
|
ImageApp_MovieMulti_SetParam((_CFG_ETHCAM_ID_1 + i), MOVIEMULTI_PARAM_FILE_EMRON, gMovie_Rec_Option.emr_on);
|
|
}
|
|
#endif
|
|
|
|
}
|
|
} else {
|
|
if (gMovie_Rec_Option.emr_on != _CFG_EMR_OFF) {
|
|
gMovie_Rec_Option.emr_on = _CFG_EMR_OFF;
|
|
for (i = 0; i < SENSOR_CAPS_COUNT; i++) {
|
|
ImageApp_MovieMulti_SetParam(gMovie_Rec_Info[i].rec_id, MOVIEMULTI_PARAM_FILE_EMRON, gMovie_Rec_Option.emr_on);
|
|
}
|
|
#if(defined(_NVT_ETHREARCAM_RX_))
|
|
for (i = 0; i < ETH_REARCAM_CAPS_COUNT; i++) {
|
|
ImageApp_MovieMulti_SetParam((_CFG_ETHCAM_ID_1 + i), MOVIEMULTI_PARAM_FILE_EMRON, gMovie_Rec_Option.emr_on);
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
return NVTEVT_CONSUME;
|
|
}
|
|
|
|
INT32 MovieExe_OnCodec(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
|
|
{
|
|
UINT32 uiSelect = 0;
|
|
UINT32 uiValue = 0;
|
|
UINT32 i, movie_rec_mask, clone_rec_mask, mask = 1;
|
|
|
|
if (paramNum > 0) {
|
|
uiSelect = paramArray[0];
|
|
}
|
|
|
|
DBG_IND("MovieExe_OnCodec uiSelect %d\r\n", uiSelect);
|
|
UI_SetData(FL_MOVIE_CODEC, uiSelect);
|
|
|
|
switch(uiSelect){
|
|
case MOVIE_CODEC_H264:
|
|
uiValue = _CFG_CODEC_H264;
|
|
break;
|
|
case MOVIE_CODEC_H265:
|
|
uiValue = _CFG_CODEC_H265;
|
|
break;
|
|
case MOVIE_CODEC_MJPG:
|
|
uiValue = _CFG_CODEC_MJPG;
|
|
break;
|
|
default:
|
|
DBG_ERR("not support\r\n");
|
|
break;
|
|
}
|
|
|
|
movie_rec_mask = Movie_GetMovieRecMask();
|
|
clone_rec_mask = Movie_GetCloneRecMask();
|
|
|
|
for (i = 0; i < SENSOR_CAPS_COUNT; i++) {
|
|
if (movie_rec_mask & mask) {
|
|
ImageApp_MovieMulti_SetParam(gMovie_Rec_Info[i].rec_id, MOVIEMULTI_PARAM_CODEC, uiValue);
|
|
}
|
|
|
|
if (clone_rec_mask & mask) {
|
|
ImageApp_MovieMulti_SetParam(gMovie_Clone_Info[i].rec_id, MOVIEMULTI_PARAM_CODEC, uiValue);
|
|
}
|
|
|
|
mask <<= 1;
|
|
}
|
|
|
|
return NVTEVT_CONSUME;
|
|
}
|
|
|
|
INT32 MovieExe_OnWDR(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
|
|
{
|
|
HD_RESULT hd_ret;
|
|
UINT32 uiSelect = 0;
|
|
IQT_WDR_PARAM iq_wdr_info = {0};
|
|
|
|
iq_wdr_info.id = 0;
|
|
if ((hd_ret = vendor_isp_init()) != HD_OK) {
|
|
DBG_ERR("vendor_isp_init() fail(%d)\r\n", hd_ret);
|
|
}
|
|
if ((hd_ret = vendor_isp_get_iq(IQT_ITEM_WDR_PARAM, &iq_wdr_info)) != HD_OK) {
|
|
DBG_ERR("vendor_isp_get_iq() fail(%d)\r\n", hd_ret);
|
|
if ((hd_ret = vendor_isp_uninit()) != HD_OK) {
|
|
DBG_ERR("vendor_isp_uninit() fail(%d)\r\n", hd_ret);
|
|
}
|
|
return NVTEVT_CONSUME;
|
|
}
|
|
|
|
if (paramNum) {
|
|
uiSelect = paramArray[0];
|
|
}
|
|
|
|
if (uiSelect == MOVIE_WDR_ON) {
|
|
UI_SetData(FL_MOVIE_WDR, MOVIE_WDR_ON);
|
|
iq_wdr_info.wdr.enable = ENABLE;
|
|
//DBG_DUMP("WDR Enable!!!\r\n");
|
|
} else {
|
|
UI_SetData(FL_MOVIE_WDR, MOVIE_WDR_OFF);
|
|
iq_wdr_info.wdr.enable = DISABLE;
|
|
//DBG_DUMP("WDR Disable!!!\r\n");
|
|
}
|
|
|
|
#if 0
|
|
{
|
|
IQT_NIGHT_MODE night_mode = {0};
|
|
night_mode.id = 0;
|
|
night_mode.mode = 1;
|
|
vendor_isp_set_iq(IQT_ITEM_NIGHT_MODE, &night_mode);
|
|
DBG_ERR(">>>>>>>>>>>>>>>>set night mode\r\n");
|
|
}
|
|
#endif
|
|
|
|
if ((hd_ret = vendor_isp_set_iq(IQT_ITEM_WDR_PARAM, &iq_wdr_info)) != HD_OK) {
|
|
DBG_ERR("vendor_isp_set_iq fail(%d)\r\n", hd_ret);
|
|
}
|
|
if ((hd_ret = vendor_isp_uninit()) != HD_OK) {
|
|
DBG_ERR("vendor_isp_uninit() fail(%d)\r\n", hd_ret);
|
|
}
|
|
return NVTEVT_CONSUME;
|
|
}
|
|
INT32 MovieExe_OnEV(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
|
|
{
|
|
UINT32 uiSelect = 0;
|
|
|
|
if (paramNum) {
|
|
uiSelect = paramArray[0];
|
|
}
|
|
|
|
UI_SetData(FL_EV, uiSelect);
|
|
//photo and movie use the same EV value,should syncronize photo EV setting
|
|
Photo_SetUserIndex(PHOTO_USR_EV, uiSelect);
|
|
MovieExe_AE_SetUIInfo(AE_UI_EV, Get_EVValue(uiSelect));
|
|
|
|
return NVTEVT_CONSUME;
|
|
}
|
|
|
|
INT32 MovieExe_OnSensorRotate(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
|
|
{
|
|
UINT32 uiSelect = 0;
|
|
|
|
if (paramNum) {
|
|
uiSelect = paramArray[0];
|
|
}
|
|
if (uiSelect == SEN_ROTATE_ON) {
|
|
UI_SetData(FL_MOVIE_SENSOR_ROTATE, SEN_ROTATE_ON);
|
|
gMovie_Rec_Info[0].sensor_rotate = TRUE;
|
|
} else {
|
|
UI_SetData(FL_MOVIE_SENSOR_ROTATE, SEN_ROTATE_OFF);
|
|
gMovie_Rec_Info[0].sensor_rotate = FALSE;
|
|
}
|
|
if (System_GetEnableSensor() & SENSOR_1) {
|
|
ImageApp_MovieMulti_SetParam(gMovie_Rec_Info[0].rec_id, MOVIEMULTI_PARAM_IPL_MIRROR, ((UI_GetData(FL_MOVIE_SENSOR_ROTATE) == SEN_ROTATE_ON) ? HD_VIDEO_DIR_MIRRORXY : HD_VIDEO_DIR_NONE));
|
|
}
|
|
if (System_GetEnableSensor() & SENSOR_2) {
|
|
ImageApp_MovieMulti_SetParam(gMovie_Rec_Info[1].rec_id, MOVIEMULTI_PARAM_IPL_MIRROR, ((UI_GetData(FL_MOVIE_SENSOR_ROTATE) == SEN_ROTATE_ON) ? HD_VIDEO_DIR_MIRRORXY : HD_VIDEO_DIR_NONE));
|
|
}
|
|
return NVTEVT_CONSUME;
|
|
}
|
|
|
|
INT32 MovieExe_OnMotionDet(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
|
|
{
|
|
UINT32 uiSelect = 0;
|
|
|
|
if (paramNum) {
|
|
uiSelect = paramArray[0];
|
|
}
|
|
|
|
UI_SetData(FL_MOVIE_MOTION_DET, uiSelect);
|
|
|
|
return NVTEVT_CONSUME;
|
|
}
|
|
|
|
INT32 MovieExe_OnMotionDetRun(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
|
|
{
|
|
if (paramNum >= 1) {
|
|
*(UINT32 *)(paramArray[0]) = MovieAlgFunc_MD_GetResult();
|
|
}
|
|
return NVTEVT_CONSUME;
|
|
}
|
|
|
|
BOOL FlowMovie_CheckReOpenItem(void)
|
|
{
|
|
BOOL bReOpen = FALSE, bMovieSizeMenu = FALSE;
|
|
#if (defined(_NVT_ETHREARCAM_RX_))
|
|
BOOL bTxStreamReStart = FALSE;
|
|
#endif
|
|
|
|
if (UI_GetData(FL_MOVIE_SIZE_MENU) != UI_GetData(FL_MOVIE_SIZE)) {
|
|
// Set resolution on mode open to avoid wrong preview image.
|
|
UI_SetData(FL_MOVIE_SIZE, UI_GetData(FL_MOVIE_SIZE_MENU));
|
|
bReOpen = TRUE;
|
|
bMovieSizeMenu = TRUE;
|
|
}
|
|
|
|
// if multi recored, set EMR mode to _CFG_EMR_MODE4 (set crash)
|
|
if (UI_GetData(FL_MOVIE_URGENT_PROTECT_AUTO) == MOVIE_URGENT_PROTECT_AUTO_ON) {
|
|
Ux_SendEvent(&CustomMovieObjCtrl, NVTEVT_EXE_MOVIE_PROTECT_AUTO, 1, MOVIE_URGENT_PROTECT_AUTO_ON);
|
|
}
|
|
if (UI_GetData(FL_MOVIE_URGENT_PROTECT_MANUAL) == MOVIE_URGENT_PROTECT_MANUAL_ON) {
|
|
Ux_SendEvent(&CustomMovieObjCtrl, NVTEVT_EXE_MOVIE_PROTECT_MANUAL, 1, MOVIE_URGENT_PROTECT_MANUAL_ON);
|
|
}
|
|
|
|
if (UI_GetData(FL_MOVIE_HDR_MENU) != UI_GetData(FL_MOVIE_HDR)) {
|
|
if (UI_GetData(FL_MOVIE_HDR_MENU) == MOVIE_HDR_ON) {
|
|
UI_SetData(FL_MOVIE_WDR, MOVIE_WDR_OFF);
|
|
UI_SetData(FL_MOVIE_WDR_MENU, MOVIE_WDR_OFF);
|
|
UI_SetData(FL_MovieRSCIndex, MOVIE_RSC_OFF);
|
|
UI_SetData(FL_MovieRSCIndex_MENU, MOVIE_RSC_OFF);
|
|
}
|
|
UI_SetData(FL_MOVIE_HDR, UI_GetData(FL_MOVIE_HDR_MENU));
|
|
bReOpen = TRUE;
|
|
}
|
|
|
|
if (UI_GetData(FL_MOVIE_WDR_MENU) != UI_GetData(FL_MOVIE_WDR)) {
|
|
|
|
if (UI_GetData(FL_MOVIE_WDR_MENU) == MOVIE_WDR_ON) {
|
|
UI_SetData(FL_MOVIE_HDR, MOVIE_HDR_OFF);
|
|
UI_SetData(FL_MOVIE_HDR_MENU, MOVIE_HDR_OFF);
|
|
}
|
|
UI_SetData(FL_MOVIE_WDR, UI_GetData(FL_MOVIE_WDR_MENU));
|
|
bReOpen = TRUE;
|
|
}
|
|
|
|
if (UI_GetData(FL_MOVIE_DEFOG_MENU) != UI_GetData(FL_MOVIE_DEFOG)) {
|
|
UI_SetData(FL_MOVIE_DEFOG, UI_GetData(FL_MOVIE_DEFOG_MENU));
|
|
bReOpen = TRUE;
|
|
}
|
|
|
|
if (UI_GetData(FL_MovieRSCIndex_MENU) != UI_GetData(FL_MovieRSCIndex)) {
|
|
|
|
if (UI_GetData(FL_MovieRSCIndex_MENU) == MOVIE_RSC_ON) {
|
|
UI_SetData(FL_MOVIE_HDR, MOVIE_HDR_OFF);
|
|
UI_SetData(FL_MOVIE_HDR_MENU, MOVIE_HDR_OFF);
|
|
}
|
|
UI_SetData(FL_MovieRSCIndex, UI_GetData(FL_MovieRSCIndex_MENU));
|
|
bReOpen = TRUE;
|
|
}
|
|
|
|
#if _TODO
|
|
#if !defined(_SENSOR2_CMOS_OFF_)
|
|
if (bMovieSizeMenu) {
|
|
switch (UI_GetData(FL_MOVIE_SIZE_MENU)) {
|
|
case MOVIE_SIZE_FRONT_2880x2160P24:
|
|
case MOVIE_SIZE_FRONT_2560x1440P30:
|
|
case MOVIE_SIZE_FRONT_1920x1080P60:
|
|
case MOVIE_SIZE_FRONT_1280x720P120:
|
|
case MOVIE_SIZE_FRONT_1280x720P60:
|
|
case MOVIE_SIZE_FRONT_640x480P240:
|
|
//#NT#2016/06/17#Brain Yen -begin
|
|
//#NT#for special aspect panel and Pipview LR
|
|
#if (PIP_VIEW_LR == ENABLE)
|
|
UI_SetData(FL_DUAL_CAM_MENU, DUALCAM_LR_FRONT_FULL);
|
|
#else
|
|
UI_SetData(FL_DUAL_CAM_MENU, DUALCAM_FRONT);
|
|
#endif
|
|
//#NT#2016/06/17#Brain Yen -end
|
|
break;
|
|
|
|
default:
|
|
//#NT#2016/06/17#Brain Yen -begin
|
|
//#NT#for special aspect panel and Pipview LR
|
|
#if (PIP_VIEW_LR == ENABLE)
|
|
if (System_GetEnableSensor() & SENSOR_2) {
|
|
UI_SetData(FL_DUAL_CAM_MENU, DUALCAM_LR_16_9);
|
|
} else {
|
|
UI_SetData(FL_DUAL_CAM_MENU, DUALCAM_LR_FRONT_FULL);
|
|
}
|
|
#else
|
|
if (System_GetEnableSensor() & SENSOR_2) {
|
|
UI_SetData(FL_DUAL_CAM_MENU, DUALCAM_BOTH);
|
|
} else {
|
|
UI_SetData(FL_DUAL_CAM_MENU, DUALCAM_FRONT);
|
|
}
|
|
#endif
|
|
//#NT#2016/06/17#Brain Yen -end
|
|
break;
|
|
}
|
|
|
|
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
if (UI_GetData(FL_DUAL_CAM_MENU) != UI_GetData(FL_DUAL_CAM)) {
|
|
if (bMovieSizeMenu == FALSE) {
|
|
switch (UI_GetData(FL_MOVIE_SIZE_MENU)) {
|
|
case MOVIE_SIZE_FRONT_2880x2160P24:
|
|
case MOVIE_SIZE_FRONT_2560x1440P30:
|
|
case MOVIE_SIZE_FRONT_1920x1080P60:
|
|
case MOVIE_SIZE_FRONT_1280x720P120:
|
|
case MOVIE_SIZE_FRONT_1280x720P60:
|
|
case MOVIE_SIZE_FRONT_640x480P240:
|
|
break;
|
|
|
|
default:
|
|
Ux_PostEvent(NVTEVT_EXE_DUALCAM, 1, UI_GetData(FL_DUAL_CAM_MENU));
|
|
break;
|
|
}
|
|
} else {
|
|
UI_SetData(FL_DUAL_CAM, UI_GetData(FL_DUAL_CAM_MENU));
|
|
#if (PIP_VIEW_FUNC == ENABLE)
|
|
PipView_SetStyle(UI_GetData(FL_DUAL_CAM));
|
|
#endif
|
|
}
|
|
|
|
if (bMovieSizeMenu == FALSE) {
|
|
bReOpen = FALSE; // because in NVTEVT_EXE_DUALCAM, NVTEVT_EXE_MOVIE_DUALCAM will invoke ReOpen
|
|
}
|
|
}
|
|
|
|
if (UI_GetData(FL_MOVIE_LDWS) != UI_GetData(FL_MOVIE_LDWS_MENU)) {
|
|
UI_SetData(FL_MOVIE_LDWS, UI_GetData(FL_MOVIE_LDWS_MENU));
|
|
bReOpen = TRUE;
|
|
}
|
|
|
|
if (UI_GetData(FL_MOVIE_FCW) != UI_GetData(FL_MOVIE_FCW_MENU)) {
|
|
UI_SetData(FL_MOVIE_FCW, UI_GetData(FL_MOVIE_FCW_MENU));
|
|
bReOpen = TRUE;
|
|
}
|
|
|
|
if (UI_GetData(FL_MOVIE_TIMELAPSE_REC) != UI_GetData(FL_MOVIE_TIMELAPSE_REC_MENU)) {
|
|
if ((UI_GetData(FL_MOVIE_TIMELAPSE_REC) == MOVIE_TIMELAPSEREC_OFF) &&
|
|
(UI_GetData(FL_MOVIE_LDWS) == MOVIE_LDWS_ON || UI_GetData(FL_MOVIE_FCW) == MOVIE_FCW_ON)) {
|
|
bReOpen = TRUE;
|
|
}
|
|
UI_SetData(FL_MOVIE_TIMELAPSE_REC, UI_GetData(FL_MOVIE_TIMELAPSE_REC_MENU));
|
|
}
|
|
if (UI_GetData(FL_MOVIE_CODEC) != UI_GetData(FL_MOVIE_CODEC_MENU)) {
|
|
UI_SetData(FL_MOVIE_CODEC, UI_GetData(FL_MOVIE_CODEC_MENU));
|
|
#if (defined(_NVT_ETHREARCAM_RX_))
|
|
bReOpen = TRUE;
|
|
#else
|
|
Ux_SendEvent(&CustomMovieObjCtrl, NVTEVT_EXE_MOVIE_CODEC, 1, UI_GetData(FL_MOVIE_CODEC_MENU));
|
|
#endif
|
|
}
|
|
if (UI_GetData(FL_MOVIE_SENSOR_ROTATE) != UI_GetData(FL_MOVIE_SENSOR_ROTATE_MENU)) {
|
|
UI_SetData(FL_MOVIE_SENSOR_ROTATE, UI_GetData(FL_MOVIE_SENSOR_ROTATE_MENU));
|
|
#if (defined(_NVT_ETHREARCAM_RX_))
|
|
bTxStreamReStart = TRUE;
|
|
#endif
|
|
Ux_SendEvent(&CustomMovieObjCtrl, NVTEVT_EXE_MOVIE_SENSOR_ROTATE, 1, UI_GetData(FL_MOVIE_SENSOR_ROTATE_MENU));
|
|
}
|
|
|
|
|
|
#if(defined(_NVT_ETHREARCAM_RX_))
|
|
UINT16 j;
|
|
UINT32 AllPathLinkStatus=0;
|
|
EthCamCmd_GetFrameTimerEn(0);
|
|
|
|
DBG_DUMP("FL_ResetFlag=%d\r\n", UI_GetData(FL_ResetFlag));
|
|
if(UI_GetData(FL_ResetFlag)){
|
|
bReOpen=TRUE;
|
|
UI_SetData(FL_ResetFlag, FALSE);
|
|
}
|
|
|
|
#if (ETH_REARCAM_CLONE_FOR_DISPLAY == ENABLE)
|
|
if(bReOpen){
|
|
socketCliEthData2_SetAllowPush(0, 0);
|
|
}
|
|
#endif
|
|
|
|
#if 1//(ETH_REARCAM_CAPS_COUNT>=2)
|
|
vos_util_delay_ms(200);//wait pull frame finish
|
|
#endif
|
|
if(bReOpen){
|
|
for(j=0;j<ETH_REARCAM_CAPS_COUNT;j++){
|
|
if(socketCliEthCmd_IsConn(j) && EthCamNet_GetEthLinkStatus(j)==ETHCAM_LINK_UP){
|
|
ImageApp_MovieMulti_EthCamLinkForDisp((_CFG_ETHCAM_ID_1 + j), DISABLE, TRUE);
|
|
EthCam_SendXMLCmd(j, ETHCAM_PORT_DATA1 ,ETHCAM_CMD_TX_STREAM_STOP, 0);
|
|
#if (ETH_REARCAM_CLONE_FOR_DISPLAY == ENABLE)
|
|
EthCam_SendXMLCmd(j, ETHCAM_PORT_DATA2 ,ETHCAM_CMD_TX_STREAM_STOP, 0);
|
|
#endif
|
|
}
|
|
}
|
|
}else if(bTxStreamReStart){
|
|
for(j=0;j<ETH_REARCAM_CAPS_COUNT;j++){
|
|
if(socketCliEthCmd_IsConn(j) && EthCamNet_GetEthLinkStatus(j)==ETHCAM_LINK_UP){
|
|
EthCam_SendXMLCmd(j, ETHCAM_PORT_DATA1 ,ETHCAM_CMD_TX_STREAM_STOP, 0);
|
|
#if (ETH_REARCAM_CLONE_FOR_DISPLAY == ENABLE)
|
|
EthCam_SendXMLCmd(j, ETHCAM_PORT_DATA2 ,ETHCAM_CMD_TX_STREAM_STOP, 0);
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
ETHCAM_MENU_SETTING sEthCamMenuSetting[ETH_REARCAM_CAPS_COUNT]={0};
|
|
for(j=0;j<ETH_REARCAM_CAPS_COUNT;j++){
|
|
if(socketCliEthCmd_IsConn(j) && EthCamNet_GetEthLinkStatus(j)==ETHCAM_LINK_UP){
|
|
AllPathLinkStatus++;
|
|
EthCam_SendXMLCmd(j, ETHCAM_PORT_DEFAULT ,ETHCAM_CMD_SYNC_MENU_SETTING, bReOpen);
|
|
#if (ETH_REARCAM_CAPS_COUNT>=2)
|
|
sEthCamMenuSetting[j].Size=MOVIE_SIZE_FRONT_1920x1080P30;//MOVIE_SIZE_CLONE_1920x1080P30_1280x720P60;//UI_GetData(FL_MOVIE_SIZE);
|
|
#else
|
|
sEthCamMenuSetting[j].Size=MOVIE_SIZE_CLONE_1920x1080P30_1280x720P30;//UI_GetData(FL_MOVIE_SIZE);
|
|
#endif
|
|
sEthCamMenuSetting[j].WDR=UI_GetData(FL_MOVIE_WDR);
|
|
sEthCamMenuSetting[j].EV=UI_GetData(FL_EV);
|
|
sEthCamMenuSetting[j].DateImprint=UI_GetData(FL_MOVIE_DATEIMPRINT);
|
|
sEthCamMenuSetting[j].SensorRotate=UI_GetData(FL_MOVIE_SENSOR_ROTATE);
|
|
//sEthCamMenuSetting[j].Codec=MOVIE_CODEC_H265;//UI_GetData(FL_MOVIE_CODEC);
|
|
sEthCamMenuSetting[j].Codec=UI_GetData(FL_MOVIE_CODEC);
|
|
#if (ETH_REARCAM_CAPS_COUNT == 1)
|
|
sEthCamMenuSetting[j].TimeLapse=UI_GetData(FL_MOVIE_TIMELAPSE_REC);
|
|
#else
|
|
sEthCamMenuSetting[j].TimeLapse=MOVIE_TIMELAPSEREC_OFF;
|
|
#endif
|
|
DBG_DUMP("Size=%d\r\n", sEthCamMenuSetting[j].Size);
|
|
EthCam_SendXMLData(j, (UINT8 *)&sEthCamMenuSetting[j], sizeof(ETHCAM_MENU_SETTING));
|
|
//if(memcmp(&g_sEthCamMenuSetting, &sEthCamMenuSetting, sizeof(ETHCAM_MENU_SETTING))){
|
|
// bReOpenMovie=1;
|
|
//}
|
|
//memcpy(&g_sEthCamMenuSetting[j], &sEthCamMenuSetting[j], sizeof(ETHCAM_MENU_SETTING));
|
|
if(bReOpen){
|
|
socketCliEthData1_SetRecv(j, 0);
|
|
socketCliEthData2_SetRecv(j, 0);
|
|
|
|
EthCamSocketCli_Close(j, ETHSOCKIPCCLI_ID_0);
|
|
EthCamSocketCli_Close(j, ETHSOCKIPCCLI_ID_1);
|
|
EthCamSocketCli_Close(j, ETHSOCKIPCCLI_ID_2);
|
|
}
|
|
}
|
|
}
|
|
if(!bReOpen && AllPathLinkStatus){
|
|
if(bTxStreamReStart){
|
|
for(j=0;j<ETH_REARCAM_CAPS_COUNT;j++){
|
|
if(socketCliEthCmd_IsConn(j) && EthCamNet_GetEthLinkStatus(j)==ETHCAM_LINK_UP){
|
|
EthCam_SendXMLCmd(j, ETHCAM_PORT_DATA1 ,ETHCAM_CMD_TX_STREAM_START, 0);
|
|
#if (ETH_REARCAM_CLONE_FOR_DISPLAY == ENABLE)
|
|
EthCam_SendXMLCmd(j, ETHCAM_PORT_DATA2 ,ETHCAM_CMD_TX_STREAM_START, 0);
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
if(System_IsModeChging()==0){
|
|
EthCamCmd_GetFrameTimerEn(1);
|
|
}
|
|
}
|
|
#endif
|
|
return bReOpen;
|
|
}
|
|
INT32 MovieExe_OnEthcamHotPlug(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
|
|
{
|
|
#if(defined(_NVT_ETHREARCAM_RX_))
|
|
UINT32 isRec=0, i;
|
|
ETHCAM_PATH_ID path_id=_CFG_ETHCAM_ID_1;
|
|
|
|
if (paramNum > 0) {
|
|
path_id = paramArray[0];
|
|
}else{
|
|
DBG_ERR("paramNum=%d\r\n",paramNum);
|
|
}
|
|
|
|
if (System_GetState(SYS_STATE_CURRSUBMODE) == SYS_SUBMODE_WIFI){
|
|
// not considering the case that all sensors can be plugged out temporarily
|
|
#if 1
|
|
for (i =_CFG_REC_ID_1; i < (_CFG_REC_ID_1+SENSOR_CAPS_COUNT); i++) {
|
|
isRec=isRec| ImageApp_MovieMulti_IsStreamRunning(i);
|
|
}
|
|
for (i = 0; i < ETH_REARCAM_CAPS_COUNT; i++) {
|
|
if(socketCliEthData1_IsRecv(ETHCAM_PATH_ID_1 +i)){
|
|
isRec=isRec| ImageApp_MovieMulti_IsStreamRunning(i);
|
|
}
|
|
}
|
|
#else
|
|
isRec = ImageApp_MovieMulti_IsStreamRunning(_CFG_REC_ID_1) |
|
|
ImageApp_MovieMulti_IsStreamRunning(_CFG_REC_ID_2)|
|
|
ImageApp_MovieMulti_IsStreamRunning(_CFG_ETHCAM_ID_1)|
|
|
ImageApp_MovieMulti_IsStreamRunning(_CFG_ETHCAM_ID_2);
|
|
#endif
|
|
} else {
|
|
isRec = (FlowMovie_GetMovDataState() == MOV_ST_REC) ? 1 : 0;
|
|
}
|
|
|
|
BKG_PostEvent(NVTEVT_BKW_ETHCAM_UPDATE_UI);
|
|
|
|
DBG_DUMP("isRec=%d\r\n",isRec);
|
|
if (isRec) {
|
|
ImageApp_MovieMulti_RecStart(_CFG_ETHCAM_ID_1+path_id);
|
|
}
|
|
#endif
|
|
|
|
return NVTEVT_CONSUME;
|
|
}
|
|
#if (SENSOR_CAPS_COUNT >= 2)
|
|
static void MovieExe_Sensor_HotPlug_Disp(void)
|
|
{
|
|
#if (SENSOR_CAPS_COUNT>=3)
|
|
UINT32 u32CurrSensorEn = System_GetEnableSensor();
|
|
UINT32 u32PrevSensorEn = System_GetPrevEnableSensor();
|
|
UINT32 u32Mask;
|
|
UINT32 i;
|
|
#if 0
|
|
#if defined(_SENSOR1_CMOS_OFF_)
|
|
u32CurrSensorEn &= ~SENSOR_1;
|
|
u32PrevSensorEn &= ~SENSOR_1;
|
|
#endif
|
|
#if defined(_SENSOR2_CMOS_OFF_)
|
|
u32CurrSensorEn &= ~SENSOR_2;
|
|
u32PrevSensorEn &= ~SENSOR_2;
|
|
#endif
|
|
#endif
|
|
DBG_DUMP("%s: u32CurrSensorEn = 0x%x\r\n", __func__, u32CurrSensorEn);
|
|
DBG_DUMP("%s: u32PrevSensorEn = 0x%x\r\n", __func__, u32PrevSensorEn);
|
|
|
|
u32Mask = 1;
|
|
for (i=0; i<SENSOR_CAPS_COUNT; i++){
|
|
if ((u32PrevSensorEn & u32Mask) != (u32CurrSensorEn & u32Mask)){
|
|
if (u32CurrSensorEn & u32Mask){
|
|
ImageApp_MovieMulti_ImgLinkForDisp(i, ENABLE, TRUE);
|
|
}else{
|
|
ImageApp_MovieMulti_ImgLinkForDisp(i, DISABLE, TRUE);
|
|
}
|
|
}
|
|
|
|
u32Mask <<= 1;
|
|
}//for (i=0; i<SENSOR_CAPS_COUNT; i++)
|
|
#else
|
|
UINT32 action;
|
|
|
|
action = (System_GetEnableSensor() & SENSOR_INSERT_MASK) ? ENABLE : DISABLE;
|
|
DBG_DUMP("MovieExe_2sensor_HotPlug_Disp: plug %d\r\n", action);
|
|
#if (SENSOR_INSERT_MASK == SENSOR_1)
|
|
ImageApp_MovieMulti_ImgLinkForDisp(_CFG_REC_ID_1, action, TRUE);
|
|
#else
|
|
ImageApp_MovieMulti_ImgLinkForDisp(_CFG_REC_ID_2, action, TRUE);
|
|
//DBG_DUMP("MovieExe_2sensor_HotPlug_Disp: _CFG_REC_ID_2\r\n");
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
static void MovieExe_Sensor_HotPlug_WiFi(void)
|
|
{
|
|
#if (SENSOR_CAPS_COUNT>=3)
|
|
UINT32 u32CurrSensorEn = System_GetEnableSensor();
|
|
UINT32 u32PrevSensorEn = System_GetPrevEnableSensor();
|
|
UINT32 u32Mask;
|
|
UINT32 i;
|
|
|
|
DBG_DUMP("%s: u32CurrSensorEn = 0x%x\r\n", __func__, u32CurrSensorEn);
|
|
DBG_DUMP("%s: u32PrevSensorEn = 0x%x\r\n", __func__, u32PrevSensorEn);
|
|
|
|
u32Mask = 1;
|
|
for (i=0; i<SENSOR_CAPS_COUNT; i++){
|
|
if ((u32PrevSensorEn & u32Mask) != (u32CurrSensorEn & u32Mask)){
|
|
if (u32CurrSensorEn & u32Mask){
|
|
ImageApp_MovieMulti_ImgLinkForStreaming(i, ENABLE, TRUE);
|
|
}else{
|
|
ImageApp_MovieMulti_ImgLinkForStreaming(i, DISABLE, TRUE);
|
|
}
|
|
}
|
|
|
|
u32Mask <<= 1;
|
|
}//for (i=0; i<SENSOR_CAPS_COUNT; i++)
|
|
#else
|
|
UINT32 action;
|
|
|
|
action = (System_GetEnableSensor() & SENSOR_INSERT_MASK) ? ENABLE : DISABLE;
|
|
DBG_DUMP("MovieExe_Sensor_HotPlug_WiFi: plug %d\r\n", action);
|
|
#if (SENSOR_INSERT_MASK == SENSOR_1)
|
|
ImageApp_MovieMulti_ImgLinkForStreaming(_CFG_REC_ID_1, action, TRUE);
|
|
#else
|
|
ImageApp_MovieMulti_ImgLinkForStreaming(_CFG_REC_ID_2, action, TRUE);
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
static void MovieExe_Sensor_HotPlug_Rec(void)
|
|
{
|
|
UINT32 sensor_enable = System_GetEnableSensor(); // sensor enabled
|
|
UINT32 i, u32Mask;
|
|
UINT32 isRec;
|
|
|
|
//if (System_GetState(SYS_STATE_CURRSUBMODE) == SYS_SUBMODE_WIFI){
|
|
// not considering the case that all sensors can be plugged out temporarily
|
|
isRec = ImageApp_MovieMulti_IsStreamRunning(_CFG_REC_ID_1) |
|
|
ImageApp_MovieMulti_IsStreamRunning(_CFG_REC_ID_2)|
|
|
ImageApp_MovieMulti_IsStreamRunning(_CFG_REC_ID_3);
|
|
DBG_DUMP("MovieExe_Sensor_HotPlug_Rec: isRec %d\r\n", isRec);
|
|
//} else {
|
|
// isRec = (FlowMovie_GetMovDataState() == MOV_ST_REC) ? 1 : 0;
|
|
//}
|
|
|
|
u32Mask = 1;
|
|
if (isRec) {
|
|
for (i=0; i<SENSOR_CAPS_COUNT; i++){
|
|
if(gMovie_Rec_Info[i].file_format ==_CFG_FILE_FORMAT_TS){
|
|
ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1 + i, MOVIEMULTI_PARAM_FILE_FRONT_MOOV, FALSE);
|
|
}
|
|
|
|
if ((sensor_enable & u32Mask)/*plug*/ && (!ImageApp_MovieMulti_IsStreamRunning(gMovie_Rec_Info[i].rec_id))/*not recording*/){
|
|
ImageApp_MovieMulti_RecStart(gMovie_Rec_Info[i].rec_id);
|
|
} else if (!(sensor_enable & u32Mask)/*unplug*/ && ImageApp_MovieMulti_IsStreamRunning(gMovie_Rec_Info[i].rec_id)/*recording*/){
|
|
ImageApp_MovieMulti_RecStop(gMovie_Rec_Info[i].rec_id);
|
|
}
|
|
u32Mask <<= 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
INT32 MovieExe_OnSensorHotPlug(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
|
|
{
|
|
#if (SENSOR_CAPS_COUNT >= 2)
|
|
MovieExe_Sensor_HotPlug_Disp();
|
|
|
|
if (System_GetState(SYS_STATE_CURRSUBMODE) == SYS_SUBMODE_WIFI){
|
|
MovieExe_Sensor_HotPlug_WiFi();
|
|
} else {
|
|
#if (MOVIE_UVAC_FUNC == ENABLE)
|
|
MovieExe_Sensor_HotPlug_WiFi();
|
|
#endif
|
|
}
|
|
|
|
MovieExe_Sensor_HotPlug_Rec();
|
|
#endif
|
|
|
|
return NVTEVT_CONSUME;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////
|
|
|
|
EVENT_ENTRY CustomMovieObjCmdMap[] = {
|
|
{NVTEVT_EXE_OPEN, MovieExe_OnOpen },
|
|
{NVTEVT_EXE_CLOSE, MovieExe_OnClose },
|
|
{NVTEVT_EXE_MOVIESIZE, MovieExe_OnMovieSize },
|
|
{NVTEVT_EXE_MOVIE_AUDIO, MovieExe_OnMovieAudio },
|
|
{NVTEVT_EXE_MOVIE_DATE_IMPRINT, MovieExe_OnDateImprint },
|
|
{NVTEVT_EXE_CYCLIC_REC, MovieExe_OnCyclicRec },
|
|
{NVTEVT_EXE_MOVIE_REC_START, MovieExe_OnRecStart },
|
|
{NVTEVT_EXE_MOVIE_REC_STOP, MovieExe_OnRecStop },
|
|
{NVTEVT_EXE_MOVIE_REC_RAWENC, MovieExe_OnRecRawEnc },
|
|
{NVTEVT_EXE_MOVIE_PROTECT_AUTO, MovieExe_OnProtectAuto },
|
|
{NVTEVT_EXE_MOVIE_PROTECT_MANUAL, MovieExe_OnProtectManual },
|
|
{NVTEVT_EXE_MOVIE_CODEC, MovieExe_OnCodec },
|
|
{NVTEVT_EXE_MOVIE_WDR, MovieExe_OnWDR },
|
|
{NVTEVT_EXE_MOVIE_EV, MovieExe_OnEV },
|
|
{NVTEVT_EXE_MOVIE_SENSOR_ROTATE, MovieExe_OnSensorRotate },
|
|
{NVTEVT_EXE_MOVIE_STRM_START, MovieExe_OnStrmStart },
|
|
{NVTEVT_EXE_MOVIE_STRM_STOP, MovieExe_OnStrmStop },
|
|
{NVTEVT_EXE_MOVIE_UVAC_START, MovieExe_OnUvacStart },
|
|
{NVTEVT_EXE_MOVIE_UVAC_STOP, MovieExe_OnUvacStop },
|
|
{NVTEVT_EXE_MOTION_DET, MovieExe_OnMotionDet },
|
|
{NVTEVT_EXE_MOTION_DET_RUN, MovieExe_OnMotionDetRun },
|
|
{NVTEVT_EXE_MOVIE_SENSORHOTPLUG, MovieExe_OnSensorHotPlug },
|
|
{NVTEVT_EXE_MOVIE_ETHCAMHOTPLUG, MovieExe_OnEthcamHotPlug },
|
|
{NVTEVT_NULL, 0}, //End of Command Map
|
|
};
|
|
|
|
CREATE_APP(CustomMovieObj, APP_SETUP)
|
|
|