Middleware_5.1/3rd/ehang/Inc/m3glib.h

/*********************************************************************/
/*        EhangCom: API Head file
 *
 *        FILE: m3glib.h
 *
 * DESCRIPTION: Header File for EhangCom Digital M3G 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.
 */
/*********************************************************************/


#ifndef __M3GLIB_H__
#define __M3GLIB_H__

#include "IsxApi.h"
#include "srllib.h"
#include "ipmlib.h"
#include "voclib.h"
#include "siplib.h"

#ifndef M3GDEV
#define	M3GDEV		INT
#endif

/************************************************************************/
//Define Media Port Format
#ifndef EHANG_MEDIA_BEGIN_PORT
#define EHANG_MEDIA_BEGIN_PORT	30000
#define EHANG_MAKE_MEDIA_PORT(ch, i)	EHANG_MEDIA_BEGIN_PORT+(ch*16)+i
#endif
/************************************************************************/

//////////////////////////////////////////////////////////////////////////
/*
 - Error codes returned by ATDV_LASTERR()
 */
#define EM3G_NOERROR						ISXEC_NOERROR
#define	EM3G_SYSTEM							ISXEC_SYSTEM
#define	EM3G_BUSY							ISXEC_BUSY
#define EM3G_TIMEOUT						ISXEC_TIMEOUT
#define EM3G_BADTPT							ISXEC_BADTPT
#define	EM3G_BADIOTT						ISXEC_BADIOTT
#define EM3G_BADPARM						ISXEC_BADPARM			
#define EM3G_OPERTIMEOUT					ISXEC_OPERTIMEOUT		
#define EM3G_INVALID_STATE					ISXEC_INVALID_STATE
#define	EM3G_CHAN_TYPE_ERROR				ISXEC_CHAN_TYPE_ERROR	
//////////////////////////////////////////////////////////////////////////

/*
 - Define M3G Event Types
*/
#ifndef M3GEV_BASE
#define	M3GEV_BASE	0x300
#define M3GEV_BASE_END						(M3GEV_BASE | 0xff)
#define M3GEV_OPEN_CMPLT					(M3GEV_BASE | 0x01)	
#define M3GEV_OPEN_FAIL						(M3GEV_BASE | 0x02)	
#define M3GEV_SET_PARM_CMPLT				(M3GEV_BASE | 0x03)	
#define M3GEV_SET_PARM_FAIL					(M3GEV_BASE | 0x04)	
#define M3GEV_GET_PARM_CMPLT				(M3GEV_BASE | 0x05)	
#define M3GEV_GET_PARM_FAIL					(M3GEV_BASE | 0x06)	
#define M3GEV_START_MEDIA_CMPLT				(M3GEV_BASE | 0x07)	
#define M3GEV_START_MEDIA_FAIL				(M3GEV_BASE | 0x08)	
#define M3GEV_STOP_MEDIA_CMPLT				(M3GEV_BASE | 0x09)	
#define M3GEV_STOP_MEDIA_FAIL				(M3GEV_BASE | 0x0a)	
#define M3GEV_PLAY_BEGIN					(M3GEV_BASE | 0x0b)	
#define M3GEV_PLAY_CMPLT					(M3GEV_BASE | 0x0c)	
#define M3GEV_PLAY_FAIL						(M3GEV_BASE | 0x0d)	
#define M3GEV_RECORD_BEGIN					(M3GEV_BASE | 0x0e)	
#define M3GEV_RECORD_CMPLT					(M3GEV_BASE | 0x0f)	
#define M3GEV_RECORD_FAIL					(M3GEV_BASE | 0x10)	
#define M3GEV_PAUSE_CMPLT					(M3GEV_BASE | 0x11)	
#define M3GEV_PAUSE_FAIL					(M3GEV_BASE | 0x12)	
#define M3GEV_RESUME_CMPLT					(M3GEV_BASE | 0x13)	
#define M3GEV_RESUME_FAIL					(M3GEV_BASE | 0x14)	
#define M3GEV_GET_DIGITS_CMPLT				(M3GEV_BASE | 0x15)	
#define M3GEV_GET_DIGITS_FAIL				(M3GEV_BASE | 0x16)	
#define	M3GEV_DIGITS_RECEIVED				(M3GEV_BASE | 0x17)	
#define M3GEV_CST							(M3GEV_BASE | 0x18)	
#define M3GEV_CST_EX						(M3GEV_BASE | 0x1b)	
#define M3GEV_SEND_DIGITS_CMPLT				(M3GEV_BASE | 0x19)	
#define M3GEV_SEND_DIGITS_FAIL				(M3GEV_BASE | 0x1a)	
#define M3GEV_IPCONNECT_CMPLT				(M3GEV_BASE | 0x1c)
#define M3GEV_IPCONNECT_FAIL				(M3GEV_BASE | 0x1d)
#define M3GEV_IPDISCONNECT_CMPLT			(M3GEV_BASE | 0x1e)
#define M3GEV_IPDISCONNECT_FAIL				(M3GEV_BASE | 0x1f)

#define M3GEV_RECV_324M_VENDORID			(M3GEV_BASE | 0x30)
#define M3GEV_SEND_IFRAME_CMPLT				(M3GEV_BASE | 0x31)
#define M3GEV_SEND_IFRAME_FAIL				(M3GEV_BASE | 0x32)
#define M3GEV_ADJVOL_CMPLT					(M3GEV_BASE | 0x33)
#define M3GEV_ADJVOL_FAIL					(M3GEV_BASE | 0x34)
#define M3GEV_STOP_DIAL_CMPLT				(M3GEV_BASE | 0x35)
#define M3GEV_STOP_DIAL_FAIL				(M3GEV_BASE | 0x36)

#define M3GEV_START_H245_CMPLT				(M3GEV_BASE | 0x50)
#define M3GEV_START_H245_FAIL				(M3GEV_BASE | 0x51)
#define M3GEV_STOP_H245_CMPLT				(M3GEV_BASE | 0x52)
#define M3GEV_STOP_H245_FAIL				(M3GEV_BASE | 0x53)
#define M3GEV_GET_CALL_STATUS_CMPLT			(M3GEV_BASE | 0x54)
#define M3GEV_GET_CALL_STATUS_FAIL			(M3GEV_BASE | 0x55)
#define M3GEV_CALL_STATUS					(M3GEV_BASE | 0x56)
#define M3GEV_GET_MSDINFO_CMPLT				(M3GEV_BASE | 0x57)	
#define M3GEV_GET_MSDINFO_FAIL				(M3GEV_BASE | 0x58)	
#define	M3GEV_MSDINFO_STATUS				(M3GEV_BASE | 0x59)	
#define M3GEV_TCSINFO_STATUS				(M3GEV_BASE | 0x5a)	
#define M3GEV_GET_TERM_CAPS_CMPLT			(M3GEV_BASE | 0x5b)	
#define M3GEV_GET_TERM_CAPS_FAIL			(M3GEV_BASE | 0x5c)	
#define M3GEV_LCINFO_STATUS					(M3GEV_BASE | 0x5d)	
#define M3GEV_GET_LC_PARM_CMPLT				(M3GEV_BASE | 0x5e)	
#define M3GEV_GET_LC_PARM_FAIL				(M3GEV_BASE | 0x5f)	
#define M3GEV_SEND_H245_MISC_CMD_CMPLT		(M3GEV_BASE | 0x60)	
#define M3GEV_SEND_H245_MISC_CMD_FAIL		(M3GEV_BASE | 0x61)	
#define M3GEV_RECV_H245_MISC_CMD			(M3GEV_BASE | 0x62)	

#define M3GEV_DOWNLOADFONT_CMPLT			(M3GEV_BASE | 0x63)	
#define M3GEV_DOWNLOADFONT_FAIL				(M3GEV_BASE | 0x64)	
#define M3GEV_CTRLTOOLBOX_CMPLT				(M3GEV_BASE | 0x65)	
#define M3GEV_CTRLTOOLBOX_FAIL				(M3GEV_BASE | 0x66)	
#define M3GEV_DOWNLOADLOGO_CMPLT			(M3GEV_BASE | 0x67)	
#define M3GEV_DOWNLOADLOGO_FAIL				(M3GEV_BASE | 0x68)	
#define M3GEV_SETLOGOPARM_CMPLT				(M3GEV_BASE | 0x69)	
#define M3GEV_SETLOGOPARM_FAIL				(M3GEV_BASE | 0x6a)	
#define M3GEV_STARTTEXTOVERLAY_CMPLT		(M3GEV_BASE | 0x6b)	
#define M3GEV_STARTTEXTOVERLAY_FAIL			(M3GEV_BASE | 0x6c)	
#define M3GEV_STOPTEXTOVERLAY_CMPLT			(M3GEV_BASE | 0x6d)	
#define M3GEV_STOPTEXTOVERLAY_FAIL			(M3GEV_BASE | 0x6e)	
#define M3GEV_SETTEXTOVERLAYPARM_CMPLT		(M3GEV_BASE | 0x6f)	
#define M3GEV_SETTEXTOVERLAYPARM_FAIL		(M3GEV_BASE | 0x70)	
#define M3GEV_GETTEXTOVERLAYPARM_CMPLT		(M3GEV_BASE | 0x71)	
#define M3GEV_GETTEXTOVERLAYPARM_FAIL		(M3GEV_BASE | 0x72)	

#define M3GEV_ESTVIDEOCONF_CMPLT			(M3GEV_BASE | 0x73)	
#define M3GEV_ESTVIDEOCONF_FAIL				(M3GEV_BASE | 0x74)	
#define M3GEV_DELVIDEOCONF_CMPLT			(M3GEV_BASE | 0x75)	
#define M3GEV_DELVIDEOCONF_FAIL				(M3GEV_BASE | 0x76)	
#define M3GEV_ADDTOVIDEOCONF_CMPLT			(M3GEV_BASE | 0x77)	
#define M3GEV_ADDTOVIDEOCONF_FAIL			(M3GEV_BASE | 0x78)	
#define M3GEV_REMFROMVIDEOCONF_CMPLT		(M3GEV_BASE | 0x79)	
#define M3GEV_REMFROMVIDEOCONF_FAIL			(M3GEV_BASE | 0x7a)	
#define M3GEV_SETVIDEOCONFCDE_CMPLT			(M3GEV_BASE | 0x7b)	
#define M3GEV_SETVIDEOCONFCDE_FAIL			(M3GEV_BASE | 0x7c)	
#define M3GEV_CREATEVIDEOCONFMIXER_CMPLT	(M3GEV_BASE | 0x7d)	
#define M3GEV_CREATEVIDEOCONFMIXER_FAIL		(M3GEV_BASE | 0x7e)	
#define M3GEV_SETVIDEOCONFMIXER_CMPLT		(M3GEV_BASE | 0x7f)	
#define M3GEV_SETVIDEOCONFMIXER_FAIL		(M3GEV_BASE | 0x80)	
#define M3GEV_DESTROYVIDEOCONFMIXER_CMPLT	(M3GEV_BASE | 0x81)	
#define M3GEV_DESTROYVIDEOCONFMIXER_FAIL	(M3GEV_BASE | 0x82)	
#define M3GEV_CTRLFOREGROUND_CMPLT			(M3GEV_BASE | 0x83)	
#define M3GEV_CTRLFOREGROUND_FAIL			(M3GEV_BASE | 0x84)	
#define M3GEV_CTRLBACKGROUND_CMPLT			(M3GEV_BASE | 0x85)	
#define M3GEV_CTRLBACKGROUND_FAIL			(M3GEV_BASE | 0x86)	
#define M3GEV_DRAWBOX_CMPLT					(M3GEV_BASE | 0x87)	
#define M3GEV_DRAWBOX_FAIL					(M3GEV_BASE | 0x88)	

#define M3GEV_ESTVOICECONF_CMPLT			(M3GEV_BASE | 0x90)	
#define M3GEV_ESTVOICECONF_FAIL				(M3GEV_BASE | 0x91)	
#define M3GEV_DELVOICECONF_CMPLT			(M3GEV_BASE | 0x92)	
#define M3GEV_DELVOICECONF_FAIL				(M3GEV_BASE | 0x93)	
#define M3GEV_ADDTOVOICECONF_CMPLT			(M3GEV_BASE | 0x94)	
#define M3GEV_ADDTOVOICECONF_FAIL			(M3GEV_BASE | 0x95)	
#define M3GEV_REMFROMVOICECONF_CMPLT		(M3GEV_BASE | 0x96)	
#define M3GEV_REMFROMVOICECONF_FAIL			(M3GEV_BASE | 0x97)	
#define M3GEV_SETVOICECONFCDE_CMPLT			(M3GEV_BASE | 0x98)	
#define M3GEV_SETVOICECONFCDE_FAIL			(M3GEV_BASE | 0x99)	


#endif

/*
 - Action values for ag_SetEvtMsk() function
*/
#define M3GACT_SETMSK   0      /* set all mask bits & clear all others */
#define M3GACT_ADDMSK   1      /* set all mask bits & ignore all others */
#define M3GACT_SUBMSK   2      /* clr all mask bits & ignore all others */

/*
 - Message mask and event equates
 */
#define M3GMM_DIGITS_RECEIVED   0x0001      /* Mask for channel digits received */
#define M3GMM_CST				0x0002		/* Mask for CST received */
/*
- mode for ISX_m3g_PauseCh or ISX_m3g_ResumeCh
*/
#define EV_RESUMEPLAY	EV_BIT_03	
#define EV_RESUMEREC	EV_BIT_04
#define EV_PAUSEPLAY	EV_BIT_05	
#define EV_PAUSEREC		EV_BIT_06

/*
- eM3G_CHAN_TYPE constants defined the M3G channel types. 
*/
#ifndef MAX_M3G_CHAN_TYPE
#define MAX_M3G_CHAN_TYPE			19
typedef enum {
	M3G_CHAN_TYPE_VOICE				= 4, /* The channel is a voice channel			*/	
	M3G_CHAN_TYPE_VOICECONF			= 7, /* The channel is a voice conferencing channel */
	M3G_CHAN_TYPE_VIDEO				= 9, /* The channel is an video channel			*/	
	M3G_CHAN_TYPE_VIDEOCONF			= 17,/* The channel is an video conferencing channel */
	M3G_CHAN_TYPE_H324M				= 18,/* The channel is an 3G-324M channel		*/
	M3G_CHAN_TYPE_AUDIO				= 20,/* The channel is an Audio channel */
}eM3G_CHAN_TYPE;
#endif

/*
- eM3G_LC_NUMBER constants defined the H324M logical channel number. 
*/
#ifndef MAX_H324M_LC_NUM
#define MAX_H324M_LC_NUM			4
typedef enum {
	M3G_LC_VIDEO_OUTPUT				= 0, /* video output logical channel */
	M3G_LC_VOICE_OUTPUT				= 1, /* voice output logical channel */	
	M3G_LC_VIDEO_INPUT				= 2, /* video input logical channel */
	M3G_LC_VOICE_INPUT				= 3, /* voice input logical channel */
}eM3G_LC_NUMBER;
#endif

/*
- eM3G_VOICE_MODE constants defined the mode of voice channel. 
*/
#ifndef MAX_M3G_VOICE_MODE
#define MAX_M3G_VOICE_MODE				11
typedef enum {
	M3G_VOICE_MODE_VOIP					= 0,	/* Voice channel mode: TDM<->IP conversion */
	M3G_VOICE_MODE_P2P					= 1,	/* Voice channel mode: voice transcoding */
	M3G_VOICE_MODE_FE_IP				= 2,	/* Front End IP - for conference */
	M3G_VOICE_MODE_FE_TDM				= 3,	/* Front End TDM - for conference */
	M3G_VOICE_MODE_RTC					= 4,	/* Run To Completion */
	M3G_VOICE_MODE_PTH223				= 5,	/* Packet to H.223 channel */
	M3G_VOICE_MODE_RX_ONLY				= 6,	/* The TX path is disabled */
	M3G_VOICE_MODE_EVD_EVG				= 7,	/* Only EVent Detector and EVent Generator are enabled */
	M3G_VOICE_MODE_FE_IP_NO_VAD			= 8,	/* Front End IP without VAD - for 3\4 way conference */
	M3G_VOICE_MODE_FE_TDM_NO_VAD		= 9, 	/* Front End TDM without VAD - for 3\4 way conference */
	M3G_VOICE_MODE_MOIP_RFC2833_ONLY	= 10,	/* The IP TX side send only RFC2833 packet (not voice) */
	MAX_M3G_VOICE_MODES
}eM3G_VOICE_MODE;
#endif

/*
- eM3G_VOICE_CODER constants defined the voice coder type.
Note: Except that the packet duration of M3G_VOCODER_ILBC_30MS is 30ms, the others are 20ms.
*/
#ifndef MAX_M3G_VOICE_CODER
#define MAX_M3G_VOICE_CODER			61
typedef enum {
	M3G_VOCODER_G711A				= 0,		/* G.711 A-law protocol	*/
	M3G_VOCODER_G711MU				= 1,		/* G.711 Mu-law protocol */
	M3G_VOCODER_G723_1H_30MS		= 3,		/* G.723.1 High rate protocol (6.3Kbit/s) */
	M3G_VOCODER_G723_1L_30MS		= 4,		/* G.723.1 Low rate protocol (5.3Kbit/s) */
	M3G_VOCODER_G726_40				= 6,		/* G.726 protocol at 40Kbit/s */
	M3G_VOCODER_G726_32				= 7,		/* G.726 protocol at 32Kbit/s */
	M3G_VOCODER_G726_24				= 8,		/* G.726 protocol at 24Kbit/s */
	M3G_VOCODER_G726_16				= 9,		/* G.726 protocol at 16Kbit/s */
	M3G_VOCODER_G729_AB				= 16,		/* G.729.Annex A + Annex B protocol */
	M3G_VOCODER_GSM_FR				= 17,		/* GSM Full Rate */
	M3G_VOCODER_GSM_EFR				= 18,		/* GSM Enhanced Full Rate */
	M3G_VOCODER_GSM_AMR475_BE		= 19,		/* GSM AMR 4.75Kbit/s Bandwidth Efficient packing */
	M3G_VOCODER_GSM_AMR515_BE		= 20,		/* GSM AMR 5.15Kbit/s Bandwidth Efficient packing */
	M3G_VOCODER_GSM_AMR59_BE		= 21,		/* GSM AMR 5.9Kbit/s Bandwidth Efficient packing */
	M3G_VOCODER_GSM_AMR67_BE		= 22,		/* GSM AMR 6.7Kbit/s Bandwidth Efficient packing */
	M3G_VOCODER_GSM_AMR74_BE		= 23,		/* GSM AMR 7.4Kbit/s Bandwidth Efficient packing */
	M3G_VOCODER_GSM_AMR795_BE		= 24,		/* GSM AMR 7.95Kbit/s Bandwidth Efficient packing */
	M3G_VOCODER_GSM_AMR102_BE		= 25,		/* GSM AMR 10.2Kbit/s Bandwidth Efficient packing */
	M3G_VOCODER_GSM_AMR122_BE		= 26,		/* GSM AMR 12.2Kbit/s Bandwidth Efficient packing */
	M3G_VOCODER_GSM_AMR475_OA		= 27,		/* GSM AMR 4.75Kbit/s Octet Aligned packing */
	M3G_VOCODER_GSM_AMR515_OA		= 28,		/* GSM AMR 5.15Kbit/s Octet Aligned packing */
	M3G_VOCODER_GSM_AMR59_OA		= 29,		/* GSM AMR 5.9Kbit/s Octet Aligned packing */
	M3G_VOCODER_GSM_AMR67_OA		= 30,		/* GSM AMR 6.7Kbit/s Octet Aligned packing */
	M3G_VOCODER_GSM_AMR74_OA		= 31,		/* GSM AMR 7.4Kbit/s Octet Aligned packing */
	M3G_VOCODER_GSM_AMR795_OA		= 32,		/* GSM AMR 7.95Kbit/s Octet Aligned packing */
	M3G_VOCODER_GSM_AMR102_OA		= 33,		/* GSM AMR 10.2Kbit/s Octet Aligned packing */
	M3G_VOCODER_GSM_AMR122_OA		= 34,		/* GSM AMR 12.2Kbit/s Octet Aligned packing */
	M3G_VOCODER_LINEAR				= 35,		/* Linear (16bit) samples */
	M3G_VOCODER_CLEAR				= 36,		/* Clear Mu/A-law channel */
	M3G_VOCODER_FULL_EVRC_HFF		= 37,		/* EVRC Full Rate (9.6Kbit/s) Header Free Format (A.K.A evrc0) */
	M3G_VOCODER_HALF_EVRC_HFF		= 38,		/* EVRC Half Rate (4.8Kbit/s) Header Free Format (A.K.A evrc0) */
	M3G_VOCODER_FULL_EVRC_BF		= 39,		/* EVRC Full Rate (9.6Kbit/s) Bundled Format */
	M3G_VOCODER_HALF_EVRC_BF		= 40,		/* EVRC Half Rate (4.8Kbit/s) Bundled Format */
	M3G_VOCODER_GSM_WB_AMR66_BE		= 41,		/* WB-AMR 6.6Kbit/s Bandwidth Efficient packing */
	M3G_VOCODER_GSM_WB_AMR885_BE	= 42,		/* WB-AMR 8.85Kbit/s Bandwidth Efficient packing */
	M3G_VOCODER_GSM_WB_AMR1265_BE	= 43,		/* WB-AMR 12.65Kbit/s Bandwidth Efficient packing */
	M3G_VOCODER_GSM_WB_AMR1425_BE	= 44,		/* WB-AMR 14.25Kbit/s Bandwidth Efficient packing */
	M3G_VOCODER_GSM_WB_AMR1585_BE	= 45,		/* WB-AMR 15.85Kbit/s Bandwidth Efficient packing */
	M3G_VOCODER_GSM_WB_AMR1825_BE	= 46,		/* WB-AMR 18.25Kbit/s Bandwidth Efficient packing */
	M3G_VOCODER_GSM_WB_AMR1985_BE	= 47,		/* WB-AMR 19.85Kbit/s Bandwidth Efficient packing */
	M3G_VOCODER_GSM_WB_AMR2305_BE	= 48,		/* WB-AMR 23.05Kbit/s Bandwidth Efficient packing */
	M3G_VOCODER_GSM_WB_AMR2385_BE	= 49,		/* WB-AMR 23.85Kbit/s Bandwidth Efficient packing */
	M3G_VOCODER_GSM_WB_AMR66_OA		= 50,		/* WB-AMR 6.6Kbit/s Octet Aligned packing */
	M3G_VOCODER_GSM_WB_AMR885_OA	= 51,		/* WB-AMR 8.85Kbit/s Octet Aligned packing */
	M3G_VOCODER_GSM_WB_AMR1265_OA	= 52,		/* WB-AMR 12.65Kbit/s Octet Aligned packing */
	M3G_VOCODER_GSM_WB_AMR1425_OA	= 53,		/* WB-AMR 14.25Kbit/s Octet Aligned packing */
	M3G_VOCODER_GSM_WB_AMR1585_OA	= 54,		/* WB-AMR 15.85Kbit/s Octet Aligned packing */
	M3G_VOCODER_GSM_WB_AMR1825_OA	= 55,		/* WB-AMR 18.25Kbit/s Octet Aligned packing */
	M3G_VOCODER_GSM_WB_AMR1985_OA	= 56,		/* WB-AMR 19.85Kbit/s Octet Aligned packing */
	M3G_VOCODER_GSM_WB_AMR2305_OA	= 57,		/* WB-AMR 23.05Kbit/s Octet Aligned packing */
	M3G_VOCODER_GSM_WB_AMR2385_OA	= 58,		/* WB-AMR 23.85Kbit/s Octet Aligned packing */
	M3G_VOCODER_ILBC_20MS			= 59,		/* iLBC 20ms frames (15.2Kbit/s) */
	M3G_VOCODER_ILBC_30MS			= 60,		/* iLBC 30ms frames (13.3Kbit/s) */ 
}eM3G_VOICE_CODER;

