Jonhon_MiddWareWinStandard/3rd/ehang/Inc/usrlib.h

/**********************************************************************/
/*		EhangCom: User reference Head file
 *
 *      FILE:		usrlib.h
 *      VERSION:	1.0.1.1
 *		DATE:		2011-2-21 
 *
 * DESCRIPTION: Header File for EhangCom Digital USR Interface library
 *   Copyright (c) EhangCom Corp. All Rights Reserved
 *   
 *   THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF EhangCom Corp.
 *   The copyright notice above does not evidence any actual or
 *   intended publication of such source code.
 *
 *	 Note: Can not modify.
 */  
/*********************************************************************/


#ifndef __USRLIB_H__
#define __USRLIB_H__

#include "IsxApi.h"
#include "ipmlib.h"
#include "srllib.h"
#include "voclib.h"
#include "m3glib.h"
#include "gclib.h"
/************************************************************************/
#ifdef __cplusplus
extern "C" {   // C++ func bindings to enable C funcs to be called from C++
#define extern
#endif

#ifndef EHV_NOTHING
#define EHV_NOTHING			-1	
#define TEMP_STR_LEN		1024
#define MAX_OUTSTR_LEN		600
#define FAILTRACE(x)		if(x) {return szOutStr;}
#define FAILRETN(x)			if(x) {return -1;}

static INT STR_OVERFLOW_CHECK(CHAR *szOutStr, CHAR* szTemp)
{		
	if(strlen(szTemp) + strlen(szOutStr) >= MAX_OUTSTR_LEN){
		strcat((CHAR *)szOutStr, "...");
		return -1;
	}
	strcat(szOutStr, szTemp);
	return 0;
}
#endif

//////////////////////////////////////////////////////////////////////////
//struct
#pragma  pack(1)

typedef struct tagM3G_VOICE_CODER_USR: public tagM3G_VOICE_CODER{
	tagM3G_VOICE_CODER_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UINT vVoCoder, UINT vPayloadType=0, UINT vCNG=0, UINT vPLC=0)
	{
		ucValid			=1;		
		if(vVoCoder!=(UINT)EHV_NOTHING)		ucVoCoder		= (UCHAR)vVoCoder;
		if(vPayloadType!=(UINT)EHV_NOTHING)	ucPayloadType	= (UCHAR)vPayloadType;	
		if(vCNG!=(UINT)EHV_NOTHING)			ucCNG			= (UCHAR)vCNG;			
		if(vPLC!=(UINT)EHV_NOTHING)			ucPLC			= (UCHAR)vPLC;			
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];

		if(ucValid){
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,Coder=%d,PT=%d,CNG=%d,PLC=%d> ", 
				pszParamName?pszParamName:"VoCoder", ucValid, ucVoCoder, ucPayloadType, ucCNG, ucPLC);
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", 
				pszParamName?pszParamName:"VoCoder", ucValid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_VOICE_CODER_USR; 

typedef struct tagVoiceConfig_PayloadSize_USR: public VoiceConfig_PayloadSize{
	tagVoiceConfig_PayloadSize_USR() { Init();	};
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UCHAR vPayloadSize = 1)
	{
		Valid			=1;
		if(vPayloadSize!=(UCHAR)EHV_NOTHING) PayloadSize = (UCHAR)vPayloadSize;	
	};

	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		if(Valid){
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,PayloadSize=%d> ", 
				pszParamName?pszParamName:"PS", Valid, PayloadSize);
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", 
				pszParamName?pszParamName:"PS", Valid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};

}VoiceConfig_PayloadSize_USR;

typedef struct tagVoiceConfig_SilenceSuppress_USR: public VoiceConfig_SilenceSuppress{
	tagVoiceConfig_SilenceSuppress_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UCHAR vSilenceSuppress)
	{
		Valid				=1;	
		if(vSilenceSuppress!=(UCHAR)EHV_NOTHING) SilenceSuppress = (UCHAR)vSilenceSuppress;	
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		if(Valid){
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,SilenceSuppress=%d> ", 
				pszParamName?pszParamName:"SS", Valid, SilenceSuppress);
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", 
				pszParamName?pszParamName:"SS", Valid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};

}VoiceConfig_SilenceSuppress_USR;

typedef struct tagVoiceConfig_EchoCancel_USR: public VoiceConfig_EchoCancel{
	tagVoiceConfig_EchoCancel_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UCHAR vEchoCancel=0, UCHAR vEchoCancellerLength=4)
	{
		Valid				=1;	
		if(vEchoCancel!=(UCHAR)EHV_NOTHING) EchoCancel	= vEchoCancel;
		if(vEchoCancellerLength!=(UCHAR)EHV_NOTHING) EchoCancellerLength = vEchoCancellerLength;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		if(Valid){
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,EchoCancel=%d,EchoCancellerLength=%d> ", 
				pszParamName?pszParamName:"EC", Valid, EchoCancel, EchoCancellerLength);
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", 
				pszParamName?pszParamName:"EC", Valid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};

} VoiceConfig_EchoCancel_USR;

