cmctrl.h

基于h323协议的软phone

/* Media loop____________________________________________________________________________*/

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

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

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

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




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

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



/* replace exist channel with new */
RVAPI int RVCALLCONV
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 RV_TRUE if  it is and return in haReplaceChannel and hsReplaceChannel
handles of replaced  channel.
*/

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


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


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



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

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


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

RVAPI int RVCALLCONV
cmChannelSetFlowControlToZero(
             IN      HCHAN               hsChan,
         IN      RvBool flowControl);



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

RVAPI int RVCALLCONV
cmChannelGetTransportCapabilityId(
             IN      HCHAN               hsChan);

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

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


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

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


RVAPI int RVCALLCONV
cmChannelSetDestination(
         IN      HCHAN               hsChan,
         IN     cmTerminalLabel *terminalLabel);


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

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

RVAPI int RVCALLCONV
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
          );

/************************************************************************
 * cmChannelRejectReason
 * purpose: Reject incoming OpenLogicaChannel request
 * input  : hsChan      - Channel to check
 *          reason      - channel reject reason
 * return : Non-negative value on success
 *          Negative value on failure
 * remar  : Created to allow all reasons for OLC rejection.
 *          cmChannelDropReason will still work using reason 'unspecified'
 ************************************************************************/
RVAPI int RVCALLCONV cmChannelRejectReason(
    IN  HCHAN            hsChan,
    IN  cmRejectLcnReason reason);


RVAPI int RVCALLCONV
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 RVCALLCONV
cmChannelGetRequestCloseParam(  IN  HCHAN       hsChan,
                                OUT  cmCloseLcnReason *reason,
                                OUT cmQosCapability * cmQOSCapability
                               );

/* Multipoint operations_______________________________________________________________________________*/




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

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



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

RVAPI int RVCALLCONV /* negative value on failure 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 RVCALLCONV 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 RVCALLCONV cmCallGetMCAddress(
                /* get active MC address */
        IN      HCALL               hsCall,
        OUT     RvUint32*           ip,
        OUT     RvUint16*           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. */
  RvInt32 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;

    /* 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 RVCALLCONV 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[]
        );

/* 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 RVCALLCONV 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 RVCALLCONV
cmCallMultipointCommand(
          /* Send multipoint command (on or off) message */
          IN  HCALL hsCall,
          IN  RvBool isModeOn /* RV_TRUE: mp mode (on), RV_FALSE: cancel mp mode (off) */
          );


RVAPI int RVCALLCONV
cmCallMultipointStatus(
          /* Get the multipoint mode status (on or off) */
          IN  HCALL hsCall,
          OUT RvBool *isModeOn /* RV_TRUE: mp mode (on), RV_FALSE: cancel mp mode (off) */
          );


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

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


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


RVAPI
int RVCALLCONV cmChannelSetNSAPAddress(
        IN      HCHAN               hsChan,
        IN      char*               address,
        IN      int                 length,
        IN      RvBool              multicast);





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


RVAPI
RvInt32 RVCALLCONV cmChannelGetNumber(IN HCHAN hsChan);


/* This function will build a Multimedia System Control Message, and will return the node ID of the message, and
   the node ID to which the message itself (according to the messageType enumerations) should be inserted (if at
   all). the function will return 0 on success and -1 on faliure. */
RVAPI int RVCALLCONV
cmBuildMultimediaSystemControlMessage(IN  HAPP              hApp,
                                      IN  cmH245MessageType messageType,
                                      IN  int               lcn,
                                      OUT RvPvtNodeId *     messageNode,
                                      OUT RvPvtNodeId *     insertionNode);



#endif  /* CM_H */

#ifdef __cplusplus
}
#endif


#endif  /* CMCTRL_H */