payton/nt9856x
Template
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

1.p+V更改

Browse Source
This commit is contained in:
payton 2023-11-16 20:13:55 +08:00
parent d0e99d5bef
commit dbdcf1c087
7 changed files with 497 additions and 269 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
rtos/code/application/source/cardv/SrcCode/System/rtos-main.c Executable file → Normal file
View File

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

1
rtos/code/application/source/cardv/SrcCode/System/sys_fastboot.h Executable file → Normal file
View File

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

18
rtos/code/application/source/cardv/SrcCode/System/sys_linuxboot.c Executable file → Normal file
View File

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

178
rtos/code/application/source/cardv/SrcCode/UIApp/Movie/UIAppMovie_CommPoolInit.c Executable file → Normal file
View File

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

529
rtos/code/application/source/cardv/SrcCode/UIApp/MovieFast/MovieFast.c
View File

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

29
rtos/code/application/source/cardv/SrcCode/UIApp/PhotoFast/PhotoFast.c Executable file → Normal file
View File

@ -1184,9 +1184,9 @@ static INT32 PhotoFast_CaptureStart(HD_VIDEO_FRAME *p_video_frame)
}
#if POWERON_FAST_SLICE_ENC_VER2 == ENABLE
return PhotoFast_Sliceencode2_Enq_Frame(p_video_frame);
return PhotoFast_Sliceencode2_Enq_Frame(p_video_frame);
#else
PhotoFast_SliceEncode(vprc_path, p_video_frame);
return PhotoFast_SliceEncode(vprc_path, p_video_frame);
#endif
}
@ -1485,9 +1485,10 @@ THREAD_RETTYPE PhotoFast_FlowPreviewThread(void *arg)
period = 1000 / max_cnt;
#endif
DBG_DUMP("period = %lu ms\n", period);
DBG_DUMP("period = %lu ms, max_cnt = %lu\n", period, max_cnt);
PhotoFast_SliceEncode2_Open(vprc_path, max_cnt);
nvt_cmdsys_runcmd("ae set_speed 0 128 700 700 100 ");
@ -1719,7 +1720,7 @@ THREAD_RETTYPE PhotoFast_FlowPreviewThread(void *arg)
case DX_HUNTING_MODE_PHOTO_MOVIE:
if (start_cap == TRUE) {
// g_u32PrvCapCnt++;
#if HUNTING_CAMERA_MCU == ENABLE
if(sf_is_night_mode(0) ==TRUE){
//DrvGPIO_IRLed_Turn_Onoff(0);
@ -1732,11 +1733,12 @@ THREAD_RETTYPE PhotoFast_FlowPreviewThread(void *arg)
}
else{
DBG_WRN("enq frame failed...\n");
/* release */
if ((hd_ret = hd_videoproc_release_out_buf(vprc_path, &video_frame))!= HD_OK) {
DBG_ERR("failed to hd_videoproc_release_out_buf, er=%d\n", (int)hd_ret);
goto exit;
}
/* release */
if ((hd_ret = hd_videoproc_release_out_buf(vprc_path, &video_frame))!= HD_OK) {
DBG_ERR("failed to hd_videoproc_release_out_buf, er=%d\n", (int)hd_ret);
goto exit;
}
}
if (g_u32PrvCapCnt >= max_cnt) {
@ -2086,7 +2088,12 @@ void Set_AEMODE(UINT32 id)
if (id == 1){
ae_manual.manual.mode = 1;
#if HUNTING_CAMERA_MCU == ENABLE
if (puiPara->NightMode == 0) {
if(puiPara->CamMode == SF_CAM_MODE_VIDEO2)
{
ae_manual.manual.expotime = 33333;
ae_manual.manual.iso_gain = ae_status.status_info.iso_gain[0]*ae_status.status_info.expotime[0]/33333;
}
else if (puiPara->NightMode == 0) {
ae_manual.manual.expotime = 125000;//ae_status.status_info.expotime[0];
ae_manual.manual.iso_gain = ae_status.status_info.iso_gain[0]*ae_status.status_info.expotime[0]/125000;
}
@ -2266,7 +2273,7 @@ ER PhotoFast_Movie_Init(void)
id++;
mem_cfg.pool_info[id].type = HD_COMMON_MEM_COMMON_POOL;
mem_cfg.pool_info[id].blk_size = DBGINFO_BUFSIZE()+VDO_YUV_BUFSIZE(sensor_info->sSize.w, sensor_info->sSize.h , HD_VIDEO_PXLFMT_YUV420);
mem_cfg.pool_info[id].blk_cnt = 1;
mem_cfg.pool_info[id].blk_cnt = 3; /* depending on cont shot */
mem_cfg.pool_info[id].ddr_id = DDR_ID0;
vendor_common_mem_relayout(&mem_cfg);

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

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