Merge branch 'Branch_S550_Fast' of gitlab.sifar.tech:linux-em-group/s530-ntk into branch_s550_fast

code/application/source/cardv/SrcCode/PrjCfg_HUNTING_S550.h

@@ -922,7 +922,7 @@
 #define HUNTING_MCU_UART				ENABLE
 #define HUNTING_IR_LED_940				ENABLE
 #define SF_EXIF_MN_BUF_SIZE		256
-#define SF_BASE_VERSION				    "7MR5RCwDB01"
+#define SF_BASE_VERSION				    "7MR5RCwDB04"
 #define HW_S530 DISABLE
 #define DCF_DIR_NAME					"MEDIA" /* 100MEDIA */
 #define DCF_FILE_NAME					"SYGW"  /* SYFW0001.JPG */
@@ -974,7 +974,7 @@
 #ifndef ANR_FUNC
 #define ANR_FUNC						ENABLE
 #endif
-#define SF_NO_SD_SEND				DISABLE
+#define SF_NO_SD_SEND				ENABLE
 //////////////////////sf end///////////////////////////////
 
 /*******************************************************************************************

code/application/source/cardv/SrcCode/UIApp/Movie/UIAppMovie_Exe.c

@@ -1455,7 +1455,7 @@ static void MovieExe_UserEventCb(UINT32 id, MOVIE_USER_CB_EVENT event_id, UINT32
 #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(((SF_CAM_MODE_VIDEO2 == puiPara->CamMode) || (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);

code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowMenuCommonItem/MenuGeneral.c

@@ -104,7 +104,7 @@ int General_MenuCallback(UINT32 uiMessage, UINT32 uiParam)
     {
     case IDM_CAMERA_MODE:
     {
-      puiPara->CamMode = uwOption == 0 ? 0 : 2;
+      puiPara->CamMode = uwOption == 0 ? 0 : 3;
       printf("\033[33m[General_MenuCallback]set CamMode:%d\033[0m\n", uwOption);
       break;
     }

code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowMenuCommonItem/UIFlowMenuCommonItemEventCallback.c

@@ -41,7 +41,7 @@ static void load_info_from_sf(void)
     UIMenuStoreInfo *puiPara = sf_ui_para_get();
 	SysSetFlag(IDF_PASSWORD, puiPara->PwdSwitch);
 	SysSetFlag(IDF_CAMERA_NAME, puiPara->CamNameSwitch == SF_CAMID_OFF ? OPTION_0 : OPTION_1);
-	SysSetFlag(IDF_CAMERA_MODE, puiPara->CamMode == 2 ? OPTION_1 : OPTION_0);
+	SysSetFlag(IDF_CAMERA_MODE, puiPara->CamMode == 3 ? OPTION_1 : OPTION_0);
 	if (PHOTO_SIZE_40M == puiPara->ImgSize)
 	{
 	    SysSetFlag(IDF_IMAGE_SIZE, 0);

code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowPhoto/UIFlowPhotoEventCallback.c

@@ -567,7 +567,7 @@ static void update_camera_mode(void)
 {
 	UIMenuStoreInfo *puiPara = sf_ui_para_get();
 	#define CAMERA_MODE_PHOTO 0
-	#define CAMERA_MODE_PHOTO_AND_VIDEO 2
+	#define CAMERA_MODE_PHOTO_AND_VIDEO 3
 	if (CAMERA_MODE_PHOTO == puiPara->CamMode)
 	{
 	    lv_plugin_img_set_src(image_mode_photo_scr_uiflowphoto, LV_PLUGIN_IMG_ID_SF_CAMERA);

code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIInfo/DateTimeInfo.c

@@ -30,7 +30,7 @@ INT32  gUITimeHour = 0;
 INT32  gUITimeMinute = 0;
 INT32  gUITimeSecond = 0;
 
-INT32  gUIDateSetFmt = DATEFMT_YMD;
+INT32  gUIDateSetFmt = DATEFMT_MDY;
 INT32  gUITimeSetFmt = TIMEFMT_24HR;
 
 void Validate_Date(INT32 *pYear, INT32 *pMonth, INT32 *pDay,
@@ -44,7 +44,7 @@ void DateTime_Init(void)
 	gUIDateMonth = DEF_MONTH;
 	gUIDateDay = DEF_DAY;
 	gUITimeHour = gUITimeMinute = gUITimeSecond = 0;
-	gUIDateSetFmt = DATEFMT_YMD;
+	gUIDateSetFmt = DATEFMT_MDY;
 	gUITimeSetFmt = TIMEFMT_24HR;
 }
 

code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIInfo/UICfgDefault.h

@@ -142,7 +142,7 @@
 #define DEFAULT_HDMI_MODE               VIDEOOUT2_AUTO
 #define DEFAULT_DUALDISP                DUALDISP_OFF
 #define DEFAULT_SENSOR_ROTATE           SEN_ROTATE_OFF
-#define DEFAULT_DATE_FORMAT             DATE_FORMAT_YMD
+#define DEFAULT_DATE_FORMAT             DATE_FORMAT_MDY
 #define DEFAULT_OPENING_LOGO            OPENING_LOGO_ON
 #define DEFAULT_LCD_DISPLAY             DISPOUT_NORMAL
 #define DEFAULT_LCD_BRIGHTNESS          LCDBRT_LVL_05

code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIInfo/UIInfo.c

@@ -2368,6 +2368,7 @@ void sf_power_on_para_check_init(void)
 	if(puiPara->DateStyle != SysGetFlag(FL_DateFormatIndex))
 	{
 		SysSetFlag(FL_DateFormatIndex, puiPara->DateStyle);
+        SysSetFlag(FL_DATE_FORMAT, puiPara->DateStyle);
 	}
 	if(puiPara->Language != SysGetFlag(FL_LANGUAGE))
 	{

code/application/source/sf_app/code/source/battery/sf_battery.c

@@ -745,9 +745,10 @@ signed int sf_battery_value_fast_get(void)
 	}
 
 
-	cTemper = sf_adc2Temperature((UINT16)TemperAdc, 1);
+	// cTemper = sf_adc2Temperature((UINT16)TemperAdc, 1);
-	fTemper = sf_celsius_change_to_fahrenheit(cTemper);
+	// fTemper = sf_celsius_change_to_fahrenheit(cTemper);
-
+    sf_battery_level_update();
+    sf_temper_update();
 	return ret;
 }
 

code/application/source/sf_app/code/source/paramMng/sf_param_common.c

@@ -329,6 +329,7 @@ void sf_app_power_on_para_check_init(void)
 	if(puiPara->DateStyle != sf_sys_get_flag(FL_DateFormatIndex))
 	{
 		sf_sys_set_flag(FL_DateFormatIndex, puiPara->DateStyle);
+        sf_sys_set_flag(FL_DATE_FORMAT, puiPara->DateStyle);
 	}
 	if(puiPara->Language != sf_sys_get_flag(FL_LANGUAGE))
 	{

code/application/source/sf_app/code/source/sf_blue/src/sf_blue_app.c

@@ -177,7 +177,7 @@ static void sf_blue_command_get_camera_para(MSG_DEV_BLE_Param_Get_Rsp_T *CamPara
 
     CamPara->zoom = puiPara->Zoom + 1;
 
-    CamPara->cameraMode = (puiPara->CamMode==2)?1:0;
+    CamPara->cameraMode = (puiPara->CamMode==3)?1:0;
 
 	printf("Camera Mode:%d\n", CamPara->cameraMode);
 	
@@ -463,7 +463,7 @@ static signed int sf_blue_command_request_process(U8 *val, unsigned int nval, U8
                             {
                                 saveMode = 2;
                             }
-                            else if (saveMode == 2)
+                            else if ((saveMode == 3) || (saveMode == 2))
                             {
                                 saveMode = 1;
                             }
@@ -480,8 +480,8 @@ static signed int sf_blue_command_request_process(U8 *val, unsigned int nval, U8
                                 }
                                 else if (tmpMode == 1)
                                 {
-                                    puiPara->CamMode = SF_CAM_MODE_PHOTO_VIDEO;
+                                    //puiPara->CamMode = SF_CAM_MODE_PHOTO_VIDEO;
-                                    //puiPara->CamMode = SF_CAM_MODE_VIDEO2;
+                                    puiPara->CamMode = SF_CAM_MODE_VIDEO2;
                                 }
                                 else if (tmpMode == 2)
                                 {

code/application/source/sf_app/code/source/storeMng/sf_storeMng.c

@@ -669,6 +669,34 @@ static void trave_file(char* path)
 
     return;
 }
+int sf_is_directory_empty(const char *path)
+{
+    DIR *dir = opendir(path);
+
+    if (dir == NULL) {
+        MLOGE("Error opening directory");
+        return -1;
+    }
+
+    struct dirent *entry;
+    int count = 0;
+
+    while ((entry = readdir(dir)) != NULL) {
+
+        if (strcmp(entry->d_name, ".") != 0 && strcmp(entry->d_name, "..") != 0) {
+            count++;
+            break;
+        }
+    }
+
+    closedir(dir);
+
+    if (count == 0) {
+        return 1;
+    } else {
+        return 0;
+    }
+}
 
 int sf_dcf_resort_min(void)
 {
@@ -706,6 +734,13 @@ int sf_dcf_resort_min(void)
             MLOGD("DirKey:%d,FileKey:%d\n", gLastDirKey, gLastFileKey);
             if(gLastFileKey <= MAX_DCF_FILE_NUM)
             {
+                sprintf(sTmp,"%s/%d%s",sRootPath,gLastDirKey,DCF_DIR_NAME);
+                if(sf_is_directory_empty(sTmp))
+                {
+                    MLOGD("Will Delete Dir:%s\n", sTmp);
+                    remove(sTmp);
+                    system("sync");
+                }
                 gLastDirKey = i;
                 MLOGD("DirKey:%d,FileKey:%d\n", gLastDirKey, gLastFileKey);
                 return 0;

code/application/source/sf_app/code/source/wifi/sf_wifi_svr.c

@@ -881,7 +881,7 @@ void sf_app_Get_Camera_Para(MSG_DEV_Param_Get_Rsp_T *CamPara)
 
     CamPara->zoom       = DigitalZoom + 1;//puiPara->Zoom+1;
 
-    CamPara->cameraMode = (puiPara->CamMode==2)?1:0;
+    CamPara->cameraMode = (puiPara->CamMode==3)?1:0;
 
 	MLOGI("Camera Mode:%d\n", CamPara->cameraMode);
 	
@@ -1340,7 +1340,7 @@ SINT32 sf_svr_packet_proc(SINT32 fd, UINT8  *pAppData, UINT16 dataLen)
 						{
 							saveMode = 2;
 						}
-						else if (saveMode == 2)
+						else if ((saveMode == 3) || (saveMode == 2))
 						{
 							saveMode = 1;
 						}
@@ -1357,8 +1357,8 @@ SINT32 sf_svr_packet_proc(SINT32 fd, UINT8  *pAppData, UINT16 dataLen)
 							}
 							else if (tmpMode == 1)
 							{
-                                puiPara->CamMode = SF_CAM_MODE_PHOTO_VIDEO;
+                                //puiPara->CamMode = SF_CAM_MODE_PHOTO_VIDEO;
-								//puiPara->CamMode = SF_CAM_MODE_VIDEO2;
+								puiPara->CamMode = SF_CAM_MODE_VIDEO2;
 							}
 							else if (tmpMode == 2)
 							{

configs/Linux/cfg_565_HUNTING_EVB_LINUX_4G_S550/nvt-mem-tbl.dtsi

@@ -17,6 +17,7 @@
 		linuxtmp{ reg = <0x02800000 0x04000000>; }; /* recycled after rtos started */
 		uboot{    reg = <0x06800000 0x01640000>; }; /* recycled after rtos started */
 		logo-fb{  reg = <0x07E40000 0x001C0000>; }; /* recycled after rtos started */