#ifndef _UNDEFINE_g_SipSdpRtpMapForM3gVoice
static ISXSIP_IE_SDP_RTP_MAP g_SipSdpRtpMapForM3gVoice[]=
{
	{8,		8000,	"PCMA",						"1"},	//0
	{0,		8000,	"PCMU",						"1"},	//1
	/*---------------------------------------------*/
	{100,	8000,	"Unassigned",				"1"},	//2
	/*---------------------------------------------*/
	{39,	8000,	"G723-6.3K",				"1"},	//3
	{4,		8000,	"G723-5.3K",				"1"},	//4
	/*---------------------------------------------*/
	{36,	8000,	"Unassigned",				"1"},	//5
	/*---------------------------------------------*/
	{38,	8000,	"G726-40K",					"1"},	//6
	{2,		8000,	"G726-32K",					"1"},	//7
	{36,	8000,	"G726-24K",					"1"},	//8
	{35,	8000,	"G726-16K",					"1"},	//9
	/*---------------------------------------------*/
	{140,	8000,	"Unassigned",				"1"},	//10
	{141,	8000,	"Unassigned",				"1"},	//11
	{142,	8000,	"Unassigned",				"1"},	//12
	{143,	8000,	"Unassigned",				"1"},	//13
	{144,	8000,	"Unassigned",				"1"},	//14
	{145,	8000,	"Unassigned",				"1"},	//15
	/*---------------------------------------------*/
	{18,	8000,	"G729",						"1"},	//16
	/*---------------------------------------------*/
	{3,		8000,	"GSM-FR",					"1"},	//17
	{40,	8000,	"GSM-EFR",					"1"},	//18
	{41,	8000,	"GSM-AMR4.75K-BE",			"1"},	//19
	{42,	8000,	"GSM-AMR5.15K-BE",			"1"},	//20
	{43,	8000,	"GSM-AMR5.9K-BE",			"1"},	//21
	{44,	8000,	"GSM-AMR6.7K-BE",			"1"},	//22
	{45,	8000,	"GSM-AMR7.4K-BE",			"1"},	//23
	{46,	8000,	"GSM-AMR7.95K-BE",			"1"},	//24
	{47,	8000,	"GSM-AMR10.2K-BE",			"1"},	//25
	{48,	8000,	"GSM-AMR12.2K-BE",			"1"},	//26
	{49,	8000,	"GSM-AMR4.75K-OA",			"1"},	//27
	{50,	8000,	"GSM-AMR5.15K-OA",			"1"},	//28
	{51,	8000,	"GSM-AMR5.9K-OA",			"1"},	//29
	{52,	8000,	"GSM-AMR6.7K-OA",			"1"},	//30
	{53,	8000,	"GSM-AMR7.4K-OA",			"1"},	//31
	{54,	8000,	"GSM-AMR7.95K-OA",			"1"},	//32
	{55,	8000,	"GSM-AMR10.2K-OA",			"1"},	//33
	{56,	8000,	"GSM-AMR12.2K-OA",			"1"},	//34
	/*---------------------------------------------*/
	{10,	44100,	"Linear16bit",				"1"},	//35
	{57,	8000,	"ClearMuAlawCH",			"1"},	//36
	/*---------------------------------------------*/
	{58,	8000,	"EVRC9.6K-HFF",				"1"},	//37
	{59,	8000,	"EVRC4.8K-HFF",				"1"},	//38
	{60,	8000,	"EVRC9.6K-BF",				"1"},	//39
	{61,	8000,	"EVRC4.8K-BF",				"1"},	//40
	/*---------------------------------------------*/
	{62,	8000,	"WB-AMR6.6K-BE",			"1"},	//41
	{63,	8000,	"WB-AMR8.85K-BE",			"1"},	//42
	{64,	8000,	"WB-AMR12.65K-BE",			"1"},	//43
	{65,	8000,	"WB-AMR14.25K-BE",			"1"},	//44
	{66,	8000,	"WB-AMR15.85K-BE",			"1"},	//45
	{67,	8000,	"WB-AMR18.25K-BE",			"1"},	//46
	{68,	8000,	"WB-AMR19.85K-BE",			"1"},	//47
	{69,	8000,	"WB-AMR23.05K-BE",			"1"},	//48
	{70,	8000,	"WB-AMR23.85K-BE",			"1"},	//49
	{71,	8000,	"WB-AMR6.6K-OA",			"1"},	//50
	{72,	8000,	"WB-AMR8.85K-OA",			"1"},	//51
	{73,	8000,	"WB-AMR12.65K-OA",			"1"},	//52
	{74,	8000,	"WB-AMR14.25K-OA",			"1"},	//53
	{75,	8000,	"WB-AMR15.85K-OA",			"1"},	//54
	{76,	8000,	"WB-AMR18.25K-OA",			"1"},	//55
	{77,	8000,	"WB-AMR19.85K-OA",			"1"},	//56
	{78,	8000,	"WB-AMR23.05K-OA",			"1"},	//57
	{79,	8000,	"WB-AMR23.85K-OA",			"1"},	//58
	/*---------------------------------------------*/
	{80,	8000,	"iLBC-15.2K",				"1"},	//59
	{98,	8000,	"iLBC-13.3K",				"1"}	//60
};
#endif
#endif

/*
- eM3G_VIDEO_RTP_PAYLOAD constants the encapsulation type of RTP compressed video data.
*/
#ifndef MAX_M3G_VIDEO_RTP_PAYLOAD_ENCAP
#define MAX_M3G_VIDEO_RTP_PAYLOAD_ENCAP				 33
typedef enum {
	M3G_VIDEO_RTP_PAYLOAD_ENCAP_RFC2190				= 0,	/* Video data is H.263 and RFC 2190 */
	M3G_VIDEO_RTP_PAYLOAD_ENCAP_NONE				= 1,	/* No additional encapuslation RFC is supported */
	M3G_VIDEO_RTP_PAYLOAD_ENCAP_RFC2429				= 2,	/* The compressed video data is H.263 (used for MPEG4). RFC 2429 and RFC4629 are both supported. */
	M3G_VIDEO_RTP_PAYLOAD_ENCAP_RFC3984				= 3,	/* The compressed video data is H.264 and RFC 3984 is supported. */
	M3G_VIDEO_RTP_PAYLOAD_ENCAP_RFC2190_MODE_B_ONLY = 20,	/* The compressed video data is H.263 and RFC 2190 mode B will be used. */
	M3G_VIDEO_RTP_PAYLOAD_ENCAP_RFC2190_MODE_A_ONLY = 21,	/* The compressed video data is H.263 and RFC 2190 mode A will be used. */
	M3G_VIDEO_RTP_PAYLOAD_ENCAP_RFC3984_MODE_1		= 30,	/* The compressed video data is H.264 and RFC 3984 mode 1 will be used. */
	M3G_VIDEO_RTP_PAYLOAD_ENCAP_RFC3984_STAP_A_ONLY = 31,	/* The compressed video data is H.264 and RFC 3984 STAP A will be used. */
	M3G_VIDEO_RTP_PAYLOAD_ENCAP_RFC3984_FU_A_ONLY	= 32,	/* The compressed video data is H.264 and RFC 3984 FU A will be used. */
}eM3G_VIDEO_RTP_PAYLOAD_ENCAP;
#endif

/*
- eM3G_VIDEO_CODER constants defined the video coding standard.
*/
#ifndef MAX_M3G_VIDEO_CODER
#define MAX_M3G_VIDEO_CODER		5
typedef enum {
	M3G_VICODER_MPEG4		= 0,	/* Mpeg4 video encoding standard */
	M3G_VICODER_H263		= 1,	/* H.263 video encoding standard, use M3G_VIDEO_RTP_PAYLOAD_ENCAP_RFC2190 */
	M3G_VICODER_H264		= 2,	/* H.264 video encoding standard */
	M3G_VICODER_WMV9		= 3,	/* WMV video encoding standard */
	M3G_VICODER_H263_PLUS	= 4,	/* H.263+ video encoding standard, use M3G_VIDEO_RTP_PAYLOAD_ENCAP_RFC2429 */
}eM3G_VIDEO_CODER;

#ifndef _UNDEFINE_g_SipSdpRtpMapForM3gVideo
static ISXSIP_IE_SDP_RTP_MAP g_SipSdpRtpMapForM3gVideo[]=
{
	{110,	90000,	"MPEG4",	"1"},	//0
	{34,	90000,	"H263",		"1"},	//1: 34
	{123,	90000,	"H264",		"1"},	//2: 123 or 124
	{112,	90000,	"WMV9",		"1"},	//3
	{115,	90000,	"H263+",	"1"},	//4: 115
};
#endif
#endif

/*
* M3G_VIDEO_ENCODER->ProfileLevel:篇撞儿抹議Profile才Level
*/
#ifndef MAX_M3G_VIDEO_MPEG4_SIMPLE_PROFILE_LEVEL
#define MAX_M3G_VIDEO_MPEG4_SIMPLE_PROFILE_LEVEL	52
typedef enum {
	M3G_VIDEO_MPEG4_SIMPLE_PROFILE_LEVEL0	= 0,	/* MPEG4 Video profile: simple profile, level 0 */
	M3G_VIDEO_MPEG4_SIMPLE_PROFILE_LEVEL1	= 1,	/* MPEG4 Video profile: simple profile, level 1 */
	M3G_VIDEO_MPEG4_SIMPLE_PROFILE_LEVEL2	= 2,	/* MPEG4 Video profile: simple profile, level 2 */
	M3G_VIDEO_MPEG4_SIMPLE_PROFILE_LEVEL3	= 3,	/* MPEG4 Video profile: simple profile, level 3 */
	M3G_VIDEO_H264_BASELINE_PROFILE_LEVEL1B = 9,	/* H.264 video profile: Baselineprofile, level 1B */
	M3G_VIDEO_H264_BASELINE_PROFILE_LEVEL10 = 10,	/* H.264 video profile:Baseline profile, level 10*/
	M3G_VIDEO_H264_BASELINE_PROFILE_LEVEL11 = 11,	/* H.264 video profile:Baseline profile, level 11 */
	M3G_VIDEO_H264_BASELINE_PROFILE_LEVEL12 = 12,	/* H.264 video profile:Baseline profile, level 12 */
	M3G_VIDEO_H264_BASELINE_PROFILE_LEVEL13 = 13,	/* H.264 video profile:Baseline profile, level 13 */
	M3G_VIDEO_H264_BASELINE_PROFILE_LEVEL20 = 20,	/* H.264 video profile:Baseline profile, level 20 */
	M3G_VIDEO_H264_BASELINE_PROFILE_LEVEL21 = 21,	/* H.264 video profile:Baseline profile, level 21 */
	M3G_VIDEO_H264_BASELINE_PROFILE_LEVEL22 = 22,	/* H.264 video profile:Baseline profile, level 22 */
	M3G_VIDEO_H264_BASELINE_PROFILE_LEVEL30 = 30,	/* H.264 video profile:Baseline profile, level 30 */
	M3G_VIDEO_H264_BASELINE_PROFILE_LEVEL31 = 31,	/* H.264 video profile:Baseline profile, level 31 */
	M3G_VIDEO_H264_BASELINE_PROFILE_LEVEL32 = 32,	/* H.264 video profile:Baseline profile, level 32 */
	M3G_VIDEO_H264_BASELINE_PROFILE_LEVEL40 = 40,	/* H.264 video profile:Baseline profile, level 40 */
	M3G_VIDEO_H264_BASELINE_PROFILE_LEVEL41 = 41,	/* H.264 video profile:Baseline profile, level 41 */
	M3G_VIDEO_H264_BASELINE_PROFILE_LEVEL42 = 42,	/* H.264 video profile:Baseline profile, level 42 */
	M3G_VIDEO_H264_BASELINE_PROFILE_LEVEL50 = 50,	/* H.264 video profile:Baseline profile, level 50 */
	M3G_VIDEO_H264_BASELINE_PROFILE_LEVEL51 = 51,	/* H.264 video profile:Baseline profile, level 51 */
}eM3G_VIDEO_MPEG4_SIMPLE_PROFILE_LEVEL;
#endif

/*
- eM3G_H324_AUDIO_CODEC constants defined the supported audio coding type of H324M, and One terminal 
can simultaneously support 4 different audio codecs.
*/
#ifndef MAX_M3G_H324_AUDIO_CODEC
#define MAX_M3G_H324_AUDIO_CODEC  3
typedef enum {
	M3G_H324_AUDIO_CODEC_NONE	= 0,	/* Defines no audio codec */
	M3G_H324_AUDIO_CODEC_AMR	= 1,	/* Defines AMR-NB audio codec */
	M3G_H324_AUDIO_CODEC_G723	= 2,	/* Defines G.723.1 audio codec */
}eM3G_H324_AUDIO_CODEC;
#endif

/*
- eM3G_H324_VIDEO_CODEC constants defined the supported video coding type of H324M, and one terminal 
can simultaneously support 4 different video codecs.
*/
#ifndef MAX_M3G_H324_VIDEO_CODEC
#define MAX_M3G_H324_VIDEO_CODEC  3
typedef enum {
	M3G_H324_VIDEO_CODEC_NONE	= 0,	/* Defines no video codec */
	M3G_H324_VIDEO_CODEC_MPEG4	= 1, /* Defines MPEG-4 video codec */
	M3G_H324_VIDEO_CODEC_H263	= 2,	/* Defines H.263 video codec */
}eM3G_H324_VIDEO_CODEC;
#endif

/*
- eM3G_FILE_TYPE constants defined the supported file format of audio/video files.
*/
#ifndef MAX_M3G_FILE_TYPE
#define MAX_M3G_FILE_TYPE	8
typedef enum {
	M3G_FILE_TYPE_BIN = 1,  /* Binary file format */
	M3G_FILE_TYPE_WAV = 2,	/* WAV file format */
	M3G_FILE_TYPE_3GP = 3,	/* 3GP file format */
	M3G_FILE_TYPE_MP4 = 4,	/* MPEG4 file format */
	M3G_FILE_TYPE_AVI = 5,	/* AVI file */
	M3G_FILE_TYPE_ASF = 6,	/* ASF file format */
	M3G_FILE_TYPE_3G2 = 7,	/* 3G2 file format */
	M3G_FILE_TYPE_AMR = 200,/* AMR file format and CoderType must be AMR type */
}eM3G_FILE_TYPE;
#endif

#ifndef MAX_M3G_WAV_BLOCK_SIZE
#define MAX_M3G_WAV_BLOCK_SIZE	 6
typedef enum {
	M3G_WAV_BLOCK_SIZE_5MS		=0,
	M3G_WAV_BLOCK_SIZE_10MS		=1,
	M3G_WAV_BLOCK_SIZE_20MS		=3,
	M3G_WAV_BLOCK_SIZE_30MS		=5,
}eM3G_WAV_BLOCK_SIZE;
#endif

/*
- eM3G_SAMPLE_TYPE constants defined the media sample type of the non-WAV 
file type (eM3G_FILE_TYPE) , such as BIN/3GP/MP4/AVI/ASF/3G2 type.
*/
#ifndef MAX_M3G_SAMPLE_TYPE
#define MAX_M3G_SAMPLE_TYPE			30
typedef enum {
	M3G_SAMPLE_TYPE_AAC				= 1,	/* AAC Audio codec - currently is not supported */
	M3G_SAMPLE_TYPE_AAC_PLUS		= 2,	/* AAC Plus Audio codec - currently is not supported */
	M3G_SAMPLE_TYPE_AMR_NB			= 3,	/* Narrow-band AMR voice codec */
	M3G_SAMPLE_TYPE_AMR_WB			= 4,	/* Wide-band AMR voice codec */
	M3G_SAMPLE_TYPE_G711_A_LAW		= 5,	/* G.711 a-law voice codec */
	M3G_SAMPLE_TYPE_G711_MU_LAW		= 6,	/* G.711 mu-law voice codec */
	M3G_SAMPLE_TYPE_G7231			= 7,	/* G.723 voice codec */
	M3G_SAMPLE_TYPE_G726_16			= 8,	/* G.726-16 voice codec */
	M3G_SAMPLE_TYPE_G728			= 9,	/* G.728 voice codec - currently is not supported */
	M3G_SAMPLE_TYPE_G729A			= 10,	/* G.729A voice codec */
	M3G_SAMPLE_TYPE_GSM_FR			= 11,	/* GSM-FR voice codec */
	M3G_SAMPLE_TYPE_GSM_EFR			= 12,	/* GSM-EFR voice codec */
	M3G_SAMPLE_TYPE_GSM_HR			= 13,	/* GSM-HR voice codec - currently is not supported */
	M3G_SAMPLE_TYPE_MPEG1_L2		= 14,	/* MPEG1-L2 audio codec - currently is not supported */
	M3G_SAMPLE_TYPE_PCM				= 15,	/* PCM - linear voice data */
	M3G_SAMPLE_TYPE_H263			= 16,	/* H.263 Video codec */
	M3G_SAMPLE_TYPE_H264			= 17,	/* H.264 Video codec */
	M3G_SAMPLE_TYPE_MPEG4			= 18,	/* MPEG-4 Video codec */
	M3G_SAMPLE_TYPE_YUV				= 19,	/* MPEG-4 Video codec */
	M3G_SAMPLE_TYPE_WMA				= 20,	/* WMA audio codec */
	M3G_SAMPLE_TYPE_WMV9			= 21,	/* WMV9 video codec */
	M3G_SAMPLE_TYPE_G726_24			= 22,	/* G.726-24 voice codec */
	M3G_SAMPLE_TYPE_G726_32			= 23,	/* G.726-32 voice codec */
	M3G_SAMPLE_TYPE_G726_40			= 24,	/* G.726-40 voice codec */
	M3G_SAMPLE_TYPE_WMA7			= 25,	/* WMA v.7 audio codec */
	M3G_SAMPLE_TYPE_WMA9			= 26,	/* WMA v.9 audio codec */
	M3G_SAMPLE_TYPE_WMAL			= 27,	/* WMA Losseless audio codec */
	M3G_SAMPLE_TYPE_G729D			= 28,	/* G.729D voice codec */
	M3G_SAMPLE_TYPE_G729E			= 29,	/* G.729E voice codec */
}eM3G_SAMPLE_TYPE;
#endif

/*
- eM3G_FILE_TIMING_SOURCE_SAMPLE constants defined the source of the timestamp of the non-WAV 
file type (eM3G_FILE_TYPE) ,such as BIN/3GP/MP4/AVI/ASF/3G2 type.
*/
#ifndef MAX_M3G_FILE_TIMING_SOURCE_SAMPLE
#define MAX_M3G_FILE_TIMING_SOURCE_SAMPLE		2
typedef enum {
	M3G_FILE_TIMING_SOURCE_SAMPLE_TIMESTAMPS	= 0,	/* timestamp from RTP */
	M3G_FILE_TIMING_SOURCE_SAMPLE_HEADERS		= 1,	/* timestamp from video head */
}eM3G_FILE_TIMING_SOURCE_SAMPLE;
#endif

/*
- eM3G_TCS_STATUS constants defined the status of TCS (Terminal Capability set) negotiation.
*/
#ifndef MAX_M3G_TCS_STATUS
#define MAX_M3G_TCS_STATUS				7
typedef enum {
	M3G_TCS_STATUS_NONE					= 0,	/* TCS initial status */
	M3G_TCS_STATUS_REQUEST				= 1,	/* Receive TCS request */
	M3G_TCS_STATUS_STARTED				= 2,	/* Send TCS */
	M3G_TCS_STATUS_RESOLVED				= 3,	/* Send TCS, and receive TCS of the other side */
	M3G_TCS_STATUS_RESOLVED_FINISHED	= 4,	/* TCS is completed and successful */
	M3G_TCS_STATUS_ERROR				= 5,	/* TCS is rejected or timeout */
	M3G_TCS_STATUS_IDLE					= 6,	/* Idle status */
}eM3G_TCS_STATUS;
#endif

/*
- eM3G_MISC_ID constants defined the command ID of Misc command.
*/
#ifndef MAX_M3G_MISC_ID
#define	MAX_M3G_MISC_ID		8
typedef enum {
	M3G_MISC_ID_VIDEO_FAST_UPDATE_PICTURE			= 0,
	M3G_MISC_ID_VIDEO_FAST_UPDATE_GOB				= 1,
	M3G_MISC_ID_VIDEO_FAST_UPDATE_MB				= 2,
	M3G_MISC_ID_VIDEO_SEND_SYNC_EVERY_GOB			= 3,
	M3G_MISC_ID_VIDEO_SEND_SYNC_EVERY_GOB_CANCEL	= 4,
	M3G_MISC_ID_VIDEO_FREEZE_PICTURE				= 5,
	M3G_MISC_ID_VIDEO_TEMPORAL_SPATIAL_TRADEOFF		= 6,
	M3G_MISC_ID_SKEW_INDICATION						= 7,
}eM3G_MISC_ID;
#endif

