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-02 09:35:48 +08:00
parent 95c1db834a
commit 537a6a1684
18 changed files with 711 additions and 184 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

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

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

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

103
rtos/code/application/source/cardv/SrcCode/FastFlow/flow_preview.c
View File

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

1
rtos/code/application/source/cardv/SrcCode/FastFlow/flow_preview.h
View File

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

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

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

17
rtos/code/application/source/cardv/SrcCode/System/sys_fwload.c
View File

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

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

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

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

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

5
rtos/code/application/source/cardv/SrcCode/UIApp/MovieStamp/MovieStamp.c
View File

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

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

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

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

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

7
rtos/code/application/source/cardv/SrcCode/UIApp/PhotoFast/PhotoFast.h
View File

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

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

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

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

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

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

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

53
rtos/code/application/source/cardv/rtos-main-hunting_lvgl.lds
View File

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

2
rtos/code/lib/include/ImageApp/ImageApp_MovieMulti.h
View File

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

BIN
rtos/code/lib/output/libimageapp_moviemulti.a
View File

Binary file not shown.