+		usrmem{   reg = <0x07A00000 0x00600000>; };
 	};
 
 	/* Linux system memory region*/

rtos/code/application/source/cardv/SrcCode/PrjCfg_HUNTING_S550.h

@@ -945,7 +945,7 @@
 #define HUNTING_MCU_UART				ENABLE
 #define HUNTING_IR_LED_940				ENABLE
 #define SF_EXIF_MN_BUF_SIZE		256
-#define SF_BASE_VERSION				"7MR5RCwDB01"
+#define SF_BASE_VERSION				"7MR5RCwDB04"
 #define DCF_DIR_NAME					"MEDIA"   /* 100MEDIA */
 #define DCF_FILE_NAME					"SYGW"    /* SYFW0001.JPG */
 #define PHOTO_THUMB_PATH 				"A:\\THUMB\\"
@@ -985,7 +985,7 @@
 #ifndef ANR_FUNC
 #define ANR_FUNC						ENABLE
 #endif
-#define SF_NO_SD_SEND				DISABLE
+#define SF_NO_SD_SEND				ENABLE
 ////////////////////sf end////////////////////////////////
 
 

rtos/code/application/source/cardv/SrcCode/System/rtos-main.c

@@ -1075,6 +1075,11 @@ static void fastboot(void)
 			vos_task_resume(handle_usb_uvacmode);
 		break;
 #endif
+
+
+    default:
+    	printf("default\n");
+    	break;
 	}
 #endif
 

rtos/code/application/source/cardv/SrcCode/System/sys_fastboot.h

@@ -14,6 +14,7 @@ typedef enum _BOOT_INIT_ {
 	BOOT_INIT_BOOTLOGO,
 	BOOT_INIT_OTHERS,
 	BOOT_FLOW_BOOT,
+	BOOT_FLOW_MOVIE2,
 	BOOT_INIT_MAX_CNT = 32, //flag max bit cnt is 32
 	ENUM_DUMMY4WORD(BOOT_INIT),
 } BOOT_INIT;

rtos/code/application/source/cardv/SrcCode/System/sys_linuxboot.c

@@ -22,6 +22,7 @@
 #include <FileSysTsk.h>
 #include <shm_info.h>
 #include "DxHunting.h"
+#include "sys_fastboot.h"
 #if HUNTING_CAMERA_MCU == ENABLE
 #include "sf_mcu.h"
 #endif
@@ -1034,12 +1035,17 @@ static int load_linux_from_nvtpack(LINUXTMP_PARTITION *p_linuxtmp, FDT_INFO *p_f
 
 static int load_linux(LINUXTMP_PARTITION *p_linuxtmp, FDT_INFO *p_fdt_info)
 {
+#if 0
 	SHMINFO *p_shm = (SHMINFO *)p_fdt_info->shmem_addr;
 	if ((p_shm->boot.LdCtrl2 & LDCF_BOOT_CARD) == 0) {
 		return load_linux_from_flash(p_linuxtmp, p_fdt_info);
 	} else {
 		return load_linux_from_nvtpack(p_linuxtmp, p_fdt_info);
 	}
+#else
+	return load_linux_from_flash(p_linuxtmp, p_fdt_info);
+#endif
+
 }
 
 static int check_mem_overlap(FDT_INFO *p_fdt_info)
@@ -1153,6 +1159,8 @@ int linuxboot_setup(LINUXBOOT_INFO *p_info)
 		p_linuxtmp->tmp2_end = p_fdt_info->fdt_addr;
 	}
 
+
+#if 0
 	SHMINFO *p_shm = (SHMINFO *)p_fdt_info->shmem_addr;
 	if (p_shm->boot.LdCtrl2 & LDCF_BOOT_CARD) {
 #if (_PACKAGE_FILESYS_ && _PACKAGE_SDCARD_)
@@ -1169,12 +1177,22 @@ int linuxboot_setup(LINUXBOOT_INFO *p_info)
 	return -1;
 #endif
 	}
+#else
+	(void) load_linux_from_nvtpack;
+	(void) load_nvtpack;
+#endif
 
 	// create new fdt for nodes of bootargs and ramdisk
 	if ((er=create_new_fdt(p_linuxtmp)) != 0) {
 		return er;
 	}
 
+	if(DrvGPIO_GetPhotoMovieModeFromMonitor() == DX_HUNTING_MODE_MOVIE2){
+		DBG_DUMP("fastboot wait BOOT_FLOW_MOVIE2...\n");
+		fastboot_wait_done(BOOT_FLOW_MOVIE2);
+		DBG_DUMP("fastboot wait BOOT_FLOW_MOVIE2 ok\n");
+	}
+
 #if (CFG_INDEP_RAMDISK)
 	// load ramdisk into memory and reserved memory
 	if ((er=load_ramdisk(p_linuxtmp)) != 0) {

rtos/code/application/source/cardv/SrcCode/UIApp/Movie/UIAppMovie_CommPoolInit.c

@@ -12,62 +12,6 @@
 #include <sf_mcu.h>
 #endif
 #include "DxHunting.h"
-//#define ENABLE      1
-//#define DISABLE     0
-
-#if (defined(_MODEL_565_CARDV_HS880C_)||defined(_MODEL_565_CARDV_HS880CC_) || defined(_MODEL_565_CARDV_HY5137_) || \
-     defined(_MODEL_565_CARDV_Y817_) || defined(_MODEL_565_CARDV_RD6000_) || defined(_MODEL_565_CARDV_EVB_) || \
-	 defined(_MODEL_560_CARDV_EVB_)||defined(_MODEL_565_CARDV_WH565_) ||defined(_MODEL_565_CARDV_EVA51_))
-#if 1
-#define VDO_SIZE_W                  2560
-#define VDO_SIZE_H                  1440
-
-#define VDO_MAIN_SIZE_W             2560
-#define VDO_MAIN_SIZE_H             1440
-#else
-#define VDO_SIZE_W                  1920
-#define VDO_SIZE_H                  1080
-
-#define VDO_MAIN_SIZE_W             1920
-#define VDO_MAIN_SIZE_H             1080
-#endif
-#define VDO_CLONE_SIZE_W            848
-#define VDO_CLONE_SIZE_H            480
-
-#else
-#define VDO_SIZE_W                  2560
-#define VDO_SIZE_H                  1440
-
-#define VDO_MAIN_SIZE_W             2560
-#define VDO_MAIN_SIZE_H             1440
-
-#define VDO_CLONE_SIZE_W            1920
-#define VDO_CLONE_SIZE_H            1080
-#endif
-
-#if (defined(_disp_ifdsi_lcd1_s3003l0_st7701s_))
-#define VDO_DISP_SIZE_W            480//1280//1280//480
-#define VDO_DISP_SIZE_H             864//854//320//320
-#else
-#define VDO_DISP_SIZE_W            960
-#define VDO_DISP_SIZE_H             180
-#endif
-
-#if (_BOARD_DRAM_SIZE_ == 0x04000000)
-#define VDO_WIFI_SIZE_W             640
-#define VDO_WIFI_SIZE_H             360
-#else
-#define VDO_WIFI_SIZE_W             848
-#define VDO_WIFI_SIZE_H             480
-#endif
-
-#define VDO2_SIZE_W                  1920 //second sensor.
-#define VDO2_SIZE_H                  1080 //second sensor.
-
-#define VDO2_MAIN_SIZE_W             1920
-#define VDO2_MAIN_SIZE_H             1080
-
-#define VDO2_CLONE_SIZE_W            848
 
 #define DBGINFO_BUFSIZE()	(0x200)
 #define CA_WIN_NUM_W        32
