RVAPI
int CALLCONV cmChannelIsDuplex(
			       /* Returns TRUE if channel is duplex. FALSE if not. and negative value
				  in case of error */
		 IN     HCHAN               hsChan);



RVAPI
int CALLCONV cmChannelSetDuplexAddress(
				       /* Set address of duplex connection */
		 IN     HCHAN               hsChan,
		 IN     cmTransportAddress  address,
		 IN     int                 externalReferenceLength,
		 IN     char*               externalReference, /* NULL if not exists */
		 IN     BOOL                isAssociated /* TRUE if associated */
		 );

RVAPI
int CALLCONV /* actual size of external reference or ERROR */
cmChannelGetDuplexAddress(
			  /* Get address of duplex connection */
		 IN     HCHAN               hsChan,
		 OUT    cmTransportAddress* address, /* User allocated structure */
		 IN     int                 externalReferenceLength, /* size of extRef buffer */
		 OUT    char*               externalReference, /* User allocated buffer */
		 OUT    BOOL*               isAssociated /* TRUE if associated */
		 );








/* Channel commands_____________________________________________________________________________________*/








RVAPI
int CALLCONV cmChannelMaxSkew(
		IN      HCHAN               hsChan1,
		IN      HCHAN               hsChan2,
		IN      UINT32              skew);

RVAPI
int CALLCONV cmChannelFlowControl(
		IN      HCHAN               hsChan,
		IN      UINT32              rate);

RVAPI
int CALLCONV cmChannelSetAddress(
		IN      HCHAN               hsChan,
		IN      UINT32              ip,
		IN      UINT16              port);

RVAPI
int CALLCONV cmChannelSetRTCPAddress(
		IN      HCHAN               hsChan,
		IN      UINT32              ip,
		IN      UINT16              port);

RVAPI
int CALLCONV cmChannelGetOrigin(
		IN      HCHAN               hsChan,
		OUT     BOOL*               origin);

RVAPI
int CALLCONV cmChannelSetDynamicRTPPayloadType(
		IN      HCHAN           hsChan,
		IN      INT8            dynamicPayloadType);

RVAPI
int CALLCONV cmChannelVideoFastUpdatePicture(
		IN      HCHAN               hsChan);

RVAPI
int CALLCONV cmChannelVideoFastUpdateGOB(
		IN      HCHAN               hsChan,
		IN      int                 firstGOB,
		IN      int                 numberOfGOBs);

RVAPI
int CALLCONV cmChannelVideoFastUpdateMB(
		IN      HCHAN               hsChan,
		IN      int                 firstGOB,
		IN      int                 firstMB,
		IN      int                 numberOfMBs);



RVAPI int CALLCONV
cmChannelTSTOCommand(
		     /* Send temporal spatial trade off command. Request the remote terminal to change
		      the tradeoff. */
		     IN HCHAN hsChan, /* incoming channel */
		     IN int tradeoffValue /* 0-31 */
		     );

RVAPI int CALLCONV
cmChannelTSTOIndication(
		     /* Send temporal spatial trade off indication. Indicates the current tradeoff value
		      of the local terminal. */
		     IN HCHAN hsChan, /* outgoing channel */
		     IN int tradeoffValue /* 0-31 */
		     );



/* Media loop____________________________________________________________________________*/

RVAPI int CALLCONV
cmChannelMediaLoopRequest(
			  /* Request media loop on this channel */
			  IN HCHAN hsChan /* outgoing channel */
			  );

RVAPI int CALLCONV
cmChannelMediaLoopConfirm(
			  /* Confirm media loop request on this channel */
			  IN HCHAN hsChan /* incoming channel */
			  );

RVAPI int CALLCONV
cmChannelMediaLoopReject(
			 /* Reject media loop request on this channel */
			 IN HCHAN hsChan /* incoming channel */
			 );

RVAPI int CALLCONV
cmCallMediaLoopOff(
		   /* Release all media loops in this call */
		   IN HCALL hsCall
		   );




RVAPI 
int CALLCONV cmChannelSameSession(
		     /* get the same session opposite channel of hsChan */
		     IN 	HCHAN	 	    hsChan,
		     OUT 	HAPPCHAN* 	    haSameSession,
		     OUT 	HCHAN*	 	    hsSameSession
		     );

RVAPI int CALLCONV /* returns the session id for this channel */
cmChannelSessionId(
		   /* get the session id of channel */
		   IN 	HCHAN	 	    hsChan
		   );



