h323caps.cxx

radius协议源码÷The Radius Stack will connect to a Radius Server. This stack implementation is built upo

}


BOOL H323VideoCapability::OnSendingPDU(H245_Capability & cap) const
{
  cap.SetTag(H245_Capability::e_receiveVideoCapability);
  return OnSendingPDU((H245_VideoCapability &)cap);
}


BOOL H323VideoCapability::OnSendingPDU(H245_DataType & dataType) const
{
  dataType.SetTag(H245_DataType::e_videoData);
  return OnSendingPDU((H245_VideoCapability &)dataType);
}


BOOL H323VideoCapability::OnReceivedPDU(const H245_Capability & cap)
{
  if (cap.GetTag() != H245_Capability::e_receiveVideoCapability &&
      cap.GetTag() != H245_Capability::e_receiveAndTransmitVideoCapability)
    return FALSE;

  return OnReceivedPDU((const H245_VideoCapability &)cap);
}


BOOL H323VideoCapability::OnReceivedPDU(const H245_DataType & dataType, BOOL)
{
  if (dataType.GetTag() != H245_DataType::e_videoData)
    return FALSE;

  return OnReceivedPDU((const H245_VideoCapability &)dataType);
}


unsigned H323VideoCapability::GetDefaultSessionID() const
{
  return RTP_Session::DefaultVideoSessionID;
}


/////////////////////////////////////////////////////////////////////////////

H323NonStandardVideoCapability::H323NonStandardVideoCapability(H323EndPoint & endpoint,
                                                               const BYTE * fixedData,
                                                               PINDEX dataSize)
  : H323NonStandardCapabilityInfo(endpoint, fixedData, dataSize)
{
}


H323NonStandardVideoCapability::H323NonStandardVideoCapability(const PString & oid,
                                                               const BYTE * fixedData,
                                                               PINDEX dataSize)
  : H323NonStandardCapabilityInfo(oid, fixedData, dataSize)
{
}


H323NonStandardVideoCapability::H323NonStandardVideoCapability(BYTE country,
                                                               BYTE extension,
                                                               WORD maufacturer,
                                                               const BYTE * fixedData,
                                                               PINDEX dataSize)
  : H323NonStandardCapabilityInfo(country, extension, maufacturer, fixedData, dataSize)
{
}


unsigned H323NonStandardVideoCapability::GetSubType() const
{
  return H245_VideoCapability::e_nonStandard;
}


BOOL H323NonStandardVideoCapability::OnSendingPDU(H245_VideoCapability & pdu) const
{
  return OnSendingNonStandardPDU(pdu, H245_VideoCapability::e_nonStandard);
}


BOOL H323NonStandardVideoCapability::OnReceivedPDU(const H245_VideoCapability & pdu)
{
  return OnReceivedNonStandardPDU(pdu, H245_VideoCapability::e_nonStandard);
}


/////////////////////////////////////////////////////////////////////////////

H323Capability::MainTypes H323DataCapability::GetMainType() const
{
  return e_Data;
}


H323Codec * H323DataCapability::CreateCodec(H323Codec::Direction) const
{
  return NULL;
}


BOOL H323DataCapability::OnSendingPDU(H245_Capability & cap) const
{
  cap.SetTag(H245_Capability::e_receiveAndTransmitDataApplicationCapability);
  return OnSendingPDU((H245_DataApplicationCapability &)cap);
}


BOOL H323DataCapability::OnSendingPDU(H245_DataType & dataType) const
{
  dataType.SetTag(H245_DataType::e_data);
  return OnSendingPDU((H245_DataApplicationCapability &)dataType);
}


BOOL H323DataCapability::OnReceivedPDU(const H245_Capability & cap)
{
  if (cap.GetTag() != H245_Capability::e_receiveDataApplicationCapability)
    return FALSE;

  return OnReceivedPDU((const H245_DataApplicationCapability &)cap);
}


BOOL H323DataCapability::OnReceivedPDU(const H245_DataType & dataType, BOOL)
{
  if (dataType.GetTag() != H245_DataType::e_data)
    return FALSE;

  return OnReceivedPDU((const H245_DataApplicationCapability &)dataType);
}


/////////////////////////////////////////////////////////////////////////////

H323NonStandardDataCapability::H323NonStandardDataCapability(H323EndPoint & endpoint,
                                                             const BYTE * fixedData,
                                                             PINDEX dataSize)
  : H323NonStandardCapabilityInfo(endpoint, fixedData, dataSize)
{
}


