IN      HCHAN                 hsChan,
		IN      INT8                  isCommand, /* 0: indication, 1: command */
		IN      INT8                  tradeoffValue); /* 0-31 trade off value */

typedef int 
    (CALLCONV *cmEvChannelMediaLoopStatusT)(
		IN      HAPPCHAN              haChan,
		IN      HCHAN                 hsChan,
		IN      cmMediaLoopStatus     status);


/* marina */
typedef int
		(CALLCONV * cmEvChannelReplaceT)(
					 IN 	HAPPCHAN	 	haChan,
					 IN 	HCHAN	 	    hsChan,
					 IN 	HAPPCHAN 	  haReplacedChannel,
					 IN 	HCHAN	 	    hsReplacedChannel

					 );
typedef		int 
    (CALLCONV * cmEvChannelFlowControlToZeroT)(
					 IN 	   HAPPCHAN	 		        haChan	,
					 IN      HCHAN               hsChan
					 );
typedef int 
    (CALLCONV * cmEvChannelMiscCommandT)(
					 IN 	   HAPPCHAN	 		        haChan	,
					 IN      HCHAN               hsChan,
					 IN		 cmMiscellaneousCommand miscCommand
					 );

typedef int 
    (CALLCONV * cmEvChannelTransportCapIndT)(
					 IN 	   HAPPCHAN	 		        haChan	,
					 IN      HCHAN               hsChan,
					 IN		 int nodeId
					 );


typedef int 
        (CALLCONV *cmEvChannelSetNSAPAddressT)(
		IN      HAPPCHAN    	haChan,
		IN      HCHAN           	hsChan,
		IN      char*               	address,
		IN      int                   	length,
                IN      BOOL                    multicast);



typedef int 
        (CALLCONV *cmEvChannelSetATMVCT)(
		IN      HAPPCHAN   	haChan,
		IN      HCHAN           	hsChan,
		IN      int                   	portNumber);


typedef struct 
{
  cmEvChannelStateChangedT            cmEvChannelStateChanged;
  cmEvChannelNewRateT                 cmEvChannelNewRate;
  cmEvChannelMaxSkewT                 cmEvChannelMaxSkew;
  cmEvChannelSetAddressT              cmEvChannelSetAddress;
  cmEvChannelSetRTCPAddressT          cmEvChannelSetRTCPAddress;
  cmEvChannelParametersT              cmEvChannelParameters;
  cmEvChannelRTPDynamicPayloadTypeT   cmEvChannelRTPDynamicPayloadType;
  cmEvChannelVideoFastUpdatePictureT  cmEvChannelVideoFastUpdatePicture;
  cmEvChannelVideoFastUpdateGOBT      cmEvChannelVideoFastUpdateGOB;
  cmEvChannelVideoFastUpdateMBT       cmEvChannelVideoFastUpdateMB;
  cmEvChannelHandleT                  cmEvChannelHandle;
  cmEvChannelGetRTCPAddressT          cmEvChannelGetRTCPAddress;
  cmEvChannelRequestCloseStatusT      cmEvChannelRequestCloseStatus;
  cmEvChannelTSTOT                    cmEvChannelTSTO;
  cmEvChannelMediaLoopStatusT         cmEvChannelMediaLoopStatus;
/* marina */
  cmEvChannelReplaceT                 cmEvChannelReplace;
  cmEvChannelFlowControlToZeroT       cmEvChannelFlowControlToZero;  
  cmEvChannelMiscCommandT			  cmEvChannelMiscCommand;	
  cmEvChannelTransportCapIndT		  cmEvChannelTransportCapInd;

  cmEvChannelSetNSAPAddressT      cmEvChannelSetNSAPAddress;
  cmEvChannelSetATMVCT            cmEvChannelSetATMVC;      

} SCMCHANEVENT,*CMCHANEVENT;









/* General_______________________________________________________________________________________________*/






RVAPI int CALLCONV /* Real number of channels in configuration or ERROR */
cmGetConfigChannels(
		    /* build array containing the channel names as appear in 
		       the configuration. The strings are copied into array elements */
		    IN	HAPP		    hApp,
		    IN 	int		    arraySize,
		    IN  int                 elementLength, /* sizeof each string in array */
		    OUT	char*		    array[] /* allocated with elements */
		    );

RVAPI
int CALLCONV cmSetControlEventHandler(
		IN      HAPP                hApp,
		IN      CMCONTROLEVENT      cmControlEvent,
		IN      int                 size);

RVAPI
int CALLCONV cmGetControlEventHandler(
		IN      HAPP                hApp,
		OUT      CMCONTROLEVENT      cmControlEvent,
		IN      int                 size);

#define cmSetSessionEventHandler cmSetControlEventHandler /* for backward compatability */


RVAPI
int CALLCONV cmSetChannelEventHandler(
		IN      HAPP                hApp,
		IN      CMCHANEVENT         cmChannelEvent,
		IN      int                 size);


