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