/* replace exist channel with new */
RVAPI int CALLCONV
cmChannelReplace(
					 IN      HCHAN          hsChan, /* openning outgoing channel,that proposed to replaced exist channel*/  
					 IN      HCHAN          hsChanReplace);/* exist outgoing channel,that must be replaced */



/* check if channel is replacing  incoming exist channel
return TRUE if  it is and return in haReplaceChannel and hsReplaceChannel
handles of replaced  channel.
*/

RVAPI int CALLCONV
cmIsChannelReplace(
		     IN 	HCHAN	 	    hsChan,
		     OUT 	HAPPCHAN* 	    haReplaceChannel,
		     OUT 	HCHAN*	 	    hsReplaceChannel
		     );


/* set establishing outgoing channel hsChan dependent on base channel with handle hsChanBase*/
RVAPI int CALLCONV
cmChannelSetDependency(
		     IN      HCHAN               hsChan,
         IN      HCHAN               hsChanBase     );


/* check if channel is dependent on another channel
return TRUE if  it is and return in haBaseChannel and hsBaseChannel
handles of base channel.
*/
RVAPI int CALLCONV
cmChannelGetDependency(
					 IN 	HCHAN	 	    hsChan,
					 OUT 	HAPPCHAN* 	    haBaseChannel,
					 OUT 	HCHAN*	 	    hsBaseChannel);



RVAPI int CALLCONV
cmChannelSetT120Setup(
		     IN      HCHAN               hsChan,
         IN      cmT120SetupProcedure t120SetupProc);

RVAPI int CALLCONV
cmChannelGetT120Setup(
		     IN      HCHAN               hsChan,
         OUT      cmT120SetupProcedure *t120SetupProc);


/* set FlowControlToZero on incoming channel during establising process
  used before answering */

RVAPI int CALLCONV
cmChannelSetFlowControlToZero(
		     IN      HCHAN               hsChan,
         IN      BOOL   flowControl);



RVAPI int CALLCONV
cmChannelSetTransportCapability(
		     IN      HCHAN               hsChan,
         int transportCapId    );

RVAPI int CALLCONV
cmChannelGetTransportCapabilityId(
		     IN      HCHAN               hsChan);

RVAPI int CALLCONV
cmChannelSetRedundancyEncoding(
		     IN      HCHAN               hsChan,
         IN     cmRedundancyEncoding * redundancyEncoding);

RVAPI int CALLCONV
cmChannelGetRedundancyEncoding(
		     IN      HCHAN               hsChan,
         OUT     cmRedundancyEncoding * redundancyEncoding);


RVAPI int CALLCONV
cmChannelSetSource(
		     IN      HCHAN               hsChan,
         IN     cmTerminalLabel *terminalLabel);

RVAPI int CALLCONV
cmChannelGetSource(
		     IN      HCHAN               hsChan,
         OUT     cmTerminalLabel *terminalLabel);

/* -------------------- close logical channels ----------------- */

RVAPI int CALLCONV
cmChannelDropReason(
	      /*
		- Close outgoing channel 
		- Reject incoming channel open request
		- New: Request to close incoming channel
		- On the other side the close lcn reason is passed via rejectStateMode to the
		  cmEvChannelStateChanged callback function.		
	      */
			IN 	HCHAN	 	hsChan,
			IN  cmCloseLcnReason reason
	      );


RVAPI int CALLCONV
cmChannelRequestClose(
	      /*
		- New: Request to close incoming channel
	      */
	      IN 	HCHAN	 	hsChan,
        IN  cmCloseLcnReason reason,
        cmQosCapability * cmQOSCapability
	      );

/* get on the outgoing side request to close channel ,reason and Qos capability of remoteendpoint */
RVAPI int CALLCONV
cmChannelGetRequestCloseParam(	IN 	HCHAN	 	hsChan,
                                OUT  cmCloseLcnReason *reason,
                                OUT cmQosCapability * cmQOSCapability
                               );

/* Multipoint operations_______________________________________________________________________________*/




RVAPI int CALLCONV
cmCallStartConference(
		      /* enter call conference mode */
		      IN      HCALL               hsCall
		      );

RVAPI int CALLCONV
cmCallCancelConference(
		       /* cancel the call conference mode */
		       IN      HCALL               hsCall
		       );



RVAPI int CALLCONV
cmCallSetTerminalLabel(
		       /* Set the remote endpoint terminal label. */
		       IN      HCALL               hsCall,
		       IN      cmTerminalLabel*    terminalLabel
		       );

