////////////////////////////////////////////////////////////////////////////////
#include "PrjInc.h"
#include "ImageApp/ImageApp_MovieMulti.h"
#include "avfile/movieinterface_def.h"
#include "sys_mempool.h"
#include "sys_fdt.h"
#include "UIApp/MovieStamp/MovieStamp.h"
#include "NamingRule/NameRule_Custom.h"
#include "FileDB.h"
#include "SysSensor.h"
#include "GxTime.h"
#include "vendor_isp.h"
#include "UIApp/Network/UIAppWiFiCmd.h"
#include "UIApp/AppDisp_PipView.h"
#include <vf_gfx.h>
#include "vendor_videocapture.h"
#include "UIApp/MovieStamp/MovieStampAPI.h"
#include <kwrap/util.h>
#if (USE_EXIF == ENABLE)
#include "UIApp/ExifVendor.h"
#endif
#include "vendor_videoout.h"
#include "sys_fastboot.h"
#include "MovieFast.h"
#include <FreeRTOS_POSIX.h>
#include <FreeRTOS_POSIX/pthread.h>
#include <comm/hwclock.h>
#include <comm/hwpower.h>
#include "DCF.h"
#include "flow_boot_linux.h"
#include "DxHunting.h"

#if defined(_UI_STYLE_LVGL_)
#include "flow_lvgl.h"
#endif

#define THIS_DBGLVL         2 // 0=FATAL, 1=ERR, 2=WRN, 3=UNIT, 4=FUNC, 5=IND, 6=MSG, 7=VALUE, 8=USER

#if 1//_TODO
#define __MODULE__          MovieFast
#define __DBGLVL__          2 // 0=FATAL, 1=ERR, 2=WRN, 3=UNIT, 4=FUNC, 5=IND, 6=MSG, 7=VALUE, 8=USER
#define __DBGFLT__          "*" //*=All, [mark]=CustomClass
#include <kwrap/debug.h>
#endif
#if HUNTING_CAMERA_MCU == ENABLE
#include <sf_mcu.h>
#endif

/**
	Flags for control
*/
#define FLG_EXE_MOVIE_IDLE         	FLGPTN_BIT(0)
#define FLG_EXE_MOVIE_RECSTART		FLGPTN_BIT(1)               ///< trigger display task
#define FLG_EXE_MOVIE_RECSTOP       FLGPTN_BIT(2)               ///< stop task

/**********************************************************************************
 * independent thumbnail
 *********************************************************************************/
#define MOVIE_THUMB_PATH "A:\\Thumb\\"

static char thumb_current_path_main[256] = {'\0'};
static char thumb_current_path_clone[256] = {'\0'};

#define MOVIE_ROOT_PATH		"A:\\Novatek\\"
#define FILE_SN_MAX		99999
#define FILEDB_MAX_NUM		5000
#define MOVIE_THUMB_WIDTH	640
#define PRI_MOVIEFAST_CMDTSK      11
#define STKSIZE_MOVIEFAST_CMDTSK   8192

//local variable
static DCF_HANDLE g_dcf_hdl = 0;
static ID MOVIEFAST_FLG_ID = 0;
static UINT32 g_moviefast_tsk_run = 1;
static UINT32 g_MovieFast_InitCommonMemFinish=0;
static THREAD_HANDLE g_moviefast_tsk_id = 0;
static BOOL g_bIsRecStatus = FALSE;


//local function
static void MovieFast_OnRecStart(void);
static void MovieFast_OnRecStop(void);
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 ER MovieFast_InstallID(void)
{
    ER ret = E_OK;
    T_CFLG cflg;

	memset(&cflg, 0, sizeof(T_CFLG));
	if ((ret |= vos_flag_create(&MOVIEFAST_FLG_ID, &cflg, "MOVIEFAST_FLG")) != E_OK) {
		DBG_ERR("MOVIEFAST_FLG_ID fail\r\n");
	}

    return ret;
}

static THREAD_RETTYPE MovieFast_CmdTsk(void)
{
    FLGPTN uiFlag = 0, wait_flag = 0;

	THREAD_ENTRY();

	wait_flag = FLGMOVIEFAST_RECSTART |
				FLGMOVIEFAST_RECSTOP |
				FLGMOVIEFAST_SHUTDOWN;

	g_moviefast_tsk_run = TRUE;

    while (g_moviefast_tsk_run) {
        vos_flag_wait(&uiFlag, MOVIEFAST_FLG_ID, wait_flag, TWF_ORW | TWF_CLR);

		if (uiFlag & FLGMOVIEFAST_RECSTART) {
			if (DCF_GetDBInfo(DCF_INFO_IS_9999)) {
				DBG_ERR("Exceed max dcf file!\r\n");
				g_moviefast_tsk_run = 0;
				MovieFast_ShutDown();
			}

			MovieFast_OnRecStart();
        } else if (uiFlag & FLGMOVIEFAST_RECSTOP) {
            MovieFast_OnRecStop();
        } else if (uiFlag & FLGMOVIEFAST_SHUTDOWN) {
        	g_moviefast_tsk_run = 0;
            MovieFast_ShutDown();
	}else{
            DBG_WRN("No flag for MovieFast_CmdTsk\r\n");
        }
	}

	THREAD_RETURN(0);
}

