multimedia-system-controlenc.c

一个非常美妙的proxy。功能强大。基于sip的协议。如果还要的话

   /* extension bit */

   extbit = 0;

   encodeBit (pctxt, extbit);

   /* encode maximumNestingDepth */

   stat = encodeConsUnsigned (pctxt, pvalue->maximumNestingDepth, 1U, 15U);
   if (stat != ASN_OK) return stat;

   /* encode maximumElementListSize */

   stat = encodeConsUnsigned (pctxt, pvalue->maximumElementListSize, 2U, 255U);
   if (stat != ASN_OK) return stat;

   /* encode maximumSubElementListSize */

   stat = encodeConsUnsigned (pctxt, pvalue->maximumSubElementListSize, 2U, 255U);
   if (stat != ASN_OK) return stat;

   return (stat);
}

/**************************************************************/
/*                                                            */
/*  H223Capability_h223MultiplexTableCapability               */
/*                                                            */
/**************************************************************/

EXTERN int asn1PE_H245H223Capability_h223MultiplexTableCapability (OOCTXT* pctxt, H245H223Capability_h223MultiplexTableCapability* pvalue)
{
   int stat = ASN_OK;

   /* Encode choice index value */

   stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1);
   if (stat != ASN_OK) return stat;

   /* Encode root element data value */

   switch (pvalue->t)
   {
      /* basic */
      case 1:
         /* NULL */
         break;

      /* enhanced */
      case 2:
         stat = asn1PE_H245H223Capability_h223MultiplexTableCapability_enhanced (pctxt, pvalue->u.enhanced);
         if (stat != ASN_OK) return stat;
         break;

      default:
         return ASN_E_INVOPT;
   }

   return (stat);
}

/**************************************************************/
/*                                                            */
/*  H223Capability_mobileOperationTransmitCapability          */
/*                                                            */
/**************************************************************/

EXTERN int asn1PE_H245H223Capability_mobileOperationTransmitCapability (OOCTXT* pctxt, H245H223Capability_mobileOperationTransmitCapability* pvalue)
{
   int stat = ASN_OK;
   ASN1BOOL extbit;

   /* extension bit */

   extbit = 0;

   encodeBit (pctxt, extbit);

   /* encode modeChangeCapability */

   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->modeChangeCapability);
   if (stat != ASN_OK) return stat;

   /* encode h223AnnexA */

   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->h223AnnexA);
   if (stat != ASN_OK) return stat;

   /* encode h223AnnexADoubleFlag */

   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->h223AnnexADoubleFlag);
   if (stat != ASN_OK) return stat;

   /* encode h223AnnexB */

   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->h223AnnexB);
   if (stat != ASN_OK) return stat;

   /* encode h223AnnexBwithHeader */

   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->h223AnnexBwithHeader);
   if (stat != ASN_OK) return stat;

   return (stat);
}

/**************************************************************/
/*                                                            */
/*  H223AnnexCCapability                                      */
/*                                                            */
/**************************************************************/

EXTERN int asn1PE_H245H223AnnexCCapability (OOCTXT* pctxt, H245H223AnnexCCapability* pvalue)
{
   int stat = ASN_OK;
   ASN1BOOL extbit;
   ASN1OpenType openType;
   OOCTXT lctxt;

   /* extension bit */

   extbit = (ASN1BOOL)(pvalue->m.rsCodeCapabilityPresent);

   encodeBit (pctxt, extbit);

   /* encode videoWithAL1M */

   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->videoWithAL1M);
   if (stat != ASN_OK) return stat;

   /* encode videoWithAL2M */

   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->videoWithAL2M);
   if (stat != ASN_OK) return stat;

   /* encode videoWithAL3M */

   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->videoWithAL3M);
   if (stat != ASN_OK) return stat;

   /* encode audioWithAL1M */

   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioWithAL1M);
   if (stat != ASN_OK) return stat;

   /* encode audioWithAL2M */

   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioWithAL2M);
   if (stat != ASN_OK) return stat;

   /* encode audioWithAL3M */

   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioWithAL3M);
   if (stat != ASN_OK) return stat;

   /* encode dataWithAL1M */

   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->dataWithAL1M);
   if (stat != ASN_OK) return stat;

   /* encode dataWithAL2M */

   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->dataWithAL2M);
   if (stat != ASN_OK) return stat;

   /* encode dataWithAL3M */

   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->dataWithAL3M);
   if (stat != ASN_OK) return stat;

   /* encode alpduInterleaving */

   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->alpduInterleaving);
   if (stat != ASN_OK) return stat;

   /* encode maximumAL1MPDUSize */

   stat = encodeConsUnsigned (pctxt, pvalue->maximumAL1MPDUSize, 0U, 65535U);
   if (stat != ASN_OK) return stat;

   /* encode maximumAL2MSDUSize */

   stat = encodeConsUnsigned (pctxt, pvalue->maximumAL2MSDUSize, 0U, 65535U);
   if (stat != ASN_OK) return stat;

   /* encode maximumAL3MSDUSize */

   stat = encodeConsUnsigned (pctxt, pvalue->maximumAL3MSDUSize, 0U, 65535U);
   if (stat != ASN_OK) return stat;

   if (extbit) {

      /* encode extension optional bits length */

      stat = encodeSmallNonNegWholeNumber (pctxt, 0);
      if (stat != ASN_OK) return stat;

      /* encode optional bits */

      encodeBit (pctxt, (ASN1BOOL)pvalue->m.rsCodeCapabilityPresent);
      /* encode extension elements */

      if (pvalue->m.rsCodeCapabilityPresent) {
         initContext (&lctxt);
         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
         if (stat != ASN_OK) return freeContext (&lctxt), stat;

         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->rsCodeCapability);
         if (stat != ASN_OK) return freeContext (&lctxt), stat;

         stat = encodeByteAlign (&lctxt);
         if (stat != ASN_OK) return freeContext (&lctxt), stat;

         openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);

         stat = encodeOpenType (pctxt, openType.numocts, openType.data);
         if (stat != ASN_OK) return freeContext (&lctxt), stat;

         freeContext (&lctxt);
      }

   }

   return (stat);
}

