704 lines
19 KiB
C
Executable File
704 lines
19 KiB
C
Executable File
//global debug level: PRJ_DBG_LVL
|
|
#include "PrjCfg.h"
|
|
|
|
#include "SysCommon.h"
|
|
//#include "SysCfg.h"
|
|
//#include "AppLib.h"
|
|
#include "UIApp/UIAppCommon.h"
|
|
#include "Mode/UIModePhoto.h"
|
|
#include "UIApp/Photo/UIAppPhoto.h"
|
|
#include "UIWnd/UIFlow.h"
|
|
//#include "UIWnd/SPORTCAM/UIInfo/UIPhotoMapping.h"
|
|
#include "FileDB.h"
|
|
//#include "ImageUnit_ImgTrans.h"
|
|
//#include "ImageUnit_VdoEnc.h"
|
|
#if (VIDEO_FUNC_MJPG == ENABLE)
|
|
#include "VideoCodec_MJPG.h"
|
|
#endif
|
|
#if (VIDEO_FUNC_H264 == ENABLE)
|
|
#include "VideoCodec_H264.h"
|
|
#endif
|
|
#if (VIDEO_FUNC_H265 == ENABLE)
|
|
#include "VideoCodec_H265.h"
|
|
#endif
|
|
#if (USE_FILEDB==ENABLE)
|
|
#include "FileDB.h"
|
|
#endif
|
|
//#include "AppDisp_PipView.h"
|
|
#include <kwrap/sxcmd.h>
|
|
#include <kwrap/stdio.h>
|
|
#include "kwrap/cmdsys.h"
|
|
#include <string.h>
|
|
#include "UIApp/AppDisp_PipView.h"
|
|
|
|
//local debug level: THIS_DBGLVL
|
|
#define THIS_DBGLVL 2 // 0=FATAL, 1=ERR, 2=WRN, 3=UNIT, 4=FUNC, 5=IND, 6=MSG, 7=VALUE, 8=USER
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
#define __MODULE__ UiAppPhotoCmd
|
|
#define __DBGLVL__ ((THIS_DBGLVL>=PRJ_DBG_LVL)?THIS_DBGLVL:PRJ_DBG_LVL)
|
|
#define __DBGFLT__ "*" //*=All, [mark]=CustomClass
|
|
#include <kwrap/debug.h>
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
static void redraw_photo_ui(void)
|
|
{
|
|
Ux_PostEvent(NVTEVT_UPDATE_INFO, 1, UIAPPPHOTO_CB_UCTRL_UPDATE_UI);
|
|
}
|
|
|
|
static BOOL cmd_fd(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
sscanf_s(argv[0], "%d", &value);
|
|
|
|
if (value == 0)
|
|
//Ux_SendEvent(&CustomPhotoObjCtrl, NVTEVT_EXE_FD, 1, FD_OFF);
|
|
Ux_PostEvent(NVTEVT_EXE_FD, 1, FD_OFF);
|
|
else
|
|
//Ux_SendEvent(&CustomPhotoObjCtrl, NVTEVT_EXE_FD, 1, FD_ON);
|
|
Ux_PostEvent(NVTEVT_EXE_FD, 1, FD_ON);
|
|
redraw_photo_ui();
|
|
//exam_msg("photo fd %d\r\n", value);
|
|
return TRUE;
|
|
}
|
|
|
|
static BOOL cmd_ev(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
sscanf_s(argv[0], "%d", &value);
|
|
|
|
if (value >= EV_SETTING_MAX) {
|
|
DBG_ERR("photo ev %d\r\n", value);
|
|
return TRUE;
|
|
}
|
|
//Ux_SendEvent(&CustomPhotoObjCtrl, NVTEVT_EXE_EV, 1, value);
|
|
Ux_PostEvent(NVTEVT_EXE_EV, 1, value);
|
|
redraw_photo_ui();
|
|
//exam_msg("photo ev %d\r\n", value);
|
|
return TRUE;
|
|
}
|
|
|
|
static BOOL cmd_iso(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
sscanf_s(argv[0], "%d", &value);
|
|
|
|
if (value >= ISO_ID_MAX) {
|
|
DBG_ERR("photo iso %d\r\n", value);
|
|
return TRUE;
|
|
}
|
|
|
|
//Ux_SendEvent(&CustomPhotoObjCtrl, NVTEVT_EXE_ISO, 1, value);
|
|
Ux_PostEvent(NVTEVT_EXE_ISO, 1, value);
|
|
redraw_photo_ui();
|
|
//exam_msg("photo iso %d\r\n", value);
|
|
return TRUE;
|
|
}
|
|
|
|
static BOOL cmd_wb(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
sscanf_s(argv[0], "%d", &value);
|
|
|
|
if (value >= WB_ID_MAX) {
|
|
DBG_ERR("photo wb %d\r\n", value);
|
|
return TRUE;
|
|
}
|
|
|
|
//Ux_SendEvent(&CustomPhotoObjCtrl, NVTEVT_EXE_WB, 1, value);
|
|
Ux_PostEvent(NVTEVT_EXE_WB, 1, value);
|
|
redraw_photo_ui();
|
|
//exam_msg("photo wb %d\r\n", value);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
static BOOL cmd_size(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
sscanf_s(argv[0], "%d", &value);
|
|
|
|
if (value >= PHOTO_SIZE_ID_MAX) {
|
|
DBG_ERR("photo capture size %d\r\n", value);
|
|
return TRUE;
|
|
}
|
|
|
|
//Ux_SendEvent(&CustomPhotoObjCtrl, NVTEVT_EXE_CAPTURE_SIZE, 1, value);
|
|
Ux_PostEvent(NVTEVT_EXE_CAPTURE_SIZE, 1, value);
|
|
redraw_photo_ui();
|
|
//exam_msg("photo capture size %d\r\n", value);
|
|
return TRUE;
|
|
}
|
|
|
|
static BOOL cmd_quality(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
sscanf_s(argv[0], "%d", &value);
|
|
|
|
if (value >= QUALITY_ID_MAX) {
|
|
DBG_ERR("photo quality %d\r\n", value);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
//Ux_SendEvent(&CustomPhotoObjCtrl, NVTEVT_EXE_QUALITY, 1, value);
|
|
Ux_PostEvent(NVTEVT_EXE_QUALITY, 1, value);
|
|
redraw_photo_ui();
|
|
//exam_msg("photo quality %d\r\n", value);
|
|
return TRUE;
|
|
}
|
|
|
|
static BOOL cmd_datestamp(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
sscanf_s(argv[0], "%d", &value);
|
|
|
|
if (value >= DATE_STAMP_ID_MAX) {
|
|
DBG_ERR("photo datestamp %d\r\n", value);
|
|
return TRUE;
|
|
}
|
|
|
|
//Ux_SendEvent(&CustomPhotoObjCtrl, NVTEVT_EXE_DATE_PRINT, 1, value);
|
|
Ux_PostEvent(NVTEVT_EXE_DATE_PRINT, 1, value);
|
|
redraw_photo_ui();
|
|
//exam_msg("photo datestamp %d\r\n", value);
|
|
return TRUE;
|
|
}
|
|
|
|
static BOOL cmd_sharp(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
sscanf_s(argv[0], "%d", &value);
|
|
|
|
if (value >= SHARPNESS_ID_MAX) {
|
|
DBG_ERR("photo sharpness %d\r\n", value);
|
|
return TRUE;
|
|
}
|
|
|
|
//Ux_SendEvent(&CustomPhotoObjCtrl, NVTEVT_EXE_SHARPNESS, 1, value);
|
|
Ux_PostEvent(NVTEVT_EXE_SHARPNESS, 1, value);
|
|
redraw_photo_ui();
|
|
//exam_msg("photo sharpness %d\r\n", value);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static BOOL cmd_qviewtime(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
sscanf_s(argv[0], "%d", &value);
|
|
|
|
if (value >= QUICK_REVIEW_ID_MAX) {
|
|
DBG_ERR("photo quick view time %d\r\n", value);
|
|
return TRUE;
|
|
}
|
|
|
|
//Ux_SendEvent(&CustomPhotoObjCtrl, NVTEVT_EXE_PREVIEW, 1, value);
|
|
Ux_PostEvent(NVTEVT_EXE_PREVIEW, 1, value);
|
|
redraw_photo_ui();
|
|
//exam_msg("photo quick view time %d\r\n", value);
|
|
return TRUE;
|
|
}
|
|
|
|
static BOOL cmd_selftimer(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
sscanf_s(argv[0], "%d", &value);
|
|
|
|
if (value >= SELFTIMER_ID_MAX) {
|
|
DBG_ERR("photo selftimer %d\r\n", value);
|
|
return TRUE;
|
|
}
|
|
|
|
//Ux_SendEvent(&CustomPhotoObjCtrl, NVTEVT_EXE_SELFTIMER, 1, value);
|
|
Ux_PostEvent(NVTEVT_EXE_SELFTIMER, 1, value);
|
|
redraw_photo_ui();
|
|
//exam_msg("photo selftimer %d\r\n", value);
|
|
return TRUE;
|
|
}
|
|
|
|
static BOOL cmd_contshot(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
sscanf_s(argv[0], "%d", &value);
|
|
|
|
if (value >= CONTINUE_SHOT_SETTING_MAX) {
|
|
DBG_ERR("photo contshot %d\r\n", value);
|
|
return TRUE;
|
|
}
|
|
|
|
//Ux_SendEvent(&CustomPhotoObjCtrl, NVTEVT_EXE_CONTSHOT, 1, value);
|
|
Ux_PostEvent(NVTEVT_EXE_CONTSHOT, 1, value);
|
|
redraw_photo_ui();
|
|
//exam_msg("photo contshot %d\r\n", value);
|
|
return TRUE;
|
|
}
|
|
|
|
static BOOL cmd_scene(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
sscanf_s(argv[0], "%d", &value);
|
|
|
|
if (value >= SCENE_ID_MAX) {
|
|
DBG_ERR("photo scene %d\r\n", value);
|
|
return TRUE;
|
|
}
|
|
//Ux_SendEvent(&CustomPhotoObjCtrl, NVTEVT_EXE_SCENEMODE, 1, value);
|
|
Ux_PostEvent(NVTEVT_EXE_SCENEMODE, 1, value);
|
|
redraw_photo_ui();
|
|
//exam_msg("photo scene %d\r\n", value);
|
|
return TRUE;
|
|
}
|
|
static BOOL cmd_wdr(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
sscanf_s(argv[0], "%d", &value);
|
|
|
|
if (value == 0)
|
|
Ux_PostEvent(NVTEVT_EXE_WDR, 1, WDR_OFF);
|
|
else
|
|
Ux_PostEvent(NVTEVT_EXE_WDR, 1, WDR_ON);
|
|
redraw_photo_ui();
|
|
return TRUE;
|
|
}
|
|
static BOOL cmd_defog(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 value;
|
|
sscanf_s(argv[0], "%d", &value);
|
|
|
|
if (value == 0)
|
|
Ux_PostEvent(NVTEVT_EXE_DEFOG, 1, DEFOG_OFF);
|
|
else
|
|
Ux_PostEvent(NVTEVT_EXE_DEFOG, 1, DEFOG_ON);
|
|
redraw_photo_ui();
|
|
return TRUE;
|
|
}
|
|
static BOOL cmd_delete_file(unsigned char argc, char **argv)
|
|
{
|
|
FILEDB_HANDLE FileDBHandle = 0;
|
|
PFILEDB_FILE_ATTR FileAttr = NULL;
|
|
INT32 ret;
|
|
INT32 FileNum, i;
|
|
UINT32 freeSpaceMB, reservSizeMB = 20;
|
|
|
|
sscanf_s(argv[0], "%d", &reservSizeMB);
|
|
|
|
FileNum = FileDB_GetTotalFileNum(FileDBHandle);
|
|
for (i = FileNum - 1; i >= 0; i--) {
|
|
freeSpaceMB = (UINT32)(FileSys_GetDiskInfo(FST_INFO_FREE_SPACE) / (1024*1024));
|
|
if (freeSpaceMB > reservSizeMB)
|
|
break;
|
|
FileAttr = FileDB_SearhFile(FileDBHandle, 0);
|
|
if (FileAttr) {
|
|
if (M_IsReadOnly(FileAttr->attrib)) {
|
|
//DBG_IND("File Locked\r\n");
|
|
DBG_IND("File %s is locked\r\n", FileAttr->filePath);
|
|
continue;
|
|
}
|
|
ret = FileSys_DeleteFile(FileAttr->filePath);
|
|
//DBG_IND("i = %04d path=%s\r\n",i,FileAttr->filePath);
|
|
if (ret != FST_STA_OK) {
|
|
DBG_ERR("Delete %s failed\r\n", FileAttr->filePath);
|
|
} else {
|
|
FileDB_DeleteFile(FileDBHandle, 0);
|
|
DBG_DUMP("Delete %s OK\r\n", FileAttr->filePath);
|
|
}
|
|
} else {
|
|
DBG_IND("FileAttr not existed\r\n");
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL cmd_cap(unsigned char argc, char **argv)
|
|
{
|
|
/*
|
|
UINT32 value;
|
|
sscanf_s(argv[0], "%d", &value);
|
|
|
|
DBG_DUMP("cap cmd %d\r\n", value);
|
|
if (value == 0)
|
|
//Ux_SendEvent(&CustomPhotoObjCtrl, NVTEVT_EXE_CAPTURE_STOP, 1, value);
|
|
Ux_PostEvent(NVTEVT_KEY_SHUTTER2, 1, NVTEVT_KEY_RELEASE);
|
|
else {
|
|
cmd_delete_file("");
|
|
Ux_PostEvent(NVTEVT_KEY_SHUTTER2, 1, NVTEVT_KEY_PRESS);
|
|
//Ux_SendEvent(&CustomPhotoObjCtrl, NVTEVT_EXE_CAPTURE_START, 1, value);
|
|
}
|
|
redraw_photo_ui();
|
|
*/
|
|
return TRUE;
|
|
}
|
|
|
|
static BOOL cmd_stream(unsigned char argc, char **argv)
|
|
{
|
|
/*
|
|
UINT32 stream_type = PHOTO_STRM_TYPE_HTTP;
|
|
UINT32 codec = PHOTO_CODEC_MJPG;
|
|
UINT32 width = 800;
|
|
UINT32 height = 600;
|
|
UINT32 target_byte_rate = 1*1024*1024;
|
|
PHOTO_STRM_INFO *p_strm = NULL;
|
|
|
|
exam_msg("cmd %s\r\n", argv[0]);
|
|
|
|
sscanf_s(argv[0], "%d %d %d %d %d", &stream_type,&codec,&width,&height,&target_byte_rate);
|
|
|
|
if (stream_type > PHOTO_STRM_TYPE_RTSP){
|
|
DBG_ERR("stream_type=%d\r\n",stream_type);
|
|
return TRUE;
|
|
}
|
|
if (codec < PHOTO_CODEC_MJPG || codec > PHOTO_CODEC_H265){
|
|
DBG_ERR("codec=%d\r\n",codec);
|
|
return TRUE;
|
|
}
|
|
if (width > 1920 || width < 320){
|
|
DBG_ERR("width=%d\r\n",width);
|
|
return TRUE;
|
|
}
|
|
if (height > 1080 || height < 240){
|
|
DBG_ERR("height=%d\r\n",height);
|
|
return TRUE;
|
|
}
|
|
width = ALIGN_CEIL_16(width);
|
|
height = ALIGN_CEIL_8(height);
|
|
p_strm = UIAppPhoto_get_StreamConfig(UIAPP_PHOTO_STRM_ID_1);
|
|
p_strm->strm_type = stream_type;
|
|
p_strm->codec = codec;
|
|
p_strm->width = width;
|
|
p_strm->height = height;
|
|
p_strm->target_bitrate = target_byte_rate;
|
|
//exam_msg("photo stream set type =%d, codec=%d, w = %d, h= %d, byterate = %d\r\n",stream_type,codec,width,height,target_byte_rate);
|
|
exam_msg("photo stream set\r\n",stream_type,codec,width,height,target_byte_rate);
|
|
|
|
ImageUnit_Begin(&ISF_VdoEnc, 0);
|
|
if (codec == PHOTO_CODEC_MJPG) {
|
|
#if (VIDEO_FUNC_MJPG == ENABLE)
|
|
MP_VDOENC_ENCODER *pObj = MP_MjpgEnc_getVideoObject(UIAPP_PHOTO_STRM_ID_1);
|
|
ImageUnit_SetParam(UIAPP_PHOTO_STRM_ID_1, VDOENC_PARAM_ENCODER_OBJ, (UINT32)pObj);
|
|
#else
|
|
ImageUnit_SetParam(UIAPP_PHOTO_STRM_ID_1, VDOENC_PARAM_ENCODER_OBJ, 0);
|
|
DBG_ERR("[PHOTO][%d] codec = %d not support\r\n", UIAPP_PHOTO_STRM_ID_1, codec);
|
|
#endif
|
|
}
|
|
if (codec == PHOTO_CODEC_H264) {
|
|
#if (VIDEO_FUNC_H264 == ENABLE)
|
|
MP_VDOENC_ENCODER *pObj = MP_H264Enc_getVideoObject(UIAPP_PHOTO_STRM_ID_1);
|
|
ImageUnit_SetParam(UIAPP_PHOTO_STRM_ID_1, VDOENC_PARAM_ENCODER_OBJ, (UINT32)pObj);
|
|
#else
|
|
ImageUnit_SetParam(UIAPP_PHOTO_STRM_ID_1, VDOENC_PARAM_ENCODER_OBJ, 0);
|
|
DBG_ERR("[PHOTO][%d] codec = %d not support\r\n", UIAPP_PHOTO_STRM_ID_1, codec);
|
|
#endif
|
|
}
|
|
if (codec == PHOTO_CODEC_H265) {
|
|
#if (VIDEO_FUNC_H265 == ENABLE)
|
|
MP_VDOENC_ENCODER *pObj = MP_H265Enc_getVideoObject(UIAPP_PHOTO_STRM_ID_1);
|
|
ImageUnit_SetParam(UIAPP_PHOTO_STRM_ID_1, VDOENC_PARAM_ENCODER_OBJ, (UINT32)pObj);
|
|
#else
|
|
ImageUnit_SetParam(UIAPP_PHOTO_STRM_ID_1, VDOENC_PARAM_ENCODER_OBJ, 0);
|
|
DBG_ERR("[PHOTO][%d] codec = %d not support\r\n", UIAPP_PHOTO_STRM_ID_1, codec);
|
|
#endif
|
|
}
|
|
ImageUnit_End();
|
|
*/
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static BOOL cmd_setfps(unsigned char argc, char **argv)
|
|
{
|
|
/*
|
|
UINT32 src_fps = 30,dst_fps = 30;
|
|
|
|
sscanf_s(argv[0], "%d %d", &src_fps,&dst_fps);
|
|
|
|
DBG_DUMP("cmd_set src_fps %d, dst_fps %d\r\n", src_fps,dst_fps);
|
|
ImageUnit_Begin(&ISF_ImgTrans, 0);
|
|
ImageUnit_SetParam(ISF_OUT1 , IMGTRANS_PARAM_FPS_IMM, ISF_VDO_FRC(dst_fps, src_fps));
|
|
ImageUnit_End();
|
|
*/
|
|
return TRUE;
|
|
}
|
|
|
|
static BOOL cmd_quefull(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 i;
|
|
for (i=0;i<257;i++)
|
|
Ux_PostEvent(NVTEVT_EXE_FDEND, 1, NVTEVT_EXE_FDEND);
|
|
return TRUE;
|
|
|
|
}
|
|
BOOL cmd_photo_dumpfdb(unsigned char argc, char **argv)
|
|
{
|
|
#if (USE_FILEDB==ENABLE)
|
|
FileDB_DumpInfo(0);
|
|
#endif
|
|
return TRUE;
|
|
}
|
|
BOOL cmd_photo(unsigned char argc, char **argv)
|
|
{
|
|
#if (PHOTO_MODE==ENABLE)
|
|
UINT32 menuIdx, value;
|
|
|
|
sscanf_s(argv[0],"%d", &menuIdx);
|
|
sscanf_s(argv[1],"%d", &value);
|
|
|
|
if (menuIdx ==0)
|
|
{
|
|
DBG_DUMP("FD En %d\r\n",value);
|
|
UI_SetData(FL_FD, value);
|
|
Ux_SendEvent(&CustomPhotoObjCtrl, NVTEVT_EXE_FD, 1, SysGetFlag(FL_FD));
|
|
|
|
}
|
|
else if (menuIdx ==1)
|
|
{
|
|
DBG_DUMP("ContSot En %d\r\n",value);
|
|
UI_SetData(FL_CONTINUE_SHOT, value);
|
|
}
|
|
else if (menuIdx ==2)
|
|
{
|
|
/*
|
|
CONT_SHOT_OFF = 0,
|
|
CONT_SHOT_INFINITE,
|
|
CONT_SHOT_10,
|
|
CONT_SHOT_3,
|
|
*/
|
|
DBG_DUMP("ContSot index %d\r\n",value);
|
|
//UI_SetData(FL_ContShotIndex, value);
|
|
}
|
|
else if (menuIdx ==3)
|
|
{
|
|
extern BOOL isS2Pressed;
|
|
isS2Pressed = value;
|
|
DBG_DUMP("isS2Pressed =%d\r\n",isS2Pressed);
|
|
}
|
|
else if (menuIdx ==4)
|
|
{
|
|
DBG_DUMP("ISO index %d\r\n",value);
|
|
UI_SetData(FL_ISO, value);
|
|
Ux_SendEvent(&CustomPhotoObjCtrl, NVTEVT_EXE_ISO, 1, SysGetFlag(FL_ISO));
|
|
}
|
|
else if (menuIdx ==5)
|
|
{
|
|
UI_SetData(FL_RSC, value);
|
|
if (value == 1)
|
|
DBG_DUMP("RSC on\r\n");
|
|
else
|
|
DBG_DUMP("RSC off\r\n");
|
|
Ux_SendEvent(&CustomPhotoObjCtrl, NVTEVT_EXE_RSC, 1, SysGetFlag(FL_RSC));
|
|
}
|
|
// rsc onoff robust test
|
|
else if (menuIdx ==6)
|
|
{
|
|
/*
|
|
UINT32 i,delayMs;
|
|
#define RANDOM_RANGE(n) (randomUINT32() % (n))
|
|
|
|
DBG_DUMP("loop %d\r\n",value);
|
|
for (i=0;i<value;i++)
|
|
{
|
|
Ux_SendEvent(&CustomPhotoObjCtrl, NVTEVT_EXE_RSC, 1, 1);
|
|
delayMs = RANDOM_RANGE(3000);
|
|
DBG_DUMP("B delayMs = %d\r\n",delayMs);
|
|
SwTimer_DelayMs(delayMs);
|
|
DBG_DUMP("E delayMs = %d\r\n",delayMs);
|
|
Ux_SendEvent(&CustomPhotoObjCtrl, NVTEVT_EXE_RSC, 1, 0);
|
|
SwTimer_DelayMs(1000);
|
|
}
|
|
*/
|
|
}
|
|
else if (menuIdx ==7)
|
|
{
|
|
UI_SetData(FL_DUAL_CAM, value);
|
|
DBG_DUMP("Sensor index %d\r\n",value);
|
|
Ux_SendEvent(&CustomPhotoObjCtrl, NVTEVT_EXE_DUALCAM, 1, SysGetFlag(FL_DUAL_CAM));
|
|
}
|
|
else if (menuIdx ==8)
|
|
{
|
|
#if 0
|
|
UI_SetData(FL_CaptureIndex, value);
|
|
DBG_DUMP("Capture index %d\r\n",value);
|
|
Ux_SendEvent(&CustomPhotoObjCtrl, NVTEVT_EXE_CAPTURE_ID, 1, SysGetFlag(FL_CaptureIndex));
|
|
#endif
|
|
}
|
|
else if (menuIdx ==9)
|
|
{
|
|
UI_SetData(FL_SCENE, value);
|
|
DBG_DUMP("scene index %d\r\n",value);
|
|
Ux_SendEvent(&CustomPhotoObjCtrl, NVTEVT_EXE_SCENEMODE, 1, SysGetFlag(FL_SCENE));
|
|
}
|
|
else if (menuIdx ==10)
|
|
{
|
|
UI_SetData(FL_SHDR, value);
|
|
DBG_DUMP("SHDR index %d\r\n",value);
|
|
Ux_SendEvent(&CustomPhotoObjCtrl, NVTEVT_EXE_SHDR, 1, SysGetFlag(FL_SHDR));
|
|
}
|
|
else if (menuIdx ==11)
|
|
{
|
|
UI_SetData(FL_WDR, value);
|
|
DBG_DUMP("WDR index %d\r\n",value);
|
|
Ux_SendEvent(&CustomPhotoObjCtrl, NVTEVT_EXE_WDR, 1, SysGetFlag(FL_WDR));
|
|
}
|
|
else if (menuIdx ==12)
|
|
{
|
|
UI_SetData(FL_ANTISHAKE, value);
|
|
DBG_DUMP("ANTISHAKE index %d\r\n",value);
|
|
Ux_SendEvent(&CustomPhotoObjCtrl, NVTEVT_EXE_ANTISHAKING, 1, SysGetFlag(FL_ANTISHAKE));
|
|
}
|
|
else if (menuIdx ==13)
|
|
{
|
|
#if 1//(PIP_VIEW_LR == ENABLE)
|
|
DBG_DUMP("enter value=%d\r\n",value);
|
|
if(value>=DUALCAM_FRONT && value<DUALCAM_SETTING_MAX )
|
|
{
|
|
}
|
|
else
|
|
{
|
|
value=DUALCAM_FRONT;
|
|
}
|
|
DBG_DUMP("out value=%d\r\n",value);
|
|
UI_SetData(FL_DUAL_CAM, value);
|
|
UI_SetData(FL_DUAL_CAM_MENU, value);
|
|
|
|
//Ux_SendEvent(&CustomPhotoObjCtrl,NVTEVT_EXE_IMAGE_RATIO,1,GetPhotoSizeRatio(UI_GetData(FL_PHOTO_SIZE)));
|
|
|
|
PipView_SetStyle(UI_GetData(FL_DUAL_CAM));
|
|
#endif
|
|
}
|
|
#endif
|
|
return TRUE;
|
|
}
|
|
static BOOL cmd_photo_trigger_cap(unsigned char argc, char **argv)
|
|
{
|
|
#if (PHOTO_MODE==ENABLE)
|
|
|
|
DBG_DUMP("trigger cap\r\n");
|
|
Ux_SendEvent(&CustomPhotoObjCtrl, NVTEVT_EXE_CAPTURE_START, 1, ON_CAPTURE_CONT);
|
|
#endif
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
static BOOL cmd_photo_ota_trigger(unsigned char argc, char **argv)
|
|
{
|
|
UINT32 uiUserData = WDT_OTA_MAKEFOURCC(WDT_OTA_STS_LINUX_TRIGGER);
|
|
char cmd[128]={0};
|
|
|
|
Ux_PostEvent(NVTEVT_ALGMSG_FOCUSEND, 0);
|
|
|
|
sprintf(cmd, "mem w %x %x",WDT_REG_ADDR(WDT_DATA_OFS),uiUserData);
|
|
system(cmd);
|
|
system("watchdog -T 1 -t 5 /dev/watchdog");
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static BOOL cmd_photo_ota_result(unsigned char argc, char **argv)
|
|
{
|
|
|
|
system("devmem 0xF0050084 32 > /tmp/ota_sts");
|
|
|
|
FILE* fd = fopen("/tmp/ota_sts", "r");
|
|
char buf[16];
|
|
UINT32 ota_mask = 0x00FFFFFF; /* mask status */
|
|
UINT32 ota_prefix = WDT_OTA_MAKEFOURCC(WDT_OTA_STS_UBOOT_UPDATE_OK) & ota_mask; /* OTA */
|
|
|
|
if(fd){
|
|
|
|
buf[11] = '\0';
|
|
fread(buf, 10, 1, fd);
|
|
DBG_DUMP("ota_sts_str = %s\n", buf);
|
|
|
|
UINT32 ota_sts = strtoul(buf, NULL, 16);
|
|
|
|
DBG_DUMP("ota_sts = %08X , masked = %08X\n", ota_sts, ota_sts & ota_mask);
|
|
|
|
/* OTA success */
|
|
if(ota_sts == WDT_OTA_MAKEFOURCC(WDT_OTA_STS_UBOOT_UPDATE_OK)){
|
|
DBG_DUMP("update ok!\n");
|
|
}
|
|
/* not OTA */
|
|
else if(ota_sts == 0x0){
|
|
DBG_DUMP("not ota\n");
|
|
}
|
|
/* OTA wrong status */
|
|
else if ((ota_sts & ota_mask) == ota_prefix){
|
|
DBG_DUMP("ota error!\n");
|
|
}
|
|
|
|
}
|
|
else{
|
|
DBG_ERR("/tmp/ota_sts not found!\n");
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static SXCMD_BEGIN(uiphoto_cmd_tbl, "uiphoto_cmd_tbl")
|
|
SXCMD_ITEM("fd %", cmd_fd, "fd off/on, indxe value 0 ~ 1")
|
|
SXCMD_ITEM("ev %", cmd_ev, "ev -2 ~ +2, index value 0 ~ 12")
|
|
SXCMD_ITEM("iso %", cmd_iso, "ISO Auto, 100 ~ 1600, index value 0 ~ 5")
|
|
SXCMD_ITEM("wb %", cmd_wb, "WB, index value 0 ~ 4")
|
|
SXCMD_ITEM("size %", cmd_size, "capture size, index value 0 ~ 5")
|
|
SXCMD_ITEM("quality %", cmd_quality, "image quality, index value 0 ~ 2")
|
|
SXCMD_ITEM("datestamp %", cmd_datestamp, "datestamp, index value 0 ~ 2")
|
|
SXCMD_ITEM("sharp %", cmd_sharp, "sharp, index value 0 ~ 2")
|
|
SXCMD_ITEM("qviewtime %", cmd_qviewtime,"quick view time 0, 2s, 5s, index value 0 ~ 2")
|
|
SXCMD_ITEM("selftimer %", cmd_selftimer,"selftimer 0, 2s, 5s, 10s index value 0 ~ 3")
|
|
SXCMD_ITEM("contshot %", cmd_contshot, "continue shot setting, index value 0 ~ 3")
|
|
SXCMD_ITEM("scene %", cmd_scene, "scene mode , index value 0 ~ 2")
|
|
SXCMD_ITEM("wdr %", cmd_wdr, "wdr off/on, indxe value 0 ~ 1")
|
|
SXCMD_ITEM("defog %", cmd_defog, "defog off/on, indxe value 0 ~ 1")
|
|
SXCMD_ITEM("del %", cmd_delete_file,"delete file until free space larger than 15MB")
|
|
//SXCMD_ITEM("cap %", cmd_cap, "capture start/stop")
|
|
SXCMD_ITEM("stream %", cmd_stream, "photo streaming setting")
|
|
SXCMD_ITEM("setfps %", cmd_setfps, "photo display fps setting")
|
|
SXCMD_ITEM("quefull %", cmd_quefull, "ui queue full")
|
|
SXCMD_ITEM("dumpfdb", cmd_photo_dumpfdb, "dump filedb 0")
|
|
SXCMD_ITEM("photo %", cmd_photo, "photo mode setting")
|
|
SXCMD_ITEM("cap", cmd_photo_trigger_cap, "trigger cap")
|
|
SXCMD_ITEM("ota_trigger %", cmd_photo_ota_trigger, "ota trigger")
|
|
SXCMD_ITEM("ota_result %", cmd_photo_ota_result, "ota result")
|
|
|
|
SXCMD_END()
|
|
|
|
static int uiphoto_cmd_showhelp(int (*dump)(const char *fmt, ...))
|
|
{
|
|
UINT32 cmd_num = SXCMD_NUM(uiphoto_cmd_tbl);
|
|
UINT32 loop = 1;
|
|
|
|
dump("---------------------------------------------------------------------\r\n");
|
|
dump(" %s\n", "uiphoto");
|
|
dump("---------------------------------------------------------------------\r\n");
|
|
|
|
for (loop = 1 ; loop <= cmd_num ; loop++) {
|
|
dump("%15s : %s\r\n", uiphoto_cmd_tbl[loop].p_name, uiphoto_cmd_tbl[loop].p_desc);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
MAINFUNC_ENTRY(uiphoto, argc, argv)
|
|
{
|
|
UINT32 cmd_num = SXCMD_NUM(uiphoto_cmd_tbl);
|
|
UINT32 loop;
|
|
int ret;
|
|
|
|
if (argc < 2) {
|
|
return -1;
|
|
}
|
|
if (strncmp(argv[1], "?", 2) == 0) {
|
|
uiphoto_cmd_showhelp(vk_printk);
|
|
return 0;
|
|
}
|
|
for (loop = 1 ; loop <= cmd_num ; loop++) {
|
|
if (strncmp(argv[1], uiphoto_cmd_tbl[loop].p_name, strlen(argv[1])) == 0) {
|
|
ret = uiphoto_cmd_tbl[loop].p_func(argc-2, &argv[2]);
|
|
return ret;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|