RVAPI
int CALLCONV cmGetChannelEventHandler(
		IN      HAPP                hApp,
		OUT      CMCHANEVENT         cmChannelEvent,
		IN      int                 size);



/* returns the value-tree node id of h245 configuration root node */
RVAPI 
INT32 CALLCONV cmGetH245ConfigurationHandle(
                IN	HAPP		     hApp);



RVAPI int CALLCONV /* TRUE or ERROR */
cmH245SetNewSessionProtocol(
			    /* Set new protocol callback function in case of new protocol
			       generation under h245Session state machine */
			    IN 	HAPP	 	hApp,
			    IN  cmNewProtocolEH newProtocolCallback
			    );



/* Control Session API_______________________________________________________________________________*/





RVAPI 
int CALLCONV cmCallCreateControlSession(
		IN 	 HCALL	 	     hsCall,
                IN OUT   cmTransportAddress* addr);



RVAPI int CALLCONV 
cmCallCloseControlSession(
			  /* Close the H.245 PDL protocol tree */
			  IN     HCALL               hsCall);


RVAPI int CALLCONV 
cmCallHasControlSession(
			  /* Checks for the H.245 PDL protocol tree */
			  IN     HCALL               hsCall);

/* --- master/slave --- */


RVAPI 
int CALLCONV cmCallMasterSlaveDetermine(
					/* Start master slave determination request */
					IN 	HCALL	 	hsCall,
					IN      int             terminalType
					);
#define cmMasterSlaveDetermine cmCallMasterSlaveDetermine


RVAPI int CALLCONV /* master/slave status of this call */
cmCallMasterSlaveStatus(
			IN 	HCALL	 	hsCall
			);








/* --- capabilities --- */

RVAPI int CALLCONV /* remote terminal capability set node id, or ERROR */
cmCallGetRemoteCapabilities(
			    /* Get latest remote terminal capability message */
			    IN 	HCALL	 	hsCall
			    );

RVAPI int CALLCONV /* TRUE or ERROR */
cmCallSendCapability(
		     /* Send terminal capability set tree to remote terminal */
		     /* Note: cap tree is not deleted! */
		     IN	 HCALL hsCall,
		     IN  int termCapSet  /* local terminal capabiliy set Id */
		     );


RVAPI int CALLCONV /* new terminalCapabilitySet node id. */
cmCallCapabilitiesBuild(
			/* Build terminalCapabilitySet value tree including the capability set
			   and capability descriptors. */
			IN 	HCALL		    hsCall,
			IN      cmCapStruct*        capSet[],
			IN      cmCapStruct***      capDesc[]
			);

RVAPI int CALLCONV
cmCallCapabilitiesSend(
		       IN      HCALL               hsCall,
		       IN      cmCapStruct*        capSet[],
		       IN      cmCapStruct***      capDesc[]
		       );

RVAPI int CALLCONV
cmCallGetLocalCapabilities(
			   /* translate local caps (from CESE_OUT machine) to application structures.
			      Usage: 
			       cmCapStruct capA[capSetASize];
			       cmCapStruct *capSetA[capSetASize];
			       void* capDescA[capDescASize];
			       cmCapStruct** capSet;
			       cmCapStruct**** capDesc;
			       int i;

			       for (i=0; i<capSetASize; i++) capSetA[i] = capA+i;
			       cmCallGetLocalCapabilities(hsCall, 
			                                  capSetA, capSetSize, 
			                                  capDescA, capDescASize,
							  &capSet, &capDesc);
							  */
			   
			   IN 	   HCALL		hsCall,
			   IN      cmCapStruct*         capSetA[], /* user allocated */
			   IN      int                  capSetASize,
			   IN      void*                capDescA[], /* user allocated */
			   IN      int                  capDescASize,
			   OUT     cmCapStruct**        capSet[],
			   OUT     cmCapStruct****      capDesc[]
			   );






/* --- alive --- */

RVAPI
int CALLCONV cmCallRoundTripDelay(
				  /* Measure the round trip delay to the remote terminal */
				  /* Note: maxDelay=0 --> delay taken from configuration */
				  IN 	HCALL	 	hsCall,
				  IN    INT32           maxDelay /* maximum waiting delay in seconds */
				  );



/* --- user input --- */


RVAPI int CALLCONV
cmCallSendUserInput(
		    /* send user input msg: userInputId tree is deleted */
		    /* Note: Select one of nonStandard or userData options */
		    IN  HCALL hsCall,
		    IN  INT32 userInputId /* indication.userInput tree node id */
		    );

RVAPI int CALLCONV  /* userInput message node id or ERROR */
cmUserInputBuildNonStandard(
			    /* Build userUser message with non-standard data */
			    IN  HAPP hApp,
			    IN  cmNonStandardIdentifier *identifier,
			    IN  char *data,
			    IN  int dataLength /* in bytes */
			    );

