#include "PrjCfg.h"

#if (defined(_NVT_ETHREARCAM_TX_) || defined(_NVT_ETHREARCAM_RX_))
#include "WifiAppCmd.h"
//#include "NVTToolCommand.h"
#include "WiFiIpc/nvtwifi.h"

#include "UIWnd/UIFlow.h"
//#include "UIWnd/SPORTCAM/UIInfo/UIInfo.h"
#include "UsockIpc/UsockIpcAPI.h"
//#include "nvtmpp.h"
//#include "SysCfg.h"
#include "WifiAppXML.h"
//#include "UIAppPhoto.h"
//#include "ImageUnit_VdoDec.h"
#include "UIApp/Movie/UIAppMovie.h"
#include "UIAppNetwork.h"
#include "EthCamAppCmd.h"
//#include "ImageApp_MovieCommon.h"
#include "ImageApp/ImageApp_MovieMulti.h"
#include "SysMain.h"
#include "SysCommon.h"
//#include "UIWnd/SPORTCAM/UIInfo/UIMovieMapping.h"
#include "Mode/UIModeUpdFw.h"
#include "EthCam/EthCamSocket.h"
#include "EthCamAppSocket.h"
#include "EthCamAppNetwork.h"
#include <comm/hwclock.h>
#include "comm/timer.h"
#include "UIApp/UsbMsdcCb/MsdcNvtCb.h"
#include "kwrap/flag.h"
#include "kwrap/type.h"
#include "Utility/SwTimer.h"
#include "kwrap/task.h"
#include "kwrap/semaphore.h"

#define THIS_DBGLVL         2 // 0=FATAL, 1=ERR, 2=WRN, 3=UNIT, 4=FUNC, 5=IND, 6=MSG, 7=VALUE, 8=USER
///////////////////////////////////////////////////////////////////////////////
#define __MODULE__          EthCamAppCmd
#define __DBGLVL__          ((THIS_DBGLVL>=PRJ_DBG_LVL)?THIS_DBGLVL:PRJ_DBG_LVL)
#define __DBGFLT__          "*" //*=All, [mark]=CustomClass
#include <kwrap/debug.h>
///////////////////////////////////////////////////////////////////////////////


ID ETHCAM_CMD_SND_FLG_ID = 0;
ID ETHCAM_CMD_RCV_FLG_ID = 0;
THREAD_HANDLE ETHCAM_CMD_SND_TSK_ID;
THREAD_HANDLE ETHCAM_CMD_RCV_TSK_ID;

ID ETHCAM_CMD_SNDDATA1_SEM_ID = 0;
ID ETHCAM_CMD_SNDDATA2_SEM_ID = 0;
ID ETHCAM_CMD_SNDCMD_SEM_ID = 0;

#if(defined(_NVT_ETHREARCAM_TX_))
UINT32 ETHCAM_CMD_SNDFRAME_SEM_ID = 0;
extern int SX_TIMER_ETHCAM_DATARECVDET_ID;
ETHCAM_TX_SYS_INFO sEthCamSysInfo={0};//for Tx
ETHCAM_TX_CODEC_SRCTYPE sEthCamCodecSrctype={0};//for Tx
UINT32  g_EthCamCmdGetFrame_SndNum = 0;
#endif
#if(defined(_NVT_ETHREARCAM_RX_))
ID  ETHCAM_WIFICB_VDOFRM_SEM_ID = 0;
ID  ETHCAM_DISP_DATA_SEM_ID = 0;
extern UINT32 EthCamHB1[ETHCAM_PATH_ID_MAX], EthCamHB2;
ETHCAM_TX_SYS_INFO sEthCamTxSysInfo[ETHCAM_PATH_ID_MAX]={0};//for Rx
ETHCAM_TX_CODEC_SRCTYPE sEthCamCodecSrctype[ETHCAM_PATH_ID_MAX]={0};//for Rx
#endif
static BOOL g_bEthCamCmdOpened = FALSE;
static ETHCAM_XML_RESULT *g_pEthCamCmdRstTbl=NULL;
ETHCAM_TX_DEC_INFO sEthCamTxDecInfo[ETHCAM_PATH_ID_MAX]={0};
ETHCAM_TX_REC_INFO sEthCamTxRecInfo[ETHCAM_PATH_ID_MAX]={0};
INT32 g_SocketCmd_Status[ETHCAM_PATH_ID_MAX]={0};

//ETHCAM_MENU_SETTING g_sEthCamMenuSetting={0};
ETHCAM_FWUD sEthCamFwUd={0};
//static TIMER_ID     g_EthCamCmd_TimerID = 0;

#if(defined(_NVT_ETHREARCAM_RX_))
static UINT32   g_EthCamCmdGetFrame_TimerID = 0;
static BOOL g_EthCamCmd_GetFrameTimerEn=0;
static UINT32 g_EthCamCmd_GetFrameTimerOpen=0;

static void EthCamCmd_GetFrameTimerCB(UINT32 TimerId)
{
	if(g_EthCamCmd_GetFrameTimerEn){
		set_flg(ETHCAM_CMD_SND_FLG_ID,FLG_ETHCAM_CMD_GETFRM);
	}
}
#endif
void EthCamCmd_GetFrameTimerOpen(void)
{
#if(defined(_NVT_ETHREARCAM_RX_))

	if(sEthCamTxSysInfo[0].PullModeEn && g_EthCamCmd_GetFrameTimerOpen==0){
		DBG_DUMP("GetFrameTimerOpen, Fps[0]=%d, Fps[1]=%d\r\n",sEthCamTxDecInfo[0].Fps,sEthCamTxDecInfo[1].Fps);
		g_EthCamCmd_GetFrameTimerEn=0;
		if (timer_open((TIMER_ID *)&g_EthCamCmdGetFrame_TimerID, EthCamCmd_GetFrameTimerCB) != E_OK) {
			DBG_ERR("open GetFrame timer fail\r\n");
		}
		if(sEthCamTxDecInfo[0].Fps==60 || sEthCamTxDecInfo[1].Fps==60){
			timer_cfg(g_EthCamCmdGetFrame_TimerID, 15 * 1000/*ms*/, TIMER_MODE_FREE_RUN | TIMER_MODE_ENABLE_INT, TIMER_STATE_PLAY);
		}else{
			timer_cfg(g_EthCamCmdGetFrame_TimerID, 30 * 1000/*ms*/, TIMER_MODE_FREE_RUN | TIMER_MODE_ENABLE_INT, TIMER_STATE_PLAY);
		}
		g_EthCamCmd_GetFrameTimerOpen=1;
	}
#endif
}
void EthCamCmd_GetFrameTimerClose(void)
{
#if(defined(_NVT_ETHREARCAM_RX_))
	if(g_EthCamCmd_GetFrameTimerOpen==1){
		g_EthCamCmd_GetFrameTimerOpen=0;
		//timer_pause_play(g_EthCamCmdGetFrame_TimerID, TIMER_STATE_PAUSE);
		timer_close(g_EthCamCmdGetFrame_TimerID);
		g_EthCamCmdGetFrame_TimerID =TIMER_NUM;
		g_EthCamCmd_GetFrameTimerEn=0;
	}
#endif
}
void EthCamCmd_GetFrameTimerEn(BOOL En)
{
#if(defined(_NVT_ETHREARCAM_RX_))
	if(En){
		EthCamCmd_GetFrameTimerOpen();

		if(sEthCamTxSysInfo[0].PullModeEn){
			g_EthCamCmd_GetFrameTimerEn=1;
		}else{
			//DBG_ERR("PullModeEn not enable!\r\n");
		}
	}else{
		g_EthCamCmd_GetFrameTimerEn=0;
	}
#endif
}
BOOL EthCamCmd_IsGetFrameTimerEnable(void)
{
#if(defined(_NVT_ETHREARCAM_RX_))
	return g_EthCamCmd_GetFrameTimerEn;
#else
	return 0;
#endif
}

ER EthCamCmdTsk_Open(void)
{
	if (g_bEthCamCmdOpened==1) {
		return E_SYS;
	}
	EthCamCmdHandler_InstallID();

	//EthCamCmd_GetFrameTimerOpen();

	// clear flag first
	clr_flg(ETHCAM_CMD_SND_FLG_ID, 0xFFFFFFFF);
	clr_flg(ETHCAM_CMD_RCV_FLG_ID, 0xFFFFFFFF);


	//sta_tsk(ETHCAM_CMD_SND_TSK_ID, 0);
	//sta_tsk(ETHCAM_CMD_RCV_TSK_ID, 0);
	vos_task_resume(ETHCAM_CMD_SND_TSK_ID);

	vos_task_resume(ETHCAM_CMD_RCV_TSK_ID);

	g_bEthCamCmdOpened=1;
	return E_OK;
}

ER EthCamCmdTsk_Close(void)
{
	FLGPTN FlgPtn;

	if (g_bEthCamCmdOpened==0) {
		return E_SYS;
	}

	// stop task
	set_flg(ETHCAM_CMD_SND_FLG_ID, FLG_ETHCAM_CMD_STOP);
	wai_flg(&FlgPtn, ETHCAM_CMD_SND_FLG_ID, FLG_ETHCAM_CMD_IDLE, TWF_ORW | TWF_CLR);

	set_flg(ETHCAM_CMD_RCV_FLG_ID, FLG_ETHCAM_CMD_STOP);
	wai_flg(&FlgPtn, ETHCAM_CMD_RCV_FLG_ID, FLG_ETHCAM_CMD_IDLE, TWF_ORW | TWF_CLR);

	//ter_tsk(ETHCAM_CMD_SND_TSK_ID);
	//ter_tsk(ETHCAM_CMD_RCV_TSK_ID);

	EthCamCmd_GetFrameTimerClose();

	EthCamCmdHandler_UnInstallID();
#if(defined(_NVT_ETHREARCAM_RX_))

	EthsockCliIpc_UnInstallID(ETH_REARCAM_CAPS_COUNT);

#endif
	g_bEthCamCmdOpened=0;
	return E_OK;
}


void EthCamCmd_SndData1Lock(void)
{
    DBG_IND("SndTsk Lock\r\n");
    SEM_WAIT(ETHCAM_CMD_SNDDATA1_SEM_ID);
}
void EthCamCmd_SndData1Unlock(void)
{
    DBG_IND("SndTsk Unlock\r\n");
    SEM_SIGNAL(ETHCAM_CMD_SNDDATA1_SEM_ID);
}
void EthCamCmd_SndData2Lock(void)
{
    DBG_IND("SndTsk Lock\r\n");
    SEM_WAIT(ETHCAM_CMD_SNDDATA2_SEM_ID);
}
void EthCamCmd_SndData2Unlock(void)
{
    DBG_IND("SndTsk Unlock\r\n");
    SEM_SIGNAL(ETHCAM_CMD_SNDDATA2_SEM_ID);
}
void EthCamCmd_SndCmdLock(void)
{
    DBG_IND("SndTsk Lock\r\n");
    SEM_WAIT(ETHCAM_CMD_SNDCMD_SEM_ID);
}
void EthCamCmd_SndCmdUnlock(void)
{
    DBG_IND("SndTsk Unlock\r\n");
    SEM_SIGNAL(ETHCAM_CMD_SNDCMD_SEM_ID);
}

//#define MAX_RETRY_CNT (100)
INT32 EthCamCmd_Send(ETHCAM_PATH_ID path_id, char* addr, int* size)
{
	INT32 result=0;
	static UINT32 errCnt=0;

	EthCamCmd_SndCmdLock();
#if(defined(_NVT_ETHREARCAM_TX_))
	result=EthCamSocket_Send(path_id, ETHSOCKET_CMD, addr, size);
#else
	result=EthCamSocket_Send(path_id, ETHSOCKETCLI_CMD, addr, size);
#endif
	EthCamCmd_SndCmdUnlock();
	if(result!=0){
		if(errCnt % 20 == 0){
			DBG_ERR("[%d]result=%d, size=%d\r\n",path_id,result,*size);
		}
		errCnt++;
	}else{
		errCnt=0;
	}

	return result;
}
THREAD_RETTYPE EthCamCmdSnd_Tsk(void)
{
	FLGPTN  FlgPtn;
#if(defined(_NVT_ETHREARCAM_RX_))
	UINT32 GetFrmNum=2;
#endif
	DBG_IND("EthCamCmdSnd_Tsk() start\r\n");

	//kent_tsk();
	//UINT32          uiTime;
	THREAD_ENTRY();

	while (ETHCAM_CMD_SND_TSK_ID) {
		set_flg(ETHCAM_CMD_SND_FLG_ID, FLG_ETHCAM_CMD_IDLE);
		PROFILE_TASK_IDLE();
		wai_flg(&FlgPtn, ETHCAM_CMD_SND_FLG_ID, FLG_ETHCAM_CMD_STOP|FLG_ETHCAM_CMD_SND|FLG_ETHCAM_CMD_GETFRM|FLG_ETHCAM_CMD_SEND_GPS, TWF_ORW | TWF_CLR);
		PROFILE_TASK_BUSY();
		clr_flg(ETHCAM_CMD_SND_FLG_ID, FLG_ETHCAM_CMD_IDLE);
		if (FlgPtn & FLG_ETHCAM_CMD_STOP){
			break;
		}

		if (FlgPtn & FLG_ETHCAM_CMD_SND) {
			DBG_IND("FLG_ETHCAM_CMD_SND\r\n");
			#if (defined(_NVT_ETHREARCAM_TX_))
			EthCamCmd_Send(0, (char*)sEthCamSendCmdInfo.ParserBuf, (int*)&sEthCamSendCmdInfo.BufSize);
			#endif
			#if(defined(_NVT_ETHREARCAM_RX_))
			EthCamCmd_Send(sEthCamSendCmdInfo.path_id, (char*)sEthCamSendCmdInfo.ParserBuf, (int*)&sEthCamSendCmdInfo.BufSize);
			#endif
		}
		if (FlgPtn & FLG_ETHCAM_CMD_GETFRM) {
			DBG_IND("FLG_ETHCAM_CMD_GETFRM\r\n");
			#if(defined(_NVT_ETHREARCAM_RX_))
			if(sEthCamTxSysInfo[0].PullModeEn){
				static UINT32 EthCamPreHB1[ETHCAM_PATH_ID_MAX]={0};
				if(EthCamNet_GetEthLinkStatus(ETHCAM_PATH_ID_1)==ETHCAM_LINK_UP && EthCamNet_GetPrevEthLinkStatus(ETHCAM_PATH_ID_1)==ETHCAM_LINK_UP){
					if(EthCamHB1[ETHCAM_PATH_ID_1]>2 && EthCamPreHB1[ETHCAM_PATH_ID_1]!=EthCamHB1[ETHCAM_PATH_ID_1]){// 4 sec
						DBG_WRN("reSend Strm Start[0]\r\n");
						EthCamPreHB1[ETHCAM_PATH_ID_1]=EthCamHB1[ETHCAM_PATH_ID_1];
						EthCam_SendXMLCmd(ETHCAM_PATH_ID_1, ETHCAM_PORT_DATA1 ,ETHCAM_CMD_TX_STREAM_START, 0);
					}
					//uiTime = Perf_GetCurrent();
					if(socketCliEthData1_IsConn(ETHCAM_PATH_ID_1)){
						EthCam_SendXMLCmd(ETHCAM_PATH_ID_1, ETHCAM_PORT_DEFAULT ,ETHCAM_CMD_GET_FRAME, GetFrmNum);
					}
					//DBG_DUMP("t1: %dus\r\n", Perf_GetCurrent() - uiTime);
				}
				if(EthCamNet_GetEthLinkStatus(ETHCAM_PATH_ID_2)==ETHCAM_LINK_UP && EthCamNet_GetPrevEthLinkStatus(ETHCAM_PATH_ID_2)==ETHCAM_LINK_UP){
					if(EthCamHB1[ETHCAM_PATH_ID_2]>2 && EthCamPreHB1[ETHCAM_PATH_ID_2]!=EthCamHB1[ETHCAM_PATH_ID_2]){// 4 sec
						DBG_WRN("reSend Strm Start[1]\r\n");
						EthCamPreHB1[ETHCAM_PATH_ID_2]=EthCamHB1[ETHCAM_PATH_ID_2];
						EthCam_SendXMLCmd(ETHCAM_PATH_ID_2, ETHCAM_PORT_DATA1 ,ETHCAM_CMD_TX_STREAM_START, 0);
					}
					if(socketCliEthData1_IsConn(ETHCAM_PATH_ID_2)){
						EthCam_SendXMLCmd(ETHCAM_PATH_ID_2, ETHCAM_PORT_DEFAULT ,ETHCAM_CMD_GET_FRAME, GetFrmNum);
					}
				}
			}
			#endif
		}
		if (FlgPtn & FLG_ETHCAM_CMD_SEND_GPS) {
			DBG_IND("FLG_ETHCAM_CMD_SEND_GPS\r\n");
			#if(defined(_NVT_ETHREARCAM_RX_))
			#if (GPS_FUNCTION == ENABLE)
			UINT16 i;
			RMCINFO sEthRmcinfo={0};
			GPSRec_GetRMCDate(&sEthRmcinfo);
			for(i=0;i<ETH_REARCAM_CAPS_COUNT;i++){
				if(EthCamNet_GetEthLinkStatus(i)==ETHCAM_LINK_UP){
					EthCam_SendXMLCmd(i, ETHCAM_PORT_DEFAULT ,ETHCAM_CMD_SET_TX_GPS, 0);
					EthCam_SendXMLData(i, (UINT8 *)&sEthRmcinfo, sizeof(RMCINFO));
				}
			}
			#endif
			#endif
		}
	}
	//ext_tsk();
	THREAD_RETURN(0);
}

