caputils.c

基于h323协议的软phone

capSetFind(
       IN  cmCapStruct **capabilities,
       IN  int capTableEntryNumber
       )
{
  int i;

  for (i=0; capabilities[i]; i++)
    if (capabilities[i]->capabilityId == capTableEntryNumber)
      return capabilities[i];
  return NULL;
}




int
capDescBuild(
         /* build array of capability set */
         IN  HPVT hVal,
         IN  int termCapSetId, /* terminalCapabilitySet node id */
         IN  cmCapStruct** capabilities, /* cap names array */
         IN  int capDescSize, /* number of elements in capDesc array */
         OUT void** capDesc /* descriptors */
         )

  /*
     A: Alternative
     S: Simulaneous
     D: Descriptor
     -: null

     (capDesc)
     \/
     ---------------------------------------------------------
     | D D ..D - S S S - S S - ==>  ...  <== A A - A A A A - |
     ---------------------------------------------------------
     */

{
  int capDescId;
  int Spos=0, Apos=capDescSize, i;

  capDescId = pvtGetChild(hVal, termCapSetId, __h245(capabilityDescriptors),NULL);

  if (capDescId <0)
  {
        capDesc[0]=NULL;
        return RV_ERROR_UNKNOWN;
  }
  Spos=pvtNumChilds(hVal, capDescId)+1;
  if (Spos>capDescSize) return RV_ERROR_UNKNOWN;
  capDesc[Spos-1] = NULL; /* D delimeter */

  for (i=0; i<pvtNumChilds(hVal, capDescId); i++) {
    int capDescEntryId, capSimId, j;

    capDesc[i] = &capDesc[Spos];
    capDescEntryId = pvtGetByIndex(hVal, capDescId, i+1, NULL); /* entry */
    capSimId = pvtGetByIndex(hVal, capDescEntryId, 2, NULL); /* sim. capability */

    for (j=0; j<pvtNumChilds(hVal, capSimId); j++) {
      int k, capSimEntryId;

      capSimEntryId = pvtGetByIndex(hVal, capSimId, j+1, NULL); /* entry */
      Apos = Apos - pvtNumChilds(hVal, capSimEntryId) - 1;
      capDesc[Spos++] = &capDesc[Apos];
      if (Spos>=Apos) return RV_ERROR_UNKNOWN; /* overflow */

      for (k=0; k<pvtNumChilds(hVal, capSimEntryId); k++) {
    int capAltEntryId;
    RvInt32 capTableEntryNumber;

    capAltEntryId = pvtGetByIndex(hVal, capSimEntryId, k+1, NULL); /* entry */
    pvtGet(hVal, capAltEntryId, NULL, NULL, &capTableEntryNumber, NULL);
    capDesc[Apos+k] = (void*)capSetFind(capabilities, (int)capTableEntryNumber);
      }
      capDesc[Apos+k] = NULL;

    }
    capDesc[Spos++] = NULL;
  }

  return RV_TRUE;
}


/*_________________________________________________________________________________*/

int
capStructBuildFromStruct(
             /* build single capability entry */
             IN  HPVT hVal,
             IN  int confRootId, /* configuration root id */
             OUT int capId,
             IN  cmCapStruct *capability
             )
{
  HPST synConf = pvtGetSynTree(hVal, confRootId);
  int ret;
  int dataTypeId=-1, capDataId=-1, capsetDataId=-1;
  RvInt16 typeNameId=LAST_TOKEN;
  int iTypeNameId;

  if (!capability || capId<0) return RV_ERROR_UNKNOWN;

  if (capability->name) { /* -- name */
    dataTypeId = pvtAddRootByPath(hVal,synConf, (char *)"channels.0.dataType", 0, NULL);
    if (confGetDataType(hVal, confRootId, capability->name, dataTypeId, NULL, RV_FALSE) <0) return RV_ERROR_UNKNOWN;
    capDataId = pvtChild(hVal, dataTypeId);
  }
  else {
    if (capability->capabilityHandle <0) return RV_ERROR_UNKNOWN;
    capDataId=capability->capabilityHandle;
  }

  switch(capability->type) {
  case cmCapNonStandard:
    typeNameId = __h245(nonStandard);
    break;

  case cmCapVideo:
    switch (capability->direction) {
    case cmCapReceive: typeNameId = __h245(receiveVideoCapability); break;
    case cmCapTransmit: typeNameId = __h245(transmitVideoCapability); break;
    case cmCapReceiveAndTransmit: typeNameId = __h245(receiveAndTransmitVideoCapability); break;
    default: break;
    }
    break;

  case cmCapAudio:
    switch (capability->direction) {
    case cmCapReceive: typeNameId = __h245(receiveAudioCapability); break;
    case cmCapTransmit: typeNameId = __h245(transmitAudioCapability); break;
    case cmCapReceiveAndTransmit: typeNameId = __h245(receiveAndTransmitAudioCapability); break;
    default: break;
    }
    break;

  case cmCapData:
    switch (capability->direction) {
    case cmCapReceive: typeNameId = __h245(receiveDataApplicationCapability); break;
    case cmCapTransmit: typeNameId = __h245(transmitDataApplicationCapability); break;
    case cmCapReceiveAndTransmit: typeNameId = __h245(receiveAndTransmitDataApplicationCapability); break;
    default: break;
    }
    break;

  case cmCapUserInput:
    switch (capability->direction) {
    case cmCapReceive: typeNameId = __h245(receiveUserInputCapability); break;
    case cmCapTransmit: typeNameId = __h245(transmitUserInputCapability); break;
    case cmCapReceiveAndTransmit: typeNameId = __h245(receiveAndTransmitUserInputCapability); break;
    default: break;
    }
    break;
  case cmCapConference:
    typeNameId = __h245(conferenceCapability);
    break;
  case cmCapH235:
    typeNameId = __h245(h235SecurityCapability);
    break;
  case cmCapMaxPendingReplacementFor:
    typeNameId = __h245(maxPendingReplacementFor);
    break;
  case cmCapGeneric:
    typeNameId = __h245(genericControlCapability);
    break;
  case cmCapMultiplexedStream:
    switch (capability->direction) {
    case cmCapReceive: typeNameId = __h245(receiveMultiplexedStreamCapability); break;
    case cmCapTransmit: typeNameId = __h245(transmitMultiplexedStreamCapability); break;
    case cmCapReceiveAndTransmit: typeNameId = __h245(receiveAndTransmitMultiplexedStreamCapability); break;
    }
    break;
  case cmCapAudioTelephonyEvent:
    typeNameId = __h245(receiveRTPAudioTelephonyEventCapability);
    break;
  case cmCapAudioTone:
    typeNameId = __h245(receiveRTPAudioToneCapability);
    break;

  default: break;
  }

  if (typeNameId == LAST_TOKEN) {
    pvtDelete(hVal, dataTypeId);
    return RV_ERROR_UNKNOWN;
  }

  iTypeNameId = typeNameId;
  capsetDataId = pvtAdd(hVal, capId, iTypeNameId, 0, NULL, NULL);
  if (capsetDataId <0)
      return capsetDataId ;
  if ((ret=pvtAddChilds(hVal, capsetDataId, hVal, capDataId)) <0) return ret;
  pvtDelete(hVal, dataTypeId);
  return RV_TRUE;
}