@@ -126,107 +70,55 @@ void Movie_CommPoolInit(void)
 
 static void Movie_CommPoolInit_Mode1(void)
 {
-	UINT32 id=0;
+	UINT32 id = 0;
 	UINT32 vcap_buf_size = 0;
 	HD_VIDEO_PXLFMT vcap_fmt = HD_VIDEO_PXLFMT_RAW12;
 
 
-#if (_PACKAGE_DISPLAY_)
+	const UINT32 vdo_size_w = 2560;
-    USIZE DispDevSize  = {0};
+	const UINT32 vdo_size_h = 1440;
 
-	hd_ret = hd_videoout_get(video_out_ctrl, HD_VIDEOOUT_PARAM_SYSCAPS, p_video_out_syscaps);
+	const UINT32 clone_size_w = 1920;
-	if (hd_ret != HD_OK) {
+	const UINT32 clone_size_h = 1080;
-		DBG_ERR("get video_out_syscaps failed\r\n");
+
-        DispDevSize.w = VDO_DISP_SIZE_W;
+	/*******************************************************************
-        DispDevSize.h = VDO_DISP_SIZE_H;
+	 * VCap + Main
-	} else {
+	 *******************************************************************/
-        DispDevSize.w = p_video_out_syscaps->output_dim.w;
+
-        DispDevSize.h = p_video_out_syscaps->output_dim.h;
+	System_GetSensorInfo(id, SENSOR_CAPOUT_FMT, &vcap_fmt);
+
+	/* yuv */
+	if (HD_VIDEO_PXLFMT_CLASS(vcap_fmt) == HD_VIDEO_PXLFMT_CLASS_YUV) {
+	    vcap_buf_size = VDO_YUV_BUFSIZE(vdo_size_w, vdo_size_h, vcap_fmt);
 	}
-#endif
+	/* raw */
-
+	else {
-	// config common pool (cap)
+		vcap_buf_size = VDO_RAW_BUFSIZE(vdo_size_w, vdo_size_h, vcap_fmt);
-	for (id = 0; id < SENSOR_CAPS_COUNT; id++) {
-		System_GetSensorInfo(id, SENSOR_CAPOUT_FMT, &vcap_fmt);
-		if (HD_VIDEO_PXLFMT_CLASS(vcap_fmt) == HD_VIDEO_PXLFMT_CLASS_YUV) {     // YUV
-		    switch (id) {
-            case 0: //single sensor
-			vcap_buf_size = VDO_YUV_BUFSIZE(VDO_SIZE_W, VDO_SIZE_H, vcap_fmt);
-                break;
-            case 1: // dual sensor
-                vcap_buf_size = VDO_YUV_BUFSIZE(VDO2_SIZE_W, VDO2_SIZE_H, vcap_fmt);
-                break;
-		    }
-		} else {                                                                // RAW
-		    switch (id) {
-            case 0:
-			vcap_buf_size = VDO_RAW_BUFSIZE(VDO_SIZE_W, VDO_SIZE_H, vcap_fmt);
-                break;
-            case 1:
-			    vcap_buf_size = VDO_RAW_BUFSIZE(VDO2_SIZE_W, VDO2_SIZE_H, vcap_fmt);
-                break;
-		    }
-		}
-		#if (MOVIE_DIRECT_FUNC == ENABLE)
-		if (id == 0) {
-			vcap_buf_size = 0;
-		}
-		#endif // (MOVIE_DIRECT_FUNC == ENABLE)
-		mem_cfg.pool_info[id].type = HD_COMMON_MEM_COMMON_POOL;
-		mem_cfg.pool_info[id].blk_size = DBGINFO_BUFSIZE() +
-										vcap_buf_size +
-										VDO_CA_BUF_SIZE(CA_WIN_NUM_W, CA_WIN_NUM_H) +
-										VDO_LA_BUF_SIZE(LA_WIN_NUM_W, LA_WIN_NUM_H);
-		mem_cfg.pool_info[id].blk_cnt = 7;
-		mem_cfg.pool_info[id].ddr_id = DDR_ID0;
 	}
 
-//	// config common pool (main)
+	#if (MOVIE_DIRECT_FUNC == ENABLE)
-//	//id ++;
+	if (id == 0) {
-//	mem_cfg.pool_info[id].type = HD_COMMON_MEM_COMMON_POOL;
+		vcap_buf_size = 0;
-//#if (MOVIE_DIS == DISABLE)
+	}
-//	#if  (MOVIE_YUV_COMPRESS == ENABLE)
+	#endif
-//	mem_cfg.pool_info[id].blk_size = DBGINFO_BUFSIZE() + VDO_NVX_BUFSIZE(VDO_MAIN_SIZE_W, VDO_MAIN_SIZE_H, HD_VIDEO_PXLFMT_YUV420);
+
-//	#else
+	mem_cfg.pool_info[id].type = HD_COMMON_MEM_COMMON_POOL;
-//	mem_cfg.pool_info[id].blk_size = DBGINFO_BUFSIZE() + VDO_YUV_BUFSIZE(VDO_MAIN_SIZE_W, VDO_MAIN_SIZE_H, HD_VIDEO_PXLFMT_YUV420);
+	mem_cfg.pool_info[id].blk_size = DBGINFO_BUFSIZE() +
-//	#endif
+									vcap_buf_size +
-//#else  // (MOVIE_DIS == DISABLE)
+									VDO_CA_BUF_SIZE(CA_WIN_NUM_W, CA_WIN_NUM_H) +
-//	mem_cfg.pool_info[id].blk_size = DBGINFO_BUFSIZE() + VDO_DIS_BUFSIZE(VDO_MAIN_SIZE_W, VDO_MAIN_SIZE_H, HD_VIDEO_PXLFMT_YUV420);
+									VDO_LA_BUF_SIZE(LA_WIN_NUM_W, LA_WIN_NUM_H);
-//#endif // (MOVIE_DIS == DISABLE)
+	mem_cfg.pool_info[id].blk_cnt = 7;
-//	#if (defined(_MODEL_565_CARDV_HS880C_)||defined(_MODEL_565_CARDV_HS880CC_)||defined(_MODEL_565_CARDV_WH565_)||defined(_MODEL_565_CARDV_EVA51_))
+	mem_cfg.pool_info[id].ddr_id = DDR_ID0;
-//	mem_cfg.pool_info[id].blk_cnt = 4;//6; //3 for 3dnr-off, 4 for 3dnr-on
-//	#else  // (defined(_MODEL_565_CARDV_HS880C_)||defined(_MODEL_565_CARDV_HS880CC_)||defined(_MODEL_565_CARDV_WH565_))
-//	#if (_BOARD_DRAM_SIZE_ == 0x04000000)
-//	mem_cfg.pool_info[id].blk_cnt = 4; //3 for 3dnr-off, 4 for 3dnr-on
-//	#else  // (_BOARD_DRAM_SIZE_ == 0x04000000)
-//	mem_cfg.pool_info[id].blk_cnt = 4; //3 for 3dnr-off, 4 for 3dnr-on
-//	#endif // (_BOARD_DRAM_SIZE_ == 0x04000000)
-//	#endif // (defined(_MODEL_565_CARDV_HS880C_)||defined(_MODEL_565_CARDV_HS880CC_)||defined(_MODEL_565_CARDV_WH565_))
-//	mem_cfg.pool_info[id].ddr_id = DDR_ID0;
 
 
-#if (_BOARD_DRAM_SIZE_ > 0x04000000)
+	/*******************************************************************
-    #if (SENSOR_CAPS_COUNT == 1)
+	 * Clone
-	// config common pool (clone)
+	 *******************************************************************/
 	id ++;
 	mem_cfg.pool_info[id].type = HD_COMMON_MEM_COMMON_POOL;
-#if (MOVIE_DIS == DISABLE)
+	mem_cfg.pool_info[id].blk_size = DBGINFO_BUFSIZE() + VDO_YUV_BUFSIZE(clone_size_w, clone_size_h, HD_VIDEO_PXLFMT_YUV420);
-	mem_cfg.pool_info[id].blk_size = DBGINFO_BUFSIZE()+VDO_YUV_BUFSIZE(VDO_CLONE_SIZE_W, VDO_CLONE_SIZE_H, HD_VIDEO_PXLFMT_YUV420);
-#else  // (MOVIE_DIS == DISABLE)
-	mem_cfg.pool_info[id].blk_size = DBGINFO_BUFSIZE()+VDO_DIS_BUFSIZE(VDO_CLONE_SIZE_W, VDO_CLONE_SIZE_H, HD_VIDEO_PXLFMT_YUV420);
-#endif // (MOVIE_DIS == DISABLE)
-	#if (defined(_MODEL_565_CARDV_HS880C_)||defined(_MODEL_565_CARDV_HS880CC_)||defined(_MODEL_565_CARDV_WH565_)||defined(_MODEL_565_CARDV_EVA51_))
-		#if (MOVIE_DIRECT_FUNC == ENABLE)
-		mem_cfg.pool_info[id].blk_cnt = 2;
-		#else  // (MOVIE_DIRECT_FUNC == ENABLE)
-		mem_cfg.pool_info[id].blk_cnt = 4;
-		#endif // (MOVIE_DIRECT_FUNC == ENABLE)
-	#else  // (defined(_MODEL_565_CARDV_HS880C_)||defined(_MODEL_565_CARDV_HS880CC_)||defined(_MODEL_565_CARDV_WH565_))
 	mem_cfg.pool_info[id].blk_cnt = 4;
-	#endif // (defined(_MODEL_565_CARDV_HS880C_)||defined(_MODEL_565_CARDV_HS880CC_)||defined(_MODEL_565_CARDV_WH565_))
 	mem_cfg.pool_info[id].ddr_id = DDR_ID0;
-#endif // (SENSOR_CAPS_COUNT == 1)
-#endif // (_BOARD_DRAM_SIZE_ > 0x04000000)
 
 #if (_PACKAGE_BOOTLOGO_)
     #if HUNTING_CAMERA_MCU == ENABLE

rtos/code/application/source/cardv/SrcCode/UIApp/MovieFast/MovieFast.c

@@ -38,6 +38,14 @@
 #include "UIAppPhoto_Param.h"
 #include "sys_fwload.h"
 #include "../lfqueue/lfqueue.h"
+
+
+#include <sys_linuxboot.h>
+#include <libfdt.h>
+#include <rtosfdt.h>
+#include <compiler.h>
+#define MEM_PATH_LINUX "/memory"
+
 #if defined(_UI_STYLE_LVGL_)
 #include "flow_lvgl.h"
 #endif
@@ -84,8 +92,6 @@ static char thumb_current_path_main[256] = {'\0'};
 static char thumb_current_path_clone[256] = {'\0'};
 static lfqueue_t write_queue = {0};
 
-#define MOVIE_ROOT_PATH		"A:\\Novatek\\"
-#define MOIVE2_YUV_PATH		"A:\\MOVIE2.yuv420"
 #define FILE_SN_MAX		99999
 #define FILEDB_MAX_NUM		5000
 #define MOVIE_THUMB_WIDTH	640
@@ -98,9 +104,12 @@ static ID MOVIEFAST_FLG_ID = 0;
 static UINT32 g_moviefast_tsk_run = 1;
 static UINT32 g_moviefast_poweroff_tsk_run = 1;
 static THREAD_HANDLE g_moviefast_tsk_id = 0;
+static THREAD_HANDLE g_moviefast_raw_tsk_id = 0;
 static THREAD_HANDLE g_moviefast_power_off_tsk_id = 0;
 static THREAD_HANDLE g_moviefast_write_tsk_id = 0;
 static BOOL g_bIsRecStatus = FALSE;
+static BOOL g_manual_raw_tsk_running = FALSE;
+static BOOL g_is_manual_raw_tsk_running = FALSE;
 static VOS_TICK g_rec_start_tick = 0;
 static VOS_TICK g_alg_start_time= 0;
 static VOS_TICK g_alg_end_time= 0;
@@ -865,6 +874,66 @@ static void MovieFast_FileNamingCB(MOVIE_CFG_REC_ID id, char *pFileName)
 	}
 }
 
+static void MovieFast_Manual_Raw_Task(void* arg)
+{
+	HD_PATH_ID vcap_path = ImageApp_MovieMulti_GetVcapPort(_CFG_REC_ID_1);
+	HD_PATH_ID vprc_path = ImageApp_MovieMulti_GetVprcInPort(_CFG_REC_ID_1);
+	HD_RESULT ret;
+	HD_VIDEO_FRAME frame;
+
+	g_is_manual_raw_tsk_running = TRUE;
+
+	while(g_manual_raw_tsk_running)
+	{
+		ret = hd_videocap_pull_out_buf(vcap_path, &frame, PHOTOFAST_HD_PUSH_PULL_TIMEOUT_MS);
+		if(ret != HD_OK){
+			DBG_ERR("hd_videocap_pull_out_buf failed!(%d)\n", ret);
+			continue;
+		}
+
+		ret = hd_videoproc_push_in_buf(vprc_path, &frame, NULL, PHOTOFAST_HD_PUSH_PULL_TIMEOUT_MS);
+		if(ret != HD_OK){
+			DBG_ERR("hd_videoproc_push_in_buf failed!(%d)\n", ret);
+			hd_videocap_release_out_buf(vcap_path, &frame);
+			continue;
+		}
+
+		ret = hd_videocap_release_out_buf(vcap_path, &frame);
+		if(ret != HD_OK){
+			DBG_ERR("hd_videocap_release_out_buf failed!(%d)\n", ret);
+			continue;
+		}
+	}
+
+	while(1)
+	{
+		ret = hd_videocap_pull_out_buf(vcap_path, &frame, 33);
+		if(ret != HD_OK){
+			DBG_ERR("hd_videocap_pull_out_buf failed!(%d)\n", ret);
+			break;
+		}
+
+		ret = hd_videoproc_push_in_buf(vprc_path, &frame, NULL, 33);
+		if(ret != HD_OK){
+			DBG_ERR("hd_videoproc_push_in_buf failed!(%d)\n", ret);
+			hd_videocap_release_out_buf(vcap_path, &frame);
+			break;
+		}
+
+		ret = hd_videocap_release_out_buf(vcap_path, &frame);
+		if(ret != HD_OK){
+			DBG_ERR("hd_videocap_release_out_buf failed!(%d)\n", ret);
+			break;
+		}
+	}
+
+	DBG_DUMP("MovieFast_Manual_Raw_Task finished\n");
+
+	g_is_manual_raw_tsk_running = FALSE;
+
+	THREAD_RETURN(0);
+}
+
 static void MovieFast_WriteFile_Task(void* arg)
 {
 	lfqueue_t* queue = (lfqueue_t*)arg;
@@ -907,6 +976,8 @@ static void MovieFast_WriteFile_Task(void* arg)
 			free(param);
 		}
 	}