//#define MAX_DATA_SIZE (230 * 1024)
INT32 EthCamData1_Send(char* addr, int* size)
{
	INT32 result=0;
	static UINT32 errCnt=0;
#if(defined(_NVT_ETHREARCAM_RX_))
	ETHCAM_PATH_ID path_id=ETHCAM_PATH_ID_1;
#endif

	EthCamCmd_SndData1Lock();

#if(defined(_NVT_ETHREARCAM_TX_))
	result=EthCamSocket_Send(0, ETHSOCKET_DATA1, addr, size);
#else
	result=EthCamSocket_Send(path_id, ETHSOCKETCLI_DATA1, addr, size);
#endif
	EthCamCmd_SndData1Unlock();

	if(result!=0){
		if(errCnt % 20 == 0){
			DBG_ERR("result=%d, size=%d\r\n",result,*size);
		}
		errCnt++;
	}else{
		errCnt=0;
	}

	return result;
}
INT32 EthCamData2_Send(char* addr, int* size)
{
	INT32 result=0;
	static UINT32 errCnt=0;
#if(defined(_NVT_ETHREARCAM_RX_))
	ETHCAM_PATH_ID path_id=ETHCAM_PATH_ID_1;
#endif
	EthCamCmd_SndData2Lock();

#if(defined(_NVT_ETHREARCAM_TX_))
	result=EthCamSocket_Send(0, ETHSOCKET_DATA2, addr, size);
#else
	result=EthCamSocket_Send(path_id, ETHSOCKETCLI_DATA2, addr, size);
#endif
 	EthCamCmd_SndData2Unlock();
	if(result!=0){
		if(errCnt % 20 == 0){
			DBG_ERR("result=%d\r\n",result);
		}
		errCnt++;
	}

	return result;
}
extern UINT32 g_testData1_Addr;
extern UINT32 g_testData1_Size;
THREAD_RETTYPE EthCamCmdRcvHandler_Tsk(void)
{
	FLGPTN  FlgPtn;

	DBG_IND("EthCamCmdRcvHandler_Tsk() start\r\n");

	//kent_tsk();
	THREAD_ENTRY();

	while (ETHCAM_CMD_RCV_TSK_ID) {
		set_flg(ETHCAM_CMD_RCV_FLG_ID, FLG_ETHCAM_CMD_IDLE);
		PROFILE_TASK_IDLE();
		wai_flg(&FlgPtn, ETHCAM_CMD_RCV_FLG_ID, FLG_ETHCAM_CMD_STOP|FLG_ETHCAM_CMD_RCV|FLG_ETHCAM_CMD_SETIP, TWF_ORW | TWF_CLR);
		PROFILE_TASK_BUSY();
		clr_flg(ETHCAM_CMD_RCV_FLG_ID, FLG_ETHCAM_CMD_IDLE);
		if (FlgPtn & FLG_ETHCAM_CMD_STOP){
			break;
		}
		if (FlgPtn & FLG_ETHCAM_CMD_RCV) {
#if (defined(_NVT_ETHREARCAM_TX_) && (ETH_REARCAM_CAPS_COUNT>=2))
			DBG_IND("FLG_ETHCAM_CMD_RCV\r\n");
			MovieExe_EthCamRecId1_SendFrm();
			EthCam_SendXMLStatus(0, ETHCAM_PORT_DEFAULT, ETHCAM_CMD_GET_FRAME, ETHCAM_RET_OK);
#endif
				char path[30];
				sprintf(path, "A:\\RxData.bin");
				//DBG_DUMP("=========RxData: %s\r\n", path);
#if 0

				static  FST_FILE fhdl = 0;
				UINT32      fileSize = 0;
				static UINT32 uiRecvSize=0;
				UINT32      TotalfileSize = 10*1024*1024;
				if(fhdl==0 && (uiRecvSize < TotalfileSize)){
					DBG_DUMP("=========RxData: %s\r\n", path);
					fhdl = FileSys_OpenFile(path, FST_CREATE_ALWAYS | FST_OPEN_WRITE);
					FileSys_SeekFile(fhdl, 0, FST_SEEK_SET);
				}else if(fhdl && (uiRecvSize < TotalfileSize)){
					FileSys_SeekFile(fhdl, 0, FST_SEEK_END);
				}
				fileSize = g_testData1_Size;
				if(fhdl && (uiRecvSize < TotalfileSize)){
					FileSys_WriteFile(fhdl, (UINT8 *)g_testData1_Addr, &fileSize, 0, NULL);
					uiRecvSize+=g_testData1_Size;
				}
				if(fhdl && (uiRecvSize>=TotalfileSize)){
					DBG_DUMP("Write Finish!\r\n");
					FileSys_CloseFile(fhdl);
					fhdl = 0;
				}
#endif
		}
		if (FlgPtn & FLG_ETHCAM_CMD_SETIP) {
#if (defined(_NVT_ETHREARCAM_TX_) && (ETH_REARCAM_CAPS_COUNT>=2))
			DBG_IND("FLG_ETHCAM_CMD_SETIP\r\n");
			System_CPU2_WaitReady();
			EthCamNet_SetTxIPAddr();
#endif
		}
	}
	//ext_tsk();
	THREAD_RETURN(0);
}
void EthCamCmdHandler_InstallID(void)
{
	OS_CONFIG_SEMPHORE(ETHCAM_CMD_SNDDATA1_SEM_ID, 0, 1, 1);
	OS_CONFIG_SEMPHORE(ETHCAM_CMD_SNDDATA2_SEM_ID, 0, 1, 1);
	OS_CONFIG_SEMPHORE(ETHCAM_CMD_SNDCMD_SEM_ID, 0, 1, 1);

	OS_CONFIG_FLAG(ETHCAM_CMD_SND_FLG_ID);
	OS_CONFIG_FLAG(ETHCAM_CMD_RCV_FLG_ID);
	//OS_CONFIG_TASK(ETHCAM_CMD_SND_TSK_ID,    PRI_ETHCAM_CMD_SND,   STKSIZE_ETHCAM_CMD_SND,   EthCamCmdSnd_Tsk);
	//OS_CONFIG_TASK(ETHCAM_CMD_RCV_TSK_ID,     PRI_ETHCAM_CMD_RCV,       STKSIZE_ETHCAM_CMD_RCV,        EthCamCmdRcvHandler_Tsk);

	ETHCAM_CMD_SND_TSK_ID=vos_task_create(EthCamCmdSnd_Tsk,  0, "EthCamCmdSnd_Tsk",   PRI_ETHCAM_CMD_SND,	STKSIZE_ETHCAM_CMD_SND);
	ETHCAM_CMD_RCV_TSK_ID=vos_task_create(EthCamCmdRcvHandler_Tsk,  0, "EthCamCmdRcvHandler_Tsk",   PRI_ETHCAM_CMD_RCV,	STKSIZE_ETHCAM_CMD_RCV);



#if(defined(_NVT_ETHREARCAM_TX_))
	OS_CONFIG_SEMPHORE(ETHCAM_CMD_SNDFRAME_SEM_ID, 0, 1, 1);
#endif

#if(defined(_NVT_ETHREARCAM_RX_) && WIFI_FUNC==ENABLE)
	OS_CONFIG_SEMPHORE(ETHCAM_WIFICB_VDOFRM_SEM_ID, 0, 1, 1);
#endif

#if(defined(_NVT_ETHREARCAM_RX_) && ETH_REARCAM_CAPS_COUNT==1)
	OS_CONFIG_SEMPHORE(ETHCAM_DISP_DATA_SEM_ID, 0, 1, 1);
#endif
}
void EthCamCmdHandler_UnInstallID(void)
{
	SEM_DESTROY(ETHCAM_CMD_SNDDATA1_SEM_ID);
	SEM_DESTROY(ETHCAM_CMD_SNDDATA2_SEM_ID);
	SEM_DESTROY(ETHCAM_CMD_SNDCMD_SEM_ID);
	rel_flg(ETHCAM_CMD_SND_FLG_ID);
	rel_flg(ETHCAM_CMD_RCV_FLG_ID);

	vos_task_destroy(ETHCAM_CMD_SND_TSK_ID);
	vos_task_destroy(ETHCAM_CMD_RCV_TSK_ID);

#if(defined(_NVT_ETHREARCAM_TX_))
	SEM_DESTROY(ETHCAM_CMD_SNDFRAME_SEM_ID);
#endif

#if(defined(_NVT_ETHREARCAM_RX_) && WIFI_FUNC==ENABLE)
	SEM_DESTROY(ETHCAM_WIFICB_VDOFRM_SEM_ID);
#endif

#if(defined(_NVT_ETHREARCAM_RX_) && ETH_REARCAM_CAPS_COUNT==1)
	SEM_DESTROY(ETHCAM_DISP_DATA_SEM_ID);
#endif
}
void EthCam_GetCmdStr(UINT32 cmd, UINT32 par, UINT8 *addr, UINT32 *size)
{
	//char pbuf[] = "/?custom=1&cmd=xxxx&par=0";
	char pbuf[128] = {0};
	sprintf(pbuf, "/?custom=1&cmd=%d&par=%d", cmd, par);
	*size=strlen(pbuf)+1;

	memcpy(addr, pbuf, *size);
	DBG_DUMP("bufSize=%d\r\n",*size);
	DBG_DUMP("cmd=%s\r\n",addr);
}
static void EthCamCmd_TimeOutTimerCB1(UINT32 uiEvent)
{
	EthCamCmd_Done(ETHCAM_PATH_ID_1, ETHCAM_CMD_TIMEOUT, ETHCAM_RET_TIMEOUT);
}
static void EthCamCmd_TimeOutTimerCB2(UINT32 uiEvent)
{
	EthCamCmd_Done(ETHCAM_PATH_ID_2, ETHCAM_CMD_TIMEOUT, ETHCAM_RET_TIMEOUT);
}

char pSendXMLCmdBuf[128] = {0};
//UINT32 EthCam_SendXMLCmd(UINT32 cmd,UINT32 par)
INT32 EthCam_SendXMLCmd(ETHCAM_PATH_ID path_id, ETHCAM_PORT_TYPE port_type, UINT32 cmd,UINT32 par)
{
	INT32 result=0;
	UINT32 len =0;

	CHAR* dest_ip[ETHCAM_PATH_ID_MAX]={SocketInfo[0].ip,SocketInfo[1].ip};
	UINT32 socket_port[ETHCAM_PATH_ID_MAX][ETHCAM_PORT_DATA_MAX]={{SocketInfo[0].port[2], SocketInfo[0].port[0], SocketInfo[0].port[1]},
																{SocketInfo[1].port[2], SocketInfo[1].port[0], SocketInfo[1].port[1]}};
	SWTIMER_ID   timer_id;
	BOOL         isOpenTimerOK = TRUE;
	SWTIMER_CB EventHandler;
	EthCamCmd_SndCmdLock();

	//sprintf(pSendXMLCmdBuf, "/?custom=1&cmd=%d&par=%d", cmd, par);
	sprintf(pSendXMLCmdBuf, "%s:%d/?custom=1&cmd=%d&par=%d", dest_ip[path_id], socket_port[path_id][port_type], cmd, par);
	len=strlen(pSendXMLCmdBuf)+1;
	DBG_IND("len=%d, cmd=%s\r\n",len,pSendXMLCmdBuf);
	EthCamCmd_ClrFlg(path_id, (ETHCAM_CMD_DONE|ETHCAM_CMD_TIMEOUT));
	if(path_id==ETHCAM_PATH_ID_1){
		EventHandler=(SWTIMER_CB)EthCamCmd_TimeOutTimerCB1;
	}else{
		EventHandler=(SWTIMER_CB)EthCamCmd_TimeOutTimerCB2;
	}
	if (SwTimer_Open(&timer_id, EventHandler) != E_OK) {
		DBG_ERR("[%d]open timer fail\r\n",path_id);
		isOpenTimerOK = FALSE;
	} else {
		//SwTimer_Cfg(timer_id, 3000 /*ms*/, SWTIMER_MODE_FREE_RUN);
		SwTimer_Cfg(timer_id, 1500 /*ms*/, SWTIMER_MODE_FREE_RUN);
		SwTimer_Start(timer_id);
	}

	//timer_pausePlay(g_EthCamCmdTimeOut_TimerID, TIMER_STATE_PLAY);

	//result= EthCamCmd_Send(path_id, (char *)pSendXMLCmdBuf, (int*)&len);
	result= EthCamSocket_Send(path_id, ETHSOCKETCLI_CMD, (char *)pSendXMLCmdBuf, (int*)&len);
	//DBG_DUMP("result=%d\r\n",result);

	if(result==0){
		result =EthCamCmd_WaitFinish(path_id, (ETHCAM_CMD_DONE|ETHCAM_CMD_TIMEOUT));
		if(ETHCAM_RET_TIMEOUT == result){
			DBG_ERR("[%d]cmd Timeout!cmd=%s\r\n",path_id,pSendXMLCmdBuf);
		}else if(ETHCAM_RET_CONTINUE == result){
			DBG_WRN("cmd CONTINUE\r\n");
			//EthCamCmd_ClrFlg(path_id, (ETHCAM_CMD_DONE));
			//result =EthCamCmd_WaitFinish(path_id, (ETHCAM_CMD_DONE|ETHCAM_CMD_TIMEOUT));
		}else{
			//DBG_DUMP("cmd=%d  OK\r\n",cmd);
		}
	}else{
		DBG_ERR("[%d]result=%d, %s\r\n",path_id,result,pSendXMLCmdBuf);
	}
	if (isOpenTimerOK) {
		SwTimer_Stop(timer_id);
		SwTimer_Close(timer_id);
	}
	EthCamCmd_SndCmdUnlock();

	return result;
}
INT32 EthCam_SendXMLData(ETHCAM_PATH_ID path_id, UINT8* addr, UINT32 size)
{
	UINT32 result=0;
	EthCamCmd_SndCmdLock();
	EthCamCmd_ClrFlg(path_id, ETHCAM_CMD_DONE);
	//timer_pausePlay(g_EthCamCmd_TimerID, TIMER_STATE_PLAY);

	//result= EthCamCmd_Send(path_id, (char *)addr, (int*)&size);
	result= EthCamSocket_Send(path_id, ETHSOCKETCLI_CMD, (char *)addr, (int*)&size);
	if(result==0){

		result=EthCamCmd_WaitFinish(path_id, (ETHCAM_CMD_DONE|ETHCAM_CMD_TIMEOUT));
		if(ETHCAM_RET_TIMEOUT == result){
			DBG_ERR("cmd Timeout!\r\n");
		}
	}else{
		DBG_ERR("result=%d\r\n",result);
	}
	EthCamCmd_SndCmdUnlock();
	return result;
}

INT32 EthCam_SendXMLCmdData(ETHCAM_PATH_ID path_id, ETHCAM_PORT_TYPE port_type, UINT32 cmd,UINT32 par, UINT8* addr, UINT32 size)
{
	INT32 result=0;
	UINT32 len =0;

	CHAR* dest_ip[ETHCAM_PATH_ID_MAX]={SocketInfo[0].ip,SocketInfo[1].ip};
	UINT32 socket_port[ETHCAM_PATH_ID_MAX][ETHCAM_PORT_DATA_MAX]={{SocketInfo[0].port[2], SocketInfo[0].port[0], SocketInfo[0].port[1]},
																{SocketInfo[1].port[2], SocketInfo[1].port[0], SocketInfo[1].port[1]}};
	SWTIMER_ID   timer_id;
	BOOL         isOpenTimerOK = TRUE;
	SWTIMER_CB EventHandler;
	EthCamCmd_SndCmdLock();

	//sprintf(pSendXMLCmdBuf, "/?custom=1&cmd=%d&par=%d", cmd, par);
	sprintf(pSendXMLCmdBuf, "%s:%d/?custom=1&cmd=%d&par=%d", dest_ip[path_id], socket_port[path_id][port_type], cmd, par);
	len=strlen(pSendXMLCmdBuf)+1;
	DBG_IND("len=%d, cmd=%s\r\n",len,pSendXMLCmdBuf);
	EthCamCmd_ClrFlg(path_id, (ETHCAM_CMD_DONE|ETHCAM_CMD_TIMEOUT));
	if(path_id==ETHCAM_PATH_ID_1){
		EventHandler=(SWTIMER_CB)EthCamCmd_TimeOutTimerCB1;
	}else{
		EventHandler=(SWTIMER_CB)EthCamCmd_TimeOutTimerCB2;
	}
	if (SwTimer_Open(&timer_id, EventHandler) != E_OK) {
		DBG_ERR("open timer fail\r\n");
		isOpenTimerOK = FALSE;
	} else {
		SwTimer_Cfg(timer_id, 3000 /*ms*/, SWTIMER_MODE_FREE_RUN);
		SwTimer_Start(timer_id);
	}

	//timer_pausePlay(g_EthCamCmdTimeOut_TimerID, TIMER_STATE_PLAY);
	result=EthCamSocket_Send(path_id, ETHSOCKETCLI_CMD, (char *)pSendXMLCmdBuf, (int*)&len);
	//result= EthCamCmd_Send(path_id, (char *)pSendXMLCmdBuf, (int*)&len);
	//DBG_DUMP("result=%d\r\n",result);

	if(result==0){

		result =EthCamCmd_WaitFinish(path_id, (ETHCAM_CMD_DONE|ETHCAM_CMD_TIMEOUT));

		if(ETHCAM_RET_TIMEOUT == result){
			DBG_ERR("cmd Timeout!cmd=%s\r\n",pSendXMLCmdBuf);
		}
	}else{
		DBG_ERR("result=%d, %s\r\n",result,pSendXMLCmdBuf);
	}
	if (isOpenTimerOK) {
		SwTimer_Stop(timer_id);
		SwTimer_Close(timer_id);
	}
	//DBG_ERR("result=%d, size=%d\r\n",result,size);

	if(addr && size){
		EthCamCmd_ClrFlg(path_id, ETHCAM_CMD_DONE);
		result= EthCamSocket_Send(path_id, ETHSOCKETCLI_CMD, (char *)addr, (int*)&size);
	}
	EthCamCmd_SndCmdUnlock();

	return result;
}

INT32 EthCam_SendXMLStatusCB(ETHCAM_PATH_ID path_id, ETHCAM_PORT_TYPE port_type, UINT32 cmd, UINT32 status)
{
	static char bufArry[128];
	static UINT32 len = 0;
	INT32 result = E_OK;
	char *buf = bufArry;
	//UINT32 sendlen = 0;
	UINT32 bufSize = 128;
	CHAR* dest_ip[ETHCAM_PATH_ID_MAX]={SocketInfo[0].ip,SocketInfo[1].ip};
	UINT32 socket_port[ETHCAM_PATH_ID_MAX][ETHCAM_PORT_DATA_MAX]={{SocketInfo[0].port[2], SocketInfo[0].port[0], SocketInfo[0].port[1]},
																{SocketInfo[1].port[2], SocketInfo[1].port[0], SocketInfo[1].port[1]}};


	memset(bufArry, 0, sizeof(bufArry));
	//len = XML_snprintf(&buf, &bufSize,  DEF_XML_HEAD);
	len = XML_snprintf(&buf, &bufSize, "%s:%d<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n" ,dest_ip[path_id], socket_port[path_id][port_type]);
	len = XML_snprintf(&buf, &bufSize, DEF_XML_RET, cmd, status);

	len = buf - bufArry;
	//sendlen = len;

	//DBG_DUMP("%d\r\n",len);
	//DBG_DUMP("%s\r\n",bufArry);

	if (len < 128) {
		#if (defined(_NVT_ETHREARCAM_TX_))
		memcpy(sEthCamSendCmdInfo.ParserBuf, bufArry, len);
		sEthCamSendCmdInfo.BufSize=len;
		set_flg(ETHCAM_CMD_SND_FLG_ID,FLG_ETHCAM_CMD_SND);
		#else
		#if 0
		DBG_IND(" %s %d\r\n", bufArry, sendlen);
		result = EthCamCmd_Send(path_id, (char*)bufArry, (int *)&len);
		if (sendlen != len) {
			result = E_SYS;
			DBG_ERR("sent %d error,should %d\r\n", len, sendlen);
		}
		#endif
		#endif
	} else {
		DBG_ERR("len %d err\r\n", len);
		result = E_SYS;
	}

	return result;

}