typedef struct tagVoiceConfig_JitterBufferDelay_USR: public VoiceConfig_JitterBufferDelay{
	tagVoiceConfig_JitterBufferDelay_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(USHORT vValue)
	{
		Valid	=1;	
		if(vValue!=(USHORT)EHV_NOTHING) Value	= vValue;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		if(Valid){
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,Value=%d> ", 
				pszParamName?pszParamName:"JB", Valid, Value);
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", 
				pszParamName?pszParamName:"JB", Valid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} VoiceConfig_JitterBufferDelay_USR;

typedef struct tagVoiceConfig_AdaptationRate_USR: public VoiceConfig_AdaptationRate{
	tagVoiceConfig_AdaptationRate_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UCHAR vValue)
	{
		Valid	=1;	
		if(vValue!=(UCHAR)EHV_NOTHING) Value = vValue;	
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		if(Valid){
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,Value=%d> ", 
				pszParamName?pszParamName:"AR", Valid, Value);
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", 
				pszParamName?pszParamName:"AR", Valid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} VoiceConfig_AdaptationRate_USR;

typedef struct tagM3G_VOICE_ATTR_CONFIG_USR: public tagM3G_VOICE_ATTR_CONFIG{
	tagM3G_VOICE_ATTR_CONFIG_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue()
	{
		((M3G_VOICE_CODER_USR*)&VoEnCoder)->SetValue(M3G_VOCODER_G711A);
		((M3G_VOICE_CODER_USR*)&VoDeCoder)->SetValue(M3G_VOCODER_G711A);
		((VoiceConfig_PayloadSize_USR*)&PayloadSize)->SetValue(1);
		((VoiceConfig_SilenceSuppress_USR*)&SilenceSuppress)->SetValue(0);
		((VoiceConfig_EchoCancel_USR*)&EchoCancel)->SetValue(0, 4);
		((VoiceConfig_JitterBufferDelay_USR*)&MinJitterBuffer)->SetValue(80);
		((VoiceConfig_JitterBufferDelay_USR*)&MaxJitterBuffer)->SetValue(200);
		((VoiceConfig_AdaptationRate_USR*)&AdaptationRate)->SetValue(7);
	};
	VOID SetVoEnCoder(eM3G_VOICE_CODER vVoCoder, UCHAR vPayloadType=8, UCHAR vCNG=0, UCHAR vPLC=0)
	{
		((M3G_VOICE_CODER_USR*)&VoEnCoder)->SetValue(vVoCoder, vPayloadType, vCNG, vPLC);
	};
	VOID SetVoDeCoder(eM3G_VOICE_CODER vVoCoder, UCHAR vPayloadType=8, UCHAR vCNG=0, UCHAR vPLC=0)
	{
		((M3G_VOICE_CODER_USR*)&VoDeCoder)->SetValue(vVoCoder, vPayloadType, vCNG, vPLC);
	};
	VOID SetOthers(UCHAR vPayloadSize=1, UCHAR vSilenceSuppress=0, 
		UCHAR vEchoCancel=0, UCHAR vEchoCancellerLength=4,
		USHORT vMinJitterBuffer=80, USHORT vMaxJitterBuffer=200, UCHAR vAdaptationRate=7)
	{
		((VoiceConfig_PayloadSize_USR*)&PayloadSize)->SetValue(vPayloadSize);
		((VoiceConfig_SilenceSuppress_USR*)&SilenceSuppress)->SetValue(vSilenceSuppress);
		((VoiceConfig_EchoCancel_USR*)&EchoCancel)->SetValue(vEchoCancel, vEchoCancellerLength);
		((VoiceConfig_JitterBufferDelay_USR*)&MinJitterBuffer)->SetValue(vMinJitterBuffer);
		((VoiceConfig_JitterBufferDelay_USR*)&MaxJitterBuffer)->SetValue(vMaxJitterBuffer);
		((VoiceConfig_AdaptationRate_USR*)&AdaptationRate)->SetValue(vAdaptationRate);
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<", pszParamName?pszParamName:"VoiceConfig");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		FAILRETN(((M3G_VOICE_CODER_USR*)&VoEnCoder)->TraceStr(szOutStr, "VoEnCoder"));
		FAILRETN(((M3G_VOICE_CODER_USR*)&VoDeCoder)->TraceStr(szOutStr, "VoDeCoder"));
		FAILRETN(((VoiceConfig_PayloadSize_USR*)&PayloadSize)->TraceStr(szOutStr, "PS"));
		FAILRETN(((VoiceConfig_SilenceSuppress_USR*)&SilenceSuppress)->TraceStr(szOutStr, "SS"));
		FAILRETN(((VoiceConfig_EchoCancel_USR*)&EchoCancel)->TraceStr(szOutStr, "EC"));
		FAILRETN(((VoiceConfig_JitterBufferDelay_USR*)&MinJitterBuffer)->TraceStr(szOutStr, "MiJB"));
		FAILRETN(((VoiceConfig_JitterBufferDelay_USR*)&MaxJitterBuffer)->TraceStr(szOutStr, "MaJB"));
		FAILRETN(((VoiceConfig_AdaptationRate_USR*)&AdaptationRate)->TraceStr(szOutStr, "AR"));
		_snprintf(szTemp, TEMP_STR_LEN, "> ");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};

} M3G_VOICE_ATTR_CONFIG_USR; 

typedef struct tagIpConfig_IP_addr_USR: public IpConfig_IP_addr{
	tagIpConfig_IP_addr_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(CHAR *vIpAddr)
	{
		Valid		=1;
		if(vIpAddr) strncpy(IpAddr, vIpAddr, sizeof(IpAddr));
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		if(Valid){
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,IpAddr=%s> ", 
				pszParamName?pszParamName:"IP", Valid, IpAddr);
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", 
				pszParamName?pszParamName:"IP", Valid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};

} IpConfig_IP_addr_USR;

typedef struct tagIpConfig_UdpPort_USR: public IpConfig_UdpPort{
	tagIpConfig_UdpPort_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(INT vPort = 0)
	{
		Valid	=1;	
		if(vPort!=(INT)EHV_NOTHING) UdpPort	= (USHORT)vPort;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		if(Valid){
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,UdpPort=%d> ", 
				pszParamName?pszParamName:"PORT", Valid, UdpPort);
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", 
				pszParamName?pszParamName:"PORT", Valid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} IpConfig_UdpPort_USR;

#define DEFAULT_DIGIT_RELAYMODE		DRM_ERASE_AND_RELAY_RFC2833
#define DEFAULT_DYNAMIC_PAYLOAD		101

typedef struct tagDtmfConfig_DigitRelay_USR: public DtmfConfig_DigitRelay{
	tagDtmfConfig_DigitRelay_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UCHAR vDigitRelayMode=DEFAULT_DIGIT_RELAYMODE)
	{
		Valid			=1;
		if(vDigitRelayMode!=(UCHAR)EHV_NOTHING) DigitRelayMode	= vDigitRelayMode;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		if(Valid){
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,DigitRelayMode=%d> ", 
				pszParamName?pszParamName:"DR", Valid, DigitRelayMode);
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", 
				pszParamName?pszParamName:"DR", Valid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} DtmfConfig_DigitRelay_USR;

typedef struct tagDtmfConfig_Dynamic_Payload_USR: public DtmfConfig_Dynamic_Payload{
	tagDtmfConfig_Dynamic_Payload_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UCHAR vDynamicPayload=DEFAULT_DYNAMIC_PAYLOAD)
	{
		Valid			=1;
		if(vDynamicPayload!=(UCHAR)EHV_NOTHING) DynamicPayload	=vDynamicPayload;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		if(Valid){
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,DynamicPayload=%d> ", 
				pszParamName?pszParamName:"DP", Valid, DynamicPayload);
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", 
				pszParamName?pszParamName:"DP", Valid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} DtmfConfig_Dynamic_Payload_USR;

typedef struct tagDtmfConfig_USR: public DtmfConfig{
	tagDtmfConfig_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UCHAR vDigitRelayMode=DEFAULT_DIGIT_RELAYMODE, UCHAR vDynamicPayload=DEFAULT_DYNAMIC_PAYLOAD) 
	{	
		((DtmfConfig_DigitRelay_USR*)&DigitRelay)->SetValue(vDigitRelayMode);
		((DtmfConfig_Dynamic_Payload_USR*)&DynamicPayload)->SetValue(vDynamicPayload);
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<", pszParamName?pszParamName:"DtmfConfig");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		FAILRETN(((DtmfConfig_DigitRelay_USR*)&DigitRelay)->TraceStr(szOutStr, "DR"));
		FAILRETN(((DtmfConfig_Dynamic_Payload_USR*)&DynamicPayload)->TraceStr(szOutStr, "DP"));
		_snprintf(szTemp, TEMP_STR_LEN, "> ");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} DtmfConfig_USR;

typedef struct tagM3G_CHAN_TYPE_VOICE_PARAM_USR: public tagM3G_CHAN_TYPE_VOICE_PARAM{
	tagM3G_CHAN_TYPE_VOICE_PARAM_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetSrcAddr(CHAR *vSrcIp, USHORT vSrcPort) 
	{
		((IpConfig_IP_addr_USR*)&SrcIpAddr)->SetValue(vSrcIp);
		((IpConfig_UdpPort_USR*)&SrcRtpPort)->SetValue(vSrcPort);
	};
	VOID SetDstAddr(CHAR *vDstIp, USHORT vDstPort) 
	{
		((IpConfig_IP_addr_USR*)&DstIpAddr)->SetValue(vDstIp);
		((IpConfig_UdpPort_USR*)&DstRtpPort)->SetValue(vDstPort);
	};
	VOID SetRtcpPort(USHORT vSrcRtcpPort, USHORT vDstRtcpPort) 
	{
		((IpConfig_UdpPort_USR*)&SrcRTCPPort)->SetValue(vSrcRtcpPort);
		((IpConfig_UdpPort_USR*)&DstRTCPPort)->SetValue(vDstRtcpPort);
	};
	VOID SetMode(UCHAR vConnMode=ConnMode_FullDup, UCHAR vVoiceMode=M3G_VOICE_MODE_P2P)
	{
		if(vConnMode!=(UCHAR)EHV_NOTHING)	ucConnMode = vConnMode;	
		if(vVoiceMode!=(UCHAR)EHV_NOTHING)	ucVoiceMode= vVoiceMode;
	};
	VOID SetVoiceCfg(M3G_VOICE_ATTR_CONFIG_USR* pVoiceCfg)
	{
		memcpy(&VoiceCfg, pVoiceCfg, sizeof(M3G_VOICE_ATTR_CONFIG_USR));
	};
	VOID SetDtmfCfg(UCHAR vDigitRelayMode=DEFAULT_DIGIT_RELAYMODE, UCHAR vDynamicPayload=DEFAULT_DYNAMIC_PAYLOAD)
	{
		((DtmfConfig_USR*)&DtmfCfg)->SetValue(vDigitRelayMode, vDynamicPayload);
	};

	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<", pszParamName?pszParamName:"VoiceParm");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		FAILRETN(((IpConfig_IP_addr_USR*)&SrcIpAddr)->TraceStr(szOutStr, "SrcIp"));
		FAILRETN(((IpConfig_UdpPort_USR*)&SrcRtpPort)->TraceStr(szOutStr, "SrcRtpPort"));
		FAILRETN(((IpConfig_IP_addr_USR*)&DstIpAddr)->TraceStr(szOutStr, "DstIp"));
		FAILRETN(((IpConfig_UdpPort_USR*)&DstRtpPort)->TraceStr(szOutStr, "DstRtpPort"));
		FAILRETN(((IpConfig_UdpPort_USR*)&SrcRTCPPort)->TraceStr(szOutStr, "SrcRTCPPort"));
		FAILRETN(((IpConfig_UdpPort_USR*)&DstRTCPPort)->TraceStr(szOutStr, "DstRTCPPort"));
		_snprintf(szTemp, TEMP_STR_LEN, "ConnMode=%d, VoiceMode=%d ", ucConnMode, ucVoiceMode);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		FAILRETN(((M3G_VOICE_ATTR_CONFIG_USR*)&VoiceCfg)->TraceStr(szOutStr, "VoiceCfg"));
		FAILRETN(((DtmfConfig_USR*)&DtmfCfg)->TraceStr(szOutStr, "DtmfCfg"));
		_snprintf(szTemp, TEMP_STR_LEN, "> ");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_CHAN_TYPE_VOICE_PARAM_USR;

typedef struct tagM3G_VIDEO_RTP_USR: public tagM3G_VIDEO_RTP{
	tagM3G_VIDEO_RTP_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UINT vRtpPayloadType=8, UINT vRtpPayloadEncap=M3G_VIDEO_RTP_PAYLOAD_ENCAP_RFC2190, USHORT vSrcUdpPort=0)
	{
		if(vRtpPayloadType!=(UINT)EHV_NOTHING)  ucRtpPayloadType	=(UCHAR)vRtpPayloadType;
		if(vRtpPayloadEncap!=(UINT)EHV_NOTHING) ulRtpPayloadEncap	=vRtpPayloadEncap;		
		if(vSrcUdpPort!=(USHORT)EHV_NOTHING)	 usSrcUdpPort		=vSrcUdpPort;			
	};	
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<PayloadType=%d,PayloadEncap=%d,SrcUdpPort=%d> ", 
			pszParamName?pszParamName:"Rtp", ucRtpPayloadType, ulRtpPayloadEncap, usSrcUdpPort);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
}M3G_VIDEO_RTP_USR;

typedef struct tagM3G_VIDEO_RTCP_USR: public tagM3G_VIDEO_RTCP{
	tagM3G_VIDEO_RTCP_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(USHORT vSrcPort, CHAR* vDstIp, USHORT vDstPort)
	{
		ucValid			=1;	
		if(vSrcPort!=(USHORT)EHV_NOTHING) usSrcUdpPort = vSrcPort;	
		if(vDstPort!=(USHORT)EHV_NOTHING) usDstUdpPort	=vDstPort;	
		if(vDstIp) strncpy(DstIpAddr, vDstIp, sizeof(DstIpAddr));	
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		if(ucValid){
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,SrcPort=%d,DstPort=%d,DstIp=%s> ", 
				pszParamName?pszParamName:"VideoRtcp", ucValid, usSrcUdpPort, usDstUdpPort, DstIpAddr);
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", 
				pszParamName?pszParamName:"VideoRtcp", ucValid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
}M3G_VIDEO_RTCP_USR;

typedef struct tagM3G_VIDEO_DEST_ITEM_USR: public tagM3G_VIDEO_DEST_ITEM{
	tagM3G_VIDEO_DEST_ITEM_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(CHAR *vDstRtpIp, USHORT vDstRtpPort, CHAR *vDstRtcpIp=NULL, USHORT vDstRtcpPort=0)
	{
		if(vDstRtpIp) strcpy(DstIpAddr, vDstRtpIp);			
		usDstUdpPort = vDstRtpPort;							
		if(vDstRtcpIp) strcpy(DstRtcpIpAddr, vDstRtcpIp);	
		usDstRtcpUdpPort = vDstRtcpPort;					
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<DstRtpIp=%s,DstRtpPort=%d,DstRtcpIp=%s,DstRtcpPort=%d> ", 
				pszParamName?pszParamName:"DestItem", DstIpAddr, usDstUdpPort, DstRtcpIpAddr, usDstRtcpUdpPort);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
}M3G_VIDEO_DEST_ITEM_USR;

typedef struct tagM3G_VIDEO_DEST_USR: public tagM3G_VIDEO_DEST{
	tagM3G_VIDEO_DEST_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetNum(UCHAR vDestNum)
	{
		ucDestNum = vDestNum;
	};
	VOID SetValue(CHAR *vDstRtpIp, USHORT vDstRtpPort, CHAR *vDstRtcpIp=NULL, USHORT vDstRtcpPort=0)
	{
		ucDestNum = 1;
		if(vDstRtpIp) strncpy(DestItem[0].DstIpAddr, vDstRtpIp, sizeof(DestItem[0].DstIpAddr));	
		if(vDstRtpPort!=(USHORT)EHV_NOTHING) DestItem[0].usDstUdpPort = vDstRtpPort;	
		if(vDstRtcpIp) strncpy(DestItem[0].DstRtcpIpAddr, vDstRtcpIp, sizeof(DestItem[0].DstRtcpIpAddr));
		if(vDstRtcpPort!=(USHORT)EHV_NOTHING) DestItem[0].usDstRtcpUdpPort = vDstRtcpPort;	
	};
	VOID AddValue(CHAR *vDstRtpIp, USHORT vDstRtpPort, CHAR *vDstRtcpIp=NULL, USHORT vDstRtcpPort=0)
	{
		INT i = ucDestNum;
		if(i>=MAX_VIDEO_DEST_ITEM) return;
		ucDestNum += 1;
		
		if(vDstRtpIp) strncpy(DestItem[i].DstIpAddr, vDstRtpIp, sizeof(DestItem[i].DstIpAddr));
		if(vDstRtpPort!=(USHORT)EHV_NOTHING) DestItem[i].usDstUdpPort = vDstRtpPort;
		if(vDstRtcpIp) strncpy(DestItem[i].DstRtcpIpAddr, vDstRtcpIp, sizeof(DestItem[i].DstRtcpIpAddr));
		if(vDstRtcpPort!=(USHORT)EHV_NOTHING) DestItem[i].usDstRtcpUdpPort = vDstRtcpPort;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<DestNum=%d,", 
				pszParamName?pszParamName:"Dest", ucDestNum);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		CHAR szIndex[16];
		for(INT i=0; i<ucDestNum; i++) {
			if(i>=MAX_VIDEO_DEST_ITEM) break;
			_snprintf(szIndex, 16, "%d", i);
			((M3G_VIDEO_DEST_ITEM_USR*)&DestItem[i])->TraceStr(szOutStr, szIndex);
		}
		_snprintf(szTemp, TEMP_STR_LEN, "> ");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
}M3G_VIDEO_DEST_USR;

typedef struct tagM3G_VIDEO_INPUT_USR: public tagM3G_VIDEO_INPUT{
	tagM3G_VIDEO_INPUT_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetEnable(UCHAR vIsEnable=1)
	{
		ucValid				=1;
		if(vIsEnable!=(UCHAR)EHV_NOTHING) ucIsEnable = vIsEnable;
	};
	VOID SetTransportType(UINT vTransportType/*eM3G_VIDEO_TRANSPORT_TYPE*/)
	{
		ucValid				=1;
		if(vTransportType!=(UINT)EHV_NOTHING) ucTransportType = (UCHAR)vTransportType; 
	};
	VOID SetRtp(USHORT vSrcRtpPort, UINT vRtpPayloadType=34, UINT vRtpPayloadEncap=M3G_VIDEO_RTP_PAYLOAD_ENCAP_RFC2190)
	{
		ucValid = 1;
		((M3G_VIDEO_RTP_USR*)&Rtp)->SetValue(vRtpPayloadType, vRtpPayloadEncap, vSrcRtpPort); 
	};
	VOID SetRtcp(USHORT vSrcRtcpPort, CHAR* vDstRtcpIp, USHORT vDstRtcpPort)
	{
		ucValid = 1;
		((M3G_VIDEO_RTCP_USR*)&Rtcp)->SetValue(vSrcRtcpPort, vDstRtcpIp, vDstRtcpPort); 
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		if(ucValid){
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,IsEnable=%d,TransportType=%d,", 
				pszParamName?pszParamName:"VideoInput", ucValid, ucIsEnable, ucTransportType);
			FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
			((M3G_VIDEO_RTP_USR*)&Rtp)->TraceStr(szOutStr); 
			((M3G_VIDEO_RTCP_USR*)&Rtcp)->TraceStr(szOutStr); 
			_snprintf(szTemp, TEMP_STR_LEN, "> ");
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", 
				pszParamName?pszParamName:"VideoInput", ucValid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
}M3G_VIDEO_INPUT_USR;

typedef struct tagM3G_VIDEO_DECODER_USR: public tagM3G_VIDEO_DECODER{
	tagM3G_VIDEO_DECODER_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetEnable(UCHAR vIsEnable=1)
	{
		ucValid				=1;
		if(vIsEnable!=(UCHAR)EHV_NOTHING) ucIsEnable = vIsEnable;
	};
	VOID SetValue(UINT vCodingStandard=M3G_VICODER_H263, 
		UINT vInputWidth=176, UINT vInputHeight=144, UINT vOutputWidth=176, 
		UINT vOutputHeight=144, UINT vFramesPerSec=10, UINT vDeblocking_smoth=0, 
		UINT vDeblocking_strength=0, UINT vReferFrames=0)
	{
		ucValid					=1;
		if(vCodingStandard!=(UINT)EHV_NOTHING)		ulCodingStandard	 = vCodingStandard;	
		if(vInputHeight!=(UINT)EHV_NOTHING)		ulInputHeight		 = vInputHeight;	
		if(vInputWidth!=(UINT)EHV_NOTHING)			ulInputWidth		 = vInputWidth;		
		if(vOutputHeight!=(UINT)EHV_NOTHING)		ulOutputHeight	  	 = vOutputHeight;	
		if(vOutputWidth!=(UINT)EHV_NOTHING)		ulOutputWidth		 = vOutputWidth;	
		if(vFramesPerSec!=(UINT)EHV_NOTHING)		ulFramesPerSec		 = vFramesPerSec;	
		if(vDeblocking_smoth!=(UINT)EHV_NOTHING)	ulDeblocking_smoth	 = vDeblocking_smoth;
		if(vDeblocking_strength!=(UINT)EHV_NOTHING)ulDeblocking_strength= vDeblocking_strength;
		if(vReferFrames!=(UINT)EHV_NOTHING)		ulReferFrames	 	 = vReferFrames;		
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		if(ucValid){
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,IsEnable=%d,CodingStd=%d,InH=%d,"
				"InW=%d,OutH=%d,OutW=%d,fps=%d,Bsmoth=%d,Bstrength=%d,ReferFrms=%d> ", 
				pszParamName?pszParamName:"VideoDecoder", ucValid, ucIsEnable, ulCodingStandard, ulInputHeight,
				ulInputWidth, ulOutputHeight, ulOutputWidth, ulFramesPerSec, ulDeblocking_smoth,
				ulDeblocking_strength, ulReferFrames);
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", 
				pszParamName?pszParamName:"VideoDecoder", ucValid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
}M3G_VIDEO_DECODER_USR;

typedef struct tagM3G_VIDEO_ENCODER_USR: public tagM3G_VIDEO_ENCODER{
	tagM3G_VIDEO_ENCODER_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetEnable(UCHAR vIsEnable=1)
	{
		ucValid				=1;
		if(vIsEnable!=(UCHAR)EHV_NOTHING) ucIsEnable	= vIsEnable;
	};
	VOID SetValue(UINT vCodingStandard=M3G_VICODER_H263, 
		UINT vProfileLevel=0, UINT vInputWidth=176, UINT vInputHeight=144,
		UINT vFramesPerSec=10, UINT vBitRate=40000, UINT vIsVariableBitRate=0, 
		UINT vVbrQualityMin=0, UINT vVbrQualityMax=0x7FFF, UINT vIFrameFrequency=99)
	{
		ucValid						=1;
		if(vCodingStandard!=(UINT)EHV_NOTHING) ulCodingStandard		= vCodingStandard;	
		if(vProfileLevel!=(UINT)EHV_NOTHING) ulProfileLevel			= vProfileLevel;	
		if(vInputHeight!=(UINT)EHV_NOTHING) ulInputHeight				= vInputHeight;		
		if(vInputWidth!=(UINT)EHV_NOTHING) ulInputWidth				= vInputWidth;		
		if(vFramesPerSec!=(UINT)EHV_NOTHING) ulFramesPerSec			= vFramesPerSec;	
		if(vBitRate!=(UINT)EHV_NOTHING) ulBitRate						= vBitRate;			
		if(vIsVariableBitRate!=(UINT)EHV_NOTHING) ucIsVariableBitRate	= (UCHAR)vIsVariableBitRate;
		if(vVbrQualityMin!=(UINT)EHV_NOTHING) ulVbrQualityMin			= vVbrQualityMin;		
		if(vVbrQualityMax!=(UINT)EHV_NOTHING) ulVbrQualityMax			= vVbrQualityMax;		
		if(vIFrameFrequency!=(UINT)EHV_NOTHING) ulIFrameFrequency		= vIFrameFrequency;		
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		if(ucValid){
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,IsEnable=%d,CodingStd=%d,ProfLvl=%d,InH=%d,InW=%d, "
				"fps=%d,BitRate=%d,VarRate=%d,VbrQMin=%d,VbrQMax=%d,IFrmFreq=%d> ", 
				pszParamName?pszParamName:"VideoEncoder", ucValid, ucIsEnable, ulCodingStandard, 
				ulProfileLevel, ulInputHeight, ulInputWidth, ulFramesPerSec, ulBitRate, 
				ucIsVariableBitRate, ulVbrQualityMin, ulVbrQualityMax, ulIFrameFrequency);
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", 
				pszParamName?pszParamName:"VideoEncoder", ucValid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};	
}M3G_VIDEO_ENCODER_USR;

typedef struct tagM3G_VIDEO_OUTPUT_USR: public tagM3G_VIDEO_OUTPUT{
	tagM3G_VIDEO_OUTPUT_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetEnable(UCHAR vIsEnable=1)
	{
		ucValid				=1;
		if(vIsEnable!=(UCHAR)EHV_NOTHING) ucIsEnable = vIsEnable;	
	};
	VOID SetTransportType(UINT vTransportType/*eM3G_VIDEO_TRANSPORT_TYPE*/)
	{
		ucValid				=1;
		if(vTransportType!=(UINT)EHV_NOTHING) ucTransportType = (UCHAR)vTransportType;
	};
	VOID SetRtp(USHORT vSrcRtpPort, UINT vRtpPayloadType=34, UINT vRtpPayloadEncap=M3G_VIDEO_RTP_PAYLOAD_ENCAP_RFC2190)
	{
		ucValid				=1;
		((M3G_VIDEO_RTP_USR*)&Rtp)->SetValue(vRtpPayloadType, vRtpPayloadEncap, vSrcRtpPort); 
	};
	VOID SetRtcp(USHORT vSrcRtcpPort, CHAR* vDstRtcpIp, USHORT vDstRtcpPort)
	{
		ucValid				=1;
		((M3G_VIDEO_RTCP_USR*)&Rtcp)->SetValue(vSrcRtcpPort, vDstRtcpIp, vDstRtcpPort); 
	};
	VOID SetDest(CHAR* vDstRtpIp, USHORT vDstRtpPort, CHAR* vDstRtcpIp=NULL, USHORT vDstRtcpPort=0)
	{
		ucValid				=0;
		if(vDstRtpIp==NULL) return;
		if(vDstRtpIp[0]==0) return;
		if(vDstRtpPort==0) return;
		ucValid				=1;
		((M3G_VIDEO_DEST_USR*)&Dest)->SetValue(vDstRtpIp, vDstRtpPort, vDstRtcpIp, vDstRtcpPort); 
	};
	VOID AddDest(CHAR* vDstRtpIp, USHORT vDstRtpPort, CHAR* vDstRtcpIp=NULL, USHORT vDstRtcpPort=0)
	{
		if(vDstRtpIp==NULL) return;
		if(vDstRtpIp[0]==0) return;
		if(vDstRtpPort==0) return;
		if(ucValid!=1) ucValid = 1;
		((M3G_VIDEO_DEST_USR*)&Dest)->AddValue(vDstRtpIp, vDstRtpPort, vDstRtcpIp, vDstRtcpPort); 
	};

	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		if(ucValid){
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,IsEnable=%d,TransportType=%d,", 
				pszParamName?pszParamName:"VideoOutput", ucValid, ucIsEnable, ucTransportType);
			FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
			((M3G_VIDEO_RTP_USR*)&Rtp)->TraceStr(szOutStr); 
			((M3G_VIDEO_RTCP_USR*)&Rtcp)->TraceStr(szOutStr); 
			((M3G_VIDEO_DEST_USR*)&Dest)->TraceStr(szOutStr); 
			_snprintf(szTemp, TEMP_STR_LEN, ">");
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", 
				pszParamName?pszParamName:"VideoOutput", ucValid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
}M3G_VIDEO_OUTPUT_USR;

typedef struct tagM3G_CHAN_TYPE_VIDEO_PARAM_USR: public tagM3G_CHAN_TYPE_VIDEO_PARAM{
	tagM3G_CHAN_TYPE_VIDEO_PARAM_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetVideoInput(M3G_VIDEO_INPUT_USR *pVideoInput)
	{
		memcpy(&VideoInput, pVideoInput, sizeof(M3G_VIDEO_INPUT_USR));
	};
	VOID SetVideoOutput(M3G_VIDEO_OUTPUT_USR *pVideoOutput)
	{
		memcpy(&VideoOutput, pVideoOutput, sizeof(M3G_VIDEO_OUTPUT_USR));
	};
	VOID SetVideoDecoder(M3G_VIDEO_DECODER_USR *pVideoDecoder)
	{
		memcpy(&VideoDecoder, pVideoDecoder, sizeof(M3G_VIDEO_DECODER_USR));
	};
	VOID SetVideoEncoder(M3G_VIDEO_ENCODER_USR *pVideoEncoder)
	{
		memcpy(&VideoEncoder, pVideoEncoder, sizeof(M3G_VIDEO_ENCODER_USR));
	};

	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<", pszParamName?pszParamName:"VideoParm");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		FAILRETN(((M3G_VIDEO_INPUT_USR*)&VideoInput)->TraceStr(szOutStr, "VideoInput"));
		FAILRETN(((M3G_VIDEO_DECODER_USR*)&VideoDecoder)->TraceStr(szOutStr, "VideoDecoder"));
		FAILRETN(((M3G_VIDEO_ENCODER_USR*)&VideoEncoder)->TraceStr(szOutStr, "VideoEncoder"));
		FAILRETN(((M3G_VIDEO_OUTPUT_USR*)&VideoOutput)->TraceStr(szOutStr, "VideoOutput"));
		_snprintf(szTemp, TEMP_STR_LEN, "> ");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
}M3G_CHAN_TYPE_VIDEO_PARAM_USR;

typedef struct tagM3G_TERM_CAPS_USR: public tagM3G_TERM_CAPS{
	tagM3G_TERM_CAPS_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue()
	{
		ucValid				=1;	

		//ucAudioCodes[0]		=M3G_H324_AUDIO_CODEC_AMR;	//AMR
		//ucAudioCodes[1]		=M3G_H324_AUDIO_CODEC_G723;	//G723
		//ucAudioCodes[2]		=M3G_H324_AUDIO_CODEC_NONE;	//NONE
		//ucAudioCodes[3]		=M3G_H324_AUDIO_CODEC_NONE;	//NONE

		//ucVideoCodes[0]		=M3G_H324_VIDEO_CODEC_MPEG4;//MPEG4
		//ucVideoCodes[1]		=M3G_H324_VIDEO_CODEC_H263;	//H263
		//ucVideoCodes[2]		=M3G_H324_VIDEO_CODEC_NONE;	//NONE
		//ucVideoCodes[3]		=M3G_H324_VIDEO_CODEC_NONE;	//NONE

		ucAudioCodes[0]		=M3G_H324_AUDIO_CODEC_AMR;	//AMR
		ucAudioCodes[1]		=M3G_H324_AUDIO_CODEC_NONE;	//NONE
		ucAudioCodes[2]		=M3G_H324_AUDIO_CODEC_NONE;	//NONE
		ucAudioCodes[3]		=M3G_H324_AUDIO_CODEC_NONE;	//NONE

		ucVideoCodes[0]		=M3G_H324_VIDEO_CODEC_H263;//H263
		ucVideoCodes[1]		=M3G_H324_VIDEO_CODEC_NONE;	//NONE
		ucVideoCodes[2]		=M3G_H324_VIDEO_CODEC_NONE;	//NONE
		ucVideoCodes[3]		=M3G_H324_VIDEO_CODEC_NONE;	//NONE

		ucDtmfSignal[0]		=1;	
		ucDtmfSignal[1]		=1;	
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		if(ucValid){
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,AudioCodes(%d,%d,%d,%d),VideoCodes(%d,%d,%d,%d),DtmfSignal(%d,%d)> ",
				pszParamName?pszParamName:"TermCaps", ucValid, ucAudioCodes[0], ucAudioCodes[1], ucAudioCodes[2],
				ucAudioCodes[3], ucVideoCodes[0], ucVideoCodes[1], ucVideoCodes[2], ucVideoCodes[3],
				ucDtmfSignal[0], ucDtmfSignal[1]);
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", 
				pszParamName?pszParamName:"TermCaps", ucValid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
}M3G_TERM_CAPS_USR;

typedef struct tagM3G_H223_PARAMS_USR: public tagM3G_H223_PARAMS{
	tagM3G_H223_PARAMS_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UINT vAl2WithSeqNumberAudio=1, UINT vAl2WitchSeqNumberVideo=1, UINT vMaxPdu=160)
	{
		ucValid						=1;	
		if(vAl2WithSeqNumberAudio!=(UINT)EHV_NOTHING) ulAl2WithSeqNumberAudio	= vAl2WithSeqNumberAudio;
		if(vAl2WitchSeqNumberVideo!=(UINT)EHV_NOTHING) ulAl2WitchSeqNumberVideo= vAl2WitchSeqNumberVideo;
		if(vMaxPdu!=(UINT)EHV_NOTHING) ulMaxPdu = vMaxPdu;	
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		if(ucValid){
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,AudioWithSN=%d,VideoWithSN=%d,MaxPdu=%d> ",
				pszParamName?pszParamName:"H223Parms", ucValid, ulAl2WithSeqNumberAudio, ulAl2WitchSeqNumberVideo, ulMaxPdu);
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", 
				pszParamName?pszParamName:"H223Parms", ucValid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_H223_PARAMS_USR;

typedef struct tagM3G_MEDIA_CHAN_USR: public tagM3G_MEDIA_CHAN{
	tagM3G_MEDIA_CHAN_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(USHORT vSrcRtpPort, USHORT vDstRtpPort=0, CHAR* vDstRtpIp=NULL, UINT vPayloadType=0, UINT vCodec=0, UCHAR vIsMuted=0)
	{
		ucValid				=1;			
		if(vPayloadType!=(UINT)EHV_NOTHING) ucRtpPayloadType	= (UCHAR)vPayloadType;	
		if(vSrcRtpPort!=(USHORT)EHV_NOTHING) usSrcUdpPort		= vSrcRtpPort;		
		if(vDstRtpPort!=(USHORT)EHV_NOTHING) usDstUdpPort		= vDstRtpPort;		
		if(vDstRtpIp) strncpy(DstIpAddr, vDstRtpIp, sizeof(DstIpAddr));				
		if(vCodec!=(UINT)EHV_NOTHING)		 ulCodec			= vCodec;			
		if(vIsMuted!=(UCHAR)EHV_NOTHING)	 ucIsMuted			= vIsMuted;			
	};
	INT SetDefaultSrcPort(INT nCh, INT i)
	{
		ucValid= 1;
		usSrcUdpPort = EHANG_MAKE_MEDIA_PORT(nCh, i);
		return 0;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		if(ucValid){
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,PT=%d,SrcPort=%d,DstPort=%d,DstIp=%s, "
				"Codec=%d, IsMuted=%d> ", pszParamName?pszParamName:"MediaChan", 
				ucValid, ucRtpPayloadType, usSrcUdpPort, usDstUdpPort, DstIpAddr, ulCodec, ucIsMuted);
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", 
				pszParamName?pszParamName:"MediaChan", ucValid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_MEDIA_CHAN_USR;

typedef struct tagM3G_CHAN_TYPE_H324M_PARAM_USR: public tagM3G_CHAN_TYPE_H324M_PARAM{
	tagM3G_CHAN_TYPE_H324M_PARAM_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue()
	{
		ucTermType		=128;
		((M3G_TERM_CAPS_USR*)&LocalCaps)->SetValue();	
		((M3G_H223_PARAMS_USR*)&H223Params)->SetValue();
		((M3G_MEDIA_CHAN_USR*)&MediaChan[0])->SetValue(0);
		((M3G_MEDIA_CHAN_USR*)&MediaChan[1])->SetValue(0);
		((M3G_MEDIA_CHAN_USR*)&MediaChan[2])->SetValue(0);
		((M3G_MEDIA_CHAN_USR*)&MediaChan[3])->SetValue(0);
	};
	INT SetLocalTerm(UCHAR vTermType=128, M3G_TERM_CAPS_USR* pTermCaps=NULL, M3G_H223_PARAMS_USR* pH223Parms=NULL)
	{
		ucTermType = vTermType;
		if(pTermCaps==NULL) {
			((M3G_TERM_CAPS_USR*)&LocalCaps)->SetValue();
		} else {
			memcpy(&LocalCaps, pTermCaps, sizeof(M3G_TERM_CAPS));
		}
		if(pH223Parms==NULL) {
			((M3G_H223_PARAMS_USR*)&H223Params)->SetValue();
		} else {
			memcpy(&H223Params, pH223Parms, sizeof(M3G_H223_PARAMS));
		}
		
		return 0;
	};
	INT SetMediaChan(eM3G_LC_NUMBER lc, M3G_MEDIA_CHAN_USR* pParam)
	{
		if(pParam == NULL) return -1;
		memcpy(&MediaChan[lc], pParam, sizeof(M3G_MEDIA_CHAN));
		return 0;
	};
	INT SetDefaultSrcPort(INT nCh)
	{
		M3G_MEDIA_CHAN_USR* pMediaChan;
		pMediaChan= (M3G_MEDIA_CHAN_USR*)&MediaChan[0];
		pMediaChan->SetDefaultSrcPort(nCh, 0);

		pMediaChan= (M3G_MEDIA_CHAN_USR*)&MediaChan[1];
		pMediaChan->SetDefaultSrcPort(nCh, 2);

		pMediaChan= (M3G_MEDIA_CHAN_USR*)&MediaChan[2];
		pMediaChan->SetDefaultSrcPort(nCh, 4);

		pMediaChan= (M3G_MEDIA_CHAN_USR*)&MediaChan[3];
		pMediaChan->SetDefaultSrcPort(nCh, 6);
		return 0;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<", pszParamName?pszParamName:"H324MParm");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		FAILRETN(((M3G_TERM_CAPS_USR*)&LocalCaps)->TraceStr(szOutStr, "LocalCaps"));
		FAILRETN(((M3G_H223_PARAMS_USR*)&H223Params)->TraceStr(szOutStr, "H223Params"));
		_snprintf(szTemp, TEMP_STR_LEN, "MediaChan< ");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		CHAR szIndex[10];
		for(INT i=0; i<MAX_H324M_LC_NUM; i++) {
			sprintf(szIndex, "%d", i);
			FAILRETN(((M3G_MEDIA_CHAN_USR*)&MediaChan[i])->TraceStr(szOutStr, szIndex));
		}
		_snprintf(szTemp, TEMP_STR_LEN, ">> ");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_CHAN_TYPE_H324M_PARAM_USR;

typedef struct tagM3G_AUDIO_RTP_USR: public tagM3G_AUDIO_RTP{
	tagM3G_AUDIO_RTP_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { 
		return sizeof(*this);
	};
	VOID SetValue(UCHAR vPayloadType, UCHAR vRtpMode, USHORT vConjugatedChanNo, UINT vTsTicksPerSecond, USHORT vSrcUdpPort, USHORT vDestUdpPort, CHAR* vDestIPAddr)
	{
		ucPayloadType = vPayloadType;
		ucRtpMode = vRtpMode;
		usConjugatedChanNo = vConjugatedChanNo;
		ulTsTicksPerSecond = vTsTicksPerSecond;
		usSrcUdpPort = vSrcUdpPort;
		usDestUdpPort = vDestUdpPort;
		if(vDestIPAddr) _snprintf(szDestIPAddr, sizeof(szDestIPAddr), "%s", vDestIPAddr);
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<PayloadType=%d,RtpMode=%d,ConjugatedChanNo=%d,TsTicksPerSecond=%d,SrcUdpPort=%d,DestUdpPort=%d,DestIPAddr=%s>", 
			pszParamName?pszParamName:"RTP", ucPayloadType, ucRtpMode, usConjugatedChanNo, ulTsTicksPerSecond, usSrcUdpPort,usDestUdpPort,szDestIPAddr);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};	
} M3G_AUDIO_RTP_USR;

typedef struct tagM3G_AUDIO_INPUT_JB_USR: public tagM3G_AUDIO_INPUT_JB{
	tagM3G_AUDIO_INPUT_JB_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { 
		return sizeof(*this);
	};
	VOID SetValue(UCHAR vType, UINT vSize, UINT vAverageDelayInMS, UINT vPacketLossTimeout)
	{
		ucType = ucType;
		ulSize = vSize;
		ulAverageDelayInMS = vAverageDelayInMS;
		ulPacketLossTimeout = vPacketLossTimeout;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<Type=%d,Size=%d,AverageDelayInMS=%d,PacketLossTimeout=%d>", 
			pszParamName?pszParamName:"JB", ucType, ulSize, ulAverageDelayInMS, ulPacketLossTimeout);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};	
} M3G_AUDIO_INPUT_JB_USR;

typedef struct tagM3G_AUDIO_RTCP_USR: public tagM3G_AUDIO_RTCP{
	tagM3G_AUDIO_RTCP_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { 
		return sizeof(*this);
	};
	VOID SetEnable(UCHAR vEnable)
	{
		ucEnable = vEnable;
	};
	VOID SetValue(UCHAR vRecvRtcp, UCHAR vRtcpHandleType, UINT vReportInterval, USHORT vSrcUdpPort, USHORT vDestUdpPort, CHAR* vDestIPAddr)
	{
		ucRecvRtcp = vRecvRtcp;
		ucRtcpHandleType = vRtcpHandleType;
		ulReportInterval = vReportInterval;
		usSrcUdpPort = vSrcUdpPort;
		usDestUdpPort = vDestUdpPort;
		if(vDestIPAddr) _snprintf(szDestIPAddr, sizeof(szDestIPAddr), "%s", vDestIPAddr);
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<Enable=%d,RecvRtcp=%d,RtcpHandleType=%d,ReportInterval=%d,SrcUdpPort=%d,DestUdpPort=%d,DestIPAddr=%s>", 
			pszParamName?pszParamName:"RTCP", ucEnable, ucRecvRtcp, ucRtcpHandleType, ulReportInterval, usSrcUdpPort,usDestUdpPort,szDestIPAddr);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};	
} M3G_AUDIO_RTCP_USR;

typedef struct tagM3G_AUDIO_INPUT_USR: public tagM3G_AUDIO_INPUT{
	tagM3G_AUDIO_INPUT_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { 
		return sizeof(*this);
	};
	VOID SetValid(UCHAR vValid)
	{
		ucValid = vValid;
	};
	VOID SetEnable(UCHAR vEnable)
	{
		ucEnable = vEnable;
	};
	VOID SetValue(UINT vTransportType, UINT vRfcType, UINT vTrackNum, UINT vSampleRate)
	{
		if(vTransportType!=(UINT)EHV_NOTHING)	ucTransportType = (UCHAR)ucTransportType;
		if(vRfcType!=(UINT)EHV_NOTHING)		ucRfcType = (UCHAR)vRfcType;
		if(vTrackNum!=(UINT)EHV_NOTHING)		ucTrackNum = (UCHAR)vTrackNum;
		if(vSampleRate!=(UINT)EHV_NOTHING)		ulSampleRate = vSampleRate;
	};
	VOID SetRTP(M3G_AUDIO_RTP *pRTP)
	{
		if(pRTP) memcpy(&RTP, pRTP, sizeof(M3G_AUDIO_RTP));
	};
	VOID SetRTCP(M3G_AUDIO_RTP *pRTCP)
	{
		if(pRTCP) memcpy(&RTCP, pRTCP, sizeof(M3G_AUDIO_RTCP));
	};
	VOID SetRTP(M3G_AUDIO_INPUT_JB *pJB)
	{
		if(pJB) memcpy(&JB, pJB, sizeof(M3G_AUDIO_INPUT_JB));
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,Enable=%d,TransportType=%d,RfcType=%d,TrackNum=%d,SampleRate=%d, ", 
			pszParamName?pszParamName:"AudioInput", ucValid, ucEnable, ucTransportType, ucRfcType, ucTrackNum,ulSampleRate);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		FAILRETN(((M3G_AUDIO_RTP_USR*)&RTP)->TraceStr(szOutStr));
		FAILRETN(((M3G_AUDIO_INPUT_JB_USR*)&JB)->TraceStr(szOutStr));
		FAILRETN(((M3G_AUDIO_RTCP_USR*)&RTCP)->TraceStr(szOutStr));
		_snprintf(szTemp, TEMP_STR_LEN, "> ");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};	
} M3G_AUDIO_INPUT_USR;

typedef struct tagM3G_AUDIO_DECODER_USR: public tagM3G_AUDIO_DECODER{
	tagM3G_AUDIO_DECODER_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { 
		return sizeof(*this);
	};
	VOID SetValid(UCHAR vValid)
	{
		ucValid = vValid;
	};
	VOID SetEnable(UCHAR vEnable)
	{
		ucEnable = vEnable;
	};
	VOID SetValue(UINT vCodecType, UINT vTrackNum, UINT vSampleRate)
	{
		if(vCodecType!=(UINT)EHV_NOTHING)		ucCodecType = (UCHAR)vCodecType;
		if(vTrackNum!=(UINT)EHV_NOTHING)		ucTrackNum = (UCHAR)vTrackNum;
		if(vSampleRate!=(UINT)EHV_NOTHING)		ulSampleRate = vSampleRate;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,Enable=%d,CodecType=%d,TrackNum=%d,SampleRate=%d>", 
			pszParamName?pszParamName:"AudioDecoder", ucValid, ucEnable, ucCodecType, ucTrackNum, ulSampleRate);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_AUDIO_DECODER_USR;

typedef struct tagM3G_AUDIO_TOOLBOX_RESAMPLE_USR: public tagM3G_AUDIO_TOOLBOX_RESAMPLE{
	tagM3G_AUDIO_TOOLBOX_RESAMPLE_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { 
		return sizeof(*this);
	};
	VOID SetValue(UINT vNewSampleRate, UCHAR vComplexity)
	{
		ulNewSampleRate = vNewSampleRate;
		ucComplexity = vComplexity;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<NewSampleRate=%d, Complexity=%d>", 
			pszParamName?pszParamName:"Resample", ulNewSampleRate, ucComplexity);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};	
}M3G_AUDIO_TOOLBOX_RESAMPLE_USR;

typedef struct tagM3G_AUDIO_TOOLBOX_TRACK_CONF_USR: public tagM3G_AUDIO_TOOLBOX_TRACK_CONF{
	tagM3G_AUDIO_TOOLBOX_TRACK_CONF_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { 
		return sizeof(*this);
	};
	VOID SetValue(UCHAR vNewTrackNum)
	{
		ucNewTrackNum = (UCHAR)vNewTrackNum;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<NewTrackNum=%d>", 
			pszParamName?pszParamName:"TrackConf", ucNewTrackNum);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};	
} M3G_AUDIO_TOOLBOX_TRACK_CONF_USR;

typedef struct tagM3G_AUDIO_TOOLBOX_ITEM_USR: public tagM3G_AUDIO_TOOLBOX_ITEM{
	tagM3G_AUDIO_TOOLBOX_ITEM_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { 
		return sizeof(*this);
	};
	VOID SetValue(UINT vDirection, UINT vInTrackNum, UINT vInSampleRate)
	{
		if(vDirection!=(UINT)EHV_NOTHING) ucDirection = (UCHAR)vDirection;
		if(vInTrackNum!=(UINT)EHV_NOTHING) ucInTrackNum = (UCHAR)vInTrackNum;
		if(vInSampleRate!=(UINT)EHV_NOTHING) ulInSampleRate = vInSampleRate;
	};
	VOID SetToolBoxTypeParm(UCHAR vType, VOID* pValue)
	{
		ucType = (UCHAR)vType;
		if(ucType==M3G_AUDIO_TOOL_TYPE_RESAMPLING) {
			memcpy(&u.Resample, pValue, sizeof(M3G_AUDIO_TOOLBOX_RESAMPLE));
		} else {
			memcpy(&u.TrackConf, pValue, sizeof(M3G_AUDIO_TOOLBOX_TRACK_CONF));
		}
	}
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<Type=%d,Direction=%d,InTrackNum=%d,InSampleRate=%d, ", 
			pszParamName?pszParamName:"ToolboxItem", ucType, ucDirection,ucInTrackNum,ulInSampleRate);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		if(ucType==M3G_AUDIO_TOOL_TYPE_RESAMPLING) {
			FAILRETN(((M3G_AUDIO_TOOLBOX_RESAMPLE_USR*)&u.Resample)->TraceStr(szOutStr));
		} else {
			FAILRETN(((M3G_AUDIO_TOOLBOX_TRACK_CONF_USR*)&u.TrackConf)->TraceStr(szOutStr));
		}
		_snprintf(szTemp, TEMP_STR_LEN, "> ");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};	
} M3G_AUDIO_TOOLBOX_ITEM_USR;

typedef struct tagM3G_AUDIO_TOOLBOX_USR: public tagM3G_AUDIO_TOOLBOX{
	tagM3G_AUDIO_TOOLBOX_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { 
		return sizeof(*this);
	};
	VOID SetValid(UCHAR vValid)
	{
		ucValid = vValid;
	};
	VOID SetToolBox(UCHAR vNum, M3G_AUDIO_TOOLBOX_ITEM *pItems)
	{
		ucToolBoxNum = vNum;
		if(ucToolBoxNum > M3G_AUDIO_TOOLBOX_ITEM_NUM) ucToolBoxNum = M3G_AUDIO_TOOLBOX_ITEM_NUM;
		if(pItems && ucToolBoxNum>0) {
			memcpy(Item, pItems, sizeof(M3G_AUDIO_TOOLBOX_ITEM)*ucToolBoxNum);
		}
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,ToolBoxNum=%d,Item<", 
			pszParamName?pszParamName:"AudioToolbox", ucValid, ucToolBoxNum);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		CHAR szIndex[16];
		if(ucToolBoxNum>M3G_AUDIO_TOOLBOX_ITEM_NUM) ucToolBoxNum = M3G_AUDIO_TOOLBOX_ITEM_NUM;
		for(INT i=0; i<ucToolBoxNum; i++) {
			sprintf(szIndex, "%d", i);
			FAILRETN(((M3G_AUDIO_TOOLBOX_ITEM_USR*)&Item[i])->TraceStr(szOutStr, szIndex));
		}
		_snprintf(szTemp, TEMP_STR_LEN, ">> ");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};	
} M3G_AUDIO_TOOLBOX_USR;

typedef struct tagM3G_AUDIO_ENCODER_USR: public tagM3G_AUDIO_ENCODER{
	tagM3G_AUDIO_ENCODER_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { 
		return sizeof(*this);
	};
	VOID SetValid(UCHAR vValid)
	{
		ucValid = vValid;
	};
	VOID SetEnable(UCHAR vEnable)
	{
		ucEnable = vEnable;
	};
	VOID SetValue(UINT vCodecType, UINT vBitRateType, UINT vBitRate, UINT vTrackNum, UINT vSampleRate)
	{
		if(vCodecType!=(UINT)EHV_NOTHING)		ucCodecType = (UCHAR)vCodecType;
		if(vBitRateType!=(UINT)EHV_NOTHING)	ucBitRateType = (UCHAR)vBitRateType;
		if(vBitRate!=(UINT)EHV_NOTHING)		ulBitRate = vBitRate;
		if(vTrackNum!=(UINT)EHV_NOTHING)		ucTrackNum = (UCHAR)vTrackNum;
		if(vSampleRate!=(UINT)EHV_NOTHING)		ulSampleRate = vSampleRate;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,Enable=%d,CodecType=%d,BitRateType=%d,BitRate=%d,TrackNum=%d,SampleRate=%d>", 
			pszParamName?pszParamName:"AudioEncoder", ucValid, ucEnable, ucCodecType, ucBitRateType, ulBitRate, ucTrackNum, ulSampleRate);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_AUDIO_ENCODER_USR;

typedef struct tagM3G_AUDIO_OUTPUT_DEST_USR: public tagM3G_AUDIO_OUTPUT_DEST{
	tagM3G_AUDIO_OUTPUT_DEST_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { 
		return sizeof(*this);
	};
	VOID SetValue(UINT vTransportType, UINT vRfcType)
	{
		if(vTransportType!=(UINT)EHV_NOTHING) ucTransportType = (UCHAR)vTransportType;
		if(vRfcType!=(UINT)EHV_NOTHING) ucRfcType = (UCHAR)vRfcType;
	};
	VOID SetRTP(M3G_AUDIO_RTP *pRTP)
	{
		if(pRTP) memcpy(&RTP, pRTP, sizeof(M3G_AUDIO_RTP));
	};
	VOID SetRTCP(M3G_AUDIO_RTP *pRTCP)
	{
		if(pRTCP) memcpy(&RTCP, pRTCP, sizeof(M3G_AUDIO_RTCP));
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<TransportType=%d,RfcType=%d, ", 
			pszParamName?pszParamName:"AudioOutputDest", ucTransportType, ucRfcType);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		FAILRETN(((M3G_AUDIO_RTP_USR*)&RTP)->TraceStr(szOutStr));
		FAILRETN(((M3G_AUDIO_RTCP_USR*)&RTCP)->TraceStr(szOutStr));
		_snprintf(szTemp, TEMP_STR_LEN, "> ");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_AUDIO_OUTPUT_DEST_USR;

typedef struct tagM3G_AUDIO_OUTPUT_USR: public tagM3G_AUDIO_OUTPUT{
	tagM3G_AUDIO_OUTPUT_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { 
		return sizeof(*this);
	};
	VOID SetValid(UCHAR vValid)
	{
		ucValid = vValid;
	};
	VOID SetDest(UCHAR vDestNum, M3G_AUDIO_OUTPUT_DEST *pDest)
	{
		ucDestNum = vDestNum;
		if(ucDestNum>MAX_M3G_AUDIO_OUTPUT_DEST_NUM) ucDestNum=MAX_M3G_AUDIO_OUTPUT_DEST_NUM;
		if(pDest && ucDestNum>0) {
			memcpy(Dest, pDest, sizeof(M3G_AUDIO_OUTPUT_DEST)*ucDestNum);
		}
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,DestNum=%d, Dest<", 
			pszParamName?pszParamName:"AudioOutput", ucValid, ucDestNum);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		CHAR szIndex[16];
		if(ucDestNum>MAX_M3G_AUDIO_OUTPUT_DEST_NUM) ucDestNum=MAX_M3G_AUDIO_OUTPUT_DEST_NUM;
		for(INT i=0; i<ucDestNum; i++) {
			sprintf(szIndex, "%d", i);
			FAILRETN(((M3G_AUDIO_OUTPUT_DEST_USR*)&Dest[i])->TraceStr(szOutStr, szIndex));
		}
		_snprintf(szTemp, TEMP_STR_LEN, ">> ");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_AUDIO_OUTPUT_USR;

typedef struct tagM3G_CHAN_TYPE_AUDIO_PARAM_USR: public tagM3G_CHAN_TYPE_AUDIO_PARAM{
	tagM3G_CHAN_TYPE_AUDIO_PARAM_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { 
		return sizeof(*this);
	};
	VOID SetInput(M3G_AUDIO_INPUT *pInput)
	{
		if(pInput) memcpy(&Input, pInput, sizeof(M3G_AUDIO_INPUT));
	};
	VOID SetDecoder(M3G_AUDIO_DECODER *pDecoder)
	{
		if(pDecoder) memcpy(&Decoder, pDecoder, sizeof(M3G_AUDIO_DECODER));
	};
	VOID SetToolBox(M3G_AUDIO_TOOLBOX *pToolBox)
	{
		if(pToolBox) memcpy(&ToolBox, pToolBox, sizeof(M3G_AUDIO_TOOLBOX));
	};
	VOID SetEncoder(M3G_AUDIO_ENCODER *pEncoder)
	{
		if(pEncoder) memcpy(&Encoder, pEncoder, sizeof(M3G_AUDIO_ENCODER));
	};
	VOID SetOutput(M3G_AUDIO_OUTPUT *pOutput)
	{
		if(pOutput) memcpy(&Output, pOutput, sizeof(M3G_AUDIO_OUTPUT));
	};
	
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<", pszParamName?pszParamName:"AudioParm");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		FAILRETN(((M3G_AUDIO_INPUT_USR*)&Input)->TraceStr(szOutStr, "Input"));
		FAILRETN(((M3G_AUDIO_DECODER_USR*)&Decoder)->TraceStr(szOutStr, "Decoder"));
		FAILRETN(((M3G_AUDIO_TOOLBOX_USR*)&ToolBox)->TraceStr(szOutStr, "ToolBox"));
		FAILRETN(((M3G_AUDIO_ENCODER_USR*)&Encoder)->TraceStr(szOutStr, "Encoder"));
		FAILRETN(((M3G_AUDIO_OUTPUT_USR*)&Output)->TraceStr(szOutStr, "Output"));
		_snprintf(szTemp, TEMP_STR_LEN, "> ");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
}M3G_CHAN_TYPE_AUDIO_PARAM_USR;

typedef struct tagM3G_CHAN_PARAM_USR: public tagM3G_CHAN_PARAM {
	tagM3G_CHAN_PARAM_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() 
	{ 
		INT iRetVal= 0;
		switch(ucChanType) {
		case M3G_CHAN_TYPE_VOICE: iRetVal = sizeof(ucChanType)+((M3G_CHAN_TYPE_VOICE_PARAM_USR*)&voice)->GetSize(); break;
		case M3G_CHAN_TYPE_VIDEO: iRetVal = sizeof(ucChanType)+((M3G_CHAN_TYPE_VIDEO_PARAM_USR*)&video)->GetSize(); break;
		case M3G_CHAN_TYPE_H324M: iRetVal = sizeof(ucChanType)+((M3G_CHAN_TYPE_H324M_PARAM_USR*)&h324m)->GetSize(); break;
		case M3G_CHAN_TYPE_AUDIO: iRetVal = sizeof(ucChanType)+((M3G_CHAN_TYPE_AUDIO_PARAM_USR*)&audio)->GetSize(); break;
		default: break;
		}
		return iRetVal;
	};
	VOID SetChanType(UCHAR vChanType) 
	{
		if(vChanType!=(UCHAR)EHV_NOTHING) ucChanType = vChanType;
	};
	VOID SetVoice(M3G_CHAN_TYPE_VOICE_PARAM_USR* pVoiceParm)
	{
		if(pVoiceParm != NULL) memcpy(&voice, pVoiceParm, sizeof(M3G_CHAN_TYPE_VOICE_PARAM));
	};
	VOID SetVideo(M3G_CHAN_TYPE_VIDEO_PARAM_USR* pVideoParm)
	{
		if(pVideoParm != NULL) memcpy(&video, pVideoParm, sizeof(M3G_CHAN_TYPE_VIDEO_PARAM));
	}
	VOID SetH324m(M3G_CHAN_TYPE_H324M_PARAM_USR* pH324mParm)
	{
		if(pH324mParm != NULL) memcpy(&h324m, pH324mParm, sizeof(M3G_CHAN_TYPE_H324M_PARAM));
	}
	VOID SetAudio(M3G_CHAN_TYPE_AUDIO_PARAM_USR* pAudioParm)
	{
		if(pAudioParm != NULL) memcpy(&audio, pAudioParm, sizeof(M3G_CHAN_TYPE_AUDIO_PARAM));
	}
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		szOutStr[0] = 0;
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<ChanType=%d,", pszParamName?pszParamName:"ChanParm", ucChanType);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));

		switch(ucChanType) {
		case M3G_CHAN_TYPE_VOICE: 
			FAILRETN(((M3G_CHAN_TYPE_VOICE_PARAM_USR*)&voice)->TraceStr(szOutStr, "voice"));
			break;
		case M3G_CHAN_TYPE_VIDEO: 
			FAILRETN(((M3G_CHAN_TYPE_VIDEO_PARAM_USR*)&video)->TraceStr(szOutStr, "video"));
			break;
		case M3G_CHAN_TYPE_H324M: 
			FAILRETN(((M3G_CHAN_TYPE_H324M_PARAM_USR*)&h324m)->TraceStr(szOutStr, "h324m"));
			break;
		case M3G_CHAN_TYPE_AUDIO: 
			FAILRETN(((M3G_CHAN_TYPE_AUDIO_PARAM_USR*)&audio)->TraceStr(szOutStr, "audio"));
			break;
		default: 
			_snprintf(szTemp, TEMP_STR_LEN, "ERROR: Unknown channel type ");
			FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
			break;
		}

		_snprintf(szTemp, TEMP_STR_LEN, "> ");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
}M3G_CHAN_PARAM_USR;

typedef struct tagM3G_CHAN_EXINFO_USR: public tagM3G_CHAN_EXINFO{
	tagM3G_CHAN_EXINFO_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UCHAR vValid, M3GDEV vVideoDev=0, UCHAR vVideoMode=0, M3GDEV vAudioDev=0, UCHAR vAudioMode=0)
	{
		ucValid = vValid;
		if(ucValid == 0) return;
		if(ucValid == 1) {
			if(vVideoDev!=(M3GDEV)EHV_NOTHING) uVoiceRelated.VideoDev = vVideoDev;
			return;
		}
		if(ucValid == 2) {
			if(vAudioMode!=(UCHAR)EHV_NOTHING) uH324mRelated.ucAudioMode = vAudioMode;	
			if(vAudioDev!=(M3GDEV)EHV_NOTHING) uH324mRelated.AudioDev = vAudioDev;		
			if(vVideoMode!=(UCHAR)EHV_NOTHING) uH324mRelated.ucVideoMode = vVideoMode;	
			if(vVideoDev!=(M3GDEV)EHV_NOTHING) uH324mRelated.VideoDev = vVideoDev;		
		}
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		szOutStr[0] = 0;
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,", pszParamName?pszParamName:"ChanExInfo", ucValid);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));

		switch(ucValid) {
		case 0: break;
		case 1: 
			_snprintf(szTemp, TEMP_STR_LEN, "VoiceRela<VideoDev=%d> ", uVoiceRelated.VideoDev);
			FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
			break;
		case 2: 
			_snprintf(szTemp, TEMP_STR_LEN, "H324mRela<AudioMode=%d, AudioDev=%d, VideoMode=%d, VideoDev=%d> ", 
				uH324mRelated.ucAudioMode, uH324mRelated.AudioDev, uH324mRelated.ucVideoMode, uH324mRelated.VideoDev);
			FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
			break;
		default: 
			_snprintf(szTemp, TEMP_STR_LEN, "ERROR: Unknown type ");
			FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
			break;
		}

		_snprintf(szTemp, TEMP_STR_LEN, "> ");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
}M3G_CHAN_EXINFO_USR;

typedef struct tagM3G_FILE_BIN_PARAMS_USR: public tagM3G_FILE_BIN_PARAMS{
	tagM3G_FILE_BIN_PARAMS_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UINT vFragmentSize=160)
	{
		if(vFragmentSize!=(UINT)EHV_NOTHING) FragmentSize			= vFragmentSize;	
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<FragmentSize=%d> ", pszParamName?pszParamName:"Bin",
			FragmentSize);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_FILE_BIN_PARAMS_USR, M3G_FILE_AMR_PARAMS_USR;

typedef struct tagM3G_FILE_WAV_PARAMS_USR: public tagM3G_FILE_WAV_PARAMS{
	tagM3G_FILE_WAV_PARAMS_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UINT vCoder=0, UINT vBlockSize=M3G_WAV_BLOCK_SIZE_5MS)
	{
		if(vCoder!=(UINT)EHV_NOTHING) ulCoder			= vCoder;	
		if(vBlockSize!=(UINT)EHV_NOTHING) ulBlockSize	= vBlockSize;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<Coder=%d,BlockSize=%d> ", pszParamName?pszParamName:"Wav",
			ulCoder, ulBlockSize);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_FILE_WAV_PARAMS_USR;

typedef struct tagM3G_FILE_AV_PLAY_TRACK_PARAM_USR: public tagM3G_FILE_AV_PLAY_TRACK_PARAM{
	tagM3G_FILE_AV_PLAY_TRACK_PARAM_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UCHAR vSampleType=M3G_SAMPLE_TYPE_AMR_NB, 
		UCHAR vTimeStampSource=M3G_FILE_TIMING_SOURCE_SAMPLE_TIMESTAMPS, USHORT vFPS=10)
	{
		if(vSampleType!=(UCHAR)EHV_NOTHING)		 ucSampleType		= vSampleType;		
		if(vTimeStampSource!=(UCHAR)EHV_NOTHING) ucTimeStampSource	= vTimeStampSource;	
		if(vFPS!=(USHORT)EHV_NOTHING)			 usFPS				= vFPS;				
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<ST=%d,TSS=%d,FPS=%d> ", 
			pszParamName?pszParamName:"Av",	ucSampleType, ucTimeStampSource, usFPS);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_FILE_AV_PLAY_TRACK_PARAM_USR;

typedef struct tagM3G_FILE_AV_PLAY_PARAMS_USR: public tagM3G_FILE_AV_PLAY_PARAMS{
	tagM3G_FILE_AV_PLAY_PARAMS_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UCHAR vVoiceST=M3G_SAMPLE_TYPE_AMR_NB, 
				  UCHAR vVoiceTSS=M3G_FILE_TIMING_SOURCE_SAMPLE_TIMESTAMPS, 
				  USHORT vVoiceFPS=10,
				  UCHAR vVideoST=M3G_SAMPLE_TYPE_H263, 
				  UCHAR vVideoTSS=M3G_FILE_TIMING_SOURCE_SAMPLE_TIMESTAMPS, 
				  USHORT vVideoFPS=10 )
	{
		ucTrackNum = 0; 
		if(vVoiceST != (UCHAR)EHV_NOTHING) {
			ucTrackNum++;
			((M3G_FILE_AV_PLAY_TRACK_PARAM_USR*)&TrackParam[0])->SetValue(vVoiceST, vVoiceTSS, vVoiceFPS);
		}
		if(vVideoST != (UCHAR)EHV_NOTHING) {
			ucTrackNum++;
			((M3G_FILE_AV_PLAY_TRACK_PARAM_USR*)&TrackParam[1])->SetValue(vVideoST, vVideoTSS, vVideoFPS);
		}
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<TrackNum=%d,", pszParamName?pszParamName:"Av",	ucTrackNum);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		CHAR szIndex[10];
		for(INT i=0; i<MAX_TRACK_NUM; i++) {
			sprintf(szIndex, "%d", i);
			if(i>=ucTrackNum) break;
			FAILRETN(((M3G_FILE_AV_PLAY_TRACK_PARAM_USR*)&TrackParam[i])->TraceStr(szOutStr, szIndex));
		}
		
		_snprintf(szTemp, TEMP_STR_LEN, "> ");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_FILE_AV_PLAY_PARAMS_USR;

typedef struct tagM3G_FILE_AV_REC_TRACK_PARAM_USR: public tagM3G_FILE_AV_REC_TRACK_PARAM{
	tagM3G_FILE_AV_REC_TRACK_PARAM_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UCHAR vSampleType=M3G_SAMPLE_TYPE_H263, 
		UCHAR vTimeStampSource=M3G_FILE_TIMING_SOURCE_SAMPLE_TIMESTAMPS, 
		UINT vWidth=176, UINT vHeight=144, USHORT vFPS=10)
	{
		if(vSampleType!=(UCHAR)EHV_NOTHING) ucSampleType			= vSampleType;		
		if(vTimeStampSource!=(UCHAR)EHV_NOTHING) ucTimeStampSource	= vTimeStampSource;	
		if(vWidth!=(UINT)EHV_NOTHING) ulWidth						= vWidth;			
		if(vHeight!=(UINT)EHV_NOTHING) ulHeight					= vHeight;			
		if(vFPS!=(USHORT)EHV_NOTHING) usFPS							= vFPS;				
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<ST=%d,TSS=%d,W=%d,H=%d,FPS=%d> ", 
			pszParamName?pszParamName:"Av",	ucSampleType, ucTimeStampSource, ulWidth, ulHeight, usFPS);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_FILE_AV_REC_TRACK_PARAM_USR;

typedef struct tagM3G_FILE_AV_REC_PARAMS_USR: public tagM3G_FILE_AV_REC_PARAMS{
	tagM3G_FILE_AV_REC_PARAMS_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UCHAR vHintTracks=0, 
				UCHAR vVoiceST=M3G_SAMPLE_TYPE_AMR_NB, 
				UCHAR vVoiceTSS=M3G_FILE_TIMING_SOURCE_SAMPLE_TIMESTAMPS, 
				UINT vVoiceW=176, 
				UINT vVoiceH=144, 
				USHORT vVoiceFPS=10,
				UCHAR vVideoST=M3G_SAMPLE_TYPE_H263, 
				UCHAR vVideoTSS=M3G_FILE_TIMING_SOURCE_SAMPLE_TIMESTAMPS, 
				UINT vVideoW=176, 
				UINT vVideoH=144, 
				USHORT vVideoFPS=10 )
	{
		if(vHintTracks!=(UCHAR)EHV_NOTHING) ucHintTracks = vHintTracks;	
		ucTrackNum		=0;		
		if(vVoiceST!=(UCHAR)EHV_NOTHING) {
			ucTrackNum++;
			((M3G_FILE_AV_REC_TRACK_PARAM_USR*)&TrackParam[0])->SetValue(vVoiceST, vVoiceTSS, vVoiceW, vVoiceH, vVoiceFPS);
		}
		if(vVideoST!=(UCHAR)EHV_NOTHING) {
			ucTrackNum++;
			((M3G_FILE_AV_REC_TRACK_PARAM_USR*)&TrackParam[1])->SetValue(vVideoST, vVideoTSS, vVideoW, vVideoH, vVideoFPS);
		}
		
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<HT=%d,TrackNum=%d,", pszParamName?pszParamName:"Av",
			ucHintTracks, ucTrackNum);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		CHAR szIndex[10];
		for(INT i=0; i<MAX_TRACK_NUM; i++) {
			sprintf(szIndex, "%d", i);
			if(i>=ucTrackNum) break;
			FAILRETN(((M3G_FILE_AV_REC_TRACK_PARAM_USR*)&TrackParam[i])->TraceStr(szOutStr, szIndex));
		}
		
		_snprintf(szTemp, TEMP_STR_LEN, "> ");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_FILE_AV_REC_PARAMS_USR;

typedef struct tagM3G_XPB_USR: public tagM3G_XPB{
	tagM3G_XPB_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetAmrFormat(UINT vFragmentSize=0) 
	{ 
		ucFileType		=M3G_FILE_TYPE_AMR;
		((M3G_FILE_AMR_PARAMS_USR*)&amr)->SetValue(vFragmentSize);
	};	
	VOID SetBinFormat(UINT vFragmentSize=160) 
	{ 
		ucFileType		=M3G_FILE_TYPE_BIN;
		((M3G_FILE_BIN_PARAMS_USR*)&bin)->SetValue(vFragmentSize);
	};	
	VOID SetWavFormat(UINT vCoder=0, UINT vBlockSize=M3G_WAV_BLOCK_SIZE_5MS) 
	{ 
		ucFileType		=M3G_FILE_TYPE_WAV;
		((M3G_FILE_WAV_PARAMS_USR*)&wav)->SetValue(vCoder, vBlockSize);
	};
	VOID SetAvpFormat(eM3G_FILE_TYPE vFileType=M3G_FILE_TYPE_3GP, 
					  UCHAR vVoiceST=M3G_SAMPLE_TYPE_AMR_NB, 
					  UCHAR vVoiceTSS=M3G_FILE_TIMING_SOURCE_SAMPLE_TIMESTAMPS, 
					  USHORT vVoiceFPS=10,
					  UCHAR vVideoST=M3G_SAMPLE_TYPE_H263, 
					  UCHAR vVideoTSS=M3G_FILE_TIMING_SOURCE_SAMPLE_TIMESTAMPS, 
					  USHORT vVideoFPS=10 ) 
	{ 
		if(vFileType!=(UCHAR)EHV_NOTHING) ucFileType = vFileType;
		((M3G_FILE_AV_PLAY_PARAMS_USR*)&avp)->SetValue(vVoiceST, vVoiceTSS, vVoiceFPS, vVideoST, vVideoTSS, vVideoFPS);
	};
	VOID SetAvrFormat(eM3G_FILE_TYPE vFileType=M3G_FILE_TYPE_3GP, UCHAR vHintTracks=0, 
				UCHAR vVoiceST=M3G_SAMPLE_TYPE_AMR_NB, 
				UCHAR vVoiceTSS=M3G_FILE_TIMING_SOURCE_SAMPLE_TIMESTAMPS, 
				UINT vVoiceW=176, 
				UINT vVoiceH=144, 
				USHORT vVoiceFPS=10,
				UCHAR vVideoST=M3G_SAMPLE_TYPE_H263, 
				UCHAR vVideoTSS=M3G_FILE_TIMING_SOURCE_SAMPLE_TIMESTAMPS, 
				UINT vVideoW=176, 
				UINT vVideoH=144, 
				USHORT vVideoFPS=10 ) 
	{ 
		if(vFileType!=(UCHAR)EHV_NOTHING) ucFileType = vFileType;
		((M3G_FILE_AV_REC_PARAMS_USR*)&avr)->SetValue(vHintTracks, vVoiceST, vVoiceTSS, vVoiceW, vVoiceH, vVoiceFPS, 
			vVideoST, vVideoTSS, vVideoW, vVideoH, vVideoFPS);
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL, BOOL bIsRec = FALSE)
	{
		szOutStr[0] = 0;
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<FileType=%d,", pszParamName?pszParamName:"xpb",	ucFileType);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		if(M3G_FILE_TYPE_WAV==ucFileType){
			FAILRETN(((M3G_FILE_WAV_PARAMS_USR*)&wav)->TraceStr(szOutStr, "wav"));
		}  else if(M3G_FILE_TYPE_BIN==ucFileType) {
			FAILRETN(((M3G_FILE_BIN_PARAMS_USR*)&bin)->TraceStr(szOutStr, "Bin"));
		}  else if(M3G_FILE_TYPE_AMR==ucFileType) {
			FAILRETN(((M3G_FILE_AMR_PARAMS_USR*)&amr)->TraceStr(szOutStr, "Amr"));
		}  else {
			if(bIsRec) {
				FAILRETN(((M3G_FILE_AV_REC_PARAMS_USR*)&avr)->TraceStr(szOutStr, "avr"));	
			} else {
				FAILRETN(((M3G_FILE_AV_PLAY_PARAMS_USR*)&avp)->TraceStr(szOutStr, "avp"));
			}
		}
		_snprintf(szTemp, TEMP_STR_LEN, "> ");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
}M3G_XPB_USR;

typedef struct tagM3G_MEDIA_EX_USR: public tagM3G_MEDIA_EX{
	tagM3G_MEDIA_EX_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(eM3G_VOICE_CODER vVoCoder=M3G_VOCODER_GSM_AMR59_OA, INT vVolumeGain=0) 
	{ 
		if(vVoCoder!=(UCHAR)EHV_NOTHING) ucVoCoder = vVoCoder;
		if(vVolumeGain!=(INT)EHV_NOTHING) iVolumeGain = vVolumeGain;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		szOutStr[0] = 0;
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<VoCoder=%d,VolumeGain=%d> ", 
			pszParamName?pszParamName:"MediaEx", ucVoCoder, iVolumeGain);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
}M3G_MEDIA_EX_USR;

typedef struct tagM3G_DIGIT_INFO_USR: public tagM3G_DIGIT_INFO{ 
	tagM3G_DIGIT_INFO_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(CHAR* vDigits, UCHAR vDigitNum, UCHAR vDigitDir=DIGIT_TDM,
		UCHAR vDigitType=DIGIT_ALPHA_NUMERIC, UCHAR vDuration=75, UCHAR vInterval=40)
	{
		if(vDigitType!=(UCHAR)EHV_NOTHING) ucDigitType	= vDigitType;
		if(vDigitDir!=(UCHAR)EHV_NOTHING) ucDigitDir	= vDigitDir;
		if(vDigitNum >= sizeof(Digits)) {	
			ucDigitNum = sizeof(Digits) - 1;
		} else ucDigitNum	= vDigitNum;			
		if(vDigits && ucDigitNum>0) memcpy(Digits, vDigits, vDigitNum);	
		if(vDuration!=(UCHAR)EHV_NOTHING) ucDuration	= vDuration;	
		if(vInterval!=(UCHAR)EHV_NOTHING) ucInterval	= vInterval;	
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		szOutStr[0] = 0;
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<DigitType=%d,DigitDir=%d,DigitNum=%d, "
			"Digits=%s, Duration=%d, Interval=%d> ", pszParamName?pszParamName:"DigitInfo",	
			ucDigitType, ucDigitDir, ucDigitNum, Digits, ucDuration, ucInterval);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_DIGIT_INFO_USR;

typedef struct tagM3G_TCS_INFO_USR: public tagM3G_TCS_INFO{
	tagM3G_TCS_INFO_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue()
	{
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		szOutStr[0] = 0;
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<ST=%s,", pszParamName?pszParamName:"TcsInfo", 
			GetTcsStatus(ucTCSStatus));
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		FAILRETN(((M3G_TERM_CAPS_USR*)&localcaps)->TraceStr(szOutStr, "localcaps"));
		FAILRETN(((M3G_TERM_CAPS_USR*)&remotecaps)->TraceStr(szOutStr, "remotecaps"));
		FAILRETN(((M3G_TERM_CAPS_USR*)&matchcaps)->TraceStr(szOutStr, "matchcaps"));
		_snprintf(szTemp, TEMP_STR_LEN, "> ");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
	CHAR *GetTcsStatus(UCHAR vStatus)
	{
		switch(vStatus) {
		case M3G_TCS_STATUS_NONE:				return (CHAR *)"TCSS_NONE";				
		case M3G_TCS_STATUS_REQUEST:			return (CHAR *)"TCSS_REQUEST";			
		case M3G_TCS_STATUS_STARTED:			return (CHAR *)"TCSS_STARTED";			
		case M3G_TCS_STATUS_RESOLVED:			return (CHAR *)"TCSS_RESOLVED";			
		case M3G_TCS_STATUS_RESOLVED_FINISHED:	return (CHAR *)"TCSS_RESOLVED_FINISHED";
		case M3G_TCS_STATUS_ERROR:				return (CHAR *)"TCSS_ERROR";			
		case M3G_TCS_STATUS_IDLE:				return (CHAR *)"TCSS_IDLE";				
		default: return (CHAR *)"TCSS_UNKNOWN";
		}
		return (CHAR *)"TCSS_UNKNOWN";
	};
}M3G_TCS_INFO_USR;

typedef struct tagM3G_VIDEO_FAST_UPDATE_GOB_USR: public tagM3G_VIDEO_FAST_UPDATE_GOB{
	tagM3G_VIDEO_FAST_UPDATE_GOB_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UINT vFirstGOB=0, UINT vNumberOfGOBs=0)
	{
		if(vFirstGOB!=(UINT)EHV_NOTHING) ulFirstGOB = vFirstGOB;		
		if(vNumberOfGOBs!=(UINT)EHV_NOTHING) ulNumberOfGOBs = vNumberOfGOBs;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<FirstGOB=%d,NumberOfGOBs=%d> ", 
			pszParamName?pszParamName:"GOB", ulFirstGOB, ulNumberOfGOBs);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_VIDEO_FAST_UPDATE_GOB_USR;

typedef struct tagM3G_VIDEO_FAST_UPDATE_MB_USR: public tagM3G_VIDEO_FAST_UPDATE_MB{
	tagM3G_VIDEO_FAST_UPDATE_MB_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UINT vFirstGOB=0, UINT vFirstMB=0, UINT vNumberOfMBs=0)
	{
		if(vFirstGOB!=(UINT)EHV_NOTHING) ulFirstGOB = vFirstGOB;		
		if(vFirstMB!=(UINT)EHV_NOTHING) ulFirstMB	= vFirstMB;			
		if(vNumberOfMBs!=(UINT)EHV_NOTHING) ulNumberOfMBs = vNumberOfMBs;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<FirstGOB=%d,FirstMB=%d,NumberOfMBs=%d> ", 
			pszParamName?pszParamName:"MB", ulFirstGOB, ulFirstMB, ulNumberOfMBs);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_VIDEO_FAST_UPDATE_MB_USR;

typedef struct tagM3G_SKEW_INDICATION_USR: public tagM3G_SKEW_INDICATION{
	tagM3G_SKEW_INDICATION_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UINT vSkew=0)
	{
		if(vSkew!=(UINT)EHV_NOTHING) ulSkew = vSkew;	
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<Skew=%d> ", pszParamName?pszParamName:"SKEW", ulSkew);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_SKEW_INDICATION_USR;

typedef struct tagM3G_H245_MISC_INFO_USR: public tagM3G_H245_MISC_INFO{
	tagM3G_H245_MISC_INFO_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue()
	{
		ucLogicChanNo	=0;
		ulMiscCmdId		=M3G_MISC_ID_VIDEO_FAST_UPDATE_GOB;
		((M3G_VIDEO_FAST_UPDATE_GOB_USR*)&vfug)->SetValue();
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		szOutStr[0] = 0;
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<LogicChanNo=%d,MiscCmdId=%d ", 
			pszParamName?pszParamName:"MISC", ucLogicChanNo, ulMiscCmdId);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		switch(ulMiscCmdId) {
		case M3G_MISC_ID_VIDEO_FAST_UPDATE_GOB:
			FAILRETN(((M3G_VIDEO_FAST_UPDATE_GOB_USR*)&vfug)->TraceStr(szOutStr, "GOB"));
			break;
		case M3G_MISC_ID_VIDEO_FAST_UPDATE_MB:
			FAILRETN(((M3G_VIDEO_FAST_UPDATE_MB_USR*)&vfug)->TraceStr(szOutStr, "MB"));
			break;
		case M3G_MISC_ID_SKEW_INDICATION:
			FAILRETN(((M3G_SKEW_INDICATION_USR*)&vfug)->TraceStr(szOutStr, "SKEW"));
			break;
		default: break;
		}
		_snprintf(szTemp, TEMP_STR_LEN, "> ");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));

		return 0;
	};
} M3G_H245_MISC_INFO_USR;

typedef struct tagM3G_LC_PARAM_USR: public tagM3G_LC_PARAM{
	tagM3G_LC_PARAM_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue() { };
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		szOutStr[0] = 0;
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<LC=%d,Status=%s,", pszParamName?pszParamName:"LcParm", 
			ucLogicChanNo, GetLcStatusName(ucLCStatus));
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		FAILRETN(((M3G_MEDIA_CHAN_USR*)&parm)->TraceStr(szOutStr, "MediaChan"));
		_snprintf(szTemp, TEMP_STR_LEN, "> ");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
	CHAR *GetLcStatusName(UCHAR vLcStatus) 
	{
		switch(vLcStatus) {
		case M3G_LC_STATUS_CREATED:					return (CHAR *)"LCS_CREATED";				
		case M3G_LC_STATUS_REQUEST:					return (CHAR *)"LCS_REQUEST";				
		case M3G_LC_STATUS_STARTED:					return (CHAR *)"LCS_STARTED";				
		case M3G_LC_STATUS_RESOLVED:				return (CHAR *)"LCS_RESOLVED";				
		case M3G_LC_STATUS_RESOLVED_FINISHED:		return (CHAR *)"LCS_RESOLVED_FINISHED";		
		case M3G_LC_STATUS_ERROR:					return (CHAR *)"LCS_ERROR";					
		case M3G_LC_STATUS_IDLE:					return (CHAR *)"LCS_IDLE";					
		default: return (CHAR *)"LCS_UNKNOWN";
		}
		return (CHAR *)"LCS_UNKNOWN";
	};
} M3G_LC_PARAM_USR;

typedef struct tagM3G_CALL_STATUS_USR: public tagM3G_CALL_STATUS{	
	tagM3G_CALL_STATUS_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue() { };
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		szOutStr[0] = 0;
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<LinkStatus=%s,CPStatus=%s> ", 
			pszParamName?pszParamName:"CallStatus", GetLinkStatusName(ucLinkStatus), GetCPStatusName(ucCPStatus));
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
	CHAR* GetLinkStatusName(UCHAR vLinkStatus) 
	{
		switch(vLinkStatus) {
		case M3G_H223_LINK_STATUS_NONE:			return (CHAR*)"HLS_NONE";			
		case M3G_H223_LINK_STATUS_SYNCHROZING:	return (CHAR*)"HLS_SYNCHROZING";	
		case M3G_H223_LINK_STATUS_CONNECTED:	return (CHAR*)"HLS_CONNECTED";		
		case M3G_H223_LINK_STATUS_ERROR:		return (CHAR*)"HLS_ERROR";			
		case M3G_H223_LINK_STATUS_IDLE:			return (CHAR*)"HLS_IDLE";			
		default: return (CHAR *)"HLS_UNKNOWN";
		}
		return (CHAR *)"HLS_UNKNOWN";
	};
	CHAR* GetCPStatusName(UCHAR vCPStatus) 
	{
		switch(vCPStatus) {
		case M3G_CP_STATUS_IDLE:				return (CHAR*)"CPS_IDLE";			
		case M3G_CP_STATUS_INITIALIZING:		return (CHAR*)"CPS_INITIALIZING";	
		case M3G_CP_STATUS_ACTIVING:			return (CHAR*)"CPS_ACTIVING";		
		case M3G_CP_STATUS_ACTIVED:				return (CHAR*)"CPS_ACTIVED";		
		case M3G_CP_STATUS_DEACTIVING:			return (CHAR*)"CPS_DEACTIVING";	
		case M3G_CP_STATUS_CLEAN_UP:			return (CHAR*)"CPS_CLEAN_UP";	
		default: return (CHAR *)"CPS_UNKNOWN";
		}
		return (CHAR *)"CPS_UNKNOWN";
	};
} M3G_CALL_STATUS_USR;

typedef struct tagM3G_MSD_INFO_USR: public tagM3G_MSD_INFO{	
	tagM3G_MSD_INFO_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue() { };
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		szOutStr[0] = 0;
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<ST=%s,LocalIsMaster=%d,LocalTermType=%d,RemoteTermType=%d> ", 
			pszParamName?pszParamName:"MsdInfo", GetMsdStatusName(ucMsdStatus), ucLocalIsMaster, ucLocalTermType, ucRemoteTermType);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
	CHAR *GetMsdStatusName(UCHAR vMsdStatus)
	{
		switch(vMsdStatus) {
		case M3G_MSD_STATUS_NONE:				return (CHAR*)"MSDS_NONE";		
		case M3G_MSD_STATUS_REQUEST:			return (CHAR*)"MSDS_REQUEST";	
		case M3G_MSD_STATUS_STARTED:			return (CHAR*)"MSDS_STARTED";	
		case M3G_MSD_STATUS_RESOLVED:			return (CHAR*)"MSDS_RESOLVED";	
		case M3G_MSD_STATUS_RESOLVED_FINISHED:	return (CHAR*)"MSDS_RESOLVED_FINISHED";
		case M3G_MSD_STATUS_ERROR:				return (CHAR*)"MSDS_ERROR";	
		case M3G_MSD_STATUS_IDLE:				return (CHAR*)"MSDS_IDLE";	
		default: return (CHAR *)"MSDS_UNKNOWN";
		}
		return (CHAR *)"MSDS_UNKNOWN";
	};
} M3G_MSD_INFO_USR;

typedef struct tagM3G_LC_INFO_USR: public tagM3G_LC_INFO{
	tagM3G_LC_INFO_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue() { };
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		szOutStr[0] = 0;
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<ChanNo=%d,ST=%d,Codec=[%d,%d,%d,%d],IsMuted=%d> ", 
			pszParamName?pszParamName:"LcInfo", ucLogicChanNo, ucLCStatus, 
			ucCodec[0], ucCodec[1], ucCodec[2], ucCodec[3], ucIsMuted);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_LC_INFO_USR;

typedef struct tagISXSIP_IE_SDP_MEDIA_DESC_EX_USR: public ISXSIP_IE_SDP_MEDIA_DESC_EX {
	tagISXSIP_IE_SDP_MEDIA_DESC_EX_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue() { };
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		return 0;
	};
	INT GetValueForAudio(eAUDIOCODEC *eCodecIdp, ISXSIP_IE_SDP_MEDIA_DESC_EX *AudioDescp) 
	{
		if(MediaType != ISXSIP_SDPMEDIATYPE_AUDIO) return FALSE;
		memcpy(AudioDescp, this, sizeof(ISXSIP_IE_SDP_MEDIA_DESC_EX));

		SIP_CODEC_PAYLOAD_MAP* pCodecMap;
		for(INT j=0; j<(INT)PayLoadNum; j++){
			INT iRet = ISXE_gc_SipGetCodecMap(CODECT_AUDIO, Payload[j], &pCodecMap);
			if(iRet==0){
				//p rintf("MEDIA_DESC, CodecId: %d, PayLoadType=%d, CodecName:%s, MediaPort=%d \n", 
				//	k, Payload[j], g_SipSdpRtpMap[k].EncodingName, AudioDescp->MediaPort);
				*eCodecIdp = (eAUDIOCODEC)pCodecMap->codec;
				AudioDescp->PayLoadNum=1;
				AudioDescp->Payload[0]=Payload[j];
				return 0;
			}
		}
		return -1;
	};
	INT GetValueForVoice(eM3G_VOICE_CODER *eCodecIdp, ISXSIP_IE_SDP_MEDIA_DESC_EX *VoiceDescp) 
	{
		if(MediaType != ISXSIP_SDPMEDIATYPE_AUDIO) return -1;
		memcpy(VoiceDescp, this, sizeof(ISXSIP_IE_SDP_MEDIA_DESC_EX));

		SIP_CODEC_PAYLOAD_MAP* pCodecMap;
		for(INT j=0; j<(INT)PayLoadNum; j++){
			INT iRet = ISXE_gc_SipGetCodecMap(CODECT_VOICE, Payload[j], &pCodecMap);
			if(iRet==0){
				//p rintf("VOICE_DESC, CodecId: %d, PayLoadType=%d, CodecName:%s, MediaPort=%d \n", 
				//	pCodecMap->codec, Payload[j], pCodecMap->rtpmap.EncodingName, VoiceDescp->MediaPort);
				*eCodecIdp = (eM3G_VOICE_CODER)pCodecMap->codec;
				VoiceDescp->PayLoadNum=2;
				VoiceDescp->Payload[0]=Payload[j];
				VoiceDescp->Payload[1]=101;
				return 0;
			}
		}
		return -1;
	};
	INT GetValueForVideo(eM3G_VIDEO_CODER *eCodecIdp, ISXSIP_IE_SDP_MEDIA_DESC_EX *VideoDescp) 
	{
		if(MediaType != ISXSIP_SDPMEDIATYPE_VIDEO) return -1;
		memcpy(VideoDescp, this, sizeof(ISXSIP_IE_SDP_MEDIA_DESC_EX));

		SIP_CODEC_PAYLOAD_MAP* pCodecMap;
		for(INT j=0; j<(INT)PayLoadNum; j++){
			INT iRet = ISXE_gc_SipGetCodecMap(CODECT_VIDEO, Payload[j], &pCodecMap);
			if(iRet==0){
				//p rintf("VIDEO_DESC, CodecId: %d, PayLoadType=%d, CodecName:%s, MediaPort=%d \n", 
				//	pCodecMap->codec, Payload[j], pCodecMap->rtpmap.EncodingName, VideoDescp->MediaPort);
				*eCodecIdp = (eM3G_VIDEO_CODER)pCodecMap->codec;
				VideoDescp->PayLoadNum=1;
				VideoDescp->Payload[0]=Payload[j];
				return 0;
			}
		}
		return -1;
	};
}ISXSIP_IE_SDP_MEDIA_DESC_EX_USR;

typedef struct tagISXSIP_IE_BODY_EX_USR: public ISXSIP_IE_BODY_EX {
	tagISXSIP_IE_BODY_EX_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue() { };
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		return 0;
	};
	INT GetCallMediaDesc(CHAR* szSrcAddr, 
						  eM3G_VOICE_CODER *eVoiceCodecp, 
						  ISXSIP_IE_SDP_MEDIA_DESC_EX*	VoiceDescp,
					      eM3G_VIDEO_CODER *eVideoCodecp, 
						  ISXSIP_IE_SDP_MEDIA_DESC_EX*	VideoDescp)
	{
		if(Valid == 0) return -1;
		if(BodyPartyType == BodyPartyType_TRANS) return -1;

		INT	 iLoopNum = u.BodySdp.SdpNum;
		BOOL bGetAddrOk = FALSE;
		BOOL bGetVoiceOk = FALSE;
		BOOL bGetVideoOk = FALSE;
		ISXSIP_IE_BODY_SDP_EX* psdpex = &u.BodySdp;
		for(INT i=0; i<iLoopNum; i++){
			if(psdpex->Sdp[i].Tag == ISXSIP_IE_SDP_TAG_CONNECTION){
				strcpy(szSrcAddr, psdpex->Sdp[i].u.Connection.Addr);
				bGetAddrOk = TRUE;
				continue;
			}

			if(psdpex->Sdp[i].Tag != ISXSIP_IE_SDP_TAG_MEDIA_DESC) continue;
			ISXSIP_IE_SDP_MEDIA_DESC_EX_USR* pmdex = (ISXSIP_IE_SDP_MEDIA_DESC_EX_USR*)&psdpex->Sdp[i].u.MediaDesc;
			if(!bGetVoiceOk) bGetVoiceOk = (pmdex->GetValueForVoice(eVoiceCodecp, VoiceDescp)==0)?TRUE:FALSE;
			if(!bGetVideoOk) bGetVideoOk = (pmdex->GetValueForVideo(eVideoCodecp, VideoDescp)==0)?TRUE:FALSE;
		}
		if(bGetAddrOk && bGetVoiceOk && bGetVideoOk) return 0;
		if(bGetAddrOk && bGetVoiceOk) return 1;
		return -1;
	};	
	INT GetCallMediaDesc4Audio(CHAR* szSrcAddr, UINT *AudioCodecp, ISXSIP_IE_SDP_MEDIA_DESC_EX* AudioDescp)
	{
		if(Valid == 0) return -1;
		if(BodyPartyType == BodyPartyType_TRANS) return -1;

		INT	 iLoopNum = u.BodySdp.SdpNum;
		BOOL bGetAddrOk = FALSE;
		BOOL bGetVoiceOk = FALSE;
		ISXSIP_IE_BODY_SDP_EX* psdpex = &u.BodySdp;
		for(INT i=0; i<iLoopNum; i++){
			if(psdpex->Sdp[i].Tag == ISXSIP_IE_SDP_TAG_CONNECTION){
				strcpy(szSrcAddr, psdpex->Sdp[i].u.Connection.Addr);
				bGetAddrOk = TRUE;
				continue;
			}

			if(psdpex->Sdp[i].Tag != ISXSIP_IE_SDP_TAG_MEDIA_DESC) continue;
			ISXSIP_IE_SDP_MEDIA_DESC_EX_USR* pmdex = (ISXSIP_IE_SDP_MEDIA_DESC_EX_USR*)&psdpex->Sdp[i].u.MediaDesc;
			if(!bGetVoiceOk) bGetVoiceOk = (pmdex->GetValueForAudio((eAUDIOCODEC *)AudioCodecp, AudioDescp)==0)?TRUE:FALSE;
		}
		if(bGetAddrOk && bGetVoiceOk) return 0;
		return -1;
	};	
	VOID SetBodySdp_o(ISXSIP_IE_BODY_SDP_EX* pb, CHAR* szConnAddr)
	{
		//o
		INT iIndex = pb->SdpNum;
		pb->Sdp[iIndex].Tag = ISXSIP_IE_SDP_TAG_ORIGIN;
		pb->Sdp[iIndex].Len = sizeof(ISXSIP_IE_SDP_ORIGIN);
		pb->Sdp[iIndex].u.Origin.NetType = ISXSIP_SDPNETTYPE_IN; 
		pb->Sdp[iIndex].u.Origin.AddrType = ISXSIP_SDPADDRTYPE_IP4;
		strcpy(pb->Sdp[iIndex].u.Origin.SessionId, "20");
		strcpy(pb->Sdp[iIndex].u.Origin.UserName, "EHang");
		strcpy(pb->Sdp[iIndex].u.Origin.Version, "001");
		strcpy(pb->Sdp[iIndex].u.Origin.Addr, szConnAddr);
		pb->SdpNum++;			
	};
	VOID SetBodySdp_s(ISXSIP_IE_BODY_SDP_EX* pb)
	{
		//s
		INT iIndex = pb->SdpNum;
		pb->Sdp[iIndex].Tag = ISXSIP_IE_SDP_TAG_SESSION;
		pb->Sdp[iIndex].Len = sizeof(ISXSIP_IE_SDP_SESSION);
		strcpy(pb->Sdp[iIndex].u.Session.Name, "EH-Call");
		strcpy(pb->Sdp[iIndex].u.Session.Info, "");
		pb->SdpNum++;			
	};
	VOID SetBodySdp_c(ISXSIP_IE_BODY_SDP_EX* pb, CHAR* szConnAddr)
	{
		//c
		INT iIndex = pb->SdpNum;
		pb->Sdp[iIndex].Tag = ISXSIP_IE_SDP_TAG_CONNECTION;
		pb->Sdp[iIndex].Len = sizeof(ISXSIP_IE_SDP_CONNECTION);
		pb->Sdp[iIndex].u.Connection.NetType = ISXSIP_SDPNETTYPE_IN; 
		pb->Sdp[iIndex].u.Connection.AddrType = ISXSIP_SDPADDRTYPE_IP4;
		sprintf(pb->Sdp[iIndex].u.Connection.Addr, szConnAddr);
		//p rintf("Connection.Addr= %s \n",pb->Sdp[iIndex].u.Connection.Addr);
		pb->SdpNum++;			
	};
	VOID SetBodySdp_t(ISXSIP_IE_BODY_SDP_EX* pb)
	{
		//t
		INT iIndex = pb->SdpNum;
		pb->Sdp[iIndex].Tag = ISXSIP_IE_SDP_TAG_SESSION_TIME;
		pb->Sdp[iIndex].Len = sizeof(ISXSIP_IE_SDP_SESSION_TIME);
		pb->Sdp[iIndex].u.SessionTime.Start = 0;
		pb->Sdp[iIndex].u.SessionTime.End = 0;
		pb->SdpNum++;
	};
	VOID SetBodySdp_m(ISXSIP_IE_BODY_SDP_EX* pb, ISXSIP_IE_SDP_MEDIA_DESC_EX* pMediaDesc)
	{
		//m
		INT iIndex = pb->SdpNum;
		pb->Sdp[iIndex].Tag = ISXSIP_IE_SDP_TAG_MEDIA_DESC;
		pb->Sdp[iIndex].Len = sizeof(ISXSIP_IE_SDP_MEDIA_DESC_EX);
		ISXSIP_IE_SDP_MEDIA_DESC_EX *pmdex =(ISXSIP_IE_SDP_MEDIA_DESC_EX *)&pb->Sdp[iIndex].u.MediaDesc;
		memcpy(pmdex, pMediaDesc, sizeof(ISXSIP_IE_SDP_MEDIA_DESC_EX));
		pb->SdpNum++;
	};
	VOID SetBodySdp_rtpmap(ISXSIP_IE_BODY_SDP_EX* pb, ISXSIP_IE_SDP_RTP_MAP* pSdpRtpMap)
	{
		//rtpmap
		INT iIndex = pb->SdpNum;
		pb->Sdp[iIndex].Tag = ISXSIP_IE_SDP_TAG_RTP_MAP;
		pb->Sdp[iIndex].Len = sizeof(ISXSIP_IE_SDP_RTP_MAP);
		ISXSIP_IE_SDP_RTP_MAP* pRtpMap = &pb->Sdp[iIndex].u.RtpMap;
		memcpy(pRtpMap, pSdpRtpMap, sizeof(ISXSIP_IE_SDP_RTP_MAP));
		pb->SdpNum++;			
	};
	VOID SetBodySdp_a(ISXSIP_IE_BODY_SDP_EX* pb, CHAR *vAttrName, CHAR *vAttrValue)
	{
		//a
		INT iIndex = pb->SdpNum;
		pb->Sdp[iIndex].Tag = ISXSIP_IE_SDP_TAG_ATTRIBUTE;
		pb->Sdp[iIndex].Len = sizeof(ISXSIP_IE_SDP_ATTRIBUTE);
		strcpy(pb->Sdp[iIndex].u.Attribute.Name, vAttrName);
		strcpy(pb->Sdp[iIndex].u.Attribute.Value, vAttrValue);
		pb->SdpNum++;
	};
	VOID SetBodySdp_mediaencode(ISXSIP_IE_BODY_SDP_EX* pb, UCHAR Payload)
	{
		//mediaencode
		INT iIndex = pb->SdpNum;
		pb->Sdp[iIndex].Tag = ISXSIP_IE_SDP_TAG_MEDIA_ENCODE;
		pb->Sdp[iIndex].Len = sizeof(ISXSIP_IE_SDP_MEDIA_ENCODE);
		pb->Sdp[iIndex].u.MediaEncode.Payload = Payload;
		pb->SdpNum++;			
	};	
	VOID SetBodySdp_fmtp(ISXSIP_IE_BODY_SDP_EX* pb, ISXSIP_IE_SDP_FMTP_EX* pSdpFmtp)
	{
		//fmtp
		INT iIndex = pb->SdpNum;
		pb->Sdp[iIndex].Tag = ISXSIP_IE_SDP_TAG_FMTP;
		pb->Sdp[iIndex].Len = sizeof(ISXSIP_IE_SDP_FMTP_EX);
		ISXSIP_IE_SDP_FMTP_EX* pFmtp = (ISXSIP_IE_SDP_FMTP_EX*)&pb->Sdp[iIndex].u.Fmtp;
		memcpy(pFmtp, pSdpFmtp, sizeof(ISXSIP_IE_SDP_FMTP_EX));
		pb->SdpNum++;			
	};

	INT SetCallBodySdp(CHAR* szConnAddr, 
						eM3G_VOICE_CODER eVoiceCodec, 
						ISXSIP_IE_SDP_MEDIA_DESC_EX* pVoiceDesc,
					    eM3G_VIDEO_CODER eVideoCodec, 
						ISXSIP_IE_SDP_MEDIA_DESC_EX* pVideoDesc)
	{
		Valid = 1;
		BodyPartyType = BodyPartyType_SDP;

		ISXSIP_IE_BODY_SDP_EX* pb = &u.BodySdp;
		pb->SdpNum = 0;
		//o
		SetBodySdp_o(pb, szConnAddr);
		//s
		SetBodySdp_s(pb);
		//c
		SetBodySdp_c(pb, szConnAddr);
		//t
		SetBodySdp_t(pb);
		//m
		SetBodySdp_m(pb, pVoiceDesc);
		//rtpmap
		ISXSIP_IE_SDP_RTP_MAP SdpRtpMap;
		SdpRtpMap.Payload = pVoiceDesc->Payload[1];
		SdpRtpMap.ClkRate	= 8000;
		strcpy(SdpRtpMap.EncodingName,  "telephone-event");
		strcpy(SdpRtpMap.EncodingParam, "");
		SetBodySdp_rtpmap(pb, &SdpRtpMap);

		//fmtp
		ISXSIP_IE_SDP_FMTP_EX SdpFmtp;
		sprintf(SdpFmtp.fmtf, "%d 0-15", pVoiceDesc->Payload[1]);
		SetBodySdp_fmtp(pb, &SdpFmtp);

		//a
		CHAR a_value[24];
		//sprintf(a_value, "%d 0-15", pVoiceDesc->Payload[1]);
		//SetBodySdp_a(pb, (CHAR *)"fmtp", a_value);
		SetBodySdp_a(pb, (CHAR *)"sendrecv", (CHAR *)"");
		
		//m
		SetBodySdp_m(pb, pVideoDesc);

		//a
		SetBodySdp_a(pb, (CHAR *)"sendrecv", (CHAR *)"");

		switch(eVideoCodec)
		{
		case M3G_VICODER_MPEG4:	
			//rtpmap
			SdpRtpMap.Payload = pVideoDesc->Payload[0];
			SdpRtpMap.ClkRate	= 90000;
			strcpy(SdpRtpMap.EncodingName,  "MPEG4"); 
			strcpy(SdpRtpMap.EncodingParam, "");
			SetBodySdp_rtpmap(pb, &SdpRtpMap);
			break;
		case M3G_VICODER_H263:
			//rtpmap
			SdpRtpMap.Payload = pVideoDesc->Payload[0];
			SdpRtpMap.ClkRate	= 90000;
			strcpy(SdpRtpMap.EncodingName,  "H263"); //34
			strcpy(SdpRtpMap.EncodingParam, "");
			SetBodySdp_rtpmap(pb, &SdpRtpMap);
			//a
			sprintf(a_value, "%d QCIF=1", pVideoDesc->Payload[0]); //34
			SetBodySdp_a(pb, (CHAR *)"fmtp", a_value);
			break;
		case M3G_VICODER_H264: 
			//rtpmap
			SdpRtpMap.Payload = pVideoDesc->Payload[0];
			SdpRtpMap.ClkRate	= 90000;
			strcpy(SdpRtpMap.EncodingName,  "H264"); //123
			strcpy(SdpRtpMap.EncodingParam, "");
			SetBodySdp_rtpmap(pb, &SdpRtpMap);
			break;
		case M3G_VICODER_WMV9:  
			//rtpmap
			SdpRtpMap.Payload = pVideoDesc->Payload[0];
			SdpRtpMap.ClkRate	= 90000;
			strcpy(SdpRtpMap.EncodingName,  "WMV9"); 
			strcpy(SdpRtpMap.EncodingParam, "");
			SetBodySdp_rtpmap(pb, &SdpRtpMap);
			break;
		case M3G_VICODER_H263_PLUS:
			//rtpmap
			SdpRtpMap.Payload = pVideoDesc->Payload[0];
			SdpRtpMap.ClkRate	= 90000;
			strcpy(SdpRtpMap.EncodingName,  "H263-1998"); //115
			strcpy(SdpRtpMap.EncodingParam, "");
			SetBodySdp_rtpmap(pb, &SdpRtpMap);
			//a
			sprintf(a_value, "%d CIF=1", pVideoDesc->Payload[0]); //115
			SetBodySdp_a(pb, (CHAR *)"fmtp", a_value);
			break;
		}
		//a
		//sprintf(a_value, "%d profile=0,level=10", pVideoDesc->Payload[0]); //107
		//sprintf(a_value, "%d QCIF=1;CIF=1", pVideoDesc->Payload[0]); //34
		//sprintf(a_value, "%d QCIF=1", pVideoDesc->Payload[0]); //34
		//sprintf(a_value, "%d QCIF=1;I=1;J=1;T=1", pVideoDesc->Payload[0]); //115
		//sprintf(a_value, "%d packetization-mode=0", pVideoDesc->Payload[0]); //123
		//sprintf(a_value, "%d packetization-mode=1", pVideoDesc->Payload[1]); //124
		//SetBodySdp_a(pb, "fmtp", a_value);

		return 0;
	};	
	INT SetCallBodySdp(CHAR* szConnAddr, 
						eM3G_VOICE_CODER eVoiceCodec, 
						ISXSIP_IE_SDP_MEDIA_DESC_EX* pVoiceDesc)
	{
		Valid = 1;
		BodyPartyType = BodyPartyType_SDP;

		ISXSIP_IE_BODY_SDP_EX* pb = &u.BodySdp;
		pb->SdpNum = 0;
		//o
		SetBodySdp_o(pb, szConnAddr);
		//s
		SetBodySdp_s(pb);
		//c
		SetBodySdp_c(pb, szConnAddr);
		//t
		SetBodySdp_t(pb);
		//m
		SetBodySdp_m(pb, pVoiceDesc);
		//rtpmap
		ISXSIP_IE_SDP_RTP_MAP SdpRtpMap;
		SdpRtpMap.Payload = pVoiceDesc->Payload[1];
		SdpRtpMap.ClkRate	= 8000;
		strcpy(SdpRtpMap.EncodingName,  "telephone-event");
		strcpy(SdpRtpMap.EncodingParam, "");
		SetBodySdp_rtpmap(pb, &SdpRtpMap);

		//fmtp
		ISXSIP_IE_SDP_FMTP_EX SdpFmtp;
		sprintf(SdpFmtp.fmtf, "%d 0-15", pVoiceDesc->Payload[1]);
		SetBodySdp_fmtp(pb, &SdpFmtp);
	
		//a
		//CHAR a_value[24];
		//sprintf(a_value, "%d 0-15", pVoiceDesc->Payload[1]);
		//SetBodySdp_a(pb, (CHAR *)"fmtp", a_value);
		SetBodySdp_a(pb, (CHAR *)"sendrecv", (CHAR *)"");

	
		return 0;
	};
	INT SetCallBodySdp4Audio(CHAR* szConnAddr, ISXSIP_IE_SDP_MEDIA_DESC_EX* pAudioDesc)
	{
		Valid = 1;
		BodyPartyType = BodyPartyType_SDP;

		ISXSIP_IE_BODY_SDP_EX* pb = &u.BodySdp;
		pb->SdpNum = 0;
		//o
		SetBodySdp_o(pb, szConnAddr);
		//s
		SetBodySdp_s(pb);
		//c
		SetBodySdp_c(pb, szConnAddr);
		//t
		SetBodySdp_t(pb);
		//m
		SetBodySdp_m(pb, pAudioDesc);
		//rtpmap
		ISXSIP_IE_SDP_RTP_MAP SdpRtpMap;
		SdpRtpMap.Payload = pAudioDesc->Payload[1];
		SdpRtpMap.ClkRate	= 8000;
		strcpy(SdpRtpMap.EncodingName,  "telephone-event");
		strcpy(SdpRtpMap.EncodingParam, "");
		SetBodySdp_rtpmap(pb, &SdpRtpMap);

		//mediaencode
		SetBodySdp_mediaencode(pb, pAudioDesc->Payload[1]);
		
		//fmtp
		ISXSIP_IE_SDP_FMTP_EX SdpFmtp;
		sprintf(SdpFmtp.fmtf, "%d 0-15", pAudioDesc->Payload[1]);
		SetBodySdp_fmtp(pb, &SdpFmtp);

		//a
		//CHAR a_value[24];
		//sprintf(a_value, "%d 0-15", pAudioDesc->Payload[1]);
		//SetBodySdp_a(pb, (CHAR *)"fmtp", a_value);
		SetBodySdp_a(pb, (CHAR *)"sendrecv", (CHAR *)"");

		return 0;
	};	
	INT ConstructAudioBody(char *szConnAddr, USHORT nSrcMediaPort, UCHAR nPayLoad1=8, UCHAR nPayLoad2=101)
	{
		ISXSIP_IE_BODY_SDP_EX* pb = NULL;
		
		Valid = 1;
		BodyPartyType = BodyPartyType_SDP;
		
		pb = &u.BodySdp;
		pb->SdpNum = 0;

		//o
		SetBodySdp_o(pb, szConnAddr);	
		//s
		SetBodySdp_s(pb);		
		//c
		SetBodySdp_c(pb, szConnAddr);		
		//t
		SetBodySdp_t(pb);

		//m
		ISXSIP_IE_SDP_MEDIA_DESC_EX MediaDescEx;
		MediaDescEx.MediaPort = nSrcMediaPort;
		MediaDescEx.MediaProtocol = ISXSIP_SDPPROTOCOL_RTP;
		MediaDescEx.MediaType = ISXSIP_SDPMEDIATYPE_AUDIO;
		MediaDescEx.PayLoadNum = 2;
		MediaDescEx.Payload[0] = nPayLoad1; 
		MediaDescEx.Payload[1] = nPayLoad2;
		SetBodySdp_m(pb, &MediaDescEx);

		//rtpmap
		ISXSIP_IE_SDP_RTP_MAP SdpRtpMap;
		SdpRtpMap.Payload = nPayLoad2;
		SdpRtpMap.ClkRate	= 8000;
		strcpy(SdpRtpMap.EncodingName,  "telephone-event");
		strcpy(SdpRtpMap.EncodingParam, "");
		SetBodySdp_rtpmap(pb, &SdpRtpMap);

		//mediaencode
		SetBodySdp_mediaencode(pb, nPayLoad1);

		//fmtp
		ISXSIP_IE_SDP_FMTP_EX SdpFmtp;
		sprintf(SdpFmtp.fmtf, "%d 0-15", nPayLoad2);
		SetBodySdp_fmtp(pb, &SdpFmtp);

		//a
		SetBodySdp_a(pb, (CHAR *)"sendrecv", (CHAR *)"");

		return 0;
	};
	INT ConstructMediaBody(char *szConnAddr, 
		USHORT nVoiceSrcPort, USHORT nVideoSrcPort, 
		UCHAR nVoicePayLoad1=8, UCHAR nVoicePayLoad2=101, UCHAR nVideoPayLoad=34)
	{
		ISXSIP_IE_BODY_SDP_EX* pb = NULL;
		
		Valid = 1;
		BodyPartyType = BodyPartyType_SDP;
		
		pb = &u.BodySdp;
		pb->SdpNum = 0;

		//o
		SetBodySdp_o(pb, szConnAddr);	
		//s
		SetBodySdp_s(pb);		
		//c
		SetBodySdp_c(pb, szConnAddr);		
		//t
		SetBodySdp_t(pb);

		//m
		ISXSIP_IE_SDP_MEDIA_DESC_EX MediaDescEx;
		MediaDescEx.MediaType = ISXSIP_SDPMEDIATYPE_AUDIO;
		MediaDescEx.MediaProtocol = ISXSIP_SDPPROTOCOL_RTP;
		MediaDescEx.MediaPort = nVoiceSrcPort;
		MediaDescEx.PayLoadNum = 2;
		MediaDescEx.Payload[0] = nVoicePayLoad1; 
		MediaDescEx.Payload[1] = nVoicePayLoad2;
		SetBodySdp_m(pb, &MediaDescEx);

		//rtpmap
		ISXSIP_IE_SDP_RTP_MAP SdpRtpMap;
		SdpRtpMap.Payload = nVoicePayLoad2;
		SdpRtpMap.ClkRate	= 8000;
		strcpy(SdpRtpMap.EncodingName,  "telephone-event");
		strcpy(SdpRtpMap.EncodingParam, "");
		SetBodySdp_rtpmap(pb, &SdpRtpMap);

		//fmtp
		ISXSIP_IE_SDP_FMTP_EX SdpFmtp;
		sprintf(SdpFmtp.fmtf, "%d 0-15", nVoicePayLoad2);
		SetBodySdp_fmtp(pb, &SdpFmtp);

		//m
		MediaDescEx.MediaType = ISXSIP_SDPMEDIATYPE_VIDEO;
		MediaDescEx.MediaProtocol = ISXSIP_SDPPROTOCOL_RTP;
		MediaDescEx.MediaPort = nVideoSrcPort;
		MediaDescEx.PayLoadNum = 1;
		MediaDescEx.Payload[0] = nVideoPayLoad; 
		SetBodySdp_m(pb, &MediaDescEx);

		//rtpmap
		SdpRtpMap.Payload = nVideoPayLoad;
		SdpRtpMap.ClkRate	= 90000;
		strcpy(SdpRtpMap.EncodingName,  "H263"); //34
		strcpy(SdpRtpMap.EncodingParam, "");
		SetBodySdp_rtpmap(pb, &SdpRtpMap);
		//fmtp
		sprintf(SdpFmtp.fmtf, "%d QCIF=1;CIF=1", nVideoPayLoad);
		SetBodySdp_fmtp(pb, &SdpFmtp);

		//a
		SetBodySdp_a(pb, (CHAR *)"sendrecv", (CHAR *)"");

		return 0;
	};
	INT ConstructMediaBody(char *szConnAddr, 
		USHORT nVoiceSrcPort, eM3G_VOICE_CODER eVoiceCodecId, 
		USHORT nVideoSrcPort, eM3G_VIDEO_CODER eVideoCodecId, 
		ISXSIP_IE_SDP_MEDIA_DESC_EX *pRetVoiceDesc,
		ISXSIP_IE_SDP_MEDIA_DESC_EX *pRetVideoDesc)
	{
		ISXSIP_IE_BODY_SDP_EX* pb = NULL;
		
		Valid = 1;
		BodyPartyType = BodyPartyType_SDP;
		
		pb = &u.BodySdp;
		pb->SdpNum = 0;

		//o
		SetBodySdp_o(pb, szConnAddr);	
		//s
		SetBodySdp_s(pb);		
		//c
		SetBodySdp_c(pb, szConnAddr);		
		//t
		SetBodySdp_t(pb);

		//m
		SIP_CODEC_PAYLOAD_MAP *pCodecMap;
		ISXE_gc_SipGetPayloadMap(CODECT_VOICE, (UINT)eVoiceCodecId, &pCodecMap);
		ISXSIP_IE_SDP_MEDIA_DESC_EX MediaDescEx;
		MediaDescEx.MediaType = ISXSIP_SDPMEDIATYPE_AUDIO;
		MediaDescEx.MediaProtocol = ISXSIP_SDPPROTOCOL_RTP;
		MediaDescEx.MediaPort = nVoiceSrcPort;
		MediaDescEx.PayLoadNum = 2;
		MediaDescEx.Payload[0] = pCodecMap->rtpmap.Payload; 
		MediaDescEx.Payload[1] = 101;
		SetBodySdp_m(pb, &MediaDescEx);
		if(pRetVoiceDesc) memcpy(pRetVoiceDesc, &MediaDescEx, sizeof(ISXSIP_IE_SDP_MEDIA_DESC_EX));

		//rtpmap
		ISXSIP_IE_SDP_RTP_MAP SdpRtpMap;
		SdpRtpMap.Payload = 101;
		SdpRtpMap.ClkRate	= 8000;
		strcpy(SdpRtpMap.EncodingName,  "telephone-event");
		strcpy(SdpRtpMap.EncodingParam, "");
		SetBodySdp_rtpmap(pb, &SdpRtpMap);

		//fmtp
		ISXSIP_IE_SDP_FMTP_EX SdpFmtp;
		sprintf(SdpFmtp.fmtf, "%d 0-15", 101);
		SetBodySdp_fmtp(pb, &SdpFmtp);

		//m
		ISXE_gc_SipGetPayloadMap(CODECT_VIDEO, (UINT)eVideoCodecId, &pCodecMap);
		MediaDescEx.MediaType = ISXSIP_SDPMEDIATYPE_VIDEO;
		MediaDescEx.MediaProtocol = ISXSIP_SDPPROTOCOL_RTP;
		MediaDescEx.MediaPort = nVideoSrcPort;
		MediaDescEx.PayLoadNum = 1;
		MediaDescEx.Payload[0] = pCodecMap->rtpmap.Payload; 
		SetBodySdp_m(pb, &MediaDescEx);
		if(pRetVideoDesc) memcpy(pRetVideoDesc, &MediaDescEx, sizeof(ISXSIP_IE_SDP_MEDIA_DESC_EX));

		//rtpmap
		SdpRtpMap.Payload = pCodecMap->rtpmap.Payload;
		SdpRtpMap.ClkRate	= 90000;
		strcpy(SdpRtpMap.EncodingName,  "H263"); //34
		strcpy(SdpRtpMap.EncodingParam, "");
		SetBodySdp_rtpmap(pb, &SdpRtpMap);
		//fmtp
		sprintf(SdpFmtp.fmtf, "%d QCIF=1;CIF=1", pCodecMap->rtpmap.Payload);
		SetBodySdp_fmtp(pb, &SdpFmtp);

		//a
		SetBodySdp_a(pb, (CHAR *)"sendrecv", (CHAR *)"");

		return 0;
	};
}ISXSIP_IE_BODY_EX_USR;

