payton/nt9856x
Template
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
8c1c8dcfd4
nt9856x/rtos/code/application/source/cardv/SrcCode/UIApp/MovieFast/MovieFast.c

1108 lines
37 KiB
C
Raw Blame History

////////////////////////////////////////////////////////////////////////////////
#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
#include <kwrap/cmdsys.h>
/**
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
*********************************************************************************/
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 void MovieFast_SetRRC(HD_PATH_ID path_id, UINT8 enable, UINT32 range, UINT32 step)
{
HD_H26XENC_ROW_RC rowrc = {0};
rowrc.enable = enable;
rowrc.i_qp_range = range;
rowrc.i_qp_step = step;
rowrc.p_qp_range = range;
rowrc.p_qp_step = step;
rowrc.min_i_qp = 1;
rowrc.max_i_qp = 51;
rowrc.min_p_qp = 1;
rowrc.max_p_qp = 51;
hd_videoenc_set(path_id, HD_VIDEOENC_PARAM_OUT_ROW_RC, &rowrc);
}
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 SF_IQ_TEST != ENABLE
if(sf_get_power_off_flag()){
sf_mcu_reg_set(SF_MCU_POWEROFF,0);
}else{
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);
#if HUNTING_CAMERA_MCU == ENABLE
/*if(1 == puiPara->DebugMode)
{
MovieFast_SetAq(ImageApp_MovieMulti_GetVdoEncPort(gMovie_Clone_Info[i].rec_id), 4);
MovieFast_SetRRC(ImageApp_MovieMulti_GetVdoEncPort(gMovie_Clone_Info[i].rec_id), 1, 1, 1);
}else if(2 == puiPara->DebugMode){
MovieFast_SetAq(ImageApp_MovieMulti_GetVdoEncPort(gMovie_Clone_Info[i].rec_id), 4);
MovieFast_SetRRC(ImageApp_MovieMulti_GetVdoEncPort(gMovie_Clone_Info[i].rec_id), 1, 1, 1);
}else {
MovieFast_SetAq(ImageApp_MovieMulti_GetVdoEncPort(gMovie_Clone_Info[i].rec_id), 2);
MovieFast_SetRRC(ImageApp_MovieMulti_GetVdoEncPort(gMovie_Clone_Info[i].rec_id), 1, 1, 1);
}*/
MovieFast_SetAq(ImageApp_MovieMulti_GetVdoEncPort(gMovie_Clone_Info[i].rec_id), 2);
MovieFast_SetRRC(ImageApp_MovieMulti_GetVdoEncPort(gMovie_Clone_Info[i].rec_id), 1, 1, 1);
#else
MovieFast_SetAq(ImageApp_MovieMulti_GetVdoEncPort(gMovie_Clone_Info[i].rec_id), 4);
#endif
}
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;
}
//nvt_cmdsys_runcmd("venc info");
}
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};
MOVIE_SENSOR_INFO *pSenCfg = &sen_cfg;
HD_RESULT hd_ret;
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
}
if ((hd_ret = vendor_isp_init()) != HD_OK) {
DBG_ERR("vendor_isp_init fail(%d)\n", hd_ret);
}
if (strlen(pSenCfg->iq_path.path) != 0) {
IQT_DTSI_INFO iq_dtsi_info;
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);
#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(132);
//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);
}
Reference in New Issue View Git Blame Copy Permalink