INT32 EthCam_SendXMLStatus(ETHCAM_PATH_ID path_id, ETHCAM_PORT_TYPE port_type, UINT32 cmd, UINT32 status)
{
	static char bufArry[128];
	static UINT32 len = 0;
	INT32 result = E_OK;
	char *buf = bufArry;
	//UINT32 sendlen = 0;
	UINT32 bufSize = 128;
	CHAR* dest_ip[ETHCAM_PATH_ID_MAX]={SocketInfo[0].ip,SocketInfo[1].ip};
	UINT32 socket_port[ETHCAM_PATH_ID_MAX][ETHCAM_PORT_DATA_MAX]={{SocketInfo[0].port[2], SocketInfo[0].port[0], SocketInfo[0].port[1]},
																{SocketInfo[1].port[2], SocketInfo[1].port[0], SocketInfo[1].port[1]}};
	EthCamCmd_SndCmdLock();

	memset(bufArry, 0, sizeof(bufArry));
	//len = XML_snprintf(&buf, &bufSize,  DEF_XML_HEAD);
	len = XML_snprintf(&buf, &bufSize, "%s:%d<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n" ,dest_ip[path_id], socket_port[path_id][port_type]);
	len = XML_snprintf(&buf, &bufSize, DEF_XML_RET, cmd, status);

	len = buf - bufArry;
	//sendlen = len;

	//DBG_DUMP("%d\r\n",len);
	//DBG_DUMP("%s\r\n",bufArry);

	if (len < 128) {
		#if (defined(_NVT_ETHREARCAM_TX_))
		//result = EthCamCmd_Send(0, (char*)bufArry, (int*)&len);
		result = EthCamSocket_Send(0, ETHSOCKET_CMD, (char*)bufArry, (int*)&len);
		#else
		#if 0
		DBG_IND(" %s %d\r\n", bufArry, sendlen);
		result = EthCamCmd_Send(path_id, (char*)bufArry, (int *)&len);
		if (sendlen != len) {
			result = E_SYS;
			DBG_ERR("sent %d error,should %d\r\n", len, sendlen);
		}
		#endif
		#endif
	} else {
		DBG_ERR("len %d err\r\n", len);
		result = E_SYS;
	}
	EthCamCmd_SndCmdUnlock();

	return result;

}

INT32 EthCam_SendXMLStr(ETHCAM_PATH_ID path_id, ETHCAM_PORT_TYPE port_type, UINT32 cmd, CHAR* str)
{
	static char bufArry[256];
	static UINT32 len = 0;
	INT32 result = E_OK;
	char *buf = bufArry;
	UINT32 sendlen = 0;
	UINT32 bufSize = 256;
	CHAR* dest_ip[ETHCAM_PATH_ID_MAX]={SocketInfo[0].ip,SocketInfo[1].ip};
	UINT32 socket_port[ETHCAM_PATH_ID_MAX][ETHCAM_PORT_DATA_MAX]={{SocketInfo[0].port[2], SocketInfo[0].port[0], SocketInfo[0].port[1]},
																{SocketInfo[1].port[2], SocketInfo[1].port[0], SocketInfo[1].port[1]}};

	EthCamCmd_SndCmdLock();
	memset(bufArry, 0, sizeof(bufArry));

	//len = XML_snprintf(&buf, &bufSize,  DEF_XML_HEAD);
	len = XML_snprintf(&buf, &bufSize, "%s:%d<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n" ,dest_ip[path_id], socket_port[path_id][port_type]);
	len = XML_snprintf(&buf, &bufSize, DEF_XML_STR, cmd, 0, str);

	len = buf - bufArry;
	sendlen = len;

	//DBG_DUMP("%d\r\n",len);
	//DBG_DUMP("Str bufArry=%s\r\n",bufArry);
	EthCamCmd_ClrFlg(path_id, (ETHCAM_CMD_DONE|ETHCAM_CMD_TIMEOUT));

	if (len < 256) {
		#if (defined(_NVT_ETHREARCAM_TX_))
		//result = EthCamCmd_Send(0, (char*)bufArry, (int*)&len);
		result = EthCamSocket_Send(0, ETHSOCKET_CMD, (char*)bufArry, (int*)&len);
		if (sendlen != len || result !=0) {
			result = E_SYS;
			DBG_ERR("sent error %d, %d\r\n", len, sendlen);
		}else{
			result = EthCamCmd_WaitFinish(path_id, (ETHCAM_CMD_DONE|ETHCAM_CMD_TIMEOUT));
		}
		#else
		DBG_IND(" %s %d\r\n", bufArry, sendlen);
		//result = EthCamCmd_Send(path_id, (char*)bufArry, (int *)&len);
		result = EthCamSocket_Send(path_id, ETHSOCKETCLI_CMD, (char*)bufArry, (int *)&len);
		if (sendlen != len) {
			result = E_SYS;
			DBG_ERR("sent %d error,should %d\r\n", len, sendlen);
		}
		#endif
	} else {
		DBG_ERR("len %d err\r\n", len);
		result = E_SYS;
	}
	EthCamCmd_SndCmdUnlock();

	return result;

}

INT32 EthCam_SendXMLValue(ETHCAM_PATH_ID path_id, ETHCAM_PORT_TYPE port_type, UINT32 cmd, UINT64 value)
{
	static char bufArry[256];
	static UINT32 len = 0;
	INT32 result = E_OK;
	char *buf = bufArry;
	UINT32 sendlen = 0;
	UINT32 bufSize = 256;
	CHAR* dest_ip[ETHCAM_PATH_ID_MAX]={SocketInfo[0].ip,SocketInfo[1].ip};
	UINT32 socket_port[ETHCAM_PATH_ID_MAX][ETHCAM_PORT_DATA_MAX]={{SocketInfo[0].port[2], SocketInfo[0].port[0], SocketInfo[0].port[1]},
																{SocketInfo[1].port[2], SocketInfo[1].port[0], SocketInfo[1].port[1]}};

	EthCamCmd_SndCmdLock();
	memset(bufArry, 0, sizeof(bufArry));

	//len = XML_snprintf(&buf, &bufSize,  DEF_XML_HEAD);
	len = XML_snprintf(&buf, &bufSize, "%s:%d<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n" ,dest_ip[path_id], socket_port[path_id][port_type]);
	len = XML_snprintf(&buf, &bufSize, DEF_XML_VALUE, cmd, 0, value);

	len = buf - bufArry;
	sendlen = len;

	//DBG_DUMP("%d\r\n",len);
	//DBG_DUMP("Value bufArry=%s\r\n",bufArry);
	EthCamCmd_ClrFlg(path_id, (ETHCAM_CMD_DONE|ETHCAM_CMD_TIMEOUT));

	if (len < 256) {
		#if (defined(_NVT_ETHREARCAM_TX_))
		//result = EthCamCmd_Send(0, (char*)bufArry, (int*)&len);
		result = EthCamSocket_Send(0, ETHSOCKET_CMD, (char*)bufArry, (int*)&len);
		if (sendlen != len || result !=0) {
			result = E_SYS;
			DBG_ERR("sent error %d, %d\r\n", len, sendlen);
		}else{
			result = EthCamCmd_WaitFinish(path_id, (ETHCAM_CMD_DONE|ETHCAM_CMD_TIMEOUT));
		}
		#else
		DBG_IND(" %s %d\r\n", bufArry, sendlen);
		//result = EthCamCmd_Send(path_id, (char*)bufArry, (int *)&len);
		result = EthCamSocket_Send(path_id, ETHSOCKETCLI_CMD, (char*)bufArry, (int *)&len);
		if (sendlen != len) {
			result = E_SYS;
			DBG_ERR("sent %d error,should %d\r\n", len, sendlen);
		}
		#endif
	} else {
		DBG_ERR("len %d err\r\n", len);
		result = E_SYS;
	}
	EthCamCmd_SndCmdUnlock();

	return result;

}

void XML_ListResult(UINT32 cmd,  UINT32* list_value, UINT32 list_total_cnt ,HFS_U32 bufAddr, HFS_U32 *bufSize, char *mimeType)
{
	char  *buf = (char *)bufAddr;
	UINT32 xmlBufSize = *bufSize;
	CHAR list_name[30] ={0};
	UINT32 i;

	XML_snprintf(&buf, &xmlBufSize, "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n<LIST>\n");
	XML_snprintf(&buf, &xmlBufSize, "<Cmd>%d</Cmd>\n", cmd);

	for(i=0;i<list_total_cnt;i++){
		sprintf(list_name,"<ITEM>%d</ITEM>\n",list_value[i]);
		DBG_IND("i=%d, list_name=%s\r\n",i,list_name);
		XML_snprintf(&buf, &xmlBufSize, list_name);
	}

	XML_snprintf(&buf, &xmlBufSize, "</LIST>\n");
	*bufSize = (HFS_U32)(buf) - bufAddr;
}
INT32 EthCamApp_CheckIfEthCamMode(void)
{
#if (defined(_NVT_ETHREARCAM_RX_) || defined(_NVT_ETHREARCAM_TX_))
	return TRUE;
#else
	return FALSE;
#endif
}

void EthCamCmd_Init(void)
{
	EthCamCmd_SetExecTable(Cmd_ethcam);
	EthCamCmd_SetResultTable(EthCamXMLResultTbl);

	EthCamCmd_SetDefautCB((UINT32)XML_DefaultFormat);
	EthCamCmd_SetEventHandle((UINT32)Ux_PostEvent);
	EthCamCmd_SetAppStartupChecker((UINT32)EthCamApp_CheckIfEthCamMode);

	EthCamCmd_ReceiveCmd(TRUE);
}
//XML parser
int EthCamCmdXML_skip_first_line(char *xml_buf){

    ////start code
    int xml_offset=0;

    if(*xml_buf == '<' &&
       *(xml_buf+1) == '?' &&
       *(xml_buf+2) == 'x' &&
       *(xml_buf+3) == 'm' &&
       *(xml_buf+4) == 'l'
       ){
        xml_offset ++;
        while(1){
            if(*(xml_buf+xml_offset)=='>'){
                xml_offset ++;
                break;
            }
            xml_offset ++;
        }
    }
    else{
        DBG_ERR("xml parser error, first char not '<' (%s) \r\n",xml_buf);
        return -1;
    }
    return xml_offset;
}

int EthCamCmdXML_remove_escape(char *xml_buf){

    int offset=0;
    while (1){
        if(*(xml_buf+offset)==0x0d || *(xml_buf+offset)==0x0a || *(xml_buf+offset)==' '){
            offset++;
            continue;
        }
        break;
    }
     return offset;
}
UINT32 EthCamCmdXML_get_tag_name(char *xml_buf, char *output){

    UINT32 offset=0;

    while(1){
        if(*(xml_buf+offset)!='>'){
            offset++;
            if(strlen(xml_buf) < offset){
                DBG_ERR("get not find tag '>' error! xml_buf=%s\r\n",xml_buf);
                return -1;
            }
            continue;
        }
        break;
    }
    if(*xml_buf == '<' && *(xml_buf+1) == '/'){
        strncpy(output,xml_buf+2,offset-2);
        output[offset -2]='\0';

    }
    else if(*xml_buf == '<'){
        strncpy(output,xml_buf+1,offset-1);
        output[offset -1]='\0';
    }
    else{
       DBG_ERR("parsing tag name error first buf=%x xml_buf=%s\r\n",*xml_buf,xml_buf);
       return -1;
    }
    if(strstr(output," ")){
       //////there is a attribute, need to_do!!!
    }
    offset++; ///skip '>'
    return offset;
}

UINT32 EthCamCmdXML_get_tag_value(char *xml_buf, char *output){

    UINT32 offset=0;
    while(1){
        if(*(xml_buf+offset)!='<'){
            offset++;
            if(strlen(xml_buf) < offset){
                DBG_ERR("get not find tag '<' error! xml_buf=%s\r\n",xml_buf);
                return -1;
            }
            continue;
        }
        break;
    }
    strncpy(output,xml_buf,offset);
    output[offset]='\0';

    return offset;
}
INT32 EthCamCmdXML_parsing_leaf(char *xml_buf, char *name, char *value){

    INT32 offset=0;
    INT32 tmp_offset=0;
    tmp_offset = EthCamCmdXML_get_tag_value(xml_buf, value);
    if(tmp_offset< 0){
        DBG_ERR("EthCamCmdXML_get_tag_value error  tmp_offset=%d\r\n",tmp_offset);
        return -1;
    }
    offset += tmp_offset;
    tmp_offset = EthCamCmdXML_get_tag_name(xml_buf+offset,name);//get end flag
    if(tmp_offset< 0){
        DBG_ERR("EthCamCmdXML_get_tag_name error  tmp_offset=%d\r\n",tmp_offset);
        return -1;
    }
    offset += tmp_offset;
    tmp_offset = EthCamCmdXML_remove_escape(xml_buf+offset);// remove \r \n
    if(tmp_offset< 0){
        DBG_ERR("EthCamCmdXML_remove_escape error  tmp_offset=%d\r\n",tmp_offset);
        return -1;
    }
    offset += tmp_offset;
    return offset;
}
//typedef enum _ETHCAM_CMD_ID{
//    ETHCAM_CMD_9001      = 9001,
//    ETHCAM_CMD_9002      = 9002,
//    ETHCAM_CMD_9003      = 9003,
//}ETHCAM_CMD_ID;

INT32 EthCamCmdXML_parsing_default_format(char *xml_buf, void * output)
{
    char current_name[64]={0};
    char current_value[128]={0};
    INT32 offset =0;
    INT32 tmp_offset=0;
    INT32 function_flag=0;
    INT32 pass_flag=0;

    //ETHCAM_XML_DEFAULT_FORMAT *output_data = (ETHCAM_XML_DEFAULT_FORMAT *)output;
    ETHCAM_XML_DEFAULT_FORMAT output_data={0};
    ETHCAM_XML_CB_REGISTER *reg = (ETHCAM_XML_CB_REGISTER *)output;
    memset(&output_data, 0, sizeof(ETHCAM_XML_DEFAULT_FORMAT));
    if(reg){
        output_data.path_id=reg->path_id;
        output_data.port_type=reg->port_type;
    }


    tmp_offset = EthCamCmdXML_get_tag_name(xml_buf+offset,current_name);

    if(tmp_offset < 0){
        DBG_ERR("get_tag_name error offset=%d\r\n",offset);
        return -1;
    }

    offset += tmp_offset;

    while(1){
        if(!strcmp(current_name, "Function")){
            function_flag++;
            if(function_flag > 1){
                /////xml parsing finish
                break;
            }
            tmp_offset = EthCamCmdXML_remove_escape(xml_buf+offset);// remove \r \n
            if(tmp_offset< 0){
                DBG_ERR("EthCamCmdXML_remove_escape error Function tmp_offset=%d\r\n",tmp_offset);
                return -1;
            }
            offset += tmp_offset;
        }
        else if(!strcmp(current_name,"Cmd")){
            tmp_offset = EthCamCmdXML_parsing_leaf(xml_buf+ offset, current_name, current_value);
            if(tmp_offset<0){
                DBG_ERR("EthCamCmdXML_parsing_leaf error tmp_offset=%d\r\n",tmp_offset);
                return -1;
            }

            offset += tmp_offset;
            output_data.cmd = atoi(current_value);
        }
        else if(!strcmp(current_name,"Status")){
            tmp_offset = EthCamCmdXML_parsing_leaf(xml_buf+ offset, current_name, current_value);
            if(tmp_offset<0){
                DBG_ERR("EthCamCmdXML_parsing_leaf error tmp_offset=%d\r\n",tmp_offset);
                return -1;
            }

            offset += tmp_offset;
            output_data.status = atoi(current_value);
            g_SocketCmd_Status[reg->path_id]=output_data.status;
            if(pass_flag==0){
                pass_flag=1;
            }
            else{
                DBG_ERR("EthCamCmdXML pass_flag error pass_flag=%d\r\n",pass_flag);
                return -1;
            }
        }
        else{
            DBG_ERR("tag name not support (%s)\r\n",current_name);
            return -1;
        }
        tmp_offset = EthCamCmdXML_get_tag_name(xml_buf+offset,current_name);
        if(tmp_offset< 0){
            DBG_ERR("EthCamCmdXML_get_tag_name error Function tmp_offset=%d\r\n",tmp_offset);
            return -1;
        }
        offset += tmp_offset;
        if(pass_flag == 1){
            ////get data finish , send data to CB function
            ////next current_name is List, it is the last data
            if(!strcmp(current_name,"Function")){
                if(reg && reg->EthCamXML_data_CB){
	                reg->EthCamXML_data_CB(1,(void *)&output_data);
                }
            }
            else{
                if(reg && reg->EthCamXML_data_CB){
	                reg->EthCamXML_data_CB(0,(void *)&output_data);
                }
            }
            pass_flag = 0;
            DBG_IND("cmd=%d, status=%d\r\n",output_data.cmd, output_data.status);
            memset(&output_data, 0, sizeof(output_data));
        }
    }
    return output_data.status;
}