static void MovieFast_ShutDown(void)
{
	MovieFast_CmdTsk_Exit();
	MovieFast_Close();

#if (POWERON_FAST_BOOT_MSG == DISABLE)
	fastboot_msg_en(ENABLE);
#endif

#if HUNTING_CAMERA_BOOT_LINUX /* Boot Linux */

#if POWERON_BOOT_REPORT == ENABLE

	UINT8 mode = DrvGPIO_GetPhotoMovieModeFromMonitor();
	DBG_DUMP("PhotoMovie mode = %u\n", mode);

	vos_perf_list_dump();

#endif

	#if HUNTING_CAMERA_MCU
	sf_mcu_reg_set(SF_MCU_POWEROFF,0);
	#else
	fastboot_set_done(BOOT_FLOW_BOOT);
	flow_wait_linux();
	#endif	


#else

	vos_perf_list_mark("pwr off", __LINE__, 0);

#if POWERON_BOOT_REPORT == ENABLE
	vos_perf_list_dump();
#endif

	#if HUNTING_CAMERA_MCU == ENABLE
	sf_mcu_reg_set(SF_MCU_POWEROFF,0);
	#else
	hwpower_set_power_key(POWER_ID_PSW1, 0xFF);
	#endif	
#endif

}

static void MovieFast_SetRecParamByRecID(MOVIE_CFG_REC_ID rec_id)
{
	// set record type (video only, video and audio, time-lapse, ...)
	if (SysGetFlag(FL_MOVIE_TIMELAPSE_REC) == MOVIE_TIMELAPSEREC_OFF) {
		if (SysGetFlag(FL_MovieAudioRec) == MOVIE_AUD_REC_OFF) {
			ImageApp_MovieMulti_SetParam(rec_id, MOVIEMULTI_PARAM_REC_FORMAT, _CFG_REC_TYPE_VID);
		} else {
			ImageApp_MovieMulti_SetParam(rec_id, MOVIEMULTI_PARAM_REC_FORMAT, _CFG_REC_TYPE_AV);
		}
		ImageApp_MovieMulti_SetParam(rec_id, MOVIEMULTI_PARAM_TIMELAPSE_TIME, 0);
		ImageApp_MovieMulti_SetParam(rec_id, MOVIEMULTI_PARAM_FILE_ENDTYPE, (SysGetFlag(FL_MOVIE_CYCLIC_REC) == MOVIE_CYCLICREC_OFF) ? MOVREC_ENDTYPE_CUT_TILLCARDFULL : MOVREC_ENDTYPE_CUTOVERLAP);
	} else {
		ImageApp_MovieMulti_SetParam(rec_id, MOVIEMULTI_PARAM_REC_FORMAT, _CFG_REC_TYPE_TIMELAPSE);
		ImageApp_MovieMulti_SetParam(rec_id, MOVIEMULTI_PARAM_TIMELAPSE_TIME, Get_MovieTimeLapseValue(SysGetFlag(FL_MOVIE_TIMELAPSE_REC)));
		//ImageApp_MovieMulti_SetParam(rec_id, MOVIEMULTI_PARAM_FILE_PLAYFRAMERATE, MOVIE_TIMELAPSE_PLAYFRAMERATE);
		ImageApp_MovieMulti_SetParam(rec_id, MOVIEMULTI_PARAM_FILE_ENDTYPE, (SysGetFlag(FL_MOVIE_CYCLIC_REC) == MOVIE_CYCLICREC_OFF) ? MOVREC_ENDTYPE_CUT_TILLCARDFULL : MOVREC_ENDTYPE_CUTOVERLAP);
	}
}