H323NonStandardDataCapability::H323NonStandardDataCapability(const PString & oid,
                                                             const BYTE * fixedData,
                                                             PINDEX dataSize)
  : H323NonStandardCapabilityInfo(oid, fixedData, dataSize)
{
}


H323NonStandardDataCapability::H323NonStandardDataCapability(BYTE country,
                                                             BYTE extension,
                                                             WORD maufacturer,
                                                             const BYTE * fixedData,
                                                             PINDEX dataSize)
  : H323NonStandardCapabilityInfo(country, extension, maufacturer, fixedData, dataSize)
{
}


unsigned H323NonStandardDataCapability::GetSubType() const
{
  return H245_DataApplicationCapability_application::e_nonStandard;
}


BOOL H323NonStandardDataCapability::OnSendingPDU(H245_DataApplicationCapability & pdu) const
{
  return OnSendingNonStandardPDU(pdu.m_application, H245_DataApplicationCapability_application::e_nonStandard);
}


BOOL H323NonStandardDataCapability::OnReceivedPDU(const H245_DataApplicationCapability & pdu)
{
  return OnReceivedNonStandardPDU(pdu.m_application, H245_DataApplicationCapability_application::e_nonStandard);
}


/////////////////////////////////////////////////////////////////////////////

H323_G711Capability::H323_G711Capability(Mode m, Speed s)
  : H323AudioCapability(240, 30) // 240ms max, 30ms desired
{
  mode = m;
  speed = s;
}


PObject * H323_G711Capability::Clone() const
{
  return new H323_G711Capability(mode, speed);
}


PString H323_G711Capability::GetFormatName() const
{
  static const char * const G711Name[2][2] = {
    { "G.711-ALaw-64k{sw}", "G.711-ALaw-56k{sw}" },
    { "G.711-uLaw-64k{sw}", "G.711-uLaw-56k{sw}" }
  };
  return G711Name[mode][speed];
}


static const unsigned G711SubType[2][2] = {
  { H245_AudioCapability::e_g711Alaw64k, H245_AudioCapability::e_g711Alaw56k },
  { H245_AudioCapability::e_g711Ulaw64k, H245_AudioCapability::e_g711Ulaw56k }
};


unsigned H323_G711Capability::GetSubType() const
{
  return G711SubType[mode][speed];
}


H323Codec * H323_G711Capability::CreateCodec(H323Codec::Direction direction) const
{
  unsigned packetSize = 8*(direction == H323Codec::Encoder ? txFramesInPacket : rxFramesInPacket);

  if (mode == muLaw)
    return new H323_muLawCodec(direction, speed, packetSize);
  else
    return new H323_ALawCodec(direction, speed, packetSize);
}


BOOL H323_G711Capability::OnSendingPDU(H245_AudioCapability & cap,
                                       unsigned packetSize) const
{
  cap.SetTag(G711SubType[mode][speed]);

  PASN_Integer & value = cap;
  value = packetSize;
  return TRUE;
}


BOOL H323_G711Capability::OnReceivedPDU(const H245_AudioCapability & cap,
                                        unsigned & packetSize)
{
  switch (cap.GetTag()) {
    case H245_AudioCapability::e_g711Alaw64k :
      mode = H323_G711Capability::ALaw;
      speed = H323_G711Capability::At64k;
      break;

    case H245_AudioCapability::e_g711Alaw56k :
      mode = H323_G711Capability::ALaw;
      speed = H323_G711Capability::At56k;
      break;

    case H245_AudioCapability::e_g711Ulaw64k :
      mode = H323_G711Capability::muLaw;
      speed = H323_G711Capability::At64k;
      break;

    case H245_AudioCapability::e_g711Ulaw56k :
      mode = H323_G711Capability::muLaw;
      speed = H323_G711Capability::At56k;
      break;

    default :
      return FALSE;
  }

  const PASN_Integer & value = cap;

  // Get the maximum number of milliseconds
  packetSize = value;
  return TRUE;
}


/////////////////////////////////////////////////////////////////////////////

PObject * H323_T120Capability::Clone() const
{
  return new H323_T120Capability();
}


unsigned H323_T120Capability::GetSubType() const
{
  return H245_DataApplicationCapability_application::e_t120;
}


PString H323_T120Capability::GetFormatName() const
{
  return "T.120";
}