+
+    DBG_DUMP("MovieFast_WriteFile_Task finished\n");
 }
 static void MovieFast_UserEventCb(UINT32 id, MOVIE_USER_CB_EVENT event_id, UINT32 value)
 {
@@ -1115,13 +1186,126 @@ static void MovieFast_Load_Sen_Cfg(MOVIEFAST_IQ_CFG cfg)
 	}
 }
 
+static int MovieFast_fdt_read_mem_node(const char *path, unsigned int *p_addr, unsigned int *p_size)
+{
+	unsigned char *p_fdt = (unsigned char *)fdt_get_base();
+
+	if (p_fdt == NULL) {
+		DBG_ERR("p_fdt is NULL.\n");
+		return -1;
+	}
+
+	int len;
+	int nodeoffset;
+	const void *nodep;  /* property node pointer */
+
+	// get linux space
+	nodeoffset = fdt_path_offset(p_fdt, path);
+	if (nodeoffset < 0) {
+		DBG_ERR("failed to offset for  %s = %d \n", path, nodeoffset);
+		return -1;
+	}
+
+	nodep = fdt_getprop(p_fdt, nodeoffset, "reg", &len);
+	if (len == 0 || nodep == NULL) {
+		DBG_ERR("failed to access reg.\n");
+		return -1;
+	} else {
+		unsigned int *p_data = (unsigned int *)nodep;
+		*p_addr = be32_to_cpu(p_data[0]);
+		*p_size = be32_to_cpu(p_data[1]);
+	}
+
+	return 0;
+}
+
+static int MovieFast_fdt_get_info(FDT_INFO *p_info)
+{
+	int er;
+	if ((er = MovieFast_fdt_read_mem_node(MEM_PATH_LINUX, &p_info->linux_addr, &p_info->linux_size)) != 0) {
+		return er;
+	}
+
+	DBG_DUMP("linux addr:%lx size:%lx\n", p_info->linux_addr, p_info->linux_size);
+
+	return 0;
+}
+
+static int MovieFast_fdt_get_tmp_buf(FDT_INFO *p_info, UINT32* addr, UINT32* size)
+{
+
+	if(p_info && addr && size){
+		*addr = (UINT32)(p_info->linux_addr + 0x1000); /* linux kernel is start from 0x0, add offset to avoid null check */
+		*size = (UINT32)(p_info->linux_size - 0x1000);
+		return E_OK;
+	}
+	else{
+		DBG_ERR("p_inf or addr or size is null\n");
+		return E_SYS;
+	}
+}
+
+static INT32 MovieFast_Mode2_Get_Cont_Shot(UINT32* max_cnt, UINT32* duration)
+{
+#if HUNTING_CAMERA_MCU == ENABLE
+    UIMenuStoreInfo *puiPara = sf_ui_para_get();
+#endif
+
+	if(max_cnt == NULL || duration == NULL){
+		DBG_ERR("max_cnt & max_cnt can't be null!\n");
+		return E_SYS;
+	}
+
+
+	switch (UI_GetData(FL_CONTINUE_SHOT))//puiPara->Multishot
+	{
+		case CONTINUE_SHOT_BURST_5:
+		case CONTINUE_SHOT_BURST_4:
+		{
+			DBG_WRN("MovieFast mode2 only support CONTINUE_SHOT_BURST_3\n");
+			*max_cnt = 3;
+			break;
+		}
+
+		case CONTINUE_SHOT_BURST_3:
+			*max_cnt = 3;
+			break;
+
+		case CONTINUE_SHOT_BURST_2:
+			*max_cnt = 2;
+			break;
+
+		case CONTINUE_SHOT_OFF:
+		default:
+			*max_cnt = 1;
+			break;
+	}
+
+#if HUNTING_CAMERA_MCU == ENABLE
+	if(SF_MULTISHOT_INTEVEL_1S == puiPara->MultiShotIntevel)
+	{
+		*duration = 1000;//The interval between consecutive shots of each photo is 1 second
+	}
+	else if(SF_MULTISHOT_INTEVEL_2S == puiPara->MultiShotIntevel)	{
+		*duration = 2000;//The interval between consecutive shots of each photo is 2 second
+	}
+	else {
+		*duration = 1000 / *max_cnt;//SF_MULTISHOT_INTEVEL_0S
+	}
+#else
+    *duration = 1000 / *max_cnt;
+#endif
+
+	return E_OK;
+}
+
 THREAD_RETTYPE MovieFast_InitMovieModeThread(void *arg)
 {
 	UINT32 i;
 	MOVIEMULTI_MAX_LINK_INFO MaxLinkInfo = {1, 0, 0, 1, 0};   //Img, Disp, Wifi, AudCap, EthCam
 
 	DBG_FUNC("\r\n");
-    UINT32 rec_type = MovieMapping_GetRecType(UI_GetData(FL_MOVIE_SIZE));
+//    UINT32 rec_type = MovieMapping_GetRecType(UI_GetData(FL_MOVIE_SIZE));
 
 	Movie_CommPoolInit();
 
@@ -1129,6 +1313,7 @@ THREAD_RETTYPE MovieFast_InitMovieModeThread(void *arg)
 
 		//UI_SetData(FL_MOVIE_SIZE, MOVIE_SIZE_CLONE_1920x1080P30_1280x720P30);
 		Set_NIGHTMODE(0, 0);
+		nvt_cmdsys_runcmd("ae set_speed 0 128 700 700 100 ");
 	}
 	else{
 	    Set_NIGHTMODE(0, 1);
@@ -1177,36 +1362,66 @@ THREAD_RETTYPE MovieFast_InitMovieModeThread(void *arg)
 	ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1, MOVIEMULTI_PARAM_VCAP_OUTFUNC, HD_VIDEOCAP_OUTFUNC_DIRECT);
 #endif
 	ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1, MOVIEMULTI_PRARM_FILEDB_MAX_MUM, 5000);
