1.自动模式p+v模式调整

rtos/code/application/source/cardv/SrcCode/Dx/565_HUNTING_EVB_LINUX_4G_S550/DxHunting.c

@@ -209,6 +209,10 @@ UINT32 DrvGPIO_GetPhotoMovieModeFromMonitor(void)
             {
                 g_uiBootMode = DX_HUNTING_MODE_MOVIE;
             }
+            else if(SF_CAM_MODE_VIDEO2 == puiPara->CamMode)
+            {
+                g_uiBootMode = DX_HUNTING_MODE_MOVIE2;
+            }
             else
             {
                 g_uiBootMode = DX_HUNTING_MODE_PHOTO_MOVIE;

rtos/code/application/source/cardv/SrcCode/Dx/include/DxHunting.h

@@ -33,10 +33,11 @@
 enum _DX_HUNTING_MODE  //Must match with _HUNTING_MODE in UIInfo.h
 {
 	/* for hunting camera application */
-    DX_HUNTING_MODE_PHOTO           = 0,
+    DX_HUNTING_MODE_PHOTO           = 0, /* PhotoFast */
-    DX_HUNTING_MODE_MOVIE,
+    DX_HUNTING_MODE_MOVIE,       /* MovieFast */
-    DX_HUNTING_MODE_PHOTO_MOVIE,
+    DX_HUNTING_MODE_PHOTO_MOVIE, /* PhotoFast -> MovieFast */
-	DX_HUNTING_MODE_OTHER,
+	DX_HUNTING_MODE_OTHER,		 /* for boot linux */
+	DX_HUNTING_MODE_MOVIE2,		 /* MovieFast + sensor sized photo with slice encode */
 	/* for life camera application */
 	DX_HUNTING_MODE_CAMERA_PHOTO    = 100,
 	DX_HUNTING_MODE_CAMERA_MOVIE,

rtos/code/application/source/cardv/SrcCode/FastFlow/flow_preview.c

@@ -851,55 +851,13 @@ void flow_preview_get_path(HD_PATH_ID *pPath, FLOW_PREIVEW_PATH PathType, UINT32
 
 extern void Set_NIGHTMODE(UINT32 id, UINT8 isSnapVideo);
 extern void DrvGOIO_Turn_Onoff_IRCUT(UINT8 onoff);
-int flow_preview(void)
+
+INT32 flow_preview_load_sen_cfg(void)
 {
-	int ret;
+	INT32 ret = E_OK;
-	// int join_ret;
+	HD_RESULT hd_ret = HD_OK;
-	VK_TASK_HANDLE handle_sensor = 0;
-	VK_TASK_HANDLE handle_cap_proc = 0;
-	VK_TASK_HANDLE handle_preview = 0;
-	// int policy;
     PHOTO_SENSOR_INFO sen_cfg = {0};
     PHOTO_SENSOR_INFO *pSenCfg = &sen_cfg;
-    HD_RESULT hd_ret;
-	// struct sched_param schedparam = {0};
-	T_CFLG cflg = {0};
-	FLGPTN flag_ptn;
-
-#if (_PACKAGE_DISPLAY_)
-	VK_TASK_HANDLE handle_videoout = 0;
-#endif
-
-	if(!flag_task){
-		if ((ret = vos_flag_create(&flag_task, &cflg, "flow_preview")) != E_OK) {
-			DBG_ERR("create flag failed!(%d)\n", ret);
-			return -1;
-		}
-	}
-
-	// quick sensor setup
-	vos_flag_clr(flag_task, FLAG_SENSOR_TASK_EXIT);
-	handle_sensor = vos_task_create(thread_sensor, NULL, "init_sensor", 10, DEFAULT_TASK_STACK_SIZE);
-	if(!handle_sensor){
-		DBG_ERR("create thread_sensor failed\r\n");
-		return -1;
-	}
-	else
-		vos_task_resume(handle_sensor);
-
-	//hd_common_init(including vds), must wait until insmod_capture()
-	fastboot_wait_done(BOOT_INIT_CAPTURE);
-
-	// init hdal
-	ret = fastflow_common_init();
-	if (ret != HD_OK) {
-		DBG_ERR("init fail\r\n");
-	}
-	ret = flowpreview_mem_relayout();
-	if (ret != HD_OK) {
-		DBG_ERR("relayout fail\r\n");
-	}
-
     //load ae/awb/iq
 	System_GetSensorInfo(0, SENSOR_AE_PATH, &(sen_cfg.ae_path));
 	System_GetSensorInfo(0, SENSOR_AWB_PATH, &(sen_cfg.awb_path));
@@ -988,8 +946,59 @@ int flow_preview(void)
 	if ((hd_ret = vendor_isp_uninit()) != HD_OK) {
 		DBG_ERR("vendor_isp_uninit fail(%d)\n", hd_ret);
 	}
-	
+	return ret;
+}
 
+int flow_preview(void)
+{
+	int ret;
+	// int join_ret;
+	VK_TASK_HANDLE handle_sensor = 0;
+	VK_TASK_HANDLE handle_cap_proc = 0;
+	VK_TASK_HANDLE handle_preview = 0;
+	// int policy;
+//    PHOTO_SENSOR_INFO sen_cfg = {0};
+//    PHOTO_SENSOR_INFO *pSenCfg = &sen_cfg;
+//    HD_RESULT hd_ret;
+	// struct sched_param schedparam = {0};
+	T_CFLG cflg = {0};
+	FLGPTN flag_ptn;
+
+#if (_PACKAGE_DISPLAY_)
+	VK_TASK_HANDLE handle_videoout = 0;
+#endif
+
+	if(!flag_task){
+		if ((ret = vos_flag_create(&flag_task, &cflg, "flow_preview")) != E_OK) {
+			DBG_ERR("create flag failed!(%d)\n", ret);
+			return -1;
+		}
+	}
+
+	// quick sensor setup
+	vos_flag_clr(flag_task, FLAG_SENSOR_TASK_EXIT);
+	handle_sensor = vos_task_create(thread_sensor, NULL, "init_sensor", 10, DEFAULT_TASK_STACK_SIZE);
+	if(!handle_sensor){
+		DBG_ERR("create thread_sensor failed\r\n");
+		return -1;
+	}
+	else
+		vos_task_resume(handle_sensor);
+
+	//hd_common_init(including vds), must wait until insmod_capture()
+	fastboot_wait_done(BOOT_INIT_CAPTURE);
+
+	// init hdal
+	ret = fastflow_common_init();
+	if (ret != HD_OK) {
+		DBG_ERR("init fail\r\n");
+	}
+	ret = flowpreview_mem_relayout();
+	if (ret != HD_OK) {
+		DBG_ERR("relayout fail\r\n");
+	}
+
+	flow_preview_load_sen_cfg();
 	vos_flag_clr(flag_task, FLAG_CAP_PROC_TASK_EXIT);
 	handle_cap_proc = vos_task_create(thread_cap_proc, NULL, "cap_proc", 10, DEFAULT_TASK_STACK_SIZE);
 	if(!handle_cap_proc){

rtos/code/application/source/cardv/SrcCode/FastFlow/flow_preview.h

@@ -19,4 +19,5 @@ extern void flow_preview_close_module(void);
 extern void flow_preview_uninit_module(void);
 extern void flow_preview_set_stop_flag(BOOL flag);
 extern BOOL flow_preview_get_stop_flag(void);
+extern INT32 flow_preview_load_sen_cfg(void);
 #endif

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

@@ -634,7 +634,7 @@ static void insmod_encoder(void)
 
 		vos_perf_list_mark(__func__, __LINE__, 1);
     } else { //fastboot
-    	fwload_wait_done(CODE_SECTION_05);
+    	fwload_wait_done(CODE_SECTION_06);
 
     	/* media encoder */
     #if (_PACKAGE_VIDEO_)
@@ -967,7 +967,7 @@ static void fastboot(void)
 			vos_task_resume(handle_photo_filenaming);
 
 		break;
-
+    case DX_HUNTING_MODE_MOVIE2:
     case DX_HUNTING_MODE_MOVIE:
     case DX_HUNTING_MODE_CAMERA_MOVIE:
 
@@ -984,11 +984,7 @@ static void fastboot(void)
 // #endif
 #endif
 
-		// wait all text-code loaded
+        fwload_wait_done(CODE_SECTION_06);
-		fwload_wait_done(CODE_SECTION_10);
-
-		System_OnPowerPreInit();
-		System_OnVideoFastbootInit();
 
 		handle_movie_filenaming = vos_task_create(MovieFast_InitFileNamingThread, "init_fn", NULL, 10, 8192);
 		if (!handle_movie_filenaming) {
@@ -997,7 +993,6 @@ static void fastboot(void)
 		else
 			vos_task_resume(handle_movie_filenaming);
 
-		fastboot_wait_done(BOOT_INIT_FILENAMINGOK);
 
 		handle_movie_moviemode = vos_task_create(MovieFast_InitMovieModeThread, "init_movie", NULL, 10, 8192);
 		if (!handle_movie_moviemode) {
@@ -1005,7 +1000,11 @@ static void fastboot(void)
 		}
 		else
 			vos_task_resume(handle_movie_moviemode);
-
+        
+		/* GxTime, for stamp */
+		fwload_wait_done(CODE_SECTION_10);
+		System_OnPowerPreInit();
+		System_OnVideoFastbootInit();
 		break;
 
     case DX_HUNTING_MODE_OTHER: /* boot linux only */

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

@@ -16,6 +16,7 @@
 #include "PrjCfg.h"
 #include "sys_fwload.h"
 #include "sys_storage_partition.h"
+#include "DxHunting.h"
 
 //#NT#PARTIAL_COMPRESS, we use rtos-main size + 1 block size
 #define FW_PARTIAL_COMPRESS_WORK_BUF_SIZE 0x320000
@@ -30,11 +31,16 @@ static ID fwload_flg_id = 0;
 static UINT32 UserSection_Load[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 
 //This array is sort by loading order
-static UINT32 UserSection_Order_full[] = {
+static UINT32 UserSection_Order_common[] = {
 	CODE_SECTION_02, CODE_SECTION_03, CODE_SECTION_04, CODE_SECTION_05, CODE_SECTION_06,
 	CODE_SECTION_07, CODE_SECTION_08, CODE_SECTION_09, CODE_SECTION_10, FWSRV_PL_BURST_END_TAG
 };
 
+static UINT32 UserSection_Order_movie_fast_mode2[] = {
+	CODE_SECTION_02, CODE_SECTION_03, CODE_SECTION_04, CODE_SECTION_06, CODE_SECTION_05,
+	CODE_SECTION_07, CODE_SECTION_08, CODE_SECTION_09, CODE_SECTION_10, FWSRV_PL_BURST_END_TAG
+};
+
 int fwload_init(void)
 {
 	vos_flag_create(&fwload_flg_id, NULL, "fwload_flg_id");
@@ -168,7 +174,14 @@ int fwload_partload(void)
 
 	// start partial load
 	void (*LoadCallback)(const UINT32 Idx) = UserSection_LoadCb;
-	UINT32 *SecOrderTable = UserSection_Order_full;
+	UINT32 *SecOrderTable = NULL;
+
+	if(DrvGPIO_GetPhotoMovieModeFromMonitor() == DX_HUNTING_MODE_MOVIE2){
+		SecOrderTable = UserSection_Order_movie_fast_mode2;
+	}
+	else{
+		SecOrderTable = UserSection_Order_common;
+	}
 
 	LoadCallback(CODE_SECTION_01); // 1st part has loaded by loader
 

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

@@ -6,9 +6,12 @@
 #include "SysSensor.h"
 #include <kwrap/debug.h>
 #include "flow_boot_logo.h"
+#include "UIApp/PhotoFast/PhotoFastSliceEncode.h"
+#include "UIAppPhoto_Param.h"
 #if HUNTING_CAMERA_MCU == ENABLE
-#include "sf_mcu.h"
+#include <sf_mcu.h>
 #endif
+#include "DxHunting.h"
 //#define ENABLE      1
 //#define DISABLE     0
 
@@ -106,7 +109,22 @@
 
 static HD_COMMON_MEM_INIT_CONFIG mem_cfg = {0};
 
+static void Movie_CommPoolInit_Mode1(void);
+static void Movie_CommPoolInit_Mode2(void);
+
 void Movie_CommPoolInit(void)
+{
+	UINT32 mode = DrvGPIO_GetPhotoMovieModeFromMonitor();
+
+	if(mode == DX_HUNTING_MODE_MOVIE || mode == DX_HUNTING_MODE_PHOTO_MOVIE){
+		Movie_CommPoolInit_Mode1();
+	}
+	else{ /* DX_HUNTING_MODE_MOVIE2 */
+		Movie_CommPoolInit_Mode2();
+	}
+}
+
+static void Movie_CommPoolInit_Mode1(void)
 {
 	UINT32 id=0;
 	UINT32 vcap_buf_size = 0;
@@ -226,6 +244,78 @@ void Movie_CommPoolInit(void)
 
 	ImageApp_MovieMulti_Config(MOVIE_CONFIG_MEM_POOL_INFO, (UINT32)&mem_cfg);
 }
+
+static void Movie_CommPoolInit_Mode2(void)
+{
+	UINT32 id=0;
+	UINT32 vcap_buf_size = 0;
+	HD_VIDEO_PXLFMT vcap_fmt = HD_VIDEO_PXLFMT_RAW12;
+
+	const UINT32 vdo_size_w = 2592;
+	const UINT32 vdo_size_h = 1944;
+
+	const UINT32 main_size_w = 1920;
+	const UINT32 main_size_h = 1080;
+
+	const UINT32 clone_size_w = 640;
+	const UINT32 clone_size_h = 360;
+
+
+	/*******************************************************************
+	 * VCap + Main
+	 *******************************************************************/
+
+	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);
+	}
+	/* raw */
+	else {
+		vcap_buf_size = VDO_RAW_BUFSIZE(vdo_size_w, vdo_size_h, vcap_fmt);
+	}
+
+	#if (MOVIE_DIRECT_FUNC == ENABLE)
+	if (id == 0) {
+		vcap_buf_size = 0;
+	}
+	#endif
+
+	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 = 6;
+	mem_cfg.pool_info[id].ddr_id = DDR_ID0;
+
+	/*******************************************************************
+	 * Main
+	 *******************************************************************/
+	id ++;
+	mem_cfg.pool_info[id].type = HD_COMMON_MEM_COMMON_POOL;
+	mem_cfg.pool_info[id].blk_size = DBGINFO_BUFSIZE() + VDO_YUV_BUFSIZE(main_size_w, main_size_h, HD_VIDEO_PXLFMT_YUV420);
+	mem_cfg.pool_info[id].blk_cnt = 4;
+	mem_cfg.pool_info[id].ddr_id = DDR_ID0;
+
+	/*******************************************************************
+	 * Clone
+	 *******************************************************************/
+	id ++;
+	mem_cfg.pool_info[id].type = HD_COMMON_MEM_COMMON_POOL;
+	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_cnt = 4;
+	mem_cfg.pool_info[id].ddr_id = DDR_ID0;
+
+
+	extern MOVIE_ALG_INFO gMovie_Alg_Info[];
+	UIAPP_PHOTO_SENSOR_INFO *sensor_info = UIAppPhoto_get_SensorInfo(0);
+	gMovie_Alg_Info[0].path13.ImgSize = (USIZE) {sensor_info->sSize.w, sensor_info->sSize.h};
+
+	ImageApp_MovieMulti_Config(MOVIE_CONFIG_MEM_POOL_INFO, (UINT32)&mem_cfg);
+}
+
 void Movie_CommPool_AI2_Init(void)
 {
 #if (ALG_FUNC_AI2 == ENABLE)

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

@@ -32,7 +32,12 @@
 #include "DxHunting.h"
 #include "flow_preview.h"
 #include <kwrap/cmdsys.h>
-
+#include "UIApp/PhotoFast/PhotoFast.h"
+#include "UIApp/PhotoFast/PhotoFastSliceEncode.h"
+#include "UIApp/PhotoFast/PhotoFastCapDateImprint.h"
+#include "UIAppPhoto_Param.h"
+#include "sys_fwload.h"
+#include "../lfqueue/lfqueue.h"
 #if defined(_UI_STYLE_LVGL_)
 #include "flow_lvgl.h"
 #endif
@@ -57,14 +62,30 @@
 #define FLG_EXE_MOVIE_RECSTART		FLGPTN_BIT(1)               ///< trigger display task
 #define FLG_EXE_MOVIE_RECSTOP       FLGPTN_BIT(2)               ///< stop task
 
+#define VDO_YUV_BUFSIZE(w, h, pxlfmt)	ALIGN_CEIL_4(((w) * (h) * HD_VIDEO_PXLFMT_BPP(pxlfmt)) / 8)
+
+typedef enum {
+	MOVIEFAST_IQ_VIDEO,
+	MOVIEFAST_IQ_PHOTO,
+} MOVIEFAST_IQ_CFG;
+
+typedef struct {
+	void* va;
+	UINT32 size;
+	char path[256];
+	HD_VIDEO_FRAME frame;
+	HD_PATH_ID vprc_path_id;
+} MOVIEFAST_WRITE_QUEUE_PARAM;
 /**********************************************************************************
  * independent thumbnail
  *********************************************************************************/
 
 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
@@ -78,9 +99,13 @@ 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_power_off_tsk_id = 0;
+static THREAD_HANDLE g_moviefast_write_tsk_id = 0;
 static BOOL g_bIsRecStatus = 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;
+static VOS_TICK g_vprc_trigger_frm_time= 0;
+static UINT32 g_vprc_trigger_frm_count= 0;
 
 //local function
 static void MovieFast_OnRecStart(void);
@@ -89,6 +114,7 @@ static void MovieFast_CmdTsk_Exit(void);
 static int MovieFast_GetWaterLogoSource(const UINT32 recWidth,WATERLOGO_BUFFER *waterSrc);
 static void MovieFast_ShutDown(void);
 static void MovieFast_Close(void);
+static void MovieFast_Load_Sen_Cfg(MOVIEFAST_IQ_CFG cfg);
 
 static VOID MovieFast_Set_RecStartTick(VOS_TICK tick)
 {
@@ -247,6 +273,14 @@ static void MovieFast_ShutDown(void)
 #if POWERON_BOOT_REPORT == ENABLE
 
 	DBG_DUMP("PhotoMovie mode = %u\n", mode);
+	VOS_TICK tick;
+
+	PhotoFast_GetTick(g_vprc_trigger_frm_count, &tick);
+
+	DBG_DUMP("\n\n**********************************************************\n"
+			" Trigger Speed(vcap frame count = %lu) : %lu us  alg_start_time = %lu g_alg_end_time = %lu,  perf tick = %lu us\n"
+			"**********************************************************\n",
+			g_vprc_trigger_frm_count, g_vprc_trigger_frm_time, g_alg_start_time, g_alg_end_time, tick);
 
 	vos_perf_list_dump();
 
@@ -284,6 +318,15 @@ static void MovieFast_ShutDown(void)
 
 #if POWERON_BOOT_REPORT == ENABLE
 
+	VOS_TICK tick;
+
+	PhotoFast_GetTick(g_vprc_trigger_frm_count, &tick);
+
+	DBG_DUMP("\n\n**********************************************************\n"
+			" Trigger Speed(vcap frame count = %lu) : %lu us  alg_start_time = %lu g_alg_end_time = %lu,  perf tick = %lu us\n"
+			"**********************************************************\n",
+			g_vprc_trigger_frm_count, g_vprc_trigger_frm_time, g_alg_start_time, g_alg_end_time, tick);
+
 	vos_perf_list_dump();
 	if(mode == DX_HUNTING_MODE_PHOTO_MOVIE){
 		MovieFast_PV_Info_Dump();
@@ -464,7 +507,7 @@ static void MovieFast_RecMovieStamp(void)
 	            NULL);
 #endif
 	    }
-#if 1
+#if 0
 	    // set rawenc path 1st movie stamp
 	    if (movie_rec_mask & mask) {
 	        Width = gMovie_Rec_Info[i].size.w;
@@ -664,6 +707,7 @@ static void MovieFast_OnRecStart(void)
     }
 
 #if defined(_UI_STYLE_LVGL_)
+    fwload_wait_done(CODE_SECTION_05);
 	flow_lv_init();
 #endif
 
@@ -821,6 +865,45 @@ static void MovieFast_FileNamingCB(MOVIE_CFG_REC_ID id, char *pFileName)
 	}
 }
 
+static void MovieFast_WriteFile_Task(void* arg)
+{
+	lfqueue_t* queue = (lfqueue_t*)arg;
+	MOVIEFAST_WRITE_QUEUE_PARAM* param;
+
+	fastboot_wait_done(BOOT_INIT_FILESYSOK);
+
+	while(1)
+	{
+		param = (MOVIEFAST_WRITE_QUEUE_PARAM*) lfqueue_deq(queue);
+		if(param == NULL){
+			vos_util_delay_ms(5);
+			continue;
+		}
+
+		if(param->va){
+			DBG_DUMP("Write %s\n", param->path);
+
+			FST_FILE fp = FileSys_OpenFile(param->path, FST_OPEN_ALWAYS | FST_OPEN_WRITE);
+			FileSys_WriteFile(fp, (UINT8*)param->va, &param->size, 0, NULL);
+			FileSys_CloseFile(fp);
+
+			free(param->va);
+		}
+		else if(param->frame.phy_addr[0]){
+			DBG_DUMP("Write %s\n", param->path);
+
+			FST_FILE fp = FileSys_OpenFile(param->path, FST_OPEN_ALWAYS | FST_OPEN_WRITE);
+			FileSys_WriteFile(fp, (UINT8*)param->frame.phy_addr[0], &param->size, 0, NULL);
+			FileSys_CloseFile(fp);
+
+			hd_videoproc_release_out_buf(param->vprc_path_id, &param->frame);
+		}
+
+		if(param){
+			free(param);
+		}
+	}
+}
 static void MovieFast_UserEventCb(UINT32 id, MOVIE_USER_CB_EVENT event_id, UINT32 value)
 {
 	//static UINT32 u32Cnt = 0;
@@ -860,8 +943,6 @@ static void MovieFast_UserEventCb(UINT32 id, MOVIE_USER_CB_EVENT event_id, UINT3
 
 	case MOVIE_USER_CB_EVENT_JENC_DONE:{
 
-		fastboot_wait_done(BOOT_INIT_FILESYSOK);
-
 		MOVIE_JPEG_INFO *ptr = (MOVIE_JPEG_INFO*)value;
 
 		if(ptr->sign == MAKEFOURCC('T', 'H', 'U', 'M')){
@@ -892,11 +973,26 @@ static void MovieFast_UserEventCb(UINT32 id, MOVIE_USER_CB_EVENT event_id, UINT3
                     #endif
 					DBG_DUMP("MOVIE_USER_CB_EVENT_JENC_DONE %s\n", tmp);
 
-					FST_FILE fp = FileSys_OpenFile(tmp, FST_CREATE_ALWAYS | FST_OPEN_WRITE);
+					MOVIEFAST_WRITE_QUEUE_PARAM* param = (MOVIEFAST_WRITE_QUEUE_PARAM*) malloc(sizeof(MOVIEFAST_WRITE_QUEUE_PARAM));
 
-					FileSys_WriteFile(fp, (UINT8*)ptr->addr_va, &ptr->size, 0, NULL);
+					if(param){
-                    FileSys_FlushFile(fp);
+
-					FileSys_CloseFile(fp);
+						memset(param, 0, sizeof(MOVIEFAST_WRITE_QUEUE_PARAM));
+						param->size = ptr->size;
+						param->va = (void *)malloc(param->size);
+						snprintf(param->path, sizeof(param->path), tmp);
+						if(param->va){
+							memcpy(param->va, (void*)ptr->addr_va, param->size);
+							while (lfqueue_enq(&write_queue, (void*) param) == -1)
+							{
+							    DBG_ERR("ENQ Full ?\r\n");
+							}
+						}
+						else{
+							DBG_ERR("malloc thumb va err!\n");
+							free(param);
+						}
+					}
 					thumb_current_path[0] = '\0';
 				}
 			}
@@ -939,6 +1035,7 @@ int MovieFast_GetWaterLogoSource(const UINT32 recWidth,WATERLOGO_BUFFER *waterSr
 	return E_OK;
 }
 
+
 THREAD_RETTYPE MovieFast_InitFileNamingThread(void *arg)
 {
 	if(DrvGPIO_GetPhotoMovieModeFromMonitor() != DX_HUNTING_MODE_PHOTO_MOVIE ){
@@ -979,21 +1076,62 @@ void MovieFast_Set_Shutdown_flag(void)
 	vos_flag_set(MOVIEFAST_FLG_ID, FLGMOVIEFAST_SHUTDOWN);
 }
 
+static void MovieFast_Load_Sen_Cfg(MOVIEFAST_IQ_CFG cfg)
+{
+	MOVIE_SENSOR_INFO sen_cfg = {0};
+	MOVIE_SENSOR_INFO *pSenCfg = &sen_cfg;
+	UINT32 size = sizeof(pSenCfg->iq_path.path) - 1;
+
+	for (int i = 0; i < SENSOR_CAPS_COUNT; 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(cfg == MOVIEFAST_IQ_VIDEO){
+			strncpy(pSenCfg->iq_path.path, "/isp/iq/os05b10_iq_0_vid", size);
+		}
+		else{ /* MOVIEFAST_IQ_PHOTO */
+
+			if(sf_is_night_mode(0) ==TRUE)
+				strncpy(pSenCfg->iq_path.path, "/isp/iq/os05b10_iq_0", size);
+			else
+				strncpy(pSenCfg->iq_path.path, "/isp/iq/os05b10_iq_0_cap", size);
+		}
+
+		ImageApp_MovieMulti_Config(MOVIE_CONFIG_SENSOR_INFO, (UINT32)&sen_cfg);
+	}
+}
+
 THREAD_RETTYPE MovieFast_InitMovieModeThread(void *arg)
 {
 	UINT32 i;
 	MOVIEMULTI_MAX_LINK_INFO MaxLinkInfo = {1, 0, 0, 1, 0};   //Img, Disp, Wifi, AudCap, EthCam
-	MOVIE_SENSOR_INFO sen_cfg = {0};
-	MOVIE_SENSOR_INFO *pSenCfg = &sen_cfg;
-	HD_RESULT hd_ret;
 
 	DBG_FUNC("\r\n");
+    UINT32 rec_type = MovieMapping_GetRecType(UI_GetData(FL_MOVIE_SIZE));
 
 	Movie_CommPoolInit();
 
+	if(DrvGPIO_GetPhotoMovieModeFromMonitor() == DX_HUNTING_MODE_MOVIE2){
+
+		//UI_SetData(FL_MOVIE_SIZE, MOVIE_SIZE_CLONE_1920x1080P30_1280x720P30);
+		Set_NIGHTMODE(0, 0);
+	}
+	else{
+	    Set_NIGHTMODE(0, 1);
+		Set_AEMODE(0);
+	}
+
 	MovieFast_SetRecInfoByUISetting();
-    Set_NIGHTMODE(0, 1);
-	Set_AEMODE(0);
 
 #if (_PACKAGE_DISPLAY_)
 	gMovie_Disp_Info.vout_ctrl = GxVideo_GetDeviceCtrl(DOUT1,DISPLAY_DEVCTRL_CTRLPATH);
@@ -1007,49 +1145,16 @@ THREAD_RETTYPE MovieFast_InitMovieModeThread(void *arg)
 	MaxLinkInfo.MaxDispLink = 1;
 #endif
 	ImageApp_MovieMulti_Config(MOVIE_CONFIG_MAX_LINK_INFO, (UINT32) &MaxLinkInfo);
-	for (i = 0; i < SENSOR_CAPS_COUNT; i++) {
+	ImageApp_MovieMulti_Config(MOVIE_CONFIG_RECORD_INFO, (UINT32)&gMovie_Rec_Info[0]);
-		ImageApp_MovieMulti_Config(MOVIE_CONFIG_RECORD_INFO, (UINT32)&gMovie_Rec_Info[i]);
+	ImageApp_MovieMulti_Config(MOVIE_CONFIG_RECORD_INFO, (UINT32)&gMovie_Clone_Info[0]);
-		ImageApp_MovieMulti_Config(MOVIE_CONFIG_RECORD_INFO, (UINT32)&gMovie_Clone_Info[i]);
+	ImageApp_MovieMulti_Config(MOVIE_CONFIG_ALG_INFO, (UINT32)&gMovie_Alg_Info[0]);
-		ImageApp_MovieMulti_Config(MOVIE_CONFIG_ALG_INFO, (UINT32)&gMovie_Alg_Info[0]);
-		// 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));
-		ImageApp_MovieMulti_Config(MOVIE_CONFIG_SENSOR_INFO, (UINT32)&sen_cfg);
-#if (SENSOR_SIEPATGEN == ENABLE)
-		ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1, MOVIEMULTI_PARAM_VCAP_PAT_GEN, HD_VIDEOCAP_SEN_PAT_COLORBAR);
-#endif
-	}
 
-	if ((hd_ret = vendor_isp_init()) != HD_OK) {
+	if(DrvGPIO_GetPhotoMovieModeFromMonitor() != DX_HUNTING_MODE_MOVIE2){
-		DBG_ERR("vendor_isp_init fail(%d)\n", hd_ret);
+		MovieFast_Load_Sen_Cfg(MOVIEFAST_IQ_VIDEO);
 	}
-	if (strlen(pSenCfg->iq_path.path) != 0) {
+	else{
-		IQT_DTSI_INFO iq_dtsi_info;
+		MovieFast_Load_Sen_Cfg(MOVIEFAST_IQ_PHOTO);
-		iq_dtsi_info.id = pSenCfg->iq_path.id;
+    }
-
-		strncpy(iq_dtsi_info.node_path, "/isp/iq/os05b10_iq_0_vid", 31);
-		strncpy(iq_dtsi_info.file_path, "null", DTSI_NAME_LENGTH);
-		
-		//DBG_ERR("vendor_isp_set_iq %s\r\n",iq_dtsi_info.node_path);
-		
-		iq_dtsi_info.buf_addr = (UINT8 *)pSenCfg->iq_path.addr;
-		if ((hd_ret = vendor_isp_set_iq(IQT_ITEM_RLD_DTSI, &iq_dtsi_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)\n", hd_ret);
-	}
-	
 	MovieMapping_GetStreamInfo(UI_GetData(FL_MOVIE_SIZE), (UINT32)&gMovie_Strm_Info);
 	ImageApp_MovieMulti_Config(MOVIE_CONFIG_STREAM_INFO, (UINT32)&gMovie_Strm_Info);
 	ImageApp_MovieMulti_Config(MOVIE_CONFIG_AUDIO_INFO, (UINT32)&gMovie_Audio_Info);
@@ -1063,7 +1168,6 @@ THREAD_RETTYPE MovieFast_InitMovieModeThread(void *arg)
 	// User Callback
 	ImageApp_MovieMulti_RegUserCB(MovieFast_UserEventCb);
 
-    ImageApp_MovieMulti_SetParam(_CFG_CTRL_ID, MOVIEMULTI_PARAM_FILE_UTC_AUTO_EN, TRUE);
 
 #if (MOVIE_DIRECT_FUNC == ENABLE)
 	ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1, MOVIEMULTI_PARAM_VCAP_OUTFUNC, HD_VIDEOCAP_OUTFUNC_DIRECT);
@@ -1071,10 +1175,34 @@ THREAD_RETTYPE MovieFast_InitMovieModeThread(void *arg)
 	ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1, MOVIEMULTI_PRARM_FILEDB_MAX_MUM, 5000);
 
 
-    MOVIEMULTI_IPL_SIZE_INFO ipl_size={{2560,1440}, 30};
+    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);
+        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);
 
-    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);
+        MOVIEMULTI_IME_CROP_INFO crop_info = {0};
+
+        /* 4:3 -> 16:9 */
+        crop_info.IMESize = (USIZE){1920, 1440};
+        crop_info.IMEWin = (URECT){0, 180, 1920, 1080};
+        ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1 , MOVIEMULTI_PARAM_MAIN_IME_CROP, (UINT32)&crop_info);
+        if(MOVIE_REC_TYPE_CLONE == rec_type)
+        {
+            /* 4:3 -> 16:9 */
+            crop_info.IMESize = (USIZE){640, 480};
+            crop_info.IMEWin = (URECT){0, 60, 640, 360};
+            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};
@@ -1098,8 +1226,42 @@ THREAD_RETTYPE MovieFast_InitMovieModeThread(void *arg)
 		ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1 + i, MOVIEMULTI_PARAM_FILE_FRONT_MOOV, TRUE);
 		ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1 + i, MOVIEMULTI_PARAM_FILE_FRONT_MOOV_FLUSH_SEC, 2);
 	}
+
 	
-	if (1){//gMovie_Alg_Info[_CFG_REC_ID_1 + i].path13.ImgSize.w && gMovie_Alg_Info[_CFG_REC_ID_1 + i].path13.ImgSize.h) {
+	if(DrvGPIO_GetPhotoMovieModeFromMonitor() == DX_HUNTING_MODE_MOVIE2){
+
+		 HD_PATH_ID vprc_in_id = ImageApp_MovieMulti_GetVprc3DNRPort(_CFG_REC_ID_1);
+		 HD_PATH_ID vprc_main_id = ImageApp_MovieMulti_GetVprcPort(_CFG_REC_ID_1, IAMOVIE_VPRC_EX_MAIN);
+		 HD_PATH_ID vprc_alg_id = ImageApp_MovieMulti_GetVprcPort(_CFG_REC_ID_1, IAMOVIE_VPRC_EX_ALG);
+		 HD_PATH_ID vprc_clone_id = ImageApp_MovieMulti_GetVprcPort(_CFG_REC_ID_1, IAMOVIE_VPRC_EX_CLONE);
+		 HD_VIDEOPROC_OUT_EX vprc_out = {0};
+		 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);
+		 hd_videoproc_set(vprc_in_id, HD_VIDEOPROC_PARAM_IN, &vprc_in);
+
+		 /* alg */
+		 hd_videoproc_get(vprc_alg_id, HD_VIDEOPROC_PARAM_OUT_EX, &vprc_out);
+		 vprc_out.frc = HD_VIDEO_FRC_RATIO(1, 1);
+		 hd_videoproc_set(vprc_alg_id, HD_VIDEOPROC_PARAM_OUT_EX, &vprc_out);
+
+		 /* main */
+		 hd_videoproc_get(vprc_main_id, HD_VIDEOPROC_PARAM_OUT_EX, &vprc_out);
+		 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 */
+            hd_videoproc_get(vprc_clone_id, HD_VIDEOPROC_PARAM_OUT_EX, &vprc_out);
+            vprc_out.frc = HD_VIDEO_FRC_RATIO(1, 1);
+    //		 vprc_out.depth = 0;
+            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) {
 		ImageApp_MovieMulti_ImgLinkForAlg((_CFG_REC_ID_1 ), _CFG_ALG_PATH3, ENABLE, TRUE);
 	} 
 
@@ -1114,9 +1276,95 @@ THREAD_RETTYPE MovieFast_InitMovieModeThread(void *arg)
 	//ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1, MOVIEMULTI_PARAM_IMGCAP_THUM_WITH_EXIF, TRUE);   	// enable if wants exif in mp4 thumbnail
 	MovieExe_InitExif();
 #endif
+	if(lfqueue_init(&write_queue)){
+		DBG_ERR("init write_queue failed\n");
+	}
+	else{
+		if ((g_moviefast_write_tsk_id = vos_task_create(MovieFast_WriteFile_Task, &write_queue, "MovieFastThumTsk", PRI_MOVIEFAST_CMDTSK, STKSIZE_MOVIEFAST_CMDTSK)) == 0) {
+			DBG_ERR("MovieFast_Thumb_Task create failed.\r\n");
+		} else {
+			vos_task_resume(g_moviefast_write_tsk_id);
+		}
+	}
 
     MovieFast_InstallID();
-	vos_util_delay_ms(132);
+
+    {
+		HD_VIDEO_FRAME frame;
+		HD_PATH_ID alg_path;
+		BOOL stop = FALSE;
+		UINT32 ae_cnt = 0;
+		UINT32 stop_cnt = 0;
+		BOOL ae_locked = FALSE;
+
+		if(DrvGPIO_GetPhotoMovieModeFromMonitor() == DX_HUNTING_MODE_MOVIE2){
+			ae_cnt = 6;
+			stop_cnt = 12;
+		}
+		else{
+			ae_cnt = 9999;
+			stop_cnt = 12;
+		}
+
+		alg_path = ImageApp_MovieMulti_GetAlgDataPort(_CFG_REC_ID_1, _CFG_ALG_PATH3);
+
+		vos_perf_mark(&g_alg_start_time);
+
+		do {
+
+			hd_videoproc_pull_out_buf(alg_path, &frame, PHOTOFAST_HD_PUSH_PULL_TIMEOUT_MS);
+
+			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);
+				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);
+			}
+		} while(stop == FALSE);
+
+		vos_perf_mark(&g_alg_end_time);
+    }
 
 	if ((g_moviefast_power_off_tsk_id = vos_task_create(MovieFast_PowerOffTsk, 0, "MovieFastPwrTsk", PRI_MOVIEFAST_CMDTSK, STKSIZE_MOVIEFAST_CMDTSK)) == 0) {
 		DBG_ERR("MovieFast_PowerOffTsk create failed.\r\n");
@@ -1147,6 +1395,65 @@ static void MovieFast_Close(void)
 
 	ImageApp_MovieMulti_Close();
 
+	if(DrvGPIO_GetPhotoMovieModeFromMonitor() == DX_HUNTING_MODE_MOVIE2){
+
+		HD_PATH_ID alg_path = ImageApp_MovieMulti_GetAlgDataPort(_CFG_REC_ID_1, _CFG_ALG_PATH3);
+		UIAPP_PHOTO_SENSOR_INFO *sensor_info = UIAppPhoto_get_SensorInfo(0);
+		UINT32 buf_pa = 0;
+		void* buf_va = 0;
+
+		PhotoFast_Movie_Init();
+
+		PhotoFast_SliceEncode_Open(alg_path);
+		PhotoFast_SliceEncode2_Open(alg_path, 1);
+
+		HD_VIDEO_FRAME frame = {0};
+		UINT32 addr_dst[HD_VIDEO_MAX_PLANE] = {0};
+		UINT32 loff_dst[HD_VIDEO_MAX_PLANE] = {0};
+		UINT32 buf_size = 0;
+
+		HD_COMMON_MEM_VB_BLK blk = 0;
+		buf_size = VDO_YUV_BUFSIZE(sensor_info->sSize.w, sensor_info->sSize.h , HD_VIDEO_PXLFMT_YUV420);
+		blk = hd_common_mem_get_block(HD_COMMON_MEM_COMMON_POOL, buf_size, DDR_ID0); // Get block from mem pool
+		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);
+		if (buf_pa == 0) {
+			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);
+		if (buf_va == 0) {
+			DBG_ERR("hd_common_mem_mmap failed!\r\n");
+		}
+
+		if(buf_pa){
+			/* dst img */
+			addr_dst[0] = buf_pa;
+			loff_dst[0] = sensor_info->sSize.w;
+			addr_dst[1] = addr_dst[0] + loff_dst[0] * sensor_info->sSize.h;
+			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);
+
+			FST_FILE fp = FileSys_OpenFile(MOIVE2_YUV_PATH, FST_OPEN_READ);
+			if(fp){
+				FileSys_ReadFile(fp, (UINT8*)buf_va, &buf_size, 0, NULL);
+				FileSys_CloseFile(fp);
+
+				PhotoFast_Sliceencode2_Enq_Frame(&frame);
+				PhotoFast_SliceEncode2_Close();
+			}
+			else{
+				DBG_ERR("%s not found!\n", MOIVE2_YUV_PATH);
+			}
+		}
+		else{
+			DBG_ERR("allocate %lx failed!\n", buf_size);
+		}
+	}
+
 	DCF_Close(g_dcf_hdl);
 	DCF_UnInstallID();
 

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

