Fix warning of Coverity Static analysis, change H225ProtocolIdentifier
[asterisk/asterisk.git] / addons / ooh323c / src / h323 / MULTIMEDIA-SYSTEM-CONTROLDec.c
1 /*
2  * Copyright (C) 2004-2005 by Objective Systems, Inc.
3  *
4  * This software is furnished under an open source license and may be 
5  * used and copied only in accordance with the terms of this license. 
6  * The text of the license may generally be found in the root 
7  * directory of this installation in the COPYING file.  It 
8  * can also be viewed online at the following URL:
9  *
10  *   http://www.obj-sys.com/open/license.html
11  *
12  * Any redistributions of this file including modified versions must 
13  * maintain this copyright notice.
14  *
15  *****************************************************************************/
16 /**
17  * This file was generated by the Objective Systems ASN1C Compiler
18  * (http://www.obj-sys.com).  Version: 5.72, Date: 22-Mar-2005.
19  */
20 #include "ooasn1.h"
21 #include "MULTIMEDIA-SYSTEM-CONTROL.h"
22 #include "eventHandler.h"
23
24 /**************************************************************/
25 /*                                                            */
26 /*  NonStandardIdentifier_h221NonStandard                     */
27 /*                                                            */
28 /**************************************************************/
29
30 EXTERN int asn1PD_H245NonStandardIdentifier_h221NonStandard (OOCTXT* pctxt, H245NonStandardIdentifier_h221NonStandard* pvalue)
31 {
32    int stat = ASN_OK;
33
34    /* decode t35CountryCode */
35
36    invokeStartElement (pctxt, "t35CountryCode", -1);
37
38    stat = decodeConsUInt8 (pctxt, &pvalue->t35CountryCode, 0U, 255U);
39    if (stat != ASN_OK) return stat;
40    invokeUIntValue (pctxt, pvalue->t35CountryCode);
41
42    invokeEndElement (pctxt, "t35CountryCode", -1);
43
44    /* decode t35Extension */
45
46    invokeStartElement (pctxt, "t35Extension", -1);
47
48    stat = decodeConsUInt8 (pctxt, &pvalue->t35Extension, 0U, 255U);
49    if (stat != ASN_OK) return stat;
50    invokeUIntValue (pctxt, pvalue->t35Extension);
51
52    invokeEndElement (pctxt, "t35Extension", -1);
53
54    /* decode manufacturerCode */
55
56    invokeStartElement (pctxt, "manufacturerCode", -1);
57
58    stat = decodeConsUInt16 (pctxt, &pvalue->manufacturerCode, 0U, 65535U);
59    if (stat != ASN_OK) return stat;
60    invokeUIntValue (pctxt, pvalue->manufacturerCode);
61
62    invokeEndElement (pctxt, "manufacturerCode", -1);
63
64    return (stat);
65 }
66
67 /**************************************************************/
68 /*                                                            */
69 /*  NonStandardIdentifier                                     */
70 /*                                                            */
71 /**************************************************************/
72
73 EXTERN int asn1PD_H245NonStandardIdentifier (OOCTXT* pctxt, H245NonStandardIdentifier* pvalue)
74 {
75    int stat = ASN_OK;
76    ASN1UINT ui;
77
78    stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
79    if (stat != ASN_OK) return stat;
80    else pvalue->t = ui + 1;
81
82    switch (ui) {
83       /* object */
84       case 0:
85          invokeStartElement (pctxt, "object", -1);
86
87          pvalue->u.object = ALLOC_ASN1ELEM (pctxt, ASN1OBJID);
88
89          stat = decodeObjectIdentifier (pctxt, pvalue->u.object);
90          if (stat != ASN_OK) return stat;
91          invokeOidValue (pctxt, pvalue->u.object->numids, pvalue->u.object->subid);
92
93          invokeEndElement (pctxt, "object", -1);
94
95          break;
96
97       /* h221NonStandard */
98       case 1:
99          invokeStartElement (pctxt, "h221NonStandard", -1);
100
101          pvalue->u.h221NonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardIdentifier_h221NonStandard);
102
103          stat = asn1PD_H245NonStandardIdentifier_h221NonStandard (pctxt, pvalue->u.h221NonStandard);
104          if (stat != ASN_OK) return stat;
105
106          invokeEndElement (pctxt, "h221NonStandard", -1);
107
108          break;
109
110       default:
111          return ASN_E_INVOPT;
112    }
113
114    return (stat);
115 }
116
117 /**************************************************************/
118 /*                                                            */
119 /*  NonStandardParameter                                      */
120 /*                                                            */
121 /**************************************************************/
122
123 EXTERN int asn1PD_H245NonStandardParameter (OOCTXT* pctxt, H245NonStandardParameter* pvalue)
124 {
125    int stat = ASN_OK;
126
127    /* decode nonStandardIdentifier */
128
129    invokeStartElement (pctxt, "nonStandardIdentifier", -1);
130
131    stat = asn1PD_H245NonStandardIdentifier (pctxt, &pvalue->nonStandardIdentifier);
132    if (stat != ASN_OK) return stat;
133
134    invokeEndElement (pctxt, "nonStandardIdentifier", -1);
135
136    /* decode data */
137
138    invokeStartElement (pctxt, "data", -1);
139
140    stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->data);
141    if (stat != ASN_OK) return stat;
142    invokeOctStrValue (pctxt, pvalue->data.numocts, pvalue->data.data);
143
144    invokeEndElement (pctxt, "data", -1);
145
146    return (stat);
147 }
148
149 /**************************************************************/
150 /*                                                            */
151 /*  V42bis                                                    */
152 /*                                                            */
153 /**************************************************************/
154
155 EXTERN int asn1PD_H245V42bis (OOCTXT* pctxt, H245V42bis* pvalue)
156 {
157    int stat = ASN_OK;
158    OOCTXT lctxt;
159    ASN1OpenType openType;
160    ASN1UINT bitcnt;
161    ASN1UINT i;
162    ASN1BOOL optbit = 0;
163    ASN1BOOL extbit = 0;
164
165    /* extension bit */
166
167    DECODEBIT (pctxt, &extbit);
168
169    /* decode numberOfCodewords */
170
171    invokeStartElement (pctxt, "numberOfCodewords", -1);
172
173    stat = decodeConsUnsigned (pctxt, &pvalue->numberOfCodewords, 1U, 65536U);
174    if (stat != ASN_OK) return stat;
175    invokeUIntValue (pctxt, pvalue->numberOfCodewords);
176
177    invokeEndElement (pctxt, "numberOfCodewords", -1);
178
179    /* decode maximumStringLength */
180
181    invokeStartElement (pctxt, "maximumStringLength", -1);
182
183    stat = decodeConsUInt16 (pctxt, &pvalue->maximumStringLength, 1U, 256U);
184    if (stat != ASN_OK) return stat;
185    invokeUIntValue (pctxt, pvalue->maximumStringLength);
186
187    invokeEndElement (pctxt, "maximumStringLength", -1);
188
189    if (extbit) {
190
191       /* decode extension optional bits length */
192
193       stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
194       if (stat != ASN_OK) return stat;
195
196       bitcnt += 1;
197
198       ZEROCONTEXT (&lctxt);
199       stat = setPERBufferUsingCtxt (&lctxt, pctxt);
200       if (stat != ASN_OK) return stat;
201
202       stat = moveBitCursor (pctxt, bitcnt);
203       if (stat != ASN_OK) return stat;
204
205       for (i = 0; i < bitcnt; i++) {
206          DECODEBIT (&lctxt, &optbit);
207
208          if (optbit) {
209             stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
210             if (stat != ASN_OK) return stat;
211
212             pctxt->buffer.byteIndex += openType.numocts;
213          }
214       }
215    }
216
217    return (stat);
218 }
219
220 /**************************************************************/
221 /*                                                            */
222 /*  CompressionType                                           */
223 /*                                                            */
224 /**************************************************************/
225
226 EXTERN int asn1PD_H245CompressionType (OOCTXT* pctxt, H245CompressionType* pvalue)
227 {
228    int stat = ASN_OK;
229    ASN1UINT ui;
230    ASN1OpenType openType;
231    ASN1BOOL extbit = 0;
232
233    /* extension bit */
234
235    DECODEBIT (pctxt, &extbit);
236
237    if (!extbit) {
238       stat = decodeConsUnsigned (pctxt, &ui, 0, 0);
239       if (stat != ASN_OK) return stat;
240       else pvalue->t = ui + 1;
241
242       switch (ui) {
243          /* v42bis */
244          case 0:
245             invokeStartElement (pctxt, "v42bis", -1);
246
247             pvalue->u.v42bis = ALLOC_ASN1ELEM (pctxt, H245V42bis);
248
249             stat = asn1PD_H245V42bis (pctxt, pvalue->u.v42bis);
250             if (stat != ASN_OK) return stat;
251
252             invokeEndElement (pctxt, "v42bis", -1);
253
254             break;
255
256          default:
257             return ASN_E_INVOPT;
258       }
259    }
260    else {
261       stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
262       if (stat != ASN_OK) return stat;
263       else pvalue->t = ui + 2;
264
265       stat = decodeByteAlign (pctxt);
266       if (stat != ASN_OK) return stat;
267
268       stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
269       if (stat != ASN_OK) return stat;
270
271    }
272
273    return (stat);
274 }
275
276 /**************************************************************/
277 /*                                                            */
278 /*  DataProtocolCapability_v76wCompression                    */
279 /*                                                            */
280 /**************************************************************/
281
282 EXTERN int asn1PD_H245DataProtocolCapability_v76wCompression (OOCTXT* pctxt, H245DataProtocolCapability_v76wCompression* pvalue)
283 {
284    int stat = ASN_OK;
285    ASN1UINT ui;
286    ASN1OpenType openType;
287    ASN1BOOL extbit = 0;
288
289    /* extension bit */
290
291    DECODEBIT (pctxt, &extbit);
292
293    if (!extbit) {
294       stat = decodeConsUnsigned (pctxt, &ui, 0, 2);
295       if (stat != ASN_OK) return stat;
296       else pvalue->t = ui + 1;
297
298       switch (ui) {
299          /* transmitCompression */
300          case 0:
301             invokeStartElement (pctxt, "transmitCompression", -1);
302
303             pvalue->u.transmitCompression = ALLOC_ASN1ELEM (pctxt, H245CompressionType);
304
305             stat = asn1PD_H245CompressionType (pctxt, pvalue->u.transmitCompression);
306             if (stat != ASN_OK) return stat;
307
308             invokeEndElement (pctxt, "transmitCompression", -1);
309
310             break;
311
312          /* receiveCompression */
313          case 1:
314             invokeStartElement (pctxt, "receiveCompression", -1);
315
316             pvalue->u.receiveCompression = ALLOC_ASN1ELEM (pctxt, H245CompressionType);
317
318             stat = asn1PD_H245CompressionType (pctxt, pvalue->u.receiveCompression);
319             if (stat != ASN_OK) return stat;
320
321             invokeEndElement (pctxt, "receiveCompression", -1);
322
323             break;
324
325          /* transmitAndReceiveCompression */
326          case 2:
327             invokeStartElement (pctxt, "transmitAndReceiveCompression", -1);
328
329             pvalue->u.transmitAndReceiveCompression = ALLOC_ASN1ELEM (pctxt, H245CompressionType);
330
331             stat = asn1PD_H245CompressionType (pctxt, pvalue->u.transmitAndReceiveCompression);
332             if (stat != ASN_OK) return stat;
333
334             invokeEndElement (pctxt, "transmitAndReceiveCompression", -1);
335
336             break;
337
338          default:
339             return ASN_E_INVOPT;
340       }
341    }
342    else {
343       stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
344       if (stat != ASN_OK) return stat;
345       else pvalue->t = ui + 4;
346
347       stat = decodeByteAlign (pctxt);
348       if (stat != ASN_OK) return stat;
349
350       stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
351       if (stat != ASN_OK) return stat;
352
353    }
354
355    return (stat);
356 }
357
358 /**************************************************************/
359 /*                                                            */
360 /*  DataProtocolCapability                                    */
361 /*                                                            */
362 /**************************************************************/
363
364 EXTERN int asn1PD_H245DataProtocolCapability (OOCTXT* pctxt, H245DataProtocolCapability* pvalue)
365 {
366    int stat = ASN_OK;
367    ASN1UINT ui;
368    ASN1OpenType openType;
369    ASN1BOOL extbit = 0;
370    OOCTXT lctxt;
371
372    /* extension bit */
373
374    DECODEBIT (pctxt, &extbit);
375
376    if (!extbit) {
377       stat = decodeConsUnsigned (pctxt, &ui, 0, 6);
378       if (stat != ASN_OK) return stat;
379       else pvalue->t = ui + 1;
380
381       switch (ui) {
382          /* nonStandard */
383          case 0:
384             invokeStartElement (pctxt, "nonStandard", -1);
385
386             pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter);
387
388             stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard);
389             if (stat != ASN_OK) return stat;
390
391             invokeEndElement (pctxt, "nonStandard", -1);
392
393             break;
394
395          /* v14buffered */
396          case 1:
397             invokeStartElement (pctxt, "v14buffered", -1);
398
399             /* NULL */
400             invokeNullValue (pctxt);
401
402             invokeEndElement (pctxt, "v14buffered", -1);
403
404             break;
405
406          /* v42lapm */
407          case 2:
408             invokeStartElement (pctxt, "v42lapm", -1);
409
410             /* NULL */
411             invokeNullValue (pctxt);
412
413             invokeEndElement (pctxt, "v42lapm", -1);
414
415             break;
416
417          /* hdlcFrameTunnelling */
418          case 3:
419             invokeStartElement (pctxt, "hdlcFrameTunnelling", -1);
420
421             /* NULL */
422             invokeNullValue (pctxt);
423
424             invokeEndElement (pctxt, "hdlcFrameTunnelling", -1);
425
426             break;
427
428          /* h310SeparateVCStack */
429          case 4:
430             invokeStartElement (pctxt, "h310SeparateVCStack", -1);
431
432             /* NULL */
433             invokeNullValue (pctxt);
434
435             invokeEndElement (pctxt, "h310SeparateVCStack", -1);
436
437             break;
438
439          /* h310SingleVCStack */
440          case 5:
441             invokeStartElement (pctxt, "h310SingleVCStack", -1);
442
443             /* NULL */
444             invokeNullValue (pctxt);
445
446             invokeEndElement (pctxt, "h310SingleVCStack", -1);
447
448             break;
449
450          /* transparent */
451          case 6:
452             invokeStartElement (pctxt, "transparent", -1);
453
454             /* NULL */
455             invokeNullValue (pctxt);
456
457             invokeEndElement (pctxt, "transparent", -1);
458
459             break;
460
461          default:
462             return ASN_E_INVOPT;
463       }
464    }
465    else {
466       stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
467       if (stat != ASN_OK) return stat;
468       else pvalue->t = ui + 8;
469
470       stat = decodeByteAlign (pctxt);
471       if (stat != ASN_OK) return stat;
472
473       stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
474       if (stat != ASN_OK) return stat;
475
476       copyContext (&lctxt, pctxt);
477       initContextBuffer (pctxt, openType.data, openType.numocts);
478
479       switch (pvalue->t) {
480          /* segmentationAndReassembly */
481          case 8:
482             invokeStartElement (pctxt, "segmentationAndReassembly", -1);
483
484             /* NULL */
485             invokeNullValue (pctxt);
486
487             invokeEndElement (pctxt, "segmentationAndReassembly", -1);
488
489             break;
490
491          /* hdlcFrameTunnelingwSAR */
492          case 9:
493             invokeStartElement (pctxt, "hdlcFrameTunnelingwSAR", -1);
494
495             /* NULL */
496             invokeNullValue (pctxt);
497
498             invokeEndElement (pctxt, "hdlcFrameTunnelingwSAR", -1);
499
500             break;
501
502          /* v120 */
503          case 10:
504             invokeStartElement (pctxt, "v120", -1);
505
506             /* NULL */
507             invokeNullValue (pctxt);
508
509             invokeEndElement (pctxt, "v120", -1);
510
511             break;
512
513          /* separateLANStack */
514          case 11:
515             invokeStartElement (pctxt, "separateLANStack", -1);
516
517             /* NULL */
518             invokeNullValue (pctxt);
519
520             invokeEndElement (pctxt, "separateLANStack", -1);
521
522             break;
523
524          /* v76wCompression */
525          case 12:
526             invokeStartElement (pctxt, "v76wCompression", -1);
527
528             pvalue->u.v76wCompression = ALLOC_ASN1ELEM (pctxt, H245DataProtocolCapability_v76wCompression);
529
530             stat = asn1PD_H245DataProtocolCapability_v76wCompression (pctxt, pvalue->u.v76wCompression);
531             if (stat != ASN_OK) return stat;
532
533             invokeEndElement (pctxt, "v76wCompression", -1);
534
535             break;
536
537          /* tcp */
538          case 13:
539             invokeStartElement (pctxt, "tcp", -1);
540
541             /* NULL */
542             invokeNullValue (pctxt);
543
544             invokeEndElement (pctxt, "tcp", -1);
545
546             break;
547
548          /* udp */
549          case 14:
550             invokeStartElement (pctxt, "udp", -1);
551
552             /* NULL */
553             invokeNullValue (pctxt);
554
555             invokeEndElement (pctxt, "udp", -1);
556
557             break;
558
559          default:;
560       }
561
562       copyContext (pctxt, &lctxt);
563    }
564
565    return (stat);
566 }
567
568 /**************************************************************/
569 /*                                                            */
570 /*  T38FaxRateManagement                                      */
571 /*                                                            */
572 /**************************************************************/
573
574 EXTERN int asn1PD_H245T38FaxRateManagement (OOCTXT* pctxt, H245T38FaxRateManagement* pvalue)
575 {
576    int stat = ASN_OK;
577    ASN1UINT ui;
578    ASN1OpenType openType;
579    ASN1BOOL extbit = 0;
580
581    /* extension bit */
582
583    DECODEBIT (pctxt, &extbit);
584
585    if (!extbit) {
586       stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
587       if (stat != ASN_OK) return stat;
588       else pvalue->t = ui + 1;
589
590       switch (ui) {
591          /* localTCF */
592          case 0:
593             invokeStartElement (pctxt, "localTCF", -1);
594
595             /* NULL */
596             invokeNullValue (pctxt);
597
598             invokeEndElement (pctxt, "localTCF", -1);
599
600             break;
601
602          /* transferredTCF */
603          case 1:
604             invokeStartElement (pctxt, "transferredTCF", -1);
605
606             /* NULL */
607             invokeNullValue (pctxt);
608
609             invokeEndElement (pctxt, "transferredTCF", -1);
610
611             break;
612
613          default:
614             return ASN_E_INVOPT;
615       }
616    }
617    else {
618       stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
619       if (stat != ASN_OK) return stat;
620       else pvalue->t = ui + 3;
621
622       stat = decodeByteAlign (pctxt);
623       if (stat != ASN_OK) return stat;
624
625       stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
626       if (stat != ASN_OK) return stat;
627
628    }
629
630    return (stat);
631 }
632
633 /**************************************************************/
634 /*                                                            */
635 /*  T38FaxUdpOptions_t38FaxUdpEC                              */
636 /*                                                            */
637 /**************************************************************/
638
639 EXTERN int asn1PD_H245T38FaxUdpOptions_t38FaxUdpEC (OOCTXT* pctxt, H245T38FaxUdpOptions_t38FaxUdpEC* pvalue)
640 {
641    int stat = ASN_OK;
642    ASN1UINT ui;
643    ASN1OpenType openType;
644    ASN1BOOL extbit = 0;
645
646    /* extension bit */
647
648    DECODEBIT (pctxt, &extbit);
649
650    if (!extbit) {
651       stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
652       if (stat != ASN_OK) return stat;
653       else pvalue->t = ui + 1;
654
655       switch (ui) {
656          /* t38UDPFEC */
657          case 0:
658             invokeStartElement (pctxt, "t38UDPFEC", -1);
659
660             /* NULL */
661             invokeNullValue (pctxt);
662
663             invokeEndElement (pctxt, "t38UDPFEC", -1);
664
665             break;
666
667          /* t38UDPRedundancy */
668          case 1:
669             invokeStartElement (pctxt, "t38UDPRedundancy", -1);
670
671             /* NULL */
672             invokeNullValue (pctxt);
673
674             invokeEndElement (pctxt, "t38UDPRedundancy", -1);
675
676             break;
677
678          default:
679             return ASN_E_INVOPT;
680       }
681    }
682    else {
683       stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
684       if (stat != ASN_OK) return stat;
685       else pvalue->t = ui + 3;
686
687       stat = decodeByteAlign (pctxt);
688       if (stat != ASN_OK) return stat;
689
690       stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
691       if (stat != ASN_OK) return stat;
692
693    }
694
695    return (stat);
696 }
697
698 /**************************************************************/
699 /*                                                            */
700 /*  T38FaxUdpOptions                                          */
701 /*                                                            */
702 /**************************************************************/
703
704 EXTERN int asn1PD_H245T38FaxUdpOptions (OOCTXT* pctxt, H245T38FaxUdpOptions* pvalue)
705 {
706    int stat = ASN_OK;
707    ASN1BOOL optbit = 0;
708
709    /* optional bits */
710
711    memset (&pvalue->m, 0, sizeof(pvalue->m));
712
713    DECODEBIT (pctxt, &optbit);
714    pvalue->m.t38FaxMaxBufferPresent = optbit;
715
716    DECODEBIT (pctxt, &optbit);
717    pvalue->m.t38FaxMaxDatagramPresent = optbit;
718
719    /* decode t38FaxMaxBuffer */
720
721    if (pvalue->m.t38FaxMaxBufferPresent) {
722       invokeStartElement (pctxt, "t38FaxMaxBuffer", -1);
723
724       stat = decodeUnconsInteger (pctxt, &pvalue->t38FaxMaxBuffer);
725       if (stat != ASN_OK) return stat;
726       invokeIntValue (pctxt, pvalue->t38FaxMaxBuffer);
727
728       invokeEndElement (pctxt, "t38FaxMaxBuffer", -1);
729    }
730
731    /* decode t38FaxMaxDatagram */
732
733    if (pvalue->m.t38FaxMaxDatagramPresent) {
734       invokeStartElement (pctxt, "t38FaxMaxDatagram", -1);
735
736       stat = decodeUnconsInteger (pctxt, &pvalue->t38FaxMaxDatagram);
737       if (stat != ASN_OK) return stat;
738       invokeIntValue (pctxt, pvalue->t38FaxMaxDatagram);
739
740       invokeEndElement (pctxt, "t38FaxMaxDatagram", -1);
741    }
742
743    /* decode t38FaxUdpEC */
744
745    invokeStartElement (pctxt, "t38FaxUdpEC", -1);
746
747    stat = asn1PD_H245T38FaxUdpOptions_t38FaxUdpEC (pctxt, &pvalue->t38FaxUdpEC);
748    if (stat != ASN_OK) return stat;
749
750    invokeEndElement (pctxt, "t38FaxUdpEC", -1);
751
752    return (stat);
753 }
754
755 /**************************************************************/
756 /*                                                            */
757 /*  T38FaxTcpOptions                                          */
758 /*                                                            */
759 /**************************************************************/
760
761 EXTERN int asn1PD_H245T38FaxTcpOptions (OOCTXT* pctxt, H245T38FaxTcpOptions* pvalue)
762 {
763    int stat = ASN_OK;
764    OOCTXT lctxt;
765    ASN1OpenType openType;
766    ASN1UINT bitcnt;
767    ASN1UINT i;
768    ASN1BOOL optbit = 0;
769    ASN1BOOL extbit = 0;
770
771    /* extension bit */
772
773    DECODEBIT (pctxt, &extbit);
774
775    /* decode t38TCPBidirectionalMode */
776
777    invokeStartElement (pctxt, "t38TCPBidirectionalMode", -1);
778
779    stat = DECODEBIT (pctxt, &pvalue->t38TCPBidirectionalMode);
780    if (stat != ASN_OK) return stat;
781    invokeBoolValue (pctxt, pvalue->t38TCPBidirectionalMode);
782
783    invokeEndElement (pctxt, "t38TCPBidirectionalMode", -1);
784
785    if (extbit) {
786
787       /* decode extension optional bits length */
788
789       stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
790       if (stat != ASN_OK) return stat;
791
792       bitcnt += 1;
793
794       ZEROCONTEXT (&lctxt);
795       stat = setPERBufferUsingCtxt (&lctxt, pctxt);
796       if (stat != ASN_OK) return stat;
797
798       stat = moveBitCursor (pctxt, bitcnt);
799       if (stat != ASN_OK) return stat;
800
801       for (i = 0; i < bitcnt; i++) {
802          DECODEBIT (&lctxt, &optbit);
803
804          if (optbit) {
805             stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
806             if (stat != ASN_OK) return stat;
807
808             pctxt->buffer.byteIndex += openType.numocts;
809          }
810       }
811    }
812
813    return (stat);
814 }
815
816 /**************************************************************/
817 /*                                                            */
818 /*  T38FaxProfile                                             */
819 /*                                                            */
820 /**************************************************************/
821
822 EXTERN int asn1PD_H245T38FaxProfile (OOCTXT* pctxt, H245T38FaxProfile* pvalue)
823 {
824    int stat = ASN_OK;
825    OOCTXT lctxt;
826    OOCTXT lctxt2;
827    ASN1OpenType openType;
828    ASN1UINT bitcnt;
829    ASN1UINT i;
830    ASN1BOOL optbit = 0;
831    ASN1BOOL extbit = 0;
832
833    /* extension bit */
834
835    DECODEBIT (pctxt, &extbit);
836
837    /* optional bits */
838
839    memset (&pvalue->m, 0, sizeof(pvalue->m));
840
841    /* decode fillBitRemoval */
842
843    invokeStartElement (pctxt, "fillBitRemoval", -1);
844
845    stat = DECODEBIT (pctxt, &pvalue->fillBitRemoval);
846    if (stat != ASN_OK) return stat;
847    invokeBoolValue (pctxt, pvalue->fillBitRemoval);
848
849    invokeEndElement (pctxt, "fillBitRemoval", -1);
850
851    /* decode transcodingJBIG */
852
853    invokeStartElement (pctxt, "transcodingJBIG", -1);
854
855    stat = DECODEBIT (pctxt, &pvalue->transcodingJBIG);
856    if (stat != ASN_OK) return stat;
857    invokeBoolValue (pctxt, pvalue->transcodingJBIG);
858
859    invokeEndElement (pctxt, "transcodingJBIG", -1);
860
861    /* decode transcodingMMR */
862
863    invokeStartElement (pctxt, "transcodingMMR", -1);
864
865    stat = DECODEBIT (pctxt, &pvalue->transcodingMMR);
866    if (stat != ASN_OK) return stat;
867    invokeBoolValue (pctxt, pvalue->transcodingMMR);
868
869    invokeEndElement (pctxt, "transcodingMMR", -1);
870
871    if (extbit) {
872
873       /* decode extension optional bits length */
874
875       stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
876       if (stat != ASN_OK) return stat;
877
878       bitcnt += 1;
879
880       ZEROCONTEXT (&lctxt);
881       stat = setPERBufferUsingCtxt (&lctxt, pctxt);
882       if (stat != ASN_OK) return stat;
883
884       stat = moveBitCursor (pctxt, bitcnt);
885       if (stat != ASN_OK) return stat;
886
887       for (i = 0; i < bitcnt; i++) {
888          DECODEBIT (&lctxt, &optbit);
889
890          if (optbit) {
891             stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
892             if (stat != ASN_OK) return stat;
893
894             if (i < 4 && openType.numocts > 0) {  /* known element */
895                copyContext (&lctxt2, pctxt);
896                initContextBuffer (pctxt, openType.data, openType.numocts);
897
898                switch (i) {
899                   case 0:
900                      pvalue->m.versionPresent = 1;
901
902                      invokeStartElement (pctxt, "version", -1);
903
904                      stat = decodeConsUInt8 (pctxt, &pvalue->version, 0U, 255U);
905                      if (stat != ASN_OK) return stat;
906                      invokeUIntValue (pctxt, pvalue->version);
907
908                      invokeEndElement (pctxt, "version", -1);
909                      break;
910
911                   case 1:
912                      pvalue->m.t38FaxRateManagementPresent = 1;
913
914                      invokeStartElement (pctxt, "t38FaxRateManagement", -1);
915
916                      stat = asn1PD_H245T38FaxRateManagement (pctxt, &pvalue->t38FaxRateManagement);
917                      if (stat != ASN_OK) return stat;
918
919                      invokeEndElement (pctxt, "t38FaxRateManagement", -1);
920                      break;
921
922                   case 2:
923                      pvalue->m.t38FaxUdpOptionsPresent = 1;
924
925                      invokeStartElement (pctxt, "t38FaxUdpOptions", -1);
926
927                      stat = asn1PD_H245T38FaxUdpOptions (pctxt, &pvalue->t38FaxUdpOptions);
928                      if (stat != ASN_OK) return stat;
929
930                      invokeEndElement (pctxt, "t38FaxUdpOptions", -1);
931                      break;
932
933                   case 3:
934                      pvalue->m.t38FaxTcpOptionsPresent = 1;
935
936                      invokeStartElement (pctxt, "t38FaxTcpOptions", -1);
937
938                      stat = asn1PD_H245T38FaxTcpOptions (pctxt, &pvalue->t38FaxTcpOptions);
939                      if (stat != ASN_OK) return stat;
940
941                      invokeEndElement (pctxt, "t38FaxTcpOptions", -1);
942                      break;
943
944                   default:
945                      pctxt->buffer.byteIndex += openType.numocts;
946                }
947                copyContext (pctxt, &lctxt2);
948             }
949             else {  /* unknown element */
950                pctxt->buffer.byteIndex += openType.numocts;
951             }
952          }
953       }
954    }
955
956    return (stat);
957 }
958
959 /**************************************************************/
960 /*                                                            */
961 /*  NonStandardMessage                                        */
962 /*                                                            */
963 /**************************************************************/
964
965 EXTERN int asn1PD_H245NonStandardMessage (OOCTXT* pctxt, H245NonStandardMessage* pvalue)
966 {
967    int stat = ASN_OK;
968    OOCTXT lctxt;
969    ASN1OpenType openType;
970    ASN1UINT bitcnt;
971    ASN1UINT i;
972    ASN1BOOL optbit = 0;
973    ASN1BOOL extbit = 0;
974
975    /* extension bit */
976
977    DECODEBIT (pctxt, &extbit);
978
979    /* decode nonStandardData */
980
981    invokeStartElement (pctxt, "nonStandardData", -1);
982
983    stat = asn1PD_H245NonStandardParameter (pctxt, &pvalue->nonStandardData);
984    if (stat != ASN_OK) return stat;
985
986    invokeEndElement (pctxt, "nonStandardData", -1);
987
988    if (extbit) {
989
990       /* decode extension optional bits length */
991
992       stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
993       if (stat != ASN_OK) return stat;
994
995       bitcnt += 1;
996
997       ZEROCONTEXT (&lctxt);
998       stat = setPERBufferUsingCtxt (&lctxt, pctxt);
999       if (stat != ASN_OK) return stat;
1000
1001       stat = moveBitCursor (pctxt, bitcnt);
1002       if (stat != ASN_OK) return stat;
1003
1004       for (i = 0; i < bitcnt; i++) {
1005          DECODEBIT (&lctxt, &optbit);
1006
1007          if (optbit) {
1008             stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
1009             if (stat != ASN_OK) return stat;
1010
1011             pctxt->buffer.byteIndex += openType.numocts;
1012          }
1013       }
1014    }
1015
1016    return (stat);
1017 }
1018
1019 /**************************************************************/
1020 /*                                                            */
1021 /*  MasterSlaveDetermination                                  */
1022 /*                                                            */
1023 /**************************************************************/
1024
1025 EXTERN int asn1PD_H245MasterSlaveDetermination (OOCTXT* pctxt, H245MasterSlaveDetermination* pvalue)
1026 {
1027    int stat = ASN_OK;
1028    OOCTXT lctxt;
1029    ASN1OpenType openType;
1030    ASN1UINT bitcnt;
1031    ASN1UINT i;
1032    ASN1BOOL optbit = 0;
1033    ASN1BOOL extbit = 0;
1034
1035    /* extension bit */
1036
1037    DECODEBIT (pctxt, &extbit);
1038
1039    /* decode terminalType */
1040
1041    invokeStartElement (pctxt, "terminalType", -1);
1042
1043    stat = decodeConsUInt8 (pctxt, &pvalue->terminalType, 0U, 255U);
1044    if (stat != ASN_OK) return stat;
1045    invokeUIntValue (pctxt, pvalue->terminalType);
1046
1047    invokeEndElement (pctxt, "terminalType", -1);
1048
1049    /* decode statusDeterminationNumber */
1050
1051    invokeStartElement (pctxt, "statusDeterminationNumber", -1);
1052
1053    stat = decodeConsUnsigned (pctxt, &pvalue->statusDeterminationNumber, 0U, 16777215U);
1054    if (stat != ASN_OK) return stat;
1055    invokeUIntValue (pctxt, pvalue->statusDeterminationNumber);
1056
1057    invokeEndElement (pctxt, "statusDeterminationNumber", -1);
1058
1059    if (extbit) {
1060
1061       /* decode extension optional bits length */
1062
1063       stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
1064       if (stat != ASN_OK) return stat;
1065
1066       bitcnt += 1;
1067
1068       ZEROCONTEXT (&lctxt);
1069       stat = setPERBufferUsingCtxt (&lctxt, pctxt);
1070       if (stat != ASN_OK) return stat;
1071
1072       stat = moveBitCursor (pctxt, bitcnt);
1073       if (stat != ASN_OK) return stat;
1074
1075       for (i = 0; i < bitcnt; i++) {
1076          DECODEBIT (&lctxt, &optbit);
1077
1078          if (optbit) {
1079             stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
1080             if (stat != ASN_OK) return stat;
1081
1082             pctxt->buffer.byteIndex += openType.numocts;
1083          }
1084       }
1085    }
1086
1087    return (stat);
1088 }
1089
1090 /**************************************************************/
1091 /*                                                            */
1092 /*  SequenceNumber                                            */
1093 /*                                                            */
1094 /**************************************************************/
1095
1096 EXTERN int asn1PD_H245SequenceNumber (OOCTXT* pctxt, H245SequenceNumber* pvalue)
1097 {
1098    int stat = ASN_OK;
1099
1100    stat = decodeConsUInt8 (pctxt, pvalue, 0U, 255U);
1101    if (stat != ASN_OK) return stat;
1102    invokeUIntValue (pctxt, *pvalue);
1103
1104    return (stat);
1105 }
1106
1107 /**************************************************************/
1108 /*                                                            */
1109 /*  VCCapability_aal1                                         */
1110 /*                                                            */
1111 /**************************************************************/
1112
1113 EXTERN int asn1PD_H245VCCapability_aal1 (OOCTXT* pctxt, H245VCCapability_aal1* pvalue)
1114 {
1115    int stat = ASN_OK;
1116    OOCTXT lctxt;
1117    ASN1OpenType openType;
1118    ASN1UINT bitcnt;
1119    ASN1UINT i;
1120    ASN1BOOL optbit = 0;
1121    ASN1BOOL extbit = 0;
1122
1123    /* extension bit */
1124
1125    DECODEBIT (pctxt, &extbit);
1126
1127    /* decode nullClockRecovery */
1128
1129    invokeStartElement (pctxt, "nullClockRecovery", -1);
1130
1131    stat = DECODEBIT (pctxt, &pvalue->nullClockRecovery);
1132    if (stat != ASN_OK) return stat;
1133    invokeBoolValue (pctxt, pvalue->nullClockRecovery);
1134
1135    invokeEndElement (pctxt, "nullClockRecovery", -1);
1136
1137    /* decode srtsClockRecovery */
1138
1139    invokeStartElement (pctxt, "srtsClockRecovery", -1);
1140
1141    stat = DECODEBIT (pctxt, &pvalue->srtsClockRecovery);
1142    if (stat != ASN_OK) return stat;
1143    invokeBoolValue (pctxt, pvalue->srtsClockRecovery);
1144
1145    invokeEndElement (pctxt, "srtsClockRecovery", -1);
1146
1147    /* decode adaptiveClockRecovery */
1148
1149    invokeStartElement (pctxt, "adaptiveClockRecovery", -1);
1150
1151    stat = DECODEBIT (pctxt, &pvalue->adaptiveClockRecovery);
1152    if (stat != ASN_OK) return stat;
1153    invokeBoolValue (pctxt, pvalue->adaptiveClockRecovery);
1154
1155    invokeEndElement (pctxt, "adaptiveClockRecovery", -1);
1156
1157    /* decode nullErrorCorrection */
1158
1159    invokeStartElement (pctxt, "nullErrorCorrection", -1);
1160
1161    stat = DECODEBIT (pctxt, &pvalue->nullErrorCorrection);
1162    if (stat != ASN_OK) return stat;
1163    invokeBoolValue (pctxt, pvalue->nullErrorCorrection);
1164
1165    invokeEndElement (pctxt, "nullErrorCorrection", -1);
1166
1167    /* decode longInterleaver */
1168
1169    invokeStartElement (pctxt, "longInterleaver", -1);
1170
1171    stat = DECODEBIT (pctxt, &pvalue->longInterleaver);
1172    if (stat != ASN_OK) return stat;
1173    invokeBoolValue (pctxt, pvalue->longInterleaver);
1174
1175    invokeEndElement (pctxt, "longInterleaver", -1);
1176
1177    /* decode shortInterleaver */
1178
1179    invokeStartElement (pctxt, "shortInterleaver", -1);
1180
1181    stat = DECODEBIT (pctxt, &pvalue->shortInterleaver);
1182    if (stat != ASN_OK) return stat;
1183    invokeBoolValue (pctxt, pvalue->shortInterleaver);
1184
1185    invokeEndElement (pctxt, "shortInterleaver", -1);
1186
1187    /* decode errorCorrectionOnly */
1188
1189    invokeStartElement (pctxt, "errorCorrectionOnly", -1);
1190
1191    stat = DECODEBIT (pctxt, &pvalue->errorCorrectionOnly);
1192    if (stat != ASN_OK) return stat;
1193    invokeBoolValue (pctxt, pvalue->errorCorrectionOnly);
1194
1195    invokeEndElement (pctxt, "errorCorrectionOnly", -1);
1196
1197    /* decode structuredDataTransfer */
1198
1199    invokeStartElement (pctxt, "structuredDataTransfer", -1);
1200
1201    stat = DECODEBIT (pctxt, &pvalue->structuredDataTransfer);
1202    if (stat != ASN_OK) return stat;
1203    invokeBoolValue (pctxt, pvalue->structuredDataTransfer);
1204
1205    invokeEndElement (pctxt, "structuredDataTransfer", -1);
1206
1207    /* decode partiallyFilledCells */
1208
1209    invokeStartElement (pctxt, "partiallyFilledCells", -1);
1210
1211    stat = DECODEBIT (pctxt, &pvalue->partiallyFilledCells);
1212    if (stat != ASN_OK) return stat;
1213    invokeBoolValue (pctxt, pvalue->partiallyFilledCells);
1214
1215    invokeEndElement (pctxt, "partiallyFilledCells", -1);
1216
1217    if (extbit) {
1218
1219       /* decode extension optional bits length */
1220
1221       stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
1222       if (stat != ASN_OK) return stat;
1223
1224       bitcnt += 1;
1225
1226       ZEROCONTEXT (&lctxt);
1227       stat = setPERBufferUsingCtxt (&lctxt, pctxt);
1228       if (stat != ASN_OK) return stat;
1229
1230       stat = moveBitCursor (pctxt, bitcnt);
1231       if (stat != ASN_OK) return stat;
1232
1233       for (i = 0; i < bitcnt; i++) {
1234          DECODEBIT (&lctxt, &optbit);
1235
1236          if (optbit) {
1237             stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
1238             if (stat != ASN_OK) return stat;
1239
1240             pctxt->buffer.byteIndex += openType.numocts;
1241          }
1242       }
1243    }
1244
1245    return (stat);
1246 }
1247
1248 /**************************************************************/
1249 /*                                                            */
1250 /*  VCCapability_aal5                                         */
1251 /*                                                            */
1252 /**************************************************************/
1253
1254 EXTERN int asn1PD_H245VCCapability_aal5 (OOCTXT* pctxt, H245VCCapability_aal5* pvalue)
1255 {
1256    int stat = ASN_OK;
1257    OOCTXT lctxt;
1258    ASN1OpenType openType;
1259    ASN1UINT bitcnt;
1260    ASN1UINT i;
1261    ASN1BOOL optbit = 0;
1262    ASN1BOOL extbit = 0;
1263
1264    /* extension bit */
1265
1266    DECODEBIT (pctxt, &extbit);
1267
1268    /* decode forwardMaximumSDUSize */
1269
1270    invokeStartElement (pctxt, "forwardMaximumSDUSize", -1);
1271
1272    stat = decodeConsUInt16 (pctxt, &pvalue->forwardMaximumSDUSize, 0U, 65535U);
1273    if (stat != ASN_OK) return stat;
1274    invokeUIntValue (pctxt, pvalue->forwardMaximumSDUSize);
1275
1276    invokeEndElement (pctxt, "forwardMaximumSDUSize", -1);
1277
1278    /* decode backwardMaximumSDUSize */
1279
1280    invokeStartElement (pctxt, "backwardMaximumSDUSize", -1);
1281
1282    stat = decodeConsUInt16 (pctxt, &pvalue->backwardMaximumSDUSize, 0U, 65535U);
1283    if (stat != ASN_OK) return stat;
1284    invokeUIntValue (pctxt, pvalue->backwardMaximumSDUSize);
1285
1286    invokeEndElement (pctxt, "backwardMaximumSDUSize", -1);
1287
1288    if (extbit) {
1289
1290       /* decode extension optional bits length */
1291
1292       stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
1293       if (stat != ASN_OK) return stat;
1294
1295       bitcnt += 1;
1296
1297       ZEROCONTEXT (&lctxt);
1298       stat = setPERBufferUsingCtxt (&lctxt, pctxt);
1299       if (stat != ASN_OK) return stat;
1300
1301       stat = moveBitCursor (pctxt, bitcnt);
1302       if (stat != ASN_OK) return stat;
1303
1304       for (i = 0; i < bitcnt; i++) {
1305          DECODEBIT (&lctxt, &optbit);
1306
1307          if (optbit) {
1308             stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
1309             if (stat != ASN_OK) return stat;
1310
1311             pctxt->buffer.byteIndex += openType.numocts;
1312          }
1313       }
1314    }
1315
1316    return (stat);
1317 }
1318
1319 /**************************************************************/
1320 /*                                                            */
1321 /*  VCCapability_availableBitRates_type_rangeOfBitRates       */
1322 /*                                                            */
1323 /**************************************************************/
1324
1325 EXTERN int asn1PD_H245VCCapability_availableBitRates_type_rangeOfBitRates (OOCTXT* pctxt, H245VCCapability_availableBitRates_type_rangeOfBitRates* pvalue)
1326 {
1327    int stat = ASN_OK;
1328
1329    /* decode lowerBitRate */
1330
1331    invokeStartElement (pctxt, "lowerBitRate", -1);
1332
1333    stat = decodeConsUInt16 (pctxt, &pvalue->lowerBitRate, 1U, 65535U);
1334    if (stat != ASN_OK) return stat;
1335    invokeUIntValue (pctxt, pvalue->lowerBitRate);
1336
1337    invokeEndElement (pctxt, "lowerBitRate", -1);
1338
1339    /* decode higherBitRate */
1340
1341    invokeStartElement (pctxt, "higherBitRate", -1);
1342
1343    stat = decodeConsUInt16 (pctxt, &pvalue->higherBitRate, 1U, 65535U);
1344    if (stat != ASN_OK) return stat;
1345    invokeUIntValue (pctxt, pvalue->higherBitRate);
1346
1347    invokeEndElement (pctxt, "higherBitRate", -1);
1348
1349    return (stat);
1350 }
1351
1352 /**************************************************************/
1353 /*                                                            */
1354 /*  VCCapability_availableBitRates_type                       */
1355 /*                                                            */
1356 /**************************************************************/
1357
1358 EXTERN int asn1PD_H245VCCapability_availableBitRates_type (OOCTXT* pctxt, H245VCCapability_availableBitRates_type* pvalue)
1359 {
1360    int stat = ASN_OK;
1361    ASN1UINT ui;
1362
1363    stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
1364    if (stat != ASN_OK) return stat;
1365    else pvalue->t = ui + 1;
1366
1367    switch (ui) {
1368       /* singleBitRate */
1369       case 0:
1370          invokeStartElement (pctxt, "singleBitRate", -1);
1371
1372          stat = decodeConsUInt16 (pctxt, &pvalue->u.singleBitRate, 1U, 65535U);
1373          if (stat != ASN_OK) return stat;
1374          invokeUIntValue (pctxt, pvalue->u.singleBitRate);
1375
1376          invokeEndElement (pctxt, "singleBitRate", -1);
1377
1378          break;
1379
1380       /* rangeOfBitRates */
1381       case 1:
1382          invokeStartElement (pctxt, "rangeOfBitRates", -1);
1383
1384          pvalue->u.rangeOfBitRates = ALLOC_ASN1ELEM (pctxt, H245VCCapability_availableBitRates_type_rangeOfBitRates);
1385
1386          stat = asn1PD_H245VCCapability_availableBitRates_type_rangeOfBitRates (pctxt, pvalue->u.rangeOfBitRates);
1387          if (stat != ASN_OK) return stat;
1388
1389          invokeEndElement (pctxt, "rangeOfBitRates", -1);
1390
1391          break;
1392
1393       default:
1394          return ASN_E_INVOPT;
1395    }
1396
1397    return (stat);
1398 }
1399
1400 /**************************************************************/
1401 /*                                                            */
1402 /*  VCCapability_availableBitRates                            */
1403 /*                                                            */
1404 /**************************************************************/
1405
1406 EXTERN int asn1PD_H245VCCapability_availableBitRates (OOCTXT* pctxt, H245VCCapability_availableBitRates* pvalue)
1407 {
1408    int stat = ASN_OK;
1409    OOCTXT lctxt;
1410    ASN1OpenType openType;
1411    ASN1UINT bitcnt;
1412    ASN1UINT i;
1413    ASN1BOOL optbit = 0;
1414    ASN1BOOL extbit = 0;
1415
1416    /* extension bit */
1417
1418    DECODEBIT (pctxt, &extbit);
1419
1420    /* decode type */
1421
1422    invokeStartElement (pctxt, "type", -1);
1423
1424    stat = asn1PD_H245VCCapability_availableBitRates_type (pctxt, &pvalue->type);
1425    if (stat != ASN_OK) return stat;
1426
1427    invokeEndElement (pctxt, "type", -1);
1428
1429    if (extbit) {
1430
1431       /* decode extension optional bits length */
1432
1433       stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
1434       if (stat != ASN_OK) return stat;
1435
1436       bitcnt += 1;
1437
1438       ZEROCONTEXT (&lctxt);
1439       stat = setPERBufferUsingCtxt (&lctxt, pctxt);
1440       if (stat != ASN_OK) return stat;
1441
1442       stat = moveBitCursor (pctxt, bitcnt);
1443       if (stat != ASN_OK) return stat;
1444
1445       for (i = 0; i < bitcnt; i++) {
1446          DECODEBIT (&lctxt, &optbit);
1447
1448          if (optbit) {
1449             stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
1450             if (stat != ASN_OK) return stat;
1451
1452             pctxt->buffer.byteIndex += openType.numocts;
1453          }
1454       }
1455    }
1456
1457    return (stat);
1458 }
1459
1460 /**************************************************************/
1461 /*                                                            */
1462 /*  Q2931Address_address_nsapAddress                          */
1463 /*                                                            */
1464 /**************************************************************/
1465
1466 EXTERN int asn1PD_H245Q2931Address_address_nsapAddress (OOCTXT* pctxt, H245Q2931Address_address_nsapAddress* pvalue)
1467 {
1468    static Asn1SizeCnst lsize1 = { 0, 1, 20, 0 };
1469    int stat = ASN_OK;
1470
1471    addSizeConstraint (pctxt, &lsize1);
1472
1473    stat = decodeOctetString (pctxt,
1474                           &pvalue->numocts,
1475                           pvalue->data,
1476                           sizeof(pvalue->data));
1477    if (stat != ASN_OK) return stat;
1478    invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
1479
1480    return (stat);
1481 }
1482
1483 /**************************************************************/
1484 /*                                                            */
1485 /*  Q2931Address_address                                      */
1486 /*                                                            */
1487 /**************************************************************/
1488
1489 EXTERN int asn1PD_H245Q2931Address_address (OOCTXT* pctxt, H245Q2931Address_address* pvalue)
1490 {
1491    static Asn1SizeCnst internationalNumber_lsize1 = { 0, 1, 16, 0 };
1492    int stat = ASN_OK;
1493    ASN1UINT ui;
1494    ASN1OpenType openType;
1495    ASN1BOOL extbit = 0;
1496
1497    /* extension bit */
1498
1499    DECODEBIT (pctxt, &extbit);
1500
1501    if (!extbit) {
1502       stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
1503       if (stat != ASN_OK) return stat;
1504       else pvalue->t = ui + 1;
1505
1506       switch (ui) {
1507          /* internationalNumber */
1508          case 0:
1509             invokeStartElement (pctxt, "internationalNumber", -1);
1510
1511             addSizeConstraint (pctxt, &internationalNumber_lsize1);
1512
1513             stat = decodeConstrainedStringEx (pctxt, &pvalue->u.internationalNumber, NUM_CANSET, 4, 4, 4);
1514             if (stat != ASN_OK) return stat;
1515             invokeCharStrValue (pctxt, pvalue->u.internationalNumber);
1516
1517             invokeEndElement (pctxt, "internationalNumber", -1);
1518
1519             break;
1520
1521          /* nsapAddress */
1522          case 1:
1523             invokeStartElement (pctxt, "nsapAddress", -1);
1524
1525             pvalue->u.nsapAddress = ALLOC_ASN1ELEM (pctxt, H245Q2931Address_address_nsapAddress);
1526
1527             stat = asn1PD_H245Q2931Address_address_nsapAddress (pctxt, pvalue->u.nsapAddress);
1528             if (stat != ASN_OK) return stat;
1529
1530             invokeEndElement (pctxt, "nsapAddress", -1);
1531
1532             break;
1533
1534          default:
1535             return ASN_E_INVOPT;
1536       }
1537    }
1538    else {
1539       stat = decodeSmallNonNegWholeNumber (pctxt, &ui);
1540       if (stat != ASN_OK) return stat;
1541       else pvalue->t = ui + 3;
1542
1543       stat = decodeByteAlign (pctxt);
1544       if (stat != ASN_OK) return stat;
1545
1546       stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
1547       if (stat != ASN_OK) return stat;
1548
1549    }
1550
1551    return (stat);
1552 }
1553
1554 /**************************************************************/
1555 /*                                                            */
1556 /*  Q2931Address_subaddress                                   */
1557 /*                                                            */
1558 /**************************************************************/
1559
1560 EXTERN int asn1PD_H245Q2931Address_subaddress (OOCTXT* pctxt, H245Q2931Address_subaddress* pvalue)
1561 {
1562    static Asn1SizeCnst lsize1 = { 0, 1, 20, 0 };
1563    int stat = ASN_OK;
1564
1565    addSizeConstraint (pctxt, &lsize1);
1566
1567    stat = decodeOctetString (pctxt,
1568                           &pvalue->numocts,
1569                           pvalue->data,
1570                           sizeof(pvalue->data));
1571    if (stat != ASN_OK) return stat;
1572    invokeOctStrValue (pctxt, pvalue->numocts, pvalue->data);
1573
1574    return (stat);
1575 }
1576
1577 /**************************************************************/
1578 /*                                                            */
1579 /*  Q2931Address                                              */
1580 /*                                                            */
1581 /**************************************************************/
1582
1583 EXTERN int asn1PD_H245Q2931Address (OOCTXT* pctxt, H245Q2931Address* pvalue)
1584 {
1585    int stat = ASN_OK;
1586    OOCTXT lctxt;
1587    ASN1OpenType openType;
1588    ASN1UINT bitcnt;
1589    ASN1UINT i;
1590    ASN1BOOL optbit = 0;
1591    ASN1BOOL extbit = 0;
1592
1593    /* extension bit */
1594
1595    DECODEBIT (pctxt, &extbit);
1596
1597    /* optional bits */
1598
1599    memset (&pvalue->m, 0, sizeof(pvalue->m));
1600
1601    DECODEBIT (pctxt, &optbit);
1602    pvalue->m.subaddressPresent = optbit;
1603
1604    /* decode address */
1605
1606    invokeStartElement (pctxt, "address", -1);
1607
1608    stat = asn1PD_H245Q2931Address_address (pctxt, &pvalue->address);
1609    if (stat != ASN_OK) return stat;
1610
1611    invokeEndElement (pctxt, "address", -1);
1612
1613    /* decode subaddress */
1614
1615    if (pvalue->m.subaddressPresent) {
1616       invokeStartElement (pctxt, "subaddress", -1);
1617
1618       stat = asn1PD_H245Q2931Address_subaddress (pctxt, &pvalue->subaddress);
1619       if (stat != ASN_OK) return stat;
1620
1621       invokeEndElement (pctxt, "subaddress", -1);
1622    }
1623
1624    if (extbit) {
1625
1626       /* decode extension optional bits length */
1627
1628       stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
1629       if (stat != ASN_OK) return stat;
1630
1631       bitcnt += 1;
1632
1633       ZEROCONTEXT (&lctxt);
1634       stat = setPERBufferUsingCtxt (&lctxt, pctxt);
1635       if (stat != ASN_OK) return stat;
1636
1637       stat = moveBitCursor (pctxt, bitcnt);
1638       if (stat != ASN_OK) return stat;
1639
1640       for (i = 0; i < bitcnt; i++) {
1641          DECODEBIT (&lctxt, &optbit);
1642
1643          if (optbit) {
1644             stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
1645             if (stat != ASN_OK) return stat;
1646
1647             pctxt->buffer.byteIndex += openType.numocts;
1648          }
1649       }
1650    }
1651
1652    return (stat);
1653 }
1654
1655 /**************************************************************/
1656 /*                                                            */
1657 /*  VCCapability_aal1ViaGateway_gatewayAddress                */
1658 /*                                                            */
1659 /**************************************************************/
1660
1661 EXTERN int asn1PD_H245VCCapability_aal1ViaGateway_gatewayAddress (OOCTXT* pctxt, H245VCCapability_aal1ViaGateway_gatewayAddress* pvalue)
1662 {
1663    static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 };
1664    int stat = ASN_OK;
1665    H245Q2931Address* pdata;
1666    ASN1UINT count = 0;
1667    ASN1UINT xx1;
1668
1669    /* decode length determinant */
1670
1671    addSizeConstraint (pctxt, &lsize1);
1672
1673    stat = decodeLength (pctxt, &count);
1674    if (stat != ASN_OK) return stat;
1675
1676    /* decode elements */
1677
1678    dListInit (pvalue);
1679
1680    for (xx1 = 0; xx1 < count; xx1++) {
1681       invokeStartElement (pctxt, "elem", xx1);
1682
1683       pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245Q2931Address);
1684
1685       stat = asn1PD_H245Q2931Address (pctxt, pdata);
1686       if (stat != ASN_OK) return stat;
1687       invokeEndElement (pctxt, "elem", xx1);
1688
1689       dListAppendNode (pctxt, pvalue, pdata);
1690    }
1691
1692    return (stat);
1693 }
1694
1695 /**************************************************************/
1696 /*                                                            */
1697 /*  VCCapability_aal1ViaGateway                               */
1698 /*                                                            */
1699 /**************************************************************/
1700
1701 EXTERN int asn1PD_H245VCCapability_aal1ViaGateway (OOCTXT* pctxt, H245VCCapability_aal1ViaGateway* pvalue)
1702 {
1703    int stat = ASN_OK;
1704    OOCTXT lctxt;
1705    ASN1OpenType openType;
1706    ASN1UINT bitcnt;
1707    ASN1UINT i;
1708    ASN1BOOL optbit = 0;
1709    ASN1BOOL extbit = 0;
1710
1711    /* extension bit */
1712
1713    DECODEBIT (pctxt, &extbit);
1714
1715    /* decode gatewayAddress */
1716
1717    invokeStartElement (pctxt, "gatewayAddress", -1);
1718
1719    stat = asn1PD_H245VCCapability_aal1ViaGateway_gatewayAddress (pctxt, &pvalue->gatewayAddress);
1720    if (stat != ASN_OK) return stat;
1721
1722    invokeEndElement (pctxt, "gatewayAddress", -1);
1723
1724    /* decode nullClockRecovery */
1725
1726    invokeStartElement (pctxt, "nullClockRecovery", -1);
1727
1728    stat = DECODEBIT (pctxt, &pvalue->nullClockRecovery);
1729    if (stat != ASN_OK) return stat;
1730    invokeBoolValue (pctxt, pvalue->nullClockRecovery);
1731
1732    invokeEndElement (pctxt, "nullClockRecovery", -1);
1733
1734    /* decode srtsClockRecovery */
1735
1736    invokeStartElement (pctxt, "srtsClockRecovery", -1);
1737
1738    stat = DECODEBIT (pctxt, &pvalue->srtsClockRecovery);
1739    if (stat != ASN_OK) return stat;
1740    invokeBoolValue (pctxt, pvalue->srtsClockRecovery);
1741
1742    invokeEndElement (pctxt, "srtsClockRecovery", -1);
1743
1744    /* decode adaptiveClockRecovery */
1745
1746    invokeStartElement (pctxt, "adaptiveClockRecovery", -1);
1747
1748    stat = DECODEBIT (pctxt, &pvalue->adaptiveClockRecovery);
1749    if (stat != ASN_OK) return stat;
1750    invokeBoolValue (pctxt, pvalue->adaptiveClockRecovery);
1751
1752    invokeEndElement (pctxt, "adaptiveClockRecovery", -1);
1753
1754    /* decode nullErrorCorrection */
1755
1756    invokeStartElement (pctxt, "nullErrorCorrection", -1);
1757
1758    stat = DECODEBIT (pctxt, &pvalue->nullErrorCorrection);
1759    if (stat != ASN_OK) return stat;
1760    invokeBoolValue (pctxt, pvalue->nullErrorCorrection);
1761
1762    invokeEndElement (pctxt, "nullErrorCorrection", -1);
1763
1764    /* decode longInterleaver */
1765
1766    invokeStartElement (pctxt, "longInterleaver", -1);
1767
1768    stat = DECODEBIT (pctxt, &pvalue->longInterleaver);
1769    if (stat != ASN_OK) return stat;
1770    invokeBoolValue (pctxt, pvalue->longInterleaver);
1771
1772    invokeEndElement (pctxt, "longInterleaver", -1);
1773
1774    /* decode shortInterleaver */
1775
1776    invokeStartElement (pctxt, "shortInterleaver", -1);
1777
1778    stat = DECODEBIT (pctxt, &pvalue->shortInterleaver);
1779    if (stat != ASN_OK) return stat;
1780    invokeBoolValue (pctxt, pvalue->shortInterleaver);
1781
1782    invokeEndElement (pctxt, "shortInterleaver", -1);
1783
1784    /* decode errorCorrectionOnly */
1785
1786    invokeStartElement (pctxt, "errorCorrectionOnly", -1);
1787
1788    stat = DECODEBIT (pctxt, &pvalue->errorCorrectionOnly);
1789    if (stat != ASN_OK) return stat;
1790    invokeBoolValue (pctxt, pvalue->errorCorrectionOnly);
1791
1792    invokeEndElement (pctxt, "errorCorrectionOnly", -1);
1793
1794    /* decode structuredDataTransfer */
1795
1796    invokeStartElement (pctxt, "structuredDataTransfer", -1);
1797
1798    stat = DECODEBIT (pctxt, &pvalue->structuredDataTransfer);
1799    if (stat != ASN_OK) return stat;
1800    invokeBoolValue (pctxt, pvalue->structuredDataTransfer);
1801
1802    invokeEndElement (pctxt, "structuredDataTransfer", -1);
1803
1804    /* decode partiallyFilledCells */
1805
1806    invokeStartElement (pctxt, "partiallyFilledCells", -1);
1807
1808    stat = DECODEBIT (pctxt, &pvalue->partiallyFilledCells);
1809    if (stat != ASN_OK) return stat;
1810    invokeBoolValue (pctxt, pvalue->partiallyFilledCells);
1811
1812    invokeEndElement (pctxt, "partiallyFilledCells", -1);
1813
1814    if (extbit) {
1815
1816       /* decode extension optional bits length */
1817
1818       stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
1819       if (stat != ASN_OK) return stat;
1820
1821       bitcnt += 1;
1822
1823       ZEROCONTEXT (&lctxt);
1824       stat = setPERBufferUsingCtxt (&lctxt, pctxt);
1825       if (stat != ASN_OK) return stat;
1826
1827       stat = moveBitCursor (pctxt, bitcnt);
1828       if (stat != ASN_OK) return stat;
1829
1830       for (i = 0; i < bitcnt; i++) {
1831          DECODEBIT (&lctxt, &optbit);
1832
1833          if (optbit) {
1834             stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
1835             if (stat != ASN_OK) return stat;
1836
1837             pctxt->buffer.byteIndex += openType.numocts;
1838          }
1839       }
1840    }
1841
1842    return (stat);
1843 }
1844
1845 /**************************************************************/
1846 /*                                                            */
1847 /*  VCCapability                                              */
1848 /*                                                            */
1849 /**************************************************************/
1850
1851 EXTERN int asn1PD_H245VCCapability (OOCTXT* pctxt, H245VCCapability* pvalue)
1852 {
1853    int stat = ASN_OK;
1854    OOCTXT lctxt;
1855    OOCTXT lctxt2;
1856    ASN1OpenType openType;
1857    ASN1UINT bitcnt;
1858    ASN1UINT i;
1859    ASN1BOOL optbit = 0;
1860    ASN1BOOL extbit = 0;
1861
1862    /* extension bit */
1863
1864    DECODEBIT (pctxt, &extbit);
1865
1866    /* optional bits */
1867
1868    memset (&pvalue->m, 0, sizeof(pvalue->m));
1869
1870    DECODEBIT (pctxt, &optbit);
1871    pvalue->m.aal1Present = optbit;
1872
1873    DECODEBIT (pctxt, &optbit);
1874    pvalue->m.aal5Present = optbit;
1875
1876    /* decode aal1 */
1877
1878    if (pvalue->m.aal1Present) {
1879       invokeStartElement (pctxt, "aal1", -1);
1880
1881       stat = asn1PD_H245VCCapability_aal1 (pctxt, &pvalue->aal1);
1882       if (stat != ASN_OK) return stat;
1883
1884       invokeEndElement (pctxt, "aal1", -1);
1885    }
1886
1887    /* decode aal5 */
1888
1889    if (pvalue->m.aal5Present) {
1890       invokeStartElement (pctxt, "aal5", -1);
1891
1892       stat = asn1PD_H245VCCapability_aal5 (pctxt, &pvalue->aal5);
1893       if (stat != ASN_OK) return stat;
1894
1895       invokeEndElement (pctxt, "aal5", -1);
1896    }
1897
1898    /* decode transportStream */
1899
1900    invokeStartElement (pctxt, "transportStream", -1);
1901
1902    stat = DECODEBIT (pctxt, &pvalue->transportStream);
1903    if (stat != ASN_OK) return stat;
1904    invokeBoolValue (pctxt, pvalue->transportStream);
1905
1906    invokeEndElement (pctxt, "transportStream", -1);
1907
1908    /* decode programStream */
1909
1910    invokeStartElement (pctxt, "programStream", -1);
1911
1912    stat = DECODEBIT (pctxt, &pvalue->programStream);
1913    if (stat != ASN_OK) return stat;
1914    invokeBoolValue (pctxt, pvalue->programStream);
1915
1916    invokeEndElement (pctxt, "programStream", -1);
1917
1918    /* decode availableBitRates */
1919
1920    invokeStartElement (pctxt, "availableBitRates", -1);
1921
1922    stat = asn1PD_H245VCCapability_availableBitRates (pctxt, &pvalue->availableBitRates);
1923    if (stat != ASN_OK) return stat;
1924
1925    invokeEndElement (pctxt, "availableBitRates", -1);
1926
1927    if (extbit) {
1928
1929       /* decode extension optional bits length */
1930
1931       stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
1932       if (stat != ASN_OK) return stat;
1933
1934       bitcnt += 1;
1935
1936       ZEROCONTEXT (&lctxt);
1937       stat = setPERBufferUsingCtxt (&lctxt, pctxt);
1938       if (stat != ASN_OK) return stat;
1939
1940       stat = moveBitCursor (pctxt, bitcnt);
1941       if (stat != ASN_OK) return stat;
1942
1943       for (i = 0; i < bitcnt; i++) {
1944          DECODEBIT (&lctxt, &optbit);
1945
1946          if (optbit) {
1947             stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
1948             if (stat != ASN_OK) return stat;
1949
1950             if (i < 1 && openType.numocts > 0) {  /* known element */
1951                copyContext (&lctxt2, pctxt);
1952                initContextBuffer (pctxt, openType.data, openType.numocts);
1953
1954                switch (i) {
1955                   case 0:
1956                      pvalue->m.aal1ViaGatewayPresent = 1;
1957
1958                      invokeStartElement (pctxt, "aal1ViaGateway", -1);
1959
1960                      stat = asn1PD_H245VCCapability_aal1ViaGateway (pctxt, &pvalue->aal1ViaGateway);
1961                      if (stat != ASN_OK) return stat;
1962
1963                      invokeEndElement (pctxt, "aal1ViaGateway", -1);
1964                      break;
1965
1966                   default:
1967                      pctxt->buffer.byteIndex += openType.numocts;
1968                }
1969                copyContext (pctxt, &lctxt2);
1970             }
1971             else {  /* unknown element */
1972                pctxt->buffer.byteIndex += openType.numocts;
1973             }
1974          }
1975       }
1976    }
1977
1978    return (stat);
1979 }
1980
1981 /**************************************************************/
1982 /*                                                            */
1983 /*  _SetOfH245VCCapability                                    */
1984 /*                                                            */
1985 /**************************************************************/
1986
1987 EXTERN int asn1PD_H245_SetOfH245VCCapability (OOCTXT* pctxt, H245_SetOfH245VCCapability* pvalue)
1988 {
1989    int stat = ASN_OK;
1990    H245VCCapability* pdata;
1991    ASN1UINT count = 0;
1992    ASN1UINT xx1;
1993    int lstat;
1994
1995    dListInit (pvalue);
1996
1997    for (;;) {
1998       /* decode length determinant */
1999
2000       lstat = decodeLength (pctxt, &count);
2001       if (lstat != ASN_OK && lstat != ASN_OK_FRAG) {
2002          return lstat;
2003       }
2004
2005       /* decode elements */
2006
2007       for (xx1 = 0; xx1 < count; xx1++) {
2008          invokeStartElement (pctxt, "elem", xx1);
2009
2010          pdata = ALLOC_ASN1ELEMDNODE (pctxt, H245VCCapability);
2011
2012          stat = asn1PD_H245VCCapability (pctxt, pdata);
2013          if (stat != ASN_OK) return stat;
2014          invokeEndElement (pctxt, "elem", xx1);
2015
2016          dListAppendNode (pctxt, pvalue, pdata);
2017       }
2018
2019       if(lstat == ASN_OK) break;
2020    }
2021
2022    return (stat);
2023 }
2024
2025 /**************************************************************/
2026 /*                                                            */
2027 /*  H222Capability                                            */
2028 /*                                                            */
2029 /**************************************************************/
2030
2031 EXTERN int asn1PD_H245H222Capability (OOCTXT* pctxt, H245H222Capability* pvalue)
2032 {
2033    int stat = ASN_OK;
2034    OOCTXT lctxt;
2035    ASN1OpenType openType;
2036    ASN1UINT bitcnt;
2037    ASN1UINT i;
2038    ASN1BOOL optbit = 0;
2039    ASN1BOOL extbit = 0;
2040
2041    /* extension bit */
2042
2043    DECODEBIT (pctxt, &extbit);
2044
2045    /* decode numberOfVCs */
2046
2047    invokeStartElement (pctxt, "numberOfVCs", -1);
2048
2049    stat = decodeConsUInt16 (pctxt, &pvalue->numberOfVCs, 1U, 256U);
2050    if (stat != ASN_OK) return stat;
2051    invokeUIntValue (pctxt, pvalue->numberOfVCs);
2052
2053    invokeEndElement (pctxt, "numberOfVCs", -1);
2054
2055    /* decode vcCapability */
2056
2057    invokeStartElement (pctxt, "vcCapability", -1);
2058
2059    stat = asn1PD_H245_SetOfH245VCCapability (pctxt, &pvalue->vcCapability);
2060    if (stat != ASN_OK) return stat;
2061
2062    invokeEndElement (pctxt, "vcCapability", -1);
2063
2064    if (extbit) {
2065
2066       /* decode extension optional bits length */
2067
2068       stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
2069       if (stat != ASN_OK) return stat;
2070
2071       bitcnt += 1;
2072
2073       ZEROCONTEXT (&lctxt);
2074       stat = setPERBufferUsingCtxt (&lctxt, pctxt);
2075       if (stat != ASN_OK) return stat;
2076
2077       stat = moveBitCursor (pctxt, bitcnt);
2078       if (stat != ASN_OK) return stat;
2079
2080       for (i = 0; i < bitcnt; i++) {
2081          DECODEBIT (&lctxt, &optbit);
2082
2083          if (optbit) {
2084             stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
2085             if (stat != ASN_OK) return stat;
2086
2087             pctxt->buffer.byteIndex += openType.numocts;
2088          }
2089       }
2090    }
2091
2092    return (stat);
2093 }
2094
2095 /**************************************************************/
2096 /*                                                            */
2097 /*  H223Capability_h223MultiplexTableCapability_enhanced      */
2098 /*                                                            */
2099 /**************************************************************/
2100
2101 EXTERN int asn1PD_H245H223Capability_h223MultiplexTableCapability_enhanced (OOCTXT* pctxt, H245H223Capability_h223MultiplexTableCapability_enhanced* pvalue)
2102 {
2103    int stat = ASN_OK;
2104    OOCTXT lctxt;
2105    ASN1OpenType openType;
2106    ASN1UINT bitcnt;
2107    ASN1UINT i;
2108    ASN1BOOL optbit = 0;
2109    ASN1BOOL extbit = 0;
2110
2111    /* extension bit */
2112
2113    DECODEBIT (pctxt, &extbit);
2114
2115    /* decode maximumNestingDepth */
2116
2117    invokeStartElement (pctxt, "maximumNestingDepth", -1);
2118
2119    stat = decodeConsUInt8 (pctxt, &pvalue->maximumNestingDepth, 1U, 15U);
2120    if (stat != ASN_OK) return stat;
2121    invokeUIntValue (pctxt, pvalue->maximumNestingDepth);
2122
2123    invokeEndElement (pctxt, "maximumNestingDepth", -1);
2124
2125    /* decode maximumElementListSize */
2126
2127    invokeStartElement (pctxt, "maximumElementListSize", -1);
2128
2129    stat = decodeConsUInt8 (pctxt, &pvalue->maximumElementListSize, 2U, 255U);
2130    if (stat != ASN_OK) return stat;
2131    invokeUIntValue (pctxt, pvalue->maximumElementListSize);
2132
2133    invokeEndElement (pctxt, "maximumElementListSize", -1);
2134
2135    /* decode maximumSubElementListSize */
2136
2137    invokeStartElement (pctxt, "maximumSubElementListSize", -1);
2138
2139    stat = decodeConsUInt8 (pctxt, &pvalue->maximumSubElementListSize, 2U, 255U);
2140    if (stat != ASN_OK) return stat;
2141    invokeUIntValue (pctxt, pvalue->maximumSubElementListSize);
2142
2143    invokeEndElement (pctxt, "maximumSubElementListSize", -1);
2144
2145    if (extbit) {
2146
2147       /* decode extension optional bits length */
2148
2149       stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
2150       if (stat != ASN_OK) return stat;
2151
2152       bitcnt += 1;
2153
2154       ZEROCONTEXT (&lctxt);
2155       stat = setPERBufferUsingCtxt (&lctxt, pctxt);
2156       if (stat != ASN_OK) return stat;
2157
2158       stat = moveBitCursor (pctxt, bitcnt);
2159       if (stat != ASN_OK) return stat;
2160
2161       for (i = 0; i < bitcnt; i++) {
2162          DECODEBIT (&lctxt, &optbit);
2163
2164          if (optbit) {
2165             stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
2166             if (stat != ASN_OK) return stat;
2167
2168             pctxt->buffer.byteIndex += openType.numocts;
2169          }
2170       }
2171    }
2172
2173    return (stat);
2174 }
2175
2176 /**************************************************************/
2177 /*                                                            */
2178 /*  H223Capability_h223MultiplexTableCapability               */
2179 /*                                                            */
2180 /**************************************************************/
2181
2182 EXTERN int asn1PD_H245H223Capability_h223MultiplexTableCapability (OOCTXT* pctxt, H245H223Capability_h223MultiplexTableCapability* pvalue)
2183 {
2184    int stat = ASN_OK;
2185    ASN1UINT ui;
2186
2187    stat = decodeConsUnsigned (pctxt, &ui, 0, 1);
2188    if (stat != ASN_OK) return stat;
2189    else pvalue->t = ui + 1;
2190
2191    switch (ui) {
2192       /* basic */
2193       case 0:
2194          invokeStartElement (pctxt, "basic", -1);
2195
2196          /* NULL */
2197          invokeNullValue (pctxt);
2198
2199          invokeEndElement (pctxt, "basic", -1);
2200
2201          break;
2202
2203       /* enhanced */
2204       case 1:
2205          invokeStartElement (pctxt, "enhanced", -1);
2206
2207          pvalue->u.enhanced = ALLOC_ASN1ELEM (pctxt, H245H223Capability_h223MultiplexTableCapability_enhanced);
2208
2209          stat = asn1PD_H245H223Capability_h223MultiplexTableCapability_enhanced (pctxt, pvalue->u.enhanced);
2210          if (stat != ASN_OK) return stat;
2211
2212          invokeEndElement (pctxt, "enhanced", -1);
2213
2214          break;
2215
2216       default:
2217          return ASN_E_INVOPT;
2218    }
2219
2220    return (stat);
2221 }
2222
2223 /**************************************************************/
2224 /*                                                            */
2225 /*  H223Capability_mobileOperationTransmitCapability          */
2226 /*                                                            */
2227 /**************************************************************/
2228
2229 EXTERN int asn1PD_H245H223Capability_mobileOperationTransmitCapability (OOCTXT* pctxt, H245H223Capability_mobileOperationTransmitCapability* pvalue)
2230 {
2231    int stat = ASN_OK;
2232    OOCTXT lctxt;
2233    ASN1OpenType openType;
2234    ASN1UINT bitcnt;
2235    ASN1UINT i;
2236    ASN1BOOL optbit = 0;
2237    ASN1BOOL extbit = 0;
2238
2239    /* extension bit */
2240
2241    DECODEBIT (pctxt, &extbit);
2242
2243    /* decode modeChangeCapability */
2244
2245    invokeStartElement (pctxt, "modeChangeCapability", -1);
2246
2247    stat = DECODEBIT (pctxt, &pvalue->modeChangeCapability);
2248    if (stat != ASN_OK) return stat;
2249    invokeBoolValue (pctxt, pvalue->modeChangeCapability);
2250
2251    invokeEndElement (pctxt, "modeChangeCapability", -1);
2252
2253    /* decode h223AnnexA */
2254
2255    invokeStartElement (pctxt, "h223AnnexA", -1);
2256
2257    stat = DECODEBIT (pctxt, &pvalue->h223AnnexA);
2258    if (stat != ASN_OK) return stat;
2259    invokeBoolValue (pctxt, pvalue->h223AnnexA);
2260
2261    invokeEndElement (pctxt, "h223AnnexA", -1);
2262
2263    /* decode h223AnnexADoubleFlag */
2264
2265    invokeStartElement (pctxt, "h223AnnexADoubleFlag", -1);
2266
2267    stat = DECODEBIT (pctxt, &pvalue->h223AnnexADoubleFlag);
2268    if (stat != ASN_OK) return stat;
2269    invokeBoolValue (pctxt, pvalue->h223AnnexADoubleFlag);
2270
2271    invokeEndElement (pctxt, "h223AnnexADoubleFlag", -1);
2272
2273    /* decode h223AnnexB */
2274
2275    invokeStartElement (pctxt, "h223AnnexB", -1);
2276
2277    stat = DECODEBIT (pctxt, &pvalue->h223AnnexB);
2278    if (stat != ASN_OK) return stat;
2279    invokeBoolValue (pctxt, pvalue->h223AnnexB);
2280
2281    invokeEndElement (pctxt, "h223AnnexB", -1);
2282
2283    /* decode h223AnnexBwithHeader */
2284
2285    invokeStartElement (pctxt, "h223AnnexBwithHeader", -1);
2286
2287    stat = DECODEBIT (pctxt, &pvalue->h223AnnexBwithHeader);
2288    if (stat != ASN_OK) return stat;
2289    invokeBoolValue (pctxt, pvalue->h223AnnexBwithHeader);
2290
2291    invokeEndElement (pctxt, "h223AnnexBwithHeader", -1);
2292
2293    if (extbit) {
2294
2295       /* decode extension optional bits length */
2296
2297       stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
2298       if (stat != ASN_OK) return stat;
2299
2300       bitcnt += 1;
2301
2302       ZEROCONTEXT (&lctxt);
2303       stat = setPERBufferUsingCtxt (&lctxt, pctxt);
2304       if (stat != ASN_OK) return stat;
2305
2306       stat = moveBitCursor (pctxt, bitcnt);
2307       if (stat != ASN_OK) return stat;
2308
2309       for (i = 0; i < bitcnt; i++) {
2310          DECODEBIT (&lctxt, &optbit);
2311
2312          if (optbit) {
2313             stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
2314             if (stat != ASN_OK) return stat;
2315
2316             pctxt->buffer.byteIndex += openType.numocts;
2317          }
2318       }
2319    }
2320
2321    return (stat);
2322 }
2323
2324 /**************************************************************/
2325 /*                                                            */
2326 /*  H223AnnexCCapability                                      */
2327 /*                                                            */
2328 /**************************************************************/
2329
2330 EXTERN int asn1PD_H245H223AnnexCCapability (OOCTXT* pctxt, H245H223AnnexCCapability* pvalue)
2331 {
2332    int stat = ASN_OK;
2333    OOCTXT lctxt;
2334    OOCTXT lctxt2;
2335    ASN1OpenType openType;
2336    ASN1UINT bitcnt;
2337    ASN1UINT i;
2338    ASN1BOOL optbit = 0;
2339    ASN1BOOL extbit = 0;
2340
2341    /* extension bit */
2342
2343    DECODEBIT (pctxt, &extbit);
2344
2345    /* optional bits */
2346
2347    memset (&pvalue->m, 0, sizeof(pvalue->m));
2348
2349    /* decode videoWithAL1M */
2350
2351    invokeStartElement (pctxt, "videoWithAL1M", -1);
2352
2353    stat = DECODEBIT (pctxt, &pvalue->videoWithAL1M);
2354    if (stat != ASN_OK) return stat;
2355    invokeBoolValue (pctxt, pvalue->videoWithAL1M);
2356
2357    invokeEndElement (pctxt, "videoWithAL1M", -1);
2358
2359    /* decode videoWithAL2M */
2360
2361    invokeStartElement (pctxt, "videoWithAL2M", -1);
2362
2363    stat = DECODEBIT (pctxt, &pvalue->videoWithAL2M);
2364    if (stat != ASN_OK) return stat;
2365    invokeBoolValue (pctxt, pvalue->videoWithAL2M);
2366
2367    invokeEndElement (pctxt, "videoWithAL2M", -1);
2368
2369    /* decode videoWithAL3M */
2370
2371    invokeStartElement (pctxt, "videoWithAL3M", -1);
2372
2373    stat = DECODEBIT (pctxt, &pvalue->videoWithAL3M);
2374    if (stat != ASN_OK) return stat;
2375    invokeBoolValue (pctxt, pvalue->videoWithAL3M);
2376
2377    invokeEndElement (pctxt, "videoWithAL3M", -1);
2378
2379    /* decode audioWithAL1M */
2380
2381    invokeStartElement (pctxt, "audioWithAL1M", -1);
2382
2383    stat = DECODEBIT (pctxt, &pvalue->audioWithAL1M);
2384    if (stat != ASN_OK) return stat;
2385    invokeBoolValue (pctxt, pvalue->audioWithAL1M);
2386
2387    invokeEndElement (pctxt, "audioWithAL1M", -1);
2388
2389    /* decode audioWithAL2M */
2390
2391    invokeStartElement (pctxt, "audioWithAL2M", -1);
2392
2393    stat = DECODEBIT (pctxt, &pvalue->audioWithAL2M);
2394    if (stat != ASN_OK) return stat;
2395    invokeBoolValue (pctxt, pvalue->audioWithAL2M);
2396
2397    invokeEndElement (pctxt, "audioWithAL2M", -1);
2398
2399    /* decode audioWithAL3M */
2400
2401    invokeStartElement (pctxt, "audioWithAL3M", -1);
2402
2403    stat = DECODEBIT (pctxt, &pvalue->audioWithAL3M);
2404    if (stat != ASN_OK) return stat;
2405    invokeBoolValue (pctxt, pvalue->audioWithAL3M);
2406
2407    invokeEndElement (pctxt, "audioWithAL3M", -1);
2408
2409    /* decode dataWithAL1M */
2410
2411    invokeStartElement (pctxt, "dataWithAL1M", -1);
2412
2413    stat = DECODEBIT (pctxt, &pvalue->dataWithAL1M);
2414    if (stat != ASN_OK) return stat;
2415    invokeBoolValue (pctxt, pvalue->dataWithAL1M);
2416
2417    invokeEndElement (pctxt, "dataWithAL1M", -1);
2418
2419    /* decode dataWithAL2M */
2420
2421    invokeStartElement (pctxt, "dataWithAL2M", -1);
2422
2423    stat = DECODEBIT (pctxt, &pvalue->dataWithAL2M);
2424    if (stat != ASN_OK) return stat;
2425    invokeBoolValue (pctxt, pvalue->dataWithAL2M);
2426
2427    invokeEndElement (pctxt, "dataWithAL2M", -1);
2428
2429    /* decode dataWithAL3M */
2430
2431    invokeStartElement (pctxt, "dataWithAL3M", -1);
2432
2433    stat = DECODEBIT (pctxt, &pvalue->dataWithAL3M);
2434    if (stat != ASN_OK) return stat;
2435    invokeBoolValue (pctxt, pvalue->dataWithAL3M);
2436
2437    invokeEndElement (pctxt, "dataWithAL3M", -1);
2438
2439    /* decode alpduInterleaving */
2440
2441    invokeStartElement (pctxt, "alpduInterleaving", -1);
2442
2443    stat = DECODEBIT (pctxt, &pvalue->alpduInterleaving);
2444    if (stat != ASN_OK) return stat;
2445    invokeBoolValue (pctxt, pvalue->alpduInterleaving);
2446
2447    invokeEndElement (pctxt, "alpduInterleaving", -1);
2448
2449    /* decode maximumAL1MPDUSize */
2450
2451    invokeStartElement (pctxt, "maximumAL1MPDUSize", -1);
2452
2453    stat = decodeConsUInt16 (pctxt, &pvalue->maximumAL1MPDUSize, 0U, 65535U);
2454    if (stat != ASN_OK) return stat;
2455    invokeUIntValue (pctxt, pvalue->maximumAL1MPDUSize);
2456
2457    invokeEndElement (pctxt, "maximumAL1MPDUSize", -1);
2458
2459    /* decode maximumAL2MSDUSize */
2460
2461    invokeStartElement (pctxt, "maximumAL2MSDUSize", -1);
2462
2463    stat = decodeConsUInt16 (pctxt, &pvalue->maximumAL2MSDUSize, 0U, 65535U);
2464    if (stat != ASN_OK) return stat;
2465    invokeUIntValue (pctxt, pvalue->maximumAL2MSDUSize);
2466
2467    invokeEndElement (pctxt, "maximumAL2MSDUSize", -1);
2468
2469    /* decode maximumAL3MSDUSize */
2470
2471    invokeStartElement (pctxt, "maximumAL3MSDUSize", -1);
2472
2473    stat = decodeConsUInt16 (pctxt, &pvalue->maximumAL3MSDUSize, 0U, 65535U);
2474    if (stat != ASN_OK) return stat;
2475    invokeUIntValue (pctxt, pvalue->maximumAL3MSDUSize);
2476
2477    invokeEndElement (pctxt, "maximumAL3MSDUSize", -1);
2478
2479    if (extbit) {
2480
2481       /* decode extension optional bits length */
2482
2483       stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
2484       if (stat != ASN_OK) return stat;
2485
2486       bitcnt += 1;
2487
2488       ZEROCONTEXT (&lctxt);
2489       stat = setPERBufferUsingCtxt (&lctxt, pctxt);
2490       if (stat != ASN_OK) return stat;
2491
2492       stat = moveBitCursor (pctxt, bitcnt);
2493       if (stat != ASN_OK) return stat;
2494
2495       for (i = 0; i < bitcnt; i++) {
2496          DECODEBIT (&lctxt, &optbit);
2497
2498          if (optbit) {
2499             stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
2500             if (stat != ASN_OK) return stat;
2501
2502             if (i < 1 && openType.numocts > 0) {  /* known element */
2503                copyContext (&lctxt2, pctxt);
2504                initContextBuffer (pctxt, openType.data, openType.numocts);
2505
2506                switch (i) {
2507                   case 0:
2508                      pvalue->m.rsCodeCapabilityPresent = 1;
2509
2510                      invokeStartElement (pctxt, "rsCodeCapability", -1);
2511
2512                      stat = DECODEBIT (pctxt, &pvalue->rsCodeCapability);
2513                      if (stat != ASN_OK) return stat;
2514                      invokeBoolValue (pctxt, pvalue->rsCodeCapability);
2515
2516                      invokeEndElement (pctxt, "rsCodeCapability", -1);
2517                      break;
2518
2519                   default:
2520                      pctxt->buffer.byteIndex += openType.numocts;
2521                }
2522                copyContext (pctxt, &lctxt2);
2523             }
2524             else {  /* unknown element */
2525                pctxt->buffer.byteIndex += openType.numocts;
2526             }
2527          }
2528       }
2529    }
2530
2531    return (stat);
2532 }
2533
2534 /**************************************************************/
2535 /*                                                            */
2536 /*  H223Capability_mobileMultilinkFrameCapability             */
2537 /*                                                            */
2538 /**************************************************************/
2539
2540 EXTERN int asn1PD_H245H223Capability_mobileMultilinkFrameCapability (OOCTXT* pctxt, H245H223Capability_mobileMultilinkFrameCapability* pvalue)
2541 {
2542    int stat = ASN_OK;
2543    OOCTXT lctxt;
2544    ASN1OpenType openType;
2545    ASN1UINT bitcnt;
2546    ASN1UINT i;
2547    ASN1BOOL optbit = 0;
2548    ASN1BOOL extbit = 0;
2549
2550    /* extension bit */
2551
2552    DECODEBIT (pctxt, &extbit);
2553
2554    /* decode maximumSampleSize */
2555
2556    invokeStartElement (pctxt, "maximumSampleSize", -1);
2557
2558    stat = decodeConsUInt8 (pctxt, &pvalue->maximumSampleSize, 1U, 255U);
2559    if (stat != ASN_OK) return stat;
2560    invokeUIntValue (pctxt, pvalue->maximumSampleSize);
2561
2562    invokeEndElement (pctxt, "maximumSampleSize", -1);
2563
2564    /* decode maximumPayloadLength */
2565
2566    invokeStartElement (pctxt, "maximumPayloadLength", -1);
2567
2568    stat = decodeConsUInt16 (pctxt, &pvalue->maximumPayloadLength, 1U, 65025U);
2569    if (stat != ASN_OK) return stat;
2570    invokeUIntValue (pctxt, pvalue->maximumPayloadLength);
2571
2572    invokeEndElement (pctxt, "maximumPayloadLength", -1);
2573
2574    if (extbit) {
2575
2576       /* decode extension optional bits length */
2577
2578       stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
2579       if (stat != ASN_OK) return stat;
2580
2581       bitcnt += 1;
2582
2583       ZEROCONTEXT (&lctxt);
2584       stat = setPERBufferUsingCtxt (&lctxt, pctxt);
2585       if (stat != ASN_OK) return stat;
2586
2587       stat = moveBitCursor (pctxt, bitcnt);
2588       if (stat != ASN_OK) return stat;
2589
2590       for (i = 0; i < bitcnt; i++) {
2591          DECODEBIT (&lctxt, &optbit);
2592
2593          if (optbit) {
2594             stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
2595             if (stat != ASN_OK) return stat;
2596
2597             pctxt->buffer.byteIndex += openType.numocts;
2598          }
2599       }
2600    }
2601
2602    return (stat);
2603 }
2604
2605 /**************************************************************/
2606 /*                                                            */
2607 /*  H223Capability                                            */
2608 /*                                                            */
2609 /**************************************************************/
2610
2611 EXTERN int asn1PD_H245H223Capability (OOCTXT* pctxt, H245H223Capability* pvalue)
2612 {
2613    int stat = ASN_OK;
2614    OOCTXT lctxt;
2615    OOCTXT lctxt2;
2616    ASN1OpenType openType;
2617    ASN1UINT bitcnt;
2618    ASN1UINT i;
2619    ASN1BOOL optbit = 0;
2620    ASN1BOOL extbit = 0;
2621
2622    /* extension bit */
2623
2624    DECODEBIT (pctxt, &extbit);
2625
2626    /* optional bits */
2627
2628    memset (&pvalue->m, 0, sizeof(pvalue->m));
2629
2630    /* decode transportWithI_frames */
2631
2632    invokeStartElement (pctxt, "transportWithI_frames", -1);
2633
2634    stat = DECODEBIT (pctxt, &pvalue->transportWithI_frames);
2635    if (stat != ASN_OK) return stat;
2636    invokeBoolValue (pctxt, pvalue->transportWithI_frames);
2637
2638    invokeEndElement (pctxt, "transportWithI_frames", -1);
2639
2640    /* decode videoWithAL1 */
2641
2642    invokeStartElement (pctxt, "videoWithAL1", -1);
2643
2644    stat = DECODEBIT (pctxt, &pvalue->videoWithAL1);
2645    if (stat != ASN_OK) return stat;
2646    invokeBoolValue (pctxt, pvalue->videoWithAL1);
2647
2648    invokeEndElement (pctxt, "videoWithAL1", -1);
2649
2650    /* decode videoWithAL2 */
2651
2652    invokeStartElement (pctxt, "videoWithAL2", -1);
2653
2654    stat = DECODEBIT (pctxt, &pvalue->videoWithAL2);
2655    if (stat != ASN_OK) return stat;
2656    invokeBoolValue (pctxt, pvalue->videoWithAL2);
2657
2658    invokeEndElement (pctxt, "videoWithAL2", -1);
2659
2660    /* decode videoWithAL3 */
2661
2662    invokeStartElement (pctxt, "videoWithAL3", -1);
2663
2664    stat = DECODEBIT (pctxt, &pvalue->videoWithAL3);
2665    if (stat != ASN_OK) return stat;
2666    invokeBoolValue (pctxt, pvalue->videoWithAL3);
2667
2668    invokeEndElement (pctxt, "videoWithAL3", -1);
2669
2670    /* decode audioWithAL1 */
2671
2672    invokeStartElement (pctxt, "audioWithAL1", -1);
2673
2674    stat = DECODEBIT (pctxt, &pvalue->audioWithAL1);
2675    if (stat != ASN_OK) return stat;
2676    invokeBoolValue (pctxt, pvalue->audioWithAL1);
2677
2678    invokeEndElement (pctxt, "audioWithAL1", -1);
2679
2680    /* decode audioWithAL2 */
2681
2682    invokeStartElement (pctxt, "audioWithAL2", -1);
2683
2684    stat = DECODEBIT (pctxt, &pvalue->audioWithAL2);
2685    if (stat != ASN_OK) return stat;
2686    invokeBoolValue (pctxt, pvalue->audioWithAL2);
2687
2688    invokeEndElement (pctxt, "audioWithAL2", -1);
2689
2690    /* decode audioWithAL3 */
2691
2692    invokeStartElement (pctxt, "audioWithAL3", -1);
2693
2694    stat = DECODEBIT (pctxt, &pvalue->audioWithAL3);
2695    if (stat != ASN_OK) return stat;
2696    invokeBoolValue (pctxt, pvalue->audioWithAL3);
2697
2698    invokeEndElement (pctxt, "audioWithAL3", -1);
2699
2700    /* decode dataWithAL1 */
2701
2702    invokeStartElement (pctxt, "dataWithAL1", -1);
2703
2704    stat = DECODEBIT (pctxt, &pvalue->dataWithAL1);
2705    if (stat != ASN_OK) return stat;
2706    invokeBoolValue (pctxt, pvalue->dataWithAL1);
2707
2708    invokeEndElement (pctxt, "dataWithAL1", -1);
2709
2710    /* decode dataWithAL2 */
2711
2712    invokeStartElement (pctxt, "dataWithAL2", -1);
2713
2714    stat = DECODEBIT (pctxt, &pvalue->dataWithAL2);
2715    if (stat != ASN_OK) return stat;
2716    invokeBoolValue (pctxt, pvalue->dataWithAL2);
2717
2718    invokeEndElement (pctxt, "dataWithAL2", -1);
2719
2720    /* decode dataWithAL3 */
2721
2722    invokeStartElement (pctxt, "dataWithAL3", -1);
2723
2724    stat = DECODEBIT (pctxt, &pvalue->dataWithAL3);
2725    if (stat != ASN_OK) return stat;
2726    invokeBoolValue (pctxt, pvalue->dataWithAL3);
2727
2728    invokeEndElement (pctxt, "dataWithAL3", -1);
2729
2730    /* decode maximumAl2SDUSize */
2731
2732    invokeStartElement (pctxt, "maximumAl2SDUSize", -1);
2733
2734    stat = decodeConsUInt16 (pctxt, &pvalue->maximumAl2SDUSize, 0U, 65535U);
2735    if (stat != ASN_OK) return stat;
2736    invokeUIntValue (pctxt, pvalue->maximumAl2SDUSize);
2737
2738    invokeEndElement (pctxt, "maximumAl2SDUSize", -1);
2739
2740    /* decode maximumAl3SDUSize */
2741
2742    invokeStartElement (pctxt, "maximumAl3SDUSize", -1);
2743
2744    stat = decodeConsUInt16 (pctxt, &pvalue->maximumAl3SDUSize, 0U, 65535U);
2745    if (stat != ASN_OK) return stat;
2746    invokeUIntValue (pctxt, pvalue->maximumAl3SDUSize);
2747
2748    invokeEndElement (pctxt, "maximumAl3SDUSize", -1);
2749
2750    /* decode maximumDelayJitter */
2751
2752    invokeStartElement (pctxt, "maximumDelayJitter", -1);
2753
2754    stat = decodeConsUInt16 (pctxt, &pvalue->maximumDelayJitter, 0U, 1023U);
2755    if (stat != ASN_OK) return stat;
2756    invokeUIntValue (pctxt, pvalue->maximumDelayJitter);
2757
2758    invokeEndElement (pctxt, "maximumDelayJitter", -1);
2759
2760    /* decode h223MultiplexTableCapability */
2761
2762    invokeStartElement (pctxt, "h223MultiplexTableCapability", -1);
2763
2764    stat = asn1PD_H245H223Capability_h223MultiplexTableCapability (pctxt, &pvalue->h223MultiplexTableCapability);
2765    if (stat != ASN_OK) return stat;
2766
2767    invokeEndElement (pctxt, "h223MultiplexTableCapability", -1);
2768
2769    if (extbit) {
2770
2771       /* decode extension optional bits length */
2772
2773       stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
2774       if (stat != ASN_OK) return stat;
2775
2776       bitcnt += 1;
2777
2778       ZEROCONTEXT (&lctxt);
2779       stat = setPERBufferUsingCtxt (&lctxt, pctxt);
2780       if (stat != ASN_OK) return stat;
2781
2782       stat = moveBitCursor (pctxt, bitcnt);
2783       if (stat != ASN_OK) return stat;
2784
2785       for (i = 0; i < bitcnt; i++) {
2786          DECODEBIT (&lctxt, &optbit);
2787
2788          if (optbit) {
2789             stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
2790             if (stat != ASN_OK) return stat;
2791
2792             if (i < 6 && openType.numocts > 0) {  /* known element */
2793                copyContext (&lctxt2, pctxt);
2794                initContextBuffer (pctxt, openType.data, openType.numocts);
2795
2796                switch (i) {
2797                   case 0:
2798                      pvalue->m.maxMUXPDUSizeCapabilityPresent = 1;
2799
2800                      invokeStartElement (pctxt, "maxMUXPDUSizeCapability", -1);
2801
2802                      stat = DECODEBIT (pctxt, &pvalue->maxMUXPDUSizeCapability);
2803                      if (stat != ASN_OK) return stat;
2804                      invokeBoolValue (pctxt, pvalue->maxMUXPDUSizeCapability);
2805
2806                      invokeEndElement (pctxt, "maxMUXPDUSizeCapability", -1);
2807                      break;
2808
2809                   case 1:
2810                      pvalue->m.nsrpSupportPresent = 1;
2811
2812                      invokeStartElement (pctxt, "nsrpSupport", -1);
2813
2814                      stat = DECODEBIT (pctxt, &pvalue->nsrpSupport);
2815                      if (stat != ASN_OK) return stat;
2816                      invokeBoolValue (pctxt, pvalue->nsrpSupport);
2817
2818                      invokeEndElement (pctxt, "nsrpSupport", -1);
2819                      break;
2820
2821                   case 2:
2822                      pvalue->m.mobileOperationTransmitCapabilityPresent = 1;
2823
2824                      invokeStartElement (pctxt, "mobileOperationTransmitCapability", -1);
2825
2826                      stat = asn1PD_H245H223Capability_mobileOperationTransmitCapability (pctxt, &pvalue->mobileOperationTransmitCapability);
2827                      if (stat != ASN_OK) return stat;
2828
2829                      invokeEndElement (pctxt, "mobileOperationTransmitCapability", -1);
2830                      break;
2831
2832                   case 3:
2833                      pvalue->m.h223AnnexCCapabilityPresent = 1;
2834
2835                      invokeStartElement (pctxt, "h223AnnexCCapability", -1);
2836
2837                      stat = asn1PD_H245H223AnnexCCapability (pctxt, &pvalue->h223AnnexCCapability);
2838                      if (stat != ASN_OK) return stat;
2839
2840                      invokeEndElement (pctxt, "h223AnnexCCapability", -1);
2841                      break;
2842
2843                   case 4:
2844                      pvalue->m.bitRatePresent = 1;
2845
2846                      invokeStartElement (pctxt, "bitRate", -1);
2847
2848                      stat = decodeConsUInt16 (pctxt, &pvalue->bitRate, 1U, 19200U);
2849                      if (stat != ASN_OK) return stat;
2850                      invokeUIntValue (pctxt, pvalue->bitRate);
2851
2852                      invokeEndElement (pctxt, "bitRate", -1);
2853                      break;
2854
2855                   case 5:
2856                      pvalue->m.mobileMultilinkFrameCapabilityPresent = 1;
2857
2858                      invokeStartElement (pctxt, "mobileMultilinkFrameCapability", -1);
2859
2860                      stat = asn1PD_H245H223Capability_mobileMultilinkFrameCapability (pctxt, &pvalue->mobileMultilinkFrameCapability);
2861                      if (stat != ASN_OK) return stat;
2862
2863                      invokeEndElement (pctxt, "mobileMultilinkFrameCapability", -1);
2864                      break;
2865
2866                   default:
2867                      pctxt->buffer.byteIndex += openType.numocts;
2868                }
2869                copyContext (pctxt, &lctxt2);
2870             }
2871             else {  /* unknown element */
2872                pctxt->buffer.byteIndex += openType.numocts;
2873             }
2874          }
2875       }
2876    }
2877
2878    return (stat);
2879 }
2880
2881 /**************************************************************/
2882 /*                                                            */
2883 /*  V75Capability                                             */
2884 /*                                                            */
2885 /**************************************************************/
2886
2887 EXTERN int asn1PD_H245V75Capability (OOCTXT* pctxt, H245V75Capability* pvalue)
2888 {
2889    int stat = ASN_OK;
2890    OOCTXT lctxt;
2891    ASN1OpenType openType;
2892    ASN1UINT bitcnt;
2893    ASN1UINT i;
2894    ASN1BOOL optbit = 0;
2895    ASN1BOOL extbit = 0;
2896
2897    /* extension bit */
2898
2899    DECODEBIT (pctxt, &extbit);
2900
2901    /* decode audioHeader */
2902
2903    invokeStartElement (pctxt, "audioHeader", -1);
2904
2905    stat = DECODEBIT (pctxt, &pvalue->audioHeader);
2906    if (stat != ASN_OK) return stat;
2907    invokeBoolValue (pctxt, pvalue->audioHeader);
2908
2909    invokeEndElement (pctxt, "audioHeader", -1);
2910
2911    if (extbit) {
2912
2913       /* decode extension optional bits length */
2914
2915       stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
2916       if (stat != ASN_OK) return stat;
2917
2918       bitcnt += 1;
2919
2920       ZEROCONTEXT (&lctxt);
2921       stat = setPERBufferUsingCtxt (&lctxt, pctxt);
2922       if (stat != ASN_OK) return stat;
2923
2924       stat = moveBitCursor (pctxt, bitcnt);
2925       if (stat != ASN_OK) return stat;
2926
2927       for (i = 0; i < bitcnt; i++) {
2928          DECODEBIT (&lctxt, &optbit);
2929
2930          if (optbit) {
2931             stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
2932             if (stat != ASN_OK) return stat;
2933
2934             pctxt->buffer.byteIndex += openType.numocts;
2935          }
2936       }
2937    }
2938
2939    return (stat);
2940 }
2941
2942 /**************************************************************/
2943 /*                                                            */
2944 /*  V76Capability                                             */
2945 /*                                                            */
2946 /**************************************************************/
2947
2948 EXTERN int asn1PD_H245V76Capability (OOCTXT* pctxt, H245V76Capability* pvalue)
2949 {
2950    int stat = ASN_OK;
2951    OOCTXT lctxt;
2952    ASN1OpenType openType;
2953    ASN1UINT bitcnt;
2954    ASN1UINT i;
2955    ASN1BOOL optbit = 0;
2956    ASN1BOOL extbit = 0;
2957
2958    /* extension bit */
2959
2960    DECODEBIT (pctxt, &extbit);
2961
2962    /* decode suspendResumeCapabilitywAddress */
2963
2964    invokeStartElement (pctxt, "suspendResumeCapabilitywAddress", -1);
2965
2966    stat = DECODEBIT (pctxt, &pvalue->suspendResumeCapabilitywAddress);
2967    if (stat != ASN_OK) return stat;
2968    invokeBoolValue (pctxt, pvalue->suspendResumeCapabilitywAddress);
2969
2970    invokeEndElement (pctxt, "suspendResumeCapabilitywAddress", -1);
2971
2972    /* decode suspendResumeCapabilitywoAddress */
2973
2974    invokeStartElement (pctxt, "suspendResumeCapabilitywoAddress", -1);
2975
2976    stat = DECODEBIT (pctxt, &pvalue->suspendResumeCapabilitywoAddress);
2977    if (stat != ASN_OK) return stat;
2978    invokeBoolValue (pctxt, pvalue->suspendResumeCapabilitywoAddress);
2979
2980    invokeEndElement (pctxt, "suspendResumeCapabilitywoAddress", -1);
2981
2982    /* decode rejCapability */
2983
2984    invokeStartElement (pctxt, "rejCapability", -1);
2985
2986    stat = DECODEBIT (pctxt, &pvalue->rejCapability);
2987    if (stat != ASN_OK) return stat;
2988    invokeBoolValue (pctxt, pvalue->rejCapability);
2989
2990    invokeEndElement (pctxt, "rejCapability", -1);
2991
2992    /* decode sREJCapability */
2993
2994    invokeStartElement (pctxt, "sREJCapability", -1);
2995
2996    stat = DECODEBIT (pctxt, &pvalue->sREJCapability);
2997    if (stat != ASN_OK) return stat;
2998    invokeBoolValue (pctxt, pvalue->sREJCapability);
2999
3000    invokeEndElement (pctxt, "sREJCapability", -1);
3001
3002    /* decode mREJCapability */
3003
3004    invokeStartElement (pctxt, "mREJCapability", -1);
3005
3006    stat = DECODEBIT (pctxt, &pvalue->mREJCapability);
3007    if (stat != ASN_OK) return stat;
3008    invokeBoolValue (pctxt, pvalue->mREJCapability);
3009
3010    invokeEndElement (pctxt, "mREJCapability", -1);
3011
3012    /* decode crc8bitCapability */
3013
3014    invokeStartElement (pctxt, "crc8bitCapability", -1);
3015
3016    stat = DECODEBIT (pctxt, &pvalue->crc8bitCapability);
3017    if (stat != ASN_OK) return stat;
3018    invokeBoolValue (pctxt, pvalue->crc8bitCapability);
3019
3020    invokeEndElement (pctxt, "crc8bitCapability", -1);
3021
3022    /* decode crc16bitCapability */
3023
3024    invokeStartElement (pctxt, "crc16bitCapability", -1);
3025
3026    stat = DECODEBIT (pctxt, &pvalue->crc16bitCapability);
3027    if (stat != ASN_OK) return stat;
3028    invokeBoolValue (pctxt, pvalue->crc16bitCapability);
3029
3030    invokeEndElement (pctxt, "crc16bitCapability", -1);
3031
3032    /* decode crc32bitCapability */
3033
3034    invokeStartElement (pctxt, "crc32bitCapability", -1);
3035
3036    stat = DECODEBIT (pctxt, &pvalue->crc32bitCapability);
3037    if (stat != ASN_OK) return stat;
3038    invokeBoolValue (pctxt, pvalue->crc32bitCapability);
3039
3040    invokeEndElement (pctxt, "crc32bitCapability", -1);
3041
3042    /* decode uihCapability */
3043
3044    invokeStartElement (pctxt, "uihCapability", -1);
3045
3046    stat = DECODEBIT (pctxt, &pvalue->uihCapability);
3047    if (stat != ASN_OK) return stat;
3048    invokeBoolValue (pctxt, pvalue->uihCapability);
3049
3050    invokeEndElement (pctxt, "uihCapability", -1);
3051
3052    /* decode numOfDLCS */
3053
3054    invokeStartElement (pctxt, "numOfDLCS", -1);
3055
3056    stat = decodeConsUInt16 (pctxt, &pvalue->numOfDLCS, 2U, 8191U);
3057    if (stat != ASN_OK) return stat;
3058    invokeUIntValue (pctxt, pvalue->numOfDLCS);
3059
3060    invokeEndElement (pctxt, "numOfDLCS", -1);
3061
3062    /* decode twoOctetAddressFieldCapability */
3063
3064    invokeStartElement (pctxt, "twoOctetAddressFieldCapability", -1);
3065
3066    stat = DECODEBIT (pctxt, &pvalue->twoOctetAddressFieldCapability);
3067    if (stat != ASN_OK) return stat;
3068    invokeBoolValue (pctxt, pvalue->twoOctetAddressFieldCapability);
3069
3070    invokeEndElement (pctxt, "twoOctetAddressFieldCapability", -1);
3071
3072    /* decode loopBackTestCapability */
3073
3074    invokeStartElement (pctxt, "loopBackTestCapability", -1);
3075
3076    stat = DECODEBIT (pctxt, &pvalue->loopBackTestCapability);
3077    if (stat != ASN_OK) return stat;
3078    invokeBoolValue (pctxt, pvalue->loopBackTestCapability);
3079
3080    invokeEndElement (pctxt, "loopBackTestCapability", -1);
3081
3082    /* decode n401Capability */
3083
3084    invokeStartElement (pctxt, "n401Capability", -1);
3085
3086    stat = decodeConsUInt16 (pctxt, &pvalue->n401Capability, 1U, 4095U);
3087    if (stat != ASN_OK) return stat;
3088    invokeUIntValue (pctxt, pvalue->n401Capability);
3089
3090    invokeEndElement (pctxt, "n401Capability", -1);
3091
3092    /* decode maxWindowSizeCapability */
3093
3094    invokeStartElement (pctxt, "maxWindowSizeCapability", -1);
3095
3096    stat = decodeConsUInt8 (pctxt, &pvalue->maxWindowSizeCapability, 1U, 127U);
3097    if (stat != ASN_OK) return stat;
3098    invokeUIntValue (pctxt, pvalue->maxWindowSizeCapability);
3099
3100    invokeEndElement (pctxt, "maxWindowSizeCapability", -1);
3101
3102    /* decode v75Capability */
3103
3104    invokeStartElement (pctxt, "v75Capability", -1);
3105
3106    stat = asn1PD_H245V75Capability (pctxt, &pvalue->v75Capability);
3107    if (stat != ASN_OK) return stat;
3108
3109    invokeEndElement (pctxt, "v75Capability", -1);
3110
3111    if (extbit) {
3112
3113       /* decode extension optional bits length */
3114
3115       stat = decodeSmallNonNegWholeNumber (pctxt, &bitcnt);
3116       if (stat != ASN_OK) return stat;
3117
3118       bitcnt += 1;
3119
3120       ZEROCONTEXT (&lctxt);
3121       stat = setPERBufferUsingCtxt (&lctxt, pctxt);
3122       if (stat != ASN_OK) return stat;
3123
3124       stat = moveBitCursor (pctxt, bitcnt);
3125       if (stat != ASN_OK) return stat;
3126
3127       for (i = 0; i < bitcnt; i++) {
3128          DECODEBIT (&lctxt, &optbit);
3129
3130          if (optbit) {
3131             stat = decodeOpenType (pctxt, &openType.data, &openType.numocts);
3132             if (stat != ASN_OK) return stat;
3133
3134             pctxt->buffer.byteIndex += openType.numocts;
3135          }
3136       }
3137    }
3138
3139    return (stat);
3140 }
3141
3142 /**************************************************************/
3143 /*                                                            */
3144 /*  T84Profile_t84Restricted                                  */
3145 /*                                                            */
3146 /**************************************************************/
3147
3148 EXTERN int asn1PD_H245T84Profile_t84Restricted (OOCTXT* pctxt, H245T84Profile_t84Restricted* pvalue)
3149 {
3150    int stat = ASN_OK;
3151    OOCTXT lctxt;
3152    ASN1OpenType openType;
3153    ASN1UINT bitcnt;
3154    ASN1UINT i;
3155    ASN1BOOL optbit = 0;
3156    ASN1BOOL extbit = 0;
3157
3158    /* extension bit */
3159
3160    DECODEBIT (pctxt, &extbit);
3161
3162    /* decode qcif */
3163
3164    invokeStartElement (pctxt, "qcif", -1);
3165
3166    stat = DECODEBIT (pctxt, &pvalue->qcif);
3167    if (stat != ASN_OK) return stat;
3168    invokeBoolValue (pctxt, pvalue->qcif);
3169
3170    invokeEndElement (pctxt, "qcif", -1);
3171
3172    /* decode cif */
3173
3174    invokeStartElement (pctxt, "cif", -1);
3175
3176    stat = DECODEBIT (pctxt, &pvalue->cif);
3177    if (stat != ASN_OK) return stat;
3178    invokeBoolValue (pctxt, pvalue->cif);
3179
3180    invokeEndElement (pctxt, "cif", -1);
3181
3182    /* decode ccir601Seq */
3183
3184    invokeStartElement (pctxt, "ccir601Seq", -1);
3185
3186    stat = DECODEBIT (pctxt, &pvalue->ccir601Seq);
3187    if (stat != ASN_OK) return stat;
3188    invokeBoolValue (pctxt, pvalue->ccir601Seq);
3189
3190    invokeEndElement (pctxt, "ccir601Seq", -1);
3191
3192    /* decode ccir601Prog */
3193
3194    invokeStartElement (pctxt, "ccir601Prog", -1);
3195
3196    stat = DECODEBIT (pctxt, &pvalue->ccir601Prog);
3197    if (stat != ASN_OK) return stat;
3198    invokeBoolValue (pctxt, pvalue->ccir601Prog);
3199
3200    invokeEndElement (pctxt, "ccir601Prog", -1);
3201
3202    /* decode hdtvSeq */
3203
3204    invokeStartElement (pctxt, "hdtvSeq", -1);
3205
3206    stat = DECODEBIT (pctxt, &pvalue->hdtvSeq);
3207    if (stat != ASN_OK) return stat;
3208    invokeBoolValue (pctxt, pvalue->hdtvSeq);
3209
3210    invokeEndElement (pctxt, "hdtvSeq", -1);
3211
3212    /* decode hdtvProg */
3213
3214    invokeStartElement (pctxt, "hdtvProg", -1);
3215
3216    stat = DECODEBIT (pctxt, &pvalue->hdtvProg);
3217    if (stat != ASN_OK) return stat;
3218    invokeBoolValue (pctxt, pvalue->hdtvProg);
3219
3220    invokeEndElement (pctxt, "hdtvProg", -1);
3221
3222    /* decode g3FacsMH200x100 */