INT32 EthCamCmdXML_parsing_value_result(char *xml_buf, void * output)
{
    char current_name[64]={0};
    char current_value[128]={0};
    INT32 offset =0;
    INT32 tmp_offset=0;
    INT32 function_flag=0;
    INT32 pass_flag=0;
    //ETHCAM_XML_VALUE_RESULT *output_data = (ETHCAM_XML_VALUE_RESULT *)output;
    ETHCAM_XML_VALUE_RESULT output_data={0};
    ETHCAM_XML_CB_REGISTER *reg = (ETHCAM_XML_CB_REGISTER *)output;
    memset(&output_data, 0, sizeof(ETHCAM_XML_VALUE_RESULT));
    if(reg){
        output_data.path_id=reg->path_id;
        output_data.port_type=reg->port_type;
    }

    tmp_offset = EthCamCmdXML_get_tag_name(xml_buf+offset,current_name);

    if(tmp_offset < 0){
        DBG_ERR("get_tag_name error offset=%d\r\n",offset);
        return -1;
    }

    offset += tmp_offset;

    while(1){
        if(!strcmp(current_name, "Function")){
            function_flag++;
            if(function_flag > 1){
                /////xml parsing finish
                break;
            }
            tmp_offset = EthCamCmdXML_remove_escape(xml_buf+offset);// remove \r \n
            if(tmp_offset< 0){
                DBG_ERR("EthCamCmdXML_remove_escape error Function tmp_offset=%d\r\n",tmp_offset);
                return -1;
            }
            offset += tmp_offset;
        }
        else if(!strcmp(current_name,"Cmd")){
            tmp_offset = EthCamCmdXML_parsing_leaf(xml_buf+ offset, current_name, current_value);
            if(tmp_offset<0){
                DBG_ERR("EthCamCmdXML_parsing_leaf error tmp_offset=%d\r\n",tmp_offset);
                return -1;
            }
            offset += tmp_offset;
            output_data.cmd = atoi(current_value);
        }
        else if(!strcmp(current_name,"Status")){
            tmp_offset = EthCamCmdXML_parsing_leaf(xml_buf+ offset, current_name, current_value);
            if(tmp_offset<0){
                DBG_ERR("EthCamCmdXML_parsing_leaf error tmp_offset=%d\r\n",tmp_offset);
                return -1;
            }
            offset += tmp_offset;
            output_data.status = atoi(current_value);
            g_SocketCmd_Status[reg->path_id]=output_data.status;
        }
        else if(!strcmp(current_name,"Value")){
            tmp_offset = EthCamCmdXML_parsing_leaf(xml_buf+ offset, current_name, current_value);
            if(tmp_offset<0){
                DBG_ERR("EthCamCmdXML_parsing_leaf error tmp_offset=%d\r\n",tmp_offset);
                return -1;
            }
            offset += tmp_offset;
            output_data.value= atoi(current_value);
            if(pass_flag==0){
                pass_flag=1;
            }
            else{
                DBG_ERR("EthCamCmdXML pass_flag error pass_flag=%d\r\n",pass_flag);
                return -1;
            }
        }
        else{
            DBG_ERR("tag name not support (%s)\r\n",current_name);
            return -1;
        }
        tmp_offset = EthCamCmdXML_get_tag_name(xml_buf+offset,current_name);
        if(tmp_offset< 0){
            DBG_ERR("EthCamCmdXML_get_tag_name error Function tmp_offset=%d\r\n",tmp_offset);
            return -1;
        }
        offset += tmp_offset;
        if(pass_flag == 1){
            ////get data finish , send data to CB function
            ////next current_name is List, it is the last data
            if(!strcmp(current_name,"Function")){
                if(reg && reg->EthCamXML_data_CB){
                	reg->EthCamXML_data_CB(1,(void *)&output_data);
                }
            }
            else{
                if(reg && reg->EthCamXML_data_CB){
                	reg->EthCamXML_data_CB(0,(void *)&output_data);
                }
            }
            pass_flag = 0;
            DBG_IND("cmd=%d, status=%d, value=%d\r\n",output_data.cmd, output_data.status,output_data.value);
            memset(&output_data, 0, sizeof(output_data));
        }
    }
    return 0;
}
INT32 EthCamCmdXML_parsing_string_result(char *xml_buf, void * output)
{
    char current_name[64]={0};
    char current_value[128]={0};
    INT32 offset =0;
    INT32 tmp_offset=0;
    INT32 function_flag=0;
    INT32 pass_flag=0;
    //ETHCAM_XML_VALUE_RESULT *output_data = (ETHCAM_XML_VALUE_RESULT *)output;
    ETHCAM_XML_STRING_RESULT output_data={0};
    ETHCAM_XML_CB_REGISTER *reg = (ETHCAM_XML_CB_REGISTER *)output;
    memset(&output_data, 0, sizeof(ETHCAM_XML_STRING_RESULT));
    if(reg){
        output_data.path_id=reg->path_id;
        output_data.port_type=reg->port_type;
    }

    tmp_offset = EthCamCmdXML_get_tag_name(xml_buf+offset,current_name);

    if(tmp_offset < 0){
        DBG_ERR("get_tag_name error offset=%d\r\n",offset);
        return -1;
    }

    offset += tmp_offset;

    while(1){
        if(!strcmp(current_name, "Function")){
            function_flag++;
            if(function_flag > 1){
                /////xml parsing finish
                break;
            }
            tmp_offset = EthCamCmdXML_remove_escape(xml_buf+offset);// remove \r \n
            if(tmp_offset< 0){
                DBG_ERR("EthCamCmdXML_remove_escape error Function tmp_offset=%d\r\n",tmp_offset);
                return -1;
            }
            offset += tmp_offset;
        }
        else if(!strcmp(current_name,"Cmd")){
            tmp_offset = EthCamCmdXML_parsing_leaf(xml_buf+ offset, current_name, current_value);
            if(tmp_offset<0){
                DBG_ERR("EthCamCmdXML_parsing_leaf error tmp_offset=%d\r\n",tmp_offset);
                return -1;
            }
            offset += tmp_offset;
            output_data.cmd = atoi(current_value);
        }
        else if(!strcmp(current_name,"Status")){
            tmp_offset = EthCamCmdXML_parsing_leaf(xml_buf+ offset, current_name, current_value);
            if(tmp_offset<0){
                DBG_ERR("EthCamCmdXML_parsing_leaf error tmp_offset=%d\r\n",tmp_offset);
                return -1;
            }
            offset += tmp_offset;
            output_data.status = atoi(current_value);
            g_SocketCmd_Status[reg->path_id]=output_data.status;
        }
        else if(!strcmp(current_name,"String")){
            tmp_offset = EthCamCmdXML_parsing_leaf(xml_buf+ offset, current_name, current_value);
            if(tmp_offset<0){
                DBG_ERR("EthCamCmdXML_parsing_leaf error tmp_offset=%d\r\n",tmp_offset);
                return -1;
            }
            offset += tmp_offset;
            strncpy(output_data.string,current_value,sizeof(output_data.string));
            output_data.string[sizeof(output_data.string)-1]='\0';
            if(pass_flag==0){
                pass_flag=1;
            }
            else{
                DBG_ERR("EthCamCmdXML pass_flag error pass_flag=%d\r\n",pass_flag);
                return -1;
            }
        }
        else{
            DBG_ERR("tag name not support (%s)\r\n",current_name);
            return -1;
        }
        tmp_offset = EthCamCmdXML_get_tag_name(xml_buf+offset,current_name);
        if(tmp_offset< 0){
            DBG_ERR("EthCamCmdXML_get_tag_name error Function tmp_offset=%d\r\n",tmp_offset);
            return -1;
        }
        offset += tmp_offset;
        if(pass_flag == 1){
            ////get data finish , send data to CB function
            ////next current_name is List, it is the last data
            if(!strcmp(current_name,"Function")){
                if(reg && reg->EthCamXML_data_CB){
                	reg->EthCamXML_data_CB(1,(void *)&output_data);
                }
            }
            else{
                if(reg && reg->EthCamXML_data_CB){
                	reg->EthCamXML_data_CB(0,(void *)&output_data);
                }
            }
            pass_flag = 0;
            DBG_IND("cmd=%d, status=%d, string=%s\r\n",output_data.cmd, output_data.status,output_data.string);
            memset(&output_data, 0, sizeof(output_data));
        }
    }
    return 0;
}
static INT32 EthCamCmdXML_parsing_list(char *xml_buf, void * reg_data){

    char current_name[64]={0};
    char current_value[128]={0};
    INT32 offset =0;
    INT32 tmp_offset=0;
    INT32 list_flag=0;
    INT32 total_count=0;

    ETHCAM_XML_CB_REGISTER *reg = (ETHCAM_XML_CB_REGISTER *)reg_data;
    ETHCAM_XML_LIST output_data={0};
    if(reg){
        output_data.path_id=reg->path_id;
        output_data.port_type=reg->port_type;
    }

    tmp_offset = EthCamCmdXML_get_tag_name(xml_buf+offset,current_name);
    if(tmp_offset < 0){
        DBG_ERR("get_tag_name error offset=%d\r\n",offset);
        return -1;
    }
    offset += tmp_offset;
    while(1){
        if(!strcmp(current_name, "LIST")){
            list_flag++;
            if(list_flag > 1){
                /////xml parsing finish
                break;
            }
            tmp_offset = EthCamCmdXML_remove_escape(xml_buf+offset);// remove \r \n
            if(tmp_offset< 0){
                DBG_ERR("EthCamCmdXML_remove_escape error Function tmp_offset=%d\r\n",tmp_offset);
                return -1;
            }
            offset += tmp_offset;
        }
        else if(!strcmp(current_name,"Cmd")){
            tmp_offset = EthCamCmdXML_parsing_leaf(xml_buf+ offset, current_name, current_value);
            if(tmp_offset<0){
                DBG_ERR("EthCamCmdXML_parsing_leaf error tmp_offset=%d\r\n",tmp_offset);
                return -1;
            }
            offset += tmp_offset;
        }
        else if(!strcmp(current_name, "ITEM")){
            tmp_offset = EthCamCmdXML_parsing_leaf(xml_buf+ offset, current_name, current_value);
            if(tmp_offset< 0){
                DBG_ERR("EthCamCmdXML_remove_escape error Function tmp_offset=%d\r\n",tmp_offset);
                return -1;
            }
            offset += tmp_offset;
            output_data.item[total_count] = atoi(current_value);
            DBG_IND("item=%d, total_count=%d\r\n",output_data.item[total_count],total_count);
            total_count++;
            output_data.total_item_cnt=total_count;
        }
        else{
            DBG_ERR("tag name not support (%s)\r\n",current_name);
            return -1;
        }
        tmp_offset = EthCamCmdXML_get_tag_name(xml_buf+offset,current_name);
        if(tmp_offset< 0){
            DBG_ERR("EthCamCmdXML_get_tag_name error Function tmp_offset=%d\r\n",tmp_offset);
            return -1;
        }
        offset += tmp_offset;
    }
    if(list_flag > 1){
        ////get data finish , send data to CB function
        ////next current_name is List, it is the last data
        if(!strcmp(current_name,"LIST")){
            if(reg && reg->EthCamXML_data_CB){
                reg->EthCamXML_data_CB(1,(void *)&output_data);
            }
        }
        else{
            if(reg && reg->EthCamXML_data_CB){
                reg->EthCamXML_data_CB(0,(void *)&output_data);
            }
        }
        list_flag = 0;
        memset(&output_data, 0, sizeof(output_data));
    }

    return 0;
}
INT32 EthCamCmdXML_GetCmdId(char *xml_buf)
{
    if(strlen(xml_buf)<=0){
        DBG_ERR("EthCam xml buf len error len=%d\r\n",strlen(xml_buf));
        return -1;
    }
    INT32 offset=0;
    INT32 tmp_offset=0;
    tmp_offset = EthCamCmdXML_skip_first_line(xml_buf);
    if(tmp_offset < 0){
        DBG_ERR("skip_first_line parsing error offset=%d\r\n",offset);
        return -1;
    }
    offset = offset + tmp_offset;
    tmp_offset = EthCamCmdXML_remove_escape(xml_buf+offset);
    if(tmp_offset < 0){
        DBG_ERR("EthCamCmdXML_remove_escape parsing error offset=%d\r\n",offset);
        return -1;
    }
    offset = offset + tmp_offset;


    char current_name[64]={0};
    char current_value[128]={0};
    INT32 function_flag=0;

    xml_buf=xml_buf+offset;
    tmp_offset = EthCamCmdXML_get_tag_name(xml_buf,current_name);

    if(tmp_offset < 0){
        DBG_ERR("get_tag_name error offset=%d\r\n",offset);
        return -1;
    }

    offset =0;
    offset += tmp_offset;
    while(1){
        if(!strcmp(current_name, "Function")){
            function_flag++;
            if(function_flag > 1){
                /////xml parsing finish
                break;
            }
            tmp_offset = EthCamCmdXML_remove_escape(xml_buf+offset);// remove \r \n
            if(tmp_offset< 0){
                DBG_ERR("EthCamCmdXML_remove_escape error Function tmp_offset=%d\r\n",tmp_offset);
                return -1;
            }
            offset += tmp_offset;
        }
        else if(!strcmp(current_name, "LIST")){
            function_flag++;
            if(function_flag > 1){
                /////xml parsing finish
                break;
            }
            tmp_offset = EthCamCmdXML_remove_escape(xml_buf+offset);// remove \r \n
            if(tmp_offset< 0){
                DBG_ERR("EthCamCmdXML_remove_escape error Function tmp_offset=%d\r\n",tmp_offset);
                return -1;
            }
            offset += tmp_offset;
        }
        else if(!strcmp(current_name,"Cmd")){
            tmp_offset = EthCamCmdXML_parsing_leaf(xml_buf+ offset, current_name, current_value);
            if(tmp_offset<0){
                DBG_ERR("EthCamCmdXML_parsing_leaf error tmp_offset=%d\r\n",tmp_offset);
                return -1;
            }
            offset += tmp_offset;
            //output_data->cmd = atoi(current_value);
            return atoi(current_value);
        }
        else if(!strcmp(current_name,"Status")){
            tmp_offset = EthCamCmdXML_parsing_leaf(xml_buf+ offset, current_name, current_value);
            if(tmp_offset<0){
                DBG_ERR("EthCamCmdXML_parsing_leaf error tmp_offset=%d\r\n",tmp_offset);
                return -1;
            }
            offset += tmp_offset;
            //output_data->status = atoi(current_value);
            DBG_DUMP("status=%d\r\n",atoi(current_value));
        }
        else{
            DBG_ERR("tag name not support (%s)\r\n",current_name);
            return -1;
        }
        tmp_offset = EthCamCmdXML_get_tag_name(xml_buf+offset,current_name);
        if(tmp_offset< 0){
            DBG_ERR("EthCamCmdXML_get_tag_name error Function tmp_offset=%d\r\n",tmp_offset);
            return -1;
        }
        offset += tmp_offset;
    }

    return -1;
}
INT32 EthCamCmdXML_parser(INT32 cmd_id,char *xml_buf ,void* output)
{
    if(cmd_id < 0){
        DBG_ERR("EthCam cmd_id error cmd_id=%d \r\n",cmd_id);
        return -1;
    }
    if(strlen(xml_buf)<=0){
        DBG_ERR("EthCam xml buf len error len=%d\r\n",strlen(xml_buf));
        return -1;
    }
    INT32 offset=0;
    INT32 tmp_offset=0;
    tmp_offset = EthCamCmdXML_skip_first_line(xml_buf);
    if(tmp_offset < 0){
        DBG_ERR("skip_first_line parsing error offset=%d\r\n",offset);
        return -1;
    }
    offset = offset + tmp_offset;
    tmp_offset = EthCamCmdXML_remove_escape(xml_buf+offset);
    if(tmp_offset < 0){
        DBG_ERR("EthCamCmdXML_remove_escape parsing error offset=%d\r\n",offset);
        return -1;
    }

    offset = offset + tmp_offset;

    INT32 i = 0;
    UINT32 result_type=0;
    ETHCAM_XML_RESULT *EthCamXMLResultTbl=EthCamCmd_GetResultTable();
    while (EthCamXMLResultTbl[i].cmd != 0) {
        if (cmd_id == EthCamXMLResultTbl[i].cmd) {
            result_type=EthCamXMLResultTbl[i].result_type;
            break;
        }
        i++;
    }
    DBG_IND("result_type=%d\r\n",result_type);

    INT32 ret =0;
    //switch (cmd_id){
    switch (result_type){

        //case ETHCAM_CMD_STARTUP:
        case ETHCAM_XML_RESULT_TYPE_DEFAULT_FORMAT:
            ret = EthCamCmdXML_parsing_default_format(xml_buf+offset, output);
            if(ret < 0){
                DBG_ERR("DEFAULT_FORMAT %d error ret =%d\r\n",cmd_id,ret);
            }
            break;
        case ETHCAM_XML_RESULT_TYPE_VALUE_RESULT:
            ret = EthCamCmdXML_parsing_value_result(xml_buf+offset, output);
            if(ret < 0){
                DBG_ERR("VALUE_RESULT %d error ret =%d\r\n",cmd_id,ret);
            }
            break;
        case ETHCAM_XML_RESULT_TYPE_LIST:
            ret = EthCamCmdXML_parsing_list(xml_buf+offset, output);
            if(ret < 0){
                DBG_ERR("LIST %d error ret =%d\r\n",cmd_id,ret);
            }
            break;
        case ETHCAM_XML_RESULT_TYPE_STRING_RESULT:
            ret = EthCamCmdXML_parsing_string_result(xml_buf+offset, output);
            if(ret < 0){
                DBG_ERR("STRING_RESULT %d error ret =%d\r\n",cmd_id,ret);
            }
            break;
        default:
            DBG_ERR("EthCam cmd %d not support!\r\n",cmd_id);
            ret=ETHCAM_RET_CMD_NOT_FOUND;
            return ret;
    }
    if(ret < 0){
        //DBG_DUMP("xml_buf=%s\r\n",xml_buf);
    }
    return ret;
}

void EthCam_GetDest(char *path,  ETHCAM_PATH_ID *path_id, ETHCAM_PORT_TYPE *port_type)
{
	char dest_ip[16];
	UINT32 dest_port = 80;
	UINT i ,j;
	//CHAR* ip_base[ETHCAM_PATH_ID_MAX]={gEthCamTxIP[0].ip,gEthCamTxIP[1].ip};
	CHAR* ip_base[ETHCAM_PATH_ID_MAX]={SocketInfo[0].ip,SocketInfo[1].ip};

	//UINT32 port_base[ETHCAM_PATH_ID_MAX][ETHCAM_PORT_DATA_MAX]={ETH_CMD_SOCKET_PORT, ETH_DATA1_SOCKET_PORT, ETH_DATA2_SOCKET_PORT};
	UINT32 port_base[ETHCAM_PATH_ID_MAX][ETHCAM_PORT_DATA_MAX]={{SocketInfo[0].port[2], SocketInfo[0].port[0], SocketInfo[0].port[1]},
																{SocketInfo[1].port[2], SocketInfo[1].port[0], SocketInfo[1].port[1]}};

	UINT32 port_type_base[ETHCAM_PATH_ID_MAX][ETHCAM_PORT_DATA_MAX]={{ETHCAM_PORT_DEFAULT, ETHCAM_PORT_DATA1, ETHCAM_PORT_DATA2},
																{ETHCAM_PORT_DEFAULT, ETHCAM_PORT_DATA1, ETHCAM_PORT_DATA2}};


	sscanf(path, "%15[^:]:%99d", dest_ip, &dest_port);
	DBG_IND("dest_ip=%s, dest_port=%d\r\n",dest_ip,dest_port);

	if(strcmp(dest_ip, ip_base[0])==0){
		*path_id=ETHCAM_PATH_ID_1;
	}else{
		*path_id=ETHCAM_PATH_ID_2;
	}
	for(i=0;i<ETHCAM_PATH_ID_MAX;i++){
		for(j=0;j<ETHCAM_PORT_DATA_MAX;j++){
			if(dest_port==port_base[i][j]){
				*port_type=port_type_base[i][j];
				break;
			}
		}
	}
}

int EthCam_STARTUP(char *path, char *argument, HFS_U32 bufAddr, HFS_U32 *bufSize, char *mimeType, HFS_U32 segmentCount)
{
	XML_DefaultFormat(ETHCAM_CMD_STARTUP, ETHCAM_RET_OK, bufAddr, bufSize, mimeType);
	return ETHCAM_CMD_GETDATA_RETURN_OK;
}

int EthCam_GetMovieTBR(char *path, char *argument, HFS_U32 bufAddr, HFS_U32 *bufSize, char *mimeType, HFS_U32 segmentCount)
{
#if(defined(_NVT_ETHREARCAM_TX_))
	ETHCAM_PATH_ID path_id;
	ETHCAM_PORT_TYPE port_type;
	EthCam_GetDest(path, &path_id, &port_type);
	DBG_DUMP("path_id=%d, port_type=%d\r\n",path_id,port_type);

	if(port_type==ETHCAM_PORT_DATA1){
		XML_ValueResult(ETHCAM_CMD_GET_TX_MOVIE_TBR, MovieExe_GetTBR(_CFG_REC_ID_1), bufAddr, bufSize, mimeType);
	}else{
		XML_ValueResult(ETHCAM_CMD_GET_TX_MOVIE_TBR, MovieExe_GetTBR(_CFG_CLONE_ID_1), bufAddr, bufSize, mimeType);
	}
#endif
	return ETHCAM_CMD_GETDATA_RETURN_OK;
}
int EthCam_GetMovieFps(char *path, char *argument, HFS_U32 bufAddr, HFS_U32 *bufSize, char *mimeType, HFS_U32 segmentCount)
{
#if(defined(_NVT_ETHREARCAM_TX_))
	ETHCAM_PATH_ID path_id;
	ETHCAM_PORT_TYPE port_type;
	EthCam_GetDest(path, &path_id, &port_type);
	if(port_type==ETHCAM_PORT_DATA1){
		XML_ValueResult(ETHCAM_CMD_GET_TX_MOVIE_FPS, MovieExe_GetFps(_CFG_REC_ID_1), bufAddr, bufSize, mimeType);
	}else{
		XML_ValueResult(ETHCAM_CMD_GET_TX_MOVIE_FPS, MovieExe_GetFps(_CFG_CLONE_ID_1), bufAddr, bufSize, mimeType);
	}
#endif
	return ETHCAM_CMD_GETDATA_RETURN_OK;
}
int EthCam_GetMovieCodec(char *path, char *argument, HFS_U32 bufAddr, HFS_U32 *bufSize, char *mimeType, HFS_U32 segmentCount)
{
#if(defined(_NVT_ETHREARCAM_TX_))
	ETHCAM_PATH_ID path_id;
	ETHCAM_PORT_TYPE port_type;
	EthCam_GetDest(path, &path_id, &port_type);
	if(port_type==ETHCAM_PORT_DATA1){
		XML_ValueResult(ETHCAM_CMD_GET_TX_MOVIE_CODEC, MovieExe_GetCodec(_CFG_REC_ID_1), bufAddr, bufSize, mimeType);
	}else{
		XML_ValueResult(ETHCAM_CMD_GET_TX_MOVIE_CODEC, MovieExe_GetCodec(_CFG_CLONE_ID_1), bufAddr, bufSize, mimeType);
	}
#endif
	return ETHCAM_CMD_GETDATA_RETURN_OK;
}