static void MovieFast_RecMovieStamp(void)
{
	UINT32 Width, Height;
	UINT32 uiStampAddr;
	UINT32 uiStampMemSize;
	WATERLOGO_BUFFER waterLogoSrc={0};
	HD_PATH_ID      uiVEncOutPortId = 0;
	STAMP_COLOR StampColorBg = {RGB_GET_Y( 16,  16,  16), RGB_GET_U( 16,  16,  16), RGB_GET_V( 16,  16,  16)}; // date stamp background color
	STAMP_COLOR StampColorFr = {RGB_GET_Y( 16,  16,  16), RGB_GET_U( 16,  16,  16), RGB_GET_V( 16,  16,  16)}; // date stamp frame color
	STAMP_COLOR StampColorFg = {RGB_GET_Y(224, 224, 192), RGB_GET_U(224, 224, 192), RGB_GET_V(224, 224, 192)}; // date stamp foreground color
	UINT32 i, mask;
	UINT32 movie_rec_mask, clone_rec_mask;

	movie_rec_mask = Movie_GetMovieRecMask();
	clone_rec_mask = Movie_GetCloneRecMask();
	//DBG_DUMP("setup_rec_moviestamp  sen_cnt=%d\r\n",sen_cnt);
	mask = 1;

	for (i = 0; i < SENSOR_CAPS_COUNT; i ++) {
		// set main path 1st movie stamp
		if ((movie_rec_mask & mask) || (SENSOR_INSERT_MASK & mask)) {
			Width = gMovie_Rec_Info[i].size.w;
			Height =gMovie_Rec_Info[i].size.h;
			memset(&waterLogoSrc,0,sizeof(WATERLOGO_BUFFER));
			MovieFast_GetWaterLogoSource(Width,&waterLogoSrc);
			uiVEncOutPortId = HD_GET_OUT(ImageApp_MovieMulti_GetVdoEncPort(_CFG_REC_ID_1+i)) - 1;    // since out is start from 1, so uiVidEncId should minus 1
			DBG_DUMP("main VEncOutPortId=%d, [%d, %d] i=%d\r\n",uiVEncOutPortId,Width,Height, i);
			#if (_BOARD_DRAM_SIZE_ == 0x04000000)
			uiStampMemSize = MovieStamp_CalcBufSize(Width/2, Height,&waterLogoSrc);
			#else
			uiStampMemSize = MovieStamp_CalcBufSize(Width, Height,&waterLogoSrc);
			#endif
			uiStampAddr = MovieStamp_GetBufAddr(uiVEncOutPortId, uiStampMemSize);   // stamp malloc vir addr
			MovieStamp_SetBuffer(uiVEncOutPortId, uiStampAddr, uiStampMemSize, waterLogoSrc.uiWidth, waterLogoSrc.uiHeight);

			MovieStamp_SetColor(uiVEncOutPortId, &StampColorBg, &StampColorFr, &StampColorFg);

			MovieStamp_Setup(
			uiVEncOutPortId,
			STAMP_ON |
			STAMP_AUTO |
			STAMP_DATE_TIME |
			STAMP_BOTTOM_LEFT |
			STAMP_POS_NORMAL |
			STAMP_YY_MM_DD,
	            Width,
	            Height,
#if defined (WATERLOGO_FUNCTION) && (WATERLOGO_FUNCTION == ENABLE)
	            (WATERLOGO_BUFFER *)&waterLogoSrc);
#else
	            NULL);
#endif
	    }
		// set clone path 1st movie stamp
		if ((clone_rec_mask & mask) || (SENSOR_INSERT_MASK & mask)) {
			Width = gMovie_Clone_Info[i].size.w;
			Height = gMovie_Clone_Info[i].size.h;
			memset(&waterLogoSrc,0,sizeof(WATERLOGO_BUFFER));
			MovieFast_GetWaterLogoSource(Width,&waterLogoSrc);
			uiVEncOutPortId = HD_GET_OUT(ImageApp_MovieMulti_GetVdoEncPort(_CFG_CLONE_ID_1+i)) - 1;    // since out is start from 1, so uiVidEncId should minus 1
			DBG_DUMP("clone VEncOutPortId=%d, GetVdoEncPort(_CFG_CLONE_ID_1+%d)=0x%x\r\n",uiVEncOutPortId,i,ImageApp_MovieMulti_GetVdoEncPort(_CFG_CLONE_ID_1+i));
			#if (_BOARD_DRAM_SIZE_ == 0x04000000)
			uiStampMemSize = MovieStamp_CalcBufSize(Width/2, Height,&waterLogoSrc);
			#else
			uiStampMemSize = MovieStamp_CalcBufSize(Width, Height,&waterLogoSrc);
			#endif
			uiStampAddr = MovieStamp_GetBufAddr(uiVEncOutPortId, uiStampMemSize);
			MovieStamp_SetBuffer(uiVEncOutPortId, uiStampAddr, uiStampMemSize, waterLogoSrc.uiWidth, waterLogoSrc.uiHeight);

			MovieStamp_SetColor(uiVEncOutPortId, &StampColorBg, &StampColorFr, &StampColorFg);

			MovieStamp_Setup(
			uiVEncOutPortId,
			STAMP_ON |
			STAMP_AUTO |
			STAMP_DATE_TIME |
			STAMP_BOTTOM_RIGHT |
			STAMP_POS_NORMAL |
			STAMP_YY_MM_DD,
	            Width,
	            Height,
#if defined (WATERLOGO_FUNCTION) && (WATERLOGO_FUNCTION == ENABLE)
	            (WATERLOGO_BUFFER *)&waterLogoSrc);
#else
	            NULL);
#endif
	    }