+    ImageApp_MovieMulti_SetParam(_CFG_CTRL_ID, MOVIEMULTI_PARAM_FILE_UTC_AUTO_EN, TRUE);
+
+	if(DrvGPIO_GetPhotoMovieModeFromMonitor() != DX_HUNTING_MODE_MOVIE2){
+		 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);
+	}
+	else{
+
+		 UIAPP_PHOTO_SENSOR_INFO *sensor_info = UIAppPhoto_get_SensorInfo(0);
+		 MOVIEMULTI_IPL_SIZE_INFO ipl_size={{sensor_info->sSize.w, sensor_info->sSize.h}, 60};
+		 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);
 
 
-    if(DrvGPIO_GetPhotoMovieModeFromMonitor() != DX_HUNTING_MODE_MOVIE2){
+		 MOVIEMULTI_IME_CROP_INFO crop_info = {0};
-        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);
-        ImageApp_MovieMulti_SetParam(_CFG_CTRL_ID, MOVIEMULTI_PARAM_FILE_UTC_AUTO_EN, TRUE);
-    }
-    else{
-        UIAPP_PHOTO_SENSOR_INFO *sensor_info = UIAppPhoto_get_SensorInfo(0);
-        MOVIEMULTI_IPL_SIZE_INFO ipl_size={{sensor_info->sSize.w, sensor_info->sSize.h}, 60};
-        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);
 
+         UINT32 movie_size_idx;
 
-        MOVIEMULTI_IME_CROP_INFO crop_info = {0};
+         UINT32 rec_type;
 
-        /* 4:3 -> 16:9 */
+         movie_size_idx = UI_GetData(FL_MOVIE_SIZE);
-        crop_info.IMESize = (USIZE){1920, 1440};
+
-        crop_info.IMEWin = (URECT){0, 180, 1920, 1080};
+         rec_type = MovieMapping_GetRecType(movie_size_idx);
-        ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1 , MOVIEMULTI_PARAM_MAIN_IME_CROP, (UINT32)&crop_info);
+        if (rec_type == MOVIE_REC_TYPE_FRONT || rec_type == MOVIE_REC_TYPE_CLONE) { // single recording
-        if(MOVIE_REC_TYPE_CLONE == rec_type)
-        {
             /* 4:3 -> 16:9 */
-            crop_info.IMESize = (USIZE){640, 480};
+//            crop_info.IMESize = (USIZE){1920, 1440};
-            crop_info.IMEWin = (URECT){0, 60, 640, 360};
+//            crop_info.IMEWin = (URECT){0, 180, 1920, 1080};
-            ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1 , MOVIEMULTI_PARAM_CLONE_IME_CROP, (UINT32)&crop_info);
+            crop_info.IMESize = (USIZE){
+                gMovie_Rec_Info[0].size.w,
+                (gMovie_Rec_Info[0].size.w * 3) / 4};
+
+            crop_info.IMEWin = (URECT){
+
+                0,
+                (crop_info.IMESize.h - gMovie_Rec_Info[0].size.h) / 2,
+                gMovie_Rec_Info[0].size.w,
+                gMovie_Rec_Info[0].size.h};
+
+            ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1 , MOVIEMULTI_PARAM_MAIN_IME_CROP, (UINT32)&crop_info);
         }
 
-    }
+       if (rec_type == MOVIE_REC_TYPE_CLONE) {
+             /* 4:3 -> 16:9 */
+//             crop_info.IMESize = (USIZE){640, 480};
+//             crop_info.IMEWin = (URECT){0, 60, 640, 360};
+
+            crop_info.IMESize = (USIZE){
+                gMovie_Clone_Info[0].size.w,
+                (gMovie_Clone_Info[0].size.w * 3) / 4};
+
+            crop_info.IMEWin = (URECT){
+                0,
+                (crop_info.IMESize.h - gMovie_Clone_Info[0].size.h) / 2,
+                gMovie_Clone_Info[0].size.w,
+                gMovie_Clone_Info[0].size.h};
+
+             ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1 , MOVIEMULTI_PARAM_CLONE_IME_CROP, (UINT32)&crop_info);
+        }
+	}
 
 #if (ANR_FUNC == ENABLE)
 	HD_AUDIOCAP_ANR audio_cfg_param = {0};
@@ -1224,10 +1439,14 @@ THREAD_RETTYPE MovieFast_InitMovieModeThread(void *arg)
 
 	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);
+
 #if FIX_RECORD_NOISE == ENABLE
  	ImageApp_MovieMulti_SetParam(0, MOVIEMULTI_PARAM_AUD_MUTE_ENC_FUNC_EN, TRUE);
     ImageApp_MovieMulti_SetParam(0, MOVIEMULTI_PARAM_AUD_MUTE_ENC, TRUE);
 #endif	