int EthCam_GetMovieRecSize(char *path, char *argument, HFS_U32 bufAddr, HFS_U32 *bufSize, char *mimeType, HFS_U32 segmentCount)
{
#if(defined(_NVT_ETHREARCAM_TX_))
	ETHCAM_PATH_ID path_id;
	ETHCAM_PORT_TYPE port_type;
	EthCam_GetDest(path, &path_id, &port_type);
	UINT32 list_value[2]={0};

	if(port_type==ETHCAM_PORT_DATA1){
		list_value[0]=MovieExe_GetWidth(_CFG_REC_ID_1);
		list_value[1]=MovieExe_GetHeight(_CFG_REC_ID_1);
	}else{
		list_value[0]=MovieExe_GetWidth(_CFG_CLONE_ID_1);
		list_value[1]=MovieExe_GetHeight(_CFG_CLONE_ID_1);
	}
	XML_ListResult(ETHCAM_CMD_GET_TX_MOVIE_REC_SIZE, list_value, sizeof(list_value)/sizeof(UINT32),  bufAddr, bufSize, mimeType);
#endif
	return ETHCAM_CMD_GETDATA_RETURN_OK;
}
int EthCam_GetMovieGop(char *path, char *argument, HFS_U32 bufAddr, HFS_U32 *bufSize, char *mimeType, HFS_U32 segmentCount)
{
#if(defined(_NVT_ETHREARCAM_TX_))
	ETHCAM_PATH_ID path_id;
	ETHCAM_PORT_TYPE port_type;
	EthCam_GetDest(path, &path_id, &port_type);
	if(port_type==ETHCAM_PORT_DATA1){
 		XML_ValueResult(ETHCAM_CMD_GET_TX_MOVIE_GOP, MovieExe_GetGOP(_CFG_REC_ID_1), bufAddr, bufSize, mimeType);
	}else{
		XML_ValueResult(ETHCAM_CMD_GET_TX_MOVIE_GOP, MovieExe_GetGOP(_CFG_CLONE_ID_1), bufAddr, bufSize, mimeType);
	}
#endif
	return ETHCAM_CMD_GETDATA_RETURN_OK;
}

int EthCam_GetMovieSPS_PPS(char *path, char *argument, HFS_U32 bufAddr, HFS_U32 *bufSize, char *mimeType, HFS_U32 segmentCount)
{
#if(defined(_NVT_ETHREARCAM_TX_))

	//UINT8 tem_buf[64];
	UINT8 tem_buf[128];
	MEM_RANGE desc;
	MEM_RANGE sps;
	MEM_RANGE pps;
	MEM_RANGE vps;
	ETHCAM_PATH_ID path_id;
	ETHCAM_PORT_TYPE port_type;
	UINT32 codec;
	EthCam_GetDest(path, &path_id, &port_type);

	desc.Addr=(UINT32)tem_buf;
	desc.Size=sizeof(tem_buf);
	DBG_ERR("VCodec=%d\r\n",sEthCamSysInfo.VCodec);
	codec= (sEthCamSysInfo.VCodec == MOVIE_CODEC_H265)?_CFG_CODEC_H265:_CFG_CODEC_H264;
	if(port_type==ETHCAM_PORT_DATA1){
		//ImageApp_MovieMulti_GetDesc(_CFG_REC_ID_1, _CFG_CODEC_H265, &desc, &sps, &pps, &vps);
		ImageApp_MovieMulti_GetDesc(_CFG_REC_ID_1, codec, &desc, &sps, &pps, &vps);
	}else{
		//ImageApp_MovieMulti_GetDesc(_CFG_CLONE_ID_1, _CFG_CODEC_H265, &desc, &sps, &pps, &vps);
		ImageApp_MovieMulti_GetDesc(_CFG_CLONE_ID_1, codec, &desc, &sps, &pps, &vps);
	}
	UINT32 list_value[desc.Size];
	DBG_IND("desc[%d]:\r\n",desc.Size);

	UINT8 *pBuf;
	pBuf=(UINT8 *)desc.Addr;

	UINT32 i;
	for(i=0;i<desc.Size;i++){
		list_value[i]=pBuf[i];
		DBG_IND("0x%x, ", pBuf[i]);
	}
	DBG_IND("\r\n");
#if 0

	DBG_DUMP("\r\nsps[%d]:\r\n",sps.Size);

	pBuf=(UINT8 *)sps.Addr;
	for(i=0;i<sps.Size;i++){
		DBG_DUMP("0x%x, ", pBuf[i]);
	}
	DBG_DUMP("\r\npps[%d]:\r\n",pps.Size);

	pBuf=(UINT8 *)pps.Addr;
	for(i=0;i<pps.Size;i++){
		DBG_DUMP("0x%x, ", pBuf[i]);
	}
	DBG_DUMP("\r\nvps[%d]:\r\n",vps.Size);
	pBuf=(UINT8 *)vps.Addr;
	for(i=0;i<vps.Size;i++){
		DBG_DUMP("0x%x, ", pBuf[i]);
	}
	DBG_DUMP("\r\n");
#endif

	XML_ListResult(ETHCAM_CMD_GET_TX_SPS_PPS, list_value, desc.Size,  bufAddr, bufSize, mimeType);
#endif
	return ETHCAM_CMD_GETDATA_RETURN_OK;
}
int EthCam_TxStreamStart(char *path, char *argument, HFS_U32 bufAddr, HFS_U32 *bufSize, char *mimeType, HFS_U32 segmentCount)
{
#if(defined(_NVT_ETHREARCAM_TX_))
	ETHCAM_PATH_ID path_id;
	ETHCAM_PORT_TYPE port_type;
	EthCam_GetDest(path, &path_id, &port_type);
	if(port_type==ETHCAM_PORT_DATA1){
		MovieExe_EthCamTxStart(_CFG_REC_ID_1);
	}else{
		MovieExe_EthCamTxStart(_CFG_CLONE_ID_1);
	}
	EthCamNet_SetTxHB(0);
	SxTimer_SetFuncActive(SX_TIMER_ETHCAM_DATARECVDET_ID, TRUE);

#endif
	XML_DefaultFormat(ETHCAM_CMD_TX_STREAM_START, ETHCAM_RET_OK, bufAddr, bufSize, mimeType);
	return ETHCAM_CMD_GETDATA_RETURN_OK;
}
int EthCam_TxStreamStop(char *path, char *argument, HFS_U32 bufAddr, HFS_U32 *bufSize, char *mimeType, HFS_U32 segmentCount)
{
#if(defined(_NVT_ETHREARCAM_TX_))
	ETHCAM_PATH_ID path_id;
	ETHCAM_PORT_TYPE port_type;
	EthCam_GetDest(path, &path_id, &port_type);

	if(port_type==ETHCAM_PORT_DATA1){
		MovieExe_EthCamTxStop(_CFG_REC_ID_1);
	}else{
		MovieExe_EthCamTxStop(_CFG_CLONE_ID_1);
	}
#endif
	XML_DefaultFormat(ETHCAM_CMD_TX_STREAM_STOP, ETHCAM_RET_OK, bufAddr, bufSize, mimeType);
	return ETHCAM_CMD_GETDATA_RETURN_OK;
}

int EthCam_GetMovieThumb(char *path, char *argument, HFS_U32 bufAddr, HFS_U32 *bufSize, char *mimeType, HFS_U32 segmentCount)
{
#if(defined(_NVT_ETHREARCAM_TX_))
	ImageApp_MovieMulti_EthCam_TxTrigThumb((0 | ETHCAM_TX_MAGIC_KEY));
#endif
	XML_DefaultFormat(ETHCAM_CMD_GET_TX_MOVIE_THUMB, ETHCAM_RET_OK, bufAddr, bufSize, mimeType);
	return ETHCAM_CMD_GETDATA_RETURN_OK;
}
int EthCam_GetMovieRawEncode(char *path, char *argument, HFS_U32 bufAddr, HFS_U32 *bufSize, char *mimeType, HFS_U32 segmentCount)
{
#if(defined(_NVT_ETHREARCAM_TX_))
	if (System_GetState(SYS_STATE_CURRMODE) != PRIMARY_MODE_MOVIE) {
		XML_DefaultFormat(ETHCAM_CMD_GET_TX_MOVIE_RAW_ENCODE, ETHCAM_RET_ERR, bufAddr, bufSize, mimeType);
		DBG_ERR("not movie mode\r\n");
		return ETHCAM_CMD_GETDATA_RETURN_OK;
	}

	//680,510 media not record,also can raw encode
	if(ImageApp_MovieMulti_IsStreamRunning(_CFG_REC_ID_1 | ETHCAM_TX_MAGIC_KEY)){
		Ux_SendEvent(&CustomMovieObjCtrl, NVTEVT_EXE_MOVIE_REC_RAWENC, 0);
	} else {
		DBG_ERR("Not in recording state\r\n");

		XML_DefaultFormat(ETHCAM_CMD_GET_TX_MOVIE_RAW_ENCODE, ETHCAM_RET_ERR, bufAddr, bufSize, mimeType);
		return ETHCAM_CMD_GETDATA_RETURN_OK;
	}
#endif
	XML_DefaultFormat(ETHCAM_CMD_GET_TX_MOVIE_RAW_ENCODE, ETHCAM_RET_OK, bufAddr, bufSize, mimeType);
	return ETHCAM_CMD_GETDATA_RETURN_OK;
}
int EthCam_GetMovieRecInfo(char *path, char *argument, HFS_U32 bufAddr, HFS_U32 *bufSize, char *mimeType, HFS_U32 segmentCount)
{
#if(defined(_NVT_ETHREARCAM_TX_))
	MOVIE_RECODE_INFO MovieRecordInfo=MovieExe_GetRecInfo(_CFG_REC_ID_1);
	MOVIEMULTI_ETHCAM_REC_INFO EthCamRecInfo={0};
	EthCamRecInfo.width = MovieRecordInfo.size.w;
	EthCamRecInfo.height = MovieRecordInfo.size.h;
	EthCamRecInfo.vfr = MovieRecordInfo.frame_rate;
	EthCamRecInfo.tbr = MovieRecordInfo.target_bitrate;
	EthCamRecInfo.ar = MovieRecordInfo.dar;
	EthCamRecInfo.gop = MovieRecordInfo.cbr_info.uiGOP;
	EthCamRecInfo.codec = MovieRecordInfo.codec;
	EthCamRecInfo.aud_codec = MovieRecordInfo.aud_codec;
	EthCamRecInfo.rec_mode = MovieRecordInfo.rec_mode;
	EthCamRecInfo.rec_format = MovieRecordInfo.file_format;

	DBG_ERR("Rec codec=%d\r\n",MovieRecordInfo.codec);


	UINT32 list_value[sizeof(MOVIEMULTI_ETHCAM_REC_INFO)/sizeof(UINT32)];
	UINT32 list_total_cnt=sizeof(MOVIEMULTI_ETHCAM_REC_INFO)/sizeof(UINT32);
	UINT32 *pBuf;
	pBuf=(UINT32 *)&EthCamRecInfo;

	UINT32 i;
	DBG_DUMP("MovieRecordInfo=\r\n");
	for(i=0;i<list_total_cnt;i++){
		list_value[i]=pBuf[i];
		DBG_DUMP("0x%x, ", pBuf[i]);
	}
	DBG_DUMP("\r\n");
	XML_ListResult(ETHCAM_CMD_GET_TX_REC_INFO, list_value, list_total_cnt,  bufAddr, bufSize, mimeType);
#endif
	return ETHCAM_CMD_GETDATA_RETURN_OK;
}
int EthCam_GetMovieDecInfo(char *path, char *argument, HFS_U32 bufAddr, HFS_U32 *bufSize, char *mimeType, HFS_U32 segmentCount)
{
#if(defined(_NVT_ETHREARCAM_TX_))
	ETHCAM_TX_DEC_INFO MovieDecInfo={0};
	ETHCAM_PATH_ID path_id;
	ETHCAM_PORT_TYPE port_type;
	MOVIE_CFG_REC_ID RecId;
	EthCam_GetDest(path, &path_id, &port_type);
	if(port_type==ETHCAM_PORT_DATA1){
		RecId=_CFG_REC_ID_1;
	}else{
		RecId=_CFG_CLONE_ID_1;
	}
	MovieDecInfo.bStarupOK=0;
	#if (ETHCAM_TX_DISPLAY_FLIP == DISABLE)
	MovieDecInfo.Flip=0;
	#else
	MovieDecInfo.Flip=1;
	#endif
	MovieDecInfo.Tbr=MovieExe_GetTBR(RecId);
	MovieDecInfo.Fps=MovieExe_GetFps(RecId);
	MovieDecInfo.Width=MovieExe_GetWidth(RecId);
	MovieDecInfo.Height=MovieExe_GetHeight(RecId);
	MovieDecInfo.Gop=MovieExe_GetGOP(RecId);
	MovieDecInfo.Codec=MovieExe_GetCodec(RecId);
	DBG_ERR("Dec codec=%d, %d, %d\r\n",MovieDecInfo.Codec,MovieExe_GetCodec(_CFG_REC_ID_1),MovieExe_GetCodec(_CFG_CLONE_ID_1));

	UINT32 list_value[sizeof(ETHCAM_TX_DEC_INFO)/sizeof(UINT32)];
	UINT32 list_total_cnt=8;//sizeof(ETHCAM_TX_DEC_INFO)/sizeof(UINT32);
	UINT32 *pBuf;
	pBuf=(UINT32 *)&MovieDecInfo;

	UINT32 i;
	DBG_DUMP("MovieDecInfo=\r\n");
	for(i=0;i<list_total_cnt;i++){
		list_value[i]=pBuf[i];
		DBG_DUMP("0x%x, ", pBuf[i]);
	}
	DBG_DUMP("\r\n");
	XML_ListResult(ETHCAM_CMD_GET_TX_DEC_INFO, list_value, list_total_cnt,  bufAddr, bufSize, mimeType);
#endif
	return ETHCAM_CMD_GETDATA_RETURN_OK;
}
int EthCam_TxRtspStart(char *path, char *argument, HFS_U32 bufAddr, HFS_U32 *bufSize, char *mimeType, HFS_U32 segmentCount)
{
#if(defined(_NVT_ETHREARCAM_TX_))
	MsdcNvtCb_Net(TRUE);

	UINet_RtspInit();
	Ux_SendEvent(&CustomMovieObjCtrl, NVTEVT_EXE_MOVIE_STRM_START, 0);
#endif
	XML_DefaultFormat(ETHCAM_CMD_TX_RTSP_START, ETHCAM_RET_OK, bufAddr, bufSize, mimeType);
	return ETHCAM_CMD_GETDATA_RETURN_OK;
}
int EthCam_SyncTime(char *path, char *argument, HFS_U32 bufAddr, HFS_U32 *bufSize, char *mimeType, HFS_U32 segmentCount)
{
#if(defined(_NVT_ETHREARCAM_TX_))
	if (argument && segmentCount==0) {
		XML_DefaultFormat(ETHCAM_CMD_SYNC_TIME, ETHCAM_RET_CONTINUE, bufAddr, bufSize, mimeType);
		return ETHCAM_CMD_GETDATA_RETURN_CONTINUE;
	}else{
		struct tm Curr_DateTime;// =(struct tm)bufAddr;
		memcpy((UINT8*)&Curr_DateTime, (UINT8*)bufAddr, sizeof(struct tm));
		DBG_DUMP("year=%d,mon=%d,day=%d,hour=%d,min=%d,sec=%d\r\n", Curr_DateTime.tm_year,Curr_DateTime.tm_mon,Curr_DateTime.tm_mday,Curr_DateTime.tm_hour,Curr_DateTime.tm_min,Curr_DateTime.tm_sec);
		HwClock_SetTime(TIME_ID_CURRENT, Curr_DateTime, 0);
	}
#endif
	XML_DefaultFormat(ETHCAM_CMD_SYNC_TIME, ETHCAM_RET_OK, bufAddr, bufSize, mimeType);
	return ETHCAM_CMD_GETDATA_RETURN_OK;
}
int EthCam_SyncMenuSetting(char *path, char *argument, HFS_U32 bufAddr, HFS_U32 *bufSize, char *mimeType, HFS_U32 segmentCount)
{
#if(defined(_NVT_ETHREARCAM_TX_))
	char  *pch = 0;
	static UINT32 bChgMode = 0;
	if (argument && segmentCount==0) {
		if ((pch = strchr(argument + strlen(CMD_STR), '&')) !=0) {
			if (strncmp(pch, PAR_STR, strlen(PAR_STR)) == 0) {
				sscanf_s(pch + strlen(PAR_STR), "%d", &bChgMode);
			}
		}
		DBG_DUMP("bChgMode=%d\r\n", bChgMode);
		XML_DefaultFormat(ETHCAM_CMD_SYNC_MENU_SETTING, ETHCAM_RET_CONTINUE, bufAddr, bufSize, mimeType);
		return ETHCAM_CMD_GETDATA_RETURN_CONTINUE;
	}else{
		ETHCAM_MENU_SETTING sEthCamMenuSetting={0};
		BOOL bReOpen = 0;
		memcpy((UINT8*)&sEthCamMenuSetting, (UINT8*)bufAddr, sizeof(ETHCAM_MENU_SETTING));
		DBG_DUMP("1size=%d,WDR=%d,EV=%d,DateImprint=%d,SensorRotate=%d,Codec=%d,TimeLapse=%d\r\n", sEthCamMenuSetting.Size,sEthCamMenuSetting.WDR,sEthCamMenuSetting.EV,sEthCamMenuSetting.DateImprint,sEthCamMenuSetting.SensorRotate,sEthCamMenuSetting.Codec,sEthCamMenuSetting.TimeLapse);

		DBG_DUMP("2size=%d,WDR=%d,EV=%d,DateImprint=%d,SensorRotate=%d,Codec=%d,TimeLapse=%d\r\n", UI_GetData(FL_MOVIE_SIZE),UI_GetData(FL_MOVIE_WDR),UI_GetData(FL_EV),UI_GetData(FL_MOVIE_DATEIMPRINT),UI_GetData(FL_MOVIE_SENSOR_ROTATE),UI_GetData(FL_MOVIE_CODEC),UI_GetData(FL_MOVIE_TIMELAPSE_REC));
		#if 0
		if(sEthCamMenuSetting.Size != UI_GetData(FL_MOVIE_SIZE)){
			//UI_SetData(FL_MOVIE_SIZE, sEthCamMenuSetting.Size);
			bReOpen=1;
		}
		#endif
		if(sEthCamMenuSetting.WDR != UI_GetData(FL_MOVIE_WDR)){
			UI_SetData(FL_MOVIE_WDR, sEthCamMenuSetting.WDR);
			bReOpen=1;
		}
		if(sEthCamMenuSetting.EV != UI_GetData(FL_EV)){
			UI_SetData(FL_EV, sEthCamMenuSetting.EV);
			Ux_SendEvent(&CustomMovieObjCtrl, NVTEVT_EXE_MOVIE_EV, 1, UI_GetData(FL_EV));
		}
		if(sEthCamMenuSetting.DateImprint != UI_GetData(FL_MOVIE_DATEIMPRINT)){
			UI_SetData(FL_MOVIE_DATEIMPRINT, sEthCamMenuSetting.DateImprint);
			MovieExe_EthCamTxDateStampConfig();
		}
		if(sEthCamMenuSetting.SensorRotate != UI_GetData(FL_MOVIE_SENSOR_ROTATE)){
			UI_SetData(FL_MOVIE_SENSOR_ROTATE, sEthCamMenuSetting.SensorRotate);
			Ux_SendEvent(&CustomMovieObjCtrl, NVTEVT_EXE_MOVIE_SENSOR_ROTATE, 1, UI_GetData(FL_MOVIE_SENSOR_ROTATE));
			ImageApp_MovieMulti_ResetIFrame(_CFG_REC_ID_1);
			MovieExe_EthCamRecId1_ResetBsQ();
		}
		//if(sEthCamMenuSetting.Codec != UI_GetData(FL_MOVIE_CODEC)){
		if(sEthCamMenuSetting.Codec != sEthCamSysInfo.VCodec){
			UI_SetData(FL_MOVIE_CODEC, sEthCamMenuSetting.Codec);
			sEthCamSysInfo.VCodec=sEthCamMenuSetting.Codec;
			//Ux_SendEvent(&CustomMovieObjCtrl,   NVTEVT_EXE_MOVIE_CODEC,         1,  UI_GetData(FL_MOVIE_CODEC));
			bReOpen=1;
		}
		if(sEthCamMenuSetting.TimeLapse != UI_GetData(FL_MOVIE_TIMELAPSE_REC)){
			UI_SetData(FL_MOVIE_TIMELAPSE_REC, sEthCamMenuSetting.TimeLapse);
			bReOpen=1;
		}


		DBG_DUMP("bReOpen=%d, bChgMode=%d\r\n", bReOpen,bChgMode);

		XML_DefaultFormat(ETHCAM_CMD_SYNC_MENU_SETTING, ETHCAM_RET_OK, bufAddr, bufSize, mimeType);

		//if(bReOpen || bChgMode){
		if(bChgMode){
			Ux_PostEvent(NVTEVT_SYSTEM_MODE, 1, System_GetState(SYS_STATE_CURRMODE));
		}
	}
#endif
	//XML_DefaultFormat(ETHCAM_CMD_SYNC_MENU_SETTING, ETHCAM_RET_OK, bufAddr, bufSize, mimeType);
	return ETHCAM_CMD_GETDATA_RETURN_OK;
}
int EthCam_TxResetI(char *path, char *argument, HFS_U32 bufAddr, HFS_U32 *bufSize, char *mimeType, HFS_U32 segmentCount)
{
#if(defined(_NVT_ETHREARCAM_TX_))
	ETHCAM_PATH_ID path_id;
	ETHCAM_PORT_TYPE port_type;
	EthCam_GetDest(path, &path_id, &port_type);

	if(port_type==ETHCAM_PORT_DATA1){
		ImageApp_MovieMulti_ResetIFrame(_CFG_REC_ID_1);
	}else{
		ImageApp_MovieMulti_ResetIFrame(_CFG_CLONE_ID_1);
	}
#endif
	XML_DefaultFormat(ETHCAM_CMD_TX_RESET_I, ETHCAM_RET_OK, bufAddr, bufSize, mimeType);
	return ETHCAM_CMD_GETDATA_RETURN_OK;
}
int EthCam_TxResetQueue(char *path, char *argument, HFS_U32 bufAddr, HFS_U32 *bufSize, char *mimeType, HFS_U32 segmentCount)
{
#if(defined(_NVT_ETHREARCAM_TX_))

	MovieExe_EthCamRecId1_ResetBsQ();
#endif
	XML_DefaultFormat(ETHCAM_CMD_TX_RESET_QUEUE, ETHCAM_RET_OK, bufAddr, bufSize, mimeType);
	return ETHCAM_CMD_GETDATA_RETURN_OK;
}
int EthCam_TxPowerOff(char *path, char *argument, HFS_U32 bufAddr, HFS_U32 *bufSize, char *mimeType, HFS_U32 segmentCount)
{
#if(defined(_NVT_ETHREARCAM_TX_))

	Ux_PostEvent(NVTEVT_SYSTEM_SHUTDOWN, 1, 0);
#endif
	XML_DefaultFormat(ETHCAM_CMD_TX_POWEROFF, ETHCAM_RET_OK, bufAddr, bufSize, mimeType);
	return ETHCAM_CMD_GETDATA_RETURN_OK;
}
int EthCam_TxFWVersion(char *path, char *argument, HFS_U32 bufAddr, HFS_U32 *bufSize, char *mimeType, HFS_U32 segmentCount)
{
#if(defined(_NVT_ETHREARCAM_TX_))
	ETHCAM_PATH_ID path_id;
	ETHCAM_PORT_TYPE port_type;
	char FWVersion[ETHCAM_PATH_ID_MAX][30]={"2019-12-12-Ver1.00","2019-12-12-Ver1.02"};
	EthCam_GetDest(path, &path_id, &port_type);
	XML_StringResult(ETHCAM_CMD_TX_FW_VERSION, FWVersion[path_id], bufAddr, bufSize, mimeType);
#endif

	return ETHCAM_CMD_GETDATA_RETURN_OK;
}
int EthCam_SetTxIPReset(char *path, char *argument, HFS_U32 bufAddr, HFS_U32 *bufSize, char *mimeType, HFS_U32 segmentCount)
{
#if(defined(_NVT_ETHREARCAM_TX_))

	SysSetFlag(FL_ETHCAM_TX_IP_ADDR, 0);

#endif
	XML_DefaultFormat(ETHCAM_CMD_SET_TX_IP_RESET, ETHCAM_RET_OK, bufAddr, bufSize, mimeType);
	return ETHCAM_CMD_GETDATA_RETURN_OK;
}