#if 1
	    // set rawenc path 1st movie stamp
	    if (movie_rec_mask & mask) {
	        Width = gMovie_Rec_Info[i].size.w;
	        Height =gMovie_Rec_Info[i].size.h;
	        memset(&waterLogoSrc,0,sizeof(WATERLOGO_BUFFER));
	        MovieFast_GetWaterLogoSource(Width,&waterLogoSrc);
	        //uiVEncOutPortId = HD_GET_OUT(ImageApp_MovieMulti_GetRawEncPort(_CFG_REC_ID_1+i)) - 1;
	        //DBG_DUMP("main Rewenc VEncOutPortId=%d, GetVdoEncPort(_CFG_REC_ID_1+%d)=0x%x\r\n",uiVEncOutPortId,i,ImageApp_MovieMulti_GetRawEncPort(_CFG_REC_ID_1+i));
			uiVEncOutPortId =MovieStamp_GetRawEncVirtualPort(i);
	        DBG_DUMP("main Rewenc VEncOutPortId=%d, i=%d, w=%d, %d\r\n",uiVEncOutPortId,i,Width,Height);
	        #if (_BOARD_DRAM_SIZE_ == 0x04000000)
	        uiStampMemSize = MovieStamp_CalcBufSize(Width/2, Height,&waterLogoSrc);
	        #else
	        uiStampMemSize = MovieStamp_CalcBufSize(Width, Height,&waterLogoSrc);
	        #endif
	        uiStampAddr = MovieStamp_GetBufAddr(uiVEncOutPortId,uiStampMemSize);

	        MovieStamp_SetBuffer(uiVEncOutPortId, uiStampAddr, uiStampMemSize, waterLogoSrc.uiWidth, waterLogoSrc.uiHeight);

	        MovieStamp_SetColor(uiVEncOutPortId, &StampColorBg, &StampColorFr, &StampColorFg);

	        MovieStamp_Setup(
			uiVEncOutPortId,
			STAMP_ON |
			STAMP_AUTO |
			STAMP_DATE_TIME |
			STAMP_BOTTOM_RIGHT |
			STAMP_POS_NORMAL |
			STAMP_YY_MM_DD,
	            Width,
	            Height,
#if defined (WATERLOGO_FUNCTION) && (WATERLOGO_FUNCTION == ENABLE)
	            (WATERLOGO_BUFFER *)&waterLogoSrc);
#else
	            NULL);
#endif
	    }
#endif
		mask <<= 1;
	}
	MovieStamp_Enable();
}