typedef struct tagM3G_TO_DISPLAY_MODE_USR: public tagM3G_TO_DISPLAY_MODE{
	tagM3G_TO_DISPLAY_MODE_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UCHAR vMode=M3G_DISPLAY_MODE_SHOW)
	{
		ucValid = 1;
		if(vMode!=(UCHAR)EHV_NOTHING) ucMode = vMode;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		if(ucValid){
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,Mode=%d> ", pszParamName?pszParamName:"DisplayMode", ucValid, ucMode);
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", pszParamName?pszParamName:"DisplayMode", ucValid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_TO_DISPLAY_MODE_USR;

typedef struct tagM3G_TOOLBOX_PARAM_USR: public tagM3G_TOOLBOX_PARAM{
	tagM3G_TOOLBOX_PARAM_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetEnable(UCHAR vIsEnable=1)
	{
		ucValid				=1;
		if(vIsEnable!=(UCHAR)EHV_NOTHING) ucIsEnable = vIsEnable;
	};
	VOID SetValue(UINT vFPS, UINT vRev, UINT vInputWidth, UINT vInputHeight, UINT vOutputWidth, UINT vOutputHeight)
	{
		ucValid = 1;
		if(vFPS!=(UINT)EHV_NOTHING)			ucFPS			= (UCHAR)vFPS;	
		if(vRev!=(UINT)EHV_NOTHING)			ucRev			= (UCHAR)vRev;	
		if(vInputHeight!=(UINT)EHV_NOTHING)	ulInputHeight	= vInputHeight;	
		if(vInputWidth!=(UINT)EHV_NOTHING)		ulInputWidth	= vInputWidth;	
		if(vOutputHeight!=(UINT)EHV_NOTHING)	ulOutputHeight	= vOutputHeight;
		if(vOutputWidth!=(UINT)EHV_NOTHING)	ulOutputWidth	= vOutputWidth;	
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		if(ucValid){
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,IsEnable=%d,FPS=%d,Rev=%d,InputHeight=%d,InputWidth=%d,OutputHeight=%d,OutputWidth=%d> ", 
				pszParamName?pszParamName:"ToolboxParam", ucValid, ucIsEnable,ucFPS,ucRev,ulInputHeight,ulInputWidth,ulOutputHeight,ulOutputWidth);
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", pszParamName?pszParamName:"ToolboxParam", ucValid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_TOOLBOX_PARAM_USR;

typedef struct tagM3G_LOGO_PARAM_USR: public tagM3G_LOGO_PARAM{
	tagM3G_LOGO_PARAM_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UINT vWidth, UINT vHeight, UINT vLeftPos, UINT vTopPos, UINT vTransY, UINT vTransU, UINT vTransV, UINT vTransAlpha, UINT vAlphaBlending)
	{
		ucValid = 1;
		if(vHeight!=(UINT)EHV_NOTHING)		ulHeight	= vHeight;			
		if(vWidth!=(UINT)EHV_NOTHING)		ulWidth		= vWidth;			
		if(vTopPos!=(UINT)EHV_NOTHING)		ulTopPos	= vTopPos;			
		if(vLeftPos!=(UINT)EHV_NOTHING)	ulLeftPos	= vLeftPos;			
		if(vTransY!=(UINT)EHV_NOTHING)		ucTransY	= (UCHAR)vTransY;
		if(vTransU!=(UINT)EHV_NOTHING)		ucTransU	= (UCHAR)vTransU;
		if(vTransV!=(UINT)EHV_NOTHING)		ucTransV	= (UCHAR)vTransV;
		if(vTransAlpha!=(UINT)EHV_NOTHING)		ucTransAlpha	= (UCHAR)vTransAlpha;
		if(vAlphaBlending!=(UINT)EHV_NOTHING)	ucAlphaBlending	= (UCHAR)vAlphaBlending;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		if(ucValid){
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,Height=%d,Width=%d,TopPos=%d,LeftPos=%d,YUV(%d.%d.%d),TransAlpha=%d,AlphaBlending=%d> ", 
				pszParamName?pszParamName:"LogoParam", ucValid, ulHeight,ulWidth,ulTopPos,ulLeftPos,ucTransY,ucTransU,ucTransV,ucTransAlpha, ucAlphaBlending);
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", pszParamName?pszParamName:"LogoParam", ucValid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_LOGO_PARAM_USR;

typedef struct tagM3G_LOGO_CONFIG_USR: public tagM3G_LOGO_CONFIG{
	tagM3G_LOGO_CONFIG_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetLogoParm(M3G_LOGO_PARAM_USR *pLogoParm)
	{ 
		if(pLogoParm) memcpy(&LogoParm, pLogoParm, sizeof(M3G_LOGO_PARAM_USR));
	};
	VOID SetDisplayMode(M3G_TO_DISPLAY_MODE_USR *pDisplayMode)
	{ 
		if(pDisplayMode) memcpy(&DisplayMode, pDisplayMode, sizeof(M3G_TO_DISPLAY_MODE_USR));
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		szOutStr[0]=0;
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<", pszParamName?pszParamName:"LogoCfg");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		FAILRETN(((M3G_LOGO_PARAM_USR*)&LogoParm)->TraceStr(szOutStr, "Param"));
		FAILRETN(((M3G_TO_DISPLAY_MODE_USR*)&DisplayMode)->TraceStr(szOutStr, "DisplayMode"));
		_snprintf(szTemp, TEMP_STR_LEN, "> ");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_LOGO_CONFIG_USR;

typedef struct tagM3G_TOOLBOX_CONFIG_USR: public tagM3G_TOOLBOX_CONFIG{
	tagM3G_TOOLBOX_CONFIG_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetLogoParm(M3G_LOGO_PARAM_USR *pLogoParm)
	{ 
		if(pLogoParm) memcpy(&logo, pLogoParm, sizeof(M3G_LOGO_PARAM_USR));
	};
	VOID SetToolbox(M3G_TOOLBOX_PARAM_USR *pToolbox)
	{ 
		if(pToolbox) memcpy(&toolbox, pToolbox, sizeof(M3G_TOOLBOX_PARAM_USR));
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		szOutStr[0]=0;
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<", pszParamName?pszParamName:"ToolBoxCfg");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		FAILRETN(((M3G_TOOLBOX_PARAM_USR*)&toolbox)->TraceStr(szOutStr, "Toolbox"));
		FAILRETN(((M3G_LOGO_PARAM_USR*)&logo)->TraceStr(szOutStr, "Logo"));
		_snprintf(szTemp, TEMP_STR_LEN, "> ");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_TOOLBOX_CONFIG_USR;

typedef struct tagM3G_TO_CARET_POSITION_USR: public tagM3G_TO_CARET_POSITION{
	tagM3G_TO_CARET_POSITION_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UINT vTextDir/*eM3G_TEXT_DIRECTION*/, UINT vLeftPos, UINT vTopPos)
	{
		ucValid = 1;
		if(vTextDir!=(UINT)EHV_NOTHING)	ucTextDir	= (UCHAR)vTextDir;
		if(vLeftPos!=(UINT)EHV_NOTHING)	ulLeftPos	= vLeftPos;		
		if(vTopPos!=(UINT)EHV_NOTHING)		ulTopPos	= vTopPos;		
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		if(ucValid!=0) { 
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,TextDir=%d,LeftPos=%d,TopPos=%d> ", 
				pszParamName?pszParamName:"Position", ucValid, ucTextDir, ulLeftPos, ulTopPos);
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", pszParamName?pszParamName:"Position", ucValid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_TO_CARET_POSITION_USR; 

/* 字体相关的信息 */
typedef struct tagM3G_TO_FONT_INFO_USR: public tagM3G_TO_FONT_INFO {
	tagM3G_TO_FONT_INFO_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UINT vFontIndex, UINT vFontSize, UINT vFontStyle/*eM3G_TEXT_STYLE*/)
	{
		ucValid = 1;
		if(vFontIndex!=(UINT)EHV_NOTHING)	ucFontIndex	= (UCHAR)vFontIndex;
		if(vFontSize!=(UINT)EHV_NOTHING)	ulFontSize	= vFontSize;		
		if(vFontStyle!=(UINT)EHV_NOTHING)	ulFontStyle	= vFontStyle;		
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		if(ucValid!=0) {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,FontIndex=%d,FontSize=%d,FontStyle=%d> ", 
				pszParamName?pszParamName:"Font", ucValid, ucFontIndex, ulFontSize, ulFontStyle);
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", pszParamName?pszParamName:"Font", ucValid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_TO_FONT_INFO_USR;

typedef struct tagM3G_TO_COLOR_USR: public tagM3G_TO_COLOR {
	tagM3G_TO_COLOR_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetForeground(UINT vR, UINT vG, UINT vB, UINT vAlpha)
	{
		ucValid = 1;
		if(vR!=(UINT)EHV_NOTHING) ucForegroundR	= (UCHAR)vR;
		if(vG!=(UINT)EHV_NOTHING) ucForegroundG	= (UCHAR)vG;
		if(vB!=(UINT)EHV_NOTHING) ucForegroundB	= (UCHAR)vB;
		if(vAlpha!=(UINT)EHV_NOTHING) ucForegroundAlpha = (UCHAR)vAlpha;
	};
	VOID SetBackground(UINT vR, UINT vG, UINT vB, UINT vAlpha)
	{
		ucValid = 1;
		if(vR!=(UINT)EHV_NOTHING) ucBackgroundR	= (UCHAR)vR;
		if(vG!=(UINT)EHV_NOTHING) ucBackgroundG	= (UCHAR)vG;
		if(vB!=(UINT)EHV_NOTHING) ucBackgroundB	= (UCHAR)vB;
		if(vAlpha!=(UINT)EHV_NOTHING) ucBackgroundAlpha = (UCHAR)vAlpha;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		if(ucValid!=0) {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,Foreground(RGB=%d.%d.%d,Alpha=%d), Background(RGB=%d.%d.%d,Alpha=%d)> ", 
				pszParamName?pszParamName:"Color", ucValid, ucForegroundR, ucForegroundG, ucForegroundB, ucForegroundAlpha,
				ucBackgroundR, ucBackgroundG, ucBackgroundB, ucBackgroundAlpha);
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", pszParamName?pszParamName:"Color", ucValid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_TO_COLOR_USR;

typedef struct tagM3G_TO_SCROLL_INFO_USR: public tagM3G_TO_SCROLL_INFO {
	tagM3G_TO_SCROLL_INFO_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetEnable(UCHAR vIsEnable=1)
	{
		ucValid				=1;
		if(vIsEnable!=(UCHAR)EHV_NOTHING) ucEnable = vIsEnable;	
	};
	VOID SetScroll(UINT vDir/*eM3G_TEXT_DIRECTION*/, UINT vEndlessLoop, UINT vSpeed, UINT vLeftPos, UINT vRightPos)
	{
		ucValid = 1;
		if(vDir!=(UINT)EHV_NOTHING)			ucScrollDir		= (UCHAR)vDir;	
		if(vEndlessLoop!=(UINT)EHV_NOTHING)	ucEndlessLoop	= (UCHAR)vEndlessLoop;
		if(vSpeed!=(UINT)EHV_NOTHING)			ulSpeed			= (UINT)vSpeed;	
		if(vLeftPos!=(UINT)EHV_NOTHING)		ulLeftPos		= (UINT)vLeftPos;
		if(vRightPos!=(UINT)EHV_NOTHING)		ulRightPos		= (UINT)vRightPos;
	};
	VOID SetBackground(UINT vLeftPos, UINT vTopPos, UINT vWidth, UINT vHeight)
	{
		ucValid = 1;
		if(vLeftPos!=(UINT)EHV_NOTHING)	ulBackgroundLeftPos	= (UINT)vLeftPos;
		if(vTopPos!=(UINT)EHV_NOTHING)		ulBackgroundTopPos	= (UINT)vTopPos;
		if(vWidth!=(UINT)EHV_NOTHING)		ulBackgroundWidth	= (UINT)vWidth;
		if(vHeight!=(UINT)EHV_NOTHING)		ulBackgroundHeight	= (UINT)vHeight;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		if(ucValid!=0) {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,Enable=%d,Scroll(Dir=%d,EndlessLoop=%d,Speed=%d,LeftPos=%d,RightPos=%d) "
				"Background(TopPos=%d,LeftPos=%d,Width=%d,Height=%d)> ", 
				pszParamName?pszParamName:"Scroll", ucValid, ucEnable, ucScrollDir, ucEndlessLoop, ulSpeed, ulLeftPos, ulRightPos,
				ulBackgroundTopPos, ulBackgroundLeftPos, ulBackgroundWidth, ulBackgroundHeight);
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", pszParamName?pszParamName:"Scroll", ucValid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_TO_SCROLL_INFO_USR;

typedef struct tagM3G_TO_TEXT_USR: public tagM3G_TO_TEXT {
	tagM3G_TO_TEXT_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); }
	VOID SetValue(CHAR* pszText)
	{
		ucValid = 1;
		INT iTmpLen = 0;
		if(pszText!=NULL) {
			iTmpLen = strlen(pszText);
			if(iTmpLen>=EHANG_MAX_TEXT_LEN) iTmpLen = EHANG_MAX_TEXT_LEN-1;
			strncpy(szContent, pszText, iTmpLen);
		}
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,Content='%s'> ", 
			pszParamName?pszParamName:"Text", ucValid, szContent);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_TO_TEXT_USR;

typedef struct tagM3G_TEXTOVERLAY_CONFIG_USR: public tagM3G_TEXTOVERLAY_CONFIG {
	tagM3G_TEXTOVERLAY_CONFIG_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetCaretPos(M3G_TO_CARET_POSITION_USR *pCaretPos)
	{ 
		if(pCaretPos) memcpy(&CaretPos, pCaretPos, sizeof(M3G_TO_CARET_POSITION_USR));
	};
	VOID SetFontInfo(M3G_TO_FONT_INFO_USR *pFontInfo)
	{ 
		if(pFontInfo) memcpy(&FontInfo, pFontInfo, sizeof(M3G_TO_FONT_INFO_USR));
	};
	VOID SetColorInfo(M3G_TO_COLOR_USR *pColorInfo)
	{ 
		if(pColorInfo) memcpy(&ColorInfo, pColorInfo, sizeof(M3G_TO_COLOR_USR));
	};
	VOID SetDisplayMode(M3G_TO_DISPLAY_MODE_USR *pDisplayMode)
	{ 
		if(pDisplayMode) memcpy(&DisplayMode, pDisplayMode, sizeof(M3G_TO_DISPLAY_MODE_USR));
	};
	VOID SetScrollInfo(M3G_TO_SCROLL_INFO_USR *pScrollInfo)
	{ 
		if(pScrollInfo) memcpy(&ScrollInfo, pScrollInfo, sizeof(M3G_TO_SCROLL_INFO_USR));
	};
	VOID SetText(M3G_TO_TEXT_USR *pText)
	{ 
		if(pText) memcpy(&Text, pText, sizeof(M3G_TO_TEXT_USR));
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		szOutStr[0]=0;
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<", pszParamName?pszParamName:"TextOverlayCfg");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		FAILRETN(((M3G_TO_CARET_POSITION_USR*)&CaretPos)->TraceStr(szOutStr));
		FAILRETN(((M3G_TO_FONT_INFO_USR*)&FontInfo)->TraceStr(szOutStr));
		FAILRETN(((M3G_TO_COLOR_USR*)&ColorInfo)->TraceStr(szOutStr));
		FAILRETN(((M3G_TO_DISPLAY_MODE_USR*)&DisplayMode)->TraceStr(szOutStr));
		FAILRETN(((M3G_TO_SCROLL_INFO_USR*)&ScrollInfo)->TraceStr(szOutStr));
		FAILRETN(((M3G_TO_TEXT_USR*)&Text)->TraceStr(szOutStr));
		_snprintf(szTemp, TEMP_STR_LEN, "> ");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_TEXTOVERLAY_CONFIG_USR;

typedef struct tagM3G_VIDEOCONF_MIXER_USR: public tagM3G_VIDEOCONF_MIXER {
	tagM3G_VIDEOCONF_MIXER_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UINT vMixerId, UINT vWidth, UINT vHeight, UINT vSynSrc, UINT vFPS, UINT vVideodev)
	{
		if(vMixerId!=(UINT)EHV_NOTHING) ucMixerId = (UCHAR)vMixerId;
		if(vWidth!=(UINT)EHV_NOTHING) ulWidth = (UINT)vWidth;
		if(vHeight!=(UINT)EHV_NOTHING) ulHeight = (UINT)vHeight;
		if(vSynSrc!=(UINT)EHV_NOTHING) ucSynSrc = (UCHAR)vSynSrc;
		if(vFPS!=(UINT)EHV_NOTHING) ulFPS = (UINT)vFPS;
		if(vVideodev!=(UINT)EHV_NOTHING) videodev = (M3GDEV)vVideodev;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<MixerId=%d,Width=%d,Height=%d,SynSrc=%d,FPS=%d,videodev=%d> ", 
				pszParamName?pszParamName:"Mixer", ucMixerId, ulWidth, ulHeight, ucSynSrc, ulFPS, videodev);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_VIDEOCONF_MIXER_USR;

typedef struct tagM3G_VIDEOCONF_PARM_USR: public tagM3G_VIDEOCONF_PARM {
	tagM3G_VIDEOCONF_PARM_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() {return sizeof(*this);};
	VOID SetValue(UINT vVideoConfCaps, UINT vSrcUdpPort)
	{
		if(vVideoConfCaps!=(UINT)EHV_NOTHING) ulVideoConfCaps = (UINT)vVideoConfCaps;
		if(vSrcUdpPort!=(UINT)EHV_NOTHING) usSrcUdpPort = (USHORT)vSrcUdpPort;
	};
	VOID SetMixer(UINT	vMixerNum, M3G_VIDEOCONF_MIXER* pMixer)
	{
		if(vMixerNum!=(UINT)EHV_NOTHING) {
			ucMixerNum = (UCHAR)vMixerNum;
			if(ucMixerNum > MAX_VIDEOCONF_MIXER_NUM) ucMixerNum = MAX_VIDEOCONF_MIXER_NUM;
			if(pMixer) memcpy(Mixer, pMixer, sizeof(M3G_VIDEOCONF_MIXER)*ucMixerNum);
		};
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<VideoConfCaps=%d,SrcUdpPort=%d,MixerNum=%d(", 
				pszParamName?pszParamName:"VideoConfParm", ulVideoConfCaps, usSrcUdpPort, ucMixerNum);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		CHAR szIndex[8]={0};
		for(INT i=0; i<ucMixerNum; i++) {
			sprintf(szIndex, "%d", i);
			FAILRETN(((M3G_VIDEOCONF_MIXER_USR*)&Mixer[i])->TraceStr(szOutStr, szIndex));
		}
		_snprintf(szTemp, TEMP_STR_LEN, ")>");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		
		return 0;
	};
} M3G_VIDEOCONF_PARM_USR;

typedef struct tagVIDEO_PARTICIANT_SENDER_USR: public tagVIDEO_PARTICIANT_SENDER {
	tagVIDEO_PARTICIANT_SENDER_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UINT vSendFlag=1, UINT vWidth=0, UINT vHeight=0)
	{
		ucValid = 1;
		if(vSendFlag!=(UINT)EHV_NOTHING) ucSendFlag = (UCHAR)vSendFlag;
		if(vWidth!=(UINT)EHV_NOTHING) usWidth = (USHORT)vWidth;
		if(vHeight!=(UINT)EHV_NOTHING) usHeight = (USHORT)vHeight;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		if(ucValid!=0) {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,SendFlag=%d,Width=%d,Height=%d> ", 
				pszParamName?pszParamName:"Sender", ucValid, ucSendFlag, usWidth, usHeight);
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", pszParamName?pszParamName:"Sender", ucValid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} VIDEO_PARTICIANT_SENDER_USR;

typedef struct tagVIDEO_PARTICIANT_RECVER_USR: public tagVIDEO_PARTICIANT_RECVER {
	tagVIDEO_PARTICIANT_RECVER_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UINT vMixerId, UINT vRecvFlag=1, UINT vRecverUdpPort=0, UINT vRecverFPS=0)
	{
		ucValid = 1;
		if(vMixerId!=(UINT)EHV_NOTHING) ucMixerId = (UCHAR)vMixerId;
		if(vRecvFlag!=(UINT)EHV_NOTHING) ucRecvFlag = (UCHAR)vRecvFlag;
		if(vRecverUdpPort!=(UINT)EHV_NOTHING) usRecverUdpPort = (USHORT)vRecverUdpPort;
		if(vRecverFPS!=(UINT)EHV_NOTHING) ulRecverFPS = (UINT)vRecverFPS;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		if(ucValid!=0) {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,MixerId=%d,RecvFlag=%d,RecverUdpPort=%d,RecverFPS=%d> ", 
				pszParamName?pszParamName:"Recver", ucValid, ucMixerId, ucRecvFlag, usRecverUdpPort, ulRecverFPS);
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", pszParamName?pszParamName:"Recver", ucValid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} VIDEO_PARTICIANT_RECVER_USR;

typedef struct tagVIDEO_PARTICIANT_VISION_ITEM_USR: public tagVIDEO_PARTICIANT_VISION_ITEM {
	tagVIDEO_PARTICIANT_VISION_ITEM_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UINT vMixerId, UINT vLayerId, UINT vLeftPos, UINT vTopPos, UINT vWidth, UINT vHeight)
	{
		if(vMixerId!=(UINT)EHV_NOTHING) ucMixerId = (UCHAR)vMixerId;
		if(vLayerId!=(UINT)EHV_NOTHING) ucLayerId = (UCHAR)vLayerId;
		if(vLeftPos!=(UINT)EHV_NOTHING) usLeftPos = (USHORT)vLeftPos;
		if(vTopPos!=(UINT)EHV_NOTHING) usTopPos = (USHORT)vTopPos;
		if(vWidth!=(UINT)EHV_NOTHING) usWidth = (USHORT)vWidth;
		if(vHeight!=(UINT)EHV_NOTHING) usHeight = (USHORT)vHeight;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<MixerId=%d,LayerId=%d,LeftPos=%d,TopPos=%d,Width=%d,Height=%d> ", 
				pszParamName?pszParamName:"MixerPos", ucMixerId, ucLayerId, usLeftPos, usTopPos, usWidth, usHeight);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} VIDEO_PARTICIANT_VISION_ITEM_USR;

typedef struct tagVIDEO_PARTICIANT_VISION_USR: public tagVIDEO_PARTICIANT_VISION {
	tagVIDEO_PARTICIANT_VISION_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UINT vVisionNum, VIDEO_PARTICIANT_VISION_ITEM* pVisions=NULL)
	{
		ucValid = 1;
		if(vVisionNum!=(UINT)EHV_NOTHING) {
			ucVisionNum = (UCHAR)vVisionNum;
			if(ucVisionNum > MAX_VIDEOCONF_MIXER_NUM) ucVisionNum = MAX_VIDEOCONF_MIXER_NUM;
			if(pVisions) memcpy(Visions, pVisions, sizeof(VIDEO_PARTICIANT_VISION_ITEM)*ucVisionNum);
		}
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];

		if(ucValid!=0) {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,VisionNum=%d(", 
					pszParamName?pszParamName:"Visions", ucValid, ucVisionNum);
			FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
			CHAR szIndex[8]={0};
			for(INT i=0; i<ucVisionNum; i++) {
				sprintf(szIndex, "%d", i);
				FAILRETN(((VIDEO_PARTICIANT_VISION_ITEM_USR*)&Visions[i])->TraceStr(szOutStr, szIndex));
			}
			_snprintf(szTemp, TEMP_STR_LEN, ")>");
			FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", pszParamName?pszParamName:"Visions", ucValid);
			FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		}
		return 0;
	};
} VIDEO_PARTICIANT_VISION_USR;

typedef struct tagVIDEO_PARTICIANT_SYNC_SRC_USR: public tagVIDEO_PARTICIANT_SYNC_SRC {
	tagVIDEO_PARTICIANT_SYNC_SRC_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UINT vMixerNum, UCHAR* pMixerIds)
	{
		ucValid = 1;
		if(vMixerNum!=(UINT)EHV_NOTHING) {
			ucMixerNum = (UCHAR)vMixerNum;
			if(ucMixerNum > MAX_VIDEOCONF_MIXER_NUM) ucMixerNum = MAX_VIDEOCONF_MIXER_NUM;
			if(pMixerIds) memcpy(ucMixerIds, pMixerIds, sizeof(UCHAR)*ucMixerNum);
		}
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		if(ucValid!=0) {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,MixerNum=%d(", 
				pszParamName?pszParamName:"SyncSrc", ucValid, ucMixerNum);
			FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
			CHAR szIndex[8]={0};
			for(INT i=0; i<ucMixerNum; i++) {
				sprintf(szIndex, "%d,", ucMixerIds[i]);
				FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szIndex));
			}
			char *p = (CHAR *)(szOutStr-1);
			p[0] = 0;
			_snprintf(szTemp, TEMP_STR_LEN, ")>");
			FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", pszParamName?pszParamName:"SyncSrc", ucValid);
			FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		}
		return 0;
	};
} VIDEO_PARTICIANT_SYNC_SRC_USR;

typedef struct tagM3G_VIDEOCONF_CDT_USR: public tagM3G_VIDEOCONF_CDT {
	tagM3G_VIDEOCONF_CDT_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UINT vVideodev, VIDEO_PARTICIANT_SENDER* pSender,VIDEO_PARTICIANT_RECVER* pRecver, VIDEO_PARTICIANT_VISION* pVision, VIDEO_PARTICIANT_SYNC_SRC *pSyncsrc)
	{
		if(vVideodev!=(UINT)EHV_NOTHING) videodev = (M3GDEV)vVideodev;
		if(pSender) memcpy(&sender, pSender, sizeof(VIDEO_PARTICIANT_SENDER));
		if(pRecver) memcpy(&recver, pRecver, sizeof(VIDEO_PARTICIANT_RECVER));
		if(pVision) memcpy(&vision, pVision, sizeof(VIDEO_PARTICIANT_VISION));
		if(pSyncsrc) memcpy(&syncsrc, pSyncsrc, sizeof(VIDEO_PARTICIANT_SYNC_SRC));
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<videodev=%d, ", pszParamName?pszParamName:"VideoCdt", videodev);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		FAILRETN(((VIDEO_PARTICIANT_SENDER_USR*)&sender)->TraceStr(szOutStr));
		FAILRETN(((VIDEO_PARTICIANT_RECVER_USR*)&recver)->TraceStr(szOutStr));
		FAILRETN(((VIDEO_PARTICIANT_VISION_USR*)&vision)->TraceStr(szOutStr));
		FAILRETN(((VIDEO_PARTICIANT_SYNC_SRC_USR*)&syncsrc)->TraceStr(szOutStr));
		_snprintf(szTemp, TEMP_STR_LEN, ">");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_VIDEOCONF_CDT_USR;

typedef struct tagM3G_VOICECONF_PARM_USR: public tagM3G_VOICECONF_PARM {
	tagM3G_VOICECONF_PARM_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UINT vMaxDominantSpeakers, UINT vHangOver)
	{
		if(vMaxDominantSpeakers!=(UINT)EHV_NOTHING) ulMaxDominantSpeakers = (UINT)vMaxDominantSpeakers;
		if(vHangOver!=(UINT)EHV_NOTHING) ulHangOver = (UINT)vHangOver;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];

		_snprintf(szTemp, TEMP_STR_LEN, "%s<MaxDominantSpeakers=%d,HangOver=%d> ", 
			pszParamName?pszParamName:"VoiceConfParm", ulMaxDominantSpeakers, ulHangOver);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_VOICECONF_PARM_USR;

typedef struct tagM3G_VOICECONF_CDT_USR: public tagM3G_VOICECONF_CDT {
	tagM3G_VOICECONF_CDT_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UINT vVoicedev, UINT vParticipantType, UINT vWhisperdev)
	{
		if(vVoicedev!=(UINT)EHV_NOTHING) voicedev = (M3GDEV)vVoicedev;
		if(vWhisperdev!=(UINT)EHV_NOTHING) Whisperdev = (M3GDEV)vWhisperdev;
		if(vParticipantType!=(UINT)EHV_NOTHING) ucParticipantType = (UCHAR)vParticipantType;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];

		_snprintf(szTemp, TEMP_STR_LEN, "%s<voicedev=%d,ParticipantType=%d,Whisperdev=%d> ", 
			pszParamName?pszParamName:"VoiceCdt", voicedev, ucParticipantType, Whisperdev);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_VOICECONF_CDT_USR;

//////////////////////////////////////////////////////////////////////////
//IPM
typedef struct tagIpConfig_TOS_USR: public IpConfig_TOS {
	tagIpConfig_TOS_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UINT vPrecedence, UINT vLowDelay, UINT vHighThroughout, UINT vHighReliability, UINT vLowCost)
	{
		Valid = 1;
		if(vPrecedence!=(UINT)EHV_NOTHING) Precedence = (UCHAR)vPrecedence;
		if(vLowDelay!=(UINT)EHV_NOTHING) LowDelay = (UCHAR)vLowDelay;
		if(vHighThroughout!=(UINT)EHV_NOTHING) HighThroughout = (UCHAR)vHighThroughout;
		if(vHighReliability!=(UINT)EHV_NOTHING) HighReliability = (UCHAR)vHighReliability;
		if(vLowCost!=(UINT)EHV_NOTHING) LowCost = (UCHAR)vLowCost;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];

		if(Valid==1) {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,Precedence=%d,LowDelay=%d,HighThroughout=%d,HighReliability=%d,LowCost=%d> ", 
				pszParamName?pszParamName:"TOS", Valid, Precedence, LowDelay, HighThroughout, HighReliability, LowCost);
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", 
				pszParamName?pszParamName:"TOS", Valid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} IpConfig_TOS_USR;

typedef struct tagIpConfig_UDPSourcePortValid_USR: public IpConfig_UDPSourcePortValid {
	tagIpConfig_UDPSourcePortValid_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UINT vSourcePortValid)
	{
		Valid = 1;
		if(vSourcePortValid!=(UINT)EHV_NOTHING) SourcePortValid = (UCHAR)vSourcePortValid;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];

		if(Valid==1) {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,SourcePortValid=%d> ", 
				pszParamName?pszParamName:"UDPSrcPortValid", Valid, SourcePortValid);
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", 
				pszParamName?pszParamName:"UDPSrcPortValid", Valid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} IpConfig_UDPSourcePortValid_USR;

typedef struct tagIpConfig_IMID_USR: public IpConfig_IMID {
	tagIpConfig_IMID_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UINT vIMID)
	{
		Valid = 1;
		if(vIMID!=(UINT)EHV_NOTHING) IMID = (USHORT)vIMID;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];

		if(Valid==1) {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,IMID=%d> ", 
				pszParamName?pszParamName:"IMID", Valid, IMID);
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", 
				pszParamName?pszParamName:"IMID", Valid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} IpConfig_IMID_USR;

typedef struct tagIpConfig_MID_USR: public IpConfig_MID {
	tagIpConfig_MID_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UINT vMID)
	{
		Valid = 1;
		if(vMID!=(UINT)EHV_NOTHING) MID = (USHORT)vMID;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];

		if(Valid==1) {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,MID=%d> ", 
				pszParamName?pszParamName:"MID", Valid, MID);
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", 
				pszParamName?pszParamName:"MID", Valid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} IpConfig_MID_USR;

typedef struct tagGeneralIpConfig_USR: public GeneralIpConfig {
	tagGeneralIpConfig_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetTOS(IpConfig_TOS *pTOS)
	{
		if(pTOS) memcpy(&TOS, pTOS, sizeof(IpConfig_TOS));
	};
	VOID SetUDPSrcPortValid(IpConfig_UDPSourcePortValid *pUDPSrcPortValid)
	{
		if(pUDPSrcPortValid) memcpy(&UDPSrcPortValid, pUDPSrcPortValid, sizeof(IpConfig_UDPSourcePortValid));
	};
	VOID SetIMID(IpConfig_IMID *pIMID)
	{
		if(pIMID) memcpy(&IMID, pIMID, sizeof(IpConfig_IMID));
	};
	VOID SetMID(IpConfig_MID *pMID)
	{
		if(pMID) memcpy(&MID, pMID, sizeof(IpConfig_MID));
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];

		_snprintf(szTemp, TEMP_STR_LEN, "%s<", pszParamName?pszParamName:"GeneralIp");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		FAILRETN(((IpConfig_TOS_USR*)&TOS)->TraceStr(szOutStr));
		FAILRETN(((IpConfig_UDPSourcePortValid_USR*)&UDPSrcPortValid)->TraceStr(szOutStr));
		FAILRETN(((IpConfig_IMID_USR*)&IMID)->TraceStr(szOutStr));
		FAILRETN(((IpConfig_MID_USR*)&MID)->TraceStr(szOutStr));
		_snprintf(szTemp, TEMP_STR_LEN, ">");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		
		return 0;
	};
} GeneralIpConfig_USR;

typedef struct tagFaxConfig_FaxType_USR: public FaxConfig_FaxType {
	tagFaxConfig_FaxType_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UINT vFaxType)
	{
		Valid = 1;
		if(vFaxType!=(UINT)EHV_NOTHING) FaxType = (UCHAR)vFaxType;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];

		if(Valid==1) {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,FaxType=%d> ", 
				pszParamName?pszParamName:"FaxType", Valid, FaxType);
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", 
				pszParamName?pszParamName:"FaxType", Valid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} FaxConfig_FaxType_USR;

typedef struct tagFaxConfig_BypassCoder_USR: public FaxConfig_BypassCoder {
	tagFaxConfig_BypassCoder_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UINT vDecoder, UINT vFaxBypassM)
	{
		Valid = 1;
		if(vDecoder!=(UINT)EHV_NOTHING) Decoder = (UCHAR)vDecoder;
		if(vFaxBypassM!=(UINT)EHV_NOTHING) FaxBypassM = (UCHAR)vFaxBypassM;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];

		if(Valid==1) {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,Decoder=%d,FaxBypassM=%d> ", 
				pszParamName?pszParamName:"BypassCoder", Valid, Decoder, FaxBypassM);
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", 
				pszParamName?pszParamName:"BypassCoder", Valid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} FaxConfig_BypassCoder_USR;

typedef struct tagFaxConfig_CompMode_USR: public FaxConfig_CompMode {
	tagFaxConfig_CompMode_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UINT vEcmComptMode)
	{
		Valid = 1;
		if(vEcmComptMode!=(UINT)EHV_NOTHING) EcmComptMode = (UCHAR)vEcmComptMode;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];

		if(Valid==1) {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,EcmComptMode=%d> ", 
				pszParamName?pszParamName:"CompMode", Valid, EcmComptMode);
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", 
				pszParamName?pszParamName:"CompMode", Valid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} FaxConfig_CompMode_USR;

typedef struct tagFaxAttributeConfig_USR: public FaxAttributeConfig {
	tagFaxAttributeConfig_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetFaxType(FaxConfig_FaxType *pFaxType)
	{
		if(pFaxType) memcpy(&FaxType, pFaxType, sizeof(FaxConfig_FaxType));
	};
	VOID SetBypassCoder(FaxConfig_BypassCoder *pBypassCoder)
	{
		if(pBypassCoder) memcpy(&BypassCoder, pBypassCoder, sizeof(FaxConfig_BypassCoder));
	};
	VOID SetCompMode(FaxConfig_CompMode *pCompMode)
	{
		if(pCompMode) memcpy(&CompMode, pCompMode, sizeof(FaxConfig_CompMode));
	};
	VOID SetSrcT38Port(IpConfig_UdpPort *pSrcT38Port)
	{
		if(pSrcT38Port) memcpy(&SrcT38Port, pSrcT38Port, sizeof(IpConfig_UdpPort));
	};
	VOID SetDstT38Port(IpConfig_UdpPort *pDstT38Port)
	{
		if(pDstT38Port) memcpy(&DstT38Port, pDstT38Port, sizeof(IpConfig_UdpPort));
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];

		_snprintf(szTemp, TEMP_STR_LEN, "%s<", pszParamName?pszParamName:"FaxConfig");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		FAILRETN(((FaxConfig_FaxType_USR*)&FaxType)->TraceStr(szOutStr));
		FAILRETN(((FaxConfig_BypassCoder_USR*)&BypassCoder)->TraceStr(szOutStr));
		FAILRETN(((FaxConfig_CompMode_USR*)&CompMode)->TraceStr(szOutStr));
		FAILRETN(((IpConfig_UdpPort_USR*)&SrcT38Port)->TraceStr(szOutStr, "SrcT38Port"));
		FAILRETN(((IpConfig_UdpPort_USR*)&DstT38Port)->TraceStr(szOutStr, "DstT38Port"));
		_snprintf(szTemp, TEMP_STR_LEN, ">");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		
		return 0;
	};
} FaxAttributeConfig_USR;

typedef struct tagVoiceConfig_PayloadType_USR: public VoiceConfig_PayloadType {
	tagVoiceConfig_PayloadType_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UINT vPaylaodType)
	{
		Valid = 1;
		if(vPaylaodType!=(UINT)EHV_NOTHING) PaylaodType = (UCHAR)vPaylaodType;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];

		if(Valid==1) {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,PaylaodType=%d> ", 
				pszParamName?pszParamName:"PaylaodType", Valid, PaylaodType);
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", 
				pszParamName?pszParamName:"PaylaodType", Valid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} VoiceConfig_PayloadType_USR;

typedef struct tagVoiceAttributeConfig_USR: public VoiceAttributeConfig {
	tagVoiceAttributeConfig_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetPayloadType(VoiceConfig_PayloadType *pPayloadType)
	{
		if(pPayloadType) memcpy(&PayloadType, pPayloadType, sizeof(VoiceConfig_PayloadType));
	};
	VOID SetPayloadSize(VoiceConfig_PayloadSize *pPayloadSize)
	{
		if(pPayloadSize) memcpy(&PayloadSize, pPayloadSize, sizeof(VoiceConfig_PayloadSize));
	};
	VOID SetSilenceSuppress(VoiceConfig_SilenceSuppress *pSilenceSuppress)
	{
		if(pSilenceSuppress) memcpy(&SilenceSuppress, pSilenceSuppress, sizeof(VoiceConfig_SilenceSuppress));
	};
	VOID SetEchoCancel(VoiceConfig_EchoCancel *pEchoCancel)
	{
		if(pEchoCancel) memcpy(&EchoCancel, pEchoCancel, sizeof(VoiceConfig_EchoCancel));
	};
	VOID SetMinJitterBuffer(VoiceConfig_JitterBufferDelay *pMinJitterBuffer)
	{
		if(pMinJitterBuffer) memcpy(&MinJitterBuffer, pMinJitterBuffer, sizeof(VoiceConfig_JitterBufferDelay));
	};
	VOID SetMaxJitterBuffer(VoiceConfig_JitterBufferDelay *pMaxJitterBuffer)
	{
		if(pMaxJitterBuffer) memcpy(&MaxJitterBuffer, pMaxJitterBuffer, sizeof(VoiceConfig_JitterBufferDelay));
	};
	VOID SetAdaptationRate(VoiceConfig_AdaptationRate *pAdaptationRate)
	{
		if(pAdaptationRate) memcpy(&AdaptationRate, pAdaptationRate, sizeof(VoiceConfig_AdaptationRate));
	};
	VOID SetSrcRTCPPort(IpConfig_UdpPort *pSrcRTCPPort)
	{
		if(pSrcRTCPPort) memcpy(&SrcRTCPPort, pSrcRTCPPort, sizeof(IpConfig_UdpPort));
	};
	VOID SetDstRTCPPort(IpConfig_UdpPort *pDstRTCPPort)
	{
		if(pDstRTCPPort) memcpy(&DstRTCPPort, pDstRTCPPort, sizeof(IpConfig_UdpPort));
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];

		_snprintf(szTemp, TEMP_STR_LEN, "%s<", pszParamName?pszParamName:"VoiceConfig");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		FAILRETN(((VoiceConfig_PayloadType_USR*)&PayloadType)->TraceStr(szOutStr));
		FAILRETN(((VoiceConfig_PayloadSize_USR*)&PayloadSize)->TraceStr(szOutStr));
		FAILRETN(((VoiceConfig_SilenceSuppress_USR*)&SilenceSuppress)->TraceStr(szOutStr));
		FAILRETN(((VoiceConfig_EchoCancel_USR*)&EchoCancel)->TraceStr(szOutStr));
		FAILRETN(((VoiceConfig_JitterBufferDelay_USR*)&MinJitterBuffer)->TraceStr(szOutStr, "MinJitterBuffer"));
		FAILRETN(((VoiceConfig_JitterBufferDelay_USR*)&MaxJitterBuffer)->TraceStr(szOutStr, "MaxJitterBuffer"));
		FAILRETN(((VoiceConfig_AdaptationRate_USR*)&AdaptationRate)->TraceStr(szOutStr));
		FAILRETN(((IpConfig_UdpPort_USR*)&SrcRTCPPort)->TraceStr(szOutStr, "SrcRTCPPort"));
		FAILRETN(((IpConfig_UdpPort_USR*)&DstRTCPPort)->TraceStr(szOutStr, "DstRTCPPort"));
		_snprintf(szTemp, TEMP_STR_LEN, ">");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		
		return 0;
	};
} VoiceAttributeConfig_USR;

typedef struct tagRfc2198Config_RTPPacketDepth_USR: public Rfc2198Config_RTPPacketDepth {
	tagRfc2198Config_RTPPacketDepth_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UINT vRedundancyDepth)
	{
		Valid = 1;
		if(vRedundancyDepth!=(UINT)EHV_NOTHING) RedundancyDepth = (UCHAR)vRedundancyDepth;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];

		if(Valid==1) {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,RedundancyDepth=%d> ", 
				pszParamName?pszParamName:"Redundancy", Valid, RedundancyDepth);
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", 
				pszParamName?pszParamName:"Redundancy", Valid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} Rfc2198Config_RTPPacketDepth_USR, Rfc2198Config_FaxPacketDepth_USR, Rfc2198Config_Rfc2833PacketDepth_USR;

typedef struct tagRfc2198Config_DynamicPayload_USR: public Rfc2198Config_DynamicPayload {
	tagRfc2198Config_DynamicPayload_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UINT vDynamicPayload)
	{
		Valid = 1;
		if(vDynamicPayload!=(UINT)EHV_NOTHING) DynamicPayload = (UCHAR)vDynamicPayload;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];

		if(Valid==1) {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,DynamicPayload=%d> ", 
				pszParamName?pszParamName:"DynamicPayload", Valid, DynamicPayload);
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", 
				pszParamName?pszParamName:"DynamicPayload", Valid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} Rfc2198Config_DynamicPayload_USR;