/*
- eM3G_LC_STATUS constants defined the status of LC (logical channel) negotiation of H324M.
*/
#ifndef MAX_M3G_LC_STATUS
#define MAX_M3G_LC_STATUS				7
typedef enum {
	M3G_LC_STATUS_CREATED				= 0,	/* LC intiated status */
	M3G_LC_STATUS_REQUEST				= 1,	/* Ready to send OLC request */
	M3G_LC_STATUS_STARTED				= 2,	/* Have sent OLC request */
	M3G_LC_STATUS_RESOLVED				= 3,	/* Receive OLC request of the other side */
	M3G_LC_STATUS_RESOLVED_FINISHED		= 4,	/* OLC is completed and successful */
	M3G_LC_STATUS_ERROR					= 5,	/* OLC is rejected or timeout */
	M3G_LC_STATUS_IDLE					= 6,	/* Idle status */
}eM3G_LC_STATUS;
#endif

/*
- eM3G_CP_STATUS constants defined the call progress status of H324M calls.
*/
#ifndef MAX_M3G_CP_STATUS
#define MAX_M3G_CP_STATUS		6
typedef enum {
	M3G_CP_STATUS_IDLE			= 0,	/* Call is in idle status*/
	M3G_CP_STATUS_INITIALIZING	= 1,	/* Call is started*/
	M3G_CP_STATUS_ACTIVING		= 2,	/* Link is established */
	M3G_CP_STATUS_ACTIVED		= 3,	/* MSD and TCS are completed*/
	M3G_CP_STATUS_DEACTIVING	= 4,	/* Call is stopped*/
	M3G_CP_STATUS_CLEAN_UP		= 5,	/* Call is cleared*/
}eM3G_CP_STATUS;
#endif

/*
- eM3G_H223_LINK_STATUS constants defined the H223 link status of H324M calls.
*/
#ifndef MAX_M3G_H223_LINK_STATUS
#define MAX_M3G_H223_LINK_STATUS		5
typedef enum {
	M3G_H223_LINK_STATUS_NONE			= 0,	/* Link initial status */
	M3G_H223_LINK_STATUS_SYNCHROZING	= 1,	/* Link is in synchronization */
	M3G_H223_LINK_STATUS_CONNECTED		= 2,	/* Link synchronization is successful */
	M3G_H223_LINK_STATUS_ERROR			= 3,	/* Link synchronization is unsuccessful*/
	M3G_H223_LINK_STATUS_IDLE			= 4,	/* Link idle status*/
}eM3G_H223_LINK_STATUS;
#endif

/*
- eM3G_MSD_STATUS constants defined the MSD status of MSD negotiation.
*/
#ifndef MAX_M3G_MSD_STATUS
#define MAX_M3G_MSD_STATUS				7
typedef enum {
	M3G_MSD_STATUS_NONE					= 0,	/* MSD initial status */
	M3G_MSD_STATUS_REQUEST				= 1,	/* Receive MSD request*/
	M3G_MSD_STATUS_STARTED				= 2,	/* Send MSD*/
	M3G_MSD_STATUS_RESOLVED				= 3,	/* MSD Send MSD, and receive MSD of the other side */
	M3G_MSD_STATUS_RESOLVED_FINISHED	= 4,	/* MSD is completed and successful*/
	M3G_MSD_STATUS_ERROR				= 5,	/* MSD is rejected or timeout*/
	M3G_MSD_STATUS_IDLE					= 6,	/* Idle status*/
}eM3G_MSD_STATUS;
#endif

/*
- eM3G_BRD_CONN_STATUS constants defined the connection status between the M3G board from M3GC server.
*/
#ifndef MAX_M3G_BRD_CONN_STATUS
#define	MAX_M3G_BRD_CONN_STATUS				4
typedef enum {
	M3G_BRD_CONN_STATUS_DEACTIVE			= 0,	/* Deactive status*/
	M3G_BRD_CONN_STATUS_ACTIVE_DISCONNED	= 1,	/* Active status+Disconned status*/
	M3G_BRD_CONN_STATUS_ACTIVE_CONNECTED	= 2,	/* Active status+Connected status */
	M3G_BRD_CONN_STATUS_DELETING			= 3     /* deleting status */
}eM3G_BRD_CONN_STATUS;
#endif

/*
- eM3G_DATA_DIR constants defined the data direction of playing/recording audio and video.
*/
#ifndef MAX_M3G_DATA_DIR
#define MAX_M3G_DATA_DIR	3
typedef enum
{
	M3G_DATA_DIR_AFTER_ENCODEC	= 0x00,				// After encoder
	M3G_DATA_DIR_BEFORE_DECODEC = 0x01,				//Before decoder
	M3G_DATA_DIR_TOIP	=	M3G_DATA_DIR_AFTER_ENCODEC,		//data to IP side, same as after encoder
	M3G_DATA_DIR_FROMIP	=	M3G_DATA_DIR_BEFORE_DECODEC,	//data from IP side, same as before decoder
	M3G_DATA_DIR_TDM	=	M3G_DATA_DIR_TOIP,		//Only for H324M channel
	M3G_DATA_DIR_IP		=	M3G_DATA_DIR_FROMIP		//Compatible with the old version
}eM3G_DATA_DIR;
#endif

/*
- eM3G_VIDEO_TRANSPORT_TYPE constants defined the video transport type.
*/
#ifndef MAX_M3G_VIDEO_TRANSPORT_TYPE
#define MAX_M3G_VIDEO_TRANSPORT_TYPE	 3
typedef enum 
{
	M3G_VIDEO_TRANSPORT_TYPE_STREAMING	= 0, /* Streaming files from host to dsp and vice versa
   												through a reliable (proprietary) socket connection */
	M3G_VIDEO_TRANSPORT_TYPE_IP			= 1, /* Ip packets through UDP socket connection */
	M3G_VIDEO_TRANSPORT_TYPE_H223		= 2  /* UDP packets from the H.223 channel */
}eM3G_VIDEO_TRANSPORT_TYPE;
#endif

/*
- eM3G_MEDIA_CHAN_OPMODE constants defined the operation type of media channel.
*/
#ifndef MAX_M3G_MEDIA_CHAN_OPMODE
#define MAX_M3G_MEDIA_CHAN_OPMODE	3
typedef enum {
	M3G_MEDIA_CHAN_OPMODE_NONE			= 0,	//no operation
	M3G_MEDIA_CHAN_OPMODE_PASS_THROUGH	= 1,	//pass through mode
	M3G_MEDIA_CHAN_OPMODE_TRANSCODE		= 2,	//transcode mode
}eM3G_MEDIA_CHAN_OPMODE;
#endif

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

/************************************************************************/
/* Voice type channel parameter                                         */
/************************************************************************/
typedef struct tagM3G_VOICE_CODER{
	UCHAR			ucValid;		//the structure valid flag
	UCHAR			ucVoCoder;		//voice encoder type
	UCHAR			ucPayloadType;	//Payload type
	UCHAR			ucCNG;			//CNG of the decoder;
	UCHAR			ucPLC;			//PLC of the decoder;
} M3G_VOICE_CODER; 

typedef struct tagM3G_VOICE_ATTR_CONFIG{
	M3G_VOICE_CODER					VoEnCoder;			//Encoder configuration
	M3G_VOICE_CODER					VoDeCoder;			//Decoder configuration
	VoiceConfig_PayloadSize			PayloadSize;		//Payload size
	VoiceConfig_SilenceSuppress		SilenceSuppress;	//Silence suppression
	VoiceConfig_EchoCancel			EchoCancel;			//Echo cancellation
	VoiceConfig_JitterBufferDelay	MinJitterBuffer;	//Minimum Jitter buffer delay
	VoiceConfig_JitterBufferDelay	MaxJitterBuffer;	//Maximum Jitter buffer delay
	VoiceConfig_AdaptationRate		AdaptationRate;		//Jitter buffer adaptation rate	
} M3G_VOICE_ATTR_CONFIG; 

typedef struct tagM3G_CHAN_TYPE_VOICE_PARAM{
	IpConfig_IP_addr		SrcIpAddr;			//source RTP IP address.
	IpConfig_UdpPort		SrcRtpPort;			//source RTP port.
	IpConfig_IP_addr		DstIpAddr;			//destination RTP IP address.
	IpConfig_UdpPort		DstRtpPort;			//destination RTP port.
	IpConfig_UdpPort		SrcRTCPPort;		//source RTCP port.
	IpConfig_UdpPort		DstRTCPPort;		//destination RTCP port.
	UCHAR					ucConnMode;			//Connection mode, Please refer to eCONN_MODE
	UCHAR					ucVoiceMode;		//Working mode of voice channel,Please refer to eM3G_VOICE_MODE
	M3G_VOICE_ATTR_CONFIG	VoiceCfg;			//Voice configuration
	DtmfConfig				DtmfCfg;			//DTMF configuration
} M3G_CHAN_TYPE_VOICE_PARAM;

/************************************************************************/
/* Video type channel parameter                                         */
/************************************************************************/
typedef struct tagM3G_VIDEO_RTP{
	UCHAR	ucRtpPayloadType;	//RTP payload type
	UINT	ulRtpPayloadEncap;	//Encapsulation type of RTP compressed video data, refer to eM3G_VIDEO_RTP_PAYLOAD_ENCAP 
	USHORT	usSrcUdpPort;		//RTP source port number			
} M3G_VIDEO_RTP;
		
typedef struct tagM3G_VIDEO_RTCP{
	UCHAR	ucValid;					//the structure valid flag
	USHORT	usSrcUdpPort;				//Source port number
	USHORT	usDstUdpPort;				//Destination port number
	CHAR	DstIpAddr[EHANG_MAX_IP_LEN];//Destination IP address
} M3G_VIDEO_RTCP; 

typedef struct tagM3G_VIDEO_INPUT{
	UCHAR			ucValid;		//the structure valid flag
	UCHAR			ucIsEnable;		//the video input module enable flag
	UCHAR			ucTransportType;//Please refer to eM3G_VIDEO_TRANSPORT_TYPE
	M3G_VIDEO_RTP	Rtp;			//RTP attributes
	M3G_VIDEO_RTCP	Rtcp;			//RTCP attributes
} M3G_VIDEO_INPUT; 

typedef struct tagM3G_VIDEO_DECODER{
	UCHAR	ucValid;				//the structure valid flag
	UCHAR	ucIsEnable;				//the decoder module enable flag
	UINT	ulCodingStandard;		//Coding standard, refer to eM3G_VIDEO_CODER
	UINT	ulInputHeight;			//Input height. range: 16~288, must be a multiple of 16.
	UINT	ulInputWidth;			//Input width. range: 16~352, must be a multiple of 16.
	UINT	ulOutputHeight;			//Output height (YUV). range: 48~576, must be a multiple of 16.
	UINT	ulOutputWidth;			//Output width (YUV). range: 48~720, must be a multiple of 16.
	UINT	ulFramesPerSec;			//FPS: frames per second. range: 4~30.
	UINT	ulDeblocking_smoth;		//Smoothness between blocks. range: 0~0x7FFF. 0 means that there is no such function.
	UINT	ulDeblocking_strength;	//Block boundary strength. range: 0~0x7FFF. 0 means that there is no such function.
	UINT	ulReferFrames;			//The maximum number of reference frames (reserved for H.264). range: 0~11.
} M3G_VIDEO_DECODER; 

typedef struct tagM3G_VIDEO_ENCODER{
	UCHAR	ucValid;				//the structure valid flag
	UCHAR	ucIsEnable;				//the decoder module enable flag
	UINT	ulCodingStandard;		//Coding standard, refer to eM3G_VIDEO_CODER
	UINT	ulProfileLevel;			//Please refer to eM3G_VIDEO_MPEG4_SIMPLE_PROFILE_LEVEL
	UINT	ulInputHeight;			//Input height (YUV). range: 16~576.
	UINT	ulInputWidth;			//Input width (YUV). range: 16~720.
	UINT	ulFramesPerSec;			//FPS: frames per second. range: 4~30.
	UINT	ulBitRate;				/* Compressed Bit rate. The following must be met:
									   If the output resolution is CIF or above, BitRate> = 8000 * FPS; 
	                                   otherwise, BitRate> = 2000 * FPS. (FPS: frames per second).*/
	UCHAR	ucIsVariableBitRate;	//Whether is the variable bit rate 0: no or 1: yes.
	UINT	ulVbrQualityMin;		//Quality minimum of VBR compression. range: 0~0x7FFF.
	UINT	ulVbrQualityMax;		//Quality maximum of VBR compression. range: 0~0x7FFF.
	UINT	ulIFrameFrequency;		//I frame frequency. Default value: 99.
} M3G_VIDEO_ENCODER; 

typedef struct tagM3G_VIDEO_DEST_ITEM{
	CHAR	DstIpAddr[EHANG_MAX_IP_LEN];		//RTP destination IP
	USHORT	usDstUdpPort;						//RTP destination UDP port
	CHAR	DstRtcpIpAddr[EHANG_MAX_IP_LEN];	//If there is no RTCP, it will be NULL string.
	USHORT	usDstRtcpUdpPort;					//If there is no RTCP, it will be 0.
} M3G_VIDEO_DEST_ITEM;

#define MAX_VIDEO_DEST_ITEM		16
typedef struct tagM3G_VIDEO_DEST{
	UCHAR	ucDestNum;		//At most 16 destinations can be 0.
	M3G_VIDEO_DEST_ITEM	DestItem[MAX_VIDEO_DEST_ITEM];
} M3G_VIDEO_DEST;

typedef struct tagM3G_VIDEO_OUTPUT{
	UCHAR			ucValid;		//The structure valid flag
	UCHAR			ucIsEnable;		//The output module enable flag
	UCHAR			ucTransportType;//Please refer to eM3G_VIDEO_TRANSPORT_TYPE
	M3G_VIDEO_RTP	Rtp;			//VIDEO output RTP attributes
	M3G_VIDEO_RTCP	Rtcp;			//output RTCP attributes
	M3G_VIDEO_DEST	Dest;			//output destinations
} M3G_VIDEO_OUTPUT; 

typedef struct tagM3G_CHAN_TYPE_VIDEO_PARAM{
	M3G_VIDEO_INPUT		VideoInput;			// Input module attributes
	M3G_VIDEO_DECODER	VideoDecoder;		// Decode module attributes
	M3G_VIDEO_ENCODER	VideoEncoder;		// encode module attributes
	M3G_VIDEO_OUTPUT	VideoOutput;		// Output module attributes
} M3G_CHAN_TYPE_VIDEO_PARAM; 

/************************************************************************/
/* 3G-324M type channel parameter                                       */
/************************************************************************/
typedef struct tagM3G_TERM_CAPS{
	UCHAR	ucValid;			//The structure valid flag
	UCHAR	ucAudioCodes[4];	//Simultaneously supported audio encoding type, refer to eM3G_H324_AUDIO_CODEC
	UCHAR	ucVideoCodes[4];	//Simultaneously supported video encoding type, refer to eM3G_H324_VIDEO_CODEC
	UCHAR	ucDtmfSignal[2];	/*Simultaneously supported DTMF transport type, 0: no or 1: yes.
								ucDtmfSignal[0] indicates whether to support the string mode to send DTMF;
								ucDtmfSignal[1] indicates whether to support the single send.
								*/
} M3G_TERM_CAPS;

typedef struct tagM3G_H223_PARAMS{
	UCHAR	ucValid;					//The structure valid flag
	UINT	ulAl2WithSeqNumberAudio;	//The audio with or without sequence number, 0: no or 1: yes.
	UINT	ulAl2WitchSeqNumberVideo;	//The video with or without sequence number, 0: no or 1: yes.
	UINT	ulMaxPdu;					//The maximum PDU length supported by the local terminal. Default value: 160.
} M3G_H223_PARAMS; 

typedef struct tagM3G_MEDIA_CHAN{
	UCHAR	ucValid;						//The structure valid flag
	UCHAR	ucRtpPayloadType;				//RTP Payload type
	USHORT	usSrcUdpPort;					//Source UDP port
	USHORT	usDstUdpPort;					//Destination UDP port
	CHAR	DstIpAddr[EHANG_MAX_IP_LEN];	//Destination IP address
	UINT	ulCodec;	/* Codec type of audio/video; 
						  if the media type is audio, refer to eM3G_H324_AUDIO_CODEC; 
						  if the media type is video, refer to eM3G_H324_VIDEO_CODEC.
						 */
	UCHAR	ucIsMuted;						//mute flag, 0: no or 1: yes.
} M3G_MEDIA_CHAN; 

typedef struct tagM3G_CHAN_TYPE_H324M_PARAM{
	UCHAR						ucTermType;		//Terminal type,  range: 0~255
	M3G_TERM_CAPS				LocalCaps;		//Local TCS
	M3G_H223_PARAMS				H223Params;		//H.223 parameters
	M3G_MEDIA_CHAN				MediaChan[MAX_H324M_LC_NUM];
								/*
								Please refer to M3G_MEDIA_CHAN for the valid value of media configuration of 
								logic channels, in which:
								MediaChan[0] for the video output logical channel.
								MediaChan[1] for the audio output logical channel.
								MediaChan[2] for the video input logical channel.
								MediaChan[3] for the audio input logical channel.
								*/
} M3G_CHAN_TYPE_H324M_PARAM;

/************************************************************************/
/* Audio type channel parameter                                         */
/************************************************************************/
/* ucRtpMode: RTP/RTCP mode Define */
#ifndef MAX_M3G_AUDIO_RTP_MODE
#define MAX_M3G_AUDIO_RTP_MODE	2
typedef enum {
	M3G_AUDIO_RTP_MODE_END_SYSTEM	= 0,	/* RTP/RTCP Mode is endpoint Sytetem*/
	M3G_AUDIO_RTP_MODE_TRANSLATOR	= 1,	/* RTP/RTCP Mode is translate module,RTP param willbe translate */
}eM3G_AUDIO_RTP_MODE;
#endif

typedef struct tagM3G_AUDIO_RTP{
	UCHAR		ucPayloadType;			/* payload Type */
	UCHAR		ucRtpMode;				/* RTP/RTCP mode, Reference eM3G_AUDIO_RTP_MODE*/
	USHORT		usConjugatedChanNo;		/* no used */
	UINT		ulTsTicksPerSecond;		/* The Frequency of the timestamp.The incoming timestamp frequency�Can not set to 0*/
	USHORT		usSrcUdpPort;			/* Local UDP Port */
	USHORT		usDestUdpPort;			/* Remote Port */
	CHAR		szDestIPAddr[EHANG_MAX_IP_LEN];	/* Remote IP Address */
} M3G_AUDIO_RTP;

/* M3G_AUDIO_INPUT_JB.ucType: Jitter buffer types Define */
#ifndef MAX_M3G_AUDIO_JB_TYPE
#define MAX_M3G_AUDIO_JB_TYPE	3
typedef enum {
	M3G_AUDIO_JB_TYPE_REORDER	= 0,	/* Reorder jitter buffer(Reordering JB) */
	M3G_AUDIO_JB_TYPE_ADAPTIVE	= 1,	/* Adaptive jitter buffer(Adaptive JB) */
	M3G_AUDIO_JB_TYPE_FIXED		= 2,	/* Fixed jitter buffer(Fixed JB) */
}eM3G_AUDIO_JB_TYPE;
#endif

typedef struct tagM3G_AUDIO_INPUT_JB{
	UCHAR	ucType;					/*Jitter buffer type�Reference eM3G_AUDIO_JB_TYPE*/
	UINT	ulSize;
	UINT	ulAverageDelayInMS;
	UINT	ulPacketLossTimeout;
} M3G_AUDIO_INPUT_JB;

/* M3G_AUDIO_RTCP.ucRtcpHandleType: RTCP statistics approach */
#ifndef MAX_M3G_AUDIO_HANDLE
#define MAX_M3G_AUDIO_HANDLE	4
typedef enum {
	M3G_AUDIO_RTCP_HANDLE_DONT_SEND				= 0,
	M3G_AUDIO_RTCP_HANDLE_SENT_TO_HOST_PERIOD	= 1,
	M3G_AUDIO_RTCP_HANDLE_SEND_TO_NET_PERIOD	= 2,
	M3G_AUDIO_RTCP_HANDLE_SEND_TO_BOTH_PERIOD	= 3,
}eM3G_AUDIO_RTCP_HANDLE;
#endif

typedef struct tagM3G_AUDIO_RTCP{
	UCHAR		ucEnable;			/* Input RTCP Module is activated sigs */
	UCHAR		ucRecvRtcp;			/* RTCP is a sign of receiving */
	UCHAR		ucRtcpHandleType;	/* RTCP statistics approach */
	UINT		ulReportInterval;	/* RTCP Report Perioad. unit :second */
	USHORT		usSrcUdpPort;		/* Local UDP Port */
	USHORT		usDestUdpPort;		/* Remote Port */
	CHAR		szDestIPAddr[EHANG_MAX_IP_LEN];	/* Remote IP ADDRESS */
} M3G_AUDIO_RTCP;

/* RFC types DEFINE */
#ifndef MAX_M3G_AUDIO_RFC_TYPE
#define MAX_M3G_AUDIO_RFC_TYPE	2
typedef enum {
	M3G_AUDIO_RFC_TYPE_NONE		= 0,	/* Does not follow the RFC Specification */
	M3G_AUDIO_RFC_TYPE_3016_AAC	= 1,	/* Follow the RFC Specification(Play/Record files Can not use this specification)*/
}eM3G_AUDIO_RFC_TYPE;
#endif

/* TransPort TYPE:ucTransportType defint below:*/
#ifndef MAX_M3G_AUDIO_TRANSPORT_TYPES
#define MAX_M3G_AUDIO_TRANSPORT_TYPES	  3
typedef enum {
	M3G_AUDIO_TRANSPORT_TYPE_STREAMING	= 0,	/* Type of record/play files*/
	M3G_AUDIO_TRANSPORT_TYPE_IP			= 1,	/* IP packets through UDP socket connection */
	M3G_AUDIO_TRANSPORT_TYPE_H223		= 2,	/* UDP packets from the H.223 channel */
}eM3G_AUDIO_TRANSPORT_TYPE;
#endif

