1313 lines
37 KiB
C
Executable File
1313 lines
37 KiB
C
Executable File
#include <stdio.h>
|
|
#include <unistd.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <signal.h>
|
|
#include <hdal.h>
|
|
#include <kwrap/perf.h>
|
|
#include <kwrap/debug.h>
|
|
#include <kwrap/util.h>
|
|
#include <kwrap/flag.h>
|
|
#include <FreeRTOS_POSIX.h>
|
|
#include <FreeRTOS_POSIX/pthread.h>
|
|
#include "PrjCfg.h"
|
|
#include "sys_fastboot.h"
|
|
#include "flow_preview.h"
|
|
#include "vendor_videocapture.h"
|
|
#include "vendor_common.h"
|
|
#include "vendor_isp.h"
|
|
#include "PhotoFast.h"
|
|
#include "UIAppPhoto.h"
|
|
#include "UIAppPhoto_Param.h"
|
|
#include "UIWnd/UIFlow.h"
|
|
#include "ImageApp/ImageApp_Photo.h"
|
|
#include "SysSensor.h"
|
|
#include "PhotoFastSliceEncode.h"
|
|
#include <kwrap/cmdsys.h>
|
|
#if HUNTING_CAMERA_MCU == ENABLE
|
|
#include <sf_mcu.h>
|
|
#endif
|
|
#include "flow_boot_logo.h"
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
//header
|
|
#define DBGINFO_BUFSIZE() (0x200)
|
|
|
|
//RAW
|
|
#define VDO_RAW_BUFSIZE(w, h, pxlfmt) (ALIGN_CEIL_4((w) * HD_VIDEO_PXLFMT_BPP(pxlfmt) / 8) * (h))
|
|
//NRX: RAW compress: Only support 12bit mode
|
|
#define RAW_COMPRESS_RATIO 59
|
|
#define VDO_NRX_BUFSIZE(w, h) (ALIGN_CEIL_4(ALIGN_CEIL_64(w) * 12 / 8 * RAW_COMPRESS_RATIO / 100 * (h)))
|
|
//CA for AWB
|
|
#define VDO_CA_BUF_SIZE(win_num_w, win_num_h) ALIGN_CEIL_4((win_num_w * win_num_h << 3) << 1)
|
|
//LA for AE
|
|
#define VDO_LA_BUF_SIZE(win_num_w, win_num_h) ALIGN_CEIL_4((win_num_w * win_num_h << 1) << 1)
|
|
|
|
//YUV
|
|
#define VDO_YUV_BUFSIZE(w, h, pxlfmt) (ALIGN_CEIL_4((w) * HD_VIDEO_PXLFMT_BPP(pxlfmt) / 8) * (h))
|
|
//NVX: YUV compress
|
|
#define YUV_COMPRESS_RATIO 75
|
|
#define VDO_NVX_BUFSIZE(w, h, pxlfmt) (VDO_YUV_BUFSIZE(w, h, pxlfmt) * YUV_COMPRESS_RATIO / 100)
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
#define SEN_OUT_FMT HD_VIDEO_PXLFMT_RAW12
|
|
#define CAP_OUT_FMT HD_VIDEO_PXLFMT_RAW12
|
|
#define SHDR_CAP_OUT_FMT HD_VIDEO_PXLFMT_RAW12_SHDR2
|
|
#define CA_WIN_NUM_W 32
|
|
#define CA_WIN_NUM_H 32
|
|
#define LA_WIN_NUM_W 32
|
|
#define LA_WIN_NUM_H 32
|
|
#define VA_WIN_NUM_W 16
|
|
#define VA_WIN_NUM_H 16
|
|
#define YOUT_WIN_NUM_W 128
|
|
#define YOUT_WIN_NUM_H 128
|
|
#define ETH_8BIT_SEL 0 //0: 2bit out, 1:8 bit out
|
|
#define ETH_OUT_SEL 1 //0: full, 1: subsample 1/2
|
|
|
|
#define LCD_SIZE_W 960
|
|
#define LCD_SIZE_H 240
|
|
|
|
#define DEFAULT_TASK_STACK_SIZE 4096
|
|
#define FLOW_PREVIEW_TASK_STACK_SIZE 8192
|
|
#define FLAG_SENSOR_TASK_EXIT 0x00000001
|
|
#define FLAG_CAP_PROC_TASK_EXIT 0x00000002
|
|
#define FLAG_VOUT_TASK_EXIT 0x00000004
|
|
#define FLAG_FLOW_PREVIEW_TASK_EXIT 0x00000008
|
|
|
|
#define AE_PRESET_FUNC DISABLE
|
|
#if (AE_PRESET_FUNC == ENABLE)
|
|
#include "adc.h"
|
|
#define ADC_CH_PHOTORESISTOR ADC_CHANNEL_0
|
|
#define ADC_READY_RETRY_CNT (1000000/10) //1 sec
|
|
#endif
|
|
|
|
static ID flag_task = 0;
|
|
|
|
#if defined(_sen_sc4238_)
|
|
static UINT32 g_shdr_mode = 1;
|
|
#else
|
|
static UINT32 g_shdr_mode = 0;
|
|
#endif
|
|
extern UINT16 IRSHTTER;
|
|
extern void get_preset_param(void);
|
|
static ISP_SENSOR_INIT_INFO preset_param;
|
|
static BOOL g_stop_flag = FALSE;
|
|
|
|
void flow_preview_set_stop_flag(BOOL flag)
|
|
{
|
|
g_stop_flag = flag;
|
|
}
|
|
|
|
extern BOOL flow_preview_get_stop_flag(void)
|
|
{
|
|
return g_stop_flag;
|
|
}
|
|
|
|
ISP_SENSOR_INIT_INFO *sen_preset_param(void)
|
|
{
|
|
return &preset_param;
|
|
}
|
|
|
|
HD_RESULT fastflow_common_init(void)
|
|
{
|
|
static BOOL need_init = TRUE;
|
|
HD_RESULT ret = HD_OK;
|
|
HD_COMMON_MEM_INIT_CONFIG mem_cfg = {0};
|
|
|
|
// init hdal
|
|
if (need_init) {
|
|
ret = hd_common_init(0);
|
|
if (ret != HD_OK) {
|
|
printf("common fail=%d\n", ret);
|
|
return -1;
|
|
}
|
|
|
|
// init memory
|
|
// default
|
|
mem_cfg.pool_info[0].type = HD_COMMON_MEM_COMMON_POOL;
|
|
mem_cfg.pool_info[0].blk_size = DBGINFO_BUFSIZE() + 160*120*3/2;
|
|
mem_cfg.pool_info[0].blk_cnt = 1;
|
|
mem_cfg.pool_info[0].ddr_id = DDR_ID0;
|
|
|
|
ret = hd_common_mem_init(&mem_cfg);
|
|
if (ret != HD_OK) {
|
|
printf("mem_init fail=%d\n", ret);
|
|
return -1;
|
|
}
|
|
need_init = FALSE;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static HD_RESULT flowpreview_mem_relayout(void)
|
|
{
|
|
HD_RESULT ret;
|
|
HD_COMMON_MEM_INIT_CONFIG mem_cfg = {0};
|
|
UIAPP_PHOTO_SENSOR_INFO *pSensorInfo = UIAppPhoto_get_SensorInfo(0);
|
|
UINT8 idx = 0;
|
|
|
|
// config common pool (cap)
|
|
mem_cfg.pool_info[idx].type = HD_COMMON_MEM_COMMON_POOL;
|
|
mem_cfg.pool_info[idx].blk_size = DBGINFO_BUFSIZE()+VDO_RAW_BUFSIZE(pSensorInfo->sSize.w, pSensorInfo->sSize.h, CAP_OUT_FMT)
|
|
+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[idx].blk_cnt = 7;
|
|
mem_cfg.pool_info[idx].ddr_id = DDR_ID0;
|
|
// config common pool (main)
|
|
// mem_cfg.pool_info[1].type = HD_COMMON_MEM_COMMON_POOL;
|
|
// mem_cfg.pool_info[1].blk_size = DBGINFO_BUFSIZE()+VDO_YUV_BUFSIZE(pSensorInfo->sSize.w, pSensorInfo->sSize.h, HD_VIDEO_PXLFMT_YUV420);
|
|
// mem_cfg.pool_info[1].blk_cnt = 2;
|
|
// mem_cfg.pool_info[1].ddr_id = DDR_ID0;
|
|
|
|
|
|
#if POWERON_FAST_SLICE_ENC == ENABLE
|
|
idx++;
|
|
mem_cfg.pool_info[idx].type = HD_COMMON_MEM_COMMON_POOL;
|
|
mem_cfg.pool_info[idx].blk_size = PhotoFast_SliceEncode_Get_Max_Dst_Slice_Buffer_Size(HD_VIDEO_PXLFMT_YUV420);
|
|
mem_cfg.pool_info[idx].blk_cnt = 1;
|
|
mem_cfg.pool_info[idx].ddr_id = DDR_ID0;
|
|
|
|
DBG_DUMP("************ blk_size = %lx ************\n", mem_cfg.pool_info[idx].blk_size);
|
|
#else
|
|
|
|
// config common pool (primary image)
|
|
{
|
|
UINT32 u32W, u32H;
|
|
u32W = GetPhotoSizeWidth(SysGetFlag(FL_PHOTO_SIZE));
|
|
u32H = GetPhotoSizeHeight(SysGetFlag(FL_PHOTO_SIZE));
|
|
mem_cfg.pool_info[2].type = HD_COMMON_MEM_COMMON_POOL;
|
|
u32W = ALIGN_CEIL_16(u32W);
|
|
u32H = ALIGN_CEIL_16(u32H);
|
|
mem_cfg.pool_info[2].blk_size = DBGINFO_BUFSIZE()+VDO_YUV_BUFSIZE(u32W, u32H, HD_VIDEO_PXLFMT_YUV420);
|
|
mem_cfg.pool_info[2].blk_cnt = 1;
|
|
mem_cfg.pool_info[2].ddr_id = DDR_ID0;
|
|
}
|
|
|
|
#endif
|
|
|
|
// config common pool (screennail image)
|
|
idx++;
|
|
mem_cfg.pool_info[idx].type = HD_COMMON_MEM_COMMON_POOL;
|
|
#if HUNTING_CAMERA_MCU == ENABLE
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
mem_cfg.pool_info[idx].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[idx].blk_size = DBGINFO_BUFSIZE()+VDO_YUV_BUFSIZE(CFG_SCREENNAIL_W, CFG_SCREENNAIL_H, HD_VIDEO_PXLFMT_YUV420);
|
|
#endif
|
|
mem_cfg.pool_info[idx].blk_cnt = 1;
|
|
mem_cfg.pool_info[idx].ddr_id = DDR_ID0;
|
|
// config common pool (thumbnail image)
|
|
idx++;
|
|
mem_cfg.pool_info[idx].type = HD_COMMON_MEM_COMMON_POOL;
|
|
mem_cfg.pool_info[idx].blk_size = DBGINFO_BUFSIZE()+VDO_YUV_BUFSIZE(CFG_THUMBNAIL_W, CFG_THUMBNAIL_H, HD_VIDEO_PXLFMT_YUV420);
|
|
mem_cfg.pool_info[idx].blk_cnt = 1;
|
|
mem_cfg.pool_info[idx].ddr_id = DDR_ID0;
|
|
// config common pool (EXIF)
|
|
idx++;
|
|
mem_cfg.pool_info[idx].type = HD_COMMON_MEM_COMMON_POOL;
|
|
mem_cfg.pool_info[idx].blk_size = DBGINFO_BUFSIZE()+CFG_JPG_HEADER_SIZE;
|
|
mem_cfg.pool_info[idx].blk_cnt = 1;
|
|
mem_cfg.pool_info[idx].ddr_id = DDR_ID0;
|
|
|
|
#if (_PACKAGE_BOOTLOGO_)
|
|
idx++;
|
|
mem_cfg.pool_info[idx].type = HD_COMMON_MEM_COMMON_POOL;
|
|
mem_cfg.pool_info[idx].blk_size = DBGINFO_BUFSIZE() + ((BOOT_LOGO_LCD_WIDTH * BOOT_LOGO_LCD_HEIGHT * 3) / 2);
|
|
mem_cfg.pool_info[idx].blk_cnt = 2;
|
|
mem_cfg.pool_info[idx].ddr_id = DDR_ID0;
|
|
#endif
|
|
|
|
ret = vendor_common_mem_relayout(&mem_cfg);
|
|
return ret;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
static HD_RESULT set_cap_cfg(HD_PATH_ID *p_video_cap_ctrl)
|
|
{
|
|
HD_RESULT ret = HD_OK;
|
|
HD_VIDEOCAP_DRV_CONFIG cap_cfg = {0};
|
|
HD_PATH_ID video_cap_ctrl = 0;
|
|
HD_VIDEOCAP_CTRL iq_ctl = {0};
|
|
|
|
System_GetSensorInfo(0, SENSOR_DRV_CFG, &cap_cfg);
|
|
#if (SENSOR_SIEPATGEN == ENABLE)
|
|
snprintf(cap_cfg.sen_cfg.sen_dev.driver_name, HD_VIDEOCAP_SEN_NAME_LEN-1, "PATTERN_GEN");
|
|
#endif
|
|
|
|
printf("Using %s\n", cap_cfg.sen_cfg.sen_dev.driver_name);
|
|
|
|
if (g_shdr_mode == 1) {
|
|
printf("Using g_shdr_mode\n");
|
|
}
|
|
|
|
ret = hd_videocap_open(0, HD_VIDEOCAP_0_CTRL, &video_cap_ctrl); //open this for device control
|
|
if (ret != HD_OK) {
|
|
return ret;
|
|
}
|
|
|
|
if (g_shdr_mode == 1) {
|
|
cap_cfg.sen_cfg.shdr_map = HD_VIDEOCAP_SHDR_MAP(HD_VIDEOCAP_HDR_SENSOR1, (HD_VIDEOCAP_0|HD_VIDEOCAP_1));
|
|
}
|
|
ret |= hd_videocap_set(video_cap_ctrl, HD_VIDEOCAP_PARAM_DRV_CONFIG, &cap_cfg);
|
|
|
|
if (g_shdr_mode == 1) {
|
|
iq_ctl.func = HD_VIDEOCAP_FUNC_AE | HD_VIDEOCAP_FUNC_AWB | HD_VIDEOCAP_FUNC_SHDR;
|
|
} else {
|
|
iq_ctl.func = HD_VIDEOCAP_FUNC_AE | HD_VIDEOCAP_FUNC_AWB;
|
|
}
|
|
ret |= hd_videocap_set(video_cap_ctrl, HD_VIDEOCAP_PARAM_CTRL, &iq_ctl);
|
|
|
|
*p_video_cap_ctrl = video_cap_ctrl;
|
|
return ret;
|
|
}
|
|
|
|
static HD_RESULT set_cap_param(HD_PATH_ID video_cap_path, HD_DIM *p_dim)
|
|
{
|
|
HD_RESULT ret = HD_OK;
|
|
{//select sensor mode, manually or automatically
|
|
HD_VIDEOCAP_IN video_in_param = {0};
|
|
|
|
#if (SENSOR_SIEPATGEN == DISABLE)
|
|
video_in_param.sen_mode = HD_VIDEOCAP_SEN_MODE_AUTO; //auto select sensor mode by the parameter of HD_VIDEOCAP_PARAM_OUT
|
|
#else
|
|
UIAPP_PHOTO_SENSOR_INFO *pSensorInfo = UIAppPhoto_get_SensorInfo(0);
|
|
video_in_param.sen_mode = HD_VIDEOCAP_PATGEN_MODE(1, ALIGN_CEIL((pSensorInfo->sSize.w *10/65), 2));
|
|
#endif
|
|
|
|
#if HUNTING_PHOTO_FAST_AE_60_FPS == ENABLE
|
|
video_in_param.frc = HD_VIDEO_FRC_RATIO(60,1);
|
|
#else
|
|
video_in_param.frc = HD_VIDEO_FRC_RATIO(30,1);
|
|
#endif
|
|
|
|
video_in_param.dim.w = p_dim->w;
|
|
video_in_param.dim.h = p_dim->h;
|
|
video_in_param.pxlfmt = SEN_OUT_FMT;
|
|
if (g_shdr_mode == 1) {
|
|
video_in_param.out_frame_num = HD_VIDEOCAP_SEN_FRAME_NUM_2;
|
|
} else {
|
|
video_in_param.out_frame_num = HD_VIDEOCAP_SEN_FRAME_NUM_1;
|
|
}
|
|
|
|
ret = hd_videocap_set(video_cap_path, HD_VIDEOCAP_PARAM_IN, &video_in_param);
|
|
//printf("set_cap_param MODE=%d\r\n", ret);
|
|
if (ret != HD_OK) {
|
|
return ret;
|
|
}
|
|
}
|
|
#if 0 //no crop, full frame
|
|
{
|
|
HD_VIDEOCAP_CROP video_crop_param = {0};
|
|
|
|
video_crop_param.mode = HD_CROP_OFF;
|
|
ret = hd_videocap_set(video_cap_path, HD_VIDEOCAP_PARAM_IN_CROP, &video_crop_param);
|
|
if (ret != HD_OK) {
|
|
return ret;
|
|
}
|
|
//printf("set_cap_param CROP NONE=%d\r\n", ret);
|
|
}
|
|
#else //HD_CROP_ON
|
|
{
|
|
HD_VIDEOCAP_CROP video_crop_param = {0};
|
|
|
|
video_crop_param.mode = HD_CROP_ON;
|
|
video_crop_param.win.rect.x = -1;
|
|
video_crop_param.win.rect.y = -1;
|
|
video_crop_param.win.rect.w = p_dim->w;
|
|
video_crop_param.win.rect.h = p_dim->h;
|
|
video_crop_param.align.w = 4;
|
|
video_crop_param.align.h = 4;
|
|
ret = hd_videocap_set(video_cap_path, HD_VIDEOCAP_PARAM_IN_CROP, &video_crop_param);
|
|
//printf("set_cap_param CROP ON=%d\r\n", ret);
|
|
}
|
|
#endif
|
|
|
|
{
|
|
HD_VIDEOCAP_OUT video_out_param = {0};
|
|
|
|
//without setting dim for no scaling, using original sensor out size
|
|
if (g_shdr_mode == 1) {
|
|
video_out_param.pxlfmt = SHDR_CAP_OUT_FMT;
|
|
} else {
|
|
video_out_param.pxlfmt = CAP_OUT_FMT;
|
|
}
|
|
video_out_param.dir = HD_VIDEO_DIR_NONE;
|
|
video_out_param.frc = 0;
|
|
|
|
#if HUNTING_PHOTO_FAST_AE_60_FPS == ENABLE
|
|
video_out_param.depth = 1;
|
|
#else
|
|
video_out_param.depth = 0;
|
|
#endif
|
|
|
|
ret = hd_videocap_set(video_cap_path, HD_VIDEOCAP_PARAM_OUT, &video_out_param);
|
|
//printf("set_cap_param OUT=%d\r\n", ret);
|
|
}
|
|
|
|
{
|
|
UINT32 data_lane = 0;
|
|
System_GetSensorInfo(0, SENSOR_DATA_LANE, &data_lane);
|
|
if (data_lane) {
|
|
if ((ret = vendor_videocap_set(video_cap_path, VENDOR_VIDEOCAP_PARAM_DATA_LANE, &data_lane)) != HD_OK) {
|
|
DBG_ERR("set VENDOR_VIDEOCAP_PARAM_DATA_LANE fail(%d)\r\n", ret);
|
|
}
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
static HD_RESULT set_proc_cfg(HD_PATH_ID *p_video_proc_ctrl, HD_DIM* p_max_dim)
|
|
{
|
|
HD_RESULT ret = HD_OK;
|
|
HD_VIDEOPROC_DEV_CONFIG video_cfg_param = {0};
|
|
HD_PATH_ID video_proc_ctrl = 0;
|
|
HD_VIDEOPROC_CTRL video_ctrl_param = {0};
|
|
|
|
ret = hd_videoproc_open(0, HD_VIDEOPROC_0_CTRL, &video_proc_ctrl); //open this for device control
|
|
if (ret != HD_OK)
|
|
return ret;
|
|
|
|
if (p_max_dim != NULL ) {
|
|
video_cfg_param.pipe = HD_VIDEOPROC_PIPE_RAWALL;
|
|
video_cfg_param.isp_id = 0;
|
|
video_cfg_param.ctrl_max.func |=(HD_VIDEOPROC_FUNC_3DNR|HD_VIDEOPROC_FUNC_WDR|HD_VIDEOPROC_FUNC_COLORNR);
|
|
video_cfg_param.ctrl_max.func |=(HD_VIDEOPROC_FUNC_WDR|HD_VIDEOPROC_FUNC_COLORNR);
|
|
if (g_shdr_mode == 1) {
|
|
video_cfg_param.ctrl_max.func |= HD_VIDEOPROC_FUNC_SHDR;
|
|
}
|
|
video_cfg_param.in_max.func = 0;
|
|
video_cfg_param.in_max.dim.w = p_max_dim->w;
|
|
video_cfg_param.in_max.dim.h = p_max_dim->h;
|
|
if (g_shdr_mode == 1) {
|
|
video_cfg_param.in_max.pxlfmt = SHDR_CAP_OUT_FMT;
|
|
} else {
|
|
video_cfg_param.in_max.pxlfmt = CAP_OUT_FMT;
|
|
}
|
|
video_cfg_param.in_max.frc = HD_VIDEO_FRC_RATIO(1,1);
|
|
ret = hd_videoproc_set(video_proc_ctrl, HD_VIDEOPROC_PARAM_DEV_CONFIG, &video_cfg_param);
|
|
if (ret != HD_OK) {
|
|
return HD_ERR_NG;
|
|
}
|
|
}
|
|
|
|
#if 1
|
|
video_ctrl_param.func = HD_VIDEOPROC_FUNC_3DNR;
|
|
video_ctrl_param.ref_path_3dnr = HD_VIDEOPROC_OUT(0, 0);
|
|
ret = hd_videoproc_set(video_proc_ctrl, HD_VIDEOPROC_PARAM_CTRL, &video_ctrl_param);
|
|
#endif
|
|
video_ctrl_param.func |= (HD_VIDEOPROC_FUNC_WDR|HD_VIDEOPROC_FUNC_COLORNR);
|
|
ret = hd_videoproc_set(video_proc_ctrl, HD_VIDEOPROC_PARAM_CTRL, &video_ctrl_param);
|
|
|
|
if (g_shdr_mode == 1) {
|
|
video_ctrl_param.func |= HD_VIDEOPROC_FUNC_SHDR;
|
|
ret = hd_videoproc_set(video_proc_ctrl, HD_VIDEOPROC_PARAM_CTRL, &video_ctrl_param);
|
|
if (ret != HD_OK) {
|
|
return HD_ERR_NG;
|
|
}
|
|
}
|
|
|
|
*p_video_proc_ctrl = video_proc_ctrl;
|
|
|
|
return ret;
|
|
}
|
|
|
|
static HD_RESULT set_proc_param(HD_PATH_ID video_proc_path, HD_DIM* p_dim)
|
|
{
|
|
HD_RESULT ret = HD_OK;
|
|
|
|
if (p_dim != NULL) { //if videoproc is already binding to dest module, not require to setting this!
|
|
HD_VIDEOPROC_OUT video_out_param = {0};
|
|
video_out_param.func = 0;
|
|
video_out_param.dim.w = p_dim->w;
|
|
video_out_param.dim.h = p_dim->h;
|
|
video_out_param.pxlfmt = HD_VIDEO_PXLFMT_YUV420;
|
|
video_out_param.dir = HD_VIDEO_DIR_NONE;
|
|
video_out_param.frc = HD_VIDEO_FRC_RATIO(1,1);
|
|
video_out_param.depth = 1; //set 1 to allow pull
|
|
ret = hd_videoproc_set(video_proc_path, HD_VIDEOPROC_PARAM_OUT, &video_out_param);
|
|
}
|
|
|
|
#if HUNTING_PHOTO_FAST_AE_60_FPS == ENABLE
|
|
{
|
|
HD_VIDEOPROC_IN video_in_param = {0};
|
|
video_in_param.func = 0;
|
|
video_in_param.dim.w = p_dim->w;
|
|
video_in_param.dim.h = p_dim->h;
|
|
video_in_param.pxlfmt = HD_VIDEO_PXLFMT_RAW12;
|
|
video_in_param.dir = HD_VIDEO_DIR_NONE;
|
|
video_in_param.frc = HD_VIDEO_FRC_RATIO(1, 1);
|
|
ret = hd_videoproc_set(video_proc_path, HD_VIDEOPROC_PARAM_IN, &video_in_param);
|
|
}
|
|
#endif
|
|
|
|
return ret;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
#if (_PACKAGE_DISPLAY_)
|
|
static HD_RESULT set_out_cfg(HD_PATH_ID *p_video_out_ctrl, UINT32 out_type,HD_VIDEOOUT_HDMI_ID hdmi_id)
|
|
{
|
|
HD_RESULT ret = HD_OK;
|
|
HD_VIDEOOUT_MODE videoout_mode = {0};
|
|
HD_PATH_ID video_out_ctrl = 0;
|
|
|
|
ret = hd_videoout_open(0, HD_VIDEOOUT_0_CTRL, &video_out_ctrl); //open this for device control
|
|
if (ret != HD_OK) {
|
|
return ret;
|
|
}
|
|
|
|
printf("out_type=%d\r\n", (int)out_type);
|
|
|
|
#if 1
|
|
videoout_mode.output_type = HD_COMMON_VIDEO_OUT_LCD;
|
|
videoout_mode.input_dim = HD_VIDEOOUT_IN_AUTO;
|
|
videoout_mode.output_mode.lcd = HD_VIDEOOUT_LCD_0;
|
|
if (out_type != 1) {
|
|
printf("520 only support LCD\r\n");
|
|
}
|
|
#else
|
|
switch(out_type){
|
|
case 0:
|
|
videoout_mode.output_type = HD_COMMON_VIDEO_OUT_CVBS;
|
|
videoout_mode.input_dim = HD_VIDEOOUT_IN_AUTO;
|
|
videoout_mode.output_mode.cvbs= HD_VIDEOOUT_CVBS_NTSC;
|
|
break;
|
|
case 1:
|
|
videoout_mode.output_type = HD_COMMON_VIDEO_OUT_LCD;
|
|
videoout_mode.input_dim = HD_VIDEOOUT_IN_AUTO;
|
|
videoout_mode.output_mode.lcd = HD_VIDEOOUT_LCD_0;
|
|
break;
|
|
case 2:
|
|
videoout_mode.output_type = HD_COMMON_VIDEO_OUT_HDMI;
|
|
videoout_mode.input_dim = HD_VIDEOOUT_IN_AUTO;
|
|
videoout_mode.output_mode.hdmi= hdmi_id;
|
|
break;
|
|
default:
|
|
printf("not support out_type\r\n");
|
|
break;
|
|
}
|
|
#endif
|
|
ret = hd_videoout_set(video_out_ctrl, HD_VIDEOOUT_PARAM_MODE, &videoout_mode);
|
|
|
|
*p_video_out_ctrl=video_out_ctrl ;
|
|
return ret;
|
|
}
|
|
|
|
static HD_RESULT get_out_caps(HD_PATH_ID video_out_ctrl,HD_VIDEOOUT_SYSCAPS *p_video_out_syscaps)
|
|
{
|
|
HD_RESULT ret = HD_OK;
|
|
HD_DEVCOUNT video_out_dev = {0};
|
|
|
|
ret = hd_videoout_get(video_out_ctrl, HD_VIDEOOUT_PARAM_DEVCOUNT, &video_out_dev);
|
|
if (ret != HD_OK) {
|
|
return ret;
|
|
}
|
|
printf("##devcount %d\r\n", (int)video_out_dev.max_dev_count);
|
|
|
|
ret = hd_videoout_get(video_out_ctrl, HD_VIDEOOUT_PARAM_SYSCAPS, p_video_out_syscaps);
|
|
if (ret != HD_OK) {
|
|
return ret;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static HD_RESULT set_out_param(HD_PATH_ID video_out_path, HD_DIM *p_dim)
|
|
{
|
|
HD_RESULT ret = HD_OK;
|
|
HD_VIDEOOUT_IN video_out_param={0};
|
|
|
|
video_out_param.dim.w = p_dim->w;
|
|
video_out_param.dim.h = p_dim->h;
|
|
video_out_param.pxlfmt = HD_VIDEO_PXLFMT_YUV420;
|
|
video_out_param.dir = HD_VIDEO_DIR_NONE;
|
|
ret = hd_videoout_set(video_out_path, HD_VIDEOOUT_PARAM_IN, &video_out_param);
|
|
if (ret != HD_OK) {
|
|
return ret;
|
|
}
|
|
memset((void *)&video_out_param,0,sizeof(HD_VIDEOOUT_IN));
|
|
ret = hd_videoout_get(video_out_path, HD_VIDEOOUT_PARAM_IN, &video_out_param);
|
|
if (ret != HD_OK) {
|
|
return ret;
|
|
}
|
|
printf("##video_out_param w:%d,h:%d %x %x\r\n", (int)video_out_param.dim.w, (int)video_out_param.dim.h, (int)video_out_param.pxlfmt, (int)video_out_param.dir);
|
|
|
|
return ret;
|
|
}
|
|
#endif
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
typedef struct _VIDEO_LIVEVIEW {
|
|
|
|
// (1)
|
|
HD_VIDEOCAP_SYSCAPS cap_syscaps;
|
|
HD_PATH_ID cap_ctrl;
|
|
HD_PATH_ID cap_path;
|
|
|
|
HD_DIM cap_dim;
|
|
HD_DIM proc_max_dim;
|
|
HD_DIM proc_dim;
|
|
|
|
// (2)
|
|
HD_VIDEOPROC_SYSCAPS proc_syscaps;
|
|
HD_PATH_ID proc_ctrl;
|
|
HD_PATH_ID proc_path;
|
|
|
|
HD_DIM out_max_dim;
|
|
HD_DIM out_dim;
|
|
|
|
// (3)
|
|
HD_VIDEOOUT_SYSCAPS out_syscaps;
|
|
HD_PATH_ID out_ctrl;
|
|
HD_PATH_ID out_path;
|
|
|
|
HD_VIDEOOUT_HDMI_ID hdmi_id;
|
|
} VIDEO_LIVEVIEW;
|
|
|
|
static VIDEO_LIVEVIEW stream[1] = {0}; //0: main stream
|
|
static UINT32 out_type = 1;
|
|
|
|
static void fast_open_sensor(void)
|
|
{
|
|
#if 0
|
|
VENDOR_VIDEOCAP_FAST_OPEN_SENSOR cap_cfg = {0};
|
|
|
|
snprintf(cap_cfg.sen_cfg.sen_dev.driver_name, HD_VIDEOCAP_SEN_NAME_LEN-1, SEN_DRVIVER_NAME);
|
|
cap_cfg.sen_cfg.sen_dev.if_type = SEN_IF_TYPE;
|
|
cap_cfg.sen_cfg.sen_dev.pin_cfg.pinmux.sensor_pinmux = SEN_PINMUX;
|
|
cap_cfg.sen_cfg.sen_dev.pin_cfg.pinmux.serial_if_pinmux = SERIAL_IF_PINMUX;
|
|
cap_cfg.sen_cfg.sen_dev.pin_cfg.pinmux.cmd_if_pinmux = CMD_IF_PINMUX;
|
|
cap_cfg.sen_cfg.sen_dev.pin_cfg.clk_lane_sel = CLK_LANE_SEL;
|
|
cap_cfg.sen_cfg.sen_dev.pin_cfg.sen_2_serial_pin_map[0] = PIN_MAP_0;
|
|
cap_cfg.sen_cfg.sen_dev.pin_cfg.sen_2_serial_pin_map[1] = PIN_MAP_1;
|
|
cap_cfg.sen_cfg.sen_dev.pin_cfg.sen_2_serial_pin_map[2] = PIN_MAP_2;
|
|
cap_cfg.sen_cfg.sen_dev.pin_cfg.sen_2_serial_pin_map[3] = PIN_MAP_3;
|
|
cap_cfg.sen_cfg.sen_dev.pin_cfg.sen_2_serial_pin_map[4] = PIN_MAP_4;
|
|
cap_cfg.sen_cfg.sen_dev.pin_cfg.sen_2_serial_pin_map[5] = PIN_MAP_5;
|
|
cap_cfg.sen_cfg.sen_dev.pin_cfg.sen_2_serial_pin_map[6] = PIN_MAP_6;
|
|
cap_cfg.sen_cfg.sen_dev.pin_cfg.sen_2_serial_pin_map[7] = PIN_MAP_7;
|
|
cap_cfg.sen_mode = 0;
|
|
cap_cfg.frc = HD_VIDEO_FRC_RATIO(30,1);
|
|
#if (AE_PRESET_FUNC == ENABLE)
|
|
cap_cfg.ae_preset.enable = TRUE;
|
|
get_ae_preset(&cap_cfg.ae_preset.exp_time, &cap_cfg.ae_preset.gain_ratio);
|
|
#endif
|
|
vendor_videocap_set(0, VENDOR_VIDEOCAP_PARAM_FAST_OPEN_SENSOR, &cap_cfg);
|
|
#endif
|
|
}
|
|
|
|
static HD_RESULT init_module_cap_proc(void)
|
|
{
|
|
HD_RESULT ret;
|
|
if ((ret = hd_videocap_init()) != HD_OK)
|
|
return ret;
|
|
if ((ret = hd_videoproc_init()) != HD_OK)
|
|
return ret;
|
|
return HD_OK;
|
|
}
|
|
|
|
#if (_PACKAGE_DISPLAY_)
|
|
static HD_RESULT init_module_videoout(void)
|
|
{
|
|
HD_RESULT ret;
|
|
if ((ret = hd_videoout_init()) != HD_OK) {
|
|
printf("failed to hd_videoout_init:%d\n", ret);
|
|
return ret;
|
|
}
|
|
return HD_OK;
|
|
}
|
|
#endif
|
|
|
|
static HD_RESULT open_module_cap_proc(VIDEO_LIVEVIEW *p_stream, HD_DIM* p_proc_max_dim, UINT32 out_type)
|
|
{
|
|
HD_RESULT ret;
|
|
// set videocap config
|
|
ret = set_cap_cfg(&p_stream->cap_ctrl);
|
|
if (ret != HD_OK) {
|
|
printf("set cap-cfg fail=%d\n", ret);
|
|
return HD_ERR_NG;
|
|
}
|
|
// set videoproc config
|
|
ret = set_proc_cfg(&p_stream->proc_ctrl, p_proc_max_dim);
|
|
if (ret != HD_OK) {
|
|
printf("set proc-cfg fail=%d\n", ret);
|
|
return HD_ERR_NG;
|
|
}
|
|
if ((ret = hd_videocap_open(HD_VIDEOCAP_0_IN_0, HD_VIDEOCAP_0_OUT_0, &p_stream->cap_path)) != HD_OK)
|
|
return ret;
|
|
|
|
if ((ret = hd_videoproc_open(HD_VIDEOPROC_0_IN_0, HD_VIDEOPROC_0_OUT_0, &p_stream->proc_path)) != HD_OK)
|
|
return ret;
|
|
|
|
return HD_OK;
|
|
}
|
|
|
|
#if (_PACKAGE_DISPLAY_)
|
|
static HD_RESULT open_module_videoout(VIDEO_LIVEVIEW *p_stream, HD_DIM* p_proc_max_dim, UINT32 out_type)
|
|
{
|
|
HD_RESULT ret;
|
|
// set videoout config
|
|
ret = set_out_cfg(&p_stream->out_ctrl, out_type,p_stream->hdmi_id);
|
|
if (ret != HD_OK) {
|
|
printf("set out-cfg fail=%d\n", ret);
|
|
return HD_ERR_NG;
|
|
}
|
|
|
|
if ((ret = hd_videoout_open(HD_VIDEOOUT_0_IN_0, HD_VIDEOOUT_0_OUT_0, &p_stream->out_path)) != HD_OK)
|
|
return ret;
|
|
|
|
return HD_OK;
|
|
}
|
|
#endif
|
|
|
|
static THREAD_RETTYPE thread_sensor(void *ptr)
|
|
{
|
|
fastboot_wait_done(BOOT_INIT_SENSOR);
|
|
// vos_perf_list_mark("ss", __LINE__, 0);
|
|
//quick sensor setup flow
|
|
fast_open_sensor();
|
|
// vos_perf_list_mark("ss", __LINE__, 1);
|
|
|
|
vos_flag_set(flag_task, FLAG_SENSOR_TASK_EXIT);
|
|
THREAD_RETURN(0);
|
|
}
|
|
|
|
static THREAD_RETTYPE thread_cap_proc(void *ptr)
|
|
{
|
|
HD_RESULT ret;
|
|
UIAPP_PHOTO_SENSOR_INFO *pSensorInfo = UIAppPhoto_get_SensorInfo(0);
|
|
ISPT_TOTAL_GAIN total_gain = {0};
|
|
|
|
// wait sensor setup ready
|
|
#if 0
|
|
int join_ret;
|
|
pthread_t *p_handle_sensor = (pthread_t *)ptr;
|
|
int pthread_ret = pthread_join(*p_handle_sensor, (void *)&join_ret);
|
|
if (0 != pthread_ret) {
|
|
printf("thread_sensor pthread_join failed, ret %d\r\n", pthread_ret);
|
|
pthread_exit((void *)-1);
|
|
return NULL;
|
|
}
|
|
#endif
|
|
|
|
// wait driver init ready
|
|
fastboot_wait_done(BOOT_INIT_CAPTURE);
|
|
vos_perf_list_mark("capproc", __LINE__, 0);
|
|
|
|
stream[0].hdmi_id=HD_VIDEOOUT_HDMI_1920X1080I60;//default
|
|
|
|
// init capture, proc
|
|
ret = init_module_cap_proc();
|
|
if (ret != HD_OK) {
|
|
DBG_ERR("init fail=%d\n", ret);
|
|
goto exit;
|
|
}
|
|
|
|
// open capture, proc
|
|
stream[0].proc_max_dim.w = pSensorInfo->sSize.w; //assign by user
|
|
stream[0].proc_max_dim.h = pSensorInfo->sSize.h; //assign by user
|
|
ret = open_module_cap_proc(&stream[0], &stream[0].proc_max_dim, out_type);
|
|
if (ret != HD_OK) {
|
|
DBG_ERR("open fail=%d\n", ret);
|
|
goto exit;
|
|
}
|
|
|
|
// set videocap parameter
|
|
stream[0].cap_dim.w = pSensorInfo->sSize.w; //assign by user
|
|
stream[0].cap_dim.h = pSensorInfo->sSize.h; //assign by user
|
|
ret = set_cap_param(stream[0].cap_path, &stream[0].cap_dim);
|
|
if (ret != HD_OK) {
|
|
DBG_ERR("set cap fail=%d\n", ret);
|
|
goto exit;
|
|
}
|
|
|
|
// set videoproc parameter (main)
|
|
#if 0
|
|
stream[0].proc_dim.w = LCD_SIZE_W;
|
|
stream[0].proc_dim.h = LCD_SIZE_H;
|
|
#else
|
|
stream[0].proc_dim.w = pSensorInfo->sSize.w;
|
|
stream[0].proc_dim.h = pSensorInfo->sSize.h;
|
|
#endif
|
|
ret = set_proc_param(stream[0].proc_path, &stream[0].proc_dim);
|
|
if (ret != HD_OK) {
|
|
DBG_ERR("set proc fail=%d\n", ret);
|
|
goto exit;
|
|
}
|
|
|
|
// bind video_liveview modules (main)
|
|
#if HUNTING_PHOTO_FAST_AE_60_FPS == ENABLE
|
|
#else
|
|
hd_videocap_bind(HD_VIDEOCAP_0_OUT_0, HD_VIDEOPROC_0_IN_0);
|
|
#endif
|
|
|
|
// start video_liveview modules (main)
|
|
hd_videocap_start(stream[0].cap_path);
|
|
vos_perf_list_mark("capproc", __LINE__, 1);
|
|
|
|
hd_videoproc_start(stream[0].proc_path);
|
|
|
|
total_gain.id = 0;
|
|
total_gain.gain = preset_param.gain/10;
|
|
vendor_isp_set_common(ISPT_ITEM_TOTAL_GAIN, &total_gain);
|
|
|
|
#if 0
|
|
// get first frame
|
|
HD_VIDEO_FRAME video_frame = {0};
|
|
hd_videoproc_pull_out_buf(stream[0].proc_path, &video_frame, -1);
|
|
hd_videoproc_release_out_buf(stream[0].proc_path, &video_frame);
|
|
#endif
|
|
|
|
vos_perf_list_mark("capproc", __LINE__, 2);
|
|
exit:
|
|
vos_flag_set(flag_task, FLAG_CAP_PROC_TASK_EXIT);
|
|
THREAD_RETURN(0);
|
|
}
|
|
|
|
#if (_PACKAGE_DISPLAY_)
|
|
static THREAD_RETTYPE thread_videoout(void *ptr)
|
|
{
|
|
HD_RESULT ret;
|
|
UIAPP_PHOTO_SENSOR_INFO *pSensorInfo = UIAppPhoto_get_SensorInfo(0);
|
|
|
|
fastboot_wait_done(BOOT_INIT_DISPLAY);
|
|
vos_perf_list_mark("disp", __LINE__, 0);
|
|
|
|
// init videoout
|
|
ret = init_module_videoout();
|
|
if (ret != HD_OK) {
|
|
DBG_ERR("init fail=%d\n", ret);
|
|
goto exit;
|
|
}
|
|
|
|
// open capture, proc modules (main)
|
|
stream[0].proc_max_dim.w = pSensorInfo->sSize.w; //assign by user
|
|
stream[0].proc_max_dim.h = pSensorInfo->sSize.h; //assign by user
|
|
ret = open_module_videoout(&stream[0], &stream[0].proc_max_dim, out_type);
|
|
if (ret != HD_OK) {
|
|
DBG_ERR("open fail=%d\n", ret);
|
|
goto exit;
|
|
}
|
|
|
|
// get videoout capability
|
|
ret = get_out_caps(stream[0].out_ctrl, &stream[0].out_syscaps);
|
|
if (ret != HD_OK) {
|
|
DBG_ERR("get out-caps fail=%d\n", ret);
|
|
goto exit;
|
|
}
|
|
stream[0].out_max_dim = stream[0].out_syscaps.output_dim;
|
|
|
|
// set videoout parameter (main)
|
|
stream[0].out_dim.w = stream[0].out_max_dim.w; //using device max dim.w
|
|
stream[0].out_dim.h = stream[0].out_max_dim.h; //using device max dim.h
|
|
ret = set_out_param(stream[0].out_path, &stream[0].out_dim);
|
|
if (ret != HD_OK) {
|
|
DBG_ERR("set out fail=%d\n", ret);
|
|
goto exit;
|
|
}
|
|
|
|
if (hd_videoout_start(stream[0].out_path) != HD_OK) {
|
|
DBG_ERR("hd_videoout_start fail\n");
|
|
goto exit;
|
|
}
|
|
|
|
vos_perf_list_mark("disp", __LINE__, 1);
|
|
|
|
exit:
|
|
vos_flag_set(flag_task, FLAG_VOUT_TASK_EXIT);
|
|
THREAD_RETURN(0);
|
|
}
|
|
#endif
|
|
|
|
void flow_preview_get_path(HD_PATH_ID *pPath, FLOW_PREIVEW_PATH PathType, UINT32 id)
|
|
{
|
|
switch (PathType) {
|
|
case FLOW_PREIVEW_VCAP_PATH:
|
|
*pPath = stream[0].cap_path;
|
|
break;
|
|
|
|
case FLOW_PREIVEW_VPRC_PATH:
|
|
*pPath = stream[0].proc_path;
|
|
break;
|
|
|
|
case FLOW_PREIVEW_VOUT_PATH:
|
|
*pPath = stream[0].out_path;
|
|
break;
|
|
|
|
case FLOW_PREIVEW_VENC_PATH:
|
|
break;
|
|
|
|
default:
|
|
DBG_ERR("No path type is selected\r\n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
extern void Set_NIGHTMODE(UINT32 id, UINT8 isSnapVideo);
|
|
extern void DrvGOIO_Turn_Onoff_IRCUT(UINT8 onoff);
|
|
|
|
INT32 flow_preview_load_sen_cfg(void)
|
|
{
|
|
INT32 ret = E_OK;
|
|
HD_RESULT hd_ret = HD_OK;
|
|
PHOTO_SENSOR_INFO sen_cfg = {0};
|
|
PHOTO_SENSOR_INFO *pSenCfg = &sen_cfg;
|
|
//load ae/awb/iq
|
|
System_GetSensorInfo(0, SENSOR_AE_PATH, &(sen_cfg.ae_path));
|
|
System_GetSensorInfo(0, SENSOR_AWB_PATH, &(sen_cfg.awb_path));
|
|
System_GetSensorInfo(0, SENSOR_IQ_PATH, &(sen_cfg.iq_path));
|
|
System_GetSensorInfo(0, SENSOR_IQ_SHADING_PATH, &(sen_cfg.iq_shading_path));
|
|
System_GetSensorInfo(0, SENSOR_IQ_DPC_PATH, &(sen_cfg.iq_dpc_path));
|
|
System_GetSensorInfo(0, SENSOR_IQ_LDC_PATH, &(sen_cfg.iq_ldc_path));
|
|
|
|
if ((hd_ret = vendor_isp_init()) != HD_OK) {
|
|
DBG_ERR("vendor_isp_init fail(%d)\n", hd_ret);
|
|
}
|
|
|
|
if (strlen(pSenCfg->ae_path.path) != 0) {
|
|
AET_DTSI_INFO ae_dtsi_info;
|
|
ae_dtsi_info.id = pSenCfg->ae_path.id;
|
|
strncpy(ae_dtsi_info.node_path, pSenCfg->ae_path.path, 31);
|
|
strncpy(ae_dtsi_info.file_path, "null", DTSI_NAME_LENGTH);
|
|
ae_dtsi_info.buf_addr = (UINT8 *)pSenCfg->ae_path.addr;
|
|
if ((hd_ret = vendor_isp_set_ae(AET_ITEM_RLD_DTSI, &ae_dtsi_info)) != HD_OK) {
|
|
DBG_ERR("vendor_isp_set_ae fail(%d)\r\n", hd_ret);
|
|
}
|
|
}
|
|
if (strlen(pSenCfg->awb_path.path) != 0) {
|
|
AWBT_DTSI_INFO awb_dtsi_info;
|
|
awb_dtsi_info.id = pSenCfg->awb_path.id;
|
|
strncpy(awb_dtsi_info.node_path, pSenCfg->awb_path.path, 31);
|
|
strncpy(awb_dtsi_info.file_path, "null", DTSI_NAME_LENGTH);
|
|
awb_dtsi_info.buf_addr = (UINT8 *)pSenCfg->awb_path.addr;
|
|
if ((hd_ret = vendor_isp_set_awb(AWBT_ITEM_RLD_DTSI, &awb_dtsi_info)) != HD_OK) {
|
|
DBG_ERR("vendor_isp_set_awb fail(%d)\r\n", hd_ret);
|
|
}
|
|
}
|
|
if (strlen(pSenCfg->iq_path.path) != 0) {
|
|
IQT_DTSI_INFO iq_dtsi_info;
|
|
iq_dtsi_info.id = pSenCfg->iq_path.id;
|
|
//printf("[%s:%d]s\n",__FUNCTION__,__LINE__);
|
|
if(sf_is_night_mode(1) ==TRUE)
|
|
strncpy(iq_dtsi_info.node_path, "/isp/iq/os05b10_iq_0", 31);
|
|
else
|
|
strncpy(iq_dtsi_info.node_path, "/isp/iq/os05b10_iq_0_cap", 31);
|
|
//printf("[%s:%d]s\n",__FUNCTION__,__LINE__);
|
|
//vos_perf_list_mark("sie_vd", __LINE__, 1);
|
|
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 (strlen(pSenCfg->iq_shading_path.path) != 0) {
|
|
IQT_DTSI_INFO iq_dtsi_info;
|
|
iq_dtsi_info.id = pSenCfg->iq_shading_path.id;
|
|
strncpy(iq_dtsi_info.node_path, pSenCfg->iq_shading_path.path, 31);
|
|
strncpy(iq_dtsi_info.file_path, "null", DTSI_NAME_LENGTH);
|
|
iq_dtsi_info.buf_addr = (UINT8 *)pSenCfg->iq_shading_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);
|
|
ret = E_SYS;
|
|
}
|
|
}
|
|
if (strlen(pSenCfg->iq_dpc_path.path) != 0) {
|
|
IQT_DTSI_INFO iq_dtsi_info;
|
|
iq_dtsi_info.id = pSenCfg->iq_dpc_path.id;
|
|
strncpy(iq_dtsi_info.node_path, pSenCfg->iq_dpc_path.path, 31);
|
|
strncpy(iq_dtsi_info.file_path, "null", DTSI_NAME_LENGTH);
|
|
iq_dtsi_info.buf_addr = (UINT8 *)pSenCfg->iq_dpc_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);
|
|
ret = E_SYS;
|
|
}
|
|
}
|
|
if (strlen(pSenCfg->iq_ldc_path.path) != 0) {
|
|
IQT_DTSI_INFO iq_dtsi_info;
|
|
iq_dtsi_info.id = pSenCfg->iq_ldc_path.id;
|
|
strncpy(iq_dtsi_info.node_path, pSenCfg->iq_ldc_path.path, 31);
|
|
strncpy(iq_dtsi_info.file_path, "null", DTSI_NAME_LENGTH);
|
|
iq_dtsi_info.buf_addr = (UINT8 *)pSenCfg->iq_ldc_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);
|
|
ret = E_SYS;
|
|
}
|
|
}
|
|
|
|
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){
|
|
DBG_ERR("create thread_cap_proc failed\r\n");
|
|
return -1;
|
|
}
|
|
else
|
|
vos_task_resume(handle_cap_proc);
|
|
Set_NIGHTMODE(0, 0);
|
|
|
|
#if (_PACKAGE_DISPLAY_)
|
|
vos_flag_clr(flag_task, FLAG_VOUT_TASK_EXIT);
|
|
handle_videoout = vos_task_create(thread_videoout, NULL, "vout", 9, DEFAULT_TASK_STACK_SIZE);
|
|
if(!handle_videoout){
|
|
DBG_ERR("create thread_videoout failed\r\n");
|
|
return -1;
|
|
}
|
|
else
|
|
vos_task_resume(handle_videoout);
|
|
#endif
|
|
vos_flag_wait(&flag_ptn, flag_task, FLAG_CAP_PROC_TASK_EXIT, (TWF_ORW | TWF_CLR));
|
|
vos_task_destroy(handle_cap_proc);
|
|
#if (_PACKAGE_DISPLAY_)
|
|
vos_flag_wait(&flag_ptn, flag_task, FLAG_VOUT_TASK_EXIT, (TWF_ORW | TWF_CLR));
|
|
vos_task_destroy(handle_videoout);
|
|
#endif
|
|
// DrvGOIO_Turn_Onoff_IRCUT(0);
|
|
// start video_preview
|
|
|
|
// nvt_cmdsys_runcmd("nvtmpp info");
|
|
|
|
vos_flag_clr(flag_task, FLAG_FLOW_PREVIEW_TASK_EXIT);
|
|
handle_preview = vos_task_create(PhotoFast_FlowPreviewThread, NULL, "flow_preview", 10, FLOW_PREVIEW_TASK_STACK_SIZE);
|
|
if(!handle_preview){
|
|
DBG_ERR("create thread_preview failed\r\n");
|
|
return -1;
|
|
}
|
|
else
|
|
vos_task_resume(handle_preview);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void flow_preview_close_module(void)
|
|
{
|
|
HD_RESULT hd_ret;
|
|
|
|
if(stream[0].cap_path){
|
|
hd_ret = hd_videocap_stop(stream[0].cap_path);
|
|
if (hd_ret != HD_OK) {
|
|
DBG_ERR("vcap stop failed, hd_ret = %d\r\n", hd_ret);
|
|
}
|
|
}
|
|
|
|
if(stream[0].proc_path){
|
|
hd_ret = hd_videoproc_stop(stream[0].proc_path);
|
|
if (hd_ret != HD_OK) {
|
|
DBG_ERR("vprc stop failed, hd_ret = %d\r\n", hd_ret);
|
|
}
|
|
}
|
|
|
|
if(stream[0].cap_path){
|
|
hd_ret = hd_videocap_close(stream[0].cap_path);
|
|
if (hd_ret != HD_OK) {
|
|
DBG_ERR("vcap close failed, hd_ret = %d\r\n", hd_ret);
|
|
}
|
|
}
|
|
|
|
if(stream[0].proc_path){
|
|
hd_ret = hd_videoproc_close(stream[0].proc_path);
|
|
if (hd_ret != HD_OK) {
|
|
DBG_ERR("vprc close failed, hd_ret = %d\r\n", hd_ret);
|
|
}
|
|
}
|
|
|
|
#if HUNTING_PHOTO_FAST_AE_60_FPS == ENABLE
|
|
|
|
#else
|
|
if(stream[0].cap_path){
|
|
hd_ret = hd_videocap_unbind(HD_VIDEOCAP_0_OUT_0);
|
|
if (hd_ret != HD_OK) {
|
|
DBG_ERR("vcap unbind failed, hd_ret = %d\r\n", hd_ret);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
void flow_preview_uninit_module(void)
|
|
{
|
|
HD_RESULT hd_ret;
|
|
|
|
hd_ret = hd_videocap_uninit();
|
|
if (hd_ret != HD_OK) {
|
|
DBG_ERR("vcap uninit failed, hd_ret = %d\r\n", hd_ret);
|
|
}
|
|
|
|
hd_ret = hd_videoproc_uninit();
|
|
if (hd_ret != HD_OK) {
|
|
DBG_ERR("vprc uninit failed, hd_ret = %d\r\n", hd_ret);
|
|
}
|
|
}
|
|
|
|
#if 1 //for pre set ae
|
|
static UINT32 ae_adc_tbl[57][3] = {
|
|
#if 0 //for S530 200K RSS photodie OK
|
|
{980, 44, 1000},
|
|
{970, 73, 1000},
|
|
{960, 88, 1000},
|
|
{945, 99, 1130},
|
|
{930, 103, 1000},
|
|
{910, 126, 1070},
|
|
{900, 203, 1020},
|
|
{885, 267, 1000},
|
|
{870, 320, 1010},
|
|
{859, 468, 1000},// 524
|
|
{854, 826, 1000},
|
|
{849, 1128, 1000},
|
|
{845, 1372, 1000},
|
|
{842, 2236, 1000},
|
|
{839, 3459, 1000},
|
|
{830, 2236, 1000},
|
|
{828, 3459, 1000},
|
|
{824, 5213, 1000},
|
|
{822, 7232, 1000},
|
|
{813, 8333, 1280},
|
|
{809, 8333, 2380},
|
|
{799, 16666, 4300},
|
|
{787, 16666, 6390},
|
|
{735, 16666, 7990},
|
|
{686, 16666, 8460},
|
|
{652, 16666, 9530},
|
|
{613, 16666, 10690},
|
|
{576, 16666, 2310},//night
|
|
{541, 16666, 2310},
|
|
{509, 16666, 2310},
|
|
{480, 16666, 2310},
|
|
{458, 16666, 2310},
|
|
{421, 16666, 2310},
|
|
{399, 16666, 4000},
|
|
{363, 16666, 6000},
|
|
{322, 16666, 8000},// 12190},
|
|
{288, 16666, 10000},// 26600},
|
|
{246, 16666, 14000}, //45770},
|
|
{216, 16666, 14000},
|
|
{188, 16666, 16000},
|
|
{162, 16666, 16000},
|
|
{151, 16666, 16000},
|
|
{138, 16666, 16000},
|
|
{118, 16666, 16000},
|
|
{96, 16666, 16000},
|
|
{80, 16666, 16000},
|
|
{62, 16666, 16000},
|
|
{48, 16666, 16000},
|
|
{35, 16666, 16000},
|
|
{26, 16666, 16000},
|
|
{19, 16666, 16000},
|
|
{13, 16666, 16000},
|
|
{10, 16666, 16000},
|
|
{8, 16666, 16000},
|
|
{4, 16666, 16000},
|
|
{2, 16666, 16000},
|
|
//{1, 33333, 3500},
|
|
{0, 16666, 16000},
|
|
|
|
#else // 100K RSS new phototransistor
|
|
{710, 44, 1000},
|
|
{708, 73, 1000},
|
|
{707, 77, 1000},
|
|
{705, 80, 1130},
|
|
{704, 80, 1130},
|
|
{703, 87, 1000},
|
|
{702, 87, 1070},
|
|
{701, 99, 1070},
|
|
{700, 99, 1010},
|
|
{699, 103, 1020},
|
|
{698, 126, 1000},
|
|
{697, 203, 1000},// 524
|
|
{696, 267, 1000},
|
|
{695, 333, 1000},
|
|
{694, 423, 1000},
|
|
{693, 539, 1000},
|
|
{691, 806, 1000}, //sun chen@20240111 start
|
|
{689, 1082, 1000},
|
|
{687, 2580, 1000},//4038
|
|
{684, 3929, 1000},//5755, 2150},
|
|
{681, 4733, 1000},//6187, 2550},
|
|
{679, 5016, 1000},//sun chen@20240111 end
|
|
{669, 8333, 1000},
|
|
{645, 8333, 1000},
|
|
{617, 8333, 1000},
|
|
{591, 16666, 1000},
|
|
{566, 16666, 1000},
|
|
{546, 16666, 2050},
|
|
{526, 16666, 2270},
|
|
{507, 16666, 2310},
|
|
{488, 16666, 2350},//night
|
|
{468, 16666, 2510},
|
|
{446, 16666, 2720},
|
|
{422, 16666, 2890},
|
|
{399, 16666, 3000},
|
|
{376, 16666, 2050},
|
|
{353, 16666, 1130},
|
|
{330, 16666, 1130},
|
|
{308, 16666, 2050},// 12190},
|
|
{286, 16666, 3000},// 26600},
|
|
{264, 16666, 4500}, //45770},
|
|
{242, 16666, 4740},
|
|
{220, 16666, 5100},
|
|
{161, 16666, 6860},
|
|
{142, 16666, 6860},
|
|
{126, 16666, 1000},
|
|
{113, 16666, 1000},
|
|
{96, 16666, 1000},
|
|
{80, 16666, 1000},
|
|
{62, 16666, 8000},
|
|
{48, 16666, 8000},
|
|
{35, 16666, 8000},
|
|
{26, 16666, 8000},
|
|
{19, 16666, 8000},
|
|
{13, 16666, 8000},
|
|
{10, 16666, 8000},
|
|
{8, 16666, 8000},
|
|
#endif
|
|
};
|
|
|
|
|
|
void ae_adc_get_exp_photo(UINT16 adc_value, UINT32 *exptime, UINT32 *isogain)
|
|
{
|
|
UINT32 idx0=0, idx1=0;
|
|
UINT32 exptime0, exptime1, isogain0, isogain1;
|
|
UINT32 adc_ev, ev0, ev1;
|
|
|
|
for(idx1=1; idx1<56; idx1++) {
|
|
//if(adc_value > ae_adc_tbl[idx1][0])
|
|
if(adc_value>=ae_adc_tbl[idx1][0])
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
if(adc_value>ae_adc_tbl[0][0]) {
|
|
*exptime = ae_adc_tbl[0][1];
|
|
*isogain = ae_adc_tbl[0][2];
|
|
}
|
|
else {
|
|
idx0 = idx1-1;
|
|
|
|
exptime0 = ae_adc_tbl[idx0][1];
|
|
isogain0 = (ae_adc_tbl[idx0][2]);
|
|
exptime1 = ae_adc_tbl[idx1][1];
|
|
isogain1 = (ae_adc_tbl[idx1][2]);
|
|
ev0 = (exptime0 * isogain0);
|
|
ev1 = (exptime1 * isogain1);
|
|
|
|
//adc_ev = ((ev1 - ev0) * (ae_adc_tbl[idx1][0]-adc_value))/(ae_adc_tbl[idx1][0]-ae_adc_tbl[idx0][0]) + ev0;
|
|
adc_ev = ((ev1 - ev0) * (adc_value - ae_adc_tbl[idx1][0]))/(ae_adc_tbl[idx0][0] - ae_adc_tbl[idx1][0]) + ev0;
|
|
|
|
//if(adc_value>35)// 200 for old phototransistor
|
|
if(1)
|
|
{
|
|
*exptime = exptime0;
|
|
*isogain = (adc_ev / exptime0);
|
|
}else{
|
|
*exptime = 16666;
|
|
#if HUNTING_IR_LED_940 == ENABLE
|
|
*isogain = 16000;
|
|
#else
|
|
*isogain = 7000;
|
|
#endif
|
|
|
|
}
|
|
}
|
|
DBG_WRN("idx = %d, %d, adc = %d, fast open preset exp = %d, %d\r\n", idx0, idx1, adc_value, *exptime, *isogain);
|
|
}
|
|
|
|
|
|
UINT32 ae_preset_exp,ae_preset_iso;
|
|
|
|
void get_preset_param(void)
|
|
{
|
|
static BOOL get_preset_flag=FALSE;
|
|
UINT32 adc_expt, adc_gain;
|
|
|
|
if(get_preset_flag==FALSE)
|
|
{
|
|
ae_adc_get_exp_photo(IRSHTTER, &adc_expt, &adc_gain);
|
|
preset_param.expt= ae_preset_exp = adc_expt;
|
|
preset_param.gain= ae_preset_iso = adc_gain;
|
|
DBG_WRN("adc_value = %d, adc_exp =========== %d, %d\r\n", IRSHTTER, (unsigned int)adc_expt, (unsigned int)adc_gain);
|
|
|
|
get_preset_flag=TRUE;
|
|
}
|
|
}
|
|
|
|
void setet_preset_param(void)
|
|
{
|
|
AET_STATUS_INFO ae_status_info = {0};
|
|
ISPT_TOTAL_GAIN total_gain = {0};
|
|
|
|
ae_status_info.id = 0;
|
|
vendor_isp_get_ae(AET_ITEM_STATUS, &ae_status_info);
|
|
DBG_WRN(">> aet status exp %d iso %d\r\n",ae_status_info.status_info.expotime[0],ae_status_info.status_info.iso_gain[0]);
|
|
preset_param.expt= ae_status_info.status_info.expotime[0];
|
|
preset_param.gain= ae_status_info.status_info.iso_gain[0]*10;
|
|
total_gain.id = 0;
|
|
total_gain.gain = ae_status_info.status_info.iso_gain[0];//preset_param.gain;
|
|
vendor_isp_set_common(ISPT_ITEM_TOTAL_GAIN, &total_gain);
|
|
}
|
|
|
|
|
|
#endif
|