src/h245_2.cxx

   1 //
   2 // h245_2.cxx
   3 //
   4 // Code automatically generated by asnparse.
   5 //
   6
   7 #include <ptlib.h>
   8 #include "h245.h"
   9
  10 #define new PNEW
  11
  12
  13 #if ! H323_DISABLE_H245
  14
  15 //
  16 // ArrayOf_CustomPictureFormat
  17 //
  18
  19 H245_ArrayOf_CustomPictureFormat::H245_ArrayOf_CustomPictureFormat(unsigned tag, PASN_Object::TagClass tagClass)
  20   : PASN_Array(tag, tagClass)
  21 {
  22 }
  23
  24
  25 PASN_Object * H245_ArrayOf_CustomPictureFormat::CreateObject() const
  26 {
  27   return new H245_CustomPictureFormat;
  28 }
  29
  30
  31 H245_CustomPictureFormat & H245_ArrayOf_CustomPictureFormat::operator[](PINDEX i) const
  32 {
  33   return (H245_CustomPictureFormat &)array[i];
  34 }
  35
  36
  37 PObject * H245_ArrayOf_CustomPictureFormat::Clone() const
  38 {
  39 #ifndef PASN_LEANANDMEAN
  40   PAssert(IsClass(H245_ArrayOf_CustomPictureFormat::Class()), PInvalidCast);
  41 #endif
  42   return new H245_ArrayOf_CustomPictureFormat(*this);
  43 }
  44
  45
  46 //
  47 // ArrayOf_H263VideoModeCombos
  48 //
  49
  50 H245_ArrayOf_H263VideoModeCombos::H245_ArrayOf_H263VideoModeCombos(unsigned tag, PASN_Object::TagClass tagClass)
  51   : PASN_Array(tag, tagClass)
  52 {
  53 }
  54
  55
  56 PASN_Object * H245_ArrayOf_H263VideoModeCombos::CreateObject() const
  57 {
  58   return new H245_H263VideoModeCombos;
  59 }
  60
  61
  62 H245_H263VideoModeCombos & H245_ArrayOf_H263VideoModeCombos::operator[](PINDEX i) const
  63 {
  64   return (H245_H263VideoModeCombos &)array[i];
  65 }
  66
  67
  68 PObject * H245_ArrayOf_H263VideoModeCombos::Clone() const
  69 {
  70 #ifndef PASN_LEANANDMEAN
  71   PAssert(IsClass(H245_ArrayOf_H263VideoModeCombos::Class()), PInvalidCast);
  72 #endif
  73   return new H245_ArrayOf_H263VideoModeCombos(*this);
  74 }
  75
  76
  77 //
  78 // RefPictureSelection_additionalPictureMemory
  79 //
  80
  81 H245_RefPictureSelection_additionalPictureMemory::H245_RefPictureSelection_additionalPictureMemory(unsigned tag, PASN_Object::TagClass tagClass)
  82   : PASN_Sequence(tag, tagClass, 6, TRUE, 0)
  83 {
  84   m_sqcifAdditionalPictureMemory.SetConstraints(PASN_Object::FixedConstraint, 1, 256);
  85   m_qcifAdditionalPictureMemory.SetConstraints(PASN_Object::FixedConstraint, 1, 256);
  86   m_cifAdditionalPictureMemory.SetConstraints(PASN_Object::FixedConstraint, 1, 256);
  87   m_cif4AdditionalPictureMemory.SetConstraints(PASN_Object::FixedConstraint, 1, 256);
  88   m_cif16AdditionalPictureMemory.SetConstraints(PASN_Object::FixedConstraint, 1, 256);
  89   m_bigCpfAdditionalPictureMemory.SetConstraints(PASN_Object::FixedConstraint, 1, 256);
  90 }
  91
  92
  93 #ifndef PASN_NOPRINTON
  94 void H245_RefPictureSelection_additionalPictureMemory::PrintOn(ostream & strm) const
  95 {
  96   int indent = strm.precision() + 2;
  97   strm << "{\n";
  98   if (HasOptionalField(e_sqcifAdditionalPictureMemory))
  99     strm << setw(indent+31) << "sqcifAdditionalPictureMemory = " << setprecision(indent) << m_sqcifAdditionalPictureMemory << '\n';
 100   if (HasOptionalField(e_qcifAdditionalPictureMemory))
 101     strm << setw(indent+30) << "qcifAdditionalPictureMemory = " << setprecision(indent) << m_qcifAdditionalPictureMemory << '\n';
 102   if (HasOptionalField(e_cifAdditionalPictureMemory))
 103     strm << setw(indent+29) << "cifAdditionalPictureMemory = " << setprecision(indent) << m_cifAdditionalPictureMemory << '\n';
 104   if (HasOptionalField(e_cif4AdditionalPictureMemory))
 105     strm << setw(indent+30) << "cif4AdditionalPictureMemory = " << setprecision(indent) << m_cif4AdditionalPictureMemory << '\n';
 106   if (HasOptionalField(e_cif16AdditionalPictureMemory))
 107     strm << setw(indent+31) << "cif16AdditionalPictureMemory = " << setprecision(indent) << m_cif16AdditionalPictureMemory << '\n';
 108   if (HasOptionalField(e_bigCpfAdditionalPictureMemory))
 109     strm << setw(indent+32) << "bigCpfAdditionalPictureMemory = " << setprecision(indent) << m_bigCpfAdditionalPictureMemory << '\n';
 110   strm << setw(indent-1) << setprecision(indent-2) << "}";
 111 }
 112 #endif
 113
 114
 115 PObject::Comparison H245_RefPictureSelection_additionalPictureMemory::Compare(const PObject & obj) const
 116 {
 117 #ifndef PASN_LEANANDMEAN
 118   PAssert(PIsDescendant(&obj, H245_RefPictureSelection_additionalPictureMemory), PInvalidCast);
 119 #endif
 120   const H245_RefPictureSelection_additionalPictureMemory & other = (const H245_RefPictureSelection_additionalPictureMemory &)obj;
 121
 122   Comparison result;
 123
 124   if ((result = m_sqcifAdditionalPictureMemory.Compare(other.m_sqcifAdditionalPictureMemory)) != EqualTo)
 125     return result;
 126   if ((result = m_qcifAdditionalPictureMemory.Compare(other.m_qcifAdditionalPictureMemory)) != EqualTo)
 127     return result;
 128   if ((result = m_cifAdditionalPictureMemory.Compare(other.m_cifAdditionalPictureMemory)) != EqualTo)
 129     return result;
 130   if ((result = m_cif4AdditionalPictureMemory.Compare(other.m_cif4AdditionalPictureMemory)) != EqualTo)
 131     return result;
 132   if ((result = m_cif16AdditionalPictureMemory.Compare(other.m_cif16AdditionalPictureMemory)) != EqualTo)
 133     return result;
 134   if ((result = m_bigCpfAdditionalPictureMemory.Compare(other.m_bigCpfAdditionalPictureMemory)) != EqualTo)
 135     return result;
 136
 137   return PASN_Sequence::Compare(other);
 138 }
 139
 140
 141 PINDEX H245_RefPictureSelection_additionalPictureMemory::GetDataLength() const
 142 {
 143   PINDEX length = 0;
 144   if (HasOptionalField(e_sqcifAdditionalPictureMemory))
 145     length += m_sqcifAdditionalPictureMemory.GetObjectLength();
 146   if (HasOptionalField(e_qcifAdditionalPictureMemory))
 147     length += m_qcifAdditionalPictureMemory.GetObjectLength();
 148   if (HasOptionalField(e_cifAdditionalPictureMemory))
 149     length += m_cifAdditionalPictureMemory.GetObjectLength();
 150   if (HasOptionalField(e_cif4AdditionalPictureMemory))
 151     length += m_cif4AdditionalPictureMemory.GetObjectLength();
 152   if (HasOptionalField(e_cif16AdditionalPictureMemory))
 153     length += m_cif16AdditionalPictureMemory.GetObjectLength();
 154   if (HasOptionalField(e_bigCpfAdditionalPictureMemory))
 155     length += m_bigCpfAdditionalPictureMemory.GetObjectLength();
 156   return length;
 157 }
 158
 159
 160 BOOL H245_RefPictureSelection_additionalPictureMemory::Decode(PASN_Stream & strm)
 161 {
 162   if (!PreambleDecode(strm))
 163     return FALSE;
 164
 165   if (HasOptionalField(e_sqcifAdditionalPictureMemory) && !m_sqcifAdditionalPictureMemory.Decode(strm))
 166     return FALSE;
 167   if (HasOptionalField(e_qcifAdditionalPictureMemory) && !m_qcifAdditionalPictureMemory.Decode(strm))
 168     return FALSE;
 169   if (HasOptionalField(e_cifAdditionalPictureMemory) && !m_cifAdditionalPictureMemory.Decode(strm))
 170     return FALSE;
 171   if (HasOptionalField(e_cif4AdditionalPictureMemory) && !m_cif4AdditionalPictureMemory.Decode(strm))
 172     return FALSE;
 173   if (HasOptionalField(e_cif16AdditionalPictureMemory) && !m_cif16AdditionalPictureMemory.Decode(strm))
 174     return FALSE;
 175   if (HasOptionalField(e_bigCpfAdditionalPictureMemory) && !m_bigCpfAdditionalPictureMemory.Decode(strm))
 176     return FALSE;
 177
 178   return UnknownExtensionsDecode(strm);
 179 }
 180
 181
 182 void H245_RefPictureSelection_additionalPictureMemory::Encode(PASN_Stream & strm) const
 183 {
 184   PreambleEncode(strm);
 185
 186   if (HasOptionalField(e_sqcifAdditionalPictureMemory))
 187     m_sqcifAdditionalPictureMemory.Encode(strm);
 188   if (HasOptionalField(e_qcifAdditionalPictureMemory))
 189     m_qcifAdditionalPictureMemory.Encode(strm);
 190   if (HasOptionalField(e_cifAdditionalPictureMemory))
 191     m_cifAdditionalPictureMemory.Encode(strm);
 192   if (HasOptionalField(e_cif4AdditionalPictureMemory))
 193     m_cif4AdditionalPictureMemory.Encode(strm);
 194   if (HasOptionalField(e_cif16AdditionalPictureMemory))
 195     m_cif16AdditionalPictureMemory.Encode(strm);
 196   if (HasOptionalField(e_bigCpfAdditionalPictureMemory))
 197     m_bigCpfAdditionalPictureMemory.Encode(strm);
 198
 199   UnknownExtensionsEncode(strm);
 200 }
 201
 202
 203 PObject * H245_RefPictureSelection_additionalPictureMemory::Clone() const
 204 {
 205 #ifndef PASN_LEANANDMEAN
 206   PAssert(IsClass(H245_RefPictureSelection_additionalPictureMemory::Class()), PInvalidCast);
 207 #endif
 208   return new H245_RefPictureSelection_additionalPictureMemory(*this);
 209 }
 210
 211
 212
 213 #ifndef PASN_NOPRINTON
 214 const static PASN_Names Names_H245_RefPictureSelection_videoBackChannelSend[]={
 215       {"none",0}
 216      ,{"ackMessageOnly",1}
 217      ,{"nackMessageOnly",2}
 218      ,{"ackOrNackMessageOnly",3}
 219      ,{"ackAndNackMessage",4}
 220 };
 221 #endif
 222 //
 223 // RefPictureSelection_videoBackChannelSend
 224 //
 225
 226 H245_RefPictureSelection_videoBackChannelSend::H245_RefPictureSelection_videoBackChannelSend(unsigned tag, PASN_Object::TagClass tagClass)
 227   : PASN_Choice(tag, tagClass, 5, TRUE
 228 #ifndef PASN_NOPRINTON
 229     ,(const PASN_Names *)Names_H245_RefPictureSelection_videoBackChannelSend,5
 230 #endif
 231 )
 232 {
 233 }
 234
 235
 236 BOOL H245_RefPictureSelection_videoBackChannelSend::CreateObject()
 237 {
 238   choice = (tag <= e_ackAndNackMessage) ? new PASN_Null() : NULL;
 239   return choice != NULL;
 240 }
 241
 242
 243 PObject * H245_RefPictureSelection_videoBackChannelSend::Clone() const
 244 {
 245 #ifndef PASN_LEANANDMEAN
 246   PAssert(IsClass(H245_RefPictureSelection_videoBackChannelSend::Class()), PInvalidCast);
 247 #endif
 248   return new H245_RefPictureSelection_videoBackChannelSend(*this);
 249 }
 250
 251
 252
 253 #ifndef PASN_NOPRINTON
 254 const static PASN_Names Names_H245_CustomPictureFormat_pixelAspectInformation[]={
 255       {"anyPixelAspectRatio",0}
 256      ,{"pixelAspectCode",1}
 257      ,{"extendedPAR",2}
 258 };
 259 #endif
 260 //
 261 // CustomPictureFormat_pixelAspectInformation
 262 //
 263
 264 H245_CustomPictureFormat_pixelAspectInformation::H245_CustomPictureFormat_pixelAspectInformation(unsigned tag, PASN_Object::TagClass tagClass)
 265   : PASN_Choice(tag, tagClass, 3, TRUE
 266 #ifndef PASN_NOPRINTON
 267     ,(const PASN_Names *)Names_H245_CustomPictureFormat_pixelAspectInformation,3
 268 #endif
 269 )
 270 {
 271 }
 272
 273
 274 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
 275 H245_CustomPictureFormat_pixelAspectInformation::operator H245_CustomPictureFormat_pixelAspectInformation_pixelAspectCode &() const
 276 #else
 277 H245_CustomPictureFormat_pixelAspectInformation::operator H245_CustomPictureFormat_pixelAspectInformation_pixelAspectCode &()
 278 {
 279 #ifndef PASN_LEANANDMEAN
 280   PAssert(PIsDescendant(PAssertNULL(choice), H245_CustomPictureFormat_pixelAspectInformation_pixelAspectCode), PInvalidCast);
 281 #endif
 282   return *(H245_CustomPictureFormat_pixelAspectInformation_pixelAspectCode *)choice;
 283 }
 284
 285
 286 H245_CustomPictureFormat_pixelAspectInformation::operator const H245_CustomPictureFormat_pixelAspectInformation_pixelAspectCode &() const
 287 #endif
 288 {
 289 #ifndef PASN_LEANANDMEAN
 290   PAssert(PIsDescendant(PAssertNULL(choice), H245_CustomPictureFormat_pixelAspectInformation_pixelAspectCode), PInvalidCast);
 291 #endif
 292   return *(H245_CustomPictureFormat_pixelAspectInformation_pixelAspectCode *)choice;
 293 }
 294
 295
 296 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
 297 H245_CustomPictureFormat_pixelAspectInformation::operator H245_CustomPictureFormat_pixelAspectInformation_extendedPAR &() const
 298 #else
 299 H245_CustomPictureFormat_pixelAspectInformation::operator H245_CustomPictureFormat_pixelAspectInformation_extendedPAR &()
 300 {
 301 #ifndef PASN_LEANANDMEAN
 302   PAssert(PIsDescendant(PAssertNULL(choice), H245_CustomPictureFormat_pixelAspectInformation_extendedPAR), PInvalidCast);
 303 #endif
 304   return *(H245_CustomPictureFormat_pixelAspectInformation_extendedPAR *)choice;
 305 }
 306
 307
 308 H245_CustomPictureFormat_pixelAspectInformation::operator const H245_CustomPictureFormat_pixelAspectInformation_extendedPAR &() const
 309 #endif
 310 {
 311 #ifndef PASN_LEANANDMEAN
 312   PAssert(PIsDescendant(PAssertNULL(choice), H245_CustomPictureFormat_pixelAspectInformation_extendedPAR), PInvalidCast);
 313 #endif
 314   return *(H245_CustomPictureFormat_pixelAspectInformation_extendedPAR *)choice;
 315 }
 316
 317
 318 BOOL H245_CustomPictureFormat_pixelAspectInformation::CreateObject()
 319 {
 320   switch (tag) {
 321     case e_anyPixelAspectRatio :
 322       choice = new PASN_Boolean();
 323       return TRUE;
 324     case e_pixelAspectCode :
 325       choice = new H245_CustomPictureFormat_pixelAspectInformation_pixelAspectCode();
 326       return TRUE;
 327     case e_extendedPAR :
 328       choice = new H245_CustomPictureFormat_pixelAspectInformation_extendedPAR();
 329       return TRUE;
 330   }
 331
 332   choice = NULL;
 333   return FALSE;
 334 }
 335
 336
 337 PObject * H245_CustomPictureFormat_pixelAspectInformation::Clone() const
 338 {
 339 #ifndef PASN_LEANANDMEAN
 340   PAssert(IsClass(H245_CustomPictureFormat_pixelAspectInformation::Class()), PInvalidCast);
 341 #endif
 342   return new H245_CustomPictureFormat_pixelAspectInformation(*this);
 343 }
 344
 345
 346 //
 347 // ArrayOf_H263ModeComboFlags
 348 //
 349
 350 H245_ArrayOf_H263ModeComboFlags::H245_ArrayOf_H263ModeComboFlags(unsigned tag, PASN_Object::TagClass tagClass)
 351   : PASN_Array(tag, tagClass)
 352 {
 353 }
 354
 355
 356 PASN_Object * H245_ArrayOf_H263ModeComboFlags::CreateObject() const
 357 {
 358   return new H245_H263ModeComboFlags;
 359 }
 360
 361
 362 H245_H263ModeComboFlags & H245_ArrayOf_H263ModeComboFlags::operator[](PINDEX i) const
 363 {
 364   return (H245_H263ModeComboFlags &)array[i];
 365 }
 366
 367
 368 PObject * H245_ArrayOf_H263ModeComboFlags::Clone() const
 369 {
 370 #ifndef PASN_LEANANDMEAN
 371   PAssert(IsClass(H245_ArrayOf_H263ModeComboFlags::Class()), PInvalidCast);
 372 #endif
 373   return new H245_ArrayOf_H263ModeComboFlags(*this);
 374 }
 375
 376
 377 //
 378 // AudioCapability_g7231
 379 //
 380
 381 H245_AudioCapability_g7231::H245_AudioCapability_g7231(unsigned tag, PASN_Object::TagClass tagClass)
 382   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
 383 {
 384   m_maxAl_sduAudioFrames.SetConstraints(PASN_Object::FixedConstraint, 1, 256);
 385 }
 386
 387
 388 #ifndef PASN_NOPRINTON
 389 void H245_AudioCapability_g7231::PrintOn(ostream & strm) const
 390 {
 391   int indent = strm.precision() + 2;
 392   strm << "{\n";
 393   strm << setw(indent+23) << "maxAl_sduAudioFrames = " << setprecision(indent) << m_maxAl_sduAudioFrames << '\n';
 394   strm << setw(indent+21) << "silenceSuppression = " << setprecision(indent) << m_silenceSuppression << '\n';
 395   strm << setw(indent-1) << setprecision(indent-2) << "}";
 396 }
 397 #endif
 398
 399
 400 PObject::Comparison H245_AudioCapability_g7231::Compare(const PObject & obj) const
 401 {
 402 #ifndef PASN_LEANANDMEAN
 403   PAssert(PIsDescendant(&obj, H245_AudioCapability_g7231), PInvalidCast);
 404 #endif
 405   const H245_AudioCapability_g7231 & other = (const H245_AudioCapability_g7231 &)obj;
 406
 407   Comparison result;
 408
 409   if ((result = m_maxAl_sduAudioFrames.Compare(other.m_maxAl_sduAudioFrames)) != EqualTo)
 410     return result;
 411   if ((result = m_silenceSuppression.Compare(other.m_silenceSuppression)) != EqualTo)
 412     return result;
 413
 414   return PASN_Sequence::Compare(other);
 415 }
 416
 417
 418 PINDEX H245_AudioCapability_g7231::GetDataLength() const
 419 {
 420   PINDEX length = 0;
 421   length += m_maxAl_sduAudioFrames.GetObjectLength();
 422   length += m_silenceSuppression.GetObjectLength();
 423   return length;
 424 }
 425
 426
 427 BOOL H245_AudioCapability_g7231::Decode(PASN_Stream & strm)
 428 {
 429   if (!PreambleDecode(strm))
 430     return FALSE;
 431
 432   if (!m_maxAl_sduAudioFrames.Decode(strm))
 433     return FALSE;
 434   if (!m_silenceSuppression.Decode(strm))
 435     return FALSE;
 436
 437   return UnknownExtensionsDecode(strm);
 438 }
 439
 440
 441 void H245_AudioCapability_g7231::Encode(PASN_Stream & strm) const
 442 {
 443   PreambleEncode(strm);
 444
 445   m_maxAl_sduAudioFrames.Encode(strm);
 446   m_silenceSuppression.Encode(strm);
 447
 448   UnknownExtensionsEncode(strm);
 449 }
 450
 451
 452 PObject * H245_AudioCapability_g7231::Clone() const
 453 {
 454 #ifndef PASN_LEANANDMEAN
 455   PAssert(IsClass(H245_AudioCapability_g7231::Class()), PInvalidCast);
 456 #endif
 457   return new H245_AudioCapability_g7231(*this);
 458 }
 459
 460
 461 //
 462 // G7231AnnexCCapability_g723AnnexCAudioMode
 463 //
 464
 465 H245_G7231AnnexCCapability_g723AnnexCAudioMode::H245_G7231AnnexCCapability_g723AnnexCAudioMode(unsigned tag, PASN_Object::TagClass tagClass)
 466   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
 467 {
 468   m_highRateMode0.SetConstraints(PASN_Object::FixedConstraint, 27, 78);
 469   m_highRateMode1.SetConstraints(PASN_Object::FixedConstraint, 27, 78);
 470   m_lowRateMode0.SetConstraints(PASN_Object::FixedConstraint, 23, 66);
 471   m_lowRateMode1.SetConstraints(PASN_Object::FixedConstraint, 23, 66);
 472   m_sidMode0.SetConstraints(PASN_Object::FixedConstraint, 6, 17);
 473   m_sidMode1.SetConstraints(PASN_Object::FixedConstraint, 6, 17);
 474 }
 475
 476
 477 #ifndef PASN_NOPRINTON
 478 void H245_G7231AnnexCCapability_g723AnnexCAudioMode::PrintOn(ostream & strm) const
 479 {
 480   int indent = strm.precision() + 2;
 481   strm << "{\n";
 482   strm << setw(indent+16) << "highRateMode0 = " << setprecision(indent) << m_highRateMode0 << '\n';
 483   strm << setw(indent+16) << "highRateMode1 = " << setprecision(indent) << m_highRateMode1 << '\n';
 484   strm << setw(indent+15) << "lowRateMode0 = " << setprecision(indent) << m_lowRateMode0 << '\n';
 485   strm << setw(indent+15) << "lowRateMode1 = " << setprecision(indent) << m_lowRateMode1 << '\n';
 486   strm << setw(indent+11) << "sidMode0 = " << setprecision(indent) << m_sidMode0 << '\n';
 487   strm << setw(indent+11) << "sidMode1 = " << setprecision(indent) << m_sidMode1 << '\n';
 488   strm << setw(indent-1) << setprecision(indent-2) << "}";
 489 }
 490 #endif
 491
 492
 493 PObject::Comparison H245_G7231AnnexCCapability_g723AnnexCAudioMode::Compare(const PObject & obj) const
 494 {
 495 #ifndef PASN_LEANANDMEAN
 496   PAssert(PIsDescendant(&obj, H245_G7231AnnexCCapability_g723AnnexCAudioMode), PInvalidCast);
 497 #endif
 498   const H245_G7231AnnexCCapability_g723AnnexCAudioMode & other = (const H245_G7231AnnexCCapability_g723AnnexCAudioMode &)obj;
 499
 500   Comparison result;
 501
 502   if ((result = m_highRateMode0.Compare(other.m_highRateMode0)) != EqualTo)
 503     return result;
 504   if ((result = m_highRateMode1.Compare(other.m_highRateMode1)) != EqualTo)
 505     return result;
 506   if ((result = m_lowRateMode0.Compare(other.m_lowRateMode0)) != EqualTo)
 507     return result;
 508   if ((result = m_lowRateMode1.Compare(other.m_lowRateMode1)) != EqualTo)
 509     return result;
 510   if ((result = m_sidMode0.Compare(other.m_sidMode0)) != EqualTo)
 511     return result;
 512   if ((result = m_sidMode1.Compare(other.m_sidMode1)) != EqualTo)
 513     return result;
 514
 515   return PASN_Sequence::Compare(other);
 516 }
 517
 518
 519 PINDEX H245_G7231AnnexCCapability_g723AnnexCAudioMode::GetDataLength() const
 520 {
 521   PINDEX length = 0;
 522   length += m_highRateMode0.GetObjectLength();
 523   length += m_highRateMode1.GetObjectLength();
 524   length += m_lowRateMode0.GetObjectLength();
 525   length += m_lowRateMode1.GetObjectLength();
 526   length += m_sidMode0.GetObjectLength();
 527   length += m_sidMode1.GetObjectLength();
 528   return length;
 529 }
 530
 531
 532 BOOL H245_G7231AnnexCCapability_g723AnnexCAudioMode::Decode(PASN_Stream & strm)
 533 {
 534   if (!PreambleDecode(strm))
 535     return FALSE;
 536
 537   if (!m_highRateMode0.Decode(strm))
 538     return FALSE;
 539   if (!m_highRateMode1.Decode(strm))
 540     return FALSE;
 541   if (!m_lowRateMode0.Decode(strm))
 542     return FALSE;
 543   if (!m_lowRateMode1.Decode(strm))
 544     return FALSE;
 545   if (!m_sidMode0.Decode(strm))
 546     return FALSE;
 547   if (!m_sidMode1.Decode(strm))
 548     return FALSE;
 549
 550   return UnknownExtensionsDecode(strm);
 551 }
 552
 553
 554 void H245_G7231AnnexCCapability_g723AnnexCAudioMode::Encode(PASN_Stream & strm) const
 555 {
 556   PreambleEncode(strm);
 557
 558   m_highRateMode0.Encode(strm);
 559   m_highRateMode1.Encode(strm);
 560   m_lowRateMode0.Encode(strm);
 561   m_lowRateMode1.Encode(strm);
 562   m_sidMode0.Encode(strm);
 563   m_sidMode1.Encode(strm);
 564
 565   UnknownExtensionsEncode(strm);
 566 }
 567
 568
 569 PObject * H245_G7231AnnexCCapability_g723AnnexCAudioMode::Clone() const
 570 {
 571 #ifndef PASN_LEANANDMEAN
 572   PAssert(IsClass(H245_G7231AnnexCCapability_g723AnnexCAudioMode::Class()), PInvalidCast);
 573 #endif
 574   return new H245_G7231AnnexCCapability_g723AnnexCAudioMode(*this);
 575 }
 576
 577
 578
 579 #ifndef PASN_NOPRINTON
 580 const static PASN_Names Names_H245_DataApplicationCapability_application[]={
 581       {"nonStandard",0}
 582      ,{"t120",1}
 583      ,{"dsm_cc",2}
 584      ,{"userData",3}
 585      ,{"t84",4}
 586      ,{"t434",5}
 587      ,{"h224",6}
 588      ,{"nlpid",7}
 589      ,{"dsvdControl",8}
 590      ,{"h222DataPartitioning",9}
 591      ,{"t30fax",10}
 592      ,{"t140",11}
 593      ,{"t38fax",12}
 594      ,{"genericDataCapability",13}
 595 };
 596 #endif
 597 //
 598 // DataApplicationCapability_application
 599 //
 600
 601 H245_DataApplicationCapability_application::H245_DataApplicationCapability_application(unsigned tag, PASN_Object::TagClass tagClass)
 602   : PASN_Choice(tag, tagClass, 10, TRUE
 603 #ifndef PASN_NOPRINTON
 604     ,(const PASN_Names *)Names_H245_DataApplicationCapability_application,14
 605 #endif
 606 )
 607 {
 608 }
 609
 610
 611 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
 612 H245_DataApplicationCapability_application::operator H245_NonStandardParameter &() const
 613 #else
 614 H245_DataApplicationCapability_application::operator H245_NonStandardParameter &()
 615 {
 616 #ifndef PASN_LEANANDMEAN
 617   PAssert(PIsDescendant(PAssertNULL(choice), H245_NonStandardParameter), PInvalidCast);
 618 #endif
 619   return *(H245_NonStandardParameter *)choice;
 620 }
 621
 622
 623 H245_DataApplicationCapability_application::operator const H245_NonStandardParameter &() const
 624 #endif
 625 {
 626 #ifndef PASN_LEANANDMEAN
 627   PAssert(PIsDescendant(PAssertNULL(choice), H245_NonStandardParameter), PInvalidCast);
 628 #endif
 629   return *(H245_NonStandardParameter *)choice;
 630 }
 631
 632
 633 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
 634 H245_DataApplicationCapability_application::operator H245_DataProtocolCapability &() const
 635 #else
 636 H245_DataApplicationCapability_application::operator H245_DataProtocolCapability &()
 637 {
 638 #ifndef PASN_LEANANDMEAN
 639   PAssert(PIsDescendant(PAssertNULL(choice), H245_DataProtocolCapability), PInvalidCast);
 640 #endif
 641   return *(H245_DataProtocolCapability *)choice;
 642 }
 643
 644
 645 H245_DataApplicationCapability_application::operator const H245_DataProtocolCapability &() const
 646 #endif
 647 {
 648 #ifndef PASN_LEANANDMEAN
 649   PAssert(PIsDescendant(PAssertNULL(choice), H245_DataProtocolCapability), PInvalidCast);
 650 #endif
 651   return *(H245_DataProtocolCapability *)choice;
 652 }
 653
 654
 655 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
 656 H245_DataApplicationCapability_application::operator H245_DataApplicationCapability_application_t84 &() const
 657 #else
 658 H245_DataApplicationCapability_application::operator H245_DataApplicationCapability_application_t84 &()
 659 {
 660 #ifndef PASN_LEANANDMEAN
 661   PAssert(PIsDescendant(PAssertNULL(choice), H245_DataApplicationCapability_application_t84), PInvalidCast);
 662 #endif
 663   return *(H245_DataApplicationCapability_application_t84 *)choice;
 664 }
 665
 666
 667 H245_DataApplicationCapability_application::operator const H245_DataApplicationCapability_application_t84 &() const
 668 #endif
 669 {
 670 #ifndef PASN_LEANANDMEAN
 671   PAssert(PIsDescendant(PAssertNULL(choice), H245_DataApplicationCapability_application_t84), PInvalidCast);
 672 #endif
 673   return *(H245_DataApplicationCapability_application_t84 *)choice;
 674 }
 675
 676
 677 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
 678 H245_DataApplicationCapability_application::operator H245_DataApplicationCapability_application_nlpid &() const
 679 #else
 680 H245_DataApplicationCapability_application::operator H245_DataApplicationCapability_application_nlpid &()
 681 {
 682 #ifndef PASN_LEANANDMEAN
 683   PAssert(PIsDescendant(PAssertNULL(choice), H245_DataApplicationCapability_application_nlpid), PInvalidCast);
 684 #endif
 685   return *(H245_DataApplicationCapability_application_nlpid *)choice;
 686 }
 687
 688
 689 H245_DataApplicationCapability_application::operator const H245_DataApplicationCapability_application_nlpid &() const
 690 #endif
 691 {
 692 #ifndef PASN_LEANANDMEAN
 693   PAssert(PIsDescendant(PAssertNULL(choice), H245_DataApplicationCapability_application_nlpid), PInvalidCast);
 694 #endif
 695   return *(H245_DataApplicationCapability_application_nlpid *)choice;
 696 }
 697
 698
 699 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
 700 H245_DataApplicationCapability_application::operator H245_DataApplicationCapability_application_t38fax &() const
 701 #else
 702 H245_DataApplicationCapability_application::operator H245_DataApplicationCapability_application_t38fax &()
 703 {
 704 #ifndef PASN_LEANANDMEAN
 705   PAssert(PIsDescendant(PAssertNULL(choice), H245_DataApplicationCapability_application_t38fax), PInvalidCast);
 706 #endif
 707   return *(H245_DataApplicationCapability_application_t38fax *)choice;
 708 }
 709
 710
 711 H245_DataApplicationCapability_application::operator const H245_DataApplicationCapability_application_t38fax &() const
 712 #endif
 713 {
 714 #ifndef PASN_LEANANDMEAN
 715   PAssert(PIsDescendant(PAssertNULL(choice), H245_DataApplicationCapability_application_t38fax), PInvalidCast);
 716 #endif
 717   return *(H245_DataApplicationCapability_application_t38fax *)choice;
 718 }
 719
 720
 721 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
 722 H245_DataApplicationCapability_application::operator H245_GenericCapability &() const
 723 #else
 724 H245_DataApplicationCapability_application::operator H245_GenericCapability &()
 725 {
 726 #ifndef PASN_LEANANDMEAN
 727   PAssert(PIsDescendant(PAssertNULL(choice), H245_GenericCapability), PInvalidCast);
 728 #endif
 729   return *(H245_GenericCapability *)choice;
 730 }
 731
 732
 733 H245_DataApplicationCapability_application::operator const H245_GenericCapability &() const
 734 #endif
 735 {
 736 #ifndef PASN_LEANANDMEAN
 737   PAssert(PIsDescendant(PAssertNULL(choice), H245_GenericCapability), PInvalidCast);
 738 #endif
 739   return *(H245_GenericCapability *)choice;
 740 }
 741
 742
 743 BOOL H245_DataApplicationCapability_application::CreateObject()
 744 {
 745   switch (tag) {
 746     case e_nonStandard :
 747       choice = new H245_NonStandardParameter();
 748       return TRUE;
 749     case e_t120 :
 750     case e_dsm_cc :
 751     case e_userData :
 752     case e_t434 :
 753     case e_h224 :
 754     case e_h222DataPartitioning :
 755     case e_t30fax :
 756     case e_t140 :
 757       choice = new H245_DataProtocolCapability();
 758       return TRUE;
 759     case e_t84 :
 760       choice = new H245_DataApplicationCapability_application_t84();
 761       return TRUE;
 762     case e_nlpid :
 763       choice = new H245_DataApplicationCapability_application_nlpid();
 764       return TRUE;
 765     case e_dsvdControl :
 766       choice = new PASN_Null();
 767       return TRUE;
 768     case e_t38fax :
 769       choice = new H245_DataApplicationCapability_application_t38fax();
 770       return TRUE;
 771     case e_genericDataCapability :
 772       choice = new H245_GenericCapability();
 773       return TRUE;
 774   }
 775
 776   choice = NULL;
 777   return FALSE;
 778 }
 779
 780
 781 PObject * H245_DataApplicationCapability_application::Clone() const
 782 {
 783 #ifndef PASN_LEANANDMEAN
 784   PAssert(IsClass(H245_DataApplicationCapability_application::Class()), PInvalidCast);
 785 #endif
 786   return new H245_DataApplicationCapability_application(*this);
 787 }
 788
 789
 790
 791 #ifndef PASN_NOPRINTON
 792 const static PASN_Names Names_H245_DataProtocolCapability_v76wCompression[]={
 793       {"transmitCompression",0}
 794      ,{"receiveCompression",1}
 795      ,{"transmitAndReceiveCompression",2}
 796 };
 797 #endif
 798 //
 799 // DataProtocolCapability_v76wCompression
 800 //
 801
 802 H245_DataProtocolCapability_v76wCompression::H245_DataProtocolCapability_v76wCompression(unsigned tag, PASN_Object::TagClass tagClass)
 803   : PASN_Choice(tag, tagClass, 3, TRUE
 804 #ifndef PASN_NOPRINTON
 805     ,(const PASN_Names *)Names_H245_DataProtocolCapability_v76wCompression,3
 806 #endif
 807 )
 808 {
 809 }
 810
 811
 812 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
 813 H245_DataProtocolCapability_v76wCompression::operator H245_CompressionType &() const
 814 #else
 815 H245_DataProtocolCapability_v76wCompression::operator H245_CompressionType &()
 816 {
 817 #ifndef PASN_LEANANDMEAN
 818   PAssert(PIsDescendant(PAssertNULL(choice), H245_CompressionType), PInvalidCast);
 819 #endif
 820   return *(H245_CompressionType *)choice;
 821 }
 822
 823
 824 H245_DataProtocolCapability_v76wCompression::operator const H245_CompressionType &() const
 825 #endif
 826 {
 827 #ifndef PASN_LEANANDMEAN
 828   PAssert(PIsDescendant(PAssertNULL(choice), H245_CompressionType), PInvalidCast);
 829 #endif
 830   return *(H245_CompressionType *)choice;
 831 }
 832
 833
 834 BOOL H245_DataProtocolCapability_v76wCompression::CreateObject()
 835 {
 836   switch (tag) {
 837     case e_transmitCompression :
 838     case e_receiveCompression :
 839     case e_transmitAndReceiveCompression :
 840       choice = new H245_CompressionType();
 841       return TRUE;
 842   }
 843
 844   choice = NULL;
 845   return FALSE;
 846 }
 847
 848
 849 PObject * H245_DataProtocolCapability_v76wCompression::Clone() const
 850 {
 851 #ifndef PASN_LEANANDMEAN
 852   PAssert(IsClass(H245_DataProtocolCapability_v76wCompression::Class()), PInvalidCast);
 853 #endif
 854   return new H245_DataProtocolCapability_v76wCompression(*this);
 855 }
 856
 857
 858 //
 859 // T84Profile_t84Restricted
 860 //
 861
 862 H245_T84Profile_t84Restricted::H245_T84Profile_t84Restricted(unsigned tag, PASN_Object::TagClass tagClass)
 863   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
 864 {
 865 }
 866
 867
 868 #ifndef PASN_NOPRINTON
 869 void H245_T84Profile_t84Restricted::PrintOn(ostream & strm) const
 870 {
 871   int indent = strm.precision() + 2;
 872   strm << "{\n";
 873   strm << setw(indent+7) << "qcif = " << setprecision(indent) << m_qcif << '\n';
 874   strm << setw(indent+6) << "cif = " << setprecision(indent) << m_cif << '\n';
 875   strm << setw(indent+13) << "ccir601Seq = " << setprecision(indent) << m_ccir601Seq << '\n';
 876   strm << setw(indent+14) << "ccir601Prog = " << setprecision(indent) << m_ccir601Prog << '\n';
 877   strm << setw(indent+10) << "hdtvSeq = " << setprecision(indent) << m_hdtvSeq << '\n';
 878   strm << setw(indent+11) << "hdtvProg = " << setprecision(indent) << m_hdtvProg << '\n';
 879   strm << setw(indent+18) << "g3FacsMH200x100 = " << setprecision(indent) << m_g3FacsMH200x100 << '\n';
 880   strm << setw(indent+18) << "g3FacsMH200x200 = " << setprecision(indent) << m_g3FacsMH200x200 << '\n';
 881   strm << setw(indent+19) << "g4FacsMMR200x100 = " << setprecision(indent) << m_g4FacsMMR200x100 << '\n';
 882   strm << setw(indent+19) << "g4FacsMMR200x200 = " << setprecision(indent) << m_g4FacsMMR200x200 << '\n';
 883   strm << setw(indent+17) << "jbig200x200Seq = " << setprecision(indent) << m_jbig200x200Seq << '\n';
 884   strm << setw(indent+18) << "jbig200x200Prog = " << setprecision(indent) << m_jbig200x200Prog << '\n';
 885   strm << setw(indent+17) << "jbig300x300Seq = " << setprecision(indent) << m_jbig300x300Seq << '\n';
 886   strm << setw(indent+18) << "jbig300x300Prog = " << setprecision(indent) << m_jbig300x300Prog << '\n';
 887   strm << setw(indent+14) << "digPhotoLow = " << setprecision(indent) << m_digPhotoLow << '\n';
 888   strm << setw(indent+17) << "digPhotoMedSeq = " << setprecision(indent) << m_digPhotoMedSeq << '\n';
 889   strm << setw(indent+18) << "digPhotoMedProg = " << setprecision(indent) << m_digPhotoMedProg << '\n';
 890   strm << setw(indent+18) << "digPhotoHighSeq = " << setprecision(indent) << m_digPhotoHighSeq << '\n';
 891   strm << setw(indent+19) << "digPhotoHighProg = " << setprecision(indent) << m_digPhotoHighProg << '\n';
 892   strm << setw(indent-1) << setprecision(indent-2) << "}";
 893 }
 894 #endif
 895
 896
 897 PObject::Comparison H245_T84Profile_t84Restricted::Compare(const PObject & obj) const
 898 {
 899 #ifndef PASN_LEANANDMEAN
 900   PAssert(PIsDescendant(&obj, H245_T84Profile_t84Restricted), PInvalidCast);
 901 #endif
 902   const H245_T84Profile_t84Restricted & other = (const H245_T84Profile_t84Restricted &)obj;
 903
 904   Comparison result;
 905
 906   if ((result = m_qcif.Compare(other.m_qcif)) != EqualTo)
 907     return result;
 908   if ((result = m_cif.Compare(other.m_cif)) != EqualTo)
 909     return result;
 910   if ((result = m_ccir601Seq.Compare(other.m_ccir601Seq)) != EqualTo)
 911     return result;
 912   if ((result = m_ccir601Prog.Compare(other.m_ccir601Prog)) != EqualTo)
 913     return result;
 914   if ((result = m_hdtvSeq.Compare(other.m_hdtvSeq)) != EqualTo)
 915     return result;
 916   if ((result = m_hdtvProg.Compare(other.m_hdtvProg)) != EqualTo)
 917     return result;
 918   if ((result = m_g3FacsMH200x100.Compare(other.m_g3FacsMH200x100)) != EqualTo)
 919     return result;
 920   if ((result = m_g3FacsMH200x200.Compare(other.m_g3FacsMH200x200)) != EqualTo)
 921     return result;
 922   if ((result = m_g4FacsMMR200x100.Compare(other.m_g4FacsMMR200x100)) != EqualTo)
 923     return result;
 924   if ((result = m_g4FacsMMR200x200.Compare(other.m_g4FacsMMR200x200)) != EqualTo)
 925     return result;
 926   if ((result = m_jbig200x200Seq.Compare(other.m_jbig200x200Seq)) != EqualTo)
 927     return result;
 928   if ((result = m_jbig200x200Prog.Compare(other.m_jbig200x200Prog)) != EqualTo)
 929     return result;
 930   if ((result = m_jbig300x300Seq.Compare(other.m_jbig300x300Seq)) != EqualTo)
 931     return result;
 932   if ((result = m_jbig300x300Prog.Compare(other.m_jbig300x300Prog)) != EqualTo)
 933     return result;
 934   if ((result = m_digPhotoLow.Compare(other.m_digPhotoLow)) != EqualTo)
 935     return result;
 936   if ((result = m_digPhotoMedSeq.Compare(other.m_digPhotoMedSeq)) != EqualTo)
 937     return result;
 938   if ((result = m_digPhotoMedProg.Compare(other.m_digPhotoMedProg)) != EqualTo)
 939     return result;
 940   if ((result = m_digPhotoHighSeq.Compare(other.m_digPhotoHighSeq)) != EqualTo)
 941     return result;
 942   if ((result = m_digPhotoHighProg.Compare(other.m_digPhotoHighProg)) != EqualTo)
 943     return result;
 944
 945   return PASN_Sequence::Compare(other);
 946 }
 947
 948
 949 PINDEX H245_T84Profile_t84Restricted::GetDataLength() const
 950 {
 951   PINDEX length = 0;
 952   length += m_qcif.GetObjectLength();
 953   length += m_cif.GetObjectLength();
 954   length += m_ccir601Seq.GetObjectLength();
 955   length += m_ccir601Prog.GetObjectLength();
 956   length += m_hdtvSeq.GetObjectLength();
 957   length += m_hdtvProg.GetObjectLength();
 958   length += m_g3FacsMH200x100.GetObjectLength();
 959   length += m_g3FacsMH200x200.GetObjectLength();
 960   length += m_g4FacsMMR200x100.GetObjectLength();
 961   length += m_g4FacsMMR200x200.GetObjectLength();
 962   length += m_jbig200x200Seq.GetObjectLength();
 963   length += m_jbig200x200Prog.GetObjectLength();
 964   length += m_jbig300x300Seq.GetObjectLength();
 965   length += m_jbig300x300Prog.GetObjectLength();
 966   length += m_digPhotoLow.GetObjectLength();
 967   length += m_digPhotoMedSeq.GetObjectLength();
 968   length += m_digPhotoMedProg.GetObjectLength();
 969   length += m_digPhotoHighSeq.GetObjectLength();
 970   length += m_digPhotoHighProg.GetObjectLength();
 971   return length;
 972 }
 973
 974
 975 BOOL H245_T84Profile_t84Restricted::Decode(PASN_Stream & strm)
 976 {
 977   if (!PreambleDecode(strm))
 978     return FALSE;
 979
 980   if (!m_qcif.Decode(strm))
 981     return FALSE;
 982   if (!m_cif.Decode(strm))
 983     return FALSE;
 984   if (!m_ccir601Seq.Decode(strm))
 985     return FALSE;
 986   if (!m_ccir601Prog.Decode(strm))
 987     return FALSE;
 988   if (!m_hdtvSeq.Decode(strm))
 989     return FALSE;
 990   if (!m_hdtvProg.Decode(strm))
 991     return FALSE;
 992   if (!m_g3FacsMH200x100.Decode(strm))
 993     return FALSE;
 994   if (!m_g3FacsMH200x200.Decode(strm))
 995     return FALSE;
 996   if (!m_g4FacsMMR200x100.Decode(strm))
 997     return FALSE;
 998   if (!m_g4FacsMMR200x200.Decode(strm))
 999     return FALSE;
1000   if (!m_jbig200x200Seq.Decode(strm))
1001     return FALSE;
1002   if (!m_jbig200x200Prog.Decode(strm))
1003     return FALSE;
1004   if (!m_jbig300x300Seq.Decode(strm))
1005     return FALSE;
1006   if (!m_jbig300x300Prog.Decode(strm))
1007     return FALSE;
1008   if (!m_digPhotoLow.Decode(strm))
1009     return FALSE;
1010   if (!m_digPhotoMedSeq.Decode(strm))
1011     return FALSE;
1012   if (!m_digPhotoMedProg.Decode(strm))
1013     return FALSE;
1014   if (!m_digPhotoHighSeq.Decode(strm))
1015     return FALSE;
1016   if (!m_digPhotoHighProg.Decode(strm))
1017     return FALSE;
1018
1019   return UnknownExtensionsDecode(strm);
1020 }
1021
1022
1023 void H245_T84Profile_t84Restricted::Encode(PASN_Stream & strm) const
1024 {
1025   PreambleEncode(strm);
1026
1027   m_qcif.Encode(strm);
1028   m_cif.Encode(strm);
1029   m_ccir601Seq.Encode(strm);
1030   m_ccir601Prog.Encode(strm);
1031   m_hdtvSeq.Encode(strm);
1032   m_hdtvProg.Encode(strm);
1033   m_g3FacsMH200x100.Encode(strm);
1034   m_g3FacsMH200x200.Encode(strm);
1035   m_g4FacsMMR200x100.Encode(strm);
1036   m_g4FacsMMR200x200.Encode(strm);
1037   m_jbig200x200Seq.Encode(strm);
1038   m_jbig200x200Prog.Encode(strm);
1039   m_jbig300x300Seq.Encode(strm);
1040   m_jbig300x300Prog.Encode(strm);
1041   m_digPhotoLow.Encode(strm);
1042   m_digPhotoMedSeq.Encode(strm);
1043   m_digPhotoMedProg.Encode(strm);
1044   m_digPhotoHighSeq.Encode(strm);
1045   m_digPhotoHighProg.Encode(strm);
1046
1047   UnknownExtensionsEncode(strm);
1048 }
1049
1050
1051 PObject * H245_T84Profile_t84Restricted::Clone() const
1052 {
1053 #ifndef PASN_LEANANDMEAN
1054   PAssert(IsClass(H245_T84Profile_t84Restricted::Class()), PInvalidCast);
1055 #endif
1056   return new H245_T84Profile_t84Restricted(*this);
1057 }
1058
1059
1060
1061 #ifndef PASN_NOPRINTON
1062 const static PASN_Names Names_H245_T38FaxUdpOptions_t38FaxUdpEC[]={
1063       {"t38UDPFEC",0}
1064      ,{"t38UDPRedundancy",1}
1065 };
1066 #endif
1067 //
1068 // T38FaxUdpOptions_t38FaxUdpEC
1069 //
1070
1071 H245_T38FaxUdpOptions_t38FaxUdpEC::H245_T38FaxUdpOptions_t38FaxUdpEC(unsigned tag, PASN_Object::TagClass tagClass)
1072   : PASN_Choice(tag, tagClass, 2, TRUE
1073 #ifndef PASN_NOPRINTON
1074     ,(const PASN_Names *)Names_H245_T38FaxUdpOptions_t38FaxUdpEC,2
1075 #endif
1076 )
1077 {
1078 }
1079
1080
1081 BOOL H245_T38FaxUdpOptions_t38FaxUdpEC::CreateObject()
1082 {
1083   choice = (tag <= e_t38UDPRedundancy) ? new PASN_Null() : NULL;
1084   return choice != NULL;
1085 }
1086
1087
1088 PObject * H245_T38FaxUdpOptions_t38FaxUdpEC::Clone() const
1089 {
1090 #ifndef PASN_LEANANDMEAN
1091   PAssert(IsClass(H245_T38FaxUdpOptions_t38FaxUdpEC::Class()), PInvalidCast);
1092 #endif
1093   return new H245_T38FaxUdpOptions_t38FaxUdpEC(*this);
1094 }
1095
1096
1097 //
1098 // ArrayOf_NonStandardParameter
1099 //
1100
1101 H245_ArrayOf_NonStandardParameter::H245_ArrayOf_NonStandardParameter(unsigned tag, PASN_Object::TagClass tagClass)
1102   : PASN_Array(tag, tagClass)
1103 {
1104 }
1105
1106
1107 PASN_Object * H245_ArrayOf_NonStandardParameter::CreateObject() const
1108 {
1109   return new H245_NonStandardParameter;
1110 }
1111
1112
1113 H245_NonStandardParameter & H245_ArrayOf_NonStandardParameter::operator[](PINDEX i) const
1114 {
1115   return (H245_NonStandardParameter &)array[i];
1116 }
1117
1118
1119 PObject * H245_ArrayOf_NonStandardParameter::Clone() const
1120 {
1121 #ifndef PASN_LEANANDMEAN
1122   PAssert(IsClass(H245_ArrayOf_NonStandardParameter::Class()), PInvalidCast);
1123 #endif
1124   return new H245_ArrayOf_NonStandardParameter(*this);
1125 }
1126
1127
1128 //
1129 // ArrayOf_ParameterIdentifier
1130 //
1131
1132 H245_ArrayOf_ParameterIdentifier::H245_ArrayOf_ParameterIdentifier(unsigned tag, PASN_Object::TagClass tagClass)
1133   : PASN_Array(tag, tagClass)
1134 {
1135 }
1136
1137
1138 PASN_Object * H245_ArrayOf_ParameterIdentifier::CreateObject() const
1139 {
1140   return new H245_ParameterIdentifier;
1141 }
1142
1143
1144 H245_ParameterIdentifier & H245_ArrayOf_ParameterIdentifier::operator[](PINDEX i) const
1145 {
1146   return (H245_ParameterIdentifier &)array[i];
1147 }
1148
1149
1150 PObject * H245_ArrayOf_ParameterIdentifier::Clone() const
1151 {
1152 #ifndef PASN_LEANANDMEAN
1153   PAssert(IsClass(H245_ArrayOf_ParameterIdentifier::Class()), PInvalidCast);
1154 #endif
1155   return new H245_ArrayOf_ParameterIdentifier(*this);
1156 }
1157
1158
1159
1160 #ifndef PASN_NOPRINTON
1161 const static PASN_Names Names_H245_FECCapability_rfc2733Format[]={
1162       {"rfc2733rfc2198",0}
1163      ,{"rfc2733sameport",1}
1164      ,{"rfc2733diffport",2}
1165 };
1166 #endif
1167 //
1168 // FECCapability_rfc2733Format
1169 //
1170
1171 H245_FECCapability_rfc2733Format::H245_FECCapability_rfc2733Format(unsigned tag, PASN_Object::TagClass tagClass)
1172   : PASN_Choice(tag, tagClass, 3, FALSE
1173 #ifndef PASN_NOPRINTON
1174     ,(const PASN_Names *)Names_H245_FECCapability_rfc2733Format,3
1175 #endif
1176 )
1177 {
1178 }
1179
1180
1181 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
1182 H245_FECCapability_rfc2733Format::operator H245_MaxRedundancy &() const
1183 #else
1184 H245_FECCapability_rfc2733Format::operator H245_MaxRedundancy &()
1185 {
1186 #ifndef PASN_LEANANDMEAN
1187   PAssert(PIsDescendant(PAssertNULL(choice), H245_MaxRedundancy), PInvalidCast);
1188 #endif
1189   return *(H245_MaxRedundancy *)choice;
1190 }
1191
1192
1193 H245_FECCapability_rfc2733Format::operator const H245_MaxRedundancy &() const
1194 #endif
1195 {
1196 #ifndef PASN_LEANANDMEAN
1197   PAssert(PIsDescendant(PAssertNULL(choice), H245_MaxRedundancy), PInvalidCast);
1198 #endif
1199   return *(H245_MaxRedundancy *)choice;
1200 }
1201
1202
1203 BOOL H245_FECCapability_rfc2733Format::CreateObject()
1204 {
1205   switch (tag) {
1206     case e_rfc2733rfc2198 :
1207     case e_rfc2733sameport :
1208     case e_rfc2733diffport :
1209       choice = new H245_MaxRedundancy();
1210       return TRUE;
1211   }
1212
1213   choice = NULL;
1214   return FALSE;
1215 }
1216
1217
1218 PObject * H245_FECCapability_rfc2733Format::Clone() const
1219 {
1220 #ifndef PASN_LEANANDMEAN
1221   PAssert(IsClass(H245_FECCapability_rfc2733Format::Class()), PInvalidCast);
1222 #endif
1223   return new H245_FECCapability_rfc2733Format(*this);
1224 }
1225
1226
1227
1228 #ifndef PASN_NOPRINTON
1229 const static PASN_Names Names_H245_NetworkAccessParameters_distribution[]={
1230       {"unicast",0}
1231      ,{"multicast",1}
1232 };
1233 #endif
1234 //
1235 // NetworkAccessParameters_distribution
1236 //
1237
1238 H245_NetworkAccessParameters_distribution::H245_NetworkAccessParameters_distribution(unsigned tag, PASN_Object::TagClass tagClass)
1239   : PASN_Choice(tag, tagClass, 2, TRUE
1240 #ifndef PASN_NOPRINTON
1241     ,(const PASN_Names *)Names_H245_NetworkAccessParameters_distribution,2
1242 #endif
1243 )
1244 {
1245 }
1246
1247
1248 BOOL H245_NetworkAccessParameters_distribution::CreateObject()
1249 {
1250   choice = (tag <= e_multicast) ? new PASN_Null() : NULL;
1251   return choice != NULL;
1252 }
1253
1254
1255 PObject * H245_NetworkAccessParameters_distribution::Clone() const
1256 {
1257 #ifndef PASN_LEANANDMEAN
1258   PAssert(IsClass(H245_NetworkAccessParameters_distribution::Class()), PInvalidCast);
1259 #endif
1260   return new H245_NetworkAccessParameters_distribution(*this);
1261 }
1262
1263
1264
1265 #ifndef PASN_NOPRINTON
1266 const static PASN_Names Names_H245_NetworkAccessParameters_networkAddress[]={
1267       {"q2931Address",0}
1268      ,{"e164Address",1}
1269      ,{"localAreaAddress",2}
1270 };
1271 #endif
1272 //
1273 // NetworkAccessParameters_networkAddress
1274 //
1275
1276 H245_NetworkAccessParameters_networkAddress::H245_NetworkAccessParameters_networkAddress(unsigned tag, PASN_Object::TagClass tagClass)
1277   : PASN_Choice(tag, tagClass, 3, TRUE
1278 #ifndef PASN_NOPRINTON
1279     ,(const PASN_Names *)Names_H245_NetworkAccessParameters_networkAddress,3
1280 #endif
1281 )
1282 {
1283 }
1284
1285
1286 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
1287 H245_NetworkAccessParameters_networkAddress::operator H245_Q2931Address &() const
1288 #else
1289 H245_NetworkAccessParameters_networkAddress::operator H245_Q2931Address &()
1290 {
1291 #ifndef PASN_LEANANDMEAN
1292   PAssert(PIsDescendant(PAssertNULL(choice), H245_Q2931Address), PInvalidCast);
1293 #endif
1294   return *(H245_Q2931Address *)choice;
1295 }
1296
1297
1298 H245_NetworkAccessParameters_networkAddress::operator const H245_Q2931Address &() const
1299 #endif
1300 {
1301 #ifndef PASN_LEANANDMEAN
1302   PAssert(PIsDescendant(PAssertNULL(choice), H245_Q2931Address), PInvalidCast);
1303 #endif
1304   return *(H245_Q2931Address *)choice;
1305 }
1306
1307
1308 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
1309 H245_NetworkAccessParameters_networkAddress::operator H245_TransportAddress &() const
1310 #else
1311 H245_NetworkAccessParameters_networkAddress::operator H245_TransportAddress &()
1312 {
1313 #ifndef PASN_LEANANDMEAN
1314   PAssert(PIsDescendant(PAssertNULL(choice), H245_TransportAddress), PInvalidCast);
1315 #endif
1316   return *(H245_TransportAddress *)choice;
1317 }
1318
1319
1320 H245_NetworkAccessParameters_networkAddress::operator const H245_TransportAddress &() const
1321 #endif
1322 {
1323 #ifndef PASN_LEANANDMEAN
1324   PAssert(PIsDescendant(PAssertNULL(choice), H245_TransportAddress), PInvalidCast);
1325 #endif
1326   return *(H245_TransportAddress *)choice;
1327 }
1328
1329
1330 BOOL H245_NetworkAccessParameters_networkAddress::CreateObject()
1331 {
1332   switch (tag) {
1333     case e_q2931Address :
1334       choice = new H245_Q2931Address();
1335       return TRUE;
1336     case e_e164Address :
1337       choice = new PASN_IA5String();
1338       choice->SetConstraints(PASN_Object::FixedConstraint, 1, 128);
1339       choice->SetCharacterSet(PASN_Object::FixedConstraint, "0123456789#*,");
1340       return TRUE;
1341     case e_localAreaAddress :
1342       choice = new H245_TransportAddress();
1343       return TRUE;
1344   }
1345
1346   choice = NULL;
1347   return FALSE;
1348 }
1349
1350
1351 PObject * H245_NetworkAccessParameters_networkAddress::Clone() const
1352 {
1353 #ifndef PASN_LEANANDMEAN
1354   PAssert(IsClass(H245_NetworkAccessParameters_networkAddress::Class()), PInvalidCast);
1355 #endif
1356   return new H245_NetworkAccessParameters_networkAddress(*this);
1357 }
1358
1359
1360
1361 #ifndef PASN_NOPRINTON
1362 const static PASN_Names Names_H245_NetworkAccessParameters_t120SetupProcedure[]={
1363       {"originateCall",0}
1364      ,{"waitForCall",1}
1365      ,{"issueQuery",2}
1366 };
1367 #endif
1368 //
1369 // NetworkAccessParameters_t120SetupProcedure
1370 //
1371
1372 H245_NetworkAccessParameters_t120SetupProcedure::H245_NetworkAccessParameters_t120SetupProcedure(unsigned tag, PASN_Object::TagClass tagClass)
1373   : PASN_Choice(tag, tagClass, 3, TRUE
1374 #ifndef PASN_NOPRINTON
1375     ,(const PASN_Names *)Names_H245_NetworkAccessParameters_t120SetupProcedure,3
1376 #endif
1377 )
1378 {
1379 }
1380
1381
1382 BOOL H245_NetworkAccessParameters_t120SetupProcedure::CreateObject()
1383 {
1384   choice = (tag <= e_issueQuery) ? new PASN_Null() : NULL;
1385   return choice != NULL;
1386 }
1387
1388
1389 PObject * H245_NetworkAccessParameters_t120SetupProcedure::Clone() const
1390 {
1391 #ifndef PASN_LEANANDMEAN
1392   PAssert(IsClass(H245_NetworkAccessParameters_t120SetupProcedure::Class()), PInvalidCast);
1393 #endif
1394   return new H245_NetworkAccessParameters_t120SetupProcedure(*this);
1395 }
1396
1397
1398
1399 #ifndef PASN_NOPRINTON
1400 const static PASN_Names Names_H245_Q2931Address_address[]={
1401       {"internationalNumber",0}
1402      ,{"nsapAddress",1}
1403 };
1404 #endif
1405 //
1406 // Q2931Address_address
1407 //
1408
1409 H245_Q2931Address_address::H245_Q2931Address_address(unsigned tag, PASN_Object::TagClass tagClass)
1410   : PASN_Choice(tag, tagClass, 2, TRUE
1411 #ifndef PASN_NOPRINTON
1412     ,(const PASN_Names *)Names_H245_Q2931Address_address,2
1413 #endif
1414 )
1415 {
1416 }
1417
1418
1419 BOOL H245_Q2931Address_address::CreateObject()
1420 {
1421   switch (tag) {
1422     case e_internationalNumber :
1423       choice = new PASN_NumericString();
1424       choice->SetConstraints(PASN_Object::FixedConstraint, 1, 16);
1425       return TRUE;
1426     case e_nsapAddress :
1427       choice = new PASN_OctetString();
1428       choice->SetConstraints(PASN_Object::FixedConstraint, 1, 20);
1429       return TRUE;
1430   }
1431
1432   choice = NULL;
1433   return FALSE;
1434 }
1435
1436
1437 PObject * H245_Q2931Address_address::Clone() const
1438 {
1439 #ifndef PASN_LEANANDMEAN
1440   PAssert(IsClass(H245_Q2931Address_address::Class()), PInvalidCast);
1441 #endif
1442   return new H245_Q2931Address_address(*this);
1443 }
1444
1445
1446
1447 #ifndef PASN_NOPRINTON
1448 const static PASN_Names Names_H245_H235Media_mediaType[]={
1449       {"nonStandard",0}
1450      ,{"videoData",1}
1451      ,{"audioData",2}
1452      ,{"data",3}
1453      ,{"redundancyEncoding",4}
1454      ,{"multiplePayloadStream",5}
1455      ,{"depFec",6}
1456      ,{"fec",7}
1457 };
1458 #endif
1459 //
1460 // H235Media_mediaType
1461 //
1462
1463 H245_H235Media_mediaType::H245_H235Media_mediaType(unsigned tag, PASN_Object::TagClass tagClass)
1464   : PASN_Choice(tag, tagClass, 4, TRUE
1465 #ifndef PASN_NOPRINTON
1466     ,(const PASN_Names *)Names_H245_H235Media_mediaType,8
1467 #endif
1468 )
1469 {
1470 }
1471
1472
1473 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
1474 H245_H235Media_mediaType::operator H245_NonStandardParameter &() const
1475 #else
1476 H245_H235Media_mediaType::operator H245_NonStandardParameter &()
1477 {
1478 #ifndef PASN_LEANANDMEAN
1479   PAssert(PIsDescendant(PAssertNULL(choice), H245_NonStandardParameter), PInvalidCast);
1480 #endif
1481   return *(H245_NonStandardParameter *)choice;
1482 }
1483
1484
1485 H245_H235Media_mediaType::operator const H245_NonStandardParameter &() const
1486 #endif
1487 {
1488 #ifndef PASN_LEANANDMEAN
1489   PAssert(PIsDescendant(PAssertNULL(choice), H245_NonStandardParameter), PInvalidCast);
1490 #endif
1491   return *(H245_NonStandardParameter *)choice;
1492 }
1493
1494
1495 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
1496 H245_H235Media_mediaType::operator H245_VideoCapability &() const
1497 #else
1498 H245_H235Media_mediaType::operator H245_VideoCapability &()
1499 {
1500 #ifndef PASN_LEANANDMEAN
1501   PAssert(PIsDescendant(PAssertNULL(choice), H245_VideoCapability), PInvalidCast);
1502 #endif
1503   return *(H245_VideoCapability *)choice;
1504 }
1505
1506
1507 H245_H235Media_mediaType::operator const H245_VideoCapability &() const
1508 #endif
1509 {
1510 #ifndef PASN_LEANANDMEAN
1511   PAssert(PIsDescendant(PAssertNULL(choice), H245_VideoCapability), PInvalidCast);
1512 #endif
1513   return *(H245_VideoCapability *)choice;
1514 }
1515
1516
1517 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
1518 H245_H235Media_mediaType::operator H245_AudioCapability &() const
1519 #else
1520 H245_H235Media_mediaType::operator H245_AudioCapability &()
1521 {
1522 #ifndef PASN_LEANANDMEAN
1523   PAssert(PIsDescendant(PAssertNULL(choice), H245_AudioCapability), PInvalidCast);
1524 #endif
1525   return *(H245_AudioCapability *)choice;
1526 }
1527
1528
1529 H245_H235Media_mediaType::operator const H245_AudioCapability &() const
1530 #endif
1531 {
1532 #ifndef PASN_LEANANDMEAN
1533   PAssert(PIsDescendant(PAssertNULL(choice), H245_AudioCapability), PInvalidCast);
1534 #endif
1535   return *(H245_AudioCapability *)choice;
1536 }
1537
1538
1539 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
1540 H245_H235Media_mediaType::operator H245_DataApplicationCapability &() const
1541 #else
1542 H245_H235Media_mediaType::operator H245_DataApplicationCapability &()
1543 {
1544 #ifndef PASN_LEANANDMEAN
1545   PAssert(PIsDescendant(PAssertNULL(choice), H245_DataApplicationCapability), PInvalidCast);
1546 #endif
1547   return *(H245_DataApplicationCapability *)choice;
1548 }
1549
1550
1551 H245_H235Media_mediaType::operator const H245_DataApplicationCapability &() const
1552 #endif
1553 {
1554 #ifndef PASN_LEANANDMEAN
1555   PAssert(PIsDescendant(PAssertNULL(choice), H245_DataApplicationCapability), PInvalidCast);
1556 #endif
1557   return *(H245_DataApplicationCapability *)choice;
1558 }
1559
1560
1561 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
1562 H245_H235Media_mediaType::operator H245_RedundancyEncoding &() const
1563 #else
1564 H245_H235Media_mediaType::operator H245_RedundancyEncoding &()
1565 {
1566 #ifndef PASN_LEANANDMEAN
1567   PAssert(PIsDescendant(PAssertNULL(choice), H245_RedundancyEncoding), PInvalidCast);
1568 #endif
1569   return *(H245_RedundancyEncoding *)choice;
1570 }
1571
1572
1573 H245_H235Media_mediaType::operator const H245_RedundancyEncoding &() const
1574 #endif
1575 {
1576 #ifndef PASN_LEANANDMEAN
1577   PAssert(PIsDescendant(PAssertNULL(choice), H245_RedundancyEncoding), PInvalidCast);
1578 #endif
1579   return *(H245_RedundancyEncoding *)choice;
1580 }
1581
1582
1583 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
1584 H245_H235Media_mediaType::operator H245_MultiplePayloadStream &() const
1585 #else
1586 H245_H235Media_mediaType::operator H245_MultiplePayloadStream &()
1587 {
1588 #ifndef PASN_LEANANDMEAN
1589   PAssert(PIsDescendant(PAssertNULL(choice), H245_MultiplePayloadStream), PInvalidCast);
1590 #endif
1591   return *(H245_MultiplePayloadStream *)choice;
1592 }
1593
1594
1595 H245_H235Media_mediaType::operator const H245_MultiplePayloadStream &() const
1596 #endif
1597 {
1598 #ifndef PASN_LEANANDMEAN
1599   PAssert(PIsDescendant(PAssertNULL(choice), H245_MultiplePayloadStream), PInvalidCast);
1600 #endif
1601   return *(H245_MultiplePayloadStream *)choice;
1602 }
1603
1604
1605 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
1606 H245_H235Media_mediaType::operator H245_DepFECData &() const
1607 #else
1608 H245_H235Media_mediaType::operator H245_DepFECData &()
1609 {
1610 #ifndef PASN_LEANANDMEAN
1611   PAssert(PIsDescendant(PAssertNULL(choice), H245_DepFECData), PInvalidCast);
1612 #endif
1613   return *(H245_DepFECData *)choice;
1614 }
1615
1616
1617 H245_H235Media_mediaType::operator const H245_DepFECData &() const
1618 #endif
1619 {
1620 #ifndef PASN_LEANANDMEAN
1621   PAssert(PIsDescendant(PAssertNULL(choice), H245_DepFECData), PInvalidCast);
1622 #endif
1623   return *(H245_DepFECData *)choice;
1624 }
1625
1626
1627 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
1628 H245_H235Media_mediaType::operator H245_FECData &() const
1629 #else
1630 H245_H235Media_mediaType::operator H245_FECData &()
1631 {
1632 #ifndef PASN_LEANANDMEAN
1633   PAssert(PIsDescendant(PAssertNULL(choice), H245_FECData), PInvalidCast);
1634 #endif
1635   return *(H245_FECData *)choice;
1636 }
1637
1638
1639 H245_H235Media_mediaType::operator const H245_FECData &() const
1640 #endif
1641 {
1642 #ifndef PASN_LEANANDMEAN
1643   PAssert(PIsDescendant(PAssertNULL(choice), H245_FECData), PInvalidCast);
1644 #endif
1645   return *(H245_FECData *)choice;
1646 }
1647
1648
1649 BOOL H245_H235Media_mediaType::CreateObject()
1650 {
1651   switch (tag) {
1652     case e_nonStandard :
1653       choice = new H245_NonStandardParameter();
1654       return TRUE;
1655     case e_videoData :
1656       choice = new H245_VideoCapability();
1657       return TRUE;
1658     case e_audioData :
1659       choice = new H245_AudioCapability();
1660       return TRUE;
1661     case e_data :
1662       choice = new H245_DataApplicationCapability();
1663       return TRUE;
1664     case e_redundancyEncoding :
1665       choice = new H245_RedundancyEncoding();
1666       return TRUE;
1667     case e_multiplePayloadStream :
1668       choice = new H245_MultiplePayloadStream();
1669       return TRUE;
1670     case e_depFec :
1671       choice = new H245_DepFECData();
1672       return TRUE;
1673     case e_fec :
1674       choice = new H245_FECData();
1675       return TRUE;
1676   }
1677
1678   choice = NULL;
1679   return FALSE;
1680 }
1681
1682
1683 PObject * H245_H235Media_mediaType::Clone() const
1684 {
1685 #ifndef PASN_LEANANDMEAN
1686   PAssert(IsClass(H245_H235Media_mediaType::Class()), PInvalidCast);
1687 #endif
1688   return new H245_H235Media_mediaType(*this);
1689 }
1690
1691
1692
1693 #ifndef PASN_NOPRINTON
1694 const static PASN_Names Names_H245_H223LogicalChannelParameters_adaptationLayerType[]={
1695       {"nonStandard",0}
1696      ,{"al1Framed",1}
1697      ,{"al1NotFramed",2}
1698      ,{"al2WithoutSequenceNumbers",3}
1699      ,{"al2WithSequenceNumbers",4}
1700      ,{"al3",5}
1701      ,{"al1M",6}
1702      ,{"al2M",7}
1703      ,{"al3M",8}
1704 };
1705 #endif
1706 //
1707 // H223LogicalChannelParameters_adaptationLayerType
1708 //
1709
1710 H245_H223LogicalChannelParameters_adaptationLayerType::H245_H223LogicalChannelParameters_adaptationLayerType(unsigned tag, PASN_Object::TagClass tagClass)
1711   : PASN_Choice(tag, tagClass, 6, TRUE
1712 #ifndef PASN_NOPRINTON
1713     ,(const PASN_Names *)Names_H245_H223LogicalChannelParameters_adaptationLayerType,9
1714 #endif
1715 )
1716 {
1717 }
1718
1719
1720 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
1721 H245_H223LogicalChannelParameters_adaptationLayerType::operator H245_NonStandardParameter &() const
1722 #else
1723 H245_H223LogicalChannelParameters_adaptationLayerType::operator H245_NonStandardParameter &()
1724 {
1725 #ifndef PASN_LEANANDMEAN
1726   PAssert(PIsDescendant(PAssertNULL(choice), H245_NonStandardParameter), PInvalidCast);
1727 #endif
1728   return *(H245_NonStandardParameter *)choice;
1729 }
1730
1731
1732 H245_H223LogicalChannelParameters_adaptationLayerType::operator const H245_NonStandardParameter &() const
1733 #endif
1734 {
1735 #ifndef PASN_LEANANDMEAN
1736   PAssert(PIsDescendant(PAssertNULL(choice), H245_NonStandardParameter), PInvalidCast);
1737 #endif
1738   return *(H245_NonStandardParameter *)choice;
1739 }
1740
1741
1742 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
1743 H245_H223LogicalChannelParameters_adaptationLayerType::operator H245_H223LogicalChannelParameters_adaptationLayerType_al3 &() const
1744 #else
1745 H245_H223LogicalChannelParameters_adaptationLayerType::operator H245_H223LogicalChannelParameters_adaptationLayerType_al3 &()
1746 {
1747 #ifndef PASN_LEANANDMEAN
1748   PAssert(PIsDescendant(PAssertNULL(choice), H245_H223LogicalChannelParameters_adaptationLayerType_al3), PInvalidCast);
1749 #endif
1750   return *(H245_H223LogicalChannelParameters_adaptationLayerType_al3 *)choice;
1751 }
1752
1753
1754 H245_H223LogicalChannelParameters_adaptationLayerType::operator const H245_H223LogicalChannelParameters_adaptationLayerType_al3 &() const
1755 #endif
1756 {
1757 #ifndef PASN_LEANANDMEAN
1758   PAssert(PIsDescendant(PAssertNULL(choice), H245_H223LogicalChannelParameters_adaptationLayerType_al3), PInvalidCast);
1759 #endif
1760   return *(H245_H223LogicalChannelParameters_adaptationLayerType_al3 *)choice;
1761 }
1762
1763
1764 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
1765 H245_H223LogicalChannelParameters_adaptationLayerType::operator H245_H223AL1MParameters &() const
1766 #else
1767 H245_H223LogicalChannelParameters_adaptationLayerType::operator H245_H223AL1MParameters &()
1768 {
1769 #ifndef PASN_LEANANDMEAN
1770   PAssert(PIsDescendant(PAssertNULL(choice), H245_H223AL1MParameters), PInvalidCast);
1771 #endif
1772   return *(H245_H223AL1MParameters *)choice;
1773 }
1774
1775
1776 H245_H223LogicalChannelParameters_adaptationLayerType::operator const H245_H223AL1MParameters &() const
1777 #endif
1778 {
1779 #ifndef PASN_LEANANDMEAN
1780   PAssert(PIsDescendant(PAssertNULL(choice), H245_H223AL1MParameters), PInvalidCast);
1781 #endif
1782   return *(H245_H223AL1MParameters *)choice;
1783 }
1784
1785
1786 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
1787 H245_H223LogicalChannelParameters_adaptationLayerType::operator H245_H223AL2MParameters &() const
1788 #else
1789 H245_H223LogicalChannelParameters_adaptationLayerType::operator H245_H223AL2MParameters &()
1790 {
1791 #ifndef PASN_LEANANDMEAN
1792   PAssert(PIsDescendant(PAssertNULL(choice), H245_H223AL2MParameters), PInvalidCast);
1793 #endif
1794   return *(H245_H223AL2MParameters *)choice;
1795 }
1796
1797
1798 H245_H223LogicalChannelParameters_adaptationLayerType::operator const H245_H223AL2MParameters &() const
1799 #endif
1800 {
1801 #ifndef PASN_LEANANDMEAN
1802   PAssert(PIsDescendant(PAssertNULL(choice), H245_H223AL2MParameters), PInvalidCast);
1803 #endif
1804   return *(H245_H223AL2MParameters *)choice;
1805 }
1806
1807
1808 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
1809 H245_H223LogicalChannelParameters_adaptationLayerType::operator H245_H223AL3MParameters &() const
1810 #else
1811 H245_H223LogicalChannelParameters_adaptationLayerType::operator H245_H223AL3MParameters &()
1812 {
1813 #ifndef PASN_LEANANDMEAN
1814   PAssert(PIsDescendant(PAssertNULL(choice), H245_H223AL3MParameters), PInvalidCast);
1815 #endif
1816   return *(H245_H223AL3MParameters *)choice;
1817 }
1818
1819
1820 H245_H223LogicalChannelParameters_adaptationLayerType::operator const H245_H223AL3MParameters &() const
1821 #endif
1822 {
1823 #ifndef PASN_LEANANDMEAN
1824   PAssert(PIsDescendant(PAssertNULL(choice), H245_H223AL3MParameters), PInvalidCast);
1825 #endif
1826   return *(H245_H223AL3MParameters *)choice;
1827 }
1828
1829
1830 BOOL H245_H223LogicalChannelParameters_adaptationLayerType::CreateObject()
1831 {
1832   switch (tag) {
1833     case e_nonStandard :
1834       choice = new H245_NonStandardParameter();
1835       return TRUE;
1836     case e_al1Framed :
1837     case e_al1NotFramed :
1838     case e_al2WithoutSequenceNumbers :
1839     case e_al2WithSequenceNumbers :
1840       choice = new PASN_Null();
1841       return TRUE;
1842     case e_al3 :
1843       choice = new H245_H223LogicalChannelParameters_adaptationLayerType_al3();
1844       return TRUE;
1845     case e_al1M :
1846       choice = new H245_H223AL1MParameters();
1847       return TRUE;
1848     case e_al2M :
1849       choice = new H245_H223AL2MParameters();
1850       return TRUE;
1851     case e_al3M :
1852       choice = new H245_H223AL3MParameters();
1853       return TRUE;
1854   }
1855
1856   choice = NULL;
1857   return FALSE;
1858 }
1859
1860
1861 PObject * H245_H223LogicalChannelParameters_adaptationLayerType::Clone() const
1862 {
1863 #ifndef PASN_LEANANDMEAN
1864   PAssert(IsClass(H245_H223LogicalChannelParameters_adaptationLayerType::Class()), PInvalidCast);
1865 #endif
1866   return new H245_H223LogicalChannelParameters_adaptationLayerType(*this);
1867 }
1868
1869
1870
1871 #ifndef PASN_NOPRINTON
1872 const static PASN_Names Names_H245_H223AL1MParameters_transferMode[]={
1873       {"framed",0}
1874      ,{"unframed",1}
1875 };
1876 #endif
1877 //
1878 // H223AL1MParameters_transferMode
1879 //
1880
1881 H245_H223AL1MParameters_transferMode::H245_H223AL1MParameters_transferMode(unsigned tag, PASN_Object::TagClass tagClass)
1882   : PASN_Choice(tag, tagClass, 2, TRUE
1883 #ifndef PASN_NOPRINTON
1884     ,(const PASN_Names *)Names_H245_H223AL1MParameters_transferMode,2
1885 #endif
1886 )
1887 {
1888 }
1889
1890
1891 BOOL H245_H223AL1MParameters_transferMode::CreateObject()
1892 {
1893   choice = (tag <= e_unframed) ? new PASN_Null() : NULL;
1894   return choice != NULL;
1895 }
1896
1897
1898 PObject * H245_H223AL1MParameters_transferMode::Clone() const
1899 {
1900 #ifndef PASN_LEANANDMEAN
1901   PAssert(IsClass(H245_H223AL1MParameters_transferMode::Class()), PInvalidCast);
1902 #endif
1903   return new H245_H223AL1MParameters_transferMode(*this);
1904 }
1905
1906
1907
1908 #ifndef PASN_NOPRINTON
1909 const static PASN_Names Names_H245_H223AL1MParameters_headerFEC[]={
1910       {"sebch16_7",0}
1911      ,{"golay24_12",1}
1912 };
1913 #endif
1914 //
1915 // H223AL1MParameters_headerFEC
1916 //
1917
1918 H245_H223AL1MParameters_headerFEC::H245_H223AL1MParameters_headerFEC(unsigned tag, PASN_Object::TagClass tagClass)
1919   : PASN_Choice(tag, tagClass, 2, TRUE
1920 #ifndef PASN_NOPRINTON
1921     ,(const PASN_Names *)Names_H245_H223AL1MParameters_headerFEC,2
1922 #endif
1923 )
1924 {
1925 }
1926
1927
1928 BOOL H245_H223AL1MParameters_headerFEC::CreateObject()
1929 {
1930   choice = (tag <= e_golay24_12) ? new PASN_Null() : NULL;
1931   return choice != NULL;
1932 }
1933
1934
1935 PObject * H245_H223AL1MParameters_headerFEC::Clone() const
1936 {
1937 #ifndef PASN_LEANANDMEAN
1938   PAssert(IsClass(H245_H223AL1MParameters_headerFEC::Class()), PInvalidCast);
1939 #endif
1940   return new H245_H223AL1MParameters_headerFEC(*this);
1941 }
1942
1943
1944
1945 #ifndef PASN_NOPRINTON
1946 const static PASN_Names Names_H245_H223AL1MParameters_crcLength[]={
1947       {"crc4bit",0}
1948      ,{"crc12bit",1}
1949      ,{"crc20bit",2}
1950      ,{"crc28bit",3}
1951      ,{"crc8bit",4}
1952      ,{"crc16bit",5}
1953      ,{"crc32bit",6}
1954      ,{"crcNotUsed",7}
1955 };
1956 #endif
1957 //
1958 // H223AL1MParameters_crcLength
1959 //
1960
1961 H245_H223AL1MParameters_crcLength::H245_H223AL1MParameters_crcLength(unsigned tag, PASN_Object::TagClass tagClass)
1962   : PASN_Choice(tag, tagClass, 4, TRUE
1963 #ifndef PASN_NOPRINTON
1964     ,(const PASN_Names *)Names_H245_H223AL1MParameters_crcLength,8
1965 #endif
1966 )
1967 {
1968 }
1969
1970
1971 BOOL H245_H223AL1MParameters_crcLength::CreateObject()
1972 {
1973   choice = (tag <= e_crcNotUsed) ? new PASN_Null() : NULL;
1974   return choice != NULL;
1975 }
1976
1977
1978 PObject * H245_H223AL1MParameters_crcLength::Clone() const
1979 {
1980 #ifndef PASN_LEANANDMEAN
1981   PAssert(IsClass(H245_H223AL1MParameters_crcLength::Class()), PInvalidCast);
1982 #endif
1983   return new H245_H223AL1MParameters_crcLength(*this);
1984 }
1985
1986
1987
1988 #ifndef PASN_NOPRINTON
1989 const static PASN_Names Names_H245_H223AL1MParameters_arqType[]={
1990       {"noArq",0}
1991      ,{"typeIArq",1}
1992      ,{"typeIIArq",2}
1993 };
1994 #endif
1995 //
1996 // H223AL1MParameters_arqType
1997 //
1998
1999 H245_H223AL1MParameters_arqType::H245_H223AL1MParameters_arqType(unsigned tag, PASN_Object::TagClass tagClass)
2000   : PASN_Choice(tag, tagClass, 3, TRUE
2001 #ifndef PASN_NOPRINTON
2002     ,(const PASN_Names *)Names_H245_H223AL1MParameters_arqType,3
2003 #endif
2004 )
2005 {
2006 }
2007
2008
2009 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
2010 H245_H223AL1MParameters_arqType::operator H245_H223AnnexCArqParameters &() const
2011 #else
2012 H245_H223AL1MParameters_arqType::operator H245_H223AnnexCArqParameters &()
2013 {
2014 #ifndef PASN_LEANANDMEAN
2015   PAssert(PIsDescendant(PAssertNULL(choice), H245_H223AnnexCArqParameters), PInvalidCast);
2016 #endif
2017   return *(H245_H223AnnexCArqParameters *)choice;
2018 }
2019
2020
2021 H245_H223AL1MParameters_arqType::operator const H245_H223AnnexCArqParameters &() const
2022 #endif
2023 {
2024 #ifndef PASN_LEANANDMEAN
2025   PAssert(PIsDescendant(PAssertNULL(choice), H245_H223AnnexCArqParameters), PInvalidCast);
2026 #endif
2027   return *(H245_H223AnnexCArqParameters *)choice;
2028 }
2029
2030
2031 BOOL H245_H223AL1MParameters_arqType::CreateObject()
2032 {
2033   switch (tag) {
2034     case e_noArq :
2035       choice = new PASN_Null();
2036       return TRUE;
2037     case e_typeIArq :
2038     case e_typeIIArq :
2039       choice = new H245_H223AnnexCArqParameters();
2040       return TRUE;
2041   }
2042
2043   choice = NULL;
2044   return FALSE;
2045 }
2046
2047
2048 PObject * H245_H223AL1MParameters_arqType::Clone() const
2049 {
2050 #ifndef PASN_LEANANDMEAN
2051   PAssert(IsClass(H245_H223AL1MParameters_arqType::Class()), PInvalidCast);
2052 #endif
2053   return new H245_H223AL1MParameters_arqType(*this);
2054 }
2055
2056
2057
2058 #ifndef PASN_NOPRINTON
2059 const static PASN_Names Names_H245_H223AL2MParameters_headerFEC[]={
2060       {"sebch16_5",0}
2061      ,{"golay24_12",1}
2062 };
2063 #endif
2064 //
2065 // H223AL2MParameters_headerFEC
2066 //
2067
2068 H245_H223AL2MParameters_headerFEC::H245_H223AL2MParameters_headerFEC(unsigned tag, PASN_Object::TagClass tagClass)
2069   : PASN_Choice(tag, tagClass, 2, TRUE
2070 #ifndef PASN_NOPRINTON
2071     ,(const PASN_Names *)Names_H245_H223AL2MParameters_headerFEC,2
2072 #endif
2073 )
2074 {
2075 }
2076
2077
2078 BOOL H245_H223AL2MParameters_headerFEC::CreateObject()
2079 {
2080   choice = (tag <= e_golay24_12) ? new PASN_Null() : NULL;
2081   return choice != NULL;
2082 }
2083
2084
2085 PObject * H245_H223AL2MParameters_headerFEC::Clone() const
2086 {
2087 #ifndef PASN_LEANANDMEAN
2088   PAssert(IsClass(H245_H223AL2MParameters_headerFEC::Class()), PInvalidCast);
2089 #endif
2090   return new H245_H223AL2MParameters_headerFEC(*this);
2091 }
2092
2093
2094
2095 #ifndef PASN_NOPRINTON
2096 const static PASN_Names Names_H245_H223AL3MParameters_headerFormat[]={
2097       {"sebch16_7",0}
2098      ,{"golay24_12",1}
2099 };
2100 #endif
2101 //
2102 // H223AL3MParameters_headerFormat
2103 //
2104
2105 H245_H223AL3MParameters_headerFormat::H245_H223AL3MParameters_headerFormat(unsigned tag, PASN_Object::TagClass tagClass)
2106   : PASN_Choice(tag, tagClass, 2, TRUE
2107 #ifndef PASN_NOPRINTON
2108     ,(const PASN_Names *)Names_H245_H223AL3MParameters_headerFormat,2
2109 #endif
2110 )
2111 {
2112 }
2113
2114
2115 BOOL H245_H223AL3MParameters_headerFormat::CreateObject()
2116 {
2117   choice = (tag <= e_golay24_12) ? new PASN_Null() : NULL;
2118   return choice != NULL;
2119 }
2120
2121
2122 PObject * H245_H223AL3MParameters_headerFormat::Clone() const
2123 {
2124 #ifndef PASN_LEANANDMEAN
2125   PAssert(IsClass(H245_H223AL3MParameters_headerFormat::Class()), PInvalidCast);
2126 #endif
2127   return new H245_H223AL3MParameters_headerFormat(*this);
2128 }
2129
2130
2131
2132 #ifndef PASN_NOPRINTON
2133 const static PASN_Names Names_H245_H223AL3MParameters_crcLength[]={
2134       {"crc4bit",0}
2135      ,{"crc12bit",1}
2136      ,{"crc20bit",2}
2137      ,{"crc28bit",3}
2138      ,{"crc8bit",4}
2139      ,{"crc16bit",5}
2140      ,{"crc32bit",6}
2141      ,{"crcNotUsed",7}
2142 };
2143 #endif
2144 //
2145 // H223AL3MParameters_crcLength
2146 //
2147
2148 H245_H223AL3MParameters_crcLength::H245_H223AL3MParameters_crcLength(unsigned tag, PASN_Object::TagClass tagClass)
2149   : PASN_Choice(tag, tagClass, 4, TRUE
2150 #ifndef PASN_NOPRINTON
2151     ,(const PASN_Names *)Names_H245_H223AL3MParameters_crcLength,8
2152 #endif
2153 )
2154 {
2155 }
2156
2157
2158 BOOL H245_H223AL3MParameters_crcLength::CreateObject()
2159 {
2160   choice = (tag <= e_crcNotUsed) ? new PASN_Null() : NULL;
2161   return choice != NULL;
2162 }
2163
2164
2165 PObject * H245_H223AL3MParameters_crcLength::Clone() const
2166 {
2167 #ifndef PASN_LEANANDMEAN
2168   PAssert(IsClass(H245_H223AL3MParameters_crcLength::Class()), PInvalidCast);
2169 #endif
2170   return new H245_H223AL3MParameters_crcLength(*this);
2171 }
2172
2173
2174
2175 #ifndef PASN_NOPRINTON
2176 const static PASN_Names Names_H245_H223AL3MParameters_arqType[]={
2177       {"noArq",0}
2178      ,{"typeIArq",1}
2179      ,{"typeIIArq",2}
2180 };
2181 #endif
2182 //
2183 // H223AL3MParameters_arqType
2184 //
2185
2186 H245_H223AL3MParameters_arqType::H245_H223AL3MParameters_arqType(unsigned tag, PASN_Object::TagClass tagClass)
2187   : PASN_Choice(tag, tagClass, 3, TRUE
2188 #ifndef PASN_NOPRINTON
2189     ,(const PASN_Names *)Names_H245_H223AL3MParameters_arqType,3
2190 #endif
2191 )
2192 {
2193 }
2194
2195
2196 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
2197 H245_H223AL3MParameters_arqType::operator H245_H223AnnexCArqParameters &() const
2198 #else
2199 H245_H223AL3MParameters_arqType::operator H245_H223AnnexCArqParameters &()
2200 {
2201 #ifndef PASN_LEANANDMEAN
2202   PAssert(PIsDescendant(PAssertNULL(choice), H245_H223AnnexCArqParameters), PInvalidCast);
2203 #endif
2204   return *(H245_H223AnnexCArqParameters *)choice;
2205 }
2206
2207
2208 H245_H223AL3MParameters_arqType::operator const H245_H223AnnexCArqParameters &() const
2209 #endif
2210 {
2211 #ifndef PASN_LEANANDMEAN
2212   PAssert(PIsDescendant(PAssertNULL(choice), H245_H223AnnexCArqParameters), PInvalidCast);
2213 #endif
2214   return *(H245_H223AnnexCArqParameters *)choice;
2215 }
2216
2217
2218 BOOL H245_H223AL3MParameters_arqType::CreateObject()
2219 {
2220   switch (tag) {
2221     case e_noArq :
2222       choice = new PASN_Null();
2223       return TRUE;
2224     case e_typeIArq :
2225     case e_typeIIArq :
2226       choice = new H245_H223AnnexCArqParameters();
2227       return TRUE;
2228   }
2229
2230   choice = NULL;
2231   return FALSE;
2232 }
2233
2234
2235 PObject * H245_H223AL3MParameters_arqType::Clone() const
2236 {
2237 #ifndef PASN_LEANANDMEAN
2238   PAssert(IsClass(H245_H223AL3MParameters_arqType::Class()), PInvalidCast);
2239 #endif
2240   return new H245_H223AL3MParameters_arqType(*this);
2241 }
2242
2243
2244
2245 #ifndef PASN_NOPRINTON
2246 const static PASN_Names Names_H245_H223AnnexCArqParameters_numberOfRetransmissions[]={
2247       {"finite",0}
2248      ,{"infinite",1}
2249 };
2250 #endif
2251 //
2252 // H223AnnexCArqParameters_numberOfRetransmissions
2253 //
2254
2255 H245_H223AnnexCArqParameters_numberOfRetransmissions::H245_H223AnnexCArqParameters_numberOfRetransmissions(unsigned tag, PASN_Object::TagClass tagClass)
2256   : PASN_Choice(tag, tagClass, 2, TRUE
2257 #ifndef PASN_NOPRINTON
2258     ,(const PASN_Names *)Names_H245_H223AnnexCArqParameters_numberOfRetransmissions,2
2259 #endif
2260 )
2261 {
2262 }
2263
2264
2265 BOOL H245_H223AnnexCArqParameters_numberOfRetransmissions::CreateObject()
2266 {
2267   switch (tag) {
2268     case e_finite :
2269       choice = new PASN_Integer();
2270       choice->SetConstraints(PASN_Object::FixedConstraint, 0, 16);
2271       return TRUE;
2272     case e_infinite :
2273       choice = new PASN_Null();
2274       return TRUE;
2275   }
2276
2277   choice = NULL;
2278   return FALSE;
2279 }
2280
2281
2282 PObject * H245_H223AnnexCArqParameters_numberOfRetransmissions::Clone() const
2283 {
2284 #ifndef PASN_LEANANDMEAN
2285   PAssert(IsClass(H245_H223AnnexCArqParameters_numberOfRetransmissions::Class()), PInvalidCast);
2286 #endif
2287   return new H245_H223AnnexCArqParameters_numberOfRetransmissions(*this);
2288 }
2289
2290
2291
2292 #ifndef PASN_NOPRINTON
2293 const static PASN_Names Names_H245_V76LogicalChannelParameters_suspendResume[]={
2294       {"noSuspendResume",0}
2295      ,{"suspendResumewAddress",1}
2296      ,{"suspendResumewoAddress",2}
2297 };
2298 #endif
2299 //
2300 // V76LogicalChannelParameters_suspendResume
2301 //
2302
2303 H245_V76LogicalChannelParameters_suspendResume::H245_V76LogicalChannelParameters_suspendResume(unsigned tag, PASN_Object::TagClass tagClass)
2304   : PASN_Choice(tag, tagClass, 3, TRUE
2305 #ifndef PASN_NOPRINTON
2306     ,(const PASN_Names *)Names_H245_V76LogicalChannelParameters_suspendResume,3
2307 #endif
2308 )
2309 {
2310 }
2311
2312
2313 BOOL H245_V76LogicalChannelParameters_suspendResume::CreateObject()
2314 {
2315   choice = (tag <= e_suspendResumewoAddress) ? new PASN_Null() : NULL;
2316   return choice != NULL;
2317 }
2318
2319
2320 PObject * H245_V76LogicalChannelParameters_suspendResume::Clone() const
2321 {
2322 #ifndef PASN_LEANANDMEAN
2323   PAssert(IsClass(H245_V76LogicalChannelParameters_suspendResume::Class()), PInvalidCast);
2324 #endif
2325   return new H245_V76LogicalChannelParameters_suspendResume(*this);
2326 }
2327
2328
2329
2330 #ifndef PASN_NOPRINTON
2331 const static PASN_Names Names_H245_V76LogicalChannelParameters_mode[]={
2332       {"eRM",0}
2333      ,{"uNERM",1}
2334 };
2335 #endif
2336 //
2337 // V76LogicalChannelParameters_mode
2338 //
2339
2340 H245_V76LogicalChannelParameters_mode::H245_V76LogicalChannelParameters_mode(unsigned tag, PASN_Object::TagClass tagClass)
2341   : PASN_Choice(tag, tagClass, 2, TRUE
2342 #ifndef PASN_NOPRINTON
2343     ,(const PASN_Names *)Names_H245_V76LogicalChannelParameters_mode,2
2344 #endif
2345 )
2346 {
2347 }
2348
2349
2350 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
2351 H245_V76LogicalChannelParameters_mode::operator H245_V76LogicalChannelParameters_mode_eRM &() const
2352 #else
2353 H245_V76LogicalChannelParameters_mode::operator H245_V76LogicalChannelParameters_mode_eRM &()
2354 {
2355 #ifndef PASN_LEANANDMEAN
2356   PAssert(PIsDescendant(PAssertNULL(choice), H245_V76LogicalChannelParameters_mode_eRM), PInvalidCast);
2357 #endif
2358   return *(H245_V76LogicalChannelParameters_mode_eRM *)choice;
2359 }
2360
2361
2362 H245_V76LogicalChannelParameters_mode::operator const H245_V76LogicalChannelParameters_mode_eRM &() const
2363 #endif
2364 {
2365 #ifndef PASN_LEANANDMEAN
2366   PAssert(PIsDescendant(PAssertNULL(choice), H245_V76LogicalChannelParameters_mode_eRM), PInvalidCast);
2367 #endif
2368   return *(H245_V76LogicalChannelParameters_mode_eRM *)choice;
2369 }
2370
2371
2372 BOOL H245_V76LogicalChannelParameters_mode::CreateObject()
2373 {
2374   switch (tag) {
2375     case e_eRM :
2376       choice = new H245_V76LogicalChannelParameters_mode_eRM();
2377       return TRUE;
2378     case e_uNERM :
2379       choice = new PASN_Null();
2380       return TRUE;
2381   }
2382
2383   choice = NULL;
2384   return FALSE;
2385 }
2386
2387
2388 PObject * H245_V76LogicalChannelParameters_mode::Clone() const
2389 {
2390 #ifndef PASN_LEANANDMEAN
2391   PAssert(IsClass(H245_V76LogicalChannelParameters_mode::Class()), PInvalidCast);
2392 #endif
2393   return new H245_V76LogicalChannelParameters_mode(*this);
2394 }
2395
2396
2397
2398 #ifndef PASN_NOPRINTON
2399 const static PASN_Names Names_H245_H2250LogicalChannelParameters_mediaPacketization[]={
2400       {"h261aVideoPacketization",0}
2401      ,{"rtpPayloadType",1}
2402 };
2403 #endif
2404 //
2405 // H2250LogicalChannelParameters_mediaPacketization
2406 //
2407
2408 H245_H2250LogicalChannelParameters_mediaPacketization::H245_H2250LogicalChannelParameters_mediaPacketization(unsigned tag, PASN_Object::TagClass tagClass)
2409   : PASN_Choice(tag, tagClass, 1, TRUE
2410 #ifndef PASN_NOPRINTON
2411     ,(const PASN_Names *)Names_H245_H2250LogicalChannelParameters_mediaPacketization,2
2412 #endif
2413 )
2414 {
2415 }
2416
2417
2418 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
2419 H245_H2250LogicalChannelParameters_mediaPacketization::operator H245_RTPPayloadType &() const
2420 #else
2421 H245_H2250LogicalChannelParameters_mediaPacketization::operator H245_RTPPayloadType &()
2422 {
2423 #ifndef PASN_LEANANDMEAN
2424   PAssert(PIsDescendant(PAssertNULL(choice), H245_RTPPayloadType), PInvalidCast);
2425 #endif
2426   return *(H245_RTPPayloadType *)choice;
2427 }
2428
2429
2430 H245_H2250LogicalChannelParameters_mediaPacketization::operator const H245_RTPPayloadType &() const
2431 #endif
2432 {
2433 #ifndef PASN_LEANANDMEAN
2434   PAssert(PIsDescendant(PAssertNULL(choice), H245_RTPPayloadType), PInvalidCast);
2435 #endif
2436   return *(H245_RTPPayloadType *)choice;
2437 }
2438
2439
2440 BOOL H245_H2250LogicalChannelParameters_mediaPacketization::CreateObject()
2441 {
2442   switch (tag) {
2443     case e_h261aVideoPacketization :
2444       choice = new PASN_Null();
2445       return TRUE;
2446     case e_rtpPayloadType :
2447       choice = new H245_RTPPayloadType();
2448       return TRUE;
2449   }
2450
2451   choice = NULL;
2452   return FALSE;
2453 }
2454
2455
2456 PObject * H245_H2250LogicalChannelParameters_mediaPacketization::Clone() const
2457 {
2458 #ifndef PASN_LEANANDMEAN
2459   PAssert(IsClass(H245_H2250LogicalChannelParameters_mediaPacketization::Class()), PInvalidCast);
2460 #endif
2461   return new H245_H2250LogicalChannelParameters_mediaPacketization(*this);
2462 }
2463
2464
2465
2466 #ifndef PASN_NOPRINTON
2467 const static PASN_Names Names_H245_RTPPayloadType_payloadDescriptor[]={
2468       {"nonStandardIdentifier",0}
2469      ,{"rfc_number",1}
2470      ,{"oid",2}
2471 };
2472 #endif
2473 //
2474 // RTPPayloadType_payloadDescriptor
2475 //
2476
2477 H245_RTPPayloadType_payloadDescriptor::H245_RTPPayloadType_payloadDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
2478   : PASN_Choice(tag, tagClass, 3, TRUE
2479 #ifndef PASN_NOPRINTON
2480     ,(const PASN_Names *)Names_H245_RTPPayloadType_payloadDescriptor,3
2481 #endif
2482 )
2483 {
2484 }
2485
2486
2487 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
2488 H245_RTPPayloadType_payloadDescriptor::operator H245_NonStandardParameter &() const
2489 #else
2490 H245_RTPPayloadType_payloadDescriptor::operator H245_NonStandardParameter &()
2491 {
2492 #ifndef PASN_LEANANDMEAN
2493   PAssert(PIsDescendant(PAssertNULL(choice), H245_NonStandardParameter), PInvalidCast);
2494 #endif
2495   return *(H245_NonStandardParameter *)choice;
2496 }
2497
2498
2499 H245_RTPPayloadType_payloadDescriptor::operator const H245_NonStandardParameter &() const
2500 #endif
2501 {
2502 #ifndef PASN_LEANANDMEAN
2503   PAssert(PIsDescendant(PAssertNULL(choice), H245_NonStandardParameter), PInvalidCast);
2504 #endif
2505   return *(H245_NonStandardParameter *)choice;
2506 }
2507
2508
2509 BOOL H245_RTPPayloadType_payloadDescriptor::CreateObject()
2510 {
2511   switch (tag) {
2512     case e_nonStandardIdentifier :
2513       choice = new H245_NonStandardParameter();
2514       return TRUE;
2515     case e_rfc_number :
2516       choice = new PASN_Integer();
2517       choice->SetConstraints(PASN_Object::ExtendableConstraint, 1, 32768);
2518       return TRUE;
2519     case e_oid :
2520       choice = new PASN_ObjectId();
2521       return TRUE;
2522   }
2523
2524   choice = NULL;
2525   return FALSE;
2526 }
2527
2528
2529 PObject * H245_RTPPayloadType_payloadDescriptor::Clone() const
2530 {
2531 #ifndef PASN_LEANANDMEAN
2532   PAssert(IsClass(H245_RTPPayloadType_payloadDescriptor::Class()), PInvalidCast);
2533 #endif
2534   return new H245_RTPPayloadType_payloadDescriptor(*this);
2535 }
2536
2537
2538 //
2539 // ArrayOf_MultiplePayloadStreamElement
2540 //
2541
2542 H245_ArrayOf_MultiplePayloadStreamElement::H245_ArrayOf_MultiplePayloadStreamElement(unsigned tag, PASN_Object::TagClass tagClass)
2543   : PASN_Array(tag, tagClass)
2544 {
2545 }
2546
2547
2548 PASN_Object * H245_ArrayOf_MultiplePayloadStreamElement::CreateObject() const
2549 {
2550   return new H245_MultiplePayloadStreamElement;
2551 }
2552
2553
2554 H245_MultiplePayloadStreamElement & H245_ArrayOf_MultiplePayloadStreamElement::operator[](PINDEX i) const
2555 {
2556   return (H245_MultiplePayloadStreamElement &)array[i];
2557 }
2558
2559
2560 PObject * H245_ArrayOf_MultiplePayloadStreamElement::Clone() const
2561 {
2562 #ifndef PASN_LEANANDMEAN
2563   PAssert(IsClass(H245_ArrayOf_MultiplePayloadStreamElement::Class()), PInvalidCast);
2564 #endif
2565   return new H245_ArrayOf_MultiplePayloadStreamElement(*this);
2566 }
2567
2568
2569 //
2570 // UnicastAddress_iPAddress
2571 //
2572
2573 H245_UnicastAddress_iPAddress::H245_UnicastAddress_iPAddress(unsigned tag, PASN_Object::TagClass tagClass)
2574   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
2575 {
2576   m_network.SetConstraints(PASN_Object::FixedConstraint, 4);
2577   m_tsapIdentifier.SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
2578 }
2579
2580
2581 #ifndef PASN_NOPRINTON
2582 void H245_UnicastAddress_iPAddress::PrintOn(ostream & strm) const
2583 {
2584   int indent = strm.precision() + 2;
2585   strm << "{\n";
2586   strm << setw(indent+10) << "network = " << setprecision(indent) << m_network << '\n';
2587   strm << setw(indent+17) << "tsapIdentifier = " << setprecision(indent) << m_tsapIdentifier << '\n';
2588   strm << setw(indent-1) << setprecision(indent-2) << "}";
2589 }
2590 #endif
2591
2592
2593 PObject::Comparison H245_UnicastAddress_iPAddress::Compare(const PObject & obj) const
2594 {
2595 #ifndef PASN_LEANANDMEAN
2596   PAssert(PIsDescendant(&obj, H245_UnicastAddress_iPAddress), PInvalidCast);
2597 #endif
2598   const H245_UnicastAddress_iPAddress & other = (const H245_UnicastAddress_iPAddress &)obj;
2599
2600   Comparison result;
2601
2602   if ((result = m_network.Compare(other.m_network)) != EqualTo)
2603     return result;
2604   if ((result = m_tsapIdentifier.Compare(other.m_tsapIdentifier)) != EqualTo)
2605     return result;
2606
2607   return PASN_Sequence::Compare(other);
2608 }
2609
2610
2611 PINDEX H245_UnicastAddress_iPAddress::GetDataLength() const
2612 {
2613   PINDEX length = 0;
2614   length += m_network.GetObjectLength();
2615   length += m_tsapIdentifier.GetObjectLength();
2616   return length;
2617 }
2618
2619
2620 BOOL H245_UnicastAddress_iPAddress::Decode(PASN_Stream & strm)
2621 {
2622   if (!PreambleDecode(strm))
2623     return FALSE;
2624
2625   if (!m_network.Decode(strm))
2626     return FALSE;
2627   if (!m_tsapIdentifier.Decode(strm))
2628     return FALSE;
2629
2630   return UnknownExtensionsDecode(strm);
2631 }
2632
2633
2634 void H245_UnicastAddress_iPAddress::Encode(PASN_Stream & strm) const
2635 {
2636   PreambleEncode(strm);
2637
2638   m_network.Encode(strm);
2639   m_tsapIdentifier.Encode(strm);
2640
2641   UnknownExtensionsEncode(strm);
2642 }
2643
2644
2645 PObject * H245_UnicastAddress_iPAddress::Clone() const
2646 {
2647 #ifndef PASN_LEANANDMEAN
2648   PAssert(IsClass(H245_UnicastAddress_iPAddress::Class()), PInvalidCast);
2649 #endif
2650   return new H245_UnicastAddress_iPAddress(*this);
2651 }
2652
2653
2654 //
2655 // UnicastAddress_iPXAddress
2656 //
2657
2658 H245_UnicastAddress_iPXAddress::H245_UnicastAddress_iPXAddress(unsigned tag, PASN_Object::TagClass tagClass)
2659   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
2660 {
2661   m_node.SetConstraints(PASN_Object::FixedConstraint, 6);
2662   m_netnum.SetConstraints(PASN_Object::FixedConstraint, 4);
2663   m_tsapIdentifier.SetConstraints(PASN_Object::FixedConstraint, 2);
2664 }
2665
2666
2667 #ifndef PASN_NOPRINTON
2668 void H245_UnicastAddress_iPXAddress::PrintOn(ostream & strm) const
2669 {
2670   int indent = strm.precision() + 2;
2671   strm << "{\n";
2672   strm << setw(indent+7) << "node = " << setprecision(indent) << m_node << '\n';
2673   strm << setw(indent+9) << "netnum = " << setprecision(indent) << m_netnum << '\n';
2674   strm << setw(indent+17) << "tsapIdentifier = " << setprecision(indent) << m_tsapIdentifier << '\n';
2675   strm << setw(indent-1) << setprecision(indent-2) << "}";
2676 }
2677 #endif
2678
2679
2680 PObject::Comparison H245_UnicastAddress_iPXAddress::Compare(const PObject & obj) const
2681 {
2682 #ifndef PASN_LEANANDMEAN
2683   PAssert(PIsDescendant(&obj, H245_UnicastAddress_iPXAddress), PInvalidCast);
2684 #endif
2685   const H245_UnicastAddress_iPXAddress & other = (const H245_UnicastAddress_iPXAddress &)obj;
2686
2687   Comparison result;
2688
2689   if ((result = m_node.Compare(other.m_node)) != EqualTo)
2690     return result;
2691   if ((result = m_netnum.Compare(other.m_netnum)) != EqualTo)
2692     return result;
2693   if ((result = m_tsapIdentifier.Compare(other.m_tsapIdentifier)) != EqualTo)
2694     return result;
2695
2696   return PASN_Sequence::Compare(other);
2697 }
2698
2699
2700 PINDEX H245_UnicastAddress_iPXAddress::GetDataLength() const
2701 {
2702   PINDEX length = 0;
2703   length += m_node.GetObjectLength();
2704   length += m_netnum.GetObjectLength();
2705   length += m_tsapIdentifier.GetObjectLength();
2706   return length;
2707 }
2708
2709
2710 BOOL H245_UnicastAddress_iPXAddress::Decode(PASN_Stream & strm)
2711 {
2712   if (!PreambleDecode(strm))
2713     return FALSE;
2714
2715   if (!m_node.Decode(strm))
2716     return FALSE;
2717   if (!m_netnum.Decode(strm))
2718     return FALSE;
2719   if (!m_tsapIdentifier.Decode(strm))
2720     return FALSE;
2721
2722   return UnknownExtensionsDecode(strm);
2723 }
2724
2725
2726 void H245_UnicastAddress_iPXAddress::Encode(PASN_Stream & strm) const
2727 {
2728   PreambleEncode(strm);
2729
2730   m_node.Encode(strm);
2731   m_netnum.Encode(strm);
2732   m_tsapIdentifier.Encode(strm);
2733
2734   UnknownExtensionsEncode(strm);
2735 }
2736
2737
2738 PObject * H245_UnicastAddress_iPXAddress::Clone() const
2739 {
2740 #ifndef PASN_LEANANDMEAN
2741   PAssert(IsClass(H245_UnicastAddress_iPXAddress::Class()), PInvalidCast);
2742 #endif
2743   return new H245_UnicastAddress_iPXAddress(*this);
2744 }
2745
2746
2747 //
2748 // UnicastAddress_iP6Address
2749 //
2750
2751 H245_UnicastAddress_iP6Address::H245_UnicastAddress_iP6Address(unsigned tag, PASN_Object::TagClass tagClass)
2752   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
2753 {
2754   m_network.SetConstraints(PASN_Object::FixedConstraint, 16);
2755   m_tsapIdentifier.SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
2756 }
2757
2758
2759 #ifndef PASN_NOPRINTON
2760 void H245_UnicastAddress_iP6Address::PrintOn(ostream & strm) const
2761 {
2762   int indent = strm.precision() + 2;
2763   strm << "{\n";
2764   strm << setw(indent+10) << "network = " << setprecision(indent) << m_network << '\n';
2765   strm << setw(indent+17) << "tsapIdentifier = " << setprecision(indent) << m_tsapIdentifier << '\n';
2766   strm << setw(indent-1) << setprecision(indent-2) << "}";
2767 }
2768 #endif
2769
2770
2771 PObject::Comparison H245_UnicastAddress_iP6Address::Compare(const PObject & obj) const
2772 {
2773 #ifndef PASN_LEANANDMEAN
2774   PAssert(PIsDescendant(&obj, H245_UnicastAddress_iP6Address), PInvalidCast);
2775 #endif
2776   const H245_UnicastAddress_iP6Address & other = (const H245_UnicastAddress_iP6Address &)obj;
2777
2778   Comparison result;
2779
2780   if ((result = m_network.Compare(other.m_network)) != EqualTo)
2781     return result;
2782   if ((result = m_tsapIdentifier.Compare(other.m_tsapIdentifier)) != EqualTo)
2783     return result;
2784
2785   return PASN_Sequence::Compare(other);
2786 }
2787
2788
2789 PINDEX H245_UnicastAddress_iP6Address::GetDataLength() const
2790 {
2791   PINDEX length = 0;
2792   length += m_network.GetObjectLength();
2793   length += m_tsapIdentifier.GetObjectLength();
2794   return length;
2795 }
2796
2797
2798 BOOL H245_UnicastAddress_iP6Address::Decode(PASN_Stream & strm)
2799 {
2800   if (!PreambleDecode(strm))
2801     return FALSE;
2802
2803   if (!m_network.Decode(strm))
2804     return FALSE;
2805   if (!m_tsapIdentifier.Decode(strm))
2806     return FALSE;
2807
2808   return UnknownExtensionsDecode(strm);
2809 }
2810
2811
2812 void H245_UnicastAddress_iP6Address::Encode(PASN_Stream & strm) const
2813 {
2814   PreambleEncode(strm);
2815
2816   m_network.Encode(strm);
2817   m_tsapIdentifier.Encode(strm);
2818
2819   UnknownExtensionsEncode(strm);
2820 }
2821
2822
2823 PObject * H245_UnicastAddress_iP6Address::Clone() const
2824 {
2825 #ifndef PASN_LEANANDMEAN
2826   PAssert(IsClass(H245_UnicastAddress_iP6Address::Class()), PInvalidCast);
2827 #endif
2828   return new H245_UnicastAddress_iP6Address(*this);
2829 }
2830
2831
2832 //
2833 // MulticastAddress_iPAddress
2834 //
2835
2836 H245_MulticastAddress_iPAddress::H245_MulticastAddress_iPAddress(unsigned tag, PASN_Object::TagClass tagClass)
2837   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
2838 {
2839   m_network.SetConstraints(PASN_Object::FixedConstraint, 4);
2840   m_tsapIdentifier.SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
2841 }
2842
2843
2844 #ifndef PASN_NOPRINTON
2845 void H245_MulticastAddress_iPAddress::PrintOn(ostream & strm) const
2846 {
2847   int indent = strm.precision() + 2;
2848   strm << "{\n";
2849   strm << setw(indent+10) << "network = " << setprecision(indent) << m_network << '\n';
2850   strm << setw(indent+17) << "tsapIdentifier = " << setprecision(indent) << m_tsapIdentifier << '\n';
2851   strm << setw(indent-1) << setprecision(indent-2) << "}";
2852 }
2853 #endif
2854
2855
2856 PObject::Comparison H245_MulticastAddress_iPAddress::Compare(const PObject & obj) const
2857 {
2858 #ifndef PASN_LEANANDMEAN
2859   PAssert(PIsDescendant(&obj, H245_MulticastAddress_iPAddress), PInvalidCast);
2860 #endif
2861   const H245_MulticastAddress_iPAddress & other = (const H245_MulticastAddress_iPAddress &)obj;
2862
2863   Comparison result;
2864
2865   if ((result = m_network.Compare(other.m_network)) != EqualTo)
2866     return result;
2867   if ((result = m_tsapIdentifier.Compare(other.m_tsapIdentifier)) != EqualTo)
2868     return result;
2869
2870   return PASN_Sequence::Compare(other);
2871 }
2872
2873
2874 PINDEX H245_MulticastAddress_iPAddress::GetDataLength() const
2875 {
2876   PINDEX length = 0;
2877   length += m_network.GetObjectLength();
2878   length += m_tsapIdentifier.GetObjectLength();
2879   return length;
2880 }
2881
2882
2883 BOOL H245_MulticastAddress_iPAddress::Decode(PASN_Stream & strm)
2884 {
2885   if (!PreambleDecode(strm))
2886     return FALSE;
2887
2888   if (!m_network.Decode(strm))
2889     return FALSE;
2890   if (!m_tsapIdentifier.Decode(strm))
2891     return FALSE;
2892
2893   return UnknownExtensionsDecode(strm);
2894 }
2895
2896
2897 void H245_MulticastAddress_iPAddress::Encode(PASN_Stream & strm) const
2898 {
2899   PreambleEncode(strm);
2900
2901   m_network.Encode(strm);
2902   m_tsapIdentifier.Encode(strm);
2903
2904   UnknownExtensionsEncode(strm);
2905 }
2906
2907
2908 PObject * H245_MulticastAddress_iPAddress::Clone() const
2909 {
2910 #ifndef PASN_LEANANDMEAN
2911   PAssert(IsClass(H245_MulticastAddress_iPAddress::Class()), PInvalidCast);
2912 #endif
2913   return new H245_MulticastAddress_iPAddress(*this);
2914 }
2915
2916
2917 //
2918 // MulticastAddress_iP6Address
2919 //
2920
2921 H245_MulticastAddress_iP6Address::H245_MulticastAddress_iP6Address(unsigned tag, PASN_Object::TagClass tagClass)
2922   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
2923 {
2924   m_network.SetConstraints(PASN_Object::FixedConstraint, 16);
2925   m_tsapIdentifier.SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
2926 }
2927
2928
2929 #ifndef PASN_NOPRINTON
2930 void H245_MulticastAddress_iP6Address::PrintOn(ostream & strm) const
2931 {
2932   int indent = strm.precision() + 2;
2933   strm << "{\n";
2934   strm << setw(indent+10) << "network = " << setprecision(indent) << m_network << '\n';
2935   strm << setw(indent+17) << "tsapIdentifier = " << setprecision(indent) << m_tsapIdentifier << '\n';
2936   strm << setw(indent-1) << setprecision(indent-2) << "}";
2937 }
2938 #endif
2939
2940
2941 PObject::Comparison H245_MulticastAddress_iP6Address::Compare(const PObject & obj) const
2942 {
2943 #ifndef PASN_LEANANDMEAN
2944   PAssert(PIsDescendant(&obj, H245_MulticastAddress_iP6Address), PInvalidCast);
2945 #endif
2946   const H245_MulticastAddress_iP6Address & other = (const H245_MulticastAddress_iP6Address &)obj;
2947
2948   Comparison result;
2949
2950   if ((result = m_network.Compare(other.m_network)) != EqualTo)
2951     return result;
2952   if ((result = m_tsapIdentifier.Compare(other.m_tsapIdentifier)) != EqualTo)
2953     return result;
2954
2955   return PASN_Sequence::Compare(other);
2956 }
2957
2958
2959 PINDEX H245_MulticastAddress_iP6Address::GetDataLength() const
2960 {
2961   PINDEX length = 0;
2962   length += m_network.GetObjectLength();
2963   length += m_tsapIdentifier.GetObjectLength();
2964   return length;
2965 }
2966
2967
2968 BOOL H245_MulticastAddress_iP6Address::Decode(PASN_Stream & strm)
2969 {
2970   if (!PreambleDecode(strm))
2971     return FALSE;
2972
2973   if (!m_network.Decode(strm))
2974     return FALSE;
2975   if (!m_tsapIdentifier.Decode(strm))
2976     return FALSE;
2977
2978   return UnknownExtensionsDecode(strm);
2979 }
2980
2981
2982 void H245_MulticastAddress_iP6Address::Encode(PASN_Stream & strm) const
2983 {
2984   PreambleEncode(strm);
2985
2986   m_network.Encode(strm);
2987   m_tsapIdentifier.Encode(strm);
2988
2989   UnknownExtensionsEncode(strm);
2990 }
2991
2992
2993 PObject * H245_MulticastAddress_iP6Address::Clone() const
2994 {
2995 #ifndef PASN_LEANANDMEAN
2996   PAssert(IsClass(H245_MulticastAddress_iP6Address::Class()), PInvalidCast);
2997 #endif
2998   return new H245_MulticastAddress_iP6Address(*this);
2999 }
3000
3001
3002 //
3003 // ArrayOf_EscrowData
3004 //
3005
3006 H245_ArrayOf_EscrowData::H245_ArrayOf_EscrowData(unsigned tag, PASN_Object::TagClass tagClass)
3007   : PASN_Array(tag, tagClass)
3008 {
3009 }
3010
3011
3012 PASN_Object * H245_ArrayOf_EscrowData::CreateObject() const
3013 {
3014   return new H245_EscrowData;
3015 }
3016
3017
3018 H245_EscrowData & H245_ArrayOf_EscrowData::operator[](PINDEX i) const
3019 {
3020   return (H245_EscrowData &)array[i];
3021 }
3022
3023
3024 PObject * H245_ArrayOf_EscrowData::Clone() const
3025 {
3026 #ifndef PASN_LEANANDMEAN
3027   PAssert(IsClass(H245_ArrayOf_EscrowData::Class()), PInvalidCast);
3028 #endif
3029   return new H245_ArrayOf_EscrowData(*this);
3030 }
3031
3032
3033
3034 #ifndef PASN_NOPRINTON
3035 const static PASN_Names Names_H245_OpenLogicalChannelAck_forwardMultiplexAckParameters[]={
3036       {"h2250LogicalChannelAckParameters",0}
3037 };
3038 #endif
3039 //
3040 // OpenLogicalChannelAck_forwardMultiplexAckParameters
3041 //
3042
3043 H245_OpenLogicalChannelAck_forwardMultiplexAckParameters::H245_OpenLogicalChannelAck_forwardMultiplexAckParameters(unsigned tag, PASN_Object::TagClass tagClass)
3044   : PASN_Choice(tag, tagClass, 1, TRUE
3045 #ifndef PASN_NOPRINTON
3046     ,(const PASN_Names *)Names_H245_OpenLogicalChannelAck_forwardMultiplexAckParameters,1
3047 #endif
3048 )
3049 {
3050 }
3051
3052
3053 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
3054 H245_OpenLogicalChannelAck_forwardMultiplexAckParameters::operator H245_H2250LogicalChannelAckParameters &() const
3055 #else
3056 H245_OpenLogicalChannelAck_forwardMultiplexAckParameters::operator H245_H2250LogicalChannelAckParameters &()
3057 {
3058 #ifndef PASN_LEANANDMEAN
3059   PAssert(PIsDescendant(PAssertNULL(choice), H245_H2250LogicalChannelAckParameters), PInvalidCast);
3060 #endif
3061   return *(H245_H2250LogicalChannelAckParameters *)choice;
3062 }
3063
3064
3065 H245_OpenLogicalChannelAck_forwardMultiplexAckParameters::operator const H245_H2250LogicalChannelAckParameters &() const
3066 #endif
3067 {
3068 #ifndef PASN_LEANANDMEAN
3069   PAssert(PIsDescendant(PAssertNULL(choice), H245_H2250LogicalChannelAckParameters), PInvalidCast);
3070 #endif
3071   return *(H245_H2250LogicalChannelAckParameters *)choice;
3072 }
3073
3074
3075 BOOL H245_OpenLogicalChannelAck_forwardMultiplexAckParameters::CreateObject()
3076 {
3077   switch (tag) {
3078     case e_h2250LogicalChannelAckParameters :
3079       choice = new H245_H2250LogicalChannelAckParameters();
3080       return TRUE;
3081   }
3082
3083   choice = NULL;
3084   return FALSE;
3085 }
3086
3087
3088 PObject * H245_OpenLogicalChannelAck_forwardMultiplexAckParameters::Clone() const
3089 {
3090 #ifndef PASN_LEANANDMEAN
3091   PAssert(IsClass(H245_OpenLogicalChannelAck_forwardMultiplexAckParameters::Class()), PInvalidCast);
3092 #endif
3093   return new H245_OpenLogicalChannelAck_forwardMultiplexAckParameters(*this);
3094 }
3095
3096
3097
3098 #ifndef PASN_NOPRINTON
3099 const static PASN_Names Names_H245_OpenLogicalChannelReject_cause[]={
3100       {"unspecified",0}
3101      ,{"unsuitableReverseParameters",1}
3102      ,{"dataTypeNotSupported",2}
3103      ,{"dataTypeNotAvailable",3}
3104      ,{"unknownDataType",4}
3105      ,{"dataTypeALCombinationNotSupported",5}
3106      ,{"multicastChannelNotAllowed",6}
3107      ,{"insufficientBandwidth",7}
3108      ,{"separateStackEstablishmentFailed",8}
3109      ,{"invalidSessionID",9}
3110      ,{"masterSlaveConflict",10}
3111      ,{"waitForCommunicationMode",11}
3112      ,{"invalidDependentChannel",12}
3113      ,{"replacementForRejected",13}
3114      ,{"securityDenied",14}
3115 };
3116 #endif
3117 //
3118 // OpenLogicalChannelReject_cause
3119 //
3120
3121 H245_OpenLogicalChannelReject_cause::H245_OpenLogicalChannelReject_cause(unsigned tag, PASN_Object::TagClass tagClass)
3122   : PASN_Choice(tag, tagClass, 6, TRUE
3123 #ifndef PASN_NOPRINTON
3124     ,(const PASN_Names *)Names_H245_OpenLogicalChannelReject_cause,15
3125 #endif
3126 )
3127 {
3128 }
3129
3130
3131 BOOL H245_OpenLogicalChannelReject_cause::CreateObject()
3132 {
3133   choice = (tag <= e_securityDenied) ? new PASN_Null() : NULL;
3134   return choice != NULL;
3135 }
3136
3137
3138 PObject * H245_OpenLogicalChannelReject_cause::Clone() const
3139 {
3140 #ifndef PASN_LEANANDMEAN
3141   PAssert(IsClass(H245_OpenLogicalChannelReject_cause::Class()), PInvalidCast);
3142 #endif
3143   return new H245_OpenLogicalChannelReject_cause(*this);
3144 }
3145
3146
3147
3148 #ifndef PASN_NOPRINTON
3149 const static PASN_Names Names_H245_CloseLogicalChannel_source[]={
3150       {"user",0}
3151      ,{"lcse",1}
3152 };
3153 #endif
3154 //
3155 // CloseLogicalChannel_source
3156 //
3157
3158 H245_CloseLogicalChannel_source::H245_CloseLogicalChannel_source(unsigned tag, PASN_Object::TagClass tagClass)
3159   : PASN_Choice(tag, tagClass, 2, FALSE
3160 #ifndef PASN_NOPRINTON
3161     ,(const PASN_Names *)Names_H245_CloseLogicalChannel_source,2
3162 #endif
3163 )
3164 {
3165 }
3166
3167
3168 BOOL H245_CloseLogicalChannel_source::CreateObject()
3169 {
3170   choice = (tag <= e_lcse) ? new PASN_Null() : NULL;
3171   return choice != NULL;
3172 }
3173
3174
3175 PObject * H245_CloseLogicalChannel_source::Clone() const
3176 {
3177 #ifndef PASN_LEANANDMEAN
3178   PAssert(IsClass(H245_CloseLogicalChannel_source::Class()), PInvalidCast);
3179 #endif
3180   return new H245_CloseLogicalChannel_source(*this);
3181 }
3182
3183
3184
3185 #ifndef PASN_NOPRINTON
3186 const static PASN_Names Names_H245_CloseLogicalChannel_reason[]={
3187       {"unknown",0}
3188      ,{"reopen",1}
3189      ,{"reservationFailure",2}
3190 };
3191 #endif
3192 //
3193 // CloseLogicalChannel_reason
3194 //
3195
3196 H245_CloseLogicalChannel_reason::H245_CloseLogicalChannel_reason(unsigned tag, PASN_Object::TagClass tagClass)
3197   : PASN_Choice(tag, tagClass, 3, TRUE
3198 #ifndef PASN_NOPRINTON
3199     ,(const PASN_Names *)Names_H245_CloseLogicalChannel_reason,3
3200 #endif
3201 )
3202 {
3203 }
3204
3205
3206 BOOL H245_CloseLogicalChannel_reason::CreateObject()
3207 {
3208   choice = (tag <= e_reservationFailure) ? new PASN_Null() : NULL;
3209   return choice != NULL;
3210 }
3211
3212
3213 PObject * H245_CloseLogicalChannel_reason::Clone() const
3214 {
3215 #ifndef PASN_LEANANDMEAN
3216   PAssert(IsClass(H245_CloseLogicalChannel_reason::Class()), PInvalidCast);
3217 #endif
3218   return new H245_CloseLogicalChannel_reason(*this);
3219 }
3220
3221
3222
3223 #ifndef PASN_NOPRINTON
3224 const static PASN_Names Names_H245_RequestChannelClose_reason[]={
3225       {"unknown",0}
3226      ,{"normal",1}
3227      ,{"reopen",2}
3228      ,{"reservationFailure",3}
3229 };
3230 #endif
3231 //
3232 // RequestChannelClose_reason
3233 //
3234
3235 H245_RequestChannelClose_reason::H245_RequestChannelClose_reason(unsigned tag, PASN_Object::TagClass tagClass)
3236   : PASN_Choice(tag, tagClass, 4, TRUE
3237 #ifndef PASN_NOPRINTON
3238     ,(const PASN_Names *)Names_H245_RequestChannelClose_reason,4
3239 #endif
3240 )
3241 {
3242 }
3243
3244
3245 BOOL H245_RequestChannelClose_reason::CreateObject()
3246 {
3247   choice = (tag <= e_reservationFailure) ? new PASN_Null() : NULL;
3248   return choice != NULL;
3249 }
3250
3251
3252 PObject * H245_RequestChannelClose_reason::Clone() const
3253 {
3254 #ifndef PASN_LEANANDMEAN
3255   PAssert(IsClass(H245_RequestChannelClose_reason::Class()), PInvalidCast);
3256 #endif
3257   return new H245_RequestChannelClose_reason(*this);
3258 }
3259
3260
3261
3262 #ifndef PASN_NOPRINTON
3263 const static PASN_Names Names_H245_RequestChannelCloseReject_cause[]={
3264       {"unspecified",0}
3265 };
3266 #endif
3267 //
3268 // RequestChannelCloseReject_cause
3269 //
3270
3271 H245_RequestChannelCloseReject_cause::H245_RequestChannelCloseReject_cause(unsigned tag, PASN_Object::TagClass tagClass)
3272   : PASN_Choice(tag, tagClass, 1, TRUE
3273 #ifndef PASN_NOPRINTON
3274     ,(const PASN_Names *)Names_H245_RequestChannelCloseReject_cause,1
3275 #endif
3276 )
3277 {
3278 }
3279
3280
3281 BOOL H245_RequestChannelCloseReject_cause::CreateObject()
3282 {
3283   choice = (tag <= e_unspecified) ? new PASN_Null() : NULL;
3284   return choice != NULL;
3285 }
3286
3287
3288 PObject * H245_RequestChannelCloseReject_cause::Clone() const
3289 {
3290 #ifndef PASN_LEANANDMEAN
3291   PAssert(IsClass(H245_RequestChannelCloseReject_cause::Class()), PInvalidCast);
3292 #endif
3293   return new H245_RequestChannelCloseReject_cause(*this);
3294 }
3295
3296
3297 //
3298 // ArrayOf_MultiplexEntryDescriptor
3299 //
3300
3301 H245_ArrayOf_MultiplexEntryDescriptor::H245_ArrayOf_MultiplexEntryDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
3302   : PASN_Array(tag, tagClass)
3303 {
3304 }
3305
3306
3307 PASN_Object * H245_ArrayOf_MultiplexEntryDescriptor::CreateObject() const
3308 {
3309   return new H245_MultiplexEntryDescriptor;
3310 }
3311
3312
3313 H245_MultiplexEntryDescriptor & H245_ArrayOf_MultiplexEntryDescriptor::operator[](PINDEX i) const
3314 {
3315   return (H245_MultiplexEntryDescriptor &)array[i];
3316 }
3317
3318
3319 PObject * H245_ArrayOf_MultiplexEntryDescriptor::Clone() const
3320 {
3321 #ifndef PASN_LEANANDMEAN
3322   PAssert(IsClass(H245_ArrayOf_MultiplexEntryDescriptor::Class()), PInvalidCast);
3323 #endif
3324   return new H245_ArrayOf_MultiplexEntryDescriptor(*this);
3325 }
3326
3327
3328 //
3329 // ArrayOf_MultiplexElement
3330 //
3331
3332 H245_ArrayOf_MultiplexElement::H245_ArrayOf_MultiplexElement(unsigned tag, PASN_Object::TagClass tagClass)
3333   : PASN_Array(tag, tagClass)
3334 {
3335 }
3336
3337
3338 PASN_Object * H245_ArrayOf_MultiplexElement::CreateObject() const
3339 {
3340   return new H245_MultiplexElement;
3341 }
3342
3343
3344 H245_MultiplexElement & H245_ArrayOf_MultiplexElement::operator[](PINDEX i) const
3345 {
3346   return (H245_MultiplexElement &)array[i];
3347 }
3348
3349
3350 PObject * H245_ArrayOf_MultiplexElement::Clone() const
3351 {
3352 #ifndef PASN_LEANANDMEAN
3353   PAssert(IsClass(H245_ArrayOf_MultiplexElement::Class()), PInvalidCast);
3354 #endif
3355   return new H245_ArrayOf_MultiplexElement(*this);
3356 }
3357
3358
3359
3360 #ifndef PASN_NOPRINTON
3361 const static PASN_Names Names_H245_MultiplexElement_type[]={
3362       {"logicalChannelNumber",0}
3363      ,{"subElementList",1}
3364 };
3365 #endif
3366 //
3367 // MultiplexElement_type
3368 //
3369
3370 H245_MultiplexElement_type::H245_MultiplexElement_type(unsigned tag, PASN_Object::TagClass tagClass)
3371   : PASN_Choice(tag, tagClass, 2, FALSE
3372 #ifndef PASN_NOPRINTON
3373     ,(const PASN_Names *)Names_H245_MultiplexElement_type,2
3374 #endif
3375 )
3376 {
3377 }
3378
3379
3380 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
3381 H245_MultiplexElement_type::operator H245_ArrayOf_MultiplexElement &() const
3382 #else
3383 H245_MultiplexElement_type::operator H245_ArrayOf_MultiplexElement &()
3384 {
3385 #ifndef PASN_LEANANDMEAN
3386   PAssert(PIsDescendant(PAssertNULL(choice), H245_ArrayOf_MultiplexElement), PInvalidCast);
3387 #endif
3388   return *(H245_ArrayOf_MultiplexElement *)choice;
3389 }
3390
3391
3392 H245_MultiplexElement_type::operator const H245_ArrayOf_MultiplexElement &() const
3393 #endif
3394 {
3395 #ifndef PASN_LEANANDMEAN
3396   PAssert(PIsDescendant(PAssertNULL(choice), H245_ArrayOf_MultiplexElement), PInvalidCast);
3397 #endif
3398   return *(H245_ArrayOf_MultiplexElement *)choice;
3399 }
3400
3401
3402 BOOL H245_MultiplexElement_type::CreateObject()
3403 {
3404   switch (tag) {
3405     case e_logicalChannelNumber :
3406       choice = new PASN_Integer();
3407       choice->SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
3408       return TRUE;
3409     case e_subElementList :
3410       choice = new H245_ArrayOf_MultiplexElement();
3411       choice->SetConstraints(PASN_Object::FixedConstraint, 2, 255);
3412       return TRUE;
3413   }
3414
3415   choice = NULL;
3416   return FALSE;
3417 }
3418
3419
3420 PObject * H245_MultiplexElement_type::Clone() const
3421 {
3422 #ifndef PASN_LEANANDMEAN
3423   PAssert(IsClass(H245_MultiplexElement_type::Class()), PInvalidCast);
3424 #endif
3425   return new H245_MultiplexElement_type(*this);
3426 }
3427
3428
3429
3430 #ifndef PASN_NOPRINTON
3431 const static PASN_Names Names_H245_MultiplexElement_repeatCount[]={
3432       {"finite",0}
3433      ,{"untilClosingFlag",1}
3434 };
3435 #endif
3436 //
3437 // MultiplexElement_repeatCount
3438 //
3439
3440 H245_MultiplexElement_repeatCount::H245_MultiplexElement_repeatCount(unsigned tag, PASN_Object::TagClass tagClass)
3441   : PASN_Choice(tag, tagClass, 2, FALSE
3442 #ifndef PASN_NOPRINTON
3443     ,(const PASN_Names *)Names_H245_MultiplexElement_repeatCount,2
3444 #endif
3445 )
3446 {
3447 }
3448
3449
3450 BOOL H245_MultiplexElement_repeatCount::CreateObject()
3451 {
3452   switch (tag) {
3453     case e_finite :
3454       choice = new PASN_Integer();
3455       choice->SetConstraints(PASN_Object::FixedConstraint, 1, 65535);
3456       return TRUE;
3457     case e_untilClosingFlag :
3458       choice = new PASN_Null();
3459       return TRUE;
3460   }
3461
3462   choice = NULL;
3463   return FALSE;
3464 }
3465
3466
3467 PObject * H245_MultiplexElement_repeatCount::Clone() const
3468 {
3469 #ifndef PASN_LEANANDMEAN
3470   PAssert(IsClass(H245_MultiplexElement_repeatCount::Class()), PInvalidCast);
3471 #endif
3472   return new H245_MultiplexElement_repeatCount(*this);
3473 }
3474
3475
3476 //
3477 // ArrayOf_MultiplexTableEntryNumber
3478 //
3479
3480 H245_ArrayOf_MultiplexTableEntryNumber::H245_ArrayOf_MultiplexTableEntryNumber(unsigned tag, PASN_Object::TagClass tagClass)
3481   : PASN_Array(tag, tagClass)
3482 {
3483 }
3484
3485
3486 PASN_Object * H245_ArrayOf_MultiplexTableEntryNumber::CreateObject() const
3487 {
3488   return new H245_MultiplexTableEntryNumber;
3489 }
3490
3491
3492 H245_MultiplexTableEntryNumber & H245_ArrayOf_MultiplexTableEntryNumber::operator[](PINDEX i) const
3493 {
3494   return (H245_MultiplexTableEntryNumber &)array[i];
3495 }
3496
3497
3498 PObject * H245_ArrayOf_MultiplexTableEntryNumber::Clone() const
3499 {
3500 #ifndef PASN_LEANANDMEAN
3501   PAssert(IsClass(H245_ArrayOf_MultiplexTableEntryNumber::Class()), PInvalidCast);
3502 #endif
3503   return new H245_ArrayOf_MultiplexTableEntryNumber(*this);
3504 }
3505
3506
3507 //
3508 // ArrayOf_MultiplexEntryRejectionDescriptions
3509 //
3510
3511 H245_ArrayOf_MultiplexEntryRejectionDescriptions::H245_ArrayOf_MultiplexEntryRejectionDescriptions(unsigned tag, PASN_Object::TagClass tagClass)
3512   : PASN_Array(tag, tagClass)
3513 {
3514 }
3515
3516
3517 PASN_Object * H245_ArrayOf_MultiplexEntryRejectionDescriptions::CreateObject() const
3518 {
3519   return new H245_MultiplexEntryRejectionDescriptions;
3520 }
3521
3522
3523 H245_MultiplexEntryRejectionDescriptions & H245_ArrayOf_MultiplexEntryRejectionDescriptions::operator[](PINDEX i) const
3524 {
3525   return (H245_MultiplexEntryRejectionDescriptions &)array[i];
3526 }
3527
3528
3529 PObject * H245_ArrayOf_MultiplexEntryRejectionDescriptions::Clone() const
3530 {
3531 #ifndef PASN_LEANANDMEAN
3532   PAssert(IsClass(H245_ArrayOf_MultiplexEntryRejectionDescriptions::Class()), PInvalidCast);
3533 #endif
3534   return new H245_ArrayOf_MultiplexEntryRejectionDescriptions(*this);
3535 }
3536
3537
3538
3539 #ifndef PASN_NOPRINTON
3540 const static PASN_Names Names_H245_MultiplexEntryRejectionDescriptions_cause[]={
3541       {"unspecifiedCause",0}
3542      ,{"descriptorTooComplex",1}
3543 };
3544 #endif
3545 //
3546 // MultiplexEntryRejectionDescriptions_cause
3547 //
3548
3549 H245_MultiplexEntryRejectionDescriptions_cause::H245_MultiplexEntryRejectionDescriptions_cause(unsigned tag, PASN_Object::TagClass tagClass)
3550   : PASN_Choice(tag, tagClass, 2, TRUE
3551 #ifndef PASN_NOPRINTON
3552     ,(const PASN_Names *)Names_H245_MultiplexEntryRejectionDescriptions_cause,2
3553 #endif
3554 )
3555 {
3556 }
3557
3558
3559 BOOL H245_MultiplexEntryRejectionDescriptions_cause::CreateObject()
3560 {
3561   choice = (tag <= e_descriptorTooComplex) ? new PASN_Null() : NULL;
3562   return choice != NULL;
3563 }
3564
3565
3566 PObject * H245_MultiplexEntryRejectionDescriptions_cause::Clone() const
3567 {
3568 #ifndef PASN_LEANANDMEAN
3569   PAssert(IsClass(H245_MultiplexEntryRejectionDescriptions_cause::Class()), PInvalidCast);
3570 #endif
3571   return new H245_MultiplexEntryRejectionDescriptions_cause(*this);
3572 }
3573
3574
3575 //
3576 // ArrayOf_RequestMultiplexEntryRejectionDescriptions
3577 //
3578
3579 H245_ArrayOf_RequestMultiplexEntryRejectionDescriptions::H245_ArrayOf_RequestMultiplexEntryRejectionDescriptions(unsigned tag, PASN_Object::TagClass tagClass)
3580   : PASN_Array(tag, tagClass)
3581 {
3582 }
3583
3584
3585 PASN_Object * H245_ArrayOf_RequestMultiplexEntryRejectionDescriptions::CreateObject() const
3586 {
3587   return new H245_RequestMultiplexEntryRejectionDescriptions;
3588 }
3589
3590
3591 H245_RequestMultiplexEntryRejectionDescriptions & H245_ArrayOf_RequestMultiplexEntryRejectionDescriptions::operator[](PINDEX i) const
3592 {
3593   return (H245_RequestMultiplexEntryRejectionDescriptions &)array[i];
3594 }
3595
3596
3597 PObject * H245_ArrayOf_RequestMultiplexEntryRejectionDescriptions::Clone() const
3598 {
3599 #ifndef PASN_LEANANDMEAN
3600   PAssert(IsClass(H245_ArrayOf_RequestMultiplexEntryRejectionDescriptions::Class()), PInvalidCast);
3601 #endif
3602   return new H245_ArrayOf_RequestMultiplexEntryRejectionDescriptions(*this);
3603 }
3604
3605
3606
3607 #ifndef PASN_NOPRINTON
3608 const static PASN_Names Names_H245_RequestMultiplexEntryRejectionDescriptions_cause[]={
3609       {"unspecifiedCause",0}
3610 };
3611 #endif
3612 //
3613 // RequestMultiplexEntryRejectionDescriptions_cause
3614 //
3615
3616 H245_RequestMultiplexEntryRejectionDescriptions_cause::H245_RequestMultiplexEntryRejectionDescriptions_cause(unsigned tag, PASN_Object::TagClass tagClass)
3617   : PASN_Choice(tag, tagClass, 1, TRUE
3618 #ifndef PASN_NOPRINTON
3619     ,(const PASN_Names *)Names_H245_RequestMultiplexEntryRejectionDescriptions_cause,1
3620 #endif
3621 )
3622 {
3623 }
3624
3625
3626 BOOL H245_RequestMultiplexEntryRejectionDescriptions_cause::CreateObject()
3627 {
3628   choice = (tag <= e_unspecifiedCause) ? new PASN_Null() : NULL;
3629   return choice != NULL;
3630 }
3631
3632
3633 PObject * H245_RequestMultiplexEntryRejectionDescriptions_cause::Clone() const
3634 {
3635 #ifndef PASN_LEANANDMEAN
3636   PAssert(IsClass(H245_RequestMultiplexEntryRejectionDescriptions_cause::Class()), PInvalidCast);
3637 #endif
3638   return new H245_RequestMultiplexEntryRejectionDescriptions_cause(*this);
3639 }
3640
3641
3642 //
3643 // ArrayOf_ModeDescription
3644 //
3645
3646 H245_ArrayOf_ModeDescription::H245_ArrayOf_ModeDescription(unsigned tag, PASN_Object::TagClass tagClass)
3647   : PASN_Array(tag, tagClass)
3648 {
3649 }
3650
3651
3652 PASN_Object * H245_ArrayOf_ModeDescription::CreateObject() const
3653 {
3654   return new H245_ModeDescription;
3655 }
3656
3657
3658 H245_ModeDescription & H245_ArrayOf_ModeDescription::operator[](PINDEX i) const
3659 {
3660   return (H245_ModeDescription &)array[i];
3661 }
3662
3663
3664 PObject * H245_ArrayOf_ModeDescription::Clone() const
3665 {
3666 #ifndef PASN_LEANANDMEAN
3667   PAssert(IsClass(H245_ArrayOf_ModeDescription::Class()), PInvalidCast);
3668 #endif
3669   return new H245_ArrayOf_ModeDescription(*this);
3670 }
3671
3672
3673
3674 #ifndef PASN_NOPRINTON
3675 const static PASN_Names Names_H245_RequestModeAck_response[]={
3676       {"willTransmitMostPreferredMode",0}
3677      ,{"willTransmitLessPreferredMode",1}
3678 };
3679 #endif
3680 //
3681 // RequestModeAck_response
3682 //
3683
3684 H245_RequestModeAck_response::H245_RequestModeAck_response(unsigned tag, PASN_Object::TagClass tagClass)
3685   : PASN_Choice(tag, tagClass, 2, TRUE
3686 #ifndef PASN_NOPRINTON
3687     ,(const PASN_Names *)Names_H245_RequestModeAck_response,2
3688 #endif
3689 )
3690 {
3691 }
3692
3693
3694 BOOL H245_RequestModeAck_response::CreateObject()
3695 {
3696   choice = (tag <= e_willTransmitLessPreferredMode) ? new PASN_Null() : NULL;
3697   return choice != NULL;
3698 }
3699
3700
3701 PObject * H245_RequestModeAck_response::Clone() const
3702 {
3703 #ifndef PASN_LEANANDMEAN
3704   PAssert(IsClass(H245_RequestModeAck_response::Class()), PInvalidCast);
3705 #endif
3706   return new H245_RequestModeAck_response(*this);
3707 }
3708
3709
3710
3711 #ifndef PASN_NOPRINTON
3712 const static PASN_Names Names_H245_RequestModeReject_cause[]={
3713       {"modeUnavailable",0}
3714      ,{"multipointConstraint",1}
3715      ,{"requestDenied",2}
3716 };
3717 #endif
3718 //
3719 // RequestModeReject_cause
3720 //
3721
3722 H245_RequestModeReject_cause::H245_RequestModeReject_cause(unsigned tag, PASN_Object::TagClass tagClass)
3723   : PASN_Choice(tag, tagClass, 3, TRUE
3724 #ifndef PASN_NOPRINTON
3725     ,(const PASN_Names *)Names_H245_RequestModeReject_cause,3
3726 #endif
3727 )
3728 {
3729 }
3730
3731
3732 BOOL H245_RequestModeReject_cause::CreateObject()
3733 {
3734   choice = (tag <= e_requestDenied) ? new PASN_Null() : NULL;
3735   return choice != NULL;
3736 }
3737
3738
3739 PObject * H245_RequestModeReject_cause::Clone() const
3740 {
3741 #ifndef PASN_LEANANDMEAN
3742   PAssert(IsClass(H245_RequestModeReject_cause::Class()), PInvalidCast);
3743 #endif
3744   return new H245_RequestModeReject_cause(*this);
3745 }
3746
3747
3748
3749 #ifndef PASN_NOPRINTON
3750 const static PASN_Names Names_H245_H235Mode_mediaMode[]={
3751       {"nonStandard",0}
3752      ,{"videoMode",1}
3753      ,{"audioMode",2}
3754      ,{"dataMode",3}
3755 };
3756 #endif
3757 //
3758 // H235Mode_mediaMode
3759 //
3760
3761 H245_H235Mode_mediaMode::H245_H235Mode_mediaMode(unsigned tag, PASN_Object::TagClass tagClass)
3762   : PASN_Choice(tag, tagClass, 4, TRUE
3763 #ifndef PASN_NOPRINTON
3764     ,(const PASN_Names *)Names_H245_H235Mode_mediaMode,4
3765 #endif
3766 )
3767 {
3768 }
3769
3770
3771 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
3772 H245_H235Mode_mediaMode::operator H245_NonStandardParameter &() const
3773 #else
3774 H245_H235Mode_mediaMode::operator H245_NonStandardParameter &()
3775 {
3776 #ifndef PASN_LEANANDMEAN
3777   PAssert(PIsDescendant(PAssertNULL(choice), H245_NonStandardParameter), PInvalidCast);
3778 #endif
3779   return *(H245_NonStandardParameter *)choice;
3780 }
3781
3782
3783 H245_H235Mode_mediaMode::operator const H245_NonStandardParameter &() const
3784 #endif
3785 {
3786 #ifndef PASN_LEANANDMEAN
3787   PAssert(PIsDescendant(PAssertNULL(choice), H245_NonStandardParameter), PInvalidCast);
3788 #endif
3789   return *(H245_NonStandardParameter *)choice;
3790 }
3791
3792
3793 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
3794 H245_H235Mode_mediaMode::operator H245_VideoMode &() const
3795 #else
3796 H245_H235Mode_mediaMode::operator H245_VideoMode &()
3797 {
3798 #ifndef PASN_LEANANDMEAN
3799   PAssert(PIsDescendant(PAssertNULL(choice), H245_VideoMode), PInvalidCast);
3800 #endif
3801   return *(H245_VideoMode *)choice;
3802 }
3803
3804
3805 H245_H235Mode_mediaMode::operator const H245_VideoMode &() const
3806 #endif
3807 {
3808 #ifndef PASN_LEANANDMEAN
3809   PAssert(PIsDescendant(PAssertNULL(choice), H245_VideoMode), PInvalidCast);
3810 #endif
3811   return *(H245_VideoMode *)choice;
3812 }
3813
3814
3815 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
3816 H245_H235Mode_mediaMode::operator H245_AudioMode &() const
3817 #else
3818 H245_H235Mode_mediaMode::operator H245_AudioMode &()
3819 {
3820 #ifndef PASN_LEANANDMEAN
3821   PAssert(PIsDescendant(PAssertNULL(choice), H245_AudioMode), PInvalidCast);
3822 #endif
3823   return *(H245_AudioMode *)choice;
3824 }
3825
3826
3827 H245_H235Mode_mediaMode::operator const H245_AudioMode &() const
3828 #endif
3829 {
3830 #ifndef PASN_LEANANDMEAN
3831   PAssert(PIsDescendant(PAssertNULL(choice), H245_AudioMode), PInvalidCast);
3832 #endif
3833   return *(H245_AudioMode *)choice;
3834 }
3835
3836
3837 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
3838 H245_H235Mode_mediaMode::operator H245_DataMode &() const
3839 #else
3840 H245_H235Mode_mediaMode::operator H245_DataMode &()
3841 {
3842 #ifndef PASN_LEANANDMEAN
3843   PAssert(PIsDescendant(PAssertNULL(choice), H245_DataMode), PInvalidCast);
3844 #endif
3845   return *(H245_DataMode *)choice;
3846 }
3847
3848
3849 H245_H235Mode_mediaMode::operator const H245_DataMode &() const
3850 #endif
3851 {
3852 #ifndef PASN_LEANANDMEAN
3853   PAssert(PIsDescendant(PAssertNULL(choice), H245_DataMode), PInvalidCast);
3854 #endif
3855   return *(H245_DataMode *)choice;
3856 }
3857
3858
3859 BOOL H245_H235Mode_mediaMode::CreateObject()
3860 {
3861   switch (tag) {
3862     case e_nonStandard :
3863       choice = new H245_NonStandardParameter();
3864       return TRUE;
3865     case e_videoMode :
3866       choice = new H245_VideoMode();
3867       return TRUE;
3868     case e_audioMode :
3869       choice = new H245_AudioMode();
3870       return TRUE;
3871     case e_dataMode :
3872       choice = new H245_DataMode();
3873       return TRUE;
3874   }
3875
3876   choice = NULL;
3877   return FALSE;
3878 }
3879
3880
3881 PObject * H245_H235Mode_mediaMode::Clone() const
3882 {
3883 #ifndef PASN_LEANANDMEAN
3884   PAssert(IsClass(H245_H235Mode_mediaMode::Class()), PInvalidCast);
3885 #endif
3886   return new H245_H235Mode_mediaMode(*this);
3887 }
3888
3889
3890 //
3891 // ArrayOf_RedundancyEncodingDTModeElement
3892 //
3893
3894 H245_ArrayOf_RedundancyEncodingDTModeElement::H245_ArrayOf_RedundancyEncodingDTModeElement(unsigned tag, PASN_Object::TagClass tagClass)
3895   : PASN_Array(tag, tagClass)
3896 {
3897 }
3898
3899
3900 PASN_Object * H245_ArrayOf_RedundancyEncodingDTModeElement::CreateObject() const
3901 {
3902   return new H245_RedundancyEncodingDTModeElement;
3903 }
3904
3905
3906 H245_RedundancyEncodingDTModeElement & H245_ArrayOf_RedundancyEncodingDTModeElement::operator[](PINDEX i) const
3907 {
3908   return (H245_RedundancyEncodingDTModeElement &)array[i];
3909 }
3910
3911
3912 PObject * H245_ArrayOf_RedundancyEncodingDTModeElement::Clone() const
3913 {
3914 #ifndef PASN_LEANANDMEAN
3915   PAssert(IsClass(H245_ArrayOf_RedundancyEncodingDTModeElement::Class()), PInvalidCast);
3916 #endif
3917   return new H245_ArrayOf_RedundancyEncodingDTModeElement(*this);
3918 }
3919
3920
3921
3922 #ifndef PASN_NOPRINTON
3923 const static PASN_Names Names_H245_RedundancyEncodingDTModeElement_type[]={
3924       {"nonStandard",0}
3925      ,{"videoMode",1}
3926      ,{"audioMode",2}
3927      ,{"dataMode",3}
3928      ,{"encryptionMode",4}
3929      ,{"h235Mode",5}
3930      ,{"fecMode",6}
3931 };
3932 #endif
3933 //
3934 // RedundancyEncodingDTModeElement_type
3935 //
3936
3937 H245_RedundancyEncodingDTModeElement_type::H245_RedundancyEncodingDTModeElement_type(unsigned tag, PASN_Object::TagClass tagClass)
3938   : PASN_Choice(tag, tagClass, 6, TRUE
3939 #ifndef PASN_NOPRINTON
3940     ,(const PASN_Names *)Names_H245_RedundancyEncodingDTModeElement_type,7
3941 #endif
3942 )
3943 {
3944 }
3945
3946
3947 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
3948 H245_RedundancyEncodingDTModeElement_type::operator H245_NonStandardParameter &() const
3949 #else
3950 H245_RedundancyEncodingDTModeElement_type::operator H245_NonStandardParameter &()
3951 {
3952 #ifndef PASN_LEANANDMEAN
3953   PAssert(PIsDescendant(PAssertNULL(choice), H245_NonStandardParameter), PInvalidCast);
3954 #endif
3955   return *(H245_NonStandardParameter *)choice;
3956 }
3957
3958
3959 H245_RedundancyEncodingDTModeElement_type::operator const H245_NonStandardParameter &() const
3960 #endif
3961 {
3962 #ifndef PASN_LEANANDMEAN
3963   PAssert(PIsDescendant(PAssertNULL(choice), H245_NonStandardParameter), PInvalidCast);
3964 #endif
3965   return *(H245_NonStandardParameter *)choice;
3966 }
3967
3968
3969 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
3970 H245_RedundancyEncodingDTModeElement_type::operator H245_VideoMode &() const
3971 #else
3972 H245_RedundancyEncodingDTModeElement_type::operator H245_VideoMode &()
3973 {
3974 #ifndef PASN_LEANANDMEAN
3975   PAssert(PIsDescendant(PAssertNULL(choice), H245_VideoMode), PInvalidCast);
3976 #endif
3977   return *(H245_VideoMode *)choice;
3978 }
3979
3980
3981 H245_RedundancyEncodingDTModeElement_type::operator const H245_VideoMode &() const
3982 #endif
3983 {
3984 #ifndef PASN_LEANANDMEAN
3985   PAssert(PIsDescendant(PAssertNULL(choice), H245_VideoMode), PInvalidCast);
3986 #endif
3987   return *(H245_VideoMode *)choice;
3988 }
3989
3990
3991 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
3992 H245_RedundancyEncodingDTModeElement_type::operator H245_AudioMode &() const
3993 #else
3994 H245_RedundancyEncodingDTModeElement_type::operator H245_AudioMode &()
3995 {
3996 #ifndef PASN_LEANANDMEAN
3997   PAssert(PIsDescendant(PAssertNULL(choice), H245_AudioMode), PInvalidCast);
3998 #endif
3999   return *(H245_AudioMode *)choice;
4000 }
4001
4002
4003 H245_RedundancyEncodingDTModeElement_type::operator const H245_AudioMode &() const
4004 #endif
4005 {
4006 #ifndef PASN_LEANANDMEAN
4007   PAssert(PIsDescendant(PAssertNULL(choice), H245_AudioMode), PInvalidCast);
4008 #endif
4009   return *(H245_AudioMode *)choice;
4010 }
4011
4012
4013 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
4014 H245_RedundancyEncodingDTModeElement_type::operator H245_DataMode &() const
4015 #else
4016 H245_RedundancyEncodingDTModeElement_type::operator H245_DataMode &()
4017 {
4018 #ifndef PASN_LEANANDMEAN
4019   PAssert(PIsDescendant(PAssertNULL(choice), H245_DataMode), PInvalidCast);
4020 #endif
4021   return *(H245_DataMode *)choice;
4022 }
4023
4024
4025 H245_RedundancyEncodingDTModeElement_type::operator const H245_DataMode &() const
4026 #endif
4027 {
4028 #ifndef PASN_LEANANDMEAN
4029   PAssert(PIsDescendant(PAssertNULL(choice), H245_DataMode), PInvalidCast);
4030 #endif
4031   return *(H245_DataMode *)choice;
4032 }
4033
4034
4035 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
4036 H245_RedundancyEncodingDTModeElement_type::operator H245_EncryptionMode &() const
4037 #else
4038 H245_RedundancyEncodingDTModeElement_type::operator H245_EncryptionMode &()
4039 {
4040 #ifndef PASN_LEANANDMEAN
4041   PAssert(PIsDescendant(PAssertNULL(choice), H245_EncryptionMode), PInvalidCast);
4042 #endif
4043   return *(H245_EncryptionMode *)choice;
4044 }
4045
4046
4047 H245_RedundancyEncodingDTModeElement_type::operator const H245_EncryptionMode &() const
4048 #endif
4049 {
4050 #ifndef PASN_LEANANDMEAN
4051   PAssert(PIsDescendant(PAssertNULL(choice), H245_EncryptionMode), PInvalidCast);
4052 #endif
4053   return *(H245_EncryptionMode *)choice;
4054 }
4055
4056
4057 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
4058 H245_RedundancyEncodingDTModeElement_type::operator H245_H235Mode &() const
4059 #else
4060 H245_RedundancyEncodingDTModeElement_type::operator H245_H235Mode &()
4061 {
4062 #ifndef PASN_LEANANDMEAN
4063   PAssert(PIsDescendant(PAssertNULL(choice), H245_H235Mode), PInvalidCast);
4064 #endif
4065   return *(H245_H235Mode *)choice;
4066 }
4067
4068
4069 H245_RedundancyEncodingDTModeElement_type::operator const H245_H235Mode &() const
4070 #endif
4071 {
4072 #ifndef PASN_LEANANDMEAN
4073   PAssert(PIsDescendant(PAssertNULL(choice), H245_H235Mode), PInvalidCast);
4074 #endif
4075   return *(H245_H235Mode *)choice;
4076 }
4077
4078
4079 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
4080 H245_RedundancyEncodingDTModeElement_type::operator H245_FECMode &() const
4081 #else
4082 H245_RedundancyEncodingDTModeElement_type::operator H245_FECMode &()
4083 {
4084 #ifndef PASN_LEANANDMEAN
4085   PAssert(PIsDescendant(PAssertNULL(choice), H245_FECMode), PInvalidCast);
4086 #endif
4087   return *(H245_FECMode *)choice;
4088 }
4089
4090
4091 H245_RedundancyEncodingDTModeElement_type::operator const H245_FECMode &() const
4092 #endif
4093 {
4094 #ifndef PASN_LEANANDMEAN
4095   PAssert(PIsDescendant(PAssertNULL(choice), H245_FECMode), PInvalidCast);
4096 #endif
4097   return *(H245_FECMode *)choice;
4098 }
4099
4100
4101 BOOL H245_RedundancyEncodingDTModeElement_type::CreateObject()
4102 {
4103   switch (tag) {
4104     case e_nonStandard :
4105       choice = new H245_NonStandardParameter();
4106       return TRUE;
4107     case e_videoMode :
4108       choice = new H245_VideoMode();
4109       return TRUE;
4110     case e_audioMode :
4111       choice = new H245_AudioMode();
4112       return TRUE;
4113     case e_dataMode :
4114       choice = new H245_DataMode();
4115       return TRUE;
4116     case e_encryptionMode :
4117       choice = new H245_EncryptionMode();
4118       return TRUE;
4119     case e_h235Mode :
4120       choice = new H245_H235Mode();
4121       return TRUE;
4122     case e_fecMode :
4123       choice = new H245_FECMode();
4124       return TRUE;
4125   }
4126
4127   choice = NULL;
4128   return FALSE;
4129 }
4130
4131
4132 PObject * H245_RedundancyEncodingDTModeElement_type::Clone() const
4133 {
4134 #ifndef PASN_LEANANDMEAN
4135   PAssert(IsClass(H245_RedundancyEncodingDTModeElement_type::Class()), PInvalidCast);
4136 #endif
4137   return new H245_RedundancyEncodingDTModeElement_type(*this);
4138 }
4139
4140
4141 //
4142 // ArrayOf_MultiplePayloadStreamElementMode
4143 //
4144
4145 H245_ArrayOf_MultiplePayloadStreamElementMode::H245_ArrayOf_MultiplePayloadStreamElementMode(unsigned tag, PASN_Object::TagClass tagClass)
4146   : PASN_Array(tag, tagClass)
4147 {
4148 }
4149
4150
4151 PASN_Object * H245_ArrayOf_MultiplePayloadStreamElementMode::CreateObject() const
4152 {
4153   return new H245_MultiplePayloadStreamElementMode;
4154 }
4155
4156
4157 H245_MultiplePayloadStreamElementMode & H245_ArrayOf_MultiplePayloadStreamElementMode::operator[](PINDEX i) const
4158 {
4159   return (H245_MultiplePayloadStreamElementMode &)array[i];
4160 }
4161
4162
4163 PObject * H245_ArrayOf_MultiplePayloadStreamElementMode::Clone() const
4164 {
4165 #ifndef PASN_LEANANDMEAN
4166   PAssert(IsClass(H245_ArrayOf_MultiplePayloadStreamElementMode::Class()), PInvalidCast);
4167 #endif
4168   return new H245_ArrayOf_MultiplePayloadStreamElementMode(*this);
4169 }
4170
4171
4172
4173 #ifndef PASN_NOPRINTON
4174 const static PASN_Names Names_H245_FECMode_rfc2733Format[]={
4175       {"rfc2733rfc2198",0}
4176      ,{"rfc2733sameport",1}
4177      ,{"rfc2733diffport",2}
4178 };
4179 #endif
4180 //
4181 // FECMode_rfc2733Format
4182 //
4183
4184 H245_FECMode_rfc2733Format::H245_FECMode_rfc2733Format(unsigned tag, PASN_Object::TagClass tagClass)
4185   : PASN_Choice(tag, tagClass, 3, FALSE
4186 #ifndef PASN_NOPRINTON
4187     ,(const PASN_Names *)Names_H245_FECMode_rfc2733Format,3
4188 #endif
4189 )
4190 {
4191 }
4192
4193
4194 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
4195 H245_FECMode_rfc2733Format::operator H245_MaxRedundancy &() const
4196 #else
4197 H245_FECMode_rfc2733Format::operator H245_MaxRedundancy &()
4198 {
4199 #ifndef PASN_LEANANDMEAN
4200   PAssert(PIsDescendant(PAssertNULL(choice), H245_MaxRedundancy), PInvalidCast);
4201 #endif
4202   return *(H245_MaxRedundancy *)choice;
4203 }
4204
4205
4206 H245_FECMode_rfc2733Format::operator const H245_MaxRedundancy &() const
4207 #endif
4208 {
4209 #ifndef PASN_LEANANDMEAN
4210   PAssert(PIsDescendant(PAssertNULL(choice), H245_MaxRedundancy), PInvalidCast);
4211 #endif
4212   return *(H245_MaxRedundancy *)choice;
4213 }
4214
4215
4216 BOOL H245_FECMode_rfc2733Format::CreateObject()
4217 {
4218   switch (tag) {
4219     case e_rfc2733rfc2198 :
4220     case e_rfc2733sameport :
4221     case e_rfc2733diffport :
4222       choice = new H245_MaxRedundancy();
4223       return TRUE;
4224   }
4225
4226   choice = NULL;
4227   return FALSE;
4228 }
4229
4230
4231 PObject * H245_FECMode_rfc2733Format::Clone() const
4232 {
4233 #ifndef PASN_LEANANDMEAN
4234   PAssert(IsClass(H245_FECMode_rfc2733Format::Class()), PInvalidCast);
4235 #endif
4236   return new H245_FECMode_rfc2733Format(*this);
4237 }
4238
4239
4240
4241 #ifndef PASN_NOPRINTON
4242 const static PASN_Names Names_H245_H223ModeParameters_adaptationLayerType[]={
4243       {"nonStandard",0}
4244      ,{"al1Framed",1}
4245      ,{"al1NotFramed",2}
4246      ,{"al2WithoutSequenceNumbers",3}
4247      ,{"al2WithSequenceNumbers",4}
4248      ,{"al3",5}
4249      ,{"al1M",6}
4250      ,{"al2M",7}
4251      ,{"al3M",8}
4252 };
4253 #endif
4254 //
4255 // H223ModeParameters_adaptationLayerType
4256 //
4257
4258 H245_H223ModeParameters_adaptationLayerType::H245_H223ModeParameters_adaptationLayerType(unsigned tag, PASN_Object::TagClass tagClass)
4259   : PASN_Choice(tag, tagClass, 6, TRUE
4260 #ifndef PASN_NOPRINTON
4261     ,(const PASN_Names *)Names_H245_H223ModeParameters_adaptationLayerType,9
4262 #endif
4263 )
4264 {
4265 }
4266
4267
4268 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
4269 H245_H223ModeParameters_adaptationLayerType::operator H245_NonStandardParameter &() const
4270 #else
4271 H245_H223ModeParameters_adaptationLayerType::operator H245_NonStandardParameter &()
4272 {
4273 #ifndef PASN_LEANANDMEAN
4274   PAssert(PIsDescendant(PAssertNULL(choice), H245_NonStandardParameter), PInvalidCast);
4275 #endif
4276   return *(H245_NonStandardParameter *)choice;
4277 }
4278
4279
4280 H245_H223ModeParameters_adaptationLayerType::operator const H245_NonStandardParameter &() const
4281 #endif
4282 {
4283 #ifndef PASN_LEANANDMEAN
4284   PAssert(PIsDescendant(PAssertNULL(choice), H245_NonStandardParameter), PInvalidCast);
4285 #endif
4286   return *(H245_NonStandardParameter *)choice;
4287 }
4288
4289
4290 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
4291 H245_H223ModeParameters_adaptationLayerType::operator H245_H223ModeParameters_adaptationLayerType_al3 &() const
4292 #else
4293 H245_H223ModeParameters_adaptationLayerType::operator H245_H223ModeParameters_adaptationLayerType_al3 &()
4294 {
4295 #ifndef PASN_LEANANDMEAN
4296   PAssert(PIsDescendant(PAssertNULL(choice), H245_H223ModeParameters_adaptationLayerType_al3), PInvalidCast);
4297 #endif
4298   return *(H245_H223ModeParameters_adaptationLayerType_al3 *)choice;
4299 }
4300
4301
4302 H245_H223ModeParameters_adaptationLayerType::operator const H245_H223ModeParameters_adaptationLayerType_al3 &() const
4303 #endif
4304 {
4305 #ifndef PASN_LEANANDMEAN
4306   PAssert(PIsDescendant(PAssertNULL(choice), H245_H223ModeParameters_adaptationLayerType_al3), PInvalidCast);
4307 #endif
4308   return *(H245_H223ModeParameters_adaptationLayerType_al3 *)choice;
4309 }
4310
4311
4312 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
4313 H245_H223ModeParameters_adaptationLayerType::operator H245_H223AL1MParameters &() const
4314 #else
4315 H245_H223ModeParameters_adaptationLayerType::operator H245_H223AL1MParameters &()
4316 {
4317 #ifndef PASN_LEANANDMEAN
4318   PAssert(PIsDescendant(PAssertNULL(choice), H245_H223AL1MParameters), PInvalidCast);
4319 #endif
4320   return *(H245_H223AL1MParameters *)choice;
4321 }
4322
4323
4324 H245_H223ModeParameters_adaptationLayerType::operator const H245_H223AL1MParameters &() const
4325 #endif
4326 {
4327 #ifndef PASN_LEANANDMEAN
4328   PAssert(PIsDescendant(PAssertNULL(choice), H245_H223AL1MParameters), PInvalidCast);
4329 #endif
4330   return *(H245_H223AL1MParameters *)choice;
4331 }
4332
4333
4334 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
4335 H245_H223ModeParameters_adaptationLayerType::operator H245_H223AL2MParameters &() const
4336 #else
4337 H245_H223ModeParameters_adaptationLayerType::operator H245_H223AL2MParameters &()
4338 {
4339 #ifndef PASN_LEANANDMEAN
4340   PAssert(PIsDescendant(PAssertNULL(choice), H245_H223AL2MParameters), PInvalidCast);
4341 #endif
4342   return *(H245_H223AL2MParameters *)choice;
4343 }
4344
4345
4346 H245_H223ModeParameters_adaptationLayerType::operator const H245_H223AL2MParameters &() const
4347 #endif
4348 {
4349 #ifndef PASN_LEANANDMEAN
4350   PAssert(PIsDescendant(PAssertNULL(choice), H245_H223AL2MParameters), PInvalidCast);
4351 #endif
4352   return *(H245_H223AL2MParameters *)choice;
4353 }
4354
4355
4356 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
4357 H245_H223ModeParameters_adaptationLayerType::operator H245_H223AL3MParameters &() const
4358 #else
4359 H245_H223ModeParameters_adaptationLayerType::operator H245_H223AL3MParameters &()
4360 {
4361 #ifndef PASN_LEANANDMEAN
4362   PAssert(PIsDescendant(PAssertNULL(choice), H245_H223AL3MParameters), PInvalidCast);
4363 #endif
4364   return *(H245_H223AL3MParameters *)choice;
4365 }
4366
4367
4368 H245_H223ModeParameters_adaptationLayerType::operator const H245_H223AL3MParameters &() const
4369 #endif
4370 {
4371 #ifndef PASN_LEANANDMEAN
4372   PAssert(PIsDescendant(PAssertNULL(choice), H245_H223AL3MParameters), PInvalidCast);
4373 #endif
4374   return *(H245_H223AL3MParameters *)choice;
4375 }
4376
4377
4378 BOOL H245_H223ModeParameters_adaptationLayerType::CreateObject()
4379 {
4380   switch (tag) {
4381     case e_nonStandard :
4382       choice = new H245_NonStandardParameter();
4383       return TRUE;
4384     case e_al1Framed :
4385     case e_al1NotFramed :
4386     case e_al2WithoutSequenceNumbers :
4387     case e_al2WithSequenceNumbers :
4388       choice = new PASN_Null();
4389       return TRUE;
4390     case e_al3 :
4391       choice = new H245_H223ModeParameters_adaptationLayerType_al3();
4392       return TRUE;
4393     case e_al1M :
4394       choice = new H245_H223AL1MParameters();
4395       return TRUE;
4396     case e_al2M :
4397       choice = new H245_H223AL2MParameters();
4398       return TRUE;
4399     case e_al3M :
4400       choice = new H245_H223AL3MParameters();
4401       return TRUE;
4402   }
4403
4404   choice = NULL;
4405   return FALSE;
4406 }
4407
4408
4409 PObject * H245_H223ModeParameters_adaptationLayerType::Clone() const
4410 {
4411 #ifndef PASN_LEANANDMEAN
4412   PAssert(IsClass(H245_H223ModeParameters_adaptationLayerType::Class()), PInvalidCast);
4413 #endif
4414   return new H245_H223ModeParameters_adaptationLayerType(*this);
4415 }
4416
4417
4418
4419 #ifndef PASN_NOPRINTON
4420 const static PASN_Names Names_H245_RedundancyEncodingMode_secondaryEncoding[]={
4421       {"nonStandard",0}
4422      ,{"audioData",1}
4423 };
4424 #endif
4425 //
4426 // RedundancyEncodingMode_secondaryEncoding
4427 //
4428
4429 H245_RedundancyEncodingMode_secondaryEncoding::H245_RedundancyEncodingMode_secondaryEncoding(unsigned tag, PASN_Object::TagClass tagClass)
4430   : PASN_Choice(tag, tagClass, 2, TRUE
4431 #ifndef PASN_NOPRINTON
4432     ,(const PASN_Names *)Names_H245_RedundancyEncodingMode_secondaryEncoding,2
4433 #endif
4434 )
4435 {
4436 }
4437
4438
4439 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
4440 H245_RedundancyEncodingMode_secondaryEncoding::operator H245_NonStandardParameter &() const
4441 #else
4442 H245_RedundancyEncodingMode_secondaryEncoding::operator H245_NonStandardParameter &()
4443 {
4444 #ifndef PASN_LEANANDMEAN
4445   PAssert(PIsDescendant(PAssertNULL(choice), H245_NonStandardParameter), PInvalidCast);
4446 #endif
4447   return *(H245_NonStandardParameter *)choice;
4448 }
4449
4450
4451 H245_RedundancyEncodingMode_secondaryEncoding::operator const H245_NonStandardParameter &() const
4452 #endif
4453 {
4454 #ifndef PASN_LEANANDMEAN
4455   PAssert(PIsDescendant(PAssertNULL(choice), H245_NonStandardParameter), PInvalidCast);
4456 #endif
4457   return *(H245_NonStandardParameter *)choice;
4458 }
4459
4460
4461 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
4462 H245_RedundancyEncodingMode_secondaryEncoding::operator H245_AudioMode &() const
4463 #else
4464 H245_RedundancyEncodingMode_secondaryEncoding::operator H245_AudioMode &()
4465 {
4466 #ifndef PASN_LEANANDMEAN
4467   PAssert(PIsDescendant(PAssertNULL(choice), H245_AudioMode), PInvalidCast);
4468 #endif
4469   return *(H245_AudioMode *)choice;
4470 }
4471
4472
4473 H245_RedundancyEncodingMode_secondaryEncoding::operator const H245_AudioMode &() const
4474 #endif
4475 {
4476 #ifndef PASN_LEANANDMEAN
4477   PAssert(PIsDescendant(PAssertNULL(choice), H245_AudioMode), PInvalidCast);
4478 #endif
4479   return *(H245_AudioMode *)choice;
4480 }
4481
4482
4483 BOOL H245_RedundancyEncodingMode_secondaryEncoding::CreateObject()
4484 {
4485   switch (tag) {
4486     case e_nonStandard :
4487       choice = new H245_NonStandardParameter();
4488       return TRUE;
4489     case e_audioData :
4490       choice = new H245_AudioMode();
4491       return TRUE;
4492   }
4493
4494   choice = NULL;
4495   return FALSE;
4496 }
4497
4498
4499 PObject * H245_RedundancyEncodingMode_secondaryEncoding::Clone() const
4500 {
4501 #ifndef PASN_LEANANDMEAN
4502   PAssert(IsClass(H245_RedundancyEncodingMode_secondaryEncoding::Class()), PInvalidCast);
4503 #endif
4504   return new H245_RedundancyEncodingMode_secondaryEncoding(*this);
4505 }
4506
4507
4508
4509 #ifndef PASN_NOPRINTON
4510 const static PASN_Names Names_H245_H261VideoMode_resolution[]={
4511       {"qcif",0}
4512      ,{"cif",1}
4513 };
4514 #endif
4515 //
4516 // H261VideoMode_resolution
4517 //
4518
4519 H245_H261VideoMode_resolution::H245_H261VideoMode_resolution(unsigned tag, PASN_Object::TagClass tagClass)
4520   : PASN_Choice(tag, tagClass, 2, FALSE
4521 #ifndef PASN_NOPRINTON
4522     ,(const PASN_Names *)Names_H245_H261VideoMode_resolution,2
4523 #endif
4524 )
4525 {
4526 }
4527
4528
4529 BOOL H245_H261VideoMode_resolution::CreateObject()
4530 {
4531   choice = (tag <= e_cif) ? new PASN_Null() : NULL;
4532   return choice != NULL;
4533 }
4534
4535
4536 PObject * H245_H261VideoMode_resolution::Clone() const
4537 {
4538 #ifndef PASN_LEANANDMEAN
4539   PAssert(IsClass(H245_H261VideoMode_resolution::Class()), PInvalidCast);
4540 #endif
4541   return new H245_H261VideoMode_resolution(*this);
4542 }
4543
4544
4545
4546 #ifndef PASN_NOPRINTON
4547 const static PASN_Names Names_H245_H262VideoMode_profileAndLevel[]={
4548       {"profileAndLevel_SPatML",0}
4549      ,{"profileAndLevel_MPatLL",1}
4550      ,{"profileAndLevel_MPatML",2}
4551      ,{"profileAndLevel_MPatH_14",3}
4552      ,{"profileAndLevel_MPatHL",4}
4553      ,{"profileAndLevel_SNRatLL",5}
4554      ,{"profileAndLevel_SNRatML",6}
4555      ,{"profileAndLevel_SpatialatH_14",7}
4556      ,{"profileAndLevel_HPatML",8}
4557      ,{"profileAndLevel_HPatH_14",9}
4558      ,{"profileAndLevel_HPatHL",10}
4559 };
4560 #endif
4561 //
4562 // H262VideoMode_profileAndLevel
4563 //
4564
4565 H245_H262VideoMode_profileAndLevel::H245_H262VideoMode_profileAndLevel(unsigned tag, PASN_Object::TagClass tagClass)
4566   : PASN_Choice(tag, tagClass, 11, TRUE
4567 #ifndef PASN_NOPRINTON
4568     ,(const PASN_Names *)Names_H245_H262VideoMode_profileAndLevel,11
4569 #endif
4570 )
4571 {
4572 }
4573
4574
4575 BOOL H245_H262VideoMode_profileAndLevel::CreateObject()
4576 {
4577   choice = (tag <= e_profileAndLevel_HPatHL) ? new PASN_Null() : NULL;
4578   return choice != NULL;
4579 }
4580
4581
4582 PObject * H245_H262VideoMode_profileAndLevel::Clone() const
4583 {
4584 #ifndef PASN_LEANANDMEAN
4585   PAssert(IsClass(H245_H262VideoMode_profileAndLevel::Class()), PInvalidCast);
4586 #endif
4587   return new H245_H262VideoMode_profileAndLevel(*this);
4588 }
4589
4590
4591
4592 #ifndef PASN_NOPRINTON
4593 const static PASN_Names Names_H245_H263VideoMode_resolution[]={
4594       {"sqcif",0}
4595      ,{"qcif",1}
4596      ,{"cif",2}
4597      ,{"cif4",3}
4598      ,{"cif16",4}
4599      ,{"custom",5}
4600 };
4601 #endif
4602 //
4603 // H263VideoMode_resolution
4604 //
4605
4606 H245_H263VideoMode_resolution::H245_H263VideoMode_resolution(unsigned tag, PASN_Object::TagClass tagClass)
4607   : PASN_Choice(tag, tagClass, 5, TRUE
4608 #ifndef PASN_NOPRINTON
4609     ,(const PASN_Names *)Names_H245_H263VideoMode_resolution,6
4610 #endif
4611 )
4612 {
4613 }
4614
4615
4616 BOOL H245_H263VideoMode_resolution::CreateObject()
4617 {
4618   choice = (tag <= e_custom) ? new PASN_Null() : NULL;
4619   return choice != NULL;
4620 }
4621
4622
4623 PObject * H245_H263VideoMode_resolution::Clone() const
4624 {
4625 #ifndef PASN_LEANANDMEAN
4626   PAssert(IsClass(H245_H263VideoMode_resolution::Class()), PInvalidCast);
4627 #endif
4628   return new H245_H263VideoMode_resolution(*this);
4629 }
4630
4631
4632
4633 #ifndef PASN_NOPRINTON
4634 const static PASN_Names Names_H245_AudioMode_g7231[]={
4635       {"noSilenceSuppressionLowRate",0}
4636      ,{"noSilenceSuppressionHighRate",1}
4637      ,{"silenceSuppressionLowRate",2}
4638      ,{"silenceSuppressionHighRate",3}
4639 };
4640 #endif
4641 //
4642 // AudioMode_g7231
4643 //
4644
4645 H245_AudioMode_g7231::H245_AudioMode_g7231(unsigned tag, PASN_Object::TagClass tagClass)
4646   : PASN_Choice(tag, tagClass, 4, FALSE
4647 #ifndef PASN_NOPRINTON
4648     ,(const PASN_Names *)Names_H245_AudioMode_g7231,4
4649 #endif
4650 )
4651 {
4652 }
4653
4654
4655 BOOL H245_AudioMode_g7231::CreateObject()
4656 {
4657   choice = (tag <= e_silenceSuppressionHighRate) ? new PASN_Null() : NULL;
4658   return choice != NULL;
4659 }
4660
4661
4662 PObject * H245_AudioMode_g7231::Clone() const
4663 {
4664 #ifndef PASN_LEANANDMEAN
4665   PAssert(IsClass(H245_AudioMode_g7231::Class()), PInvalidCast);
4666 #endif
4667   return new H245_AudioMode_g7231(*this);
4668 }
4669
4670
4671
4672 #ifndef PASN_NOPRINTON
4673 const static PASN_Names Names_H245_IS11172AudioMode_audioLayer[]={
4674       {"audioLayer1",0}
4675      ,{"audioLayer2",1}
4676      ,{"audioLayer3",2}
4677 };
4678 #endif
4679 //
4680 // IS11172AudioMode_audioLayer
4681 //
4682
4683 H245_IS11172AudioMode_audioLayer::H245_IS11172AudioMode_audioLayer(unsigned tag, PASN_Object::TagClass tagClass)
4684   : PASN_Choice(tag, tagClass, 3, FALSE
4685 #ifndef PASN_NOPRINTON
4686     ,(const PASN_Names *)Names_H245_IS11172AudioMode_audioLayer,3
4687 #endif
4688 )
4689 {
4690 }
4691
4692
4693 BOOL H245_IS11172AudioMode_audioLayer::CreateObject()
4694 {
4695   choice = (tag <= e_audioLayer3) ? new PASN_Null() : NULL;
4696   return choice != NULL;
4697 }
4698
4699
4700 PObject * H245_IS11172AudioMode_audioLayer::Clone() const
4701 {
4702 #ifndef PASN_LEANANDMEAN
4703   PAssert(IsClass(H245_IS11172AudioMode_audioLayer::Class()), PInvalidCast);
4704 #endif
4705   return new H245_IS11172AudioMode_audioLayer(*this);
4706 }
4707
4708
4709
4710 #ifndef PASN_NOPRINTON
4711 const static PASN_Names Names_H245_IS11172AudioMode_audioSampling[]={
4712       {"audioSampling32k",0}
4713      ,{"audioSampling44k1",1}
4714      ,{"audioSampling48k",2}
4715 };
4716 #endif
4717 //
4718 // IS11172AudioMode_audioSampling
4719 //
4720
4721 H245_IS11172AudioMode_audioSampling::H245_IS11172AudioMode_audioSampling(unsigned tag, PASN_Object::TagClass tagClass)
4722   : PASN_Choice(tag, tagClass, 3, FALSE
4723 #ifndef PASN_NOPRINTON
4724     ,(const PASN_Names *)Names_H245_IS11172AudioMode_audioSampling,3
4725 #endif
4726 )
4727 {
4728 }
4729
4730
4731 BOOL H245_IS11172AudioMode_audioSampling::CreateObject()
4732 {
4733   choice = (tag <= e_audioSampling48k) ? new PASN_Null() : NULL;
4734   return choice != NULL;
4735 }
4736
4737
4738 PObject * H245_IS11172AudioMode_audioSampling::Clone() const
4739 {
4740 #ifndef PASN_LEANANDMEAN
4741   PAssert(IsClass(H245_IS11172AudioMode_audioSampling::Class()), PInvalidCast);
4742 #endif
4743   return new H245_IS11172AudioMode_audioSampling(*this);
4744 }
4745
4746
4747
4748 #ifndef PASN_NOPRINTON
4749 const static PASN_Names Names_H245_IS11172AudioMode_multichannelType[]={
4750       {"singleChannel",0}
4751      ,{"twoChannelStereo",1}
4752      ,{"twoChannelDual",2}
4753 };
4754 #endif
4755 //
4756 // IS11172AudioMode_multichannelType
4757 //
4758
4759 H245_IS11172AudioMode_multichannelType::H245_IS11172AudioMode_multichannelType(unsigned tag, PASN_Object::TagClass tagClass)
4760   : PASN_Choice(tag, tagClass, 3, FALSE
4761 #ifndef PASN_NOPRINTON
4762     ,(const PASN_Names *)Names_H245_IS11172AudioMode_multichannelType,3
4763 #endif
4764 )
4765 {
4766 }
4767
4768
4769 BOOL H245_IS11172AudioMode_multichannelType::CreateObject()
4770 {
4771   choice = (tag <= e_twoChannelDual) ? new PASN_Null() : NULL;
4772   return choice != NULL;
4773 }
4774
4775
4776 PObject * H245_IS11172AudioMode_multichannelType::Clone() const
4777 {
4778 #ifndef PASN_LEANANDMEAN
4779   PAssert(IsClass(H245_IS11172AudioMode_multichannelType::Class()), PInvalidCast);
4780 #endif
4781   return new H245_IS11172AudioMode_multichannelType(*this);
4782 }
4783
4784
4785
4786 #ifndef PASN_NOPRINTON
4787 const static PASN_Names Names_H245_IS13818AudioMode_audioLayer[]={
4788       {"audioLayer1",0}
4789      ,{"audioLayer2",1}
4790      ,{"audioLayer3",2}
4791 };
4792 #endif
4793 //
4794 // IS13818AudioMode_audioLayer
4795 //
4796
4797 H245_IS13818AudioMode_audioLayer::H245_IS13818AudioMode_audioLayer(unsigned tag, PASN_Object::TagClass tagClass)
4798   : PASN_Choice(tag, tagClass, 3, FALSE
4799 #ifndef PASN_NOPRINTON
4800     ,(const PASN_Names *)Names_H245_IS13818AudioMode_audioLayer,3
4801 #endif
4802 )
4803 {
4804 }
4805
4806
4807 BOOL H245_IS13818AudioMode_audioLayer::CreateObject()
4808 {
4809   choice = (tag <= e_audioLayer3) ? new PASN_Null() : NULL;
4810   return choice != NULL;
4811 }
4812
4813
4814 PObject * H245_IS13818AudioMode_audioLayer::Clone() const
4815 {
4816 #ifndef PASN_LEANANDMEAN
4817   PAssert(IsClass(H245_IS13818AudioMode_audioLayer::Class()), PInvalidCast);
4818 #endif
4819   return new H245_IS13818AudioMode_audioLayer(*this);
4820 }
4821
4822
4823
4824 #ifndef PASN_NOPRINTON
4825 const static PASN_Names Names_H245_IS13818AudioMode_audioSampling[]={
4826       {"audioSampling16k",0}
4827      ,{"audioSampling22k05",1}
4828      ,{"audioSampling24k",2}
4829      ,{"audioSampling32k",3}
4830      ,{"audioSampling44k1",4}
4831      ,{"audioSampling48k",5}
4832 };
4833 #endif
4834 //
4835 // IS13818AudioMode_audioSampling
4836 //
4837
4838 H245_IS13818AudioMode_audioSampling::H245_IS13818AudioMode_audioSampling(unsigned tag, PASN_Object::TagClass tagClass)
4839   : PASN_Choice(tag, tagClass, 6, FALSE
4840 #ifndef PASN_NOPRINTON
4841     ,(const PASN_Names *)Names_H245_IS13818AudioMode_audioSampling,6
4842 #endif
4843 )
4844 {
4845 }
4846
4847
4848 BOOL H245_IS13818AudioMode_audioSampling::CreateObject()
4849 {
4850   choice = (tag <= e_audioSampling48k) ? new PASN_Null() : NULL;
4851   return choice != NULL;
4852 }
4853
4854
4855 PObject * H245_IS13818AudioMode_audioSampling::Clone() const
4856 {
4857 #ifndef PASN_LEANANDMEAN
4858   PAssert(IsClass(H245_IS13818AudioMode_audioSampling::Class()), PInvalidCast);
4859 #endif
4860   return new H245_IS13818AudioMode_audioSampling(*this);
4861 }
4862
4863
4864
4865 #ifndef PASN_NOPRINTON
4866 const static PASN_Names Names_H245_IS13818AudioMode_multichannelType[]={
4867       {"singleChannel",0}
4868      ,{"twoChannelStereo",1}
4869      ,{"twoChannelDual",2}
4870      ,{"threeChannels2_1",3}
4871      ,{"threeChannels3_0",4}
4872      ,{"fourChannels2_0_2_0",5}
4873      ,{"fourChannels2_2",6}
4874      ,{"fourChannels3_1",7}
4875      ,{"fiveChannels3_0_2_0",8}
4876      ,{"fiveChannels3_2",9}
4877 };
4878 #endif
4879 //
4880 // IS13818AudioMode_multichannelType
4881 //
4882
4883 H245_IS13818AudioMode_multichannelType::H245_IS13818AudioMode_multichannelType(unsigned tag, PASN_Object::TagClass tagClass)
4884   : PASN_Choice(tag, tagClass, 10, FALSE
4885 #ifndef PASN_NOPRINTON
4886     ,(const PASN_Names *)Names_H245_IS13818AudioMode_multichannelType,10
4887 #endif
4888 )
4889 {
4890 }
4891
4892
4893 BOOL H245_IS13818AudioMode_multichannelType::CreateObject()
4894 {
4895   choice = (tag <= e_fiveChannels3_2) ? new PASN_Null() : NULL;
4896   return choice != NULL;
4897 }
4898
4899
4900 PObject * H245_IS13818AudioMode_multichannelType::Clone() const
4901 {
4902 #ifndef PASN_LEANANDMEAN
4903   PAssert(IsClass(H245_IS13818AudioMode_multichannelType::Class()), PInvalidCast);
4904 #endif
4905   return new H245_IS13818AudioMode_multichannelType(*this);
4906 }
4907
4908
4909 //
4910 // G7231AnnexCMode_g723AnnexCAudioMode
4911 //
4912
4913 H245_G7231AnnexCMode_g723AnnexCAudioMode::H245_G7231AnnexCMode_g723AnnexCAudioMode(unsigned tag, PASN_Object::TagClass tagClass)
4914   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
4915 {
4916   m_highRateMode0.SetConstraints(PASN_Object::FixedConstraint, 27, 78);
4917   m_highRateMode1.SetConstraints(PASN_Object::FixedConstraint, 27, 78);
4918   m_lowRateMode0.SetConstraints(PASN_Object::FixedConstraint, 23, 66);
4919   m_lowRateMode1.SetConstraints(PASN_Object::FixedConstraint, 23, 66);
4920   m_sidMode0.SetConstraints(PASN_Object::FixedConstraint, 6, 17);
4921   m_sidMode1.SetConstraints(PASN_Object::FixedConstraint, 6, 17);
4922 }
4923
4924
4925 #ifndef PASN_NOPRINTON
4926 void H245_G7231AnnexCMode_g723AnnexCAudioMode::PrintOn(ostream & strm) const
4927 {
4928   int indent = strm.precision() + 2;
4929   strm << "{\n";
4930   strm << setw(indent+16) << "highRateMode0 = " << setprecision(indent) << m_highRateMode0 << '\n';
4931   strm << setw(indent+16) << "highRateMode1 = " << setprecision(indent) << m_highRateMode1 << '\n';
4932   strm << setw(indent+15) << "lowRateMode0 = " << setprecision(indent) << m_lowRateMode0 << '\n';
4933   strm << setw(indent+15) << "lowRateMode1 = " << setprecision(indent) << m_lowRateMode1 << '\n';
4934   strm << setw(indent+11) << "sidMode0 = " << setprecision(indent) << m_sidMode0 << '\n';
4935   strm << setw(indent+11) << "sidMode1 = " << setprecision(indent) << m_sidMode1 << '\n';
4936   strm << setw(indent-1) << setprecision(indent-2) << "}";
4937 }
4938 #endif
4939
4940
4941 PObject::Comparison H245_G7231AnnexCMode_g723AnnexCAudioMode::Compare(const PObject & obj) const
4942 {
4943 #ifndef PASN_LEANANDMEAN
4944   PAssert(PIsDescendant(&obj, H245_G7231AnnexCMode_g723AnnexCAudioMode), PInvalidCast);
4945 #endif
4946   const H245_G7231AnnexCMode_g723AnnexCAudioMode & other = (const H245_G7231AnnexCMode_g723AnnexCAudioMode &)obj;
4947
4948   Comparison result;
4949
4950   if ((result = m_highRateMode0.Compare(other.m_highRateMode0)) != EqualTo)
4951     return result;
4952   if ((result = m_highRateMode1.Compare(other.m_highRateMode1)) != EqualTo)
4953     return result;
4954   if ((result = m_lowRateMode0.Compare(other.m_lowRateMode0)) != EqualTo)
4955     return result;
4956   if ((result = m_lowRateMode1.Compare(other.m_lowRateMode1)) != EqualTo)
4957     return result;
4958   if ((result = m_sidMode0.Compare(other.m_sidMode0)) != EqualTo)
4959     return result;
4960   if ((result = m_sidMode1.Compare(other.m_sidMode1)) != EqualTo)
4961     return result;
4962
4963   return PASN_Sequence::Compare(other);
4964 }
4965
4966
4967 PINDEX H245_G7231AnnexCMode_g723AnnexCAudioMode::GetDataLength() const
4968 {
4969   PINDEX length = 0;
4970   length += m_highRateMode0.GetObjectLength();
4971   length += m_highRateMode1.GetObjectLength();
4972   length += m_lowRateMode0.GetObjectLength();
4973   length += m_lowRateMode1.GetObjectLength();
4974   length += m_sidMode0.GetObjectLength();
4975   length += m_sidMode1.GetObjectLength();
4976   return length;
4977 }
4978
4979
4980 BOOL H245_G7231AnnexCMode_g723AnnexCAudioMode::Decode(PASN_Stream & strm)
4981 {
4982   if (!PreambleDecode(strm))
4983     return FALSE;
4984
4985   if (!m_highRateMode0.Decode(strm))
4986     return FALSE;
4987   if (!m_highRateMode1.Decode(strm))
4988     return FALSE;
4989   if (!m_lowRateMode0.Decode(strm))
4990     return FALSE;
4991   if (!m_lowRateMode1.Decode(strm))
4992     return FALSE;
4993   if (!m_sidMode0.Decode(strm))
4994     return FALSE;
4995   if (!m_sidMode1.Decode(strm))
4996     return FALSE;
4997
4998   return UnknownExtensionsDecode(strm);
4999 }
5000
5001
5002 void H245_G7231AnnexCMode_g723AnnexCAudioMode::Encode(PASN_Stream & strm) const
5003 {
5004   PreambleEncode(strm);
5005
5006   m_highRateMode0.Encode(strm);
5007   m_highRateMode1.Encode(strm);
5008   m_lowRateMode0.Encode(strm);
5009   m_lowRateMode1.Encode(strm);
5010   m_sidMode0.Encode(strm);
5011   m_sidMode1.Encode(strm);
5012
5013   UnknownExtensionsEncode(strm);
5014 }
5015
5016
5017 PObject * H245_G7231AnnexCMode_g723AnnexCAudioMode::Clone() const
5018 {
5019 #ifndef PASN_LEANANDMEAN
5020   PAssert(IsClass(H245_G7231AnnexCMode_g723AnnexCAudioMode::Class()), PInvalidCast);
5021 #endif
5022   return new H245_G7231AnnexCMode_g723AnnexCAudioMode(*this);
5023 }
5024
5025
5026
5027 #ifndef PASN_NOPRINTON
5028 const static PASN_Names Names_H245_DataMode_application[]={
5029       {"nonStandard",0}
5030      ,{"t120",1}
5031      ,{"dsm_cc",2}
5032      ,{"userData",3}
5033      ,{"t84",4}
5034      ,{"t434",5}
5035      ,{"h224",6}
5036      ,{"nlpid",7}
5037      ,{"dsvdControl",8}
5038      ,{"h222DataPartitioning",9}
5039      ,{"t30fax",10}
5040      ,{"t140",11}
5041      ,{"t38fax",12}
5042      ,{"genericDataMode",13}
5043 };
5044 #endif
5045 //
5046 // DataMode_application
5047 //
5048
5049 H245_DataMode_application::H245_DataMode_application(unsigned tag, PASN_Object::TagClass tagClass)
5050   : PASN_Choice(tag, tagClass, 10, TRUE
5051 #ifndef PASN_NOPRINTON
5052     ,(const PASN_Names *)Names_H245_DataMode_application,14
5053 #endif
5054 )
5055 {
5056 }
5057
5058
5059 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
5060 H245_DataMode_application::operator H245_NonStandardParameter &() const
5061 #else
5062 H245_DataMode_application::operator H245_NonStandardParameter &()
5063 {
5064 #ifndef PASN_LEANANDMEAN
5065   PAssert(PIsDescendant(PAssertNULL(choice), H245_NonStandardParameter), PInvalidCast);
5066 #endif
5067   return *(H245_NonStandardParameter *)choice;
5068 }
5069
5070
5071 H245_DataMode_application::operator const H245_NonStandardParameter &() const
5072 #endif
5073 {
5074 #ifndef PASN_LEANANDMEAN
5075   PAssert(PIsDescendant(PAssertNULL(choice), H245_NonStandardParameter), PInvalidCast);
5076 #endif
5077   return *(H245_NonStandardParameter *)choice;
5078 }
5079
5080
5081 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
5082 H245_DataMode_application::operator H245_DataProtocolCapability &() const
5083 #else
5084 H245_DataMode_application::operator H245_DataProtocolCapability &()
5085 {
5086 #ifndef PASN_LEANANDMEAN
5087   PAssert(PIsDescendant(PAssertNULL(choice), H245_DataProtocolCapability), PInvalidCast);
5088 #endif
5089   return *(H245_DataProtocolCapability *)choice;
5090 }
5091
5092
5093 H245_DataMode_application::operator const H245_DataProtocolCapability &() const
5094 #endif
5095 {
5096 #ifndef PASN_LEANANDMEAN
5097   PAssert(PIsDescendant(PAssertNULL(choice), H245_DataProtocolCapability), PInvalidCast);
5098 #endif
5099   return *(H245_DataProtocolCapability *)choice;
5100 }
5101
5102
5103 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
5104 H245_DataMode_application::operator H245_DataMode_application_nlpid &() const
5105 #else
5106 H245_DataMode_application::operator H245_DataMode_application_nlpid &()
5107 {
5108 #ifndef PASN_LEANANDMEAN
5109   PAssert(PIsDescendant(PAssertNULL(choice), H245_DataMode_application_nlpid), PInvalidCast);
5110 #endif
5111   return *(H245_DataMode_application_nlpid *)choice;
5112 }
5113
5114
5115 H245_DataMode_application::operator const H245_DataMode_application_nlpid &() const
5116 #endif
5117 {
5118 #ifndef PASN_LEANANDMEAN
5119   PAssert(PIsDescendant(PAssertNULL(choice), H245_DataMode_application_nlpid), PInvalidCast);
5120 #endif
5121   return *(H245_DataMode_application_nlpid *)choice;
5122 }
5123
5124
5125 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
5126 H245_DataMode_application::operator H245_DataMode_application_t38fax &() const
5127 #else
5128 H245_DataMode_application::operator H245_DataMode_application_t38fax &()
5129 {
5130 #ifndef PASN_LEANANDMEAN
5131   PAssert(PIsDescendant(PAssertNULL(choice), H245_DataMode_application_t38fax), PInvalidCast);
5132 #endif
5133   return *(H245_DataMode_application_t38fax *)choice;
5134 }
5135
5136
5137 H245_DataMode_application::operator const H245_DataMode_application_t38fax &() const
5138 #endif
5139 {
5140 #ifndef PASN_LEANANDMEAN
5141   PAssert(PIsDescendant(PAssertNULL(choice), H245_DataMode_application_t38fax), PInvalidCast);
5142 #endif
5143   return *(H245_DataMode_application_t38fax *)choice;
5144 }
5145
5146
5147 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
5148 H245_DataMode_application::operator H245_GenericCapability &() const
5149 #else
5150 H245_DataMode_application::operator H245_GenericCapability &()
5151 {
5152 #ifndef PASN_LEANANDMEAN
5153   PAssert(PIsDescendant(PAssertNULL(choice), H245_GenericCapability), PInvalidCast);
5154 #endif
5155   return *(H245_GenericCapability *)choice;
5156 }
5157
5158
5159 H245_DataMode_application::operator const H245_GenericCapability &() const
5160 #endif
5161 {
5162 #ifndef PASN_LEANANDMEAN
5163   PAssert(PIsDescendant(PAssertNULL(choice), H245_GenericCapability), PInvalidCast);
5164 #endif
5165   return *(H245_GenericCapability *)choice;
5166 }
5167
5168
5169 BOOL H245_DataMode_application::CreateObject()
5170 {
5171   switch (tag) {
5172     case e_nonStandard :
5173       choice = new H245_NonStandardParameter();
5174       return TRUE;
5175     case e_t120 :
5176     case e_dsm_cc :
5177     case e_userData :
5178     case e_t84 :
5179     case e_t434 :
5180     case e_h224 :
5181     case e_h222DataPartitioning :
5182     case e_t30fax :
5183     case e_t140 :
5184       choice = new H245_DataProtocolCapability();
5185       return TRUE;
5186     case e_nlpid :
5187       choice = new H245_DataMode_application_nlpid();
5188       return TRUE;
5189     case e_dsvdControl :
5190       choice = new PASN_Null();
5191       return TRUE;
5192     case e_t38fax :
5193       choice = new H245_DataMode_application_t38fax();
5194       return TRUE;
5195     case e_genericDataMode :
5196       choice = new H245_GenericCapability();
5197       return TRUE;
5198   }
5199
5200   choice = NULL;
5201   return FALSE;
5202 }
5203
5204
5205 PObject * H245_DataMode_application::Clone() const
5206 {
5207 #ifndef PASN_LEANANDMEAN
5208   PAssert(IsClass(H245_DataMode_application::Class()), PInvalidCast);
5209 #endif
5210   return new H245_DataMode_application(*this);
5211 }
5212
5213
5214
5215 #ifndef PASN_NOPRINTON
5216 const static PASN_Names Names_H245_MaintenanceLoopRequest_type[]={
5217       {"systemLoop",0}
5218      ,{"mediaLoop",1}
5219      ,{"logicalChannelLoop",2}
5220 };
5221 #endif
5222 //
5223 // MaintenanceLoopRequest_type
5224 //
5225
5226 H245_MaintenanceLoopRequest_type::H245_MaintenanceLoopRequest_type(unsigned tag, PASN_Object::TagClass tagClass)
5227   : PASN_Choice(tag, tagClass, 3, TRUE
5228 #ifndef PASN_NOPRINTON
5229     ,(const PASN_Names *)Names_H245_MaintenanceLoopRequest_type,3
5230 #endif
5231 )
5232 {
5233 }
5234
5235
5236 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
5237 H245_MaintenanceLoopRequest_type::operator H245_LogicalChannelNumber &() const
5238 #else
5239 H245_MaintenanceLoopRequest_type::operator H245_LogicalChannelNumber &()
5240 {
5241 #ifndef PASN_LEANANDMEAN
5242   PAssert(PIsDescendant(PAssertNULL(choice), H245_LogicalChannelNumber), PInvalidCast);
5243 #endif
5244   return *(H245_LogicalChannelNumber *)choice;
5245 }
5246
5247
5248 H245_MaintenanceLoopRequest_type::operator const H245_LogicalChannelNumber &() const
5249 #endif
5250 {
5251 #ifndef PASN_LEANANDMEAN
5252   PAssert(PIsDescendant(PAssertNULL(choice), H245_LogicalChannelNumber), PInvalidCast);
5253 #endif
5254   return *(H245_LogicalChannelNumber *)choice;
5255 }
5256
5257
5258 BOOL H245_MaintenanceLoopRequest_type::CreateObject()
5259 {
5260   switch (tag) {
5261     case e_systemLoop :
5262       choice = new PASN_Null();
5263       return TRUE;
5264     case e_mediaLoop :
5265     case e_logicalChannelLoop :
5266       choice = new H245_LogicalChannelNumber();
5267       return TRUE;
5268   }
5269
5270   choice = NULL;
5271   return FALSE;
5272 }
5273
5274
5275 PObject * H245_MaintenanceLoopRequest_type::Clone() const
5276 {
5277 #ifndef PASN_LEANANDMEAN
5278   PAssert(IsClass(H245_MaintenanceLoopRequest_type::Class()), PInvalidCast);
5279 #endif
5280   return new H245_MaintenanceLoopRequest_type(*this);
5281 }
5282
5283
5284
5285 #ifndef PASN_NOPRINTON
5286 const static PASN_Names Names_H245_MaintenanceLoopAck_type[]={
5287       {"systemLoop",0}
5288      ,{"mediaLoop",1}
5289      ,{"logicalChannelLoop",2}
5290 };
5291 #endif
5292 //
5293 // MaintenanceLoopAck_type
5294 //
5295
5296 H245_MaintenanceLoopAck_type::H245_MaintenanceLoopAck_type(unsigned tag, PASN_Object::TagClass tagClass)
5297   : PASN_Choice(tag, tagClass, 3, TRUE
5298 #ifndef PASN_NOPRINTON
5299     ,(const PASN_Names *)Names_H245_MaintenanceLoopAck_type,3
5300 #endif
5301 )
5302 {
5303 }
5304
5305
5306 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
5307 H245_MaintenanceLoopAck_type::operator H245_LogicalChannelNumber &() const
5308 #else
5309 H245_MaintenanceLoopAck_type::operator H245_LogicalChannelNumber &()
5310 {
5311 #ifndef PASN_LEANANDMEAN
5312   PAssert(PIsDescendant(PAssertNULL(choice), H245_LogicalChannelNumber), PInvalidCast);
5313 #endif
5314   return *(H245_LogicalChannelNumber *)choice;
5315 }
5316
5317
5318 H245_MaintenanceLoopAck_type::operator const H245_LogicalChannelNumber &() const
5319 #endif
5320 {
5321 #ifndef PASN_LEANANDMEAN
5322   PAssert(PIsDescendant(PAssertNULL(choice), H245_LogicalChannelNumber), PInvalidCast);
5323 #endif
5324   return *(H245_LogicalChannelNumber *)choice;
5325 }
5326
5327
5328 BOOL H245_MaintenanceLoopAck_type::CreateObject()
5329 {
5330   switch (tag) {
5331     case e_systemLoop :
5332       choice = new PASN_Null();
5333       return TRUE;
5334     case e_mediaLoop :
5335     case e_logicalChannelLoop :
5336       choice = new H245_LogicalChannelNumber();
5337       return TRUE;
5338   }
5339
5340   choice = NULL;
5341   return FALSE;
5342 }
5343
5344
5345 PObject * H245_MaintenanceLoopAck_type::Clone() const
5346 {
5347 #ifndef PASN_LEANANDMEAN
5348   PAssert(IsClass(H245_MaintenanceLoopAck_type::Class()), PInvalidCast);
5349 #endif
5350   return new H245_MaintenanceLoopAck_type(*this);
5351 }
5352
5353
5354
5355 #ifndef PASN_NOPRINTON
5356 const static PASN_Names Names_H245_MaintenanceLoopReject_type[]={
5357       {"systemLoop",0}
5358      ,{"mediaLoop",1}
5359      ,{"logicalChannelLoop",2}
5360 };
5361 #endif
5362 //
5363 // MaintenanceLoopReject_type
5364 //
5365
5366 H245_MaintenanceLoopReject_type::H245_MaintenanceLoopReject_type(unsigned tag, PASN_Object::TagClass tagClass)
5367   : PASN_Choice(tag, tagClass, 3, TRUE
5368 #ifndef PASN_NOPRINTON
5369     ,(const PASN_Names *)Names_H245_MaintenanceLoopReject_type,3
5370 #endif
5371 )
5372 {
5373 }
5374
5375
5376 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
5377 H245_MaintenanceLoopReject_type::operator H245_LogicalChannelNumber &() const
5378 #else
5379 H245_MaintenanceLoopReject_type::operator H245_LogicalChannelNumber &()
5380 {
5381 #ifndef PASN_LEANANDMEAN
5382   PAssert(PIsDescendant(PAssertNULL(choice), H245_LogicalChannelNumber), PInvalidCast);
5383 #endif
5384   return *(H245_LogicalChannelNumber *)choice;
5385 }
5386
5387
5388 H245_MaintenanceLoopReject_type::operator const H245_LogicalChannelNumber &() const
5389 #endif
5390 {
5391 #ifndef PASN_LEANANDMEAN
5392   PAssert(PIsDescendant(PAssertNULL(choice), H245_LogicalChannelNumber), PInvalidCast);
5393 #endif
5394   return *(H245_LogicalChannelNumber *)choice;
5395 }
5396
5397
5398 BOOL H245_MaintenanceLoopReject_type::CreateObject()
5399 {
5400   switch (tag) {
5401     case e_systemLoop :
5402       choice = new PASN_Null();
5403       return TRUE;
5404     case e_mediaLoop :
5405     case e_logicalChannelLoop :
5406       choice = new H245_LogicalChannelNumber();
5407       return TRUE;
5408   }
5409
5410   choice = NULL;
5411   return FALSE;
5412 }
5413
5414
5415 PObject * H245_MaintenanceLoopReject_type::Clone() const
5416 {
5417 #ifndef PASN_LEANANDMEAN
5418   PAssert(IsClass(H245_MaintenanceLoopReject_type::Class()), PInvalidCast);
5419 #endif
5420   return new H245_MaintenanceLoopReject_type(*this);
5421 }
5422
5423
5424
5425 #ifndef PASN_NOPRINTON
5426 const static PASN_Names Names_H245_MaintenanceLoopReject_cause[]={
5427       {"canNotPerformLoop",0}
5428 };
5429 #endif
5430 //
5431 // MaintenanceLoopReject_cause
5432 //
5433
5434 H245_MaintenanceLoopReject_cause::H245_MaintenanceLoopReject_cause(unsigned tag, PASN_Object::TagClass tagClass)
5435   : PASN_Choice(tag, tagClass, 1, TRUE
5436 #ifndef PASN_NOPRINTON
5437     ,(const PASN_Names *)Names_H245_MaintenanceLoopReject_cause,1
5438 #endif
5439 )
5440 {
5441 }
5442
5443
5444 BOOL H245_MaintenanceLoopReject_cause::CreateObject()
5445 {
5446   choice = (tag <= e_canNotPerformLoop) ? new PASN_Null() : NULL;
5447   return choice != NULL;
5448 }
5449
5450
5451 PObject * H245_MaintenanceLoopReject_cause::Clone() const
5452 {
5453 #ifndef PASN_LEANANDMEAN
5454   PAssert(IsClass(H245_MaintenanceLoopReject_cause::Class()), PInvalidCast);
5455 #endif
5456   return new H245_MaintenanceLoopReject_cause(*this);
5457 }
5458
5459
5460 //
5461 // ArrayOf_CommunicationModeTableEntry
5462 //
5463
5464 H245_ArrayOf_CommunicationModeTableEntry::H245_ArrayOf_CommunicationModeTableEntry(unsigned tag, PASN_Object::TagClass tagClass)
5465   : PASN_Array(tag, tagClass)
5466 {
5467 }
5468
5469
5470 PASN_Object * H245_ArrayOf_CommunicationModeTableEntry::CreateObject() const
5471 {
5472   return new H245_CommunicationModeTableEntry;
5473 }
5474
5475
5476 H245_CommunicationModeTableEntry & H245_ArrayOf_CommunicationModeTableEntry::operator[](PINDEX i) const
5477 {
5478   return (H245_CommunicationModeTableEntry &)array[i];
5479 }
5480
5481
5482 PObject * H245_ArrayOf_CommunicationModeTableEntry::Clone() const
5483 {
5484 #ifndef PASN_LEANANDMEAN
5485   PAssert(IsClass(H245_ArrayOf_CommunicationModeTableEntry::Class()), PInvalidCast);
5486 #endif
5487   return new H245_ArrayOf_CommunicationModeTableEntry(*this);
5488 }
5489
5490
5491
5492 #ifndef PASN_NOPRINTON
5493 const static PASN_Names Names_H245_CommunicationModeTableEntry_dataType[]={
5494       {"videoData",0}
5495      ,{"audioData",1}
5496      ,{"data",2}
5497 };
5498 #endif
5499 //
5500 // CommunicationModeTableEntry_dataType
5501 //
5502
5503 H245_CommunicationModeTableEntry_dataType::H245_CommunicationModeTableEntry_dataType(unsigned tag, PASN_Object::TagClass tagClass)
5504   : PASN_Choice(tag, tagClass, 3, TRUE
5505 #ifndef PASN_NOPRINTON
5506     ,(const PASN_Names *)Names_H245_CommunicationModeTableEntry_dataType,3
5507 #endif
5508 )
5509 {
5510 }
5511
5512
5513 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
5514 H245_CommunicationModeTableEntry_dataType::operator H245_VideoCapability &() const
5515 #else
5516 H245_CommunicationModeTableEntry_dataType::operator H245_VideoCapability &()
5517 {
5518 #ifndef PASN_LEANANDMEAN
5519   PAssert(PIsDescendant(PAssertNULL(choice), H245_VideoCapability), PInvalidCast);
5520 #endif
5521   return *(H245_VideoCapability *)choice;
5522 }
5523
5524
5525 H245_CommunicationModeTableEntry_dataType::operator const H245_VideoCapability &() const
5526 #endif
5527 {
5528 #ifndef PASN_LEANANDMEAN
5529   PAssert(PIsDescendant(PAssertNULL(choice), H245_VideoCapability), PInvalidCast);
5530 #endif
5531   return *(H245_VideoCapability *)choice;
5532 }
5533
5534
5535 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
5536 H245_CommunicationModeTableEntry_dataType::operator H245_AudioCapability &() const
5537 #else
5538 H245_CommunicationModeTableEntry_dataType::operator H245_AudioCapability &()
5539 {
5540 #ifndef PASN_LEANANDMEAN
5541   PAssert(PIsDescendant(PAssertNULL(choice), H245_AudioCapability), PInvalidCast);
5542 #endif
5543   return *(H245_AudioCapability *)choice;
5544 }
5545
5546
5547 H245_CommunicationModeTableEntry_dataType::operator const H245_AudioCapability &() const
5548 #endif
5549 {
5550 #ifndef PASN_LEANANDMEAN
5551   PAssert(PIsDescendant(PAssertNULL(choice), H245_AudioCapability), PInvalidCast);
5552 #endif
5553   return *(H245_AudioCapability *)choice;
5554 }
5555
5556
5557 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
5558 H245_CommunicationModeTableEntry_dataType::operator H245_DataApplicationCapability &() const
5559 #else
5560 H245_CommunicationModeTableEntry_dataType::operator H245_DataApplicationCapability &()
5561 {
5562 #ifndef PASN_LEANANDMEAN
5563   PAssert(PIsDescendant(PAssertNULL(choice), H245_DataApplicationCapability), PInvalidCast);
5564 #endif
5565   return *(H245_DataApplicationCapability *)choice;
5566 }
5567
5568
5569 H245_CommunicationModeTableEntry_dataType::operator const H245_DataApplicationCapability &() const
5570 #endif
5571 {
5572 #ifndef PASN_LEANANDMEAN
5573   PAssert(PIsDescendant(PAssertNULL(choice), H245_DataApplicationCapability), PInvalidCast);
5574 #endif
5575   return *(H245_DataApplicationCapability *)choice;
5576 }
5577
5578
5579 BOOL H245_CommunicationModeTableEntry_dataType::CreateObject()
5580 {
5581   switch (tag) {
5582     case e_videoData :
5583       choice = new H245_VideoCapability();
5584       return TRUE;
5585     case e_audioData :
5586       choice = new H245_AudioCapability();
5587       return TRUE;
5588     case e_data :
5589       choice = new H245_DataApplicationCapability();
5590       return TRUE;
5591   }
5592
5593   choice = NULL;
5594   return FALSE;
5595 }
5596
5597
5598 PObject * H245_CommunicationModeTableEntry_dataType::Clone() const
5599 {
5600 #ifndef PASN_LEANANDMEAN
5601   PAssert(IsClass(H245_CommunicationModeTableEntry_dataType::Class()), PInvalidCast);
5602 #endif
5603   return new H245_CommunicationModeTableEntry_dataType(*this);
5604 }
5605
5606
5607 //
5608 // ArrayOf_TerminalLabel
5609 //
5610
5611 H245_ArrayOf_TerminalLabel::H245_ArrayOf_TerminalLabel(unsigned tag, PASN_Object::TagClass tagClass)
5612   : PASN_Array(tag, tagClass)
5613 {
5614 }
5615
5616
5617 PASN_Object * H245_ArrayOf_TerminalLabel::CreateObject() const
5618 {
5619   return new H245_TerminalLabel;
5620 }
5621
5622
5623 H245_TerminalLabel & H245_ArrayOf_TerminalLabel::operator[](PINDEX i) const
5624 {
5625   return (H245_TerminalLabel &)array[i];
5626 }
5627
5628
5629 PObject * H245_ArrayOf_TerminalLabel::Clone() const
5630 {
5631 #ifndef PASN_LEANANDMEAN
5632   PAssert(IsClass(H245_ArrayOf_TerminalLabel::Class()), PInvalidCast);
5633 #endif
5634   return new H245_ArrayOf_TerminalLabel(*this);
5635 }
5636
5637
5638
5639 #ifndef PASN_NOPRINTON
5640 const static PASN_Names Names_H245_ConferenceResponse_makeMeChairResponse[]={
5641       {"grantedChairToken",0}
5642      ,{"deniedChairToken",1}
5643 };
5644 #endif
5645 //
5646 // ConferenceResponse_makeMeChairResponse
5647 //
5648
5649 H245_ConferenceResponse_makeMeChairResponse::H245_ConferenceResponse_makeMeChairResponse(unsigned tag, PASN_Object::TagClass tagClass)
5650   : PASN_Choice(tag, tagClass, 2, TRUE
5651 #ifndef PASN_NOPRINTON
5652     ,(const PASN_Names *)Names_H245_ConferenceResponse_makeMeChairResponse,2
5653 #endif
5654 )
5655 {
5656 }
5657
5658
5659 BOOL H245_ConferenceResponse_makeMeChairResponse::CreateObject()
5660 {
5661   choice = (tag <= e_deniedChairToken) ? new PASN_Null() : NULL;
5662   return choice != NULL;
5663 }
5664
5665
5666 PObject * H245_ConferenceResponse_makeMeChairResponse::Clone() const
5667 {
5668 #ifndef PASN_LEANANDMEAN
5669   PAssert(IsClass(H245_ConferenceResponse_makeMeChairResponse::Class()), PInvalidCast);
5670 #endif
5671   return new H245_ConferenceResponse_makeMeChairResponse(*this);
5672 }
5673
5674
5675 //
5676 // ConferenceResponse_extensionAddressResponse
5677 //
5678
5679 H245_ConferenceResponse_extensionAddressResponse::H245_ConferenceResponse_extensionAddressResponse(unsigned tag, PASN_Object::TagClass tagClass)
5680   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
5681 {
5682 }
5683
5684
5685 #ifndef PASN_NOPRINTON
5686 void H245_ConferenceResponse_extensionAddressResponse::PrintOn(ostream & strm) const
5687 {
5688   int indent = strm.precision() + 2;
5689   strm << "{\n";
5690   strm << setw(indent+19) << "extensionAddress = " << setprecision(indent) << m_extensionAddress << '\n';
5691   strm << setw(indent-1) << setprecision(indent-2) << "}";
5692 }
5693 #endif
5694
5695
5696 PObject::Comparison H245_ConferenceResponse_extensionAddressResponse::Compare(const PObject & obj) const
5697 {
5698 #ifndef PASN_LEANANDMEAN
5699   PAssert(PIsDescendant(&obj, H245_ConferenceResponse_extensionAddressResponse), PInvalidCast);
5700 #endif
5701   const H245_ConferenceResponse_extensionAddressResponse & other = (const H245_ConferenceResponse_extensionAddressResponse &)obj;
5702
5703   Comparison result;
5704
5705   if ((result = m_extensionAddress.Compare(other.m_extensionAddress)) != EqualTo)
5706     return result;
5707
5708   return PASN_Sequence::Compare(other);
5709 }
5710
5711
5712 PINDEX H245_ConferenceResponse_extensionAddressResponse::GetDataLength() const
5713 {
5714   PINDEX length = 0;
5715   length += m_extensionAddress.GetObjectLength();
5716   return length;
5717 }
5718
5719
5720 BOOL H245_ConferenceResponse_extensionAddressResponse::Decode(PASN_Stream & strm)
5721 {
5722   if (!PreambleDecode(strm))
5723     return FALSE;
5724
5725   if (!m_extensionAddress.Decode(strm))
5726     return FALSE;
5727
5728   return UnknownExtensionsDecode(strm);
5729 }
5730
5731
5732 void H245_ConferenceResponse_extensionAddressResponse::Encode(PASN_Stream & strm) const
5733 {
5734   PreambleEncode(strm);
5735
5736   m_extensionAddress.Encode(strm);
5737
5738   UnknownExtensionsEncode(strm);
5739 }
5740
5741
5742 PObject * H245_ConferenceResponse_extensionAddressResponse::Clone() const
5743 {
5744 #ifndef PASN_LEANANDMEAN
5745   PAssert(IsClass(H245_ConferenceResponse_extensionAddressResponse::Class()), PInvalidCast);
5746 #endif
5747   return new H245_ConferenceResponse_extensionAddressResponse(*this);
5748 }
5749
5750
5751
5752 #ifndef PASN_NOPRINTON
5753 const static PASN_Names Names_H245_ConferenceResponse_broadcastMyLogicalChannelResponse[]={
5754       {"grantedBroadcastMyLogicalChannel",0}
5755      ,{"deniedBroadcastMyLogicalChannel",1}
5756 };
5757 #endif
5758 //
5759 // ConferenceResponse_broadcastMyLogicalChannelResponse
5760 //
5761
5762 H245_ConferenceResponse_broadcastMyLogicalChannelResponse::H245_ConferenceResponse_broadcastMyLogicalChannelResponse(unsigned tag, PASN_Object::TagClass tagClass)
5763   : PASN_Choice(tag, tagClass, 2, TRUE
5764 #ifndef PASN_NOPRINTON
5765     ,(const PASN_Names *)Names_H245_ConferenceResponse_broadcastMyLogicalChannelResponse,2
5766 #endif
5767 )
5768 {
5769 }
5770
5771
5772 BOOL H245_ConferenceResponse_broadcastMyLogicalChannelResponse::CreateObject()
5773 {
5774   choice = (tag <= e_deniedBroadcastMyLogicalChannel) ? new PASN_Null() : NULL;
5775   return choice != NULL;
5776 }
5777
5778
5779 PObject * H245_ConferenceResponse_broadcastMyLogicalChannelResponse::Clone() const
5780 {
5781 #ifndef PASN_LEANANDMEAN
5782   PAssert(IsClass(H245_ConferenceResponse_broadcastMyLogicalChannelResponse::Class()), PInvalidCast);
5783 #endif
5784   return new H245_ConferenceResponse_broadcastMyLogicalChannelResponse(*this);
5785 }
5786
5787
5788
5789 #ifndef PASN_NOPRINTON
5790 const static PASN_Names Names_H245_ConferenceResponse_makeTerminalBroadcasterResponse[]={
5791       {"grantedMakeTerminalBroadcaster",0}
5792      ,{"deniedMakeTerminalBroadcaster",1}
5793 };
5794 #endif
5795 //
5796 // ConferenceResponse_makeTerminalBroadcasterResponse
5797 //
5798
5799 H245_ConferenceResponse_makeTerminalBroadcasterResponse::H245_ConferenceResponse_makeTerminalBroadcasterResponse(unsigned tag, PASN_Object::TagClass tagClass)
5800   : PASN_Choice(tag, tagClass, 2, TRUE
5801 #ifndef PASN_NOPRINTON
5802     ,(const PASN_Names *)Names_H245_ConferenceResponse_makeTerminalBroadcasterResponse,2
5803 #endif
5804 )
5805 {
5806 }
5807
5808
5809 BOOL H245_ConferenceResponse_makeTerminalBroadcasterResponse::CreateObject()
5810 {
5811   choice = (tag <= e_deniedMakeTerminalBroadcaster) ? new PASN_Null() : NULL;
5812   return choice != NULL;
5813 }
5814
5815
5816 PObject * H245_ConferenceResponse_makeTerminalBroadcasterResponse::Clone() const
5817 {
5818 #ifndef PASN_LEANANDMEAN
5819   PAssert(IsClass(H245_ConferenceResponse_makeTerminalBroadcasterResponse::Class()), PInvalidCast);
5820 #endif
5821   return new H245_ConferenceResponse_makeTerminalBroadcasterResponse(*this);
5822 }
5823
5824
5825
5826 #ifndef PASN_NOPRINTON
5827 const static PASN_Names Names_H245_ConferenceResponse_sendThisSourceResponse[]={
5828       {"grantedSendThisSource",0}
5829      ,{"deniedSendThisSource",1}
5830 };
5831 #endif
5832 //
5833 // ConferenceResponse_sendThisSourceResponse
5834 //
5835
5836 H245_ConferenceResponse_sendThisSourceResponse::H245_ConferenceResponse_sendThisSourceResponse(unsigned tag, PASN_Object::TagClass tagClass)
5837   : PASN_Choice(tag, tagClass, 2, TRUE
5838 #ifndef PASN_NOPRINTON
5839     ,(const PASN_Names *)Names_H245_ConferenceResponse_sendThisSourceResponse,2
5840 #endif
5841 )
5842 {
5843 }
5844
5845
5846 BOOL H245_ConferenceResponse_sendThisSourceResponse::CreateObject()
5847 {
5848   choice = (tag <= e_deniedSendThisSource) ? new PASN_Null() : NULL;
5849   return choice != NULL;
5850 }
5851
5852
5853 PObject * H245_ConferenceResponse_sendThisSourceResponse::Clone() const
5854 {
5855 #ifndef PASN_LEANANDMEAN
5856   PAssert(IsClass(H245_ConferenceResponse_sendThisSourceResponse::Class()), PInvalidCast);
5857 #endif
5858   return new H245_ConferenceResponse_sendThisSourceResponse(*this);
5859 }
5860
5861
5862 //
5863 // ArrayOf_TerminalInformation
5864 //
5865
5866 H245_ArrayOf_TerminalInformation::H245_ArrayOf_TerminalInformation(unsigned tag, PASN_Object::TagClass tagClass)
5867   : PASN_Array(tag, tagClass)
5868 {
5869 }
5870
5871
5872 PASN_Object * H245_ArrayOf_TerminalInformation::CreateObject() const
5873 {
5874   return new H245_TerminalInformation;
5875 }
5876
5877
5878 H245_TerminalInformation & H245_ArrayOf_TerminalInformation::operator[](PINDEX i) const
5879 {
5880   return (H245_TerminalInformation &)array[i];
5881 }
5882
5883
5884 PObject * H245_ArrayOf_TerminalInformation::Clone() const
5885 {
5886 #ifndef PASN_LEANANDMEAN
5887   PAssert(IsClass(H245_ArrayOf_TerminalInformation::Class()), PInvalidCast);
5888 #endif
5889   return new H245_ArrayOf_TerminalInformation(*this);
5890 }
5891
5892
5893
5894 #ifndef PASN_NOPRINTON
5895 const static PASN_Names Names_H245_RemoteMCResponse_reject[]={
5896       {"unspecified",0}
5897      ,{"functionNotSupported",1}
5898 };
5899 #endif
5900 //
5901 // RemoteMCResponse_reject
5902 //
5903
5904 H245_RemoteMCResponse_reject::H245_RemoteMCResponse_reject(unsigned tag, PASN_Object::TagClass tagClass)
5905   : PASN_Choice(tag, tagClass, 2, TRUE
5906 #ifndef PASN_NOPRINTON
5907     ,(const PASN_Names *)Names_H245_RemoteMCResponse_reject,2
5908 #endif
5909 )
5910 {
5911 }
5912
5913
5914 BOOL H245_RemoteMCResponse_reject::CreateObject()
5915 {
5916   choice = (tag <= e_functionNotSupported) ? new PASN_Null() : NULL;
5917   return choice != NULL;
5918 }
5919
5920
5921 PObject * H245_RemoteMCResponse_reject::Clone() const
5922 {
5923 #ifndef PASN_LEANANDMEAN
5924   PAssert(IsClass(H245_RemoteMCResponse_reject::Class()), PInvalidCast);
5925 #endif
5926   return new H245_RemoteMCResponse_reject(*this);
5927 }
5928
5929
5930 //
5931 // MultilinkRequest_callInformation
5932 //
5933
5934 H245_MultilinkRequest_callInformation::H245_MultilinkRequest_callInformation(unsigned tag, PASN_Object::TagClass tagClass)
5935   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
5936 {
5937   m_maxNumberOfAdditionalConnections.SetConstraints(PASN_Object::FixedConstraint, 1, 65535);
5938 }
5939
5940
5941 #ifndef PASN_NOPRINTON
5942 void H245_MultilinkRequest_callInformation::PrintOn(ostream & strm) const
5943 {
5944   int indent = strm.precision() + 2;
5945   strm << "{\n";
5946   strm << setw(indent+35) << "maxNumberOfAdditionalConnections = " << setprecision(indent) << m_maxNumberOfAdditionalConnections << '\n';
5947   strm << setw(indent-1) << setprecision(indent-2) << "}";
5948 }
5949 #endif
5950
5951
5952 PObject::Comparison H245_MultilinkRequest_callInformation::Compare(const PObject & obj) const
5953 {
5954 #ifndef PASN_LEANANDMEAN
5955   PAssert(PIsDescendant(&obj, H245_MultilinkRequest_callInformation), PInvalidCast);
5956 #endif
5957   const H245_MultilinkRequest_callInformation & other = (const H245_MultilinkRequest_callInformation &)obj;
5958
5959   Comparison result;
5960
5961   if ((result = m_maxNumberOfAdditionalConnections.Compare(other.m_maxNumberOfAdditionalConnections)) != EqualTo)
5962     return result;
5963
5964   return PASN_Sequence::Compare(other);
5965 }
5966
5967
5968 PINDEX H245_MultilinkRequest_callInformation::GetDataLength() const
5969 {
5970   PINDEX length = 0;
5971   length += m_maxNumberOfAdditionalConnections.GetObjectLength();
5972   return length;
5973 }
5974
5975
5976 BOOL H245_MultilinkRequest_callInformation::Decode(PASN_Stream & strm)
5977 {
5978   if (!PreambleDecode(strm))
5979     return FALSE;
5980
5981   if (!m_maxNumberOfAdditionalConnections.Decode(strm))
5982     return FALSE;
5983
5984   return UnknownExtensionsDecode(strm);
5985 }
5986
5987
5988 void H245_MultilinkRequest_callInformation::Encode(PASN_Stream & strm) const
5989 {
5990   PreambleEncode(strm);
5991
5992   m_maxNumberOfAdditionalConnections.Encode(strm);
5993
5994   UnknownExtensionsEncode(strm);
5995 }
5996
5997
5998 PObject * H245_MultilinkRequest_callInformation::Clone() const
5999 {
6000 #ifndef PASN_LEANANDMEAN
6001   PAssert(IsClass(H245_MultilinkRequest_callInformation::Class()), PInvalidCast);
6002 #endif
6003   return new H245_MultilinkRequest_callInformation(*this);
6004 }
6005
6006
6007 //
6008 // MultilinkRequest_addConnection
6009 //
6010
6011 H245_MultilinkRequest_addConnection::H245_MultilinkRequest_addConnection(unsigned tag, PASN_Object::TagClass tagClass)
6012   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
6013 {
6014 }
6015
6016
6017 #ifndef PASN_NOPRINTON
6018 void H245_MultilinkRequest_addConnection::PrintOn(ostream & strm) const
6019 {
6020   int indent = strm.precision() + 2;
6021   strm << "{\n";
6022   strm << setw(indent+17) << "sequenceNumber = " << setprecision(indent) << m_sequenceNumber << '\n';
6023   strm << setw(indent+21) << "dialingInformation = " << setprecision(indent) << m_dialingInformation << '\n';
6024   strm << setw(indent-1) << setprecision(indent-2) << "}";
6025 }
6026 #endif
6027
6028
6029 PObject::Comparison H245_MultilinkRequest_addConnection::Compare(const PObject & obj) const
6030 {
6031 #ifndef PASN_LEANANDMEAN
6032   PAssert(PIsDescendant(&obj, H245_MultilinkRequest_addConnection), PInvalidCast);
6033 #endif
6034   const H245_MultilinkRequest_addConnection & other = (const H245_MultilinkRequest_addConnection &)obj;
6035
6036   Comparison result;
6037
6038   if ((result = m_sequenceNumber.Compare(other.m_sequenceNumber)) != EqualTo)
6039     return result;
6040   if ((result = m_dialingInformation.Compare(other.m_dialingInformation)) != EqualTo)
6041     return result;
6042
6043   return PASN_Sequence::Compare(other);
6044 }
6045
6046
6047 PINDEX H245_MultilinkRequest_addConnection::GetDataLength() const
6048 {
6049   PINDEX length = 0;
6050   length += m_sequenceNumber.GetObjectLength();
6051   length += m_dialingInformation.GetObjectLength();
6052   return length;
6053 }
6054
6055
6056 BOOL H245_MultilinkRequest_addConnection::Decode(PASN_Stream & strm)
6057 {
6058   if (!PreambleDecode(strm))
6059     return FALSE;
6060
6061   if (!m_sequenceNumber.Decode(strm))
6062     return FALSE;
6063   if (!m_dialingInformation.Decode(strm))
6064     return FALSE;
6065
6066   return UnknownExtensionsDecode(strm);
6067 }
6068
6069
6070 void H245_MultilinkRequest_addConnection::Encode(PASN_Stream & strm) const
6071 {
6072   PreambleEncode(strm);
6073
6074   m_sequenceNumber.Encode(strm);
6075   m_dialingInformation.Encode(strm);
6076
6077   UnknownExtensionsEncode(strm);
6078 }
6079
6080
6081 PObject * H245_MultilinkRequest_addConnection::Clone() const
6082 {
6083 #ifndef PASN_LEANANDMEAN
6084   PAssert(IsClass(H245_MultilinkRequest_addConnection::Class()), PInvalidCast);
6085 #endif
6086   return new H245_MultilinkRequest_addConnection(*this);
6087 }
6088
6089
6090 //
6091 // MultilinkRequest_removeConnection
6092 //
6093
6094 H245_MultilinkRequest_removeConnection::H245_MultilinkRequest_removeConnection(unsigned tag, PASN_Object::TagClass tagClass)
6095   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
6096 {
6097 }
6098
6099
6100 #ifndef PASN_NOPRINTON
6101 void H245_MultilinkRequest_removeConnection::PrintOn(ostream & strm) const
6102 {
6103   int indent = strm.precision() + 2;
6104   strm << "{\n";
6105   strm << setw(indent+23) << "connectionIdentifier = " << setprecision(indent) << m_connectionIdentifier << '\n';
6106   strm << setw(indent-1) << setprecision(indent-2) << "}";
6107 }
6108 #endif
6109
6110
6111 PObject::Comparison H245_MultilinkRequest_removeConnection::Compare(const PObject & obj) const
6112 {
6113 #ifndef PASN_LEANANDMEAN
6114   PAssert(PIsDescendant(&obj, H245_MultilinkRequest_removeConnection), PInvalidCast);
6115 #endif
6116   const H245_MultilinkRequest_removeConnection & other = (const H245_MultilinkRequest_removeConnection &)obj;
6117
6118   Comparison result;
6119
6120   if ((result = m_connectionIdentifier.Compare(other.m_connectionIdentifier)) != EqualTo)
6121     return result;
6122
6123   return PASN_Sequence::Compare(other);
6124 }
6125
6126
6127 PINDEX H245_MultilinkRequest_removeConnection::GetDataLength() const
6128 {
6129   PINDEX length = 0;
6130   length += m_connectionIdentifier.GetObjectLength();
6131   return length;
6132 }
6133
6134
6135 BOOL H245_MultilinkRequest_removeConnection::Decode(PASN_Stream & strm)
6136 {
6137   if (!PreambleDecode(strm))
6138     return FALSE;
6139
6140   if (!m_connectionIdentifier.Decode(strm))
6141     return FALSE;
6142
6143   return UnknownExtensionsDecode(strm);
6144 }
6145
6146
6147 void H245_MultilinkRequest_removeConnection::Encode(PASN_Stream & strm) const
6148 {
6149   PreambleEncode(strm);
6150
6151   m_connectionIdentifier.Encode(strm);
6152
6153   UnknownExtensionsEncode(strm);
6154 }
6155
6156
6157 PObject * H245_MultilinkRequest_removeConnection::Clone() const
6158 {
6159 #ifndef PASN_LEANANDMEAN
6160   PAssert(IsClass(H245_MultilinkRequest_removeConnection::Class()), PInvalidCast);
6161 #endif
6162   return new H245_MultilinkRequest_removeConnection(*this);
6163 }
6164
6165
6166 //
6167 // MultilinkResponse_callInformation
6168 //
6169
6170 H245_MultilinkResponse_callInformation::H245_MultilinkResponse_callInformation(unsigned tag, PASN_Object::TagClass tagClass)
6171   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
6172 {
6173   m_callAssociationNumber.SetConstraints(PASN_Object::FixedConstraint, 0, 4294967295U);
6174 }
6175
6176
6177 #ifndef PASN_NOPRINTON
6178 void H245_MultilinkResponse_callInformation::PrintOn(ostream & strm) const
6179 {
6180   int indent = strm.precision() + 2;
6181   strm << "{\n";
6182   strm << setw(indent+21) << "dialingInformation = " << setprecision(indent) << m_dialingInformation << '\n';
6183   strm << setw(indent+24) << "callAssociationNumber = " << setprecision(indent) << m_callAssociationNumber << '\n';
6184   strm << setw(indent-1) << setprecision(indent-2) << "}";
6185 }
6186 #endif
6187
6188
6189 PObject::Comparison H245_MultilinkResponse_callInformation::Compare(const PObject & obj) const
6190 {
6191 #ifndef PASN_LEANANDMEAN
6192   PAssert(PIsDescendant(&obj, H245_MultilinkResponse_callInformation), PInvalidCast);
6193 #endif
6194   const H245_MultilinkResponse_callInformation & other = (const H245_MultilinkResponse_callInformation &)obj;
6195
6196   Comparison result;
6197
6198   if ((result = m_dialingInformation.Compare(other.m_dialingInformation)) != EqualTo)
6199     return result;
6200   if ((result = m_callAssociationNumber.Compare(other.m_callAssociationNumber)) != EqualTo)
6201     return result;
6202
6203   return PASN_Sequence::Compare(other);
6204 }
6205
6206
6207 PINDEX H245_MultilinkResponse_callInformation::GetDataLength() const
6208 {
6209   PINDEX length = 0;
6210   length += m_dialingInformation.GetObjectLength();
6211   length += m_callAssociationNumber.GetObjectLength();
6212   return length;
6213 }
6214
6215
6216 BOOL H245_MultilinkResponse_callInformation::Decode(PASN_Stream & strm)
6217 {
6218   if (!PreambleDecode(strm))
6219     return FALSE;
6220
6221   if (!m_dialingInformation.Decode(strm))
6222     return FALSE;
6223   if (!m_callAssociationNumber.Decode(strm))
6224     return FALSE;
6225
6226   return UnknownExtensionsDecode(strm);
6227 }
6228
6229
6230 void H245_MultilinkResponse_callInformation::Encode(PASN_Stream & strm) const
6231 {
6232   PreambleEncode(strm);
6233
6234   m_dialingInformation.Encode(strm);
6235   m_callAssociationNumber.Encode(strm);
6236
6237   UnknownExtensionsEncode(strm);
6238 }
6239
6240
6241 PObject * H245_MultilinkResponse_callInformation::Clone() const
6242 {
6243 #ifndef PASN_LEANANDMEAN
6244   PAssert(IsClass(H245_MultilinkResponse_callInformation::Class()), PInvalidCast);
6245 #endif
6246   return new H245_MultilinkResponse_callInformation(*this);
6247 }
6248
6249
6250 //
6251 // MultilinkResponse_removeConnection
6252 //
6253
6254 H245_MultilinkResponse_removeConnection::H245_MultilinkResponse_removeConnection(unsigned tag, PASN_Object::TagClass tagClass)
6255   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
6256 {
6257 }
6258
6259
6260 #ifndef PASN_NOPRINTON
6261 void H245_MultilinkResponse_removeConnection::PrintOn(ostream & strm) const
6262 {
6263   int indent = strm.precision() + 2;
6264   strm << "{\n";
6265   strm << setw(indent+23) << "connectionIdentifier = " << setprecision(indent) << m_connectionIdentifier << '\n';
6266   strm << setw(indent-1) << setprecision(indent-2) << "}";
6267 }
6268 #endif
6269
6270
6271 PObject::Comparison H245_MultilinkResponse_removeConnection::Compare(const PObject & obj) const
6272 {
6273 #ifndef PASN_LEANANDMEAN
6274   PAssert(PIsDescendant(&obj, H245_MultilinkResponse_removeConnection), PInvalidCast);
6275 #endif
6276   const H245_MultilinkResponse_removeConnection & other = (const H245_MultilinkResponse_removeConnection &)obj;
6277
6278   Comparison result;
6279
6280   if ((result = m_connectionIdentifier.Compare(other.m_connectionIdentifier)) != EqualTo)
6281     return result;
6282
6283   return PASN_Sequence::Compare(other);
6284 }
6285
6286
6287 PINDEX H245_MultilinkResponse_removeConnection::GetDataLength() const
6288 {
6289   PINDEX length = 0;
6290   length += m_connectionIdentifier.GetObjectLength();
6291   return length;
6292 }
6293
6294
6295 BOOL H245_MultilinkResponse_removeConnection::Decode(PASN_Stream & strm)
6296 {
6297   if (!PreambleDecode(strm))
6298     return FALSE;
6299
6300   if (!m_connectionIdentifier.Decode(strm))
6301     return FALSE;
6302
6303   return UnknownExtensionsDecode(strm);
6304 }
6305
6306
6307 void H245_MultilinkResponse_removeConnection::Encode(PASN_Stream & strm) const
6308 {
6309   PreambleEncode(strm);
6310
6311   m_connectionIdentifier.Encode(strm);
6312
6313   UnknownExtensionsEncode(strm);
6314 }
6315
6316
6317 PObject * H245_MultilinkResponse_removeConnection::Clone() const
6318 {
6319 #ifndef PASN_LEANANDMEAN
6320   PAssert(IsClass(H245_MultilinkResponse_removeConnection::Class()), PInvalidCast);
6321 #endif
6322   return new H245_MultilinkResponse_removeConnection(*this);
6323 }
6324
6325
6326 //
6327 // MultilinkResponse_maximumHeaderInterval
6328 //
6329
6330 H245_MultilinkResponse_maximumHeaderInterval::H245_MultilinkResponse_maximumHeaderInterval(unsigned tag, PASN_Object::TagClass tagClass)
6331   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
6332 {
6333   m_currentInterval.SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
6334 }
6335
6336
6337 #ifndef PASN_NOPRINTON
6338 void H245_MultilinkResponse_maximumHeaderInterval::PrintOn(ostream & strm) const
6339 {
6340   int indent = strm.precision() + 2;
6341   strm << "{\n";
6342   strm << setw(indent+18) << "currentInterval = " << setprecision(indent) << m_currentInterval << '\n';
6343   strm << setw(indent-1) << setprecision(indent-2) << "}";
6344 }
6345 #endif
6346
6347
6348 PObject::Comparison H245_MultilinkResponse_maximumHeaderInterval::Compare(const PObject & obj) const
6349 {
6350 #ifndef PASN_LEANANDMEAN
6351   PAssert(PIsDescendant(&obj, H245_MultilinkResponse_maximumHeaderInterval), PInvalidCast);
6352 #endif
6353   const H245_MultilinkResponse_maximumHeaderInterval & other = (const H245_MultilinkResponse_maximumHeaderInterval &)obj;
6354
6355   Comparison result;
6356
6357   if ((result = m_currentInterval.Compare(other.m_currentInterval)) != EqualTo)
6358     return result;
6359
6360   return PASN_Sequence::Compare(other);
6361 }
6362
6363
6364 PINDEX H245_MultilinkResponse_maximumHeaderInterval::GetDataLength() const
6365 {
6366   PINDEX length = 0;
6367   length += m_currentInterval.GetObjectLength();
6368   return length;
6369 }
6370
6371
6372 BOOL H245_MultilinkResponse_maximumHeaderInterval::Decode(PASN_Stream & strm)
6373 {
6374   if (!PreambleDecode(strm))
6375     return FALSE;
6376
6377   if (!m_currentInterval.Decode(strm))
6378     return FALSE;
6379
6380   return UnknownExtensionsDecode(strm);
6381 }
6382
6383
6384 void H245_MultilinkResponse_maximumHeaderInterval::Encode(PASN_Stream & strm) const
6385 {
6386   PreambleEncode(strm);
6387
6388   m_currentInterval.Encode(strm);
6389
6390   UnknownExtensionsEncode(strm);
6391 }
6392
6393
6394 PObject * H245_MultilinkResponse_maximumHeaderInterval::Clone() const
6395 {
6396 #ifndef PASN_LEANANDMEAN
6397   PAssert(IsClass(H245_MultilinkResponse_maximumHeaderInterval::Class()), PInvalidCast);
6398 #endif
6399   return new H245_MultilinkResponse_maximumHeaderInterval(*this);
6400 }
6401
6402
6403 //
6404 // MultilinkIndication_crcDesired
6405 //
6406
6407 H245_MultilinkIndication_crcDesired::H245_MultilinkIndication_crcDesired(unsigned tag, PASN_Object::TagClass tagClass)
6408   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
6409 {
6410 }
6411
6412
6413 #ifndef PASN_NOPRINTON
6414 void H245_MultilinkIndication_crcDesired::PrintOn(ostream & strm) const
6415 {
6416   int indent = strm.precision() + 2;
6417   strm << "{\n";
6418   strm << setw(indent-1) << setprecision(indent-2) << "}";
6419 }
6420 #endif
6421
6422
6423 PINDEX H245_MultilinkIndication_crcDesired::GetDataLength() const
6424 {
6425   PINDEX length = 0;
6426   return length;
6427 }
6428
6429
6430 BOOL H245_MultilinkIndication_crcDesired::Decode(PASN_Stream & strm)
6431 {
6432   if (!PreambleDecode(strm))
6433     return FALSE;
6434
6435
6436   return UnknownExtensionsDecode(strm);
6437 }
6438
6439
6440 void H245_MultilinkIndication_crcDesired::Encode(PASN_Stream & strm) const
6441 {
6442   PreambleEncode(strm);
6443
6444
6445   UnknownExtensionsEncode(strm);
6446 }
6447
6448
6449 PObject * H245_MultilinkIndication_crcDesired::Clone() const
6450 {
6451 #ifndef PASN_LEANANDMEAN
6452   PAssert(IsClass(H245_MultilinkIndication_crcDesired::Class()), PInvalidCast);
6453 #endif
6454   return new H245_MultilinkIndication_crcDesired(*this);
6455 }
6456
6457
6458 //
6459 // MultilinkIndication_excessiveError
6460 //
6461
6462 H245_MultilinkIndication_excessiveError::H245_MultilinkIndication_excessiveError(unsigned tag, PASN_Object::TagClass tagClass)
6463   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
6464 {
6465 }
6466
6467
6468 #ifndef PASN_NOPRINTON
6469 void H245_MultilinkIndication_excessiveError::PrintOn(ostream & strm) const
6470 {
6471   int indent = strm.precision() + 2;
6472   strm << "{\n";
6473   strm << setw(indent+23) << "connectionIdentifier = " << setprecision(indent) << m_connectionIdentifier << '\n';
6474   strm << setw(indent-1) << setprecision(indent-2) << "}";
6475 }
6476 #endif
6477
6478
6479 PObject::Comparison H245_MultilinkIndication_excessiveError::Compare(const PObject & obj) const
6480 {
6481 #ifndef PASN_LEANANDMEAN
6482   PAssert(PIsDescendant(&obj, H245_MultilinkIndication_excessiveError), PInvalidCast);
6483 #endif
6484   const H245_MultilinkIndication_excessiveError & other = (const H245_MultilinkIndication_excessiveError &)obj;
6485
6486   Comparison result;
6487
6488   if ((result = m_connectionIdentifier.Compare(other.m_connectionIdentifier)) != EqualTo)
6489     return result;
6490
6491   return PASN_Sequence::Compare(other);
6492 }
6493
6494
6495 PINDEX H245_MultilinkIndication_excessiveError::GetDataLength() const
6496 {
6497   PINDEX length = 0;
6498   length += m_connectionIdentifier.GetObjectLength();
6499   return length;
6500 }
6501
6502
6503 BOOL H245_MultilinkIndication_excessiveError::Decode(PASN_Stream & strm)
6504 {
6505   if (!PreambleDecode(strm))
6506     return FALSE;
6507
6508   if (!m_connectionIdentifier.Decode(strm))
6509     return FALSE;
6510
6511   return UnknownExtensionsDecode(strm);
6512 }
6513
6514
6515 void H245_MultilinkIndication_excessiveError::Encode(PASN_Stream & strm) const
6516 {
6517   PreambleEncode(strm);
6518
6519   m_connectionIdentifier.Encode(strm);
6520
6521   UnknownExtensionsEncode(strm);
6522 }
6523
6524
6525 PObject * H245_MultilinkIndication_excessiveError::Clone() const
6526 {
6527 #ifndef PASN_LEANANDMEAN
6528   PAssert(IsClass(H245_MultilinkIndication_excessiveError::Class()), PInvalidCast);
6529 #endif
6530   return new H245_MultilinkIndication_excessiveError(*this);
6531 }
6532
6533
6534 //
6535 // ArrayOf_DialingInformationNumber
6536 //
6537
6538 H245_ArrayOf_DialingInformationNumber::H245_ArrayOf_DialingInformationNumber(unsigned tag, PASN_Object::TagClass tagClass)
6539   : PASN_Array(tag, tagClass)
6540 {
6541 }
6542
6543
6544 PASN_Object * H245_ArrayOf_DialingInformationNumber::CreateObject() const
6545 {
6546   return new H245_DialingInformationNumber;
6547 }
6548
6549
6550 H245_DialingInformationNumber & H245_ArrayOf_DialingInformationNumber::operator[](PINDEX i) const
6551 {
6552   return (H245_DialingInformationNumber &)array[i];
6553 }
6554
6555
6556 PObject * H245_ArrayOf_DialingInformationNumber::Clone() const
6557 {
6558 #ifndef PASN_LEANANDMEAN
6559   PAssert(IsClass(H245_ArrayOf_DialingInformationNumber::Class()), PInvalidCast);
6560 #endif
6561   return new H245_ArrayOf_DialingInformationNumber(*this);
6562 }
6563
6564
6565 //
6566 // ArrayOf_DialingInformationNetworkType
6567 //
6568
6569 H245_ArrayOf_DialingInformationNetworkType::H245_ArrayOf_DialingInformationNetworkType(unsigned tag, PASN_Object::TagClass tagClass)
6570   : PASN_Array(tag, tagClass)
6571 {
6572 }
6573
6574
6575 PASN_Object * H245_ArrayOf_DialingInformationNetworkType::CreateObject() const
6576 {
6577   return new H245_DialingInformationNetworkType;
6578 }
6579
6580
6581 H245_DialingInformationNetworkType & H245_ArrayOf_DialingInformationNetworkType::operator[](PINDEX i) const
6582 {
6583   return (H245_DialingInformationNetworkType &)array[i];
6584 }
6585
6586
6587 PObject * H245_ArrayOf_DialingInformationNetworkType::Clone() const
6588 {
6589 #ifndef PASN_LEANANDMEAN
6590   PAssert(IsClass(H245_ArrayOf_DialingInformationNetworkType::Class()), PInvalidCast);
6591 #endif
6592   return new H245_ArrayOf_DialingInformationNetworkType(*this);
6593 }
6594
6595
6596
6597 #ifndef PASN_NOPRINTON
6598 const static PASN_Names Names_H245_FlowControlCommand_scope[]={
6599       {"logicalChannelNumber",0}
6600      ,{"resourceID",1}
6601      ,{"wholeMultiplex",2}
6602 };
6603 #endif
6604 //
6605 // FlowControlCommand_scope
6606 //
6607
6608 H245_FlowControlCommand_scope::H245_FlowControlCommand_scope(unsigned tag, PASN_Object::TagClass tagClass)
6609   : PASN_Choice(tag, tagClass, 3, FALSE
6610 #ifndef PASN_NOPRINTON
6611     ,(const PASN_Names *)Names_H245_FlowControlCommand_scope,3
6612 #endif
6613 )
6614 {
6615 }
6616
6617
6618 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
6619 H245_FlowControlCommand_scope::operator H245_LogicalChannelNumber &() const
6620 #else
6621 H245_FlowControlCommand_scope::operator H245_LogicalChannelNumber &()
6622 {
6623 #ifndef PASN_LEANANDMEAN
6624   PAssert(PIsDescendant(PAssertNULL(choice), H245_LogicalChannelNumber), PInvalidCast);
6625 #endif
6626   return *(H245_LogicalChannelNumber *)choice;
6627 }
6628
6629
6630 H245_FlowControlCommand_scope::operator const H245_LogicalChannelNumber &() const
6631 #endif
6632 {
6633 #ifndef PASN_LEANANDMEAN
6634   PAssert(PIsDescendant(PAssertNULL(choice), H245_LogicalChannelNumber), PInvalidCast);
6635 #endif
6636   return *(H245_LogicalChannelNumber *)choice;
6637 }
6638
6639
6640 BOOL H245_FlowControlCommand_scope::CreateObject()
6641 {
6642   switch (tag) {
6643     case e_logicalChannelNumber :
6644       choice = new H245_LogicalChannelNumber();
6645       return TRUE;
6646     case e_resourceID :
6647       choice = new PASN_Integer();
6648       choice->SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
6649       return TRUE;
6650     case e_wholeMultiplex :
6651       choice = new PASN_Null();
6652       return TRUE;
6653   }
6654
6655   choice = NULL;
6656   return FALSE;
6657 }
6658
6659
6660 PObject * H245_FlowControlCommand_scope::Clone() const
6661 {
6662 #ifndef PASN_LEANANDMEAN
6663   PAssert(IsClass(H245_FlowControlCommand_scope::Class()), PInvalidCast);
6664 #endif
6665   return new H245_FlowControlCommand_scope(*this);
6666 }
6667
6668
6669
6670 #ifndef PASN_NOPRINTON
6671 const static PASN_Names Names_H245_FlowControlCommand_restriction[]={
6672       {"maximumBitRate",0}
6673      ,{"noRestriction",1}
6674 };
6675 #endif
6676 //
6677 // FlowControlCommand_restriction
6678 //
6679
6680 H245_FlowControlCommand_restriction::H245_FlowControlCommand_restriction(unsigned tag, PASN_Object::TagClass tagClass)
6681   : PASN_Choice(tag, tagClass, 2, FALSE
6682 #ifndef PASN_NOPRINTON
6683     ,(const PASN_Names *)Names_H245_FlowControlCommand_restriction,2
6684 #endif
6685 )
6686 {
6687 }
6688
6689
6690 BOOL H245_FlowControlCommand_restriction::CreateObject()
6691 {
6692   switch (tag) {
6693     case e_maximumBitRate :
6694       choice = new PASN_Integer();
6695       choice->SetConstraints(PASN_Object::FixedConstraint, 0, 16777215);
6696       return TRUE;
6697     case e_noRestriction :
6698       choice = new PASN_Null();
6699       return TRUE;
6700   }
6701
6702   choice = NULL;
6703   return FALSE;
6704 }
6705
6706
6707 PObject * H245_FlowControlCommand_restriction::Clone() const
6708 {
6709 #ifndef PASN_LEANANDMEAN
6710   PAssert(IsClass(H245_FlowControlCommand_restriction::Class()), PInvalidCast);
6711 #endif
6712   return new H245_FlowControlCommand_restriction(*this);
6713 }
6714
6715
6716
6717 #ifndef PASN_NOPRINTON
6718 const static PASN_Names Names_H245_EndSessionCommand_gstnOptions[]={
6719       {"telephonyMode",0}
6720      ,{"v8bis",1}
6721      ,{"v34DSVD",2}
6722      ,{"v34DuplexFAX",3}
6723      ,{"v34H324",4}
6724 };
6725 #endif
6726 //
6727 // EndSessionCommand_gstnOptions
6728 //
6729
6730 H245_EndSessionCommand_gstnOptions::H245_EndSessionCommand_gstnOptions(unsigned tag, PASN_Object::TagClass tagClass)
6731   : PASN_Choice(tag, tagClass, 5, TRUE
6732 #ifndef PASN_NOPRINTON
6733     ,(const PASN_Names *)Names_H245_EndSessionCommand_gstnOptions,5
6734 #endif
6735 )
6736 {
6737 }
6738
6739
6740 BOOL H245_EndSessionCommand_gstnOptions::CreateObject()
6741 {
6742   choice = (tag <= e_v34H324) ? new PASN_Null() : NULL;
6743   return choice != NULL;
6744 }
6745
6746
6747 PObject * H245_EndSessionCommand_gstnOptions::Clone() const
6748 {
6749 #ifndef PASN_LEANANDMEAN
6750   PAssert(IsClass(H245_EndSessionCommand_gstnOptions::Class()), PInvalidCast);
6751 #endif
6752   return new H245_EndSessionCommand_gstnOptions(*this);
6753 }
6754
6755
6756
6757 #ifndef PASN_NOPRINTON
6758 const static PASN_Names Names_H245_EndSessionCommand_isdnOptions[]={
6759       {"telephonyMode",0}
6760      ,{"v140",1}
6761      ,{"terminalOnHold",2}
6762 };
6763 #endif
6764 //
6765 // EndSessionCommand_isdnOptions
6766 //
6767
6768 H245_EndSessionCommand_isdnOptions::H245_EndSessionCommand_isdnOptions(unsigned tag, PASN_Object::TagClass tagClass)
6769   : PASN_Choice(tag, tagClass, 3, TRUE
6770 #ifndef PASN_NOPRINTON
6771     ,(const PASN_Names *)Names_H245_EndSessionCommand_isdnOptions,3
6772 #endif
6773 )
6774 {
6775 }
6776
6777
6778 BOOL H245_EndSessionCommand_isdnOptions::CreateObject()
6779 {
6780   choice = (tag <= e_terminalOnHold) ? new PASN_Null() : NULL;
6781   return choice != NULL;
6782 }
6783
6784
6785 PObject * H245_EndSessionCommand_isdnOptions::Clone() const
6786 {
6787 #ifndef PASN_LEANANDMEAN
6788   PAssert(IsClass(H245_EndSessionCommand_isdnOptions::Class()), PInvalidCast);
6789 #endif
6790   return new H245_EndSessionCommand_isdnOptions(*this);
6791 }
6792
6793
6794
6795 #ifndef PASN_NOPRINTON
6796 const static PASN_Names Names_H245_MiscellaneousCommand_type[]={
6797       {"equaliseDelay",0}
6798      ,{"zeroDelay",1}
6799      ,{"multipointModeCommand",2}
6800      ,{"cancelMultipointModeCommand",3}
6801      ,{"videoFreezePicture",4}
6802      ,{"videoFastUpdatePicture",5}
6803      ,{"videoFastUpdateGOB",6}
6804      ,{"videoTemporalSpatialTradeOff",7}
6805      ,{"videoSendSyncEveryGOB",8}
6806      ,{"videoSendSyncEveryGOBCancel",9}
6807      ,{"videoFastUpdateMB",10}
6808      ,{"maxH223MUXPDUsize",11}
6809      ,{"encryptionUpdate",12}
6810      ,{"encryptionUpdateRequest",13}
6811      ,{"switchReceiveMediaOff",14}
6812      ,{"switchReceiveMediaOn",15}
6813      ,{"progressiveRefinementStart",16}
6814      ,{"progressiveRefinementAbortOne",17}
6815      ,{"progressiveRefinementAbortContinuous",18}
6816      ,{"videoBadMBs",19}
6817      ,{"lostPicture",20}
6818      ,{"lostPartialPicture",21}
6819      ,{"recoveryReferencePicture",22}
6820      ,{"encryptionUpdateCommand",23}
6821      ,{"encryptionUpdateAck",24}
6822 };
6823 #endif
6824 //
6825 // MiscellaneousCommand_type
6826 //
6827
6828 H245_MiscellaneousCommand_type::H245_MiscellaneousCommand_type(unsigned tag, PASN_Object::TagClass tagClass)
6829   : PASN_Choice(tag, tagClass, 10, TRUE
6830 #ifndef PASN_NOPRINTON
6831     ,(const PASN_Names *)Names_H245_MiscellaneousCommand_type,25
6832 #endif
6833 )
6834 {
6835 }
6836
6837
6838 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
6839 H245_MiscellaneousCommand_type::operator H245_MiscellaneousCommand_type_videoFastUpdateGOB &() const
6840 #else
6841 H245_MiscellaneousCommand_type::operator H245_MiscellaneousCommand_type_videoFastUpdateGOB &()
6842 {
6843 #ifndef PASN_LEANANDMEAN
6844   PAssert(PIsDescendant(PAssertNULL(choice), H245_MiscellaneousCommand_type_videoFastUpdateGOB), PInvalidCast);
6845 #endif
6846   return *(H245_MiscellaneousCommand_type_videoFastUpdateGOB *)choice;
6847 }
6848
6849
6850 H245_MiscellaneousCommand_type::operator const H245_MiscellaneousCommand_type_videoFastUpdateGOB &() const
6851 #endif
6852 {
6853 #ifndef PASN_LEANANDMEAN
6854   PAssert(PIsDescendant(PAssertNULL(choice), H245_MiscellaneousCommand_type_videoFastUpdateGOB), PInvalidCast);
6855 #endif
6856   return *(H245_MiscellaneousCommand_type_videoFastUpdateGOB *)choice;
6857 }
6858
6859
6860 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
6861 H245_MiscellaneousCommand_type::operator H245_MiscellaneousCommand_type_videoFastUpdateMB &() const
6862 #else
6863 H245_MiscellaneousCommand_type::operator H245_MiscellaneousCommand_type_videoFastUpdateMB &()
6864 {
6865 #ifndef PASN_LEANANDMEAN
6866   PAssert(PIsDescendant(PAssertNULL(choice), H245_MiscellaneousCommand_type_videoFastUpdateMB), PInvalidCast);
6867 #endif
6868   return *(H245_MiscellaneousCommand_type_videoFastUpdateMB *)choice;
6869 }
6870
6871
6872 H245_MiscellaneousCommand_type::operator const H245_MiscellaneousCommand_type_videoFastUpdateMB &() const
6873 #endif
6874 {
6875 #ifndef PASN_LEANANDMEAN
6876   PAssert(PIsDescendant(PAssertNULL(choice), H245_MiscellaneousCommand_type_videoFastUpdateMB), PInvalidCast);
6877 #endif
6878   return *(H245_MiscellaneousCommand_type_videoFastUpdateMB *)choice;
6879 }
6880
6881
6882 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
6883 H245_MiscellaneousCommand_type::operator H245_EncryptionSync &() const
6884 #else
6885 H245_MiscellaneousCommand_type::operator H245_EncryptionSync &()
6886 {
6887 #ifndef PASN_LEANANDMEAN
6888   PAssert(PIsDescendant(PAssertNULL(choice), H245_EncryptionSync), PInvalidCast);
6889 #endif
6890   return *(H245_EncryptionSync *)choice;
6891 }
6892
6893
6894 H245_MiscellaneousCommand_type::operator const H245_EncryptionSync &() const
6895 #endif
6896 {
6897 #ifndef PASN_LEANANDMEAN
6898   PAssert(PIsDescendant(PAssertNULL(choice), H245_EncryptionSync), PInvalidCast);
6899 #endif
6900   return *(H245_EncryptionSync *)choice;
6901 }
6902
6903
6904 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
6905 H245_MiscellaneousCommand_type::operator H245_EncryptionUpdateRequest &() const
6906 #else
6907 H245_MiscellaneousCommand_type::operator H245_EncryptionUpdateRequest &()
6908 {
6909 #ifndef PASN_LEANANDMEAN
6910   PAssert(PIsDescendant(PAssertNULL(choice), H245_EncryptionUpdateRequest), PInvalidCast);
6911 #endif
6912   return *(H245_EncryptionUpdateRequest *)choice;
6913 }
6914
6915
6916 H245_MiscellaneousCommand_type::operator const H245_EncryptionUpdateRequest &() const
6917 #endif
6918 {
6919 #ifndef PASN_LEANANDMEAN
6920   PAssert(PIsDescendant(PAssertNULL(choice), H245_EncryptionUpdateRequest), PInvalidCast);
6921 #endif
6922   return *(H245_EncryptionUpdateRequest *)choice;
6923 }
6924
6925
6926 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
6927 H245_MiscellaneousCommand_type::operator H245_MiscellaneousCommand_type_progressiveRefinementStart &() const
6928 #else
6929 H245_MiscellaneousCommand_type::operator H245_MiscellaneousCommand_type_progressiveRefinementStart &()
6930 {
6931 #ifndef PASN_LEANANDMEAN
6932   PAssert(PIsDescendant(PAssertNULL(choice), H245_MiscellaneousCommand_type_progressiveRefinementStart), PInvalidCast);
6933 #endif
6934   return *(H245_MiscellaneousCommand_type_progressiveRefinementStart *)choice;
6935 }
6936
6937
6938 H245_MiscellaneousCommand_type::operator const H245_MiscellaneousCommand_type_progressiveRefinementStart &() const
6939 #endif
6940 {
6941 #ifndef PASN_LEANANDMEAN
6942   PAssert(PIsDescendant(PAssertNULL(choice), H245_MiscellaneousCommand_type_progressiveRefinementStart), PInvalidCast);
6943 #endif
6944   return *(H245_MiscellaneousCommand_type_progressiveRefinementStart *)choice;
6945 }
6946
6947
6948 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
6949 H245_MiscellaneousCommand_type::operator H245_MiscellaneousCommand_type_videoBadMBs &() const
6950 #else
6951 H245_MiscellaneousCommand_type::operator H245_MiscellaneousCommand_type_videoBadMBs &()
6952 {
6953 #ifndef PASN_LEANANDMEAN
6954   PAssert(PIsDescendant(PAssertNULL(choice), H245_MiscellaneousCommand_type_videoBadMBs), PInvalidCast);
6955 #endif
6956   return *(H245_MiscellaneousCommand_type_videoBadMBs *)choice;
6957 }
6958
6959
6960 H245_MiscellaneousCommand_type::operator const H245_MiscellaneousCommand_type_videoBadMBs &() const
6961 #endif
6962 {
6963 #ifndef PASN_LEANANDMEAN
6964   PAssert(PIsDescendant(PAssertNULL(choice), H245_MiscellaneousCommand_type_videoBadMBs), PInvalidCast);
6965 #endif
6966   return *(H245_MiscellaneousCommand_type_videoBadMBs *)choice;
6967 }
6968
6969
6970 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
6971 H245_MiscellaneousCommand_type::operator H245_ArrayOf_PictureReference &() const
6972 #else
6973 H245_MiscellaneousCommand_type::operator H245_ArrayOf_PictureReference &()
6974 {
6975 #ifndef PASN_LEANANDMEAN
6976   PAssert(PIsDescendant(PAssertNULL(choice), H245_ArrayOf_PictureReference), PInvalidCast);
6977 #endif
6978   return *(H245_ArrayOf_PictureReference *)choice;
6979 }
6980
6981
6982 H245_MiscellaneousCommand_type::operator const H245_ArrayOf_PictureReference &() const
6983 #endif
6984 {
6985 #ifndef PASN_LEANANDMEAN
6986   PAssert(PIsDescendant(PAssertNULL(choice), H245_ArrayOf_PictureReference), PInvalidCast);
6987 #endif
6988   return *(H245_ArrayOf_PictureReference *)choice;
6989 }
6990
6991
6992 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
6993 H245_MiscellaneousCommand_type::operator H245_MiscellaneousCommand_type_lostPartialPicture &() const
6994 #else
6995 H245_MiscellaneousCommand_type::operator H245_MiscellaneousCommand_type_lostPartialPicture &()
6996 {
6997 #ifndef PASN_LEANANDMEAN
6998   PAssert(PIsDescendant(PAssertNULL(choice), H245_MiscellaneousCommand_type_lostPartialPicture), PInvalidCast);
6999 #endif
7000   return *(H245_MiscellaneousCommand_type_lostPartialPicture *)choice;
7001 }
7002
7003
7004 H245_MiscellaneousCommand_type::operator const H245_MiscellaneousCommand_type_lostPartialPicture &() const
7005 #endif
7006 {
7007 #ifndef PASN_LEANANDMEAN
7008   PAssert(PIsDescendant(PAssertNULL(choice), H245_MiscellaneousCommand_type_lostPartialPicture), PInvalidCast);
7009 #endif
7010   return *(H245_MiscellaneousCommand_type_lostPartialPicture *)choice;
7011 }
7012
7013
7014 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
7015 H245_MiscellaneousCommand_type::operator H245_MiscellaneousCommand_type_encryptionUpdateCommand &() const
7016 #else
7017 H245_MiscellaneousCommand_type::operator H245_MiscellaneousCommand_type_encryptionUpdateCommand &()
7018 {
7019 #ifndef PASN_LEANANDMEAN
7020   PAssert(PIsDescendant(PAssertNULL(choice), H245_MiscellaneousCommand_type_encryptionUpdateCommand), PInvalidCast);
7021 #endif
7022   return *(H245_MiscellaneousCommand_type_encryptionUpdateCommand *)choice;
7023 }
7024
7025
7026 H245_MiscellaneousCommand_type::operator const H245_MiscellaneousCommand_type_encryptionUpdateCommand &() const
7027 #endif
7028 {
7029 #ifndef PASN_LEANANDMEAN
7030   PAssert(PIsDescendant(PAssertNULL(choice), H245_MiscellaneousCommand_type_encryptionUpdateCommand), PInvalidCast);
7031 #endif
7032   return *(H245_MiscellaneousCommand_type_encryptionUpdateCommand *)choice;
7033 }
7034
7035
7036 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
7037 H245_MiscellaneousCommand_type::operator H245_MiscellaneousCommand_type_encryptionUpdateAck &() const
7038 #else
7039 H245_MiscellaneousCommand_type::operator H245_MiscellaneousCommand_type_encryptionUpdateAck &()
7040 {
7041 #ifndef PASN_LEANANDMEAN
7042   PAssert(PIsDescendant(PAssertNULL(choice), H245_MiscellaneousCommand_type_encryptionUpdateAck), PInvalidCast);
7043 #endif
7044   return *(H245_MiscellaneousCommand_type_encryptionUpdateAck *)choice;
7045 }
7046
7047
7048 H245_MiscellaneousCommand_type::operator const H245_MiscellaneousCommand_type_encryptionUpdateAck &() const
7049 #endif
7050 {
7051 #ifndef PASN_LEANANDMEAN
7052   PAssert(PIsDescendant(PAssertNULL(choice), H245_MiscellaneousCommand_type_encryptionUpdateAck), PInvalidCast);
7053 #endif
7054   return *(H245_MiscellaneousCommand_type_encryptionUpdateAck *)choice;
7055 }
7056
7057
7058 BOOL H245_MiscellaneousCommand_type::CreateObject()
7059 {
7060   switch (tag) {
7061     case e_equaliseDelay :
7062     case e_zeroDelay :
7063     case e_multipointModeCommand :
7064     case e_cancelMultipointModeCommand :
7065     case e_videoFreezePicture :
7066     case e_videoFastUpdatePicture :
7067     case e_videoSendSyncEveryGOB :
7068     case e_videoSendSyncEveryGOBCancel :
7069     case e_switchReceiveMediaOff :
7070     case e_switchReceiveMediaOn :
7071     case e_progressiveRefinementAbortOne :
7072     case e_progressiveRefinementAbortContinuous :
7073       choice = new PASN_Null();
7074       return TRUE;
7075     case e_videoFastUpdateGOB :
7076       choice = new H245_MiscellaneousCommand_type_videoFastUpdateGOB();
7077       return TRUE;
7078     case e_videoTemporalSpatialTradeOff :
7079       choice = new PASN_Integer();
7080       choice->SetConstraints(PASN_Object::FixedConstraint, 0, 31);
7081       return TRUE;
7082     case e_videoFastUpdateMB :
7083       choice = new H245_MiscellaneousCommand_type_videoFastUpdateMB();
7084       return TRUE;
7085     case e_maxH223MUXPDUsize :
7086       choice = new PASN_Integer();
7087       choice->SetConstraints(PASN_Object::FixedConstraint, 1, 65535);
7088       return TRUE;
7089     case e_encryptionUpdate :
7090       choice = new H245_EncryptionSync();
7091       return TRUE;
7092     case e_encryptionUpdateRequest :
7093       choice = new H245_EncryptionUpdateRequest();
7094       return TRUE;
7095     case e_progressiveRefinementStart :
7096       choice = new H245_MiscellaneousCommand_type_progressiveRefinementStart();
7097       return TRUE;
7098     case e_videoBadMBs :
7099       choice = new H245_MiscellaneousCommand_type_videoBadMBs();
7100       return TRUE;
7101     case e_lostPicture :
7102     case e_recoveryReferencePicture :
7103       choice = new H245_ArrayOf_PictureReference();
7104       return TRUE;
7105     case e_lostPartialPicture :
7106       choice = new H245_MiscellaneousCommand_type_lostPartialPicture();
7107       return TRUE;
7108     case e_encryptionUpdateCommand :
7109       choice = new H245_MiscellaneousCommand_type_encryptionUpdateCommand();
7110       return TRUE;
7111     case e_encryptionUpdateAck :
7112       choice = new H245_MiscellaneousCommand_type_encryptionUpdateAck();
7113       return TRUE;
7114   }
7115
7116   choice = NULL;
7117   return FALSE;
7118 }
7119
7120
7121 PObject * H245_MiscellaneousCommand_type::Clone() const
7122 {
7123 #ifndef PASN_LEANANDMEAN
7124   PAssert(IsClass(H245_MiscellaneousCommand_type::Class()), PInvalidCast);
7125 #endif
7126   return new H245_MiscellaneousCommand_type(*this);
7127 }
7128
7129
7130
7131 #ifndef PASN_NOPRINTON
7132 const static PASN_Names Names_H245_H223MultiplexReconfiguration_h223ModeChange[]={
7133       {"toLevel0",0}
7134      ,{"toLevel1",1}
7135      ,{"toLevel2",2}
7136      ,{"toLevel2withOptionalHeader",3}
7137 };
7138 #endif
7139 //
7140 // H223MultiplexReconfiguration_h223ModeChange
7141 //
7142
7143 H245_H223MultiplexReconfiguration_h223ModeChange::H245_H223MultiplexReconfiguration_h223ModeChange(unsigned tag, PASN_Object::TagClass tagClass)
7144   : PASN_Choice(tag, tagClass, 4, TRUE
7145 #ifndef PASN_NOPRINTON
7146     ,(const PASN_Names *)Names_H245_H223MultiplexReconfiguration_h223ModeChange,4
7147 #endif
7148 )
7149 {
7150 }
7151
7152
7153 BOOL H245_H223MultiplexReconfiguration_h223ModeChange::CreateObject()
7154 {
7155   choice = (tag <= e_toLevel2withOptionalHeader) ? new PASN_Null() : NULL;
7156   return choice != NULL;
7157 }
7158
7159
7160 PObject * H245_H223MultiplexReconfiguration_h223ModeChange::Clone() const
7161 {
7162 #ifndef PASN_LEANANDMEAN
7163   PAssert(IsClass(H245_H223MultiplexReconfiguration_h223ModeChange::Class()), PInvalidCast);
7164 #endif
7165   return new H245_H223MultiplexReconfiguration_h223ModeChange(*this);
7166 }
7167
7168
7169
7170 #ifndef PASN_NOPRINTON
7171 const static PASN_Names Names_H245_H223MultiplexReconfiguration_h223AnnexADoubleFlag[]={
7172       {"start",0}
7173      ,{"stop",1}
7174 };
7175 #endif
7176 //
7177 // H223MultiplexReconfiguration_h223AnnexADoubleFlag
7178 //
7179
7180 H245_H223MultiplexReconfiguration_h223AnnexADoubleFlag::H245_H223MultiplexReconfiguration_h223AnnexADoubleFlag(unsigned tag, PASN_Object::TagClass tagClass)
7181   : PASN_Choice(tag, tagClass, 2, TRUE
7182 #ifndef PASN_NOPRINTON
7183     ,(const PASN_Names *)Names_H245_H223MultiplexReconfiguration_h223AnnexADoubleFlag,2
7184 #endif
7185 )
7186 {
7187 }
7188
7189
7190 BOOL H245_H223MultiplexReconfiguration_h223AnnexADoubleFlag::CreateObject()
7191 {
7192   choice = (tag <= e_stop) ? new PASN_Null() : NULL;
7193   return choice != NULL;
7194 }
7195
7196
7197 PObject * H245_H223MultiplexReconfiguration_h223AnnexADoubleFlag::Clone() const
7198 {
7199 #ifndef PASN_LEANANDMEAN
7200   PAssert(IsClass(H245_H223MultiplexReconfiguration_h223AnnexADoubleFlag::Class()), PInvalidCast);
7201 #endif
7202   return new H245_H223MultiplexReconfiguration_h223AnnexADoubleFlag(*this);
7203 }
7204
7205
7206
7207 #ifndef PASN_NOPRINTON
7208 const static PASN_Names Names_H245_NewATMVCCommand_aal[]={
7209       {"aal1",0}
7210      ,{"aal5",1}
7211 };
7212 #endif
7213 //
7214 // NewATMVCCommand_aal
7215 //
7216
7217 H245_NewATMVCCommand_aal::H245_NewATMVCCommand_aal(unsigned tag, PASN_Object::TagClass tagClass)
7218   : PASN_Choice(tag, tagClass, 2, TRUE
7219 #ifndef PASN_NOPRINTON
7220     ,(const PASN_Names *)Names_H245_NewATMVCCommand_aal,2
7221 #endif
7222 )
7223 {
7224 }
7225
7226
7227 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
7228 H245_NewATMVCCommand_aal::operator H245_NewATMVCCommand_aal_aal1 &() const
7229 #else
7230 H245_NewATMVCCommand_aal::operator H245_NewATMVCCommand_aal_aal1 &()
7231 {
7232 #ifndef PASN_LEANANDMEAN
7233   PAssert(PIsDescendant(PAssertNULL(choice), H245_NewATMVCCommand_aal_aal1), PInvalidCast);
7234 #endif
7235   return *(H245_NewATMVCCommand_aal_aal1 *)choice;
7236 }
7237
7238
7239 H245_NewATMVCCommand_aal::operator const H245_NewATMVCCommand_aal_aal1 &() const
7240 #endif
7241 {
7242 #ifndef PASN_LEANANDMEAN
7243   PAssert(PIsDescendant(PAssertNULL(choice), H245_NewATMVCCommand_aal_aal1), PInvalidCast);
7244 #endif
7245   return *(H245_NewATMVCCommand_aal_aal1 *)choice;
7246 }
7247
7248
7249 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
7250 H245_NewATMVCCommand_aal::operator H245_NewATMVCCommand_aal_aal5 &() const
7251 #else
7252 H245_NewATMVCCommand_aal::operator H245_NewATMVCCommand_aal_aal5 &()
7253 {
7254 #ifndef PASN_LEANANDMEAN
7255   PAssert(PIsDescendant(PAssertNULL(choice), H245_NewATMVCCommand_aal_aal5), PInvalidCast);
7256 #endif
7257   return *(H245_NewATMVCCommand_aal_aal5 *)choice;
7258 }
7259
7260
7261 H245_NewATMVCCommand_aal::operator const H245_NewATMVCCommand_aal_aal5 &() const
7262 #endif
7263 {
7264 #ifndef PASN_LEANANDMEAN
7265   PAssert(PIsDescendant(PAssertNULL(choice), H245_NewATMVCCommand_aal_aal5), PInvalidCast);
7266 #endif
7267   return *(H245_NewATMVCCommand_aal_aal5 *)choice;
7268 }
7269
7270
7271 BOOL H245_NewATMVCCommand_aal::CreateObject()
7272 {
7273   switch (tag) {
7274     case e_aal1 :
7275       choice = new H245_NewATMVCCommand_aal_aal1();
7276       return TRUE;
7277     case e_aal5 :
7278       choice = new H245_NewATMVCCommand_aal_aal5();
7279       return TRUE;
7280   }
7281
7282   choice = NULL;
7283   return FALSE;
7284 }
7285
7286
7287 PObject * H245_NewATMVCCommand_aal::Clone() const
7288 {
7289 #ifndef PASN_LEANANDMEAN
7290   PAssert(IsClass(H245_NewATMVCCommand_aal::Class()), PInvalidCast);
7291 #endif
7292   return new H245_NewATMVCCommand_aal(*this);
7293 }
7294
7295
7296
7297 #ifndef PASN_NOPRINTON
7298 const static PASN_Names Names_H245_NewATMVCCommand_multiplex[]={
7299       {"noMultiplex",0}
7300      ,{"transportStream",1}
7301      ,{"programStream",2}
7302 };
7303 #endif
7304 //
7305 // NewATMVCCommand_multiplex
7306 //
7307
7308 H245_NewATMVCCommand_multiplex::H245_NewATMVCCommand_multiplex(unsigned tag, PASN_Object::TagClass tagClass)
7309   : PASN_Choice(tag, tagClass, 3, TRUE
7310 #ifndef PASN_NOPRINTON
7311     ,(const PASN_Names *)Names_H245_NewATMVCCommand_multiplex,3
7312 #endif
7313 )
7314 {
7315 }
7316
7317
7318 BOOL H245_NewATMVCCommand_multiplex::CreateObject()
7319 {
7320   choice = (tag <= e_programStream) ? new PASN_Null() : NULL;
7321   return choice != NULL;
7322 }
7323
7324
7325 PObject * H245_NewATMVCCommand_multiplex::Clone() const
7326 {
7327 #ifndef PASN_LEANANDMEAN
7328   PAssert(IsClass(H245_NewATMVCCommand_multiplex::Class()), PInvalidCast);
7329 #endif
7330   return new H245_NewATMVCCommand_multiplex(*this);
7331 }
7332
7333
7334
7335 #ifndef PASN_NOPRINTON
7336 const static PASN_Names Names_H245_MobileMultilinkReconfigurationCommand_status[]={
7337       {"synchronized",0}
7338      ,{"reconfiguration",1}
7339 };
7340 #endif
7341 //
7342 // MobileMultilinkReconfigurationCommand_status
7343 //
7344
7345 H245_MobileMultilinkReconfigurationCommand_status::H245_MobileMultilinkReconfigurationCommand_status(unsigned tag, PASN_Object::TagClass tagClass)
7346   : PASN_Choice(tag, tagClass, 2, TRUE
7347 #ifndef PASN_NOPRINTON
7348     ,(const PASN_Names *)Names_H245_MobileMultilinkReconfigurationCommand_status,2
7349 #endif
7350 )
7351 {
7352 }
7353
7354
7355 BOOL H245_MobileMultilinkReconfigurationCommand_status::CreateObject()
7356 {
7357   choice = (tag <= e_reconfiguration) ? new PASN_Null() : NULL;
7358   return choice != NULL;
7359 }
7360
7361
7362 PObject * H245_MobileMultilinkReconfigurationCommand_status::Clone() const
7363 {
7364 #ifndef PASN_LEANANDMEAN
7365   PAssert(IsClass(H245_MobileMultilinkReconfigurationCommand_status::Class()), PInvalidCast);
7366 #endif
7367   return new H245_MobileMultilinkReconfigurationCommand_status(*this);
7368 }
7369
7370
7371
7372 #ifndef PASN_NOPRINTON
7373 const static PASN_Names Names_H245_FunctionNotSupported_cause[]={
7374       {"syntaxError",0}
7375      ,{"semanticError",1}
7376      ,{"unknownFunction",2}
7377 };
7378 #endif
7379 //
7380 // FunctionNotSupported_cause
7381 //
7382
7383 H245_FunctionNotSupported_cause::H245_FunctionNotSupported_cause(unsigned tag, PASN_Object::TagClass tagClass)
7384   : PASN_Choice(tag, tagClass, 3, TRUE
7385 #ifndef PASN_NOPRINTON
7386     ,(const PASN_Names *)Names_H245_FunctionNotSupported_cause,3
7387 #endif
7388 )
7389 {
7390 }
7391
7392
7393 BOOL H245_FunctionNotSupported_cause::CreateObject()
7394 {
7395   choice = (tag <= e_unknownFunction) ? new PASN_Null() : NULL;
7396   return choice != NULL;
7397 }
7398
7399
7400 PObject * H245_FunctionNotSupported_cause::Clone() const
7401 {
7402 #ifndef PASN_LEANANDMEAN
7403   PAssert(IsClass(H245_FunctionNotSupported_cause::Class()), PInvalidCast);
7404 #endif
7405   return new H245_FunctionNotSupported_cause(*this);
7406 }
7407
7408
7409
7410 #ifndef PASN_NOPRINTON
7411 const static PASN_Names Names_H245_MiscellaneousIndication_type[]={
7412       {"logicalChannelActive",0}
7413      ,{"logicalChannelInactive",1}
7414      ,{"multipointConference",2}
7415      ,{"cancelMultipointConference",3}
7416      ,{"multipointZeroComm",4}
7417      ,{"cancelMultipointZeroComm",5}
7418      ,{"multipointSecondaryStatus",6}
7419      ,{"cancelMultipointSecondaryStatus",7}
7420      ,{"videoIndicateReadyToActivate",8}
7421      ,{"videoTemporalSpatialTradeOff",9}
7422      ,{"videoNotDecodedMBs",10}
7423      ,{"transportCapability",11}
7424 };
7425 #endif
7426 //
7427 // MiscellaneousIndication_type
7428 //
7429
7430 H245_MiscellaneousIndication_type::H245_MiscellaneousIndication_type(unsigned tag, PASN_Object::TagClass tagClass)
7431   : PASN_Choice(tag, tagClass, 10, TRUE
7432 #ifndef PASN_NOPRINTON
7433     ,(const PASN_Names *)Names_H245_MiscellaneousIndication_type,12
7434 #endif
7435 )
7436 {
7437 }
7438
7439
7440 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
7441 H245_MiscellaneousIndication_type::operator H245_MiscellaneousIndication_type_videoNotDecodedMBs &() const
7442 #else
7443 H245_MiscellaneousIndication_type::operator H245_MiscellaneousIndication_type_videoNotDecodedMBs &()
7444 {
7445 #ifndef PASN_LEANANDMEAN
7446   PAssert(PIsDescendant(PAssertNULL(choice), H245_MiscellaneousIndication_type_videoNotDecodedMBs), PInvalidCast);
7447 #endif
7448   return *(H245_MiscellaneousIndication_type_videoNotDecodedMBs *)choice;
7449 }
7450
7451
7452 H245_MiscellaneousIndication_type::operator const H245_MiscellaneousIndication_type_videoNotDecodedMBs &() const
7453 #endif
7454 {
7455 #ifndef PASN_LEANANDMEAN
7456   PAssert(PIsDescendant(PAssertNULL(choice), H245_MiscellaneousIndication_type_videoNotDecodedMBs), PInvalidCast);
7457 #endif
7458   return *(H245_MiscellaneousIndication_type_videoNotDecodedMBs *)choice;
7459 }
7460
7461
7462 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
7463 H245_MiscellaneousIndication_type::operator H245_TransportCapability &() const
7464 #else
7465 H245_MiscellaneousIndication_type::operator H245_TransportCapability &()
7466 {
7467 #ifndef PASN_LEANANDMEAN
7468   PAssert(PIsDescendant(PAssertNULL(choice), H245_TransportCapability), PInvalidCast);
7469 #endif
7470   return *(H245_TransportCapability *)choice;
7471 }
7472
7473
7474 H245_MiscellaneousIndication_type::operator const H245_TransportCapability &() const
7475 #endif
7476 {
7477 #ifndef PASN_LEANANDMEAN
7478   PAssert(PIsDescendant(PAssertNULL(choice), H245_TransportCapability), PInvalidCast);
7479 #endif
7480   return *(H245_TransportCapability *)choice;
7481 }
7482
7483
7484 BOOL H245_MiscellaneousIndication_type::CreateObject()
7485 {
7486   switch (tag) {
7487     case e_logicalChannelActive :
7488     case e_logicalChannelInactive :
7489     case e_multipointConference :
7490     case e_cancelMultipointConference :
7491     case e_multipointZeroComm :
7492     case e_cancelMultipointZeroComm :
7493     case e_multipointSecondaryStatus :
7494     case e_cancelMultipointSecondaryStatus :
7495     case e_videoIndicateReadyToActivate :
7496       choice = new PASN_Null();
7497       return TRUE;
7498     case e_videoTemporalSpatialTradeOff :
7499       choice = new PASN_Integer();
7500       choice->SetConstraints(PASN_Object::FixedConstraint, 0, 31);
7501       return TRUE;
7502     case e_videoNotDecodedMBs :
7503       choice = new H245_MiscellaneousIndication_type_videoNotDecodedMBs();
7504       return TRUE;
7505     case e_transportCapability :
7506       choice = new H245_TransportCapability();
7507       return TRUE;
7508   }
7509
7510   choice = NULL;
7511   return FALSE;
7512 }
7513
7514
7515 PObject * H245_MiscellaneousIndication_type::Clone() const
7516 {
7517 #ifndef PASN_LEANANDMEAN
7518   PAssert(IsClass(H245_MiscellaneousIndication_type::Class()), PInvalidCast);
7519 #endif
7520   return new H245_MiscellaneousIndication_type(*this);
7521 }
7522
7523
7524
7525 #ifndef PASN_NOPRINTON
7526 const static PASN_Names Names_H245_JitterIndication_scope[]={
7527       {"logicalChannelNumber",0}
7528      ,{"resourceID",1}
7529      ,{"wholeMultiplex",2}
7530 };
7531 #endif
7532 //
7533 // JitterIndication_scope
7534 //
7535
7536 H245_JitterIndication_scope::H245_JitterIndication_scope(unsigned tag, PASN_Object::TagClass tagClass)
7537   : PASN_Choice(tag, tagClass, 3, FALSE
7538 #ifndef PASN_NOPRINTON
7539     ,(const PASN_Names *)Names_H245_JitterIndication_scope,3
7540 #endif
7541 )
7542 {
7543 }
7544
7545
7546 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
7547 H245_JitterIndication_scope::operator H245_LogicalChannelNumber &() const
7548 #else
7549 H245_JitterIndication_scope::operator H245_LogicalChannelNumber &()
7550 {
7551 #ifndef PASN_LEANANDMEAN
7552   PAssert(PIsDescendant(PAssertNULL(choice), H245_LogicalChannelNumber), PInvalidCast);
7553 #endif
7554   return *(H245_LogicalChannelNumber *)choice;
7555 }
7556
7557
7558 H245_JitterIndication_scope::operator const H245_LogicalChannelNumber &() const
7559 #endif
7560 {
7561 #ifndef PASN_LEANANDMEAN
7562   PAssert(PIsDescendant(PAssertNULL(choice), H245_LogicalChannelNumber), PInvalidCast);
7563 #endif
7564   return *(H245_LogicalChannelNumber *)choice;
7565 }
7566
7567
7568 BOOL H245_JitterIndication_scope::CreateObject()
7569 {
7570   switch (tag) {
7571     case e_logicalChannelNumber :
7572       choice = new H245_LogicalChannelNumber();
7573       return TRUE;
7574     case e_resourceID :
7575       choice = new PASN_Integer();
7576       choice->SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
7577       return TRUE;
7578     case e_wholeMultiplex :
7579       choice = new PASN_Null();
7580       return TRUE;
7581   }
7582
7583   choice = NULL;
7584   return FALSE;
7585 }
7586
7587
7588 PObject * H245_JitterIndication_scope::Clone() const
7589 {
7590 #ifndef PASN_LEANANDMEAN
7591   PAssert(IsClass(H245_JitterIndication_scope::Class()), PInvalidCast);
7592 #endif
7593   return new H245_JitterIndication_scope(*this);
7594 }
7595
7596
7597
7598 #ifndef PASN_NOPRINTON
7599 const static PASN_Names Names_H245_NewATMVCIndication_aal[]={
7600       {"aal1",0}
7601      ,{"aal5",1}
7602 };
7603 #endif
7604 //
7605 // NewATMVCIndication_aal
7606 //
7607
7608 H245_NewATMVCIndication_aal::H245_NewATMVCIndication_aal(unsigned tag, PASN_Object::TagClass tagClass)
7609   : PASN_Choice(tag, tagClass, 2, TRUE
7610 #ifndef PASN_NOPRINTON
7611     ,(const PASN_Names *)Names_H245_NewATMVCIndication_aal,2
7612 #endif
7613 )
7614 {
7615 }
7616
7617
7618 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
7619 H245_NewATMVCIndication_aal::operator H245_NewATMVCIndication_aal_aal1 &() const
7620 #else
7621 H245_NewATMVCIndication_aal::operator H245_NewATMVCIndication_aal_aal1 &()
7622 {
7623 #ifndef PASN_LEANANDMEAN
7624   PAssert(PIsDescendant(PAssertNULL(choice), H245_NewATMVCIndication_aal_aal1), PInvalidCast);
7625 #endif
7626   return *(H245_NewATMVCIndication_aal_aal1 *)choice;
7627 }
7628
7629
7630 H245_NewATMVCIndication_aal::operator const H245_NewATMVCIndication_aal_aal1 &() const
7631 #endif
7632 {
7633 #ifndef PASN_LEANANDMEAN
7634   PAssert(PIsDescendant(PAssertNULL(choice), H245_NewATMVCIndication_aal_aal1), PInvalidCast);
7635 #endif
7636   return *(H245_NewATMVCIndication_aal_aal1 *)choice;
7637 }
7638
7639
7640 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
7641 H245_NewATMVCIndication_aal::operator H245_NewATMVCIndication_aal_aal5 &() const
7642 #else
7643 H245_NewATMVCIndication_aal::operator H245_NewATMVCIndication_aal_aal5 &()
7644 {
7645 #ifndef PASN_LEANANDMEAN
7646   PAssert(PIsDescendant(PAssertNULL(choice), H245_NewATMVCIndication_aal_aal5), PInvalidCast);
7647 #endif
7648   return *(H245_NewATMVCIndication_aal_aal5 *)choice;
7649 }
7650
7651
7652 H245_NewATMVCIndication_aal::operator const H245_NewATMVCIndication_aal_aal5 &() const
7653 #endif
7654 {
7655 #ifndef PASN_LEANANDMEAN
7656   PAssert(PIsDescendant(PAssertNULL(choice), H245_NewATMVCIndication_aal_aal5), PInvalidCast);
7657 #endif
7658   return *(H245_NewATMVCIndication_aal_aal5 *)choice;
7659 }
7660
7661
7662 BOOL H245_NewATMVCIndication_aal::CreateObject()
7663 {
7664   switch (tag) {
7665     case e_aal1 :
7666       choice = new H245_NewATMVCIndication_aal_aal1();
7667       return TRUE;
7668     case e_aal5 :
7669       choice = new H245_NewATMVCIndication_aal_aal5();
7670       return TRUE;
7671   }
7672
7673   choice = NULL;
7674   return FALSE;
7675 }
7676
7677
7678 PObject * H245_NewATMVCIndication_aal::Clone() const
7679 {
7680 #ifndef PASN_LEANANDMEAN
7681   PAssert(IsClass(H245_NewATMVCIndication_aal::Class()), PInvalidCast);
7682 #endif
7683   return new H245_NewATMVCIndication_aal(*this);
7684 }
7685
7686
7687
7688 #ifndef PASN_NOPRINTON
7689 const static PASN_Names Names_H245_NewATMVCIndication_multiplex[]={
7690       {"noMultiplex",0}
7691      ,{"transportStream",1}
7692      ,{"programStream",2}
7693 };
7694 #endif
7695 //
7696 // NewATMVCIndication_multiplex
7697 //
7698
7699 H245_NewATMVCIndication_multiplex::H245_NewATMVCIndication_multiplex(unsigned tag, PASN_Object::TagClass tagClass)
7700   : PASN_Choice(tag, tagClass, 3, TRUE
7701 #ifndef PASN_NOPRINTON
7702     ,(const PASN_Names *)Names_H245_NewATMVCIndication_multiplex,3
7703 #endif
7704 )
7705 {
7706 }
7707
7708
7709 BOOL H245_NewATMVCIndication_multiplex::CreateObject()
7710 {
7711   choice = (tag <= e_programStream) ? new PASN_Null() : NULL;
7712   return choice != NULL;
7713 }
7714
7715
7716 PObject * H245_NewATMVCIndication_multiplex::Clone() const
7717 {
7718 #ifndef PASN_LEANANDMEAN
7719   PAssert(IsClass(H245_NewATMVCIndication_multiplex::Class()), PInvalidCast);
7720 #endif
7721   return new H245_NewATMVCIndication_multiplex(*this);
7722 }
7723
7724
7725
7726 #ifndef PASN_NOPRINTON
7727 const static PASN_Names Names_H245_UserInputIndication_userInputSupportIndication[]={
7728       {"nonStandard",0}
7729      ,{"basicString",1}
7730      ,{"iA5String",2}
7731      ,{"generalString",3}
7732      ,{"encryptedBasicString",4}
7733      ,{"encryptedIA5String",5}
7734      ,{"encryptedGeneralString",6}
7735 };
7736 #endif
7737 //
7738 // UserInputIndication_userInputSupportIndication
7739 //
7740
7741 H245_UserInputIndication_userInputSupportIndication::H245_UserInputIndication_userInputSupportIndication(unsigned tag, PASN_Object::TagClass tagClass)
7742   : PASN_Choice(tag, tagClass, 4, TRUE
7743 #ifndef PASN_NOPRINTON
7744     ,(const PASN_Names *)Names_H245_UserInputIndication_userInputSupportIndication,7
7745 #endif
7746 )
7747 {
7748 }
7749
7750
7751 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
7752 H245_UserInputIndication_userInputSupportIndication::operator H245_NonStandardParameter &() const
7753 #else
7754 H245_UserInputIndication_userInputSupportIndication::operator H245_NonStandardParameter &()
7755 {
7756 #ifndef PASN_LEANANDMEAN
7757   PAssert(PIsDescendant(PAssertNULL(choice), H245_NonStandardParameter), PInvalidCast);
7758 #endif
7759   return *(H245_NonStandardParameter *)choice;
7760 }
7761
7762
7763 H245_UserInputIndication_userInputSupportIndication::operator const H245_NonStandardParameter &() const
7764 #endif
7765 {
7766 #ifndef PASN_LEANANDMEAN
7767   PAssert(PIsDescendant(PAssertNULL(choice), H245_NonStandardParameter), PInvalidCast);
7768 #endif
7769   return *(H245_NonStandardParameter *)choice;
7770 }
7771
7772
7773 BOOL H245_UserInputIndication_userInputSupportIndication::CreateObject()
7774 {
7775   switch (tag) {
7776     case e_nonStandard :
7777       choice = new H245_NonStandardParameter();
7778       return TRUE;
7779     case e_basicString :
7780     case e_iA5String :
7781     case e_generalString :
7782     case e_encryptedBasicString :
7783     case e_encryptedIA5String :
7784     case e_encryptedGeneralString :
7785       choice = new PASN_Null();
7786       return TRUE;
7787   }
7788
7789   choice = NULL;
7790   return FALSE;
7791 }
7792
7793
7794 PObject * H245_UserInputIndication_userInputSupportIndication::Clone() const
7795 {
7796 #ifndef PASN_LEANANDMEAN
7797   PAssert(IsClass(H245_UserInputIndication_userInputSupportIndication::Class()), PInvalidCast);
7798 #endif
7799   return new H245_UserInputIndication_userInputSupportIndication(*this);
7800 }
7801
7802
7803 //
7804 // UserInputIndication_encryptedAlphanumeric
7805 //
7806
7807 H245_UserInputIndication_encryptedAlphanumeric::H245_UserInputIndication_encryptedAlphanumeric(unsigned tag, PASN_Object::TagClass tagClass)
7808   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
7809 {
7810 }
7811
7812
7813 #ifndef PASN_NOPRINTON
7814 void H245_UserInputIndication_encryptedAlphanumeric::PrintOn(ostream & strm) const
7815 {
7816   int indent = strm.precision() + 2;
7817   strm << "{\n";
7818   strm << setw(indent+15) << "algorithmOID = " << setprecision(indent) << m_algorithmOID << '\n';
7819   if (HasOptionalField(e_paramS))
7820     strm << setw(indent+9) << "paramS = " << setprecision(indent) << m_paramS << '\n';
7821   strm << setw(indent+12) << "encrypted = " << setprecision(indent) << m_encrypted << '\n';
7822   strm << setw(indent-1) << setprecision(indent-2) << "}";
7823 }
7824 #endif
7825
7826
7827 PObject::Comparison H245_UserInputIndication_encryptedAlphanumeric::Compare(const PObject & obj) const
7828 {
7829 #ifndef PASN_LEANANDMEAN
7830   PAssert(PIsDescendant(&obj, H245_UserInputIndication_encryptedAlphanumeric), PInvalidCast);
7831 #endif
7832   const H245_UserInputIndication_encryptedAlphanumeric & other = (const H245_UserInputIndication_encryptedAlphanumeric &)obj;
7833
7834   Comparison result;
7835
7836   if ((result = m_algorithmOID.Compare(other.m_algorithmOID)) != EqualTo)
7837     return result;
7838   if ((result = m_paramS.Compare(other.m_paramS)) != EqualTo)
7839     return result;
7840   if ((result = m_encrypted.Compare(other.m_encrypted)) != EqualTo)
7841     return result;
7842
7843   return PASN_Sequence::Compare(other);
7844 }
7845
7846
7847 PINDEX H245_UserInputIndication_encryptedAlphanumeric::GetDataLength() const
7848 {
7849   PINDEX length = 0;
7850   length += m_algorithmOID.GetObjectLength();
7851   if (HasOptionalField(e_paramS))
7852     length += m_paramS.GetObjectLength();
7853   length += m_encrypted.GetObjectLength();
7854   return length;
7855 }
7856
7857
7858 BOOL H245_UserInputIndication_encryptedAlphanumeric::Decode(PASN_Stream & strm)
7859 {
7860   if (!PreambleDecode(strm))
7861     return FALSE;
7862
7863   if (!m_algorithmOID.Decode(strm))
7864     return FALSE;
7865   if (HasOptionalField(e_paramS) && !m_paramS.Decode(strm))
7866     return FALSE;
7867   if (!m_encrypted.Decode(strm))
7868     return FALSE;
7869
7870   return UnknownExtensionsDecode(strm);
7871 }
7872
7873
7874 void H245_UserInputIndication_encryptedAlphanumeric::Encode(PASN_Stream & strm) const
7875 {
7876   PreambleEncode(strm);
7877
7878   m_algorithmOID.Encode(strm);
7879   if (HasOptionalField(e_paramS))
7880     m_paramS.Encode(strm);
7881   m_encrypted.Encode(strm);
7882
7883   UnknownExtensionsEncode(strm);
7884 }
7885
7886
7887 PObject * H245_UserInputIndication_encryptedAlphanumeric::Clone() const
7888 {
7889 #ifndef PASN_LEANANDMEAN
7890   PAssert(IsClass(H245_UserInputIndication_encryptedAlphanumeric::Class()), PInvalidCast);
7891 #endif
7892   return new H245_UserInputIndication_encryptedAlphanumeric(*this);
7893 }
7894
7895
7896
7897 #ifndef PASN_NOPRINTON
7898 const static PASN_Names Names_H245_FlowControlIndication_scope[]={
7899       {"logicalChannelNumber",0}
7900      ,{"resourceID",1}
7901      ,{"wholeMultiplex",2}
7902 };
7903 #endif
7904 //
7905 // FlowControlIndication_scope
7906 //
7907
7908 H245_FlowControlIndication_scope::H245_FlowControlIndication_scope(unsigned tag, PASN_Object::TagClass tagClass)
7909   : PASN_Choice(tag, tagClass, 3, FALSE
7910 #ifndef PASN_NOPRINTON
7911     ,(const PASN_Names *)Names_H245_FlowControlIndication_scope,3
7912 #endif
7913 )
7914 {
7915 }
7916
7917
7918 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
7919 H245_FlowControlIndication_scope::operator H245_LogicalChannelNumber &() const
7920 #else
7921 H245_FlowControlIndication_scope::operator H245_LogicalChannelNumber &()
7922 {
7923 #ifndef PASN_LEANANDMEAN
7924   PAssert(PIsDescendant(PAssertNULL(choice), H245_LogicalChannelNumber), PInvalidCast);
7925 #endif
7926   return *(H245_LogicalChannelNumber *)choice;
7927 }
7928
7929
7930 H245_FlowControlIndication_scope::operator const H245_LogicalChannelNumber &() const
7931 #endif
7932 {
7933 #ifndef PASN_LEANANDMEAN
7934   PAssert(PIsDescendant(PAssertNULL(choice), H245_LogicalChannelNumber), PInvalidCast);
7935 #endif
7936   return *(H245_LogicalChannelNumber *)choice;
7937 }
7938
7939
7940 BOOL H245_FlowControlIndication_scope::CreateObject()
7941 {
7942   switch (tag) {
7943     case e_logicalChannelNumber :
7944       choice = new H245_LogicalChannelNumber();
7945       return TRUE;
7946     case e_resourceID :
7947       choice = new PASN_Integer();
7948       choice->SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
7949       return TRUE;
7950     case e_wholeMultiplex :
7951       choice = new PASN_Null();
7952       return TRUE;
7953   }
7954
7955   choice = NULL;
7956   return FALSE;
7957 }
7958
7959
7960 PObject * H245_FlowControlIndication_scope::Clone() const
7961 {
7962 #ifndef PASN_LEANANDMEAN
7963   PAssert(IsClass(H245_FlowControlIndication_scope::Class()), PInvalidCast);
7964 #endif
7965   return new H245_FlowControlIndication_scope(*this);
7966 }
7967
7968
7969
7970 #ifndef PASN_NOPRINTON
7971 const static PASN_Names Names_H245_FlowControlIndication_restriction[]={
7972       {"maximumBitRate",0}
7973      ,{"noRestriction",1}
7974 };
7975 #endif
7976 //
7977 // FlowControlIndication_restriction
7978 //
7979
7980 H245_FlowControlIndication_restriction::H245_FlowControlIndication_restriction(unsigned tag, PASN_Object::TagClass tagClass)
7981   : PASN_Choice(tag, tagClass, 2, FALSE
7982 #ifndef PASN_NOPRINTON
7983     ,(const PASN_Names *)Names_H245_FlowControlIndication_restriction,2
7984 #endif
7985 )
7986 {
7987 }
7988
7989
7990 BOOL H245_FlowControlIndication_restriction::CreateObject()
7991 {
7992   switch (tag) {
7993     case e_maximumBitRate :
7994       choice = new PASN_Integer();
7995       choice->SetConstraints(PASN_Object::FixedConstraint, 0, 16777215);
7996       return TRUE;
7997     case e_noRestriction :
7998       choice = new PASN_Null();
7999       return TRUE;
8000   }
8001
8002   choice = NULL;
8003   return FALSE;
8004 }
8005
8006
8007 PObject * H245_FlowControlIndication_restriction::Clone() const
8008 {
8009 #ifndef PASN_LEANANDMEAN
8010   PAssert(IsClass(H245_FlowControlIndication_restriction::Class()), PInvalidCast);
8011 #endif
8012   return new H245_FlowControlIndication_restriction(*this);
8013 }
8014
8015
8016
8017 #ifndef PASN_NOPRINTON
8018 const static PASN_Names Names_H245_TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded[]={
8019       {"highestEntryNumberProcessed",0}
8020      ,{"noneProcessed",1}
8021 };
8022 #endif
8023 //
8024 // TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded
8025 //
8026
8027 H245_TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded::H245_TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded(unsigned tag, PASN_Object::TagClass tagClass)
8028   : PASN_Choice(tag, tagClass, 2, FALSE
8029 #ifndef PASN_NOPRINTON
8030     ,(const PASN_Names *)Names_H245_TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded,2
8031 #endif
8032 )
8033 {
8034 }
8035
8036
8037 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
8038 H245_TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded::operator H245_CapabilityTableEntryNumber &() const
8039 #else
8040 H245_TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded::operator H245_CapabilityTableEntryNumber &()
8041 {
8042 #ifndef PASN_LEANANDMEAN
8043   PAssert(PIsDescendant(PAssertNULL(choice), H245_CapabilityTableEntryNumber), PInvalidCast);
8044 #endif
8045   return *(H245_CapabilityTableEntryNumber *)choice;
8046 }
8047
8048
8049 H245_TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded::operator const H245_CapabilityTableEntryNumber &() const
8050 #endif
8051 {
8052 #ifndef PASN_LEANANDMEAN
8053   PAssert(PIsDescendant(PAssertNULL(choice), H245_CapabilityTableEntryNumber), PInvalidCast);
8054 #endif
8055   return *(H245_CapabilityTableEntryNumber *)choice;
8056 }
8057
8058
8059 BOOL H245_TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded::CreateObject()
8060 {
8061   switch (tag) {
8062     case e_highestEntryNumberProcessed :
8063       choice = new H245_CapabilityTableEntryNumber();
8064       return TRUE;
8065     case e_noneProcessed :
8066       choice = new PASN_Null();
8067       return TRUE;
8068   }
8069
8070   choice = NULL;
8071   return FALSE;
8072 }
8073
8074
8075 PObject * H245_TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded::Clone() const
8076 {
8077 #ifndef PASN_LEANANDMEAN
8078   PAssert(IsClass(H245_TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded::Class()), PInvalidCast);
8079 #endif
8080   return new H245_TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded(*this);
8081 }
8082
8083
8084
8085 #ifndef PASN_NOPRINTON
8086 const static PASN_Names Names_H245_VCCapability_availableBitRates_type[]={
8087       {"singleBitRate",0}
8088      ,{"rangeOfBitRates",1}
8089 };
8090 #endif
8091 //
8092 // VCCapability_availableBitRates_type
8093 //
8094
8095 H245_VCCapability_availableBitRates_type::H245_VCCapability_availableBitRates_type(unsigned tag, PASN_Object::TagClass tagClass)
8096   : PASN_Choice(tag, tagClass, 2, FALSE
8097 #ifndef PASN_NOPRINTON
8098     ,(const PASN_Names *)Names_H245_VCCapability_availableBitRates_type,2
8099 #endif
8100 )
8101 {
8102 }
8103
8104
8105 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
8106 H245_VCCapability_availableBitRates_type::operator H245_VCCapability_availableBitRates_type_rangeOfBitRates &() const
8107 #else
8108 H245_VCCapability_availableBitRates_type::operator H245_VCCapability_availableBitRates_type_rangeOfBitRates &()
8109 {
8110 #ifndef PASN_LEANANDMEAN
8111   PAssert(PIsDescendant(PAssertNULL(choice), H245_VCCapability_availableBitRates_type_rangeOfBitRates), PInvalidCast);
8112 #endif
8113   return *(H245_VCCapability_availableBitRates_type_rangeOfBitRates *)choice;
8114 }
8115
8116
8117 H245_VCCapability_availableBitRates_type::operator const H245_VCCapability_availableBitRates_type_rangeOfBitRates &() const
8118 #endif
8119 {
8120 #ifndef PASN_LEANANDMEAN
8121   PAssert(PIsDescendant(PAssertNULL(choice), H245_VCCapability_availableBitRates_type_rangeOfBitRates), PInvalidCast);
8122 #endif
8123   return *(H245_VCCapability_availableBitRates_type_rangeOfBitRates *)choice;
8124 }
8125
8126
8127 BOOL H245_VCCapability_availableBitRates_type::CreateObject()
8128 {
8129   switch (tag) {
8130     case e_singleBitRate :
8131       choice = new PASN_Integer();
8132       choice->SetConstraints(PASN_Object::FixedConstraint, 1, 65535);
8133       return TRUE;
8134     case e_rangeOfBitRates :
8135       choice = new H245_VCCapability_availableBitRates_type_rangeOfBitRates();
8136       return TRUE;
8137   }
8138
8139   choice = NULL;
8140   return FALSE;
8141 }
8142
8143
8144 PObject * H245_VCCapability_availableBitRates_type::Clone() const
8145 {
8146 #ifndef PASN_LEANANDMEAN
8147   PAssert(IsClass(H245_VCCapability_availableBitRates_type::Class()), PInvalidCast);
8148 #endif
8149   return new H245_VCCapability_availableBitRates_type(*this);
8150 }
8151
8152
8153 //
8154 // ArrayOf_Q2931Address
8155 //
8156
8157 H245_ArrayOf_Q2931Address::H245_ArrayOf_Q2931Address(unsigned tag, PASN_Object::TagClass tagClass)
8158   : PASN_Array(tag, tagClass)
8159 {
8160 }
8161
8162
8163 PASN_Object * H245_ArrayOf_Q2931Address::CreateObject() const
8164 {
8165   return new H245_Q2931Address;
8166 }
8167
8168
8169 H245_Q2931Address & H245_ArrayOf_Q2931Address::operator[](PINDEX i) const
8170 {
8171   return (H245_Q2931Address &)array[i];
8172 }
8173
8174
8175 PObject * H245_ArrayOf_Q2931Address::Clone() const
8176 {
8177 #ifndef PASN_LEANANDMEAN
8178   PAssert(IsClass(H245_ArrayOf_Q2931Address::Class()), PInvalidCast);
8179 #endif
8180   return new H245_ArrayOf_Q2931Address(*this);
8181 }
8182
8183
8184 //
8185 // H223Capability_h223MultiplexTableCapability_enhanced
8186 //
8187
8188 H245_H223Capability_h223MultiplexTableCapability_enhanced::H245_H223Capability_h223MultiplexTableCapability_enhanced(unsigned tag, PASN_Object::TagClass tagClass)
8189   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
8190 {
8191   m_maximumNestingDepth.SetConstraints(PASN_Object::FixedConstraint, 1, 15);
8192   m_maximumElementListSize.SetConstraints(PASN_Object::FixedConstraint, 2, 255);
8193   m_maximumSubElementListSize.SetConstraints(PASN_Object::FixedConstraint, 2, 255);
8194 }
8195
8196
8197 #ifndef PASN_NOPRINTON
8198 void H245_H223Capability_h223MultiplexTableCapability_enhanced::PrintOn(ostream & strm) const
8199 {
8200   int indent = strm.precision() + 2;
8201   strm << "{\n";
8202   strm << setw(indent+22) << "maximumNestingDepth = " << setprecision(indent) << m_maximumNestingDepth << '\n';
8203   strm << setw(indent+25) << "maximumElementListSize = " << setprecision(indent) << m_maximumElementListSize << '\n';
8204   strm << setw(indent+28) << "maximumSubElementListSize = " << setprecision(indent) << m_maximumSubElementListSize << '\n';
8205   strm << setw(indent-1) << setprecision(indent-2) << "}";
8206 }
8207 #endif
8208
8209
8210 PObject::Comparison H245_H223Capability_h223MultiplexTableCapability_enhanced::Compare(const PObject & obj) const
8211 {
8212 #ifndef PASN_LEANANDMEAN
8213   PAssert(PIsDescendant(&obj, H245_H223Capability_h223MultiplexTableCapability_enhanced), PInvalidCast);
8214 #endif
8215   const H245_H223Capability_h223MultiplexTableCapability_enhanced & other = (const H245_H223Capability_h223MultiplexTableCapability_enhanced &)obj;
8216
8217   Comparison result;
8218
8219   if ((result = m_maximumNestingDepth.Compare(other.m_maximumNestingDepth)) != EqualTo)
8220     return result;
8221   if ((result = m_maximumElementListSize.Compare(other.m_maximumElementListSize)) != EqualTo)
8222     return result;
8223   if ((result = m_maximumSubElementListSize.Compare(other.m_maximumSubElementListSize)) != EqualTo)
8224     return result;
8225
8226   return PASN_Sequence::Compare(other);
8227 }
8228
8229
8230 PINDEX H245_H223Capability_h223MultiplexTableCapability_enhanced::GetDataLength() const
8231 {
8232   PINDEX length = 0;
8233   length += m_maximumNestingDepth.GetObjectLength();
8234   length += m_maximumElementListSize.GetObjectLength();
8235   length += m_maximumSubElementListSize.GetObjectLength();
8236   return length;
8237 }
8238
8239
8240 BOOL H245_H223Capability_h223MultiplexTableCapability_enhanced::Decode(PASN_Stream & strm)
8241 {
8242   if (!PreambleDecode(strm))
8243     return FALSE;
8244
8245   if (!m_maximumNestingDepth.Decode(strm))
8246     return FALSE;
8247   if (!m_maximumElementListSize.Decode(strm))
8248     return FALSE;
8249   if (!m_maximumSubElementListSize.Decode(strm))
8250     return FALSE;
8251
8252   return UnknownExtensionsDecode(strm);
8253 }
8254
8255
8256 void H245_H223Capability_h223MultiplexTableCapability_enhanced::Encode(PASN_Stream & strm) const
8257 {
8258   PreambleEncode(strm);
8259
8260   m_maximumNestingDepth.Encode(strm);
8261   m_maximumElementListSize.Encode(strm);
8262   m_maximumSubElementListSize.Encode(strm);
8263
8264   UnknownExtensionsEncode(strm);
8265 }
8266
8267
8268 PObject * H245_H223Capability_h223MultiplexTableCapability_enhanced::Clone() const
8269 {
8270 #ifndef PASN_LEANANDMEAN
8271   PAssert(IsClass(H245_H223Capability_h223MultiplexTableCapability_enhanced::Class()), PInvalidCast);
8272 #endif
8273   return new H245_H223Capability_h223MultiplexTableCapability_enhanced(*this);
8274 }
8275
8276
8277 //
8278 // ArrayOf_RTPH263VideoRedundancyFrameMapping
8279 //
8280
8281 H245_ArrayOf_RTPH263VideoRedundancyFrameMapping::H245_ArrayOf_RTPH263VideoRedundancyFrameMapping(unsigned tag, PASN_Object::TagClass tagClass)
8282   : PASN_Array(tag, tagClass)
8283 {
8284 }
8285
8286
8287 PASN_Object * H245_ArrayOf_RTPH263VideoRedundancyFrameMapping::CreateObject() const
8288 {
8289   return new H245_RTPH263VideoRedundancyFrameMapping;
8290 }
8291
8292
8293 H245_RTPH263VideoRedundancyFrameMapping & H245_ArrayOf_RTPH263VideoRedundancyFrameMapping::operator[](PINDEX i) const
8294 {
8295   return (H245_RTPH263VideoRedundancyFrameMapping &)array[i];
8296 }
8297
8298
8299 PObject * H245_ArrayOf_RTPH263VideoRedundancyFrameMapping::Clone() const
8300 {
8301 #ifndef PASN_LEANANDMEAN
8302   PAssert(IsClass(H245_ArrayOf_RTPH263VideoRedundancyFrameMapping::Class()), PInvalidCast);
8303 #endif
8304   return new H245_ArrayOf_RTPH263VideoRedundancyFrameMapping(*this);
8305 }
8306
8307
8308 //
8309 // RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters
8310 //
8311
8312 H245_RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters::H245_RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters(unsigned tag, PASN_Object::TagClass tagClass)
8313   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
8314 {
8315   m_mpuHorizMBs.SetConstraints(PASN_Object::FixedConstraint, 1, 128);
8316   m_mpuVertMBs.SetConstraints(PASN_Object::FixedConstraint, 1, 72);
8317   m_mpuTotalNumber.SetConstraints(PASN_Object::FixedConstraint, 1, 65536);
8318 }
8319
8320
8321 #ifndef PASN_NOPRINTON
8322 void H245_RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters::PrintOn(ostream & strm) const
8323 {
8324   int indent = strm.precision() + 2;
8325   strm << "{\n";
8326   strm << setw(indent+14) << "mpuHorizMBs = " << setprecision(indent) << m_mpuHorizMBs << '\n';
8327   strm << setw(indent+13) << "mpuVertMBs = " << setprecision(indent) << m_mpuVertMBs << '\n';
8328   strm << setw(indent+17) << "mpuTotalNumber = " << setprecision(indent) << m_mpuTotalNumber << '\n';
8329   strm << setw(indent-1) << setprecision(indent-2) << "}";
8330 }
8331 #endif
8332
8333
8334 PObject::Comparison H245_RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters::Compare(const PObject & obj) const
8335 {
8336 #ifndef PASN_LEANANDMEAN
8337   PAssert(PIsDescendant(&obj, H245_RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters), PInvalidCast);
8338 #endif
8339   const H245_RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters & other = (const H245_RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters &)obj;
8340
8341   Comparison result;
8342
8343   if ((result = m_mpuHorizMBs.Compare(other.m_mpuHorizMBs)) != EqualTo)
8344     return result;
8345   if ((result = m_mpuVertMBs.Compare(other.m_mpuVertMBs)) != EqualTo)
8346     return result;
8347   if ((result = m_mpuTotalNumber.Compare(other.m_mpuTotalNumber)) != EqualTo)
8348     return result;
8349
8350   return PASN_Sequence::Compare(other);
8351 }
8352
8353
8354 PINDEX H245_RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters::GetDataLength() const
8355 {
8356   PINDEX length = 0;
8357   length += m_mpuHorizMBs.GetObjectLength();
8358   length += m_mpuVertMBs.GetObjectLength();
8359   length += m_mpuTotalNumber.GetObjectLength();
8360   return length;
8361 }
8362
8363
8364 BOOL H245_RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters::Decode(PASN_Stream & strm)
8365 {
8366   if (!PreambleDecode(strm))
8367     return FALSE;
8368
8369   if (!m_mpuHorizMBs.Decode(strm))
8370     return FALSE;
8371   if (!m_mpuVertMBs.Decode(strm))
8372     return FALSE;
8373   if (!m_mpuTotalNumber.Decode(strm))
8374     return FALSE;
8375
8376   return UnknownExtensionsDecode(strm);
8377 }
8378
8379
8380 void H245_RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters::Encode(PASN_Stream & strm) const
8381 {
8382   PreambleEncode(strm);
8383
8384   m_mpuHorizMBs.Encode(strm);
8385   m_mpuVertMBs.Encode(strm);
8386   m_mpuTotalNumber.Encode(strm);
8387
8388   UnknownExtensionsEncode(strm);
8389 }
8390
8391
8392 PObject * H245_RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters::Clone() const
8393 {
8394 #ifndef PASN_LEANANDMEAN
8395   PAssert(IsClass(H245_RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters::Class()), PInvalidCast);
8396 #endif
8397   return new H245_RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters(*this);
8398 }
8399
8400
8401 //
8402 // CustomPictureFormat_mPI_customPCF
8403 //
8404
8405 H245_CustomPictureFormat_mPI_customPCF::H245_CustomPictureFormat_mPI_customPCF(unsigned tag, PASN_Object::TagClass tagClass)
8406   : PASN_Array(tag, tagClass)
8407 {
8408   SetConstraints(PASN_Object::FixedConstraint, 1, 16);
8409 }
8410
8411
8412 PASN_Object * H245_CustomPictureFormat_mPI_customPCF::CreateObject() const
8413 {
8414   return new H245_CustomPictureFormat_mPI_customPCF_subtype;
8415 }
8416
8417
8418 H245_CustomPictureFormat_mPI_customPCF_subtype & H245_CustomPictureFormat_mPI_customPCF::operator[](PINDEX i) const
8419 {
8420   return (H245_CustomPictureFormat_mPI_customPCF_subtype &)array[i];
8421 }
8422
8423
8424 PObject * H245_CustomPictureFormat_mPI_customPCF::Clone() const
8425 {
8426 #ifndef PASN_LEANANDMEAN
8427   PAssert(IsClass(H245_CustomPictureFormat_mPI_customPCF::Class()), PInvalidCast);
8428 #endif
8429   return new H245_CustomPictureFormat_mPI_customPCF(*this);
8430 }
8431
8432
8433 //
8434 // CustomPictureFormat_pixelAspectInformation_pixelAspectCode
8435 //
8436
8437 H245_CustomPictureFormat_pixelAspectInformation_pixelAspectCode::H245_CustomPictureFormat_pixelAspectInformation_pixelAspectCode(unsigned tag, PASN_Object::TagClass tagClass)
8438   : PASN_Array(tag, tagClass)
8439 {
8440   SetConstraints(PASN_Object::FixedConstraint, 1, 14);
8441 }
8442
8443
8444 PASN_Object * H245_CustomPictureFormat_pixelAspectInformation_pixelAspectCode::CreateObject() const
8445 {
8446   PASN_Integer * obj = new PASN_Integer;
8447   obj->SetConstraints(PASN_Object::FixedConstraint, 1, 14);
8448   return obj;
8449 }
8450
8451
8452 PASN_Integer & H245_CustomPictureFormat_pixelAspectInformation_pixelAspectCode::operator[](PINDEX i) const
8453 {
8454   return (PASN_Integer &)array[i];
8455 }
8456
8457
8458 PObject * H245_CustomPictureFormat_pixelAspectInformation_pixelAspectCode::Clone() const
8459 {
8460 #ifndef PASN_LEANANDMEAN
8461   PAssert(IsClass(H245_CustomPictureFormat_pixelAspectInformation_pixelAspectCode::Class()), PInvalidCast);
8462 #endif
8463   return new H245_CustomPictureFormat_pixelAspectInformation_pixelAspectCode(*this);
8464 }
8465
8466
8467 //
8468 // CustomPictureFormat_pixelAspectInformation_extendedPAR
8469 //
8470
8471 H245_CustomPictureFormat_pixelAspectInformation_extendedPAR::H245_CustomPictureFormat_pixelAspectInformation_extendedPAR(unsigned tag, PASN_Object::TagClass tagClass)
8472   : PASN_Array(tag, tagClass)
8473 {
8474   SetConstraints(PASN_Object::FixedConstraint, 1, 256);
8475 }
8476
8477
8478 PASN_Object * H245_CustomPictureFormat_pixelAspectInformation_extendedPAR::CreateObject() const
8479 {
8480   return new H245_CustomPictureFormat_pixelAspectInformation_extendedPAR_subtype;
8481 }
8482
8483
8484 H245_CustomPictureFormat_pixelAspectInformation_extendedPAR_subtype & H245_CustomPictureFormat_pixelAspectInformation_extendedPAR::operator[](PINDEX i) const
8485 {
8486   return (H245_CustomPictureFormat_pixelAspectInformation_extendedPAR_subtype &)array[i];
8487 }
8488
8489
8490 PObject * H245_CustomPictureFormat_pixelAspectInformation_extendedPAR::Clone() const
8491 {
8492 #ifndef PASN_LEANANDMEAN
8493   PAssert(IsClass(H245_CustomPictureFormat_pixelAspectInformation_extendedPAR::Class()), PInvalidCast);
8494 #endif
8495   return new H245_CustomPictureFormat_pixelAspectInformation_extendedPAR(*this);
8496 }
8497
8498
8499 //
8500 // DataApplicationCapability_application_t84
8501 //
8502
8503 H245_DataApplicationCapability_application_t84::H245_DataApplicationCapability_application_t84(unsigned tag, PASN_Object::TagClass tagClass)
8504   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
8505 {
8506 }
8507
8508
8509 #ifndef PASN_NOPRINTON
8510 void H245_DataApplicationCapability_application_t84::PrintOn(ostream & strm) const
8511 {
8512   int indent = strm.precision() + 2;
8513   strm << "{\n";
8514   strm << setw(indent+14) << "t84Protocol = " << setprecision(indent) << m_t84Protocol << '\n';
8515   strm << setw(indent+13) << "t84Profile = " << setprecision(indent) << m_t84Profile << '\n';
8516   strm << setw(indent-1) << setprecision(indent-2) << "}";
8517 }
8518 #endif
8519
8520
8521 PObject::Comparison H245_DataApplicationCapability_application_t84::Compare(const PObject & obj) const
8522 {
8523 #ifndef PASN_LEANANDMEAN
8524   PAssert(PIsDescendant(&obj, H245_DataApplicationCapability_application_t84), PInvalidCast);
8525 #endif
8526   const H245_DataApplicationCapability_application_t84 & other = (const H245_DataApplicationCapability_application_t84 &)obj;
8527
8528   Comparison result;
8529
8530   if ((result = m_t84Protocol.Compare(other.m_t84Protocol)) != EqualTo)
8531     return result;
8532   if ((result = m_t84Profile.Compare(other.m_t84Profile)) != EqualTo)
8533     return result;
8534
8535   return PASN_Sequence::Compare(other);
8536 }
8537
8538
8539 PINDEX H245_DataApplicationCapability_application_t84::GetDataLength() const
8540 {
8541   PINDEX length = 0;
8542   length += m_t84Protocol.GetObjectLength();
8543   length += m_t84Profile.GetObjectLength();
8544   return length;
8545 }
8546
8547
8548 BOOL H245_DataApplicationCapability_application_t84::Decode(PASN_Stream & strm)
8549 {
8550   if (!PreambleDecode(strm))
8551     return FALSE;
8552
8553   if (!m_t84Protocol.Decode(strm))
8554     return FALSE;
8555   if (!m_t84Profile.Decode(strm))
8556     return FALSE;
8557
8558   return UnknownExtensionsDecode(strm);
8559 }
8560
8561
8562 void H245_DataApplicationCapability_application_t84::Encode(PASN_Stream & strm) const
8563 {
8564   PreambleEncode(strm);
8565
8566   m_t84Protocol.Encode(strm);
8567   m_t84Profile.Encode(strm);
8568
8569   UnknownExtensionsEncode(strm);
8570 }
8571
8572
8573 PObject * H245_DataApplicationCapability_application_t84::Clone() const
8574 {
8575 #ifndef PASN_LEANANDMEAN
8576   PAssert(IsClass(H245_DataApplicationCapability_application_t84::Class()), PInvalidCast);
8577 #endif
8578   return new H245_DataApplicationCapability_application_t84(*this);
8579 }
8580
8581
8582 //
8583 // DataApplicationCapability_application_nlpid
8584 //
8585
8586 H245_DataApplicationCapability_application_nlpid::H245_DataApplicationCapability_application_nlpid(unsigned tag, PASN_Object::TagClass tagClass)
8587   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
8588 {
8589 }
8590
8591
8592 #ifndef PASN_NOPRINTON
8593 void H245_DataApplicationCapability_application_nlpid::PrintOn(ostream & strm) const
8594 {
8595   int indent = strm.precision() + 2;
8596   strm << "{\n";
8597   strm << setw(indent+16) << "nlpidProtocol = " << setprecision(indent) << m_nlpidProtocol << '\n';
8598   strm << setw(indent+12) << "nlpidData = " << setprecision(indent) << m_nlpidData << '\n';
8599   strm << setw(indent-1) << setprecision(indent-2) << "}";
8600 }
8601 #endif
8602
8603
8604 PObject::Comparison H245_DataApplicationCapability_application_nlpid::Compare(const PObject & obj) const
8605 {
8606 #ifndef PASN_LEANANDMEAN
8607   PAssert(PIsDescendant(&obj, H245_DataApplicationCapability_application_nlpid), PInvalidCast);
8608 #endif
8609   const H245_DataApplicationCapability_application_nlpid & other = (const H245_DataApplicationCapability_application_nlpid &)obj;
8610
8611   Comparison result;
8612
8613   if ((result = m_nlpidProtocol.Compare(other.m_nlpidProtocol)) != EqualTo)
8614     return result;
8615   if ((result = m_nlpidData.Compare(other.m_nlpidData)) != EqualTo)
8616     return result;
8617
8618   return PASN_Sequence::Compare(other);
8619 }
8620
8621
8622 PINDEX H245_DataApplicationCapability_application_nlpid::GetDataLength() const
8623 {
8624   PINDEX length = 0;
8625   length += m_nlpidProtocol.GetObjectLength();
8626   length += m_nlpidData.GetObjectLength();
8627   return length;
8628 }
8629
8630
8631 BOOL H245_DataApplicationCapability_application_nlpid::Decode(PASN_Stream & strm)
8632 {
8633   if (!PreambleDecode(strm))
8634     return FALSE;
8635
8636   if (!m_nlpidProtocol.Decode(strm))
8637     return FALSE;
8638   if (!m_nlpidData.Decode(strm))
8639     return FALSE;
8640
8641   return UnknownExtensionsDecode(strm);
8642 }
8643
8644
8645 void H245_DataApplicationCapability_application_nlpid::Encode(PASN_Stream & strm) const
8646 {
8647   PreambleEncode(strm);
8648
8649   m_nlpidProtocol.Encode(strm);
8650   m_nlpidData.Encode(strm);
8651
8652   UnknownExtensionsEncode(strm);
8653 }
8654
8655
8656 PObject * H245_DataApplicationCapability_application_nlpid::Clone() const
8657 {
8658 #ifndef PASN_LEANANDMEAN
8659   PAssert(IsClass(H245_DataApplicationCapability_application_nlpid::Class()), PInvalidCast);
8660 #endif
8661   return new H245_DataApplicationCapability_application_nlpid(*this);
8662 }
8663
8664
8665 //
8666 // DepFECCapability_rfc2733_separateStream
8667 //
8668
8669 H245_DepFECCapability_rfc2733_separateStream::H245_DepFECCapability_rfc2733_separateStream(unsigned tag, PASN_Object::TagClass tagClass)
8670   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
8671 {
8672 }
8673
8674
8675 #ifndef PASN_NOPRINTON
8676 void H245_DepFECCapability_rfc2733_separateStream::PrintOn(ostream & strm) const
8677 {
8678   int indent = strm.precision() + 2;
8679   strm << "{\n";
8680   strm << setw(indent+15) << "separatePort = " << setprecision(indent) << m_separatePort << '\n';
8681   strm << setw(indent+11) << "samePort = " << setprecision(indent) << m_samePort << '\n';
8682   strm << setw(indent-1) << setprecision(indent-2) << "}";
8683 }
8684 #endif
8685
8686
8687 PObject::Comparison H245_DepFECCapability_rfc2733_separateStream::Compare(const PObject & obj) const
8688 {
8689 #ifndef PASN_LEANANDMEAN
8690   PAssert(PIsDescendant(&obj, H245_DepFECCapability_rfc2733_separateStream), PInvalidCast);
8691 #endif
8692   const H245_DepFECCapability_rfc2733_separateStream & other = (const H245_DepFECCapability_rfc2733_separateStream &)obj;
8693
8694   Comparison result;
8695
8696   if ((result = m_separatePort.Compare(other.m_separatePort)) != EqualTo)
8697     return result;
8698   if ((result = m_samePort.Compare(other.m_samePort)) != EqualTo)
8699     return result;
8700
8701   return PASN_Sequence::Compare(other);
8702 }
8703
8704
8705 PINDEX H245_DepFECCapability_rfc2733_separateStream::GetDataLength() const
8706 {
8707   PINDEX length = 0;
8708   length += m_separatePort.GetObjectLength();
8709   length += m_samePort.GetObjectLength();
8710   return length;
8711 }
8712
8713
8714 BOOL H245_DepFECCapability_rfc2733_separateStream::Decode(PASN_Stream & strm)
8715 {
8716   if (!PreambleDecode(strm))
8717     return FALSE;
8718
8719   if (!m_separatePort.Decode(strm))
8720     return FALSE;
8721   if (!m_samePort.Decode(strm))
8722     return FALSE;
8723
8724   return UnknownExtensionsDecode(strm);
8725 }
8726
8727
8728 void H245_DepFECCapability_rfc2733_separateStream::Encode(PASN_Stream & strm) const
8729 {
8730   PreambleEncode(strm);
8731
8732   m_separatePort.Encode(strm);
8733   m_samePort.Encode(strm);
8734
8735   UnknownExtensionsEncode(strm);
8736 }
8737
8738
8739 PObject * H245_DepFECCapability_rfc2733_separateStream::Clone() const
8740 {
8741 #ifndef PASN_LEANANDMEAN
8742   PAssert(IsClass(H245_DepFECCapability_rfc2733_separateStream::Class()), PInvalidCast);
8743 #endif
8744   return new H245_DepFECCapability_rfc2733_separateStream(*this);
8745 }
8746
8747
8748
8749 #ifndef PASN_NOPRINTON
8750 const static PASN_Names Names_H245_OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters[]={
8751       {"h222LogicalChannelParameters",0}
8752      ,{"h223LogicalChannelParameters",1}
8753      ,{"v76LogicalChannelParameters",2}
8754      ,{"h2250LogicalChannelParameters",3}
8755      ,{"none",4}
8756 };
8757 #endif
8758 //
8759 // OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters
8760 //
8761
8762 H245_OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters::H245_OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters(unsigned tag, PASN_Object::TagClass tagClass)
8763   : PASN_Choice(tag, tagClass, 3, TRUE
8764 #ifndef PASN_NOPRINTON
8765     ,(const PASN_Names *)Names_H245_OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters,5
8766 #endif
8767 )
8768 {
8769 }
8770
8771
8772 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
8773 H245_OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters::operator H245_H222LogicalChannelParameters &() const
8774 #else
8775 H245_OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters::operator H245_H222LogicalChannelParameters &()
8776 {
8777 #ifndef PASN_LEANANDMEAN
8778   PAssert(PIsDescendant(PAssertNULL(choice), H245_H222LogicalChannelParameters), PInvalidCast);
8779 #endif
8780   return *(H245_H222LogicalChannelParameters *)choice;
8781 }
8782
8783
8784 H245_OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters::operator const H245_H222LogicalChannelParameters &() const
8785 #endif
8786 {
8787 #ifndef PASN_LEANANDMEAN
8788   PAssert(PIsDescendant(PAssertNULL(choice), H245_H222LogicalChannelParameters), PInvalidCast);
8789 #endif
8790   return *(H245_H222LogicalChannelParameters *)choice;
8791 }
8792
8793
8794 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
8795 H245_OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters::operator H245_H223LogicalChannelParameters &() const
8796 #else
8797 H245_OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters::operator H245_H223LogicalChannelParameters &()
8798 {
8799 #ifndef PASN_LEANANDMEAN
8800   PAssert(PIsDescendant(PAssertNULL(choice), H245_H223LogicalChannelParameters), PInvalidCast);
8801 #endif
8802   return *(H245_H223LogicalChannelParameters *)choice;
8803 }
8804
8805
8806 H245_OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters::operator const H245_H223LogicalChannelParameters &() const
8807 #endif
8808 {
8809 #ifndef PASN_LEANANDMEAN
8810   PAssert(PIsDescendant(PAssertNULL(choice), H245_H223LogicalChannelParameters), PInvalidCast);
8811 #endif
8812   return *(H245_H223LogicalChannelParameters *)choice;
8813 }
8814
8815
8816 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
8817 H245_OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters::operator H245_V76LogicalChannelParameters &() const
8818 #else
8819 H245_OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters::operator H245_V76LogicalChannelParameters &()
8820 {
8821 #ifndef PASN_LEANANDMEAN
8822   PAssert(PIsDescendant(PAssertNULL(choice), H245_V76LogicalChannelParameters), PInvalidCast);
8823 #endif
8824   return *(H245_V76LogicalChannelParameters *)choice;
8825 }
8826
8827
8828 H245_OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters::operator const H245_V76LogicalChannelParameters &() const
8829 #endif
8830 {
8831 #ifndef PASN_LEANANDMEAN
8832   PAssert(PIsDescendant(PAssertNULL(choice), H245_V76LogicalChannelParameters), PInvalidCast);
8833 #endif
8834   return *(H245_V76LogicalChannelParameters *)choice;
8835 }
8836
8837
8838 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
8839 H245_OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters::operator H245_H2250LogicalChannelParameters &() const
8840 #else
8841 H245_OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters::operator H245_H2250LogicalChannelParameters &()
8842 {
8843 #ifndef PASN_LEANANDMEAN
8844   PAssert(PIsDescendant(PAssertNULL(choice), H245_H2250LogicalChannelParameters), PInvalidCast);
8845 #endif
8846   return *(H245_H2250LogicalChannelParameters *)choice;
8847 }
8848
8849
8850 H245_OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters::operator const H245_H2250LogicalChannelParameters &() const
8851 #endif
8852 {
8853 #ifndef PASN_LEANANDMEAN
8854   PAssert(PIsDescendant(PAssertNULL(choice), H245_H2250LogicalChannelParameters), PInvalidCast);
8855 #endif
8856   return *(H245_H2250LogicalChannelParameters *)choice;
8857 }
8858
8859
8860 BOOL H245_OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters::CreateObject()
8861 {
8862   switch (tag) {
8863     case e_h222LogicalChannelParameters :
8864       choice = new H245_H222LogicalChannelParameters();
8865       return TRUE;
8866     case e_h223LogicalChannelParameters :
8867       choice = new H245_H223LogicalChannelParameters();
8868       return TRUE;
8869     case e_v76LogicalChannelParameters :
8870       choice = new H245_V76LogicalChannelParameters();
8871       return TRUE;
8872     case e_h2250LogicalChannelParameters :
8873       choice = new H245_H2250LogicalChannelParameters();
8874       return TRUE;
8875     case e_none :
8876       choice = new PASN_Null();
8877       return TRUE;
8878   }
8879
8880   choice = NULL;
8881   return FALSE;
8882 }
8883
8884
8885 PObject * H245_OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters::Clone() const
8886 {
8887 #ifndef PASN_LEANANDMEAN
8888   PAssert(IsClass(H245_OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters::Class()), PInvalidCast);
8889 #endif
8890   return new H245_OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters(*this);
8891 }
8892
8893
8894
8895 #ifndef PASN_NOPRINTON
8896 const static PASN_Names Names_H245_OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters[]={
8897       {"h223LogicalChannelParameters",0}
8898      ,{"v76LogicalChannelParameters",1}
8899      ,{"h2250LogicalChannelParameters",2}
8900 };
8901 #endif
8902 //
8903 // OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters
8904 //
8905
8906 H245_OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters::H245_OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters(unsigned tag, PASN_Object::TagClass tagClass)
8907   : PASN_Choice(tag, tagClass, 2, TRUE
8908 #ifndef PASN_NOPRINTON
8909     ,(const PASN_Names *)Names_H245_OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters,3
8910 #endif
8911 )
8912 {
8913 }
8914
8915
8916 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
8917 H245_OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters::operator H245_H223LogicalChannelParameters &() const
8918 #else
8919 H245_OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters::operator H245_H223LogicalChannelParameters &()
8920 {
8921 #ifndef PASN_LEANANDMEAN
8922   PAssert(PIsDescendant(PAssertNULL(choice), H245_H223LogicalChannelParameters), PInvalidCast);
8923 #endif
8924   return *(H245_H223LogicalChannelParameters *)choice;
8925 }
8926
8927
8928 H245_OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters::operator const H245_H223LogicalChannelParameters &() const
8929 #endif
8930 {
8931 #ifndef PASN_LEANANDMEAN
8932   PAssert(PIsDescendant(PAssertNULL(choice), H245_H223LogicalChannelParameters), PInvalidCast);
8933 #endif
8934   return *(H245_H223LogicalChannelParameters *)choice;
8935 }
8936
8937
8938 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
8939 H245_OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters::operator H245_V76LogicalChannelParameters &() const
8940 #else
8941 H245_OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters::operator H245_V76LogicalChannelParameters &()
8942 {
8943 #ifndef PASN_LEANANDMEAN
8944   PAssert(PIsDescendant(PAssertNULL(choice), H245_V76LogicalChannelParameters), PInvalidCast);
8945 #endif
8946   return *(H245_V76LogicalChannelParameters *)choice;
8947 }
8948
8949
8950 H245_OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters::operator const H245_V76LogicalChannelParameters &() const
8951 #endif
8952 {
8953 #ifndef PASN_LEANANDMEAN
8954   PAssert(PIsDescendant(PAssertNULL(choice), H245_V76LogicalChannelParameters), PInvalidCast);
8955 #endif
8956   return *(H245_V76LogicalChannelParameters *)choice;
8957 }
8958
8959
8960 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
8961 H245_OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters::operator H245_H2250LogicalChannelParameters &() const
8962 #else
8963 H245_OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters::operator H245_H2250LogicalChannelParameters &()
8964 {
8965 #ifndef PASN_LEANANDMEAN
8966   PAssert(PIsDescendant(PAssertNULL(choice), H245_H2250LogicalChannelParameters), PInvalidCast);
8967 #endif
8968   return *(H245_H2250LogicalChannelParameters *)choice;
8969 }
8970
8971
8972 H245_OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters::operator const H245_H2250LogicalChannelParameters &() const
8973 #endif
8974 {
8975 #ifndef PASN_LEANANDMEAN
8976   PAssert(PIsDescendant(PAssertNULL(choice), H245_H2250LogicalChannelParameters), PInvalidCast);
8977 #endif
8978   return *(H245_H2250LogicalChannelParameters *)choice;
8979 }
8980
8981
8982 BOOL H245_OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters::CreateObject()
8983 {
8984   switch (tag) {
8985     case e_h223LogicalChannelParameters :
8986       choice = new H245_H223LogicalChannelParameters();
8987       return TRUE;
8988     case e_v76LogicalChannelParameters :
8989       choice = new H245_V76LogicalChannelParameters();
8990       return TRUE;
8991     case e_h2250LogicalChannelParameters :
8992       choice = new H245_H2250LogicalChannelParameters();
8993       return TRUE;
8994   }
8995
8996   choice = NULL;
8997   return FALSE;
8998 }
8999
9000
9001 PObject * H245_OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters::Clone() const
9002 {
9003 #ifndef PASN_LEANANDMEAN
9004   PAssert(IsClass(H245_OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters::Class()), PInvalidCast);
9005 #endif
9006   return new H245_OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters(*this);
9007 }
9008
9009
9010 //
9011 // H223LogicalChannelParameters_adaptationLayerType_al3
9012 //
9013
9014 H245_H223LogicalChannelParameters_adaptationLayerType_al3::H245_H223LogicalChannelParameters_adaptationLayerType_al3(unsigned tag, PASN_Object::TagClass tagClass)
9015   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
9016 {
9017   m_controlFieldOctets.SetConstraints(PASN_Object::FixedConstraint, 0, 2);
9018   m_sendBufferSize.SetConstraints(PASN_Object::FixedConstraint, 0, 16777215);
9019 }
9020
9021
9022 #ifndef PASN_NOPRINTON
9023 void H245_H223LogicalChannelParameters_adaptationLayerType_al3::PrintOn(ostream & strm) const
9024 {
9025   int indent = strm.precision() + 2;
9026   strm << "{\n";
9027   strm << setw(indent+21) << "controlFieldOctets = " << setprecision(indent) << m_controlFieldOctets << '\n';
9028   strm << setw(indent+17) << "sendBufferSize = " << setprecision(indent) << m_sendBufferSize << '\n';
9029   strm << setw(indent-1) << setprecision(indent-2) << "}";
9030 }
9031 #endif
9032
9033
9034 PObject::Comparison H245_H223LogicalChannelParameters_adaptationLayerType_al3::Compare(const PObject & obj) const
9035 {
9036 #ifndef PASN_LEANANDMEAN
9037   PAssert(PIsDescendant(&obj, H245_H223LogicalChannelParameters_adaptationLayerType_al3), PInvalidCast);
9038 #endif
9039   const H245_H223LogicalChannelParameters_adaptationLayerType_al3 & other = (const H245_H223LogicalChannelParameters_adaptationLayerType_al3 &)obj;
9040
9041   Comparison result;
9042
9043   if ((result = m_controlFieldOctets.Compare(other.m_controlFieldOctets)) != EqualTo)
9044     return result;
9045   if ((result = m_sendBufferSize.Compare(other.m_sendBufferSize)) != EqualTo)
9046     return result;
9047
9048   return PASN_Sequence::Compare(other);
9049 }
9050
9051
9052 PINDEX H245_H223LogicalChannelParameters_adaptationLayerType_al3::GetDataLength() const
9053 {
9054   PINDEX length = 0;
9055   length += m_controlFieldOctets.GetObjectLength();
9056   length += m_sendBufferSize.GetObjectLength();
9057   return length;
9058 }
9059
9060
9061 BOOL H245_H223LogicalChannelParameters_adaptationLayerType_al3::Decode(PASN_Stream & strm)
9062 {
9063   if (!PreambleDecode(strm))
9064     return FALSE;
9065
9066   if (!m_controlFieldOctets.Decode(strm))
9067     return FALSE;
9068   if (!m_sendBufferSize.Decode(strm))
9069     return FALSE;
9070
9071   return UnknownExtensionsDecode(strm);
9072 }
9073
9074
9075 void H245_H223LogicalChannelParameters_adaptationLayerType_al3::Encode(PASN_Stream & strm) const
9076 {
9077   PreambleEncode(strm);
9078
9079   m_controlFieldOctets.Encode(strm);
9080   m_sendBufferSize.Encode(strm);
9081
9082   UnknownExtensionsEncode(strm);
9083 }
9084
9085
9086 PObject * H245_H223LogicalChannelParameters_adaptationLayerType_al3::Clone() const
9087 {
9088 #ifndef PASN_LEANANDMEAN
9089   PAssert(IsClass(H245_H223LogicalChannelParameters_adaptationLayerType_al3::Class()), PInvalidCast);
9090 #endif
9091   return new H245_H223LogicalChannelParameters_adaptationLayerType_al3(*this);
9092 }
9093
9094
9095 //
9096 // ArrayOf_RedundancyEncodingElement
9097 //
9098
9099 H245_ArrayOf_RedundancyEncodingElement::H245_ArrayOf_RedundancyEncodingElement(unsigned tag, PASN_Object::TagClass tagClass)
9100   : PASN_Array(tag, tagClass)
9101 {
9102 }
9103
9104
9105 PASN_Object * H245_ArrayOf_RedundancyEncodingElement::CreateObject() const
9106 {
9107   return new H245_RedundancyEncodingElement;
9108 }
9109
9110
9111 H245_RedundancyEncodingElement & H245_ArrayOf_RedundancyEncodingElement::operator[](PINDEX i) const
9112 {
9113   return (H245_RedundancyEncodingElement &)array[i];
9114 }
9115
9116
9117 PObject * H245_ArrayOf_RedundancyEncodingElement::Clone() const
9118 {
9119 #ifndef PASN_LEANANDMEAN
9120   PAssert(IsClass(H245_ArrayOf_RedundancyEncodingElement::Class()), PInvalidCast);
9121 #endif
9122   return new H245_ArrayOf_RedundancyEncodingElement(*this);
9123 }
9124
9125
9126
9127 #ifndef PASN_NOPRINTON
9128 const static PASN_Names Names_H245_DepFECData_rfc2733_mode[]={
9129       {"redundancyEncoding",0}
9130      ,{"separateStream",1}
9131 };
9132 #endif
9133 //
9134 // DepFECData_rfc2733_mode
9135 //
9136
9137 H245_DepFECData_rfc2733_mode::H245_DepFECData_rfc2733_mode(unsigned tag, PASN_Object::TagClass tagClass)
9138   : PASN_Choice(tag, tagClass, 2, TRUE
9139 #ifndef PASN_NOPRINTON
9140     ,(const PASN_Names *)Names_H245_DepFECData_rfc2733_mode,2
9141 #endif
9142 )
9143 {
9144 }
9145
9146
9147 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
9148 H245_DepFECData_rfc2733_mode::operator H245_DepFECData_rfc2733_mode_separateStream &() const
9149 #else
9150 H245_DepFECData_rfc2733_mode::operator H245_DepFECData_rfc2733_mode_separateStream &()
9151 {
9152 #ifndef PASN_LEANANDMEAN
9153   PAssert(PIsDescendant(PAssertNULL(choice), H245_DepFECData_rfc2733_mode_separateStream), PInvalidCast);
9154 #endif
9155   return *(H245_DepFECData_rfc2733_mode_separateStream *)choice;
9156 }
9157
9158
9159 H245_DepFECData_rfc2733_mode::operator const H245_DepFECData_rfc2733_mode_separateStream &() const
9160 #endif
9161 {
9162 #ifndef PASN_LEANANDMEAN
9163   PAssert(PIsDescendant(PAssertNULL(choice), H245_DepFECData_rfc2733_mode_separateStream), PInvalidCast);
9164 #endif
9165   return *(H245_DepFECData_rfc2733_mode_separateStream *)choice;
9166 }
9167
9168
9169 BOOL H245_DepFECData_rfc2733_mode::CreateObject()
9170 {
9171   switch (tag) {
9172     case e_redundancyEncoding :
9173       choice = new PASN_Null();
9174       return TRUE;
9175     case e_separateStream :
9176       choice = new H245_DepFECData_rfc2733_mode_separateStream();
9177       return TRUE;
9178   }
9179
9180   choice = NULL;
9181   return FALSE;
9182 }
9183
9184
9185 PObject * H245_DepFECData_rfc2733_mode::Clone() const
9186 {
9187 #ifndef PASN_LEANANDMEAN
9188   PAssert(IsClass(H245_DepFECData_rfc2733_mode::Class()), PInvalidCast);
9189 #endif
9190   return new H245_DepFECData_rfc2733_mode(*this);
9191 }
9192
9193
9194
9195 #ifndef PASN_NOPRINTON
9196 const static PASN_Names Names_H245_FECData_rfc2733_pktMode[]={
9197       {"rfc2198coding",0}
9198      ,{"rfc2733sameport",1}
9199      ,{"rfc2733diffport",2}
9200 };
9201 #endif
9202 //
9203 // FECData_rfc2733_pktMode
9204 //
9205
9206 H245_FECData_rfc2733_pktMode::H245_FECData_rfc2733_pktMode(unsigned tag, PASN_Object::TagClass tagClass)
9207   : PASN_Choice(tag, tagClass, 3, TRUE
9208 #ifndef PASN_NOPRINTON
9209     ,(const PASN_Names *)Names_H245_FECData_rfc2733_pktMode,3
9210 #endif
9211 )
9212 {
9213 }
9214
9215
9216 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
9217 H245_FECData_rfc2733_pktMode::operator H245_FECData_rfc2733_pktMode_rfc2733sameport &() const
9218 #else
9219 H245_FECData_rfc2733_pktMode::operator H245_FECData_rfc2733_pktMode_rfc2733sameport &()
9220 {
9221 #ifndef PASN_LEANANDMEAN
9222   PAssert(PIsDescendant(PAssertNULL(choice), H245_FECData_rfc2733_pktMode_rfc2733sameport), PInvalidCast);
9223 #endif
9224   return *(H245_FECData_rfc2733_pktMode_rfc2733sameport *)choice;
9225 }
9226
9227
9228 H245_FECData_rfc2733_pktMode::operator const H245_FECData_rfc2733_pktMode_rfc2733sameport &() const
9229 #endif
9230 {
9231 #ifndef PASN_LEANANDMEAN
9232   PAssert(PIsDescendant(PAssertNULL(choice), H245_FECData_rfc2733_pktMode_rfc2733sameport), PInvalidCast);
9233 #endif
9234   return *(H245_FECData_rfc2733_pktMode_rfc2733sameport *)choice;
9235 }
9236
9237
9238 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
9239 H245_FECData_rfc2733_pktMode::operator H245_FECData_rfc2733_pktMode_rfc2733diffport &() const
9240 #else
9241 H245_FECData_rfc2733_pktMode::operator H245_FECData_rfc2733_pktMode_rfc2733diffport &()
9242 {
9243 #ifndef PASN_LEANANDMEAN
9244   PAssert(PIsDescendant(PAssertNULL(choice), H245_FECData_rfc2733_pktMode_rfc2733diffport), PInvalidCast);
9245 #endif
9246   return *(H245_FECData_rfc2733_pktMode_rfc2733diffport *)choice;
9247 }
9248
9249
9250 H245_FECData_rfc2733_pktMode::operator const H245_FECData_rfc2733_pktMode_rfc2733diffport &() const
9251 #endif
9252 {
9253 #ifndef PASN_LEANANDMEAN
9254   PAssert(PIsDescendant(PAssertNULL(choice), H245_FECData_rfc2733_pktMode_rfc2733diffport), PInvalidCast);
9255 #endif
9256   return *(H245_FECData_rfc2733_pktMode_rfc2733diffport *)choice;
9257 }
9258
9259
9260 BOOL H245_FECData_rfc2733_pktMode::CreateObject()
9261 {
9262   switch (tag) {
9263     case e_rfc2198coding :
9264       choice = new PASN_Null();
9265       return TRUE;
9266     case e_rfc2733sameport :
9267       choice = new H245_FECData_rfc2733_pktMode_rfc2733sameport();
9268       return TRUE;
9269     case e_rfc2733diffport :
9270       choice = new H245_FECData_rfc2733_pktMode_rfc2733diffport();
9271       return TRUE;
9272   }
9273
9274   choice = NULL;
9275   return FALSE;
9276 }
9277
9278
9279 PObject * H245_FECData_rfc2733_pktMode::Clone() const
9280 {
9281 #ifndef PASN_LEANANDMEAN
9282   PAssert(IsClass(H245_FECData_rfc2733_pktMode::Class()), PInvalidCast);
9283 #endif
9284   return new H245_FECData_rfc2733_pktMode(*this);
9285 }
9286
9287
9288
9289 #ifndef PASN_NOPRINTON
9290 const static PASN_Names Names_H245_UnicastAddress_iPSourceRouteAddress_routing[]={
9291       {"strict",0}
9292      ,{"loose",1}
9293 };
9294 #endif
9295 //
9296 // UnicastAddress_iPSourceRouteAddress_routing
9297 //
9298
9299 H245_UnicastAddress_iPSourceRouteAddress_routing::H245_UnicastAddress_iPSourceRouteAddress_routing(unsigned tag, PASN_Object::TagClass tagClass)
9300   : PASN_Choice(tag, tagClass, 2, FALSE
9301 #ifndef PASN_NOPRINTON
9302     ,(const PASN_Names *)Names_H245_UnicastAddress_iPSourceRouteAddress_routing,2
9303 #endif
9304 )
9305 {
9306 }
9307
9308
9309 BOOL H245_UnicastAddress_iPSourceRouteAddress_routing::CreateObject()
9310 {
9311   choice = (tag <= e_loose) ? new PASN_Null() : NULL;
9312   return choice != NULL;
9313 }
9314
9315
9316 PObject * H245_UnicastAddress_iPSourceRouteAddress_routing::Clone() const
9317 {
9318 #ifndef PASN_LEANANDMEAN
9319   PAssert(IsClass(H245_UnicastAddress_iPSourceRouteAddress_routing::Class()), PInvalidCast);
9320 #endif
9321   return new H245_UnicastAddress_iPSourceRouteAddress_routing(*this);
9322 }
9323
9324
9325 //
9326 // UnicastAddress_iPSourceRouteAddress_route
9327 //
9328
9329 H245_UnicastAddress_iPSourceRouteAddress_route::H245_UnicastAddress_iPSourceRouteAddress_route(unsigned tag, PASN_Object::TagClass tagClass)
9330   : PASN_Array(tag, tagClass)
9331 {
9332 }
9333
9334
9335 PASN_Object * H245_UnicastAddress_iPSourceRouteAddress_route::CreateObject() const
9336 {
9337   PASN_OctetString * obj = new PASN_OctetString;
9338   obj->SetConstraints(PASN_Object::FixedConstraint, 4);
9339   return obj;
9340 }
9341
9342
9343 PASN_OctetString & H245_UnicastAddress_iPSourceRouteAddress_route::operator[](PINDEX i) const
9344 {
9345   return (PASN_OctetString &)array[i];
9346 }
9347
9348
9349 PObject * H245_UnicastAddress_iPSourceRouteAddress_route::Clone() const
9350 {
9351 #ifndef PASN_LEANANDMEAN
9352   PAssert(IsClass(H245_UnicastAddress_iPSourceRouteAddress_route::Class()), PInvalidCast);
9353 #endif
9354   return new H245_UnicastAddress_iPSourceRouteAddress_route(*this);
9355 }
9356
9357
9358
9359 #ifndef PASN_NOPRINTON
9360 const static PASN_Names Names_H245_OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters[]={
9361       {"h222LogicalChannelParameters",0}
9362      ,{"h2250LogicalChannelParameters",1}
9363 };
9364 #endif
9365 //
9366 // OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters
9367 //
9368
9369 H245_OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters::H245_OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters(unsigned tag, PASN_Object::TagClass tagClass)
9370   : PASN_Choice(tag, tagClass, 1, TRUE
9371 #ifndef PASN_NOPRINTON
9372     ,(const PASN_Names *)Names_H245_OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters,2
9373 #endif
9374 )
9375 {
9376 }
9377
9378
9379 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
9380 H245_OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters::operator H245_H222LogicalChannelParameters &() const
9381 #else
9382 H245_OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters::operator H245_H222LogicalChannelParameters &()
9383 {
9384 #ifndef PASN_LEANANDMEAN
9385   PAssert(PIsDescendant(PAssertNULL(choice), H245_H222LogicalChannelParameters), PInvalidCast);
9386 #endif
9387   return *(H245_H222LogicalChannelParameters *)choice;
9388 }
9389
9390
9391 H245_OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters::operator const H245_H222LogicalChannelParameters &() const
9392 #endif
9393 {
9394 #ifndef PASN_LEANANDMEAN
9395   PAssert(PIsDescendant(PAssertNULL(choice), H245_H222LogicalChannelParameters), PInvalidCast);
9396 #endif
9397   return *(H245_H222LogicalChannelParameters *)choice;
9398 }
9399
9400
9401 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
9402 H245_OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters::operator H245_H2250LogicalChannelParameters &() const
9403 #else
9404 H245_OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters::operator H245_H2250LogicalChannelParameters &()
9405 {
9406 #ifndef PASN_LEANANDMEAN
9407   PAssert(PIsDescendant(PAssertNULL(choice), H245_H2250LogicalChannelParameters), PInvalidCast);
9408 #endif
9409   return *(H245_H2250LogicalChannelParameters *)choice;
9410 }
9411
9412
9413 H245_OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters::operator const H245_H2250LogicalChannelParameters &() const
9414 #endif
9415 {
9416 #ifndef PASN_LEANANDMEAN
9417   PAssert(PIsDescendant(PAssertNULL(choice), H245_H2250LogicalChannelParameters), PInvalidCast);
9418 #endif
9419   return *(H245_H2250LogicalChannelParameters *)choice;
9420 }
9421
9422
9423 BOOL H245_OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters::CreateObject()
9424 {
9425   switch (tag) {
9426     case e_h222LogicalChannelParameters :
9427       choice = new H245_H222LogicalChannelParameters();
9428       return TRUE;
9429     case e_h2250LogicalChannelParameters :
9430       choice = new H245_H2250LogicalChannelParameters();
9431       return TRUE;
9432   }
9433
9434   choice = NULL;
9435   return FALSE;
9436 }
9437
9438
9439 PObject * H245_OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters::Clone() const
9440 {
9441 #ifndef PASN_LEANANDMEAN
9442   PAssert(IsClass(H245_OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters::Class()), PInvalidCast);
9443 #endif
9444   return new H245_OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters(*this);
9445 }
9446
9447
9448
9449 #ifndef PASN_NOPRINTON
9450 const static PASN_Names Names_H245_DepFECMode_rfc2733Mode_mode[]={
9451       {"redundancyEncoding",0}
9452      ,{"separateStream",1}
9453 };
9454 #endif
9455 //
9456 // DepFECMode_rfc2733Mode_mode
9457 //
9458
9459 H245_DepFECMode_rfc2733Mode_mode::H245_DepFECMode_rfc2733Mode_mode(unsigned tag, PASN_Object::TagClass tagClass)
9460   : PASN_Choice(tag, tagClass, 2, TRUE
9461 #ifndef PASN_NOPRINTON
9462     ,(const PASN_Names *)Names_H245_DepFECMode_rfc2733Mode_mode,2
9463 #endif
9464 )
9465 {
9466 }
9467
9468
9469 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
9470 H245_DepFECMode_rfc2733Mode_mode::operator H245_DepFECMode_rfc2733Mode_mode_separateStream &() const
9471 #else
9472 H245_DepFECMode_rfc2733Mode_mode::operator H245_DepFECMode_rfc2733Mode_mode_separateStream &()
9473 {
9474 #ifndef PASN_LEANANDMEAN
9475   PAssert(PIsDescendant(PAssertNULL(choice), H245_DepFECMode_rfc2733Mode_mode_separateStream), PInvalidCast);
9476 #endif
9477   return *(H245_DepFECMode_rfc2733Mode_mode_separateStream *)choice;
9478 }
9479
9480
9481 H245_DepFECMode_rfc2733Mode_mode::operator const H245_DepFECMode_rfc2733Mode_mode_separateStream &() const
9482 #endif
9483 {
9484 #ifndef PASN_LEANANDMEAN
9485   PAssert(PIsDescendant(PAssertNULL(choice), H245_DepFECMode_rfc2733Mode_mode_separateStream), PInvalidCast);
9486 #endif
9487   return *(H245_DepFECMode_rfc2733Mode_mode_separateStream *)choice;
9488 }
9489
9490
9491 BOOL H245_DepFECMode_rfc2733Mode_mode::CreateObject()
9492 {
9493   switch (tag) {
9494     case e_redundancyEncoding :
9495       choice = new PASN_Null();
9496       return TRUE;
9497     case e_separateStream :
9498       choice = new H245_DepFECMode_rfc2733Mode_mode_separateStream();
9499       return TRUE;
9500   }
9501
9502   choice = NULL;
9503   return FALSE;
9504 }
9505
9506
9507 PObject * H245_DepFECMode_rfc2733Mode_mode::Clone() const
9508 {
9509 #ifndef PASN_LEANANDMEAN
9510   PAssert(IsClass(H245_DepFECMode_rfc2733Mode_mode::Class()), PInvalidCast);
9511 #endif
9512   return new H245_DepFECMode_rfc2733Mode_mode(*this);
9513 }
9514
9515
9516 //
9517 // H223ModeParameters_adaptationLayerType_al3
9518 //
9519
9520 H245_H223ModeParameters_adaptationLayerType_al3::H245_H223ModeParameters_adaptationLayerType_al3(unsigned tag, PASN_Object::TagClass tagClass)
9521   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
9522 {
9523   m_controlFieldOctets.SetConstraints(PASN_Object::FixedConstraint, 0, 2);
9524   m_sendBufferSize.SetConstraints(PASN_Object::FixedConstraint, 0, 16777215);
9525 }
9526
9527
9528 #ifndef PASN_NOPRINTON
9529 void H245_H223ModeParameters_adaptationLayerType_al3::PrintOn(ostream & strm) const
9530 {
9531   int indent = strm.precision() + 2;
9532   strm << "{\n";
9533   strm << setw(indent+21) << "controlFieldOctets = " << setprecision(indent) << m_controlFieldOctets << '\n';
9534   strm << setw(indent+17) << "sendBufferSize = " << setprecision(indent) << m_sendBufferSize << '\n';
9535   strm << setw(indent-1) << setprecision(indent-2) << "}";
9536 }
9537 #endif
9538
9539
9540 PObject::Comparison H245_H223ModeParameters_adaptationLayerType_al3::Compare(const PObject & obj) const
9541 {
9542 #ifndef PASN_LEANANDMEAN
9543   PAssert(PIsDescendant(&obj, H245_H223ModeParameters_adaptationLayerType_al3), PInvalidCast);
9544 #endif
9545   const H245_H223ModeParameters_adaptationLayerType_al3 & other = (const H245_H223ModeParameters_adaptationLayerType_al3 &)obj;
9546
9547   Comparison result;
9548
9549   if ((result = m_controlFieldOctets.Compare(other.m_controlFieldOctets)) != EqualTo)
9550     return result;
9551   if ((result = m_sendBufferSize.Compare(other.m_sendBufferSize)) != EqualTo)
9552     return result;
9553
9554   return PASN_Sequence::Compare(other);
9555 }
9556
9557
9558 PINDEX H245_H223ModeParameters_adaptationLayerType_al3::GetDataLength() const
9559 {
9560   PINDEX length = 0;
9561   length += m_controlFieldOctets.GetObjectLength();
9562   length += m_sendBufferSize.GetObjectLength();
9563   return length;
9564 }
9565
9566
9567 BOOL H245_H223ModeParameters_adaptationLayerType_al3::Decode(PASN_Stream & strm)
9568 {
9569   if (!PreambleDecode(strm))
9570     return FALSE;
9571
9572   if (!m_controlFieldOctets.Decode(strm))
9573     return FALSE;
9574   if (!m_sendBufferSize.Decode(strm))
9575     return FALSE;
9576
9577   return UnknownExtensionsDecode(strm);
9578 }
9579
9580
9581 void H245_H223ModeParameters_adaptationLayerType_al3::Encode(PASN_Stream & strm) const
9582 {
9583   PreambleEncode(strm);
9584
9585   m_controlFieldOctets.Encode(strm);
9586   m_sendBufferSize.Encode(strm);
9587
9588   UnknownExtensionsEncode(strm);
9589 }
9590
9591
9592 PObject * H245_H223ModeParameters_adaptationLayerType_al3::Clone() const
9593 {
9594 #ifndef PASN_LEANANDMEAN
9595   PAssert(IsClass(H245_H223ModeParameters_adaptationLayerType_al3::Class()), PInvalidCast);
9596 #endif
9597   return new H245_H223ModeParameters_adaptationLayerType_al3(*this);
9598 }
9599
9600
9601 //
9602 // DataMode_application_nlpid
9603 //
9604
9605 H245_DataMode_application_nlpid::H245_DataMode_application_nlpid(unsigned tag, PASN_Object::TagClass tagClass)
9606   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
9607 {
9608 }
9609
9610
9611 #ifndef PASN_NOPRINTON
9612 void H245_DataMode_application_nlpid::PrintOn(ostream & strm) const
9613 {
9614   int indent = strm.precision() + 2;
9615   strm << "{\n";
9616   strm << setw(indent+16) << "nlpidProtocol = " << setprecision(indent) << m_nlpidProtocol << '\n';
9617   strm << setw(indent+12) << "nlpidData = " << setprecision(indent) << m_nlpidData << '\n';
9618   strm << setw(indent-1) << setprecision(indent-2) << "}";
9619 }
9620 #endif
9621
9622
9623 PObject::Comparison H245_DataMode_application_nlpid::Compare(const PObject & obj) const
9624 {
9625 #ifndef PASN_LEANANDMEAN
9626   PAssert(PIsDescendant(&obj, H245_DataMode_application_nlpid), PInvalidCast);
9627 #endif
9628   const H245_DataMode_application_nlpid & other = (const H245_DataMode_application_nlpid &)obj;
9629
9630   Comparison result;
9631
9632   if ((result = m_nlpidProtocol.Compare(other.m_nlpidProtocol)) != EqualTo)
9633     return result;
9634   if ((result = m_nlpidData.Compare(other.m_nlpidData)) != EqualTo)
9635     return result;
9636
9637   return PASN_Sequence::Compare(other);
9638 }
9639
9640
9641 PINDEX H245_DataMode_application_nlpid::GetDataLength() const
9642 {
9643   PINDEX length = 0;
9644   length += m_nlpidProtocol.GetObjectLength();
9645   length += m_nlpidData.GetObjectLength();
9646   return length;
9647 }
9648
9649
9650 BOOL H245_DataMode_application_nlpid::Decode(PASN_Stream & strm)
9651 {
9652   if (!PreambleDecode(strm))
9653     return FALSE;
9654
9655   if (!m_nlpidProtocol.Decode(strm))
9656     return FALSE;
9657   if (!m_nlpidData.Decode(strm))
9658     return FALSE;
9659
9660   return UnknownExtensionsDecode(strm);
9661 }
9662
9663
9664 void H245_DataMode_application_nlpid::Encode(PASN_Stream & strm) const
9665 {
9666   PreambleEncode(strm);
9667
9668   m_nlpidProtocol.Encode(strm);
9669   m_nlpidData.Encode(strm);
9670
9671   UnknownExtensionsEncode(strm);
9672 }
9673
9674
9675 PObject * H245_DataMode_application_nlpid::Clone() const
9676 {
9677 #ifndef PASN_LEANANDMEAN
9678   PAssert(IsClass(H245_DataMode_application_nlpid::Class()), PInvalidCast);
9679 #endif
9680   return new H245_DataMode_application_nlpid(*this);
9681 }
9682
9683
9684
9685 #ifndef PASN_NOPRINTON
9686 const static PASN_Names Names_H245_MultilinkRequest_maximumHeaderInterval_requestType[]={
9687       {"currentIntervalInformation",0}
9688      ,{"requestedInterval",1}
9689 };
9690 #endif
9691 //
9692 // MultilinkRequest_maximumHeaderInterval_requestType
9693 //
9694
9695 H245_MultilinkRequest_maximumHeaderInterval_requestType::H245_MultilinkRequest_maximumHeaderInterval_requestType(unsigned tag, PASN_Object::TagClass tagClass)
9696   : PASN_Choice(tag, tagClass, 2, TRUE
9697 #ifndef PASN_NOPRINTON
9698     ,(const PASN_Names *)Names_H245_MultilinkRequest_maximumHeaderInterval_requestType,2
9699 #endif
9700 )
9701 {
9702 }
9703
9704
9705 BOOL H245_MultilinkRequest_maximumHeaderInterval_requestType::CreateObject()
9706 {
9707   switch (tag) {
9708     case e_currentIntervalInformation :
9709       choice = new PASN_Null();
9710       return TRUE;
9711     case e_requestedInterval :
9712       choice = new PASN_Integer();
9713       choice->SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
9714       return TRUE;
9715   }
9716
9717   choice = NULL;
9718   return FALSE;
9719 }
9720
9721
9722 PObject * H245_MultilinkRequest_maximumHeaderInterval_requestType::Clone() const
9723 {
9724 #ifndef PASN_LEANANDMEAN
9725   PAssert(IsClass(H245_MultilinkRequest_maximumHeaderInterval_requestType::Class()), PInvalidCast);
9726 #endif
9727   return new H245_MultilinkRequest_maximumHeaderInterval_requestType(*this);
9728 }
9729
9730
9731
9732 #ifndef PASN_NOPRINTON
9733 const static PASN_Names Names_H245_MultilinkResponse_addConnection_responseCode[]={
9734       {"accepted",0}
9735      ,{"rejected",1}
9736 };
9737 #endif
9738 //
9739 // MultilinkResponse_addConnection_responseCode
9740 //
9741
9742 H245_MultilinkResponse_addConnection_responseCode::H245_MultilinkResponse_addConnection_responseCode(unsigned tag, PASN_Object::TagClass tagClass)
9743   : PASN_Choice(tag, tagClass, 2, TRUE
9744 #ifndef PASN_NOPRINTON
9745     ,(const PASN_Names *)Names_H245_MultilinkResponse_addConnection_responseCode,2
9746 #endif
9747 )
9748 {
9749 }
9750
9751
9752 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
9753 H245_MultilinkResponse_addConnection_responseCode::operator H245_MultilinkResponse_addConnection_responseCode_rejected &() const
9754 #else
9755 H245_MultilinkResponse_addConnection_responseCode::operator H245_MultilinkResponse_addConnection_responseCode_rejected &()
9756 {
9757 #ifndef PASN_LEANANDMEAN
9758   PAssert(PIsDescendant(PAssertNULL(choice), H245_MultilinkResponse_addConnection_responseCode_rejected), PInvalidCast);
9759 #endif
9760   return *(H245_MultilinkResponse_addConnection_responseCode_rejected *)choice;
9761 }
9762
9763
9764 H245_MultilinkResponse_addConnection_responseCode::operator const H245_MultilinkResponse_addConnection_responseCode_rejected &() const
9765 #endif
9766 {
9767 #ifndef PASN_LEANANDMEAN
9768   PAssert(PIsDescendant(PAssertNULL(choice), H245_MultilinkResponse_addConnection_responseCode_rejected), PInvalidCast);
9769 #endif
9770   return *(H245_MultilinkResponse_addConnection_responseCode_rejected *)choice;
9771 }
9772
9773
9774 BOOL H245_MultilinkResponse_addConnection_responseCode::CreateObject()
9775 {
9776   switch (tag) {
9777     case e_accepted :
9778       choice = new PASN_Null();
9779       return TRUE;
9780     case e_rejected :
9781       choice = new H245_MultilinkResponse_addConnection_responseCode_rejected();
9782       return TRUE;
9783   }
9784
9785   choice = NULL;
9786   return FALSE;
9787 }
9788
9789
9790 PObject * H245_MultilinkResponse_addConnection_responseCode::Clone() const
9791 {
9792 #ifndef PASN_LEANANDMEAN
9793   PAssert(IsClass(H245_MultilinkResponse_addConnection_responseCode::Class()), PInvalidCast);
9794 #endif
9795   return new H245_MultilinkResponse_addConnection_responseCode(*this);
9796 }
9797
9798
9799 //
9800 // ArrayOf_CapabilityDescriptorNumber
9801 //
9802
9803 H245_ArrayOf_CapabilityDescriptorNumber::H245_ArrayOf_CapabilityDescriptorNumber(unsigned tag, PASN_Object::TagClass tagClass)
9804   : PASN_Array(tag, tagClass)
9805 {
9806 }
9807
9808
9809 PASN_Object * H245_ArrayOf_CapabilityDescriptorNumber::CreateObject() const
9810 {
9811   return new H245_CapabilityDescriptorNumber;
9812 }
9813
9814
9815 H245_CapabilityDescriptorNumber & H245_ArrayOf_CapabilityDescriptorNumber::operator[](PINDEX i) const
9816 {
9817   return (H245_CapabilityDescriptorNumber &)array[i];
9818 }
9819
9820
9821 PObject * H245_ArrayOf_CapabilityDescriptorNumber::Clone() const
9822 {
9823 #ifndef PASN_LEANANDMEAN
9824   PAssert(IsClass(H245_ArrayOf_CapabilityDescriptorNumber::Class()), PInvalidCast);
9825 #endif
9826   return new H245_ArrayOf_CapabilityDescriptorNumber(*this);
9827 }
9828
9829
9830 //
9831 // MiscellaneousCommand_type_videoFastUpdateGOB
9832 //
9833
9834 H245_MiscellaneousCommand_type_videoFastUpdateGOB::H245_MiscellaneousCommand_type_videoFastUpdateGOB(unsigned tag, PASN_Object::TagClass tagClass)
9835   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
9836 {
9837   m_firstGOB.SetConstraints(PASN_Object::FixedConstraint, 0, 17);
9838   m_numberOfGOBs.SetConstraints(PASN_Object::FixedConstraint, 1, 18);
9839 }
9840
9841
9842 #ifndef PASN_NOPRINTON
9843 void H245_MiscellaneousCommand_type_videoFastUpdateGOB::PrintOn(ostream & strm) const
9844 {
9845   int indent = strm.precision() + 2;
9846   strm << "{\n";
9847   strm << setw(indent+11) << "firstGOB = " << setprecision(indent) << m_firstGOB << '\n';
9848   strm << setw(indent+15) << "numberOfGOBs = " << setprecision(indent) << m_numberOfGOBs << '\n';
9849   strm << setw(indent-1) << setprecision(indent-2) << "}";
9850 }
9851 #endif
9852
9853
9854 PObject::Comparison H245_MiscellaneousCommand_type_videoFastUpdateGOB::Compare(const PObject & obj) const
9855 {
9856 #ifndef PASN_LEANANDMEAN
9857   PAssert(PIsDescendant(&obj, H245_MiscellaneousCommand_type_videoFastUpdateGOB), PInvalidCast);
9858 #endif
9859   const H245_MiscellaneousCommand_type_videoFastUpdateGOB & other = (const H245_MiscellaneousCommand_type_videoFastUpdateGOB &)obj;
9860
9861   Comparison result;
9862
9863   if ((result = m_firstGOB.Compare(other.m_firstGOB)) != EqualTo)
9864     return result;
9865   if ((result = m_numberOfGOBs.Compare(other.m_numberOfGOBs)) != EqualTo)
9866     return result;
9867
9868   return PASN_Sequence::Compare(other);
9869 }
9870
9871
9872 PINDEX H245_MiscellaneousCommand_type_videoFastUpdateGOB::GetDataLength() const
9873 {
9874   PINDEX length = 0;
9875   length += m_firstGOB.GetObjectLength();
9876   length += m_numberOfGOBs.GetObjectLength();
9877   return length;
9878 }
9879
9880
9881 BOOL H245_MiscellaneousCommand_type_videoFastUpdateGOB::Decode(PASN_Stream & strm)
9882 {
9883   if (!PreambleDecode(strm))
9884     return FALSE;
9885
9886   if (!m_firstGOB.Decode(strm))
9887     return FALSE;
9888   if (!m_numberOfGOBs.Decode(strm))
9889     return FALSE;
9890
9891   return UnknownExtensionsDecode(strm);
9892 }
9893
9894
9895 void H245_MiscellaneousCommand_type_videoFastUpdateGOB::Encode(PASN_Stream & strm) const
9896 {
9897   PreambleEncode(strm);
9898
9899   m_firstGOB.Encode(strm);
9900   m_numberOfGOBs.Encode(strm);
9901
9902   UnknownExtensionsEncode(strm);
9903 }
9904
9905
9906 PObject * H245_MiscellaneousCommand_type_videoFastUpdateGOB::Clone() const
9907 {
9908 #ifndef PASN_LEANANDMEAN
9909   PAssert(IsClass(H245_MiscellaneousCommand_type_videoFastUpdateGOB::Class()), PInvalidCast);
9910 #endif
9911   return new H245_MiscellaneousCommand_type_videoFastUpdateGOB(*this);
9912 }
9913
9914
9915 //
9916 // MiscellaneousCommand_type_videoFastUpdateMB
9917 //
9918
9919 H245_MiscellaneousCommand_type_videoFastUpdateMB::H245_MiscellaneousCommand_type_videoFastUpdateMB(unsigned tag, PASN_Object::TagClass tagClass)
9920   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
9921 {
9922   m_firstGOB.SetConstraints(PASN_Object::FixedConstraint, 0, 255);
9923   m_firstMB.SetConstraints(PASN_Object::FixedConstraint, 1, 8192);
9924   m_numberOfMBs.SetConstraints(PASN_Object::FixedConstraint, 1, 8192);
9925 }
9926
9927
9928 #ifndef PASN_NOPRINTON
9929 void H245_MiscellaneousCommand_type_videoFastUpdateMB::PrintOn(ostream & strm) const
9930 {
9931   int indent = strm.precision() + 2;
9932   strm << "{\n";
9933   if (HasOptionalField(e_firstGOB))
9934     strm << setw(indent+11) << "firstGOB = " << setprecision(indent) << m_firstGOB << '\n';
9935   if (HasOptionalField(e_firstMB))
9936     strm << setw(indent+10) << "firstMB = " << setprecision(indent) << m_firstMB << '\n';
9937   strm << setw(indent+14) << "numberOfMBs = " << setprecision(indent) << m_numberOfMBs << '\n';
9938   strm << setw(indent-1) << setprecision(indent-2) << "}";
9939 }
9940 #endif
9941
9942
9943 PObject::Comparison H245_MiscellaneousCommand_type_videoFastUpdateMB::Compare(const PObject & obj) const
9944 {
9945 #ifndef PASN_LEANANDMEAN
9946   PAssert(PIsDescendant(&obj, H245_MiscellaneousCommand_type_videoFastUpdateMB), PInvalidCast);
9947 #endif
9948   const H245_MiscellaneousCommand_type_videoFastUpdateMB & other = (const H245_MiscellaneousCommand_type_videoFastUpdateMB &)obj;
9949
9950   Comparison result;
9951
9952   if ((result = m_firstGOB.Compare(other.m_firstGOB)) != EqualTo)
9953     return result;
9954   if ((result = m_firstMB.Compare(other.m_firstMB)) != EqualTo)
9955     return result;
9956   if ((result = m_numberOfMBs.Compare(other.m_numberOfMBs)) != EqualTo)
9957     return result;
9958
9959   return PASN_Sequence::Compare(other);
9960 }
9961
9962
9963 PINDEX H245_MiscellaneousCommand_type_videoFastUpdateMB::GetDataLength() const
9964 {
9965   PINDEX length = 0;
9966   if (HasOptionalField(e_firstGOB))
9967     length += m_firstGOB.GetObjectLength();
9968   if (HasOptionalField(e_firstMB))
9969     length += m_firstMB.GetObjectLength();
9970   length += m_numberOfMBs.GetObjectLength();
9971   return length;
9972 }
9973
9974
9975 BOOL H245_MiscellaneousCommand_type_videoFastUpdateMB::Decode(PASN_Stream & strm)
9976 {
9977   if (!PreambleDecode(strm))
9978     return FALSE;
9979
9980   if (HasOptionalField(e_firstGOB) && !m_firstGOB.Decode(strm))
9981     return FALSE;
9982   if (HasOptionalField(e_firstMB) && !m_firstMB.Decode(strm))
9983     return FALSE;
9984   if (!m_numberOfMBs.Decode(strm))
9985     return FALSE;
9986
9987   return UnknownExtensionsDecode(strm);
9988 }
9989
9990
9991 void H245_MiscellaneousCommand_type_videoFastUpdateMB::Encode(PASN_Stream & strm) const
9992 {
9993   PreambleEncode(strm);
9994
9995   if (HasOptionalField(e_firstGOB))
9996     m_firstGOB.Encode(strm);
9997   if (HasOptionalField(e_firstMB))
9998     m_firstMB.Encode(strm);
9999   m_numberOfMBs.Encode(strm);
10000
10001   UnknownExtensionsEncode(strm);
10002 }
10003
10004
10005 PObject * H245_MiscellaneousCommand_type_videoFastUpdateMB::Clone() const
10006 {
10007 #ifndef PASN_LEANANDMEAN
10008   PAssert(IsClass(H245_MiscellaneousCommand_type_videoFastUpdateMB::Class()), PInvalidCast);
10009 #endif
10010   return new H245_MiscellaneousCommand_type_videoFastUpdateMB(*this);
10011 }
10012
10013
10014 //
10015 // MiscellaneousCommand_type_videoBadMBs
10016 //
10017
10018 H245_MiscellaneousCommand_type_videoBadMBs::H245_MiscellaneousCommand_type_videoBadMBs(unsigned tag, PASN_Object::TagClass tagClass)
10019   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
10020 {
10021   m_firstMB.SetConstraints(PASN_Object::FixedConstraint, 1, 9216);
10022   m_numberOfMBs.SetConstraints(PASN_Object::FixedConstraint, 1, 9216);
10023   m_temporalReference.SetConstraints(PASN_Object::FixedConstraint, 0, 1023);
10024 }
10025
10026
10027 #ifndef PASN_NOPRINTON
10028 void H245_MiscellaneousCommand_type_videoBadMBs::PrintOn(ostream & strm) const
10029 {
10030   int indent = strm.precision() + 2;
10031   strm << "{\n";
10032   strm << setw(indent+10) << "firstMB = " << setprecision(indent) << m_firstMB << '\n';
10033   strm << setw(indent+14) << "numberOfMBs = " << setprecision(indent) << m_numberOfMBs << '\n';
10034   strm << setw(indent+20) << "temporalReference = " << setprecision(indent) << m_temporalReference << '\n';
10035   strm << setw(indent-1) << setprecision(indent-2) << "}";
10036 }
10037 #endif
10038
10039
10040 PObject::Comparison H245_MiscellaneousCommand_type_videoBadMBs::Compare(const PObject & obj) const
10041 {
10042 #ifndef PASN_LEANANDMEAN
10043   PAssert(PIsDescendant(&obj, H245_MiscellaneousCommand_type_videoBadMBs), PInvalidCast);
10044 #endif
10045   const H245_MiscellaneousCommand_type_videoBadMBs & other = (const H245_MiscellaneousCommand_type_videoBadMBs &)obj;
10046
10047   Comparison result;
10048
10049   if ((result = m_firstMB.Compare(other.m_firstMB)) != EqualTo)
10050     return result;
10051   if ((result = m_numberOfMBs.Compare(other.m_numberOfMBs)) != EqualTo)
10052     return result;
10053   if ((result = m_temporalReference.Compare(other.m_temporalReference)) != EqualTo)
10054     return result;
10055
10056   return PASN_Sequence::Compare(other);
10057 }
10058
10059
10060 PINDEX H245_MiscellaneousCommand_type_videoBadMBs::GetDataLength() const
10061 {
10062   PINDEX length = 0;
10063   length += m_firstMB.GetObjectLength();
10064   length += m_numberOfMBs.GetObjectLength();
10065   length += m_temporalReference.GetObjectLength();
10066   return length;
10067 }
10068
10069
10070 BOOL H245_MiscellaneousCommand_type_videoBadMBs::Decode(PASN_Stream & strm)
10071 {
10072   if (!PreambleDecode(strm))
10073     return FALSE;
10074
10075   if (!m_firstMB.Decode(strm))
10076     return FALSE;
10077   if (!m_numberOfMBs.Decode(strm))
10078     return FALSE;
10079   if (!m_temporalReference.Decode(strm))
10080     return FALSE;
10081
10082   return UnknownExtensionsDecode(strm);
10083 }
10084
10085
10086 void H245_MiscellaneousCommand_type_videoBadMBs::Encode(PASN_Stream & strm) const
10087 {
10088   PreambleEncode(strm);
10089
10090   m_firstMB.Encode(strm);
10091   m_numberOfMBs.Encode(strm);
10092   m_temporalReference.Encode(strm);
10093
10094   UnknownExtensionsEncode(strm);
10095 }
10096
10097
10098 PObject * H245_MiscellaneousCommand_type_videoBadMBs::Clone() const
10099 {
10100 #ifndef PASN_LEANANDMEAN
10101   PAssert(IsClass(H245_MiscellaneousCommand_type_videoBadMBs::Class()), PInvalidCast);
10102 #endif
10103   return new H245_MiscellaneousCommand_type_videoBadMBs(*this);
10104 }
10105
10106
10107 //
10108 // ArrayOf_PictureReference
10109 //
10110
10111 H245_ArrayOf_PictureReference::H245_ArrayOf_PictureReference(unsigned tag, PASN_Object::TagClass tagClass)
10112   : PASN_Array(tag, tagClass)
10113 {
10114 }
10115
10116
10117 PASN_Object * H245_ArrayOf_PictureReference::CreateObject() const
10118 {
10119   return new H245_PictureReference;
10120 }
10121
10122
10123 H245_PictureReference & H245_ArrayOf_PictureReference::operator[](PINDEX i) const
10124 {
10125   return (H245_PictureReference &)array[i];
10126 }
10127
10128
10129 PObject * H245_ArrayOf_PictureReference::Clone() const
10130 {
10131 #ifndef PASN_LEANANDMEAN
10132   PAssert(IsClass(H245_ArrayOf_PictureReference::Class()), PInvalidCast);
10133 #endif
10134   return new H245_ArrayOf_PictureReference(*this);
10135 }
10136
10137
10138 //
10139 // MiscellaneousCommand_type_lostPartialPicture
10140 //
10141
10142 H245_MiscellaneousCommand_type_lostPartialPicture::H245_MiscellaneousCommand_type_lostPartialPicture(unsigned tag, PASN_Object::TagClass tagClass)
10143   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
10144 {
10145   m_firstMB.SetConstraints(PASN_Object::FixedConstraint, 1, 9216);
10146   m_numberOfMBs.SetConstraints(PASN_Object::FixedConstraint, 1, 9216);
10147 }
10148
10149
10150 #ifndef PASN_NOPRINTON
10151 void H245_MiscellaneousCommand_type_lostPartialPicture::PrintOn(ostream & strm) const
10152 {
10153   int indent = strm.precision() + 2;
10154   strm << "{\n";
10155   strm << setw(indent+19) << "pictureReference = " << setprecision(indent) << m_pictureReference << '\n';
10156   strm << setw(indent+10) << "firstMB = " << setprecision(indent) << m_firstMB << '\n';
10157   strm << setw(indent+14) << "numberOfMBs = " << setprecision(indent) << m_numberOfMBs << '\n';
10158   strm << setw(indent-1) << setprecision(indent-2) << "}";
10159 }
10160 #endif
10161
10162
10163 PObject::Comparison H245_MiscellaneousCommand_type_lostPartialPicture::Compare(const PObject & obj) const
10164 {
10165 #ifndef PASN_LEANANDMEAN
10166   PAssert(PIsDescendant(&obj, H245_MiscellaneousCommand_type_lostPartialPicture), PInvalidCast);
10167 #endif
10168   const H245_MiscellaneousCommand_type_lostPartialPicture & other = (const H245_MiscellaneousCommand_type_lostPartialPicture &)obj;
10169
10170   Comparison result;
10171
10172   if ((result = m_pictureReference.Compare(other.m_pictureReference)) != EqualTo)
10173     return result;
10174   if ((result = m_firstMB.Compare(other.m_firstMB)) != EqualTo)
10175     return result;
10176   if ((result = m_numberOfMBs.Compare(other.m_numberOfMBs)) != EqualTo)
10177     return result;
10178
10179   return PASN_Sequence::Compare(other);
10180 }
10181
10182
10183 PINDEX H245_MiscellaneousCommand_type_lostPartialPicture::GetDataLength() const
10184 {
10185   PINDEX length = 0;
10186   length += m_pictureReference.GetObjectLength();
10187   length += m_firstMB.GetObjectLength();
10188   length += m_numberOfMBs.GetObjectLength();
10189   return length;
10190 }
10191
10192
10193 BOOL H245_MiscellaneousCommand_type_lostPartialPicture::Decode(PASN_Stream & strm)
10194 {
10195   if (!PreambleDecode(strm))
10196     return FALSE;
10197
10198   if (!m_pictureReference.Decode(strm))
10199     return FALSE;
10200   if (!m_firstMB.Decode(strm))
10201     return FALSE;
10202   if (!m_numberOfMBs.Decode(strm))
10203     return FALSE;
10204
10205   return UnknownExtensionsDecode(strm);
10206 }
10207
10208
10209 void H245_MiscellaneousCommand_type_lostPartialPicture::Encode(PASN_Stream & strm) const
10210 {
10211   PreambleEncode(strm);
10212
10213   m_pictureReference.Encode(strm);
10214   m_firstMB.Encode(strm);
10215   m_numberOfMBs.Encode(strm);
10216
10217   UnknownExtensionsEncode(strm);
10218 }
10219
10220
10221 PObject * H245_MiscellaneousCommand_type_lostPartialPicture::Clone() const
10222 {
10223 #ifndef PASN_LEANANDMEAN
10224   PAssert(IsClass(H245_MiscellaneousCommand_type_lostPartialPicture::Class()), PInvalidCast);
10225 #endif
10226   return new H245_MiscellaneousCommand_type_lostPartialPicture(*this);
10227 }
10228
10229
10230 //
10231 // MiscellaneousCommand_type_encryptionUpdateAck
10232 //
10233
10234 H245_MiscellaneousCommand_type_encryptionUpdateAck::H245_MiscellaneousCommand_type_encryptionUpdateAck(unsigned tag, PASN_Object::TagClass tagClass)
10235   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
10236 {
10237   m_synchFlag.SetConstraints(PASN_Object::FixedConstraint, 0, 255);
10238 }
10239
10240
10241 #ifndef PASN_NOPRINTON
10242 void H245_MiscellaneousCommand_type_encryptionUpdateAck::PrintOn(ostream & strm) const
10243 {
10244   int indent = strm.precision() + 2;
10245   strm << "{\n";
10246   strm << setw(indent+12) << "synchFlag = " << setprecision(indent) << m_synchFlag << '\n';
10247   strm << setw(indent-1) << setprecision(indent-2) << "}";
10248 }
10249 #endif
10250
10251
10252 PObject::Comparison H245_MiscellaneousCommand_type_encryptionUpdateAck::Compare(const PObject & obj) const
10253 {
10254 #ifndef PASN_LEANANDMEAN
10255   PAssert(PIsDescendant(&obj, H245_MiscellaneousCommand_type_encryptionUpdateAck), PInvalidCast);
10256 #endif
10257   const H245_MiscellaneousCommand_type_encryptionUpdateAck & other = (const H245_MiscellaneousCommand_type_encryptionUpdateAck &)obj;
10258
10259   Comparison result;
10260
10261   if ((result = m_synchFlag.Compare(other.m_synchFlag)) != EqualTo)
10262     return result;
10263
10264   return PASN_Sequence::Compare(other);
10265 }
10266
10267
10268 PINDEX H245_MiscellaneousCommand_type_encryptionUpdateAck::GetDataLength() const
10269 {
10270   PINDEX length = 0;
10271   length += m_synchFlag.GetObjectLength();
10272   return length;
10273 }
10274
10275
10276 BOOL H245_MiscellaneousCommand_type_encryptionUpdateAck::Decode(PASN_Stream & strm)
10277 {
10278   if (!PreambleDecode(strm))
10279     return FALSE;
10280
10281   if (!m_synchFlag.Decode(strm))
10282     return FALSE;
10283
10284   return UnknownExtensionsDecode(strm);
10285 }
10286
10287
10288 void H245_MiscellaneousCommand_type_encryptionUpdateAck::Encode(PASN_Stream & strm) const
10289 {
10290   PreambleEncode(strm);
10291
10292   m_synchFlag.Encode(strm);
10293
10294   UnknownExtensionsEncode(strm);
10295 }
10296
10297
10298 PObject * H245_MiscellaneousCommand_type_encryptionUpdateAck::Clone() const
10299 {
10300 #ifndef PASN_LEANANDMEAN
10301   PAssert(IsClass(H245_MiscellaneousCommand_type_encryptionUpdateAck::Class()), PInvalidCast);
10302 #endif
10303   return new H245_MiscellaneousCommand_type_encryptionUpdateAck(*this);
10304 }
10305
10306
10307 //
10308 // NewATMVCCommand_aal_aal5
10309 //
10310
10311 H245_NewATMVCCommand_aal_aal5::H245_NewATMVCCommand_aal_aal5(unsigned tag, PASN_Object::TagClass tagClass)
10312   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
10313 {
10314   m_forwardMaximumSDUSize.SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
10315   m_backwardMaximumSDUSize.SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
10316 }
10317
10318
10319 #ifndef PASN_NOPRINTON
10320 void H245_NewATMVCCommand_aal_aal5::PrintOn(ostream & strm) const
10321 {
10322   int indent = strm.precision() + 2;
10323   strm << "{\n";
10324   strm << setw(indent+24) << "forwardMaximumSDUSize = " << setprecision(indent) << m_forwardMaximumSDUSize << '\n';
10325   strm << setw(indent+25) << "backwardMaximumSDUSize = " << setprecision(indent) << m_backwardMaximumSDUSize << '\n';
10326   strm << setw(indent-1) << setprecision(indent-2) << "}";
10327 }
10328 #endif
10329
10330
10331 PObject::Comparison H245_NewATMVCCommand_aal_aal5::Compare(const PObject & obj) const
10332 {
10333 #ifndef PASN_LEANANDMEAN
10334   PAssert(PIsDescendant(&obj, H245_NewATMVCCommand_aal_aal5), PInvalidCast);
10335 #endif
10336   const H245_NewATMVCCommand_aal_aal5 & other = (const H245_NewATMVCCommand_aal_aal5 &)obj;
10337
10338   Comparison result;
10339
10340   if ((result = m_forwardMaximumSDUSize.Compare(other.m_forwardMaximumSDUSize)) != EqualTo)
10341     return result;
10342   if ((result = m_backwardMaximumSDUSize.Compare(other.m_backwardMaximumSDUSize)) != EqualTo)
10343     return result;
10344
10345   return PASN_Sequence::Compare(other);
10346 }
10347
10348
10349 PINDEX H245_NewATMVCCommand_aal_aal5::GetDataLength() const
10350 {
10351   PINDEX length = 0;
10352   length += m_forwardMaximumSDUSize.GetObjectLength();
10353   length += m_backwardMaximumSDUSize.GetObjectLength();
10354   return length;
10355 }
10356
10357
10358 BOOL H245_NewATMVCCommand_aal_aal5::Decode(PASN_Stream & strm)
10359 {
10360   if (!PreambleDecode(strm))
10361     return FALSE;
10362
10363   if (!m_forwardMaximumSDUSize.Decode(strm))
10364     return FALSE;
10365   if (!m_backwardMaximumSDUSize.Decode(strm))
10366     return FALSE;
10367
10368   return UnknownExtensionsDecode(strm);
10369 }
10370
10371
10372 void H245_NewATMVCCommand_aal_aal5::Encode(PASN_Stream & strm) const
10373 {
10374   PreambleEncode(strm);
10375
10376   m_forwardMaximumSDUSize.Encode(strm);
10377   m_backwardMaximumSDUSize.Encode(strm);
10378
10379   UnknownExtensionsEncode(strm);
10380 }
10381
10382
10383 PObject * H245_NewATMVCCommand_aal_aal5::Clone() const
10384 {
10385 #ifndef PASN_LEANANDMEAN
10386   PAssert(IsClass(H245_NewATMVCCommand_aal_aal5::Class()), PInvalidCast);
10387 #endif
10388   return new H245_NewATMVCCommand_aal_aal5(*this);
10389 }
10390
10391
10392
10393 #ifndef PASN_NOPRINTON
10394 const static PASN_Names Names_H245_NewATMVCCommand_reverseParameters_multiplex[]={
10395       {"noMultiplex",0}
10396      ,{"transportStream",1}
10397      ,{"programStream",2}
10398 };
10399 #endif
10400 //
10401 // NewATMVCCommand_reverseParameters_multiplex
10402 //
10403
10404 H245_NewATMVCCommand_reverseParameters_multiplex::H245_NewATMVCCommand_reverseParameters_multiplex(unsigned tag, PASN_Object::TagClass tagClass)
10405   : PASN_Choice(tag, tagClass, 3, TRUE
10406 #ifndef PASN_NOPRINTON
10407     ,(const PASN_Names *)Names_H245_NewATMVCCommand_reverseParameters_multiplex,3
10408 #endif
10409 )
10410 {
10411 }
10412
10413
10414 BOOL H245_NewATMVCCommand_reverseParameters_multiplex::CreateObject()
10415 {
10416   choice = (tag <= e_programStream) ? new PASN_Null() : NULL;
10417   return choice != NULL;
10418 }
10419
10420
10421 PObject * H245_NewATMVCCommand_reverseParameters_multiplex::Clone() const
10422 {
10423 #ifndef PASN_LEANANDMEAN
10424   PAssert(IsClass(H245_NewATMVCCommand_reverseParameters_multiplex::Class()), PInvalidCast);
10425 #endif
10426   return new H245_NewATMVCCommand_reverseParameters_multiplex(*this);
10427 }
10428
10429
10430 //
10431 // MiscellaneousIndication_type_videoNotDecodedMBs
10432 //
10433
10434 H245_MiscellaneousIndication_type_videoNotDecodedMBs::H245_MiscellaneousIndication_type_videoNotDecodedMBs(unsigned tag, PASN_Object::TagClass tagClass)
10435   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
10436 {
10437   m_firstMB.SetConstraints(PASN_Object::FixedConstraint, 1, 8192);
10438   m_numberOfMBs.SetConstraints(PASN_Object::FixedConstraint, 1, 8192);
10439   m_temporalReference.SetConstraints(PASN_Object::FixedConstraint, 0, 255);
10440 }
10441
10442
10443 #ifndef PASN_NOPRINTON
10444 void H245_MiscellaneousIndication_type_videoNotDecodedMBs::PrintOn(ostream & strm) const
10445 {
10446   int indent = strm.precision() + 2;
10447   strm << "{\n";
10448   strm << setw(indent+10) << "firstMB = " << setprecision(indent) << m_firstMB << '\n';
10449   strm << setw(indent+14) << "numberOfMBs = " << setprecision(indent) << m_numberOfMBs << '\n';
10450   strm << setw(indent+20) << "temporalReference = " << setprecision(indent) << m_temporalReference << '\n';
10451   strm << setw(indent-1) << setprecision(indent-2) << "}";
10452 }
10453 #endif
10454
10455
10456 PObject::Comparison H245_MiscellaneousIndication_type_videoNotDecodedMBs::Compare(const PObject & obj) const
10457 {
10458 #ifndef PASN_LEANANDMEAN
10459   PAssert(PIsDescendant(&obj, H245_MiscellaneousIndication_type_videoNotDecodedMBs), PInvalidCast);
10460 #endif
10461   const H245_MiscellaneousIndication_type_videoNotDecodedMBs & other = (const H245_MiscellaneousIndication_type_videoNotDecodedMBs &)obj;
10462
10463   Comparison result;
10464
10465   if ((result = m_firstMB.Compare(other.m_firstMB)) != EqualTo)
10466     return result;
10467   if ((result = m_numberOfMBs.Compare(other.m_numberOfMBs)) != EqualTo)
10468     return result;
10469   if ((result = m_temporalReference.Compare(other.m_temporalReference)) != EqualTo)
10470     return result;
10471
10472   return PASN_Sequence::Compare(other);
10473 }
10474
10475
10476 PINDEX H245_MiscellaneousIndication_type_videoNotDecodedMBs::GetDataLength() const
10477 {
10478   PINDEX length = 0;
10479   length += m_firstMB.GetObjectLength();
10480   length += m_numberOfMBs.GetObjectLength();
10481   length += m_temporalReference.GetObjectLength();
10482   return length;
10483 }
10484
10485
10486 BOOL H245_MiscellaneousIndication_type_videoNotDecodedMBs::Decode(PASN_Stream & strm)
10487 {
10488   if (!PreambleDecode(strm))
10489     return FALSE;
10490
10491   if (!m_firstMB.Decode(strm))
10492     return FALSE;
10493   if (!m_numberOfMBs.Decode(strm))
10494     return FALSE;
10495   if (!m_temporalReference.Decode(strm))
10496     return FALSE;
10497
10498   return UnknownExtensionsDecode(strm);
10499 }
10500
10501
10502 void H245_MiscellaneousIndication_type_videoNotDecodedMBs::Encode(PASN_Stream & strm) const
10503 {
10504   PreambleEncode(strm);
10505
10506   m_firstMB.Encode(strm);
10507   m_numberOfMBs.Encode(strm);
10508   m_temporalReference.Encode(strm);
10509
10510   UnknownExtensionsEncode(strm);
10511 }
10512
10513
10514 PObject * H245_MiscellaneousIndication_type_videoNotDecodedMBs::Clone() const
10515 {
10516 #ifndef PASN_LEANANDMEAN
10517   PAssert(IsClass(H245_MiscellaneousIndication_type_videoNotDecodedMBs::Class()), PInvalidCast);
10518 #endif
10519   return new H245_MiscellaneousIndication_type_videoNotDecodedMBs(*this);
10520 }
10521
10522
10523 //
10524 // NewATMVCIndication_aal_aal5
10525 //
10526
10527 H245_NewATMVCIndication_aal_aal5::H245_NewATMVCIndication_aal_aal5(unsigned tag, PASN_Object::TagClass tagClass)
10528   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
10529 {
10530   m_forwardMaximumSDUSize.SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
10531   m_backwardMaximumSDUSize.SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
10532 }
10533
10534
10535 #ifndef PASN_NOPRINTON
10536 void H245_NewATMVCIndication_aal_aal5::PrintOn(ostream & strm) const
10537 {
10538   int indent = strm.precision() + 2;
10539   strm << "{\n";
10540   strm << setw(indent+24) << "forwardMaximumSDUSize = " << setprecision(indent) << m_forwardMaximumSDUSize << '\n';
10541   strm << setw(indent+25) << "backwardMaximumSDUSize = " << setprecision(indent) << m_backwardMaximumSDUSize << '\n';
10542   strm << setw(indent-1) << setprecision(indent-2) << "}";
10543 }
10544 #endif
10545
10546
10547 PObject::Comparison H245_NewATMVCIndication_aal_aal5::Compare(const PObject & obj) const
10548 {
10549 #ifndef PASN_LEANANDMEAN
10550   PAssert(PIsDescendant(&obj, H245_NewATMVCIndication_aal_aal5), PInvalidCast);
10551 #endif
10552   const H245_NewATMVCIndication_aal_aal5 & other = (const H245_NewATMVCIndication_aal_aal5 &)obj;
10553
10554   Comparison result;
10555
10556   if ((result = m_forwardMaximumSDUSize.Compare(other.m_forwardMaximumSDUSize)) != EqualTo)
10557     return result;
10558   if ((result = m_backwardMaximumSDUSize.Compare(other.m_backwardMaximumSDUSize)) != EqualTo)
10559     return result;
10560
10561   return PASN_Sequence::Compare(other);
10562 }
10563
10564
10565 PINDEX H245_NewATMVCIndication_aal_aal5::GetDataLength() const
10566 {
10567   PINDEX length = 0;
10568   length += m_forwardMaximumSDUSize.GetObjectLength();
10569   length += m_backwardMaximumSDUSize.GetObjectLength();
10570   return length;
10571 }
10572
10573
10574 BOOL H245_NewATMVCIndication_aal_aal5::Decode(PASN_Stream & strm)
10575 {
10576   if (!PreambleDecode(strm))
10577     return FALSE;
10578
10579   if (!m_forwardMaximumSDUSize.Decode(strm))
10580     return FALSE;
10581   if (!m_backwardMaximumSDUSize.Decode(strm))
10582     return FALSE;
10583
10584   return UnknownExtensionsDecode(strm);
10585 }
10586
10587
10588 void H245_NewATMVCIndication_aal_aal5::Encode(PASN_Stream & strm) const
10589 {
10590   PreambleEncode(strm);
10591
10592   m_forwardMaximumSDUSize.Encode(strm);
10593   m_backwardMaximumSDUSize.Encode(strm);
10594
10595   UnknownExtensionsEncode(strm);
10596 }
10597
10598
10599 PObject * H245_NewATMVCIndication_aal_aal5::Clone() const
10600 {
10601 #ifndef PASN_LEANANDMEAN
10602   PAssert(IsClass(H245_NewATMVCIndication_aal_aal5::Class()), PInvalidCast);
10603 #endif
10604   return new H245_NewATMVCIndication_aal_aal5(*this);
10605 }
10606
10607
10608
10609 #ifndef PASN_NOPRINTON
10610 const static PASN_Names Names_H245_NewATMVCIndication_reverseParameters_multiplex[]={
10611       {"noMultiplex",0}
10612      ,{"transportStream",1}
10613      ,{"programStream",2}
10614 };
10615 #endif
10616 //
10617 // NewATMVCIndication_reverseParameters_multiplex
10618 //
10619
10620 H245_NewATMVCIndication_reverseParameters_multiplex::H245_NewATMVCIndication_reverseParameters_multiplex(unsigned tag, PASN_Object::TagClass tagClass)
10621   : PASN_Choice(tag, tagClass, 3, TRUE
10622 #ifndef PASN_NOPRINTON
10623     ,(const PASN_Names *)Names_H245_NewATMVCIndication_reverseParameters_multiplex,3
10624 #endif
10625 )
10626 {
10627 }
10628
10629
10630 BOOL H245_NewATMVCIndication_reverseParameters_multiplex::CreateObject()
10631 {
10632   choice = (tag <= e_programStream) ? new PASN_Null() : NULL;
10633   return choice != NULL;
10634 }
10635
10636
10637 PObject * H245_NewATMVCIndication_reverseParameters_multiplex::Clone() const
10638 {
10639 #ifndef PASN_LEANANDMEAN
10640   PAssert(IsClass(H245_NewATMVCIndication_reverseParameters_multiplex::Class()), PInvalidCast);
10641 #endif
10642   return new H245_NewATMVCIndication_reverseParameters_multiplex(*this);
10643 }
10644
10645
10646 //
10647 // UserInputIndication_signal_rtp
10648 //
10649
10650 H245_UserInputIndication_signal_rtp::H245_UserInputIndication_signal_rtp(unsigned tag, PASN_Object::TagClass tagClass)
10651   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
10652 {
10653   m_timestamp.SetConstraints(PASN_Object::FixedConstraint, 0, 4294967295U);
10654   m_expirationTime.SetConstraints(PASN_Object::FixedConstraint, 0, 4294967295U);
10655 }
10656
10657
10658 #ifndef PASN_NOPRINTON
10659 void H245_UserInputIndication_signal_rtp::PrintOn(ostream & strm) const
10660 {
10661   int indent = strm.precision() + 2;
10662   strm << "{\n";
10663   if (HasOptionalField(e_timestamp))
10664     strm << setw(indent+12) << "timestamp = " << setprecision(indent) << m_timestamp << '\n';
10665   if (HasOptionalField(e_expirationTime))
10666     strm << setw(indent+17) << "expirationTime = " << setprecision(indent) << m_expirationTime << '\n';
10667   strm << setw(indent+23) << "logicalChannelNumber = " << setprecision(indent) << m_logicalChannelNumber << '\n';
10668   strm << setw(indent-1) << setprecision(indent-2) << "}";
10669 }
10670 #endif
10671
10672
10673 PObject::Comparison H245_UserInputIndication_signal_rtp::Compare(const PObject & obj) const
10674 {
10675 #ifndef PASN_LEANANDMEAN
10676   PAssert(PIsDescendant(&obj, H245_UserInputIndication_signal_rtp), PInvalidCast);
10677 #endif
10678   const H245_UserInputIndication_signal_rtp & other = (const H245_UserInputIndication_signal_rtp &)obj;
10679
10680   Comparison result;
10681
10682   if ((result = m_timestamp.Compare(other.m_timestamp)) != EqualTo)
10683     return result;
10684   if ((result = m_expirationTime.Compare(other.m_expirationTime)) != EqualTo)
10685     return result;
10686   if ((result = m_logicalChannelNumber.Compare(other.m_logicalChannelNumber)) != EqualTo)
10687     return result;
10688
10689   return PASN_Sequence::Compare(other);
10690 }
10691
10692
10693 PINDEX H245_UserInputIndication_signal_rtp::GetDataLength() const
10694 {
10695   PINDEX length = 0;
10696   if (HasOptionalField(e_timestamp))
10697     length += m_timestamp.GetObjectLength();
10698   if (HasOptionalField(e_expirationTime))
10699     length += m_expirationTime.GetObjectLength();
10700   length += m_logicalChannelNumber.GetObjectLength();
10701   return length;
10702 }
10703
10704
10705 BOOL H245_UserInputIndication_signal_rtp::Decode(PASN_Stream & strm)
10706 {
10707   if (!PreambleDecode(strm))
10708     return FALSE;
10709
10710   if (HasOptionalField(e_timestamp) && !m_timestamp.Decode(strm))
10711     return FALSE;
10712   if (HasOptionalField(e_expirationTime) && !m_expirationTime.Decode(strm))
10713     return FALSE;
10714   if (!m_logicalChannelNumber.Decode(strm))
10715     return FALSE;
10716
10717   return UnknownExtensionsDecode(strm);
10718 }
10719
10720
10721 void H245_UserInputIndication_signal_rtp::Encode(PASN_Stream & strm) const
10722 {
10723   PreambleEncode(strm);
10724
10725   if (HasOptionalField(e_timestamp))
10726     m_timestamp.Encode(strm);
10727   if (HasOptionalField(e_expirationTime))
10728     m_expirationTime.Encode(strm);
10729   m_logicalChannelNumber.Encode(strm);
10730
10731   UnknownExtensionsEncode(strm);
10732 }
10733
10734
10735 PObject * H245_UserInputIndication_signal_rtp::Clone() const
10736 {
10737 #ifndef PASN_LEANANDMEAN
10738   PAssert(IsClass(H245_UserInputIndication_signal_rtp::Class()), PInvalidCast);
10739 #endif
10740   return new H245_UserInputIndication_signal_rtp(*this);
10741 }
10742
10743
10744 //
10745 // UserInputIndication_signalUpdate_rtp
10746 //
10747
10748 H245_UserInputIndication_signalUpdate_rtp::H245_UserInputIndication_signalUpdate_rtp(unsigned tag, PASN_Object::TagClass tagClass)
10749   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
10750 {
10751 }
10752
10753
10754 #ifndef PASN_NOPRINTON
10755 void H245_UserInputIndication_signalUpdate_rtp::PrintOn(ostream & strm) const
10756 {
10757   int indent = strm.precision() + 2;
10758   strm << "{\n";
10759   strm << setw(indent+23) << "logicalChannelNumber = " << setprecision(indent) << m_logicalChannelNumber << '\n';
10760   strm << setw(indent-1) << setprecision(indent-2) << "}";
10761 }
10762 #endif
10763
10764
10765 PObject::Comparison H245_UserInputIndication_signalUpdate_rtp::Compare(const PObject & obj) const
10766 {
10767 #ifndef PASN_LEANANDMEAN
10768   PAssert(PIsDescendant(&obj, H245_UserInputIndication_signalUpdate_rtp), PInvalidCast);
10769 #endif
10770   const H245_UserInputIndication_signalUpdate_rtp & other = (const H245_UserInputIndication_signalUpdate_rtp &)obj;
10771
10772   Comparison result;
10773
10774   if ((result = m_logicalChannelNumber.Compare(other.m_logicalChannelNumber)) != EqualTo)
10775     return result;
10776
10777   return PASN_Sequence::Compare(other);
10778 }
10779
10780
10781 PINDEX H245_UserInputIndication_signalUpdate_rtp::GetDataLength() const
10782 {
10783   PINDEX length = 0;
10784   length += m_logicalChannelNumber.GetObjectLength();
10785   return length;
10786 }
10787
10788
10789 BOOL H245_UserInputIndication_signalUpdate_rtp::Decode(PASN_Stream & strm)
10790 {
10791   if (!PreambleDecode(strm))
10792     return FALSE;
10793
10794   if (!m_logicalChannelNumber.Decode(strm))
10795     return FALSE;
10796
10797   return UnknownExtensionsDecode(strm);
10798 }
10799
10800
10801 void H245_UserInputIndication_signalUpdate_rtp::Encode(PASN_Stream & strm) const
10802 {
10803   PreambleEncode(strm);
10804
10805   m_logicalChannelNumber.Encode(strm);
10806
10807   UnknownExtensionsEncode(strm);
10808 }
10809
10810
10811 PObject * H245_UserInputIndication_signalUpdate_rtp::Clone() const
10812 {
10813 #ifndef PASN_LEANANDMEAN
10814   PAssert(IsClass(H245_UserInputIndication_signalUpdate_rtp::Class()), PInvalidCast);
10815 #endif
10816   return new H245_UserInputIndication_signalUpdate_rtp(*this);
10817 }
10818
10819
10820 //
10821 // UserInputIndication_extendedAlphanumeric_encryptedAlphanumeric
10822 //
10823
10824 H245_UserInputIndication_extendedAlphanumeric_encryptedAlphanumeric::H245_UserInputIndication_extendedAlphanumeric_encryptedAlphanumeric(unsigned tag, PASN_Object::TagClass tagClass)
10825   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
10826 {
10827 }
10828
10829
10830 #ifndef PASN_NOPRINTON
10831 void H245_UserInputIndication_extendedAlphanumeric_encryptedAlphanumeric::PrintOn(ostream & strm) const
10832 {
10833   int indent = strm.precision() + 2;
10834   strm << "{\n";
10835   strm << setw(indent+15) << "algorithmOID = " << setprecision(indent) << m_algorithmOID << '\n';
10836   if (HasOptionalField(e_paramS))
10837     strm << setw(indent+9) << "paramS = " << setprecision(indent) << m_paramS << '\n';
10838   strm << setw(indent+12) << "encrypted = " << setprecision(indent) << m_encrypted << '\n';
10839   strm << setw(indent-1) << setprecision(indent-2) << "}";
10840 }
10841 #endif
10842
10843
10844 PObject::Comparison H245_UserInputIndication_extendedAlphanumeric_encryptedAlphanumeric::Compare(const PObject & obj) const
10845 {
10846 #ifndef PASN_LEANANDMEAN
10847   PAssert(PIsDescendant(&obj, H245_UserInputIndication_extendedAlphanumeric_encryptedAlphanumeric), PInvalidCast);
10848 #endif
10849   const H245_UserInputIndication_extendedAlphanumeric_encryptedAlphanumeric & other = (const H245_UserInputIndication_extendedAlphanumeric_encryptedAlphanumeric &)obj;
10850
10851   Comparison result;
10852
10853   if ((result = m_algorithmOID.Compare(other.m_algorithmOID)) != EqualTo)
10854     return result;
10855   if ((result = m_paramS.Compare(other.m_paramS)) != EqualTo)
10856     return result;
10857   if ((result = m_encrypted.Compare(other.m_encrypted)) != EqualTo)
10858     return result;
10859
10860   return PASN_Sequence::Compare(other);
10861 }
10862
10863
10864 PINDEX H245_UserInputIndication_extendedAlphanumeric_encryptedAlphanumeric::GetDataLength() const
10865 {
10866   PINDEX length = 0;
10867   length += m_algorithmOID.GetObjectLength();
10868   if (HasOptionalField(e_paramS))
10869     length += m_paramS.GetObjectLength();
10870   length += m_encrypted.GetObjectLength();
10871   return length;
10872 }
10873
10874
10875 BOOL H245_UserInputIndication_extendedAlphanumeric_encryptedAlphanumeric::Decode(PASN_Stream & strm)
10876 {
10877   if (!PreambleDecode(strm))
10878     return FALSE;
10879
10880   if (!m_algorithmOID.Decode(strm))
10881     return FALSE;
10882   if (HasOptionalField(e_paramS) && !m_paramS.Decode(strm))
10883     return FALSE;
10884   if (!m_encrypted.Decode(strm))
10885     return FALSE;
10886
10887   return UnknownExtensionsDecode(strm);
10888 }
10889
10890
10891 void H245_UserInputIndication_extendedAlphanumeric_encryptedAlphanumeric::Encode(PASN_Stream & strm) const
10892 {
10893   PreambleEncode(strm);
10894
10895   m_algorithmOID.Encode(strm);
10896   if (HasOptionalField(e_paramS))
10897     m_paramS.Encode(strm);
10898   m_encrypted.Encode(strm);
10899
10900   UnknownExtensionsEncode(strm);
10901 }
10902
10903
10904 PObject * H245_UserInputIndication_extendedAlphanumeric_encryptedAlphanumeric::Clone() const
10905 {
10906 #ifndef PASN_LEANANDMEAN
10907   PAssert(IsClass(H245_UserInputIndication_extendedAlphanumeric_encryptedAlphanumeric::Class()), PInvalidCast);
10908 #endif
10909   return new H245_UserInputIndication_extendedAlphanumeric_encryptedAlphanumeric(*this);
10910 }
10911
10912
10913 //
10914 // VCCapability_availableBitRates_type_rangeOfBitRates
10915 //
10916
10917 H245_VCCapability_availableBitRates_type_rangeOfBitRates::H245_VCCapability_availableBitRates_type_rangeOfBitRates(unsigned tag, PASN_Object::TagClass tagClass)
10918   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
10919 {
10920   m_lowerBitRate.SetConstraints(PASN_Object::FixedConstraint, 1, 65535);
10921   m_higherBitRate.SetConstraints(PASN_Object::FixedConstraint, 1, 65535);
10922 }
10923
10924
10925 #ifndef PASN_NOPRINTON
10926 void H245_VCCapability_availableBitRates_type_rangeOfBitRates::PrintOn(ostream & strm) const
10927 {
10928   int indent = strm.precision() + 2;
10929   strm << "{\n";
10930   strm << setw(indent+15) << "lowerBitRate = " << setprecision(indent) << m_lowerBitRate << '\n';
10931   strm << setw(indent+16) << "higherBitRate = " << setprecision(indent) << m_higherBitRate << '\n';
10932   strm << setw(indent-1) << setprecision(indent-2) << "}";
10933 }
10934 #endif
10935
10936
10937 PObject::Comparison H245_VCCapability_availableBitRates_type_rangeOfBitRates::Compare(const PObject & obj) const
10938 {
10939 #ifndef PASN_LEANANDMEAN
10940   PAssert(PIsDescendant(&obj, H245_VCCapability_availableBitRates_type_rangeOfBitRates), PInvalidCast);
10941 #endif
10942   const H245_VCCapability_availableBitRates_type_rangeOfBitRates & other = (const H245_VCCapability_availableBitRates_type_rangeOfBitRates &)obj;
10943
10944   Comparison result;
10945
10946   if ((result = m_lowerBitRate.Compare(other.m_lowerBitRate)) != EqualTo)
10947     return result;
10948   if ((result = m_higherBitRate.Compare(other.m_higherBitRate)) != EqualTo)
10949     return result;
10950
10951   return PASN_Sequence::Compare(other);
10952 }
10953
10954
10955 PINDEX H245_VCCapability_availableBitRates_type_rangeOfBitRates::GetDataLength() const
10956 {
10957   PINDEX length = 0;
10958   length += m_lowerBitRate.GetObjectLength();
10959   length += m_higherBitRate.GetObjectLength();
10960   return length;
10961 }
10962
10963
10964 BOOL H245_VCCapability_availableBitRates_type_rangeOfBitRates::Decode(PASN_Stream & strm)
10965 {
10966   if (!PreambleDecode(strm))
10967     return FALSE;
10968
10969   if (!m_lowerBitRate.Decode(strm))
10970     return FALSE;
10971   if (!m_higherBitRate.Decode(strm))
10972     return FALSE;
10973
10974   return UnknownExtensionsDecode(strm);
10975 }
10976
10977
10978 void H245_VCCapability_availableBitRates_type_rangeOfBitRates::Encode(PASN_Stream & strm) const
10979 {
10980   PreambleEncode(strm);
10981
10982   m_lowerBitRate.Encode(strm);
10983   m_higherBitRate.Encode(strm);
10984
10985   UnknownExtensionsEncode(strm);
10986 }
10987
10988
10989 PObject * H245_VCCapability_availableBitRates_type_rangeOfBitRates::Clone() const
10990 {
10991 #ifndef PASN_LEANANDMEAN
10992   PAssert(IsClass(H245_VCCapability_availableBitRates_type_rangeOfBitRates::Class()), PInvalidCast);
10993 #endif
10994   return new H245_VCCapability_availableBitRates_type_rangeOfBitRates(*this);
10995 }
10996
10997
10998 //
10999 // CustomPictureFormat_mPI_customPCF_subtype
11000 //
11001
11002 H245_CustomPictureFormat_mPI_customPCF_subtype::H245_CustomPictureFormat_mPI_customPCF_subtype(unsigned tag, PASN_Object::TagClass tagClass)
11003   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
11004 {
11005   m_clockConversionCode.SetConstraints(PASN_Object::FixedConstraint, 1000, 1001);
11006   m_clockDivisor.SetConstraints(PASN_Object::FixedConstraint, 1, 127);
11007   m_customMPI.SetConstraints(PASN_Object::FixedConstraint, 1, 2048);
11008 }
11009
11010
11011 #ifndef PASN_NOPRINTON
11012 void H245_CustomPictureFormat_mPI_customPCF_subtype::PrintOn(ostream & strm) const
11013 {
11014   int indent = strm.precision() + 2;
11015   strm << "{\n";
11016   strm << setw(indent+22) << "clockConversionCode = " << setprecision(indent) << m_clockConversionCode << '\n';
11017   strm << setw(indent+15) << "clockDivisor = " << setprecision(indent) << m_clockDivisor << '\n';
11018   strm << setw(indent+12) << "customMPI = " << setprecision(indent) << m_customMPI << '\n';
11019   strm << setw(indent-1) << setprecision(indent-2) << "}";
11020 }
11021 #endif
11022
11023
11024 PObject::Comparison H245_CustomPictureFormat_mPI_customPCF_subtype::Compare(const PObject & obj) const
11025 {
11026 #ifndef PASN_LEANANDMEAN
11027   PAssert(PIsDescendant(&obj, H245_CustomPictureFormat_mPI_customPCF_subtype), PInvalidCast);
11028 #endif
11029   const H245_CustomPictureFormat_mPI_customPCF_subtype & other = (const H245_CustomPictureFormat_mPI_customPCF_subtype &)obj;
11030
11031   Comparison result;
11032
11033   if ((result = m_clockConversionCode.Compare(other.m_clockConversionCode)) != EqualTo)
11034     return result;
11035   if ((result = m_clockDivisor.Compare(other.m_clockDivisor)) != EqualTo)
11036     return result;
11037   if ((result = m_customMPI.Compare(other.m_customMPI)) != EqualTo)
11038     return result;
11039
11040   return PASN_Sequence::Compare(other);
11041 }
11042
11043
11044 PINDEX H245_CustomPictureFormat_mPI_customPCF_subtype::GetDataLength() const
11045 {
11046   PINDEX length = 0;
11047   length += m_clockConversionCode.GetObjectLength();
11048   length += m_clockDivisor.GetObjectLength();
11049   length += m_customMPI.GetObjectLength();
11050   return length;
11051 }
11052
11053
11054 BOOL H245_CustomPictureFormat_mPI_customPCF_subtype::Decode(PASN_Stream & strm)
11055 {
11056   if (!PreambleDecode(strm))
11057     return FALSE;
11058
11059   if (!m_clockConversionCode.Decode(strm))
11060     return FALSE;
11061   if (!m_clockDivisor.Decode(strm))
11062     return FALSE;
11063   if (!m_customMPI.Decode(strm))
11064     return FALSE;
11065
11066   return UnknownExtensionsDecode(strm);
11067 }
11068
11069
11070 void H245_CustomPictureFormat_mPI_customPCF_subtype::Encode(PASN_Stream & strm) const
11071 {
11072   PreambleEncode(strm);
11073
11074   m_clockConversionCode.Encode(strm);
11075   m_clockDivisor.Encode(strm);
11076   m_customMPI.Encode(strm);
11077
11078   UnknownExtensionsEncode(strm);
11079 }
11080
11081
11082 PObject * H245_CustomPictureFormat_mPI_customPCF_subtype::Clone() const
11083 {
11084 #ifndef PASN_LEANANDMEAN
11085   PAssert(IsClass(H245_CustomPictureFormat_mPI_customPCF_subtype::Class()), PInvalidCast);
11086 #endif
11087   return new H245_CustomPictureFormat_mPI_customPCF_subtype(*this);
11088 }
11089
11090
11091 //
11092 // CustomPictureFormat_pixelAspectInformation_extendedPAR_subtype
11093 //
11094
11095 H245_CustomPictureFormat_pixelAspectInformation_extendedPAR_subtype::H245_CustomPictureFormat_pixelAspectInformation_extendedPAR_subtype(unsigned tag, PASN_Object::TagClass tagClass)
11096   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
11097 {
11098   m_width.SetConstraints(PASN_Object::FixedConstraint, 1, 255);
11099   m_height.SetConstraints(PASN_Object::FixedConstraint, 1, 255);
11100 }
11101
11102
11103 #ifndef PASN_NOPRINTON
11104 void H245_CustomPictureFormat_pixelAspectInformation_extendedPAR_subtype::PrintOn(ostream & strm) const
11105 {
11106   int indent = strm.precision() + 2;
11107   strm << "{\n";
11108   strm << setw(indent+8) << "width = " << setprecision(indent) << m_width << '\n';
11109   strm << setw(indent+9) << "height = " << setprecision(indent) << m_height << '\n';
11110   strm << setw(indent-1) << setprecision(indent-2) << "}";
11111 }
11112 #endif
11113
11114
11115 PObject::Comparison H245_CustomPictureFormat_pixelAspectInformation_extendedPAR_subtype::Compare(const PObject & obj) const
11116 {
11117 #ifndef PASN_LEANANDMEAN
11118   PAssert(PIsDescendant(&obj, H245_CustomPictureFormat_pixelAspectInformation_extendedPAR_subtype), PInvalidCast);
11119 #endif
11120   const H245_CustomPictureFormat_pixelAspectInformation_extendedPAR_subtype & other = (const H245_CustomPictureFormat_pixelAspectInformation_extendedPAR_subtype &)obj;
11121
11122   Comparison result;
11123
11124   if ((result = m_width.Compare(other.m_width)) != EqualTo)
11125     return result;
11126   if ((result = m_height.Compare(other.m_height)) != EqualTo)
11127     return result;
11128
11129   return PASN_Sequence::Compare(other);
11130 }
11131
11132
11133 PINDEX H245_CustomPictureFormat_pixelAspectInformation_extendedPAR_subtype::GetDataLength() const
11134 {
11135   PINDEX length = 0;
11136   length += m_width.GetObjectLength();
11137   length += m_height.GetObjectLength();
11138   return length;
11139 }
11140
11141
11142 BOOL H245_CustomPictureFormat_pixelAspectInformation_extendedPAR_subtype::Decode(PASN_Stream & strm)
11143 {
11144   if (!PreambleDecode(strm))
11145     return FALSE;
11146
11147   if (!m_width.Decode(strm))
11148     return FALSE;
11149   if (!m_height.Decode(strm))
11150     return FALSE;
11151
11152   return UnknownExtensionsDecode(strm);
11153 }
11154
11155
11156 void H245_CustomPictureFormat_pixelAspectInformation_extendedPAR_subtype::Encode(PASN_Stream & strm) const
11157 {
11158   PreambleEncode(strm);
11159
11160   m_width.Encode(strm);
11161   m_height.Encode(strm);
11162
11163   UnknownExtensionsEncode(strm);
11164 }
11165
11166
11167 PObject * H245_CustomPictureFormat_pixelAspectInformation_extendedPAR_subtype::Clone() const
11168 {
11169 #ifndef PASN_LEANANDMEAN
11170   PAssert(IsClass(H245_CustomPictureFormat_pixelAspectInformation_extendedPAR_subtype::Class()), PInvalidCast);
11171 #endif
11172   return new H245_CustomPictureFormat_pixelAspectInformation_extendedPAR_subtype(*this);
11173 }
11174
11175
11176
11177 #ifndef PASN_NOPRINTON
11178 const static PASN_Names Names_H245_V76LogicalChannelParameters_mode_eRM_recovery[]={
11179       {"rej",0}
11180      ,{"sREJ",1}
11181      ,{"mSREJ",2}
11182 };
11183 #endif
11184 //
11185 // V76LogicalChannelParameters_mode_eRM_recovery
11186 //
11187
11188 H245_V76LogicalChannelParameters_mode_eRM_recovery::H245_V76LogicalChannelParameters_mode_eRM_recovery(unsigned tag, PASN_Object::TagClass tagClass)
11189   : PASN_Choice(tag, tagClass, 3, TRUE
11190 #ifndef PASN_NOPRINTON
11191     ,(const PASN_Names *)Names_H245_V76LogicalChannelParameters_mode_eRM_recovery,3
11192 #endif
11193 )
11194 {
11195 }
11196
11197
11198 BOOL H245_V76LogicalChannelParameters_mode_eRM_recovery::CreateObject()
11199 {
11200   choice = (tag <= e_mSREJ) ? new PASN_Null() : NULL;
11201   return choice != NULL;
11202 }
11203
11204
11205 PObject * H245_V76LogicalChannelParameters_mode_eRM_recovery::Clone() const
11206 {
11207 #ifndef PASN_LEANANDMEAN
11208   PAssert(IsClass(H245_V76LogicalChannelParameters_mode_eRM_recovery::Class()), PInvalidCast);
11209 #endif
11210   return new H245_V76LogicalChannelParameters_mode_eRM_recovery(*this);
11211 }
11212
11213
11214
11215 #ifndef PASN_NOPRINTON
11216 const static PASN_Names Names_H245_DepFECData_rfc2733_mode_separateStream[]={
11217       {"differentPort",0}
11218      ,{"samePort",1}
11219 };
11220 #endif
11221 //
11222 // DepFECData_rfc2733_mode_separateStream
11223 //
11224
11225 H245_DepFECData_rfc2733_mode_separateStream::H245_DepFECData_rfc2733_mode_separateStream(unsigned tag, PASN_Object::TagClass tagClass)
11226   : PASN_Choice(tag, tagClass, 2, TRUE
11227 #ifndef PASN_NOPRINTON
11228     ,(const PASN_Names *)Names_H245_DepFECData_rfc2733_mode_separateStream,2
11229 #endif
11230 )
11231 {
11232 }
11233
11234
11235 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
11236 H245_DepFECData_rfc2733_mode_separateStream::operator H245_DepFECData_rfc2733_mode_separateStream_differentPort &() const
11237 #else
11238 H245_DepFECData_rfc2733_mode_separateStream::operator H245_DepFECData_rfc2733_mode_separateStream_differentPort &()
11239 {
11240 #ifndef PASN_LEANANDMEAN
11241   PAssert(PIsDescendant(PAssertNULL(choice), H245_DepFECData_rfc2733_mode_separateStream_differentPort), PInvalidCast);
11242 #endif
11243   return *(H245_DepFECData_rfc2733_mode_separateStream_differentPort *)choice;
11244 }
11245
11246
11247 H245_DepFECData_rfc2733_mode_separateStream::operator const H245_DepFECData_rfc2733_mode_separateStream_differentPort &() const
11248 #endif
11249 {
11250 #ifndef PASN_LEANANDMEAN
11251   PAssert(PIsDescendant(PAssertNULL(choice), H245_DepFECData_rfc2733_mode_separateStream_differentPort), PInvalidCast);
11252 #endif
11253   return *(H245_DepFECData_rfc2733_mode_separateStream_differentPort *)choice;
11254 }
11255
11256
11257 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
11258 H245_DepFECData_rfc2733_mode_separateStream::operator H245_DepFECData_rfc2733_mode_separateStream_samePort &() const
11259 #else
11260 H245_DepFECData_rfc2733_mode_separateStream::operator H245_DepFECData_rfc2733_mode_separateStream_samePort &()
11261 {
11262 #ifndef PASN_LEANANDMEAN
11263   PAssert(PIsDescendant(PAssertNULL(choice), H245_DepFECData_rfc2733_mode_separateStream_samePort), PInvalidCast);
11264 #endif
11265   return *(H245_DepFECData_rfc2733_mode_separateStream_samePort *)choice;
11266 }
11267
11268
11269 H245_DepFECData_rfc2733_mode_separateStream::operator const H245_DepFECData_rfc2733_mode_separateStream_samePort &() const
11270 #endif
11271 {
11272 #ifndef PASN_LEANANDMEAN
11273   PAssert(PIsDescendant(PAssertNULL(choice), H245_DepFECData_rfc2733_mode_separateStream_samePort), PInvalidCast);
11274 #endif
11275   return *(H245_DepFECData_rfc2733_mode_separateStream_samePort *)choice;
11276 }
11277
11278
11279 BOOL H245_DepFECData_rfc2733_mode_separateStream::CreateObject()
11280 {
11281   switch (tag) {
11282     case e_differentPort :
11283       choice = new H245_DepFECData_rfc2733_mode_separateStream_differentPort();
11284       return TRUE;
11285     case e_samePort :
11286       choice = new H245_DepFECData_rfc2733_mode_separateStream_samePort();
11287       return TRUE;
11288   }
11289
11290   choice = NULL;
11291   return FALSE;
11292 }
11293
11294
11295 PObject * H245_DepFECData_rfc2733_mode_separateStream::Clone() const
11296 {
11297 #ifndef PASN_LEANANDMEAN
11298   PAssert(IsClass(H245_DepFECData_rfc2733_mode_separateStream::Class()), PInvalidCast);
11299 #endif
11300   return new H245_DepFECData_rfc2733_mode_separateStream(*this);
11301 }
11302
11303
11304 //
11305 // FECData_rfc2733_pktMode_rfc2733sameport
11306 //
11307
11308 H245_FECData_rfc2733_pktMode_rfc2733sameport::H245_FECData_rfc2733_pktMode_rfc2733sameport(unsigned tag, PASN_Object::TagClass tagClass)
11309   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
11310 {
11311 }
11312
11313
11314 #ifndef PASN_NOPRINTON
11315 void H245_FECData_rfc2733_pktMode_rfc2733sameport::PrintOn(ostream & strm) const
11316 {
11317   int indent = strm.precision() + 2;
11318   strm << "{\n";
11319   strm << setw(indent-1) << setprecision(indent-2) << "}";
11320 }
11321 #endif
11322
11323
11324 PINDEX H245_FECData_rfc2733_pktMode_rfc2733sameport::GetDataLength() const
11325 {
11326   PINDEX length = 0;
11327   return length;
11328 }
11329
11330
11331 BOOL H245_FECData_rfc2733_pktMode_rfc2733sameport::Decode(PASN_Stream & strm)
11332 {
11333   if (!PreambleDecode(strm))
11334     return FALSE;
11335
11336
11337   return UnknownExtensionsDecode(strm);
11338 }
11339
11340
11341 void H245_FECData_rfc2733_pktMode_rfc2733sameport::Encode(PASN_Stream & strm) const
11342 {
11343   PreambleEncode(strm);
11344
11345
11346   UnknownExtensionsEncode(strm);
11347 }
11348
11349
11350 PObject * H245_FECData_rfc2733_pktMode_rfc2733sameport::Clone() const
11351 {
11352 #ifndef PASN_LEANANDMEAN
11353   PAssert(IsClass(H245_FECData_rfc2733_pktMode_rfc2733sameport::Class()), PInvalidCast);
11354 #endif
11355   return new H245_FECData_rfc2733_pktMode_rfc2733sameport(*this);
11356 }
11357
11358
11359 #endif // if ! H323_DISABLE_H245
11360
11361
11362 // End of h245_2.cxx