/**************************************************************/
/*                                                            */
/*  H223Capability_mobileMultilinkFrameCapability             */
/*                                                            */
/**************************************************************/

EXTERN int asn1PE_H245H223Capability_mobileMultilinkFrameCapability (OOCTXT* pctxt, H245H223Capability_mobileMultilinkFrameCapability* pvalue)
{
   int stat = ASN_OK;
   ASN1BOOL extbit;

   /* extension bit */

   extbit = 0;

   encodeBit (pctxt, extbit);

   /* encode maximumSampleSize */

   stat = encodeConsUnsigned (pctxt, pvalue->maximumSampleSize, 1U, 255U);
   if (stat != ASN_OK) return stat;

   /* encode maximumPayloadLength */

   stat = encodeConsUnsigned (pctxt, pvalue->maximumPayloadLength, 1U, 65025U);
   if (stat != ASN_OK) return stat;

   return (stat);
}

/**************************************************************/
/*                                                            */
/*  H223Capability                                            */
/*                                                            */
/**************************************************************/

EXTERN int asn1PE_H245H223Capability (OOCTXT* pctxt, H245H223Capability* pvalue)
{
   int stat = ASN_OK;
   ASN1BOOL extbit;
   ASN1OpenType openType;
   OOCTXT lctxt;

   /* extension bit */

   extbit = (ASN1BOOL)(pvalue->m.maxMUXPDUSizeCapabilityPresent ||
   pvalue->m.nsrpSupportPresent ||
   pvalue->m.mobileOperationTransmitCapabilityPresent ||
   pvalue->m.h223AnnexCCapabilityPresent ||
   pvalue->m.bitRatePresent ||
   pvalue->m.mobileMultilinkFrameCapabilityPresent);

   encodeBit (pctxt, extbit);

   /* encode transportWithI_frames */

   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->transportWithI_frames);
   if (stat != ASN_OK) return stat;

   /* encode videoWithAL1 */

   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->videoWithAL1);
   if (stat != ASN_OK) return stat;

   /* encode videoWithAL2 */

   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->videoWithAL2);
   if (stat != ASN_OK) return stat;

   /* encode videoWithAL3 */

   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->videoWithAL3);
   if (stat != ASN_OK) return stat;

   /* encode audioWithAL1 */

   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioWithAL1);
   if (stat != ASN_OK) return stat;

   /* encode audioWithAL2 */

   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioWithAL2);
   if (stat != ASN_OK) return stat;

   /* encode audioWithAL3 */

   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioWithAL3);
   if (stat != ASN_OK) return stat;

   /* encode dataWithAL1 */

   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->dataWithAL1);
   if (stat != ASN_OK) return stat;

   /* encode dataWithAL2 */

   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->dataWithAL2);
   if (stat != ASN_OK) return stat;

   /* encode dataWithAL3 */

   stat = encodeBit (pctxt, (ASN1BOOL)pvalue->dataWithAL3);
   if (stat != ASN_OK) return stat;

   /* encode maximumAl2SDUSize */

   stat = encodeConsUnsigned (pctxt, pvalue->maximumAl2SDUSize, 0U, 65535U);
   if (stat != ASN_OK) return stat;

   /* encode maximumAl3SDUSize */

   stat = encodeConsUnsigned (pctxt, pvalue->maximumAl3SDUSize, 0U, 65535U);
   if (stat != ASN_OK) return stat;

   /* encode maximumDelayJitter */

   stat = encodeConsUnsigned (pctxt, pvalue->maximumDelayJitter, 0U, 1023U);
   if (stat != ASN_OK) return stat;

   /* encode h223MultiplexTableCapability */

   stat = asn1PE_H245H223Capability_h223MultiplexTableCapability (pctxt, &pvalue->h223MultiplexTableCapability);
   if (stat != ASN_OK) return stat;

   if (extbit) {

      /* encode extension optional bits length */

      stat = encodeSmallNonNegWholeNumber (pctxt, 5);
      if (stat != ASN_OK) return stat;

      /* encode optional bits */

      encodeBit (pctxt, (ASN1BOOL)pvalue->m.maxMUXPDUSizeCapabilityPresent);
      encodeBit (pctxt, (ASN1BOOL)pvalue->m.nsrpSupportPresent);
      encodeBit (pctxt, (ASN1BOOL)pvalue->m.mobileOperationTransmitCapabilityPresent);
      encodeBit (pctxt, (ASN1BOOL)pvalue->m.h223AnnexCCapabilityPresent);
      encodeBit (pctxt, (ASN1BOOL)pvalue->m.bitRatePresent);
      encodeBit (pctxt, (ASN1BOOL)pvalue->m.mobileMultilinkFrameCapabilityPresent);
      /* encode extension elements */

      if (pvalue->m.maxMUXPDUSizeCapabilityPresent) {
         initContext (&lctxt);
         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
         if (stat != ASN_OK) return freeContext (&lctxt), stat;

         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->maxMUXPDUSizeCapability);
         if (stat != ASN_OK) return freeContext (&lctxt), stat;

         stat = encodeByteAlign (&lctxt);
         if (stat != ASN_OK) return freeContext (&lctxt), stat;

         openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);

         stat = encodeOpenType (pctxt, openType.numocts, openType.data);
         if (stat != ASN_OK) return freeContext (&lctxt), stat;

         freeContext (&lctxt);
      }

      if (pvalue->m.nsrpSupportPresent) {
         initContext (&lctxt);
         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
         if (stat != ASN_OK) return freeContext (&lctxt), stat;

         stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->nsrpSupport);
         if (stat != ASN_OK) return freeContext (&lctxt), stat;

         stat = encodeByteAlign (&lctxt);
         if (stat != ASN_OK) return freeContext (&lctxt), stat;

         openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);

         stat = encodeOpenType (pctxt, openType.numocts, openType.data);
         if (stat != ASN_OK) return freeContext (&lctxt), stat;

         freeContext (&lctxt);
      }

      if (pvalue->m.mobileOperationTransmitCapabilityPresent) {
         initContext (&lctxt);
         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
         if (stat != ASN_OK) return freeContext (&lctxt), stat;

         stat = asn1PE_H245H223Capability_mobileOperationTransmitCapability (&lctxt, &pvalue->mobileOperationTransmitCapability);
         if (stat != ASN_OK) return freeContext (&lctxt), stat;

         stat = encodeByteAlign (&lctxt);
         if (stat != ASN_OK) return freeContext (&lctxt), stat;

         openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);

         stat = encodeOpenType (pctxt, openType.numocts, openType.data);
         if (stat != ASN_OK) return freeContext (&lctxt), stat;

         freeContext (&lctxt);
      }

      if (pvalue->m.h223AnnexCCapabilityPresent) {
         initContext (&lctxt);
         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
         if (stat != ASN_OK) return freeContext (&lctxt), stat;

         stat = asn1PE_H245H223AnnexCCapability (&lctxt, &pvalue->h223AnnexCCapability);
         if (stat != ASN_OK) return freeContext (&lctxt), stat;

         stat = encodeByteAlign (&lctxt);
         if (stat != ASN_OK) return freeContext (&lctxt), stat;

         openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts);

         stat = encodeOpenType (pctxt, openType.numocts, openType.data);
         if (stat != ASN_OK) return freeContext (&lctxt), stat;

         freeContext (&lctxt);
      }

      if (pvalue->m.bitRatePresent) {
         initContext (&lctxt);
         stat = setPERBuffer (&lctxt, 0, 0, TRUE);
         if (stat != ASN_OK) return freeContext (&lctxt), stat;