int EthCam_SetTxSysInfo(char *path, char *argument, HFS_U32 bufAddr, HFS_U32 *bufSize, char *mimeType, HFS_U32 segmentCount)
{
#if(defined(_NVT_ETHREARCAM_TX_))
	if (argument && segmentCount==0) {
		XML_DefaultFormat(ETHCAM_CMD_SET_TX_SYS_INFO, ETHCAM_RET_CONTINUE, bufAddr, bufSize, mimeType);
		return ETHCAM_CMD_GETDATA_RETURN_CONTI_NEED_ACKDATA;
	}else{
		ETHCAM_TX_SYS_INFO SysInfo;
		memcpy((UINT8*)&SysInfo, (UINT8*)bufAddr, sizeof(ETHCAM_TX_SYS_INFO));
		DBG_DUMP("PullModeEn=%d, CloneDisplayPathEn=%d, VCode=%d, SrcType=%d\r\n", SysInfo.PullModeEn,SysInfo.CloneDisplayPathEn,SysInfo.VCodec,SysInfo.SrcType);
		sEthCamSysInfo.PullModeEn=SysInfo.PullModeEn;
		sEthCamSysInfo.CloneDisplayPathEn=SysInfo.CloneDisplayPathEn;
		sEthCamSysInfo.VCodec=SysInfo.VCodec;
		sEthCamSysInfo.SrcType=SysInfo.SrcType;

		if (System_GetState(SYS_STATE_CURRMODE) == PRIMARY_MODE_MOVIE || System_GetState(SYS_STATE_NEXTMODE) == PRIMARY_MODE_MOVIE) {
			Ux_SendEvent(&CustomMovieObjCtrl,   NVTEVT_EXE_MOVIE_CODEC,         1,  SysInfo.VCodec);
		}

		if(sEthCamSysInfo.SrcType==ETHCAM_TX_SYS_SRCTYPE_57){
			ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1, MOVIEMULTI_PARAM_VDOENC_UIPRJMODE, 0x57500000);
			ImageApp_MovieMulti_SetParam(_CFG_CLONE_ID_1, MOVIEMULTI_PARAM_VDOENC_UIPRJMODE, 0x57500000);
	}
	}

	DBG_DUMP("sizeof(ETHCAM_TX_SYS_INFO)=%d\r\n", sizeof(ETHCAM_TX_SYS_INFO));
	if((sEthCamSysInfo.PullModeEn>=0 && sEthCamSysInfo.PullModeEn<=1)
		&& (sEthCamSysInfo.CloneDisplayPathEn>=0 && sEthCamSysInfo.CloneDisplayPathEn<=1)
		&& (sEthCamSysInfo.VCodec>=MOVIE_CODEC_H264 && sEthCamSysInfo.VCodec<=MOVIE_CODEC_H265)
		&& (sEthCamSysInfo.SrcType>=ETHCAM_TX_SYS_SRCTYPE_67 && sEthCamSysInfo.SrcType<=ETHCAM_TX_SYS_SRCTYPE_68)){
	XML_ValueResult(ETHCAM_CMD_SET_TX_SYS_INFO, sizeof(ETHCAM_TX_SYS_INFO), bufAddr, bufSize, mimeType);
	}else{
		XML_ValueResult(ETHCAM_CMD_SET_TX_SYS_INFO, 0, bufAddr, bufSize, mimeType);
	}
#endif
	//XML_DefaultFormat(ETHCAM_CMD_SET_TX_SYS_INFO, ETHCAM_RET_OK, bufAddr, bufSize, mimeType);
	return ETHCAM_CMD_GETDATA_RETURN_OK;
}
int EthCam_DumpTxBsInfo(char *path, char *argument, HFS_U32 bufAddr, HFS_U32 *bufSize, char *mimeType, HFS_U32 segmentCount)
{
#if(defined(_NVT_ETHREARCAM_TX_))
	ImageApp_MovieMulti_EthCamTxRecId1_DumpBsInfo();
	ImageApp_MovieMulti_EthCamTxCloneId1_DumpBsInfo();
#endif
	XML_DefaultFormat(ETHCAM_CMD_DUMP_TX_BS_INFO, ETHCAM_RET_OK, bufAddr, bufSize, mimeType);
	return ETHCAM_CMD_GETDATA_RETURN_OK;
}

int EthCam_TxFwUpdate(char *path, char *argument, HFS_U32 bufAddr, HFS_U32 *bufSize, char *mimeType, HFS_U32 segmentCount)
{
#if(defined(_NVT_ETHREARCAM_TX_))
	//UINT32 uiWorkAddr, uiWorkSize;
	static UINT32 uiFwAddr=0, uiFwSize=0;
	static UINT32 uiRecvFwSize=0;
	char  *pch = 0;
	static UINT32 FwSendStart=0;
	DBG_IND("path =%s, argument = %s, bufAddr = 0x%x, bufSize =0x%x , segmentCount  =%d , putStatus = %d\r\n", path, argument, bufAddr, bufSize, segmentCount);
	//FWSRV_CMD FwSrvCmd = {0};

	UINT32 cmd = 0, par = 0;

	if (argument && segmentCount==0) {
		if (strncmp(argument, CMD_STR, strlen(CMD_STR)) == 0) {
			sscanf_s(argument+ strlen(CMD_STR), "%d", &cmd);
			DBG_DUMP("Recv cmd=%d\r\n",cmd);
		}
		pch = strchr(argument + strlen(CMD_STR), '&');
		if (pch) {
			if (strncmp(pch, PAR_STR, strlen(PAR_STR)) == 0) {
				sscanf_s(pch + strlen(PAR_STR), "%d", &par);
			}
		}
		if(cmd==ETHCAM_CMD_TX_FWUPDATE_FWSEND){
			if(uiFwSize==0){
				System_ChangeSubMode(SYS_SUBMODE_UPDFW);
				Ux_SendEvent(0, NVTEVT_SYSTEM_MODE, 1, PRIMARY_MODE_UPDFW);
				//uiFwAddr=EthCam_GetTxFwUpdateBufAddr(uiFwSize);
				uiFwAddr = OS_GetMempoolAddr(POOL_ID_APP);
			}
			uiFwSize=par;
			DBG_DUMP("Total FwSize=%d\r\n",uiFwSize);
			if(uiFwSize==0){
				DBG_ERR("uiFwSize Error ,uiFwSize=%d\r\n",uiFwSize);
			}

			if(uiFwSize!=0 && uiRecvFwSize < uiFwSize){
				DBG_DUMP("FWSEND Start\r\n");
				FwSendStart=1;
				XML_DefaultFormat(cmd, ETHCAM_RET_CONTINUE, bufAddr, bufSize, mimeType);
				return ETHCAM_CMD_GETDATA_RETURN_CONTINUE;
			}else{
				DBG_ERR("uiFwSize Error ,TotalSz=%d, RecvSz=%d\r\n",uiFwSize,uiRecvFwSize);
				XML_DefaultFormat(cmd, ETHCAM_RET_ERR, bufAddr, bufSize, mimeType);
				return CYG_HFS_CB_GETDATA_RETURN_ERROR;
			}
		}else if(cmd==ETHCAM_CMD_TX_FWUPDATE_START){

			DBG_DUMP("FWUPDATE_START\r\n");
			sEthCamFwUd.FwAddr=uiFwAddr;
			sEthCamFwUd.FwSize=uiFwSize;
			sEthCamFwUd.cmd=ETHCAM_CMD_TX_FWUPDATE_START;
			EthCam_GetDest(path, &sEthCamFwUd.path_id, &sEthCamFwUd.port_type);
			BKG_PostEvent(NVTEVT_BKW_FW_UPDATE);
			XML_DefaultFormat(cmd, ETHCAM_RET_CONTINUE, bufAddr, bufSize, mimeType);
			return ETHCAM_CMD_GETDATA_RETURN_OK;//CYG_HFS_CB_GETDATA_RETURN_OK;
		}else{
			DBG_ERR("argument=%s\r\n",argument);
			return CYG_HFS_CB_GETDATA_RETURN_ERROR;
		}
	}else{
		if(FwSendStart){
			if(uiFwSize!=0 && uiRecvFwSize < uiFwSize){
				hwmem_open();
				hwmem_memcpy((UINT32)(uiFwAddr + uiRecvFwSize), bufAddr, *bufSize);
				hwmem_close();
				uiRecvFwSize+=*bufSize;
				DBG_IND("RecvFwSize=%d, TotalFwSize=%d\r\n",uiRecvFwSize,uiFwSize);
#if 0 //write to card
				char path[30];
				sprintf(path, "A:\\TX_RecvFw.bin");
				DBG_DUMP("TX_RecvFw: %s\r\n", path);

				static  FST_FILE fhdl = 0;
				UINT32      fileSize = 0;

				if(fhdl==0){
					fhdl = FileSys_OpenFile(path, FST_CREATE_ALWAYS | FST_OPEN_WRITE);
					FileSys_SeekFile(fhdl, 0, FST_SEEK_SET);
				}else{
					FileSys_SeekFile(fhdl, 0, FST_SEEK_END);
				}
				fileSize = *bufSize;
				FileSys_WriteFile(fhdl, (UINT8 *)bufAddr, &fileSize, 0, NULL);
				if(uiRecvFwSize>=uiFwSize){
					DBG_DUMP("Write Finish!\r\n");
					FileSys_CloseFile(fhdl);
					fhdl = 0;
				}
#endif
				if(uiRecvFwSize>=uiFwSize){
					DBG_DUMP("Fw Recv Finish! RecvFwSize=%d, TotalFwSize=%d\r\n",uiRecvFwSize,uiFwSize);
					FwSendStart=0;
					XML_DefaultFormat(ETHCAM_CMD_TX_FWUPDATE_FWSEND, ETHCAM_RET_OK, bufAddr, bufSize, mimeType);
					return ETHCAM_CMD_GETDATA_RETURN_OK;
				}else{
					//XML_DefaultFormat(ETHCAM_CMD_TX_FWUPDATE_FWSEND, ETHCAM_RET_CONTINUE, bufAddr, bufSize, mimeType);
					return ETHCAM_CMD_GETDATA_RETURN_CONTINUE;
				}
			}else{
				DBG_ERR("argument=%s\r\n",argument);

#if 0
				// verify firmware
				FWSRV_VERIFY_FW Verify = {0};
				Verify.Buf.uiAddr = uiFwAddr;
				Verify.Buf.uiSize = uiFwSize;
				FwSrvCmd.Idx = FWSRV_CMD_IDX_VERIFY_FW;
				FwSrvCmd.In.pData = &Verify;
				FwSrvCmd.In.uiNumByte = sizeof(Verify);
				FwSrvCmd.Prop.bExitCmdFinish = TRUE;
				if (FwSrv_Cmd(&FwSrvCmd) != FWSRV_ER_OK) {
					DBG_ERR("check sum failed.\r\n");
					return CYG_HFS_CB_GETDATA_RETURN_ERROR;
				}
#endif

				return CYG_HFS_CB_GETDATA_RETURN_ERROR;
			}
		}
	}
#endif
	return ETHCAM_CMD_GETDATA_RETURN_OK;
}
int EthCam_GetFrame(char *path, char *argument, HFS_U32 bufAddr, HFS_U32 *bufSize, char *mimeType, HFS_U32 segmentCount)
{
#if(defined(_NVT_ETHREARCAM_TX_))
	set_flg(ETHCAM_CMD_RCV_FLG_ID,FLG_ETHCAM_CMD_RCV);
	EthCamNet_SetTxHB(0);
	//XML_DefaultFormat(ETHCAM_CMD_GET_FRAME, ETHCAM_CMD_GETDATA_RETURN_WAIT, bufAddr, bufSize, mimeType);
#endif
	return ETHCAM_CMD_GETDATA_RETURN_WAIT;
}
int EthCam_TxDispCropSet(char *path, char *argument, HFS_U32 bufAddr, HFS_U32 *bufSize, char *mimeType, HFS_U32 segmentCount)
{
#if(defined(_NVT_ETHREARCAM_TX_))
	if (argument && segmentCount==0) {
		XML_DefaultFormat(ETHCAM_CMD_TX_DISP_CROP, ETHCAM_RET_CONTINUE, bufAddr, bufSize, mimeType);
		return ETHCAM_CMD_GETDATA_RETURN_CONTINUE;
	}else{
		MOVIEMULTI_IME_CROP_INFO CropInfo={0};
		memcpy((UINT8*)&CropInfo, (UINT8*)bufAddr, sizeof(MOVIEMULTI_IME_CROP_INFO));
		DBG_DUMP("CropSize w=%d, h=%d, CropWin x=%d,y=%d,w=%d,h=%d\r\n", CropInfo.IMESize.w,CropInfo.IMESize.h,CropInfo.IMEWin.x,CropInfo.IMEWin.y,CropInfo.IMEWin.w,CropInfo.IMEWin.h);
		ImageApp_MovieMulti_SetParam(_CFG_REC_ID_1, MOVIEMULTI_PARAM_ETHCAM_IME_CROP, (UINT32)&CropInfo);
	}
#endif
	XML_DefaultFormat(ETHCAM_CMD_TX_DISP_CROP, ETHCAM_RET_OK, bufAddr, bufSize, mimeType);

	return CYG_HFS_CB_GETDATA_RETURN_OK;
}