/* Sampling Rate Define */
typedef enum {
	M3G_AUDIO_SAMPLING_RATE_96000	= 96000,
	M3G_AUDIO_SAMPLING_RATE_88200	= 88200,
	M3G_AUDIO_SAMPLING_RATE_64000	= 64000,
	M3G_AUDIO_SAMPLING_RATE_48000	= 48000,
	M3G_AUDIO_SAMPLING_RATE_44100	= 44100,
	M3G_AUDIO_SAMPLING_RATE_32000	= 32000,
	M3G_AUDIO_SAMPLING_RATE_24000	= 24000,
	M3G_AUDIO_SAMPLING_RATE_22050	= 22050,
	M3G_AUDIO_SAMPLING_RATE_16000	= 16000,
	M3G_AUDIO_SAMPLING_RATE_12000	= 12000,
	M3G_AUDIO_SAMPLING_RATE_11025	= 11025,
	M3G_AUDIO_SAMPLING_RATE_8000	= 8000,
	M3G_AUDIO_SAMPLING_RATE_NONE	= 0
}eM3G_AUDIO_SAMPLING_RATE;


#ifndef MAX_M3G_AUDIO_CHANNEL_CONF
#define MAX_M3G_AUDIO_CHANNEL_CONF	3
typedef enum {
	M3G_AUDIO_CHANNEL_CONF_NONE		= 0,	/* not used .no Voice Channel*/
	M3G_AUDIO_CHANNEL_CONF_MONO		= 1,	/* Single Voice Channel�Mono (1 channel) */
	M3G_AUDIO_CHANNEL_CONF_STEREO	= 2,	/* Stereo Voice Channel�Stereo (2 channels) */
}eM3G_AUDIO_CHANNEL_CONF;
#endif

/*Audio INPUT struct is below:*/
typedef struct tagM3G_AUDIO_INPUT{
	UCHAR	ucValid;			/* sign of validity of the this struct */
	UCHAR	ucEnable;			/* sign of the AUDIO Channel INPUT is Enable. */
	UCHAR	ucTransportType;	/* Transport TYEP: IP/H223 , Reference eM3G_AUDIO_TRANSPORT_TYPE*/
	UCHAR	ucRfcType;			/* Rfc TYPE, Reference eM3G_AUDIO_RFC_TYPE */
	UCHAR	ucTrackNum;			/* AUDIO number of the Channels:Single or stereo ,Reference eM3G_AUDIO_CHANNEL_CONF */
	UINT	ulSampleRate;		/* Reference eM3G_AUDIO_SAMPLING_RATE */
	M3G_AUDIO_RTP		RTP;	/* RTP parameter */
	M3G_AUDIO_INPUT_JB	JB;		/* Jitter buffer Parameter */
	M3G_AUDIO_RTCP		RTCP;	/* RTCP Parameter */
} M3G_AUDIO_INPUT;

/* Codec type define */
#ifndef MAX_M3G_AUDIO_CODEC_TYPE
#define MAX_M3G_AUDIO_CODEC_TYPE	2
typedef enum {
	M3G_AUDIO_CODEC_TYPE_L16	= 0,
	M3G_AUDIO_CODEC_TYPE_AAC	= 1,
}eM3G_AUDIO_CODEC_TYPE;
#endif

typedef struct tagM3G_AUDIO_DECODER{
	UCHAR	ucValid;		/* sign of the validity of the this struct */
	UCHAR	ucEnable;		/* sign of the Decoder Module is Enable */
	UCHAR	ucCodecType;	/* Reference eM3G_AUDIO_CODEC_TYPE */
	UCHAR	ucTrackNum;		/* Reference eM3G_AUDIO_CHANNEL_CONF */
	UINT	ulSampleRate;	/* Reference eM3G_AUDIO_SAMPLING_RATE */
} M3G_AUDIO_DECODER;

/* Audio re-sampling of the types defined in the computational complexity */
#ifndef MAX_M3G_AUDIO_COMPLEXITY
#define MAX_M3G_AUDIO_COMPLEXITY	3
typedef enum {
	M3G_AUDIO_COMPLEXITY_LOW		= 0,
	M3G_AUDIO_COMPLEXITY_MEDIUM		= 1,
	M3G_AUDIO_COMPLEXITY_HIGH		= 2,
}eM3G_AUDIO_COMPLEXITY;
#endif

/* ToolBox Changing the sampling rate parameters */
typedef struct tagM3G_AUDIO_TOOLBOX_RESAMPLE{
	UINT	ulNewSampleRate;		/* Reference eM3G_AUDIO_SAMPLING_RATE */
	UCHAR	ucComplexity;			/* Reference eM3G_AUDIO_COMPLEXITY */
}M3G_AUDIO_TOOLBOX_RESAMPLE;

/* Toolbox Changing the voice Channels Number parameters*/
typedef struct tagM3G_AUDIO_TOOLBOX_TRACK_CONF{
	UCHAR	ucNewTrackNum;		/* Reference eM3G_AUDIO_CHANNEL_CONF */
} M3G_AUDIO_TOOLBOX_TRACK_CONF;

/* Toolbox type define */
#ifndef MAX_M3G_AUDIO_TOOL_TYPE
#define	MAX_M3G_AUDIO_TOOL_TYPE		2
typedef enum {
	M3G_AUDIO_TOOL_TYPE_RESAMPLING	= 0,	/* Resampling */
	M3G_AUDIO_TOOL_TYPE_TRACK_CONF	= 1		/* Changing number of the channels */
}eM3G_AUDIO_TOOL_TYPE;
#endif

/* Audio toolbox direction define */
typedef enum {
	M3G_AUDIO_TOOL_DIRECTION_FROM_DECODER			= 0,
	M3G_AUDIO_TOOL_DIRECTION_FROM_TOOLBOX_INPUT		= 1,
	M3G_AUDIO_TOOL_DIRECTION_BOTH					= 2
}eM3G_AUDIO_TOOL_DIRECTION;

/* ToolBox Convert the structure of items */
typedef struct tagM3G_AUDIO_TOOLBOX_ITEM{
	UCHAR	ucType;			/* Reference :eM3G_AUDIO_TOOL_TYPE */
	UCHAR	ucDirection;	/* Reference :eM3G_AUDIO_TOOL_DIRECTION */
	UCHAR	ucInTrackNum;	/* Reference :eM3G_AUDIO_CHANNEL_CONF */
	UINT	ulInSampleRate;	/*Reference :eM3G_AUDIO_SAMPLING_RATE */
	union { /* Parameters associated with the type of operation */
			M3G_AUDIO_TOOLBOX_RESAMPLE		Resample;	/* Resampling */
			M3G_AUDIO_TOOLBOX_TRACK_CONF	TrackConf;	/* Changing number of the channles */
	} u;		
} M3G_AUDIO_TOOLBOX_ITEM;

/* ToolBox structure define.ToolBox Currently doing two conversion�Resampling and change the number of channels�*/
#define M3G_AUDIO_TOOLBOX_ITEM_NUM	8
typedef struct tagM3G_AUDIO_TOOLBOX{
	UCHAR	ucValid;			/* sign of the validity of this structure*/
	UCHAR	ucToolBoxNum;		/* Toolbox number of Convert items.MAX 8 Items */
	M3G_AUDIO_TOOLBOX_ITEM		Item[M3G_AUDIO_TOOLBOX_ITEM_NUM];
} M3G_AUDIO_TOOLBOX;

/* Encoding bit rate control type */
#ifndef MAX_M3G_AUDIO_BITRATE_VARIABLE
#define MAX_M3G_AUDIO_BITRATE_VARIABLE	3
typedef enum {
		M3G_AUDIO_BITRATE_VARIABLE_CBR	= 0,	/* Constant bit rate */
		M3G_AUDIO_BITRATE_VARIABLE_VBR	= 1,	/* Variable bit rate */
		M3G_AUDIO_BITRATE_VARIABLE_ABR	= 2	/* Average bit rate */
}eM3G_AUDIO_BITRATE_VARIABLE;
#endif

/* decode structure define:*/
typedef struct tagM3G_AUDIO_ENCODER{
	UCHAR		ucValid;		/* sign of the validity of this structure*/
	UCHAR		ucEnable;		/* sign of the Enable of the decode module*/
	UCHAR		ucCodecType;	/* Reference eM3G_AUDIO_CODEC_TYPE */
	UCHAR		ucBitRateType;	/* Reference eM3G_AUDIO_BITRATE_VARIABLE */
	UINT		ulBitRate;		/* decoding bit rate */
	UCHAR		ucTrackNum;		/* Reference eM3G_AUDIO_CHANNEL_CONF */
	UINT		ulSampleRate;	/* Reference eM3G_AUDIO_SAMPLING_RATE */
} M3G_AUDIO_ENCODER;

/* Audio Channel output target defined */
typedef struct tagM3G_AUDIO_OUTPUT_DEST{
	UCHAR		ucTransportType;	/* Reference:eM3G_AUDIO_TRANSPORT_TYPE */
	UCHAR		ucRfcType;			/* Reference:eM3G_AUDIO_RFC_TYPE */		
	M3G_AUDIO_RTP		RTP;		/* RTP Parameters */
	M3G_AUDIO_RTCP		RTCP;		/* RTCP Parameters */
} M3G_AUDIO_OUTPUT_DEST;

/*OUTPUT Strucrure Define:*/
#define MAX_M3G_AUDIO_OUTPUT_DEST_NUM	7
typedef struct tagM3G_AUDIO_OUTPUT{
	UCHAR		ucValid;		/* sign of the validity this structure*/
	UCHAR		ucDestNum;		/* Dest numbers�MAX 7 Dest */
	M3G_AUDIO_OUTPUT_DEST	Dest[MAX_M3G_AUDIO_OUTPUT_DEST_NUM];	/* Dest information,variable-length structure */
} M3G_AUDIO_OUTPUT;

/* Audio channels configure paramters is below:*/
typedef struct tagM3G_CHAN_TYPE_AUDIO_PARAM{
	M3G_AUDIO_INPUT			Input;		/*input module parameters*/
	M3G_AUDIO_DECODER		Decoder;	/*decoder module parameters*/
	M3G_AUDIO_TOOLBOX		ToolBox;	/*ToolBox module parameters*/
	M3G_AUDIO_ENCODER		Encoder;	/*Encoder module parameters*/
	M3G_AUDIO_OUTPUT		Output;		/*output module parameters*/
}M3G_CHAN_TYPE_AUDIO_PARAM;

/*
* M3G channel parameters
*/
typedef struct tagM3G_CHAN_PARAM {
	UCHAR	ucChanType;				//M3G channels type�Rms reference eM3G_CHAN_TYPE
	union {
		M3G_CHAN_TYPE_VOICE_PARAM voice;	//voice channel parameters
		M3G_CHAN_TYPE_VIDEO_PARAM video;	//video channel parameters
		M3G_CHAN_TYPE_H324M_PARAM h324m;	//H324M channel parameters
		M3G_CHAN_TYPE_AUDIO_PARAM audio;	//Audio channel parameters
	};
}M3G_CHAN_PARAM, *PM3G_CHAN_PARAM;

/*
* Play video and audio expansion of information, only when playing audio and video need to use
*/
typedef struct tagM3G_CHAN_EXINFO{
	UCHAR	ucValid;	//0:Invalid; 1:uVoiceRelated;  2:uH324mRelated
	union{
		struct { //Only valid for voice channels
			M3GDEV VideoDev;	//Audio and video while playing video channel device handle		
		}uVoiceRelated;
		struct { //only valid for H324M channel
			UCHAR	ucAudioMode;	//0 no oper ; 1 pass through  ;2 transcode,Reference eM3G_MEDIA_CHAN_OPMODE
			M3GDEV	AudioDev;		//voice Transcode channel handle�only valid for ucAudioMode=2
			UCHAR	ucVideoMode;	//0 no oper ; 1 pass through  ;2 transcode,Reference eM3G_MEDIA_CHAN_OPMODE
			M3GDEV	VideoDev;		//Video Transcode channel handle�only valid for ucVideoMode=2
		}uH324mRelated;
	};
}M3G_CHAN_EXINFO, *PM3G_CHAN_EXINFO;

/*
* while files type is M3G_FILE_TYPE_BIN�parameters structure is below:
*/
typedef struct tagM3G_FILE_BIN_PARAMS{
	UINT	FragmentSize;		/* Byte number of one packet while SURF encoder or decoder*/
} M3G_FILE_BIN_PARAMS, M3G_FILE_AMR_PARAMS;

/*
* while files type is M3G_FILE_TYPE_WAV�parameters structure is below:
*/
typedef struct tagM3G_FILE_WAV_PARAMS{
	UINT	ulCoder;		/* Reference eM3G_VOICE_CODER*/
	UINT	ulBlockSize;	/* Length of the Data module ,Reference eM3G_WAV_BLOCK_SIZE */
} M3G_FILE_WAV_PARAMS;

/*
*  While files type is not M3G_FILE_TYPE_WAV�parameters structure is below:
*/
typedef struct tagM3G_FILE_AV_PLAY_TRACK_PARAM{
	UCHAR	ucSampleType;			/* Reference :eM3G_SAMPLE_TYPE */
	UCHAR	ucTimeStampSource;		/* Reference :eM3G_FILE_TIMING_SOURCE_SAMPLE */
	USHORT	usFPS;					/* frame per second�1 ~ 30 */
} M3G_FILE_AV_PLAY_TRACK_PARAM;

#define MAX_TRACK_NUM		2
typedef struct tagM3G_FILE_AV_PLAY_PARAMS{
	UCHAR	ucTrackNum;			 /* Track the number of media files,value range is 0~1 */
	M3G_FILE_AV_PLAY_TRACK_PARAM TrackParam[MAX_TRACK_NUM];	/* Media Information trajectories */
} M3G_FILE_AV_PLAY_PARAMS;

typedef struct tagM3G_FILE_AV_REC_TRACK_PARAM{
	UCHAR	ucSampleType;		/* Reference :eM3G_SAMPLE_TYPE */
	UCHAR	ucTimeStampSource;	/* Reference :eM3G_FILE_TIMING_SOURCE_SAMPLE */
	UINT	ulWidth;			/* Video frame width of the lattice�WMV9 and YUV valid�value:16~720 */
	UINT	ulHeight;			/* Video frame Height of the lattice�WMV9 and YUV valid�value:16~576 */
	USHORT	usFPS;				/* frame per second�value:1~30 */
} M3G_FILE_AV_REC_TRACK_PARAM;

typedef struct tagM3G_FILE_AV_REC_PARAMS{
	UCHAR	ucHintTracks;			/* Whether to insert an index track�0 - Do not insert�1 - insert */
	UCHAR	ucTrackNum;				/* Track the number of media files�value0~1 */
	M3G_FILE_AV_REC_TRACK_PARAM		TrackParam[MAX_TRACK_NUM];	/* Media Information trajectories */
} M3G_FILE_AV_REC_PARAMS;

/*
* M3G record and play data format 
*/
typedef struct tagM3G_XPB{
	UCHAR	ucFileType;		//files type�reference:eM3G_FILE_TYPE
	union {
		M3G_FILE_BIN_PARAMS		bin;	//(BIN) for play
		M3G_FILE_AMR_PARAMS		amr;	//(AMR) for play
		M3G_FILE_WAV_PARAMS		wav;	//(WAV) for play and record
		M3G_FILE_AV_PLAY_PARAMS avp;	//(BIN/3GP/MP4/AVI/ASF/3G2) for play
		M3G_FILE_AV_REC_PARAMS	avr;	//(BIN/3GP/MP4/AVI/ASF/3G2) for record
	};
}M3G_XPB;

/*
* M3G special recording media expansion parameters
*/
typedef struct tagM3G_MEDIA_EX{
	UCHAR	ucVoCoder;		/* reference:eM3G_VOICE_CODER*/
	INT		iVolumeGain;	/* VOICE Volume Gain�Unit:0.1dB�value-90~+90(-9dB~+9dB)*/
}M3G_MEDIA_EX;

/*
* M3G send DIGIT date
*/
typedef struct tagM3G_DIGIT_INFO{ 
	UCHAR	ucDigitType;			//Digit type�Reference:eIPM_DIGIT_TYPE
	UCHAR	ucDigitDir;				//Digit direct�Reference:eIPM_DIGIT_DIRECTION
	UCHAR	ucDigitNum;				//Digit number of the buffer
	CHAR	Digits[MAX_IPM_DIGITS];	//Digit buffer 
	UCHAR	ucDuration;				//Digit active time�Unit:ms
	UCHAR	ucInterval;				//Digit interval�Unit:ms
} M3G_DIGIT_INFO; 

/*
* M3G and ability to set data terminal state
*/
typedef struct tagM3G_TCS_INFO{
	UCHAR			ucTCSStatus;	//TCS state�Reference:eM3G_TCS_STATUS
	M3G_TERM_CAPS	localcaps;		//local endpoint capability
	M3G_TERM_CAPS	remotecaps;		//Remote endpoint capability
	M3G_TERM_CAPS	matchcaps;		//Terminal capability negotiation
}M3G_TCS_INFO;

/*
* Command ID is MISC_ID_VIDEO_FAST_UPDATE_GOB structure is below:
*/
typedef struct tagM3G_VIDEO_FAST_UPDATE_GOB{
	UINT	ulFirstGOB;		/* Group to specify the start block number of the video refresh */
	UINT	ulNumberOfGOBs;	/* Specify the number of refresh blocks */
} M3G_VIDEO_FAST_UPDATE_GOB;
/*
* Command ID is MISC_ID_VIDEO_FAST_UPDATE_MB structure is below:
*/
typedef struct tagM3G_VIDEO_FAST_UPDATE_MB{
	UINT	ulFirstGOB;		/* Group to specify the start block number of the video refresh */
	UINT	ulFirstMB;		/* Macro to specify the start block number of the video refresh */
	UINT	ulNumberOfMBs;	/* Specify the number of macroblocks to refresh */
} M3G_VIDEO_FAST_UPDATE_MB;
/*
* Command ID is MISC_ID_SKEW_INDICATION structure :
*/
typedef struct tagM3G_SKEW_INDICATION{
	UINT	ulSkew;		/* The first logical channel to the second logical channel maximum delay, the unit is ms */
} M3G_SKEW_INDICATION;

/*
* M3G-MISC Command information
*/
typedef struct tagM3G_H245_MISC_INFO{
	UCHAR		ucLogicChanNo;	//logical channel number�Reference eM3G_LC_NUMBER
	UINT		ulMiscCmdId;	//MISC Command ID,reference eM3G_MISC_ID
	union{
		M3G_VIDEO_FAST_UPDATE_GOB	vfug;	//Command is M3G_MISC_ID_VIDEO_FAST_UPDATE_GOB
		M3G_VIDEO_FAST_UPDATE_MB	vfum;	//Command ID is M3G_MISC_ID_VIDEO_FAST_UPDATE_MB
		M3G_SKEW_INDICATION			si;		//Command ID is M3G_MISC_ID_SKEW_INDICATION
	};
} M3G_H245_MISC_INFO; 

/*
* Logical channel parameters of the channel state and the media
*/
typedef struct tagM3G_LC_PARAM{	
	UCHAR			ucLogicChanNo;	//Reference eM3G_LC_NUMBER
	UCHAR			ucLCStatus;		//ReferenceeM3G_LC_STATUS
	M3G_MEDIA_CHAN	parm;			//logical channel parameters
} M3G_LC_PARAM;

/*
* H324M Call state Data
*/
typedef struct tagM3G_CALL_STATUS{	
	UCHAR	ucLinkStatus;	//link status,Reference eM3G_H223_LINK_STATUS
	UCHAR	ucCPStatus;		//Reference eM3G_CP_STATUS
} M3G_CALL_STATUS;

/*
* MSD master data information from the decision
*/
typedef struct tagM3G_MSD_INFO{	
	UCHAR	ucMsdStatus;		//Reference eM3G_MSD_STATUS
	UCHAR	ucLocalIsMaster;	//Local terminal-based
	UCHAR	ucLocalTermType;	//Local terminal type
	UCHAR	ucRemoteTermType;	//Remote terminal type
} M3G_MSD_INFO;

/*
* H324M logical channel status
*/
typedef struct tagM3G_LC_INFO{
	UCHAR	ucLogicChanNo;		//logical channel number�reference eM3G_LC_NUMBER
	UCHAR	ucLCStatus;			//logical channel status�reference eM3G_LC_STATUS
	UCHAR	ucCodec[4];			//Reference eM3G_H324_AUDIO_CODEC or eM3G_H324_VIDEO_CODEC
	UCHAR	ucIsMuted;			//Mute the logical channel is a sign, if Mute, will not send data to the remote
} M3G_LC_INFO;

//////////////////////////////////////////////////////////////////////////
#define EHANG_MAX_TEXTOVERLAYSTR_NUM	8	/*Maximum number of text strings superimposed*/
#define EHANG_MAX_FOREGROUNDID_NUM		5	/*The largest number of prospects Number*/
#define EHANG_MAX_BACKGROUNDID_NUM		5	/*Maximum number of number of background*/

/*DisplayMode*/
#define		DM_HIDE			0x00	/* hide */
#define 	DM_DISPLAY		0x01	/* display */

/*toolbar type*/
typedef enum {
	M3G_TOOLBOX_TYPE_PRIMARY 	= 0,	/*master toolbar*/
	M3G_TOOLBOX_TYPE_VIDEOCONF	= 1  	/*Video conferencing kit*/
} eM3G_TOOLBOX_TYPE;

/*Toolbox control coding*/
typedef enum {
	M3G_CTRLCODE_SETPARAM			= 0x00,	/* set param */
	M3G_CTRLCODE_LOGO_DOWNLOAD		= 0x01,	/* LOGO download */
	M3G_CTRLCODE_LOGO_DISPLAY		= 0x02,	/* LOGO display */
	M3G_CTRLCODE_LOGO_HIDE			= 0x20,	/* LOGO hide */
	M3G_CTRLCODE_COLOR_REMOVE		= 0x04,	/* clear color */
	M3G_CTRLCODE_COLOR_DISPLAY		= 0x40,	/* display normal color */
	M3G_CTRLCODE_TEXT_OVERLAY		= 0x08,	/* Enable text overlay function */
	M3G_CTRLCODE_TEXT_OVERLAY_STOP	= 0x80,	/* Stop text overlay function */
} eM3G_TOOLBOX_CTRLCODE;

/* Display module:display or hide*/
typedef enum {
	M3G_DISPLAY_MODE_HIDE	= 0,
	M3G_DISPLAY_MODE_SHOW	= 1
} eM3G_DISPLAY_MODE;
typedef struct tagM3G_TO_DISPLAY_MODE {
	UCHAR	ucValid; 	/* sign of validity  */
	UCHAR	ucMode;		/* 0-hide; 1-display�Reference eM3G_DISPLAY_MODE*/
} M3G_TO_DISPLAY_MODE;