static void MovieFast_SetRecInfoByUISetting(void)
{
	UINT32 movie_size_idx, size_idx = 0;
	UINT32 movie_aspect_ratio_idx = 0;
	UINT32 i, rec_type;
	UINT32 mask, ipl_id = 0, setting_count = 0;
	UINT32 movie_rec_mask;//, clone_rec_mask;

	movie_size_idx = UI_GetData(FL_MOVIE_SIZE);
	rec_type = MovieMapping_GetRecType(movie_size_idx);

	movie_rec_mask = SENSOR_ALL; //All ImagePipe must be initialized first, but they isn't running state
	//clone_rec_mask = SENSOR_ALL;

	mask = 1;
	for (i = 0; i < SENSOR_CAPS_COUNT; i++) {

		if (rec_type == MOVIE_REC_TYPE_FRONT || rec_type == MOVIE_REC_TYPE_CLONE) { // single recording
			if (movie_rec_mask & mask) { // active sensor, for movie recording
				ipl_id = 0; // get data from the mapping table of single recording, so IPL ID = 0
				size_idx = movie_size_idx;
			}
		} else if (rec_type == MOVIE_REC_TYPE_DUAL) { // dual recording
			if ((movie_rec_mask & mask) && (setting_count < 2)) { // active sensor, for movie recording
				ipl_id = 0; // get data from the mapping table of dual recording, 1st IPL ID = 0
				size_idx = movie_size_idx;
				setting_count++;
			}
		} else if (rec_type == MOVIE_REC_TYPE_TRI) { // tri recording
			if ((movie_rec_mask & mask) && (setting_count < 3)) { // active sensor, for movie recording
				if (setting_count == 0) { // 1st active sensor
					ipl_id = 0; // get data from the mapping table of tri recording, 1st IPL ID = 0
				} else if (setting_count == 1) { // 2nd active sensor
					ipl_id = 1; // get data from the mapping table of tri recording, 2nd IPL ID = 1
				} else { // 3rd active sensor
					ipl_id = 2; // get data from the mapping table of tri recording, 3rd IPL ID = 2
				}
				size_idx = movie_size_idx;
				setting_count++;
			}
		} else { // quad recording
			ipl_id = i;
			size_idx = movie_size_idx;
		}

		// set main movie
		gMovie_Rec_Info[i].size.w = MovieMapping_GetWidth(size_idx, ipl_id);
		gMovie_Rec_Info[i].size.h = MovieMapping_GetHeight(size_idx, ipl_id);
		gMovie_Rec_Info[i].raw_enc_size.w = MovieMapping_GetWidth(size_idx, ipl_id);
		gMovie_Rec_Info[i].raw_enc_size.h = MovieMapping_GetHeight(size_idx, ipl_id);
		gMovie_Rec_Info[i].frame_rate = MovieMapping_GetFrameRate(size_idx, ipl_id);
		gMovie_Rec_Info[i].target_bitrate = MovieMapping_GetTargetBitrate(size_idx, ipl_id);
		gMovie_Rec_Info[i].dar = MovieMapping_GetDispAspectRatio(size_idx, ipl_id);
		gMovie_Rec_Info[i].codec = _CFG_CODEC_H265;
		//#NT#2018/02/14#KCHong -begin
		//#NT#support sensor rotate setting
		gMovie_Rec_Info[i].sensor_rotate = FALSE;
		//#NT#2018/02/14#KCHong -end
		MovieMapping_GetAqInfo(size_idx, ipl_id, (UINT32)&gMovie_Rec_Info[i].aq_info);
		MovieMapping_GetCbrInfo(size_idx, ipl_id, (UINT32)&gMovie_Rec_Info[i].cbr_info);
		movie_aspect_ratio_idx = MovieMapping_GetImageRatio(size_idx, ipl_id);

		switch (movie_aspect_ratio_idx) {
		case IMAGERATIO_16_9:
			gMovie_Rec_Info[i].ratio.w = 16;
			gMovie_Rec_Info[i].ratio.h = 9;
			gMovie_Rec_Info[i].disp_ratio.w = 16;
			gMovie_Rec_Info[i].disp_ratio.h = 9;
			break;
		default:
			gMovie_Rec_Info[i].ratio.w = 4;
			gMovie_Rec_Info[i].ratio.h = 3;
			gMovie_Rec_Info[i].disp_ratio.w = 4;
			gMovie_Rec_Info[i].disp_ratio.h = 3;
			break;
		}

		// set clone movie
		if (rec_type == MOVIE_REC_TYPE_CLONE) {
			gMovie_Clone_Info[i].size.w = MovieMapping_GetCloneWidth(size_idx, ipl_id);
			gMovie_Clone_Info[i].size.h = MovieMapping_GetCloneHeight(size_idx, ipl_id);
			gMovie_Clone_Info[i].raw_enc_size.w = MovieMapping_GetCloneWidth(size_idx, ipl_id);
			gMovie_Clone_Info[i].raw_enc_size.h = MovieMapping_GetCloneHeight(size_idx, ipl_id);
			gMovie_Clone_Info[i].frame_rate = MovieMapping_GetCloneFrameRate(size_idx, ipl_id);
			gMovie_Clone_Info[i].target_bitrate = MovieMapping_GetCloneTargetBitrate(size_idx, ipl_id);
			gMovie_Clone_Info[i].dar = MovieMapping_GetCloneDispAspectRatio(size_idx, ipl_id);
			gMovie_Clone_Info[i].codec = _CFG_CODEC_H264;
			MovieMapping_GetCloneAqInfo(size_idx, ipl_id, (UINT32)&gMovie_Clone_Info[i].aq_info);
			MovieMapping_GetCloneCbrInfo(size_idx, ipl_id, (UINT32)&gMovie_Clone_Info[i].cbr_info);
			movie_aspect_ratio_idx = MovieMapping_GetCloneImageRatio(size_idx, ipl_id);

			switch (movie_aspect_ratio_idx) {
			case IMAGERATIO_16_9:
				gMovie_Clone_Info[i].ratio.w = 16;
				gMovie_Clone_Info[i].ratio.h = 9;
				gMovie_Clone_Info[i].disp_ratio.w = 16;
				gMovie_Clone_Info[i].disp_ratio.h = 9;
				break;
			default:
				gMovie_Clone_Info[i].ratio.w = 4;
				gMovie_Clone_Info[i].ratio.h = 3;
				gMovie_Clone_Info[i].disp_ratio.w = 4;
				gMovie_Clone_Info[i].disp_ratio.h = 3;
				break;
			}
		}

		mask <<= 1;
	}
}