typedef struct tagRfc2198Config_USR: public Rfc2198Config {
	tagRfc2198Config_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetRtpPacketDepth(Rfc2198Config_RTPPacketDepth *pRtpPacketDepth)
	{
		if(pRtpPacketDepth) memcpy(&RtpPacketDepth, pRtpPacketDepth, sizeof(Rfc2198Config_RTPPacketDepth));
	};
	VOID SetFaxPacketDepth(Rfc2198Config_FaxPacketDepth *pFaxPacketDepth)
	{
		if(pFaxPacketDepth) memcpy(&FaxPacketDepth, pFaxPacketDepth, sizeof(Rfc2198Config_FaxPacketDepth));
	};
	VOID SetRfc2833PacketDepth(Rfc2198Config_Rfc2833PacketDepth *pRfc2833PacketDepth)
	{
		if(pRfc2833PacketDepth) memcpy(&Rfc2833PacketDepth, pRfc2833PacketDepth, sizeof(Rfc2198Config_Rfc2833PacketDepth));
	};
	VOID SetDynamicPayload(Rfc2198Config_DynamicPayload *pDynamicPayload)
	{
		if(pDynamicPayload) memcpy(&DynamicPayload, pDynamicPayload, sizeof(Rfc2198Config_DynamicPayload));
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];

		_snprintf(szTemp, TEMP_STR_LEN, "%s<", pszParamName?pszParamName:"Rfc2198Config");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		FAILRETN(((Rfc2198Config_RTPPacketDepth_USR*)&RtpPacketDepth)->TraceStr(szOutStr));
		FAILRETN(((Rfc2198Config_FaxPacketDepth_USR*)&FaxPacketDepth)->TraceStr(szOutStr));
		FAILRETN(((Rfc2198Config_Rfc2833PacketDepth_USR*)&Rfc2833PacketDepth)->TraceStr(szOutStr));
		FAILRETN(((Rfc2198Config_DynamicPayload_USR*)&DynamicPayload)->TraceStr(szOutStr));
		_snprintf(szTemp, TEMP_STR_LEN, ">");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		
		return 0;
	};
} Rfc2198Config_USR;