RVAPI int CALLCONV /* ERROR if terminal label is not defined for this terminal */
cmCallGetTerminalLabel(
		       /* Get the local endpoint terminal label. */
		       IN      HCALL               hsCall,
		       OUT     cmTerminalLabel*    terminalLabel /* user allocated */
		       );


/* When the conference becomes active, the master (MC) terminal shall call cmCallDeclareMC() to
   indicate the new conference status. */
RVAPI 
int CALLCONV cmCallDeclareMC(
			     /* declare this terminal to be the MC of the call */
		IN      HCALL               hsCall
		);




/* When the conference becomes active, this function provides the address of the Active MC. */
RVAPI 
int CALLCONV cmCallGetMCAddress(
				/* get active MC address */
		IN      HCALL               hsCall,
		IN      UINT32*             ip,
		IN      UINT16*             port
		);





typedef struct {
  HCHAN hsChan; /* outgoing: new reverse channel. incoming: keep the existing channel 
		   null: new not associated reverse channel. */

  /* ! set the following fields only for new outgoing channels */

  HCHAN hsChanAssociate; /* associate channel. FFS */

  char *channelName; /* channel name from configuration or NULL for handle setting. */
  INT32 channelDataTypeHandle; /* data type (HPVT) tree handle. channelName should be NULL. */
  
  cmTerminalLabel terminalLabel; /* Use 0xffff if label unavailable */

  char *sessionDescription;
  int sessionDescriptionLength; /* number of bytes in sessionDescription */

  cmTransportAddress rtpAddress;
  cmTransportAddress rtcpAddress;
/* marina used only in cmCallSetChannelsExt function */
  int uid; /* uniq id may be index in array.*/
  int dependency; /* uniq id of element,which describe the channel,that this channel is dependent on */
  /* if its value is equal -1 ,parameter is not used. */
  int redEncodingId; /* node id of redundancyEncoding pvt,built by user. */

} cmChannelStruct;


/* The master (MC) terminal shall use cmCallSetChannels() to force the remote terminal to open
   the indicated channels for transmit. */
RVAPI 
int CALLCONV cmCallSetChannels(
			     /* As an Active MC, set transfer channels for remote terminal */
		IN      HCALL               hsCall,
		IN      int                 channelSetSize, /* number of elements in channelSet */
		IN      cmChannelStruct     channelSet[]
		);

/*marina*/
/* The master (MC) terminal shall use cmCallSetChannels() to force the remote terminal to open
   the indicated channels for transmit.Add few parameters specified in version 3,such as redEncoding
   and sessionDependancy */

RVAPI 
int CALLCONV cmCallSetChannelsExt(
			     /* As an Active MC, set transfer channels for remote terminal */
		IN      HCALL               hsCall,
		IN      int                 channelSetSize, /* number of elements in channelSet */
		IN      cmChannelStruct     channelSet[]
		);



/*   multipoint mode set/cancel operations */

RVAPI int CALLCONV
cmCallMultipointCommand(
		  /* Send multipoint command (on or off) message */
		  IN  HCALL hsCall,
		  IN  BOOL isModeOn /* TRUE: mp mode (on), FALSE: cancel mp mode (off) */
		  );


RVAPI int CALLCONV
cmCallMultipointStatus(
		  /* Get the multipoint mode status (on or off) */
		  IN  HCALL hsCall,
		  IN  BOOL *isModeOn /* TRUE: mp mode (on), FALSE: cancel mp mode (off) */
		  );


RVAPI int CALLCONV
cmChannelSendTransportCapInd(
	     IN 	HCHAN	 	hsChan,
		 IN		int			nodeId);  /* node Id of type TransportCapability */

RVAPI int CALLCONV
cmChannelSendMiscCommand(
	     IN 	HCHAN	 	hsChan,
		 IN		cmMiscellaneousCommand miscCommand);


/* delete pvt of remote capability to reduce memory*/
RVAPI 
int CALLCONV cmFreeCapability(	IN HCALL hsCall);


RVAPI 
int CALLCONV cmChannelSetNSAPAddress(
		IN      HCHAN           	hsChan,
		IN      char*               	address,
		IN      int                   	length,
                IN      BOOL                    multicast);





RVAPI 
int CALLCONV cmChannelSetATMVC(
		IN      HCHAN           	hsChan,
		IN      int                   	portNumber);


RVAPI
INT32 CALLCONV cmChannelGetNumber(IN HCHAN hsChan);





#endif
#endif
#ifdef __cplusplus
}              
#endif