static void MovieFast_OnRecStart(void)
{
	UINT32 i, mask;
	UINT32 movie_rec_mask, clone_rec_mask;
	USIZE  thmub_size;
	UINT32 uifile_buffer_reserved_sec = 5;

    if (g_bIsRecStatus) {
		return;
    } else {
    	g_bIsRecStatus = TRUE;
    }

#if defined(_UI_STYLE_LVGL_)
	flow_lv_init();
#endif

	movie_rec_mask = Movie_GetMovieRecMask();
	clone_rec_mask = Movie_GetCloneRecMask();

	mask = 1;
	for (i = 0; i < SENSOR_CAPS_COUNT; i++) {
		if ((movie_rec_mask & mask) || (SENSOR_INSERT_MASK & mask)) {

			// set thumbnail size
			thmub_size.w = MOVIE_THUMB_WIDTH;
			thmub_size.h = (thmub_size.w * gMovie_Rec_Info[i].size.h) / gMovie_Rec_Info[i].size.w;
			ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1 + i, MOVIEMULTI_PARAM_IMGCAP_THUM_SIZE, (UINT32)&thmub_size);

			MovieFast_SetRecParamByRecID(gMovie_Rec_Info[i].rec_id);
		}

		if (clone_rec_mask & mask) {

			// set thumbnail size
			thmub_size.w = MOVIE_THUMB_WIDTH;
			thmub_size.h = (thmub_size.w * gMovie_Clone_Info[i].size.h) / gMovie_Clone_Info[i].size.w;
			ImageApp_MovieMulti_SetParam(_CFG_CLONE_ID_1 + i, MOVIEMULTI_PARAM_IMGCAP_THUM_SIZE, (UINT32)&thmub_size);

			MovieFast_SetRecParamByRecID(gMovie_Clone_Info[i].rec_id);
		}

		mask <<= 1;
	}

	MovieFast_RecMovieStamp();

	// trigger record
	mask = 1;
	for (i = 0; i < SENSOR_CAPS_COUNT; i++)
	{
		// start clone path first due to some functions (such as 2v1a need this procedure)
		if (clone_rec_mask & mask) {
			ImageApp_MovieMulti_SetParam(gMovie_Clone_Info[i].rec_id, MOVIEMULTI_PARAM_FILE_WRITE_BLKSIZE, 0x200000);
			ImageApp_MovieMulti_SetParam(gMovie_Clone_Info[i].rec_id, MOVIEMULTI_PARAM_FILE_BUFRESSEC, uifile_buffer_reserved_sec);
			//ImageApp_MovieMulti_RecStart(gMovie_Clone_Info[i].rec_id);
			ImageApp_MovieMulti_TrigOnce(gMovie_Clone_Info[i].rec_id, SysGetFlag(VideoLenth));
		}

		if (movie_rec_mask & mask) {
			ImageApp_MovieMulti_SetParam(gMovie_Rec_Info[i].rec_id, MOVIEMULTI_PARAM_FILE_WRITE_BLKSIZE, 0x200000);
			ImageApp_MovieMulti_SetParam(gMovie_Rec_Info[i].rec_id, MOVIEMULTI_PARAM_FILE_BUFRESSEC, uifile_buffer_reserved_sec);
			//ImageApp_MovieMulti_RecStart(gMovie_Rec_Info[i].rec_id);
			ImageApp_MovieMulti_TrigOnce(gMovie_Rec_Info[i].rec_id, SysGetFlag(VideoLenth));
		}

		mask <<= 1;
	}
}

static void MovieFast_OnRecStop(void)
{
	UINT32 i, mask;
	UINT32 movie_rec_mask, clone_rec_mask;

    if (g_bIsRecStatus) {
		g_bIsRecStatus = FALSE;
    } else {
    	return;
    }

	movie_rec_mask = Movie_GetMovieRecMask();
	clone_rec_mask = Movie_GetCloneRecMask();

	mask = 1;
	for (i = 0; i < SENSOR_CAPS_COUNT; i++) {
		// stop clone path first due to some functions (such as 2v1a need this procedure)
		if (clone_rec_mask & mask) {
			ImageApp_MovieMulti_RecStop(gMovie_Clone_Info[i].rec_id);
		}

		if (movie_rec_mask & mask) {
			ImageApp_MovieMulti_RecStop(gMovie_Rec_Info[i].rec_id);
		}

		mask <<= 1;
	}

	if (UI_GetData(FL_MOVIE_DATEIMPRINT) == MOVIE_DATEIMPRINT_ON && ImageApp_MovieMulti_IsStreamRunning(_CFG_STRM_ID_1)==0) {
		MovieStamp_Disable();
	}

}

static void MovieFast_FileNamingCB(MOVIE_CFG_REC_ID id, char *pFileName)
{
    //1. The FileID and DirID is set at booting.
    //2. When it can erntry this function, only the File ID (serial number) is accumulated.
    //3. If the working mode is normal and it is cyclic recording, please judge the DirID and FileID by yourself before enering next new file recording.
	UINT32 nextFolderID = 0, nextFileID = 0;

    if (DCF_GetDBInfo(DCF_INFO_IS_9999)) {
		DBG_ERR("Exceed max dcf file!\r\n");
		pFileName[0] = '\0';
	} else {
		DCF_GetNextID(&nextFolderID,&nextFileID);
		DCF_MakeObjPath(nextFolderID, nextFileID, DCF_FILE_TYPE_MP4, pFileName);

		if(id == _CFG_REC_ID_1){
			snprintf(thumb_current_path_main, sizeof(thumb_current_path_main), "%s", pFileName);
		}
		else if(id == _CFG_CLONE_ID_1){
			snprintf(thumb_current_path_clone, sizeof(thumb_current_path_clone), "%s", pFileName);
		}
	}
}