typedef struct tagIpMedia_AnswerDetectorInfo_USR: public IpMedia_AnswerDetectorInfo {
	tagIpMedia_AnswerDetectorInfo_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UINT vActive, UINT vActivityDelay, UINT vRedirection, UINT vSilenceTime)
	{
		Valid = 1;
		if(vActive!=(UINT)EHV_NOTHING) Active = (UCHAR)vActive;
		if(vActivityDelay!=(UINT)EHV_NOTHING) ActivityDelay = (UCHAR)vActivityDelay;
		if(vRedirection!=(UINT)EHV_NOTHING) Redirection = (UCHAR)vRedirection;
		if(vSilenceTime!=(UINT)EHV_NOTHING) SilenceTime = (UCHAR)vSilenceTime;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];

		if(Valid==1) {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,Active=%d,ActivityDelay=%d,Redirection=%d,SilenceTime=%d> ", 
				pszParamName?pszParamName:"AnswerDetector", Valid, Active, ActivityDelay, Redirection, SilenceTime);
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", 
				pszParamName?pszParamName:"AnswerDetector", Valid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} IpMedia_AnswerDetectorInfo_USR;

typedef struct tagIpMedia_AgcInfo_USR: public IpMedia_AgcInfo {
	tagIpMedia_AgcInfo_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UINT vActive, UINT vGainSlop, UINT vRedirection, UINT vTargetEnergy)
	{
		Valid = 1;
		if(vActive!=(UINT)EHV_NOTHING) Active = (UCHAR)vActive;
		if(vGainSlop!=(UINT)EHV_NOTHING) GainSlop = (UCHAR)vGainSlop;
		if(vRedirection!=(UINT)EHV_NOTHING) Redirection = (UCHAR)vRedirection;
		if(vTargetEnergy!=(UINT)EHV_NOTHING) TargetEnergy = (UCHAR)vTargetEnergy;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];

		if(Valid==1) {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,Active=%d,GainSlop=%d,Redirection=%d,TargetEnergy=%d> ", 
				pszParamName?pszParamName:"Agc", Valid, Active, GainSlop, Redirection, TargetEnergy);
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", 
				pszParamName?pszParamName:"Agc", Valid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} IpMedia_AgcInfo_USR;