/*ToolboxParam:*/
typedef struct tagM3G_TOOLBOX_PARAM{
	UCHAR	ucValid;		/* sign of valid */
	UCHAR	ucIsEnable;		/* Enable flag */
	UCHAR	ucFPS;			/* Frame rate */
	UCHAR	ucRev;			/* Retention */
	UINT	ulInputHeight;	
	UINT	ulInputWidth;	
	UINT	ulOutputHeight;	
	UINT	ulOutputWidth;	
} M3G_TOOLBOX_PARAM;

/* LOGO parameter information; */
typedef struct tagM3G_LOGO_PARAM{
	UCHAR	ucValid; 			/*sign of validity */
	UINT	ulHeight;			/* LOGO Height�Unit:piexl�0~144 */
	UINT	ulWidth;			/* LOGO Width�Unit:piexl�0~176 */
	UINT	ulTopPos;			/* LOGO Top Position�Unit:piexl�0~575 */
	UINT	ulLeftPos;			/* LOGO Left Position�Unit:piexl�0~719 */
	UCHAR	ucTransY;
	UCHAR	ucTransU;
	UCHAR	ucTransV;
	UCHAR	ucTransAlpha;
	UCHAR	ucAlphaBlending;
} M3G_LOGO_PARAM;

/* Logo configuration information structure */
typedef struct tagM3G_LOGO_CONFIG {
	M3G_LOGO_PARAM			LogoParm;		/* LOGO parameter information */
	M3G_TO_DISPLAY_MODE		DisplayMode;	/* display mode */
} M3G_LOGO_CONFIG;

/*toolbox confiruation information*/
typedef struct tagM3G_TOOLBOX_CONFIG {
	M3G_TOOLBOX_PARAM 	toolbox;
	M3G_LOGO_PARAM		logo;
} M3G_TOOLBOX_CONFIG;

/* Text of location information: The left, top to specify the text displayed in the location in the YUV */
typedef struct tagM3G_TO_CARET_POSITION {
	UCHAR	ucValid;		/* sign of validity */
	UCHAR	ucTextDir;		/* Text direct,Reference eM3G_TEXT_DIRECTION */
	UINT	ulLeftPos;		/* 0~351 */
	UINT	ulTopPos;		/* 0~287 */
} M3G_TO_CARET_POSITION; 

/*Text direct define */
typedef enum {
	TEXT_DIRECTION_LEFT_TO_RIGHT	= 0x00, /*From left to rigth*/
	TEXT_DIRECTION_RIGHT_TO_LEFT	= 0x01,	/*From rigth to lefer*/
	TEXT_DIRECTION_UP_TO_DOWN		= 0x02,	/*no used*/
	TEXT_DIRECTION_DOWN_TO_UP		= 0x03	/*no used*/
}eM3G_TEXT_DIRECTION;

/* Font-related information */
typedef struct tagM3G_TO_FONT_INFO {
	UCHAR	ucValid; 		/* sign of validity */
	UCHAR	ucFontIndex;	/* Font Index, Current is 0 */
	UINT	ulFontSize;		/* Font Size:0 ~ 255 */
	UINT	ulFontStyle;	/* Font Style�Reference eM3G_TEXT_STYLE */
} M3G_TO_FONT_INFO;

/* Font Style- M3G_TO_FONT_INFO.ulFontStyle */
typedef enum {
	TEXT_STYLE_BM_BOLD				= 0x00000001,
	TEXT_STYLE_BM_ITALIC			= 0x00000002,
	TEXT_STYLE_BM_UNDERLINE			= 0x00000004,
	TEXT_STYLE_BM_OUTLINE			= 0x00000008,
	TEXT_STYLE_BM_STRIKETHROUGH		= 0x00000010,
	TEXT_STYLE_BM_SUBSCRIPT			= 0x00000020,
	TEXT_STYLE_BM_SUPERSCRIPT		= 0x00000040,
	TEXT_STYLE_BM_SHADOW			= 0x00000080,
	TEXT_STYLE_BM_ENGRAVE			= 0x00000100
}eM3G_TEXT_STYLE;

/* Foreground / background color scheme information */
typedef struct tagM3G_TO_COLOR {
	UCHAR	ucValid; 		
	UCHAR	ucForegroundR;
	UCHAR	ucForegroundG;
	UCHAR	ucForegroundB;
	UCHAR	ucForegroundAlpha;
	UCHAR	ucBackgroundR;
	UCHAR	ucBackgroundG;
	UCHAR	ucBackgroundB;
	UCHAR	ucBackgroundAlpha;
} M3G_TO_COLOR;

/*Scroll direction is defined */
typedef enum {
	SCROLL_DIRECTION_LEFT_TO_RIGHT	= 0x00,
	SCROLL_DIRECTION_RIGHT_TO_LEFT	= 0x01,
}eM3G_SCROLL_DIRECTION;

/* Scrolling text information related to: scroll function is enabled only after most of the information to be effective */
typedef struct tagM3G_TO_SCROLL_INFO {
	UCHAR	ucValid; 				/* sign of validity */
	UCHAR	ucEnable;				/* Scroll function is enabled the flag */
	UCHAR	ucScrollDir;			/* Reference eM3G_SCROLL_DIRECTION */
	UCHAR	ucEndlessLoop;			/* Whether a sign has been scrolling:0-NO; 1-YES */
	UINT	ulSpeed;				/* Scrolling speed:piexls/second */
	UINT	ulLeftPos;				/* Position of the scroll box to the left */
	UINT	ulRightPos;				/* Scroll box to the right place */
	UINT	ulBackgroundTopPos;		/* Background at the top position */
	UINT	ulBackgroundLeftPos;	/* Background on the left position */
	UINT	ulBackgroundWidth;		/* Background width */
	UINT	ulBackgroundHeight;		/* Background height */
} M3G_TO_SCROLL_INFO;

/* Text: Each unicode character is said */
#define EHANG_MAX_TEXT_LEN		256
typedef struct tagM3G_TO_TEXT {
	UCHAR	ucValid; 		/* sign of validity */
	CHAR	szContent[EHANG_MAX_TEXT_LEN]; /*text buffer,English maximum 160 characters, maximum 80 characters Chinese*/
} M3G_TO_TEXT;

/*TextOverlay*/
typedef struct tagM3G_TEXTOVERLAY_CONFIG {
	M3G_TO_CARET_POSITION		CaretPos;		/* text position */
	M3G_TO_FONT_INFO			FontInfo;		/* Font Information */
	M3G_TO_COLOR				ColorInfo;		/* Foreground / background color  */
	M3G_TO_DISPLAY_MODE			DisplayMode;	
	M3G_TO_SCROLL_INFO			ScrollInfo;		/* Scrolling text information related to */
	M3G_TO_TEXT					Text;			/* Text */
} M3G_TEXTOVERLAY_CONFIG;

/************************************************************************/
/* 3G Conference                                                       */
/************************************************************************/
#define MAX_VIDEOCONF_MIXER_NUM		5	/* Maximum number of video conferencing mixer */

/*M3G_VIDEOCONF_PARM.ulVideoConfCaps*/
typedef enum {
	VIDEO_CONF_CAP_MULTIPLE_MIXERS = 0x01,/* Support for multiple video conferencing channel mixer */
	VIDEO_CONF_CAP_HIGH_RESOLUTION = 0x02,/* Support a mixture of more than CIF resolution image */
} eM3G_VIDEOCONF_CAP;

typedef struct tagM3G_VIDEOCONF_MIXER {
	UCHAR	ucMixerId;			/* Mixer of the number, range: 1 to 5 */
	UINT	ulWidth;			/* Horizontal image size */
	UINT 	ulHeight;			/* Vertical image size */
	UCHAR	ucSynSrc;			/* Synchronization source type: 0 - self-synchronization; 1 - sync to a meeting participant */
	UINT 	ulFPS;				/* Valid sync source is 0, that frame rate */
	M3GDEV 	videodev;			/* Effective synchronization source is 1, the meeting participants that the video channel device handle */
} M3G_VIDEOCONF_MIXER, *PM3G_VIDEOCONF_MIXER;

typedef struct tagM3G_VIDEOCONF_PARM {
	UINT	ulVideoConfCaps;	/* Reference eM3G_VIDEOCONF_CAP*/
	USHORT	usSrcUdpPort;		/* Source UDP Port */
	UCHAR	ucMixerNum;			/* Mixer Max is MAX_VIDEOCONF_MIXER_NUM */
	M3G_VIDEOCONF_MIXER Mixer[MAX_VIDEOCONF_MIXER_NUM]; /* The properties of each mixer, the number determined by the ucMixerNum */
} M3G_CHAN_TYPE_VIDEOCONF_PARAM, M3G_VIDEOCONF_PARM, *PM3G_VIDEOCONF_PARM;

/*Video channel to send the video stream video conferencing channel properties*/
typedef struct tagVIDEO_PARTICIANT_SENDER {
	UCHAR	ucValid;			/* Sign structure is valid: 0 - valid; 1 - effective */
	UCHAR 	ucSendFlag;			/* A sign of whether to send the video stream: 0 - Pause send 1 - continued to send, the default value of 1*/
	USHORT	usWidth;			/* Mixer to give the image width, default is 0 */
	USHORT	usHeight;			/* Mixer to give the image height, default value is 0 */
} VIDEO_PARTICIANT_SENDER, *PVIDEO_PARTICIANT_SENDER;

/*Video channel to receive the properties of composite video*/
typedef struct tagVIDEO_PARTICIANT_RECVER {
	UCHAR	ucValid;			/* Sign structure is valid: 0 - valid; 1 - effective */
	UCHAR	ucMixerId;			/* Mixer ID, range: 1 to 5 */
	UCHAR	ucRecvFlag;			/* Whether to receive the video stream flags: 0 - not accept 1 - receives, the default is 1*/
	USHORT	usRecverUdpPort; 	/* In the remote video conference participant to receive the next meeting of the UDP port; local video conference mode, this value does not make sense*/
	UINT 	ulRecverFPS;		/* Receiving the composite video frame rate, the default is 0 */
} VIDEO_PARTICIANT_RECVER, *PVIDEO_PARTICIANT_RECVER;

/*Video channel in the mixer properties*/
typedef struct tagVIDEO_PARTICIANT_VISION_ITEM{
	UCHAR ucMixerId;		/* Mixer ID�Range:1~5 */
	UCHAR ucLayerId;		/* Layer number*/
	USHORT usLeftPos; 		/* Left Position; */
	USHORT usTopPos; 		/* Top Position; */
	USHORT usWidth; 		
	USHORT usHeight; 		
} VIDEO_PARTICIANT_VISION_ITEM, *PVIDEO_PARTICIANT_VISION_ITEM;

/*
Mixer in the video conferencing video stream in the Display Properties
Note: This ucVisionNum adding that the number of mixer, range: 0 to create a number of conference mixer.
 0 means not to join any mixer. If ucValid 0 said not to join the mixer.
*/
typedef struct tagVIDEO_PARTICIANT_VISION {
	UCHAR	ucValid;		/* Sign structure is valid: 0 - valid; 1 - effective */
	UCHAR	ucVisionNum;	/* Adding the number of video channels mixer, 0 for no member of any mixer */
	VIDEO_PARTICIANT_VISION_ITEM Visions[MAX_VIDEOCONF_MIXER_NUM]; /* Video channels display properties by adding mixer */
} VIDEO_PARTICIANT_VISION, *PVIDEO_PARTICIANT_VISION;

/*The video channel as the properties of the synchronization source mixer*/
typedef struct tagVIDEO_PARTICIANT_SYNC_SRC {
	UCHAR	ucValid;		/* Sign structure is valid: 0 - valid; 1 - effective */
	UCHAR	ucMixerNum;		/* Video channel mixer as the number of simultaneous sources */
	UCHAR	ucMixerIds[MAX_VIDEOCONF_MIXER_NUM];	/* As a synchronization source video mixer channel number (range: 1 to 5), the number determined by the ucMixerNum */
} VIDEO_PARTICIANT_SYNC_SRC, *PVIDEO_PARTICIANT_SYNC_SRC;

typedef struct tagM3G_VIDEOCONF_CDT {
	M3GDEV videodev; 	/*Specifies the handle to join the conference video channel*/
	VIDEO_PARTICIANT_SENDER		sender;		/*Video participants join the properties of composite video*/
	VIDEO_PARTICIANT_RECVER		recver; 	/*Participants received mixed video video attributes*/
	VIDEO_PARTICIANT_VISION		vision; 	/*Participants in the video mixer in the Display Properties; */
	VIDEO_PARTICIANT_SYNC_SRC	syncsrc;	/*Participants as a mixer video sync source properties*/
}M3G_VIDEOCONF_CDT, *PM3G_VIDEOCONF_CDT;

typedef struct tagM3G_VIDEOCONF_FOREGROUND {
	UCHAR ucControlCode;			/*Control code, 0 - produced images; 1 - Remove the image; 2-- control the properties of the image; */
	VIDEO_PARTICIANT_VISION vision; /*Foreground or background in a video conference mixer in the Display Properties; */
	CHAR szFileName[MAX_PATH];		/*To '\ 0' end of the image file name string.*/
} M3G_VIDEOCONF_FOREGROUND, M3G_VIDEOCONF_BACKGROUND;

typedef struct tagM3G_BOX_ATTRI{
	UCHAR	ucBoxColorY;
	UCHAR	ucBoxColorU;
	UCHAR	ucBoxColorV;
	UCHAR	ucLineSize;
} M3G_BOX_ATTRI, *PM3G_BOX_ATTRI;

typedef struct tagM3G_BOX_VISION_ITEM{
	VIDEO_PARTICIANT_VISION_ITEM	Vision;		/* box shows the location of the size of information */
	M3G_BOX_ATTRI					BoxAttr;		/* BOX frame and line width information */
} M3G_BOX_VISION_ITEM, *PM3G_BOX_VISION_ITEM;

typedef struct tagM3G_VIDEOCONF_BOX {
	UCHAR	ucVisionNum;	/* Box number in the mixer, to 0 for no member of any mixer */
	M3G_BOX_VISION_ITEM Visions[MAX_VIDEOCONF_MIXER_NUM]; /*Box in the Display Properties in the mixer*/
} M3G_VIDEOCONF_BOX;

typedef struct tagM3G_VOICECONF_PARM {
	UINT	ulMaxDominantSpeakers;		/* A spokesman for the maximum number of range: 1 to 5*/
	UINT	ulHangOver;					/* Spokesman for the switching time, range: 1 to 20, units of 10ms */
} M3G_CHAN_TYPE_VOICE_CONF_PARAM, M3G_VOICECONF_PARM;

/* ucParticipantType */
typedef enum {
	VOICECONF_PARTICIPANT_DISABLED			= 0, /* Not part of the conference participants */
	VOICECONF_PARTICIPANT_ENABLED			= 1, /* Non-privileged meeting participants */
	VOICECONF_PARTICIPANT_LISTEN_ONLY		= 2, /* Just listen to conference participants */
	VOICECONF_PARTICIPANT_ALWAYS_DOMINANT	= 3, /* Always able to hear the conference participants*/
	VOICECONF_PARTICIPANT_DISTRIBUTED		= 4, /* Distributed Channel Conference */
	VOICECONF_PARTICIPANT_WHISPER			= 5, /* The Council members can only talk with one of the participating parties */
} eParticipantType;

typedef struct tagM3G_VOICECONF_CDT {
	M3GDEV	voicedev;			/*Specifies the handle to join the meeting audio channel*/
	UCHAR	ucParticipantType;	/*Participant type, reference eParticipantType */
	M3GDEV	Whisperdev;			/*ucParticipantType is WHISPER, the designated meeting in the private audio channel handle*/
}M3G_VOICECONF_CDT;

typedef struct tagM3G_H324M_VENDOR_ID {
	CHAR*	p_vendor_id;			//Provider ID
	USHORT	vendor_id_len;			//Provider ID Length
	CHAR*	p_production_num;		//Product No.
	USHORT	production_num_len;		//Product No Length
	CHAR*	p_version;				//Version
	USHORT  version_len;			//Version Length
} M3G_H324M_VENDOR_ID;

/* VOICE channel fixed gain, the gain of the unit is 0.1dB, the range of -90 ~ +90 (-9dB ~ +9 dB) */
typedef struct tagM3G_VOICE_EC_GAIN {
	INT		rin_gain;		/* RIN;  Default:0*/
	INT		rout_gain;		/* ROUT; Default:0*/
	INT		sin_gain;		/* SIN;  Default:0*/
	INT		sout_gain;		/* SOUT; Default:0*/
} M3G_VOICE_EC_GAIN, *PM3G_VOICE_EC_GAIN;

/* AGC gain some */
typedef struct tagM3G_VOICE_AGC {
	UCHAR		ucEnable;				/* AGC enable flag: 0 - do not start the AGC, 1 - start the AGC; default AGC does not start */
	UINT		ulEngAvgWindowLen;		/* Average energy window length (: ms): 50ms ~ 1000ms; default value: 100*/
	INT			lMinSignalLevel;		/* The minimum signal level, little more than the value of the signal will be amplified to this value (unit: 1dBm0):-37dBm0 ~-6dBm0; default values??: -14*/
	INT			lMaxSignalLevel;		/* Maximum signal level greater than this value the signal will be attenuated to this value (unit: 1dBm0):-37dBm0 ~-6dBm0; default value: -10*/
	UINT		ulStepLevel;			/* Energy rate (unit: 0.1dB / s): 0 ~ 2500; default value: 10*/
	INT			lSilentLevelThreshold;	/* Absolute silence of the energy value, little more than this value will not enter the energy calculation, it will not be amplified (unit: dBm0):-60dBm0 ~-6dBm0; default value: -30*/
	UCHAR		ucMaxAppliedGainUsed;	/* Whether to use the maximum gain: 0 - not used, 1 - use; default value: 0*/
	UINT		ulMaxAppliedGain;		/* Maximum gain value (unit: 1dB): 0 ~ 40; default value: 20*/
} M3G_VOICE_AGC, *PM3G_VOICE_AGC;

/* VOICE channel volume gain parameter */
typedef struct tagM3G_VOICE_VOLPARM {
	M3G_VOICE_EC_GAIN	EcGain;		/* EC gain */
	M3G_VOICE_AGC		AGCFromTDM;	/* TDM to IP direction of the AGC control */
	M3G_VOICE_AGC		AGCFromIP;	/* IP to TDM direction of the AGC control */
} M3G_VOICE_VOLPARM, *PM3G_VOICE_VOLPARM;

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

/*
 * Prototypes for all library functions.
 */