static void MovieFast_UserEventCb(UINT32 id, MOVIE_USER_CB_EVENT event_id, UINT32 value)
{
	//static UINT32 u32Cnt = 0;

	switch ((UINT32)event_id) {
#if 0
	case MOVIE_USER_CB_EVENT_REC_ONE_SECOND: {
			u32Cnt++;
            //DBG_DUMP("%s: u32Cnt=%d\r\n", __func__, u32Cnt);
            if (u32Cnt == 10) {
                u32Cnt = 0;
                vos_flag_set(MOVIEFAST_FLG_ID, FLGMOVIEFAST_SHUTDOWN);
            }
		}
		break;
#endif

	case MOVIE_USER_CB_EVENT_CLOSE_FILE_COMPLETED: {
			MOVIEMULTI_CLOSE_FILE_INFO *info = (MOVIEMULTI_CLOSE_FILE_INFO *)value;
			DCF_AddDBfile(info->path);
			DBG_DUMP("%s added to DCF\r\n", info->path);
			vos_flag_set(MOVIEFAST_FLG_ID, FLGMOVIEFAST_SHUTDOWN);
		}
		break;

	case MOVIE_USER_CB_EVENT_RAWENC_PREPARED: {
#if (USE_EXIF == ENABLE)
			EXIF_HANDLE_ID HandleID;
			HandleID = value;
			ExifVendor_Write0thIFD(HandleID);
			ExifVendor_WriteExifIFD(HandleID);
			ExifVendor_Write0thIntIFD(HandleID);
#endif
		}
		break;

	case MOVIE_USER_CB_EVENT_JENC_DONE:{

		fastboot_wait_done(BOOT_INIT_FILESYSOK);

		MOVIE_JPEG_INFO *ptr = (MOVIE_JPEG_INFO*)value;

		if(ptr->sign == MAKEFOURCC('T', 'H', 'U', 'M')){

			char* thumb_current_path = NULL;

			if(id == _CFG_REC_ID_1){
				thumb_current_path = thumb_current_path_main;
			}
			else if(id == _CFG_CLONE_ID_1){
				thumb_current_path = thumb_current_path_clone;
			}

			if(thumb_current_path){

				UINT32 length = strlen(thumb_current_path);

				if(length){

					char tmp[256] = {'\0'};

					snprintf(tmp, sizeof(tmp), "%s%s", MOVIE_THUMB_PATH, (thumb_current_path + (length - 12))); /* DCF 8.3 naming rule */
					snprintf(tmp + strlen(tmp) - 3, sizeof(tmp), "%s", "JPG");

					DBG_DUMP("MOVIE_USER_CB_EVENT_JENC_DONE %s\n", tmp);

					FST_FILE fp = FileSys_OpenFile(tmp, FST_OPEN_ALWAYS | FST_OPEN_WRITE);

					FileSys_WriteFile(fp, (UINT8*)ptr->addr_va, &ptr->size, 0, NULL);
					FileSys_CloseFile(fp);
					thumb_current_path[0] = '\0';
				}
			}
		}

		break;
	}

	case MOVIE_USER_CB_EVENT_FILENAMING_MOV_CB:
	case MOVIE_USER_CB_EVENT_FILENAMING_EMR_CB: {
	            CHAR *pFileName = (CHAR *) value;

	            // Make custome file name
	            MovieFast_FileNamingCB(id, pFileName);

		}
		break;
	}
}

static void MovieFast_CmdTsk_Exit(void)
{
    g_moviefast_tsk_run = 0;
}

int MovieFast_GetWaterLogoSource(const UINT32 recWidth,WATERLOGO_BUFFER *waterSrc)
{
#if defined (WATERLOGO_FUNCTION) && (WATERLOGO_FUNCTION == ENABLE)
	if(recWidth >= 1080){
		memcpy(waterSrc,&g_WaterLogo_1440,sizeof(WATERLOGO_BUFFER));
	}else{
		memcpy(waterSrc,&g_WaterLogo_640,sizeof(WATERLOGO_BUFFER));
	}
#endif
	return E_OK;
}

THREAD_RETTYPE MovieFast_InitFileNamingThread(void *arg)
{
	fastboot_wait_done(BOOT_INIT_FILESYSOK);

	DCF_InstallID();

	DCF_OPEN_PARM dcfParm = {
		.Drive = 'A',
		.WorkbuffAddr = mempool_dcf,
		.WorkbuffSize = POOL_SIZE_DCF_BUFFER,
	};
	g_dcf_hdl = DCF_Open(&dcfParm);

	DCF_SetParm(DCF_PRMID_REMOVE_DUPLICATE_FOLDER, TRUE);
	DCF_SetParm(DCF_PRMID_REMOVE_DUPLICATE_FILE, TRUE);
	DCF_SetParm(DCF_PRMID_SET_VALID_FILE_FMT, DCF_FILE_TYPE_JPG|DCF_FILE_TYPE_MP4|DCF_FILE_TYPE_MOV);
	DCF_SetParm(DCF_PRMID_SET_DEP_FILE_FMT, DCF_FILE_TYPE_JPG|DCF_FILE_TYPE_WAV|DCF_FILE_TYPE_MPO);
	DCF_SetDirFreeChars(DCF_DIR_NAME);
	DCF_SetFileFreeChars(DCF_FILE_TYPE_ANYFORMAT, DCF_FILE_NAME);
	DCF_ScanObj();

	fastboot_set_done(BOOT_INIT_FILENAMINGOK);

	THREAD_RETURN(0);
}
extern void Set_NIGHTMODE(UINT32 id, UINT8 isSnapVideo);
extern void Set_AEMODE(UINT32 id);
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};

	DBG_FUNC("\r\n");

	Movie_CommPoolInit();
	g_MovieFast_InitCommonMemFinish = 1;

