1048 lines
34 KiB
C
1048 lines
34 KiB
C
////////////////////////////////////////////////////////////////////////////////
|
|
#include "PrjInc.h"
|
|
#include "ImageApp/ImageApp_MovieMulti.h"
|
|
#include "avfile/movieinterface_def.h"
|
|
#include "kwrap/task.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"
|
|
#include "flow_preview.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>
|
|
#include "sf_led.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_poweroff_tsk_run = 1;
|
|
static UINT32 g_MovieFast_InitCommonMemFinish=0;
|
|
static THREAD_HANDLE g_moviefast_tsk_id = 0;
|
|
static THREAD_HANDLE g_moviefast_power_off_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_PowerOffTsk(void)
|
|
{
|
|
const BOOL delay_ms = 200;
|
|
|
|
THREAD_ENTRY();
|
|
|
|
DBG_DUMP("MovieFast_PowerOffTsk started\n");
|
|
|
|
g_moviefast_poweroff_tsk_run = TRUE;
|
|
|
|
while(g_moviefast_poweroff_tsk_run)
|
|
{
|
|
if(TRUE == flow_preview_get_stop_flag()){
|
|
DBG_ERR("Stop!!!!!!!!!!!!!!!!!\n");
|
|
break;
|
|
}
|
|
|
|
vos_util_delay_ms(delay_ms);
|
|
}
|
|
|
|
if(MOVIEFAST_FLG_ID){
|
|
vos_flag_set(MOVIEFAST_FLG_ID, FLGMOVIEFAST_SHUTDOWN);
|
|
}
|
|
else{
|
|
MovieFast_ShutDown();
|
|
}
|
|
|
|
THREAD_RETURN(0);
|
|
}
|
|
|
|
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");
|
|
MovieFast_ShutDown();
|
|
}
|
|
|
|
MovieFast_OnRecStart();
|
|
} else if (uiFlag & FLGMOVIEFAST_RECSTOP) {
|
|
MovieFast_OnRecStop();
|
|
} else if (uiFlag & FLGMOVIEFAST_SHUTDOWN) {
|
|
MovieFast_ShutDown();
|
|
}else{
|
|
DBG_WRN("No flag for MovieFast_CmdTsk\r\n");
|
|
}
|
|
}
|
|
|
|
THREAD_RETURN(0);
|
|
}
|
|
|
|
static void MovieFast_ShutDown(void)
|
|
{
|
|
UINT8 mode = DrvGPIO_GetPhotoMovieModeFromMonitor();
|
|
|
|
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
|
|
|
|
DBG_DUMP("PhotoMovie mode = %u\n", mode);
|
|
|
|
vos_perf_list_dump();
|
|
|
|
if(mode == DX_HUNTING_MODE_PHOTO_MOVIE){
|
|
extern void PhotoFast_TriggerFrm_Dump(void);
|
|
PhotoFast_TriggerFrm_Dump();
|
|
}
|
|
|
|
#endif
|
|
|
|
#if HUNTING_CAMERA_MCU
|
|
#if HUNTING_CAMERA_4G == ENABLE
|
|
fastboot_set_done(BOOT_FLOW_BOOT);
|
|
flow_wait_linux();
|
|
#else
|
|
sf_mcu_reg_set(SF_MCU_POWEROFF,0);
|
|
#endif
|
|
#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();
|
|
if(mode == DX_HUNTING_MODE_PHOTO_MOVIE){
|
|
extern void PhotoFast_TriggerFrm_Dump(void);
|
|
PhotoFast_TriggerFrm_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_SetAq(HD_PATH_ID path_id, UINT8 ip_str)
|
|
{
|
|
HD_H26XENC_AQ aq_param = {0};
|
|
|
|
if(ip_str > 8)
|
|
ip_str = 8;
|
|
|
|
aq_param.enable = 1; // AQ enable. default: 0, range: 0~1 (0: disable, 1: enable)
|
|
aq_param.i_str = ip_str; // aq strength of I frame. default: 3, range: 1~8
|
|
aq_param.p_str = ip_str; // aq strength of P frame. default: 1, range: 1~8
|
|
aq_param.min_delta_qp = -8; // max delta qp of aq.
|
|
aq_param.max_delta_qp = 8; // min delta qp of aq.
|
|
hd_videoenc_set(path_id, HD_VIDEOENC_PARAM_OUT_AQ, &aq_param);
|
|
}
|
|
|
|
static void MovieFast_RecMovieStamp(void)
|
|
{
|
|
UINT32 Width, Height;
|
|
UINT32 uiStampAddr;
|
|
UINT32 uiStampMemSize;
|
|
WATERLOGO_BUFFER waterLogoSrc={0};
|
|
HD_PATH_ID uiVEncOutPortId = 0;
|
|
UINT32 i, mask;
|
|
UINT32 movie_rec_mask, clone_rec_mask;
|
|
|
|
#if defined(_UI_STYLE_LVGL_)
|
|
lv_color32_t color = (lv_color32_t){.full = LV_USER_CFG_STAMP_COLOR_BACKGROUND};
|
|
uint8_t r = LV_COLOR_GET_R32(color);
|
|
uint8_t g = LV_COLOR_GET_G32(color);
|
|
uint8_t b = LV_COLOR_GET_B32(color);
|
|
STAMP_COLOR StampColorBg = {RGB_GET_Y(r, g, b), RGB_GET_U(r, g, b), RGB_GET_V(r, g, b)}; // date stamp foreground color
|
|
#else
|
|
STAMP_COLOR StampColorBg = {RGB_GET_Y( 16, 16, 16), RGB_GET_U( 16, 16, 16), RGB_GET_V( 16, 16, 16)}; // date stamp background color
|
|
#endif
|
|
|
|
#if defined(_UI_STYLE_LVGL_)
|
|
color = (lv_color32_t){.full = LV_USER_CFG_STAMP_COLOR_FRAME};
|
|
r = LV_COLOR_GET_R32(color);
|
|
g = LV_COLOR_GET_G32(color);
|
|
b = LV_COLOR_GET_B32(color);
|
|
STAMP_COLOR StampColorFr = {RGB_GET_Y(r, g, b), RGB_GET_U(r, g, b), RGB_GET_V(r, g, b)}; // date stamp foreground color
|
|
#else
|
|
STAMP_COLOR StampColorFr = {RGB_GET_Y( 16, 16, 16), RGB_GET_U( 16, 16, 16), RGB_GET_V( 16, 16, 16)}; // date stamp frame color
|
|
#endif
|
|
|
|
|
|
#if defined(_UI_STYLE_LVGL_)
|
|
color = (lv_color32_t){.full = LV_USER_CFG_STAMP_COLOR_TEXT};
|
|
r = LV_COLOR_GET_R32(color);
|
|
g = LV_COLOR_GET_G32(color);
|
|
b = LV_COLOR_GET_B32(color);
|
|
STAMP_COLOR StampColorFg = {RGB_GET_Y(r, g, b), RGB_GET_U(r, g, b), RGB_GET_V(r, g, b)}; // date stamp foreground color
|
|
#else
|
|
STAMP_COLOR StampColorFg = {RGB_GET_Y(224, 224, 192), RGB_GET_U(224, 224, 192), RGB_GET_V(224, 224, 192)}; // date stamp foreground color
|
|
#endif
|
|
|
|
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 = (UI_GetData(FL_MOVIE_CODEC) == MOVIE_CODEC_H265) ? _CFG_CODEC_H265 : _CFG_CODEC_H264;
|
|
//#NT#2018/02/14#KCHong -begin
|
|
//#NT#support sensor rotate setting
|
|
gMovie_Rec_Info[i].sensor_rotate = FALSE;
|
|
//#NT#2018/02/14#KCHong -end
|
|
MovieMapping_GetAqInfo(size_idx, ipl_id, (UINT32)&gMovie_Rec_Info[i].aq_info);
|
|
MovieMapping_GetCbrInfo(size_idx, ipl_id, (UINT32)&gMovie_Rec_Info[i].cbr_info);
|
|
movie_aspect_ratio_idx = MovieMapping_GetImageRatio(size_idx, ipl_id);
|
|
|
|
switch (movie_aspect_ratio_idx) {
|
|
case IMAGERATIO_16_9:
|
|
gMovie_Rec_Info[i].ratio.w = 16;
|
|
gMovie_Rec_Info[i].ratio.h = 9;
|
|
gMovie_Rec_Info[i].disp_ratio.w = 16;
|
|
gMovie_Rec_Info[i].disp_ratio.h = 9;
|
|
break;
|
|
default:
|
|
gMovie_Rec_Info[i].ratio.w = 4;
|
|
gMovie_Rec_Info[i].ratio.h = 3;
|
|
gMovie_Rec_Info[i].disp_ratio.w = 4;
|
|
gMovie_Rec_Info[i].disp_ratio.h = 3;
|
|
break;
|
|
}
|
|
|
|
// set clone movie
|
|
if (rec_type == MOVIE_REC_TYPE_CLONE) {
|
|
gMovie_Clone_Info[i].size.w = MovieMapping_GetCloneWidth(size_idx, ipl_id);
|
|
gMovie_Clone_Info[i].size.h = MovieMapping_GetCloneHeight(size_idx, ipl_id);
|
|
gMovie_Clone_Info[i].raw_enc_size.w = MovieMapping_GetCloneWidth(size_idx, ipl_id);
|
|
gMovie_Clone_Info[i].raw_enc_size.h = MovieMapping_GetCloneHeight(size_idx, ipl_id);
|
|
gMovie_Clone_Info[i].frame_rate = MovieMapping_GetCloneFrameRate(size_idx, ipl_id);
|
|
gMovie_Clone_Info[i].target_bitrate = MovieMapping_GetCloneTargetBitrate(size_idx, ipl_id);
|
|
gMovie_Clone_Info[i].dar = MovieMapping_GetCloneDispAspectRatio(size_idx, ipl_id);
|
|
gMovie_Clone_Info[i].codec = (UI_GetData(FL_MOVIE_CODEC) == MOVIE_CODEC_H265) ? _CFG_CODEC_H265 : _CFG_CODEC_H264;
|
|
MovieMapping_GetCloneAqInfo(size_idx, ipl_id, (UINT32)&gMovie_Clone_Info[i].aq_info);
|
|
MovieMapping_GetCloneCbrInfo(size_idx, ipl_id, (UINT32)&gMovie_Clone_Info[i].cbr_info);
|
|
movie_aspect_ratio_idx = MovieMapping_GetCloneImageRatio(size_idx, ipl_id);
|
|
|
|
switch (movie_aspect_ratio_idx) {
|
|
case IMAGERATIO_16_9:
|
|
gMovie_Clone_Info[i].ratio.w = 16;
|
|
gMovie_Clone_Info[i].ratio.h = 9;
|
|
gMovie_Clone_Info[i].disp_ratio.w = 16;
|
|
gMovie_Clone_Info[i].disp_ratio.h = 9;
|
|
break;
|
|
default:
|
|
gMovie_Clone_Info[i].ratio.w = 4;
|
|
gMovie_Clone_Info[i].ratio.h = 3;
|
|
gMovie_Clone_Info[i].disp_ratio.w = 4;
|
|
gMovie_Clone_Info[i].disp_ratio.h = 3;
|
|
break;
|
|
}
|
|
}
|
|
|
|
mask <<= 1;
|
|
}
|
|
}
|
|
|
|
|
|
static void MovieFast_OnRecStart(void)
|
|
{
|
|
UINT32 i, mask;
|
|
UINT32 movie_rec_mask, clone_rec_mask;
|
|
USIZE thmub_size;
|
|
UINT32 uifile_buffer_reserved_sec = 5;
|
|
|
|
#if HUNTING_CAMERA_MCU == ENABLE
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
#endif
|
|
|
|
if (g_bIsRecStatus) {
|
|
return;
|
|
} else {
|
|
g_bIsRecStatus = TRUE;
|
|
}
|
|
|
|
{
|
|
HD_FILEOUT_CONFIG fout_cfg = {0};
|
|
HD_PATH_ID fileout_ctrl = 0;
|
|
HD_RESULT hd_ret = 0;
|
|
|
|
if ((hd_ret = hd_fileout_open(0, HD_FILEOUT_CTRL(0), &fileout_ctrl)) != HD_OK) {
|
|
DBG_ERR("hd_fileout_open(HD_FILEOUT_CTRL) fail(%d)\n", hd_ret);
|
|
}
|
|
|
|
if ((hd_ret = hd_fileout_get(fileout_ctrl, HD_FILEOUT_PARAM_CONFIG, &fout_cfg)) != HD_OK) {
|
|
DBG_ERR("hd_fileout_get(HD_FILEOUT_PARAM_CONFIG) fail(%d)\n", hd_ret);
|
|
}
|
|
|
|
{ //wait_ready
|
|
fout_cfg.wait_ready = (UINT32) FALSE; // TRUE or FALSE
|
|
}
|
|
|
|
if ((hd_ret = hd_fileout_set(fileout_ctrl, HD_FILEOUT_PARAM_CONFIG, &fout_cfg)) != HD_OK) {
|
|
DBG_ERR("hd_fileout_set(HD_FILEOUT_PARAM_CONFIG) fail(%d)\n", hd_ret);
|
|
}
|
|
|
|
if ((hd_ret = hd_fileout_close(fileout_ctrl)) != HD_OK) {
|
|
DBG_ERR("hd_fileout_close(HD_FILEOUT_CTRL) fail(%d)\n", hd_ret);
|
|
}
|
|
}
|
|
|
|
#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(gMovie_Rec_Info[i].rec_id, MOVIEMULTI_PARAM_IMGCAP_THUM_SIZE, (UINT32)&thmub_size);
|
|
|
|
MovieFast_SetRecParamByRecID(gMovie_Rec_Info[i].rec_id);
|
|
MovieFast_SetAq(ImageApp_MovieMulti_GetVdoEncPort(gMovie_Rec_Info[i].rec_id), 4);
|
|
}
|
|
|
|
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(gMovie_Clone_Info[i].rec_id, MOVIEMULTI_PARAM_IMGCAP_THUM_SIZE, (UINT32)&thmub_size);
|
|
|
|
MovieFast_SetRecParamByRecID(gMovie_Clone_Info[i].rec_id);
|
|
MovieFast_SetAq(ImageApp_MovieMulti_GetVdoEncPort(gMovie_Clone_Info[i].rec_id), 4);
|
|
}
|
|
|
|
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) {
|
|
vos_perf_list_mark("sie_vd", __LINE__, 5);
|
|
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);
|
|
|
|
#if HUNTING_CAMERA_MCU == ENABLE
|
|
ImageApp_MovieMulti_SetParam(gMovie_Clone_Info[i].rec_id, MOVIEMULTI_PARAM_FILE_SEAMLESSSEC, puiPara->VideoLenth);
|
|
ImageApp_MovieMulti_TrigOnce(gMovie_Clone_Info[i].rec_id, puiPara->VideoLenth);
|
|
#else
|
|
ImageApp_MovieMulti_SetParam(gMovie_Clone_Info[i].rec_id, MOVIEMULTI_PARAM_FILE_SEAMLESSSEC, 10);
|
|
ImageApp_MovieMulti_TrigOnce(gMovie_Clone_Info[i].rec_id, 10);
|
|
#endif
|
|
}
|
|
|
|
if (movie_rec_mask & mask) {
|
|
#if SF_TRIGGER_TIME_TEST == ENABLE && HUNTING_CAMERA_MCU == ENABLE
|
|
sf_trigger_time_led_cb(1);
|
|
#endif
|
|
vos_perf_list_mark("sie_vd", __LINE__, 6);
|
|
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);
|
|
|
|
#if HUNTING_CAMERA_MCU == ENABLE
|
|
ImageApp_MovieMulti_SetParam(gMovie_Rec_Info[i].rec_id, MOVIEMULTI_PARAM_FILE_SEAMLESSSEC, puiPara->VideoLenth);
|
|
ImageApp_MovieMulti_TrigOnce(gMovie_Rec_Info[i].rec_id, puiPara->VideoLenth);
|
|
#else
|
|
ImageApp_MovieMulti_SetParam(gMovie_Rec_Info[i].rec_id, MOVIEMULTI_PARAM_FILE_SEAMLESSSEC, 10);
|
|
ImageApp_MovieMulti_TrigOnce(gMovie_Rec_Info[i].rec_id, 10);
|
|
#endif
|
|
}
|
|
|
|
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);
|
|
DCF_AddDBfile(pFileName);
|
|
DBG_DUMP("%s added to DCF\r\n", pFileName);
|
|
#if HUNTING_CAMERA_MCU == ENABLE
|
|
char tmp[NMC_TOTALFILEPATH_MAX_LEN] = {'\0'};
|
|
sprintf(tmp, "S%03ld%04ld.JPG", nextFolderID, nextFileID);
|
|
if(id == _CFG_REC_ID_1){
|
|
snprintf(thumb_current_path_main, sizeof(thumb_current_path_main), "%s", tmp);
|
|
}
|
|
else if(id == _CFG_CLONE_ID_1){
|
|
snprintf(thumb_current_path_clone, sizeof(thumb_current_path_clone), "%s", tmp);
|
|
}
|
|
DBG_DUMP("last send file:%s\r\n", tmp);
|
|
#else
|
|
if(id == _CFG_REC_ID_1){
|
|
snprintf(thumb_current_path_main, sizeof(thumb_current_path_main), "%s", pFileName);
|
|
}
|
|
else if(id == _CFG_CLONE_ID_1){
|
|
snprintf(thumb_current_path_clone, sizeof(thumb_current_path_clone), "%s", pFileName);
|
|
}
|
|
#endif
|
|
|
|
}
|
|
}
|
|
|
|
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: {
|
|
sf_ir_led_set(0, 0, 0, 0);
|
|
//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'};
|
|
|
|
|
|
#if HUNTING_CAMERA_MCU == ENABLE
|
|
snprintf(tmp, sizeof(tmp), "%s%s", MOVIE_THUMB_PATH, thumb_current_path); /* DCF 8.3 naming rule */
|
|
#else
|
|
snprintf(tmp, sizeof(tmp), "%s%s", MOVIE_THUMB_PATH, (thumb_current_path + (length - 12))); /* DCF 8.3 naming rule */
|
|
snprintf(tmp + strlen(tmp) - 3, sizeof(tmp), "%s", "JPG");
|
|
#endif
|
|
DBG_DUMP("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;
|
|
|
|
if(fastboot_wait_done_timeout(BOOT_INIT_FILENAMINGOK, FASTBOOT_WAIT_FILENAMING_TIMEOUT_MS) == E_OK){
|
|
MovieFast_FileNamingCB(id, pFileName);
|
|
}
|
|
else{
|
|
vos_flag_set(MOVIEFAST_FLG_ID, FLGMOVIEFAST_SHUTDOWN);
|
|
}
|
|
}
|
|
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)
|
|
{
|
|
if(fastboot_wait_done_timeout(BOOT_INIT_FILESYSOK, FASTBOOT_WAIT_FILESYS_TIMEOUT_MS) != E_OK){
|
|
goto EXIT;
|
|
}
|
|
|
|
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);
|
|
|
|
EXIT:
|
|
THREAD_RETURN(0);
|
|
}
|
|
extern void Set_NIGHTMODE(UINT32 id, UINT8 isSnapVideo);
|
|
extern void Set_AEMODE(UINT32 id);
|
|
extern void setet_preset_param(void);
|
|
|
|
void MovieFast_Set_Shutdown_flag(void)
|
|
{
|
|
vos_flag_set(MOVIEFAST_FLG_ID, FLGMOVIEFAST_SHUTDOWN);
|
|
}
|
|
|
|
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);
|
|
|
|
|
|
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);
|
|
|
|
|
|
#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);
|
|
setet_preset_param();
|
|
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 (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);
|
|
}
|
|
|
|
#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(330);
|
|
//Set_AEMODE(1);
|
|
//vos_util_delay_ms(500);
|
|
|
|
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");
|
|
} else {
|
|
vos_task_resume(g_moviefast_power_off_tsk_id);
|
|
}
|
|
|
|
if ((g_moviefast_tsk_id = vos_task_create(MovieFast_CmdTsk, 0, "MovieFastTsk", PRI_MOVIEFAST_CMDTSK, STKSIZE_MOVIEFAST_CMDTSK)) == 0) {
|
|
DBG_ERR("MovieFast_CmdTsk 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);
|
|
}
|
|
|