/* * h323caps.cxx * * H.323 protocol handler * * Open H323 Library * * Copyright (c) 1998-2000 Equivalence Pty. Ltd. * * The contents of this file are subject to the Mozilla Public License * Version 1.0 (the "License"); you may not use this file except in * compliance with the License. You may obtain a copy of the License at * http://www.mozilla.org/MPL/ * * Software distributed under the License is distributed on an "AS IS" * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See * the License for the specific language governing rights and limitations * under the License. * * The Original Code is Open H323 Library. * * The Initial Developer of the Original Code is Equivalence Pty. Ltd. * * Portions of this code were written with the assisance of funding from * Vovida Networks, Inc. http://www.vovida.com. * * Contributor(s): ______________________________________. * * $Log: h323caps.cxx,v $ * Revision 1.15  2000/07/13 12:30:46  robertj * Fixed problems with fast start frames per packet adjustment. * * Revision 1.14  2000/07/12 10:25:37  robertj * Renamed all codecs so obvious whether software or hardware. * * Revision 1.13  2000/07/10 16:03:02  robertj * Started fixing capability set merging, still more to do. * * Revision 1.12  2000/07/04 01:16:49  robertj * Added check for capability allowed in "combinations" set, still needs more done yet. * * Revision 1.11  2000/07/02 14:08:43  craigs * Fixed problem with removing capabilities based on wildcard * * Revision 1.10  2000/06/03 03:16:39  robertj * Fixed using the wrong capability table (should be connections) for some operations. * * Revision 1.9  2000/05/30 06:53:48  robertj * Fixed bug where capability numbers in duplicate table are not identical (should be!). * * Revision 1.8  2000/05/23 11:32:37  robertj * Rewrite of capability table to combine 2 structures into one and move functionality into that class *    allowing some normalisation of usage across several applications. * Changed H323Connection so gets a copy of capabilities instead of using endponts, allows adjustments *    to be done depending on the remote client application. * * Revision 1.7  2000/05/10 04:05:34  robertj * Changed capabilities so has a function to get name of codec, instead of relying on PrintOn. * * Revision 1.6  2000/05/02 04:32:26  robertj * Fixed copyright notice comment. * * Revision 1.5  2000/04/05 19:01:12  robertj * Added function so can change desired transmit packet size. * * Revision 1.4  2000/03/22 01:29:43  robertj * Fixed default "frame" size for audio codecs, caused crash using G.711 * * Revision 1.3  2000/03/21 03:06:50  robertj * Changes to make RTP TX of exact numbers of frames in some codecs. * * Revision 1.2  2000/02/16 03:24:27  robertj * Fixed bug in clamping maximum transmit packet size in G.711 capabilities. * * Revision 1.1  1999/12/23 23:02:36  robertj * File reorganision for separating RTP from H.323 and creation of LID for VPB support. * */#include <ptlib.h>#include "h323caps.h"#include "h323.h"#include "h225.h"#include "h245.h"#define new PNEW/////////////////////////////////////////////////////////////////////////////H323Capability::H323Capability(){  assignedCapabilityNumber = 0; // Unassigned}PObject::Comparison H323Capability::Compare(const PObject & obj) const{  PAssert(obj.IsDescendant(H323Capability::Class()), PInvalidCast);  const H323Capability & other = (const H323Capability &)obj;  int mt = GetMainType();  int omt = other.GetMainType();  if (mt < omt)    return LessThan;  if (mt > omt)    return GreaterThan;  int st = GetSubType();  int ost = other.GetSubType();  if (st < ost)    return LessThan;  if (st > ost)    return GreaterThan;  return EqualTo;}void H323Capability::PrintOn(ostream & strm) const{  strm << GetFormatName();  if (assignedCapabilityNumber != 0)    strm << " <" << assignedCapabilityNumber << '>';}unsigned H323Capability::GetDefaultSessionID() const{  return 0;}void H323Capability::SetTxFramesInPacket(unsigned /*frames*/){}unsigned H323Capability::GetTxFramesInPacket() const{  return 1;}unsigned H323Capability::GetRxFramesInPacket() const{  return 1;}unsigned H323Capability::GetMaxFrameSize() const{  return 1;}#if PTRACINGconst char * const H323Capability::MainTypesNames[] = {  "Audio", "Video", "Data", "UserInput"};#endif/////////////////////////////////////////////////////////////////////////////H323Channel * H323RealTimeCapability::CreateChannel(H323Connection & connection,                                                    H323Channel::Directions dir,                                                    unsigned sessionID,                                 const H245_H2250LogicalChannelParameters * param) const{  RTP_Session * session;  if (param != NULL)    session = connection.UseSession(param->m_sessionID, param->m_mediaControlChannel);  else {    // Make a fake transmprt address from the connection so gets initialised with    // the transport type (IP, IPX, multicast etc).    H245_TransportAddress addr;    connection.GetControlChannel().SetUpTransportPDU(addr, 0);    session = connection.UseSession(sessionID, addr);  }  if (session == NULL)    return NULL;  return new H323_RTPChannel(connection, *this, dir, *session);}/////////////////////////////////////////////////////////////////////////////H323NonStandardCapabilityInfo::H323NonStandardCapabilityInfo(H323EndPoint & endpoint,                                                             const BYTE * dataPtr,                                                             PINDEX dataSize)  : fixedData(dataPtr, dataSize){  H225_H221NonStandard h221;  endpoint.SetH221NonStandardInfo(h221);  t35CountryCode = (BYTE)(unsigned)h221.m_t35CountryCode;  t35Extension = (BYTE)(unsigned)h221.m_t35Extension;  manufacturerCode = (WORD)(unsigned)h221.m_manufacturerCode;}H323NonStandardCapabilityInfo::H323NonStandardCapabilityInfo(const PString & _oid,                                                             const BYTE * dataPtr,                                                             PINDEX dataSize)  : oid(_oid),    fixedData(dataPtr, dataSize){}H323NonStandardCapabilityInfo::H323NonStandardCapabilityInfo(BYTE country,                                                             BYTE extension,                                                             WORD maufacturer,                                                             const BYTE * dataPtr,                                                             PINDEX dataSize)  : t35CountryCode(country),    t35Extension(extension),    manufacturerCode(maufacturer),    fixedData(dataPtr, dataSize){}H323NonStandardCapabilityInfo::~H323NonStandardCapabilityInfo(){}BOOL H323NonStandardCapabilityInfo::OnSendingPDU(PBYTEArray & data) const{  data = fixedData;  return data.GetSize() > 0;}BOOL H323NonStandardCapabilityInfo::OnReceivedPDU(const PBYTEArray & data){  return data == fixedData;}BOOL H323NonStandardCapabilityInfo::OnSendingNonStandardPDU(PASN_Choice & pdu,                                                            unsigned nonStandardTag) const{  PBYTEArray data;  if (!OnSendingPDU(data))    return FALSE;  pdu.SetTag(nonStandardTag);  H245_NonStandardParameter & param = (H245_NonStandardParameter &)pdu.GetObject();  if (!oid) {    param.m_nonStandardIdentifier.SetTag(H245_NonStandardIdentifier::e_object);    ((PASN_ObjectId &)param) = oid;  }  else {    param.m_nonStandardIdentifier.SetTag(H245_NonStandardIdentifier::e_h221NonStandard);    H245_NonStandardIdentifier_h221NonStandard & h221 = param.m_nonStandardIdentifier;    h221.m_t35CountryCode = (unsigned)t35CountryCode;    h221.m_t35Extension = (unsigned)t35Extension;    h221.m_manufacturerCode = (unsigned)manufacturerCode;  }  param.m_data = data;  return data.GetSize() > 0;}BOOL H323NonStandardCapabilityInfo::OnReceivedNonStandardPDU(const PASN_Choice & pdu,                                                             unsigned nonStandardTag){  if (pdu.GetTag() != nonStandardTag)    return FALSE;  const H245_NonStandardParameter & param = (const H245_NonStandardParameter &)pdu.GetObject();  if (!oid) {    if (param.m_nonStandardIdentifier.GetTag() != H245_NonStandardIdentifier::e_object)      return FALSE;    if (((PASN_ObjectId &)param) != oid)      return FALSE;  }  else {    if (param.m_nonStandardIdentifier.GetTag() != H245_NonStandardIdentifier::e_h221NonStandard)      return FALSE;    const H245_NonStandardIdentifier_h221NonStandard & h221 = param.m_nonStandardIdentifier;    if (h221.m_t35CountryCode != (unsigned)t35CountryCode)      return FALSE;    if (h221.m_t35Extension != (unsigned)t35Extension)      return FALSE;    if (h221.m_manufacturerCode != (unsigned)manufacturerCode)      return FALSE;  }  return OnReceivedPDU(param.m_data);}/////////////////////////////////////////////////////////////////////////////H323AudioCapability::H323AudioCapability(unsigned rx, unsigned tx){  rxFramesInPacket = rx;  txFramesInPacket = tx;  maxFrameSize = 8;}H323Capability::MainTypes H323AudioCapability::GetMainType() const{  return e_Audio;}unsigned H323AudioCapability::GetDefaultSessionID() const{  return RTP_Session::DefaultAudioSessionID;}void H323AudioCapability::SetTxFramesInPacket(unsigned frames){  PAssert(frames > 0, PInvalidParameter);  txFramesInPacket = frames;}unsigned H323AudioCapability::GetTxFramesInPacket() const{  return txFramesInPacket;}unsigned H323AudioCapability::GetRxFramesInPacket() const{  return rxFramesInPacket;}unsigned H323AudioCapability::GetMaxFrameSize() const{  return maxFrameSize;}BOOL H323AudioCapability::OnSendingPDU(H245_Capability & cap) const{  cap.SetTag(H245_Capability::e_receiveAudioCapability);  return OnSendingPDU((H245_AudioCapability &)cap, rxFramesInPacket);}BOOL H323AudioCapability::OnSendingPDU(H245_DataType & dataType) const{  dataType.SetTag(H245_DataType::e_audioData);  return OnSendingPDU((H245_AudioCapability &)dataType, txFramesInPacket);}BOOL H323AudioCapability::OnReceivedPDU(const H245_Capability & cap){  if (cap.GetTag() != H245_Capability::e_receiveAudioCapability &&    cap.GetTag() != H245_Capability::e_receiveAndTransmitAudioCapability)    return FALSE;  unsigned packetSize;  if (!OnReceivedPDU((const H245_AudioCapability &)cap, packetSize))    return FALSE;  // Clamp our transmit size to maximum allowed  if (txFramesInPacket > packetSize)    txFramesInPacket = packetSize;  return TRUE;}BOOL H323AudioCapability::OnReceivedPDU(const H245_DataType & dataType, BOOL receiver){  if (dataType.GetTag() != H245_DataType::e_audioData)    return FALSE;  return OnReceivedPDU((const H245_AudioCapability &)dataType, receiver ? rxFramesInPacket : txFramesInPacket);}/////////////////////////////////////////////////////////////////////////////H323NonStandardAudioCapability::H323NonStandardAudioCapability(unsigned max,                                                               unsigned desired,                                                               H323EndPoint & endpoint,                                                               const BYTE * fixedData,                                                               PINDEX dataSize)  : H323AudioCapability(max, desired),    H323NonStandardCapabilityInfo(endpoint, fixedData, dataSize){}H323NonStandardAudioCapability::H323NonStandardAudioCapability(unsigned max,                                                               unsigned desired,                                                               const PString & oid,                                                               const BYTE * fixedData,                                                               PINDEX dataSize)  : H323AudioCapability(max, desired),    H323NonStandardCapabilityInfo(oid, fixedData, dataSize){}H323NonStandardAudioCapability::H323NonStandardAudioCapability(unsigned max,                                                               unsigned desired,                                                               BYTE country,                                                               BYTE extension,                                                               WORD maufacturer,                                                               const BYTE * fixedData,                                                               PINDEX dataSize)  : H323AudioCapability(max, desired),    H323NonStandardCapabilityInfo(country, extension, maufacturer, fixedData, dataSize){}unsigned H323NonStandardAudioCapability::GetSubType() const{  return H245_AudioCapability::e_nonStandard;}BOOL H323NonStandardAudioCapability::OnSendingPDU(H245_AudioCapability & pdu,                                                  unsigned) const{  return OnSendingNonStandardPDU(pdu, H245_AudioCapability::e_nonStandard);}BOOL H323NonStandardAudioCapability::OnReceivedPDU(const H245_AudioCapability & pdu,                                                   unsigned &){  return OnReceivedNonStandardPDU(pdu, H245_AudioCapability::e_nonStandard);}/////////////////////////////////////////////////////////////////////////////H323Capability::MainTypes H323VideoCapability::GetMainType() const{  return e_Video;