int EthCam_ChangeMode(char *path, char *argument, HFS_U32 bufAddr, HFS_U32 *bufSize, char *mimeType, HFS_U32 segmentCount)
{
#if(defined(_NVT_ETHREARCAM_TX_))
	Ux_PostEvent(NVTEVT_SYSTEM_MODE, 1, System_GetState(SYS_STATE_CURRMODE));
#endif
	XML_DefaultFormat(ETHCAM_CMD_CHANGE_MODE, ETHCAM_RET_OK, bufAddr, bufSize, mimeType);
	return ETHCAM_CMD_GETDATA_RETURN_OK;
}
int EthCam_IperfTest(char *path, char *argument, HFS_U32 bufAddr, HFS_U32 *bufSize, char *mimeType, HFS_U32 segmentCount)
{
#if(defined(_NVT_ETHREARCAM_TX_))
#endif
	XML_DefaultFormat(ETHCAM_CMD_IPERF_TEST, ETHCAM_RET_OK, bufAddr, bufSize, mimeType);
	return ETHCAM_CMD_GETDATA_RETURN_OK;
}

//======================XML Cmd Result CB Satrt======================
void EthCam_Startup_CB(INT32 bEnd, void *output_data)
{
	ETHCAM_XML_DEFAULT_FORMAT *output=(ETHCAM_XML_DEFAULT_FORMAT*)output_data;
	DBG_IND("bEnd=%d, cmd=%d, status=%d\r\n",bEnd,output->cmd, output->status);
	if(output->status == ETHCAM_RET_OK){
		DBG_DUMP("Startup OK\r\n");
		sEthCamTxDecInfo[output->path_id].bStarupOK=1;
	}
}
void EthCam_MovieTBR_CB(INT32 bEnd, void *output_data)
{
	ETHCAM_XML_VALUE_RESULT *output=(ETHCAM_XML_VALUE_RESULT*)output_data;
	DBG_IND("bEnd=%d, cmd=%d, status=%d, value=%d\r\n",bEnd,output->cmd, output->status,output->value);
	DBG_IND("Tx TBR=%d\r\n",output->value);
	DBG_IND("path_id=%d, port_type=%d\r\n",output->path_id,output->port_type);

	sEthCamTxDecInfo[output->path_id].Tbr=output->value;
}
void EthCam_MovieFps_CB(INT32 bEnd, void *output_data)
{
	ETHCAM_XML_VALUE_RESULT *output=(ETHCAM_XML_VALUE_RESULT*)output_data;
	DBG_IND("bEnd=%d, cmd=%d, status=%d, value=%d\r\n",bEnd,output->cmd, output->status,output->value);
	DBG_IND("Tx Fps=%d\r\n",output->value);
	sEthCamTxDecInfo[output->path_id].Fps=output->value;
}
void EthCam_MovieGOP_CB(INT32 bEnd, void *output_data)
{
	ETHCAM_XML_VALUE_RESULT *output=(ETHCAM_XML_VALUE_RESULT*)output_data;
	DBG_IND("bEnd=%d, cmd=%d, status=%d, value=%d\r\n",bEnd,output->cmd, output->status,output->value);
	DBG_IND("Tx GOP=%d\r\n",output->value);
	sEthCamTxDecInfo[output->path_id].Gop=output->value;
}
void EthCam_MovieCodec_CB(INT32 bEnd, void *output_data)
{
	ETHCAM_XML_VALUE_RESULT *output=(ETHCAM_XML_VALUE_RESULT*)output_data;
	DBG_IND("bEnd=%d, cmd=%d, status=%d, value=%d\r\n",bEnd,output->cmd, output->status,output->value);
	DBG_IND("Tx Codec=%d\r\n",output->value);
	sEthCamTxDecInfo[output->path_id].Codec=output->value;
}

void EthCam_MovieRecSize_CB(INT32 bEnd, void *output_data)
{
	ETHCAM_XML_LIST *output=(ETHCAM_XML_LIST*)output_data;
	DBG_IND("bEnd=%d, cmd=%d, total_item_cnt=%d\r\n",bEnd,output->cmd, output->total_item_cnt);
	if(output->total_item_cnt==2){
		DBG_IND("Tx Width=%d, Height=%d\r\n",output->item[0], output->item[1]);
		sEthCamTxDecInfo[output->path_id].Width=output->item[0];
		sEthCamTxDecInfo[output->path_id].Height=output->item[1];
	}
}
/*
	H264_NALU_TYPE_SPS = 7,
	H264_NALU_TYPE_PPS = 8,

	H265_NALU_TYPE_VPS = 32,
	H265_NALU_TYPE_SPS = 33,
	H265_NALU_TYPE_PPS = 34,
*/
void EthCam_MovieSPS_PPS_CB(INT32 bEnd, void *output_data)
{
	ETHCAM_XML_LIST *output=(ETHCAM_XML_LIST*)output_data;
	UINT32 i;
	DBG_IND("bEnd=%d, cmd=%d, total_item_cnt=%d\r\n",bEnd,output->cmd, output->total_item_cnt);
	#if (ETH_REARCAM_CLONE_FOR_DISPLAY == ENABLE)
	if(output->port_type == ETHCAM_PORT_DATA1){
		sEthCamTxRecInfo[output->path_id].DescSize=output->total_item_cnt;
		//memcpy(sEthCamTxInfo.Desc,output->item,  output->total_item_cnt);
		DBG_IND("Rec Tx SPS[%d]= {",output->total_item_cnt);
		sEthCamTxRecInfo[output->path_id].SPSSize=0;
		sEthCamTxRecInfo[output->path_id].PPSSize=0;
		sEthCamTxRecInfo[output->path_id].VPSSize=0;
		if(sEthCamTxRecInfo[output->path_id].codec == HD_CODEC_TYPE_H264){//MEDIAVIDENC_H264){
			for(i=0;i<output->total_item_cnt;i++){
				sEthCamTxRecInfo[output->path_id].Desc[i]=output->item[i];
				if(sEthCamTxRecInfo[output->path_id].SPSSize==0 && output->item[i] ==0  && output->item[i+1] ==0 && output->item[i+2] ==0 && output->item[i+3] ==1 && (output->item[i+4] & 0x1F) == 0x8){
					sEthCamTxRecInfo[output->path_id].SPSSize=i;
				}
				DBG_IND("0x%x, ",output->item[i]);
			}
			DBG_IND("}\r\n");
			sEthCamTxRecInfo[output->path_id].PPSSize=output->total_item_cnt-sEthCamTxRecInfo[output->path_id].SPSSize;
		}else{
			for(i=0;i<output->total_item_cnt;i++){
				sEthCamTxRecInfo[output->path_id].Desc[i]=output->item[i];
				if(sEthCamTxRecInfo[output->path_id].VPSSize==0 && output->item[i] ==0  && output->item[i+1] ==0 && output->item[i+2] ==0 && output->item[i+3] ==1 && (output->item[i+4] >>0x1) == 33){
					sEthCamTxRecInfo[output->path_id].VPSSize=i;
				}
				if(sEthCamTxRecInfo[output->path_id].SPSSize==0 && output->item[i] ==0  && output->item[i+1] ==0 && output->item[i+2] ==0 && output->item[i+3] ==1 && (output->item[i+4] >>0x1) == 34){
					sEthCamTxRecInfo[output->path_id].SPSSize=i-sEthCamTxRecInfo[output->path_id].VPSSize;
				}
				DBG_IND("0x%x, ",output->item[i]);
			}
			DBG_IND("}\r\n");
			sEthCamTxRecInfo[output->path_id].PPSSize=output->total_item_cnt-sEthCamTxRecInfo[output->path_id].VPSSize-sEthCamTxRecInfo[output->path_id].SPSSize;
		}
		DBG_DUMP("Rec SPSSize=%d, PPSSize=%d, VPSSize=%d\r\n",sEthCamTxRecInfo[output->path_id].SPSSize, sEthCamTxRecInfo[output->path_id].PPSSize,sEthCamTxRecInfo[output->path_id].VPSSize);

	}else if(output->port_type == ETHCAM_PORT_DATA2){
		sEthCamTxDecInfo[output->path_id].DescSize=output->total_item_cnt;
		//memcpy(sEthCamTxInfo.Desc,output->item,  output->total_item_cnt);
		DBG_IND("Dec Tx SPS[%d]= {",output->total_item_cnt);
		sEthCamTxDecInfo[output->path_id].SPSSize=0;
		sEthCamTxDecInfo[output->path_id].PPSSize=0;
		sEthCamTxDecInfo[output->path_id].VPSSize=0;
		if(sEthCamTxDecInfo[output->path_id].Codec == HD_CODEC_TYPE_H264){//MEDIAVIDENC_H264){
			for(i=0;i<output->total_item_cnt;i++){
				sEthCamTxDecInfo[output->path_id].Desc[i]=output->item[i];
				if(sEthCamTxDecInfo[output->path_id].SPSSize==0 && output->item[i] ==0  && output->item[i+1] ==0 && output->item[i+2] ==0 && output->item[i+3] ==1 && (output->item[i+4] & 0x1F) == 0x8){
					sEthCamTxDecInfo[output->path_id].SPSSize=i;
				}
				DBG_IND("0x%x, ",output->item[i]);
			}
			DBG_IND("}\r\n");
			sEthCamTxDecInfo[output->path_id].PPSSize=output->total_item_cnt-sEthCamTxDecInfo[output->path_id].SPSSize;
		}else{
			for(i=0;i<output->total_item_cnt;i++){
				sEthCamTxDecInfo[output->path_id].Desc[i]=output->item[i];
				if(sEthCamTxDecInfo[output->path_id].VPSSize==0 && output->item[i] ==0  && output->item[i+1] ==0 && output->item[i+2] ==0 && output->item[i+3] ==1 && (output->item[i+4] >>0x1) == 33){
					sEthCamTxDecInfo[output->path_id].VPSSize=i;
				}
				if(sEthCamTxDecInfo[output->path_id].SPSSize==0 && output->item[i] ==0  && output->item[i+1] ==0 && output->item[i+2] ==0 && output->item[i+3] ==1 && (output->item[i+4] >>0x1) == 34){
					sEthCamTxDecInfo[output->path_id].SPSSize=i-sEthCamTxDecInfo[output->path_id].VPSSize;
				}
				DBG_IND("0x%x, ",output->item[i]);
			}
			DBG_IND("}\r\n");
			sEthCamTxDecInfo[output->path_id].PPSSize=output->total_item_cnt-sEthCamTxDecInfo[output->path_id].VPSSize-sEthCamTxDecInfo[output->path_id].SPSSize;
		}
		DBG_DUMP("Dec SPSSize=%d, PPSSize=%d, VPSSize=%d\r\n",sEthCamTxDecInfo[output->path_id].SPSSize, sEthCamTxDecInfo[output->path_id].PPSSize,sEthCamTxDecInfo[output->path_id].VPSSize);

	}
	#else
	DBG_IND("path_id= %d, port_type=%d\r\n",output->path_id,output->port_type);

	sEthCamTxRecInfo[output->path_id].DescSize=output->total_item_cnt;
	//memcpy(sEthCamTxInfo.Desc,output->item,  output->total_item_cnt);
	DBG_IND("Rec Tx SPS[%d]= {",output->total_item_cnt);
	sEthCamTxRecInfo[output->path_id].SPSSize=0;
	sEthCamTxRecInfo[output->path_id].PPSSize=0;
	sEthCamTxRecInfo[output->path_id].VPSSize=0;
	if(sEthCamTxRecInfo[output->path_id].codec == HD_CODEC_TYPE_H264){//MEDIAVIDENC_H264){
		for(i=0;i<output->total_item_cnt;i++){
			sEthCamTxRecInfo[output->path_id].Desc[i]=output->item[i];
				if(sEthCamTxRecInfo[output->path_id].SPSSize==0 && output->item[i] ==0  && output->item[i+1] ==0 && output->item[i+2] ==0 && output->item[i+3] ==1 && (output->item[i+4] & 0x1F) == 0x8){
					sEthCamTxRecInfo[output->path_id].SPSSize=i;
				}
			DBG_IND("0x%x, ",output->item[i]);
		}
		DBG_IND("}\r\n");
		sEthCamTxRecInfo[output->path_id].PPSSize=output->total_item_cnt-sEthCamTxRecInfo[output->path_id].SPSSize;
	}else{
		for(i=0;i<output->total_item_cnt;i++){
			sEthCamTxRecInfo[output->path_id].Desc[i]=output->item[i];
			if(sEthCamTxRecInfo[output->path_id].VPSSize==0 && output->item[i] ==0  && output->item[i+1] ==0 && output->item[i+2] ==0 && output->item[i+3] ==1 && (output->item[i+4] >>0x1) == 33){
				sEthCamTxRecInfo[output->path_id].VPSSize=i;
			}
			if(sEthCamTxRecInfo[output->path_id].SPSSize==0 && output->item[i] ==0  && output->item[i+1] ==0 && output->item[i+2] ==0 && output->item[i+3] ==1 && (output->item[i+4] >>0x1) == 34){
				sEthCamTxRecInfo[output->path_id].SPSSize=i-sEthCamTxRecInfo[output->path_id].VPSSize;
			}
			DBG_IND("0x%x, ",output->item[i]);
		}
		DBG_IND("}\r\n");
		sEthCamTxRecInfo[output->path_id].PPSSize=output->total_item_cnt-sEthCamTxRecInfo[output->path_id].VPSSize-sEthCamTxRecInfo[output->path_id].SPSSize;
	}
	DBG_DUMP("Rec SPSSize=%d, PPSSize=%d, VPSSize=%d\r\n",sEthCamTxRecInfo[output->path_id].SPSSize, sEthCamTxRecInfo[output->path_id].PPSSize,sEthCamTxRecInfo[output->path_id].VPSSize);

	sEthCamTxDecInfo[output->path_id].DescSize=output->total_item_cnt;
	//memcpy(sEthCamTxInfo.Desc,output->item,  output->total_item_cnt);
	DBG_IND("Dec Tx SPS[%d]= {",output->total_item_cnt);
	sEthCamTxDecInfo[output->path_id].SPSSize=0;
	sEthCamTxDecInfo[output->path_id].PPSSize=0;
	sEthCamTxDecInfo[output->path_id].VPSSize=0;
	if(sEthCamTxDecInfo[output->path_id].Codec == HD_CODEC_TYPE_H264){//MEDIAVIDENC_H264){
		for(i=0;i<output->total_item_cnt;i++){
			sEthCamTxDecInfo[output->path_id].Desc[i]=output->item[i];
			if(sEthCamTxDecInfo[output->path_id].SPSSize==0 && output->item[i] ==0  && output->item[i+1] ==0 && output->item[i+2] ==0 && output->item[i+3] ==1 && (output->item[i+4] & 0x1F) == 0x8){
				sEthCamTxDecInfo[output->path_id].SPSSize=i;
			}
			DBG_IND("0x%x, ",output->item[i]);
		}
		DBG_IND("}\r\n");
		sEthCamTxDecInfo[output->path_id].PPSSize=output->total_item_cnt-sEthCamTxDecInfo[output->path_id].SPSSize;
	}else{
		for(i=0;i<output->total_item_cnt;i++){
			sEthCamTxDecInfo[output->path_id].Desc[i]=output->item[i];
			if(sEthCamTxDecInfo[output->path_id].VPSSize==0 && output->item[i] ==0  && output->item[i+1] ==0 && output->item[i+2] ==0 && output->item[i+3] ==1 && (output->item[i+4] >>0x1) == 33){
				sEthCamTxDecInfo[output->path_id].VPSSize=i;
			}
			if(sEthCamTxDecInfo[output->path_id].SPSSize==0 && output->item[i] ==0  && output->item[i+1] ==0 && output->item[i+2] ==0 && output->item[i+3] ==1 && (output->item[i+4] >>0x1) == 34){
				sEthCamTxDecInfo[output->path_id].SPSSize=i-sEthCamTxDecInfo[output->path_id].VPSSize;
			}
			DBG_IND("0x%x, ",output->item[i]);
		}
		DBG_IND("}\r\n");
		sEthCamTxDecInfo[output->path_id].PPSSize=output->total_item_cnt-sEthCamTxDecInfo[output->path_id].VPSSize-sEthCamTxDecInfo[output->path_id].SPSSize;
	}
	DBG_DUMP("Dec SPSSize=%d, PPSSize=%d, VPSSize=%d\r\n",sEthCamTxDecInfo[output->path_id].SPSSize, sEthCamTxDecInfo[output->path_id].PPSSize,sEthCamTxDecInfo[output->path_id].VPSSize);
	#endif
}
void EthCam_MovieThumb_CB(INT32 bEnd, void *output_data)
{
	ETHCAM_XML_DEFAULT_FORMAT *output=(ETHCAM_XML_DEFAULT_FORMAT*)output_data;
	DBG_DUMP("bEnd=%d, cmd=%d, status=%d\r\n",bEnd,output->cmd, output->status);
}