H323Channel * H323_T120Capability::CreateChannel(H323Connection &,
                                                 H323Channel::Directions,
                                                 unsigned,
                                const H245_H2250LogicalChannelParameters *) const
{
  return NULL;
}


BOOL H323_T120Capability::OnSendingPDU(H245_DataApplicationCapability & cap) const
{
  cap.m_maxBitRate = 85000;
  cap.m_application.SetTag(H245_DataApplicationCapability_application::e_t120);
  H245_DataProtocolCapability & proto = cap.m_application;
  proto.SetTag(H245_DataProtocolCapability::e_separateLANStack);
  return TRUE;
}


BOOL H323_T120Capability::OnReceivedPDU(const H245_DataApplicationCapability & cap)
{
  if (cap.m_application.GetTag() != H245_DataApplicationCapability_application::e_t120)
    return FALSE;

  const H245_DataProtocolCapability & dataCap = cap.m_application;

  return dataCap.GetTag() == H245_DataProtocolCapability::e_separateLANStack;
}


/////////////////////////////////////////////////////////////////////////////

H323_UserInputCapability::H323_UserInputCapability(unsigned _subType)
{
  subType = _subType;
}


PObject * H323_UserInputCapability::Clone() const
{
  return new H323_UserInputCapability(subType);
}


PString H323_UserInputCapability::GetFormatName() const
{
  switch (subType) {
    case H245_UserInputCapability::e_basicString :
      return "UserInput/basicString";
    case H245_UserInputCapability::e_iA5String :
      return "UserInput/iA5String";
    case H245_UserInputCapability::e_generalString :
      return "UserInput/generalString";
    case H245_UserInputCapability::e_dtmf :
      return "UserInput/dtmf";
    case H245_UserInputCapability::e_hookflash :
      return "UserInput/hookflash";
    default :
      return psprintf("SubType(%u)", subType);
  }
}


H323Capability::MainTypes H323_UserInputCapability::GetMainType() const
{
  return e_UserInput;
}


unsigned  H323_UserInputCapability::GetSubType()  const
{
  return subType;
}


H323Channel * H323_UserInputCapability::CreateChannel(H323Connection &,
                                                      H323Channel::Directions,
                                                      unsigned,
                                                      const H245_H2250LogicalChannelParameters *) const
{
  PTRACE(1, "Codec\tCannot create UserInputCapability channel");
  return NULL;
}


H323Codec * H323_UserInputCapability::CreateCodec(H323Codec::Direction) const
{
  PTRACE(1, "Codec\tCannot create UserInputCapability codec");
  return NULL;
}


BOOL H323_UserInputCapability::OnSendingPDU(H245_Capability & pdu) const
{
  pdu.SetTag(H245_Capability::e_receiveUserInputCapability);
  H245_UserInputCapability & ui = pdu;
  ui.SetTag(subType);
  return TRUE;
}


BOOL H323_UserInputCapability::OnSendingPDU(H245_DataType &) const
{
  PTRACE(1, "Codec\tCannot have UserInputCapability in DataType");
  return FALSE;
}


BOOL H323_UserInputCapability::OnReceivedPDU(const H245_Capability & pdu)
{
  if (pdu.GetTag() != H245_Capability::e_receiveUserInputCapability)
    return FALSE;

  const H245_UserInputCapability & ui = pdu;
  subType = ui.GetTag();
  return TRUE;
}


BOOL H323_UserInputCapability::OnReceivedPDU(const H245_DataType &, BOOL)
{
  PTRACE(1, "Codec\tCannot have UserInputCapability in DataType");
  return FALSE;
}


/////////////////////////////////////////////////////////////////////////////

BOOL H323SimultaneousCapabilities::SetSize(PINDEX newSize)
{
  PINDEX oldSize = GetSize();

  if (!H323CapabilitiesListArray::SetSize(newSize))
    return FALSE;

  while (oldSize < newSize) {
    H323CapabilitiesList * list = new H323CapabilitiesList;
    // The lowest level list should not delete codecs on destruction
    list->DisallowDeleteObjects();
    SetAt(oldSize++, list);
  }

  return TRUE;
}


BOOL H323CapabilitiesSet::SetSize(PINDEX newSize)
{
  PINDEX oldSize = GetSize();

  if (!H323CapabilitiesSetArray::SetSize(newSize))
    return FALSE;

  while (oldSize < newSize)
    SetAt(oldSize++, new H323SimultaneousCapabilities);