cmctrl.h

基于h323协议的软phone

                IN  HCALL       hsCall
                );


RVAPI int RVCALLCONV /* RV_TRUE or negative value on failure */
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 RVCALLCONV /* 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 RVCALLCONV
cmCallCapabilitiesSend(
               IN      HCALL               hsCall,
               IN      cmCapStruct*        capSet[],
               IN      cmCapStruct***      capDesc[]
               );

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





RVAPI int RVCALLCONV
cmCallCapabilitiesAck(
               IN HCALL hsCall);


/* --- alive --- */

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



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


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

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

RVAPI int RVCALLCONV  /* userInput message node id or negative value on failure */
cmUserInputBuildAlphanumeric(
                 /* Build userUser message with alphanumeric data */
                 IN  HAPP hApp,
                 IN  cmUserInputData *userData
                 );


RVAPI int RVCALLCONV  /* RV_TRUE or negative value on failure */
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  RvInt32 userInputId,

           /* 1) nonStandard */
           IN  cmNonStandardIdentifier *identifier, /* user allocated */
           IN  char *data, /* user allocated */
           INOUT RvInt32 *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 RVCALLCONV
cmCallRequestMode(
          /* send request mode msg */
          /* Note: id is deleted when function returns */
          IN  HCALL hsCall,
          IN  RvInt32 modeDescriptorsId /* (requestMode.requestedModes) */
          );

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

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



RVAPI int RVCALLCONV/* request mode node id or negative value on failure */
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 RVCALLCONV/* RV_TRUE or negative value on failure */
cmRequestModeStructBuild(
             /* Build request mode matrix structure from msg */
             /* Note: entry name as in h.245 standard */
             IN  HAPP hApp,
             IN  RvInt32 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 RVCALLCONV
cmChannelGetCallHandles(
            /* Get the stack and application call handles by the channel handle */
            IN  HCHAN hsChan,
            OUT HCALL *hsCall,
            OUT HAPPCALL *haCall
            );




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

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



/************************************************************************
 * cmChannelOpen
 * purpose: Opens a new logical channel using the definitions in the
 *          Stack Configuration
 * input  : hsChan              - Channel to open
 *          channelName         - Name of the Stack Configuration settings
 *                                entry for the channel to be opened
 *          hsChanSameSession   - Stack handle for channel that belongs to
 *                                the same session (may be NULL)
 *          hsChanAssociated    - Stack handle of outgoing channel that is
 *                                to be associated with the newly created one
 *                                (may be NULL).
 *          rate                - Unused. Reserved for backward compatability
 * output : none
 * return : Non-negative value on success
 *          Negative value on failure
 ************************************************************************/
RVAPI
int RVCALLCONV cmChannelOpen(
        IN      HCHAN               hsChan,
        IN      char*               channelName,
        IN      HCHAN               hsChanSameSession,
        IN      HCHAN               hsChanAssociated,
        IN      RvUint32            rate);

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


RVAPI
int RVCALLCONV cmChannelOn(
        IN      HCHAN               hsChan);

RVAPI
int RVCALLCONV cmChannelOff(
        IN      HCHAN               hsChan);

RVAPI
int RVCALLCONV cmChannelAnswer(
        IN      HCHAN               hsChan);

RVAPI
int RVCALLCONV cmChannelDrop(
        IN      HCHAN               hsChan);

RVAPI
int RVCALLCONV cmChannelClose(
         IN     HCHAN               hsChan);


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


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

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



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

RVAPI
int RVCALLCONV /* actual size of external reference or negative value on failure */
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    RvBool*               isAssociated /* RV_TRUE if associated */
         );








/* Channel commands_____________________________________________________________________________________*/








RVAPI
int RVCALLCONV cmChannelMaxSkew(
        IN      HCHAN               hsChan1,
        IN      HCHAN               hsChan2,
        IN      RvUint32            skew);

RVAPI
int RVCALLCONV cmChannelFlowControl(
        IN      HCHAN               hsChan,
        IN      RvUint32            rate);

RVAPI
int RVCALLCONV cmChannelSetAddress(
        IN      HCHAN               hsChan,
        IN      RvUint32            ip,
        IN      RvUint16            port);

RVAPI
int RVCALLCONV cmChannelSetRTCPAddress(
        IN      HCHAN               hsChan,
        IN      RvUint32            ip,
        IN      RvUint16            port);

RVAPI
int RVCALLCONV cmChannelGetOrigin(
        IN      HCHAN               hsChan,
        OUT     RvBool*               origin);

RVAPI
int RVCALLCONV cmChannelSetDynamicRTPPayloadType(
        IN      HCHAN           hsChan,
        IN      RvInt8          dynamicPayloadType);

RVAPI
int RVCALLCONV cmChannelVideoFastUpdatePicture(
        IN      HCHAN               hsChan);

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

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



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