typedef struct tagIpMedia_EnergyDetectorInfo_USR: public IpMedia_EnergyDetectorInfo {
	tagIpMedia_EnergyDetectorInfo_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UINT vActive, UINT vThreshold, UINT vQualifyFactor)
	{
		Valid = 1;
		if(vActive!=(UINT)EHV_NOTHING) Active = (UCHAR)vActive;
		if(vThreshold!=(UINT)EHV_NOTHING) Threshold = (UCHAR)vThreshold;
		if(vQualifyFactor!=(UINT)EHV_NOTHING) QualifyFactor = (UCHAR)vQualifyFactor;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];

		if(Valid==1) {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,Active=%d,Threshold=%d,QualifyFactor=%d> ", 
				pszParamName?pszParamName:"EnergyDetector", Valid, Active, Threshold, QualifyFactor);
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d> ", 
				pszParamName?pszParamName:"EnergyDetector", Valid);
		}
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} IpMedia_EnergyDetectorInfo_USR;

typedef struct tagIpMediaConfig_USR: public IpMediaConfig {
	tagIpMediaConfig_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetAnswerDetector(IpMedia_AnswerDetectorInfo *pAnswerDetector)
	{
		if(pAnswerDetector) memcpy(&AnswerDetector, pAnswerDetector, sizeof(IpMedia_AnswerDetectorInfo));
	};
	VOID SetAgc(IpMedia_AgcInfo *pAgc)
	{
		if(pAgc) memcpy(&Agc, pAgc, sizeof(IpMedia_AgcInfo));
	};
	VOID SetEnergyDetector(IpMedia_EnergyDetectorInfo *pEnergyDetector)
	{
		if(pEnergyDetector) memcpy(&EnergyDetector, pEnergyDetector, sizeof(IpMedia_EnergyDetectorInfo));
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];

		_snprintf(szTemp, TEMP_STR_LEN, "%s<", pszParamName?pszParamName:"IpMediaCfg");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		FAILRETN(((IpMedia_AnswerDetectorInfo_USR*)&AnswerDetector)->TraceStr(szOutStr));
		FAILRETN(((IpMedia_AgcInfo_USR*)&Agc)->TraceStr(szOutStr));
		FAILRETN(((IpMedia_EnergyDetectorInfo_USR*)&EnergyDetector)->TraceStr(szOutStr));
		_snprintf(szTemp, TEMP_STR_LEN, ">");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		
		return 0;
	};
} IpMediaConfig_USR;