int
capSetBuildFromStruct(
              /* Build capability table from capability structure array.
             - The capabilityId field is updated here.
             - if name != 0 then the configuration channel data definition is used.
             - if name == 0 and capabilityHandle >=0 then the specified data tree is used.
             - type and direction values shall be set.
             */
              IN  HPVT hVal,
              IN  int confRootId, /* configuration root id */
              OUT int termCapSetId, /* terminalCapabilitySet node id */
              IN  cmCapStruct** capabilities /* cap names array */
              )
{
  int capTableId, capEntryId, capId;
  int i,ret;

  if (!capabilities || termCapSetId<0) return RV_ERROR_UNKNOWN;

  capTableId = pvtAdd(hVal, termCapSetId, __h245(capabilityTable), 0, NULL, NULL);
  if (capTableId <0) return capTableId;

  for (i=1; capabilities[i-1]; i++) { /* loop all caps */
    if ( (capEntryId = pvtAdd(hVal, capTableId, 0, -556, NULL, NULL)) <0) return capEntryId;
    if ( (ret=pvtAdd(hVal, capEntryId, __h245(capabilityTableEntryNumber), i, NULL, NULL)) <0) return ret;
    capabilities[i-1]->capabilityId = i;
    if ( (capId = pvtAdd(hVal, capEntryId, __h245(capability), i, NULL, NULL)) <0) return capId;

    capStructBuildFromStruct(hVal, confRootId, capId, capabilities[i-1]);
  }

  return RV_TRUE;
}


int
capDescBuildFromStruct(
               /* build capability combinations from nested array.
              - The capabilityId shall be set to correct value, meaning
              this is called after capStructBuildFromStruct().
              */
               IN  HPVT hVal,
               OUT int termCapSetId, /* terminalCapabilitySet node id */
               IN  cmCapStruct*** capabilities[] /* cap names array */
               )
{
  int i, j, k,ret;
  int capDescId, capDescEntryId, capSimId, capSimEntryId;

  if (!capabilities || termCapSetId<0) return RV_ERROR_UNKNOWN;

  capDescId = pvtAdd(hVal, termCapSetId, __h245(capabilityDescriptors), 0, NULL, NULL);
  if (capDescId <0) return capDescId;

  for (i=0; capabilities[i]; i++) {
    if ( (capDescEntryId = pvtAdd(hVal, capDescId, 0, -556, NULL, NULL)) <0) return capDescEntryId;
    if ( (ret = pvtAdd(hVal, capDescEntryId, __h245(capabilityDescriptorNumber), i, NULL, NULL)) <0) return ret;
    if ( (capSimId = pvtAdd(hVal, capDescEntryId, __h245(simultaneousCapabilities), 0, NULL, NULL)) <0)
      return capSimId;

    for (j=0; capabilities[i][j]; j++) {
      if ( (capSimEntryId = pvtAdd(hVal, capSimId, 0, -556, NULL, NULL)) <0) return capSimEntryId;

      for (k=0; capabilities[i][j][k]; k++) {
    if ((ret=pvtAdd(hVal, capSimEntryId, 0, capabilities[i][j][k]->capabilityId, NULL, NULL)) <0)
      return ret;
      }
    }
  }

  return RV_TRUE;
}

#ifdef __cplusplus
}
#endif