+
+    ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1, MOVIEMULTI_PARAM_MANUAL_PUSH_RAW_FRAME, TRUE);
+
 	ImageApp_MovieMulti_Open();
 
 	for (i = 0; i < SENSOR_CAPS_COUNT; i++) {
@@ -1246,7 +1465,7 @@ THREAD_RETTYPE MovieFast_InitMovieModeThread(void *arg)
 		 HD_VIDEOPROC_IN vprc_in = {0};
 
 		 hd_videoproc_get(vprc_in_id, HD_VIDEOPROC_PARAM_IN, &vprc_in);
-		 vprc_in.frc = HD_VIDEO_FRC_RATIO(30, 60);
+		 vprc_in.frc = HD_VIDEO_FRC_RATIO(1, 1);
 		 hd_videoproc_set(vprc_in_id, HD_VIDEOPROC_PARAM_IN, &vprc_in);
 
 		 /* alg */
@@ -1259,14 +1478,12 @@ THREAD_RETTYPE MovieFast_InitMovieModeThread(void *arg)
 		 vprc_out.frc = HD_VIDEO_FRC_RATIO(1, 1);
 //		 vprc_out.depth = 0; /* raw encode */
 		 hd_videoproc_set(vprc_main_id, HD_VIDEOPROC_PARAM_OUT_EX, &vprc_out);
-        if(MOVIE_REC_TYPE_CLONE == rec_type)
+
-        {
+		 /* clone */
-            /* clone */
+		 hd_videoproc_get(vprc_clone_id, HD_VIDEOPROC_PARAM_OUT_EX, &vprc_out);
-            hd_videoproc_get(vprc_clone_id, HD_VIDEOPROC_PARAM_OUT_EX, &vprc_out);
+		 vprc_out.frc = HD_VIDEO_FRC_RATIO(1, 1);
-            vprc_out.frc = HD_VIDEO_FRC_RATIO(1, 1);
+//		 vprc_out.depth = 0;
-    //		 vprc_out.depth = 0;
+		 hd_videoproc_set(vprc_clone_id, HD_VIDEOPROC_PARAM_OUT_EX, &vprc_out);
-            hd_videoproc_set(vprc_clone_id, HD_VIDEOPROC_PARAM_OUT_EX, &vprc_out);
-        }
 	}
 
     if (1){//gMovie_Alg_Info[_CFG_REC_ID_1 + i].path13.ImgSize.w && gMovie_Alg_Info[_CFG_REC_ID_1 + i].path13.ImgSize.h) {
@@ -1300,10 +1517,12 @@ THREAD_RETTYPE MovieFast_InitMovieModeThread(void *arg)
     {
 		HD_VIDEO_FRAME frame;
 		HD_PATH_ID alg_path;
+		HD_PATH_ID vcap_path, vprc_path;
 		BOOL stop = FALSE;
 		UINT32 ae_cnt = 0;
 		UINT32 stop_cnt = 0;
 		BOOL ae_locked = FALSE;
+		HD_RESULT ret;
 
 		if(DrvGPIO_GetPhotoMovieModeFromMonitor() == DX_HUNTING_MODE_MOVIE2){
 			ae_cnt = 6;
@@ -1315,60 +1534,63 @@ THREAD_RETTYPE MovieFast_InitMovieModeThread(void *arg)
 		}
 
 		alg_path = ImageApp_MovieMulti_GetAlgDataPort(_CFG_REC_ID_1, _CFG_ALG_PATH3);
+		vcap_path = ImageApp_MovieMulti_GetVcapPort(_CFG_REC_ID_1);
+		vprc_path = ImageApp_MovieMulti_GetVprcInPort(_CFG_REC_ID_1);
 
 		vos_perf_mark(&g_alg_start_time);
 
 		do {
+			ret = hd_videocap_pull_out_buf(vcap_path, &frame, PHOTOFAST_HD_PUSH_PULL_TIMEOUT_MS);
+			if(ret != HD_OK){
+				DBG_ERR("hd_videocap_pull_out_buf failed!(%d)\n", ret);
+			}
 
-			hd_videoproc_pull_out_buf(alg_path, &frame, PHOTOFAST_HD_PUSH_PULL_TIMEOUT_MS);
+			ret = hd_videoproc_push_in_buf(vprc_path, &frame, NULL, PHOTOFAST_HD_PUSH_PULL_TIMEOUT_MS);
+			if(ret != HD_OK){
+				DBG_ERR("hd_videoproc_push_in_buf failed!(%d)\n", ret);
+			}
+
+			ret = hd_videocap_release_out_buf(vcap_path, &frame);
+			if(ret != HD_OK){
+				DBG_ERR("hd_videocap_release_out_buf failed!(%d)\n", ret);
+			}
+
+			ret = hd_videoproc_pull_out_buf(alg_path, &frame, PHOTOFAST_HD_PUSH_PULL_TIMEOUT_MS);
+			if(ret != HD_OK){
+				DBG_ERR("hd_videoproc_pull_out_buf failed!(%d)\n", ret);
+			}
 
 			DBG_DUMP("count = %llu, timestamp = %llu\n", frame.count, frame.timestamp);
 
 			if(frame.count >= ae_cnt && ae_locked == FALSE){
+
 				DBG_DUMP("timestamp = %llu count = %llu\n", frame.timestamp, frame.count);
+
+				if(DrvGPIO_GetPhotoMovieModeFromMonitor() == DX_HUNTING_MODE_MOVIE2){
+
+#if 0
+					 HD_PATH_ID vprc_in_id = ImageApp_MovieMulti_GetVprc3DNRPort(_CFG_REC_ID_1);
+					 HD_VIDEOPROC_IN vprc_in = {0};
+
+					 hd_videoproc_get(vprc_in_id, HD_VIDEOPROC_PARAM_IN, &vprc_in);
+					 vprc_in.frc = HD_VIDEO_FRC_RATIO(1, 1);
+					 hd_videoproc_set(vprc_in_id, HD_VIDEOPROC_PARAM_IN, &vprc_in);
+					 hd_videoproc_start(vprc_in_id);
+#endif
+				}
+
 				Set_AEMODE(1);
 				setet_preset_param();
+
 				ae_locked = TRUE;
 			}
 
 			if(frame.count >= stop_cnt){
-
-				UIAPP_PHOTO_SENSOR_INFO *sensor_info = UIAppPhoto_get_SensorInfo(0);
-				UINT32 buf_size = 0;
-
-				buf_size = VDO_YUV_BUFSIZE(sensor_info->sSize.w, sensor_info->sSize.h , HD_VIDEO_PXLFMT_YUV420);
-#if 0
-				VOS_TICK t1, t2;
-				vos_perf_mark(&t1);
-				FST_FILE fp = FileSys_OpenFile(MOIVE2_YUV_PATH, FST_OPEN_ALWAYS | FST_OPEN_WRITE);
-				FileSys_WriteFile(fp, (UINT8*)frame.phy_addr[0], &buf_size, 0, NULL);
-				FileSys_CloseFile(fp);
-				vos_perf_mark(&t2);
-				DBG_DUMP("write = %lu us\n", vos_perf_duration(t1, t2));
-#endif
-
-				MOVIEFAST_WRITE_QUEUE_PARAM* param = (MOVIEFAST_WRITE_QUEUE_PARAM*) malloc(sizeof(MOVIEFAST_WRITE_QUEUE_PARAM));
-				if(param){
-					memcpy((void*)&param->frame, (void*)&frame, sizeof(HD_VIDEO_FRAME));
-					param->va = NULL;
-					param->vprc_path_id = alg_path;
-					param->size = buf_size;
-					sprintf(param->path, MOIVE2_YUV_PATH);
-				}
-
-				g_vprc_trigger_frm_time = (VOS_TICK)frame.timestamp;
-				g_vprc_trigger_frm_count = (UINT32)frame.count;
-
-				while (lfqueue_enq(&write_queue, (void*) param) == -1)
-				{
-				    DBG_ERR("ENQ Full ?\r\n");
-				}
-
 				stop = TRUE;
 			}
-			else{
+
-				hd_videoproc_release_out_buf(alg_path, &frame);
+			hd_videoproc_release_out_buf(alg_path, &frame);
-			}
+
 		} while(stop == FALSE);
 
 		vos_perf_mark(&g_alg_end_time);
@@ -1386,16 +1608,118 @@ THREAD_RETTYPE MovieFast_InitMovieModeThread(void *arg)
 		vos_task_resume(g_moviefast_tsk_id);
 	}
 
+	if ((g_moviefast_raw_tsk_id = vos_task_create(MovieFast_Manual_Raw_Task, 0, "MovieFastRawTsk", PRI_MOVIEFAST_CMDTSK, STKSIZE_MOVIEFAST_CMDTSK)) == 0) {
+		DBG_ERR("MovieFast_Manual_Raw_Task create failed.\r\n");
+	} else {
+		g_manual_raw_tsk_running = TRUE;
+		vos_task_resume(g_moviefast_raw_tsk_id);
+	}
+
     vos_flag_set(MOVIEFAST_FLG_ID, FLGMOVIEFAST_RECSTART);
+    
+    VOS_TICK t1, t2;
+    
+    vos_perf_mark(&t1);
+
+#if 1
+
+    FDT_INFO fdt_info;
+    UINT32 tmp_buf, tmp_buf_size;
+    UINT32 cnt = 0;
+    UIAPP_PHOTO_SENSOR_INFO *sensor_info = UIAppPhoto_get_SensorInfo(0);
+    UINT32 yuv_size = 0;
+    HD_PATH_ID alg_path = ImageApp_MovieMulti_GetAlgDataPort(_CFG_REC_ID_1, _CFG_ALG_PATH3);
+    UINT32 max_cnt , duration;
+
+
+    CHKPNT;
+
+    MovieFast_fdt_get_info(&fdt_info);
+
+    if(MovieFast_fdt_get_tmp_buf(&fdt_info, &tmp_buf, &tmp_buf_size) != E_OK){
+    	DBG_ERR("get tmp buffer failed\n");
+    	goto EXIT;
+    }
+
+    if(MovieFast_Mode2_Get_Cont_Shot(&max_cnt, &duration) != E_OK){
+    	DBG_ERR("get cont shut failed\n");
+    	goto EXIT;
+    }
+
+    CHKPNT;
+
+    yuv_size = VDO_YUV_BUFSIZE(sensor_info->sSize.w, sensor_info->sSize.h , HD_VIDEO_PXLFMT_YUV420);
+
+
+    CHKPNT;
+
+    do {
+    	HD_VIDEO_FRAME frame = {0};
+
+		if((tmp_buf + yuv_size) > (tmp_buf + tmp_buf_size)){
+			DBG_ERR("tmp buffer overflow!!\n");
+			goto EXIT;
+		}
+
+    	hd_videoproc_pull_out_buf(alg_path, &frame, -1);
+
+    	DBG_DUMP("tmp_buf = %lx , frame.phy_addr[0] = %lx , copy size = %lx\n", tmp_buf, frame.phy_addr[0], yuv_size);
+    	memcpy((void*)(tmp_buf), (void*)frame.phy_addr[0], yuv_size);
+    	tmp_buf += yuv_size;
+
+    	hd_videoproc_release_out_buf(alg_path, &frame);
+    	if(++cnt >= max_cnt)
+    		break;
+
+    	vos_util_delay_ms(duration);
+
+    } while(1);
+#endif
+
+	vos_perf_mark(&t2);
+
 #if FIX_RECORD_NOISE == ENABLE
- 	vos_util_delay_ms(300);
+
+	UINT32 elapse_time_ms = ((t2 - t1) / 1000);
+
+	  CHKPNT;
+	if(elapse_time_ms < 300)	
+ 		vos_util_delay_ms(300 - elapse_time_ms);
+ 	
     ImageApp_MovieMulti_SetParam(0, MOVIEMULTI_PARAM_AUD_MUTE_ENC, FALSE);
 #endif
+
+
+EXIT:
+
 	THREAD_RETURN(0);
 }
 
 static void MovieFast_Close(void)
 {
+
+
+	if(g_moviefast_raw_tsk_id){
+
+		UINT32 delay_cnt;
+
+		delay_cnt = 10;
+		g_manual_raw_tsk_running = FALSE;
+
+		while (g_is_manual_raw_tsk_running && delay_cnt) {
+			vos_util_delay_us(10000);
+			delay_cnt --;
+		}
+
+		if(g_is_manual_raw_tsk_running){
+			vos_task_destroy(g_moviefast_raw_tsk_id);
+			g_is_manual_raw_tsk_running = FALSE;
+		}
+
+		g_moviefast_raw_tsk_id = 0;
+	}
+
+
 	MovieFast_OnRecStop();
 
 	MovieStamp_Disable();
@@ -1412,59 +1736,86 @@ static void MovieFast_Close(void)
 		UIAPP_PHOTO_SENSOR_INFO *sensor_info = UIAppPhoto_get_SensorInfo(0);
 		UINT32 buf_pa = 0;
 		void* buf_va = 0;
+		UINT32 max_cnt , duration;
+		UINT32 tmp_buf, tmp_buf_size;
+		FDT_INFO fdt_info;
+		UINT32 yuv_size = 0;
+
+	    MovieFast_fdt_get_info(&fdt_info);
+
+	    if(MovieFast_fdt_get_tmp_buf(&fdt_info, &tmp_buf, &tmp_buf_size) != E_OK){
+	    	DBG_ERR("get tmp buffer failed\n");
+	    	goto EXIT;
+	    }
+
+	    if(MovieFast_Mode2_Get_Cont_Shot(&max_cnt, &duration) != E_OK){
+	    	DBG_ERR("get cont shut failed\n");
+	    	goto EXIT;
+	    }
+
+	    yuv_size = VDO_YUV_BUFSIZE(sensor_info->sSize.w, sensor_info->sSize.h , HD_VIDEO_PXLFMT_YUV420);
 
 		PhotoFast_Movie_Init();
-
 		PhotoFast_SliceEncode_Open(alg_path);
-		PhotoFast_SliceEncode2_Open(alg_path, 1);
+		PhotoFast_SliceEncode2_Open(alg_path, max_cnt);
 
-		HD_VIDEO_FRAME frame = {0};
+		for(UINT32 i = 0 ; i < max_cnt ; i++)
-		UINT32 addr_dst[HD_VIDEO_MAX_PLANE] = {0};
+		{
-		UINT32 loff_dst[HD_VIDEO_MAX_PLANE] = {0};
+			HD_VIDEO_FRAME frame = {0};
-		UINT32 buf_size = 0;
+			UINT32 addr_dst[HD_VIDEO_MAX_PLANE] = {0};
+			UINT32 loff_dst[HD_VIDEO_MAX_PLANE] = {0};
+			HD_COMMON_MEM_VB_BLK blk = 0;
 
-		HD_COMMON_MEM_VB_BLK blk = 0;
+			blk = hd_common_mem_get_block(HD_COMMON_MEM_COMMON_POOL, yuv_size, DDR_ID0); // Get block from mem pool
-		buf_size = VDO_YUV_BUFSIZE(sensor_info->sSize.w, sensor_info->sSize.h , HD_VIDEO_PXLFMT_YUV420);
+			if (blk == HD_COMMON_MEM_VB_INVALID_BLK) {
-		blk = hd_common_mem_get_block(HD_COMMON_MEM_COMMON_POOL, buf_size, DDR_ID0); // Get block from mem pool
+				DBG_ERR("hd_common_mem_get_block failed!(size=%lx)\n", yuv_size);
-		if (blk == HD_COMMON_MEM_VB_INVALID_BLK) {
+			}
-			DBG_ERR("hd_common_mem_get_block failed!(size=%lx)\n", buf_size);
-		}
 
-		buf_pa = hd_common_mem_blk2pa(blk);
+			buf_pa = hd_common_mem_blk2pa(blk);
-		if (buf_pa == 0) {
+			if (buf_pa == 0) {
-			DBG_ERR("hd_common_mem_blk2pa failed!(blk=0x%x)\n", blk);
+				DBG_ERR("hd_common_mem_blk2pa failed!(blk=0x%x)\n", blk);
-		}
+			}
 
-		buf_va = (void*)hd_common_mem_mmap(HD_COMMON_MEM_MEM_TYPE_CACHE, buf_pa, buf_size);
+			buf_va = (void*)hd_common_mem_mmap(HD_COMMON_MEM_MEM_TYPE_CACHE, buf_pa, yuv_size);
-		if (buf_va == 0) {
+			if (buf_va == 0) {
-			DBG_ERR("hd_common_mem_mmap failed!\r\n");
+				DBG_ERR("hd_common_mem_mmap failed!\r\n");
-		}
+			}
 
-		if(buf_pa){
+			if(buf_pa){
-			/* dst img */
+				/* dst img */
-			addr_dst[0] = buf_pa;
+				addr_dst[0] = buf_pa;
-			loff_dst[0] = sensor_info->sSize.w;
+				loff_dst[0] = sensor_info->sSize.w;
-			addr_dst[1] = addr_dst[0] + loff_dst[0] * sensor_info->sSize.h;
+				addr_dst[1] = addr_dst[0] + loff_dst[0] * sensor_info->sSize.h;
-			loff_dst[1] = sensor_info->sSize.w;
+				loff_dst[1] = sensor_info->sSize.w;
-			vf_init_ex(&frame, sensor_info->sSize.w, sensor_info->sSize.h, HD_VIDEO_PXLFMT_YUV420, loff_dst, addr_dst);
+				vf_init_ex(&frame, sensor_info->sSize.w, sensor_info->sSize.h, HD_VIDEO_PXLFMT_YUV420, loff_dst, addr_dst);
 
-			FST_FILE fp = FileSys_OpenFile(MOIVE2_YUV_PATH, FST_OPEN_READ);
+				memcpy((void*)buf_pa, (void*)(tmp_buf), yuv_size);
-			if(fp){
+				tmp_buf += yuv_size;
-				FileSys_ReadFile(fp, (UINT8*)buf_va, &buf_size, 0, NULL);
+
-				FileSys_CloseFile(fp);
+				DBG_DUMP("enq %lu\n", i);
+
+				while(1)
+				{
+					if(PhotoFast_Sliceencode2_Enq_Frame(&frame) == E_OK){
+						break;
+					}
+					else{
+						vos_util_delay_ms(1);
+					}
+				}
 
-				PhotoFast_Sliceencode2_Enq_Frame(&frame);
-				PhotoFast_SliceEncode2_Close();
 			}
 			else{
-				DBG_ERR("%s not found!\n", MOIVE2_YUV_PATH);
+				DBG_ERR("allocate %lx failed!\n", yuv_size);
 			}
 		}
-		else{
+
-			DBG_ERR("allocate %lx failed!\n", buf_size);
+		fastboot_set_done(BOOT_FLOW_MOVIE2);
-		}
+		PhotoFast_SliceEncode2_Close();
 	}
 
+EXIT:
+
 	DCF_Close(g_dcf_hdl);
 	DCF_UnInstallID();
 

rtos/code/application/source/cardv/SrcCode/UIApp/PhotoFast/PhotoFast.c

@@ -1184,9 +1184,9 @@ static INT32 PhotoFast_CaptureStart(HD_VIDEO_FRAME *p_video_frame)
 	}
 
 #if POWERON_FAST_SLICE_ENC_VER2 == ENABLE
-    return PhotoFast_Sliceencode2_Enq_Frame(p_video_frame);
+	return PhotoFast_Sliceencode2_Enq_Frame(p_video_frame);
 #else
-	PhotoFast_SliceEncode(vprc_path, p_video_frame);
+	return PhotoFast_SliceEncode(vprc_path, p_video_frame);
 #endif
 
 }