RVAPI int CALLCONV  /* userInput message node id or ERROR */
cmUserInputBuildAlphanumeric(
			     /* Build userUser message with alphanumeric data */
			     IN  HAPP hApp,
			     IN  cmUserInputData *userData
			     );


RVAPI int CALLCONV  /* TRUE or ERROR */
cmUserInputGet(
	       /* Note: One of dataLength or userData->length is NULL (the other exists) */
	       /* Note: pointers are set to addresses in the user input value tree */
	       IN  HAPP hApp,
	       IN  INT32 userInputId,

	       /* 1) nonStandard */
	       IN  cmNonStandardIdentifier *identifier, /* user allocated */
	       IN  char *data, /* user allocated */
	       INOUT INT32 *dataLength,  /* (in bytes) IN: data allocation. OUT: correct size */
	       
	       /* 2) userData */
	       IN  cmUserInputData *userData /*.length: IN: data allocation. OUT: correct size */
	       );


/* --- request mode --- */

RVAPI int CALLCONV
cmCallRequestMode(
		  /* send request mode msg */
		  /* Note: id is deleted when function returns */
		  IN  HCALL hsCall,
		  IN  INT32 modeDescriptorsId /* (requestMode.requestedModes) */
		  );

RVAPI int CALLCONV
cmCallRequestModeAck(
		     /* Acknowledge the request */
		     IN  HCALL hsCall,
		     IN  char* responseName /* (requestModeAck.response) */
		     );

RVAPI int CALLCONV
cmCallRequestModeReject(
			/* Reject the request */
			IN  HCALL hsCall,
			IN  char* causeName /* requestModeReject.cause */
			);



RVAPI int CALLCONV/* request mode node id or ERROR */
cmRequestModeBuild(
		   /* Build request mode msg */
		   /* Note: entryId overrides name */
		   IN  HAPP hApp,
		   IN  cmReqModeEntry **modes[] /* modes matrix in preference order. NULL terminated arrays */
		   );

RVAPI int CALLCONV/* TRUE or ERROR */
cmRequestModeStructBuild(
			 /* Build request mode matrix structure from msg */
			 /* Note: entry name as in h.245 standard */
			 IN  HAPP hApp,
			 IN  INT32 descId, /* requestMode.requestedModes node id */
			 IN  cmReqModeEntry **entries, /* user allocated entries */
			 IN  int entriesSize, /* number of entries */
			 IN  void **ptrs, /* pool of pointers to construct modes */
			 IN  int ptrsSize, /* number of ptrs */

			 /* modes matrix in preference order. NULL terminated arrays */
			 OUT cmReqModeEntry ***modes[]
			 );




/* Channels____________________________________________________________________________________*/





RVAPI int CALLCONV
cmChannelGetCallHandles(
			/* Get the stack and application call handles by the channel handle */
			IN  HCHAN hsChan,
			OUT HCALL *hsCall,
			OUT HAPPCALL *haCall
			);




RVAPI int CALLCONV
cmChannelNew(
	     IN      HCALL               hsCall,
	     IN      HAPPCHAN            haChan,
	     OUT     LPHCHAN             lphsChan);

RVAPI int CALLCONV
cmChannelSetHandle(
		   /* let haChan be the new application handle of this channel */
		   IN HCHAN                    hsChan,
		   IN HAPPCHAN                 haChan);



RVAPI
int CALLCONV cmChannelOpen(
		IN      HCHAN               hsChan,
		IN      char*               channelName,
		IN      HCHAN               hsChanSameSession,
		IN      HCHAN               hsChanAssociated,
		IN      UINT32              rate);

RVAPI
int CALLCONV cmChannelOpenDynamic(
		IN      HCHAN               hsChan,
		IN      int                 dataTypeHandle, /* data type (HPVT) tree handle */
		IN      HCHAN               hsChanSameSession,
		IN      HCHAN               hsChanAssociated,
		IN      BOOL                isDynamicPaloadType);


RVAPI
int CALLCONV cmChannelOn(
		IN      HCHAN               hsChan);

RVAPI
int CALLCONV cmChannelOff(
		IN      HCHAN               hsChan);

RVAPI
int CALLCONV cmChannelAnswer(
		IN      HCHAN               hsChan);

RVAPI
int CALLCONV cmChannelDrop(
		IN      HCHAN               hsChan);

RVAPI
int CALLCONV cmChannelClose(
		 IN     HCHAN               hsChan);


RVAPI int CALLCONV
cmChannelRequestCloseReject(
			    /* Reject the request for closing the outgoing channel. */
			    IN 	HCHAN	 	hsChan
			    );


/* --- Duplex channels --- */
RVAPI
int CALLCONV cmChannelDuplex(
			     /* declare channel as duplex. Meaning full duplex. Composed of 
				two uni-directional channels in opposite directions. */
		IN      HCHAN               hsChan);