@@ -19,6 +19,7 @@
 #include "vf_gfx.h"
 #include "GxTime.h"
 #include "hd_type.h"
+#include "sys_fwload.h"
 
 #if MOVIE_ISP_LOG
 #include "vendor_isp.h"
@@ -328,6 +329,8 @@ static void MovieStamp_get_isp_status(UINT32 id, char* Buf, UINT32 BufLen)
 #endif
 UINT32 MovieStamp_TriggerUpdateChk(void)
 {
+	extern int fwload_wait_done(CODE_SECTION section);
+	fwload_wait_done(CODE_SECTION_10);
 
 	struct tm   CurDateTime;
 	GxTime_GetTime(&CurDateTime);
@@ -1490,7 +1493,7 @@ void MovieStamp_VsFontConfig(UINT32 uiVEncOutPortId)
 	YUV_GET_RGB(y, u, v, r, g, b);
 
 #if defined(_UI_STYLE_LVGL_)
-	g_VsFontIn[uiVEncOutPortId].ciTransparet = ((LV_COLOR_GET_A32((lv_color32_t){.full = LV_USER_CFG_MOVIE_DATESTAMP_COLOR_BACKGROUND}) >> 4) << 12) | ((g>>4)<<4) | (b>>4); //0x0000;
+	g_VsFontIn[uiVEncOutPortId].ciTransparet = ((LV_COLOR_GET_A32((lv_color32_t){.full = LV_USER_CFG_STAMP_COLOR_BACKGROUND}) >> 4) << 12) | ((g>>4)<<4) | (b>>4); //0x0000;
 #else
 	g_VsFontIn[uiVEncOutPortId].ciTransparet = ((r>>4)<<8) | ((g>>4)<<4) | (b>>4); //0x0000;
 #endif

rtos/code/application/source/cardv/SrcCode/UIApp/Photo/UIAppPhoto.h

@@ -72,7 +72,7 @@
 #else
 	#if PHOTO_PREVIEW_SLICE_ENC_FUNC || POWERON_FAST_SLICE_ENC
 		#define    PHOTO_MAX_CAP_SIZE  					UIAPP_PHOTO_SIZE_40M	/* Max slice encode size */
-		#define	   PHOTO_SLICE_ENC_MIN_CAP_SIZE  		UIAPP_PHOTO_SIZE_2M		/* UI Menu only display options which size is larger than PHOTO_SLICE_ENC_MIN_CAP_SIZE */
+		#define	   PHOTO_MIN_CAP_SIZE  		UIAPP_PHOTO_SIZE_2M		/* UI Menu only display options which size is larger than PHOTO_SLICE_ENC_MIN_CAP_SIZE */
 	#else
 		#define    PHOTO_MAX_CAP_SIZE  UIAPP_PHOTO_SIZE_12M
 	#endif

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

@@ -37,6 +37,7 @@
 #include "PhotoFastCapDateImprint.h"
 #include "DCF.h"
 #include "flow_boot_linux.h"
+#include "UIAppPhoto_Param.h"
 #if HUNTING_CAMERA_MCU == ENABLE
 #include <sf_mcu.h>
 #include "sf_led.h"
@@ -116,7 +117,7 @@ INT32 PhotoFast_FileNaming_MakePath(UINT32 filetype, CHAR *pPath, UINT32 uiPathI
 INT32 PhotoFast_Phy2LogID(UINT32 id);
 THREAD_RETTYPE PhotoFast_EncodeBsPullThread(void *ptr);
 UINT32 PhotoFast_GetExpectSize_RhoBRCrtl(UINT32 ImgIdx, BOOL bPrimaryOnly);
-INT32 PhotoFast_WriteFile(UINT32 Addr, UINT32 Size, UINT32 Fmt, UINT32 uiPathId);
+INT32 PhotoFast_WriteFile(UINT32 Addr, UINT32 Size, UINT32 Fmt, UINT32 uiPathId, char* Path);
 static void PhotoFast_ShutDown(void);
 void Set_NIGHTMODE(UINT32 id, UINT8 isSnapVideo);
 void Set_AEMODE(UINT32 id);
@@ -847,7 +848,7 @@ void PhotoFast_FileNaming_SetSortBySN(CHAR *pDelimStr, UINT32 nDelimCount, UINT3
         DBG_ERR("No set Delim String!!\r\n");
 }
 
-INT32 PhotoFast_WriteFile(UINT32 Addr, UINT32 Size, UINT32 Fmt, UINT32 uiPathId)
+INT32 PhotoFast_WriteFile(UINT32 Addr, UINT32 Size, UINT32 Fmt, UINT32 uiPathId, char* Path)
 {
 	FST_FILE fp;
 	INT32    rt;
@@ -857,19 +858,26 @@ INT32 PhotoFast_WriteFile(UINT32 Addr, UINT32 Size, UINT32 Fmt, UINT32 uiPathId)
 	UINT32   open_flag;
 	UINT32 nextFolderID = 0, nextFileID = 0;
 
-    if (DCF_GetDBInfo(DCF_INFO_IS_9999)) {
+	if(Path == NULL){
-		DBG_ERR("Exceed max dcf file!\r\n");
+        if (DCF_GetDBInfo(DCF_INFO_IS_9999)) {
-		return FST_STA_NOFREE_SPACE;
+            DBG_ERR("Exceed max dcf file!\r\n");
-	}
+            return FST_STA_NOFREE_SPACE;
-    else {
+        }
-		if (Fmt == HD_CODEC_TYPE_RAW){
+        else {
-			fileType = DCF_FILE_TYPE_RAW;
+            if (Fmt == HD_CODEC_TYPE_RAW){
-		}
+                fileType = DCF_FILE_TYPE_RAW;
-		else{
+            }
-			fileType = DCF_FILE_TYPE_JPG;
+            else{
-		}
+                fileType = DCF_FILE_TYPE_JPG;
-		DCF_GetNextID(&nextFolderID,&nextFileID);
+            }
-		DCF_MakeObjPath(nextFolderID, nextFileID, fileType, FilePath);
+            DCF_GetNextID(&nextFolderID,&nextFileID);
+            DCF_MakeObjPath(nextFolderID, nextFileID, fileType, FilePath);
+                DCF_AddDBfile(FilePath);
+                DBG_DUMP("%s added to DCF\r\n", FilePath);
+            }
+        }
+        else{
+            strncpy(FilePath, Path, sizeof(FilePath));
 	}
 
 #if HUNTING_CAMERA_MCU == ENABLE
@@ -897,8 +905,8 @@ INT32 PhotoFast_WriteFile(UINT32 Addr, UINT32 Size, UINT32 Fmt, UINT32 uiPathId)
         FileSys_FlushFile(fp);
 		FileSys_CloseFile(fp);
 		if (rt == FST_STA_OK) {
-		DCF_AddDBfile(FilePath);
+		// DCF_AddDBfile(FilePath);
-		DBG_DUMP("%s added to DCF\r\n", FilePath);
+		// DBG_DUMP("%s added to DCF\r\n", FilePath);
 		} else {
 			DBG_ERR("Addr=0x%x,Size=0x%x,Fmt=%d\r\n", Addr, Size, Fmt);
 		}
@@ -1343,7 +1351,7 @@ static void PhotoFast_CaptureStart(HD_VIDEO_FRAME *p_video_frame)
     GxImgFile_CombineJPG(&exif_data, &pri_jpg, &scr_jpg, &dst_jpg_file);
 
 	fastboot_wait_done(BOOT_INIT_FILENAMINGOK);
-	PhotoFast_WriteFile(dst_jpg_file.addr, dst_jpg_file.size, NAMERULE_FMT_JPG, 0);
+	PhotoFast_WriteFile(dst_jpg_file.addr, dst_jpg_file.size, NAMERULE_FMT_JPG, 0, 0);
 
     for (i=0; i < PHOTO_ENC_JPG_TYPE_MAX_ID; i++) {
 		hd_ret = hd_videoenc_release_out_buf(g_video_enc_path[i], &g_bs_data_pull[i]);
@@ -1684,7 +1692,11 @@ THREAD_RETTYPE PhotoFast_FlowPreviewThread(void *arg)
 //#endif
 			start_cap = TRUE;
 
-			DBG_DUMP("*** trigger frame count = %llu (start from 1)\n", video_cap_frame.count); /* UINT64, use %llu */
+			VOS_TICK tick;
+
+			PhotoFast_GetTick(video_cap_frame.count, &tick);
+
+			DBG_DUMP("*** trigger frame count = %llu (start from 1) frame timestamp = %llu, tick=%lu ms , \n", video_cap_frame.count, video_cap_frame.timestamp, tick); /* UINT64, use %llu */
 			//Set_AEMODE(1);
 		}
 
@@ -2033,7 +2045,6 @@ void Set_NIGHTMODE(UINT32 id, UINT8 isSnapVideo)
 void Set_AEMODE(UINT32 id)
 {
     AET_MANUAL ae_manual = {0};
-	AWBT_MANUAL manual = {0};
 	AWBT_STATUS status = {0};
     ISPT_C_GAIN c_gain = {0};
 	HD_RESULT hd_ret;
@@ -2102,20 +2113,6 @@ void Set_AEMODE(UINT32 id)
 			c_gain.gain[1] = status.status.cur_g_gain;
 			c_gain.gain[2] = status.status.cur_b_gain;
 			vendor_isp_set_common(ISPT_ITEM_C_GAIN, &c_gain);
-			manual.id = 0;
-            if (id == 1)
-            {
-                manual.manual.en = 1;
-                manual.manual.r_gain = status.status.cur_r_gain;
-                manual.manual.g_gain = status.status.cur_g_gain;
-                manual.manual.b_gain = status.status.cur_b_gain;
-            
-            }
-            else
-            {
-                manual.manual.en = 0;
-            }
-    		vendor_isp_set_awb(AWBT_ITEM_MANUAL, &manual);			
 		}
 	}
 		if ((hd_ret = vendor_isp_uninit()) != HD_OK) {
@@ -2189,5 +2186,75 @@ UINT32 PhotoFast_GetTickBufSize(void)
 	return VD_TICK_BUF_SIZE;
 }
 
+#include "vendor_common.h"
+#define DBGINFO_BUFSIZE()	(0x200)
+
+ER PhotoFast_Movie_Init(void)
+{
+	PhotoFast_InitExif();
+	PhotoFastCapDateImprint_InitBuff();
+	hd_gfx_init();
+
+
+	HD_COMMON_MEM_INIT_CONFIG mem_cfg = {0};
+	UINT32 id = 0;
+
+	/*******************************************************************
+	 * Slice encode thumbnail
+	 *******************************************************************/
+
+
+#if HUNTING_CAMERA_MCU == ENABLE
+			UIMenuStoreInfo *puiPara = sf_ui_para_get();
+			UINT32 blk_size = DBGINFO_BUFSIZE() + VDO_YUV_BUFSIZE(sf_get_screen_nail_width(puiPara->SendPicSize), sf_get_screen_nail_height(puiPara->SendPicSize), HD_VIDEO_PXLFMT_YUV420);
+#else
+			UINT32 blk_size = DBGINFO_BUFSIZE() + VDO_YUV_BUFSIZE(CFG_SCREENNAIL_W, CFG_SCREENNAIL_H, HD_VIDEO_PXLFMT_YUV420);
+#endif
+	mem_cfg.pool_info[id].type = HD_COMMON_MEM_COMMON_POOL;
+	mem_cfg.pool_info[id].blk_size = blk_size;
+	mem_cfg.pool_info[id].blk_cnt = 1;
+	mem_cfg.pool_info[id].ddr_id = DDR_ID0;
+
+	/*******************************************************************
+	 * Slice encode slice yuv buffer
+	 *******************************************************************/
+	id ++;
+	mem_cfg.pool_info[id].type = HD_COMMON_MEM_COMMON_POOL;
+	mem_cfg.pool_info[id].blk_size = PhotoFast_SliceEncode_Get_Max_Dst_Slice_Buffer_Size(HD_VIDEO_PXLFMT_YUV420);
+	mem_cfg.pool_info[id].blk_cnt = 1;
+	mem_cfg.pool_info[id].ddr_id = DDR_ID0;
+
+
+	// config common pool (screennail image)
+	id ++;
+	mem_cfg.pool_info[id].type = HD_COMMON_MEM_COMMON_POOL;
+#if HUNTING_CAMERA_MCU == ENABLE
+	mem_cfg.pool_info[id].blk_size = DBGINFO_BUFSIZE()+VDO_YUV_BUFSIZE(sf_get_screen_nail_width(puiPara->SendPicSize), sf_get_screen_nail_height(puiPara->SendPicSize), HD_VIDEO_PXLFMT_YUV420);
+
+#else
+	mem_cfg.pool_info[id].blk_size = DBGINFO_BUFSIZE()+VDO_YUV_BUFSIZE(CFG_SCREENNAIL_W, CFG_SCREENNAIL_H, HD_VIDEO_PXLFMT_YUV420);
+#endif
+	mem_cfg.pool_info[id].blk_cnt = 1;
+	mem_cfg.pool_info[id].ddr_id = DDR_ID0;
+
+	// config common pool (EXIF)
+	id++;
+	mem_cfg.pool_info[id].type = HD_COMMON_MEM_COMMON_POOL;
+	mem_cfg.pool_info[id].blk_size = DBGINFO_BUFSIZE()+CFG_JPG_HEADER_SIZE;
+	mem_cfg.pool_info[id].blk_cnt = 1;
+	mem_cfg.pool_info[id].ddr_id = DDR_ID0;
+
+	UIAPP_PHOTO_SENSOR_INFO *sensor_info = UIAppPhoto_get_SensorInfo(0);
+	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].ddr_id = DDR_ID0;
+
+	vendor_common_mem_relayout(&mem_cfg);
+
+	return E_OK;
+}
+
 #endif
 

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

@@ -56,10 +56,11 @@ extern THREAD_RETTYPE PhotoFast_EncodeBsPullThread(void *arg);
 extern THREAD_RETTYPE PhotoFast_FlowPreviewThread(void *arg);
 extern void  PhotoFast_PhotoClose(void);
 
-extern BOOL PhotoFast_SetTick(UINT32 cnt, VOS_TICK tick); /* start from 0 */
+extern BOOL PhotoFast_SetTick(UINT32 cnt, VOS_TICK tick); /* start from 1 */
-extern BOOL PhotoFast_GetTick(UINT32 cnt, VOS_TICK* tick); /* start from 0 */
+extern BOOL PhotoFast_GetTick(UINT32 cnt, VOS_TICK* tick); /* start from 1 */
 extern BOOL PhotoFast_SetTriggerFrmCnt(UINT32 cnt); /* trigger vcap frame count , get from HD_VIDEO_FRAME */
+UINT32 PhotoFast_GetTriggerFrmCnt(VOID);
 extern UINT32 PhotoFast_GetTickBufSize(void);
-
+ER PhotoFast_Movie_Init(void);
 
 #endif //_UIAPP_PHOTO_H_

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

@@ -234,7 +234,7 @@ static UINT32 PhotoFast_SliceEncode_Get_Max_Dst_Slice_Info(PhotoFast_SliceSize_I
 
 		UINT8 cap_idx = 0;
 
-		for(cap_idx = PHOTO_MAX_CAP_SIZE ; cap_idx <= PHOTO_SLICE_ENC_MIN_CAP_SIZE ; cap_idx++)
+		for(cap_idx = PHOTO_MAX_CAP_SIZE ; cap_idx <= PHOTO_MIN_CAP_SIZE ; cap_idx++)
 		{
 			HD_DIM tmp_cap_size = {0};
 			PhotoFast_SliceSize_Info tmp_slice_info = {0};

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

@@ -19,43 +19,43 @@ TMDEF_BEGIN_OPTIONS(PHOTO_SIZE)
 
 #if PHOTO_PREVIEW_SLICE_ENC_FUNC || POWERON_FAST_SLICE_ENC
 
-	#if(PHOTO_MAX_CAP_SIZE > PHOTO_SLICE_ENC_MIN_CAP_SIZE)
+	#if(PHOTO_MAX_CAP_SIZE > PHOTO_MIN_CAP_SIZE)
 		#error "please check PHOTO_MAX_CAP_SIZE in UIAppPhoto.h"
 	#endif
 
-	#if (PHOTO_SLICE_ENC_MIN_CAP_SIZE < UIAPP_PHOTO_SIZE_40M)//PHOTO_SIZE_40M
+	#if (PHOTO_MIN_CAP_SIZE < UIAPP_PHOTO_SIZE_40M)//PHOTO_SIZE_40M
 	TMDEF_OPTION_TEXT_S(PHOTO_SIZE_40M, TM_OPTION_DISABLE)
 	#else
 	TMDEF_OPTION_TEXT_S(PHOTO_SIZE_40M, TM_OPTION_ENABLE)
 	#endif
 
-	#if (PHOTO_SLICE_ENC_MIN_CAP_SIZE < UIAPP_PHOTO_SIZE_12M)//PHOTO_SIZE_12M
+	#if (PHOTO_MIN_CAP_SIZE < UIAPP_PHOTO_SIZE_12M)//PHOTO_SIZE_12M
 	TMDEF_OPTION_TEXT_S(PHOTO_SIZE_12M, TM_OPTION_DISABLE)
 	#else
 	TMDEF_OPTION_TEXT_S(PHOTO_SIZE_12M, TM_OPTION_ENABLE)
 	#endif
-	#if (PHOTO_SLICE_ENC_MIN_CAP_SIZE < UIAPP_PHOTO_SIZE_10M)//PHOTO_SIZE_10M
+	#if (PHOTO_MIN_CAP_SIZE < UIAPP_PHOTO_SIZE_10M)//PHOTO_SIZE_10M
 	TMDEF_OPTION_TEXT_S(PHOTO_SIZE_10M, TM_OPTION_DISABLE)
 	#else
 	TMDEF_OPTION_TEXT_S(PHOTO_SIZE_10M, TM_OPTION_ENABLE)
 	#endif
-	#if (PHOTO_SLICE_ENC_MIN_CAP_SIZE < UIAPP_PHOTO_SIZE_8M)//PHOTO_SIZE_8M
+	#if (PHOTO_MIN_CAP_SIZE < UIAPP_PHOTO_SIZE_8M)//PHOTO_SIZE_8M
 	TMDEF_OPTION_TEXT_S(PHOTO_SIZE_8M, TM_OPTION_DISABLE)
 	#else
 	TMDEF_OPTION_TEXT_S(PHOTO_SIZE_8M, TM_OPTION_ENABLE)
 	#endif
-	#if (PHOTO_SLICE_ENC_MIN_CAP_SIZE < UIAPP_PHOTO_SIZE_5M)//PHOTO_SIZE_5M
+	#if (PHOTO_MIN_CAP_SIZE < UIAPP_PHOTO_SIZE_5M)//PHOTO_SIZE_5M
 	TMDEF_OPTION_TEXT_S(PHOTO_SIZE_5M, TM_OPTION_DISABLE)
 	#else
 	TMDEF_OPTION_TEXT_S(PHOTO_SIZE_5M, TM_OPTION_ENABLE)
 	#endif
-	#if (PHOTO_SLICE_ENC_MIN_CAP_SIZE < UIAPP_PHOTO_SIZE_3M)//PHOTO_SIZE_3M
+	#if (PHOTO_MIN_CAP_SIZE < UIAPP_PHOTO_SIZE_3M)//PHOTO_SIZE_3M
 	TMDEF_OPTION_TEXT_S(PHOTO_SIZE_3M, TM_OPTION_DISABLE)
 	#else
 	TMDEF_OPTION_TEXT_S(PHOTO_SIZE_3M, TM_OPTION_ENABLE)
 	#endif
 
-	#if (PHOTO_SLICE_ENC_MIN_CAP_SIZE < UIAPP_PHOTO_SIZE_VGA)//PHOTO_SIZE_VGA
+	#if (PHOTO_MIN_CAP_SIZE < UIAPP_PHOTO_SIZE_VGA)//PHOTO_SIZE_VGA
 	TMDEF_OPTION_TEXT_S(PHOTO_SIZE_VGA, TM_OPTION_DISABLE)
 	#else
 	TMDEF_OPTION_TEXT_S(PHOTO_SIZE_VGA, TM_OPTION_ENABLE)

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

@@ -1866,6 +1866,7 @@ typedef enum {
 	SF_CAM_MODE_PHOTO		= 0x00,
 	SF_CAM_MODE_VIDEO,
 	SF_CAM_MODE_PHOTO_VIDEO,
+    SF_CAM_MODE_VIDEO2,
 	SF_CAM_MODE_MAX,
 }SF_BOOT_WORK_MODE;
 

rtos/code/application/source/cardv/rtos-main-hunting_lvgl.lds

@@ -164,6 +164,7 @@ SECTIONS
         libdrv_storage.a (.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
         libsifar.a (.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
         /* kdrv */
+        libker_pkg.a (.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
         libkdrv_comm.a (.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
         libarb_protected.a (.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
         libkdrv_cpu.a (.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
@@ -175,7 +176,7 @@ SECTIONS
         libkdrv_interrupt.a (.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
         /* os */
         ./SrcCode/Startup/bin_info.o(.got*)
-        libker_pkg.a (.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
+        /*libker_pkg.a (.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)*/
         libkwrap.a (.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
         libvos.a (.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
         /* freertos.a must be located after kwrap.a for linking text.xEventGroup* */
@@ -295,17 +296,6 @@ SECTIONS
         libexif.a (.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
 		libgximagefile.a (.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
 
-        /* audio */
-#if (_PACKAGE_AUDIO_)
-        libkflow_audiocap.a(.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
-        libkflow_audioenc.a(.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
-        libnvt_audio.a(.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
-        libnvt_kdrv_audio.a(.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
-        libaud_aec.a(.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
-        libaud_aace.a(.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
-        libaudlib_IIR.a(.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
-#endif
-
 		liblvgl.a (.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
         ./SrcCode/FastFlow/flow_lvgl.o (.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)             
 		./SrcCode/UIApp/lv_user_font_conv/lv_user_font_conv.o (.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
@@ -324,6 +314,35 @@ SECTIONS
     {
         _section_05_size = ABSOLUTE(.) - _section_05_addr;
         _section_06_addr = ABSOLUTE(.);
+              
+        /* app */
+        ./SrcCode/UIApp/MovieFast/MovieFast.o (.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
+        ./SrcCode/UIApp/Movie/UIAppMovie_Exe.o (.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
+        ./SrcCode/UIApp/Movie/UIAppMovie_CommPoolInit.o (.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
+        ./SrcCode/UIApp/Movie/UIAppMovie_RecSetting.o (.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
+        ./SrcCode/UIApp/MovieStamp/MovieStamp.o (.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
+        ./SrcCode/UIApp/MovieStamp/MovieStampID.o (.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
+        ./SrcCode/UIApp/MovieStamp/MovieStampTsk.o (.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
+        ./SrcCode/UIApp/MovieStamp/BG_Watermark_640x480.o (.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
+        ./SrcCode/UIWnd/LVGL_SPORTCAM/UIInfo/UIMovieMapping.o (.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
+        
+        /* lib */
+        libimageapp_moviemulti.a (.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
+        libimageapp_common.a (.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
+        libfileout.a (.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
+        libbsmux.a (.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
+        libavfile.a (.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)    
+        
+         /* audio */
+#if (_PACKAGE_AUDIO_)
+        libkflow_audiocap.a(.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
+        libkflow_audioenc.a(.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
+        libnvt_audio.a(.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
+        libnvt_kdrv_audio.a(.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
+        libaud_aec.a(.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
+        libaud_aace.a(.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
+        libaudlib_IIR.a(.text* .data* .data1* .rodata* .rodata1* .reginfo* .init* .exit*)
+#endif
     }
 
     . = ALIGN(4);
@@ -484,3 +503,13 @@ GROUP(libgcc.a libc.a libdrv_portable.a libfreertos.a libkwrap.a libkdrv_comm.a
 
 EXTERN("_init")
 EXTERN("SwTimer_Open")
+EXTERN("vendor_videoenc_set")
+EXTERN("vendor_audiocap_set")
+EXTERN("vendor_audioenc_set")
+EXTERN("vendor_videoproc_set")
+EXTERN("vendor_videodec_set")
+EXTERN("eac_init")
+EXTERN("dai_disableclk")
+EXTERN("aud_open")
+EXTERN("h264Enc_queryMemSize")
+EXTERN("aud_set_default_setting")

rtos/code/lib/include/ImageApp/ImageApp_MovieMulti.h

@@ -101,6 +101,7 @@ typedef enum {
 	IAMOVIE_VPRC_EX_ALG,
 	IAMOVIE_VPRC_EX_DISP2,
 	IAMOVIE_VPRC_EX_ALG2,
+    IAMOVIE_VPRC_EX_MAX,
 	ENUM_DUMMY4WORD(IAMOVIE_VPRC_EX_PATH)
 } IAMOVIE_VPRC_EX_PATH;
 
@@ -884,6 +885,7 @@ extern HD_PATH_ID ImageApp_MovieMulti_GetVprcInPort(MOVIE_CFG_REC_ID id);
 extern HD_PATH_ID ImageApp_MovieMulti_GetVprc3DNRPort(MOVIE_CFG_REC_ID id);
 extern HD_PATH_ID ImageApp_MovieMulti_GetVdoEncPort(MOVIE_CFG_REC_ID id);
 extern HD_PATH_ID ImageApp_MovieMulti_GetRawEncPort(MOVIE_CFG_REC_ID id);
+extern HD_PATH_ID ImageApp_MovieMulti_GetVprcPort(MOVIE_CFG_REC_ID id, IAMOVIE_VPRC_EX_PATH path);
 extern HD_PATH_ID ImageApp_MovieMulti_GetAlgDataPort(MOVIE_CFG_REC_ID id, MOVIE_CFG_ALG_PATH path);
 extern HD_PATH_ID ImageApp_MovieMulti_GetAudEncPort(MOVIE_CFG_REC_ID id);
 extern void ImageApp_MovieMulti_Root_Path(CHAR *prootpath, UINT32 rec_id);