#ifdef __cplusplus
extern "C" {   // C++ func bindings to enable C funcs to be called from C++
#define extern
#endif

/************************************************************************/
/*　Function: ISX_m3g_OpenEx()
Description:
	The application use ISX_m3g_OpenEx() function to open the M3G channel device of the M3G daughter 
	and got the channel device handle on successful. The channel device handle put in the memory specified 
	by the parameter devp when the function completed. In the asynchronous mode, the event M3GEV_OPEN_CMPLT 
	is for successful and the event M3GEV_OPEN_FAIL for unsuccessful to open the M3G channel device. 
	The channel can only be opened by only one application, so, if A application has successfully opened 
	a channel, then the B application will fail to open the same channel. Only when A application called 
	ISX_m3g_close() function to close the M3G channel device handle, the B application can open the same 
	channel now. The channel device handle returned by this function is defined by Ehangcom, it is not a 
	standard file handle of the operating system, so the application can¨t use operating system functions 
	such as read(), write() or ioctl() to operate the handle. Unexpected result will occur on doing so.
Completed Event:
	M3GEV_OPEN_CMPLT: The channel was successful opened.
	M3GEV_OPEN_FAIL: The channel was unsuccessful opened
Return value:
	0 success
	-1 failure
Parameters:
-devp
	The pointer for returned the M3G channel device handle and can not be empty.
-nodenum
	iSX node number
-brdnum
	M3G daughter board number
-channel
	M3G channel number
-mode
	EV_ASYNC - asynchronous
	EV_SYNC - synchronous
-pusrattr
	The pointer of user-defined attributes
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT)  ISX_m3g_OpenEx(M3GDEV *devp, CHAR nodenum, CHAR brdnum, SHORT channel, USHORT mode=EV_SYNC, VOID* pusrattr = 0);
#else
ISXAPI_FUNC_STDCL(INT)  ISX_m3g_OpenEx(M3GDEV *devp, CHAR nodenum, CHAR brdnum, SHORT channel, USHORT mode, VOID* pusrattr);
#endif

/************************************************************************/
/*　Function:ISX_m3g_Close()
 *　Description:
 The application use the ISX_m3g_Close() function to close the M3G board
 device or channel device handle. The function does not change the device state (such as switch), 
 and it only releases the handle and the occupied relation between the call application and the device.
 Note: ISX_m3g_Close() forbids all events related to the device to occur.
 *	Return value:	0 success;	-1 failure
 *	Parameters:
-dev		
	Specify an valid device handle (returned by ISX_m3g_OpenEx() or ISX_m3g_Open())
*/
/************************************************************************/
ISXAPI_FUNC_STDCL(INT)  ISX_m3g_Close(M3GDEV dev);

/************************************************************************/
/*　Function:ISX_m3g_SetParm()
 *　Description:
 The application use the ISX_m3g_SetParm() function to set the M3G channel type and relevant parameters. 
 The ISX_m3g_OpenEx() function only open the M3G channel device, and don¨t change the channel type. 
 Once the channel type is specified, the channel type can not be changed. If the channel type indeed 
 needs to be changed, the application must ensure that the channel is in the idle state.
*	Stop Event
	M3GEV_SET_PARM_CMPLT: The function call completed successfully.
	M3GEV_SET_PARM_FAIL: The function call completed unsuccessfully.

 *	Return value:	0 success;	-1 failure
 *	Parameters:
-dev 		
	The M3G channel device handle returned by ISX_m3g_OpenEx( )
	pParmInfo	The pointer of the M3G channel parameter information structure; for the detailed 
	description of parameters, please refer to the data structure M3G_CHAN_PARAM
-mode
	EV_ASYNC - asynchronous
	EV_SYNC - synchronous
-ulOperIndex	
	Asynchronous operation number. When the operation completed and the event M3GEV_SET_PARM_CMPLT 
	or M3GEV_SET_PARM_FAIL occurred, the application can use the ISX_sr_getevtoperindex() function 
	to get the operation number.
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT)  ISX_m3g_SetParm(M3GDEV dev, M3G_CHAN_PARAM *pParmInfo, USHORT mode=EV_SYNC, UINT ulOperIndex = 0);
#else
ISXAPI_FUNC_STDCL(INT)  ISX_m3g_SetParm(M3GDEV dev, M3G_CHAN_PARAM *pParmInfo, USHORT mode, UINT ulOperIndex);
#endif

/************************************************************************/
/*　Function:ISX_m3g_GetParm()
 *　Description:
 	The application use the ISX_m3g_GetParm() function to get the M3G channel type and relevant parameters. 
 	The returned M3G channel parameter information will be written into the local buffer specified by pParmInfo.
 *	Stop Event
	M3GEV_GET_PARM_CMPLT: The function call completed successfully.
	M3GEV_GET_PARM_FAIL: The function call completed unsuccessfully.
 *	Return value:	0 success;	-1 failure 
 *	Parameters:
-dev 		
	The M3G channel device handle returned by ISX_m3g_OpenEx( )
-pParmInfo	
	The pointer of the M3G channel parameter information structure; please refer to M3G_CHAN_PARAM for 
	detailed description.
-mode
	EV_ASYNC - asynchronous
	EV_SYNC - synchronous
	
-ulOperIndex	
	Asynchronous operation number. When the operation completed and the event M3GEV_SET_PARM_CMPLT 
	or M3GEV_SET_PARM_FAIL occurred, the application can use the ISX_sr_getevtoperindex() function 
	to get the operation number.
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT)  ISX_m3g_GetParm(M3GDEV dev, M3G_CHAN_PARAM *pParmInfo, USHORT mode=EV_SYNC, UINT ulOperIndex = 0);
#else
ISXAPI_FUNC_STDCL(INT)  ISX_m3g_GetParm(M3GDEV dev, M3G_CHAN_PARAM *pParmInfo, USHORT mode, UINT ulOperIndex);
#endif

/************************************************************************/
/*　Function:ISX_m3g_Set2Default()
 *　Description:
 	The application use the ISX_m3g_Set2Default( ) function to set each domain of M3G_CHAN_PARAM 
 	structure into the default value of SDK.
 *	Return value:	0 success;	-1 failure
 *	Parameters:
-ucChanType	
	M3G channel type
-pParmInfo	
	The pointer of the M3G channel parameter information structure
*/
/************************************************************************/
ISXAPI_FUNC_STDCL(INT)  ISX_m3g_Set2Default(eM3G_CHAN_TYPE ucChanType, M3G_CHAN_PARAM *pParmInfo);

/************************************************************************/
/*　Function:ISX_m3g_StartMedia()
 *　Description:
 	The application use the function ISX_m3g_StartMedia() to start the media of the specified M3G channel.
 	 The function is only applicable to the VOICE and VIDEO channels.
 * Stop Event
		M3GEV_START_MEDIA_CMPLT: The function completed successfully.
		M3GEV_START_MEDIA_FAIL: The function completed unsuccessfully.
 *	Return value:	0 success;	-1 failure
 *	Parameters:
-dev 	
	The M3G channel device handle returned by ISX_m3g_OpenEx()
-pParmInfo
	The pointer of the M3G channel parameter structure. Please refer to the structure M3G_CHAN_PARAM for detail.
-mode:
	EV_ASYNC - asynchronous
	EV_SYNC - synchronous
-ulOperIndex	
	Asynchronous operation number. When the operation is completed and the M3GEV_START_MEDIA_CMPLT 
	or M3GEV_START_MEDIA_FAIL occurs, the number can be obtained through ISX_sr_getevtoperindex() function.
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT)  ISX_m3g_StartMedia(M3GDEV dev, M3G_CHAN_PARAM *pParmInfo, USHORT mode=EV_SYNC, UINT ulOperIndex = 0);
#else
ISXAPI_FUNC_STDCL(INT)  ISX_m3g_StartMedia(M3GDEV dev, M3G_CHAN_PARAM *pParmInfo, USHORT mode, UINT ulOperIndex);
#endif

/************************************************************************/
/*　Function:ISX_m3g_StopMedia()
 *　Description:
 	The application use the function ISX_m3g_StopMedia() to stop the media of the specified M3G channel. 
 	The function is only applicable to the VOICE and VIDEO M3G channels.
 *	Stop Event
	M3GEV_STOP_MEDIA_CMPLT: The function completed successfully.
	M3GEV_STOP_MEDIA_FAIL: The function completed unsuccessfully.
 *	Return value:	0 success;	-1 failure 
 *	Parameters:
-dev 		
	The M3G channel device handle returned by ISX_m3g_OpenEx()
-mode:
	EV_ASYNC - asynchronous
	EV_SYNC - synchronous
-ulOperIndex	
	Asynchronous operation number; when the operation is completed and the M3GEV_STOP_MEDIA_CMPLT 
	or M3GEV_STOP_MEDIA_FAIL occurs, the number can be obtained through ISX_sr_getevtoperindex() function.
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT)  ISX_m3g_StopMedia(M3GDEV dev, USHORT mode=EV_SYNC, UINT ulOperIndex = 0);
#else
ISXAPI_FUNC_STDCL(INT)  ISX_m3g_StopMedia(M3GDEV dev, USHORT mode, UINT ulOperIndex);
#endif

/************************************************************************/
/*　Function:ISX_m3g_Play()
 *　Description:
 	The application use the function ISX_m3g_play() to play audio and video files. 
 	The FileType domain of M3G_XPB specify the file formats of the file, and other domains of M3G_XPB specify 
 	the data format of the file. When the audio and video files need to be played at the same time or the 
 	video/audio transcoding needs to be carried out, please use M3G_CHAN_EXINFO structure to indicate the channel
 	 extension information. The audio and video files played by the function are stored in the M3G control server.
 *	Stop Event
	M3GEV_PLAY_BEGIN: The function completed successfully and the files begin to play.
	M3GEV_PLAY_CMPLT: All files have played, so the playing are finished.
	M3GEV_PLAY_FAIL: The function call completed unsuccessfully.
 *	Return value:	0 success;	-1 failure 
 *	Parameters:
-dev 		
	The M3G channel device handle returned by ISX_m3g_OpenEx()
-iottp 		
	Points to the I/O transfer table structure. I/O transfer tables composed of one or more DX_IOTT structures. 
	One DX_IOTT structure identifies a source or destination for audio and video data. During the files playing, 
	I/O transfer tables must be global or static. Please refer to ISX4000 VOICE User Manual for the detail of DX_IOTT.
	Note: It must point to a global or static variable, otherwise unexpected errors will occur.
-tptp 
	Points to Termination Parameter Table structure; the Termination Parameter Tablecomposed of one or more 
	DV_TPT structures. The DV_TPT structure is used to specify all conditions of play terminated. Please refer 
	to ISX4000 VOICE User Manual for the detail of DV_TPT.
	Note: It must point to a global or static variable, otherwise unexpected errors will occur.
-xpbp 	
	Points to I/O parameter block structure. The parameter specifies the file format and data formats, 
	please refer to M3G_XPB for detail.
-eDirection	
	Please refer to eM3G_DATA_DIR for stream direction
	Note: The stream direction of the H324M channel always is TDM direction (please use M3G_DATA_DIR_TDM instead).
-mode		
	EV_SYNC - synchronous
	EV_ASYNC - asynchronous
-pExChanInfo	
	Additional extension information is used only when the audio and video files need to be played 
	at the same time or the video/audio transcoding needs to be carried out. Please refer to M3G_CHAN_EXINFO 
	for the detail.
-ulOperIndex	
	Asynchronous operation number; when the operation is completed and the M3GEV_PLAY_CMPLT or M3GEV_PLAY_FAIL occurs, 
	the number can be obtained through ISX_sr_getevtoperindex() function.
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT)	ISX_m3g_Play(M3GDEV dev, DX_IOTT *iottp, const DV_TPT *tptp, M3G_XPB * xpbp=NULL, eM3G_DATA_DIR eDirection=M3G_DATA_DIR_TOIP, USHORT mode=EV_SYNC, M3G_CHAN_EXINFO *pExChanInfo=NULL, UINT ulOperIndex=0);
#else
ISXAPI_FUNC_STDCL(INT)	ISX_m3g_Play(M3GDEV dev, DX_IOTT *iottp, const DV_TPT *tptp, M3G_XPB * xpbp, eM3G_DATA_DIR eDirection, USHORT mode, M3G_CHAN_EXINFO *pExChanInfo, UINT ulOperIndex);
#endif

/************************************************************************/
/*　Function:ISX_m3g_Record()
 *　Description:
 	The application use the function ISX_m3g_ Record() to record audio and video files. The FileType domain 
 	of M3G_XPB specify the file formats of the file, and other domains of M3G_XPB specify the data format of the file.
 	 When the audio and video files need to be recorded at the same time or the video/audio transcoding needs to be 
 	 carried out, please use M3G_CHAN_EXINFO structure to indicate the channel extension information. The audio and 
 	 video files recorded by the function are stored in the M3G control server.
 *	Stop Event
	M3GEV_RECORD_BEGIN: The function completed successfully and the file begin to record. 
	M3GEV_RECORD_CMPLT: The file recording finished.
	M3GEV_RECORD_FAIL: The function completed unsuccessfully.
 *	Return value:	0 success;	-1 failure 
 *	Parameters:
-dev
	The M3G channel device handle returned by ISX_m3g_OpenEx( )
-iottp
	Points to the I/O transfer table structure. I/O transfer tables composed of one or more DX_IOTT structures. 
	One DX_IOTT structure identifies a source or destination for audio and video data. During the files recording, 
	I/O transfer tables must be global or static. Please refer to ISX4000 VOICE User Manual for the detail of DX_IOTT.
	Note: It must point to a global or static variable, otherwise unexpected errors will occur.
	Note: Recording only supports one IOTT now.
-tptp
	Points to Termination Parameter Table structure; the Termination Parameter Table composed of one or more DV_TPT 
	structures. The DV_TPT structure is used to specify all conditions of play terminated. Please refer to ISX4000 
	VOICE User Manual for the detail of DV_TPT.
	Note: It must point to a global or static variable, otherwise unexpected errors will occur.
-xpbp
	Points to I/O parameter block structure. The parameter specifies the file format and data formats, 
	please refer to M3G_XPB for detail.
-eDirection
	Please refer to eM3G_DATA_DIR for stream direction
	Note: The stream direction of the H324M channel always is TDM direction (please use M3G_DATA_DIR_TDM instead).
-mode
	Synchronous/asynchronous mode:
	EV_SYNC - synchronous
	EV_ASYNC - asynchronous
-pExChanInfo
	Additional extension information is used only when the audio and video files need to be recorded at the same 
	time or the video/audio transcoding needs to be carried out. Please refer to M3G_CHAN_EXINFO for the details.
-ulOperIndex
	Asynchronous operation number; when the operation is completed and the M3GEV_RECORD_CMPLT or M3GEV_RECORD_FAIL 
	occurs, the number can be obtained through ISX_sr_getevtoperindex() function.
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT)	ISX_m3g_Record(M3GDEV dev, DX_IOTT *iottp, const DV_TPT *tptp, M3G_XPB * xpbp=NULL, eM3G_DATA_DIR eDirection=M3G_DATA_DIR_FROMIP, USHORT mode=EV_SYNC, M3G_CHAN_EXINFO *pExChanInfo=NULL, UINT ulOperIndex=0);
#else
ISXAPI_FUNC_STDCL(INT)	ISX_m3g_Record(M3GDEV dev, DX_IOTT *iottp, const DV_TPT *tptp, M3G_XPB * xpbp, eM3G_DATA_DIR eDirection, USHORT mode, M3G_CHAN_EXINFO *pExChanInfo, UINT ulOperIndex);
#endif

/************************************************************************/
/*　Function:ISX_m3g_StopCh()
 *　Description:
 	The application use the function ISX_m3g_StopCh() to forces termination of currently active I/O functions 
 	on a M3G channel. If the specified channel has no active I/O functions, there is no action on the channel. 
 	After the active I/O functions were terminated, the terminated reason (TM_USRSTOP) can be obtained through 
 	the ISX_ATDX_TERMMSK() function.
 *	Terminated Event
	M3GEV_PLAY_CMPLT: After the function completed, file playing action was forcibly terminated
	M3GEV_RECORD_CMPLT: After the function completed, file recording action was forcibly terminated.
	M3GEV_RECV_DIGITS_CMPLT: After the function completed, the DIGIT receiving action is forcibly stopped.
	M3GEV_STOP_FAIL: The function completed unsuccessfully.
 *	Return value:	0 success;	-1 failure 
 *	Parameters:
-dev
	The M3G channel device handle returned by ISX_m3g_OpenEx()
-mode
	Call mode:
	EV_SYNC - synchronous
	EV_ASYNC - asynchronous
	I/O mode:
	EV_STOPPLAY: terminate playing action
	EV_STOPREC: terminate recording action
	EV_STOPGETDIG: terminate receiving DIGIT action
	Mode can be the combination of call mode and I/O mode (Bitwise OR)
*/
/************************************************************************/
ISXAPI_FUNC_STDCL(INT)	ISX_m3g_StopCh(M3GDEV dev, USHORT mode );

/************************************************************************/
/*　Function:ISX_m3g_PauseCh()
 *　Description:
 	The application use the function ISX_m3g_PauseCh() to suspend the I/O actions of a M3G channel. 
 	If the specified channel has no I/O actions, there is no any influence on the channel. After the I/O actions 
 	were suspended, the M3GEV_PAUSE_CMPLT or M3GEV_PAUSE_FAIL event will occur. After the event is received, 
 	the currently suspended operation types (OPER_PLAY and OPER_RECORD) can be obtained through ISX_sr_getevtopertype() 
 	function.
 *	Stop Event
	M3GEV_PAUSE_CMPLT : The function completed successfully.
	M3GEV_PAUSE_FAIL: The function completed unsuccessfully.
 *	Return value:	0 success;	-1 failure 
 *	Parameters:
-dev
	The M3G channel device handle returned by ISX_m3g_OpenEx()
-mode
	Call mode:
	EV_SYNC - synchronous
	EV_ASYNC - asynchronous
	I/O mode:
	EV_ PAUSEPLAY - suspend the file playing
	EV_ PAUSEREC - suspend the file recording
	Mode can be the combination of call mode and I/O mode (Bitwise OR)
*/
/************************************************************************/
ISXAPI_FUNC_STDCL(INT)	ISX_m3g_PauseCh(M3GDEV dev, USHORT mode );

/************************************************************************/
/*　Function:ISX_m3g_ResumeCh()
 *　Description:
 	The application use the function ISX_m3g_ ResumeCh() to resume the suspended I/O actions of a M3G channel. 
 	If the specified channel has no I/O actions suspended, there is no any influence on the channel. After the I/O 
 	actions are resumed, the M3GEV_RESUME_CMPLT or M3GEV_RESUME_FAIL event will occur. After the event is received, 
 	the currently suspended operation types (OPER_PLAY and OPER_RECORD) can be obtained through ISX_sr_getevtopertype() 
 	function.
 *	Stop Event
		M3GEV_RESUME_CMPLT: The function completed successfully.
		M3GEV_RESUME_FAIL: The function completed unsuccessfully.
 *	Return value:	0 success;	-1 failure 
 *	Parameters:
-dev
	The M3G channel device handle returned by ISX_m3g_OpenEx( )
-mode
	Call mode:
	EV_SYNC - synchronous
	EV_ASYNC - asynchronous
	I/O mode:
	EV_ RESUMEPLAY - resume the file playing
	EV_ RESUMEREC - resume the file recording
	Mode can be the combination of call mode and I/O mode (Bitwise OR)
*/
/************************************************************************/
ISXAPI_FUNC_STDCL(INT)	ISX_m3g_ResumeCh(M3GDEV dev, USHORT mode );

/************************************************************************/
/*　Function:ISX_m3g_SendDigits()
 *　Description:
 The application use the function ISX_m3g_SendDigits() to send DIGIT with the specified M3G channel. 
 When the sending direction is DIGIT_H324M and the DIGIT type is DIGIT_ALPHA_NUMERIC, the pDigitInfo 
 structure contain the sending contents and the SDK will not convert before sending. Otherwise, the SDK will 
 convert the sending content with the following table before sending.
		  -----------------------------------------------------------
			DIGIT (character)				Value after conversion (hex)
		  -----------------------------------------------------------
			'0'								0x00
			'1'								0x01
			'2'								0x02
			'3'								0x03
			'4'								0x04
			'5'								0x05
			'6'								0x06
			'7'								0x07
			'8'								0x08
			'9'								0x09
			'*'								0x0a
			'#'								0x0b
			'a'  or  'A'					0x0c
			'b'  or  'B'					0x0d
			'c'  or  'C'					0x0e
			'd'  or  'D'					0x0f
		  -----------------------------------------------------------
		  Note: The above table is valid for the DIGIT_TDM or DIGIT_IP direction. And for the DIGIT_IP direction, 
		  DIGIT can only be sent one by one.
 *	Stop Event
	M3GEV_SEND_DIGITS_CMPLT: The function completed successfully and all the digits sent.
	M3GEV_SEND_DIGITS_FAIL: The function completed unsuccessfully.
 *	Return value:	0 success;	-1 failure 
 *	Parameters:
-dev
	The M3G channel device handle returned by ISX_m3g_OpenEx( )
-pDigitInfo
	The pointer of the DIGITS information structure. Please refer to M3G_DIGIT_INFO for the details
-mode
	EV_ASYNC - asynchronous
	EV_SYNC - synchronous
-ulOperIndex
	Asynchronous operation number; when the operation is completed and the M3GEV_SEND_DIGITS_CMPLT or 
	M3GEV_SEND_DIGITS_FAIL occurs, the number can be obtained through ISX_sr_getevtoperindex() function.
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT)	ISX_m3g_SendDigits(M3GDEV dev, M3G_DIGIT_INFO *pDigitInfo,USHORT mode, UINT ulOperIndex=0);
#else
ISXAPI_FUNC_STDCL(INT)	ISX_m3g_SendDigits(M3GDEV dev, M3G_DIGIT_INFO *pDigitInfo,USHORT mode, UINT ulOperIndex);
#endif

/************************************************************************/
/*　Function:ISX_m3g_GetDigits()
 *　Description:
 	  The application use the function ISX_m3g_GetDigits() to gather digits of a M3G channel.
 	  After the action terminated, the gathered digits were written into the local buffer specified by digitp in ASCIIZ
 	  format. At present, the digits type only is DTMF and can not be other TONEs(such as MFs and user-defined TONEs).
 	  The action of gathering DIGITs can be stopped through ISX_m3g_StopCh() function.
 *	Stop Event:
	M3GEV_GET_DIGITS_CMPLT: The event indicates that the DIGITS data is received.
	M3GEV_GET_DIGITS_FAIL: The function completed unsuccessfully.
 *	Return value:	0 success;	-1 failure 
 *	Parameters:
dev 		The M3G channel device handle returned by ISX_m3g_OpenEx()
-tptp
	Points to Termination Parameter Table structure; the Termination Parameter Table composed of one or more 
	DV_TPT structures. The DV_TPT structure is used to specify all conditions of play terminated. Please refer to 
	ISX4000 VOICE User Manual for the detail of DV_TPT.
-digitp
	The pointer pointing to DIGITS information structure; please refer to ISX4000 VOICE User Manual for the detailed 
	information of DV_DIGIT.
-mode
	EV_ASYNC - asynchronous
	EV_SYNC - synchronous
-ulOperIndex
	Asynchronous operation number; when the operation is completed and the M3GEV_GET_DIGITS_CMPLT or 
	M3GEV_GET_DIGITS_FAIL occurs, the number can be obtained through ISX_sr_getevtoperindex() function.
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT)  ISX_m3g_GetDigits(M3GDEV dev, const DV_TPT *tptp, DV_DIGIT *digitp, USHORT mode, UINT ulOperIndex=0);
#else
ISXAPI_FUNC_STDCL(INT)  ISX_m3g_GetDigits(M3GDEV dev, const DV_TPT *tptp, DV_DIGIT *digitp, USHORT mode, UINT ulOperIndex);
#endif

/************************************************************************/
/*　Function:ISX_m3g_ClrDigBuf()
 *　Description:
 	The application use the function ISX_m3g_ClrDigBuf() to clear the digits buffer of the channel clearly.
 *	Return value:	0 success;	-1 failure 
 *	Parameters:
-dev 	
	Valid M3G channel device handle (returned by ISX_m3g_OpenEx())
*/
/************************************************************************/
ISXAPI_FUNC_STDCL(INT)	ISX_m3g_ClrDigBuf(M3GDEV dev);

/************************************************************************/
/*　Function:ISX_m3g_StartH245()
 *　Description:
 	The application use the function ISX_m3g_StartH245() to initiate the H.245 call of the M3G channel.
 *	Stop Event
	M3GEV_START_H245_CMPLT: The H.245 call initiated successfully.
	M3GEV_START_H245_FAIL: The H.245 call initiated unsuccessfully.
 *	Return value:	0 success;	-1 failure 
 *	Parameters:
-dev
	The M3G channel device handle returned by ISX_m3g_OpenEx( )
-pParmInfo
	points to the M3G channel parameter information structure; please refer to M3G_CHAN_PARAM for the details.
-mode
	EV_ASYNC - asynchronous
	EV_SYNC - synchronous
-ulOperIndex
	Asynchronous operation number; when the operation is completed and the events M3GEV_START_H245_CMPLT 
	or M3GEV_START_H245_FAIL occurs, the number can be obtained through ISX_sr_getevtoperindex() function.
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT)  ISX_m3g_StartH245(M3GDEV dev, M3G_CHAN_PARAM *pParmInfo, USHORT mode=EV_SYNC, UINT ulOperIndex = 0);
#else
ISXAPI_FUNC_STDCL(INT)  ISX_m3g_StartH245(M3GDEV dev, M3G_CHAN_PARAM *pParmInfo, USHORT mode, UINT ulOperIndex);
#endif

/************************************************************************/
/*　Function:ISX_m3g_StopH245()
 *　Description:
 	The application use the function ISX_m3g_StopH245() to drop the H245 call of the M3G channel.
 *	Stop Event
	M3GEV_STOP_H245_CMPLT: The H245 call dropped successfully.
	M3GEV_STOP_H245_FAIL: The H245 call dropped unsuccessfully.
 *	Return value:	0 success;	-1 failure 
 *	Parameters:
-dev
	The M3G channel device handle returned by ISX_m3g_OpenEx( )
-mode
	EV_ASYNC - asynchronous
	EV_SYNC - synchronous
-ulOperIndex
	Asynchronous operation number; when the operation is completed and the events M3GEV_STOP_H245_CMPLT 
	or M3GEV_STOP_H245_FAIL occurs, the number can be obtained through ISX_sr_getevtoperindex() function.
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT)  ISX_m3g_StopH245(M3GDEV dev, USHORT mode=EV_SYNC, UINT ulOperIndex = 0);
#else
ISXAPI_FUNC_STDCL(INT)  ISX_m3g_StopH245(M3GDEV dev, USHORT mode, UINT ulOperIndex);
#endif

/************************************************************************/
/*　Function:ISX_m3g_GetCallStatus()
 *　Description:
 	The application use the function ISX_m3g_GetCallStatus() to return the call status (including H223 link 
 	status and call progress status) after the 3G-324M call initiated. The returned status information was 
 	written into the buffer specified by pStatusInfo.
 *	Stop Event
	M3GEV_GET_CALL_STATUS_CMPLT: The call status returned successfully.
	M3GEV_GET_CALL_STATUS_FAIL: The call status returned unsuccessfully.
 *	Return value:	0 success;	-1 failure 
 *	Parameters:
-dev
	The M3G channel device handle returned by ISX_m3g_OpenEx( )
-pStatusInfo
	points to the H324M call status information structure; please refer to M3G_CALL_STATUS for the details.
-mode
	EV_ASYNC - asynchronous
	EV_SYNC - synchronous
-ulOperIndex
	Asynchronous operation number; when the operation is completed, the number can
	be obtained through ISX_sr_getevtoperindex() function.
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT)	ISX_m3g_GetCallStatus(M3GDEV dev, M3G_CALL_STATUS *pStatusInfo, USHORT mode=EV_SYNC, UINT ulOperIndex=0);
#else 
ISXAPI_FUNC_STDCL(INT)	ISX_m3g_GetCallStatus(M3GDEV dev, M3G_CALL_STATUS *pStatusInfo, USHORT mode, UINT ulOperIndex);
#endif

/************************************************************************/
/*　Function:ISX_m3g_GetMsdInfo()
 *　Description:
 	The application use the function ISX_m3g_GetMsdInfo() to return the MSD information (such as MSD signal status, 
 	local terminal type, remote terminal type and other informations) after the 3G-324M call initiated. The retrived 
 	MSD data information is written into the buffer specified by pMsdInfo.
 *	Stop Event
	M3GEV_GET_MSDINFO_CMPLT: The MSD information returned successfully.
	M3GEV_GET_MSDINFO_FAIL: The MSD information returned unsuccessfully.
 *	Return value:	0 success;	-1 failure 
 *	Parameters:
-dev
	The M3G channel device handle returned by ISX_m3g_OpenEx( )
-pMsdInfo
	points to the MSD information structure; please refer to M3G_MSD_INFO for details.
-mode
	EV_ASYNC - asynchronous
	EV_SYNC - synchronous
-ulOperIndex
	Asynchronous operation number; when the operation is completed, the number can be obtained through 
	ISX_sr_getevtoperindex() function.
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT)	ISX_m3g_GetMsdInfo(M3GDEV dev, M3G_MSD_INFO *pMsdInfo, USHORT mode=EV_SYNC, UINT ulOperIndex=0);
#else
ISXAPI_FUNC_STDCL(INT)	ISX_m3g_GetMsdInfo(M3GDEV dev, M3G_MSD_INFO *pMsdInfo, USHORT mode, UINT ulOperIndex);
#endif

/************************************************************************/
/*　Function:ISX_m3g_GetTermCaps()
 *　Description:
 	The application use the function ISX_m3g_GetTermCaps() to return the local, remote and matching TCS information 
 	(TCS data) after the 3G-324M call initiated. The returned TCS data information is written into the buffer specified 
 	by pTcsInfo. The local terminal capacity can be modified through ISX_m3g_SetParm() function.
 *	Stop Event
	M3GEV_GET_TERM_CAPS_CMPLT: The TCS information returned successfully.
	M3GEV_GET_TERM_CAPS_FAIL: The TCS information returned unsuccessfully.
 *	Return value:	0 success;	-1 failure 
 *	Parameters:
-dev 		The M3G channel device handle returned by ISX_m3g_OpenEx( )
-pTcsInfo	points to the M3G terminal capacity set information structure; please refer to M3G_TCS_INFO for details.
-mode:
				EV_ASYNC - asynchronous
				EV_SYNC - synchronous
-ulOperIndex	
	Asynchronous operation number; when the operation is completed and the events M3GEV_GET_TERM_CAPS_CMPLT 
	or M3GEV_GET_TERM_CAPS_FAIL occurs, the number can be obtained through ISX_sr_getevtoperindex() function.
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT)	ISX_m3g_GetTermCaps(M3GDEV dev, M3G_TCS_INFO *pTcsInfo, USHORT mode=EV_SYNC, UINT ulOperIndex=0);
#else
ISXAPI_FUNC_STDCL(INT)	ISX_m3g_GetTermCaps(M3GDEV dev, M3G_TCS_INFO *pTcsInfo, USHORT mode, UINT ulOperIndex);
#endif

/************************************************************************/
/*　Function:ISX_m3g_GetLCParm()
 *　Description:
 	The application use the function ISX_m3g_GetLCParm() to return the LC parameters(Logic Channel parameters) 
 	of H324M channel. The function must be called after receiving the M3GEV_LCINFO_STATUS event corresponding to 
 	the logical channel. The returned LC parameter is written into the buffer specified by pLcParam.
 *	Stop Event
M3GEV_GET_LC_PARM_CMPLT: The LC parameter returned successfully.
M3GEV_GET_LC_PARM_FAIL: The LC parameter returned unsuccessfully.
 *	Return value:	0 success;	-1 failure 
 *	Parameters:
-dev
	The M3G channel device handle returned by ISX_m3g_OpenEx( )
-LogicChanNo
	Please refer to eM3G_LC_NUMBER for the valid value of H324M logical channel number
-pLcParam
	points to the M3G logical channel parameter information structure; please refer to M3G_LC_PARAM for details.
-mode
	EV_ASYNC - asynchronous
	EV_SYNC - synchronous
-ulOperIndex
	Asynchronous operation number; when the operation is completed and the M3GEV_GET_LC_PARM_CMPLT or 
	M3GEV_GET_LC_PARM_FAIL occurs, the number can be obtained through ISX_sr_getevtoperindex() function.
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT)	ISX_m3g_GetLCParm(M3GDEV dev, eM3G_LC_NUMBER ucLogicChanNo, M3G_LC_PARAM *pLcParam, USHORT mode=EV_SYNC, UINT ulOperIndex=0);
#else
ISXAPI_FUNC_STDCL(INT)	ISX_m3g_GetLCParm(M3GDEV dev, eM3G_LC_NUMBER ucLogicChanNo, M3G_LC_PARAM *pLcParam, USHORT mode, UINT ulOperIndex);
#endif

/************************************************************************/
/*　Function:ISX_m3g_SendH245MiscCmd()
 *　Description:
 	The application use the function ISX_m3g_SendH245MiscCmd() to send MISC command to the remote of the 
 	H.245 call. The command must be sent after the H245 call initiated(namely, after the ISX_m3g_StartH245() 
 	function is successfully completed).
 *	Stop Event
	M3GEV_SEND_H245_MISC_CMD_CMPLT: The MISC command sent successfully.
	M3GEV_SEND_H245_MISC_CMD_FAIL: The MISC command sent unsuccessfully.
 *	Return value:	0 success;	-1 failure 
 *	Parameters:
-dev
	The M3G channel device handle returned by ISX_m3g_OpenEx( )
-pMiscInfo
	points to the MISC command information structure; please refer to M3G_H245_MISC_INFO for details.
-mode
	EV_ASYNC - asynchronous
	EV_SYNC - synchronous
-ulOperIndex
	Asynchronous operation number; when the operation is completed and the M3GEV_SEND_H245_MISC_CMD_CMPLT or 
	M3GEV_SEND_H245_MISC_CMD_FAIL occurs, the number can be obtained through ISX_sr_getevtoperindex() function.
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT)	ISX_m3g_SendH245MiscCmd(M3GDEV dev, M3G_H245_MISC_INFO *pMiscInfo, USHORT mode=EV_SYNC, UINT ulOperIndex=0);
#else
ISXAPI_FUNC_STDCL(INT)	ISX_m3g_SendH245MiscCmd(M3GDEV dev, M3G_H245_MISC_INFO *pMiscInfo, USHORT mode, UINT ulOperIndex);
#endif

/************************************************************************/
/*　Function:ISX_m3g_SetEvtMsk()
 *　Description:
		The application use the function ISX_m3g_SetEvtMsk() to set the channel event mask. 
		If the mask of an event is cleared, the event will not be sent to the application. 
		Please refer to Table 1 for the mask type and the default value of the event.
    -----------------------------------------------------------------------------
	Type 					Description 										Default value 
	-----------------------------------------------------------------------------
	M3GMM_DIGITS_RECEIVED 	Set whether to receive the M3GEV_DIGITS_RECEIVED event		Disable
	M3GMM_CST				Set whether to receive the M3GEV_CST event					Disable
	-----------------------------------------------------------------------------
 *	Return value:	0 success;	-1 failure 
 *	Parameters:
-dev 	
	The M3G channel device handle returned by ISX_m3g_OpenEx()
-mask 	
	Please refer to Table 1 for the event mask
-action 	Action marks:
	M3GACT_SETMSK: allows receiving the specified event, but forbids the unspecified events.
	M3GACT_ADDMSK: allows receiving the specified events.
	M3GACT_SUBMSK: does not allow receiving the specified events.
*/
/************************************************************************/
ISXAPI_FUNC_STDCL(INT)	ISX_m3g_SetEvtMsk(INT dev, UINT mask, INT action);

/************************************************************************/
/*　Function:ISX_ATM3G_TERMMSK()
 *　Description:
 	The application use the ISX_ATM3G_TERMMSK() function to return the last I/O operation terminated reason.
 *	Return value:	0 success;	-1 failure
 *	Parameters:
-dev 		
	Valid M3G channel device handle
-OperType	
	Operation type
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT)	ISX_ATM3G_TERMMSK(M3GDEV dev, INT OperType = OPER_UNKNOWN);
#else
ISXAPI_FUNC_STDCL(INT)	ISX_ATM3G_TERMMSK(M3GDEV dev, INT OperType);
#endif

/************************************************************************/
/*　Function:ISX_m3g_SetUsrAttr()
 *　Description:
 	The application use the function ISX_m3g_SetUsrAttr() to set the channel attribute 
 	(user-defined). The user attribute set by the user can be returned through the ISX_m3g_GetUsrAttr() function.
 *	Return value:	0 success;	-1 failure 
 *	Parameters:
-dev 		
	Valid M3G channel device handle
-usrattr 
	The pointer of user attribute
*/
/************************************************************************/
ISXAPI_FUNC_STDCL(INT)  ISX_m3g_SetUsrAttr(M3GDEV dev, VOID *usr_attr);

/************************************************************************/
/*　Function:ISX_m3g_GetUsrAttr()
 *　Description:
 	The application use the function ISX_m3g_GetUsrAttr() to return the user-defined attributes 
 	(the user attributes set previously through the function ISX_m3g_OpenEx() and ISX_m3g_SetUsrAttr()).
 *	Return value:	0 success;	-1 failure
 *	Parameters:
-dev 		
	The M3G device handle returned by ISX_m3g_OpenEx() or ISX_m3g_Open()
-usr_attrp 	
	The pointer for saving the user attribute address
*/
/************************************************************************/
ISXAPI_FUNC_STDCL(INT)  ISX_m3g_GetUsrAttr(M3GDEV dev, VOID  **usr_attrp);

/************************************************************************/
/*　Function:ISX_ATM3G_BUFDIGS()
 *　Description:
 	The application use the ISX_ATM3G_BUFDIGS() function to get the number of digits in 
 	the digit buffer of VOICE channel. The digit buffer has at most 31 digits and 1 NULL terminator.
 *	Return value:	0 success;	-1 failure
 *	Parameters:
-dev
	Valid M3G channel device handle
*/
/************************************************************************/
ISXAPI_FUNC_STDCL(INT)	ISX_ATM3G_BUFDIGS(M3GDEV dev);

/************************************************************************/
/*　Function:ISX_m3g_DownloadFont()
 *　Description:
 	For the text-overlay functions, the application can select using the built-in ttf or the customized 
 	ttf that downloaded on the M3G board. The application use the function ISX_m3g_DownloadFont() to download 
 	the TrueType font file of the customer to the specified M3G board.
 *	Stop Event
	M3GEV_DOWNLOADFONT_CMPLT: The font download successfully.
	M3GEV_DOWNLOADFONT_FAIL:The font download unsuccessfully.
 *	Return value:	0 success;	-1 failure
 *	Parameters:
-ucIsxNo
	Valid iSX node number, range: 0~ MAX_NODE_NUM
-ucBrdNo
	Valid M3G board number, range: 0~ MAX_M3G_BRD
-szFileName
	Points to the font file name.
-tTimeout
	timeout time during downloading, the default is -1 that the application will wait the file download completed. Unit: ms
-mode
	Synchronous/asynchronous mode:
	EV_SYNC - synchronous
	EV_ASYNC - asynchronous
-ulOperIndex
	asynchronous operation number; if the asynchronous operation mode is used, the number can be obtained through 
	ISX_sr_getevtoperindex() function when the font download is completed and the event M3GEV_DOWNLOADFONT_CMPLT occurs.
pRvr		
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT) ISX_m3g_DownloadFont(UCHAR ucIsxNo, UCHAR ucBrdNo, CHAR *pszFileName, INT tTimeout=(INT)-1, USHORT mode=EV_SYNC, UINT ulOperIndex=0, VOID* pRvr=0);
#else
ISXAPI_FUNC_STDCL(INT) ISX_m3g_DownloadFont(UCHAR ucIsxNo, UCHAR ucBrdNo, CHAR *pszFileName, INT tTimeout, USHORT mode, UINT ulOperIndex, VOID* pRvr);
#endif

/************************************************************************/
/*　Function:ISXE_m3g_CtrlToolbox()
 *　Description:
 	The application use the function ISX_m3g_CtrlToolbox() to configure the toolbox of video channel. 
 	Before use the function, the application must start the video media of the channel (namely, the function ISX_m3g_StartMedia() must be successful).
 *	Stop Event
	M3GEV_CTRLTOOLBOX_CMPLT: The toolbox configured successfully.
	M3GEV_CTRLTOOLBOX_FAIL: The toolbox configured unsuccessfully.
 *	Return value:	0 success;	-1 failure
 *	Parameters:
-dev
	The valid video channel device handle returned by ISX_m3g_OpenEx()
-ucToolboxType
	Please refer to eM3G_TOOLBOX_TYPE for the toolbox type; only after the video channel was added to the video mixer, 
	the application can configure the M3G_TOOLBOX_TYPE_VIDEOCONF.
-ucCtrlCode
	Please refer to eM3G_TOOLBOX_CTRLCODE for the toolbox control code
-pConfig
	The toolbox configuration information is specified by M3G_TOOLBOX_CONFIG structure.
-pszLogoFileName
	When the control code has M3G_VIDEO_LOGO_DOWNLOAD, pszLogoFileName is bitmap file name of the LOGO that will 
	download to the toolbox and the LOGO file name can not exceed 256 bytes. On other control code, the pointer can 
	be NULL.
-mode
	Synchronous/asynchronous mode:
	EV_SYNC - synchronous
	EV_ASYNC - asynchronous
-ulOperIndex
	asynchronous operation number; if the asynchronous operation mode is used, the number can be obtained through 
	ISX_sr_getevtoperindex() function when the control toolbox is completed and the event M3GEV_CTRLTOOLBOX_CMPLT 
	occurs.
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT) ISX_m3g_CtrlToolbox(M3GDEV dev, UCHAR ucToolboxType, UCHAR ucCtrlCode, M3G_TOOLBOX_CONFIG *pConfig, CHAR *pszLogoFileName=NULL, USHORT mode=EV_SYNC, UINT ulOperIndex=0, VOID* pRvr=0);
#else
ISXAPI_FUNC_STDCL(INT) ISX_m3g_CtrlToolbox(M3GDEV dev, UCHAR ucToolboxType, UCHAR ucCtrlCode, M3G_TOOLBOX_CONFIG *pConfig, CHAR *pszLogoFileName, USHORT mode, UINT ulOperIndex, VOID* pRvr);
#endif

/************************************************************************/
/*　Function:ISX_m3g_DownloadLogo()
 *　Description:
 The application use the function ISX_m3g_DownloadLogo( ) to download the LOGO bitmap file to the toolbox of the 
 VIDEO channel. Before use the function, the application must start the video media of the channel (namely, the 
 function ISX_m3g_StartMedia() must be successful).
 *	Stop Event
M3GEV_DOWNLOADLOGO_CMPLT: The LOGO file download successfully.
M3GEV_DOWNLOADLOGO_FAIL: The LOGO file download unsuccessfully.
 *	Return value:	0 success;	-1 failure 
 *	Parameters:
-dev
	The valid video channel device handle returned by ISX_m3g_OpenEx()
-ucToolboxType
	Please refer to eM3G_TOOLBOX_TYPE for the toolbox type; only after the video channel was added to the video mixer, 
	the application can configure the M3G_TOOLBOX_TYPE_VIDEOCONF.
-pszFileName
	Points to the LOGO bitmap filename. The length of LOGO file name can not exceed 256 bytes.
-pConfig
	LOGO configuration information is specified by M3G_LOGO_CONFIG structure. When it is NULL, only download the LOGO 
	file to toolbox but not change the configuration of toolbox. After the file downloading is completed, the LOGO will 
	displayed on default.
-mode
	Synchronous/asynchronous mode:
	EV_SYNC - synchronous (default)
	EV_ASYNC - asynchronous
-ulOperIndex
	asynchronous operation number; if the asynchronous operation mode is used, the number can be obtained through 
	ISX_sr_getevtoperindex() function when the LOGO parameter configuring is completed and the event 
	M3GEV_SETLOGOPARM_CMPLT occurs.
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT) ISX_m3g_DownloadLogo(M3GDEV dev, UCHAR ucToolboxType, CHAR *pszFileName, M3G_LOGO_CONFIG *pConfig, USHORT mode=EV_SYNC, UINT ulOperIndex=0, VOID* pRvr=0);
#else
ISXAPI_FUNC_STDCL(INT) ISX_m3g_DownloadLogo(M3GDEV dev, UCHAR ucToolboxType, CHAR *pszFileName, M3G_LOGO_CONFIG *pConfig, USHORT mode, UINT ulOperIndex, VOID* pRvr);
#endif

/************************************************************************/
/*　Function:ISX_m3g_SetLogoParm()
 *　Description:
 	The application use the function ISX_m3g_SetLogoParm() to set the LOGO attribute such as overlay position, 
 	showing, hiding or other parameters of video channel. After the LOGO file downloaded to the toolbox of video 
 	channel(please refer to ISX_m3g_DownloadLogo() function), the application can change the attributes of the LOGO. 
 	Before use the function, the application must start the video media of the channel (namely, the function 
 	ISX_m3g_StartMedia() must be successful).
 *	Stop Event
M3GEV_SETLOGOPARM_CMPLT: The LOGO attributes set successfully.
M3GEV_SETLOGOPARM_FAIL: The LOGO attributes set unsuccessfully.
 *	Return value:	0 success;	-1 failure
 *	Parameters:
-dev
	The valid video channel device handle returned by ISX_m3g_OpenEx()
-ucToolboxType
	Please refer to eM3G_TOOLBOX_TYPE for the toolbox type; only after the video channel was added to the video mixer, 
	the application can configure the M3G_TOOLBOX_TYPE_VIDEOCONF.
-pConfig
	Points to LOGO configuration information and it is M3G_LOGO_CONFIG structure. This pointer can not be NULL. The LOGO
	 is display on default.
-mode
	Synchronous/asynchronous mode:
	EV_SYNC - synchronous (default)
	EV_ASYNC - asynchronous
-ulOperIndex
	asynchronous operation number; if the asynchronous operation mode is used, the number can be obtained through 
	ISX_sr_getevtoperindex() function when the LOGO parameter setting is completed and the event M3GEV_SETLOGOPARM_CMPLT
	 occurs.
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT) ISX_m3g_SetLogoParm(M3GDEV dev, UCHAR ucToolboxType, M3G_LOGO_CONFIG *pConfig, USHORT mode=EV_SYNC, UINT ulOperIndex=0, VOID* pRvr=0);
#else
ISXAPI_FUNC_STDCL(INT) ISX_m3g_SetLogoParm(M3GDEV dev, UCHAR ucToolboxType, M3G_LOGO_CONFIG *pConfig, USHORT mode, UINT ulOperIndex, VOID* pRvr);
#endif

/************************************************************************/
/*　Function:ISX_m3g_StartTextOverlay()
 *　Description:
 	The application use the function ISX_m3g_StartTextOverlay() to start the text overlay function corresponding to ucStringId of the video channel.
 *	Stop Event
	M3GEV_STARTTEXTOVERLAY_CMPLT: The text overlay started successfully.
	M3GEV_STARTTEXTOVERLAY_FAIL: The text overlay started unsuccessfully.
 *	Return value:	0 success;	-1 failure
 *	Parameters:
dev
	The valid video channel device handle returned by ISX_m3g_OpenEx()
ucToolboxType
	Please refer to eM3G_TOOLBOX_TYPE for the toolbox type; only after the video channel was added to the video mixer,
	the application can configure the M3G_TOOLBOX_TYPE_VIDEOCONF.
ucStringId
	String ID of Text Overlay; each channel can have multiple text strings overlayed and each text string has a ID as 
	denotation; The range is 0~7;
pConfig
	Points to the M3G_TEXTOVERLAY_CONFIG structure
mode
	Synchronous/asynchronous mode:
	EV_SYNC - synchronous
	EV_ASYNC - asynchronous
ulOperIndex
	asynchronous operation number; if the asynchronous operation mode is used, the number can be obtained through 
	ISX_sr_getevtoperindex() function when the text overlay startup is completed and the event 
	M3GEV_STARTTEXTOVERLAY_CMPLT occurs.	
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT) ISX_m3g_StartTextOverlay(M3GDEV dev, UCHAR ucToolboxType, UCHAR ucStringId, M3G_TEXTOVERLAY_CONFIG *pConfig, USHORT mode=EV_SYNC, UINT ulOperIndex=0, VOID* pRvr=0);
#else
ISXAPI_FUNC_STDCL(INT) ISX_m3g_StartTextOverlay(M3GDEV dev, UCHAR ucToolboxType, UCHAR ucStringId, M3G_TEXTOVERLAY_CONFIG *pConfig, USHORT mode, UINT ulOperIndex, VOID* pRvr);
#endif

/************************************************************************/
/*　Function:ISX_m3g_StopTextOverlay()
 *　Description:
 	The application use the function ISX_m3g_StopTextOverlay() to stop the text overlay function corresponding to ucStringId of the video channel.
 *	Stop Event
M3GEV_STOPTEXTOVERLAY_CMPLT: The event text overlay stopped successfully.
M3GEV_STOPTEXTOVERLAY_FAIL: The text overlay stopped unsuccessfully.
 *	Return value:	0 success;	-1 failure
 *	Parameters:
dev
	The valid video channel device handle returned by ISX_m3g_OpenEx()
ucToolboxType
	Please refer to eM3G_TOOLBOX_TYPE for the toolbox type; only after the video channel was added to the video mixer,
	 the application can configure the M3G_TOOLBOX_TYPE_VIDEOCONF.
ucStringId
	String ID of Text Overlay; each channel can have multiple text strings overlayed and each text string has a ID as 
	denotation; The range is 0~7;
mode
	Synchronous/asynchronous mode:
	EV_SYNC - synchronous
	EV_ASYNC - asynchronous
ulOperIndex
	asynchronous operation number; if the asynchronous operation mode is used, the number can be obtained through 
	ISX_sr_getevtoperindex() function when the text overlay stop is completed and the event M3GEV_STOPTEXTOVERLAY_CMPLT 
	occurs.
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT) ISX_m3g_StopTextOverlay(M3GDEV dev, UCHAR ucToolboxType, UCHAR ucStringId, USHORT mode=EV_SYNC, UINT ulOperIndex=0, VOID* pRvr=0);
#else
ISXAPI_FUNC_STDCL(INT) ISX_m3g_StopTextOverlay(M3GDEV dev, UCHAR ucToolboxType, UCHAR ucStringId, USHORT mode, UINT ulOperIndex, VOID* pRvr);
#endif

/************************************************************************/
/*　Function:ISX_m3g_SetTextOverlayParm()
 *　Description:
 The application use the function ISX_m3g_SetTextOverlay() to modify the text overlay configuration corresponding to ucStringId of the video channel.
 *	Stop Event
M3GEV_SETTEXTOVERLAYPARM_CMPLT: The text overlay attributes set successfully.
M3GEV_SETTEXTOVERLAYPARM_FAIL: The text overlay attributes set unsuccessfully.
 *	Return value:	0 success;	-1 failure
 *	Parameters:
-dev
	The valid video channel device handle returned by ISX_m3g_OpenEx()
-ucToolboxType
	Please refer to eM3G_TOOLBOX_TYPE for the toolbox type; only after the video channel was added to the video mixer, 
	the application can configure the M3G_TOOLBOX_TYPE_VIDEOCONF.
-ucStringId
	String ID of Text Overlay; each channel can have multiple text strings overlayed and each text string has a ID as 
	denotation; The range is 0~7;
-pConfig
	Points to the M3G_TEXTOVERLAY_CONFIG structure
-mode
	Synchronous/asynchronous mode:
	EV_SYNC - synchronous
	EV_ASYNC - asynchronous
-ulOperIndex
	asynchronous operation number; if the asynchronous operation mode is used, the number can be obtained through 
	ISX_sr_getevtoperindex() function when the text overlay parameter setting is completed and the event 
	M3GEV_SETTEXTOVERLAYPARM_CMPLT occurs.
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT) ISX_m3g_SetTextOverlayParm(M3GDEV dev, UCHAR ucToolboxType, UCHAR ucStringId, M3G_TEXTOVERLAY_CONFIG *pConfig, USHORT mode=EV_SYNC, UINT ulOperIndex=0, VOID* pRvr=0);
#else
ISXAPI_FUNC_STDCL(INT) ISX_m3g_SetTextOverlayParm(M3GDEV dev, UCHAR ucToolboxType, UCHAR ucStringId, M3G_TEXTOVERLAY_CONFIG *pConfig, USHORT mode, UINT ulOperIndex, VOID* pRvr);
#endif

/************************************************************************/
/*　Function:ISX_m3g_GetTextOverlayParm()
 *　Description:
 	The application use the function ISX_m3g_GetTextOverlayParm() to returned the text overlay configuration corresponding to ucStringId of the video channel.
 *	Stop Event
M3GEV_GETTEXTOVERLAYPARM_CMPLT: The text overlay attributes returned successfully.
M3GEV_GETTEXTOVERLAYPARM_FAIL: The text overlay attributes returned unsuccessfully.
 *	Return value:	0 success;	-1 failure
 *	Parameters:
-dev
	The valid video channel device handle returned by ISX_m3g_OpenEx()
-ucToolboxType
	Please refer to eM3G_TOOLBOX_TYPE for the toolbox type; only after the video channel was added to the video mixer, 
	the application can configure the M3G_TOOLBOX_TYPE_VIDEOCONF.
-ucStringId
	String ID of Text Overlay; each channel can have multiple text strings overlayed and each text string has a ID as 
	denotation; The range is 0~7;
-pConfig
	Textoverlay configuration information that returned; Used only with the synchronous mode and is the 
	M3G_TEXTOVERLAY_CONFIG structure. On asynchronous mode, the textoverlay attributes is obtained through 
	ISX_sr_getevtdatap ().
-mode
	Synchronous/asynchronous mode:
	EV_SYNC - synchronous
	EV_ASYNC - asynchronous
-ulOperIndex
	asynchronous operation number; if the asynchronous operation mode is used, the number can be obtained through ISX_sr_getevtoperindex() function when the text overlay parameter getting is completed and the event M3GEV_GETTEXTOVERLAYPARM_CMPLT occurs.
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT) ISX_m3g_GetTextOverlayParm(M3GDEV dev, UCHAR ucToolboxType, UCHAR ucStringId, M3G_TEXTOVERLAY_CONFIG *pConfig, USHORT mode=EV_SYNC, UINT ulOperIndex=0, VOID* pRvr=0);
#else
ISXAPI_FUNC_STDCL(INT) ISX_m3g_GetTextOverlayParm(M3GDEV dev, UCHAR ucToolboxType, UCHAR ucStringId, M3G_TEXTOVERLAY_CONFIG *pConfig, USHORT mode, UINT ulOperIndex, VOID* pRvr);
#endif

/************************************************************************/
/*　Function:ISX_m3g_EstVideoConf()
 *　Description:
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT) ISX_m3g_EstVoiceConf(M3GDEV confdev, M3G_VOICECONF_CDT *in_cdt, INT numpty, M3G_VOICECONF_PARM * pConfParm, USHORT mode=EV_SYNC, UINT ulOperIndex=0, VOID* pRvr=0);
#else
ISXAPI_FUNC_STDCL(INT) ISX_m3g_EstVoiceConf(M3GDEV confdev, M3G_VOICECONF_CDT *in_cdt, INT numpty, M3G_VOICECONF_PARM * pConfParm, USHORT mode, UINT ulOperIndex, VOID* pRvr);
#endif

/************************************************************************/
/*　Function:ISX_m3g_DelVideoConf()
 *　Description: 
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT) ISX_m3g_DelVoiceConf(M3GDEV confdev, USHORT mode=EV_SYNC, UINT ulOperIndex=0, VOID* pRvr=0);
#else
ISXAPI_FUNC_STDCL(INT) ISX_m3g_DelVoiceConf(M3GDEV confdev, USHORT mode, UINT ulOperIndex, VOID* pRvr);
#endif

/************************************************************************/
/*　Function:ISX_m3g_AddToVoiceConf()
 *　Description:
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT) ISX_m3g_AddToVoiceConf(M3GDEV confdev, M3G_VOICECONF_CDT *in_cdt, USHORT mode=EV_SYNC, UINT ulOperIndex=0, VOID* pRvr=0);
#else
ISXAPI_FUNC_STDCL(INT) ISX_m3g_AddToVoiceConf(M3GDEV confdev, M3G_VOICECONF_CDT *in_cdt, USHORT mode, UINT ulOperIndex, VOID* pRvr);
#endif

/************************************************************************/
/*　Function:ISX_m3g_RemFromVoiceConf()
 *　Description: 
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT) ISX_m3g_RemFromVoiceConf(M3GDEV confdev, M3G_VOICECONF_CDT *in_cdt, USHORT mode=EV_SYNC, UINT ulOperIndex=0, VOID* pRvr=0);
#else
ISXAPI_FUNC_STDCL(INT) ISX_m3g_RemFromVoiceConf(M3GDEV confdev, M3G_VOICECONF_CDT *in_cdt, USHORT mode, UINT ulOperIndex, VOID* pRvr);
#endif

/************************************************************************/
/*　Function:ISX_m3g_SetVoiceConfCde()
 *　Description: 
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT) ISX_m3g_SetVoiceConfCde(M3GDEV confdev, M3G_VOICECONF_CDT *in_cdt, USHORT mode=EV_SYNC, UINT ulOperIndex=0, VOID* pRvr=0);
#else
ISXAPI_FUNC_STDCL(INT) ISX_m3g_SetVoiceConfCde(M3GDEV confdev, M3G_VOICECONF_CDT *in_cdt, USHORT mode, UINT ulOperIndex, VOID* pRvr);
#endif

/************************************************************************/
/*　Function:ISX_m3g_QueryVoiceConf()
 *　Description: 
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT) ISX_m3g_QueryVoiceConf(M3GDEV voicedev, VOID* pRvr=0);
#else
ISXAPI_FUNC_STDCL(INT) ISX_m3g_QueryVoiceConf(M3GDEV voicedev, VOID* pRvr);
#endif

/************************************************************************/
/*　Function:ISX_m3g_QueryVoiceConferees()
 *　Description:
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT) ISX_m3g_QueryVoiceConferees(M3GDEV confdev, INT* parties, INT n_max, VOID* pRvr=0);
#else
ISXAPI_FUNC_STDCL(INT) ISX_m3g_QueryVoiceConferees(M3GDEV confdev, INT* parties, INT n_max, VOID* pRvr);
#endif

/************************************************************************/
/*　Function:ISX_m3g_EstVideoConf()
 *　Description: 
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT) ISX_m3g_EstVideoConf(M3GDEV confdev, M3G_VIDEOCONF_CDT *in_cdt, INT numpty, M3G_VIDEOCONF_PARM* pConfParm, USHORT mode=EV_SYNC, UINT ulOperIndex=0, VOID* pRvr=0);
#else
ISXAPI_FUNC_STDCL(INT) ISX_m3g_EstVideoConf(M3GDEV confdev, M3G_VIDEOCONF_CDT *in_cdt, INT numpty, M3G_VIDEOCONF_PARM* pConfParm, USHORT mode, UINT ulOperIndex, VOID* pRvr);
#endif

/************************************************************************/
/*　Function:ISX_m3g_DelVideoConf()
 *　Description: 
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT) ISX_m3g_DelVideoConf(M3GDEV confdev, USHORT mode=EV_SYNC, UINT ulOperIndex=0, VOID* pRvr=0);
#else
ISXAPI_FUNC_STDCL(INT) ISX_m3g_DelVideoConf(M3GDEV confdev, USHORT mode, UINT ulOperIndex, VOID* pRvr);
#endif

/************************************************************************/
/*　Function:ISX_m3g_AddToVideoConf()
 *　Description: 
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT) ISX_m3g_AddToVideoConf(M3GDEV confdev, M3G_VIDEOCONF_CDT *in_cdt, USHORT mode=EV_SYNC, UINT ulOperIndex=0, VOID* pRvr=0);
#else
ISXAPI_FUNC_STDCL(INT) ISX_m3g_AddToVideoConf(M3GDEV confdev, M3G_VIDEOCONF_CDT *in_cdt, USHORT mode, UINT ulOperIndex, VOID* pRvr);
#endif

/************************************************************************/
/*　Function:ISX_m3g_RemFromVideoConf()
 *　Description: 
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT) ISX_m3g_RemFromVideoConf(M3GDEV confdev, M3G_VIDEOCONF_CDT *in_cdt, USHORT mode=EV_SYNC, UINT ulOperIndex=0, VOID* pRvr=0);
#else
ISXAPI_FUNC_STDCL(INT) ISX_m3g_RemFromVideoConf(M3GDEV confdev, M3G_VIDEOCONF_CDT *in_cdt, USHORT mode, UINT ulOperIndex, VOID* pRvr);
#endif

/************************************************************************/
/*　Function:ISX_m3g_SetVideoConfCde()
 *　Description: 
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT) ISX_m3g_SetVideoConfCde(M3GDEV confdev, M3G_VIDEOCONF_CDT *in_cdt, USHORT mode=EV_SYNC, UINT ulOperIndex=0, VOID* pRvr=0);
#else
ISXAPI_FUNC_STDCL(INT) ISX_m3g_SetVideoConfCde(M3GDEV confdev, M3G_VIDEOCONF_CDT *in_cdt, USHORT mode, UINT ulOperIndex, VOID* pRvr);
#endif

/************************************************************************/
/*　Function:ISX_m3g_CreateVideoConfMixer()
 *　Description: 
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT) ISX_m3g_CreateVideoConfMixer(M3GDEV confdev, M3G_VIDEOCONF_MIXER* pMixer, UCHAR num, USHORT mode=EV_SYNC, UINT ulOperIndex=0, VOID* pRvr=0);
#else
ISXAPI_FUNC_STDCL(INT) ISX_m3g_CreateVideoConfMixer(M3GDEV confdev, M3G_VIDEOCONF_MIXER* pMixer, UCHAR num, USHORT mode, UINT ulOperIndex, VOID* pRvr);
#endif

/************************************************************************/
/*　Function:ISX_m3g_SetVideoConfMixer()
 *　Description: 
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT) ISX_m3g_SetVideoConfMixer(M3GDEV confdev, M3G_VIDEOCONF_MIXER* pMixer, UCHAR num, USHORT mode=EV_SYNC, UINT ulOperIndex=0, VOID* pRvr=0);
#else
ISXAPI_FUNC_STDCL(INT) ISX_m3g_SetVideoConfMixer(M3GDEV confdev, M3G_VIDEOCONF_MIXER* pMixer, UCHAR num, USHORT mode, UINT ulOperIndex, VOID* pRvr);
#endif

/************************************************************************/
/*　Function:ISX_m3g_DestroyVideoConfMixer()
 *　Description: 
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT) ISX_m3g_DestroyVideoConfMixer(M3GDEV confdev, M3G_VIDEOCONF_MIXER* pMixer, UCHAR num, USHORT mode=EV_SYNC, UINT ulOperIndex=0, VOID* pRvr=0);
#else
ISXAPI_FUNC_STDCL(INT) ISX_m3g_DestroyVideoConfMixer(M3GDEV confdev, M3G_VIDEOCONF_MIXER* pMixer, UCHAR num, USHORT mode, UINT ulOperIndex, VOID* pRvr);
#endif

/************************************************************************/
/*　Function:ISX_m3g_CtrlForeground()
 *　Description: 
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT) ISX_m3g_CtrlForeground(M3GDEV confdev, UCHAR ucForegroundId, M3G_VIDEOCONF_FOREGROUND *pForeground, USHORT mode=EV_SYNC, UINT ulOperIndex=0, VOID* pRvr=0);
#else 
ISXAPI_FUNC_STDCL(INT) ISX_m3g_CtrlForeground(M3GDEV confdev, UCHAR ucForegroundId, M3G_VIDEOCONF_FOREGROUND *pForeground, USHORT mode, UINT ulOperIndex, VOID* pRvr);
#endif

/************************************************************************/
/*　Function:ISX_m3g_CtrlBackground()
 *　Description: 
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT) ISX_m3g_CtrlBackground(M3GDEV confdev, UCHAR ucBackgroundId, M3G_VIDEOCONF_BACKGROUND *pBackground, USHORT mode=EV_SYNC, UINT ulOperIndex=0, VOID* pRvr=0);
#else 
ISXAPI_FUNC_STDCL(INT) ISX_m3g_CtrlBackground(M3GDEV confdev, UCHAR ucBackgroundId, M3G_VIDEOCONF_BACKGROUND *pBackground, USHORT mode, UINT ulOperIndex, VOID* pRvr);
#endif

/************************************************************************/
/*　Function:ISX_m3g_DrawBox()
 *　Description:
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT) ISX_m3g_DrawBox(M3GDEV confdev, M3G_VIDEOCONF_BOX *pBox, USHORT mode=EV_SYNC, UINT ulOperIndex=0, VOID* pRvr=0);
#else
ISXAPI_FUNC_STDCL(INT) ISX_m3g_DrawBox(M3GDEV confdev, M3G_VIDEOCONF_BOX *pBox, USHORT mode, UINT ulOperIndex, VOID* pRvr);
#endif

/************************************************************************/
/*　Function:ISX_m3g_QueryVideoConf()
 *　Description:
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT) ISX_m3g_QueryVideoConf(M3GDEV videodev, VOID* pRvr=0);
#else
ISXAPI_FUNC_STDCL(INT) ISX_m3g_QueryVideoConf(M3GDEV videodev, VOID* pRvr);
#endif

/************************************************************************/
/*　Function:ISX_m3g_QueryVideoConferees()
 *　Description: 
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT) ISX_m3g_QueryVideoConferees(M3GDEV confdev, INT* parties, INT n_max, VOID* pRvr=0);
#else
ISXAPI_FUNC_STDCL(INT) ISX_m3g_QueryVideoConferees(M3GDEV confdev, INT* parties, INT n_max, VOID* pRvr);
#endif

/************************************************************************/
/*　Function:ISXE_m3g_SpecRecord()
 *　Description:
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT)	ISXE_m3g_SpecRecord(M3GDEV dev, DX_IOTT *iottp, const DV_TPT *tptp, M3G_XPB* xpbp=NULL, M3G_MEDIA_EX* pMediaEx=NULL, USHORT mode=EV_SYNC, UINT ulOperIndex=0, VOID* pRvr=0);
#else
ISXAPI_FUNC_STDCL(INT)	ISXE_m3g_SpecRecord(M3GDEV dev, DX_IOTT *iottp, const DV_TPT *tptp, M3G_XPB* xpbp, M3G_MEDIA_EX* pMediaEx, USHORT mode, UINT ulOperIndex, VOID* pRvr);
#endif

/************************************************************************/
/*　Function:ISXE_m3g_SpecStop()
 *　Description:
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT)	ISXE_m3g_SpecStop(M3GDEV dev, USHORT mode=EV_SYNC, UINT ulOperIndex=0, VOID* pRvr=0);
#else
ISXAPI_FUNC_STDCL(INT)	ISXE_m3g_SpecStop(M3GDEV dev, USHORT mode, UINT ulOperIndex, VOID* pRvr);
#endif

/************************************************************************/
/*　Function:ISXE_m3g_SendIFrame()
 *　Description:
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT) ISXE_m3g_SendIFrame(M3GDEV dev, USHORT mode, UINT ulOperIndex=0, VOID* pRvr=0);
#else
ISXAPI_FUNC_STDCL(INT) ISXE_m3g_SendIFrame(M3GDEV dev, USHORT mode, UINT ulOperIndex, VOID* pRvr);
#endif

/************************************************************************/
/*　Function:ISXE_m3g_adjvol()
 *　Description: 
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT) ISXE_m3g_adjvol(M3GDEV voicedev, M3G_VOICE_VOLPARM *pVolParm, USHORT mode, UINT ulOperIndex=0, VOID* pRvr=0);
#else
ISXAPI_FUNC_STDCL(INT) ISXE_m3g_adjvol(M3GDEV voicedev, M3G_VOICE_VOLPARM *pVolParm, USHORT mode, UINT ulOperIndex, VOID* pRvr);
#endif

typedef enum {
	IPCONNATTR_CLEAR_VIDEO_OUTPUT_SRCPORT,	//set M3G_CHAN_PARAM->M3G_VIDEO_OUTPUT data struct attribute for ISX_m3g_IPConnect
} eIPCONNECT_ATTR_TYPE;

/************************************************************************/
/*　Function:ISX_m3g_SetIPConnectAttribute()
 *　Description: set data struct attribute for ISX_m3g_IPConnect()
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT)	ISX_m3g_SetIPConnectAttribute(INT nAttrType, VOID *pAttrDataStru, VOID* pRvr=0);
#else
ISXAPI_FUNC_STDCL(INT)	ISX_m3g_SetIPConnectAttribute(INT nAttrType, VOID *pAttrDataStru, VOID* pRvr);
#endif

/************************************************************************/
/*　Function:ISX_m3g_IPConnect()
 *　Description: connect m3g channel from dev1 to dev2.
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT)	ISX_m3g_IPConnect(M3GDEV dev1, M3GDEV dev2, USHORT mode, UINT ulOperIndex=0, VOID* pRvr=0);
#else
ISXAPI_FUNC_STDCL(INT)	ISX_m3g_IPConnect(M3GDEV dev1, M3GDEV dev2, USHORT mode, UINT ulOperIndex, VOID* pRvr);
#endif

/************************************************************************/
/*　Function:ISX_m3g_IPConnect()
 *　Description: disconnect m3g channel from dev1 to dev2.
*/
/************************************************************************/
#ifndef EHANG_ISXAPI_STD_C
ISXAPI_FUNC_STDCL(INT)	ISX_m3g_IPDisconnect(M3GDEV dev1, M3GDEV dev2, USHORT mode, UINT ulOperIndex=0, VOID* pRvr=0);
#else
ISXAPI_FUNC_STDCL(INT)	ISX_m3g_IPDisconnect(M3GDEV dev1, M3GDEV dev2, USHORT mode, UINT ulOperIndex, VOID* pRvr);
#endif


#ifdef __cplusplus
}
#undef extern
#endif

#endif