/*
#if (defined(_sen_os05a10_) || defined(_sen_imx335_))
	SysSetFlag(FL_MOVIE_SIZE, MOVIE_SIZE_FRONT_2560x1440P30);
#elif (defined(_sen_imx290_) || defined(_sen_imx291_))
	SysSetFlag(FL_MOVIE_SIZE, MOVIE_SIZE_FRONT_1920x1080P30);
#else
	SysSetFlag(FL_MOVIE_SIZE, MOVIE_SIZE_FRONT_2560x1440P30);
#endif

	SysSetFlag(FL_MOVIE_TIMELAPSE_REC, MOVIE_TIMELAPSEREC_OFF);
	SysSetFlag(FL_MovieAudioRec, MOVIE_AUD_REC_ON);
	SysSetFlag(FL_MOVIE_CYCLIC_REC, MOVIE_CYCLICREC_1MIN);
 */   
	MovieFast_SetRecInfoByUISetting();
    Set_NIGHTMODE(0, 1);
	Set_AEMODE(0);

#if (_PACKAGE_DISPLAY_)
	gMovie_Disp_Info.vout_ctrl = GxVideo_GetDeviceCtrl(DOUT1,DISPLAY_DEVCTRL_CTRLPATH);
	gMovie_Disp_Info.vout_path = GxVideo_GetDeviceCtrl(DOUT1,DISPLAY_DEVCTRL_PATH);
	gMovie_Disp_Info.ratio = GxVideo_GetDeviceAspect(0);
	gMovie_Disp_Info.dir = SysVideo_GetDirbyID(0);
#endif

	MaxLinkInfo.MaxImgLink = SENSOR_CAPS_COUNT;
#if (_PACKAGE_DISPLAY_)
	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[i]);
		ImageApp_MovieMulti_Config(MOVIE_CONFIG_RECORD_INFO, (UINT32)&gMovie_Clone_Info[i]);
		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
	}
	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);
#if (_PACKAGE_DISPLAY_)
	ImageApp_MovieMulti_Config(MOVIE_CONFIG_DISP_INFO, (UINT32)&gMovie_Disp_Info);
#endif

	// File option
	ImageApp_MovieMulti_FileOption((MOVIE_RECODE_FILE_OPTION *) &gMovie_Rec_Option);

	// User Callback
	ImageApp_MovieMulti_RegUserCB(MovieFast_UserEventCb);


#if (MOVIE_DIRECT_FUNC == ENABLE)
	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);

#if (ANR_FUNC == ENABLE)
	HD_AUDIOCAP_ANR audio_cfg_param = {0};

	// set audio ANR function parameter
	audio_cfg_param.enabled = TRUE;
	audio_cfg_param.suppress_level = 13;
	audio_cfg_param.hpf_cut_off_freq = 200;
	audio_cfg_param.bias_sensitive = 9;

	ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1, MOVIEMULTI_PARAM_AUD_ACAP_ANR, (UINT32)&audio_cfg_param);
#endif

	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);

	ImageApp_MovieMulti_Open();

	for (i = 0; i < SENSOR_CAPS_COUNT; i++) {
		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 (_PACKAGE_DISPLAY_)
	ImageApp_MovieMulti_ImgLinkForDisp(_CFG_REC_ID_1, DISABLE, TRUE);
#endif
	// start acap function
	ImageApp_MovieMulti_AudCapStart(0);

#if (USE_EXIF == ENABLE)
	ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1, MOVIEMULTI_PARAM_IMGCAP_EXIF_EN, TRUE);
	//ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1, MOVIEMULTI_PARAM_IMGCAP_THUM_WITH_EXIF, TRUE);   	// enable if wants exif in mp4 thumbnail
	MovieExe_InitExif();
#endif

    MovieFast_InstallID();
	vos_util_delay_ms(500);
	Set_AEMODE(1);
	vos_util_delay_ms(500);

	if ((g_moviefast_tsk_id = vos_task_create(MovieFast_CmdTsk, 0, "MovieFastTsk", PRI_MOVIEFAST_CMDTSK, STKSIZE_MOVIEFAST_CMDTSK)) == 0) {
		DBG_ERR("MovieFastTsk create failed.\r\n");
	} else {
		vos_task_resume(g_moviefast_tsk_id);
	}

    vos_flag_set(MOVIEFAST_FLG_ID, FLGMOVIEFAST_RECSTART);

	THREAD_RETURN(0);

}

static void MovieFast_Close(void)
{
	MovieFast_OnRecStop();

	MovieStamp_Disable();
	MovieStamp_DestroyBuff();

	// stop acap function
	ImageApp_MovieMulti_AudCapStop(0);

	ImageApp_MovieMulti_Close();

	DCF_Close(g_dcf_hdl);
	DCF_UnInstallID();

	vos_flag_destroy(MOVIEFAST_FLG_ID);
}