void EthCam_MovieRawEncode_CB(INT32 bEnd, void *output_data)
{
	ETHCAM_XML_DEFAULT_FORMAT *output=(ETHCAM_XML_DEFAULT_FORMAT*)output_data;
	DBG_IND("bEnd=%d, cmd=%d, status=%d\r\n",bEnd,output->cmd, output->status);
	if(output->status == ETHCAM_RET_OK){
		DBG_IND("RawEncode OK\r\n");
 	}else{
		DBG_ERR("RawEncode Fail\r\n");
 	}
}
void EthCam_MovieRecInfo_CB(INT32 bEnd, void *output_data)
{
	ETHCAM_XML_LIST *output=(ETHCAM_XML_LIST*)output_data;
	UINT32 i;
	DBG_IND("MovieRecInfo_CB bEnd=%d, cmd=%d, total_item_cnt=%d\r\n",bEnd,output->cmd, output->total_item_cnt);
	UINT32 *pBuf;
	pBuf=(UINT32 *)&sEthCamTxRecInfo[output->path_id];
	for(i=0;i<output->total_item_cnt;i++){
		pBuf[i]=output->item[i];
	}
	sEthCamTxRecInfo[output->path_id].codec= (sEthCamTxRecInfo[output->path_id].codec == _CFG_CODEC_H265)?HD_CODEC_TYPE_H265:HD_CODEC_TYPE_H264;

	DBG_DUMP("[%d]RecInfo, ar=%d, aud_codec=%d, codec=%d, gop=%d, vfr=%d\r\n",output->path_id,sEthCamTxRecInfo[output->path_id].ar,sEthCamTxRecInfo[output->path_id].aud_codec,sEthCamTxRecInfo[output->path_id].codec,sEthCamTxRecInfo[output->path_id].gop,sEthCamTxRecInfo[output->path_id].vfr);
	DBG_DUMP("[%d]height=%d, rec_format=%d, rec_mode=%d, tbr=%d, width=%d\r\n",output->path_id,sEthCamTxRecInfo[output->path_id].height,sEthCamTxRecInfo[output->path_id].rec_format,sEthCamTxRecInfo[output->path_id].rec_mode,sEthCamTxRecInfo[output->path_id].tbr,sEthCamTxRecInfo[output->path_id].width);
}
void EthCam_MovieDecInfo_CB(INT32 bEnd, void *output_data)
{
	ETHCAM_XML_LIST *output=(ETHCAM_XML_LIST*)output_data;
	UINT32 i;
	DBG_DUMP("MovieDecInfo_CB bEnd=%d, cmd=%d, total_item_cnt=%d\r\n",bEnd,output->cmd, output->total_item_cnt);
	UINT32 *pBuf;
	pBuf=(UINT32 *)&sEthCamTxDecInfo[output->path_id];
	for(i=1;i<output->total_item_cnt;i++){
		pBuf[i]=output->item[i];
	}
	sEthCamTxDecInfo[output->path_id].Codec= (sEthCamTxDecInfo[output->path_id].Codec == _CFG_CODEC_H265)?HD_CODEC_TYPE_H265:HD_CODEC_TYPE_H264;
	DBG_DUMP("[%d]DecInfo, Tbr=%d, Fps=%d, Width=%d, Height=%d, Gop=%d, Codec=%d\r\n",output->path_id,sEthCamTxDecInfo[output->path_id].Tbr,sEthCamTxDecInfo[output->path_id].Fps,sEthCamTxDecInfo[output->path_id].Width,sEthCamTxDecInfo[output->path_id].Height,sEthCamTxDecInfo[output->path_id].Gop,sEthCamTxDecInfo[output->path_id].Codec);
}

void EthCam_TxFwUpdate_CB(INT32 bEnd, void *output_data)
{
	ETHCAM_XML_DEFAULT_FORMAT *output=(ETHCAM_XML_DEFAULT_FORMAT*)output_data;
	DBG_DUMP("bEnd=%d, cmd=%d, status=%d\r\n",bEnd,output->cmd, output->status);
	if(output->cmd == ETHCAM_CMD_TX_FWUPDATE_START ){
		if(output->status == ETHCAM_RET_FW_OK){
			DBG_DUMP("TxFwUpdate OK\r\n");
		}else if(output->status != ETHCAM_RET_CONTINUE){
			DBG_ERR("TxFwUpdate status=%d\r\n",output->status);
		}
	}
}
void EthCam_SyncTime_CB(INT32 bEnd, void *output_data)
{
	//ETHCAM_XML_DEFAULT_FORMAT *output=(ETHCAM_XML_DEFAULT_FORMAT*)output_data;
	//DBG_IND("cmd=%d, status=%d\r\n",output->cmd, output->status);
}
void EthCam_SyncMenuSetting_CB(INT32 bEnd, void *output_data)
{
	ETHCAM_XML_DEFAULT_FORMAT *output=(ETHCAM_XML_DEFAULT_FORMAT*)output_data;
	DBG_DUMP("cmd=%d, status=%d\r\n",output->cmd, output->status);
}
void EthCam_GetFrame_CB(INT32 bEnd, void *output_data)
{
	//ETHCAM_XML_VALUE_RESULT *output=(ETHCAM_XML_VALUE_RESULT*)output_data;
	//DBG_IND("path_id=%d, cmd=%d, status=%d\r\n",output->path_id,output->cmd, output->status);
}
void EthCam_TxIOStatus_CB(INT32 bEnd, void *output_data)
{
	ETHCAM_XML_VALUE_RESULT *output=(ETHCAM_XML_VALUE_RESULT*)output_data;
	DBG_DUMP("TxIOStatus cmd=%d, path_id=%d, status=%d, value=%d\r\n",output->cmd, output->path_id, output->status,output->value);
}
void EthCam_TxFWVersion_CB(INT32 bEnd, void *output_data)
{
	ETHCAM_XML_STRING_RESULT *output=(ETHCAM_XML_STRING_RESULT*)output_data;
	DBG_DUMP("TxFWVersion cmd=%d, path_id=%d, status=%d, string=%s\r\n",output->cmd, output->path_id,output->status,output->string);
}
void EthCam_SetTxIPReset_CB(INT32 bEnd, void *output_data)
{
	ETHCAM_XML_DEFAULT_FORMAT *output=(ETHCAM_XML_DEFAULT_FORMAT*)output_data;
	DBG_DUMP("cmd=%d, status=%d\r\n",output->cmd, output->status);
}

void EthCam_SetTxSysInfo_CB(INT32 bEnd, void *output_data)
{
	ETHCAM_XML_DEFAULT_FORMAT *output=(ETHCAM_XML_DEFAULT_FORMAT*)output_data;
	DBG_DUMP("SetTxSysInfo cmd=%d, path_id=%d, status=%d\r\n",output->cmd, output->path_id,output->status);
#if (defined(_NVT_ETHREARCAM_RX_))
	//if(output->status== sizeof(ETHCAM_TX_SYS_INFO)){
	if((output->status & 0x0f) == sizeof(ETHCAM_TX_SYS_INFO)){
		DBG_DUMP("SetTxSysInfo cmd OK\r\n");
		sEthCamTxSysInfo[output->path_id].bCmdOK=1;
	}else if(output->status== ETHCAM_RET_CONTINUE){
	}else{
		DBG_ERR("SetTxSysInfo cmd FAIL!!!\r\n");
		sEthCamTxSysInfo[output->path_id].bCmdOK=0;
	}
	if(output->status!= ETHCAM_RET_CONTINUE){
		if(((output->status & 0xf0)>>4) == ETHCAM_TX_SYS_SRCTYPE_56){
			DBG_DUMP("[%d]Tx = 562\r\n",output->path_id);
		}else{
			DBG_DUMP("[%d]Tx = 671\r\n",output->path_id);
		}
	}
#endif
}
void EthCam_SetTxCodecSrctype_CB(INT32 bEnd, void *output_data)
{
	ETHCAM_XML_VALUE_RESULT *output=(ETHCAM_XML_VALUE_RESULT*)output_data;
	DBG_DUMP("SetTxCodecSrctype cmd=%d, path_id=%d, status=%d, value=%d\r\n",output->cmd, output->path_id, output->status,output->value);
#if (defined(_NVT_ETHREARCAM_RX_))
	if(output->value== sizeof(ETHCAM_TX_CODEC_SRCTYPE)){
		DBG_DUMP("SetTxCodecSrctype cmd OK\r\n");
		sEthCamCodecSrctype[output->path_id].bCmdOK=1;
	}else{
		DBG_ERR("SetTxCodecSrctype cmd FAIL!!!\r\n");
		sEthCamCodecSrctype[output->path_id].bCmdOK=0;
	}
#endif
}

void EthCam_MovieStreamStart_CB(INT32 bEnd, void *output_data)
{
	ETHCAM_XML_DEFAULT_FORMAT *output=(ETHCAM_XML_DEFAULT_FORMAT*)output_data;
	DBG_DUMP("cmd=%d, status=%d\r\n",output->cmd, output->status);
}
void EthCam_MovieStreamStop_CB(INT32 bEnd, void *output_data)
{
	ETHCAM_XML_DEFAULT_FORMAT *output=(ETHCAM_XML_DEFAULT_FORMAT*)output_data;
	DBG_DUMP("cmd=%d, status=%d\r\n",output->cmd, output->status);
}

//======================XML Cmd Result CB End======================



void EthCamCmd_SetResultTable(ETHCAM_XML_RESULT *pAppCmdTbl)
{
	g_pEthCamCmdRstTbl = pAppCmdTbl;
}
ETHCAM_XML_RESULT *EthCamCmd_GetResultTable(void)
{
	if(g_pEthCamCmdRstTbl==NULL){
		DBG_ERR("Tbl NULL\r\n");
		return NULL;
	}
	return g_pEthCamCmdRstTbl;
}

ETHCAM_CMD_BEGIN(ethcam)
ETHCAM_CMD_ITEM(ETHCAM_CMD_STARTUP, 0, (UINT32)EthCam_STARTUP, 0, FL_NULL)

ETHCAM_CMD_ITEM(ETHCAM_CMD_GET_TX_MOVIE_TBR, 0, (UINT32)EthCam_GetMovieTBR, 0, FL_NULL)
ETHCAM_CMD_ITEM(ETHCAM_CMD_GET_TX_MOVIE_REC_SIZE, 0, (UINT32)EthCam_GetMovieRecSize, 0, FL_NULL)
ETHCAM_CMD_ITEM(ETHCAM_CMD_GET_TX_MOVIE_FPS, 0, (UINT32)EthCam_GetMovieFps, 0, FL_NULL)
ETHCAM_CMD_ITEM(ETHCAM_CMD_GET_TX_MOVIE_CODEC, 0, (UINT32)EthCam_GetMovieCodec, 0, FL_NULL)
ETHCAM_CMD_ITEM(ETHCAM_CMD_GET_TX_SPS_PPS, 0, (UINT32)EthCam_GetMovieSPS_PPS, 0, FL_NULL)
ETHCAM_CMD_ITEM(ETHCAM_CMD_GET_TX_MOVIE_GOP, 0, (UINT32)EthCam_GetMovieGop, 0, FL_NULL)
ETHCAM_CMD_ITEM(ETHCAM_CMD_TX_STREAM_START, 0, (UINT32)EthCam_TxStreamStart, 0, FL_NULL)
ETHCAM_CMD_ITEM(ETHCAM_CMD_TX_STREAM_STOP, 0, (UINT32)EthCam_TxStreamStop, 0, FL_NULL)
ETHCAM_CMD_ITEM(ETHCAM_CMD_GET_TX_MOVIE_THUMB, 0, (UINT32)EthCam_GetMovieThumb, 0, FL_NULL)
ETHCAM_CMD_ITEM(ETHCAM_CMD_GET_TX_MOVIE_RAW_ENCODE, 0, (UINT32)EthCam_GetMovieRawEncode, 0, FL_NULL)
ETHCAM_CMD_ITEM(ETHCAM_CMD_GET_TX_REC_INFO, 0, (UINT32)EthCam_GetMovieRecInfo, 0, FL_NULL)
ETHCAM_CMD_ITEM(ETHCAM_CMD_TX_RTSP_START, 0, (UINT32)EthCam_TxRtspStart, 0, FL_NULL)
ETHCAM_CMD_ITEM(ETHCAM_CMD_SYNC_TIME, 0, (UINT32)EthCam_SyncTime, 0, FL_NULL)
ETHCAM_CMD_ITEM(ETHCAM_CMD_SYNC_MENU_SETTING, 0, (UINT32)EthCam_SyncMenuSetting, 0, FL_NULL)
ETHCAM_CMD_ITEM(ETHCAM_CMD_TX_RESET_I, 0, (UINT32)EthCam_TxResetI, 0, FL_NULL)
ETHCAM_CMD_ITEM(ETHCAM_CMD_TX_FWUPDATE_FWSEND, 0, (UINT32)EthCam_TxFwUpdate, 0, FL_NULL)
ETHCAM_CMD_ITEM(ETHCAM_CMD_TX_FWUPDATE_START, 0, (UINT32)EthCam_TxFwUpdate, 0, FL_NULL)
ETHCAM_CMD_ITEM(ETHCAM_CMD_GET_TX_DEC_INFO, 0, (UINT32)EthCam_GetMovieDecInfo, 0, FL_NULL)
ETHCAM_CMD_ITEM(ETHCAM_CMD_TX_DISP_CROP, 0, (UINT32)EthCam_TxDispCropSet, 0, FL_NULL)
ETHCAM_CMD_ITEM(ETHCAM_CMD_GET_FRAME, 0, (UINT32)EthCam_GetFrame, 0, FL_NULL)
ETHCAM_CMD_ITEM(ETHCAM_CMD_TX_RESET_QUEUE, 0, (UINT32)EthCam_TxResetQueue ,0, FL_NULL)
ETHCAM_CMD_ITEM(ETHCAM_CMD_TX_POWEROFF, 0, (UINT32)EthCam_TxPowerOff ,0, FL_NULL)
ETHCAM_CMD_ITEM(ETHCAM_CMD_TX_FW_VERSION, 0, (UINT32)EthCam_TxFWVersion ,0, FL_NULL)
ETHCAM_CMD_ITEM(ETHCAM_CMD_SET_TX_IP_RESET, 0, (UINT32)EthCam_SetTxIPReset ,0, FL_NULL)
ETHCAM_CMD_ITEM(ETHCAM_CMD_SET_TX_SYS_INFO, 0, (UINT32)EthCam_SetTxSysInfo ,0, FL_NULL)
ETHCAM_CMD_ITEM(ETHCAM_CMD_DUMP_TX_BS_INFO, 0, (UINT32)EthCam_DumpTxBsInfo ,0, FL_NULL)
ETHCAM_CMD_ITEM(ETHCAM_CMD_CHANGE_MODE, 0, (UINT32)EthCam_ChangeMode ,0, FL_NULL)
ETHCAM_CMD_ITEM(ETHCAM_CMD_IPERF_TEST, 0, (UINT32)EthCam_IperfTest ,0, FL_NULL)

ETHCAM_CMD_END()


ETHCAM_XML_RESULT EthCamXMLResultTbl[]={
	{ETHCAM_CMD_STARTUP, 						ETHCAM_XML_RESULT_TYPE_DEFAULT_FORMAT, 		EthCam_Startup_CB},
	{ETHCAM_CMD_GET_TX_MOVIE_TBR, 				ETHCAM_XML_RESULT_TYPE_VALUE_RESULT, 			EthCam_MovieTBR_CB},
	{ETHCAM_CMD_GET_TX_MOVIE_REC_SIZE, 		ETHCAM_XML_RESULT_TYPE_LIST, 					EthCam_MovieRecSize_CB},
	{ETHCAM_CMD_GET_TX_MOVIE_FPS, 				ETHCAM_XML_RESULT_TYPE_VALUE_RESULT, 			EthCam_MovieFps_CB},
	{ETHCAM_CMD_GET_TX_MOVIE_GOP, 			ETHCAM_XML_RESULT_TYPE_VALUE_RESULT, 			EthCam_MovieGOP_CB},
	{ETHCAM_CMD_GET_TX_MOVIE_CODEC, 			ETHCAM_XML_RESULT_TYPE_VALUE_RESULT, 			EthCam_MovieCodec_CB},
	{ETHCAM_CMD_GET_TX_SPS_PPS, 				ETHCAM_XML_RESULT_TYPE_LIST, 					EthCam_MovieSPS_PPS_CB},
	{ETHCAM_CMD_TX_STREAM_START, 				ETHCAM_XML_RESULT_TYPE_DEFAULT_FORMAT, 		EthCam_MovieStreamStart_CB},
	{ETHCAM_CMD_TX_STREAM_STOP, 				ETHCAM_XML_RESULT_TYPE_DEFAULT_FORMAT, 		EthCam_MovieStreamStop_CB},
	{ETHCAM_CMD_GET_TX_MOVIE_THUMB, 			ETHCAM_XML_RESULT_TYPE_DEFAULT_FORMAT, 		EthCam_MovieThumb_CB},
	{ETHCAM_CMD_GET_TX_MOVIE_RAW_ENCODE, 	ETHCAM_XML_RESULT_TYPE_DEFAULT_FORMAT, 		EthCam_MovieRawEncode_CB},
	{ETHCAM_CMD_GET_TX_REC_INFO, 				ETHCAM_XML_RESULT_TYPE_LIST, 					EthCam_MovieRecInfo_CB},
	{ETHCAM_CMD_TX_RTSP_START, 				ETHCAM_XML_RESULT_TYPE_DEFAULT_FORMAT, 		NULL},
	{ETHCAM_CMD_SYNC_TIME, 					ETHCAM_XML_RESULT_TYPE_DEFAULT_FORMAT, 		EthCam_SyncTime_CB},
	{ETHCAM_CMD_SYNC_MENU_SETTING, 			ETHCAM_XML_RESULT_TYPE_DEFAULT_FORMAT, 		EthCam_SyncMenuSetting_CB},
	{ETHCAM_CMD_TX_RESET_I, 					ETHCAM_XML_RESULT_TYPE_DEFAULT_FORMAT, 		NULL},
	{ETHCAM_CMD_GET_TX_DEC_INFO, 				ETHCAM_XML_RESULT_TYPE_LIST, 					EthCam_MovieDecInfo_CB},
	{ETHCAM_CMD_TX_FWUPDATE_FWSEND, 			ETHCAM_XML_RESULT_TYPE_DEFAULT_FORMAT, 		EthCam_TxFwUpdate_CB},
	{ETHCAM_CMD_TX_FWUPDATE_START, 			ETHCAM_XML_RESULT_TYPE_DEFAULT_FORMAT, 		EthCam_TxFwUpdate_CB},
	{ETHCAM_CMD_TX_DISP_CROP, 					ETHCAM_XML_RESULT_TYPE_DEFAULT_FORMAT, 		NULL},
	{ETHCAM_CMD_GET_FRAME, 					ETHCAM_XML_RESULT_TYPE_DEFAULT_FORMAT, 		EthCam_GetFrame_CB},
	{ETHCAM_CMD_TX_RESET_QUEUE, 				ETHCAM_XML_RESULT_TYPE_DEFAULT_FORMAT, 		NULL},
	{ETHCAM_CMD_TX_POWEROFF, 					ETHCAM_XML_RESULT_TYPE_DEFAULT_FORMAT, 		NULL},
	{ETHCAM_CMD_TX_IO_STATUS, 					ETHCAM_XML_RESULT_TYPE_VALUE_RESULT, 			EthCam_TxIOStatus_CB},
	{ETHCAM_CMD_TX_FW_VERSION, 				ETHCAM_XML_RESULT_TYPE_STRING_RESULT, 			EthCam_TxFWVersion_CB},
	{ETHCAM_CMD_SET_TX_IP_RESET, 				ETHCAM_XML_RESULT_TYPE_DEFAULT_FORMAT, 		EthCam_SetTxIPReset_CB},
	{ETHCAM_CMD_SET_TX_SYS_INFO, 				ETHCAM_XML_RESULT_TYPE_DEFAULT_FORMAT, 		EthCam_SetTxSysInfo_CB},
	{ETHCAM_CMD_DUMP_TX_BS_INFO, 				ETHCAM_XML_RESULT_TYPE_DEFAULT_FORMAT, 		NULL},
	{ETHCAM_CMD_CHANGE_MODE, 					ETHCAM_XML_RESULT_TYPE_DEFAULT_FORMAT, 		NULL},
	{ETHCAM_CMD_IPERF_TEST, 					ETHCAM_XML_RESULT_TYPE_DEFAULT_FORMAT, 		NULL},
	{ETHCAM_CMD_SET_TX_CODEC_SRCTYPE, 		ETHCAM_XML_RESULT_TYPE_VALUE_RESULT, 			EthCam_SetTxCodecSrctype_CB},
	{ETHCAM_CMD_SET_TX_GPS, 					ETHCAM_XML_RESULT_TYPE_DEFAULT_FORMAT, 		NULL},
};
#endif