typedef struct tagXOIP_CFG_USR: public XOIP_CFG {
	tagXOIP_CFG_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UINT vConnMode)
	{
		if(vConnMode!=(UINT)EHV_NOTHING) ConnMode = (UCHAR)vConnMode;
	};
	VOID SetDstIpAddr(IpConfig_IP_addr *pDstIpAddr)
	{
		if(pDstIpAddr) memcpy(&DstIpAddr, pDstIpAddr, sizeof(IpConfig_IP_addr));
	};
	VOID SetDstRtpPort(IpConfig_UdpPort *pDstRtpPort)
	{
		if(pDstRtpPort) memcpy(&DstRtpPort, pDstRtpPort, sizeof(IpConfig_UdpPort));
	};
	VOID SetGenIpCfg(GeneralIpConfig *pGenIpCfg)
	{
		if(pGenIpCfg) memcpy(&GenIpCfg, pGenIpCfg, sizeof(GeneralIpConfig));
	};
	VOID SetFaxCfg(FaxAttributeConfig *pFaxCfg)
	{
		if(pFaxCfg) memcpy(&FaxCfg, pFaxCfg, sizeof(FaxAttributeConfig));
	};
	VOID SetVoiceCfg(VoiceAttributeConfig *pVoiceCfg)
	{
		if(pVoiceCfg) memcpy(&VoiceCfg, pVoiceCfg, sizeof(VoiceAttributeConfig));
	};
	VOID SetDtmfCfg(DtmfConfig *pDtmfCfg)
	{
		if(pDtmfCfg) memcpy(&DtmfCfg, pDtmfCfg, sizeof(DtmfConfig));
	};
	VOID SetRfc2189Cfg(Rfc2198Config *pRfc2189Cfg)
	{
		if(pRfc2189Cfg) memcpy(&Rfc2189Cfg, pRfc2189Cfg, sizeof(Rfc2198Config));
	};
	VOID SetIpMediaCfg(IpMediaConfig *pIpMediaCfg)
	{
		if(pIpMediaCfg) memcpy(&IpMediaCfg, pIpMediaCfg, sizeof(IpMediaConfig));
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];

		_snprintf(szTemp, TEMP_STR_LEN, "%s<ConnMode=%d,", 
			pszParamName?pszParamName:"VoiceCdt", ConnMode);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		FAILRETN(((IpConfig_IP_addr_USR*)&DstIpAddr)->TraceStr(szOutStr));
		FAILRETN(((IpConfig_UdpPort_USR*)&DstRtpPort)->TraceStr(szOutStr));
		FAILRETN(((GeneralIpConfig_USR*)&GenIpCfg)->TraceStr(szOutStr));
		FAILRETN(((FaxAttributeConfig_USR*)&FaxCfg)->TraceStr(szOutStr));
		FAILRETN(((VoiceAttributeConfig_USR*)&VoiceCfg)->TraceStr(szOutStr));
		FAILRETN(((DtmfConfig_USR*)&DtmfCfg)->TraceStr(szOutStr));
		FAILRETN(((Rfc2198Config_USR*)&Rfc2189Cfg)->TraceStr(szOutStr));
		FAILRETN(((IpMediaConfig_USR*)&IpMediaCfg)->TraceStr(szOutStr));
		FAILRETN(((IpConfig_UdpPort_USR*)&SrcRtpPort)->TraceStr(szOutStr));
		_snprintf(szTemp, TEMP_STR_LEN, ">");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		
		return 0;
	};
} XOIP_CFG_USR;