@@ -1427,6 +1427,7 @@ THREAD_RETTYPE PhotoFast_FlowPreviewThread(void *arg)
 	UINT32 max_cnt = 0;
 	BOOL start_cap = FALSE;
 	BOOL stop_flag = FALSE;
+	BOOL led_flag = FALSE;
 
 #if HUNTING_CAMERA_MCU == ENABLE
     UIMenuStoreInfo *puiPara = sf_ui_para_get();
@@ -1485,9 +1486,10 @@ THREAD_RETTYPE PhotoFast_FlowPreviewThread(void *arg)
 	period = 1000 / max_cnt;
 #endif
 
-	DBG_DUMP("period = %lu ms\n", period);
 
 
+	DBG_DUMP("period = %lu ms, max_cnt = %lu\n", period, max_cnt);
+
 	PhotoFast_SliceEncode2_Open(vprc_path, max_cnt);
 	nvt_cmdsys_runcmd("ae set_speed 0 128 700 700 100 ");
 
@@ -1546,7 +1548,7 @@ THREAD_RETTYPE PhotoFast_FlowPreviewThread(void *arg)
 			VOS_TICK t1, t2;
 			UINT32 duration;
 			UINT32 led_delay = 170;
-
+            led_flag = FALSE;
 			vos_perf_mark(&t1);
 
 			/**************************************************
@@ -1565,7 +1567,8 @@ THREAD_RETTYPE PhotoFast_FlowPreviewThread(void *arg)
 				if((duration >= period) ||((period - duration) <= (led_delay + 17))
 
 				){
-					if(sf_is_night_mode(0) ==TRUE){
+					if((FALSE == led_flag) && (sf_is_night_mode(0) ==TRUE)){
+                        led_flag = TRUE;
 						sf_ir_led_set(((2 == puiPara->NightMode) ? 2 : 1),puiPara->FlashLed, puiPara->NightMode,0);
 					}
 
@@ -1719,7 +1722,7 @@ THREAD_RETTYPE PhotoFast_FlowPreviewThread(void *arg)
 		case DX_HUNTING_MODE_PHOTO_MOVIE:
 
 			if (start_cap == TRUE) {
-				// g_u32PrvCapCnt++;
+				
 				#if HUNTING_CAMERA_MCU == ENABLE
 				if(sf_is_night_mode(0) ==TRUE){
 				    //DrvGPIO_IRLed_Turn_Onoff(0);
@@ -1732,11 +1735,12 @@ THREAD_RETTYPE PhotoFast_FlowPreviewThread(void *arg)
                 }
                 else{
                     DBG_WRN("enq frame failed...\n");
-                    /* release */
+
-                    if ((hd_ret = hd_videoproc_release_out_buf(vprc_path, &video_frame))!= HD_OK) {
+            		/* release */
-                        DBG_ERR("failed to hd_videoproc_release_out_buf, er=%d\n", (int)hd_ret);
+            		if ((hd_ret = hd_videoproc_release_out_buf(vprc_path, &video_frame))!= HD_OK) {
-                        goto exit;
+            			DBG_ERR("failed to hd_videoproc_release_out_buf, er=%d\n", (int)hd_ret);
-                    }
+            			goto exit;
+            		}
                 }
 
 				if (g_u32PrvCapCnt >= max_cnt) {
@@ -2086,7 +2090,12 @@ void Set_AEMODE(UINT32 id)
 		if (id == 1){
 				ae_manual.manual.mode = 1;
 				#if HUNTING_CAMERA_MCU == ENABLE
-				if (puiPara->NightMode == 0) {
+                if(puiPara->CamMode == SF_CAM_MODE_VIDEO2)
+                {
+                    ae_manual.manual.expotime = 33333;
+			        ae_manual.manual.iso_gain = ae_status.status_info.iso_gain[0]*ae_status.status_info.expotime[0]/33333;
+                }
+				else if (puiPara->NightMode == 0) {
 					ae_manual.manual.expotime = 125000;//ae_status.status_info.expotime[0];
 				    ae_manual.manual.iso_gain = ae_status.status_info.iso_gain[0]*ae_status.status_info.expotime[0]/125000;
 					}
@@ -2266,7 +2275,7 @@ ER PhotoFast_Movie_Init(void)
 	id++;
 	mem_cfg.pool_info[id].type = HD_COMMON_MEM_COMMON_POOL;
 	mem_cfg.pool_info[id].blk_size = DBGINFO_BUFSIZE()+VDO_YUV_BUFSIZE(sensor_info->sSize.w, sensor_info->sSize.h , HD_VIDEO_PXLFMT_YUV420);
-	mem_cfg.pool_info[id].blk_cnt = 1;
+	mem_cfg.pool_info[id].blk_cnt = 3;  /* depending on cont shot */
 	mem_cfg.pool_info[id].ddr_id = DDR_ID0;
 
 	vendor_common_mem_relayout(&mem_cfg);

rtos/code/application/source/cardv/SrcCode/UIApp/PhotoFast/PhotoFastSliceEncode.c

@@ -639,7 +639,7 @@ static INT32 PhotoFast_SliceEncode_Alloc_Buffer(PhotoFast_MEM_Info* info, char*
 #else
 	if ((ret = hd_common_mem_alloc(name, &info->pa, (void **)&va_ptr, info->blk_size, ddr_id)) != HD_OK) {
 #endif
-		DBG_ERR("hd_common_mem_alloc failed(%d)\r\n", ret);
+		DBG_ERR("hd_common_mem_alloc failed(size:%d name:%s)\r\n", ret, name);
 		return E_SYS;
 	}
 
@@ -2085,7 +2085,7 @@ INT32 PhotoFast_SliceEncode_CB2(void* user_data)
 		if(PhotoFast_SliceEncode_Alloc_Buffer_Retry(
 				&slice_encode_screennail_info->bs_buf_mem_info,
 				"slice_enc_screennail",
-				10,
+				50,
 				100
 		) != E_OK){
 			goto EXIT;
@@ -2246,9 +2246,11 @@ INT32 PhotoFast_SliceEncode_CB2(void* user_data)
 		param->cnt++;
 		if(param->cnt >= param->max_cnt)
 			break;
+        #if SF_NO_SD_SEND == ENABLE
         if(fastboot_wait_done_timeout(BOOT_INIT_FILESYSOK, 1) != E_OK){
             goto EXIT;
         }
+        #endif
 	} while(1);
 
 EXIT:

rtos/code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIInfo/DateTimeInfo.c

@@ -30,7 +30,7 @@ INT32  gUITimeHour = 0;
 INT32  gUITimeMinute = 0;
 INT32  gUITimeSecond = 0;
 
-INT32  gUIDateSetFmt = DATEFMT_YMD;
+INT32  gUIDateSetFmt = DATEFMT_MDY;
 INT32  gUITimeSetFmt = TIMEFMT_24HR;
 
 void Validate_Date(INT32 *pYear, INT32 *pMonth, INT32 *pDay,
@@ -44,7 +44,7 @@ void DateTime_Init(void)
 	gUIDateMonth = DEF_MONTH;
 	gUIDateDay = DEF_DAY;
 	gUITimeHour = gUITimeMinute = gUITimeSecond = 0;
-	gUIDateSetFmt = DATEFMT_YMD;
+	gUIDateSetFmt = DATEFMT_MDY;
 	gUITimeSetFmt = TIMEFMT_24HR;
 }
 

rtos/code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIInfo/UIInfo.c

@@ -1761,6 +1761,7 @@ void sf_power_on_para_check_init(void)
 	if(puiPara->DateStyle != SysGetFlag(FL_DateFormatIndex))
 	{
 		SysSetFlag(FL_DateFormatIndex, puiPara->DateStyle);
+        SysSetFlag(FL_DATE_FORMAT, puiPara->DateStyle);
 	}
 	if(puiPara->Language != SysGetFlag(FL_LANGUAGE))
 	{