typedef struct tagM3G_VIDEOCONF_FOREGROUND_USR: public tagM3G_VIDEOCONF_FOREGROUND {
	tagM3G_VIDEOCONF_FOREGROUND_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UINT vControlCode, CHAR *vFileName) 
	{ 
		if(vControlCode!=(UINT)EHV_NOTHING) ucControlCode = (UCHAR)vControlCode;
		if(vFileName!=NULL) strncpy(szFileName, vFileName, sizeof(szFileName));
	};
	VOID Set_vision(VIDEO_PARTICIANT_VISION *pVision)
	{
		if(pVision) memcpy(&vision, pVision, sizeof(VIDEO_PARTICIANT_VISION));
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];

		_snprintf(szTemp, TEMP_STR_LEN, "%s<ControlCode=%d,", pszParamName?pszParamName:"Foreground", ucControlCode);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		FAILRETN(((VIDEO_PARTICIANT_VISION_USR*)&vision)->TraceStr(szOutStr));
		_snprintf(szTemp, TEMP_STR_LEN, "FileName=%s)> ", szFileName);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_VIDEOCONF_FOREGROUND_USR, M3G_VIDEOCONF_BACKGROUND_USR;

typedef struct tagM3G_BOX_ATTRI_USR: public tagM3G_BOX_ATTRI {
	tagM3G_BOX_ATTRI_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UINT vBoxColorY, UINT vBoxColorU, UINT vBoxColorV, UINT vLineSize) 
	{ 
		if(vBoxColorY!=(UINT)EHV_NOTHING) ucBoxColorY = (UCHAR)vBoxColorY;
		if(vBoxColorU!=(UINT)EHV_NOTHING) ucBoxColorU = (UCHAR)vBoxColorU;
		if(vBoxColorV!=(UINT)EHV_NOTHING) ucBoxColorV = (UCHAR)vBoxColorV;
		if(vLineSize!=(UINT)EHV_NOTHING) ucLineSize = (UCHAR)vLineSize;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];

		_snprintf(szTemp, TEMP_STR_LEN, "%s<YUV(%d.%d.%d),LineSize=%d> ", 
			pszParamName?pszParamName:"BoxAttr", ucBoxColorY, ucBoxColorU, ucBoxColorV, ucLineSize);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_BOX_ATTRI_USR;

typedef struct tagM3G_BOX_VISION_ITEM_USR: public tagM3G_BOX_VISION_ITEM {
	tagM3G_BOX_VISION_ITEM_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue() { };
	VOID Set_Vision(VIDEO_PARTICIANT_VISION *pVision)
	{
		if(pVision) memcpy(&Vision, pVision, sizeof(VIDEO_PARTICIANT_VISION));
	};
	VOID Set_BoxAttr(M3G_BOX_ATTRI *pBoxAttr)
	{
		if(pBoxAttr) memcpy(&BoxAttr, pBoxAttr, sizeof(M3G_BOX_ATTRI));
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];

		_snprintf(szTemp, TEMP_STR_LEN, "%s<", pszParamName?pszParamName:"BoxItem");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		FAILRETN(((VIDEO_PARTICIANT_VISION_USR*)&Vision)->TraceStr(szOutStr));
		FAILRETN(((M3G_BOX_ATTRI_USR*)&BoxAttr)->TraceStr(szOutStr));
		_snprintf(szTemp, TEMP_STR_LEN, ">");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_BOX_VISION_ITEM_USR;

typedef struct tagM3G_VIDEOCONF_BOX_USR: public tagM3G_VIDEOCONF_BOX {
	tagM3G_VIDEOCONF_BOX_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UINT vVisionNum, M3G_BOX_VISION_ITEM* pVision=NULL) 
	{ 
		if(vVisionNum!=(UINT)EHV_NOTHING) {
			ucVisionNum = (UCHAR)vVisionNum;
			if(ucVisionNum>=MAX_VIDEOCONF_MIXER_NUM) ucVisionNum = MAX_VIDEOCONF_MIXER_NUM;
		} else ucVisionNum = 0;
		if(pVision) {
			for(INT i=0; i<(INT)ucVisionNum; i++) {
				memcpy(&Visions[i], &pVision[i], sizeof(M3G_BOX_VISION_ITEM));
			}
		}
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<VisionNum=%d(", pszParamName?pszParamName:"ConfBox", ucVisionNum);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		CHAR szIndex[8]={0};
		for(INT i=0; i<(INT)ucVisionNum; i++) {
			sprintf(szIndex, "%d", i);
			FAILRETN(((M3G_BOX_VISION_ITEM_USR*)&Visions[i])->TraceStr(szOutStr, szIndex));
		}
		_snprintf(szTemp, TEMP_STR_LEN, ")> ");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_VIDEOCONF_BOX_USR;

typedef struct tagM3G_VOICE_EC_GAIN_USR: public tagM3G_VOICE_EC_GAIN {
	tagM3G_VOICE_EC_GAIN_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(INT rin=0, INT rout=0, INT sin=0, INT sout=0) 
	{ 
		rin_gain = rin;
		rout_gain = rout;
		sin_gain = sin;
		sout_gain = sout;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];

		_snprintf(szTemp, TEMP_STR_LEN, "%s<rin=%d, rout=%d, sin=%d, sout=%d> ", 
			pszParamName?pszParamName:"EcGain", rin_gain, rout_gain, sin_gain, sout_gain);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_VOICE_EC_GAIN_USR;

/* AGC增益部分 */
typedef struct tagM3G_VOICE_AGC_USR: public tagM3G_VOICE_AGC {
	tagM3G_VOICE_AGC_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(UCHAR vEnable=0, UINT vEngAvgWindowLen=100, INT vMinSignalLevel=-14, INT vMaxSignalLevel=-10,
			UINT vStepLevel=10, INT vSilentLevelThreshold=-30, UCHAR vMaxAppliedGainUsed=0, UINT vMaxAppliedGain=20) 
	{ 
		ucEnable = vEnable;
		ulEngAvgWindowLen = vEngAvgWindowLen;
		lMinSignalLevel = vMinSignalLevel;
		lMaxSignalLevel = vMaxSignalLevel;
		ulStepLevel = vStepLevel;
		lSilentLevelThreshold = vSilentLevelThreshold;
		ucMaxAppliedGainUsed = vMaxAppliedGainUsed;
		ulMaxAppliedGain = vMaxAppliedGain;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];

		_snprintf(szTemp, TEMP_STR_LEN, "%s<Enable=%d, EngAvgWindowLen=%d, MinSignalLevel=%d, MaxSignalLevel=%d, "
			"StepLevel=%d, SilentLevelThreshold=%d, MaxAppliedGainUsed=%d, MaxAppliedGain=%d> ", 
			pszParamName?pszParamName:"AGCGain", ucEnable, ulEngAvgWindowLen, lMinSignalLevel, lMaxSignalLevel,
			ulStepLevel, lSilentLevelThreshold, ucMaxAppliedGainUsed, ulMaxAppliedGain);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_VOICE_AGC_USR;

typedef struct tagM3G_VOICE_VOLPARM_USR: public tagM3G_VOICE_VOLPARM {
	tagM3G_VOICE_VOLPARM_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(M3G_VOICE_EC_GAIN *pEcGain, M3G_VOICE_AGC* pAGCFromTDM=NULL, M3G_VOICE_AGC* pAGCFromIP=NULL) 
	{ 
		if(pEcGain) memcpy(&EcGain, pEcGain, sizeof(M3G_VOICE_EC_GAIN));
		if(pAGCFromTDM) memcpy(&AGCFromTDM, pAGCFromTDM, sizeof(M3G_VOICE_AGC));
		else AGCFromTDM.ucEnable = 0;
		if(pAGCFromIP) memcpy(&AGCFromIP, pAGCFromIP, sizeof(M3G_VOICE_AGC));
		else AGCFromIP.ucEnable = 0;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];

		_snprintf(szTemp, TEMP_STR_LEN, "%s<", pszParamName?pszParamName:"VolParm");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		FAILRETN(((M3G_VOICE_EC_GAIN_USR*)&EcGain)->TraceStr(szOutStr));
		FAILRETN(((M3G_VOICE_AGC_USR*)&AGCFromTDM)->TraceStr(szOutStr, "AGCFromTDM"));
		FAILRETN(((M3G_VOICE_AGC_USR*)&AGCFromIP)->TraceStr(szOutStr, "AGCFromIP"));
		_snprintf(szTemp, TEMP_STR_LEN, ">");
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	};
} M3G_VOICE_VOLPARM_USR;

typedef struct tagUSER_TO_USER_INFO_USR: public USER_TO_USER_INFO{
	tagUSER_TO_USER_INFO_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT SetDefault(UCHAR vValid)
	{
		if(vValid==enFieldMT_User2UserInfo) {
			valid = enFieldMT_User2UserInfo;
			ProtoDiscriminator = 0x04;		//IA5 characters
			sprintf((CHAR*)info, "0123456789");
			len = strlen((CHAR*)info);
		} else if(vValid == enFieldMT_PRI_RedirctingNumb) {
			valid = enFieldMT_PRI_RedirctingNumb;
			RedirectingNumb.numb_type = 0;
			RedirectingNumb.numb_play = 0;
			RedirectingNumb.pres_ind = 0;
			RedirectingNumb.redirect_reason = 0;
			sprintf((CHAR*)RedirectingNumb.numb, "02085567013");
		} else if(valid==enFieldMT_PRI_UuiRedirNumb){
			valid = enFieldMT_PRI_UuiRedirNumb;
			UuiRN.ProtoDiscriminator = 0x04;		//IA5 characters
			sprintf((CHAR*)UuiRN.info, "0123456789");
			UuiRN.len = strlen((CHAR*)UuiRN.info);
			UuiRN.info[UuiRN.len]=0;
			UuiRN.pRedirNumb = (PRI_REDIRECT_NUMB *)&UuiRN.info[UuiRN.len+1];
			UuiRN.pRedirNumb->numb_type = 0;
			UuiRN.pRedirNumb->numb_play = 0;
			UuiRN.pRedirNumb->pres_ind = 0;
			UuiRN.pRedirNumb->redirect_reason = 0;
			sprintf((CHAR*)UuiRN.pRedirNumb->numb, "02085567013");

		} else return -1;
		return 0;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		if(valid==enFieldMT_User2UserInfo) {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<valid=%d, len=%d,ProtoDiscriminator=%d,info=%s>",
				pszParamName?pszParamName:"U2UInfo", 
				valid,len,ProtoDiscriminator, (char *)info);
			FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		} else if(valid==enFieldMT_PRI_RedirctingNumb){
			_snprintf(szTemp, TEMP_STR_LEN, "%s<valid=%d, RedirectingNumb<numb_type=%d,numb_play=%d,"
				"pres_ind=%d,redirect_reason=%d,numb=%s>>",	pszParamName?pszParamName:"U2UInfo", 
				valid,RedirectingNumb.numb_type,RedirectingNumb.numb_play, 
				RedirectingNumb.pres_ind, RedirectingNumb.redirect_reason, (char *)RedirectingNumb.numb);
			FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		} else if(valid==enFieldMT_PRI_UuiRedirNumb){
			if(UuiRN.pRedirNumb) {
				_snprintf(szTemp, TEMP_STR_LEN, "%s<valid=%d, len=%d,ProtoDiscriminator=%d,info=%s, "
					"pRedirNumb<numb_type=%d,numb_play=%d,pres_ind=%d,redirect_reason=%d,numb=%s> >",
					pszParamName?pszParamName:"U2UInfo", valid, UuiRN.len, UuiRN.ProtoDiscriminator, 
					(char*)UuiRN.info, 
					UuiRN.pRedirNumb->numb_type, 
					UuiRN.pRedirNumb->numb_play,
					UuiRN.pRedirNumb->pres_ind,
					UuiRN.pRedirNumb->redirect_reason,
					(char *)UuiRN.pRedirNumb->numb);
			} else {
				_snprintf(szTemp, TEMP_STR_LEN, "%s<valid=%d, len=%d,ProtoDiscriminator=%d,info=%s, pRedirNumb=NULL >",
					pszParamName?pszParamName:"U2UInfo", valid, UuiRN.len, UuiRN.ProtoDiscriminator, (char*)UuiRN.info);
			}
			FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<valid=%d>", pszParamName?pszParamName:"U2UInfo", valid);
			FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		}
		return 0;
	};
}USER_TO_USER_INFO_USR;

typedef struct tagISXSIP_ADDR_URL_USR: public ISXSIP_ADDR_URL{
	tagISXSIP_ADDR_URL_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetDefault()
	{
		User[0]=0;
		Host[0]=0;
		PortNum = 0xffff;
		Ttl = 0xffff;
		IsSecure = 0;
		LrType = ISXSIP_URL_LR_UNDEFINED;
		TransportType = ISXSIP_TRANSPORT_UNDEFINED;
		MethodType = ISXSIP_METHOD_UNDEFINED;
		MAddrParam[0]=0;
	};
	VOID SetValue(CHAR* vUser, CHAR* vHost, USHORT vPort=0xffff) 
	{	
		_snprintf(User, sizeof(User), vUser);
		_snprintf(Host, sizeof(Host), vHost);
		PortNum = vPort;
	};
	VOID SetOther(USHORT vTtl=0xffff, UCHAR vIsSecure=0, 
				  UCHAR vLrType=ISXSIP_URL_LR_UNDEFINED, 
				  UCHAR vTransportType=ISXSIP_TRANSPORT_UNDEFINED, 
				  UCHAR vMethodType=ISXSIP_METHOD_UNDEFINED, 
				  CHAR* vMAddrParam=NULL) 
	{	
		Ttl = vTtl;
		IsSecure = vIsSecure;
		LrType = vLrType;
		TransportType = vTransportType;
		MethodType = vMethodType;
		if(vMAddrParam) _snprintf(MAddrParam, sizeof(MAddrParam), vMAddrParam);
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<User=%s,Host=%s,PortNum=%d,Ttl=%d,IsSecure=%d,LrType=%d,TransportType=%d,MethodType=%d,MAddrParam=%s>",
			pszParamName?pszParamName:"url", (char*)User, (char*)Host, PortNum,Ttl,IsSecure,LrType,TransportType,MethodType,(char*)MAddrParam);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	}
}ISXSIP_ADDR_URL_USR;

typedef struct tagISXSIP_ADDR_URI_USR: public ISXSIP_ADDR_URI{
	tagISXSIP_ADDR_URI_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetDefault()
	{
		Scheme[0] = 0;
		Identifier[0] = 0;
	};
	VOID SetValue(CHAR* vScheme, CHAR* vIdentifier) 
	{	
		_snprintf(Scheme, sizeof(Scheme), vScheme);
		_snprintf(Identifier, sizeof(Identifier), vIdentifier);
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<Scheme=%s, Identifier=%s>",
			pszParamName?pszParamName:"uri", (char*)Scheme, (char*)Identifier);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	}
}ISXSIP_ADDR_URI_USR;

typedef struct tagISXSIP_ADDR_LONG_URL_USR: public ISXSIP_ADDR_LONG_URL{
	tagISXSIP_ADDR_LONG_URL_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetDefault()
	{
		User[0]=0;
		Host[0]=0;
		PortNum = 0xffff;
		IsSecure = 0;
		TransportType = ISXSIP_TRANSPORT_UNDEFINED;
	};
	VOID SetValue(CHAR* vUser, CHAR* vHost, USHORT vPort=0xffff) 
	{	
		_snprintf(User, sizeof(User), vUser);
		_snprintf(Host, sizeof(Host), vHost);
		PortNum = vPort;
	};
	VOID SetOther(UCHAR vIsSecure=0, UCHAR vTransportType=ISXSIP_TRANSPORT_UNDEFINED) 
	{	
		IsSecure = vIsSecure;
		TransportType = vTransportType;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<User=%s,Host=%s,PortNum=%d,IsSecure=%d,TransportType=%d>",
			pszParamName?pszParamName:"url", (char*)User, (char*)Host, PortNum,IsSecure,TransportType);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	}
}ISXSIP_ADDR_LONG_URL_USR;

typedef struct tagISXSIP_ADDR_LONG_USER_USR: public ISXSIP_ADDR_LONG_USER{
	tagISXSIP_ADDR_LONG_USER_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetDefault()
	{
		User[0]=0;
		Host[0]=0;
		PortNum = 0xffff;
		IsSecure = 0;
		TransportType = ISXSIP_TRANSPORT_UNDEFINED;
		UserType=ISXSIP_USER_TYPE_UNDEFINED;
	};
	VOID SetValue(CHAR* vUser, CHAR* vHost, USHORT vPort=0xffff) 
	{	
		_snprintf(User, sizeof(User), vUser);
		_snprintf(Host, sizeof(Host), vHost);
		PortNum = vPort;
	};
	VOID SetOther(UCHAR vIsSecure=0, UCHAR vTransportType=ISXSIP_TRANSPORT_UNDEFINED, UCHAR vUserType=ISXSIP_USER_TYPE_UNDEFINED) 
	{	
		IsSecure = vIsSecure;
		TransportType = vTransportType;
		UserType = vUserType;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		_snprintf(szTemp, TEMP_STR_LEN, "%s<User=%s,Host=%s,PortNum=%d,IsSecure=%d,TransportType=%d,UserType=%d>",
			pszParamName?pszParamName:"url", (char*)User, (char*)Host, PortNum,IsSecure,TransportType,UserType);
		FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		return 0;
	}
}ISXSIP_ADDR_LONG_USER_USR;

typedef struct tagISXSIP_IE_ADDR: public ISXSIP_IE_ADDR {
	tagISXSIP_IE_ADDR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT SetDefault(UCHAR vValid, UCHAR vAddType)
	{
		Valid = vValid;
		AddType = vAddType;
		if(vAddType==ISXSIP_ADDTYPE_URL) {
			((ISXSIP_ADDR_URL_USR*)&u.AddrUrl)->SetDefault();
		} else if(vAddType == ISXSIP_ADDTYPE_URI) {
			((ISXSIP_ADDR_URI_USR*)&u.AddrUri)->SetDefault();
		} else if(vAddType==ISXSIP_ADDTYPE_LONG_URL){
			((ISXSIP_ADDR_LONG_URL_USR*)&u.AddrLongUrl)->SetDefault();
		} else if(vAddType==ISXSIP_ADDTYPE_LONG_USER) {
			((ISXSIP_ADDR_LONG_USER_USR*)&u.AddrLongUsr)->SetDefault();
		}
		else return -1;
		return 0;
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		CHAR szTemp[TEMP_STR_LEN];
		if(Valid==0) {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d>", pszParamName?pszParamName:"Addr", Valid);
			FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		} else if(AddType==ISXSIP_ADDTYPE_URL) {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,AddType=%d ",	pszParamName?pszParamName:"Addr", Valid,AddType);
			FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
			FAILRETN(((ISXSIP_ADDR_URL_USR*)&u.AddrUrl)->TraceStr(szOutStr, "AddrUrl"));
			_snprintf(szTemp, TEMP_STR_LEN, "> ");
			FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		} else if(AddType==ISXSIP_ADDTYPE_URI){
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,AddType=%d ",	pszParamName?pszParamName:"Addr", Valid,AddType);
			FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
			FAILRETN(((ISXSIP_ADDR_URI_USR*)&u.AddrUri)->TraceStr(szOutStr, "AddrUri"));
			_snprintf(szTemp, TEMP_STR_LEN, "> ");
			FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		} else if(AddType==ISXSIP_ADDTYPE_LONG_URL){
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,AddType=%d ",	pszParamName?pszParamName:"Addr", Valid,AddType);
			FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
			FAILRETN(((ISXSIP_ADDR_LONG_URL_USR*)&u.AddrUri)->TraceStr(szOutStr, "AddrLongUrl"));
			_snprintf(szTemp, TEMP_STR_LEN, "> ");
			FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		} else if(AddType==ISXSIP_ADDTYPE_LONG_USER){
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,AddType=%d ",	pszParamName?pszParamName:"Addr", Valid,AddType);
			FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
			FAILRETN(((ISXSIP_ADDR_LONG_USER_USR*)&u.AddrUri)->TraceStr(szOutStr, "AddrLongUsr"));
			_snprintf(szTemp, TEMP_STR_LEN, "> ");
			FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
		} else {
			_snprintf(szTemp, TEMP_STR_LEN, "%s<Valid=%d,AddType=%d(ERR)>", pszParamName?pszParamName:"Addr", Valid, AddType);
			FAILRETN(STR_OVERFLOW_CHECK(szOutStr, szTemp));
			return -1;
		}
		return 0;
	};
} ISXSIP_IE_ADDR_USR;

#pragma  pack()
//pack() end
//////////////////////////////////////////////////////////////////////////

typedef struct tagDX_IOTT_USR: public DX_IOTT {
	tagDX_IOTT_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(CHAR* vio_bufp, USHORT vio_type=IO_EOT, UINT vio_length=(UINT)-1, UINT vio_offset=0, INT vio_fhandle=0, DX_IOTT* vio_nextp=NULL) 
	{ 
		io_type		=vio_type;		/* Transfer type */
		io_fhandle	=vio_fhandle;	/* File descriptor */
		io_bufp		=vio_bufp;		/* Pointer to base memory */
		io_offset	=vio_offset;		/* File/Buffer offset */
		io_length	=vio_length;		/* Length of data */
		io_nextp	=vio_nextp;		/* Pointer to next DX_IOTT if IO_LINK */
		io_prevp	=NULL;			/* (optional) Pointer to previous DX_IOTT */ 
		rfu			=0;				/* reserved */
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		return 0;
	};
	
}DX_IOTT_USR;

typedef struct tagDV_TPT_USR: public DV_TPT {
	tagDV_TPT_USR() { Init(); };
	VOID Init()	{ memset(this, 0, sizeof(*this) ); };
	INT  GetSize() { return sizeof(*this); };
	VOID SetValue(USHORT vtp_termno, USHORT vtp_length, USHORT vtp_flags, USHORT vtp_data=0, USHORT vtp_type=IO_EOT, DV_TPT* vtp_nextp=NULL) 
	{ 
		tp_type		=vtp_type;		/* Flags Describing this Entry */
		tp_termno	=vtp_termno;		/* Termination Parameter Number */
		tp_length	=vtp_length;		/* Length of Terminator */
		tp_flags	=vtp_flags;		/* Termination Parameter Attributes Flag */
		tp_data		=vtp_data;		/* Optional Additional Data */
		rfu			=0;				/* Reserved */
		tp_nextp	=vtp_nextp;		/* Ptr to next DV_TPT if IO_LINK set */
	};
	INT TraceStr(CHAR *szOutStr, const CHAR* pszParamName = NULL)
	{
		return 0;
	};
	
}DV_TPT_USR;

//////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#undef extern
#endif

#endif